next up previous contents index
Next: Pseudo-Flat Generator Functions Up: Geometry Creation and Management Previous: Selections   Contents   Index


Object Management by Handles

The following functions provide a fairly complete interface to database objects. In general, objects in electrical views can be accessed for reading, but modification is prohibited.

Some of the functions generate or accept lists of ``object copies''. These are objects that are not included in the object database for any cell. A list of copies behaves in most respects like an ordinary object list, except that the objects can not be modified. The functions that modify database objects will fail quietly (returning 0). The ObjectCopy function can be used to create a new database object from a copy. Lists of copies can be used in the first argument to the clipping functions such as ClipTo, but not the second. The handle manipulation functions such as HandleCat work, but lists of copies can not be mixed with lists of database objects, HandleCat will fail quietly if this is attempted. Copies can not be selected.

(object_handle) SelectHandle()
This function returns a handle to the list of objects currently selected. The list is copied internally, and so is unchanged if the objects are subsequently deselected.

A handle to the object list is returned. The ObjectNext function is used to advance the handle to point to the next object in the list. The HandleContent function returns the number of objects remaining in the list.

(object_handle) SelectHandleTypes(types)
This function returns a handle to a list of objects that are currently selected, but only the types of objects specified in the argument are included. The argument is a string which specifies the types of objects to include. If zero or an empty string is passed, all types are included, and the function is equivalent to SelectHandle. Otherwise the characters in the string signify which objects to include:

`b' boxes
`p' polygons
`w' wires
`l' labels
`c' subcells

For example, passing ``pwb'' would include polygons, wires, and boxes only. The order of the characters is unimportant.

(object_handle) AreaHandle(l, b, r, t, types)
This function creates a list of objects that touch the rectangular area specified by the first four coordinates (which are the left, bottom, right, and top values of the rectangle). The fifth argument is a string which specifies the types of objects to include. If zero or an empty string is passed, all types are included, otherwise the characters in the string signify which objects to include:

`b' boxes
`p' polygons
`w' wires
`l' labels
`c' subcells

For example, passing ``pwb'' would list polygons, wires, and boxes only. The order of the characters is unimportant.

A handle to the object list is returned. The ObjectNext function is used to advance the handle to point to the next object in the list. The HandleContent function returns the number of objects remaining in the list.

(object_handle) MakeObjectCopy(numpts, array)
This function creates an object copy from the numpts coordinate pairs in the array. The function returns an object list handle referencing the ``copy'', which can be used in the same manner as copies of ``real'' objects. The coordinate list must be closed, i.e., the last coordinate pair must be the same as the first. If the coordinates represent a rectangle, a box object is created, otherwise the object is a polygon. Coordinates are in microns, relative to the origin of the current cell. The object is associated with the current layer (but of course it really does not exist on that layer).

(object_handle) BloatObjects(object_handle, dimen, lname, mode)
This function returns a handle to a list of object copies which are bloated versions of the objects referenced by the handle argument, similar to the !bloat command. The passed handle and objects are not affected. Edges will be pushed outward or pulled inward by dimen (positive values push outward). The dimen is given in microns. The third argument is a layer name. If this argument is zero, or a null or empty string, all objects on the returned list are associated with the layer of the first object in the passed list, and only objects on this layer in the passed list are processed. Otherwise, the layer will be created if it does not exist, and all new objects will be associated with this layer, and all objects in the passed list will be processed.

The fourth 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 (14.14.4) for documentation of the algorithms available.

The ObjectDelete function can be called to delete the old objects. The ObjectCopy function can be called on the returned objects to add them to the database. This function returns a handle to the new list upon success, or 0 if there are no objects. The function will fail if the first argument is not a handle to a list of objects or copies, or the lname argument is non-null and not a valid layer name.

This function uses the JoinMaxXXX variables in processing. There is no effect on objects in the list whose handle is passed as the first argument, or on the handle.

(object_handle) EdgeObjects(object_handle, dimen, lname, mode)
This function creates new polygon copies that cover the edges of the figures in the passed handle. The new polygons are like wires with width 2*dimen (dimen is given in microns) centered on the figure edge. If a layer name is passed as a third argument, new polygons will be assigned to that layer, which will be created if it does not exist. If the argument is null or empty, new polygons will be assigned to the same layer as the original polygon. If the boolean argument all is nonzero, all of the objects in the passed list will be processed, otherwise only the object at the head of the list will be processed.

