def __init__(self): self.menu = gtk.Menu() self._app_indicator = None self._status_icon = None try: import appindicator except ImportError: self._status_icon = StatusIcon() self._status_icon.set_menu(self.menu) else: self._app_indicator = appindicator.Indicator("glipper", "glipper", appindicator.CATEGORY_APPLICATION_STATUS) self._app_indicator.set_status(appindicator.STATUS_ACTIVE) self._app_indicator.set_menu(self.menu) glipper.GCONF_CLIENT.notify_add(glipper.GCONF_MARK_DEFAULT_ENTRY, lambda x, y, z, a: self.update_menu(get_glipper_history().get_history())) glipper.GCONF_CLIENT.notify_add(glipper.GCONF_MAX_ITEM_LENGTH, lambda x, y, z, a: self.update_menu(get_glipper_history().get_history())) gtk.window_set_default_icon_name("glipper") get_glipper_keybinder().connect('activated', self.on_key_combination_press) get_glipper_keybinder().connect('changed', self.on_key_combination_changed) get_glipper_history().connect('changed', self.on_history_changed) get_glipper_plugins_manager().load() get_glipper_history().load() get_glipper_plugins_manager().connect('menu-items-changed', self.on_plugins_menu_items_changed)
def __init__(self, datadir, version, argv): self.file_path = datadir self.version = version self.editor = MenuEditor() gtk.window_set_default_icon_name("mozo") self.tree = gtk.Builder() self.tree.set_translation_domain(config.GETTEXT_PACKAGE) self.tree.add_from_file(os.path.join(self.file_path, "mozo.ui")) self.tree.connect_signals(self) self.setupMenuTree() self.setupItemTree() self.tree.get_object("edit_delete").set_sensitive(False) self.tree.get_object("edit_revert_to_original").set_sensitive(False) self.tree.get_object("edit_properties").set_sensitive(False) self.tree.get_object("move_up_button").set_sensitive(False) self.tree.get_object("move_down_button").set_sensitive(False) self.tree.get_object("new_separator_button").set_sensitive(False) accelgroup = gtk.AccelGroup() keyval, modifier = gtk.accelerator_parse("<Ctrl>Z") accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_mainwindow_undo) keyval, modifier = gtk.accelerator_parse("<Ctrl><Shift>Z") accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_mainwindow_redo) keyval, modifier = gtk.accelerator_parse("F1") accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_help_button_clicked) self.tree.get_object("mainwindow").add_accel_group(accelgroup)
def create_hamster_window(self): if self.window is None: # load window of activity switcher and todays view self._gui = load_ui_file("today.ui") self.window = self._gui.get_object('hamster-window') self.window.connect("delete_event", self.on_delete_window) gtk.window_set_default_icon_name("hamster-time-tracker") self.new_name = widgets.ActivityEntry() self.new_name.connect("value-entered", self.on_switch_activity_clicked) widgets.add_hint(self.new_name, _("Activity")) self.get_widget("new_name_box").add(self.new_name) self.new_name.connect("changed", self.on_activity_text_changed) self.new_tags = widgets.TagsEntry() self.new_tags.connect("tags_selected", self.on_switch_activity_clicked) widgets.add_hint(self.new_tags, _("Tags")) self.get_widget("new_tags_box").add(self.new_tags) self.tag_box = widgets.TagBox(interactive = False) self.get_widget("tag_box").add(self.tag_box) self.treeview = widgets.FactTree() self.treeview.connect("key-press-event", self.on_todays_keys) self.treeview.connect("edit-clicked", self._open_edit_activity) self.treeview.connect("row-activated", self.on_today_row_activated) self.get_widget("today_box").add(self.treeview) # connect the accelerators self.accel_group = self.get_widget("accelgroup") self.window.add_accel_group(self.accel_group) self._gui.connect_signals(self)
def __init__(self, ui_file="avahi-discover.ui", **kwargs): ui_path = os.path.join(os.path.dirname(__file__), ui_file) gtk.window_set_default_icon_name("network-wired") self.ui = gtk.Builder() self.ui.add_from_file(ui_path) self.ui.connect_signals(self) self.tree_view = self.ui.get_object("tree_view") self.info_label = self.ui.get_object("info_label") self.treemodel = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING) self.tree_view.set_model(self.treemodel) #creating the columns headers self.tree_view.set_headers_visible(False) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn("", renderer, text=0) column.set_resizable(True) column.set_sizing("GTK_TREE_VIEW_COLUMN_GROW_ONLY") column.set_expand(True) self.tree_view.append_column(column) # Tree domain -> type -> service self.domain_iters = {} self.type_iters = {} self.service_iters = {} super(MainWindow, self).__init__(**kwargs) # Some "improvements" # Don't unfold .local if there are other domains self.unfold_local = True
def __init__(self): # Default values self.filename = None self.about_dialog = None # use GtkBuilder to build our interface from the XML file try: builder = gtk.Builder() builder.add_from_file("res/texteditor.glade") except: self.error_message("Failed to load UI XML file: texteditor.glade") sys.exit(1) # get the widgets which will be referenced in callbacks self.window = builder.get_object("window") self.statusbar = builder.get_object("statusbar") self.text_view = builder.get_object("text_view") # connect signals builder.connect_signals(self) # set the text view font self.text_view.modify_font(pango.FontDescription("monospace 10")) # set the default icon to the GTK "edit" icon gtk.window_set_default_icon_name(gtk.STOCK_EDIT) # setup and initialize our statusbar self.statusbar_cid = self.statusbar.get_context_id("Tutorial GTK+ Text Editor") self.reset_default_status()
def main(): signal.signal(signal.SIGHUP, signal.SIG_IGN) gtk.window_set_default_icon_name("gnome-terminal") parts = {"history": shell.History()} make_terminal(parts).get_widget().show_all() errorgui.set_excepthook() gtk.main()
def __init__(self, datadir, version, argv): self.file_path = datadir self.version = version self.editor = MenuEditor() gtk.window_set_default_icon_name('mozo') self.tree = gtk.Builder() self.tree.set_translation_domain(config.GETTEXT_PACKAGE) self.tree.add_from_file(os.path.join(self.file_path, 'mozo.ui')) self.tree.connect_signals(self) self.setupMenuTree() self.setupItemTree() self.tree.get_object('edit_delete').set_sensitive(False) self.tree.get_object('edit_revert_to_original').set_sensitive(False) self.tree.get_object('edit_properties').set_sensitive(False) self.tree.get_object('move_up_button').set_sensitive(False) self.tree.get_object('move_down_button').set_sensitive(False) self.tree.get_object('new_separator_button').set_sensitive(False) accelgroup = gtk.AccelGroup() keyval, modifier = gtk.accelerator_parse('<Ctrl>Z') accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_mainwindow_undo) keyval, modifier = gtk.accelerator_parse('<Ctrl><Shift>Z') accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_mainwindow_redo) keyval, modifier = gtk.accelerator_parse('F1') accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_help_button_clicked) self.tree.get_object('mainwindow').add_accel_group(accelgroup)
def __init__(self): # Default values self.filename = None self.about_dialog = None # use GtkBuilder to build our interface from the XML file try: builder = gtk.Builder() builder.add_from_file("res/texteditor.glade") except: self.error_message("Failed to load UI XML file: texteditor.glade") sys.exit(1) # get the widgets which will be referenced in callbacks self.window = builder.get_object("window") self.statusbar = builder.get_object("statusbar") self.text_view = builder.get_object("text_view") # connect signals builder.connect_signals(self) # set the text view font self.text_view.modify_font(pango.FontDescription("monospace 10")) # set the default icon to the GTK "edit" icon gtk.window_set_default_icon_name(gtk.STOCK_EDIT) # setup and initialize our statusbar self.statusbar_cid = self.statusbar.get_context_id( "Tutorial GTK+ Text Editor") self.reset_default_status()
def setup_main_window (self): gtk.window_set_default_icon_name('mate-sudoku') self.w = gtk.Window() self.w.set_default_size(self.mateconf['width'], self.mateconf['height']) self.w.set_title(APPNAME_SHORT) self.w.connect('configure-event', self.resize_cb) self.w.connect('delete-event', self.quit_cb) self.uimanager = gtk.UIManager()
def init(): from blamainwindow import BlaMainWindow gtk.icon_theme_get_default().append_search_path(blaconst.ICONS_PATH) theme = gtk.icon_theme_get_default() gtk.window_set_default_icon_name(blaconst.APPNAME) return BlaMainWindow()
def setup_main_window (self): gtk.window_set_default_icon_name('gnome-sudoku') self.w = gtk.Window() self.w.set_default_size(self.gconf['width'], self.gconf['height']) self.w.set_title(APPNAME_SHORT) self.w.connect('configure-event', self.resize_cb) self.w.connect('delete-event', self.quit_cb) self.uimanager = gtk.UIManager()
def __init__(self, datadir=None, options=None, file=None, parent=None): """ Provide a GTK based graphical user interface to configure the used software repositories, corresponding authentication keys and update automation """ SoftwareProperties.__init__(self, options=options, datadir=datadir) gtk.window_set_default_icon_name("software-properties") SimpleGladeApp.__init__(self, datadir + "glade/main.glade", None, domain="software-properties") if parent: self.window_main.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG) self.window_main.show() self.window_main.set_transient_for(parent) # If externally called, reparent to external application. self.options = options if options and options.toplevel != None: self.window_main.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG) self.window_main.show() toplevel = gtk.gdk.window_foreign_new(int(options.toplevel)) if (toplevel): self.window_main.window.set_transient_for(toplevel) # Show what we have early self.window_main.show() # used to store the handlers of callbacks self.handlers = [] # Put some life into the user interface: self.init_popcon() self.init_auto_update() self.show_auto_update_level() # Setup the key list self.init_keys() self.show_keys() # Setup the ISV sources list self.init_isv_sources() self.show_isv_sources() self.show_cdrom_sources() # Setup and show the distro elements self.init_distro() self.show_distro() # Show the import/replace sources.list dialog if a file different # to the default sources.list was specified # NOTE: If the file path points to the default sources.list the user # perhaps assumed that s-p would act like a normal editor. # We have got some bug reports from users calling # "sudo software-properties-gtk /etc/apt/sources.list" from the # command line. if file != None and \ os.path.abspath(file) != "%s%s" % (apt_pkg.Config.FindDir("Dir::Etc"), apt_pkg.Config.Find("Dir::Etc::sourcelist")): self.open_file(file)
def __init__(self, path="avahi-discover.ui", root="main_window", domain=None, **kwargs): path = os.path.join(ui_dir, path) gtk.window_set_default_icon_name("network-wired") self.ui = gtk.Builder() self.ui.add_from_file(path) self.ui.connect_signals(self) self.tree_view = self.ui.get_object("tree_view") self.info_label = self.ui.get_object("info_label") self.new()
def create_hamster_window(self): if self.window is None: # load window of activity switcher and todays view self._gui = load_ui_file("today.ui") self.window = self._gui.get_object('hamster-window') self.window.connect("delete_event", self.on_delete_window) gtk.window_set_default_icon_name("hamster-time-tracker") self.new_name = widgets.ActivityEntry() self.new_name.connect("value-entered", self.on_switch_activity_clicked) widgets.add_hint(self.new_name, _("Activity")) self.get_widget("new_name_box").add(self.new_name) self.new_name.connect("changed", self.on_activity_text_changed) self.new_tags = widgets.TagsEntry() self.new_tags.connect("tags_selected", self.on_switch_activity_clicked) widgets.add_hint(self.new_tags, _("Tags")) self.get_widget("new_tags_box").add(self.new_tags) self.tag_box = widgets.TagBox(interactive=False) self.get_widget("tag_box").add(self.tag_box) self.treeview = widgets.FactTree() self.treeview.connect("key-press-event", self.on_todays_keys) self.treeview.connect("edit-clicked", self._open_edit_activity) self.treeview.connect("row-activated", self.on_today_row_activated) self.get_widget("today_box").add(self.treeview) # connect the accelerators self.accel_group = self.get_widget("accelgroup") self.window.add_accel_group(self.accel_group) self._gui.connect_signals(self) # Signal for Redmine issue combo self.get_widget("issue_combo").connect( "changed", self.on_redmine_issue_combo_change) # Signal for Redmine arbitrary issue id entry self.get_widget("arbitrary_issue_id_entry").connect( "changed", self.on_redmine_arbitrary_issue_id_entry_change) # Redmine combos additional setup cell = gtk.CellRendererText() self.get_widget("issue_combo").pack_start(cell, True) self.get_widget("issue_combo").add_attribute(cell, 'text', 0) cell = gtk.CellRendererText() self.get_widget("time_activity_combo").pack_start(cell, True) self.get_widget("time_activity_combo").add_attribute( cell, 'text', 0)
def __init__(self, filename=None): # Default values self.filename = None self.about_dialog = None # use GtkBuilder to build our interface from the XML file builder = gtk.Builder() builder.add_from_file( os.path.join(EasyHybrid_ROOT, 'TextEditor', "TextEditorWindow.glade")) #builder.add_from_string(glade) # get the widgets which will be referenced in callbacks self.window = builder.get_object("window1") self.statusbar = builder.get_object("statusbar1") self.text_view = builder.get_object("textview1") # connect signals builder.connect_signals(self) # set the text view font self.text_view.modify_font(pango.FontDescription("monospace 10")) #self.text_view.modify_font(pango.weight( 'bold')) # set the default icon to the GTK "edit" icon gtk.window_set_default_icon_name(gtk.STOCK_EDIT) # setup and initialize our statusbar self.statusbar_cid = self.statusbar.get_context_id( "Tutorial GTK+ Text Editor") #self.reset_default_status() if filename != None: TheFile = os.path.split(filename) fin = open(filename, "r") text = fin.read() fin.close() # disable the text view while loading the buffer with the text self.text_view.set_sensitive(False) buff = self.text_view.get_buffer() buff.set_text(text) buff.set_modified(False) self.text_view.set_sensitive(True) self.window.set_title(TheFile[-1]) # now we can set the current filename since loading was a success self.filename = filename print filename self.main()
def init_ui(self): gobject.set_application_name("Pithos") gtk.window_set_default_icon_name('pithos') os.environ['PULSE_PROP_media.role'] = 'music' self.playpause_button = self.builder.get_object('playpause_button') self.volume = self.builder.get_object('volume') self.volume.set_property("value", math.pow(float(self.preferences['volume']), 1.0/3.0)) self.statusbar = self.builder.get_object('statusbar1') self.song_menu = self.builder.get_object('song_menu') self.song_menu_love = self.builder.get_object('menuitem_love') self.song_menu_unlove = self.builder.get_object('menuitem_unlove') self.song_menu_ban = self.builder.get_object('menuitem_ban') self.song_menu_unban = self.builder.get_object('menuitem_unban') self.songs_treeview = self.builder.get_object('songs_treeview') self.songs_treeview.set_model(self.songs_model) title_col = gtk.TreeViewColumn() def bgcolor_data_func(column, cell, model, iter): if model.get_value(iter, 0) is self.current_song: bgcolor = column.get_tree_view().get_style().mid[gtk.STATE_NORMAL] else: bgcolor = column.get_tree_view().get_style().base[gtk.STATE_NORMAL] cell.set_property("cell-background-gdk", bgcolor) render_icon = CellRendererAlbumArt() title_col.pack_start(render_icon, expand=False) title_col.add_attribute(render_icon, "icon", 2) title_col.add_attribute(render_icon, "pixbuf", 3) title_col.set_cell_data_func(render_icon, bgcolor_data_func) render_text = gtk.CellRendererText() render_text.props.ellipsize = pango.ELLIPSIZE_END title_col.pack_start(render_text, expand=True) title_col.add_attribute(render_text, "markup", 1) title_col.set_cell_data_func(render_text, bgcolor_data_func) self.songs_treeview.append_column(title_col) self.songs_treeview.connect('button_press_event', self.on_treeview_button_press_event) self.stations_combo = self.builder.get_object('stations') self.stations_combo.set_model(self.stations_model) render_text = gtk.CellRendererText() self.stations_combo.pack_start(render_text, expand=True) self.stations_combo.add_attribute(render_text, "text", 1) self.stations_combo.set_row_separator_func(lambda model, iter: model.get_value(iter, 0) is None) buttonMenu(self.builder.get_object("toolbutton_options"), self.builder.get_object("menu_options"))
def _init_window(self): """Initialize the main window.""" self.window = gtk.Window() self.window.set_icon_name("gaupol") gtk.window_set_default_icon_name("gaupol") self.window.resize(*gaupol.conf.application_window.size) self.window.move(*gaupol.conf.application_window.position) if gaupol.conf.application_window.maximized: self.window.maximize() aeidon.util.connect(self, "window", "delete-event") aeidon.util.connect(self, "window", "window-state-event")
def __init__(self): gobject.GObject.__init__(self) gobject.set_application_name("Meld") gtk.window_set_default_icon_name("meld") self.version = version self.prefs = preferences.MeldPreferences() self.prefs.notify_add(self.on_preference_changed) self.file_filters = self._parse_filters(self.prefs.filters, FilterEntry.SHELL) self.text_filters = self._parse_filters(self.prefs.regexes, FilterEntry.REGEX)
def __init__(self, filename = None): # Default values self.filename = None self.about_dialog = None # use GtkBuilder to build our interface from the XML file builder = gtk.Builder() builder.add_from_file(os.path.join(EasyHybrid_ROOT, 'TextEditor',"TextEditorWindow.glade")) #builder.add_from_string(glade) # get the widgets which will be referenced in callbacks self.window = builder.get_object("window1") self.statusbar = builder.get_object("statusbar1") self.text_view = builder.get_object("textview1") # connect signals builder.connect_signals(self) # set the text view font self.text_view.modify_font(pango.FontDescription("monospace 10")) #self.text_view.modify_font(pango.weight( 'bold')) # set the default icon to the GTK "edit" icon gtk.window_set_default_icon_name(gtk.STOCK_EDIT) # setup and initialize our statusbar self.statusbar_cid = self.statusbar.get_context_id("Tutorial GTK+ Text Editor") #self.reset_default_status() if filename != None: TheFile = os.path.split(filename) fin = open(filename, "r") text = fin.read() fin.close() # disable the text view while loading the buffer with the text self.text_view.set_sensitive(False) buff = self.text_view.get_buffer() buff.set_text(text) buff.set_modified(False) self.text_view.set_sensitive(True) self.window.set_title(TheFile[-1]) # now we can set the current filename since loading was a success self.filename = filename print filename self.main()
def __init__(self): gobject.GObject.__init__(self) gobject.set_application_name("Meld") gtk.window_set_default_icon_name("meld") self.version = version self.prefs = preferences.MeldPreferences() self.prefs.notify_add(self.on_preference_changed) self.file_filters = self._parse_filters(self.prefs.filters, filters.FilterEntry.SHELL) self.text_filters = self._parse_filters(self.prefs.regexes, filters.FilterEntry.REGEX) self.recent_comparisons = recent.RecentFiles(sys.argv[0])
def __init__(self): gtk.window_set_default_icon_name(gtk.STOCK_MEDIA_RECORD) self.tray_image = gtk.Image() self.tray_image.set_from_stock(gtk.STOCK_MEDIA_RECORD, gtk.ICON_SIZE_SMALL_TOOLBAR) self.event_box.add(self.tray_image) self.tooltips = gtk.Tooltips() self.tooltips.set_tip(self.event_box, _("Left click to start screencast. Right click for menu.")) self.tray_container = egg.trayicon.TrayIcon("istanbul") self.tray_container.add(self.event_box) self.event_box.connect("button-press-event", self._trayicon_clicked) self.tray_container.show_all()
def __init__ (self, uid, panel_id, media_button_type): """ Creating the applet's core """ awn.AppletSimple.__init__(self, 'media-icon' + media_button_type[1:], \ uid, panel_id) self.icon_names = {} self.icon_names["--next"] = "media-skip-forward" self.icon_names["--previous"] = "media-skip-backward" self.icon_names["--pp"] = "media-playback-start" self.tooltips = {} self.tooltips["--next"] = _("Next") self.tooltips["--previous"] = _("Previous") self.tooltips["--pp"] = _("Play/Pause") self.funcs = {} self.funcs["--next"] = self.button_next_press self.funcs["--previous"] = self.button_previous_press self.funcs["--pp"] = self.button_pp_press #(Same as desktop files so there's only one string each for i18n) self.desc = {} self.desc["--next"] = _("A media-control applet (Next Track)") self.desc["--previous"] = _("A media-control applet (Previous Track)") self.desc["--pp"] = _("A media-control applet (Play/Pause)") #(Also same as desktop files) self.titles = {} self.titles["--next"] = _("Media Icons Next") self.titles["--previous"] = _("Media Icons Previous") self.titles["--pp"] = _("Media Icons Play/Pause") gtk.window_set_default_icon_name(self.icon_names[media_button_type]) self.media_button_type = media_button_type self.set_icon_name(self.icon_names[media_button_type]) self.what_app() self.set_tooltip_text(self.tooltips[media_button_type]) self.popup_menu = self.create_default_menu() about = gtk.ImageMenuItem(gtk.STOCK_ABOUT) self.popup_menu.append(about) gtk.about_dialog_set_url_hook(self.do_url, None) about.connect("activate", self.show_about) self.connect("clicked", lambda w: self.funcs[self.media_button_type]()) self.connect("context-menu-popup", self.menu_popup)
def __init__(self, uid, panel_id, media_button_type): """ Creating the applet's core """ awn.AppletSimple.__init__(self, 'media-icon' + media_button_type[1:], \ uid, panel_id) self.icon_names = {} self.icon_names["--next"] = "media-skip-forward" self.icon_names["--previous"] = "media-skip-backward" self.icon_names["--pp"] = "media-playback-start" self.tooltips = {} self.tooltips["--next"] = _("Next") self.tooltips["--previous"] = _("Previous") self.tooltips["--pp"] = _("Play/Pause") self.funcs = {} self.funcs["--next"] = self.button_next_press self.funcs["--previous"] = self.button_previous_press self.funcs["--pp"] = self.button_pp_press #(Same as desktop files so there's only one string each for i18n) self.desc = {} self.desc["--next"] = _("A media-control applet (Next Track)") self.desc["--previous"] = _("A media-control applet (Previous Track)") self.desc["--pp"] = _("A media-control applet (Play/Pause)") #(Also same as desktop files) self.titles = {} self.titles["--next"] = _("Media Icons Next") self.titles["--previous"] = _("Media Icons Previous") self.titles["--pp"] = _("Media Icons Play/Pause") gtk.window_set_default_icon_name(self.icon_names[media_button_type]) self.media_button_type = media_button_type self.set_icon_name(self.icon_names[media_button_type]) self.what_app() self.set_tooltip_text(self.tooltips[media_button_type]) self.popup_menu = self.create_default_menu() about = gtk.ImageMenuItem(gtk.STOCK_ABOUT) self.popup_menu.append(about) gtk.about_dialog_set_url_hook(self.do_url, None) about.connect("activate", self.show_about) self.connect("clicked", lambda w: self.funcs[self.media_button_type]()) self.connect("context-menu-popup", self.menu_popup)
def create_hamster_window(self): if self.window is None: # load window of activity switcher and todays view self._gui = load_ui_file("today.ui") self.window = self._gui.get_object('hamster-window') self.window.connect("delete_event", self.on_delete_window) gtk.window_set_default_icon_name("hamster-time-tracker") self.new_name = widgets.ActivityEntry() self.new_name.connect("value-entered", self.on_switch_activity_clicked) widgets.add_hint(self.new_name, _("Activity")) self.get_widget("new_name_box").add(self.new_name) self.new_name.connect("changed", self.on_activity_text_changed) self.new_tags = widgets.TagsEntry() self.new_tags.connect("tags_selected", self.on_switch_activity_clicked) widgets.add_hint(self.new_tags, _("Tags")) self.get_widget("new_tags_box").add(self.new_tags) self.tag_box = widgets.TagBox(interactive = False) self.get_widget("tag_box").add(self.tag_box) self.treeview = widgets.FactTree() self.treeview.connect("key-press-event", self.on_todays_keys) self.treeview.connect("edit-clicked", self._open_edit_activity) self.treeview.connect("row-activated", self.on_today_row_activated) self.get_widget("today_box").add(self.treeview) # connect the accelerators self.accel_group = self.get_widget("accelgroup") self.window.add_accel_group(self.accel_group) self._gui.connect_signals(self) # Signal for Redmine issue combo self.get_widget("issue_combo").connect("changed", self.on_redmine_issue_combo_change) # Signal for Redmine arbitrary issue id entry self.get_widget("arbitrary_issue_id_entry").connect("changed", self.on_redmine_arbitrary_issue_id_entry_change) # Redmine combos additional setup cell = gtk.CellRendererText() self.get_widget("issue_combo").pack_start(cell, True) self.get_widget("issue_combo").add_attribute(cell, 'text',0) cell = gtk.CellRendererText() self.get_widget("time_activity_combo").pack_start(cell, True) self.get_widget("time_activity_combo").add_attribute(cell, 'text',0)
def __init__ (self, paths): assert len (paths) > 0 self.__fields = [] for p in paths: self.__fields.append (FieldData.open (p)) self.builder = gtk.Builder () #dirname = os.path.realpath (os.path.dirname (sys.argv[0])) dirname = os.path.dirname (sys.argv[0]) self.builder.add_from_file (os.path.join (dirname, "show-field.glade")) self.builder.connect_signals (self) for obj in self.builder.get_objects (): name = gtk.Buildable.get_name (obj) assert name not in self.__dict__ self.__dict__[name] = obj plotters = [(AmplitudePlotter, True), (FFTPlotter, False)] if len (self.__fields) == 2: plotters.append ((RelErrorPlotter, True)) self.plotViewer = PlotViewer (plotters, self.__fields) self.plotViewer.onUpdateInfo (self.updateInfo) self.amplBox.pack_start (self.plotViewer, True, True) self.plotViewer.show () self.pol2CB = gtk.CheckButton ("Second polarization") self.plotViewer.checkboxes.pack_start (self.pol2CB, False, False) self.plotViewer.checkboxes.reorder_child (self.pol2CB, 0) self.pol2CB.connect ("toggled", self.__on_pol2cb_toggled) self.pol2CB.show () font_desc = pango.FontDescription('monospace') self.infoLabel.modify_font (font_desc) gtk.window_set_default_icon_name (gtk.STOCK_DIALOG_INFO) self.statusbar_cid = self.statusbar.get_context_id ("Foo bar") self.statusbar.push (self.statusbar_cid, "") self.pol = PolEntry () self.pol.onUpdate (self.plotViewer.setPol) self.paramHBox.pack_start (self.pol) self.pol2 = PolEntry () self.pol2.onUpdate (self.plotViewer.setPol2) self.paramHBox2.pack_start (self.pol2) self.expander2.hide ()
def __init__(self, paths): assert len(paths) > 0 self.__fields = [] for p in paths: self.__fields.append(FieldData.open(p)) self.builder = gtk.Builder() #dirname = os.path.realpath (os.path.dirname (sys.argv[0])) dirname = os.path.dirname(sys.argv[0]) self.builder.add_from_file(os.path.join(dirname, "show-field.glade")) self.builder.connect_signals(self) for obj in self.builder.get_objects(): name = gtk.Buildable.get_name(obj) assert name not in self.__dict__ self.__dict__[name] = obj plotters = [(AmplitudePlotter, True), (FFTPlotter, False)] if len(self.__fields) == 2: plotters.append((RelErrorPlotter, True)) self.plotViewer = PlotViewer(plotters, self.__fields) self.plotViewer.onUpdateInfo(self.updateInfo) self.amplBox.pack_start(self.plotViewer, True, True) self.plotViewer.show() self.pol2CB = gtk.CheckButton("Second polarization") self.plotViewer.checkboxes.pack_start(self.pol2CB, False, False) self.plotViewer.checkboxes.reorder_child(self.pol2CB, 0) self.pol2CB.connect("toggled", self.__on_pol2cb_toggled) self.pol2CB.show() font_desc = pango.FontDescription('monospace') self.infoLabel.modify_font(font_desc) gtk.window_set_default_icon_name(gtk.STOCK_DIALOG_INFO) self.statusbar_cid = self.statusbar.get_context_id("Foo bar") self.statusbar.push(self.statusbar_cid, "") self.pol = PolEntry() self.pol.onUpdate(self.plotViewer.setPol) self.paramHBox.pack_start(self.pol) self.pol2 = PolEntry() self.pol2.onUpdate(self.plotViewer.setPol2) self.paramHBox2.pack_start(self.pol2) self.expander2.hide()
def _set_default_icon(self): # set the icon so that it doesn't flash when the window is # realized in Application.build_window(). # if this isn't a themed Miro, then we use the default icon set ico_path = resources.share_path("icons/hicolor/24x24/apps/miro.png") if app.config.get(prefs.THEME_NAME) != prefs.THEME_NAME.default and app.config.get(options.WINDOWS_ICON): theme_ico_path = resources.theme_path( app.config.get(prefs.THEME_NAME), app.config.get(options.WINDOWS_ICON) ) if os.path.exists(theme_ico_path): ico_path = theme_ico_path gtk.window_set_default_icon_from_file(ico_path) else: gtk.icon_theme_get_default().append_search_path(resources.share_path("icons")) gtk.window_set_default_icon_name("miro") return ico_path
def _set_default_icon(self): # set the icon so that it doesn't flash when the window is # realized in Application.build_window(). # if this isn't a themed Miro, then we use the default icon set ico_path = resources.share_path("icons/hicolor/24x24/apps/miro.png") if ((app.config.get(prefs.THEME_NAME) != prefs.THEME_NAME.default and app.config.get(options.WINDOWS_ICON))): theme_ico_path = resources.theme_path( app.config.get(prefs.THEME_NAME), app.config.get(options.WINDOWS_ICON)) if os.path.exists(theme_ico_path): ico_path = theme_ico_path gtk.window_set_default_icon_from_file(ico_path) else: gtk.icon_theme_get_default().append_search_path( resources.share_path('icons')) gtk.window_set_default_icon_name("miro") return ico_path
def __init__(self): # Default values self.filename= None self.about_dialog = None #self.__gobject_init__() # Using Gtk builder to build the application from XML code which is present in "text.glade" try : builder = gtk.Builder() builder.add_from_file("text.glade") except : self.error_message("Unable to load XML file: text.xml") sys.exit(1) # connects signal # builder.connect_signals({ "on_window_destroy" : gtk.main_quit }) builder.connect_signals(self) # get the widgets which will be referenced in callbacks self.window = builder.get_object("window") self.statusbar = builder.get_object("statusbar") self.text_view = builder.get_object("text_view") # sets the text view background self.text_view.modify_base(gtk.STATE_NORMAL,gtk.gdk.color_parse("Black")) # sets the text view font self.text_view.modify_font(pango.FontDescription("monospace 10")) # sets the text colour self.text_view.modify_text(gtk.STATE_NORMAL,gtk.gdk.color_parse("White")) # sets the default icon to the "texter_icon.jpeg" icon gtk.window_set_default_icon_name("texter_icon.jpeg") # setup and initialize our statusbar self.statusbar_cid = self.statusbar.get_context_id("statusbar") self.reset_default_status() # For Syntax Highlighting self.language_cats = categories[:] self.languages = [] self.add_languages(languages)
def main(): gobject.threads_init() gtk.window_set_default_icon_name(gtk.STOCK_FILE) settings = gtk.settings_get_default() settings.props.gtk_toolbar_style = gtk.TOOLBAR_ICONS settings.props.gtk_toolbar_icon_size = gtk.ICON_SIZE_SMALL_TOOLBAR ## proxy settings proxies = urllib.getproxies() if 'http' in proxies: webkit_set_proxy_uri(proxies['http']) elif 'https' in proxies: webkit_set_proxy_uri(proxies['https']) ## if sys.argv[1:]: url = sys.argv[1] if os.path.exists(url): url = 'file://' + os.path.abspath(url) webbrowser = BrowserWindow(url) else: webbrowser = BrowserWindow(url = 'about:blank') gtk.main() pass
def run(args, datadir): ''' Executes the properties dialog. ''' import logging # Support full tracing when --debug switch is passed: if '--debug' in args or '-d' in args: logging.getLogger().setLevel(logging.NOTSET) # Integrate DBus with GLib main loop from dbus.mainloop.glib import DBusGMainLoop DBusGMainLoop(set_as_default=True) # Initialize user interface import pygtk pygtk.require('2.0') from gettext import gettext as _ from gnome_lirc_properties import ui import gobject, gtk, gtk.gdk, os.path # Setup defaut properties: gobject.threads_init() gobject.set_application_name(_('Infrared Remote Control Properties')) gtk.window_set_default_icon_name('gnome-lirc-properties') # Enable thread support: gtk.gdk.threads_init() # Load the user interface: ui_filename = os.path.join(datadir, 'gnome-lirc-properties.ui') builder = gtk.Builder() builder.add_from_file(ui_filename) return ui.RemoteControlProperties(builder, datadir).run()
def main (args): import gettext import locale import sys import pygtk; pygtk.require('2.0'); import gtk import maindialog import lockdownappliergconf import config try: locale.setlocale (locale.LC_ALL, "") except locale.Error: print >> sys.stderr, "Warning: unsupported locale" gettext.install (config.PACKAGE, config.LOCALEDIR) gtk.window_set_default_icon_name ("pessulus") applier = lockdownappliergconf.PessulusLockdownApplierGconf () if not applier.supports_normal_settings () and not applier.supports_mandatory_settings (): dialog = gtk.MessageDialog (type = gtk.MESSAGE_ERROR, buttons = gtk.BUTTONS_CLOSE, message_format = _("Cannot contact the GConf server")) dialog.format_secondary_text (_("This usually happens when running this application with 'su' instead of 'su -'.\nIf this is not the case, you can look at the output of the application to get more details.")) # this is a dialog with no parent dialog.set_skip_taskbar_hint (False) dialog.set_title (_("Lockdown Editor")) dialog.run () return dialog = maindialog.PessulusMainDialog (applier) gtk.main ()
def __init__(self, datadir, version, argv): self.file_path = datadir self.version = version self.editor = MenuEditor() gtk.window_set_default_icon_name('alacarte') self.tree = gtk.Builder() self.tree.set_translation_domain(config.GETTEXT_PACKAGE) self.tree.add_from_file('/usr/lib/cinnamon-menu-editor/cinnamon-menu-editor.ui') self.tree.connect_signals(self) self.setupMenuTree() self.setupItemTree() self.tree.get_object('edit_delete').set_sensitive(False) self.tree.get_object('edit_revert_to_original').set_sensitive(False) self.tree.get_object('edit_properties').set_sensitive(False) self.tree.get_object('move_up_button').set_sensitive(False) self.tree.get_object('move_down_button').set_sensitive(False) self.tree.get_object('new_separator_button').set_sensitive(False) accelgroup = gtk.AccelGroup() keyval, modifier = gtk.accelerator_parse('<Ctrl>Z') accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_mainwindow_undo) keyval, modifier = gtk.accelerator_parse('<Ctrl><Shift>Z') accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_mainwindow_redo) self.tree.get_object('mainwindow').add_accel_group(accelgroup)
def __init__(self, applet): self.applet = applet self.size = 24 self.menu = gtk.Menu() self.tooltips = gtk.Tooltips() self.image = gtk.Image() self.image.set_from_pixbuf(gtk.IconTheme.load_icon(gtk.icon_theme_get_default(), "glipper", self.size - 2, 0)) self.tooltips.set_tip(self.applet, _("Glipper - Popup shortcut: ") + get_glipper_keybinder().get_key_combination()) glipper.GCONF_CLIENT.notify_add(glipper.GCONF_MARK_DEFAULT_ENTRY, lambda x, y, z, a: self.update_menu(get_glipper_history().get_history())) glipper.GCONF_CLIENT.notify_add(glipper.GCONF_MAX_ITEM_LENGTH, lambda x, y, z, a: self.update_menu(get_glipper_history().get_history())) gtk.window_set_default_icon_name("glipper") get_glipper_keybinder().connect('activated', self.on_key_combination_press) get_glipper_keybinder().connect('changed', self.on_key_combination_changed) get_glipper_history().connect('changed', self.on_history_changed) get_glipper_plugins_manager().load() get_glipper_history().load() get_glipper_plugins_manager().connect('menu-items-changed', self.on_plugins_menu_items_changed) self.applet.connect('size-allocate', self.on_size_allocate) self.applet.connect('button-press-event', self.on_clicked) self.applet.connect('destroy', self.on_destroy) self.applet.setup_menu_from_file ( glipper.SHARED_DATA_DIR, "Glipper.xml", None, [ ("Properties", self.on_properties), ("Help", self.on_help), ("About", self.on_about), ("Plugins", self.on_plugins), ]) self.applet.add(self.image) self.applet.set_applet_flags(gnomeapplet.EXPAND_MINOR) self.applet.show_all()
def __init__(self, languagefrom="de", languageto="en"): gtk.StatusIcon.__init__(self) self._langfrom = languagefrom self._langto = languageto if libtranstray.is_installed(): self.set_from_icon_name(self.APP_ICON) gtk.window_set_default_icon_name(self.get_icon_name()) else: self.set_from_file("%s.svg" % self.APP_ICON) gtk.window_set_default_icon(self.get_pixbuf()) self.set_visible(True) self.connect('activate', self._on_activate) self.connect('popup-menu', self._on_popup_menu) self._create_right_menu() self._nl = NetworkListener() #monitor the selection clipboard self._clip_selection = gtk.clipboard_get("PRIMARY") pynotify.init(self.APP_NAME)
def __init__(self): self.engine = ContactEngine.ContactDB() gtk.window_set_default_icon_name("address-book") self.widgets = gtk.glade.XML(find_path("arkadas.glade")) signals = {} for attr in dir(self.__class__): signals[attr] = getattr(self, attr) self.widgets.signal_autoconnect(signals) self.tooltips = gtk.Tooltips() self.clipboard = gtk.Clipboard() self.load_fallbackprefs() self.load_prefs() self.load_widgets() self.build_list() self.build_table() self.build_prefs() self.window.set_app_paintable(True) self.window.show_all() def load_db(): self.engine.load(os.path.join(self.data_dir, "contacts.db")) self.clear() self.load_groups() gobject.idle_add(load_db) args = sys.argv[1:] if args and HAVE_VOBJECT: if question(_("Import contacts to the contactlist?"), self.window): for arg in args: for contact in import_vcard(arg, self.engine, self.photo_dir): self.add_to_list(contact, True)
def __init__(self): gtk.Window.__init__(self) _logger.debug("Entered in __init__") self.keyboard = None self.set_accept_focus(False) self.grab_remove() self.set_keep_above(True) gtk.window_set_default_icon_name("onboard") self.set_title(_("Onboard")) config.geometry_notify_add(self.resize) self.set_default_size(config.keyboard_width, config.keyboard_height) config.position_notify_add(self.move) self.move(config.x_position, config.y_position) self.connect("window-state-event", self.cb_state_change) self.icp = IconPalette() self.icp.connect_object("activated", gtk.Window.deiconify, self) self.show_all() if config.start_minimized: self.iconify() _logger.debug("Leaving __init__")
month=selected_date.month, day=selected_date.day) fact.end_time = fact.end_time.replace(year=selected_date.year, month=selected_date.month, day=selected_date.day) new_id = runtime.storage.add_fact(fact) # You can do that?! - copy/pasted an activity trophies.unlock("can_do_that") if new_id: self.fact_tree.select_fact(new_id) if __name__ == "__main__": gtk.window_set_default_icon_name("hamster-applet") window = gtk.Window() window.set_title("Hamster - reports") window.set_size_request(800, 600) overview = OverviewBox() window.add(overview) window.connect("delete_event", lambda *args: gtk.main_quit()) window.show_all() start_date = dt.date.today() - dt.timedelta(days=30) end_date = dt.date.today() facts = runtime.storage.get_facts(start_date, end_date) overview.search(start_date, end_date, facts) gtk.main()
def __init__(self, th, port, server): self.th = th self.port = port self.server = server # we need this to quit the server when closing main window gtk.window_set_default_icon_name('thawab') gtk.Window.__init__(self) self.set_title(_('Thawab')) self.set_default_size(600, 480) self.import_w = None self.fixes_w = None self.ix_w = ThIndexerWindow(self) vb = gtk.VBox(False, 0) self.add(vb) tools = gtk.Toolbar() vb.pack_start(tools, False, False, 2) self._content = ContentPane("http://127.0.0.1:%d/" % port, _("Thawab")) vb.pack_start(self._content, True, True, 2) b = gtk.ToolButton(gtk.STOCK_NEW) b.connect('clicked', lambda bb: self._content.new_tab()) b.set_tooltip_text(_("Open a new tab")) tools.insert(b, -1) # TODO: add navigation buttons (back, forward ..etc.) and zoom buttons tools.insert(gtk.SeparatorToolItem(), -1) img = gtk.Image() img.set_from_stock(gtk.STOCK_CONVERT, gtk.ICON_SIZE_BUTTON) b = gtk.ToolButton(icon_widget=img, label=_("Import")) b.set_tooltip_text(_("Import .bok files")) b.connect('clicked', self.import_cb) tools.insert(b, -1) img = gtk.Image() img.set_from_stock(gtk.STOCK_FIND_AND_REPLACE, gtk.ICON_SIZE_BUTTON) b = gtk.ToolButton(icon_widget=img, label=_("Index")) b.set_is_important(True) b.set_tooltip_text(_("Create search index")) b.connect('clicked', lambda *a: self.ix_w.show_all()) tools.insert(b, -1) tools.insert(gtk.SeparatorToolItem(), -1) img = gtk.Image() img.set_from_stock(gtk.STOCK_ZOOM_IN, gtk.ICON_SIZE_BUTTON) b = gtk.ToolButton(icon_widget=img, label=_("Zoom in")) b.set_is_important(True) b.set_tooltip_text(_("Makes things appear bigger")) b.connect('clicked', lambda a: self._do_in_current_view("zoom_in")) tools.insert(b, -1) img = gtk.Image() img.set_from_stock(gtk.STOCK_ZOOM_OUT, gtk.ICON_SIZE_BUTTON) b = gtk.ToolButton(icon_widget=img, label=_("Zoom out")) b.set_tooltip_text(_("Makes things appear smaller")) b.connect('clicked', lambda a: self._do_in_current_view("zoom_out")) tools.insert(b, -1) img = gtk.Image() img.set_from_stock(gtk.STOCK_ZOOM_100, gtk.ICON_SIZE_BUTTON) b = gtk.ToolButton(icon_widget=img, label=_("1:1 Zoom")) b.set_tooltip_text(_("restore original zoom factor")) b.connect('clicked', lambda a: self._do_in_current_view("set_zoom_level", 1.0)) tools.insert(b, -1) tools.insert(gtk.SeparatorToolItem(), -1) img = gtk.Image() img.set_from_stock(gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_BUTTON) b = gtk.ToolButton(icon_widget=img, label=_("Fixes")) b.set_is_important(True) b.set_tooltip_text(_("Misc Fixes")) b.connect('clicked', self.fixes_cb) tools.insert(b, -1) tools.insert(gtk.SeparatorToolItem(), -1) img = gtk.Image() img.set_from_stock(gtk.STOCK_HELP, gtk.ICON_SIZE_BUTTON) b = gtk.ToolButton(icon_widget=img, label=_("Help")) b.set_tooltip_text(_("Show user manual")) b.connect( 'clicked', lambda a: self._content.new_tab( "http://127.0.0.1:%d/_theme/manual/manual.html" % port)) tools.insert(b, -1) self._content.new_tab() self.connect("delete_event", self.quit) self.drag_dest_set(gtk.DEST_DEFAULT_ALL, targets_l, (1 << 5) - 1) self.connect('drag-data-received', self.drop_data_cb) self.show_all()
config.askpass_package = askpass_package import virtManager.guidiff virtManager.guidiff.is_gui(True) # Now we've got basic environment up & running we can fork if not options.nofork and not options.debug: drop_tty() drop_stdio() # Ignore SIGHUP, otherwise a serial console closing drops the whole app signal.signal(signal.SIGHUP, signal.SIG_IGN) from virtManager.engine import vmmEngine gtk.window_set_default_icon_name(appname) if options.show and options.uri == None: raise optparse.OptionValueError("can't use --show-* options " "without --connect") engine = vmmEngine() if not options.nodbus: try: managerObj = dbus_config(engine) if managerObj: # yes, we exit completely now - remote service is in charge logging.debug("Connected to already running instance.") show_remote(managerObj, options.show, options.uri, options.uuid)
month=selected_date.month, day=selected_date.day) fact.end_time = fact.end_time.replace(year=selected_date.year, month=selected_date.month, day=selected_date.day) new_id = runtime.storage.add_fact(fact) # You can do that?! - copy/pasted an activity trophies.unlock("can_do_that") if new_id: self.fact_tree.select_fact(new_id) if __name__ == "__main__": gtk.window_set_default_icon_name("hamster-time-tracker") window = gtk.Window() window.set_title("Hamster - reports") window.set_size_request(800, 600) overview = OverviewBox() window.add(overview) window.connect("delete_event", lambda *args: gtk.main_quit()) window.show_all() start_date = dt.date.today() - dt.timedelta(days=30) end_date = dt.date.today() facts = runtime.storage.get_facts(start_date, end_date) overview.search(start_date, end_date, facts) gtk.main()
SAMPLE_RATES = [8000, 11025, 22050, 32000, 44100, 48000, 96000, 192000] PLAYBACK_BACKENDS = [(_("Autodetect"), "autoaudiosink"), (_("Use GNOME Settings"), "gconfaudiosink"), ("ALSA", "alsasink"), ("OSS", "osssink"), ("JACK", "jackaudiosink"), ("PulseAudio", "pulsesink"), ("Direct Sound", "directsoundsink"), ("Core Audio", "osxaudiosink")] CAPTURE_BACKENDS = [(_("GNOME Settings"), "gconfaudiosrc"), ("ALSA", "alsasrc"), ("OSS", "osssrc"), ("JACK", "jackaudiosrc"), ("PulseAudio", "pulsesrc"), ("Direct Sound", "dshowaudiosrc"), ("Core Audio", "osxaudiosrc")] """ Default Instruments """ DEFAULT_INSTRUMENTS = [] """ init Settings """ settings = Settings() """ Cache Instruments """ gobject.idle_add(idleCacheInstruments) gobject.set_application_name(_("Jokosher Audio Editor")) gobject.set_prgname(LOCALE_APP) gtk.window_set_default_icon_name("jokosher") # environment variable for pulseaudio type os.environ["PULSE_PROP_media.role"] = "production" # I have decided that Globals.py is a boring source file. So, here is a little # joke. What does the tax office and a pelican have in common? They can both stick # their bills up their arses. Har har har.
from glchess.defaults import * import LaunchpadIntegration # Stop PyGTK from catching exceptions os.environ['PYGTK_FATAL_EXCEPTIONS'] = '1' import glchess.config import glchess.ui import glchess.chess.board import dialogs import log import chessview import network # Mark all windows with our icon gtk.window_set_default_icon_name(ICON_NAME) def loadUIFile(name, root=None): ui = gtk.Builder() ui.set_translation_domain(DOMAIN) ui.add_from_file(os.path.join(UI_DIR, name)) return ui class GLibTimer(glchess.ui.Timer): """ """ # FIXME: time.time() is _not_ monotonic so this is not really safe at all...
for opt, args in opts: if opt in ("-w", "--window"): standalone = True elif opt in ("-s", "--start"): start_window = args elif opt in ("-t", "--trace-sql"): runtime.trace_sql = True except getopt.GetoptError: usage() print "Starting nevertheless, because applet dies otherwise (TODO)" gtk.window_set_default_icon_name("hamster-applet") if standalone: gnome.init(defs.PACKAGE, defs.VERSION) app = gtk.Window(gtk.WINDOW_TOPLEVEL) app.set_title(_(u"Time Tracker")) applet = gnomeapplet.Applet() applet_factory(applet, None) applet.reparent(app) app.show_all() gtk.main() elif start_window:
def set_default_icon_name(cls, icon_name): window_set_default_icon_name(icon_name)
def __init__(self, exaile): """ Initializes the GUI @param exaile: The Exaile instance """ from xlgui import icons, main, panels, tray, progress gtk.gdk.set_program_class("Exaile") self.exaile = exaile self.first_removed = False self.tray_icon = None self.builder = gtk.Builder() self.builder.add_from_file(xdg.get_data_path('ui', 'main.ui')) self.progress_box = self.builder.get_object('progress_box') self.progress_manager = progress.ProgressManager(self.progress_box) for name in ('exaile', 'exaile-pause', 'exaile-play', 'folder-music', 'audio-x-generic', 'office-calendar', 'extension', 'music-library', 'artist', 'genre'): icons.MANAGER.add_icon_name_from_directory( name, xdg.get_data_path('images')) gtk.window_set_default_icon_name('exaile') for name in ('dynamic', 'repeat', 'shuffle'): icon_name = 'media-playlist-%s' % name icons.MANAGER.add_icon_name_from_directory( icon_name, xdg.get_data_path('images')) logger.info("Using GTK+ %s" % '.'.join(map(str, gtk.gtk_version))) logger.info("Loading main window...") self.main = main.MainWindow(self, self.builder, exaile.collection) if self.exaile.options.StartMinimized: self.main.window.iconify() self.play_toolbar = self.builder.get_object('play_toolbar') panel_notebook = self.builder.get_object('panel_notebook') self.panel_notebook = panels.PanelNotebook(exaile, self) self.device_panels = {} # add the device panels for device in self.exaile.devices.list_devices(): if device.connected: self.add_device_panel(None, None, device) logger.info("Connecting panel events...") self.main._connect_panel_events() guiutil.gtk_widget_replace(panel_notebook, self.panel_notebook) if settings.get_option('gui/use_tray', False): self.tray_icon = tray.TrayIcon(self.main) from xl import event event.add_callback(self.add_device_panel, 'device_connected') event.add_callback(self.remove_device_panel, 'device_disconnected') event.add_callback(self.on_gui_loaded, 'gui_loaded') logger.info("Done loading main window...") Main._main = self
def __init__(self, conduitApplication, moduleManager, typeConverter, syncManager): """ Constructs the mainwindow. Throws up a splash screen to cover the most time consuming pieces """ #add some additional dirs to the icon theme search path so that #modules can provider their own icons icon_dirs = [ conduit.SHARED_DATA_DIR, conduit.SHARED_MODULE_DIR, os.path.join(conduit.SHARED_DATA_DIR, "icons"), os.path.join(conduit.USER_DIR, "modules") ] for i in icon_dirs: gtk.icon_theme_get_default().prepend_search_path(i) gtk.window_set_default_icon_name("conduit") signals = { "on_mainwindow_delete": self.on_window_closed, "on_mainwindow_state_event": self.on_window_state_event, "on_synchronize_activate": self.on_synchronize_all_clicked, "on_cancel_activate": self.on_cancel_all_clicked, "on_quit_activate": self.on_window_closed, "on_clear_canvas_activate": self.on_clear_canvas, "on_preferences_activate": self.on_conduit_preferences, "on_about_activate": self.on_about_conduit, "on_contents_activate": self.on_help, "on_save1_activate": self.save_settings, } self.conduitApplication = conduitApplication self.builder = _GtkBuilderWrapper(conduit.SHARED_DATA_DIR, "conduit.ui") self.builder.connect_signals(signals) #type converter and sync manager self.type_converter = typeConverter self.sync_manager = syncManager #Initialize the mainWindow self.mainWindow = self.builder.get_object("MainWindow") #Enable RGBA colormap if conduit.GLOBALS.settings.get("gui_use_rgba_colormap") == True: screen = self.mainWindow.get_screen() colormap = screen.get_rgba_colormap() if colormap: gtk.widget_set_default_colormap(colormap) self.mainWindow.set_position(gtk.WIN_POS_CENTER) title = "Conduit" if conduit.IS_DEVELOPMENT_VERSION: title = title + _(" - %s (Development Version)") % conduit.VERSION if not conduit.IS_INSTALLED: title = title + _(" - Running Uninstalled") self.mainWindow.set_title(title) #Configure canvas self.canvasSW = self.builder.get_object("canvasScrolledWindow") self.hpane = self.builder.get_object("hpaned1") #start up the canvas msg = MsgArea.MsgAreaController() self.builder.get_object("mainVbox").pack_start(msg, False, False) self.canvas = Canvas.Canvas(parentWindow=self.mainWindow, typeConverter=self.type_converter, syncManager=self.sync_manager, gtkbuilder=self.builder, msg=msg) self.canvasSW.add(self.canvas) self.canvas.connect('drag-drop', self.drop_cb) self.canvas.connect("drag-data-received", self.drag_data_received_data) # Populate the tree model self.dataproviderTreeModel = Tree.DataProviderTreeModel() dataproviderScrolledWindow = self.builder.get_object("scrolledwindow2") self.dataproviderTreeView = Tree.DataProviderTreeView( self.dataproviderTreeModel) dataproviderScrolledWindow.add(self.dataproviderTreeView) #Set up the expander used for resolving sync conflicts self.conflictResolver = ConflictResolver.ConflictResolver(self.builder) #Preferences manager self.preferences = PreferencesWindow(self.builder) #add the preconfigured Conduit menu if conduit.GLOBALS.settings.get("gui_show_hints"): self.preconfiguredConduitsMenu = _PreconfiguredConduitMenu() self.builder.get_object("file_menu").insert( self.preconfiguredConduitsMenu.item, 3) else: self.preconfiguredConduitsMenu = None #if running a development version, add some developer specific links #to the help menu if conduit.IS_DEVELOPMENT_VERSION: helpMenu = self.builder.get_object("help_menu") developersMenuItem = gtk.ImageMenuItem(_("Developers")) developersMenuItem.set_image( gtk.image_new_from_icon_name("applications-development", gtk.ICON_SIZE_MENU)) developersMenu = gtk.Menu() developersMenuItem.set_submenu(developersMenu) helpMenu.prepend(developersMenuItem) for name, url in DEVELOPER_WEB_LINKS: item = gtk.ImageMenuItem(_(name)) item.set_image( gtk.image_new_from_icon_name("applications-internet", gtk.ICON_SIZE_MENU)) item.connect("activate", self.on_developer_menu_item_clicked, _(name), url) developersMenu.append(item) #final GUI setup self.cancelSyncButton = self.builder.get_object('cancel') self.hpane.set_position( conduit.GLOBALS.settings.get("gui_hpane_postion")) self.dataproviderTreeView.set_expand_rows() self.window_state = 0 log.info("Main window constructed (thread: %s)" % thread.get_ident())
def __init__(self, controller, model): self._controller = controller self._model = model gtk.window_set_default_icon_name("deskbar-applet")
from subscription_manager.gui.about import AboutDialog from subscription_manager.gui.allsubs import AllSubscriptionsTab from subscription_manager.gui.importsub import ImportSubDialog from subscription_manager.gui.installedtab import InstalledProductsTab from subscription_manager.gui.mysubstab import MySubscriptionsTab from subscription_manager.gui.preferences import PreferencesDialog from subscription_manager.gui.utils import handle_gui_exception, linkify from subscription_manager.gui.reposgui import RepositoriesDialog from subscription_manager.overrides import Overrides _ = gettext.gettext gettext.textdomain("rhsm") gtk.glade.bindtextdomain("rhsm") gtk.window_set_default_icon_name("subscription-manager") log = logging.getLogger('rhsm-app.' + __name__) cfg = config.initConfig() ONLINE_DOC_URL_TEMPLATE = "https://access.redhat.com/knowledge/docs/Red_Hat_Subscription_Management/?locale=%s" ONLINE_DOC_FALLBACK_URL = "https://access.redhat.com/knowledge/docs/Red_Hat_Subscription_Management/" class Backend(object): """ Wrapper for sharing UEP connections to Candlepin. Reference to a Backend object will be passed around UI components, so the UEP connection it contains can be modified/recreated and all
def main(): # When changing this, make sure to update configure.ac as well if sys.version_info < (2, 6, 1): message = "Reinteract requires Python 2.6.1 or newer" print >> sys.stderr, message try: dialog = gtk.MessageDialog(buttons=gtk.BUTTONS_OK, type=gtk.MESSAGE_ERROR, message_format=message) dialog.run() finally: sys.exit(1) # When launched from the finder on OS X, the command line will have a # -psx (process serial number) argument. Strip that out. sys.argv = filter(lambda x: not x.startswith("-psn"), sys.argv) parser = OptionParser() parser.add_option("-u", "--ui", choices=("standard", "mini"), default="standard", help="the user interface mode (standard or mini)") parser.add_option("-d", "--debug", action="store_true", help="enable internal debug messages") options, args = parser.parse_args() if options.debug: logging.basicConfig(level=logging.DEBUG) global_settings.mini_mode = options.ui == "mini" user_ext_path = os.path.expanduser( os.path.join('~', '.reinteract', 'modules')) if os.path.exists(user_ext_path): sys.path[0:0] = [user_ext_path] gtk.window_set_default_icon_name("reinteract") glib.set_application_name("Reinteract") if len(args) > 0: if sys.platform == 'win32': args = [a.decode("mbcs") for a in args] else: args = [a.decode("UTF-8") for a in args] if options.ui == "standard": for arg in args: application.open_path(os.path.abspath(arg)) if len(application.windows) == 0: # nothing opened successfully sys.exit(1) else: # mini-mode, can specify one notebook if len(args) > 1: print >> sys.stderr, "Ignoring extra command line arguments." absolute = os.path.abspath(args[0].decode("UTF-8")) # We look to see if we can find the specified notebook so that we can # produce a good error message instead of opening a worksheet window notebook_path, relative = application.find_notebook_path(absolute) if not notebook_path: if os.path.isdir(absolute): error_message = "'%s' is not a Reinteract notebook" % args[ 0] else: error_message = "'%s' is not inside a Reinteract notebook" % args[ 0] dialog = gtk.MessageDialog(buttons=gtk.BUTTONS_OK, type=gtk.MESSAGE_ERROR, message_format=error_message) dialog.run() sys.exit(1) if not application.open_path(absolute): sys.exit(1) else: recent_notebooks = application.state.get_recent_notebooks() window = None for notebook in recent_notebooks: notebook_dir = notebook.path try: window = application.open_notebook(notebook_dir) except OSError: pass else: break if window is None: notebook_dir = os.path.expanduser( os.path.join(global_settings.notebooks_dir, "Main")) if not os.path.exists(notebook_dir): window = application.create_notebook( notebook_dir, description= "Notebook for scratch work.\nCreate worksheets here if they are not part of a larger project, or for quick experiments." ) else: window = application.open_notebook(notebook_dir) # This really should be a more general check for "is writeable" if notebook_dir != global_settings.examples_dir: window.add_initial_worksheet() gtk.main()
def __init__(self): gladefile = paths.ui_dir("meldapp.glade") gtk.window_set_default_icon_name("icon") if getattr(gobject, "pygobject_version", ()) >= (2, 16, 0): gobject.set_application_name("Meld") gnomeglade.Component.__init__(self, gladefile, "meldapp") self.prefs = MeldPreferences() actions = ( ("FileMenu", None, _("_File")), ("New", gtk.STOCK_NEW, _("_New..."), "<control>N", _("Start a new comparison"), self.on_menu_file_new_activate), ("Save", gtk.STOCK_SAVE, None, None, _("Save the current file"), self.on_menu_save_activate), ("SaveAs", gtk.STOCK_SAVE_AS, None, "<control><shift>S", "Save the current file with a different name", self.on_menu_save_as_activate), ("Close", gtk.STOCK_CLOSE, None, None, _("Close the current file"), self.on_menu_close_activate), ("Quit", gtk.STOCK_QUIT, None, None, _("Quit the program"), self.on_menu_quit_activate), ("EditMenu", None, _("_Edit")), ("Undo", gtk.STOCK_UNDO, None, "<control>Z", _("Undo the last action"), self.on_menu_undo_activate), ("Redo", gtk.STOCK_REDO, None, "<control><shift>Z", _("Redo the last undone action"), self.on_menu_redo_activate), ("Cut", gtk.STOCK_CUT, None, None, _("Cut the selection"), self.on_menu_cut_activate), ("Copy", gtk.STOCK_COPY, None, None, _("Copy the selection"), self.on_menu_copy_activate), ("Paste", gtk.STOCK_PASTE, None, None, _("Paste the clipboard"), self.on_menu_paste_activate), ("Find", gtk.STOCK_FIND, None, None, _("Search for text"), self.on_menu_find_activate), ("FindNext", None, _("Find Ne_xt"), "<control>G", _("Search forwards for the same text"), self.on_menu_find_next_activate), ("Replace", gtk.STOCK_FIND_AND_REPLACE, _("_Replace"), "<control>H", _("Find and replace text"), self.on_menu_replace_activate), ("Down", gtk.STOCK_GO_DOWN, None, "<control>D", _("Go to the next difference"), self.on_menu_edit_down_activate), ("Up", gtk.STOCK_GO_UP, None, "<control>E", _("Go to the previous difference"), self.on_menu_edit_up_activate), ("Preferences", gtk.STOCK_PREFERENCES, _("Prefere_nces"), None, _("Configure the application"), self.on_menu_preferences_activate), ("ViewMenu", None, _("_View")), ("FileStatus", None, _("File status")), ("VcStatus", None, _("Version status")), ("FileFilters", None, _("File filters")), ("Stop", gtk.STOCK_STOP, None, "Escape", _("Stop the current action"), self.on_toolbar_stop_clicked), ("Refresh", gtk.STOCK_REFRESH, None, "<control>R", _("Refresh the view"), self.on_menu_refresh_activate), ("Reload", gtk.STOCK_REFRESH, _("Reload"), "<control><shift>R", _("Reload the comparison"), self.on_menu_reload_activate), ("HelpMenu", None, _("_Help")), ("Help", gtk.STOCK_HELP, _("_Contents"), "F1", _("Open the Meld manual"), self.on_menu_help_activate), ("BugReport", gtk.STOCK_DIALOG_WARNING, _("Report _Bug"), None, _("Report a bug in Meld"), self.on_menu_help_bug_activate), ("About", gtk.STOCK_ABOUT, None, None, _("About this program"), self.on_menu_about_activate), ) toggleactions = (("Fullscreen", None, _("Full Screen"), "F11", _("View the comparison in full screen"), self.on_action_fullscreen_toggled, False), ("ToolbarVisible", None, _("_Toolbar"), None, _("Show or hide the toolbar"), self.on_menu_toolbar_toggled, self.prefs.toolbar_visible), ("StatusbarVisible", None, _("_Statusbar"), None, _("Show or hide the statusbar"), self.on_menu_statusbar_toggled, self.prefs.statusbar_visible)) ui_file = paths.ui_dir("meldapp-ui.xml") self.actiongroup = gtk.ActionGroup('MainActions') self.actiongroup.set_translation_domain("meld") self.actiongroup.add_actions(actions) self.actiongroup.add_toggle_actions(toggleactions) self.ui = gtk.UIManager() self.ui.insert_action_group(self.actiongroup, 0) self.ui.add_ui_from_file(ui_file) self.ui.connect("connect-proxy", self._on_uimanager_connect_proxy) self.ui.connect("disconnect-proxy", self._on_uimanager_disconnect_proxy) for menuitem in ("Save", "Undo"): self.actiongroup.get_action(menuitem).props.is_important = True self.widget.add_accel_group(self.ui.get_accel_group()) self.menubar = self.ui.get_widget('/Menubar') self.toolbar = self.ui.get_widget('/Toolbar') self.appvbox.pack_start(self.menubar, expand=False) self.appvbox.pack_start(self.toolbar, expand=False) # TODO: should possibly use something other than doc_status self._menu_context = self.doc_status.get_context_id("Tooltips") self.statusbar = MeldStatusBar(self.task_progress, self.task_status, self.doc_status) self.widget.drag_dest_set( gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_HIGHLIGHT | gtk.DEST_DEFAULT_DROP, [('text/uri-list', 0, 0)], gtk.gdk.ACTION_COPY) if gnomevfs_available: self.widget.connect('drag_data_received', self.on_widget_drag_data_received) self.toolbar.set_style(self.prefs.get_toolbar_style()) self.toolbar.props.visible = self.prefs.toolbar_visible self.status_box.props.visible = self.prefs.statusbar_visible self.prefs.notify_add(self.on_preference_changed) self.idle_hooked = 0 self.scheduler = task.LifoScheduler() self.scheduler.connect("runnable", self.on_scheduler_runnable) self.widget.set_default_size(self.prefs.window_size_x, self.prefs.window_size_y) self.ui.ensure_update() self.widget.show() self.widget.connect('focus_in_event', self.on_focus_change) self.widget.connect('focus_out_event', self.on_focus_change)
rightWidget.hide_all() self.LeftPane.remove(leftWidget) self.RightPane.remove(rightWidget) if self.CurrentPage != self.MainPage: leftWidget.destroy() rightWidget.destroy() self.LeftPane.pack_start(page.LeftWidget, True, True) self.RightPane.pack_start(page.RightWidget, True, True) self.CurrentPage = page self.show_all() def BackToMain(self, widget): self.SetPage(self.MainPage) self.MainPage.filterEntry.grab_focus() def RefreshPage(self, updatedPlugin): currentPage = self.CurrentPage if isinstance(currentPage, PluginPage) and currentPage.Plugin: for basePlugin in updatedPlugin.GetExtensionBasePlugins(): # If updatedPlugin is an extension plugin and a base plugin # is currently being displayed, then update its current page if currentPage.Plugin.Name == basePlugin.Name: if currentPage.CheckDialogs(basePlugin, self): currentPage.RefreshPage(basePlugin, self) break gtk.window_set_default_icon_name('ccsm')
def __init__(self, conduitApplication, moduleManager, typeConverter, syncManager): """ Constructs the mainwindow. Throws up a splash screen to cover the most time consuming pieces """ #add some additional dirs to the icon theme search path so that #modules can provider their own icons icon_dirs = [ conduit.SHARED_DATA_DIR, conduit.SHARED_MODULE_DIR, os.path.join(conduit.SHARED_DATA_DIR,"icons"), os.path.join(conduit.USER_DIR, "modules") ] for i in icon_dirs: gtk.icon_theme_get_default().prepend_search_path(i) gtk.window_set_default_icon_name("conduit") signals = { "on_mainwindow_delete" : self.on_window_closed, "on_mainwindow_state_event" : self.on_window_state_event, "on_synchronize_activate" : self.on_synchronize_all_clicked, "on_cancel_activate" : self.on_cancel_all_clicked, "on_quit_activate" : self.on_window_closed, "on_clear_canvas_activate" : self.on_clear_canvas, "on_preferences_activate" : self.on_conduit_preferences, "on_about_activate" : self.on_about_conduit, "on_contents_activate" : self.on_help, "on_save1_activate" : self.save_settings, } self.conduitApplication = conduitApplication self.builder = _GtkBuilderWrapper(conduit.SHARED_DATA_DIR, "conduit.ui") self.builder.connect_signals(signals) #type converter and sync manager self.type_converter = typeConverter self.sync_manager = syncManager #Initialize the mainWindow self.mainWindow = self.builder.get_object("MainWindow") #Enable RGBA colormap if conduit.GLOBALS.settings.get("gui_use_rgba_colormap") == True: screen = self.mainWindow.get_screen() colormap = screen.get_rgba_colormap() if colormap: gtk.widget_set_default_colormap(colormap) self.mainWindow.set_position(gtk.WIN_POS_CENTER) title = "Conduit" if conduit.IS_DEVELOPMENT_VERSION: title = title + _(" - %s (Development Version)") % conduit.VERSION if not conduit.IS_INSTALLED: title = title + _(" - Running Uninstalled") self.mainWindow.set_title(title) #Configure canvas self.canvasSW = self.builder.get_object("canvasScrolledWindow") self.hpane = self.builder.get_object("hpaned1") #start up the canvas msg = MsgArea.MsgAreaController() self.builder.get_object("mainVbox").pack_start(msg, False, False) self.canvas = Canvas.Canvas( parentWindow=self.mainWindow, typeConverter=self.type_converter, syncManager=self.sync_manager, gtkbuilder=self.builder, msg=msg ) self.canvasSW.add(self.canvas) self.canvas.connect('drag-drop', self.drop_cb) self.canvas.connect("drag-data-received", self.drag_data_received_data) # Populate the tree model self.dataproviderTreeModel = Tree.DataProviderTreeModel() dataproviderScrolledWindow = self.builder.get_object("scrolledwindow2") self.dataproviderTreeView = Tree.DataProviderTreeView(self.dataproviderTreeModel) dataproviderScrolledWindow.add(self.dataproviderTreeView) #Set up the expander used for resolving sync conflicts self.conflictResolver = ConflictResolver.ConflictResolver(self.builder) #Preferences manager self.preferences = PreferencesWindow(self.builder) #add the preconfigured Conduit menu if conduit.GLOBALS.settings.get("gui_show_hints"): self.preconfiguredConduitsMenu = _PreconfiguredConduitMenu() self.builder.get_object("file_menu").insert(self.preconfiguredConduitsMenu.item, 3) else: self.preconfiguredConduitsMenu = None #if running a development version, add some developer specific links #to the help menu if conduit.IS_DEVELOPMENT_VERSION: helpMenu = self.builder.get_object("help_menu") developersMenuItem = gtk.ImageMenuItem(_("Developers")) developersMenuItem.set_image( gtk.image_new_from_icon_name( "applications-development", gtk.ICON_SIZE_MENU)) developersMenu = gtk.Menu() developersMenuItem.set_submenu(developersMenu) helpMenu.prepend(developersMenuItem) for name,url in DEVELOPER_WEB_LINKS: item = gtk.ImageMenuItem(_(name)) item.set_image( gtk.image_new_from_icon_name( "applications-internet", gtk.ICON_SIZE_MENU)) item.connect("activate",self.on_developer_menu_item_clicked,_(name),url) developersMenu.append(item) #final GUI setup self.cancelSyncButton = self.builder.get_object('cancel') self.hpane.set_position(conduit.GLOBALS.settings.get("gui_hpane_postion")) self.dataproviderTreeView.set_expand_rows() self.window_state = 0 log.info("Main window constructed (thread: %s)" % thread.get_ident())
def __init__(self, exaile): """ Initializes the GUI @param exaile: The Exaile instance """ from xlgui import main, panel, tray, progress from xlgui.panel import collection, radio, playlists, files gtk.gdk.set_program_class("Exaile") self.exaile = exaile self.first_removed = False self.tray_icon = None self.panels = {} self.builder = gtk.Builder() self.builder.add_from_file(xdg.get_data_path("ui/main.ui")) self.progress_box = self.builder.get_object('progress_box') self.progress_manager = progress.ProgressManager(self.progress_box) icons.MANAGER.add_icon_name_from_directory('exaile', xdg.get_data_path('images')) gtk.window_set_default_icon_name('exaile') icons.MANAGER.add_icon_name_from_directory('exaile-pause', xdg.get_data_path('images')) icons.MANAGER.add_icon_name_from_directory('exaile-play', xdg.get_data_path('images')) for name in ('dynamic', 'repeat', 'shuffle'): icon_name = 'media-playlist-%s' % name icons.MANAGER.add_icon_name_from_directory( icon_name, xdg.get_data_path('images')) logger.info("Loading main window...") self.main = main.MainWindow(self, self.builder, exaile.collection, exaile.player, exaile.queue, covers.MANAGER) self.panel_notebook = self.builder.get_object('panel_notebook') self.play_toolbar = self.builder.get_object('play_toolbar') logger.info("Loading panels...") self.panels['collection'] = collection.CollectionPanel( self.main.window, exaile.collection, _show_collection_empty_message=True) self.panels['radio'] = radio.RadioPanel(self.main.window, exaile.collection, exaile.radio, exaile.stations) self.panels['playlists'] = playlists.PlaylistsPanel( self.main.window, exaile.playlists, exaile.smart_playlists, exaile.collection) self.panels['files'] = files.FilesPanel(self.main.window, exaile.collection) for panel in ('collection', 'radio', 'playlists', 'files'): self.add_panel(*self.panels[panel].get_panel()) # add the device panels for device in self.exaile.devices.list_devices(): if device.connected: self.add_device_panel(None, None, device) logger.info("Connecting panel events...") self.main._connect_panel_events() if settings.get_option('gui/use_tray', False): self.tray_icon = tray.TrayIcon(self.main) self.device_panels = {} event.add_callback(self.add_device_panel, 'device_connected') event.add_callback(self.remove_device_panel, 'device_disconnected') event.add_callback(self.on_gui_loaded, 'gui_loaded') logger.info("Done loading main window...") Main._main = self