Actions

All user accessible commands may be bound to almost any X event. Almost no default binding for commands is done in the binaries, so it is vital for the application that at least a system-wide application resource file exists. This file normally resides in the share/pcb directory and is called Pcb. The bindings to which the manual refers to are the ones as defined by the shipped resource file. Besides binding an action to an X11 event, you can also execute any action command using a ":" command (see User Commands).

Take special care about translations related to the functions keys and the pointer buttons because most of the window managers use them too. Change the file according to your hardware/software environment. You may have to replace all occurances of baseTranslations to translations if you use a X11R4 server.

Passing Object as an argument to an action routine causes the object at the cursor location to be changed, removed or whatever. If more than one object is located at the cross hair position the smallest type is used. If there are two of the same type the newer one is taken. SelectedObjects will handle all selected and visible objects.

AddRats(AllRats|SelectedRats)

Adds rat-lines to the layout using the loaded netlist file (see the :rn, User Commands.). Rat lines are added on the active layer using the current line thickness shown in the status line. Only missing connectivity is added by the AddRats command so if, for example, the layout is complete nothing will be added. Rat lines are drawn on the screen with a stippled pattern to make them easier to identify since they cannot appear in a completed layout. The rat-lines are added in the minimum length straight-line tree pattern (always ending on pins or pads) that satisfies the missing connectivity in the circuit. If a SMD pad is unreachable on the active layer, a warning will be issued about it and the rat-line to that pad will not be generated. If connections exist on the board which are not listed in the netlist while AllRats are being added, warning messages will be issued and the affected pins and pads will be drawn in a special warnColor until the next Notify() event. If the entire layout agrees completely with the net-list a message informs you that the layout is complete and no rat-lines are added (since none are needed). If SelectedRats is passed as the argument, only those missing connections that might connect among the selected pins and pads are drawn. Default:

          None<Key>w:	AddRats(AllRats)
          !Shift<Key>w:	AddRats(SelectedRats)
          None<Key>o:	DeleteRats(AllRats) AddRats(AllRats)
          !Shift<Key>o:	DeleteRats(SelectedRats) AddRats(SelectedRats)
          

ApplyVendor()

Applies an already loaded vendor drill map to the design.

          ApplyVendor()
          

Atomic(Save|Restore|Block|Close)

Controls the undo grouping of sequences of actions. Before the first action in a group, Atomic(Save) should be issued. After each action that might be undoable, Atomic(Restore) should be issued. Atomic(Block) concludes and save the undo grouping if there was anything in the group to undo. Atomic(Close) concludes and save the undo grouping even if nothing was actually done. Thus it might produce an "empty" undo. This can be useful when you want to use undo in a group of actions.

Bell([-100..100])

Rings the bell of your display. If no value is passed the setting of the resource volume will be used.

ChangeClearSize(Object, value[, unit])

ChangeClearSize(SelectedPins|SelectedVias, value[, unit])

The effect of this action depends on if the soldermask display is presently turned on or off. If soldermask is displayed, then the soldermask relief size will be changed. If soldermask display is turned off, then the clearance to polygons will be changed. unit is "mil" or "mm". If not specified the units will default to the internal unit of 0.01 mil.

          !Mod1<Key>k:      ChangeClearSize(Object, +2, mil)
          !Mod1 Shift<Key>k: ChangeClearSize(Object, -2, mil)
          

ChangeDrillSize(Object, value[, unit])

ChangeDrillSize(SelectedPins|SelectedVias, value[, unit])

This action routine changes the drilling hole of pins and vias. If value starts with + or -, then it adds (or subtracts) value from the current hole diameter, otherwise it sets the diameter to the value. unit is "mil" or "mm". If not specified the units will default to the internal unit of 0.01 mil. Default:

          !Mod1<Key>s:       Change2ndSize(Object, +5, mil)
          !Mod1 Shift<Key>s: Change2ndSize(Object, -5, mil)
          

