Main Page   File List   Globals  

TECUTILQ.h File Reference

More...

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...


Detailed Description


Define Documentation

#define EXTERN   extern
 


Function Documentation

Boolean_t TecUtilAutoRedrawIsActive void   
 

Queries the auto redraw state.

Returns:
Returns TRUE if Auto Redraw is active, FALSE otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilAutoRedrawIsActive()

Query the auto redraw state.

   {
   Boolean_t AutoRedrawIsActive;
   TecUtilLockStart(AddOnID);
   AutoRedrawIsActive = TecUtilAutoRedrawIsActive();
   TecUtilLockFinish(AddOnID);
   }

AuxData_pa TecUtilAuxDataDataSetGetRef void   
 

Gets a reference to the current data set's auxiliary data.

Returns:
Reference to the current data set's auxiliary data.
Fortran Syntax:

    SUBROUTINE TecUtilAuxDataDataSetGetRef(ResultPtr)
    POINTER (ResultPtr, Result)

void TecUtilAuxDataDeleteItemByIndex AuxData_pa    AuxDataRef,
LgIndex_t    Index
 

Deletes the auxiliary data item.

Parameters:
AuxDataRef  Reference to the auxiliary data.
Index  Index of the auxiliary data item of interest.
Returns:
Reference to the current frame's auxiliary data..
Fortran Syntax:

    SUBROUTINE TecUtilAuxDataDeleteItemByIndex(
   &           AuxDataRefPtr,
   &           Index)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    INTEGER*4       Index

Delete the dataset's fourth auxiliary data item:

   AuxData_pa AuxDataRef = TecUtilAuxDataDataSetGetRef();
       if (AuxDataRef != NULL)
         {
    TecUtilAuxDataDeleteItemByIndex(AuxDataRef, 4);
         }
       else
         {
           / * ... allocation failure ... * /
         }

Boolean_t TecUtilAuxDataDeleteItemByName AuxData_pa    AuxDataRef,
const char *    Name
 

Deletes the auxiliary data item by the specified name if it exists.

Parameters:
AuxDataRef  Reference to the auxiliary data.
Name  Name used for the search.
Returns:
TRUE if successful, FALSE otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilAuxDataDeleteItemByName(
   &                   AuxDataRefPtr,
   &                   Name)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    CHARACTER*(*)   Name

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 ... * /
         }

AuxData_pa TecUtilAuxDataFrameGetRef void   
 

Gets a reference to the current frame's auxiliary data.

Returns:
Reference to the current frame's auxiliary data..
Fortran Syntax:

    SUBROUTINE TecUtilAuxDataFrameGetRef(ResultPtr)
    POINTER (ResultPtr, Result)

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.

NOTE: The resulting name and value are allocated copies and therefore it is the client's responsibility to release them when no longer needed.

See also:
(see TecUtilStringDealloc).
Parameters:
AuxDataRef  Reference to the auxiliary data.
Index  Index of the auxiliary data of interest.
Name  Address to hold the auxiliary data item name.
Value  Address to hold the auxiliary data item value.
Type  Address to hold the auxiliary data item type.
Retain  Address to hold the auxiliary data item retain flag.
Returns:
None.
Fortran Syntax:

    SUBROUTINE TecUtilAuxDataGetItemByIndex(
   &           AuxDataRefPtr,
   &           Index,
   &           Name,
   &           NameLength,
   &           ValuePtr,
   &           Type,
   &           Retain)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    INTEGER*4       Index
    CHARACTER*(*)   Name
    INTEGER*4       NameLength
    POINTER         (ValuePtr, Value)
    INTEGER*4       Type
    INTEGER*4       Retain

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 ... * /
         }

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.

NOTE: The resulting value is an allocated copy and therefore it is the caller's responsibility to release it when no longer needed.

See also:
TecUtilStringDealloc
Parameters:
AuxDataRef  Reference to the auxiliary data.
Name  Address to hold the auxiliary data item name.
Value  Address to hold the auxiliary data item value.
Type  Address to hold the auxiliary data item type.
Retain  Address to hold the auxiliary data item retain flag. If Retain is set to TRUE, then saving the data set will include this item.
Returns:
None.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilAuxDataGetItemByName(
   &                   AuxDataRefPtr,
   &                   Name,
   &                   ValuePtr,
   &                   Type,
   &                   Retain)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    CHARACTER*(*)   Name
    POINTER         (ValuePtr, Value)
    INTEGER*4       Type
    INTEGER*4       Retain

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 ... * /
         }

Boolean_t TecUtilAuxDataGetItemIndex AuxData_pa    AuxDataRef,
const char *    Name,
LgIndex_t   ItemIndex
 

Gets a reference to the current frame's auxiliary data.

Parameters:
AuxDataRef  Reference to auxiliary data.
Name  Name used for search.
ItemIndex  Address to hold the index of the found item.
Returns:
TRUE if the named item was found, FALSE otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilAuxDataGetItemIndex(
   &                   AuxDataRefPtr,
   &                   Name,
   &                   ItemIndex)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    CHARACTER*(*)   Name
    INTEGER*4       ItemIndex

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 ... * /
         }

LgIndex_t TecUtilAuxDataGetNumItems AuxData_pa    AuxDataRef
 

Gets the current number of auxiliary data items maintained the auxiliary data reference.

Parameters:
AuxDataRef  Reference to auxiliary data.
Returns:
Number of items maintained by the auxiliary data.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilAuxDataGetNumItems(AuxDataRefPtr)
    POINTER (AuxDataRefPtr, AuxDataRef)

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 ... * /
         }

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.

Parameters:
AuxDataRef  Reference to the auxiliary data.
Name  Auxiliary data item's name. Be sure to consider a unique naming convention for your auxiliary data to avoid naming conflicts with auxiliary data produed by other addonaddons or macros. By convention addons that wish to share auxiliary data can prepend the name with the "Common" prefix. For example, the Plot3D loader uses CommonReferenceMachNumber for the reference Mach number.
Value  Value of item to set.
Type  Type of item being set.
Retain  Flag specifying whether or not to retain this item on file export such as writing out a datafile, etc.Add an item named "MachNumber" to the frame's auxiliary data:AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
Returns:
TRUE if the item was added to the auxiliay data, FALSE if otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilAuxDataSetItem(
   &                   AuxDataRefPtr,
   &                   Name,
   &                   ValuePtr,
   &                   Type,
   &                   Retain)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    CHARACTER*(*)   Name
    POINTER         (ValuePtr, Value)
    INTEGER*4       Type
    INTEGER*4       Retain

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
             {

AuxData_pa TecUtilAuxDataZoneGetRef EntIndex_t    Zone
 

Gets a reference to the specified zone's auxiliary data.

Parameters:
Zone  Zone number for which the auxiliary data is desired. R)
Returns:
Reference to the specified zone's auxiliary data.
Fortran Syntax:

    SUBROUTINE TecUtilAuxDataZoneGetRef(
   &           Zone,
   &           ResultPtr)
    INTEGER*4       Zone
    POINTER         (ResultPtr, Result)

void TecUtilAxisGetRange char    Axis,
short    AxisNum,
double *    AxisMin,
double *    AxisMax
 

Get the current minimum and maximum values for the specified axis.

Parameters:
Axis  The axis to query. This can be one of `X', `Y' or `Z'
AxisNum  The axis number. For XY-plots this can be any number from one to five. For all other plots this must be one.
AxisMin  The current axis minimum value
AxisMax  The current axis maximum value
Fortran Syntax:

    SUBROUTINE TecUtilAxisGetRange(
   &           Axis,
   &           AxisNum,
   &           AxisMin,
   &           AxisMax)
    CHARACTER*(*)   Axis
    INTEGER*4       AxisNum
    REAL*8          AxisMin
    REAL*8          AxisMax

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);

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.

Parameters:
Zone  The number of the zone in which the PointIndex is located.
PointIndex  The index of the point of interest.
Returns:
TRUE if the data point is visible, FALSE if it is blanked.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilBlankingCheckDataPoint(
   &                   Zone,
   &                   PointIndex)
    INTEGER*4       Zone
    INTEGER*4       PointIndex

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 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.

Parameters:
Zone  The number of the zone in which the element is located. The zone must be finite-element.
CellIndex  The index of the element of interest.
Returns:
TRUE if the element is visible, FALSE if it is blanked.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilBlankingCheckFECell(
   &                   Zone,
   &                   CellIndex)
    INTEGER*4       Zone
    INTEGER*4       CellIndex

Zone 5 is finite-element. Determine if element number 13 of zone 5 is visible:

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.

Parameters:
Zone  The number of the zone in which the cell is located. The zone must be IJK-ordered.
ZonePlane  The plane in which the cell resides. For I or IJ-ordered data, use Planes_K. For IJK-ordered data, this determines what to use to determine the cell. The possible values are: Planes_I, Planes_J, Planes_K, or Planes_Volume.
CellIndex  The index of the cell of interest.
Returns:
TRUE if the cell is visible, FALSE if it is blanked.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilBlankingCheckIJKCell(
   &                   Zone,
   &                   ZonePlane,
   &                   CellIndex)
    INTEGER*4       Zone
    INTEGER*4       ZonePlane
    INTEGER*4       CellIndex

Zone 4 is IJ-ordered. Determine if cell 13 of zone 4 is visible:

void TecUtilColorMapGetBasicColorRGB ColorIndex_t    BasicColor,
ColorIndex_t   Red,
ColorIndex_t   Green,
ColorIndex_t   Blue
 

Get the RGB components of a basic color.

