first version of the all-in-one edit UI skeleton -> features need to be re-implemented one by ony now!

21 files changed, 2048 insertions, 4363 deletions

diff --git a/activity.py b/activity.py
index e0099bf..65942f8 100644
--- a/activity.py
+++ b/activity.py
@@ -79,11 +79,6 @@ class ThreadAnim(threading.Thread):
                 _current_screen.refresh()
             else:
                 pass
-            # update timeline
-            if hasattr(_current_screen, 'timeline'):
-                _current_screen.timeline.refresh()
-            else:
-                pass
             # update panel
             if hasattr(_current_screen, 'panel'):
                 _current_screen.panel.refresh()
@@ -141,7 +136,7 @@ class AToiDeJouerActivity(activity.Activity):
         # init parent
         activity.Activity.__init__(self, handle)
         # init activity working folder
-        storage.init_activity_folder()
+        storage.init_activity_files()
         # ..
         self.max_participants = 1
         # get toolbox
@@ -176,6 +171,7 @@ class AToiDeJouerActivity(activity.Activity):
     def get_toolbox(self):
         return self._toolbox
 
+    """
     def update_number_of_keys(self):
         # set max
         _graphic_max = self.graphic_keys.get_max_frame()
@@ -183,6 +179,7 @@ class AToiDeJouerActivity(activity.Activity):
         _max = _graphic_max if _graphic_max > _sound_max else _sound_max
         # update value
         self._number_of_keys = _max + 1
+    """
 
     def get_current_screen(self):
         # little check
@@ -259,11 +256,7 @@ class AToiDeJouerActivity(activity.Activity):
                 toolbar.pause()
                 # update all
                 self._thread.set_time()
-            if self._current == 'edit':
-                # .. refresh
-                self._screens[self._current].timeline.refresh_sequence()
-                self._screens[self._current].timeline.refresh_adjustment()
-            elif self._current == 'help':
+            if self._current == 'help':
                 del self._screens[self._current]
                 self._screens[self._current] = screens.ScreenHelp(self)
             else:
@@ -280,12 +273,6 @@ class AToiDeJouerActivity(activity.Activity):
         # screen factory
         elif self._current == 'edit':
             _scr = screens.ScreenEdit(toolbar)
-            # .. init sequences
-            for _n in self.graphic_keys._names:
-                _scr.timeline.add_sequence(_n)
-            # .. refresh
-            _scr.timeline.refresh_sequence()
-            _scr.timeline.refresh_adjustment()
         elif self._current == 'story':
             _scr = screens.ScreenStory(toolbar, set_canvas=True)
         elif self._current == 'help':
@@ -299,8 +286,7 @@ class AToiDeJouerActivity(activity.Activity):
         self._update_slider(toolbar)
 
     def read_file(self, file_path):
-        """Read saved data from datastore and resume activity based on a
-        previous state.
+        pass
         """
         # init content
         _data = None
@@ -311,18 +297,19 @@ class AToiDeJouerActivity(activity.Activity):
         finally:
             _file.close()
         # parse json data
-        self.graphic_keys.loads(_data)
-        self.sound_keys.loads(_data)
+        # self.graphic_keys.loads(_data)
+        # self.sound_keys.loads(_data)
         # set activity new number of keys
-        self.update_number_of_keys()
+        # self.update_number_of_keys()
         # clear
-        self.graphic_keys.ask_clear()
+        # self.graphic_keys.ask_clear()
         # switch to edit mode if no key
         self._toolbox.set_current_toolbar(1)
         self._change_screen(toolbar=self.__story_toolbar)
+        """
 
     def write_file(self, file_path):
-        """Dummy overiding ...
+        pass
         """
         # content dict
         _data_dict = {
@@ -339,6 +326,7 @@ class AToiDeJouerActivity(activity.Activity):
             _f.write(_data)
         finally:
             _f.close()
+        """
 
     def close(self, skip_save=False):
         # stop the thread
@@ -351,5 +339,4 @@ class AToiDeJouerActivity(activity.Activity):
             pass
         else:
             _screen.item_preview._thread.kill()
-        # ..
         activity.Activity.close(self, skip_save=True)
diff --git a/atoidejouer/db/story.py b/atoidejouer/db/story.py
index ed7c40b..a0392c7 100644
--- a/atoidejouer/db/story.py
+++ b/atoidejouer/db/story.py
@@ -150,6 +150,12 @@ class DB(object):
                 yield obj
             cur.close()
 
+        def get_layout_max(self):
+            return 10
+
+        def get_duration_max(self):
+            return 10
+
         def update(self, obj):
             cur = self.con.cursor()
             cur.execute(obj.update())
diff --git a/atoidejouer/story/__init__.py b/atoidejouer/story/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/atoidejouer/story/__init__.py
+++ /dev/null
diff --git a/atoidejouer/story/keys.py b/atoidejouer/story/keys.py
deleted file mode 100644
index 2f41e10..0000000
--- a/atoidejouer/story/keys.py
+++ /dev/null
@@ -1,692 +0,0 @@
-
-# python import
-import json, logging, os
-# ..
-from functools import partial
-from gettext import gettext as _
-
-# gtk import
-import gobject, gtk, glib
-
-# sugar import
-from sugar.activity import activity
-
-# atoidejouer import
-from atoidejouer.tools import image, sound, storage, ui
-
-# get application logger
-logger = logging.getLogger('atoidejouer')
-
-
-class StoryKeys(object):
-
-    def __init__(self, type_, activity_):
-        # keep type
-        self._type = type_
-        # ..
-        self._activity = activity_
-        # ..
-        self.clear()
-
-    def clear(self):
-        # ..
-        self._names = list()
-        self.__codes = {
-                'graphics': dict(),
-                'sounds': dict(),
-                'story': dict(),
-                }
-        self.__clear = {
-                'graphics': False,
-                'sounds': False,
-                'story': False,
-                }
-        #
-        self._keys = dict()
-
-    def loads(self, data, clear=True):
-        # parse json data
-        _data_dict = json.loads(data)
-        # ..
-        if self._type == 'graphics':
-            # ..
-            _tmp_names = _data_dict['graphic_names']
-            _tmp_keys = _data_dict['graphic_keys']
-        # ..
-        elif self._type == 'sounds':
-            # ..
-            _tmp_names = _data_dict['sound_names']
-            _tmp_keys = _data_dict['sound_keys']
-        # ??
-        else:
-            return
-        # reset keys
-        if clear is True:
-            self.clear()
-        else:
-            pass
-        # set names
-        _exist_list = list()
-        for _n in _tmp_names:
-            if _n in self._names:
-                _exist_list.append(_n)
-            else:
-                self._names.append(_n)
-        # ensure keys
-        for _seq_name, _seq_dict in _tmp_keys.items():
-            # get seq_path for check
-            _seq_path = storage.get_sequence_path(self._type, _seq_name)
-            # little check
-            if _seq_name in self._keys:
-                continue
-            # check path
-            elif os.path.exists(_seq_path):
-                # init seq dict copy
-                _tmp_seq_dict = dict()
-                # work on seq dict copy
-                for _frame_name, _frame_dict in _seq_dict.items():
-                    # seq dict copy update
-                    _tmp_seq_dict[float(_frame_name)] = _frame_dict
-                # update main dict
-                self._keys[_seq_name] = _tmp_seq_dict
-            # sequence does not exist
-            else:
-                if _seq_name in self._names:
-                    self._names.remove(_seq_name)
-                else:
-                    pass
-        # ..
-        return _exist_list
-
-    def add_sequence(self, sequence_name, filenames):
-        # TODO ensure valid name
-        if sequence_name in self._names:
-            return False
-        else:
-            # add name to the registry
-            self._names.append(sequence_name)
-            # init seq dict
-            _seq_dict = dict()
-            # update dict
-            for _i, _f in enumerate(filenames):
-                _seq_dict[_f] = {
-                        '__align': [0, 0],
-                        '__duration': 0,
-                        '__loop': False,
-                        '__file_type': None,
-                        '__key_type': None
-                        }
-            # udpate main dict
-            self._keys[sequence_name] = {
-                    0: _seq_dict
-                    }
-            # ok
-            return True
-
-    def remove_sequence(self, sequence_name):
-        # little check
-        if sequence_name in self._names:
-            self._names.remove(sequence_name)
-            del self._keys[sequence_name]
-        # ??
-        else:
-            pass
-
-    def ask_clear(self):
-        # ...
-        self.__clear = {
-                'graphics': True,
-                'sounds': True,
-                'story': True,
-                }
-
-    def get_clear(self, screen):
-        return self.__clear[screen]
-
-    def set_clear(self, screen, flag):
-        self.__clear[screen] = flag
-
-    def set_layout(self, sequence_name, layout):
-        # little check
-        if sequence_name in self._names:
-            _current = self._names.index(sequence_name)
-            # little check
-            if _current == layout:
-                # do nothing
-                pass
-            else:
-                # ...
-                self._names.remove(sequence_name)
-                # ...
-                self._names.insert(layout, sequence_name)
-        # nothing to do
-        else:
-            pass
-
-    def get_layout(self, sequence_name):
-        if sequence_name in self._names:
-            return self._names.index(sequence_name)
-        else:
-            return -1
-
-    def get_max_layout(self):
-        return len(self._names) - 1
-
-    def set_code(self, screen, sequence_name, filename, _code):
-        # ..
-        if sequence_name in self.__codes[screen]:
-            pass
-        else:
-            self.__codes[screen][sequence_name] = dict()
-        # ..
-        self.__codes[screen][sequence_name][filename] = _code
-
-    def get_code(self, screen, sequence_name, filename):
-        # ..
-        if sequence_name in self.__codes[screen]:
-            # ..
-            if filename in self.__codes[screen][sequence_name]:
-                return self.__codes[screen][sequence_name][filename]
-            # ??
-            else:
-                return None
-        # ??
-        else:
-            return None
-
-    def get_sequence_codes(self, screen, sequence_name):
-        # ..
-        if sequence_name in self.__codes[screen]:
-            return self.__codes[screen][sequence_name]
-        else:
-            return dict()
-
-    def get_names(self, mask=False):
-        # .. add mask
-        if mask is True:
-            yield 'background_default'
-        else:
-            pass
-        for _n in self._names:
-            yield _n
-        # .. add mask
-        if mask is True:
-            yield 'mask_default'
-        else:
-            pass
-
-    def get_frame_dict(self, sequence_name, frame):
-        # little check
-        if sequence_name in self._names:
-            # ..
-            _seq_dict = self._keys[sequence_name]
-            # little check
-            if frame in _seq_dict:
-                # get frame dict
-                return _seq_dict[frame]
-            else:
-                return None
-        else:
-            return None
-
-    def set_frame(self, sequence_name, previous_frame, new_frame):
-        # little check
-        if sequence_name in self._names:
-            # ..
-            _seq_dict = self._keys[sequence_name]
-            # little check
-            if previous_frame in _seq_dict:
-                # set frame dict from previous
-                _seq_dict[new_frame] = _seq_dict[previous_frame]
-                # clear main dict
-                del _seq_dict[previous_frame]
-            else:
-                pass
-        else:
-            pass
-
-    def get_max_frame(self):
-        # ...
-        _tmp_set = set()
-        # ...
-        for _seq_dict in self._keys.values():
-            # udpate set
-            _tmp_set = _tmp_set.union(_seq_dict.keys())
-        # order list
-        _tmp_list = list(_tmp_set)
-        _tmp_list.sort()
-        # return max
-        if len(_tmp_list) == 0:
-            return 0
-        else:
-            return _tmp_list[-1]
-
-    def set_filename_dict(self, sequence_name, frame, filename, dict_=None):
-        # ensure default dict
-        if dict_ is None:
-            dict_ = {
-                    '__align': [0, 0],
-                    '__duration': 0,
-                    '__loop': False,
-                    '__file_type': None,
-                    '__key_type': None
-                    }
-        else:
-            pass
-        # ensure frame dict
-        _frame_dict = self.get_frame_dict(sequence_name, frame)
-        if _frame_dict is None:
-            self._keys[sequence_name][frame] = dict()
-        else:
-            pass
-        # update the main dict
-        self._keys[sequence_name][frame][filename] = dict_
-
-    def get_filename_dict(self, sequence_name, frame, filename):
-        # little check
-        if sequence_name in self._names:
-            # ..
-            _seq_dict = self._keys[sequence_name]
-            # little check
-            if frame in _seq_dict:
-                # get frame dict
-                _frame_dict = _seq_dict[frame]
-                # little check
-                if filename in _frame_dict:
-                    # return filename dict
-                    return _frame_dict[filename]
-                else:
-                    return None
-            else:
-                return None
-        else:
-            return None
-
-    def remove_filename(self, sequence_name, frame, filename):
-        # .. get the dict
-        _f_dict = self.get_filename_dict(sequence_name, frame, filename)
-        # little check
-        if _f_dict is None:
-            return
-        # do remove
-        else:
-            del self._keys[sequence_name][frame][filename]
-
-    def remove_filename_from_all(self, sequence_name, filename):
-        # little check
-        if sequence_name in self._names:
-            for _frame in range(self.get_max_frame()):
-                self.remove_filename(sequence_name, _frame, filename)
-        # ..
-        else:
-            pass
-
-    def set_align(self, sequence_name, frame, filename, align):
-        # .. get the dict
-        _f_dict = self.get_filename_dict(sequence_name, frame, filename)
-        # little check
-        if _f_dict is None:
-            return
-        else:
-            self._keys[sequence_name][frame][filename]['__align'] = align
-
-    def get_previous_align(self, sequence_name, frame):
-        # prepare inversed range
-        _range = range(frame)
-        _range.reverse()
-        # try one by one
-        for _f in _range:
-            # get frame dict            
-            _frame_dict = self.get_frame_dict(sequence_name, _f)
-            # get frame values
-            _frame_values = [] if _frame_dict is None else _frame_dict.values()
-            # find first valid key
-            for _f_dict in _frame_values:
-                # little check
-                if _f_dict['__key_type'] != 'key':
-                    continue
-                elif '__align' in _f_dict:
-                    return _f_dict['__align']
-                else:
-                    return [0, 0]
-        # default
-        return [0, 0]
-
-    def get_align(self, sequence_name, frame, filename):
-        # .. get the dict
-        _f_dict = self.get_filename_dict(sequence_name, frame, filename)
-        # little check
-        if _f_dict is None:
-            return [0, 0]
-        else:
-            # ensure default
-            if '__align' in _f_dict:
-                return _f_dict['__align']
-            else:
-                # set default
-                _f_dict['__align'] = [0, 0]
-                # return default
-                return [0, 0]
-
-    def get_next_align(self, sequence_name, frame, filename,
-            use_transition=False):
-        # prepare inversed range
-        _range = range(frame + 1, self.get_max_frame() + 1)
-        # try one by one
-        for _f in _range:
-            # get frame dict            
-            _frame_dict = self.get_frame_dict(sequence_name, _f)
-            # get frame values
-            _frame_values = [] if _frame_dict is None else _frame_dict.values()
-            if _frame_dict is None:
-                continue
-            else:
-                # find first valid key
-                for _f_name, _f_dict in _frame_dict.items():
-                    # little check
-                    if use_transition is False\
-                    and _f_dict['__key_type'] != 'key':
-                        continue
-                    elif '__align' in _f_dict\
-                    and _f_dict['__key_type'] in ['key', 'transition']:
-                        # works on the same file only
-                        if _f_name == filename:
-                            return _f_dict['__align']
-                        else:
-                            return None, None
-                    else:
-                        continue
-        # default
-        return None, None
-
-    def inc_position(self, sequence_name, frame, filename, move, value):
-        # get align first
-        _x, _y = self.get_align(sequence_name, frame, filename)
-        # inc
-        if move == 'x':
-            _x += value
-        elif move == 'y':
-            _y += value
-        else:
-            # ??
-            return
-        # update
-        self.set_align(sequence_name, frame, filename, (_x, _y))
-        # return current pos
-        return _x, _y
-
-    def set_duration(self, sequence_name, frame, filename, duration):
-        # .. get the dict
-        _f_dict = self.get_filename_dict(sequence_name, frame, filename)
-        # little check
-        if _f_dict is None:
-            return
-        else:
-            self._keys[sequence_name][frame][filename]['__duration'] = duration
-
-    def get_duration(self, sequence_name, frame, filename):
-        # .. get the dict
-        _f_dict = self.get_filename_dict(sequence_name, frame, filename)
-        # little check
-        if _f_dict is None:
-            return 0
-        else:
-            # ensure default
-            if '__duration' in _f_dict:
-                return _f_dict['__duration']
-            else:
-                # set default
-                _f_dict['__duration'] = 0
-                # return default
-                return 0
-
-    def inc_duration(self, sequence_name, frame, filename, value):
-        # get duration first
-        _d = self.get_duration(sequence_name, frame, filename)
-        # inc
-        _d += value
-        # TODO max is max_ or next key
-        # get max frame
-        _max_frame = self._activity._number_of_keys - frame
-        # ensure value
-        if _d < 0:
-            _d = 0
-        elif _d >= _max_frame:
-            _d = _max_frame - 1
-        else:
-            pass
-        # update
-        self.set_duration(sequence_name, frame, filename, _d)
-        # return current pos
-        return _d
-
-    def set_loop(self, sequence_name, frame, filename, loop):
-        # .. get the dict
-        _f_dict = self.get_filename_dict(sequence_name, frame, filename)
-        # little check
-        if _f_dict is None:
-            return
-        else:
-            self._keys[sequence_name][frame][filename]['__loop'] = loop
-
-    def get_loop(self, sequence_name, frame, filename):
-        # .. get the dict
-        _f_dict = self.get_filename_dict(sequence_name, frame, filename)
-        # little check
-        if _f_dict is None:
-            return False
-        # ensure default
-        else:
-            if '__loop' in _f_dict:
-                return _f_dict['__loop']
-            else:
-                # set default
-                _f_dict['__loop'] = False
-                # return default
-                return False
-
-    def set_current(self, sequence_name, frame, filename, file_type='lib',
-            key_type='key'):
-        """
-        file_type lib or jnl
-        key_type key or transition
-        """
-        # get the dict
-        _filename_dict = self.get_filename_dict(sequence_name, frame, filename)
-        # ensure filename dict
-        if _filename_dict is None:
-            self.set_filename_dict(sequence_name, frame, filename)
-        else:
-            pass
-        # get the dict
-        _frame_dict = self.get_frame_dict(sequence_name, frame)
-        # little check
-        if _frame_dict is None:
-            pass
-        else:
-            # set current
-            for _f, _d in _frame_dict.items():
-                # key type or none
-                _ft = key_type if _f == filename else None
-                # update
-                self._keys[sequence_name][frame][_f]['__file_type'] = _ft
-                # key type or none
-                _kt = key_type if _f == filename else None
-                # update
-                self._keys[sequence_name][frame][_f]['__key_type'] = _kt
-
-    def get_current(self, sequence_name, frame):
-        # get the dict
-        _f_dict = self.get_frame_dict(sequence_name, frame)
-        # little check
-        if _f_dict is None:
-            return None, None, None
-        else:
-            for _f, _d in _f_dict.items():
-                if _d['__key_type'] is None:
-                    continue
-                else:
-                    return _f, _d['__file_type'], _d['__key_type']
-        # default              
-        return None, None, None
-
-    def _refresh_graphic_keys(self, sequence_name):
-        # little check
-        if sequence_name in self._keys:
-            # next dict for transition check
-            _next_list = list()
-            _range = list()
-            _filenames = list()
-            # update next dict
-            for _frame, _filename_dict in self._keys[sequence_name].items():
-                for _filename, _dict in _filename_dict.items():
-                    if _filename is None or _dict['__key_type'] != 'key':
-                        # invalidate previous
-                        self._keys[sequence_name][_frame][_filename] = {
-                                '__align': [0, 0],
-                                '__duration': 0,
-                                '__loop': False,
-                                '__file_type': None,
-                                '__key_type': None
-                                }
-                    else:
-                        # small update for transition management
-                        _tr_frame = (_frame + 1) if len(_range) == 0 else _frame
-                        # update current range
-                        _range.append(_tr_frame)
-                        _filenames.append((_filename, _dict['__file_type']))
-                        # ..
-                        if len(_range) == 2:
-                            _next_list.append((_range, _filenames))
-                            _range = list()
-                            _filenames = list()
-                        else:
-                            continue
-            # set transition
-            for _range, _filenames in _next_list:
-                # get first align
-                _first_filename, _first_filetype = _filenames[0]
-                _first_x, _first_y = self.get_align(sequence_name, _range[0]-1,
-                        _first_filename)
-                # get last align
-                _last_filename, _last_filetype = _filenames[1]
-                _last_x, _last_y = self.get_align(sequence_name, _range[1],
-                        _last_filename)
-                # compute steps
-                _inc_x = float(_last_x - _first_x)
-                _inc_x /= (_range[1] - _range[0] + 1)
-                _inc_y = float(_last_y - _first_y)
-                _inc_y /= (_range[1] - _range[0] + 1)
-                # init new position values
-                _new_x = _first_x
-                _new_y = _first_y
-                for _i in range(*_range):
-                    # compute filename and file type
-                    if _i < ((_range[1] - _range[0]) / 2):
-                        _f = _first_filename
-                        _t = _first_filetype
-                    else:
-                        #_f = _last_filename
-                        #_t = _last_filetype
-                        _f = _first_filename
-                        _t = _first_filename
-                    # set transition
-                    self.set_current(sequence_name, _i, _f, file_type=_t,
-                            key_type='transition')
-                    # compute align
-                    _new_x += _inc_x
-                    _new_y += _inc_y
-                    # update align
-                    self.set_align(sequence_name, _i, _f, (_new_x, _new_y))
-        else:
-            pass
-
-    def _refresh_sound_keys(self, sequence_name):
-        # shortcut
-        _max = self._activity._number_of_keys
-        # little check
-        if sequence_name in self._keys:
-            # next dict for transition check
-            _durations = list()
-            _loops = list()
-            # update next dict
-            for _frame, _filename_dict in self._keys[sequence_name].items():
-                for _filename, _dict in _filename_dict.items():
-                    if _filename is None or _dict['__key_type'] != 'key':
-                        # invalidate previous
-                        self._keys[sequence_name][_frame][_filename] = {
-                                '__align': [0, 0],
-                                '__duration': 0,
-                                '__loop': False,
-                                '__file_type': None,
-                                '__key_type': None
-                                }
-                    else:
-                        if _dict['__loop'] is True:
-                            _loops.append((_frame, _filename, _dict['__file_type']))
-                        elif _dict['__duration'] != None:
-                            _durations.append((_frame, _filename,
-                                _dict['__file_type'], _dict['__duration']))
-                        else:
-                            continue
-            # set transition for loop keys
-            for _frame, _f, _f_type in _loops:
-                # little check
-                _t_start = _frame + 1
-                # ..
-                if _t_start >= _max:
-                    continue
-                else:
-                    pass
-                # ..
-                for _i in range(_t_start, _max+1):
-                    # set transition
-                    self.set_current(sequence_name, _i, _f,
-                            file_type=_f_type, key_type='transition')
-            # set transition for loop keys
-            for _frame, _f, _f_type, _d in _durations:
-                # little check
-                _t_start = _frame + 1
-                _t_end = _t_start + _d
-                # ..
-                if _t_start >= _max:
-                    continue
-                elif _t_end > _max:
-                    _t_end = _max+1
-                else:
-                    pass
-                # ..
-                if _t_start > _t_end:
-                    continue
-                else:
-                    pass
-                # ..
-                for _i in range(_t_start, _t_end):
-                    _f_dict = self.get_filename_dict(sequence_name, _i, _f)
-                    # update
-                    _kt = None if _f_dict is None else _f_dict['__key_type']
-                    # ..
-                    if _kt is None:
-                        # set transition
-                        self.set_current(sequence_name, _i, _f,
-                                file_type=_f_type, key_type='transition')
-
-    def check_sequences(self):
-        # sequence check
-        _s_to_remove = list()
-        for _s_name in self._names:
-            _path = storage.get_sequence_path(self._type, _s_name)
-            if os.path.exists(_path):
-                continue
-            else:
-                _s_to_remove.append(_s_name)
-        # ..
-        for _s_name in _s_to_remove:
-            self.remove_sequence(_s_name)
-
-    def refresh(self, sequence_name):
-        # ..
-        if self._type == 'graphics':
-            self._refresh_graphic_keys(sequence_name)
-        else:
-            self._refresh_sound_keys(sequence_name)
diff --git a/atoidejouer/tools/image.py b/atoidejouer/tools/image.py
index c3c9288..f5ff573 100644
--- a/atoidejouer/tools/image.py
+++ b/atoidejouer/tools/image.py
@@ -42,7 +42,6 @@ def get_pixbuf(file_path, max_width, max_height, use_max=False):
 
 
 def get_sequence_first_graphic(type_, sequence_name, size=None):
-    # ..
     _filename = storage.get_sequence_first_graphic_name(type_, sequence_name)
     if _filename is None:
         _path = storage.get_image_path('blank', dir_='data')
@@ -57,7 +56,6 @@ def get_sequence_first_graphic(type_, sequence_name, size=None):
         size = (64, 48)
     else:
         pass
-    # ..
     return get_pixbuf(_path, *size)
 
 
@@ -65,6 +63,8 @@ def compute_width_height(width, height, max_width, max_height, use_max=False):
     # compute ratio
     _ratio_scr = max_width / float(max_height)
     _ratio_img = width / float(height)
+    # DEBUG
+    logger.debug('[tools.image] compute_width_height - r_src/r_img: %s/%s' % (_ratio_scr, _ratio_img))
     # ..
     if width > max_width\
     or height > max_height:
@@ -77,7 +77,9 @@ def compute_width_height(width, height, max_width, max_height, use_max=False):
         else:
             width = max_width
             height = max_height
-        # ..
+        # DEBUG
+        logger.debug('[tools.image] compute_width_height - w/h: %s/%s' % (width, height))
+        logger.debug('[tools.image] compute_width_height - max_w/max_h: %s/%s' % (max_width, max_height))
         return width, height
     # ..
     elif use_max is True:
@@ -87,7 +89,7 @@ def compute_width_height(width, height, max_width, max_height, use_max=False):
         return width, height
 
 
-def get_image_info(path):
+def get_image_info(path=None, data=None):
     """Tricky method found on Internet that returns the image info from a given
     raw image data.
     """
@@ -96,51 +98,50 @@ def get_image_info(path):
     # already exist
     if _info is not None:
         return _info
-    elif os.path.exists(path):
+    elif data is not None:
         pass
+    elif os.path.exists(path):
+        # read file
+        _f = open(path)
+        data = _f.read()
+        _f.close()
     else:
         return None, 0, 0
-
-    # read file
-    _f = open(path)
-    _data = _f.read()
-    _f.close()
     #
-    size = len(_data)
+    size = len(data)
     height = 0
     width = 0
     content_type = None
-
     # handle GIFs
-    if (size >= 10) and _data[:6] in ('GIF87a', 'GIF89a'):
+    if (size >= 10) and data[:6] in ('GIF87a', 'GIF89a'):
         # Check to see if content_type is correct
         content_type = 'image/gif'
-        w, h = struct.unpack("<HH", _data[6:10])
+        w, h = struct.unpack("<HH", data[6:10])
         width = int(w)
         height = int(h)
 
     # See PNG 2. Edition spec (http://www.w3.org/TR/PNG/)
     # Bytes 0-7 are below, 4-byte chunk length, then 'IHDR'
     # and finally the 4-byte width, height
-    elif ((size >= 24) and _data.startswith('\211PNG\r\n\032\n')
-          and (_data[12:16] == 'IHDR')):
+    elif ((size >= 24) and data.startswith('\211PNG\r\n\032\n')
+          and (data[12:16] == 'IHDR')):
         content_type = 'image/png'
-        w, h = struct.unpack(">LL", _data[16:24])
+        w, h = struct.unpack(">LL", data[16:24])
         width = int(w)
         height = int(h)
 
     # Maybe this is for an older PNG version.
-    elif (size >= 16) and _data.startswith('\211PNG\r\n\032\n'):
+    elif (size >= 16) and data.startswith('\211PNG\r\n\032\n'):
         # Check to see if we have the right content type
         content_type = 'image/png'
-        w, h = struct.unpack(">LL", _data[8:16])
+        w, h = struct.unpack(">LL", data[8:16])
         width = int(w)
         height = int(h)
 
     # handle JPEGs
-    elif (size >= 2) and _data.startswith('\377\330'):
+    elif (size >= 2) and data.startswith('\377\330'):
         content_type = 'image/jpeg'
-        jpeg = StringIO.StringIO(_data)
+        jpeg = StringIO.StringIO(data)
         jpeg.read(2)
         b = jpeg.read(1)
         try:
diff --git a/atoidejouer/tools/storage.py b/atoidejouer/tools/storage.py
index 6db569e..2dad46b 100644
--- a/atoidejouer/tools/storage.py
+++ b/atoidejouer/tools/storage.py
@@ -4,15 +4,22 @@ import dbus, logging, os, shutil, tarfile, time
 # ..
 from gettext import gettext as _
 
