How to create two or three key strokes bindkeys

I had originally planned to describe an outline of a way to do this - but realised that as I started writing the outline, I wasn't that far off having the code itself. So I put together the code below which is a way to implement what I've called "sequence" bindkeys.

Rather than having to code each specific combination (as in the code in the original post) you register a SKILL action against particular sequences. 

Anyway, the comments at the top of the code should explain things clearly enough.

/* abSeqBindKey.ils

Author     A.D.Beckett
Group      Custom IC (UK), Cadence Design Systems Ltd.
Language   SKILL++ (keep the .ils suffix on this file)
Date       Oct 22, 2009 
Modified   
By         

A package to support sequence bindkeys. This means you can define multi-key
bindkeys. So for example, you can define a bindkey "chop" - you type the four
characters c, h, o, and then p - and this then triggers the bindkey.
The sequence is displayed as a banner label so you can see the current 
sequence. Escape is normally used to reset the sequence.

Note this is really a proof-of-concept - it is not fully formed, and may
need some enhancement.

; Initialize the a-z, A-Z, and 0-9 bindkeys to be entry keys
; and escape to be a reset key for Layout application
abSeqBindKey->initBindKeys("Layout")

; give warning if any key sequence defined which obscures another
; for example, "ed" obscures "edit"
abSeqBindKey->option(?checkObscured t)

; Define some key sequences
abSeqBindKey->set("Layout" "fit" "hiZoomAbsoluteScale(hiGetCurrentWindow() 0.9)")
abSeqBindKey->set("Layout" 
  '(
    ("copy" "leHiCopy()")
    ("chop" "leHiChop()")
    ("del"  "leHiDelete()")
    ("undo" "hiUndo()")
   )
)

; Retrieve bindkeys:
abSeqBindKey->get("Layout") => returns all the keys
abSeqBindKey->get("Layout" "chop") => "leHiChop()"

; If you want to define your own bindkeys (rather than using initBindKeys)
; then you'll need to use these:
abSeqBindKey->enter("X") ; enters an X in the sequence
abSeqBindKey->reset()    ; resets the sequence

Limitations:

Doesn't have the concept of "Enter Function" bindkeys which are
different during enter functions. Could do, but needs some thought
as to a sensible use model.

***************************************************

SCCS Info: @(#) abSeqBindKey.ils 10/22/09.13:44:45 1.1

*/