Parameters:
BasicColor  Index of basic color to query.
Red  Receives red component of the color. This parameter may be NULL.
Green  Receives green component of the color. This parameter may be NULL.
Blue  Receives blue component of the color. This parameter may be NULL
Returns:
None.
Fortran Syntax:

    SUBROUTINE TecUtilColorMapGetBasicColorRGB(
   &           BasicColor,
   &           Red,
   &           Green,
   &           Blue)
    INTEGER*4       BasicColor
    INTEGER*4       Red
    INTEGER*4       Green
    INTEGER*4       Blue

Get the RGB components of the Custom2_C basic color.

   {
   Byte R,G,B;
    TecUtilColorMapGetBasicColorRGB(Custom2_C,&R,&G,&B);
   }

LgIndex_t TecUtilColorMapNumBasicColors void   
 

Get the number of basic colors in Tecplot.

Returns:
The number of basic colors in Tecplot.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilColorMapNumBasicColors()

Get the number of basic colors in Tecplot.

   {
     LgIndex_t NumBasicColors;
   
     TecUtilLockStart(AddOnID);
     NumBasicColors = TecUtilColorMapNumBasicColors();
   
     TecUtilLockFinish(AddOnID);
   }

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.

The LevelValues array must be deallocated by the addon using TecUtilArrayDealloc.

Parameters:
ContourGroup  The contour group of interest and must be an integer between 1 and 4.
NumLevels  Pointer to an LgIndex_t variable that will receive the current number of levels for the specified contour group.
LevelValues  Pointer to a double pointer variable that will receive the allocated double array of level values or NULL if there are none
Returns:
FALSE if an allocation error occured otherwise TRUE.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilContourGetLevels(
   &                   ContourGroup,
   &                   NumLevels,
   &                   LevelValues)
    INTEGER*4       ContourGroup
    INTEGER*4       NumLevels
    REAL*8(*)       LevelValues

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);

EntIndex_t TecUtilDataConnectGetShareCount EntIndex_t    Zone
 

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.

Parameters:
Zone  Zone number where connectivity is to be branched.
Returns:
Number of zones sharing connectivity.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataConnectGetShareCount(Zone)
    INTEGER*4 Zone

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.

Parameters:
Element  The element number (starts at one)
Face  Face for which the face neighbor information is desired
NeighborsCompletelyObscure  Set to TRUE if the supplied neighbors completely obscure the face.
NumNeighbors  Number of neighbors for this face
NeighborElems  Array containing the element numbers of the neighbors
NeighborZones  Array containing the zone numbers of the neighbors
Returns:
TRUE if successful in assigning to the context, FALSE otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceNbrAssign(
   &                   Element,
   &                   Face,
   &                   NeighborsCompletelyObscure,
   &                   NumNeighbors,
   &                   NeighborElems,
   &                   NeighborZones)
    INTEGER*4       Element
    INTEGER*4       Face
    INTEGER*4       NeighborsCompletelyObscure
    INTEGER*4       NumNeighbors
    INTEGER*4       NeighborElems
    INTEGER*4       NeighborZones

Boolean_t TecUtilDataFaceNbrBeginAssign EntIndex_t    Zone
 

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.

Parameters:
Zone  Zone number to which the face neighors are to be assigned.
Returns:
TRUE if successful in opening the context, FALSE otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceNbrBeginAssign(Zone)
    INTEGER*4 Zone

Boolean_t TecUtilDataFaceNbrEndAssign void   
 

Closes the open face neighbor assignment context and packs the assignments into an efficient storage within Tecplot.

Returns:
TRUE if successful in assigning to the context, FALSE otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceNbrEndAssign()

LgIndex_t TecUtilDataFaceNbrGetByRef FaceNeighbor_pa    FaceNeighbor,
LgIndex_t    Element,
LgIndex_t    Face
 

Deprecated:
See also:
TecUtilDataFaceNbrGetNbrByRef TecUtilDataFaceNbrGetNumNByRef TecUtilDataFaceNbrGetModeByRef

LgIndex_t TecUtilDataFaceNbrGetByZone EntIndex_t    Zone,
LgIndex_t    Element,
LgIndex_t    Face
 

Deprecated:
See also:
TecUtilDataFaceNbrGetNbrByRef TecUtilDataFaceNbrGetNumNByRef TecUtilDataFaceNbrGetModeByRef

FaceNeighborMode_e TecUtilDataFaceNbrGetModeByRef FaceNeighbor_pa    FaceNeighbor
 

Returns the FaceNeigborMode_e value for the referenced face neighbor.

Parameters:
FaceNeighbor  The face neighbor handle to the specified zone in the data set attached to the current frame
Returns:
Mode of the face neighbor.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceNbrGetModeByRef(FaceNeighborPtr)
    POINTER (FaceNeighborPtr, FaceNeighbor)

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.

To use this function you must have already obtained a handle to face neighbors.

Parameters:
FaceNeighbor  Handle to the face neighbors. Use TecUtilDataFaceNbrGetRef to get handles to the face neighbors.
Element  The element number (starts at one).
Face  The face number of the element. Different element types have different number of faces. Use TecUtilZoneGetType to get the element type for a particular zone. Face numbers start at one.ZoneType_FETriangle: Three faces.ZoneType_FEQuad: Four faces.ZoneType_FETetra: Four faces.ZoneType_FEBrick: Six faces.Please see section 4.1.2.g "Face Neighbors" of the Tecplot User's Manual for a description of how nodes and faces map to one another.
NeighborNumber  Specify which neighbor to retrieve. Use TecUtilDataFaceNbrGetNumNByRef to get the number of neighbors
NeighborElem  Pointer that gives the value of the neighboring element number
NeighborZone  Pointer that gives the value of the neighboring zone number
Returns:
None.
Fortran Syntax:

    SUBROUTINE TecUtilDataFaceNbrGetNbrByRef(
   &           FaceNeighborPtr,
   &           Element,
   &           Face,
   &           NeighborNumber,
   &           NeighborElem,
   &           NeighborZone)
    POINTER         (FaceNeighborPtr, FaceNeighbor)
    INTEGER*4       Element
    INTEGER*4       Face
    INTEGER*4       NeighborNumber
    INTEGER*4       NeighborElem
    INTEGER*4       NeighborZone

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. * /
    }

LgIndex_t TecUtilDataFaceNbrGetNumNByRef FaceNeighbor_pa    FaceNeighbor,
LgIndex_t    Element,
LgIndex_t    Face
 

Gets the number of face neighbors for the elements's face.

Parameters:
FaceNeighbor  Handle to the face neighbors. Use TecUtilDataFaceNbrGetRef to get handles to the face neighbors
Element  The element number (starts at one)
Face  The face number of the element. Different element types have different number of faces. Use TecUtilZoneGetType to get the element type for a particular zone. Face numbers start at one.ZoneType_FETriangle: Three faces.ZoneType_FEQuad: Four faces.ZoneType_FETetra: Four faces.ZoneType_FEBrick: Six faces
Returns:
Number of neighbors for the element's face.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceNbrGetNumNByRef(
   &                   FaceNeighborPtr,
   &                   Element,
   &                   Face)
    POINTER         (FaceNeighborPtr, FaceNeighbor)
    INTEGER*4       Element
    INTEGER*4       Face

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);

void TecUtilDataFaceNbrGetRawPtr EntIndex_t    Zone,
LgIndex_t **    FNPtr
 

Deprecated:
This function is not replaced. Do not access face neighbors using raw pointers anymore.

FaceNeighbor_pa TecUtilDataFaceNbrGetRef EntIndex_t    Zone
 

Get a face neighbor handle to the specified zone in the data set attached to the current frame.

Parameters:
Zone  Number of the zone for which to get the face neighbor handle. This must be a finite-element zone
Returns:
The face neighbor handle to the specified zone in the data set attached to the current frame.
Fortran Syntax:

    SUBROUTINE TecUtilDataFaceNbrGetRef(
   &           Zone,
   &           ResultPtr)
    INTEGER*4       Zone
    POINTER         (ResultPtr, Result)

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.

Parameters:
Zone  Zone in which the cell exists. This must be a finite-element zone.
Face  Face of the finite-element cell. If the zone uses tetrahedrons this is a number between one and four. If the zone uses bricks this is a number between one and six. If the zone uses triangles or quadrilaterals then this is ignored.
CellIndex  The cell index (that is, the element number) to query.
I1  First Node index.
I2  Second Node index.
I3  Third Node index.
I4  Fourth Node index (not valid if triangle element).
Fortran Syntax:

    SUBROUTINE TecUtilDataFECellGetNodes(
   &           Zone,
   &           Face,
   &           CellIndex,
   &           I1,
   &           I2,
   &           I3,
   &           I4)
    INTEGER*4       Zone
    INTEGER*4       Face
    INTEGER*4       CellIndex
    INTEGER*4       I1
    INTEGER*4       I2
    INTEGER*4       I3
    INTEGER*4       I4

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);

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.

Parameters:
Zone  Zone in which the cell exists
Plane  Plane in which the cell resides. The possible values are: Planes_I, Planes_J, Planes_K or Planes_Volume. For I- or IJ-ordered data use Planes_K. For IJK-ordered data this determines which of the three faces (I, J, or K) to use to determine which cell to query.
CellIndex  The index of the lowest indexed corner of the cell to query
I1  First node index for the cell. If the zone is IJ-ordered or IJK-ordered, these indices are calculated from treating the two- or three-dimensional array as a one-dimensional array
I2  Second node index for the cell. If the zone is IJ-ordered or IJK-ordered, these indices are calculated from treating the two- or three-dimensional array as a one-dimensional array
I3  Third node index for the cell. If the zone is IJ-ordered or IJK-ordered, these indices are calculated from treating the two- or three-dimensional array as a one-dimensional array
I4  Fourth node index for the cell. If the zone is IJ-ordered or IJK-ordered, these indices are calculated from treating the two- or three-dimensional array as a one-dimensional array
Fortran Syntax:

    SUBROUTINE TecUtilDataIJKCellGetIndices(
   &           Zone,
   &           Plane,
   &           CellIndex,
   &           I1,
   &           I2,
   &           I3,
   &           I4)
    INTEGER*4       Zone
    INTEGER*4       Plane
    INTEGER*4       CellIndex
    INTEGER*4       I1
    INTEGER*4       I2
    INTEGER*4       I3
    INTEGER*4       I4

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);

