def __init__(self, owner):
gtk.Toolbar.__init__(self)
self.owner = owner
self._insert_separator(True)
self.desktop = []
btn = RadioToolButton(group=None)
btn.set_named_icon('jam-preset1')
btn.connect('toggled', self.setDesktop, 0)
btn.set_tooltip(_('Desktop 1'))
self.insert(btn, -1)
self.desktop.append(btn)
for i in range(2, 11):
btn = RadioToolButton(group=self.desktop[0])
btn.set_named_icon('jam-preset%d' % i)
btn.connect('toggled', self.setDesktop, i - 1)
btn.set_tooltip(_('Desktop %d' % i))
self.insert(btn, -1)
self.desktop.append(btn)
self._insert_separator(True)
self.show_all()
def _page_new(self, tag_type):
def page_cb(widget, view_index, view):
lists.props.page = view_index
self._view_by_page[tag_type].freeze()
self._view_by_page[tag_type] = view
view.update()
model.this['tag_sidebar'][`tag_type`]['cloud_active'] = \
view_index == 1
vbox = gtk.VBox()
lists = gtk.Notebook()
lists.props.show_border = False
lists.props.show_tabs = False
vbox.pack_start(lists)
tree = Tree(tag_type)
tree.props.hover_selection = True
scrolled = gtk.ScrolledWindow()
scrolled.set_shadow_type(gtk.SHADOW_OUT)
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.add(tree)
lists.append_page(scrolled)
self._view_by_page[tag_type] = tree
cloud = Cloud(tag_type)
scrolled = gtk.ScrolledWindow()
scrolled.set_shadow_type(gtk.SHADOW_OUT)
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.add(cloud)
lists.append_page(scrolled)
toolbar = gtk.Toolbar()
toolbar.modify_bg(gtk.STATE_NORMAL,
style.COLOR_PANEL_GREY.get_gdk_color())
vbox.pack_end(toolbar, False)
tree_button = RadioToolButton(named_icon='view-list',
tooltip=_('Tree view'),
group=None)
tree_button.connect('toggled', page_cb, 0, tree)
toolbar.insert(tree_button, -1)
cloud_button = RadioToolButton(named_icon='view-cloud',
group=tree_button,
palette=CloudPalette(
_('Cloud view'), tag_type, cloud))
cloud_button.connect('toggled', page_cb, 1, cloud)
toolbar.insert(cloud_button, -1)
vbox.show_all()
if model.this['tag_sidebar'][ ` tag_type `]['cloud_active']:
cloud_button.props.active = True
def add_level_button(icon_name, tooltip, signal_name):
if levels:
button = RadioToolButton(named_icon=icon_name, group=levels[0])
else:
button = RadioToolButton(named_icon=icon_name)
levels.append(button)
toolbar.add(button)
def callback(source):
if source.get_active():
self.emit(signal_name)
button.connect('clicked', callback)
button.set_tooltip(tooltip)
def __init__(self, owner):
gtk.Toolbar.__init__(self)
self.owner = owner
self.toolItem = {}
self.blockBeat = False
self.beatWheel = []
btn = RadioToolButton(group=None)
btn.set_named_icon('beats')
btn.connect('toggled', self.setBeat, 0)
btn.set_tooltip(_('Jump To Beat'))
self.insert(btn, -1)
self.beatWheel.append(btn)
for i in range(1, 12):
btn = RadioToolButton(group=self.beatWheel[0])
btn.set_named_icon('beats')
btn.connect('toggled', self.setBeat, i)
btn.set_tooltip(_('Jump To Beat'))
self.insert(btn, -1)
self.beatWheel.append(btn)
label = gtk.Label(_("Synch to:"))
self.syncLabel = gtk.ToolItem()
self.syncLabel.add(label)
self.insert(self.syncLabel, 0)
self.comboBox = ComboBox()
self.comboBox.append_item(1, _("1 Beat"))
self.comboBox.append_item(2, _("2 Beats"))
self.comboBox.append_item(3, _("3 Beats"))
self.comboBox.append_item(4, _("4 Beats"))
self.comboBox.append_item(5, _("5 Beats"))
self.comboBox.append_item(6, _("6 Beats"))
self.comboBox.append_item(7, _("7 Beats"))
self.comboBox.append_item(8, _("8 Beats"))
self.comboBox.append_item(9, _("9 Beats"))
self.comboBox.append_item(10, _("10 Beats"))
self.comboBox.append_item(11, _("11 Beats"))
self.comboBox.append_item(12, _("12 Beats"))
self.comboBox.set_active(4 - 1) # default 4 beats
self.comboBox.connect("changed", self.changeSync)
self.syncBox = ToolComboBox(self.comboBox)
self.insert(self.syncBox, 1)
self.show_all()
def __init__(self, parent):
self._main_toolbar = parent.get_toolbar_box().toolbar
self._main_area = parent._main_area
self._erase_button = parent.edit_toolbar.erase_button
self._sw = parent._sw
if HASTOOLBARBOX:
target_toolbar = self._main_toolbar
else:
target_toolbar = self.parent.edit_toolbar
self._mods = RadioToolButton(named_icon='select-mode')
self._mods.set_tooltip(_('Select thoughts'))
self._mods.set_group(parent.btn_group)
self._mods.set_accelerator(_('<ctrl>e'))
self._mods.connect('clicked', parent.mode_cb, MMapArea.MODE_NULL)
target_toolbar.insert(self._mods, -1)
self._link_button = RadioToolButton(named_icon='link')
self._link_button.set_tooltip(_('Link/unlink two selected thoughts'))
self._link_button.set_group(parent.btn_group)
self._link_button.set_accelerator(_('<ctrl>l'))
self._link_button.connect('clicked', self.__link_cb)
target_toolbar.insert(self._link_button, -1)
self.move_button = RadioToolButton(named_icon='move')
self.move_button.set_tooltip(_('Move selected thoughs'))
self.move_button.set_group(parent.btn_group)
self.move_button.set_accelerator(_('<ctrl>m'))
self.move_button.connect('clicked', self.__move_cb)
target_toolbar.insert(self.move_button, -1)
self.drag_button = RadioToolButton(named_icon='drag')
self.drag_button.set_tooltip(_('Scroll the screen'))
self.drag_button.set_group(parent.btn_group)
self.drag_button.connect('clicked', self.__drag_cb)
target_toolbar.insert(self.drag_button, -1)
if HASTOOLBARBOX:
self._separator_2 = gtk.SeparatorToolItem()
self._separator_2.props.draw = False
#self._separator_2.set_size_request(0, -1)
self._separator_2.set_expand(True)
self._separator_2.show()
target_toolbar.insert(self._separator_2, -1)
self._stop_button = StopButton(parent)
target_toolbar.insert(self._stop_button, -1)
def _insert_create_tools(self, create_toolbar):
# Stop/play button
self.stop_play_state = True
self.stop_play = ToolButton('media-playback-stop')
self.stop_play.set_tooltip(_("Stop"))
self.stop_play.set_accelerator(_('<ctrl>space'))
self.stop_play.connect('clicked', self.stop_play_cb)
create_toolbar.insert(self.stop_play, -1)
self.stop_play.show()
separator = gtk.SeparatorToolItem()
create_toolbar.insert(separator, -1)
separator.show()
# Make + add the component buttons
self.radioList = {}
firstButton = None
for c in tools.allTools:
button = RadioToolButton(named_icon=c.icon)
if firstButton:
button.set_group(firstButton)
else:
button.set_group(None)
firstButton = button
button.set_tooltip(c.toolTip)
button.set_accelerator(c.toolAccelerator)
button.connect('clicked', self.radioClicked)
create_toolbar.insert(button, -1)
button.show()
self.radioList[button] = c.name
def _create_button(name):
button = RadioToolButton()
button.show()
button.props.group = this.all
button.set_label(name)
button.connect('toggled', _query, len(this.path))
return button
def load_buttons(self):
self.lista_sensores_button = []
for i in range(len(self.sensores)):
self.sensor = self.sensores[i]
log.debug('agregando boton para : ' + self.sensor)
#radio_tool_button = 0
radio_tool_button = RadioToolButton(group=self.time)
icono = self.sensor.strip('0123456789:')
radio_tool_button.set_named_icon(icono)
radio_tool_button.set_tooltip(_(self.sensor))
if self.sensor.count('temp'):
#determino el numero de sensor y lo paso por parametro.
#log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) )
radio_tool_button.connect('clicked', self.click_temp_button,
self.get_sensor_number(self.sensor))
elif self.sensor.count('dist'):
#log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) )
radio_tool_button.connect('clicked', self.click_dist_button,
self.get_sensor_number(self.sensor))
elif self.sensor.count('grey'):
#log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) )
radio_tool_button.connect('clicked', self.click_grises_button,
self.get_sensor_number(self.sensor))
elif self.sensor.count('light'):
#log.debug('el sensor '+ self.sensor + 'es el numero '+ self.get_sensor_number(self.sensor) )
radio_tool_button.connect('clicked', self.click_luz_button,
self.get_sensor_number(self.sensor))
self.insert(radio_tool_button, 2)
self.lista_sensores_button.append(radio_tool_button)
def __init__(self, activity, **kwargs):
palette = RadioPalette()
self.private = RadioToolButton(icon_name='zoom-home')
palette.append(self.private, _('Private'))
self.neighborhood = RadioToolButton(icon_name='zoom-neighborhood',
group=self.private)
self._neighborhood_handle = self.neighborhood.connect(
'clicked', self.__neighborhood_clicked_cb, activity)
palette.append(self.neighborhood, _('My Neighborhood'))
activity.connect('shared', self.__update_share_cb)
activity.connect('joined', self.__update_share_cb)
RadioMenuButton.__init__(self, **kwargs)
self.props.palette = palette
if activity.props.max_participants == 1:
self.props.sensitive = False
def get_tool_item(self):
self.toolitem = RadioToolButton()
if self.group:
self.toolitem.set_group(self.group.toolitem)
self.toolitem.set_named_icon(
stock.icons[self._stock_id] if self._stock_id in
stock.icons else self._stock_id)
self.toolitem.set_active(self.default_value)
self.toolitem.connect('toggled', self.toggled_cb)
self.setup_tooltip()
return self.toolitem
def __init__(self):
gtk.Toolbar.__init__(self)
sidebar = ToggleToolButton(named_icon='sidebar', palette=TagPalette())
sidebar.connect('toggled', self._tags_cb)
sidebar.props.active = this.config['sidebar_visible']
self.insert(sidebar, -1)
separator = gtk.SeparatorToolItem()
self.insert(separator, -1)
objects = [None] * 3
objects[0] = RadioToolButton(named_icon='view-list',
group=None,
palette=ObjectPalette(
_('Compact object list'),
this.objects_compat))
objects[0].connect('toggled', self._objects_cb, 0, this.objects_compat)
self.insert(objects[0], -1)
objects[1] = RadioToolButton(named_icon='view-thumbs',
tooltip=_('Thumbs object list'),
group=objects[0])
objects[1].connect('toggled', self._objects_cb, 1, this.object_thumbs)
self.insert(objects[1], -1)
objects[this.config['objects_view']].props.active = True
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
self.insert(separator, -1)
search = SearchEntry()
search.connect('query-changed', self._search_changed_cb)
search_toolitem = gtk.ToolItem()
search_toolitem.add(search)
search_toolitem.set_expand(True)
self.insert(search_toolitem, -1)
self.show_all()
def __init__(self, parent):
gtk.Toolbar.__init__(self)
self._parent = parent
text_mode_btn = RadioToolButton(named_icon='text-mode')
text_mode_btn.set_tooltip(_('Text mode'))
text_mode_btn.set_accelerator(_('<ctrl>t'))
text_mode_btn.set_group(None)
text_mode_btn.connect('clicked', self._parent.mode_cb,
MMapArea.MODE_TEXT)
self._parent.btn_group = text_mode_btn
self.insert(text_mode_btn, -1)
image_mode_btn = RadioToolButton(named_icon='image-mode')
image_mode_btn.set_group(text_mode_btn)
image_mode_btn.set_tooltip(_('Image add mode'))
image_mode_btn.set_accelerator(_('<ctrl>i'))
image_mode_btn.connect('clicked', self._parent.mode_cb,
MMapArea.MODE_IMAGE)
self.insert(image_mode_btn, -1)
draw_mode_btn = RadioToolButton(named_icon='draw-mode')
draw_mode_btn.set_group(text_mode_btn)
draw_mode_btn.set_tooltip(_('Drawing mode'))
draw_mode_btn.set_accelerator(_('<ctrl>d'))
draw_mode_btn.connect('clicked', self._parent.mode_cb,
MMapArea.MODE_DRAW)
self.insert(draw_mode_btn, -1)
label_mode_btn = RadioToolButton(named_icon='label-mode')
label_mode_btn.set_tooltip(_('Label mode'))
label_mode_btn.set_accelerator(_('<ctrl>a'))
label_mode_btn.set_group(text_mode_btn)
label_mode_btn.connect('clicked', self._parent.mode_cb,
MMapArea.MODE_LABEL)
self.insert(label_mode_btn, -1)
self.show_all()
def _radio_button_factory(name='', toolbar=None, cb=None, arg=None,
tooltip=None, group=None):
''' Add a radio button to a toolbar '''
button = RadioToolButton(group=group)
button.set_named_icon(name)
if cb is not None:
if arg is None:
button.connect('clicked', cb)
else:
button.connect('clicked', cb, arg)
if toolbar is not None:
toolbar.insert(button, -1)
button.show()
if tooltip is not None:
button.set_tooltip(tooltip)
return button
def radio_factory(button_name, toolbar, callback, cb_arg=None, tooltip=None,
group=None):
''' Add a radio button to a toolbar '''
button = RadioToolButton(group=group)
button.set_named_icon(button_name)
if callback is not None:
if cb_arg is None:
button.connect('clicked', callback)
else:
button.connect('clicked', callback, cb_arg)
if hasattr(toolbar, 'insert'): # Add button to the main toolbar...
toolbar.insert(button, -1)
else: # ...or a secondary toolbar.
toolbar.props.page.insert(button, -1)
button.show()
if tooltip is not None:
button.set_tooltip(tooltip)
return button
def add_pathway_button(self):
# get the hometoolbar
toolbar = self.home_box._toolbar
#add a new button, with a different icon
toolbar._pathway_button = RadioToolButton(
named_icon='media-playback-start') #TODO this icon fails on soas
toolbar._pathway_button.props.group = toolbar._list_button
toolbar._pathway_button.props.tooltip = _('Pathway view')
toolbar._pathway_button.props.accelerator = _('<Ctrl>3')
# toolbar._pathway_button.connect('toggled', toolbar.__view_button_toggled_cb,
# _LIST_VIEW)
toolbar._pathway_button.connect('toggled',
self._show_pathway_button_cb, None)
toolbar.insert(toolbar._pathway_button,
toolbar.get_item_index(toolbar._list_button) + 1)
toolbar._pathway_button.show()
def _add_button(self, icon_name, label, accelerator, zoom_level):
if self.get_children():
group = self.get_children()[0]
else:
group = None
button = RadioToolButton(named_icon=icon_name,
group=group,
accelerator=accelerator)
button.connect('clicked', self.__level_clicked_cb, zoom_level)
self.add(button)
button.show()
palette = Palette(glib.markup_escape_text(label))
palette.props.invoker = FrameWidgetInvoker(button)
palette.set_group_id('frame')
button.set_palette(palette)
return button
def __init__(self):
gtk.Toolbar.__init__(self)
self._query = None
self._autosearch_timer = None
self._add_separator()
tool_item = gtk.ToolItem()
self.insert(tool_item, -1)
tool_item.show()
self.search_entry = iconentry.IconEntry()
self.search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'system-search')
self.search_entry.add_clear_button()
self.search_entry.set_width_chars(25)
self.search_entry.connect('activate', self.__entry_activated_cb)
self.search_entry.connect('changed', self.__entry_changed_cb)
tool_item.add(self.search_entry)
self.search_entry.show()
self._add_separator(expand=True)
favorites_button = FavoritesButton()
favorites_button.connect('toggled', self.__view_button_toggled_cb,
_FAVORITES_VIEW)
self.insert(favorites_button, -1)
favorites_button.show()
self._list_button = RadioToolButton(named_icon='view-list')
self._list_button.props.group = favorites_button
self._list_button.props.tooltip = _('List view')
self._list_button.props.accelerator = _('<Ctrl>2')
self._list_button.connect('toggled', self.__view_button_toggled_cb,
_LIST_VIEW)
self.insert(self._list_button, -1)
self._list_button.show()
self._add_separator()
def load_buttons(self):
self.sensores = [_('Light Sensor'), _('Distance Sensor'), _('Grey Sensor'), _('Button Sensor'), _('Sound Sensor')]
self.lista_sensores_button = []
for i in range(len(self.sensores)):
self.sensor = self.sensores[i]
radio_tool_button = RadioToolButton(group=self.time)
icono = self.sensor.strip('0123456789:')
radio_tool_button.set_named_icon(icono)
radio_tool_button.set_tooltip(_(self.sensor))
if self.sensor.count(_('Sound Sensor')):
radio_tool_button.connect('clicked',self.click_sound_button)
if self.sensor.count(_('Distance Sensor')):
radio_tool_button.connect('clicked',self.click_dist_button)
elif self.sensor.count(_('Grey Sensor')):
radio_tool_button.connect('clicked',self.click_grises_button)
elif self.sensor.count(_('Button Sensor')):
radio_tool_button.connect('clicked',self.click_button)
log.debug(self.sensores)
elif self.sensor.count(_('Light sensor')):
radio_tool_button.connect('clicked',self.click_luz_button)
self.insert(radio_tool_button, 2)
self.lista_sensores_button.append(radio_tool_button)
def __init__(self):
RadioToolButton.__init__(self)
self.props.tooltip = _('Favorites view')
self.props.accelerator = _('<Ctrl>1')
self.props.group = None
favorites_settings = favoritesview.get_settings()
self._layout = favorites_settings.layout
self._update_icon()
# someday, this will be a gtk.Table()
layouts_grid = gtk.HBox()
layout_item = None
for layoutid, layoutclass in sorted(favoritesview.LAYOUT_MAP.items()):
layout_item = RadioToolButton(icon_name=layoutclass.icon_name,
group=layout_item,
active=False)
if layoutid == self._layout:
layout_item.set_active(True)
layouts_grid.pack_start(layout_item, fill=False)
layout_item.connect('toggled', self.__layout_activate_cb, layoutid)
layouts_grid.show_all()
self.props.palette.set_content(layouts_grid)
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
self.max_participants = 1
# CHART_OPTIONS
self.x_label = ""
self.y_label = ""
self.chart_color = utils.get_user_fill_color('str')
self.chart_line_color = utils.get_user_stroke_color('str')
self.current_chart = None
self.charts_area = None
self.chart_data = []
# TOOLBARS
toolbarbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
activity_btn_toolbar = activity_button.page
activity_btn_toolbar.title.connect('changed', self._set_chart_title)
save_as_image = ToolButton("save-as-image")
save_as_image.connect("clicked", self._save_as_image)
save_as_image.set_tooltip(_("Save as image"))
activity_btn_toolbar.insert(save_as_image, -1)
save_as_image.show()
import_stopwatch = ToolButton("import-stopwatch")
import_stopwatch.connect("clicked", self.__import_stopwatch_cb)
import_stopwatch.set_tooltip(_("Read StopWatch data"))
activity_btn_toolbar.insert(import_stopwatch, -1)
import_stopwatch.show()
import_measure = ToolButton("import-measure")
import_measure.set_tooltip(_("Read Measure data"))
if utils.get_channels() == 1:
import_measure.connect("clicked", self.__import_measure_cb, 1)
else:
import_measure.connect("clicked", self._measure_btn_clicked)
self._create_measure_palette(import_measure)
activity_btn_toolbar.insert(import_measure, -1)
import_measure.show()
activity_btn_toolbar.keep.hide()
toolbarbox.toolbar.insert(activity_button, 0)
add_v = ToolButton("row-insert")
add_v.connect("clicked", self._add_value)
add_v.set_tooltip(_("Add a value"))
toolbarbox.toolbar.insert(add_v, -1)
remove_v = ToolButton("row-remove")
remove_v.connect("clicked", self._remove_value)
remove_v.set_tooltip(_("Remove the selected value"))
toolbarbox.toolbar.insert(remove_v, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
add_vbar_chart = RadioToolButton()
add_vbar_chart.connect("clicked", self._add_chart_cb, "vbar")
add_vbar_chart.set_tooltip(_("Vertical Bar Chart"))
add_vbar_chart.props.icon_name = "vbar"
charts_group = add_vbar_chart
toolbarbox.toolbar.insert(add_vbar_chart, -1)
add_hbar_chart = RadioToolButton()
add_hbar_chart.connect("clicked", self._add_chart_cb, "hbar")
add_hbar_chart.set_tooltip(_("Horizontal Bar Chart"))
add_hbar_chart.props.icon_name = "hbar"
add_hbar_chart.props.group = charts_group
toolbarbox.toolbar.insert(add_hbar_chart, -1)
add_line_chart = RadioToolButton()
add_line_chart.connect("clicked", self._add_chart_cb, "line")
add_line_chart.set_tooltip(_("Line Chart"))
add_line_chart.props.icon_name = "line"
add_line_chart.props.group = charts_group
toolbarbox.toolbar.insert(add_line_chart, -1)
add_pie_chart = RadioToolButton()
add_pie_chart.connect("clicked", self._add_chart_cb, "pie")
add_pie_chart.set_tooltip(_("Pie Chart"))
add_pie_chart.props.icon_name = "pie"
add_pie_chart.props.group = charts_group
add_pie_chart.set_active(True)
toolbarbox.toolbar.insert(add_pie_chart, -1)
self.chart_type_buttons = [
add_vbar_chart, add_hbar_chart, add_line_chart, add_pie_chart
]
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
options_button = ToolbarButton(icon_name='preferences-system')
options_toolbar = gtk.Toolbar()
self.chart_color_btn = ColorToolButton()
self.chart_color_btn.set_color(_COLOR1)
self.chart_color_btn.set_title(_("Chart Color"))
self.chart_color_btn.connect('notify::color', self._set_chart_color)
options_toolbar.insert(self.chart_color_btn, -1)
self.line_color_btn = ColorToolButton()
self.line_color_btn.set_color(_COLOR2)
self.line_color_btn.set_title(_("Line Color"))
self.line_color_btn.connect('notify::color',
self._set_chart_line_color)
options_toolbar.insert(self.line_color_btn, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
options_toolbar.insert(separator, -1)
h_label_icon = Icon(icon_name="hlabel")
h_label_tool_item = gtk.ToolItem()
h_label_tool_item.add(h_label_icon)
options_toolbar.insert(h_label_tool_item, -1)
self.h_label = Entry(_("Horizontal label..."))
self.h_label.entry.connect("changed", self._set_h_label)
options_toolbar.insert(self.h_label, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(False)
options_toolbar.insert(separator, -1)
v_label_icon = Icon(icon_name="vlabel")
v_label_tool_item = gtk.ToolItem()
v_label_tool_item.add(v_label_icon)
options_toolbar.insert(v_label_tool_item, -1)
self.v_label = Entry(_("Vertical label..."))
self.v_label.entry.connect("changed", self._set_v_label)
options_toolbar.insert(self.v_label, -1)
options_button.props.page = options_toolbar
options_toolbar.show_all()
toolbarbox.toolbar.insert(options_button, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
fullscreen_btn = ToolButton('view-fullscreen')
fullscreen_btn.set_tooltip(_('Fullscreen'))
fullscreen_btn.connect("clicked", self.__fullscreen_cb)
toolbarbox.toolbar.insert(fullscreen_btn, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
toolbarbox.toolbar.insert(separator, -1)
simplegraphhelp.create_help(toolbarbox.toolbar)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
# CANVAS
paned = gtk.HPaned()
box = gtk.VBox()
self.box = box
# Set the info box width to 1/3 of the screen:
def size_allocate_cb(widget, allocation):
paned.disconnect(self._setup_handle)
box_width = allocation.width / 3
box.set_size_request(box_width, -1)
self._setup_handle = paned.connect('size_allocate', size_allocate_cb)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.labels_and_values = ChartData(self)
scroll.add(self.labels_and_values)
self.labels_and_values.connect("label-changed", self._label_changed)
self.labels_and_values.connect("value-changed", self._value_changed)
box.pack_start(scroll, True, True, 0)
paned.add1(box)
# CHARTS AREA
eventbox = gtk.EventBox()
self.charts_area = ChartArea(self)
self.charts_area.connect('size_allocate', self._chart_size_allocate)
eventbox.modify_bg(gtk.STATE_NORMAL, _WHITE)
eventbox.add(self.charts_area)
paned.add2(eventbox)
self.set_canvas(paned)
self.show_all()
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
self.max_participants = 1
self.dic = {}
# Canvas
self._canvas = gtk.VBox()
hbox = gtk.HBox()
self._liststore1 = gtk.ListStore(str)
self.combo1 = gtk.ComboBox(self._liststore1)
cell = gtk.CellRendererText()
self.combo1.pack_start(cell, True)
self.combo1.add_attribute(cell, 'markup', 0)
self.combo1.connect('changed', self._call)
flip_btn = gtk.Button()
flip_btn.connect('clicked', self._flip)
flip_btn.add(gtk.image_new_from_file('icons/flip.svg'))
self._liststore2 = gtk.ListStore(str)
self.combo2 = gtk.ComboBox(self._liststore1)
cell = gtk.CellRendererText()
self.combo2.pack_start(cell, True)
self.combo2.add_attribute(cell, 'markup', 0)
self.combo2.connect('changed', self._call)
self.label_box = gtk.HBox()
self.adjustment = gtk.Adjustment(1.0, 0.0000000001, 10.0**20.0, 0.1,
1.0)
self.spin = gtk.SpinButton(self.adjustment, 0.0, 2)
self.label = gtk.Label()
self.label.set_selectable(True)
self.label._size = 12
self.label.connect('expose-event', self.resize_label)
self.convert_btn = gtk.Button(_('Convert'))
self.convert_btn.connect('clicked', self._call)
self._canvas.pack_start(hbox, False, False, 20)
hbox.pack_start(self.combo1, False, True, 20)
hbox.pack_start(flip_btn, True, False)
hbox.pack_end(self.combo2, False, True, 20)
spin_box = gtk.HBox()
convert_box = gtk.HBox()
convert_box.pack_start(spin_box, True, False, 0)
spin_box.pack_start(self.spin, False, False, 0)
self._canvas.pack_start(convert_box, False, False, 5)
self._canvas.pack_start(self.label_box, True, False, 0)
self.label_box.add(self.label)
spin_box.pack_start(self.convert_btn, False, False, 20)
self.set_canvas(self._canvas)
# Toolbar
toolbarbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbarbox.toolbar.insert(activity_button, 0)
separator = gtk.SeparatorToolItem()
separator.set_expand(False)
separator.set_draw(True)
toolbarbox.toolbar.insert(separator, -1)
# RadioToolButton
self._length_btn = RadioToolButton()
self._length_btn.connect('clicked',
lambda w: self._update_combo(convert.length))
self._length_btn.set_tooltip(_('Length'))
self._length_btn.props.icon_name = 'length'
self._volume_btn = RadioToolButton()
self._volume_btn.connect('clicked',
lambda w: self._update_combo(convert.volume))
self._volume_btn.set_tooltip(_('Volume'))
self._volume_btn.props.icon_name = 'volume'
self._volume_btn.props.group = self._length_btn
self._area_btn = RadioToolButton()
self._area_btn.connect('clicked',
lambda w: self._update_combo(convert.area))
self._area_btn.set_tooltip(_('Area'))
self._area_btn.props.icon_name = 'area'
self._area_btn.props.group = self._length_btn
self._weight_btn = RadioToolButton()
self._weight_btn.connect('clicked',
lambda w: self._update_combo(convert.weight))
self._weight_btn.set_tooltip(_('Weight'))
self._weight_btn.props.icon_name = 'weight'
self._weight_btn.props.group = self._length_btn
self._speed_btn = RadioToolButton()
self._speed_btn.connect('clicked',
lambda w: self._update_combo(convert.speed))
self._speed_btn.set_tooltip(_('Speed'))
self._speed_btn.props.icon_name = 'speed'
self._speed_btn.props.group = self._length_btn
self._time_btn = RadioToolButton()
self._time_btn.connect('clicked',
lambda w: self._update_combo(convert.time))
self._time_btn.set_tooltip(_('Time'))
self._time_btn.props.icon_name = 'time'
self._time_btn.props.group = self._length_btn
self._temp_btn = RadioToolButton()
self._temp_btn.connect('clicked',
lambda w: self._update_combo(convert.temp))
self._temp_btn.set_tooltip(_('Temperature'))
self._temp_btn.props.icon_name = 'temp'
self._temp_btn.props.group = self._length_btn
toolbarbox.toolbar.insert(self._length_btn, -1)
toolbarbox.toolbar.insert(self._volume_btn, -1)
toolbarbox.toolbar.insert(self._area_btn, -1)
toolbarbox.toolbar.insert(self._weight_btn, -1)
toolbarbox.toolbar.insert(self._speed_btn, -1)
toolbarbox.toolbar.insert(self._time_btn, -1)
toolbarbox.toolbar.insert(self._temp_btn, -1)
separator = gtk.SeparatorToolItem()
separator.set_expand(True)
separator.set_draw(False)
toolbarbox.toolbar.insert(separator, -1)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
self._update_combo(convert.length)
self.show_all()
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
self.max_participants = 1
# CHART_OPTIONS
self.x_label = ""
self.y_label = ""
self.chart_color = utils.get_user_fill_color('str')
self.chart_line_color = utils.get_user_stroke_color('str')
self.current_chart = None
self.charts_area = None
self.chart_data = []
# TOOLBARS
toolbarbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
activity_btn_toolbar = activity_button.page
activity_btn_toolbar.title.connect('changed', self._set_chart_title)
save_as_image = ToolButton("save-as-image")
save_as_image.connect("clicked", self._save_as_image)
save_as_image.set_tooltip(_("Save as image"))
activity_btn_toolbar.insert(save_as_image, -1)
save_as_image.show()
toolbarbox.toolbar.insert(activity_button, 0)
import_freespace = ToolButton("import-freespace")
import_freespace.connect("clicked", self.__import_freespace_cb)
import_freespace.set_tooltip(_("Read Freespace data"))
toolbarbox.toolbar.insert(import_freespace, -1)
import_freespace.show()
import_journal = ToolButton('import-journal')
import_journal.connect('clicked', self.__import_journal_cb)
import_journal.set_tooltip(_('Read Journal data'))
toolbarbox.toolbar.insert(import_journal, -1)
import_journal.show()
import_turtle = ToolButton('import-turtle')
import_turtle.connect('clicked', self.__import_turtle_cb)
import_turtle.set_tooltip(_('Read Turtle data'))
toolbarbox.toolbar.insert(import_turtle, -1)
import_turtle.show()
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
add_vbar_chart = RadioToolButton()
add_vbar_chart.connect("clicked", self._add_chart_cb, "vbar")
add_vbar_chart.set_tooltip(_("Vertical Bar Chart"))
add_vbar_chart.props.icon_name = "vbar"
charts_group = add_vbar_chart
toolbarbox.toolbar.insert(add_vbar_chart, -1)
add_hbar_chart = RadioToolButton()
add_hbar_chart.connect("clicked", self._add_chart_cb, "hbar")
add_hbar_chart.set_tooltip(_("Horizontal Bar Chart"))
add_hbar_chart.props.icon_name = "hbar"
add_hbar_chart.props.group = charts_group
toolbarbox.toolbar.insert(add_hbar_chart, -1)
add_pie_chart = RadioToolButton()
add_pie_chart.connect("clicked", self._add_chart_cb, "pie")
add_pie_chart.set_tooltip(_("Pie Chart"))
add_pie_chart.props.icon_name = "pie"
add_pie_chart.props.group = charts_group
add_pie_chart.set_active(True)
toolbarbox.toolbar.insert(add_pie_chart, -1)
self.chart_type_buttons = [
add_vbar_chart, add_hbar_chart, add_pie_chart
]
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
fullscreen_btn = ToolButton('view-fullscreen')
fullscreen_btn.set_tooltip(_('Fullscreen'))
fullscreen_btn.connect("clicked", self.__fullscreen_cb)
toolbarbox.toolbar.insert(fullscreen_btn, -1)
charthelp.create_help(toolbarbox.toolbar)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
toolbarbox.toolbar.insert(separator, -1)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
# CANVAS
paned = gtk.HPaned()
box = gtk.VBox()
self.box = box
# Set the info box width to 1/3 of the screen:
def size_allocate_cb(widget, allocation):
paned.disconnect(self._setup_handle)
box_width = allocation.width / 3
box.set_size_request(box_width, -1)
self._setup_handle = paned.connect('size_allocate', size_allocate_cb)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.labels_and_values = ChartData(self)
scroll.add(self.labels_and_values)
self.labels_and_values.connect("label-changed", self._label_changed)
self.labels_and_values.connect("value-changed", self._value_changed)
box.pack_start(scroll, True, True, 0)
paned.add1(box)
# CHARTS AREA
eventbox = gtk.EventBox()
self.charts_area = ChartArea(self)
self.charts_area.connect('size_allocate', self._chart_size_allocate)
eventbox.modify_bg(gtk.STATE_NORMAL, _WHITE)
eventbox.add(self.charts_area)
paned.add2(eventbox)
self.set_canvas(paned)
self.show_all()
def build_toolbar(self):
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()
tool_group = None
self.game_button = RadioToolButton()
self.game_button.props.icon_name = 'gamecanvas'
self.game_button.set_tooltip(_('Juego'))
self.game_button.accelerator = "<Ctrl>1"
self.game_button.props.group = tool_group
self.game_button.connect('clicked', self.show_game)
toolbar_box.toolbar.insert(self.game_button, -1)
self.game_button.show()
tool_group = self.game_button
button = RadioToolButton()
button.props.icon_name = 'view-source'
button.set_tooltip(_('Editor'))
button.accelerator = "<Ctrl>2"
button.props.group = tool_group
button.connect('clicked', self.show_editor)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.save_button = ToolButton('dialog-ok')
self.save_button.set_tooltip(_('Guardar'))
self.save_button.accelerator = "<Ctrl>s"
self.save_button.connect('clicked', self.save_file)
self.save_button.set_sensitive(False)
toolbar_box.toolbar.insert(self.save_button, -1)
self.save_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = ToolButton('system-restart')
button.set_tooltip(_('Reiniciar juego'))
button.accelerator = "<Alt><Shift>r"
button.connect('clicked', self.restart_game)
toolbar_box.toolbar.insert(button, -1)
button.show()
self.editor_button = ToolButton('sources')
self.editor_button.set_tooltip(_('Consola'))
self.editor_button.accelerator = "<Ctrl>grave"
self.editor_button.connect('clicked', self.toggle_console)
toolbar_box.toolbar.insert(self.editor_button, -1)
self.editor_button.show()
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = helpbutton.HelpButton(self)
toolbar_box.toolbar.insert(button, -1)
button.show()
button = ToolButton()
button.props.icon_name = 'activity-about'
button.set_tooltip(_('Acerca de'))
button.accelerator = "<Ctrl>i"
button.connect('clicked', self.run_credits)
toolbar_box.toolbar.insert(button, -1)
button.show()
# Blank space (separator) and Stop button at the end:
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()
def ui_init(self):
self._fullscreen = False
self._showing_info = False
# FIXME: if _thumb_tray becomes some kind of button group, we wouldn't
# have to track which recd is active
self._active_recd = None
self.connect_after('key-press-event', self._key_pressed)
self._active_toolbar_idx = 0
self._toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
self._toolbar_box.toolbar.insert(activity_button, 0)
self.set_toolbar_box(self._toolbar_box)
self._toolbar = self.get_toolbar_box().toolbar
tool_group = None
if self.model.get_has_camera():
self._photo_button = RadioToolButton()
self._photo_button.props.group = tool_group
tool_group = self._photo_button
self._photo_button.props.icon_name = 'camera-external'
self._photo_button.props.label = _('Photo')
self._photo_button.mode = constants.MODE_PHOTO
self._photo_button.connect('clicked', self._mode_button_clicked)
self._toolbar.insert(self._photo_button, -1)
self._video_button = RadioToolButton()
self._video_button.props.group = tool_group
self._video_button.props.icon_name = 'media-video'
self._video_button.props.label = _('Video')
self._video_button.mode = constants.MODE_VIDEO
self._video_button.connect('clicked', self._mode_button_clicked)
self._toolbar.insert(self._video_button, -1)
else:
self._photo_button = None
self._video_button = None
self._audio_button = RadioToolButton()
self._audio_button.props.group = tool_group
self._audio_button.props.icon_name = 'media-audio'
self._audio_button.props.label = _('Audio')
self._audio_button.mode = constants.MODE_AUDIO
self._audio_button.connect('clicked', self._mode_button_clicked)
self._toolbar.insert(self._audio_button, -1)
self._toolbar.insert(gtk.SeparatorToolItem(), -1)
self._toolbar_controls = RecordControl(self._toolbar)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self._toolbar.insert(separator, -1)
self._toolbar.insert(StopButton(self), -1)
self.get_toolbar_box().show_all()
main_box = gtk.VBox()
self.set_canvas(main_box)
main_box.get_parent().modify_bg(gtk.STATE_NORMAL, COLOR_BLACK)
main_box.show()
self._media_view = MediaView()
self._media_view.connect('media-clicked', self._media_view_media_clicked)
self._media_view.connect('pip-clicked', self._media_view_pip_clicked)
self._media_view.connect('info-clicked', self._media_view_info_clicked)
self._media_view.connect('full-clicked', self._media_view_full_clicked)
self._media_view.connect('tags-changed', self._media_view_tags_changed)
self._media_view.show()
self._controls_hbox = gtk.HBox()
self._controls_hbox.show()
self._shutter_button = ShutterButton()
self._shutter_button.connect("clicked", self._shutter_clicked)
self._controls_hbox.pack_start(self._shutter_button, expand=True, fill=False)
self._countdown_image = CountdownImage()
self._controls_hbox.pack_start(self._countdown_image, expand=True, fill=False)
self._play_button = PlayButton()
self._play_button.connect('clicked', self._play_pause_clicked)
self._controls_hbox.pack_start(self._play_button, expand=False)
self._playback_scale = PlaybackScale(self.model)
self._controls_hbox.pack_start(self._playback_scale, expand=True, fill=True)
self._progress = ProgressInfo()
self._controls_hbox.pack_start(self._progress, expand=True, fill=True)
self._title_label = gtk.Label()
self._title_label.set_markup("<b><span foreground='white'>"+_('Title:')+'</span></b>')
self._controls_hbox.pack_start(self._title_label, expand=False)
self._title_entry = gtk.Entry()
self._title_entry.modify_bg(gtk.STATE_INSENSITIVE, COLOR_BLACK)
self._title_entry.connect('changed', self._title_changed)
self._controls_hbox.pack_start(self._title_entry, expand=True, fill=True, padding=10)
container = RecordContainer(self._media_view, self._controls_hbox)
main_box.pack_start(container, expand=True, fill=True, padding=6)
container.show()
self._thumb_tray = HTray()
self._thumb_tray.set_size_request(-1, 150)
main_box.pack_end(self._thumb_tray, expand=False)
self._thumb_tray.show_all()
def __init__(self, activity, channels):
''' By default, start with resistance mode '''
gtk.Toolbar.__init__(self)
self.activity = activity
self._channels = channels
self._lock_radio_buttons = False
self._radio_button_pushed = False
self.values = []
for i in range(self._channels):
self.values.append('')
self.string_for_textbox = ''
self.gain = 1.0
self.y_mag = 3.0
self.capture_gain = CAPTURE_GAIN
self.mic_boost = MIC_BOOST
self.mode = 'sound'
# Set up Time-domain Button
self.time = RadioToolButton(group=None)
self.time.set_named_icon('media-audio')
self.insert(self.time, -1)
self.time.set_tooltip(_('Sound'))
self.time.connect('clicked', self.analog_resistance_voltage_mode_cb,
'sound')
# Set up Resistance Button
self.resistance = RadioToolButton(group=self.time)
self.resistance.set_named_icon('resistance')
if _is_xo(self.activity.hw):
self.insert(self.resistance, -1)
self.resistance.show()
self.resistance.set_tooltip(_('Resistance Sensor'))
self.resistance.connect('clicked',
self.analog_resistance_voltage_mode_cb,
'resistance')
# Set up Voltage Button
self.voltage = RadioToolButton(group=self.time)
self.voltage.set_named_icon('voltage')
if _is_xo(self.activity.hw):
self.insert(self.voltage, -1)
self.voltage.set_tooltip(_('Voltage Sensor'))
self.voltage.connect('clicked', self.analog_resistance_voltage_mode_cb,
'voltage')
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._log_interval_combo = ComboBox()
self.interval = [
_('1/10 second'),
_('1 second'),
_('30 seconds'),
_('5 minutes'),
_('30 minutes')
]
if hasattr(self._log_interval_combo, 'set_tooltip_text'):
self._log_interval_combo.set_tooltip_text(_('Sampling interval'))
self._interval_changed_id = self._log_interval_combo.connect(
'changed', self.log_interval_cb)
for i, s in enumerate(self.interval):
self._log_interval_combo.append_item(i, s, None)
if s == _('1 second'):
self._log_interval_combo.set_active(i)
self._log_interval_tool = ToolComboBox(self._log_interval_combo)
self.insert(self._log_interval_tool, -1)
self.logging_interval_status = '1 second'
# Set up Logging/Stop Logging Button
self._record = ToolButton('media-record')
self.insert(self._record, -1)
self._record.set_tooltip(_('Start Recording'))
self._record.connect('clicked', self.record_control_cb)
if self.activity.has_toolbarbox:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
# Set up Trigger Combo box
self.trigger_combo = ComboBox()
self.trigger = [_('None'), _('Rising Edge'), _('Falling Edge')]
self.trigger_conf = [
self.activity.wave.TRIGGER_NONE, self.activity.wave.TRIGGER_POS,
self.activity.wave.TRIGGER_NEG
]
self._trigger_changed_id = self.trigger_combo.connect(
'changed', self.update_trigger_control)
for i, s in enumerate(self.trigger):
self.trigger_combo.append_item(i, s, None)
self.trigger_combo.set_active(0)
if hasattr(self.trigger_combo, 'set_tooltip_text'):
self.trigger_combo.set_tooltip_text(_('Create a trigger'))
self._trigger_tool = ToolComboBox(self.trigger_combo)
self.insert(self._trigger_tool, -1)
self.show_all()
def instance(self):
book.wiki = book.WikiBook()
if not book.custom:
book.custom = book.CustomBook()
self.edit_page = 1
self.edit = edit.View()
self.library = library.View(self)
if OLD_TOOLBAR:
self.edit_toolbar = gtk.Toolbar()
self.edit_bar = edit.ToolbarBuilder(self.edit, self.edit_toolbar)
self.edit_toolbar.show_all()
self.library_toolbar = gtk.Toolbar()
self.library_bar = library.ToolbarBuilder(self.library,
self.library_toolbar)
self.library_toolbar.show_all()
toolbox = ActivityToolbox(self)
toolbox.connect('current-toolbar-changed',
self._toolbar_changed_cb)
self.set_toolbox(toolbox)
toolbox.add_toolbar(_('Library'), self.library_toolbar)
toolbox.add_toolbar(_('Edit'), self.edit_toolbar)
toolbox.set_current_toolbar(1)
else:
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
self.set_toolbar_box(toolbar_box)
self._toolbar = toolbar_box.toolbar
tool_group = None
search_button = RadioToolButton()
search_button.props.group = tool_group
tool_group = search_button
search_button.props.icon_name = 'white-search'
search_button.set_tooltip(_('Library'))
search_button.mode = 'search'
search_button.connect('clicked', self.__mode_button_clicked)
self._toolbar.insert(search_button, -1)
edit_button = RadioToolButton()
edit_button.props.group = tool_group
edit_button.props.icon_name = 'toolbar-edit'
edit_button.set_tooltip(_('Edit'))
edit_button.mode = 'edit'
edit_button.connect('clicked', self.__mode_button_clicked)
self._toolbar.insert(edit_button, -1)
self._toolbar.insert(gtk.SeparatorToolItem(), -1)
self.edit_bar = edit.ToolbarBuilder(self.edit, self._toolbar)
self.library_bar = library.ToolbarBuilder(self.library,
self._toolbar)
edit_fake = gtk.EventBox()
self.notebook.append_page(self.library)
self.notebook.append_page(self.edit)
self.notebook.append_page(edit_fake)
self.show_all()
if not OLD_TOOLBAR:
self.__mode_button_clicked(search_button)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
self._toolbar.insert(separator, -1)
stop_button = StopButton(self)
stop_button.show()
self._toolbar.insert(stop_button, -1)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.max_participants = 1
self.toolbarbox = ToolbarBox()
self.toolbar = self.toolbarbox.toolbar
self.start_vnc = RadioToolButton(icon_name="start_vnc",
tooltip=_("Start VNC Server"))
self.stop_vnc = RadioToolButton(icon_name="stop_vnc",
tooltip=_("Stop VNC Server"),
group=self.start_vnc)
self.stop_vnc.set_active(True)
self.get_ipbutton = ToolButton(icon_name="get_ip",
tooltip=_("Get the current IP"))
##
self.messages = gtk.TreeView()
self.messages.set_rules_hint(True)
modelo = gtk.ListStore(str, str, gtk.gdk.Color)
self.messages.set_model(modelo)
render = gtk.CellRendererText()
render1 = gtk.CellRendererText()
column1 = gtk.TreeViewColumn(_("Hour"), render, markup=0)
column2 = gtk.TreeViewColumn(_("Message"), render1, markup=1)
column1.add_attribute(render, 'foreground-gdk', 2)
column2.add_attribute(render1, 'foreground-gdk', 2)
self.messages.append_column(column1)
self.messages.append_column(column2)
color = gtk.gdk.color_parse("dark blue")
modelo.insert(0, [
time.strftime("\n<b>%H:%M:%S</b>\n"),
_("\n<b>Start of activity.</b>\n"), color
])
self.showed_message_stop = True
self.showed_message_start = False
self.isrunning = True
self.stop_vnc.connect("clicked", self.__stop_vnc)
self.start_vnc.connect("clicked", self.__start_vnc)
self.clear_model = ToolButton(icon_name="clear_console",
tooltip=_("Delete messages"))
self.clear_model.connect("clicked", lambda x: modelo.clear())
self.get_ipbutton.connect("clicked", self.__get_ip)
self.last_message = 1
self.__get_x11vnc_path()
##
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.stop_activity = StopButton(self)
self.toolbar.insert(ActivityToolbarButton(self), -1)
self.toolbar.insert(gtk.SeparatorToolItem(), -1)
self.toolbar.insert(self.start_vnc, -1)
self.toolbar.insert(self.stop_vnc, -1)
self.toolbar.insert(gtk.SeparatorToolItem(), -1)
self.toolbar.insert(self.get_ipbutton, -1)
self.toolbar.insert(self.clear_model, -1)
self.toolbar.insert(separator, -1)
self.toolbar.insert(self.stop_activity, -1)
self.messages_scroll = gtk.ScrolledWindow()
self.messages_scroll.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.messages_scroll.add_with_viewport(self.messages)
self.set_toolbar_box(self.toolbarbox)
self.set_canvas(self.messages_scroll)
self.show_all()
gobject.timeout_add(100, self.__check_is_on)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.max_participants = 1
# Canvas
canvas = Canvas(self)
self.set_canvas(canvas)
self._download_list = canvas.gtk_list.download_list
# Toolbars
toolbarbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbarbox.toolbar.insert(activity_button, 0)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
# Switch
store_list = RadioToolButton()
store_list.set_active(True)
store_list.props.icon_name = 'view-list'
store_list.connect("clicked", canvas.switch_to_list)
store_list.set_tooltip(_("Show the search list"))
toolbarbox.toolbar.insert(store_list, -1)
downloads_list = RadioToolButton()
downloads_list.connect("clicked", canvas.switch_to_downloads_list)
downloads_list.set_tooltip(_("Show the downloads list"))
downloads_list.props.group = store_list
self.downloads_icon = DownloadsIcon()
downloads_list.set_icon_widget(self.downloads_icon)
toolbarbox.toolbar.insert(downloads_list, -1)
self.store_list = store_list
self.downloads_list = downloads_list
separator = gtk.SeparatorToolItem()
separator.set_draw(True)
separator.set_expand(False)
toolbarbox.toolbar.insert(separator, -1)
# Search
search_entry = iconentry.IconEntry()
search_entry.set_size_request(gtk.gdk.screen_width() / 4, -1)
search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'system-search')
search_entry.connect('activate', canvas.gtk_list.search)
search_entry.connect('activate', lambda w: canvas.switch_to_list(None))
search_entry.add_clear_button()
search_item = gtk.ToolItem()
search_item.add(search_entry)
toolbarbox.toolbar.insert(search_item, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
toolbarbox.toolbar.insert(separator, -1)
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
self.set_toolbar_box(toolbarbox)
self.show_all()
canvas.set_page(0)
def __init__(self, title, bundle_path, document_path, sugar_toolkit_path):
gtk.Toolbar.__init__(self)
document_button = None
self.bundle_path = bundle_path
self.sugar_toolkit_path = sugar_toolkit_path
self._add_separator()
activity_bundle = ActivityBundle(bundle_path)
file_name = activity_bundle.get_icon()
if document_path is not None and os.path.exists(document_path):
document_button = DocumentButton(file_name, document_path, title)
document_button.connect('toggled', self.__button_toggled_cb,
document_path)
self.insert(document_button, -1)
document_button.show()
self._add_separator()
if bundle_path is not None and os.path.exists(bundle_path):
activity_button = DocumentButton(file_name,
bundle_path,
title,
bundle=True)
icon = Icon(file=file_name,
icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR,
fill_color=style.COLOR_TRANSPARENT.get_svg(),
stroke_color=style.COLOR_WHITE.get_svg())
activity_button.set_icon_widget(icon)
icon.show()
if document_button is not None:
activity_button.props.group = document_button
activity_button.props.tooltip = _('Activity Bundle Source')
activity_button.connect('toggled', self.__button_toggled_cb,
bundle_path)
self.insert(activity_button, -1)
activity_button.show()
self._add_separator()
if sugar_toolkit_path is not None:
sugar_button = RadioToolButton()
icon = Icon(icon_name='computer-xo',
icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR,
fill_color=style.COLOR_TRANSPARENT.get_svg(),
stroke_color=style.COLOR_WHITE.get_svg())
sugar_button.set_icon_widget(icon)
icon.show()
if document_button is not None:
sugar_button.props.group = document_button
else:
sugar_button.props.group = activity_button
sugar_button.props.tooltip = _('Sugar Toolkit Source')
sugar_button.connect('toggled', self.__button_toggled_cb,
sugar_toolkit_path)
self.insert(sugar_button, -1)
sugar_button.show()
self._add_separator()
self.activity_title_text = _('View source: %s') % title
self.sugar_toolkit_title_text = _('View source: %r') % 'Sugar Toolkit'
self.label = gtk.Label()
self.label.set_markup('<b>%s</b>' % self.activity_title_text)
self.label.set_alignment(0, 0.5)
self._add_widget(self.label)
self._add_separator(True)
stop = ToolButton(icon_name='dialog-cancel')
stop.set_tooltip(_('Close'))
stop.connect('clicked', self.__stop_clicked_cb)
self.insert(stop, -1)
stop.show()
def __init__(self, handle):
activity.Activity.__init__(self, handle)
try:
# Use new >= 0.86 toolbar design
self.max_participants = 1
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
activity_button.props.page.insert(separator, -1)
separator.show()
tool = ToolButton('pdf-export')
tool.set_tooltip(_('Portable Document Format (PDF)'))
tool.connect('clicked', self.__export_pdf_cb)
activity_button.props.page.insert(tool, -1)
tool.show()
tool = ToolButton('png-export')
tool.set_tooltip(_('Portable Network Graphic (PNG)'))
tool.connect('clicked', self.__export_png_cb)
activity_button.props.page.insert(tool, -1)
tool.show()
self.edit_toolbar = ToolbarButton()
self.edit_toolbar.props.page = EditToolbar(self)
self.edit_toolbar.props.icon_name = 'toolbar-edit'
self.edit_toolbar.props.label = _('Edit'),
toolbar_box.toolbar.insert(self.edit_toolbar, -1)
self._undo = UndoManager.UndoManager(
self, self.edit_toolbar.props.page.undo.child,
self.edit_toolbar.props.page.redo.child)
self.__build_main_canvas_area()
tool = ToolbarButton()
tool.props.page = ViewToolbar(self._main_area)
tool.props.icon_name = 'toolbar-view'
tool.props.label = _('View'),
toolbar_box.toolbar.insert(tool, -1)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
toolbar_box.toolbar.insert(separator, -1)
target_toolbar = toolbar_box.toolbar
tool_offset = 4
tool = StopButton(self)
toolbar_box.toolbar.insert(tool, -1)
toolbar_box.show_all()
self.set_toolbar_box(toolbar_box)
except NameError:
# Use old <= 0.84 toolbar design
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
activity_toolbar = toolbox.get_activity_toolbar()
keep_palette = activity_toolbar.keep.get_palette()
menu_item = MenuItem(_('Portable Document Format (PDF)'))
menu_item.connect('activate', self.__export_pdf_cb)
keep_palette.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Portable Network Graphic (PNG)'))
menu_item.connect('activate', self.__export_png_cb)
keep_palette.menu.append(menu_item)
menu_item.show()
self.edit_toolbar = EditToolbar(self)
toolbox.add_toolbar(_('Edit'), self.edit_toolbar)
separator = gtk.SeparatorToolItem()
self.edit_toolbar.insert(separator, 0)
self.edit_toolbar.show()
target_toolbar = self.edit_toolbar
tool_offset = 0
self._undo = UndoManager.UndoManager(self,
self.edit_toolbar.undo.child,
self.edit_toolbar.redo.child)
self.__build_main_canvas_area()
view_toolbar = ViewToolbar(self._main_area)
toolbox.add_toolbar(_('View'), view_toolbar)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
toolbox.set_current_toolbar(1)
self.mods = [None] * 6
self.mods[0] = RadioToolButton(named_icon='select-mode')
self.mods[0].set_tooltip(_('Edit mode'))
self.mods[0].set_accelerator(_('<ctrl>e'))
self.mods[0].set_group(None)
self.mods[0].connect('clicked', self.__mode_cb, MMapArea.MODE_NULL)
target_toolbar.insert(self.mods[0], tool_offset)
self.mods[1] = RadioToolButton(named_icon='text-mode')
self.mods[1].set_tooltip(_('Text mode'))
self.mods[1].set_accelerator(_('<ctrl>t'))
self.mods[1].set_group(self.mods[0])
self.mods[1].connect('clicked', self.__mode_cb, MMapArea.MODE_TEXT)
target_toolbar.insert(self.mods[1], tool_offset + 1)
self.mods[2] = RadioToolButton(named_icon='draw-mode')
self.mods[2].set_group(self.mods[0])
self.mods[2].set_tooltip(_('Drawing mode'))
self.mods[2].set_accelerator(_('<ctrl>d'))
self.mods[2].connect('clicked', self.__mode_cb, MMapArea.MODE_DRAW)
target_toolbar.insert(self.mods[2], tool_offset + 2)
self.mods[3] = RadioToolButton(named_icon='image-mode')
self.mods[3].set_group(self.mods[0])
self.mods[3].set_tooltip(_('Image add mode'))
self.mods[3].set_accelerator(_('<ctrl>i'))
self.mods[3].connect('clicked', self.__mode_cb, MMapArea.MODE_IMAGE)
target_toolbar.insert(self.mods[3], tool_offset + 3)
self.mods[5] = RadioToolButton(named_icon='label-mode')
self.mods[5].set_tooltip(_('Label mode'))
self.mods[5].set_accelerator(_('<ctrl>a'))
self.mods[5].set_group(self.mods[0])
self.mods[5].connect('clicked', self.__mode_cb, MMapArea.MODE_LABEL)
target_toolbar.insert(self.mods[5], tool_offset + 4)
separator = gtk.SeparatorToolItem()
target_toolbar.insert(separator, tool_offset + 5)
tool = ToolButton('link')
tool.set_tooltip(_('Link/unlink two selected thoughts'))
tool.set_accelerator(_('<ctrl>l'))
tool.connect('clicked', self.__link_cb)
target_toolbar.insert(tool, tool_offset + 6)
tool = ToolButton('edit-delete')
tool.set_tooltip(_('Erase selected thought(s)'))
tool.connect('clicked', self.__delete_cb)
target_toolbar.insert(tool, tool_offset + 7)
self.show_all()
self._mode = MMapArea.MODE_TEXT
self._main_area.set_mode(self._mode)
self.mods[MMapArea.MODE_TEXT].set_active(True)
self.set_focus_child(self._main_area)