ChangeFlag(Object|SelectElements|SelectedPins|SelectedVias|Selected,thermal|octagon|square,0|1)

Sets/clears the indicated flag. This adds/removes thermals, adds/removes the flag which indicates a pin/pad should be square, or adds/removes the flag which indicates a pin/pad should be octagonal.

          :ChangeFlag(SelectedVias,thermal,1)
          :ChangeFlag(SelectedPads,square,0)
          

ChangeHole(Object|SelectedVias)

This action routine converts a via to and from a hole. A hole is a via that has no copper annulus. The drill size for the via determines the hole diameter.

          !Ctrl<Key>h:	ChangeHole(Object)
          

ChangeName(Object)

ChangeName(Layer|Layout)

Changes the name of the visible object at the cursor location. A text object doesn't have a name therefore the text string itself is changed. The element name currently used for display is always the one changed with this command. See Display(Description|NameOnPCB|Value) for details. Passing Layer changes the current layers name. Default:

          None<Key>n: ChangeName(Object)
          

ChangeOctagon(Object|SelectElements|SelectedPins|SelectedVias|Selected)

Toggles what shape the affected pin(s) or via(s) will be drawn when they are not square. The shape will either be round or octagonal. Default:

          !Ctrl<Key>o: ChangeOctagon(Object)
          

ChangeSize(Object, value[, unit])

ChangeSize(SelectedLines|SelectedPins|SelectedVias, value[, unit])

ChangeSize(SelectedPads|SelectedTexts|SelectedNames, value[, unit])

ChangeSize(SelectedElements, value[, unit])

To change the size of an object you have to bind these action to some X event (or use :ChangeSize(...)). If value begins with a + or - then the value will be added (or subtracted) from the current size, otherwise the size is set equal to value. Range checking is done to insure that none of the maximum/minimums of any size are violated. If Object is passed then a single object at the cursor location is changed. If any of the Selected arguments are passed then all selected and visible objects of that type are changed. If the type being modified is an element, then the thickness of the silkscreen lines defining the element is changed. unit is "mil" or "mm". If not specified the units will default to the internal unit of 0.01 mil. Default:

          None<Key>s:   ChangeSize(Object, +5)
          !Shift<Key>s: ChangeSize(Object, -5)
          

ChangeSquare(Object|SelectedElements|SelectedPins)

Toggles the setting of the square flag. The flag is used to identify a certain pin, normally the first one, of circuits. It is also used to make SMD pads have square ends.

          None<Key>q:   ChangeSquare(Object)
          

ClrFlag(Object|SelectElements|SelectedPins|SelectedVias|Selected,thermal|octagon|square)

Clears the indicated flag. This removes thermals, removes the flag which indicates a pin/pad should be square, or removes the flag which indicates a pin/pad should be octagonal.

          :ClrFlag(SelectedVias,thermal)
          

Command()

Calling Command() pops up an input line at the bottom of the window which allows you to enter commands. Including all action commands! The dialog ends when None<Key>Return to confirm or None<Key>Escape to abort is entered. Default:

          <Key>colon: Command()
          

Connection(Find)

Connection(ResetFoundLinesAndRectangles|ResetPinsViasAndPads|Reset)

The Connection() action is used to mark all connections from one pin, line or via to others. The ResetFoundLinesAndRectangles, ResetFoundPinsAndVias and Reset arguments may be used to reset all marked lines and rectangles, vias and pins or all of them. The search starts with the pin or via at the cursor position. All found objects are drawn with the color defined by the resource connectedColor. See also, Display(Description|NameOnPCB|Value). Default:

          !Shift<Key>c: Connection(Reset)
          None<Key>f:   Connection(Find)
          !Shift<Key>f: Connection(Reset)
          

DeleteRats(AllRats|SelectedRats)

This routine deletes either all rat-lines in the layout, or only the selected and visible ones. Non-rat-lines and other layout objects are unaffected. Default:

          None<Key>e:   DeleteRats(AllRats)
          !Shift<Key>e: DeleteRats(SelectedRats)
          

