### Run SKILL Installation Script

Source: https://context7.com/ananthchellappa/skill/llms.txt

Execute the installation script to automate setup, including backing up existing configuration files and copying new ones.

```bash
#!/bin/bash -eu
# Run install.sh from the SKILL directory

# Navigate to the repository directory
cd ~/SKILL

# Execute the installation script
./install.sh

# The script will:
# 1. Backup existing .cdsenv and .cdsinit files
# 2. Copy new configuration files from dotfiles/
# 3. Replace USERNAME placeholder with your actual username
# 4. Create a backup of any existing SKILL directory

```

--------------------------------

### Initialize SKILL Environment and Load Utilities (.cdsinit)

Source: https://context7.com/ananthchellappa/skill/llms.txt

Initialize fonts, load utilities, and set up the SKILL environment at Cadence tool startup. This includes configuring scrollwheel zoom/pan and loading custom bindkeys.

```skill
; Set up fonts for various UI elements
hiSetFont("text" ?name "Courier 10 Pitch" ?size 15 ?bold nil ?italic nil)
hiSetFont("label" ?name "Sans Serif" ?size 15 ?bold nil ?italic nil)
hiSetFont("ciw" ?name "Courier 10 Pitch" ?size 16 ?bold nil ?italic nil)

; Enable scrollwheel zoom and pan for all applications
foreach(application '("Schematics" "Show File" "Symbol" "Graphics Browser" "Layout")
    hiSetBindKey( application "Ctrl<Btn4Down>" "hiZoomInAtMouse()")
    hiSetBindKey( application "Ctrl<Btn5Down>" "hiZoomOutAtMouse()")
    hiSetBindKey( application "Shift<Btn4Down>" "geScroll(nil \"w\" nil)")
    hiSetBindKey( application "Shift<Btn5Down>" "geScroll(nil \"e\" nil)")
    hiSetBindKey( application "<Btn4Down>" "geScroll(nil \"n\" nil)")
    hiSetBindKey( application "<Btn5Down>" "geScroll(nil \"s\" nil)")
)

; Initialize ViVa and load all custom bindkeys
callInitProc("viva")
load_all_settings = t
loadi("/home/USERNAME/SKILL/bindkeys.il")

```

--------------------------------

### Load SKILL Bindkeys Utility

Source: https://github.com/ananthchellappa/skill/blob/main/README.md

Loads the bindkeys.il file, which contains various SKILL utilities accessed through keyboard shortcuts. Ensure this line is present in your .cdsinit file to activate the shortcuts.

```SKILL
load "bindkeys.il"
```

--------------------------------

### Load LSW Configuration from Files

Source: https://context7.com/ananthchellappa/skill/llms.txt

Procedures to load a previously saved Layer Selection Window (LSW) configuration from specified files. These functions open the load form and then load the LSW info.

```skill
; Load LSW configuration from files
procedure(loadFile1()
    pteOpenForm("Load LSW Info")
    pteLoadLSWInfo("./ac_lsw_file1")
)

procedure(loadFile2()
    pteOpenForm("Load LSW Info")
    pteLoadLSWInfo("./ac_lsw_file2")
)

procedure(loadFile3()
    pteOpenForm("Load LSW Info")
    pteLoadLSWInfo("./ac_lsw_file3")
)
```

--------------------------------

### Search for Bindkeys in bindkeys.il

Source: https://github.com/ananthchellappa/skill/blob/main/README.md

A command-line utility to search for specific bindkeys within the bindkeys.il file. Use this to quickly find the key combination for a desired action.

```bash
alias sbk="search.pl -f /path/to/bindkey.il"
```

```bash
sbk pin selection
```

--------------------------------

### Configure Cadence Environment (.cdsenv)

Source: https://context7.com/ananthchellappa/skill/llms.txt

Set critical environment settings in .cdsenv to disable menu shortcut restrictions and enable custom key bindings. Ensure these settings are appropriate for your workflow.

