diff options
Diffstat (limited to 'atoidejouerbeta/ui/panel.py')
| -rw-r--r-- | atoidejouerbeta/ui/panel.py | 1025 |
1 files changed, 1025 insertions, 0 deletions
diff --git a/atoidejouerbeta/ui/panel.py b/atoidejouerbeta/ui/panel.py new file mode 100644 index 0000000..e124461 --- /dev/null +++ b/atoidejouerbeta/ui/panel.py @@ -0,0 +1,1025 @@ + +# 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 + +# atoidejouerbeta import +from atoidejouerbeta.tools import config, image, storage, ui + +# get application logger +logger = logging.getLogger('atoidejouerbeta') + + +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 |