path: root/atoidejouer/ui/panel.py

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

# gtk import
import gobject, gtk, glib

# sugar import
from sugar.activity import activity

# atoidejouer import
from atoidejouer.tools import config, image, storage, ui

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


def _get_filename(panel):
    # get model
    _model = panel.combo_box.get_model()
    # get iter
    _iter = panel.combo_box.get_active_iter()
    # get filename
    if isinstance(_iter, gtk.TreeIter):
        return _model.get_value(_iter, 1)
    else:
        return None


def _on_graphic_combo_changed(combobox, panel):
    # shortcut
    _activity = panel.screen.toolbar.activity
    # get filename
    _filename = _get_filename(panel)
    # get current
    _current, _f_type, _k_type = panel.story_keys.get_current(
            panel.sequence_name, _activity._thread._time)
    # do nothing
    if _filename is None\
    or _k_type == 'transition'\
    or _activity._thread._pause is False:
        return
    # ...
    elif _filename == '':
        # remove key
        panel.story_keys.remove_filename(panel.sequence_name,
                _activity._thread._time, _current)
        # reset current
        panel.story_keys.set_current(panel.sequence_name,
                _activity._thread._time, None, file_type=None,
                key_type=None)
    elif _current != _filename:
        # update keys
        panel.story_keys.set_current(panel.sequence_name,
                _activity._thread._time, _filename, file_type='lib',
                key_type='key')
        # ..
        if panel.screen.toolbar.name == 'graphics':
            # get previous align
            _prev_align = panel.story_keys.get_previous_align(
                    panel.sequence_name, _activity._thread._time)
            # set align
            panel.story_keys.set_align(panel.sequence_name,
                    _activity._thread._time, _filename, _prev_align)
        else:
            pass
    # ...
    panel.story_keys.refresh(panel.sequence_name)
    # refresh timeline
    panel.screen.timeline.refresh_sequence()
    # refresh scene
    panel.screen.scene.refresh(sequence_name=panel.sequence_name)


def _on_position_clicked(widget, panel, move, value):
    # shortcut
    _activity = panel.screen.toolbar.activity
    # get filename
    _filename = _get_filename(panel)
    # get current
    _current, _f_type, _k_type = panel.story_keys.get_current(
            panel.sequence_name, _activity._thread._time)
    # do nothing
    if _filename is None\
    or _k_type != 'key'\
    or _activity._thread._pause is False:
        pass
    else:
        # update keys
        _x, _y = panel.story_keys.inc_position(panel.sequence_name,
                _activity._thread._time, _filename, move, value)
        # ...
        panel.story_keys.refresh(panel.sequence_name)
        # refresh timeline
        panel.screen.timeline.refresh_sequence()
        # update panel entries
        panel.entry_x.set_text(str(_x))
        panel.entry_y.set_text(str(-_y))
        # refresh scene
        panel.screen.scene.refresh(sequence_name=panel.sequence_name)


def _on_layout_clicked(widget, panel, move):
    # shortcut
    _activity = panel.screen.toolbar.activity
    # get current layout
    _layout = panel.story_keys.get_layout(panel.sequence_name)
    _max_layout = panel.story_keys.get_max_layout()
    # do nothing
    if _activity._thread._pause is False:
        return
    # layout factory
    elif move == 'move_up_up':
        _layout = _max_layout
    elif move == 'move_up':
        _layout = (_layout + 1) if _layout < _max_layout else _max_layout
    elif move == 'move_down':
        _layout = (_layout - 1) if _layout > 0 else 0
    elif move == 'move_down_down':
        _layout = 0
    else:
        # ??
        return
    # ..
    panel.story_keys.set_layout(panel.sequence_name, _layout)
    # ...
    panel.story_keys.refresh(panel.sequence_name)
    # refresh timeline
    panel.screen.timeline.refresh_sequence()
    # update entry
    panel.entry_layout.set_text(str(_layout))
    # refresh scene
    panel.screen.scene.refresh()
    # reorder timeline
    panel.screen.timeline.reorder()