DisableVendor()

Disables automatic drill size mapping to the loaded vendor drill table.

          DisableVendor()
          

DisperseElements(All|Selected)

Disperses either all elements or only the selected elements in the layout. This action should be used at the start of a design to spread out all footprints before any placement or routing is done.

          DisperseElements(All)
          

Display(Description|NameOnPCB|Value)

Display(Toggle45Degree|CycleClip)

Display(Grid|ToggleGrid)

Display(ToggleRubberBandMode)

Display(Center|ClearAndRedraw|Redraw)

Display(Pinout|PinOrPadName)

This action routines handles some output related settings. It is used to center the display around the cursor location and to redraw the output area optionally after clearing the window. Centering is done with respect to the grid setting. Displaying the grid itself may be switched on and off by Grid but only if the distance between two pixels exceeds 4 pixels. Pcb is able to handle several labels of an element. One of them is a description of the functionality (eg resistor), the second should be a unique identifier (R1) whereas the last one is a value (100k). The Display() action selects which of the names is displayed. It also controls which name will be affected by the ChangeName command. If ToggleGrid is passed, Pcb changes between relative ('rel' in the statusline) and absolute grid (an 'abs' in the statusline). Relative grid means the pointer position when the command is issued is used as the grid origin; while (0,0) is used in the absolute grid case. Passing Pinout displays the pinout of the element at the current cursor location whereas PinOrPadName toggles displaying of the pins or pads name under the cursor. If none of them matches but the cursor is inside of an element, the flags is toggled for all of its pins and pads. For details about rubberbands see also the details about Mode. Default:

          None<Key>c:  Display(Center)
          None<Key>d:  Display(PinOrPadName)
          !Shift<Key>d: Display(Pinout)
          None<Key>r:  Display(ClearAndRedraw)
          None<Key>.:  Display(Toggle45Degree)
          None<Key>/:  Display(CycleClip)
          

DRC()

Initiates design rule checking of the entire layout. Must be repeated until no errors are found.

ExecuteFile(filename)

Executes the PCB actions contained in the specified file. This can be used to automate a complex sequence of operations.

          :ExecuteFile(custom.cmd)
          

The command file contains a list of PCB actions. Blank lines are ignored and lines starting with a # are treated as comment lines. For example

          # This is a comment line
          Display(Grid)
          SetValue(Zoom,2)
          DRC()
          

EditLayerGroups()

Pops up a dialog box to edit the layergroup setting. The function is also available from the Objects menu. There are no defaults.

EnableVendor()

Enables automatic drill size mapping to the loaded vendor drill table.

          EnableVendor()
          

Load(ElementToBuffer|Layout|LayoutToBuffer|Nelist)

This routine pops up a fileselect box to load layout, element data, or netlist. The passed filename for layout data is saved and may be reused. ElementToBuffer and LayoutToBuffer load the data into the current buffer. There are no defaults.

LoadVendor(vendorfile)

Loads the specified vendor resource file.

          LoadVendor(myvendor.res)
          

MarkCrosshair()

This routine marks the current cursor location with an X, and then the cursor display shows both absolute position and position relative to the mark. If a mark is already present, this routine removes it and stops displaying relative cursor coordinates. Defaults:

          !Ctrl<key>m:	MarkCrosshair()
          

Mode(Copy|InsertPoint|Line|Move|None|PasteBuffer|Polygon|Thermal)

Mode(Remove|Rectangle|RubberbandMove|Text|Via)

Mode(Cycle)

Mode(Notify)

Mode(Save|Restore)

