Tecplot: Notification Services

Boolean_t TecUtilEventAddPostDrawCallback	(	DrawEventCallback_pf	DrawEventCallback,
		ArbParam_t	ClientData
	)

Adds the callback and its client data to the list of post-draw event callbacks.

Tecplot calls all post-draw event callbacks with their associated client data immediately after performing a redraw.

Since:: 11.0-0-363

Parameters:

	DrawEventCallback	Callback to call immediately after a Tecplot performs a redraw.
	ClientData	Client data that Tecplot passes along to the callback as a parameter.

Returns:: TRUE if the callback and its client data were successfully added, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilEventAddPostDrawCallback(
   &                   DrawEventCallback,
   &                   ClientDataPtr)
    EXTERNAL           DrawEventCallback
    POINTER            (ClientDataPtr, ClientData)

Python Syntax:

    This function is not supported in Python.

See also:: TecUtilEventAddPreDrawCallback()

Boolean_t TecUtilEventAddPreDrawCallback	(	DrawEventCallback_pf	DrawEventCallback,
		ArbParam_t	ClientData
	)

Adds the callback and its client data to the list of pre-draw event callbacks.

Tecplot calls all pre-draw event callbacks with their associated client data immediately before performing a redraw.

Since:: 11.0-0-363

Parameters:

	DrawEventCallback	Callback to call immediately before a Tecplot performs a redraw.
	ClientData	Client data that Tecplot passes along to the callback as a parameter.

Returns:: TRUE if the callback and its client data were successfully added, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilEventAddPreDrawCallback(
   &                   DrawEventCallback,
   &                   ClientDataPtr)
    EXTERNAL           DrawEventCallback
    POINTER            (ClientDataPtr, ClientData)

Python Syntax:

    This function is not supported in Python.

See also:: TecUtilEventAddPostDrawCallback()

void TecUtilGetBoundingBoxOfAllFrames	(	double *	X1,
		double *	Y1,
		double *	X2,
		double *	Y2
	)

Get dimension of the bounding box surrounding all frames in CoordSys_Paper units.

Parameters:

	X1	x coordinate of the upper left corner
	Y1	y coordinate of the upper left corner
	X2	x coordinate of the bottom right corner
	Y2	y coordinate of the bottom right corner

Fortran Syntax:

    SUBROUTINE TecUtilGetBoundingBoxOfAllFrames(
   &           X1,
   &           Y1,
   &           X2,
   &           Y2)
    INTEGER*4       X1
    INTEGER*4       Y1
    INTEGER*4       X2
    INTEGER*4       Y2

Python Syntax:

  Results = TecUtil.GetBoundingBoxOfAllFrames()

  Output:
    Results[0]    X1                   double
    Results[1]    Y1                   double
    Results[2]    X2                   double
    Results[3]    Y2                   double

Since:: 11.2-0-467

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

Python Syntax:

  Results = TecUtil.LockGetCount()

  Output:
    Results[0]    ReturnVal            int

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 the Chapter "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()

Python Syntax:

  Results = TecUtil.LockIsOn()

  Output:
    Results[0]    ReturnVal            boolean

MouseButtonMode_e TecUtilMouseGetCurrentMode ( void )

Get Tecplot's current mouse mode.

Returns:: Returns the current mode.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilMouseGetCurrentMode()

Python Syntax:

  Results = TecUtil.MouseGetCurrentMode()

  Output:
    Results[0]    ReturnVal            MouseButtonMode_e  (defined in TecVals.py)

Boolean_t TecUtilMouseIsValidMode ( MouseButtonMode_e MouseMode )

This function will tell you if the specified mouse mode is valid for the current state of Tecplot.

Parameters:

MouseMode

Mouse mode to check.

Returns:: Returns TRUE if the specified mode is appropriate, otherwise FALSE.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilMouseIsValidMode(MouseMode)
    INTEGER*4 MouseMode

Python Syntax:

  Results = TecUtil.MouseIsValidMode(MouseMode)

  Input:
                  MouseMode            MouseButtonMode_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilMouseSetMode ( MouseButtonMode_e MouseMode )

Sets Tecplot's mouse mode to the one specified.

This service request behaves exactly as if the user had selected the mouse mode via Tecplot's user interface.

Parameters:

MouseMode

Desired mouse mode.

Returns:: TRUE if the requested mouse mode was set, otherwise FALSE.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilMouseSetMode(MouseMode)
    INTEGER*4 MouseMode

Python Syntax:

  Results = TecUtil.MouseSetMode(MouseMode)

  Input:
                  MouseMode            MouseButtonMode_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilPickAddAll ( PickObjects_e ObjectType )

Add all objects of a certain type to the pick list.

See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.

Parameters:

ObjectType

The type of object to select. Except for PickObject_Frame, all objects are selected in the current frame. The possible values are: PickObject_Text (Text) PickObject_Geom (Geometries) PickObject_Frame (Frames) PickObject_Zone (Zones) PickObject_LineMapping (X-Y Mappings) PickObject_StreamtracePosition (Streamtraces starting positions)

Returns:: Returns TRUE if any objects of the specified type were found.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickAddAll(ObjectType)
    INTEGER*4 ObjectType

Python Syntax:

  Results = TecUtil.PickAddAll(ObjectType)

  Input:
                  ObjectType           PickObjects_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            boolean

Select all text and geometries in the current frame:

   Boolean_t TextsExist, GeomsExist;
   TecUtilPickDeselectAll();
   TextsExist = TecUtilPickAddAll(PickObject_Text);
   GeomsExist = TecUtilPickAddAll(PickObject_Geom);

Boolean_t TecUtilPickAddAllInRect	(	double	X1,
		double	Y1,
		double	X2,
		double	Y2,
		PickObjects_e	ObjectType,
		const char *	Filter
	)

Add all objects defined within a specified rectangle to the pick list.

The rectangle is defined by the two corner points (X1, Y1) and (X2, Y2) in inches relative to the top left edge of the paper. An optional filter can be defined which specifies more details about which objects to select. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.

Parameters:

	X1	X-Value for Top left corner of the rectangle defining the region in which to select objects. (Specify in inches relative to the top left corner of the paper.)
	Y1	Y-Value for Top left corner.
	X2	X-Value for Lower right corner of the rectangle defining the region in which to select objects. (Specify in inches relative to the top left corner of the paper.)
	Y2	Y-Value for Lower right corner.
	ObjectType	The type of object to select within the specified region. Except for PickObject_Frame, all objects are selected in the current frame within the specified rectangle. The possible values are: PickObject_Text,PickObject_Geom, PickObject_Frame, PickObject_Zone, PickObject_LineMapping PickObject_StreamtracePosition, PickObject_Axis, PickObject_ContourLabel.
	Filter	An optional character string which specifies more details about which objects to select within the specified rectangle. If no filter is desired, NULL can be used. The filter uses the same text which is used in the macro language for the $!PICK ADDALLINRECT macro command. The keywords are COLORFILTER=<color>, LINEPATTERNFILTER=<linepattern>, FONTFILTER=<font>, GEOMFILTER=<geomtype>. The filter string can include one or more of these keywords. You can seperate keywords with spaces or '\n'. See the Tecplot Reference Manual for more information about the filter.

Returns:: Returns TRUE if any objects specified by ObjectType and Filter were found within the defined rectangle.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickAddAllInRect(
   &                   X1,
   &                   Y1,
   &                   X2,
   &                   Y2,
   &                   ObjectType,
   &                   Filter)
    REAL*8          X1
    REAL*8          Y1
    REAL*8          X2
    REAL*8          Y2
    INTEGER*4       ObjectType
    CHARACTER*(*)   Filter

Python Syntax:

  Results = TecUtil.PickAddAllInRect(X1, Y1, X2, Y2, ObjectType, Filter)

  Input:
                  X1                   double
                  Y1                   double
                  X2                   double
                  Y2                   double
                  ObjectType           PickObjects_e  (defined in TecVals.py)
                  Filter               string
  Output:
    Results[0]    ReturnVal            boolean

In the current frame, within the rectangle bounded by (1.5, 1.5) and (7.5, 8.0), select red text, geometries with a dashed line pattern, and all contour labels:

   Boolean_t RedTextsExist, DashedGeomsExist, ContLabelsExist;
   RedTextsExist =
     TecUtilPickAddAllInRect(1.5, 1.5, 7.5, 8.0,
                             PickObject_Text,
                             "COLORFILTER = RED");
   DashedGeomsExist =
     TecUtilPickAddAllInRect(1.5, 1.5, 7.5, 8.0,
                             PickObject_Geom,
                             "LINEPATTERNFILTER = DASHED");
   ContLabelsExist =
     TecUtilPickAddAllInRect(1.5, 1.5, 7.5, 8.0,
                             PickObject_ContourLabel,
                             NULL);

Boolean_t TecUtilPickAddFrameByUniqueID	(	Boolean_t	CollectingObjects,
		UniqueID_t	UniqueID
	)

Adds the frame identified by the unique identifier to the pick list.

Each Tecplot frame is assigned a unique ID that can be obtained for the current frame by calling TecUtilFrameGetUniqueID().

Parameters:

	CollectingObjects	Set to TRUE to add frames identified by the unique ID to the pick list. If FALSE, all objects previously picked are first removed from the pick list.
	UniqueID	Unique ID of the frame.

Returns:: TRUE if the pick was successful, FALSE otherwise.

See also:: TecUtilFrameGetUniqueID()

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickAddFrameByUniqueID(
   &                   CollectingObjects,
   &                   UniqueID)
    INTEGER*4 CollectingObjects
    INTEGER*4 UniqueID

Python Syntax:

  Results = TecUtil.PickAddFrameByUniqueID(CollectingObjects, UniqueID)

  Input:
                  CollectingObjects    boolean
                  UniqueID             long
  Output:
    Results[0]    ReturnVal            boolean

Add the current frame to a new pick list.

   {
     UniqueID_t FrameID;
     Boolean_t Picked;
     TecUtilLockStart(AddOnID);
     FrameID = TecUtilFrameGetUniqueID();
     Picked  = TecUtilPickAddFrameByUniqueID(FALSE, FrameID);
     TecUtilLockFinish(AddOnID);
   }

