refactoring to enhance perfomance issue -> dnd broken .. ooops! but no crash and less loadings!

5 files changed, 131 insertions, 145 deletions

diff --git a/activity.py b/activity.py
index 0b1d0fd..2de755a 100644
--- a/activity.py
+++ b/activity.py
@@ -247,6 +247,13 @@ class AToiDeJouerActivity(activity.Activity):
                 toolbar.pause()
                 # update all
                 self._thread.set_time()
+            if self._current == 'graphics'\
+            or self._current == 'sounds':
+                # .. refresh
+                self._screens[self._current].timeline.refresh_sequence()
+                self._screens[self._current].timeline.refresh_adjustment()
+            else:
+                pass
             # exit
             return
         # ..
@@ -264,6 +271,7 @@ class AToiDeJouerActivity(activity.Activity):
                 _scr.timeline.add_sequence(_n)
             # .. refresh
             _scr.timeline.refresh_sequence()
+            _scr.timeline.refresh_adjustment()
         elif self._current == 'sounds':
             _scr = screens.ScreenEditSounds(toolbar)
             # .. init sequences
@@ -271,6 +279,7 @@ class AToiDeJouerActivity(activity.Activity):
                 _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)
         else:
diff --git a/atoidejouer/story/keys.py b/atoidejouer/story/keys.py
index a0277ae..2f41e10 100644
--- a/atoidejouer/story/keys.py
+++ b/atoidejouer/story/keys.py
@@ -86,7 +86,7 @@ class StoryKeys(object):
                 # work on seq dict copy
                 for _frame_name, _frame_dict in _seq_dict.items():
                     # seq dict copy update
-                    _tmp_seq_dict[int(_frame_name)] = _frame_dict
+                    _tmp_seq_dict[float(_frame_name)] = _frame_dict
                 # update main dict
                 self._keys[_seq_name] = _tmp_seq_dict
             # sequence does not exist
@@ -368,7 +368,8 @@ class StoryKeys(object):
                 # return default
                 return [0, 0]
 
-    def get_next_align(self, sequence_name, frame, use_transition=False):
+    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
@@ -377,19 +378,26 @@ class StoryKeys(object):
             _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
+            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 [0, 0]
+        return None, None
 
     def inc_position(self, sequence_name, frame, filename, move, value):
         # get align first
@@ -523,8 +531,6 @@ class StoryKeys(object):
         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
diff --git a/atoidejouer/ui/panel.py b/atoidejouer/ui/panel.py
index e255814..8e65bea 100644
--- a/atoidejouer/ui/panel.py
+++ b/atoidejouer/ui/panel.py
@@ -37,7 +37,7 @@ def _on_graphic_combo_changed(combobox, panel):
     _filename = _get_filename(panel)
     # get current
     _current, _f_type, _k_type = panel.story_keys.get_current(
-            panel._sequence_name, _activity._thread._time)
+            panel.sequence_name, _activity._thread._time)
     # do nothing
     if _filename is None\
     or _k_type == 'transition'\
@@ -46,33 +46,33 @@ def _on_graphic_combo_changed(combobox, panel):
     # ...
     elif _filename == '':
         # remove key
-        panel.story_keys.remove_filename(panel._sequence_name,
+        panel.story_keys.remove_filename(panel.sequence_name,
                 _activity._thread._time, _current)
         # reset current
-        panel.story_keys.set_current(panel._sequence_name,
+        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,
+        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)
+                    panel.sequence_name, _activity._thread._time)
             # set align
-            panel.story_keys.set_align(panel._sequence_name,
+            panel.story_keys.set_align(panel.sequence_name,
                     _activity._thread._time, _filename, _prev_align)
         else:
             pass
     # ...
-    panel.story_keys.refresh(panel._sequence_name)
+    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)
+    panel.screen.scene.refresh(sequence_name=panel.sequence_name)
 
 
 def _on_position_clicked(widget, panel, move, value):
@@ -82,7 +82,7 @@ def _on_position_clicked(widget, panel, move, value):
     _filename = _get_filename(panel)
     # get current
     _current, _f_type, _k_type = panel.story_keys.get_current(
-            panel._sequence_name, _activity._thread._time)
+            panel.sequence_name, _activity._thread._time)
     # do nothing
     if _filename is None\
     or _k_type != 'key'\
@@ -90,24 +90,24 @@ def _on_position_clicked(widget, panel, move, value):
         pass
     else:
         # update keys
-        _x, _y = panel.story_keys.inc_position(panel._sequence_name,
+        _x, _y = panel.story_keys.inc_position(panel.sequence_name,
                 _activity._thread._time, _filename, move, value)
         # ...
-        panel.story_keys.refresh(panel._sequence_name)
+        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)
+        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)
+    _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:
@@ -125,9 +125,9 @@ def _on_layout_clicked(widget, panel, move):
         # ??
         return
     # ..
