def _add_row(self, sender, message, icon_name, icon_color): self._store.append((get_icon_file_name(icon_name), XoColor(icon_color), sender, message, get_icon_file_name('list-remove'), XoColor('#FFFFFF,#000000')))
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 __init__(self, activity_info): self._activity_info = activity_info client = GConf.Client.get_default() color = XoColor(client.get_string('/desktop/sugar/user/color')) activity_icon = Icon(file=activity_info.get_icon(), xo_color=color, icon_size=Gtk.IconSize.LARGE_TOOLBAR) 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 _update_info(self): name = _ICON_NAME current_level = self._model.props.level xo_color = self._color badge_name = None if not self._model.props.present: status = _STATUS_NOT_PRESENT badge_name = None xo_color = XoColor( '%s,%s' % (style.COLOR_WHITE.get_svg(), style.COLOR_WHITE.get_svg())) elif self._model.props.charging: status = _STATUS_CHARGING name += '-charging' xo_color = XoColor( '%s,%s' % (style.COLOR_WHITE.get_svg(), style.COLOR_WHITE.get_svg())) elif self._model.props.discharging: status = _STATUS_DISCHARGING if current_level <= _WARN_MIN_PERCENTAGE: badge_name = 'emblem-warning' else: status = _STATUS_FULLY_CHARGED self.icon.props.icon_name = get_icon_state(name, current_level, step=-5) self.icon.props.xo_color = xo_color self.icon.props.badge_name = badge_name self.palette.set_info(current_level, self._model.props.time_remaining, status)
def __init__(self, file_name, document_path, activity_name, title, bundle=False): RadioToolButton.__init__(self) self._document_path = document_path self._title = title self._jobject = None self._activity_name = activity_name 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() box = PaletteMenuBox() self.props.palette.set_content(box) box.show() if bundle: menu_item = PaletteMenuItem(_('Duplicate'), 'edit-duplicate', xo_color=XoColor(self._color)) menu_item.connect('activate', self.__show_duplicate_alert) else: menu_item = PaletteMenuItem(_('Keep'), 'document-save', xo_color=XoColor(self._color)) menu_item.connect('activate', self.__keep_in_journal_cb) box.append_item(menu_item) menu_item.show()
def __init__(self): Gtk.Grid.__init__(self) self.set_row_spacing(style.DEFAULT_SPACING) self.set_column_spacing(style.DEFAULT_SPACING) self._gender = load_gender() self._buttons = [] self._nocolor = XoColor('#010101,#ffffff') self._color = XoColor() for i, gender in enumerate(GENDERS): self._buttons.append( EventIcon(pixel_size=style.XLARGE_ICON_SIZE, icon_name='%s-6' % (gender))) self._buttons[-1].connect('button-press-event', self._button_press_cb, i) self.attach(self._buttons[-1], i * 2, 0, 1, 1) self._buttons[-1].show() self.reset_button = EventIcon(pixel_size=style.SMALL_ICON_SIZE, icon_name='entry-cancel') self.reset_button.connect('button-press-event', self._reset_button_press_cb) self.attach(self.reset_button, 1, 0, 1, 1) self.reset_button.xo_color = XoColor('#010101,#a0a0a0') self.reset_button.show()
def get_color(): if 'org.sugarlabs.user' in Gio.Settings.list_schemas(): settings = Gio.Settings('org.sugarlabs.user') color = settings.get_string('color') return XoColor(color) else: return XoColor()
def create_profile(name, color=None): if not color: color = XoColor() client = GConf.Client.get_default() client.set_string('/desktop/sugar/user/nick', name) client.set_string('/desktop/sugar/user/color', color.to_string()) client.suggest_sync() if profile.get_pubkey() and profile.get_profile().privkey_hash: logging.info('Valid key pair found, skipping generation.') return # Generate keypair import commands keypath = os.path.join(env.get_profile_path(), 'owner.key') if os.path.exists(keypath): os.rename(keypath, keypath + '.broken') logging.warning('Existing private key %s moved to %s.broken', keypath, keypath) if os.path.exists(keypath + '.pub'): os.rename(keypath + '.pub', keypath + '.pub.broken') logging.warning('Existing public key %s.pub moved to %s.pub.broken', keypath, keypath) logging.debug("Generating user keypair") cmd = "ssh-keygen -q -t dsa -f %s -C '' -N ''" % (keypath, ) (s, o) = commands.getstatusoutput(cmd) if s != 0: logging.error('Could not generate key pair: %d %s', s, o) logging.debug("User keypair generated")
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, 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 create_profile(user_profile): settings = Gio.Settings('org.sugarlabs.user') settings.set_string('nick', user_profile.nickname) colors = user_profile.colors if colors is None: colors = XoColor() settings.set_string('color', colors.to_string()) if user_profile.gender is not None: settings.set_string('gender', user_profile.gender) else: settings.set_string('gender', '') settings.set_int('birth-timestamp', calculate_birth_timestamp(user_profile.age)) # settings.sync() # DEPRECATED from gi.repository import GConf client = GConf.Client.get_default() client.set_string('/desktop/sugar/user/nick', user_profile.nickname) client.set_string('/desktop/sugar/user/color', colors.to_string()) if user_profile.gender is not None: client.set_string('/desktop/sugar/user/gender', user_profile.gender) client.set_int('/desktop/sugar/user/birth_timestamp', calculate_birth_timestamp(user_profile.age)) client.suggest_sync() if profile.get_pubkey() and profile.get_profile().privkey_hash: logging.info('Valid key pair found, skipping generation.') return # Generate keypair keypath = os.path.join(env.get_profile_path(), 'owner.key') if os.path.exists(keypath): os.rename(keypath, keypath + '.broken') logging.warning('Existing private key %s moved to %s.broken', keypath, keypath) if os.path.exists(keypath + '.pub'): os.rename(keypath + '.pub', keypath + '.pub.broken') logging.warning('Existing public key %s.pub moved to %s.pub.broken', keypath, keypath) logging.debug("Generating user keypair") cmd = "ssh-keygen -q -t dsa -f %s -C '' -N ''" % (keypath, ) (s, o) = subprocess.getstatusoutput(cmd) if s != 0: logging.error('Could not generate key pair: %d %s', s, o) logging.debug("User keypair generated")
def __init__(self, gender, page=None): Gtk.Grid.__init__(self) self.set_row_spacing(style.DEFAULT_SPACING) self.set_column_spacing(style.DEFAULT_SPACING) self._group_labels = get_group_labels() self._page = page self._gender = gender self._age = self.get_age() self._pickers = [] self._nocolor = XoColor('#010101,#ffffff') self._color = XoColor() if self._gender not in GENDERS: self._gender = 'male' gender_index = GENDERS.index(self._gender) age_index = age_to_index(self._age) width = Gdk.Screen.width() num_ages = len(self._group_labels.AGES) for i in range(num_ages): self._pickers.append( Picker(self._group_labels.ICONS[i][gender_index], _(self._group_labels.LABELS[i]))) self._pickers[i].connect(self._button_activate_cb, i) self._fixed = Gtk.Fixed() fixed_size = width - 4 * style.GRID_CELL_SIZE self._fixed.set_size_request(fixed_size, -1) self.attach(self._fixed, 0, 0, 1, 1) self._fixed.show() self._age_adj = Gtk.Adjustment(value=age_index, lower=0, upper=num_ages - 1, step_incr=1, page_incr=3, page_size=0) self._age_adj.connect('value-changed', self.__age_adj_changed_cb) self._age_slider = Gtk.HScale() self._age_slider.set_draw_value(False) self._age_slider.set_adjustment(self._age_adj) self.attach(self._age_slider, 0, 1, 1, 1) for i in range(num_ages): self._fixed.put(self._pickers[i], 0, 0) self._configure(width) Gdk.Screen.get_default().connect('size-changed', self._configure_cb)
def _update_favorite_item(self): if self._favorite: self._favorite_item.set_label(_('Remove favorite')) xo_color = XoColor('%s,%s' % (style.COLOR_WHITE.get_svg(), style.COLOR_TRANSPARENT.get_svg())) else: self._favorite_item.set_label(_('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 _create_activity_icon(metadata): if metadata.get('icon-color', ''): color = XoColor(metadata['icon-color']) else: color = XoColor() from sugar3.activity.activity import get_bundle_path bundle = ActivityBundle(get_bundle_path()) icon = Icon(file=bundle.get_icon(), xo_color=color) return icon
def set_widget_icon(self, icon_name=None, file_name=None): if file_name is not None: icon = Icon(file=file_name, pixel_size=style.SMALL_ICON_SIZE, xo_color=XoColor('white')) else: icon = Icon(icon_name=icon_name, pixel_size=style.SMALL_ICON_SIZE, xo_color=XoColor('white')) self.set_icon_widget(icon) icon.show()
def __init__(self, tree_view): CellRendererIcon.__init__(self, tree_view) self.props.width = style.GRID_CELL_SIZE self.props.height = style.GRID_CELL_SIZE self.props.size = style.SMALL_ICON_SIZE self.props.icon_name = 'emblem-favorite' self.props.mode = Gtk.CellRendererMode.ACTIVATABLE client = GConf.Client.get_default() prelit_color = XoColor(client.get_string('/desktop/sugar/user/color')) self.props.prelit_stroke_color = prelit_color.get_stroke_color() self.props.prelit_fill_color = prelit_color.get_fill_color()
def create_profile(user_profile): settings = Gio.Settings('org.sugarlabs.user') if user_profile.nickname in [None, '']: nick = settings.get_string('nick') if nick is not None: logging.debug('recovering old nickname %s' % (nick)) user_profile.nickname = nick settings.set_string('nick', user_profile.nickname) colors = user_profile.colors if colors is None: colors = XoColor() settings.set_string('color', colors.to_string()) genderpicker.save_gender(user_profile.gender) agepicker.save_age(user_profile.age) # DEPRECATED from gi.repository import GConf client = GConf.Client.get_default() client.set_string('/desktop/sugar/user/nick', user_profile.nickname) client.set_string('/desktop/sugar/user/color', colors.to_string()) client.suggest_sync() if profile.get_pubkey() and profile.get_profile().privkey_hash: logging.info('Valid key pair found, skipping generation.') return # Generate keypair keypath = os.path.join(env.get_profile_path(), 'owner.key') if os.path.exists(keypath): os.rename(keypath, keypath + '.broken') logging.warning('Existing private key %s moved to %s.broken', keypath, keypath) if os.path.exists(keypath + '.pub'): os.rename(keypath + '.pub', keypath + '.pub.broken') logging.warning('Existing public key %s.pub moved to %s.pub.broken', keypath, keypath) logging.debug("Generating user keypair") cmd = "ssh-keygen -q -t dsa -f %s -C '' -N ''" % (keypath, ) (s, o) = commands.getstatusoutput(cmd) if s != 0: logging.error('Could not generate key pair: %d %s', s, o) logging.debug("User keypair generated")
def set_color(self, color): if self._picker == _PREVIOUS_FILL_COLOR: self._color = XoColor(_get_previous_fill_color(color)) elif self._picker == _PREVIOUS_STROKE_COLOR: self._color = XoColor(_get_previous_stroke_color(color)) elif self._picker == _NEXT_FILL_COLOR: self._color = XoColor(_get_next_fill_color(color)) elif self._picker == _NEXT_STROKE_COLOR: self._color = XoColor(_get_next_stroke_color(color)) else: self._color = color self.props.xo_color = self._color
def _create_activity_icon(metadata): if metadata.get('icon-color', ''): color = XoColor(metadata['icon-color']) else: client = GConf.Client.get_default() color = XoColor(client.get_string('/desktop/sugar/user/color')) from sugar3.activity.activity import get_bundle_path bundle = ActivityBundle(get_bundle_path()) icon = Icon(file=bundle.get_icon(), xo_color=color) return icon
def __download_running_cb(self): progress = downloadmanager.overall_downloads_progress() self._download_icon.update(progress) if downloadmanager.num_downloads() > 0: self._download_icon.props.tooltip = \ _('{}% Downloaded').format(int(progress*100)) self._download_icon.props.xo_color = XoColor(None) return True else: GLib.source_remove(self._download_running_hid) self._download_running_hid = None self._download_icon.props.tooltip = _('No Downloads Running') self._download_icon.props.xo_color = XoColor('insensitive') return False
def __init__(self, home_activity, group): RadioToolButton.__init__(self, group=group) self.set_palette_invoker(FrameWidgetInvoker(self)) self.palette_invoker.cache_palette = False self._home_activity = home_activity self._notify_launch_hid = None self._icon = NotificationPulsingIcon() self._icon.props.base_color = home_activity.get_icon_color() self._icon.props.pulse_color = \ XoColor('%s,%s' % (style.COLOR_BUTTON_GREY.get_svg(), style.COLOR_TOOLBAR_GREY.get_svg())) if home_activity.get_icon_path(): self._icon.props.file = home_activity.get_icon_path() else: # Let's see if the X11 window can give us an icon. window = home_activity.get_window() if not window.get_icon_is_fallback(): pixbuf = window.get_icon() self._icon.pixbuf = pixbuf else: self._icon.props.icon_name = 'image-missing' self.set_icon_widget(self._icon) self._icon.show() if home_activity.props.launch_status == shell.Activity.LAUNCHING: self._icon.props.pulsing = True self._notify_launch_hid = home_activity.connect( 'notify::launch-status', self.__notify_launch_status_cb) elif home_activity.props.launch_status == shell.Activity.LAUNCH_FAILED: self._on_failed_launch()
def __init__(self, **kwargs): Gtk.EventBox.__init__(self) BaseExpandedEntry.__init__(self) self.project_metadata = None self._service = None self._activity_id = None self._project = None self.modify_bg(Gtk.StateType.NORMAL, style.COLOR_WHITE.get_gdk_color()) self._vbox = Gtk.VBox() self.add(self._vbox) back_bar = BackBar() back_bar.connect('button-release-event', self.__back_bar_release_event_cb) self._vbox.pack_start(back_bar, False, True, 0) header = self.create_header() self._vbox.pack_start(header, False, False, style.DEFAULT_SPACING * 2) header.show() description_box, self._description = self._create_description() self._vbox.pack_start(description_box, False, True, style.DEFAULT_SPACING / 3) self._title.connect('focus-out-event', self._title_focus_out_event_cb) settings = Gio.Settings.new('org.sugarlabs.user') icon_color = settings.get_string('color') self._icon = Icon(icon_name='project-box', pixel_size=style.MEDIUM_ICON_SIZE) self._icon.xo_color = XoColor(icon_color) self._icon_box.pack_start(self._icon, False, False, 0)
def launch(bundle, activity_id=None, object_id=None, uri=None, color=None, invited=False): 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) 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 color is None: client = GConf.Client.get_default() color = XoColor(client.get_string('/desktop/sugar/user/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 create_icon_widgets(box, sensitive=True): icon = Icon(icon_name='go-previous') icon.props.icon_size = Gtk.IconSize.LARGE_TOOLBAR box.pack_start(icon, True, True, 0) icon.set_sensitive(sensitive) icon.show() icon = Icon(icon_name='computer-xo', icon_size=Gtk.IconSize.LARGE_TOOLBAR, xo_color=XoColor()) box.pack_start(icon, True, True, 0) icon.set_sensitive(sensitive) icon.show() icon = Icon(icon_name='battery-000', icon_size=Gtk.IconSize.LARGE_TOOLBAR, badge_name='emblem-busy') box.pack_start(icon, True, True, 0) icon.set_sensitive(sensitive) icon.show() icon = Icon(icon_name='gtk-new', icon_size=Gtk.IconSize.LARGE_TOOLBAR, badge_name='gtk-cancel') box.pack_start(icon, True, True, 0) icon.set_sensitive(sensitive) icon.show()
def __init__(self, **kwargs): self._icon_name = None self._pixel_size = style.GRID_CELL_SIZE self._xo_color = None self._title = 'No Title' Gtk.EventBox.__init__(self, **kwargs) self._vbox = Gtk.VBox() self._icon = Icon(icon_name=self._icon_name, pixel_size=self._pixel_size, xo_color=XoColor('#000000,#000000')) self._vbox.pack_start(self._icon, expand=False, fill=False, padding=0) self._label = Gtk.Label(label=self._title) self._vbox.pack_start(self._label, expand=False, fill=False, padding=0) self._vbox.set_spacing(style.DEFAULT_SPACING) self.set_visible_window(False) self.set_app_paintable(True) self.set_events(Gdk.EventMask.BUTTON_PRESS_MASK) self.add(self._vbox) self._vbox.show() self._label.show() self._icon.show()
def __init__(self, activity_info, journal_entries): ActivityPalette.__init__(self, activity_info) if not journal_entries: xo_color = XoColor('%s,%s' % (style.COLOR_BUTTON_GREY.get_svg(), style.COLOR_WHITE.get_svg())) else: xo_color = misc.get_icon_color(journal_entries[0]) self.props.icon = Icon(file=activity_info.get_icon(), xo_color=xo_color, pixel_size=style.STANDARD_ICON_SIZE) if journal_entries: self.props.secondary_text = journal_entries[0]['title'] menu_items = [] for entry in journal_entries: icon_file_name = misc.get_icon_name(entry) color = misc.get_icon_color(entry) menu_item = PaletteMenuItem(text_label=entry['title'], file_name=icon_file_name, xo_color=color) menu_item.connect('activate', self.__resume_entry_cb, entry) menu_items.append(menu_item) menu_item.show() if journal_entries: separator = PaletteMenuItemSeparator() menu_items.append(separator) separator.show() for i in range(0, len(menu_items)): self.menu_box.pack_start(menu_items[i], True, True, 0)
def __activity_updated_cb(self, account, activity_id, properties): logging.debug('__activity_updated_cb %r %r', activity_id, properties) if activity_id not in self._activities: logging.debug( '__activity_updated_cb Unknown activity with ' 'activity_id %r', activity_id) return registry = bundleregistry.get_registry() bundle = registry.get_bundle(properties['type']) if not bundle: logging.warning('Ignoring shared activity we don' 't have') return activity = self._activities[activity_id] is_new = activity.props.bundle is None # arrives unicode but we connect with byte_arrays=True - SL #4157 activity.props.color = XoColor(str(properties['color'])) activity.props.bundle = bundle activity.props.name = properties['name'] activity.props.private = properties['private'] if is_new: self._shell_model.add_shared_activity(activity_id, activity.props.color) self.emit('activity-added', activity)
def __buddy_updated_cb(self, account, contact_id, properties): logging.debug('__buddy_updated_cb %r', contact_id) if contact_id is None: # Don't know the contact-id yet, will get the full state later return if contact_id not in self._buddies: logging.debug( '__buddy_updated_cb Unknown buddy with contact_id' ' %r', contact_id) return buddy = self._buddies[contact_id] is_new = buddy.props.key is None and 'key' in properties if 'color' in properties: # arrives unicode but we connect with byte_arrays=True - SL #4157 buddy.props.color = XoColor(str(properties['color'])) if 'key' in properties: buddy.props.key = properties['key'] nick_key = CONNECTION_INTERFACE_ALIASING + '/alias' if nick_key in properties: buddy.props.nick = properties[nick_key] if is_new: self.emit('buddy-added', buddy)
def create_icon_widgets(box, sensitive=True): icon = Icon(icon_name='go-previous') icon.props.pixel_size = style.STANDARD_ICON_SIZE box.pack_start(icon, True, True, 0) icon.set_sensitive(sensitive) icon.show() icon = Icon(icon_name='computer-xo', pixel_size=style.STANDARD_ICON_SIZE, xo_color=XoColor()) box.pack_start(icon, True, True, 0) icon.set_sensitive(sensitive) icon.show() icon = Icon(icon_name='battery-000', pixel_size=style.STANDARD_ICON_SIZE, badge_name='emblem-busy') box.pack_start(icon, True, True, 0) icon.set_sensitive(sensitive) icon.show() icon = Icon(icon_name='gtk-new', pixel_size=style.STANDARD_ICON_SIZE, badge_name='gtk-cancel') box.pack_start(icon, True, True, 0) icon.set_sensitive(sensitive) icon.show()
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() client = GConf.Client.get_default() color = XoColor(client.get_string('/desktop/sugar/user/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 __init__(self, tree_view): CellRendererIcon.__init__(self, tree_view) self.props.width = style.GRID_CELL_SIZE self.props.height = style.GRID_CELL_SIZE self.props.size = style.STANDARD_ICON_SIZE self.props.stroke_color = style.COLOR_BUTTON_GREY.get_svg() self.props.fill_color = style.COLOR_TRANSPARENT.get_svg() self.props.mode = Gtk.CellRendererMode.ACTIVATABLE client = GConf.Client.get_default() prelit_color = XoColor(client.get_string("/desktop/sugar/user/color")) self.props.prelit_stroke_color = prelit_color.get_stroke_color() self.props.prelit_fill_color = prelit_color.get_fill_color() self._tree_view = tree_view
def __init__(self, tree_view): CellRendererIcon.__init__(self, tree_view) self.props.width = style.GRID_CELL_SIZE self.props.height = style.GRID_CELL_SIZE self.props.size = style.STANDARD_ICON_SIZE self.props.stroke_color = style.COLOR_BUTTON_GREY.get_svg() self.props.fill_color = style.COLOR_TRANSPARENT.get_svg() self.props.mode = Gtk.CellRendererMode.ACTIVATABLE client = GConf.Client.get_default() prelit_color = XoColor(client.get_string('/desktop/sugar/user/color')) self.props.prelit_stroke_color = prelit_color.get_stroke_color() self.props.prelit_fill_color = prelit_color.get_fill_color() self._tree_view = tree_view
def __init__(self, **kwargs): self._xo_color = XoColor('insensitive') self._icon_name = None self._direction = 'vertical' self._progress = 0.0 ToolButton.__init__(self, **kwargs) # GObject should do this, but something down the ToolButton chain of # parents is not passing the kwargs to GObject if 'xo_color' in kwargs: self.props.xo_color = kwargs['xo_color'] if 'icon_name' in kwargs: self.props.icon_name = kwargs['icon_name'] if 'direction' in kwargs: self.props.direction = kwargs['direction'] self._updated()
def _add_bookmark_icon(self, bookmark): self._xo_color = XoColor(str(bookmark.color)) self._fill_color = style.Color(self._xo_color.get_fill_color()) self._stroke_color = style.Color(self._xo_color.get_stroke_color()) self._bookmark_icon = Icon(icon_name='emblem-favorite', xo_color=self._xo_color, pixel_size=style.STANDARD_ICON_SIZE) self._bookmark_icon.set_valign(Gtk.Align.START) self._box.props.has_tooltip = True self.__box_query_tooltip_cb_id = self._box.connect( 'query_tooltip', self.__bookmark_query_tooltip_cb) self._box.pack_start(self._bookmark_icon, False, False, 0) self._bookmark_icon.show_all() if bookmark.is_local(): self._is_showing_local_bookmark = True
class BookmarkView(Gtk.EventBox): __gsignals__ = { 'bookmark-changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE, ([])), } def __init__(self): Gtk.EventBox.__init__(self) self._box = Gtk.VButtonBox() self._box.set_layout(Gtk.ButtonBoxStyle.START) self._box.set_margin_top(style.GRID_CELL_SIZE / 2) self.add(self._box) self._box.show() self._bookmark_icon = None self._bookmark_manager = None self._is_showing_local_bookmark = False self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK) self.connect('draw', self.__draw_cb) self.connect('event', self.__event_cb) def __draw_cb(self, widget, ctx): width = style.GRID_CELL_SIZE height = style.GRID_CELL_SIZE * (len(self._bookmarks) + 1) ctx.rectangle(0, 0, width, height) ctx.set_source_rgba(*self._fill_color.get_rgba()) ctx.paint() ctx.new_path() ctx.move_to(0, 0) ctx.line_to(width, 0) ctx.line_to(width, height) ctx.line_to(width / 2, height - width / 2) ctx.line_to(0, height) ctx.close_path() ctx.set_source_rgba(*self._stroke_color.get_rgba()) ctx.fill() def _add_bookmark_icon(self, bookmark): self._xo_color = XoColor(str(bookmark.color)) self._fill_color = style.Color(self._xo_color.get_fill_color()) self._stroke_color = style.Color(self._xo_color.get_stroke_color()) self._bookmark_icon = Icon(icon_name='emblem-favorite', xo_color=self._xo_color, pixel_size=style.STANDARD_ICON_SIZE) self._bookmark_icon.set_valign(Gtk.Align.START) self._box.props.has_tooltip = True self.__box_query_tooltip_cb_id = self._box.connect( 'query_tooltip', self.__bookmark_query_tooltip_cb) self._box.pack_start(self._bookmark_icon, False, False, 0) self._bookmark_icon.show_all() if bookmark.is_local(): self._is_showing_local_bookmark = True def __bookmark_query_tooltip_cb(self, widget, x, y, keyboard_mode, tip): vbox = Gtk.VBox() for bookmark in self._bookmarks: tooltip_header = bookmark.get_note_title() tooltip_body = bookmark.get_note_body() time = timestamp_to_elapsed_string(bookmark.timestamp) # TRANS: This goes like Bookmark added by User 5 days ago # TRANS: (the elapsed string gets translated automatically) tooltip_footer = ( _('Bookmark added by %(user)s %(time)s') % {'user': bookmark.nick.decode('utf-8'), 'time': time.decode('utf-8')}) l = Gtk.Label('<big>%s</big>' % tooltip_header) l.set_use_markup(True) l.set_width_chars(40) l.set_line_wrap(True) vbox.pack_start(l, False, False, 0) l.show() l = Gtk.Label('%s' % tooltip_body) l.set_use_markup(True) l.set_alignment(0, 0) l.set_padding(2, 6) l.set_width_chars(40) l.set_line_wrap(True) l.set_justify(Gtk.Justification.FILL) vbox.pack_start(l, True, True, 0) l.show() l = Gtk.Label('<small><i>%s</i></small>' % tooltip_footer) l.set_use_markup(True) l.set_width_chars(40) l.set_line_wrap(True) vbox.pack_start(l, False, False, 0) l.show() tip.set_custom(vbox) return True def __event_cb(self, widget, event): if event.type == Gdk.EventType.BUTTON_PRESS: # TODO: show the first bookmark dialog = BookmarkEditDialog( self.get_toplevel().get_window(), _("Add notes for bookmark: "), self._bookmarks, self._page, self) dialog.show_all() return False def _clear_bookmarks(self): for bookmark_icon in self._box.get_children(): bookmark_icon.destroy() self._bookmark_icon = None self._is_showing_local_bookmark = False def set_bookmarkmanager(self, bookmark_manager): self._bookmark_manager = bookmark_manager def get_bookmarkmanager(self): return (self._bookmark_manager) def update_for_page(self, page): self._page = page self._clear_bookmarks() if self._bookmark_manager is None: return self._bookmarks = self._bookmark_manager.get_bookmarks_for_page(page) if self._bookmarks: self.show() else: self.hide() for bookmark in self._bookmarks: self._add_bookmark_icon(bookmark) self.set_size_request( style.GRID_CELL_SIZE, style.GRID_CELL_SIZE * (len(self._bookmarks) + 1)) self.notify_bookmark_change() def notify_bookmark_change(self): self.queue_draw() self.emit('bookmark-changed') def add_bookmark(self, page): bookmark_title = (_("%s's bookmark") % profile.get_nick_name()) bookmark_content = (_("Bookmark for page %d") % (int(page) + 1)) dialog = BookmarkAddDialog( parent_xid=self.get_toplevel().get_window(), dialog_title=_("Add notes for bookmark: "), bookmark_title=bookmark_title, bookmark_content=bookmark_content, page=page, sidebarinstance=self) dialog.show_all() def _real_add_bookmark(self, page, content): self._bookmark_manager.add_bookmark(page, unicode(content)) self.update_for_page(page) def del_bookmark(self, page): self._bookmark_manager.del_bookmark(page) self.update_for_page(page) def is_showing_local_bookmark(self): return self._is_showing_local_bookmark
class ProgressToolButton(ToolButton): ''' This button is just like a normal tool button, except that the icon can dynamically fill based on a progress number. ''' __gtype_name__ = 'SugarProgressToolButton' def __init__(self, **kwargs): self._xo_color = XoColor('insensitive') self._icon_name = None self._direction = 'vertical' self._progress = 0.0 ToolButton.__init__(self, **kwargs) # GObject should do this, but something down the ToolButton chain of # parents is not passing the kwargs to GObject if 'xo_color' in kwargs: self.props.xo_color = kwargs['xo_color'] if 'icon_name' in kwargs: self.props.icon_name = kwargs['icon_name'] if 'direction' in kwargs: self.props.direction = kwargs['direction'] self._updated() @GObject.property def xo_color(self): ''' This property defines the stroke and fill of the icon, and is the type :class:`sugar3.graphics.xocolor.XoColor` ''' return self._xo_color @xo_color.setter def xo_color(self, new): self._xo_color = new self._updated() @GObject.property def icon_name(self): ''' Icon name (same as with a :class:`sugar3.graphics.icon.Icon`), as the type :class:`str` ''' return self._icon_name @icon_name.setter def icon_name(self, new): self._icon_name = new self._updated() @GObject.property def direction(self): ''' Direction for the icon to fill as it progresses, filling either, * :class:`Gtk.Orientation.VERTICAL` - bottom to top * :class:`Gtk.Orientation.HORIZONTAL` - user's text direction ''' if self._direction == 'vertical': return Gtk.Orientation.VERTICAL else: return Gtk.Orientation.HORIZONTAL @direction.setter def direction(self, new): if new == Gtk.Orientation.VERTICAL: self._direction = 'vertical' else: self._direction = 'horizontal' self._updated() def _updated(self): self._icon = ProgressIcon( self._icon_name, style.STANDARD_ICON_SIZE, self._xo_color.get_stroke_color(), self._xo_color.get_fill_color(), self._direction) self._icon.update(self._progress) self.set_icon_widget(self._icon) self._icon.show() def update(self, progress): ''' Redraw the icon with a different percentage filled in Args: progress (float): a value from 0.0 to 1.0, where 1.0 fully fills the icon and 0.0 results in only the stroke being visible ''' self._progress = progress self._icon.update(progress) self.queue_draw()
return t def invX(x, id): # noqa return float(x) * h / GLYPH_BOX[id]['height'] def invY(y, id): # noqa return h - float(y) * h / GLYPH_BOX[id]['height'] - b # ######### # User Info # ######### client = GConf.Client.get_default() color =\ XoColor(client.get_string('/desktop/sugar/user/color')) USER_COLOR = color.to_string().split(',') # ########### # Screen Info # ########### SCREEN = Gdk.Screen.get_default() SCREEN_WIDTH = SCREEN.get_width() SCREEN_HEIGHT = SCREEN.get_height() # ###################### # Widget Styles/Settings # ###################### # General
def __init__(self, activity): GObject.GObject.__init__(self) self.activity = activity self.instrumentDB = InstrumentDB.getRef() self.noteDB = NoteDB.NoteDB() #-- initial settings ---------------------------------- self.tempo = Config.PLAYER_TEMPO self.beatDuration = 60.0 / self.tempo self.ticksPerSecond = Config.TICKS_PER_BEAT * self.tempo / 60.0 self.volume = 0.5 self.csnd = new_csound_client() for i in range(0, 9): self.csnd.setTrackVolume(100, i) # csnd expects a range 0-100 for now self.csnd.setMasterVolume(self.volume * 100) self.csnd.setTempo(self.tempo) self.muted = False #-- Drawing ------------------------------------------- def darken(hex): hexToDec = {"0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9, "A": 10, "B": 11, "C": 12, "D": 13, "E": 14, "F": 15, "a": 10, "b": 11, "c": 12, "d": 13, "e": 14, "f": 15} r = int(0.7 * (16 * hexToDec[hex[1]] + hexToDec[hex[2]])) g = int(0.7 * (16 * hexToDec[hex[3]] + hexToDec[hex[4]])) b = int(0.7 * (16 * hexToDec[hex[5]] + hexToDec[hex[6]])) return r * 256, g * 256, b * 256 def lighten(hex): hexToDec = {"0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9, "A": 10, "B": 11, "C": 12, "D": 13, "E": 14, "F": 15, "a": 10, "b": 11, "c": 12, "d": 13, "e": 14, "f": 15} r = 255 - int(0.7 * (255 - ( 16 * hexToDec[hex[1]] + hexToDec[hex[2]]))) g = 255 - int(0.7 * (255 - ( 16 * hexToDec[hex[3]] + hexToDec[hex[4]]))) b = 255 - int(0.7 * (255 - ( 16 * hexToDec[hex[5]] + hexToDec[hex[6]]))) return r * 256, g * 256, b * 256 xoColor = profile.get_color() if not xoColor: xoColorKey = ("#8D8D8D,#FFDDEA") xoColor = XoColor(xoColorKey) # colors in Config and in XoColor are strings, # the colors in style are style.Color, transform all to Gdk.Color self.colors = {"bg": CairoUtil.get_gdk_color(Config.PANEL_BCK_COLOR), "black": style.COLOR_BLACK.get_gdk_color(), #"Picker_Bg": colormap.alloc_color("#404040"), #"Picker_Bg_Inactive": colormap.alloc_color("#808080"), "Picker_Bg": style.COLOR_TOOLBAR_GREY.get_gdk_color(), "Picker_Bg_Inactive": style.COLOR_BUTTON_GREY.get_gdk_color(), "Picker_Fg": style.COLOR_WHITE.get_gdk_color(), "Border_Active": \ CairoUtil.get_gdk_color(xoColor.get_stroke_color()), "Border_Inactive": CairoUtil.get_gdk_color("#8D8D8D"), "Border_Highlight": CairoUtil.get_gdk_color("#FFFFFF"), "Bg_Active": CairoUtil.get_gdk_color(xoColor.get_fill_color()), "Bg_Inactive": CairoUtil.get_gdk_color("#DBDBDB"), "Preview_Note_Fill": CairoUtil.get_gdk_color(Config.BG_COLOR), "Preview_Note_Border": CairoUtil.get_gdk_color(Config.FG_COLOR), "Preview_Note_Selected": style.COLOR_WHITE.get_gdk_color(), # TODO: lighten here can be removed, check if is used in other # places "Note_Fill_Active": Gdk.Color(*lighten("#590000")), # base "Border_Active" "Note_Fill_Inactive": Gdk.Color(*lighten("#8D8D8D")), # base "Border_Inactive" "Beat_Line": CairoUtil.get_gdk_color("#959595")} self.colors["Note_Border_Active"] = self.colors["Border_Active"] self.colors["Note_Border_Inactive"] = self.colors["Border_Inactive"] self.sampleNoteHeight = 7 self.sampleBg = cairo.ImageSurface.create_from_png( imagefile('sampleBG.png')) self.loopPitchOffset = 4 self.loopTickOffset = 13 self.pitchPerPixel = float(Config.NUMBER_OF_POSSIBLE_PITCHES - 1) / \ (Block.Loop.HEIGHT - 2 * self.loopPitchOffset - \ self.sampleNoteHeight) self.pixelsPerPitch = float(Block.Loop.HEIGHT - \ 2 * self.loopPitchOffset - self.sampleNoteHeight) / \ (Config.MAXIMUM_PITCH - Config.MINIMUM_PITCH) self.pixelsPerTick = Block.Loop.BEAT / float(Config.TICKS_PER_BEAT) self.ticksPerPixel = 1.0 / self.pixelsPerTick #-- Instruments --------------------------------------- self.instrumentImage = {} self.instrumentImageActive = {} for inst in self.instrumentDB.getSet("All"): if not inst.kitStage: self.prepareInstrumentImage(inst.instrumentId, inst.img) self.csnd.load_instrument(inst.name) #-- Loop Images --------------------------------------- self.loopImage = {} # get filled in through updateLoopImage self.loopImageActive = {} #-- Key Images ---------------------------------------- self.keyImage = {} self.keyImageActive = {} # use hardware key codes to work on any keyboard layout (hopefully) self.valid_shortcuts = {18: "9", 19: "0", 20: "-", 21: "=", 32: "O", 33: "P", 34: "[", 35: "]", 47: ";", 48: "'", 51: "\\", 60: ".", 61: "/", None: " "} for key in self.valid_shortcuts.keys(): self.prepareKeyImage(key) #-- Toolbars ------------------------------------------ self.jamToolbar = JamToolbar(self) jam_toolbar_button = ToolbarButton(label=_('Jam'), page=self.jamToolbar, icon_name='voltemp') self.jamToolbar.show() jam_toolbar_button.show() self.activity.toolbar_box.toolbar.insert(jam_toolbar_button, -1) self.beatToolbar = BeatToolbar(self) beat_toolbar_button = ToolbarButton(label=_('Beat'), page=self.beatToolbar, icon_name='heart') self.beatToolbar.show() beat_toolbar_button.show() self.activity.toolbar_box.toolbar.insert(beat_toolbar_button, -1) self.desktopToolbar = DesktopToolbar(self) desktop_toolbar_button = ToolbarButton(label=_('Desktop'), page=self.desktopToolbar, icon_name='jam-presets-list') self.desktopToolbar.show() desktop_toolbar_button.show() self.activity.toolbar_box.toolbar.insert(desktop_toolbar_button, -1) if Config.FEATURES_MIC or Config.FEATURES_NEWSOUNDS: self.recordToolbar = RecordToolbar(self) record_toolbar_button = ToolbarButton(label=_('Record'), page=self.recordToolbar, icon_name='microphone') self.recordToolbar.show() record_toolbar_button.show() self.activity.toolbar_box.toolbar.insert(record_toolbar_button, -1) separator = Gtk.SeparatorToolItem() separator.props.draw = True separator.set_expand(False) self.activity.toolbar_box.toolbar.insert(separator, -1) separator.show() common_playback_buttons(self.activity.toolbar_box.toolbar, self) #-- GUI ----------------------------------------------- if True: # GUI self.modify_bg(Gtk.StateType.NORMAL, self.colors["bg"]) self.GUI = {} self.GUI["mainVBox"] = Gtk.VBox() self.add(self.GUI["mainVBox"]) #-- Desktop ------------------------------------------- self.desktop = self.GUI["desktop"] = Desktop(self) self.GUI["mainVBox"].pack_start(self.GUI["desktop"], True, True, 0) #-- Bank ---------------------------------------------- separator = Gtk.Label(label=" ") separator.set_size_request(-1, style.TOOLBOX_SEPARATOR_HEIGHT) self.GUI["mainVBox"].pack_start(separator, False, True, 0) self.GUI["notebook"] = Gtk.Notebook() self.GUI["notebook"].set_scrollable(True) self.GUI["notebook"].modify_bg(Gtk.StateType.NORMAL, self.colors["Picker_Bg"]) self.GUI["notebook"].modify_bg(Gtk.StateType.ACTIVE, self.colors["Picker_Bg_Inactive"]) # TODO gtk3 no available anymore? #self.GUI["notebook"].props.tab_vborder = style.TOOLBOX_TAB_VBORDER #self.GUI["notebook"].props.tab_hborder = style.TOOLBOX_TAB_HBORDER self.GUI["notebook"].set_size_request(-1, scale(160)) self.GUI["notebook"].connect("switch-page", self.setPicker) self.GUI["mainVBox"].pack_start(self.GUI["notebook"], False, False, 0) self.pickers = {} self.pickerScroll = {} for type in [Picker.Instrument, Picker.Drum, Picker.Loop]: self.pickers[type] = type(self) def prepareLabel(name): label = Gtk.Label(label=Tooltips.categories.get(name) or name) label.set_alignment(0.0, 0.5) label.modify_fg(Gtk.StateType.NORMAL, self.colors["Picker_Fg"]) label.modify_fg(Gtk.StateType.ACTIVE, self.colors["Picker_Fg"]) return label self.GUI["notebook"].append_page(self.pickers[Picker.Drum], prepareLabel(_("Drum Kits"))) self.GUI["notebook"].append_page(self.pickers[Picker.Loop], prepareLabel(_("Loops"))) sets = self.instrumentDB.getLabels()[:] sets.sort() for set in sets: page = Gtk.HBox() page.set = set self.GUI["notebook"].append_page(page, prepareLabel(set)) self.show_all() self.GUI["notebook"].set_current_page(0) #-- Keyboard ------------------------------------------ self.key_dict = {} self.nextTrack = 2 self.keyboardListener = None self.recordingNote = None self.keyMap = {} # default instrument self._updateInstrument( self.instrumentDB.instNamed["kalimba"].instrumentId, 0.5) self.instrumentStack = [] # metronome page = NoteDB.Page(1, local=False) self.metronomePage = self.noteDB.addPage(-1, page) self.metronome = False #-- Drums --------------------------------------------- self.drumLoopId = None # use dummy values for now self.drumFillin = Fillin( 2, 100, self.instrumentDB.instNamed["drum1kit"].instrumentId, 0, 1) #-- Desktops ------------------------------------------ self.curDesktop = None # copy preset desktops path = Config.FILES_DIR + "/Desktops/" filelist = os.listdir(path) for file in filelist: shutil.copyfile(path + file, Config.TMP_DIR + '/' + file) #-- Network ------------------------------------------- self.network = Net.Network() self.network.addWatcher(self.networkStatusWatcher) self.network.connectMessage(Net.HT_SYNC_REPLY, self.processHT_SYNC_REPLY) self.network.connectMessage(Net.HT_TEMPO_UPDATE, self.processHT_TEMPO_UPDATE) self.network.connectMessage(Net.PR_SYNC_QUERY, self.processPR_SYNC_QUERY) self.network.connectMessage(Net.PR_TEMPO_QUERY, self.processPR_TEMPO_QUERY) self.network.connectMessage(Net.PR_REQUEST_TEMPO_CHANGE, self.processPR_REQUEST_TEMPO_CHANGE) # sync self.syncQueryStart = {} self.syncTimeout = None self.heartbeatLoop = self.csnd.loopCreate() self.syncBeats = 4 self.syncTicks = self.syncBeats * Config.TICKS_PER_BEAT self.offsetTicks = 0 # offset from the true heartbeat self.csnd.loopSetNumTicks(self.syncTicks * HEARTBEAT_BUFFER, self.heartbeatLoop) self.heartbeatStart = time.time() self.csnd.loopStart(self.heartbeatLoop) self.curBeat = 0 self.beatWheelTimeout = GObject.timeout_add(100, self.updateBeatWheel) # data packing classes self.packer = xdrlib.Packer() self.unpacker = xdrlib.Unpacker("") # handle forced networking if self.network.isHost(): self.updateSync() self.syncTimeout = GObject.timeout_add(1000, self.updateSync) elif self.network.isPeer(): self.sendTempoQuery() self.syncTimeout = GObject.timeout_add(1000, self.updateSync) self.activity.connect("shared", self.shared) if self.activity.shared_activity: # PEER self.activity.shared_activity.connect("buddy-joined", self.buddy_joined) self.activity.shared_activity.connect("buddy-left", self.buddy_left) self.activity.connect("joined", self.joined) self.network.setMode(Net.MD_WAIT) #-- Final Set Up -------------------------------------- self.setVolume(self.volume) self.setTempo(self.tempo) #self.activity.toolbar_box.set_current_toolbar(1) # JamToolbar self.setDesktop(0, True)