Boolean_t TecUtilPickAddLineMaps	(	Boolean_t	CollectingObjects,
		Set_pa	LineMapSet
	)

Adds the specified Line-maps to the pick object list.

In addition, you can control whether the Line-maps are added to the list of already picked objects or if the pick object list is cleared prior to adding them.

Parameters:

	CollectingObjects	Set to TRUE to add identified linemaps to the pick list. If FALSE, all objects previously picked are removed from the pick list
	LineMapSet	Set of Line-maps to add to the pick list

Returns:: Returns TRUE if the linemaps could be picked, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickAddLineMaps(
   &                   CollectingObjects,
   &                   LineMapSetPtr)
    INTEGER*4       CollectingObjects
    POINTER         (LineMapSetPtr, LineMapSet)

Python Syntax:

  Results = TecUtil.PickAddLineMaps(CollectingObjects, LineMapSet)

  Input:
                  CollectingObjects    boolean
                  LineMapSet           sequence of ints
  Output:
    Results[0]    ReturnVal            boolean

Pick Line-maps 1 and 3

   Set_pa LineMapSet;
   LineMapSet = TecUtilSetAlloc(TRUE);
   TecUtilSetAddMember(LineMapSet,1,TRUE);
   TecUtilSetAddMember(LineMapSet,3,TRUE);
   TecUtilPickAddLineMaps(TRUE,LineMapSet);
   TecUtilSetDealloc(&LineMapSet);

Boolean_t TecUtilPickAddXYMaps	(	Boolean_t	CollectingObjects,
		Set_pa	XYMapsSet
	)

Deprecated:: Please use TecUTilPickAddLineMaps() instead.

Boolean_t TecUtilPickAddZones	(	Boolean_t	CollectingObjects,
		Set_pa	ZoneSet
	)

Adds the specified Line-maps to the pick object list.

In addition, you can control whether the Line-maps are added to the list of already picked objects or if the pick object list is cleared prior to adding them.

Parameters:

	CollectingObjects	Set to TRUE to add identified linemaps to the pick list. If FALSE, all objects previously picked are first removed from the pick list.
	ZoneSet	Set of zones to add to the pick list.

Returns:: Returns TRUE if the zones could be picked, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickAddZones(
   &                   CollectingObjects,
   &                   ZoneSetPtr)
    INTEGER*4       CollectingObjects
    POINTER         (ZoneSetPtr, ZoneSet)

Python Syntax:

  Results = TecUtil.PickAddZones(CollectingObjects, ZoneSet)

  Input:
                  CollectingObjects    boolean
                  ZoneSet              sequence of ints
  Output:
    Results[0]    ReturnVal            boolean

Pick zones 1 and 3

   Set_pa ZoneSet;
   ZoneSet = TecUtilSetAlloc(TRUE);
   TecUtilSetAddMember(ZoneSet,1,TRUE);
   TecUtilSetAddMember(ZoneSet,3,TRUE);
   TecUtilPickAddZones(TRUE,ZoneSet);
   TecUtilSetDealloc(&ZoneSet);

Boolean_t TecUtilPickAtPosition	(	double	X,
		double	Y,
		Boolean_t	CollectingObjects,
		Boolean_t	DiggingForObjects
	)

Pick an object at a specified location.

The location is defined as the (X,Y) location in inches relative to the top-left edge of the paper. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.

Parameters:

	X	X-location (in inches) relative to the left edge of the paper
	Y	Y-location (in inches) relative to the top edge of the paper
	CollectingObjects	If FALSE, the list of picked objects is cleared before the attempt is made to add a new object. If TRUE, the new object is added to the list of picked objects. (This is like holding Shift down while selecting objects in the workspace.) If CollectingObjects is TRUE, DiggingForObjects must be FALSE
	DiggingForObjects	If TRUE, attempt to pick objects below any currently picked objects at this location. If FALSE, pick the top object at this location. (This is like holding Ctrl down while selecting objects in the workspace. It allows you to select objects which are beneath other objects.) If DiggingForObjects is TRUE, CollectingObjects must be FALSE

Returns:: Currently, TRUE is always returned.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickAtPosition(
   &                   X,
   &                   Y,
   &                   CollectingObjects,
   &                   DiggingForObjects)
    REAL*8          X
    REAL*8          Y
    INTEGER*4       CollectingObjects
    INTEGER*4       DiggingForObjects

Python Syntax:

  Results = TecUtil.PickAtPosition(X, Y, CollectingObjects, DiggingForObjects)

  Input:
                  X                    double
                  Y                    double
                  CollectingObjects    boolean
                  DiggingForObjects    boolean
  Output:
    Results[0]    ReturnVal            boolean

Select the object at the location (1.5, 3.2). Then, select the object underneath that object instead. Add the object at (5.5, 5.4) to the list of picked objects:

   Boolean_t IsOk;
   IsOk = TecUtilPickAtPosition(1.5, 3.2, FALSE, FALSE);
   IsOk = TecUtilPickAtPosition(1.5, 3.2, FALSE, TRUE);
   IsOk = TecUtilPickAtPosition(5.5, 5.4, TRUE,  FALSE);

Boolean_t TecUtilPickClear ( void )

Clear (that is, delete) all objects that are currently picked.

These objects cannot be retrieved.

Returns:: TRUE if any objects were deleted.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickClear()

Python Syntax:

  Results = TecUtil.PickClear()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilPickCopy ( void )

Copy all objects that are currently picked to the paste buffer.

Returns:: TRUE if successful, FALSE if not or if no objects are currently picked.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickCopy()

Python Syntax:

  Results = TecUtil.PickCopy()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilPickCut ( void )

Copy all objects that are currently picked to the paste buffer and then delete them from the plot.

Returns:: TRUE if successful, FALSE if not or if no objects are currently picked.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickCut()

Python Syntax:

  Results = TecUtil.PickCut()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilPickDeselectAll ( void )

Deselect all selected objects.

See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.

Returns:: Currently TRUE is always returned.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickDeselectAll()

Python Syntax:

  Results = TecUtil.PickDeselectAll()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilPickEdit ( const char * Action )

Perform a global edit operation on the currently picked objects.

Only one edit operation is allowed per call to TecUtilPickEdit(). Objects are edited only if the supplied parameter is relevant. See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.

Parameters:

Action

The action to perform on the currently picked objects. The action uses the same text which is used in the macro language for the $!PickEdit macro command. See the Tecplot Reference Manual for more information about available keywords

Returns:: TRUE if successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickEdit(Action)
    CHARACTER*(*) Action

Python Syntax:

  Results = TecUtil.PickEdit(Action)

  Input:
                  Action               string
  Output:
    Results[0]    ReturnVal            boolean

Set the color for all picked objects to yellow. Set the contour type for all picked zones to be "Flood".

   TecUtilPickEdit("COLOR = YELLOW");
   TecUtilPickEdit("CONTOUR {COUNTOURTYPE = FLOOD}");

Boolean_t TecUtilPickGeom ( Geom_ID GID )

Add the specified geometry to the pick list.

See Section 17.4, "The Pick List," in the ADK User's Manual for a discussion of pick lists.

Parameters:

GID

Geometry ID to pick

Returns:: TRUE if successful. A return value of FALSE usually indicates that Tecplot's limit on the number of picked objects has been exceeded.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickGeom(GIDPtr)
    POINTER(GIDPtr, GID)

Python Syntax:

  Results = TecUtil.PickGeom(GID)

  Input:
                  GID                  long
  Output:
    Results[0]    ReturnVal            boolean

Pick the first geometry in the current frame:

   Geom_ID gid;
   gid = TecUtilGeomGetBase();
   if (gid ! = NULL)
      TecUtilPickGeom(gid);

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

Python Syntax:

  Results = TecUtil.PickListGetAxisKind(PickListIndex)

  Input:
                  PickListIndex        int
  Output:
    Results[0]    ReturnVal            int

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

Python Syntax:

  Results = TecUtil.PickListGetAxisNumber(PickListIndex)

  Input:
                  PickListIndex        int
  Output:
    Results[0]    ReturnVal            int

int TecUtilPickListGetCount ( void )

Get the number of items currently in the pick list.

See Section "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()

Python Syntax:

  Results = TecUtil.PickListGetCount()

  Output:
    Results[0]    ReturnVal            int

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

Python Syntax:

  Results = TecUtil.PickListGetFrameName(PickListIndex)

  Input:
                  PickListIndex        int
  Output:
    Results[0]    ReturnVal            string

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

Python Syntax:

  Results = TecUtil.PickListGetFrameUniqueID(PickListIndex)

  Input:
                  PickListIndex        int
  Output:
    Results[0]    ReturnVal            long

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

   if (TecUtilPickListGetType(1) == PickObject_Frame)
     {
       UniqueID_t UniqueID = TecUtilPickListGetFrameUniqueID(1);
       .
       .
       .
     }

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

Python Syntax:

  Results = TecUtil.PickListGetGeom(PickListIndex)

  Input:
                  PickListIndex        int
  Output:
    Results[0]    ReturnVal            long

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

Fortran Syntax:

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

Python Syntax:

  Results = TecUtil.PickListGetGeomInfo(PickListIndex)

  Input:
                  PickListIndex        int
  Output:
    Results[0]    PolylineNum          int
    Results[1]    PointIndex           int

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

Python Syntax:

  Results = TecUtil.PickListGetLineMapIndex(PickListIndex)

  Input:
                  PickListIndex        int
  Output:
    Results[0]    ReturnVal            int

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

   if (TecUtilPickListGetType(1) == PickObject_LineMapping)
     {
       EntIndex_t MapNumber = TecUtilPickListGetLineMapNumber(1);
       LgIndex_t  MapIndex  = TecUtilPickListGetLineMapIndex(1);
   
       // Do Something here
   
     }

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

Python Syntax:

  Results = TecUtil.PickListGetLineMapNumber(PickListIndex)

  Input:
                  PickListIndex        int
  Output:
    Results[0]    ReturnVal            int

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

