C/C++ Scripting Engine > Fab3000 Header File

The Fab3000 header file defines all the API Classes, Database Functions, UI Functions, Variables, Constants, and Other Functions used to talk directly with Fab3000.

Note: The Fab3000.h header file always contains the newest API calls, and should always be referenced in every Fab3000 script.

Note: The Fab3000.h header file is located in the Fab3000 installation folder .../scripts/include.

Note: The Fab3000.h header file is the most import file for the C/C scripting engine, and should never be modified in any way. If you need to define functions no you may create your own unique classes and header files, or contact technical support and we'll consider adding your requested feature.

//----------------------------------------------------------------------//

//Constant Types

//----------------------------------------------------------------------//

enum dbTypeEnum {

dbcUnknownType = 0,

dbcCellViewType = 1,

dbcLPPHeaderType = 2,

dbcLayerHeaderType = 3,

dbcArcType = 4,

dbcDonutType = 5,

dbcFlashType = 6,

dbcEllipseType = 7,

dbcLineType = 8,

dbcPathType = 9,

dbcPolygonType = 10,

dbcRectType = 11,

dbcTextType = 12,

dbcEvalTextType = 13,

dbcPropDisplayType = 14,

dbcAttrDisplayType = 15,

dbcTextOverrideType = 16,

dbcInstPropDisplayType = 17,

dbcInstAttrDisplayType = 18,

dbcInstHeaderType = 19,

dbcArrayInstType = 20,

dbcScalarInstType = 21,

dbcVectorInstType = 22,

dbcVectorInstDefType = 23,

dbcBundleNetType = 24,

dbcBusNetType = 25,

dbcBusNetBitType = 26,

dbcScalarNetType = 27,

dbcRepeatNetType = 28,

dbcBusNetDefType = 29,

dbcBundleTermType = 30,

dbcBusTermType = 31,

dbcBusTermBitType = 32,

dbcScalarTermType = 33,

dbcRepeatTermType = 34,

dbcBusTermDefType = 35,

dbcInstTermType = 36,

dbcInstPinType = 37,

dbcNetConnectDefType = 38,

dbcTermConnectDefType = 39,

dbcAssignValueType = 40,

dbcAssignAssignmentType = 41,

dbcRouteType = 42,

dbcMarkerType = 43,

dbcMarkerMemType = 44,

dbcTrackPatternType = 45,

dbcRowType = 46,

dbcRowHeaderType = 47,

dbcPinType = 48,

dbcClusterType = 49,

dbcCellViewBoundaryType = 50,

dbcPRBoundaryType = 51,

dbcSnapBoundaryType = 52,

dbcClusterBoundaryType = 53,

dbcBlockageType = 54,

dbcSteinerType = 55,

dbcSteinerPinType = 56,

dbcScanChainType = 57,

dbcScanChainInstType = 58,

dbcScanChainSetType = 59,

dbcStdViaHeaderType = 60,

dbcCustomViaHeaderType = 61,

dbcGCellPatternType = 62,

dbcCMapType = 63,

dbcStrongPinGroupType = 64,

dbcWeakPinGroupType = 65,

dbcAnalysisPointType = 66,

dbcAnalysisOpPointType = 67,

dbcOpPointHeaderType = 68,

dbcReducedDriverType = 69,

dbcParasiticNetworkType = 70,

dbcSubNetworkType = 71,

dbcSubNetworkMemType = 72,

dbcResistorType = 73,

dbcCouplingCapType = 74,

dbcInductorType = 75,

dbcDiodeType = 76,

dbcSeriesRLType = 77,

dbcMutualInductorType = 78,

dbcExternalDeviceType = 79,

dbcNodeType = 80,

dbcGroundedNodeType = 81,

dbcRouteSpecHeaderType = 82,

dbcGuideType = 83,

dbcLumpedElmoreType = 84,

dbcPiElmoreType = 85,

dbcPiPoleResidueType = 86,

dbcElmoreType = 87,

dbcPoleResidueType = 88,

dbcIntPropType = 89,

dbcIntRangePropType = 90,

dbcFloatPropType = 91,

dbcFloatRangePropType = 92,

dbcStringPropType = 93,

dbcAppPropType = 94,

dbcDoublePropType = 95,

dbcDoubleRangePropType = 96,

dbcBooleanPropType = 97,

dbcHierPropType = 98,

dbcTimePropType = 99,

dbcTimeRangePropType = 100,

dbcEnumPropType = 101,

dbcGroupType = 102,

dbcGroupMemberType = 103,

dbcTechType = 104,

dbcPhysicalLayerType = 105,

dbcDerivedLayerType = 106,

dbcPurposeType = 107,

dbcSiteDefType = 108,

dbcViaSpecType = 109,

dbcStdViaDefType = 110,

dbcCustomViaDefType = 111,

dbcOpPointType = 112,

dbcAnalysisLibType = 113,

dbcRouteSpecType = 114,

dbcDDLibType = 115,

dbcDDCellType = 116,

dbcDDViewType = 117,

dbcDDLibFileType = 118,

dbcDDCellFileType = 119,

dbcDDViewFileType = 120,

dbcDDObjectDBType = 121,

dbcAppObjectType = 122,

dbcBoolRuleType = 123,

dbcIntRuleType = 124,

dbcFloatRuleType = 125,

dbcIntParamRuleType = 126,

dbcFloatParamRuleType = 127,

dbcInt1DTblRuleType = 128,

dbcFloat1DTblRuleType = 129,

dbcInt2DTblRuleType = 130,

dbcFloat2DTblRuleType = 131,

dbcCurDensTblRuleType = 132,

dbcIntFltTblRuleType = 133,

dbcFltIntTblRuleType = 134,

dbcAntennaRuleType = 135

};

//----------------------------------------------------------------------//

enum dbOrientEnum

{

dbcR0 = 0,

dbcR90 = 1,

dbcR180 = 2,

dbcR270 = 3,

dbcMY = 4,

dbcMYR90 = 5,

dbcMX = 6,

dbcMXR90 = 7,

};

//----------------------------------------------------------------------//

enum dbPolarityEnum

{

dbcPolarityDark = 0,

dbcPolarityClear = 1,

};

//----------------------------------------------------------------------//

enum dbAlignmentEnum

{

dbcUpperLeft = 0,

dbcCenterLeft = 1,

dbcLowerLeft = 2,

dbcUpperCenter = 3,

dbcCenterCenter = 4,

dbcLowerCenter = 5,

dbcUpperRight = 6,

dbcCenterRight = 7,

dbcLowerRight = 8,

};

//----------------------------------------------------------------------//

enum dbPathStyleEnum

{

dbcTruncatePathStyle = 0,

dbcExtendPathStyle = 1,

dbcRoundPathStyle = 2,

};

//----------------------------------------------------------------------//

enum dbUnitsEnum

{

dbcMicron = 0,

dbcMillimeter = 1,

dbcCentimeter = 2,

dbcMeter = 3,

dbcMil = 4,

dbcInch = 5,

dbcNanometer = 6,

};

//----------------------------------------------------------------------//

enum dbSymmetryEnum

{

dbcSymmetryNone = 0,

dbcSymmetryX = 1,

dbcSymmetryY = 2,

dbcSymmetryXY = 3,

dbcSymmetryAny = 4,

};

