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