Python Syntax:

  Results = TecUtil.PickListGetText(PickListIndex)

  Input:
                  PickListIndex        int
  Output:
    Results[0]    ReturnVal            long

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

Python Syntax:

  Results = TecUtil.PickListGetType(PickListIndex)

  Input:
                  PickListIndex        int
  Output:
    Results[0]    ReturnVal            PickObjects_e  (defined in TecVals.py)

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:: Please use TecUtilPickListGetLineMapIndex() instead.

EntIndex_t TecUtilPickListGetXYMapNumber ( int PickListIndex )

Deprecated:: Please use TecUtilPickListGetLineMapNumber() instead.

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

Fortran Syntax:

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

Python Syntax:

  Results = TecUtil.PickListGetZoneIndices(PickListIndex)

  Input:
                  PickListIndex        int
  Output:
    Results[0]    IIndex               int
    Results[1]    JIndex               int
    Results[2]    KIndex               int

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

Python Syntax:

  Results = TecUtil.PickListGetZoneNumber(PickListIndex)

  Input:
                  PickListIndex        int
  Output:
    Results[0]    ReturnVal            int

Boolean_t TecUtilPickMagnify ( double MagFactor )

Magnify all picked objects.

The first object picked will remain in place; the other picked objects will move proportionally as the image is magnified. Only frames, text, and geometries are allowed to be magnified.

Parameters:

MagFactor

Amount to magnify

Returns:: TRUE if picked objects could be magnified, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickMagnify(MagFactor)
    REAL*8 MagFactor

Python Syntax:

  Results = TecUtil.PickMagnify(MagFactor)

  Input:
                  MagFactor            double
  Output:
    Results[0]    ReturnVal            boolean

Double the size of all picked objects.

   Boolean_t IsOk = TecUtilPickMagnify(2.0);

Boolean_t TecUtilPickPaste ( void )

Paste the currently picked objects from the paste buffer to the workspace.

Returns:: TRUE if successful, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickPaste()

Python Syntax:

  Results = TecUtil.PickPaste()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilPickPop ( void )

Change the order in which objects are drawn by popping the currently picked objects to the front.

Only frames, text, geometries, and the grid area for 2-D plots are allowed to be popped.

Returns:: TRUE if all currently picked objects are allowed to be popped, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickPop()

Python Syntax:

  Results = TecUtil.PickPop()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilPickPush ( void )

Change the order in which objects are drawn by pushing the currently picked objects back.

Only frames, text, geometries, and the grid area for 2-D plots are allowed to be pushed.

Returns:: TRUE if all currently picked objects are allowed to be pushed, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickPush()

Python Syntax:

  Results = TecUtil.PickPush()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilPickSetMouseMode ( MouseButtonMode_e MouseMode )

Deprecated:: Please use TecUtilMouseSetMode() instead.

Boolean_t TecUtilPickShift	(	double	DXPaper,
		double	DYPaper,
		PointerStyle_e	PointerStyle
	)

Shift the currently picked objects.

Objects are shifted relative to their starting position. X and Y shift amounts are in paper units (inches). If snapping is in effect then it is applied after shifting in X and Y.

Parameters:

	DXPaper	Shift amount in the X-direction. Units are in inches. Positive numbers will shift objects to the right. Ignored if PointerStyle is PointerStyle_BottomBracket, PointerStyle_TopBracket, or PointerStyle_UpDown
	DYPaper	Shift amount in the Y-direction. Units are in inches. Positive numbers will shift objects down. Ignored if PointerStyle is PointerStyle_LeftBracket, PointerStyle_RightBracket, or PointerStyle_LeftRight.
	PointerStyle	The type of shift to perform on the picked objects. This is ignored if not appropriate for the currently selected objects. PointerStyle_AllDirections is appropriate for all types of objects. Currently, the other options are only available for Axis and Frame objects. See PointerStyle_e.

Returns:: TRUE if successful, FALSE if no items are selected or if a zone or Line-mapping is selected and the current mouse mode is not the Adjustor tool. Objects can only be selected if the current mouse mode is the selector or the Adjustor tool.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickShift(
   &                   DXPaper,
   &                   DYPaper,
   &                   PointerStyle)
    REAL*8          DXPaper
    REAL*8          DYPaper
    INTEGER*4       PointerStyle

Python Syntax:

  Results = TecUtil.PickShift(DXPaper, DYPaper, PointerStyle)

  Input:
                  DXPaper              double
                  DYPaper              double
                  PointerStyle         int
  Output:
    Results[0]    ReturnVal            boolean

Select all frames and resize their upper-left corners to be 2.5 inches to the right and 3.5 inches down from their previous location. Then, select all text in the current frame and move them 1.5 inches to the left and 0.25 inches up from their previous locations:

   TecUtilPickSetMouseMode(Mouse_Select);
   if (TecUtilPickAddAll(PickObject_Frame))
     TecUtilPickShift(2.5, 3.5, PointerStyle_UpperLeftBracket);
   TecUtilPickDeselectAll();
   if (TecUtilPickAddAll(PickObject_Text))
     TecUtilPickShift(-1.5, -0.25, PointerStyle_AllDirections);

Boolean_t TecUtilPickText ( Text_ID TID )

Add the specified text to the pick list.

See the ADK User's Manual for a discussion of pick lists.

Parameters:

TID

Text ID to pick

Returns:: TRUE if successful. A return value of FALSE usually indicates that Tecplot's limit on the number of picked objects has been exceeded.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilPickText(TIDPtr)
    POINTER(TIDPtr, TID)

Python Syntax:

  Results = TecUtil.PickText(TID)

  Input:
                  TID                  long
  Output:
    Results[0]    ReturnVal            boolean

Pick the first text in the current frame.

   Text_ID tid;
   tid = TecUtilTextGetBase();
   if (tid ! = NULL)
      TecUtilPickText(tid);

void TecUtilProbeAllowCOBs ( void )

Instructs Tecplot to include COBs (iso-surfaces, slices, streamtraces, and so forth) along with zones during a probe when an add-on has a callback registered with TecUtilProbeInstallCallback() and if the user is pressing the Alt key.

By default the Alt key is ignored for an add-on's installed probe callback.

Fortran Syntax:

    SUBROUTINE TecUtilProbeAllowCOBs()

Python Syntax:

  Results = TecUtil.ProbeAllowCOBs()

  Output:
    Results[0]    ReturnVal            NONE

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 and the frame must be in 2D or 3D.

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. 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 otherwise. FALSE usually indicates that the data point could not be found however it could also mean that the probe was interrupted by the user or failed to load variables. You can check for interrupt by calling TecUtilInterruptCheck or if you are using the status line family of functions, TecUtilStatusXxxxPercentDone, during the probe then calling TecUtilStatusCheckPercentDone will tell you if Tecplot was interrupted, thereby providing more complete information about why TecUtilProbeAtPosition returned FALSE.

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

Python Syntax:

    This function is not supported in Python.

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

void TecUtilProbeAtPosSequenceBeginX ( ArgList_pa ArgList )

Begin a sequence of calling TecUtilProbeAtPosition() many times.

The following rules must be obeyed between TecUtilProbeAtPosSequenceBeginX() and TecUtilProbeAtPosSequenceEnd() calls:

     - Do not make any calls that will change the style of the plot.
     - Do not make any calls that will re-order or replace zones in 
       the underlying dataset (i.e. push or pop frames, load data, delete
       zones etc.).
     - Once a sequence has been started you MUST end the sequence
       even if there was a failure of any sort in the intervening code.

Parameters:

ArgList

Set of Arglist entries. THIS PARAMETER IS RESERVED FOR FUTURE USE AND IS CURRENTLY NOT USED. YOU MUST SET THIS TO NULL.

Assuming a 2-D plot, probe at 100 locations with Y = 1.45 and X varying between 1.0 and 100.0. Assume that once a "hit" is discovered in a zone that the next hit will be nearby in that same zone.

   LgIndex_t    ICell, JCell, KCell;
   IJKPlanes_e  Plane;
   Boolean_t    StartWithLocalCell = FALSE;
   EntIndex_t   SourceZone;
   EntIndex_t   NumVars;
   double      *VValues;
   int          IX;
   
   TecUtilDataSetGetInfo((char **)NULL,
                         (EntIndex_t *)NULL,
                          &NumVars);
   
   VValues = (double *)malloc(NumVars*sizeof(double));

   TecUtilProbeAtPosSequenceBeginX((ArgList_pa)NULL);
   
   for (IX = 1; IX <= 100; IX++)
     {
       if (TecUtilProbeAtPosition((double)IX,
                                  1.45, 
                                  0.0,
                                  &ICell,
                                  &JCell,
                                  &KCell,
                                  &Plane,
                                  &SourceZone,
                                  StartWithLocalCell,
                                  VValues,
                                  (Set_pa )NULL,
                                  FALSE,
                                  FALSE,
                                  FALSE))

         {
             // Look at VValues[VarNum-1] to find the
             // value for a particular variable.

            StartWithLocalCell = TRUE;
         }
       else
         StartWithLocalCell = FALSE;
     }

    TecUtilProbeAtPosSequenceEnd();

Fortran Syntax:

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

Python Syntax:

  Results = TecUtil.ProbeAtPosSequenceBeginX(ArgList)

  Input:
                  ArgList              dictionary
  Output:
    Results[0]    ReturnVal            NONE

void TecUtilProbeAtPosSequenceEnd ( void )

End a sequence of calling TecUtilProbeAtPosition() many times.

See TecUtilProbeAtPosSequenceEnd() for an details and an example.

Fortran Syntax:

    SUBROUTINE TecUtilProbeAtPosSequenceEnd()

Python Syntax:

  Results = TecUtil.ProbeAtPosSequenceEnd()

  Output:
    Results[0]    ReturnVal            NONE

LgIndex_t TecUtilProbeFieldGetCell ( void )

Call this function from a probe destination callback to get the cell from the previous probe event in a field plot.

In order to use this function, the value passed to the probe destination callback must have been FALSE, indicating an interpolated probe.

