Changeset 1419

Show
Ignore:
Timestamp:
07/13/06 17:03:17 (2 years ago)
Author:
jstenar
Message:

pyreadline-refactor: More work on ironpython port especially to keep cpython working.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • pyreadline/branches/refactor/doc/ChangeLog

    r1385 r1419  
     12006-07-13 Jörgen Stenarson  <jorgen.stenarson -at- bostream.nu> 
     2    * Work to get selection between ironpython and cpython to work 
     3    * Some editing works but there are issues with control keys for ironpython 
     4 
    152006-07-04 Jörgen Stenarson  <jorgen.stenarson -at- bostream.nu> 
    26    * First commit for ironpython. Typing in alphabet works but no special keys. 

  • pyreadline/branches/refactor/pyreadline/__init__.py

    r1385 r1419  
    77#  the file COPYING, distributed as part of this software. 
    88#***************************************************************************** 
    9  
    109import logger,clipboard,lineeditor,modes 
    1110from rlmain import * 

  • pyreadline/branches/refactor/pyreadline/clipboard/__init__.py

    r1385 r1419  
    1 from common import * 
    21success=False 
     2 
    33try: 
    44    from clipboard import GetClipboardText,SetClipboardText 
    55    success=True 
    66except ImportError: 
    7     pass 
    8      
    9 try: 
    10     from ironpython_clipboard import GetClipboardText,SetClipboardText 
    11     success=True 
    12 except ImportError: 
    13     pass 
     7    try: 
     8        from ironpython_clipboard import GetClipboardText,SetClipboardText 
     9        success=True 
     10    except ImportError: 
     11        pass 
    1412     
    1513     
    1614     
    1715     
     16 
     17 
     18def send_data(lists): 
     19    SetClipboardText(make_tab(lists)) 
     20     
     21 
     22def set_clipboard_text(toclipboard): 
     23    SetClipboardText(str(toclipboard)) 
     24 
     25def make_tab(lists): 
     26    if hasattr(lists,"tolist"): 
     27        lists=lists.tolist() 
     28    ut=[] 
     29    for rad in lists: 
     30        if type(rad) in [list,tuple]: 
     31            ut.append("\t".join(["%s"%x for x in rad])) 
     32        else: 
     33            ut.append("%s"%rad) 
     34    return "\n".join(ut)             
     35     
     36def make_list_of_list(txt): 
     37    def make_num(x): 
     38        try: 
     39            return int(x) 
     40        except ValueError: 
     41            try: 
     42                return float(x) 
     43            except ValueError: 
     44                try: 
     45                    return complex(x) 
     46                except ValueError: 
     47                    return x 
     48        return x                 
     49    ut=[] 
     50    flag=False 
     51    for rad in [x for x in txt.split("\r\n") if x!=""]: 
     52        raden=[make_num(x) for x in rad.split("\t")] 
     53        if str in map(type,raden): 
     54            flag=True 
     55        ut.append(raden) 
     56    return ut,flag 
     57 
     58 
     59def get_clipboard_text_and_convert(paste_list=False): 
     60    """Get txt from clipboard. if paste_list==True the convert tab separated  
     61    data to list of lists. Enclose list of list in array() if all elements are  
     62    numeric""" 
     63    txt=GetClipboardText() 
     64    if txt: 
     65        if paste_list and "\t" in txt: 
     66            array,flag=make_list_of_list(txt) 
     67            if flag: 
     68                txt=repr(array) 
     69            else: 
     70                txt="array(%s)"%repr(array) 
     71            txt="".join([c for c in txt if c not in " \t\r\n"]) 
     72    return txt 
     73 

  • pyreadline/branches/refactor/pyreadline/clipboard/clipboard.py

    r1385 r1419  
    3535 
    3636from ctypes import * 
    37 from keysyms.winconstants import CF_TEXT, GHND 
     37from pyreadline.keysyms.winconstants import CF_TEXT, GHND 
    3838 
    3939OpenClipboard = windll.user32.OpenClipboard 

  • pyreadline/branches/refactor/pyreadline/console/__init__.py

    r1385 r1419  
    77    success=True 
    88except ImportError: 
    9     pass 
    109 
    11 try: 
    12     from ironpython_console import * 
    13     success=True 
    14 except ImportError: 
    15     pass 
     10    try: 
     11        from ironpython_console import * 
     12        success=True 
     13    except ImportError: 
     14        pass 
    1615 
    1716 

  • pyreadline/branches/refactor/pyreadline/console/console.py

    r1385 r1419  
    2727 
    2828# my code 
    29 from pyreadline.keysyms import make_keysym, make_keyinfo 
     29from pyreadline.keysyms import make_KeyPress 
    3030 
    3131# some constants we need 
    …… 
    460460        while 1: 
    461461            e = self.get() 
    462             log("getKeypress:%s,%s,%s"%(e.keyinfo,e.keycode,e.type)) 
    463462            if e.type == 'KeyPress' and e.keycode not in key_modifiers: 
    464463                log(e) 
    …… 
    470469                    return e 
    471470            elif e.type == 'KeyRelease' and e.keyinfo==(True, False, False, 83): 
     471                log("getKeypress:%s,%s,%s"%(e.keyinfo,e.keycode,e.type)) 
    472472                return e 
    473473                 
    …… 
    545545from event import Event 
    546546 
     547VkKeyScan = windll.user32.VkKeyScanA 
     548 
     549 
    547550class event(Event): 
    548551    '''Represent events from the console.''' 
    …… 
    558561        self.keycode = 0 
    559562        self.keysym = '??' 
    560         self.keyinfo = '' # a tuple with (control, meta, shift, keycode) for dispatch 
     563        self.keyinfo = None # a tuple with (control, meta, shift, keycode) for dispatch 
    561564        self.width = None 
    562  
     565         
    563566        if input.EventType == KEY_EVENT: 
    564567            if input.Event.KeyEvent.bKeyDown: 
    …… 
    569572            self.keycode = input.Event.KeyEvent.wVirtualKeyCode 
    570573            self.state = input.Event.KeyEvent.dwControlKeyState 
    571             self.keysym = make_keysym(self.keycode) 
    572             self.keyinfo = make_keyinfo(self.keycode, self.state) 
     574            self.keyinfo=make_KeyPress(self.char,self.state,self.keycode) 
     575 
    573576        elif input.EventType == MOUSE_EVENT: 
    574577            if input.Event.MouseEvent.dwEventFlags & MOUSE_MOVED: 
    …… 
    691694if __name__ == '__main__': 
    692695    import time, sys 
     696 
     697     
     698    def p(char): 
     699        return chr(VkKeyScan(ord(char)) & 0xff) 
     700 
    693701    c = Console(0) 
    694702    sys.stdout = c 
    695703    sys.stderr = c 
    696704    c.page() 
     705    print p("d"),p("D") 
    697706    c.pos(5, 10) 
    698707    c.write('hi there') 

  • pyreadline/branches/refactor/pyreadline/console/event.py

    r1385 r1419  
    2020            s = 'unknown event type' 
    2121        return s 
     22 
     23 
     24#    def __str__(self): 
     25#        return "('%s',%s,%s,%s)"%(self.char,self.key,self.state,self.keyinfo) 

  • pyreadline/branches/refactor/pyreadline/console/ironpython_console.py

    r1385 r1419  
    1313 
    1414import clr 
    15 clr.AddReference("IronPythonConsole.exe") 
     15clr.AddReference("ipy.exe") 
    1616import IronPythonConsole 
    1717 
    …… 
    2626from pyreadline.logger import log 
    2727 
    28 print "Codepage",System.Console.InputEncoding.CodePage 
    29 from pyreadline.keysyms import make_keysym, make_keyinfo 
     28#print "Codepage",System.Console.InputEncoding.CodePage 
     29from pyreadline.keysyms import make_keysym, make_keyinfo,make_KeyPress 
    3030 
    3131color=System.ConsoleColor 
    …… 
    6262        self.attr = System.Console.ForegroundColor 
    6363        self.saveattr = System.Console.ForegroundColor 
    64         log('initial attr=%x' % self.attr) 
     64        log('initial attr=%s' % self.attr) 
    6565 
    6666    def __del__(self): 
    …… 
    220220        pass 
    221221        #raise NotImplementedError 
     222        x0, y0, x1, y1 = rect 
     223        if attr is None: 
     224            attr = self.attr 
     225        if fill: 
     226            rowfill=fill[:1]*abs(x1-x0) 
     227        else: 
     228            rowfill=' '*abs(x1-x0) 
     229        for y in range(y0, y1): 
     230                System.Console.SetCursorPosition(x0,y) 
     231                self.write_color(rowfill,attr) 
    222232 
    223233    def scroll(self, rect, dx, dy, attr=None, fill=' '): 
    …… 
    264274            return sc.WindowWidth,sc.WindowHeight 
    265275     
    266     def cursor(self, visible=None, size=None): 
     276    def cursor(self, visible=True, size=None): 
    267277        '''Set cursor on or off.''' 
    268278        System.Console.CursorVisible=visible 
    …… 
    286296        self.x = 0 
    287297        self.y = 0 
    288         self.char = chr(input.KeyChar) 
     298        self.char = str(input.KeyChar) 
    289299        self.keycode = input.Key 
    290300        self.state = input.Modifiers 
    …… 
    293303 
    294304        self.keysym = make_keysym(self.keycode) 
    295         self.keyinfo = make_keyinfo(self.keycode, self.state) 
     305        self.keyinfo = make_KeyPress(self.char, self.state, self.keycode) 
    296306 
    297307 
    …… 
    316326        return c 
    317327 
    318 if __name__ == '_zx_main__': 
     328if __name__ == '__main__': 
    319329    import time, sys 
    320330    c = Console(0) 
    …… 
    334344    del c 
    335345 
     346System.Console.Clear() 

  • pyreadline/branches/refactor/pyreadline/keysyms/__init__.py

    r1385 r1419  
    66    success=True 
    77except ImportError,x: 
    8     pass 
    98 
    10 try: 
    11     from ironpython_keysyms import * 
    12     success=True 
    13 except ImportError,x: 
    14     pass 
     9    try: 
     10        from ironpython_keysyms import * 
     11        success=True 
     12    except ImportError,x: 
     13        pass 
    1514     
    1615if not success: 

  • pyreadline/branches/refactor/pyreadline/keysyms/ironpython_keysyms.py

    r1385 r1419  
    88#***************************************************************************** 
    99import System 
     10from common import validkey,KeyPress,make_KeyPress_from_keydescr 
    1011 
    1112c32=System.ConsoleKey 
     13Shift=System.ConsoleModifiers.Shift 
     14Control=System.ConsoleModifiers.Control 
     15Alt=System.ConsoleModifiers.Alt 
    1216# table for translating virtual keys to X windows key symbols 
    1317code2sym_map = {#c32.CANCEL: 'Cancel', 
    …… 
    185189    shift=False 
    186190    return (control, meta, shift, keycode) 
     191 
     192 
     193def make_KeyPress(char,state,keycode): 
     194 
     195    shift=bool(int(state)&int(Shift)) 
     196    control=bool(int(state)&int(Control)) 
     197    meta=bool(int(state)&int(Alt)) 
     198    keyname=code2sym_map.get(keycode,"").lower() 
     199    if control: 
     200        char=str(keycode) 
     201    return KeyPress(char,shift,control,meta,keyname) 
     202 

  • pyreadline/branches/refactor/pyreadline/keysyms/keysyms.py

    r1385 r1419  
    1111import ctypes 
    1212# table for translating virtual keys to X windows key symbols 
    13 code2sym_map = {c32.VK_CANCEL: 'Cancel', 
    14                 c32.VK_BACK: 'BackSpace', 
    15                 c32.VK_TAB: 'Tab', 
    16                 c32.VK_CLEAR: 'Clear', 
    17                 c32.VK_RETURN: 'Return', 
    18                 c32.VK_SHIFT:'Shift_L', 
    19                 c32.VK_CONTROL: 'Control_L', 
    20                 c32.VK_MENU: 'Alt_L', 
    21                 c32.VK_PAUSE: 'Pause', 
    22                 c32.VK_CAPITAL: 'Caps_Lock', 
    23                 c32.VK_ESCAPE: 'Escape', 
    24                 c32.VK_SPACE: 'space', 
    25                 c32.VK_PRIOR: 'Prior', 
    26                 c32.VK_NEXT: 'Next', 
    27                 c32.VK_END: 'End', 
    28                 c32.VK_HOME: 'Home', 
    29                 c32.VK_LEFT: 'Left', 
    30                 c32.VK_UP: 'Up', 
    31                 c32.VK_RIGHT: 'Right', 
    32                 c32.VK_DOWN: 'Down', 
    33                 c32.VK_SELECT: 'Select', 
    34                 c32.VK_PRINT: 'Print', 
    35                 c32.VK_EXECUTE: 'Execute', 
    36                 c32.VK_SNAPSHOT: 'Snapshot', 
    37                 c32.VK_INSERT: 'Insert', 
    38                 c32.VK_DELETE: 'Delete', 
    39                 c32.VK_HELP: 'Help', 
    40                 c32.VK_F1: 'F1', 
    41                 c32.VK_F2: 'F2', 
    42                 c32.VK_F3: 'F3', 
    43                 c32.VK_F4: 'F4', 
    44                 c32.VK_F5: 'F5', 
    45                 c32.VK_F6: 'F6', 
    46                 c32.VK_F7: 'F7', 
    47                 c32.VK_F8: 'F8', 
    48                 c32.VK_F9: 'F9', 
    49                 c32.VK_F10: 'F10', 
    50                 c32.VK_F11: 'F11', 
    51                 c32.VK_F12: 'F12', 
    52                 c32.VK_F13: 'F13', 
    53                 c32.VK_F14: 'F14', 
    54                 c32.VK_F15: 'F15', 
    55                 c32.VK_F16: 'F16', 
    56                 c32.VK_F17: 'F17', 
    57                 c32.VK_F18: 'F18', 
    58                 c32.VK_F19: 'F19', 
    59                 c32.VK_F20: 'F20', 
    60                 c32.VK_F21: 'F21', 
    61                 c32.VK_F22: 'F22', 
    62                 c32.VK_F23: 'F23', 
    63                 c32.VK_F24: 'F24', 
    64                 c32.VK_NUMLOCK: 'Num_Lock,', 
    65                 c32.VK_SCROLL: 'Scroll_Lock', 
    66                 c32.VK_APPS: 'VK_APPS', 
    67                 c32.VK_PROCESSKEY: 'VK_PROCESSKEY', 
    68                 c32.VK_ATTN: 'VK_ATTN', 
    69                 c32.VK_CRSEL: 'VK_CRSEL', 
    70                 c32.VK_EXSEL: 'VK_EXSEL', 
    71                 c32.VK_EREOF: 'VK_EREOF', 
    72                 c32.VK_PLAY: 'VK_PLAY', 
    73                 c32.VK_ZOOM: 'VK_ZOOM', 
    74                 c32.VK_NONAME: 'VK_NONAME', 
    75                 c32.VK_PA1: 'VK_PA1', 
    76                 c32.VK_OEM_CLEAR: 'VK_OEM_CLEAR', 
    77                 c32.VK_NUMPAD0: 'NUMPAD0', 
    78                 c32.VK_NUMPAD1: 'NUMPAD1', 
    79                 c32.VK_NUMPAD2: 'NUMPAD2', 
    80                 c32.VK_NUMPAD3: 'NUMPAD3', 
    81                 c32.VK_NUMPAD4: 'NUMPAD4', 
    82                 c32.VK_NUMPAD5: 'NUMPAD5', 
    83                 c32.VK_NUMPAD6: 'NUMPAD6', 
    84                 c32.VK_NUMPAD7: 'NUMPAD7', 
    85                 c32.VK_NUMPAD8: 'NUMPAD8', 
    86                 c32.VK_NUMPAD9: 'NUMPAD9', 
    87                 c32.VK_DIVIDE: 'Divide', 
    88                 c32.VK_MULTIPLY: 'Multiply', 
    89                 c32.VK_ADD: 'Add', 
    90                 c32.VK_SUBTRACT: 'Subtract', 
    91                 c32.VK_DECIMAL: 'VK_DECIMAL' 
     13 
     14from common import validkey,KeyPress,make_KeyPress_from_keydescr 
     15 
     16code2sym_map = {c32.VK_CANCEL:     'cancel', 
     17                c32.VK_BACK:       'backspace', 
     18                c32.VK_TAB:        'tab', 
     19                c32.VK_CLEAR:      'clear', 
     20                c32.VK_RETURN:     'return', 
     21                c32.VK_SHIFT:      'shift_l', 
     22                c32.VK_CONTROL:    'control_l', 
     23                c32.VK_MENU:       'alt_l', 
     24                c32.VK_PAUSE:      'pause', 
     25                c32.VK_CAPITAL:    'caps_lock', 
     26                c32.VK_ESCAPE:     'escape', 
     27                c32.VK_SPACE:      'space', 
     28                c32.VK_PRIOR:      'prior', 
     29                c32.VK_NEXT:       'next', 
     30                c32.VK_END:        'end', 
     31                c32.VK_HOME:       'home', 
     32                c32.VK_LEFT:       'left', 
     33                c32.VK_UP:         'up', 
     34                c32.VK_RIGHT:      'right', 
     35                c32.VK_DOWN:       'down', 
     36                c32.VK_SELECT:     'select', 
     37                c32.VK_PRINT:      'print', 
     38                c32.VK_EXECUTE:    'execute', 
     39                c32.VK_SNAPSHOT:   'snapshot', 
     40                c32.VK_INSERT:     'insert', 
     41                c32.VK_DELETE:     'delete', 
     42                c32.VK_HELP:       'help', 
     43                c32.VK_F1:         'f1', 
     44                c32.VK_F2:         'f2', 
     45                c32.VK_F3:         'f3', 
     46                c32.VK_F4:         'f4', 
     47                c32.VK_F5:         'f5', 
     48                c32.VK_F6:         'f6', 
     49                c32.VK_F7:         'f7', 
     50                c32.VK_F8:         'f8', 
     51                c32.VK_F9:         'f9', 
     52                c32.VK_F10:        'f10', 
     53                c32.VK_F11:        'f11', 
     54                c32.VK_F12:        'f12', 
     55                c32.VK_F13:        'f13', 
     56                c32.VK_F14:        'f14', 
     57                c32.VK_F15:        'f15', 
     58                c32.VK_F16:        'f16', 
     59                c32.VK_F17:        'f17', 
     60                c32.VK_F18:        'f18', 
     61                c32.VK_F19:        'f19', 
     62                c32.VK_F20:        'f20', 
     63                c32.VK_F21:        'f21', 
     64                c32.VK_F22:        'f22', 
     65                c32.VK_F23:        'f23', 
     66                c32.VK_F24:        'f24', 
     67                c32.VK_NUMLOCK:    'num_lock,', 
     68                c32.VK_SCROLL:     'scroll_lock', 
     69                c32.VK_APPS:       'vk_apps', 
     70                c32.VK_PROCESSKEY: 'vk_processkey', 
     71                c32.VK_ATTN:       'vk_attn', 
     72                c32.VK_CRSEL:      'vk_crsel', 
     73                c32.VK_EXSEL:      'vk_exsel', 
     74                c32.VK_EREOF:      'vk_ereof', 
     75                c32.VK_PLAY:       'vk_play', 
     76                c32.VK_ZOOM:       'vk_zoom', 
     77                c32.VK_NONAME:     'vk_noname', 
     78                c32.VK_PA1:        'vk_pa1', 
     79                c32.VK_OEM_CLEAR   :'vk_oem_clear', 
     80                c32.VK_NUMPAD0:    'numpad0', 
     81                c32.VK_NUMPAD1:    'numpad1', 
     82                c32.VK_NUMPAD2:    'numpad2', 
     83                c32.VK_NUMPAD3:    'numpad3', 
     84                c32.VK_NUMPAD4:    'numpad4', 
     85                c32.VK_NUMPAD5:    'numpad5', 
     86                c32.VK_NUMPAD6:    'numpad6', 
     87                c32.VK_NUMPAD7:    'numpad7', 
     88                c32.VK_NUMPAD8:    'numpad8', 
     89                c32.VK_NUMPAD9:    'numpad9', 
     90                c32.VK_DIVIDE:     'divide', 
     91                c32.VK_MULTIPLY:   'multiply', 
     92                c32.VK_ADD:        'add', 
     93                c32.VK_SUBTRACT:   'subtract', 
     94                c32.VK_DECIMAL:    'vk_decimal' 
    9295               } 
    93  
    94 # function to handle the mapping 
    95 def make_keysym(keycode): 
    96     try: 
    97         sym = code2sym_map[keycode] 
    98     except KeyError: 
    99         sym = '' 
    100     return sym 
    101  
    102 sym2code_map = {} 
    103 for code,sym in code2sym_map.iteritems(): 
    104     sym2code_map[sym.lower()] = code 
    105  
    106 def key_text_to_keyinfo(keytext): 
    107     '''Convert a GNU readline style textual description of a key to keycode with modifiers''' 
    108     if keytext.startswith('"'): # " 
    109         return keyseq_to_keyinfo(keytext[1:-1]) 
    110     else: 
    111         return keyname_to_keyinfo(keytext) 
    11296 
    11397VkKeyScan = windll.user32.VkKeyScanA 
    11498 
    11599def char_to_keyinfo(char, control=False, meta=False, shift=False): 
     100    k=KeyPress() 
    116101    vk = VkKeyScan(ord(char)) 
    117102    if vk & 0xffff == 0xffff: 
    …… 
    119104        raise ValueError, 'bad key' 
    120105    if vk & 0x100: 
    121         shift = True 
     106        k.shift = True 
    122107    if vk & 0x200: 
    123         control = True 
     108        k.control = True 
    124109    if vk & 0x400: 
    125         meta = True 
    126     return (control, meta, shift, vk & 0xff) 
     110        k.meta = True 
     111    k.char=chr(vk & 0xff) 
     112    return k 
    127113 
    128 def keyname_to_keyinfo(keyname): 
    129     control = False 
    130     meta = False 
    131     shift = False 
    132  
    133     while 1: 
    134         lkeyname = keyname.lower() 
    135         if lkeyname.startswith('control-'): 
    136             control = True 
    137             keyname = keyname[8:] 
    138         elif lkeyname.startswith('ctrl-'): 
    139             control = True 
    140             keyname = keyname[5:] 
    141         elif lkeyname.startswith('meta-'): 
    142             meta = True 
    143             keyname = keyname[5:] 
    144         elif lkeyname.startswith('alt-'): 
    145             meta = True 
    146             keyname = keyname[4:] 
    147         elif lkeyname.startswith('shift-'): 
    148             shift = True 
    149             keyname = keyname[6:] 
    150         else: 
    151             if len(keyname) > 1: 
    152                 return (control, meta, shift, sym2code_map.get(keyname.lower()," ")) 
    153             else: 
    154                 return char_to_keyinfo(keyname, control, meta, shift) 
    155  
    156 def keyseq_to_keyinfo(keyseq): 
    157     res = [] 
    158     control = False 
    159     meta = False 
    160     shift = False 
    161  
    162     while 1: 
    163         if keyseq.startswith('\\C-'): 
    164             control = True 
    165             keyseq = keyseq[3:] 
    166         elif keyseq.startswith('\\M-'): 
    167             meta = True 
    168             keyseq = keyseq[3:] 
    169         elif keyseq.startswith('\\e'): 
    170             res.append(char_to_keyinfo('\033', control, meta, shift)) 
    171             control = meta = shift = False 
    172             keyseq = keyseq[2:] 
    173         elif len(keyseq) >= 1: 
    174             res.append(char_to_keyinfo(keyseq[0], control, meta, shift)) 
    175             control = meta = shift = False 
    176             keyseq = keyseq[1:] 
    177         else: 
    178             return res[0] 
    179  
    180 def make_keyinfo(keycode, state): 
     114def make_KeyPress(char,state,keycode): 
    181115    control = (state & (4+8)) != 0 
    182116    meta = (state & (1+2)) != 0 
    183117    shift = (state & 0x10) != 0 
    184     return (control, meta, shift, keycode) 
     118    if control: 
     119       char = chr(VkKeyScan(ord(char)) & 0xff) 
     120    try: 
     121        keyname=code2sym_map[keycode] 
     122    except KeyError: 
     123        keyname="" 
     124    return KeyPress(char,shift,control,meta,keyname) 
     125 
     126if __name__=="__main__": 
     127    import startup 
     128     

  • pyreadline/branches/refactor/pyreadline/modes/basemode.py

    r1267 r1419  
    1010import pyreadline.logger as logger 
    1111from   pyreadline.logger import log 
    12 from   pyreadline.keysyms import key_text_to_keyinfo 
     12from   pyreadline.keysyms.common import make_KeyPress_from_keydescr 
    1313import pyreadline.lineeditor.lineobj as lineobj 
    1414import pyreadline.lineeditor.history as history 
    …… 
    7676    def _bind_key(self, key, func): 
    7777        '''setup the mapping from key to call the function.''' 
    78         keyinfo = key_text_to_keyinfo(key) 
    79 #        print key,keyinfo,func.__name__ 
     78        keyinfo = make_KeyPress_from_keydescr(key.lower()).tuple() 
    8079        self.key_dispatch[keyinfo] = func 
    8180 
    8281    def _bind_exit_key(self, key): 
    8382        '''setup the mapping from key to call the function.''' 
    84         keyinfo = key_text_to_keyinfo(key) 
     83        keyinfo = make_KeyPress_from_keydescr(key.lower()).tuple() 
    8584        self.exit_dispatch[keyinfo] = None 
    8685 

  • pyreadline/branches/refactor/pyreadline/modes/emacs.py

    r1385 r1419  
    1010import pyreadline.logger as logger 
    1111from   pyreadline.logger import log 
    12 from   pyreadline.keysyms import key_text_to_keyinfo 
    1312import pyreadline.lineeditor.lineobj as lineobj 
    1413import pyreadline.lineeditor.history as history 
    1514import basemode 
    16  
    1715 
    1816 
    …… 
    4240 
    4341            #Process exit keys. Only exit on empty line 
    44             if event.keyinfo in self.exit_dispatch: 
     42            if event.keyinfo.tuple() in self.exit_dispatch: 
    4543                if lineobj.EndOfLine(self.l_buffer) == 0: 
    4644                    raise EOFError 
    47  
    48             dispatch_func = self.key_dispatch.get(event.keyinfo,self.self_insert) 
    49             log("readline from keyboard:%s"%(event.keyinfo,)) 
     45             
     46            dispatch_func = self.key_dispatch.get(event.keyinfo.tuple(),self.self_insert) 
     47            log("readline from keyboard:%s"%(event.keyinfo.tuple(),)) 
    5048            r = None 
    5149            if dispatch_func: 
    …… 
    482480 
    483481    #Create key bindings: 
    484  
    485     def _bind_key(self, key, func): 
    486         '''setup the mapping from key to call the function.''' 
    487 #        print key,func 
    488         keyinfo = key_text_to_keyinfo(key) 
    489 #        print key,keyinfo,func.__name__ 
    490         self.key_dispatch[keyinfo] = func 
    491  
    492     def _bind_exit_key(self, key): 
    493         '''setup the mapping from key to call the function.''' 
    494         keyinfo = key_text_to_keyinfo(key) 
    495         self.exit_dispatch[keyinfo] = None 
    496482 
    497483    def init_editing_mode(self, e): # (C-e) 

  • pyreadline/branches/refactor/pyreadline/modes/notemacs.py

    r1219 r1419  
    1010import pyreadline.logger as logger 
    1111from   pyreadline.logger import log 
    12 from   pyreadline.keysyms import key_text_to_keyinfo 
    1312import pyreadline.lineeditor.lineobj as lineobj 
    1413import pyreadline.lineeditor.history as history 
    …… 
    565564    #Create key bindings: 
    566565 
    567     def _bind_key(self, key, func): 
    568         '''setup the mapping from key to call the function.''' 
    569         keyinfo = key_text_to_keyinfo(key) 
    570 #        print key,keyinfo,func.__name__ 
    571         self.key_dispatch[keyinfo] = func 
    572  
    573     def _bind_exit_key(self, key): 
    574         '''setup the mapping from key to call the function.''' 
    575         keyinfo = key_text_to_keyinfo(key) 
    576         self.exit_dispatch[keyinfo] = None 
    577  
    578566    def init_editing_mode(self, e): # (C-e) 
    579567        '''When in vi command mode, this causes a switch to emacs editing 

  • pyreadline/branches/refactor/pyreadline/modes/vi.py

    r1237 r1419  
    1111import pyreadline.logger as logger 
    1212from   pyreadline.logger import log 
    13 from   pyreadline.keysyms import key_text_to_keyinfo 
    1413import pyreadline.lineeditor.lineobj as lineobj 
    1514import pyreadline.lineeditor.history as history 
    …… 
    114113        # make ' ' to ~ self insert 
    115114        for c in range(ord(' '), 127): 
    116             self._bind_key('"%s"' % chr(c), self.vi_key) 
     115            self._bind_key('%s' % chr(c), self.vi_key) 
    117116        self._bind_key('BackSpace', self.vi_backspace) 
    118117        self._bind_key('Escape', self.vi_escape) 

  • pyreadline/branches/refactor/pyreadline/rlmain.py

    r1267 r1419  
    1313import sys 
    1414from glob import glob 
    15 import os 
     15import os,pdb 
    1616import re 
    1717import traceback 
    …… 
    2121import clipboard,logger,console 
    2222from   logger import log 
    23 from   keysyms import key_text_to_keyinfo 
     23from   pyreadline.keysyms.common import make_KeyPress_from_keydescr 
    2424 
    2525import pyreadline.lineeditor.lineobj as lineobj 
    …… 
    252252        out.append("%-20s: %s"%("mark_directories",self.mark_directories)) 
    253253        out.append("------------- key bindings ------------") 
    254         out.append("%7s %7s %7s %7s %7s %7s"%("Control","Meta","Shift","Keycode","Character","Function")) 
    255         bindings=[(k[0],k[1],k[2],k[3],repr(chr(k[3])),v.__name__)for k,v in self.key_dispatch.iteritems()] 
     254        tablepat="%-7s %-7s %-7s %-15s %-15s " 
     255        out.append(tablepat%("Control","Meta","Shift","Keycode/char","Function")) 
     256        bindings=[(k[0],k[1],k[2],k[3],v.__name__)for k,v in self.mode.key_dispatch.iteritems()] 
     257        #print self.mode.key_dispatch 
     258        #bindings=[str(v) for k,v in self.mode.key_dispatch.iteritems()] 
    256259        bindings.sort() 
    257260        for key in bindings: 
    258             out.append("%7s %7s %7s %7d %7s %7s"%(key)) 
     261            pass 
     262         #   out.append(str(key)) 
     263            out.append(tablepat%(key)) 
    259264        return out 
    260265     
    …… 
    332337            self.mode=modes[name] 
    333338        def bind_key(key,name): 
     339         #   print "bind",key,name 
    334340            if hasattr(modes[mode],name): 
    335                 #print key,name 
     341         #       print "can bind",key,name 
    336342                modes[mode]._bind_key(key,getattr(modes[mode],name)) 
    337343        def un_bind_key(key): 
    338             keyinfo = key_text_to_keyinfo(key) 
     344            keyinfo = make_KeyPress_from_keydescr(key).tuple() 
    339345            if keyinfo in modes[mode].key_dispatch: 
    340346                del modes[mode].key_dispatch[keyinfo] 
    …… 
    343349            modes[mode]._bind_exit_key(key) 
    344350        def un_bind_exit_key(key): 
    345             keyinfo = key_text_to_keyinfo(key) 
     351            keyinfo = make_KeyPress_from_keydescr(key).tuple() 
    346352            if keyinfo in modes[mode].exit_dispatch: 
    347353                del modes[mode].exit_dispatch[keyinfo] 
    …… 
    404410rl = Readline() 
    405411 
     412 
    406413def GetOutputFile(): 
    407414    '''Return the console object used by readline so that it can be used for printing in color.'''