```skill
; Disable menu access shortcuts (CRITICAL for custom bindkeys)
ui enableMenuShortcuts boolean nil

; Enable schematic object and instance pin selection
schematic schematicSelectFilter string "allSchObj instancePins"

; Keep IC5-style 2x2 major grid points
graphic dotStyleMajorGrid boolean t
layout dotStyleMajorGrid boolean t

; ViVa waveform viewer settings
viva.rectGraph stripChartOn string "1"
viva.trace lineThickness string "medium"
viva.rectGraph legendPosition string "above"

; Enable net tracer in Layout
layout netTracerOn boolean t

; Synchronize schematic selection with Hierarchy Editor
schematic broadcast boolean t

```

--------------------------------

### Save LSW Configuration to Files

Source: https://context7.com/ananthchellappa/skill/llms.txt

Procedures to save the current Layer Selection Window (LSW) configuration to specified files. These functions open the save form and then save the LSW info.

```skill
; Save LSW configuration to files
procedure(saveFile1()
    pteOpenForm("Save LSW Info")
    pteSaveLSWInfo("./ac_lsw_file1")
)

procedure(saveFile2()
    pteOpenForm("Save LSW Info")
    pteSaveLSWInfo("./ac_lsw_file2")
)

procedure(saveFile3()
    pteOpenForm("Save LSW Info")
    pteSaveLSWInfo("./ac_lsw_file3")
)
```

--------------------------------

### Select Similar Instances in SKILL

Source: https://context7.com/ananthchellappa/skill/llms.txt

Selects all instances in the current cellview that match the library and cell of the selected instance. It uses the selected instance or the Library Manager selection if none is explicitly selected.

```skill
; selSimilar() - Select all instances of same type
; Uses selected instance, or Library Manager selection if none selected

procedure( selSimilar( )
    let( (cv inst sought id lib cell)
        cv = geGetEditCellView(getCurrentWindow())
        ; Get reference from selection or Library Manager
        if( 0 < length( geGetSelSet() )
        then
            lib = car(geGetSelSet())~>libName
            cell = car(geGetSelSet())~>cellName
        else
            id = ddsGetLibManLCV()
            lib = car( id )
            cell = cadr( id )
        )
        ; Select all matching instances
        foreach( inst cv~>instances
            if( and(inst~>libName == lib,
                    if( "" != cell then inst~>cellName == cell else t ) )
            then
                geSelectFig( inst )
            )
        )
    )
)

; Keyboard bindings:
; Ctrl-Alt-H (Schematics) - Select all instances of same type
; Ctrl-Alt-H (Layout)     - Select all instances of same type

```

--------------------------------

### MYdescend: Hierarchical Navigation with History

Source: https://context7.com/ananthchellappa/skill/llms.txt

Use MYdescend for intelligent descent into schematic hierarchy. Set w_query to 1 for form-based view selection or 0 for quick descent. Tracks descent for navigation history.

```skill
; MYdescend(w_query) - Descend into hierarchy
; w_query = 1: Use form to select view (bound to 'e' key)
; w_query = 0: Quick descend without form (bound to Ctrl-X)

procedure( MYdescend( w_query )
    let( (w current dont_update iname icell instStuff )
        dont_update = nil
        w = hiGetCurrentWindow()
        current = w~>cellView~>cellName
        if( 1 == w_query
        then
            ; Form-based descent with view selection
            if( 0 == length( geGetSelSet() )
                then dont_update = t
                else
                    iname = car( geGetSelSet() )~>name
                    icell = car( geGetSelSet() )~>cellName
            )
            CCSQueryUserSchHiDescend()
            ; Track descent chain for navigation history
            if( ( w~>cellView~>cellName == icell && !dont_update )
            then
                if( nil == w~>descend_chain
                then w~>descend_chain = list( iname )
                else w~>descend_chain = cons( iname w~>descend_chain )
                )
            )
        else
            ; Quick descend - reuse last instance or selected instance
            if( 0 == length( geGetSelSet() )
            then
                if( w~>most_recent && w~>most_recent != "none" )
                then
                    ; Descend into previously visited instance
                    instStuff = dbFindMemInstByName((hiGetCurrentWindow()~>cellView) w~>most_recent)
                    geSelectFig( car(instStuff) )
                    CCSNoQueryUserSchHiDescend(-1)
                )
            else
                ; Descend into selected instance
                iname = car( geGetSelSet() )~>name
                CCSNoQueryUserSchHiDescend(-1)
            )
        )
    )
)

; Keyboard bindings in schematic editor:
; 'e'      - Descend with view selection form
; Ctrl-X   - Quick descend into selected/last instance
; Ctrl-E   - Return up one level (MYReturn)

```