-    panel.story_keys.set_layout(panel._sequence_name, _layout)
+    panel.story_keys.set_layout(panel.sequence_name, _layout)
     # ...
-    panel.story_keys.refresh(panel._sequence_name)
+    panel.story_keys.refresh(panel.sequence_name)
     # refresh timeline
     panel.screen.timeline.refresh_sequence()
     # update entry
@@ -149,9 +149,9 @@ def _on_time_clicked(widget, panel, value):
     _activity = panel.screen.toolbar.activity
     # get current
     _current, _f_type, _k_type = panel.story_keys.get_current(
-            panel._sequence_name, _activity._thread._time)
+            panel.sequence_name, _activity._thread._time)
     # little check
-    if panel._sequence_name is None:
+    if panel.sequence_name is None:
         return panel.time_entry.set_text('')
     # do nothing
     elif _k_type == 'transition'\
@@ -165,10 +165,10 @@ def _on_time_clicked(widget, panel, value):
     # 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,
+    panel.story_keys.set_frame(panel.sequence_name, _previous_frame,
                                    _new_frame)
     # ...
-    panel.story_keys.refresh(panel._sequence_name)
+    panel.story_keys.refresh(panel.sequence_name)
     # refresh timeline
     panel.screen.timeline.refresh_sequence()
     # set activity new number of keys
@@ -176,16 +176,16 @@ def _on_time_clicked(widget, panel, value):
     # update thread time
     _activity._thread.set_time(time_=_new_frame)
     # restore current
-    panel.screen.timeline.set_active_sequence(panel._sequence_name)
+    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)
+    panel.story_keys.remove_sequence(panel.sequence_name)
     # reorder timeline
-    panel.screen.timeline.remove_sequence(panel._sequence_name)
+    panel.screen.timeline.remove_sequence(panel.sequence_name)
     # ..
     panel.clear()
     # ...
@@ -199,21 +199,21 @@ def _on_remove_key_clicked(widget, panel):
     _activity = panel.screen.toolbar.activity
     # get current
     _current, _f_type, _k_type = panel.story_keys.get_current(
-            panel._sequence_name, _activity._thread._time)
+            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,
+    panel.story_keys.remove_filename(panel.sequence_name,
             _activity._thread._time, _current)
     # reset current
-    panel.story_keys.set_current(panel._sequence_name,
+    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)
+    panel.story_keys.refresh(panel.sequence_name)
     # refresh timeline
     panel.screen.timeline.refresh_sequence()
     # ...
@@ -231,9 +231,9 @@ def _on_duration_clicked(widget, panel, value):
     _filename = _get_filename(panel)
     # get current
     _current, _f_type, _k_type = panel.story_keys.get_current(
-            panel._sequence_name, _activity._thread._time)
+            panel.sequence_name, _activity._thread._time)
     # do nothing
-    if panel._sequence_name is None:
+    if panel.sequence_name is None:
         panel.entry_duration.set_text('')
     elif _filename is None\
     or _k_type != 'key'\
@@ -241,10 +241,10 @@ def _on_duration_clicked(widget, panel, value):
         pass
     else:
         # update keys
-        _d = panel.story_keys.inc_duration(panel._sequence_name,
+        _d = panel.story_keys.inc_duration(panel.sequence_name,
                 _activity._thread._time, _filename, value)
         # ...
-        panel.story_keys.refresh(panel._sequence_name)
+        panel.story_keys.refresh(panel.sequence_name)
         # refresh timeline
         panel.screen.timeline.refresh_sequence()
         # update panel entries
@@ -261,9 +261,9 @@ def _on_loop_click(toggle, panel, image):
     _filename = _get_filename(panel)
     # get current
     _current, _f_type, _k_type = panel.story_keys.get_current(
-            panel._sequence_name, _activity._thread._time)
+            panel.sequence_name, _activity._thread._time)
     # do nothing
-    if panel._sequence_name is None:
+    if panel.sequence_name is None:
         panel.toggle_loop.set_active(False)
     elif _filename is None\
     or _k_type != 'key'\
@@ -272,10 +272,10 @@ def _on_loop_click(toggle, panel, image):
     else:
         _loop = toggle.get_active()
         # update keys
