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 in')
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 out')
self.insert(self.font_minus, -1)
self.font_minus.show()
self.show()
def _create_view_toolbar(self): # Color changer and Zoom toolbar
view_toolbar = Gtk.Toolbar()
self._theme_toggler = ToolButton('dark-theme')
self._theme_toggler.set_tooltip('Switch to Dark Theme')
self._theme_toggler.props.accelerator = '<Ctrl><Shift>I'
self._theme_toggler.connect('clicked', self._toggled_theme)
view_toolbar.insert(self._theme_toggler, -1)
self._theme_toggler.show()
sep = Gtk.SeparatorToolItem()
view_toolbar.insert(sep, -1)
sep.show()
zoom_out_button = ToolButton('zoom-out')
zoom_out_button.set_tooltip(_('Zoom out'))
zoom_out_button.props.accelerator = '<Ctrl>minus'
zoom_out_button.connect('clicked', self.__zoom_out_cb)
view_toolbar.insert(zoom_out_button, -1)
zoom_out_button.show()
zoom_in_button = ToolButton('zoom-in')
zoom_in_button.set_tooltip(_('Zoom in'))
zoom_in_button.props.accelerator = '<Ctrl>plus'
zoom_in_button.connect('clicked', self.__zoom_in_cb)
view_toolbar.insert(zoom_in_button, -1)
zoom_in_button.show()
fullscreen_button = ToolButton('view-fullscreen')
fullscreen_button.set_tooltip(_("Fullscreen"))
fullscreen_button.props.accelerator = '<Alt>Return'
fullscreen_button.connect('clicked', self.__fullscreen_cb)
view_toolbar.insert(fullscreen_button, -1)
fullscreen_button.show()
return view_toolbar
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, parent, web_view):
GObject.GObject.__init__(self)
self._help = parent
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()
home = ToolButton('zoom-home')
home.set_tooltip(_('Home'))
home.connect('clicked', self._go_home_cb)
self.insert(home, -1)
home.show()
separator = Gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
def __init__(self, main_area):
Gtk.Toolbar.__init__(self)
self._main_area = main_area
tool = ToolButton('zoom-best-fit')
tool.set_tooltip(_('Fit to window'))
tool.set_accelerator(_('<ctrl>9'))
tool.connect('clicked', self.__zoom_tofit_cb)
self.insert(tool, -1)
tool = ToolButton('zoom-original')
tool.set_tooltip(_('Original size'))
tool.set_accelerator(_('<ctrl>0'))
tool.connect('clicked', self.__zoom_original_cb)
self.insert(tool, -1)
tool = ToolButton('zoom-out')
tool.set_tooltip(_('Zoom out'))
tool.set_accelerator(_('<ctrl>minus'))
tool.connect('clicked', self.__zoom_out_cb)
self.insert(tool, -1)
tool = ToolButton('zoom-in')
tool.set_tooltip(_('Zoom in'))
tool.set_accelerator(_('<ctrl>equal'))
tool.connect('clicked', self.__zoom_in_cb)
self.insert(tool, -1)
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.back_button = ToolButton("go-previous-paired")
self.back_button.set_sensitive(False)
self.back_button.connect("clicked", self._go_back)
toolbarbox.toolbar.insert(self.back_button, -1)
self.forward_button = ToolButton("go-next-paired")
self.forward_button.set_sensitive(False)
self.forward_button.connect("clicked", self._go_forward)
toolbarbox.toolbar.insert(self.forward_button, -1)
toolbarbox.toolbar.insert(Gtk.SeparatorToolItem(), -1)
self.redact_button = ToolButton("document-send")
self.redact_button.set_tooltip(_("Redact"))
self.redact_button.set_sensitive(False)
self.redact_button.connect("clicked", self._redact)
toolbarbox.toolbar.insert(self.redact_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 __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.HScale.new(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):
GObject.GObject.__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()
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(800, self.LOWER, self.UPPER, 50,
200, 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 make_toolbar(self):
def make_separator(expand=True):
separator = Gtk.SeparatorToolItem()
separator.props.draw = not expand
separator.set_expand(expand)
return separator
toolbarbox = ToolbarBox()
self.set_toolbar_box(toolbarbox)
toolbar = toolbarbox.toolbar
toolbar.insert(ActivityToolbarButton(self), -1)
toolbar.insert(make_separator(False), -1)
self.restart_button = ToolButton(icon_name="system-restart")
self.restart_button.set_tooltip(_("Restart"))
self.restart_button.props.accelerator = '<Ctrl>N'
self.restart_button.connect("clicked", self._restart_cb)
toolbar.insert(self.restart_button, -1)
self.ok_button = ToolButton(icon_name="dialog-ok")
self.ok_button.set_tooltip(_("Ok"))
self.ok_button.set_sensitive(False)
self.ok_button.props.accelerator = "Return"
self.ok_button.connect("clicked", self._ok_cb)
toolbar.insert(self.ok_button, -1)
item = Gtk.ToolItem()
toolbar.insert(item, -1)
self.label = Gtk.Label()
self.label.modify_font(Pango.FontDescription("Bold"))
item.add(self.label)
toolbar.insert(make_separator(True), -1)
helpbutton = HelpButton()
helpbutton.add_section(_("Instructions:"))
helpbutton.add_paragraph(_("Place colors to the last played row."),
image="instructions1.png")
helpbutton.add_paragraph(
_("When you complete a row, click on 'Ok button'."),
image="instructions2.png")
helpbutton.add_paragraph(
_("Next to the row will appear black and white circles."),
image="instructions3.png")
helpbutton.add_paragraph(
_("A black circle means you matched a peg and you placed it correctly."
))
helpbutton.add_paragraph(
_("A white circle means you matched a peg and you wrong placed it."
))
helpbutton.add_paragraph(
_("The goal is match all pegs in the correct place."))
toolbar.insert(helpbutton, -1)
stop_button = StopButton(self)
toolbar.insert(stop_button, -1)
toolbar.show_all()
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 make_toolbar(self):
def make_separator(expand=False):
separator = Gtk.SeparatorToolItem()
if expand:
separator.set_expand(True)
separator.props.draw = False
return separator
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar = toolbar_box.toolbar
activity_button = ActivityToolbarButton(self)
toolbar.insert(activity_button, -1)
toolbar.insert(make_separator(), -1)
button_add = ToolButton(Gtk.STOCK_ADD)
button_add.set_tooltip(_("Add a channel"))
button_add.connect("clicked", self._add_channel)
toolbar.insert(button_add, -1)
toolbar.insert(make_separator(True), -1)
stop_button = ToolButton("activity-stop")
stop_button.connect("clicked", self._exit)
stop_button.props.accelerator = "<Ctrl>Q"
toolbar.insert(stop_button, -1)
def __init__(self):
Gtk.Toolbar.__init__(self)
self.button = ToolbarButton(page=self, icon_name="info")
self.button_simulation = RadioToolButton(
icon_name="solar-system", group=None)
self.button_simulation.set_tooltip(_("Show solar system"))
self.button_simulation.connect("toggled", self._show_simulation_cb)
self.insert(self.button_simulation, -1)
self.button_info = RadioToolButton(
icon_name="info", group=self.button_simulation)
self.button_info.set_tooltip(_("Show information"))
self.button_info.connect("toggled", self._show_info_cb)
self.insert(self.button_info, -1)
self.insert(make_separator(False), -1)
self.back_button = ToolButton("go-previous-paired")
self.back_button.set_tooltip(_("Go back"))
self.back_button.set_sensitive(False)
self.back_button.connect("clicked", self._go_back_cb)
self.insert(self.back_button, -1)
self.forward_button = ToolButton("go-next-paired")
self.forward_button.set_tooltip(_("Go forward"))
self.forward_button.set_sensitive(False)
self.forward_button.connect("clicked", self._go_forward_cb)
self.insert(self.forward_button, -1)
self.show_all()
def __init__(self, activity):
Gtk.Toolbar.__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, parent):
GObject.GObject.__init__(self)
self.parent = parent
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)
def add_frequency_slider(self, toolbox):
''' Either on the Sound toolbar or the Main toolbar '''
self._freq_stepper_up = ToolButton('freq-high')
self._freq_stepper_up.set_tooltip(_('Zoom out'))
self._freq_stepper_up.connect('clicked', self._freq_stepper_up_cb)
self._freq_stepper_up.show()
self.activity.adjustmentf = Gtk.Adjustment(0.5, self.LOWER, self.UPPER,
0.01, 0.1, 0)
self.activity.adjustmentf.connect('value_changed', self.cb_page_sizef)
self._freq_range = Gtk.Scale(orientation=Gtk.Orientation.HORIZONTAL,
adjustment=self.activity.adjustmentf)
self._freq_range.set_inverted(True)
self._freq_range.set_draw_value(False)
self._freq_range.set_size_request(120, 15)
self._freq_range.show()
self._freq_stepper_down = ToolButton('freq-low')
self._freq_stepper_down.set_tooltip(_('Zoom in'))
self._freq_stepper_down.connect('clicked', self._freq_stepper_down_cb)
self._freq_stepper_down.show()
self._freq_range_tool = Gtk.ToolItem()
self._freq_range_tool.add(self._freq_range)
self._freq_range_tool.show()
toolbox.add(self._freq_stepper_up)
toolbox.add(self._freq_range_tool)
toolbox.add(self._freq_stepper_down)
return
def __init__(self, activity_name, has_local_help):
Gtk.Toolbar.__init__(self)
self._add_separator(False)
if has_local_help and get_social_help_server():
help_button = RadioToolButton()
icon = Icon(icon_name='toolbar-help',
pixel_size=style.STANDARD_ICON_SIZE,
fill_color=style.COLOR_TRANSPARENT.get_svg(),
stroke_color=style.COLOR_WHITE.get_svg())
help_button.set_icon_widget(icon)
icon.show()
help_button.props.tooltip = _('Help Manual')
help_button.connect('toggled', self.__button_toggled_cb,
_MODE_HELP)
self.insert(help_button, -1)
help_button.show()
self._add_separator(False)
social_help_button = RadioToolButton()
icon = Icon(icon_name='toolbar-social-help',
pixel_size=style.STANDARD_ICON_SIZE,
fill_color=style.COLOR_TRANSPARENT.get_svg(),
stroke_color=style.COLOR_WHITE.get_svg())
social_help_button.set_icon_widget(icon)
icon.show()
social_help_button.props.tooltip = _('Social Help')
social_help_button.props.group = help_button
social_help_button.connect('toggled', self.__button_toggled_cb,
_MODE_SOCIAL_HELP)
self.insert(social_help_button, -1)
social_help_button.show()
self._add_separator(False)
self._back_button = ToolButton(icon_name='go-previous-paired')
self._back_button.props.tooltip = _('Back')
self._back_button.connect('clicked', self.__back_clicked_cb)
self.insert(self._back_button, -1)
self._back_button.show()
self._forward_button = ToolButton(icon_name='go-next-paired')
self._forward_button.props.tooltip = _('Forward')
self._forward_button.connect('clicked', self.__forward_clicked_cb)
self.insert(self._forward_button, -1)
self._forward_button.show()
title = _('Help: %s') % activity_name
self._label = Gtk.Label()
self._label.set_markup('<b>%s</b>' % title)
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)
self.props.max_participants = 1
self._web_view = WebKit.WebView()
toolbox = ToolbarBox()
self.set_toolbar_box(toolbox)
toolbox.show()
toolbar = toolbox.toolbar
toolbar.show()
activity_button = ActivityButton(self)
toolbar.insert(activity_button, -1)
viewtoolbar = ViewToolbar(self)
viewtoolbar_button = ToolbarButton(
page=viewtoolbar, icon_name='toolbar-view')
toolbar.insert(viewtoolbar_button, -1)
toolbar.show_all()
self._back = ToolButton('go-previous-paired')
self._back.set_tooltip(_('Back'))
self._back.props.sensitive = False
self._back.connect('clicked', self._go_back_cb)
toolbar.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)
toolbar.insert(self._forward, -1)
self._forward.show()
home = ToolButton('go-home')
home.set_tooltip(_('Home'))
home.connect('clicked', self._go_home_cb)
toolbar.insert(home, -1)
home.show()
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._web_view.connect('load-finished', self.update_navigation_buttons)
self.set_canvas(self._web_view)
self._web_view.show()
self._web_view.load_uri(HOME)
def __init__(self, game, editor_index):
Gtk.EventBox.__init__(self)
self._game = game
self.snd = None
self.editor_index = editor_index
self.temp_folder = None
box = Gtk.Grid()
box.set_column_spacing(style.DEFAULT_SPACING)
box.set_row_spacing(style.DEFAULT_SPACING)
box.props.margin = style.DEFAULT_SPACING
self.card = svgcard.SvgCard(-1, {
'front_text': {
'card_text': '',
'text_color': style.Color('#ffffff')
}
}, None, PAIR_SIZE, '#c0c0c0')
self.card.flip()
card_align = Gtk.Alignment.new(.5, .5, 0, 0)
card_align.add(self.card)
box.attach(card_align, 0, 0, 1, 1)
self.textentry = Gtk.Entry()
self.textentry.connect('changed', self.update_text)
self.textentry.set_valign(Gtk.Align.START)
box.attach(self.textentry, 0, 1, 1, 1)
toolbar = Gtk.VBox()
toolbar.set_valign(Gtk.Align.CENTER)
browsepicture = ToolButton(icon_name='import_picture',
tooltip=_('Insert picture'))
toolbar.add(browsepicture)
browsesound = ToolButton(icon_name='import_sound',
tooltip=_('Insert sound'))
toolbar.add(browsesound)
browsepicture.connect('clicked', self._load_image)
browsesound.connect('clicked', self._load_audio)
if speak.espeak.supported:
self.usespeak = ToggleToolButton(icon_name='speak')
self.usespeak.set_palette(SpeakPalette(self))
toolbar.add(self.usespeak)
self.usespeak.connect('toggled', self._usespeak_cb)
else:
self.usespeak = None
self.fontbutton = FontButton()
toolbar.add(self.fontbutton)
self.id_font_changed = self.fontbutton.connect('changed',
self.__font_changed_cb)
box.attach(toolbar, 1, 0, 1, 2)
self.add(box)
def __init__(self, activity):
SugarToolbarBox.__init__(self)
activity_button = ActivityToolbarButton(activity)
self.toolbar.insert(activity_button, -1)
self.toolbar.insert(make_separator(False), -1)
self.toolbar_info = ToolbarInfo()
self.toolbar_info.connect("show-simulation", self._show_simulation_cb)
self.toolbar_info.connect("show-info", self._show_info_cb)
self.toolbar_info.connect("go-back", self._go_back_cb)
self.toolbar_info.connect("go-forward", self._go_forward_cb)
self.toolbar.insert(self.toolbar_info.button, -1)
self.toolbar_view = ToolbarView()
self.toolbar_view.connect("show-orbits", self._show_orbits_cb)
self.toolbar_view.connect("show-body", self._show_body_cb)
self.toolbar.insert(self.toolbar_view.button, -1)
self.toolbar_speed = ToolbarSpeed()
self.toolbar_speed.connect("speed-changed", self._speed_changed_cb)
self.toolbar.insert(self.toolbar_speed.button, -1)
self.toolbar.insert(make_separator(False), -1)
adj = Gtk.Adjustment(16.5, 0.8, 75, 0.5, 1)
self.zoom_scale = Gtk.HScale()
self.zoom_scale.set_draw_value(False)
self.zoom_scale.set_adjustment(adj)
self.zoom_scale.set_size_request(200, 1)
self.zoom_scale.connect("value-changed", self._zoom_changed_cb)
self.zoom_out = ToolButton("zoom-out")
self.zoom_out.set_tooltip(_("Zoom out"))
self.zoom_out.connect("clicked", self._zoom_out_cb)
self.toolbar.insert(self.zoom_out, -1)
item = Gtk.ToolItem()
item.add(self.zoom_scale)
self.toolbar.insert(item, -1)
self.zoom_in = ToolButton("zoom-in")
self.zoom_in.set_tooltip(_("Zoom in"))
self.zoom_in.connect("clicked", self._zoom_in_cb)
self.toolbar.insert(self.zoom_in, -1)
self.toolbar.insert(make_separator(True), -1)
help_button = HelpButton()
self.toolbar.insert(help_button, -1)
stop_button = StopButton(activity)
self.toolbar.insert(stop_button, -1)
self.make_help(help_button)
def Boton(tooltip=None, icon=None, connect=None):
if icon != None:
Boton = ToolButton(icon)
else:
Boton = ToolButton('gtk-missing-image')
if tooltip != None:
Boton.set_tooltip(tooltip)
if connect != None:
Boton.connect("clicked", connect)
return Boton
def __init__(self, act):
BaseEditToolbar.__init__(self)
self._activity = act
self._browser = None
self._source_id = None
self.undo.connect('clicked', self.__undo_cb)
self.redo.connect('clicked', self.__redo_cb)
self.copy.connect('clicked', self.__copy_cb)
self.paste.connect('clicked', self.__paste_cb)
separator = Gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
search_item = Gtk.ToolItem()
self.search_entry = iconentry.IconEntry()
self.search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'entry-search')
self.search_entry.add_clear_button()
self.search_entry.connect('activate', self.__search_entry_activate_cb)
self.search_entry.connect('changed', self.__search_entry_changed_cb)
width = int(Gdk.Screen.width() / 3)
self.search_entry.set_size_request(width, -1)
search_item.add(self.search_entry)
self.search_entry.show()
self.insert(search_item, -1)
search_item.show()
self._prev = ToolButton('go-previous-paired')
self._prev.set_tooltip(_('Previous'))
self._prev.props.sensitive = False
self._prev.connect('clicked', self.__find_previous_cb)
self.insert(self._prev, -1)
self._prev.show()
self._next = ToolButton('go-next-paired')
self._next.set_tooltip(_('Next'))
self._next.props.sensitive = False
self._next.connect('clicked', self.__find_next_cb)
self.insert(self._next, -1)
self._next.show()
tabbed_view = self._activity.get_canvas()
GObject.idle_add(lambda: self._connect_to_browser(tabbed_view.props.
current_browser))
tabbed_view.connect_after('switch-page', self.__switch_page_cb)
def make_toolbar(self):
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
toolbarview = Gtk.Toolbar()
langtoolbar_button = ToolbarButton(label=_('View'),
page=toolbarview,
icon_name='settings')
langtoolbar_button.show()
toolbar_box.toolbar.insert(langtoolbar_button, -1)
tool = ToolButton('en')
tool.set_tooltip(_('English'))
tool.connect('clicked', self.language_en)
tool.show()
toolbarview.insert(tool, -1)
tool = ToolButton('es')
tool.set_tooltip(_('Spanish'))
tool.connect('clicked', self.language_es)
tool.show()
toolbarview.insert(tool, -1)
tool = ToolButton('fr')
tool.set_tooltip(_('French'))
tool.connect('clicked', self.language_fr)
tool.show()
toolbarview.insert(tool, -1)
tool = ToolButton('remote')
tool.set_tooltip(_('Server settings'))
tool.connect('clicked', self.settings)
tool.show()
toolbarview.insert(tool, -1)
toolbarview.show()
favorite_button = ToolButton(self.favorite_status)
favorite_button.set_tooltip('Filter on favorite')
favorite_button.connect('clicked', self.favorite)
toolbar_box.toolbar.insert(favorite_button, -1)
favorite_button.show()
self.favorite_button = favorite_button
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()
def __init__(self):
GObject.GObject.__init__(self)
self.back = ToolButton('go-previous')
self.back.set_tooltip(_('Back'))
self.back.props.sensitive = False
palette = self.back.get_palette()
self.prev_page = MenuItem(text_label=_("Previous page"))
palette.menu.append(self.prev_page)
self.prev_page.show_all()
self.back.connect('clicked', self.go_back_cb)
self.prev_page.connect('activate', self.go_back_cb)
self.insert(self.back, -1)
self.back.show()
self.forward = ToolButton('go-next')
self.forward.set_tooltip(_('Forward'))
self.forward.props.sensitive = False
palette = self.forward.get_palette()
self.next_page = MenuItem(text_label=_("Next page"))
palette.menu.append(self.next_page)
self.next_page.show_all()
self.forward.connect('clicked', self.go_forward_cb)
self.next_page.connect('activate', self.go_forward_cb)
self.insert(self.forward, -1)
self.forward.show()
num_page_item = Gtk.ToolItem()
self._num_page_entry = Gtk.Entry()
self._num_page_entry.set_text('0')
self._num_page_entry.set_alignment(1)
self._num_page_entry.connect('insert-text',
self._num_page_entry_insert_text_cb)
self._num_page_entry.connect('activate',
self._num_page_entry_activate_cb)
self._num_page_entry.set_width_chars(4)
num_page_item.add(self._num_page_entry)
self._num_page_entry.show()
self.insert(num_page_item, -1)
num_page_item.show()
total_page_item = Gtk.ToolItem()
self._total_page_label = Gtk.Label()
self._total_page_label.set_text(' / 0')
total_page_item.add(self._total_page_label)
self._total_page_label.show()
self.insert(total_page_item, -1)
total_page_item.show()
def build_toolbar(self):
"""Build our Activity toolbar for the Sugar system."""
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
separator = Gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
easier_button = ToolButton('create-easier')
easier_button.set_tooltip(_('Easier level'))
easier_button.connect('clicked', self._easier_button_cb)
toolbar_box.toolbar.insert(easier_button, -1)
harder_button = ToolButton('create-harder')
harder_button.set_tooltip(_('Harder level'))
harder_button.connect('clicked', self._harder_button_cb)
toolbar_box.toolbar.insert(harder_button, -1)
self._risk_button = ToggleToolButton('make-risk')
self._risk_button.set_tooltip(_('Make risk'))
if self.state and 'risk' in self.state:
self._risk_button.set_active(self.state['risk'])
self._risk_button.connect('toggled', self._make_risk_button_cb)
toolbar_box.toolbar.insert(self._risk_button, -1)
separator = Gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
separator.show()
self.show_trail_button = ToggleToolButton('show-trail')
self.show_trail_button.set_tooltip(_('Show trail'))
self.show_trail_button.set_active(True)
self.show_trail_button.connect('toggled', self._toggled_show_trail_cb)
toolbar_box.toolbar.insert(self.show_trail_button, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_size_request(0, -1)
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_all()
return toolbar_box
def __init__(self, parent_xid, dialog_title):
Gtk.Window.__init__(self)
self.connect('realize', self.__realize_cb)
self.set_decorated(False)
self.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
self.set_border_width(style.LINE_WIDTH)
self.set_resizable(False)
width = Gdk.Screen.width() - style.GRID_CELL_SIZE * 4
height = Gdk.Screen.height() - style.GRID_CELL_SIZE * 4
self.set_size_request(width, height)
self._parent_window_xid = parent_xid
_vbox = Gtk.VBox(spacing=2)
self.add(_vbox)
self.toolbar = Gtk.Toolbar()
label = Gtk.Label()
label.set_markup('<b><span foreground="#ffffff"> %s</span></b>' %
dialog_title)
label.set_alignment(0, 0.5)
tool_item = Gtk.ToolItem()
tool_item.add(label)
label.show()
self.toolbar.insert(tool_item, -1)
tool_item.show()
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.toolbar.insert(separator, -1)
separator.show()
stop = ToolButton(icon_name='dialog-cancel')
stop.set_tooltip(_('Cancel'))
stop.connect('clicked', self.cancel_clicked_cb)
self.toolbar.insert(stop, -1)
stop.show()
accept = ToolButton(icon_name='dialog-ok')
accept.set_tooltip(_('Ok'))
accept.connect('clicked', self.accept_clicked_cb)
accept.show()
self.toolbar.insert(accept, -1)
_vbox.pack_start(self.toolbar, False, True, 0)
self.toolbar.show()
self._event_box = Gtk.EventBox()
_vbox.pack_start(self._event_box, True, True, 0)
self._canvas = None
def build_toolbar(self):
self.max_participants = 1
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, -1)
activity_button.show()
pano_toolbar = toolbox.toolbar
new_button = ToolButton('stock_refresh')
new_button.set_tooltip(_('New Panorama'))
new_button.connect('clicked', self.new_event)
pano_toolbar.insert(new_button, -1)
new_button.show()
capture_button = ToolButton('add_capture')
capture_button.set_tooltip(_('Add a capture to the Panorama'))
capture_button.connect('clicked', self.capture_event)
pano_toolbar.insert(capture_button, -1)
capture_button.show()
stitch_button = ToolButton('format-columns-triple')
stitch_button.set_tooltip(_('Stitch Panorama'))
stitch_button.connect('clicked', self.stitch_event)
pano_toolbar.insert(stitch_button, -1)
stitch_button.show()
stiching_auto = ToolButton('media-playback-start')
stiching_auto.set_tooltip(_('Enable auto-stitch'))
stiching_auto.connect('clicked', self.change_stich)
pano_toolbar.insert(stiching_auto, -1)
save_button = ToolButton('filesave')
save_button.set_tooltip(_('Save Panorama'))
save_button.connect('clicked', self.save_event)
pano_toolbar.insert(save_button, -1)
save_button.show()
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
pano_toolbar.insert(separator, -1)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
pano_toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbox)
toolbox.show_all()
def __init__(self, abiword_canvas):
Gtk.Toolbar.__init__(self)
self._abiword_canvas = abiword_canvas
self._table = abiword.TableCreator()
self._table.set_labels(_('Table'), _('Cancel'))
self._table_id = self._table.connect('selected', self._table_cb)
image = Gtk.Image()
image.set_from_icon_name('insert-table', -1)
self._table.set_image(image)
self._table.set_relief(Gtk.ReliefStyle.NONE)
tool_item = Gtk.ToolItem()
tool_item.add(self._table)
self.insert(tool_item, -1)
tool_item.show_all()
self._table_rows_after = ToolButton('row-insert')
self._table_rows_after.set_tooltip(_('Insert Row'))
self._table_rows_after_id = self._table_rows_after.connect( \
'clicked', self._table_rows_after_cb)
self.insert(self._table_rows_after, -1)
self._table_delete_rows = ToolButton('row-remove')
self._table_delete_rows.set_tooltip(_('Delete Row'))
self._table_delete_rows_id = self._table_delete_rows.connect( \
'clicked', self._table_delete_rows_cb)
self.insert(self._table_delete_rows, -1)
self._table_cols_after = ToolButton('column-insert')
self._table_cols_after.set_tooltip(_('Insert Column'))
self._table_cols_after_id = self._table_cols_after.connect( \
'clicked', self._table_cols_after_cb)
self.insert(self._table_cols_after, -1)
self._table_delete_cols = ToolButton('column-remove')
self._table_delete_cols.set_tooltip(_('Delete Column'))
self._table_delete_cols_id = self._table_delete_cols.connect( \
'clicked', self._table_delete_cols_cb)
self.insert(self._table_delete_cols, -1)
separator = Gtk.SeparatorToolItem()
self.insert(separator, -1)
image = ToolButton('insert-picture')
image.set_tooltip(_('Insert Image'))
self._image_id = image.connect('clicked', self._image_cb)
self.insert(image, -1)
self.show_all()
self._abiword_canvas.connect('table-state', self._isTable_cb)