--------------------------------

### Annotate DC Operating Points and Node Voltages

Source: https://context7.com/ananthchellappa/skill/llms.txt

Sets keyboard bindings for annotating DC operating points and node voltages in the Schematics editor. It uses sevPrintResults and sevAnnotateResults functions.

```skill
; DC Operating Point annotation
hiSetBindKey("Schematics" "<Key>1"
    "sevPrintResults(sevSession(hiGetCurrentWindow()) 'dcOpPoints)")
hiSetBindKey("Schematics" "<Key>6"
    "sevAnnotateResults(sevSession(hiGetCurrentWindow()) 'dcOpPoints)")
hiSetBindKey("Schematics" "Alt<Key>6"
    "sevAnnotateResults(sevSession(hiGetCurrentWindow()) 'dcNodeVoltages)")
```

--------------------------------

### Return Up Hierarchy with Instance Selection

Source: https://context7.com/ananthchellappa/skill/llms.txt

Navigates up one level in the instance hierarchy while keeping the exited instance selected. It handles the case where the user is already at the top level and avoids re-selecting an instance if a save dialog appears.

```skill
; MYReturn() - Return up hierarchy with instance selection

procedure( MYReturn() 
    let( (w the_inst ) 
        w = hiGetCurrentWindow()
        if( (geGetWindowCellView() == geGetTopLevelCellView() )
        then
            hiGetAttention()
            println("Already at Top Level")
        else
            ; Remember the instance we're leaving
            the_inst = car( reverse( parseString( geGetInstHier( hiGetCurrentWindow() ) "/" ) ) )
            schHiReturn()
            ; Select the instance we just exited (unless save dialog appeared)
            unless( rexMatchp( "modify_save" car( getPrompts() ) )
                geSelectFig( car( dbFindMemInstByName((hiGetCurrentWindow()~>cellView) the_inst ) ) )
            )
        )
    )
)

; Keyboard binding:
; Ctrl-E - Return up one hierarchy level

```

--------------------------------

### Select Signals for Plotting

Source: https://context7.com/ananthchellappa/skill/llms.txt

Sets keyboard bindings to initiate signal selection mode for plotting in the Schematics editor. It supports selecting voltage and current traces/signals using the _vivaStartSelectSignalMode function.

```skill
; Signal selection for plotting
hiSetBindKey("Schematics" "<Key>4" "_vivaStartSelectSignalMode( \"VT\" )")  ; Voltage traces
hiSetBindKey("Schematics" "<Key>7" "_vivaStartSelectSignalMode( \"VS\" )")  ; Voltage signals
hiSetBindKey("Schematics" "Alt<Key>4" "_vivaStartSelectSignalMode( \"IT\" )") ; Current traces
hiSetBindKey("Schematics" "Alt<Key>7" "_vivaStartSelectSignalMode( \"IS\" )") ; Current signals

; Keyboard bindings summary:
; 1     - Print DC operating points to CIW
; 6     - Annotate DC operating points on schematic
; Alt-6 - Annotate DC node voltages
; Ctrl-6 - Remove terminal net name annotations
; 0     - Delete all probes and highlights
; 4     - Select voltage traces for plotting
; 7     - Select voltage signals for plotting

```

--------------------------------

### Zoom to Instance from Path in SKILL