//----------------------------------------------------------------------//

enum dbAnchorEnum

{

dbcAnchorLowerLeft = 0,

dbcAnchorCenter = 1,

dbcAnchorOrigin = 2,

};

//----------------------------------------------------------------------//

enum dbTeardropEnum

{

dbcTeardrop = 0,

dbcSnowman = 1,

};

//----------------------------------------------------------------------//

enum dbHomebaseEnum

{

dbcHomebaseInward = 0,

dbcHomebaseOutward = 1,

};

//----------------------------------------------------------------------//

enum dbCPadEnum

{

dbcCPadFlatInward = 0,

dbcCPadFlatOutward = 1,

dbcCPadPointedInward = 2,

dbcCPadPointedOutward = 3,

};

//----------------------------------------------------------------------//

enum dbDrillTypeEnum

{

dbcDrillTypePlated = 0,

dbcDrillTypeUnplated = 1,

};

//----------------------------------------------------------------------//

enum dbLayerType

{

dbcLayerTypeNone = 0,

dbcLayerTypeTop = 1,

dbcLayerTypeBottom = 2,

dbcLayerTypeInternal = 3,

dbcLayerTypeNegPlane = 4,

dbcLayerTypePosPlane = 5,

dbcLayerTypeNcPrimary = 6,

dbcLayerTypeNcSecondary = 7,

dbcLayerTypeSilkTop = 8,

dbcLayerTypeSilkBot = 9,

dbcLayerTypeMaskTop = 10,

dbcLayerTypeMaskBot = 11,

dbcLayerTypePasteTop = 12,

dbcLayerTypePasteBot = 13,

dbcLayerTypeRoutMill = 14,

dbcLayerTypeInsulator = 15,

dbcLayerTypeComponentsTop = 16,

dbcLayerTypeComponentsBot = 17,

dbcLayerTypeTemporary = 18,

dbcLayerTypeFab = 19,

dbcLayerTypeBorder = 20,

dbcLayerTypeScore = 21,

dbcLayerTypeGraphic = 22,

};

//----------------------------------------------------------------------//

enum dbApertureType

{

dbApertureTypeNone = 0,

dbApertureTypeCircle = 1,

dbApertureTypeDiamond = 2,

dbApertureTypeDonut = 3,

dbApertureTypeDonutSquare = 4,

dbApertureTypeOblong = 5,

dbApertureTypeRect = 6,

dbApertureTypeRectRounded = 7,

dbApertureTypeRectChamfered = 8,

dbApertureTypeTarget = 9,

dbApertureTypeThermal = 10,

dbApertureTypeThermalSquare = 11,

dbApertureTypeThermalSquareRound = 12,

dbApertureTypeThermalRectangle = 13,

dbApertureTypeTrapezoid = 14,

dbApertureTypeTriangle = 15,

dbApertureTypeButterfly = 16,

dbApertureTypeSquareButterfly = 17,

dbApertureTypeHexagon = 18,

dbApertureTypeHexagonHorizontal = 19,

dbApertureTypeHexagonVertical = 20,

dbApertureTypeOctagon = 21,

dbApertureTypeBullet = 22,

dbApertureTypeMoire = 23,

dbApertureTypeEllipse = 24,

dbApertureTypeCustom = 25,

dbApertureTypePoex = 26,

dbApertureTypePoin = 27,

dbApertureTypeDonutSquareRound = 28,

dbApertureTypeDonutRoundedSquare = 29,

dbApertureTypeDonutRectangle = 30,

dbApertureTypeDonutRoundedRectangle = 31,

dbApertureTypeDonutOval = 32,

dbApertureTypeThermalRoundedSquare = 33,

dbApertureTypeThermalRoundedRectangle = 34,

dbApertureTypeThermalOval = 35,

};

enum dbFileType

{

dbcFileTypeGerber = 0,

dbcFileTypeDrill = 1,

dbcFileTypeMill = 2,

dbcFileTypeDxf = 3,

dbcFileTypeOdb = 4,

dbcFileTypeIges = 5,

dbcFileTypeImage = 6,

dbcFileTypePostscript = 7,

dbcFileTypeHpgl = 8,

dbcFileTypeNetlist = 9,

dbcFileTypeCentroid = 10,

dbcFileTypeBom = 11,

dbcFileTypeCustomLib = 12,

dbcFileTypeText = 13,

dbcFileTypeTable = 14,

dbcFileTypeFolder = 15,

dbcFileTypeSimpleLib = 16,

dbcFileTypeLargeBitmap = 17,

};

//----------------------------------------------------------------------//

enum dbSuppressionEnum

{

dbcSuppressLeading = 0,

dbcSuppressTrailing = 1,

dbcSuppressNone = 2,

};

//----------------------------------------------------------------------//

enum dbDataType

{

dbcDataTypeNormal = 0,

dbcDataTypeIncremental = 1,

};

//----------------------------------------------------------------------//

enum dbClockwiseType

{

dbcClockwise = 0,

dbcCounterClockwise = 1,

};

//----------------------------------------------------------------------//

enum dbMessageBoxType

{

dbcMessageBoxError = 0,

dbcMessageBoxWarning = 1,

dbcMessageBoxQuestion = 2,

dbcMessageBoxInformation = 3,

};

//----------------------------------------------------------------------//

enum dbOutputPolygonType

{

dbcOutputTriangles = 0,

dbcOutputWithCutlines = 1,

dbcOutputWithoutCutlines = 2,

};

//----------------------------------------------------------------------//

enum dbPropertyDlgType

{

dbcPropertyDlgNone = 0,

dbcPropertyDlgEdit = 1,

dbcPropertyDlgCombo = 2,

dbcPropertyDlgCheck = 3,

dbcPropertyDlgColor = 4,

dbcPropertyDlgFile = 5,

dbcPropertyDlgDirectory = 6,

dbcPropertyDlgEditPoint = 7,

dbcPropertyDlgEditPathWidth = 8,

dbcPropertyDlgEditAngle = 9,

dbcPropertyDlgEditScale = 10,

dbcPropertyDlgEditColCnt = 11,

dbcPropertyDlgEditRowCnt = 12,

dbcPropertyDlgEditColSpace = 13,

dbcPropertyDlgEditRowSpace = 14,

dbcPropertyDlgEditTextHeight = 15,

dbcPropertyDlgEditTextXScale = 16,

dbcPropertyDlgEditTextString = 17,

dbcPropertyDlgEditBoxHeight = 18,

dbcPropertyDlgEditBoxWidth = 19,

dbcPropertyDlgComboLayer = 20,

dbcPropertyDlgComboLayerMarkup = 21,

dbcPropertyDlgComboLayerBoolean = 22,

dbcPropertyDlgComboLayerType = 23,

dbcPropertyDlgComboComposite = 24,

dbcPropertyDlgComboNotComposite = 25,

dbcPropertyDlgComboUnits = 26,

dbcPropertyDlgComboPoints = 27,

dbcPropertyDlgComboPathType = 28,

dbcPropertyDlgComboShape = 29,

dbcPropertyDlgComboInsert = 30,

dbcPropertyDlgComboTextStyle = 31,

dbcPropertyDlgComboTextJustify = 32,

dbcPropertyDlgComboTextExternal = 33,

dbcPropertyDlgComboTextFonts = 34,

dbcPropertyDlgComboRouteElements = 35,

dbcPropertyDlgComboOrient = 36,

dbcPropertyDlgComboCellviewType = 37,

dbcPropertyDlgComboLibs = 38,

dbcPropertyDlgComboCells = 39,

dbcPropertyDlgComboJobs = 40,

dbcPropertyDlgComboViews = 41,

dbcPropertyDlgComboTechs = 42,

dbcPropertyDlgComboMaterial = 43,

dbcPropertyDlgComboRouteDir = 44,

dbcPropertyDlgComboLayerOP = 45,

dbcPropertyDlgComboFindType = 46,

dbcPropertyDlgComboPrinters = 47,

dbcPropertyDlgComboApertures = 48,

dbcPropertyDlgComboAperturesCustom = 49,

dbcPropertyDlgComboCompLevel = 50,

dbcPropertyDlgComboComponents = 51,

dbcPropertyDlgComboFootprints = 52,

dbcPropertyDlgComboTools = 53,

dbcPropertyDlgComboToolCompensation = 54,

dbcPropertyDlgComboClockwise = 55,

dbcPropertyDlgComboWizardName = 56,

dbcPropertyDlgComboNets = 57,

dbcPropertyDlgPopupLayerSelection = 58,

dbcPropertyDlgPopupLayerSelectionAdvanced = 59,

dbcPropertyDlgPopupPointSelection = 60,

dbcPropertyDlgPopupComboLibs = 61,

dbcPropertyDlgPopupComboCells = 62,

dbcPropertyDlgPopupPoints = 63,

};

