def reset_toggled(self, button):
        """
        Resets toggled property and combobox liststore.

        @param button: The reset button (can be omitted by passing None).
        @note: If a tag was selected within the L{geotagmodel.GeotagModel},
        the tag will be deleted.
        """
        self.toggled = NONE_CATEGORY

        # reset liststore
        combo = self.toolbar.combobox
        combo.set_model(self.EMPTY_LIST_STORE)

        # reset selected widget
        color_fill = profile.get_color().get_fill_color()
        color_stroke = profile.get_color().get_stroke_color()
        self._set_selected(get_gtkimage_from_plugin(NONE_CATEGORY,
                                                    color_stroke,
                                                    color_fill,
                                                    self.IMG_SIZE))

        self.reset_selected_btn.set_active(True)
        self.selected.queue_draw()
        combo.queue_draw()

    def __init__(self, nickname, properties=None):
        """
        Initializes a player.

        @param nickname: The players name.
        @param properties: A list containing features.
        """
        gobject.GObject.__init__(self)
        self._logger = logging.getLogger('player.' + nickname)
        self._logger.setLevel(constants.LOG_LEVEL)

        # players properties
        self.nickname = nickname
        self.position = Point(0,0)
        self.trace = dict()

        # set colors of the current player as default
        self.color_fill = profile.get_color().get_fill_color()
        self.color_stroke = profile.get_color().get_stroke_color()

        # the players features
        if properties is None:
            self.feature_collection = geojson.FeatureCollection(features=list())
        else:
            self.feature_collection = geojson.FeatureCollection(features=properties)

    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(_have_toolbox)
        self._setup_dispatch_table()

        # Create a canvas
        canvas = gtk.DrawingArea()
        canvas.set_size_request(gtk.gdk.screen_width(), \
                                gtk.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 set_toggled(self, button, category):
        """
        Switches the empty Button and the tagged category button clicked.
        Also, sets the appropriate liststore for the combobox.

        @param button: Toggled button (can be omittted).
        @param category: The corresponding category to set.
        """
        self._logger.debug("set_toggled()")

        self.toggled = category

        # set liststore
        combo = self.toolbar.combobox
        combo.set_model(self.toolbar.description_sets[category])

        color_fill = profile.get_color().get_fill_color()
        color_stroke = profile.get_color().get_stroke_color()

#        self._logger.debug("storage type: %s", self.selected.get_property("storage-type"))
        self._set_selected(get_gtkimage_from_plugin(category,
                                                    color_stroke,
                                                    color_fill,
                                                    self.IMG_SIZE))
        combo.queue_draw()

    def set_color(self, fill=profile.get_color().get_fill_color(), \
                  stroke=profile.get_color().get_stroke_color()):
        """
        Sets the xo colors for this player.

        @param fill: hex string for fill color.
        @param stroke: hex string for stroke color.
        """
        self.color_stroke = stroke
        self.color_fill   = fill

 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 get_xo_icon(color_stroke=None, color_fill=None, size=(20,20)):
    """
    @param color_stroke: The stroke color as hex string (default is players stroke).
    @param color_fill: The fill color as hex string (default is players fill).
    @param size: A tupel of size in pixels: (width,height).
    @return: The XO icon with given colors and size
    """
    if (color_stroke == None) or (color_fill == None):
        color_stroke = profile.get_color().get_stroke_color()
        color_fill = profile.get_color().get_fill_color()
    name = os.path.join(constants.BUNDLE_PATH, 'icons/computer-xo.svg')
    return load_svg_image(name, color_stroke, color_fill, size)

    def __members_changed_cb(self, adhoc_manager, channel, has_members):
        if channel == self._channel:
            if has_members == 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 _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 _save_recording(self):
     if os.path.exists(os.path.join(self.datapath, 'output.ogg')):
         _logger.debug('Saving recording to Journal...')
         obj_id = self._get_audio_obj_id()
         copyfile(os.path.join(self.datapath, 'output.ogg'),
                  os.path.join(self.datapath, '%s.ogg' % (obj_id)))
         dsobject = self._search_for_audio_note(obj_id)
         if dsobject is None:
             dsobject = datastore.create()
         if dsobject is not None:
             _logger.debug(self.dsobjects[self.i].metadata['title'])
             dsobject.metadata['title'] = _('Audio recording by %s') % \
                 (self.metadata['title'])
             dsobject.metadata['icon-color'] = \
                 profile.get_color().to_string()
             dsobject.metadata['tags'] = obj_id
             dsobject.metadata['mime_type'] = 'audio/ogg'
             dsobject.set_file_path(
                 os.path.join(self.datapath, '%s.ogg' % (obj_id)))
             datastore.write(dsobject)
             dsobject.destroy()
         self._add_playback_button(
             profile.get_nick_name(), self.colors,
             os.path.join(self.datapath, '%s.ogg' % (obj_id)))
         if hasattr(self, 'chattube') and self.chattube is not None:
             self._share_audio()
     else:
         _logger.debug('Nothing to save...')
     return

    def __init__(self, handle):
        ''' Initialize the toolbars and the work surface '''
        super(BBoardActivity, self).__init__(handle)

        self.datapath = get_path(activity, 'instance')

        self._hw = get_hardware()

        self._playback_buttons = {}
        self._audio_recordings = {}
        self.colors = profile.get_color().to_string().split(',')

        self._setup_toolbars()
        self._setup_canvas()

        self.slides = []
        self._setup_workspace()

        self._buddies = [profile.get_nick_name()]
        self._setup_presence_service()

        self._thumbs = []
        self._thumbnail_mode = False

        self._recording = False
        self._grecord = None
        self._alert = None

        self._dirty = False

 def _load_game(self, button):
     chooser = ObjectChooser(_('Choose memorize game'),
             parent=self.activity,
             flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
     jobject = ''
     try:
         result = chooser.run()
         if result == gtk.RESPONSE_ACCEPT:
             logging.debug('ObjectChooser: %r', 
                           chooser.get_selected_object())
             jobject = chooser.get_selected_object()
             if not jobject or  not jobject.file_path:
                 return
     finally:
         chooser.destroy()
         del chooser
         
     if jobject and jobject.file_path:   
         title = jobject.metadata['title']
         if jobject.metadata.has_key('icon-color'):
             color = jobject.metadata['icon-color']
         else:
             color = profile.get_color().to_string()
         self.emit('game_changed', jobject.file_path, 4,
                   'file', title, color)
          
         if self.jobject != None:
             self.jobject.destroy()
         self.jobject = jobject

def myblock(tw, title):
    ''' Save heap to journal (Sugar only) '''

    import os.path
    from gettext import gettext as _

    from sugar.activity import activity
    from sugar.datastore import datastore
    from sugar import profile

    from TurtleArt.tautils import get_path, data_to_file

    # Save JSON-encoded heap to temporary file
    heap_file = os.path.join(get_path(activity, 'instance'),
                             str(title) + '.txt')
    data_to_file(tw.lc.heap, heap_file)

    # Create a datastore object
    dsobject = datastore.create()

    # Write any metadata (specifically set the title of the file
    #                     and specify that this is a plain text file).
    dsobject.metadata['title'] = str(title)
    dsobject.metadata['icon-color'] = profile.get_color().to_string()
    dsobject.metadata['mime_type'] = 'text/plain'
    dsobject.set_file_path(heap_file)
    datastore.write(dsobject)
    dsobject.destroy()

 def open_url(self, url):
     """Ask the journal to open an URL for us."""
     from sugar import profile
     from shutil import rmtree
     from sugar.datastore import datastore
     from sugar.activity.activity import show_object_in_journal
     from tempfile import mkdtemp
     tmpfolder = mkdtemp('.tmp', 'url', os.path.join(self.get_activity_root(), 'instance'))
     tmpfilepath = os.path.join(tmpfolder, 'url')
     try:
         tmpfile = open(tmpfilepath, 'w')
         tmpfile.write(url)
         tmpfile.close()
         os.chmod(tmpfolder, 0755)
         os.chmod(tmpfilepath, 0755)
         jobject = datastore.create()
         metadata = {
             'title': url,
             'title_set_by_user': '1',
             'buddies': '',
             'preview': '',
             'icon-color': profile.get_color().to_string(),
             'mime_type': 'text/uri-list',
         }
         for k, v in metadata.items():
             jobject.metadata[k] = v # the dict.update method is missing =(
         jobject.file_path = tmpfilepath
         datastore.write(jobject)
         show_object_in_journal(jobject.object_id)
         jobject.destroy()
     finally:
         rmtree(tmpfilepath, ignore_errors=True) # clean up!

    def __init__(self, title, mimetype, evaluation='', can_check=True):
        gtk.HBox.__init__(self)

        if can_check:
            self._checkbutton = gtk.CheckButton()
            self._checkbutton.connect('toggled', self._toggled)
        label = gtk.Label("<b>%s</b>" % (title))
        label.set_use_markup(True)
        icon = Icon(pixel_size=52)
        icon.props.icon_name = mime.get_mime_icon(mimetype)
        icon.props.xo_color = profile.get_color()
        evaluation = gtk.Label(evaluation)
        button = gtk.ToolButton()
        button.connect('clicked', lambda w: self.emit('show-info'))
        icon_info = Icon(pixel_size=24)
        icon_info.props.icon_name = 'info-small'
        button.set_icon_widget(icon_info)
        if can_check:
            self.pack_start(self._checkbutton, False, True, 5)
        self.pack_start(icon, False, True, 5)
        self.pack_start(label, False, True, 5)
        self.pack_end(button, False, True, 5)
        self.pack_end(evaluation, False, True, 5)
        self.title = title
        self.mimetype = mimetype

        self.show_all()

    def __init__(self, channel):
        CanvasPulsingIcon.__init__(self,
                                   icon_name=self._ICON_NAME + str(channel),
                                   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)

        self.connect('button-release-event', self.__button_release_event_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 = self._create_palette()
        self.set_palette(self._palette)
        self._palette_icon.props.xo_color = self._state_color

    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 read_file(self, file_path):
     if self.metadata['mime_type'] == 'application/x-memorize-project':
         self.toolbox.set_current_toolbar(_TOOLBAR_PLAY)
         if self.metadata.has_key('icon-color'):
             color = self.metadata['icon-color']
         else:
             color = profile.get_color().to_string()
         self.game.change_game(None, file_path, 4, 'file',
                               self.metadata['title'], color)

    def _add_link(self):
        ''' take screenshot and add link info to the model '''
        for link in self.model.data['shared_links']:
            if link['hash'] == sha.new(self.current).hexdigest():
                _logger.debug('_add_link: link exist already a=%s b=%s' %(
                    link['hash'], sha.new(self.current).hexdigest()))
                return
        buf = self._get_screenshot()
        timestamp = time.time()
        self.model.add_link(self.current, self.webtitle, buf,
                            profile.get_nick_name(),
                            profile.get_color().to_string(), timestamp)

        if self.messenger is not None:
            self.messenger._add_link(self.current, self.webtitle,       
                                     profile.get_color().to_string(),
                                     profile.get_nick_name(),
                                     base64.b64encode(buf), timestamp)

    def _set_mail(self, mail):
        if mail == self._mail:
            return

        self._mail = mail
        if mail:
            self.props.xo_color = profile.get_color()
        else:
            self.props.stroke_color = style.COLOR_BUTTON_GREY.get_svg()
            self.props.fill_color = style.COLOR_TRANSPARENT.get_svg()