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_toolbar(self, toolbars):
gtktoolbar = super(Form, self).create_toolbar(toolbars)
attach_btn = self.buttons['attach']
target_entry = gtk.TargetEntry.new('text/uri-list', 0, 0)
attach_btn.drag_dest_set(gtk.DEST_DEFAULT_ALL, [
target_entry,
], gtk.gdk.ACTION_MOVE | gtk.gdk.ACTION_COPY)
attach_btn.connect('drag_data_received',
self.attach_drag_data_received)
iconstock = {
'print': 'tryton-print',
'action': 'tryton-executable',
'relate': 'tryton-go-jump',
'email': 'tryton-print-email',
'open': 'tryton-print-open',
}
for action_type, special_action, action_name, tooltip in (
('action', 'action', _('Action'), _('Launch action')),
('relate', 'relate', _('Relate'), _('Open related records')),
(None, ) * 4,
('print', 'open', _('Report'), _('Open report')),
('print', 'email', _('E-Mail'), _('E-Mail report')),
('print', 'print', _('Print'), _('Print report')),
):
if action_type is not None:
tbutton = gtk.ToggleToolButton(iconstock.get(special_action))
tbutton.set_label(action_name)
tbutton._menu = self._create_popup_menu(
tbutton, action_type, toolbars[action_type],
special_action)
tbutton.connect('toggled', self.action_popup)
self.tooltips.set_tip(tbutton, tooltip)
self.buttons[special_action] = tbutton
if action_type != 'action':
tbutton._can_be_sensitive = bool(
tbutton._menu.get_children())
else:
tbutton = gtk.SeparatorToolItem()
gtktoolbar.insert(tbutton, -1)
gtktoolbar.insert(gtk.SeparatorToolItem(), -1)
url_button = gtk.ToggleToolButton('tryton-web-browser')
url_button.set_label(_('_Copy URL'))
url_button.set_use_underline(True)
self.tooltips.set_tip(url_button, _('Copy URL into clipboard'))
url_button._menu = url_menu = gtk.Menu()
url_menuitem = gtk.MenuItem()
url_menuitem.connect('activate', self.url_copy)
url_menu.add(url_menuitem)
url_menu.show_all()
url_menu.connect('deactivate', self._popup_menu_hide, url_button)
url_button.connect('toggled', self.url_set, url_menuitem)
url_button.connect('toggled', self.action_popup)
self.buttons['copy_url'] = url_button
gtktoolbar.insert(url_button, -1)
return gtktoolbar
def __init__(self):
gtk.EventBox.__init__(self)
self.set_border_width(4)
toolbar = gtk.Toolbar()
self.modify_bg(gtk.STATE_NORMAL, COLORES["toolbar"])
toolbar.modify_bg(gtk.STATE_NORMAL, COLORES["toolbar"])
toolbar.modify_fg(gtk.STATE_NORMAL, COLORES["text"])
item = gtk.ToolItem()
item.set_expand(True)
imagen = gtk.Image()
imagen.set_from_file("Imagenes/ple.png")
self.homebutton = gtk.ToggleToolButton()
self.homebutton.set_label_widget(imagen)
self.homebutton.connect("toggled", self.__go_home)
item.add(self.homebutton)
toolbar.insert(item, -1)
separador = gtk.SeparatorToolItem()
separador.props.draw = True
toolbar.insert(separador, -1)
item = gtk.ToolItem()
item.set_expand(True)
label = gtk.Label("Instructions")
label.modify_font(pango.FontDescription("DejaVu Sans Bold 16"))
label.modify_fg(gtk.STATE_NORMAL, COLORES["text"])
self.instructionsbutton = gtk.ToggleToolButton()
self.instructionsbutton.set_label_widget(label)
self.instructionsbutton.connect("toggled", self.__go_instructions)
item.add(self.instructionsbutton)
toolbar.insert(item, -1)
separador = gtk.SeparatorToolItem()
separador.props.draw = True
toolbar.insert(separador, -1)
self.menu = Menu()
self.menubutton = PopupMenuButton("Topics")
self.menubutton.child.modify_font(pango.FontDescription("DejaVu Sans Bold 16"))
self.menubutton.child.modify_fg(gtk.STATE_NORMAL, COLORES["text"])
self.menubutton.child.modify_bg(gtk.STATE_NORMAL, COLORES["toolbar"])
self.menubutton.set_menu(self.menu)
item = gtk.ToolItem()
item.set_expand(True)
item.add(self.menubutton)
toolbar.insert(item, -1)
self.add(toolbar)
self.show_all()
self.menu.connect("activar", self.__emit_accion_menu)
def __init__(self, graph, mydot, core):
gtk.VBox.__init__(self)
self.graph = graph
self.mydot = mydot
self.uicore = core
self.toolbox = self
b = SemiStockButton("", gtk.STOCK_ZOOM_IN, 'Zoom In')
b.connect("clicked", self._zoom, "in")
self.toolbox.pack_start(b, False, False)
b = SemiStockButton("", gtk.STOCK_ZOOM_OUT, 'Zoom Out')
b.connect("clicked", self._zoom, "out")
self.toolbox.pack_start(b, False, False)
b = SemiStockButton("", gtk.STOCK_ZOOM_FIT, 'Zoom Fit')
b.connect("clicked", self._zoom, "fit")
self.toolbox.pack_start(b, False, False)
b = SemiStockButton("", gtk.STOCK_ZOOM_100, 'Zoom 100%')
b.connect("clicked", self._zoom, "100")
self.toolbox.pack_start(b, False, False)
# Separator
self.sep = gtk.HSeparator()
self.toolbox.pack_start(self.sep, False, False)
# Change between Callgraph and Flowgraph
if self.uicore.backend == 'radare':
self.grpah_layout = gtk.ToggleToolButton(
stock_id=gtk.STOCK_FULLSCREEN)
self.grpah_layout.connect("clicked", self._change_layout)
self.toolbox.pack_start(self.grpah_layout, False, False)
# Grayed?
self.toolbox.set_sensitive(True)
self.show_all()
def create_toolbar(self, toolbars):
gtktoolbar = super(Form, self).create_toolbar(toolbars)
iconstock = {
'print': 'tryton-print',
'action': 'tryton-executable',
'relate': 'tryton-go-jump',
'email': 'tryton-print-email',
'open': 'tryton-print-open',
}
for action_type, special_action, action_name, tooltip in (
('action', 'action', _('Action'), _('Launch action')),
('relate', 'relate', _('Relate'), _('Open related records')),
(None,) * 4,
('print', 'open', _('Report'), _('Open report')),
('print', 'email', _('E-Mail'), _('E-Mail report')),
('print', 'print', _('Print'), _('Print report')),
):
if action_type is not None:
tbutton = gtk.ToggleToolButton(iconstock.get(special_action))
tbutton.set_label(action_name)
tbutton._menu = self._create_popup_menu(tbutton,
action_type, toolbars[action_type], special_action)
tbutton.connect('toggled', self.action_popup)
self.tooltips.set_tip(tbutton, tooltip)
self.buttons[special_action] = tbutton
tbutton._can_be_sensitive = bool(tbutton._menu.get_children())
else:
tbutton = gtk.SeparatorToolItem()
gtktoolbar.insert(tbutton, -1)
return gtktoolbar
def onTaskOpened(self, plugin_api):
image_geolocalization_path = os.path.join(
self.plugin_path, "icons/hicolor/24x24/\
geolocalization.png")
pixbuf_geolocalization = gtk.gdk.pixbuf_new_from_file_at_size(
image_geolocalization_path, 24, 24)
# create the image and associate the pixbuf
icon_geolocalization = gtk.Image()
icon_geolocalization.set_from_pixbuf(pixbuf_geolocalization)
icon_geolocalization.show()
# toolbar button for the location_view
btn_location_view = gtk.ToggleToolButton()
btn_location_view.set_icon_widget(icon_geolocalization)
btn_location_view.set_label("Location View")
self.task_separator = plugin_api.add_task_toolbar_item(
gtk.SeparatorToolItem())
btn_set_location = gtk.ToolButton()
btn_set_location.set_icon_widget(icon_geolocalization)
btn_set_location.set_label("Set/View location")
btn_set_location.connect('clicked', self.set_task_location, plugin_api)
self.btn_set_location = plugin_api.add_task_toolbar_item(
btn_set_location)
def append_toggle(self, stock, signal):
button = gtk.ToggleToolButton(stock)
button.set_active(True)
self.insert(button, self.position)
button.connect("clicked", self.clicked, signal)
self.install_signal(signal)
self.position += 1
def __init__(self, figure):
_gtk.Toolbar.__init__(self)
self.figure = figure
self.set_style(_gtk.TOOLBAR_BOTH_HORIZ)
savebutton = _gtk.ToolButton(_gtk.STOCK_SAVE_AS)
savebutton.connect("clicked", self.savefig)
self.insert(savebutton, 0)
lightbutton = _gtk.ToggleToolButton()
lightbutton.set_icon_widget(_gtk.Label('Lights'))
lightbutton.set_label('Lights')
lightbutton.connect("toggled", self.on_toggle_lights)
self.insert(lightbutton, -1)
self.lights_window = LightsWindow(self.figure, lightbutton)
sep = _gtk.SeparatorToolItem()
sep.set_expand(True)
sep.set_property('draw', False)
self.insert(sep, -1)
ti = _gtk.ToolItem()
self.view_lab = _gtk.Label()
self.view_lab.set_justify(_gtk.JUSTIFY_RIGHT)
ti.add(self.view_lab)
self.insert(ti, -1)
self.connect("destroy", self.on_destroy)
def configWindow(self, title, x, y):
self.set_size_request(x, y)
self.set_position(gtk.WIN_POS_CENTER)
self.connect("destroy", self.quit)
self.set_title(title)
self.vbox = gtk.VBox(False, 8)
self.toolbar = gtk.Toolbar()
self.toolbar.set_style(gtk.TOOLBAR_ICONS)
self.tbClean = gtk.ToolButton(gtk.STOCK_CLEAR)
self.tbAutoScroll = gtk.ToggleToolButton(gtk.STOCK_GOTO_BOTTOM)
self.tbAutoScroll.set_active(self.AScroll)
self.toolbar.insert(self.tbClean, 0)
self.toolbar.insert(self.tbAutoScroll, 1)
self.vbox.pack_start(self.toolbar, False, False, 0)
self.tbClean.connect("clicked", self.clean)
self.tbAutoScroll.connect("clicked", self.autoScroll)
self.area = gtk.DrawingArea()
self.area.set_size_request(x, 50)
self.area.connect("expose-event", self.expose)
self.vbox.pack_start(self.area, False, False, 0)
self.sw = gtk.ScrolledWindow()
self.sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.vbox.pack_start(self.sw, True, True, 0)
self.statusbar = gtk.Statusbar()
self.vbox.pack_start(self.statusbar, False, False, 0)
self.add(self.vbox)
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 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 __init__(self):
self.flag_enable_xmlrpc = True
self.xmlrpc_server = None
self._server_toggle_btn = None
self._current_model = None
toolbar = coot_python.main_toolbar()
port = 40000
if ("COOT_XMLRPC_PORT" in os.environ):
port = string.atoi(os.environ["COOT_XMLRPC_PORT"])
try:
self.xmlrpc_server = coot_xmlrpc_server(interface=self,
addr=("127.0.0.1", port))
self.xmlrpc_server.socket.settimeout(0.01)
except Exception as e:
print("Error starting XML-RPC server:")
print(str(e))
else:
import gobject
import gtk
print("xml-rpc server running on port %d" % port)
# timeout used to be set to whatever the Phenix preferences have it as,
# but 250ms seems to be a universally good choice, and much shorter
# intervals screw up the Coot GUI (at least on Windows)
gobject.timeout_add(250, self.timeout_func)
if (toolbar is not None):
self._server_toggle_btn = gtk.ToggleToolButton()
self._server_toggle_btn.set_label("Connected to PHENIX")
self._server_toggle_btn.set_is_important(True)
toolbar.insert(self._server_toggle_btn, -1)
self._server_toggle_btn.connect("clicked", self.toggle_update)
self._server_toggle_btn.set_active(True)
self._server_toggle_btn.show()
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 __init__(self, callback):
'''
Конструктор панели
:param callback: Метод-коллбек, который будет вызван при возникновении
события. В качестве параметра будет передан объект PathEvent
'''
gtk.HBox.__init__(self)
self.callback = callback
self.longest_common_path = None
self.path = None
self.pathHBox = gtk.HBox()
self.editBtn = gtk.ToggleToolButton(gtk.STOCK_EDIT)
self.editBtn.connect('clicked', self.__edit_clicked__)
#self.editBtn.set_size_request(32,32)
self.pathEntry = gtk.Entry()
self.completion = gtk.EntryCompletion()
self.pathEntry.set_completion(self.completion)
self.pathEntry.hide()
self.pathEntry.connect('focus-out-event', self.__edit_focus_out__)
self.pathEntry.connect('key-release-event', self.__edit_key_released__)
self.historyBtn = gtk.ToolButton(gtk.STOCK_GO_DOWN)
self.favBtn = gtk.ToolButton(gtk.STOCK_ABOUT)
self.pack_start(self.editBtn, False, False)
self.pack_start(self.pathHBox, True, True)
self.pack_start(self.pathEntry, True, True)
# self.pack_start(self.historyBtn, False, False)
# self.pack_start(self.favBtn, False, False)
# self.historyBtn.show()
# self.favBtn.show()
self.set_no_show_all(True)
def create_base_toolbar(self, toolbar):
previous = None
for item in self.menu_def:
if item and item.toolbar:
callback = getattr(self, 'sig_%s' % item.id, None)
if not callback:
continue
if item.toggle:
toolitem = gtk.ToggleToolButton()
toolitem.connect('toggled', callback)
else:
toolitem = gtk.ToolButton()
toolitem.connect('clicked', callback)
toolitem.set_icon_widget(
common.IconFactory.get_image(
item.icon_name, gtk.ICON_SIZE_LARGE_TOOLBAR))
toolitem.set_label(item.label)
toolitem.set_use_underline(True)
self.tooltips.set_tip(toolitem, item.tooltip)
self.buttons[item.id] = toolitem
elif not item and previous:
toolitem = gtk.SeparatorToolItem()
else:
continue
previous = item
toolbar.insert(toolitem, -1)
def _toolbar(self):
toolbar = gtk.Toolbar()
button = gtk.RadioToolButton(None)
button.set_tooltip_text("Start transition")
button.set_stock_id(gtk.STOCK_GO_FORWARD)
toolbar.add(button)
self.button_run_phase1 = button
button = gtk.RadioToolButton(self.button_run_phase1, None)
button.set_tooltip_text("Start & finish transition")
button.set_stock_id(gtk.STOCK_GOTO_LAST)
toolbar.add(button)
self.button_run_phase12 = button
toolbar.add(gtk.SeparatorToolItem())
button = gtk.ToolButton(None)
button.set_tooltip_text("Receive all packets")
button.set_stock_id(gtk.STOCK_GOTO_BOTTOM)
button.connect("clicked",
lambda w: self.simulation.receive_all(
self.netview.get_perspective().get_process_ids()))
toolbar.add(button)
button = gtk.ToggleToolButton(None)
button.set_tooltip_text(
"Automatically call 'Receive all packets' after any transition action")
button.set_stock_id(gtk.STOCK_EXECUTE)
toolbar.add(button)
self.button_auto_receive = button
return toolbar
def __init__(self, gui):
super(PlayerSlot, self).__init__(1, 15, True)
self.gmgb_gui = gui
self.mediaPlayer = gmgbPlayer(self)
self.fb_needs_reload = False # workaround flag for gtk drag-drop bug
self.fb = gtk.FileChooserButton("select a audio file", backend=None)
self.fileFilter = gtk.FileFilter()
self.fileFilter.set_name("Audio Files")
self.fileFilter.add_pattern("*.ogg")
self.fileFilter.add_pattern("*.mp3")
self.fileFilter.add_pattern("*.wav")
self.fb.set_filter(self.fileFilter)
self.fb.connect("file-set", self.load_file)
#self.fb.connect("drag-motion",self.load_file_drag_motion)
#self.fb.connect("drag-leave",self.load_file_drag_leave)
self.attach(self.fb, 0, 4, 0, 1)
self.playButton = gtk.ToggleToolButton(gtk.STOCK_MEDIA_PLAY)
self.playButton.set_sensitive(False)
self.playButton.connect("toggled", self.toggle_play)
self.attach(self.playButton, 4, 5, 0, 1)
self.loopButton = gtk.ToggleToolButton(gtk.STOCK_UNDO)
self.loopButton.set_sensitive(False)
self.loopButton.connect("toggled", self.toggle_loop)
self.attach(self.loopButton, 5, 6, 0, 1)
self.playbackSlider = gtk.HScale()
self.playbackSlider.set_sensitive(False)
self.playbackSlider.set_draw_value(False)
self.playbackSlider.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
self.playbackSlider_dragged = False
self.playbackSlider.connect("button-press-event",
self.slider_button_press)
self.playbackSlider.connect("button-release-event",
self.slider_button_release)
self.attach(self.playbackSlider, 6, 14, 0, 1)
self.volumeButton = gtk.VolumeButton()
self.volumeButton.set_sensitive(False)
self.volumeButton.connect("value-changed", self.volume_change)
self.attach(self.volumeButton, 14, 15, 0, 1)
def _toolbar_togglebtn(self, toolbar, text, image, position, met):
""" Add toggle button to the defined toolbar referenced through toolbar. Additionally the text, image, position and method can be defined. """
btn = gtk.ToggleToolButton()
btn.set_icon_widget(image)
btn.set_label(text)
btn.set_tooltip(gtk.Tooltips(), text)
btn.connect('clicked', met)
toolbar.insert(btn, position)
btn.show()
def new_toggle_button(self, label, filter):
togglebutton = gtk.ToggleToolButton()
togglebutton.set_label(label)
togglebutton.set_tooltip(self.tooltips, label)
icon = 'gnome-mime-' + filter
icon_widget = gtk.image_new_from_icon_name(icon, gtk.ICON_SIZE_MENU)
togglebutton.set_icon_widget(icon_widget)
togglebutton.filter_value = filter
return togglebutton
def __init__(self):
super(PyApp, self).__init__()
self.set_title('Incf button')
self.set_default_size(250, 200)
self.set_position(gtk.WIN_POS_CENTER)
vbox = gtk.VBox()
self.btn1 = gtk.ToggleToolButton('Button 1')
self.btn1.connect('toggled', self.on_toggled)
self.btn2 = gtk.ToggleToolButton('Button 2')
self.lbl = gtk.Label()
vbox.add(self.btn1)
vbox.add(self.btn2)
vbox.add(self.lbl)
self.add()
self.connect('destroy', gtk.main_quit)
self.show_all()
def __create_widgets(self):
"""
"""
self.__tools_menu = ToolsMenu(self.radialnet)
self.__tools_button = gtk.MenuToolButton(gtk.STOCK_PREFERENCES)
self.__tools_button.set_label(_("Tools"))
self.__tools_button.set_is_important(True)
self.__tools_button.set_menu(self.__tools_menu)
self.__tools_button.connect('clicked', self.__tools_callback)
self.__control = gtk.ToggleToolButton(gtk.STOCK_PROPERTIES)
self.__control.set_label(_("Controls"))
self.__control.set_is_important(True)
self.__control.connect('clicked', self.__control_callback)
self.__control.set_tooltip_text(_("Show control panel"))
self.__control.set_active(False)
self.__fisheye = gtk.ToggleToolButton(gtk.STOCK_ZOOM_FIT)
self.__fisheye.set_label(_("Fisheye"))
self.__fisheye.set_is_important(True)
self.__fisheye.connect('clicked', self.__fisheye_callback)
self.__fisheye.set_tooltip_text(_("Enable fisheye"))
self.__fisheye.set_active(False)
self.__fullscreen = gtk.ToggleToolButton(gtk.STOCK_FULLSCREEN)
self.__fullscreen.set_label(_("Fullscreen"))
self.__fullscreen.set_is_important(True)
self.__fullscreen.connect('clicked', self.__fullscreen_callback)
self.__fullscreen.set_tooltip_text(_("Toggle fullscreen"))
self.__separator = gtk.SeparatorToolItem()
self.__expander = gtk.SeparatorToolItem()
self.__expander.set_expand(True)
self.__expander.set_draw(False)
self.insert(self.__tools_button, 0)
self.insert(self.__expander, 1)
self.insert(self.__control, 2)
self.insert(self.__fisheye, 3)
self.insert(self.__fullscreen, 4)
gobject.timeout_add(REFRESH_RATE, self.__update)
def init(self, context):
BaseOutlineView.init(self, context)
self._offset_map = OutlineOffsetMap()
# additional toolbar buttons
btn_graphics = gtk.ToggleToolButton()
btn_graphics.set_icon_widget(gtk.image_new_from_file(find_resource("icons/tree_includegraphics.png")))
btn_graphics.set_tooltip_text("Show graphics")
self._toolbar.insert(btn_graphics, -1)
btn_tables = gtk.ToggleToolButton()
btn_tables.set_icon_widget(gtk.image_new_from_file(find_resource("icons/tree_table.png")))
btn_tables.set_tooltip_text("Show tables")
self._toolbar.insert(btn_tables, -1)
btn_graphics.set_active(Preferences().get_bool("ShowGraphicsInOutline", True))
btn_tables.set_active(Preferences().get_bool("ShowTablesInOutline", True))
self._handlers[btn_graphics] = btn_graphics.connect("toggled", self._on_graphics_toggled)
self._handlers[btn_tables] = btn_tables.connect("toggled", self._on_tables_toggled)
def __init__(self):
gtk.Toolbar.__init__(self)
self._mask = False
for lesson in lessons.THEMES:
button = gtk.ToggleToolButton()
button.set_label(lesson.name)
button.connect('clicked', self._lessons_cb, lesson)
self.insert(button, -1)
self.get_nth_item(0).set_active(True)
self.show_all()
def __init_view(self):
"""Load the widgets."""
gtk.VBox.__init__(self)
self.__sw = gtk.ScrolledWindow()
self.pack_start(self.__sw)
self.__sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.__view = gtk.TreeView(self.__model)
self.__view.set_rules_hint(True)
self.__view.set_enable_search(False)
self.__view.set_model(self.__model)
self.__sw.add(self.__view)
self.__view.set_headers_visible(False)
for column in self.__init_renderers():
self.__view.append_column(column)
if self.SORT_CONTROLS == True:
sb = gtk.Expander()
self.pack_start(sb, expand=False)
l = gtk.Label('Sort')
sb.set_label_widget(l)
hb = gtk.HBox()
sb.add(hb)
self.__sortcombo = gtk.combo_box_new_text()
hb.pack_start(self.__sortcombo)
if self.SORT_AVAILABLE is not None:
self.sort_available = dict(self.SORT_AVAILABLE)
for attr, val in self.SORT_AVAILABLE:
self.__sortcombo.append_text(attr)
self.__sortdir = gtk.ToggleToolButton(
stock_id=gtk.STOCK_SORT_DESCENDING)
hb.pack_start(self.__sortdir, expand=False)
self.__sortdir.set_active(True)
self.__sortcombo.set_active(0)
self.__sortdir.connect('toggled', self.cb_sortdir_toggled)
self.__sortcombo.connect('changed', self.cb_sortcombo_changed)
self.__user_initiated_sort()
if self.EDIT_BOX == True:
self.__editbox = QuestionBox()
self.pack_start(self.__editbox, expand=False)
if self.EDIT_BUTTONS == True:
self.__toolbar = toolbar.Toolbar()
self.__toolbar.add_button('new', 'new', 'new', True)
self.__toolbar.add_button('delete', 'delete', 'delete', True)
self.__toolbar.add_button('edit', 'edit', 'Edit this item.', True)
self.__toolbar.connect('clicked', self.cb_toolbar_clicked)
self.pack_start(self.__toolbar, expand=False)
self.__init_signals()
if self.SORT_BY is not None:
self.sort_by([self.SORT_BY])
if self.SORT_LIST is not None:
self.sort_by(self.SORT_LIST)
self.show_all()
def __populate__(self):
# The main box.
self.win = gtk.VBox()
self.win.show()
# The tool bar.
self.bar = gtk.HBox()
self.win.pack_start(self.bar, expand=False)
self.bar.show()
## The control bar.
self.ctlbar = gtk.HBox()
self.bar.pack_start(self.ctlbar)
self.ctlbar.show()
# detach button
eb = gtk.EventBox()
self.dtbut = gtk.ToggleToolButton(stock_id=None)
eb.add(self.dtbut)
self.ctlbar.pack_start(eb, expand=False)
ic = self.do_get_image(self.DICON[0])
self.dtbut.set_icon_widget(ic)
self.dtbut.connect('toggled', self.cb_toggledetatch)
self.do_set_tooltip(eb, self.DICON[1])
# The main title label.
self.label = gtk.Label(self.NAME)
self.ctlbar.pack_start(self.label, expand=False)
# The horizontal expander.
self.sepbar = gtkextra.Sepbar()
self.sepbar.connect(self.cb_sep_rclick, self.cb_sep_dclick)
self.ctlbar.pack_start(self.sepbar.win, padding=6)
# The shortcut bar.
self.shortbar = gtk.HBox()
self.bar.pack_start(self.shortbar, expand=False)
# The custom tool bar.
self.cusbar = gtkextra.Toolbar()
self.bar.pack_start(self.cusbar.win, expand=False)
# The holder for transient windows.
self.transwin = gtk.VBox()
# self.transwin.show()
self.win.pack_start(self.transwin, expand=False)
#message dialog
self.msgbox = gtkextra.Messagebox()
self.transwin.pack_start(self.msgbox.win, expand=False)
#question dialog
self.qstbox = gtkextra.Questionbox()
self.transwin.pack_start(self.qstbox.win, expand=False)
# The content area.
self.frame = gtk.VBox()
self.win.pack_start(self.frame)
# The toolbar popup menu.
self.toolbar_popup = gtkextra.Popup()
def toolbar_button(pixbuf=None, tooltips=None, tooltip=None, toggle=None):
image = gtk.Image()
image.set_from_pixbuf(pixbuf)
if ( toggle ):
button = gtk.ToggleToolButton()
else:
button = gtk.ToolButton()
button.set_icon_widget(image)
button.unset_flags(gtk.CAN_FOCUS)
if ( tooltips and tooltip ):
if ( gtk.pygtk_version < (2, 12, 0) ):
button.set_tooltip(tooltips, tooltip)
else:
button.set_tooltip_text(tooltip)
return button
def __init__(self, separator=False):
import coot # import dependency
import coot_python
import gtk
toolbar = coot_python.main_toolbar()
assert (toolbar is not None)
if (separator):
toolbar.insert(gtk.SeparatorToolItem(), -1)
self.h_button = gtk.ToggleToolButton()
self.h_button.set_label("Hydrogens off")
self.h_button.set_is_important(True)
toolbar.insert(self.h_button, -1)
self.h_button.connect("clicked", self.OnToggleHydrogens)
self.h_button.set_active(True)
self.h_button.show()
def build(self):
entries = self.create_entries()
index = 0
for entry in entries:
if entry is None:
button = gtk.SeparatorToolItem()
else:
action = self.actions[entry]
button = action.create_tool_item()
self.insert(button, index)
index += 1
btn = gtk.ToggleToolButton(gtk.STOCK_JUSTIFY_FILL)
btn.set_tooltip_text("Data view")
btn.set_active(config.bin_view)
btn.connect("toggled", self.docarea.change_view)
self.insert(btn, index)
def add_panel(self,title,tooltip_text=None,icon_name=None,panel=True,add_to_toolbar=True,use_other_monitor=True):
if panel:
p=FloatingPanel(title)
else:
p=FloatingWindow(title)
p.set_transient_for(self.mainframe.window)
p.set_destroy_with_parent(True)
if use_other_monitor:
p.move_to_other_monitor()
self.panels[title]=p
if icon_name:
p.toggle=gtk.ToggleToolButton(icon_name)
p.toggle.show()
if add_to_toolbar:
toolbar_helpers.add_item(self.mainframe.toolbar1,p.toggle,p.toggle_panel,title,tooltip_text)
return p
def get_ToggleToolButton(archivo, flip=False, rotacion=None,
pixels=24, tooltip_text=None):
button = gtk.ToggleToolButton()
imagen = gtk.Image()
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(archivo, pixels, pixels)
if flip:
pixbuf = pixbuf.flip(True)
if rotacion:
pixbuf = pixbuf.rotate_simple(rotacion)
imagen.set_from_pixbuf(pixbuf)
button.set_icon_widget(imagen)
imagen.show()
button.show()
if tooltip_text:
button.set_property("tooltip_text", tooltip_text)
return button