The ObjectDelete function can be called to delete the old objects. The ObjectCopy function can be called on the returned objects to add them to the database. This function returns a handle to the new list upon success, or 0 if there are no objects. The function will fail if the first argument is not a handle to a list of objects or copies, or the lname argument is non-null and not a valid layer name.

(object_handle) ManhattanizeObjects(object_handle, dimen, lname)
This function will convert the objects pointed to by the handle argument into a list of copies, which is referenced by the returned handle. The supplied objects and handle are not affected. Each new object is a Manhattan approximation of the original object. The second argument is the minimum height or width in microns of rectangles created to approximate the non-Manhattan parts. The third argument is a layer name, or zero. If a layer name is given, the new objects will be associated with that layer, which will be created if it does not exist. If 0 or an empty string is passed, the new objects will be associated with the layer of the original object. The function will fail if the handle argument is not an object handle, or the size argument is smaller than 0.01. On success, a handle to the list of copies is returned. Each object in the returned list is a box or Manhattan polygon which approximates one of the original objects. Of course, if the original objects were all Manhattan, the shapes will be unchanged.

The ObjectDelete function can be called to delete the old objects. The ObjectCopy function can be called on the returned objects to add them to the database. This function returns a handle to the new list upon success, or 0 if there are no objects. The function will fail if the first argument is not a handle to a list of objects or copies, or the lname argument is non-null and not a valid layer name.

This function uses the JoinMaxXXX variables in processing. There is no effect on objects in the list whose handle is passed as the first argument, or on the handle.

(int) GroupObjects(object_handle, array)
This function acts on the first object in the list and all other objects on the same layer found in the list. The objects are copied, then sorted into groups, so that each group forms a single figure, i.e., no two members of the same group are disjoint. The groups are then joined into polygons, and a handle to each group is returned in the array. The array will be resized if necessary. The returned value is the number of groups, corresponding to the used entries in the array. The H function should be used on the array elements to convert the values to an object handle data type, similar to the treatment of the array returned from the HandleArray function. The CloseArray function can be used to close the handles. The created objects are copies, so are not added to the database.

This function uses the JoinMaxXXX variables in processing. There is no effect on objects in the list whose handle is passed as the first argument, or on the handle. The value 0 is returned on error or if the list is empty.

(object_handle) JoinObjects(object_handle, lname)
This function will combine the objects in the list passed as the first argument, if possible, into a new list of object copies, which is returned. The passed handle and objects are not affected. All objects in the returned list will be associated with the layer named in the second argument. This layer will be created if it does not exist, and the output will consist of the joined outlines of all of the objects in the passed list, from any layer. If 0, or a null or empty string is passed, the new objects will be associated with the layer of the first object in the passed list, and only the outlines of objects on this layer found in the passed list will contribute to the result.

The ObjectDelete function can be called to delete the old objects. The ObjectCopy function can be called on the returned objects to add them to the database. This function returns a handle to the new list upon success, or 0 if there are no objects. The function will fail if the first argument is not a handle to a list of objects or copies, or the lname argument is non-null and not a vail layer name.

This function uses the JoinMaxXXX variables in processing. There is no effect on objects in the list whose handle is passed as the first argument, or on the handle.

(object_handle) SplitObjects(object_handle, lname, vert)
This function will split the objects in the list passed as the first argument into horizontal or vertical trapezoids (polygons or boxes) and return a list of the new objects. The new objects are ``object copies'' and are not added to the database. The new objects are placed on the layer with the name given in lname, which is created if it does not exist, independent of the originating layer of the objects. If a null string or 0 is passed for lname, the target layer will be the layer of the first object found in the list passed as an argument. The third argument is an integer which if nonzero indicates a vertical decomposition, otherwise a horizontal decomposition is produced. The objects passed are untouched. The ObjectDelete function can be called to delete the old objects. The ObjectCopy function can be called on the returned objects to add them to the database. This function returns a handle to the new list upon success, or 0 if there are no objects. The function will fail if the first argument is not a handle to a list of objects or copies, or the lname argument is non-null and not a valid layer name.

(int) CheckObjectsConnected(object_handle)
This function returns 1 unless the list contains objects on the layer of the first object in the list that are mutually disjoint, meaning that there exist two objects and one can not draw a curve from the interior of one to the other without crossing empty area. If disjoint objects are found, 0 is returned.

(int) CheckForHoles(object_handle, all)
This function returns 1 if the object, or collection of objects, has ``holes'', i.e., uncovered areas completely surrounded by geometry. The first argument is a handle to a list of objects. If the second argument is nonzero, the geometry represented by all objects in the list is checked. If zero, only the first object (which might be a complex polygon containing holes) is checked. If no holes are found, 0 is returned.