LgIndex_t TecUtilDataNodeGetByRef NodeMap_pa    NodeMapPtr,
LgIndex_t    Element,
LgIndex_t    Corner
 

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.

Parameters:
NodeMapPtr  Handle to the connectivity list (that is, the node map). Use TecUtilDataNodeGetByRef or TecUtilZoneGetInfo to get handles to the zone map
Element  The element number (starts at 1)
Corner  The element corner (starts at 1)
Returns:
The index of the node.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataNodeGetByRef(
   &                   NodeMapPtrPtr,
   &                   Element,
   &                   Corner)
    POINTER         (NodeMapPtrPtr, NodeMapPtr)
    INTEGER*4       Element
    INTEGER*4       Corner

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 * /
     }

LgIndex_t TecUtilDataNodeGetByZone EntIndex_t    Zone,
LgIndex_t    Element,
LgIndex_t    Corner
 

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.

Parameters:
Zone  Zone number. This must be a finite-element zone.
Element  The element number (starts at 1)
Corner  The element corner (starts at 1)
Returns:
The index of the node.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataNodeGetByZone(
   &                   Zone,
   &                   Element,
   &                   Corner)
    INTEGER*4       Zone
    INTEGER*4       Element
    INTEGER*4       Corner

Get the third node of the 43rd element of zone 5:

   LgIndex_t n3;
   n3 = TecUtilDataNodeGetByZone(5, 43, 3);

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.

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.

Parameters:
Zone  Number of the zone for which to get the raw node map data. This must be a finite-element zone
NodeMapPtr  Receives address of the raw node map data
Fortran Syntax:

    SUBROUTINE TecUtilDataNodeGetRawPtr(
   &           Zone,
   &           NodeMapPtr)
    INTEGER*4       Zone
    POINTER         (NodeMapPtrPtr, NodeMapPtr)

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);
     }

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.

Parameters:
Zone  Number of the zone for which to get the node map handle. This must be a finite-element zone
Returns:
The finite-element node map handle to the specified zone in the data set attached to the current frame.
Fortran Syntax:

    SUBROUTINE TecUtilDataNodeGetRef(
   &           Zone,
   &           ResultPtr)
    INTEGER*4       Zone
    POINTER         (ResultPtr, Result)

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.

Parameters:
DataSetTitle  Character string containing the title of the data set attached to the current frame. If you pass NULL, this will not be assigned. Deallocate the returned string with TecUtilStringDealloc when you are done with it.
NumZones  The number of zones in the data set attached to the current frame. If you pass NULL, this will not be assigned
NumVars  The number of variables in the data set attached to the current frame. If you pass NULL, this will not be assigned.
Returns:
TRUE if successful, FALSE if not.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetGetInfo(
   &                   DataSetTitle,
   &                   DataSetTitleLength,
   &                   NumZones,
   &                   NumVars)
    CHARACTER*(*)   DataSetTitle
    INTEGER*4       DataSetTitleLength
    INTEGER*4       NumZones
    INTEGER*4       NumVars

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);

UniqueID_t TecUtilDataSetGetUniqueID void   
 

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.

Returns:
A unique id for the current data set.
Fortran Syntax:

    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);
   }

Boolean_t TecUtilDataSetIsAvailable void   
 

Determine if the current frame has a data set attached.

Returns:
TRUE if the current frame has an attached data set, FALSE if not.
Fortran Syntax:

    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);

Boolean_t TecUtilDataSetIsSharingAllowed void   
 

Query to see of the data set attached to the current frame is locked.

Returns:
Returns TRUE if sharing is allowed in Tecplot, FALSE if otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetIsSharingAllowed()

Boolean_t IsSharing;

Boolean_t TecUtilDataSetJournalIsValid void   
 

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.

Returns:
Returns TRUE if the data set journal is valid, FALSE otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetJournalIsValid()

Boolean_t TecUtilDataSetRequiresSaving void   
 

Deprecated:
See also:
TecUtilDataSetJournalIsValid

void TecUtilDataValueArrayGetByRef FieldData_pa    SourceFieldData,
LgIndex_t    SourceOffset,
LgIndex_t    SourceCount,
void *    DestValueArray
 

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.

double TecUtilDataValueGetByRef FieldData_pa    FieldData,
LgIndex_t    PointIndex
 

Get a field data value.

To use this function you must have already obtained a handle to field data.

Parameters:
FieldData  Handle to the field data. Use TecUtilDataValueGetRef or TecUtilZoneGetInfo to get handles to field data.
PointIndex  Position in the array of field data values. Position starts at one. If FieldData came from an IJ- or IJK-ordered zone then the position is calculated by treating the two- or three-dimensional array as a one-dimensional array.
Returns:
The value at a given position in field data FieldData
Fortran Syntax:

    REAL*8 FUNCTION TecUtilDataValueGetByRef(
   &                   FieldDataPtr,
   &                   PointIndex)
    POINTER         (FieldDataPtr, FieldData)
    INTEGER*4       PointIndex

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 * /
         }
     }

double TecUtilDataValueGetByZoneVar EntIndex_t    Zone,
EntIndex_t    Var,
LgIndex_t    PointIndex
 

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.

Parameters:
Zone  The zone number
Var  The variable number
PointIndex  Position in the array of field data values. Position starts at one. If FieldData came from an IJ- or IJK-ordered zone then the position is calculated by treating the two- or three-dimensional array as a one-dimensional array
Returns:
The variable value at a specific point in a zone.
Fortran Syntax:

    REAL*8 FUNCTION TecUtilDataValueGetByZoneVar(
   &                   Zone,
   &                   Var,
   &                   PointIndex)
    INTEGER*4       Zone
    INTEGER*4       Var
    INTEGER*4       PointIndex

Get the twenty-first value of the second variable of zone 5:

   double dd = TecUtilDataValueGetByZoneVar(5, 2, 21);
   / * Use val. * /

ValueLocation_e TecUtilDataValueGetLocation EntIndex_t    Zone,
EntIndex_t    Var
 

Queries the location of the variable: ValueLocation_CellCentered or ValueLocation_Nodal.

Parameters:
Zone  The zone number.
Var  The variable number
Returns:
The data type of the variable.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataValueGetLocation(
   &                   Zone,
   &                   Var)
    INTEGER*4       Zone
    INTEGER*4       Var

Get the location of variable 2 in zone 5:

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.

Parameters:
FieldData  Handle to the variable to be examined
Min  Returned minimum value
Max  Returned maximum value
Fortran Syntax:

    SUBROUTINE TecUtilDataValueGetMinMaxByRef(
   &           FieldDataPtr,
   &           Min,
   &           Max)
    POINTER         (FieldDataPtr, FieldData)
    REAL*8          Min
    REAL*8          Max

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);

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.

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.

Parameters:
Zone  Number of the zone for which to get the raw field data
Var  Number of the variable for which to get the raw field data
DataPtr  Receives the address of the raw field data
FieldDataType  Receives the data type of the raw field data. The following table shows the possible values for FieldDataType along with the corresponding data type that DataPtr references:
     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:

    SUBROUTINE TecUtilDataValueGetRawPtr(
   &           Zone,
   &           Var,
   &           DataPtr,
   &           FieldDataType)
    INTEGER*4       Zone
    INTEGER*4       Var
    POINTER         (DataPtrPtr, DataPtr)
    INTEGER*4       FieldDataType

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);
         }
     }

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.

Parameters:
Zone  Number of the zone for which to get the field data
Var  Number of the variable for which to get the field data
Returns:
The field data handle to the specified zone and variable in the data set attached to the current frame.
Fortran Syntax:

    SUBROUTINE TecUtilDataValueGetRef(
   &           Zone,
   &           Var,
   &           ResultPtr)
    INTEGER*4       Zone
    INTEGER*4       Var
    POINTER         (ResultPtr, Result)

FieldDataType_e TecUtilDataValueGetRefType FieldData_pa    FieldData
 

Get the field data type of a field data handle.

Parameters:
FieldData  The field data handle for which to get the type
Returns:
The field data type of FieldData. The possible values are: FieldDataType_Float FieldDataType_Double FieldDataType_LongInt FieldDataType_ShortInt FieldDataType_Byte FieldDataType_Bit
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataValueGetRefType(FieldDataPtr)
    POINTER (FieldDataPtr, FieldData)

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 * /
     }

EntIndex_t TecUtilDataValueGetShareCount EntIndex_t    Zone,
EntIndex_t    Var
 

Branch off a shared variable.

The specified variable of the specified zone is branched so it is no longer shared with anything.

Parameters:
Zone  Zone in which the shared variable is located.
Var  Variable that is shared.
Returns:
Returns share count for the given variable within the given zone. This is the number of times the data handle is shared. 1 means not shared (shared once), 2 means two zones share it, etc.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataValueGetShareCount(
   &                   Zone,
   &                   Var)
    INTEGER*4       Zone
    INTEGER*4       Var

Get share count of variable 2 in zone 1.

Boolean_t TecUtilDataValueIsSharingOk EntIndex_t    SourceZone,
EntIndex_t    DestZone,
EntIndex_t    Var
 

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.

Parameters:
SourceZone  The source zone (the zone where the values will be stored).
DestZone  The destination zone (the zone acquiring the shared values).
Var  The variable to be shared.
If sharing is ok for variable 7 between zones 3 and 5 then share the variable.

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.

Note: This function cannot be called when Tecplot is running in batch mode.