Source: https://context7.com/ananthchellappa/skill/llms.txt

Navigates to and zooms in on a specific instance given a hierarchical path string. Useful for locating instances identified in simulator output. It first returns to the top level and then descends through the hierarchy.

```skill
; zoomInst(CLIPDATA) - Navigate to and zoom on instance from path
; CLIPDATA = hierarchical path string like "top/sub1/sub2/inst"

procedure( zoomInst(CLIPDATA)
    let(( text inst instPath instList itrName itrNum l r prsOp )
        ; Return to top level first
        if( (geGetWindowCellView() != geGetTopLevelCellView() )
            schHiReturnToTop()
        )

        ; Parse hierarchical path
        instPath = parseString(CLIPDATA "./\n")
        inst = car(reverse(instPath))          ; Final instance
        instList = reverse(cdr(reverse(instPath))) ; Parent hierarchy

        ; Descend through hierarchy
        hierDescend( instList )

        ; Handle arrayed instances like "a<2>"
        prsOp = parseString(inst "<>")
        if( (length(prsOp) > 1) then
            itrName = strcat(car(prsOp) "<")
            itrNum = atoi( cadr(prsOp) )
            foreach( xx geGetEditCellView()~>instances
                if( rexMatchp(itrName xx~>name) then
                    prsOp = parseString( xx~>name "<:>")
                    if( (3 == length(prsOp) ) then
                        l = atoi( cadr(prsOp) )
                        r = atoi( caddr(prsOp) )
                        if( (l >= itrNum) && (r <= itrNum) then geSelectFig(xx) )
                    )
                )
            )
        else
            geSelectObject( dbFindAnyInstByName(geGetEditCellView() inst) )
        )

        ; Pan and zoom to selected instance
        hiPan( hiGetCurrentWindow() centerBox(car(geGetSelSet())~>bBox))
        hiZoomRelativeScale( hiGetCurrentWindow() 3.0)
    )
)

; Keyboard binding:
; Alt-D - Read clipboard and zoom to instance path

```

--------------------------------

### Enable Menu Shortcuts in Cadence

Source: https://github.com/ananthchellappa/skill/blob/main/README.md

Disables menu-access restrictions on ALT and CTRL keys to allow custom shortcuts. Use this setting to regain control over key combinations.

```SKILL
ui enableMenuShortcuts boolean nil
```

--------------------------------

### MYdescend - Hierarchical Navigation

Source: https://context7.com/ananthchellappa/skill/llms.txt

Provides intelligent descent into schematic hierarchy with history tracking. It supports both form-based selection and quick descent options.

```APIDOC
## MYdescend / MYdescend

### Description
Intelligent descent into schematic hierarchy with history tracking, allowing quick navigation of complex designs.

### Method
`procedure( MYdescend( w_query ) )`

### Parameters
- **w_query** (integer) - Required - `1`: Use form to select view (bound to 'e' key). `0`: Quick descend without form (bound to Ctrl-X).

### Request Example
```skill
MYdescend(1) ; Descend with view selection form
MYdescend(0) ; Quick descend
```

### Response
This procedure modifies the current schematic view and does not return a specific value.

### Notes
- Keyboard bindings in schematic editor:
  - 'e'      - Descend with view selection form
  - Ctrl-X   - Quick descend into selected/last instance
  - Ctrl-E   - Return up one level (MYReturn)
```

--------------------------------

### Snap Objects to Grid in SKILL

Source: https://context7.com/ananthchellappa/skill/llms.txt

Use CCSSnapToGrid to snap selected objects or all objects in the current cell view back to the grid. It adjusts the coordinates of instances, wires, and shapes.

