Go to the source code of this file.
Defines | |
#define | EXTERN extern |
Functions | |
Boolean_t | TecUtilFieldLayerIsActive (const char *LayerShowFlag) |
Indicates if the field layer of interest is active or not. More... | |
Boolean_t | TecUtilLinePlotLayerIsActive (const char *LayerShowFlag) |
Indicates if the line plot layer of interest is active or not. More... | |
ArbParam_t | TecUtilFrameGetLinking (const char *Attribute) |
ArbParam_t | TecUtilLinkingGetValue (const char *Attribute, const char *SubAttribute) |
Gets frame linking attributes. More... | |
void | TecUtilPaperGetDimensions (double *Width, double *Height) |
Get the dimensions of the currently defined paper in the Tecplot workspace. More... | |
Boolean_t | TecUtilBlankingCheckDataPoint (EntIndex_t Zone, LgIndex_t PointIndex) |
Determine if the specified data point in the specified zone is visible or if it is not drawn due to value-blanking or IJK-blanking. More... | |
Boolean_t | TecUtilBlankingCheckFECell (EntIndex_t Zone, LgIndex_t CellIndex) |
Determine if the specified element in the specified finite-element zone is visible or if it is not drawn due to value-blanking. More... | |
Boolean_t | TecUtilBlankingCheckIJKCell (EntIndex_t Zone, IJKPlanes_e ZonePlane, LgIndex_t CellIndex) |
Determine if the specified cell in the specified IJK-ordered zone is visible or if it is not drawn due to value-blanking or IJK-blanking. More... | |
int | TecUtilLockGetCount (void) |
Determine how many levels of locking are currently active in Tecplot. More... | |
Boolean_t | TecUtilLockIsOn (void) |
Determine if Tecplot is locked. More... | |
LgIndex_t | TecUtilGetTecplotVersion (void) |
Get the version of Tecplot. More... | |
char * | TecUtilTecplotGetHomeDirectory (void) |
Get the Tecplot home directory. More... | |
int | TecUtilFrameGetCount (void) |
Get a count of the number of frames currently defined. More... | |
FrameMode_e | TecUtilFrameGetMode (void) |
PlotType_e | TecUtilFrameGetPlotType (void) |
Get the plot type of the current frame. More... | |
int | TecUtilPickListGetCount (void) |
Get the number of items currently in the pick list. More... | |
PickObjects_e | TecUtilPickListGetType (int PickListIndex) |
Gets the type of object from the pick list at the specified index. More... | |
char * | TecUtilPickListGetFrameName (int PickListIndex) |
Get the name of the frame from the pick list at the specified index. More... | |
UniqueID_t | TecUtilPickListGetFrameUniqueID (int PickListIndex) |
Get the unique identifier of the frame from the pick list at the specified index. More... | |
void | TecUtilAxisGetRange (char Axis, short AxisNum, double *AxisMin, double *AxisMax) |
Get the current minimum and maximum values for the specified axis. More... | |
char | TecUtilPickListGetAxisKind (int PickListIndex) |
Get the kind of axis (X, Y, or Z) from the pick list at the specified index. More... | |
int | TecUtilPickListGetAxisNumber (int PickListIndex) |
Get the number of the axis from the pick list at the specified index. More... | |
EntIndex_t | TecUtilPickListGetZoneNumber (int PickListIndex) |
Get the number of the zone from the pick list at the specified index. More... | |
void | TecUtilPickListGetZoneIndices (int PickListIndex, LgIndex_t *IIndex, LgIndex_t *JIndex, LgIndex_t *KIndex) |
Get the specific point that was selected in the zone from the pick list at the specified index. More... | |
EntIndex_t | TecUtilPickListGetXYMapNumber (int PickListIndex) |
EntIndex_t | TecUtilPickListGetLineMapNumber (int PickListIndex) |
Get the number of the Line-mapping from the pick list at the specified index. More... | |
LgIndex_t | TecUtilPickListGetXYMapIndex (int PickListIndex) |
LgIndex_t | TecUtilPickListGetLineMapIndex (int PickListIndex) |
Get the index value of the specific point that was selected in the Line-mapping from the pick list at the specified index. More... | |
Text_ID | TecUtilPickListGetText (int PickListIndex) |
Get the text from the pick list at the specified index. More... | |
Geom_ID | TecUtilPickListGetGeom (int PickListIndex) |
Get the geometry from the pick list at the specified index. More... | |
void | TecUtilPickListGetGeomInfo (int PickListIndex, SmInteger_t *PolylineNum, LgIndex_t *PointIndex) |
Get the specific point that was selected in the geometry from the pick list at the specified index. More... | |
void | TecUtilVarGetMinMax (EntIndex_t Var, double *VarMin, double *VarMax) |
Gets the minimum and maximum values of a variable. More... | |
void | TecUtilDataFECellGetNodes (EntIndex_t Zone, int Face, LgIndex_t CellIndex, LgIndex_t *I1, LgIndex_t *I2, LgIndex_t *I3, LgIndex_t *I4) |
Get the indices for the nodes of a finite-element cell. More... | |
void | TecUtilDataIJKCellGetIndices (EntIndex_t Zone, IJKPlanes_e Plane, LgIndex_t CellIndex, LgIndex_t *I1, LgIndex_t *I2, LgIndex_t *I3, LgIndex_t *I4) |
Get the indices for the nodes a cell in an ordered zone. More... | |
GetValueReturnCode_e | TecUtilStyleGetLowLevelX (ArgList_pa ArgList) |
Low level function used to get most frame and base attribute values in Tecplot. More... | |
ArbParam_t | TecUtilFieldStyleGetArbValue (EntIndex_t Zone, const char *S1, const char *S2, const char *S3) |
Queries a zone attribute. More... | |
double | TecUtilFieldStyleGetDoubleValue (EntIndex_t Zone, const char *S1, const char *S2, const char *S3) |
Queries a zone attribute. More... | |
ArbParam_t | TecUtilXYMapStyleGetArbValue (EntIndex_t XYMap, const char *S1, const char *S2, const char *S3) |
ArbParam_t | TecUtilLineMapStyleGetArbValue (EntIndex_t LineMap, const char *S1, const char *S2, const char *S3) |
Queries an Line-map attribute. More... | |
double | TecUtilXYMapStyleGetDoubleValue (EntIndex_t XYMap, const char *S1, const char *S2, const char *S3) |
double | TecUtilLineMapStyleGetDoubleValue (EntIndex_t LineMap, const char *S1, const char *S2, const char *S3) |
Queries an Line-map attribute. More... | |
Boolean_t | TecUtilStateIsProcessingJournal (void) |
Query Tecplot to find out if Tecplot is in the middle of processing the data journal. More... | |
Boolean_t | TecUtilStateIsProcessingLayout (void) |
Query Tecplot to find out if Tecplot is in the middle of processing a layout. More... | |
UniqueID_t | TecUtilFrameGetUniqueID (void) |
Gets a unique id for a frame. More... | |
UniqueID_t | TecUtilDataSetGetUniqueID (void) |
Gets a unique ID for a data set. More... | |
UniqueID_t | TecUtilZoneGetUniqueID (EntIndex_t Zone) |
Gets a unique ID for a zone. More... | |
UniqueID_t | TecUtilVarGetUniqueID (EntIndex_t Var) |
Gets a unique ID for a variable. More... | |
EntIndex_t | TecUtilVarGetNumByUniqueID (UniqueID_t UniqueID) |
Gets a variable number, given a unique ID. More... | |
EntIndex_t | TecUtilZoneGetNumByUniqueID (UniqueID_t UniqueID) |
Gets a zone number, given a unique ID. More... | |
EntIndex_t | TecUtilVarGetNumByAssignment (char Var) |
Gets the number (that is, the index) of a variable based on the variable assignment. More... | |
EntIndex_t | TecUtilVarGetNumByName (const char *VarName) |
Gets the number (that is, the index) of a variable based on variable name. More... | |
void | TecUtilDataValueGetRawPtr (EntIndex_t Zone, EntIndex_t Var, void **DataPtr, FieldDataType_e *FieldDataType) |
Get a handle to the raw field data in the data set attached to the current frame. More... | |
void | TecUtilDataNodeGetRawPtr (EntIndex_t Zone, NodeMap_t **NodeMapPtr) |
Get a handle to the raw node map data in the data set attached to the current frame. More... | |
void | TecUtilDataFaceNbrGetRawPtr (EntIndex_t Zone, LgIndex_t **FNPtr) |
Boolean_t | TecUtilZoneGetName (EntIndex_t Zone, char **ZName) |
Get the name of a specified zone in the data set attached to the current frame. More... | |
Boolean_t | TecUtilVarGetName (EntIndex_t VarNum, char **VName) |
Get the name of a variable in the data set attached to the current frame. More... | |
Boolean_t | TecUtilXYMapGetName (EntIndex_t Map, char **Name) |
Boolean_t | TecUtilLineMapGetName (EntIndex_t Map, char **Name) |
Get the name of an Line-map. More... | |
void | TecUtilZoneGetInfo (EntIndex_t CurZone, LgIndex_t *IMax, LgIndex_t *JMax, LgIndex_t *KMax, FieldData_pa *XVar, FieldData_pa *YVar, FieldData_pa *ZVar, NodeMap_pa *NMap, FieldData_pa *UVar, FieldData_pa *VVar, FieldData_pa *WVar, FieldData_pa *BVar, FieldData_pa *CVar, FieldData_pa *SVar) |
Convenience function used to obtain information about a specific zone. More... | |
Boolean_t | TecUtilDataSetGetInfo (char **DataSetTitle, EntIndex_t *NumZones, EntIndex_t *NumVars) |
Get the title, number of zones, and number of variables of the data set attached to the current frame. More... | |
Boolean_t | TecUtilDataSetJournalIsValid (void) |
Query Tecplot to see if the journal for the data set attached to the current frame is valid. More... | |
Boolean_t | TecUtilDataSetRequiresSaving (void) |
void | TecUtilFrameGetPosAndSize (double *X, double *Y, double *Width, double *Height) |
Get the position and size of a frame. More... | |
Text_ID | TecUtilTextGetBase (void) |
Get the first text object from the list of text objects maintained by the current frame. More... | |
Geom_ID | TecUtilGeomGetBase (void) |
Get the base geometry attached to the current frame. More... | |
Boolean_t | TecUtilProbeAtPosition (double X, double Y, double Z, LgIndex_t *ICell, LgIndex_t *JCell, LgIndex_t *KCell, IJKPlanes_e *Plane, EntIndex_t *CurZone, Boolean_t StartWithLocalCell, double *VValue_Array, Set_pa SourceZones, Boolean_t SearchVolume, Boolean_t GetZoneOnly, Boolean_t GetNearestPoint) |
Use Tecplot's probe capability to return field values at a specified X, Y, [Z] location. More... | |
Boolean_t | TecUtilZoneGetEnabled (Set_pa *EnabledZones) |
Get the set of enabled zones. More... | |
Boolean_t | TecUtilVarGetEnabled (Set_pa *EnabledVars) |
Get the set of enabled variables. More... | |
Boolean_t | TecUtilZoneGetActive (Set_pa *ActiveZones) |
Obtain the set of active field zones. More... | |
Boolean_t | TecUtilXYMapGetActive (Set_pa *ActiveXYMaps) |
Boolean_t | TecUtilLineMapGetActive (Set_pa *ActiveLineMaps) |
Obtain the set of active Line-maps. More... | |
void | TecUtilXYMapGetAssignment (EntIndex_t XYMap, EntIndex_t *Zone, EntIndex_t *XAxisVar, EntIndex_t *YAxisVar, SmInteger_t *XAxis, SmInteger_t *YAxis, FunctionDependency_e *FunctionDependency) |
void | TecUtilLineMapGetAssignment (EntIndex_t LineMap, EntIndex_t *Zone, EntIndex_t *XOrThetaVar, EntIndex_t *YOrRVar, SmInteger_t *XAxis, SmInteger_t *YAxis, FunctionDependency_e *FunctionDependency) |
Get the assignment information for a given Line-map. More... | |
Boolean_t | TecUtilZoneIsFiniteElement (EntIndex_t Zone) |
Determine if a zone in the data set attached to the current frame contains finite-element data. More... | |
Boolean_t | TecUtilZoneIsOrdered (EntIndex_t Zone) |
Determine if the specified zone in the data set attached to the current frame contains ordered data. More... | |
ZoneType_e | TecUtilZoneGetType (EntIndex_t Zone) |
Get the type of a specified zone in the data set attached to the current frame. More... | |
double | TecUtilDataValueGetByZoneVar (EntIndex_t Zone, EntIndex_t Var, LgIndex_t PointIndex) |
Get a field data value. More... | |
FieldData_pa | TecUtilDataValueGetRef (EntIndex_t Zone, EntIndex_t Var) |
Get a handle to the data for the specified zone and variable in the data set attached to the current frame. More... | |
NodeMap_pa | TecUtilDataNodeGetRef (EntIndex_t Zone) |
Get a finite-element node map handle to the specified zone in the data set attached to the current frame. More... | |
FaceNeighbor_pa | TecUtilDataFaceNbrGetRef (EntIndex_t Zone) |
Get a face neighbor handle to the specified zone in the data set attached to the current frame. More... | |
FieldDataType_e | TecUtilDataValueGetRefType (FieldData_pa FieldData) |
Get the field data type of a field data handle. More... | |
ValueLocation_e | TecUtilDataValueGetLocation (EntIndex_t Zone, EntIndex_t Var) |
Queries the location of the variable: ValueLocation_CellCentered or ValueLocation_Nodal. More... | |
Boolean_t | TecUtilImportGetLoaderInstr (char **DataSetLoaderName, StringList_pa *DataSetLoaderInstructions) |
Get the instructions used to load the data for the data set attached to the current frame. More... | |
Boolean_t | TecUtilDialogMessageBox (const char *Message, MessageBoxType_e MessageBoxType) |
Display a message to the user and, if desired, prompt for yes or no input. More... | |
Boolean_t | TecUtilDialogGetIndexRange (LgIndex_t MaxRangeValue, LgIndex_t *Min, LgIndex_t *Max, LgIndex_t *Skip) |
Launch a dialog that prompts the user for the minimum, maximum, and skip values of a range. More... | |
Boolean_t | TecUtilDialogGetVariables (const char *Instructions, const char *TextField1Label, const char *TextField2Label, const char *TextField3Label, EntIndex_t *Var1, EntIndex_t *Var2, EntIndex_t *Var3) |
Launch a dialog that prompts the user for one, two, or three variables. More... | |
Boolean_t | TecUtilDialogGetSimpleText (const char *Instructions, const char *DefaultText, char **Text) |
Launch a dialog to prompt the user to input into a simple text field. More... | |
void | TecUtilTextBoxGetPosition (Text_ID T, double *X1, double *Y1, double *X2, double *Y2, double *X3, double *Y3, double *X4, double *Y4) |
Get the position of the four corners of the box surrounding the text object. More... | |
Boolean_t | TecUtilMacroFunctionExists (const char *FunctionName) |
Query Tecplot to see if a macro function called FunctionName exists. More... | |
Boolean_t | TecUtilMacroIsBatchModeActive (void) |
Determine if Tecplot is currently running in batch mode. More... | |
void | TecUtilInterfaceGetDotsPerInch (double *VDotsPerInch, double *HDotsPerInch) |
Get the number of pixels per inch in the vertical and horizontal directions on the screen. More... | |
void | TecUtilDataValueArrayGetByRef (FieldData_pa SourceFieldData, LgIndex_t SourceOffset, LgIndex_t SourceCount, void *DestValueArray) |
Fetch an Array of values by reference. More... | |
double | TecUtilDataValueGetByRef (FieldData_pa FieldData, LgIndex_t PointIndex) |
Get a field data value. More... | |
void | TecUtilDataValueGetMinMaxByRef (FieldData_pa FieldData, double *Min, double *Max) |
Get the minimum and maximum values for a tecplot variable using a reference to the variable. More... | |
LgIndex_t | TecUtilDataNodeGetByZone (EntIndex_t Zone, LgIndex_t Element, LgIndex_t Corner) |
Get the node index for a particular corner of a finite-element. More... | |
LgIndex_t | TecUtilDataNodeGetByRef (NodeMap_pa NodeMapPtr, LgIndex_t Element, LgIndex_t Corner) |
Get the node index for a particular corner of a finite-element. More... | |
LgIndex_t | TecUtilDataFaceNbrGetByZone (EntIndex_t Zone, LgIndex_t Element, LgIndex_t Face) |
LgIndex_t | TecUtilDataFaceNbrGetByRef (FaceNeighbor_pa FaceNeighbor, LgIndex_t Element, LgIndex_t Face) |
FaceNeighborMode_e | TecUtilDataFaceNbrGetModeByRef (FaceNeighbor_pa FaceNeighbor) |
Returns the FaceNeigborMode_e value for the referenced face neighbor. More... | |
LgIndex_t | TecUtilDataFaceNbrGetNumNByRef (FaceNeighbor_pa FaceNeighbor, LgIndex_t Element, LgIndex_t Face) |
Gets the number of face neighbors for the elements's face. More... | |
void | TecUtilDataFaceNbrGetNbrByRef (FaceNeighbor_pa FaceNeighbor, LgIndex_t Element, LgIndex_t Face, LgIndex_t NeighborNumber, LgIndex_t *NeighborElem, EntIndex_t *NeighborZone) |
Get the cell index of the element the is a neighbor of the specified Element and Face. More... | |
Boolean_t | TecUtilDataFaceNbrBeginAssign (EntIndex_t Zone) |
Clears any previous user defined face neighbor assignments and opens a new face neighbor assignment context. More... | |
Boolean_t | TecUtilDataFaceNbrAssign (LgIndex_t Element, LgIndex_t Face, Boolean_t NeighborsCompletelyObscure, LgIndex_t NumNeighbors, LgIndex_t *NeighborElems, EntIndex_t *NeighborZones) |
Sets the user defined face neighbors within an open face neighbor assignment context for the specified element and face. More... | |
Boolean_t | TecUtilDataFaceNbrEndAssign (void) |
Closes the open face neighbor assignment context and packs the assignments into an efficient storage within Tecplot. More... | |
EntIndex_t | TecUtilXYMapGetCount (void) |
EntIndex_t | TecUtilLineMapGetCount (void) |
Returns the number of Line-maps. More... | |
Boolean_t | TecUtilMacroIsRecordingActive (void) |
Determine if Tecplot is currently recording a macro. More... | |
LgIndex_t | TecUtilLimitGetValue (const char *LimitString) |
Query Tecplot for a limit value. More... | |
Boolean_t | TecUtilDataSetIsAvailable (void) |
Determine if the current frame has a data set attached. More... | |
Boolean_t | TecUtilVarIsEnabled (EntIndex_t Var) |
Determine if a variable is enabled. More... | |
Boolean_t | TecUtilZoneIsEnabled (EntIndex_t Zone) |
Determine if a zone is enabled. More... | |
Boolean_t | TecUtilZoneIsActive (EntIndex_t Zone) |
Determine if a zone is active. More... | |
Boolean_t | TecUtilXYMapIsActive (EntIndex_t XYMap) |
Boolean_t | TecUtilLineMapIsActive (EntIndex_t LineMap) |
Determine if an Line-map is active. More... | |
Boolean_t | TecUtilGetTempFileName (char **TempFileName) |
Boolean_t | TecUtilFileGetTempName (char **TempFileName) |
Creates a temporary file name, including a full path. More... | |
void | TecUtilColorMapGetBasicColorRGB (ColorIndex_t BasicColor, ColorIndex_t *Red, ColorIndex_t *Green, ColorIndex_t *Blue) |
Get the RGB components of a basic color. More... | |
LgIndex_t | TecUtilColorMapNumBasicColors (void) |
Get the number of basic colors in Tecplot. More... | |
Boolean_t | TecUtilAutoRedrawIsActive (void) |
Queries the auto redraw state. More... | |
AuxData_pa | TecUtilAuxDataDataSetGetRef (void) |
Gets a reference to the current data set's auxiliary data. More... | |
AuxData_pa | TecUtilAuxDataFrameGetRef (void) |
Gets a reference to the current frame's auxiliary data. More... | |
AuxData_pa | TecUtilAuxDataZoneGetRef (EntIndex_t Zone) |
Gets a reference to the specified zone's auxiliary data. More... | |
LgIndex_t | TecUtilAuxDataGetNumItems (AuxData_pa AuxDataRef) |
Gets the current number of auxiliary data items maintained the auxiliary data reference. More... | |
Boolean_t | TecUtilAuxDataGetItemIndex (AuxData_pa AuxDataRef, const char *Name, LgIndex_t *ItemIndex) |
Gets a reference to the current frame's auxiliary data. More... | |
void | TecUtilAuxDataGetItemByIndex (AuxData_pa AuxDataRef, LgIndex_t Index, char **Name, ArbParam_t *Value, AuxDataType_e *Type, Boolean_t *Retain) |
Gets the auxiliary data item at the specified index. More... | |
Boolean_t | TecUtilAuxDataGetItemByName (AuxData_pa AuxDataRef, const char *Name, ArbParam_t *Value, AuxDataType_e *Type, Boolean_t *Retain) |
Gets the auxiliary data item by the specified name if it exists. More... | |
Boolean_t | TecUtilAuxDataSetItem (AuxData_pa AuxDataRef, const char *Name, ArbParam_t Value, AuxDataType_e Type, Boolean_t Retain) |
Adds the auxiliary data item to the auxiliary data or replaces it if one already exists by the same name. More... | |
void | TecUtilAuxDataDeleteItemByIndex (AuxData_pa AuxDataRef, LgIndex_t Index) |
Deletes the auxiliary data item. More... | |
Boolean_t | TecUtilAuxDataDeleteItemByName (AuxData_pa AuxDataRef, const char *Name) |
Deletes the auxiliary data item by the specified name if it exists. More... | |
Boolean_t | TecUtilDataSetIsSharingAllowed (void) |
Query to see of the data set attached to the current frame is locked. More... | |
Boolean_t | TecUtilDataValueIsSharingOk (EntIndex_t SourceZone, EntIndex_t DestZone, EntIndex_t Var) |
Determine if it is ok to share a variable between zones. More... | |
EntIndex_t | TecUtilDataValueGetShareCount (EntIndex_t Zone, EntIndex_t Var) |
Branch off a shared variable. More... | |
EntIndex_t | TecUtilDataConnectGetShareCount (EntIndex_t Zone) |
Returns the share count for connectivity for the given zone. More... | |
Boolean_t | TecUtilContourGetLevels (SmInteger_t ContourGroup, LgIndex_t *NumLevels, double **LevelValues) |
Gets the number of contour levels and contour level values currently defined for the specified contour group. More... |
|
|
|
Queries the auto redraw state.
INTEGER*4 FUNCTION TecUtilAutoRedrawIsActive() Query the auto redraw state.
{ Boolean_t AutoRedrawIsActive; TecUtilLockStart(AddOnID); AutoRedrawIsActive = TecUtilAutoRedrawIsActive(); TecUtilLockFinish(AddOnID); } |
|
Gets a reference to the current data set's auxiliary data.
SUBROUTINE TecUtilAuxDataDataSetGetRef(ResultPtr) |
|
Deletes the auxiliary data item.
SUBROUTINE TecUtilAuxDataDeleteItemByIndex( Delete the dataset's fourth auxiliary data item:
AuxData_pa AuxDataRef = TecUtilAuxDataDataSetGetRef(); if (AuxDataRef != NULL) { TecUtilAuxDataDeleteItemByIndex(AuxDataRef, 4); } else { / * ... allocation failure ... * / } |
|
Deletes the auxiliary data item by the specified name if it exists.
INTEGER*4 FUNCTION TecUtilAuxDataDeleteItemByName( If it exists, delete the dataset's auxiliary data item named "MachNumber":
AuxData_pa AuxDataRef = TecUtilAuxDataDataSetGetRef(); if (AuxDataRef != NULL) { if (TecUtilAuxDataDeleteItemByName(AuxDataRef, "MachNumber")) { / * ... item found and deleted ... * / } else { / * ... item not found ... * / } } else { / * ... allocation failure ... * / } |
|
Gets a reference to the current frame's auxiliary data.
SUBROUTINE TecUtilAuxDataFrameGetRef(ResultPtr) |
|
Gets the auxiliary data item at the specified index. NOTE: The resulting name and value are allocated copies and therefore it is the client's responsibility to release them when no longer needed.
SUBROUTINE TecUtilAuxDataGetItemByIndex( Get the frame's fourth auxiliary data item:
AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef(); if (AuxDataRef != NULL) { char *Name; ArbParam_t Value; AuxDataType_e Type; Boolean_t Retain; TecUtilAuxDataGetItemByIndex(AuxDataRef, 4, &Name, &Value, &Type, &Retain); if (Type == AuxDataType_String) / * currently the only type supported * / { char *ValueString = (char *)Value; if (ValueString != NULL) { / * ... do something with the value string ... * / / * release the allocated string copy * / TecUtilStringDealloc(&ValueString); } else { / * ... handle the NULL condition ... * / } } else { / * value type not yet supported by this addon * / } } else { / * ... allocation failure ... * / } |
|
Gets the auxiliary data item by the specified name if it exists. NOTE: The resulting value is an allocated copy and therefore it is the caller's responsibility to release it when no longer needed.
INTEGER*4 FUNCTION TecUtilAuxDataGetItemByName( If it exists, get the frame's auxiliary data item named "MachNumber":
/ * * If it exists, get the frame's auxiliary * data item named "MachNumber". * / AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef(); if (AuxDataRef != NULL) { ArbParam_t Value; AuxDataType_e Type; Boolean_t Retain; if (TecUtilAuxDataGetItemByName(AuxDataRef, "MachNumber", &Value, &Type, &Retain)) { if (Type == AuxDataType_String) / * currently the only type supported * / { char *ValueString = (char *)Value; if (ValueString != NULL) { / * ... do something with the value string ... * / double MachNumber; if (sscanf(ValueString, "%lf", &MachNumber) == 1) { } else { / * ... invalid value ... * / } / * release the allocated string copy * / TecUtilStringDealloc(&ValueString); } else { / * ... handle the NULL condition ... * / } } else { / * ... value type not yet supported by this addon ... * / } } else { / * ... item not found ... * / } } else { / * ... allocation failure ... * / } |
|
Gets a reference to the current frame's auxiliary data.
INTEGER*4 FUNCTION TecUtilAuxDataGetItemIndex( If it exists, get the item index of the frame's auxiliary data item named "MachNumber":
/ * * If it exists, get the item index of the frame's * auxiliary data item named "MachNumber". * / AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef(); if (AuxDataRef != NULL) { LgIndex_t ItemIndex; if (TecUtilAuxDataGetItemIndex(AuxDataRef, "MachNumber", &ItemIndex)) { / * ... do something with the item index ... * / } else { / * ... item not found ... * / } } else { / * ... allocation failure ... * / } |
|
Gets the current number of auxiliary data items maintained the auxiliary data reference.
INTEGER*4 FUNCTION TecUtilAuxDataGetNumItems(AuxDataRefPtr) Find the number of auxiliary data items linked to the frame:
AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef(); if (AuxDataRef != NULL) { LgIndex_t NumItems = TecUtilAuxDataGetNumItems(AuxDataRef); if (NumItems != 0) { / * ... do something with the 1..NumItems items ... * / } } else { / * ... allocation failure ... * / } |
|
Adds the auxiliary data item to the auxiliary data or replaces it if one already exists by the same name.
INTEGER*4 FUNCTION TecUtilAuxDataSetItem( Add an item named "MachNumber" to the frame's auxiliary data.
AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef(); if (AuxDataRef != NULL) { ArbParam_t Value = (ArbParam_t)"1.75"; if (TecUtilAuxDataSetItem(AuxDataRef, "MachNumber", Value, AuxDataType_String, TRUE)) / * Retain * / { / * ... item was added ... * / } else { |
|
Gets a reference to the specified zone's auxiliary data.
SUBROUTINE TecUtilAuxDataZoneGetRef( |
|
Get the current minimum and maximum values for the specified axis.
SUBROUTINE TecUtilAxisGetRange( Get the range on Y-Axis number 2 (assume that it was previously determined that the frame mode is currently XY):
double YMin,YMax; TecUtilAxisGetRange('Y',2,&YMin,&YMax); |
|
Determine if the specified data point in the specified zone is visible or if it is not drawn due to value-blanking or IJK-blanking.
INTEGER*4 FUNCTION TecUtilBlankingCheckDataPoint( Zone 4 is IJ-ordered and has IMax = 12, JMax = 8. Determine if the point (I=3, J=2) of zone 4 is visible:
Boolean_t IsVisible = TecUtilBlankingCheckDataPoint(4,(2-1)*8+3); Zone 5 is finite-element. Determine if the point (N=17) of zone 5 is visible:
Boolean_t IsVisible = TecUtilBlankingCheckDataPoint(5, 17); |
|
Determine if the specified element in the specified finite-element zone is visible or if it is not drawn due to value-blanking.
INTEGER*4 FUNCTION TecUtilBlankingCheckFECell( Zone 5 is finite-element. Determine if element number 13 of zone 5 is visible:
Boolean_t IsVisible = TecUtilBlankingCheckFECell(5, 13); |
|
Determine if the specified cell in the specified IJK-ordered zone is visible or if it is not drawn due to value-blanking or IJK-blanking.
INTEGER*4 FUNCTION TecUtilBlankingCheckIJKCell( Zone 4 is IJ-ordered. Determine if cell 13 of zone 4 is visible:
Boolean_t IsVisible = TecUtilBlankingCheckIJKCell(4, Planes_K, 13); |
|
Get the RGB components of a basic color.
SUBROUTINE TecUtilColorMapGetBasicColorRGB( Get the RGB components of the Custom2_C basic color.
{ Byte R,G,B; TecUtilColorMapGetBasicColorRGB(Custom2_C,&R,&G,&B); } |
|
Get the number of basic colors in Tecplot.
INTEGER*4 FUNCTION TecUtilColorMapNumBasicColors() Get the number of basic colors in Tecplot.
{ LgIndex_t NumBasicColors; TecUtilLockStart(AddOnID); NumBasicColors = TecUtilColorMapNumBasicColors(); TecUtilLockFinish(AddOnID); } |
|
Gets the number of contour levels and contour level values currently defined for the specified contour group. The LevelValues array must be deallocated by the addon using TecUtilArrayDealloc.
INTEGER*4 FUNCTION TecUtilContourGetLevels( Fetch the number of contour levels for contour group 2:
Boolean_t IsOk; LgIndex_t NumLevels; double *LevelValues; TecUtilLockStart(AddOnID); IsOk = TecUtilContourGetLevels(2, &NumLevels, &LevelValues); if (IsOk) { if (NumLevels != 0) { LgIndex_t LIndex; printf("There are %d levels for contour group #2:\n", NumLevels); for (LIndex = 0; LIndex < NumLevels; LIndex++) printf(" %lg\n", LevelValues[LIndex]); TecUtilArrayDealloc((void **)&LevelValues); } else printf("No levels are specified for contour group #2\n"); } TecUtilLockFinish(AddOnID); |
|
Returns the share count for connectivity for the given zone. This is the number of times the connectivity is shared. 1 means not shared (shared once), 2 means two zones share it, etc.
INTEGER*4 FUNCTION TecUtilDataConnectGetShareCount(Zone) |
|
Sets the user defined face neighbors within an open face neighbor assignment context for the specified element and face.
INTEGER*4 FUNCTION TecUtilDataFaceNbrAssign( |
|
Clears any previous user defined face neighbor assignments and opens a new face neighbor assignment context. One and only one face neighbor assignment context must be open prior to calling TecUtilDataFaceNbrAssign. The context must be closed with a call to TecUtilDataFaceNbrEndAssign when all face neighbor assignments have been delivered.
INTEGER*4 FUNCTION TecUtilDataFaceNbrBeginAssign(Zone) |
|
Closes the open face neighbor assignment context and packs the assignments into an efficient storage within Tecplot.
INTEGER*4 FUNCTION TecUtilDataFaceNbrEndAssign() |
|
|
|
|
|
Returns the FaceNeigborMode_e value for the referenced face neighbor.
INTEGER*4 FUNCTION TecUtilDataFaceNbrGetModeByRef(FaceNeighborPtr) |
|
Get the cell index of the element the is a neighbor of the specified Element and Face. To use this function you must have already obtained a handle to face neighbors.
SUBROUTINE TecUtilDataFaceNbrGetNbrByRef( Get the cell index of the cell next to face 5 of element 23 in zone 2. It is assumed that zone 2 is of type ZoneType_FEBrick.
FaceNeighbor_pa FNPtr = NULL; LgIndex_t NeighborElem; EntIndex_t NeighborZone; FNPtr = TecUtilDataFaceNbrGetRef(2); If (FNPtr != NULL) { TecUtilDataFaceNbrGetNbrByRef(FNPtr, 23, 5, 1, &NeighborElem, &NeighborZone); / * Do something with NeighborElem and NeighborZone. * / } |
|
Gets the number of face neighbors for the elements's face.
INTEGER*4 FUNCTION TecUtilDataFaceNbrGetNumNByRef( Get the number of neighbors for face 5 of element 23 of zone 2. It is assumed that zone 2 is of type ZoneType_FEBrick.
LgIndex_t NumNeighbors; FaceNeighbor_pa FNbr; FNbr = TecUtilDataFaceNbrGetRef(2); NumNeighbors = TecUtilDataFaceNbrGetNumNByRef(FNbr, 23, 5); |
|
|
|
Get a face neighbor handle to the specified zone in the data set attached to the current frame.
SUBROUTINE TecUtilDataFaceNbrGetRef( |
|
Get the indices for the nodes of a finite-element cell.
SUBROUTINE TecUtilDataFECellGetNodes( Get the node indices for face number 2 of cell number 23 in zone 3:
LgIndex_t I1,I2,I3,I4; / * Add code here to make sure data exists, and the zone exists and is the right size and type * / TecUtilDataFECellGetNodes(3, 2, 23, &I1,&I2,&I3,&I4); |
|
Get the indices for the nodes a cell in an ordered zone.
SUBROUTINE TecUtilDataIJKCellGetIndices( Get the node indices for the face that lies in the J-plane of the cell that resides at (1, 1, 1) in zone 2 which is an IJK-ordered data set:
LgIndex_t I1,I2,I3,I4; / * Add code here to make sure data exists and the zone exists and is the right size and type * / TecUtilDataIJKCellGetIndices(2, Planes_J, 1, &I1,&I2,&I3,&I4); LgIndex_t I1,I2,I3,I4; LgIndex_t CellIndex; / * Add code here to make sure data exists, and the zone exists and is the right size and type * / CellIndex = 2+10*((5-1)+20*(13-1)); TecUtilDataIJKCellGetIndices(2, Planes_K, CellIndex, &I1,&I2,&I3,&I4); Get the nodel indices for the face that lies in the K-plane of the cell that resides at (2, 5, 13) in zone 2, which is an IJK-ordered data set dimensioned 10 by 20 by 30:
LgIndex_t I1,I2,I3,I4; LgIndex_t CellIndex; / * Add code here to make sure data exists, and the zone exists and is the right size and type * / CellIndex = 2+10*((5-1)+20*(13-1)); TecUtilDataIJKCellGetIndices(2, Planes_K, CellIndex, &I1,&I2,&I3,&I4); |
|
Get the node index for a particular corner of a finite-element. To use this function you must have already obtained a handle to a node map.
INTEGER*4 FUNCTION TecUtilDataNodeGetByRef( Get the first two nodes of the 43rd element of zone 5:
NodeMap_pa nm; nm = TecUtilDataNodeGetRef(5); if ( nm ) { LgIndex_t n1, n2; n1 = TecUtilDataNodeGetByRef(nm, 43, 1); n2 = TecUtilDataNodeGetByRef(nm, 43, 2); / * use n1 and n2 * / } |
|
Get the node index for a particular corner of a finite-element. This function does not require you to obtain the handle to the node map as does TecUtilDataNodeGetByRef, however, this function is not very efficient. Use TecUtilDataNodeGetByRef if you are getting multiple nodes from the same zone.
INTEGER*4 FUNCTION TecUtilDataNodeGetByZone( Get the third node of the 43rd element of zone 5:
LgIndex_t n3; n3 = TecUtilDataNodeGetByZone(5, 43, 3); |
|
Get a handle to the raw node map data in the data set attached to the current frame. Use this function with extreme caution and only as a last resort. TecUtilDataNodeGetByRef and TecUtilDataNodeSetByRef should be used instead in most cases. Note: Do not assume that raw data internal to Tecplot remain in the same location at all times. Always call this function again after any event where Tecplot itself may move or alter the raw data. Also, make sure to call TecUtilStateChanged after any values have changed.
SUBROUTINE TecUtilDataNodeGetRawPtr( Get and then set the first and second node of the 43rd element of zone 5 using a raw data pointer. The 43rd element is accessed by 42*nodes_per_element and the first and second nodes are accessed by +0 and +1 respectively since the raw data is accessed with a zero-base numbering system. Be sure to call TecUtilStateChanged when you change the node map in this way:
/ * assume we already know zone 5 is a finite element zone with * / / * triangle elements (by using TecUtilZoneGetInfo or * / / * TecUtilZoneGetType) * / LgIndex_t zone = 5; NodeMap_t *raw_nm_ptr = NULL; LgIndex_t nodes_per_element = 3; / * triangular * / TecUtilDataNodeGetRawPtr(zone, &raw_nm_ptr); if ( raw_nm_ptr ) { Set_pa altered_zones = TecUtilSetAlloc(TRUE); LgIndex n1, n2; n1 = raw_nm_ptr[42*nodes_per_element + 0];/ *zero-based numbering* / n2 = raw_nm_ptr[42*nodes_per_element + 1]; / * alter n1 and n2 in some way * / n1++; n2++; raw_nm_ptr[42*nodes_per_element + 0] = n1; raw_nm_ptr[42*nodes_per_element + 1] = n2; / * inform Tecplot of node map change * / TecUtilSetAddMember(altered_zones, 5); TecUtilStateChanged(StateChange_NodeMapsAltered, (ArbParam_t)altered_zones); TecUtilSetDealloc(&altered_zones); } |
|
Get a finite-element node map handle to the specified zone in the data set attached to the current frame.
SUBROUTINE TecUtilDataNodeGetRef( |
|
Get the title, number of zones, and number of variables of the data set attached to the current frame.
INTEGER*4 FUNCTION TecUtilDataSetGetInfo( Get the data set title and number of zones and variables from the current data set:
char *dataset_title = NULL; EntIndex_t nzones, nvars; TecUtilDataSetGetInfo(&dataset_title, &nzones, &nvars); / * use dataset_title * / TecUtilStringDealloc(&dataset_title); |
|
Gets a unique ID for a data set. A unique ID is an integer that is unique to a data set. This id can be used to determine if the data sets from several frames are the same.
INTEGER*4 FUNCTION TecUtilDataSetGetUniqueID() Determine if the datasets of the top 2 frames are the same
{ UniqueID_t id; TecUtilLockStart(AddOnID); id = TecUtilDataSetGetUniqueID(); TecUtilFramePushTop(); if ( id == TecUtilDataSetGetUniqueID() ) { / * Datasets are the same for both frames * / } else { / * Datasets are different * / } TecUtilLockFinish(AddOnID); } |
|
Determine if the current frame has a data set attached.
INTEGER*4 FUNCTION TecUtilDataSetIsAvailable() Get the number of zones for the data set for the current frame, or use zero if there is no data set:
EntIndex_t nzones = 0; if ( TecUtilDataSetIsAvailable() ) TecUtilDataSetGetInfo(NULL, &nzones, NULL); |
|
Query to see of the data set attached to the current frame is locked.
INTEGER*4 FUNCTION TecUtilDataSetIsSharingAllowed() Boolean_t IsSharing;
IsSharing = TecUtilDataSetIsSharingAllowed();. |
|
Query Tecplot to see if the journal for the data set attached to the current frame is valid. This is a concern if a layout file is to be generated from an addon. When layouts are generated from an addon the layout must be able to reproduce all data sets via named files and journal entries. A data set will require saving if any un-journaled data operations are performed on it.
INTEGER*4 FUNCTION TecUtilDataSetJournalIsValid() |
|
|
|
Fetch an Array of values by reference. This function fetches the specified number of values from the source field data starting at the specified source item offset and copies them to the base of the destination value array. Note that the destination value array must be of the same data type as the source field data. param SourceFieldData Field data containing the data to fetch. param SourceOffset Member offset in the source field data to begin fetching values. param SourceCount Number of values to fetch from the source field data. param DestValueArray Pre-allocated array large enough to hold the requested members. The first member is placed at the base of the array. |
|
Get a field data value. To use this function you must have already obtained a handle to field data.
REAL*8 FUNCTION TecUtilDataValueGetByRef( Get the first twenty data values for the second variable in zone 5:
LgIndex_t numpts = 20; / * assume we know this * / FieldData_pa fd; fd = TecUtilDataValueGetRef(5, 2); if ( fd ) { int ii; for ( ii = 1; ii <= numpts; ii++ ) { double val = TecUtilDataValueGetByRef(fd, ii); / * do something with val * / } } |
|
Get a field data value. This function does not require you to obtain the handle to the field data as does TecUtilDataValueGetByRef, however, this function is not very efficient. Use TecUtilDataValueGetByRef if you are getting multiple values from the same zone.
REAL*8 FUNCTION TecUtilDataValueGetByZoneVar( Get the twenty-first value of the second variable of zone 5:
double dd = TecUtilDataValueGetByZoneVar(5, 2, 21); / * Use val. * / |
|
Queries the location of the variable: ValueLocation_CellCentered or ValueLocation_Nodal.
INTEGER*4 FUNCTION TecUtilDataValueGetLocation( Get the location of variable 2 in zone 5:
ValueLocation_e ValLoc = TecUtilDataValueGetLocation(5, 2); |
|
Get the minimum and maximum values for a tecplot variable using a reference to the variable.
SUBROUTINE TecUtilDataValueGetMinMaxByRef( Get the minimum and maximum values for the third variable in zone 2 in the current data set.
FieldData_pa FD; double Min; double Max; FD = TecUtilDataValueGetRef(2,3); TecUtilDataValueGetMinMaxByRef(FD,&Min,&Max); |
|
Get a handle to the raw field data in the data set attached to the current frame. Use this function with extreme caution and only as a last resort. TecUtilDataValueGetByRef and TecUtilDataValueSetByRef should be used instead in most cases. Note: Do not assume that raw data internal to Tecplot remain in the same location at all times. Always call this function again after any event where Tecplot itself may move/alter the raw data. Make sure to call TecUtilStateChanged after any field values have changed.
FieldDataType DataPtr references ------------------------------------------- FieldDataType_Float float * FieldDataType_Double double * FieldDataType_LongInt LgIndex_t * FieldDataType_ShortInt short * FieldDataType_Byte char * FieldDataType_Bit UInt32_t *
Fortran Syntax: Get and then set the first and second values of the second variable of zone 5 using a raw data pointer. Note that the first and second values are accessed by zero and one respectively since the raw data is accessed with a zero-base numbering system. Be sure to call TecUtilStateChanged when you change the data in this way: EntIndex_t zone = 5; EntIndex_t var = 2; void *raw_fd_ptr = NULL; FieldDataType_e field_data_type; TecUtilDataValueGetRawPtr(zone, var, &raw_fd_ptr, &field_data_type); if ( raw_fd_ptr ) { if ( field_data_type == FieldData_Float ) { Set_pa altered_vars = TecUtilSetAlloc(TRUE); float *float_ptr = (float *)raw_fd_ptr; float v1 = float_ptr[0]; float v2 = float_ptr[1]; / * alter v1 and v2 in some way * / v1 = 2.0 * v1; v2 = 2.0 * v2; float_ptr[0] = v1; float_ptr[1] = v2; / * inform Tecplot of var value change * / TecUtilSetAddMember(altered_vars, var); TecUtilStateChanged(StateChange_VarsAltered, (ArbParam_t)altered_vars); TecUtilSetDealloc(&altered_vars); } } |
|
Get a handle to the data for the specified zone and variable in the data set attached to the current frame.
SUBROUTINE TecUtilDataValueGetRef( |
|
Get the field data type of a field data handle.
INTEGER*4 FUNCTION TecUtilDataValueGetRefType(FieldDataPtr) Get the type of the data for variable 2 in zone 5 of the data set attached to the current frame and do something special if that type is FieldData_Bit:
FieldData_pa fd = TecUtilDataValueGetRef(5, 2); FieldDataType_e field_data_type = TecUtilDataValueGetRefType(fd); if ( field_data_type == FieldData_Bit ) { / * do something special * / } |
|
Branch off a shared variable. The specified variable of the specified zone is branched so it is no longer shared with anything.
INTEGER*4 FUNCTION TecUtilDataValueGetShareCount( Get share count of variable 2 in zone 1.
EntIndex_t ShareCount = TecUtilDataValueGetShareCount(1, 2); |
|
Determine if it is ok to share a variable between zones. A variable can be shared if the dimensions, type and value location are the same in the source and destination zones and if the zones are of the same type.
if (TecUtilDataValueIsSharingOk(3,5,7)) TecUtilDataValueShare(3,5,7); |
|
Launch a dialog that prompts the user for the minimum, maximum, and skip values of a range. Note: This function cannot be called when Tecplot is running in batch mode.
INTEGER*4 FUNCTION TecUtilDialogGetIndexRange( Launch a dialog that prompts the user for the minimum, maximum, and skip values of a range:
LgIndex_t Min = 0, Max = 100, Skip = 1; TecUtilDialogGetIndexRange(100,&Min,&Max,&Skip); / * values returned in Min,Max, and skip * / |
|
Launch a dialog to prompt the user to input into a simple text field. Note: This function cannot be called when Tecplot is running in batch mode.
INTEGER*4 FUNCTION TecUtilDialogGetSimpleText( Prompt the user for text:
char *Text = NULL; if (TecUtilDialogGetSimpleText("Enter your name","Fred",&Text)) { / * Do somthing with Text * / TecUtilStringDealloc(&Text); } |
|
Launch a dialog that prompts the user for one, two, or three variables. Note: This function cannot be called when Tecplot is running in batch mode.
INTEGER*4 FUNCTION TecUtilDialogGetVariables( Prompt the user for two variables:
EntIndex_t Var1 = 1,Var2 = 1; if (TecUtilDialogGetVariables("Enter the values for V1 and V2:", "V1:", "V2:", NULL, &Var1, &Var2, NULL) { / * values successfully entered * / } |
|
Display a message to the user and, if desired, prompt for yes or no input. Note: This function cannot be called when Tecplot is running in batch mode.
INTEGER*4 FUNCTION TecUtilDialogMessageBox( Prompt the user for a response to a question:
if (TecUtilDialogMessageBox("Do you like green eggs and ham?", MessageBox_Question)) { / * do something here... * / } |
|
Indicates if the field layer of interest is active or not.
INTEGER*4 FUNCTION TecUtilFieldLayerIsActive(LayerShowFlag) Determine if the field's contour layer is on:
if (TecUtilFieldLayerIsActive(SV_SHOWCONTOUR)) { / * do something with the field's contour level * / } |
|
Queries a zone attribute. You can use this function to query any plot attribute that is not a floating point value. To query a floating point plot attribute, use TecUtilFieldStyleGetDoubleValue().
SUBROUTINE TecUtilFieldStyleGetArbValue( Query the mesh color for zone 2.
{ // Equivalent macro command to set the color is: // $!FIELD [2] MESH {Color = ...} ColorIndex_t MeshColor; ArbParam_t Result; TecUtilLockStart(AddOnID); MeshColor = (ColorIndex_t) TecUtilFieldStyleGetArbValue(2,SV_MESH,SV_COLOR,NULL); TecUtilLockFinish(AddOnID); } |
|
Queries a zone attribute. You can use this function to query any plot attribute that is a floating point value. To query a non-floating point plot attribute, use TecUtilFieldStyleGetArbValue().
REAL*8 FUNCTION TecUtilFieldStyleGetDoubleValue( Query the mesh pattern length for for zone 2.
{ / * * Equivalent macro command to set the color is: * $!FIELD [2] MESH {P ATTERNLENGTH = ... } * / double MeshPatternLength; TecUtilLockStart(AddOnID); MeshPatternLength = TecUtilFieldStyleGetDoubleValue(2,SV_MESH, SV_PATTERNLENGTH,NULL); TecUtilLockFinish(AddOnID); } |
|
Creates a temporary file name, including a full path. An empty file with the temporary is file name is also created.
INTEGER*4 FUNCTION TecUtilFileGetTempName( Create a temporary file.
{ FILE *TempFile = NULL; char *TempFileName = NULL; if ( TecUtilFileGetTempName(&TempFileName) ) { TempFile = fopen(TempFileName,"w"); if ( TempFile ) { / * Do something with the temp file. * / fclose(TempFile); } TecUtilStringDealloc(&TempFileName); / * Be sure to deallocate the string when finished. * / } } |
|
Get a count of the number of frames currently defined.
INTEGER*4 FUNCTION TecUtilFrameGetCount() |
|
|
|
|
|
Get the plot type of the current frame.
INTEGER*4 FUNCTION TecUtilFrameGetPlotType() Do something when the frame mode is 3D:
if ( TecUtilFrameGetPlotType() == PlotType_XYLine ) { / * do something * / } |
|
Get the position and size of a frame.
SUBROUTINE TecUtilFrameGetPosAndSize( Get the current frame's position and size:
double x, y, width, height; TecUtilFrameGetPosAndSize(&x, &y, &width, &height); |
|
Gets a unique id for a frame. A unique ID is an integer that is unique to a frame. The frame can be compared to other frames or pushed or popped by this unique id using TecUtilFramePopByUniqueID() and TecUtilFramePushByUniqueID().
INTEGER*4 FUNCTION TecUtilFrameGetUniqueID() Push the current frame using a unique id.
{ UniqueID_t id; TecUtilLockStart(AddOnID); id = TecUtilFrameGetUniqueID(); TecUtilFramePushByUniqueID(id); TecUtilLockFinish(AddOnID); } |
|
Get the base geometry attached to the current frame.
SUBROUTINE TecUtilGeomGetBase(ResultPtr) |
|
Get the version of Tecplot.
INTEGER*4 FUNCTION TecUtilGetTecplotVersion() Get the current version of Tecplot:
LgIndex_t Ver = TecUtilGetTecplotVersion(); if (Ver >= 750000) && (Ver <= 900000) . . else if (Ver >= 900000) . . |
|
|
|
Get the instructions used to load the data for the data set attached to the current frame. If a foreign data set loader addon was used to load the data, then the instruction string passed to the loader is returned. If the data was loaded by Tecplot, then DataSetReaderName returned is "Tecplot" and each file name in the data set is returned in the DataSetLoaderInstructions stringlist parameter. The current frame must have an attached data set when this function is used.
INTEGER*4 FUNCTION TecUtilImportGetLoaderInstr( Get the data set loader and instructions used to load the current frame's data set:
char *LoaderName = NULL; StringList_pa LoaderInstructs; Boolean_t IsOk; IsOk = TecUtilImportGetLoaderInstr(&LoaderName, &LoaderInstructs); if (IsOk) { if (strcmp(LoaderName, "BANANA") == 0) . . TecUtilStringDealloc(&LoaderName); TecUtilStringListDealloc(&LoaderInstructs); } |
|
Get the number of pixels per inch in the vertical and horizontal directions on the screen.
SUBROUTINE TecUtilInterfaceGetDotsPerInch( Get the pixels per inch values:
double VertPixels, HorzPixels; TecUtilInterfaceGetDotsPerInch(&VertPixels, &HorzPixels); |
|
Query Tecplot for a limit value. These are the same values you can set using the $!LIMITS command in the Tecplot macro language. Note that this function requires Tecplot Version 7.5-0-6 or newer.
INTEGER*4 FUNCTION TecUtilLimitGetValue(LimitString) Get the number of points allowed per polyline in Tecplot:
LgIndex_t MaxPtsPerLine; MaxPtsPerLine = TecUtilLimitGetValue("MaxPtsInALine"); |
|
Obtain the set of active Line-maps.
INTEGER*4 FUNCTION TecUtilLineMapGetActive(ActiveLineMapsPtr) Get the set of active Line-maps:
Set_pa s = NULL; if (TecUtilLineMapGetActive(&s)) { / * maps are now in s * / TecUtilSetDealloc(&s); } |
|
Get the assignment information for a given Line-map.
SUBROUTINE TecUtilLineMapGetAssignment( Obtain the zone number and which variables are used for X and Y for Line-map number 3:
EntIndex_t Zone; EntIndex_t XVar; EntIndex_t YVar; TecUtilLineMapGetAssignment(3, &Zone, &XVar, &YVar, (SmInteger_t *)NULL, (SmInteger_t *)NULL, (FunctionDependency_e *)NULL); |
|
Returns the number of Line-maps.
INTEGER*4 FUNCTION TecUtilLineMapGetCount() |
|
Get the name of an Line-map.
INTEGER*4 FUNCTION TecUtilLineMapGetName( Get the name of Line-map 3:
Boolean_t IsOk; char *MapName = NULL; IsOk = TecUtilLineMapGetName(3,&MapName); |
|
Determine if an Line-map is active.
INTEGER*4 FUNCTION TecUtilLineMapIsActive(LineMap) |
|
Queries an Line-map attribute. You can use this function to query any Line-map attribute that is not a floating point value. To query a floating point attribute, use TecUtilLineMapStyleGetDoubleValue().
SUBROUTINE TecUtilLineMapStyleGetArbValue( Query the name of Line-map number 2.
{ // Equivalent macro command to set the color is: $!LINEMAP [2] NAME = "..." char *LineMapName = NULL; TecUtilLockStart(AddOnID); MapName = (const char *) TecUtilLineMapStyleGetArbValue(2,SV_NAME,NULL,NULL); // Use MapName. TecUtilStringDealloc(&MapName); / * When finished * / TecUtilLockFinish(AddOnID); } Get the error bar variable for line map 7:
EntIndex_t ErrorBarVar; TecUtilLockStart(AddOnID); LineThickness = (EntIndex_t)TecUtilLineMapStyleGetArbValue(7, SV_ERRORBARS, SV_VAR, NULL); TecUtilLockFinish(AddOnID); |
|
Queries an Line-map attribute. You can use this function to query any attribute that is a floating point value. To query a non-floating point attribute, use TecUtilLineMapStyleGetArbValue().
REAL*8 FUNCTION TecUtilLineMapStyleGetDoubleValue( Query the pattern length for Line-map number 2.
{ // Equivalent macro command to set the pattern // length is: $!LINEMAP [2] LINES { PATTERNLENGTH = ... } double LinePatternLength; TecUtilLockStart(AddOnID); LinePatternLength = TecUtilLineMapStyleGetDoubleValue(2,SV_LINES, SV_PATTERNLENGTH, NULL); TecUtilLockFinish(AddOnID); } |
|
Indicates if the line plot layer of interest is active or not.
INTEGER*4 FUNCTION TecUtilLinePlotLayerIsActive(LayerShowFlag) Determine if the line plot's symbol layer is on:
if (TecUtilLinePlotLayerIsActive(SV_SHOWSYMBOLS)) { / *Do something with the line plot's symbols * / } |
|
Gets frame linking attributes.
SUBROUTINE TecUtilLinkingGetValue( Query the group number of the current frame:
SmInteger_t GroupNumber; GroupNumber = (SmInteger_t)TecUtilFrameGetLinking(SV_BETWEENFRAMES, SV_LINKGROUP); |
|
Determine how many levels of locking are currently active in Tecplot. In other words, return the number of nested calls to TecUtilLockStart without matching calls to TecUtilLockFinish. See Chapter 10, "Locking and Unlocking Tecplot," in the ADK User's Manual for more information on locks in Tecplot.
INTEGER*4 FUNCTION TecUtilLockGetCount() If Tecplot is not locked, lock it. Later, get the lock count.
if (!TecUtilLockIsOn()) { int LockCount; Addon_pa AddonID = TecUtilAddOnRegister(10,"test","v1.23","author"); TecUtilLockStart(AddonID); . . LockCount = TecUtilLockGetCount(); / * LockCount will be at least 1 * / . . TecUtilLockFinish(AddonID); } |
|
Determine if Tecplot is locked. See Chapter 10, "Locking and Unlocking Tecplot," in the ADK User's Manual for more information on locks in Tecplot.
INTEGER*4 FUNCTION TecUtilLockIsOn() |
|
Query Tecplot to see if a macro function called FunctionName exists. Note: This function requires Tecplot Version 7.5-0-6 or newer.
INTEGER*4 FUNCTION TecUtilMacroFunctionExists(FunctionName) If the macro function "abc" exists, then execute it.
if (TecUtilMacroFunctionExists("abc")) { TecUtilMacroRunFunction("abc",(char *)NULL); } |
|
Determine if Tecplot is currently running in batch mode.
INTEGER*4 FUNCTION TecUtilMacroIsBatchModeActive() Perform some operations if Tecplot is not running in batch mode:
if (!TecUtilMacroIsBatchModeActive()) { / * Perform some operations * / } |
|
Determine if Tecplot is currently recording a macro.
INTEGER*4 FUNCTION TecUtilMacroIsRecordingActive() If Tecplot is currently recording a macro, record the macro command "GO" for the addon "BANANA":
if (TecUtilMacroIsRecordingActive()) { TecUtilMacroRecordAddOnCommand("BANANA", "GO"); } |
|
Get the dimensions of the currently defined paper in the Tecplot workspace.
SUBROUTINE TecUtilPaperGetDimensions( Get the current paper's position and size:
double width, height; TecUtilPaperGetDimensions(&width, &height); |
|
Get the kind of axis (X, Y, or Z) from the pick list at the specified index. The object in the pick list at the specified index must be of type PickObject_Axis. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.
INTEGER*4 FUNCTION TecUtilPickListGetAxisKind(PickListIndex) If an axis object is picked, get its type and number:
int PickIndex, NumPickedItems = TecUtilPickListGetCount(); for (PickIndex = 1; PickIndex <= NumPickedItems; PickIndex++) { if (TecUtilPickListGetType(PickIndex) == PickObject_Axis) { char AxisKind = TecUtilPickListGetAxisKind(PickIndex); int AxisNum = TecUtilPickListGetAxisNumber(PickIndex); . . } } |
|
Get the number of the axis from the pick list at the specified index. The object in the pick list at the specified index must be of type PickObject_Axis. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.
INTEGER*4 FUNCTION TecUtilPickListGetAxisNumber(PickListIndex) |
|
Get the number of items currently in the pick list. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.
INTEGER*4 FUNCTION TecUtilPickListGetCount() Get the number of items in the pick list and loop through the pick list:
int PickIndex, NumPickedItems = TecUtilPickListGetCount(); for (PickIndex = 1; PickIndex <= NumPickedItems; PickIndex++) { / * Go through each object in the pick list using * / / * TecUtilPickListGetType(PickIndex) to determine * / / * the type of object * / } |
|
Get the name of the frame from the pick list at the specified index. The object in the pick list at the specified index must be of type PickObject_Frame. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.
SUBROUTINE TecUtilPickListGetFrameName( If the first object in the pick list is a frame, get its name:
if (TecUtilPickListGetType(1) == PickObject_Frame) { char *FrameName = TecUtilPickListGetFrameName(1); . . TecUtilStringDealloc(&FrameName); } |
|
Get the unique identifier of the frame from the pick list at the specified index. The object in the pick list at the specified index must be of type PickObject_Frame. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.
INTEGER*4 FUNCTION TecUtilPickListGetFrameUniqueID(PickListIndex) If the first object in the pick list is a frame, get its unique identifier:
if (TecUtilPickListGetType(1) == PickObject_Frame) { UniqueID_t UniqueID = TecUtilPickListGetFrameUniqueID(1); . . . } |
|
Get the geometry from the pick list at the specified index. The object in the pick list at the specified index must be of type PickObject_Geom. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.
SUBROUTINE TecUtilPickListGetGeom( If a specific point of a polyline geometry object is picked, set the coordinates for that point to be X = 4.5, Y = 3.2 :
int PickIndex, NumPickedItems = TecUtilPickListGetCount(); for (PickIndex = 1; PickIndex <= NumPickedItems; PickIndex++) { if (TecUtilPickListGetType(PickIndex) == PickObject_Geom) { SmInteger_t PolylineNum; LgIndex_t PointIndex; Geom_ID GID = TecUtilPickListGetGeom(PickIndex); if (TecUtilGeomGetType(GID) == GeomForm_LineSegs) TecUtilPickListGetGeomInfo(PickIndex, &PolylineNum, &PointIndex); if ((PolylineNum > 0) && (PointIndex > 0)) TecUtilGeom2DMPolySetPoint(GID, PolylineNum, PointIndex, 4.5, 3.2); } } |
|
Get the specific point that was selected in the geometry from the pick list at the specified index. The object in the pick list at the specified index must be of type PickObject_Geom. In order to get useful information from this function, the geometry should be of type GeomForm_LineSegs or GeomForm_LineSegs3D. The mouse mode should be Mouse_Adjust. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.
SUBROUTINE TecUtilPickListGetGeomInfo( |
|
Get the index value of the specific point that was selected in the Line-mapping from the pick list at the specified index. The object in the pick list at the specified index must be of type PickObject_LineMapping. In order to get useful information from this function, the mouse mode should be of the type Mouse_Adjust. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.
INTEGER*4 FUNCTION TecUtilPickListGetLineMapIndex(PickListIndex) If the first object in the pick list is an Line-mapping, get its number and index:
if (TecUtilPickListGetType(1) == PickObject_LineMapping) { EntIndex_t MapNumber = TecUtilPickListGetLineMapNumber(1); LgIndex_t MapIndex = TecUtilPickListGetLineMapIndex(1); / * Do Something here * / } |
|
Get the number of the Line-mapping from the pick list at the specified index. The object in the pick list at the specified index must be of type PickObject_LineMapping. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.
INTEGER*4 FUNCTION TecUtilPickListGetLineMapNumber(PickListIndex) |
|
Get the text from the pick list at the specified index. The object in the pick list at the specified index must be of type PickObject_Text. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.
SUBROUTINE TecUtilPickListGetText( For every text object which is picked, set it to have a filled text box:
int PickIndex, NumPickedItems = TecUtilPickListGetCount(); for (PickIndex = 1; PickIndex <= NumPickedItems; PickIndex++) { if (TecUtilPickListGetType(PickIndex) == PickObject_Text) { Text_ID TID = TecUtilPickListGetText(PickIndex); TecUtilTextBoxSetType(TID, TextBox_Filled); } } |
|
Gets the type of object from the pick list at the specified index. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.
INTEGER*4 FUNCTION TecUtilPickListGetType(PickListIndex) Go through the pick list, checking object types: int PickIndex, NumPickedItems = TecUtilPickListGetCount(); for (PickIndex = 1; PickIndex <= NumPickedItems; PickIndex++) { PickObjects_e ObjectType = TecUtilPickListGetType(PickIndex); switch (ObjectType) { case PickObject_Geom : // Do something with picked geometries break; case PickObject_Text : // Do something with picked text break; case PickObject_Zone : // Do something with picked zones break; case PickObject_LineMapping : // Do something with picked line mappings break; . . } } |
|
|
|
|
|
Get the specific point that was selected in the zone from the pick list at the specified index. The object in the pick list at the specified index must be of type PickObject_Zone. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.
SUBROUTINE TecUtilPickListGetZoneIndices( If the first object in the pick list is a zone, get its number and indices:
if (TecUtilPickListGetType(1) == PickObject_Zone) { LgIndex_t IIndex, JIndex, KIndex; EntIndex_t ZoneNumber = TecUtilPickListGetZoneNumber(1); TecUtilPickListGetZoneIndices(1, &IIndex, &JIndex, &KIndex); . . } |
|
Get the number of the zone from the pick list at the specified index. The object in the pick list at the specified index must be of type PickObject_Zone. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.
INTEGER*4 FUNCTION TecUtilPickListGetZoneNumber(PickListIndex) |
|
Use Tecplot's probe capability to return field values at a specified X, Y, [Z] location. The current frame must have an attached data set when this function is called.
INTEGER*4 FUNCTION TecUtilProbeAtPosition( Assuming a 2-D plot, probe at the location (3.2, 1.45):
LgIndex_t ICell, JCell, KCell; IJKPlanes_e Plane; EntIndex_t SourceZone; EntIndex_t NumVars; double *VValues; TecUtilDataSetGetInfo((char **)NULL, (EntIndex_t *)NULL, &NumVars); VValues = (double *)malloc(NumVars*sizeof(double)); if (TecUtilProbeAtPosition(3.2, 1.45, 0.0, &ICell, &JCell, &KCell, &Plane, &SourceZone, FALSE, VValues, (Set_pa )NULL, FALSE, FALSE, FALSE)) { / * Look at VValues[VarNum-1] to find the * / / * value for a particular variable. * / } |
|
Query Tecplot to find out if Tecplot is in the middle of processing the data journal.
INTEGER*4 FUNCTION TecUtilStateIsProcessingJournal() |
|
Query Tecplot to find out if Tecplot is in the middle of processing a layout.
INTEGER*4 FUNCTION TecUtilStateIsProcessingLayout() |
|
Low level function used to get most frame and base attribute values in Tecplot. The parameters to TecUtilStyleGetLowLevelX mimic the Macro Frame SetValue Commands described in the Tecplot Reference Manual.
* GetValue_Ok Value was assigned to either the double * or ArbParam_t value given. * * GetValue_ResultTypeError Resulting type mismatch with the supplied * DValue or IValue. * * GetValue_SyntaxError SV_P# parameters did not follow the macro * command syntax. The parameters must mimic the * macro command language and only for the * branches of the language tree that are * available. *
Fortran Syntax: Make some miscellaneous queries:
ArgList_pa ArgList; ArbParam_t IValue; double DValue; GetValueReturnCode_e GVRC; TecUtilLockStart(AddOnID); ArgList = TecUtilArgListAlloc(); / * get mesh color for zone 2... assuming Tecplot's plot type is cartesian * / TecUtilArgListClear(ArgList); TecUtilArgListAppendInt(ArgList, SV_OFFSET1, 2); TecUtilArgListAppendString(ArgList, SV_P1, SV_FIELD); TecUtilArgListAppendString(ArgList, SV_P2, SV_MESH); TecUtilArgListAppendString(ArgList, SV_P3, SV_COLOR); TecUtilArgListAppendArbParamPtr(ArgList, SV_IVALUE, &IValue); GVRC = TecUtilStyleGetLowLevelX(ArgList); if (GVRC == GetValue_Ok) { ColorIndex_t MeshColor = (ColorIndex_t)IValue; printf("Zone 2's mesh color is %d\n", MeshColor); } / * get the line thickness of zone 3... same assumptions as above * / TecUtilArgListClear(ArgList); TecUtilArgListAppendInt(ArgList, SV_OFFSET1, 3); TecUtilArgListAppendString(ArgList, SV_P1, SV_FIELD); TecUtilArgListAppendString(ArgList, SV_P2, SV_MESH); TecUtilArgListAppendString(ArgList, SV_P3, SV_LINETHICKNESS); TecUtilArgListAppendDoublePtr(ArgList, SV_DVALUE, &DValue); GVRC = TecUtilStyleGetLowLevelX(ArgList); if (GVRC == GetValue_Ok) { double MeshLineThickness = DValue; printf("Zone 3's mesh line thickness is %lg\n", MeshLineThickenss); } / * get the positive prefix number for contour group 1's contour legend * / TecUtilArgListClear(ArgList); TecUtilArgListAppendInt(ArgList, SV_OFFSET1, 1); TecUtilArgListAppendString(ArgList, SV_P1, SV_GLOBALCONTOUR); TecUtilArgListAppendString(ArgList, SV_P2, SV_LEGEND); TecUtilArgListAppendString(ArgList, SV_P3, SV_NUMFORMAT); TecUtilArgListAppendString(ArgList, SV_P3, SV_POSITIVEPREFIX); TecUtilArgListAppendArbParamPtr(ArgList, SV_IVALUE, &IValue); if (GVRC == GetValue_Ok) { char *PositivePrefixStr = (char *)IValue; if (PositivePrefixStr != NULL) { printf("Positive prefix number format for " "contour group 1's contour legend is:%s\n", PositivePrefixStr); TecUtilStringDealloc(&PositivePrefixStr); } else printf("Positive prefix number format for " "contour group 1's contour legend " "was not specified.\n"); } TecUtilArgListDealloc(&ArgList); TecUtilLockFinish(AddOnID); |
|
Get the Tecplot home directory.
SUBROUTINE TecUtilTecplotGetHomeDirectory( Get the Tecplot home directory.
char *TecHome = NULL; TecUtilLockStart(AddOnID); TecHome = TecUtilTecplotGetHomeDirectory(); ..... TecUtilStringDealloc(&TecHome); TecUtilLockFinish(AddOnID); |
|
Get the position of the four corners of the box surrounding the text object.
SUBROUTINE TecUtilTextBoxGetPosition( Obtain the four corners of the text referenced by T.
/ * * variable T of type Text_ID already obtained at this point. * / double X1,Y1,X2,Y2,X3,Y3,X4,Y4; TecUtilTextBoxGetPosition(T,&X1,&Y1,&X2,&Y2,&X3,&Y3,&X4,&Y4); |
|
Get the first text object from the list of text objects maintained by the current frame. Note: See also TecUtilTextGetNext and TecUtilTextGetPrev.
SUBROUTINE TecUtilTextGetBase(ResultPtr) Examine all text labels in the current frame and see if any of them are red.
TextID Text; for (Text = TecUtilTextGetBase(); Text != TECUTILBADID; Text = TecUtilTextGetNext(Text)) { if (TecUtilTextGetColor(Text) == Red_C) { / * do something with the red text * / } } |
|
Get the set of enabled variables. Variables are enabled/disabled when they are read in. There must be a data set attached to the current frame.
INTEGER*4 FUNCTION TecUtilVarGetEnabled(EnabledVarsPtr) Get the set of enabled variables. It is assumed that a data set has been created:
Set_pa set = NULL; TecUtilVarGetEnabled(&set); / * Do something with set * / TecUtilSetDealloc(&set); |
|
Gets the minimum and maximum values of a variable.
SUBROUTINE TecUtilVarGetMinMax( Get the minimum and maximum values of the first variable in a data set:
double VarMin,VarMax; TecUtilVarGetMinMax(1,&VarMin,&VarMax); |
|
Get the name of a variable in the data set attached to the current frame. There must be a data set attached to the current frame.
INTEGER*4 FUNCTION TecUtilVarGetName( Get the name of the first variable:
char buffer[100]; VarName_t Name; TecUtilVarGetName(1,&Name); sprintf(buffer,"The name of the first variable is %s",Name); TecUtilStringDealloc(&Name); |
|
Gets the number (that is, the index) of a variable based on the variable assignment.
INTEGER*4 FUNCTION TecUtilVarGetNumByAssignment(Var) Get the index of the 'X' variable:
/ * frame mode must be 2-D or 3-D * / EntIndex_t i = TecUtilVarGetNumByAssignment('X'); |
|
Gets the number (that is, the index) of a variable based on variable name.
INTEGER*4 FUNCTION TecUtilVarGetNumByName(VarName) Get the index of the variable Rainfall:
EntIndex_t i = TecUtilVarGetNumByName("Rainfall"); |
|
Gets a variable number, given a unique ID.
INTEGER*4 FUNCTION TecUtilVarGetNumByUniqueID(UniqueID) Get a variable number from a unique id
{ extern UniqueID_t id; / * previously initialized * / EntIndex_t VarNum; TecUtilLockStart(AddOnID); VarNum = TecUtilVarGetNumByUniqueID(id); assert(VarNum != TECUTILBADID); TecUtilLockFinish(AddOnID); } |
|
Gets a unique ID for a variable. A unique ID is an integer that uniquely identifies a variable. An addon can use these IDs to internally keep track of a set of variables. TecUtilVarGetNumByUniqueID() can be used to convert between a unique ID and a variable number.
INTEGER*4 FUNCTION TecUtilVarGetUniqueID(Var) Get the unique ID for variable 1.
{ UniqueID_t id; TecUtilLockStart(AddOnID); if ( TecUtilDataSetIsAvailable() ) id = TecUtilVarGetUniqueID(1); TecUtilLockFinish(AddOnID); } |
|
Determine if a variable is enabled.
INTEGER*4 FUNCTION TecUtilVarIsEnabled(Var) Check if the first variable is enabled:
if (TecUtilVarIsEnabled(1)) { / * sure is! * / } |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Obtain the set of active field zones.
INTEGER*4 FUNCTION TecUtilZoneGetActive(ActiveZonesPtr) Do something if zone 3 is active:
Set_pa zone_set = NULL; TecUtilZoneGetActive(&zone_set); if ( TecUtilSetIsMember(zone_set, 3) ) { / * do something * / } TecUtilSetDealloc(&zone_set); |
|
Get the set of enabled zones. Zones are enabled/disabled when they are read in.
INTEGER*4 FUNCTION TecUtilZoneGetEnabled(EnabledZonesPtr) Get the set of enabled zones:
Set_pa set = NULL; if (TecUtilZoneGetEnabled(&set)) { / * do something with the set here * / TecUtilSetDealloc(&set); } |
|
Convenience function used to obtain information about a specific zone. This function is primarily targeted for use with 2D and 3D frame modes. If the frame mode is XY, only the zone dimensions can be queried. To get a field data pointer to axis variables when the frame mode is XY use TecUtilLineMapGetAssignment.
SUBROUTINE TecUtilZoneGetInfo( Get IMAX for the first zone:
LgIndex_t IMax; / *Use NULL for values we're not interested in * / TecUtilZoneGetInfo(1,&IMax,NULL,NULL,NULL,NULL,NULL,NULL,NULL, NULL,NULL,NULL,NULL,NULL); |
|
Get the name of a specified zone in the data set attached to the current frame.
INTEGER*4 FUNCTION TecUtilZoneGetName( Get the name of the first zone:
char *name = NULL; if (TecUtilZoneGetName(1,&name) { / * do something with the name here * / TecUtilStringDealloc(&name); } |
|
Gets a zone number, given a unique ID.
INTEGER*4 FUNCTION TecUtilZoneGetNumByUniqueID(UniqueID) Get a zone number from a unique id
{ extern UniqueID_t id; / * previously initialized * / EntIndex_t ZoneNum; TecUtilLockStart(AddOnID); ZoneNum = TecUtilZoneGetNumByUniqueID(id); assert(ZoneNum != TECUTILBADID); TecUtilLockFinish(AddOnID); } |
|
Get the type of a specified zone in the data set attached to the current frame.
ZoneType_FEBrick: F E-Brick zone type
Fortran Syntax: Get the time of the first zone:
ZoneType_e type = TecUtilZoneGetType(1); |
|
Gets a unique ID for a zone. A unique ID is an integer that uniquely identifies a zone. An addon can use these IDs to internally keep track of a set of zones. TecUtilZoneGetNumByUniqueID() can be used to convert between a unique ID and a zone number.
INTEGER*4 FUNCTION TecUtilZoneGetUniqueID(Zone) Get the UniqueID for zone 1
{ UniqueID_t id; TecUtilLockStart(AddOnID); if ( TecUtilDataSetIsAvailable() ) id = TecUtilZoneGetUniqueID(1); TecUtilLockFinish(AddOnID); } |
|
Determine if a zone is active.
INTEGER*4 FUNCTION TecUtilZoneIsActive(Zone) |
|
Determine if a zone is enabled.
INTEGER*4 FUNCTION TecUtilZoneIsEnabled(Zone) Check if the first zone is enabled:
if (TecUtilZoneIsEnabled(1)) { / * sure is! * / } |
|
Determine if a zone in the data set attached to the current frame contains finite-element data.
INTEGER*4 FUNCTION TecUtilZoneIsFiniteElement(Zone) Check if the first zone is finite element:
if (TecUtilZoneIsFiniteElement(1)) { / * sure is! * / } |
|
Determine if the specified zone in the data set attached to the current frame contains ordered data.
INTEGER*4 FUNCTION TecUtilZoneIsOrdered(Zone) Check if the first zone is ordered:
if (TecUtilZoneIsOrdered(1)) { / * sure is! * / } |