path: root/atoidejouer/ui/timeline.py

# python import
import logging, os
# ..
from functools import partial
from gettext import gettext as _

# gtk import
import gtk, glib

# atoidejouer import
from atoidejouer.tools import storage, ui

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


def _on_title_clicked(widget, timeline, sequence_name):
    # .. do update
    timeline.set_active_sequence(sequence_name)


def _on_key_clicked(widget, timeline, sequence_name, frame):
    # shortcut
    # timeline.story_keys.ask_clear()
    # update time and scene
    timeline.screen.toolbar.activity._thread.set_time(time_=frame)
    # do timeline update
    if timeline.screen.panel.sequence_name == sequence_name:
        pass
    else:
        timeline.set_active_sequence(sequence_name)


class Timeline(gtk.Frame):

    def __init__(self, screen):
        # init parent
        gtk.Frame.__init__(self)
        self.set_shadow_type(gtk.SHADOW_NONE)
        self.set_size_request(-1, 236)
        # do show
        self.show()
        # keep the screen
        self.screen = screen
        self.hadjustment = None
        self.vadjustment = gtk.Adjustment(0, 0, 1, 1)
        # tmp
        _s = self.screen
        self._viewport_width = _s.scene._screen_width - 120
        self._current_keys = dict()
        self._number_of_keys = self._get_number_of_keys()
        # prepare scrolled window
        self.scrolled_window = gtk.ScrolledWindow(vadjustment=self.vadjustment)
        self.scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
        self.scrolled_window.show()
        # ..
        self.add(self.scrolled_window)
        # ..
        if self.screen.toolbar.name == 'graphics':
            self.story_keys = self.screen.toolbar.activity.graphic_keys
        else:
            self.story_keys = self.screen.toolbar.activity.sound_keys
        # ..
        self._main_hbox = None
        self._titles_box = None
        self._keys_box = None
        # ..
        self.__init_rows()

    def __init_rows(self):
        # ..
        if self._main_hbox is None:
            pass
        else:
            self._main_hbox.destroy()
        # a box
        self._main_hbox = gtk.HBox(homogeneous=False, spacing=0)
        # show it
        self._main_hbox.show()
        # ..
        self.scrolled_window.add_with_viewport(self._main_hbox)
        # init main vars
        if self._titles_box is None:
            pass
        else:
            self._titles_box.destroy()
        # init main vars
        if self._keys_box is None:
            pass
        else:
            self._keys_box.destroy()
        # ..
        self._titles_box = None
        self._init_titles_box()
        # ..
        self._keys_box = None
        self._init_keys_box()

    def set_active_sequence(self, sequence_name):
        # get viewport
        _t_rows = self._titles_box.get_children()
        # get viewport
        _k_rows = self._keys_box.get_children()
        # ..
        _c1 = ui.get_color(0.92, 0.92, 0.92)
        _c2 = ui.get_color(0.8, 0.8, 0.8)
        # ...
        for _i, _r in enumerate(_t_rows):
            # title row | row - eventbox - button - label
            _label = _r.get_children()[0].get_children()[0].get_children()[1]
            # prepare color
            _c = _c1 if _label.get_label() == sequence_name else _c2
            # update row color
            _r.modify_bg(gtk.STATE_NORMAL, _c)
            _k_rows[_i].modify_bg(gtk.STATE_NORMAL, _c)
        # update panel at the end
        self.screen.panel.refresh(sequence_name=sequence_name,
                update_store=True)

    def _get_number_of_keys(self):
        """shortcut ..
        """
        return self.screen.toolbar.activity._number_of_keys

    def _get_number_of_rows(self):
        """shortcut ..
        """
        return len(self._titles_box.get_children())

    def _add_title(self, sequence_name):
        # screen name
        _screen_name = self.screen.toolbar.name.replace('_add', '')
        # get first image name
        _img_name = storage.get_sequence_first_graphic_name(_screen_name,
                                                            sequence_name)
        # get button
        _title = ui.get_button(label=sequence_name, img_name=_img_name,
                width=0, padding=(4, 0), img_size=(16, 16))
        # _title.set_size_request(-1, 28)
        # set color
        _title.modify_bg(gtk.STATE_NORMAL, ui.get_color(0.3, 0.5, 0.6)) # TODO manage common colors like a theme
        # _title.modify_bg(gtk.STATE_PRELIGHT, ui.get_color(0.5, 0.7, 0.8)) # TODO manage common colors like a theme
        # get row number
        _row_number = self._get_number_of_rows()
        # add simple cb
        _title.connect('released', _on_title_clicked, self, sequence_name)
        # to manage color
        _e_box = gtk.EventBox()
        # show
        _e_box.show()
        # ..
        _e_box.modify_bg(gtk.STATE_NORMAL, ui.get_color(0.8, 0.8, 0.8)) # TODO manage common colors like a theme
        # add it
        _e_box.add(_title)
        # add it
        self._titles_box.pack_start(_e_box, expand=False, fill=True)

    def _add_keys(self, sequence_name):
        # default row color
        _c = ui.get_color(0.8, 0.8, 0.8)
        # to manage color
        _e_box = gtk.EventBox()
        # show
        _e_box.show()
        # ..
        _e_box.modify_bg(gtk.STATE_NORMAL, _c)
        # init row
        _row = gtk.HBox(homogeneous=False, spacing=1)
        # show
        _row.show()
        # add it
        _e_box.add(_row)
        # ..
        for _x in range(self._get_number_of_keys()):
            # to manage color
            _e = gtk.EventBox()
            # show
            _e.show()
            # ..
            _e.set_visible_window(False)
            # get button
            _b = ui.get_button(label='', width=24) # label='%s' % _x
            # add simple cb
            _b.connect('released', _on_key_clicked, self, sequence_name, _x)
            # add to event box
            _e.add(_b)
            # set color
            _b.modify_bg(gtk.STATE_NORMAL, _c)
            # add to the row
            _row.pack_start(_e, expand=False, fill=True)
        # add it
        self._keys_box.pack_start(_e_box, expand=False, fill=True)

    def _refresh_row_keys(self, row, time_, color):
        # 
        _r_e_box = row.get_children()[0]
        # get cells
        _cells = _r_e_box.get_children()
        _c_idx = int(time_)
        # ..
        for _i, _c in enumerate(_cells):
            if _i == _c_idx:
                pass
            else:
                # update row color
                _c.modify_bg(gtk.STATE_NORMAL, color)

    def _init_titles_box(self):
        # prepare scrolled window
        _viewport = gtk.Viewport()
        _viewport.set_size_request(100, -1)
        _viewport.show()
        # init row
        self._titles_box = gtk.VBox(homogeneous=False, spacing=1)
        # show
        self._titles_box.show()
        # ..
        _viewport.add(self._titles_box)
        # update main box
        self._main_hbox.pack_start(_viewport, expand=False, fill=True)

    def _init_keys_box(self):
        # init horizontal adjustment
        self.hadjustment = gtk.Adjustment(0, 0, self._number_of_keys, 1)
        # prepare scrolled window
        _viewport = gtk.Viewport(hadjustment=self.hadjustment)
        _viewport.set_size_request(self._viewport_width, -1)
        _viewport.show()
        # init row
        self._keys_box = gtk.VBox(homogeneous=False, spacing=1)
        # show
        self._keys_box.show()
        # ..
        _viewport.add(self._keys_box)
        # ..
        self._main_hbox.pack_start(_viewport, expand=False, fill=True)

    def _refresh_keys(self, time_):
        # ...
        _t_children = self._titles_box.get_children()
        _k_children = self._keys_box.get_children()
        # ..
        _color = ui.get_color(1.0, 1.0, 0.5)
        # for each row
        for _i, _r in enumerate(_k_children):
            # 
            _r_e_box = _r.get_children()[0]
            # get cells
            _cells = _r_e_box.get_children()
            _c_idx = int(time_)
            # ..
            if _c_idx < len(_cells):
                # ...
                _c = _cells[_c_idx]
                # update row color
                _c.modify_bg(gtk.STATE_NORMAL, _color)
                _c.set_visible_window(True)
                #
                self._current_keys[_i] = _c
            else:
                continue

    def reorder(self):
        # get new order
        _names = [_n for _n in self.story_keys.get_names()]
        # ...
        _t_children = self._titles_box.get_children()
        _k_children = self._keys_box.get_children()
        # ...
        for _i, _r in enumerate(_t_children):
            # title row | row - eventbox - button - label
            _label = _r.get_children()[0].get_children()[0].get_children()[1]
            # ...
            if _label.get_label() in _names:
                _index = _names.index(_label.get_label())
            else:
                continue
            # do reorder
            self._titles_box.reorder_child(_r, _index)
            self._keys_box.reorder_child(_k_children[_i], _index)

    def add_sequence(self, sequence_name):
        """Need to rebuild all on each add to ensure valid scrollwindow ??
        """
        # ..
        self.__init_rows()
        # ..
        _seq_names = self.story_keys.get_names()
        # restore all
        for _n in _seq_names:
            # first add title
            self._add_title(_n)
            # second add new keys
            self._add_keys(_n)

    def remove_sequence(self, sequence_name):
        # ...
        _t_children = self._titles_box.get_children()
        _k_children = self._keys_box.get_children()
        # ...
        for _i, _r in enumerate(_t_children):
            # title row | row - eventbox - button - label
            _label = _r.get_children()[0].get_children()[0].get_children()[1]
            # ...
            if _label.get_label() == sequence_name:
                _r.destroy()
                _k_children[_i].destroy()
            else:
                continue

    def refresh_sequence(self):
        # ...
        _t_children = self._titles_box.get_children()
        _k_children = self._keys_box.get_children()
        # sequence to remove
        _seq_to_remove = list()
        # ...
        for _i, _r in enumerate(_t_children):
            # title row | row - eventbox - button - label
            _label_wid = _r.get_children()[0].get_children()[0].get_children()[1]
            _seq_name = _label_wid.get_label()
            # seq check
            if _seq_name in self.story_keys._names:
                pass
            else:
                _seq_to_remove.append(_seq_name)
                continue
            # ...
            for _frame, _c_key in enumerate(_k_children[_i].get_children()[0]):
                # ...
                _current, _f_type, _k_type = self.story_keys.get_current(
                        _seq_name, _frame)
                # get button
                _button = _c_key.get_children()[0]
                # ...
                if _current is None:
                    # _button.set_image(None)
                    _button.set_label("")
                elif _k_type == 'transition':
                    # _button.set_image(None)
                    _button.set_label("-")
                else:
                    # _button.set_image(None)
                    _button.set_label("0")
        # remove non-exisitng sequences
        for _s_name in _seq_to_remove:
            self.remove_sequence(_s_name)


    def __reset(self):
        # ..
        _seq_names = self.story_keys.get_names()
        # remove all
        for _n in _seq_names:
            self.remove_sequence(_n)
        # ??
        _seq_names = self.story_keys.get_names()
        # restore all
        for _n in _seq_names:
            # first add title
            self._add_title(_n)
            # second add new keys
            self._add_keys(_n)

    def refresh_adjustment(self, time=None):
        # ensure time
        if time is None:
            time = 0 if self.screen.toolbar.activity._thread is None\
                    else self.screen.toolbar.activity._thread._time
        else:
            pass
        # compute new adjustment
        _keys_width = self._number_of_keys * 26
        if self._viewport_width < _keys_width:
            _new_value = (_keys_width - self._viewport_width) * time
            _new_value /= float(self._number_of_keys)
        else:
            _new_value = 0
        # ..
        self.hadjustment.set_value(_new_value)

    def refresh(self):
        # ..
        _time = 0 if self.screen.toolbar.activity._thread is None\
                else self.screen.toolbar.activity._thread._time
        # ..
        _activity_nb_of_keys = self._get_number_of_keys()
        # check reset
        if self._number_of_keys != _activity_nb_of_keys:
            # update number of keys
            self._number_of_keys = _activity_nb_of_keys
            # reset
            self.__reset()
        else:
            pass
        self.refresh_adjustment(time=_time)
        # first avoid current keys colors
        for _c in self._current_keys.values():
            _c.set_visible_window(False)
        # change cell colors
        self._refresh_keys(_time)
        # udpate sequences
        self.refresh_sequence()