//----------------------------------------------------------------------//

// Class Declarations

//----------------------------------------------------------------------//

class dbIntArray;

class dbFloatArray;

class dbObjectArray;

class dbStringArray;

class dbPointArray;

class dbSelectionSet;

class dbDlgProperty;

class dbPoint;

class dbBox;

class dbAperture;

class dbNCTool;

class dbLayer;

class dbImportDxf;

class dbImportImage;

class dbImportGerber;

class dbImportDrill;

class dbImportOdb;

class dbExportDxf;

class dbExportIges;

class dbExportGerber;

class dbExportDrill;

class dbExportOdb;

class dbDrcSettings;

//----------------------------------------------------------------------//

// Typedefs

//----------------------------------------------------------------------//

typedef void* dbObject;

//----------------------------------------------------------------------//

// Classes

//----------------------------------------------------------------------//

class dbIntArray

{

#ifndef _CH_

private:

void *pArray;

#endif

public:

dbIntArray();

~dbIntArray();

void append( int value );

void prepend( int value );

void clear();

int no();

int find( int value );

int rfind( int value );

void insert( int pos, int value );

void remove( int pos );

int index( int pos );

void* data();

};

//----------------------------------------------------------------------//

class dbFloatArray

{

#ifndef _CH_

private:

void *pArray;

#endif

public:

dbFloatArray();

~dbFloatArray();

void append( float value );

void prepend( float value );

void clear();

int no();

int find( float value );

int rfind( float value );

void insert( int pos, float value );

void remove( int pos );

float index( int pos );

void* data();

};

//----------------------------------------------------------------------//

class dbStringArray

{

#ifndef _CH_

private:

void *pArray;

#endif

public:

dbStringArray();

~dbStringArray();

void append( char* value );

void prepend( char* value );

void clear();

int no();

int find( char* value );

int rfind( char* value );

void insert( int pos, char* value );

void remove( int pos );

char* index( int pos );

void* data();

};

//----------------------------------------------------------------------//

class dbObjectArray

{

#ifndef _CH_

private:

void *pArray;

#endif

public:

dbObjectArray();

~dbObjectArray();

void append( dbObject value );

void prepend( dbObject value );

void clear();

int no();

int find( dbObject value );

int rfind( dbObject value );

void insert( int pos, dbObject value );

void remove( int pos );

dbObject index( int pos );

void* data();

};

//----------------------------------------------------------------------//

class dbPointArray

{

#ifndef _CH_

private:

void *pArray;

#endif

public:

dbPointArray();

~dbPointArray();

void append( dbPoint *pt );

void appendPt( float x, float y );

int no();

void clear();

int isSelfIntersecting( int isClosed );

int isOrthogonal( int isClosed );

int isRectangle();

int onEdge( dbPoint point, int isClosed );

int contains( dbPoint point, int includeEdges );

int overlaps( dbBox box );

float distanceFrom2( dbPoint point );

float getArea();

int hasExtraPoints( int isClosed );

void compress( int isClosed );

void transform( float scale, float angle );

void getBBox( dbBox &box );

void index( int pos, dbPoint *pt );

void* getPointArray();

};

//----------------------------------------------------------------------//

class dbSelectionSet

{

#ifndef _CH_

private:

void *pArray;

dbIntArray layerFilter;

dbIntArray typeFilter;

dbIntArray dcodeFilter;

dbStringArray netFilter;

#endif

public:

dbSelectionSet();

~dbSelectionSet();

//Figure Functions

void append( dbObject entity );

void prepend( dbObject entity );

void clear();

int no();

int find( dbObject entity );

int rfind( dbObject entity );

void insert( int pos, dbObject entity );

void remove( int pos );

dbObject index( int pos );

//Selection Set Functions

int selectionCallback ();

int selectAll ();

int selectSelected ();

int selectPoint ( float x, float y );

int selectWindow ( dbPoint pt1, dbPoint pt2 );

int selectCrossing ( dbPoint pt1, dbPoint pt2 );

int selectFence ( dbPointArray* pts );

int selectWindowPolygon ( dbPointArray* pts );

int selectCrossingPolygon( dbPointArray* pts );

void setLayerFilter ( dbIntArray* pFilter );

void setTypeFilter ( dbIntArray* pFilter );

void setDcodeFilter ( dbIntArray* pFilter );

void setNetFilter ( dbStringArray* pFilter );

//Get Functions

void* getFigureData ();

dbIntArray* getLayerFilter ();

dbIntArray* getTypeFilter ();

dbIntArray* getDcodeFilter ();

dbStringArray* getNetFilter ();

};

//----------------------------------------------------------------------//

class dbPoint

{

#ifndef _CH_

private:

float x;

float y;

public:

dbPoint();

dbPoint( float xVal, float yVal );

#else

//Multiple Construction Definition

public:

dbPoint(...);

#endif

public:

~dbPoint();

float getX ();

float getY ();

void setX ( float xVal );

void setY ( float yVal );

void set ( float xVal, float yVal );

};

//----------------------------------------------------------------------//

class dbBox

{

#ifndef _CH_

private:

float left;

float top;

float right;

float bottom;

public:

dbBox();

dbBox( dbPoint p1, dbPoint p2 );

dbBox( float _left, float _top, float _right, float _bottom );

~dbBox();

#else

public:

dbBox(...);

~dbBox();

#endif

float getLeft();

float getTop();

float getBottom();

float getRight();

float getWidth();

float getHeight();

void setLeft( float val );

void setTop( float val );

void setBottom( float val );

void setRight( float val );

void setEmpty();

void normalize();

void setCenterWidthHeight( dbPoint cen, float width, float height );

void getCenter( dbPoint* cen );

int isEqual( dbBox& src );

int isRectEmpty();

};