```skill
; CCSSnapToGrid() - Snap all off-grid items to the current grid
; Works on selected objects, or entire cellview if nothing selected

procedure( CCSSnapToGrid() 
    let((cv count Set grid newpoints pointi compFactor)
        cv = geGetEditCellView(getCurrentWindow())
        compFactor = 1/cv~>DBUPerUU

        ; Determine working set
        if(geGetObjectSelectedSet() != nil then
            println("selected")
            Set = foreach(mapcar item geGetObjectSelectedSet() car(item))
        else
            Set = append(cv~>instances cv~>shapes)
            println("nothing selected - operating on entire cellview")
        )

        ; Get appropriate grid spacing
        if(cv~>cellViewType=="schematic" then
            grid = schGetEnv("schSnapSpacing")
        else if(cv~>cellViewType=="schematicSymbol" then
            grid = schGetEnv("symSnapSpacing")
        ))

        count = 0
        foreach( shape Set
            ; Snap instance xy coordinates
            shapeCoords = shape~>xy
            if( shapeCoords then
                if((int(xCoord(shapeCoords)/grid) != xCoord(shapeCoords)/grid )
                    ||(int(yCoord(shapeCoords)/grid) != yCoord(shapeCoords)/grid )
                    then
                    count++
                    shape~>xy = roundCoord(shapeCoords grid compFactor)
                )
            )
            ; Snap wire points
            if(shape~>points then
                newpoints = nil
                for(i 1 shape~>nPoints
                    pointi = nth(i-1 shape~>points)
                    if((int(xCoord(pointi)/grid) != xCoord(pointi)/grid )
                        ||(int(yCoord(pointi)/grid) != yCoord(pointi)/grid )
                        then
                        count++
                        newpoints = cons(roundCoord(pointi grid compFactor) newpoints)
                    else
                        newpoints = cons(pointi newpoints)
                    )
                )
                shape~>points = newpoints
            )
        )
        printf("%d Offgrid items moved\n" count)
    )
)

; Keyboard binding:
; Alt-G - Snap selected objects (or all) to grid

```

--------------------------------

### Clear Annotations and Probes

Source: https://context7.com/ananthchellappa/skill/llms.txt

Sets keyboard bindings to clear annotations and probes in the Schematics editor. It uses killPinAnnotate, geDeleteAllProbe, and geDeleteAllHilightSet functions.

```skill
; Clear annotations and probes
hiSetBindKey("Schematics" "Ctrl<Key>6" "killPinAnnotate()")
hiSetBindKey("Schematics" "<Key>0"
    "{geDeleteAllProbe(getCurrentWindow() t) geDeleteAllHilightSet( geGetWindowCellView() )}")
```

--------------------------------

### Modify Wire Width in Skill

Source: https://context7.com/ananthchellappa/skill/llms.txt

Changes the width of selected wires, preserving attached labels. Handles conversion between 'line' and 'path' types and allows setting width to 0 for narrow lines. Use `defWideWireWidth` for default wide wire settings.

```skill
; CCSchangeWireWidth(?width ?wires) - Change wire width
; width = 0 or nil for narrow lines
; width = number for wide wires (default: defWideWireWidth)
; wires = list of wire objects (default: selected set)

(defun CCSchangeWireWidth (@key (width (schGetEnv "defWideWireWidth"))
                               (wires (geGetSelSet)))
    (let (objType newWires cellView childInfo points)
        (foreach wire wires
            (setq objType (dbGetq wire objType))
            (setq childInfo nil)
            (cond
                ; Convert line to path or vice versa
                ((or (and (equal objType "line") (numberp width) (null (zerop width)))
                     (and (equal objType "path") (or (null width) (zerop width))))
                    ; Capture wire label information before deletion
                    (setq cellView (dbGetq wire cellView))
                    (setq points (dbGetq wire points))
                    (setq childInfo
                        (foreach mapcan child (dbGetq wire children)
                            (when (equal (dbGetq child objType) "label")
                                (list (list (dbGetq child xy)
                                           (dbGetq child theLabel)
                                           (dbGetq child justify)
                                           (dbGetq child orient)
                                           (dbGetq child font)
                                           (dbGetq child height))))))
                    (dbDeleteObject wire)
                    ; Create new wire with specified width
                    (setq newWires (schCreateWire cellView "draw" "full" points
                                                  0 0 (if width width 0)))
                )
                ; Just modify path width
                ((and (equal objType "path") (numberp width) (null (zerop width)))
                    (dbSetq wire width width)
                )
            )
            ; Recreate wire labels
            (foreach child childInfo
                (apply 'schCreateWireLabel `(,cellView ,(car newWires) ,@child nil)))
        )
        ; Reselect modified wires
        (foreach(mapcar x newWires geSelectFig(x)))
    )
)