def _on_time_clicked(widget, panel, value):
    # little check
    if hasattr(panel, 'time_entry')\
    or panel.time_entry is None:
        pass
    else:
        return False
    # shortcut
    _activity = panel.screen.toolbar.activity
    # get current
    _current, _f_type, _k_type = panel.story_keys.get_current(
            panel.sequence_name, _activity._thread._time)
    # little check
    if panel.sequence_name is None:
        return panel.time_entry.set_text('')
    # do nothing
    elif _k_type == 'transition'\
    or _activity._thread._pause is False:
        return
    else:
        _previous_frame = _activity._thread._time
    # time factory
    _new_frame = _previous_frame + value
    _new_frame = 0 if _new_frame < 0 else _new_frame
    # entry update
    panel.time_entry.set_text('%1d:%02d' % divmod(_new_frame, 60))
    # update keys
    panel.story_keys.set_frame(panel.sequence_name, _previous_frame,
                                   _new_frame)
    # ...
    panel.story_keys.refresh(panel.sequence_name)
    # refresh timeline
    panel.screen.timeline.refresh_sequence()
    # set activity new number of keys
    _activity.update_number_of_keys()
    # update thread time
    _activity._thread.set_time(time_=_new_frame)
    # restore current
    panel.screen.timeline.set_active_sequence(panel.sequence_name)


def _on_remove_sequence_clicked(widget, panel):
    # shortcut
    _activity = panel.screen.toolbar.activity
    # clear keys
    panel.story_keys.remove_sequence(panel.sequence_name)
    # reorder timeline
    panel.screen.timeline.remove_sequence(panel.sequence_name)
    # ..
    panel.clear()
    # ...
    panel.story_keys.ask_clear()
    # refresh scene
    panel.screen.scene.refresh()


def _on_remove_key_clicked(widget, panel):
    # shortcut
    _activity = panel.screen.toolbar.activity
    # get current
    _current, _f_type, _k_type = panel.story_keys.get_current(
            panel.sequence_name, _activity._thread._time)
    # ..
    if _k_type is None:
        pass
    elif _k_type != 'key':
        return
    # remove key
    panel.story_keys.remove_filename(panel.sequence_name,
            _activity._thread._time, _current)
    # reset current
    panel.story_keys.set_current(panel.sequence_name,
            _activity._thread._time, None, file_type=None,
            key_type=None)
    # ...
    panel.story_keys.refresh(panel.sequence_name)
    # refresh timeline
    panel.screen.timeline.refresh_sequence()
    # ...
    panel.story_keys.ask_clear()
    # refresh scene
    panel.screen.scene.refresh()
    # .. and reset panel
    panel.refresh()


def _on_duration_clicked(widget, panel, value):
    # shortcut
    _activity = panel.screen.toolbar.activity
    # get filename
    _filename = _get_filename(panel)
    # get current
    _current, _f_type, _k_type = panel.story_keys.get_current(
            panel.sequence_name, _activity._thread._time)
    # do nothing
    if panel.sequence_name is None:
        panel.entry_duration.set_text('')
    elif _filename is None\
    or _k_type != 'key'\
    or _activity._thread._pause is False:
        pass
    else:
        # update keys
        _d = panel.story_keys.inc_duration(panel.sequence_name,
                _activity._thread._time, _filename, value)
        # ...
        panel.story_keys.refresh(panel.sequence_name)
        # refresh timeline
        panel.screen.timeline.refresh_sequence()
        # update panel entries
        panel.entry_duration.set_text('%1d:%02d' % divmod(_d, 60))


def _on_loop_click(toggle, panel, image):
    # update image
    _stock_id = 'repeat_grey' if toggle.get_active() is True else 'repeat'
    image.set_from_file(storage.get_icon_path(_stock_id))
    # shortcut
    _activity = panel.screen.toolbar.activity
    # get filename
    _filename = _get_filename(panel)
    # get current
    _current, _f_type, _k_type = panel.story_keys.get_current(
            panel.sequence_name, _activity._thread._time)
    # do nothing
    if panel.sequence_name is None:
        panel.toggle_loop.set_active(False)
    elif _filename is None\
    or _k_type != 'key'\
    or _activity._thread._pause is False:
        pass
    else:
        _loop = toggle.get_active()
        # update keys
        panel.story_keys.set_loop(panel.sequence_name,
                _activity._thread._time, _filename, _loop)
        # ...
        panel.story_keys.refresh(panel.sequence_name)
        # refresh timeline
        panel.screen.timeline.refresh_sequence()