//----------------------------------------------------------------------//

class dbAperture

{

#ifndef _CH_

private:

int shape_type;

float width;

float height;

float od;

float id;

float base;

float top;

float delta;

char *sCustom;

float rotate;

float scaleX;

float scaleY;

float compensation;

int mirror;

int crosshairCount;

float crosshairThick;

float crosshairLength;

//Rectangle Shape

float rectRadius;

int rectCorner_ur;

int rectCorner_ul;

int rectCorner_ll;

int rectCorner_lr;

//Thermal

float spokeAngle;

int thermalOpenEnds;

float thermalAirGap;

//Moire

float moireRingWidth;

float moireRingGap;

int moireRingCount;

float moireLineWidth;

float moireLineLength;

#endif

public:

dbAperture();

~dbAperture();

int getType();

float getWidth();

float getHeight();

float getOD();

float getID();

float getBase();

float getTop();

float getDelta();

char* getCustomName();

float getRotation();

float getScaleX();

float getScaleY();

float getCompensation();

int isMirror();

int getCrosshairCount();

float getCrosshairThick();

float getCrosshairLength();

float getRectRadius();

int getRectCorner_ur();

int getRectCorner_ul();

int getRectCorner_ll();

int getRectCorner_lr();

float getSpokeAngle();

int getThermalOpenEnds();

float getThermalAirGap();

float getMoireRingWidth();

float getMoireRingGap();

int getMoireRingCount();

float getMoireLineWidth();

float getMoireLineLength();

void setType( int val );

void setWidth( float val );

void setHeight( float val );

void setOD( float val );

void setID( float val );

void setBase( float val );

void setTop( float val );

void setDelta( float val );

void setCustomName( char* val );

void setRotation( float val );

void setScaleX( float val );

void setScaleY( float val );

void setCompensation( float val );

void setMirror( int val );

void setCrosshairCount( int val );

void setCrosshairThick( float val );

void setCrosshairLength( float val );

void setRectRadius( float val );

void setRectCorner_ur( int val );

void setRectCorner_ul( int val );

void setRectCorner_ll( int val );

void setRectCorner_lr( int val );

void setSpokeAngle( float val );

void setThermalOpenEnds( int val );

void setThermalAirGap( float val );

void setMoireRingWidth( float val );

void setMoireRingGap( float val );

void setMoireRingCount( int val );

void setMoireLineWidth( float val );

void setMoireLineLength( float val );

};

//----------------------------------------------------------------------//

class dbNCTool

{

#ifndef _CH_

private:

int index;

int plated;

float od;

float size;

float comp;

float feed;

float speed;

float zaxis;

float tab;

char* sComments;

#endif

public:

dbNCTool();

~dbNCTool();

int getIndex();

int isPlated();

float getOD();

float getSize();

float getComp();

float getFeed();

float getSpeed();

float getZAxis();

float getTab();

char* getComments();

void setIndex( int val );

void setPlated( int val );

void setOD( float val );

void setSize( float val );

void setComp( float val );

void setFeed( float val );

void setSpeed( float val );

void setZAxis( float val );

void setTab( float val );

void setComments( char* val );

};

//----------------------------------------------------------------------//

class dbLayer

{

#ifndef _CH_

private:

int nVisible;

int nLock;

int nMarkup;

int nNegative;

int nMirror;

int nColor;

int nFlashColor;

int nType;

int nPriority;

char* sName;

#endif

public:

dbLayer();

~dbLayer();

int isVisible();

int isLocked();

int isMarkup();

int isNegative();

int isMirror();

int getDrawColor();

int getFlashColor();

int getType();

int getPriority();

char* getName();

void setVisible( int val );

void setLocked( int val );

void setMarkup( int val );

void setNegative( int val );

void setMirror( int val );

void setDrawColor( int val );

void setFlashColor( int val );

void setType( int val );

void setPriority( int val );

void setName( char* val );

};

//----------------------------------------------------------------------//

class dbImportDxf

{

#ifndef _CH_

private:

char *filename;

int nUnits;

float fScale;

int nTraceMode;

int nFillMode;

int nIgnoreHatch;

int nDeEmbedMode;

int nByBlock;

int nIgnoreDimension;

int nJoin;

float fLineWidth;

float fTextWidth;

float fTextRatio;

float fArcDeviation;

int nScan;

#endif

public:

dbImportDxf();

~dbImportDxf();

char* getFileName();

int getUnits();

float getScale();

int getTraceMode();

int getFillMode();

int getIgnoreHatch();

int getDeEmbedMode();

int getByBlock();

int getIgnoreDimension();

int getJoin();

int getScan();

float getLineWidth();

float getTextWidth();

float getTextRatio();

float getArcDeviation();

void setFileName( char *value );

void setUnits( int value );

void setScale( float value );

void setTraceMode( int value );

void setFillMode(int value );

void setIgnoreHatch(int value );

void setDeEmbedMode(int value );

void setByBlock(int value );

void setIgnoreDimension(int value );

void setJoin(int value );

void setScan(int value );

void setLineWidth(float value );

void setTextWidth(float value );

void setTextRatio(float value );

void setArcDeviation(float value );

};

//----------------------------------------------------------------------//

class dbImportOdb

{

#ifndef _CH_

private:

char *filename;

char *foldername;

int nUnits;

int nScan;

int nLoadFolder;

#endif

public:

dbImportOdb();

~dbImportOdb();

char* getFileName();

char* getFolderName();

int getUnits();

int isScan();

int isLoadFolder();

void setFileName( char *value );

void setFolderName( char *value );

void setUnits( int value );

void setScan( int value );

void setLoadFolder( int value );

};

//----------------------------------------------------------------------//

class dbImportImage

{

#ifndef _CH_

private:

char *filename;

char *cellname;

int nUnits;

char *color;

float pixelsize;

int nFactor;

#endif

public:

dbImportImage();

~dbImportImage();

char* getFileName();

char* getCellName();

int getUnits();

char* getColor();

float getPixelSize();

int getBackgroundRecognitionFactor();

void setFileName( char *value );

void setCellName( char *value );

void setUnits( int value );

void setColor( char *value );

void setPixelSize( float value );

void setBackgroundRecognitionFactor( int value );

};

//----------------------------------------------------------------------//

class dbImportGerber

{

#ifndef _CH_

public:

char *sJobname;

int nArc360;

int nMirrorInput;

int nEndAtNewline;

int nMaxBlockSize;

int nUnits;

int nInteger;

int nDecimal;

int nType;

int nSuppression;

dbStringArray arFileNames;

dbIntArray fileTypes;

#endif

public:

dbImportGerber();

~dbImportGerber();

void setJobName( char *value );

void set360Arc( int value );

void setMirrorInput( int value );

void setEndAtNewline( int value );

void setMaxBlockSize( int value );

void setUnits( int value );

void setInteger( int value );

void setDecimal( int value );

void setType( int value );

void setSuppression( int value );

void addFileName( char *file_name, int file_type );

void clearAll();

//Internal Use Only

char* getJobName();

int get360Arc();

int getMirrorInput();

int getEndAtNewline();

int getMaxBlockSize();

int getUnits();

int getInteger();

int getDecimal();

int getType();

int getSuppression();

};