; Example usage:
; CCSchangeWireWidth(?width 0)          ; Make wires narrow
; CCSchangeWireWidth(?width 0.03)       ; Make wires 0.03 units wide
; CCSchangeWireWidth()                  ; Use default wide wire width

```

--------------------------------

### Toggle All Layers or Objects Visibility

Source: https://context7.com/ananthchellappa/skill/llms.txt

Sets keyboard bindings to toggle the visibility of all layers or all objects in the Layout editor. It uses the pteToggleAllVisible function.

```skill
; Toggle all layers/objects
hiSetBindKey("Layout" "Alt <Key>0"
    "pteToggleAllVisible( \"Layers\" hiGetCurrentWindow() )")
hiSetBindKey("Layout" "Alt <Key>9"
    "pteToggleAllVisible( \"Objects\" hiGetCurrentWindow() )")

; Keyboard bindings summary:
; Alt-1 through Alt-4 - Toggle MET1-MET4 visibility
; Alt-P - Toggle POLY visibility
; Alt-T - Toggle TEXT visibility
; Alt-V - Toggle Vias visibility
; Alt-0 - Toggle all layers
; Alt-9 - Toggle all objects

```

--------------------------------

### Scale Pin Label Height in Skill

Source: https://context7.com/ananthchellappa/skill/llms.txt

Scales pin label heights uniformly based on the maximum height found among all pin labels in the current cell view. Requires the cell view to be in write mode; otherwise, it prints a message and exits. Use keyboard shortcuts for quick adjustments.

```skill
; updatePinLabels(factor) - Scale pin label sizes
; factor > 1.0 increases size
; factor < 1.0 decreases size

procedure( updatePinLabels( factor )
    let( (cv max)
        cv = geGetWindowCellView()
        max = 0
        printf("Processing %s\n", cv~>cellName)
        if( !( cv~>mode == "r") then
            ; Find maximum pin label height
            foreach( shape cv~>shapes
                if( (equal("label" shape~>purpose) && equal("pin" car(shape~>lpp) ))
                then
                    if( (shape~>height > max ) max = shape~>height )
                )
            )
            ; Apply scaled height to all pin labels
            foreach( shape cv~>shapes
                if( (equal("label" shape~>purpose) && equal("pin" car(shape~>lpp) ))
                then
                    shape~>height = factor*max
                    schSetTextDisplayBBox(shape nil)
                )
            )
            t
        else
            println("Sorry, exiting due to read-only mode")
            nil
        )
    )
)

; Keyboard bindings:
; Ctrl-Up   - Increase pin label size (factor 1.2)
; Ctrl-Down - Decrease pin label size (factor 0.8)

```

--------------------------------

### Toggle Individual Metal Layer Visibility

Source: https://context7.com/ananthchellappa/skill/llms.txt

Sets keyboard bindings to toggle the visibility of individual metal layers (MET1-MET4) in the Layout editor. It uses the pteSetVisible function, inverting the current visibility state.

```skill
; Toggle visibility of individual metal layers
hiSetBindKey("Layout" "Alt <Key>1"
    "pteSetVisible(\"MET1 drawing\" !pteIsVisible(\"MET1 drawing\" \"Layers\") \"Layers\")")
hiSetBindKey("Layout" "Alt <Key>2"
    "pteSetVisible(\"MET2 drawing\" !pteIsVisible(\"MET2 drawing\" \"Layers\") \"Layers\")")
