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