def _get_next_time(panel, factor):
    # get the current frame
    _time = 0.0 if panel.screen.toolbar.activity._thread is None\
            else panel.screen.toolbar.activity._thread._time
    # get rate
    _rate = config.Config().get_rate_value()
    # next time
    _next = _time + factor * _rate
    # get max
    _max = panel.screen.toolbar.activity._number_of_keys - 1
    if _next < _max:
        # ok!
        return _next
    else:
        # return max + pause
        return _max


def _get_previous_time(panel, factor):
    # get the current frame
    _time = 0.0 if panel.screen.toolbar.activity._thread is None\
            else panel.screen.toolbar.activity._thread._time
    # get rate
    _rate = config.Config().get_rate_value()
    # previous time
    _previous = _time - factor * _rate
    # ..
    if _previous < 0:
        # return min
        return 0
    else:
        # ok
        return _previous


def _on_key_press(widget, event, panel):
    # ..
    if isinstance(panel, Panel):
        # ..
        _keyval = event.keyval
        _name = gtk.gdk.keyval_name(_keyval)
        _mod = gtk.accelerator_get_label(_keyval, event.state)
        # ..
        if panel.screen != panel.screen.toolbar.activity.get_current_screen():
            return
        # key factory
        elif panel.screen.toolbar.name == 'graphics':
            # POSITION
            if _name == 'Left' and _mod.startswith('Ctrl+'): # big left
                _on_position_clicked(widget, panel, 'x', -10)
            elif _name == 'Left': # left
                _on_position_clicked(widget, panel, 'x', -1)
            elif _name == 'Right' and _mod.startswith('Ctrl+'): # big right
                _on_position_clicked(widget, panel, 'x', 10)
            elif _name == 'Right': # right
                _on_position_clicked(widget, panel, 'x', 1)
            elif _name == 'Up' and _mod.startswith('Ctrl+'): # big top
                _on_position_clicked(widget, panel, 'y', -10)
            elif _name == 'Up': # top
                _on_position_clicked(widget, panel, 'y', -1)
            elif _name == 'Down' and _mod.startswith('Ctrl+'): # big bottom
                _on_position_clicked(widget, panel, 'y', 10)
            elif _name == 'Down': # bottom
                _on_position_clicked(widget, panel, 'y', 1)
            # LAYOUT
            elif _name == 'Page_Up' and _mod.startswith('Ctrl+'):
                _on_layout_clicked(widget, panel, 'move_up_up')
            elif _name == 'Page_Up':
                _on_layout_clicked(widget, panel, 'move_up')
            elif _name == 'Page_Down' and _mod.startswith('Ctrl+'):
                _on_layout_clicked(widget, panel, 'move_down_down')
            elif _name == 'Page_Down':
                _on_layout_clicked(widget, panel, 'move_down')
            # TIME
            elif _name == 'plus' and _mod.startswith('Ctrl+'):
                _on_time_clicked(widget, panel, 10)
            elif _name == 'plus':
                _on_time_clicked(widget, panel, 1)
            elif _name == 'minus' and _mod.startswith('Ctrl+'):
                _on_time_clicked(widget, panel, -10)
            elif _name == 'minus':
                _on_time_clicked(widget, panel, -1)
            # DELETE
            elif _name == 'BackSpace' and _mod.startswith('Ctrl+'):
                _on_remove_sequence_clicked(widget, panel)
            elif _name == 'BackSpace':
                _on_remove_key_clicked(widget, panel)
            # IMAGE
            # TODO ...
        elif panel.screen.toolbar.name == 'sounds':
            pass
        else:
            pass
        # IN EVERY CASE
        if panel.screen.toolbar.name in ['graphics', 'sounds', 'story']:
            # shortcut
            _thread = panel.screen.toolbar.activity._thread
            # ..
            if _name == 'space': # play right
                # 
                _time = _get_next_time(panel, 1)
                # 
                _thread.set_time(time_=_time, pause=True)
            elif _name == 'space' and _mod.startswith('Ctrl+'): # play left
                # 
                _time = _get_previous_time(panel, 1)
                # 
                _thread.set_time(time_=_time, pause=True)
            # PLAY
            elif _name == 'Return':
                # ..
                if _thread._pause is True:
                    panel.screen.toolbar.play()
                    _thread.play()
                # ..
                else:
                    panel.screen.toolbar.pause()
                    _thread.pause()
            else:
                pass
            # avoid propagation for rendering issue
            widget.emit_stop_by_name('key-press-event')
            # ..
            return False
        else:
            return False
    else:
        return False


