def __init__(self, handle): """ Initialize the toolbars and the game board """ super(RecallActivity, self).__init__(handle) self.path = activity.get_bundle_path() self.nick = profile.get_nick_name() if profile.get_color() is not None: self.colors = profile.get_color().to_string().split(",") else: self.colors = ["#A0FFA0", "#FF8080"] self._restoring = False self._setup_toolbars(True) self._setup_dispatch_table() # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), Gdk.Screen.height()) self.set_canvas(canvas) canvas.show() self.show_all() self._game = Game(canvas, parent=self, path=self.path, colors=self.colors) self._setup_presence_service() if "dotlist" in self.metadata: self._restore() else: self._game.new_game()
def __init__(self, handle): """ Initialize the toolbars and the game board """ try: super(XOEditorActivity, self).__init__(handle) except dbus.exceptions.DBusException as e: _logger.error(str(e)) self.nick = profile.get_nick_name() if profile.get_color() is not None: self.colors = profile.get_color().to_string().split(',') else: self.colors = ['#A0FFA0', '#FF8080'] self.level = 0 self._setup_toolbars(_have_toolbox) # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), Gdk.Screen.height()) self.set_canvas(canvas) canvas.show() self.show_all() self._game = Game(canvas, parent=self, mycolors=self.colors) # Read the dot positions from the Journal for i in range(len(colors)): if 'x%d' % (i) in self.metadata and 'y%d' % (i) in self.metadata: self._game.move_dot(i, int(self.metadata['x%d' % (i)]), int(self.metadata['y%d' % (i)])) if 'xox' in self.metadata and 'xoy' in self.metadata: self._game.move_xo_man(int(self.metadata['xox']), int(self.metadata['xoy']))
def __init__(self, handle): """ Initialize the toolbars and the game board """ try: super(FlipActivity, self).__init__(handle) except dbus.exceptions.DBusException as e: _logger.error(str(e)) self.nick = profile.get_nick_name() if profile.get_color() is not None: self.colors = profile.get_color().to_string().split(',') else: self.colors = ['#A0FFA0', '#FF8080'] self._setup_toolbars() self._setup_dispatch_table() # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), Gdk.Screen.height()) self.set_canvas(canvas) canvas.show() self.show_all() self._game = Game(canvas, parent=self, colors=self.colors) self._setup_presence_service() if 'dotlist' in self.metadata: self._restore() else: self._game.new_game()
def __init__(self, handle): """ Initialize the toolbars and the game board """ super(PathsActivity, self).__init__(handle) self.nick = profile.get_nick_name() if profile.get_color() is not None: self.colors = profile.get_color().to_string().split(',') else: self.colors = ['#A0FFA0', '#FF8080'] self._setup_toolbars() self._setup_dispatch_table() # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), Gdk.Screen.height()) self.set_canvas(canvas) canvas.show() self.show_all() self._game = Game(canvas, parent=self, colors=self.colors) self._setup_presence_service() # Restore game state from Journal or start new game if 'deck' in self.metadata: self._restore() else: self._game.new_game()
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()
def __init__(self, handle): ''' Initiate activity. ''' super(FractionBounceActivity, self).__init__(handle) self.nick = profile.get_nick_name() if profile.get_color() is not None: self._colors = profile.get_color().to_string().split(',') else: self._colors = ['#A0FFA0', '#FF8080'] self.max_participants = 4 # sharing self._playing = True self._setup_toolbars() self._setup_dispatch_table() canvas = self._setup_canvas() # Read any custom fractions from the project metadata if 'custom' in self.metadata: custom = self.metadata['custom'] else: custom = None self._current_ball = 'soccerball' self._toolbar_was_expanded = False # Initialize the canvas self._bounce_window = Bounce(canvas, activity.get_bundle_path(), self) Gdk.Screen.get_default().connect('size-changed', self._configure_cb) # Restore any custom fractions if custom is not None: fractions = custom.split(',') for f in fractions: self._bounce_window.add_fraction(f) if self.shared_activity: # We're joining if not self.get_shared(): xocolors = XoColor(profile.get_color().to_string()) share_icon = Icon(icon_name='zoom-neighborhood', xo_color=xocolors) self._joined_alert = NotifyAlert() self._joined_alert.props.icon = share_icon self._joined_alert.props.title = _('Please wait') self._joined_alert.props.msg = _('Starting connection...') self._joined_alert.connect('response', self._alert_cancel_cb) self.add_alert(self._joined_alert) self._label.set_label(_('Wait for the sharer to start.')) # Wait for joined signal self.connect("joined", self._joined_cb) self._setup_sharing()
def _get_colors(self): colors = None if self._tw.running_sugar: if profile.get_color() is not None: colors = profile.get_color().to_string() else: colors = self._activity.get_colors() if colors is None: colors = '%s,%s' % (DEFAULT_TURTLE_COLORS[0], DEFAULT_TURTLE_COLORS[1]) return colors.split(',')
def _update(self): state = self._device_state if (state >= network.NM_DEVICE_STATE_PREPARE) and \ (state <= network.NM_DEVICE_STATE_IP_CONFIG): self._icon.props.base_color = self._inactive_color self._icon.props.pulse_color = profile.get_color() self._palette.set_connecting() self._icon.props.pulsing = True elif state == network.NM_DEVICE_STATE_ACTIVATED: address = self._device_props.Get(network.NM_DEVICE_IFACE, 'Ip4Address') self._palette.set_connected_with_channel(self._channel, address) self._icon.props.base_color = profile.get_color() self._icon.props.pulsing = False self._update_text()
def __members_changed_cb(self, adhoc_manager, channel, has_members): if channel == self._channel: if has_members is True: self._state_color = profile.get_color() else: color = '%s,%s' % (profile.get_color().get_stroke_color(), style.COLOR_TRANSPARENT.get_svg()) self._state_color = XoColor(color) if not self._filtered: self.props.base_color = self._state_color self._palette_icon.props.xo_color = self._state_color self.alpha = 1.0 else: self.alpha = _FILTERED_ALPHA
def __init__(self): BaseBuddyModel.__init__(self) self.props.nick = profile.get_nick_name() self.props.color = profile.get_color() self.props.key = profile.get_profile().pubkey self.connect('notify::nick', self.__property_changed_cb) self.connect('notify::color', self.__property_changed_cb) bus = dbus.SessionBus() bus.add_signal_receiver(self.__name_owner_changed_cb, signal_name='NameOwnerChanged', dbus_interface='org.freedesktop.DBus') bus_object = bus.get_object(dbus.BUS_DAEMON_NAME, dbus.BUS_DAEMON_PATH) for service in bus_object.ListNames( dbus_interface=dbus.BUS_DAEMON_IFACE): if service.startswith(CONNECTION + '.'): path = '/%s' % service.replace('.', '/') Connection(service, path, bus, ready_handler=self.__connection_ready_cb)
def __notification_received_cb(self, **kwargs): logging.debug('__notification_received_cb') icon = NotificationIcon() icon.show_badge() icon.connect('button-release-event', self.__button_release_event_cb) hints = kwargs['hints'] icon_file_name = hints.get('x-sugar-icon-file-name', '') icon_name = hints.get('x-sugar-icon-name', '') if icon_file_name: icon.props.icon_filename = icon_file_name elif icon_name: icon.props.icon_name = icon_name else: icon.props.icon_name = 'application-octet-stream' icon_colors = hints.get('x-sugar-icon-colors', '') if not icon_colors: icon_colors = profile.get_color() icon.props.xo_color = icon_colors duration = kwargs.get('expire_timeout', -1) if duration == -1: duration = NOTIFICATION_DURATION self.add_notification(icon, Gtk.CornerType.TOP_LEFT, duration)
def _comment_activate_cb(self, entry): text = entry.props.text if not "comments" in self._reflection.data: self._reflection.data["comments"] = [] data = { "nick": profile.get_nick_name(), "color": self._reflection.activity.fg_color.get_html(), "comment": text, } self._reflection.data["comments"].append(data) self.add_new_comment(data) # Send the comment if self._reflection.activity.sharing: self._reflection.activity.send_event( "%s|%s|%s|%s|%s" % (COMMENT_CMD, self._reflection.data["obj_id"], data["nick"], data["color"], data["comment"]) ) entry.set_text("") # Update journal entry dsobj = datastore.get(self._reflection.data["obj_id"]) if "comments" in dsobj.metadata: data = json.loads(dsobj.metadata["comments"]) else: data = [] data.append({"from": profile.get_nick_name(), "message": text, "icon-color": profile.get_color().to_string()}) dsobj.metadata["comments"] = json.dumps(data) datastore.write( dsobj, update_mtime=False, reply_handler=self.datastore_write_cb, error_handler=self.datastore_write_error_cb, )
def _update_properties(self, properties): if 'Mode' in properties: self._mode = properties['Mode'] self._color = None if 'Ssid' in properties: self._ssid = properties['Ssid'] self._display_name = network.ssid_to_display_name(self._ssid) self._color = None if 'Strength' in properties: self._strength = properties['Strength'] if 'Flags' in properties: self._flags = properties['Flags'] if 'Frequency' in properties: self._frequency = properties['Frequency'] if self._color == None: if self._mode == network.NM_802_11_MODE_ADHOC and \ network.is_sugar_adhoc_network(self._ssid): self._color = profile.get_color() else: sha_hash = hashlib.sha1() data = self._ssid + hex(self._flags) sha_hash.update(data) digest = hash(sha_hash.digest()) index = digest % len(xocolor.colors) self._color = xocolor.XoColor( '%s,%s' % (xocolor.colors[index][0], xocolor.colors[index][1])) self._update()
def create_journal_entry(self, tempfile): journal_entry = datastore.create() journal_title = self.selected_title if self.selected_volume != '': journal_title += ' ' + _('Volume') + ' ' + self.selected_volume if self.selected_author != '': journal_title = journal_title + ', by ' + self.selected_author journal_entry.metadata['title'] = journal_title journal_entry.metadata['title_set_by_user'] = '******' journal_entry.metadata['keep'] = '0' if _NEW_TOOLBAR_SUPPORT: format = self.format_combo.props.value else: format = self._books_toolbar.format_combo.props.value if format == '.epub': journal_entry.metadata['mime_type'] = 'application/epub+zip' if format == '.djvu': journal_entry.metadata['mime_type'] = 'image/vnd.djvu' if format == '.pdf' or format == '_bw.pdf': journal_entry.metadata['mime_type'] = 'application/pdf' journal_entry.metadata['buddies'] = '' journal_entry.metadata['preview'] = '' journal_entry.metadata['icon-color'] = profile.get_color().to_string() textbuffer = self.textview.get_buffer() journal_entry.metadata['description'] = textbuffer.get_text(textbuffer.get_start_iter(), textbuffer.get_end_iter(), True) journal_entry.file_path = tempfile datastore.write(journal_entry) os.remove(tempfile) self.progressbar.hide() self._alert(_('Success'), self.selected_title + _(' added to Journal.'))
def save(self): """ Save the current font loaded in globals.FONT as a .ufo.zip file. The file will be saved in the activity data folder """ ufo_path = self._create_font_instance() title = self.get_title() zip_path = \ os.path.join(self.get_activity_root(), 'data', '%s_ufo.zip' % (title)) if globals.FONT.save_zip(ufo_path, zip_path) is True: # create a journal entry jobject = datastore.create() # FIXME: This method of setting the metadata is not working # set the title to the output of self.get_title() jobject.metadata['icon-color'] = profile.get_color().to_string() jobject.metadata['mime_type'] = 'application/zip' jobject.metadata['title'] = title jobject.file_path = zip_path datastore.write(jobject, transfer_ownership=True) self._object_id = jobject.object_id # create an alert success_title = 'Success' success_msg = 'A UFO Font zip file was created in the Journal' self._show_journal_alert(_(success_title), _(success_msg)) else: # create an alert failure_title = 'Error' failure_msg = 'Could not create the Zip file' self._show_journal_alert(_(failure_title), _(failure_msg))
def __init__(self): self._color = profile.get_color() TrayIcon.__init__(self, icon_name=_ICON_NAME, xo_color=self._color) self.set_palette_invoker(FrameWidgetInvoker(self)) self.palette_invoker.props.toggle_palette = True self._manager = speech.get_speech_manager()
def _create_chart(self, data): chart = charts.Chart(charts.HORIZONTAL_BAR) colors = profile.get_color() logging.debug(colors) chart_color = colors.get_fill_color() logging.debug(chart_color) chart_line_color = colors.get_stroke_color() logging.debug(chart_line_color) eventbox = Gtk.EventBox() charts_area = ChartArea(chart) eventbox.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse('white')) eventbox.add(charts_area) eventbox.show() self._vbox.pack_end(eventbox, True, True, 0) chart_data = [] i = 0 for entry in data: label = entry[0] value = len(entry[1]) chart_data.append((label, float(value))) i += 1 if i > 15: break chart.data_set(chart_data) chart.width = Gdk.Screen.width() - 2 * style.GRID_CELL_SIZE chart.height = Gdk.Screen.height() - 2 * style.GRID_CELL_SIZE chart.set_color_scheme(color=chart_color) chart.set_line_color(chart_line_color) chart.render() charts_area.queue_draw() self.show_all()
def save_bundle(self, btn): # create bundle builder = XOPackager(Builder(Config(self.activity_dir, '/tmp'))) builder.package() logging.error('Packaging %s', builder.package_path) jobject = datastore.create() icon_color = profile.get_color().to_string() metadata = { 'title': '%s-%s.xo' % (builder.config.bundle_name, builder.config.version), 'title_set_by_user': '******', 'suggested_filename': '%s-%s.xo' % (builder.config.bundle_name, builder.config.version), 'icon-color': icon_color, 'mime_type': 'application/vnd.olpc-sugar', 'activity': '', 'activity_id': '', 'share-scope': activity.SCOPE_PRIVATE, 'preview': '', 'source': self.activity_dir, } for k, v in metadata.items(): jobject.metadata[k] = v jobject.file_path = builder.package_path datastore.write(jobject) jobject.destroy() self._show_alert(_('The bundle has been saved in the journal.'), _('Success'))
def _save_recording(self): self.metadata['dirty'] = 'True' # So we know that we've done work if os.path.exists(os.path.join(self.datapath, 'output.ogg')): _logger.debug('Saving recording to Journal...') if self._uid is None: self._uid = generate_uid() if self._game.get_mode() == 'array': target = self._uid else: target = '%s-%d' % (self._uid, self._game.current_image) dsobject = self._search_for_audio_note(target) if dsobject is None: dsobject = datastore.create() dsobject.metadata['title'] = \ _('audio note for %s') % (self.metadata['title']) dsobject.metadata['icon-color'] = profile.get_color().to_string() dsobject.metadata['mime_type'] = 'audio/ogg' if self._uid is not None: dsobject.metadata['tags'] = target dsobject.set_file_path(os.path.join(self.datapath, 'output.ogg')) datastore.write(dsobject) dsobject.destroy() # Enable playback after record is finished self._game.set_play_icon_state(True) self.metadata['dirty'] = 'True' # Always save an image with the recording. # self._do_save_as_image_cb() else: _logger.debug('Nothing to save...') return
def _save_as_image(self): ''' Grab the current canvas and save it to the Journal. ''' if self._uid is None: self._uid = generate_uid() if self._game.get_mode() == 'array': target = self._uid else: target = '%s-%d' % (self._uid, self._game.current_image) file_path = os.path.join(self.datapath, 'story.png') png_surface = self._game.export() png_surface.write_to_png(file_path) dsobject = datastore.create() dsobject.metadata['title'] = '%s %s' % \ (self.metadata['title'], _('image')) dsobject.metadata['icon-color'] = profile.get_color().to_string() dsobject.metadata['mime_type'] = 'image/png' dsobject.metadata['tags'] = target dsobject.set_file_path(file_path) datastore.write(dsobject) dsobject.destroy() os.remove(file_path) GObject.timeout_add(1000, self._remove_alert)
def do_drag_data_get(self, path, selection): data = self.get_iter(path) mime_type = self.get_value(data, 13) fileid = self.get_value(data, 14) title = self.get_value(data, 15) data = self._account.download_file(fileid, self._display_alert) fd, file_path = tempfile.mkstemp(dir="/tmp/") os.close(fd) if data[0]: f = open(file_path, 'w') f.write(data[0]) f.close() jobject = datastore.create() jobject.metadata['title'] = title jobject.metadata['icon-color'] = profile.get_color().to_string() jobject.metadata['mime_type'] = mime_type if data[1]: jobject.metadata['activity'] = data[1] if data[0]: jobject.file_path = file_path datastore.write(jobject) self._load_files() self._journal_button.set_active(True) self._listview.refresh()
def start_game(self, numPlayers): self._create_domino() self.placed_pieces = [] self.players = [] auto_player = SimpleAutoPlayer(self, 0) auto_player.set_pieces(self.take_pieces(7)) self.players.append(auto_player) if self.ENABLE_AUTO_MODE: auto_player2 = SimpleAutoPlayer(self, 1) auto_player2.set_pieces(self.take_pieces(7)) auto_player2.pieces_position = self.table.second_player_position self.players.append(auto_player2) else: for n in range(1, numPlayers): player = DominoPlayer(self, n) player.set_pieces(self.take_pieces(7)) self.players.append(player) # comienza a jugar el primer jugador self.players[0].play() self.ui_player = self.players[1] self.ui_player.color = profile.get_color() self.ui_player.name = profile.get_nick_name() self._actual_player = 0
def _share_stats(self): stats = self._generate_stats() nick = profile.get_nick_name() colors = profile.get_color().to_string() self._send_event('S:%s' % (json.dumps([nick, colors, stats]))) self._restore_cursor() self._create_chart(stats)
def __save_data_cb(self, button): if type(self.get_canvas()) is not PollCanvas: return chart_params = {} axis = { 'tickFont': 'Sans', 'labelFont': 'Sans', 'labelFontSize': 14, 'labelColor': '#666666', 'lineColor': '#b3b3b3', 'tickColor': '#000000', 'tickFontSize': 12 } chart_params['font_options'] = { 'titleFont': 'Sans', 'titleFontSize': 12, 'titleColor': '#000000', 'axis': axis } title = _('Results from poll "%s"') % self._poll.title chart_params['title'] = title chart_params['x_label'] = '' chart_params['y_label'] = '' chart_params['current_chart.type'] = 1 xo_color = profile.get_color() chart_params['chart_line_color'] = xo_color.get_stroke_color() chart_params['chart_color'] = xo_color.get_fill_color() """ 'chart_data': [ ['hello', 200.0], ['mrch', 100.0]], """ data = [] for choice in range(self._poll.number_of_options): # data is used by the chart data.append([self._poll.options[choice], self._poll.data[choice]]) chart_params['chart_data'] = data logging.debug('chart_data %s', chart_params) # save to the journal data_file = tempfile.NamedTemporaryFile(mode='w+b', suffix='.json') journal_entry = datastore.create() journal_entry.metadata['title'] = title journal_entry.metadata['keep'] = '0' journal_entry.metadata['mime_type'] = 'application/x-chart-activity' journal_entry.metadata['activity'] = 'org.sugarlabs.SimpleGraph' json.dump(chart_params, data_file.file) data_file.file.close() journal_entry.file_path = data_file.name logging.debug('Create %s data file', data_file.name) datastore.write(journal_entry) self._show_journal_alert(_('Exported data'), _('Open in the Journal'), journal_entry.object_id)
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', 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, 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 _comment_activate_cb(self, entry): text = entry.props.text if not 'comments' in self._reflection.data: self._reflection.data['comments'] = [] data = {'nick': profile.get_nick_name(), 'color': self._reflection.activity.fg_color.get_html(), 'comment': text} self._reflection.data['comments'].append(data) self.add_new_comment(data) # Send the comment if self._reflection.activity.sharing: send_data = data.copy() send_data["obj_id"] = self._reflection.data["obj_id"] self._reflection.activity.send_event(COMMENT_CMD, send_data) entry.set_text('') # Update journal entry dsobj = datastore.get(self._reflection.data['obj_id']) if 'comments' in dsobj.metadata: data = json.loads(dsobj.metadata['comments']) else: data = [] data.append({'from': profile.get_nick_name(), 'message': text, 'icon-color': profile.get_color().to_string()}) dsobj.metadata['comments'] = json.dumps(data) datastore.write(dsobj, update_mtime=False, reply_handler=self.datastore_write_cb, error_handler=self.datastore_write_error_cb)
def export_font(self): """ Export the current font loaded in globals.FONT as a .otf file. The file will be saved in the activity data folder """ # create the file path file_path =\ os.path.join(self.get_activity_root(), 'data', '%s.otf' % self.get_title) # save the otf globals.FONT.export_binary(file_path) # create a journal entry jobject = datastore.create() jobject.metadata['icon-color'] = profile.get_color().to_string() jobject.metadata['mime_type'] = 'application/x-font-opentype' jobject.metadata['title'] = '%s.otf' % self.get_title jobject.file_path = file_path datastore.write(jobject, transfer_ownership=True) self._object_id = jobject.object_id success_title = 'Success' success_msg = 'A OTF Font file was created in the Journal' self._show_journal_alert(_(success_title), _(success_msg))
def __init__(self, cb_object, group): RadioToolButton.__init__(self, group=group) self.props.palette_invoker = FrameWidgetInvoker(self) self.palette_invoker.props.toggle_palette = True self._cb_object = cb_object self.owns_clipboard = False self.props.sensitive = False self.props.active = False self._notif_icon = None self._current_percent = None self._icon = Icon() color = profile.get_color() self._icon.props.xo_color = color self.set_icon_widget(self._icon) self._icon.show() cb_service = clipboard.get_instance() cb_service.connect('object-state-changed', self._object_state_changed_cb) cb_service.connect('object-selected', self._object_selected_cb) child = self.get_child() child.connect('drag-data-get', self._drag_data_get_cb) self.connect('notify::active', self._notify_active_cb)
def read_file(self, file_path): if 'icon-color' in self.metadata: color = self.metadata['icon-color'] else: color = profile.get_color().to_string() self.change_game(None, file_path, 4, 'file', self.metadata['title'], color)
def _create_journal_object(self): logging.debug('_create_journal_object') self.dl_jobject = datastore.create() filename = self._download.get_response().get_suggested_filename() self.dl_jobject.metadata['title'] = \ _('Downloading %(filename)s from \n%(source)s.') % \ {'filename': filename, 'source': self._source} self.dl_jobject.metadata['progress'] = '0' self.dl_jobject.metadata['keep'] = '0' self.dl_jobject.metadata['buddies'] = '' self.dl_jobject.metadata['preview'] = '' self.dl_jobject.metadata['icon-color'] = \ profile.get_color().to_string() self.dl_jobject.metadata['mime_type'] = '' self.dl_jobject.file_path = self._dest_path datastore.write(self.dl_jobject) bus = dbus.SessionBus() obj = bus.get_object(DS_DBUS_SERVICE, DS_DBUS_PATH) datastore_dbus = dbus.Interface(obj, DS_DBUS_INTERFACE) self.datastore_deleted_handler = datastore_dbus.connect_to_signal( 'Deleted', self.__datastore_deleted_cb, arg0=self.dl_jobject.object_id)
def __init__(self, cb_object, group): RadioToolButton.__init__(self, group=group) self.props.palette_invoker = FrameWidgetInvoker(self) self.palette_invoker.props.toggle_palette = True self._cb_object = cb_object self.owns_clipboard = False self.props.sensitive = False self.props.active = False self._notif_icon = None self._current_percent = None self._icon = Icon() color = profile.get_color() self._icon.props.xo_color = color self.set_icon_widget(self._icon) self._icon.show() cb_service = clipboard.get_instance() cb_service.connect('object-state-changed', self._object_state_changed_cb) cb_service.connect('object-selected', self._object_selected_cb) child = self.get_child() child.connect('drag_data_get', self._drag_data_get_cb) self.connect('notify::active', self._notify_active_cb)
def load_object(self, full_path, filename): if self.set_to_page_like(full_path): return scrollwnd = Gtk.ScrolledWindow() scrollwnd.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) page = GtkSourceview2Page(full_path) page.set_theme(self.theme_state) page.set_font_size(self.font_size) vbox = Gtk.VBox() if full_path.endswith('.svg'): icon = Icon(file=full_path, pixel_size=100, xo_color=profile.get_color()) vbox.pack_start(icon, False, False, 0) vbox.pack_start(scrollwnd, True, True, 0) scrollwnd.add(page) vbox.page = page label = filename page.text_buffer.connect('changed', self.__text_changed_cb) tablabel = TabLabel(scrollwnd, label) tablabel.connect( 'tab-close', lambda widget, child: self.remove_page(self.page_num(child))) tablabel.page = page self.append_page(vbox, tablabel) self.__text_changed_cb(page.text_buffer) self.show_all() self.set_current_page(-1)
def __init__(self, activity_info): self._activity_info = activity_info color = profile.get_color() activity_icon = Icon(file=activity_info.get_icon(), xo_color=color, pixel_size=style.STANDARD_ICON_SIZE) name = activity_info.get_name() Palette.__init__(self, primary_text=GLib.markup_escape_text(name), icon=activity_icon) xo_color = XoColor( '%s,%s' % (style.COLOR_WHITE.get_svg(), style.COLOR_TRANSPARENT.get_svg())) self.menu_box = PaletteMenuBox() menu_item = PaletteMenuItem(text_label=_('Start new'), file_name=activity_info.get_icon(), xo_color=xo_color) menu_item.connect('activate', self.__start_activate_cb) self.menu_box.pack_end(menu_item, True, True, 0) menu_item.show() self.set_content(self.menu_box) self.menu_box.show_all()
def __init__(self, channel): EventPulsingIcon.__init__(self, icon_name=self._ICON_NAME + str(channel), pixel_size=style.STANDARD_ICON_SIZE, cache=True) self._bus = dbus.SystemBus() self._channel = channel self._disconnect_item = None self._connect_item = None self._palette_icon = None self._filtered = False get_adhoc_manager_instance().connect('members-changed', self.__members_changed_cb) get_adhoc_manager_instance().connect('state-changed', self.__state_changed_cb) pulse_color = XoColor('%s,%s' % (style.COLOR_BUTTON_GREY.get_svg(), style.COLOR_TRANSPARENT.get_svg())) self.props.pulse_color = pulse_color self._state_color = XoColor('%s,%s' % (profile.get_color().get_stroke_color(), style.COLOR_TRANSPARENT.get_svg())) self.props.base_color = self._state_color self.palette_invoker.props.toggle_palette = True self._palette = self._create_palette() self.set_palette(self._palette) self._palette_icon.props.xo_color = self._state_color
def __favorite_set_data(self, column, cell, tree_model, tree_iter, data): favorite = tree_model[tree_iter][1] if favorite: cell.props.xo_color = profile.get_color() else: cell.props.xo_color = None
def __favorite_set_data_cb(self, column, cell, tree_model, tree_iter, data): favorite = tree_model[tree_iter][ListModel.COLUMN_FAVORITE] if favorite: cell.props.xo_color = profile.get_color() else: cell.props.xo_color = None
def _comment_activate_cb(self, entry): text = entry.props.text if not 'comments' in self._reflection.data: self._reflection.data['comments'] = [] data = { 'nick': profile.get_nick_name(), 'color': self._reflection.activity.fg_color.get_html(), 'comment': text } self._reflection.data['comments'].append(data) self.add_new_comment(data) # Send the comment if self._reflection.activity.sharing: send_data = data.copy() send_data["obj_id"] = self._reflection.data["obj_id"] self._reflection.activity.send_event(COMMENT_CMD, send_data) entry.set_text('') # Update journal entry dsobj = datastore.get(self._reflection.data['obj_id']) if 'comments' in dsobj.metadata: data = json.loads(dsobj.metadata['comments']) else: data = [] data.append({ 'from': profile.get_nick_name(), 'message': text, 'icon-color': profile.get_color().to_string() }) dsobj.metadata['comments'] = json.dumps(data) datastore.write(dsobj, update_mtime=False, reply_handler=self.datastore_write_cb, error_handler=self.datastore_write_error_cb)
def __favorite_set_data_cb(self, column, cell, model, tree_iter, data): favorite = \ model[tree_iter][self._model.column_favorites[cell.favorite_view]] if favorite: cell.props.xo_color = profile.get_color() else: cell.props.xo_color = None
def launch(bundle, activity_id=None, object_id=None, uri=None, color=None, invited=False, alert_window=None): bundle_id = bundle.get_bundle_id() if activity_id is None or not activity_id: activity_id = activityfactory.create_activity_id() logging.debug('launch bundle_id=%s activity_id=%s object_id=%s uri=%s', bundle.get_bundle_id(), activity_id, object_id, uri) if isinstance(bundle, ContentBundle): # Content bundles are a special case: we treat them as launching # Browse with a specific URI. uri = bundle.get_start_uri() activities = get_activities_for_mime('text/html') if len(activities) == 0: logging.error("No browser available for content bundle") return bundle = activities[0] logging.debug('Launching content bundle with uri %s', uri) shell_model = shell.get_model() activity = shell_model.get_activity_by_id(activity_id) if activity is not None: logging.debug('re-launch %r', activity.get_window()) activity.get_window().activate(Gtk.get_current_event_time()) return if not shell_model.can_launch_activity(): if alert_window is None: from jarabe.desktop import homewindow alert_window = homewindow.get_instance() if alert_window is not None: alerts.show_max_open_activities_alert(alert_window) return if not shell_model.can_launch_activity_instance(bundle): if alert_window is None: from jarabe.desktop import homewindow alert_window = homewindow.get_instance() if alert_window is not None: alerts.show_multiple_instance_alert( alert_window, shell_model.get_name_from_bundle_id(bundle_id)) return if color is None: color = profile.get_color() launcher.add_launcher(activity_id, bundle.get_icon(), color) activity_handle = ActivityHandle(activity_id=activity_id, object_id=object_id, uri=uri, invited=invited) activityfactory.create(bundle, activity_handle)
def export_font(self): """ Export the current font loaded in globals.FONT as a .otf file. The file will be saved in the activity data folder """ # create the file path file_path = \ os.path.join(self.get_activity_root(), 'data', '%s.otf' % self.get_title) # save the otf globals.FONT.export_binary(file_path) # create a journal entry jobject = datastore.create() jobject.metadata['icon-color'] = profile.get_color().to_string() jobject.metadata['mime_type'] = 'application/x-font-opentype' jobject.metadata['title'] = '%s.otf' % self.get_title jobject.file_path = file_path datastore.write(jobject, transfer_ownership=True) self._object_id = jobject.object_id success_title = 'Success' success_msg = 'A OTF Font file was created in the Journal' self._show_journal_alert(_(success_title), _(success_msg))
def save(self): """ Save the current font loaded in globals.FONT as a .ufo.zip file. The file will be saved in the activity data folder """ ufo_path = self._create_font_instance() title = self.get_title() zip_path =\ os.path.join(self.get_activity_root(), 'data', '%s_ufo.zip' % (title)) if globals.FONT.save_zip(ufo_path, zip_path) is True: # create a journal entry jobject = datastore.create() # FIXME: This method of setting the metadata is not working # set the title to the output of self.get_title() jobject.metadata['icon-color'] = profile.get_color().to_string() jobject.metadata['mime_type'] = 'application/zip' jobject.metadata['title'] = title jobject.file_path = zip_path datastore.write(jobject, transfer_ownership=True) self._object_id = jobject.object_id # create an alert success_title = 'Success' success_msg = 'A UFO Font zip file was created in the Journal' self._show_journal_alert(_(success_title), _(success_msg)) else: # create an alert failure_title = 'Error' failure_msg = 'Could not create the Zip file' self._show_journal_alert(_(failure_title), _(failure_msg))
def _update_properties(self, properties): if 'Mode' in properties: self._mode = properties['Mode'] self._color = None if 'Ssid' in properties: self._ssid = properties['Ssid'] self._display_name = network.ssid_to_display_name(self._ssid) self._color = None if 'Strength' in properties: self._strength = properties['Strength'] if 'Flags' in properties: self._flags = properties['Flags'] if 'Frequency' in properties: self._frequency = properties['Frequency'] if self._color is None: if self._mode == network.NM_802_11_MODE_ADHOC and \ network.is_sugar_adhoc_network(self._ssid): self._color = profile.get_color() else: sha_hash = hashlib.sha1() data = self._ssid + hex(self._flags) sha_hash.update(data) digest = hash(sha_hash.digest()) index = digest % len(xocolor.colors) self._color = xocolor.XoColor('%s,%s' % (xocolor.colors[index][0], xocolor.colors[index][1])) self._update()
def internal_callback(): files = [] if os.path.exists(USER_FILES): f = open(USER_FILES, 'r') try: data = json.load(f) except: files = [] os.remove(USER_FILES) self._journal.get_window().set_cursor(None) f.close() data = [] isdict = False if isinstance(data, dict): isdict = True if isdict: data = data['items'] for userfile in data: txt = '<span weight="bold">%s</span>' % ( GLib.markup_escape_text(userfile['title'])) icon_name = _get_icon_for_mime(userfile['mimeType']) link = userfile['alternateLink'] itter = self._model.insert(-1, [ '', False, icon_name, profile.get_color(), txt, '', '', 50, profile.get_color(), profile.get_color(), profile.get_color(), True, link, userfile['mimeType'], userfile['id'], userfile['title'] ]) files.append(itter) if len(files) == 0 or not os.path.exists(USER_FILES): self._listview._show_message(_( 'No files in your ' 'account, please update your file list ' 'clicking in the toolbar menu option.'), icon_name=ACCOUNT_ICON) else: self._listview._clear_message() self._journal.get_window().set_cursor(None)
def internal_callback(): files = [] if os.path.exists(USER_FILES): f = open(USER_FILES, 'r') try: data = json.load(f) except: files = [] os.remove(USER_FILES) self._journal.get_window().set_cursor(None) f.close() data = [] isdict = False if isinstance(data, dict): isdict = True if isdict: data = data['items'] for userfile in data: txt = '<span weight="bold">%s</span>' % ( GLib.markup_escape_text(userfile['title'])) icon_name = _get_icon_for_mime(userfile['mimeType']) link = userfile['alternateLink'] itter = self._model.insert(-1, [ '', False, icon_name, profile.get_color(), txt, '', '', 50, profile.get_color(), profile.get_color(), profile.get_color(), True, link, userfile['mimeType'], userfile['id'], userfile['title']]) files.append(itter) if len(files) == 0 or not os.path.exists(USER_FILES): self._listview._show_message(_('No files in your ' 'account, please update your file list ' 'clicking in the toolbar menu option.'), icon_name=ACCOUNT_ICON) else: self._listview._clear_message() self._journal.get_window().set_cursor(None)
def __init__(self): self._color = profile.get_color() TrayIcon.__init__(self, icon_name=_ICON_NAME, xo_color=self._color) self._input_method = Maliit.InputMethod() self.connect('button-release-event', self.__button_release_event_cb) self.set_palette_invoker(FrameWidgetInvoker(self))
def __init__(self, handle): """ Initialize the toolbars and the game board """ activity.Activity.__init__(self, handle) self.nick = profile.get_nick_name() if profile.get_color() is not None: self.colors = profile.get_color().to_string().split(',') else: self.colors = ['#A0FFA0', '#FF8080'] self.level = 0 self._correct = 0 self._playing = True self._game_over = False self._python_code = None self._setup_toolbars() self._setup_dispatch_table() # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), Gdk.Screen.height()) self.set_canvas(canvas) canvas.show() self.show_all() self._game = Game(canvas, parent=self, colors=self.colors) self._sharing = False self._initiating = False self.connect('shared', self._shared_cb) self._collab = CollabWrapper(self) self._collab.connect('message', self._message_cb) self._collab.connect('joined', self._joined_cb) self._collab.setup() if 'level' in self.metadata: self.level = int(self.metadata['level']) self.status.set_label(_('Resuming level %d') % (self.level + 1)) self._game.show_random() else: self._game.new_game()
def __init__(self): """ Create the icon that represents the touchpad. """ icon_name = STATUS_ICON[_read_touchpad_mode()] color = profile.get_color() TrayIcon.__init__(self, icon_name=icon_name, xo_color=color) self.set_palette_invoker(FrameWidgetInvoker(self)) self.connect('button-release-event', self.__button_release_event_cb)