moving to common toolbar utils

2 files changed, 334 insertions, 237 deletions

diff --git a/VisualMatchActivity.py b/VisualMatchActivity.py
index d69b607..68595de 100644
--- a/VisualMatchActivity.py
+++ b/VisualMatchActivity.py
@@ -55,6 +55,9 @@ except(ImportError, AttributeError):
 
 from StringIO import StringIO
 
+from toolbar_utils import radio_factory, button_factory, label_factory, \
+    spin_factory, separator_factory
+
 from constants import DECKSIZE, PRODUCT, HASH, ROMAN, WORD, CHINESE, MAYAN, \
                       INCAN, DOTS, STAR, DICE, LINES, DEAL
 
@@ -76,83 +79,10 @@ IFACE = SERVICE
 PATH = '/org/augarlabs/VisualMatchActivity'
 
 
-def _radio_button_factory(name='', toolbar=None, cb=None, arg=None,
-                          tooltip=None, group=None):
-    ''' Add a radio button to a toolbar '''
-    button = RadioToolButton(group=group)
-    button.set_named_icon(name)
-    if cb is not None:
-        if arg is None:
-            button.connect('clicked', cb)
-        else:
-            button.connect('clicked', cb, arg)
-    if toolbar is not None:
-        toolbar.insert(button, -1)
-    button.show()
-    if tooltip is not None:
-        button.set_tooltip(tooltip)
-    return button
-
-
-def _button_factory(icon_name, tooltip, callback, toolbar, cb_arg=None,
-                    accelerator=None):
-    """Factory for making toolbar buttons"""
-    my_button = ToolButton(icon_name)
-    my_button.set_tooltip(tooltip)
-    my_button.props.sensitive = True
-    if accelerator is not None:
-        my_button.props.accelerator = accelerator
-    if cb_arg is not None:
-        my_button.connect('clicked', callback, cb_arg)
-    else:
-        my_button.connect('clicked', callback)
-    if hasattr(toolbar, 'insert'):  # the main toolbar
-        toolbar.insert(my_button, -1)
-    else:  # or a secondary toolbar
-        toolbar.props.page.insert(my_button, -1)
-    my_button.show()
-    return my_button
-
-
-def _label_factory(label, toolbar):
-    """ Factory for adding a label to a toolbar """
-    my_label = gtk.Label(label)
-    my_label.set_line_wrap(True)
-    my_label.show()
-    _toolitem = gtk.ToolItem()
-    _toolitem.add(my_label)
-    toolbar.insert(_toolitem, -1)
-    _toolitem.show()
-    return my_label
-
-
-def _spin_factory(default, min, max, callback, toolbar):
-    """ Factory for adding a spinner """
-    _spin_adj = gtk.Adjustment(default, min, max, 5, 15, 0)
-    my_spin = gtk.SpinButton(_spin_adj, 0, 0)
-    _spin_id = my_spin.connect('value-changed', callback)
-    my_spin.set_numeric(True)
-    my_spin.show()
-    _toolitem = gtk.ToolItem()
-    _toolitem.add(my_spin)
-    toolbar.insert(_toolitem, -1)
-    _toolitem.show()
-    return my_spin
-
-
-def _separator_factory(toolbar, visible=True, expand=False):
-    """ Factory for adding a separator to a toolbar """
-    _separator = gtk.SeparatorToolItem()
-    _separator.props.draw = visible
-    _separator.set_expand(expand)
-    toolbar.insert(_separator, -1)
-    _separator.show()
-
-
 class VisualMatchActivity(activity.Activity):
-    """ Dimension matching game """
+    ''' Dimension matching game '''
     def __init__(self, handle):
-        """ Initialize the Sugar activity """
+        ''' Initialize the Sugar activity '''
         super(VisualMatchActivity, self).__init__(handle)
 
         self._read_journal_data()
@@ -166,7 +96,7 @@ class VisualMatchActivity(activity.Activity):
             self._saved_state = None
         self.vmw.new_game(self._saved_state, self._deck_index)
         if self._saved_state == None:
-            # Launch "attract mode" by turning on Robot with 5 second delay
+            # Launch 'attract mode' by turning on Robot with 5 second delay
             self.vmw.robot_time = 5
             self._robot_cb()
 
@@ -178,7 +108,7 @@ class VisualMatchActivity(activity.Activity):
             self.vmw.edit_custom_card()
 
     def _select_game_cb(self, button, card_type):