-        panel.story_keys.set_loop(panel._sequence_name,
+        panel.story_keys.set_loop(panel.sequence_name,
                 _activity._thread._time, _filename, _loop)
         # ...
-        panel.story_keys.refresh(panel._sequence_name)
+        panel.story_keys.refresh(panel.sequence_name)
         # refresh timeline
         panel.screen.timeline.refresh_sequence()
 
@@ -432,7 +432,7 @@ class Panel(gtk.Frame):
         self.show()
         # init vars
         self._store = None
-        self._sequence_name = None
+        self.sequence_name = None
         # ..
         self.combo_box = None
         self.time_entry = None
@@ -480,7 +480,7 @@ class Panel(gtk.Frame):
         self.combo_box.add_attribute(_cell_text, 'text', 1)
 
     def clear(self):
-        self._sequence_name = None
+        self.sequence_name = None
         self.time_entry.set_text('')
         self.update_store()
 
@@ -506,7 +506,7 @@ class Panel(gtk.Frame):
         if sequence_name is None:
             pass
         else:
-            self._sequence_name = sequence_name
+            self.sequence_name = sequence_name
         # update store
         if update_store is True:
             self.update_store()
@@ -514,13 +514,13 @@ class Panel(gtk.Frame):
             pass
         # prepare dir path
         _seq_path = os.path.join(activity.get_activity_root(), 'data',
-                'sequences', type_, '%s.seq' % self._sequence_name)
+                '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)
+                    self.sequence_name, _activity._thread._time)
             # get sound names
             _items = storage.get_sequence_items(_seq_path)
             # get combo box active
@@ -668,11 +668,11 @@ class PanelGraphics(Panel):
         # little check
         if os.path.exists(_seq_path):
             # get current layout
-            _layout = self.story_keys.get_layout(self._sequence_name)
+            _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,
+            _x, _y = self.story_keys.get_align(self.sequence_name,
                     _activity._thread._time, _current)
             # update panel x
             if self.entry_x is None:
@@ -692,7 +692,7 @@ class PanelGraphics(Panel):
         Panel.update_store(self)
         # prepare dir path
         _seq_path = os.path.join(activity.get_activity_root(), 'data',
-                'sequences', 'graphics', '%s.seq' % self._sequence_name)
+                'sequences', 'graphics', '%s.seq' % self.sequence_name)
         # little check
         if os.path.exists(_seq_path):
             # get graphic names
@@ -882,7 +882,7 @@ class PanelSounds(Panel):
         Panel.update_store(self)
         # prepare dir path
         _seq_path = os.path.join(activity.get_activity_root(), 'data',
-                'sequences', 'sounds', '%s.seq' % self._sequence_name)
+                'sequences', 'sounds', '%s.seq' % self.sequence_name)
         # little check
         if os.path.exists(_seq_path):
             # get graphic names
@@ -1009,12 +1009,12 @@ class PanelSounds(Panel):
                 pass
             else:
                 # get current x and y
-                _d = self.story_keys.get_duration(self._sequence_name,
+                _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,
+            _l = self.story_keys.get_loop(self.sequence_name,
                     _activity._thread._time, _current)
             # ...
             self.toggle_loop.set_active(_l)
diff --git a/atoidejouer/ui/screens.py b/atoidejouer/ui/screens.py
index cf511b3..31518ea 100644
--- a/atoidejouer/ui/screens.py
+++ b/atoidejouer/ui/screens.py
@@ -299,7 +299,7 @@ class ScreenStory(graphics.Scene):
         # and return displayed code
         return _code
 
-    def __get_transition_align(self, sequence_name, filename, time, rate):
+    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)
@@ -309,9 +309,12 @@ class ScreenStory(graphics.Scene):
             return _x, _y
         else:
             _next_x, _next_y = self._get_keys('graphics').get_next_align(
-                    sequence_name, int(time), use_transition=True)
+                    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 _x + (_next_x - _x) * _ratio, _y + (_next_y - _y) * _ratio
+            return _next_x, _next_y
 
     def _get_current_code(self, type_, sequence_name, time):
         # get sequence filename
@@ -343,8 +346,8 @@ class ScreenStory(graphics.Scene):
         # get/update width and height
         _size = self._update_w_h(_current)
         # get align
-        _align = self.__get_transition_align(sequence_name, _current,
-                time, rate)
+        _align = self.__get_transition_align(sequence_name, time, _current,
+                rate)
         # ensure current image
         if _code in self.__graphics:
             # ..
@@ -476,7 +479,7 @@ class ScreenStory(graphics.Scene):
 
     def _show(self):
         # first refresh
-        self.refresh()
+        # self.refresh()
         # ..
         self.show()
         # update size request
@@ -638,12 +641,19 @@ class ScreenBrowserSounds(ScreenBrowser):
 
 
 def _on_toggle_click(radio, screen, option, value):
-    # ensure config for further use
-    config.Config().set('activity>%s' % option, value)
+    # manage change state manually
+    _previous = config.Config().get('activity>%s' % option)
     # remove screens to recreate them after
-    if option == 'mode':
-        screen._activity.remove_screen('graphics')
-        screen._activity.remove_screen('sounds')
+    if screen._initialized is True\
+    and _previous != value:
+        # update
+        config.Config().set('activity>%s' % option, value)
+        # ...
+        if option == 'mode':
+            screen._activity.remove_screen('graphics')
+            screen._activity.remove_screen('sounds')
+        else:
+            pass
     else:
         pass
 
