path: root/atoidejouer/ui/screens.py

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

# gtk import
import cairo, gobject, gtk, glib

# graphics import
from lib import graphics

# sugar import
from sugar.activity import activity
from sugar.graphics.objectchooser import ObjectChooser

#from hulahop.webview import WebView

# atoidejouer import
from atoidejouer.tools import config, image, key, sound, storage, ui
from atoidejouer.ui.panel import PanelGraphics, PanelSounds
from atoidejouer.ui.preview import ImagePreview, SequencePreview, SoundPreview
from atoidejouer.ui.timeline import Timeline
from atoidejouer.ui.notebook import ResourceNotebook
# ..
from atoidejouer.story.keys import StoryKeys

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


COLOR_BLACK       = ui.get_color(0.0, 0.0, 0.0)
COLOR_GREY_DARK   = ui.get_color(0.5, 0.5, 0.5)
COLOR_GREY_LIGHT  = ui.get_color(0.7, 0.7, 0.7)
COLOR_GREY_WHITE  = ui.get_color(0.85, 0.85, 0.85)
COLOR_WHITE       = ui.get_color(1.0, 1.0, 1.0)


def _on_drag_finish(image, event, scene, sequence_name, frame, filename,
        image_size):
    # get align values
    _a_x, _a_y = scene._reverse_x_y(image_size, (image.x, image.y))
    # shortcut
    _story_keys = scene._get_keys('graphics')
    # update keys
    _story_keys.set_align(sequence_name, frame, filename,
            (_a_x, _a_y))
    # update transitions
    _story_keys.refresh(sequence_name)
    # _story_keys.ask_clear()
    # refresh scene with rounded values
    scene.refresh(sequence_name=sequence_name)
    # get current screen
    _screen = scene.toolbar.activity.get_current_screen()
    # update timeline
    if hasattr(_screen, 'timeline'):
        _screen.timeline.set_active_sequence(sequence_name)
    else:
        pass
    # update position in panel
    if hasattr(_screen, 'panel'):
        _screen.panel.refresh()
    else:
        pass


def _on_click(image, event, scene, sequence_name):
    # get current screen
    _screen = scene.toolbar.activity.get_current_screen()
    # update timeline
    if hasattr(_screen, 'timeline'):
        _screen.timeline.set_active_sequence(sequence_name)
    else:
        pass
    # update panel
    if hasattr(_screen, 'panel'):
        _screen.panel.refresh()
    else:
        pass


