def _sig_path_entry_activate(self, entry, msg, task): if 'z_run_cmd' in msg: # M-x initiated self.get_editor().get_last_line().start_mx_commanding( msg['z_run_cmd']) return if task == 'activate' and msg['return_msg'] == 'Accept': # activate key is pressed fullpath = io_encap.norm_path(self.path_entry.get_text()) fn_list = os.path.split(fullpath) if io_encap.is_dir(fn_list): self.set_folder(fullpath) elif io_encap.is_file(fn_list): self.open_file(fn_list) else: self.update_path_entry() raise ValueError( 'Cannot open "{0}".\n Make sure the path is spelled correctly.' .format(fullpath)) elif task == 'cancel' and msg['return_msg'] == 'Quit': # cancel key is pressed self.update_path_entry()
def set_folder(self, fullpath=None): # get real path if not fullpath: new_dirname = zTheme.env['starting_path'] else: new_dirname = io_encap.norm_path(fullpath) # test permission if not os.access(new_dirname, os.F_OK): raise AssertionError('Fatal Error: directory does not exist!') if not os.access(new_dirname, os.R_OK): raise AssertionError('Permission Denied: directory not readable!') if not os.access(new_dirname, os.X_OK): raise AssertionError('Permission Denied: directory not navigable!') # begin to changing folder if self.__on_setting_folder: return # early return else: self.__on_setting_folder = True self.dirname = new_dirname self.treeview.dirname = self.dirname # fetch file listing self.__file_list = [] self.__dir_list = [] for non_hidden in [ fn for fn in os.listdir(self.dirname) if fn[0] <> '.' ]: fn_list = [self.dirname, non_hidden] if io_encap.is_dir(fn_list): self.__dir_list.append(non_hidden) else: self.__file_list.append(non_hidden) self.__file_list.sort(key=str.lower) self.__dir_list.sort(key=str.lower) self.__dir_list = ['..'] + self.__dir_list # update model with the listing self.treeview.model.clear() for fn in self.__dir_list: self.treeview.model.append([fn, False]) for fn in self.__file_list: self.treeview.model.append([fn, False]) self.update_path_entry() # clear flags for key in self.__cell_data_func_skip: self.__cell_data_func_skip[key] = None self.__file_name_old = '' self.__on_setting_folder = False
def set_db(self, db_file): if self.__on_init: return # on initializing, early return if zDisplayPanel._DB_FILE: db_file = zDisplayPanel._DB_FILE # force switch to overall setting # normalize path db_file = io_encap.norm_path(db_file) if self.__db_file: if self.__db_file == db_file: return # no need to change, early return else: self.disconnect_db() if db_file: self.__db_file = db_file self.connect_db() else: self.__db_file = None
# this is the "Major Editing Mode" selector # each Major Mode is defined as an resource module in "zMajorMode" # resource folder, or in user's config folder (~/.zPE/) from zPE.GUI import min_import, GUI_PGK_PATH from zPE.GUI.io_encap import norm_path, list_dir from zPE.GUI.conf import CONFIG_PATH, MODE_MAP, DEFAULT_BUFF_MODE_MAP as DEFAULT import os, sys SEARCH_PATH = { 'global': norm_path(os.path.join(GUI_PGK_PATH[0], "zMajorMode")), 'user': norm_path(CONFIG_PATH['dir']), } # BaseMode need to be imported the EXACT SAME WAY as other modes are _base_ = min_import('zPE.GUI.basemode', ['BaseMode'], 0) def load_mode(path): for fn in list_dir(path): [mn, ext] = os.path.splitext(fn) # Handles no-extension files, etc. if ext == '.py': cn = mn.title() + 'Mode' try: _cls_ = min_import(mn, [cn], -1, path) _obj_ = _cls_() except: sys.stderr.write( 'warn: {0}: Fail to load Major Mode Module.\n'.format(cn))
def set_db_all(db_file): if db_file: zDisplayPanel._DB_FILE = io_encap.norm_path(db_file) else: zDisplayPanel._DB_FILE = None
def _sig_key_pressed(self, widget, event, task, init_widget=None): # self.__debug_print_maps() if event.type != gtk.gdk.KEY_PRESS: return False if event.is_modifier: return False ### generate stroke ctrl_mod_mask = gtk.gdk.CONTROL_MASK | gtk.gdk.MOD1_MASK # check and re-map punctuation mark key_name = gtk.gdk.keyval_name(event.keyval) if key_name in PUNCT_KEY_MAP: # punctuation key_name = PUNCT_KEY_MAP[key_name] elif key_name.upper() in FUNC_KEY_MAP: # function key if event.state & gtk.gdk.SHIFT_MASK: # only check SHIFT modifier when a function key is pressed key_name = 'S-' + key_name elif len(key_name) == 1 and key_name.isalpha(): # letters if (event.state & gtk.gdk.LOCK_MASK) == gtk.gdk.LOCK_MASK: key_name = key_name.swapcase() if (event.state & ctrl_mod_mask) == ctrl_mod_mask: stroke = 'C-M-' + key_name elif event.state & gtk.gdk.CONTROL_MASK: stroke = 'C-' + key_name elif event.state & gtk.gdk.MOD1_MASK: stroke = 'M-' + key_name else: stroke = key_name if task == 'func': self.__entry_entering = True # initialize the editable flag try: w_editable = widget.get_editable() except: w_editable = None ### style-regardless checkings # check Cancelling if is_sp_func_key(stroke, 'CANCEL', self.get_style()): # with any style, this means 'cancel' if not init_widget or task != 'func': # init_widget not set, or in regular mode (non-mx-mode) init_widget = widget self.emit('z_cancel', self.__build_msg(init_widget, stroke, 'Quit')) self.__update_last_cmd('Quit') # on cancelling, reset all modes self.__combo_entering = False self.__combo_content = '' self.__entry_entering = False self.__entry_content = '' return True # no Cancelling # check Activating if (not self.__combo_entering and # must not on combo-entering, and is_sp_func_key(stroke, 'ACTIVATE', self.get_style()) # the activate kay is pressed ): if task == 'text': return False # pass 'Enter' to the widget to handle elif task == 'func': # is on M-x commanding self.__entry_content = widget.get_text( ) # update the content backup if not init_widget: # set the responing widget init_widget = widget local_is_enabled_func = init_widget.listener.is_enabled_func local_func_callback_map = init_widget.listener.func_callback_map if self.__is_enabled_func(self.__entry_content, local_is_enabled_func): # is a valid functionality if self.__entry_content in local_func_callback_map: # has registered function self.__z_activate_callback = local_func_callback_map[ self.__entry_content] self.emit( 'z_activate', self.__build_msg(init_widget, stroke, 'Accept')) self.__z_activate_callback = None elif self.__entry_content in zStrokeListener.global_func_callback_map: # has globally registered function self.__z_activate_callback = zStrokeListener.global_func_callback_map[ self.__entry_content] self.emit( 'z_activate', self.__build_msg(init_widget, stroke, 'Accept')) self.__z_activate_callback = None else: self.emit( 'z_cancel', self.__build_msg( init_widget, stroke, '(function `{0}` not implemented)'.format( self.__entry_content))) else: self.emit( 'z_cancel', self.__build_msg( init_widget, stroke, '({0}: no such function)'.format( self.__entry_content))) # record the function the init_widget is trying to invoke init_widget.listener.__update_last_cmd(self.__entry_content) # M-x cmd emitted, reset entering mode self.__entry_entering = False self.__entry_content = '' return True # must be 'file', 'dir', or 'path' path_entered = widget.get_text() if path_entered: # normalize path if '"' in path_entered: path_entered = path_entered.replace('"', '') path_entered = io_encap.norm_path(path_entered) widget.set_text(path_entered) if ((task == 'file' and not os.path.isdir(path_entered)) or (task == 'dir' and not os.path.isfile(path_entered)) or (task == 'path')): self.emit('z_activate', self.__build_msg(widget, stroke, 'Accept')) self.__update_last_cmd('Activate') elif self.__is_enabled_func('complete-list'): # list completion is enabled, execute it if mapped if 'complete-list' in self.func_callback_map: self.func_callback_map['complete-list']() elif 'complete-list' in zStrokeListener.global_func_callback_map: zStrokeListener.global_func_callback_map[ 'complete-list']() return True # no Activating ### style-specific checkings if self.get_style() == 'emacs': # style::emacs # check C-q Escaping if self.__escaping: # this should guarantee no combo is entering try: if w_editable: if self.__is_printable(stroke): insertion = stroke elif stroke.upper() in self.__ctrl_char_map: insertion = self.__ctrl_char_map[stroke.upper()] else: insertion = '' # ignore the rest ctrl chars self.__insert_text(widget, insertion) else: pass # no need to handle C-q escaping when the widget is not editable except: pass # if anything goes wrong, give up the escaping self.__escaping = False return True # no C-q Escaping # check M-x Commanding input if (not self.__combo_entering and self.__entry_entering): # on M-x Commanding, Commanding *MUST NOT* be initiated if self.__is_printable(stroke): # regular keypress self.__insert_text(widget, stroke) return True elif self.__is_space(stroke): # space self.__insert_text(widget, ' ') return True else: # leave the rest checking to commanding pass # no active M-x Commanding, or stroke is passed on # check initiated Commanding if not self.__combo_entering: # initiating stroke, check reserved bindings (M-x and C-q) if stroke == 'M-x': self.emit('z_activate', {'z_run_cmd': widget}) return True elif stroke == 'C-q': # start C-q Escaping if w_editable: self.__escaping = True else: pass # no need to handle C-q escaping when the widget is not editable return True # not reserved bindings, check forbidden bindings (printable) elif self.__is_printable(stroke): # is a printable if w_editable: self.__insert_text(widget, stroke) else: self.emit('z_activate', self.__build_msg(widget, stroke, '')) return True # not any reserved or forbidden bindings # initiate Commanding self.__combo_entering = True self.__combo_focus_widget = widget self.__combo_focus_widget_id = widget.connect( 'focus-out-event', self._sig_kp_focus_out) # Commanding initiated # on commanding # retrieve previous combo, if there is any if self.__combo_content: # appand previous combo to stroke stroke = '{0} {1}'.format(self.__combo_content, stroke) # validate stroke sequence key_binding = zStrokeListener.__key_func_binding # make a reference if stroke in key_binding and self.__is_enabled_func( key_binding[stroke]): # is a valid functionality self.__combo_content = stroke self.__kp_focus_out_rm() # release focus requirement if key_binding[stroke] in self.func_callback_map: # has registered functions self.__z_activate_callback = self.func_callback_map[ key_binding[stroke]] self.emit('z_activate', self.__build_msg(widget, stroke, '')) self.__z_activate_callback = None elif key_binding[ stroke] in zStrokeListener.global_func_callback_map: # has globally registered function self.__z_activate_callback = zStrokeListener.global_func_callback_map[ key_binding[stroke]] self.emit('z_activate', self.__build_msg(widget, stroke, '')) self.__z_activate_callback = None else: self.emit( 'z_cancel', self.__build_msg( widget, stroke, '(function `{0}` not implemented)'.format( key_binding[stroke]))) # record the function the widget is trying to invoke self.__update_last_cmd(key_binding[stroke]) # cmd emitted, reset combo mode self.__combo_entering = False self.__combo_content = '' return True else: # not a valid stroke sequence so far found = False for key in key_binding: if key.startswith(stroke): # part of a valid stroke sequence self.emit('z_activate', self.__build_msg(widget, stroke, 'z_combo')) found = True break if found: self.__combo_content = stroke return True else: # not a valid stroke sequence *AT ALL* self.__kp_focus_out_rm() # release focus requirement if not self.__combo_content: # initiate stroke, do not eat it self.__combo_entering = False if self.__is_space(stroke): # space if w_editable: self.__insert_text(widget, ' ') else: self.emit('z_activate', self.__build_msg(widget, ' ', '')) return True else: # not regular keypress nor space, pass it to the widget self.__update_last_cmd(None) return False else: # has previous combo, eat the current combo self.emit( 'z_cancel', self.__build_msg(widget, stroke, stroke + ' is undefined!')) self.__update_last_cmd(None) # cmd terminated, reset combo mode self.__combo_entering = False self.__combo_content = '' return True elif self.get_style() == 'vi': # style::vi return False # not implemetad yet else: # style::other key_binding = zStrokeListener.__key_func_binding # make a reference if (stroke in key_binding and # is a binded key stroke self.__is_enabled_func( key_binding[stroke]) # is a valid functionality ): if key_binding[stroke] in self.func_callback_map: # has registered functions self.__z_activate_callback = self.func_callback_map[ key_binding[stroke]] self.emit('z_activate', self.__build_msg(widget, stroke, '')) self.__z_activate_callback = None elif key_binding[ stroke] in zStrokeListener.global_func_callback_map: # has globally registered function self.__z_activate_callback = zStrokeListener.global_func_callback_map[ key_binding[stroke]] self.emit('z_activate', self.__build_msg(widget, stroke, '')) self.__z_activate_callback = None else: self.emit( 'z_cancel', self.__build_msg( widget, stroke, '(function `{0}` not implemented)'.format( key_binding[stroke]))) # record the function the widget is trying to invoke self.__update_last_cmd(key_binding[stroke]) return True else: if self.__is_printable(stroke): # regular keypress if w_editable: self.__insert_text(widget, stroke) else: self.emit('z_activate', self.__build_msg(widget, stroke, '')) return True elif self.__is_space(stroke): # space if w_editable: self.__insert_text(widget, ' ') else: self.emit('z_activate', self.__build_msg(widget, ' ', '')) return True else: # not regular keypress nor space, pass it to the widget self.__update_last_cmd(None) return False raise LookupError( '{0}: key stroke not captured or processed.\n\tPlease report this as a bug.' .format(stroke))
def read_rc(): init_rc() __CK_CONFIG() label = None for line in open(CONFIG_PATH['gui_rc'], 'r'): if line.isspace(): # skip empty line continue line = line[:-1] # get rid of the '\n' if line in ['[MISC]', '[FONT]', '[COLOR_MAP]', '[ENV]']: label = line[1:-1] # retrieve the top-level key continue if not label: continue # no top-level key so far, skip the line (k, v) = re.split('[ \t]*=[ \t]*', line, maxsplit=1) if label == 'MISC': if k in [ 'tab_on', 'tab_grouped', 'debug_mode', ]: if v and v not in STR_FALSE: Config[label][k] = 1 else: Config[label][k] = 0 elif k == 'key_binding': if v in DEFAULT_FUNC_KEY_BIND_KEY: Config[label][k] = v else: Config[label][k] = DEFAULT['MISC']['KEY_BINDING'] sys.stderr.write( 'CONFIG WARNING: {0}: Invalid key binding style.\n'. format(v)) elif k == 'kill_ring_sz': try: v = int(v) if v >= 1: Config[label][k] = v else: sys.stderr.write( 'CONFIG WARNING: {0}: Kill-ring size must be at least 1.\n' .format(v)) except ValueError: Config[label][k] = DEFAULT['MISC']['KILL_RING_SZ'] sys.stderr.write( 'CONFIG WARNING: {0}: Invalid kill-ring size.\n'. format(v)) elif label == 'FONT': if k == 'name': found = False for font in MONO_FONT: if font == v: Config[label][k] = v found = True break if not found: sys.stderr.write( 'CONFIG WARNING: {0}: Invalid font name.\n'.format(v)) elif k == 'size': try: Config[label][k] = int(v) except ValueError: Config[label][k] = DEFAULT['FONT_SZ'] sys.stderr.write( 'CONFIG WARNING: {0}: Invalid font size.\n'.format(v)) elif label == 'COLOR_MAP': if v.lower() in COLOR_LIST: v_ty = 'name' v = COLOR_LIST[v] else: v_ty = 'code' v = v.upper() # convert hex color code to all upper case if not re.match('#[0-9A-F]{6}', v): sys.stderr.write( 'CONFIG WARNING: {0}: Invalid color {1}.\n'.format( v, v_ty)) continue # valid color, check key if k in Config[label]: Config[label][k] = v else: sys.stderr.write( 'CONFIG WARNING: {0}: Invalid color mapping.\n'.format(k)) elif label == 'ENV': if k == 'starting_path': tmp_v = io_encap.norm_path(v) if os.path.isdir(tmp_v): Config[label][k] = tmp_v else: Config[label][k] = io_encap.norm_path( DEFAULT['ENV']['STARTING_PATH']) sys.stderr.write( 'CONFIG WARNING: {0}: Invalid starting path.\n'.format( v)) write_rc()