Introduction
Screenshots
License
Download
Userinterface
Function Index
White Papers
Community
Contact

no help

cell Class Reference

a single cell more...

Public Member Functions

Public Attributes

Detailed Description

This class holds all information relevant for a single cell.

Member Documentation

elementList* cell::firstElement

list of all element

This is a list of all elements in this cell.

string cell::cellName

cell name

The name of this cell.

void cell::fSelect(rect select)

form select

Selects a complete element, if one point is inside rect.

void cell::fSelectLayer(rect select, int layer)

form select layer

Selects a complete element, if one point is inside rect and it is on layer

void cell::fAllSelect(rect select)

form all select

Selects a complete element, if all points are inside rect.

void cell::pSelect(rect select)

point select

Selects point in the rect.

void cell::cSelect(rect select)

cell select

Selects a cell, if the base point is in the rect.

void cell::fDeselect(rect select)

form deselect

Deselects a complete element, if one point is inside rect.

void cell::fDeselectLayer(rect select, int layer)

form deselect layer

Deselects a complete element, if one point is inside rect and it is on layer

void cell::fAllDeselect(rect select)

form all deselect

Deselects a complete element, if all points are inside rect.

void cell::pDeselect(rect select)

point deselect

Deselects point in the rect.

void cell::cDeselect(rect select)

cell deselect

Deselects a cell, if the base point is in the rect.

void cell::selectAll()

select all

All elements are selected.

void cell::invertSelect()

invert select

The selection of this cell is inverted.

void cell::selectVisible()

select visible

All visible elements are selected.

void cell::deselectAll()

deselect all

All elements are deselected.

void cell::pathSelectVisible()

path select

All visible path elements are selected.

void cell::pathDeselect()

path deselect

All path elements are deselected.

void cell::boxSelectVisible()

box select

All visible boxes are selected.

void cell::boxDeselect()

box deselect

All boxes are deselected.

void cell::polygonSelectVisible()

polygon select

All visible polygons are selected.

void cell::polygonDeselect()

polygon deselect

All polygons are deselected.

void cell::selectText(string text)

select text

All text elements with 'text' are selected.

void cell::deselectText(string text)

deselect text

All text elements with 'text' are deselected.

void cell::textSelectVisible()

text select

All visible text elements are selected.

void cell::textDeselect()

text deselect

All text elements are deselected.

void cell::selectCellref(string cellname)

select cellref

All cellref to cells named cellname are selected

void cell::selectLayer(int layer)

select Layer

All elements on layer are selected.

void cell::deselectLayer(int layer)

deselect layer

All elements on layer are deselected.

void cell::selectNode(int node)

select node

All elements connected with node are selected.

void cell::deselectNode(int node)

deselect node

All elements connected with node are deselected.

void cell::selectNodeOnLayer(int node,int layer)

select node on layer

All elements on layer connected with node are selected

void cell::deselectNodeOnLayer(int node,int layer)

deselect node on layer

All elements on layer connected with node are sdeelected

void cell::mapLayer(layerTranslator *t)

map layer

all elements in this cell are maped with layerTranslator t.

void cell::rotateSelect(double angle,point pos)

rotate select elements

Selected elements are rotated.

Parameters:

void cell::mirrorSelect(point p1,point p2)

mirror select elements

Selected elements are mirror at a Line made by p1 and p2. If p1==p2, it is mirrored at this single point.

void cell::scaleSelect(point p1,point p2,point p3)

scale select elements

Selected elements are scaled. p2 is scale to p3.

Parameters:

void cell::moveToLayerSelect(int layer)

move to layer

Selected elements are moved to the layer

Parameters:

void cell::copySelect(point p=point(0,0)

copy select

Selected elements are copyed and move by p

Parameters:

void cell::deleteRefs(cell *c)

delete references

Cellrefs and cellrefarrays on the cell c are deleted.

Parameters:

void cell::flatSelect()

flatten

Selected cellrefs and cellrefarrays are flatten.

void cell::flatAllSelect()

flatten multilevel

Selected cellrefs and cellrefarrays are flatten. If the the cellrefs contain more cellrefs, they are flatten as well.

void cell::flatCellrefArray()

flatten cellrefarray

all cellrefarrays are flatten.

void cell::deleteSelect()

delete select

Selected element are deleted.

void cell::moveSelect(point pos)

move select

Selected element are moved by pos

void cell::move(point pos)

move

All element are moved by pos

void cell::cutSelect(point p1, point p2)

cut

Cut selected elements between p1 and p2.

void cell::sizeadjustSelect(int value)

adjust size

Selected elements grow/shrink with value.

void cell::sizeadjustSelect(int valueX, int valueY)

adjust size

Selected elements grow/shrink with different values in x and y.

void cell::modifyCornersSelect(double value1,double value2)

modify corners

All corners of selected elements will be modified. A addition area will be added/substracted in the corner region. The amount of the area will be calculation in dependence with the corner angles. sharp corner will add more area than small angles. The first parameter will give the squart of amount for a 90° angle. The second parameter will modify the shape of the added area.

void cell::cropWithSelection()

crop with selection

Selected elements are used to crop the complete cell.

void cell::toMeshSelect(int width,int spaceing)

convert to mesh

Selected elements are converted to a mesh of path elements.

void cell::mergeSelect()

merge

Selected elements on the same layer are merged.

void cell::roundSelect(int i)

round

Selected elements/point are rounded to a multiply of i.

void cell::setDatatypeSelect(int i)

set datatype select

The datatype of selected element is set to i

void cell::selectDatatype(int i)

select datatype

All element with the datatype i are selected.

void cell::edgeRemoveSelect(int i)

remove edges

Edges smaller than i are removed.

void cell::cropSharpAnglesSelect(int i)

crop sharp angles

Angles smaler than 90° are removed by inserting additional points

double cell::areaSelect()

area

The area of all selected elements is calculated.

double cell::circumferenceSelect()

area

The circumference of all selected elements is calculated.

double cell::circumferenceSelected()

area

The circumference of all elements is calculated.

double cell::areaSelected()

area

The area of all elements is calculated.

elementList* cell::nearestElement(point p)

nearest element

Returns:

the nearest element to the point p.

cell * cell::copy()

copy

Returns:

a copy of this cell

element* cell::addBox(int x,int y,int b, int h,int layer)

add box

A box is added to this cell. The box is defined by one of the corner points and the width and the height.  For positive width and height the point will be the lower left corner of the box.

Parameters:

Returns:

a pointer to the new element is returned.

element* cell::addRoundedBox(int x,int y,int b, int h,int radius, int layer)

add rounded box

A rectangular polygon with rounded corners is added to this cell. The polygon is defined by one of the corner points and the width and the height.  For positive width and height the point will be the lower left corner of the box.

Parameters:

Returns:

a pointer to the new element is returned.

element* cell::addBox(pointArray points,int layer)

add box

A box is added to this cell. The box is defined by an array of 5 points. The first and the last point have to be the same. If the box is rotated, a polygon is added instead of a box.

Parameters:

Returns:

a pointer to the new element is returned.

element* cell::addPolygon(pointArray points,int layer)

add polygon

A polygon is added to this cell.

element* cell::addPath(pointArray points,int layer)

add path

A path is added to this cell.

element* cell::addCellref(cell *c,point pos)

add cellref

A cellref is added to this cell.

element* cell::addCellrefArray(cell *c,pointArray array,int anzx,int anzy)

add cellrefarray

A cellrefarray is added to this cell.

element* cell::addCellrefArray(cell *c,point pos1,point pos2,int anzx,int anzy)

add cellrefarray

A cellrefarray is added to this cell.

element* cell::addText(int layer,point pos, string text)

add text

A test is added to this cell.

element* cell::addCircle(int layer,point center,int radius)

add circle

A circle is added to this cell.

element* cell::addEllipse(int layer,point center,int rx,int ry)

add ellipse

A ellipse is added to this cell.

element* cell::addCircleBox(point p1, point p2,int layer)

add circle

A circle is added to this cell. p1 and p2 are the edges of the bounding box.

void cell::group(cell *cell_)

group

Selected elements are moved to cell_

int cell::groupStructure(cell *cell_)

group structure

Searchs structures identical to cell_ and replace it with a cellref to this cell. The number of replaced structures is returned.

void cell::minimum(point *pos)

minimum

The minimum coordinates is returned, if less than pos.

void cell::maximum(point *pos)

maximum

The maximum coordinates is returned, if bigger than pos.

void cell::minimumSelect(point *pos)

minimum select

The minimum coordinates of all selected elements is returned, if bigger than pos..

void cell::maximumSelect(point *pos)

maximum select

The maximum coordinates of all selected elements is returned, if less than pos.

bool cell::depend(cell*Cell)

depend on

Returns:

true if this cell or its cellrefs has a cellref to Cell

bool cell::useCell(cell*Cell)

use cell

Returns:

true if this cell has a cellref to Cell

void cell::relink(cell*Cellold,cell*Cellnew)

relink

Cellreferences to Cellold are relink to Cellnew.

void cell::relinkSelect(cell*Cellnew)

relink select

Selected cellref are relinked to Cellnew.

bool cell::identical(cell*Cell)

identical

Returns:

true if this cell is identical to Cell; Non identical elements will be selected.

void cell::compare(cell*Cell)

compare

Tests, if this cell is the same as Cell. Non identical elements will be selected in both cells. All other elements will be deselected.

void cell::resize(double scale)

resize

Multiply all element with the factor scale.

void cell::deleteElement(element *e)

delete element

Delete the element e.

void cell::swapLayer(int i,int k)

swap layer

This function swap the layers i and k in the this cell.

void cell::swapLayerSelect(int i,int k)

swap layer select

This function swap the layers i and k of the selected elements in the this cell.

void cell::toBoxSelect()

select to box

Converts selected element to a box element if possible.

void cell::toPolygonSelect()

select to polygon

Converts selected element to a polygon if possible.

void cell::toBox()

to box

Converts element to a box element if possible.

void cell::toPolygon()

to polygon

Converts element to a polygon if possible.

void cell::toCircleSelect()

to circle select

Converts selected element polygon and box element to a circle. The circle is fitted in all existing points of the element.

void cell::closeToPolygonSelect()

close to polygon

Closes selected path elements to a polygon.

void cell::convertToPolygonIfClosedSelect()

convert to polygon if the path element is closed

Converts selected path elements to a polygon, if the first point is identical with the last point..

void cell::closeToPolygon()

close to polygon

Closes path elements to a polygon.

void cell::convertToPolygonIfClosed()

convert to polygon if the path element is closed

Converts all path elements to polygons, if the first point is identical with the last point..

void cell::setWidthSelect(int w)

set width

In selected path and text elements the width is set to w.

void cell::setCapSelect(int w)

set cap

In selected path elements the caps is set to w. (0 for no cap, 1 for round caps, 2 for square caps)

void cell::stripIdenticalElements()

strip identical elements

If a cell contains two identical elements at the same position, it is impossible to see it. This function will detect this and remove one of the element.

void cell::clearProperties()

clear properties

All properties in this cell are removed.

int cell::replaceText(string text1,string text2)

replace text

If text element are named text1, it is replaced with text2.

Returns:

number of replacements

void cell::flatLayer(int layer)

flat layer

All element on layer are flatten. They are not removed in the cell reference and double exists afterwards (in the cell and in the cell reference):

void cell::triangulateSelect(int layer)

triangulate select

Selected polygon are triangulated. The result is added to layer.

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