//----------------------------------------------------------------------//

class dbImportDrill

{

#ifndef _CH_

public:

char *sJobname;

int nUnits;

int nInteger;

int nDecimal;

int nType;

int nSuppression;

dbStringArray arFileNames;

#endif

public:

dbImportDrill();

~dbImportDrill();

void setJobName( char *value );

void setUnits( int value );

void setInteger( int value );

void setDecimal( int value );

void setType( int value );

void setSuppression( int value );

void addFileName( char *file_name );

void clearAll();

//Internal Use Only

char* getJobName();

int getUnits();

int getInteger();

int getDecimal();

int getType();

int getSuppression();

};

//----------------------------------------------------------------------//

class dbExportDxf

{

#ifndef _CH_

private:

char *filename;

char *topcell;

int nCreateOutlinesForPaths;

int nFlattenHierarchy;

int nFlattenCompositeLayers;

#endif

public:

dbExportDxf();

~dbExportDxf();

char* getFileName();

char* getTopCellName();

int getCreateOutlinesForPaths();

int getFlattenHierarchy();

int getFlattenCompositeLayers();

void setFileName( char *value );

void setTopJobName( char *value );

void setCreateOutlinesForPaths( int value );

void setFlattenHierarchy(int value );

void setFlattenCompositeLayers(int value );

};

//----------------------------------------------------------------------//

class dbExportIges

{

#ifndef _CH_

public:

char *filename;

char *topcell;

char *version;

int nUnits;

int nTextMode;

int nPathMode;

#endif

public:

dbExportIges();

~dbExportIges();

void setFileName( char *value );

void setTopJobName( char *value );

void setVersion( char *value );

void setUnits( int value );

void setTextMode( int value );

void setPathMode(int value );

};

//----------------------------------------------------------------------//

class dbExportGerber

{

#ifndef _CH_

public:

char *sExportfolder;

char *sJobname;

int nUnits;

int nInteger;

int nDecimal;

int nType;

int nSuppression;

int nGbrFormat;

int ArcG75;

int StepRepeat;

char *Extension;

dbStringArray arFileNames;

dbIntArray arFileNegative;

dbIntArray arFileMirror;

#endif

public:

dbExportGerber();

~dbExportGerber();

void setExportFolder( char *value );

void setJobName( char *value );

void setUnits( int value );

void setInteger( int value );

void setDecimal( int value );

void setType( int value );

void setSuppression( int value );

void setFormat( int value );

void setArcG75( int value );

void setStepRepeat( int value );

void setExtension( char *value );

void addExportLayer( char *layer, int mirror, int negative );

void clearAll();

};

//----------------------------------------------------------------------//

class dbExportDrill

{

#ifndef _CH_

public:

char *sExportfolder;

char *sJobname;

int nUnits;

int nInteger;

int nDecimal;

int nType;

int nSuppression;

int StepRepeat;

char *Extension;

dbStringArray arFileNames;

#endif

public:

dbExportDrill();

~dbExportDrill();

void setExportFolder( char *value );

void setJobName( char *value );

void setUnits( int value );

void setInteger( int value );

void setDecimal( int value );

void setType( int value );

void setSuppression( int value );

void setStepRepeat( int value );

void setExtension( char *value );

void addExportLayer( char *layer );

void clearAll();

};

//----------------------------------------------------------------------//

class dbExportOdb

{

#ifndef _CH_

public:

char *sExportfolder;

char *sExportfile;

char *sJobname;

int nUnits;

int nOutputProfile;

int nSymbolsAsBoundaries;

dbStringArray arLayerNames;

#endif

public:

dbExportOdb();

~dbExportOdb();

void setExportFolder( char *value );

void setExportFile( char *value );

void setJobName( char *value );

void setUnits( int value );

void setOutputProfile( int value );

void setSymbolsAsBoundaries( int value );

void addExportLayer( char *layer );

void clearAll();

};

//----------------------------------------------------------------------//

class dbDrcSettings

