def __init__(self, file_name, document_path, title, bundle=False):
RadioToolButton.__init__(self)
self._document_path = document_path
self._title = title
self._jobject = None
self.props.tooltip = _('Instance Source')
client = GConf.Client.get_default()
self._color = client.get_string('/desktop/sugar/user/color')
icon = Icon(file=file_name,
icon_size=Gtk.IconSize.LARGE_TOOLBAR,
xo_color=XoColor(self._color))
self.set_icon_widget(icon)
icon.show()
if bundle:
menu_item = MenuItem(_('Duplicate'))
icon = Icon(icon_name='edit-duplicate',
icon_size=Gtk.IconSize.MENU,
xo_color=XoColor(self._color))
menu_item.connect('activate', self.__copy_to_home_cb)
else:
menu_item = MenuItem(_('Keep'))
icon = Icon(icon_name='document-save',
icon_size=Gtk.IconSize.MENU,
xo_color=XoColor(self._color))
menu_item.connect('activate', self.__keep_in_journal_cb)
menu_item.set_image(icon)
self.props.palette.menu.append(menu_item)
menu_item.show()
def __init__(self, file_name, document_path, title, bundle=False):
RadioToolButton.__init__(self)
self._document_path = document_path
self._title = title
self._jobject = None
self.props.tooltip = _("Instance Source")
settings = Gio.Settings("org.sugarlabs.user")
self._color = settings.get_string("color")
icon = Icon(file=file_name, icon_size=Gtk.IconSize.LARGE_TOOLBAR, xo_color=XoColor(self._color))
self.set_icon_widget(icon)
icon.show()
if bundle:
menu_item = MenuItem(_("Duplicate"))
icon = Icon(icon_name="edit-duplicate", icon_size=Gtk.IconSize.MENU, xo_color=XoColor(self._color))
menu_item.connect("activate", self.__copy_to_home_cb)
else:
menu_item = MenuItem(_("Keep"))
icon = Icon(icon_name="document-save", icon_size=Gtk.IconSize.MENU, xo_color=XoColor(self._color))
menu_item.connect("activate", self.__keep_in_journal_cb)
menu_item.set_image(icon)
self.props.palette.menu.append(menu_item)
menu_item.show()
def create_palette(self):
primary_text = glib.markup_escape_text(self._model.bundle.get_name())
secondary_text = glib.markup_escape_text(self._model.get_name())
palette_icon = Icon(file=self._model.bundle.get_icon(),
xo_color=self._model.get_color())
palette_icon.props.icon_size = Gtk.IconSize.LARGE_TOOLBAR
palette = Palette(None,
primary_text=primary_text,
secondary_text=secondary_text,
icon=palette_icon)
private = self._model.props.private
joined = get_owner_instance() in self._model.props.buddies
if joined:
item = MenuItem(_('Resume'), 'activity-start')
item.connect('activate', self.__palette_item_clicked_cb)
item.show()
palette.menu.append(item)
elif not private:
item = MenuItem(_('Join'), 'activity-start')
item.connect('activate', self.__palette_item_clicked_cb)
item.show()
palette.menu.append(item)
self.connect_to_palette_pop_events(palette)
return palette
def refresh_activity_list(self):
self.menu = Gtk.Menu()
def process_dir(activity_path):
for dir_name in sorted(os.listdir(activity_path)):
bundles_installed = []
if dir_name.endswith('.activity'):
bundle_dir = os.path.join(activity_path, dir_name)
bundle = ActivityBundle(bundle_dir)
bundles_installed.append(bundle)
item = MenuItem(file_name=bundle.get_icon(),
xo_color=xocolor.XoColor())
item.set_label(bundle.get_name())
item.set_reserve_indicator(True)
item.set_submenu(self.make_submenu(bundle))
self.menu.append(item)
process_dir('/usr/share/sugar/activities/')
process_dir(activities_path) # ~/Activities
separator = Gtk.SeparatorMenuItem()
self.menu.append(separator)
about = MenuItem()
about.set_label("About")
about.connect("activate", self.show_about_dialog)
self.menu.append(about)
quit = MenuItem()
quit.set_label("Quit")
quit.connect("activate", Gtk.main_quit)
self.menu.append(quit)
self.menu.show_all()
def __init__(self, _parent):
SugarEditToolbar.__init__(self)
self._parent = _parent
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)
menu_item = MenuItem(_('Cut'))
menu_item.connect('activate', self.__cut_cb)
menu_item.show()
self.copy.get_palette().menu.append(menu_item)
self.insert(Gtk.SeparatorToolItem(), -1)
self.erase_button = ToolButton('edit-delete')
self.erase_button.set_tooltip(_('Erase selected thought(s)'))
self.erase_button.connect('clicked', self.__delete_cb)
self.insert(self.erase_button, -1)
self.show_all()
self.clipboard = Gtk.Clipboard()
self.copy.set_sensitive(False)
self.paste.set_sensitive(False)
self.erase_button.set_sensitive(False)
def __init__(self, cb_object):
Palette.__init__(self, text_maxlen=100)
self._cb_object = cb_object
self.set_group_id('frame')
cb_service = clipboard.get_instance()
cb_service.connect('object-state-changed',
self._object_state_changed_cb)
self._remove_item = MenuItem(pgettext('Clipboard', 'Remove'),
'list-remove')
self._remove_item.connect('activate', self._remove_item_activate_cb)
self.menu.append(self._remove_item)
self._remove_item.show()
self._open_item = MenuItem(_('Open'), 'zoom-activity')
self._open_item.connect('activate', self._open_item_activate_cb)
self.menu.append(self._open_item)
self._open_item.show()
self._journal_item = MenuItem(_('Keep'))
color = profile.get_color()
icon = Icon(icon_name='document-save',
pixel_size=style.SMALL_ICON_SIZE,
xo_color=color)
self._journal_item.set_image(icon)
self._journal_item.connect('activate', self._journal_item_activate_cb)
self.menu.append(self._journal_item)
self._journal_item.show()
self._update()
def __init__(self, invite):
Palette.__init__(self, "")
self._invite = invite
menu_item = MenuItem(_("Join"), icon_name="dialog-ok")
menu_item.connect("activate", self.__join_activate_cb)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_("Decline"), icon_name="dialog-cancel")
menu_item.connect("activate", self.__decline_activate_cb)
self.menu.append(menu_item)
menu_item.show()
bundle_id = invite.get_bundle_id()
registry = bundleregistry.get_registry()
self._bundle = registry.get_bundle(bundle_id)
if self._bundle:
name = self._bundle.get_name()
else:
name = bundle_id
self.set_primary_text(GLib.markup_escape_text(name))
def __init__(self, file_name, document_path, title, bundle=False):
RadioToolButton.__init__(self)
self._document_path = document_path
self._title = title
self._jobject = None
self.props.tooltip = _('Instance Source')
settings = Gio.Settings('org.sugarlabs.user')
self._color = settings.get_string('color')
icon = Icon(file=file_name,
pixel_size=style.STANDARD_ICON_SIZE,
xo_color=XoColor(self._color))
self.set_icon_widget(icon)
icon.show()
if bundle:
menu_item = MenuItem(_('Duplicate'))
icon = Icon(icon_name='edit-duplicate',
pixel_size=style.SMALL_ICON_SIZE,
xo_color=XoColor(self._color))
menu_item.connect('activate', self.__copy_to_home_cb)
else:
menu_item = MenuItem(_('Keep'))
icon = Icon(icon_name='document-save',
pixel_size=style.SMALL_ICON_SIZE,
xo_color=XoColor(self._color))
menu_item.connect('activate', self.__keep_in_journal_cb)
menu_item.set_image(icon)
self.props.palette.menu.append(menu_item)
menu_item.show()
def __init__(self, cb_object):
Palette.__init__(self, text_maxlen=100)
self._cb_object = cb_object
self.set_group_id('frame')
cb_service = clipboard.get_instance()
cb_service.connect('object-state-changed',
self._object_state_changed_cb)
self._remove_item = MenuItem(pgettext('Clipboard', 'Remove'),
'list-remove')
self._remove_item.connect('activate', self._remove_item_activate_cb)
self.menu.append(self._remove_item)
self._remove_item.show()
self._open_item = MenuItem(_('Open'), 'zoom-activity')
self._open_item.connect('activate', self._open_item_activate_cb)
self.menu.append(self._open_item)
self._open_item.show()
self._journal_item = MenuItem(_('Keep'))
client = GConf.Client.get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
icon = Icon(icon_name='document-save', icon_size=Gtk.IconSize.MENU,
xo_color=color)
self._journal_item.set_image(icon)
self._journal_item.connect('activate', self._journal_item_activate_cb)
self.menu.append(self._journal_item)
self._journal_item.show()
self._update()
def __init__(self, account, get_uid_list, is_active):
MenuItem.__init__(self, ACCOUNT_NAME)
self._account = account
self.set_image(Icon(icon_name=ACCOUNT_ICON,
icon_size=Gtk.IconSize.MENU))
self.show()
self._get_uid_list = get_uid_list
self.connect('activate', self.__share_menu_cb)
def __init__(self, account, get_uid_list, is_active):
MenuItem.__init__(self, ACCOUNT_DESCRIPTION)
self._account = account
self.set_image(Icon(icon_name=ACCOUNT_ICON,
icon_size=Gtk.IconSize.MENU))
self.show()
self._get_uid_list = get_uid_list
self.connect('activate', self.upload_file)
def _setup_octaves_palette(self):
self._octaves_palette = self._octaves_button.get_palette()
for octave in range(9):
menu_item = MenuItem(icon_name='',
text_label=str(octave))
menu_item.connect('activate', self._octave_selected_cb, octave)
self._octaves_palette.menu.append(menu_item)
menu_item.show()
def _add_erase_option(self, registry, activity_info):
menu_item = MenuItem(_('Erase'), 'list-remove')
menu_item.connect('activate', self.__erase_activate_cb)
self.menu.append(menu_item)
menu_item.show()
if not os.access(activity_info.get_path(), os.W_OK) or \
registry.is_activity_protected(self._bundle_id):
menu_item.props.sensitive = False
def _setup_notes_palette(self):
self._notes_palette = self._notes_button.get_palette()
for note in NOTES:
menu_item = MenuItem(icon_name='',
text_label=note)
menu_item.connect('activate', self._note_selected_cb, note)
self._notes_palette.menu.append(menu_item)
menu_item.show()
def _setup_robot_palette(self):
self._robot_palette = self._robot_time_button.get_palette()
for seconds in ROBOT_TIMER_VALUES:
text = ROBOT_TIMER_LABELS[seconds]
menu_item = MenuItem(icon_name='timer-%d' % (seconds),
text_label=text)
menu_item.connect('activate', self._robot_selected_cb, seconds)
self._robot_palette.menu.append(menu_item)
menu_item.show()
def create_palette(self, text, help_cb):
p = Palette(text)
if help_cb is not None:
item = MenuItem(_('Help'), 'action-help')
item.connect('activate', help_cb)
item.show()
p.menu.append(item)
self.set_palette(p)
def __init__(self, activity, abi):
ToolButton.__init__(self, 'document-save')
self.props.tooltip = _('Export')
self.props.label = _('Export')
for i in self._EXPORT_FORMATS:
menu_item = MenuItem(i['title'])
menu_item.connect('activate', self.__activate_cb, activity, abi, i)
self.props.palette.menu.append(menu_item)
menu_item.show()
def __init__(self, webaccount, is_active):
MenuItem.__init__(self, ACCOUNT_NAME)
self._account = webaccount
self._is_active = is_active
self.set_image(Icon(icon_name=ACCOUNT_ICON,
icon_size=Gtk.IconSize.MENU))
self.show()
self.set_sensitive(False)
def _setup_instrument_palette(self):
self.instrument_palette = self._instrument_button.get_palette()
self.instrument = []
for k in INSTRUMENT_DICT.keys():
self.instrument.append(k)
menu_item = MenuItem(icon_name='',
text_label=k)
menu_item.connect('activate', self.instrument_selected_cb, k)
self.instrument_palette.menu.append(menu_item)
menu_item.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 __init__(self, account, get_uid_list, is_active):
MenuItem.__init__(self, ACCOUNT_NAME)
self._facebook = account
if is_active:
icon_name = 'facebook-share'
else:
icon_name = 'facebook-share-insensitive'
self.set_image(Icon(icon_name=icon_name,
icon_size=Gtk.IconSize.MENU))
self.show()
self._get_uid_list = get_uid_list
self.connect('activate', self._facebook_share_menu_cb)
def __init__(self, account, is_active):
MenuItem.__init__(self, ACCOUNT_NAME)
self._facebook = account
self._is_active = is_active
self._metadata = None
if is_active:
icon_name = 'facebook-refresh'
else:
icon_name = 'facebook-refresh-insensitive'
self.set_image(Icon(icon_name=icon_name,
icon_size=Gtk.IconSize.MENU))
self.show()
self.connect('activate', self._fb_refresh_menu_clicked_cb)
def __init__(self, account, metadata, is_active):
MenuItem.__init__(self, ACCOUNT_NAME)
self._facebook = account
if is_active:
icon_name = 'facebook-share'
else:
icon_name = 'facebook-share-insensitive'
self.set_image(Icon(icon_name=icon_name,
icon_size=Gtk.IconSize.MENU))
self.show()
self._metadata = metadata
self._comment = '%s: %s' % (self._get_metadata_by_key('title'),
self._get_metadata_by_key('description'))
self.connect('activate', self._facebook_share_menu_cb)
def __init__(self, activity_info):
ActivityPalette.__init__(self, activity_info)
self._bundle_id = activity_info.get_bundle_id()
self._version = activity_info.get_activity_version()
registry = bundleregistry.get_registry()
self._favorite = registry.is_bundle_favorite(self._bundle_id,
self._version)
self._favorite_item = MenuItem('')
self._favorite_icon = Icon(icon_name='emblem-favorite',
icon_size=Gtk.IconSize.MENU)
self._favorite_item.set_image(self._favorite_icon)
self._favorite_item.connect('activate',
self.__change_favorite_activate_cb)
self.menu.append(self._favorite_item)
self._favorite_item.show()
if activity_info.is_user_activity():
self._add_erase_option(registry, activity_info)
registry = bundleregistry.get_registry()
self._activity_changed_sid = registry.connect('bundle_changed',
self.__activity_changed_cb)
self._update_favorite_item()
self.menu.connect('destroy', self.__destroy_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'
for property_, icon, label in self._SORT_OPTIONS:
button = MenuItem(icon_name=icon, text_label=label)
button.connect('activate',
self.__sort_type_changed_cb,
property_,
icon)
button.show()
self.props.palette.menu.insert(button, -1)
def __init__(self, calc):
Gtk.Toolbar.__init__(self)
copy_tool = ToolButton('edit-copy')
copy_tool.set_tooltip(_('Copy'))
copy_tool.set_accelerator(_('<ctrl>c'))
copy_tool.connect('clicked', lambda x: calc.text_copy())
self.insert(copy_tool, -1)
menu_item = MenuItem(_('Cut'))
try:
menu_item.set_accelerator(_('<ctrl>x'))
except AttributeError:
pass
menu_item.connect('activate', lambda x: calc.text_cut())
menu_item.show()
copy_tool.get_palette().menu.append(menu_item)
self.insert(IconToolButton('edit-paste', _('Paste'),
lambda x: calc.text_paste(),
alt_html='Paste'), -1)
self.show_all()
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 _reload_fonts(self, monitor, gio_file, other_file, event):
if event != Gio.FileMonitorEvent.CHANGES_DONE_HINT:
return
self._font_white_list = []
self._font_white_list.extend(DEFAULT_FONTS)
fonts_file = open(USER_FONTS_FILE_PATH)
for line in fonts_file:
self._font_white_list.append(line.strip())
# update the menu
for child in self.props.palette.menu.get_children():
self.props.palette.menu.remove(child)
child = None
context = self.get_pango_context()
tmp_list = []
for family in context.list_families():
name = family.get_name()
if name in self._font_white_list:
tmp_list.append(name)
for font_name in sorted(tmp_list):
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()
return False
def __init__(self, webaccount, get_uid_list, is_active):
MenuItem.__init__(self, ACCOUNT_NAME)
self._account = webaccount
logging.debug('SHAREMENU INIT %s' % (self._account.url_cache))
self._activity_id = None
self._shared_activity = None
self._join_id = None
self._tubes_chan = None
self.set_image(Icon(icon_name=ACCOUNT_ICON,
icon_size=Gtk.IconSize.MENU))
self.show()
self.set_sensitive(self.get_shared_activity_model())
self._get_uid_list = get_uid_list
# In this callback join the Journal Share activity
self.connect('activate', self.__share_menu_cb)
def new_note_cb(self, *args):
''' Add a new note to instrument tuning list '''
name = self._name_entry.get_text()
if name not in INSTRUMENT_DICT:
INSTRUMENT_DICT[name] = []
self.activity.tuning_toolbar.instrument.append(name)
menu_item = MenuItem(icon_name='', text_label=name)
menu_item.connect(
'activate',
self.activity.tuning_toolbar.instrument_selected_cb, name)
self.activity.tuning_toolbar.instrument_palette.menu.append(
menu_item)
menu_item.show()
self.new_instruments.append(name)
freq = A0 * pow(TWELTHROOT2,
self._octave * 12 + NOTES.index(self._note))
if freq not in INSTRUMENT_DICT[name]:
INSTRUMENT_DICT[name].append(freq)
def _setup_timer_palette(self):
self.timer_values = [None, 30, 180, 600]
self.timer_tooltips = [
'', _('30 seconds'),
_('3 minutes'),
_('10 minutes')
]
self.timer_labels = [
_('Disabled'),
# TRANS: Lightning chess 30 seconds between moves
_('Lightning: %d seconds') % (30),
# TRANS: Blitz chess 3 minutes between moves
_('Blitz: %d minutes') % (3),
# TRANS: Tournament chess 10 minutes between moves
_('Tournament: %d minutes') % (10)
]
self.timer_palette = self.timer_button.get_palette()
for i, label in enumerate(self.timer_labels):
menu_item = MenuItem(icon_name='timer-%d' % (i), text_label=label)
menu_item.connect('activate', self._timer_selected_cb, i)
self.timer_palette.menu.append(menu_item)
menu_item.show()
def __init__(self, cb_object):
Palette.__init__(self, text_maxlen=100)
self._cb_object = cb_object
self.set_group_id('frame')
cb_service = clipboard.get_instance()
cb_service.connect('object-state-changed',
self._object_state_changed_cb)
self._progress_bar = None
self._remove_item = MenuItem(pgettext('Clipboard', 'Remove'),
'list-remove')
self._remove_item.connect('activate', self._remove_item_activate_cb)
self.menu.append(self._remove_item)
self._remove_item.show()
self._open_item = MenuItem(_('Open'), 'zoom-activity')
self._open_item.connect('activate', self._open_item_activate_cb)
self.menu.append(self._open_item)
self._open_item.show()
self._journal_item = MenuItem(_('Keep'))
client = GConf.Client.get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
icon = Icon(icon_name='document-save', icon_size=Gtk.IconSize.MENU,
xo_color=color)
self._journal_item.set_image(icon)
self._journal_item.connect('activate', self._journal_item_activate_cb)
self.menu.append(self._journal_item)
self._journal_item.show()
self._update()
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
def create_new_toolbar(self):
toolbar_box = ToolbarBox()
activity_button = MyActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self.connect('go-fullscreen', \
self.__view_toolbar_go_fullscreen_cb)
self.back = ToolButton('go-previous')
self.back.set_tooltip(_('Back'))
self.back.props.sensitive = False
palette = self.back.get_palette()
self.menu_prev_page = MenuItem(text_label= _("Previous page"))
palette.menu.append(self.menu_prev_page)
self.menu_prev_page.show_all()
self.back.connect('clicked', self.go_back_cb)
self.menu_prev_page.connect('activate', self.go_back_cb)
toolbar_box.toolbar.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.menu_next_page = MenuItem(text_label= _("Next page"))
palette.menu.append(self.menu_next_page)
self.menu_next_page.show_all()
self.forward.connect('clicked', self.go_forward_cb)
self.menu_next_page.connect('activate', self.go_forward_cb)
toolbar_box.toolbar.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.__new_num_page_entry_insert_text_cb)
self.num_page_entry.connect('activate',
self.__new_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()
toolbar_box.toolbar.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()
toolbar_box.toolbar.insert(total_page_item, -1)
total_page_item.show()
spacer = Gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(spacer, -1)
spacer.show()
self._zoom_out = ToolButton('zoom-out')
self._zoom_out.set_tooltip(_('Zoom out'))
self._zoom_out.connect('clicked', self._zoom_out_cb)
toolbar_box.toolbar.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)
toolbar_box.toolbar.insert(self._zoom_in, -1)
self._zoom_in.props.sensitive = True
self._zoom_in.show()
self._fullscreen = ToolButton('view-fullscreen')
self._fullscreen.set_tooltip(_('Fullscreen'))
self._fullscreen.connect('clicked', self._fullscreen_cb)
toolbar_box.toolbar.insert(self._fullscreen, -1)
self._fullscreen.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()
def __init__(self, activity):
GObject.GObject.__init__(self)
self.activity = activity
self.toolbar = self.activity.get_toolbar_box().toolbar
self.jobject = None
# Change demo games button
self._demo_games = RadioMenuButton(icon_name='memorize-collection')
self._demo_games.props.tooltip = _('Load demo games')
for i, game in enumerate(self.translated_game_names):
menu_item = MenuItem(game, icon_name=self.standard_game_names[i])
menu_item.connect('activate', self.__activate_game_cb, i)
self._demo_games.props.palette.menu.append(menu_item)
menu_item.show()
self.toolbar.insert(self._demo_games, -1)
if USE_ART4APPS:
for language in art4apps_data.get_languages():
language_description = art4apps_data.get_language_name(
language)
lang_menu_item = MenuItem(language_description,
'activity-start')
self._demo_games.props.palette.menu.append(lang_menu_item)
lang_menu_item.show()
categories_menu = Gtk.Menu()
# create a submenu with the categories
categories = {}
for category in art4apps_data.get_categories():
if category in ['letters', 'other']:
continue
translated_category = art4apps_data.get_translation(
category, language)
if translated_category is not None:
label = translated_category
else:
label = category
categories[label] = category
for label in sorted(categories):
cat_menu_item = MenuItem(label)
cat_menu_item.connect('activate',
self.__activate_art4apps_game_cb,
categories[label], language)
categories_menu.append(cat_menu_item)
cat_menu_item.show()
lang_menu_item.set_submenu(categories_menu)
self._selected_game = self.standard_game_names[0]
# Change size combobox
self._size_combo = RadioMenuButton(icon_name='change_size')
self._size_combo.props.tooltip = _('Change size')
self._sizes = ['4 X 4', '5 X 5', '6 X 6']
for i, f in enumerate(self._sizes):
menu_item = MenuItem(f, icon_name=self._sizes[i])
menu_item.connect('activate', self._game_size_cb, i)
self._size_combo.props.palette.menu.append(menu_item)
menu_item.show()
self.toolbar.insert(self._size_combo, -1)
self._selected_game_size = self._sizes[0][0]
# Reset Button
self._restart_button = ToolButton('game-new')
self._restart_button.connect('clicked', self._game_reset_cb)
self._restart_button.set_tooltip(_('Restart Game'))
self.toolbar.insert(self._restart_button, -1)
self._restart_button.show()
def __init__(self, file_name, document_path, title, bundle=False):
RadioToolButton.__init__(self)
self._document_path = document_path
self._title = title
self._jobject = None
self.props.tooltip = _('Instance Source')
settings = Gio.Settings('org.sugarlabs.user')
self._color = settings.get_string('color')
icon = Icon(file=file_name,
pixel_size=style.STANDARD_ICON_SIZE,
xo_color=XoColor(self._color))
self.set_icon_widget(icon)
icon.show()
if bundle:
menu_item = MenuItem(_('Duplicate'))
icon = Icon(icon_name='edit-duplicate',
pixel_size=style.SMALL_ICON_SIZE,
xo_color=XoColor(self._color))
menu_item.connect('activate', self.__copy_to_home_cb)
else:
menu_item = MenuItem(_('Keep'))
icon = Icon(icon_name='document-save',
pixel_size=style.SMALL_ICON_SIZE,
xo_color=XoColor(self._color))
menu_item.connect('activate', self.__keep_in_journal_cb)
menu_item.set_image(icon)
self.props.palette.menu.append(menu_item)
menu_item.show()
def __init__(self, metadata):
Gtk.Menu.__init__(self)
self._metadata = metadata
for activity_info in misc.get_activities(metadata):
menu_item = MenuItem(activity_info.get_name())
menu_item.set_image(
Icon(file=activity_info.get_icon(),
icon_size=Gtk.IconSize.MENU))
menu_item.connect('activate', self.__item_activate_cb,
activity_info.get_bundle_id())
self.append(menu_item)
menu_item.show()
if not self.get_children():
if metadata.get('activity_id', ''):
resume_label = _('No activity to resume entry')
else:
resume_label = _('No activity to start entry')
menu_item = MenuItem(resume_label)
menu_item.set_sensitive(False)
self.append(menu_item)
menu_item.show()
class ActivityListPalette(ActivityPalette):
__gtype_name__ = 'SugarActivityListPalette'
__gsignals__ = {
'erase-activated': (GObject.SignalFlags.RUN_FIRST, None, ([str])),
}
def __init__(self, activity_info):
ActivityPalette.__init__(self, activity_info)
self._bundle_id = activity_info.get_bundle_id()
self._version = activity_info.get_activity_version()
registry = bundleregistry.get_registry()
self._favorite = registry.is_bundle_favorite(self._bundle_id,
self._version)
self._favorite_item = MenuItem('')
self._favorite_icon = Icon(icon_name='emblem-favorite',
icon_size=Gtk.IconSize.MENU)
self._favorite_item.set_image(self._favorite_icon)
self._favorite_item.connect('activate',
self.__change_favorite_activate_cb)
self.menu.append(self._favorite_item)
self._favorite_item.show()
if activity_info.is_user_activity():
self._add_erase_option(registry, activity_info)
registry = bundleregistry.get_registry()
self._activity_changed_sid = registry.connect(
'bundle_changed', self.__activity_changed_cb)
self._update_favorite_item()
self.menu.connect('destroy', self.__destroy_cb)
def _add_erase_option(self, registry, activity_info):
menu_item = MenuItem(_('Erase'), 'list-remove')
menu_item.connect('activate', self.__erase_activate_cb)
self.menu.append(menu_item)
menu_item.show()
if not os.access(activity_info.get_path(), os.W_OK) or \
registry.is_activity_protected(self._bundle_id):
menu_item.props.sensitive = False
def __destroy_cb(self, palette):
registry = bundleregistry.get_registry()
registry.disconnect(self._activity_changed_sid)
def _update_favorite_item(self):
label = self._favorite_item.get_child()
if self._favorite:
label.set_text(_('Remove favorite'))
xo_color = XoColor('%s,%s' % (style.COLOR_WHITE.get_svg(),
style.COLOR_TRANSPARENT.get_svg()))
else:
label.set_text(_('Make favorite'))
client = GConf.Client.get_default()
xo_color = XoColor(client.get_string('/desktop/sugar/user/color'))
self._favorite_icon.props.xo_color = xo_color
def __change_favorite_activate_cb(self, menu_item):
registry = bundleregistry.get_registry()
registry.set_bundle_favorite(self._bundle_id, self._version,
not self._favorite)
def __activity_changed_cb(self, activity_registry, activity_info):
if activity_info.get_bundle_id() == self._bundle_id and \
activity_info.get_activity_version() == self._version:
registry = bundleregistry.get_registry()
self._favorite = registry.is_bundle_favorite(
self._bundle_id, self._version)
self._update_favorite_item()
def __erase_activate_cb(self, menu_item):
self.emit('erase-activated', self._bundle_id)
def __init__(self, get_uid_list_cb):
MenuItem.__init__(self, _('Clipboard'))
self._temp_file_path = None
self._get_uid_list_cb = get_uid_list_cb
self.connect('activate', self.__copy_to_clipboard_cb)
def __init__(self, metadata):
MenuItem.__init__(self, _('Clipboard'))
self._temp_file_path = None
self._metadata = metadata
self.connect('activate', self.__copy_to_clipboard_cb)
def __init__(self):
Gtk.Toolbar.__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.prev_bookmark = MenuItem(text_label=_("Previous bookmark"))
palette.menu.append(self.prev_bookmark)
self.prev_bookmark.show_all()
self.back.connect('clicked', self.go_back_cb)
self.prev_page.connect('activate', self.go_back_cb)
self.prev_bookmark.connect('activate', self.prev_bookmark_activate_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.next_bookmark = MenuItem(text_label=_("Next bookmark"))
palette.menu.append(self.next_bookmark)
self.next_bookmark.show_all()
self.forward.connect('clicked', self.go_forward_cb)
self.next_page.connect('activate', self.go_forward_cb)
self.next_bookmark.connect('activate', self.next_bookmark_activate_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_markup(
"<span size='14000' foreground='black'>")
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()
spacer = Gtk.SeparatorToolItem()
self.insert(spacer, -1)
spacer.show()
bookmarkitem = Gtk.ToolItem()
self.bookmarker = ToggleToolButton('emblem-favorite')
self.bookmarker.set_tooltip(_('Toggle Bookmark'))
self.bookmarker_handler_id = self.bookmarker.connect(
'clicked', self.bookmarker_clicked_cb)
bookmarkitem.add(self.bookmarker)
self.insert(bookmarkitem, -1)
bookmarkitem.show_all()
underline_item = Gtk.ToolItem()
self.underline = ToggleToolButton('format-text-underline')
self.underline.set_tooltip(_('Underline'))
self.underline.props.sensitive = False
self.underline_id = self.underline.connect('clicked',
self.underline_cb)
underline_item.add(self.underline)
self.insert(underline_item, -1)
underline_item.show_all()
def __init__(self, file_name, document_path, title, bundle=False):
RadioToolButton.__init__(self)
self._document_path = document_path
self._title = title
self._jobject = None
self.props.tooltip = _('Instance Source')
client = GConf.Client.get_default()
self._color = client.get_string('/desktop/sugar/user/color')
icon = Icon(file=file_name,
icon_size=Gtk.IconSize.LARGE_TOOLBAR,
xo_color=XoColor(self._color))
self.set_icon_widget(icon)
icon.show()
if bundle:
menu_item = MenuItem(_('Duplicate'))
icon = Icon(icon_name='edit-duplicate',
icon_size=Gtk.IconSize.MENU,
xo_color=XoColor(self._color))
menu_item.connect('activate', self.__copy_to_home_cb)
else:
menu_item = MenuItem(_('Keep'))
icon = Icon(icon_name='document-save',
icon_size=Gtk.IconSize.MENU,
xo_color=XoColor(self._color))
menu_item.connect('activate', self.__keep_in_journal_cb)
menu_item.set_image(icon)
self.props.palette.menu.append(menu_item)
menu_item.show()
def __init__(self, metadata, label, mount_point):
MenuItem.__init__(self, label)
self._metadata = metadata
self.connect('activate', self.__copy_to_volume_cb, mount_point)
def _setup_tuning_palette(self, instrument):
self._tuning_palette = self._tuning_button.get_palette()
self.tuning = []
self.tuning.append(_('All notes'))
menu_item = MenuItem(icon_name='', text_label=_('All notes'))
menu_item.connect('activate', self._tuning_selected_cb, instrument, -1)
self._tuning_palette.menu.append(menu_item)
menu_item.show()
for i, f in enumerate(INSTRUMENT_DICT[instrument]):
self.tuning.append(freq_note(f))
menu_item = MenuItem(icon_name='', text_label=freq_note(f))
menu_item.connect('activate', self._tuning_selected_cb, instrument,
i)
self._tuning_palette.menu.append(menu_item)
menu_item.show()
self.show_all()
def _update(self):
new_state = self.file_transfer.props.state
logging.debug('_update state: %r', new_state)
if new_state == filetransfer.FT_STATE_PENDING:
menu_item = MenuItem(_('Cancel'), icon_name='dialog-cancel')
menu_item.connect('activate', self.__cancel_activate_cb)
self.menu.append(menu_item)
menu_item.show()
vbox = Gtk.VBox()
self.set_content(vbox)
vbox.show()
if self.file_transfer.description:
label = Gtk.Label(label=self.file_transfer.description)
vbox.add(label)
label.show()
mime_type = self.file_transfer.mime_type
type_description = mime.get_mime_description(mime_type)
size = self._format_size(self.file_transfer.file_size)
label = Gtk.Label(label='%s (%s)' % (size, type_description))
vbox.add(label)
label.show()
elif new_state in [filetransfer.FT_STATE_ACCEPTED,
filetransfer.FT_STATE_OPEN]:
for item in self.menu.get_children():
self.menu.remove(item)
menu_item = MenuItem(_('Cancel'), icon_name='dialog-cancel')
menu_item.connect('activate', self.__cancel_activate_cb)
self.menu.append(menu_item)
menu_item.show()
vbox = Gtk.VBox()
self.set_content(vbox)
vbox.show()
self.progress_bar = Gtk.ProgressBar()
vbox.add(self.progress_bar)
self.progress_bar.show()
self.progress_label = Gtk.Label(label='')
vbox.add(self.progress_label)
self.progress_label.show()
self.update_progress()
elif new_state in [filetransfer.FT_STATE_COMPLETED,
filetransfer.FT_STATE_CANCELLED]:
for item in self.menu.get_children():
self.menu.remove(item)
menu_item = MenuItem(_('Dismiss'), icon_name='dialog-cancel')
menu_item.connect('activate', self.__dismiss_activate_cb)
self.menu.append(menu_item)
menu_item.show()
self.update_progress()
def __init__(self, journalactivity, get_uid_list_cb, label, mount_point):
MenuItem.__init__(self, label)
self._get_uid_list_cb = get_uid_list_cb
self._journalactivity = journalactivity
self._mount_point = mount_point
self.connect('activate', self.__copy_to_volume_cb)
class ClipboardMenu(Palette):
def __init__(self, cb_object):
Palette.__init__(self, text_maxlen=100)
self._cb_object = cb_object
self.set_group_id('frame')
cb_service = clipboard.get_instance()
cb_service.connect('object-state-changed',
self._object_state_changed_cb)
self._remove_item = MenuItem(pgettext('Clipboard', 'Remove'),
'list-remove')
self._remove_item.connect('activate', self._remove_item_activate_cb)
self.menu.append(self._remove_item)
self._remove_item.show()
self._open_item = MenuItem(_('Open'), 'zoom-activity')
self._open_item.connect('activate', self._open_item_activate_cb)
self.menu.append(self._open_item)
self._open_item.show()
self._journal_item = MenuItem(_('Keep'))
color = profile.get_color()
icon = Icon(icon_name='document-save',
pixel_size=style.SMALL_ICON_SIZE,
xo_color=color)
self._journal_item.set_image(icon)
self._journal_item.connect('activate', self._journal_item_activate_cb)
self.menu.append(self._journal_item)
self._journal_item.show()
self._update()
def _update_open_submenu(self):
activities = self._get_activities()
logging.debug('_update_open_submenu: %r', activities)
child = self._open_item.get_child()
if activities is None or len(activities) <= 1:
child.set_text(_('Open'))
if self._open_item.get_submenu() is not None:
self._open_item.set_submenu(None)
return
child.set_text(_('Open with'))
submenu = self._open_item.get_submenu()
if submenu is None:
submenu = Gtk.Menu()
self._open_item.set_submenu(submenu)
submenu.show()
else:
for item in submenu.get_children():
submenu.remove(item)
for service_name in activities:
registry = bundleregistry.get_registry()
activity_info = registry.get_bundle(service_name)
if not activity_info:
logging.warning('Activity %s is unknown.', service_name)
item = Gtk.MenuItem(activity_info.get_name())
item.connect('activate', self._open_submenu_item_activate_cb,
service_name)
submenu.append(item)
item.show()
def _update_items_visibility(self):
activities = self._get_activities()
installable = self._cb_object.is_bundle()
percent = self._cb_object.get_percent()
if percent == 100 and (activities or installable):
self._remove_item.props.sensitive = True
self._open_item.props.sensitive = True
self._journal_item.props.sensitive = True
elif percent == 100 and (not activities and not installable):
self._remove_item.props.sensitive = True
self._open_item.props.sensitive = False
self._journal_item.props.sensitive = True
else:
self._remove_item.props.sensitive = True
self._open_item.props.sensitive = False
self._journal_item.props.sensitive = False
def _get_activities(self):
mime_type = self._cb_object.get_mime_type()
if not mime_type:
return ''
registry = bundleregistry.get_registry()
activities = registry.get_activities_for_type(mime_type)
if activities:
return [info.get_bundle_id() for info in activities]
return ''
def _object_state_changed_cb(self, cb_service, cb_object):
if cb_object != self._cb_object:
return
self._update()
def _update(self):
self.props.primary_text = self._cb_object.get_name()
preview = self._cb_object.get_preview()
if preview:
self.props.secondary_text = preview
self._update_items_visibility()
self._update_open_submenu()
def _open_item_activate_cb(self, menu_item):
logging.debug('_open_item_activate_cb')
percent = self._cb_object.get_percent()
if percent < 100 or menu_item.get_submenu() is not None:
return
jobject = self._copy_to_journal()
misc.resume(jobject.metadata, self._get_activities()[0])
jobject.destroy()
def _open_submenu_item_activate_cb(self, menu_item, service_name):
logging.debug('_open_submenu_item_activate_cb')
percent = self._cb_object.get_percent()
if percent < 100:
return
jobject = self._copy_to_journal()
misc.resume(jobject.metadata, service_name)
jobject.destroy()
def _remove_item_activate_cb(self, menu_item):
cb_service = clipboard.get_instance()
cb_service.delete_object(self._cb_object.get_id())
def _journal_item_activate_cb(self, menu_item):
logging.debug('_journal_item_activate_cb')
jobject = self._copy_to_journal()
jobject.destroy()
def _write_to_temp_file(self, data):
tmp_dir = os.path.join(env.get_profile_path(), 'data')
f, file_path = tempfile.mkstemp(dir=tmp_dir)
try:
os.write(f, data)
finally:
os.close(f)
return file_path
def _copy_to_journal(self):
formats = list(self._cb_object.get_formats().keys())
most_significant_mime_type = mime.choose_most_significant(formats)
format_ = self._cb_object.get_formats()[most_significant_mime_type]
transfer_ownership = False
if most_significant_mime_type == 'text/uri-list':
uri = format_.get_data()
if uri.startswith('file://'):
parsed_url = urllib.parse.urlparse(uri)
file_path = parsed_url.path # pylint: disable=E1101
transfer_ownership = False
mime_type = mime.get_for_file(file_path)
else:
file_path = self._write_to_temp_file(format_.get_data())
transfer_ownership = True
mime_type = 'text/uri-list'
else:
if format_.is_on_disk():
parsed_url = urllib.parse.urlparse(format_.get_data())
file_path = parsed_url.path # pylint: disable=E1101
transfer_ownership = False
mime_type = mime.get_for_file(file_path)
else:
file_path = self._write_to_temp_file(format_.get_data())
transfer_ownership = True
sniffed_mime_type = mime.get_for_file(file_path)
if sniffed_mime_type == 'application/octet-stream':
mime_type = most_significant_mime_type
else:
mime_type = sniffed_mime_type
jobject = datastore.create()
jobject.metadata['title'] = self._cb_object.get_name()
jobject.metadata['keep'] = '0'
jobject.metadata['buddies'] = ''
jobject.metadata['preview'] = ''
settings = Gio.Settings.new('org.sugarlabs.user')
color = settings.get_string('color')
jobject.metadata['icon-color'] = color
jobject.metadata['mime_type'] = mime_type
jobject.file_path = file_path
datastore.write(jobject, transfer_ownership=transfer_ownership)
return jobject
def __init__(self):
Gtk.Menu.__init__(self)
if filetransfer.file_transfer_available():
friends_model = friends.get_model()
for friend in friends_model:
if friend.is_present():
menu_item = MenuItem(text_label=friend.get_nick(),
icon_name='computer-xo',
xo_color=friend.get_color())
menu_item.connect('activate', self.__item_activate_cb,
friend)
self.append(menu_item)
menu_item.show()
if not self.get_children():
menu_item = MenuItem(_('No friends present'))
menu_item.set_sensitive(False)
self.append(menu_item)
menu_item.show()
else:
menu_item = MenuItem(_('No valid connection found'))
menu_item.set_sensitive(False)
self.append(menu_item)
menu_item.show()
def __init__(self, handle):
activity.Activity.__init__(self, handle)
if HASTOOLBARBOX:
self.max_participants = 1
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
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()
tool = ToolbarButton()
self.edit_toolbar = EditToolbar(self)
tool.props.page = self.edit_toolbar
tool.props.icon_name = 'toolbar-edit'
##tool.props.label = _('Edit'),
toolbar_box.toolbar.insert(tool, -1)
#self._undo = UndoManager.UndoManager(self,
# self.edit_toolbar.undo.child,
# self.edit_toolbar.redo.child)
self._undo = UndoManager.UndoManager(self, self.edit_toolbar.undo,
self.edit_toolbar.redo)
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)
tool = ToolbarButton()
self.text_format_toolbar = TextAttributesToolbar(self._main_area)
tool.props.page = self.text_format_toolbar
tool.props.icon_name = 'toolbar-text'
tool.props.label = _('Text')
toolbar_box.toolbar.insert(tool, -1)
# self._main_area.set_text_attributes(self.text_format_toolbar)
self.thought_toolbar = ToolbarButton()
self.thought_toolbar.props.page = ThoughtsToolbar(self)
self.thought_toolbar.props.icon_name = 'thought'
self.thought_toolbar.props.label = _('Thought Type')
toolbar_box.toolbar.insert(self.thought_toolbar, -1)
self.action_buttons = ActionButtons(self)
toolbar_box.show_all()
else:
# 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()
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.show_all()
self.__configure_cb(None)
self._mode = MMapArea.MODE_TEXT
self._main_area.set_mode(self._mode)
self.set_focus_child(self._main_area)
def __init__(self, journalactivity, metadata, detail=False):
self._journalactivity = journalactivity
self._metadata = metadata
activity_icon = Icon(icon_size=Gtk.IconSize.LARGE_TOOLBAR)
activity_icon.props.file = misc.get_icon_name(metadata)
color = misc.get_icon_color(metadata)
activity_icon.props.xo_color = color
if 'title' in metadata:
title = GObject.markup_escape_text(metadata['title'])
else:
title = GLib.markup_escape_text(_('Untitled'))
Palette.__init__(self, primary_text=title, icon=activity_icon)
if misc.get_activities(metadata) or misc.is_bundle(metadata):
if metadata.get('activity_id', ''):
resume_label = _('Resume')
resume_with_label = _('Resume with')
else:
resume_label = _('Start')
resume_with_label = _('Start with')
menu_item = MenuItem(resume_label, 'activity-start')
menu_item.connect('activate', self.__start_activate_cb)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(resume_with_label, 'activity-start')
self.menu.append(menu_item)
menu_item.show()
start_with_menu = StartWithMenu(self._metadata)
menu_item.set_submenu(start_with_menu)
else:
menu_item = MenuItem(_('No activity to start entry'))
menu_item.set_sensitive(False)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Copy to'))
icon = Icon(icon_name='edit-copy',
xo_color=color,
icon_size=Gtk.IconSize.MENU)
menu_item.set_image(icon)
self.menu.append(menu_item)
menu_item.show()
copy_menu = CopyMenu(self._journalactivity, self.__get_uid_list_cb)
copy_menu.connect('volume-error', self.__volume_error_cb)
menu_item.set_submenu(copy_menu)
if self._metadata['mountpoint'] == '/':
menu_item = MenuItem(_('Duplicate'))
icon = Icon(icon_name='edit-duplicate',
xo_color=color,
icon_size=Gtk.IconSize.MENU)
menu_item.set_image(icon)
menu_item.connect('activate', self.__duplicate_activate_cb)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Send to'), 'document-send')
self.menu.append(menu_item)
menu_item.show()
friends_menu = FriendsMenu()
friends_menu.connect('friend-selected', self.__friend_selected_cb)
menu_item.set_submenu(friends_menu)
if detail is True:
menu_item = MenuItem(_('View Details'), 'go-right')
menu_item.connect('activate', self.__detail_activate_cb)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Erase'), 'list-remove')
menu_item.connect('activate', self.__erase_activate_cb)
self.menu.append(menu_item)
menu_item.show()
def __init__(self):
MenuItem.__init__(self, text_label=ACCOUNT_NAME)
self.show()
def __init__(self, browser, title, url, owner_document):
Palette.__init__(self)
self._browser = browser
self._title = title
self._url = url
self._owner_document = owner_document
if title is not None:
self.props.primary_text = title
self.props.secondary_text = url
else:
self.props.primary_text = url
menu_item = MenuItem(_('Follow link'), 'browse-follow-link')
menu_item.connect('activate', self.__follow_activate_cb)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Follow link in new tab'),
'browse-follow-link-new-tab')
menu_item.connect('activate', self.__follow_activate_cb, True)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Keep link'))
icon = Icon(icon_name='document-save', xo_color=profile.get_color(),
icon_size=Gtk.IconSize.MENU)
menu_item.set_image(icon)
menu_item.connect('activate', self.__download_activate_cb)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Copy link'))
icon = Icon(icon_name='edit-copy', xo_color=profile.get_color(),
icon_size=Gtk.IconSize.MENU)
menu_item.set_image(icon)
menu_item.connect('activate', self.__copy_activate_cb)
self.menu.append(menu_item)
menu_item.show()
def __init__(self, journalactivity, metadata, detail=False):
self._journalactivity = journalactivity
self._metadata = metadata
activity_icon = Icon(pixel_size=style.STANDARD_ICON_SIZE)
activity_icon.props.file = misc.get_icon_name(metadata)
color = misc.get_icon_color(metadata)
activity_icon.props.xo_color = color
if 'title' in metadata:
title = metadata['title']
else:
title = _('Untitled')
Palette.__init__(self, primary_text=title, icon=activity_icon)
description = metadata.get('description', '')
if description:
self.set_secondary_text(description)
if misc.can_resume(metadata):
if metadata.get('activity_id', ''):
resume_label = _('Resume')
resume_with_label = _('Resume with')
else:
resume_label = _('Start')
resume_with_label = _('Start with')
menu_item = MenuItem(resume_label, 'activity-start')
menu_item.connect('activate', self.__start_activate_cb)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(resume_with_label, 'activity-start')
self.menu.append(menu_item)
menu_item.show()
start_with_menu = StartWithMenu(self._metadata)
menu_item.set_submenu(start_with_menu)
elif metadata.get('activity', None) == PROJECT_BUNDLE_ID:
open_label = _('Open')
menu_item = MenuItem(open_label, 'project-box')
menu_item.connect('activate', self.__open_project_activate_cb)
self.menu.append(menu_item)
menu_item.show()
else:
menu_item = MenuItem(_('No activity to start entry'))
menu_item.set_sensitive(False)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Copy to'))
icon = Icon(icon_name='edit-copy',
xo_color=color,
pixel_size=style.SMALL_ICON_SIZE)
menu_item.set_image(icon)
self.menu.append(menu_item)
menu_item.show()
copy_menu = CopyMenu(self._journalactivity, self.__get_uid_list_cb)
copy_menu.connect('volume-error', self.__volume_error_cb)
menu_item.set_submenu(copy_menu)
if not metadata.get('activity', None) == PROJECT_BUNDLE_ID:
menu_item = MenuItem(_('Send to project...'), 'project-box')
menu_item.connect('activate', self.__copy_to_project_activated_cb)
self.menu.append(menu_item)
menu_item.show()
if self._metadata['mountpoint'] == '/':
menu_item = MenuItem(_('Duplicate'))
icon = Icon(icon_name='edit-duplicate',
xo_color=color,
pixel_size=style.SMALL_ICON_SIZE)
menu_item.set_image(icon)
menu_item.connect('activate', self.__duplicate_activate_cb)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Send to'), 'document-send')
self.menu.append(menu_item)
menu_item.show()
friends_menu = FriendsMenu()
friends_menu.connect('friend-selected', self.__friend_selected_cb)
menu_item.set_submenu(friends_menu)
if detail is True:
menu_item = MenuItem(_('View Details'), 'go-right')
menu_item.connect('activate', self.__detail_activate_cb)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Erase'), 'list-remove')
menu_item.connect('activate', self.__erase_activate_cb)
self.menu.append(menu_item)
menu_item.show()
def __init__(self, invite):
Palette.__init__(self, '')
self._invite = invite
menu_item = MenuItem(_('Join'), icon_name='dialog-ok')
menu_item.connect('activate', self.__join_activate_cb)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Decline'), icon_name='dialog-cancel')
menu_item.connect('activate', self.__decline_activate_cb)
self.menu.append(menu_item)
menu_item.show()
bundle_id = invite.get_bundle_id()
registry = bundleregistry.get_registry()
self._bundle = registry.get_bundle(bundle_id)
if self._bundle:
name = self._bundle.get_name()
else:
name = bundle_id
self.set_primary_text(name)
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 _update(self):
logging.debug('_update state: %r', self.file_transfer.props.state)
if self.file_transfer.props.state == filetransfer.FT_STATE_PENDING:
menu_item = MenuItem(_('Accept'), icon_name='dialog-ok')
menu_item.connect('activate', self.__accept_activate_cb)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Decline'), icon_name='dialog-cancel')
menu_item.connect('activate', self.__decline_activate_cb)
self.menu.append(menu_item)
menu_item.show()
vbox = Gtk.VBox()
self.set_content(vbox)
vbox.show()
if self.file_transfer.description:
label = Gtk.Label(label=self.file_transfer.description)
vbox.add(label)
label.show()
mime_type = self.file_transfer.mime_type
type_description = mime.get_mime_description(mime_type)
size = self._format_size(self.file_transfer.file_size)
label = Gtk.Label(label='%s (%s)' % (size, type_description))
vbox.add(label)
label.show()
elif self.file_transfer.props.state in \
[filetransfer.FT_STATE_ACCEPTED, filetransfer.FT_STATE_OPEN]:
for item in self.menu.get_children():
self.menu.remove(item)
menu_item = MenuItem(_('Cancel'), icon_name='dialog-cancel')
menu_item.connect('activate', self.__cancel_activate_cb)
self.menu.append(menu_item)
menu_item.show()
vbox = Gtk.VBox()
self.set_content(vbox)
vbox.show()
self.progress_bar = Gtk.ProgressBar()
vbox.add(self.progress_bar)
self.progress_bar.show()
self.progress_label = Gtk.Label(label='')
vbox.add(self.progress_label)
self.progress_label.show()
self.update_progress()
elif self.file_transfer.props.state == filetransfer.FT_STATE_COMPLETED:
for item in self.menu.get_children():
self.menu.remove(item)
menu_item = MenuItem(_('Dismiss'), icon_name='dialog-cancel')
menu_item.connect('activate', self.__dismiss_activate_cb)
self.menu.append(menu_item)
menu_item.show()
self.update_progress()
elif self.file_transfer.props.state == filetransfer.FT_STATE_CANCELLED:
for item in self.menu.get_children():
self.menu.remove(item)
if self.file_transfer.reason_last_change == \
filetransfer.FT_REASON_REMOTE_STOPPED:
menu_item = MenuItem(_('Dismiss'), icon_name='dialog-cancel')
menu_item.connect('activate', self.__dismiss_activate_cb)
self.menu.append(menu_item)
menu_item.show()
text = _('The other participant canceled the file transfer')
label = Gtk.Label(label=text)
self.set_content(label)
label.show()
class ReadToolbar(Gtk.Toolbar):
__gtype_name__ = 'ReadToolbar'
def __init__(self):
Gtk.Toolbar.__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.prev_bookmark = MenuItem(text_label=_("Previous bookmark"))
palette.menu.append(self.prev_bookmark)
self.prev_bookmark.show_all()
self.back.connect('clicked', self.go_back_cb)
self.prev_page.connect('activate', self.go_back_cb)
self.prev_bookmark.connect('activate', self.prev_bookmark_activate_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.next_bookmark = MenuItem(text_label=_("Next bookmark"))
palette.menu.append(self.next_bookmark)
self.next_bookmark.show_all()
self.forward.connect('clicked', self.go_forward_cb)
self.next_page.connect('activate', self.go_forward_cb)
self.next_bookmark.connect('activate', self.next_bookmark_activate_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_markup(
"<span size='14000' foreground='black'>")
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()
spacer = Gtk.SeparatorToolItem()
self.insert(spacer, -1)
spacer.show()
bookmarkitem = Gtk.ToolItem()
self.bookmarker = ToggleToolButton('emblem-favorite')
self.bookmarker.set_tooltip(_('Toggle Bookmark'))
self.bookmarker_handler_id = self.bookmarker.connect(
'clicked', self.bookmarker_clicked_cb)
bookmarkitem.add(self.bookmarker)
self.insert(bookmarkitem, -1)
bookmarkitem.show_all()
underline_item = Gtk.ToolItem()
self.underline = ToggleToolButton('format-text-underline')
self.underline.set_tooltip(_('Underline'))
self.underline.props.sensitive = False
self.underline_id = self.underline.connect('clicked',
self.underline_cb)
underline_item.add(self.underline)
self.insert(underline_item, -1)
underline_item.show_all()
def num_page_entry_insert_text_cb(self, entry, text, length, position):
if not re.match('[0-9]', text):
entry.emit_stop_by_name('insert-text')
return True
return False
def num_page_entry_activate_cb(self, entry):
if entry.props.text:
page = int(entry.props.text) - 1
else:
page = 0
if page >= self.total_pages:
page = self.total_pages - 1
elif page < 0:
page = 0
self.current_page = page
self.activity.set_current_page(page)
self.activity.show_page(page)
entry.props.text = str(page + 1)
self.update_nav_buttons()
def go_back_cb(self, button):
self.activity.page_previous()
def go_forward_cb(self, button):
self.activity.page_next()
def update_nav_buttons(self):
current_page = self.current_page
self.back.props.sensitive = current_page > 0
self.forward.props.sensitive = \
current_page < self.total_pages - 1
self.num_page_entry.props.text = str(current_page + 1)
self.total_page_label.props.label = \
' / ' + str(self.total_pages)
def set_total_pages(self, pages):
self.total_pages = pages
def set_current_page(self, page):
self.current_page = page
self.update_nav_buttons()
def set_activity(self, activity):
self.activity = activity
def prev_bookmark_activate_cb(self, menuitem):
self.activity.prev_bookmark()
def next_bookmark_activate_cb(self, menuitem):
self.activity.next_bookmark()
def bookmarker_clicked_cb(self, button):
self.activity.bookmarker_clicked(button)
def underline_cb(self, button):
self.activity.underline_clicked(button)
def setToggleButtonState(self, button, b, id):
button.handler_block(id)
button.set_active(b)
button.handler_unblock(id)
def update_underline_button(self, state):
self.setToggleButtonState(self.underline, state, self.underline_id)
def update_bookmark_button(self, state):
self.setToggleButtonState(self.bookmarker, state,
self.bookmarker_handler_id)
def __init__(self, title, url, owner_document):
Palette.__init__(self)
self._title = title
self._url = url
self._owner_document = owner_document
self.props.primary_text = title
self.props.secondary_text = url
menu_item = MenuItem(_('Keep image'))
icon = Icon(icon_name='document-save', xo_color=profile.get_color(),
icon_size=Gtk.IconSize.MENU)
menu_item.set_image(icon)
menu_item.connect('activate', self.__download_activate_cb)
self.menu.append(menu_item)
menu_item.show()
menu_item = MenuItem(_('Copy image'))
icon = Icon(icon_name='edit-copy', xo_color=profile.get_color(),
icon_size=Gtk.IconSize.MENU)
menu_item.set_image(icon)
menu_item.connect('activate', self.__copy_activate_cb)
self.menu.append(menu_item)
menu_item.show()
class ReadSDComics(activity.Activity):
__gsignals__ = {
'go-fullscreen': (GObject.SignalFlags.RUN_FIRST,
None,
([]))
}
def __init__(self, handle):
"The entry point to the Activity"
activity.Activity.__init__(self, handle)
self._object_id = handle.object_id
self.zoom_image_to_fit = True
self.total_pages = 0
self.connect("draw", self.__draw_cb)
self.connect("delete_event", self.delete_cb)
if _NEW_TOOLBAR_SUPPORT:
self.create_new_toolbar()
else:
self.create_old_toolbar()
self.scrolled = Gtk.ScrolledWindow()
self.scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
self.scrolled.props.shadow_type = Gtk.ShadowType.NONE
self.image = Gtk.Image()
self.eventbox = Gtk.EventBox()
self.eventbox.add(self.image)
self.image.show()
self.eventbox.show()
self.scrolled.add_with_viewport(self.eventbox)
self.eventbox.set_events(Gdk.EventMask.KEY_PRESS_MASK | Gdk.EventMask.BUTTON_PRESS_MASK)
self.eventbox.set_can_focus(True)
self.eventbox.connect("key_press_event", self.keypress_cb)
self.eventbox.connect("button_press_event", self.buttonpress_cb)
self._filechooser = Gtk.FileChooserWidget(
action=Gtk.FileChooserAction.OPEN)
filter = Gtk.FileFilter()
filter.add_mime_type('application/zip')
filter.add_mime_type('application/x-cbz')
self._filechooser.set_filter(filter)
self._filechooser.set_current_folder("/media")
self.copy_button = Gtk.Button(_("Read Comic"))
self.copy_button.connect('clicked', self.select_comic_path)
self.copy_button.show()
self._filechooser.set_extra_widget(self.copy_button)
preview = Gtk.Image()
self._filechooser.set_preview_widget(preview)
self._filechooser.connect("update-preview",
self.update_preview_cb, preview)
vbox = Gtk.VBox()
vbox.pack_start(self.scrolled, True, True, 0)
vbox.pack_end(self._filechooser, True, True, 0)
self.set_canvas(vbox)
if self._object_id is None:
self.scrolled.hide()
self._filechooser.show()
else:
self.scrolled.show()
self._filechooser.hide()
vbox.show()
self.page = 0
self.saved_screen_width = 0
self.eventbox.grab_focus()
self.hidden_cursor = Gdk.Cursor.new(Gdk.CursorType.BLANK_CURSOR)
self.cursor_visible = True
self.link = None
self._close_requested = False
def select_comic_path(self, widget, data=None):
filename = self._filechooser.get_filename()
self._filechooser.hide()
self.scrolled.show()
self.link = filename
self.metadata['title'] = self.make_new_filename(self.link)
self._load_document(filename)
def create_old_toolbar(self):
toolbox = activity.ActivityToolbox(self)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.keep.props.visible = False
activity_toolbar.share.props.visible = False
self.read_toolbar = ReadToolbar()
toolbox.add_toolbar(_('Read'), self.read_toolbar)
self.read_toolbar.show()
self.read_toolbar.set_activity(self)
self.view_toolbar = ViewToolbar()
toolbox.add_toolbar(_('View'), self.view_toolbar)
self.view_toolbar.set_activity(self)
self.view_toolbar.connect('go-fullscreen',
self.__view_toolbar_go_fullscreen_cb)
self.view_toolbar.show()
self.set_toolbox(toolbox)
toolbox.show()
# start on the read toolbar
self.toolbox.set_current_toolbar(_TOOLBAR_READ)
def update_preview_cb(self, file_chooser, preview):
filename = file_chooser.get_preview_filename()
try:
file_mimetype = mime.get_for_file(filename)
if file_mimetype == 'application/x-cbz' or file_mimetype == 'application/zip':
fname = self.extract_image(filename)
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(fname,
style.zoom(320), style.zoom(240))
preview.set_from_pixbuf(pixbuf)
have_preview = True
os.remove(fname)
else:
have_preview = False
except:
have_preview = False
file_chooser.set_preview_widget_active(have_preview)
return
def extract_image(self, filename):
zf = zipfile.ZipFile(filename, 'r')
image_files = zf.namelist()
image_files.sort()
file_to_extract = image_files[0]
extract_new_filename = self.make_new_filename(file_to_extract)
if extract_new_filename is None or extract_new_filename == '':
# skip over directory name if the images are in a subdirectory.
file_to_extract = image_files[1]
extract_new_filename = self.make_new_filename(file_to_extract)
if len(image_files) > 0:
if self.save_extracted_file(zf, file_to_extract):
fname = os.path.join(self.get_activity_root(), 'instance',
extract_new_filename)
return fname
def create_new_toolbar(self):
toolbar_box = ToolbarBox()
activity_button = MyActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self.connect('go-fullscreen', \
self.__view_toolbar_go_fullscreen_cb)
self.back = ToolButton('go-previous')
self.back.set_tooltip(_('Back'))
self.back.props.sensitive = False
palette = self.back.get_palette()
self.menu_prev_page = MenuItem(text_label= _("Previous page"))
palette.menu.append(self.menu_prev_page)
self.menu_prev_page.show_all()
self.back.connect('clicked', self.go_back_cb)
self.menu_prev_page.connect('activate', self.go_back_cb)
toolbar_box.toolbar.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.menu_next_page = MenuItem(text_label= _("Next page"))
palette.menu.append(self.menu_next_page)
self.menu_next_page.show_all()
self.forward.connect('clicked', self.go_forward_cb)
self.menu_next_page.connect('activate', self.go_forward_cb)
toolbar_box.toolbar.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.__new_num_page_entry_insert_text_cb)
self.num_page_entry.connect('activate',
self.__new_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()
toolbar_box.toolbar.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()
toolbar_box.toolbar.insert(total_page_item, -1)
total_page_item.show()
spacer = Gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(spacer, -1)
spacer.show()
self._zoom_out = ToolButton('zoom-out')
self._zoom_out.set_tooltip(_('Zoom out'))
self._zoom_out.connect('clicked', self._zoom_out_cb)
toolbar_box.toolbar.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)
toolbar_box.toolbar.insert(self._zoom_in, -1)
self._zoom_in.props.sensitive = True
self._zoom_in.show()
self._fullscreen = ToolButton('view-fullscreen')
self._fullscreen.set_tooltip(_('Fullscreen'))
self._fullscreen.connect('clicked', self._fullscreen_cb)
toolbar_box.toolbar.insert(self._fullscreen, -1)
self._fullscreen.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()
def _zoom_in_cb(self, button):
self._zoom_in.props.sensitive = False
self._zoom_out.props.sensitive = True
self.zoom_to_width()
def _zoom_out_cb(self, button):
self._zoom_in.props.sensitive = True
self._zoom_out.props.sensitive = False
self.zoom_to_fit()
def enable_zoom_in(self):
self._zoom_in.props.sensitive = True
self._zoom_out.props.sensitive = False
def enable_zoom_out(self):
self._zoom_in.props.sensitive = False
self._zoom_out.props.sensitive = True
def _fullscreen_cb(self, button):
self.emit('go-fullscreen')
def __new_num_page_entry_insert_text_cb(self, entry, text, length, position):
for char in text:
if not re.match('[0-9,-.]', char):
entry.emit_stop_by_name('insert-text')
return True
return False
def __new_num_page_entry_activate_cb(self, entry):
if entry.props.text:
page = int(entry.props.text) - 1
else:
page = 0
if page >= self.total_pages:
page = self.total_pages - 1
elif page < 0:
page = 0
self.set_current_page(page)
self.show_page(page)
entry.props.text = str(page + 1)
self.update_nav_buttons()
def go_back_cb(self, button):
self.previous_page()
def go_forward_cb(self, button):
self.next_page()
def update_nav_buttons(self):
current_page = self.page
self.back.props.sensitive = current_page > 0
self.forward.props.sensitive = \
current_page < self.total_pages - 1
self.num_page_entry.props.text = str(current_page + 1)
self.total_page_label.props.label = \
' / ' + str(self.total_pages)
def set_total_pages(self, pages):
self.total_pages = pages
def setToggleButtonState(self,button,b,id):
button.handler_block(id)
button.set_active(b)
button.handler_unblock(id)
def buttonpress_cb(self, widget, event):
widget.grab_focus()
def __view_toolbar_go_fullscreen_cb(self, view_toolbar):
self.fullscreen()
def zoom_to_width(self):
self.zoom_image_to_fit = False
self.show_page(self.page)
def zoom_to_fit(self):
self.zoom_image_to_fit = True
self.show_page(self.page)
def keypress_cb(self, widget, event):
"Respond when the user presses Escape or one of the arrow keys"
keyname = Gdk.keyval_name(event.keyval)
if keyname == 'Page_Up':
self.previous_page()
return True
if keyname == 'Page_Down' :
self.next_page()
return True
if keyname == 'KP_Right':
self.scroll_down()
return True
if keyname == 'Down' or keyname == 'KP_Down':
self.scroll_down()
return True
if keyname == 'Up' or keyname == 'KP_Up':
self.scroll_up()
return True
if keyname == 'KP_Left':
self.scroll_up()
return True
if keyname == 'KP_Home':
if self.cursor_visible:
self.window.set_cursor(self.hidden_cursor)
self.cursor_visible = False
else:
self.window.set_cursor(None)
self.cursor_visible = True
return True
if keyname == 'plus':
self.view_toolbar.enable_zoom_out()
self.zoom_to_width()
return True
if keyname == 'minus':
self.view_toolbar.enable_zoom_in()
self.zoom_to_fit()
return True
return False
def scroll_down(self):
v_adjustment = self.scrolled.get_vadjustment()
if v_adjustment.value == v_adjustment.upper - v_adjustment.page_size:
self.next_page()
return
if v_adjustment.value < v_adjustment.upper - v_adjustment.page_size:
new_value = v_adjustment.value + v_adjustment.step_increment
if new_value > v_adjustment.upper - v_adjustment.page_size:
new_value = v_adjustment.upper - v_adjustment.page_size
v_adjustment.value = new_value
def scroll_up(self):
v_adjustment = self.scrolled.get_vadjustment()
if v_adjustment.value == v_adjustment.lower:
self.previous_page()
return
if v_adjustment.value > v_adjustment.lower:
new_value = v_adjustment.value - v_adjustment.step_increment
if new_value < v_adjustment.lower:
new_value = v_adjustment.lower
v_adjustment.value = new_value
def previous_page(self):
page = self.page
page=page-1
if page < 0: page=0
if self.save_extracted_file(self.zf, self.image_files[page]) == True:
fname = os.path.join(self.get_activity_root(), 'instance', self.make_new_filename(self.image_files[page]))
self.show_image(fname)
os.remove(fname)
v_adjustment = self.scrolled.get_vadjustment()
v_adjustment.value = v_adjustment.upper - v_adjustment.page_size
if _NEW_TOOLBAR_SUPPORT:
self.set_current_page(page)
else:
self.read_toolbar.set_current_page(page)
self.page = page
def set_current_page(self, page):
self.page = page
if _NEW_TOOLBAR_SUPPORT:
self.update_nav_buttons()
def next_page(self):
page = self.page
page = page + 1
if page >= len(self.image_files): page=len(self.image_files) - 1
if self.save_extracted_file(self.zf, self.image_files[page]) == True:
fname = os.path.join(self.get_activity_root(), 'instance', self.make_new_filename(self.image_files[page]))
self.show_image(fname)
os.remove(fname)
v_adjustment = self.scrolled.get_vadjustment()
v_adjustment.value = v_adjustment.lower
if _NEW_TOOLBAR_SUPPORT:
self.set_current_page(page)
else:
self.read_toolbar.set_current_page(page)
self.page = page
def __draw_cb(self, widget, cr):
screen_width = Gdk.Screen.width()
screen_height = Gdk.Screen.height()
if self.saved_screen_width != screen_width and self.saved_screen_width != 0:
self.show_page(self.page)
self.saved_screen_width = screen_width
return False
def show_page(self, page):
if self.save_extracted_file(self.zf, self.image_files[page]) == True:
fname = os.path.join(self.get_activity_root(), 'instance', self.make_new_filename(self.image_files[page]))
self.show_image(fname)
os.remove(fname)
def show_image(self, filename):
"display a resized image in a full screen window"
TOOLBOX_HEIGHT = 60
BORDER_WIDTH = 30
# get the size of the fullscreen display
screen_width = Gdk.Screen.width()
screen_width = screen_width - BORDER_WIDTH
screen_height = Gdk.Screen.height()
screen_height = screen_height - TOOLBOX_HEIGHT
# get the size of the image.
im = pygame.image.load(filename)
image_width, image_height = im.get_size()
getcontext().prec = 7
s_a_ratio = Decimal(screen_height) / Decimal(screen_width)
i_a_ratio = Decimal(image_height) / Decimal(image_width)
new_width = image_width
new_height = image_height
if self.zoom_image_to_fit == True:
if s_a_ratio >= i_a_ratio:
new_width = screen_width
new_height = image_height * screen_width
if image_width > 1:
new_height /= image_width
if new_height > screen_width:
new_height *= screen_width
if new_width > 1:
new_height /= new_width
new_width = screen_width
else:
new_height = screen_height
new_width = image_width * screen_height
if image_height > 1:
new_width /= image_height
if new_width > screen_height:
new_width *= screen_height
if new_height > 1:
new_width /= new_height
new_height = screen_height
else:
new_width = screen_width
new_height = image_height * screen_width
if image_width > 1:
new_height /= image_width
if new_height > screen_width:
new_height *= screen_width
if new_width > 1:
new_height /= new_width
new_width = screen_width
pixbuf = GdkPixbuf.Pixbuf.new_from_file(filename)
scaled_buf = pixbuf.scale_simple(new_width, new_height, GdkPixbuf.InterpType.BILINEAR)
self.image.set_from_pixbuf(scaled_buf)
self.image.show()
def save_extracted_file(self, zipfile, filename):
"Extract the file to a temp directory for viewing"
try:
filebytes = zipfile.read(filename)
except BadZipfile, err:
print 'Error opening the zip file: %s' % (err)
return False
except KeyError, err:
self._alert('Key Error', 'Zipfile key not found: ' + str(filename))
return