-# gtk import
-import gtk
-
 # png import from pypng
 from lib import png
 
 # sugar import
-from sugar.activity import activity
-from sugar.datastore import datastore
+try:
+    from sugar.activity import activity
+    from sugar.datastore import datastore
+    import gtk
+    ROOT = activity.get_activity_root()
+    BUND = activity.get_bundle_path()
+except Exception, e:
+    datastore = None
+    gtk = None
+    ROOT = os.path.join(os.path.dirname(__file__), '..', '..',
+                        '..', 'atdj_root')
+    BUND = os.path.join(os.path.dirname(__file__), '..', '..')
 
 # get application logger
 logger = logging.getLogger('atoidejouer')
@@ -22,126 +29,38 @@ ACTIVITY_NAMES = {
         'record': 'org.laptop.RecordActivity',
         }
 
+ACTIVITY_PER_MIME_TYPES = {
+        'image/png': 'org.laptop.Oficina',
+        'audio/ogg': 'org.laptop.RecordActivity',
+        }
+
 
 def get_tmp_path(ext='png'):
-    return os.path.join(activity.get_activity_root(), 'tmp.%s' % ext)
+    return os.path.join(ROOT, 'tmp.%s' % ext)
 
 
 def get_config_path():
     # get bundle path
-    _bundle_path = activity.get_bundle_path()
+    _bundle_path = BUND
     # return path
     return os.path.join(_bundle_path, 'static', 'data', 'config', 'config.ini')
 
 
-def list_sequence_names(type_):
-    # init result
-    _names = list()
-    # prepare dir path
-    _seq_dir = os.path.join(activity.get_activity_root(), 'data',
-                            'sequences', type_)
-    # ..
-    for _filename in os.listdir(_seq_dir):
-        # ..
-        _path = os.path.join(_seq_dir, _filename)
-        # little check
-        if os.path.isfile(_path):
-            # check name
-            try:
-                _n, _ext = os.path.splitext(_filename)
-                # check ext
-                if _ext == '.seq':
-                    _names.append((_n, _path))
-                else:
-                    continue
-            except Exception, e:
-                # TODO log something
-                continue
-    # ..
-    return _names
-
-
-def get_sequence_items(sequence_path):
-    if os.path.exists(sequence_path):
-        _f = open(sequence_path)
-        _rows = _f.readlines()
-        _f.close()
-    else:
-        return []
-    # ..
-    _names = list()
-    for _n in _rows:
-        _n = _n.strip()
-        if _n == '':
-            continue
-        else:
-            _names.append(_n)
-    # ..
-    return _names
-
-
-def get_sequence_path(type_, sequence_name):
-    return os.path.join(activity.get_activity_root(), 'data',
-            'sequences', type_, '%s.seq' % sequence_name)
-
-
-def get_sequence_first_graphic_name(type_, sequence_name):
-    # seq file
-    _f = open(get_sequence_path(type_, sequence_name))
-    _names = _f.readlines()
-    _f.close()
-    # ..
-    return None if len(_names) == 0 else _names[0].strip()
-
-
-def sequence_save(toolbar, remove=False):
-    # get sequence name
-    _name = toolbar._sequence_entry.get_text()
-    # get screen
-    _screen = toolbar.activity.get_current_screen()
-    # get nb of graphics
-    _nb_of_items = _screen.sequence_preview.number_of_items()
-    # type shortcut 'graphic' or 'sound'
-    _type = _screen.notebook._type
-    # get sequence path
-    _seq_path = get_sequence_path(_type, _name)
-    # little check
-    if _name.strip() == '':
-        return
-    elif _nb_of_items == 0\
-    and remove is True:
-        # remove from files
-        os.remove(_seq_path)
-        # ..
-        _keys = toolbar.activity.graphic_keys\
-                if toolbar.name == 'graphics_add'\
-                else toolbar.activity.sound_keys
-        # remove from keys
-        _keys.remove_sequence(_name)
-    else:
-        # open file
-        _file = open(_seq_path, 'wb')
-        # update
-        for _filename in _screen.sequence_preview.items:
-            _filename = _filename.strip()
-            if _filename == '':
-                continue
-            else:
-                _file.write('%s\n' % _filename)
-        _file.close()
-    # update notebook
-    _screen.notebook._get_store_sequence()
+def get_db_path(filename, dir_='db'):
+    # return path
+    return os.path.join(ROOT, 'data', dir_,
+            '%s.db' % filename)
 
 
 def get_sound_path(filename, dir_='sounds'):
     # return path