Parameters:
MaxRangeValue  Maximum value for the range. Currently, this value is displayed at the top of the Enter Index Range dialog and also used to interpret zero and negative values for the other parameters, but it does not limit what values the user can enter. You must check the values of the other parameters upon return and check their validity in your code. A value of zero for MaxRangeValue will turn off the maximum value processing
Min  The value passed in is the default value displayed in the minimum text field. Upon return, this value holds the user-specified minimum value. If MaxRangeValue is not zero, a Min of zero is interpreted as MaxRangeValue, and negative values of Min are interpreted as subtracted from MaxRangeValue
Max  The value passed in is the default value displayed in the maximum text field. Upon return, this value holds the user-specified maximum value. Zero and negative values are interpreted as with Min above
Skip  The value passed in is the default value displayed in the skip text field. Upon return, this value holds the user-specified skip value. Zero and negative values are interpreted as with Min above
Returns:
TRUE if successful, FALSE if not. FALSE usually indicates that Cancel on the dialog was clicked.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDialogGetIndexRange(
   &                   MaxRangeValue,
   &                   Min,
   &                   Max,
   &                   Skip)
    INTEGER*4       MaxRangeValue
    INTEGER*4       Min
    INTEGER*4       Max
    INTEGER*4       Skip

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 * /

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.

Note: This function cannot be called when Tecplot is running in batch mode.

Parameters:
Instructions  String containing the instructions for the user. Tecplot will wrap the instructions for you. However, if you include a newline in the string it will force a new line. Under Windows you are limited to three lines of text
DefaultText  Set to TRUE if the Text parameter being passed in has been preset with a default value for the user. May be NULL
Text  The resulting text string is placed here.
Returns:
TRUE if the user enters text and clicks OK.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDialogGetSimpleText(
   &                   Instructions,
   &                   DefaultText,
   &                   Text,
   &                   TextLength)
    CHARACTER*(*)   Instructions
    CHARACTER*(*)   DefaultText
    CHARACTER*(*)   Text
    INTEGER*4       TextLength

Prompt the user for text:

   char *Text = NULL;
   
   if (TecUtilDialogGetSimpleText("Enter your name","Fred",&Text))
      {
       / * Do somthing with Text * /
       TecUtilStringDealloc(&Text);
      }

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.

Note: This function cannot be called when Tecplot is running in batch mode.

Parameters:
Instructions  Character string displayed at the top of the dialog. Must not be NULL
TextField1Label  Character string displayed to the left of the first variable's selection menu. May be NULL
TextField2Label  Character string displayed to the left of the second variable's selection menu. Only used if Var2 is not NULL. May be NULL
TextField3Label  Character string displayed to the left of the third variable's selection menu. Only used if Var3 is not NULL. May be NULL.
Var1  Value passed in is the default value displayed in the first variable's selection menu. Must not be NULL, and must be a valid variable number. Upon return, this value holds the user-selected first variable value
Var2  Value passed in is the default value displayed in the second variable's selection menu. Use NULL to prompt for only one variable. May be NULL, but if not NULL, must be a valid variable number. Upon return, this value holds the user-selected second variable value
Var3  Value passed in is the default value displayed in the third variable's selection menu. Use NULL to prompt for only one or two variables. May be NULL, but if not NULL, must be a valid variable number. Upon return, this value holds the user-selected third variable value.
Returns:
TRUE if successful, FALSE if not. FALSE usually indicates that Cancel on the dialog was clicked.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDialogGetVariables(
   &                   Instructions,
   &                   TextField1Label,
   &                   TextField2Label,
   &                   TextField3Label,
   &                   Var1,
   &                   Var2,
   &                   Var3)
    CHARACTER*(*)   Instructions
    CHARACTER*(*)   TextField1Label
    CHARACTER*(*)   TextField2Label
    CHARACTER*(*)   TextField3Label
    INTEGER*4       Var1
    INTEGER*4       Var2
    INTEGER*4       Var3

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 * /
   }

Boolean_t TecUtilDialogMessageBox const char *    Message,
MessageBoxType_e    MessageBoxType
 

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.

Parameters:
Message  Character string to display at the top of the dialog. Must not be NULL
MessageBoxType  The possible values are: Buttons Included:MessageBox_Error : OKMessageBox_Warning : OKMessageBox_Information : OKMessageBox_Question : OK, CancelMessageBox_YesNo : Yes, No
Returns:
TRUE if the OK or Yes is clicked, FALSE if Cancel or No is clicked.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDialogMessageBox(
   &                   Message,
   &                   MessageBoxType)
    CHARACTER*(*)   Message
    INTEGER*4       MessageBoxType

Prompt the user for a response to a question:

   if (TecUtilDialogMessageBox("Do you like green eggs and ham?",
                               MessageBox_Question))
    {
     / * do something here... * /
    }

Boolean_t TecUtilFieldLayerIsActive const char *    LayerShowFlag
 

Indicates if the field layer of interest is active or not.

Parameters:
LayerShowFlag  The show flag for the field layer of interest. Possible values are: SV_SHOWMESH, SV_SHOWCONTOUR, SV_SHOWVECTOR, SV_SHOWSCATTER, SV_SHOWSHADE or SV_SHOWBOUNDARY
Returns:
TRUE if the specified field layer is active.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilFieldLayerIsActive(LayerShowFlag)
    CHARACTER*(*) LayerShowFlag

Determine if the field's contour layer is on:

   if (TecUtilFieldLayerIsActive(SV_SHOWCONTOUR))
     {
       / * do something with the field's contour level * /
   
     }

ArbParam_t TecUtilFieldStyleGetArbValue EntIndex_t    Zone,
const char *    S1,
const char *    S2,
const char *    S3
 

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().

Returns:
The queried attribute. This must be cast to the appropriate type.
Parameters:
Zone  Zone number to query
S1  First parameter that defines the attribute to query. The parameters follow the same order that you would use when constructing a set value macro command. If a parameter is not used, then it must be NULL. If you are not sure of the possible values for an enumerated type, you can find the definitions in the Include/GLOBAL.h directory, below the Tecplot home directory. These parameters are actually strings, but you can use the supplied SV_ constants from the SV.h include file. Using the SV_ constants will help prevent misspellings and other errors.
S2  Second parameter that defines the attribute to query. See S1.
S3  Third parameter that defines the attribute to query. See S1.
Fortran Syntax:

    SUBROUTINE TecUtilFieldStyleGetArbValue(
   &           Zone,
   &           S1,
   &           S2,
   &           S3,
   &           ResultPtr)
    INTEGER*4       Zone
    CHARACTER*(*)   S1
    CHARACTER*(*)   S2
    CHARACTER*(*)   S3
    POINTER         (ResultPtr, Result)

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);
   }

double TecUtilFieldStyleGetDoubleValue EntIndex_t    Zone,
const char *    S1,
const char *    S2,
const char *    S3
 

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().

Parameters:
Zone  Zone number to query.
S1  First parameter used to define the attribute to query. The parameters follow the same order that you would use when constructing the $!FIELD macro command.
S2  Second parameter used to define the attribute to query. See S1.
S3  Third parameter used to define the attribute to query. See S1.
Returns:
The queried attribute.
Fortran Syntax:

    REAL*8 FUNCTION TecUtilFieldStyleGetDoubleValue(
   &                   Zone,
   &                   S1,
   &                   S2,
   &                   S3)
    INTEGER*4       Zone
    CHARACTER*(*)   S1
    CHARACTER*(*)   S2
    CHARACTER*(*)   S3

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);
   }

Boolean_t TecUtilFileGetTempName char **    TempFileName
 

Creates a temporary file name, including a full path.

An empty file with the temporary is file name is also created.

Parameters:
TempFileName  Receives the temporary file name, including path. You must later free this string with TecUtilStringDealloc()
Returns:
TRUE if successful, FALSE otherwise. If the return value is FALSE, *FileName is set to NULL.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilFileGetTempName(
   &                   TempFileName,
   &                   TempFileNameLength)
    CHARACTER*(*)   TempFileName
    INTEGER*4       TempFileNameLength

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. * /
       }
   }

int TecUtilFrameGetCount void   
 

Get a count of the number of frames currently defined.

Returns:
Number of frames defined.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilFrameGetCount()

ArbParam_t TecUtilFrameGetLinking const char *    Attribute
 

Deprecated:
See also:
TecUtilLinkingGetValue

FrameMode_e TecUtilFrameGetMode void   
 

Deprecated:
See also:
TecUtilFrameGetPlotType

PlotType_e TecUtilFrameGetPlotType void   
 

Get the plot type of the current frame.

Returns:
The Plot Type can be one of the following possible values: PlotType_Automatic, PlotType_Cartesian2D, PlotType_Cartesian3D, PlotType_XYLine or PlotType_Sketch
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilFrameGetPlotType()

Do something when the frame mode is 3D:

   if ( TecUtilFrameGetPlotType() == PlotType_XYLine )
     {
       / * do something * /
     }

void TecUtilFrameGetPosAndSize double *    X,
double *    Y,
double *    Width,
double *    Height
 

Get the position and size of a frame.

Parameters:
X  Returned X-Coordinate for left hand side of the frame (in inches) relative to the left hand side of the paper.
Y  Returned Y-Coordinate for top of the frame (in inches) relative to the top of the paper.
Width  Width of the frame (in inches).
Height  Height of the frame (in inches).
Returns:
None.
Fortran Syntax:

    SUBROUTINE TecUtilFrameGetPosAndSize(
   &           X,
   &           Y,
   &           Width,
   &           Height)
    REAL*8          X
    REAL*8          Y
    REAL*8          Width
    REAL*8          Height

Get the current frame's position and size:

   double x, y, width, height;
   TecUtilFrameGetPosAndSize(&x, &y, &width, &height);

UniqueID_t TecUtilFrameGetUniqueID void   
 

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().

