def UpdatePatchDo(items): menu = gtk.GtkMenu() for item in items[0]: menu_item = gtk.GtkMenuItem(item) menu_item.connect("activate", Patch_Changed) menu_item.show() menu.append(menu_item) menu.set_active(items[1]) getWidget("whichpatch").set_menu(menu) getWidget("patch_name").set_text(items[0][items[1]]) menu = gtk.GtkMenu() for item in items[2]: menu_item = gtk.GtkMenuItem(item) menu_item.connect("activate", Port_Changed) menu_item.show() menu.append(menu_item) menu.set_active(0) getWidget("whichport").set_menu(menu) getWidget("port").set_text(items[3]) getWidget("channel").set_text(str(items[4])) getWidget("msb").set_text(str(items[5])) getWidget("lsb").set_text(str(items[6])) getWidget("preset").get_adjustment().set_value(items[7]) getWidget("pan_onoff").set_active(items[8]) panwidg = getWidget("pan") panwidg.set_sensitive(items[8]) panwidg.get_adjustment().set_value(items[9]) getWidget("vol_onoff").set_active(items[10]) volwidg = getWidget("vol") volwidg.set_sensitive(items[10]) volwidg.get_adjustment().set_value(items[11]) getWidget("vel").get_adjustment().set_value(items[12]) ccnams = range(8) ccvals = range(8) for lokke in range(8): ccnams[lokke] = getWidget("ccnam" + str(lokke)) ccvals[lokke] = getWidget("ccval" + str(lokke)) getWidget("cconoff" + str(lokke)).set_active(items[13][lokke]) ccnams[lokke].set_sensitive(items[13][lokke]) ccvals[lokke].set_sensitive(items[13][lokke]) ccnams[lokke].set_text( str(items[15][lokke]) + ". " + items[14][lokke]) ccvals[lokke].get_adjustment().set_value(items[16][lokke])
def makeoptmenu(name, opts, default=0, func=None): hbox = gtk.GtkHBox() label = gtk.GtkLabel(name) label.show() hbox.pack_start(label) menu = gtk.GtkMenu() def store(widget, data): self.values[name] = data if func: func(widget, data) for text, data in opts: menu_item = gtk.GtkMenuItem(text) menu_item.connect("activate", store, data) menu_item.show() menu.append(menu_item) option_menu = gtk.GtkOptionMenu() option_menu.set_menu(menu) option_menu.set_history(default) self.values[name] = opts[default][1] option_menu.show() hbox.pack_start(option_menu) hbox.show() return hbox
def __init__(self, ok_cb=None, cancel_cb=None, cb_data=None, classify_type=CLASSIFY_EQUAL_INTERVAL): gtk.GtkWindow.__init__(self) self.set_title('Classification') self.user_ok_cb = ok_cb self.user_cancel_cb = cancel_cb self.user_cb_data = cb_data self.classify_type = classify_type self.set_border_width(6) #main vertical box vbox = gtk.GtkVBox(spacing=6) type_box = gtk.GtkHBox(spacing=6) type_box.pack_start(gtk.GtkLabel('Type:'), expand=gtk.FALSE) opt_menu = gtk.GtkOptionMenu() type_menu = gtk.GtkMenu() #using classification_types dictionary from gvclassification for i in range(len(classification_types)): for type in classification_types.iteritems(): if type[1] == i: item = gtk.GtkMenuItem(type[0]) item.connect('activate', self.type_menu_cb, classification_types[type[0]]) type_menu.append(item) opt_menu.set_menu(type_menu) opt_menu.set_history(classify_type) opt_menu.resize_children() type_box.pack_start(opt_menu) vbox.pack_start(type_box, expand=gtk.FALSE) #Number of classes classes_box = gtk.GtkHBox(spacing=6) classes_box.pack_start(gtk.GtkLabel('Number of classes:')) adj = gtk.GtkAdjustment(5, 2, 80, 1, 5, 5, 0) self.spinner = gtk.GtkSpinButton(adj) self.spinner.set_snap_to_ticks(gtk.TRUE) self.spinner.set_digits(0) classes_box.pack_start(self.spinner) vbox.pack_start(classes_box, expand=gtk.FALSE) #add the ok and cancel buttons button_box = gtk.GtkHButtonBox() ok_button = gtk.GtkButton("OK") ok_button.connect('clicked', self.ok_cb, cb_data) cancel_button = gtk.GtkButton("Cancel") cancel_button.connect('clicked', self.cancel_cb, cb_data) button_box.pack_start(ok_button) button_box.pack_start(cancel_button) vbox.pack_start(button_box, expand=gtk.FALSE) vbox.show_all() self.add(vbox) ok_button.set_flags(gtk.CAN_DEFAULT) ok_button.grab_default()
def _createMenu(items, callback, data): menu = gtk.GtkMenu() if not items: items = [("(none)", None)] for label, id in items: menu_item = gtk.GtkMenuItem(label) menu_item.set_data("Gimp-ID", id) menu.add(menu_item) if callback: menu_item.connect("activate", _callbackWrapper, callback, data) menu_item.show() return menu
def get_menu(self, path): """ get the menu rooted at the given path """ if path == '': return self.__w if self.__menus.has_key(path): return self.__menus[path] wid = self.create(path) menu = gtk.GtkMenu() menu.set_accel_group(self.accelerator) wid.set_submenu(menu) self.__menus[path] = menu return menu
def _updateAccountMenu(self): # This seems to be necessary -- I don't understand gtk's handling of # GtkOptionMenus print 'updating account menu', self.accountMenuItems self.accountMenu = gtk.GtkMenu() for account in self.accountMenuItems: i = gtk.GtkMenuItem(account.accountName) i.connect('activate', self.on_AccountsListPopup_activate, account) self.accountMenu.append(i) if self.accountMenuItems: print "setting default account to", self.accountMenuItems[0] self.currentAccount = self.accountMenuItems[0] self.accountMenu.show_all() self.optionMenu.set_menu(self.accountMenu)
def __init__(self, type=MENU_FACTORY_MENU_BAR): """ Initialize the menu factory """ self.accelerator = gtk.GtkAccelGroup() if type == MENU_FACTORY_MENU_BAR: self.__w = gtk.GtkMenuBar() self.__ret = self.__w elif type == MENU_FACTORY_MENU: self.__w =gtk. GtkMenu() self.__w.set_accel_group(self.accelerator) self.__ret = self.__w elif type == MENU_FACTORY_OPTION_MENU: self.__w = gtk.GtkMenu() self.__w.set_accel_group(self.accelerator) self.__ret = gtk.GtkOptionMenu() self.__ret.set_menu(self.__w) self.__menus = {} self.__items = {}
def __init__(self, manager): self.manager = manager self.manager.lockNewAccount(1) self.xml = openGlade(GLADE_FILE, root="NewAccountWindow") autoConnectMethods(self) self.widget = self.xml.get_widget("NewAccountWindow") self.frame = self.xml.get_widget("GatewayFrame") # Making up for a deficiency in glade. widgetMenu = self.xml.get_widget("GatewayOptionMenu") m = gtk.GtkMenu() activ = 0 self.currentGateway = None for name, klas in registeredTypes: i = gtk.GtkMenuItem(name) m.append(i) k = klas(self.manager) i.connect("activate", self.gatewaySelected, k) if not activ: activ = 1 self.gatewaySelected(None, k) widgetMenu.set_menu(m) self.widget.show_all()
def show(self): if self.window is not None: self.window.destroy() xml = p4vasp.util.loadGlade("graphwindow.glade", "exportdata_window") self.connect_signals(xml) self.xml = xml self.file_entry = xml.get_widget("file_entry") opt = xml.get_widget("type_optionmenu") menu = gtk.GtkMenu() opt.set_menu(menu) self.type_menu = menu self.type_options = opt for i in range(len(self.options)): item = gtk.GtkMenuItem(self.options[i]) item.signal_connect("activate", self._set_type, i) menu.append(item) item.show() opt.show() opt.set_history(0) self.window = xml.get_widget("exportdata_window") self.window.show()
def refresh_directory(self, *args): """refresh the directory menu and cause a rebuild of the file/directory lists""" self.menu_update = gtk.TRUE self.opt_menu.remove_menu() paths = [] drive, head = os.path.splitdrive(self.cwd) while head <> os.sep and head <> "": paths.append(drive + head) head, tail = os.path.split(head) paths.append(drive + os.sep) menu = gtk.GtkMenu() for path in paths: item = gtk.GtkMenuItem(path) item.show() item.connect('activate', self.directory_cb, path) menu.append(item) self.opt_menu.set_menu(menu) self.opt_menu.set_history(len(paths)) self.refresh_files() self.menu_update = gtk.FALSE
def __init__(self, reader, message, addrlist): self.reader = reader self.message = message composewin = reader.readglade("composewin", self) self.widget = sqmail.gui.utils.WidgetStore(composewin) self.font = gtk.load_font(sqmail.preferences.get_composefont()) # Ensure the text box is 80 columns wide. width = gtk.gdk_char_width(self.font, "m") * 82 # Set up the header fields. if addrlist: self.widget.tofield.set_text( sqmail.gui.utils.render_addrlist(addrlist)) self.widget.fromfield.set_text(sqmail.preferences.get_fromaddress()) if message: i = self.message.getsubject() if (i[:3] == "Re:") or (i[:3] == "re:"): self.widget.subjectfield.set_text(i) else: self.widget.subjectfield.set_text("Re: " + i) # Set up the sign button. self.signaturespopup = gtk.GtkMenu() signatures = os.listdir(os.path.expanduser("~")) signatures.sort() for i in signatures: if (i[0:10] == ".signature"): w = gtk.GtkMenuItem(i) w.show() w.connect("activate", sqmail.gui.utils.Callback(self)["on_sign_with"]) w.set_data("file", i) self.signaturespopup.append(w) # Set up the quote button. if message: self.quotepopup = gtk.GtkMenu() attachments = message.mimeflatten() for i in attachments: if (i[1] in sqmail.gui.textviewer.displayable): w = gtk.GtkMenuItem(i[1] + ": " + i[0]) w.show() w.connect("activate", sqmail.gui.utils.Callback(self)["on_quote_with"]) w.set_data("msg", i[2]) self.quotepopup.append(w) else: self.widget.quotebutton.set_sensitive(0) self.widget.textbox.freeze() self.widget.textbox.set_usize(width, 0) # These two lines set the font. *shrug* self.widget.textbox.insert(self.font, None, None, "\n") self.widget.textbox.delete_text(0, 1) # We want word wrapping. self.widget.textbox.set_word_wrap(1) self.widget.textbox.thaw()
def __init__(self, title=None, cwd=None, dialog_type=FILE_OPEN, filter=None, app=None, multiselect=0): gtk.GtkWindow.__init__(self) if dialog_type >= FILE_OPEN and dialog_type <= DIRECTORY_SELECT: self.dialog_type = dialog_type else: self.dialog_type = FILE_OPEN self.filter = None #current filter self.filters = {} #active filter objects self.filter_keys = [] #ordered list of the names of the filters self.file_selection = [] self.multiselect = multiselect self.set_border_width(5) self.set_policy(as=gtk.FALSE, ag=gtk.FALSE, autos=gtk.TRUE) self.drives = None if title == None: if dialog_type == FILE_OPEN: title = nls.get('filedlg-title-open-file', 'Open File ...') elif dialog_type == FILE_SAVE: title = nls.get('filedlg-title-save-file', 'Save File ...') elif dialog_type == DIRECTORY_SELECT: title = nls.get('filedlg-title-select-directory', 'Select Directory ...') self.set_title(title) #setup the current working directory if cwd is None or not os.path.exists(cwd): cwd = gview.get_preference('working-directory') if cwd is None: cwd = os.getcwd() self.cwd = cwd #widgets vbox = gtk.GtkVBox(spacing=5) if dialog_type == FILE_OPEN or dialog_type == DIRECTORY_SELECT: lbl = gtk.GtkLabel(nls.get('filedlg-label-open-from', 'Open From:')) elif dialog_type == FILE_SAVE: lbl = gtk.GtkLabel(nls.get('filedlg-label-save-in', 'Save In:')) self.opt_menu = gtk.GtkOptionMenu() self.opt_menu.set_menu(gtk.GtkMenu()) hbox = gtk.GtkHBox() hbox.pack_start(lbl, expand=gtk.FALSE) hbox.pack_start(self.opt_menu) vbox.pack_start(hbox, expand = gtk.FALSE) self.list_directory = gtk.GtkCList() scr_directories = gtk.GtkScrolledWindow() scr_directories.add(self.list_directory) self.list_directory.connect('button-press-event', self.directory_selected_cb) if dialog_type == DIRECTORY_SELECT: self.list_files = None vbox.pack_start(scr_directories) else: self.list_files = gtk.GtkCList() if self.multiselect: self.list_files.set_selection_mode( gtk.SELECTION_EXTENDED ) scr_files = gtk.GtkScrolledWindow() scr_files.add(self.list_files) self.list_files.connect('button-press-event', self.file_clicked_cb) self.list_files.connect('select-row', self.file_selected_cb ) self.list_files.connect('unselect-row', self.file_unselected_cb ) pane = gtk.GtkHPaned() scr_directories.set_usize(100, -1) scr_files.set_usize(100, -1) pane.add1(scr_directories) pane.add2(scr_files) pane.set_position(200) vbox.pack_start(pane) widget = None if dialog_type == FILE_SAVE: self.txt_filename = gtk.GtkEntry() widget = self.txt_filename elif dialog_type == FILE_OPEN: combo = gtk.GtkCombo() combo.set_value_in_list(gtk.FALSE, gtk.FALSE) combo.disable_activate() if app is not None: rfl = app.get_rfl() rfl.insert(0, '') combo.set_popdown_strings( rfl ) self.txt_filename = combo.entry widget = combo if widget is not None: table = gtk.GtkTable(rows=2, cols=2) lbl = gtk.GtkLabel(nls.get('filedlg-label-file-name', 'File Name:')) self.txt_filename.connect('focus-out-event', self.map_path_cb) self.txt_filename.connect('key-press-event', self.map_path_cb) table.attach(lbl, 0, 1, 0, 1) table.attach(widget, 1, 2, 0, 1) lbl = gtk.GtkLabel(nls.get('filedlg-label-filter-extension', 'Filter extension:')) self.cmb_filter = pguCombo() self.set_filter(filter) self.cmb_filter.entry.connect('changed', self.filter_cb) table.attach(lbl, 0, 1, 1, 2) table.attach(self.cmb_filter, 1, 2, 1, 2) vbox.pack_start(table, expand=gtk.FALSE) if dialog_type == FILE_SAVE: self.ok_button = gtk.GtkButton(nls.get('filedlg-button-ok', 'OK')) elif dialog_type == FILE_OPEN: self.ok_button = gtk.GtkButton(nls.get('filedlg-button-open', 'Open')) elif dialog_type == DIRECTORY_SELECT: self.ok_button = gtk.GtkButton(nls.get('filedlg-button-ok', 'OK')) self.cancel_button = gtk.GtkButton(nls.get('filedlg-button-cancel', 'Cancel')) self.ok_button.connect('clicked', self.remove_grab) self.ok_button.connect('clicked', self.update_cwd) self.cancel_button.connect('clicked', self.remove_grab) btn_box = gtk.GtkHButtonBox() btn_box.pack_start(self.ok_button) btn_box.pack_start(self.cancel_button) vbox.pack_start(btn_box, expand=gtk.FALSE) self.add(vbox) self.show_all() #make modal gtk.grab_add(self) self.ok_button.set_flags(gtk.CAN_DEFAULT) self.ok_button.grab_default() self.set_usize(400, 400) self.menu_update = gtk.FALSE while gtk.events_pending(): gtk.mainiteration(FALSE) self.refresh_directory() self.connect('delete-event', self.quit) self.ok_button.connect('clicked', self.quit) self.cancel_button.connect('clicked', self.quit) self.publish('quit') self.add_events(gtk.GDK.KEY_PRESS_MASK) self.connect('key-press-event', self.key_press_cb) self.result = 'cancel'
def prefs_window(): win = gtk.GtkWindow() gui["prefs_window"] = win win.set_policy(gtk.TRUE, gtk.TRUE, gtk.FALSE) win.set_title("Preferences") win.connect("delete_event", prefs_window_close) win.set_border_width(2) window_pos_mode(win) frame = gtk.GtkFrame() frame.show() frame.set_border_width(2) win.add(frame) vbox = gtk.GtkVBox(spacing=5) vbox.show() frame.add(vbox) gui["cb_ascii"] = gtk.GtkCheckButton("ASCII only") vbox.pack_start(gui["cb_ascii"]) gui["cb_ascii"].connect("toggled", prefs_toggled, 0) gui["cb_ascii"].show() gui["cb_rexp"] = gtk.GtkCheckButton("Remember last expression") vbox.pack_start(gui["cb_rexp"]) gui["cb_rexp"].connect("toggled", prefs_toggled, 1) gui["cb_rexp"].show() hbox = gtk.GtkHBox() vbox.pack_start(hbox) hbox.show() label = gtk.GtkLabel(" Window placement: ") label.show() hbox.pack_start(label) menu = gtk.GtkMenu() menuitem = gtk.GtkMenuItem("None") menuitem.connect("activate", prefs_selected_1, 0) menu.append(menuitem) menuitem.show() menuitem = gtk.GtkMenuItem("Center") menuitem.connect("activate", prefs_selected_1, 1) menu.append(menuitem) menuitem.show() menuitem = gtk.GtkMenuItem("Mouse") menuitem.connect("activate", prefs_selected_1, 2) menu.append(menuitem) menuitem.show() gui["wp_menu"] = gtk.GtkOptionMenu() gui["wp_menu"].set_menu(menu) gui["wp_menu"].set_history( hive.get_integer("/window/placement", default_window_placement)) hbox.pack_start(gui["wp_menu"]) gui["wp_menu"].show() hbox = gtk.GtkHBox() vbox.pack_start(hbox) hbox.show() label = gtk.GtkLabel(" Binary separators: ") label.show() hbox.pack_start(label) menu = gtk.GtkMenu() menuitem = gtk.GtkMenuItem("0") menuitem.connect("activate", prefs_selected_2, 0) menu.append(menuitem) menuitem.show() menuitem = gtk.GtkMenuItem("1") menuitem.connect("activate", prefs_selected_2, 1) menu.append(menuitem) menuitem.show() menuitem = gtk.GtkMenuItem("3") menuitem.connect("activate", prefs_selected_2, 2) menu.append(menuitem) menuitem.show() menuitem = gtk.GtkMenuItem("7") menuitem.connect("activate", prefs_selected_2, 3) menu.append(menuitem) menuitem.show() gui["bs_menu"] = gtk.GtkOptionMenu() gui["bs_menu"].set_menu(menu) gui["bs_menu"].set_history( hive.get_integer("/binary_separators", default_binary_separators)) hbox.pack_start(gui["bs_menu"]) gui["bs_menu"].show() if hive.get_bool("/ascii_only", default_ascii_only): gui["cb_ascii"].set_active(gtk.TRUE) else: gui["cb_ascii"].set_active(gtk.FALSE) if hive.get_bool("/remember_expression", default_remember_expression): gui["cb_rexp"].set_active(gtk.TRUE) else: gui["cb_rexp"].set_active(gtk.FALSE) button = gtk.GtkButton("Close") button.connect("clicked", prefs_window_close) vbox.pack_start(button, expand=gtk.FALSE) button.set_flags(gtk.CAN_DEFAULT) button.grab_default() button.show() gui["main_window"].set_sensitive(gtk.FALSE) gui["prefs_window"].show()
def init_dialog(self): self.dialog = gtk.GtkWindow() self.dialog.set_title('Tabular Shapes Attribute Grid Demo') self.dialog.set_default_size(300, 400) self.dialog.set_policy(gtk.FALSE, gtk.TRUE, gtk.TRUE) shell = gtk.GtkVBox(spacing=5) shell.set_border_width(10) self.dialog.add(shell) self.pgugrid = pgugrid.pguGrid(config=(3, 2, 0, 2, 4, 2, 0, 0, 0)) shell.pack_start(self.pgugrid, expand=gtk.TRUE) hbox = gtk.GtkHBox(spacing=5) shell.pack_start(hbox) self.column_button = gtk.GtkCheckButton("Schema properties only") self.column_button.connect("toggled", self.refresh_columns) self.column_button.set_active(gtk.TRUE) hbox.pack_start(self.column_button) rbutton = gtk.GtkButton("Refresh columns") rbutton.connect("clicked", self.refresh_columns) hbox.pack_start(rbutton, expand=gtk.FALSE) button = gtk.GtkButton("close") button.connect("clicked", self.close) shell.pack_start(button, expand=gtk.FALSE) button.show() shell.show_all() # Trap window close event self.dialog.connect('delete-event', self.close) self.app.sel_manager.subscribe('active-layer-changed', self.layer_update) self.pgugrid.subscribe("clicked", self.clicked_cb) self.pgugrid.connect("button-release-event", self.clicked_nocolumns_cb) #self.pgugrid.subscribe("cell-selection-changed",self.cell_cb) #self.pgugrid.subscribe("cell-changed",self.cellch_cb) #self.pgugrid.subscribe("row-selection-changed",self.row_cb) #self.pgugrid.subscribe("column-selection-changed",self.column_cb) # Popup menus: itemlist = [ #('Configuration',None,None), ('Set subset/Selected', self.set_subset_selected_cb, None), ('Set subset/Unseleted', self.set_subset_unselected_cb, None), ('Set subset/All', self.set_subset_all_cb, None), ('New layer/Selected', self.new_layer_selected_cb, None), ('New layer/Unselected', self.new_layer_unselected_cb, None), ('Edit Schema', self.edit_schema, None), #('Query',None,None), #('Save',None,None), #('Help',None,None) ] self.cell_popup_menu = [] self.cell_popup_menu.append(gtk.GtkMenu()) for label, func, args in itemlist: menu_item = gtk.GtkMenuItem(label) if func is not None: menu_item.connect("activate", func, args) self.cell_popup_menu[0].append(menu_item) self.cell_popup_menu[0].show_all() itemlist2 = [ #('Configuration',None,None), ('Set subset/Selected', self.set_subset_selected_cb, None), ('Set subset/Unseleted', self.set_subset_unselected_cb, None), ('Set subset/All', self.set_subset_all_cb, None), ('New layer/Selected', self.new_layer_selected_cb, None), ('New layer/Unselected', self.new_layer_unselected_cb, None), ('Edit Schema', self.edit_schema, None), ('Add property', self.add_property_column, None), #('Query',None,None), #('Save',None,None), #('Help',None,None) ] self.cell_popup_menu.append(gtk.GtkMenu()) for label, func, args in itemlist2: menu_item = gtk.GtkMenuItem(label) if func is not None: menu_item.connect("activate", func, args) self.cell_popup_menu[1].append(menu_item) self.cell_popup_menu[1].show_all() # Only do actions when grid is visible self.active = 0
def __init__(self, classification): """Initialize a GvClassificationDlg on a particular GvLayer""" gtk.GtkWindow.__init__(self) self.set_title('Layer Classification') self.set_usize(-1, 400) self.connect('delete-event', self.close) self.set_border_width(5) self.color_buttons = [] self.sym_menus = [] self.scale_spinners = [] self.view_mgr = None self.ranges = [] self.labels = [] self.reclassdlg = None self.updating = FALSE items = load_ramp_config_file() self.ramp = None if classification is None: self.classification = GvClassification() elif issubclass(classification.__class__, GvClassification): self.classification = classification else: raise TypeError, 'GvClassificationDlg now requires a \ GvClassification instance' if self.classification.count <= 0: self.ramp = items[0] self.classification.prepare_default() #d = self.classification.serialize() #main vertical box vbox = gtk.GtkVBox(spacing=3) save_box = gtk.GtkHButtonBox() btn_save = gtk.GtkButton('Save ...') btn_save.connect('clicked', self.save_cb) btn_load = gtk.GtkButton('Load ...') btn_load.connect('clicked', self.load_cb) save_box.pack_start(btn_load) save_box.pack_start(btn_save) try: import pgucombo self.property_list = pgucombo.pguCombo() except: self.property_list = gtk.GtkCombo() self.property_list.entry.connect('changed', self.property_select_cb) self.update_property_list() save_box.pack_start(self.property_list) vbox.pack_start(save_box, expand=gtk.FALSE) #classification frame class_frame = gtk.GtkFrame() frame_box = gtk.GtkVBox(spacing=3) title_box = gtk.GtkHBox() title_lbl = gtk.GtkLabel('Legend Title: ') self.title_txt = gtk.GtkEntry() self.title_txt.set_text(self.classification.get_title()) self.title_txt.connect('changed', self.title_changed_cb) title_box.pack_start(title_lbl, expand=gtk.FALSE) title_box.pack_start(self.title_txt) frame_box.pack_start(title_box, expand=gtk.FALSE) frame_box.set_border_width(5) #classification list class_box = gtk.GtkScrolledWindow() self.class_list = gtk.GtkList() self.class_list.connect('select-child', self.list_selected) class_box.add_with_viewport(self.class_list) frame_box.pack_start(class_box) self.reset_classification_list() class_frame.add(frame_box) vbox.pack_start(class_frame) ar_box = gtk.GtkHButtonBox() add_btn = gtk.GtkButton('Add class') add_btn.connect('clicked', self.add_class_cb) classify_btn = gtk.GtkButton('reclassify ...') classify_btn.connect('clicked', self.reclassify_cb) reset_btn = gtk.GtkButton('Revert') reset_btn.connect('clicked', self.reset_cb) ar_box.pack_start(add_btn) ar_box.pack_start(classify_btn) ar_box.pack_start(reset_btn) vbox.pack_start(ar_box, expand=gtk.FALSE) #Color Ramp choices ramp_table = gtk.GtkTable(rows=2, cols=2) ramp_table.show() ramp_lbl = gtk.GtkLabel('Color Ramps: ') ramp_lbl.show() ramp_table.attach(ramp_lbl, 0, 1, 0, 1) ramp_opt = gtk.GtkOptionMenu() ramp_opt.show() self.ramp_menu = gtk.GtkMenu() self.ramp_menu.show() ramp_item = gtk.GtkMenuItem() ramp_item.add(gtk.GtkHSeparator()) ramp_item.set_sensitive(gtk.FALSE) ramp_item.show_all self.ramp_menu.append(ramp_item) for n in items: ramp_item = gtk.GtkMenuItem() ramp_item.add(n) ramp_item.show_all() if issubclass(n.__class__, ColorRamp): ramp_item.connect('activate', self.ramp_cb, n) else: ramp_item.set_sensitive(gtk.FALSE) self.ramp_menu.append(ramp_item) ramp_opt.set_menu(self.ramp_menu) ramp_opt.show() ramp_opt.set_history(0) ramp_table.attach(ramp_opt, 1, 2, 0, 1) ramp_table.show_all() vbox.pack_start(ramp_table, expand=gtk.FALSE) #buttons button_box = gtk.GtkHButtonBox() #button_box.set_layout_default(gtk.BUTTONBOX_START) self.ok_button = gtk.GtkButton('OK') self.ok_button.connect('clicked', self.ok_cb) self.apply_button = gtk.GtkButton('Apply') self.apply_button.connect('clicked', self.apply_cb) self.cancel_button = gtk.GtkButton('Cancel') self.cancel_button.connect('clicked', self.cancel_cb) button_box.pack_start(self.ok_button, expand=gtk.FALSE) button_box.pack_start(self.apply_button, expand=gtk.FALSE) button_box.pack_start(self.cancel_button, expand=gtk.FALSE) vbox.pack_start(button_box, expand=gtk.FALSE) vbox.show_all() self.add(vbox) #make ok_button a default button ? why isn't it working ? self.ok_button.set_flags(gtk.CAN_DEFAULT) self.ok_button.grab_default() self.publish('classification-changed') self.update_property_list()