class ScreenStory(graphics.Scene):

    def __init__(self, toolbar, height_offset=0, width_offset=0,
                 set_canvas=False, frame=None):
        # ..
        graphics.Scene.__init__(self)
        self.background_color = "#ffffff"
        # keep toolbar
        self.toolbar = toolbar
        # ..
        self._set_canvas = set_canvas
        # init image dicts
        self.__sizes = dict()
        self.__graphics = dict()
        self.__sounds = dict()
        self.__dd_signals = dict()
        # init fullscreen flag
        self.fullscreen = False
        self._fullscreen_changed = True
        # screen size first
        self._height_offset = height_offset
        self._width_offset = width_offset
        # ..
        self._screen_height = None
        self._screen_width = None
        # ...
        self._refresh_screen_size()
        # and show
        self._show()

    def _get_keys(self, type_):
        # ..
        if type_ == 'graphics':
            return self.toolbar.activity.graphic_keys
        else:
            return self.toolbar.activity.sound_keys

    def set_fullscreen(self, fullscreen):
        # update fullscreen flag
        self.fullscreen = fullscreen
        # has changed
        self._fullscreen_changed = True
        # refresh
        self.refresh()

    def _refresh_screen_size(self):
        # keep some info
        self._screen_height = gtk.gdk.screen_height() - self._height_offset
        self._screen_width = gtk.gdk.screen_width() - self._width_offset

    def _check_clear(self):
        # need clear
        if self._get_keys('graphics').get_clear(self.toolbar.name) is True:
            # hide previous
            for _image in self.__graphics.values():
                _image.visible = False
                del _image
            # ..
            self.__graphics = dict()
            # ..
            self.__sizes = dict()
            # done
            self._get_keys('graphics').set_clear(self.toolbar.name, False)
            # ..
            return True
        else:
            return False

    def refresh(self, sequence_name=None):
        # get the current frame
        _time = 0.0 if self.toolbar.activity._thread is None\
                else self.toolbar.activity._thread._time
        # get the current rate
        _rate = config.Config().get_rate_value()
        # clear ??
        self._check_clear()
        # ..
        self._refresh_screen_size()
        # ..
        _currents = list()
        # for each images
        for _n in self._get_keys('graphics').get_names():
            if sequence_name is None\
            or sequence_name == _n:
                # do move
                _currents.append(self.__refresh_image(_n, _time, _rate))
            else:
                # just get code
                _currents.append(self._get_current_code('graphics', _n,
                    _time))
        # draw mask
        _currents.append(self.__refresh_default('mask'))
        # hide previous
        for _code, _image in self.__graphics.items():
            if _code in _currents:
                continue
            else:
                _image.visible = False
        self.queue_draw()
        # show first
        if self._fullscreen_changed is True:
            # disable changed flag
            self._fullscreen_changed = False
        else:
            pass
        # refresh sounds if playing
        if self.toolbar.activity._thread is None:
            pass
        elif self.toolbar.activity._thread._pause is False:
            # for each sound
            for _n in self._get_keys('sounds').get_names():
                if sequence_name is None\
                or sequence_name == _n:
                    # do move
                    self.__refresh_sound(_n, _time)
                else:
                    # just get code
                    _currents.append(self._get_current_code('sounds', _n,
                        _time))
        else:
            # stop all
            for _code, _sound in self.__sounds.items():
                if self.toolbar.activity._thread._time == 0:
                    _sound.stop()
                else:
                    _sound.pause()

    def _update_w_h(self, filename):
        if filename in self.__sizes:
            pass
        else:
            # get graphics path
            _path = storage.get_image_path(filename)
            # get file size
            _c, _w, _h = image.get_image_info(_path)
            # ..
            if (self.fullscreen is True\
            or self._screen_width < 1024)\
            and _w != 0:
                _new_w = _w * self._screen_width / 1024
                _new_h = _h * _new_w / _w
            else:
                _new_w = _w
                _new_h = _h
            # update size
            self.__sizes[filename] = _new_w, _new_h, _w, _h
        # return new values
        return self.__sizes[filename]

    def _reverse_x_y(self, size, position):
        # ..
        _w, _h = size
        _x, _y = position
        # ..
        if self.fullscreen is True\
        or self._screen_width < 1024:
            _scene_with = self._screen_width
            _scene_height = 516 * _scene_with / 1024.0
        else:
            _scene_with = 1024
            _scene_height = 516
        # update x
        _a_x = _x - (self._screen_width - _w) / 2
        _a_x = int(_a_x * 100.0 / _scene_with)
        # update y
        _a_y = _y - (self._screen_height - _h - 88) / 2
        _a_y = int(_a_y * 100.0 / _scene_height)
        # return it
        return _a_x, _a_y

    def _update_x_y(self, size, align):
        # ..
        _new_w, _new_h, _w, _h = size
        _x, _y = align
        #
        if self.fullscreen is True\
        or self._screen_width < 1024:
            _scene_with = self._screen_width
            _scene_height = 516 * _scene_with / 1024.0
        else:
            _scene_with = 1024
            _scene_height = 516
        # update x
        _new_x = ((self._screen_width - _new_w) / 2)
        _new_x += int(_x * _scene_with / 100.0)
        # update y
        _new_y = ((self._screen_height - _new_h - 88) / 2)
        _new_y += int(_y * _scene_height / 100.0)
        # return it
        return _new_x, _new_y

    def __get_scene_size(self):
        #
        if self.fullscreen is True\
        or self._screen_width < 1024:
            _scene_with = self._screen_width
            _scene_height = 516 * _scene_with / 1024.0
        else:
            _scene_with = 1024
            _scene_height = 516
        # ..
        return _scene_with, _scene_height

    def __refresh_default(self, default_name):
        _code = '__%s' % default_name
        # ensure current image
        if _code in self.__graphics:
            # ..
            self.__graphics[_code].visible = True
        else:
            _filename = '%s_default' % default_name
            # ..
            _align = (0, 0)
            # get/update width and height
            _size = self._update_w_h(_filename)
            # ..
            self.__graphics[_code] =\
                    self.__update_drawing_area(_filename, _code, _size, _align)
        # and return displayed code
        return _code

    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)
        # get transition ratio
        _ratio = time - int(time)
        if _ratio < rate:
            return _x, _y
        else:
            _next_x, _next_y = self._get_keys('graphics').get_next_align(
                    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 _next_x, _next_y

    def _get_current_code(self, type_, sequence_name, time):
        # get sequence filename
        _current, _f_type, _k_type = self._get_keys(type_).get_current(
                sequence_name, int(time))
        # need current
        if _current is None:
            return None
        else:
            pass
        # get sequence file codes
        return self._get_keys(type_).get_code(
                self.toolbar.name, sequence_name, _current)

    def __refresh_image(self, sequence_name, time, rate):
        # get sequence filename
        _current, _f_type, _k_type = self._get_keys('graphics').get_current(
                sequence_name, int(time))
        # need current
        if _current is None:
            return None
        else:
            pass
        # get sequence file codes
        _code = self._get_keys('graphics').get_code(
                self.toolbar.name, sequence_name, _current)
        # current file code
        _code = key.random_str() if _code is None else _code
        # get/update width and height
        _size = self._update_w_h(_current)
        # get align
        _align = self.__get_transition_align(sequence_name, time, _current,
                rate)
        # ensure current image
        if _code in self.__graphics:
            # ..
            _image = self.__graphics[_code]
            # update x, y
            _image.x, _image.y = self._update_x_y(_size, _align)
            # get z_order
            _image.z_order = self._get_keys('graphics').get_layout(
                    sequence_name)
            # disconnect
            if _code in self.__dd_signals:
                _image.disconnect(self.__dd_signals[_code])
            else:
                pass
            # scale
            _new_w, _new_h, _w, _h = _size
            # re-connect
            _h_id = _image.connect('on-drag-finish', _on_drag_finish, self,
                    sequence_name, int(time), _current, (_new_w, _new_h))
            # ..
            self.__dd_signals[_code] = _h_id
            # ..
            _image.visible = True
        else:
            # draggable for edit only
            _draggable = self._set_canvas is False\
                    and config.Config().use_dnd() is True
            # ..
            _image = self.__update_drawing_area(_current, _code, _size, _align,
                    sequence_name=sequence_name, frame=int(time),
                    draggable=_draggable)
            # ..
            self.__graphics[_code] = _image
            # ..
            self._get_keys('graphics').set_code(self.toolbar.name, sequence_name,
                    _current, _code)
        # and return displayed code
        return _code

    def __update_drawing_area(self, filename, code, size, align,
            sequence_name=None, frame=None, draggable=False):
        # get path
        _path = storage.get_image_path(filename)
        # update x, y
        _x, _y = self._update_x_y(size, align)
        # scale
        _new_w, _new_h, _w, _h = size
        # ..
        if _w is None or _w == 0:
            _scale = 1
        else:
            _scale = float(_new_w)/_w
        # get z_order
        if sequence_name is None:
            _z_order = 1000
        else:
            _z_order = self._get_keys('graphics').get_layout(sequence_name)
        # image
        _image = graphics.Image(_path, x=_x, y=_y, scale_x=_scale,
                scale_y=_scale, z_order=_z_order, draggable=draggable)
        # connect drag
        if self._set_canvas is True\
        or config.Config().use_dnd() is False\
        or self.toolbar.name != 'graphics':
            pass
        else:
            # ..
            _h_id = _image.connect('on-drag-finish', _on_drag_finish, self,
                    sequence_name, frame, filename, (_new_w, _new_h))
            # ..
            self.__dd_signals[code] = _h_id
        # connect on click
        if sequence_name is None:
            pass
        else:
            _image.connect('on-click', _on_click, self, sequence_name)
        # do add
        self.add_child(_image)
        # ..
        return _image

    def __stop_unused_sounds(self, sequence_codes, current_code):
        # hide previous
        for _filename, _code in sequence_codes.items():
            if _code != current_code\
            and _code in self.__sounds:
                self.__sounds[_code].pause()
            else:
                continue

    def __refresh_sound(self, sequence_name, frame):
        # get sequence file codes
        _seq_codes = self._get_keys('sounds').get_sequence_codes(
                self.toolbar.name, sequence_name)
        # get sequence filename
        _current, _f_type, _k_type = self._get_keys('sounds').get_current(
                sequence_name, frame)
        # need current
        if _current is None:
            return self.__stop_unused_sounds(_seq_codes, None)
        else:
            pass
        # current file code
        _code = _seq_codes[_current] if _current in _seq_codes else None
        # ensure current image
        if _code in self.__sounds:
            _s = self.__sounds[_code]
            if _k_type is None:
                _s.pause()
            elif _k_type == 'key':
                # reset
                _s.seek(0)
                # play
                _s.play()
            else:
                _s.seek(frame)
                _s.play()
        else:
            # create new
            if _k_type is None:
                pass
            else:
                # ... TODO manage start time
                _code, _sound = self._prepare_sound(sequence_name, _current)
                _sound.play()
        # ..
        self.__stop_unused_sounds(_seq_codes, _code)

    def _prepare_sound(self, sequence_name, current):
        # get graphics path
        _path = storage.get_sound_path(current)
        # ensure/generate code
        _filecode = key.random_str()
        # update story key object
        self._get_keys('sounds').set_code(self.toolbar.name, sequence_name,
                current, _filecode)
        # ...
        _sound = sound.Player()
        _sound.load(_path)
        # update graphic dict
        self.__sounds[_filecode] = _sound
        # return image for futher use
        return _filecode, _sound

    def _show(self):
        # first refresh
        self.refresh()
        # ..
        self.show()
        # update size request
        self.set_size_request(self._screen_width, self._screen_height)
        # update canvas
        if self._set_canvas is True:
            self.toolbar.activity.set_canvas(self)
        else:
            pass


class Splash(graphics.Scene):

    def __init__(self, toolbar):
        # ..
        graphics.Scene.__init__(self)
        # ..
        # self.background_color = "#ffffff"
        # ..
        self.__current = 0
        # toolbar keep
        self.toolbar = toolbar
        # ..
        self._image = None
        # ..
        if self.toolbar is None:
            self._screen_height = None
            self._screen_width = None
        else:
            # keep some info
            self._screen_height = gtk.gdk.screen_height()
            self._screen_width = gtk.gdk.screen_width()
            # ..
            self._show()

    def _update_x_y(self, path):
        # get file size
        _c, _w, _h = image.get_image_info(path)
        # update x
        _x = ((self._screen_width - _w) / 2)
        # update y
        _y = ((self._screen_height - _h - 88) / 2)
        # return it
        return _x, _y

    def _get_image(self):
        # get path
        _path = storage.get_image_path('splash', dir_='data')
        # ..
        _x, _y = self._update_x_y(_path)
        # image
        return graphics.Image(_path, x=_x, y=_y, draggable=False)

    def _show(self):
        # ..
        self._image = self._get_image()
        # do add
        self.add_child(self._image)
        # show
        self.show()
        # update toolbar
        self.toolbar.activity.set_canvas(self)


class ScreenEdit(gtk.HBox):

    def __init__(self, toolbar):
        # init parent
        gtk.HBox.__init__(self, homogeneous=False, spacing=2)
        # keep toolbar
        self.toolbar = toolbar
        # render
        self.render()
        # init main vars
        self.scene = None
        self.panel = None
        self.timeline = None
        # init top box
        _vbox = gtk.VBox(homogeneous=False, spacing=2)
        # do show
        _vbox.show()
        # init frames
        self.add_scene(_vbox)
        # ..
        self.add_timelime(_vbox)
        # add top box
        self.pack_start(_vbox, expand=False, fill=False)
        # ..
        self.add_panel()
        # and show
        self._show()

    def add_scene(self, vbox):
        # get scene
        self.scene = ScreenStory(self.toolbar, height_offset=148,
                width_offset=300)
        # add it
        vbox.pack_start(self.scene, expand=True, fill=True)

    def add_timelime(self, vbox):
        # init time line and keep it
        self.timeline = Timeline(self)
        # add it
        vbox.pack_start(self.timeline, expand=True, fill=True)

    def add_panel(self):
        pass

    def render(self):
        pass

    def _show(self):
        # show self
        self.show_all()
        # ..
        self.toolbar.story_keys.check_sequences()
        # ..
        self.scene.refresh()
        # get current time
        self.timeline.refresh()
        # update toolbar
        self.toolbar.activity.set_canvas(self)


class ScreenEditGraphics(ScreenEdit):

    def __init__(self, toolbar):
        # init parent
        ScreenEdit.__init__(self, toolbar)

    def add_panel(self):
        # init time line and keep it
        self.panel = PanelGraphics(self)
        # add it
        self.pack_start(self.panel, expand=False, fill=False)


class ScreenEditSounds(ScreenEdit):

    def __init__(self, toolbar):
        # init parent
        ScreenEdit.__init__(self, toolbar)

    def add_panel(self):
        # init time line and keep it
        self.panel = PanelSounds(self)
        # add it
        self.pack_start(self.panel, expand=False, fill=False)


class ScreenBrowser(gtk.HBox):

    def __init__(self, toolbar, type_):
        # init parent
        gtk.HBox.__init__(self, homogeneous=False, spacing=2)
        # keep toolbar
        self.toolbar = toolbar
        # keep name
        self._type = type_
        # keep previews
        self.notebook = None
        self.item_preview = None
        self.sequence_preview = None
        # add it
        self._add_previews()
        self._add_notebook()
        # do show
        self._show()

    def _add_previews(self):
        # init top box
        _vbox = gtk.VBox(homogeneous=False, spacing=4)
        # do show
        _vbox.show()
        # add the box
        self.pack_start(_vbox, expand=True, fill=True)
        # init frame
        self.item_preview = ImagePreview(self) if self._type == 'graphics'\
                else SoundPreview(self)
        # add it
        _vbox.pack_start(self.item_preview, expand=True, fill=True)
        # ..
        self.sequence_preview = SequencePreview(self, self._type)
        # add it
        _vbox.pack_start(self.sequence_preview, expand=False, fill=True)

    def _add_notebook(self):
        # init
        self.notebook = ResourceNotebook(self, self._type)
        # add
        self.pack_start(self.notebook, expand=False, fill=True)

    def _show(self):
        # show all
        self.show()
        # update toolbar
        self.toolbar.activity.set_canvas(self)


class ScreenBrowserGraphics(ScreenBrowser):

    def __init__(self, toolbar):
        # init parent
        ScreenBrowser.__init__(self, toolbar, 'graphics')


class ScreenBrowserSounds(ScreenBrowser):

    def __init__(self, toolbar):
        # init parent
        ScreenBrowser.__init__(self, toolbar, 'sounds')


def _on_toggle_click(radio, screen, option, value):
    # manage change state manually
    _previous = config.Config().get('activity>%s' % option)
    # remove screens to recreate them after
    if screen._initialized is True\
    and _previous != value:
        # update
        config.Config().set('activity>%s' % option, value)
        # ...
        if option in ['mode', 'dnd']:
            screen._activity.remove_screen('graphics')
            screen._activity.remove_screen('sounds')
        else:
            pass
    else:
        pass


def _on_button_click(button, screen, name, msg_label, value):
    if name == 'import':
        try:
            # int file chooser
            _chooser = ObjectChooser(button.get_label(), screen,
                    gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
            # get chooser result
            _r = _chooser.run()
            # check result
            if _r == gtk.RESPONSE_ACCEPT:
                # get selected object
                _object = _chooser.get_selected_object()
                # do import
                storage.import_project(screen._activity, _object.file_path,
                        msg_label)
            else:
                pass
        except Exception, e:
            # ERROR
            logger.error('[screens] _on_button_click - e: %s' % e)
    elif name == 'export':
        # do export
        storage.export_project(screen._activity, msg_label, value)
    else:
        pass


[
    ADVANCED,
    EASY,
] = range(2)


[
    FASTER,
    SMOOTH,
    NORMAL,
] = range(3)


[
    YES,
    NO,
] = range(2)


class ScreenActivity(gtk.ScrolledWindow):

    def __init__(self, activity_):
        gtk.ScrolledWindow.__init__(self)
        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
        # init main box
        self.__main_box = gtk.HBox(homogeneous=True, spacing=2)
        self.__main_box.show()
        # ..
        self.add_with_viewport(self.__main_box)
        # add left menu
        self._group_mode = None
        self._group_rate = None
        self._group_dnd = None
        self._add_left_part()
        # ..
        self.__main_box.pack_start(gtk.EventBox(), expand=False, fill=True)
        # add right menu
        self._add_right_part()
        # do show
        self._show()

    def _get_title(self, text):
        # init
        _label = gtk.Label()
        # show
        _label.show()
        # set markup
        _label.set_use_markup(True)
        _label.set_markup('<span size="x-large" weight="heavy">%s</span>' % text)
        # align
        _label.set_padding(5, 5)
        _label.set_alignment(0, 0.5)
        # return it
        return _label

    def _get_toggle_box(self, group, option, value, text):
        # 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('toggled', _on_toggle_click, self, option, value)
        # return it
        return _toggle

    def _get_button(self, name, text, stock_id, msg_label=None, value=None):
        # init button
        _button = ui.get_button(label=text, stock_id=stock_id, width=48,
                padding=(10, 0))
        _button.show()
        # set cb
        _button.connect('clicked', _on_button_click, self, name, msg_label,
                value)
        # return it
        return _button

    def _get_hidden_text(self):
        # init
        _label = gtk.Label()
        # set markup
        _label.set_use_markup(True)
        # align
        _label.set_padding(5, 5)
        _label.set_alignment(0, 0.5)
        # return it
        return _label

    def _get_mode_part(self):
        # ..
        _vbox = gtk.VBox(homogeneous=False, spacing=5)
        # border
        _vbox.set_border_width(5)
        # show
        _vbox.show()
        # add first part title
        _vbox.pack_start(self._get_title(_('MODE')),
                expand=False, fill=True)
        # TODO - add some explanation text
        # init easy option and use it as group
        _easy = self._get_toggle_box(None, 'mode', 'easy', _('Easy'))
        # add options
        _vbox.pack_start(_easy, expand=False, fill=True)
        # with easy as group
        _vbox.pack_start(self._get_toggle_box(_easy, 'mode', 'advanced',
            _('Advanced')), expand=False, fill=True)
        # init group
        self._group_mode = _easy.get_group()
        # ..
        return _vbox

    def _get_rate_part(self):
        # ..
        _vbox = gtk.VBox(homogeneous=False, spacing=5)
        # border
        _vbox.set_border_width(5)
        # show
        _vbox.show()
        # add first part title
        _vbox.pack_start(self._get_title(_('FRAME RATE')),
                expand=False, fill=True)
        # TODO - add some explanation text
        # init normal option and use it as group
        _normal = self._get_toggle_box(None, 'rate', 'normal', _('Normal'))
        # add options
        _vbox.pack_start(_normal, expand=False, fill=True)
        # with easy as group
        _vbox.pack_start(self._get_toggle_box(_normal, 'rate', 'smooth',
            _('Smooth')), expand=False, fill=True)
        # with easy as group
        _vbox.pack_start(self._get_toggle_box(_normal, 'rate', 'faster',
            _('Faster')), expand=False, fill=True)
        # init group
        self._group_rate = _normal.get_group()
        # ..
        return _vbox

    def _get_dnd_part(self):
        # ..
        _vbox = gtk.VBox(homogeneous=False, spacing=5)
        # border
        _vbox.set_border_width(5)
        # show
        _vbox.show()
        # add first part title
        _vbox.pack_start(self._get_title(_('DRAG\'N\'DROP')),
                expand=False, fill=True)
        # TODO - add some explanation text
        # init normal option and use it as group
        _no = self._get_toggle_box(None, 'dnd', 'no', _('Don\'t Use Drag\'n\'Drop'))
        # add options
        _vbox.pack_start(_no, expand=False, fill=True)
        # with easy as group
        _vbox.pack_start(self._get_toggle_box(_no, 'dnd', 'yes',
            _('Use Drag\'n\'Drop')), expand=False, fill=True)
        # init group
        self._group_dnd = _no.get_group()
        # ..
        return _vbox

    def _add_left_part(self):
        # ..
        _vbox = gtk.VBox(homogeneous=False, spacing=5)
        # border
        _vbox.set_border_width(5)
        # show
        _vbox.show()
        # add
        self.__main_box.pack_start(_vbox, expand=False, fill=True)
        # add part choices
        _vbox.pack_start(self._get_mode_part(),
                expand=False, fill=True)
        # add rate choices
        _vbox.pack_start(self._get_rate_part(),
                expand=False, fill=True)
        # add dnd choices
        _vbox.pack_start(self._get_dnd_part(),
                expand=False, fill=True)

    def _get_export_part(self):
        # ..
        _vbox = gtk.VBox(homogeneous=False, spacing=5)
        # border
        _vbox.set_border_width(5)
        # show
        _vbox.show()
        # add first part title
        _vbox.pack_start(self._get_title(_('IMPORT')),
                expand=False, fill=True)
        self.msg_label_import = self._get_hidden_text()
        _vbox.pack_start(self._get_button('import', _('Choose a File'),
            'import', msg_label=self.msg_label_import), expand=False, fill=True)
        _vbox.pack_start(self.msg_label_import, expand=False, fill=True)
        # add first part title
        _vbox.pack_start(self._get_title(_('EXPORT')),
                expand=False, fill=True)
        self.msg_label_export = self._get_hidden_text()
        # list the possible medias
        for _media in os.listdir('/media'):
            # current path
            _path = os.path.join('/media', _media)
            # should be a dir
            if os.path.isdir(_path):
                # set export button text
                _button_text = _('Export to') + ' "' + _media + '"'
                # init button
                _button = self._get_button('export', _button_text, 'export',
                        msg_label=self.msg_label_export, value=_media)
                # add button
                _vbox.pack_start(_button, expand=False, fill=True)
            else:
                continue
        # add label
        _vbox.pack_start(self.msg_label_export, expand=False, fill=True)
        # ..
        return _vbox

    def _add_right_part(self):
        # ..
        _vbox = gtk.VBox(homogeneous=False, spacing=5)
        # border
        _vbox.set_border_width(5)
        # show
        _vbox.show()
        # add
        self.__main_box.pack_start(_vbox, expand=False, fill=True)
        # add first part title
        _vbox.pack_start(self._get_export_part(),
                expand=False, fill=True)

    def _show(self):
        self._initialized = True
        # show all
        self.show()
        # update toolbar
        self._activity.set_canvas(self)


class ScreenHelp(object):

    def __init__(self, activity_):
        # WebView.__init__(self)
        # keep activity
        self._activity = activity_
        # load html content
        self.load_uri(storage.get_html_path('help'))
        # do show
        self._show()

    def _show(self):
        pass
        # show all
        # self.show()
        # update toolbar
        # self._activity.set_canvas(self)