diff options
Diffstat (limited to 'atoideweb/tools/keys.py')
| -rw-r--r-- | atoideweb/tools/keys.py | 686 |
1 files changed, 0 insertions, 686 deletions
diff --git a/atoideweb/tools/keys.py b/atoideweb/tools/keys.py deleted file mode 100644 index 8a4099a..0000000 --- a/atoideweb/tools/keys.py +++ /dev/null @@ -1,686 +0,0 @@ - -# python import -import json, logging, os, random, string -# .. -from functools import partial -from gettext import gettext as _ - -# atoidejouer import -from atoideweb.tools import storage - -# get application logger -logger = logging.getLogger('atoidejouer') - - -def random_str(length=12): - """Simple method to generate unique and random string value. - """ - return ''.join(random.choice(string.letters) for i in xrange(length)) - - -class StoryKeys(object): - - def __init__(self, type_, activity_): - # keep type - self._type = type_ - # .. - self._activity = activity_ - # .. - self.clear() - - def clear(self): - # .. - self._names = list() - self.__codes = { - 'graphics': dict(), - 'sounds': dict(), - 'story': dict(), - } - self.__clear = { - 'graphics': False, - 'sounds': False, - 'story': False, - } - # - self._keys = dict() - - def loads(self, data, clear=True): - # parse json data - _data_dict = json.loads(data) - # .. - if self._type == 'graphics': - # .. - _tmp_names = _data_dict['graphic_names'] - _tmp_keys = _data_dict['graphic_keys'] - # .. - elif self._type == 'sounds': - # .. - _tmp_names = _data_dict['sound_names'] - _tmp_keys = _data_dict['sound_keys'] - # ?? - else: - return - # reset keys - if clear is True: - self.clear() - else: - pass - # set names - _exist_list = list() - for _n in _tmp_names: - if _n in self._names: - _exist_list.append(_n) - else: - self._names.append(_n) - # ensure keys - for _seq_name, _seq_dict in _tmp_keys.items(): - # get seq_path for check - _seq_path = storage.get_sequence_path(self._type, _seq_name) - # little check - if _seq_name in self._keys: - continue - # check path - elif os.path.exists(_seq_path): - # init seq dict copy - _tmp_seq_dict = dict() - # work on seq dict copy - for _frame_name, _frame_dict in _seq_dict.items(): - # seq dict copy update - _tmp_seq_dict[float(_frame_name)] = _frame_dict - # update main dict - self._keys[_seq_name] = _tmp_seq_dict - # sequence does not exist - else: - if _seq_name in self._names: - self._names.remove(_seq_name) - else: - pass - # .. - return _exist_list - - def add_sequence(self, sequence_name, filenames): - # TODO ensure valid name - if sequence_name in self._names: - return False - else: - # add name to the registry - self._names.append(sequence_name) - # init seq dict - _seq_dict = dict() - # update dict - for _i, _f in enumerate(filenames): - _seq_dict[_f] = { - '__align': [0, 0], - '__duration': 0, - '__loop': False, - '__file_type': None, - '__key_type': None - } - # udpate main dict - self._keys[sequence_name] = { - 0: _seq_dict - } - # ok - return True - - def remove_sequence(self, sequence_name): - # little check - if sequence_name in self._names: - self._names.remove(sequence_name) - del self._keys[sequence_name] - # ?? - else: - pass - - def ask_clear(self): - # ... - self.__clear = { - 'graphics': True, - 'sounds': True, - 'story': True, - } - - def get_clear(self, screen): - return self.__clear[screen] - - def set_clear(self, screen, flag): - self.__clear[screen] = flag - - def set_layout(self, sequence_name, layout): - # little check - if sequence_name in self._names: - _current = self._names.index(sequence_name) - # little check - if _current == layout: - # do nothing - pass - else: - # ... - self._names.remove(sequence_name) - # ... - self._names.insert(layout, sequence_name) - # nothing to do - else: - pass - - def get_layout(self, sequence_name): - if sequence_name in self._names: - return self._names.index(sequence_name) - else: - return -1 - - def get_max_layout(self): - return len(self._names) - 1 - - def set_code(self, screen, sequence_name, filename, _code): - # .. - if sequence_name in self.__codes[screen]: - pass - else: - self.__codes[screen][sequence_name] = dict() - # .. - self.__codes[screen][sequence_name][filename] = _code - - def get_code(self, screen, sequence_name, filename): - # .. - if sequence_name in self.__codes[screen]: - # .. - if filename in self.__codes[screen][sequence_name]: - return self.__codes[screen][sequence_name][filename] - # ?? - else: - return None - # ?? - else: - return None - - def get_sequence_codes(self, screen, sequence_name): - # .. - if sequence_name in self.__codes[screen]: - return self.__codes[screen][sequence_name] - else: - return dict() - - def get_names(self, mask=False): - # .. add mask - if mask is True: - yield 'background_default' - else: - pass - for _n in self._names: - yield _n - # .. add mask - if mask is True: - yield 'mask_default' - else: - pass - - def get_frame_dict(self, sequence_name, frame): - # little check - if sequence_name in self._names: - # .. - _seq_dict = self._keys[sequence_name] - # little check - if frame in _seq_dict: - # get frame dict - return _seq_dict[frame] - else: - return None - else: - return None - - def set_frame(self, sequence_name, previous_frame, new_frame): - # little check - if sequence_name in self._names: - # .. - _seq_dict = self._keys[sequence_name] - # little check - if previous_frame in _seq_dict: - # set frame dict from previous - _seq_dict[new_frame] = _seq_dict[previous_frame] - # clear main dict - del _seq_dict[previous_frame] - else: - pass - else: - pass - - def get_max_frame(self): - # ... - _tmp_set = set() - # ... - for _seq_dict in self._keys.values(): - # udpate set - _tmp_set = _tmp_set.union(_seq_dict.keys()) - # order list - _tmp_list = list(_tmp_set) - _tmp_list.sort() - # return max - if len(_tmp_list) == 0: - return 0 - else: - return _tmp_list[-1] - - def set_filename_dict(self, sequence_name, frame, filename, dict_=None): - # ensure default dict - if dict_ is None: - dict_ = { - '__align': [0, 0], - '__duration': 0, - '__loop': False, - '__file_type': None, - '__key_type': None - } - else: - pass - # ensure frame dict - _frame_dict = self.get_frame_dict(sequence_name, frame) - if _frame_dict is None: - self._keys[sequence_name][frame] = dict() - else: - pass - # update the main dict - self._keys[sequence_name][frame][filename] = dict_ - - def get_filename_dict(self, sequence_name, frame, filename): - # little check - if sequence_name in self._names: - # .. - _seq_dict = self._keys[sequence_name] - # little check - if frame in _seq_dict: - # get frame dict - _frame_dict = _seq_dict[frame] - # little check - if filename in _frame_dict: - # return filename dict - return _frame_dict[filename] - else: - return None - else: - return None - else: - return None - - def remove_filename(self, sequence_name, frame, filename): - # .. get the dict - _f_dict = self.get_filename_dict(sequence_name, frame, filename) - # little check - if _f_dict is None: - return - # do remove - else: - del self._keys[sequence_name][frame][filename] - - def remove_filename_from_all(self, sequence_name, filename): - # little check - if sequence_name in self._names: - for _frame in range(self.get_max_frame()): - self.remove_filename(sequence_name, _frame, filename) - # .. - else: - pass - - def set_align(self, sequence_name, frame, filename, align): - # .. get the dict - _f_dict = self.get_filename_dict(sequence_name, frame, filename) - # little check - if _f_dict is None: - return - else: - self._keys[sequence_name][frame][filename]['__align'] = align - - def get_previous_align(self, sequence_name, frame): - # prepare inversed range - _range = range(frame) - _range.reverse() - # try one by one - for _f in _range: - # get frame dict - _frame_dict = self.get_frame_dict(sequence_name, _f) - # get frame values - _frame_values = [] if _frame_dict is None else _frame_dict.values() - # find first valid key - for _f_dict in _frame_values: - # little check - if _f_dict['__key_type'] != 'key': - continue - elif '__align' in _f_dict: - return _f_dict['__align'] - else: - return [0, 0] - # default - return [0, 0] - - def get_align(self, sequence_name, frame, filename): - # .. get the dict - _f_dict = self.get_filename_dict(sequence_name, frame, filename) - # little check - if _f_dict is None: - return [0, 0] - else: - # ensure default - if '__align' in _f_dict: - return _f_dict['__align'] - else: - # set default - _f_dict['__align'] = [0, 0] - # return default - return [0, 0] - - def get_next_align(self, sequence_name, frame, use_transition=False): - # prepare inversed range - _range = range(frame + 1, self.get_max_frame() + 1) - # try one by one - for _f in _range: - # get frame dict - _frame_dict = self.get_frame_dict(sequence_name, _f) - # get frame values - _frame_values = [] if _frame_dict is None else _frame_dict.values() - # find first valid key - for _f_dict in _frame_values: - # little check - if use_transition is False\ - and _f_dict['__key_type'] != 'key': - continue - elif '__align' in _f_dict\ - and _f_dict['__key_type'] in ['key', 'transition']: - return _f_dict['__align'] - else: - continue - # default - return [0, 0] - - def inc_position(self, sequence_name, frame, filename, move, value): - # get align first - _x, _y = self.get_align(sequence_name, frame, filename) - # inc - if move == 'x': - _x += value - elif move == 'y': - _y += value - else: - # ?? - return - # update - self.set_align(sequence_name, frame, filename, (_x, _y)) - # return current pos - return _x, _y - - def set_duration(self, sequence_name, frame, filename, duration): - # .. get the dict - _f_dict = self.get_filename_dict(sequence_name, frame, filename) - # little check - if _f_dict is None: - return - else: - self._keys[sequence_name][frame][filename]['__duration'] = duration - - def get_duration(self, sequence_name, frame, filename): - # .. get the dict - _f_dict = self.get_filename_dict(sequence_name, frame, filename) - # little check - if _f_dict is None: - return 0 - else: - # ensure default - if '__duration' in _f_dict: - return _f_dict['__duration'] - else: - # set default - _f_dict['__duration'] = 0 - # return default - return 0 - - def inc_duration(self, sequence_name, frame, filename, value): - # get duration first - _d = self.get_duration(sequence_name, frame, filename) - # inc - _d += value - # TODO max is max_ or next key - # get max frame - _max_frame = self._activity._number_of_keys - frame - # ensure value - if _d < 0: - _d = 0 - elif _d >= _max_frame: - _d = _max_frame - 1 - else: - pass - # update - self.set_duration(sequence_name, frame, filename, _d) - # return current pos - return _d - - def set_loop(self, sequence_name, frame, filename, loop): - # .. get the dict - _f_dict = self.get_filename_dict(sequence_name, frame, filename) - # little check - if _f_dict is None: - return - else: - self._keys[sequence_name][frame][filename]['__loop'] = loop - - def get_loop(self, sequence_name, frame, filename): - # .. get the dict - _f_dict = self.get_filename_dict(sequence_name, frame, filename) - # little check - if _f_dict is None: - return False - # ensure default - else: - if '__loop' in _f_dict: - return _f_dict['__loop'] - else: - # set default - _f_dict['__loop'] = False - # return default - return False - - def set_current(self, sequence_name, frame, filename, file_type='lib', - key_type='key'): - """ - file_type lib or jnl - key_type key or transition - """ - # get the dict - _filename_dict = self.get_filename_dict(sequence_name, frame, filename) - # ensure filename dict - if _filename_dict is None: - self.set_filename_dict(sequence_name, frame, filename) - else: - pass - # get the dict - _frame_dict = self.get_frame_dict(sequence_name, frame) - # little check - if _frame_dict is None: - pass - else: - # set current - for _f, _d in _frame_dict.items(): - # key type or none - _ft = key_type if _f == filename else None - # update - self._keys[sequence_name][frame][_f]['__file_type'] = _ft - # key type or none - _kt = key_type if _f == filename else None - # update - self._keys[sequence_name][frame][_f]['__key_type'] = _kt - - def get_current(self, sequence_name, frame): - # get the dict - _f_dict = self.get_frame_dict(sequence_name, frame) - # little check - if _f_dict is None: - return None, None, None - else: - for _f, _d in _f_dict.items(): - if _d['__key_type'] is None: - continue - else: - return _f, _d['__file_type'], _d['__key_type'] - # default - return None, None, None - - def _refresh_graphic_keys(self, sequence_name): - # get max frame - _max_frame = self.get_max_frame() - # little check - if sequence_name in self._keys: - # next dict for transition check - _next_list = list() - _range = list() - _filenames = list() - # update next dict - for _frame, _filename_dict in self._keys[sequence_name].items(): - for _filename, _dict in _filename_dict.items(): - if _filename is None or _dict['__key_type'] != 'key': - # invalidate previous - self._keys[sequence_name][_frame][_filename] = { - '__align': [0, 0], - '__duration': 0, - '__loop': False, - '__file_type': None, - '__key_type': None - } - else: - # small update for transition management - _tr_frame = (_frame + 1) if len(_range) == 0 else _frame - # update current range - _range.append(_tr_frame) - _filenames.append((_filename, _dict['__file_type'])) - # .. - if len(_range) == 2: - _next_list.append((_range, _filenames)) - _range = list() - _filenames = list() - else: - continue - # set transition - for _range, _filenames in _next_list: - # get first align - _first_filename, _first_filetype = _filenames[0] - _first_x, _first_y = self.get_align(sequence_name, _range[0]-1, - _first_filename) - # get last align - _last_filename, _last_filetype = _filenames[1] - _last_x, _last_y = self.get_align(sequence_name, _range[1], - _last_filename) - # compute steps - _inc_x = float(_last_x - _first_x) - _inc_x /= (_range[1] - _range[0] + 1) - _inc_y = float(_last_y - _first_y) - _inc_y /= (_range[1] - _range[0] + 1) - # init new position values - _new_x = _first_x - _new_y = _first_y - for _i in range(*_range): - # compute filename and file type - if _i < ((_range[1] - _range[0]) / 2): - _f = _first_filename - _t = _first_filetype - else: - #_f = _last_filename - #_t = _last_filetype - _f = _first_filename - _t = _first_filename - # set transition - self.set_current(sequence_name, _i, _f, file_type=_t, - key_type='transition') - # compute align - _new_x += _inc_x - _new_y += _inc_y - # update align - self.set_align(sequence_name, _i, _f, (_new_x, _new_y)) - else: - pass - - def _refresh_sound_keys(self, sequence_name): - # shortcut - _max = self._activity._number_of_keys - # little check - if sequence_name in self._keys: - # next dict for transition check - _durations = list() - _loops = list() - # update next dict - for _frame, _filename_dict in self._keys[sequence_name].items(): - for _filename, _dict in _filename_dict.items(): - if _filename is None or _dict['__key_type'] != 'key': - # invalidate previous - self._keys[sequence_name][_frame][_filename] = { - '__align': [0, 0], - '__duration': 0, - '__loop': False, - '__file_type': None, - '__key_type': None - } - else: - if _dict['__loop'] is True: - _loops.append((_frame, _filename, _dict['__file_type'])) - elif _dict['__duration'] != None: - _durations.append((_frame, _filename, - _dict['__file_type'], _dict['__duration'])) - else: - continue - # set transition for loop keys - for _frame, _f, _f_type in _loops: - # little check - _t_start = _frame + 1 - # .. - if _t_start >= _max: - continue - else: - pass - # .. - for _i in range(_t_start, _max+1): - # set transition - self.set_current(sequence_name, _i, _f, - file_type=_f_type, key_type='transition') - # set transition for loop keys - for _frame, _f, _f_type, _d in _durations: - # little check - _t_start = _frame + 1 - _t_end = _t_start + _d - # .. - if _t_start >= _max: - continue - elif _t_end > _max: - _t_end = _max+1 - else: - pass - # .. - if _t_start > _t_end: - continue - else: - pass - # .. - for _i in range(_t_start, _t_end): - _f_dict = self.get_filename_dict(sequence_name, _i, _f) - # update - _kt = None if _f_dict is None else _f_dict['__key_type'] - # .. - if _kt is None: - # set transition - self.set_current(sequence_name, _i, _f, - file_type=_f_type, key_type='transition') - - def check_sequences(self): - # sequence check - _s_to_remove = list() - for _s_name in self._names: - _path = storage.get_sequence_path(self._type, _s_name) - if os.path.exists(_path): - continue - else: - _s_to_remove.append(_s_name) - # .. - for _s_name in _s_to_remove: - self.remove_sequence(_s_name) - - def refresh(self, sequence_name): - # .. - if self._type == 'graphics': - self._refresh_graphic_keys(sequence_name) - else: - self._refresh_sound_keys(sequence_name) |