path: root/atoidepoc/ui/screens.py

# python import
import logging, os, threading, time
from gettext import gettext as _

# gtk import
import gobject, gtk

# sugar import
from sugar.activity import activity
from sugar.graphics import style

# atoidepoc import
from atoidepoc.tools import image, sound, storage

# get application logger
logger = logging.getLogger('atoidepoc')


class ScreenBrowser(gtk.HBox):

    def __init__(self, toolbar, title=None, _type=None):
        # init parent
        gtk.HBox.__init__(self)
        # keep toolbar
        self.toolbar = toolbar
        # keep name
        self._type = _type
        # add viewer
        self._add_viewer()
        self._add_list(title)
        # do show
        self._show()

    def _add_viewer(self):
        # init preview
        self._preview_frame = gtk.Frame()
        self._preview_frame.set_shadow_type(gtk.SHADOW_NONE)
        self._preview_frame.set_size_request(400, -1)
        self._preview_frame.show()
        # add it
        self.pack_start(self._preview_frame, expand=True, fill=True)

    def _get_store(self):
        # model: preview - description - activity_id - timestamp
        _store = gtk.ListStore(
                gtk.gdk.Pixbuf,
                gobject.TYPE_STRING,
                gobject.TYPE_PYOBJECT,
                gobject.TYPE_PYOBJECT
                )
        # app to get the journal entries
        _app_name = 'paint' if self._type=='graphic' else 'record'
        # update store
        for _i in storage.list_info_from_journal(_app_name):
            # prepare preview
            _p = storage.get_pixbuf_from_data(_i['preview'], size=(64, 48))
            # do update
            _store.append([_p, _i['title'], _i['activity_id'], _i['timestamp']])
        # return it
        return _store

    def _add_list(self, title):
        # prepare colums
        _col_preview = gtk.TreeViewColumn(title)
        _col_description = gtk.TreeViewColumn()
        # set renderers
        _cell_pix = gtk.CellRendererPixbuf()
        _col_preview.pack_start(_cell_pix)
        _col_preview.add_attribute(_cell_pix, 'pixbuf', 0)
        # ..
        _cell_text = gtk.CellRendererText()
        _col_description.pack_start(_cell_text, True)
        _col_description.add_attribute(_cell_text, 'text', 1)
        # init treeview
        self._list_treeview = gtk.TreeView(self._get_store())
        self._list_treeview.set_reorderable(False)
        # add columns
        self._list_treeview.append_column(_col_preview)
        self._list_treeview.append_column(_col_description)
        # show it
        self._list_treeview.show()
        # add it
        self.pack_start(self._list_treeview)

    def _show(self):
        # show all
        self.show()
        # update toolbar
        self.toolbar.activity.set_canvas(self)


class ScreenBrowserGraphics(ScreenBrowser):

    def __init__(self, toolbar):
        # init parent
        ScreenBrowser.__init__(self, toolbar, title=_('Graphics'),
                _type='graphic')


class ScreenBrowserSounds(ScreenBrowser):

    def __init__(self, toolbar):
        # init parent
        ScreenBrowser.__init__(self, toolbar, title=_('Sounds'),
                _type='sound')

PROMENEUR_KEYS = [(20, 12), (40, 12), (60, 12), (80, 12), (100, 12), (80, 12),
                  (100, 12), (120, 12), (100, 12), (80, 12), (60, 12), (80, 12),
                  (100, 12), (120, 12), (140, 12), (160, 12), (120, 12), (200, 12),
                  (120, 12), (200, 12), (220, 12), (220, 12), (220, 12), (220, 12)]

CHIEN_KEYS = [(80, 54), (100, 32), (80, 54), (100, 32), (120, 54), (140, 32),
              (140, 54), (160, 32), (200, 54), (200, 32), (220, 54), (240, 32),
              (260, 54), (240, 32), (220, 54), (200, 32), (180, 54), (160, 32),
              (200, 54), (200, 32), (220, 54), (240, 32), (160, 54), (280, 32)]

MAISONS_KEYS = [(0, 0), (0, 2), (2, 4), (0, 2), (2, 0), (2, 2),
             (0, 4), (0, 6), (-2, 8), (0, 6), (-2, 4), (0, 2),
             (0, 2), (2, 2), (0, 0), (-2, 2), (0, 4), (2, 6),
             (0, 8), (0, 6), (0, 4), (-2, 2), (-2, 2), (0, 0)]

CIEL_KEYS = [(0, -9) for _i in range(24)]

BOTTOM_KEYS = [(0, 16) for _i in range(24)]

DEFAULT_KEYS = [(0, 0) for _i in range(24)]

ALL_KEYS = {
        'CIEL': CIEL_KEYS,
        'MAISONS': MAISONS_KEYS,
        'ROUTE': DEFAULT_KEYS,
        'PROMENEUR': PROMENEUR_KEYS,
        'CHIEN': CHIEN_KEYS,
        'OVERLAY': DEFAULT_KEYS,
        'mask_default': DEFAULT_KEYS,
        }

NAMES = [
        'CIEL',
        'MAISONS',
        'ROUTE',
        'PROMENEUR',
        'CHIEN',
        'OVERLAY',
        'mask_default',
        ]