-        """ Choose which game we are playing. """
+        ''' Choose which game we are playing. '''
         if self.vmw.joiner():  # joiner cannot change level
             return
         self.vmw.card_type = card_type
@@ -194,7 +124,7 @@ class VisualMatchActivity(activity.Activity):
             self.vmw.new_game()
 
     def _robot_cb(self, button=None):
-        """ Toggle robot assist on/off """
+        ''' Toggle robot assist on/off '''
         if self.vmw.robot:
             self.vmw.robot = False
             self.robot_button.set_tooltip(_('Play with the computer.'))
@@ -206,7 +136,7 @@ class VisualMatchActivity(activity.Activity):
             self.robot_button.set_icon('robot-on')
 
     def _level_cb(self, button, level):
-        """ Cycle between levels """
+        ''' Cycle between levels '''
         if self.vmw.joiner():  # joiner cannot change level
             return
         self.vmw.level = level
@@ -218,24 +148,24 @@ class VisualMatchActivity(activity.Activity):
         self.vmw.new_game()
 
     def calc_level_label(self, low_score, play_level):
-        """ Show the score. """
+        ''' Show the score. '''
         if low_score[play_level] == -1:
             return LEVEL_LABELS[play_level]
         else:
-            return "%s (%d:%02d)" % \
+            return '%s (%d:%02d)' % \
                     (LEVEL_LABELS[play_level],
                      int(low_score[play_level] / 60),
                      int(low_score[play_level] % 60))
 
     def image_import_cb(self, button=None):
-        """ Import custom cards from the Journal """
+        ''' Import custom cards from the Journal '''
         self.vmw.editing_custom_cards = True
         self.vmw.edit_custom_card()
         if self.vmw.robot:
             self._robot_cb(button)
 
     def _number_card_O_cb(self, button, numberO):
-        """ Choose between O-card list for numbers game. """
+        ''' Choose between O-card list for numbers game. '''
         if self.vmw.joiner():  # joiner cannot change decks
             return
         self.vmw.numberO = numberO
@@ -243,7 +173,7 @@ class VisualMatchActivity(activity.Activity):
         self.vmw.new_game()
 
     def _number_card_C_cb(self, button, numberC):
-        """ Choose between C-card list for numbers game. """
+        ''' Choose between C-card list for numbers game. '''
         if self.vmw.joiner():  # joiner cannot change decks
             return
         self.vmw.numberC = numberC
@@ -251,26 +181,26 @@ class VisualMatchActivity(activity.Activity):
         self.vmw.new_game()
 
     def _robot_time_spin_cb(self, button):
-        """ Set delay for robot. """
+        ''' Set delay for robot. '''
         self.vmw.robot_time = self._robot_time_spin.get_value_as_int()
         return
 
     def _edit_words_cb(self, button):
-        """ Edit the word list. """
+        ''' Edit the word list. '''
         self.vmw.editing_word_list = True
         self.vmw.edit_word_list()
         if self.vmw.robot:
             self._robot_cb(button)
 
     def _read_metadata(self, keyword, default_value):
-        """ If the keyword is found, return stored value """
+        ''' If the keyword is found, return stored value '''
         if keyword in self.metadata:
             return(self.metadata[keyword])
         else:
             return(default_value)
 
     def _read_journal_data(self):
-        """ There may be data from a previous instance. """
+        ''' There may be data from a previous instance. '''
         self._play_level = int(self._read_metadata('play_level', 1))
         self._robot_time = int(self._read_metadata('robot_time', 60))
         self._card_type = self._read_metadata('cardtype', 'pattern')
@@ -307,15 +237,15 @@ class VisualMatchActivity(activity.Activity):
                     'custom_' + str(i), None))
 
     def _find_datapath(self, activity):
-        """ Find the datapath for saving card files. """
+        ''' Find the datapath for saving card files. '''
         if hasattr(activity, 'get_activity_root'):
             return os.path.join(activity.get_activity_root(), 'data')
         else:
