make the flask based tools more clean and nicer -> move requirements to lib dir + limit import of code

17 files changed, 121 insertions, 2083 deletions

diff --git a/atoideweb/activity.py b/atoideweb/activity.py
index 5df308e..9f34d83 100644
--- a/atoideweb/activity.py
+++ b/atoideweb/activity.py
@@ -9,14 +9,13 @@ from sugar.activity import activity
 # hulahop import
 from hulahop.webview import WebView
 
-# atoidejouer import
-import app_main
+# atoideweb import
+import run
 # ..
-from atoideweb.tools import config, keys
 from atoideweb.ui import toolbar
 
 # get application logger
-logger = logging.getLogger('atoidejouer')
+logger = logging.getLogger(run.APP_NAME)
 
 
 URL_BASE = 'http://localhost:5000/'
@@ -35,11 +34,11 @@ def _toolbar_changed(toolbox, page, activity_):
     return True
 
 
-class AToiDeWebActivity(activity.Activity, app_main.AToiDeWeb):
+class AToiDeWebActivity(activity.Activity, run.atoideweb):
 
     def __init__(self, handle):
         # init parents
-        app_main.AToiDeWeb.__init__(self)
+        run.atoideweb.__init__(self)
         activity.Activity.__init__(self, handle)
         # ..
         self.max_participants = 1
@@ -56,11 +55,11 @@ class AToiDeWebActivity(activity.Activity, app_main.AToiDeWeb):
         # tmp var
         _toolbar = None
         # init toolbars
-        for _n in ['story', 'graphics', 'graphics_add', 'sounds', 'sounds_add']:
+        for _n in ['eating', 'spare-time']:
             # init toolbar
             _t = toolbar.Toolbar(self, name=_n)
             # if default toolbar .. set default screen
-            if _n == 'story':
+            if _n == 'eating':
                 self._change_screen(_t)
                 _toolbar = _t
         # set default tab
@@ -78,12 +77,13 @@ class AToiDeWebActivity(activity.Activity, app_main.AToiDeWeb):
         self.web_view.load_uri(URL_BASE + _name)
 
     def read_file(self, file_path):
-        app_main.AToiDeWeb.read_file(self, file_path)
+        # .. should be overriden
+        pass
 
     def write_file(self, file_path):
-        app_main.AToiDeWeb.write_file(self, file_path)
+        # .. should be overriden
+        pass
 
     def close(self, skip_save=False):
-        app_main.AToiDeWeb.close(self)
+        run.atoideweb.close(self)
         activity.Activity.close(self, skip_save=True)
