diff options
Diffstat (limited to 'atoidejouerbeta/ui/screens.py')
| -rw-r--r-- | atoidejouerbeta/ui/screens.py | 1021 |
1 files changed, 1021 insertions, 0 deletions
diff --git a/atoidejouerbeta/ui/screens.py b/atoidejouerbeta/ui/screens.py new file mode 100644 index 0000000..1fbe35f --- /dev/null +++ b/atoidejouerbeta/ui/screens.py @@ -0,0 +1,1021 @@ + +# 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 + +# atoidejouerbeta import +from atoidejouerbeta.tools import config, image, key, sound, storage, ui +from atoidejouerbeta.ui.panel import PanelGraphics, PanelSounds +from atoidejouerbeta.ui.preview import ImagePreview, SequencePreview, SoundPreview +from atoidejouerbeta.ui.timeline import Timeline +from atoidejouerbeta.ui.notebook import ResourceNotebook +# .. +from atoidejouerbeta.story.keys import StoryKeys + +# get application logger +logger = logging.getLogger('atoidejouerbeta') + + +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) |