path: root/atoidejouer/ui/panel/edit.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.db import story
from atoidejouer.tools import config, image, storage, ui

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


COLOR_GREY_DARK   = ui.get_color(0.5, 0.5, 0.5)
COLOR_GREY_LIGHT  = ui.get_color(0.75, 0.75, 0.75)
COLOR_GREY_WHITE  = ui.get_color(0.85, 0.85, 0.85)
COLOR_WHITE       = ui.get_color(1.0, 1.0, 1.0)


def _set_bg(widget):
    # bg
    widget.modify_bg(gtk.STATE_NORMAL, COLOR_GREY_WHITE)
    widget.modify_bg(gtk.STATE_PRELIGHT, COLOR_GREY_WHITE)
    widget.modify_bg(gtk.STATE_ACTIVE, COLOR_WHITE)
    # fg
    widget.modify_fg(gtk.STATE_NORMAL, COLOR_WHITE)


def _on_position_clicked(widget, panel, move, value):
    # shortcut
    _activity = panel.screen.activity
    if _activity._thread._pause is False\
    or panel.key is None:
        pass
    elif move == 'x':
        panel.key.x += value
    elif move == 'y':
        panel.key.y += value
    else:
        raise Exception('[ui.panel] _on_position_clicked"\
                " - invalid position move: %s' % move)
    # DB update
    rowcount = story.DB().update(panel.key)
    # DEBUG
    # logger.debug('[ui.panel.edit] _on_position_clicked - rowcount: %s' % rowcount)
    # update panel entries
    panel.entry_x.set_text(str(panel.key.x))
    panel.entry_y.set_text(str(-panel.key.y))
    # refresh scene
    panel.screen.scene.refresh()


def _on_layer_clicked(widget, panel, move):
    # shortcut
    _activity = panel.screen.activity
    # get max
    _layer_max = story.DB().get_max('layer')
    # do nothing
    if _activity._thread._pause is False\
    or panel.key is None:
        return
    # layer factory
    elif move == 'move_up_up':
        panel.key.layer = _layer_max
    elif move == 'move_up':
        panel.key.layer = panel.key.layer + 1\
                if panel.key.layer <= _layer_max else _layer_max
    elif move == 'move_down':
        panel.key.layer = panel.key.layer - 1\
                if panel.key.layer > 0 else 0
    elif move == 'move_down_down':
        panel.key.layer = 0
    else:
        raise Exception('[ui.panel] _on_layer_clicked"\
                " - invalid layer move: %s' % move)
    # DB update
    rowcount = story.DB().update(panel.key)
    # DEBUG
    # logger.debug('[ui.panel.edit] _on_layer_clicked - key: %s' % panel.key)
    # logger.debug('[ui.panel.edit] _on_layer_clicked - rowcount: %s' % rowcount)
    # DEBUG
    # update entry
    panel.entry_layer.set_text(str(panel.key.layer))
    # refresh scene
    panel.screen.refresh(key=panel.key)


def _on_duration_clicked(widget, panel, value):
    # shortcut
    _activity = panel.screen.activity
    _duration_max = story.DB().get_max('duration')
    _duration = None
    # do nothing
    if _activity._thread._pause is False\
    or panel.key is None:
        return
    elif panel.key.duration + value < 0:
        _duration = 0
    else:
        _duration = panel.key.duration + value
    # DB update
    panel.key.update_duration(_duration)
    # update max time
    _activity.update_max_time()
    # update panel entries
    panel.entry_duration.set_text(
            '%1d:%02d' % divmod(panel.key.duration, 60))


def _on_loop_click(toggle, panel, image):
    # update image
    _stock_id = 'repeat_grey' if toggle.get_active() is True else 'repeat'
    image.set_from_file(storage.get_icon_path(_stock_id))
    # shortcut
    _activity = panel.screen.activity
    # do nothing
    if _activity._thread._pause is False\
    or panel.key is None:
        return
    else:
        panel.key.loop = toggle.get_active()
        story.DB().update(panel.key)


def _get_next_time(panel, factor):
    # get the current frame
    _time = 0.0 if panel.screen.activity._thread is None\
            else panel.screen.activity._thread._time
    # get rate
    _rate = config.Config().get_rate_value()
    # next time
    _next = _time + factor * _rate
    # get max
    _max = panel.screen.activity.max_time
    # little check
    return _next if _next < _max else _max


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


def _on_remove_key_clicked(widget, panel):
    # shortcut
    _activity = panel.screen.activity
    if _activity._thread._pause is False\
    or panel.key is None:
        return
    else:
        # delete
        story.DB()._del(panel.key)
        # empty key
        panel.key = None
        # update max time
        _activity.update_max_time()
        # refresh screen
        panel.screen.refresh()


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