When all is true, only objects on the same layer as the first object in the list are considered.

(object_handle) ObjectHandleDup(object_handle, types)
This function creates a new handle and list of objects. The new object list consists of those objects in the list referenced by the argument whose types are given in the string types argument. If zero or an empty string is passed, all types are included, otherwise the characters in the string signify which objects to include:

`b' boxes
`p' polygons
`w' wires
`l' labels
`c' subcells

The return value is a handle, or 0 if an error occurred. Note that the new handle may be empty if there were no matching objects. The function will fail if the handle argument is not a pointer to an object list.

(int) ObjectHandlePurge(object_handle, types)
This function will purge from the list of objects referenced by the handle argument objects with types listed in the types string. If zero or an empty string is passed, all types are deleted, otherwise the characters in the string signify which objects to delete:

`b' boxes
`p' polygons
`w' wires
`l' labels
`c' subcells

The return value is the number of objects remaining in the list. The function will fail if the handle argument does not reference a list of objects.

(int) ObjectNext(object_handle)
This function is called with a handle to a list of objects, and causes the handle to reference the next object in the list. If there are no more objects, the handle is closed, and this function returns zero. Otherwise, 1 is returned. This function will fail if the handle passed is not a handle to an object list.

(int) ObjectDelete(object_handle)
Calling this function will delete the object referenced by the handle from the current cell. The handle will point to the next object in its list. This function will fail if the handle passed is not a handle to an object list. If the object is deleted, 1 is returned, otherwise 0 is returned.

(int) ObjectSelect(object_handle)
This function will select the object referenced by the handle, if it is currently not selected, and the object is in the current cell. The function returns 1 if the object was previously not selected and was selected, otherwise 0 is returned. It is not possible to select object copies, 0 is returned if the passed handle represents copies. This function will fail if the handle passed is not a handle to an object list.

(int) ObjectDeselect(object_handle)
If the object pointed to by the handle is selected, calling this function will deselect the object. The function returns 1 if the object was previously selected and was deselected, otherwise 0 is returned. This function will fail if the handle passed is not a handle to an object list.

(int) ObjectMove(object_handle, refx, refy, x, y, all)
This function is similar to the Move function, however it operates on the object(s) referenced by the handle. An object is moved such that the coordinate refx, refy is translated to x, y. The current transform will be applied to the move. If all is nonzero, all objects in the list are moved, otherwise only the object currently referenced is moved. The function returns the number of objects moved. This function will fail if the handle passed is not a handle to an object list.

If the handle references object copies, each copy is translated and possibly transformed as described above. The handle will subsequently reference the modified object.

(int) ObjectMoveToLayer(object_handle, refx, refy, x, y, all, oldlayer, newlayer)
This is similar to the ObjectMove function, but allows layer change. If newlayer is 0, null, or empty, oldlayer is ignored and the function behaves identically to ObjectMove. 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 ObjectMove, i.e., the layer arguments are ignored.

(int) ObjectCopy(object_handle, refx, refy, x, y, all)
This function is similar to the Copy function, however it operates on the object(s) referenced by the handle. An object is copied such that the coordinate refx, refy is translated to x, y. The current transform will be applied to the copy. If all is nonzero, all of the objects in the list are copied, otherwise only the object currently being referenced is copied. The function returns the number of objects copied. This function will fail if the handle passed is not a handle to an object list.

If the handle references object copies, the object copies that are referenced remains untouched, however the new objects, translated and possibly transformed as described above, are added to the database.

(int) ObjectCopyToLayer(object_handle, refx, refy, x, y, all, oldlayer, newlayer)
This is similar to the ObjectCopy function, but allows layer change. If newlayer is 0, null, or empty, oldlayer is ignored and the function behaves identically to ObjectCopy. 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 ObjectCopy, i.e., the layer arguments are ignored.

(string) ObjectString(object_handle)
This function returns a CIF-like string describing the object pointed to by the given object handle. This provides all of the geometric information for the object. Strings of this format can be reconverted to object copies with the ObjectCopyFromString function.

On error or for an empty handle, a null string is returned. The function will fail if the argument is not a handle to an object list.

(object_handle) ObjectCopyFromString(string, layer)
This function will create an object copy from the CIF-like string, as generated by the ObjectString function. Boxes, polygons, and wires are supported, labels and subcells will not return a handle. The object will be associated with the layer named in the second argument. The layer will be created if it does not exist. Only physical layers are accepted.

