def __init__(self, handle):
print "running activity init", handle
activity.Activity.__init__(self, handle)
print "activity running"
self.set_title('Teach Teacher')
toolbarbox = ToolbarBox()
self.set_toolbar_box(toolbarbox)
toolbar = Gtk.Toolbar()
button = ActivityToolbarButton(self)
toolbarbox.toolbar.insert(button, -1)
self.goBack = ToolButton('go-left')
self.goBack.set_tooltip("Go Back")
self.goBack.connect('clicked', self.back_clicked)
toolbar.insert(self.goBack, -1)
self.home = ToolButton('go-home')
self.home.set_tooltip("Home")
self.home.connect('clicked', self.home_clicked)
toolbar.insert(self.home, -1)
self.xois = ToolButton('computer-xo')
self.xois.set_tooltip("T's XO")
self.xois.connect('clicked', self.xois_clicked)
# toolbar.insert(self.xois, -1)
# self.xois.show()
self.guide = ToolButton('go-next')
self.guide.set_tooltip("T's Guide")
self.guide.connect('clicked', self.guide_clicked)
# toolbar.insert(self.guide, -1)
# self.guide.show()
toolbarbox.toolbar.insert(ToolbarButton(page=toolbar, icon_name='toolbar-edit'), -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbarbox.toolbar.insert(separator, -1)
stop_button = StopButton(self)
toolbarbox.toolbar.insert(stop_button, -1)
scroll = Gtk.ScrolledWindow()
self.set_canvas(scroll)
self.webview = WebView()
self.webview.load_uri('http://147.47.120.20/~tsquare/menu.php')
scroll.add(self.webview)
toolbar.show_all()
toolbarbox.show_all()
toolbarbox.toolbar.show_all()
self.show_all()
print "AT END OF THE CLASS"
def add_button(icon_name, tooltip, func):
def callback(source):
func()
button = ToolButton(icon_name)
toolbar.add(button)
button.connect('clicked', callback)
button.set_tooltip(tooltip)
def __init__(self):
ToolButton.__init__(self)
self._property = 'timestamp'
self._order = Gtk.SortType.ASCENDING
self.props.tooltip = _('Sort view')
self.props.icon_name = 'view-lastedit'
self.props.hide_tooltip_on_click = False
self.palette_invoker.props.toggle_palette = True
menu_box = PaletteMenuBox()
self.props.palette.set_content(menu_box)
menu_box.show()
sort_options = [
('timestamp', 'view-lastedit', _('Sort by date modified')),
('creation_time', 'view-created', _('Sort by date created')),
('filesize', 'view-size', _('Sort by size')),
]
for property_, icon, label in sort_options:
button = PaletteMenuItem(label)
button_icon = Icon(pixel_size=style.SMALL_ICON_SIZE,
icon_name=icon)
button.set_image(button_icon)
button_icon.show()
button.connect('activate',
self.__sort_type_changed_cb,
property_,
icon)
button.show()
menu_box.append_item(button)
class TitleBox(VolumesToolbar):
__gtype_name__ = 'TitleBox'
def __init__(self):
VolumesToolbar.__init__(self)
label = Gtk.Label()
label.set_markup('<b>%s</b>' % _('Choose an object'))
label.set_alignment(0, 0.5)
self._add_widget(label, expand=True)
self.close_button = ToolButton(icon_name='dialog-cancel')
self.close_button.set_tooltip(_('Close'))
self.insert(self.close_button, -1)
self.close_button.show()
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 __init__(self):
Gtk.Toolbar.__init__(self)
self._zoom_out = ToolButton('zoom-out')
self._zoom_out.set_tooltip(_('Zoom out'))
self._zoom_out.connect('clicked', self._zoom_out_cb)
self.insert(self._zoom_out, -1)
self._zoom_out.props.sensitive = False
self._zoom_out.show()
self._zoom_in = ToolButton('zoom-in')
self._zoom_in.set_tooltip(_('Zoom in'))
self._zoom_in.connect('clicked', self._zoom_in_cb)
self.insert(self._zoom_in, -1)
self._zoom_in.props.sensitive = True
self._zoom_in.show()
spacer = Gtk.SeparatorToolItem()
spacer.props.draw = False
self.insert(spacer, -1)
spacer.show()
self._fullscreen = ToolButton('view-fullscreen')
self._fullscreen.set_tooltip(_('Fullscreen'))
self._fullscreen.connect('clicked', self._fullscreen_cb)
self.insert(self._fullscreen, -1)
self._fullscreen.show()
class BasicToolbar(Gtk.Toolbar):
def __init__(self, title):
GObject.GObject.__init__(self)
self.modify_bg(Gtk.StateType.NORMAL,
style.COLOR_BLACK.get_gdk_color())
label = Gtk.Label()
label.set_markup('<b>%s</b>' % title)
label.set_halign(Gtk.Align.START)
tool_item = Gtk.ToolItem()
tool_item.set_expand(True)
tool_item.add(label)
tool_item.show_all()
tool_item.props.margin_left = style.GRID_CELL_SIZE / 2
self.insert(tool_item, -1)
self.separator = Gtk.SeparatorToolItem()
self.separator.props.draw = False
self.separator.set_expand(True)
self.insert(self.separator, -1)
self.stop = ToolButton(icon_name='dialog-cancel')
self.stop.set_tooltip(_('Cancel'))
self.insert(self.stop, -1)
self.stop.show()
def __init__(self, activity, **kwargs):
ToolButton.__init__(self, 'edit-cloud', **kwargs)
self.set_tooltip(_('Cloud Text'))
self.palette_invoker.props.toggle_palette = True
self.palette_invoker.props.lock_palette = True
self.props.hide_tooltip_on_click = False
self._palette = self.get_palette()
description_box = PaletteMenuBox()
sw = Gtk.ScrolledWindow()
sw.set_size_request(int(Gdk.Screen.width() / 3),
5 * style.GRID_CELL_SIZE)
sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self._text_view = Gtk.TextView()
self._text_view.set_left_margin(style.DEFAULT_PADDING)
self._text_view.set_right_margin(style.DEFAULT_PADDING)
self._text_view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
self._text_buffer = Gtk.TextBuffer()
self._text_buffer.set_text(_TEXT)
self._text_view.set_buffer(self._text_buffer)
self._text_view.connect('focus-in-event', self._text_focus_in_cb)
sw.add(self._text_view)
description_box.append_item(sw, vertical_padding=0)
self._palette.set_content(description_box)
description_box.show_all()
self.set_expanded(True)
def __init__(self):
Gtk.Toolbar.__init__(self)
book_search_item = Gtk.ToolItem()
self.search_entry = Gtk.Entry()
self.search_entry.connect('activate', self.search_entry_activate_cb)
self.search_entry.connect("key_press_event", self.keypress_cb)
width = int(Gdk.Screen.width() / 2)
self.search_entry.set_size_request(width, -1)
book_search_item.add(self.search_entry)
self.search_entry.show()
self.search_entry.grab_focus()
self.insert(book_search_item, -1)
book_search_item.show()
self.download = ToolButton('go-down')
self.download.set_tooltip(_('Get Book'))
self.download.props.sensitive = False
self.download.connect('clicked', self.get_book_cb)
self.insert(self.download, -1)
self.download.show()
self.hide_results = ToolButton('dialog-cancel')
self.hide_results.set_tooltip(_('Remove Results List'))
self.hide_results.props.sensitive = False
self.hide_results.connect('clicked', self.hide_results_cb)
self.insert(self.hide_results, -1)
self.hide_results.show()
def __init__(self, _activity):
GObject.GObject.__init__(self)
self._activity = _activity
self.theme_state = "light"
self.font_size = DEFAULT_FONT_SIZE
self.theme_toggler = ToolButton('dark-theme')
self.theme_toggler.connect('clicked', self._toggled_theme)
self.theme_toggler.set_tooltip('Switch to Dark Theme')
self.insert(self.theme_toggler, -1)
self.theme_toggler.show()
sep = Gtk.SeparatorToolItem()
self.insert(sep, -1)
sep.show()
self.font_plus = ToolButton('zoom-in')
self.font_plus.connect('clicked', self._font_size_increase)
self.font_plus.set_tooltip('Zoom out')
self.insert(self.font_plus, -1)
self.font_plus.show()
self.font_minus = ToolButton('zoom-out')
self.font_minus.connect('clicked', self._font_size_decrease)
self.font_minus.set_tooltip('Zoom in')
self.insert(self.font_minus, -1)
self.font_minus.show()
self.show()
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()
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(False)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
button = ToolButton('speaker-muted-100')
button.set_tooltip(_('Sound'))
button.connect('clicked', self.sound_control)
toolbar_box.toolbar.insert(button, -1)
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 add_text_icon_and_button(self, text, icon_name,
button_icon=None,
button_label=None,
size='large', bold=False,
color=style.COLOR_BLACK.get_html(),
justify=Gtk.Justification.LEFT,
stroke=style.COLOR_BUTTON_GREY.get_svg(),
fill=style.COLOR_TRANSPARENT.get_svg(),
icon_size=style.XLARGE_ICON_SIZE):
label = Gtk.Label()
label.set_use_markup(True)
label.set_justify(justify)
if bold:
text = '<b>' + text + '</b>'
span = '<span foreground="%s" size="%s">' % (color, size)
label.set_markup(span + text + '</span>')
icon = Icon(pixel_size=icon_size, icon_name=icon_name,
stroke_color=stroke, fill_color=fill)
if button_icon is not None:
button = ToolButton(button_icon)
else:
button = Gtk.Button()
button.set_label(button_label)
self._attach_three(label, icon, button)
label.show()
icon.show()
button.show()
return button
class TitleBox(Gtk.Toolbar):
def __init__(self, title_text):
Gtk.Toolbar.__init__(self)
label = Gtk.Label()
title = _(title_text)
label.set_markup('<b>%s</b>' % title)
label.set_alignment(0, 0.5)
self._add_widget(label, expand=True)
self.close_button = ToolButton(icon_name='dialog-cancel')
"""
self.close_button.set_tooltip(_('Close'))
"""
self.insert(self.close_button, -1)
self.close_button.show()
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 make_toolbar(self):
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self._go_home = ToolButton('go-home')
self._go_home.set_tooltip(_('Home page'))
self._go_home.connect('clicked', self._go_home_cb)
toolbar_box.toolbar.insert(self._go_home, -1)
self._go_home.show()
self._browse = ToolButton('browse')
self._browse.set_tooltip(_('Open in Browse'))
self._browse.connect('clicked', self._do_browse_clicked_cb)
toolbar_box.toolbar.insert(self._browse, -1)
self._browse.show()
separator=Gtk.SeparatorToolItem(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.set_toolbar_box(toolbar_box)
toolbar_box.show()
def __init__(self, name):
ToolButton.__init__(self)
self._name = name
self._icon = None
self.set_palette_invoker(FrameWidgetInvoker(self))
self.palette_invoker.cache_palette = False
self.connect('clicked', self.__clicked_cb)
def __init__(self):
ToolButton.__init__(self)
self._property = 'timestamp'
self._order = Gtk.SortType.ASCENDING
self.props.tooltip = _('Sort view')
self.props.icon_name = 'view-lastedit'
self.props.hide_tooltip_on_click = False
self.palette_invoker.props.toggle_palette = True
menu_box = PaletteMenuBox()
self.props.palette.set_content(menu_box)
menu_box.show()
for property_, icon, label in self._SORT_OPTIONS:
button = PaletteMenuItem(label)
button_icon = Icon(icon_size=Gtk.IconSize.MENU, icon_name=icon)
button.set_image(button_icon)
button_icon.show()
button.connect('activate',
self.__sort_type_changed_cb,
property_,
icon)
button.show()
menu_box.append_item(button)
def __init__(self):
Gtk.Toolbar.__init__(self)
self._add_separator()
self._icon = Icon()
self._add_widget(self._icon)
self._add_separator()
self._title = Gtk.Label()
self._add_widget(self._title)
self._add_separator(True)
self.cancel_button = ToolButton('dialog-cancel')
self.cancel_button.set_tooltip(_('Cancel'))
self.cancel_button.connect('clicked', self.__cancel_button_clicked_cb)
self.insert(self.cancel_button, -1)
self.cancel_button.show()
self.accept_button = ToolButton('dialog-ok')
self.accept_button.set_tooltip(_('Ok'))
self.accept_button.connect('clicked', self.__accept_button_clicked_cb)
self.insert(self.accept_button, -1)
self.accept_button.show()
def _add_level_slider(self, toolbar):
self._level_stepper_down = ToolButton('easy')
self._level_stepper_down.set_tooltip(_('Easier'))
self._level_stepper_down.connect('clicked',
self._level_stepper_down_cb)
self._level_stepper_down.show()
self._adjustment = Gtk.Adjustment.new(
1, self.LOWER, self.UPPER, 1, 5, 0)
self._adjustment.connect('value_changed', self._level_change_cb)
self._level_range = Gtk.Scale.new(
orientation=Gtk.Orientation.HORIZONTAL,
adjustment=self._adjustment)
self._level_range.set_draw_value(False)
self._level_range.set_size_request(120, 15)
self._level_range.show()
self._level_stepper_up = ToolButton('hard')
self._level_stepper_up.set_tooltip(_('Harder'))
self._level_stepper_up.connect('clicked', self._level_stepper_up_cb)
self._level_stepper_up.show()
self._level_range_tool = Gtk.ToolItem()
self._level_range_tool.add(self._level_range)
self._level_range_tool.show()
toolbar.insert(self._level_stepper_down, -1)
toolbar.insert(self._level_range_tool, -1)
toolbar.insert(self._level_stepper_up, -1)
return
def __init__(self, icon_name, title=''):
GObject.GObject.__init__(self)
icon = ToolButton(icon_name)
self.insert(icon, -1)
label = Gtk.Label()
label.set_markup('<b>%s</b>' % title)
label.set_alignment(0, 0.5)
tool_item = Gtk.ToolItem()
tool_item.set_expand(True)
tool_item.add(label)
tool_item.show_all()
self.insert(tool_item, -1)
self.separator = Gtk.SeparatorToolItem()
self.separator.props.draw = False
self.separator.set_expand(True)
self.insert(self.separator, -1)
self.stop = ToolButton(icon_name='dialog-cancel')
self.stop.set_tooltip(_('Cancel'))
self.insert(self.stop, -1)
self.stop.show()
self.confirm = ToolButton(icon_name='dialog-ok')
self.confirm.set_tooltip(_('Done'))
self.insert(self.confirm, -1)
self.confirm.show()
def __init__(self, child, label, path, tabs):
GObject.GObject.__init__(self)
self.child = child
self.label_text = label
self._path = path # Hide the path in the label
self.tabs = tabs
self.label_box = Gtk.EventBox()
self._label = Gtk.Label(label=self.label_text)
self._label.set_alignment(0, 0.5)
self._label.show()
self.label_box.add(self._label)
self.label_box.connect('button-press-event', self._label_clicked)
self.label_box.show_all()
self.pack_start(self.label_box, True, True, 5)
self.label_entry = Gtk.Entry()
self.label_entry.connect('activate', self._label_entry_cb)
self.label_entry.connect('focus-out-event', self._label_entry_cb)
self.pack_start(self.label_entry, True, True, 0)
button = ToolButton('close-tab')
button.connect('clicked', self.__button_clicked_cb)
self.pack_start(button, False, True, 0)
button.show()
self._close_button = button
tab_object.append(self)
def build_toolbar(self):
toolbox = ToolbarBox()
toolbar = toolbox.toolbar
label = Gtk.Label(_('Open an example bundle'))
label.modify_fg(Gtk.StateType.NORMAL,
Gdk.color_parse('white'))
item = Gtk.ToolItem()
item.add(label)
close = ToolButton('entry-cancel')
close.connect('clicked', self._destroy)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar.insert(item, -1)
toolbar.insert(separator, -1)
toolbar.insert(close, -1)
toolbox.set_size_request(-1, 35)
return toolbox
def __init__(self):
Gtk.ComboBox.__init__(self)
ToolButton.__init__(self, icon_name='font-text',
tooltip=_('Select font'))
self.connect('clicked', self.__font_selection_cb)
context = self.get_pango_context()
self._init_font_list()
self._font_name = 'Sans'
font_names = []
for family in context.list_families():
name = family.get_name()
if name in self._font_white_list:
font_names.append(name)
for font_name in sorted(font_names):
menu_item = MenuItem(font_name)
markup = '<span font="%s">%s</span>' % (font_name, font_name)
menu_item.get_children()[0].set_markup(markup)
menu_item.connect('activate', self.__menu_activated, font_name)
self.props.palette.menu.append(menu_item)
menu_item.show()
self.show()
def _add_speed_slider(self, toolbar):
self._speed_stepper_down = ToolButton('speed-down')
self._speed_stepper_down.set_tooltip(_('Slow down'))
self._speed_stepper_down.connect('clicked',
self._speed_stepper_down_cb)
self._speed_stepper_down.show()
self._adjustment = Gtk.Adjustment.new(
200, self.LOWER, self.UPPER, 25, 100, 0)
self._adjustment.connect('value_changed', self._speed_change_cb)
self._speed_range = Gtk.HScale.new(self._adjustment)
self._speed_range.set_inverted(True)
self._speed_range.set_draw_value(False)
self._speed_range.set_size_request(120, 15)
self._speed_range.show()
self._speed_stepper_up = ToolButton('speed-up')
self._speed_stepper_up.set_tooltip(_('Speed up'))
self._speed_stepper_up.connect('clicked', self._speed_stepper_up_cb)
self._speed_stepper_up.show()
self._speed_range_tool = Gtk.ToolItem()
self._speed_range_tool.add(self._speed_range)
self._speed_range_tool.show()
toolbar.insert(self._speed_stepper_down, -1)
toolbar.insert(self._speed_range_tool, -1)
toolbar.insert(self._speed_stepper_up, -1)
return
def __init__(self, activity, **kwargs):
ToolButton.__init__(self, 'edit-description', **kwargs)
self.set_tooltip(_('Description'))
self.palette_invoker.props.toggle_palette = True
self.palette_invoker.props.lock_palette = True
self.props.hide_tooltip_on_click = False
self._palette = self.get_palette()
description_box = PaletteMenuBox()
sw = Gtk.ScrolledWindow()
sw.set_size_request(int(Gdk.Screen.width() / 2),
2 * style.GRID_CELL_SIZE)
sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self._text_view = Gtk.TextView()
self._text_view.set_left_margin(style.DEFAULT_PADDING)
self._text_view.set_right_margin(style.DEFAULT_PADDING)
self._text_view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
text_buffer = Gtk.TextBuffer()
if 'description' in activity.metadata:
text_buffer.set_text(activity.metadata['description'])
self._text_view.set_buffer(text_buffer)
self._text_view.connect('focus-out-event',
self.__description_changed_cb, activity)
sw.add(self._text_view)
description_box.append_item(sw, vertical_padding=0)
self._palette.set_content(description_box)
description_box.show_all()
activity.metadata.connect('updated', self.__jobject_updated_cb)
class TitleBox(VolumesToolbar):
__gtype_name__ = 'TitleBox'
def __init__(self, what_filter='', filter_type=None):
VolumesToolbar.__init__(self)
label = Gtk.Label()
title = _('Choose an object')
if filter_type == FILTER_TYPE_MIME_BY_ACTIVITY:
registry = bundleregistry.get_registry()
bundle = registry.get_bundle(what_filter)
if bundle is not None:
title = _('Choose an object to open with %s activity') % \
bundle.get_name()
label.set_markup('<b>%s</b>' % title)
label.set_alignment(0, 0.5)
self._add_widget(label, expand=True)
self.close_button = ToolButton(icon_name='dialog-cancel')
self.close_button.set_tooltip(_('Close'))
self.insert(self.close_button, -1)
self.close_button.show()
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 _create_export_button(self):
# Add expoprt button
export_data = ToolButton('save-as-data')
export_data.props.tooltip = _('Export data')
export_data.props.hide_tooltip_on_click = False
export_data.palette_invoker.props.toggle_palette = True
export_data.show()
menu_box = PaletteMenuBox()
export_data.props.palette.set_content(menu_box)
menu_item = PaletteMenuItem(text_label=_('Export credits by day'))
menu_item.connect('activate', self.__export_data_to_chart_cb,
'credit', DAY)
menu_box.append_item(menu_item)
menu_item = PaletteMenuItem(text_label=_('Export debits by day'))
menu_item.connect('activate', self.__export_data_to_chart_cb,
'debit', DAY)
menu_box.append_item(menu_item)
menu_item = PaletteMenuItem(text_label=_('Export credits by month'))
menu_item.connect('activate', self.__export_data_to_chart_cb,
'credit', MONTH)
menu_box.append_item(menu_item)
menu_item = PaletteMenuItem(text_label=_('Export debits by month'))
menu_item.connect('activate', self.__export_data_to_chart_cb,
'debit', MONTH)
menu_box.append_item(menu_item)
menu_box.show_all()
return export_data
def __init__(self, activity):
GObject.GObject.__init__(self)
self._activity = activity
self._browser = self._activity._web_view
self.zoomout = ToolButton('zoom-out')
self.zoomout.set_tooltip(_('Zoom out'))
self.zoomout.connect('clicked', self.__zoomout_clicked_cb)
self.insert(self.zoomout, -1)
self.zoomout.show()
self.zoomin = ToolButton('zoom-in')
self.zoomin.set_tooltip(_('Zoom in'))
self.zoomin.connect('clicked', self.__zoomin_clicked_cb)
self.insert(self.zoomin, -1)
self.zoomin.show()
self.separator = Gtk.SeparatorToolItem()
self.separator.set_draw(True)
self.insert(self.separator, -1)
self.separator.show()
self.fullscreen = ToolButton('view-fullscreen')
self.fullscreen.set_tooltip(_('Fullscreen'))
self.fullscreen.connect('clicked', self.__fullscreen_clicked_cb)
self.insert(self.fullscreen, -1)
self.fullscreen.show()
def __init__(self, web_view):
GObject.GObject.__init__(self)
self._web_view = web_view
self._back = ToolButton('go-previous-paired')
self._back.set_tooltip(_('Back'))
self._back.props.sensitive = False
self._back.connect('clicked', self._go_back_cb)
self.insert(self._back, -1)
self._back.show()
self._forward = ToolButton('go-next-paired')
self._forward.set_tooltip(_('Forward'))
self._forward.props.sensitive = False
self._forward.connect('clicked', self._go_forward_cb)
self.insert(self._forward, -1)
self._forward.show()
self._home = ToolButton('go-home')
self._home.set_tooltip(_('Home'))
self._home.connect('clicked', self._go_home_cb)
self.insert(self._home, -1)
self._home.show()
self._web_view.connect('notify::uri', self._uri_changed_cb)
class QrReader(activity.Activity):
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.realize()
self.qr_window = Gtk.DrawingArea()
self.qr_window.set_double_buffered(False)
self.qr_window.set_app_paintable(True)
self.image = Gtk.Image()
self.box = Gtk.VBox()
self.box.pack_start(self.qr_window, True, True, 0)
self.box.pack_end(self.image, True, True, 0)
self.set_canvas(self.box)
self.build_toolbar()
self.show_all()
self.image.hide()
GObject.idle_add(self.setup_init)
def build_toolbar(self):
toolbox = ToolbarBox()
toolbar = toolbox.toolbar
activity_button = ActivityButton(self)
toolbar.insert(activity_button, -1)
toolbar.insert(Gtk.SeparatorToolItem(), -1)
self.stop_play = ToogleButton('media-playback-start')
self.stop_play.set_tooltip(_("Turn on/off the camera"))
self.stop_play.props.active = True
self.copylink = ToolButton('text-uri-list')
self.copylink.set_tooltip(_("Copy link to clipboard"))
self.copylink.set_sensitive(False)
toolbar.insert(self.stop_play, -1)
toolbar.insert(self.copylink, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar.insert(separator, -1)
stopbtn = StopButton(self)
toolbar.insert(stopbtn, -1)
toolbar.show_all()
self.set_toolbar_box(toolbox)
def setup_init(self):
xid = self.qr_window.get_property('window').get_xid()
visor = QrVisor(xid, self.stop_play, self, self.qr_window,
self.copylink, self.image)
visor.play()
class BaseWindow(Gtk.Box):
'''
A basic Sugar style popover window.
Like view source mode.
Use self to add content to a vbox.
'''
__gtype_name__ = 'BibliographyBaseWindow'
def __init__(self):
Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL)
self.props.halign = Gtk.Align.CENTER
self.props.valign = Gtk.Align.CENTER
self._tb = Gtk.Toolbar()
self.pack_start(self._tb, True, True, 0)
self._tb.show()
sep = Gtk.SeparatorToolItem()
sep.props.draw = False
self._tb.insert(sep, -1)
sep.show()
label = Gtk.Label()
label.set_markup('<b>{}</b>'.format(_('Edit Bibliography Entry')))
label.set_alignment(0, 0.5)
self._add_widget(label)
sep = Gtk.SeparatorToolItem()
sep.props.draw = False
sep.props.expand = True
self._tb.insert(sep, -1)
sep.show()
self.add_ = ToolButton(icon_name='dialog-ok')
self.add_.set_tooltip(_('Add Bibliography Item'))
self._tb.insert(self.add_, -1)
self.add_.show()
stop = ToolButton(icon_name='dialog-cancel')
stop.set_tooltip(_('Close'))
stop.connect('clicked', lambda *args: self.destroy())
self._tb.insert(stop, -1)
stop.show()
self.show()
def _add_widget(self, widget):
t = Gtk.ToolItem()
t.props.expand = True
t.add(widget)
widget.show()
self._tb.insert(t, -1)
t.show()
def __init__(self, page=None, **kwargs):
ToolButton.__init__(self, **kwargs)
self.page_widget = None
self.set_page(page)
self.connect("clicked", lambda widget: self.set_expanded(not self.is_expanded()))
self.connect_after("draw", self.__drawing_cb)
self.connect("hierarchy-changed", self.__hierarchy_changed_cb)
class BasicToolbar(Gtk.Toolbar):
def __init__(self, title):
GObject.GObject.__init__(self)
self.modify_bg(Gtk.StateType.NORMAL, style.COLOR_BLACK.get_gdk_color())
label = Gtk.Label()
label.set_markup('<b>%s</b>' % title)
label.set_halign(Gtk.Align.START)
tool_item = Gtk.ToolItem()
tool_item.set_expand(True)
tool_item.add(label)
tool_item.show_all()
tool_item.props.margin_left = style.GRID_CELL_SIZE / 2
self.insert(tool_item, -1)
self.separator = Gtk.SeparatorToolItem()
self.separator.props.draw = False
self.separator.set_expand(True)
self.insert(self.separator, -1)
self.stop = ToolButton(icon_name='dialog-cancel')
self.stop.set_tooltip(_('Cancel'))
self.insert(self.stop, -1)
self.stop.show()
class BooksToolbar(Gtk.Toolbar):
__gtype_name__ = 'BooksToolbar'
def __init__(self):
Gtk.Toolbar.__init__(self)
book_search_item = Gtk.ToolItem()
self.search_entry = Gtk.Entry()
self.search_entry.connect('activate', self.search_entry_activate_cb)
width = int(Gdk.Screen.width() / 2)
self.search_entry.set_size_request(width, -1)
book_search_item.add(self.search_entry)
self.search_entry.show()
self.insert(book_search_item, -1)
book_search_item.show()
self._download = ToolButton('go-down')
self._download.set_tooltip(_('Get Book'))
self._download.props.sensitive = False
self._download.connect('clicked', self._get_book_cb)
self.insert(self._download, -1)
self._download.show()
self.format_combo = ComboBox()
self.format_combo.connect('changed', self.format_changed_cb)
self.format_combo.append_item('.djvu', 'Deja Vu')
self.format_combo.append_item('_bw.pdf', 'B/W PDF')
self.format_combo.append_item('.pdf', 'Color PDF')
self.format_combo.append_item('.epub', 'EPUB')
self.format_combo.set_active(0)
self.format_combo.props.sensitive = False
combotool = ToolComboBox(self.format_combo)
self.insert(combotool, -1)
combotool.show()
self.search_entry.grab_focus()
def set_activity(self, activity):
self.activity = activity
def format_changed_cb(self, combo):
if self.activity != None:
self.activity.show_book_data()
def search_entry_activate_cb(self, entry):
self.activity.find_books(entry.props.text)
def _get_book_cb(self, button):
self.activity.get_book()
def enable_button(self, state):
self._download.props.sensitive = state
self.format_combo.props.sensitive = state
def __init__(self):
Gtk.Toolbar.__init__(self)
book_search_item = Gtk.ToolItem()
self.search_entry = Gtk.Entry()
self.search_entry.connect('activate', self.search_entry_activate_cb)
width = int(Gdk.Screen.width() / 2)
self.search_entry.set_size_request(width, -1)
book_search_item.add(self.search_entry)
self.search_entry.show()
self.insert(book_search_item, -1)
book_search_item.show()
self._download = ToolButton('go-down')
self._download.set_tooltip(_('Get Book'))
self._download.props.sensitive = False
self._download.connect('clicked', self._get_book_cb)
self.insert(self._download, -1)
self._download.show()
self.format_combo = ComboBox()
self.format_combo.connect('changed', self.format_changed_cb)
self.format_combo.append_item('.djvu', 'Deja Vu')
self.format_combo.append_item('_bw.pdf', 'B/W PDF')
self.format_combo.append_item('.pdf', 'Color PDF')
self.format_combo.append_item('.epub', 'EPUB')
self.format_combo.set_active(0)
self.format_combo.props.sensitive = False
combotool = ToolComboBox(self.format_combo)
self.insert(combotool, -1)
combotool.show()
self.search_entry.grab_focus()
def _create_edit_toolbar(self):
edit_toolbar = EditToolbar()
edit_toolbar.undo.props.visible = False
edit_toolbar.redo.props.visible = False
edit_toolbar.separator.props.visible = False
edit_toolbar.copy.connect('clicked', self.__copy_cb)
edit_toolbar.copy.props.accelerator = '<Ctrl><Shift>C'
edit_toolbar.paste.connect('clicked', self.__paste_cb)
edit_toolbar.paste.props.accelerator = '<Ctrl><Shift>V'
clear = ToolButton('edit-clear')
clear.set_tooltip(_('Clear scrollback'))
clear.connect('clicked', self.__clear_cb)
edit_toolbar.insert(clear, -1)
clear.show()
return edit_toolbar
def common_playback_buttons(toolbar, owner):
""" Playback and mute buttons are either on the main toolbar or
the Playback toolbar, depending upon whether or not the new
toolbars are available. """
toolbar.stopButton = ToolButton('media-playback-stop')
toolbar.stopButton.connect('clicked', owner.handleStopButton)
toolbar.insert(toolbar.stopButton, -1)
toolbar.stopButton.show()
toolbar.stopButton.set_tooltip(_('Stop Loops'))
toolbar.muteButton = ToggleToolButton('mute')
toolbar.muteButton.connect('clicked', owner.handleMuteButton)
toolbar.insert(toolbar.muteButton, -1)
toolbar.muteButton.show()
toolbar.muteButton.set_tooltip(_('Mute Loops'))
def __init__(self, activity):
GObject.GObject.__init__(self)
self._browser = None
self._activity = activity
self._activity.tray.connect('unmap', self.__unmap_cb)
self._activity.tray.connect('map', self.__map_cb)
self.zoomout = ToolButton('zoom-out')
self.zoomout.set_tooltip(_('Zoom out'))
self.zoomout.connect('clicked', self.__zoomout_clicked_cb)
self.insert(self.zoomout, -1)
self.zoomout.show()
self.zoomin = ToolButton('zoom-in')
self.zoomin.set_tooltip(_('Zoom in'))
self.zoomin.connect('clicked', self.__zoomin_clicked_cb)
self.insert(self.zoomin, -1)
self.zoomin.show()
self.separator = Gtk.SeparatorToolItem()
self.separator.set_draw(True)
self.insert(self.separator, -1)
self.separator.show()
self.fullscreen = ToolButton('view-fullscreen')
self.fullscreen.set_tooltip(_('Fullscreen'))
self.fullscreen.connect('clicked', self.__fullscreen_clicked_cb)
self.insert(self.fullscreen, -1)
self.fullscreen.show()
self.traybutton = ToolButton('tray-hide')
self.traybutton.connect('clicked', self.__tray_clicked_cb)
self.traybutton.props.sensitive = False
self.insert(self.traybutton, -1)
self.traybutton.show()
tabbed_view = self._activity.get_canvas()
if tabbed_view.get_n_pages():
self._connect_to_browser(tabbed_view.props.current_browser)
tabbed_view.connect_after('switch-page', self.__switch_page_cb)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.max_participants = 1
self.sound_enable = True
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
separator = Gtk.SeparatorToolItem()
separator.props.draw = True
toolbox.toolbar.insert(separator, -1)
separator.show()
sound_button = ToolButton('speaker-muted-100')
sound_button.set_tooltip(_('Sound'))
sound_button.connect('clicked', self.sound_control)
toolbox.toolbar.insert(sound_button, -1)
sound_button.show()
separator2 = Gtk.SeparatorToolItem()
separator2.props.draw = False
separator2.set_expand(True)
toolbox.toolbar.insert(separator2, -1)
separator2.show()
stop_button = StopButton(self)
stop_button.props.accelerator = _('<Ctrl>Q')
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
toolbox.show()
self.set_toolbar_box(toolbox)
self.show_all()
self.game = conozco.Conozco(self)
self.game.canvas = sugargame.canvas.PygameCanvas(
self, main=self.game.run, modules=[
pygame.display, pygame.font, pygame.mixer])
self.set_canvas(self.game.canvas)
self.game.canvas.grab_focus()
def __init__(self, activity_name):
Gtk.Toolbar.__init__(self)
title = 'Help: ' + activity_name
self._add_separator(False)
label = Gtk.Label()
label.set_markup('<b>%s</b>' % title)
label.set_alignment(0, 0.5)
self._add_widget(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()
class ClassifyCats(activity.Activity):
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.make_toolbar()
self.timeout_id = None
self.area = GameArea()
self.set_canvas(self.area)
self.show_all()
def make_toolbar(self):
toolbarbox = ToolbarBox()
self.set_toolbar_box(toolbarbox)
button = ActivityToolbarButton(self)
toolbarbox.toolbar.insert(button, -1)
toolbarbox.toolbar.insert(Gtk.SeparatorToolItem(), -1)
self.button = ToolButton("star")
self.button.set_tooltip(_("Start"))
self.button.connect("clicked", self._change)
toolbarbox.toolbar.insert(self.button, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbarbox.toolbar.insert(separator, -1)
button = StopButton(self)
toolbarbox.toolbar.insert(button, -1)
def _change(self, button):
if self.area.timeout_id is None:
self.button.set_tooltip(_("Stop"))
self.area.start()
else:
self.button.set_tooltip(_("Start"))
self.area.stop()
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)
# new game button
new_game = ToolButton('new-game')
new_game.connect('clicked', self._new_game)
new_game.set_tooltip(_('New game'))
toolbar_box.toolbar.insert(new_game, -1)
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 _create_back_button(self):
back = ToolButton('go-previous-paired')
back.set_tooltip(_('Back'))
back.props.sensitive = False
palette = back.get_palette()
previous_page = MenuItem(text_label=_("Previous page"))
previous_page.show()
previous_bookmark = MenuItem(text_label=_("Previous bookmark"))
previous_bookmark.show()
palette.menu.append(previous_page)
palette.menu.append(previous_bookmark)
back.connect('clicked', self.__go_back_cb)
previous_page.connect('activate', self.__go_back_page_cb)
previous_bookmark.connect('activate', self.__prev_bookmark_activate_cb)
return back
def _create_forward_button(self):
forward = ToolButton('go-next-paired')
forward.set_tooltip(_('Forward'))
forward.props.sensitive = False
palette = forward.get_palette()
next_page = MenuItem(text_label=_("Next page"))
next_page.show()
next_bookmark = MenuItem(text_label=_("Next bookmark"))
next_bookmark.show()
palette.menu.append(next_page)
palette.menu.append(next_bookmark)
forward.connect('clicked', self.__go_forward_cb)
next_page.connect('activate', self.__go_forward_page_cb)
next_bookmark.connect('activate', self.__next_bookmark_activate_cb)
return forward
class Toolbar(ToolbarBox):
def __init__(self, activity):
ToolbarBox.__init__(self)
activity_button = ActivityToolbarButton(activity)
self.toolbar.insert(activity_button, 0)
activity_button.show()
separator = Gtk.SeparatorToolItem()
self.toolbar.insert(separator, -1)
self.choose_button = ToolButton('view-list')
self.choose_button.set_tooltip(_('Choose a Poll'))
self.toolbar.insert(self.choose_button, -1)
self.create_button = ToolButton('view-source')
self.create_button.set_tooltip(_('Build a Poll'))
self.toolbar.insert(self.create_button, -1)
self.settings_button = ToolButton('preferences-system')
self.settings_button.set_tooltip(_('Settings'))
self.toolbar.insert(self.settings_button, -1)
self.help_button = ToolButton('toolbar-help')
self.help_button.set_tooltip(_('Lesson Plans'))
self.toolbar.insert(self.help_button, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.toolbar.insert(separator, -1)
separator.show()
self.toolbar.insert(StopButton(activity), -1)
self.show_all()
def make_toolbar(self):
toolbarbox = ToolbarBox()
self.set_toolbar_box(toolbarbox)
toolbar = toolbarbox.toolbar
button = ActivityToolbarButton(self)
toolbar.insert(button, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar.insert(separator, -1)
button = ToolButton("save-colors")
button.set_tooltip(_("Save colors"))
button.connect("clicked", self._save_colors)
toolbar.insert(button, -1)
button = StopButton(self)
toolbar.insert(button, -1)
def __init__(self, activity):
GObject.GObject.__init__(self)
self._activity = activity
self._browser = self._activity._web_view
self.zoomout = ToolButton('zoom-out', accelerator='<ctrl>minus')
self.zoomout.set_tooltip(_('Zoom out'))
self.zoomout.connect('clicked', self.__zoomout_clicked_cb)
self.insert(self.zoomout, -1)
self.zoomout.show()
self.zoomin = ToolButton('zoom-in', accelerator='<ctrl>plus')
self.zoomin.set_tooltip(_('Zoom in'))
self.zoomin.connect('clicked', self.__zoomin_clicked_cb)
self.insert(self.zoomin, -1)
self.zoomin.show()
self.zoom_original = ToolButton('zoom-original', accelerator='<ctrl>0')
self.zoom_original.set_tooltip(_('Actual size'))
self.zoom_original.connect('clicked', self.__zoom_original_clicked_cb)
self.insert(self.zoom_original, -1)
self.zoom_original.show()
self._zoom_update_sensitive()
self.separator = Gtk.SeparatorToolItem()
self.separator.set_draw(True)
self.insert(self.separator, -1)
self.separator.show()
self.fullscreen = ToolButton('view-fullscreen')
self.fullscreen.set_tooltip(_('Fullscreen'))
self.fullscreen.connect('clicked', self.__fullscreen_clicked_cb)
self.insert(self.fullscreen, -1)
self.fullscreen.show()
def __init__(self, handle):
"The entry point to the Activity"
activity.Activity.__init__(self, handle, False)
self.max_participants = 1
self._sequence = 0
self.selected_book = None
self.queryresults = None
self._getter = None
self.show_images = True
self.languages = {}
self._lang_code_handler = languagenames.LanguageNames()
self.catalogs_configuration = {}
self.catalog_history = []
if os.path.exists('/etc/get-books.cfg'):
self._read_configuration('/etc/get-books.cfg')
else:
self._read_configuration()
toolbar_box = ToolbarBox()
activity_button = ToolButton()
color = profile.get_color()
bundle = ActivityBundle(activity.get_bundle_path())
icon = Icon(file=bundle.get_icon(), xo_color=color)
activity_button.set_icon_widget(icon)
activity_button.show()
toolbar_box.toolbar.insert(activity_button, 0)
self._add_search_controls(toolbar_box.toolbar)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
toolbar_box.toolbar.insert(StopButton(self), -1)
self.set_toolbar_box(toolbar_box)
toolbar_box.show_all()
self._books_toolbar = toolbar_box.toolbar
self._create_controls()
self.using_powerd = os.access(POWERD_INHIBIT_DIR, os.W_OK)
self.__book_downloader = self.__image_downloader = None
class SmileyToolbar(Gtk.Toolbar):
def __init__(self, activity):
Gtk.Toolbar.__init__(self)
self._activity = activity
self._add_separator()
self._icon = Icon(icon_name='smilies-white')
self._add_widget(self._icon)
self._add_separator()
self._title = Gtk.Label(_('Insert a smiley'))
self._add_widget(self._title)
self._add_separator(True)
self.cancel_button = ToolButton('dialog-cancel')
self.cancel_button.set_tooltip(_('Cancel'))
self.cancel_button.connect('clicked', self.__cancel_button_clicked_cb)
self.insert(self.cancel_button, -1)
self.cancel_button.show()
def _add_separator(self, expand=False):
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
if expand:
separator.set_expand(True)
else:
separator.set_size_request(style.DEFAULT_SPACING, -1)
self.insert(separator, -1)
separator.show()
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 __cancel_button_clicked_cb(self, widget, data=None):
self._activity._hide_smiley_window()
def __init__(self, button, toolbar, view_icon, favorite_icon, label):
Gtk.Toolbar.__init__(self)
self.toolbar = toolbar
self.button = button
self.view_icon = view_icon
self.favorite_icon = favorite_icon
self.set_view_icon = ToolButton(view_icon)
self.set_view_icon.set_tooltip(_('Set toolbar icon'))
self.set_view_icon.connect('clicked', self.set_icon, False)
self.set_favorite_icon = ToolButton(favorite_icon)
self.set_favorite_icon.set_tooltip(_('Set the icon of favorites list'))
self.set_favorite_icon.connect('clicked', self.set_icon, True)
entry_toolitem = Gtk.ToolItem()
self.favorite_name_entry = Gtk.Entry()
self.favorite_name_entry.set_placeholder_text(_('Favorite view name'))
width = Gdk.Screen.width() - (style.STANDARD_ICON_SIZE * 12)
entry_toolitem.set_size_request(width, 55)
self.favorite_name_entry.set_text(label)
self.favorite_name_entry.connect("activate", self.edited_view_name)
entry_toolitem.add(self.favorite_name_entry)
label = Gtk.Label(_('Name of favorite view') + '\t')
label.modify_fg(Gtk.StateType.NORMAL, Gdk.color_parse('white'))
tool_label = Gtk.ToolItem()
tool_label.add(label)
self.remove_btn = ToolButton('list-remove')
self.remove_btn.set_tooltip(_('Remove favorite view'))
self.remove_btn.connect('clicked', self.remove_view)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(self.set_view_icon, -1)
self.insert(self.set_favorite_icon, -1)
self.insert(tool_label, -1)
self.insert(entry_toolitem, -1)
self.insert(separator, -1)
self.insert(self.remove_btn, -1)
self.show_all()
def __make_toolbar(self):
self.toolbar = Gtk.Toolbar()
self.toolbar.modify_bg(Gtk.StateType.NORMAL,
style.COLOR_TOOLBAR_GREY.get_gdk_color())
self.go_up_button = ToolButton(icon_name='go-up')
self.go_up_button.props.accelerator = '<Alt>S'
self.go_up_button.set_tooltip(_('Go to pather directory'))
self.go_up_button.connect('clicked', self.go_up)
self.toolbar.insert(self.go_up_button, -1)
self.toolbar.insert(Gtk.SeparatorToolItem(), -1)
self.hidden_files_button = ToggleToolButton('show-hidden-files')
self.hidden_files_button.props.accelerator = '<Ctrl>H'
self.hidden_files_button.set_tooltip(_('Show hidden files'))
self.hidden_files_button.connect('clicked', self.__show_hidden_files)
self.toolbar.insert(self.hidden_files_button, -1)
self.toolbar.insert(Gtk.SeparatorToolItem(), -1)
item = Gtk.ToolItem()
self.entry = Gtk.Entry()
self.entry.set_size_request(300, -1)
self.entry.set_text(self.folder)
self.entry.connect('activate', self.__open_path_from_entry)
item.add(self.entry)
self.toolbar.insert(item, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.toolbar.insert(separator, -1)
self.button_open = ToolButton(icon_name='fileopen')
self.button_open.set_tooltip(_('Open selected file'))
self.button_open.set_sensitive(False)
self.button_open.connect('clicked', self.__open_path)
self.toolbar.insert(self.button_open, -1)
self.close_button = ToolButton(icon_name='dialog-cancel')
self.close_button.connect('clicked', self.close)
self.toolbar.insert(self.close_button, -1)
self.vbox.pack_start(self.toolbar, False, False, 0)
def __init__(self, icon_name, title):
super(_DialogToolbar, self).__init__()
icon = Icon()
icon.set_from_icon_name(icon_name, Gtk.IconSize.LARGE_TOOLBAR)
self._add_widget(icon)
self._add_separator()
label = Gtk.Label(label=title)
self._add_widget(label)
self._add_separator(expand=True)
stop = ToolButton(icon_name='dialog-cancel')
stop.set_tooltip(_('Done'))
stop.connect('clicked', self._stop_clicked_cb)
self.add(stop)
def __init__(self, data, toplevel, jobject):
PopWindow.__init__(self, transient_for=toplevel)
self.props.size = PopWindow.FULLSCREEN
w, h = PopWindow.FULLSCREEN
self._toplevel = toplevel
self._jobject = jobject
self._links = data.get('shared_links', [])
if not self._links:
self._show_howto_copy()
return
self._total_links = len(self._links)
self._entry = None
self._paned = Gtk.Paned()
self.add_view(self._paned)
self._paned.show()
self._webview = WebKit2.WebView()
self._paned.add1(self._webview)
self._webview.set_size_request(w / 2, h)
self._webview.show()
self._2box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self._paned.add2(self._2box)
self._2box.show()
self._combo = Gtk.ComboBoxText()
for t in WEB_TYPES:
self._combo.append(t.type, t.name)
self._combo.set_active(0)
self._combo.connect('changed', self.__combo_changed_cb)
self._2box.add(self._combo)
self._combo.show()
self.next_link()
add = ToolButton(icon_name='dialog-ok')
add.props.tooltip = \
_('Add This Bibliography Item and Continue to Next Bookmark')
add.connect('clicked', self.__add_clicked_cb)
self.props.title_box.insert(add, -2)
add.show()
def __init__(self, handle):
"""Set up the activity."""
activity.Activity.__init__(self, handle)
self.max_participants = 1
self._connection = None
self._nick_lists = {}
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
clear_all = ToolButton("clear")
toolbar_box.toolbar.insert(clear_all, -1)
# clear_all.show()
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.set_toolbar_box(toolbar_box)
toolbar_box.show()
# Start Screen, etc. starts here
self.start_screen = StartScreen()
self.start_screen.connect("connect-clicked", self._start)
self.set_canvas(self.start_screen)
class ViewToolbar(Gtk.Toolbar):
__gtype_name__ = 'ViewToolbar'
__gsignals__ = {
'needs-update-size':
(GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ([])),
'go-fullscreen': (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ([]))
}
def __init__(self):
Gtk.Toolbar.__init__(self)
self.fullscreen = ToolButton('view-fullscreen')
self.fullscreen.set_tooltip(_('Fullscreen'))
self.fullscreen.connect('clicked', self.fullscreen_cb)
self.insert(self.fullscreen, -1)
self.fullscreen.show()
def fullscreen_cb(self, button):
self.emit('go-fullscreen')
def __init__(self, activity):
super(type(self), self).__init__()
self.activity = activity
self.new_instruments = []
self._name_entry = Gtk.Entry()
self._name_entry.set_text(_('my instrument'))
self._name_entry_changed_id = self._name_entry.connect(
'changed', self.update_name_entry)
if hasattr(self._name_entry, 'set_tooltip_text'):
self._name_entry.set_tooltip_text(
_('Enter instrument name.'))
self._name_entry.set_width_chars(24)
self._name_entry.show()
toolitem = Gtk.ToolItem()
toolitem.add(self._name_entry)
self.insert(toolitem, -1)
toolitem.show()
self._note = 'A'
self._notes_button = ToolButton('notes')
self._notes_button.set_tooltip(_('Notes'))
self._notes_button.connect('clicked',
self._button_selection_cb)
self.insert(self._notes_button, -1)
self._setup_notes_palette()
self._notes_button.show()
self._octave = 4
self._octaves_button = ToolButton('octaves')
self._octaves_button.set_tooltip(_('Octaves'))
self._octaves_button.connect('clicked',
self._button_selection_cb)
self.insert(self._octaves_button, -1)
self._setup_octaves_palette()
self._octaves_button.show()
self._new_note = ToolButton('list-add')
self._new_note.show()
self.insert(self._new_note, -1)
self._new_note.set_tooltip(_('Add a new note.'))
self._new_note.connect('clicked', self.new_note_cb)
self._new_note.show()
def __make_toolbar(self):
self.toolbar = Gtk.Toolbar()
self.toolbar.modify_bg(
Gtk.StateType.NORMAL, style.COLOR_TOOLBAR_GREY.get_gdk_color())
self.toolbar.insert(self.go_up_button, -1)
self.toolbar.insert(Gtk.SeparatorToolItem(), -1)
self.button_new_folder = ToolButton(icon_name="new-folder")
self.button_new_folder.set_tooltip(_("Create a folder"))
self.button_new_folder.connect("clicked", self.create_folder)
self.toolbar.insert(self.button_new_folder, -1)
item = Gtk.ToolItem()
item.add(self.entry)
self.toolbar.insert(item, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.toolbar.insert(separator, -1)
item = Gtk.ToolItem()
self.entry_name = Gtk.Entry()
self.entry_name.set_size_request(200, -1)
self.entry_name.set_placeholder_text("Select a name for this file.")
self.entry_name.connect("activate", self.__name_selected)
item.add(self.entry_name)
self.toolbar.insert(item, -1)
self.entries.append(self.entry_name)
self.button_save = ToolButton(icon_name="save-as")
self.button_save.connect("clicked", self.__save_path_from_button)
self.toolbar.insert(self.button_save, -1)
self.close_button = ToolButton(icon_name="dialog-cancel")
self.close_button.connect("clicked", self.close)
self.toolbar.insert(self.close_button, -1)
self.vbox.pack_start(self.toolbar, False, False, 0)
def __init__(self, **kwargs):
GObject.GObject.__init__(self)
help_button = ToolButton('toolbar-help')
help_button.set_tooltip(_('Help'))
self.add(help_button)
self._palette = help_button.get_palette()
sw = Gtk.ScrolledWindow()
sw.set_size_request(int(Gdk.Screen.width() / 2.8),
Gdk.Screen.height() - style.GRID_CELL_SIZE * 3)
sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
self._vbox = Gtk.Box()
self._vbox.set_orientation(Gtk.Orientation.VERTICAL)
self._vbox.set_homogeneous(False)
sw.add_with_viewport(self._vbox)
self._palette.set_content(sw)
sw.show_all()
help_button.connect('clicked', self.__help_button_clicked_cb)
def make_toolbar(self):
toolbarbox = ToolbarBox()
self.set_toolbar_box(toolbarbox)
button = ActivityToolbarButton(self)
toolbarbox.toolbar.insert(button, -1)
toolbarbox.toolbar.insert(Gtk.SeparatorToolItem(), -1)
button_new = ToolButton("new-button")
button_new.set_tooltip(_("New"))
button_new.connect("clicked", self._next_level)
toolbarbox.toolbar.insert(button_new, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbarbox.toolbar.insert(separator, -1)
button = StopButton(self)
toolbarbox.toolbar.insert(button, -1)
def __init__(self, toolbar):
self._timer_value = TIMER_VALUES[0]
self._timer_button = ToolButton('timer-0')
self._timer_button.set_tooltip(_('Select timer'))
self._timer_button.connect('clicked', self._timer_selection_cb)
toolbar.insert(self._timer_button, -1)
self._setup_timer_palette()
self._duration_value = DURATION_VALUES[0]
self._duration_button = ToolButton('duration-2')
self._duration_button.set_tooltip(_('Select duration'))
self._duration_button.connect('clicked', self._duration_selection_cb)
toolbar.insert(self._duration_button, -1)
self._setup_duration_palette()
self._quality_value = 0
self._quality_button = ToolButton('low-quality')
self._quality_button.set_tooltip(_('Select quality'))
self._quality_button.connect('clicked', self._quality_selection_cb)
toolbar.insert(self._quality_button, -1)
self._setup_quality_palette()
def _create_montage_toolbar(self):
toolbar = Gtk.Toolbar()
playButtonImg = Gtk.Image()
playButtonImg.show()
playButtonImg.set_from_icon_name('media-playback-start',
Gtk.IconSize.LARGE_TOOLBAR)
pauseButtonImg = Gtk.Image()
pauseButtonImg.show()
pauseButtonImg.set_from_icon_name('media-playback-pause',
Gtk.IconSize.LARGE_TOOLBAR)
self.playButton = ToggleToolButton('media-playback-start')
self.playButton.connect('toggled', self.__play_cb, playButtonImg,
pauseButtonImg)
toolbar.insert(self.playButton, -1)
self.playButton.set_tooltip(_('Play / Pause'))
tempo = TempoSlider(0, 10)
tempo.adjustment.connect("value-changed", self.__tempo_cb)
tempo.set_size_request(250, -1)
tempo.set_value(5)
tempo_item = Gtk.ToolItem()
tempo_item.add(tempo)
toolbar.insert(tempo_item, -1)
separator = Gtk.SeparatorToolItem()
toolbar.insert(separator, -1)
clear_tape = ToolButton('sl-reset')
clear_tape.connect('clicked', self.__clear_tape_cb)
clear_tape.set_tooltip(_('Reset'))
toolbar.insert(clear_tape, -1)
toolbar.show_all()
return toolbar
def build_toolbar(self):
toolbar_box = ToolbarBox()
play_button = ToolButton('media-playback-start')
play_button.props.accelerator = 'P'
toolbar_box.toolbar.insert(play_button, -1)
play_button.show()
play_button.connect('clicked', self._play_cb)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl><Shift>Q'
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
stop_button.connect('clicked', self._stop_cb)
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