importSkillVar(abSeqBindKey)
abSeqBindKey=let(
    ((bindkeys makeTable('bindkeys nil)) obscuredCheck)

    /*****************************************************************
    *                                                                *
    *                     initBindKeys(appType)                      *
    *                                                                *
    * EXPORTED function to initialize the bindkeys a-z, A-Z and 0-9, *
    *  as well as Escape, to work with the sequence bindkey system.  *
    *                                                                *
    *****************************************************************/
    defun(initBindKeys (appType)
        let((appRoot)
            appRoot=hiGetBindKeyInheritRoot(appType)
            when(appRoot
                ;--------------------------------------------------------
                ; Define bindkeys for a-z, A-Z and 0-9
                ;--------------------------------------------------------
                for(ascii charToInt('a) charToInt('z)
                    hiSetBindKey(appRoot
                        strcat("<Key>" intToChar(ascii))
                        sprintf(nil "abSeqBindKey->enter(\"%s\")" 
                            intToChar(ascii))
                    )
                    hiSetBindKey(appRoot
                        strcat("Shift<Key>" intToChar(ascii))
                        sprintf(nil "abSeqBindKey->enter(\"%s\")" 
                            upperCase(intToChar(ascii)))
                    )
                ) ; for
                for(ascii charToInt('\0) charToInt('\9)
                    hiSetBindKey(appRoot
                        strcat("<Key>" intToChar(ascii))
                        sprintf(nil "abSeqBindKey->enter(\"%s\")" 
                            intToChar(ascii))
                    )
                ) ; for
                hiSetBindKey(appRoot "<Key>Escape" "abSeqBindKey->reset()")
            ) ; when appRoot
        ) ; let
    ) ; defun initBindKeys

    /************************************************************************
    *                                                                       *
    *                              enter(char)                              *
    *                                                                       *
    *   EXPORTED Function to enter a character in the sequence. If there    *
    *     is a sequence bindkey registered for that sequence, reset and     *
    *       then execute the bindkey definition - otherwise continue        *
    * collecting the characters in the sequence (and display in the banner) *
    *                                                                       *
    ************************************************************************/
    defun(enter (char)
        let((win appType appRoot bindkeyTab defn sequence)
            win=hiGetCurrentWindow()
            when(win
                sequence=strcat(win~>abSequence || "" char)
                win~>abSequence=sequence
            )
            appType=win && hiGetAppType(win)
            when(appType
                appRoot=hiGetBindKeyInheritRoot(appType)
            )
            when(appRoot
                ;--------------------------------------------------------
                ; Look up the bindkey definition. If found, then
                ; reset the sequence and evaluate it, otherwise just
                ; append the current sequence.
                ;--------------------------------------------------------
                bindkeyTab=bindkeys[appRoot]
                defn=bindkeyTab && bindkeyTab[sequence]
                if(stringp(defn) then
                    reset()
                    errsetstring(defn t)
                else
                    hiChangeBannerLabel(
                        hiGetCurrentWindow()
                        strcat("Seq: " sequence)
                        0
                    )
                ) ; if bindkey found
            ) ; when appRoot
        ) ; let
    ) ; defun enter

    /***************************************************************
    *                                                              *
    *                           reset()                            *
    *                                                              *
    *       EXPORTED function to reset the current sequence        *
    *                                                              *
    ***************************************************************/
    defun(reset ()
        hiGetCurrentWindow()~>abSequence=""
        hiChangeBannerLabel(
            hiGetCurrentWindow()
            "Seq: "
            0
        )
    ) ; defun reset

    /***************************************************************
    *                                                              *
    *                    check(bindkeyTab key)                     *
    *                                                              *
    *  INTERNAL function to check that a new key sequence is not   *
    *    obscured by another, or does not obscure another. Only    *
    *      checked if option(?checkObscured t) has been used.      *
    *                                                              *
    ***************************************************************/
    defun(check (bindkeyTab key)
        let((len subKeyName)
            when(obscuredCheck && stringp(bindkeyTab[key])
                len=strlen(key)
                ;--------------------------------------------------------
                ; Look for any existing key sequences which the new key is
                ; the beginning part of
                ;--------------------------------------------------------
                foreach(keyName bindkeyTab
                    when(key!=keyName && zerop(strncmp(key keyName len)) &&
                        stringp(bindkeyTab[keyName])
                        warn("Definition for sequence %s will obscure sequence %s\n"
                            key keyName)
                    ) ; when
                ) ; foreach
                ;--------------------------------------------------------
                ; Look for any key sequences which are shorter than the new key
                ;--------------------------------------------------------
                for(sub 1 sub1(len)
                    subKeyName=substring(key 1 sub)
                    when(stringp(bindkeyTab[subKeyName])
                        warn("Definition for sequence %s will obscure sequence %s\n"
                            subKeyName key)
                    ) ; when
                ) ; for
            )
        ) ;let
    ) ; defun

    /***************************************************************
    *                                                              *
    *                   set(appType key [defn])                    *
    *                                                              *
    *  EXPORTED function to set one or more sequence bindkeys for  *
    *                        an application                        *
    *                                                              *
    ***************************************************************/
    defun(set (appType key @optional defn "tg")
        let((appRoot bindkeyTab)
            appRoot=hiGetBindKeyInheritRoot(appType)
            when(appRoot
                bindkeyTab=bindkeys[appRoot]
                unless(bindkeyTab
                    bindkeyTab=makeTable('appBindkeys nil)
                    bindkeys[appRoot]=bindkeyTab
                )
                ;--------------------------------------------------------
                ; Handle list of definitions, and individual definitions
                ;--------------------------------------------------------
                if(listp(key) then
                    foreach(keyDefn key
                        if(listp(keyDefn) && length(keyDefn==2) then
                            bindkeyTab[car(keyDefn)]=cadr(keyDefn)
                            check(bindkeyTab car(keyDefn))
                        else
                            warn("Key definition %L is invalid\n" keyDefn)
                        )
                    )
                else
                    bindkeyTab[key]=defn
                    check(bindkeyTab key)
                )
                t
            ) ; when appRoot
        ) ; let
    ) ; defun set

    /*******************************************************************
    *                                                                  *
    *                        get(appType [key])                        *
    *                                                                  *
    * EXPORTED function to get one or all sequence bindkey definitions *
    *                                                                  *
    *******************************************************************/
    defun(get (appType @optional key "tg")
        let((appRoot bindkeyTab)
            appRoot=hiGetBindKeyInheritRoot(appType)
            when(appType 
                bindkeyTab=bindkeys[appRoot]
                ;--------------------------------------------------------
                ; If the key argument provided, just return the definition
                ; otherwise return an assoc list of the whole lot
                ;--------------------------------------------------------
                if(key then
                    bindkeyTab && bindkeyTab[key]
                else
                    tableToList(bindkeyTab)
                )
            ) ; when appType
        ) ; let
    ) ; defun get

    /***************************************************************
    *                                                              *
    *                  option(@key checkObscured)                  *
    *                                                              *
    *       EXPORTED function to set any options. Currently        *
    *                     just ?checkObscured.                     *
    *                                                              *
    ***************************************************************/
    defun(option (@key checkObscured)
        obscuredCheck=checkObscured
    )

    ;--------------------------------------------------------------------
    ; DPL containing all the package functions available from outside
    ;--------------------------------------------------------------------
    `(nil
        initBindKeys ,initBindKeys
        enter ,enter
        reset ,reset
        set ,set
        get ,get
        option ,option
    )
) ; let

Regards,

Andrew.

Hi Andrew,

Thanks for the code. It works great !

But after I initialise the code, the default bindkeys of virtuoso like f(fit screen) are not working. Seems like I have to de-initialise the code. How do I do it

That's inevitable. The code works by redefining all the letter and number keys so that it can detect what keys you've pressed. If it left the original bind keys alone (e.g. the "f" key), then you wouldn't be able to have "f" in any key sequence!

The examples in the comments show "fit" being defined for this. You could of course adapt that and use "f" instead, but then you wouldn't be able to have any other sequence which begins with 'f". So it's a compromise:

abSeqBindKey->set("Layout" "f" "hiZoomAbsoluteScale(hiGetCurrentWindow() 0.9)")

Regards,

Andrew.

Understood ! So now to get it back to whatever it was before initialising the code, I have to re invoke virtuoso. Right ?  or Is there any other alternative other than re-invoking ?

You can just re-load the standard bind keys file. Either:

load(ddGetStartup("dfII/bindkeys/Layout.il"))

or:

load(prependInstallPath("samples/local/leBindKeys.il"))

That's assuming you are using the "out of the box" bindkey definitions. The top function (with ddGetStartup) would work if you've put a dfII/bindkeys/Layout.il further up your "Cadence Search File" path, but if you've loaded some other custom bind keys from  your .cdsinit you'd need to locate that and re-load it.

Andrew.

You can just re-load the standard bind keys file. Either:

load(ddGetStartup("dfII/bindkeys/Layout.il"))

or:

load(prependInstallPath("samples/local/leBindKeys.il"))

That's assuming you are using the "out of the box" bindkey definitions. The top function (with ddGetStartup) would work if you've put a dfII/bindkeys/Layout.il further up your "Cadence Search File" path, but if you've loaded some other custom bind keys from  your .cdsinit you'd need to locate that and re-load it.

Andrew.

Ok Andrew. Thanks again