class Panel(gtk.Frame):

    def __init__(self, screen):
        # init parent
        gtk.Frame.__init__(self)
        self.set_shadow_type(gtk.SHADOW_NONE)
        # set screen
        self.screen = screen
        # ..
        if screen.toolbar.name == 'graphics':
            self.story_keys = self.screen.toolbar.activity.graphic_keys
        else:
            self.story_keys = self.screen.toolbar.activity.sound_keys
        # get mode
        self._mode = config.Config().get('activity>mode')
        self._conf = config.Config().get('mode>%s' % self._mode, type_=list)
        # ...
        self.set_size_request(298, screen.scene._screen_height)
        # do show
        self.show()
        # init vars
        self._store = None
        self.sequence_name = None
        # ..
        self.combo_box = None
        self.time_entry = None
        # add vbox to the panel for sub frames
        self.main_box = gtk.VBox(homogeneous=False, spacing=0)
        # do show
        self.main_box.show()
        # add it to the panel
        self.add(self.main_box)
        # ..
        self.__init_handler()

    def __init_handler(self):
        # shortcuts
        _activity = self.screen.toolbar.activity
        _handler_id = _activity._handler_id
        if _handler_id is None:
            pass
        else:
            _activity.disconnect(_handler_id)
        # ..
        _activity._handler_id = _activity.connect('key-press-event',
                _on_key_press, self)

    def _init_sequence_box(self):
        # update store
        self.update_store()
        # init combo
        self.combo_box = gtk.ComboBox(model=self._store)
        # set tooltip
        self.combo_box.set_tooltip_text(_('Choose a Sequence Item'))
        # set renderers
        _cell_pix = gtk.CellRendererPixbuf()
        _cell_pix.set_property('width', 48)
        _cell_pix.set_property('height', 36)
        # ..
        self.combo_box.pack_start(_cell_pix, expand=False)
        self.combo_box.add_attribute(_cell_pix, 'pixbuf', 0)
        # ..
        _cell_text = gtk.CellRendererText()
        _cell_text.set_property('xpad', 4)
        _cell_text.set_property('yalign', 0.5)
        # ..
        self.combo_box.pack_start(_cell_text, expand=True)
        self.combo_box.add_attribute(_cell_text, 'text', 1)

    def clear(self):
        self.sequence_name = None
        self.time_entry.set_text('')
        self.update_store()

    def _get_pixbuf(self, graphic_name, dir_='graphics'):
        # get the image path
        _graphic_path = storage.get_image_path(graphic_name, dir_=dir_)
        # return pix and path
        return image.get_pixbuf(_graphic_path, 48, 36), _graphic_path

    def update_store(self):
        # init store
        if self._store is None:
            self._store = gtk.ListStore(gtk.gdk.Pixbuf, gobject.TYPE_STRING,
                    gobject.TYPE_PYOBJECT)
        else:
            self._store.clear()

    def refresh(self, sequence_name=None, update_store=False):
        pass

    def _refresh(self, type_, sequence_name=None, update_store=False):
        # keep older if not specified
        if sequence_name is None:
            pass
        else:
            self.sequence_name = sequence_name
        # update store
        if update_store is True:
            self.update_store()
        else:
            pass
        # prepare dir path
        _seq_path = os.path.join(activity.get_activity_root(), 'data',
                'sequences', type_, '%s.seq' % self.sequence_name)
        # little check
        if os.path.exists(_seq_path):
            _activity = self.screen.toolbar.activity
            # ..
            _current, _f_type, _k_type = self.story_keys.get_current(
                    self.sequence_name, _activity._thread._time)
            # get sound names
            _items = storage.get_sequence_items(_seq_path)
            # get combo box active
            if _current in _items:
                _active = _items.index(_current) + 1
            else:
                _active = 0
            # update combobox
            self.combo_box.set_active(_active)
        else:
            _current = None
        # shortcut
        _activity = self.screen.toolbar.activity
        # time entry update
        if self.time_entry is None:
            pass
        else:
            self.time_entry.set_text(
                    '%1d:%02d' % divmod(_activity._thread._time, 60))
        # ..
        return _seq_path, _current

    def __get_time_button(self, name, value, tooltip_text):
        # init button
        _button = ui.get_button(stock_id=name)
        # set tooltip
        _button.set_tooltip_text(tooltip_text)
        # set cb
        _button.connect('clicked', _on_time_clicked, self, value)
        # ..
        return _button

    def add_frame_time(self):
        # init frame
        _frame_time = gtk.Frame(label=_('Time'))
        _frame_time.set_border_width(1)
        # do show
        _frame_time.show()
        # do add
        self.main_box.pack_start(_frame_time, expand=False, fill=True)
        # get over/under spin buttons
        _time_box = gtk.HBox(homogeneous=False, spacing=4)
        _time_box.set_border_width(4)
        _time_box.show()
        # before ..
        _time_box.pack_start(self.__get_time_button('go_left', -10,
            _('Play Before (10 Frames)')), expand=False, fill=True)
        _time_box.pack_start(self.__get_time_button('go_left_small', -1,
            _('Play Before (1 Frames)')), expand=False, fill=True)
        # entry
        self.time_entry = gtk.Entry()
        # show
        self.time_entry.show()
        # set value - should be a string
        self.time_entry.set_text('')
        self.time_entry.set_alignment(1)
        self.time_entry.set_property('editable', False)
        # add entry
        _time_box.pack_start(self.time_entry, expand=True, fill=True)
        # .. after
        _time_box.pack_start(self.__get_time_button('go_right_small', 1,
            _('Play After (1 Frames)')), expand=False, fill=True)
        _time_box.pack_start(self.__get_time_button('go_right', 10,
            _('Play After (10 Frames)')), expand=False, fill=True)
        # do add
        _frame_time.add(_time_box)

    def add_frame_remove(self):
        # init frame
        _frame_remove = gtk.Frame(label=_('Remove'))
        _frame_remove.set_border_width(1)
        # do show
        _frame_remove.show()
        # do add
        self.main_box.pack_start(_frame_remove, expand=False, fill=True)
        # init container
        _in_vbox = gtk.HBox(homogeneous=True, spacing=4)
        _in_vbox.set_border_width(4)
        # show
        _in_vbox.show()
        # do add
        _frame_remove.add(_in_vbox)
        # prepare remove sequence button
        _rm_seq_button = ui.get_button(label=_('Sequence'),
                stock_id='remove_sequence', width=48, padding=(8, 0))
        _rm_seq_button.set_tooltip_text(_('Remove Sequence'))
        # set cb
        _rm_seq_button.connect('clicked', _on_remove_sequence_clicked, self)
        # get remove sequence button
        _in_vbox.pack_start(_rm_seq_button, expand=False, fill=True)
        # prepare remove sequence button
        _rm_key_button = ui.get_button(label=_('Key'),
                stock_id='remove_item', width=48, padding=(12, 0))
        _rm_key_button.set_tooltip_text(_('Remove Key'))
        # set cb
        _rm_key_button.connect('clicked', _on_remove_key_clicked, self)
        # get remove image button
        _in_vbox.pack_start(_rm_key_button, expand=False, fill=True)