Returns:
A unique id for the current frame.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilFrameGetUniqueID()

Push the current frame using a unique id.

Geom_ID TecUtilGeomGetBase void   
 

Get the base geometry attached to the current frame.

Returns:
Returns TECUTILBADID if the current frame does not have any attached geometries, otherwise, a valid geometry ID. Use TecUtilGeomGetNext to get successive geometries.
Fortran Syntax:

    SUBROUTINE TecUtilGeomGetBase(ResultPtr)
    POINTER        (ResultPtr, Result)

LgIndex_t TecUtilGetTecplotVersion void   
 

Get the version of Tecplot.

Returns:
The current Tecplot version. This is expressed as 750000 for Tecplot 7.5, 750105 for Tecplot 7.5-1-5, 900000 for Tecplot 9.0, and so on.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilGetTecplotVersion()

Get the current version of Tecplot:

   LgIndex_t Ver = TecUtilGetTecplotVersion();
   if (Ver >= 750000) && (Ver <= 900000)
     .
     .
   else if (Ver >= 900000)
     .
     .

Boolean_t TecUtilGetTempFileName char **    TempFileName
 

Deprecated:
See also:
TecUtilFileGetTempName

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.

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.

Parameters:
DataSetLoaderName  Name of the data set loader. You must use TecUtilStringDealloc to free this string when you are done with it.
DataSetLoaderInstructions  The data set loader instructions. You must use TecUtilStringListDealloc to free this string list when you are done with it.
Returns:
Returns TRUE if the data was loaded using a data set loader.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilImportGetLoaderInstr(
   &                   DataSetLoaderName,
   &                   DataSetLoaderNameLength,
   &                   DataSetLoaderInstructionsPtr)
    CHARACTER*(*)   DataSetLoaderName
    INTEGER*4       DataSetLoaderNameLength
    POINTER         (DataSetLoaderInstructionsPtr, DataSetLoaderInstructions)

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);
     }

void TecUtilInterfaceGetDotsPerInch double *    VDotsPerInch,
double *    HDotsPerInch
 

Get the number of pixels per inch in the vertical and horizontal directions on the screen.

Parameters:
VDotsPerInch  The number of pixels per inch in the vertical direction
HDotsPerInch  The number of pixels per inch in the horizontal direction.
Returns:
None
Fortran Syntax:

    SUBROUTINE TecUtilInterfaceGetDotsPerInch(
   &           VDotsPerInch,
   &           HDotsPerInch)
    REAL*8          VDotsPerInch
    REAL*8          HDotsPerInch

Get the pixels per inch values:

   double VertPixels, HorzPixels;
   TecUtilInterfaceGetDotsPerInch(&VertPixels, &HorzPixels);

LgIndex_t TecUtilLimitGetValue const char *    LimitString
 

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.

Parameters:
LimitString  This must be one of the following: MaxPtsInALine, MaxChrsInTextLabels, MaxNumContourLevels, MaxPreplotZones, IPCTimeoutSeconds.
Returns:
Returns the limit value as an integer.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilLimitGetValue(LimitString)
    CHARACTER*(*) LimitString

Get the number of points allowed per polyline in Tecplot:

   LgIndex_t MaxPtsPerLine;
   MaxPtsPerLine = TecUtilLimitGetValue("MaxPtsInALine");

Boolean_t TecUtilLineMapGetActive Set_pa   ActiveLineMaps
 

Obtain the set of active Line-maps.

Parameters:
ActiveLineMaps  Receives the set of active Line-maps.Note: You must call TecUtilSetDealloc when you are through using the set. It must not be NULL
Returns:
TRUE if successful.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilLineMapGetActive(ActiveLineMapsPtr)
    POINTER (ActiveLineMapsPtr, ActiveLineMaps)

Get the set of active Line-maps:

   Set_pa s = NULL;
   if (TecUtilLineMapGetActive(&s))
   {
    / * maps are now in s * /
    TecUtilSetDealloc(&s);
   }

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.

Parameters:
LineMap  Map number to query
Zone  Zone number assigned to the Line-map. Set to NULL if you are not interested in this returned value.
XOrThetaVar  Receives the X-axis or Theta variable number assigned to the Line-map. Will only receive a Theta value if plot is in polar mode. Set to NULL if you are not interested in this returned value
YOrRVar  Receives the Y-axis or Radian variable number assigned to the Line-map. Will only receive Radian value if plot is in polar mode. Set to NULL if you are not interested in this returned value.
XAxis  Receives the X-axis number assigned to the Line-map. Set to NULL if you are not interested in this returned value.
YAxis  Receives the Y-axis number assigned to the Line-map. Set to NULL if you are not interested in this returned value
FunctionDependency  Receives thefFunction dependency assigned to the Line-map. Set to NULL if you are not interested in this returned value
Fortran Syntax:

    SUBROUTINE TecUtilLineMapGetAssignment(
   &           LineMap,
   &           Zone,
   &           XOrThetaVar,
   &           YOrRVar,
   &           XAxis,
   &           YAxis,
   &           FunctionDependency)
    INTEGER*4       LineMap
    INTEGER*4       Zone
    INTEGER*4       XOrThetaVar
    INTEGER*4       YOrRVar
    INTEGER*4       XAxis
    INTEGER*4       YAxis
    INTEGER*4       FunctionDependency

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);

EntIndex_t TecUtilLineMapGetCount void   
 

Returns the number of Line-maps.

Returns:
The number of Line-maps.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilLineMapGetCount()

Boolean_t TecUtilLineMapGetName EntIndex_t    Map,
char **    Name
 

Get the name of an Line-map.

Parameters:
Map  Number of the Line-map
Name  Allocated string containing the Line-map name
Returns:
Returns TRUE if successful, FALSE otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilLineMapGetName(
   &                   Map,
   &                   Name,
   &                   NameLength)
    INTEGER*4       Map
    CHARACTER*(*)   Name
    INTEGER*4       NameLength

Get the name of Line-map 3:

   Boolean_t IsOk;
   char *MapName = NULL;
   IsOk = TecUtilLineMapGetName(3,&MapName);

Boolean_t TecUtilLineMapIsActive EntIndex_t    LineMap
 

Determine if an Line-map is active.

Returns:
Returns TRUE if the Line-map is active, FALSE otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilLineMapIsActive(LineMap)
    INTEGER*4 LineMap

ArbParam_t TecUtilLineMapStyleGetArbValue EntIndex_t    LineMap,
const char *    S1,
const char *    S2,
const char *    S3
 

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().

Parameters:
LineMap  Line-map number to query
S1  First parameter used to define the attribute to query. The parameters follow the same order that you would use when constructing a set value macro command. If a parameter is not used, then it must be NULL.These parameters are actually strings, but you can use the supplied SV_ constants from the SV.h include file. Using the SV_ constants will help prevent misspellings and other errors.If you are not sure of the possible values for an enumerate type, you can find the definitions in Include/GLOBAL.h below the Teclot home directory.
S2  Second parameter used to define the attribute to query. See S1.
S3  Third parameter used to define the attribute to query. See S1.This function will assert if the combination of parameters or the LineMap number is invalid.
Returns:
The queried attribute. This must be cast to the appropriate type (see the table below). If the return type is a char *, then you must call TecUtilStringDealloc() to free the string.
Fortran Syntax:

    SUBROUTINE TecUtilLineMapStyleGetArbValue(
   &           LineMap,
   &           S1,
   &           S2,
   &           S3,
   &           ResultPtr)
    INTEGER*4       LineMap
    CHARACTER*(*)   S1
    CHARACTER*(*)   S2
    CHARACTER*(*)   S3
    POINTER         (ResultPtr, Result)

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);

double TecUtilLineMapStyleGetDoubleValue EntIndex_t    LineMap,
const char *    S1,
const char *    S2,
const char *    S3
 

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().

Parameters:
LineMap  Line-map number to query
S1  First parameter used to define the attribute to query. The parameters follow the same order that you would use when constructing a set value macro command. If a parameter is not used, then it must be NULL.These parameters are actually strings, but you can use the supplied SV_ constants from the SV.h include file. Using the SV_ constants will help prevent misspellings and other errors.If you are not sure of the possible values for an enumerate type, you can find the definitions in Include/GLOBAL.h below the Teclot home directory.
S2  Second parameter used to define the attribute to query. See S1.
S3  Third parameter used to define the attribute to query. See S1.
Returns:
The queried attribute.
Fortran Syntax:

    REAL*8 FUNCTION TecUtilLineMapStyleGetDoubleValue(
   &                   LineMap,
   &                   S1,
   &                   S2,
   &                   S3)
    INTEGER*4       LineMap
    CHARACTER*(*)   S1
    CHARACTER*(*)   S2
    CHARACTER*(*)   S3

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);
   }

Boolean_t TecUtilLinePlotLayerIsActive const char *    LayerShowFlag
 

Indicates if the line plot layer of interest is active or not.

Parameters:
LayerShowFlag  Show flag for the line plot layer of interest.
Returns:
TRUE if the specific layer in a line plot is active, FALSE otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilLinePlotLayerIsActive(LayerShowFlag)
    CHARACTER*(*) LayerShowFlag

Determine if the line plot's symbol layer is on:

   if (TecUtilLinePlotLayerIsActive(SV_SHOWSYMBOLS))
     {
       / *Do something with the line plot's symbols * /
     }

ArbParam_t TecUtilLinkingGetValue const char *    Attribute,
const char *    SubAttribute
 

Gets frame linking attributes.