Switches to a new mode of operation. The active mode is displayed by a thick line around the matching mode selector button. Most of the functionality of Pcb is implemented by selecting a mode and calling Mode(Notify). The arguments Line, Polygon, Rectangle, Text and Via are used to create the appropriate object whenever Mode(Notify) is called. Some of them, such as Polygon, need more than one call for one object to be created. InsertPoint adds points to existing polygons or lines. Save and Restore are used to temporarily save the mode, switch to another one, call Mode(Notify) and restore the saved one. Have a look at the application resource file for examples. Copy and Move modes are used to change an object's location and, optionally, to create a new one. The first call of Mode(Notify) attaches the object at the pointer location to the cross hair whereas the second one drops it to the layout. The rubberband version of move performs the move while overriding the current rubberband mode. Passing PasteBuffer attaches the contents of the currently selected buffer to the cross hair. Each call to Mode(Notify) pastes this contents to the layout. Mode(Cycle) cycles through the modes available in the mode-button pallet. Mode(None) switches all modes off. Default:

          <Key>Escape:             Mode(None)
          <Key>space:              Mode(Cycle)
          None<Key>BackSpace:      Mode(Save) Mode(Remove) Mode(Notify) Mode(Restore)
          None<Key>Delete:         Mode(Save) Mode(Remove) Mode(Notify) Mode(Restore)
          None<Key>F1:             Mode(Via)
          None<Key>F2:             Mode(Line)
          None<Key>F3:             Mode(PasteBuffer)
          None<Key>F4:             Mode(Rectangle)
          None<Key>F5:             Mode(Text)
          None<Key>F6:             Mode(Polygon)
          None<Key>F7:             Mode(Thermal)
          None<Key>F8:		 Mode(Arc)
          None<Key>Insert:         Mode(InsertPoint)
          None<Key>[:              Mode(Save) Mode(Move) Mode(Notify)
          None<Key>]:              Mode(Notify) Mode(Restore)
          None<Btn1>:          Mode(Notify)
          !Shift Ctrl<Btn1>:   Mode(Save) Mode(Remove) Mode(Notify) Mode(Restore)
          None<Btn2Down>:          Mode(Save) Mode(Move) Mode(Notify)
          None<Btn2Up>:            Mode(Notify) Mode(Restore)
          !Mod1<Btn2Down>:       Mode(Save) Mode(Copy) Mode(Notify)
          !Mod1<Btn2Up>:         Mode(Notify) Mode(Restore)
          Shift BTNMOD<Btn2Down>: Mode(Save) Mode(RubberbandMove) Mode(Notify)
          

MovePointer(delta_x, delta_y)

With this function it is possible to move the cross hair cursor by using the cursor keys. The X server's pointer follows because the necessary events are generated by Pcb. All movements are performed with respect to the currently set grid value. Default:

          None<Key>Up:      MovePointer(0, -1)
          !Shift<Key>Up:    MovePointer(0, -10)
          None<Key>Down:    MovePointer(0, 1)
          !Shift<Key>Down:  MovePointer(0, 10)
          None<Key>Right:   MovePointer(1, 0)
          !Shift<Key>Right: MovePointer(10, 0)
          None<Key>Left:    MovePointer(-1, 0)
          !Shift<Key>Left:  MovePointer(-10, 0)
          

MoveToCurrentLayer(Object|SelectedObjects)

The function moves a single object at the cross hair location or all selected objects to the current layer. Elements are not movable by this function. They have to be deleted and replaced on the other side. If a line segment is moved and the movement would result in a loss of connectivity to another segment then via(s) are automatically added to maintain the connectivity.

          None<Key>m:       MoveToCurrentLayer(Object)
          !Shift<Key>m:     MoveToCurrentLayer(SelectedObjects)
          

New()

Clear the current layout and starts a new one after entering its name. Refer to the resource backup for more information. No defaults.

PasteBuffer(AddSelected|Clear|1..5)

PasteBuffer(Rotate, 1..3)

PasteBuffer(Convert)

