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