Note:: For all zone types other than ordered volume data this function returns the same information as TecUtilProbeFieldGetFaceCell(). For ordered volume data the distinction is that this function returns the volume cell whereas TecUtilProbeFieldGetFaceCell() returns the face cell.

Returns:: The index of the cell which was probed. For ordered data, this is equivalent to the index value of the node in the lowest indexed corner of the cell. For finite-element data, this is the element number.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilProbeFieldGetCell()

Python Syntax:

  Results = TecUtil.ProbeFieldGetCell()

  Output:
    Results[0]    ReturnVal            int

CZType_e TecUtilProbeFieldGetCZType ( void )

Indicates type type of COB or zone that was selected during the probe event.

Returns:: Type of COB selected by the probe. This can be one of seven values: CZType_FieldDataZone CZType_FEBoundaryCOB CZType_IsoSurfaceCOB CZType_SliceCOB CZType_StreamtraceCOB CZType_StreamtraceMarkerCOB CZType_StreamtraceArrowheadCOB.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilProbeFieldGetCZType()

Python Syntax:

  Results = TecUtil.ProbeFieldGetCZType()

  Output:
    Results[0]    ReturnVal            CZType_e  (defined in TecVals.py)

LgIndex_t TecUtilProbeFieldGetFaceCell ( void )

Call this function from a probe destination callback to get the cell from the previous probe event in a field plot.

In order to use this function, the value passed to the probe destination callback must have been FALSE, indicating an interpolated probe.

Note:: For all zone types other than ordered volume data this function returns the same information as TecUtilProbeFieldGetCell(). For ordered volume data the distinction is that this function returns the face cell whereas TecUtilProbeFieldGetCell() returns the volume cell.

Returns:: The index of the cell which was probed. For ordered data, this is equivalent to the index value of the node in the lowest indexed corner of the face cell. For finite-element data, this is the element number.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilProbeFieldGetFaceCell()

Python Syntax:

  Results = TecUtil.ProbeFieldGetFaceCell()

  Output:
    Results[0]    ReturnVal            int

SmInteger_t TecUtilProbeFieldGetFaceNumber ( void )

Call this function from a probe destination callback to get the face number from the previous probe event in a field plot.

In order to use this function, the value passed to the probe destination callback must have been FALSE, indicating an interpolated probe.

Returns:: The face number of the cell that was probed. For ordered volume and FE brick data the value is between 1 and 6. For ordered surface, FE tetra, and FE quandrangle data the value is between 1 and 4. For FE triangular data the value is between 1 and 3. For ordered or FE linear data the value is 0.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilProbeFieldGetFaceNumber()

Python Syntax:

  Results = TecUtil.ProbeFieldGetFaceNumber()

  Output:
    Results[0]    ReturnVal            int

IJKPlanes_e TecUtilProbeFieldGetPlane ( void )

Call this function from a probe destination callback to get the I-, J-, or K-plane from the previous probe event in a field plot.

Returns:: The plane which was probed. This can be one of Planes_I, Planes_J, or Planes_K.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilProbeFieldGetPlane()

Python Syntax:

  Results = TecUtil.ProbeFieldGetPlane()

  Output:
    Results[0]    ReturnVal            IJKPlanes_e  (defined in TecVals.py)

double TecUtilProbeFieldGetValue ( EntIndex_t VarNum )

Call this function from a probe destination callback to get a field variable value from the previous probe event in a field plot.

Parameters:

VarNum

The variable number for which to get the field value.

Returns:: The value for variable VarNum at the previous probe data point.

Fortran Syntax:

    REAL*8 FUNCTION TecUtilProbeFieldGetValue(VarNum)
    INTEGER*4 VarNum

Python Syntax:

  Results = TecUtil.ProbeFieldGetValue(VarNum)

  Input:
                  VarNum               int
  Output:
    Results[0]    ReturnVal            double

EntIndex_t TecUtilProbeFieldGetZone ( void )

Call this function from a probe destination callback to get the zone number from the previous probe event in a field plot.

Returns:: The number of the zone which was probed.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilProbeFieldGetZone()

Python Syntax:

  Results = TecUtil.ProbeFieldGetZone()

  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilProbeGetPointIndex ( void )

Call this function from a probe destination callback to get the point index from the previous nearest-point probe event in a field plot or an XY-plot.

In order to use this function, the value passed to the probe destination callback must have been TRUE, indicating a nearest-point probe.

Returns:: The index of the data point selected in the previous nearest point probe.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilProbeGetPointIndex()

Python Syntax:

  Results = TecUtil.ProbeGetPointIndex()

  Output:
    Results[0]    ReturnVal            int

Boolean_t TecUtilProbeInstallCallback	(	ProbeDestination_pf	ProbeDestination,
		const char *	InformationLineText
	)

If the current frame mode is XY, 2D, or 3D, change the mouse mode to be the probe tool and instruct Tecplot to call a different function when the user completes a probe-like operation in the work area.

This function callback will remain in effect until the mouse mode is changed in the Tecplot interface.

Parameters:

	ProbeDestination	Function to call when the probe event takes place.
	InformationLineText	Text to write on the status line when the override is in effect.

Returns:: TRUE if successfully installed.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilProbeInstallCallback(
   &                   ProbeDestination,
   &                   InformationLineText)
    EXTERNAL        ProbeDestination
    CHARACTER*(*)   InformationLineText

Python Syntax:

    This function is not supported in Python.

Override the behavior of the probe tool in Tecplot. When a probe occurs, just print out the results of the probe to simulate some of the capabilities of the probe dialogs in Tecplot. The task is to provide a mechanism whereby your own probe callback overrides the default behavior when a probe event occurs in Tecplot. One way to do this is to add an option to the Tools menu in Tecplot. The callback function assigned to the menu option would then turn around and install the probe callback with the following code: .

   .
   TecUtilProbeInstallCallback(MyProbeCallback,
                       "Click to print out my probe information");
   .
   TecUtilProbeAllowCOBs()
   .
   
   The function MyProbeCallback is then defined as:
   void MyProbeCallback(Boolean_t IsNearestPoint)
   {
     FrameMode_e FrameMode;
     TecUtilLockStart(AddOnID);
     FrameMode = TecUtilFrameGetMode();
   
     if (FrameMode == Frame_XY)
       {
         printf("XY Probe, Independent value is: %G\n",
                TecUtilProbeLinePlotGetIndValue());
         if (IsNearestPoint)
           {
             double DepValue;
             TecUtilProbeXYGetDepValue(1,&DepValue);
             printf("Nearest Point:  Dependent Value = %G\n",
                    DepValue);
             printf("                Source LineMap    = %d\n",
                    TecUtilProbeLinePlotGetMap());
             printf("                Point Index     = %d\n",
                    TecUtilProbeGetPointIndex());
           }
         else
           {
             EntIndex_t M;
             for (M = 1; M <= TecUtilLineMapGetCount(); M++)
               {
                 double DepValue;
                 printf("LineMap = %02d, Dependent Value = ",M);
                 if (TecUtilProbeLinePlotGetDepValue(M,&DepValue))
                   printf("%G\n",DepValue);
                 else
                   printf("Unknown\n");
               }
           }
       }
     else
       {
         EntIndex_t  SourceZone = TecUtilProbeFieldGetZone();
         ZoneType_e  ZoneType   = TecUtilZoneGetType(SourceZone);
         IJKPlanes_e Plane      = TecUtilProbeFieldGetPlane();
         EntIndex_t  V;
         EntIndex_t  NumVars;
   
         TecUtilDataSetGetInfo((char **)NULL,
                               (EntIndex_t *)NULL,
                               &NumVars);
   
         if (IsNearestPoint)
           printf("Nearest point probe:\n");
         else
          {
            LgIndex_t ProbeCell = TecUtilProbeFieldGetCell();
            printf("Interpolated  probe:(Cell = %d)\n",ProbeCell);
          }
   
         for (V = 1; V <= NumVars; V++)
           {
             char *VName;
             if (TecUtilVarGetName(V,&VName))
               {
                 printf("%20s : ",VName);
                 TecUtilStringDealloc(&VName);
               }
             else
               printf("<Unknown>            : ");
             printf("%G\n",TecUtilProbeFieldGetValue(V));
           }
       }
     TecUtilLockFinish(AddOnID);
   }
   A complete example can be found in the probtest sample add-on included in the distribution.

Boolean_t TecUtilProbeLinePlotGetDepValue	(	EntIndex_t	MapNum,
		double *	DepValue
	)

Call this function from a probe destination callback to get a dependent value from the previous probe event in an Line-plot.

Parameters:

	MapNum	Number of the Line-map to query for its dependent value at the previous probe.
	DepValue	Dependent value resulting from previous probe. This parameter is ignored if the previous probe was a nearest-point probe.

Returns:: TRUE if the dependent value for the selected Line-map number is valid, otherwise FALSE. A dependent value can be invalid if a probe occurs outside the range of the independent variable for a given Line-map.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilProbeLinePlotGetDepValue(
   &                   MapNum,
   &                   DepValue)
    INTEGER*4       MapNum
    REAL*8          DepValue

Python Syntax:

  Results = TecUtil.ProbeLinePlotGetDepValue(MapNum)

  Input:
                  MapNum               int
  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    DepValue             double

double TecUtilProbeLinePlotGetIndValue ( void )

Call this function from a probe destination callback to get the independent value from the previous probe event in an Line-plot.

Returns:: The independent value from the previous probe event.

Fortran Syntax:

    REAL*8 FUNCTION TecUtilProbeLinePlotGetIndValue()

Python Syntax:

  Results = TecUtil.ProbeLinePlotGetIndValue()

  Output:
    Results[0]    ReturnVal            double

EntIndex_t TecUtilProbeLinePlotGetSourceMap ( void )

Call this function from a probe destination callback to get the Line-map whose point was selected in the previous nearest-point probe.

In order to use this function, the value passed to the probe destination callback must have been TRUE, indicating a nearest-point probe.

Returns:: The number of the Line-map.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilProbeLinePlotGetSourceMa()

Note:: IMPORTANT! Note that the FORTRAN Name for this function is truncated to 31 characters!

