def __init__(self, plugin, window, bookmarks, config): self._window = window self._plugin = plugin self._bookmarks = bookmarks self._config = config self._doc_lines = {} # Create icon self._icon = gtk.Image() self._icon.set_from_icon_name('stock_help-add-bookmark', gtk.ICON_SIZE_MENU) # Insert main menu items self._insert_menu() # Create bookmark toggle dialog self._dlg_toggle = toggle_dlg.toggle_dlg(None, self._config) self._dlg_toggle.connect("response", self._on_dlg_toggle_response) # Create bottom pane tree self._tree = gtk.TreeView() # Create line number column self._line_column = gtk.TreeViewColumn(_('Line')) self._tree.append_column(self._line_column) self._line_cell = gtk.CellRendererText() self._line_column.pack_start(self._line_cell, True) self._line_column.add_attribute(self._line_cell, 'text', 0) # Create comment column self._comment_column = gtk.TreeViewColumn(_('Source / Comment')) self._tree.append_column(self._comment_column) self._comment_cell = gtk.CellRendererText() self._comment_column.pack_start(self._comment_cell, True) self._comment_column.add_attribute(self._comment_cell, 'text', 1) self._comment_column.set_cell_data_func(self._comment_cell, self._render_comment_callback) # Addtitional settings self._tree.set_enable_tree_lines(True) self._tree.set_search_column(1) self._tree.set_rules_hint(True) self._tree.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH) # Create bottom pane self._pane = gtk.ScrolledWindow() # Add tree to bottom pane self._pane.add(self._tree) self._tree.show() # Setup row selection event self._tree.connect("row-activated", self._on_row_activated) self._tree.connect("cursor-changed", self._on_row_selected) self._tree.connect("focus-in-event", self._on_tree_focused) # Create popup menu for tree self._popup_menu = gtk.Menu() self._pop_toggle = gtk.MenuItem(_("Toggle bookmark")) self._pop_toggle.connect("activate", self._on_toggle_bookmark) self._pop_toggle.show() self._popup_menu.append(self._pop_toggle) self._pop_edit = gtk.MenuItem(_("Edit bookmark")) self._pop_edit.set_sensitive(False) self._pop_edit.connect("activate", self._on_edit_clicked) self._pop_edit.show() self._popup_menu.append(self._pop_edit) self._popup_menu.attach_to_widget(self._tree, None) self._tree.connect("button-release-event", self._on_tree_clicked) # Create button boxes self._btn_hbox = gtk.HBox(False, 5) self._btn_vbox = gtk.VBox(False, 0) # Create buttons self._btn_toggle = gtk.Button(_("Toggle")) self._btn_toggle.set_focus_on_click(False) self._btn_toggle.connect("clicked", self._on_toggle_bookmark) self._btn_vbox.pack_start(self._btn_toggle, False, False, 5) self._btn_edit = gtk.Button(_("Edit")) self._btn_edit.set_sensitive(False) self._btn_edit.set_focus_on_click(False) self._btn_edit.connect("clicked", self._on_edit_clicked) self._btn_vbox.pack_start(self._btn_edit, False, False, 0) # Pack vbox into hbox self._btn_hbox.pack_start(self._btn_vbox, False, False, 5) self._btn_vbox.show_all() # Create layout table table = gtk.Table(2, 1) table.attach(self._pane, 0, 1, 0, 1) table.attach(self._btn_hbox, 1, 2, 0, 1, 0) table.show_all() # Install layout table into bottom pane pane = window.get_bottom_panel() pane.add_item(table, _('Bookmarks'), self._icon) # Setup handlers for all documents for doc in window.get_documents(): doc.connect("loaded", self._on_doc_loaded) # Setup tab handlers window.connect("tab-added", self._on_tab_added) window.connect("tab-removed", self._on_tab_removed) window.connect("active-tab-changed", self._on_tab_changed)
def treeview_button_press(self, widget, event): model, iter = self.treeview.get_selection().get_selected() if (iter == None): return exp = model.get_value(iter, 0) name = model.get_value(iter, 1) desc = model.get_value(iter, 2) if ("CVE" in exp): hostname = model.get_value(model.iter_parent(model.iter_parent(iter)), 0) elif (exp in ["Remote", "Clientside", "Local"]): hostname = model.get_value(model.iter_parent(iter), 0) else: hostname = exp m = re.search("[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+", hostname) if not m == None: hostname = m.group() # Expand / collapse handler if (event.button == 1): if (event.type == gtk.gdk._2BUTTON_PRESS): if ("CVE" in exp): # Check exploit type Remote / Client Side / Local CANVAS / Local D2 exploittype = model.get_value(model.iter_parent(iter), 0) if (exploittype == "Remote"): # Get hostname and add host to "Knowledge" self.argsDict["host"] = hostname app = canvasengine.getModuleExploit("addhost") app.link(self) app.run() self.log("[D2 LOG] Host %s added" % hostname) # Set hostname as target host node = self.argsDict["passednodes"][0] target = node.get_known_host(hostname) target.set_as_target() self.log("[D2 LOG] Host %s set as target" % hostname) # Start CANVAS exploit self.gui.gui_queue_append("launch_exploit", [name]) self.log("[D2 LOG] Exploit %s started" % name) elif (exploittype == "Clientside"): self.log("[D2 LOG] Exploit %s can be started from D2 Client Insider" % name) elif (exploittype == "Local"): for item in self.ReportList: if (item.HostName == hostname): for i, vuln in enumerate(item.CVEAList): if (vuln == exp): if (item.ExploitAType[i] == "CANVAS"): self.log("[D2 LOG] Local Exploit %s can be started from CANVAS" % name) elif (item.ExploitAType[i] == "D2"): path = os.getcwd() + "/3rdparty/D2SEC/d2sec_modules/" + item.ExploitAList[i][2] + "/" + item.ExploitAList[i][0] + "/" self.log("[D2 LOG] Local Exploit %s can be started from: %s" % (name, path)) break break # Right click elif (event.button == 3): if not (exp in ["Remote", "Clientside", "Local"])and not ("CVE" in exp): menulines = ["Delete"] menu = gtk.Menu() for l in menulines: mline = gtk.MenuItem(l) mline.connect("activate", self.menu_response, l) mline.show() menu.append(mline) menu.show() menu.popup(None, None, None, event.button, event.time) return
def do_init(self, *args): self.menu = gtk.Menu() self.init(*args)
def right_click_menu(self, event, task_id, type='live task'): name, point_string = TaskID.split(task_id) menu = gtk.Menu() menu_root = gtk.MenuItem(task_id) menu_root.set_submenu(menu) timezoom_item_direct = gtk.MenuItem('Focus on ' + point_string) timezoom_item_direct.connect('activate', self.focused_timezoom_direct, point_string) # TODO - pre cylc-6 could focus on a range of points (was hours-based). # timezoom_item = gtk.MenuItem('Focus on Range') # timezoom_item.connect( # 'activate', self.focused_timezoom_popup, task_id) timezoom_reset_item = gtk.MenuItem('Focus Reset') timezoom_reset_item.connect('activate', self.focused_timezoom_direct, None) group_item = gtk.ImageMenuItem('Group') img = gtk.image_new_from_stock('group', gtk.ICON_SIZE_MENU) group_item.set_image(img) group_item.set_sensitive(not self.t.have_leaves_and_feet or name not in self.t.feet) group_item.connect('activate', self.grouping, name, True) ungroup_item = gtk.ImageMenuItem('UnGroup') img = gtk.image_new_from_stock('ungroup', gtk.ICON_SIZE_MENU) ungroup_item.set_image(img) ungroup_item.set_sensitive(not self.t.have_leaves_and_feet or name not in self.t.leaves) ungroup_item.connect('activate', self.grouping, name, False) ungroup_rec_item = gtk.ImageMenuItem('Recursive UnGroup') img = gtk.image_new_from_stock('ungroup', gtk.ICON_SIZE_MENU) ungroup_rec_item.set_image(img) ungroup_rec_item.set_sensitive(not self.t.have_leaves_and_feet or name not in self.t.leaves) ungroup_rec_item.connect('activate', self.grouping, name, False, True) menu.append(gtk.SeparatorMenuItem()) if type is not 'live task': insert_item = gtk.ImageMenuItem('Insert ...') img = gtk.image_new_from_stock(gtk.STOCK_DIALOG_INFO, gtk.ICON_SIZE_MENU) insert_item.set_image(img) menu.append(insert_item) insert_item.connect( 'button-press-event', lambda *a: self.insert_task_popup( is_fam=(name in self.t.descendants), name=name, point_string=point_string)) menu.append(gtk.SeparatorMenuItem()) menu.append(timezoom_item_direct) menu.append(timezoom_reset_item) menu.append(gtk.SeparatorMenuItem()) menu.append(group_item) menu.append(ungroup_item) menu.append(ungroup_rec_item) if type == 'live task': is_fam = (name in self.t.descendants) if is_fam: t_state = self.t.fam_state_summary[task_id]['state'] submit_num = None else: t_state = self.t.state_summary[task_id]['state'] submit_num = self.t.state_summary[task_id]['submit_num'] default_menu = self.get_right_click_menu(task_id, t_state, task_is_family=is_fam, submit_num=submit_num) dm_kids = default_menu.get_children() for item in reversed(dm_kids[:2]): # Put task name and URL at the top. default_menu.remove(item) menu.prepend(item) for item in dm_kids[2:]: # And the rest of the default menu at the bottom. default_menu.remove(item) menu.append(item) menu.show_all() menu.popup(None, None, None, event.button, event.time) # TODO - popup menus are not automatically destroyed and can be # reused if saved; however, we need to reconstruct or at least # alter ours dynamically => should destroy after each use to # prevent a memory leak? But I'm not sure how to do this as yet.) return True
def add_encoding_items(self, menu): """Add the encoding list to the menu""" terminal = self.terminal active_encodings = terminal.config['active_encodings'] item = gtk.MenuItem(_("Encodings")) menu.append(item) submenu = gtk.Menu() item.set_submenu(submenu) encodings = TerminatorEncoding().get_list() encodings.sort(lambda x, y: cmp(x[2].lower(), y[2].lower())) current_encoding = terminal.vte.get_encoding() group = None if current_encoding not in active_encodings: active_encodings.insert(0, _(current_encoding)) for encoding in active_encodings: if encoding == terminal.default_encoding: extratext = " (%s)" % _("Default") elif encoding == current_encoding and \ terminal.custom_encoding == True: extratext = " (%s)" % _("User defined") else: extratext = "" radioitem = gtk.RadioMenuItem(group, _(encoding) + extratext) if encoding == current_encoding: radioitem.set_active(True) if group is None: group = radioitem radioitem.connect('activate', terminal.on_encoding_change, encoding) submenu.append(radioitem) item = gtk.MenuItem(_("Other Encodings")) submenu.append(item) #second level submenu = gtk.Menu() item.set_submenu(submenu) group = None for encoding in encodings: if encoding[1] in active_encodings: continue if encoding[1] is None: label = "%s %s" % (encoding[2], terminal.vte.get_encoding()) else: label = "%s %s" % (encoding[2], encoding[1]) radioitem = gtk.RadioMenuItem(group, label) if group is None: group = radioitem if encoding[1] == current_encoding: radioitem.set_active(True) radioitem.connect('activate', terminal.on_encoding_change, encoding[1]) submenu.append(radioitem)
def __init__(self, manager): gtk.MenuBar.__init__(self) self.show() self.manager = manager fileitem = gtk.MenuItem('File') self.append(fileitem) fileitem.show() filemenu = gtk.Menu() fileitem.set_submenu(filemenu) filemenu.show() openitem = gtk.MenuItem('Open...') filemenu.append(openitem) openitem.connect('activate', self.on_file_open) openitem.show() i = self.file_prev = gtk.MenuItem('Load previous') i.set_sensitive(False) filemenu.append(i) i.connect('activate', self.on_file_prev) i.show() i = self.file_next = gtk.MenuItem('Load next') i.set_sensitive(False) filemenu.append(i) i.connect('activate', self.on_file_next) i.show() i = gtk.SeparatorMenuItem() i.show() filemenu.append(i) i = self.file_save = gtk.MenuItem('Save') i.set_sensitive(True) i.show() i.connect('activate', self.on_file_save) filemenu.append(i) i = gtk.SeparatorMenuItem() i.show() filemenu.append(i) i = self.file_save = gtk.MenuItem('Settings') i.set_sensitive(False) i.show() i.connect('activate', self.on_file_settings) filemenu.append(i) canvasitem = gtk.MenuItem('Canvas') self.append(canvasitem) canvasitem.show() canvasmenu = gtk.Menu() canvasitem.set_submenu(canvasmenu) canvasmenu.show() irfitem = gtk.CheckMenuItem('IRF') irfitem.set_active(True) irfitem.show() irfitem.connect('toggled', self.on_irf_toggle) canvasmenu.append(irfitem)
def update_list(self): mb = gtk.MenuBar() filemenu = gtk.Menu() filem = gtk.MenuItem("File") filem.set_submenu(filemenu) mb.append(filem) #ADD GESTURE add = gtk.MenuItem("Add Gesture") add.connect("activate", self.add_new) filemenu.append(add) #ANALYZER self.analyze_all = True analyzer_menu = gtk.MenuItem("Analyzer") analyzer_menu.connect("activate", self.start_analyze) filemenu.append(analyzer_menu) close = gtk.MenuItem("Close") close.connect("activate", lambda x: self.destroy()) filemenu.append(close) #HELP helpmenu = gtk.Menu() helpm = gtk.MenuItem("Help") helpm.set_submenu(helpmenu) mb.append(helpm) #RESET reset = gtk.MenuItem("Reset Jarvis") reset.connect( "activate", lambda x: self.prompt( "Click OK to reset Jarvis. Note that this process is Irreversible!", self.reset_jarvis)) helpmenu.append(reset) self.sv = gtk.ScrolledWindow() self.vbox = gtk.VBox(False, 2) self.vbox.pack_start(mb, False, False, 0) boolean = False for gest in gesture.get_all_gestures(): frame = gtk.Frame() ev = gtk.EventBox() vbox2 = gtk.VBox(False, 2) vbox2.set_size_request(0, 100) gest_name = gtk.Label("Gesture Name: " + str(gest[0])) comment = gtk.Label("Comment: " + str(gest[1])) command = gtk.Label("Command: " + str(gest[2])) sequence = gtk.Label("Sequence: " + str(gest[3])) hbox = gtk.HBox(False, 2) edit = gtk.Button("Edit " + str(gest[0])) delete = gtk.Button("Delete " + str(gest[0])) #edit.connect("clicked",lambda x:edit_gesture_dialog.Edit(str(gest[0]),str(gest[1]),str(gest[2]),str(gest[3]))) edit.connect("clicked", self.edit) delete.connect("clicked", self.delete_prompt) hbox.add(edit) hbox.add(delete) vbox2.add(gest_name) vbox2.add(comment) vbox2.add(command) vbox2.add(sequence) vbox2.add(hbox) ev.add(vbox2) frame.add(ev) if boolean: ev.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color("#ccc")) boolean = not boolean self.vbox.add(frame) self.sv.add_with_viewport(self.vbox) self.add(self.sv) self.show_all()
def launch_browser(uri, quit_function=None, echo=True): window = gtk.Window() browser = implementation.create_browser() box = gtk.VBox(homogeneous=False, spacing=0) window.add(box) if quit_function is not None: # Obligatory "File: Quit" menu # { file_menu = gtk.Menu() quit_item = gtk.MenuItem('Quit') accel_group = gtk.AccelGroup() quit_item.add_accelerator('activate', accel_group, ord('Q'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) window.add_accel_group(accel_group) file_menu.append(quit_item) quit_item.connect('activate', quit_function) quit_item.show() # menu_bar = gtk.MenuBar() menu_bar.show() file_item = gtk.MenuItem('File') file_item.show() file_item.set_submenu(file_menu) menu_bar.append(file_item) # } box.pack_start(menu_bar, expand=False, fill=True, padding=0) if quit_function is not None: window.connect('destroy', quit_function) box.pack_start(browser, expand=True, fill=True, padding=0) #window.set_default_size() window.show_all() message_queue = Queue.Queue() def title_changed(title): if title != 'null': message_queue.put(title) implementation.connect_title_changed(browser, title_changed) implementation.open_uri(browser, uri) def web_recv(): if message_queue.empty(): return None else: msg = message_queue.get() if echo: print '>>>', msg return msg def web_send(msg): if echo: print '<<<', msg asynchronous_gtk_message(implementation.inject_javascript)(browser, msg) return browser, web_recv, web_send
def run(): # Internationalisation gettext.bindtextdomain('redshift', defs.LOCALEDIR) gettext.textdomain('redshift') _ = gettext.gettext # Start redshift with arguments from the command line args = sys.argv[1:] args.insert(0, os.path.join(defs.BINDIR, 'redshift')) process = subprocess.Popen(args) try: if appindicator: # Create indicator indicator = appindicator.Indicator( 'redshift', 'redshift-status-on', appindicator.CATEGORY_APPLICATION_STATUS) indicator.set_status(appindicator.STATUS_ACTIVE) else: # Create status icon status_icon = gtk.StatusIcon() status_icon.set_from_icon_name('redshift-status-on') status_icon.set_tooltip('Redshift') def is_enabled(): if appindicator: return indicator.get_icon() == 'redshift-status-on' else: return status_icon.get_icon_name() == 'redshift-status-on' def remove_suspend_timer(): global SUSPEND_TIMER if SUSPEND_TIMER is not None: glib.source_remove(SUSPEND_TIMER) SUSPEND_TIMER = None def toggle_cb(widget, data=None): # If the user toggles redshift, we forget about the suspend timer. # Only then widget is not None. if widget: remove_suspend_timer() process.send_signal(signal.SIGUSR1) if appindicator: if indicator.get_icon() == 'redshift-status-on': indicator.set_icon('redshift-status-off') else: indicator.set_icon('redshift-status-on') else: if status_icon.get_icon_name() == 'redshift-status-on': status_icon.set_from_icon_name('redshift-status-off') else: status_icon.set_from_icon_name('redshift-status-on') def enable_cb(): if is_enabled(): return # Enable redshift toggle_cb(None) def suspend_cb(widget, minutes): if is_enabled(): # Disable redshift toggle_cb(None) # If "suspend" is clicked while redshift is disabled, we reenable # it after the last selected timespan is over. remove_suspend_timer() # If redshift was already disabled we reenable it nonetheless. global SUSPEND_TIMER SUSPEND_TIMER = glib.timeout_add_seconds(minutes * 60, enable_cb) def autostart_cb(widget, data=None): utils.set_autostart(widget.get_active()) def destroy_cb(widget, data=None): if not appindicator: status_icon.set_visible(False) gtk.main_quit() return False # Create popup menu status_menu = gtk.Menu() toggle_item = gtk.MenuItem(_('Toggle')) toggle_item.connect('activate', toggle_cb) status_menu.append(toggle_item) suspend_menu_item = gtk.MenuItem(_('Suspend for')) suspend_menu = gtk.Menu() for minutes, label in [(30, _('30 minutes')), (60, _('1 hour')), (120, _('2 hours'))]: suspend_item = gtk.MenuItem(label) suspend_item.connect('activate', suspend_cb, minutes) suspend_menu.append(suspend_item) suspend_menu_item.set_submenu(suspend_menu) status_menu.append(suspend_menu_item) autostart_item = gtk.CheckMenuItem(_('Autostart')) try: autostart_item.set_active(utils.get_autostart()) except IOError as strerror: print strerror autostart_item.set_property('sensitive', False) else: autostart_item.connect('activate', autostart_cb) finally: status_menu.append(autostart_item) quit_item = gtk.ImageMenuItem(gtk.STOCK_QUIT) quit_item.connect('activate', destroy_cb) status_menu.append(quit_item) if appindicator: status_menu.show_all() # Set the menu indicator.set_menu(status_menu) else: def popup_menu_cb(widget, button, time, data=None): status_menu.show_all() status_menu.popup(None, None, gtk.status_icon_position_menu, button, time, status_icon) # Connect signals for status icon and show status_icon.connect('activate', toggle_cb) status_icon.connect('popup-menu', popup_menu_cb) status_icon.set_visible(True) def child_cb(pid, cond, data=None): sys.exit(-1) # Add watch on child process glib.child_watch_add(process.pid, child_cb) # Run main loop gtk.main() except KeyboardInterrupt: # Ignore user interruption pass finally: # Always terminate redshift process.terminate() process.wait()
if __name__ == "__main__": def menuitem_response(w, buf): if ind.get_status() == appindicator.STATUS_ATTENTION: ind.set_status(appindicator.STATUS_ACTIVE) else: ind.set_status(appindicator.STATUS_ATTENTION) ind = appindicator.Indicator("example-simple-client", "indicator-messages", appindicator.CATEGORY_APPLICATION_STATUS) ind.set_status(appindicator.STATUS_ACTIVE) ind.set_attention_icon("indicator-messages-new") # create a menu menu = gtk.Menu() # create some for i in range(3): buf = "Test-undermenu - %d" % i menu_items = gtk.MenuItem(buf) menu.append(menu_items) # this is where you would connect your menu item up with a function: menu_items.connect("activate", menuitem_response, buf) # show the items menu_items.show()
def build_gui(self): self.window = gtk.Window() gtk.window_set_default_icon_from_file( utils.get_ui_object('image/ic128_hotot.png')) self.window.set_icon_from_file( utils.get_ui_object('image/ic128_hotot.png')) self.window.set_title(_("Hotot")) self.window.set_position(gtk.WIN_POS_CENTER) vbox = gtk.VBox() scrollw = gtk.ScrolledWindow() self.webv = view.MainView() agent.view = self.webv scrollw.add(self.webv) vbox.pack_start(scrollw) vbox.show_all() self.window.add(vbox) self.menu_tray = gtk.Menu() mitem_resume = gtk.MenuItem(_("_Resume/Hide")) mitem_resume.connect('activate', self.on_trayicon_activate); self.menu_tray.append(mitem_resume) mitem_compose = gtk.MenuItem(_("_Compose")) mitem_compose.connect('activate', self.on_mitem_compose); self.menu_tray.append(mitem_compose) mitem_prefs = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES) mitem_prefs.connect('activate', self.on_mitem_prefs_activate); self.menu_tray.append(mitem_prefs) mitem_about = gtk.ImageMenuItem(gtk.STOCK_ABOUT) mitem_about.connect('activate', self.on_mitem_about_activate); self.menu_tray.append(mitem_about) mitem_quit = gtk.ImageMenuItem(gtk.STOCK_QUIT) mitem_quit.connect('activate', self.on_mitem_quit_activate); self.menu_tray.append(mitem_quit) self.menu_tray.show_all() ## support for ubuntu unity indicator-appmenu menubar = gtk.MenuBar() menuitem_file = gtk.MenuItem(_("_File")) menuitem_file_menu = gtk.Menu() mitem_resume = gtk.MenuItem(_("_Resume/Hide")) mitem_resume.connect('activate', self.on_mitem_resume_activate) menuitem_file_menu.append(mitem_resume) mitem_compose = gtk.MenuItem(_("_Compose")) mitem_compose.connect('activate', self.on_mitem_compose) menuitem_file_menu.append(mitem_compose) mitem_prefs = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES) mitem_prefs.connect('activate', self.on_mitem_prefs_activate) menuitem_file_menu.append(mitem_prefs) menuitem_quit = gtk.ImageMenuItem(gtk.STOCK_QUIT) menuitem_quit.connect("activate", self.quit) menuitem_file_menu.append(menuitem_quit) menuitem_file.set_submenu(menuitem_file_menu) menubar.append(menuitem_file) menuitem_help = gtk.MenuItem(_("_Help")) menuitem_help_menu = gtk.Menu() menuitem_about = gtk.ImageMenuItem(gtk.STOCK_ABOUT) menuitem_about.connect("activate", self.on_mitem_about_activate) menuitem_help_menu.append(menuitem_about) menuitem_help.set_submenu(menuitem_help_menu) menubar.append(menuitem_help) menubar.set_size_request(0, 0) menubar.show_all() vbox.pack_start(menubar, expand=0, fill=0, padding=0) ## self.window.set_geometry_hints(min_height=380, min_width=460) self.window.show() self.window.connect('delete-event', self.on_window_delete)
def walk_tree(prefix, parent_menu): for name in tree_structure[prefix]: path = os.path.join(prefix, name) item = self.pending_items_hash[path] needs_refresh = item["visible_fn"] or \ item["sensitive_fn"] is_leaf = not tree_structure.has_key(path) item_name = item["name"] or "" ### Flag items that aren't hooked up to callbacks. if is_leaf and not item["callback"]: item_name = item_name + " (inactive)" if item["is_separator"]: menu_item = gtk.SeparatorMenuItem() elif item["stock"]: #menu_item = gtk.ImageMenuItem(item["stock"], # self.accel_group) menu_item = gtk.ImageMenuItem(item["stock"]) elif item["image"]: menu_item = gtk.ImageMenuItem(item["name"]) menu_item.set_image(item["image"]) elif item["radiogroup"] and item["radiotag"]: grp = radiogroups.get(item["radiogroup"]) grp_widget = None if grp: grp_widget, grp_item = grp item["radio_get"] = grp_item["radio_get"] item["radio_set"] = grp_item["radio_set"] menu_item = gtk.RadioMenuItem(grp_widget, item["name"]) if not grp: #assert item["radio_get"] and item["radio_set"] radiogroups[item["radiogroup"]] = (menu_item, item) def radio_activate(mi, get_fn, set_fn, tag): if get_fn() != tag: set_fn(tag) menu_item.connect_after("activate", radio_activate, item["radio_get"], item["radio_set"], item["radiotag"]) needs_refresh = 1 elif item["checked_get"] and item["checked_set"]: menu_item = gtk.CheckMenuItem(item["name"]) menu_item.set_active(item["checked_get"]()) needs_refresh = 1 def check_activate(mi, get_fn, set_fn): state = mi.get_active() x = (get_fn() and 1) or 0 if x ^ state: set_fn(state) menu_item.connect_after("activate", check_activate, item["checked_get"], item["checked_set"]) else: if item["with_dropdown_arrow"]: menu_item = gtk.MenuItem() hbox = gtk.HBox(0, 0) hbox.pack_start(gtk.Label(item_name), 0, 0, 0) hbox.pack_start(gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_OUT), 0, 0, 0) menu_item.add(hbox) else: menu_item = gtk.MenuItem(item_name) if self.statusbar and item["description"]: def select_cb(mi, sb, i): sb.push(hash(mi), i["description"]) def deselect_cb(mi, sb): sb.pop(hash(mi)) menu_item.connect("select", select_cb, self.statusbar, item) menu_item.connect("deselect", deselect_cb, self.statusbar) parent_menu.append(menu_item) menu_item.show_all() ### If this item is a leaf in our tree, ### hook up it's callback if is_leaf and item["callback"]: menu_item.connect_after( "activate", lambda x, i:i["callback"](self.user_data), item) if item["accelerator"]: self.accel_parser.parse(item["accelerator"]) key = self.accel_parser.key() if key: mods = self.accel_parser.mods() menu_item.add_accelerator("activate", self.accel_group, key, mods, gtk.ACCEL_VISIBLE) ### ### If this item has special visibility, sensitivity or checked ### functions, hook them up to listen for our refresh_items ### signals. ### def refresh_items(widget, item): visible_fn = item["visible_fn"] if (not visible_fn) or visible_fn(): widget.show() else: widget.hide() def eval_fn_or_tuple(fn): if not fn: return 1 elif callable(fn): return (fn() and 1) or 0 elif type(fn) == types.TupleType \ or type(fn) == types.ListType: assert(len(fn) > 0) assert(callable(fn[0])) return (apply(fn[0], fn[1:]) and 1) or 0 print "Couldn't eval", fn return 0 is_sensitive = eval_fn_or_tuple(item["sensitive_fn"]) widget.set_sensitive(is_sensitive) if item["checked_get"]: is_checked = eval_fn_or_tuple(item["checked_get"]) widget.set_active(is_checked) radiogroup = item["radiogroup"] radiotag = item["radiotag"] radio_get = item["radio_get"] radio_set = item["radio_set"] if radiogroup and radiotag and radio_get and radio_set: active_tag = radio_get() widget.set_active(radiotag == active_tag) if needs_refresh: self.connect("refresh_items", lambda menu, x, y: refresh_items(x, y), menu_item, item) ### ### If this item has subitems, construct the submenu ### and continue walking down the tree. ### if not is_leaf: # Refresh the menu bar every time a top-level # menu item is opened. if prefix == "/": menu_item.connect("activate", lambda x:self.refresh_items()) submenu = gtk.Menu() menu_item.set_submenu(submenu) submenu.show() walk_tree(path, submenu)
def append( self, widget ): # creating a method to append widgets to an instance of the frame. The append method takes widget as input and widget_type = type( widget ) # executes the code corresponding to that widget in the following if conditions if (isinstance(widget, button) ): # if widget type is button this if condition creates a button widget.ctr = gtk.Button(widget.label) widget.ctr.set_size_request(widget.size[0], widget.size[1]) self.fixed.put(widget.ctr, widget.pos[0], widget.pos[1]) widget.ctr.show() if (widget.callbackMethod != None): widget.ctr.connect('clicked', widget.callbackMethod) elif ( isinstance(widget, text_area) ): # if widget type is text_area this if condition creates a text_area widget.ctr = gtk.TextView(widget.buffer) widget.ctr.set_size_request(widget.size[0], widget.size[1]) self.fixed.put(widget.ctr, widget.pos[0], widget.pos[1]) widget.ctr.show() if (widget.callbackMethod != None): widget.ctr.connect('clicked', widget.callbackMethod) elif ( isinstance(widget, text_field) ): # if widget type is text_field this elseif condition creates a text_field widget.ctr = gtk.Entry() widget.ctr.set_size_request(widget.size[0], widget.size[1]) widget.ctr.set_visibility(widget.visibility) self.fixed.put(widget.ctr, widget.pos[0], widget.pos[1]) widget.ctr.set_text(widget.label) widget.ctr.show() elif ( isinstance(widget, check_box) ): # if widget type is check_box this elseif condition creates a check_box widget.ctr = gtk.CheckButton(widget.label) widget.ctr.set_size_request(widget.size[0], widget.size[1]) self.fixed.put(widget.ctr, widget.pos[0], widget.pos[1]) widget.ctr.show() widget.ctr.set_active(widget.value) elif ( isinstance(widget, radio_buttons) ): # if widget type is radio_buttons this elseif condition creates a radiobuttons widget.ctr = [] radio_ctr = gtk.RadioButton(None, widget.labels[0]) radio_ctr.set_size_request(widget.size[0], widget.size[1]) self.fixed.put(radio_ctr, widget.position_X[0], widget.position_Y[0]) radio_ctr.show() widget.ctr.append(radio_ctr) for i in range(1, len(widget.labels)): radio_ctr = gtk.RadioButton(widget.ctr[0], widget.labels[i]) radio_ctr.set_size_request(widget.size[0], widget.size[1]) self.fixed.put(radio_ctr, widget.position_X[i], widget.position_Y[i]) radio_ctr.show() widget.ctr.append(radio_ctr) if (widget.selected_pos != None): widget.ctr[widget.selected_pos].set_active(True) elif ( isinstance(widget, combo_box) ): # if widget type is combo_box this elseif condition creates a combo_box widget.ctr = gtk.OptionMenu() widget.ctr.set_size_request(widget.size[0], widget.size[1]) menu = gtk.Menu() widget.labels.insert(0, widget.default) for name in widget.labels: item = gtk.MenuItem(name) item.show() menu.append(item) widget.ctr.set_menu(menu) widget.ctr.show() self.fixed.put(widget.ctr, widget.pos[0], widget.pos[1]) elif (widget_type == "Slider" or isinstance(widget, Slider)): adj1 = gtk.Adjustment(0.0, widget.start, widget.end, 0.1, 1.0, 1.0) widget.instance = gtk.HScale(adj1) widget.instance.set_size_request(widget.width, widget.height) self.fixed.put(widget.instance, widget.position_X, widget.position_Y) widget.instance.show() elif (widget_type == "SpinBox" or isinstance(widget, SpinBox)): adj = gtk.Adjustment(0.0, widget.start, widget.end, 0.1, 0.1, 0.0) widget.instance = gtk.SpinButton(adj, 0.1, 1) widget.instance.set_size_request(widget.width, widget.height) self.fixed.put(widget.instance, widget.position_X, widget.position_Y) widget.instance.show() elif ( isinstance(widget, static_text) ): # if widget type is static_text this elseif condition creates a static_text widget.ctr = gtk.Label(widget.label) widget.ctr.set_size_request(widget.size[0], widget.size[1]) self.fixed.put(widget.ctr, widget.pos[0], widget.pos[1]) widget.ctr.show()
def __init__(self, host='localhost', port=1234, op='request'): gtk.VPaned.__init__(self) self.show() # Connect to liquidsoap self.op = op self.tel = LiqClient(host, port) self.list = View( [ ['rid', 40], ['status', '70'], ['artist', '120'], ['title', '120'], # Right-align URI because the end is more informative # than the beginning ['initial_uri', '300', { 'xalign': 1.0 }] ], []) self.update() # Popup menu for requests menu = gtk.Menu() item = gtk.ImageMenuItem(gtk.STOCK_REMOVE) def remove_request(item): model, path = self.list.get_selection().get_selected() self.tel.command(self.op + '.remove ' + str(model.get_value(path, 0))) item.connect('activate', remove_request) item.show() menu.append(item) def popup(w, event): if event.button == 3: menu.popup(None, None, None, event.button, event.time) self.list.connect('button_press_event', popup) # Receive drag-n-drops self.list.enable_model_drag_dest([('text/uri-list', 0, 0), ridformat], gtk.gdk.ACTION_DEFAULT) def dnd_receive(w, context, x, y, data, info, time): if data and (data.format != 8 and data.format != ridformat[2]): print "DnD received: Unknown data format! (%d)" % data.format return row = w.get_dest_row_at_pos(x, y) if row: # This is an insertion path, pos = row # Remove the number of resolv(ed|ing) requests to get the pos # in the pending queue pos = path[0] - (len(w.get_model()) - self.plen) if pos < 0: print "Cannot move outside pending queue!" return if pos >= self.plen - 1: pos = -1 if data and data.format == ridformat[2]: rid = int(data.data) self.tel.command('%s.move %d %d' % (self.op, rid, pos)) if data and data.format == 8: for e in data.data.split('\r\n')[:-1]: self.tel.command(self.op + '.insert ' + str(pos) + ' ' + e) else: # This is a push if data and data.format == ridformat[2]: rid = int(data.data) self.tel.command('%s.move %d %d' % (self.op, rid, -1)) if data and data.format == 8: for e in data.data.split('\r\n')[:-1]: self.tel.command(self.op + ".push " + urllib.unquote(e)) context.finish(True, False, time) self.list.connect("drag_data_received", dnd_receive) # Emit drag-n-drops self.list.enable_model_drag_source(gtk.gdk.BUTTON1_MASK, [ridformat], gtk.DEST_DEFAULT_ALL) def dnd_emit(w, context, sel, info, time): # Check that format is RID if info == ridformat[2]: model, iter = w.get_selection().get_selected() if iter: sel.set(sel.target, info, str(model.get_value(iter, 0))) self.list.connect("drag_data_get", dnd_emit) # Put the list in a scroll scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scroll.add(self.list) scroll.show() self.list.show() # Pack this to self, with a doc label box = gtk.VBox() lbl = gtk.Label() lbl.set_markup("\ <b>Enqueue</b> files by drag-n-dropping from your file manager or \ using the file chooser below.\n\ <b>Re-order</b> the queue by drag-n-dropping.\n\ <b>Remove</b> scheduled requests by right-clicking.") box.pack_start(scroll, fill=True, expand=True) box.pack_start(lbl, fill=True, expand=False) self.pack1(box, resize=True) lbl.show() box.show() # A file selector in the other side of the pane fsel = gtk.FileChooserWidget() fsel.connect("file_activated", lambda s: self.selected(s)) exp = gtk.Expander("File chooser") exp.add(fsel) self.pack2(exp, resize=False) fsel.show() exp.show() # And the update callback gobject.timeout_add(1000, self.update)
def __init__(self): # Standard window-creating stuff self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.connect("destroy", lambda w: gtk.main_quit()) self.window.set_title("range controls") box1 = gtk.VBox(False, 0) self.window.add(box1) box1.show() box2 = gtk.HBox(False, 10) box2.set_border_width(10) box1.pack_start(box2, True, True, 0) box2.show() # value, lower, upper, step_increment, page_increment, page_size # Note that the page_size value only makes a difference for # scrollbar widgets, and the highest value you'll get is actually # (upper - page_size). adj1 = gtk.Adjustment(0.0, 0.0, 101.0, 0.1, 1.0, 1.0) self.vscale = gtk.VScale(adj1) scale_set_default_values(self.vscale) box2.pack_start(self.vscale, True, True, 0) self.vscale.show() box3 = gtk.VBox(False, 10) box2.pack_start(box3, True, True, 0) box3.show() # Reuse the same adjustment self.hscale = gtk.HScale(adj1) self.hscale.set_size_request(200, 30) scale_set_default_values(self.hscale) box3.pack_start(self.hscale, True, True, 0) self.hscale.show() # Reuse the same adjustment again scrollbar = gtk.HScrollbar(adj1) # Notice how this causes the scales to always be updated # continuously when the scrollbar is moved scrollbar.set_update_policy(gtk.UPDATE_CONTINUOUS) box3.pack_start(scrollbar, True, True, 0) scrollbar.show() box2 = gtk.HBox(False, 10) box2.set_border_width(10) box1.pack_start(box2, True, True, 0) box2.show() # A checkbutton to control whether the value is displayed or not button = gtk.CheckButton("Display value on scale widgets") button.set_active(True) button.connect("toggled", self.cb_draw_value) box2.pack_start(button, True, True, 0) button.show() box2 = gtk.HBox(False, 10) box2.set_border_width(10) # An option menu to change the position of the value label = gtk.Label("Scale Value Position:") box2.pack_start(label, False, False, 0) label.show() opt = gtk.OptionMenu() menu = gtk.Menu() item = make_menu_item("Top", self.cb_pos_menu_select, gtk.POS_TOP) menu.append(item) item = make_menu_item("Bottom", self.cb_pos_menu_select, gtk.POS_BOTTOM) menu.append(item) item = make_menu_item("Left", self.cb_pos_menu_select, gtk.POS_LEFT) menu.append(item) item = make_menu_item("Right", self.cb_pos_menu_select, gtk.POS_RIGHT) menu.append(item) opt.set_menu(menu) box2.pack_start(opt, True, True, 0) opt.show() box1.pack_start(box2, True, True, 0) box2.show() box2 = gtk.HBox(False, 10) box2.set_border_width(10) # Yet another option menu, this time for the update policy of the # scale widgets label = gtk.Label("Scale Update Policy:") box2.pack_start(label, False, False, 0) label.show() opt = gtk.OptionMenu() menu = gtk.Menu() item = make_menu_item("Continuous", self.cb_update_menu_select, gtk.UPDATE_CONTINUOUS) menu.append(item) item = make_menu_item("Discontinuous", self.cb_update_menu_select, gtk.UPDATE_DISCONTINUOUS) menu.append(item) item = make_menu_item("Delayed", self.cb_update_menu_select, gtk.UPDATE_DELAYED) menu.append(item) opt.set_menu(menu) box2.pack_start(opt, True, True, 0) opt.show() box1.pack_start(box2, True, True, 0) box2.show() box2 = gtk.HBox(False, 10) box2.set_border_width(10) # An HScale widget for adjusting the number of digits on the # sample scales. label = gtk.Label("Scale Digits:") box2.pack_start(label, False, False, 0) label.show() adj2 = gtk.Adjustment(1.0, 0.0, 5.0, 1.0, 1.0, 0.0) adj2.connect("value_changed", self.cb_digits_scale) scale = gtk.HScale(adj2) scale.set_digits(0) box2.pack_start(scale, True, True, 0) scale.show() box1.pack_start(box2, True, True, 0) box2.show() box2 = gtk.HBox(False, 10) box2.set_border_width(10) # And, one last HScale widget for adjusting the page size of the # scrollbar. label = gtk.Label("Scrollbar Page Size:") box2.pack_start(label, False, False, 0) label.show() adj2 = gtk.Adjustment(1.0, 1.0, 101.0, 1.0, 1.0, 0.0) adj2.connect("value_changed", self.cb_page_size, adj1) scale = gtk.HScale(adj2) scale.set_digits(0) box2.pack_start(scale, True, True, 0) scale.show() box1.pack_start(box2, True, True, 0) box2.show() separator = gtk.HSeparator() box1.pack_start(separator, False, True, 0) separator.show() box2 = gtk.VBox(False, 10) box2.set_border_width(10) box1.pack_start(box2, False, True, 0) box2.show() button = gtk.Button("Quit") button.connect("clicked", lambda w: gtk.main_quit()) box2.pack_start(button, True, True, 0) button.set_flags(gtk.CAN_DEFAULT) button.grab_default() button.show() self.window.show()
def __init__(self): self._label = None self._items = [] self._menu = gtk.Menu()
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 create_toolbar(self, toolbars): gtktoolbar = super(Form, self).create_toolbar(toolbars) attach_btn = self.buttons['attach'] target_entry = gtk.TargetEntry.new('text/uri-list', 0, 0) attach_btn.drag_dest_set(gtk.DEST_DEFAULT_ALL, [ target_entry, ], gtk.gdk.ACTION_MOVE | gtk.gdk.ACTION_COPY) attach_btn.connect('drag_data_received', self.attach_drag_data_received) iconstock = { 'print': 'tryton-print', 'action': 'tryton-executable', 'relate': 'tryton-go-jump', 'email': 'tryton-print-email', 'open': 'tryton-print-open', } for action_type, special_action, action_name, tooltip in ( ('action', 'action', _('Action'), _('Launch action')), ('relate', 'relate', _('Relate'), _('Open related records')), (None,) * 4, ('print', 'open', _('Report'), _('Open report')), ('print', 'email', _('E-Mail'), _('E-Mail report')), ('print', 'print', _('Print'), _('Print report')), ): if action_type is not None: tbutton = gtk.ToggleToolButton(iconstock.get(special_action)) tbutton.set_label(action_name) tbutton._menu = self._create_popup_menu(tbutton, action_type, toolbars[action_type], special_action) tbutton.connect('toggled', self.action_popup) self.tooltips.set_tip(tbutton, tooltip) self.buttons[special_action] = tbutton if action_type != 'action': tbutton._can_be_sensitive = bool( tbutton._menu.get_children()) else: tbutton = gtk.SeparatorToolItem() gtktoolbar.insert(tbutton, -1) gtktoolbar.insert(gtk.SeparatorToolItem(), -1) url_button = gtk.ToggleToolButton('tryton-web-browser') url_button.set_label(_('_Copy URL')) url_button.set_use_underline(True) self.tooltips.set_tip( url_button, _('Copy URL into clipboard')) url_button._menu = url_menu = gtk.Menu() url_menuitem = gtk.MenuItem() url_menuitem.connect('activate', self.url_copy) url_menu.add(url_menuitem) url_menu.show_all() url_menu.connect('deactivate', self._popup_menu_hide, url_button) url_button.connect('toggled', self.url_set, url_menuitem) url_button.connect('toggled', self.action_popup) self.buttons['copy_url'] = url_button gtktoolbar.insert(url_button, -1) quick_actions = toolbars.get('quick_actions', []) if quick_actions: gtktoolbar.insert(gtk.SeparatorToolItem(), -1) for quick_action in quick_actions: icon = quick_action.get('icon.rec_name') if not icon: icon = 'tryton-executable' qbutton = gtk.ToolButton(icon) qbutton.set_label(quick_action['name']) qbutton.connect('clicked', lambda b: self._action(quick_action, 'quick_actions')) self.tooltips.set_tip(qbutton, _(quick_action['name'])) gtktoolbar.insert(qbutton, -1) return gtktoolbar
def __init__(self, frame, name, title): WorkspacePage.ButtonWorkspacePage.__init__(self, frame, name, title) self.pagelist = [] self.pagelimit = 100 self.db = {} # TODO: this dict is growing indefinitely self.track = {} # Don't allow DND to this workspace self.nb.set_group_id(2) self.nb.set_tab_pos(gtk.POS_RIGHT) ## menu = self.add_pulldownmenu("Page") ## item = gtk.MenuItem(label="Close") ## # currently disabled ## item.set_sensitive(False) ## menu.append(item) ## item.connect_object ("activate", lambda w: self.close(), ## "menu.Close") ## item.show() # Options menu ## menu = self.add_pulldownmenu("Option") menu = gtk.Menu() item = gtk.MenuItem(label="Option") self.wsmenu.append(item) item.show() item.set_submenu(menu) # Option variables self.save_decode_result = False self.show_times = False self.track_elapsed = False self.track_subcommands = True w = gtk.CheckMenuItem("Track Subcommands") w.set_active(self.track_subcommands) menu.append(w) w.show() w.connect("activate", lambda w: self.toggle_var(w, 'track_subcommands')) w = gtk.CheckMenuItem("Save Decode Result") w.set_active(self.save_decode_result) menu.append(w) w.show() w.connect("activate", lambda w: self.toggle_var(w, 'save_decode_result')) w = gtk.CheckMenuItem("Show Times") w.set_active(self.show_times) menu.append(w) w.show() w.connect("activate", lambda w: self.toggle_var(w, 'show_times')) w = gtk.CheckMenuItem("Track Elapsed") w.set_active(self.track_elapsed) menu.append(w) w.show() w.connect("activate", lambda w: self.toggle_var(w, 'track_elapsed'))
def attach_submenu(self, menu_node, submenu_list): submenu = gtk.Menu() menu_node.set_submenu(submenu) [submenu.append(item) for item in submenu_list]
def __init__(self): ## Prep the Main Window for stuff window = gtk.Window(gtk.WINDOW_TOPLEVEL) window.set_title("ccUVCPTZ") window.connect("delete_event", self.hide, window) window.connect("window-state-event", self.window_event, window) ## Create a StatusIcon for the app statusIcon = gtk.StatusIcon() ## Let's build the menu for the StatusIcon self.sMenu = gtk.Menu() menuItem = gtk.ImageMenuItem(gtk.STOCK_OPEN) menuItem.connect('activate', self.activate_window, window) self.sMenu.append(menuItem) menuItem = gtk.ImageMenuItem(gtk.STOCK_QUIT) menuItem.connect('activate', self.exit, statusIcon) self.sMenu.append(menuItem) ## Don't forget to include the icon actions itself statusIcon.set_from_stock(gtk.STOCK_HOME) statusIcon.set_tooltip("StatusIcon test") statusIcon.connect('activate', self.activate_window, window) statusIcon.connect('popup-menu', self.popup_menu, self.sMenu) statusIcon.set_visible(True) ## Let's use a table to make a nice pretty grid for our buttons self.table = gtk.Table(5, 3, True) window.add(self.table) ## Time to build the buttons # Tilt Up Button self.tiltupBtn = gtk.Button(stock=gtk.STOCK_GO_UP) self.tiltupBtn.connect("clicked", self.ptUp) self.table.attach(self.tiltupBtn, 1, 2, 0, 1) # Pan Left Button self.panleftBtn = gtk.Button(stock=gtk.STOCK_GO_BACK) self.panleftBtn.connect("clicked", self.ptLeft) self.table.attach(self.panleftBtn, 0, 1, 1, 2) # Pan/tilt Reset Button self.resetBtn = gtk.Button(stock=gtk.STOCK_UNDO) self.resetBtn.connect("clicked", self.ptReset) self.table.attach(self.resetBtn, 1, 2, 1, 2) # Pan Right Button self.panrightBtn = gtk.Button(stock=gtk.STOCK_GO_FORWARD) self.panrightBtn.connect("clicked", self.ptRight) self.table.attach(self.panrightBtn, 2, 3, 1, 2) # Tilt Down Button self.tiltdownBtn = gtk.Button(stock=gtk.STOCK_GO_DOWN) self.tiltdownBtn.connect("clicked", self.ptDown) self.table.attach(self.tiltdownBtn, 1, 2, 2, 3) # Quit Button self.quitBtn = gtk.Button(stock=gtk.STOCK_QUIT) self.quitBtn.connect("clicked", self.exit) self.table.attach(self.quitBtn, 1, 2, 4, 5) # Now display the table we built self.table.show() # Show the entire window window.show_all()
def __init__(self, project): self.project = project # Gconf settings # self._settings = gconf.client_get_default() # self._settings.add_dir(self.BASE_KEY, gconf.CLIENT_PRELOAD_NONE) # Key to enable/disable icon glow self._use_icon_glow = conf.get("icon_glow") self._show_label = conf.get("show_label") self._label_length = conf.get("label_length") self._last_activities_days = conf.get("last_activities_days") conf.connect('conf-changed', self.on_conf_changed) self._activity_as_attribute = None # Create a fake applet since HamsterApplet requires one # applet = FakeApplet() self.indicator = appindicator.Indicator( "hamster-applet", "hamster-applet-inactive", appindicator.CATEGORY_SYSTEM_SERVICES) self.indicator.set_status(appindicator.STATUS_ACTIVE) # Set the attention icon as per the icon_glow gconf key self._set_attention_icon() # Initialise the activity label with "No Activity" self.indicator.set_label(self._get_no_activity_label()) self.activity, self.duration = None, None self.menu = gtk.Menu() self.activity_item = gtk.MenuItem("") self.menu.append(self.activity_item) # this is where you would connect your menu item up with a function: self.activity_item.connect("activate", self.on_activate) self.activity_label = self.activity_item.get_child() self.activity_label.connect('style-set', self.on_label_style_set) # show the items self.activity_item.show() self.stop_activity_item = gtk.MenuItem(_(u"Sto_p tracking")) self.menu.append(self.stop_activity_item) # this is where you would connect your menu item up with a function: self.stop_activity_item.connect("activate", self.on_stop_activity_activated, None) # show the items self.stop_activity_item.show() self.last_activities_item = gtk.MenuItem(_(u"_Last activities")) self.menu.append(self.last_activities_item) # show the items self.last_activities_item.show() self.append_separator(self.menu) self.earlier_activity_item = gtk.MenuItem(_(u"Add earlier activity")) self.menu.append(self.earlier_activity_item) # this is where you would connect your menu item up with a function: self.earlier_activity_item.connect("activate", self.on_earlier_activity_activated, None) # show the items self.earlier_activity_item.show() self.overview_show_item = gtk.MenuItem(_(u"Show Overview")) self.menu.append(self.overview_show_item) # this is where you would connect your menu item up with a function: self.overview_show_item.connect("activate", self.on_overview_show_activated, None) # show the items self.overview_show_item.show() self.append_separator(self.menu) self.preferences_show_item = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES) self.menu.append(self.preferences_show_item) # this is where you would connect your menu item up with a function: self.preferences_show_item.connect("activate", self.on_show_preferences_activated, None) # show the items self.preferences_show_item.show() self.append_separator(self.menu) self.quit_item = gtk.ImageMenuItem(gtk.STOCK_QUIT) self.menu.append(self.quit_item) # this is where you would connect your menu item up with a function: self.quit_item.connect("activate", gtk.main_quit, None) # show the items self.quit_item.show() self.project.last_activity = None runtime.storage.connect('activities-changed', self.after_activity_update) runtime.storage.connect('facts-changed', self.after_fact_update) runtime.storage.connect('toggle-called', self.on_toggle_called) gobject.timeout_add_seconds( 20, self.refresh_tray ) # refresh hamster every 20 seconds to update duration
def clear_menu(self): menu = self.menu self.menu = gtk.Menu() self.row = 0 self.col = 0 menu.destroy()
def show_popup(self, status_icon, button, activate_time): """ Create the popupmenu """ ## From the PyGTK 2.10 documentation # status_icon : the object which received the signal # button : the button that was pressed, or 0 if the signal is not emitted in response to a button press event # activate_time : the timestamp of the event that triggered the signal emission if self.specto.specto_gconf.get_entry("always_show_icon") == True and self.specto.notifier.get_state() == True: text = _("Hide window") else: text = _("Show window") # Create menu items self.item_show = gtk.MenuItem( text, True) self.item_pref = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES) self.item_help = gtk.ImageMenuItem(gtk.STOCK_HELP) self.item_about = gtk.ImageMenuItem(gtk.STOCK_ABOUT) self.item_quit = gtk.ImageMenuItem(gtk.STOCK_QUIT) self.item_clear = gtk.ImageMenuItem(gtk.STOCK_CLEAR) #create submenu for updated watches self.sub_menu = gtk.Menu() self.sub_item_clear = gtk.MenuItem(_("_Clear All"), True) self.sub_item_clear.connect('activate', self.specto.notifier.clear_all) self.sub_menu.append(self.sub_item_clear) self.sub_menu.append(gtk.SeparatorMenuItem()) for i in self.specto.watch_db: if self.specto.watch_db[i].updated == True: self.sub_item_clear = gtk.MenuItem(self.specto.watch_db[i].name, True) self.sub_item_clear.connect('activate', self.specto.notifier.clear_watch, self.specto.watch_db[i].id) self.sub_menu.append( self.sub_item_clear) self.sub_menu.show_all() self.item_clear.set_submenu(self.sub_menu) # Connect the events self.item_show.connect( 'activate', self.show_notifier) self.item_pref.connect( 'activate', self.show_preferences) self.item_help.connect( 'activate', self.show_help) self.item_about.connect( 'activate', self.show_about) self.item_quit.connect( 'activate', self.quit) # Create the menu self.menu = gtk.Menu() # Append menu items to the menu self.menu.append( self.item_show) self.menu.append( gtk.SeparatorMenuItem()) self.menu.append( self.item_clear) self.menu.append( gtk.SeparatorMenuItem()) self.menu.append( self.item_pref) self.menu.append( self.item_help) self.menu.append( self.item_about) self.menu.append( gtk.SeparatorMenuItem()) self.menu.append( self.item_quit) self.menu.show_all() self.menu.popup(None, None, gtk.status_icon_position_menu, button, activate_time, self.tray)#the last argument is to tell gtk.status_icon_position_menu where to grab the coordinates to position the popup menu correctly
def show(self, widget, event=None): """Display the context menu""" terminal = self.terminal menu = gtk.Menu() url = None button = None time = None self.config.set_profile(terminal.get_profile()) if event: url = terminal.check_for_url(event) button = event.button time = event.time else: time = 0 button = 3 if url: dbg("URL matches id: %d" % url[1]) if not url[1] in terminal.matches.values(): err("Unknown URL match id: %d" % url[1]) dbg("Available matches: %s" % terminal.matches) nameopen = None namecopy = None if url[1] == terminal.matches['email']: nameopen = _('_Send email to...') namecopy = _('_Copy email address') elif url[1] == terminal.matches['voip']: nameopen = _('Ca_ll VoIP address') namecopy = _('_Copy VoIP address') elif url[1] in terminal.matches.values(): # This is a plugin match for pluginname in terminal.matches: if terminal.matches[pluginname] == url[1]: break dbg("Found match ID (%d) in terminal.matches plugin %s" % (url[1], pluginname)) registry = plugin.PluginRegistry() registry.load_plugins() plugins = registry.get_plugins_by_capability('url_handler') for urlplugin in plugins: if urlplugin.handler_name == pluginname: dbg("Identified matching plugin: %s" % urlplugin.handler_name) nameopen = _(urlplugin.nameopen) namecopy = _(urlplugin.namecopy) break if not nameopen: nameopen = _('_Open link') if not namecopy: namecopy = _('_Copy address') icon = gtk.image_new_from_stock(gtk.STOCK_JUMP_TO, gtk.ICON_SIZE_MENU) item = gtk.ImageMenuItem(nameopen) item.set_property('image', icon) item.connect('activate', lambda x: terminal.open_url(url, True)) menu.append(item) item = gtk.MenuItem(namecopy) item.connect( 'activate', lambda x: terminal.clipboard.set_text( terminal.prepare_url(url))) menu.append(item) menu.append(gtk.MenuItem()) item = gtk.ImageMenuItem(gtk.STOCK_COPY) item.connect('activate', lambda x: terminal.vte.copy_clipboard()) item.set_sensitive(terminal.vte.get_has_selection()) menu.append(item) item = gtk.ImageMenuItem(gtk.STOCK_PASTE) item.connect('activate', lambda x: terminal.paste_clipboard()) menu.append(item) menu.append(gtk.MenuItem()) if not terminal.is_zoomed(): item = gtk.ImageMenuItem(_('Split H_orizontally')) image = gtk.Image() image.set_from_icon_name(APP_NAME + '_horiz', gtk.ICON_SIZE_MENU) item.set_image(image) if hasattr(item, 'set_always_show_image'): item.set_always_show_image(True) item.connect( 'activate', lambda x: terminal.emit( 'split-horiz', self.terminator.pid_cwd(self.terminal.pid))) menu.append(item) item = gtk.ImageMenuItem(_('Split V_ertically')) image = gtk.Image() image.set_from_icon_name(APP_NAME + '_vert', gtk.ICON_SIZE_MENU) item.set_image(image) if hasattr(item, 'set_always_show_image'): item.set_always_show_image(True) item.connect( 'activate', lambda x: terminal.emit( 'split-vert', self.terminator.pid_cwd(self.terminal.pid))) menu.append(item) item = gtk.MenuItem(_('Open _Tab')) item.connect('activate', lambda x: terminal.emit('tab-new', False, terminal)) menu.append(item) if self.terminator.debug_address is not None: item = gtk.MenuItem(_('Open _Debug Tab')) item.connect( 'activate', lambda x: terminal.emit('tab-new', True, terminal)) menu.append(item) menu.append(gtk.MenuItem()) item = gtk.ImageMenuItem(gtk.STOCK_CLOSE) item.connect('activate', lambda x: terminal.close()) menu.append(item) menu.append(gtk.MenuItem()) if not terminal.is_zoomed(): item = gtk.MenuItem(_('_Zoom terminal')) item.connect('activate', terminal.zoom) menu.append(item) item = gtk.MenuItem(_('Ma_ximise terminal')) item.connect('activate', terminal.maximise) menu.append(item) menu.append(gtk.MenuItem()) else: item = gtk.MenuItem(_('_Restore all terminals')) item.connect('activate', terminal.unzoom) menu.append(item) menu.append(gtk.MenuItem()) if self.config['show_titlebar'] == False: item = gtk.MenuItem(_('Grouping')) submenu = self.terminal.populate_group_menu() submenu.show_all() item.set_submenu(submenu) menu.append(item) menu.append(gtk.MenuItem()) item = gtk.CheckMenuItem(_('Show _scrollbar')) item.set_active(terminal.scrollbar.get_property('visible')) item.connect('toggled', lambda x: terminal.do_scrollbar_toggle()) menu.append(item) if hasattr(gtk, 'Builder'): item = gtk.MenuItem(_('_Preferences')) item.connect('activate', lambda x: PrefsEditor(self.terminal)) menu.append(item) profilelist = self.config.list_profiles() if len(profilelist) > 1: item = gtk.MenuItem(_('Profiles')) submenu = gtk.Menu() item.set_submenu(submenu) menu.append(item) current = terminal.get_profile() group = None for profile in profilelist: item = gtk.RadioMenuItem(group, profile.capitalize()) if profile == current: item.set_active(True) item.connect('activate', terminal.force_set_profile, profile) submenu.append(item) self.add_encoding_items(menu) try: menuitems = [] registry = plugin.PluginRegistry() registry.load_plugins() plugins = registry.get_plugins_by_capability('terminal_menu') for menuplugin in plugins: menuplugin.callback(menuitems, menu, terminal) if len(menuitems) > 0: menu.append(gtk.MenuItem()) for menuitem in menuitems: menu.append(menuitem) except Exception, ex: err('TerminalPopupMenu::show: %s' % ex)
def _construct_menu(self): ''' Construct menu by walking dirs. ''' #drop boards and programmers menus for child in self.boards_menu.get_children(): for sub_child in child.get_children(): child.remove(sub_child) sub_child.destroy() self.boards_menu.remove(child) child.destroy() for child in self.programmers_menu.get_children(): self.boards_menu.remove(child) child.destroy() #get olders prefs cur_board = self.get_pref('board') cur_programmer = self.get_pref('programmer') cur_fname_boards = None boards = [] programmers = [] #boards and programmers in aurduino dirs for arduino_dirs in self.arduino_dirs: if os.path.isdir(os.path.join(arduino_dirs, 'hardware')): for package in os.listdir( os.path.join(arduino_dirs, 'hardware')): if os.path.isdir( os.path.join(arduino_dirs, 'hardware', package)): for arch in os.listdir( os.path.join(arduino_dirs, 'hardware', package)): fname_platform = os.path.join( arduino_dirs, 'hardware', package, arch, 'platform.txt') if os.path.isfile(fname_platform): with open(fname_platform, 'r') as f: packageName = re.findall( '^name=(.*)$', f.read(), re.M)[0] fname_boards = os.path.join( arduino_dirs, 'hardware', package, arch, 'boards.txt') if os.path.isfile(fname_boards): with open(fname_boards, 'r') as f_boards: for (board, boardName) in re.findall( '^(.*)\.name=(.*)$', f_boards.read(), re.M): boards.append((packageName, boardName, (fname_boards, package, arch, board))) fname_programmers = os.path.join( arduino_dirs, 'hardware', package, arch, 'programmers.txt') if os.path.isfile(fname_programmers): with open(fname_programmers, 'r') as f_programmers: for (programmer, programmerName) in re.findall( '^(.*)\.name=(.*)$', f_programmers.read(), re.M): programmers.append( (programmerName, (fname_programmers, package, arch, programmer))) #boards and programmers in packages dir for packages_dir in self.packages_dirs: if os.path.isdir(packages_dir): for package in os.listdir(packages_dir): if os.path.isdir( os.path.join(packages_dir, package, 'hardware')): for arch in os.listdir( os.path.join(packages_dir, package, 'hardware')): for version in os.listdir( os.path.join(packages_dir, package, 'hardware', arch)): fname_platform = os.path.join( packages_dir, package, 'hardware', arch, version, 'platform.txt') if os.path.isfile(fname_platform): with open(fname_platform, 'r') as f: packageName = re.findall( '^name=(.*)$', f.read(), re.M)[0] fname_boards = os.path.join( packages_dir, package, 'hardware', arch, version, 'boards.txt') if os.path.isfile(fname_boards): with open(fname_boards, 'r') as f_boards: for (board, boardName) in re.findall( '^(.*)\.name=(.*)$', f_boards.read(), re.M): boards.append( (packageName, boardName, (fname_boards, package, arch, board))) fname_programmers = os.path.join( packages_dir, package, 'hardware', arch, version, 'programmers.txt') if os.path.isfile(fname_programmers): with open(fname_programmers, 'r') as f_programmers: for (programmer, programmerName) in re.findall( '^(.*)\.name=(.*)$', f_programmers.read(), re.M): programmers.append( (programmerName, (fname_programmers, package, arch, programmer))) #sort boards.sort() programmers.sort() #construct boards menu groupBoard = '' board_menu_item = None package_menu_item = None for (packageName, boardName, data) in boards: if groupBoard != packageName: groupBoard = packageName package_menu = gtk.Menu() package_menu_item = gtk.RadioMenuItem(package_menu_item, packageName) package_menu_item.set_submenu(package_menu) self.boards_menu.append(package_menu_item) package_menu_item.show() board_menu_item = gtk.RadioMenuItem(board_menu_item, boardName) if cur_board == data[3]: #radiobutton on current board_menu_item.set_active(True) package_menu_item.set_active(True) (cur_fname_boards, package, arch, board) = data package_menu.append(board_menu_item) board_menu_item.show() board_menu_item.connect("activate", self.on_board_menu_item_clicked, data) #construct programmers menu programmer_menu_item = None for (programmerName, data) in programmers: (fname_programmers, package, arch, programmer) = data programmer_menu_item = gtk.RadioMenuItem(programmer_menu_item, programmerName) if cur_programmer == "%s:%s" % ( package, programmer): #radiobutton on current programmer_menu_item.set_active(True) self.programmers_menu.append(programmer_menu_item) programmer_menu_item.show() programmer_menu_item.connect("activate", self.on_programmer_menu_item_clicked, programmer) return (cur_board, cur_fname_boards)
def _get_menu_bar(self): ''' Instead of Sugar toolbars, use GNOME menus. ''' menu = gtk.Menu() make_menu_item(menu, _('New'), self._do_new_cb) make_menu_item(menu, _('Show sample projects'), self._create_store) make_menu_item(menu, _('Open'), self._do_open_cb) make_menu_item(menu, _('Add project'), self._do_load_cb) make_menu_item(menu, _('Load plugin'), self._do_load_plugin_cb) make_menu_item(menu, _('Save'), self._do_save_cb) make_menu_item(menu, _('Save as'), self._do_save_as_cb) # export submenu export_submenu = gtk.Menu() export_menu = make_sub_menu(export_submenu, _('Export as')) menu.append(export_menu) make_menu_item(export_submenu, _('image'), self._do_save_picture_cb) make_menu_item(export_submenu, _('image (blocks)'), self._do_save_blocks_image_cb) make_menu_item(export_submenu, _('SVG'), self._do_save_svg_cb) make_menu_item(export_submenu, _('icon'), self._do_save_as_icon_cb) # TRANS: ODP is Open Office presentation make_menu_item(export_submenu, _('ODP'), self._do_save_as_odp_cb) make_menu_item(export_submenu, _('Logo'), self._do_save_logo_cb) make_menu_item(export_submenu, _('Python'), self._do_save_python_cb) make_menu_item(menu, _('Quit'), self._quit_ta) activity_menu = make_sub_menu(menu, _('File')) menu = gtk.Menu() make_menu_item(menu, _('Cartesian coordinates'), self._do_cartesian_cb) make_menu_item(menu, _('Polar coordinates'), self._do_polar_cb) self.coords = make_checkmenu_item(menu, _('Rescale coordinates'), self._do_rescale_cb, status=False) make_menu_item(menu, _('Grow blocks'), self._do_resize_cb, 1.5) make_menu_item(menu, _('Shrink blocks'), self._do_resize_cb, 0.667) make_menu_item(menu, _('Reset block size'), self._do_resize_cb, -1) self.hover = make_checkmenu_item(menu, _('Turn on hover help'), self._do_toggle_hover_help_cb, status=True) view_menu = make_sub_menu(menu, _('View')) menu = gtk.Menu() make_menu_item(menu, _('Copy'), self._do_copy_cb) make_menu_item(menu, _('Paste'), self._do_paste_cb) make_menu_item(menu, _('Save stack'), self._do_save_macro_cb) make_menu_item(menu, _('Delete stack'), self._do_delete_macro_cb) edit_menu = make_sub_menu(menu, _('Edit')) menu = gtk.Menu() make_menu_item(menu, _('Show palette'), self._do_palette_cb) make_menu_item(menu, _('Hide palette'), self._do_hide_palette_cb) make_menu_item(menu, _('Show/hide blocks'), self._do_hideshow_cb) tool_menu = make_sub_menu(menu, _('Tools')) menu = gtk.Menu() make_menu_item(menu, _('Clean'), self._do_eraser_cb) make_menu_item(menu, _('Run'), self._do_run_cb) make_menu_item(menu, _('Step'), self._do_step_cb) make_menu_item(menu, _('Debug'), self._do_trace_cb) make_menu_item(menu, _('Stop'), self._do_stop_cb) turtle_menu = make_sub_menu(menu, _('Turtle')) self._plugin_menu = gtk.Menu() plugin_men = make_sub_menu(self._plugin_menu, _('Plugins')) menu = gtk.Menu() make_menu_item(menu, _('About...'), self._do_about_cb) help_menu = make_sub_menu(menu, _('Help')) menu_bar = gtk.MenuBar() menu_bar.append(activity_menu) menu_bar.append(edit_menu) menu_bar.append(view_menu) menu_bar.append(tool_menu) menu_bar.append(turtle_menu) menu_bar.append(plugin_men) # Add menus for plugins for p in self._gnome_plugins: menu_item = p.get_menu() if menu_item is not None: menu_bar.append(menu_item) menu_bar.append(help_menu) return menu_bar
def __init__(self): geany.Plugin.__init__(self) #usually arduino dirs if sys.platform.startswith('linux') or sys.platform.startswith( 'cygwin'): self.arduino_dirs = [ '/usr/local/share/arduino', '/usr/share/arduino', os.path.join(os.environ['HOME'], 'Arduino'), os.path.join(os.environ['HOME'], '.arduino'), os.path.join(os.environ['HOME'], '.arduino15'), ] self.packages_dirs = [ os.path.join(os.environ['HOME'], '.arduino', 'packages'), os.path.join(os.environ['HOME'], '.arduino15', 'packages') ] elif sys.platform.startswith('win'): self.arduino_dirs = [] #TODO ticket#1 self.packages_dirs = [] #TODO ticket#1 elif sys.platform.startswith('darwin'): self.arduino_dirs = [] #TODO ticket#2 self.packages_dirs = [] #TODO ticket#2 else: #unknom OS self.arduino_dirs = [] self.packages_dirs = [] #arduino in config file if not os.path.isfile(self.conf_path): with open(self.conf_path, 'wb') as configfile: configfile.write( "[arduino]\n#libraries and boards paths search\ndirs =\n#package paths search\npackages_dirs =\n" ) config = ConfigParser() config.read(self.conf_path) #~ if not config.has_section('arduino') : #~ config.add_section('arduino') #~ config.set('arduino','dirs','#tata') #~ config.set('arduino','packages_dirs','') #~ with open(self.conf_path, 'wb') as configfile: #~ config.write(configfile) self.arduino_dirs.extend((config.get('arduino', 'dirs') or '').split(',')) self.packages_dirs.extend((config.get('arduino', 'packages_dirs') or '').split(',')) #arduino dirs by ENV (replace usually dirs) if os.environ.has_key('GEANY_ARDUINO_DIRS'): self.arduino_dirs.extend( os.environ['GEANY_ARDUINO_DIRS'].split(',')) if os.environ.has_key('GEANY_ARDUINO_PACKAGES_DIRS'): self.packages_dirs.extend( os.environ['GEANY_ARDUINO_PACKAGES_DIRS'].split(',')) self.file_prefs = None #arduino preferences filename self.store_customs_prefs = None self.signal_id_document_save = None #main menu self.arduino_menu = gtk.Menu() self.arduino_menu_item = gtk.MenuItem("Arduino") self.arduino_menu_item.set_submenu(self.arduino_menu) self.arduino_menu_item.connect("activate", self.on_arduino_menu_item_clicked) geany.main_widgets.tools_menu.append(self.arduino_menu_item) #board menu self.boards_menu = gtk.Menu() boards_menu_item = gtk.MenuItem("Boards") boards_menu_item.set_submenu(self.boards_menu) self.arduino_menu.append(boards_menu_item) boards_menu_item.show() #cutoms prefs menu self.customs_prefs_menu_item = gtk.MenuItem("Bord preferences ...") self.customs_prefs_menu_item.connect( "activate", self.on_customs_prefs_menu_item_clicked) self.arduino_menu.append(self.customs_prefs_menu_item) self.customs_prefs_menu_item.show() #separator separator = gtk.SeparatorMenuItem() self.arduino_menu.append(separator) separator.show() #port menu self.ports_menu = gtk.Menu() ports_menu_item = gtk.MenuItem("Port") ports_menu_item.set_submenu(self.ports_menu) ports_menu_item.connect("activate", self.on_ports_menu_item_clicked) self.arduino_menu.append(ports_menu_item) ports_menu_item.show() #separator separator = gtk.SeparatorMenuItem() self.arduino_menu.append(separator) separator.show() #programmer menu self.programmers_menu = gtk.Menu() programmers_menu_item = gtk.MenuItem("Programmers") programmers_menu_item.set_submenu(self.programmers_menu) self.arduino_menu.append(programmers_menu_item) programmers_menu_item.show() #separator separator = gtk.SeparatorMenuItem() self.arduino_menu.append(separator) separator.show() #libraries menu libraries_menu_item = gtk.MenuItem("Include libraries ...") libraries_menu_item.connect("activate", self.on_libraries_item_clicked) self.arduino_menu.append(libraries_menu_item) libraries_menu_item.show() #separator separator = gtk.SeparatorMenuItem() self.arduino_menu.append(separator) separator.show() #open preferences.txt open_prefs_txt_menu_item = gtk.MenuItem("Open preference.txt") open_prefs_txt_menu_item.connect( "activate", self.on_open_prefs_txt_menu_item_clicked) self.arduino_menu.append(open_prefs_txt_menu_item) open_prefs_txt_menu_item.show() #events geany.signals.connect('document-activate', self.on_document_activate)
def __assemble(self): self.item_id_list = [] menu = gtk.Menu() channels = rcd_util.get_all_channels() channels.sort( lambda x, y: cmp(string.lower(x["name"]), string.lower(y["name"]))) if self.__allow_any_channel: channels.insert(0, { "name": _("All Catalogs"), "id": MATCH_ANY_CHANNEL }) if self.__allow_any_subd_channel: channels.insert( 0, { "name": _("All Subscribed Catalogs"), "id": MATCH_ANY_SUBD_CHANNEL, "subscribed": 1 }) if self.__allow_no_channel: channels.append({ "name": _("No Catalog/Unknown Catalog"), "id": MATCH_NO_CHANNEL }) width, height = gtk.icon_size_lookup(gtk.ICON_SIZE_MENU) for c in channels: hbox = gtk.HBox(0, 0) if not is_channel_wildcard(c["id"]): pixbuf = rcd_util.get_channel_icon(c["id"], 24, 24) else: pixbuf = None img = gtk.Image() img.set_size_request(24, 24) if pixbuf: img.set_from_pixbuf(pixbuf) label = gtk.Label(c["name"]) hbox.pack_start(img, 0, 0, 0) hbox.pack_start(label, 0, 0, 4) if c.get("subscribed"): sub_img = red_pixbuf.get_widget("status-installed", width=width, height=height) hbox.pack_end(sub_img, expand=0, fill=0, padding=2) item = gtk.MenuItem() item.add(hbox) item.show_all() self.item_id_list.append(c["id"]) def activate_cb(item, id, opt): if id != self.__last_id: opt.__last_id = id opt.emit("selected", id) item.connect("activate", activate_cb, c["id"], self) menu.append(item) menu.show() self.set_menu(menu)
def generate_right_click_menu_state(self): menu = gtk.Menu() accel_group = self.accel_group shortcuts_dict = global_gui_config.get_config_value('SHORTCUTS') self.insert_is_start_state_in_menu(menu, shortcuts_dict, accel_group) self.insert_execution_sub_menu_in_menu(menu, shortcuts_dict, accel_group) menu.append(gtk.SeparatorMenuItem()) add_sub_menu_item, add_sub_menu = append_sub_menu_to_parent_menu("Add", menu, constants.BUTTON_ADD) add_state_sub_menu_item, add_state_sub_menu = append_sub_menu_to_parent_menu("State", add_sub_menu, constants.BUTTON_ADD) add_state_sub_menu.append(create_image_menu_item("Execution State", constants.BUTTON_ADD, self.on_add_execution_state_activate, accel_code=shortcuts_dict['add_execution_state'][0], accel_group=accel_group)) add_state_sub_menu.append(create_image_menu_item("Hierarchy State", constants.BUTTON_ADD, self.on_add_hierarchy_state_activate, accel_code=shortcuts_dict['add_hierarchy_state'][0], accel_group=accel_group)) add_state_sub_menu.append(create_image_menu_item("Preemptive State", constants.BUTTON_ADD, self.on_add_preemptive_state_activate, accel_code=shortcuts_dict['add_preemptive_state'][0], accel_group=accel_group)) add_state_sub_menu.append(create_image_menu_item("Barrier State", constants.BUTTON_ADD, self.on_add_barrier_state_activate, accel_code=shortcuts_dict['add_barrier_state'][0], accel_group=accel_group)) add_sub_menu.append(gtk.SeparatorMenuItem()) add_sub_menu.append(create_image_menu_item("Outcome", constants.BUTTON_ADD, self.on_add_outcome, accel_code=shortcuts_dict['add_outcome'][0], accel_group=accel_group)) add_sub_menu.append(create_image_menu_item("Output Port", constants.BUTTON_ADD, self.on_add_output, accel_code=shortcuts_dict['add_output'][0], accel_group=accel_group)) add_sub_menu.append(create_image_menu_item("Input Port", constants.BUTTON_ADD, self.on_add_input, accel_code=shortcuts_dict['add_input'][0], accel_group=accel_group)) add_sub_menu.append(create_image_menu_item("Scoped Variable", constants.BUTTON_ADD, self.on_add_scoped_variable, accel_code=shortcuts_dict['add_scoped_variable'][0], accel_group=accel_group)) menu.append(gtk.SeparatorMenuItem()) self.insert_copy_cut_paste_in_menu(menu, shortcuts_dict, accel_group) from rafcon.core.states.barrier_concurrency_state import DeciderState selection = gui_singletons.state_machine_manager_model.get_selected_state_machine_model().selection selected_state_m = selection.get_selected_state() all_m_list = gui_singletons.state_machine_manager_model.get_selected_state_machine_model().selection.get_all() if all([isinstance(elem, (AbstractStateModel, ScopedVariableModel)) for elem in all_m_list]) and \ not any([state_m.state.is_root_state for state_m in selection.states]): menu.append(create_image_menu_item("Group states", constants.BUTTON_GROUP, self.on_group_states_activate, accel_code=shortcuts_dict['group'][0], accel_group=accel_group)) if len(selection.states) == 1: if isinstance(selected_state_m, ContainerStateModel) and not selected_state_m.state.is_root_state: menu.append(create_image_menu_item("Ungroup states", constants.BUTTON_UNGR, self.on_ungroup_state_activate, accel_code=shortcuts_dict['ungroup'][0], accel_group=accel_group)) if not isinstance(selected_state_m.state, DeciderState) and not selected_state_m.state.is_root_state: menu.append(create_image_menu_item("Substitute state", constants.BUTTON_REFR, self.on_substitute_state_activate, accel_code=shortcuts_dict['substitute_state'][0], accel_group=accel_group)) from rafcon.gui.controllers.state_editor.overview import StateOverviewController state_type_class_dict = StateOverviewController.change_state_type_class_dict(selected_state_m.state) if len(state_type_class_dict) > 1: change_type_sub_menu_item, change_type_sub_menu = append_sub_menu_to_parent_menu("Change state type", menu, constants.BUTTON_EXCHANGE) for class_key, item in state_type_class_dict.iteritems(): class_item = create_image_menu_item(class_key, constants.SIGN_LIB, partial(self.on_type_change_activate, target_class=item['class']), accel_code=None, accel_group=accel_group) if isinstance(selected_state_m.state, item['class']): class_item.set_sensitive(False) change_type_sub_menu.append(class_item) menu.append(gtk.SeparatorMenuItem()) # save state as but not for root state, therefore the user should use save state machine as if len(selection.states) == 1 and not selected_state_m.state.is_root_state: save_as_sub_menu_item, save_as_sub_menu = append_sub_menu_to_parent_menu("Save state as", menu, constants.BUTTON_SAVE) save_as_sub_menu.append(create_image_menu_item("State machine", constants.BUTTON_SAVE, self.on_save_state_as_state_machine_activate, accel_code=shortcuts_dict['save_state_as'][0], accel_group=accel_group)) save_as_library_sub_menu_item, save_as_library_sub_menu = append_sub_menu_to_parent_menu("Library", save_as_sub_menu, constants.SIGN_LIB) library_root_paths = core_singletons.library_manager.library_root_paths for library_root_key in library_root_paths.iterkeys(): save_as_library_sub_menu.append(create_image_menu_item(library_root_key, constants.SIGN_LIB, partial(self.on_save_state_as_state_machine_activate, path=library_root_paths[library_root_key]), accel_code=None, accel_group=accel_group)) return menu