-            return os.path.join(os.environ['HOME'], ".sugar", "default",
+            return os.path.join(os.environ['HOME'], '.sugar', 'default',
                                 SERVICE, 'data')
 
     def _setup_toolbars(self, new_sugar_system):
-        """ Setup the toolbars.. """
+        ''' Setup the toolbars.. '''
 
         games_toolbar = gtk.Toolbar()
         tools_toolbar = gtk.Toolbar()
@@ -350,7 +280,7 @@ class VisualMatchActivity(activity.Activity):
             tools_toolbar_button.show()
 
             self._set_labels(toolbox.toolbar)
-            _separator_factory(toolbox.toolbar, False, True)
+            separator_factory(toolbox.toolbar, True, False)
 
             stop_button = StopButton(self)
             stop_button.props.accelerator = '<Ctrl>q'
@@ -370,17 +300,18 @@ class VisualMatchActivity(activity.Activity):
             toolbox.show()
             toolbox.set_current_toolbar(1)
 
-        self.button_pattern = _button_factory('new-pattern-game',
-            _('New pattern game'), self._select_game_cb, games_toolbar,
-                                              'pattern')
-        self.button_number = _button_factory(
-            'new-number-game', _('New number game'), self._select_game_cb,
-            games_toolbar, 'number')
-        self.button_word = _button_factory('new-word-game', _('New word game'),
-            self._select_game_cb, games_toolbar, 'word')
-        self.button_custom = _button_factory('no-custom-game',
-            _('Import custom cards'), self._select_game_cb, games_toolbar,
-                                             'custom')
+        self.button_pattern = button_factory(
+            'new-pattern-game', games_toolbar, self._select_game_cb,
+            cb_arg='pattern', tooltip=_('New pattern game'))
+        self.button_number = button_factory(
+            'new-number-game', games_toolbar, self._select_game_cb,
+            cb_arg='number', tooltip=_('New number game'))
+        self.button_word = button_factory(
+            'new-word-game', games_toolbar, self._select_game_cb,
+            cb_arg='word', tooltip=_('New word game'))
+        self.button_custom = button_factory(
+            'no-custom-game', games_toolbar, self._select_game_cb, 
+            cb_arg='custom', tooltip=_('Import custom cards'))
 
         if new_sugar_system:
             self._set_extras(games_toolbar, games_toolbar=True)
@@ -388,161 +319,163 @@ class VisualMatchActivity(activity.Activity):
             self._set_labels(games_toolbar)
             self._set_extras(tools_toolbar, games_toolbar=False)
 
-        self.words_tool_button = _button_factory('word-tools',
-                                                 _('Edit word lists.'),
-                                                 self._edit_words_cb,
-                                                 tools_toolbar)
-        self.import_button = _button_factory('image-tools',
-            _('Import custom cards'), self.image_import_cb, tools_toolbar)
+        self.words_tool_button = button_factory(
+            'word-tools', tools_toolbar, self._edit_words_cb,
+            tooltip=_('Edit word lists.'))
+
+        self.import_button = button_factory(
+            'image-tools', tools_toolbar, self.image_import_cb,
+            tooltip=_('Import custom cards'))
 
-        self.product_button = _radio_button_factory(
-            name='product',
+        self.product_button = radio_factory(
+            'product',
+            numbers_toolbar,
+            self._number_card_O_cb,
+            cb_arg=PRODUCT,
             tooltip=_('product'),
-            cb=self._number_card_O_cb,
-            arg=PRODUCT,
-            toolbar=numbers_toolbar,
             group=None)
         NUMBER_O_BUTTONS[PRODUCT] = self.product_button
-        self.roman_button = _radio_button_factory(
-            name='roman',
+        self.roman_button = radio_factory(
+            'roman',
+            numbers_toolbar,
+            self._number_card_O_cb,
+            cb_arg=ROMAN,
             tooltip=_('Roman numerals'),
-            cb=self._number_card_O_cb,
-            arg=ROMAN,
-            toolbar=numbers_toolbar,
             group=self.product_button)
         NUMBER_O_BUTTONS[ROMAN] = self.roman_button
-        self.word_button = _radio_button_factory(
-            name='word',
+        self.word_button = radio_factory(
+            'word',
+            numbers_toolbar,
+            self._number_card_O_cb,
+            cb_arg=WORD,
             tooltip=_('word'),
-            cb=self._number_card_O_cb,
-            arg=WORD,
-            toolbar=numbers_toolbar,
             group=self.product_button)
         NUMBER_O_BUTTONS[WORD] = self.word_button
-        self.chinese_button = _radio_button_factory(
-            name='chinese',
+        self.chinese_button = radio_factory(
+            'chinese',
+            numbers_toolbar,
+            self._number_card_O_cb,
+            cb_arg=CHINESE,
             tooltip=_('Chinese'),
-            cb=self._number_card_O_cb,
-            arg=CHINESE,
-            toolbar=numbers_toolbar,
             group=self.product_button)
         NUMBER_O_BUTTONS[CHINESE] = self.chinese_button
-        self.mayan_button = _radio_button_factory(
-            name='mayan',
+        self.mayan_button = radio_factory(
+            'mayan',
+            numbers_toolbar,
+            self._number_card_O_cb,
+            cb_arg=MAYAN,
             tooltip=_('Mayan'),
-            cb=self._number_card_O_cb,
-            arg=MAYAN,
-            toolbar=numbers_toolbar,
             group=self.product_button)
         NUMBER_O_BUTTONS[MAYAN] = self.mayan_button
-        self.incan_button = _radio_button_factory(
-            name='incan',
+        self.incan_button = radio_factory(
+            'incan',
+            numbers_toolbar,
+            self._number_card_O_cb,
+            cb_arg=INCAN,
             tooltip=_('Quipu'),
-            cb=self._number_card_O_cb,
-            arg=INCAN,
-            toolbar=numbers_toolbar,
             group=self.product_button)
         NUMBER_O_BUTTONS[INCAN] = self.incan_button
 
-        _separator_factory(numbers_toolbar, True, False)
+        separator_factory(numbers_toolbar, False, True)
 
-        self.hash_button = _radio_button_factory(
-            name='hash',
+        self.hash_button = radio_factory(
+            'hash',
+            numbers_toolbar,
+            self._number_card_C_cb,
+            cb_arg=HASH,
             tooltip=_('hash marks'),
-            cb=self._number_card_C_cb,
-            arg=HASH,
-            toolbar=numbers_toolbar,
             group=None)
         NUMBER_C_BUTTONS[HASH] = self.hash_button
-        self.dots_button = _radio_button_factory(
-            name='dots',
+        self.dots_button = radio_factory(
+            'dots',
+            numbers_toolbar,
+            self._number_card_C_cb,
+            cb_arg=DOTS,
             tooltip=_('dots in a circle'),
-            cb=self._number_card_C_cb,
-            arg=DOTS,
-            toolbar=numbers_toolbar,
             group=self.hash_button)
         NUMBER_C_BUTTONS[DOTS] = self.dots_button
-        self.star_button = _radio_button_factory(
-            name='star',
+        self.star_button = radio_factory(
+            'star',
+            numbers_toolbar,
+            self._number_card_C_cb,
+            cb_arg=STAR,
             tooltip=_('points on a star'),
-            cb=self._number_card_C_cb,
-            arg=STAR,
-            toolbar=numbers_toolbar,
             group=self.hash_button)
         NUMBER_C_BUTTONS[STAR] = self.star_button
-        self.dice_button = _radio_button_factory(
-            name='dice',
+        self.dice_button = radio_factory(
+            'dice',
+            numbers_toolbar,
+            self._number_card_C_cb,
+            cb_arg=DICE,
             tooltip=_('dice'),
-            cb=self._number_card_C_cb,
-            arg=DICE,
-            toolbar=numbers_toolbar,
             group=self.hash_button)
         NUMBER_C_BUTTONS[DICE] = self.dice_button
-        self.lines_button = _radio_button_factory(
-            name='lines',
+        self.lines_button = radio_factory(
+            'lines',
+            numbers_toolbar,
+            self._number_card_C_cb,
+            cb_arg=LINES,
             tooltip=_('dots in a line'),
-            cb=self._number_card_C_cb,
-            arg=LINES,
-            toolbar=numbers_toolbar,
             group=self.hash_button)
         NUMBER_C_BUTTONS[LINES] = self.lines_button
 
     def _set_extras(self, toolbar, games_toolbar=True):
         if games_toolbar:
-            _separator_factory(toolbar, True, False)
-        self.robot_button = _button_factory("robot-off",
-                                            _('Play with the computer'),
-                                            self._robot_cb, toolbar)
-        self._robot_time_spin = _spin_factory(self._robot_time, 15, 180,
+            separator_factory(toolbar, False, True)
+        self.robot_button = button_factory(
+            'robot-off', toolbar, self._robot_cb,
+            tooltip=_('Play with the computer'))
+
+        self._robot_time_spin = spin_factory(self._robot_time, 15, 180,
                                               self._robot_time_spin_cb,
                                               toolbar)
-        _separator_factory(toolbar, True, False)
+        separator_factory(toolbar, False, True)
 
-        self.beginner_button = _radio_button_factory(
-            name='beginner',
+        self.beginner_button = radio_factory(
+            'beginner',
+            toolbar,
+            self._level_cb,
+            cb_arg=BEGINNER,
             tooltip=_('beginner'),
-            cb=self._level_cb,
-            arg=BEGINNER,
-            toolbar=toolbar,
             group=None)
         LEVEL_BUTTONS[BEGINNER] = self.beginner_button
-        self.intermediate_button = _radio_button_factory(
-            name='intermediate',
+        self.intermediate_button = radio_factory(
+            'intermediate',
+            toolbar,
+            self._level_cb,
+            cb_arg=INTERMEDIATE,
             tooltip=_('intermediate'),
-            cb=self._level_cb,
-            arg=INTERMEDIATE,
-            toolbar=toolbar,
             group=self.beginner_button)
         LEVEL_BUTTONS[INTERMEDIATE] = self.intermediate_button
-        self.expert_button = _radio_button_factory(
-            name='expert',
+        self.expert_button = radio_factory(
+            'expert',
+            toolbar,
+            self._level_cb,
+            cb_arg=EXPERT,
             tooltip=_('expert'),
-            cb=self._level_cb,
-            arg=EXPERT,
-            toolbar=toolbar,
             group=self.beginner_button)
         LEVEL_BUTTONS[EXPERT] = self.expert_button
 
-        self.level_label = _label_factory(self.calc_level_label(
-                self._low_score, self._play_level), toolbar)
+        self.level_label = label_factory(toolbar, self.calc_level_label(
+                self._low_score, self._play_level))
 
         if not games_toolbar:
-            _separator_factory(toolbar, True, False)
+            separator_factory(toolbar, False, True)
 
     def _set_labels(self, toolbar):
-        """ Add labels to toolbar toolbar """
-        self.status_label = _label_factory(_('Find a match.'), toolbar)
-        _separator_factory(toolbar, True, False)
-        self.deck_label = _label_factory("%d %s" % \
-                                             (LEVEL_DECKSIZE[self._play_level]\
-                                                  - DEAL, _('cards')), toolbar)
-        _separator_factory(toolbar, True, False)
-        self.match_label = _label_factory("%d %s" % (0, _('matches')), toolbar)
-        _separator_factory(toolbar, True, False)
-        self.clock_label = _label_factory("-", toolbar)
+        ''' Add labels to toolbar toolbar '''
+        self.status_label = label_factory(toolbar, _('Find a match.'))
+        separator_factory(toolbar, False, True)
+        self.deck_label = label_factory(
+            toolbar, '%d %s' % (LEVEL_DECKSIZE[self._play_level] - DEAL,
+                                _('cards')))
+        separator_factory(toolbar, False, True)
+        self.match_label = label_factory(toolbar, '%d %s' % (0, _('matches')))
+        separator_factory(toolbar, False, True)
+        self.clock_label = label_factory(toolbar, '-')
 
     def _setup_canvas(self, datapath):
-        """ Create a canvas.. """
+        ''' Create a canvas.. '''
         canvas = gtk.DrawingArea()
         canvas.set_size_request(gtk.gdk.screen_width(),
                                 gtk.gdk.screen_height())
@@ -579,8 +512,8 @@ class VisualMatchActivity(activity.Activity):
         return canvas
 
     def write_file(self, file_path):
-        """ Write data to the Journal. """
-        _logger.debug("Saving to: %s" % file_path)
+        ''' Write data to the Journal. '''
+        _logger.debug('Saving to: %s' % file_path)
         if hasattr(self, 'vmw'):
             self.metadata['play_level'] = self.vmw.level
             self.metadata['low_score_beginner'] = int(self.vmw.low_score[0])
@@ -610,10 +543,10 @@ class VisualMatchActivity(activity.Activity):
             f.write(self._dump())
             f.close()
         else:
-            _logger.debug("Deferring saving to %s" % file_path)
+            _logger.debug('Deferring saving to %s' % file_path)
 
     def _dump(self):
-        """ Dump game data to the journal."""
+        ''' Dump game data to the journal.'''
         data = []
         for i in self.vmw.grid.grid:
             if i is None or self.vmw.editing_word_list:
@@ -646,14 +579,14 @@ class VisualMatchActivity(activity.Activity):
             return io.getvalue()
 
     def read_file(self, file_path):
-        """ Read data from the Journal. """
-        _logger.debug("Resuming from: %s" % file_path)
+        ''' Read data from the Journal. '''
+        _logger.debug('Resuming from: %s' % file_path)
         f = open(file_path, 'r')
         self._load(f.read())
         f.close()
 
     def _load(self, data):
-        """ Load game data from the journal. """
+        ''' Load game data from the journal. '''
         if self._old_sugar_system:
             saved_state = json.read(data)
         else:
@@ -663,22 +596,22 @@ class VisualMatchActivity(activity.Activity):
             self._saved_state = saved_state
 
     def _setup_presence_service(self):
-        """ Setup the Presence Service. """
+        ''' Setup the Presence Service. '''
         self.pservice = presenceservice.get_instance()
         self.initiating = None  # sharing (True) or joining (False)
 
         owner = self.pservice.get_owner()
         self.owner = owner
         self.vmw.buddies.append(self.owner)
-        self._share = ""
+        self._share = ''
         self.connect('shared', self._shared_cb)
         self.connect('joined', self._joined_cb)
 
     def _shared_cb(self, activity):
-        """ Either set up initial share..."""
+        ''' Either set up initial share...'''
         if self._shared_activity is None:
-            _logger.error("Failed to share or join activity ... \
-                _shared_activity is null in _shared_cb()")
+            _logger.error('Failed to share or join activity ... \
+                _shared_activity is null in _shared_cb()')
             return
 
         self.initiating = True
@@ -697,10 +630,10 @@ class VisualMatchActivity(activity.Activity):
             SERVICE, {})
 
     def _joined_cb(self, activity):
-        """ ...or join an exisiting share. """
+        ''' ...or join an exisiting share. '''
         if self._shared_activity is None:
-            _logger.error("Failed to share or join activity ... \
-                _shared_activity is null in _shared_cb()")
+            _logger.error('Failed to share or join activity ... \
+                _shared_activity is null in _shared_cb()')
             return
 
         self.initiating = False
@@ -721,16 +654,16 @@ class VisualMatchActivity(activity.Activity):
         self.waiting_for_deck = True
 
     def _list_tubes_reply_cb(self, tubes):
-        """ Reply to a list request. """
+        ''' Reply to a list request. '''
         for tube_info in tubes:
             self._new_tube_cb(*tube_info)
 
     def _list_tubes_error_cb(self, e):
-        """ Log errors. """
+        ''' Log errors. '''
         _logger.error('ListTubes() failed: %s', e)
 
     def _new_tube_cb(self, id, initiator, type, service, params, state):
-        """ Create a new tube. """
+        ''' Create a new tube. '''
         _logger.debug('New tube: ID=%d initator=%d type=%d service=%s '
                      'params=%r state=%d', id, initiator, type, service,
                      params, state)
@@ -748,66 +681,66 @@ class VisualMatchActivity(activity.Activity):
                 self.event_received_cb)
 
             if self.waiting_for_deck:
-                self._send_event("j")
+                self._send_event('j')
 
     def event_received_cb(self, text):
-        """ Data is passed as tuples: cmd:text """
+        ''' Data is passed as tuples: cmd:text '''
         if text[0] == 'B':
             e, card_index = text.split(':')
-            _logger.debug("receiving card index: " + card_index)
+            _logger.debug('receiving card index: ' + card_index)
             self.vmw._process_selection(
                 self.vmw.deck.index_to_card(int(card_index)).spr)
         elif text[0] == 'S':
             e, card_index = text.split(':')
-            _logger.debug("receiving selection index: " + card_index)
+            _logger.debug('receiving selection index: ' + card_index)
             self.vmw._process_selection(
                 self.vmw.selected[int(card_index)].spr)
         elif text[0] == 'j':
-            if self.initiating:  # Only the sharer "shares".
-                _logger.debug("serialize the project and send to joiner")
-                self._send_event("P:" + str(self.vmw.level))
-                self._send_event("X:" + str(self.vmw.deck.index))
-                self._send_event("M:" + str(self.vmw.matches))
-                self._send_event("C:" + self.vmw.card_type)
-                self._send_event("D:" + str(self._dump()))
+            if self.initiating:  # Only the sharer 'shares'.
+                _logger.debug('serialize the project and send to joiner')
+                self._send_event('P:' + str(self.vmw.level))
+                self._send_event('X:' + str(self.vmw.deck.index))
+                self._send_event('M:' + str(self.vmw.matches))
+                self._send_event('C:' + self.vmw.card_type)
+                self._send_event('D:' + str(self._dump()))
         elif text[0] == 'J':  # Force a request for current state.
-            self._send_event("j")
+            self._send_event('j')
             self.waiting_for_deck = True
         elif text[0] == 'C':
             e, text = text.split(':')
-            _logger.debug("receiving card_type from sharer " + text)
+            _logger.debug('receiving card_type from sharer ' + text)
             self.vmw.card_type = text
         elif text[0] == 'P':
             e, text = text.split(':')
-            _logger.debug("receiving play level from sharer " + text)
+            _logger.debug('receiving play level from sharer ' + text)
             self.vmw.level = int(text)
             self.level_label.set_text(self.calc_level_label(
                 self.vmw.low_score, self.vmw.level))
             self.level_button.set_icon(LEVEL_ICONS[self.vmw.level])
         elif text[0] == 'X':
             e, text = text.split(':')
-            _logger.debug("receiving deck index from sharer " + text)
+            _logger.debug('receiving deck index from sharer ' + text)
             self.vmw.deck.index = int(text)
         elif text[0] == 'M':
             e, text = text.split(':')
-            _logger.debug("receiving matches from sharer " + text)
+            _logger.debug('receiving matches from sharer ' + text)
             self.vmw.matches = int(text)
         elif text[0] == 'D':
             if self.waiting_for_deck:
                 e, text = text.split(':')
-                _logger.debug("receiving deck data from sharer")
+                _logger.debug('receiving deck data from sharer')
                 self._load(text)
                 self.waiting_for_deck = False
             self.vmw.new_game(self._saved_state, self.vmw.deck.index)
 
     def _send_event(self, entry):
-        """ Send event through the tube. """
+        ''' Send event through the tube. '''
         if hasattr(self, 'chattube') and self.chattube is not None:
             self.chattube.SendText(entry)
 
 
 class ChatTube(ExportedGObject):
-    """ Class for setting up tube for sharing """
+    ''' Class for setting up tube for sharing '''
     def __init__(self, tube, is_initiator, stack_received_cb):
         super(ChatTube, self).__init__(tube, PATH)
         self.tube = tube
diff --git a/toolbar_utils.py b/toolbar_utils.py
new file mode 100644
index 0000000..94e6883
--- /dev/null
+++ b/toolbar_utils.py
@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2011, Walter Bender
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# You should have received a copy of the GNU General Public License
+# along with this library; if not, write to the Free Software
+# Foundation, 51 Franklin Street, Suite 500 Boston, MA 02110-1335 USA
+
+
+import gtk
+
+from sugar.graphics.radiotoolbutton import RadioToolButton
+from sugar.graphics.toolbutton import ToolButton
+from sugar.graphics.combobox import ComboBox
+from sugar.graphics.toolcombobox import ToolComboBox
+
+
+def combo_factory(combo_array, toolbar, callback, cb_arg=None,
+                  tooltip=None, default=None):
+    '''Factory for making a toolbar combo box'''
+    combo = ComboBox()
+    if tooltip is not None and hasattr(combo, 'set_tooltip_text'):
+        combo.set_tooltip_text(tooltip)
+    if cb_arg is not None:
+        combo.connect('changed', callback, cb_arg)
+    else:
+        combo.connect('changed', callback)
+    for i, selection in enumerate(combo_array):
+        combo.append_item(i, selection, None)
+    combo.show()
+    toolitem = gtk.ToolItem()
+    toolitem.add(combo)
+    if hasattr(toolbar, 'insert'):  # the main toolbar
+        toolbar.insert(toolitem, -1)
+    else:  # or a secondary toolbar
+        toolbar.props.page.insert(toolitem, -1)
+    toolitem.show()
+    if default is not None:
+        combo.set_active(combo_array.index(default))
+    return combo
+
+
+def entry_factory(default_string, toolbar, tooltip=None, max=3):
+    ''' Factory for adding a text box to a toolbar '''
+    entry = gtk.Entry()
+    entry.set_text(default_string)
+    if tooltip is not None and hasattr(entry, 'set_tooltip_text'):
+        entry.set_tooltip_text(tooltip)
+    entry.set_width_chars(max)
+    entry.show()
+    toolitem = gtk.ToolItem()
+    toolitem.add(entry)
+    if hasattr(toolbar, 'insert'):  # the main toolbar
+        toolbar.insert(toolitem, -1)
+    else:  # or a secondary toolbar
+        toolbar.props.page.insert(toolitem, -1)
+    toolitem.show()
+    return entry
+
+
+def button_factory(icon_name, toolbar, callback, cb_arg=None, tooltip=None,
+                   accelerator=None):
+    '''Factory for making tooplbar buttons'''
+    button = ToolButton(icon_name)
+    if tooltip is not None:
+        button.set_tooltip(tooltip)
+    button.props.sensitive = True
+    if accelerator is not None:
+        button.props.accelerator = accelerator
+    if cb_arg is not None:
+        button.connect('clicked', callback, cb_arg)
+    else:
+        button.connect('clicked', callback)
+    if hasattr(toolbar, 'insert'):  # the main toolbar
+        toolbar.insert(button, -1)
+    else:  # or a secondary toolbar
+        toolbar.props.page.insert(button, -1)
+    button.show()
+    return button
+
+
+def radio_factory(name, toolbar, callback, cb_arg=None, tooltip=None,
+                  group=None):
+    ''' Add a radio button to a toolbar '''
+    button = RadioToolButton(group=group)
+    button.set_named_icon(name)
+    if callback is not None:
+        if cb_arg is None:
+            button.connect('clicked', callback)
+        else:
+            button.connect('clicked', callback, cb_arg)
+    if hasattr(toolbar, 'insert'):  # Add button to the main toolbar...
+        toolbar.insert(button, -1)
+    else:  # ...or a secondary toolbar.
+        toolbar.props.page.insert(button, -1)
+    button.show()
+    if tooltip is not None:
+        button.set_tooltip(tooltip)
+    return button
+
+
+def label_factory(toolbar, label_text, width=None):
+    ''' Factory for adding a label to a toolbar '''
+    label = gtk.Label(label_text)
+    label.set_line_wrap(True)
+    if width is not None:
+        label.set_size_request(width, -1)  # doesn't work on XOs
+    label.show()
+    toolitem = gtk.ToolItem()
+    toolitem.add(label)
+    if hasattr(toolbar, 'insert'):  # the main toolbar
+        toolbar.insert(toolitem, -1)
+    else:  # or a secondary toolbar
+        toolbar.props.page.insert(toolitem, -1)
+    toolitem.show()
+    return label
+
+
+def separator_factory(toolbar, expand=False, visible=True):
+    ''' add a separator to a toolbar '''
+    separator = gtk.SeparatorToolItem()
+    separator.props.draw = visible
+    separator.set_expand(expand)
+    if hasattr(toolbar, 'insert'):  # the main toolbar
+        toolbar.insert(separator, -1)
+    else:  # or a secondary toolbar
+        toolbar.props.page.insert(separator, -1)
+    separator.show()
+
+
+def image_factory(image, toolbar, tooltip=None):
+    ''' Add an image to the toolbar '''
+    img = gtk.Image()
+    img.set_from_pixbuf(image)
+    img_tool = gtk.ToolItem()
+    img_tool.add(img)
+    if tooltip is not None:
+        img.set_tooltip_text(tooltip)
+    if hasattr(toolbar, 'insert'):  # the main toolbar
+        toolbar.insert(img_tool, -1)
+    else:  # or a secondary toolbar
+        toolbar.props.page.insert(img_tool, -1)
+    img_tool.show()
+    return img
+
+
+def spin_factory(default, min, max, callback, toolbar):
+    spin_adj = gtk.Adjustment(default, min, max, 1, 32, 0)
+    spin = gtk.SpinButton(spin_adj, 0, 0)
+    spin_id = spin.connect('value-changed', callback)
+    spin.set_numeric(True)
+    spin.show()
+    toolitem = gtk.ToolItem()
+    toolitem.add(spin)
+    if hasattr(toolbar, 'insert'):  # the main toolbar
+        toolbar.insert(toolitem, -1)
+    else:
+        toolbar.props.page.insert(toolitem, -1)
+    toolitem.show()
+    return spin