hiSetBindKey("Layout" "Alt <Key>3"
    "pteSetVisible(\"MET3 drawing\" !pteIsVisible(\"MET3 drawing\" \"Layers\") \"Layers\")")
hiSetBindKey("Layout" "Alt <Key>4"
    "pteSetVisible(\"MET4 drawing\" !pteIsVisible(\"MET4 drawing\" \"Layers\") \"Layers\")")
hiSetBindKey("Layout" "Alt <Key>p"
    "pteSetVisible(\"POLY drawing\" !pteIsVisible(\"POLY drawing\" \"Layers\") \"Layers\")")
hiSetBindKey("Layout" "Alt <Key>t"
    "pteSetVisible(\"TEXT drawing\" !pteIsVisible(\"TEXT drawing\" \"Layers\") \"Layers\")")
hiSetBindKey("Layout" "Alt <Key>v"
    "pteSetVisible(\"Vias\" !pteIsVisible(\"Vias\" \"Objects\") \"Objects\")")
```

--------------------------------

### schIncreasePinSpacing: Adjust Pin Spacing

Source: https://context7.com/ananthchellappa/skill/llms.txt

Use schIncreasePinSpacing to adjust spacing between selected pins. Pins must be selected in order. Automatically detects horizontal or vertical arrangement.

```skill
; schIncreasePinSpacing(space) - Increase or decrease pin spacing
; space = "+" to increase spacing
; space = "-" to decrease spacing
; IMPORTANT: Pins MUST be selected in the proper order (first to last)

procedure(schIncreasePinSpacing( space )
    let( ( direction unitsep obj count snapSpacing newx newy firstx firsty firstxy lastxy add)
        ; Filter selection to only pins
        foreach( obj geGetSelSet() 
            if( ! obj~>pin geDeselectObject( obj ) )
        )

        ; Get first and last pin positions
        firstxy = car( geGetSelSet() )~>xy
        lastxy = car( reverse(geGetSelSet() ) )~>xy
        snapSpacing = envGetVal("schematic" "symSnapSpacing")

        ; Detect horizontal vs vertical orientation
        if( (abs( car(firstxy) - car( lastxy ) ) > abs( cadr(firstxy) - cadr(lastxy) ) )
        then
            direction = "hor"
            unitsep = abs( round( (car(firstxy) - car( lastxy ) ) /
                (snapSpacing * ( length( geGetSelSet() ) - 1 ) ) ) )
        else
            direction = "ver"
            unitsep = abs( round( (cadr(firstxy) - cadr(lastxy) ) /
                (snapSpacing * ( length( geGetSelSet() ) - 1 ) ) ) )
        )

        ; Reposition each pin with adjusted spacing
        count = 0
        foreach( obj geGetSelSet() 
            if(direction == "hor" then
                if("+" == space then newx = firstx + (unitsep + 1)*snapSpacing*add*count)
                if("-" == space then newx = firstx + (unitsep - 1)*snapSpacing*add*count)
                obj~>xy = list( newx firsty )
            )
            count++
        )
    )
)

; Keyboard bindings:
; Ctrl-+  or Ctrl-KP_Add      - Increase pin spacing
; Ctrl--  or Ctrl-KP_Subtract - Decrease pin spacing

```

--------------------------------

### schIncreasePinSpacing - Pin Spacing Adjustment

Source: https://context7.com/ananthchellappa/skill/llms.txt

Adjusts the spacing between selected pins in schematics, automatically detecting orientation and applying spacing changes.

```APIDOC
## schIncreasePinSpacing / schIncreasePinSpacing

### Description
Adjusts the spacing between selected pins in schematics, automatically detecting horizontal or vertical arrangement.

### Method
`procedure( schIncreasePinSpacing( space ) )`

### Parameters
- **space** (string) - Required - `"+"` to increase spacing, `"-"` to decrease spacing.

### Request Example
```skill
schIncreasePinSpacing("+") ; Increase spacing
schIncreasePinSpacing("-") ; Decrease spacing
```