-
diff --git a/atoideweb/controllers/__init__.py b/atoideweb/controllers/__init__.py
index 8b13789..547773f 100644
--- a/atoideweb/controllers/__init__.py
+++ b/atoideweb/controllers/__init__.py
@@ -1 +1,2 @@
-
+# atoideweb import
+from atoideweb.controllers.index import app, render
diff --git a/atoideweb/controllers/ajax.py b/atoideweb/controllers/ajax.py
new file mode 100644
index 0000000..2fb0120
--- /dev/null
+++ b/atoideweb/controllers/ajax.py
@@ -0,0 +1,31 @@
+# gettext import
+from gettext import gettext as _
+
+# server import
+from server.flask import app, logger, render, request, jsonify
+
+
+@app.route('/ajax', methods=['GET', 'POST'])
+def ajax():
+    # POST
+    if request.method == 'POST':
+        if 'ajax-sample' in request.form:
+            # prepare ajax result
+            _ajax_content = {
+                    'result': request.form['ajax-sample']
+                    }
+            # render ajax
+            return jsonify(_ajax_content)
+        # ?? should not happen
+        else:
+            _result = '??'
+    # GET
+    else:
+        _result = ''
+    # prepare result
+    _content = {
+                'title': _('atdw - Ajax sample'),
+                'result': _result
+                }
+    # render result
+    return render('atoideweb/ajax.html', **_content)
diff --git a/atoideweb/controllers/base.py b/atoideweb/controllers/base.py
deleted file mode 100644
index dda2048..0000000
--- a/atoideweb/controllers/base.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# python import
-import logging
-# ..
-from gettext import gettext
-
-# make module
-from flask import Module
-module_base = Module(__name__)
-
-# bewype import
-from bewype.flask import app, render
-
-# get application logger
-logger = logging.getLogger('atoidejouer')
-
-def _render(template, **context):
-    """Crappy hack!
-    """
-    context['_'] = gettext
-    return render(template, **context)
-
-@module_base.route('/')
-def helo():
-    return 'Helo!'
-
-
-@module_base.route('/activity')
-def activity():
-    return _render('atoideweb/activity.html')
-
-
-@module_base.route('/story')
-def story():
-    return _render('atoideweb/story.html')
-
-# do register
-app.register_module(module_base)
diff --git a/atoideweb/controllers/index.py b/atoideweb/controllers/index.py
new file mode 100644
index 0000000..7d0e1af
--- /dev/null
+++ b/atoideweb/controllers/index.py
@@ -0,0 +1,14 @@
+# gettext import
+from gettext import gettext as _
+
+# server import
+from server.flask import app, logger, render, request, jsonify
+
+# atoideweb import
+from atoideweb.controllers import post, ajax
+
+
+@app.route('/')
+def index():
+    logger.debug(_('Welcome!'))
+    return 'Welcome!'
diff --git a/atoideweb/controllers/post.py b/atoideweb/controllers/post.py
new file mode 100644
index 0000000..15c189c
--- /dev/null
+++ b/atoideweb/controllers/post.py
@@ -0,0 +1,25 @@
+# gettext import
+from gettext import gettext as _
+
+# server import
+from server.flask import app, logger, render, request, jsonify
+
+
+@app.route('/post', methods=['GET', 'POST'])
+def post():
+    # POST
+    if request.method == 'POST':
+        if 'post-sample' in request.form:
+            _result = request.form['post-sample']
+        else:
+            _result = '??'
+    # GET
+    else:
+        _result = ''
+    # 
+    _content = {
+                'title': _('atdw - POST sample'),
+                'result': _result
+                }
+    # render result
+    return render('atoideweb/post.html', **_content)
diff --git a/atoideweb/controllers/templates/_helpers.html b/atoideweb/controllers/templates/_helpers.html
deleted file mode 100644
index c99703c..0000000
--- a/atoideweb/controllers/templates/_helpers.html
+++ /dev/null
@@ -1,14 +0,0 @@
-{% macro link_to(text, endpoint) -%}
-    <a href="{{ url_for(endpoint, **kwargs) }}">{{ text }}</a>
-{%- endmacro %}
-
-{% macro options(_, name, option_list, current) -%}
-    <div class='{{ name }}'>
-        <h1>{{ _(name) }}</h1>
-        <form name='{{ name }}' action='/config/{{ name }}' method="post">
-            {% for opt in option_list %}
-            <input type='radio' name='{{ name }}' value='{{ opt }}' {% if opt == current %}checked{% endif %} />{{ _(opt) }}<br />
-            {% endfor %}
-        </form>
-    </div>
-{%- endmacro %}
diff --git a/atoideweb/controllers/templates/atoideweb/activity.html b/atoideweb/controllers/templates/atoideweb/activity.html
deleted file mode 100644
index 2f7ed46..0000000
--- a/atoideweb/controllers/templates/atoideweb/activity.html
+++ /dev/null
@@ -1,16 +0,0 @@
-{% extends "layout.html" %}
-{% block title %}{{ _('Activity') }}{% endblock %}
-{% block content %}
-<div class='config-options'>
-    {{ options(_, 'difficutly', ['easy', 'advanced'], 'easy') }}
-<div>
-<script>
-<!--
-$(document).ready(function() {
-    $(".config-options input[type='radio']").change( function() {
-        $(".config-options form").submit();
-    });
-});
--->
-</script>
-{% endblock %}
diff --git a/atoideweb/controllers/templates/atoideweb/story.html b/atoideweb/controllers/templates/atoideweb/story.html
deleted file mode 100644
index 5bfd600..0000000
--- a/atoideweb/controllers/templates/atoideweb/story.html
+++ /dev/null
@@ -1,12 +0,0 @@
-{% extends "layout.html" %}
-{% block title %}{{ _('Story') }}{% endblock %}
-{% block content %}
-<h1>{{ _('Story')  }}</h1>
-<div id='helo'>
-</div>
-<script>
-<!--
-$('#helo').html('JQuery is working ...');
--->
-</script>
-{% endblock %}
diff --git a/atoideweb/controllers/templates/layout.html b/atoideweb/controllers/templates/layout.html
deleted file mode 100644
index ba91e6e..0000000
--- a/atoideweb/controllers/templates/layout.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<!doctype html>
-{% from "_helpers.html" import link_to %}
-{% from "_helpers.html" import options %}
-<head>
-    <title>{{ title }}</title>
-    <script src='/static/js/jquery.js' }}" type="text/javascript"></script>
-    {% block head %}{% endblock %}
-</head>
-
-<body>    
-    {% block content %}{% endblock %}
-</body>
diff --git a/atoideweb/tools/config.py b/atoideweb/tools/config.py
deleted file mode 100644
index 00b4c5d..0000000
--- a/atoideweb/tools/config.py
+++ /dev/null
@@ -1,169 +0,0 @@
-
-# python import
-import logging
-from ConfigParser import SafeConfigParser
-
-# get application logger
-logger = logging.getLogger('atoidejouer')
-
-
-class Config(object):
-
-    class __Singleton:
-        """Our singleton object.
-        """
-
-        def __init__(self, config=None, debug=False):
-            """Create the new singleton with the application config.
-
-            :param config: SafeConfigParser object for all the application
-            :see: `ConfigParser.SafeConfigParser`
-            """
-            # dummy flag
-            self.debug = debug
-            # ensure config
-            if config is None:
-                # ...
-                self.__config = SafeConfigParser()
-                # ...
-                self.__config.read('config.ini')
-            # ...
-            else:
-                self.__config = config
-
-        def get_mode(self):
-            # get mode value
-            _mode = self.get('activity>mode')
-            # ensure mode
-            if _mode in ['easy', 'advanced']:
-                pass
-            else:
-                # is easy by default
-                _mode = 'easy'
-                # ensure config for further use
-                self.set('activity>mode', _mode)
-            # return it
-            return _mode
-
-        def get_rate(self):
-            # get rate value
-            _rate = self.get('activity>rate')
-            # ensure rate
-            if _rate in ['normal', 'smooth', 'faster']:
-                pass
-            else:
-                # is easy by default
-                _rate = 'normal'
-                # ensure config for further use
-                self.set('activity>rate', _rate)
-            # return it
-            return _rate
-
-        def get_rate_value(self):
-            # ..
-            _rate = self.get_rate()
-            # simple rate factory
-            if _rate == 'faster':
-                return 0.2
-            elif _rate == 'smooth':
-                return 0.5
-            else:
-                return 1.0
-
-        def get_dnd(self):
-            # get dnd value
-            _dnd = self.get('activity>dnd')
-            # ensure dnd
-            if _dnd in ['yes', 'no']:
-                pass
-            else:
-                # is no by default
-                _dnd = 'no'
-                # ensure config for further use
-                self.set('activity>dnd', _dnd)
-            # return it
-            return _dnd
-
-        def use_dnd(self):
-            return self.get_dnd() == 'yes'
-
-        def set(self, path, value, type_=str):
-            # set value
-            self.set_value(*path.split(">"), value=value, type_=type_)
-
-        def get(self, path, type_=str):
-            """A little jQuery like shortcut for the `get_value` method.
-
-            :param path: something like "section>option"
-            :param type_: type of the expected value. Default: str
-            :return: expected value in the expected type or None
-            :rtype: `object`
-            """
-            # get value
-            _value = self.get_value(*path.split(">"), type_=type_)
-            # check and return
-            return None if _value is None or _value == "" else _value
-
-        def set_value(self, section, option, value=None, type_=str):
-            # check has config
-            if self.__config is None:
-                return
-            # ensure section
-            if self.__config.has_section(section):
-                pass
-            else:
-                self.__config.add_section(section)
-            # do set
-            self.__config.set(section, option, value)
-
-        def get_value(self, section, option, type_=str):
-            """Simple config value getter to avoid exception risk when getting
-            a config value. If the section and option exist, returns the
-            corresponding value, None otherwise.
-
-            The `type_` parameter specify the expected option type and
-            return.
-
-            :param section: section name of the expected value
-            :param option: option name name of the expected value
-            :param type_: type of the expected value. Default: str
-            :return: expected value in the expected type or None
-            :rtype: `object`
-            """
-            # check has config
-            if self.__config is None:
-                return None
-            # check value exist
-            elif self.__config.has_section(section) \
-            and self.__config.has_option(section, option):
-                # check expected value type
-                if type_ is int:
-                    return self.__config.getint(section, option)
-                elif type_ is bool:
-                    return self.__config.getboolean(section, option)
-                elif type_ is str:
-                    return self.__config.get(section, option)
-                elif type_ is list:
-                    _v = self.__config.get(section, option)
-                    return _v.split(' ')
-                # unexpected type ??
-                else:
-                    return None
-            # value does not exist                
-            else:
-                # do nothing
-                return None
-
-    # singleton instance
-    instance = None
-
-    def __new__(c, config=None, force=False, debug=False):
-        """Singleton new init.
-        """
-        # if doesn't already initialized
-        if not Config.instance \
-        or force is True:
-            # create a new instance
-            Config.instance = Config.__Singleton(config=config, debug=debug)
-        # return the manager object
-        return Config.instance
diff --git a/atoideweb/tools/image.py b/atoideweb/tools/image.py
index 3fa93bd..c5057cb 100644
--- a/atoideweb/tools/image.py
+++ b/atoideweb/tools/image.py
@@ -2,24 +2,11 @@
 # python import
 import logging, os, struct, StringIO
 