This action routine controls and selects the pastebuffer as well as all cut-and-paste operations. Passing a buffer number selects one in of the range 1..5. The statusline is updated with the new number. Rotate performs a number of 90 degree counter clockwise rotations of the buffer contents. AddSelected as first argument copies all selected and visible objects into the buffer. Passing Clear removes all objects from the currently selected buffer. Convert causes the contents of the buffer (lines, arc, vias) to be converted into an element definition. Refer to Pastebuffer for examples. Default:

          !Ctrl<Key>x:       PasteBuffer(Clear) PasteBuffer(AddSelected)
          		   Mode(PasteBuffer)
          !Shift Ctrl<Key>x: PasteBuffer(Clear) PasteBuffer(AddSelected)
          		   RemoveSelected() Mode(PasteBuffer)
          !Mod1<Key>c:       PasteBuffer(Clear) PasteBuffer(AddSelected)
          !Mod1<key>x:       PasteBuffer(Clear) PasteBuffer(AddSelected)
          		   RemoveSelected()
          !Shift<Key>1:      PasteBuffer(1)
          !Shift<Key>2:      PasteBuffer(2)
          !Shift<Key>3:      PasteBuffer(3)
          !Shift<Key>4:      PasteBuffer(4)
          !Shift<Key>5:      PasteBuffer(5)
          None<Key>F3:       Mode(PasteBuffer)
          