On success, a handle to an object list containing the new copy is returned. On error, a scalar zero is returned. The function will fail if the string is null or a new layer cannot be created.

(object_handle) FilterObjects(object_list, template_list, touchok, useall, remove)
This function creates a handle to a list of objects that is a subset of the objects contained in the object_list. The objects in the new list are those that touch or overlap objects in the template_list, which is also a handle to a list of objects. If touchok is nonzero, objects in the object list that touch but do not overlap the template object(s) will be added to the new list, otherwise not. If useall is nonzero, all of the objects in the template_list will be used for comparison, otherwise only the head object in the template list will be used. If remove is nonzero, objects that are added to the new list are removed from the object_list, otherwise the object_list is not touched. The function will fail if the handle arguments are of the wrong type. The return value is a new handle to a list of objects.

(object_handle) FilterObjectsA(object_list, array, array_size, touchok, remove)
This function creates a handle to a list of objects, which consist of the objects in the object_list that touch or overlap the polygon defined in the array. The array_size is the number of x-y coordinates represented in the array. In the array, the values are x-y coordinate pairs representing the polygon vertices, and the first pair must match the last pair (i.e., the figure must be closed). The values are specified in microns. If touchok is nonzero, objects that touch but do not overlap the polygon will be added to the list, otherwise not. If remove is nonzero, objects that are added to the new list are removed from the object_list, otherwise the object_list is not touched.

The function will fail if array_size is less than 4, or the size of the array is less than twice array_size, or if the handle argument is not a handle to a list of objects. The return value is a new handle to a list of objects.

(string) GetObjectType(object_handle)
This function returns a one-character string representing the type of object referenced by the handle argument. If the handle is invalid, a null string is returned. The types are:

`b' boxes
`p' polygons
`w' wires
`l' labels
`c' subcells

This function will fail if the handle passed is not a handle to an object list.

(int) GetObjectID(object_handle)
This function returns a unique id number for the object. The id is actually the address of the object in the process memory, so it is valid only for the current Xic process. If the referenced object is a copy, the id returned is the address of the real object, not the copy. If no object is referenced by the handle, 0 is returned. The function fails if the handle is not an object list type.

(int) GetObjectArea(object_handle)
Return the area in square microns of the object pointed to by the handle. Zero is returned for a defunct handle or upon error.

(int) GetObjectPerim(object_handle)
Return the perimeter in microns of the object pointed to by the handle. Zero is returned for a defunct handle or upon error.

(int) GetObjectBB(object_handle, array)
This function loads the left, bottom, right, and top coordinates of the object's bounding box (in microns) into the array passed. This function will fail if the handle passed is not a handle to an object list, or if the size of the array is less than 4. The return value is 1 if successful, 0 otherwise.

(int) SetObjectBB(object_handle, array)
This function will alter the shape of the object pointed to by the handle such that it has the bounding box passed. The array contains the left, bottom, right, and top coordinates, in microns. This function will modify objects in physical views only. This function will fail if the handle passed is not a handle to an object list, or if the size of the array is less than 4. The return value is 1 if successful, 0 otherwise. This function has no effect on subcells, but other types of object will be rescaled to the new bounding box.

(string) GetObjectLayer(object_handle)
This function returns the name of the layer on which the object referenced by the handle is defined. For subcells, this layer is named ``$$'', but objects will return a layer from the layer table. This function will fail if the handle passed is not a handle to an object list. A stale handle will return a null string.

(int) SetObjectLayer(object_handle, layername)
This function will move the object to the layer named in the string layername. This will have no effect on subcells, or objects in electrical views. A value 1 is returned if successful, 0 otherwise. This function will fail if the handle passed is not a handle to an object list.

(int) GetObjectFlags(object_handle)
This function returns internal flag data from the object referenced by the handle. It is unlikely that this information would be useful to the user. This function will fail if the handle passed is not a handle to an object list. A stale handle will return 0.

(int) GetObjectState(object_handle)
This function returns a status value for the object referenced by the handle. The status values are:

0 normal state
1 object is selected
2 object is deleted
3 object is incomplete
4 object is internal only

Only values 0 and 1 are likely to be seen. This function will fail if the handle passed is not a handle to an object list. A stale handle will return 0.

(int) GetObjectGroup(object_handle)
This function returns the conductor group number of the object. This has relevance for physical boxes, polygons, and wires. The group number is set by the extraction system and is used for connectivity testing. This function will fail if the handle passed is not a handle to an object list. A stale handle will return 0.

(int) GetObjectCoords(object_handle, array)
This function will obtain the vertex list for polygons and wires, or the bounding box vertices of other objects, starting from the lower left corner and working clockwise. If an array is passed, the vertex coordinates are copied into the array, and the vertex count is returned. The array will contain the x, y values of the vertices, in microns, if successful. The coordinates are copied only if the array is large enough, or can be resized. If the array is a pointer to a too small array, or the array is too small but has other variables pointing to it, resizing is impossible and the copying is skipped. In this case, the returned value is the negative vertex count. If 0 is passed instead of the array, the (positive) vertex count is returned. Zero is returned if there is an error. This function will fail if the handle passed is not a handle to an object list.

(int) SetObjectCoords(object_handle, array, size)
This function will modify a physical object to have the vertex list passed in the array. The size is the number of vertices (one half the size of the array used). For all but wires, the first and last vertices must coincide, thus the minimum number of vertices is four. The array consists of x, y coordinates of the vertices. If the operation is successful, 1 is returned, otherwise 0 is returned. The coordinates in the array are in microns. If the coordinates represent a rectangle, the new object will be a box, if it was previously a polygon or box. A box may be converted to a polygon if the coordinates are not those of a rectangle. For labels, the coordinates must represent a rectangle, and the label will be stretched to the new box. The function has no effect on instances. This function will fail if the handle passed is not a handle to an object list.

(real) GetObjectMagn(object_handle)
This function returns the magnification part of the transform if the object referenced by the handle is a subcell, or 1.0 for other objects. Only physical subcells can have non-unit magnification. This function will fail if the handle passed is not a handle to an object list. A stale handle returns 0.

(int) SetObjectMagn(object_handle, magn)
This will set the magnification of the subcell referenced by the handle, or scale other physical objects. The real number magn must be between .001 and 1000 inclusive. It applies in physical views only. If the operation is successful, 1 is returned, otherwise 0 is returned. This function will fail if the handle passed is not a handle to an object list.

(real) GetWireWidth(object_handle)
This function will return the wire width if the object referenced by the handle is a wire, otherwise 0 is returned. This function will fail if the handle passed is not a handle to an object list.

(int) SetWireWidth(object_handle, width)
This function will set the width of the wire referenced by the handle to the given width (in microns). If the operation is successful, 1 is returned, otherwise 0 is returned. This function will fail if the handle passed is not a handle to an object list.

(int) GetWireStyle(object_handle)
This function returns the end style code of the wire pointed to by the handle, or -1 if the object is not a wire. The codes are

0 flush ends
1 projecting rounded ends
2 projecting square ends

This function will fail if the handle passed is not a handle to an object list.

(int) SetWireStyle(object_handle, code)
This function will change the end style of the wire referenced by the handle to the given code. The code is an integer which can take the following values

0 flush ends
1 projecting rounded ends
2 projecting square ends

If the operation succeeds, 1 is returned, otherwise 0. This can apply to physical wires only. This function will fail if the handle passed is not a handle to an object list.

(int) SetWireToPoly(object_handle)
This function converts the wire object referenced by the handle to a polygon object. If the conversion is done, the handle will reference the new polygon object. The conversion will be done only if the wire has nonzero width. If the wire is not a copy, the wire object in the database will be converted to a polygon. Otherwise, only the copy will be changed. Upon success, the function returns 1, otherwise 0 is returned. The function fails if the argument is not a handle to an object list.

(int) GetWirePoly(object_handle, array)
This function returns the polygon used for rendering a wire. This will be different from the wire vertices, if the wire has nonzero width. The first argument is a handle to an object list which references a wire object. The second argument is an array which will hold the polygon coordinates. This argument can be 0, if the polygon points are not needed. The array will be resized if necessary (and possible). The return value is the number of vertices required or used in the polygon. If an error occurs, the return value is 0. If an array is passed which can't be resized because it is referenced by a pointer, the return value is a negative value, the negative vertex count required. The function will fail if the first argument is not a handle to an object list, or the second argument is not an array or zero. The coordinates returned in the array are in microns, relative to the origin of the current cell.

(string) GetLabelText(object_handle)
This function returns the label text if the object referenced by the handle is a label. Otherwise, a null string is returned. The actual text is always returned, and not the symbolic text that is shown on-screen for script and long text labels. This function will fail if the handle passed is not a handle to an object list.

(int) SetLabelText(object_handle, text)
This function will set the label text of a label referenced by the handle. This applies to physical-mode labels only. Setting the text in this manner will cause a long-text label to revert to a normal label. If the operation succeeds, the return value is 1, otherwise 0 is returned. This function will fail if the handle passed is not a handle to an object list.

(int) GetLabelXform(object_handle)
This function returns the orientation code of the label referenced by the handle, or 0 if the object is not a label. The orientation code is a bit field with the following significance:

bits description
0-1 0-no rotation, 1-90, 2-180, 3-270
2 mirror y after rotation
3 mirror x after rotation and mirror y
4 shift rotation to 45, 135, 225, 315
5-6 horiz. justification 00,11 left, 01 center, 10 right
7-8 vert. justification 00,11 bottom, 01 center, 10 top
9-10 font

This function will fail if the handle passed is not a handle to an object list.

(int) SetLabelXform(object_handle, xform)
This function will apply the given orientation code, as defined for GetLabelXform, to the label referenced by the handle. If the operation is successful, 1 is returned, otherwise 0 is returned. Only physical-mode labels can be changed. This function will fail if the handle passed is not a handle to an object list.

(int) GetInstanceArray(object_handle, array)
This function fills in the array, which must have size of four or larger, with the array parameters for the instance referenced by the handle. If the operation succeeds, 1 is returned, and the array components have the following values, relative to the untransformed coordinates:

array[0] number of cells along x
array[1] number of cells along y
array[2] center to center x spacing (in microns)
array[3] center to center y spacing (in microns)

If the operation fails, 0 is returned. This function will fail if the handle passed is not a handle to an object list.

(int) SetInstanceArray(object_handle, array)
This function will change the array parameters of the instance referenced by the handle to the indicated values. The array values are in the format as returned from GetInstanceArray. Only physical mode subcells can be changed by this function, arrays are not supported in electrical mode. If the operation succeeds, 1 is returned, otherwise 0 is returned. This function will fail if the handle passed is not a handle to an object list.

(string) GetInstanceXform(object_handle)
This function returns a string giving the CIF transformation code for the instance referenced by the handle. If the object is not an instance, a null string is returned. This function will fail if the handle passed is not a handle to an object list.

(string) GetInstanceXformA(object_handle, array)
This function fills in the array, which must have size 4 or larger, with the components of the transformation of the instance referenced by the handle. The values are:

array[0] 1 if mirror-y, 0 if no mirror-y
array[1] angle in degrees
array[2] translation x
array[3] translation y

This is the same data as provided by the GetInstanceXform function, but in numerical rather than string form. The transform components are applied in the order as found in the array, i.e., mirror first, then rotate, then translate. The function returns 1 if successful, 0 otherwise. It will fail if the handle passed is not a handle to an object list.

(int) SetInstanceXform(object_handle, transform)
This function applies the given transform to the instance referenced by the handle. The transform is in the form of a CIF transformation string, as returned by GetInstanceXform. Note that coordinates in the transform string are in internal units (1 unit = .001 micron). Only physical-mode subcells can be modified by this function. If the operation succeeds, 1 is returned, otherwise 0 is returned. This function will fail if the handle passed is not a handle to an object list.

(int) SetInstanceXformA(object_handle, array)
This function applies the given transform parameters in the array to the instance referenced by the handle. The parameters are:

array[0] 1 if mirror-y, 0 if no mirror-y
array[1] angle in degrees
array[2] translation x
array[3] translation y

Only physical-mode subcells can be modified by this function. If the operation succeeds, 1 is returned, otherwise 0 is returned. The transform components are applied in the order as found in the array, i.e., mirror first, then rotate, then translate. The function returns 1 if successful, 0 otherwise. It will fail if the handle passed is not a handle to an object list.

(string) GetInstanceName(object_handle)
This function returns the cell name of the instance referenced by the handle. If the object is not an instance, a null string is returned. This function will fail if the handle passed is not a handle to an object list.

(int) SetInstanceName(object_handle, newname)
This function will replace the instance referenced by the handle with an instance of the cell given as newname, in the parent cell of the referenced instance. The current transform is added to the transform of the new instance. This function will fail if the handle passed is not a handle to an object list. If successful, 1 is returned, otherwise 0 is returned.


next up previous contents index
Next: Pseudo-Flat Generator Functions Up: Geometry Creation and Management Previous: Selections   Contents   Index
Stephen R. Whiteley 2006-10-23