def _init_video_button(self): """Intialize the video button on the video toolbar.""" # Let's make this resemble a gtk.FileChooserButton, # but not actually be one, because they are slow to instantiate. hbox = gtk.HBox(False, 4) size = gtk.ICON_SIZE_MENU image = gtk.image_new_from_stock(gtk.STOCK_FILE, size) hbox.pack_start(image, False, False) label = gtk.Label() label.props.xalign = 0 label.set_ellipsize(pango.ELLIPSIZE_END) hbox.pack_start(label, True, True) hbox.pack_start(gtk.VSeparator(), False, False) image = gtk.image_new_from_stock(gtk.STOCK_OPEN, size) hbox.pack_start(image, False, False) self.video_button = gtk.Button() self.video_button.add(hbox) self.video_button.set_data("label", label) self.video_button.drag_dest_set(gtk.DEST_DEFAULT_ALL, [("text/uri-list", 0, 0)], gtk.gdk.ACTION_COPY) aeidon.util.connect(self, "video_button", "clicked") aeidon.util.connect(self, "video_button", "drag-data-received") tool_item = gtk.ToolItem() tool_item.set_border_width(4) tool_item.set_expand(True) tool_item.add(self.video_button) self.video_toolbar.insert(tool_item, -1)
def __init__(self, handler): """ constructor handler -- e3common.Handler.HelpHandler """ gtk.Menu.__init__(self) self.handler = handler self.website = gtk.ImageMenuItem(_("_Website")) self.website.set_image(gtk.image_new_from_stock(gtk.STOCK_HOME, gtk.ICON_SIZE_MENU)) self.website.connect("activate", lambda *args: self.handler.on_website_selected()) self.about = gtk.ImageMenuItem(gtk.STOCK_ABOUT) self.about.connect("activate", lambda *args: self.handler.on_about_selected()) self.debug = gtk.MenuItem(_("Debug")) self.debug.connect("activate", lambda *args: self.handler.on_debug_selected()) self.updatecheck = gtk.ImageMenuItem(_("Check for updates")) self.updatecheck.set_image(gtk.image_new_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_MENU)) self.updatecheck.connect("activate", lambda *args: self.handler.on_check_update_selected()) self.append(self.website) self.append(self.about) self.append(self.debug) self.append(gtk.SeparatorMenuItem()) self.append(self.updatecheck)
def __init__(self, gui, master, undo_stack = None): gtk.VBox.__init__(self) super(GtkChildhoodPane, self).__init__(gui, master, undo_stack) self.button_move_up = gtk.Button() self.button_add = gtk.Button() self.button_remove = gtk.Button() self.button_move_down = gtk.Button() self.button_move_up .set_image(gtk.image_new_from_stock(gtk.STOCK_GO_UP , gtk.ICON_SIZE_BUTTON)) self.button_add .set_image(gtk.image_new_from_stock(gtk.STOCK_ADD , gtk.ICON_SIZE_BUTTON)) self.button_remove .set_image(gtk.image_new_from_stock(gtk.STOCK_REMOVE , gtk.ICON_SIZE_BUTTON)) self.button_move_down.set_image(gtk.image_new_from_stock(gtk.STOCK_GO_DOWN, gtk.ICON_SIZE_BUTTON)) self.button_move_up .connect("clicked", self.on_move_up) self.button_add .connect("clicked", self.on_add) self.button_remove .connect("clicked", self.on_remove) self.button_move_down.connect("clicked", self.on_move_down) self.pack_start(self.button_move_up , 1, 1) self.pack_start(self.button_add , 1, 1) self.pack_start(self.button_remove , 1, 1) self.pack_start(self.button_move_down, 1, 1) self.button_move_up .set_relief(gtk.RELIEF_NONE) self.button_add .set_relief(gtk.RELIEF_NONE) self.button_remove .set_relief(gtk.RELIEF_NONE) self.button_move_down.set_relief(gtk.RELIEF_NONE) self.set_property("visible", 0) self.set_property("no-show-all", 1)
def __init__(self, icon_theme=None): """ Creates an enhanced IconEntry that supports a time out when typing and uses a different background colour when the search is active """ sexy.IconEntry.__init__(self) if not icon_theme: icon_theme = gtk.icon_theme_get_default() self._handler_changed = self.connect_after("changed", self._on_changed) self.connect("icon-pressed", self._on_icon_pressed) image_find = gtk.image_new_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_MENU) self.set_icon(sexy.ICON_ENTRY_PRIMARY, image_find) self.empty_image = gtk.Image() self.clear_image = gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU) self.set_icon(sexy.ICON_ENTRY_SECONDARY, self.clear_image) self.set_icon_highlight(sexy.ICON_ENTRY_PRIMARY, True) # Do not draw a yellow bg if an a11y theme is used settings = gtk.settings_get_default() theme = settings.get_property("gtk-theme-name") self._a11y = (theme.startswith("HighContrast") or theme.startswith("LowContrast")) # data self._timeout_id = 0 self._undo_stack = [""] self._redo_stack = []
def __init__(self,layermanager=None,controller=None): self.layermanager=layermanager self.controller=controller gtk.Window.__init__(self) self.set_title(self.program_name+" - v"+self.__version__) self.connect("destroy",gtk.main_quit) vbox=gtk.VBox(False,0) hbox=gtk.HBox(False,0) if layermanager: vbox.add(layermanager) else: error=gtk.image_new_from_stock("gtk-dialog-error",gtk.ICON_SIZE_DIALOG) error.set_size_request(settings.IMAGE_WIDTH,settings.IMAGE_HEIGHT) vbox.add(error) timeline=gtk.Adjustment(0,0,len(layermanager),1,1,1) timeline.connect("value-changed",self.timeline_changed) timescale=gtk.HScale(timeline) timescale.set_digits(0) vbox.add(timescale) hbox.add(vbox) if controller: hbox.add(controller) else: hbox.add(gtk.image_new_from_stock("gtk-dialog-error",gtk.ICON_SIZE_DIALOG)) self.add(hbox) self.show_all()
def show_folder_view_menu_popup( self, list, button, time ): iter = list.get_selection().get_selected()[1] if iter is None: return #print "popup-menu" self.popup_menu = gtk.Menu() menu_item = gtk.ImageMenuItem( 'backintime.open' ) menu_item.set_image( gtk.image_new_from_icon_name( self.store_folder_view.get_value( iter, 2 ), gtk.ICON_SIZE_MENU ) ) menu_item.connect( 'activate', self.on_list_folder_view_open_item ) self.popup_menu.append( menu_item ) self.popup_menu.append( gtk.SeparatorMenuItem() ) menu_item = gtk.ImageMenuItem( 'backintime.copy' ) menu_item.set_image( gtk.image_new_from_stock( gtk.STOCK_COPY, gtk.ICON_SIZE_MENU ) ) menu_item.connect( 'activate', self.on_list_folder_view_copy_item ) self.popup_menu.append( menu_item ) menu_item = gtk.ImageMenuItem( 'backintime.snapshots' ) menu_item.set_image( gtk.image_new_from_stock( gtk.STOCK_INDEX, gtk.ICON_SIZE_MENU ) ) menu_item.connect( 'activate', self.on_list_folder_view_snapshots_item ) self.popup_menu.append( menu_item ) if len( self.snapshot_id ) > 1: menu_item = gtk.ImageMenuItem( 'backintime.restore' ) menu_item.set_image( gtk.image_new_from_stock( gtk.STOCK_UNDELETE, gtk.ICON_SIZE_MENU ) ) menu_item.connect( 'activate', self.on_list_folder_view_restore_item ) self.popup_menu.append( menu_item ) self.popup_menu.show_all() self.popup_menu.popup( None, None, None, button, time )
def get_toolitems( self ): """Return the tool bar items specific to this view.""" items = [] expand_button = gtk.ToolButton() image = gtk.image_new_from_stock( gtk.STOCK_ADD, gtk.ICON_SIZE_SMALL_TOOLBAR ) expand_button.set_icon_widget( image ) expand_button.set_label( "Expand" ) self._set_tooltip( expand_button, "Tree View - Expand all" ) expand_button.connect( 'clicked', lambda x: self.ttreeview.expand_all() ) items.append( expand_button ) collapse_button = gtk.ToolButton() image = gtk.image_new_from_stock( gtk.STOCK_REMOVE, gtk.ICON_SIZE_SMALL_TOOLBAR ) collapse_button.set_icon_widget( image ) collapse_button.set_label( "Collapse" ) collapse_button.connect( 'clicked', lambda x: self.ttreeview.collapse_all() ) self._set_tooltip( collapse_button, "Tree View - Collapse all" ) items.append( collapse_button ) self.group_toolbutton = gtk.ToggleToolButton() self.group_toolbutton.set_active( self.t.should_group_families ) g_image = gtk.image_new_from_stock( 'group', gtk.ICON_SIZE_SMALL_TOOLBAR ) self.group_toolbutton.set_icon_widget( g_image ) self.group_toolbutton.set_label( "Group" ) self.group_toolbutton.connect( 'toggled', self.toggle_grouping ) self._set_tooltip( self.group_toolbutton, "Tree View - Click to group tasks by families" ) items.append( self.group_toolbutton ) return items
def __init__(self, handler): """ constructor handler -- a e3common.Handler.AccountHandler """ gtk.Menu.__init__(self) self.handler = handler self.set_nick = gtk.ImageMenuItem('Set nick') self.set_nick.set_image(gtk.image_new_from_stock(gtk.STOCK_EDIT, gtk.ICON_SIZE_MENU)) self.set_nick.connect('activate', lambda *args: self.handler.on_set_nick_selected()) self.set_message = gtk.ImageMenuItem('Set message') self.set_message.set_image(gtk.image_new_from_stock(gtk.STOCK_EDIT, gtk.ICON_SIZE_MENU)) self.set_message.connect('activate', lambda *args: self.handler.on_set_message_selected()) self.set_picture = gtk.ImageMenuItem('Set picture') self.set_picture.set_image(gtk.image_new_from_stock(gtk.STOCK_EDIT, gtk.ICON_SIZE_MENU)) self.set_picture.connect('activate', lambda *args: self.handler.on_set_picture_selected()) self.append(self.set_nick) self.append(self.set_message) self.append(self.set_picture)
def _populate_checker_tab(self, report_failure=True): # This is a limitation of GLADE, and can be removed when we migrate to # GTK2 Builder checker_service = self._get_checker_service(report_failure) self.get_widget("restart_checker").set_image(gtk.image_new_from_stock(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_BUTTON)) self.get_widget("refresh_info").set_image(gtk.image_new_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_BUTTON)) self.get_widget("stop_checker").set_image(gtk.image_new_from_stock(gtk.STOCK_STOP, gtk.ICON_SIZE_BUTTON)) self.get_widget("stop_checker").set_sensitive(bool(checker_service)) if checker_service: self.get_widget("checker_type").set_text(checker_service.CheckerType()) self.get_widget("pid").set_text(str(checker_service.PID())) memory = checker_service.MemoryUsage() if memory: self.get_widget("memory_usage").set_text("%s KB" % memory) else: self.get_widget("memory_usage").set_text(CHECKER_UNKNOWN_INFO) self._populate_info_table(checker_service.ExtraInformation()) else: self.get_widget("checker_type").set_text(CHECKER_UNKNOWN_INFO) self.get_widget("pid").set_text(CHECKER_UNKNOWN_INFO) self.get_widget("memory_usage").set_text(CHECKER_UNKNOWN_INFO) self._clear_info_table()
def __init__(self, session, members): '''constructor''' gtk.HBox.__init__(self) self.set_border_width(2) self._information = Renderers.SmileyLabel() self.eventBox = gtk.EventBox() self.eventBox.set_visible_window(False) self.eventBox.add(self._information) self.eventBox.connect('button-press-event', self.on_clicked) self.pack_start(self.eventBox, True, True) self.session = session self.members = members self.menu = gtk.Menu() copynick = gtk.ImageMenuItem(_('Copy nick to clipboard')) copynick.set_image(gtk.image_new_from_stock(gtk.STOCK_COPY, gtk.ICON_SIZE_MENU)) copypm = gtk.ImageMenuItem(_('Copy personal message to clipboard')) copypm.set_image(gtk.image_new_from_stock(gtk.STOCK_COPY, gtk.ICON_SIZE_MENU)) copymail = gtk.ImageMenuItem(_('Copy mail to clipboard')) copymail.set_image(gtk.image_new_from_stock(gtk.STOCK_COPY, gtk.ICON_SIZE_MENU)) self.menu.append(copynick) self.menu.append(copypm) self.menu.append(copymail) copynick.connect('activate', self.copy_nick) copypm.connect('activate', self.copy_pm) copymail.connect('activate', self.copy_mail) copynick.show() copypm.show() copymail.show()
def event(self, button, event, smilie): if event.type == gtk.gdk.BUTTON_PRESS and event.button == 1: self.hide() self.callback(smilie) if event.type == gtk.gdk.BUTTON_PRESS and event.button == 3: # -- Custom Emoticon Menu -- self.emoMenu = gtk.Menu() self.shortcutItem = gtk.ImageMenuItem(_("Change shortcut")) self.shortcutItem.set_image(gtk.image_new_from_stock( gtk.STOCK_EDIT, gtk.ICON_SIZE_MENU)) self.shortcutItem.connect("activate", self.onEditShortcut, smilie) self.deleteItem = gtk.ImageMenuItem(_("Delete")) self.deleteItem.set_image(gtk.image_new_from_stock( gtk.STOCK_DELETE, gtk.ICON_SIZE_MENU)) self.deleteItem.connect("activate", self.onDeleteEmo, smilie) self.emoMenu.add(self.shortcutItem) self.emoMenu.add(self.deleteItem) self.emoMenu.show_all() # ----- self.emoMenu.popup(None, None, None, event.button, event.time)
def get_image_from_name(name, size, fit_size = "both"): assert isinstance(name, str), "Image name must be a string" icon = None if gtk.stock_lookup(name): icon = gtk.image_new_from_stock(name, size) elif gtk.icon_theme_get_default().has_icon(name): icon = gtk.image_new_from_icon_name(name, size) else: path = os.path.join('..', os.path.dirname(os.path.dirname(__file__)), 'data', 'gfx', name+'.png') if os.path.exists(path): try: _size = gtk.icon_size_lookup(size) pixbuf = gtk.gdk.pixbuf_new_from_file(path) heightS = max(float(_size[1])/float(pixbuf.get_height()), 1.0) widthS = max(float(_size[0])/float(pixbuf.get_width()), 1.0) if fit_size == 'both': if heightS < widthS: pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(path, _size[1]*pixbuf.get_width()/pixbuf.get_height(), _size[1]) else: pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(path, _size[0], _size[0]*pixbuf.get_height()/pixbuf.get_width()) elif fit_size == 'width': pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(path, _size[0], _size[0]*pixbuf.get_height()/pixbuf.get_widtht()) else: pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(path, _size[1]*pixbuf.get_width()/pixbuf.get_height(), _size[1]) icon = gtk.image_new_from_pixbuf(pixbuf) except Exception as e: print e icon = gtk.image_new_from_stock(gtk.STOCK_MISSING_IMAGE, size) else: icon = gtk.image_new_from_stock(gtk.STOCK_MISSING_IMAGE, size) return icon
def _right_click(self, icon, button, timestamp): menu = gtk.Menu() about = gtk.ImageMenuItem('About') quit = gtk.ImageMenuItem('Quit') img = gtk.image_new_from_stock(gtk.STOCK_ABOUT, gtk.ICON_SIZE_MENU) img.show() about.set_image(img) img = gtk.image_new_from_stock(gtk.STOCK_QUIT, gtk.ICON_SIZE_MENU) img.show() quit.set_image(img) about.connect('activate', self._show_about_dialog) quit.connect('activate', gtk.main_quit) menu.append(about) menu.append(gtk.SeparatorMenuItem()) menu.append(quit) menu.show_all() menu.popup(None, None, gtk.status_icon_position_menu, button, timestamp, icon)
def generate_buttons(self): """Create the add button.""" add_image = gtk.image_new_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_MENU) add_image.show() self.add_button = gtk.EventBox() self.add_button.set_tooltip_text(self.TIP_ADD) self.add_button.add(add_image) self.add_button.connect('button-release-event', lambda b, e: self.add_entry()) self.add_button.connect('enter-notify-event', lambda b, e: b.set_state(gtk.STATE_ACTIVE)) self.add_button.connect('leave-notify-event', lambda b, e: b.set_state(gtk.STATE_NORMAL)) del_image = gtk.image_new_from_stock(gtk.STOCK_REMOVE, gtk.ICON_SIZE_MENU) del_image.show() self.del_button = gtk.EventBox() self.del_button.set_tooltip_text(self.TIP_ADD) self.del_button.add(del_image) self.del_button.show() self.del_button.connect('button-release-event', self.remove_entry) self.del_button.connect('enter-notify-event', lambda b, e: b.set_state(gtk.STATE_ACTIVE)) self.del_button.connect('leave-notify-event', lambda b, e: b.set_state(gtk.STATE_NORMAL)) self.button_box = gtk.VBox() self.button_box.show() self.button_box.pack_start(self.add_button, expand=False, fill=False) self.button_box.pack_start(self.del_button, expand=False, fill=False)
def get_trayicon_menu(self): menu = gtk.Menu() item = gtk.ImageMenuItem(_("About")) img = gtk.image_new_from_stock(gtk.STOCK_ABOUT, gtk.ICON_SIZE_MENU) item.set_image(img) item.connect("activate", self.on_about_menuitem_activate) item.show() menu.append(item) item = gtk.ImageMenuItem(_("Preferences")) item.set_image(gtk.image_new_from_stock(gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_MENU)) item.connect("activate", self.on_preferences_menu_item_activate) if self.model.device is None: item.set_sensitive(False) else: item.set_sensitive(True) item.show() menu.append(item) item = gtk.ImageMenuItem(_("Quit")) img = gtk.image_new_from_stock(gtk.STOCK_QUIT, gtk.ICON_SIZE_MENU) item.set_image(img) item.connect("activate", self.close_application) item.show() menu.append(item) return menu
def generate_buttons(self): """Insert an add row and delete row button.""" del_image = gtk.image_new_from_stock(gtk.STOCK_REMOVE, gtk.ICON_SIZE_MENU) del_image.show() self.del_button = gtk.EventBox() self.del_button.set_tooltip_text(self.TIP_ADD) self.del_button.add(del_image) self.del_button.show() self.del_button.connect('button-release-event', self.del_row) self.del_button.connect('enter-notify-event', lambda b, e: b.set_state(gtk.STATE_ACTIVE)) self.del_button.connect('leave-notify-event', lambda b, e: b.set_state(gtk.STATE_NORMAL)) add_image = gtk.image_new_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_MENU) add_image.show() self.add_button = gtk.EventBox() self.add_button.set_tooltip_text(self.TIP_ADD) self.add_button.add(add_image) self.add_button.show() self.add_button.connect('button-release-event', self.add_row) self.add_button.connect('enter-notify-event', lambda b, e: b.set_state(gtk.STATE_ACTIVE)) self.add_button.connect('leave-notify-event', lambda b, e: b.set_state(gtk.STATE_NORMAL)) self.add_del_button_box = gtk.VBox() self.add_del_button_box.pack_start( self.add_button, expand=False, fill=False) self.add_del_button_box.pack_start( self.del_button, expand=False, fill=False) self.add_del_button_box.show() self._decide_show_buttons()
def __init__(self, _map): gtk.HBox.__init__(self) zo = gtk.EventBox() zo.add(gtk.image_new_from_stock (gtk.STOCK_ZOOM_OUT, gtk.ICON_SIZE_MENU)) zo.connect("button-press-event", self._on_zoom_out_pressed, _map) self.pack_start(zo, False, False) self.zoom = gtk.Adjustment( value=_map.props.zoom, lower=_map.props.min_zoom, upper=_map.props.max_zoom, step_incr=1, page_incr=1, page_size=0) self.zoom.connect("value-changed", self._on_zoom_slider_value_changed, _map) hs = gtk.HScale(self.zoom) hs.props.digits = 0 hs.props.draw_value = False hs.set_size_request(100,-1) hs.set_update_policy(gtk.UPDATE_DISCONTINUOUS) self.pack_start(hs, True, True) zi = gtk.EventBox() zi.add(gtk.image_new_from_stock (gtk.STOCK_ZOOM_IN, gtk.ICON_SIZE_MENU)) zi.connect("button-press-event", self._on_zoom_in_pressed, _map) self.pack_start(zi, False, False) _map.connect("notify::zoom", self._on_map_zoom_changed)
def __init__(self): self.hbox=gtk.HBox() self.arrow_left2=gtk.Button() self.arrow_left2.set_relief(2) image=gtk.image_new_from_stock(gtk.STOCK_GO_BACK,gtk.ICON_SIZE_SMALL_TOOLBAR) self.arrow_left2.set_image(image) self.hbox.pack_start(self.arrow_left2,0,0,0) self.monthname=gtk.Label(" <b></b> ") self.monthname.set_use_markup(True) self.hbox.pack_start(self.monthname,0,0,0) self.arrow_right2=gtk.Button() self.arrow_right2.set_relief(2) image=gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD,gtk.ICON_SIZE_SMALL_TOOLBAR) self.arrow_right2.set_image(image) self.hbox.pack_start(self.arrow_right2,0,0,0) self.hbox.show_all() self .label=gtk.HSeparator() self.hbox.pack_start(self.label,1,1,0) self.arrow_left=gtk.Button() self.arrow_left.set_relief(2) image=gtk.image_new_from_stock(gtk.STOCK_GO_BACK,gtk.ICON_SIZE_SMALL_TOOLBAR) self.arrow_left.set_image(image) self.hbox.pack_start(self.arrow_left,0,0,0) self.yearnum=gtk.Label(" <b></b> ") self.yearnum.set_use_markup(True) self.hbox.pack_start(self.yearnum,0,0,0) self.arrow_right=gtk.Button() self.arrow_right.set_relief(2) image=gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD,gtk.ICON_SIZE_SMALL_TOOLBAR) self.arrow_right.set_image(image) self.hbox.pack_start(self.arrow_right,0,0,0)
def get_toolitems(self): """Return the tool bar items specific to this view.""" items = [] self.group_toolbutton = gtk.ToggleToolButton() self.group_toolbutton.set_active(self.t.should_group_families) g_image = gtk.image_new_from_stock( 'group', gtk.ICON_SIZE_SMALL_TOOLBAR) self.group_toolbutton.set_icon_widget(g_image) self.group_toolbutton.set_label("Group") self.group_toolbutton.connect('toggled', self.toggle_grouping) items.append(self.group_toolbutton) self._set_tooltip( self.group_toolbutton, "Dot View - Click to group tasks by families") self.transpose_toolbutton = gtk.ToggleToolButton() self.transpose_toolbutton.set_active(self.t.should_transpose_view) g_image = gtk.image_new_from_stock( 'transpose', gtk.ICON_SIZE_SMALL_TOOLBAR) self.transpose_toolbutton.set_icon_widget(g_image) self.transpose_toolbutton.set_label("Transpose") self.transpose_toolbutton.connect('toggled', self.toggle_transpose) items.append(self.transpose_toolbutton) self._set_tooltip( self.transpose_toolbutton, "Dot View - Click to transpose view") return items
def create_ui(self): vbox = gtk.VBox() self.add(vbox) self.videowidget = VideoWidget() vbox.pack_start(self.videowidget) hbox = gtk.HBox() vbox.pack_start(hbox, fill=False, expand=False) self.pause_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PAUSE, gtk.ICON_SIZE_BUTTON) self.pause_image.show() self.play_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY, gtk.ICON_SIZE_BUTTON) self.play_image.show() self.button = button = gtk.Button() button.add(self.play_image) button.set_property("can-default", True) button.set_focus_on_click(False) button.show() hbox.pack_start(button, False) button.set_property("has-default", True) button.connect("clicked", lambda *args: self.play_toggled()) self.adjustment = gtk.Adjustment(0.0, 0.00, 100.0, 0.1, 1.0, 1.0) hscale = gtk.HScale(self.adjustment) hscale.set_digits(2) hscale.set_update_policy(gtk.UPDATE_CONTINUOUS) hscale.connect("button-press-event", self.scale_button_press_cb) hscale.connect("button-release-event", self.scale_button_release_cb) hscale.connect("format-value", self.scale_format_value_cb) hbox.pack_start(hscale) self.hscale = hscale self.videowidget.connect_after("realize", lambda *x: self.play_toggled())
def _append_new(self): lbl = gtk.Label(self.label_fmt) lbl.set_alignment(0.0, 0.5) lbl.show() widget = self.create_cb() widget.show() idx = len(self.widgets) btn = gtk.Button() if idx != 0: btn.connect("clicked", self.__on_remove) b_image = gtk.image_new_from_stock(gtk.STOCK_REMOVE, gtk.ICON_SIZE_BUTTON) else: btn.connect("clicked", self.__on_add) b_image = gtk.image_new_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_BUTTON) b_image.show() btn.add(b_image) btn.set_relief(gtk.RELIEF_NONE) btn.show() hbox = gtk.HBox(False, 10) hbox.pack_start(lbl, False, False, 0) hbox.pack_start(widget) hbox.pack_start(btn, False, False, 0) hbox.show() self.pack_start(hbox, False, False, 0) self.widgets.append((lbl, widget, btn))
def menu(self, event_button, event_time, data=None): """Create popup menu """ self.sub_menu() menu = gtk.Menu() menu.append(self.daemon) separator = gtk.SeparatorMenuItem() menu_Check = gtk.ImageMenuItem("Check updates") img_Check = gtk.image_new_from_stock(gtk.STOCK_OK, gtk.ICON_SIZE_MENU) img_Check.show() menu_Info = gtk.ImageMenuItem("OS Info") img_Info = gtk.image_new_from_stock(gtk.STOCK_INFO, gtk.ICON_SIZE_MENU) img_Info.show() menu_About = gtk.ImageMenuItem("About") img_About = gtk.image_new_from_stock(gtk.STOCK_ABOUT, gtk.ICON_SIZE_MENU) img_About.show() self.daemon.set_image(self.img_daemon) menu.append(self.daemon) self.daemon.show() menu_Quit = gtk.ImageMenuItem("Quit") img_Quit = gtk.image_new_from_stock(gtk.STOCK_QUIT, gtk.ICON_SIZE_MENU) img_Quit.show() menu_Check.set_image(img_Check) menu_Info.set_image(img_Info) menu_About.set_image(img_About) menu_Quit.set_image(img_Quit) menu.append(menu_Check) menu.append(menu_Info) menu.append(separator) menu.append(menu_About) menu.append(menu_Quit) separator.show() menu_Check.show() menu_Info.show() menu_About.show() menu_Quit.show() menu_Check.connect_object("activate", self._Check, " ") menu_Info.connect_object("activate", self._Info, "OS Info") menu_About.connect_object("activate", self._About, "SUN") self.start.connect_object("activate", self._start, "Start daemon ") self.stop.connect_object("activate", self._stop, "Stop daemon ") self.restart.connect_object("activate", self._restart, "Restart daemon ") self.status.connect_object("activate", self._status, daemon_status()) menu_Quit.connect_object("activate", self._Quit, "stop") menu.popup(None, None, None, event_button, event_time, data)
def __init__(self, controls): gtk.HBox.__init__(self, False) self.order = gtk.ToggleButton() order_image = gtk.image_new_from_stock(gtk.STOCK_REDO, gtk.ICON_SIZE_BUTTON) self.order.add(order_image) self.order.set_relief(gtk.RELIEF_NONE) self.order.set_focus_on_click(False) self.order.set_has_tooltip(True) self.order.connect("button-press-event", self.on_order) self.pack_start(self.order) self.repeat = gtk.ToggleButton() repeat_image = gtk.image_new_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_BUTTON) self.repeat.add(repeat_image) self.repeat.set_relief(gtk.RELIEF_NONE) self.repeat.set_focus_on_click(False) self.repeat.set_has_tooltip(True) self.repeat.connect("button-press-event", self.choise) self.pack_start(self.repeat) self.pack_start(gtk.SeparatorToolItem()) self.menu = gtk.Menu() self.item_all = gtk.CheckMenuItem(_("Repeat all")) self.item_all.connect("button-press-event", self.on_repeat) self.menu.append(self.item_all) self.item_single = gtk.CheckMenuItem(_("Repeat single")) self.item_single.connect("button-press-event", lambda item, *a: self.on_repeat(item, False)) self.menu.append(self.item_single)
def get_menuitems(self): """Return the menu items specific to this view.""" items = [] graph_range_item = gtk.MenuItem("Time Range Focus ...") items.append(graph_range_item) graph_range_item.connect("activate", self.graph_timezoom_popup) crop_item = gtk.CheckMenuItem("Toggle _Crop Base Graph") items.append(crop_item) crop_item.set_active(self.t.crop) crop_item.connect("activate", self.toggle_crop) menu_filter_item = gtk.ImageMenuItem("Task _Filtering ...") img = gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU) menu_filter_item.set_image(img) items.append(menu_filter_item) menu_filter_item.connect("activate", self.filter_popup) self.menu_group_item = gtk.ImageMenuItem("_Group All Families") img = gtk.image_new_from_stock("group", gtk.ICON_SIZE_MENU) self.menu_group_item.set_image(img) items.append(self.menu_group_item) self.menu_group_item.connect("activate", self.group_all, True) self.menu_ungroup_item = gtk.ImageMenuItem("_UnGroup All Families") img = gtk.image_new_from_stock("ungroup", gtk.ICON_SIZE_MENU) self.menu_ungroup_item.set_image(img) items.append(self.menu_ungroup_item) self.menu_ungroup_item.connect("activate", self.group_all, False) menu_landscape_item = gtk.CheckMenuItem("Toggle _Landscape Mode") items.append(menu_landscape_item) menu_landscape_item.set_active(self.t.orientation == "LR") menu_landscape_item.connect("activate", self.toggle_landscape_mode) return items
def __create_widgets(self): self.image = gtk.image_new_from_pixbuf(self._reader.get_logo()) self.label = gtk.Label('') self.label.set_ellipsize(pango.ELLIPSIZE_END) self.versions_model = gtk.ListStore(str, str) self.versions_button = gtk.ComboBox(self.versions_model) rend = gtk.CellRendererPixbuf() self.versions_button.pack_start(rend, False) self.versions_button.add_attribute(rend, 'stock-id', 0) rend = gtk.CellRendererText() self.versions_button.pack_end(rend) self.versions_button.add_attribute(rend, 'text', 1) self.img_play = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY, \ gtk.ICON_SIZE_BUTTON) self.img_stop = gtk.image_new_from_stock(gtk.STOCK_MEDIA_STOP, \ gtk.ICON_SIZE_BUTTON) self.action_btn = HIGButton('') self.uninstall_btn = HIGButton(_("Uninstall"), gtk.STOCK_CLEAR) self.preference_btn = HIGButton(stock=gtk.STOCK_PREFERENCES) self.progressbar = gtk.ProgressBar()
def iterated_find_dialog_exist_or_create(self): """Exist or Create the Iterated Find Dialog""" if self.iteratedfinddialog: return dialog = gtk.Dialog(title=_("Iterate Latest Find/Replace"), parent=self.dad.window, flags=gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT, buttons=(_("Close"), 0, _("Find"), 4, _("Find"), 1, _("Replace"), 2, _("Undo"), 3) ) dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT) try: button = dialog.get_widget_for_response(0) button.set_image(gtk.image_new_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_BUTTON)) button = dialog.get_widget_for_response(4) button.set_image(gtk.image_new_from_stock("find_back", gtk.ICON_SIZE_BUTTON)) button = dialog.get_widget_for_response(1) button.set_image(gtk.image_new_from_stock("find_again", gtk.ICON_SIZE_BUTTON)) button = dialog.get_widget_for_response(2) button.set_image(gtk.image_new_from_stock("find_replace", gtk.ICON_SIZE_BUTTON)) button = dialog.get_widget_for_response(3) button.set_image(gtk.image_new_from_stock(gtk.STOCK_UNDO, gtk.ICON_SIZE_BUTTON)) except: pass def on_key_press_iterated_find_dialog(widget, event): if gtk.gdk.keyval_name(event.keyval) == cons.STR_KEY_RETURN: try: dialog.get_widget_for_response(1).clicked() except: print cons.STR_PYGTK_222_REQUIRED return True return False dialog.connect("key_press_event", on_key_press_iterated_find_dialog) self.iteratedfinddialog = dialog
def show_menu(self, event): #Create the menu and menu items if they don't exist if not self.menu: #Create the items add_feed = awn.image_menu_item_new_with_label(_("Add Feed")) update = gtk.ImageMenuItem(gtk.STOCK_REFRESH) self.show_only_new_check = gtk.CheckMenuItem(_("Show Only _New Feeds")) sep = gtk.SeparatorMenuItem() prefs_item = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES) about = gtk.ImageMenuItem(_("_About %s") % _("Feeds Applet")) about.props.always_show_image = True about.set_image(gtk.image_new_from_stock(gtk.STOCK_ABOUT, gtk.ICON_SIZE_MENU)) #Add icon for "Add Feed" add_icon = gtk.image_new_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_MENU) add_feed.set_image(add_icon) if self.client.get_value(GROUP_DEFAULT, 'show_only_new'): self.show_only_new_check.set_active(True) add_feed.connect('activate', self.add_feed_dialog) update.connect('activate', self.update_feeds) self.show_only_new_check.connect('toggled', self.toggle_show_only_new) prefs_item.connect('activate', self.open_prefs) about.connect('activate', self.show_about) #Create the menu self.menu = self.create_default_menu() for item in (add_feed, update, self.show_only_new_check, sep, prefs_item, about): self.menu.append(item) self.menu.show_all() self.popup_gtk_menu (self.menu, event.button, event.time)
def changetitle(self, widget, title=None): "Change Title when file is temporary" pg = self.notebook.get_current_page() print self.file, pg, self.widget if self.change[pg] == 0: hbox = gtk.HBox(False, 0) print title if title is None: title = self.file[pg] label = gtk.Label('**' + title.split('/')[-1]) hbox.pack_start(label) # get a stock close button image close_image = gtk.image_new_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU) image_w, image_h = gtk.icon_size_lookup(gtk.ICON_SIZE_MENU) # make the close button btn = gtk.Button() btn.set_relief(gtk.RELIEF_NONE) btn.set_focus_on_click(False) btn.add(close_image) hbox.pack_start(btn, False, False) # this reduces the size of the button style = gtk.RcStyle() style.xthickness = 0 style.ythickness = 0 btn.modify_style(style) hbox.show_all() self.notebook.set_tab_label(self.widget[pg], hbox) btn.connect('clicked', self.on_closetab_button_clicked, self.widget[pg]) self.change[pg] = 1 elif not title is None: hbox = gtk.HBox(False, 0) label = gtk.Label(title.split('/')[-1]) hbox.pack_start(label) # get a stock close button image close_image = gtk.image_new_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU) image_w, image_h = gtk.icon_size_lookup(gtk.ICON_SIZE_MENU) # make the close button btn = gtk.Button() btn.set_relief(gtk.RELIEF_NONE) btn.set_focus_on_click(False) btn.add(close_image) hbox.pack_start(btn, False, False) # this reduces the size of the button style = gtk.RcStyle() style.xthickness = 0 style.ythickness = 0 btn.modify_style(style) hbox.show_all() self.notebook.set_tab_label(self.widget[pg], hbox) btn.connect('clicked', self.on_closetab_button_clicked, self.widget[pg]) self.change[pg] = 0
def __create_toolbar(self): toolbar = gtk.Toolbar() toolbar.show() icon = gtk.image_new_from_stock(gtk.STOCK_GO_UP, gtk.ICON_SIZE_LARGE_TOOLBAR) icon.show() self.move_up_button = gtk.ToolButton(icon, 'Up') #self.move_up_button.connect('clicked', self.__on_move_up) self.move_up_button.set_sensitive(False) self.move_up_button.show() toolbar.insert(self.move_up_button, -1) icon = gtk.image_new_from_stock(gtk.STOCK_GO_DOWN, gtk.ICON_SIZE_LARGE_TOOLBAR) icon.show() self.move_down_button = gtk.ToolButton(icon, 'Down') #self.move_down_button.connect('clicked', self.__on_move_down) self.move_down_button.set_sensitive(False) self.move_down_button.show() toolbar.insert(self.move_down_button, -1) icon = gtk.image_new_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_LARGE_TOOLBAR) icon.show() self.delete_button = gtk.ToolButton(icon, u'Delete') self.delete_button.connect('clicked', self.__on_delete) self.delete_button.set_sensitive(False) self.delete_button.show() toolbar.insert(self.delete_button, -1) return toolbar
def __init__(self, handler): """ constructor handler -- e3common.Handler.HelpHandler """ gtk.Menu.__init__(self) website = gtk.ImageMenuItem(_('_Website')) website.set_image(gtk.image_new_from_stock(gtk.STOCK_HOME, gtk.ICON_SIZE_MENU)) website.connect('activate', lambda *args: handler.on_website_selected()) about = gtk.ImageMenuItem(gtk.STOCK_ABOUT) about.connect('activate', lambda *args: handler.on_about_selected()) debug = gtk.MenuItem(_('Debug')) debug.connect('activate', lambda *args: handler.on_debug_selected()) updatecheck = gtk.ImageMenuItem(_('Check for updates')) updatecheck.set_image(gtk.image_new_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_MENU)) updatecheck.connect('activate', lambda *args: handler.on_check_update_selected()) self.append(website) self.append(about) self.append(debug) self.append(gtk.SeparatorMenuItem()) self.append(updatecheck)
def __init__(self): ImageListPage.__init__(self) hb = gtk.HBox(False, 5) hb.show() img = gtk.image_new_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_LARGE_TOOLBAR) img.show() refresh_button = gtk.Button() refresh_button.set_image(img) refresh_button.show() refresh_button.set_tooltip_text("Refresh") refresh_button.connect("clicked", self.refresh_clicked) hb.pack_start(refresh_button, False, False) self.pack_start(hb, False, False)
def allmatchesdialog_init(self): """Create the All Matches Dialog""" self.allmatchesdialog = gtk.Dialog( parent=self.dad.window, flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, buttons=(_("Hide (Restore with '%s')") % menus.get_menu_item_kb_shortcut( self.dad, "toggle_show_allmatches_dlg"), gtk.RESPONSE_CLOSE)) self.allmatchesdialog.set_default_size(700, 350) self.allmatchesdialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT) try: button = self.allmatchesdialog.get_widget_for_response( gtk.RESPONSE_CLOSE) button.set_image( gtk.image_new_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_BUTTON)) except: pass # ROW: 0-node_id, 1-start_offset, 2-end_offset, 3-node_name, 4-line_content, 5-line_num 6-node_hier_name self.liststore = gtk.ListStore(long, long, long, str, str, int, str) self.treeview = gtk.TreeView(self.liststore) self.renderer_text_node = gtk.CellRendererText() self.renderer_text_linenum = gtk.CellRendererText() self.renderer_text_linecontent = gtk.CellRendererText() self.node_column = gtk.TreeViewColumn(_("Node Name"), self.renderer_text_node, text=3) self.treeview.append_column(self.node_column) self.linenum_column = gtk.TreeViewColumn(_("Line"), self.renderer_text_linenum, text=5) self.treeview.append_column(self.linenum_column) self.linecontent_column = gtk.TreeViewColumn( _("Line Content"), self.renderer_text_linecontent, text=4) self.treeview.append_column(self.linecontent_column) self.treeview.set_tooltip_column(6) self.treeviewselection = self.treeview.get_selection() self.treeview.connect('event-after', self.on_treeview_event_after) self.allmatchesdialog.connect("key_press_event", self.on_key_press_allmatches_dialog) scrolledwindow_allmatches = gtk.ScrolledWindow() scrolledwindow_allmatches.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scrolledwindow_allmatches.add(self.treeview) content_area = self.allmatchesdialog.get_content_area() content_area.pack_start(scrolledwindow_allmatches) content_area.show_all()
def add_text(self, data_dict, version): '''data_dict ontains text to be added. Key will be the title Value will be... well, the value :)''' self.box = gtk.HBox(False, 1) self._statusbar.pack_start(self.box, False, False, 1) ellipsize = pango.ELLIPSIZE_NONE for element in data_dict.keys(): # Element icon if element == 'processor': _icon = gtk.image_new_from_file( os.path.dirname(__file__) + os.sep + 'data' + os.sep + 'processor_small.png') self.box.pack_start(_icon, False, False, 0) else: _icon = gtk.image_new_from_stock(self.icons[element], gtk.ICON_SIZE_MENU) self.box.pack_start(_icon, False, False, 0) # Element label label = gtk.Label() label.set_markup('<b>' + element.capitalize() + ':</b>') label.set_padding(1, 5) label.set_max_width_chars(len(element) + 1) label.set_single_line_mode(True) label.set_ellipsize(ellipsize) self.box.pack_start(label, True, True, 1) # Element content label = gtk.Label(str(data_dict[element])) label.set_padding(1, 5) label.set_max_width_chars(len(str(data_dict[element]))) label.set_single_line_mode(True) label.set_ellipsize(ellipsize) self.box.pack_start(label, True, True, 1) sep = gtk.VSeparator() self.box.pack_start(sep, True, True, 1) if version: _icon = gtk.image_new_from_file( os.path.dirname(__file__) + os.sep + 'data' + os.sep + 'bokken-small.svg') self.pack_start(_icon, False, False, 1) label = gtk.Label() label.set_markup('<b>Bokken ' + version + '</b> (' + self.uicore.backend.capitalize() + ')') label.set_padding(3, 3) self.pack_end(label, False) self.show_all()
def generate_image(filename, is_stock=False): image = None if is_stock: image = gtk.image_new_from_stock( filename, gtk.icon_size_from_name('panucci-button') ) else: filename = util.find_data_file(filename) if filename is not None: image = gtk.image_new_from_file(filename) if image is not None: if platform.MAEMO: image.set_padding(20, 20) else: image.set_padding(5, 5) image.show() return image
def winkEvent(self, img, event, attrs): winkDir = os.path.join(self.winkCacheDir, attrs['class']) xmlfile = os.path.join(winkDir, 'content.xml') if not os.path.exists(xmlfile): return if event.type == gtk.gdk.BUTTON_PRESS: menu = gtk.Menu() menu_items = gtk.ImageMenuItem(_("_Play")) menu_items.set_image( gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY, gtk.ICON_SIZE_MENU)) menu.append(menu_items) swfFile = os.path.join(winkDir, self.getSwf(xmlfile)) menu_items.connect('activate', self.onplayWink, swfFile) menu_items.show() menu.popup(None, None, None, event.button, event.time)
def __init__(self, handler): """ constructor handler -- a e3common.Handler.AccountHandler """ gtk.Menu.__init__(self) self.handler = handler self.change_profile = gtk.ImageMenuItem('Change profile') self.change_profile.set_image( gtk.image_new_from_stock(gtk.STOCK_EDIT, gtk.ICON_SIZE_MENU)) self.change_profile.connect( 'activate', lambda *args: self.handler.change_profile()) self.append(self.change_profile)
def add_image_item(self, title, gtk_stock, func=None, param=None): item = gtk.ImageMenuItem(title) item.show() if gtk_stock: img = gtk.image_new_from_stock(gtk_stock, gtk.ICON_SIZE_MENU) item.set_image(img) logging.debug("Menu-Image-Activate" + title + str(gtk_stock) + str(func) + str(param)) if func and param: item.connect("activate", lambda *a: func(param)) elif func: item.connect("activate", lambda *a: func()) self.append(item) return item
def createToolButton(stock_id, label): ''' Create a toolbar button @param stock_id: Stock_id @param label: Label text ''' if label is not None: button = gtk.ToolButton(gtk.image_new_from_stock( stock_id, gtk.ICON_SIZE_MENU), label=label) else: button = gtk.ToolButton(stock_id=stock_id) button.set_is_important(True) return button
def progress_timeout(self): # Calculate the value of the progress bar if self.sampler.status == 'running': self.pbar.set_fraction(self.sampler._current_iter / self.sampler._iter) elif self.sampler.status == 'ready': self.pbar.set_fraction(0.) self.button2.set_label('Start') self.button2.set_image( gtk.image_new_from_stock('gtk-yes', gtk.ICON_SIZE_BUTTON)) return False else: # Sampling is interrupted. return False # As this is a timeout function, return TRUE so that it # continues to get called return True
def __create_widgets(self): self._title = gtk.Label() self._message = gtk.Label() self._icon = gtk.image_new_from_stock(gtk.STOCK_DIALOG_INFO, \ gtk.ICON_SIZE_MENU) self._message.set_alignment(0, 0.5) # We use label as separator self._top = gtk.Label() self._bottom = gtk.Label() self._right = gtk.Label() self._left = gtk.Label() self.vbox = gtk.VBox()
def add_flag(self, flag_type, tooltip_text=None): """Set the display of a flag denoting a property.""" if flag_type in self.var_flags: return self.var_flags.append(flag_type) stock_id = self.FLAG_ICON_MAP[flag_type] event_box = gtk.EventBox() event_box._flag_type = flag_type image = gtk.image_new_from_stock(stock_id, gtk.ICON_SIZE_MENU) image.set_tooltip_text(tooltip_text) image.show() event_box.add(image) event_box.show() event_box.connect("button-press-event", self._toggle_flag_label) self.hbox.pack_end(event_box, expand=False, fill=False, padding=rose.config_editor.SPACING_SUB_PAGE)
def __init__(self, stock_image, size=gtk.ICON_SIZE_LARGE_TOOLBAR): gtk.EventBox.__init__(self) self.button = gtk.Button() #self.button.set_sensitive(False) self.button.set_focus_on_click(False) self.button.set_relief(gtk.RELIEF_NONE) img = gtk.image_new_from_stock(stock_image, size) self.button.set_image(img) self.add(HBoxDecorator(self.button, gtk.Label("R"))) #self.button.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("red")) self.connect("button-press-event", self.on_click) self.button.connect("button-press-event", self.on_click1) self.insensetive = False
def __init__(self, value, metadata, set_value, hook, arg_str=None): super(LogicalArrayValueWidget, self).__init__(homogeneous=False, spacing=0) self.value = value self.metadata = metadata self.set_value = set_value self.hook = hook self.max_length = metadata[rose.META_PROP_LENGTH] value_array = rose.variable.array_split(value) if metadata.get(rose.META_PROP_TYPE) == "boolean": self.allowed_values = [ rose.TYPE_BOOLEAN_VALUE_FALSE, rose.TYPE_BOOLEAN_VALUE_TRUE ] self.label_dict = dict( zip(self.allowed_values, self.allowed_values)) else: self.allowed_values = [ rose.TYPE_LOGICAL_VALUE_FALSE, rose.TYPE_LOGICAL_VALUE_TRUE ] self.label_dict = { rose.TYPE_LOGICAL_VALUE_FALSE: rose.TYPE_LOGICAL_FALSE_TITLE, rose.TYPE_LOGICAL_VALUE_TRUE: rose.TYPE_LOGICAL_TRUE_TITLE } imgs = [(gtk.STOCK_MEDIA_STOP, gtk.ICON_SIZE_MENU), (gtk.STOCK_APPLY, gtk.ICON_SIZE_MENU)] self.make_log_image = lambda i: gtk.image_new_from_stock(*imgs[i]) self.chars_width = max([len(v) for v in value_array] + [1]) + 1 self.num_allowed_columns = 3 self.entry_table = gtk.Table(rows=1, columns=self.num_allowed_columns, homogeneous=True) self.entry_table.connect('focus-in-event', self.hook.trigger_scroll) self.entry_table.show() self.entries = [] for value_item in value_array: entry = self.get_entry(value_item) self.entries.append(entry) self.generate_buttons() self.populate_table() self.pack_start(self.button_box, expand=False, fill=False) self.pack_start(self.entry_table, expand=True, fill=True) self.entry_table.connect_after('size-allocate', lambda w, e: self.reshape_table()) self.connect('focus-in-event', lambda w, e: self.hook.get_focus(self.get_focus_entry()))
def __init__(self, presenter, level): """ """ self.presenter = presenter self.species = presenter.model table = self.presenter.view.widgets.infrasp_table nrows = table.props.n_rows ncols = table.props.n_columns self.level = level rank, epithet, author = self.species.get_infrasp(self.level) # rank combo self.rank_combo = gtk.ComboBox() self.presenter.view.init_translatable_combo(self.rank_combo, infrasp_rank_values) utils.set_widget_value(self.rank_combo, rank) presenter.view.connect(self.rank_combo, 'changed', self.on_rank_combo_changed) table.attach(self.rank_combo, 0, 1, level, level+1, xoptions=gtk.FILL, yoptions=-1) # epithet entry self.epithet_entry = gtk.Entry() utils.set_widget_value(self.epithet_entry, epithet) presenter.view.connect(self.epithet_entry, 'changed', self.on_epithet_entry_changed) table.attach(self.epithet_entry, 1, 2, level, level+1, xoptions=gtk.FILL | gtk.EXPAND, yoptions=-1) # author entry self.author_entry = gtk.Entry() utils.set_widget_value(self.author_entry, author) presenter.view.connect(self.author_entry, 'changed', self.on_author_entry_changed) table.attach(self.author_entry, 2, 3, level, level+1, xoptions=gtk.FILL | gtk.EXPAND, yoptions=-1) self.remove_button = gtk.Button() img = gtk.image_new_from_stock(gtk.STOCK_REMOVE, gtk.ICON_SIZE_BUTTON) self.remove_button.props.image = img presenter.view.connect(self.remove_button, 'clicked', self.on_remove_button_clicked) table.attach(self.remove_button, 3, 4, level, level+1, xoptions=gtk.FILL, yoptions=-1) table.show_all()
def __init__(self, session, list_type, init_path, radio=False, use_tabs=False): '''constructor''' DownloadListBase.__init__(self, session, radio, use_tabs) self.list_types = [list_type] self.current_collection = self.collections[list_type]['supported'] self.download_list = {} self.removable_list = {} refresh_button = gtk.Button(stock=gtk.STOCK_REFRESH) refresh_button.connect('clicked', self.on_update, True) self.download_button = gtk.Button(_('Download')) self.download_button.set_image(gtk.image_new_from_stock( gtk.STOCK_GO_DOWN, gtk.ICON_SIZE_MENU)) self.download_button.connect('clicked', self.start_download) self.download_button.set_property('no-show-all', True) self.remove_button = gtk.Button(stock=gtk.STOCK_REMOVE) self.remove_button.connect('clicked', self.remove) self.remove_button.set_property('no-show-all', True) self.no_button = gtk.HBox() self.no_button2 = gtk.HBox() combo_store = gtk.ListStore(str, str) combo_store.append((_('Supported'), 'supported')) combo_store.append((_('Community'), 'community')) source_combo = gtk.ComboBox() source_combo.set_model(combo_store) cell = gtk.CellRendererText() source_combo.pack_start(cell, True) source_combo.add_attribute(cell, 'text', 0) source_combo.set_active(0) source_combo.connect('changed', self.on_change_source) self.buttonbox.pack_start(source_combo, fill=False) self.buttonbox.pack_start(refresh_button, fill=False) self.buttonbox.pack_start(self.no_button) self.buttonbox.pack_start(self.no_button2) self.buttonbox.pack_start(self.remove_button, fill=False) self.buttonbox.pack_start(self.download_button, fill=False)
def __init__(self, message): super(ErrorDialog, self).__init__(parent=gui.widgets.get_object("main_window"), title=_("Error occured"), buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)) self.set_default_size(400, 300) self.error_label = gtk.Label() self.error_label.set_properties(width_chars=50, wrap=True, xalign=0.0) self.error_label.set_markup( _("<span size='larger' weight='bold'>Don't Panic!</span>\n\n" "An error occured – we apologize for that. " "Feel free to submit a bug report at " "<a href=\"https://bugs.launchpad.net/sushi\">" "https://bugs.launchpad.net/sushi</a>.")) self.tv = gtk.TextView() self.tv.get_buffer().set_text(message) self.sw = gtk.ScrolledWindow() self.sw.set_properties(shadow_type=gtk.SHADOW_ETCHED_IN, hscrollbar_policy=gtk.POLICY_AUTOMATIC, vscrollbar_policy=gtk.POLICY_AUTOMATIC) self.sw.add(self.tv) self.vbox_inner = gtk.VBox() self.vbox_inner.set_property("border-width", 6) hbox = gtk.HBox() hbox.set_property("border-width", 6) hbox.set_spacing(12) hbox.pack_start(gtk.image_new_from_stock(gtk.STOCK_DIALOG_INFO, gtk.ICON_SIZE_DIALOG), expand=False) hbox.pack_end(self.error_label) align = gtk.Alignment() align.add(hbox) align.set_padding(0, 6, 0, 0) self.vbox_inner.pack_start(align, expand=False) self.vbox_inner.pack_start(self.sw) self.vbox.pack_start(self.vbox_inner)
def __init__(self, iconname, text, onclose): gtk.HBox.__init__(self, False, 4) label = gtk.Label(text) # FIXME: ideally, we would use custom ellipsization that ellipsized the # two paths separately, but that requires significant changes to label # generation in many different parts of the code label.set_ellipsize(pango.ELLIPSIZE_MIDDLE) label.set_single_line_mode(True) label.set_alignment(0.0, 0.5) label.set_padding(0, 0) context = self.get_pango_context() metrics = context.get_metrics(self.style.font_desc, context.get_language()) char_width = metrics.get_approximate_digit_width() (w, h) = gtk.icon_size_lookup_for_settings(self.get_settings(), gtk.ICON_SIZE_MENU) self.set_size_request( self.tab_width_in_chars * pango.PIXELS(char_width) + 2 * w, -1) button = gtk.Button() button.set_relief(gtk.RELIEF_NONE) button.set_focus_on_click(False) image = gtk.image_new_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU) image.set_tooltip_text(_("Close tab")) button.add(image) button.set_name("meld-tab-close-button") button.set_size_request(w + 2, h + 2) button.connect("clicked", onclose) icon = gtk.image_new_from_icon_name(iconname, gtk.ICON_SIZE_MENU) label_box = gtk.EventBox() label_box.add_events(gtk.gdk.BUTTON_PRESS_MASK) label_box.props.visible_window = False label_box.connect("button-press-event", self.on_label_clicked) label_box.add(label) self.pack_start(icon, expand=False) self.pack_start(label_box) self.pack_start(button, expand=False) self.set_tooltip_text(text) self.show_all() self.__label = label self.__onclose = onclose
def get_warning_message_dialog_panel(primary_txt, secondary_txt, is_info=False, alternative_icon=None): if is_info == True: icon = gtk.STOCK_DIALOG_INFO else: icon = gtk.STOCK_DIALOG_WARNING if alternative_icon != None: icon = alternative_icon warning_icon = gtk.image_new_from_stock(icon, gtk.ICON_SIZE_DIALOG) icon_box = gtk.VBox(False, 2) icon_box.pack_start(warning_icon, False, False, 0) icon_box.pack_start(gtk.Label(), True, True, 0) p_label = guiutils.bold_label(primary_txt) s_label = gtk.Label(secondary_txt) s_label.set_use_markup(True) texts_pad = gtk.Label() texts_pad.set_size_request(12, 12) pbox = gtk.HBox(False, 1) pbox.pack_start(p_label, False, False, 0) pbox.pack_start(gtk.Label(), True, True, 0) sbox = gtk.HBox(False, 1) sbox.pack_start(s_label, False, False, 0) sbox.pack_start(gtk.Label(), True, True, 0) text_box = gtk.VBox(False, 0) text_box.pack_start(pbox, False, False, 0) text_box.pack_start(texts_pad, False, False, 0) text_box.pack_start(sbox, False, False, 0) text_box.pack_start(gtk.Label(), True, True, 0) hbox = gtk.HBox(False, 12) hbox.pack_start(icon_box, False, False, 0) hbox.pack_start(text_box, True, True, 0) align = gtk.Alignment(0.5, 0.5, 1.0, 1.0) align.set_padding(12, 0, 12, 12) align.add(hbox) return align
def _on_editor_help_button_activate(self, event): dialog = gtk.Dialog(title=_("Tag Editor Help"), parent=None, flags=gtk.DIALOG_MODAL, buttons=(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)) hbox = gtk.HBox() hbox.set_spacing(12) image = gtk.image_new_from_stock(gtk.STOCK_DIALOG_INFO, gtk.ICON_SIZE_DIALOG) hbox.pack_start(image, False, False, 12) label = gtk.Label(_("""Select a tag in the list on the left, and all the feeds with that tag will be marked on the right. You may mark and unmark feeds to add or remove that tag from them. Tagged feeds will appear at the top of the list.""")) label.set_line_wrap(True) hbox.pack_start(label, True, True, 0) dialog.vbox.pack_start(hbox, True, True, 0) dialog.show_all() dialog.resize(400,-1) response = dialog.run() dialog.hide() del dialog
def on_view_populate_popup(self, view, menu): # taken from gedit-plugins-python-openuricontextmenu doc = view.get_buffer() win = view.get_window(gtk.TEXT_WINDOW_TEXT) x, y, mod = win.get_pointer() x, y = view.window_to_buffer_coords(gtk.TEXT_WINDOW_TEXT, x, y) # first try at pointer location insert = view.get_iter_at_location(x, y) # second try at cursor if insert == None: insert = doc.get_iter_at_mark(doc.get_insert()) while insert.forward_char(): if not RE_DELIM.match(insert.get_char()): break start = insert.copy() while start.backward_char(): if not RE_DELIM.match(start.get_char()): start.forward_char() break word = unicode(doc.get_text(start, insert)) if len(word) == 0: return True word = self.validate_word(word) if not word: return True open_quicktorial_item = gtk.ImageMenuItem( _("Know more about '%s'") % (word)) open_quicktorial_item.set_image( gtk.image_new_from_stock(gtk.STOCK_JUMP_TO, gtk.ICON_SIZE_MENU)) open_quicktorial_item.connect('activate', self.on_open_quicktorial, word) open_quicktorial_item.show() separator = gtk.SeparatorMenuItem() separator.show() menu.prepend(separator) menu.prepend(open_quicktorial_item)
def __init__(self, property_type='text'): gtk.HBox.__init__(self, homogeneous=False, spacing=5) # Informs of special formatting required self.property_type = property_type self.field = gtk.Entry() self.field.set_editable(False) self.pack_start(self.field) self.parent_row = None if self.property_type == 'location': self.folder_button = gtk.Button() self.folder_button.set_tooltip_text(_('Open Directory')) self.folder_button.set_image( gtk.image_new_from_stock(gtk.STOCK_OPEN, gtk.ICON_SIZE_BUTTON)) self.pack_start(self.folder_button, expand=False, fill=False) self.folder_button.connect("clicked", self.folder_button_clicked)
def __init__(self, ui, enabled): super(OmemoMenu, self).__init__() self.ui = ui self.item_omemo_state = gtk.CheckMenuItem('Activate OMEMO') self.item_omemo_state.set_active(enabled) self.item_omemo_state.connect('activate', self.on_toggle_omemo) self.append(self.item_omemo_state) item = gtk.ImageMenuItem('Fingerprints') icon = gtk.image_new_from_stock(gtk.STOCK_DIALOG_AUTHENTICATION, gtk.ICON_SIZE_MENU) item.set_image(icon) item.connect('activate', self.on_open_fingerprint_window) self.append(item) self.show_all()
def __init__(self, value, metadata, set_value, hook, arg_str=None): super(RowArrayValueWidget, self).__init__(homogeneous=False, spacing=0) self.value = value self.metadata = metadata self.set_value = set_value self.hook = hook self.value_array = rose.variable.array_split(value) self.extra_array = [] # For new rows self.element_values = [] self.rows = [] self.widgets = [] self.has_length_error = False self.length = metadata.get(rose.META_PROP_LENGTH) self.type = metadata.get(rose.META_PROP_TYPE, "raw") self.num_cols = len(self.value_array) if arg_str is None: if isinstance(self.type, list): self.num_cols = len(self.type) elif self.length is not None and self.length.isdigit(): self.num_cols = int(self.length) else: self.num_cols = int(arg_str) self.unlimited = (self.length == ':') if self.unlimited: self.array_length = 1 else: self.array_length = metadata.get(rose.META_PROP_LENGTH, 1) log_imgs = [(gtk.STOCK_MEDIA_STOP, gtk.ICON_SIZE_MENU), (gtk.STOCK_APPLY, gtk.ICON_SIZE_MENU), (gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_MENU)] self.make_log_image = lambda i: gtk.image_new_from_stock(*log_imgs[i]) self.set_num_rows() self.entry_table = gtk.Table(rows=self.num_rows, columns=self.num_cols, homogeneous=True) self.entry_table.connect('focus-in-event', self.hook.trigger_scroll) self.entry_table.show() for r in range(self.num_rows): self.insert_row(r) self.normalise_width_widgets() self.generate_buttons(is_for_elements=not isinstance(self.type, list)) self.pack_start(self.add_del_button_box, expand=False, fill=False) self.pack_start(self.entry_table, expand=True, fill=True) self.show()
def pop_up(self, iconview, event): ''' manage the context menu (?) ''' if event.button == 3 and self.iconv_type != IconView.TYPE_SYSTEM_PICS: path = self.iconview.get_path_at_pos(int(event.x), int(event.y)) if path != None: self.iconview.select_path(path) if self.on_remove_cb != None: remove_menu = gtk.Menu() remove_item = gtk.ImageMenuItem(_('Delete')) remove_item.set_image(gtk.image_new_from_stock(\ gtk.STOCK_REMOVE, gtk.ICON_SIZE_MENU)) remove_item.connect('activate', self.on_remove_cb) remove_menu.append(remove_item) remove_menu.popup(None, None, None, event.button, event.time) remove_menu.show_all()
def __init__(self, title, gtk_stock, tooltip=None): gtk.Button.__init__(self, "") if not tooltip: tooltip = title self.set_tooltip_text(tooltip) label = self.get_child() self.remove(label) box = gtk.HBox(False, 0) img = gtk.image_new_from_stock(gtk_stock, gtk.ICON_SIZE_MENU) box.add(img) box.add(gtk.Label(title)) box.show_all() self.add(box)
def create_widgets(): """ Widgets for editing clip effects properties. """ widgets.clip_info = guicomponents.ClipInfoPanel() widgets.exit_button = gtk.Button() icon = gtk.image_new_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU) widgets.exit_button.set_image(icon) widgets.exit_button.connect("clicked", lambda w: _quit_editing_clip_clicked()) widgets.exit_button.set_tooltip_text(_("Quit editing Clip in editor")) widgets.effect_stack_view = guicomponents.FilterSwitchListView( lambda ts: effect_selection_changed(), toggle_filter_active) dnd.connect_stack_treeview(widgets.effect_stack_view) gui.effect_stack_list_view = widgets.effect_stack_view widgets.value_edit_box = gtk.VBox() widgets.value_edit_frame = gtk.Frame() widgets.value_edit_frame.set_shadow_type(gtk.SHADOW_NONE) widgets.value_edit_frame.add(widgets.value_edit_box) widgets.add_effect_b = gtk.Button(_("Add")) widgets.del_effect_b = gtk.Button(_("Delete")) widgets.toggle_all = gtk.Button() widgets.toggle_all.set_image( gtk.image_new_from_file(respaths.IMAGE_PATH + "filters_all_toggle.png")) widgets.add_effect_b.connect("clicked", lambda w, e: add_effect_pressed(), None) widgets.del_effect_b.connect("clicked", lambda w, e: delete_effect_pressed(), None) widgets.toggle_all.connect("clicked", lambda w: toggle_all_pressed()) # These are created elsewhere and then monkeypatched here widgets.group_combo = None widgets.effect_list_view = None widgets.clip_info.set_tooltip_text(_("Clip being edited")) widgets.effect_stack_view.set_tooltip_text(_("Clip Filter Stack")) widgets.add_effect_b.set_tooltip_text(_("Add Filter to Clip Filter Stack")) widgets.del_effect_b.set_tooltip_text( _("Delete Filter from Clip Filter Stack")) widgets.toggle_all.set_tooltip_text(_("Toggle all Filters On/Off"))
def _on_queue_row_button_press(self, widget, event): if event.button==3: #right click menu = gtk.Menu() path = widget.get_path_at_pos(int(event.x),int(event.y)) model = widget.get_model() if path is None: #nothing selected return item = gtk.ImageMenuItem(_("_Remove")) img = gtk.image_new_from_stock('gtk-remove',gtk.ICON_SIZE_MENU) item.set_image(img) item.connect('activate',self._on_remove_clicked) menu.append(item) menu.show_all() menu.popup(None,None,None, event.button,event.time)
def on_playback_start(self, type, player, object): """ Called when playback starts Sets the currently playing track visible in the currently selected playlist if the user has chosen this setting """ if self.resuming: self.resuming = False return self._update_track_information() glib.idle_add( self.playpause_button.set_image, gtk.image_new_from_stock(gtk.STOCK_MEDIA_PAUSE, gtk.ICON_SIZE_SMALL_TOOLBAR)) glib.idle_add(self.playpause_button.set_tooltip_text, _('Pause Playback'))
def make_basic_dialog(title, buttons, stock_image): flags = gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT | \ gtk.DIALOG_NO_SEPARATOR dialog = gtk.Dialog(title, flags=flags, buttons=buttons) box = gtk.HBox() box.add(gtk.image_new_from_stock(stock_image, gtk.ICON_SIZE_DIALOG)) vbox = gtk.VBox() box.add(vbox) box.set_spacing(12) vbox.set_spacing(6) alignment = gtk.Alignment() alignment.set_padding(6, 6, 6, 6) alignment.add(box) dialog.vbox.add(alignment) return dialog, vbox
def __init__(self, session): DownloadListBase.__init__(self, session) self.update_list = {'plugins': {}, 'themes': {}} self.update_amount = 0 self.themes = {} self.theme_names = {} self.theme_configs = {} self.download_button = gtk.Button(_('Update')) self.download_button.set_image( gtk.image_new_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_MENU)) self.download_button.connect('clicked', self.start_download) self.buttonbox.set_layout(gtk.BUTTONBOX_END) self.buttonbox.pack_start(self.download_button, fill=False)