def set_loading(self, loading):
self._loading = loading
if self._loading:
self._show_stop_icon()
self._stop_and_reload.set_tooltip(gtk.Tooltips(), _('Stop'))
else:
self._show_reload_icon()
self._stop_and_reload.set_tooltip(gtk.Tooltips(), _('Reload'))
self._update_navigation_buttons()
def build_window(self):
self.set_size_request(550, 700)
self.set_title("Open connections")
self.set_resizable(True)
self.vbox = gtk.VBox()
self.add(self.vbox)
""" Toolbar """
toolbar = gtk.Toolbar()
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
toolbar.set_style(gtk.TOOLBAR_BOTH)
self.new_button = gtk.ToolButton(gtk.STOCK_ADD)
self.new_button.connect('clicked', self.on_add_host)
self.new_button.set_tooltip(gtk.Tooltips(), 'Add')
self.new_button.set_label("Add")
toolbar.insert(self.new_button, -1)
self.edit_button = gtk.ToolButton(gtk.STOCK_EDIT)
self.edit_button.connect('clicked', self.on_edit_host)
self.edit_button.set_tooltip(gtk.Tooltips(), 'Edit')
self.edit_button.set_label("Edit")
toolbar.insert(self.edit_button, -1)
self.copy_button = gtk.ToolButton(gtk.STOCK_COPY)
self.copy_button.connect('clicked', self.on_copy_host)
self.copy_button.set_tooltip(gtk.Tooltips(), 'Copy')
self.copy_button.set_label("Copy")
toolbar.insert(self.copy_button, -1)
self.remove_button = gtk.ToolButton(gtk.STOCK_ADD)
self.remove_button.set_label("Remove")
self.remove_button.set_tooltip(gtk.Tooltips(), 'Remove')
self.remove_button.connect('clicked', self.on_remove_host)
toolbar.insert(self.remove_button, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
self.connect_button = gtk.ToolButton(gtk.STOCK_CONNECT)
self.connect_button.set_label("Connect")
self.connect_button.set_tooltip(gtk.Tooltips(), 'Connect')
self.connect_button.connect('clicked', self.hosts_tree.on_connect)
toolbar.insert(self.connect_button, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
self.vbox.pack_start(toolbar, False, False, 0)
self.vbox.pack_start(self.hosts_tree, True, True)
""" Run """
self.connect("delete_event", self.on_exit)
self.connect("key-press-event", self._key_press_event)
self.show_all()
self.on_cursor_changed()
self.hosts_tree.entry.grab_focus()
self.window.focus(0)
def create_tool_bar(self):
"""Create the tool bar for the GUI."""
self.tool_bar = gtk.Toolbar()
update_now_button = gtk.ToolButton(
icon_widget=gtk.image_new_from_stock(
gtk.STOCK_REFRESH, gtk.ICON_SIZE_SMALL_TOOLBAR))
update_now_button.set_label("Update Listing")
tooltip = gtk.Tooltips()
tooltip.enable()
tooltip.set_tip(update_now_button, "Update Suite Listing Now")
update_now_button.connect("clicked", self.updater.set_update_listing)
clear_stopped_button = gtk.ToolButton(
icon_widget=gtk.image_new_from_stock(
gtk.STOCK_CLEAR, gtk.ICON_SIZE_SMALL_TOOLBAR))
clear_stopped_button.set_label("Clear")
tooltip = gtk.Tooltips()
tooltip.enable()
tooltip.set_tip(clear_stopped_button, "Clear stopped suites")
clear_stopped_button.connect("clicked",
self.updater.clear_stopped_suites)
expand_button = gtk.ToolButton(
icon_widget=gtk.image_new_from_stock(
gtk.STOCK_ADD, gtk.ICON_SIZE_SMALL_TOOLBAR))
expand_button.set_label("Expand all")
tooltip = gtk.Tooltips()
tooltip.enable()
tooltip.set_tip(expand_button, "Expand all rows")
expand_button.connect("clicked", lambda e: self.treeview.expand_all())
collapse_button = gtk.ToolButton(
icon_widget=gtk.image_new_from_stock(
gtk.STOCK_REMOVE, gtk.ICON_SIZE_SMALL_TOOLBAR))
collapse_button.set_label("Expand all")
tooltip = gtk.Tooltips()
tooltip.enable()
tooltip.set_tip(collapse_button, "Collapse all rows")
collapse_button.connect(
"clicked", lambda e: self.treeview.collapse_all())
self.tool_bar.insert(update_now_button, 0)
self.tool_bar.insert(clear_stopped_button, 0)
self.tool_bar.insert(collapse_button, 0)
self.tool_bar.insert(expand_button, 0)
separator = gtk.SeparatorToolItem()
separator.set_expand(True)
self.tool_bar.insert(separator, 0)
self.tool_bar.show_all()
def fill_status_label(self):
if self.xml.get_widget('information_notebook').get_n_pages() < 2:
return
contact_list = gajim.contacts.get_contacts(self.account,
self.contact.jid)
# stats holds show and status message
stats = ''
one = True # Are we adding the first line ?
if contact_list:
for c in contact_list:
if not one:
stats += '\n'
stats += helpers.get_uf_show(c.show)
if c.status:
stats += ': ' + c.status
if c.last_status_time:
stats += '\n' + _('since %s') % time.strftime(
'%c', c.last_status_time).decode(
locale.getpreferredencoding())
one = False
else: # Maybe gc_vcard ?
stats = helpers.get_uf_show(self.contact.show)
if self.contact.status:
stats += ': ' + self.contact.status
status_label = self.xml.get_widget('status_label')
status_label.set_max_width_chars(15)
status_label.set_text(stats)
tip = gtk.Tooltips()
status_label_eventbox = self.xml.get_widget('status_label_eventbox')
tip.set_tip(status_label_eventbox, stats)
def _init_toolbar2_4(self):
basedir = os.path.join(matplotlib.rcParams['datapath'], 'images')
self.tooltips = gtk.Tooltips()
for text, tooltip_text, image_file, callback in self.toolitems:
if text is None:
self.insert(gtk.SeparatorToolItem(), -1)
continue
fname = os.path.join(basedir, image_file)
image = gtk.Image()
image.set_from_file(fname)
tbutton = gtk.ToolButton(image, text)
self.insert(tbutton, -1)
tbutton.connect('clicked', getattr(self, callback))
tbutton.set_tooltip(self.tooltips, tooltip_text, 'Private')
toolitem = gtk.SeparatorToolItem()
self.insert(toolitem, -1)
# set_draw() not making separator invisible,
# bug #143692 fixed Jun 06 2004, will be in GTK+ 2.6
toolitem.set_draw(False)
toolitem.set_expand(True)
toolitem = gtk.ToolItem()
self.insert(toolitem, -1)
self.message = gtk.Label()
toolitem.add(self.message)
self.show_all()
def create_toolbar( self):
self.toolbar_box = gtk.HandleBox()
toolbar = gnutr_widgets.GnutrToolbar()
tooltips = gtk.Tooltips()
self.toolbar_box.add( toolbar)
self.open_button = toolbar.append_button( 'gtk-open', "Open", tooltips, "Open recipe from database")
self.save_button = toolbar.append_button( 'gtk-save', "Save", tooltips, "Save recipe to database")
self.clear_button = toolbar.append_button( 'gtk-refresh', "Clear", tooltips, "Clear recipe")
sep = gtk.SeparatorToolItem()
toolbar.insert( sep, -1)
self.add_button = toolbar.append_button( 'gtk-add', "Add", tooltips, "Add food to recipe")
self.delete_button = toolbar.append_button( 'gtk-remove', "Delete", tooltips, "Delete food from recipe")
self.edit_button = toolbar.append_button( 'gtk-undo', "Edit", tooltips, "Edit food in recipe")
sep = gtk.SeparatorToolItem()
toolbar.insert( sep, -1)
self.nutr_button = toolbar.append_button( 'gtk-execute', "Nutrients", tooltips, "Display recipe nutrient totals")
self.goal_button = toolbar.append_button( 'gtk-properties', "Goals", tooltips, "Nutrition goals")
# icon9 = gtk.Image()
# icon9.set_from_stock( 'gtk-execute', gtk.ICON_SIZE_LARGE_TOOLBAR)
# self.graph_button = toolbar.append_item( "Graph",
# "Display graph of recipe nutrient totals", None, icon9,
# None, None)
self.toolbar_box.show_all()
def switch(self, classname, ncols):
area = self.area
for c in area.get_children():
area.remove(c)
classsize = self.sizeFromName[classname]
self.label.set_markup("%s : <b>%s</b>"% (self.fname,classname) )
print "***", classname, classsize #XXX
area.resize( 1+classsize/ncols, ncols)
members = self.membersFromName[classname]
tooltips = gtk.Tooltips()
for off, origsize, name, typename in members + [(classsize,1,"{END}","")]:
print "+", off, origsize, name, typename #XXX
left, top = off%ncols, off//ncols
size = origsize
while size > 0:
width = min(ncols-left, size)
if left == 0:
height = max(size//ncols, 1)
else:
height = 1
#print size, left, left+width, top, top+height
size -= width*height
b = gtk.Button("%s %s" % (name,["","..."][size>0] ) )
b.set_use_underline(False)
b.connect("clicked", lambda a,n=typename : self.jump_to(n))
b.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("White"))
tooltips.set_tip(b, "%s %s %i@%i" % (typename, name, origsize, off))
area.attach(b, left, left+width, top, top+height)
top += height
left = (left+width)%ncols
tooltips.enable()
area.show_all()
def _update(self):
if self.history is None:
return
for button in self.get_children()[2:]:
self.remove(button)
self._selected = None
for path in self.get_paths():
button = gtk.ToggleButton(label=path.basename)
button.set_use_underline(False)
button.zim_path = path
button.connect('clicked', self.on_button_clicked)
button.connect('popup-menu', self.on_button_popup_menu)
button.connect('button-release-event',
self.do_button_release_event)
button.connect('drag-data-get', self.on_drag_data_get)
button.drag_source_set(gtk.gdk.BUTTON1_MASK,
(INTERNAL_PAGELIST_TARGET, ),
gtk.gdk.ACTION_LINK)
button.show()
self.add(button)
# FIXME tooltips seem not to work - not sure why
if gtk.gtk_version >= (2, 12) \
and gtk.pygtk_version >= (2, 12):
for button in self.get_children()[2:]:
button.set_tooltip_text(button.zim_path.name)
else:
tooltips = gtk.Tooltips()
for button in self.get_children()[2:]:
tooltips.set_tip(button, button.zim_path.name)
def __init__(self, client, main):
'''
Initialize the ChatFrame
@param client: ScrabbleClient instance
@param main: MainWindow instance
@see: L{pyscrabble.net.client.ScrabbleClient}
@see: L{pyscrabble.gui.main.MainWindow}
'''
gtk.Frame.__init__(self)
self.client = client
self.client.setChatWindow(self)
self.mainwindow = main
self.connect("realize", self.onRealize_cb)
main = gtk.VBox(False, 10)
self.messageWindowOpen = False
self.serverInfoWindow = None
main.pack_start(self.createChatWindow(), True, True, 0)
main.pack_start(self.createEntryWindow(), False, False, 0)
self.tips = gtk.Tooltips()
self.set_border_width(10)
self.add(main)
self.show_all()
self.client.checkMessages()
def __init__(self, mainwindow, section=None):
'''
Constructor
@param mainwindow: Mainwindow instance
'''
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
self.connect("destroy", self.onDestroy)
self.connect("delete_event", self.onDelete_event)
self.set_title(_('Options'))
self.mainwindow = mainwindow
self.section = section
self.optionmanager = manager.OptionManager()
self.tips = gtk.Tooltips()
self.set_default_size(OPTION_WINDOW_WIDTH, OPTION_WINDOW_HEIGHT)
hbox = gtk.HBox(False, 10)
hbox.pack_start(self.getOptionsMenu(), False, False, 0)
hbox.pack_start(self.getOptionsFrame(), True, True, 0)
self.add(hbox)
#self.set_resizable( False )
self.set_border_width(10)
self.show_all()
def __init__(self, parent):
dialog = gtk.Dialog("Key/mouse input", parent,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
("Close", gtk.RESPONSE_CLOSE))
tips = gtk.Tooltips()
entry = gtk.Entry()
entry.connect("activate", self._entry_cb)
insert = create_button("Insert", self._entry_cb)
tips.set_tip(insert, "Insert text to Hatari window")
hbox1 = gtk.HBox()
hbox1.add(gtk.Label("Text:"))
hbox1.add(entry)
hbox1.add(insert)
dialog.vbox.add(hbox1)
rclick = gtk.Button("Rightclick")
tips.set_tip(rclick, "Simulate Atari left button double-click")
rclick.connect("pressed", self._rightpress_cb)
rclick.connect("released", self._rightrelease_cb)
dclick = create_button("Doubleclick", self._doubleclick_cb)
tips.set_tip(dclick, "Simulate Atari rigth button click")
hbox2 = gtk.HBox()
hbox2.add(rclick)
hbox2.add(dclick)
dialog.vbox.add(hbox2)
dialog.show_all()
self.dialog = dialog
self.entry = entry
def __init__(self,
title="Message",
message="",
buttons=("Ok",),
pixmap=ICON_INFO,
modal=gtk.TRUE):
"""
message: either a string or a list of strings
pixmap: either a filename string, or one of: ICON_STOP, ICON_ALERT,
ICON_INFO or ICON_QUESTION, or None
"""
gtk.Dialog.__init__(self)
self.set_title(title)
self.set_wmclass("icewmcontrolpanel","IceWMControlPanel") # added, 4.2.2003 - Erica Andrews
self.connect("destroy", self.quit)
self.connect("delete_event", self.quit)
self.connect("key-press-event", self.__press)
self.set_modal(gtk.TRUE)
hbox = gtk.HBox(spacing=5)
hbox.set_border_width(10)
self.vbox.pack_start(hbox)
hbox.show()
if pixmap:
self.realize()
pic = gtk.Image()
if type(pixmap) == type(""):
pic.set_from_file(pixmap)
else:
p, m = gtk.gdk.pixmap_create_from_xpm_d(self.window,
None,
icons[pixmap])
pic.set_from_pixmap(p, m)
pic.set_alignment(0.5, 0.0)
hbox.pack_start(pic, expand=gtk.FALSE)
pic.show()
if type(message) == type(""):
label = gtk.Label(message)
else:
label = gtk.Label(join(message, "\n"))
label.set_justify(gtk.JUSTIFY_LEFT)
label.set_line_wrap(1) # added 4.4.2003 - for better readibility on low-res screens, Erica Andrews
hbox.pack_start(label)
label.show()
if not buttons:
buttons = ("Ok",)
tips=gtk.Tooltips()
for text in buttons:
b = gtk.Button(text)
tips.set_tip(b,text)
if text == buttons[0]:
# the first button will always be the default button:
b.set_flags(gtk.CAN_FOCUS|gtk.CAN_DEFAULT|gtk.HAS_FOCUS|gtk.HAS_DEFAULT)
b.set_flags(gtk.CAN_DEFAULT)
b.set_data("user_data", text)
b.connect("clicked", self.__click)
self.action_area.pack_start(b)
b.show()
self.default = buttons[0]
self.ret = None
def main():
global cal
global notify, tips,tr,box,l
try: pynotify.init('HijriApplet'); notify=pynotify.Notification("التقويم الهجري")
except: pass
Y,M,D,W=cal.today
yy,mm,dd=cal.g_today
tr = egg.trayicon.TrayIcon("HijriApplet")
box = gtk.EventBox()
l=gtk.Label()
l.set_markup('<span size="small" weight="bold" foreground="red" background="#ffffff">%02d</span>\n<span size="small" weight="bold" foreground="yellow" background="black">%02d</span>' % (D, M))
tr.add(box)
box.add(l)
try: box.set_tooltip_text("Waiting ...")
except AttributeError: tips=gtk.Tooltips()
set_tip(box, "%s, %d من %s لعام %d" % (week_days[W], D, months[M-1], Y))
#notify.attach_to_widget(w) # whats wrong with it
#notify.set_property('attach-widget',box)
try:
notify.set_property('icon-name','gtk-info')
notify.set_property('summary', "التقويم الهجري" )
notify.set_property('body', "%s, %d من %s لعام %d\nالموافق %d من %s لعام %s" % (week_days[W], D, months[M-1], Y,dd,gmonths[mm-1],yy) )
notify.show()
except: pass
setup_popup_menu()
#update_cb()
gobject.timeout_add(5000, update_cb)
tr.show_all()
build_gui()
#print "Done"
gtk.main()
def __init__(self):
gtk.Window.__init__(self)
self.connect('destroy', self.__destroy)
self.set_default_size(800, 400)
self.set_title(self.__class__.__name__)
self.set_border_width(10)
self.tooltips = gtk.Tooltips()
hbox = gtk.HBox(False, 3)
self.add(hbox)
vbox = gtk.VBox(False, 0)
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.set_shadow_type(gtk.SHADOW_IN)
treeview = self.__create_treeview()
treeview.set_size_request(250, 600)
scrolled_window.add(treeview)
vbox.pack_start(scrolled_window)
hbox1 = gtk.HBox(False, 0)
button = gtk.Button("About")
button.connect("clicked", self.__about_clicked)
self.tooltips.set_tip(button,
"README! Show the purpose of this program.")
hbox1.pack_start(button)
button = gtk.Button("Revert")
button.connect("clicked", self.__revert_clicked)
self.tooltips.set_tip(button, "Revert settings for selected codec.")
hbox1.pack_start(button)
button = gtk.Button("Diff")
button.connect("clicked", self.__diff_clicked)
self.tooltips.set_tip(button, "Show settings diff for selected codec.")
hbox1.pack_start(button)
button = gtk.Button("Exp")
button.connect("clicked", self.__export_clicked)
self.tooltips.set_tip(
button,
"Export settings differences for selected codec.\nGenerates a python script."
)
hbox1.pack_start(button)
button = gtk.Button("Graph")
button.connect("clicked", self.__graph_clicked)
self.tooltips.set_tip(button, "Show graph for selected codec.")
hbox1.pack_start(button)
vbox.pack_start(hbox1, False, False)
hbox.pack_start(vbox, False, False)
self.notebook = gtk.Notebook()
hbox.pack_start(self.notebook, expand=True)
self.node_window = gtk.Table()
self._new_notebook_page(self.node_window, '_Node editor')
scrolled_window, self.info_buffer = self.__create_text(
self.__dump_visibility)
self._new_notebook_page(scrolled_window, '_Text dump')
self.show_all()
TRACKER.add(self)
def constructTable(self, comp, specs):
table = gtk.Table(rows=len(specs), columns=2, homogeneous=True)
i = 0
for k, v in specs.items():
label = gtk.Label(v['name'])
entry = gtk.Entry()
entry.set_name(k)
self.entries[(comp, k)] = entry
entry.set_text(str(v['value']))
entry.connect('activate', self.entryEdited, None, comp, specs)
entry.connect('focus-out-event', self.entryEdited, comp, specs)
table.attach(label,
left_attach=0,
right_attach=1,
top_attach=i,
bottom_attach=i + 1)
label.show()
table.attach(entry,
left_attach=1,
right_attach=2,
top_attach=i,
bottom_attach=i + 1)
entry.show()
tooltip = gtk.Tooltips()
tooltip.set_tip(label, v['tooltip'])
i += 1
table.set_row_spacings(5)
return table
def make_pages(self):
# The editor has (at this moment) four tabs this are pointers to the
# vboxes inside each tab.
self._vbox_widget, v1 = self._notebook_page(_('Widget'))
self._vbox_packing, v2 = self._notebook_page(_('Packing'))
self._vbox_common, v3 = self._notebook_page(_('Common'))
self._vbox_signals, v4 = self._notebook_page(_('Signals'))
self.set_page(0)
# A handy reference to the widget that is loaded in the editor. None
# if no widgets are selected
self._loaded_widget = None
# A list of properties for the current widget
# XXX: We might want to cache this
self._widget_properties = []
self._signal_editor = None
self._tooltips = gtk.Tooltips()
# Display some help
help_label = gtk.Label(_("Select a widget to edit its properties"))
help_label.show()
self._vbox_widget.pack_start(help_label)
def __init__(self, plugOrPlugValueWidget, label=None, description=None):
GafferUI.Widget.__init__(self, gtk.HBox(spacing=5))
self.__gtkHBox = self.gtkWidget()
if isinstance(plugOrPlugValueWidget, PlugValueWidget):
self.__valueWidget = plugOrPlugValueWidget
plug = self.__valueWidget.getPlug()
else:
self.__valueWidget = PlugValueWidget.create(plugOrPlugValueWidget)
plug = plugOrPlugValueWidget
label = gtk.Label(label or CamelCase.toSpaced(plug.getName()))
label.set_width_chars(15)
label.set_alignment(1, 0.5)
labelEventBox = gtk.EventBox()
labelEventBox.add(label)
self.__gtkHBox.pack_start(labelEventBox, False)
if self.__valueWidget:
self.__gtkHBox.pack_start(self.__valueWidget.gtkWidget())
if description:
self.__tooltips = gtk.Tooltips()
self.__tooltips.set_tip(labelEventBox, "hi there")
self.__gtkHBox.show_all()
def __init__(self, *args):
gtk.VBox.__init__(self)
WidgetObserver.__init__(self, *args)
self._pages = {}
self._nb = gtk.Notebook()
self._tips = gtk.Tooltips()
self.pack_start(self._nb)
def create_toolbar(self):
self.toolbar_box = gtk.HandleBox()
toolbar = gnutr_widgets.GnutrToolbar()
tooltips = gtk.Tooltips()
self.toolbar_box.add(toolbar)
self.clear_button = toolbar.append_button('gtk-clear', 'Clear', tooltips, 'Clear food data')
sep = gtk.SeparatorToolItem()
toolbar.insert(sep, -1)
self.select_button = toolbar.append_button('gtk-find', 'Select', tooltips, 'Select food from database')
self.compute_button = toolbar.append_button('gtk-execute', 'Compute', tooltips, 'Compute nutrition composition')
sep = gtk.SeparatorToolItem()
toolbar.insert(sep, -1)
self.pref_button = toolbar.append_button('gtk-preferences', 'Goals', tooltips, 'Nutritient goal')
# icon5 = gtk.Image()
# icon5.set_from_stock('gtk-execute', gtk.ICON_SIZE_LARGE_TOOLBAR)
# self.graph_button = toolbar.append_item('Graph',
# 'Graph of nutrient composition', None, icon5, None, None)
self.toolbar_box.show_all()
def __addButton(self, group, name, filename, pix, mask):
butt = None
tips=gtk.Tooltips()
#DJM try:
if 1:
if filename == "-":
butt = gtk.RadioButton(group, "None")
else:
if pix is None or mask is None:
newheight,newwidth = 28,28 # 2.21.2003 - added larger icons ([email protected])
img = gtk.gdk.pixbuf_new_from_file(filename)
img2 = img.scale_simple(newheight,
newwidth,
gtk.gdk.INTERP_BILINEAR)
pix,mask = img2.render_pixmap_and_mask()
icon = gtk.Image()
icon.set_from_pixmap(pix, mask)
icon.show()
butt = gtk.RadioButton(group)
butt.add(icon)
tips.set_tip(butt,filename)
butt.set_relief(gtk.RELIEF_NONE) # new relief - flat added 2.21.2003
butt.set_mode(gtk.FALSE)
butt.set_data("filename", filename)
butt.set_data("name", name)
butt.connect("clicked", self.on_iconbutton_clicked)
butt.connect("button-press-event", self.on_iconbutton_pressed)
butt.show()
## if len(self.err_msg)<2: raise TypeError # this was for testing only, 4/25/2003, Erica Andrews
self.buttons.append(butt)
#DJM except: # added 4/25/2003, be quiet about image loading problems, but report errors later, Erica Andrews
#DJM print "error"
#DJM self.err_msg.append(str(filename))
return butt
def __init__(self):
super(ClassInspectorSidebar, self).__init__()
self.__tooltips = gtk.Tooltips()
self.__otype = None
self.__olabel = ObjectInspectLink()
self.__olabel.set_ellipsize(True)
self.pack_start(self.__olabel, expand=False)
membersframe = gtk.Frame(_('Members'))
vbox = gtk.VBox()
membersframe.add(vbox)
self.__hidden_check = gtk.CheckButton(_('Show _Hidden'))
vbox.pack_start(self.__hidden_check, expand=False)
self.__hidden_check.connect_after('toggled', self.__on_show_hidden_toggled)
self.__members_model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
self.__membersview = gtk.TreeView(self.__members_model)
self.__membersview.connect('row-activated', self.__on_row_activated)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scroll.add(self.__membersview)
vbox.add(scroll)
self.pack_start(membersframe, expand=True)
colidx = self.__membersview.insert_column_with_data_func(-1, '',
gtk.CellRendererPixbuf(),
self.__render_icon)
col = self.__membersview.insert_column_with_attributes(-1, _('Name'),
hotwidgets.CellRendererText(),
text=0)
self.__membersview.set_search_column(0)
col.set_spacing(0)
col.set_resizable(True)
def make_msg_tab(self):
def pack(txt, i):
hb = gtk.HBox(False, 2)
l = gtk.Label()
l.set_markup('<span size="10000"><b>{}</b></span>'.format(txt))
hb.add(i)
hb.add(l)
return hb
v = gtk.VBox(False, 1)
v.pack_start(self.agtora, False, True, 5)
vv = gtk.HBox(True, 5)
tooltips = gtk.Tooltips()
pixbuf = env.IconTheme.load_icon("kuser", 24,
gtk.ICON_LOOKUP_GENERIC_FALLBACK)
img = gtk.Image()
img.set_from_pixbuf(pixbuf)
bt = gtk.Button()
bt.connect('clicked', self.on_add_agt)
bt.add(pack('Adaugă', img))
tooltips.set_tip(bt, 'Adaugă un nou agent!')
vv.add(bt)
img = gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU)
bt = gtk.Button()
bt.connect('clicked', self.on_del_agt)
tooltips.set_tip(bt, 'Șterge agentul selectat!')
bt.add(pack('Șterge', img))
vv.add(bt)
pixbuf = env.IconTheme.load_icon("gnome-settings-theme", 24,
gtk.ICON_LOOKUP_GENERIC_FALLBACK)
img = gtk.Image()
img.set_from_pixbuf(pixbuf)
bt = gtk.Button()
bt.connect('clicked', self.on_edit_agt)
tooltips.set_tip(bt, 'Modifică numele\nagentului selectat!')
bt.add(pack('Modifică', img))
vv.add(bt)
v.pack_start(vv, False, True)
v.add(
gtk.image_new_from_pixbuf(
gtk.gdk.pixbuf_new_from_file_at_size('agt.png', 64, 64)))
self.mesaj.set_editable(False)
self.mesaj.modify_font(FontDescription('Segoe UI 9'))
self.mesaj.set_wrap_mode(gtk.WRAP_WORD)
# self.mesaj.set_justification(gtk.JUSTIFY_CENTER)
self.mesaj.set_cursor_visible(False)
self.mesaj.set_left_margin(2)
self.mesaj.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse('#ddd'))
self.mesaj.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse('#000'))
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add(self.mesaj)
self.mesaj.set_size_request(-1, 80)
v.add(sw)
v.pack_end(self.userbt, False, True)
return v
def __create_widgets(self):
"""
"""
cur_mode = view_mode_descr[self.timeline_base.graph_mode]
self.select_label = gtk.Label(cur_mode)
values = self.timeline_base.bounds_by_graphmode()
self.date_select = gtk.SpinButton(
gtk.Adjustment(value=values[2],
lower=values[0],
upper=values[1],
step_incr=1), 1)
###############
#Refresh Button
self.tooltips = gtk.Tooltips()
self.refresh_button = gtk.Button()
self.refresh_button.set_border_width(3)
self.refresh_button.set_relief(gtk.RELIEF_NONE)
self.tooltips.set_tip(self.refresh_button, _("Graph Refresh"))
img = gtk.Image()
img.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_BUTTON)
box = gtk.HBox()
box.pack_start(img, False, False, 0)
self.refresh_button.add(box)
def _update(self):
if self.history is None:
return
for button in self.get_children()[2:]:
self.remove(button)
self._selected = None
for path in self.get_paths():
button = gtk.ToggleButton(label=path.basename)
button.set_use_underline(False)
button.zim_path = path
button.connect('clicked', self.on_button_clicked)
button.connect('popup-menu', self.on_button_popup_menu)
button.connect('button-release-event', self.do_button_release_event)
# TODO Drag n drop support also nice to have
button.show()
self.add(button)
# FIXME tooltips seem not to work - not sure why
if gtk.gtk_version >= (2, 12) \
and gtk.pygtk_version >= (2, 12):
for button in self.get_children()[2:]:
button.set_tooltip_text(button.zim_path.name)
else:
tooltips = gtk.Tooltips()
for button in self.get_children()[2:]:
tooltips.set_tip(button, button.zim_path.name)
def create_toolbar( self):
self.toolbar_box = gtk.HandleBox()
toolbar = gnutr_widgets.GnutrToolbar()
tooltips = gtk.Tooltips()
self.toolbar_box.add( toolbar)
self.save_button = toolbar.append_button( 'gtk-save', 'Save', tooltips, 'Save meal plan')
sep = gtk.SeparatorToolItem()
toolbar.insert(sep, -1)
self.add_button = toolbar.append_button( 'gtk-add', 'Add', tooltips, 'Add food or recipe')
self.edit_button = toolbar.append_button( 'gtk-undo', 'Edit', tooltips, 'Edit recipe or food')
self.delete_button = toolbar.append_button( 'gtk-remove', 'Delete', tooltips, 'Delete selected recipe or food')
sep = gtk.SeparatorToolItem()
toolbar.insert(sep, -1)
self.compute_button = toolbar.append_button( 'gtk-execute', 'Compute', tooltips, 'Compute nutritient composition')
# icon6 = gtk.Image()
# icon6.set_from_stock( 'gtk-execute', gtk.ICON_SIZE_LARGE_TOOLBAR)
# self.graph_button = toolbar.append_item( 'Graph',
# 'Graph of nutrient composition', None, icon6, None, None)
# icon7 = gtk.Image()
# icon7.set_from_stock( 'gtk-execute', gtk.ICON_SIZE_LARGE_TOOLBAR)
# self.graph_button = toolbar.append_item( 'Variation',
# 'Graph of variation of nutrient composition', None, icon7,
# None, None)
self.toolbar_box.show_all()
def __init__(self):
gtk.Toolbar.__init__(self)
self.tooltips1 = gtk.Tooltips()
iconSize = gtk.ICON_SIZE_SMALL_TOOLBAR
#self.set_border_width(5)
self.set_style(gtk.TOOLBAR_BOTH)
#self.set_style(gtk.TOOLBAR_ICONS)
#self.set_orientation(gtk.ORIENTATION_VERTICAL)
self.add_toolbutton1(gtk.STOCK_REFRESH, 'Enable interact',
'Enable mouse rotate pan/zoom', 'Private',
self.notify, 'mouse1 interact')
self.add_toolbutton1(
gtk.STOCK_REFRESH, 'Reset Camera',
'If this button used to do something else, right now it resets the camera',
'Private', self.notify, 'vtk interact')
self.add_toolbutton1(gtk.STOCK_BOLD, 'Label markers',
'Label clicked markers', 'Private', self.notify,
'mouse1 label')
self.add_toolbutton1(gtk.STOCK_APPLY, 'Select markers',
'Select clicked markers', 'Private', self.notify,
'mouse1 select')
self.add_toolbutton1(gtk.STOCK_CLEAR, 'Set color', 'Set marker color',
'Private', self.notify, 'mouse1 color')
self.add_toolbutton1(gtk.STOCK_GO_FORWARD, 'Move', 'Move markers',
'Private', self.notify, 'mouse1 move')
self.add_toolbutton1(gtk.STOCK_DELETE, 'Delete',
'Delete clicked markers', 'Private', self.notify,
'mouse1 delete')
self.show_all()
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.connect('toggled', self.toggle_grouping)
self._set_tooltip(self.group_toolbutton,
"Dot View - Click to group tasks by families")
items.append(self.group_toolbutton)
self.filter_entry = EntryTempText()
self.filter_entry.set_width_chars(7) # Reduce width in toolbar
self.filter_entry.connect("activate", self.check_filter_entry)
self.filter_entry.set_temp_text("filter")
filter_toolitem = gtk.ToolItem()
filter_toolitem.add(self.filter_entry)
tooltip = gtk.Tooltips()
tooltip.enable()
tooltip.set_tip(
filter_toolitem,
"Dot View - Filter tasks by name\n(enter a sub-string or regex)")
items.append(filter_toolitem)
return items
def _button_box(self):
'''
Panel which includes buttons for manipulating the current treeview:
- add / delete
- move up / move down row
:return: vbox-panel
'''
vbox = gtk.VBox(spacing=5)
tooltips = gtk.Tooltips()
for stock, handler, data, tooltip in (
(gtk.STOCK_ADD, self.on_add_new_column, None,
_('Add column')), # T: hoover tooltip
(gtk.STOCK_DELETE, self.on_delete_column, None,
_('Remove column')), # T: hoover tooltip
(gtk.STOCK_GO_UP, self.on_move_column, -1,
_('Move column ahead')), # T: hoover tooltip
(gtk.STOCK_GO_DOWN, self.on_move_column, 1,
_('Move column backward')), # T: hoover tooltip
):
button = IconButton(stock)
if data:
button.connect('clicked', handler, data)
else:
button.connect('clicked', handler)
tooltips.set_tip(button, tooltip)
vbox.pack_start(button, False)
vbox.show_all()
return vbox
def __init__(self, gtimelog_window):
self.gtimelog_window = gtimelog_window
self.timelog = gtimelog_window.timelog
self.trayicon = None
try:
import egg.trayicon
except ImportError:
# nothing to do here, move along
# or install python-gnome2-extras
return
self.tooltips = gtk.Tooltips()
self.eventbox = gtk.EventBox()
hbox = gtk.HBox()
icon = gtk.Image()
icon.set_from_file(icon_file)
hbox.add(icon)
self.time_label = gtk.Label()
hbox.add(self.time_label)
self.eventbox.add(hbox)
self.trayicon = egg.trayicon.TrayIcon("GTimeLog")
self.trayicon.add(self.eventbox)
self.last_tick = False
self.tick(force_update=True)
self.trayicon.show_all()
tray_icon_popup_menu = gtimelog_window.tray_icon_popup_menu
self.eventbox.connect_object("button-press-event", self.on_press,
tray_icon_popup_menu)
self.eventbox.connect("button-release-event", self.on_release)
gobject.timeout_add(1000, self.tick)
self.gtimelog_window.entry_watchers.append(self.entry_added)
def _create_toolitems_2_4(self):
# use the GTK+ 2.4 GtkToolbar API
iconSize = gtk.ICON_SIZE_SMALL_TOOLBAR
self.tooltips = gtk.Tooltips()
for text, tooltip_text, image_num, callback, callback_arg, scroll \
in self.toolitems:
if text is None:
self.insert(gtk.SeparatorToolItem(), -1)
continue
image = gtk.Image()
image.set_from_stock(image_num, iconSize)
tbutton = gtk.ToolButton(image, text)
self.insert(tbutton, -1)
if callback_arg:
tbutton.connect('clicked', getattr(self, callback),
callback_arg)
else:
tbutton.connect('clicked', getattr(self, callback))
if scroll:
tbutton.connect('scroll_event', getattr(self, callback))
tbutton.set_tooltip(self.tooltips, tooltip_text, 'Private')
# Axes toolitem, is empty at start, update() adds a menu if >=2 axes
self.axes_toolitem = gtk.ToolItem()
self.insert(self.axes_toolitem, 0)
self.axes_toolitem.set_tooltip(
self.tooltips,
tip_text='Select axes that controls affect',
tip_private='Private')
align = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.0, yscale=0.0)
self.axes_toolitem.add(align)
self.menubutton = gtk.Button("Axes")
align.add(self.menubutton)
def position_menu(menu):
"""Function for positioning a popup menu.
Place menu below the menu button, but ensure it does not go off
the bottom of the screen.
The default is to popup menu at current mouse position
"""
x0, y0 = self.window.get_origin()
x1, y1, m = self.window.get_pointer()
x2, y2 = self.menubutton.get_pointer()
sc_h = self.get_screen().get_height() # requires GTK+ 2.2 +
w, h = menu.size_request()
x = x0 + x1 - x2
y = y0 + y1 - y2 + self.menubutton.allocation.height
y = min(y, sc_h - h)
return x, y, True
def button_clicked(button, data=None):
self.axismenu.popup(None, None, position_menu, 0,
gtk.get_current_event_time())
self.menubutton.connect("clicked", button_clicked)