{

#ifndef _CH_

private:

dbBox boxSearchArea;

int nMissingLayerCheck;

char *sDcodeFilter;

char *sTextErrorFile;

dbFloatArray arSignalValues;

dbFloatArray arPlaneValues;

dbFloatArray arSilkValues;

dbFloatArray arDrillValues;

dbFloatArray arMaskValues;

dbIntArray arSignalCheck;

dbIntArray arPlaneCheck;

dbIntArray arSilkCheck;

dbIntArray arDrillCheck;

dbIntArray arMaskCheck;

dbIntArray arSignalFix;

dbIntArray arPlaneFix;

dbIntArray arSilkFix;

dbIntArray arDrillFix;

dbIntArray arMaskFix;

#endif

public:

dbDrcSettings();

~dbDrcSettings();

void setSearchArea( dbBox box );

void setMissingLayerCheck( int nLayerCheck );

void setDcodeFilter( char* sFilter );

void setTextErrorFile( char* sErrorFile );

void setCheckMinimumPadSize( int value );

void setMinimumPadSize( float value );

void setFixMinimumPadSize( int value );

void setCheckMinimumSMTPadWidth( int value );

void setMinimumSMTPadWidth( float value );

void setFixMinimumSMTPadWidth( int value );

void setCheckMinimumTraceWidth( int value );

void setMinimumTraceWidth( float value );

void setFixMinimumTraceWidth( int value );

void setCheckMinimumSpacingOuterLayers( int value );

void setMinimumSpacingOuterLayers( float value );

void setFixMinimumSpacingOuterLayers( int value );

void setCheckMinimumSpacingInnerLayers( int value );

void setMinimumSpacingInnerLayers( float value );

void setFixMinimumSpacingInnerLayers( int value );

void setCheckMinimumAnnularRing( int value );

void setMinimumAnnularRing( float value );

void setFixMinimumAnnularRing( int value );

void setCheckClearancefromBoardEdge( int value );

void setClearancefromBoardEdge( float value );

void setFixClearancefromBoardEdge( int value );

void setCheckFindAcidTraps( int value );

void setFindAcidTraps( float value );

void setFixFindAcidTraps( int value );

void setCheckFindNonFunctionalPadsInnerLayers( int value );

void setFixFindNonFunctionalPadsInnerLayers( int value );

void setCheckMinimumDrillSize( int value );

void setMinimumDrillSize( float value );

void setFixMinimumDrillSize( int value );

void setCheckFindDoubleHits( int value );

void setFixFindDoubleHits( int value );

void setCheckFindMissingHits( int value );

void setFixFindMissingHits( int value );

void setCheckFindMissingPadsforPlatedDrillHits( int value );

void setFixFindMissingPadsforPlatedDrillHits( int value );

void setCheckFindTouchingHoles( int value );

void setFixFindTouchingHoles( int value );

void setCheckMinimumSilkscreenLineWidth( int value );

void setMinimumSilkscreenLineWidth( float value );

void setFixMinimumSilkscreenLineWidth( int value );

void setCheckFindSilkscreenoverSoldermask( int value );

void setFindSilkscreenoverSoldermask( float value );

void setFixFindSilkscreenoverSoldermask( int value );

void setCheckSilkClearancefromBoardEdge( int value );

void setSilkClearancefromBoardEdge( float value );

void setFixSilkClearancefromBoardEdge( int value );

void setCheckLocateUndersizedMaskClearances( int value );

void setLocateUndersizedMaskClearances( float value );

void setFixLocateUndersizedMaskClearances( int value );

void setCheckLocateMissingMaskClearances( int value );

void setFixLocateMissingMaskClearances( int value );

void setCheckFindMaskSlivers( int value );

void setFixFindMaskSlivers( int value );

void setCheckFindSolderBridges( int value );

void setFindSolderBridges( float value );

void setFixFindSolderBridges( int value );

void setCheckInnerClearanceDrilltofeature( int value );

void setInnerClearanceDrilltofeature( float value );

void setFixInnerClearanceDrilltofeature( int value );

void setCheckPowerGroundMinimumAnnularRing( int value );

void setPowerGroundMinimumAnnularRing( float value );

void setFixPowerGroundMinimumAnnularRing( int value );

void setCheckFindStarvedThermals( int value );

void setFindStarvedThermals( float value );

void setFixFindStarvedThermals( int value );

void setCheckPowerGroundShort( int value );

void setFixPowerGroundShort( int value );

void setCheckNegPlaneThermalConflicts( int value );

void setFixNegPlaneThermalConflicts( int value );

void setCheckFindIsolatedConnections( int value );

void setFixFindIsolatedConnections( int value );

/////////////////////////////////////////////////////////

void getSearchArea( dbBox* box );

void getMissingLayerCheck( int* nLayerCheck );

void getDcodeFilter( char* sFilter );

void getTextErrorFile( char* sErrorFile );

void getCheckMinimumPadSize( int* value );

void getMinimumPadSize( float* value );

void getFixMinimumPadSize( int* value );

void getCheckMinimumSMTPadWidth( int* value );

void getMinimumSMTPadWidth( float* value );

void getFixMinimumSMTPadWidth( int* value );

void getCheckMinimumTraceWidth( int* value );

void getMinimumTraceWidth( float* value );

void getFixMinimumTraceWidth( int* value );

void getCheckMinimumSpacingOuterLayers( int* value );

void getMinimumSpacingOuterLayers( float* value );

void getFixMinimumSpacingOuterLayers( int* value );

void getCheckMinimumSpacingInnerLayers( int* value );

void getMinimumSpacingInnerLayers( float* value );

void getFixMinimumSpacingInnerLayers( int* value );

void getCheckMinimumAnnularRing( int* value );

void getMinimumAnnularRing( float* value );

void getFixMinimumAnnularRing( int* value );

void getCheckClearancefromBoardEdge( int* value );

void getClearancefromBoardEdge( float* value );

void getFixClearancefromBoardEdge( int* value );

void getCheckFindAcidTraps( int* value );

void getFindAcidTraps( float* value );

void getFixFindAcidTraps( int* value );

void getCheckFindNonFunctionalPadsInnerLayers( int* value );

void getFixFindNonFunctionalPadsInnerLayers( int* value );

void getCheckMinimumDrillSize( int* value );

void getMinimumDrillSize( float* value );

void getFixMinimumDrillSize( int* value );

void getCheckFindDoubleHits( int* value );

void getFixFindDoubleHits( int* value );

void getCheckFindMissingHits( int* value );

void getFixFindMissingHits( int* value );

void getCheckFindMissingPadsforPlatedDrillHits( int* value );

void getFixFindMissingPadsforPlatedDrillHits( int* value );

void getCheckFindTouchingHoles( int* value );

void getFixFindTouchingHoles( int* value );

void getCheckMinimumSilkscreenLineWidth( int* value );

void getMinimumSilkscreenLineWidth( float* value );

void getFixMinimumSilkscreenLineWidth( int* value );

void getCheckFindSilkscreenoverSoldermask( int* value );

void getFindSilkscreenoverSoldermask( float* value );

void getFixFindSilkscreenoverSoldermask( int* value );

void getCheckSilkClearancefromBoardEdge( int* value );

void getSilkClearancefromBoardEdge( float* value );

void getFixSilkClearancefromBoardEdge( int* value );

void getCheckLocateUndersizedMaskClearances( int* value );

void getLocateUndersizedMaskClearances( float* value );

void getFixLocateUndersizedMaskClearances( int* value );

void getCheckLocateMissingMaskClearances( int* value );

void getFixLocateMissingMaskClearances( int* value );

void getCheckFindMaskSlivers( int* value );

void getFixFindMaskSlivers( int* value );

void getCheckFindSolderBridges( int* value );

void getFindSolderBridges( float* value );

void getFixFindSolderBridges( int* value );

void getCheckInnerClearanceDrilltofeature( int* value );

void getInnerClearanceDrilltofeature( float* value );

void getFixInnerClearanceDrilltofeature( int* value );

void getCheckPowerGroundMinimumAnnularRing( int* value );

void getPowerGroundMinimumAnnularRing( float* value );

void getFixPowerGroundMinimumAnnularRing( int* value );

void getCheckFindStarvedThermals( int* value );

void getFindStarvedThermals( float* value );

void getFixFindStarvedThermals( int* value );

void getCheckPowerGroundShort( int* value );

void getFixPowerGroundShort( int* value );

void getCheckNegPlaneThermalConflicts( int* value );

void getFixNegPlaneThermalConflicts( int* value );

void getCheckFindIsolatedConnections( int* value );

void getFixFindIsolatedConnections( int* value );

};

//----------------------------------------------------------------------//

class dbDlgProperty

{

#ifndef _CH_

private:

void *pDlgTable;

#endif

public:

dbDlgProperty();

~dbDlgProperty();

void setWidth( int val );

void setHeight( int val );

void setTitle( char* sCaption );

void setColumnWidth( int val );

void addPropertyRow( int nItemType, char* sCaption, char* sDefault, dbStringArray* pComboItems );

void getItemText( int nRow, char* sValue );

int getItemCheck( int nRow );

int execute();

};

//----------------------------------------------------------------------//

// Global Function Definitions

//----------------------------------------------------------------------//

void princ( char* sMessage );

void beginWaitCursor();

void endWaitCursor();

int ColortoInt( int R, int G, int B );

int inputDialog( char* sCaption, char* sLabel, char* sResult );

int fileDialog( char* sCaption, char* sPatternList, char* sFile );

int directoryDialog( char* sCaption, char* sPath );

int messageBox( char* sCaption, char* sLabel, int mode );

//----------------------------------------------------------------------//

// Database Definitions

//----------------------------------------------------------------------//

int dbGetType ( dbObject obj );

int dbIsValid ( dbObject obj );

int dbIsInstance ( dbObject obj );

int dbHasPin ( dbObject obj );

dbObject dbGetPin ( dbObject obj );

dbObject dbGetJob ( char* jobname, char mode );

dbObject dbGetActiveJob ();

int dbGetBBox ( dbObject obj, dbBox *box );

int dbGetOutline ( dbObject obj, dbPointArray *pts );

void dbSetActiveLayer ( int layer );

void dbSetActiveDcode ( int dcode );

void dbSetActiveTool ( int tool );

void dbSetActiveEip ( int eip );

void dbSetActiveMarkupLayer ( int markuplayer );

void dbSetActiveComponent ( int component );

void dbSetActivePanelize ( int panelize );

int dbGetActiveLayer ();

int dbGetActiveDcode ();

int dbGetActiveTool ();