Python Syntax:

  Results = TecUtil.ProbeLinePlotGetSourceMap()

  Output:
    Results[0]    ReturnVal            int

Boolean_t TecUtilProbeXYGetDepValue	(	EntIndex_t	MapNum,
		double *	DepValue
	)

Deprecated:: Please use TecUtilProbeLinePlotGetDepValue() instead.

double TecUtilProbeXYGetIndValue ( void )

Deprecated:: Please use TecUtilProbeLinePlotGetIndValue() instead.

EntIndex_t TecUtilProbeXYGetSourceMap ( void )

Deprecated:: Please use TecUtilProbeLinePlotGetSourceMap() instead.

Boolean_t TecUtilStateChangeAddCallback ( StateChangeAddOnCallback_pf StateChangeCallback )

Include a function in the list of functions to call when a state change occurs in Tecplot.

For more detailed discussion, either see TecUtilOnIdleQueueAddCallback() or the ADK User's Manual. If you want to take advantage of newer capabilities with regard to state changes then use TecUtilStateChangeAddCallbackX() instead.

Parameters:

StateChangeCallback

This is the name of the callback function you provide. This function will be called by Tecplot each time a state change occurs. See

Returns:: Returns TRUE if callback has been added. Returns FALSE only if there is not enough room to allocate space for an additional callback (highly unlikely).

The following example will set up a state change callback. This callback will do the following:

When the user picks an object, check and see if it is a zone. If it is, then change its color to red.
If anything has happened to the fourth variable, then show an error message.
If Tecplot is quitting, then close some files that are open.

First, in the Tecplot initialization code add the callback:

   IsOk=TecUtilStateChangeAddCallback(MyStateChangeCallback);

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStateChangeAddCallback(StateChangeCallback)
    EXTERNAL StateChangeCallback

Python Syntax:

    This function is not supported in Python.

And add the state change callback:

   void MyStateChangeCallback(StateChange_e StateChange,
                              ArbParam_t    CallData)
   {
     .
     .
     .
     //
     // Item 1.  Check for the case when the user picks a zone.
     //
     if (StateChange == StateChange_PickListSingleSelect)
       {
         int NumPickedObjects;
         NumPickedObjects = TecUtilPickListGetCount();
   
          //
          // Check to see if the last object picked is a zone.
          //
         if (TecUtilPickListGetType(NumPickedObjects)==
             PickObject_Zone)
           {
             EntIndex_t ZonePicked;
             Set_pa     ZoneSet;
   
             // Get the number of the zone picked 
             ZonePicked = TecUtilPickListGetZoneNumber(NumPickedObjects);
   
             //
             // Build the zone set to pass to TecUtilZoneSetMesh().
             // In this case there is only one zone
             //
             ZoneSet = TecUtilSetAlloc(FALSE);
             if (ZoneSet)
               {
                 TecUtilSetAddMember(ZoneSet,ZonePicked,TRUE);
   
                 //
                 // Change the mesh color attribute.
                 //
                 TecUtilZoneSetMesh(SV_COLOR, ZoneSet, 0.0,
                                    (ArbParam_t)Red_C);
                 TecUtilSetDealloc(&ZoneSet);
               }
           }
       }
       //
       // Item 2. Check for a change in the 4th variable.
       //
       else if (StateChange == StateChange_VarsAltered)
       {
         if (TecUtilSetIsMember((Set_pa)CallData, (SetIndex_t)4))
           TecUtilDialogErrMsg("Var number 4 was altered");
       }
   
       //
       // Item 3.  Close an open file if Tecplot is
       // shutting down.
       //
       else if (StateChange == StateChange_QuitTecplot)
       {
         fclose(SomeOpenFile);
       }
       .
       .
       .
     }

Boolean_t TecUtilStateChangeAddCallbackX ( ArgList_pa ArgList )

Add a callback to Tecplot's list of add-on's to receive state changes notifications.

Parameters:

ArgList

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

Arglist Values

SV_STATECHANGEMODE

Type:	StateChangeMode_e
Arg Function:	TecUtilArgListAppendInt()
Default:	StateChangeMode_V100
Required:	No
Notes:	Assigns the state change mode. Possible values are StateChangeMode_v75, StateChangeMode_v80 and StateChangeMode_v100. See the ADK Users manual for an indepth discussion of the modes.

SV_CALLBACKFUNCTION

Type:	void *
Arg Function:	TecUtilArgListAppendFunction()
Required:	Yes
Notes:	Callback Function for state changes. See discussion of StateChangeCallbackAPI below.

SV_STATECHANGECALLBACKAPI

Type:	StateChangeCallbackAPI_e
Arg Function:	TecUtilArgListAppendInt()
Default:	StateChangeCallbackAPI_ChangeOnly
Required:	No
Notes:	Determines the API for the statechange callback function. Use StateChangeCallbackAPI_Classic if your callback uses StateChangeAddOnCallback_pf. Use StateChangeCallbackAPI_ChangeOnly if your callback uses StateChangeAddOnCallbackV2_pf Use StateChangeCallbackAPI_ChangePlusClassic if your callback uses StateChangeAddOnCallbackWithClientData_pf.

SV_CLIENTDATA

Type:	ArbParam_t
Arg Function:	TecUtilArgListAppendArbParam()
Default:	0
Required:	No
Notes:	Client data sent to callback if StateChangeCallbackAPI is set to StateChangeCallbackAPI_ChangePlusClient.

Returns:: TRUE if successful, FALSE otherwise.

Fortran Syntax:

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

Python Syntax:

    This function is not supported in Python.

Register the function MyStateChangeCallback with Tecplot using the "ChangeOnly" API:

   static void MyStateChangeCallback(StateChange_e StateChange)    
   {
     TecUtilLockStart(AddOnID);
     switch (StateChange)
       {
         case StateChange_VarsAltered,
           {
             Set_pa VarsAlteredRef = NULL;
             if (TecUtilStateChangeGetVarSet(&VarsAlteredRef))
               {
                 Set_pa ZonesAlteredRef = NULL;
                 if (TecUtilStateChangeGetZoneSet(&ZonesAlteredRef))
                   {
                     ... take action knowing which vars in which
                     ... were altered.
                   }
                 else
                   {
                     ... assume all zones were affected.  Take action
                     ... knowing which vars were altered.
                   }
               }
           } break;
         ... and so on...
       }
     TecUtilLockFinish(AddOnID);
   }
   .
   .
   .
   void InitTecAddOn(void)
   {
     ArgList_pa ArgList;
     .
     .
     .
     ArgList = TecUtilArgListAlloc();
     TecUtilArgListAppendFunction(ArgList,
                                  SV_CALLBACKFUNCTION,
                                  MyStateChangeCallback);
     TecUtilStateChangeAddCallbackX(ArgList);
     TecUtilArgListDealloc(&ArgList);
     .
     .
     .
   }

Register the function MyStateChageCallback with Tecplot using the "ChangePlusClient" API:

   static void MyStateChangeCallback(StateChange_e StateChange,
                                     ArbParam_t    ClientData)
   {
     // Do something with ClientData....
     TecUtilLockStart(AddOnID);
     switch (StateChange)
       {
         case StateChange_VarsAltered,
           {
             Set_pa VarsAlteredRef = NULL;
             if (TecUtilStateChangeGetVarSet(&VarsAlteredRef))
               {
                 Set_pa ZonesAlteredRef = NULL;
                 if (TecUtilStateChangeGetZoneSet(&ZonesAlteredRef))
                   {
                     ... take action knowing which vars in which
                     ... were altered.
                   }
                 else
                   {
                     ... assume all zones were affected.  Take action
                     ... knowing which vars were altered.
                   }
               }
           } break;
         ... and so on...
       }
     TecUtilLockFinish(AddOnID);
   }
   .
   .
   .
   void InitTecAddOn(void)
   {
     ArgList_pa ArgList;
     ArbParam_t MyClientData;
     .
     . ...Assign something to MyClientData...
     .
     ArgList = TecUtilArgListAlloc();
     TecUtilArgListAppendFunction(ArgList, 
                                  SV_CALLBACKFUNCTION,
                                  (const void *)MyStateChangeCallback);
    
     TecUtilArgListAppendInt(     ArgList, 
                                  SV_STATECHANGECALLBACKAPI, 
                                  (LgIndex_t)StateChangeCallbackAPI_ChangePlusClient);

     TecUtilArgListAppendArbParam(ArgList, 
                                  SV_CLIENTDATA, 
                                  MyClientData);

     TecUtilStateChangeAddCallbackX(ArgList);
     TecUtilArgListDealloc(&ArgList);
     .
     .
     .
   }

void TecUtilStateChanged	(	StateChange_e	StateChange,
		ArbParam_t	CallData
	)

Inform tecplot of a state change.

Currently this must be called in the following situations:

Launch and dismiss of modal dialogs (Windows only).
After a variable has been added and subsequently modified.
After a variable has been modified.
After TecUtilDataSetAddZone() has been called and the field data has been modified (Use StateChange_ZonesAdded).
After the node map has been altered.

The CallData parameter is required for the following state changes:

                                  CallData 
     StateChange                  Type      Represents
     --------------------------------------------------------------------------
     StateChange_VarsAltered      Set_pa    set of variables altered
     StateChange_VarsAdded        Set_pa    set of variables added
     StateChange_ZonesDeleted     Set_pa    set of zones deleted
     StateChange_ZonesAdded       Set_pa    set of zones added
     StateChange_NodeMapsAltered  Set_pa    set of zones where nodemaps were altered

Parameters:

	StateChange	Specifies the state change of which to inform Tecplot. addons are only allowed to send specific state change messages. See the ADK User's Manual
	CallData	Extra information for the state change.

Fortran Syntax:

    SUBROUTINE TecUtilStateChanged(
   &           StateChange,
   &           CallDataPtr)
    INTEGER*4       StateChange
    POINTER         (CallDataPtr, CallData)

Python Syntax:

  Results = TecUtil.StateChanged(StateChange, CallData)

  Input:
                  StateChange          StateChange_e  (defined in TecVals.py)
                  CallData             (depends on attribute)
  Output:
    Results[0]    ReturnVal            NONE

