def addExpander(self, name, *choices, **kwargs):
options = {}
group = gtk.ToolItemGroup(name)
self.add(group)
group.set_collapsed(True)
item = gtk.ToolItem()
group.insert(item, -1)
group.child_set_property(item, 'new-row', False)
group.child_set_property(item, 'expand', False)
table = gtk.Table()
table.resize(len(choices), 2)
table.set_homogeneous(True)
item.add(table)
radio_group = None
for i, (choice, mode) in enumerate(choices):
entry = None
radio = gtk.RadioButton(group=radio_group, label=choice)
if not mode:
table.attach(radio, 0, 2, i, i + 1)
else:
if mode == 'entry':
entry = gtk.Entry()
else:
entry = gtk.FileChooserButton('Select a file...')
table.attach(radio, 0, 1, i, i + 1)
table.attach(entry, 1, 2, i, i + 1)
options[choice] = entry
if not radio_group:
radio_group = radio
self.show_all()
self.__groups[name] = radio_group, options
if 'expanded' in kwargs:
group.set_collapsed(not kwargs['expanded'])
return group
def __init__(self, pc):
gtk.Toolbar.__init__(self)
self.activity = pc
# C slider
self.activity.c_slider = ToolButton("Con")
self.activity.c_slider.set_tooltip(_('C'))
self.activity.c_slider.props.sensitive = True
self.activity.c_slider.connect('clicked', self.activity._c_slider_cb)
self.insert(self.activity.c_slider, -1)
self.activity.c_slider.show()
# A slider
self.activity.a_slider = ToolButton("Aoff")
self.activity.a_slider.set_tooltip(_('A'))
self.activity.a_slider.props.sensitive = True
self.activity.a_slider.connect('clicked', self.activity._a_slider_cb)
self.insert(self.activity.a_slider, -1)
self.activity.a_slider.show()
# Label for showing status
self.activity.results_label = gtk.Label("1.0 × 1.0 = 1.0")
self.activity.results_label.show()
self.activity.results_toolitem = gtk.ToolItem()
self.activity.results_toolitem.add(self.activity.results_label)
self.insert(self.activity.results_toolitem, -1)
self.activity.results_toolitem.show()
def __init__(self, widgets=[], sep_on_name=[]):
super(ToolBar, self).__init__()
self.item_dict = {}
self.show()
widgets.reverse()
for name, stock in widgets:
if name in sep_on_name:
separator = gtk.SeparatorToolItem()
separator.show()
self.insert(separator, 0)
if isinstance(stock, basestring) and stock.startswith("gtk."):
stock = getattr(gtk, stock.replace("gtk.", "", 1))
if callable(stock):
widget = stock()
widget.show()
widget.set_tooltip_text(name)
else:
widget = CustomButton(stock_id=stock,
tip_text=name,
as_tool=True)
icon_tool_item = gtk.ToolItem()
icon_tool_item.add(widget)
icon_tool_item.show()
self.item_dict[name] = {
"tip": name,
"widget": widget,
"func": None
}
self.insert(icon_tool_item, 0)
def __init_file_open(self, toolbar):
try:
self.__fileDialog = gtk.FileChooserDialog()
self.__fileDialog.connect("close", self.__on_filechooser_close)
self.__fileDialog.connect("unmap-event", self.__on_unmap_event)
self.__fileButton = gtk.FileChooserButton(self.__fileDialog)
self.__fileButton.set_width_chars(6)
#connect the widget with the class that implements the logic
self.__fileOpen = dlg.FileOpen(
self.__fileDialog, [ffilter.ELF(self, gtk.FileFilter())])
#wrap FileChooserButton in a ToolItem
item = gtk.ToolItem()
item.add(self.__fileButton)
item.show_all()
toolbar.insert(item, 0)
except:
#FileChooser is available n Pygtk 2.4 and newer;
# fallback to FileSelection if not available
self.__fileButton = None
self.__fileDialog = gtk.FileSelection()
self.__fileDialog.hide_fileop_buttons()
#connect the widget with the class that implements the logic
self.__fileOpen = dlg.FileOpen(self.__fileDialog,
[ffilter.ELF(self, None)])
def _init_toolbar2_4(self):
basedir = os.path.join(rcParams['datapath'], 'images')
if not _new_tooltip_api:
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 + '.png')
image = gtk.Image()
image.set_from_file(fname)
tbutton = gtk.ToolButton(image, text)
self.insert(tbutton, -1)
tbutton.connect('clicked', getattr(self, callback))
if _new_tooltip_api:
tbutton.set_tooltip_text(tooltip_text)
else:
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 _add_widget(self, widget, expand=False):
tool_item = gtk.ToolItem()
tool_item.set_expand(expand)
tool_item.add(widget)
widget.show()
self.insert(tool_item, -1)
tool_item.show()
def add_frequency_slider(self, toolbox):
''' Either on the Sound toolbar or the Main toolbar '''
self._freq_stepper_up = ToolButton('freq-high')
self._freq_stepper_up.set_tooltip(_('Zoom out'))
self._freq_stepper_up.connect('clicked', self._freq_stepper_up_cb)
self._freq_stepper_up.show()
self.activity.adjustmentf = gtk.Adjustment(0.5, self.LOWER, self.UPPER,
0.01, 0.1, 0)
self.activity.adjustmentf.connect('value_changed', self.cb_page_sizef)
self._freq_range = gtk.HScale(self.activity.adjustmentf)
self._freq_range.set_inverted(True)
self._freq_range.set_draw_value(False)
self._freq_range.set_update_policy(gtk.UPDATE_CONTINUOUS)
self._freq_range.set_size_request(120, 15)
self._freq_range.show()
self._freq_stepper_down = ToolButton('freq-low')
self._freq_stepper_down.set_tooltip(_('Zoom in'))
self._freq_stepper_down.connect('clicked', self._freq_stepper_down_cb)
self._freq_stepper_down.show()
self._freq_range_tool = gtk.ToolItem()
self._freq_range_tool.add(self._freq_range)
self._freq_range_tool.show()
toolbox.add(self._freq_stepper_up)
toolbox.add(self._freq_range_tool)
toolbox.add(self._freq_stepper_down)
return
def _init_toolbar2_4(self):
basedir = matplotlib.rcParams['datapath']
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()
self.fileselect = FileChooserDialog(
title='Save the figure',
parent=self.win,
)
def __init__(self, location_enabled=True, toolbar_enabled=True):
gtk.Toolbar.__init__(self)
# location entry
if location_enabled:
self._entry = gtk.Entry()
self._entry.connect('activate', self._entry_activate_cb)
entry_item = gtk.ToolItem()
entry_item.set_expand(True)
entry_item.add(self._entry)
self._entry.show()
self.insert(entry_item, -1)
entry_item.show()
# add tab button
if toolbar_enabled:
addTabButton = gtk.ToolButton(gtk.STOCK_ADD)
addTabButton.connect("clicked", self._add_tab_cb)
self.insert(addTabButton, -1)
addTabButton.show()
viewSourceItem = gtk.ToggleToolButton(gtk.STOCK_PROPERTIES)
viewSourceItem.set_label("View Source Mode")
viewSourceItem.connect('toggled', self._view_source_mode_cb)
self.insert(viewSourceItem, -1)
viewSourceItem.show()
def combo_factory(combo_array,
toolbar,
callback,
cb_arg=None,
tooltip=None,
default=None):
'''Factory for making a toolbar combo box'''
combo = ComboBox()
if tooltip is not None and hasattr(combo, 'set_tooltip_text'):
combo.set_tooltip_text(tooltip)
if cb_arg is not None:
combo.connect('changed', callback, cb_arg)
else:
combo.connect('changed', callback)
for i, selection in enumerate(combo_array):
combo.append_item(i, selection, None)
combo.show()
toolitem = gtk.ToolItem()
toolitem.add(combo)
if hasattr(toolbar, 'insert'): # the main toolbar
toolbar.insert(toolitem, -1)
else: # or a secondary toolbar
toolbar.props.page.insert(toolitem, -1)
toolitem.show()
if default is not None:
combo.set_active(combo_array.index(default))
return combo
def __init__(self, text):
gtk.Toolbar.__init__(self)
self.modify_bg(gtk.STATE_NORMAL, get_colors("drawingplayer"))
self.label = None
self.texto = text
self.numero = 0
item = gtk.ToolItem()
self.label = gtk.Label("%s: %s" % (text, self.numero))
#self.label.modify_fg(gtk.STATE_NORMAL, get_colors("window"))
self.label.show()
item.add(self.label)
self.insert(item, -1)
self.insert(get_separador(draw=False, ancho=0, expand=True), -1)
archivo = os.path.join(BASE_PATH, "Iconos", "lista.svg")
boton = get_boton(archivo, flip=False, pixels=24)
boton.set_tooltip_text("Lista de Búsquedas")
boton.connect("clicked", self.__get_menu)
self.insert(boton, -1)
archivo = os.path.join(BASE_PATH, "Iconos", "play.svg")
boton = get_boton(archivo,
flip=False,
pixels=24,
rotacion=gtk.gdk.PIXBUF_ROTATE_CLOCKWISE)
boton.set_tooltip_text("Guardar Lista")
boton.connect("clicked", self.__emit_guardar)
self.insert(boton, -1)
self.show_all()
def _tab_added(self, browser_book, tab, index):
""" When a tab is added create a button an add it to the tabs toolbar.
"""
# Only add it if the tab is a browser tab.
if not isinstance(tab, BrowserTabBase):
return
# A tuple containing the settings for the button.
up_button_tup = ('_up_button', ('up', True, 'Go up a level.',
self._up_clicked, tab))
(button_name, settings) = up_button_tup
item = gtk.ToolItem()
item.add(tab._toolbar_button(*settings))
# Enable or disable the button based on whether it looks like the
# uri can go up a level or not.
uri = tab.get_uri()
if uri:
item.set_sensitive(len(uri.strip('/').split('/')) > 3)
else:
item.set_sensitive(False)
item.show_all()
self._item_dict[tab] = item
tab._address_bar.insert(item, 3)
# Update the button when the title changes.
tab.connect('title-changed', self._update_item)
def add_widget(self, widget, tip_text, private_text):
toolitem = gtk.ToolItem()
toolitem.add(widget)
toolitem.set_expand(False)
toolitem.set_homogeneous(False)
toolitem.set_tooltip_text(tip_text)
self.insert(toolitem, -1)
def __init__(self):
gtk.VBox.__init__(self, False, 2)
self.entry = FilterEntry()
self.tree = AuditOutputTree()
self.toolbar = gtk.Toolbar()
self.toolbar.set_style(gtk.TOOLBAR_ICONS)
action = gtk.Action('save', _('Save log'),
_('Save log to file'), gtk.STOCK_SAVE)
action.connect('activate', self.tree.on_save_log)
item = action.create_tool_item()
self.toolbar.insert(item, -1)
item = gtk.ToolItem()
item.add(self.entry)
item.set_expand(True)
self.toolbar.insert(item, -1)
self.pack_start(self.toolbar, False, False)
self.pack_end(self.tree)
self.entry.get_entry().connect('changed', self.__on_filter)
def _addCustomToolbar(fig):
#fig.canvas.toolbar = CustomToolbar(fig.canvas, fig)
# Start location varies depending on version, so you might want to change
# this value.
tb = fig.canvas.toolbar
if useGtk:
# Change axis
a = gtk.Entry(40)
ti = gtk.ToolItem()
ti.add(a)
#ti.set_visible(True)
#a.set_visible(True)
ti.show_all()
a.connect('activate', _changeAxis, fig)
a.set_editable(True)
a.set_text('auto')
a.set_tooltip_text(
"Change the axis:\n'on', 'off', 'equal', 'tight', 'auto'\n'x:xmin,xmax', 'y:ymin,ymax'\n'xmin,xmax,ymin,ymax'"
)
a.grab_focus()
tb.insert(ti, 0)
_addButton(tb, 'Clip', _copyToClipboard, fig,
'Copy figure to system clipboard')
tb.update()
tb.show_all()
fig.canvas.draw()
def _addButton(tb, label, callback, fig, tooltip):
button = gtk.Button(label)
button.connect('clicked', callback, fig)
button.set_tooltip_text(tooltip)
ti = gtk.ToolItem()
ti.add(button)
tb.insert(ti, 0)
def __init__(self, label):
gtk.Toolbar.__init__(self)
self.modify_bg(gtk.STATE_NORMAL, get_colors("window"))
self.titulo = label
self.escala = SlicerBalance()
item = gtk.ToolItem()
item.set_expand(True)
self.frame = gtk.Frame()
self.frame.set_border_width(4)
self.frame.set_label(self.titulo)
self.frame.get_property("label-widget").modify_fg(
0, get_colors("drawingplayer"))
self.frame.set_label_align(0.5, 1.0)
event = gtk.EventBox()
event.set_border_width(4)
event.modify_bg(gtk.STATE_NORMAL, get_colors("window"))
event.add(self.escala)
self.frame.add(event)
self.frame.show_all()
item.add(self.frame)
self.insert(item, -1)
self.show_all()
self.escala.connect("user-set-value", self.__user_set_value)
def __init__(self):
gtk.Toolbar.__init__(self)
self.back = ToolButton('go-previous')
self.back.set_tooltip(_('Back'))
self.back.props.sensitive = False
self.insert(self.back, -1)
self.back.show()
self.forward = ToolButton('go-next')
self.forward.set_tooltip(_('Forward'))
self.forward.props.sensitive = False
self.insert(self.forward, -1)
self.forward.show()
num_page_item = gtk.ToolItem()
self.num_page_entry = gtk.Entry()
self.num_page_entry.set_text('0')
self.num_page_entry.set_alignment(1)
self.num_page_entry.connect('insert-text',
self.num_page_entry_insert_text_cb)
self.num_page_entry.set_width_chars(4)
num_page_item.add(self.num_page_entry)
self.num_page_entry.show()
self.insert(num_page_item, -1)
num_page_item.show()
total_page_item = gtk.ToolItem()
self.total_page_label = gtk.Label()
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(
pango.AttrForeground(65535, 65535, 65535, 0, -1))
self.total_page_label.set_attributes(label_attributes)
self.total_page_label.set_text(' / 0')
total_page_item.add(self.total_page_label)
self.total_page_label.show()
self.insert(total_page_item, -1)
total_page_item.show()
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)
def insert_combo(self):
"""
Inserta el 'ComboOfDirectories' en la 'ContextToolbar'.
"""
item = gtk.ToolItem()
item.add(self._mwindow.get_combo())
item.show_all()
self.insert(item, 9)
def build_toolbar(self):
self.max_participants = 1
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, -1)
activity_button.show()
# toolbars
self.build_size_toolbar(toolbar_box)
self.build_colors_toolbar(toolbar_box)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
#current
item = gtk.ToolItem()
label = gtk.Label()
label.set_text(' %s ' % _('Current player:'))
item.add(label)
toolbar_box.toolbar.insert(item, -1)
#player
item = gtk.ToolItem()
self.current_label = gtk.Label()
self.current_label.set_text(' %s ' % _('Player 1'))
item.add(self.current_label)
toolbar_box.toolbar.insert(item, -1)
# end separator
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.show_all()
def __init__(self, tabla, main=None):
#conjunto de botones para navegar y actuar sobre la tabla
gtk.HButtonBox.__init__(self)
self.main = main
self.tabla = tabla
self.estado = 'consultar'
self.set_homogeneous(False)
# METEMOS LOS BOTONES
self.principio = gtk.Button('<<')
self.add(self.principio)
self.principio.connect_object("clicked", self.movimiento,
self.principio)
self.atras = gtk.Button('<')
self.add(self.atras)
self.atras.connect_object("clicked", self.movimiento, self.atras)
self.delante = gtk.Button('>')
self.add(self.delante)
self.delante.connect_object("clicked", self.movimiento, self.delante)
self.fin = gtk.Button('>>')
self.add(self.fin)
self.fin.connect_object("clicked", self.movimiento, self.fin)
self.editar = gtk.Button('Editar')
self.add(self.editar)
self.editar.connect_object("clicked", self.control, self.editar)
self.borrar = gtk.Button('Borrar')
self.add(self.borrar)
self.borrar.connect_object("clicked", self.control, self.borrar)
self.alta = gtk.Button('Alta')
self.add(self.alta)
self.alta.connect_object("clicked", self.control, self.alta)
self.aplicar = gtk.Button('Aplicar')
self.add(self.aplicar)
self.aplicar.connect_object("clicked", self.control, self.aplicar)
self.cancelar = gtk.Button('Cancelar')
self.add(self.cancelar)
self.cancelar.connect_object("clicked", self.control, self.cancelar)
if main is not None:
#crea un toolbar en la ventana que contiene al navegador,
#donde representamos el numero de registro visualizado.
self.lestado = gtk.Label('inicio')
labelitem = gtk.ToolItem()
labelitem.add(self.lestado)
self.toolb = gtk.Toolbar()
self.toolb.insert(labelitem, 0)
main.vbox.pack_start(self.toolb, False, True)
self.lestado.show()
labelitem.show()
self.toolb.show()
self.atras.show()
self.delante.show()
self.principio.show()
self.fin.show()
self.editar.show()
self.borrar.show()
self.alta.show()
self.show()
self.actualizar_widget()
def load_toolbar(self):
self.context = self.emit("load-pango-context")
self.family_combo = ComboBox()
family_renderer = gtk.CellRendererText()
family_renderer.set_property("family-set", True)
self.family_combo.pack_start(family_renderer)
self.family_combo.add_attribute(family_renderer, 'text', 0)
self.family_combo.add_attribute(family_renderer, 'family', 0)
self.family_model = gtk.ListStore(str)
monospace_index = 0
count = 0
self.faces = {}
for i in self.context.list_families():
name = i.get_name()
monospace_index = count if name == "Monospace" else 0
count += 1
self.family_model.append([name])
family_faces = gtk.ListStore(str, str)
for face in i.list_faces():
face_name = face.get_face_name()
family_faces.append([face_name, "%s %s" % (name, face_name)])
self.faces[name] = family_faces
self.family_combo.set_model(self.family_model)
self.family_combo.set_active(monospace_index)
self.family_combo.connect("changed", self.family_changed)
self.family_combo.show()
self.family_tool_item = ToolComboBox(self.family_combo)
self.family_tool_item.show()
self.toolbar.insert(self.family_tool_item, -1)
self.face_combo = ComboBox()
face_renderer = gtk.CellRendererText()
face_renderer.set_property("family-set", True)
self.face_combo.pack_start(face_renderer)
self.face_combo.add_attribute(face_renderer, 'text', 0)
self.face_combo.add_attribute(face_renderer, 'font', 1)
current_model = self.faces["Monospace"]
self.face_combo.set_model(current_model)
self.face_combo.set_active(0)
self.face_combo.connect("changed", self.face_changed)
self.face_combo.show()
self.face_tool_item = ToolComboBox(self.face_combo)
self.face_tool_item.show()
self.toolbar.insert(self.face_tool_item, -1)
self.size_adj = gtk.Adjustment(value=10,
lower=5,
upper=100,
step_incr=1)
self.size_adj.connect("value-changed", self.size_changed)
self.size_spin = gtk.SpinButton(self.size_adj)
self.size_spin.show()
self.size_spin_item = gtk.ToolItem()
self.size_spin_item.add(self.size_spin)
self.size_spin_item.show()
self.toolbar.insert(self.size_spin_item, -1)
self.toolbar.show()
def _build_toolbar_label(self, info, label):
ti = gtk.ToolItem()
b = gtk.HBox()
l = gtk.Label(info)
b.pack_start(l, False, False, 5)
lbl = gtk.Label(label)
b.pack_start(lbl, False, False, 5)
ti.add(b)
return (lbl, ti)
def __init__(self, parent_xid, dialog_title):
gtk.Window.__init__(self)
self.connect('realize', self.__realize_cb)
self.set_decorated(False)
self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.set_border_width(style.LINE_WIDTH)
width = gtk.gdk.screen_width() - style.GRID_CELL_SIZE * 4
height = gtk.gdk.screen_height() - style.GRID_CELL_SIZE * 4
self.set_size_request(width, height)
self._parent_window_xid = parent_xid
_vbox = gtk.VBox(spacing=2)
self.add(_vbox)
self.toolbar = gtk.Toolbar()
label = gtk.Label()
label.set_markup('<b> %s</b>' % dialog_title)
label.set_alignment(0, 0.5)
tool_item = gtk.ToolItem()
tool_item.add(label)
label.show()
self.toolbar.insert(tool_item, -1)
tool_item.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.toolbar.insert(separator, -1)
separator.show()
stop = ToolButton(icon_name='dialog-cancel')
stop.set_tooltip(_('Cancel'))
stop.connect('clicked', lambda *w: self.destroy())
self.toolbar.insert(stop, -1)
stop.show()
delete = ToolButton(icon_name='edit-delete')
delete.set_tooltip(_('Delete'))
delete.connect('clicked', self.accept_clicked_delete_cb)
self.toolbar.insert(delete, -1)
delete.show()
accept = ToolButton(icon_name='dialog-ok')
accept.set_tooltip(_('Ok'))
accept.connect('clicked', self.accept_clicked_cb)
accept.show()
self.toolbar.insert(accept, -1)
_vbox.pack_start(self.toolbar, expand=False)
self.toolbar.show()
self._event_box = gtk.EventBox()
_vbox.pack_start(self._event_box, expand=True, fill=True)
self._canvas = None
def build_widget(self):
mapping = {
'webkit': webkit_wrapper,
'mozembed': mozembed_wrapper,
'gtkhtml2': gtkhtml_wrapper,
None: None
}
wrapper = mapping.get(engine)
if wrapper is None:
w = gtk.Label(_("No available HTML rendering component"))
self.component = w
else:
self.component = wrapper(controller=self.controller,
notify=self.notify)
w = self.component.widget
def utbv_menu(*p):
if self.controller and self.controller.gui:
m = self.controller.gui.build_utbv_menu(action=self.open_url)
m.popup(None, None, None, 0, gtk.get_current_event_time())
return True
tb = gtk.Toolbar()
tb.set_style(gtk.TOOLBAR_ICONS)
for icon, action in (
(gtk.STOCK_GO_BACK, self.component.back),
(gtk.STOCK_REFRESH, self.component.refresh),
(gtk.STOCK_HOME, utbv_menu),
):
b = gtk.ToolButton(stock_id=icon)
b.connect('clicked', action)
tb.insert(b, -1)
def entry_validated(e):
self.component.set_url(self.current_url())
return True
self.url_entry = gtk.Entry()
self.url_entry.connect('activate', entry_validated)
ti = gtk.ToolItem()
ti.add(self.url_entry)
ti.set_expand(True)
tb.insert(ti, -1)
vbox = gtk.VBox()
vbox.pack_start(tb, expand=False)
vbox.add(w)
self.url_label = gtk.Label('')
self.url_label.set_alignment(0, 0)
vbox.pack_start(self.url_label, expand=False)
return vbox
def CreateInstrumentBar(self):
self.instrumentBar = gtk.Toolbar()
self.instrumentBar.set_show_arrow(True)
self.instrumentBar.set_style(gtk.TOOLBAR_BOTH_HORIZ)
toollab = gtk.ToolItem()
lab = gtk.Label()
lab.set_markup(_("<b>Instruments Not Shown:</b>"))
toollab.add(lab)
toollab.set_is_important(True)
self.instrumentBar.insert(toollab, 0)
def labelFactory(label_text, toolbar):
''' Factory for adding a label to a toolbar '''
label = gtk.Label(label_text)
label.set_line_wrap(True)
label.show()
toolitem = gtk.ToolItem()
toolitem.add(label)
toolbar.insert(toolitem, -1)
toolitem.show()
return label
def label_factory(label, toolbar):
''' Factory for adding a label to a toolbar '''
my_label = gtk.Label(label)
my_label.set_line_wrap(True)
my_label.show()
toolitem = gtk.ToolItem()
toolitem.add(my_label)
toolbar.insert(toolitem, -1)
toolitem.show()
return my_label
def __init__(self, tipo="gnome", proyecto=None):
gtk.Frame.__init__(self)
self.set_label(" Selecciona un Icono para Tu Aplicación ")
self.set_border_width(15)
self.tipo = tipo # FIXME: tipo debe determinar que formato de ico se permite (svg para sugar)
self.proyecto = proyecto
toolbar = gtk.Toolbar()
self.image = gtk.Image()
self.image.set_size_request(50, 50)
boton = get_boton(gtk.STOCK_OPEN, "Buscar Archivo")
self.aceptar = gtk.Button("Construir Instalador")
self.aceptar.set_sensitive(False)
toolbar.insert(get_separador(draw=False, ancho=10, expand=False), -1)
item = gtk.ToolItem()
item.add(self.image)
toolbar.insert(item, -1)
toolbar.insert(get_separador(draw=False, ancho=10, expand=False), -1)
toolbar.insert(boton, -1)
toolbar.insert(get_separador(draw=False, ancho=0, expand=True), -1)
item = gtk.ToolItem()
item.add(self.aceptar)
toolbar.insert(item, -1)
toolbar.insert(get_separador(draw=False, ancho=10, expand=False), -1)
self.add(toolbar)
self.show_all()
boton.connect("clicked", self.__open_filechooser)
self.aceptar.connect("clicked", self.__Construir)
