# Copyright (C) 2006, 2007, 2008 One Laptop Per Child # Copyright (C) 2009 Simon Schampijer, Aleksey Lim # Copyright (C) 2013 Sugar Labs # # 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 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # # activate threads for gst needs import gobject gobject.threads_init() import locale locale.setlocale(locale.LC_NUMERIC, 'C') import logging _logger = logging.getLogger('memorize-activity') from gettext import gettext as _ import os import zipfile import gtk import telepathy import telepathy.client from sugar.activity.widgets import ActivityToolbarButton from sugar.activity.widgets import StopButton from sugar.graphics.toolbarbox import ToolbarBox from sugar.graphics.toggletoolbutton import ToggleToolButton from sugar.graphics import style from sugar.activity.activity import Activity from sugar.presence import presenceservice from sugar.presence.tubeconn import TubeConnection from sugar import profile import cardtable import scoreboard import game import messenger import memorizetoolbar import createtoolbar import cardlist import createcardpanel import face SERVICE = 'org.laptop.Memorize' IFACE = SERVICE PATH = '/org/laptop/Memorize' _MODE_PLAY = 1 _MODE_CREATE = 2 # These strings are added only to enable the translators # to translate the words needed in the stable version # We can remove them when the version with the new UI is available # to all the users. changed_strings = [_('Play'), _('Create'), _('Game name:'), _('Equal pairs'), _('addition'), _('letters'), _('sounds')] class MemorizeActivity(Activity): def __init__(self, handle): Activity.__init__(self, handle) self.play_mode = None self._calculate_sizes() toolbar_box = ToolbarBox() self.set_toolbar_box(toolbar_box) self.activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(self.activity_button, -1) self._memorizeToolbarBuilder = \ memorizetoolbar.MemorizeToolbarBuilder(self) toolbar_box.toolbar.insert(gtk.SeparatorToolItem(), -1) self._edit_button = ToggleToolButton('view-source') self._edit_button.set_tooltip(_('Edit game')) self._edit_button.set_active(False) toolbar_box.toolbar.insert(self._edit_button, -1) self._createToolbarBuilder = \ createtoolbar.CreateToolbarBuilder(self) separator = gtk.SeparatorToolItem() separator.set_expand(True) separator.set_draw(False) separator.set_size_request(0, -1) toolbar_box.toolbar.insert(separator, -1) toolbar_box.toolbar.insert(StopButton(self), -1) self.portrait_mode = gtk.gdk.screen_width() < gtk.gdk.screen_height() # Play game mode self.table = cardtable.CardTable() self.scoreboard = scoreboard.Scoreboard() self.cardlist = cardlist.CardList() self.createcardpanel = createcardpanel.CreateCardPanel(self) self.cardlist.connect('pair-selected', self.createcardpanel.pair_selected) self.cardlist.connect('update-create-toolbar', self._createToolbarBuilder.update_create_toolbar) self.createcardpanel.connect('add-pair', self.cardlist.add_pair) self.createcardpanel.connect('update-pair', self.cardlist.update_selected) self.createcardpanel.connect('change-font', self.cardlist.change_font) self._createToolbarBuilder.connect('create_new_game', self.cardlist.clean_list) self._createToolbarBuilder.connect('create_new_game', self.createcardpanel.clean) self._createToolbarBuilder.connect('create_new_game', self._memorizeToolbarBuilder.reset) self._createToolbarBuilder.connect('create_equal_pairs', self.change_equal_pairs) self.game = game.MemorizeGame() self._edit_button.connect('toggled', self._change_mode_bt) self.table.connect('key-press-event', self.table.key_press_event) self.table.connect('card-flipped', self.game.card_flipped) self.table.connect('card-overflipped', self.game.card_overflipped) self.table.connect('card-highlighted', self.game.card_highlighted) self.game.connect('set-border', self.table.set_border) self.game.connect('flop-card', self.table.flop_card) self.game.connect('flip-card', self.table.flip_card) self.game.connect('cement-card', self.table.cement_card) self.game.connect('highlight-card', self.table.highlight_card) self.game.connect('load_mode', self.table.load_msg) self.game.connect('msg_buddy', self.scoreboard.set_buddy_message) self.game.connect('add_buddy', self.scoreboard.add_buddy) self.game.connect('rem_buddy', self.scoreboard.rem_buddy) self.game.connect('increase-score', self.scoreboard.increase_score) self.game.connect('wait_mode_buddy', self.scoreboard.set_wait_mode) self.game.connect('change-turn', self.scoreboard.set_selected) self.game.connect('change_game', self.scoreboard.change_game) self.game.connect('reset_scoreboard', self.scoreboard.reset) self.game.connect('reset_table', self.table.reset) self.game.connect('load_game', self.table.load_game) self.game.connect('change_game', self.table.change_game) self.game.connect('load_game', self._memorizeToolbarBuilder.update_toolbar) self.game.connect('change_game', self._memorizeToolbarBuilder.update_toolbar) self.game.connect('change_game', self.createcardpanel.update_font_combos) self._memorizeToolbarBuilder.connect('game_changed', self.change_game) self.vbox = gtk.VBox(False) self.sbox = gtk.VBox() self.hbox = gtk.HBox(False) self.set_canvas(self.hbox) # connect to the in/out events of the memorize activity self.connect('focus_in_event', self._focus_in) self.connect('focus_out_event', self._focus_out) self.connect('destroy', self._cleanup_cb) self.add_events(gtk.gdk.POINTER_MOTION_MASK) self.connect('motion_notify_event', lambda widget, event: face.look_at()) gtk.gdk.screen_get_default().connect('size-changed', self.__configure_cb) # start on the game toolbar, might change this # to the create toolbar later self._change_mode(_MODE_PLAY) # Get the Presence Service self.pservice = presenceservice.get_instance() self.initiating = None # Buddy object for you owner = self.pservice.get_owner() self.owner = owner self.current = 0 self.game.set_myself(self.owner) self.connect('shared', self._shared_cb) # Owner.props.key if self._shared_activity: # We are joining the activity self.connect('joined', self._joined_cb) if self.get_shared(): # We've already joined self._joined_cb(self) elif not self._jobject.file_path: _logger.debug('buddy joined - __init__: %s', self.owner.props.nick) game_file = os.path.join(os.path.dirname(__file__), 'demos', 'addition.zip') self.game.load_game(game_file, 4, 'demo') _logger.debug('loading conventional') self.game.add_buddy(self.owner) else: self.game.add_buddy(self.owner) self.show_all() def _calculate_sizes(self): width = gtk.gdk.screen_width() height = gtk.gdk.screen_height() if width < height: self.table_size = (width, width) self.score_size = (width, height - width - style.GRID_CELL_SIZE) else: self.table_size = (height - style.GRID_CELL_SIZE, height - style.GRID_CELL_SIZE) self.score_size = (width - self.table_size[0], height - style.GRID_CELL_SIZE) def __configure_cb(self, event): ''' Screen size has changed ''' width = gtk.gdk.screen_width() height = gtk.gdk.screen_height() - style.GRID_CELL_SIZE self.hbox.set_size_request(width, height) self._calculate_sizes() self.vbox.set_size_request(self.table_size[0], height) self.sbox.set_size_request(self.score_size[0], self.score_size[1]) self.sbox.show() if width < height: if self.play_mode == _MODE_PLAY and not self.portrait_mode: self.table.resize(self.table_size[0]) self.hbox.remove(self.sbox) self.vbox.pack_end(self.sbox) self.portrait_mode = True else: if self.play_mode == _MODE_PLAY and self.portrait_mode: self.table.resize(self.table_size[0]) self.vbox.remove(self.sbox) self.hbox.pack_start(self.sbox) self.portrait_mode = False self.vbox.show() self.hbox.show() self.show_all() if self.play_mode != _MODE_PLAY: self.createcardpanel.resize() def _change_mode_bt(self, button): if button.get_active(): self._change_mode(_MODE_CREATE) button.set_named_icon('player_play') button.set_tooltip(_('Play game')) else: self._change_mode(_MODE_PLAY) button.set_named_icon('view-source') button.set_tooltip(_('Edit game')) def read_file(self, file_path): if 'icon-color' in self.metadata: color = self.metadata['icon-color'] else: color = profile.get_color().to_string() self.change_game(None, file_path, 4, 'file', self.metadata['title'], color) def write_file(self, file_path): logging.debug('WRITE_FILE is_demo %s', self.game.model.is_demo) if self.game.model.is_demo: # if is a demo game only want keep the metadata self._jobject.set_file_path(None) raise NotImplementedError return if self.cardlist.pair_list_modified: self.cardlist.update_model(self.game.model) temp_img_folder = os.path.join(self.game.model.temp_folder, 'images') temp_snd_folder = os.path.join(self.game.model.temp_folder, 'sounds') self.game.model.create_temp_directories() game_zip = zipfile.ZipFile(file_path, 'w') equal_pairs = self.game.model.data['equal_pairs'] == '1' for pair in self.game.model.pairs: # aimg aimg = self.game.model.pairs[pair].get_property('aimg') if aimg != None: if equal_pairs: aimgfile = 'img' + str(pair) + '.jpg' else: aimgfile = 'aimg' + str(pair) + '.jpg' game_zip.write(os.path.join(temp_img_folder, aimgfile), os.path.join('images', aimgfile)) # bimg bimg = self.game.model.pairs[pair].get_property('bimg') if bimg != None: if equal_pairs: bimgfile = 'img' + str(pair) + '.jpg' else: bimgfile = 'bimg' + str(pair) + '.jpg' game_zip.write(os.path.join(temp_img_folder, bimgfile), os.path.join('images', bimgfile)) # asnd asnd = self.game.model.pairs[pair].get_property('asnd') if asnd != None: game_zip.write(os.path.join(temp_snd_folder, asnd), os.path.join('sounds', asnd)) # bsnd bsnd = self.game.model.pairs[pair].get_property('bsnd') if bsnd != None: game_zip.write(os.path.join(temp_snd_folder, bsnd), os.path.join('sounds', bsnd)) self.game.model.game_path = self.game.model.temp_folder self.game.model.data['name'] = str(self.get_title()) self.game.model.write() game_zip.write(os.path.join(self.game.model.temp_folder, 'game.xml'), 'game.xml') game_zip.close() self.metadata['mime_type'] = 'application/x-memorize-project' def _complete_close(self): self._remove_temp_files() Activity._complete_close(self) def _remove_temp_files(self): tmp_root = os.path.join(os.environ['SUGAR_ACTIVITY_ROOT'], 'instance') for root, dirs, files in os.walk(tmp_root, topdown=False): for name in files: os.remove(os.path.join(root, name)) for name in dirs: os.rmdir(os.path.join(root, name)) def _change_mode(self, mode): logging.debug("Change mode %s" % mode) if mode == _MODE_CREATE: if self.play_mode == True: if not self.portrait_mode: self.hbox.remove(self.sbox) self.hbox.remove(self.vbox) self.hbox.pack_start(self.createcardpanel, False) self.hbox.pack_start(self.cardlist) self.cardlist.load_game(self.game) self.game.model.create_temp_directories() self.createcardpanel.set_temp_folder( self.game.model.temp_folder) self.play_mode = False else: if self.game.model.modified: self.cardlist.update_model(self.game.model) self.save() self.game.reset_game() self.table.change_game(None, self.game.model.data, self.game.model.grid) self.game.model.modified = False if self.play_mode == False: self.hbox.remove(self.createcardpanel) self.hbox.remove(self.cardlist) # Two configurations: # (1) In landscape mode, sbox and table (vbox) will go into hbox # (2) In portrait mode, sbox goes into vbox below table if self.play_mode in (False, None): self._calculate_sizes() if self.play_mode is not None: self.sbox.remove(self.scoreboard) self.vbox.remove(self.table) self.sbox.set_size_request(self.score_size[0], self.score_size[1]) self.sbox.pack_start(self.scoreboard) height = gtk.gdk.screen_height() - style.GRID_CELL_SIZE self.vbox.set_size_request(self.table_size[0], height) self.vbox.pack_start(self.table) if self.portrait_mode: self.hbox.remove(self.vbox) self.vbox.pack_end(self.sbox) self.hbox.pack_end(self.vbox) else: self.hbox.remove(self.vbox) self.hbox.pack_end(self.vbox) self.hbox.pack_start(self.sbox) self.play_mode = True self._memorizeToolbarBuilder.update_controls(mode == _MODE_PLAY) self._createToolbarBuilder.update_controls(mode == _MODE_CREATE) def change_game(self, widget, game_name, size, mode, title=None, color=None): _logger.debug('Change game %s', game_name) self.game.change_game(widget, game_name, size, mode, title, color) self.cardlist.game_loaded = False def change_equal_pairs(self, widget, state): self.cardlist.update_model(self.game.model) self.createcardpanel.change_equal_pairs(widget, state) def _shared_cb(self, activity): _logger.debug('My activity was shared') self.initiating = True self._sharing_setup() _logger.debug('This is my activity: making a tube...') id_ = self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].OfferDBusTube( SERVICE, {}) def _sharing_setup(self): if self._shared_activity is None: _logger.error('Failed to share or join activity') return self.conn = self._shared_activity.telepathy_conn self.tubes_chan = self._shared_activity.telepathy_tubes_chan self.text_chan = self._shared_activity.telepathy_text_chan self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].connect_to_signal( \ 'NewTube', self._new_tube_cb) self._shared_activity.connect('buddy-joined', self._buddy_joined_cb) self._shared_activity.connect('buddy-left', self._buddy_left_cb) def _list_tubes_reply_cb(self, tubes): for tube_info in tubes: self._new_tube_cb(*tube_info) def _list_tubes_error_cb(self, e): _logger.error('ListTubes() failed: %s', e) def _joined_cb(self, activity): if not self._shared_activity: return _logger.debug('Joined an existing shared activity') for buddy in self._shared_activity.get_joined_buddies(): if buddy != self.owner: _logger.debug("buddy joined - _joined_cb: %s " "(get buddies and add them to my list)", buddy.props.nick) self.game.add_buddy(buddy) self.game.add_buddy(self.owner) self.initiating = False self._sharing_setup() _logger.debug('This is not my activity: waiting for a tube...') self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].ListTubes( reply_handler=self._list_tubes_reply_cb, error_handler=self._list_tubes_error_cb) def _new_tube_cb(self, identifier, initiator, tube_type, service, params, state): _logger.debug('New tube: ID=%d initator=%d type=%d service=%s ' 'params=%r state=%d', identifier, initiator, tube_type, service, params, state) if (tube_type == telepathy.TUBE_TYPE_DBUS and service == SERVICE): if state == telepathy.TUBE_STATE_LOCAL_PENDING: self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube( \ identifier) self.tube_conn = TubeConnection(self.conn, self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES], identifier, group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP]) self.messenger = messenger.Messenger(self.tube_conn, self.initiating, self._get_buddy, self.game) self.game.connect('flip-card-signal', self.messenger.flip_sender) self.game.connect('change_game_signal', self.messenger.change_game) def _get_buddy(self, cs_handle): """Get a Buddy from a channel specific handle.""" group = self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP] my_csh = group.GetSelfHandle() if my_csh == cs_handle: handle = self.conn.GetSelfHandle() else: handle = group.GetHandleOwners([cs_handle])[0] assert handle != 0 return self.pservice.get_buddy_by_telepathy_handle( \ self.tp_conn_name, self.tp_conn_path, handle) def _buddy_joined_cb(self, activity, buddy): if buddy != self.owner: if buddy.props.nick == '': _logger.debug("buddy joined: empty nick=%s. Will not add.", buddy.props.nick) else: _logger.debug("buddy joined: %s", buddy.props.nick) self.game.add_buddy(buddy) def _buddy_left_cb(self, activity, buddy): if buddy.props.nick == '': _logger.debug("buddy joined: empty nick=%s. Will not remove", buddy.props.nick) else: _logger.debug("buddy left: %s", buddy.props.nick) self.game.rem_buddy(buddy) def _focus_in(self, event, data=None): self.game.audio.play() def _focus_out(self, event, data=None): self.game.audio.pause() def _cleanup_cb(self, data=None): self.game.audio.stop()