Parts

There are a few parameters shared by many of the parts.

The callback parameter

The callback parameter can take one of the following forms:

• A function (or bound method) that expects one parameter: the number of the side the callback is currently called for.

• A dict with some of the numbers of the sides as keys and functions without parameters as values.

• A list of functions without parameters. The list may contain None as place holder and be shorter than the number of sides.

The callback functions are called with the side of the part at the positive x and y axis. If the edge uses up space this space is below the x axis. You do not have to restore the coordinate settings in the callback.

Instead of functions it can be handy to use a lambda expression calling the one building block function you need (e.g. fingerHolesAt).

For your own parts you can use this helper function:

Boxes.cc(callback, number, x=0.0, y=None, a=0.0)

Call callback from edge of a part

Parameters:

• callback – callback (callable or list of callables)

• number – number of the callback

• x – (Default value = 0.0) x position to be call on

• y – (Default value = None) y position to be called on (default does burn correction)

For finding the right piece to the callback parameter this function is used:

Boxes.getEntry(param, idx)

Get entry from list or items itself

Parameters:

• param – list or item

• idx – index in list

The move parameter

The move parameter helps when placing multiple parts. It controls the location where the current and next part will be drawn. It’s a string with space separated words controlling the direction; see the documentation for where below for possible values.

This kind of direction controls the global placement and is unrelated to the drawing direction which is important for burn correction (aka kerf).

For implementing parts the following helper function can be used to implement a move parameter:

Boxes.move(x, y, where, before=False, label='')

Intended to be used by parts to implement the move parameter.

The part needs to call this function once before drawing with before=True (and skip drawing if it returns True) and once after the drawing. The function returns whether actual drawing of the part should be omitted.

where can be a combination of the following values:

• “up” / “down”

• “left” / “right”

• “mirror”

• “rotated”

• “only”

“down” and “left” move before drawing, while “up” and “right” move after drawing.

“mirror” will flip the part along the y-axis; “rotated” draws the parts rotated 90 degrees counter clockwise; when “only” is included the move is only done when before is True

Parameters:

• x – width of part

• y – height of part

• where – which direction to move

• before – (Default value = False) called before or after part being drawn

Returns:

whether drawing the part should be skipped

If “only” is given the part is not drawn but only the move is done. This can be useful to go in one direction after having placed multiple parts in the other and have returned with .ctx.restore().

The following example draws three walls: one on the left of the origin and two on the right. The second draw with “right only” is necessary to prevent “drawing over” the first wall. The last call needs no move as no more parts get drawn afterwards.

self.rectangularWall(x, y, move="left")        # move left and draw
self.rectangularWall(x, y, move="right only")  # move right
self.rectangularWall(x, y, move="right")       # draw and move right
self.rectangularWall(x, y)                     # draw

The edges parameter

The edges parameter needs to be an iterable of Edge instances to be used as edges of the part. Instead of instances it is possible to pass a single character that is looked up in the .edges dict. This allows to pass a string with the desired characters per edge. See Edges for a list of possible edges and their symbols.

Generators can register their own Edges by putting them into the .edges dictionary.

Same applies to the parameters of .surroundingWall although they denominate single edge (types) only.

PartsMatrix

To place a grid of identical parts, partMatrix can used:

Boxes.partsMatrix(n, width, move, part, *l, **kw)

place many of the same part

Parameters:

• n – number of parts

• width – number of parts in a row (0 for same as n)

• move – (Default value = “”)

• part – callable that draws a part and knows move param

• l – params for part

• kw – keyword params for part

It creates one big block of parts. The move param treats this block like one big part.