Create a zone, modify its variable values, and inform Tecplot of the state change:

   if (TecUtilDataSetAddZone("Banana", 10, 10, 1,
                             ZoneType_Ordered, NULL))
     {
       EntIndex_t Zone;
       Set_pa     ZSet = TecUtilSetAlloc(TRUE);
       TecUtilDataSetGetInfo(NULL, &Zone, NULL);
   
       //  Set up the variable values for the new zone  
   
       TecUtilSetAddMember(ZSet, Zone,TRUE);
       TecUtilStateChanged(StateChange_ZonesAdded,(ArbParam_t)ZSet);
       TecUtilSetDealloc(&ZSet);
     }

void TecUtilStateChangedX ( ArgList_pa ArgList )

Inform Tecplot of a state change.

Parameters:

ArgList

An argument list containing the appropriate entries described below. Arguments are added to the list via calls to TecUtilArgListAppendXXXX functions.

Arglist Values

SV_STATECHANGE

Type:	StateChange_e
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	The state change to send to Tecplot. See sub-section "Sending state changes" in the ADK User's Manual for a list of possible state changes.

SV_VARLIST

Type:	Set_pa
Arg Function:	TecUtilArgListAppendSet()
Default:	NULL
Required:	No, (see below)

SV_ZONELIST

Type:	Set_pa
Arg Function:	TecUtilArgListAppendSet()
Default:	NULL
Required:	No, (see below)

SV_INDEX

Type:	Set_pa
Arg Function:	TecUtilArgListAppendSet()
Default:	NULL
Required:	No, (see below)

Note:: The SV_VARLIST, SV_ZONELIST and SV_INDEX arguments are required or optional based on the value of the state change argument. For a description of when you can and/or must supply these arguments see sub-section "Sending state changes" in the ADK User's Manual.

Returns:: TRUE if successful, FALSE otherwise.

Fortran Syntax:

    SUBROUTINE TecUtilStateChangedX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.StateChangedX(ArgList)

  Input:
                  ArgList              dictionary
  Output:
    Results[0]    ReturnVal            NONE

Inform tecplot that variables have been altered. Tell Tecplot that variable 2 in zones 3 and 4 has been altered.

 Set_pa     ZoneList = NULL;
 Set_pa     VarList  = NULL;
 ArgList_pa ArgList  = NULL;

 ArgList  = TecUtilArgListAlloc();
 ZoneList = TecUtilSetAlloc(FALSE);
 VarList  = TecUtilSetAlloc(FALSE);

 TecUtilSetAddMember(VarList,2,FALSE);

 TecUtilSetAddMember(ZoneList,3,FALSE);
 TecUtilSetAddMember(ZoneList,4,FALSE);

 TecUtilArgListAppendInt(ArgList,    SV_STATECHANGE,      StateChange_VarsAltered);
 TecUtilArgListAppendSet(ArgList,    SV_ZONELIST,         ZoneList);
 TecUtilArgListAppendSet(ArgList,    SV_VARLIST,          VarList);
 TecUtilStateChangedX(ArgList);

 TecUtilArgListDealloc(&ArgList);
 TecUtilSetDealloc(&ZoneList);
 TecUtilSetDealloc(&VarList);

Same example as above but for FORTRAN.

       INTEGER*4 DummyArgList
       pointer (ArgListPtr,DummyArgList)
       pointer (ZoneListPtr,DummyZoneList)
       INTEGER*4 DummyZoneList
       pointer (VarListPtr,DummyVarList)
       INTEGER*4 DummyVarList
       INTEGER*4 IShowErr,IErr
 
       IShowErr = 0
 
       Call TecUtilArgListAlloc(ArgListPtr)
       Call TecUtilSetAlloc(IShowErr,ZoneListPtr)
       Call TecUtilSetAlloc(IShowErr,VarListPtr)
 
       IErr = TecUtilSetAddMember(VarListPtr,2,IShowErr)

       IErr = TecUtilSetAddMember(ZoneListPtr,3,IShowErr)
       IErr = TecUtilSetAddMember(ZoneListPtr,4,IShowErr)
 
       IErr = TecUtilArgListAppendInt(ArgListPtr,
      &                               'STATECHANGE'//char(0),
      &                               StateChange_VarsAltered)
       IErr = TecUtilArgListAppendSet(ArgListPtr,
      &                               'ZONELIST'//char(0),
      &                               ZoneListPtr)
       IErr = TecUtilArgListAppendSet(ArgListPtr,
      &                               'VARLIST'//char(0),
      &                               VarListPtr)
 
       Call TecUtilStateChangedX(ArgListPtr)
 
       Call TecUtilArgListDealloc(ArgListPtr)
       Call TecUtilSetDealloc(ZoneListPtr)
       Call TecUtilSetDealloc(VarListPtr)

Boolean_t TecUtilStateChangeGetArbEnum ( LgIndex_t * ArbEnum )

Retrieve enumerated supplemental information from the previous state change.

Parameters:

ArbEnum

Retrieved enumerated value from the previous state change. Type cast this to the appropriate enum to get the value

Returns:: Returns TRUE successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStateChangeGetArbEnum(ArbEnum)
    INTEGER*4 ArbEnum

Python Syntax:

    This function is not supported in Python.

Your state change callback was just called with StateChange_View. Take action if the view type was View_Zoom

     LgIndex_t ArbEnumValue;
     TecUtilStateChangeGetArbEnum(&ArbEnumValue);
     if ((View_e)ArbEnumValue == View_Zoom)
        {
           .... take some action.
        }

Boolean_t TecUtilStateChangeGetIndex ( LgIndex_t * Index )

Retrieve Index supplemental information from the previous state change.

Since:: 11.0-5-016

Parameters:

Index

Retrieved Index value from the previous state change

Returns:: Returns TRUE successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStateChangeGetIndex(Index)
    INTEGER*4 Index

Python Syntax:

    This function is not supported in Python.

Your state change callback was just called with StateChange_VarsAltered. Take action if you can retrieve which data point index was altered.

     LgIndex_t IndexValue;
     if (TecUtilStateChangeGetIndex(&IndexValue))
       {
           .... take some action using IndexValue.
       }

void TecUtilStateChangeGetInfoX ( ArgList_pa ArgList )

Retrieve the P1,P2,P3,P4,P5 style parameters from the previous style state change.

As well as the Offset1, Offset2, and ObjectSet parameters.

This function is useful since the form is more consistent with the form required for calling TecUtilStyleSetLowLevelX and TecUtilStyleGetLowLevelX

Parameters:

ArgList

An argument list containing the appropriate entries described below. Arguments are added to the list via calls to TecUtilArgListAppendXXXX functions.

Arglist Values

SV_P1

Type:	char **
Arg Function:	TecUtilArgListAppendArbParamPtr()
Default:	NULL Note: DO NOT FREE THIS STRING. NULL will be returned if the previous state change does not have a P1 parameter
Required:	No

SV_P2

Type:	char **
Arg Function:	TecUtilArgListAppendArbParamPtr()
Default:	NULL Note: DO NOT FREE THIS STRING. NULL will be returned if the previous state change does not have a P2 parameter
Required:	No

SV_P3

Type:	char **
Arg Function:	TecUtilArgListAppendArbParamPtr()
Default:	NULL Note: DO NOT FREE THIS STRING. NULL will be returned if the previous state change does not have a P3 parameter
Required:	No

SV_P4

Type:	char **
Arg Function:	TecUtilArgListAppendArbParamPtr()
Default:	NULL Note: DO NOT FREE THIS STRING. NULL will be returned if the previous state change does not have a P4 parameter
Required:	No

SV_P5

Type:	char **
Arg Function:	TecUtilArgListAppendArbParamPtr()
Default:	NULL Note: DO NOT FREE THIS STRING. NULL will be returned if the previous state change does not have a P5 parameter
Required:	No

SV_OFFSET1

Type:	LgIndex_t *
Arg Function:	TecUtilArgListAppendArbParamPtr()
Default:	NULL Note: An offset of -1 will be returned if Offset1 does not apply to the previous state change
Required:	No

SV_OFFSET2

Type:	LgIndex_t *
Arg Function:	TecUtilArgListAppendArbParamPtr()
Default:	NULL Note: An offset of -1 will be returned if Offset2 does not apply to the previous state change
Required:	No

SV_OBJECTSET

Type:	Set_pa *
Arg Function:	TecUtilArgListAppendArbParamPtr()
Default:	NULL Note: DO NOT FREE THIS SET. NULL will be returned if ObjectSet does not apply to the previous state change.
Required:	No

Python Syntax:

    This function is not supported in Python.

Returns:: Returns TRUE successful, FALSE otherwise.

    const char* P1;
    const char* P2;
    const char* P3;
    const char* P4;
    const char* P5;
    Set_pa objectSet = NULL;
    LgIndex_t offset1;
    LgIndex_t offset2;
    ArgList_pa argList = TecUtilArgListAlloc();
    TecUtilArgListAppendArbParamPtr(argList, SV_P1, (ArbParam_t*)&P1);
    TecUtilArgListAppendArbParamPtr(argList, SV_P2, (ArbParam_t*)&P2);
    TecUtilArgListAppendArbParamPtr(argList, SV_P3, (ArbParam_t*)&P3);
    TecUtilArgListAppendArbParamPtr(argList, SV_P4, (ArbParam_t*)&P4);
    TecUtilArgListAppendArbParamPtr(argList, SV_P5, (ArbParam_t*)&P5);
    TecUtilArgListAppendArbParamPtr(argList, SV_OBJECTSET, (ArbParam_t*)&objectSet);
    TecUtilArgListAppendArbParamPtr(argList, SV_OFFSET1, (ArbParam_t*)&offset1);
    TecUtilArgListAppendArbParamPtr(argList, SV_OFFSET2, (ArbParam_t*)&offset2); 
    TecUtilStateChangeGetInfoX(argList);
    ... do something with P1, P2, P3, etc ...

Boolean_t TecUtilStateChangeGetMap ( EntIndex_t * Map )

