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 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_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 __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 __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 _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 __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 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()