int dbGetActiveEip ();

int dbGetActiveMarkupLayer ();

int dbGetActiveComponent ();

int dbGetActivePanelize ();

void dbGetHomeDirectory ( char* sDirectory );

void dbGetTempDirectory ( char* sDirectory );

void dbGetCurrentDirectory ( char* sDirectory );

void dbGetExportDirectory ( char* sDirectory );

void dbSetExportDirectory ( char* sDirectory );

//Transform

void dbDestroy ( dbObject obj );

void dbTransform ( dbObject obj, float scale, float angle );

void dbMove ( dbObject obj, float xOffset, float yOffset, int orient );

void dbCopy ( dbObject obj, float xOffset, float yOffset, int orient );

void dbMoveToJob ( dbObject obj, float xOffset, float yOffset, int orient, dbObject job );

void dbCopyToJob ( dbObject obj, float xOffset, float yOffset, int orient, dbObject job );

//Units

float dbGetDBUPerUU ();

int dbGetUserUnits ();

void dbSetDBUPerUU ( float dbu );

void dbSetUserUnits ( int units );

//Layers

void dbSetLayerAllOn ();

void dbSetLayerAllOff ();

void dbGetLayer ( int layer_num, dbLayer *layer );

void dbGetLayerByName ( char* layer_name, dbLayer *layer );

void dbSetLayer ( int layer_num, dbLayer *layer );

void dbSetLayerByName ( char* layer_name, dbLayer *layer );

int dbFindLayer ( dbLayer *layer );

int dbAddLayer ( dbLayer *layer );

int dbIsLayerEmpty ( int layer_num );

void dbGetAllLayerNames ( dbStringArray* layers );

void dbGetAllLayerNumbers( dbIntArray* layers );

int dbGetLayerNum ( dbObject obj );

int dbSetLayerNum ( dbObject obj, int layer );

//Jobs/Pages

void dbGetJobs ( dbStringArray* jobs );

void dbGetOpenJobs ( dbStringArray* jobs );

void dbGetPanels ( dbStringArray* panels );

void dbGetOpenPanels ( dbStringArray* panels );

//PDF Reports

void dbGeneratePdfDfmViolations ( char* filename, char* description, int units );

void dbGeneratePdfNetErrors ( char* filename, char* description, int units );

void dbGeneratePdfJoinErrors ( char* filename, char* description, int units );

//Dcodes/Apertures

void dbGetAperture ( int dcode_num, dbAperture *aperture );

void dbSetAperture ( int dcode_num, dbAperture *aperture );

int dbFindDcode ( dbAperture *aperture );

int dbIsDcodeEmpty ( int dcode_num );

//NC Tool

void dbGetNCTool ( int tool_num, dbNCTool *tool );

void dbSetNCTool ( int tool_num, dbNCTool *tool );

int dbFindNCTool ( dbNCTool *tool );

int dbIsNCToolEmpty ( int tool_num );

//Composites

int dbGetCompositeNum ( dbObject obj );

int dbSetCompositeNum ( dbObject obj, int composite );

//Nets

int dbHasNet ( dbObject obj );

dbObject dbGetNet ( dbObject obj );

void dbAddToNet ( dbObject obj, dbObject net );

//Database Functions

int dbOpenJob ( char* job );

int dbCopyJob ( char* src_job, char* dst_job );

int dbScanDxf ( dbImportDxf* options, dbStringArray* layers, dbStringArray* cells, dbStringArray* styles );

int dbScanOdb ( dbImportOdb* options, dbStringArray* layers, dbStringArray* steps );

//----------------------------------------------------------------------//

// User Interface Definitions

//----------------------------------------------------------------------//

int uiFileNewJob ( char* job );

int uiFileNewPanel ( char* panel, int units, float width, float height );

int uiFileOpenWorkspace ( char* filename );

int uiFileCloseWorkspace ();

int uiFileSaveWorkspace ();

int uiFileSaveWorkspaceAs ( char* filename );

int uiFileSave ();

int uiFileImportDXF ( dbImportDxf* options );

int uiFileImportOdb ( dbImportOdb* options );

int uiFileImportImage ( dbImportImage* options );

int uiFileImportPostscript ( char* filename, float fScale );

int uiFileImportZip ( char* filename, int nFileType );

int uiFileImportGerber ( dbImportGerber* options );

int uiFileImportDrill ( dbImportDrill* options );

int uiFileExportDXF ( dbExportDxf* options );

int uiFileExportIGES ( dbExportIges* options );

int uiFileExportImage ( char* filename, char* units, float fScale );

int uiFileExportPostscript ( char* foldername, float fScale );

int uiFileExportGerber ( dbExportGerber* options );

int uiFileExportDrill ( dbExportDrill* options );

int uiFileExportOdb ( dbExportOdb* options );

int uiEditDelete ( dbSelectionSet* sset );

int uiEditMove ( dbSelectionSet* sset, dbPoint* offset );

int uiEditCopy ( dbSelectionSet* sset, dbPoint* offset );

int uiEditCopyToLayers ( dbSelectionSet* sset, dbIntArray* layers );

int uiEditMirrorHorizontal ( dbSelectionSet* sset, dbPoint* refPt );

int uiEditMirrorVertical ( dbSelectionSet* sset, dbPoint* refPt );

int uiEditRotate ( dbSelectionSet* sset, float angle, dbPoint* cenPt );

int uiEditArray ( dbSelectionSet* sset, int nCols, int nRows, float fColDistance, float fRowDistance );

int uiEditScale ( dbSelectionSet* sset, float scale, dbPoint* cenPt );

int uiEditDeEmbed ( dbSelectionSet* sset );

int uiEditBoolAdd ( dbSelectionSet* sset );

int uiEditBoolSubtract ( dbSelectionSet* sset );

int uiEditBoolIntersect ( dbSelectionSet* sset );

int uiEditBoolDifference ( dbSelectionSet* sset );

int uiEditExplodeAll ( dbSelectionSet* sset );

int uiEditAddLayer ( char* lname, int nLayer );

int uiEditDeleteLayer ( int nLayer );

int uiEditDeleteLayerName ( char* lname );

int uiEditScaleLayerXY ( int nLayer, float scaleX, float scaleY );

int uiViewRedraw();

int uiViewZoomAll();

int uiViewZoomIn();

int uiViewZoomOut();

int uiViewZoomWindow( dbPoint* pt1, dbPoint* pt2 );

int uiViewZoomPrevious();

int uiViewZoomToCoordinates( dbPoint* cenPt );

int uiViewZoomToSelection();

int uiViewPanLeft();

int uiViewPanRight();

int uiViewPanUp();

int uiViewPanDown();

int uiViewPanToPoint( dbPoint* cenPt );

int uiViewShowBackgroundImage( int nValue );

int uiViewExternalNetsSize( float fValue );

int uiViewExternalNetsViewTop( int nValue );

int uiViewExternalNetsViewBottom( int nValue );

int uiViewFill( int nValue );

int uiViewTranslucent( int nValue );

int uiViewHighlightDcode( int nValue );

int uiViewOriginIcon( int nValue );

int uiViewFilmBox( int nValue );

int uiViewInsert( int nValue );

int uiViewJobProfile( int nValue );

int uiViewMarkup( int nValue );

