-
- (int) ChangeLayer()
This function will change the layer of all selected geometry to the
current layer. This is similar to the functionality of the Chg Layer button in the Modify Menu.
- (int) Bloat(dimen, mode)
Each selected object is bloated by the given dimension, similar to the
!bloat command. The returned value is 0 on success, or 1 if
there was a runtime error. This function will return 1 if not called
in physical mode.
The second argument is an integer that specifies the algorithm to use
for bloating. Giving zero specifies the default algorithm. See the
description of the !bloat command (19.13.12) for
documentation of the algorithms available.
- (int) Manhattanize(dimen, mode)
Each selected non-Manhattan polygon or wire is converted to a
Manhattan polygon or box approximation, similar to the !manh
command. The first argument is a size in microns representing the
smallest dimension of the boxes created to approximate the
non-Manhattan parts. The second argument is a boolean value that
specifies which of two algorithms to use. These algorithms are
described with the !manh command.
The returned value is 0 on success, or 1 if there was a runtime error.
This function will return 1 if not called in physical mode. The
function will fail if the dimen argument is smaller than 0.01.
- (int) Join()
The selected objects that touch or overlap are merged together into
polygons, similar to the !join command. The returned value is 0
on success, 1 if there is a runtime error. This function will return
1 if not called in physical mode.
- (int) Decompose(vert)
The selected polygons and wires are decomposed into elemental
non-overlapping trapezoids (polygons) similar to the !split
command. If the integer argument is nonzero, the decomposition favors
a vertical orientation, otherwise the splitting favors horizontal.
The returned value is 0 if called in physical mode, 1 if not called in
physical mode (an error).
- (int) Box(left, bottom, right,
top)
The four arguments are real values specifying the coordinates of a
rectangle in microns. Calling this function will generate a box on
the current layer with the given coordinates. This provides
functionality similar to the box menu button.
If the UseTransform function has been called to enable use of
the current transform, the current transform will be applied to given
coordinates before the box is created. The translation supplied to
UseTransform is added to the coordinates before the current
transform is applied.
The Box function will actually create a polygon if the current
transform is being used and the rotation angle is 45 degrees or one of
the other non-Manhattan angles.
- (object_handle) BoxH(left, bottom, right,
top)
This is similar to the Box function, but will return a handle to
the new object. On error, a scalar 0 is returned.
- (int) Polygon(num, arraypts)
This function creates a polygon on the current layer. The second
argument is an array of values, taken as x-y pairs. The first pair of
values must be the same as the last, i.e., the path must be closed.
The first argument is the number of pairs of coordinates in the array.
This provides functionality similar to the polyg menu button.
If the UseTransform function has been called to enable use of
the current transform, the current transform will be applied to the
given coordinates before the polygon is created. The translation
supplied to UseTransform is added to the coordinates before the
current transform is applied.
The Polygon function will actually create a box if the rotated
figure can be so represented. The Polygon function will never
create boxes unless use of the current transform is enabled.
- (object_handle) PolygonH(num, arraypts)
This is similar to the Polygon function, but will return a
handle to the new object. On error, a scalar 0 is returned.
- (int) Arc(x, y, rad1X, rad1Y,
rad2X, rad2Y, ang_start, ang_end)
This produces a circular or elliptical solid or ring-like figure,
providing functionality similar to the round, donut, and
arc buttons in the physical side menu.
| x, y |
center coordinates |
|---|
| rad1X, rad1Y |
x and y inner radii |
|---|
| rad2X, rad2Y |
x and y outer radii |
|---|
| ang_start |
starting angle in degrees |
|---|
| ang_end |
ending angle in degrees |
|---|
All dimensions are given in microns. The first two arguments provide
the center coordinates. The second two arguments are the inner radius
in the X and Y directions. If these differ, the inner radus will be
elliptical, otherwise it will be circular. If both are zero, the
figure will not have an inner surface.
Similarly, the next two arguments specify the outer radius, X and Y
directions separately. Both are required to be larger than the inner
radius counterpart.
The final two arguments are the start and end angle, given in degrees.
If ang_start and ang_end are equal, a donut (ring
figure) is produced. If the outer and inner radii are equal, a solid
figure is produced. Angles are defined from the positive x-axis, in a
counter-clockwise sense. The arc is generated in a clockwise
direction.
If the UseTransform function has been called to enable use of
the current transform, the current transform will be applied to the
arc coordinates before the arc is created. The translation supplied
to UseTransform is added to the coordinates before the current
transform is applied.
The function returns 1 on success, 0 otherwise.
- (object_handle) ArcH(x, y, rad1X,
rad1Y, rad2X, rad2Y, ang_start,
ang_end)
This is similar to the Arc function, but will return a handle to
the new object. On error, a scalar 0 is returned.
- (int) Round(x, y, rad)
This a simplification of the Arc function which simply creates a
circular disk object at the location specified in the first two
arguments. All dimensions are in microns. The third argument
specifies the radius.
The function returns 1 on success, 0 otherwise.
- (object_handle) RoundH(x, y, rad)
This is similar to the Round function, but will return a handle
to the new object. On error, a scalar 0 is returned.
- (int) HalfRound(x, y, rad,
dir)
This is a simplification of the Arc function which creates a
half-circular figure. The first two arguments indicate the center of
an equivalent full circle, i.e., it is the midpoint of the flat edge.
The dir argument is an integer 0-7 which specifies the
orientation, in increments of 45 degrees. With 0, the flat section is
horizontal with the curved surface on top. The dir rotates clockwise,
so that a value of 2 would produce a figure that looks like the letter
D.
The function returns 1 on success, 0 otherwise.
- (object_handle) HalfRoundH(x, y, rad,
dir)
This is similar to the HalfRound function, but will return a
handle to the new object. On error, a scalar 0 is returned.
- (int) Sides(numsides)
This sets the number of segments to use in generating round objects,
for the current display mode (electrical or physical). The function
returns the present value for this parameter. This is similar to the
sides side menu button in physical mode. It simply sets the
RoundFlashSides variable, or clears the variable if the number
of sides given is the default. Similarly, in electrical mode it is
similar to the sides entry in the menu from the shape
button in the side menu, and sets or clears the ElecRoundFlashSides variable.
- (int) Wire(width, num, arraypts,
end_style)
This function creates a wire on the current layer. The first argument
is the width of the wire in microns. The third argument is the name
of an array of coordinates, taken as x-y pairs. The second argument
is the number of coordinate pairs in the array. The fourth argument
is 0, 1, or 2 to set the end style to flush, rounded, or extended,
respectively. This provides the functionality of the wire menu
button.
If the UseTransform function has been called to enable use of
the current transform, the current transform will be applied to the
given coordinates before the wire is created. The translation
supplied to UseTransform is added to the coordinates before the
current transform is applied. The variable NoWireWidthMag will
suppress changes to the wire width due to the magnification component
of the current transform when set.
- (object_handle) WireH(width, num, arraypts,
end_style)
This is similar to the Wire function, but will return a handle
to the new object. On error, a scalar 0 is returned.
- (int) Label(text, x, y [, width,
height, flags)]
This function creates a label on the current layer. The function
takes a variable number of arguments, but the first three must be
present. The first argument is of string type and contains the label
text. The next two arguments specify the x and y coordinates of the
label reference point.
The remaining arguments are optional. The width and height specify the size of the bounding box into which the text will
be rendered, in microns. if both are zero or negative or not given, a
default size will be used. If only one is given a value greater than
zero, the other will be computed using a default aspect ratio. If
both are greater than zero, the text will be squeezed or stretched to
conform.
The flags argument is a label flags word used in Xic to set
various label attributes, as described in C.2. If given,
the Justify function and UseTransform function settings
will be ignored, and these attributes will be set from the flags. If flags is not given, the functions will set the
justification and transformation.
This function always returns 1.
- (object_handle) LabelH(text, x, y
[, width, height, xform)]
This is similar to the Label function, but will return a handle
to the new object. On error, a scalar 0 is returned.
- (int) Logo(string, x, y [, width,
height])
This creates and places physical text, i.e., text that is constructed
with database polygons that will appear in the mask layout. The
function takes a variable number of arguments, but the first three
must be present. The first argument is of string type and contains
the label text. The next two arguments specify the x and y
coordinates of the reference point, which is dependent on the current
justification, as set with the Justify function. The default is
the lower-left corner of the bounding box. The text will be
transformed according to the current transform.
The remaining arguments are optional. The width and height specify the approximate size of the rendered text. Unlike the
Label function, the text aspect ratio is fixed. The first of
height or width which is positive will be used to set the
``pixel'' size used to render the text, by dividing this value by the
character cell height or width of the default font. Thus, the
rendered text size will only be accurate for this font, and will scale
with the number of pixels used in the ``pretty'' fonts. One must
experiment with a chosen font to obtain accurate sizing. If neither
parameter is given and positive, a default size will be used.
This provides the functionality of the logo menu button, and is
sensitive to the following variables.
LogoEndStyle
LogoPathWidth
LogoAltFont
LogoPrettyFont
LogoPixelSize
LogoToFile
This function always returns 1.
- (int) Justify(hj, vj)
This sets the justification for text created with the logo and
label commands and corresponding script functions. The
arguments can have the following values:
| hj/vj |
horizontal |
vertical |
|---|
| 0 |
left |
bottom |
| 1 |
center |
center |
| 2 |
right |
top |
Values out of range will preserve the present justification setting.
The function always returns 1.
- (int) Delete()
This function deletes all selected objects from the database.
- (int) Erase(left, bottom, right,
top)
This function erases the rectangular area defined by the arguments.
Polygons, wires, and boxes are appropriately clipped. The erase
function has no effect on subcells or labels. This provides an erase
capability similar to the erase menu button.
- (int) EraseUnder()
This function will erase geometry from unselected objects that
intersect with objects that are selected. This is equivalent to the
Erase Under command in Xic. This function always returns 1.
- (int) Yank(left, bottom, right,
top)
This function puts the geometry in the specified rectangle in yank
buffer 0. It can be placed with the Put function, or the put command. This provides a yank capability similar to the erase button in the side menu.
- (int) Put(x, y, bufnum)
This puts the contents of the indicated yank buffer in the current
layout, with the lower left at x, y. The bufnum is
the yank buffer index, which can be 0-4. Buffer 0 is the most recent
yank or erase, buffer 1 is the next most recent, etc. This provides
functionality similar to the put button in the side menu.
- (int) Xor(left, bottom, right,
top)
This function exclusive-or's the rectangular area defined by the
arguments with boxes, polygons, and wires on the current layer.
Existing objects become clear areas. This provides functionality
similar to the xor button in the side menu.
- (int) Copy(fromx, fromy, tox,
toy, repcnt)
Copies of selected objects are created and placed such that the point
specified by the first two arguments is moved to the location
specified by the second two arguments.
The repcnt is an integer replication count in the range
1-100000, which will be silently taken as one if out of range. If
not one, multiple copies are made, at multiples of the translation
factors given.
This provides functionality similar to the Copy button in the
Modify Menu. The return value is 1 if there were no errors and
something was copied, 0 otherwise.
- (int) CopyToLayer(fromx, fromy, tox,
toy, oldlayer, newlayer, repcnt)
This is similar to the Copy function, but allows layer change.
If newlayer is 0, null, or empty, oldlayer is ignored and
the function behaves identically to Copy. Otherwise the newlayer string must be a layer name. If oldlayer is 0, null,
or empty, all copied objects are placed on newlayer.
Otherwise, oldlayer must be a layer name, in which case only
objects on oldlayer will be placed on newlayer, other
objects will remain on the same layer. Subcell objects are copied as
in Copy, i.e., the layer arguments are ignored.
- (int) Move(fromx, fromy, tox,
toy)
This function moves the selected objects such that the reference point
specified in the first two arguments is moved to the point specified
by the second two arguments. This provides functionality similar to
the Move button in the Modify Menu. The return value is 1
if there were no errors and something was moved, 0 otherwise.
- (int) MoveToLayer(fromx, fromy, tox,
toy, oldlayer, newlayer)
This is similar to the Move function, but allows layer change.
If newlayer is 0, null, or empty, oldlayer is ignored and
the function behaves identically to Move. Otherwise the newlayer string must be a layer name. If oldlayer is 0, null,
or empty, all moved objects are placed on newlayer.
Otherwise, oldlayer must be a layer name, in which case only
objects on oldlayer will be placed on newlayer, other
objects will remain on the same layer. Subcell objects are moved as
in Move, i.e., the layer arguments are ignored.
- (int) Rotate(x, y, ang, remove)
The selected objects are rotated counter-clockwise by ang (in
degrees) about he point specified in the first two arguments. This
provides functionality similar to the spin button in the side
menu.
If the boolean argument remove is true (nonzero), the original
objects will be deleted. Otherwise, the original objects are
retained, and will become deselected.
The return value is 1 if there were no errors and something was
rotated, 0 otherwise.
Note: in releases prior to 3.0.5, the remove argument was
absent and effectively 0 in the current function implementation.
- (int) RotateToLayer(x, y, ang,
oldlayer, newlayer, remove)
This is similar to the Rotate function, but allows layer change.
If newlayer is 0, null, or empty, oldlayer is ignored and
the function behaves identically to Rotate. Otherwise the newlayer string must be a layer name. If oldlayer is 0, null,
or empty, all rotated objects are placed on newlayer.
Otherwise, oldlayer must be a layer name, in which case only
objects on oldlayer will be placed on newlayer, other
objects will remain on the same layer. Subcell objects are rotated as
in Rotate, i.e., the layer arguments are ignored.
If the boolean argument remove is true (nonzero), the original
objects will be deleted. Otherwise, the original objects are
retained, and will become deselected.
The return value is 1 if there were no errors and something was
rotated, 0 otherwise.
Note: in releases prior to 3.0.5, the remove argument was
absent and effectively 0 in the current function implementation.
- (int) Split(x, y, flag, orient)
This will sever selected objects along a vertical or horizontal line
through x, y if flag is nonzero. If orient
is 0, the break line is vertical, otherwise it is horizontal. If flag is zero, the function will return 1 if an object would be split,
0 otherwise, though no objects are actually split. This provides
functionality similar to the break button in the side menu.
- (int) Flatten(depth, use_merge,
fast_mode)
The selected subcells are flattened into the current cell, recursively
to the given depth, similar to the effect of the Flatten button
in the Edit Menu.
The depth argument may be an integer representing the depth into
the hierarchy to flatten: 0 for top-level subcells only, 1 to include
second-level subcells, etc. This argument can also be a string
starting with `a' to signify flattening all levels. A negative
depth also signifies flattening all levels.
The use_merge argument is a boolean which if nonzero indicates
that new objects will be merged with existing objects when added to
the current cell. This is the same merging as specified in the Editing Setup panel from the Edit Menu, or corresponding
variables.
If the boolean argument fast_mode is nonzero, ``fast'' mode is used,
meaning that there will be no undo list generation and no object
merging. This is not undoable so should be used with care.
The function returns 1 on success, 0 otherwise, with an error message
probably available from GetError.
- Layer(string, mode, depth, recurse,
noclear, use_merge, fast_mode)
This is very similar to the !layer command, and operations from
the Evaluate Layer Expression panel brought up with the Layer Expression button in the Edit Menu. The string is
of the form
``new_layer_name [=] layer_expression''.
The mode argument is an integer which sets the split/join mode,
similar to the keywords in the !layer command, and the buttons
in the Evaluate Layer Expression panel. Only the two
least-significant bits of the integer value are used.
| 0 |
default |
| 1 |
horizontal split |
| 2 |
vertical split |
| 3 |
join |
The depth is the search depth, which can be an integer which
sets the maximum depth to search (0 means search the current cell
only, 1 means search the current cell plus the subcells, etc., and a
negative integer sets the depth to search the entire hierarchy). This
argument can also be a string starting with `a' such as ``a'' or ``all'' which specifies to search the entire hierarchy.
The recurse argument is a boolean value which corresponds to the
``-r'' option of the !layer command, or the Recursively create in subcells check box in the Evaluate Layer
Expression panel. If nonzero, evaluation will be performed in
subcells to depth, using only that cell's geometry. When zero,
geometry is created in the current cell only, using geometry found in
subcells to depth.
If the boolean argument noclear is true, the target layer will
not be cleared before expression evaluation. This corresponds to the
``-c'' option of the !layer command, and the Don't
clear layer before evaluation button in the Evaluate Layer
Expression panel.
The boolean argument use_merge corresponds to the ``-m''
option in the !layer command, and the Use object merging
while processing check box in the Evaluate Layer Expression
panel. When nonzero, new objects will be merged with existing objects
when added to a cell.
The fast_mode argument is a boolean value that corresponds to
the ``-f'' option in the !layer command, and the Fast
mode check box in the Evaluate Layer Expression panel. When
nonzero, undo list processing and merging are skipped for speed and to
reduce memory use. However, the result is not undoable so this flag
should be used with care.
There is no return value; the function either succeeds or will
terminate the script on error.