class PanelEdit(gtk.Frame):

    def __init__(self, screen):
        # init parent
        gtk.Frame.__init__(self)
        self.set_shadow_type(gtk.SHADOW_NONE)
        # set screen
        self.screen = screen
        # key var
        self.key = None
        # get mode
        self._mode = config.Config().get('activity>mode')
        self._conf = config.Config().get('mode>%s' % self._mode, type_=list)
        # ...
        self.set_size_request(298, screen.scene._screen_height)
        # do show
        self.show()
        # init vars
        self._store = None
        self.sequence_name = None
        # add vbox to the panel for sub frames
        self.main_box = gtk.VBox(homogeneous=False, spacing=0)
        # do show
        self.main_box.show()
        # add it to the panel
        self.add(self.main_box)
        # ..
        self.__init_handler()
        # main vars
        # title
        self._frame_title = None
        self._title_image = None
        self._title_label = None
        self._add_frame_title()
        # add specific
        self.entry_layer = None
        self._frame_layer = None
        self._add_frame_layer()
        self.entry_x = None
        self.entry_y = None
        self._frame_position = None
        self._add_frame_position()
        # init sound fields
        self.toggle_loop = None
        self._image_loop = None
        # add specific
        self._frame_sound = None
        self._add_frame_sound()
        # add common
        self.entry_duration = None
        self._frame_duration = None
        self._frame_remove = None
        self._add_frame_duration()
        self._add_frame_remove()

    def __init_handler(self):
        _activity = self.screen.activity
        _handler_id = _activity._handler_id
        if _handler_id:
            _activity.disconnect(_handler_id)
        _activity._handler_id = _activity.connect('key-press-event',
                _on_key_press, self)

    def clear(self):
        self.entry_layer.set_text('')
        self.entry_x.set_text('')
        self.entry_y.set_text('')
        self.entry_duration.set_text('')
        self.toggle_loop.set_active(False)

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

    def __refresh_image(self):
        # hide frame sound
        self._frame_sound.hide()
        # shortcut
        _activity = self.screen.activity
        # set layer value
        self.entry_layer.set_text(str(self.key.layer))
        # set x value
        self.entry_x.set_text(str(self.key.x))
        # set y value
        self.entry_y.set_text(str(-self.key.y))
        # hide frame image
        self._frame_layer.show()
        self._frame_position.show()

    def __refresh_sound(self):
        # hide frame image
        self._frame_layer.hide()
        self._frame_position.hide()
        # update loop value
        self.toggle_loop.set_active(self.key.loop==1)
        # update image
        _stock_id = 'repeat_grey' if self.key.loop==1 else 'repeat'
        self._image_loop.set_from_file(storage.get_icon_path(_stock_id))
        # show frame sound
        self._frame_sound.show()

    def refresh(self, key=None):
        # DEBUG
        # logger.debug('[ui.panel.edit] refresh - key: %s' % key)
        # DEBUG
        self.key = key
        if not key:
            self._frame_title.hide()
            self._frame_layer.hide()
            self._frame_position.hide()
            self._frame_sound.hide()
            self._frame_duration.hide()
            self._frame_remove.hide()
            return self.clear()
        elif key.mime_type == 'image/png':
            self.__refresh_image()
        elif key.mime_type == 'audio/ogg':
            self.__refresh_sound()
        else:
            raise Exception('[ui.panel] refresh - invalid key: %s' % key)
        # update title image
        self._title_image.set_from_pixbuf(key.get_preview())
        # udpate title label
        self._title_label.set_text(key.title)
        self._frame_title.show()
        # update common duration value
        self.entry_duration.set_text(
                '%1d:%02d' % divmod(key.duration, 60))
        self._frame_duration.show()
        self._frame_remove.show()

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

    def _add_frame_duration(self):
        # init frame
        self._frame_duration = gtk.Frame(label=_('Duration'))
        self._frame_duration.set_border_width(1)
        # do show
        self._frame_duration.show()
        # do add
        self.main_box.pack_start(self._frame_duration, expand=False, fill=True)
        # get over/under spin buttons
        _duration_box = gtk.HBox(homogeneous=False, spacing=4)
        _duration_box.set_border_width(4)
        # before ..
        _duration_box.pack_start(self.__get_duration_button('go_left', -10,
            _('Play Before (10 Frames)')), expand=False, fill=True)
        _duration_box.pack_start(self.__get_duration_button('go_left_small', -1,
            _('Play Before (1 Frames)')), 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.entry_duration.set_alignment(1)
        self.entry_duration.set_property('editable', False)
        # add entry
        _duration_box.pack_start(self.entry_duration, expand=True, fill=True)
        # .. after
        _duration_box.pack_start(self.__get_duration_button('go_right_small', 1,
            _('Play After (1 Frames)')), expand=False, fill=True)
        _duration_box.pack_start(self.__get_duration_button('go_right', 10,
            _('Play After (10 Frames)')), expand=False, fill=True)
        # do add
        self._frame_duration.add(_duration_box)

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

    def _add_frame_title(self):
        # init frame
        self._frame_title = gtk.Frame(label=_('Title'))
        self._frame_title.set_border_width(1)
        # do add
        self.main_box.pack_start(self._frame_title, expand=False, fill=True)
        # vbox for the fram
        _in_hbox = gtk.HBox(homogeneous=False, spacing=4)
        _in_hbox.set_border_width(4)
        # do add
        self._frame_title.add(_in_hbox)
        # create image
        self._title_image = gtk.Image()
        # get img path
        self._title_image.set_from_file(storage.get_icon_path('repeat'))
        self._title_image.set_size_request(48, -1)
        # add duration box
        _in_hbox.pack_start(self._title_image, expand=False, fill=True)
        # create label
        self._title_label = gtk.Label()
        self._title_label.set_alignment(0, 0.5)
        # add duration box
        _in_hbox.pack_start(self._title_label, expand=False, fill=True)

    def __get_layer_button(self, name, tooltip_text):
        _button = ui.get_button(stock_id=name)
        _button.set_tooltip_text(tooltip_text)
        _button.connect('clicked', _on_layer_clicked, self, name)
        return _button

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

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

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

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

    def _add_frame_sound(self):
        # init frame
        self._frame_sound = gtk.Frame(label=_('Sound'))
        self._frame_sound.set_border_width(1)
        # do add
        self.main_box.pack_start(self._frame_sound, expand=False, fill=True)
        # add loop button
        self._init_loop_box()
        self._frame_sound.add(self.toggle_loop)