int uiViewFullScreen( int nValue );

int uiViewCommandConsole( int nValue );

int uiViewGrid( int nValue );

int uiViewSetGrid( int units, float xSize, float ySize );

int uiViewFilterFlashes( int nValue );

int uiViewFilterTraces( int nValue );

int uiViewFilterPolygons( int nValue );

int uiViewFilterText( int nValue );

int uiViewSnap( int nSnapMode );

int uiViewOrtho( int nOrthoMode );

int uiViewSetBackgroundImage( char* imagefilepath, int DPI, dbPoint* pt );

int uiViewExternalNetsOffset( dbPoint* pt );

int uiViewExternalNetsScale( float fValue );

int uiAddFlash( int nLayer, int nCompositeLevel, dbPoint* pt );

int uiAddTrace( int nLayer, int nCompositeLevel, dbPointArray* pts );

int uiAddPolygon( int nLayer, int nCompositeLevel, dbPointArray* pts );

int uiAddWidePath( int nLayer, int nCompositeLevel, dbPointArray* pts, float width, int nPathStyle );

int uiAddRectangle( int nLayer, int nCompositeLevel, dbPoint* cen, float width, float height );

int uiAddRectanglePts( int nLayer, int nCompositeLevel, dbPoint* pt1, dbPoint* pt2 );

int uiAddCircle( int nLayer, int nCompositeLevel, dbPoint* cen, float radius );

int uiAddArc( int nLayer, int nCompositeLevel, dbPoint* cen, float radius, float start, float end );

int uiAddDonut( int nLayer, int nCompositeLevel, dbPoint* cen, float od, float id );

int uiAddEllipse( int nLayer, int nCompositeLevel, dbPoint* cen, float width, float height );

int uiAddText( int nLayer, int nCompositeLevel, char *text, char *fontStyle, dbPoint* origin, float height, int orient, int alignment );

int uiAddMText( int nLayer, int nCompositeLevel, char *text, char *fontStyle, dbBox* box, float height, int orient, int alignment, int usePolygon );

int uiJobInsert( char* job, dbPoint* pt, int orient );

int uiJobInsertArray( char* job, dbPoint* pt, int orient, int nCols, int nRows, float fColDistance, float fRowDistance );

int uiJobDelete( char* job );

int uiJobFlatten( int nLevel );

int uiToolsBareBoardAnalysis( dbDrcSettings* drcSettings );

int uiToolsMinimumGap( dbSelectionSet* sset, float fGap, int searchLevel );

int uiToolsMinimumWidth( dbSelectionSet* sset, float fWidth, int searchLevel );

int uiToolsDeEmbed( dbSelectionSet* sset );

int uiToolsSilkScreenOptimizer( int nSilkLayer, int nSolderLayer, float fClearance, float fMinStubLength );

int uiToolsCopperBalancing( int nOutputLayer, dbPointArray* pts, float fClearance, float fMinSize );

int uiToolsEtchCompensation( dbSelectionSet* sset, float fSizePerSide );

int uiToolsPinHoleElimination( float fMaxSize );

int uiToolsTearDropCreation( dbSelectionSet* sset, int nTeardropType, float fOffsetMultiple );

int uiToolsRemovePads( dbSelectionSet* sset, int nIsolated, int nStacked );

int uiToolsRemoveCoveredData( dbSelectionSet* sset );

int uiToolsGeneratePasteLayer( int nCreateTopPaste, int nCreateBottomPaste, float fMaskClearance );

int uiToolsCreatePcbbBoarderLayer( dbSelectionSet* sset );

int uiToolsNetlistExtraction( int nAllowSinglePointNets, int nAllowNetsWithoutPads );

int uiToolsCompareNets();

int uiToolsFindNetShorts();

int uiToolsApplyExternalNetlist();

int uiToolsGerberLayerToDrill( int nGerberLayer, int nDrillLayer, int nDrillType, float fAnnularRing );

int uiToolsDrillLayerToGerber( int nDrillLayer, int nGerberLayer );

int uiToolsCreateDrillLayer( int nTopLayer, int nBottomLayer, float fTolerance, float fAnnularRing );

int uiToolsHomebasePadConversion( dbSelectionSet* sset, int nDirection, int nEdgeFactorWidth, int nEdgeFactorHeight, int nOutputLayer, int nApplyToAll, float fTolerance );

int uiToolsCPadConversion( dbSelectionSet* sset, int nPattern, int nAdjust, int nDepthValue, int nWidthValue, int nOutputLayer, int nApplyToAll, float fTolerance );

int uiToolsSplitPads( dbSelectionSet* sset, int nSplitPattern, float fGapWidth, int nOutputLayer, int nApplyToAll );

int uiToolsScalePads( dbSelectionSet* sset, int nScaleAdjust, float fPercentageX, float fPercentageY, int nOutputLayer );

int uiToolsPadPitchAdjustment( dbSelectionSet* sset, int nPadAdjust, float fMaxPitch, float fPadSizeToPitchPercentage, int nOutputLayer );

int uiToolsHeelToeEdits( dbSelectionSet* sset, int nAdjust, float fHeelPercentage, float fToePercentage, int nOutputLayer, int nApplyToAll, float fTolerance );

int uiToolsAddEpoxyBars( dbSelectionSet* sset, int nGapFactorWidth, int nGapFactorHeight, int nOutputLayer, int nDeleteOldObjects, int nApplyToAll, float fTolerance );

int uiToolsAddComponents( dbSelectionSet* sset, dbSelectionSet* ssetPin1, char* sFootprintName, int nType, int nSide, int nRotation, int nApplyToAll );

int uiToolsInsertComponent( char* sFootprintName, int nSide, int nRotation );

int uiToolsDrawToFlashAutomatic( dbSelectionSet* sset, int nShape, int nOutputLayer, float fTolerance );

int uiToolsDrawToFlashInteractive( dbSelectionSet* sset, int nShape, int nOutputLayer, int nApplyToAll, float fTolerance );

int uiToolsDrawToFlashInteractiveUseDcode( dbSelectionSet* sset, int nDcode, int nOutputLayer, int nApplyToAll, float fTolerance );

int uiToolsConvertToCustomAperture( dbSelectionSet* sset, char* sCustomName, int nDcode, int nReplaceExistingData );

int uiToolsConvertToNewJob( dbSelectionSet* sset, char* sJobName, int nAnchorPoint, int nReplaceExistingData );

int uiToolsMergeOverlappingObjects( dbSelectionSet* sset );

int uiToolsJoinWizard( dbSelectionSet* sset, float fJoinTolerance, int nConvertClosedToPolygons );

int uiToolsRemoveTinySegments( dbSelectionSet* sset, float fMinSegmentLength );

int uiToolsChopPolygons( int nMaxPolygonVertices );

int uiToolsFixInvalidPolygons();

int uiToolsDeEmbedLayer( int nLayer, int nOutputLayer );

int uiToolsBuildCompositeLayers( char* sNewLayer, int nPolarity, dbIntArray* layers, dbIntArray* polarities );

int uiToolsFlattenComposite( int nLayer );

int uiToolsSeparateComposite( int nLayer );

int uiToolsOpenComposite( int nLayer );

int uiToolsCloseComposite();

float uiToolsCopperAreaCalculation( int nLayer, int nUnits );