Polygon((Close|PreviousPoint)

Polygons need a special action routine to make life easier. Calling Polygon(PreviousPoint) resets the newly entered corner to the previous one. The Undo action will call Polygon(PreviousPoint) when appropriate to do so. Close creates the final segment of the polygon. This may fail if clipping to 45 degree lines is switched on, in which case a warning is issued. Default:

          None<Key>p:             Polygon(Close)
          !Shift<Key>p:           Polygon(Close)
          

Print()

Pops up a print control box that lets you select the output device, scaling and many more options. Each run creates all files that are supported by the selected device. These are mask files as well as drilling files, silk screens and so on. The table shows the filenames for all possible files:

          	POSIX (extension)             8.3 filename
          		---------------------------------------------
          		*_componentmask.*             cmsk.*
          		*_componentsilk.*             cslk.*
          		*_soldermask.*                smsk.*
          		*_soldersilk.*                sslk.*
          		*_drill.*                     dril.*
          		*_groundplane.*               gpl.*
          		*_group[1..8].*     [..8].*
          

The output may be sent to a post-processor by starting the filename with the pipe ("|") character. Any "%f" in a command is replaced with the current filename. The function is available from the file menu. There are no defaults.

Quit()

Quits the application after confirming the operation. Default:

          <Message>WM_PROTOCOLS: Quit()
          

Redo()

This routine allows you to recover from the last undo command. You might want to do this if you thought that undo was going to revert something other than what it actually did (in case you are confused about which operations are un-doable), or if you have been backing up through a long undo list and over-shoot your stopping point. Any change that is made since the undo in question will trim the redo list. For example if you add ten lines, then undo three of them you could use redo to put them back, but if you move a line on the board before performing the redo, you will lose the ability to "redo" the three "undone" lines. Default:

          !Shift<Key>r:	Redo()
          

RemoveSelected()

This routine removes all visible and selected objects. There are no defaults.

Report(Object|DrillReport)

This routine pops up a dialog box describing the various characteristics of an object (or piece of an object such as a pad or pin) in the layout at the cursor position, or a report about all of the drill holes in the layout. There are no defaults.

RouteStyle(1|2|3|4)

This routine copies the sizes corresponding to the numbered route style into the active line thickens, via diameter, and via drill size. Defaults:

          !Ctrl<Key>1: RouteStyle(1)
          ...
          !Ctrl<Key>NUM_STYLES: RouteStyle(NUM_STYLES)
          

The variable NUM_STYLES is set at compile time in globalconfig.h.

Save(Layout|LayoutAs)

Save(AllConnections|AllUnusedPins|ElementConnections)

Passing Layout saves the layout using the file from which it was loaded or, if it is a new layout, calls Save(LayoutAs) which queries the user for a filename. The values: AllConnections, AllUnusedPins and ElementConnections start a connection scan and save all connections, all unused pins or the connections of a single element to a file. There are no defaults.

Select(All|Block|Connection|ToggleObject)

Select(ElementByName|ObjectByName|PadByName|PinByName)

Select(TextByName|ViaByName)

Toggles either the selection flag of the object at the cross hair position (ToggleObject) or selects all visible objects, all inside a rectangle or all objects which have been found during the last connection scan. The ByName functions use a Regular Expressions search, always case insensitive, to select the objects. Default:

          None<Btn3Down>:  Select(ToggleObject)
          None<Btn3Down>,None<Btn3Motion>: See resource file - this is complex
          

SetFlag(Object|SelectElements|SelectedPins|SelectedVias|Selected,thermal|octagon|square)

Sets the indicated flag. This adds thermals, sets the flag which indicates a pin/pad should be square, or sets the flag which indicates a pin/pad should be octagonal.

          :SetFlag(Selected,thermal)
          

SetValue(Grid|LineSize|TextScale|ViaDrillingHole|ViaSize|Zoom, value)

Some internal values may be changed online by this function. The first parameter specifies which data has to be changed. The other one determines if the resource is set to the passed value, if value is specified without sign, or increments/decrements if it is specified with a plus or minus sign. The function doesn't change any existing object only the initial values of new objects. Use the ChangeSize() and ChangeDrillSize() to change existing objects. Default:

          None<Key>g:        SetValue(Grid, +5)
          !Shift<Key>g:      SetValue(Grid, -5)
          None<Key>l:        SetValue(LineSize, +5)
          !Shift<Key>l:      SetValue(LineSize, -5)
          None<Key>t:        SetValue(TextScale, +10)
          !Shift<Key>t:      SetValue(TextScale, -10)
          None<Key>v:        SetValue(ViaSize, +5)
          !Shift<Key>v:      SetValue(ViaSize, -5)
          !Mod1<Key>v:       SetValue(ViaDrillingHole, +5)
          !Mod1 Shift<Key>v: SetValue(ViaDrillingHole, -5)
          None<Key>z:        SetValue(Zoom, -1)
          !Shift<Key>z:      SetValue(Zoom, +1)
          

SwapSides()

This routine changes the board side you are viewing. Default:

          None<Key>Tab:      SwapSides()
          

SwitchDrawingLayer(value)

Makes layer number 1..MAX_LAYER the current one. Default:

          None<Key>1:        SwitchDrawingLayer(1)
          ...
          None<Key>MAX_LAYER:        SwitchDrawingLayer(MAX_LAYER)
          

ToggleHideName(Object|SelectedElements)

Toggles whether the element's name is displayed or hidden. If it is hidden you won't see it on the screen and it will not appear on the silk layer when you print the layout.

          None<Key>h:	ToggleHideName(Object)
          !Shift<Key>h:	ToggleHideName(SelectedElements)
          

ToggleVendor()

Toggles automatic drill size mapping to the loaded vendor drill table.

          ToggleVendor()
          

ToggleVisibility(Layer)

Toggles the visibility of the layer.

          Mod1<Key>1:	ToggleVisibility(1)
          Mod1<Key>2:	ToggleVisibility(2)
          Mod1<Key>3:	ToggleVisibility(3)
          Mod1<Key>4:	ToggleVisibility(4)
          

Undo()

Undo(ClearList)

The unlimited undo feature of Pcb allows you to recover from most operations that materially affect you work. Calling Undo() without any parameter recovers from the last (non-undo) operation. ClearList is used to release the allocated memory. ClearList is called whenever a new layout is started or loaded. See also Redo. Default:

          None<Key>u:        Undo()
          !Shift Ctrl<Key>u: Undo(ClearList)
          

UnloadVendor()

Unloads the loaded vendor drill table.

          UnloadVendor()
          

Unselect(All|Block|Connection)

Unselects all visible objects, all inside a rectangle or all objects which have been found during the last connection scan. Default:

          !Shift <Btn3Down>: Mode(Save) Mode(None) Unselect(Block)
          !Shift <Btn3Up>:   Unselect(Block) Mode(Restore)