Parameters:
Attribute  Valid values: SV_BETWEENFRAMES and SV_WITHINFRAME.
SubAttribute  Attribute to set. For Attribute SV_BETWEENFRAMES the subattribute must be one of SV_LINKCONTOURLEVELS, SV_LINKFRAMESIZEANDPOSITION, SV_LINKXAXISRANGE, SV_LINKYAXISRANGE, SV_LINK3DVIEW, SV_LINKGROUP. For Attribute SV_WITHINFRAME the subattribute must be one of SV_LINKAXISSTYLE, SV_LINKGRIDLINESTYLE, SV_LINKLAYERLINECOLOR, SV_LINKLAYERLINEPATTERN
Returns:
The type of return value is dependent upon the attribute parameter. If the subattribute is SV_LINKGROUP, the return value is the Group Number and should be cast to a SmInteger_t, otherwise the return value is TRUE or FALSE and should be cast to a Boolean_t.
Fortran Syntax:

    SUBROUTINE TecUtilLinkingGetValue(
   &           Attribute,
   &           SubAttribute,
   &           ResultPtr)
    CHARACTER*(*)   Attribute
    CHARACTER*(*)   SubAttribute
    POINTER         (ResultPtr, Result)

Query the group number of the current frame:

   SmInteger_t GroupNumber;
   GroupNumber = (SmInteger_t)TecUtilFrameGetLinking(SV_BETWEENFRAMES, 
               SV_LINKGROUP);

int TecUtilLockGetCount void   
 

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.

Returns:
The number of times Tecplot has been locked without being unlocked.
Fortran Syntax:

    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);
     }

Boolean_t TecUtilLockIsOn void   
 

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.

Returns:
TRUE, if Tecplot is locked. FALSE, if it is not locked.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilLockIsOn()

Boolean_t TecUtilMacroFunctionExists const char *    FunctionName
 

Query Tecplot to see if a macro function called FunctionName exists.

Note: This function requires Tecplot Version 7.5-0-6 or newer.

Parameters:
FunctionName  Name of the macro function
Returns:
TRUE if the function exists, otherwise FALSE.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilMacroFunctionExists(FunctionName)
    CHARACTER*(*) FunctionName

If the macro function "abc" exists, then execute it.

   if (TecUtilMacroFunctionExists("abc"))
      {
         TecUtilMacroRunFunction("abc",(char *)NULL);
      }

Boolean_t TecUtilMacroIsBatchModeActive void   
 

Determine if Tecplot is currently running in batch mode.

Returns:
TRUE if Tecplot is in batch mode, otherwise FALSE.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilMacroIsBatchModeActive()

Perform some operations if Tecplot is not running in batch mode:

   if (!TecUtilMacroIsBatchModeActive())
     {
       / *  Perform some operations  * /
     }

Boolean_t TecUtilMacroIsRecordingActive void   
 

Determine if Tecplot is currently recording a macro.

Returns:
TRUE if Tecplot is recording macros, otherwise FALSE.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilMacroIsRecordingActive()

If Tecplot is currently recording a macro, record the macro command "GO" for the addon "BANANA":

void TecUtilPaperGetDimensions double *    Width,
double *    Height
 

Get the dimensions of the currently defined paper in the Tecplot workspace.

Parameters:
Width  Width of the paper (in inches).
Height  Height of the paper (in inches).
Returns:
None.
Fortran Syntax:

    SUBROUTINE TecUtilPaperGetDimensions(
   &           Width,
   &           Height)
    REAL*8          Width
    REAL*8          Height

Get the current paper's position and size:

   double width, height;
   TecUtilPaperGetDimensions(&width, &height);

char TecUtilPickListGetAxisKind int    PickListIndex
 

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.

Parameters:
PickListIndex  Index into the pick list
Returns:
The kind of axis from the pick list at the specified index.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickListGetAxisKind(PickListIndex)
    INTEGER*4 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);
           .
           .
         }
     }

int TecUtilPickListGetAxisNumber int    PickListIndex
 

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.

Parameters:
PickListIndex  Index into the pick list
Returns:
For Sketch, 2-D, and 3-D plots, the return value is one. For XY plots, returns the axis number from the pick list at the specified index.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickListGetAxisNumber(PickListIndex)
    INTEGER*4 PickListIndex

int TecUtilPickListGetCount void   
 

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.

Returns:
Returns the number of items currently in the pick list.
Fortran Syntax:

    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                              * /
     }

char* TecUtilPickListGetFrameName int    PickListIndex
 

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.

Parameters:
PickListIndex  Index into the pick list.
Returns:
The name of the frame from the pick list at the specified index. You must call TecUtilStringDealloc on the returned string.
Fortran Syntax:

    SUBROUTINE TecUtilPickListGetFrameName(
   &           PickListIndex,
   &           Result,
   &           ResultLength)
    INTEGER*4       PickListIndex
    CHARACTER*(*)   Result
    INTEGER*4       ResultLength

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);
     }

UniqueID_t TecUtilPickListGetFrameUniqueID int    PickListIndex
 

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.

Parameters:
PickListIndex  Index into the pick list
Returns:
The unique identifier of the frame from the pick list at the specified index.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickListGetFrameUniqueID(PickListIndex)
    INTEGER*4 PickListIndex

If the first object in the pick list is a frame, get its unique identifier:

Geom_ID TecUtilPickListGetGeom int    PickListIndex
 

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.

Parameters:
PickListIndex  Index into the pick list
Returns:
The geometry ID from the pick list at the specified index.
Fortran Syntax:

    SUBROUTINE TecUtilPickListGetGeom(
   &           PickListIndex,
   &           ResultPtr)
    INTEGER*4      PickListIndex
    POINTER        (ResultPtr, Result)

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);
         }
     }

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.

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.

Parameters:
PickListIndex  Index into the pick list.
PolylineNum  The number of the polyline that was selected if the geometry is a line segment and the Adjustor mode is being used. Otherwise, zero
PointIndex  The index of the specific point that was selected in the polyline if the geometry is a line segment and the Adjustor mode is being used. Otherwise, zero.
Returns:
None.
Fortran Syntax:

    SUBROUTINE TecUtilPickListGetGeomInfo(
   &           PickListIndex,
   &           PolylineNum,
   &           PointIndex)
    INTEGER*4       PickListIndex
    INTEGER*4       PolylineNum
    INTEGER*4       PointIndex

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.

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.

Parameters:
PickListIndex  Index into the pick list.
Returns:
The index value of the specific point that was selected in the Line-mapping from the pick list at the specified index if the Adjustor mode is being used. Otherwise, zero.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickListGetLineMapIndex(PickListIndex)
    INTEGER*4 PickListIndex

If the first object in the pick list is an Line-mapping, get its number and index:

EntIndex_t TecUtilPickListGetLineMapNumber int    PickListIndex
 

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.

Parameters:
PickListIndex  Index into the pick list.
Returns:
The number of the Line-mapping from the pick list at the specified index.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickListGetLineMapNumber(PickListIndex)
    INTEGER*4 PickListIndex

Text_ID TecUtilPickListGetText int    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.

Parameters:
PickListIndex  Index into the pick list
Returns:
The text ID from the pick list at the specified index.
Fortran Syntax:

    SUBROUTINE TecUtilPickListGetText(
   &           PickListIndex,
   &           ResultPtr)
    INTEGER*4      PickListIndex
    POINTER        (ResultPtr, Result)

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);
         }
     }

PickObjects_e TecUtilPickListGetType int    PickListIndex
 

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.

Parameters:
PickListIndex  Index into the pick list
Returns:
The type of object from the pick list at the specified index.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickListGetType(PickListIndex)
    INTEGER*4 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;
          .
          .
        }
     }

LgIndex_t TecUtilPickListGetXYMapIndex int    PickListIndex
 

Deprecated:
See also:
TecUtilPickListGetLineMapIndex

EntIndex_t TecUtilPickListGetXYMapNumber int    PickListIndex
 

Deprecated:
See also:
TecUtilPickListGetLineMapNumber

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.

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.

Parameters:
PickListIndex  Index into the pick list
IIndex  The I-index value of the point that was selected in the zone
JIndex  The J-index value of the point that was selected in the zone
KIndex  The K-index value of the point that was selected in the zone
Returns:
None.
Fortran Syntax:

    SUBROUTINE TecUtilPickListGetZoneIndices(
   &           PickListIndex,
   &           IIndex,
   &           JIndex,
   &           KIndex)
    INTEGER*4       PickListIndex
    INTEGER*4       IIndex
    INTEGER*4       JIndex
    INTEGER*4       KIndex

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);
      .
      .
     }

EntIndex_t TecUtilPickListGetZoneNumber int    PickListIndex
 

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.

Parameters:
PickListIndex  Index into the pick list
Returns:
The number of the zone from the pick list at the specified index.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickListGetZoneNumber(PickListIndex)
    INTEGER*4 PickListIndex

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.

The current frame must have an attached data set when this function is called.