Retrieve a reference to the map associated with the previous state change.

Since:: 11.0-0-320

Parameters:

Map

Reference to the map associated with the previous state change.

Returns:: Returns TRUE successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStateChangeGetMap(Map)
    INTEGER*4 Map

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilStateChangeGetName ( char ** NameRef )

Retrieve a reference to the name associated with the previous state change.

Since:: 10.0-3-129

Note:: Unlike many other properties retrieved from Tecplot this name string is not an allocated copy and should not be deallocated.

Parameters:

NameRef

Read-only reference to a retrieved name associated with the previous state change.

Returns:: Returns TRUE successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStateChangeGetName(
   &                   Name,
   &                   NameLength)
    CHARACTER*(*)   Name
    INTEGER*4       NameLength

Python Syntax:

    This function is not supported in Python.

Your state change callback was just called with StateChange_AuxDataAdded. Take action if it was "COMMON.TIME" auxiliary data associated with zone 2.

     LgIndex_t   ArbEnumValue;
     EntIndex_t  Zone;
     char       *Name;
     if ((TecUtilStateChangeGetArbEnum(&ArbEnumValue) &&      
          ((AuxDataLocation_e)ArbEnumValue == AuxDataLocation_Zone)) &&
         (TecUtilStateChangeGetZone(&Zone) &&
          Zone == 2)                                                 &&
         (TecUtilStateChangeGetName(&Name) &&
          ustrcmp(Name, AuxData_Common_Time) == 0))
        {
           .... take some knowing aux data "COMMON.TIME" was just added
           .... to zone Zone.
        }

Boolean_t TecUtilStateChangeGetStyleParam	(	int	Param,
		const char **	StyleParam
	)

Retrieve one of the P1,P2,P3,P4,P5,P6, or P7 style parameters from the previous style state change.

Parameters:

	Param	The parameter number to retrieve. Must be a number between 1 and 7
	StyleParam	Style parameter retrieved. DO NOT FREE THIS STRING.

Python Syntax:

    This function is not supported in Python.

Returns:: Returns TRUE successful, FALSE otherwise.

Your state change callback was just called with StateChange_Style. Take action if the first two style parameters are SV_INTERFACE and SV_USEAPPROXIMATEPLOTS.

     char *P1;
     char *P2;
     if (TecUtilStateChangeGetStyleParam(1,&P1) &&
         TecUtilStateChangeGetStyleParam(2,&P2) &&
         (strcmp(P1,SV_INTERFACE) == 0)             &&
         (strcmp(P2,SV_USEAPPROXIMATEPLOTS) == 0))
       {
           .... take some action.
       }

Boolean_t TecUtilStateChangeGetUniqueID ( UniqueID_t * UniqueID )

Retrieve UniqueID supplemental information from the previous state change.

Since:: 11.0-5-016

Parameters:

UniqueID

Retrieved UniqueID value from the previous state change.

Returns:: Returns TRUE successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStateChangeGetUniqueID(UniqueID)
    INTEGER*4 UniqueID

Python Syntax:

    This function is not supported in Python.

   UniqueID_t UniqueID;
   if (TecUtilStateChangeGetUniqueID(&UniqueID))
     {
       .... take some action using UniqueID.
     }

Boolean_t TecUtilStateChangeGetVar ( EntIndex_t * Var )

Retrieve a reference to the variable associated with the previous state change.

Since:: 11.0-0-320

Parameters:

Var

Reference to the variable associated with the previous state change.

Returns:: Returns TRUE successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStateChangeGetVar(Var)
    INTEGER*4 Var

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilStateChangeGetVarSet ( Set_pa * VarSetRef )

Retrieve a reference to the set of variables associated with the previous state change.

Note:: Unlike many other properties retrieved from Tecplot this set is not an allocated copy and should not be deallocated.

Parameters:

VarSetRef

Read-only reference to a retrieved set of variables associated with the previous state change.

Returns:: Returns TRUE successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStateChangeGetVarSet(VarSetRefPtr)
    POINTER (VarSetRefPtr, VarSetRef)

Python Syntax:

    This function is not supported in Python.

Your state change callback was just called with StateChange_VarsAltered. Take action using the retrieved set of variables that were altered.

   Set_pa VarsAlteredRef;
   if (TecUtilStateChangeGetVarSet(&VarsAlteredRef))
     {
         .... take some action using VarsAltered.
         .... Do not dealloc VarsAltered when finished.
     }

Boolean_t TecUtilStateChangeGetZone ( EntIndex_t * Zone )

Retrieve the number of the zone associated with the previous state change.

Parameters:

Zone

Retreived zone number associated with previous state change

Returns:: Returns TRUE successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStateChangeGetZone(Zone)
    INTEGER*4 Zone

Python Syntax:

    This function is not supported in Python.

Your state change callback was just called with StateChange_AuxDataAdded. Take action if it was auxiliary data associated with zone 2.

     LgIndex_t  ArbEnumValue;
     EntIndex_t Zone;
     if ((TecUtilStateChangeGetArbEnum(&ArbEnumValue) &&      
          ((AuxDataLocation_e)ArbEnumValue == AuxDataLocation_Zone)) &&
         (TecUtilStateChangeGetZone(&Zone) &&
          Zone == 2))
        {
           .... take some knowing aux data was just added
           .... to zone Zone.
        }

Boolean_t TecUtilStateChangeGetZoneSet ( Set_pa * ZoneSetRef )

Retrieve a reference to the set of zones associated with the previous state change.

Note:: Unlike many other properties retrieved from Tecplot this set is not an allocated copy and should not be deallocated.

Parameters:

ZoneSetRef

Read-only reference to a retreived set of zones associated with the previous state change.

Returns:: Returns TRUE successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStateChangeGetZoneSet(ZoneSetRefPtr)
    POINTER (ZoneSetRefPtr, ZoneSetRef)

Python Syntax:

    This function is not supported in Python.

Your state change callback was just called with StateChange_VarsAltered. Take action using the retrieved set of variables that were altered. In addition, if possible, make use of the set of zones that were altered if you can retrieve that information.

   Set_pa VarsAlteredRef;
   if (TecUtilStateChangeGetVarSet(&VarsAlteredRef))
     {
        Set_pa ZonesAlteredRef;
        if (TecUtilStateChangeGetZoneSet(&ZonesAlteredRef))
           {
              ... take action knowing both what zones and
              ... what vars were altered.
           }
         else
           {
              .... take some action using only VarsAltered.
              .... assume all zones were altered.
           }
     }

Boolean_t TecUtilStateChangeRemoveCallback ( void * AddOnStateChangeCallback )

Remove a previously added callback from Tecplot's list of add-on state change callbacks.

Note:: An add-on may not remove its callback in response to a state change.

Since:: 11.0-5-041

Parameters:

AddOnStateChangeCallback

Previously registered add-on callback to remove from Tecplot's list of state change callbacks.

Returns:: TRUE if the callback was found in the list of add-on state change callbacks, FALSE otherwise.

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilStateChangeRemoveCBX ( ArgList_pa ArgList )

Remove a previously added callback from Tecplot's list of add-on state change callbacks.

Note:: An add-on may not remove its callback in response to a state change.

Since:: 11.2-0-113

Parameters:

ArgList

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

Arglist Values

SV_CALLBACKFUNCTION

Type:	void *
Arg Function:	TecUtilArgListAppendFunction()
Required:	Yes
Notes:	Previously registered add-on state change callback to remove from Tecplot's list of state change callbacks.

SV_CLIENTDATA

Type:	ArbParam_t
Arg Function:	TecUtilArgListAppendArbParam()
Default:	0
Required:	No
Notes:	Client data that was previously registered with the callback. If supplied, Tecplot will only remove the callback that matches both the supplied callback function and client data. This is useful if the same callback was previously registered with different client data. If not supplied Tecplot will remove the first callback that matches the supplied function regardless of the client data registered with the callback.

Returns:: TRUE if the callback was found in the list of add-on state change callbacks, FALSE otherwise.

Fortran Syntax:

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

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilStateChangeSetMode	(	StateChangeAddOnCallback_pf	Callback,
		StateChangeMode_e	Mode
	)

Set the mode in which state changes are propagated to the specified state change callback.

Parameters:

	Callback	Function already registered to receive state change callbacks
	Mode	Mode you want state changes propagated to your state change callback function. Choose either StateChangeMode_v80 or StateChangeMode_v90. See the section "Sending State Changes" in the ADK User's Manual for a complete description on what is different between these two options

Returns:: Returns TRUE successful (that is, the callback function was registered), FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStateChangeSetMode(
   &                   StateChangeCallback,
   &                   Mode)
    EXTERNAL   StateChangeCallback
    INTEGER*4  Mode

Python Syntax:

    This function is not supported in Python.

Set the mode state change callbacks to the function BananaCallbackFunction to use the v90 mode.

     TecUtilStateChangeSetMode(BananaCallbackFunction,
                               StateChangeMode_v90);

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

Python Syntax:

  Results = TecUtil.StateIsProcessingJournal()

  Output:
    Results[0]    ReturnVal            boolean

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

Python Syntax:

  Results = TecUtil.StateIsProcessingLayout()

  Output:
    Results[0]    ReturnVal            boolean

Notification Services

Functions

Function Documentation


Functions
Boolean_t	TecUtilPickAtPosition (double X, double Y, Boolean_t CollectingObjects, Boolean_t DiggingForObjects)
	Pick an object at a specified location.
Boolean_t	TecUtilPickDeselectAll (void)
	Deselect all selected objects.
Boolean_t	TecUtilPickAddFrameByUniqueID (Boolean_t CollectingObjects, UniqueID_t UniqueID)
	Adds the frame identified by the unique identifier to the pick list.
Boolean_t	TecUtilPickAddZones (Boolean_t CollectingObjects, Set_pa ZoneSet)
	Adds the specified Line-maps to the pick object list.
Boolean_t	TecUtilPickAddXYMaps (Boolean_t CollectingObjects, Set_pa XYMapsSet)
Boolean_t	TecUtilPickAddLineMaps (Boolean_t CollectingObjects, Set_pa LineMapSet)
	Adds the specified Line-maps to the pick object list.