@@ -701,6 +711,8 @@ class ScreenActivity(gtk.ScrolledWindow):
         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
@@ -721,61 +733,6 @@ class ScreenActivity(gtk.ScrolledWindow):
         # do show
         self._show()
 
-    def __refresh_mode_part(self):
-        # get mode value
-        _mode = config.Config().get_mode()
-        # update ui
-        for _i, _b in enumerate(self._group_mode):
-            _b.set_active(False)
-        # update radio boxes
-        if _mode == 'easy':
-            self._group_mode[EASY].set_active(True)
-        elif _mode == 'advanced':
-            self._group_mode[ADVANCED].set_active(True)
-        # default easy
-        else:
-            self._group_mode[EASY].set_active(True)
-
-    def __refresh_rate_part(self):
-        # get rate value
-        _rate = config.Config().get_rate()
-        # update ui
-        for _i, _b in enumerate(self._group_rate):
-            _b.set_active(False)
-        # update radio boxes
-        if _rate == 'normal':
-            self._group_rate[NORMAL].set_active(True)
-        elif _rate == 'smooth':
-            self._group_rate[SMOOTH].set_active(True)
-        elif _rate == 'faster':
-            self._group_rate[FASTER].set_active(True)
-        # default easy
-        else:
-            self._group_rate[NORMAL].set_active(True)
-
-    def __refresh_dnd_part(self):
-        # get dnd value
-        _dnd = config.Config().get_dnd()
-        # update ui
-        for _i, _b in enumerate(self._group_dnd):
-            _b.set_active(False)
-        # update radio boxes
-        if _dnd == 'no':
-            self._group_dnd[NO].set_active(True)
-        elif _dnd == 'yes':
-            self._group_dnd[YES].set_active(True)
-        # default no
-        else:
-            self._group_dnd[NO].set_active(True)
-
-    def refresh(self):
-        # mode
-        self.__refresh_mode_part()
-        # rate
-        self.__refresh_rate_part()
-        # dnd
-        self.__refresh_dnd_part()
-
     def _get_title(self, text):
         # init 
         _label = gtk.Label()
@@ -794,8 +751,11 @@ class ScreenActivity(gtk.ScrolledWindow):
         # 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('clicked', _on_toggle_click, self, option, value)
+        _toggle.connect('toggled', _on_toggle_click, self, option, value)
         # return it
         return _toggle
 
@@ -964,9 +924,8 @@ class ScreenActivity(gtk.ScrolledWindow):
                 expand=False, fill=True)
 
     def _show(self):
+        self._initialized = True
         # show all
         self.show()
         # update toolbar
         self._activity.set_canvas(self)
-        # always refresh after show
-        self.refresh()
diff --git a/atoidejouer/ui/timeline.py b/atoidejouer/ui/timeline.py
index 51a5f53..60c741f 100644
--- a/atoidejouer/ui/timeline.py
+++ b/atoidejouer/ui/timeline.py
@@ -22,11 +22,14 @@ def _on_title_clicked(widget, timeline, sequence_name):
 
 def _on_key_clicked(widget, timeline, sequence_name, frame):
     # shortcut
-    timeline.story_keys.ask_clear()
+    # timeline.story_keys.ask_clear()
     # update time and scene
     timeline.screen.toolbar.activity._thread.set_time(time_=frame)
     # do timeline update
-    timeline.set_active_sequence(sequence_name)
+    if timeline.screen.panel.sequence_name == sequence_name:
+        pass
+    else:
+        timeline.set_active_sequence(sequence_name)
 
 
 class Timeline(gtk.Frame):
@@ -135,7 +138,7 @@ class Timeline(gtk.Frame):
         # _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
+        # _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
@@ -249,8 +252,8 @@ class Timeline(gtk.Frame):
                 # ...
                 _c = _cells[_c_idx]
                 # update row color
-                glib.idle_add(partial(_c.modify_bg, gtk.STATE_NORMAL, _color))
-                glib.idle_add(partial(_c.set_visible_window, True))
+                _c.modify_bg(gtk.STATE_NORMAL, _color)
+                _c.set_visible_window(True)
                 #
                 self._current_keys[_i] = _c
             else:
@@ -358,6 +361,23 @@ class Timeline(gtk.Frame):
             # 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\
@@ -372,18 +392,10 @@ class Timeline(gtk.Frame):
             self.__reset()
         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
-        # ..
-        glib.idle_add(partial(self.hadjustment.set_value, _new_value))
+        self.refresh_adjustment(time=_time)
         # first avoid current keys colors
         for _c in self._current_keys.values():
-            glib.idle_add(partial(_c.set_visible_window, False))
+            _c.set_visible_window(False)
         # change cell colors
         self._refresh_keys(_time)
         # udpate sequences