### Response
This procedure modifies the positions of selected pins and does not return a specific value.

### Notes
- IMPORTANT: Pins MUST be selected in the proper order (first to last).
- Keyboard bindings:
  - Ctrl-+  or Ctrl-KP_Add      - Increase pin spacing
  - Ctrl--  or Ctrl-KP_Subtract - Decrease pin spacing
```

--------------------------------

### Modify Wire Thickness and Bus Index in SKILL

Source: https://context7.com/ananthchellappa/skill/llms.txt

The inc_wire_inst function modifies wire thickness or increments bus indices for selected objects. It handles instances, labels, and wires, and operates only on editable cell views.

```skill
; inc_wire_inst(factor) - Change wire width or increment bus indices
; factor > 1.0 increases width/bus index
; factor < 1.0 decreases width/bus index

procedure( inc_wire_inst( factor ) 
    let( (inst wire namelems saved_sel nw bigger pcv np opname newobs npname)
        if( "r" == geGetWindowCellView()~>mode
        then println("No action : read-only cellview")
        else
            if( factor > 1.0 then bigger = 1 else bigger = 0 )
            foreach( obj geGetSelSet() 
                ; Handle instances - modify bus index in name
                if( "inst" == obj~>objType then
                    obj~>name = inc_bus( obj~>name bigger )
                    saved_sel = append( saved_sel list( obj ) )
                )

                ; Handle labels - modify bus index in label text
                if( "label" == obj~>objType
                    obj~>theLabel = inc_bus( obj~>theLabel bigger )
                    saved_sel = append( saved_sel list( obj ) )
                )

                ; Handle wires - change width
                if( ("line" == obj~>objType) || ( "path" == obj~>objType ) then
                    if( "line" == obj~>objType && factor > 1.0 )
                        CCSchangeWireWidth( ?width 0.02 ?wires list(obj) )
                    )
                    if( "path" == obj~>objType
                        nw = obj~>width / 0.0125
                        if( factor > 1.0 then nw = 0.0125 * (nw + 1)
                        else nw = 0.0125 * (nw - 1) )
                        CCSchangeWireWidth( ?width nw ?wires list(obj) )
                    )
                )
            )
            ; Restore selection
            foreach( obj saved_sel geSelectObject(obj) )
        )
    )
)

; Keyboard bindings:
; Alt-ScrollUp   (Alt-Btn4Down) - Increase wire width or bus index
; Alt-ScrollDown (Alt-Btn5Down) - Decrease wire width or bus index

```

--------------------------------

### Toggle Text Case in SKILL

Source: https://context7.com/ananthchellappa/skill/llms.txt

Toggles the case of selected labels or pin names between uppercase and lowercase. This function operates on the current window's cellview and avoids modification in read-only mode.

```skill
; toggleCase() - Toggle case of selected labels/pins

procedure( toggleCase()
    let( (cv)
        cv = geGetWindowCellView()
        printf("Processing %s\n", cv~>cellName)
        if( !( cv~>mode == "r") then
            foreach( obj geGetSelSet() 
                ; Handle regular labels
                if( "label" == obj~>objType then
                    if( rexMatchp( "^[A-Z]" obj~>theLabel )
                    then obj~>theLabel = lowerCase( obj~>theLabel )
                    else obj~>theLabel = upperCase( obj~>theLabel )
                    )
                else
                    ; Handle pin text displays
                    if( "textDisplay" == obj~>objType && obj~>parent~>pin then
                        if( rexMatchp( "^[A-Z]" obj~>parent~>pin~>term~>name)
                        then obj~>parent~>pin~>term~>name = lowerCase( obj~>parent~>pin~>term~>name)
                        else obj~>parent~>pin~>term~>name = upperCase( obj~>parent~>pin~>term~>name)
                        )
                    )
                )
            )
            t
        else
            println("Sorry, exiting due to read-only mode")
            nil
        )
    )
)

; Keyboard binding:
; Ctrl-Alt-C - Toggle case of selected text/pins

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.