Boolean_t	TecUtilPickAddAll (PickObjects_e ObjectType)
	Add all objects of a certain type to the pick list.
Boolean_t	TecUtilPickAddAllInRect (double X1, double Y1, double X2, double Y2, PickObjects_e ObjectType, const char *Filter)
	Add all objects defined within a specified rectangle to the pick list.
Boolean_t	TecUtilPickEdit (const char *Action)
	Perform a global edit operation on the currently picked objects.
Boolean_t	TecUtilPickCut (void)
	Copy all objects that are currently picked to the paste buffer and then delete them from the plot.
Boolean_t	TecUtilPickCopy (void)
	Copy all objects that are currently picked to the paste buffer.
Boolean_t	TecUtilPickClear (void)
	Clear (that is, delete) all objects that are currently picked.
Boolean_t	TecUtilPickPaste (void)
	Paste the currently picked objects from the paste buffer to the workspace.
Boolean_t	TecUtilPickShift (double DXPaper, double DYPaper, PointerStyle_e PointerStyle)
	Shift the currently picked objects.
Boolean_t	TecUtilPickMagnify (double MagFactor)
	Magnify all picked objects.
Boolean_t	TecUtilPickPush (void)
	Change the order in which objects are drawn by pushing the currently picked objects back.
Boolean_t	TecUtilPickPop (void)
	Change the order in which objects are drawn by popping the currently picked objects to the front.
Boolean_t	TecUtilPickSetMouseMode (MouseButtonMode_e MouseMode)
MouseButtonMode_e	TecUtilMouseGetCurrentMode (void)
	Get Tecplot's current mouse mode.
Boolean_t	TecUtilMouseIsValidMode (MouseButtonMode_e MouseMode)
	This function will tell you if the specified mouse mode is valid for the current state of Tecplot.
Boolean_t	TecUtilMouseSetMode (MouseButtonMode_e MouseMode)
	Sets Tecplot's mouse mode to the one specified.
Boolean_t	TecUtilProbeInstallCallback (ProbeDestination_pf ProbeDestination, const char *InformationLineText)
	If the current frame mode is XY, 2D, or 3D, change the mouse mode to be the probe tool and instruct Tecplot to call a different function when the user completes a probe-like operation in the work area.
void	TecUtilProbeAllowCOBs (void)
	Instructs Tecplot to include COBs (iso-surfaces, slices, streamtraces, and so forth) along with zones during a probe when an add-on has a callback registered with TecUtilProbeInstallCallback() and if the user is pressing the Alt key.
double	TecUtilProbeXYGetIndValue (void)
double	TecUtilProbeLinePlotGetIndValue (void)
	Call this function from a probe destination callback to get the independent value from the previous probe event in an Line-plot.
Boolean_t	TecUtilProbeXYGetDepValue (EntIndex_t MapNum, double *DepValue)
Boolean_t	TecUtilProbeLinePlotGetDepValue (EntIndex_t MapNum, double *DepValue)
	Call this function from a probe destination callback to get a dependent value from the previous probe event in an Line-plot.
EntIndex_t	TecUtilProbeXYGetSourceMap (void)
EntIndex_t	TecUtilProbeLinePlotGetSourceMap (void)
	Call this function from a probe destination callback to get the Line-map whose point was selected in the previous nearest-point probe.
LgIndex_t	TecUtilProbeGetPointIndex (void)
	Call this function from a probe destination callback to get the point index from the previous nearest-point probe event in a field plot or an XY-plot.
CZType_e	TecUtilProbeFieldGetCZType (void)
	Indicates type type of COB or zone that was selected during the probe event.
double	TecUtilProbeFieldGetValue (EntIndex_t VarNum)
	Call this function from a probe destination callback to get a field variable value from the previous probe event in a field plot.
EntIndex_t	TecUtilProbeFieldGetZone (void)
	Call this function from a probe destination callback to get the zone number from the previous probe event in a field plot.
IJKPlanes_e	TecUtilProbeFieldGetPlane (void)
	Call this function from a probe destination callback to get the I-, J-, or K-plane from the previous probe event in a field plot.
SmInteger_t	TecUtilProbeFieldGetFaceNumber (void)
	Call this function from a probe destination callback to get the face number from the previous probe event in a field plot.
LgIndex_t	TecUtilProbeFieldGetFaceCell (void)
	Call this function from a probe destination callback to get the cell from the previous probe event in a field plot.
LgIndex_t	TecUtilProbeFieldGetCell (void)
	Call this function from a probe destination callback to get the cell from the previous probe event in a field plot.
Boolean_t	TecUtilEventAddPreDrawCallback (DrawEventCallback_pf DrawEventCallback, ArbParam_t ClientData)
	Adds the callback and its client data to the list of pre-draw event callbacks.
Boolean_t	TecUtilEventAddPostDrawCallback (DrawEventCallback_pf DrawEventCallback, ArbParam_t ClientData)
	Adds the callback and its client data to the list of post-draw event callbacks.
Boolean_t	TecUtilStateChangeSetMode (StateChangeAddOnCallback_pf Callback, StateChangeMode_e Mode)
	Set the mode in which state changes are propagated to the specified state change callback.
Boolean_t	TecUtilStateChangeAddCallback (StateChangeAddOnCallback_pf StateChangeCallback)
	Include a function in the list of functions to call when a state change occurs in Tecplot.
void	TecUtilStateChanged (StateChange_e StateChange, ArbParam_t CallData)
	Inform tecplot of a state change.
Boolean_t	TecUtilStateChangeRemoveCBX (ArgList_pa ArgList)
	Remove a previously added callback from Tecplot's list of add-on state change callbacks.
Boolean_t	TecUtilStateChangeRemoveCallback (void *AddOnStateChangeCallback)
	Remove a previously added callback from Tecplot's list of add-on state change callbacks.
Boolean_t	TecUtilStateChangeAddCallbackX (ArgList_pa ArgList)
	Add a callback to Tecplot's list of add-on's to receive state changes notifications.
Boolean_t	TecUtilStateChangeGetIndex (LgIndex_t *Index)
	Retrieve Index supplemental information from the previous state change.
Boolean_t	TecUtilStateChangeGetUniqueID (UniqueID_t *UniqueID)
	Retrieve UniqueID supplemental information from the previous state change.
Boolean_t	TecUtilStateChangeGetArbEnum (LgIndex_t *ArbEnum)
	Retrieve enumerated supplemental information from the previous state change.
Boolean_t	TecUtilStateChangeGetZoneSet (Set_pa *ZoneSetRef)
	Retrieve a reference to the set of zones associated with the previous state change.
Boolean_t	TecUtilStateChangeGetVarSet (Set_pa *VarSetRef)
	Retrieve a reference to the set of variables associated with the previous state change.
Boolean_t	TecUtilStateChangeGetName (char **NameRef)
	Retrieve a reference to the name associated with the previous state change.
Boolean_t	TecUtilStateChangeGetMap (EntIndex_t *Map)
	Retrieve a reference to the map associated with the previous state change.
Boolean_t	TecUtilStateChangeGetZone (EntIndex_t *Zone)
	Retrieve the number of the zone associated with the previous state change.
Boolean_t	TecUtilStateChangeGetVar (EntIndex_t *Var)
	Retrieve a reference to the variable associated with the previous state change.
Boolean_t	TecUtilStateChangeGetStyleParam (int Param, const char **StyleParam)
	Retrieve one of the P1,P2,P3,P4,P5,P6, or P7 style parameters from the previous style state change.
void	TecUtilStateChangeGetInfoX (ArgList_pa ArgList)
	Retrieve the P1,P2,P3,P4,P5 style parameters from the previous style state change.
void	TecUtilStateChangedX (ArgList_pa ArgList)
	Inform Tecplot of a state change.
Boolean_t	TecUtilPickGeom (Geom_ID GID)
	Add the specified geometry to the pick list.
Boolean_t	TecUtilPickText (Text_ID TID)
	Add the specified text to the pick list.
int	TecUtilLockGetCount (void)
	Determine how many levels of locking are currently active in Tecplot.
Boolean_t	TecUtilLockIsOn (void)
	Determine if Tecplot is locked.
int	TecUtilPickListGetCount (void)
	Get the number of items currently in the pick list.
PickObjects_e	TecUtilPickListGetType (int PickListIndex)
	Gets the type of object from the pick list at the specified index.
char *	TecUtilPickListGetFrameName (int PickListIndex)
	Get the name of the frame from the pick list at the specified index.
UniqueID_t	TecUtilPickListGetFrameUniqueID (int PickListIndex)
	Get the unique identifier of the frame from the pick list at the specified index.
void	TecUtilGetBoundingBoxOfAllFrames (double X1, double Y1, double X2, double Y2)
	Get dimension of the bounding box surrounding all frames in CoordSys_Paper units.
char	TecUtilPickListGetAxisKind (int PickListIndex)
	Get the kind of axis (X, Y, or Z) from the pick list at the specified index.
int	TecUtilPickListGetAxisNumber (int PickListIndex)
	Get the number of the axis from the pick list at the specified index.
EntIndex_t	TecUtilPickListGetZoneNumber (int PickListIndex)
	Get the number of the zone from the pick list at the specified index.
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.
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.
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.
Text_ID	TecUtilPickListGetText (int PickListIndex)
	Get the text from the pick list at the specified index.
Geom_ID	TecUtilPickListGetGeom (int PickListIndex)
	Get the geometry from the pick list at the specified index.
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.
Boolean_t	TecUtilStateIsProcessingJournal (void)
	Query Tecplot to find out if Tecplot is in the middle of processing the data journal.
Boolean_t	TecUtilStateIsProcessingLayout (void)
	Query Tecplot to find out if Tecplot is in the middle of processing a layout.
void	TecUtilProbeAtPosSequenceBeginX (ArgList_pa ArgList)
	Begin a sequence of calling TecUtilProbeAtPosition() many times.
void	TecUtilProbeAtPosSequenceEnd (void)
	End a sequence of calling TecUtilProbeAtPosition() many times.
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.