def __init__(self): super(Guake, self).__init__(gladefile('guake.glade')) self.client = gconf.client_get_default() # setting global hotkey and showing a pretty notification =) guake.globalhotkeys.init() # Cannot use "getattr(gtk.Window().get_style(), "base")[int(gtk.STATE_SELECTED)]" # since theme has not been applied before first show_all self.selected_color = None self.isPromptQuitDialogOpened = False self.hidden = True self.forceHide = False # trayicon! try: import appindicator except ImportError: img = pixmapfile('guake-tray.png') self.tray_icon = gtk.status_icon_new_from_file(img) self.tray_icon.set_tooltip(_('Guake Terminal')) self.tray_icon.connect('popup-menu', self.show_menu) self.tray_icon.connect('activate', self.show_hide) else: self.tray_icon = appindicator.Indicator( _("guake-indicator"), _("guake-tray"), appindicator.CATEGORY_OTHER) self.tray_icon.set_icon("guake-tray") self.tray_icon.set_status(appindicator.STATUS_ACTIVE) menu = self.get_widget('tray-menu') show = gtk.MenuItem(_('Show')) show.set_sensitive(True) show.connect('activate', self.show_hide) show.show() menu.prepend(show) self.tray_icon.set_menu(menu) # adding images from a different path. ipath = pixmapfile('guake.png') self.get_widget('image1').set_from_file(ipath) ipath = pixmapfile('add_tab.png') self.get_widget('image2').set_from_file(ipath) # important widgets self.window = self.get_widget('window-root') self.mainframe = self.get_widget('mainframe') self.mainframe.remove(self.get_widget('notebook-teminals')) self.notebook = GuakeNotebook() self.notebook.set_name("notebook-teminals") self.notebook.set_property("tab_pos", "bottom") self.notebook.set_property("show_tabs", False) self.notebook.set_property("show_border", False) self.notebook.set_property("visible", True) self.notebook.set_property("has_focus", True) self.notebook.set_property("can_focus", True) self.notebook.set_property("is_focus", True) self.notebook.set_property("enable_popup", True) self.notebook.connect("switch_page", self.select_current_tab) self.mainframe.add(self.notebook) self.set_tab_position() self.tabs = self.get_widget('hbox-tabs') self.toolbar = self.get_widget('toolbar') self.mainframe = self.get_widget('mainframe') self.resizer = self.get_widget('resizer') # check and set ARGB for real transparency screen = self.window.get_screen() colormap = screen.get_rgba_colormap() if colormap is None: self.has_argb = False else: self.window.set_colormap(colormap) self.has_argb = self.window.get_screen().is_composited() def composited_changed(screen): self.has_argb = screen.is_composited() self.set_background_transparency( self.client.get_int(KEY('/style/background/transparency'))) self.set_background_image( self.client.get_string(KEY('/style/background/image'))) self.window.get_screen().connect("composited-changed", composited_changed) # It's intended to know which tab was selected to # close/rename. This attribute will be set in # self.show_tab_menu self.selected_tab = None # holds fullscreen status self.is_fullscreen = False # holds the timestamp of the losefocus event self.losefocus_time = 0 # holds the timestamp of the previous show/hide action self.prev_showhide_time = 0 # double click stuff def double_click(hbox, event): """Handles double clicks on tabs area and when receive one, calls add_tab. """ if event.button == 1 and event.type == gtk.gdk._2BUTTON_PRESS: self.add_tab() evtbox = self.get_widget('event-tabs') evtbox.connect('button-press-event', double_click) # Flag to prevent guake hide when window_losefocus is true and # user tries to use the context menu. self.showing_context_menu = False def hide_context_menu(menu): """Turn context menu flag off to make sure it is not being shown. """ self.showing_context_menu = False self.get_widget('context-menu').connect('hide', hide_context_menu) self.get_widget('tab-menu').connect('hide', hide_context_menu) self.window.connect('focus-out-event', self.on_window_losefocus) # Handling the delete-event of the main window to avoid # problems when closing it. def destroy(*args): self.hide() return True self.window.connect('delete-event', destroy) # Flag to completely disable losefocus hiding self.disable_losefocus_hiding = False # this line is important to resize the main window and make it # smaller. self.window.set_geometry_hints(min_width=1, min_height=1) # special trick to avoid the "lost guake on Ubuntu 'Show Desktop'" problem. # DOCK makes the window foundable after having being "lost" after "Show Desktop" self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DOCK) # Restore back to normal behavior self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_NORMAL) # resizer stuff self.resizer.connect('motion-notify-event', self.on_resizer_drag) # adding the first tab on guake self.add_tab() # loading and setting up configuration stuff GConfHandler(self) GConfKeyHandler(self) self.hotkeys = guake.globalhotkeys.GlobalHotkey() self.load_config() key = self.client.get_string(GKEY('show_hide')) keyval, mask = gtk.accelerator_parse(key) label = gtk.accelerator_get_label(keyval, mask) filename = pixmapfile('guake-notification.png') if self.client.get_bool(KEY('/general/start_fullscreen')): self.fullscreen() if not self.hotkeys.bind(key, self.show_hide): guake.notifier.show_message( _('Guake!'), _('A problem happened when binding <b>%s</b> key.\n' 'Please use Guake Preferences dialog to choose another ' 'key') % xml_escape(label), filename) self.client.set_bool(KEY('/general/use_trayicon'), True) elif self.client.get_bool(KEY('/general/use_popup')): # Pop-up that shows that guake is working properly (if not # unset in the preferences windows) guake.notifier.show_message( _('Guake!'), _('Guake is now running,\n' 'press <b>%s</b> to use it.') % xml_escape(label), filename)
def __init__(self, widget, boton, pos, tiempo, path, modelo): gtk.Menu.__init__(self) _iter = modelo.get_iter(path) uri = modelo.get_value(_iter, 2) quitar = gtk.MenuItem("Quitar de la Lista") self.append(quitar) quitar.connect_object("activate", self.__emit_accion, widget, path, "Quitar") my_files_directory = get_my_files_directory() if describe_acceso_uri(uri): lectura, escritura, ejecucion = describe_acceso_uri(uri) if lectura and os.path.dirname(uri) != my_files_directory: copiar = gtk.MenuItem("Copiar a JAMedia") self.append(copiar) copiar.connect_object("activate", self.__emit_accion, widget, path, "Copiar") if escritura and os.path.dirname(uri) != my_files_directory: mover = gtk.MenuItem("Mover a JAMedia") self.append(mover) mover.connect_object("activate", self.__emit_accion, widget, path, "Mover") if escritura: borrar = gtk.MenuItem("Borrar el Archivo") self.append(borrar) borrar.connect_object("activate", self.__emit_accion, widget, path, "Borrar") #tipo = describe_archivo(uri) #if "audio" in tipo or "video" in tipo or "application/ogg" in tipo: # editar = gtk.MenuItem("Editar o Convertir Archivo") # self.append(editar) # editar.connect_object("activate", self.__emit_accion, # widget, path, "Editar") else: borrar = gtk.MenuItem("Borrar Streaming") self.append(borrar) borrar.connect_object("activate", self.__emit_accion, widget, path, "Borrar") listas = [ os.path.join(get_data_directory(), "JAMediaTV.JAMedia"), os.path.join(get_data_directory(), "JAMediaRadio.JAMedia"), os.path.join(get_data_directory(), "MisRadios.JAMedia"), os.path.join(get_data_directory(), "MisTvs.JAMedia"), os.path.join(get_data_directory(), "JAMediaWebCams.JAMedia"), ] jtv = stream_en_archivo(uri, listas[0]) jr = stream_en_archivo(uri, listas[1]) r = stream_en_archivo(uri, listas[2]) tv = stream_en_archivo(uri, listas[3]) webcam = stream_en_archivo(uri, listas[4]) if (jtv and not tv) or (jr and not r): copiar = gtk.MenuItem("Copiar a JAMedia") self.append(copiar) copiar.connect_object("activate", self.__emit_accion, widget, path, "Copiar") mover = gtk.MenuItem("Mover a JAMedia") self.append(mover) mover.connect_object("activate", self.__emit_accion, widget, path, "Mover") grabar = gtk.MenuItem("Grabar") self.append(grabar) grabar.connect_object("activate", self.__emit_accion, widget, path, "Grabar") self.show_all() self.attach_to_widget(widget, self.__null)
def Generate(self): self.clear() appl = AppletService() items = [] if not self.is_popup or self.props.visible: device = self.Blueman.List.get(self.Blueman.List.selected(), "device")["device"] else: (x, y) = self.Blueman.List.get_pointer() path = self.Blueman.List.get_path_at_pos(x, y) if path != None: device = self.Blueman.List.get(path[0][0], "device")["device"] else: return if not device.Valid: return self.SelectedDevice = device op = self.get_op(device) if op != None: item = create_menuitem(op, get_icon("gtk-connect", 16)) item.props.sensitive = False item.show() self.append(item) return rets = self.Blueman.Plugins.Run("on_request_menu_items", self, device) for ret in rets: if ret: for (item, pos) in ret: items.append((pos, item)) if device.Fake: item = create_menuitem(_("_Add Device"), get_icon("gtk-add", 16)) self.Signals.Handle("gobject", item, "activate", lambda x: self.Blueman.add_device(device)) item.show() self.append(item) item.props.tooltip_text = _( "Add this device to known devices list") item = create_menuitem(_("_Setup..."), get_icon("gtk-properties", 16)) self.append(item) self.Signals.Handle("gobject", item, "activate", lambda x: self.Blueman.setup(device)) item.show() item.props.tooltip_text = _( "Run the setup assistant for this device") item = create_menuitem(_("_Pair"), get_icon("gtk-dialog-authentication", 16)) self.Signals.Handle("gobject", item, "activate", lambda x: self.Blueman.bond(device)) self.append(item) item.show() item.props.tooltip_text = _("Pair with the device") item = gtk.SeparatorMenuItem() item.show() self.append(item) send_item = create_menuitem(_("Send a _File..."), get_icon("gtk-copy", 16)) self.Signals.Handle("gobject", send_item, "activate", lambda x: self.Blueman.send(device)) send_item.show() self.append(send_item) else: dprint(device.Alias) item = None have_disconnectables = False have_connectables = False if True in map(lambda x: x[0] >= 100 and x[0] < 200, items): have_disconnectables = True if True in map(lambda x: x[0] < 100, items): have_connectables = True if True in map(lambda x: x[0] >= 200, items) and (have_connectables or have_disconnectables): item = gtk.SeparatorMenuItem() item.show() items.append((199, item)) if have_connectables: item = gtk.MenuItem() label = gtk.Label() label.set_markup(_("<b>Connect To:</b>")) label.props.xalign = 0.0 label.show() item.add(label) item.props.sensitive = False item.show() items.append((0, item)) if have_disconnectables: item = gtk.MenuItem() label = gtk.Label() label.set_markup(_("<b>Disconnect:</b>")) label.props.xalign = 0.0 label.show() item.add(label) item.props.sensitive = False item.show() items.append((99, item)) items.sort(lambda a, b: cmp(a[0], b[0])) for priority, item in items: self.append(item) if items != []: item = gtk.SeparatorMenuItem() item.show() self.append(item) del items send_item = create_menuitem(_("Send a _File..."), get_icon("gtk-copy", 16)) send_item.props.sensitive = False self.append(send_item) send_item.show() browse_item = create_menuitem(_("_Browse Device..."), get_icon("gtk-open", 16)) browse_item.props.sensitive = False self.append(browse_item) browse_item.show() uuids = device.UUIDs for uuid in uuids: uuid16 = uuid128_to_uuid16(uuid) if uuid16 == OBEX_OBJPUSH_SVCLASS_ID: self.Signals.Handle("gobject", send_item, "activate", lambda x: self.Blueman.send(device)) send_item.props.sensitive = True if uuid16 == OBEX_FILETRANS_SVCLASS_ID: self.Signals.Handle("gobject", browse_item, "activate", lambda x: self.Blueman.browse(device)) browse_item.props.sensitive = True item = gtk.SeparatorMenuItem() item.show() self.append(item) item = create_menuitem(_("_Pair"), get_icon("gtk-dialog-authentication", 16)) item.props.tooltip_text = _("Create pairing with the device") self.append(item) item.show() if not device.Paired: self.Signals.Handle("gobject", item, "activate", lambda x: self.Blueman.bond(device)) else: item.props.sensitive = False if not device.Trusted: item = create_menuitem(_("_Trust"), get_icon("blueman-trust", 16)) self.Signals.Handle( "gobject", item, "activate", lambda x: self.Blueman.toggle_trust(device)) self.append(item) item.show() else: item = create_menuitem(_("_Untrust"), get_icon("blueman-untrust", 16)) self.append(item) self.Signals.Handle( "gobject", item, "activate", lambda x: self.Blueman.toggle_trust(device)) item.show() item.props.tooltip_text = _("Mark/Unmark this device as trusted") item = create_menuitem(_("_Setup..."), get_icon("gtk-properties", 16)) self.append(item) self.Signals.Handle("gobject", item, "activate", lambda x: self.Blueman.setup(device)) item.show() item.props.tooltip_text = _( "Run the setup assistant for this device") def update_services(item): def reply(): self.unset_op(device) prog.message(_("Success!")) MessageArea.close() def error(*args): self.unset_op(device) prog.message(_("Fail")) MessageArea.show_message(e_(str(args[0]))) prog = ManagerProgressbar(self.Blueman, False, _("Refreshing")) prog.start() self.set_op(device, _("Refreshing Services...")) appl.RefreshServices(device.GetObjectPath(), reply_handler=reply, error_handler=error) item = create_menuitem(_("Refresh Services"), get_icon("gtk-refresh", 16)) self.append(item) self.Signals.Handle(item, "activate", update_services) item.show() item = gtk.SeparatorMenuItem() item.show() self.append(item) item = create_menuitem(_("_Remove..."), get_icon("gtk-delete", 16)) self.Signals.Handle(item, "activate", lambda x: self.Blueman.remove(device)) self.append(item) item.show() item.props.tooltip_text = _( "Remove this device from the known devices list") item = gtk.SeparatorMenuItem() item.show() self.append(item) item = create_menuitem(_("_Disconnect"), get_icon("gtk-disconnect", 16)) item.props.tooltip_text = _("Forcefully disconnect the device") self.append(item) item.show() def on_disconnect(item): def finished(*args): self.unset_op(device) self.set_op(device, _("Disconnecting...")) self.Blueman.disconnect(device, reply_handler=finished, error_handler=finished) if device.Connected: self.Signals.Handle(item, "activate", on_disconnect) else: item.props.sensitive = False
def get_gpanel_scan_menu(suite_keys, theme_name, set_theme_func, has_stopped_suites, clear_stopped_suites_func, scanned_hosts, change_hosts_func, update_now_func, start_func, program_name, extra_items=None, owner=None, is_stopped=False): """Return a right click menu for the gpanel GUI. TODO this used to be for gscan too; simplify now it's only for gpanel? suite_keys should be a list of (host, owner, suite) tuples (if any). theme_name should be the name of the current theme. set_theme_func should be a function accepting a new theme name. has_stopped_suites should be a boolean denoting currently stopped suites. clear_stopped_suites should be a function with no arguments that removes stopped suites from the current view. scanned_hosts should be a list of currently scanned suite hosts. change_hosts_func should be a function accepting a new list of suite hosts to scan. update_now_func should be a function with no arguments that forces an update now or soon. start_func should be a function with no arguments that re-activates idle GUIs. program_name should be a string describing the parent program. extra_items (keyword) should be a list of extra menu items to add to the right click menu. owner (keyword) should be the owner of the suites, if not the current user. is_stopped (keyword) denotes whether the GUI is in an inactive state. """ menu = gtk.Menu() if is_stopped: switch_on_item = gtk.ImageMenuItem("Activate") img = gtk.image_new_from_stock(gtk.STOCK_YES, gtk.ICON_SIZE_MENU) switch_on_item.set_image(img) switch_on_item.show() switch_on_item.connect("button-press-event", lambda b, e: start_func()) menu.append(switch_on_item) # Construct gcylc launcher items for each relevant suite. for host, owner, suite in suite_keys: gcylc_item = gtk.ImageMenuItem("Launch gcylc: %s - %s@%s" % (suite.replace('_', '__'), owner, host)) img_gcylc = gtk.image_new_from_stock("gcylc", gtk.ICON_SIZE_MENU) gcylc_item.set_image(img_gcylc) gcylc_item._connect_args = (host, owner, suite) gcylc_item.connect("button-press-event", lambda b, e: launch_gcylc(b._connect_args)) gcylc_item.show() menu.append(gcylc_item) if suite_keys: sep_item = gtk.SeparatorMenuItem() sep_item.show() menu.append(sep_item) if extra_items is not None: for item in extra_items: menu.append(item) sep_item = gtk.SeparatorMenuItem() sep_item.show() menu.append(sep_item) # Construct a cylc stop item to stop a suite if len(suite_keys) > 1: stoptask_item = gtk.ImageMenuItem('Stop all') else: stoptask_item = gtk.ImageMenuItem('Stop') img_stop = gtk.image_new_from_stock(gtk.STOCK_MEDIA_STOP, gtk.ICON_SIZE_MENU) stoptask_item.set_image(img_stop) stoptask_item._connect_args = suite_keys, 'stop' stoptask_item.connect( "button-press-event", lambda b, e: call_cylc_command(b._connect_args[0], b._connect_args[1])) stoptask_item.show() menu.append(stoptask_item) # Construct a cylc hold item to hold (pause) a suite if len(suite_keys) > 1: holdtask_item = gtk.ImageMenuItem('Hold all') else: holdtask_item = gtk.ImageMenuItem('Hold') img_hold = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PAUSE, gtk.ICON_SIZE_MENU) holdtask_item.set_image(img_hold) holdtask_item._connect_args = suite_keys, 'hold' holdtask_item.connect( "button-press-event", lambda b, e: call_cylc_command(b._connect_args[0], b._connect_args[1])) menu.append(holdtask_item) holdtask_item.show() # Construct a cylc release item to release a paused/stopped suite if len(suite_keys) > 1: unstoptask_item = gtk.ImageMenuItem('Release all') else: unstoptask_item = gtk.ImageMenuItem('Release') img_release = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY, gtk.ICON_SIZE_MENU) unstoptask_item.set_image(img_release) unstoptask_item._connect_args = suite_keys, 'release' unstoptask_item.connect( "button-press-event", lambda b, e: call_cylc_command(b._connect_args[0], b._connect_args[1])) unstoptask_item.show() menu.append(unstoptask_item) # Add another separator sep_item = gtk.SeparatorMenuItem() sep_item.show() menu.append(sep_item) # Construct theme chooser items (same as cylc.gui.app_main). theme_item = gtk.ImageMenuItem('Theme') img = gtk.image_new_from_stock(gtk.STOCK_SELECT_COLOR, gtk.ICON_SIZE_MENU) theme_item.set_image(img) theme_item.set_sensitive(not is_stopped) thememenu = gtk.Menu() theme_item.set_submenu(thememenu) theme_item.show() theme_items = {} theme = "default" theme_items[theme] = gtk.RadioMenuItem(label=theme) thememenu.append(theme_items[theme]) theme_items[theme].theme_name = theme for theme in gcfg.get(['themes']): if theme == "default": continue theme_items[theme] = gtk.RadioMenuItem(group=theme_items['default'], label=theme) thememenu.append(theme_items[theme]) theme_items[theme].theme_name = theme # set_active then connect, to avoid causing an unnecessary toggle now. theme_items[theme_name].set_active(True) for theme in gcfg.get(['themes']): theme_items[theme].show() theme_items[theme].connect( 'toggled', lambda i: (i.get_active() and set_theme_func(i.theme_name))) menu.append(theme_item) theme_legend_item = gtk.MenuItem("Show task state key") theme_legend_item.show() theme_legend_item.set_sensitive(not is_stopped) theme_legend_item.connect( "button-press-event", lambda b, e: ThemeLegendWindow(None, gcfg.get(['themes', theme_name]))) menu.append(theme_legend_item) sep_item = gtk.SeparatorMenuItem() sep_item.show() menu.append(sep_item) # Construct a trigger update item. update_now_item = gtk.ImageMenuItem("Update Now") img = gtk.image_new_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_MENU) update_now_item.set_image(img) update_now_item.show() update_now_item.set_sensitive(not is_stopped) update_now_item.connect("button-press-event", lambda b, e: update_now_func()) menu.append(update_now_item) # Construct a clean stopped suites item. clear_item = gtk.ImageMenuItem("Clear Stopped Suites") img = gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU) clear_item.set_image(img) clear_item.show() clear_item.set_sensitive(has_stopped_suites) clear_item.connect("button-press-event", lambda b, e: clear_stopped_suites_func()) menu.append(clear_item) # Construct a configure scanned hosts item. hosts_item = gtk.ImageMenuItem("Configure Hosts") img = gtk.image_new_from_stock(gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_MENU) hosts_item.set_image(img) hosts_item.show() hosts_item.connect( "button-press-event", lambda b, e: launch_hosts_dialog(scanned_hosts, change_hosts_func)) menu.append(hosts_item) sep_item = gtk.SeparatorMenuItem() sep_item.show() menu.append(sep_item) # Construct an about dialog item. info_item = gtk.ImageMenuItem("About") img = gtk.image_new_from_stock(gtk.STOCK_ABOUT, gtk.ICON_SIZE_MENU) info_item.set_image(img) info_item.show() info_item.connect( "button-press-event", lambda b, e: launch_about_dialog(program_name, scanned_hosts)) menu.append(info_item) return menu
class rotateindicator: controller=AutoRotateController.AutoRotateController(dbus.SystemBus(),"/rotate"); monitor=AutoRotateDaemonMonitor.AutoRotateDaemonMonitor(dbus.SystemBus(),"/rotate"); auto_menu_item = gtk.MenuItem(" Automatic") daemon_menu_item=gtk.MenuItem("Auto-Rotate Daemon"); def setRotation(self,widget,direction): codes={"Normal":xrandr.RR_ROTATE_0, "Left":xrandr.RR_ROTATE_90, "Inverted":xrandr.RR_ROTATE_180, "Right":xrandr.RR_ROTATE_270}; self.controller.setRotation(codes[direction]); def refreshLabels(self): if(self.monitor.isDaemonRunning()): self.daemon_menu_item.set_label("Stop Auto-Rotate Daemon") self.auto_menu_item.set_sensitive(1); else: self.daemon_menu_item.set_label("Start Auto-Rotate Daemon") self.auto_menu_item.set_sensitive(0); def startStopDaemon(self,widget): if(self.monitor.isDaemonRunning()): self.monitor.killDaemon(); else: os.system("auto-rotate.py -d"); def serviceCheck(self,name): self.refreshLabels(); def __init__(self): # Setup some callbacks to update the status of the buttons self.monitor.daemon_status_callback=self.serviceCheck; ind = appindicator.Indicator ("autorotate-client", "gsd-xrandr", appindicator.CATEGORY_APPLICATION_STATUS) ind.set_status (appindicator.STATUS_ACTIVE) ind.set_attention_icon ("indicator-messages-new") # create a menu menu = gtk.Menu() rotate_submenu = gtk.Menu(); rotate_item=gtk.MenuItem("Rotate Screen") rotate_item.show() menu.append(rotate_item); # create some labels for the normal rotations directions=["Normal","Left","Inverted","Right"]; for direction in directions: menu_item = gtk.MenuItem(" "+direction) menu.append(menu_item) menu_item.connect("activate",self.setRotation,direction) # show the items menu_item.show() # Add button to enable automatic rotation menu.append(self.auto_menu_item) self.auto_menu_item.connect("activate",self.setRotation,direction) self.auto_menu_item.show() # Autorotate configuration menu separator_item1=gtk.SeparatorMenuItem(); separator_item1.show(); menu.append(separator_item1); self.daemon_menu_item.connect("activate",self.startStopDaemon); menu.append(self.daemon_menu_item); self.daemon_menu_item.show(); # Run the indicator! ind.set_menu(menu) gtk.main()
def __init__(self): ''' Init. ''' # Init widgets. self.window = self.initMainWindow() self.window.connect("destroy", lambda w: gtk.main_quit()) # self.window.connect("size-allocate", lambda w, a: updateShape(w, a, 4)) self.generalMainbox = gtk.VBox(False, 10) # setup self.bodyAlign = gtk.Alignment() self.bodyAlign.set_padding(10, 20, 10, 10) imageSetupFrame = gtk.Frame("图片格式") imageSetupMainBox = gtk.VBox() imageQualityHbox = gtk.HBox(False,40) self.adj1 = gtk.Adjustment(0, 0, 110, 10, 10, 10) self.imageQualityLabel = gtk.Label("质量:") self.imageQualityHscale = gtk.HScale(self.adj1) self.imageQualityHscale.set_size_request(190, -1) self.imageQualityHscale.set_value_pos(gtk.POS_RIGHT) self.imageQualityHscale.set_digits(0) self.imageQualityHscale.set_draw_value(True) self.imageQualityHscale.set_update_policy(gtk.UPDATE_CONTINUOUS) imageQualityHbox.pack_start(self.imageQualityLabel, False, False) imageQualityHbox.pack_start(self.imageQualityHscale, False, False) imageFormatHbox = gtk.HBox(False, 10) imageFormatLabel = gtk.Label("图片格式:") imageFormatList = gtk.OptionMenu() imageFormatList.set_size_request(180, -1) menu = gtk.Menu() pngItem = gtk.MenuItem("png - PNG 图像格式") jpegItem = gtk.MenuItem("jpeg - JPEG 图像格式") bmpItem = gtk.MenuItem("bmp - BMP 图像格式") menu.append(pngItem) menu.append(jpegItem) menu.append(bmpItem) imageFormatList.set_menu(menu) imageFormatHbox.pack_start(imageFormatLabel, False, False) imageFormatHbox.pack_start(imageFormatList, False, False) imageSetupMainBox.pack_start(imageQualityHbox) imageSetupMainBox.pack_start(imageFormatHbox) imageQualityAlign = gtk.Alignment() imageQualityAlign.set_padding(10, 10, 10, 10) imageQualityAlign.add(imageSetupMainBox) imageSetupFrame.add(imageQualityAlign) # save saveProjectFrame = gtk.Frame("保存方案") saveProjectMainbox = gtk.VBox() self.tipsaveRadio = gtk.RadioButton(None, "提示保存") self.autosaveRadio = gtk.RadioButton(self.tipsaveRadio, "自动保存") saveFilenameHbox = gtk.HBox(False, 26) saveFilenameLabel = gtk.Label("文件名:") self.saveFilenameEntry = gtk.Entry() saveFilenameHbox.pack_start(saveFilenameLabel, False, False) saveFilenameHbox.pack_start(self.saveFilenameEntry) saveDirHbox = gtk.HBox(False, 10) saveDirLabel = gtk.Label("保存目录:") self.saveDirButton = gtk.FileChooserButton("dir") self.saveDirButton.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER) saveDirHbox.pack_start(saveDirLabel, False, False) saveDirHbox.pack_start(self.saveDirButton) saveDirMainbox = gtk.VBox() saveDirMainbox.pack_start(saveFilenameHbox) saveDirMainbox.pack_start(saveDirHbox) saveDirAlign = gtk.Alignment() saveDirAlign.set_padding(0, 0, 20, 10) saveDirAlign.add(saveDirMainbox) saveProjectAlign = gtk.Alignment() saveProjectAlign.set_padding(10, 10, 10, 10) saveProjectFrame.add(saveProjectAlign) saveProjectAlign.add(saveProjectMainbox) saveProjectMainbox.pack_start(self.tipsaveRadio) saveProjectMainbox.pack_start(self.autosaveRadio) saveProjectMainbox.pack_start(saveDirAlign) # buttons controlBox = gtk.HBox(True, 5) controlAlign = gtk.Alignment() controlAlign.set(1.0, 0.0, 0.0, 0.0) controlAlign.add(controlBox) okButton = gtk.Button(None, gtk.STOCK_OK) cancelButton = gtk.Button(None, gtk.STOCK_CANCEL) applyButton = gtk.Button(None, gtk.STOCK_APPLY) controlBox.pack_start(okButton) controlBox.pack_start(cancelButton) controlBox.pack_start(applyButton) self.window.add(self.bodyAlign) self.bodyAlign.add(self.generalMainbox) self.generalMainbox.pack_start(imageSetupFrame) self.generalMainbox.pack_start(saveProjectFrame) self.generalMainbox.pack_start(controlAlign) self.window.show_all() gtk.main()
def _package_menu_launch(self, widget, event): # Create a menu below the widget for package actions. menu = gtk.Menu() packages = {} for section, vars_ in self.variables.items(): for var in vars_: if var.name == self.STREQ_NL_PACKAGE_OPT: is_ignored = (rose.variable.IGNORED_BY_USER in self.sections[section].ignored_reason) packages.setdefault(var.value, []) packages[var.value].append(is_ignored) for package in sorted(packages.keys()): ignored_list = packages[package] package_title = "Package: " + package package_menuitem = gtk.MenuItem(package_title) package_menuitem.show() package_menu = gtk.Menu() enable_menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_YES) enable_menuitem.set_label(label="Enable all") enable_menuitem._connect_args = (package, False) enable_menuitem.connect( "button-release-event", lambda m, e: self._packages_enable(*m._connect_args)) enable_menuitem.show() enable_menuitem.set_sensitive(any(ignored_list)) package_menu.append(enable_menuitem) ignore_menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_NO) ignore_menuitem.set_label(label="Ignore all") ignore_menuitem._connect_args = (package, True) ignore_menuitem.connect( "button-release-event", lambda m, e: self._packages_enable(*m._connect_args)) ignore_menuitem.set_sensitive(any(not i for i in ignored_list)) ignore_menuitem.show() package_menu.append(ignore_menuitem) remove_menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_REMOVE) remove_menuitem.set_label(label="Remove all") remove_menuitem._connect_args = (package, ) remove_menuitem.connect( "button-release-event", lambda m, e: self._packages_remove(*m._connect_args)) remove_menuitem.show() package_menu.append(remove_menuitem) package_menuitem.set_submenu(package_menu) menu.append(package_menuitem) menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_ADD) menuitem.set_label(label="Import") import_menu = gtk.Menu() new_packages = set(self._package_lookup.keys()) - set(packages.keys()) for new_package in sorted(new_packages): new_pack_menuitem = gtk.MenuItem(label=new_package) new_pack_menuitem._connect_args = (new_package, ) new_pack_menuitem.connect( "button-release-event", lambda m, e: self._package_add(*m._connect_args)) new_pack_menuitem.show() import_menu.append(new_pack_menuitem) if not new_packages: menuitem.set_sensitive(False) menuitem.set_submenu(import_menu) menuitem.show() menu.append(menuitem) menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_NO) menuitem.set_label(label="Disable all packages") menuitem.connect("activate", lambda i: self._packages_enable(disable=True)) menuitem.show() menu.append(menuitem) menu.popup(None, None, widget.position_menu, event.button, event.time, widget)
def check_status(self): """ Gets the current status of btsync and updates the menu accordingly Shows each shared folder with connected peer and any transfer activity with it. Also retrieves the secrets for each folder. If the server cannot be contacted, stops polling and attempts calls setup_session to establish a new session. """ """ Since some state information from the btsync-agent may be changed from outside, we should keep it also up to date in the menu... """ filepath = self.config['storage_path'] + '/debug.txt' self.debug_item.disconnect(self.debug_item_handler) self.debug_item.set_active(os.path.isfile(filepath)) self.debug_item_handler = self.debug_item.connect( "activate", self.toggle_debugging) if self.btsync_user: filepath = self.config['storage_path'] + '/paused' self.pause_item.disconnect(self.pause_item_handler) self.pause_item.set_active(os.path.isfile(filepath)) self.pause_item_handler = self.pause_item.connect( "activate", self.toggle_pause) if (os.path.isfile(filepath)): logging.info('BitTorrent Sync is paused. Cleaning menu') self.show_error("BitTorrent Sync is paused") self.folderitems = {} self.status = {'folders': []} gtk.timeout_add(5000, self.setup_session) return False try: logging.info('Requesting status') params = {'token': self.token, 'action': 'getsyncfolders'} response = requests.get(self.urlroot, params=params, cookies=self.cookies, auth=self.auth) response.raise_for_status() self.clear_error() status = self.get_response_json(response) self.check_activity(status['folders']) curfoldernames = [ folder['name'] for folder in self.status['folders'] ] newfoldernames = [folder['name'] for folder in status['folders']] updatefolders = [ folder for folder in status['folders'] if folder['name'] in curfoldernames ] newfolders = [ folder for folder in status['folders'] if folder['name'] not in curfoldernames ] oldfolders = [ folder for folder in self.status['folders'] if folder['name'] not in newfoldernames ] for folder in newfolders: name = folder['name'] menuitem = gtk.MenuItem(name) self.menu.prepend(menuitem) menuitem.show() folderitem = { 'menuitem': menuitem, 'sizeitem': {}, 'peeritems': {} } self.folderitems[name] = folderitem submenu = self.build_folder_menu(folder) menuitem.set_submenu(submenu) for folder in updatefolders: self.update_folder_menu(folder) for folder in oldfolders: name = folder['name'] self.menu.remove(self.folderitems[name]['menuitem']) del self.folderitems[name] self.status = status return True except requests.exceptions.ConnectionError: logging.warning( 'Status request failed, attempting to re-initialise session') self.show_error("Lost connection to Bittorrent Sync") self.folderitems = {} self.status = {'folders': []} gtk.timeout_add(5000, self.setup_session) return False except requests.exceptions.HTTPError: logging.warning( 'Communication Error caught, displaying error message') self.show_error("Communication Error " + str(response.status_code)) self.folderitems = {} self.status = {'folders': []} gtk.timeout_add(5000, self.setup_session) return True
def build_folder_menu(self, folder): """ Build a submenu for the specified folder, including items to show the size, open the folder in the file manager, show each connected peer, and to copy the secrets to the clipboard. Stores references to the size and peer items so they can easily be updated. """ menu = gtk.Menu() folderitem = self.folderitems[folder['name']] folderitem['sizeitem'] = gtk.MenuItem(folder['status']) folderitem['sizeitem'].set_sensitive(False) folderitem['sizeitem'].show() openfolder = gtk.MenuItem('Open in File Browser') openfolder.connect("activate", self.open_fm, folder['name']) openfolder.show() menu.append(folderitem['sizeitem']) menu.append(openfolder) if len(folder['peers']) > 0: sep = gtk.SeparatorMenuItem() sep.show() menu.append(sep) folderitem['topsepitem'] = sep for peer in folder['peers']: buf = self.format_status(peer) img = gtk.Image() if peer['direct']: img.set_from_file(args.iconpath + '/btsync-direct.png') else: img.set_from_file(args.iconpath + '/btsync-relay.png') peeritem = gtk.ImageMenuItem(gtk.STOCK_NEW, buf) peeritem.set_image(img) peeritem.set_always_show_image(True) peeritem.set_sensitive(False) peeritem.show() folderitem['peeritems'][peer['name']] = peeritem menu.append(peeritem) else: folderitem['topsepitem'] = None sep = gtk.SeparatorMenuItem() sep.show() menu.append(sep) folderitem['bottomsepitem'] = sep readonlysecret = folder['secret'] if folder['iswritable']: readonlysecret = folder['readonlysecret'] readwrite = gtk.MenuItem('Get Full Access Secret') readwrite.connect("activate", self.copy_secret, folder['secret']) readwrite.show() menu.append(readwrite) readonly = gtk.MenuItem('Get Read Only Secret') readonly.connect("activate", self.copy_secret, readonlysecret) readonly.show() menu.append(readonly) return menu
def make_annotation_menu(self, element, menu): def add_item(*p, **kw): self.add_menuitem(menu, *p, **kw) def loop_on_annotation(menu, ann): self.controller.gui.loop_on_annotation_gui(ann, goto=True) return True def save_snapshot(menu, ann): self.controller.gui.save_snapshot_as(ann.fragment.begin) return True add_item(_("Go to..."), self.goto_annotation, element) add_item(_("Loop"), loop_on_annotation, element) add_item(_("Duplicate"), self.duplicate_annotation, element) item = gtk.MenuItem(_("Highlight"), use_underline=False) item.set_submenu(self.activate_submenu(element)) menu.append(item) add_item(_("Save snapshot..."), save_snapshot, element) if 'montagerenderer' in self.controller.generic_features: add_item(_("Extract video fragment"), self.extract_fragment, element) def build_submenu(submenu, el, items): """Build the submenu for the given element. """ if submenu.get_children(): # The submenu was already populated. return False if len(items) == 1: # Only 1 elements, do not use an intermediary menu m=Menu(element=items[0], controller=self.controller) for c in m.menu.get_children(): m.menu.remove(c) submenu.append(c) else: for i in items: item=gtk.MenuItem(self.get_title(i), use_underline=False) m=Menu(element=i, controller=self.controller) item.set_submenu(m.menu) submenu.append(item) submenu.show_all() return False def build_related(submenu, el): """Build the related annotations submenu for the given element. """ if submenu.get_children(): # The submenu was already populated. return False if el.incomingRelations: i=gtk.MenuItem(_("Incoming")) submenu.append(i) i=gtk.SeparatorMenuItem() submenu.append(i) for t, l in el.typedRelatedIn.iteritems(): at=self.controller.package.get_element_by_id(t) m=gtk.MenuItem(self.get_title(at), use_underline=False) amenu=gtk.Menu() m.set_submenu(amenu) amenu.connect('map', build_submenu, at, l) submenu.append(m) if submenu.get_children(): # There were incoming annotations. Use a separator i=gtk.SeparatorMenuItem() submenu.append(i) if el.outgoingRelations: i=gtk.MenuItem(_("Outgoing")) submenu.append(i) i=gtk.SeparatorMenuItem() submenu.append(i) for t, l in el.typedRelatedOut.iteritems(): at=self.controller.package.get_element_by_id(t) m=gtk.MenuItem(self.get_title(at), use_underline=False) amenu=gtk.Menu() m.set_submenu(amenu) amenu.connect('map', build_submenu, at, l) submenu.append(m) submenu.show_all() return False if element.relations: i=gtk.MenuItem(_("Related annotations"), use_underline=False) submenu=gtk.Menu() i.set_submenu(submenu) submenu.connect('map', build_related, element) menu.append(i) if element.incomingRelations: i=gtk.MenuItem(_("Incoming relations"), use_underline=False) submenu=gtk.Menu() i.set_submenu(submenu) submenu.connect('map', build_submenu, element, element.incomingRelations) menu.append(i) if element.outgoingRelations: i=gtk.MenuItem(_("Outgoing relations"), use_underline=False) submenu=gtk.Menu() i.set_submenu(submenu) submenu.connect('map', build_submenu, element, element.outgoingRelations) menu.append(i) add_item("") item = gtk.MenuItem() item.add(image_from_position(self.controller, position=element.fragment.begin, height=60)) item.connect('activate', self.goto_annotation, element) menu.append(item) #add_item(element.content.data[:40]) add_item(_('Begin: %s') % helper.format_time (element.fragment.begin), lambda i: self.controller.gui.adjust_annotation_bound(element, 'begin')) add_item(_('End: %s') % helper.format_time (element.fragment.end), lambda i: self.controller.gui.adjust_annotation_bound(element, 'end')) add_item(_('Duration: %s') % helper.format_time (element.fragment.duration)) return
def __init__(self): super(QuicknoteProgram, self).__init__() self._clipboard = gtk.clipboard_get() _moduleLogger.info('Starting quicknote') self._wordWrapEnabled = False self._window_in_fullscreen = False #The window isn't in full screen mode initially. self._db = speichern.Speichern() #Create GUI main vbox vbox = gtk.VBox(homogeneous = False, spacing = 0) if hildonize.GTK_MENU_USED: #Create Menu and apply it for hildon filemenu = gtk.Menu() menu_items = gtk.MenuItem(_("Set DB file")) filemenu.append(menu_items) menu_items.connect("activate", self.set_db_file, None) menu_items = gtk.MenuItem(_("SQL History")) filemenu.append(menu_items) menu_items.connect("activate", self._on_view_sql_history, None) menu_items = gtk.MenuItem(_("Sync notes")) filemenu.append(menu_items) menu_items.connect("activate", self._on_sync_notes, None) menu_items = gtk.MenuItem(_("Quit")) filemenu.append(menu_items) menu_items.connect("activate", self._on_destroy, None) file_menu = gtk.MenuItem(_("File")) file_menu.show() file_menu.set_submenu(filemenu) categorymenu = gtk.Menu() menu_items = gtk.MenuItem(_("Search")) categorymenu.append(menu_items) menu_items.connect("activate", self._on_toggle_search) menu_items = gtk.MenuItem(_("Delete")) categorymenu.append(menu_items) menu_items.connect("activate", self._on_delete_category) category_menu = gtk.MenuItem(_("Category")) category_menu.show() category_menu.set_submenu(categorymenu) viewmenu = gtk.Menu() menu_items = gtk.MenuItem(_("Move To Category")) viewmenu.append(menu_items) menu_items.connect("activate", self._on_move_category) menu_items = gtk.MenuItem(_("History")) viewmenu.append(menu_items) menu_items.connect("activate", self._on_show_history) menu_items = gtk.MenuItem(_("Word Wrap")) viewmenu.append(menu_items) menu_items.connect("activate", self._on_toggle_word_wrap) view_menu = gtk.MenuItem(_("Note")) view_menu.show() view_menu.set_submenu(viewmenu) helpmenu = gtk.Menu() menu_items = gtk.MenuItem(_("About")) helpmenu.append(menu_items) menu_items.connect("activate", self._on_show_about, None) help_menu = gtk.MenuItem(_("Help")) help_menu.show() help_menu.set_submenu(helpmenu) menuBar = gtk.MenuBar() menuBar.show() menuBar.append (file_menu) menuBar.append (category_menu) menuBar.append (view_menu) menuBar.append (help_menu) vbox.pack_start(menuBar, False, False, 0) else: menuBar = gtk.MenuBar() menuBar.show() vbox.pack_start(menuBar, False, False, 0) #Create GUI elements self._category = kopfzeile.Kopfzeile(self._db) self._search = search.Search() self._notizen = notizen.Notizen(self._db, self._category, self._search) # notizen packs in the category vbox.pack_start(self._notizen, expand = True, fill = True) vbox.pack_start(self._search, expand = False, fill = True) #Get the Main Window, and connect the "destroy" event self._window = gtk.Window() self._window.add(vbox) self._on_toggle_word_wrap() try: os.makedirs(self._user_data) except OSError, e: if e.errno != 17: raise
class Menu: def __init__(self, element=None, controller=None, readonly=False): self.element=element self.controller=controller self.readonly=readonly self.menu=self.make_base_menu(element) def popup(self): self.menu.popup(None, None, None, 0, gtk.get_current_event_time()) return True def get_title (self, element): """Return the element title.""" return self.controller.get_title(element, max_size=40) def goto_annotation (self, widget, ann): c=self.controller pos = c.create_position (value=ann.fragment.begin, key=c.player.MediaTime, origin=c.player.AbsolutePosition) c.update_status (status="set", position=pos) c.gui.set_current_annotation(ann) return True def duplicate_annotation(self, widget, ann): self.controller.duplicate_annotation(ann) return True def activate_annotation (self, widget, ann): self.controller.notify("AnnotationActivate", annotation=ann) return True def desactivate_annotation (self, widget, ann): self.controller.notify("AnnotationDeactivate", annotation=ann) return True def activate_stbv (self, widget, view): self.controller.activate_stbv(view) return True def open_adhoc_view (self, widget, view): self.controller.gui.open_adhoc_view(view) return True def create_element(self, widget, elementtype=None, parent=None): if elementtype == 'staticview': elementtype=View mimetype='text/html' elif elementtype == 'dynamicview': elementtype=View mimetype='application/x-advene-ruleset' else: mimetype=None cr = self.controller.gui.create_element_popup(type_=elementtype, parent=parent, controller=self.controller, mimetype=mimetype) cr.popup() return True def do_insert_resource_file(self, parent=None, filename=None, id_=None): if id_ is None: # Generate the id_ basename = os.path.basename(filename) id_=re.sub('[^a-zA-Z0-9_.]', '_', basename) size=os.stat(filename).st_size f=open(filename, 'rb') parent[id_]=f.read(size + 2) f.close() el=parent[id_] self.controller.notify('ResourceCreate', resource=el) return el def do_insert_resource_dir(self, parent=None, dirname=None, id_=None): if id_ is None: # Generate the id_ basename = os.path.basename(dirname) id_=re.sub('[^a-zA-Z0-9_.]', '_', basename) parent[id_] = parent.DIRECTORY_TYPE el=parent[id_] self.controller.notify('ResourceCreate', resource=el) for n in os.listdir(dirname): filename = os.path.join(dirname, n) if os.path.isdir(filename): self.do_insert_resource_dir(parent=el, dirname=filename) else: self.do_insert_resource_file(parent=el, filename=filename) return el def insert_resource_data(self, widget, parent=None, title=None, filter=None): if title is None: title = _("Choose the file to insert") filename=dialog.get_filename(title=title, filter=filter) if filename is None: return True basename = os.path.basename(filename) id_=re.sub('[^a-zA-Z0-9_.]', '_', basename) if id_ != basename: while True: id_ = dialog.entry_dialog(title=_("Select a valid identifier"), text=_("The filename %s contains invalid characters\nthat have been replaced.\nYou can modify this identifier if necessary:") % filename, default=id_) if id_ is None: # Edition cancelled return True elif re.match('^[a-zA-Z0-9_.]+$', id_): break self.do_insert_resource_file(parent=parent, filename=filename, id_=id_) return True def insert_soundclip(self, widget, parent=None): self.insert_resource_data(widget, parent, title=_("Choose the soundclip to insert"), filter='audio') return True def insert_resource_directory(self, widget, parent=None): dirname=dialog.get_dirname(title=_("Choose the directory to insert")) if dirname is None: return True self.do_insert_resource_dir(parent=parent, dirname=dirname) return True def edit_element (self, widget, el): self.controller.gui.edit_element(el) return True def nerd_service(self, widget, annotationtype): # Relatively ugly hack becase the Importer GUI API does not # allow to specify default parameters easily. config.data.preferences['nerd-annotation-type'] = annotationtype.id v = self.controller.gui.open_adhoc_view('importerview', filename='http://nerd.eurecom.fr/', message=_("Named-Entity extraction using NERD"), display_unlikely=False) def popup_get_offset(self): offset=dialog.entry_dialog(title='Enter an offset', text=_("Give the offset to use\non specified element.\nIt is in ms and can be\neither positive or negative."), default="0") if offset is not None: return long(offset) else: return offset def offset_element (self, widget, el): offset = self.popup_get_offset() if offset is None: return True if isinstance(el, Annotation): self.controller.notify('EditSessionStart', element=el, immediate=True) el.fragment.begin += offset el.fragment.end += offset self.controller.notify('AnnotationEditEnd', annotation=el) self.controller.notify('EditSessionEnd', element=el) elif isinstance(el, AnnotationType): batch_id=object() for a in el.annotations: self.controller.notify('EditSessionStart', element=a, immediate=True) a.fragment.begin += offset a.fragment.end += offset self.controller.notify('AnnotationEditEnd', annotation=a, batch=batch_id) self.controller.notify('EditSessionEnd', element=a) elif isinstance(el, Package): for a in el.annotations: a.fragment.begin += offset a.fragment.end += offset self.controller.notify('PackageActivate', package=el) elif isinstance(el, Schema): batch_id=object() for at in el.annotationTypes: for a in at.annotations: self.controller.notify('EditSessionStart', element=a, immediate=True) a.fragment.begin += offset a.fragment.end += offset self.controller.notify('AnnotationEditEnd', annotation=a, batch=batch_id) self.controller.notify('EditSessionEnd', element=a) return True def search_replace_content(self, widget, el): if isinstance(el, (Annotation, View)): l = [ el ] title = _("Replace content in %s" % self.controller.get_title(el)) elif isinstance(el, AnnotationType): l = el.annotations title = _("Replace content in annotations of type %s" % self.controller.get_title(el)) elif isinstance(el, Package): l = el.annotations title = _("Replace content in all annotations") self.controller.gui.search_replace_dialog(l, title=title) return True def copy_id (self, widget, el): clip=gtk.clipboard_get() clip.set_text(el.id) return True def browse_element (self, widget, el): self.controller.gui.open_adhoc_view('browser', element=el) return True def query_element (self, widget, el): self.controller.gui.open_adhoc_view('interactivequery', here=el, sources= [ "here" ]) return True def delete_element (self, widget, el): self.controller.delete_element(el) return True def delete_elements (self, widget, el, elements): batch_id=object() if isinstance(el, AnnotationType) or isinstance(el, RelationType): for e in elements: self.controller.delete_element(e, batch=batch_id) return True def create_montage(self, widget, rt): """Create a montage from a relationtype. """ l = list(set( r.members[0] for r in rt.relations )) res = [] if l: l.sort(key=lambda a: a.fragment.begin) ann = l[0] while True: res.append(ann) try: l.remove(ann) except ValueError: pass r = ann.typedRelatedOut.get(rt.id, None) if not r: ann = None else: ann = r[0] if ann is None or ann in res: # End of relations. Look for other roots. if l: ann = l[0] else: break self.controller.gui.open_adhoc_view('montage', elements=res) return True def pick_color(self, widget, element): self.controller.gui.update_color(element) return True def add_menuitem(self, menu=None, item=None, action=None, *param, **kw): if item is None or item == "": i = gtk.SeparatorMenuItem() else: i = gtk.MenuItem(item, use_underline=False) if action is not None: i.connect('activate', action, *param, **kw) menu.append(i) return i def make_base_menu(self, element): """Build a base popup menu dedicated to the given element. @param element: the element @type element: an Advene element @return: the built menu @rtype: gtk.Menu """ menu = gtk.Menu() def add_item(*p, **kw): return self.add_menuitem(menu, *p, **kw) title=add_item(self.get_title(element)) if hasattr(element, 'id') or isinstance(element, Package): title.set_submenu(self.common_submenu(element)) add_item("") try: i=element.id add_item(_("Copy id %s") % i, self.copy_id, element) except AttributeError: pass if hasattr(element, 'viewableType'): self.make_bundle_menu(element, menu) specific_builder={ Annotation: self.make_annotation_menu, Relation: self.make_relation_menu, AnnotationType: self.make_annotationtype_menu, RelationType: self.make_relationtype_menu, Schema: self.make_schema_menu, View: self.make_view_menu, Package: self.make_package_menu, Query: self.make_query_menu, Resources: self.make_resources_menu, ResourceData: self.make_resourcedata_menu, } for t, method in specific_builder.iteritems(): if isinstance(element, t): method(element, menu) menu.show_all() return menu def display_stats(self, m, el): """Display statistics about the element's annotations. element can be either the package, or an annotation type. """ self.controller.gui.display_statistics(el.annotations, label=_("<b>Statistics about %s</b>\n\n") % self.controller.get_title(el)) return True def renumber_annotations(self, m, at): """Renumber all annotations of a given type. """ d = gtk.Dialog(title=_("Renumbering annotations of type %s") % self.get_title(at), parent=None, flags=gtk.DIALOG_DESTROY_WITH_PARENT, buttons=( gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK, )) l=gtk.Label() l.set_markup(_("<b>Renumber all annotations according to their order.</b>\n\n<i>Note that this action cannot be undone.</i>\nReplace the first numeric value of the annotation content with the new annotation number.\nIf no numeric value is found and the annotation is structured, it will insert the number.\nIf no numeric value is found and the annotation is of type text/plain, it will overwrite the annotation content.\nThe offset parameter allows you to renumber from a given annotation.")) l.set_line_wrap(True) l.show() d.vbox.add(l) hb=gtk.HBox() l=gtk.Label(_("Offset")) hb.pack_start(l, expand=False) s=gtk.SpinButton() s.set_range(-5, len(at.annotations)) s.set_value(1) s.set_increments(1, 5) hb.add(s) d.vbox.pack_start(hb, expand=False) d.connect('key-press-event', dialog.dialog_keypressed_cb) d.show_all() dialog.center_on_mouse(d) res=d.run() if res == gtk.RESPONSE_OK: re_number=re.compile('(\d+)') re_struct=re.compile('^num=(\d+)$', re.MULTILINE) offset=s.get_value_as_int() - 1 l=at.annotations l.sort(key=lambda a: a.fragment.begin) l=l[offset:] size=float(len(l)) dial=gtk.Dialog(_("Renumbering %d annotations") % size, None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)) prg=gtk.ProgressBar() dial.vbox.pack_start(prg, expand=False) dial.show_all() for i, a in enumerate(l[offset:]): prg.set_text(_("Annotation #%d") % i) prg.set_fraction( i / size ) while gtk.events_pending(): gtk.main_iteration() if a.type.mimetype == 'application/x-advene-structured': if re_struct.search(a.content.data): # A 'num' field is present. Update it. data=re_struct.sub("num=%d" % (i+1), a.content.data) else: # Insert the num field data=("num=%d\n" % (i+1)) + a.content.data elif re_number.search(a.content.data): # There is a number. Simply substitute the new one. data=re_number.sub(str(i+1), a.content.data) elif a.type.mimetype == 'text/plain': # Overwrite the contents data=str(i+1) else: data=None if data is not None and a.content.data != data: a.content.data=data self.controller.notify('PackageActivate', package=self.controller.package) dial.destroy() d.destroy() return True def extract_fragment(self, m, ann): """Extract the fragment corresponding to an annotation. """ title = self.controller.get_title(ann) begin = helper.format_time(ann.fragment.begin) end = helper.format_time(ann.fragment.end) self.controller.gui.render_montage_dialog([ ann ], basename = ann.id + "-" + helper.title2id(title) + ".ogv", title = _("Extracting %s") % title, label = _("Exporting annotation %(title)s\nfrom %(begin)s to %(end)s\nto %%(filename)s") % locals()) return True def common_submenu(self, element): """Build the common submenu for all elements. """ submenu=gtk.Menu() def add_item(*p, **kw): self.add_menuitem(submenu, *p, **kw) # Common to all other elements: add_item(_("Edit"), self.edit_element, element) if config.data.preferences['expert-mode']: add_item(_("Browse"), self.browse_element, element) add_item(_("Query"), self.query_element, element) def open_in_browser(i, v): c=self.controller.build_context(here=element) url=c.evaluateValue('here/absolute_url') self.controller.open_url(url) return True add_item(_("Open in web browser"), open_in_browser, element) if not self.readonly: # Common to deletable elements if type(element) in (Annotation, Relation, View, Query, Schema, AnnotationType, RelationType, ResourceData): add_item(_("Delete"), self.delete_element, element) if type(element) == Resources and type(element.parent) == Resources: # Add Delete item to Resources except for the root resources (with parent = package) add_item(_("Delete"), self.delete_element, element) if isinstance(element, (Annotation, AnnotationType, Package)): add_item(_("Search/replace content"), self.search_replace_content, element) ## Common to offsetable elements if (config.data.preferences['expert-mode'] and type(element) in (Annotation, Schema, AnnotationType, Package)): add_item(_("Offset"), self.offset_element, element) submenu.show_all() return submenu def activate_submenu(self, element): """Build an "activate" submenu for the given annotation""" submenu=gtk.Menu() def add_item(*p, **kw): self.add_menuitem(submenu, *p, **kw) add_item(_("Activate"), self.activate_annotation, element) add_item(_("Desactivate"), self.desactivate_annotation, element) submenu.show_all() return submenu def make_annotation_menu(self, element, menu): def add_item(*p, **kw): self.add_menuitem(menu, *p, **kw) def loop_on_annotation(menu, ann): self.controller.gui.loop_on_annotation_gui(ann, goto=True) return True def save_snapshot(menu, ann): self.controller.gui.save_snapshot_as(ann.fragment.begin) return True add_item(_("Go to..."), self.goto_annotation, element) add_item(_("Loop"), loop_on_annotation, element) add_item(_("Duplicate"), self.duplicate_annotation, element) item = gtk.MenuItem(_("Highlight"), use_underline=False) item.set_submenu(self.activate_submenu(element)) menu.append(item) add_item(_("Save snapshot..."), save_snapshot, element) if 'montagerenderer' in self.controller.generic_features: add_item(_("Extract video fragment"), self.extract_fragment, element) def build_submenu(submenu, el, items): """Build the submenu for the given element. """ if submenu.get_children(): # The submenu was already populated. return False if len(items) == 1: # Only 1 elements, do not use an intermediary menu m=Menu(element=items[0], controller=self.controller) for c in m.menu.get_children(): m.menu.remove(c) submenu.append(c) else: for i in items: item=gtk.MenuItem(self.get_title(i), use_underline=False) m=Menu(element=i, controller=self.controller) item.set_submenu(m.menu) submenu.append(item) submenu.show_all() return False def build_related(submenu, el): """Build the related annotations submenu for the given element. """ if submenu.get_children(): # The submenu was already populated. return False if el.incomingRelations: i=gtk.MenuItem(_("Incoming")) submenu.append(i) i=gtk.SeparatorMenuItem() submenu.append(i) for t, l in el.typedRelatedIn.iteritems(): at=self.controller.package.get_element_by_id(t) m=gtk.MenuItem(self.get_title(at), use_underline=False) amenu=gtk.Menu() m.set_submenu(amenu) amenu.connect('map', build_submenu, at, l) submenu.append(m) if submenu.get_children(): # There were incoming annotations. Use a separator i=gtk.SeparatorMenuItem() submenu.append(i) if el.outgoingRelations: i=gtk.MenuItem(_("Outgoing")) submenu.append(i) i=gtk.SeparatorMenuItem() submenu.append(i) for t, l in el.typedRelatedOut.iteritems(): at=self.controller.package.get_element_by_id(t) m=gtk.MenuItem(self.get_title(at), use_underline=False) amenu=gtk.Menu() m.set_submenu(amenu) amenu.connect('map', build_submenu, at, l) submenu.append(m) submenu.show_all() return False if element.relations: i=gtk.MenuItem(_("Related annotations"), use_underline=False) submenu=gtk.Menu() i.set_submenu(submenu) submenu.connect('map', build_related, element) menu.append(i) if element.incomingRelations: i=gtk.MenuItem(_("Incoming relations"), use_underline=False) submenu=gtk.Menu() i.set_submenu(submenu) submenu.connect('map', build_submenu, element, element.incomingRelations) menu.append(i) if element.outgoingRelations: i=gtk.MenuItem(_("Outgoing relations"), use_underline=False) submenu=gtk.Menu() i.set_submenu(submenu) submenu.connect('map', build_submenu, element, element.outgoingRelations) menu.append(i) add_item("") item = gtk.MenuItem() item.add(image_from_position(self.controller, position=element.fragment.begin, height=60)) item.connect('activate', self.goto_annotation, element) menu.append(item) #add_item(element.content.data[:40]) add_item(_('Begin: %s') % helper.format_time (element.fragment.begin), lambda i: self.controller.gui.adjust_annotation_bound(element, 'begin')) add_item(_('End: %s') % helper.format_time (element.fragment.end), lambda i: self.controller.gui.adjust_annotation_bound(element, 'end')) add_item(_('Duration: %s') % helper.format_time (element.fragment.duration)) return def make_relation_menu(self, element, menu): def add_item(*p, **kw): self.add_menuitem(menu, *p, **kw) add_item(element.content.data) add_item(_('Members:')) for a in element.members: item=gtk.MenuItem(self.get_title(a), use_underline=False) m=Menu(element=a, controller=self.controller) item.set_submenu(m.menu) menu.append(item) return def make_package_menu(self, element, menu): def add_item(*p, **kw): self.add_menuitem(menu, *p, **kw) if self.readonly: return add_item(_('Edit package properties...'), self.controller.gui.on_package_properties1_activate) add_item(_('%d annotations(s) - statistics') % len(element.annotations), self.display_stats, element) add_item('') add_item(_('Create a new static view...'), self.create_element, 'staticview', element) add_item(_('Create a new dynamic view...'), self.create_element, 'dynamicview', element) add_item(_('Create a new annotation...'), self.create_element, Annotation, element) #add_item(_('Create a new relation...'), self.create_element, Relation, element) add_item(_('Create a new schema...'), self.create_element, Schema, element) add_item(_('Create a new query...'), self.create_element, Query, element) return def make_resources_menu(self, element, menu): def add_item(*p, **kw): self.add_menuitem(menu, *p, **kw) if self.readonly: return add_item(_('Create a new folder...'), self.create_element, Resources, element) add_item(_('Create a new resource file...'), self.create_element, ResourceData, element) add_item(_('Insert a new resource file...'), self.insert_resource_data, element) add_item(_('Insert a new resource directory...'), self.insert_resource_directory, element) #print "Menu for", id(element), id(self.controller.package.resources), element.id if element.resourcepath == '': # Resources root if not element.has_key('soundclips'): # Create the soundclips folder element['soundclips'] = element.DIRECTORY_TYPE self.controller.notify('ResourceCreate', resource=element['soundclips']) add_item(_('Insert a soundclip...'), self.insert_soundclip, element['soundclips']) elif element.resourcepath == 'soundclips': add_item(_('Insert a soundclip...'), self.insert_soundclip, element) return def make_resourcedata_menu(self, element, menu): def add_item(*p, **kw): self.add_menuitem(menu, *p, **kw) def play_sound(w, filename): self.controller.soundplayer.play(filename) return True if element.id.split('.')[-1] in ('wav', 'ogg', 'mp3'): # Audio resource (presumably). Propose to play it. add_item(_('Play sound'), play_sound, element.file_) if self.readonly: return return def make_schema_menu(self, element, menu): def add_item(*p, **kw): self.add_menuitem(menu, *p, **kw) if self.readonly: return add_item(_('Create a new annotation type...'), self.create_element, AnnotationType, element) add_item(_('Create a new relation type...'), self.create_element, RelationType, element) add_item(_('Select a color'), self.pick_color, element) return def create_dynamic_view(self, at): """Create a caption dynamic view for the given annotation-type. """ p=self.controller.package ident='v_caption_%s' % at.id if p.get_element_by_id(ident) is not None: dialog.message_dialog(_("A caption dynamic view for %s already seems to exist.") % self.get_title(at)) return True v=p.createView( ident=ident, author=config.data.userid, date=self.controller.get_timestamp(), clazz='package', content_mimetype='application/x-advene-ruleset' ) v.title=_("Caption %s annotations") % self.get_title(at) # Build the ruleset r=RuleSet() catalog=self.controller.event_handler.catalog ra=catalog.get_action("AnnotationCaption") action=Action(registeredaction=ra, catalog=catalog) action.add_parameter('message', 'annotation/content/data') rule=Rule(name=_("Caption the annotation"), event=Event("AnnotationBegin"), condition=Condition(lhs='annotation/type/id', operator='equals', rhs='string:%s' % at.id), action=action) r.add_rule(rule) v.content.data=r.xml_repr() p.views.append(v) self.controller.notify('ViewCreate', view=v) self.controller.activate_stbv(v) return True def make_annotationtype_menu(self, element, menu): def add_item(*p, **kw): self.add_menuitem(menu, *p, **kw) def create_static(at): v=self.controller.create_static_view([ at ]) self.controller.gui.edit_element(v) return True add_item(_('Create a comment view'), lambda i: create_static(element)) add_item(_('Generate a caption dynamic view...'), lambda i: self.create_dynamic_view(element)) add_item(_('Display as transcription'), lambda i: self.controller.gui.open_adhoc_view('transcription', source='here/annotationTypes/%s/annotations/sorted' % element.id)) add_item(_('Display annotations in table'), lambda i: self.controller.gui.open_adhoc_view('table', elements=element.annotations)) add_item(_('Export to another format...'), lambda i: self.controller.gui.export_element(element)) if [ i for i in advene.util.importer.IMPORTERS if 'NERD' in i.name ]: add_item(_('Extract Named Entities...'), self.nerd_service, element) if self.readonly: return add_item(None) add_item(_('Select a color'), self.pick_color, element) add_item(_('Create a new annotation...'), self.create_element, Annotation, element) add_item(_('Delete all annotations'), self.delete_elements, element, element.annotations) add_item(_('Renumber annotations...'), self.renumber_annotations, element) add_item(_('Shot validation view...'), lambda m, at: self.controller.gui.adjust_annotationtype_bounds(at), element) add_item('') add_item(_('%d annotations(s) - statistics') % len(element.annotations), self.display_stats, element) return def create_follow_dynamic_view(self, rt): """Create a dynamic view for the given relation-type. """ p = self.controller.package ident = 'v_follow_%s' % rt.id if p.get_element_by_id(ident) is not None: dialog.message_dialog(_("A follow dynamic view for %s already seems to exist.") % self.get_title(rt)) return True v = p.createView( ident=ident, author=config.data.userid, date=self.controller.get_timestamp(), clazz='package', content_mimetype='application/x-advene-ruleset' ) v.title = _("Follow %s relation-type") % self.get_title(rt) # Build the ruleset r = RuleSet() catalog = self.controller.event_handler.catalog ra = catalog.get_action("PlayerGoto") action = Action(registeredaction=ra, catalog=catalog) action.add_parameter('position', 'annotation/typedRelatedOut/%s/first/fragment/begin' % rt.id) rule=Rule(name=_("Follow the relation"), event=Event("AnnotationEnd"), condition=Condition(lhs='annotation/typedRelatedOut/%s' % rt.id, operator='value'), action=action) r.add_rule(rule) v.content.data=r.xml_repr() p.views.append(v) self.controller.notify('ViewCreate', view=v) self.controller.activate_stbv(v) return True def make_relationtype_menu(self, element, menu): def add_item(*p, **kw): self.add_menuitem(menu, *p, **kw) if self.readonly: return add_item(_('Select a color'), self.pick_color, element) add_item(_('Delete all relations...'), self.delete_elements, element, element.relations) add_item(_('Create montage from related annotations'), self.create_montage, element) add_item(_('Create dynamic view following relations'), lambda i, e: self.create_follow_dynamic_view(e), element) return def make_query_menu(self, element, menu): def add_item(*p, **kw): self.add_menuitem(menu, *p, **kw) def try_query(item, expr): try: res, q = self.controller.evaluate_query(element, expr=expr) self.controller.gui.open_adhoc_view('interactiveresult', query=element, result=res, destination='east') except Exception, e: self.controller.log(_('Exception in query: %s') % unicode(e)) return True m=gtk.MenuItem(_('Apply query on...')) menu.append(m) sm=gtk.Menu() m.set_submenu(sm) for (expr, label) in ( ('package', _('the package')), ('package/annotations', _('all annotations of the package')), ('package/annotations/first', _('the first annotation of the package')), ): i=gtk.MenuItem(label) i.connect('activate', try_query, expr) sm.append(i) return
def __init__(self): # create a new window window = gtk.Window(gtk.WINDOW_TOPLEVEL) window.set_size_request(200, 100) window.set_title("GTK Menu Test") window.connect("delete_event", lambda w,e: gtk.main_quit()) # Init the menu-widget, and remember -- never # show() the menu widget!! # This is the menu that holds the menu items, the one that # will pop up when you click on the "Root Menu" in the app menu = gtk.Menu() # Next we make a little loop that makes three menu-entries for # "test-menu". Notice the call to gtk_menu_append. Here we are # adding a list of menu items to our menu. Normally, we'd also # catch the "clicked" signal on each of the menu items and setup a # callback for it, but it's omitted here to save space. for i in range(3): # Copy the names to the buf. buf = "Test-undermenu - %d" % i # Create a new menu-item with a name... menu_items = gtk.MenuItem(buf) # ...and add it to the menu. menu.append(menu_items) # Do something interesting when the menuitem is selected menu_items.connect("activate", self.menuitem_response, buf) # Show the widget menu_items.show() # This is the root menu, and will be the label # displayed on the menu bar. There won't be a signal handler attached, # as it only pops up the rest of the menu when pressed. root_menu = gtk.MenuItem("Root Menu") root_menu.show() # Now we specify that we want our newly created "menu" to be the # menu for the "root menu" root_menu.set_submenu(menu) # A vbox to put a menu and a button in: vbox = gtk.VBox(False, 0) window.add(vbox) vbox.show() # Create a menu-bar to hold the menus and add it to our main window menu_bar = gtk.MenuBar() vbox.pack_start(menu_bar, False, False, 2) menu_bar.show() # Create a button to which to attach menu as a popup button = gtk.Button("press me") button.connect_object("event", self.button_press, menu) vbox.pack_end(button, True, True, 2) button.show() # And finally we append the menu-item to the menu-bar -- this is the # "root" menu-item I have been raving about =) menu_bar.append (root_menu) # always display the window as the last step so it all splashes on # the screen at once. window.show()
def __init__(self): self._callback = None self._callback_data = None self._menu_item = gtk.MenuItem() self._menu_item.connect('activate', self._on_activate)
#!/usr/bin/python import requests from bs4 import BeautifulSoup import appindicator import pynotify import gtk import random a = appindicator.Indicator('tubecheck', '/usr/share/pixmaps/debian-logo.png', appindicator.CATEGORY_APPLICATION_STATUS) a.set_label('England19 vs Pakistan19') a.set_status(appindicator.STATUS_ACTIVE) m = gtk.Menu() one = gtk.MenuItem('News') two = gtk.MenuItem('Live score') three = gtk.MenuItem('Quote of the day') four = gtk.MenuItem('Word of the day') qi = gtk.MenuItem('Quit') m.append(one) m.append(two) m.append(three) m.append(four) m.append(qi) a.set_menu(m) one.show() two.show() three.show() four.show() qi.show()
def update_folder_menu(self, folder): """ Updates the submenu for the given folder with the current size and updates each peer. """ folderitem = self.folderitems[folder['name']] folderitem['sizeitem'].set_label(folder['status']) menuitem = folderitem['menuitem'] # we build up this set during check_activity # it contains the names of any folders with active peers # we display these in the menu with a different icon so that users # can see at a glance which of the peers is responsible for a busy icon if folder['name'] in self.active_folder_names: menuitem.set_label('⇅\t' + folder['name']) else: menuitem.set_label('―\t' + folder['name']) menu = menuitem.get_submenu() curfolder = [ f for f in self.status['folders'] if folder['name'] == f['name'] ].pop() curpeernames = [peer['name'] for peer in curfolder['peers']] newpeernames = [peer['name'] for peer in folder['peers']] updatepeers = [ peer for peer in folder['peers'] if peer['name'] in curpeernames ] newpeers = [ peer for peer in folder['peers'] if peer['name'] not in curpeernames ] oldpeers = [ peer for peer in curfolder['peers'] if peer['name'] not in newpeernames ] for peer in newpeers: bottomseppos = menu.get_children().index( folderitem['bottomsepitem']) buf = self.format_status(peer) peeritem = gtk.MenuItem(buf) peeritem.set_sensitive(False) peeritem.show() folderitem['peeritems'][peer['name']] = peeritem pos = bottomseppos if (folderitem['topsepitem'] == None): sep = gtk.SeparatorMenuItem() sep.show() menu.insert(sep, pos) folderitem['topsepitem'] = sep pos = pos + 1 menu.insert(peeritem, pos) for peer in updatepeers: buf = self.format_status(peer) folderitem['peeritems'][peer['name']].set_label(buf) for peer in oldpeers: menu.remove(folderitem['peeritems'][peer['name']]) topseppos = menu.get_children().index(folderitem['topsepitem']) bottomseppos = menu.get_children().index( folderitem['bottomsepitem']) if (topseppos == bottomseppos - 1): menu.remove(folderitem['topsepitem']) folderitem['topsepitem'] = None
def __init__(self): self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_title("Paparazzi Airframe File Editor") self.my_vbox = gtk.VBox() # MenuBar mb = gtk.MenuBar() # File filemenu = gtk.Menu() # File Title filem = gtk.MenuItem("File") filem.set_submenu(filemenu) openm = gtk.MenuItem("Open") openm.connect("activate", self.open) filemenu.append(openm) exitm = gtk.MenuItem("Exit") exitm.connect("activate", gtk.main_quit) filemenu.append(exitm) mb.append(filem) # Help helpmenu = gtk.Menu() # Help Title helpm = gtk.MenuItem("Help") helpm.set_submenu(helpmenu) aboutm = gtk.MenuItem("About") aboutm.connect("activate", self.about) helpmenu.append(aboutm) mb.append(helpm) self.my_vbox.pack_start(mb, False) ##### Buttons self.btnExit = gtk.Button("Exit") self.btnExit.connect("clicked", self.destroy) self.btnExit.set_tooltip_text("Close application") self.btnOpen = gtk.Button("Open") self.btnOpen.connect("clicked", self.open) self.btnRun = gtk.Button("Reorganize XML") self.btnRun.connect("clicked", self.reorganize_xml) self.btnFirmwares = gtk.Button("Firmwares") self.btnFirmwares.connect("clicked", self.find_firmwares) self.btnSubSystem = gtk.Button("SubSystems") self.btnSubSystem.connect("clicked", self.find_subsystems) self.btnModules = gtk.Button("Add Modules") self.btnModules.connect("clicked", self.find_modules) self.btnModuleDefines = gtk.Button("Define") self.btnModuleDefines.connect("clicked", self.find_module_defines) self.btnAbout = gtk.Button("About") self.btnAbout.connect("clicked", self.about) self.toolbar = gtk.HBox() self.toolbar.pack_start(self.btnOpen) self.toolbar.pack_start(self.btnRun) self.toolbar.pack_start(self.btnAbout) self.toolbar.pack_start(self.btnExit) self.my_vbox.pack_start(self.toolbar, False) self.firmwares_combo = gtk.combo_box_entry_new_text() self.find_firmwares(self.firmwares_combo) self.firmwares_combo.connect("changed", self.find_subsystems) self.subsystems_combo = gtk.combo_box_entry_new_text() self.boards_combo = gtk.combo_box_entry_new_text() self.find_boards(self.boards_combo) self.firmwarebar = gtk.HBox() self.firmwarebar.pack_start(self.btnFirmwares) self.firmwarebar.pack_start(self.btnSubSystem) self.firmwarebar.pack_start(self.firmwares_combo) self.firmwarebar.pack_start(self.boards_combo) self.firmwarebar.pack_start(self.subsystems_combo) self.modules_combo = gtk.combo_box_entry_new_text() self.find_modules(self.modules_combo) self.modules_combo.connect("changed", self.find_module_defines) #self.modulebar = gtk.HBox() self.firmwarebar.pack_start(self.btnModules) self.firmwarebar.pack_start(self.btnModuleDefines) self.firmwarebar.pack_start(self.modules_combo) #self.my_vbox.pack_start(self.modulebar) self.my_vbox.pack_start(self.firmwarebar, False) ##### Middle self.editor = gtk.HBox() self.fill_tree_from_airframe() self.scrolltree = gtk.ScrolledWindow() self.scrolltree.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.scrolltree.add(self.treeview) self.scrolltree.set_size_request(400, 600) self.editor.pack_start(self.scrolltree) self.fill_datagrid_from_section() self.datagrid.set_size_request(900, 600) self.editor.pack_start(self.datagrid) self.my_vbox.pack_start(self.editor) self.text_box = gtk.Label("") self.text_box.set_size_request(600, 1000) self.scrolltext = gtk.ScrolledWindow() self.scrolltext.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.scrolltext.add_with_viewport(self.text_box) self.scrolltext.set_size_request(400, 100) self.my_vbox.pack_start(self.scrolltext) self.load_airframe_xml() ##### Bottom self.searchbar = gtk.HBox() self.textbox = gtk.Entry() #self.textbox.connect("changed",self.textchanged) self.btnSearch = gtk.Button("Search...") self.btnSearch.connect("clicked", self.search) self.searchbar.pack_start(self.textbox) self.searchbar.pack_start(self.btnSearch) self.my_vbox.pack_start(self.searchbar, False) self.window.add(self.my_vbox) self.window.show_all() self.window.connect("destroy", self.destroy)
def button_action(self, widget, event): x = int(event.x) y = int(event.y) path = self.treeview.get_path_at_pos(x, y) if path == None: return True row_path, column, _, _ = path if event.button == 3: if self.cb_item_right_click != None: return self.cb_item_right_click(widget, event) else: iter = self.store.get_iter(row_path) type, object = self.store.get(iter, TYPE_COLUMN, OBJECT_COLUMN) if type == DEVICE: menu = gtk.Menu() item = gtk.CheckMenuItem("Show events") item.set_sensitive(False) menu.append(item) item = gtk.CheckMenuItem("Show log") item.set_sensitive(False) menu.append(item) menu.append(gtk.SeparatorMenuItem()) item = gtk.MenuItem("Extract device and service descriptions...") item.connect("activate", self.extract_descriptions, object) menu.append(item) menu.append(gtk.SeparatorMenuItem()) item = gtk.MenuItem("Test device...") item.set_sensitive(False) menu.append(item) devtype = device_type(object) if devtype == 'mediaserver': menu.append(gtk.SeparatorMenuItem()) item = gtk.MenuItem("Browse MediaServer...") item.connect("activate", self.mediaserver_browse, object) menu.append(item) elif devtype == 'mediarenderer': menu.append(gtk.SeparatorMenuItem()) item = gtk.MenuItem("Control MediaRendererer...") item.connect("activate", self.mediarenderer_control, object) menu.append(item) elif devtype == 'internetgatewaydevice': menu.append(gtk.SeparatorMenuItem()) item = gtk.MenuItem("control InternetGatewayDevice") item.connect("activate", self.igd_control, object) menu.append(item) menu.show_all() menu.popup(None, None, None, event.button, event.time) return True elif type == SERVICE: menu = gtk.Menu() item = gtk.CheckMenuItem("Show events") item.set_sensitive(False) menu.append(item) item = gtk.CheckMenuItem("Show log") item.set_sensitive(False) menu.append(item) menu.show_all() menu.popup(None, None, None, event.button, event.time) return True return False elif (event.button == 1 and self.cb_item_left_click != None): reactor.callLater(0.1, self.cb_item_left_click, widget, event) return False return 0
def make_menu_item(self, name, data): item = gtk.MenuItem(name) item.connect("activate", self.set_save_filetype, data) item.show() self.menu.append(item)
def __init__(self, name, lash_client): self.mixer = jack_mixer_c.Mixer(name) if not self.mixer: return self.monitor_channel = self.mixer.add_output_channel( "Monitor", True, True) self.save = False if lash_client: # Send our client name to server lash_event = lash.lash_event_new_with_type(lash.LASH_Client_Name) lash.lash_event_set_string(lash_event, name) lash.lash_send_event(lash_client, lash_event) lash.lash_jack_client_name(lash_client, name) self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) if name != self.mixer.client_name(): self.window.set_title(name + " (" + self.mixer.client_name() + ")") else: self.window.set_title(name) self.window.set_icon_name('jack_mixer') self.gui_factory = gui.Factory(self.window, self.meter_scales, self.slider_scales) self.vbox_top = gtk.VBox() self.window.add(self.vbox_top) self.menubar = gtk.MenuBar() self.vbox_top.pack_start(self.menubar, False) mixer_menu_item = gtk.MenuItem("_Mixer") self.menubar.append(mixer_menu_item) edit_menu_item = gtk.MenuItem('_Edit') self.menubar.append(edit_menu_item) help_menu_item = gtk.MenuItem('_Help') self.menubar.append(help_menu_item) self.window.set_default_size(120, 300) mixer_menu = gtk.Menu() mixer_menu_item.set_submenu(mixer_menu) add_input_channel = gtk.ImageMenuItem('New _Input Channel') mixer_menu.append(add_input_channel) add_input_channel.connect("activate", self.on_add_input_channel) add_output_channel = gtk.ImageMenuItem('New _Output Channel') mixer_menu.append(add_output_channel) add_output_channel.connect("activate", self.on_add_output_channel) mixer_menu.append(gtk.SeparatorMenuItem()) open = gtk.ImageMenuItem(gtk.STOCK_OPEN) mixer_menu.append(open) open.connect('activate', self.on_open_cb) save = gtk.ImageMenuItem(gtk.STOCK_SAVE) mixer_menu.append(save) save.connect('activate', self.on_save_cb) save_as = gtk.ImageMenuItem(gtk.STOCK_SAVE_AS) mixer_menu.append(save_as) save_as.connect('activate', self.on_save_as_cb) mixer_menu.append(gtk.SeparatorMenuItem()) quit = gtk.ImageMenuItem(gtk.STOCK_QUIT) mixer_menu.append(quit) quit.connect('activate', self.on_quit_cb) edit_menu = gtk.Menu() edit_menu_item.set_submenu(edit_menu) self.channel_edit_input_menu_item = gtk.MenuItem('_Edit Input Channel') edit_menu.append(self.channel_edit_input_menu_item) self.channel_edit_input_menu = gtk.Menu() self.channel_edit_input_menu_item.set_submenu( self.channel_edit_input_menu) self.channel_edit_output_menu_item = gtk.MenuItem( 'Edit _Output Channel') edit_menu.append(self.channel_edit_output_menu_item) self.channel_edit_output_menu = gtk.Menu() self.channel_edit_output_menu_item.set_submenu( self.channel_edit_output_menu) self.channel_remove_input_menu_item = gtk.MenuItem( 'Remove _Input Channel') edit_menu.append(self.channel_remove_input_menu_item) self.channel_remove_input_menu = gtk.Menu() self.channel_remove_input_menu_item.set_submenu( self.channel_remove_input_menu) self.channel_remove_output_menu_item = gtk.MenuItem( '_Remove Output Channel') edit_menu.append(self.channel_remove_output_menu_item) self.channel_remove_output_menu = gtk.Menu() self.channel_remove_output_menu_item.set_submenu( self.channel_remove_output_menu) channel_remove_all_menu_item = gtk.ImageMenuItem(gtk.STOCK_CLEAR) edit_menu.append(channel_remove_all_menu_item) channel_remove_all_menu_item.connect("activate", self.on_channels_clear) edit_menu.append(gtk.SeparatorMenuItem()) preferences = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES) preferences.connect('activate', self.on_preferences_cb) edit_menu.append(preferences) help_menu = gtk.Menu() help_menu_item.set_submenu(help_menu) about = gtk.ImageMenuItem(gtk.STOCK_ABOUT) help_menu.append(about) about.connect("activate", self.on_about) self.hbox_top = gtk.HBox() self.vbox_top.pack_start(self.hbox_top, True) self.scrolled_window = gtk.ScrolledWindow() self.hbox_top.pack_start(self.scrolled_window, True) self.hbox_inputs = gtk.HBox() self.hbox_inputs.set_spacing(0) self.hbox_inputs.set_border_width(0) self.hbox_top.set_spacing(0) self.hbox_top.set_border_width(0) self.channels = [] self.output_channels = [] self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.scrolled_window.add_with_viewport(self.hbox_inputs) self.hbox_outputs = gtk.HBox() self.hbox_outputs.set_spacing(0) self.hbox_outputs.set_border_width(0) frame = gtk.Frame() self.hbox_outputs.pack_start(frame, False) self.hbox_top.pack_start(self.hbox_outputs, False) self.window.connect("destroy", gtk.main_quit) self.trayicon = TrayIcon(self) self.window.connect('delete-event', self.on_delete_event) gobject.timeout_add(80, self.read_meters) self.lash_client = lash_client gobject.timeout_add(200, self.lash_check_events) gobject.timeout_add(50, self.midi_events_check)
def __init__(self, handler, config): """ constructor handler -- e3common.Handler.OptionsHandler """ gtk.Menu.__init__(self) self.handler = handler if not check_gtk3(): self.by_status = gtk.RadioMenuItem(None, _('Order by _status')) self.by_group = gtk.RadioMenuItem(self.by_status, _('Order by _group')) else: self.by_status = gtk.RadioMenuItem(_('Order by _status')) self.by_status.set_use_underline(True) self.by_group = gtk.RadioMenuItem.new_with_mnemonic_from_widget( self.by_status, _('Order by _group')) self.by_group.set_active(config.b_order_by_group) self.by_status.set_active(not config.b_order_by_group) self.show_menu = gtk.MenuItem(_('Show...')) self.show_submenu = gtk.Menu() self.show_offline = gtk.CheckMenuItem(_('Show _offline contacts')) self.show_offline.set_active(config.b_show_offline) self.group_offline = gtk.CheckMenuItem(_('G_roup offline contacts')) self.group_offline.set_active(config.b_group_offline) self.show_empty_groups = gtk.CheckMenuItem(_('Show _empty groups')) self.show_empty_groups.set_active(config.b_show_empty_groups) self.show_blocked = gtk.CheckMenuItem(_('Show _blocked contacts')) self.show_blocked.set_active(config.b_show_blocked) self.order_by_name = gtk.CheckMenuItem(_('Sort by name')) self.order_by_name.set_active(config.b_order_by_name) self.preferences = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES) self.preferences.connect( 'activate', lambda *args: self.handler.on_preferences_selected()) self.by_status.connect( 'toggled', lambda *args: self.handler.on_order_by_status_toggled( self.by_status.get_active())) self.by_group.connect( 'toggled', lambda *args: self.handler.on_order_by_group_toggled( self.by_group.get_active())) self.show_empty_groups.connect( 'toggled', lambda *args: self.handler.on_show_empty_groups_toggled( self.show_empty_groups.get_active())) self.show_offline.connect( 'toggled', lambda *args: self.handler.on_show_offline_toggled( self.show_offline.get_active())) self.group_offline.connect( 'toggled', lambda *args: self.handler.on_group_offline_toggled( self.group_offline.get_active())) self.show_blocked.connect( 'toggled', lambda *args: self.handler.on_show_blocked_toggled( self.show_blocked.get_active())) self.order_by_name.connect( 'toggled', lambda *args: self.handler.on_order_by_name_toggled( self.order_by_name.get_active())) self.show_menu.set_submenu(self.show_submenu) self.show_submenu.append(self.show_offline) self.append(self.by_status) self.append(self.by_group) self.append(gtk.SeparatorMenuItem()) self.append(self.show_menu) self.show_submenu.append(self.show_empty_groups) self.show_submenu.append(self.show_blocked) self.show_submenu.append(self.order_by_name) self.append(self.group_offline) self.append(gtk.SeparatorMenuItem()) self.append(self.preferences)
def CreateMenus(self): """Create all menus for Indicator""" self.MainMenu = gtk.Menu() self.ControlsMenu = gtk.Menu() self.UpdatesMenu = gtk.Menu() #Create the items for the main menu. self.VersionandNameItem = gtk.MenuItem("Wine Autostart v"+Version) self.Separator1 = gtk.SeparatorMenuItem() self.StatusItem = gtk.MenuItem("Status: Please wait...") self.Separator2 = gtk.SeparatorMenuItem() self.SettingsItem = gtk.MenuItem("Settings") self.UpdatesMenuItem = gtk.MenuItem("Updates") self.ControlsMenuItem = gtk.MenuItem("Controls") self.Separator3 = gtk.SeparatorMenuItem() self.AboutItem = gtk.MenuItem("About") self.Separator4 = gtk.SeparatorMenuItem() self.QuitItem = gtk.MenuItem("Quit") #Create the items for the updates menu. self.UpdateCheckItem = gtk.MenuItem("Check For Updates") self.PrivacyPolicyItem = gtk.MenuItem("Privacy Policy") #Create the items for the controls menu. self.StartItem = gtk.MenuItem("Start") self.StopItem = gtk.MenuItem("Stop") #Add the items to the main menu. self.MainMenu.append(self.VersionandNameItem) self.MainMenu.append(self.Separator1) self.MainMenu.append(self.StatusItem) self.MainMenu.append(self.Separator2) self.MainMenu.append(self.SettingsItem) self.MainMenu.append(self.UpdatesMenuItem) self.MainMenu.append(self.ControlsMenuItem) self.MainMenu.append(self.Separator3) self.MainMenu.append(self.AboutItem) self.MainMenu.append(self.Separator4) self.MainMenu.append(self.QuitItem) #Add the items to the updates menu. self.UpdatesMenu.append(self.UpdateCheckItem) self.UpdatesMenu.append(self.PrivacyPolicyItem) self.UpdatesMenuItem.set_submenu(self.UpdatesMenu) #Add the items to the controls menu. self.ControlsMenu.append(self.StartItem) self.ControlsMenu.append(self.StopItem) self.ControlsMenuItem.set_submenu(self.ControlsMenu) #Show the items self.VersionandNameItem.show() self.Separator1.show() self.StatusItem.show() self.Separator2.show() self.SettingsItem.show() self.UpdatesMenuItem.show() self.UpdateCheckItem.show() self.PrivacyPolicyItem.show() self.ControlsMenuItem.show() self.StartItem.show() self.StopItem.show() self.Separator3.show() self.AboutItem.show() self.Separator4.show() self.QuitItem.show() #Set MainMenu as the menu for the appindicator. self.AppIndicator.set_menu(self.MainMenu)
def update_menu(self): self.isos = {} def umount(widget, iso_name, data=None): self.isos[iso_name].umount() self.update_menu() notification = pynotify.Notification(_('Disk Image Unmounted'), os.path.basename(iso_name), 'media-eject') notification.show() def browse(widget, iso_name, data=None): self.isos[iso_name].browse() def burn(widget, iso_name, data=None): self.isos[iso_name].burn() try: mtab_path = os.path.join(os.path.expanduser('~'), '.mtab.fuseiso') mtab = open(mtab_path).read().split('\n') except: mtab = [] menu = gtk.Menu() menu.show() show_separator = False for line in mtab: if line: show_separator = True items = line.split(' ') items[0] = items[0].replace('\\040', ' ') iso = DiskImage(items[0]) self.isos[items[0]] = iso item = gtk.MenuItem(os.path.basename(items[0])) #item.set_image(gtk.image_new_from_icon_name('media-cdrom',gtk.ICON_SIZE_MENU)) item.show() item.connect("activate", browse, items[0]) menu.append(item) # item = gtk.MenuItem(_(' Burn')) # item.show() # item.connect("activate", burn, items[0]) # menu.append(item) item = gtk.MenuItem(_(' Eject')) item.show() item.connect("activate", umount, items[0]) menu.append(item) separator = gtk.MenuItem() separator.show() menu.append(separator) image = gtk.MenuItem(_('Open Disk Image...')) image.connect("activate", self.add_image) image.show() menu.append(image) # item = gtk.CheckMenuItem(_('Remember mounted images')) # client = gconf.client_get_default() # item.set_active(client.get_bool('/apps/mounty/remember-mounts')) # item.connect("activate", self.set_remember) # item.show() # menu.append(item) # item = gtk.CheckMenuItem(_('Load at startup')) # if os.path.exists(os.path.join(os.path.expanduser('~'), '.config', 'autostart', 'mounty-autostart.desktop')): # item.set_active(True) # item.connect("activate", self.set_startup) # item.show() # menu.append(item) item = gtk.MenuItem(_('About')) item.connect("activate", self.show_about) item.show() menu.append(item) # Begin XFCEpatch # item = gtk.MenuItem(_('Quit')) # item.connect("activate", self.quit) # item.show() # menu.append(item) # self.ind.set_menu(menu) try: self.statusIcon.disconnect(self.handlerid) except: pass self.handlerid = self.statusIcon.connect("activate", self.on_left_click, menu)
def showmenu(self, widget, data=None): ''' Show a menu ''' self.menugohome = gtk.MenuItem("Prev") self.menugohome.connect("activate", self.gohome) self.menugohome.add(self.menugohome)
def __init__(self, parentConversationWindow, controller): '''Contructor''' gtk.MenuBar.__init__(self) self.parentConversationWindow = parentConversationWindow self.controller = controller accelGroup = parentConversationWindow.accelGroup # --- 'Conversation' menu conversationMenu = gtk.Menu() conversationMenuItem = gtk.MenuItem(_("_Conversation")) conversationMenuItem.set_submenu(conversationMenu) self.inviteMenuItem = gtk.ImageMenuItem(_('_Invite')) self.inviteMenuItem.set_image( gtk.image_new_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_MENU)) self.inviteMenuItem.connect('activate', self.onInviteActivate) self.inviteMenuItem.add_accelerator('activate', accelGroup, ord('I'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) self.sendFileMenuItem = gtk.ImageMenuItem(_("_Send file")) self.sendFileMenuItem.set_image( gtk.image_new_from_stock(gtk.STOCK_GOTO_TOP, gtk.ICON_SIZE_MENU)) self.sendFileMenuItem.connect('activate', self.onSendFileActivate) self.sendFileMenuItem.add_accelerator('activate', accelGroup, ord('S'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) clearMenuItem = gtk.ImageMenuItem(_('C_lear Conversation')) clearMenuItem.set_image( gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU)) clearMenuItem.connect('activate', parentConversationWindow.clearOutputText) clearMenuItem.add_accelerator('activate', accelGroup, ord('L'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) closeMenuItem = gtk.ImageMenuItem(_('Close all')) closeMenuItem.set_image( gtk.image_new_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU)) closeMenuItem.connect('activate', self.onCloseActivate) closeMenuItem.add_accelerator('activate', accelGroup, ord('Q'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) conversationMenu.add(self.inviteMenuItem) conversationMenu.add(self.sendFileMenuItem) conversationMenu.add(clearMenuItem) conversationMenu.add(gtk.SeparatorMenuItem()) conversationMenu.add(closeMenuItem) self.add(conversationMenuItem) # --- Format menu formatMenu = gtk.Menu() formatMenuItem = gtk.MenuItem(_("For_mat")) formatMenuItem.set_submenu(formatMenu) fontMenuItem = gtk.ImageMenuItem(gtk.STOCK_SELECT_FONT) colorMenuItem = gtk.ImageMenuItem(gtk.STOCK_SELECT_COLOR) fontMenuItem.connect('activate', self.onFontActivate) colorMenuItem.connect('activate', self.onColorActivate) formatMenu.add(fontMenuItem) formatMenu.add(colorMenuItem) self.add(formatMenuItem)
def __init__(self): ## Setup window. gtk.Window.__init__(self) self.set_default_size(400, 300) self.set_title("BlueDar %s"%VERSION) self.set_decorated(True) self.set_icon(gtk.gdk.pixbuf_new_from_file(ICON)) self.set_border_width(5) self.connect('delete-event', self.Destroy) ## Make button self.confirmButton = gtk.Button('Apply') self.cancelButton = gtk.Button('Close') self.scanButton = gtk.Button('Scan') self.setMacButton = gtk.Button('Set Mac') self.clearScanButton = gtk.Button('Clear') self.enableButton = gtk.Button("Disable") self.confirmButton.connect('clicked', self.saveAll) self.cancelButton.connect('clicked', self.showAll) self.scanButton.connect('clicked', self.scan) self.setMacButton.connect('clicked', self.setMacAddress) self.clearScanButton.connect('clicked', self.clearScan) self.enableButton.connect('clicked', self.toggleRadar) ## Setup status icon in sys tray. self.icon = gtk.StatusIcon() self.setStatus("BlueDar %s"%VERSION) self.icon.set_from_file(ICON) ## Create VBox and HBox. self.configBox = gtk.VBox(True, 1) self.vBox = gtk.VBox(False, 1) self.vBox2 = gtk.VBox(True, 1) self.vBox3 = gtk.VBox(True, 1) self.hBox1 = gtk.HBox(True, 0) self.hBox2 = gtk.HBox(True, 0) self.hBox3 = gtk.HBox(True, 0) self.hBox4 = gtk.HBox(True, 0) self.hBox5 = gtk.HBox(True, 0) self.hBox6 = gtk.HBox(True, 0) self.hBox7 = gtk.HBox(True, 0) self.label1 = gtk.Label("Mac Address: ") self.label2 = gtk.Label("Lock Signal: ") self.label3 = gtk.Label("Unlock Signal: ") self.label4 = gtk.Label("Lock Command: ") self.label5 = gtk.Label("Unlock Command: ") self.label6 = gtk.Label("Proximity Command: ") self.label7 = gtk.Label("Interval: ") self.label1.set_alignment(0,1) self.label2.set_alignment(0,1) self.label3.set_alignment(0,1) self.label4.set_alignment(0,1) self.label5.set_alignment(0,1) self.label6.set_alignment(0,1) self.label7.set_alignment(0,1) ## Create Text Entries. self.entry1 = gtk.Entry() self.entry2 = gtk.Entry() self.entry3 = gtk.Entry() self.entry4 = gtk.Entry() self.entry5 = gtk.Entry() self.entry6 = gtk.Entry() self.entry7 = gtk.Entry() ## Pack HBoxes self.hBox1.pack_start(self.label1, False, True, 1) self.hBox1.pack_start(self.entry1, True, True, 1) self.hBox2.pack_start(self.label2, False, True, 1) self.hBox2.pack_start(self.entry2, True, True, 1) self.hBox3.pack_start(self.label3, False, True, 1) self.hBox3.pack_start(self.entry3, True, True, 1) self.hBox4.pack_start(self.label4, False, True, 1) self.hBox4.pack_start(self.entry4, True, True, 1) self.hBox5.pack_start(self.label5, False, True, 1) self.hBox5.pack_start(self.entry5, True, True, 1) self.hBox6.pack_start(self.label6, False, True, 1) self.hBox6.pack_start(self.entry6, True, True, 1) self.hBox7.pack_start(self.label7, False, True, 1) self.hBox7.pack_start(self.entry7, True, True, 1) ## Pack entries on the hBox. self.vBox2.pack_start(self.hBox1, True, True, 1) self.vBox2.pack_start(self.hBox2, True, True, 1) self.vBox2.pack_start(self.hBox3, True, True, 1) self.vBox2.pack_start(self.hBox4, True, True, 1) self.vBox2.pack_start(self.hBox5, True, True, 1) self.vBox2.pack_start(self.hBox6, True, True, 1) self.vBox2.pack_start(self.hBox7, True, True, 1) self.buttonHBox = gtk.HBox(True, 0) self.buttonHBox.pack_start(self.confirmButton, False, True, 1) self.buttonHBox.pack_start(self.cancelButton, False, True, 1) ## Pack box of configs into this container. self.configBox.pack_start(self.vBox2, True, True, 1) ## Make notebook self.Notebook1 = Notebook() self.DeviceList = Tree() self.avBox = gtk.VBox(False, 1) sw = ScrollWindow() sw.add(self.DeviceList) self.ahBox = gtk.HBox(True, 1) self.ahBox.pack_start(self.scanButton, False, True, 1) self.ahBox.pack_start(self.setMacButton, False, True, 1) self.ahBox.pack_start(self.clearScanButton, False, True, 1) self.avBox.pack_start(sw, True, True, 1) self.avBox.pack_start(self.ahBox, False, False, 1) self.vBox3.pack_start(self.enableButton, True, False, 1) self.Notebook1.prepend(self.avBox, "BlueDar") self.Notebook1.append(self.configBox, "Config") self.Notebook1.append(self.vBox3, "Controls") ## Pack buttons onto vBox3 self.vBox.pack_start(self.Notebook1, True, False, 1) self.vBox.pack_start(self.buttonHBox, False, False, 1) self.vBox.show_all() self.add(self.vBox) ## Setup menu for status icon. self.popupmenu = gtk.Menu() menuItem = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES) menuItem.connect('activate', self.showAll) self.popupmenu.append(menuItem) menuItem = gtk.ImageMenuItem(gtk.STOCK_ABOUT) menuItem.connect('activate', self.showAbout) self.popupmenu.append(menuItem) menuItem = gtk.MenuItem() self.popupmenu.append(menuItem) menuItem = gtk.ImageMenuItem(gtk.STOCK_QUIT) menuItem.connect('activate', self.quit) self.popupmenu.append(menuItem) ## Connect icon events. self.icon.connect('activate', self.showAll) self.icon.connect('popup-menu', self.menu, self.popupmenu) ## Show Status Icon. self.icon.set_visible(True) ## Start radar self.startRadar()
def __init__(self): self.menu_item = gtk.MenuItem("Plot data") self.menu_item.show() geany.main_widgets.tools_menu.append(self.menu_item) self.menu_item.connect("activate", self.on_plot_item_clicked)
def build_menu_radio_list(value_list, callback, pref_value=None, suffix=None, show_notset=False, notset_label=None, notset_lessthan=0, show_other=False, show_activated=False, activated_label=None): # Build a menu with radio menu items from a list and connect them to # the callback. The pref_value is what you would like to test for the # default active radio item. if notset_label is None: notset_label = _("Unlimited") if activated_label is None: activated_label = _("Activated") menu = gtk.Menu() group = None if show_activated is False: if pref_value > -1 and pref_value not in value_list: value_list.pop() value_list.append(pref_value) for value in sorted(value_list): if suffix != None: menuitem = gtk.RadioMenuItem(group, str(value) + " " + \ suffix) else: menuitem = gtk.RadioMenuItem(group, str(value)) group = menuitem if value == pref_value and pref_value != None: menuitem.set_active(True) if callback != None: menuitem.connect("toggled", callback) menu.append(menuitem) if show_activated is True: for value in sorted(value_list): menuitem = gtk.RadioMenuItem(group, str(activated_label)) group = menuitem if value == pref_value and pref_value != None: menuitem.set_active(True) if callback != None: menuitem.connect("toggled", callback) menu.append(menuitem) if show_notset: menuitem = gtk.RadioMenuItem(group, notset_label) menuitem.set_name("unlimited") if pref_value < notset_lessthan and pref_value != None: menuitem.set_active(True) if show_activated and pref_value == 1: menuitem.set_active(True) menuitem.connect("toggled", callback) menu.append(menuitem) # Add the Other... menuitem if show_other is True: menuitem = gtk.SeparatorMenuItem() menu.append(menuitem) menuitem = gtk.MenuItem(_("Other...")) menuitem.set_name("other") menuitem.connect("activate", callback) menu.append(menuitem) return menu
def build_submenu(self, menu, menu_items, submenu_items, insert_pos, selected_pos=[], selected_icon=None, selected_submenu=None, higher_level_item=None, do_connect_subitem=False): """ Given a base menu, a list of menuitems, and a list of submenuitems create a submenu structure at the specified position in the menu. Each new line in the menu has the same submenu elements. e.g. =menu= |-MenuItem 1 |-Submenu1 |-Submenu2 |-..... |-MenuItem 2 |-Submenu1 |-Submenu2 |-..... |.... Optionally a list of selected positions can be specifed, this can have either/both an icon associated to show selection and a different submenu than unselected menu lines. ATM selected icon must be a stock item string if submenu_items has dictionary then this creates a further submenu and so on - if the attribute of the dict is a callable we use it as a generator function which creates a list, if its an iterable its just iterated. click callback is the click response fucntion that is connected to all leaf nodes (nodes node producing another submenu - meaning that can be clicked casuing an action) """ for line in menu_items: ##A line for our menu named by the host/interface menuitem = gtk.ImageMenuItem(line) ## if selected add the specified icon if insert_pos in selected_pos and selected_icon: img = gtk.image_new_from_stock(selected_icon, 1) menuitem.set_image(img) ##If a different item has been selected for a submenu and we're selected swap out and use that submenu if type(selected_submenu) != type( None) and insert_pos in selected_pos: submenu_to_use = selected_submenu else: ##reset to standard submenu submenu_to_use = submenu_items ##Is our submenu a a static list or a callable so dynamic content can be created for this entry? if callable(submenu_to_use): submenu_to_use = submenu_to_use(line, higher_level_item) #print "SUBMENU TO USE",submenu_to_use,type(submenu_to_use) if submenu_to_use: ##Make a menu container for the submenu submenu_cont = gtk.Menu() submenu_cont.show() ##Now add in the correct lines for that submenu for subitem in submenu_to_use: if type(subitem) == type({}): ##dictionaries denote the submenu is a submenu itself - the key is use for the line entry - the value should be a list which we call ourselves with ## iterate on ourselves basically sub_sub = self.build_submenu(submenu_cont, subitem.keys(), subitem.values()[0], 0, higher_level_item=line, do_connect_subitem=True) else: submenuItem = gtk.MenuItem(subitem) submenuItem.show() submenu_cont.append(submenuItem) ##Now for each submenu entry set the response method if that ## has been requested - need this as no way to look for ## existing handlers it seems ?? if do_connect_subitem: submenuItem.connect("activate", self.get_rightclick_response, subitem, line) ##Attach the submenu to our menu menuitem.set_submenu(submenu_cont) else: ##If the item was suppose to have a submenu but doesn't dim it (unless it's selected) if insert_pos not in selected_pos: menuitem.set_sensitive(False) menuitem.show() ##Finally add it to the right click menu proper at the desired position menu.append(menuitem) menu.reorder_child(menuitem, insert_pos) insert_pos += 1 return menu
def __init__(self): # paparazzi process self.pp = None self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_title("Paparazzi Configuration Chooser") self.my_vbox = gtk.VBox() self.conf_xml = os.path.join(paparazzi.conf_dir, "conf.xml") self.conf_personal_name = "conf_personal.xml" self.conf_personal = os.path.join(paparazzi.conf_dir, self.conf_personal_name) self.controlpanel_xml = os.path.join(paparazzi.conf_dir, "control_panel.xml") self.controlpanel_personal_name = "control_panel_personal.xml" self.controlpanel_personal = os.path.join(paparazzi.conf_dir, self.controlpanel_personal_name) self.exclude_backups = True self.verbose = False # MenuBar mb = gtk.MenuBar() # File filemenu = gtk.Menu() # File Title filem = gtk.MenuItem("File") filem.set_submenu(filemenu) exitm = gtk.MenuItem("Exit") exitm.connect("activate", gtk.main_quit) filemenu.append(exitm) mb.append(filem) # Help helpmenu = gtk.Menu() # Help Title helpm = gtk.MenuItem("Help") helpm.set_submenu(helpmenu) aboutm = gtk.MenuItem("About") aboutm.connect("activate", self.about) helpmenu.append(aboutm) mb.append(helpm) self.my_vbox.pack_start(mb, False) # Combo Bar self.conf_label = gtk.Label("Conf:") self.conf_label.set_size_request(100, 30) self.conf_file_combo = gtk.combo_box_new_text() self.find_conf_files() self.conf_file_combo.connect("changed", self.changed_cb) self.conf_file_combo.set_size_request(550, 30) self.btnDeleteConf = gtk.Button(None, gtk.STOCK_DELETE) self.btnDeleteConf.connect("clicked", self.delete_conf) self.btnDeleteConf.set_tooltip_text("Permanently Delete Conf") self.btnPersonalConf = gtk.Button(None, gtk.STOCK_COPY) self.btnPersonalConf.connect("clicked", self.personal_conf) self.btnPersonalConf.set_tooltip_text("Create Personal Conf Based on Selected and Activate") self.confbar = gtk.HBox() self.confbar.pack_start(self.conf_label) self.confbar.pack_start(self.conf_file_combo) self.confbar.pack_start(self.btnDeleteConf) self.confbar.pack_start(self.btnPersonalConf) self.my_vbox.pack_start(self.confbar, False) # Explain current conf config self.conf_explain = gtk.Label("") self.update_conf_label() self.conf_explain.set_size_request(0, 45) self.cfexbar = gtk.HBox() self.cfexbar.pack_start(self.conf_explain) self.my_vbox.pack_start(self.cfexbar, False) # Count Airframes self.conf_airframes = gtk.Label("") self.count_airframes_in_conf() self.conf_airframes.set_size_request(650,180) self.conf_airframes.set_line_wrap(True) self.btnInfo = gtk.Button(None, "More\nInfo") self.btnInfo.connect("clicked", self.more_info) self.btnInfo.set_tooltip_text("More information on airframe files") self.caexbar = gtk.HBox() self.caexbar.pack_start(self.conf_airframes) self.caexbar.pack_start(self.btnInfo) self.my_vbox.pack_start(self.caexbar, False) # Controlpanel self.controlpanel_label = gtk.Label("Controlpanel:") self.controlpanel_label.set_size_request(100, 30) self.controlpanel_file_combo = gtk.combo_box_new_text() self.find_controlpanel_files() self.controlpanel_file_combo.set_size_request(550, 30) # window self.btnDeleteControl = gtk.Button(None, gtk.STOCK_DELETE) self.btnDeleteControl.connect("clicked", self.delete_controlpanel) self.btnDeleteControl.set_tooltip_text("Permanently Delete") self.btnPersonalControl = gtk.Button(None, gtk.STOCK_COPY) self.btnPersonalControl.connect("clicked", self.personal_controlpanel) self.btnPersonalControl.set_tooltip_text("Create Personal Controlpanel Based on Selected and Activate") self.controlpanelbar = gtk.HBox(False) self.controlpanelbar.pack_start(self.controlpanel_label) self.controlpanelbar.pack_start(self.controlpanel_file_combo) self.controlpanelbar.pack_start(self.btnDeleteControl) self.controlpanelbar.pack_start(self.btnPersonalControl) self.my_vbox.pack_start(self.controlpanelbar, False) # Explain current controlpanel config self.controlpanel_explain = gtk.Label("") self.update_controlpanel_label() self.controlpanel_explain.set_size_request(0, 45) self.ctexbar = gtk.HBox() self.ctexbar.pack_start(self.controlpanel_explain) self.my_vbox.pack_start(self.ctexbar, False) # show backups button self.btnBackups = gtk.CheckButton("show backups") self.btnBackups.connect("toggled", self.set_backups) self.my_vbox.pack_start(self.btnBackups, False) # show gui button self.btnPythonGUI = gtk.CheckButton("new python center (beta)") self.my_vbox.pack_start(self.btnPythonGUI, False) # Buttons self.btnAccept = gtk.Button("Set Active") self.btnAccept.connect("clicked", self.accept) self.btnAccept.set_tooltip_text("Set selected Conf/Control_Panel as Active") self.btnLaunch = gtk.Button("Launch Paparazzi with selected configuration") self.btnLaunch.connect("clicked", self.launch) self.btnLaunch.set_tooltip_text("Launch Paparazzi with current conf.xml and control_panel.xml") self.btnExit = gtk.Button("Exit") self.btnExit.connect("clicked", gtk.main_quit) self.btnExit.set_tooltip_text("Close application") self.toolbar = gtk.HBox() self.toolbar.set_size_request(0, 60) self.toolbar.pack_start(self.btnLaunch) self.toolbar.pack_start(self.btnAccept) self.toolbar.pack_start(self.btnExit) self.my_vbox.pack_start(self.toolbar, False) # status bar self.statusbar = gtk.Statusbar() self.context_id = self.statusbar.get_context_id("info") #self.statusbar.push(self.context_id, "Waiting for you to do something...") self.my_vbox.pack_end(self.statusbar, False) # Bottom self.window.add(self.my_vbox) self.window.show_all() self.window.set_position(gtk.WIN_POS_CENTER_ALWAYS) self.window.connect("destroy", gtk.main_quit)