-# atoidejouer import
-from atoideweb.tools import registry, storage
+# atoideweb import
+from atoideweb.tools import registry
 
 # get application logger
-logger = logging.getLogger('atoidejouer')
-
-
-def get_sequence_first_graphic(type_, sequence_name):
-    # ..
-    _filename = storage.get_sequence_first_graphic_name(type_, sequence_name)
-    if _filename is None:
-        return storage.get_image_path('blank', dir_='data')
-    if type_ == 'graphics':
-        return storage.get_image_path(_filename)
-    elif type_ == 'sounds':
-        return storage.get_image_path('sound', dir_='data')
-    else:
-        return storage.get_image_path('blank', dir_='data')
+logger = logging.getLogger('atoideweb')
 
 
 def compute_width_height(width, height, max_width, max_height, use_max=False):
@@ -61,7 +48,6 @@ def get_image_info(path):
         pass
     else:
         return None, 0, 0
-
     # read file
     _f = open(path)
     _data = _f.read()
diff --git a/atoideweb/tools/keys.py b/atoideweb/tools/keys.py
deleted file mode 100644
index 8a4099a..0000000
--- a/atoideweb/tools/keys.py
+++ /dev/null
@@ -1,686 +0,0 @@
-
-# python import
-import json, logging, os, random, string
-# ..
-from functools import partial
-from gettext import gettext as _
-
-# atoidejouer import
-from atoideweb.tools import storage
-
-# get application logger
-logger = logging.getLogger('atoidejouer')
-
-
-def random_str(length=12):
-    """Simple method to generate unique and random string value.
-    """
-    return ''.join(random.choice(string.letters) for i in xrange(length))
-
-
-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, 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()
-            # find first valid key
-            for _f_dict in _frame_values:
-                # 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']:
-                    return _f_dict['__align']
-                else:
-                    continue
-        # default
-        return [0, 0]
-
-    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):
-        # get max frame
-        _max_frame = self.get_max_frame()
-        # 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/atoideweb/tools/registry.py b/atoideweb/tools/registry.py
index 8947d4d..a57285e 100644
--- a/atoideweb/tools/registry.py
+++ b/atoideweb/tools/registry.py
@@ -3,62 +3,7 @@
 import logging
 
 # get application logger
-logger = logging.getLogger('atoidejouer')
-
-class PixRegistry(object):
-
-    class __Singleton:
-        """Our singleton object.
-        """
-
-        def __init__(self):
-            """Create the new singleton with the application config.
-
-            :param config: SafeConfigParser object for all the application
-            :see: `ConfigParser.SafeConfigParser`
-            """
-            # ensure config
-            self.__dict = dict()
-
-        def __key(self, path, width, height):
-            return '%s|%sx%s' % (path, width, height)
-
-        def get_pix(self, path, width, height):
-            # get key
-            _k = self.__key(path, width, height)
-            # ..
-            if _k in self.__dict:
-                return self.__dict[_k]
-            else:
-                return None
-
-        def set_pix(self, path, width, height, pixbuf):
-            # get key
-            _k = self.__key(path, width, height)
-            # clear previous
-            if _k in self.__dict:
-                _p = self.__dict[_k]
-                _p.destroy()
-            else:
-                pass
-            # ...
-            self.__dict[_k] = pixbuf
-
-    # singleton instance
-    instance = None
-
-    def __new__(c, force=False):
-        """Singleton new init.
-        """
-        # if doesn't already initialized
-        if not PixRegistry.instance \
-        or force is True:
-            # create a new instance
-            PixRegistry.instance = PixRegistry.__Singleton()
-        else:
-            pass
-        # return the manager object
-        return PixRegistry.instance
+logger = logging.getLogger('atoideweb')
 
 
 class InfoRegistry(object):