class PanelGraphics(Panel):

    def __init__(self, screen):
        # init parent
        Panel.__init__(self, screen)
        # main vars
        self.entry_layout = None
        # ..
        self.entry_x = None
        self.entry_y = None
        # add specific
        if 'image' in self._conf:
            self._add_frame_image()
        else:
            pass
        if 'position' in self._conf:
            self._add_frame_position()
        else:
            pass
        # .. common
        if 'time' in self._conf:
            self.add_frame_time()
        else:
            pass
        # ..
        if 'remove' in self._conf:
            self.add_frame_remove()
        else:
            pass

    def clear(self):
        # clear parent
        Panel.clear(self)
        # ..
        self.entry_layout.set_text('')
        self.entry_x.set_text('')
        self.entry_y.set_text('')

    def refresh(self, sequence_name=None, update_store=False):
        # shortcut
        _activity = self.screen.toolbar.activity
        # update parent
        _seq_path, _current = Panel._refresh(self, 'graphics',
                sequence_name=sequence_name, update_store=update_store)
        # little check
        if os.path.exists(_seq_path):
            # get current layout
            _layout = self.story_keys.get_layout(self.sequence_name)
            # update layout
            self.entry_layout.set_text(str(_layout))
            # get current x and y
            _x, _y = self.story_keys.get_align(self.sequence_name,
                    _activity._thread._time, _current)
            # update panel x
            if self.entry_x is None:
                pass
            else:
                self.entry_x.set_text(str(_x))
            # update panel y
            if self.entry_y is None:
                pass
            else:
                self.entry_y.set_text(str(-_y))
        else:
            pass

    def update_store(self):
        # init parent
        Panel.update_store(self)
        # prepare dir path
        _seq_path = os.path.join(activity.get_activity_root(), 'data',
                'sequences', 'graphics', '%s.seq' % self.sequence_name)
        # little check
        if os.path.exists(_seq_path):
            # get graphic names
            _items = storage.get_sequence_items(_seq_path)
            # add dummy row
            _dummy_pix, _path = self._get_pixbuf('blank', dir_='data')
            self._store.append([_dummy_pix, '', None])
            # for each graphics
            for _filename in _items:
                # prepare pixbuf
                _pixbuf, _path = self._get_pixbuf(_filename)
                # do update
                self._store.append([_pixbuf, _filename, _path])
        # not exist .. clear
        else:
            self._store.clear()

    def _init_sequence_box(self):
        # ..
        Panel._init_sequence_box(self)
        # set callback
        self.combo_box.connect('changed', _on_graphic_combo_changed, self)

    def __get_layout_button(self, name, tooltip_text):
        # init button
        _button = ui.get_button(stock_id=name)
        # set tooltip
        _button.set_tooltip_text(tooltip_text)
        # set cb
        _button.connect('clicked', _on_layout_clicked, self, name)
        # ..
        return _button

    def _add_frame_image(self):
        # init frame
        _frame_sequence = gtk.Frame(label=_('Image'))
        _frame_sequence.set_border_width(1)
        # do show
        _frame_sequence.show()
        # do add
        self.main_box.pack_start(_frame_sequence, expand=False, fill=True)
        # vbox for the frame
        _in_vbox = gtk.VBox(homogeneous=False, spacing=4)
        _in_vbox.set_border_width(4)
        # do show
        _in_vbox.show()
        # do add
        _frame_sequence.add(_in_vbox)
        # init
        self._init_sequence_box()
        # add row sequence
        _in_vbox.pack_start(self.combo_box, expand=False, fill=True)
        # get over/under spin buttons
        _layer_box = gtk.HBox(homogeneous=True, spacing=4)
        _layer_box.show()
        # down ..
        _layer_box.pack_start(self.__get_layout_button('move_down_down',
            _('Layer to Bottom')), expand=False, fill=True)
        _layer_box.pack_start(self.__get_layout_button('move_down',
            _('Lower Layer')), expand=False, fill=True)
        # entry
        self.entry_layout = gtk.Entry()
        # show
        self.entry_layout.show()
        # set value - should be a string
        self.entry_layout.set_text("")
        self.entry_layout.set_alignment(1)
        self.entry_layout.set_property('editable', False)
        # add entry
        _layer_box.pack_start(self.entry_layout, expand=False, fill=True)
        # .. up
        _layer_box.pack_start(self.__get_layout_button('move_up',
            _('Raise Layer')), expand=False, fill=True)
        _layer_box.pack_start(self.__get_layout_button('move_up_up',
            _('Layer to Top')), expand=False, fill=True)
        # add row sequence
        _in_vbox.pack_start(_layer_box, expand=True, fill=True)

    def __get_position_button(self, name, move, value, tooltip_text):
        # init button
        _button = ui.get_button(stock_id=name)
        # set tooltip
        _button.set_tooltip_text(tooltip_text)
        # set cb
        _button.connect('clicked', _on_position_clicked, self, move, value)
        # ..
        return _button

    def _add_frame_position(self):
        # init frame
        _frame_position = gtk.Frame(label=_('Position'))
        _frame_position.set_border_width(1)
        # do show
        _frame_position.show()
        # do add
        self.main_box.pack_start(_frame_position, expand=False, fill=True)
        # _vbox
        _in_vbox = gtk.VBox(homogeneous=False, spacing=4)
        _in_vbox.set_border_width(4)
        _in_vbox.show()
        # first _row
        _in_vbox.pack_start(self.__get_position_button('y_up_up', 'y', -10,
            _('Move Up by 10%')), expand=False, fill=False)
        # second _row
        _in_vbox.pack_start(self.__get_position_button('y_up', 'y', -1,
            _('Move Up by 1%')), expand=False, fill=False)
        # third _row
        _row3 = gtk.HBox(homogeneous=False, spacing=4)
        _row3.show()
        _row3.pack_start(self.__get_position_button('x_left_left', 'x', -10,
            _('Move Left by 10%')), expand=False, fill=True)
        _row3.pack_start(self.__get_position_button('x_left', 'x', -1,
            _('Move Left by 1%')), expand=False, fill=True)
        # prepare middle box
        _middle_box = gtk.VBox(homogeneous=True, spacing=4)
        _middle_box.show()
        # get entries
        _entry_box_x = ui.get_entry(label='X')
        _entry_box_y = ui.get_entry(label='Y')
        # update main vars
        self.entry_x = _entry_box_x.get_children()[1]
        self.entry_y = _entry_box_y.get_children()[1]
        # add entries to the box
        _middle_box.pack_start(_entry_box_x, expand=False, fill=True)
        _middle_box.pack_start(_entry_box_y, expand=False, fill=True)
        _middle_box.set_size_request(64, -1)
        # add the box to the row
        _row3.pack_start(_middle_box, expand=True, fill=True)
        # ..
        _row3.pack_start(self.__get_position_button('x_right', 'x', 1,
            _('Move Right by 1%')), expand=False, fill=True)
        _row3.pack_start(self.__get_position_button('x_right_right', 'x', 10,
            _('Move Right by 10%')), expand=False, fill=True)
        # and add the third row
        _in_vbox.pack_start(_row3, expand=False, fill=False)
        # fourth _row
        _in_vbox.pack_start(self.__get_position_button('y_down', 'y', 1,
            _('Move Down by 1%')), expand=False, fill=False)
        # fifth _row
        _in_vbox.pack_start(self.__get_position_button('y_down_down', 'y', 10,
            _('Move Down by 10%')), expand=False, fill=False)
        # put it in
        _frame_position.add(_in_vbox)