class ThreadMove(threading.Thread):

    def __init__(self, fixed, filename):
        # init parent
        threading.Thread.__init__(self)
        # ...
        self._fixed = fixed
        self._filename = filename

    def run(self):
        for _align in ALL_KEYS[self._filename]:
            # ...
            self._fixed._move_image(self._filename, align=_align)
            # ...
            time.sleep(1)


class ScreenStory(gtk.Fixed):

    def __init__(self, toolbar):
        # init parent
        gtk.Fixed.__init__(self)
        # keep toolbar
        self.toolbar = toolbar
        # init image dict
        self.__graphics = dict()
        self.__sizes = dict()
        self.__positions = dict()
        # keep some info
        self._screen_height = gtk.gdk.screen_height()
        self._screen_width = gtk.gdk.screen_width()
        # render
        self._render()
        # and show
        self._show()
        # do anim
        for _n in NAMES:
            self._anim(_n)

    def _anim(self, filename):
        # init thread
        _t = ThreadMove(self, filename)
        # start it
        _t.start()

    def _render(self):
        # png check
        self._add_image('CIEL', align=(0, -10))
        self._add_image('MAISONS', align=(0, 0))
        self._add_image('ROUTE', align=(0, 16))
        self._add_image('PROMENEUR', align=(0, 16))
        self._add_image('CHIEN', align=(0, 16))
        self._add_image('OVERLAY', align=(0, 0))
        # add border
        self._add_image('mask_default', align=(0, 0))

    def _get_image_path(self, filename):
        return os.path.join(activity.get_bundle_path(),
                'static', 'graphics', '%s.png' % filename)

    def _update_x_y(self, width, height, x, y):
        # update x
        x = ((gtk.gdk.screen_width() - width) / 2) + x
        # update y
        y = ((gtk.gdk.screen_height() - height -  + 88) / 2) + y
        # return it
        return x, y

    def _move_image(self, filename, align=None):
        # get graphic from dict
        _image = self.__graphics[filename]
        # set alignment
        if align is None:
            # use current position by default
            _x , _y = self.__positions[filename]
        else:
            # parse align value
            _x, _y = align
        # get image size
        _w, _h = self.__sizes[filename]
        # update x, y
        _x, _y = self._update_x_y(_w, _h, _x, _y)
        self.__positions[filename] = (_x, _y)
        # move
        self.move(_image, _x, _y)

    def _add_image(self, filename, align=None, size=None):
        # get graphics path
        _path = self._get_image_path(filename)
        # add a picture here
        _image = gtk.Image()
        # set size
        if size is None:
            # set file
            _image.set_from_file(_path)
            # get file size
            _c, _w, _h = image.get_image_info(_path)
        else:
            # parse size value
            _w, _h = size
            # get pixbuff
            _pixbuf = gtk.gdk.pixbuf_new_from_file(_path)
            # do resize and set image
            _image.set_from_pixbuf(
                    _pixbuf.scale_simple(_w, _h, gtk.gdk.INTERP_BILINEAR))
        # set alignment
        if align is None:
            _x = 0
            _y = 0
        else:
            # parse align value
            _x, _y = align
        # TODO manage cb for click or dnd
        # ...
        # show
        _image.show()
        # update graphic dict
        self.__graphics[filename] = _image
        self.__sizes[filename] = (_w, _h)
        # update x, y
        _x, _y = self._update_x_y(_w, _h, _x, _y)
        self.__positions[filename] = (_x, _y)
        # add
        self.put(_image, _x, _y)

    def _show(self):
        # show self
        self.show()

        # DEBUG
        logger.debug('[screen_story] _show - width: %s' % gtk.gdk.screen_width())
        # DEBUG

        # update toolbar
        self.toolbar.activity.set_canvas(self)


class ScreenPlayer(gtk.Fixed):

    def __init__(self, toolbar):
        # init parent
        gtk.Fixed.__init__(self)
        # keep toolbar
        self.toolbar = toolbar
        # render
        self.render()
        # and show
        self._show()

    def render(self):
        pass

    def _show(self):
        # show self
        self.show()
        # update toolbar
        self.toolbar.activity.set_canvas(self)


class ScreenPlayerGraphics(ScreenPlayer):

    def __init__(self, toolbar):
        # init parent
        ScreenPlayer.__init__(self, toolbar)


class ScreenPlayerSounds(ScreenPlayer):

    def __init__(self, toolbar):
        # init parent
        ScreenPlayer.__init__(self, toolbar)

    def render(self):
        # init 2 players
        _s_player_1 = sound.Player(soundfile='/home/sugar/shared/demo1.ogg')
        _s_player_2 = sound.Player(soundfile='/home/sugar/shared/demo2.ogg')
        # get duration
        _d1 = _s_player_1.get_duration()

        # DEBUG
        logger.debug('[player_sound] render - _d1: %s' % _d1)
        # DEBUG

        _d2 = _s_player_2.get_duration()

        # DEBUG
        logger.debug('[player_sound] render - _d2: %s' % _d2)
        # DEBUG

        # play together
        _s_player_1.play()
        _s_player_2.play()