Parameters:
X  The X-position at which to probe.
Y  The Y-position at which to probe.
Z  The Z-position at which to probe. Only required if plot type is 3D. Note: If the frame mode is 3D and SearchVolume is FALSE, then only X and Y are used and they are assumed to be the XY coordinates in the eye coordinate system. The returned probe will be the location on the first surface encountered in the eye coordinate system
ICell  Returns the I-Index of the cell in which the data point was found. If StartWithLocalCell is TRUE, then this must be pre-set to the I-index of the cell in which to start looking.
JCell  Returns the J-Index of the cell in which the data point was found. If StartWithLocalCell is TRUE, then this must be pre-set to the J-index of the cell in which to start looking.
KCell  Returns the K-Index of the cell in which the data point was found. If StartWithLocalCell is TRUE, then this must be pre-set to the K-index of the cell in which to start looking.
Plane  If the current frame is 3D, the plane of the cell in which the data point was found is returned. (Ignore if SearchVolume is TRUE.) Plane must be pre-set if the current frame is 2D and StartWithLocalCell is TRUE and the zone is not finite element. Plane can be one of: Planes_I Planes_J Planes_K
CurZone  Returns the zone of the cell in which the data point was found
StartWithLocalCell  TRUE if the search should be started in the area of cell *ICell,*JCell,*KCell. FALSE if the search should not be started in any particular cell
VValue_Array  An array of doubles which is the size of the number of variables in the data set. The array must be allocated by the calling function. If TecUtilProbeAtPosition returns TRUE and GetZoneOnly is FALSE, the array will be filled with the values of each variable at the probed position
SourceZones  The set of zones to which to limit the search. Set to NULL to search all zones
SearchVolume  Set to TRUE if the XYZ coordinates represent a data point inside of a 3-D volume zone. Set to FALSE to use the XY coordinates only which will return a point on the surface of a zone
GetZoneOnly  Set to TRUE to do the minimal work necessary to only update the CurZone variable
GetNearestPoint  TRUE to return values for the nearest grid point, FALSE to return interpolated values for the exact XYZ coordinates. A value of TRUE will cause this function to return FALSE if the initial probe does not fall within a cell
Returns:
TRUE if successful, FALSE if not. FALSE usually indicates that the data point could not be found.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilProbeAtPosition(
   &                   X,
   &                   Y,
   &                   Z,
   &                   ICell,
   &                   JCell,
   &                   KCell,
   &                   Plane,
   &                   CurZone,
   &                   StartWithLocalCell,
   &                   VValue_Array,
   &                   SourceZonesPtr,
   &                   SearchVolume,
   &                   GetZoneOnly,
   &                   GetNearestPoint)
    REAL*8          X
    REAL*8          Y
    REAL*8          Z
    INTEGER*4       ICell
    INTEGER*4       JCell
    INTEGER*4       KCell
    INTEGER*4       Plane
    INTEGER*4       CurZone
    INTEGER*4       StartWithLocalCell
    REAL*8          VValue_Array
    POINTER         (SourceZonesPtr, SourceZones)
    INTEGER*4       SearchVolume
    INTEGER*4       GetZoneOnly
    INTEGER*4       GetNearestPoint

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.       * /
      }

Boolean_t TecUtilStateIsProcessingJournal void   
 

Query Tecplot to find out if Tecplot is in the middle of processing the data journal.

Returns:
Returns TRUE if Tecplot is processing the data journal, otherwise FALSE.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStateIsProcessingJournal()

Boolean_t TecUtilStateIsProcessingLayout void   
 

Query Tecplot to find out if Tecplot is in the middle of processing a layout.

Returns:
Returns TRUE if Tecplot is processing a layout, otherwise FALSE.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStateIsProcessingLayout()

GetValueReturnCode_e TecUtilStyleGetLowLevelX ArgList_pa    ArgList
 

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.

Parameters:
ArgList  Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions.

Arglist Values

SV_P1
Type: char *
Arg Function: TecUtilArgListAppendString
Default: --
Required: No
Notes: and SV_GLOBALTHREEDVECTOR.

SV_P2
Type: char *
Arg Function: TecUtilArgListAppendString
Default: --
Required: No
Notes:

SV_P3
Type: char *
Arg Function: TecUtilArgListAppendString
Default: --
Required: No
Notes:

SV_P4
Type: char *
Arg Function: TecUtilArgListAppendString
Default: --
Required: No
Notes:

SV_P5
Type: char *
Arg Function: TecUtilArgListAppendString
Default: --
Required: No
Notes:

SV_P6
Type: char *
Arg Function: TecUtilArgListAppendString
Default: --
Required: No
Notes:

SV_OFFSET1
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt
Default: --
Required: No
Notes: Depending on the command the first offset is used to denote the zone, line map, or contour group of interest.

SV_OFFSET2
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt
Default: --
Required: No
Notes: number for a specified contour group

SV_DVALUE
Type: double *
Arg Function: TecUtilArgListAppendDoublePtr
Default: --
Required: No
Notes: Address to a variable of type double where the double valued result of the query can be stored

SV_IVALUE
Type: double *
Arg Function: TecUtilArgListAppendDoublePtr
Default: --
Required: No
Notes: TecUtilArrayDealloc

SV_IVALUE
Type: ArbParam_t *
Arg Function: TecUtilArgListAppendArbParamPtr
Default: --
Required: No
Notes:


Returns:
The function return value is of type GetValueReturnCode_e with the following possible values:
 *   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:

    INTEGER*4 FUNCTION TecUtilStyleGetLowLevelX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

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);

char* TecUtilTecplotGetHomeDirectory void   
 

Get the Tecplot home directory.

Returns:
The Tecplot home directory. This is specified by the TEC100HOME environment variable, or the -h flag used when launching Tecplot from the command line.
Fortran Syntax:

    SUBROUTINE TecUtilTecplotGetHomeDirectory(
   &           Result,
   &           ResultLength)
    CHARACTER*(*)   Result
    INTEGER*4       ResultLength

Get the Tecplot home directory.

   char *TecHome = NULL;
   
   TecUtilLockStart(AddOnID);
   TecHome = TecUtilTecplotGetHomeDirectory();
   .....
   TecUtilStringDealloc(&TecHome);
   TecUtilLockFinish(AddOnID);

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.

Parameters:
T  Handle to a text object.
X1  Returned X-Coordinate for bottom left corner of the text box.
Y1  Returned Y-Coordinate for bottom left corner of the text box.
X2  Returned X-Coordinate for bottom right corner of the text box.
Y2  Returned Y-Coordinate for bottom right corner of the text box.
X3  Returned X-Coordinate for upper right corner of the text box.
Y3  Returned Y-Coordinate for upper right corner of the text box.
X4  Returned X-Coordinate for upper left corner of the text box.
Y4  Returned Y-Coordinate for upper left corner of the text box.
Returns:
None
Fortran Syntax:

    SUBROUTINE TecUtilTextBoxGetPosition(
   &           T,
   &           X1,
   &           Y1,
   &           X2,
   &           Y2,
   &           X3,
   &           Y3,
   &           X4,
   &           Y4)
    INTEGER*4       T
    REAL*8          X1
    REAL*8          Y1
    REAL*8          X2
    REAL*8          Y2
    REAL*8          X3
    REAL*8          Y3
    REAL*8          X4
    REAL*8          Y4

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);

Text_ID TecUtilTextGetBase void   
 

Get the first text object from the list of text objects maintained by the current frame.

Note: See also TecUtilTextGetNext and TecUtilTextGetPrev.

Returns:
First text object of the list maintained by the current frame. If no text objects are maintained by the current frame then TECUTILBADID is returned.
Fortran Syntax:

    SUBROUTINE TecUtilTextGetBase(ResultPtr)
    POINTER        (ResultPtr, Result)

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 * /
         }
     }

Boolean_t TecUtilVarGetEnabled Set_pa   EnabledVars
 

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.

Parameters:
EnabledVars  Set of enabled variables. Must not be NULL
Returns:
TRUE if successful, FALSE otherwise
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarGetEnabled(EnabledVarsPtr)
    POINTER (EnabledVarsPtr, EnabledVars)

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);

void TecUtilVarGetMinMax EntIndex_t    Var,
double *    VarMin,
double *    VarMax
 

Gets the minimum and maximum values of a variable.

Parameters:
Var  Index of the variable. Must be greater than zero and the variable must be enabled
VarMin  Receives the minimum value of the variable. Must not be NULL
VarMax  Receives the maximum value of the variable. Must not be NULL
Returns:
None.
Fortran Syntax:

    SUBROUTINE TecUtilVarGetMinMax(
   &           Var,
   &           VarMin,
   &           VarMax)
    INTEGER*4       Var
    REAL*8          VarMin
    REAL*8          VarMax

Get the minimum and maximum values of the first variable in a data set:

   double VarMin,VarMax;
   TecUtilVarGetMinMax(1,&VarMin,&VarMax);

Boolean_t TecUtilVarGetName EntIndex_t    VarNum,
char **    VName
 

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.

Parameters:
VarNum  Number of the variable for which to get the variable name information. Must be greater than zero, and the variable must be enabled
VName  Receives the name of the specified variable. Must not be NULL. You must free this string with TecUtilStringDealloc
Returns:
TRUE if successful, FALSE if not.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarGetName(
   &                   VarNum,
   &                   VName,
   &                   VNameLength)
    INTEGER*4       VarNum
    CHARACTER*(*)   VName
    INTEGER*4       VNameLength

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);

EntIndex_t TecUtilVarGetNumByAssignment char    Var
 

Gets the number (that is, the index) of a variable based on the variable assignment.

Parameters:
Var  Variable to get. The frame mode must be 2-D or 3-D.If the frame mode is 2-D, select one of 'X', 'Y', 'U', 'V', 'B', 'C', or 'S'.If the frame mode is 3-D, select one of 'X','Y','Z','U','V','W', 'B', 'C', or 'S'Table 0-1. Variable assignment identifiers (Var) and descriptions.
Var  Description'X' X-axis variable'Y' Y-axis variable'Z' Z-axis variable'U' U-velocity variable'V' V-velocity variable'W' W-velocity variable'B' Blanking variable'C' Contouring variable'S' Scatter sizing variable
Returns:
The index (number) of the variable referenced by Var.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarGetNumByAssignment(Var)
    CHARACTER*(*) Var

Get the index of the 'X' variable:

   / * frame mode must be 2-D or 3-D * /
   EntIndex_t i = TecUtilVarGetNumByAssignment('X');

EntIndex_t TecUtilVarGetNumByName const char *    VarName
 

Gets the number (that is, the index) of a variable based on variable name.

Parameters:
VarName  Name of the variable. Must not be NULL
Returns:
The index (number) of the variable with name VarName, otherwise TECUTILSETNOTMEMBER if the variable is not a member of the current frame's data set.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarGetNumByName(VarName)
    CHARACTER*(*) VarName

Get the index of the variable Rainfall:

EntIndex_t TecUtilVarGetNumByUniqueID UniqueID_t    UniqueID
 

Gets a variable number, given a unique ID.

Parameters:
UniqueID  Unique ID of the variable
Returns:
The variable number of the variable represented by the unique ID. If there is no variable number for the given unique ID, the return value is TECUTILBADID.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarGetNumByUniqueID(UniqueID)
    INTEGER*4 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);
   }

UniqueID_t TecUtilVarGetUniqueID EntIndex_t    Var
 

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.

Parameters:
Var  Variable number to query.
Returns:
A unique ID for a variable.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarGetUniqueID(Var)
    INTEGER*4 Var

Get the unique ID for variable 1.

Boolean_t TecUtilVarIsEnabled EntIndex_t    Var
 

Determine if a variable is enabled.

Returns:
TRUE, if a variable is enabled, otherwise, FALSE.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarIsEnabled(Var)
    INTEGER*4 Var

Check if the first variable is enabled:

   if (TecUtilVarIsEnabled(1))
     {
         / * sure is! * /
     }

Boolean_t TecUtilXYMapGetActive Set_pa   ActiveXYMaps
 

Deprecated:
See also:
TecUtilLineMapGetActive

void TecUtilXYMapGetAssignment EntIndex_t    XYMap,
EntIndex_t   Zone,
EntIndex_t   XAxisVar,
EntIndex_t   YAxisVar,
SmInteger_t   XAxis,
SmInteger_t   YAxis,
FunctionDependency_e   FunctionDependency
 

Deprecated:
See also:
TecUtilLineMapGetAssignment

EntIndex_t TecUtilXYMapGetCount void   
 

Deprecated:
See also:
TecUtilLineMapGetCount

Boolean_t TecUtilXYMapGetName EntIndex_t    Map,
char **    Name
 

Deprecated:
See also:
TecUtilLineMapGetName

Boolean_t TecUtilXYMapIsActive EntIndex_t    XYMap
 

Deprecated:
See also:
TecUtilLineMapIsActive

ArbParam_t TecUtilXYMapStyleGetArbValue EntIndex_t    XYMap,
const char *    S1,
const char *    S2,
const char *    S3
 

Deprecated:
See also:
TecUtilLineMapStyleGetArbValue

double TecUtilXYMapStyleGetDoubleValue EntIndex_t    XYMap,
const char *    S1,
const char *    S2,
const char *    S3
 

Deprecated:
See also:
TecUtilLineMapStyleGetDoubleValue

Boolean_t TecUtilZoneGetActive Set_pa   ActiveZones
 

Obtain the set of active field zones.

Parameters:
ActiveZones  Receives the set of active field zones.Note: You must call TecUtilSetDealloc when you are through using the set.
Returns:
TRUE if successful, FALSE otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetActive(ActiveZonesPtr)
    POINTER (ActiveZonesPtr, ActiveZones)

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);

Boolean_t TecUtilZoneGetEnabled Set_pa   EnabledZones
 

Get the set of enabled zones.

Zones are enabled/disabled when they are read in.

Parameters:
EnabledZones  Receives the set of enabled zones. You must free this pointer by calling TecUtilSetDealloc
Returns:
TRUE if successful, FALSE otherwise
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetEnabled(EnabledZonesPtr)
    POINTER (EnabledZonesPtr, EnabledZones)

Get the set of enabled zones:

   Set_pa set = NULL;
   if (TecUtilZoneGetEnabled(&set))
   {
    / * do something with the set here * /
    TecUtilSetDealloc(&set);
   }

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.

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.

Parameters:
CurZone  Number of the zone to use
IMax  Receives the I-dimension for ordered data. Number of data points for FE-data. May be NULL
JMax  Receives the J-dimension for ordered data. Number of elements for FE-data. May be NULL
KMax  Receives the K-dimension for ordered data. Number of nodes per cell for FE-data. May be NULL
XVar  Receives the handle to field data for X. May be NULL. If the frame mode is XY this parameter must be NULL
YVar  Receives the handle to field data for Y. May be NULL. If the frame mode is XY this parameter must be NULL
ZVar  Receives the handle to field data for Z. May be NULL. If the frame mode is XY this parameter must be NULL
NMap  Receives the handle for the connectivity list. May be NULL. If the frame mode is XY this parameter must be NULL
UVar  Receives the Handle to field data for U. May be NULL. If the frame mode is XY this parameter must be NULL
VVar  Receives the handle to field data for V. May be NULL. If the frame mode is XY this parameter must be NULL
WVar  Receives the handle to field data for W. May be NULL. If the frame mode is XY this parameter must be NULL
BVar  Receives the handle to field data for the blanking variable. May be NULL. If the frame mode is XY this parameter must be NULL
CVar  Receives the handle for the contouring variable. May be NULL. If the frame mode is XY this parameter must be NULL
SVar  Receives the handle for the scatter sizing variable. May be NULL. If the frame mode is XY this parameter must be NULL
Returns:
None.
Fortran Syntax:

    SUBROUTINE TecUtilZoneGetInfo(
   &           CurZone,
   &           IMax,
   &           JMax,
   &           KMax,
   &           XVarPtr,
   &           YVarPtr,
   &           ZVarPtr,
   &           NMapPtr,
   &           UVarPtr,
   &           VVarPtr,
   &           WVarPtr,
   &           BVarPtr,
   &           CVarPtr,
   &           SVarPtr)
    INTEGER*4       CurZone
    INTEGER*4       IMax
    INTEGER*4       JMax
    INTEGER*4       KMax
    POINTER         (XVarPtr, XVar)
    POINTER         (YVarPtr, YVar)
    POINTER         (ZVarPtr, ZVar)
    POINTER         (NMapPtr, NMap)
    POINTER         (UVarPtr, UVar)
    POINTER         (VVarPtr, VVar)
    POINTER         (WVarPtr, WVar)
    POINTER         (BVarPtr, BVar)
    POINTER         (CVarPtr, CVar)
    POINTER         (SVarPtr, SVar)

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);

Boolean_t TecUtilZoneGetName EntIndex_t    Zone,
char **    ZName
 

Get the name of a specified zone in the data set attached to the current frame.

Parameters:
Zone  Number of the zone for which to get the zone name information
ZName  Receives the name of the specified zone. You must free the returned string with TecUtilStringDealloc
Returns:
TRUE if successful, FALSE if not. FALSE usually indicates an invalid zone or that the current frame does not have an attached data set.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetName(
   &                   Zone,
   &                   ZName,
   &                   ZNameLength)
    INTEGER*4       Zone
    CHARACTER*(*)   ZName
    INTEGER*4       ZNameLength

Get the name of the first zone:

   char *name = NULL;
   if (TecUtilZoneGetName(1,&name)
   {
      / * do something with the name here * /
     TecUtilStringDealloc(&name);
   }

EntIndex_t TecUtilZoneGetNumByUniqueID UniqueID_t    UniqueID
 

Gets a zone number, given a unique ID.

Parameters:
UniqueID  Unique ID of the zone
Returns:
The zone number of the vairable represented by the unique ID. If there is no zone number for the given unique ID, the return value is TECUTILBADID.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetNumByUniqueID(UniqueID)
    INTEGER*4 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);
   }

ZoneType_e TecUtilZoneGetType EntIndex_t    Zone
 

Get the type of a specified zone in the data set attached to the current frame.

Parameters:
Zone  Number of the zone for which to get the zone type information
Returns:
ZoneType_Ordered: I-, IJ-, or IJK-Ordered zone type ZoneType_FETriangle: FE-Triangle zone type
ZoneType_FEQuad: FE-Quadrilateral zone type ZoneType_FETetra: FE-Tetrahedral zone type

ZoneType_FEBrick: F E-Brick zone type

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetType(Zone)
    INTEGER*4 Zone

Get the time of the first zone:

UniqueID_t TecUtilZoneGetUniqueID EntIndex_t    Zone
 

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.

Parameters:
Zone  Zone number to query.
Returns:
A unique ID for a zone.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetUniqueID(Zone)
    INTEGER*4 Zone

Get the UniqueID for zone 1

Boolean_t TecUtilZoneIsActive EntIndex_t    Zone
 

Determine if a zone is active.

Returns:
Returns TRUE if the zone is active, FALSE otherwise.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneIsActive(Zone)
    INTEGER*4 Zone

Boolean_t TecUtilZoneIsEnabled EntIndex_t    Zone
 

Determine if a zone is enabled.

Parameters:
Zone  Number of the zone for which to get the zone type information
Returns:
TRUE, if a zone is enabled, otherwise, FALSE.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneIsEnabled(Zone)
    INTEGER*4 Zone

Check if the first zone is enabled:

   if (TecUtilZoneIsEnabled(1))
   {
     / * sure is! * /
   }

Boolean_t TecUtilZoneIsFiniteElement EntIndex_t    Zone
 

Determine if a zone in the data set attached to the current frame contains finite-element data.

Parameters:
Zone  Number of the zone for which to get the zone type information
Returns:
TRUE if the zone is a finite-element zone, FALSE if it is not.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneIsFiniteElement(Zone)
    INTEGER*4 Zone

Check if the first zone is finite element:

   if (TecUtilZoneIsFiniteElement(1))
   {
    / * sure is! * /
   }

Boolean_t TecUtilZoneIsOrdered EntIndex_t    Zone
 

Determine if the specified zone in the data set attached to the current frame contains ordered data.

Parameters:
Zone  Number of the zone for which to get the zone type information
Returns:
TRUE if the zone is an I-ordered, IJ-ordered, or IJK-ordered zone; FALSE if it is not.
Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneIsOrdered(Zone)
    INTEGER*4 Zone

Check if the first zone is ordered:

   if (TecUtilZoneIsOrdered(1))
   {
    / * sure is! * /
   }


Generated on Tue May 18 14:14:12 2004 for Tecplot by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002