class PanelSounds(Panel):

    def __init__(self, screen):
        # init parent
        Panel.__init__(self, screen)
        # init commonf fields
        self.entry_duration = None
        self.toggle_loop = None
        self.image_loop = None
        # add specific
        if 'sound' in self._conf:
            self._add_frame_sound()
        else:
            pass
        # .. common
        if 'time' in self._conf:
            self.add_frame_time()
        else:
            pass
        # ..
        if 'remove' in self._conf:
            self.add_frame_remove()
        else:
            pass


    def clear(self):
        # clear parent
        Panel.clear(self)
        # ..
        self.entry_duration.set_text('')
        self.toggle_loop.set_active(False)

    def _get_time(self, value):
        """Format the time value to display
        """
        # return formated value
        return '%1d:%02d' % divmod(value, 60)

    def update_store(self):
        # init parent
        Panel.update_store(self)
        # prepare dir path
        _seq_path = os.path.join(activity.get_activity_root(), 'data',
                'sequences', 'sounds', '%s.seq' % self.sequence_name)
        # little check
        if os.path.exists(_seq_path):
            # get graphic names
            _items = storage.get_sequence_items(_seq_path)
            # add dummy row
            _dummy_pix, _path = self._get_pixbuf('blank', dir_='data')
            self._store.append([_dummy_pix, '', None])
            # for each graphics
            for _filename in _items:
                # prepare pixbuf
                _pixbuf, _path = self._get_pixbuf('sound', dir_='data')
                # do update
                self._store.append([_pixbuf, _filename, _path])
        # not exist .. clear
        else:
            self._store.clear()

    def _init_sequence_box(self):
        # ..
        Panel._init_sequence_box(self)
        # set callback
        self.combo_box.connect('changed', _on_graphic_combo_changed, self)

    def __get_duration_button(self, name, value, tooltip_text):
        # init button
        _button = ui.get_button(stock_id=name)
        # ..
        _button.set_tooltip_text(tooltip_text)
        # set cb
        _button.connect('clicked', _on_duration_clicked, self, value)
        # ..
        return _button

    def _get_duration_box(self):
        # get less/more spin buttons
        _duration_box = gtk.HBox(homogeneous=True, spacing=4)
        _duration_box.show()
        # down ..
        _duration_box.pack_start(self.__get_duration_button('less', -10,
            _('Duration -10s')), expand=False, fill=True)
        _duration_box.pack_start(self.__get_duration_button('less_small', -1,
            _('Duration -1s')), expand=False, fill=True)
        # entry
        self.entry_duration = gtk.Entry()
        # show
        self.entry_duration.show()
        # set value - should be a string
        self.entry_duration.set_text('') # self._get_time(0)
        self.entry_duration.set_alignment(1)
        self.entry_duration.set_property('editable', False)
        self.entry_duration.set_size_request(64, -1)
        # add entry
        _duration_box.pack_start(self.entry_duration, expand=False, fill=True)
        # .. up
        _duration_box.pack_start(self.__get_duration_button('more_small', 1,
            _('Duration +1s')), expand=False, fill=True)
        _duration_box.pack_start(self.__get_duration_button('more', 10,
            _('Duration +10s')), expand=False, fill=True)
        # return it
        return _duration_box

    def _init_loop_box(self):
        # init row
        _loop_box = gtk.HBox(homogeneous=False, spacing=4)
        _loop_box.show()
        # create image
        self.image_loop = gtk.Image()
        self.image_loop.show()
        # get img path
        self.image_loop.set_from_file(storage.get_icon_path('repeat'))
        self.image_loop.set_size_request(48, -1)
        # add image
        _loop_box.pack_start(self.image_loop, expand=False, fill=True)
        # create label
        _label = gtk.Label(_('Repeat'))
        _label.set_alignment(0, 0.5)
        _label.show()
        # add label
        _loop_box.pack_start(_label, expand=True, fill=True)
        # create checkbox
        self.toggle_loop = gtk.ToggleButton()
        # set tooltip
        self.toggle_loop.set_tooltip_text(_('Loop (On/Off)'))
        # ..
        self.toggle_loop.show()
        self.toggle_loop.add(_loop_box)
        # set cb
        self.toggle_loop.connect('toggled', _on_loop_click, self,
                self.image_loop)

    def _add_frame_sound(self):
        # init frame
        _frame_sound = gtk.Frame(label=_('Sound'))
        _frame_sound.set_border_width(1)
        # do show
        _frame_sound.show()
        # do add
        self.main_box.pack_start(_frame_sound, expand=False, fill=True)
        # vbox for the fram
        _in_vbox = gtk.VBox(homogeneous=False, spacing=4)
        _in_vbox.set_border_width(4)
        # do show
        _in_vbox.show()
        # do add
        _frame_sound.add(_in_vbox)
        # add row sequence
        self._init_sequence_box()
        _in_vbox.pack_start(self.combo_box, expand=False, fill=True)
        # add duration box
        _in_vbox.pack_start(self._get_duration_box(), expand=False, fill=True)
        # add loop button
        self._init_loop_box()
        _in_vbox.pack_start(self.toggle_loop, expand=False, fill=True)

    def refresh(self, sequence_name=None, update_store=False):
        # update parent
        _seq_path, _current = Panel._refresh(self, 'sounds',
                sequence_name=sequence_name, update_store=update_store)
        # little check
        if os.path.exists(_seq_path):
            # shortcut
            _activity = self.screen.toolbar.activity
            if self.entry_duration is None:
                pass
            else:
                # get current x and y
                _d = self.story_keys.get_duration(self.sequence_name,
                        _activity._thread._time, _current)
                # update panel x y
                self.entry_duration.set_text('%1d:%02d' % divmod(_d, 60))
            # ...
            _l = self.story_keys.get_loop(self.sequence_name,
                    _activity._thread._time, _current)
            # ...
            self.toggle_loop.set_active(_l)
            # update image
            _stock_id = 'repeat_grey' if _l is True else 'repeat'
            self.image_loop.set_from_file(storage.get_icon_path(_stock_id))
        else:
            pass