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 = [(1.95, 2.2), (3.9, 2.2), (5.86, 2.2), (7.8, 2.2), (9.77, 2.2),
        (7.8, 2.2), (9.77, 2.2), (11.72, 2.2), (9.77, 2.2), (7.8, 2.2),
        (5.86, 2.2), (7.8, 2.2), (9.77, 2.2), (11.72, 2.2), (13.67, 2.2),
        (15.625, 2.2), (17.56, 2.2), (19.53, 2.2), (19.53, 2.2), (19.53, 2.2),
        (21.48, 2.2), (21.48, 2.2), (19.53, 2.2), (17.56, 2.2)]

CHIEN_KEYS = [(7.8, 12.3), (9.77, 10.125), (7.8, 12.3), (9.77, 10.125), (11.72, 12.3),
        (13.67, 10.125), (13.67, 12.3), (15.625, 10.125), (19.53, 12.3), (19.53, 10.125),
        (21.48, 12.3), (23.44, 10.125), (25.4, 12.3), (23.44, 10.125), (21.48, 12.3),
        (19.53, 10.125), (17.56, 12.3), (15.625, 10.125), (19.53, 12.3), (19.53, 10.125),
        (21.48, 12.3), (23.44, 10.125), (25.4, 12.3), (27.34, 10.125)]

MAISONS_KEYS = [(0, 0), (0, 0.2), (0.2, 0.4), (0, 0.2), (0.2, 0),
        (0.2, 0.2),  (0, 0.4), (0, 0.6), (-0.2, 0.8), (0, 0.6),
        (-0.2, 0.4), (0, 0.2), (0, 0.2), (0.2, 0.2), (0, 0),
        (-0.2, 0.2), (0, 0.4), (0.2, 0.6), (0, 0.8), (0, 0.6),
        (0, 0.4), (-0.2, 0.2), (-0.2, 0.2), (0, 0)]

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

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

OVERLAY_KEYS = [(-0.4*_i, 0) 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': OVERLAY_KEYS,
        'mask_default': DEFAULT_KEYS,
        }

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

NUMBER_OF_KEYS = 24

class ThreadAnim(threading.Thread):

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

    def run(self):
        # first pass
        for _i in range(NUMBER_OF_KEYS):
            # first refresh
            self._fixed.refresh(_i)
            # ...
            time.sleep(0.5)
        # second pass
        for _i in range(NUMBER_OF_KEYS):
            # first refresh
            self._fixed.refresh()
            # for each images
            for _n in NAMES:
                # do move
                self._fixed._move_image(_n, align=ALL_KEYS[_n][-_i-1])
            # disable changed flag
            self._fixed._fullscreen_changed = False
            # ...
            time.sleep(0.5)
        # ...
        for _i in range(60):
            # first refresh
            self._fixed.refresh(frame=None)
            # ...
            time.sleep(1)


def _set_fixed_bg(fixed):
    # do it
    fixed.set_has_window(True)
    fixed.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0, 0, 0))
    # conveniant return
    return fixed


class ScreenStory(gtk.Fixed):

    def __init__(self, toolbar):
        # init parent
        gtk.Fixed.__init__(self)
        # keep toolbar
        self.toolbar = toolbar
        # set has window for bg color issue
        _set_fixed_bg(self)
        # create dummy
        self.__dummy = _set_fixed_bg(gtk.Fixed())
        # init image dicts
        self.__graphics = dict()
        self.__sizes = dict()
        self.__positions = dict()
        # init fullscreen flag
        self.fullscreen = False
        self._fullscreen_changed = False
        # do refresh first
        self._screen_height = gtk.gdk.screen_height()
        self._screen_width = gtk.gdk.screen_width()
        # render
        self._render()
        #
        self.refresh(0)
        # and show
        self._show()
        # do anim
        ThreadAnim(self).start()

    def _hide_all(self):
        # show dummy
        self.__dummy.show()
        # update toolbar
        self.toolbar.activity.set_canvas(self.__dummy)
        # hide us
        self.hide()

    def _show_all(self):
        # show us
        self._show()
        # hide dummy
        self.__dummy.hide()

    def set_fullscreen(self, fullscreen):
        # update fullscreen flag
        self.fullscreen = fullscreen
        # has changed
        self._fullscreen_changed = True
        # hide all
        self._hide_all()

    def refresh(self, frame=None):
        # keep some info
        self._screen_height = gtk.gdk.screen_height()
        self._screen_width = gtk.gdk.screen_width()
        # for each images
        for _n in NAMES:
            _align = None if frame is None else ALL_KEYS[_n][frame]
            # do move
            self._move_image(_n, align=_align)
        # show
        if self._fullscreen_changed is True:
            # disable changed flag
            self._fullscreen_changed = False
            # show all
            self._show_all()
        else:
            pass

    def _render(self):
        for _n in NAMES:
            # add image
            self._add_image(_n, align=ALL_KEYS[_n][0])

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

    def _update_w_h(self, filename):
        # get image size
        _w, _h = self.__sizes[filename]
        # ..
        if self._fullscreen_changed is True:
            if self.fullscreen is True:
                _new_w = _w * self._screen_width / 1024
                _new_h = _h * _new_w / _w
            else:
                # get graphics path
                _path = self._get_image_path(filename)
                # get file size
                _c, _new_w, _new_h = image.get_image_info(_path)
            # update size
            self.__sizes[filename] = _new_w, _new_h
            # return new values
            return _new_w, _new_h
        else:
            # return current values
            return _w, _h

    def _update_x_y(self, width, height, x, y):
        # 
        if self.fullscreen is True:
            _scene_with = self._screen_width
            _scene_height = 468 * _scene_with / 1024.0
        else:
            _scene_with = 1024
            _scene_height = 468
        # update x
        _x = ((self._screen_width - width) / 2)
        _x += int(x * _scene_with / 100.0)
        # update y
        _y = ((self._screen_height - height -  + 88) / 2)
        _y += int(y * _scene_height / 100.0)
        # return it
        return _x, _y

    def _move_image(self, filename, align=None):
        # get/update width and height
        _w, _h = self._update_w_h(filename)
        # set alignment
        if align is None:
            # use current position by default
            _x , _y = self.__positions[filename]
        else:
            # parse align value
            _x, _y = align
            # update positions
            self.__positions[filename] = align
        # get graphic from dict
        _image = self.__graphics[filename]
        # redraw all or move only
        if self._fullscreen_changed is True:
            # remove previous image
            _image.destroy()
            # create new image
            self._add_image(filename, align=(_x, _y), size=(_w, _h))
        else:
            # update x, y
            _x, _y = self._update_x_y(_w, _h, _x, _y)
            # do 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
        # init positions
        self.__positions[filename] = (_x, _y)
        # 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)
        # add
        self.put(_image, _x, _y)

    def _show(self):
        # show self
        self.show()
        # 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()