diff --git a/atoideweb/tools/sound.py b/atoideweb/tools/sound.py
index 87db3d9..18edb8c 100644
--- a/atoideweb/tools/sound.py
+++ b/atoideweb/tools/sound.py
@@ -4,7 +4,7 @@ import gst, logging
 from datetime import timedelta
 
 # get application logger
-logger = logging.getLogger('atoidejouer')
+logger = logging.getLogger('AToiDeWeb')
 
 
 class Player(object):
diff --git a/atoideweb/tools/storage.py b/atoideweb/tools/storage.py
index f3f40ca..329b1f8 100644
--- a/atoideweb/tools/storage.py
+++ b/atoideweb/tools/storage.py
@@ -7,7 +7,7 @@ from gettext import gettext as _
 # png import from pypng
 from lib import png
 
-# atoidejouer import
+# atoideweb import
 from atoideweb.tools import config
 
 # ...
@@ -23,7 +23,7 @@ else:
     BUND_PATH = activity.get_bundle_path()
 
 # get application logger
-logger = logging.getLogger('atoidejouer')
+logger = logging.getLogger('atoideweb')
 
 ACTIVITY_NAMES = {
         'paint': 'org.laptop.Oficina',
@@ -40,39 +40,6 @@ def get_config_path():
     return os.path.join(BUND_PATH, 'static', 'data', 'config', 'config.ini')
 
 
-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(ROOT_PATH, '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 get_sound_path(filename, dir_='sounds'):
     # return path
     return os.path.join(ROOT_PATH, 'data', dir_,
@@ -87,7 +54,7 @@ def get_icon_path(stock_id):
 
 def get_image_path(filename, dir_='graphics'):
     # return path
-    if filename in ['background_default', 'mask_default']\
+    if filename in ['background_default']\
     or dir_=='data':
         return os.path.join(BUND_PATH, 'static', 'data',
                 'graphics', '%s.png' % filename)
@@ -96,140 +63,6 @@ def get_image_path(filename, dir_='graphics'):
                 '%s.png' % filename)
 
 
-def __remove_inner_true(a_list):
-    _new_list = list()
-    # ..
-    _has_false = False
-    # ..
-    for _i, _v in enumerate(a_list):
-        if _v is False:
-            _has_false = True
-        else:
-            _sub = a_list[_i+1:]
-            if _has_false is True\
-            and _sub.count(False) != 0:
-                _new_list.append(False)
-                continue
-            else:
-                pass
-        # ..
-        _new_list.append(_v)
-    # ..
-    del a_list
-    # ..
-    return _new_list
-
-
-def png_from_pixbuf(filename, timestamp):
-    # prepare outpath
-    _out_path = get_image_path(filename)
-    if os.path.exists(_out_path):
-        return
-    else:
-        pass
-    # prepare inpath
-    _in_path = get_path_from_journal(timestamp, 'image/png')
-    # init png reader
-    _reader = png.Reader(filename=_in_path)
-    # read the file
-    _w, _h, _pixels, _metadata = _reader.read()
-    # init working vars
-    _new_pixels = list()
-    _first_color = None
-    _remove_row_list = [True for _dummy in range(_h)]
-    _remove_col_list = [True for _dummy in range(_w)]
-    # ..
-    _planes = _metadata['planes']
-    # update vars
-    for _i, _row in enumerate(_pixels):
-        # init new row
-        _new_row = list()
-        for _j, _col in enumerate(_row):
-            # upate rgb
-            if _j % _planes == 0:
-                _rgb = [_col]
-                continue
-            else:
-                _rgb.append(_col)
-            # update color first and after
-            if _j % _planes == (_planes - 1):
-                # keep the first color
-                if _first_color is None:
-                    _first_color = _rgb
-                else:
-                    pass
-                # make it alpha if first
-                if _rgb == _first_color:
-                    _new_row.extend([0, 0, 0, 0])
-                else:
-                    _remove_row_list[_i] = False
-                    _remove_col_list[(_j/_planes)-1] = False
-                    # small hack
-                    if _planes == 3:
-                        _rgb.append(255)
-                    else:
-                        pass
-                    _new_row.extend(_rgb)
-            else:
-                continue
-        # add new row
-        _new_pixels.append(_new_row)
-    # cleaning
-    del _reader
-    del _pixels
-    # remove inner True in cols or rows
-    _remove_row_list = __remove_inner_true(_remove_row_list)
-    _remove_col_list = __remove_inner_true(_remove_col_list)
-    # init working vars
-    _new_new_pixels = list()
-    # 2cd pass
-    for _i, _row in enumerate(_new_pixels):
-        # transparent row
-        if _remove_row_list[_i] is True:
-            continue
-        else:
-            # init new row
-            _new_new_row = list()
-            # ..
-            for _j, _col in enumerate(_row):
-                # upate rgb
-                if _j % 4 == 0:
-                    _rgb = [_col]
-                    continue
-                else:
-                    _rgb.append(_col)
-                # update color first and after
-                if _j % 4 == 3:
-                    # transparent col
-                    if _remove_col_list[(_j/4)-1] is True:
-                        continue
-                    else:
-                        _new_new_row.extend(_rgb)
-                else:
-                    continue
-            # sorry for that!
-            _new_new_pixels.append(_new_new_row)
-    # cleaning
-    del _new_pixels
-    del _remove_row_list
-    del _remove_col_list
-    # update h and w
-    _w = len(_new_new_pixels[0])/4
-    _h = len(_new_new_pixels)
-    # update alpha meta
-    _metadata['alpha'] = True
-    _metadata['planes'] = 4
-    del _metadata['size']
-    # write the new image with alpha
-    _new_png = open(_out_path, 'wb')
-    _writer = png.Writer(_w, _h, **_metadata)
-    _writer.write(_new_png, _new_new_pixels)
-    _new_png.close()
-    # just in case
-    del _writer
-    del _new_new_pixels
-
-
 def __do_query(query):
     from sugar.datastore import datastore
     # find in ds
@@ -298,7 +131,7 @@ def list_files_from_journal(activity_name=None, mime_type=None):
     for _o in _objs:
         # TODO open the files
         yield _o.get_file_path()
-
+        
 
 def get_path_from_journal(timestamp, mime_type):
     from sugar.datastore import datastore
@@ -315,315 +148,3 @@ def get_path_from_journal(timestamp, mime_type):
         return _results[0].get_file_path()
     else:
         return None
-
-
-def __check_dir(dir_name, parent='data'):
-    # get activity path
-    if parent is None:
-        _dir = os.path.join(ROOT_PATH, dir_name)
-    else:
-        _dir = os.path.join(ROOT_PATH, parent, dir_name)
-    # ensure activity path
-    if os.path.exists(_dir):
-        pass
-    else:
-        os.mkdir(_dir)
-
-
-def __check_file(sub_path, file_name):
-    # ..
-    __check_dir(sub_path)
-    # file path
-    _path = os.path.join(ROOT_PATH, 'data', sub_path,
-            file_name)
-    # ensure file
-    if os.path.exists(_path):
-        pass
-    else:
-        # get bundle path
-        _p = os.path.join(BUND_PATH, 'static', 'ext',
-                sub_path, file_name)
-        # copy
-        shutil.copy(_p, _path)
-
-
-def __check_dir_files(sub_path):
-    # get bundle path
-    _path = os.path.join(BUND_PATH, '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):
-            pass
-        else:
-            __check_file(sub_path, _f)
-
-
-def init_activity_folder():
-    # 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_dir_files('stories')
-
-
-def __show_in_out_result_message(label, message):
-    # ..
-    label.set_markup('<span size="large" style="italic">%s</span>' % message)
-    label.show()
-
-
-def __merge_dir(project_name, dir_name, exist_list=None):
-    # archive path
-    _path_src = os.path.join(ROOT_PATH, 'tmp', project_name,
-            dir_name)
-    # little check
-    if os.path.exists(_path_src):
-        # project path
-        _path_dst = os.path.join(ROOT_PATH, 'data',
-                dir_name)
-        # init existing list
-        exist_list = list() if exist_list is None else exist_list
-        for _f in os.listdir(_path_src):
-            # ..
-            _p_src = os.path.join(_path_src, _f)
-            _p_dst = os.path.join(_path_dst, _f)
-            # little check
-            if os.path.isdir(_p_src):
-                continue
-            # do not replace
-            elif os.path.exists(_p_dst):
-                # update exist list
-                exist_list.append(os.path.join(dir_name, _f))
-            # do copy
-            else:
-                shutil.copy(_p_src, _path_dst)
-        # OK!
-        return True
-    else:
-        # Oops!
-        return False
-
-
-def __import_keys(activity_, project_name):
-    # ..
-    _path_data = os.path.join(ROOT_PATH, 'tmp',
-            project_name, 'story.keys')
-    # init content
-    _data = None
-    # little check
-    if os.path.exists(_path_data):
-        # read file
-        _file = open(_path_data, 'r')
-        try:
-            _data = _file.read()
-        finally:
-            _file.close()
-        # parse json data
-        _exist_graphic_keys = activity_.graphic_keys.loads(_data, clear=False)
-        _exist_sound_keys = activity_.sound_keys.loads(_data, clear=False)
-        # set activity new number of keys
-        activity_.update_number_of_keys()
-        # ..
-        return {
-                'graphics': _exist_graphic_keys,
-                'sounds': _exist_sound_keys,
-                }
-    # ?? invalid archive
-    else:
-        return None
-
-
-def import_project(activity_, file_path, msg_label):
-    # clean tmp dir
-    __remove_dir('tmp', parent=None)
-    __check_dir('tmp', parent=None)
-    # ..
-    _tmp_root = os.path.join(ROOT_PATH, 'tmp')
-    try:
-        # copy file to tmp
-        _tar_path = os.path.join(_tmp_root, '__tmp.tar.bz2')
-        shutil.copy(file_path, _tar_path)
-        # change dir for unzipping
-        os.chdir(_tmp_root)
-        # extract files in tmp dir
-        _tar = tarfile.open(file_path)
-        _p_name = _tar.getnames()[0]
-        _tar.extractall()
-        _tar.close()
-    except Exception, e:
-        # prepare message
-        _msg = _('Project import failed!')
-        _msg += _('\n\n[Error] Can not read archive file!')
-        # remove tmp structure
-        __remove_dir('tmp', parent=None)
-        # quit!
-        return __show_in_out_result_message(msg_label, _msg)
-    # 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):
-        # init result message
-        _msg = _('Project sucessfully imported')
-    else:
-        # prepare message
-        _msg = _('Project import failed!')
-        _msg += _('\n\n[Error] Can not load files!')
-        # remove tmp structure
-        __remove_dir('tmp', parent=None)
-        # quit!
-        return __show_in_out_result_message(msg_label, _msg)
-    # existing files stop
-    if len(_exist_list) == 0:
-        pass
-    else:
-        # prepare message
-        _msg += _('\n\n[Warning] Following files already exist:\n')
-        for _f in _exist_list:
-            _msg = '%s - %s\n' % (_msg, _f)
-    # merge keys
-    _existing_dict = __import_keys(activity_, _p_name)
-    if _existing_dict is None:
-        # prepare message
-        _msg = _('Project import failed!')
-        _msg += _('\n\n[Error] Can not load keys!')
-        # remove tmp structure
-        __remove_dir('tmp', parent=None)
-        # quit!
-        return __show_in_out_result_message(msg_label, _msg)
-    if len(_existing_dict['graphics']) == 0\
-    or len(_existing_dict['sounds']) == 0:
-        pass
-    else:
-        # prepare message
-        _msg += _('\n\n[Warning] Following sequences already exist:\n')
-        for _s in _existing_dict['graphics']:
-            _msg = '%s - graphics.%s\n' % (_msg, _s)
-        _msg = '%s\n' % _msg
-        for _s in _existing_dict['sounds']:
-            _msg = '%s - sounds.%s\n' % (_msg, _s)
-    # remove tmp structure
-    __remove_dir('tmp', parent=None)
-    # show result
-    __show_in_out_result_message(msg_label, _msg)
-
-
-def __remove_dir(dir_name, parent=None):
-    # get activity path
-    if parent is None:
-        _dir = os.path.join(ROOT_PATH, dir_name)
-        _next_parent = dir_name
-    else:
-        _dir = os.path.join(ROOT_PATH, parent, dir_name)
-        _next_parent = os.path.join(parent, dir_name)
-    # remove files and dir recursively
-    if os.path.exists(_dir):
-        for _f in os.listdir(_dir):
-            _p = os.path.join(_dir, _f)
-            if os.path.isdir(_p):
-                __remove_dir(_f, parent=_next_parent)
-            else:
-                os.remove(_p)
-        # and remove the dir
-        if os.path.exists(_dir):
-            os.removedirs(_dir)
-        else:
-            pass
-    # nothing to do
-    else:
-        pass
-
-
-def __export_seq_and_res(activity_, tmp_root, type_='graphics'):
-    # path updates
-    _seq_src = os.path.join(ROOT_PATH, 'data', 'sequences',
-            type_)
-    _seq_dst = os.path.join(tmp_root, 'sequences', type_)
-    # ..
-    _res_root = os.path.join(ROOT_PATH, '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()
-    # get the projet name
-    _name = _toolbar.title.get_text()
-    # clean tmp dir first
-    __remove_dir('tmp', parent=None)
-    __check_dir('tmp', parent=None)
-    # 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(ROOT_PATH, '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')
-    # change dir for zipping
-    os.chdir(_tmp_root)
-    # zip all
-    _tar_name = '%s.tar.bz2' % _name
-    # ..
-    _tar = tarfile.open(_tar_name, "w:bz2")
-    _tar.add(_name)
-    _tar.close()
-    # try to copy
-    try:
-        if os.path.exists(os.path.join('/media', media, _tar_name)):
-            # ..
-            _msg = _('Project') + ' "' + _name + '" '
-            _msg += _('already exported to') + ' "' + media + '" '
-        else:
-            # ..
-            shutil.copy(os.path.join(_tmp_root, _tar_name),
-                    os.path.join('/media', media))
-            # ..
-            _msg = _('Project') + ' "' + _name + '" '
-            _msg += _('sucessfully exported to') + ' "' + media + '" '
-    except Exception, e:
-        # ERROR
-        logger.error('[storage] export_project - e: %s' % e)
-        # ERROR
-        # ..
-        # ..
-        _msg = _('Project') + ' "' + _name + '" '
-        _msg += _('export to') + ' "' + media + '" ' + _('failed!')
-    # remove tmp structure
-    __remove_dir('tmp', parent=None)
-    # tmp message
-    __show_in_out_result_message(msg_label, _msg)
diff --git a/atoideweb/ui/toolbar.py b/atoideweb/ui/toolbar.py
index a2da877..0c0bc03 100644
--- a/atoideweb/ui/toolbar.py
+++ b/atoideweb/ui/toolbar.py
@@ -1,6 +1,6 @@
 
 # python import
-import logging, os, re, shutil
+import logging
 # ...
 from functools import partial
 from gettext import gettext as _
@@ -14,490 +14,59 @@ from sugar.activity import activity
 # sugar import
 from sugar.graphics.toolbutton import ToolButton
 
-# atoidejouer import
-from atoideweb.tools import config, storage
-# from atoidejouer.ui import screens
+# atoideweb import
+from atoideweb.tools import config
+# from atoideweb.ui import screens
 
 # get application logger
-logger = logging.getLogger('atoidejouer')
+logger = logging.getLogger('atoideweb')
 
 
-def _clean_dir(dir_path):
-    # little check first
-    if os.path.exists(dir_path):
-        pass
-    # ???
-    else:
-        return
-    # ..
-    for _filename in os.listdir(dir_path):
-        # ..
-        _path = os.path.join(dir_path, _filename)
-        # little check
-        if os.path.isfile(_path):
-            os.remove(_path)
-        elif os.path.isdir(_path):
-            _clean_dir(_path)
-        else:
-            # ERRROR
-            logger.error('[toolbar] _clean_dir - path error: %s' % dir_path)
-    # remove dir at the end
-    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()
-        # nothing to do
-        else:
-            pass
-
-
-def _cb_seq_save(widget, 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
-    # little check
-    if _name.strip() == '':
-        return
-    elif _nb_of_items == 0\
-    and remove is True:
-        # get sequence path
-        _seq_path = storage.get_sequence_path(_type, _name)
-        # 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:
-        # get sequence path
-        _seq_path = storage.get_sequence_path(_type, _name)
-        # 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 _show_browser(toolbar, cls):
-    # next screen name
-    _screen_name = '%s_add' % toolbar.name
-    # do switch
-    toolbar._switch(_screen_name)
-    # get or create screen
-    _screen = toolbar.activity.get_screen(_screen_name)\
-            if toolbar.activity.has_screen(_screen_name)\
-            else cls(toolbar)
-    # update activity screens
-    toolbar.activity.set_current_screen(_screen_name, _screen)
-    # do show
-    _screen._show()
-    # update entry
-    _seq_name = _screen.notebook.current_sequence
-    if _seq_name is None:
-        pass
-    else:
-        # ..
-        toolbar._sequence_entry.set_text(_seq_name)
-        # pos
-        _current_pos = _screen.sequence_preview.get_current_pos()
-        toolbar._frame_entry.set_text(str(_current_pos))
-"""
-
-
-def _cb_add(widget, toolbar):
-    # browser screen factory
-    if toolbar.name == 'graphics':
-        # _show_browser(toolbar, screens.ScreenBrowserGraphics)
-        pass
-    # add graphic to the sequence
-    elif toolbar.name in ['graphics_add', 'sounds_add']:
-        # get current screen
-        _screen = toolbar.activity.get_current_screen()
-        # get graphic name
-        _item_name = _screen.notebook.current_item
-        # ..
-        _sequence_name = _screen.notebook.current_sequence
-        if _sequence_name is None\
-        or _sequence_name.strip() == ''\
-        or _item_name is None:
-            pass
-        else:
-            # udpate sequence preview
-            _screen.sequence_preview.add_item(_item_name)
-            # update sequence file
-            _cb_seq_save(widget, toolbar)
-    # ..
-    elif toolbar.name == 'sounds':
-        # _show_browser(toolbar, screens.ScreenBrowserSounds)
-        pass
-    # ??
-    else:
-        # ERROR
-        logger.error('[toolbar] _cb_add - unknown: %s' % toolbar.name)
-
-
-def _cb_remove(widget, toolbar):
-    # browser screen factory
-    if toolbar.name == 'graphics':
-        pass
-    # add graphic to the sequence
-    elif toolbar.name in ['graphics_add', 'sounds_add']:
-        # ..
-        _screen = toolbar.activity.get_current_screen()
-        # udpate sequence preview
-        _screen.sequence_preview.remove_current()
-        # seq name
-        _seq_name = _screen.notebook.current_sequence
-        _file_name = _screen.notebook.current_item
-        # ..
-        _keys = toolbar.activity.graphic_keys\
-                if toolbar.name == 'graphics_add'\
-                else toolbar.activity.sound_keys
-        # remove from keys
-        _keys.remove_filename_from_all(_seq_name, _file_name)
-        # update sequence file
-        _cb_seq_save(widget, toolbar, remove=True)
-    # ..
-    elif toolbar.name == 'sounds':
-        pass
-    # add graphic to the sequence
-    elif toolbar.name == 'sounds_add':
-        pass
-    # ??
-    else:
-        # ERROR
-        logger.error('[toolbar] _cb_remove - name: %s' % toolbar.name)
-
-
-def _cb_frame_after(widget, toolbar):
-    # get previous value
-    _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):
-    # get previous value
-    _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):
-    # get screen
-    _screen = toolbar.activity.get_current_screen()
-    # get max value
-    _max = _screen.sequence_preview.number_of_items() - 1
-    # prepare value
-    _new_val = None
-    if value > _max:
-        _new_val = _max
-    elif value < 0:
-        _new_val = 0
-    # reset max just in case
-    else:
-        _new_val = value
-    # update entry
-    toolbar._frame_entry.set_text(str(_new_val))
-    # update sequence
-    _screen.sequence_preview.move_current(_new_val)
-
-
-def _cb_open(widget, toolbar):
-    pass
-
-
-def _cb_back(widget, toolbar):
-    # do switch
-    toolbar._switch(toolbar.name.replace('_add', ''))
-    # restore screen
-    toolbar.activity._change_screen(toolbar)
-
-
-def _cb_import(widget, toolbar):
-    # get the current sequence name
-    _sequence_name = toolbar._sequence_entry.get_text()
-    # get filenames
-    _screen = toolbar.activity.get_current_screen()
-    # shortcut
-    _filenames = _screen.sequence_preview.items
-    # and back
-    _cb_back(widget, toolbar)
-    # add sequence to the story keys
-    if toolbar.story_keys.add_sequence(_sequence_name, _filenames):
-        # get screen now
-        _screen = toolbar.activity.get_current_screen()
-        # add sequence to the timeline
-        _screen.timeline.add_sequence(_sequence_name)
-        # ..
-        _screen.scene.refresh()
-    # already added
-    else:
-        pass
-
-
-def _cb_play(widget, toolbar):
-    # replace play button
-    toolbar._replace_button('play', 'pause')
-    # trigger playing
-    toolbar.activity._thread.play()
-
-
-def _cb_pause(widget, toolbar):
-    # replace pause button
-    toolbar._replace_button('pause', 'play')
-    # trigger pausing
-    toolbar.activity._thread.pause()
-
-
-def _cb_stop(widget, toolbar):
-    # replace pause button - if playing
-    if toolbar._has_button('pause'):
-        # ..
-        toolbar._replace_button('pause', 'play')
-    else:
-        pass
-    # update main thread
-    toolbar.activity._thread.pause(stop=True)
-    # ..
-    toolbar.activity._thread.set_time()
-
-
-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()
-    # get current screen
-    _screen = toolbar.activity.get_current_screen()
-    # enbale fullscreen
-    _screen.set_fullscreen(True)
-
-
-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()
-    # get current screen
-    _screen = toolbar.activity.get_current_screen()
-    # disable fullscreen
-    _screen.set_fullscreen(False)
-
-
-def _cb_slider(widget, event, toolbar):
-    """action = 'press' or 'release'
-    """
-    # ...
-    if event.type == gtk.gdk.BUTTON_PRESS:
-        pass
-    elif event.type == gtk.gdk.BUTTON_RELEASE:
-        toolbar.activity._thread.set_time(time_=widget.get_value())
-    # ??
-    else:
-        pass
-
-
-def _cb_format_value(widget, value, toolbar):
-    """Format the slider value to display
-    """
-    # return formated value
-    return '%1d:%02d' % divmod(value, 60)
-
+def _cb_default(widget, toolbar):
+    # DEBUG
+    logger.debug('[toolbar] cb - toolbar.name: %s' % toolbar.name)
 
 BUTTONS = {
-        'add' : ['list-add', _cb_add],
-        'back' : ['edit-undo', _cb_back],
-        'backward' : ['media-seek-backward', None],
-        'forward' : ['media-seek-forward', None],
-        'frame_after' : ['go-right', _cb_frame_after],
-        'frame_before' : ['go-left', _cb_frame_before],
-        'frame_entry' : [None, None],
-        'import' : ['insert-image', _cb_import],
-        'open' : ['media', _cb_open],
-        'pause' : ['media-playback-pause', _cb_pause],
-        'play' : ['media-playback-start', _cb_play],
-        'remove' : ['list-remove', _cb_remove],
+        'add' : ['list-add', _cb_default],
+        'back' : ['edit-undo', _cb_default],
+        'backward' : ['media-seek-backward', _cb_default],
+        'forward' : ['media-seek-forward', _cb_default],
+        'open' : ['media', _cb_default],
+        'pause' : ['media-playback-pause', _cb_default],
+        'play' : ['media-playback-start', _cb_default],
+        'remove' : ['list-remove', _cb_default],
         '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],
-        'view_return' : ['view-return', _cb_view_return],
+        'stop' : ['media-playback-stop', _cb_default],
         }
 
 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'
+        'eating' : [
+            ['stop', 'play', 'slider',
              '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'],
+        'spare-time' : [
+            ['stop', 'play',],
             []
             ],
         }
 
 TITLES = {
-        'graphics' : {
+        'eating' : {
             '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'),
-            'buttons': {
-                # 'backward': _('Seek Backward'),
-                # 'forward': _('Seek Forward'),
-                'pause': _('Pause Story'),
-                'play': _('Play Story'),
+                'play': _('Play'),
                 'slider': _('Progress Bar'),
-                'stop': _('Stop Story'),
-                'add': _('Add Sound'),
+                'stop': _('Stop'),
+                'add': _('Add'),
                 }
             },
-        'sounds_add' : {
+        'spare-time' : {
             'toolbox': None,
             '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'),
-                'pause': _('Pause Story'),
-                'play': _('Play Story'),
-                'slider': _('Progress Bar'),
-                'stop': _('Stop Story'),
-                'view_fullscreen': _('Fullscreen'),
-                'view_return': _('Default Screen'),
+                'play': _('Play'),
+                'stop': _('Stop'),
                 }
             },
         }
@@ -512,18 +81,8 @@ 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
-        # keep components
-        self._sequence_entry = None
-        self._frame_entry = None
         # init widget dict
         self._button_dict = dict()
         # init buttons
@@ -577,60 +136,6 @@ class Toolbar(gtk.Toolbar):
             # add button
             self._add_button(_b)
 
-    def update_slider(self, time_, pause):
-        # get slider
-        _s = self.get_slider()
-        # slider stuff
-        if _s is None:
-            pass
-        else:
-            _s.set_value(time_)
-        # update pause status
-        if pause is True:
-            self._replace_button('pause', 'play')
-        else:
-            self._replace_button('play', 'pause')
-
-    def get_slider(self):
-        # little check
-        if 'slider' in self._button_dict:
-            _children = self._button_dict['slider'].get_children()
-            return None if len(_children) == 0 else _children[0]
-        else:
-            return None
-
-    def play(self):
-        # do pause
-        _cb_play(None, self)
-
-    def pause(self):
-        # do pause
-        _cb_pause(None, self)
-
-    def refresh(self, value):
-        # ...
-        if self._number_of_keys != self.activity._number_of_keys:
-            # update nb of keys
-            self._number_of_keys = self.activity._number_of_keys
-            # update adjustment
-            if hasattr(self._adjustment, 'set_upper'):
-                self._adjustment.set_upper(self._number_of_keys-1)
-            else:
-                self._adjustment.upper = self._number_of_keys-1
-        else:
-            pass
-        # get slider
-        _s = self.get_slider()
-        # slider stuff
-        if _s is None:
-            # just in case
-            value = 0
-        else:
-            # update value
-            _s.set_value(int(value))
-        # return _v to keep time value in thread
-        return value
-
     def _on_focus(self, widget, direction):
         if self.name in ['graphics_add', 'sounds_add']:
             self._switch(self.name.replace('_add', ''))
@@ -656,50 +161,6 @@ class Toolbar(gtk.Toolbar):
         if button_id == 'separator':
             _buton = gtk.SeparatorToolItem()
             _buton.set_draw(True)
-        # manage slider
-        elif button_id == 'slider':
-            #
-            self._adjustment = gtk.Adjustment(0, 0, self._number_of_keys-1, 1)
-            # ..
-            _hscale = gtk.HScale(self._adjustment)
-            _hscale.set_draw_value(True)
-            _hscale.set_digits(False)
-            _hscale.set_update_policy(gtk.UPDATE_CONTINUOUS)
-            # manage cb
-            _hscale.connect('button-release-event', _cb, self)
-            _hscale.connect('format-value', _cb_format_value, self)
-            # show
-            _hscale.show()
-            # ..
-            _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()
-            # ..
-            self._frame_entry.set_editable(False)
-            self._frame_entry.set_width_chars(2)
-            self._frame_entry.set_size_request(44, -1)
-            # set value
-            self._frame_entry.set_text('0')
-            # center text
-            self._frame_entry.set_alignment(1)
-            # show
-            self._frame_entry.show()
-            # ..
-            _buton = gtk.ToolItem()
-            _buton.add(self._frame_entry)
         # standard button
         elif button_id in BUTTONS:
             # get tooltip