-    return os.path.join(activity.get_activity_root(), 'data', dir_,
+    return os.path.join(ROOT, 'data', dir_,
             '%s.ogg' % filename)
 
 
 def get_icon_path(stock_id):
     # return path
-    return os.path.join(activity.get_bundle_path(), 'static', 'data', 'icons',
+    return os.path.join(BUND, 'static', 'data', 'icons',
             '%s.png' % stock_id)
 
 
@@ -149,31 +68,40 @@ def get_image_path(filename, dir_='graphics'):
     # return path
     if filename in ['background_default', 'mask_default']\
     or dir_=='data':
-        return os.path.join(activity.get_bundle_path(), 'static', 'data',
+        return os.path.join(BUND, 'static', 'data',
                 'graphics', '%s.png' % filename)
     else:
-        return os.path.join(activity.get_activity_root(), 'data', dir_,
+        return os.path.join(ROOT, 'data', dir_,
                 '%s.png' % filename)
 
 
 def get_html_path(page):
     # return path
-    return os.path.join(activity.get_bundle_path(), 'static', 'data', 'html',
+    return os.path.join(BUND, 'static', 'data', 'html',
             '%s.html' % page)
 
 
 def get_pixbuf_from_data(data, image_type=None, size=None):
     # load it
-    if image_type:
+    if gtk is None:
+        return
+    elif image_type:
         _loader = gtk.gdk.PixbufLoader(image_type=image_type)
     else:
         _loader = gtk.gdk.PixbufLoader()
+    # DEBUG
+    logger.debug('[tools.storage] get_pixbuf_from_data - size: %s/%s' % size)
     # size check
     if size is None:
         pass
     else:
+        # get image size
+        from atoidejouer.tools import image
+        _info, _w, _h = image.get_image_info(data=data)
         # parse size
-        _w, _h = size
+        _max_w, _max_h = size
+        # compute target size to keep ratio
+        _w, _h = image.compute_width_height(_w, _h, _max_w, _max_h)
         # set loader size
         _loader.set_size(_w, _h)
     # load data
@@ -318,40 +246,30 @@ def png_from_pixbuf(filename, timestamp):
     del _new_new_pixels
 
 
-def __do_query(query):
+def journal_query(query):
+    if not datastore:
+        return
     # find in ds
     _results, _count = datastore.find(query, sorting='timestamp')
     for _r in _results:
-        # get meta
-        _m = _r.get_metadata()
-        if 'activity' in query:
-            yield _r
-        elif _m['activity'] == '':
-            yield _r
-        else:
-            continue
+        yield _r
 
 
 def get_journal_objects(activity_name=None, mime_type=None):
-    # init
-    _query = dict()
-    # prepare query name
     if activity_name is None\
     and mime_type is None:
         return []
     elif mime_type is None:
-        return __do_query({'activity': ACTIVITY_NAMES[activity_name]})
+        return journal_query({'activity': ACTIVITY_NAMES[activity_name]})
     else:
-        return __do_query({'mime_type': mime_type})
+        return journal_query({'mime_type': mime_type})
 
 
-def list_info_from_journal(activity_name=None, mime_type=None):
-    # get objects first
-    _objs = get_journal_objects(activity_name=activity_name, mime_type=mime_type)
+def list_info_from_journal(mime_type=None):
     # make unique titles
     _titles = {}
     # return infos
-    for _o in _objs:
+    for _o in journal_query({'mime_type': mime_type}):
         # get meta
         _m = _o.get_metadata()
         # get title
@@ -388,16 +306,16 @@ def list_files_from_journal(activity_name=None, mime_type=None):
 
 
 def get_path_from_journal(timestamp, mime_type):
-    # ..
+    if not datastore:
+        return
+    # prepare datastore query
     _query = {
             'timestamp': int(timestamp),
             'mime_type': mime_type
             }
     # find in ds
     _results, _count = datastore.find(_query)
-    # ..
     if _count == 1:
-        # get path
         return _results[0].get_file_path()
     else:
         return None
@@ -406,9 +324,9 @@ def get_path_from_journal(timestamp, mime_type):
 def __check_dir(dir_name, parent='data'):
     # get activity path
     if parent is None:
-        _dir = os.path.join(activity.get_activity_root(), dir_name)
+        _dir = os.path.join(ROOT, dir_name)
     else:
-        _dir = os.path.join(activity.get_activity_root(), parent, dir_name)
+        _dir = os.path.join(ROOT, parent, dir_name)
     # ensure activity path
     if os.path.exists(_dir):
         pass
@@ -416,50 +334,107 @@ def __check_dir(dir_name, parent='data'):
         os.mkdir(_dir)
 
 
-def __check_file(sub_path, file_name):
-    # ..
+def __check_file_in_bundle(sub_path, file_name, mime_type=None, in_journal=False):
+    # ensure dir exist in bundle
     __check_dir(sub_path)
     # file path
-    _path = os.path.join(activity.get_activity_root(), 'data', sub_path,
-            file_name)
+    _path = os.path.join(ROOT, 'data', sub_path, file_name)
     # ensure file
     if os.path.exists(_path):
         pass
     else:
         # get bundle path
-        _p = os.path.join(activity.get_bundle_path(), 'static', 'ext',
-                sub_path, file_name)
-        # copy
+        _p = os.path.join(BUND, 'static', 'ext', sub_path, file_name)
+        # copy to the bundle
         shutil.copy(_p, _path)
 
 
-def __check_dir_files(sub_path):
+def is_in_journal(file_name, mime_type):
+    if not datastore:
+        return
+    # prepare query
+    _query = {
+            'activity': ACTIVITY_PER_MIME_TYPES[mime_type],
+            'mime_type': mime_type
+            }
+    # has records ?
+    _res, _count = datastore.find(_query)
+    # manual check because query with title doesnt work ?
+    return file_name in [o.metadata['title'] for o in _res]
+
+
+def __get_preview(file_path):
+    """Creates preview from file path for ds metadata.
+    cf.: http://en.flossmanuals.net/make-your-own-sugar-activities/fun-with-the-journal
+    """
+    # DEBUG
+    logger.debug('[tools.storage] __get_preview - file_path: %s' % file_path)
+    # avoid inter-dependance loop
+    from atoidejouer.tools import image
+    # prepare pixbuf
+    _pixbuf = image.get_pixbuf(file_path, 128, 96)
+    # data cb
+    def _save_func(buf, data):
+        data.append(buf)
+    # save data
+    _data = []
+    _pixbuf.save_to_callback(_save_func, 'png', user_data=_data)
+    # done
+    return dbus.ByteArray(''.join(_data))
+
+
+def add_file_to_journal(file_name, file_path, mime_type):
+    if not datastore:
+        return
+    _props = {
+            'activity': ACTIVITY_PER_MIME_TYPES[mime_type],
+            'mime_type': mime_type,
+            'title': file_name,
+            'preview': __get_preview(file_path)
+            }
+    # prepare meta
+    _meta = datastore.DSMetadata(_props)
+    # prepare ds object
+    _dsobject = datastore.create()
+    _dsobject.metadata = _meta
+    _dsobject.file_path = file_path
+    # write it
+    datastore.write(_dsobject)
+
+
+def __check_file_in_journal(sub_path, file_name, mime_type=None):
+    # is already in the journal
+    if is_in_journal(file_name, mime_type):
+        pass
+    else:
+        # file path
+        _path = os.path.join(ROOT, 'data', sub_path, file_name)
+        # ensure dir exist in bundle
+        add_file_to_journal(file_name, _path, mime_type)
+
+
+def __check_dir_files(sub_path, mime_type=None, in_journal=False):
     # get bundle path
-    _path = os.path.join(activity.get_bundle_path(), 'static', 'ext', sub_path)
+    _path = os.path.join(BUND, 'static', 'ext', sub_path)
     # file by file
     for _f in os.listdir(_path):
         # full path
         _p = os.path.join(_path, _f)
         # little check
-        if os.path.isdir(_p):
+        if os.path.isdir(_p) or _f in ['blank']:
             pass
+        elif in_journal is True:
+            __check_file_in_journal(sub_path, _f, mime_type=mime_type)
         else:
-            __check_file(sub_path, _f)
-
-
-def init_activity_folder():
-    # check folders
-    _root = activity.get_activity_root()
-    # graphics
-    __check_dir_files('graphics')
-    # sounds
-    __check_dir_files('sounds')
-    # sequences
-    __check_dir('sequences')
-    __check_dir_files(os.path.join('sequences', 'graphics'))
-    __check_dir_files(os.path.join('sequences', 'sounds'))
-    # stories
+            __check_file_in_bundle(sub_path, _f)
+
+
+def init_activity_files():
+    __check_dir_files('db')
     __check_dir_files('stories')
+    # add embedded resources to the journal for common usage
+    __check_dir_files('graphics', mime_type='image/png', in_journal=True)
+    __check_dir_files('sounds', mime_type='audio/ogg', in_journal=True)
 
 
 def __show_in_out_result_message(label, message):
@@ -470,12 +445,12 @@ def __show_in_out_result_message(label, message):
 
 def __merge_dir(project_name, dir_name, exist_list=None):
     # archive path
-    _path_src = os.path.join(activity.get_activity_root(), 'tmp', project_name,
+    _path_src = os.path.join(ROOT, 'tmp', project_name,
             dir_name)
     # little check
     if os.path.exists(_path_src):
         # project path
-        _path_dst = os.path.join(activity.get_activity_root(), 'data',
+        _path_dst = os.path.join(ROOT, 'data',
                 dir_name)
         # init existing list
         exist_list = list() if exist_list is None else exist_list
@@ -502,7 +477,7 @@ def __merge_dir(project_name, dir_name, exist_list=None):
 
 def __import_keys(activity_, project_name):
     # ..
-    _path_data = os.path.join(activity.get_activity_root(), 'tmp',
+    _path_data = os.path.join(ROOT, 'tmp',
             project_name, 'story.keys')
     # init content
     _data = None
@@ -534,7 +509,7 @@ def import_project(activity_, file_path, msg_label):
     __remove_dir('tmp', parent=None)
     __check_dir('tmp', parent=None)
     # ..
-    _tmp_root = os.path.join(activity.get_activity_root(), 'tmp')
+    _tmp_root = os.path.join(ROOT, 'tmp')
     try:
         # copy file to tmp
         _tar_path = os.path.join(_tmp_root, '__tmp.tar.bz2')
@@ -557,11 +532,7 @@ def import_project(activity_, file_path, msg_label):
     # merge dirs
     _exist_list = list()
     if __merge_dir(_p_name, 'graphics', exist_list=_exist_list)\
-    and __merge_dir(_p_name, 'sounds', exist_list=_exist_list)\
-    and __merge_dir(_p_name, os.path.join('sequences', 'graphics'),
-            exist_list=_exist_list)\
-    and __merge_dir(_p_name, os.path.join('sequences', 'sounds'),
-            exist_list=_exist_list):
+    and __merge_dir(_p_name, 'sounds', exist_list=_exist_list):
         # init result message
         _msg = _('Project sucessfully imported')
     else:
@@ -610,10 +581,10 @@ def import_project(activity_, file_path, msg_label):
 def __remove_dir(dir_name, parent=None):
     # get activity path
     if parent is None:
-        _dir = os.path.join(activity.get_activity_root(), dir_name)
+        _dir = os.path.join(ROOT, dir_name)
         _next_parent = dir_name
     else:
-        _dir = os.path.join(activity.get_activity_root(), parent, dir_name)
+        _dir = os.path.join(ROOT, parent, dir_name)
         _next_parent = os.path.join(parent, dir_name)
     # remove files and dir recursively
     if os.path.exists(_dir):
@@ -633,31 +604,6 @@ def __remove_dir(dir_name, parent=None):
         pass
 
 
-def __export_seq_and_res(activity_, tmp_root, type_='graphics'):
-    # path updates
-    _seq_src = os.path.join(activity.get_activity_root(), 'data', 'sequences',
-            type_)
-    _seq_dst = os.path.join(tmp_root, 'sequences', type_)
-    # ..
-    _res_root = os.path.join(activity.get_activity_root(), 'data', type_)
-    _res_dst = os.path.join(tmp_root, type_)
-    # keys factory
-    _keys = activity_.graphic_keys if type_ == 'graphics'\
-            else activity_.sound_keys
-    # set res ext
-    _ext = '.png' if type_ == 'graphics' else '.ogg'
-    # copy
-    for _n in _keys._names:
-        if _n.strip() == '':
-            continue
-        else:
-            _s_path = os.path.join(_seq_src, '%s.seq' % _n)
-            shutil.copy(_s_path, _seq_dst)
-            for _res in get_sequence_items(_s_path):
-                _res_path = os.path.join(_res_root, '%s%s' % (_res, _ext))
-                shutil.copy(_res_path, _res_dst)
-
-
 def export_project(activity_, msg_label, media):
     # get the toolbar
     _toolbar = activity_._toolbox.get_activity_toolbar()
@@ -669,19 +615,16 @@ def export_project(activity_, msg_label, media):
     # create a tmp stucture
     __check_dir(_name, parent='tmp')
     __check_dir(os.path.join(_name, 'graphics'), parent='tmp')
-    __check_dir(os.path.join(_name, 'sequences'), parent='tmp')
-    __check_dir(os.path.join(_name, 'sequences', 'graphics'), parent='tmp')
-    __check_dir(os.path.join(_name, 'sequences', 'sounds'), parent='tmp')
     __check_dir(os.path.join(_name, 'sounds'), parent='tmp')
     # ..
-    _tmp_root = os.path.join(activity.get_activity_root(), 'tmp')
+    _tmp_root = os.path.join(ROOT, 'tmp')
     _out_root = os.path.join(_tmp_root, _name)
     # copy keys
     _keys_path = os.path.join(_out_root, 'story.keys')
     activity_.write_file(_keys_path)
     # copy sequences and resources
-    __export_seq_and_res(activity_, _out_root, type_='graphics')
-    __export_seq_and_res(activity_, _out_root, type_='sounds')
+    # __export_seq_and_res(activity_, _out_root, type_='graphics')
+    # __export_seq_and_res(activity_, _out_root, type_='sounds')
     # change dir for zipping
     os.chdir(_tmp_root)
     # zip all
diff --git a/atoidejouer/ui/panel.py b/atoidejouer/ui/panel.py
deleted file mode 100644
index 8e65bea..0000000
--- a/atoidejouer/ui/panel.py
+++ /dev/null
@@ -1,1025 +0,0 @@
-
-# python import
-import logging, os
-# ..
-from functools import partial
-from gettext import gettext as _
-
-# gtk import
-import gobject, gtk, glib
-
-# sugar import
-from sugar.activity import activity
-
-# atoidejouer import
-from atoidejouer.tools import config, image, storage, ui
-
-# get application logger
-logger = logging.getLogger('atoidejouer')
-
-
-def _get_filename(panel):
-    # get model
-    _model = panel.combo_box.get_model()
-    # get iter
-    _iter = panel.combo_box.get_active_iter()
-    # get filename
-    if isinstance(_iter, gtk.TreeIter):
-        return _model.get_value(_iter, 1)
-    else:
-        return None
-
-
-def _on_graphic_combo_changed(combobox, panel):
-    # shortcut
-    _activity = panel.screen.toolbar.activity
-    # get filename
-    _filename = _get_filename(panel)
-    # get current
-    _current, _f_type, _k_type = panel.story_keys.get_current(
-            panel.sequence_name, _activity._thread._time)
-    # do nothing
-    if _filename is None\
-    or _k_type == 'transition'\
-    or _activity._thread._pause is False:
-        return
-    # ...
-    elif _filename == '':
-        # remove key
-        panel.story_keys.remove_filename(panel.sequence_name,
-                _activity._thread._time, _current)
-        # reset current
-        panel.story_keys.set_current(panel.sequence_name,
-                _activity._thread._time, None, file_type=None,
-                key_type=None)
-    elif _current != _filename:
-        # update keys
-        panel.story_keys.set_current(panel.sequence_name,
-                _activity._thread._time, _filename, file_type='lib',
-                key_type='key')
-        # ..
-        if panel.screen.toolbar.name == 'graphics':
-            # get previous align
-            _prev_align = panel.story_keys.get_previous_align(
-                    panel.sequence_name, _activity._thread._time)
-            # set align
-            panel.story_keys.set_align(panel.sequence_name,
-                    _activity._thread._time, _filename, _prev_align)
-        else:
-            pass
-    # ...
-    panel.story_keys.refresh(panel.sequence_name)
-    # refresh timeline
-    panel.screen.timeline.refresh_sequence()
-    # refresh scene
-    panel.screen.scene.refresh(sequence_name=panel.sequence_name)
-
-
-def _on_position_clicked(widget, panel, move, value):
-    # shortcut
-    _activity = panel.screen.toolbar.activity
-    # get filename
-    _filename = _get_filename(panel)
-    # get current
-    _current, _f_type, _k_type = panel.story_keys.get_current(
-            panel.sequence_name, _activity._thread._time)
-    # do nothing
-    if _filename is None\
-    or _k_type != 'key'\
-    or _activity._thread._pause is False:
-        pass
-    else:
-        # update keys
-        _x, _y = panel.story_keys.inc_position(panel.sequence_name,
-                _activity._thread._time, _filename, move, value)
-        # ...
-        panel.story_keys.refresh(panel.sequence_name)
-        # refresh timeline
-        panel.screen.timeline.refresh_sequence()
-        # update panel entries
-        panel.entry_x.set_text(str(_x))
-        panel.entry_y.set_text(str(-_y))
-        # refresh scene
-        panel.screen.scene.refresh(sequence_name=panel.sequence_name)
-
-
-def _on_layout_clicked(widget, panel, move):
-    # shortcut
-    _activity = panel.screen.toolbar.activity
-    # get current layout
-    _layout = panel.story_keys.get_layout(panel.sequence_name)
-    _max_layout = panel.story_keys.get_max_layout()
-    # do nothing
-    if _activity._thread._pause is False:
-        return
-    # layout factory
-    elif move == 'move_up_up':
-        _layout = _max_layout
-    elif move == 'move_up':
-        _layout = (_layout + 1) if _layout < _max_layout else _max_layout
-    elif move == 'move_down':
-        _layout = (_layout - 1) if _layout > 0 else 0
-    elif move == 'move_down_down':
-        _layout = 0
-    else:
-        # ??
-        return
-    # ..
-    panel.story_keys.set_layout(panel.sequence_name, _layout)
-    # ...
-    panel.story_keys.refresh(panel.sequence_name)
-    # refresh timeline
-    panel.screen.timeline.refresh_sequence()
-    # update entry
-    panel.entry_layout.set_text(str(_layout))
-    # refresh scene
-    panel.screen.scene.refresh()
-    # reorder timeline
-    panel.screen.timeline.reorder()
-
-
-def _on_time_clicked(widget, panel, value):
-    # little check
-    if hasattr(panel, 'time_entry')\
-    or panel.time_entry is None:
-        pass
-    else:
-        return False
-    # shortcut
-    _activity = panel.screen.toolbar.activity
-    # get current
-    _current, _f_type, _k_type = panel.story_keys.get_current(
-            panel.sequence_name, _activity._thread._time)
-    # little check
-    if panel.sequence_name is None:
-        return panel.time_entry.set_text('')
-    # do nothing
-    elif _k_type == 'transition'\
-    or _activity._thread._pause is False:
-        return
-    else:
-        _previous_frame = _activity._thread._time
-    # time factory
-    _new_frame = _previous_frame + value
-    _new_frame = 0 if _new_frame < 0 else _new_frame
-    # entry update
-    panel.time_entry.set_text('%1d:%02d' % divmod(_new_frame, 60))
-    # update keys
-    panel.story_keys.set_frame(panel.sequence_name, _previous_frame,
-                                   _new_frame)
-    # ...
-    panel.story_keys.refresh(panel.sequence_name)
-    # refresh timeline
-    panel.screen.timeline.refresh_sequence()
-    # set activity new number of keys
-    _activity.update_number_of_keys()
-    # update thread time
-    _activity._thread.set_time(time_=_new_frame)
-    # restore current
-    panel.screen.timeline.set_active_sequence(panel.sequence_name)
-
-
-def _on_remove_sequence_clicked(widget, panel):
-    # shortcut
-    _activity = panel.screen.toolbar.activity
-    # clear keys
-    panel.story_keys.remove_sequence(panel.sequence_name)
-    # reorder timeline
-    panel.screen.timeline.remove_sequence(panel.sequence_name)
-    # ..
-    panel.clear()
-    # ...
-    panel.story_keys.ask_clear()
-    # refresh scene
-    panel.screen.scene.refresh()
-
-
-def _on_remove_key_clicked(widget, panel):
-    # shortcut
-    _activity = panel.screen.toolbar.activity
-    # get current
-    _current, _f_type, _k_type = panel.story_keys.get_current(
-            panel.sequence_name, _activity._thread._time)
-    # ..
-    if _k_type is None:
-        pass
-    elif _k_type != 'key':
-        return
-    # remove key
-    panel.story_keys.remove_filename(panel.sequence_name,
-            _activity._thread._time, _current)
-    # reset current
-    panel.story_keys.set_current(panel.sequence_name,
-            _activity._thread._time, None, file_type=None,
-            key_type=None)
-    # ...
-    panel.story_keys.refresh(panel.sequence_name)
-    # refresh timeline
-    panel.screen.timeline.refresh_sequence()
-    # ...
-    panel.story_keys.ask_clear()
-    # refresh scene
-    panel.screen.scene.refresh()
-    # .. and reset panel
-    panel.refresh()
-
-
-def _on_duration_clicked(widget, panel, value):
-    # shortcut
-    _activity = panel.screen.toolbar.activity
-    # get filename
-    _filename = _get_filename(panel)
-    # get current
-    _current, _f_type, _k_type = panel.story_keys.get_current(
-            panel.sequence_name, _activity._thread._time)
-    # do nothing
-    if panel.sequence_name is None:
-        panel.entry_duration.set_text('')
-    elif _filename is None\
-    or _k_type != 'key'\
-    or _activity._thread._pause is False:
-        pass
-    else:
-        # update keys
-        _d = panel.story_keys.inc_duration(panel.sequence_name,
-                _activity._thread._time, _filename, value)
-        # ...
-        panel.story_keys.refresh(panel.sequence_name)
-        # refresh timeline
-        panel.screen.timeline.refresh_sequence()
-        # update panel entries
-        panel.entry_duration.set_text('%1d:%02d' % divmod(_d, 60))
-
-
-def _on_loop_click(toggle, panel, image):
-    # update image
-    _stock_id = 'repeat_grey' if toggle.get_active() is True else 'repeat'
-    image.set_from_file(storage.get_icon_path(_stock_id))
-    # shortcut
-    _activity = panel.screen.toolbar.activity
-    # get filename
-    _filename = _get_filename(panel)
-    # get current
-    _current, _f_type, _k_type = panel.story_keys.get_current(
-            panel.sequence_name, _activity._thread._time)
-    # do nothing
-    if panel.sequence_name is None:
-        panel.toggle_loop.set_active(False)
-    elif _filename is None\
-    or _k_type != 'key'\
-    or _activity._thread._pause is False:
-        pass
-    else:
-        _loop = toggle.get_active()
-        # update keys
-        panel.story_keys.set_loop(panel.sequence_name,
-                _activity._thread._time, _filename, _loop)
-        # ...
-        panel.story_keys.refresh(panel.sequence_name)
-        # refresh timeline
-        panel.screen.timeline.refresh_sequence()
-
-
-def _get_next_time(panel, factor):
-    # get the current frame
-    _time = 0.0 if panel.screen.toolbar.activity._thread is None\
-            else panel.screen.toolbar.activity._thread._time
-    # get rate
-    _rate = config.Config().get_rate_value()
-    # next time
-    _next = _time + factor * _rate
-    # get max
-    _max = panel.screen.toolbar.activity._number_of_keys - 1
-    if _next < _max:
-        # ok!
-        return _next
-    else:
-        # return max + pause
-        return _max
-
-
-def _get_previous_time(panel, factor):
-    # get the current frame
-    _time = 0.0 if panel.screen.toolbar.activity._thread is None\
-            else panel.screen.toolbar.activity._thread._time
-    # get rate
-    _rate = config.Config().get_rate_value()
-    # previous time
-    _previous = _time - factor * _rate
-    # ..
-    if _previous < 0:
-        # return min
-        return 0
-    else:
-        # ok
-        return _previous
-
-
-def _on_key_press(widget, event, panel):
-    # ..
-    if isinstance(panel, Panel):
-        # ..
-        _keyval = event.keyval
-        _name = gtk.gdk.keyval_name(_keyval)
-        _mod = gtk.accelerator_get_label(_keyval, event.state)
-        # ..
-        if panel.screen != panel.screen.toolbar.activity.get_current_screen():
-            return
-        # key factory
-        elif panel.screen.toolbar.name == 'graphics':
-            # POSITION
-            if _name == 'Left' and _mod.startswith('Ctrl+'): # big left
-                _on_position_clicked(widget, panel, 'x', -10)
-            elif _name == 'Left': # left
-                _on_position_clicked(widget, panel, 'x', -1)
-            elif _name == 'Right' and _mod.startswith('Ctrl+'): # big right
-                _on_position_clicked(widget, panel, 'x', 10)
-            elif _name == 'Right': # right
-                _on_position_clicked(widget, panel, 'x', 1)
-            elif _name == 'Up' and _mod.startswith('Ctrl+'): # big top
-                _on_position_clicked(widget, panel, 'y', -10)
-            elif _name == 'Up': # top
-                _on_position_clicked(widget, panel, 'y', -1)
-            elif _name == 'Down' and _mod.startswith('Ctrl+'): # big bottom
-                _on_position_clicked(widget, panel, 'y', 10)
-            elif _name == 'Down': # bottom
-                _on_position_clicked(widget, panel, 'y', 1)
-            # LAYOUT
-            elif _name == 'Page_Up' and _mod.startswith('Ctrl+'):
-                _on_layout_clicked(widget, panel, 'move_up_up')
-            elif _name == 'Page_Up':
-                _on_layout_clicked(widget, panel, 'move_up')
-            elif _name == 'Page_Down' and _mod.startswith('Ctrl+'):
-                _on_layout_clicked(widget, panel, 'move_down_down')
-            elif _name == 'Page_Down':
-                _on_layout_clicked(widget, panel, 'move_down')
-            # TIME
-            elif _name == 'plus' and _mod.startswith('Ctrl+'):
-                _on_time_clicked(widget, panel, 10)
-            elif _name == 'plus':
-                _on_time_clicked(widget, panel, 1)
-            elif _name == 'minus' and _mod.startswith('Ctrl+'):
-                _on_time_clicked(widget, panel, -10)
-            elif _name == 'minus':
-                _on_time_clicked(widget, panel, -1)
-            # DELETE
-            elif _name == 'BackSpace' and _mod.startswith('Ctrl+'):
-                _on_remove_sequence_clicked(widget, panel)
-            elif _name == 'BackSpace':
-                _on_remove_key_clicked(widget, panel)
-            # IMAGE
-            # TODO ...
-        elif panel.screen.toolbar.name == 'sounds':
-            pass
-        else:
-            pass
-        # IN EVERY CASE
-        if panel.screen.toolbar.name in ['graphics', 'sounds', 'story']:
-            # shortcut
-            _thread = panel.screen.toolbar.activity._thread
-            # ..
-            if _name == 'space': # play right
-                # 
-                _time = _get_next_time(panel, 1)
-                # 
-                _thread.set_time(time_=_time, pause=True)
-            elif _name == 'space' and _mod.startswith('Ctrl+'): # play left
-                # 
-                _time = _get_previous_time(panel, 1)
-                # 
-                _thread.set_time(time_=_time, pause=True)
-            # PLAY
-            elif _name == 'Return':
-                # ..
-                if _thread._pause is True:
-                    panel.screen.toolbar.play()
-                    _thread.play()
-                # ..
-                else:
-                    panel.screen.toolbar.pause()
-                    _thread.pause()
-            else:
-                pass
-            # avoid propagation for rendering issue
-            widget.emit_stop_by_name('key-press-event')
-            # ..
-            return False
-        else:
-            return False
-    else:
-        return False
-
-
-class Panel(gtk.Frame):
-
-    def __init__(self, screen):
-        # init parent
-        gtk.Frame.__init__(self)
-        self.set_shadow_type(gtk.SHADOW_NONE)
-        # set screen
-        self.screen = screen
-        # ..
-        if screen.toolbar.name == 'graphics':
-            self.story_keys = self.screen.toolbar.activity.graphic_keys
-        else:
-            self.story_keys = self.screen.toolbar.activity.sound_keys
-        # get mode
-        self._mode = config.Config().get('activity>mode')
-        self._conf = config.Config().get('mode>%s' % self._mode, type_=list)
-        # ...
-        self.set_size_request(298, screen.scene._screen_height)
-        # do show
-        self.show()
-        # init vars
-        self._store = None
-        self.sequence_name = None
-        # ..
-        self.combo_box = None
-        self.time_entry = None
-        # add vbox to the panel for sub frames
-        self.main_box = gtk.VBox(homogeneous=False, spacing=0)
-        # do show
-        self.main_box.show()
-        # add it to the panel
-        self.add(self.main_box)
-        # ..
-        self.__init_handler()
-
-    def __init_handler(self):
-        # shortcuts
-        _activity = self.screen.toolbar.activity
-        _handler_id = _activity._handler_id
-        if _handler_id is None:
-            pass
-        else:
-            _activity.disconnect(_handler_id)
-        # ..
-        _activity._handler_id = _activity.connect('key-press-event',
-                _on_key_press, self)
-
-    def _init_sequence_box(self):
-        # update store
-        self.update_store()
-        # init combo
-        self.combo_box = gtk.ComboBox(model=self._store)
-        # set tooltip
-        self.combo_box.set_tooltip_text(_('Choose a Sequence Item'))
-        # set renderers
-        _cell_pix = gtk.CellRendererPixbuf()
-        _cell_pix.set_property('width', 48)
-        _cell_pix.set_property('height', 36)
-        # ..
-        self.combo_box.pack_start(_cell_pix, expand=False)
-        self.combo_box.add_attribute(_cell_pix, 'pixbuf', 0)
-        # ..
-        _cell_text = gtk.CellRendererText()
-        _cell_text.set_property('xpad', 4)
-        _cell_text.set_property('yalign', 0.5)
-        # ..
-        self.combo_box.pack_start(_cell_text, expand=True)
-        self.combo_box.add_attribute(_cell_text, 'text', 1)
-
-    def clear(self):
-        self.sequence_name = None
-        self.time_entry.set_text('')
-        self.update_store()
-
-    def _get_pixbuf(self, graphic_name, dir_='graphics'):
-        # get the image path
-        _graphic_path = storage.get_image_path(graphic_name, dir_=dir_)
-        # return pix and path
-        return image.get_pixbuf(_graphic_path, 48, 36), _graphic_path
-
-    def update_store(self):
-        # init store
-        if self._store is None:
-            self._store = gtk.ListStore(gtk.gdk.Pixbuf, gobject.TYPE_STRING,
-                    gobject.TYPE_PYOBJECT)
-        else:
-            self._store.clear()
-
-    def refresh(self, sequence_name=None, update_store=False):
-        pass
-
-    def _refresh(self, type_, sequence_name=None, update_store=False):
-        # keep older if not specified
-        if sequence_name is None:
-            pass
-        else:
-            self.sequence_name = sequence_name
-        # update store
-        if update_store is True:
-            self.update_store()
-        else:
-            pass
-        # prepare dir path
-        _seq_path = os.path.join(activity.get_activity_root(), 'data',
-                'sequences', type_, '%s.seq' % self.sequence_name)
-        # little check
-        if os.path.exists(_seq_path):
-            _activity = self.screen.toolbar.activity
-            # ..
-            _current, _f_type, _k_type = self.story_keys.get_current(
-                    self.sequence_name, _activity._thread._time)
-            # get sound names
-            _items = storage.get_sequence_items(_seq_path)
-            # get combo box active
-            if _current in _items:
-                _active = _items.index(_current) + 1
-            else:
-                _active = 0
-            # update combobox
-            self.combo_box.set_active(_active)
-        else:
-            _current = None
-        # shortcut
-        _activity = self.screen.toolbar.activity
-        # time entry update
-        if self.time_entry is None:
-            pass
-        else:
-            self.time_entry.set_text(
-                    '%1d:%02d' % divmod(_activity._thread._time, 60))
-        # ..
-        return _seq_path, _current
-
-    def __get_time_button(self, name, value, tooltip_text):
-        # init button
-        _button = ui.get_button(stock_id=name)
-        # set tooltip
-        _button.set_tooltip_text(tooltip_text)
-        # set cb
-        _button.connect('clicked', _on_time_clicked, self, value)
-        # ..
-        return _button
-
-    def add_frame_time(self):
-        # init frame
-        _frame_time = gtk.Frame(label=_('Time'))
-        _frame_time.set_border_width(1)
-        # do show
-        _frame_time.show()
-        # do add
-        self.main_box.pack_start(_frame_time, expand=False, fill=True)
-        # get over/under spin buttons
-        _time_box = gtk.HBox(homogeneous=False, spacing=4)
-        _time_box.set_border_width(4)
-        _time_box.show()
-        # before ..
-        _time_box.pack_start(self.__get_time_button('go_left', -10,
-            _('Play Before (10 Frames)')), expand=False, fill=True)
-        _time_box.pack_start(self.__get_time_button('go_left_small', -1,
-            _('Play Before (1 Frames)')), expand=False, fill=True)
-        # entry
-        self.time_entry = gtk.Entry()
-        # show
-        self.time_entry.show()
-        # set value - should be a string
-        self.time_entry.set_text('')
-        self.time_entry.set_alignment(1)
-        self.time_entry.set_property('editable', False)
-        # add entry
-        _time_box.pack_start(self.time_entry, expand=True, fill=True)
-        # .. after
-        _time_box.pack_start(self.__get_time_button('go_right_small', 1,
-            _('Play After (1 Frames)')), expand=False, fill=True)
-        _time_box.pack_start(self.__get_time_button('go_right', 10,
-            _('Play After (10 Frames)')), expand=False, fill=True)
-        # do add
-        _frame_time.add(_time_box)
-
-    def add_frame_remove(self):
-        # init frame
-        _frame_remove = gtk.Frame(label=_('Remove'))
-        _frame_remove.set_border_width(1)
-        # do show
-        _frame_remove.show()
-        # do add
-        self.main_box.pack_start(_frame_remove, expand=False, fill=True)
-        # init container
-        _in_vbox = gtk.HBox(homogeneous=True, spacing=4)
-        _in_vbox.set_border_width(4)
-        # show
-        _in_vbox.show()
-        # do add
-        _frame_remove.add(_in_vbox)
-        # prepare remove sequence button
-        _rm_seq_button = ui.get_button(label=_('Sequence'),
-                stock_id='remove_sequence', width=48, padding=(8, 0))
-        _rm_seq_button.set_tooltip_text(_('Remove Sequence'))
-        # set cb
-        _rm_seq_button.connect('clicked', _on_remove_sequence_clicked, self)
-        # get remove sequence button
-        _in_vbox.pack_start(_rm_seq_button, expand=False, fill=True)
-        # prepare remove sequence button
-        _rm_key_button = ui.get_button(label=_('Key'),
-                stock_id='remove_item', width=48, padding=(12, 0))
-        _rm_key_button.set_tooltip_text(_('Remove Key'))
-        # set cb
-        _rm_key_button.connect('clicked', _on_remove_key_clicked, self)
-        # get remove image button
-        _in_vbox.pack_start(_rm_key_button, expand=False, fill=True)
-
-
-class PanelGraphics(Panel):
-
-    def __init__(self, screen):
-        # init parent
-        Panel.__init__(self, screen)
-        # main vars
-        self.entry_layout = None
-        # ..
-        self.entry_x = None
-        self.entry_y = None
-        # add specific
-        if 'image' in self._conf:
-            self._add_frame_image()
-        else:
-            pass
-        if 'position' in self._conf:
-            self._add_frame_position()
-        else:
-            pass
-        # .. common
-        if 'time' in self._conf:
-            self.add_frame_time()
-        else:
-            pass
-        # ..
-        if 'remove' in self._conf:
-            self.add_frame_remove()
-        else:
-            pass
-
-    def clear(self):
-        # clear parent
-        Panel.clear(self)
-        # ..
-        self.entry_layout.set_text('')
-        self.entry_x.set_text('')
-        self.entry_y.set_text('')
-
-    def refresh(self, sequence_name=None, update_store=False):
-        # shortcut
-        _activity = self.screen.toolbar.activity
-        # update parent
-        _seq_path, _current = Panel._refresh(self, 'graphics',
-                sequence_name=sequence_name, update_store=update_store)
-        # little check
-        if os.path.exists(_seq_path):
-            # get current layout
-            _layout = self.story_keys.get_layout(self.sequence_name)
-            # update layout
-            self.entry_layout.set_text(str(_layout))
-            # get current x and y
-            _x, _y = self.story_keys.get_align(self.sequence_name,
-                    _activity._thread._time, _current)
-            # update panel x
-            if self.entry_x is None:
-                pass
-            else:
-                self.entry_x.set_text(str(_x))
-            # update panel y
-            if self.entry_y is None:
-                pass
-            else:
-                self.entry_y.set_text(str(-_y))
-        else:
-            pass
-
-    def update_store(self):
-        # init parent
-        Panel.update_store(self)
-        # prepare dir path
-        _seq_path = os.path.join(activity.get_activity_root(), 'data',
-                'sequences', 'graphics', '%s.seq' % self.sequence_name)
-        # little check
-        if os.path.exists(_seq_path):
-            # get graphic names
-            _items = storage.get_sequence_items(_seq_path)
-            # add dummy row
-            _dummy_pix, _path = self._get_pixbuf('blank', dir_='data')
-            self._store.append([_dummy_pix, '', None])
-            # for each graphics
-            for _filename in _items:
-                # prepare pixbuf
-                _pixbuf, _path = self._get_pixbuf(_filename)
-                # do update
-                self._store.append([_pixbuf, _filename, _path])
-        # not exist .. clear
-        else:
-            self._store.clear()
-
-    def _init_sequence_box(self):
-        # ..
-        Panel._init_sequence_box(self)
-        # set callback
-        self.combo_box.connect('changed', _on_graphic_combo_changed, self)
-
-    def __get_layout_button(self, name, tooltip_text):
-        # init button
-        _button = ui.get_button(stock_id=name)
-        # set tooltip
-        _button.set_tooltip_text(tooltip_text)
-        # set cb
-        _button.connect('clicked', _on_layout_clicked, self, name)
-        # ..
-        return _button
-
-    def _add_frame_image(self):
-        # init frame
-        _frame_sequence = gtk.Frame(label=_('Image'))
-        _frame_sequence.set_border_width(1)
-        # do show
-        _frame_sequence.show()
-        # do add
-        self.main_box.pack_start(_frame_sequence, expand=False, fill=True)
-        # vbox for the frame
-        _in_vbox = gtk.VBox(homogeneous=False, spacing=4)
-        _in_vbox.set_border_width(4)
-        # do show
-        _in_vbox.show()
-        # do add
-        _frame_sequence.add(_in_vbox)
-        # init
-        self._init_sequence_box()
-        # add row sequence
-        _in_vbox.pack_start(self.combo_box, expand=False, fill=True)
-        # get over/under spin buttons
-        _layer_box = gtk.HBox(homogeneous=True, spacing=4)
-        _layer_box.show()
-        # down ..
-        _layer_box.pack_start(self.__get_layout_button('move_down_down',
-            _('Layer to Bottom')), expand=False, fill=True)
-        _layer_box.pack_start(self.__get_layout_button('move_down',
-            _('Lower Layer')), expand=False, fill=True)
-        # entry
-        self.entry_layout = gtk.Entry()
-        # show
-        self.entry_layout.show()
-        # set value - should be a string
-        self.entry_layout.set_text("")
-        self.entry_layout.set_alignment(1)
-        self.entry_layout.set_property('editable', False)
-        # add entry
-        _layer_box.pack_start(self.entry_layout, expand=False, fill=True)
-        # .. up
-        _layer_box.pack_start(self.__get_layout_button('move_up',
-            _('Raise Layer')), expand=False, fill=True)
-        _layer_box.pack_start(self.__get_layout_button('move_up_up',
-            _('Layer to Top')), expand=False, fill=True)
-        # add row sequence
-        _in_vbox.pack_start(_layer_box, expand=True, fill=True)
-
-    def __get_position_button(self, name, move, value, tooltip_text):
-        # init button
-        _button = ui.get_button(stock_id=name)
-        # set tooltip
-        _button.set_tooltip_text(tooltip_text)
-        # set cb
-        _button.connect('clicked', _on_position_clicked, self, move, value)
-        # ..
-        return _button
-
-    def _add_frame_position(self):
-        # init frame
-        _frame_position = gtk.Frame(label=_('Position'))
-        _frame_position.set_border_width(1)
-        # do show
-        _frame_position.show()
-        # do add
-        self.main_box.pack_start(_frame_position, expand=False, fill=True)
-        # _vbox
-        _in_vbox = gtk.VBox(homogeneous=False, spacing=4)
-        _in_vbox.set_border_width(4)
-        _in_vbox.show()
-        # first _row
-        _in_vbox.pack_start(self.__get_position_button('y_up_up', 'y', -10,
-            _('Move Up by 10%')), expand=False, fill=False)
-        # second _row
-        _in_vbox.pack_start(self.__get_position_button('y_up', 'y', -1,
-            _('Move Up by 1%')), expand=False, fill=False)
-        # third _row
-        _row3 = gtk.HBox(homogeneous=False, spacing=4)
-        _row3.show()
-        _row3.pack_start(self.__get_position_button('x_left_left', 'x', -10,
-            _('Move Left by 10%')), expand=False, fill=True)
-        _row3.pack_start(self.__get_position_button('x_left', 'x', -1,
-            _('Move Left by 1%')), expand=False, fill=True)
-        # prepare middle box
-        _middle_box = gtk.VBox(homogeneous=True, spacing=4)
-        _middle_box.show()
-        # get entries
-        _entry_box_x = ui.get_entry(label='X')
-        _entry_box_y = ui.get_entry(label='Y')
-        # update main vars
-        self.entry_x = _entry_box_x.get_children()[1]
-        self.entry_y = _entry_box_y.get_children()[1]
-        # add entries to the box
-        _middle_box.pack_start(_entry_box_x, expand=False, fill=True)
-        _middle_box.pack_start(_entry_box_y, expand=False, fill=True)
-        _middle_box.set_size_request(64, -1)
-        # add the box to the row
-        _row3.pack_start(_middle_box, expand=True, fill=True)
-        # ..
-        _row3.pack_start(self.__get_position_button('x_right', 'x', 1,
-            _('Move Right by 1%')), expand=False, fill=True)
-        _row3.pack_start(self.__get_position_button('x_right_right', 'x', 10,
-            _('Move Right by 10%')), expand=False, fill=True)
-        # and add the third row
-        _in_vbox.pack_start(_row3, expand=False, fill=False)
-        # fourth _row
-        _in_vbox.pack_start(self.__get_position_button('y_down', 'y', 1,
-            _('Move Down by 1%')), expand=False, fill=False)
-        # fifth _row
-        _in_vbox.pack_start(self.__get_position_button('y_down_down', 'y', 10,
-            _('Move Down by 10%')), expand=False, fill=False)
-        # put it in
-        _frame_position.add(_in_vbox)
-
-
-class PanelSounds(Panel):
-
-    def __init__(self, screen):
-        # init parent
-        Panel.__init__(self, screen)
-        # init commonf fields
-        self.entry_duration = None
-        self.toggle_loop = None
-        self.image_loop = None
-        # add specific
-        if 'sound' in self._conf:
-            self._add_frame_sound()
-        else:
-            pass
-        # .. common
-        if 'time' in self._conf:
-            self.add_frame_time()
-        else:
-            pass
-        # ..
-        if 'remove' in self._conf:
-            self.add_frame_remove()
-        else:
-            pass
-
-
-    def clear(self):
-        # clear parent
-        Panel.clear(self)
-        # ..
-        self.entry_duration.set_text('')
-        self.toggle_loop.set_active(False)
-
-    def _get_time(self, value):
-        """Format the time value to display
-        """
-        # return formated value
-        return '%1d:%02d' % divmod(value, 60)
-
-    def update_store(self):
-        # init parent
-        Panel.update_store(self)
-        # prepare dir path
-        _seq_path = os.path.join(activity.get_activity_root(), 'data',
-                'sequences', 'sounds', '%s.seq' % self.sequence_name)
-        # little check
-        if os.path.exists(_seq_path):
-            # get graphic names
-            _items = storage.get_sequence_items(_seq_path)
-            # add dummy row
-            _dummy_pix, _path = self._get_pixbuf('blank', dir_='data')
-            self._store.append([_dummy_pix, '', None])
-            # for each graphics
-            for _filename in _items:
-                # prepare pixbuf
-                _pixbuf, _path = self._get_pixbuf('sound', dir_='data')
-                # do update
-                self._store.append([_pixbuf, _filename, _path])
-        # not exist .. clear
-        else:
-            self._store.clear()
-
-    def _init_sequence_box(self):
-        # ..
-        Panel._init_sequence_box(self)
-        # set callback
-        self.combo_box.connect('changed', _on_graphic_combo_changed, self)
-
-    def __get_duration_button(self, name, value, tooltip_text):
-        # init button
-        _button = ui.get_button(stock_id=name)
-        # ..
-        _button.set_tooltip_text(tooltip_text)
-        # set cb
-        _button.connect('clicked', _on_duration_clicked, self, value)
-        # ..
-        return _button
-
-    def _get_duration_box(self):
-        # get less/more spin buttons
-        _duration_box = gtk.HBox(homogeneous=True, spacing=4)
-        _duration_box.show()
-        # down ..
-        _duration_box.pack_start(self.__get_duration_button('less', -10,
-            _('Duration -10s')), expand=False, fill=True)
-        _duration_box.pack_start(self.__get_duration_button('less_small', -1,
-            _('Duration -1s')), expand=False, fill=True)
-        # entry
-        self.entry_duration = gtk.Entry()
-        # show
-        self.entry_duration.show()
-        # set value - should be a string
-        self.entry_duration.set_text('') # self._get_time(0)
-        self.entry_duration.set_alignment(1)
-        self.entry_duration.set_property('editable', False)
-        self.entry_duration.set_size_request(64, -1)
-        # add entry
-        _duration_box.pack_start(self.entry_duration, expand=False, fill=True)
-        # .. up
-        _duration_box.pack_start(self.__get_duration_button('more_small', 1,
-            _('Duration +1s')), expand=False, fill=True)
-        _duration_box.pack_start(self.__get_duration_button('more', 10,
-            _('Duration +10s')), expand=False, fill=True)
-        # return it
-        return _duration_box
-
-    def _init_loop_box(self):
-        # init row
-        _loop_box = gtk.HBox(homogeneous=False, spacing=4)
-        _loop_box.show()
-        # create image
-        self.image_loop = gtk.Image()
-        self.image_loop.show()
-        # get img path
-        self.image_loop.set_from_file(storage.get_icon_path('repeat'))
-        self.image_loop.set_size_request(48, -1)
-        # add image
-        _loop_box.pack_start(self.image_loop, expand=False, fill=True)
-        # create label
-        _label = gtk.Label(_('Repeat'))
-        _label.set_alignment(0, 0.5)
-        _label.show()
-        # add label
-        _loop_box.pack_start(_label, expand=True, fill=True)
-        # create checkbox
-        self.toggle_loop = gtk.ToggleButton()
-        # set tooltip
-        self.toggle_loop.set_tooltip_text(_('Loop (On/Off)'))
-        # ..
-        self.toggle_loop.show()
-        self.toggle_loop.add(_loop_box)
-        # set cb
-        self.toggle_loop.connect('toggled', _on_loop_click, self,
-                self.image_loop)
-
-    def _add_frame_sound(self):
-        # init frame
-        _frame_sound = gtk.Frame(label=_('Sound'))
-        _frame_sound.set_border_width(1)
-        # do show
-        _frame_sound.show()
-        # do add
-        self.main_box.pack_start(_frame_sound, expand=False, fill=True)
-        # vbox for the fram
-        _in_vbox = gtk.VBox(homogeneous=False, spacing=4)
-        _in_vbox.set_border_width(4)
-        # do show
-        _in_vbox.show()
-        # do add
-        _frame_sound.add(_in_vbox)
-        # add row sequence
-        self._init_sequence_box()
-        _in_vbox.pack_start(self.combo_box, expand=False, fill=True)
-        # add duration box
-        _in_vbox.pack_start(self._get_duration_box(), expand=False, fill=True)
-        # add loop button
-        self._init_loop_box()
-        _in_vbox.pack_start(self.toggle_loop, expand=False, fill=True)
-
-    def refresh(self, sequence_name=None, update_store=False):
-        # update parent
-        _seq_path, _current = Panel._refresh(self, 'sounds',
-                sequence_name=sequence_name, update_store=update_store)
-        # little check
-        if os.path.exists(_seq_path):
-            # shortcut
-            _activity = self.screen.toolbar.activity
-            if self.entry_duration is None:
-                pass
-            else:
-                # get current x and y
-                _d = self.story_keys.get_duration(self.sequence_name,
-                        _activity._thread._time, _current)
-                # update panel x y
-                self.entry_duration.set_text('%1d:%02d' % divmod(_d, 60))
-            # ...
-            _l = self.story_keys.get_loop(self.sequence_name,
-                    _activity._thread._time, _current)
-            # ...
-            self.toggle_loop.set_active(_l)
-            # update image
-            _stock_id = 'repeat_grey' if _l is True else 'repeat'
-            self.image_loop.set_from_file(storage.get_icon_path(_stock_id))
-        else:
-            pass
diff --git a/atoidejouer/ui/panel/__init__.py b/atoidejouer/ui/panel/__init__.py
new file mode 100644
index 0000000..114343d
--- /dev/null
+++ b/atoidejouer/ui/panel/__init__.py
@@ -0,0 +1,3 @@
+from atoidejouer.ui.panel.edit import PanelEdit
+from atoidejouer.ui.panel.notebook import PanelNotebook
+from atoidejouer.ui.panel.sound import PanelSound
diff --git a/atoidejouer/ui/panel/edit.py b/atoidejouer/ui/panel/edit.py
new file mode 100644
index 0000000..7da08d4
--- /dev/null
+++ b/atoidejouer/ui/panel/edit.py
@@ -0,0 +1,642 @@
+
+# python import
+import logging, os
+# ..
+from functools import partial
+from gettext import gettext as _
+
+# gtk import
+import gobject, gtk, glib
+
+# sugar import
+from sugar.activity import activity
+
+# atoidejouer import
+from atoidejouer.db import story
+from atoidejouer.tools import config, image, storage, ui
+
+# get application logger
+logger = logging.getLogger('atoidejouer')
+
+
+COLOR_GREY_DARK   = ui.get_color(0.5, 0.5, 0.5)
+COLOR_GREY_LIGHT  = ui.get_color(0.75, 0.75, 0.75)
+COLOR_GREY_WHITE  = ui.get_color(0.85, 0.85, 0.85)
+COLOR_WHITE       = ui.get_color(1.0, 1.0, 1.0)
+
+
+def _set_bg(widget):
+    # bg
+    widget.modify_bg(gtk.STATE_NORMAL, COLOR_GREY_WHITE)
+    widget.modify_bg(gtk.STATE_PRELIGHT, COLOR_GREY_WHITE)
+    widget.modify_bg(gtk.STATE_ACTIVE, COLOR_WHITE)
+    # fg
+    widget.modify_fg(gtk.STATE_NORMAL, COLOR_WHITE)
+
+
+def _on_position_clicked(widget, panel, move, value):
+    # shortcut
+    _activity = panel.screen.toolbar.activity
+    if _activity._thread._pause is False\
+    or panel.key is None:
+        pass
+    elif move == 'x':
+        panel.key.x += value
+    elif move == 'y':
+        panel.key.y += value
+    else:
+        raise Exception('[ui.panel] _on_position_clicked"\
+                " - invalid position move: %s' % move)
+    # DB update
+    story.DB().update(panel.key)
+    # update panel entries
+    panel.entry_x.set_text(str(panel.key.x))
+    panel.entry_y.set_text(str(-panel.key.y))
+    # refresh scene
+    panel.screen.scene.refresh(key=panel.key)
+
+
+def _on_layout_clicked(widget, panel, move):
+    # shortcut
+    _activity = panel.screen.toolbar.activity
+    # get max
+    _layout_max = story.DB().get_layout_max()
+    # do nothing
+    if _activity._thread._pause is False\
+    or panel.key is None:
+        return
+    # layout factory
+    elif move == 'move_up_up':
+        panel.key.layout = _layout_max
+    elif move == 'move_up':
+        panel.key.layout = panel.key.layout + 1\
+                if panel.key.layout < _layout_max else _layout_max
+    elif move == 'move_down':
+        panel.key.layout = panel.key.layout - 1\
+                if panel.key.layout > 0 else 0
+    elif move == 'move_down_down':
+        panel.key.layout = 0
+    else:
+        raise Exception('[ui.panel] _on_layout_clicked"\
+                " - invalid layout move: %s' % move)
+    # DB update
+    story.DB().update(panel.key)
+    # update entry
+    panel.entry_layout.set_text(str(panel.key.layout))
+    # refresh scene
+    panel.screen.scene.refresh()
+
+
+def _on_time_clicked(widget, panel, value):
+    # shortcut
+    _activity = panel.screen.toolbar.activity
+    # little check
+    if _activity._thread._pause is False\
+    or panel.key is None:
+        return
+    else:
+        _time = _activity._thread._time
+    # time factory
+    _time += value
+    panel.key.time = 0 if _time < 0 else _time
+    # DB update
+    story.DB().update(panel.key)
+    # entry update
+    panel.time_entry.set_text('%1d:%02d' % divmod(_time, 60))
+    # update thread time
+    _activity._thread.set_time(time_=_time)
+
+
+def _on_remove_key_clicked(widget, panel):
+    # shortcut
+    _activity = panel.screen.toolbar.activity
+    if _activity._thread._pause is False\
+    or panel.key is None:
+        return
+    else:
+        # delete
+        story.DB()._del(panel.key)
+        # empty key
+        panel.key = None
+        # refresh scene
+        panel.screen.scene.refresh()
+        # and reset panel
+        panel.refresh()
+
+
+def _on_duration_clicked(widget, panel, value):
+    # shortcut
+    _activity = panel.screen.toolbar.activity
+    _duration_max = story.DB().get_duration_max()
+    # do nothing
+    if _activity._thread._pause is False\
+    or panel.key is None:
+        pass
+    elif panel.key.duration + value < 0:
+        panel.key.duration = 0
+    elif panel.key.duration + value > _duration_max:
+        panel.key.duration = _duration_max
+    else:
+        panel.key.duration += value
+    # DB update
+    story.DB().update(panel.key)
+    # update panel entries
+    panel.entry_duration.set_text(
+            '%1d:%02d' % divmod(panel.key.duration, 60))
+
+
+def _on_loop_click(toggle, panel, image):
+    # update image
+    _stock_id = 'repeat_grey' if toggle.get_active() is True else 'repeat'
+    image.set_from_file(storage.get_icon_path(_stock_id))
+    # shortcut
+    _activity = panel.screen.toolbar.activity
+    # do nothing
+    if _activity._thread._pause is False\
+    or panel.key is None:
+        return
+    else:
+        panel.key.loop = toggle.get_active()
+        # DB update
+        story.DB().update(panel.key)
+
+
+def _get_next_time(panel, factor):
+    # get the current frame
+    _time = 0.0 if panel.screen.toolbar.activity._thread is None\
+            else panel.screen.toolbar.activity._thread._time
+    # get rate
+    _rate = config.Config().get_rate_value()
+    # next time
+    _next = _time + factor * _rate
+    # get max
+    _max = panel.screen.toolbar.activity._number_of_keys - 1
+    if _next < _max:
+        # ok!
+        return _next
+    else:
+        # return max + pause
+        return _max
+
+
+def _get_previous_time(panel, factor):
+    # get the current frame
+    _time = 0.0 if panel.screen.toolbar.activity._thread is None\
+            else panel.screen.toolbar.activity._thread._time
+    # get rate
+    _rate = config.Config().get_rate_value()
+    # previous time
+    _previous = _time - factor * _rate
+    # ..
+    if _previous < 0:
+        # return min
+        return 0
+    else:
+        # ok
+        return _previous
+
+
+def _on_key_press(widget, event, parent):
+    # ..
+    _keyval = event.keyval
+    _name = gtk.gdk.keyval_name(_keyval)
+    _mod = gtk.accelerator_get_label(_keyval, event.state)
+    # ..
+    if parent.screen != parent.screen.toolbar.activity.get_current_screen():
+        return
+    # key factory
+    elif panel.screen.toolbar.name == 'edit':
+        # POSITION
+        if _name == 'Left' and _mod.startswith('Ctrl+'): # big left
+            _on_position_clicked(widget, parent, 'x', -10)
+        elif _name == 'Left': # left
+            _on_position_clicked(widget, parent, 'x', -1)
+        elif _name == 'Right' and _mod.startswith('Ctrl+'): # big right
+            _on_position_clicked(widget, parent, 'x', 10)
+        elif _name == 'Right': # right
+            _on_position_clicked(widget, parent, 'x', 1)
+        elif _name == 'Up' and _mod.startswith('Ctrl+'): # big top
+            _on_position_clicked(widget, parent, 'y', -10)
+        elif _name == 'Up': # top
+            _on_position_clicked(widget, parent, 'y', -1)
+        elif _name == 'Down' and _mod.startswith('Ctrl+'): # big bottom
+            _on_position_clicked(widget, parent, 'y', 10)
+        elif _name == 'Down': # bottom
+            _on_position_clicked(widget, parent, 'y', 1)
+        # LAYOUT
+        elif _name == 'Page_Up' and _mod.startswith('Ctrl+'):
+            _on_layout_clicked(widget, parent, 'move_up_up')
+        elif _name == 'Page_Up':
+            _on_layout_clicked(widget, parent, 'move_up')
+        elif _name == 'Page_Down' and _mod.startswith('Ctrl+'):
+            _on_layout_clicked(widget, parent, 'move_down_down')
+        elif _name == 'Page_Down':
+            _on_layout_clicked(widget, parent, 'move_down')
+        # TIME
+        elif _name == 'plus' and _mod.startswith('Ctrl+'):
+            _on_time_clicked(widget, parent, 10)
+        elif _name == 'plus':
+            _on_time_clicked(widget, parent, 1)
+        elif _name == 'minus' and _mod.startswith('Ctrl+'):
+            _on_time_clicked(widget, parent, -10)
+        elif _name == 'minus':
+            _on_time_clicked(widget, parent, -1)
+        # DELETE
+        elif _name == 'BackSpace':
+            _on_remove_key_clicked(widget, parent)
+        # IMAGE
+        # TODO ...
+    # IN EVERY CASE
+    if parent.screen.toolbar.name in ['edit', 'story']:
+        # shortcut
+        _thread = parent.screen.toolbar.activity._thread
+        # ..
+        if _name == 'space': # play right
+            # 
+            _time = _get_next_time(parent, 1)
+            # 
+            _thread.set_time(time_=_time, pause=True)
+        elif _name == 'space' and _mod.startswith('Ctrl+'): # play left
+            # 
+            _time = _get_previous_time(parent, 1)
+            # 
+            _thread.set_time(time_=_time, pause=True)
+        # PLAY
+        elif _name == 'Return':
+            # ..
+            if _thread._pause is True:
+                parent.screen.toolbar.play()
+                _thread.play()
+            # ..
+            else:
+                parent.screen.toolbar.pause()
+                _thread.pause()
+        else:
+            pass
+        # avoid propagation for rendering issue
+        widget.emit_stop_by_name('key-press-event')
+
+
+class PanelEdit(gtk.Frame):
+
+    def __init__(self, screen):
+        # init parent
+        gtk.Frame.__init__(self)
+        self.set_shadow_type(gtk.SHADOW_NONE)
+        # set screen
+        self.screen = screen
+        # key var
+        self.key = None
+        # get mode
+        self._mode = config.Config().get('activity>mode')
+        self._conf = config.Config().get('mode>%s' % self._mode, type_=list)
+        # ...
+        self.set_size_request(298, screen.scene._screen_height)
+        # do show
+        self.show()
+        # init vars
+        self._store = None
+        self.sequence_name = None
+        # ..
+        self.time_entry = None
+        # add vbox to the panel for sub frames
+        self.main_box = gtk.VBox(homogeneous=False, spacing=0)
+        # do show
+        self.main_box.show()
+        # add it to the panel
+        self.add(self.main_box)
+        # ..
+        self.__init_handler()
+        # main vars
+        self.entry_layout = None
+        # ..
+        self.entry_x = None
+        self.entry_y = None
+        # add specific
+        self._frame_layout = None
+        self._frame_position = None
+        self._add_frame_layout()
+        self._add_frame_position()
+        # init sound fields
+        self.entry_duration = None
+        self.toggle_loop = None
+        self.image_loop = None
+        # add specific
+        self._frame_sound = None
+        self._add_frame_sound()
+        # add common
+        self._frame_time = None
+        self._frame_remove = None
+        self.add_frame_time()
+        self.add_frame_remove()
+
+    def __init_handler(self):
+        _activity = self.screen.toolbar.activity
+        _handler_id = _activity._handler_id
+        if _handler_id:
+            _activity.disconnect(_handler_id)
+        _activity._handler_id = _activity.connect('key-press-event',
+                _on_key_press, self)
+
+    def clear(self):
+        self.time_entry.set_text('')
+        self.entry_duration.set_text('')
+        self.toggle_loop.set_active(False)
+        # ..
+        self.entry_layout.set_text('')
+        self.entry_x.set_text('')
+        self.entry_y.set_text('')
+
+    def _get_pixbuf(self, graphic_name, dir_='graphics'):
+        # get the image path
+        _graphic_path = storage.get_image_path(graphic_name, dir_=dir_)
+        # return pix and path
+        return image.get_pixbuf(_graphic_path, 48, 36), _graphic_path
+
+    def __refresh_image(self):
+        # hide frame sound
+        self._frame_sound.hide()
+        # shortcut
+        _activity = self.screen.toolbar.activity
+        # set layout value
+        self.entry_layout.set_text(str(self.key.layout))
+        # set x value
+        self.entry_x.set_text(str(self.key.x))
+        # set y value
+        self.entry_y.set_text(str(-self.key.y))
+        # hide frame image
+        self._frame_layout.show()
+        self._frame_position.show()
+
+    def __refresh_sound(self):
+        # hide frame image
+        self._frame_layout.hide()
+        self._frame_position.hide()
+        # update duration value
+        self.entry_duration.set_text('%1d:%02d' % divmod(self.key.duration, 60))
+        # update loop value
+        self.toggle_loop.set_active(self.key.loop==1)
+        # update image
+        _stock_id = 'repeat_grey' if self.key.loop==1 else 'repeat'
+        self.image_loop.set_from_file(storage.get_icon_path(_stock_id))
+        # show frame sound
+        self._frame_sound.show()
+
+    def refresh(self, key=None):
+        self.key = key
+        if not key:
+            """
+            self._frame_layout.hide()
+            self._frame_position.hide()
+            self._frame_sound.hide()
+            self._frame_time.hide()
+            self._frame_remove.hide()
+            """
+            self.show_all()
+            return self.clear()
+        elif key.type == 'image':
+            self.__refresh_image()
+        elif key.type == 'sound':
+            self.__refresh_sound()
+        else:
+            raise Exception('[ui.panel] refresh - invalid key: %s' % key)
+        # update common time value
+        self.time_entry.set_text(
+                '%1d:%02d' % divmod(key.time, 60))
+        self._frame_time.show()
+        self._frame_remove.show()
+
+    def __get_time_button(self, name, value, tooltip_text):
+        _button = ui.get_button(stock_id=name)
+        _button.set_tooltip_text(tooltip_text)
+        _button.connect('clicked', _on_time_clicked, self, value)
+        return _button
+
+    def add_frame_time(self):
+        # init frame
+        self._frame_time = gtk.Frame(label=_('Time'))
+        self._frame_time.set_border_width(1)
+        # do show
+        self._frame_time.show()
+        # do add
+        self.main_box.pack_start(self._frame_time, expand=False, fill=True)
+        # get over/under spin buttons
+        _time_box = gtk.HBox(homogeneous=False, spacing=4)
+        _time_box.set_border_width(4)
+        # before ..
+        _time_box.pack_start(self.__get_time_button('go_left', -10,
+            _('Play Before (10 Frames)')), expand=False, fill=True)
+        _time_box.pack_start(self.__get_time_button('go_left_small', -1,
+            _('Play Before (1 Frames)')), expand=False, fill=True)
+        # entry
+        self.time_entry = gtk.Entry()
+        # show
+        self.time_entry.show()
+        # set value - should be a string
+        self.time_entry.set_text('')
+        self.time_entry.set_alignment(1)
+        self.time_entry.set_property('editable', False)
+        # add entry
+        _time_box.pack_start(self.time_entry, expand=True, fill=True)
+        # .. after
+        _time_box.pack_start(self.__get_time_button('go_right_small', 1,
+            _('Play After (1 Frames)')), expand=False, fill=True)
+        _time_box.pack_start(self.__get_time_button('go_right', 10,
+            _('Play After (10 Frames)')), expand=False, fill=True)
+        # do add
+        self._frame_time.add(_time_box)
+
+    def add_frame_remove(self):
+        # init frame
+        self._frame_remove = gtk.Frame(label=_('Remove'))
+        self._frame_remove.set_border_width(1)
+        # do show
+        self._frame_remove.show()
+        # do add
+        self.main_box.pack_start(self._frame_remove, expand=False, fill=True)
+        # init container
+        _in_vbox = gtk.HBox(homogeneous=True, spacing=4)
+        _in_vbox.set_border_width(4)
+        # do add
+        self._frame_remove.add(_in_vbox)
+        # prepare remove sequence button
+        _rm_key_button = ui.get_button(label=_('Key'),
+                stock_id='remove_item', width=48, padding=(12, 0))
+        _rm_key_button.set_tooltip_text(_('Remove Key'))
+        # set cb
+        _rm_key_button.connect('clicked', _on_remove_key_clicked, self)
+        # get remove image button
+        _in_vbox.pack_start(_rm_key_button, expand=False, fill=True)
+
+    def __get_layout_button(self, name, tooltip_text):
+        _button = ui.get_button(stock_id=name)
+        _button.set_tooltip_text(tooltip_text)
+        _button.connect('clicked', _on_layout_clicked, self, name)
+        return _button
+
+    def _add_frame_layout(self):
+        # init frame
+        self._frame_layout = gtk.Frame(label=_('Layout'))
+        self._frame_layout.set_border_width(1)
+        # do add
+        self.main_box.pack_start(self._frame_layout, expand=False, fill=True)
+        # vbox for the frame
+        _in_vbox = gtk.VBox(homogeneous=False, spacing=4)
+        _in_vbox.set_border_width(4)
+        # do add
+        self._frame_layout.add(_in_vbox)
+        # get over/under spin buttons
+        _layer_box = gtk.HBox(homogeneous=True, spacing=4)
+        # down ..
+        _layer_box.pack_start(self.__get_layout_button('move_down_down',
+            _('Layer to Bottom')), expand=False, fill=True)
+        _layer_box.pack_start(self.__get_layout_button('move_down',
+            _('Lower Layer')), expand=False, fill=True)
+        # entry
+        self.entry_layout = gtk.Entry()
+        # set value - should be a string
+        self.entry_layout.set_text("")
+        self.entry_layout.set_alignment(1)
+        self.entry_layout.set_property('editable', False)
+        # add entry
+        _layer_box.pack_start(self.entry_layout, expand=False, fill=True)
+        # .. up
+        _layer_box.pack_start(self.__get_layout_button('move_up',
+            _('Raise Layer')), expand=False, fill=True)
+        _layer_box.pack_start(self.__get_layout_button('move_up_up',
+            _('Layer to Top')), expand=False, fill=True)
+        # add row sequence
+        _in_vbox.pack_start(_layer_box, expand=True, fill=True)
+
+    def __get_position_button(self, name, move, value, tooltip_text):
+        # init button
+        _button = ui.get_button(stock_id=name)
+        _button.set_tooltip_text(tooltip_text)
+        _button.connect('clicked', _on_position_clicked, self, move, value)
+        return _button
+
+    def _add_frame_position(self):
+        # init frame
+        self._frame_position = gtk.Frame(label=_('Position'))
+        self._frame_position.set_border_width(1)
+        # do add
+        self.main_box.pack_start(self._frame_position, expand=False, fill=True)
+        # _vbox
+        _in_vbox = gtk.VBox(homogeneous=False, spacing=4)
+        _in_vbox.set_border_width(4)
+        # first _row
+        _in_vbox.pack_start(self.__get_position_button('y_up_up', 'y', -10,
+            _('Move Up by 10%')), expand=False, fill=False)
+        # second _row
+        _in_vbox.pack_start(self.__get_position_button('y_up', 'y', -1,
+            _('Move Up by 1%')), expand=False, fill=False)
+        # third _row
+        _row3 = gtk.HBox(homogeneous=False, spacing=4)
+        _row3.pack_start(self.__get_position_button('x_left_left', 'x', -10,
+            _('Move Left by 10%')), expand=False, fill=True)
+        _row3.pack_start(self.__get_position_button('x_left', 'x', -1,
+            _('Move Left by 1%')), expand=False, fill=True)
+        # prepare middle box
+        _middle_box = gtk.VBox(homogeneous=True, spacing=4)
+        # get entries
+        _entry_box_x = ui.get_entry(label='X')
+        _entry_box_y = ui.get_entry(label='Y')
+        # update main vars
+        self.entry_x = _entry_box_x.get_children()[1]
+        self.entry_y = _entry_box_y.get_children()[1]
+        # add entries to the box
+        _middle_box.pack_start(_entry_box_x, expand=False, fill=True)
+        _middle_box.pack_start(_entry_box_y, expand=False, fill=True)
+        _middle_box.set_size_request(64, -1)
+        # add the box to the row
+        _row3.pack_start(_middle_box, expand=True, fill=True)
+        _row3.pack_start(self.__get_position_button('x_right', 'x', 1,
+            _('Move Right by 1%')), expand=False, fill=True)
+        _row3.pack_start(self.__get_position_button('x_right_right', 'x', 10,
+            _('Move Right by 10%')), expand=False, fill=True)
+        # and add the third row
+        _in_vbox.pack_start(_row3, expand=False, fill=False)
+        # fourth _row
+        _in_vbox.pack_start(self.__get_position_button('y_down', 'y', 1,
+            _('Move Down by 1%')), expand=False, fill=False)
+        # fifth _row
+        _in_vbox.pack_start(self.__get_position_button('y_down_down', 'y', 10,
+            _('Move Down by 10%')), expand=False, fill=False)
+        # put it in
+        self._frame_position.add(_in_vbox)
+
+    def _get_time(self, value):
+        """Format the time value to display
+        """
+        return '%1d:%02d' % divmod(value, 60)
+
+    def __get_duration_button(self, name, value, tooltip_text):
+        _button = ui.get_button(stock_id=name)
+        _button.set_tooltip_text(tooltip_text)
+        _button.connect('clicked', _on_duration_clicked, self, value)
+        return _button
+
+    def _get_duration_box(self):
+        # get less/more spin buttons
+        _duration_box = gtk.HBox(homogeneous=True, spacing=4)
+        # down ..
+        _duration_box.pack_start(self.__get_duration_button('less', -10,
+            _('Duration -10s')), expand=False, fill=True)
+        _duration_box.pack_start(self.__get_duration_button('less_small', -1,
+            _('Duration -1s')), expand=False, fill=True)
+        # entry
+        self.entry_duration = gtk.Entry()
+        # set value - should be a string
+        self.entry_duration.set_text('') # self._get_time(0)
+        self.entry_duration.set_alignment(1)
+        self.entry_duration.set_property('editable', False)
+        self.entry_duration.set_size_request(64, -1)
+        # add entry
+        _duration_box.pack_start(self.entry_duration, expand=False, fill=True)
+        _duration_box.pack_start(self.__get_duration_button('more_small', 1,
+            _('Duration +1s')), expand=False, fill=True)
+        _duration_box.pack_start(self.__get_duration_button('more', 10,
+            _('Duration +10s')), expand=False, fill=True)
+        # return it
+        return _duration_box
+
+    def _init_loop_box(self):
+        # init row
+        _loop_box = gtk.HBox(homogeneous=False, spacing=4)
+        # create image
+        self.image_loop = gtk.Image()
+        # get img path
+        self.image_loop.set_from_file(storage.get_icon_path('repeat'))
+        self.image_loop.set_size_request(48, -1)
+        # add image
+        _loop_box.pack_start(self.image_loop, expand=False, fill=True)
+        # create label
+        _label = gtk.Label(_('Repeat'))
+        _label.set_alignment(0, 0.5)
+        # add label
+        _loop_box.pack_start(_label, expand=True, fill=True)
+        # create checkbox
+        self.toggle_loop = gtk.ToggleButton()
+        # set tooltip
+        self.toggle_loop.set_tooltip_text(_('Loop (On/Off)'))
+        self.toggle_loop.add(_loop_box)
+        # set cb
+        self.toggle_loop.connect('toggled', _on_loop_click, self,
+                self.image_loop)
+
+    def _add_frame_sound(self):
+        # init frame
+        self._frame_sound = gtk.Frame(label=_('Sound'))
+        self._frame_sound.set_border_width(1)
+        # do add
+        self.main_box.pack_start(self._frame_sound, expand=False, fill=True)
+        # vbox for the fram
+        _in_vbox = gtk.VBox(homogeneous=False, spacing=4)
+        _in_vbox.set_border_width(4)
+        # do add
+        self._frame_sound.add(_in_vbox)
+        # add duration box
+        _in_vbox.pack_start(self._get_duration_box(), expand=False, fill=True)
+        # add loop button
+        self._init_loop_box()
+        _in_vbox.pack_start(self.toggle_loop, expand=False, fill=True)
diff --git a/atoidejouer/ui/notebook.py b/atoidejouer/ui/panel/notebook.py
index 7f80670..63e1be3 100644
--- a/atoidejouer/ui/notebook.py
+++ b/atoidejouer/ui/panel/notebook.py
@@ -13,6 +13,7 @@ from sugar.activity import activity
 
 # atoidejouer import
 from atoidejouer.tools import image, storage, ui
+from atoidejouer.ui.panel import PanelEdit
 
 # get application logger
 logger = logging.getLogger('atoidejouer')
@@ -24,21 +25,36 @@ COLOR_GREY_WHITE  = ui.get_color(0.85, 0.85, 0.85)
 COLOR_WHITE       = ui.get_color(1.0, 1.0, 1.0)
 
 
+def _set_bg(widget):
+    # bg
+    widget.modify_bg(gtk.STATE_NORMAL, COLOR_GREY_WHITE)
+    widget.modify_bg(gtk.STATE_PRELIGHT, COLOR_GREY_WHITE)
+    widget.modify_bg(gtk.STATE_ACTIVE, COLOR_WHITE)
+    # fg
+    widget.modify_fg(gtk.STATE_NORMAL, COLOR_WHITE)
+
+
 def _cb_swicth_page(widget, page, page_num, notebook):
+    """
     if page_num == 1:
         notebook.remove_button.show()
     else:
         notebook.remove_button.hide()
         notebook.remove_label.hide()
+    """
     # get current child
     _child = widget.get_nth_page(page_num)
     # get current label
     _label = widget.get_tab_label(_child)
     # force white
-    glib.idle_add(partial(_label.modify_fg, gtk.STATE_NORMAL, COLOR_WHITE))
+    # glib.idle_add(partial(_label.modify_fg, gtk.STATE_NORMAL, COLOR_WHITE))
+    # _label.modify_fg(gtk.STATE_NORMAL, COLOR_WHITE)
+    _set_bg(_label)
 
 
 def _cb_cursor_changed(treeview, notebook, type_):
+    pass
+    """
     # get the current cursor and path
     _path, _column = treeview.get_cursor()
     # DEBUG
@@ -105,8 +121,8 @@ def _cb_cursor_changed(treeview, notebook, type_):
         notebook.current_sequence = _sequence_name
         # ..
         notebook.update_store_sequence()
-    else:
-        pass
+    """
+    """
     # .. add action - add column as no title
     if _column.get_title() is None:
         # get graphic name
@@ -123,9 +139,12 @@ def _cb_cursor_changed(treeview, notebook, type_):
             storage.sequence_save(notebook.screen.toolbar)
     else:
         pass
+    """
 
 
 def __remove_filename_from_sequence(type_, sequence, filename):
+    pass
+    """
     # little check
     if filename.strip() == '':
         # do nothing
@@ -154,9 +173,12 @@ def __remove_filename_from_sequence(type_, sequence, filename):
             _file.close()
             # ..
             return True
+    """
 
 
 def _on_button_click(button, notebook):
+    pass
+    """
     # get file path
     if notebook._type == 'graphics':
         _path = storage.get_image_path(notebook.current_item)
@@ -201,43 +223,39 @@ def _on_button_click(button, notebook):
     _screen.sequence_preview.remove_item(notebook.current_item)
     # avoid current
     notebook.current_item = None
+    """
 
 
-class ResourceNotebook(gtk.Frame):
+class PanelNotebook(gtk.Frame):
 
-    def __init__(self, screen, type_):
+    def __init__(self, screen):
         # init parent
         gtk.Frame.__init__(self)
         self.set_shadow_type(gtk.SHADOW_NONE)
-        # do show
-        self.show()
         # keep the screen
         self.screen = screen
-        # keep the type
-        self._type = type_
         # keep the current item
         self.current_item = None
-        self.current_sequence = None
         # ..
-        self.library_treeview = None
-        self.sequence_treeview = None
+        self._graphics_treeview = None
+        self._sounds_treeview = None
         # keep stores
-        self._store_sequence = None
         self._store_graphic = None
         self._store_sound = None
-        self._store_journal = None
         # init main box
         _main_box = gtk.VBox(homogeneous=False, spacing=0)
         _main_box.show()
         # ..
         self.add(_main_box)
+        # and the notebook
+        _main_box.pack_start(self._get_notebook(), expand=True, fill=True)
+        """
         # init remove button and label
         self.remove_button, self.remove_label = self._get_remove_button()
         # ..
-        _main_box.pack_start(self._get_notebook(), expand=True, fill=True)
-        # ..
         _main_box.pack_start(self.remove_button, expand=False, fill=True)
         _main_box.pack_start(self.remove_label, expand=False, fill=True)
+        """
 
     def _get_remove_button(self):
         # init button
@@ -257,72 +275,7 @@ class ResourceNotebook(gtk.Frame):
         # return it
         return _button, _label
 
-    def focus_current_seq(self, name=None):
-        # get seq names
-        _seq_names = [_n for _n, _p in storage.list_sequence_names(self._type)]
-        _seq_names.sort()
-        # ..
-        self.current_sequence = name\
-                if len(_seq_names) == 0 or name is not None\
-                else _seq_names[0]
-        if len(_seq_names) == 0:
-            return
-        else:
-            # ..
-            _index = 0 if self.current_sequence is None\
-                    or self.current_sequence not in _seq_names\
-                    else _seq_names.index(self.current_sequence)
-            # get the current cursor and path
-            self.sequence_treeview.set_cursor(_index)
-
-
-    def remove_current_row(self):
-        # get the current cursor and path
-        _path, _column = self.library_treeview.get_cursor()
-        # get model
-        _model = self.library_treeview.get_model()
-        # get resource info
-        _info = _model
-        # get iter
-        _iter = _model.get_iter(_path)
-        # and remove
-        _model.remove(_iter)
-
-    def update_store_sequence(self):
-        # .. 
-        if self.current_sequence is None:
-            return
-        else:
-            # ..
-            _filename = storage.get_sequence_first_graphic_name(
-                    self._type, self.current_sequence)
-            if _filename is None:
-                return
-            # set current
-            else:
-                self.screen.sequence_preview.set_current(_filename)
-
-    def _get_store_sequence(self):
-        # init store
-        if self._store_sequence is None:
-            self._store_sequence = gtk.ListStore(
-                    gtk.gdk.Pixbuf,
-                    gobject.TYPE_STRING,
-                    gobject.TYPE_PYOBJECT
-                    )
-        else:
-            self._store_sequence.clear()
-        # liste seq names
-        _seq_names = storage.list_sequence_names(self._type)
-        # ..
-        for _name, _path in _seq_names:
-            # ...
-            _pixbuf = image.get_sequence_first_graphic(self._type, _name)
-            # do update
-            self._store_sequence.append([_pixbuf, _name, _path])
-        # return the store
-        return self._store_sequence
-
+    """
     def _get_store_graphic(self):
         # init/reset store
         if self._store_graphic is None:
@@ -365,7 +318,9 @@ class ResourceNotebook(gtk.Frame):
                 continue
         # return the store
         return self._store_graphic
+    """
 
+    """
     def _get_store_sound(self):
         # init/reset store
         if self._store_sound is None:
@@ -409,13 +364,33 @@ class ResourceNotebook(gtk.Frame):
                 continue
         # return the store
         return self._store_sound
+    """
 
-    def __update_store(self, default_pix_path, **query):
+    def update_store(self, type_):
+        _store = self._store_graphic if type_ == 'graphics'\
+                else self._store_sound
+        # init/reset store
+        if _store is None:
+            _store = gtk.ListStore(
+                    gtk.gdk.Pixbuf,
+                    gobject.TYPE_STRING,
+                    gtk.gdk.Pixbuf,
+                    gobject.TYPE_PYOBJECT
+                    )
+        else:
+            _store.clear()
+        # app to get the journal entries
+        _a_name = 'paint' if type_=='graphics' else 'record'
+        # prepare icon path
+        _default_pix_path = storage.get_image_path(_a_name, dir_='data')
+        # mime type factory
+        _mime_type = 'image/png' if type_=='graphics' else 'audio/ogg'
         # update store
-        for _i in storage.list_info_from_journal(**query):
+        for _i in storage.list_info_from_journal(mime_type=_mime_type):
+            # DEBUG
+            logger.debug('[ui.panel.notebook] update_store - title: %s' % _i['title'])
             if _i['preview'] is None:
-                # ..
-                _pixbuf = image.get_pixbuf(default_pix_path, 64, 48)
+                _pixbuf = image.get_pixbuf(_default_pix_path, 64, 48)
             else:
                 # prepare preview
                 _pixbuf = storage.get_pixbuf_from_data(_i['preview'],
@@ -430,34 +405,9 @@ class ResourceNotebook(gtk.Frame):
                     }
             # do update
             _row = [_pixbuf, _i['title'], _pix_a, _store_info]
-            self._store_journal.append(_row)
-
-    def _get_store_journal(self):
-        # init/reset store
-        if self._store_journal is None:
-            self._store_journal = gtk.ListStore(
-                    gtk.gdk.Pixbuf,
-                    gobject.TYPE_STRING,
-                    gtk.gdk.Pixbuf,
-                    gobject.TYPE_PYOBJECT
-                    )
-        else:
-            self._store_journal.clear()
-        # app to get the journal entries
-        _a_name = 'paint' if self._type=='graphics' else 'record'
-        # prepare icon path
-        _default_pix_path = storage.get_image_path(_a_name, dir_='data')
-        # manage image from app for paint only
-        if self._type=='graphics':
-            self.__update_store(_default_pix_path, activity_name=_a_name)
-        else:
-            pass
+            _store.append(_row)
         # ..
-        _mime_type = 'image/png' if self._type=='graphics' else 'audio/ogg'
-        # import based on myme type
-        self.__update_store(_default_pix_path, mime_type=_mime_type)
-        # return the store
-        return self._store_journal
+        return _store
 
     def _get_treeview(self, type_=None):
         # ..
@@ -470,38 +420,26 @@ class ResourceNotebook(gtk.Frame):
         _col_add = gtk.TreeViewColumn()
         # set renderers
         _cell_pix = gtk.CellRendererPixbuf()
-        _cell_pix.set_property('height', 50)
+        _cell_pix.set_property('height', 48)
         _col_preview.pack_start(_cell_pix, expand=False)
         _col_preview.add_attribute(_cell_pix, 'pixbuf', 0)
+        _col_description.set_fixed_width(64)
         # ..
         _cell_text = gtk.CellRendererText()
-        _cell_text.set_property('height', 50)
+        _cell_text.set_property('height', 48)
         _col_description.pack_start(_cell_text, expand=False)
         _col_description.add_attribute(_cell_text, 'text', 1)
         _col_description.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
+        _col_description.set_fixed_width(220)
         # ..
-        if type_ == 'sequence':
-            _col_description.set_fixed_width(220)
-        else:
-            _col_description.set_fixed_width(250)
-            # ..
-            _cell_add = gtk.CellRendererPixbuf()
-            _cell_add.set_property('height', 50)
-            _col_add.pack_start(_cell_add, expand=False)
-            _col_add.add_attribute(_cell_add, 'pixbuf', 2)
-            _col_add.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
-            _col_add.set_fixed_width(30)
+        _cell_add = gtk.CellRendererPixbuf()
+        _cell_add.set_property('height', 48)
+        _col_add.pack_start(_cell_add, expand=False)
+        _col_add.add_attribute(_cell_add, 'pixbuf', 2)
+        _col_add.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
+        _col_add.set_fixed_width(28)
         # update store
-        if type_ == 'sequence':
-            _store = self._get_store_sequence()
-        elif type_ == 'graphics':
-            _store = self._get_store_graphic()
-        elif type_ == 'sounds':
-            _store = self._get_store_sound()
-        elif type_ == 'journal':
-            _store = self._get_store_journal()
-        else:
-            return None
+        _store = self.update_store(type_)
         # ensure sorting
         _store.set_sort_column_id(1, gtk.SORT_ASCENDING)
         # init treeview
@@ -514,61 +452,61 @@ class ResourceNotebook(gtk.Frame):
         # add columns
         _treeview.append_column(_col_preview)
         _treeview.append_column(_col_description)
-        # ..
-        if type_ == 'sequence':
-            pass
-        else:
-            _treeview.append_column(_col_add)
+        _treeview.append_column(_col_add)
         # ..
         _scrolled_win.add(_treeview)
         # return it
         return _scrolled_win
 
+    def _get_edit_panel(self):
+        # ..
+        _scrolled_win = gtk.ScrolledWindow()
+        _scrolled_win.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
+        _scrolled_win.show()
+        # ..
+        self._edit_panel = PanelEdit(self.screen)
+        _scrolled_win.add(self._edit_panel)
+        # ..
+        return _scrolled_win
+
+    def _get_label(self, text):
+        # create a label for the button
+        _label = gtk.Label(text)
+        _label.modify_fg(gtk.STATE_ACTIVE, COLOR_WHITE)
+        _label.show()
+        # ..
+        return _label
+
     def _get_notebook(self):
+        # get panel edit
+        _list0 = self._get_edit_panel()
+        _label0 = self._get_label(_('Edit'))
         # get list 1
-        _list1 = self._get_treeview(type_='sequence')
+        _list1 = self._get_treeview(type_='graphics')
+        _label1 = self._get_label(_('Graphics'))
         # keep sequence treeview
-        self.sequence_treeview = _list1.get_children()[0]
-        # create a label for the button
-        _label1 = gtk.Label(_('Sequences'))
-        # ...
-        _label1.modify_fg(gtk.STATE_ACTIVE, COLOR_WHITE)
-        # ...
-        _label1.show()
+        self._graphics_treeview = _list1.get_children()[0]
         # get list 2
-        _list2 = self._get_treeview(type_=self._type)
+        _list2 = self._get_treeview(type_='sounds')
+        _label2 = self._get_label(_('Sounds'))
         # keep library treeview
-        self.library_treeview = _list2.get_children()[0]
-        # create a label for the button
-        _label2 = gtk.Label(_('Library'))
-        # ...
-        _label2.modify_fg(gtk.STATE_ACTIVE, COLOR_WHITE)
-        # ...
-        _label2.show()
-        # get list 2
-        _list3 = self._get_treeview(type_='journal')
-        # create a label for the button
-        _label3 = gtk.Label(_('Journal'))
-        # ...
-        _label3.modify_fg(gtk.STATE_ACTIVE, COLOR_WHITE)
-        # ...
-        _label3.show()
+        self._sounds_treeview = _list2.get_children()[0]
         # init notebook
         _notebook = gtk.Notebook()
         _notebook.set_show_border(True)
         _notebook.set_border_width(2)
         _notebook.set_tab_pos(gtk.POS_TOP)
         _notebook.set_size_request(360, -1)
-        # ..
         _notebook.modify_bg(gtk.STATE_NORMAL, COLOR_GREY_DARK)
         _notebook.modify_bg(gtk.STATE_ACTIVE, COLOR_GREY_LIGHT)
-        # ..
         _notebook.connect('switch-page', _cb_swicth_page, self)
-        # ..
         _notebook.show()
         # add tabs
+        _notebook.append_page(_list0, _label0)
         _notebook.append_page(_list1, _label1)
         _notebook.append_page(_list2, _label2)
-        _notebook.append_page(_list3, _label3)
         # return it
         return _notebook
+
+    def refresh(self, key=None):
+        self._edit_panel.refresh(key=key)
diff --git a/atoidejouer/ui/panel/sound.py b/atoidejouer/ui/panel/sound.py
new file mode 100644
index 0000000..2a76332
--- /dev/null
+++ b/atoidejouer/ui/panel/sound.py
@@ -0,0 +1,198 @@
+
+# python import
+import logging
+# ..
+from functools import partial
+from gettext import gettext as _
+
+# gtk import
+import gtk
+
+# atoidejouer import
+from atoidejouer.db import story
+from atoidejouer.tools import image, sound, storage, ui
+
+# get application logger
+logger = logging.getLogger('atoidejouer')
+
+
+COLOR_GREY_DARK   = ui.get_color(0.5, 0.5, 0.5)
+COLOR_GREY_LIGHT  = ui.get_color(0.75, 0.75, 0.75)
+COLOR_GREY_WHITE  = ui.get_color(0.85, 0.85, 0.85)
+COLOR_WHITE       = ui.get_color(1.0, 1.0, 1.0)
+
+
+def _cb_on_click(button, panel_sound, key):
+    pass
+    # TODO - update edit panel
+
+
+def _cb_on_remove(panel_sound, key, button):
+    # udpate DB
+    story.DB()._del(key)
+    # TODO - update edit panel
+
+
+def _set_bg(widget):
+    widget.modify_bg(gtk.STATE_NORMAL, COLOR_GREY_LIGHT)
+    widget.modify_bg(gtk.STATE_PRELIGHT, COLOR_GREY_WHITE)
+    widget.modify_bg(gtk.STATE_ACTIVE, COLOR_WHITE)
+
+
+def _add_simple_button(parent, icon_name, tooltip, cb):
+    # .. remove button
+    _button = gtk.Button()
+    _button.show()
+    _button.set_tooltip_text(tooltip) # _('Remove ') + filename
+    # cb
+    _button.connect('clicked', cb) # cb, self, filename
+    # add
+    parent.pack_start(_button, expand=False, fill=False)
+    # add a remove image here
+    _img = gtk.Image()
+    _img.show()
+    _button.add(_img)
+    _button.set_size_request(30, 30)
+    # ..
+    _set_bg(_button)
+    # get pixbuff and update image
+    _path = storage.get_icon_path(icon_name)
+    _img.set_from_pixbuf(image.get_pixbuf(_path, 24, 24))
+
+
+class PanelSound(gtk.Frame):
+
+    def __init__(self, screen):
+        # init parent
+        gtk.Frame.__init__(self, _('Sounds'))
+        self.set_border_width(2)
+        self.set_size_request(-1, 140)
+        # do show
+        self.show()
+        # keep item list for the sequence
+        self.keys = list()
+        self._current = None
+        # prepare scrolled window
+        self._scrolled_window = gtk.ScrolledWindow()
+        self._scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_NEVER)
+        self._scrolled_window.show()
+        # a box
+        _hbox = gtk.HBox(homogeneous=False, spacing=2)
+        _hbox.show()
+        self.add(_hbox)
+        # a box
+        self._scrolled_hbox = gtk.HBox(homogeneous=False, spacing=2)
+        self._scrolled_hbox.show()
+        # add box in viewport
+        self._scrolled_window.add_with_viewport(self._scrolled_hbox)
+        # add
+        _hbox.add(self._scrolled_window)
+
+    def clear(self):
+        # keep item list for the sequence
+        self.keys = list()
+        self._current = None
+        # remove graphics
+        _children = self._scrolled_hbox.get_children()
+        for _c in _children:
+            _c.destroy()
+        # add box in viewport
+        self._scrolled_window.add_with_viewport(self._scrolled_hbox)
+
+    def get_current_pos(self):
+        # get children
+        _children = self._scrolled_hbox.get_children()
+        # get button index
+        return _children.index(self._current)\
+                if self._current in _children else 0
+
+    def set_current(self, key):
+        # get children
+        _children = self._scrolled_hbox.get_children()
+        # get new idx index
+        _index = self.keys.index(key)\
+                if key in self.keys else 1000
+        # little check
+        if _index < len(_children):
+            # update current
+            self._current = _children[_index]
+            # update toolbar frame entry
+            if self.screen.toolbar._frame_entry is None:
+                pass
+            else:
+                self.screen.toolbar._frame_entry.set_text(str(_index))
+        else:
+            pass
+
+    def number_of_items(self):
+        return len(self.keys)
+
+    def __remove(self, index):
+        # update list
+        if index + 1 <= len(self.items):
+            self.items.pop(index)
+            # clear current
+            self._current.destroy()
+            self._current = None
+        else:
+            pass
+
+    def remove_current(self):
+        # get button index
+        _index = self.get_current_pos()
+        # do remove
+        self.__remove(_index)
+
+    def remove_item(self, item_name):
+        # get children
+        _children = self._scrolled_hbox.get_children()
+        # get button index
+        _index = _children.index(item_name)\
+                if item_name in _children else 0
+        # do remove
+        self.__remove(_index)
+
+    def add_key(self, key):
+        # ..
+        _item_box = gtk.HBox(homogeneous=False, spacing=2)
+        _item_box.show()
+        self._scrolled_hbox.pack_start(_item_box, expand=False, fill=False)
+        # prepare vbox item
+        _vbox = gtk.VBox(homogeneous=False, spacing=2)
+        _vbox.show()
+        _item_box.pack_start(_vbox, expand=False, fill=False)
+        # simple add
+        if key in self.keys:
+            pass
+        elif pos is None:
+            self.keys.append(key)
+        # add at pos
+        else:
+            self.keys.insert(pos, key)
+            self._scrolled_hbox.reorder_child(_vbox, pos)
+        # init event box to manage color
+        _item = gtk.Button()
+        _vbox.pack_start(_item, expand=False, fill=True)
+        _set_bg(_item)
+        _item.set_size_request(96, 78)
+        _item.set_relief(gtk.RELIEF_NONE)
+        _item.connect('clicked', _cb_on_click, self, key)
+        _item.show()
+        # add a picture here
+        _item_img = gtk.Image()
+        _item_img.show()
+        _item.add(_item_img)
+        # get pixbuff and update image
+        _path = storage.get_image_path('sound', dir_='data')
+        _item_img.set_from_pixbuf(image.get_pixbuf(_path, 96, 62))
+        # add label
+        _label = gtk.Label(key.name)
+        _label.show()
+        # ...
+        _vbox.pack_start(_label, expand=False, fill=True)
+        # remove button
+        _add_simple_button(_item_box, 'less_small', _('Remove ') + key.name,
+                partial(_cb_on_remove, self, key))
+
+    def refresh(self):
+        pass
diff --git a/atoidejouer/ui/preview.py b/atoidejouer/ui/preview.py
deleted file mode 100644
index 9769a86..0000000
--- a/atoidejouer/ui/preview.py
+++ /dev/null
@@ -1,608 +0,0 @@
-
-# python import
-import logging, os, threading, time
-# ..
-from functools import partial
-from gettext import gettext as _
-
-# gtk import
-import gobject, gtk, glib
-
-# sugar import
-from sugar.activity import activity
-
-# atoidejouer import
-from atoidejouer.tools import image, sound, storage, ui
-
-# get application logger
-logger = logging.getLogger('atoidejouer')
-
-
-COLOR_GREY_DARK   = ui.get_color(0.5, 0.5, 0.5)
-COLOR_GREY_LIGHT  = ui.get_color(0.75, 0.75, 0.75)
-COLOR_GREY_WHITE  = ui.get_color(0.85, 0.85, 0.85)
-COLOR_WHITE       = ui.get_color(1.0, 1.0, 1.0)
-
-
-def _cb_on_click(button, sequence_preview, filename):
-    # update current
-    sequence_preview.set_current(filename)
-    # udpate preview
-    sequence_preview.screen.item_preview.set_item(filename)
-    # get current item pos
-    _pos = sequence_preview
-    # get toolbar frame entry
-    if sequence_preview.screen.toolbar._frame_entry is None:
-        pass
-    else:
-        # get current
-        _current = str(sequence_preview.get_current_pos())
-        # update toolbar entry
-        sequence_preview.screen.toolbar._frame_entry.set_text(_current)
-
-
-def _cb_on_remove(sequence_preview, filename, button):
-    # set current first
-    sequence_preview.set_current(filename)
-    # udpate sequence preview
-    sequence_preview.remove_current()
-    # seq name
-    _seq_name = sequence_preview.screen.notebook.current_sequence
-    # ..
-    _keys = sequence_preview.screen.toolbar.activity.graphic_keys\
-            if sequence_preview.screen.toolbar.name == 'graphics_add'\
-            else sequence_preview.screen.toolbar.activity.sound_keys
-    # remove from keys
-    _keys.remove_filename_from_all(_seq_name, filename)
-    # update sequence file
-    storage.sequence_save(sequence_preview.screen.toolbar)
-
-
-def _cb_on_move(sequence_preview, move, button):
-    # ..
-    _current = sequence_preview.get_current_pos()
-    if move == 'left':
-        _current -= 1
-    else:
-        _current += 1
-    # get max value
-    _max = sequence_preview.number_of_items() - 1
-    # prepare value
-    _new_val = None
-    if _current > _max:
-        _current = _max
-    elif _current < 0:
-        _current = 0
-    # reset max just in case
-    else:
-        pass
-    # update entry
-    if sequence_preview.screen.toolbar._frame_entry is None:
-        pass
-    else:
-        sequence_preview.screen.toolbar._frame_entry.set_text(str(_current))
-    # update sequence
-    sequence_preview.move_current(_current)
-
-
-def _set_preview_buttom_bg(button):
-    # set color
-    button.modify_bg(gtk.STATE_NORMAL, COLOR_GREY_LIGHT)
-    button.modify_bg(gtk.STATE_PRELIGHT, COLOR_GREY_WHITE)
-    button.modify_bg(gtk.STATE_ACTIVE, COLOR_WHITE)
-
-
-def _add_simple_button(parent, icon_name, tooltip, cb):
-    # .. remove button
-    _button = gtk.Button()
-    _button.show()
-    _button.set_tooltip_text(tooltip) # _('Remove ') + filename
-    # cb
-    _button.connect('clicked', cb) # cb, self, filename
-    # add
-    parent.pack_start(_button, expand=False, fill=False)
-    # add a remove image here
-    _img = gtk.Image()
-    _img.show()
-    _button.add(_img)
-    _button.set_size_request(30, 30)
-    # ..
-    _set_preview_buttom_bg(_button)
-    # get pixbuff and update image
-    _path = storage.get_icon_path(icon_name)
-    _img.set_from_pixbuf(image.get_pixbuf(_path, 24, 24))
-
-class SequencePreview(gtk.Frame):
-
-    def __init__(self, screen, type_):
-        # keep type
-        self._type = type_
-        # specific frame name
-        _frame_name = _('Sequence Graphics') if self._type=='graphics'\
-                else _('Sequence Sounds')
-        # init parent
-        gtk.Frame.__init__(self, _frame_name)
-        self.set_border_width(2)
-        self.set_size_request(-1, 140)
-        # do show
-        self.show()
-        # keep the screen
-        self.screen = screen
-        self._current = None
-        # keep item list for the sequence
-        self.items = list()
-        # prepare scrolled window
-        self._scrolled_window = gtk.ScrolledWindow()
-        self._scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_NEVER)
-        self._scrolled_window.show()
-        # a box
-        _hbox = gtk.HBox(homogeneous=False, spacing=2)
-        _hbox.show()
-        self.add(_hbox)
-        # .. move left button
-        _add_simple_button(_hbox, 'go_left', _('Move Before'),
-                partial(_cb_on_move, self, 'left'))
-        # a box
-        self._scrolled_hbox = gtk.HBox(homogeneous=False, spacing=2)
-        self._scrolled_hbox.show()
-        # add box in viewport
-        self._scrolled_window.add_with_viewport(self._scrolled_hbox)
-        # add
-        _hbox.add(self._scrolled_window)
-        # .. move left button
-        _add_simple_button(_hbox, 'go_right', _('Move After'),
-                partial(_cb_on_move, self, 'right'))
-
-    def clear(self):
-        # ...
-        self._current = None
-        # keep item list for the sequence
-        self.items = list()
-        # remove graphics
-        _children = self._scrolled_hbox.get_children()
-        for _c in _children:
-            _c.destroy()
-        # remove image from preview
-        self.screen.item_preview.unset_item()
-        # add box in viewport
-        self._scrolled_window.add_with_viewport(self._scrolled_hbox)
-
-    def move_current(self, new_pos):
-        # get current pos
-        _current_pos = self.get_current_pos()
-        # little check
-        _filename = None
-        if _current_pos == new_pos:
-            return
-        # remove current
-        else:
-            # update list
-            _filename = self.items.pop(_current_pos)
-            self.items.insert(new_pos, _filename)
-            # ..
-            self._scrolled_hbox.reorder_child(self._current, new_pos)
-
-    def get_current_pos(self):
-        # get children
-        _children = self._scrolled_hbox.get_children()
-        # get button index
-        return _children.index(self._current)\
-                if self._current in _children else 0
-
-    def set_current(self, filename):
-        # get children
-        _children = self._scrolled_hbox.get_children()
-        # get new idx index
-        _index = self.items.index(filename)\
-                if filename in self.items else 1000
-        # little check
-        if _index < len(_children):
-            # update current
-            self._current = _children[_index]
-            # update preview
-            self.screen.item_preview.set_item(filename)
-            # update toolbar frame entry
-            if self.screen.toolbar._frame_entry is None:
-                pass
-            else:
-                self.screen.toolbar._frame_entry.set_text(str(_index))
-        # ??
-        else:
-            pass
-
-    def number_of_items(self):
-        return len(self._scrolled_hbox.get_children())
-
-    def __remove(self, index):
-        # update list
-        if index + 1 <= len(self.items):
-            self.items.pop(index)
-            # clear current
-            self._current.destroy()
-            self._current = None
-            # remove image from preview
-            self.screen.item_preview.unset_item()
-        else:
-            pass
-
-    def remove_current(self):
-        # get button index
-        _index = self.get_current_pos()
-        # do remove
-        self.__remove(_index)
-
-    def remove_item(self, item_name):
-        # get children
-        _children = self._scrolled_hbox.get_children()
-        # get button index
-        _index = _children.index(item_name)\
-                if item_name in _children else 0
-        # do remove
-        self.__remove(_index)
-
-    def add_item(self, filename, pos=None):
-        # ..
-        _item_box = gtk.HBox(homogeneous=False, spacing=2)
-        _item_box.show()
-        self._scrolled_hbox.pack_start(_item_box, expand=False, fill=False)
-        # prepare vbox item
-        _vbox = gtk.VBox(homogeneous=False, spacing=2)
-        _vbox.show()
-        _item_box.pack_start(_vbox, expand=False, fill=False)
-        # ...
-        # simple add
-        if filename in self.items:
-            pass
-        elif pos is None:
-            # update list
-            self.items.append(filename)
-        # add at pos
-        else:
-            # insert filename
-            self.items.insert(pos, filename)
-            # second pass .. reorder
-            self._scrolled_hbox.reorder_child(_vbox, pos)
-        # init event box to manage color
-        _item = gtk.Button()
-        _vbox.pack_start(_item, expand=False, fill=True)
-        # ..
-        _set_preview_buttom_bg(_item)
-        # set size
-        _item.set_size_request(96, 78)
-        # set relief
-        _item.set_relief(gtk.RELIEF_NONE)
-        # cb
-        _item.connect('clicked', _cb_on_click, self, filename)
-        # ..
-        _item.show()
-        # add a picture here
-        _item_img = gtk.Image()
-        _item_img.show()
-        _item.add(_item_img)
-        # get graphics path
-        if self._type == 'graphics':
-            _path = storage.get_image_path(filename)
-        elif self._type == 'sounds':
-            _path = storage.get_image_path('sound', dir_='data')
-        # ?? do nothing - TODO maybe log something
-        else:
-            _path = storage.get_image_path('blank', dir_='data')
-        # get pixbuff and update image
-        _item_img.set_from_pixbuf(image.get_pixbuf(_path, 96, 62))
-        # add label
-        _label = gtk.Label(filename)
-        # ...
-        _label.show()
-        # ...
-        _vbox.pack_start(_label, expand=False, fill=True)
-        # .. remove button
-        _add_simple_button(_item_box, 'less_small', _('Remove ') + filename,
-                partial(_cb_on_remove, self, filename))
-        # set current file nam eat the end
-        self.set_current(filename)
-
-
-class ItemPreview(gtk.VBox):
-
-    def __init__(self, screen, type_=None):
-        # init parent
-        gtk.VBox.__init__(self, homogeneous=False, spacing=0)
-        # keep screen and type
-        self.screen = screen
-        self._type = type_
-        # ..
-        self._screen_height = gtk.gdk.screen_height() - 140
-        self._screen_width = gtk.gdk.screen_width() - 360
-        # update size request
-        self.set_size_request(self._screen_width, self._screen_height)
-        # show self
-        self.show()
-
-    def unset_item(self):
-        for _c in self.get_children():
-            _c.destroy()
-
-    def __set_image(self, path):
-        # eventbox for the background
-        _ebox_image = gtk.EventBox()
-        _ebox_image.modify_bg(gtk.STATE_NORMAL, COLOR_WHITE)
-        _ebox_image.show()
-        # add a picture here
-        _image = gtk.Image()
-        # show
-        _image.show()
-        # ..
-        _ebox_image.add(_image)
-        # get pixbuff
-        _pixbuf = image.get_pixbuf(path, self._screen_width,
-                self._screen_height)
-        # set image
-        _image.set_from_pixbuf(_pixbuf)
-        # ...
-        self.pack_start(_ebox_image, expand=True, fill=True)
-
-    def __set_label(self, filename):
-        # eventbox for the background
-        _ebox_label = gtk.EventBox()
-        _ebox_label.modify_bg(gtk.STATE_NORMAL, COLOR_GREY_DARK)
-        _ebox_label.set_size_request(-1, 24)
-        _ebox_label.show()
-        # add label
-        _label = gtk.Label('<b>%s</b>' % filename)
-        _label.set_property('use-markup', True)
-        _ebox_label.modify_bg(gtk.STATE_NORMAL, COLOR_WHITE)
-        # ...
-        _label.show()
-        # ...
-        _ebox_label.add(_label)
-        # ...
-        self.pack_start(_ebox_label, expand=False, fill=True)
-
-    def set_item(self, filename):
-        # get path
-        if self._type == 'graphics':
-            _path = storage.get_image_path(filename)
-        elif self._type == 'sounds':
-            _path = storage.get_image_path('sound', dir_='data')
-        else:
-            _path = storage.get_image_path('blank', dir_='data')
-        # little check
-        if os.path.exists(_path):
-            # unset first
-            self.unset_item()
-            # ..
-            self.__set_image(_path)
-            # ..
-            self.__set_label(filename)
-            # OK
-            return True
-        else:
-            return False
-
-
-class ImagePreview(ItemPreview):
-
-    def __init__(self, screen):
-        # init parent
-        ItemPreview.__init__(self, screen, type_='graphics')
-
-
-def _on_stop(widget, sound_view, filename):
-    # update playing flag
-    sound_view.playing = False
-    # thread update
-    sound_view._thread.pause(stop=True)
-
-
-def _on_play_pause(widget, sound_view, filename):
-    # update playing flag
-    sound_view.playing = not sound_view.playing
-    # thread update
-    if sound_view.playing is True:
-        sound_view._thread.play()
-    else:
-        sound_view._thread.pause()
-
-
-def _cb_slider(widget, event, sound_view):
-    """action = 'press' or 'release'
-    """
-    # ...
-    if event.type == gtk.gdk.BUTTON_PRESS:
-        sound_view._thread._set_value = False
-    elif event.type == gtk.gdk.BUTTON_RELEASE:
-        # get time
-        _time = widget.get_value()
-        # udpate thread time
-        sound_view._thread._time = _time
-        sound_view._thread._set_value = True
-        # seek player
-        sound_view.player.seek(_time)
-    # ??
-    else:
-        pass
-
-
-def _cb_format_value(widget, value, sound_view):
-    """Format the slider value to display
-    """
-    # return formated value
-    return '%1d:%02d' % divmod(value, 60)
-
-
-class ThreadPlayer(threading.Thread):
-
-    def __init__(self, sound_view, rate=1):
-        # init parent
-        threading.Thread.__init__(self)
-        # main flag
-        self._die = False
-        self._pause = True
-        self._set_value = True
-        # main vars
-        self.sound_view = sound_view
-        self._rate = rate
-        self._time = 0
-        self._max = 0
-        # start right now
-        self.start()
-
-    def set_max(self, max_):
-        self._max = max_
-
-    def pause(self, stop=False):
-        self._pause = True
-        # ..
-        self.sound_view.switch_button()
-        # ..
-        if self.sound_view._adjustment is None:
-            return
-        # reset time on stop
-        elif stop is True:
-            # reset time
-            self._time = 0
-            # update slider
-            self.sound_view._adjustment.set_value(0)
-            # stop player
-            self.sound_view.player.stop()
-            # ..
-            self.sound_view._slider.set_property('sensitive', False)
-        else:
-            # pause player
-            self.sound_view.player.pause()
-
-    def play(self):
-        self._pause = False
-        # pause player
-        self.sound_view.player.play()
-        # seek player
-        self.sound_view.player.seek(self._time)
-        # ..
-        self.sound_view.switch_button()
-        # ..
-        self.sound_view._slider.set_property('sensitive', True)
-
-    def kill(self):
-        # stop player
-        self.sound_view.player.stop()
-        # ..
-        self._die = True
-
-    def run(self):
-        # ...
-        while self._die is False:
-            # ...
-            time.sleep(self._rate)
-            if self._time >= self._max:
-                self.pause(stop=True)
-            # do pause
-            elif self._pause is False:
-                # just in case
-                self._time += self._rate
-                # ...
-                if self.sound_view._adjustment is None:
-                    pass
-                # ...
-                elif self._set_value is True:
-                    self.sound_view._adjustment.set_value(self._time)
-                else:
-                    pass
-            # .. do nothing
-            else:
-                pass
-
-class SoundPreview(ItemPreview):
-
-    def __init__(self, screen):
-        # init parent
-        ItemPreview.__init__(self, screen, type_='sounds')
-        # ..
-        self.playing = False
-        # ..
-        self.player = sound.Player()
-        # ..
-        self._adjustment = None
-        self._slider = None
-        self._button_play = None
-        self._thread = ThreadPlayer(self)
-
-    def switch_button(self):
-        # image stuff
-        _img = gtk.Image()
-        _img.show()
-        # ..
-        _stock_id = 'pause' if self.playing is True else 'play'
-        # update image
-        _img.set_from_file(storage.get_icon_path(_stock_id))
-        # update button
-        if self._button_play is None:
-            pass
-        else:
-            self._button_play.set_image(_img)
-
-    def unset_item(self):
-        # call parent
-        ItemPreview.unset_item(self)
-        # stop player
-        self.player.stop()
-
-    def __set_slider(self, filename):
-        # eventbox for the background
-        _ebox_player = gtk.EventBox()
-        _ebox_player.modify_bg(gtk.STATE_NORMAL, COLOR_WHITE)
-        _ebox_player.show()
-        # init player row
-        _hbox = gtk.HBox(homogeneous=False, spacing=12)
-        _hbox.set_border_width(8)
-        _hbox.set_size_request(-1, 64)
-        # ..
-        _hbox.show()
-        # ..
-        _ebox_player.add(_hbox)
-        # add button stop
-        _button_stop = ui.get_button(stock_id='stop')
-        # set cb
-        _button_stop.connect('clicked', _on_stop, self, filename)
-        _button_stop.modify_bg(gtk.STATE_NORMAL, COLOR_WHITE)
-        # ..
-        _hbox.pack_start(_button_stop, expand=False, fill=True)
-        # add button play
-        self._button_play = ui.get_button(stock_id='play')
-        # set cb
-        self._button_play.connect('clicked', _on_play_pause, self, filename)
-        self._button_play.modify_bg(gtk.STATE_NORMAL, COLOR_WHITE)
-        # ..
-        _hbox.pack_start(self._button_play, expand=False, fill=True)
-        # add slider
-        _timedelta = self.player.get_duration()
-        self._adjustment = gtk.Adjustment(0, 0, _timedelta.seconds, 1)
-        # udpate max
-        self._thread.set_max(_timedelta.seconds)
-        # ..
-        self._slider = gtk.HScale(self._adjustment)
-        self._slider.set_draw_value(True)
-        self._slider.set_digits(False)
-        self._slider.set_update_policy(gtk.UPDATE_CONTINUOUS)
-        self._slider.set_property('sensitive', False)
-        # manage cb
-        self._slider.connect('button-press-event', _cb_slider, self)
-        self._slider.connect('button-release-event', _cb_slider, self)
-        self._slider.connect('format-value', _cb_format_value, self)
-        # show
-        self._slider.show()
-        # ..
-        _hbox.pack_start(self._slider, expand=True, fill=True)
-        # ...
-        self.pack_start(_ebox_player, expand=False, fill=True)
-
-    def set_item(self, filename):
-        # call parent
-        if ItemPreview.set_item(self, filename):
-            # get sound path
-            _soundfile = storage.get_sound_path(filename)
-            # load player
-            self.player.load(_soundfile)
-            # add player
-            self.__set_slider(filename)
-        else:
-            pass
diff --git a/atoidejouer/ui/screens.py b/atoidejouer/ui/screens.py
deleted file mode 100644
index 551e662..0000000
--- a/atoidejouer/ui/screens.py
+++ /dev/null
@@ -1,1021 +0,0 @@
-
-# python import
-import logging, os, threading, time
-# ..
-from functools import partial
-# ..
-from gettext import gettext as _
-
-# gtk import
-import cairo, gobject, gtk, glib
-
-# graphics import
-from lib import graphics
-
-# sugar import
-from sugar.activity import activity
-from sugar.graphics.objectchooser import ObjectChooser
-
-#from hulahop.webview import WebView
-from hulahop.webview import WebView
-
-# atoidejouer import
-from atoidejouer.tools import config, image, key, sound, storage, ui
-from atoidejouer.ui.panel import PanelGraphics, PanelSounds
-from atoidejouer.ui.preview import ImagePreview, SequencePreview, SoundPreview
-from atoidejouer.ui.timeline import Timeline
-from atoidejouer.ui.notebook import ResourceNotebook
-# ..
-from atoidejouer.story.keys import StoryKeys
-
-# get application logger
-logger = logging.getLogger('atoidejouer')
-
-
-COLOR_BLACK       = ui.get_color(0.0, 0.0, 0.0)
-COLOR_GREY_DARK   = ui.get_color(0.5, 0.5, 0.5)
-COLOR_GREY_LIGHT  = ui.get_color(0.7, 0.7, 0.7)
-COLOR_GREY_WHITE  = ui.get_color(0.85, 0.85, 0.85)
-COLOR_WHITE       = ui.get_color(1.0, 1.0, 1.0)
-
-
-def _on_drag_finish(image, event, scene, sequence_name, frame, filename,
-        image_size):
-    # get align values
-    _a_x, _a_y = scene._reverse_x_y(image_size, (image.x, image.y))
-    # shortcut
-    _story_keys = scene._get_keys('graphics')
-    # update keys
-    _story_keys.set_align(sequence_name, frame, filename,
-            (_a_x, _a_y))
-    # update transitions
-    _story_keys.refresh(sequence_name)
-    # _story_keys.ask_clear()
-    # refresh scene with rounded values
-    scene.refresh(sequence_name=sequence_name)
-    # get current screen
-    _screen = scene.toolbar.activity.get_current_screen()
-    # update timeline
-    if hasattr(_screen, 'timeline'):
-        _screen.timeline.set_active_sequence(sequence_name)
-    else:
-        pass
-    # update position in panel
-    if hasattr(_screen, 'panel'):
-        _screen.panel.refresh()
-    else:
-        pass
-
-
-def _on_click(image, event, scene, sequence_name):
-    # get current screen
-    _screen = scene.toolbar.activity.get_current_screen()
-    # update timeline
-    if hasattr(_screen, 'timeline'):
-        _screen.timeline.set_active_sequence(sequence_name)
-    else:
-        pass
-    # update panel
-    if hasattr(_screen, 'panel'):
-        _screen.panel.refresh()
-    else:
-        pass
-
-
-class ScreenStory(graphics.Scene):
-
-    def __init__(self, toolbar, height_offset=0, width_offset=0,
-                 set_canvas=False, frame=None):
-        # ..
-        graphics.Scene.__init__(self)
-        self.background_color = "#ffffff"
-        # keep toolbar
-        self.toolbar = toolbar
-        # ..
-        self._set_canvas = set_canvas
-        # init image dicts
-        self.__sizes = dict()
-        self.__graphics = dict()
-        self.__sounds = dict()
-        self.__dd_signals = dict()
-        # init fullscreen flag
-        self.fullscreen = False
-        self._fullscreen_changed = True
-        # screen size first
-        self._height_offset = height_offset
-        self._width_offset = width_offset
-        # ..
-        self._screen_height = None
-        self._screen_width = None
-        # ...
-        self._refresh_screen_size()
-        # and show
-        self._show()
-
-    def _get_keys(self, type_):
-        # ..
-        if type_ == 'graphics':
-            return self.toolbar.activity.graphic_keys
-        else:
-            return self.toolbar.activity.sound_keys
-
-    def set_fullscreen(self, fullscreen):
-        # update fullscreen flag
-        self.fullscreen = fullscreen
-        # has changed
-        self._fullscreen_changed = True
-        # refresh
-        self.refresh()
-
-    def _refresh_screen_size(self):
-        # keep some info
-        self._screen_height = gtk.gdk.screen_height() - self._height_offset
-        self._screen_width = gtk.gdk.screen_width() - self._width_offset
-
-    def _check_clear(self):
-        # need clear
-        if self._get_keys('graphics').get_clear(self.toolbar.name) is True:
-            # hide previous
-            for _image in self.__graphics.values():
-                _image.visible = False
-                del _image
-            # ..
-            self.__graphics = dict()
-            # ..
-            self.__sizes = dict()
-            # done
-            self._get_keys('graphics').set_clear(self.toolbar.name, False)
-            # ..
-            return True
-        else:
-            return False
-
-    def refresh(self, sequence_name=None):
-        # get the current frame
-        _time = 0.0 if self.toolbar.activity._thread is None\
-                else self.toolbar.activity._thread._time
-        # get the current rate
-        _rate = config.Config().get_rate_value()
-        # clear ??
-        self._check_clear()
-        # ..
-        self._refresh_screen_size()
-        # ..
-        _currents = list()
-        # for each images
-        for _n in self._get_keys('graphics').get_names():
-            if sequence_name is None\
-            or sequence_name == _n:
-                # do move
-                _currents.append(self.__refresh_image(_n, _time, _rate))
-            else:
-                # just get code
-                _currents.append(self._get_current_code('graphics', _n,
-                    _time))
-        # draw mask
-        _currents.append(self.__refresh_default('mask'))
-        # hide previous
-        for _code, _image in self.__graphics.items():
-            if _code in _currents:
-                continue
-            else:
-                _image.visible = False
-        self.queue_draw()
-        # show first
-        if self._fullscreen_changed is True:
-            # disable changed flag
-            self._fullscreen_changed = False
-        else:
-            pass
-        # refresh sounds if playing
-        if self.toolbar.activity._thread is None:
-            pass
-        elif self.toolbar.activity._thread._pause is False:
-            # for each sound
-            for _n in self._get_keys('sounds').get_names():
-                if sequence_name is None\
-                or sequence_name == _n:
-                    # do move
-                    self.__refresh_sound(_n, _time)
-                else:
-                    # just get code
-                    _currents.append(self._get_current_code('sounds', _n,
-                        _time))
-        else:
-            # stop all
-            for _code, _sound in self.__sounds.items():
-                if self.toolbar.activity._thread._time == 0:
-                    _sound.stop()
-                else:
-                    _sound.pause()
-
-    def _update_w_h(self, filename):
-        if filename in self.__sizes:
-            pass
-        else:
-            # get graphics path
-            _path = storage.get_image_path(filename)
-            # get file size
-            _c, _w, _h = image.get_image_info(_path)
-            # ..
-            if (self.fullscreen is True\
-            or self._screen_width < 1024)\
-            and _w != 0:
-                _new_w = _w * self._screen_width / 1024
-                _new_h = _h * _new_w / _w
-            else:
-                _new_w = _w
-                _new_h = _h
-            # update size
-            self.__sizes[filename] = _new_w, _new_h, _w, _h
-        # return new values
-        return self.__sizes[filename]
-
-    def _reverse_x_y(self, size, position):
-        # ..
-        _w, _h = size
-        _x, _y = position
-        # ..
-        if self.fullscreen is True\
-        or self._screen_width < 1024:
-            _scene_with = self._screen_width
-            _scene_height = 516 * _scene_with / 1024.0
-        else:
-            _scene_with = 1024
-            _scene_height = 516
-        # update x
-        _a_x = _x - (self._screen_width - _w) / 2
-        _a_x = int(_a_x * 100.0 / _scene_with)
-        # update y
-        _a_y = _y - (self._screen_height - _h - 88) / 2
-        _a_y = int(_a_y * 100.0 / _scene_height)
-        # return it
-        return _a_x, _a_y
-
-    def _update_x_y(self, size, align):
-        # ..
-        _new_w, _new_h, _w, _h = size
-        _x, _y = align
-        # 
-        if self.fullscreen is True\
-        or self._screen_width < 1024:
-            _scene_with = self._screen_width
-            _scene_height = 516 * _scene_with / 1024.0
-        else:
-            _scene_with = 1024
-            _scene_height = 516
-        # update x
-        _new_x = ((self._screen_width - _new_w) / 2)
-        _new_x += int(_x * _scene_with / 100.0)
-        # update y
-        _new_y = ((self._screen_height - _new_h - 88) / 2)
-        _new_y += int(_y * _scene_height / 100.0)
-        # return it
-        return _new_x, _new_y
-
-    def __get_scene_size(self):
-        # 
-        if self.fullscreen is True\
-        or self._screen_width < 1024:
-            _scene_with = self._screen_width
-            _scene_height = 516 * _scene_with / 1024.0
-        else:
-            _scene_with = 1024
-            _scene_height = 516
-        # ..
-        return _scene_with, _scene_height
-
-    def __refresh_default(self, default_name):
-        _code = '__%s' % default_name
-        # ensure current image
-        if _code in self.__graphics:
-            # ..
-            self.__graphics[_code].visible = True
-        else:
-            _filename = '%s_default' % default_name
-            # ..
-            _align = (0, 0)
-            # get/update width and height
-            _size = self._update_w_h(_filename)
-            # ..
-            self.__graphics[_code] =\
-                    self.__update_drawing_area(_filename, _code, _size, _align)
-        # and return displayed code
-        return _code
-
-    def __get_transition_align(self, sequence_name, time, filename, rate):
-        # get align
-        _x, _y = self._get_keys('graphics').get_align(sequence_name,
-                int(time), filename)
-        # get transition ratio
-        _ratio = time - int(time)
-        if _ratio < rate:
-            return _x, _y
-        else:
-            _next_x, _next_y = self._get_keys('graphics').get_next_align(
-                    sequence_name, int(time), filename, use_transition=True)
-            # ...
-            _next_x = _x if _next_x is None else _x + (_next_x - _x) * _ratio
-            _next_y = _y if _next_y is None else _y + (_next_y - _y) * _ratio
-            # ..
-            return _next_x, _next_y
-
-    def _get_current_code(self, type_, sequence_name, time):
-        # get sequence filename
-        _current, _f_type, _k_type = self._get_keys(type_).get_current(
-                sequence_name, int(time))
-        # need current
-        if _current is None:
-            return None
-        else:
-            pass
-        # get sequence file codes
-        return self._get_keys(type_).get_code(
-                self.toolbar.name, sequence_name, _current)
-
-    def __refresh_image(self, sequence_name, time, rate):
-        # get sequence filename
-        _current, _f_type, _k_type = self._get_keys('graphics').get_current(
-                sequence_name, int(time))
-        # need current
-        if _current is None:
-            return None
-        else:
-            pass
-        # get sequence file codes
-        _code = self._get_keys('graphics').get_code(
-                self.toolbar.name, sequence_name, _current)
-        # current file code
-        _code = key.random_str() if _code is None else _code
-        # get/update width and height
-        _size = self._update_w_h(_current)
-        # get align
-        _align = self.__get_transition_align(sequence_name, time, _current,
-                rate)
-        # ensure current image
-        if _code in self.__graphics:
-            # ..
-            _image = self.__graphics[_code]
-            # update x, y
-            _image.x, _image.y = self._update_x_y(_size, _align)
-            # get z_order
-            _image.z_order = self._get_keys('graphics').get_layout(
-                    sequence_name)
-            # disconnect
-            if _code in self.__dd_signals:
-                _image.disconnect(self.__dd_signals[_code])
-            else:
-                pass
-            # scale
-            _new_w, _new_h, _w, _h = _size
-            # re-connect
-            _h_id = _image.connect('on-drag-finish', _on_drag_finish, self,
-                    sequence_name, int(time), _current, (_new_w, _new_h))
-            # ..
-            self.__dd_signals[_code] = _h_id
-            # ..
-            _image.visible = True
-        else:
-            # draggable for edit only
-            _draggable = self._set_canvas is False\
-                    and config.Config().use_dnd() is True
-            # ..
-            _image = self.__update_drawing_area(_current, _code, _size, _align,
-                    sequence_name=sequence_name, frame=int(time),
-                    draggable=_draggable)
-            # ..
-            self.__graphics[_code] = _image
-            # ..
-            self._get_keys('graphics').set_code(self.toolbar.name, sequence_name,
-                    _current, _code)
-        # and return displayed code
-        return _code
-
-    def __update_drawing_area(self, filename, code, size, align,
-            sequence_name=None, frame=None, draggable=False):
-        # get path
-        _path = storage.get_image_path(filename)
-        # update x, y
-        _x, _y = self._update_x_y(size, align)
-        # scale
-        _new_w, _new_h, _w, _h = size
-        # ..
-        if _w is None or _w == 0:
-            _scale = 1
-        else:
-            _scale = float(_new_w)/_w
-        # get z_order
-        if sequence_name is None:
-            _z_order = 1000
-        else:
-            _z_order = self._get_keys('graphics').get_layout(sequence_name)
-        # image
-        _image = graphics.Image(_path, x=_x, y=_y, scale_x=_scale,
-                scale_y=_scale, z_order=_z_order, draggable=draggable)
-        # connect drag
-        if self._set_canvas is True\
-        or config.Config().use_dnd() is False\
-        or self.toolbar.name != 'graphics':
-            pass
-        else:
-            # ..
-            _h_id = _image.connect('on-drag-finish', _on_drag_finish, self,
-                    sequence_name, frame, filename, (_new_w, _new_h))
-            # ..
-            self.__dd_signals[code] = _h_id
-        # connect on click
-        if sequence_name is None:
-            pass
-        else:
-            _image.connect('on-click', _on_click, self, sequence_name)
-        # do add
-        self.add_child(_image)
-        # ..
-        return _image
-
-    def __stop_unused_sounds(self, sequence_codes, current_code):
-        # hide previous
-        for _filename, _code in sequence_codes.items():
-            if _code != current_code\
-            and _code in self.__sounds:
-                self.__sounds[_code].pause()
-            else:
-                continue
-
-    def __refresh_sound(self, sequence_name, frame):
-        # get sequence file codes
-        _seq_codes = self._get_keys('sounds').get_sequence_codes(
-                self.toolbar.name, sequence_name)
-        # get sequence filename
-        _current, _f_type, _k_type = self._get_keys('sounds').get_current(
-                sequence_name, frame)
-        # need current
-        if _current is None:
-            return self.__stop_unused_sounds(_seq_codes, None)
-        else:
-            pass
-        # current file code
-        _code = _seq_codes[_current] if _current in _seq_codes else None
-        # ensure current image
-        if _code in self.__sounds:
-            _s = self.__sounds[_code]
-            if _k_type is None:
-                _s.pause()
-            elif _k_type == 'key':
-                # reset
-                _s.seek(0)
-                # play
-                _s.play()
-            else:
-                _s.seek(frame)
-                _s.play()
-        else:
-            # create new
-            if _k_type is None:
-                pass
-            else:
-                # ... TODO manage start time
-                _code, _sound = self._prepare_sound(sequence_name, _current)
-                _sound.play()
-        # ..
-        self.__stop_unused_sounds(_seq_codes, _code)
-
-    def _prepare_sound(self, sequence_name, current):
-        # get graphics path
-        _path = storage.get_sound_path(current)
-        # ensure/generate code
-        _filecode = key.random_str()
-        # update story key object
-        self._get_keys('sounds').set_code(self.toolbar.name, sequence_name,
-                current, _filecode)
-        # ...
-        _sound = sound.Player()
-        _sound.load(_path)
-        # update graphic dict
-        self.__sounds[_filecode] = _sound
-        # return image for futher use
-        return _filecode, _sound
-
-    def _show(self):
-        # first refresh
-        self.refresh()
-        # ..
-        self.show()
-        # update size request
-        self.set_size_request(self._screen_width, self._screen_height)
-        # update canvas
-        if self._set_canvas is True:
-            self.toolbar.activity.set_canvas(self)
-        else:
-            pass
-
-
-class Splash(graphics.Scene):
-
-    def __init__(self, toolbar):
-        # ..
-        graphics.Scene.__init__(self)
-        # ..
-        # self.background_color = "#ffffff"
-        # ..
-        self.__current = 0
-        # toolbar keep
-        self.toolbar = toolbar
-        # ..
-        self._image = None
-        # ..
-        if self.toolbar is None:
-            self._screen_height = None
-            self._screen_width = None
-        else:
-            # keep some info
-            self._screen_height = gtk.gdk.screen_height()
-            self._screen_width = gtk.gdk.screen_width()
-            # ..
-            self._show()
-
-    def _update_x_y(self, path):
-        # get file size
-        _c, _w, _h = image.get_image_info(path)
-        # update x
-        _x = ((self._screen_width - _w) / 2)
-        # update y
-        _y = ((self._screen_height - _h - 88) / 2)
-        # return it
-        return _x, _y
-
-    def _get_image(self):
-        # get path
-        _path = storage.get_image_path('splash', dir_='data')
-        # ..
-        _x, _y = self._update_x_y(_path)
-        # image
-        return graphics.Image(_path, x=_x, y=_y, draggable=False)
-
-    def _show(self):
-        # ..
-        self._image = self._get_image()
-        # do add
-        self.add_child(self._image)
-        # show
-        self.show()
-        # update toolbar
-        self.toolbar.activity.set_canvas(self)
-
-
-class ScreenEdit(gtk.HBox):
-
-    def __init__(self, toolbar):
-        # init parent
-        gtk.HBox.__init__(self, homogeneous=False, spacing=2)
-        # keep toolbar
-        self.toolbar = toolbar
-        # render
-        self.render()
-        # init main vars
-        self.scene = None
-        self.panel = None
-        self.timeline = None
-        # init top box
-        _vbox = gtk.VBox(homogeneous=False, spacing=2)
-        # do show
-        _vbox.show()
-        # init frames
-        self.add_scene(_vbox)
-        # ..
-        self.add_timelime(_vbox)
-        # add top box
-        self.pack_start(_vbox, expand=False, fill=False)
-        # ..
-        self.add_panel()
-        # and show
-        self._show()
-
-    def add_scene(self, vbox):
-        # get scene
-        self.scene = ScreenStory(self.toolbar, height_offset=148,
-                width_offset=300)
-        # add it
-        vbox.pack_start(self.scene, expand=True, fill=True)
-
-    def add_timelime(self, vbox):
-        # init time line and keep it
-        self.timeline = Timeline(self)
-        # add it
-        vbox.pack_start(self.timeline, expand=True, fill=True)
-
-    def add_panel(self):
-        pass
-
-    def render(self):
-        pass
-
-    def _show(self):
-        # show self
-        self.show_all()
-        # ..
-        self.toolbar.story_keys.check_sequences()
-        # ..
-        self.scene.refresh()
-        # get current time
-        self.timeline.refresh()
-        # update toolbar
-        self.toolbar.activity.set_canvas(self)
-
-
-class ScreenEditGraphics(ScreenEdit):
-
-    def __init__(self, toolbar):
-        # init parent
-        ScreenEdit.__init__(self, toolbar)
-
-    def add_panel(self):
-        # init time line and keep it
-        self.panel = PanelGraphics(self)
-        # add it
-        self.pack_start(self.panel, expand=False, fill=False)
-
-
-class ScreenEditSounds(ScreenEdit):
-
-    def __init__(self, toolbar):
-        # init parent
-        ScreenEdit.__init__(self, toolbar)
-
-    def add_panel(self):
-        # init time line and keep it
-        self.panel = PanelSounds(self)
-        # add it
-        self.pack_start(self.panel, expand=False, fill=False)
-
-
-class ScreenBrowser(gtk.HBox):
-
-    def __init__(self, toolbar, type_):
-        # init parent
-        gtk.HBox.__init__(self, homogeneous=False, spacing=2)
-        # keep toolbar
-        self.toolbar = toolbar
-        # keep name
-        self._type = type_
-        # keep previews
-        self.notebook = None
-        self.item_preview = None
-        self.sequence_preview = None
-        # add it
-        self._add_previews()
-        self._add_notebook()
-        # do show
-        self._show()
-
-    def _add_previews(self):
-        # init top box
-        _vbox = gtk.VBox(homogeneous=False, spacing=4)
-        # do show
-        _vbox.show()
-        # add the box
-        self.pack_start(_vbox, expand=True, fill=True)
-        # init frame
-        self.item_preview = ImagePreview(self) if self._type == 'graphics'\
-                else SoundPreview(self)
-        # add it
-        _vbox.pack_start(self.item_preview, expand=True, fill=True)
-        # ..
-        self.sequence_preview = SequencePreview(self, self._type)
-        # add it
-        _vbox.pack_start(self.sequence_preview, expand=False, fill=True)
-
-    def _add_notebook(self):
-        # init
-        self.notebook = ResourceNotebook(self, self._type)
-        # add
-        self.pack_start(self.notebook, expand=False, fill=True)
-
-    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, 'graphics')
-
-
-class ScreenBrowserSounds(ScreenBrowser):
-
-    def __init__(self, toolbar):
-        # init parent
-        ScreenBrowser.__init__(self, toolbar, 'sounds')
-
-
-def _on_toggle_click(radio, screen, option, value):
-    # manage change state manually
-    _previous = config.Config().get('activity>%s' % option)
-    # remove screens to recreate them after
-    if screen._initialized is True\
-    and _previous != value:
-        # update
-        config.Config().set('activity>%s' % option, value)
-        # ...
-        if option in ['mode', 'dnd']:
-            screen._activity.remove_screen('graphics')
-            screen._activity.remove_screen('sounds')
-        else:
-            pass
-    else:
-        pass
-
-
-def _on_button_click(button, screen, name, msg_label, value):
-    if name == 'import':
-        try:
-            # int file chooser
-            _chooser = ObjectChooser(button.get_label(), screen,
-                    gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
-            # get chooser result
-            _r = _chooser.run()
-            # check result
-            if _r == gtk.RESPONSE_ACCEPT:
-                # get selected object
-                _object = _chooser.get_selected_object()
-                # do import
-                storage.import_project(screen._activity, _object.file_path,
-                        msg_label)
-            else:
-                pass
-        except Exception, e:
-            # ERROR
-            logger.error('[screens] _on_button_click - e: %s' % e)
-    elif name == 'export':
-        # do export
-        storage.export_project(screen._activity, msg_label, value)
-    else:
-        pass
-
-
-[
-    ADVANCED,
-    EASY,
-] = range(2)
-
-
-[
-    FASTER,
-    SMOOTH,
-    NORMAL,
-] = range(3)
-
-
-[
-    YES,
-    NO,
-] = range(2)
-
-
-class ScreenActivity(gtk.ScrolledWindow):
-
-    def __init__(self, activity_):
-        gtk.ScrolledWindow.__init__(self)
-        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
-        # keep toolbar
-        self._activity = activity_
-        # dummy flag
-        self._initialized = False
-        # keep result label
-        self.msg_label_import = None
-        self.msg_label_export = None
-        # init main box
-        self.__main_box = gtk.HBox(homogeneous=True, spacing=2)
-        self.__main_box.show()
-        # ..
-        self.add_with_viewport(self.__main_box)
-        # add left menu
-        self._group_mode = None
-        self._group_rate = None
-        self._group_dnd = None
-        self._add_left_part()
-        # ..
-        self.__main_box.pack_start(gtk.EventBox(), expand=False, fill=True)
-        # add right menu
-        self._add_right_part()
-        # do show
-        self._show()
-
-    def _get_title(self, text):
-        # init 
-        _label = gtk.Label()
-        # show
-        _label.show()
-        # set markup
-        _label.set_use_markup(True)
-        _label.set_markup('<span size="x-large" weight="heavy">%s</span>' % text)
-        # align
-        _label.set_padding(5, 5)
-        _label.set_alignment(0, 0.5)
-        # return it
-        return _label
-
-    def _get_toggle_box(self, group, option, value, text):
-        # create checkbox
-        _toggle = gtk.RadioButton(group=group, label=text)
-        _toggle.show()
-        # set current
-        _current = config.Config().get('activity>%s' % option)
-        _toggle.set_active(_current==value)
-        # set cb
-        _toggle.connect('toggled', _on_toggle_click, self, option, value)
-        # return it
-        return _toggle
-
-    def _get_button(self, name, text, stock_id, msg_label=None, value=None):
-        # init button
-        _button = ui.get_button(label=text, stock_id=stock_id, width=48,
-                padding=(10, 0))
-        _button.show()
-        # set cb
-        _button.connect('clicked', _on_button_click, self, name, msg_label,
-                value)
-        # return it
-        return _button
-
-    def _get_hidden_text(self):
-        # init 
-        _label = gtk.Label()
-        # set markup
-        _label.set_use_markup(True)
-        # align
-        _label.set_padding(5, 5)
-        _label.set_alignment(0, 0.5)
-        # return it
-        return _label
-
-    def _get_mode_part(self):
-        # ..
-        _vbox = gtk.VBox(homogeneous=False, spacing=5)
-        # border
-        _vbox.set_border_width(5)
-        # show
-        _vbox.show()
-        # add first part title
-        _vbox.pack_start(self._get_title(_('MODE')),
-                expand=False, fill=True)
-        # TODO - add some explanation text
-        # init easy option and use it as group
-        _easy = self._get_toggle_box(None, 'mode', 'easy', _('Easy'))
-        # add options
-        _vbox.pack_start(_easy, expand=False, fill=True)
-        # with easy as group
-        _vbox.pack_start(self._get_toggle_box(_easy, 'mode', 'advanced',
-            _('Advanced')), expand=False, fill=True)
-        # init group
-        self._group_mode = _easy.get_group()
-        # ..
-        return _vbox
-
-    def _get_rate_part(self):
-        # ..
-        _vbox = gtk.VBox(homogeneous=False, spacing=5)
-        # border
-        _vbox.set_border_width(5)
-        # show
-        _vbox.show()
-        # add first part title
-        _vbox.pack_start(self._get_title(_('FRAME RATE')),
-                expand=False, fill=True)
-        # TODO - add some explanation text
-        # init normal option and use it as group
-        _normal = self._get_toggle_box(None, 'rate', 'normal', _('Normal'))
-        # add options
-        _vbox.pack_start(_normal, expand=False, fill=True)
-        # with easy as group
-        _vbox.pack_start(self._get_toggle_box(_normal, 'rate', 'smooth',
-            _('Smooth')), expand=False, fill=True)
-        # with easy as group
-        _vbox.pack_start(self._get_toggle_box(_normal, 'rate', 'faster',
-            _('Faster')), expand=False, fill=True)
-        # init group
-        self._group_rate = _normal.get_group()
-        # ..
-        return _vbox
-
-    def _get_dnd_part(self):
-        # ..
-        _vbox = gtk.VBox(homogeneous=False, spacing=5)
-        # border
-        _vbox.set_border_width(5)
-        # show
-        _vbox.show()
-        # add first part title
-        _vbox.pack_start(self._get_title(_('DRAG\'N\'DROP')),
-                expand=False, fill=True)
-        # TODO - add some explanation text
-        # init normal option and use it as group
-        _no = self._get_toggle_box(None, 'dnd', 'no', _('Don\'t Use Drag\'n\'Drop'))
-        # add options
-        _vbox.pack_start(_no, expand=False, fill=True)
-        # with easy as group
-        _vbox.pack_start(self._get_toggle_box(_no, 'dnd', 'yes',
-            _('Use Drag\'n\'Drop')), expand=False, fill=True)
-        # init group
-        self._group_dnd = _no.get_group()
-        # ..
-        return _vbox
-
-    def _add_left_part(self):
-        # ..
-        _vbox = gtk.VBox(homogeneous=False, spacing=5)
-        # border
-        _vbox.set_border_width(5)
-        # show
-        _vbox.show()
-        # add
-        self.__main_box.pack_start(_vbox, expand=False, fill=True)
-        # add part choices
-        _vbox.pack_start(self._get_mode_part(),
-                expand=False, fill=True)
-        # add rate choices
-        _vbox.pack_start(self._get_rate_part(),
-                expand=False, fill=True)
-        # add dnd choices
-        _vbox.pack_start(self._get_dnd_part(),
-                expand=False, fill=True)
-
-    def _get_export_part(self):
-        # ..
-        _vbox = gtk.VBox(homogeneous=False, spacing=5)
-        # border
-        _vbox.set_border_width(5)
-        # show
-        _vbox.show()
-        # add first part title
-        _vbox.pack_start(self._get_title(_('IMPORT')),
-                expand=False, fill=True)
-        self.msg_label_import = self._get_hidden_text()
-        _vbox.pack_start(self._get_button('import', _('Choose a File'),
-            'import', msg_label=self.msg_label_import), expand=False, fill=True)
-        _vbox.pack_start(self.msg_label_import, expand=False, fill=True)
-        # add first part title
-        _vbox.pack_start(self._get_title(_('EXPORT')),
-                expand=False, fill=True)
-        self.msg_label_export = self._get_hidden_text()
-        # list the possible medias
-        for _media in os.listdir('/media'):
-            # current path
-            _path = os.path.join('/media', _media)
-            # should be a dir
-            if os.path.isdir(_path):
-                # set export button text
-                _button_text = _('Export to') + ' "' + _media + '"'
-                # init button
-                _button = self._get_button('export', _button_text, 'export',
-                        msg_label=self.msg_label_export, value=_media)
-                # add button
-                _vbox.pack_start(_button, expand=False, fill=True)
-            else:
-                continue
-        # add label
-        _vbox.pack_start(self.msg_label_export, expand=False, fill=True)
-        # ..
-        return _vbox
-
-    def _add_right_part(self):
-        # ..
-        _vbox = gtk.VBox(homogeneous=False, spacing=5)
-        # border
-        _vbox.set_border_width(5)
-        # show
-        _vbox.show()
-        # add
-        self.__main_box.pack_start(_vbox, expand=False, fill=True)
-        # add first part title
-        _vbox.pack_start(self._get_export_part(),
-                expand=False, fill=True)
-
-    def _show(self):
-        self._initialized = True
-        # show all
-        self.show()
-        # update toolbar
-        self._activity.set_canvas(self)
-
-
-class ScreenHelp(WebView):
-
-    def __init__(self, activity_):
-        WebView.__init__(self)
-        # keep activity
-        self._activity = activity_
-        # load html content
-        self.load_uri(storage.get_html_path('help'))
-        # do show
-        self._show()
-
-    def _show(self):
-        # show all
-        self.show()
-        # update toolbar
-        self._activity.set_canvas(self)
diff --git a/atoidejouer/ui/screens/__init__.py b/atoidejouer/ui/screens/__init__.py
new file mode 100644
index 0000000..0df38d5
--- /dev/null
+++ b/atoidejouer/ui/screens/__init__.py
@@ -0,0 +1,5 @@
+from atoidejouer.ui.screens.splash      import Splash
+from atoidejouer.ui.screens.activity    import ScreenActivity
+from atoidejouer.ui.screens.story       import ScreenStory
+from atoidejouer.ui.screens.edit        import ScreenEdit
+from atoidejouer.ui.screens.help        import ScreenHelp
diff --git a/atoidejouer/ui/screens/activity.py b/atoidejouer/ui/screens/activity.py
new file mode 100644
index 0000000..24f72e4
--- /dev/null
+++ b/atoidejouer/ui/screens/activity.py
@@ -0,0 +1,231 @@
+# python import
+import logging, os
+# ..
+from gettext import gettext as _
+
+# gtk import
+import gtk
+
+# atoidejouer import
+from atoidejouer.tools import config, ui
+
+# get application logger
+logger = logging.getLogger('atoidejouer')
+
+
+def _on_toggle_click(radio, screen, option, value):
+    # manage change state manually
+    _previous = config.Config().get('activity>%s' % option)
+    # remove screens to recreate them after
+    if screen._initialized is True\
+    and _previous != value:
+        # update
+        config.Config().set('activity>%s' % option, value)
+        # ...
+        if option in ['mode', 'dnd']:
+            screen._activity.remove_screen('graphics')
+            screen._activity.remove_screen('sounds')
+        else:
+            pass
+    else:
+        pass
+
+
+def _on_button_click(button, screen, name, msg_label, value):
+    if name == 'import':
+        try:
+            # int file chooser
+            _chooser = ObjectChooser(button.get_label(), screen,
+                    gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
+            # get chooser result
+            _r = _chooser.run()
+            # check result
+            if _r == gtk.RESPONSE_ACCEPT:
+                # get selected object
+                _object = _chooser.get_selected_object()
+                # do import
+                storage.import_project(screen._activity, _object.file_path,
+                        msg_label)
+            else:
+                pass
+        except Exception, e:
+            # ERROR
+            logger.error('[screens] _on_button_click - e: %s' % e)
+    elif name == 'export':
+        # do export
+        storage.export_project(screen._activity, msg_label, value)
+    else:
+        pass
+
+
+[
+    ADVANCED,
+    EASY,
+] = range(2)
+
+[
+    FASTER,
+    SMOOTH,
+    NORMAL,
+] = range(3)
+
+[
+    YES,
+    NO,
+] = range(2)
+
+
+class ScreenActivity(gtk.ScrolledWindow):
+
+    def __init__(self, activity_):
+        gtk.ScrolledWindow.__init__(self)
+        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        # keep toolbar
+        self._activity = activity_
+        # dummy flag
+        self._initialized = False
+        # keep result label
+        self.msg_label_import = None
+        self.msg_label_export = None
+        # init main box
+        self.__main_box = gtk.HBox(homogeneous=True, spacing=2)
+        self.__main_box.show()
+        # ..
+        self.add_with_viewport(self.__main_box)
+        # add left menu
+        self._add_left_part()
+        # ..
+        self.__main_box.pack_start(gtk.EventBox(), expand=False, fill=True)
+        # add right menu
+        self._add_right_part()
+        # do show
+        self._show()
+
+    def _get_title(self, text):
+        # init 
+        _label = gtk.Label()
+        # show
+        _label.show()
+        # set markup
+        _label.set_use_markup(True)
+        _label.set_markup('<span size="x-large" weight="heavy">%s</span>' % text)
+        # align
+        _label.set_padding(5, 5)
+        _label.set_alignment(0, 0.5)
+        # return it
+        return _label
+
+    def _get_toggle_box(self, group, option, value, text):
+        # create checkbox
+        _toggle = gtk.RadioButton(group=group, label=text)
+        _toggle.show()
+        # set current
+        _current = config.Config().get('activity>%s' % option)
+        _toggle.set_active(_current==value)
+        # set cb
+        _toggle.connect('toggled', _on_toggle_click, self, option, value)
+        # return it
+        return _toggle
+
+    def _get_button(self, name, text, stock_id, msg_label=None, value=None):
+        # init button
+        _button = ui.get_button(label=text, stock_id=stock_id, width=48,
+                padding=(10, 0))
+        _button.show()
+        # set cb
+        _button.connect('clicked', _on_button_click, self, name, msg_label,
+                value)
+        # return it
+        return _button
+
+    def _get_hidden_text(self):
+        # init 
+        _label = gtk.Label()
+        # set markup
+        _label.set_use_markup(True)
+        # align
+        _label.set_padding(5, 5)
+        _label.set_alignment(0, 0.5)
+        # return it
+        return _label
+
+    def _get_mode_part(self):
+        # ..
+        _vbox = gtk.VBox(homogeneous=False, spacing=5)
+        # border
+        _vbox.set_border_width(5)
+        # show
+        _vbox.show()
+        # ..
+        return _vbox
+
+    def _add_left_part(self):
+        # ..
+        _vbox = gtk.VBox(homogeneous=False, spacing=5)
+        # border
+        _vbox.set_border_width(5)
+        # show
+        _vbox.show()
+        # add
+        self.__main_box.pack_start(_vbox, expand=False, fill=True)
+        # add part choices
+        _vbox.pack_start(self._get_mode_part(),
+                expand=False, fill=True)
+
+    def _get_export_part(self):
+        # ..
+        _vbox = gtk.VBox(homogeneous=False, spacing=5)
+        # border
+        _vbox.set_border_width(5)
+        # show
+        _vbox.show()
+        # add first part title
+        _vbox.pack_start(self._get_title(_('IMPORT')),
+                expand=False, fill=True)
+        self.msg_label_import = self._get_hidden_text()
+        _vbox.pack_start(self._get_button('import', _('Choose a File'),
+            'import', msg_label=self.msg_label_import), expand=False, fill=True)
+        _vbox.pack_start(self.msg_label_import, expand=False, fill=True)
+        # add first part title
+        _vbox.pack_start(self._get_title(_('EXPORT')),
+                expand=False, fill=True)
+        self.msg_label_export = self._get_hidden_text()
+        # list the possible medias
+        for _media in os.listdir('/media'):
+            # current path
+            _path = os.path.join('/media', _media)
+            # should be a dir
+            if os.path.isdir(_path):
+                # set export button text
+                _button_text = _('Export to') + ' "' + _media + '"'
+                # init button
+                _button = self._get_button('export', _button_text, 'export',
+                        msg_label=self.msg_label_export, value=_media)
+                # add button
+                _vbox.pack_start(_button, expand=False, fill=True)
+            else:
+                continue
+        # add label
+        _vbox.pack_start(self.msg_label_export, expand=False, fill=True)
+        # ..
+        return _vbox
+
+    def _add_right_part(self):
+        # ..
+        _vbox = gtk.VBox(homogeneous=False, spacing=5)
+        # border
+        _vbox.set_border_width(5)
+        # show
+        _vbox.show()
+        # add
+        self.__main_box.pack_start(_vbox, expand=False, fill=True)
+        # add first part title
+        _vbox.pack_start(self._get_export_part(),
+                expand=False, fill=True)
+
+    def _show(self):
+        self._initialized = True
+        # show all
+        self.show()
+        # update toolbar
+        self._activity.set_canvas(self)
diff --git a/atoidejouer/ui/screens/edit.py b/atoidejouer/ui/screens/edit.py
new file mode 100644
index 0000000..1d28baf
--- /dev/null
+++ b/atoidejouer/ui/screens/edit.py
@@ -0,0 +1,64 @@
+# python import
+import logging
+# ..
+from gettext import gettext as _
+
+# gtk import
+import gtk
+
+# sugar import
+from sugar.graphics.objectchooser import ObjectChooser
+
+# atoidejouer import
+from atoidejouer.tools import config, storage, ui
+from atoidejouer.ui.panel import PanelNotebook, PanelSound
+from atoidejouer.ui.screens import ScreenStory
+
+# get application logger
+logger = logging.getLogger('atoidejouer')
+
+
+class ScreenEdit(gtk.HBox):
+
+    def __init__(self, toolbar):
+        # init parent
+        gtk.HBox.__init__(self, homogeneous=False, spacing=2)
+        # keep toolbar
+        self.toolbar = toolbar
+        # init main vars
+        self.scene = None
+        self.panel_sound = None
+        self.panel_edit = None
+        # init top box
+        _vbox = gtk.VBox(homogeneous=False, spacing=2)
+        _vbox.show()
+        self.pack_start(_vbox, expand=False, fill=False)
+        # init frames
+        self.add_scene(_vbox)
+        self.add_panel_sound(_vbox)
+        self.add_panel_edit()
+        # and show
+        self._show()
+
+    def add_scene(self, vbox):
+        self.scene = ScreenStory(self.toolbar,
+                height_offset=148, width_offset=360)
+        vbox.pack_start(self.scene, expand=True, fill=True)
+
+    def add_panel_sound(self, vbox):
+        self.panel_sound = PanelSound(self)
+        vbox.pack_start(self.panel_sound, expand=False, fill=False)
+
+    def add_panel_edit(self):
+        self.panel_edit = PanelNotebook(self) # PanelEdit(self)
+        self.pack_start(self.panel_edit, expand=False, fill=False)
+
+    def _show(self):
+        # show self
+        self.show_all()
+        # refresh all
+        self.scene.refresh()
+        self.panel_sound.refresh()
+        self.panel_edit.refresh()
+        # update toolbar
+        self.toolbar.activity.set_canvas(self)
diff --git a/atoidejouer/ui/screens/help.py b/atoidejouer/ui/screens/help.py
new file mode 100644
index 0000000..32f8a2a
--- /dev/null
+++ b/atoidejouer/ui/screens/help.py
@@ -0,0 +1,34 @@
+# python import
+import logging
+# ..
+from gettext import gettext as _
+
+# gtk import
+import gtk
+
+# from hulahop.webview import WebView
+from hulahop.webview import WebView
+
+# atoidejouer import
+from atoidejouer.tools import storage
+
+# get application logger
+logger = logging.getLogger('atoidejouer')
+
+
+class ScreenHelp(WebView):
+
+    def __init__(self, activity_):
+        WebView.__init__(self)
+        # keep activity
+        self._activity = activity_
+        # load html content
+        self.load_uri(storage.get_html_path('help'))
+        # do show
+        self._show()
+
+    def _show(self):
+        # show all
+        self.show()
+        # update toolbar
+        self._activity.set_canvas(self)
diff --git a/atoidejouer/ui/screens/splash.py b/atoidejouer/ui/screens/splash.py
new file mode 100644
index 0000000..a822b74
--- /dev/null
+++ b/atoidejouer/ui/screens/splash.py
@@ -0,0 +1,72 @@
+# python import
+import logging
+# ..
+from functools import partial
+# ..
+from gettext import gettext as _
+
+# gtk import
+import gtk
+
+# graphics import
+from lib import graphics
+
+# atoidejouer import
+from atoidejouer.tools import image, storage
+
+# get application logger
+logger = logging.getLogger('atoidejouer')
+
+
+class Splash(graphics.Scene):
+
+    def __init__(self, toolbar):
+        # ..
+        graphics.Scene.__init__(self)
+        # ..
+        # self.background_color = "#ffffff"
+        # ..
+        self.__current = 0
+        # toolbar keep
+        self.toolbar = toolbar
+        # ..
+        self._image = None
+        # ..
+        if self.toolbar is None:
+            self._screen_height = None
+            self._screen_width = None
+        else:
+            # keep some info
+            self._screen_height = gtk.gdk.screen_height()
+            self._screen_width = gtk.gdk.screen_width()
+            # ..
+            self._show()
+
+    def _update_x_y(self, path):
+        # get file size
+        _c, _w, _h = image.get_image_info(path)
+        # update x
+        _x = ((self._screen_width - _w) / 2)
+        # update y
+        _y = ((self._screen_height - _h - 88) / 2)
+        # return it
+        return _x, _y
+
+    def _get_image(self):
+        # get path
+        _path = storage.get_image_path('splash', dir_='data')
+        # ..
+        _x, _y = self._update_x_y(_path)
+        # image
+        return graphics.Image(_path, x=_x, y=_y, draggable=False)
+
+    def _show(self):
+        # ..
+        self._image = self._get_image()
+        # do add
+        self.add_child(self._image)
+        # show
+        self.show()
+        # update toolbar
+        self.toolbar.activity.set_canvas(self)
+
diff --git a/atoidejouer/ui/screens/story.py b/atoidejouer/ui/screens/story.py
new file mode 100644
index 0000000..fb9e1e9
--- /dev/null
+++ b/atoidejouer/ui/screens/story.py
@@ -0,0 +1,486 @@
+# python import
+import logging
+# ..
+from gettext import gettext as _
+
+# gtk import
+import gtk
+
+# graphics import
+from lib import graphics
+
+# atoidejouer import
+from atoidejouer.db import story
+from atoidejouer.tools import config, image, sound, storage
+
+# get application logger
+logger = logging.getLogger('atoidejouer')
+
+
+def _on_drag_finish(image, event, scene, key, image_size):
+    # get align values
+    _a_x, _a_y = scene._reverse_x_y(image_size, (image.x, image.y))
+    # shortcut
+    # story_keys = scene._get_keys('graphics')
+    # update keys
+    # story_keys.set_align(sequence_name, frame, filename,
+    #         (_a_x, _a_y))
+    # update transitions
+    # story_keys.refresh(sequence_name)
+    # story_keys.ask_clear()
+    # refresh scene with rounded values
+    scene.refresh(key=key)
+    # get current screen
+    _screen = scene.toolbar.activity.get_current_screen()
+    # update position in panel
+    if hasattr(_screen, 'panel'):
+        _screen.panel.refresh()
+    else:
+        pass
+
+
+def _on_click(image, event, scene, key):
+    # get current screen
+    _screen = scene.toolbar.activity.get_current_screen()
+    # update panel
+    if hasattr(_screen, 'panel'):
+        _screen.panel.refresh()
+    else:
+        pass
+
+
+class ScreenStory(graphics.Scene):
+
+    def __init__(self, toolbar, height_offset=0, width_offset=0,
+                 set_canvas=False, clear=False):
+        # ..
+        graphics.Scene.__init__(self)
+        self.background_color = "#ffffff"
+        # keep toolbar
+        self.toolbar = toolbar
+        # ..
+        self._set_canvas = set_canvas
+        self._clear = False
+        # init image dicts
+        self.__sizes = dict()
+        self.__graphics = dict()
+        self.__sounds = dict()
+        self.__dd_signals = dict()
+        # init fullscreen flag
+        self.fullscreen = False
+        self._fullscreen_changed = True
+        # screen size first
+        self._height_offset = height_offset
+        self._width_offset = width_offset
+        # ..
+        self._screen_height = None
+        self._screen_width = None
+        # ...
+        self._refresh_screen_size()
+        # and show
+        self._show()
+
+    """
+    def _get_keys(self, type_):
+        # ..
+        if type_ == 'graphics':
+            return self.toolbar.activity.graphic_keys
+        else:
+            return self.toolbar.activity.sound_keys
+    """
+
+    def set_fullscreen(self, fullscreen):
+        # update fullscreen flag
+        self.fullscreen = fullscreen
+        # has changed
+        self._fullscreen_changed = True
+        # refresh
+        self.refresh()
+
+    def _refresh_screen_size(self):
+        # keep some info
+        self._screen_height = gtk.gdk.screen_height() - self._height_offset
+        self._screen_width = gtk.gdk.screen_width() - self._width_offset
+
+    def set_clear(self, clear):
+        self._clear = clear
+
+    def _check_clear(self):
+        # need clear
+        if self._clear is True:
+            # hide previous
+            for _image in self.__graphics.values():
+                _image.visible = False
+                del _image
+            # ..
+            self.__graphics = dict()
+            # ..
+            self.__sizes = dict()
+            # done
+            self._clear = False
+            return True
+        else:
+            return False
+
+    def refresh(self, key=None):
+        # get the current frame
+        _time = 0.0 if self.toolbar.activity._thread is None\
+                else self.toolbar.activity._thread._time
+        # get the current rate
+        _rate = config.Config().get_rate_value()
+        # clear ??
+        # self._check_clear()
+        # ..
+        self._refresh_screen_size()
+        # ..
+        _currents = list()
+        """
+        # for each images
+        for _n in self._get_keys('graphics').get_names():
+            if sequence_name is None\
+            or sequence_name == _n:
+                # do move
+                _currents.append(self.__refresh_image(_n, _time, _rate))
+            else:
+                # just get code
+                _currents.append(self._get_current_code('graphics', _n,
+                    _time))
+        """
+        # using DB
+        for _key in story.DB().get(story.Key(type='image', time=_time)):
+            # redraw only if necessary
+            if key is None or key.id == _k.id:
+                self.__refresh_image(key, _rate)
+            _currents.append(key.id)
+        # draw mask
+        _currents.append(self.__refresh_default('mask'))
+        # hide previous
+        for _id, _image in self.__graphics.items():
+            if _id not in _currents:
+                _image.visible = False
+        self.queue_draw()
+        # show first
+        if self._fullscreen_changed is True:
+            # disable changed flag
+            self._fullscreen_changed = False
+        else:
+            pass
+        # refresh sounds if playing
+        if self.toolbar.activity._thread is None:
+            pass
+        elif self.toolbar.activity._thread._pause is False:
+            """
+            # for each sound
+            for _n in self._get_keys('sounds').get_names():
+                if sequence_name is None\
+                or sequence_name == _n:
+                    # do move
+                    self.__refresh_sound(_n, _time)
+                else:
+                    # just get code
+                    _currents.append(self._get_current_code('sounds', _n,
+                        _time))
+            # using DB
+            for key in story.DB().get(story.Key(type='sound', time=_time)):
+                self.__refresh_sound(key)
+            """
+        else:
+            # stop all
+            for _id, _sound in self.__sounds.items():
+                if self.toolbar.activity._thread._time == 0:
+                    _sound.stop()
+                else:
+                    _sound.pause()
+
+    def _update_w_h(self, key):
+        if key.id in self.__sizes:
+            pass
+        else:
+            # get file size
+            _c, _w, _h = image.get_image_info(key.media)
+            # ..
+            if (self.fullscreen is True\
+            or self._screen_width < 1024)\
+            and _w != 0:
+                _new_w = _w * self._screen_width / 1024
+                _new_h = _h * _new_w / _w
+            else:
+                _new_w = _w
+                _new_h = _h
+            # update size
+            self.__sizes[key.id] = _new_w, _new_h, _w, _h
+        # return new values
+        return self.__sizes[key.id]
+
+    def _reverse_x_y(self, size, position):
+        # ..
+        _w, _h = size
+        _x, _y = position
+        # ..
+        if self.fullscreen is True\
+        or self._screen_width < 1024:
+            _scene_with = self._screen_width
+            _scene_height = 516 * _scene_with / 1024.0
+        else:
+            _scene_with = 1024
+            _scene_height = 516
+        # update x
+        _a_x = _x - (self._screen_width - _w) / 2
+        _a_x = int(_a_x * 100.0 / _scene_with)
+        # update y
+        _a_y = _y - (self._screen_height - _h - 88) / 2
+        _a_y = int(_a_y * 100.0 / _scene_height)
+        # return it
+        return _a_x, _a_y
+
+    def _update_x_y(self, size, align):
+        # ..
+        _new_w, _new_h, _w, _h = size
+        _x, _y = align
+        # 
+        if self.fullscreen is True\
+        or self._screen_width < 1024:
+            _scene_with = self._screen_width
+            _scene_height = 516 * _scene_with / 1024.0
+        else:
+            _scene_with = 1024
+            _scene_height = 516
+        # update x
+        _new_x = ((self._screen_width - _new_w) / 2)
+        _new_x += int(_x * _scene_with / 100.0)
+        # update y
+        _new_y = ((self._screen_height - _new_h - 88) / 2)
+        _new_y += int(_y * _scene_height / 100.0)
+        # return it
+        return _new_x, _new_y
+
+    def __get_scene_size(self):
+        # 
+        if self.fullscreen is True\
+        or self._screen_width < 1024:
+            _scene_with = self._screen_width
+            _scene_height = 516 * _scene_with / 1024.0
+        else:
+            _scene_with = 1024
+            _scene_height = 516
+        # ..
+        return _scene_with, _scene_height
+
+    def __refresh_default(self, default_name):
+        _code = '__%s' % default_name
+        # ensure current image
+        if _code in self.__graphics:
+            # ..
+            self.__graphics[_code].visible = True
+        else:
+            _filename = '%s_default' % default_name
+            _path     = storage.get_image_path(_filename)
+            _key      = story.Key(id=_code, media=_path, layer=0)
+            # ..
+            _align = (0, 0)
+            # get/update width and height
+            _size = self._update_w_h(_key)
+            # ..
+            self.__graphics[_key.id] =\
+                    self.__update_drawing_area(_key, _size, _align)
+        # and return displayed code
+        return _code
+
+    def __get_transition_align(self, key, rate):
+        # get align
+        _x, _y = key.x, key.y
+        # get transition ratio
+        _ratio = time - int(time)
+        if _ratio < rate:
+            return _x, _y
+        else:
+            """
+            _next_x, _next_y = self._get_keys('graphics').get_next_align(
+                    sequence_name, int(time), filename, use_transition=True)
+            """
+            _next_key = story.Key(name=key.name, type="image", time=(key.time+1),
+                    layer=key.layer)
+            _next_key = story.DB().get(_next_key)
+            _next_x, _next_y = _next_key.x, _next_key.y
+            _next_x = _x if _next_x is None else _x + (_next_x - _x) * _ratio
+            _next_y = _y if _next_y is None else _y + (_next_y - _y) * _ratio
+            return _next_x, _next_y
+
+    """
+    def _get_current_code(self, type_, sequence_name, time):
+        # get sequence filename
+        _current, _f_type, _k_type = self._get_keys(type_).get_current(
+                sequence_name, int(time))
+        # need current
+        if _current is None:
+            return None
+        else:
+            pass
+        # get sequence file codes
+        return self._get_keys(type_).get_code(
+                self.toolbar.name, sequence_name, _current)
+    """
+
+    def __refresh_image(self, key, rate):
+        """
+        # get sequence filename
+        _current, _f_type, _k_type = self._get_keys('graphics').get_current(
+                sequence_name, int(time))
+        # need current
+        if _current is None:
+            return None
+        else:
+            pass
+        # get sequence file codes
+        _code = self._get_keys('graphics').get_code(
+                self.toolbar.name, sequence_name, _current)
+        # current file code
+        _code = key.random_str() if _code is None else _code
+        """
+        # get/update width and height
+        _size = self._update_w_h(key)
+        # get align
+        _align = self.__get_transition_align(key, rate)
+        # ensure current image
+        if key.id in self.__graphics:
+            # ..
+            _image = self.__graphics[key.id]
+            # update x, y
+            _image.x, _image.y = self._update_x_y(_size, _align)
+            # get z_order
+            _image.z_order = key.layer
+            # disconnect
+            if _code in self.__dd_signals:
+                _image.disconnect(self.__dd_signals[key.id])
+            else:
+                pass
+            # scale
+            _new_w, _new_h, _w, _h = _size
+            # re-connect
+            _h_id = _image.connect('on-drag-finish', _on_drag_finish, self,
+                    key, (_new_w, _new_h))
+            # ..
+            self.__dd_signals[key.id] = _h_id
+            # ..
+            _image.visible = True
+        else:
+            # draggable for edit only
+            _draggable = self._set_canvas is False\
+                    and config.Config().use_dnd() is True
+            # ..
+            _image = self.__update_drawing_area(key, _size, _align,
+                    draggable=_draggable)
+            # ..
+            self.__graphics[key.id] = _image
+            """
+            self._get_keys('graphics').set_code(self.toolbar.name, sequence_name,
+                    _current, _code)
+            """
+
+    def __update_drawing_area(self, key, size, align, draggable=False):
+        # update x, y
+        _x, _y = self._update_x_y(size, align)
+        # scale
+        _new_w, _new_h, _w, _h = size
+        # ..
+        if _w is None or _w == 0:
+            _scale = 1
+        else:
+            _scale = float(_new_w)/_w
+        # image
+        _image = graphics.Image(key.media, x=_x, y=_y, scale_x=_scale,
+                scale_y=_scale, z_order=key.layer, draggable=draggable)
+        # connect drag
+        if self._set_canvas is True\
+        or config.Config().use_dnd() is False\
+        or self.toolbar.name != 'graphics':
+            pass
+        else:
+            _h_id = _image.connect('on-drag-finish', _on_drag_finish, self,
+                    key, (_new_w, _new_h))
+            self.__dd_signals[key.id] = _h_id
+        # connect on click
+        _image.connect('on-click', _on_click, self, key)
+        # do add
+        self.add_child(_image)
+        # ..
+        return _image
+
+    """
+    def __stop_unused_sounds(self, key):
+        sounds = story.DB().get(story.Key(name=key.name, type='sound'))
+        # hide previous
+        for _k in keys:
+            if _k.id != current\
+            and _k.id in self.__sounds:
+                self.__sounds[_k.id].pause()
+            else:
+                continue
+
+    def __refresh_sound(self, sequence_name, frame):
+        # get sequence file codes
+        _seq_codes = self._get_keys('sounds').get_sequence_codes(
+                self.toolbar.name, sequence_name)
+        # get sequence filename
+        _current, _f_type, _k_type = self._get_keys('sounds').get_current(
+                sequence_name, frame)
+        # need current
+        if _current is None:
+            return self.__stop_unused_sounds(_seq_codes, None)
+        else:
+            pass
+        # current file code
+        _code = _seq_codes[_current] if _current in _seq_codes else None
+        # ensure current image
+        if _code in self.__sounds:
+            _s = self.__sounds[_code]
+            if _k_type is None:
+                _s.pause()
+            elif _k_type == 'key':
+                # reset
+                _s.seek(0)
+                # play
+                _s.play()
+            else:
+                _s.seek(frame)
+                _s.play()
+        else:
+            # create new
+            if _k_type is None:
+                pass
+            else:
+                # ... TODO manage start time
+                _code, _sound = self._prepare_sound(sequence_name, _current)
+                _sound.play()
+        # ..
+        self.__stop_unused_sounds(_seq_codes, _code)
+
+    def _prepare_sound(self, sequence_name, current):
+        # get graphics path
+        _path = storage.get_sound_path(current)
+        # ensure/generate code
+        _filecode = key.random_str()
+        # update story key object
+        self._get_keys('sounds').set_code(self.toolbar.name, sequence_name,
+                current, _filecode)
+        # ...
+        _sound = sound.Player()
+        _sound.load(_path)
+        # update graphic dict
+        self.__sounds[_filecode] = _sound
+        # return image for futher use
+        return _filecode, _sound
+    """
+
+    def _show(self):
+        # first refresh
+        self.refresh()
+        # ..
+        self.show()
+        # update size request
+        self.set_size_request(self._screen_width, self._screen_height)
+        # update canvas
+        if self._set_canvas is True:
+            self.toolbar.activity.set_canvas(self)
+        else:
+            pass
diff --git a/atoidejouer/ui/timeline.py b/atoidejouer/ui/timeline.py
deleted file mode 100644
index f359bd2..0000000
--- a/atoidejouer/ui/timeline.py
+++ /dev/null
@@ -1,404 +0,0 @@
-
-# python import
-import logging, os
-# ..
-from functools import partial
-from gettext import gettext as _
-
-# gtk import
-import gtk, glib
-
-# atoidejouer import
-from atoidejouer.tools import storage, ui
-
-# get application logger
-logger = logging.getLogger('atoidejouer')
-
-
-def _on_title_clicked(widget, timeline, sequence_name):
-    # .. do update
-    timeline.set_active_sequence(sequence_name)
-
-
-def _on_key_clicked(widget, timeline, sequence_name, frame):
-    # shortcut
-    # timeline.story_keys.ask_clear()
-    # update time and scene
-    timeline.screen.toolbar.activity._thread.set_time(time_=frame)
-    # do timeline update
-    if timeline.screen.panel.sequence_name == sequence_name:
-        pass
-    else:
-        timeline.set_active_sequence(sequence_name)
-
-
-class Timeline(gtk.Frame):
-
-    def __init__(self, screen):
-        # init parent
-        gtk.Frame.__init__(self)
-        self.set_shadow_type(gtk.SHADOW_NONE)
-        self.set_size_request(-1, 236)
-        # do show
-        self.show()
-        # keep the screen
-        self.screen = screen
-        self.hadjustment = None
-        self.vadjustment = gtk.Adjustment(0, 0, 1, 1)
-        # tmp
-        _s = self.screen
-        self._viewport_width = _s.scene._screen_width - 120
-        self._current_keys = dict()
-        self._number_of_keys = self._get_number_of_keys()
-        # prepare scrolled window
-        self.scrolled_window = gtk.ScrolledWindow(vadjustment=self.vadjustment)
-        self.scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
-        self.scrolled_window.show()
-        # ..
-        self.add(self.scrolled_window)
-        # ..
-        if self.screen.toolbar.name == 'graphics':
-            self.story_keys = self.screen.toolbar.activity.graphic_keys
-        else:
-            self.story_keys = self.screen.toolbar.activity.sound_keys
-        # ..
-        self._main_hbox = None
-        self._titles_box = None
-        self._keys_box = None
-        # ..
-        self.__init_rows()
-
-    def __init_rows(self):
-        # ..
-        if self._main_hbox is None:
-            pass
-        else:
-            self._main_hbox.destroy()
-        # a box
-        self._main_hbox = gtk.HBox(homogeneous=False, spacing=0)
-        # show it
-        self._main_hbox.show()
-        # ..
-        self.scrolled_window.add_with_viewport(self._main_hbox)
-        # init main vars
-        if self._titles_box is None:
-            pass
-        else:
-            self._titles_box.destroy()
-        # init main vars
-        if self._keys_box is None:
-            pass
-        else:
-            self._keys_box.destroy()
-        # ..
-        self._titles_box = None
-        self._init_titles_box()
-        # ..
-        self._keys_box = None
-        self._init_keys_box()
-
-    def set_active_sequence(self, sequence_name):
-        # get viewport
-        _t_rows = self._titles_box.get_children()
-        # get viewport
-        _k_rows = self._keys_box.get_children()
-        # ..
-        _c1 = ui.get_color(0.92, 0.92, 0.92)
-        _c2 = ui.get_color(0.8, 0.8, 0.8)
-        # ...
-        for _i, _r in enumerate(_t_rows):
-            # title row | row - eventbox - button - label
-            _label = _r.get_children()[0].get_children()[0].get_children()[1]
-            # prepare color
-            _c = _c1 if _label.get_label() == sequence_name else _c2
-            # update row color
-            _r.modify_bg(gtk.STATE_NORMAL, _c)
-            _k_rows[_i].modify_bg(gtk.STATE_NORMAL, _c)
-        # update panel at the end
-        self.screen.panel.refresh(sequence_name=sequence_name,
-                update_store=True)
-
-    def _get_number_of_keys(self):
-        """shortcut ..
-        """
-        return self.screen.toolbar.activity._number_of_keys
-
-    def _get_number_of_rows(self):
-        """shortcut ..
-        """
-        return len(self._titles_box.get_children())
-
-    def _add_title(self, sequence_name):
-        # screen name
-        _screen_name = self.screen.toolbar.name.replace('_add', '')
-        # get first image name
-        _img_name = storage.get_sequence_first_graphic_name(_screen_name,
-                                                            sequence_name)
-        # get button
-        _title = ui.get_button(label=sequence_name, img_name=_img_name,
-                width=0, padding=(4, 0), img_size=(16, 16))
-        # _title.set_size_request(-1, 28)
-        # set color
-        _title.modify_bg(gtk.STATE_NORMAL, ui.get_color(0.3, 0.5, 0.6)) # TODO manage common colors like a theme
-        # _title.modify_bg(gtk.STATE_PRELIGHT, ui.get_color(0.5, 0.7, 0.8)) # TODO manage common colors like a theme
-        # get row number
-        _row_number = self._get_number_of_rows()
-        # add simple cb
-        _title.connect('released', _on_title_clicked, self, sequence_name)
-        # to manage color
-        _e_box = gtk.EventBox()
-        # show
-        _e_box.show()
-        # ..
-        _e_box.modify_bg(gtk.STATE_NORMAL, ui.get_color(0.8, 0.8, 0.8)) # TODO manage common colors like a theme
-        # add it
-        _e_box.add(_title)
-        # add it
-        self._titles_box.pack_start(_e_box, expand=False, fill=True)
-
-    def _add_keys(self, sequence_name):
-        # default row color
-        _c = ui.get_color(0.8, 0.8, 0.8)
-        # to manage color
-        _e_box = gtk.EventBox()
-        # show
-        _e_box.show()
-        # ..
-        _e_box.modify_bg(gtk.STATE_NORMAL, _c)
-        # init row
-        _row = gtk.HBox(homogeneous=False, spacing=1)
-        # show
-        _row.show()
-        # add it
-        _e_box.add(_row)
-        # ..
-        for _x in range(self._get_number_of_keys()):
-            # to manage color
-            _e = gtk.EventBox()
-            # show
-            _e.show()
-            # ..
-            _e.set_visible_window(False)
-            # get button
-            _b = ui.get_button(label='', width=24) # label='%s' % _x
-            # add simple cb
-            _b.connect('released', _on_key_clicked, self, sequence_name, _x)
-            # add to event box
-            _e.add(_b)
-            # set color
-            _b.modify_bg(gtk.STATE_NORMAL, _c)
-            # add to the row
-            _row.pack_start(_e, expand=False, fill=True)
-        # add it
-        self._keys_box.pack_start(_e_box, expand=False, fill=True)
-
-    def _refresh_row_keys(self, row, time_, color):
-        # 
-        _r_e_box = row.get_children()[0]
-        # get cells
-        _cells = _r_e_box.get_children()
-        _c_idx = int(time_)
-        # ..
-        for _i, _c in enumerate(_cells):
-            if _i == _c_idx:
-                pass
-            else:
-                # update row color
-                _c.modify_bg(gtk.STATE_NORMAL, color)
-
-    def _init_titles_box(self):
-        # prepare scrolled window
-        _viewport = gtk.Viewport()
-        _viewport.set_size_request(100, -1)
-        _viewport.show()
-        # init row
-        self._titles_box = gtk.VBox(homogeneous=False, spacing=1)
-        # show
-        self._titles_box.show()
-        # ..
-        _viewport.add(self._titles_box)
-        # update main box
-        self._main_hbox.pack_start(_viewport, expand=False, fill=True)
-
-    def _init_keys_box(self):
-        # init horizontal adjustment
-        self.hadjustment = gtk.Adjustment(0, 0, self._number_of_keys, 1)
-        # prepare scrolled window
-        _viewport = gtk.Viewport(hadjustment=self.hadjustment)
-        _viewport.set_size_request(self._viewport_width, -1)
-        _viewport.show()
-        # init row
-        self._keys_box = gtk.VBox(homogeneous=False, spacing=1)
-        # show
-        self._keys_box.show()
-        # ..
-        _viewport.add(self._keys_box)
-        # ..
-        self._main_hbox.pack_start(_viewport, expand=False, fill=True)
-
-    def _refresh_keys(self, time_):
-        # ...
-        _t_children = self._titles_box.get_children()
-        _k_children = self._keys_box.get_children()
-        # ..
-        _color = ui.get_color(1.0, 1.0, 0.5)
-        # for each row
-        for _i, _r in enumerate(_k_children):
-            # 
-            _r_e_box = _r.get_children()[0]
-            # get cells
-            _cells = _r_e_box.get_children()
-            _c_idx = int(time_)
-            # ..
-            if _c_idx < len(_cells):
-                # ...
-                _c = _cells[_c_idx]
-                # update row color
-                _c.modify_bg(gtk.STATE_NORMAL, _color)
-                _c.set_visible_window(True)
-                #
-                self._current_keys[_i] = _c
-            else:
-                continue
-
-    def reorder(self):
-        # get new order
-        _names = [_n for _n in self.story_keys.get_names()]
-        # ...
-        _t_children = self._titles_box.get_children()
-        _k_children = self._keys_box.get_children()
-        # ...
-        for _i, _r in enumerate(_t_children):
-            # title row | row - eventbox - button - label
-            _label = _r.get_children()[0].get_children()[0].get_children()[1]
-            # ...
-            if _label.get_label() in _names:
-                _index = _names.index(_label.get_label())
-            else:
-                continue
-            # do reorder
-            self._titles_box.reorder_child(_r, _index)
-            self._keys_box.reorder_child(_k_children[_i], _index)
-
-    def add_sequence(self, sequence_name):
-        """Need to rebuild all on each add to ensure valid scrollwindow ??
-        """
-        # ..
-        self.__init_rows()
-        # ..
-        _seq_names = self.story_keys.get_names()
-        # restore all
-        for _n in _seq_names:
-            # first add title
-            self._add_title(_n)
-            # second add new keys
-            self._add_keys(_n)
-
-    def remove_sequence(self, sequence_name):
-        # ...
-        _t_children = self._titles_box.get_children()
-        _k_children = self._keys_box.get_children()
-        # ...
-        for _i, _r in enumerate(_t_children):
-            # title row | row - eventbox - button - label
-            _label = _r.get_children()[0].get_children()[0].get_children()[1]
-            # ...
-            if _label.get_label() == sequence_name:
-                _r.destroy()
-                _k_children[_i].destroy()
-            else:
-                continue
-
-    def refresh_sequence(self):
-        # ...
-        _t_children = self._titles_box.get_children()
-        _k_children = self._keys_box.get_children()
-        # sequence to remove
-        _seq_to_remove = list()
-        # ...
-        for _i, _r in enumerate(_t_children):
-            # title row | row - eventbox - button - label
-            _label_wid = _r.get_children()[0].get_children()[0].get_children()[1]
-            _seq_name = _label_wid.get_label()
-            # seq check
-            if _seq_name in self.story_keys._names:
-                pass
-            else:
-                _seq_to_remove.append(_seq_name)
-                continue
-            # ...
-            for _frame, _c_key in enumerate(_k_children[_i].get_children()[0]):
-                # ...
-                _current, _f_type, _k_type = self.story_keys.get_current(
-                        _seq_name, _frame)
-                # get button
-                _button = _c_key.get_children()[0]
-                # ...
-                if _current is None:
-                    # _button.set_image(None)
-                    _button.set_label("")
-                elif _k_type == 'transition':
-                    # _button.set_image(None)
-                    _button.set_label("-")
-                else:
-                    # _button.set_image(None)
-                    _button.set_label("0")
-        # remove non-exisitng sequences
-        for _s_name in _seq_to_remove:
-            self.remove_sequence(_s_name)
-
-
-    def __reset(self):
-        # ..
-        _seq_names = self.story_keys.get_names()
-        # remove all
-        for _n in _seq_names:
-            self.remove_sequence(_n)
-        # ??
-        _seq_names = self.story_keys.get_names()
-        # restore all
-        for _n in _seq_names:
-            # first add title
-            self._add_title(_n)
-            # second add new keys
-            self._add_keys(_n)
-
-    def refresh_adjustment(self, time=None):
-        # ensure time
-        if time is None:
-            time = 0 if self.screen.toolbar.activity._thread is None\
-                    else self.screen.toolbar.activity._thread._time
-        else:
-            pass
-        # compute new adjustment
-        _keys_width = self._number_of_keys * 26
-        if self._viewport_width < _keys_width:
-            _new_value = (_keys_width - self._viewport_width) * time
-            _new_value /= float(self._number_of_keys)
-        else:
-            _new_value = 0
-        # ..
-        self.hadjustment.set_value(_new_value)
-
-    def refresh(self):
-        # ..
-        _time = 0 if self.screen.toolbar.activity._thread is None\
-                else self.screen.toolbar.activity._thread._time
-        # ..
-        _activity_nb_of_keys = self._get_number_of_keys()
-        # check reset
-        if self._number_of_keys != _activity_nb_of_keys:
-            # update number of keys
-            self._number_of_keys = _activity_nb_of_keys
-            # reset
-            self.__reset()
-        else:
-            pass
-        self.refresh_adjustment(time=_time)
-        # first avoid current keys colors
-        for _c in self._current_keys.values():
-            _c.set_visible_window(False)
-        # change cell colors
-        self._refresh_keys(_time)
-        # udpate sequences
-        self.refresh_sequence()
diff --git a/atoidejouer/ui/toolbar.py b/atoidejouer/ui/toolbar.py
index 65be152..88fdd51 100644
--- a/atoidejouer/ui/toolbar.py
+++ b/atoidejouer/ui/toolbar.py
@@ -45,69 +45,9 @@ def _clean_dir(dir_path):
     os.removedirs(dir_path)
 
 
-def _cb_seq_new(widget, toolbar):
-    # get screen
-    _screen = toolbar.activity.get_current_screen()
-    # remove items from preview boxes
-    _screen.sequence_preview.clear()
-    # ..
-    _screen.notebook.current_sequence = None
-    # clear entry
-    toolbar._sequence_entry.set_text("")
-
-
 NON_ALPHA_NUM_PATTERN = re.compile('[\W_]+')
 
 
-def _cb_seq_name(entry):
-    # ensure good string
-    _str = NON_ALPHA_NUM_PATTERN.sub('-', entry.get_text())
-    # update entry
-    entry.set_text(_str)
-
-
-def _cb_seq_remove(widget, toolbar):
-    # get sequence name
-    _name = toolbar._sequence_entry.get_text()
-    # get screen
-    _screen = toolbar.activity.get_current_screen()
-    # type shortcut 'graphic' or 'sound'
-    _type = _screen.notebook._type
-    # little check
-    if _name.strip() == '':
-        # do nothing
-        pass
-    else:
-        # get sequence path
-        _seq_path = storage.get_sequence_path(_type, _name)
-        # remove dir
-        if os.path.exists(_seq_path):
-            # do clean
-            os.remove(_seq_path)
-            # and clear all at the end
-            _screen.sequence_preview.clear()
-            # clear entry
-            toolbar._sequence_entry.set_text("")
-            # update notebook
-            _screen.notebook._get_store_sequence()
-            # update focus
-            _screen.notebook.focus_current_seq()
-        # nothing to do
-        else:
-            pass
-
-
-def _cb_seq_save(widget, toolbar, remove=False):
-    storage.sequence_save(toolbar, remove=remove)
-    # get screen
-    _screen = toolbar.activity.get_current_screen()
-    # get sequence name
-    _name = toolbar._sequence_entry.get_text()
-    # update focus
-    _screen.notebook.focus_current_seq(name=_name)
-
-
-
 def _show_browser(toolbar, cls):
     # next screen name
     _screen_name = '%s_add' % toolbar.name
@@ -139,7 +79,7 @@ def _show_browser(toolbar, cls):
 
 def _cb_add(widget, toolbar):
     # browser screen factory
-    if toolbar.name == 'graphics':
+    if toolbar.name == 'edit':
         _show_browser(toolbar, screens.ScreenBrowserGraphics)
     # ..
     elif toolbar.name == 'sounds':
@@ -150,19 +90,6 @@ def _cb_add(widget, toolbar):
         logger.error('[toolbar] _cb_add - unknown: %s' % toolbar.name)
 
 
-def _cb_remove(widget, toolbar):
-    # browser screen factory
-    if toolbar.name == 'graphics':
-        pass
-    # ..
-    elif toolbar.name == 'sounds':
-        pass
-    # ??
-    else:
-        # ERROR
-        logger.error('[toolbar] _cb_remove - name: %s' % toolbar.name)
-
-
 def _cb_frame_after(widget, toolbar):
     if toolbar._frame_entry is None:
         pass
@@ -171,8 +98,6 @@ def _cb_frame_after(widget, toolbar):
         _value = int(toolbar._frame_entry.get_text())
         # inc it
         _update_frame_entry(widget, toolbar, _value + 1)
-        # update sequence file
-        _cb_seq_save(widget, toolbar)
 
 
 def _cb_frame_before(widget, toolbar):
@@ -183,8 +108,6 @@ def _cb_frame_before(widget, toolbar):
         _value = int(toolbar._frame_entry.get_text())
         # dec it
         _update_frame_entry(widget, toolbar, _value - 1)
-        # update sequence file
-        _cb_seq_save(widget, toolbar)
 
 
 def _update_frame_entry(entry, toolbar, value):
@@ -229,16 +152,7 @@ def _cb_import(widget, toolbar):
     # shortcut
     _filenames = _screen.sequence_preview.items
     # add sequence to the story keys
-    if toolbar.story_keys.add_sequence(_sequence_name, _filenames):
-        # screen name factory
-        _screen_name = toolbar.name.replace('_add', '')
-        # get screen now
-        _screen = toolbar.activity.get_screen(_screen_name)
-        # add sequence to the timeline
-        _screen.timeline.add_sequence(_sequence_name)
-    # already added
-    else:
-        pass
+    # toolbar.story_keys.add_sequence(_sequence_name, _filenames)
 
 
 def _cb_play(widget, toolbar):
@@ -272,7 +186,7 @@ def _cb_view_fullscreen(widget, toolbar):
     # replace fullscreen button with return button
     toolbar._replace_button('view_fullscreen', 'view_return')
     # ask_clear
-    toolbar.story_keys.ask_clear()
+    # toolbar.story_keys.ask_clear()
     # get current screen
     _screen = toolbar.activity.get_current_screen()
     # enbale fullscreen
@@ -283,7 +197,7 @@ def _cb_view_return(widget, toolbar):
     # remove return button with fullscreen button
     toolbar._replace_button('view_return', 'view_fullscreen')
     # ask_clear
-    toolbar.story_keys.ask_clear()
+    # toolbar.story_keys.ask_clear()
     # get current screen
     _screen = toolbar.activity.get_current_screen()
     # disable fullscreen
@@ -309,7 +223,7 @@ def _cb_format_value(widget, value, toolbar):
     # return formated value
     return '%1d:%02d' % divmod(value, 60)
 
-TOOLBAR_INDEXES = ['activity', 'story', 'graphics', 'sounds', 'help']
+TOOLBAR_INDEXES = ['activity', 'story', 'edit', 'help']
 
 def _cb_help_back(widget, toolbar):
     _previous = toolbar.activity._previous
@@ -333,12 +247,7 @@ BUTTONS = {
         'open' : ['media', _cb_open],
         'pause' : ['media-playback-pause', _cb_pause],
         'play' : ['media-playback-start', _cb_play],
-        'remove' : ['list-remove', _cb_remove],
         'separator' : [None, None],
-        'seq_new' : ['document-generic', _cb_seq_new],
-        'seq_name' : [None, _cb_seq_name],
-        'seq_remove' : ['button_cancel', _cb_seq_remove],
-        'seq_save' : ['dialog-apply', _cb_seq_save],
         'slider' : [None, _cb_slider],
         'stop' : ['media-playback-stop', _cb_stop],
         'view_fullscreen' : ['view-fullscreen', _cb_view_fullscreen],
@@ -346,42 +255,18 @@ BUTTONS = {
         }
 
 TOOLBARS = {
-        'graphics' : [
-            ['stop', 'play', 'slider', # 'backward', 'forward'
-             'separator',
-             'add'],
-            []
-            ],
-        'graphics_add' : [
-            ['seq_new', 'seq_name', 'seq_save', 'seq_remove',
-             # 'separator',
-             # 'add', 'remove',
-             # ''separator',
-             # 'frame_before', 'frame_entry', 'frame_after'
-            ],
-            ['import', 'back']
-            ],
-        'sounds' : [
-            ['stop', 'play', 'slider', # 'backward', 'forward'
-             'separator',
-             'add'],
-            []
-            ],
-        'sounds_add' : [
-            ['seq_new', 'seq_name', 'seq_save', 'seq_remove',
-             # 'separator',
-             # 'add', 'remove',
-             # ''separator',
-             # 'frame_before', 'frame_entry', 'frame_after'
-            ],
-            ['import', 'back']
-            ],
         'story' : [
             ['stop', 'play', 'slider', # 'backward', 'forward'
              'separator',
              'view_fullscreen'],
             []
             ],
+        'edit' : [
+            ['stop', 'play', 'slider', 'backward', 'forward'
+             # 'separator', 'add'
+             ],
+            []
+            ],
         'help'  : [
             [],
             ['help_back']
@@ -389,74 +274,30 @@ TOOLBARS = {
         }
 
 TITLES = {
-        'graphics' : {
-            'toolbox': _('Graphic'),
-            'buttons': {
-                # 'backward': _('Seek Backward'),
-                # 'forward': _('Seek Forward'),
-                'pause': _('Pause Story'),
-                'play': _('Play Story'),
-                'slider': _('Progress Bar'),
-                'stop': _('Stop Story'),
-                'add': _('Add Graphic'),
-                }
-            },
-        'graphics_add' : {
-            'toolbox': None,
-            'buttons': {
-                'add': _('Add Graphic'),
-                'back': _('Back'),
-                'frame_after': _('Frame Before'),
-                'frame_before': _('Frame After'),
-                'frame_entry': None,
-                'import': _('Import Sequence'),
-                'remove': _('Remove Graphic'),
-                'seq_new': _('New Sequence'),
-                'seq_name': None,
-                'seq_remove': _('Remove Sequence'),
-                'seq_save': _('Save Sequence'),
-                }
-            },
-        'sounds'   : {
-            'toolbox': _('Sound'),
+        'story'  : {
+            'toolbox': _('Story'),
             'buttons': {
+                # 'open': _('Open Story'),
                 # 'backward': _('Seek Backward'),
                 # 'forward': _('Seek Forward'),
                 'pause': _('Pause Story'),
                 'play': _('Play Story'),
                 'slider': _('Progress Bar'),
                 'stop': _('Stop Story'),
-                'add': _('Add Sound'),
+                'view_fullscreen': _('Fullscreen'),
+                'view_return': _('Default Screen'),
                 }
             },
-        'sounds_add' : {
-            'toolbox': None,
+        'edit' : {
+            'toolbox': _('Edit'),
             'buttons': {
-                'add': _('Add Sound'),
-                'back': _('Back'),
-                'frame_after': _('Frame Before'),
-                'frame_before': _('Frame After'),
-                'frame_entry': None,
-                'import': _('Import Sequence'),
-                'remove': _('Remove Sound'),
-                'seq_new': _('New Sound'),
-                'seq_name': None,
-                'seq_remove': _('Remove Sequence'),
-                'seq_save': _('Save Sequence'),
-                }
-            },
-        'story'  : {
-            'toolbox': _('Story'),
-            'buttons': {
-                # 'open': _('Open Story'),
-                # 'backward': _('Seek Backward'),
-                # 'forward': _('Seek Forward'),
+                'backward': _('Seek Backward'),
+                'forward': _('Seek Forward'),
                 'pause': _('Pause Story'),
                 'play': _('Play Story'),
                 'slider': _('Progress Bar'),
                 'stop': _('Stop Story'),
-                'view_fullscreen': _('Fullscreen'),
-                'view_return': _('Default Screen'),
+                'add': _('Add Graphic'),
                 }
             },
         'help'  : {
@@ -464,7 +305,7 @@ TITLES = {
             'buttons': {
                 'help_back': _('Back')
                 }
-            }
+            },
         }
 
 
@@ -477,12 +318,6 @@ class Toolbar(gtk.Toolbar):
         self.set_name(name)
         # keep activity
         self.activity = activity
-        # ..
-        if self.name == 'graphics'\
-        or self.name == 'story':
-            self.story_keys = self.activity.graphic_keys
-        else:
-            self.story_keys = self.activity.sound_keys
         # adjustment
         self._adjustment = None
         self._number_of_keys = self.activity._number_of_keys
@@ -639,16 +474,6 @@ class Toolbar(gtk.Toolbar):
             _buton = gtk.ToolItem()
             _buton.set_expand(True)
             _buton.add(_hscale)
-        elif button_id == 'seq_name':
-            self._sequence_entry = gtk.Entry()
-            # show
-            self._sequence_entry.show()
-            # ..
-            self._sequence_entry.connect('changed', _cb)
-            # ..
-            _buton = gtk.ToolItem()
-            _buton.set_expand(True)
-            _buton.add(self._sequence_entry)
         elif button_id == 'frame_entry':
             # ...
             self._frame_entry = gtk.Entry()