def set_mac_accelerators(self): # Set up accelerators suitable for the Mac. # Ctrl-Up and Ctrl-Down are taken by the window manager, so we use # Ctrl-PgUp and Ctrl-PgDn. # We want it to be easy to switch, so both sets of keys are always # active, but only one, most suitable for each platform, is displayed # in the menu. accel_group = gtk.accel_groups_from_object(self.window_main)[0] menu_up = self.menuitem_history_up UP = gdk.keyval_from_name('Up') PGUP = gdk.keyval_from_name('Prior') menu_dn = self.menuitem_history_down DN = gdk.keyval_from_name('Down') PGDN = gdk.keyval_from_name('Next') if sys.platform != 'darwin': menu_up.add_accelerator('activate', accel_group, PGUP, gdk.CONTROL_MASK, 0) menu_dn.add_accelerator('activate', accel_group, PGDN, gdk.CONTROL_MASK, 0) else: menu_up.remove_accelerator(accel_group, UP, gdk.CONTROL_MASK) menu_up.add_accelerator('activate', accel_group, PGUP, gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) menu_up.add_accelerator('activate', accel_group, UP, gdk.CONTROL_MASK, 0) menu_dn.remove_accelerator(accel_group, DN, gdk.CONTROL_MASK) menu_dn.add_accelerator('activate', accel_group, PGDN, gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) menu_dn.add_accelerator('activate', accel_group, DN, gdk.CONTROL_MASK, 0)
def __init_attributes(self, manager, editor): self.__manager = manager self.__editor = editor # Dictionary Format: {(keyval, modifier): trigger} self.__dictionary = {} from gtk import accel_groups_from_object self.__accelgroup = accel_groups_from_object(self.__editor.window)[0] return False
def enable_ctrl_m(self): if self.config['use_ctr_m']: window = self.roster.window self.accel_group = gtk.accel_groups_from_object(window)[0] self.accel_group.connect_group(gtk.keysyms.m, gtk.gdk.CONTROL_MASK, gtk.ACCEL_MASK, self.on_ctrl_m) self.config['menu_visible'] = not self.config['menu_visible'] self.on_ctrl_m(None, None, None, None)
def __init__(self, vm, window): vmmGObjectUI.__init__(self, None, None) self.vm = vm self.windowname = "vmm-details" self.window = window self.topwin = self.widget(self.windowname) self.err = vmmErrorDialog(self.topwin) self.pointer_is_grabbed = False self.change_title() self.vm.connect("config-changed", self.change_title) # State for disabling modifiers when keyboard is grabbed self.accel_groups = gtk.accel_groups_from_object(self.topwin) self.gtk_settings_accel = None self.gtk_settings_mnemonic = None # Initialize display widget self.viewer = None self.tunnels = None self.viewerRetriesScheduled = 0 self.viewerRetryDelay = 125 self._viewer_connected = False self.viewer_connecting = False self.scale_type = self.vm.get_console_scaling() # Fullscreen toolbar self.send_key_button = None self.fs_toolbar = None self.fs_drawer = None self.keycombo_menu = uihelpers.build_keycombo_menu(self.send_key) self.init_fs_toolbar() finish_img = gtk.image_new_from_stock(gtk.STOCK_YES, gtk.ICON_SIZE_BUTTON) self.widget("console-auth-login").set_image(finish_img) # Make viewer widget background always be black black = gtk.gdk.Color(0, 0, 0) self.widget("console-vnc-viewport").modify_bg(gtk.STATE_NORMAL, black) # Signals are added by vmmDetails. Don't use connect_signals here # or it changes will be overwritten # Set console scaling self.add_gconf_handle( self.vm.on_console_scaling_changed(self.refresh_scaling)) scroll = self.widget("console-vnc-scroll") scroll.connect("size-allocate", self.scroll_size_allocate) self.add_gconf_handle( self.config.on_console_accels_changed(self.set_enable_accel)) self.add_gconf_handle( self.config.on_keys_combination_changed(self.grab_keys_changed)) self.page_changed()
def menubar_osx(gtkui, osxapp): main_builder = gtkui.mainwindow.get_builder() menubar = main_builder.get_object('menubar') group = accel_groups_from_object(gtkui.mainwindow.window)[0] config = ConfigManager('gtkui.conf') # NOTE: accel maps doesn't work with glade file format # because of libglade not setting MenuItem accel groups # That's why we remove / set accelerators by hand... (dirty) # Clean solution: migrate glades files to gtkbuilder format file_menu = main_builder.get_object('menu_file').get_submenu() file_items = file_menu.get_children() accel_meta(file_items[0], group, 'o') accel_meta(file_items[1], group, 'n') quit_all_item = file_items[3] accel_swap( quit_all_item, group, 'q', SHIFT_MASK | CONTROL_MASK, 'q', SHIFT_MASK | META_MASK, ) for item in range(2, len(file_items)): # remove quits file_menu.remove(file_items[item]) menu_widget = main_builder.get_object('menu_edit') edit_menu = menu_widget.get_submenu() edit_items = edit_menu.get_children() pref_item = edit_items[0] accel_swap(pref_item, group, 'p', CONTROL_MASK, ',', META_MASK) edit_menu.remove(pref_item) conn_item = edit_items[1] accel_meta(conn_item, group, 'm') edit_menu.remove(conn_item) menubar.remove(menu_widget) help_menu = main_builder.get_object('menu_help').get_submenu() help_items = help_menu.get_children() about_item = help_items[4] help_menu.remove(about_item) help_menu.remove(help_items[3]) # separator menubar.hide() osxapp.set_menu_bar(menubar) # populate app menu osxapp.insert_app_menu_item(about_item, 0) osxapp.insert_app_menu_item(SeparatorMenuItem(), 1) osxapp.insert_app_menu_item(pref_item, 2) if not config['standalone']: osxapp.insert_app_menu_item(conn_item, 3) if quit_all_item.get_visible(): osxapp.insert_app_menu_item(SeparatorMenuItem(), 4) osxapp.insert_app_menu_item(quit_all_item, 5)
def create(toolbar): '''Set of instructions to create the search widget in a toolbar.''' # Search components toolbar.search_combo_tb = gtk.ToolItem() toolbar.search_combo_align = gtk.Alignment(yalign=0.5) store = gtk.ListStore(gtk.gdk.Pixbuf, str) toolbar.search_combo = gtk.ComboBox(store) rendererText = gtk.CellRendererText() rendererPix = gtk.CellRendererPixbuf() toolbar.search_combo.pack_start(rendererPix, False) toolbar.search_combo.pack_start(rendererText, True) toolbar.search_combo.add_attribute(rendererPix, 'pixbuf', 0) toolbar.search_combo.add_attribute(rendererText, 'text', 1) options = { 'String': gtk.gdk.pixbuf_new_from_file(datafile_path('icon_string_16.png')), 'String no case': gtk.gdk.pixbuf_new_from_file( datafile_path('icon_string_no_case_16.png')), 'Hexadecimal': gtk.gdk.pixbuf_new_from_file(datafile_path('icon_hexadecimal_16.png')), 'Regexp': gtk.gdk.pixbuf_new_from_file(datafile_path('icon_regexp_16.png')) } for option in options.keys(): store.append([options[option], option]) toolbar.search_combo.set_active(0) toolbar.search_combo_align.add(toolbar.search_combo) toolbar.search_combo_tb.add(toolbar.search_combo_align) toolbar.main_tb.insert(toolbar.search_combo_tb, -1) # Separator toolbar.sep = gtk.SeparatorToolItem() toolbar.sep.set_draw(False) toolbar.main_tb.insert(toolbar.sep, -1) toolbar.search_entry_tb = gtk.ToolItem() toolbar.search_entry = gtk.Entry(100) toolbar.search_entry.set_text('Text to search') toolbar.search_entry.set_icon_from_stock(1, gtk.STOCK_FIND) toolbar.search_entry.set_icon_tooltip_text(1, 'Search') toolbar.search_entry.connect("activate", toolbar.search) toolbar.search_entry.connect("icon-press", toolbar.search) toolbar.search_entry.connect('focus-in-event', toolbar._clean, 'in') toolbar.search_entry.connect('focus-out-event', toolbar._clean, 'out') toolbar.search_entry_tb.add(toolbar.search_entry) # We use the AccelGroup object from the main window. my_accel = gtk.accel_groups_from_object(toolbar.main.window)[0] key, mod = gtk.accelerator_parse('<Control>F') toolbar.search_entry.set_tooltip_text('Control-F to search') toolbar.search_entry.add_accelerator('grab-focus', my_accel, key, mod, gtk.ACCEL_MASK) toolbar.main_tb.insert(toolbar.search_entry_tb, -1)
def menu_bar(self): log.debug("menu_bar") window = self.gtkui.mainwindow glade = window.main_glade menubar = glade.get_widget("menubar") group = gtk.accel_groups_from_object(window.window)[0] # NOTE: accel maps doesn't work with glade file format # because of libglade not setting MenuItem accel groups # That's why we remove / set accelerators by hand... (dirty) # Clean solution: migrate glades files to gtkbuilder format file_menu = glade.get_widget("menu_file").get_submenu() file_items = file_menu.get_children() self.accel_meta(file_items[0], group, "o") self.accel_meta(file_items[1], group, "n") quit_all_item = file_items[3] self.accel_swap( quit_all_item, group, "q", gtk.gdk.SHIFT_MASK | gtk.gdk.CONTROL_MASK, "q", gtk.gdk.SHIFT_MASK | gtk.gdk.META_MASK, ) for item in range(2, len(file_items)): # remove quits file_menu.remove(file_items[item]) menu_widget = glade.get_widget("menu_edit") edit_menu = menu_widget.get_submenu() edit_items = edit_menu.get_children() pref_item = edit_items[0] self.accel_swap(pref_item, group, "p", gtk.gdk.CONTROL_MASK, ",", gtk.gdk.META_MASK) edit_menu.remove(pref_item) conn_item = edit_items[1] self.accel_meta(conn_item, group, "m") edit_menu.remove(conn_item) menubar.remove(menu_widget) help_menu = glade.get_widget("menu_help").get_submenu() help_items = help_menu.get_children() about_item = help_items[4] help_menu.remove(about_item) help_menu.remove(help_items[3]) # separator menubar.hide() self.osxapp.set_menu_bar(menubar) # populate app menu self.osxapp.insert_app_menu_item(about_item, 0) self.osxapp.insert_app_menu_item(gtk.SeparatorMenuItem(), 1) self.osxapp.insert_app_menu_item(pref_item, 2) self.osxapp.insert_app_menu_item(conn_item, 3) if quit_all_item.get_visible(): self.osxapp.insert_app_menu_item(gtk.SeparatorMenuItem(), 4) self.osxapp.insert_app_menu_item(quit_all_item, 5)
def __init_attributes(self, manager, editor): self.__manager = manager self.__editor = editor self.__treeview = manager.gui.get_object("TreeView") self.__window = editor.window from gtk import accel_groups_from_object self.__accelgroup = accel_groups_from_object(self.__window)[0] self.__accel_group_is_removed = False self.__treeview_signal_is_blocked = False self.__window_signal_is_blocked = False return
def menubar_osx(gtkui, osxapp): window = gtkui.mainwindow glade = window.main_glade menubar = glade.get_widget("menubar") group = gtk.accel_groups_from_object(window.window)[0] config = ConfigManager("gtkui.conf") # NOTE: accel maps doesn't work with glade file format # because of libglade not setting MenuItem accel groups # That's why we remove / set accelerators by hand... (dirty) # Clean solution: migrate glades files to gtkbuilder format file_menu = glade.get_widget("menu_file").get_submenu() file_items = file_menu.get_children() accel_meta(file_items[0], group, 'o') accel_meta(file_items[1], group, 'n') quit_all_item = file_items[3] accel_swap(quit_all_item, group, 'q', gtk.gdk.SHIFT_MASK | gtk.gdk.CONTROL_MASK, 'q', gtk.gdk.SHIFT_MASK | gtk.gdk.META_MASK) for item in range(2, len(file_items)): # remove quits file_menu.remove(file_items[item]) menu_widget = glade.get_widget("menu_edit") edit_menu = menu_widget.get_submenu() edit_items = edit_menu.get_children() pref_item = edit_items[0] accel_swap(pref_item, group, 'p', gtk.gdk.CONTROL_MASK, ',', gtk.gdk.META_MASK) edit_menu.remove(pref_item) conn_item = edit_items[1] accel_meta(conn_item, group, 'm') edit_menu.remove(conn_item) menubar.remove(menu_widget) help_menu = glade.get_widget("menu_help").get_submenu() help_items = help_menu.get_children() about_item = help_items[4] help_menu.remove(about_item) help_menu.remove(help_items[3]) # separator menubar.hide() osxapp.set_menu_bar(menubar) # populate app menu osxapp.insert_app_menu_item(about_item, 0) osxapp.insert_app_menu_item(gtk.SeparatorMenuItem(), 1) osxapp.insert_app_menu_item(pref_item, 2) if not config["classic_mode"]: osxapp.insert_app_menu_item(conn_item, 3) if quit_all_item.get_visible(): osxapp.insert_app_menu_item(gtk.SeparatorMenuItem(), 4) osxapp.insert_app_menu_item(quit_all_item, 5)
def __init__(self): self._bindings = {} self._db = None self.widgets = [] wt = self._glade_adaptor = WidgetTree(self, self.gladefile, self.widgets) toplevel = self.toplevel = wt.get_widget(self.gladefile) assert isinstance(toplevel, gtk.Window) toplevel.connect('delete-event', self._on_delete_event) toplevel.connect('key-press-event', self._on_key_press_event) self._accel_groups = gtk.accel_groups_from_object(toplevel) self._broker = GladeSignalBroker(self, self) self._set_bindings() self._statusbar_context = self.statusbar.get_context_id('APP')
def _attach_groups(self, win, accel_groups): # get groups currently attached to the window; we use them # to avoid reattaching an accelerator to the same window, which # generates messages like: # # gtk-critical **: file gtkaccelgroup.c: line 188 # (gtk_accel_group_attach): assertion `g_slist_find # (accel_group->attach_objects, object) == null' failed. # # interestingly, this happens many times with notebook, # because libglade creates and attaches groups in runtime to # its toplevel window. current_groups = gtk.accel_groups_from_object(win) for group in accel_groups: if group in current_groups: # skip group already attached continue win.add_accel_group(group)
def __init__(self, toplevel=None, widgets=None, gladefile=None, toplevel_name=None, domain=None): """ Creates a new SlaveView. Sets up self.toplevel and self.widgets and checks for reserved names. """ gobject.GObject.__init__(self) self._broker = None self.slaves = {} self._proxies = [] self._valid = True # slave/widget name -> validation status self._validation = {} # stores the function that will be called when widgets # validity is checked self._validate_function = None # setup the initial state with the value of the arguments or the # class variables klass = type(self) self.toplevel = toplevel or klass.toplevel self.widgets = widgets or klass.widgets self.gladefile = gladefile or klass.gladefile self.toplevel_name = (toplevel_name or klass.toplevel_name or self.gladefile) self.domain = domain or klass.domain self._check_reserved() self._glade_adaptor = self.get_glade_adaptor() self.toplevel = self._get_toplevel() # grab the accel groups self._accel_groups = gtk.accel_groups_from_object(self.toplevel) # XXX: support normal widgets # notebook page label widget -> # dict (slave name -> validation status) self._notebook_validation = {} self._notebooks = self._get_notebooks()
def toggle_fullscreen(self, *args): if hasattr(self, "fullwindow"): main_widget = self.fullwindow.get_child() self.fullwindow.remove(main_widget) self.fullwindow.destroy() del self.fullwindow self.main_box.add(main_widget) return main_widget = self.main_box.get_child() if main_widget is None: return self.main_box.remove(main_widget) self.fullwindow = gtk.Window() self.fullwindow.add(main_widget) self.fullwindow.fullscreen() self.fullwindow.show() for accelgroup in gtk.accel_groups_from_object( self.builder.get_object("window1")): self.fullwindow.add_accel_group(accelgroup) accelgroup = gtk.AccelGroup() keyval, mods = gtk.accelerator_parse("Escape") accelgroup.connect_group(keyval, mods, 0, self.toggle_fullscreen) self.fullwindow.add_accel_group(accelgroup)
def __init__(self): gnome.init(goghglobals.APPNAME, goghglobals.APPVERSION) enable_devices() xml = gtk.glade.XML(get_abspath("glade/goghglade.glade"), root="gogh_drawing_window") xml.signal_autoconnect(self) xml_about = gtk.glade.XML(get_abspath("glade/goghglade.glade"), root="gogh_about_dialog") self.about_dialog = xml_about.get_widget("gogh_about_dialog") self.about_dialog.set_name(goghglobals.APPNAME) self.about_dialog.set_version(goghglobals.APPVERSION) self.draw_area = xml.get_widget("drawing_area") self.drawable = self.draw_area.window self.drawarea_viewport = xml.get_widget("drawarea_viewport") self.editor_window = xml.get_widget("gogh_drawing_window") goghglobals.gogh_main_window = self.editor_window self.drawarea_scrolled_window = xml.get_widget("drawarea_scrolled_window") self.brush_manager = BrushManager() self.layers_dialog = LayersDialog() self.layers_dialog.assign_check_menu_item(xml.get_widget("show_layer_selection1")) self.layers_dialog.dialog.add_accel_group(gtk.accel_groups_from_object(self.editor_window)[0]) self.resize_dialog = ResizeDialog() self.scale_dialog = ScaleDialog() goghdoc = GoghDoc(width = 400, height = 400) goghdoc.add_new_layer() goghdoc.command_stack.clear() self.load_document(goghdoc) self.brush_list_button = xml.get_widget("brush_list_menubutton") self.brush_list_button.set_menu(self.brush_manager.brush_menu) self.color_select_dialog = ColorDialog() self.color_select_dialog.assign_check_menu_item(xml.get_widget("show_color_selection1")) self.brush_manager.brush_selection_observer.add_callback(self.reset_cursor) self.brush_management_dialog = BrushManagementDialog(self.brush_manager) self.brush_management_dialog.assign_check_menu_item(xml.get_widget("show_brush_management_dialog1")) self.is_pressed = False self.reset_cursor() self.gogh_filter = gtk.FileFilter() self.gogh_filter.set_name(_("Gogh Documents")) self.gogh_filter.add_pattern("*.gogh") self.gogh_filter.add_pattern("image/gogh") self.image_file_filter = gtk.FileFilter() self.image_file_filter.set_name(_("Images")) self.image_file_filter.add_pattern("*.jpeg") self.image_file_filter.add_pattern("*.jpg") self.image_file_filter.add_pattern("*.png") self.image_file_filter.add_pattern("*.JPEG") self.image_file_filter.add_pattern("*.JPG") self.image_file_filter.add_pattern("*.PNG") self.image_file_filter.add_pattern("image/jpeg") self.image_file_filter.add_pattern("image/png") self.all_files_filter = gtk.FileFilter() self.all_files_filter.set_name(_("All files")) self.all_files_filter.add_pattern("*") if len(sys.argv)>1 : self.load_document_from_unknown_file(sys.argv[1]) self.ignore_invalidate = False
def __init__(self, library, player): super(QuodLibetWindow, self).__init__() self.last_dir = const.HOME self.__update_title(player) self.set_default_size(550, 450) main_box = gtk.VBox() self.add(main_box) # create test instance of the MPD backend self._mpd = quodmpd.QuodMpd() # create main menubar, load/restore accelerator groups self.__library = library self.__create_menu(player, library) self.add_accel_group(self.ui.get_accel_group()) accel_fn = os.path.join(const.USERDIR, "accels") gtk.accel_map_load(accel_fn) accelgroup = gtk.accel_groups_from_object(self)[0] accelgroup.connect('accel-changed', lambda *args: gtk.accel_map_save(accel_fn)) main_box.pack_start(self.ui.get_widget("/Menu"), expand=False) # get the playlist up before other stuff self.songlist = MainSongList(library, player) self.songlist.show_all() self.add_accel_group(self.songlist.accelerators) self.songlist.connect_after( 'drag-data-received', self.__songlist_drag_data_recv) self.song_scroller = SongListScroller( self.ui.get_widget("/Menu/View/SongList")) self.song_scroller.add(self.songlist) self.qexpander = QueueExpander( self.ui.get_widget("/Menu/View/Queue"), library, player) self.playlist = PlaylistMux( player, self.qexpander.model, self.songlist.model) top_bar = TopBar(self, player, library) top_align = Alignment(top_bar, border=3, bottom=-3) main_box.pack_start(top_align, expand=False) self.__browserbox = Alignment(top=3, bottom=3) main_box.pack_start(self.__browserbox) statusbox = StatusBarBox(self.songlist.model, player) self.order = statusbox.order self.repeat = statusbox.repeat self.statusbar = statusbox.statusbar main_box.pack_start(Alignment(statusbox, border=3, top=-3), expand=False) self.songpane = gtk.VPaned() self.songpane.pack1(self.song_scroller, resize=True, shrink=False) self.songpane.pack2(self.qexpander, resize=True, shrink=False) self.__handle_position = self.songpane.get_property("position") self.song_scroller.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::expanded', self.__expand_or) self.qexpander.connect('size-allocate', self.__qex_size_allocate) self.songpane.connect('notify', self.__moved_pane_handle) sort = config.get('memory', 'sortby') self.songlist.set_sort_by(None, sort[1:], order=int(sort[0])) self.browser = None main_box.show_all() try: self.select_browser( self, config.get("memory", "browser"), library, player, True) except: config.set("memory", "browser", browsers.name(0)) config.save(const.CONFIG) raise # set at least the playlist before the mainloop starts.. player.setup(self.playlist, None, 0) def delayed_song_set(): song = library.get(config.get("memory", "song")) seek_pos = config.getint("memory", "seek") config.set("memory", "seek", 0) player.setup(self.playlist, song, seek_pos) gobject.idle_add(delayed_song_set) self.showhide_playlist(self.ui.get_widget("/Menu/View/SongList")) self.showhide_playqueue(self.ui.get_widget("/Menu/View/Queue")) self.songlist.connect('popup-menu', self.__songs_popup_menu) self.songlist.connect('columns-changed', self.__cols_changed) self.songlist.connect('columns-changed', self.__hide_headers) self.songlist.get_selection().connect( 'changed', util.DeferredSignal(self.__set_time)) lib = library.librarian gobject_weak(lib.connect, 'removed', self.__set_time, parent=self) gobject_weak(lib.connect, 'added', self.__set_time, parent=self) gobject_weak(lib.connect_object, 'changed', self.__song_changed, player, parent=self) player_sigs = [ ('song-ended', self.__song_ended), ('song-started', self.__song_started), ('paused', self.__update_paused, True), ('unpaused', self.__update_paused, False), ] for sig in player_sigs: gobject_weak(player.connect, *sig, **{"parent": self}) targets = [("text/uri-list", 0, 1)] self.drag_dest_set( gtk.DEST_DEFAULT_ALL, targets, gtk.gdk.ACTION_DEFAULT) self.connect_object('drag-motion', QuodLibetWindow.__drag_motion, self) self.connect_object('drag-leave', QuodLibetWindow.__drag_leave, self) self.connect_object( 'drag-data-received', QuodLibetWindow.__drag_data_received, self) if config.getboolean('library', 'refresh_on_start'): self.__rebuild(None, False) self.connect_object("key-press-event", self.__key_pressed, player) self.connect("delete-event", self.__save_browser) self.connect("destroy", self.__destroy) self.enable_window_tracking("quodlibet")
""" To make shortcuts work both AccelMap and AccelGroup have to know about them. """ import gtk key, mod = gtk.accelerator_parse("<ctrl>s") assert gtk.accelerator_valid(key, mod) PATH = "<MyApp-MainWindow>/Save" gtk.accel_map_add_entry(PATH, key, mod) group = gtk.AccelGroup() group.connect_by_path(PATH, gtk.main_quit) window = gtk.Window() assert not gtk.accel_groups_from_object(window) window.add_accel_group(group) window.show_all() gtk.main()
def __init__(self, toplevel=None, widgets=None, gladefile=None, toplevel_name=None, domain=None): """ Creates a new SlaveView. Sets up self.toplevel and self.widgets and checks for reserved names. """ gobject.GObject.__init__(self) self._broker = None self.slaves = {} self._proxies = [] self.is_valid = True # slave/widget name -> validation status self._validation = {} self._forms = {} self._forms_attached = False # stores the function that will be called when widgets # validity is checked self._validate_function = None # setup the initial state with the value of the arguments or the # class variables klass = type(self) self.toplevel = toplevel or getattr(self, 'toplevel', klass.toplevel) self.widgets = widgets or klass.widgets self.gladefile = gladefile or klass.gladefile self.toplevel_name = (toplevel_name or klass.toplevel_name or self.gladefile) self.domain = domain or klass.domain self._check_reserved() # Make it possible to run a view without a glade file, to be able # to attach slaves we need the toplevel widget to be an EventBox. if not self.gladefile and self.toplevel is None: self.toplevel = gtk.Window() self.toplevel.set_name('KiwiViewWindow') # Forms create widgets that we want to connect signals to, # so this needs to be done before the View constructor if self.fields: self.add_form(self.fields) self._glade_adaptor = self.get_glade_adaptor() self.toplevel = self._get_toplevel() # grab the accel groups self._accel_groups = gtk.accel_groups_from_object(self.toplevel) # XXX: support normal widgets # notebook page label widget -> # dict (slave name -> validation status) self._notebook_validation = {} self._notebooks = self._get_notebooks() if len(self._notebooks) == 1: register_notebook_shortcuts(self, self._notebooks[0]) # FIXME: This is a hack to avoid a toplevel window # showing up, I cannot quite figure out how it works # probably related to attach_slave(), Johan 2012-06-19 if self.fields and not self.gladefile: self.toplevel.hide()
def __init__(self, toplevel=None, widgets=None, gladefile=None, toplevel_name=None, domain=None): """ Creates a new SlaveView. Sets up self.toplevel and self.widgets and checks for reserved names. """ gobject.GObject.__init__(self) self._broker = None self.slaves = {} self._proxies = [] self.is_valid = True # slave/widget name -> validation status self._validation = {} self._forms = {} self._forms_attached = False # stores the function that will be called when widgets # validity is checked self._validate_function = None # setup the initial state with the value of the arguments or the # class variables klass = type(self) self.toplevel = toplevel or getattr(self, 'toplevel', klass.toplevel) self.widgets = widgets or klass.widgets self.gladefile = gladefile or klass.gladefile self.toplevel_name = (toplevel_name or klass.toplevel_name) if not self.toplevel_name and self.gladefile: self.toplevel_name = os.path.splitext( os.path.basename(self.gladefile))[0] self.domain = domain or klass.domain # Fallback to domain if translation_domain is not provided self.translation_domain = klass.translation_domain or self.domain self._check_reserved() # Make it possible to run a view without a glade file, to be able # to attach slaves we need the toplevel widget to be an EventBox. if not self.gladefile and self.toplevel is None: self.toplevel = gtk.Window() self.toplevel.set_name('KiwiViewWindow') # Forms create widgets that we want to connect signals to, # so this needs to be done before the View constructor if self.fields: self.add_form(self.fields) self._glade_adaptor = self.get_glade_adaptor() self.toplevel = self._get_toplevel() # grab the accel groups self._accel_groups = gtk.accel_groups_from_object(self.toplevel) # XXX: support normal widgets # notebook page label widget -> # dict (slave name -> validation status) self._notebook_validation = {} self._notebooks = self._get_notebooks() if len(self._notebooks) == 1: register_notebook_shortcuts(self, self._notebooks[0]) # FIXME: This is a hack to avoid a toplevel window # showing up, I cannot quite figure out how it works # probably related to attach_slave(), Johan 2012-06-19 if self.fields and not self.gladefile: self.toplevel.hide()