Utilites

Functions
Boolean_t	TecUtilDoubleBuffer (DoubleBufferAction_e DoubleBufferAction)
	Implements a double buffer action as described below by the DoubleBufferAction parameter definitions.
Boolean_t	TecUtilQuit (void)
	Terminate the execution of the Tecplot program.
char *	TecUtilGetBasePath (const char *FName)
	Get the base path of a file name.
Boolean_t	TecUtilDelay (LgIndex_t Seconds)
	Delay Tecplot execution for a specified time.
Boolean_t	TecUtilSystem (const char *Command, Boolean_t Wait)
	Instruct Tecplot to submit and execute an operating system specific command.
void	TecUtilSetupTransformations (void)
	Initializes transformation information so that coordinate conversion functions can be used.
void	TecUtilMemoryChangeNotify (Int64_t ChangeInKBytes)
	Notify Tecplot when a significant change in memory occurs that is outside Tecplot's knowledge.
void	TecUtilWindowsAssertionFailed (const char *expr, const char *file, int line)
	Private: Used by Windows add-ons in checked builds to display an assertion error and copy the assertion to the Windows clipboard.
char *	TecUtilStringFormatValue (double Value, NumberFormat_e Format, SmInteger_t Precision)
	Formats the data value according to the specified format and precision.
char *	TecUtilStringFormatTimeDate (double TimeDateValue, const char *TimeDateFormat)
	Formats the data value according to the specified time/date format.
Boolean_t	TecUtilTimerAddCallback (UInt32_t Interval, ArbParam_t ClientData, AddOnTimerCallback_pf TimerCallback)
	Adds a timer callback, a function which is called by Tecplot at a set interval of time.
Boolean_t	TecUtilOnIdleQueueAddCallback (OnIdleCallback_pf Callback, ArbParam_t ClientData)
	Adds the function to a list of functions that Tecplot calls only one time when Tecplot is in an idle state.
Boolean_t	TecUtilOnIdleQueueRemoveCallback (OnIdleCallback_pf Callback, ArbParam_t ClientData)
	Remove the oldest registered callback/client data pair from the on-idle queue if it exists.
Boolean_t	TecUtilFileDownloadURL (const char *SourceURL, const char *LocalDestinationFile, Boolean_t IsAscii, Boolean_t ConfirmOverwrite)
	Download a file given a valid URL.
Boolean_t	TecUtilFileUploadURL (const char *LocalSourceFile, const char *DestinationURL, Boolean_t IsAscii, Boolean_t ConfirmOverwrite)
	Upload a file given a valid URL.
Boolean_t	TecUtilFileIsURL (const char *URLFName)
	Convenience function that will determine if a supplied string uses valid URL syntax.
void	TecUtilArrayDealloc (void **Array)
	Deallocates an array that was allocated and given to an add-on by Tecplot and assigns the pointer to NULL.
Boolean_t	TecUtilQuitAddQueryCallback (MopupQueryAddOnCallback_pf QuitQueryCallback)
	Include a function in the list of functions to call when Tecplot is considering shutting down.
void	TecUtilDispatchWorkAreaEvent (int I, int J, int ButtonOrKey, Event_e Event, Boolean_t IsShifted, Boolean_t IsAlted, Boolean_t IsControlled)
	Dispatches a Tecplot work area event to the Tecplot engine.
Boolean_t	TecUtilInterruptCheck (void)
	Checks if Tecplot is in an interrupted state.
void	TecUtilInterrupt (void)
	Interrupt Tecplot execution.
char *	TecUtilStringConvOldFormatting (const char *OldString, Font_e BaseFont)
	Convert a text string using the old formatting syntax into the new formatting syntax.
char *	TecUtilStringAlloc (int MaxLength, const char *DebugInfo)
	Allocate a character string.
void	TecUtilStringDealloc (char **S)
	Free a string previously allocated with TecUtilStringAlloc(), or one that was allocated and returned as the result of calling any other TecUtilXxx function.
void	TecUtilDropOpeningBanner (void)
	Forces drop of opening banner.
void	TecUtilPopMainProcessWindow (void)
	Pop Tecplot to the top of the Z-Order.
void	TecUtilHelp (const char *HelpFileOrURL, Boolean_t GoToID, int HelpID)
	Use either WinHelp or a browser to view help information.
void	TecUtilPleaseWait (const char *WaitMessage, Boolean_t DoWait)
	Shows or hides the wait cursor and optionally displays a wait message.
int	TecUtilThreadPoolPoolSize (void)
	Returns the number of worker threads assigned to this thread pool.
int	TecUtilThreadPoolJobThreadOffset (void)
	Returns this worker thread's unique offset.
int	TecUtilThreadPoolGetNumConcurrentJobs (void)
	Returns the number of jobs that can concurrently run within the thread pool.
LgIndex_t	TecUtilGetTecplotVersion (void)
LgIndex_t	TecUtilTecplotGetMajorVersion (void)
	Gets Tecplot's major version number.
LgIndex_t	TecUtilTecplotGetMinorVersion (void)
	Gets Tecplot's minor version number.
LgIndex_t	TecUtilTecplotGetMajorRevision (void)
	Gets Tecplot's major revision number.
LgIndex_t	TecUtilTecplotGetMinorRevision (void)
	Gets Tecplot's minor revision number.
char *	TecUtilTecplotGetHomeDirectory (void)
	Get the Tecplot home directory.
char *	TecUtilTecplotGetExePath (void)
	Get the full path name of the Tecplot executable.
LgIndex_t	TecUtilLimitGetValue (const char *LimitString)
	Convenience function to query Tecplot for a limit value.
Boolean_t	TecUtilGetTempFileName (char **TempFileName)
Boolean_t	TecUtilFileGetTempName (char **TempFileName)
	Creates a temporary file name, including a full path.
Boolean_t	TecUtilFileGetTempDirName (char **TempDirName)
	Creates a temporary directory name, including a full path.
Set_pa	TecUtilDataSetGetZonesForStrandID (Strand_t strandID)
	Returns a list of zones associated to the specifiesd strand Id.
Set_pa	TecUtilDataSetGetStrandIDs (void)
	Returns a list of all the existing strand Ids.
Set_pa	TecUtilDataSetGetActiveStrandIDs (void)
	Returns a list of all the active existing strand Ids.
Boolean_t	TecUtilExtractTimesFromFileNames (StringList_pa fileNames, double *times, Boolean_t requireAlphaTokenMatching)
	Extracts time values from a consistent tokenized location within the list of file names.
Boolean_t	TecUtilQueryCanPlotStreamtraces (void)
	Determine if streamtraces can be ploted.
Boolean_t	TecUtilQueryCanPlotVolumeStreamtraces (void)
	Determine if volume streamtraces can be ploted.
Boolean_t	TecUtilQueryCanPlotSlices (void)
	Determine if slices can be ploted.
Boolean_t	TecUtilQueryPlotContainsContourLines (void)
	Determine if the plot contains contour lines.
Boolean_t	TecUtilQueryContourLevelModificationsAllowed (void)
	Determine if contour level modification are allowed.
Boolean_t	TecUtilQueryOkToExtractPoints (void)
	Determine if points can be extracted.
Boolean_t	TecUtilQueryStreamtracesAreActive (void)
	Determine if there are active streamtraces.
Boolean_t	TecUtilQueryOkToCopyPickedObjects (void)
	Determine if there are picked objects to copy This function is Thread Safe.
Boolean_t	TecUtilQueryOkToPastePickedObjects (void)
	Determine if there are picked objects to paste This function is Thread Safe.
Boolean_t	TecUtilQueryOkToClearPickedObjects (void)
	Determine if there are picked objects to clear This function is Thread Safe.
Boolean_t	TecUtilQueryOkToPushPopPickedObjects (void)
	Determine if there are picked objects to send to the back or bring to the front This function is Thread Safe.
Boolean_t	TecUtilQueryIsLayoutDirty (void)
	Determine if the dirty layout flag was activated
Boolean_t	TecUtilQueryLayoutHasStyle (void)
	Determine if the current layout has any style, checking if there are pages or data ser defined, as well as a base text or base geom on a current frame

---

Function Documentation

void TecUtilArrayDealloc

(

void **

Array

)

Deallocates an array that was allocated and given to an add-on by Tecplot and assigns the pointer to NULL.

This function may not be used for deallocating memory allocated by any other facility (such as the add-on itself).

Parameters:

Array

Pointer to the Array to be deallocated.

Precondition:

Array Pointer must be a valid address and non-NULL.

Array Pointer must be a valid address or NULL.

Fortran Syntax:

    SUBROUTINE TecUtilArrayDealloc(Array)
    POINTER (ArrayPtr, Array)

Python Syntax:

    This function is not supported in Python.

See also:

See TecGUIListGetSelectedItems() for a complete example.

Set_pa TecUtilDataSetGetActiveStrandIDs

(

void

)

Returns a list of all the active existing strand Ids.

Returns:

Allocated set containing the active strand Ids.

Precondition:

Must have one or more frames.

Fortran Syntax:

Python Syntax:

  Results = TecUtil.DataSetGetActiveStrandIDs()

  Output:
    Results[0]    ReturnVal            sequence of ints

See also:

Since:

13.0.0.14385

Set_pa TecUtilDataSetGetStrandIDs

(

void

)

Returns a list of all the existing strand Ids.

Returns:

Allocated set containing the strand Ids.

Precondition:

Must have one or more frames.

Fortran Syntax:

Python Syntax:

  Results = TecUtil.DataSetGetStrandIDs()

  Output:
    Results[0]    ReturnVal            sequence of ints

See also:

Since:

13.0.0.14385

Set_pa TecUtilDataSetGetZonesForStrandID

(

Strand_t

strandID

)

Returns a list of zones associated to the specifiesd strand Id.

Parameters:

strandID

Strand Id to get the related zones.

Returns:

Allocated set containing the zones related to the specified strand Id.

Precondition:

Must have one or more frames.

Fortran Syntax:

Python Syntax:

  Results = TecUtil.DataSetGetZonesForStrandID(strandID)

  Input:
                  strandID             int
  Output:
    Results[0]    ReturnVal            sequence of ints

See also:

Since:

13.0.0.14385

Boolean_t TecUtilDelay

(

LgIndex_t

Seconds

)

Delay Tecplot execution for a specified time.

Parameters:

Seconds

Number of seconds to delay

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDelay(Seconds)
    INTEGER*4 Seconds

Python Syntax:

  Results = TecUtil.Delay(Seconds)

  Input:
                  Seconds              int
  Output:
    Results[0]    ReturnVal            boolean

void TecUtilDispatchWorkAreaEvent	(	int	I,
		int	J,
		int	ButtonOrKey,
		Event_e	Event,
		Boolean_t	IsShifted,
		Boolean_t	IsAlted,
		Boolean_t	IsControlled
	)

Dispatches a Tecplot work area event to the Tecplot engine.

The event is queued to be processed at time deemed appropriate by Tecplot.

Since:

11.0-5-036

Parameters:

	I	I-Location in the work area where the event occurs (in screen coordinates) with 0 being the left edge of the work area.
	J	J-Location in the work area where the event occurs (in screen coordinates) with 0 being the top edge of the work area.
	ButtonOrKey	The ButtonOrKey parameter assumes the following: If the event is a button press, then: ButtonOrKey = 1 ....... Mouse button 1. ButtonOrKey = 2 ....... Mouse button 2. If the event is a key press then: ButtonOrKey = 32 to 127 for ASCII characters on the keyboard.
	Event	Event type. The possible values are: Event_ButtonPress, Event_ButtonRelease, Event_ButtonDoublePress, Event_Motion, Event_Drag or Event_KeyPress
	IsShifted	Set to TRUE if Shift key is held down.
	IsAlted	Set to TRUE if Alt key is held down.
	IsControlled	Set to TRUE if Ctrl key is held down.

Python Syntax:

  Results = TecUtil.DispatchWorkAreaEvent(I, J, ButtonOrKey, Event, IsShifted, IsAlted, IsControlled)

  Input:
                  I                    int
                  J                    int
                  ButtonOrKey          int
                  Event                Event_e  (defined in TecVals.py)
                  IsShifted            boolean
                  IsAlted              boolean
                  IsControlled         boolean
  Output:
    Results[0]    ReturnVal            NONE

Boolean_t TecUtilDoubleBuffer

(

DoubleBufferAction_e

DoubleBufferAction

)

Implements a double buffer action as described below by the DoubleBufferAction parameter definitions.

Parameters:

DoubleBufferAction

Action to take. The possible values are:

• DoubleBufferAction_Off (turns off double buffering. Use this command once at the end of a sequence of using the double buffer).
• DoubleBufferAction_On (turns on double buffering. Use this command once at the beginning of a sequence of using the double buffer. While double buffering is turned on, all drawing is sent to the back buffer).
• DoubleBufferAction_Swap (swaps the back buffer to the front. In other words, copy the image in the back buffer to the front).

Returns:

TRUE if successful, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDoubleBuffer(DoubleBufferAction)
    INTEGER*4 DoubleBufferAction

Python Syntax:

  Results = TecUtil.DoubleBuffer(DoubleBufferAction)

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

void TecUtilDropOpeningBanner

(

void

)

Forces drop of opening banner.

If this function is not called, the opening banner will stay up until all addons are loaded.

Fortran Syntax:

    SUBROUTINE TecUtilDropOpeningBanner()

Python Syntax:

  Results = TecUtil.DropOpeningBanner()

  Output:
    Results[0]    ReturnVal            NONE

Boolean_t TecUtilExtractTimesFromFileNames	(	StringList_pa	fileNames,
		double *	times,
		Boolean_t	requireAlphaTokenMatching
	)

Extracts time values from a consistent tokenized location within the list of file names.

Each file name is broken into its tokenized parts separated by alpha characters and numbers. A dash ('-') or a plus sign ('+') is considered part of a number if it precedes a number and is not preceded by an alpha character or a digit character, otherwise it is considered part of the alpha tokens. If the tokenized file names have multiple numeric fields the one that provides the unique set of times is chosen. Example: The following list of file names:

     mach1.1_alpha0.75_+1.0e-1+1530.q
     mach1.1_alpha0.80_+1.1e-1+1530.q
     mach1.1_alpha0.85_+1.2e-1+1530.q
     mach1.1_alpha0.90_+1.3e-1+1530.q
     mach1.2_alpha0.75_+1.4e-1+1530.q
     mach1.2_alpha0.80_+1.5e-1+1530.q
     mach1.2_alpha0.85_+1.6e-1+1530.q
     mach1.2_alpha0.90_+1.7e-1+1530.q
   

will be splitted into the following tokens:

     "mach", "1.1", "_alpha", "0.75_", "+1.0e-1", "+", "1530", ".q"
     "mach", "1.1", "_alpha", "0.80_", "+1.1e-1", "+", "1530", ".q"
     "mach", "1.1", "_alpha", "0.85_", "+1.2e-1", "+", "1530", ".q"
     "mach", "1.1", "_alpha", "0.90_", "+1.3e-1", "+", "1530", ".q"
     "mach", "1.2", "_alpha", "0.75_", "+1.4e-1", "+", "1530", ".q"
     "mach", "1.2", "_alpha", "0.80_", "+1.5e-1", "+", "1530", ".q"
     "mach", "1.2", "_alpha", "0.85_", "+1.6e-1", "+", "1530", ".q"
     "mach", "1.2", "_alpha", "0.90_", "+1.7e-1", "+", "1530", ".q"
   

and will return the following time steps

     0.1
     0.11
     0.12
     0.13
     0.14
     0.15
     0.16
     0.17
   

since the second to last numerical column (the fourth to last considering all columns) is the one that contains unique values.

Parameters:

	fileNames	String list of file names containing an embedded time value.
	times	A pre-sized array to receive the resulting time values. If the file names contain multiple numeric token fields, the token field that contains a unique set of time values is used.
	requireAlphaTokenMatching	A boolean flag that turns on or off the behavior to force the alpha character tokens to match, case sensitive. TRUE enables this behavior, FALSE disables it.

Returns:

TRUE if the time values could be parsed, FALSE otherwise.

Precondition:

times Pointer must be a valid address and non-NULL.

requireAlphaTokenMatching Value must be TRUE or FALSE.

Since:

13.2.0.16744

See also:

Python Syntax:

  Results = TecUtil.ExtractTimesFromFileNames(fileNames, requireAlphaTokenMatching)

  Input:
                  fileNames            sequence of strings
                  requireAlphaTokenMatching boolean
  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    times                double

Boolean_t TecUtilFileDownloadURL	(	const char *	SourceURL,
		const char *	LocalDestinationFile,
		Boolean_t	IsAscii,
		Boolean_t	ConfirmOverwrite
	)

Download a file given a valid URL.

Parameters:

	SourceURL	A string representing the URL for the file to download. Must be valid URL syntax
	LocalDestinationFile	A string representing a local filename where the data is to be stored
	IsAscii	Set to TRUE if the file is to be treated as an ASCII file during the download. Set to FALSE if it is to be treated as a Binary file during the download
	ConfirmOverwrite	Set to TRUE if you want the user to be prompted with a message and options if LocalDestinationFile exists. The user can then choose to cancel the operation. If set to FALSE and LocalDestinationFile exists it will be overwritten with no warning

Precondition:

SourceURL Pointer must be a valid address and non-NULL.

LocalDestinationFile Pointer must be a valid address and non-NULL.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilFileDownloadURL(
   &                   SourceURL,
   &                   LocalDestinationFile,
   &                   IsAscii,
   &                   ConfirmOverwrite)
    CHARACTER*(*)   SourceURL
    CHARACTER*(*)   LocalDestinationFile
    INTEGER*4       IsAscii
    INTEGER*4       ConfirmOverwrite

Python Syntax:

  Results = TecUtil.FileDownloadURL(SourceURL, LocalDestinationFile, IsAscii, ConfirmOverwrite)

  Input:
                  SourceURL            string
                  LocalDestinationFile string
                  IsAscii              boolean
                  ConfirmOverwrite     boolean
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilFileGetTempDirName

(

char **

TempDirName

)

Creates a temporary directory name, including a full path.

An empty directory with the temporary directory name is also created. This function is Thread Safe.

Parameters:

TempDirName

Receives the temporary directory name, including path. You must later free this string with TecUtilStringDealloc()

Returns:

TRUE if successful, FALSE otherwise. If the return value is FALSE, *TempDirName is set to NULL.

Precondition:

TempDirName Pointer must be a valid address and non-NULL.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilFileGetTempDirName(
   &                   TempDirName,
   &                   TempDirNameLength)
    CHARACTER*(*)   TempDirName
    INTEGER*4       TempDirNameLength

Python Syntax:

  Results = TecUtil.FileGetTempDirName()

  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    TempDirName          string

Boolean_t TecUtilFileGetTempName

(

char **

TempFileName

)

Creates a temporary file name, including a full path.

An empty file with the temporary file name is also created. This function is Thread Safe.

Parameters:

TempFileName

Receives the temporary file name, including path. You must later free this string with TecUtilStringDealloc()

Returns:

TRUE if successful, FALSE otherwise. If the return value is FALSE, *FileName is set to NULL.

Precondition:

TempFileName Pointer must be a valid address and non-NULL.

Fortran Syntax:

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

Python Syntax:

  Results = TecUtil.FileGetTempName()

  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    TempFileName         string

Create a temporary file.

   {
     FILE *TempFile = NULL;
     char *TempFileName = NULL;

     if ( TecUtilFileGetTempName(&TempFileName) )
       {
         TempFile = fopen(TempFileName,"w");
         if ( TempFile )
           {
             // Do something with the temp file.
             fclose(TempFile);
           }

         // Be sure to deallocate the string when finished.
         TecUtilStringDealloc(&TempFileName);
       }
   }

Boolean_t TecUtilFileIsURL

(

const char *

URLFName

)

Convenience function that will determine if a supplied string uses valid URL syntax.

Parameters:

*URLFName

A string containing the URL to test

Returns:

Returns TRUE if URL is valid, FALSE otherwise

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilFileIsURL(URLFName)
    CHARACTER*(*) URLFName

Python Syntax:

  Results = TecUtil.FileIsURL(URLFName)

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

Boolean_t TecUtilFileUploadURL	(	const char *	LocalSourceFile,
		const char *	DestinationURL,
		Boolean_t	IsAscii,
		Boolean_t	ConfirmOverwrite
	)

Upload a file given a valid URL.

Parameters:

	LocalSourceFile	A string representing the local file to upload
	DestinationURL	A string representing the remote filename where the data is to be stored. Must be valid URL syntax,
	IsAscii	Set to TRUE if the file is to be treated as an ASCII file during the upload. Set to FALSE if it is to be treated as a Binary file during the upload
	ConfirmOverwrite	Set to TRUE if you want the user to be prompted with a message and options if exists. The user can then choose to cancel the operation. If set to FALSE and DestinationURL exists it will be overwritten with no warning

Precondition:

LocalSourceFile Pointer must be a valid address and non-NULL.

DestinationURL Pointer must be a valid address and non-NULL.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilFileUploadURL(
   &                   LocalSourceFile,
   &                   DestinationURL,
   &                   IsAscii,
   &                   ConfirmOverwrite)
    CHARACTER*(*)   LocalSourceFile
    CHARACTER*(*)   DestinationURL
    INTEGER*4       IsAscii
    INTEGER*4       ConfirmOverwrite

Python Syntax:

  Results = TecUtil.FileUploadURL(LocalSourceFile, DestinationURL, IsAscii, ConfirmOverwrite)

  Input:
                  LocalSourceFile      string
                  DestinationURL       string
                  IsAscii              boolean
                  ConfirmOverwrite     boolean
  Output:
    Results[0]    ReturnVal            boolean

char* TecUtilGetBasePath

(

const char *

FName

)

Get the base path of a file name.

This function allocates space for and creates a new string of the base path.

Parameters:

FName

File name. A NULL file name is allowed in which case the startup directory is returned

Returns:

The base path of the file name including the trailing '/' or '\.' You must call TecUtilStringDealloc() on the returned string.

Fortran Syntax:

    SUBROUTINE TecUtilGetBasePath(
   &           FName,
   &           Result,
   &           ResultLength)
    CHARACTER*(*)   FName
    CHARACTER*(*)   Result
    INTEGER*4       ResultLength

Python Syntax:

  Results = TecUtil.GetBasePath(FName)

  Input:
                  FName                string
  Output:
    Results[0]    ReturnVal            string

Get the start up directory and the base path of the current layout file name:

   char *FName = TecUtilGetCurLayoutFName();
   if (FName)
     {
       char *StartUpDir = TecUtilGetBasePath(NULL);
       char *BasePath = TecUtilGetBasePath(FName);
       //  BasePath is something like "C:\TEC75\DEMO\LAY\"
       if (BasePath)
         {
           .
           .
             TecUtilStringDealloc(&BasePath);
         }
       TecUtilStringDealloc(&FName);
       if (StartUpDir)
         TecUtilStringDealloc(&StartUpDir);
     }

LgIndex_t TecUtilGetTecplotVersion

(

void

)

Deprecated:

Please use TecUtilTecplotGetMajorVersion(), TecUtilTecplotGetMinorVersion(), TecUtilTecplotGetMajorRevision(), and TecUtilTecplotGetMinorRevision() instead.

Python Syntax:

  Results = TecUtil.GetTecplotVersion()

  Output:
    Results[0]    ReturnVal            int

Boolean_t TecUtilGetTempFileName

(

char **

TempFileName

)

Deprecated:

Please use TecUtilFileGetTempName() instead.

Python Syntax:

  Results = TecUtil.GetTempFileName()

  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    TempFileName         string

void TecUtilHelp	(	const char *	HelpFileOrURL,
		Boolean_t	GoToID,
		int	HelpID
	)

Use either WinHelp or a browser to view help information.

WinHelp is only available under Windows.

Parameters:

	HelpFileOrURL	This represents either a WinHelp file or a valid URL for a browser. If HelpFileOrURL ends with .hlp then this is assumed to be a WinHelp file, and in Windows, the Windows help engine will be launched (in UNIX, an error will result). You can specify an absolute path, or just use the base name and Tecplot will prepend the path to the help subdirectory below the Tecplot home directory for you. If this parameter does not end in .hlp then this is assumed to be a local HTML file or a valid URL. If just a base file name is supplied, then file:/ and the help directory below the Tecplot home directory will be prepended for you. If http:/ or file:/ is not prepended, then file:/ will be prepended for you. Specifying crunch/index.html will launch the browser with file:/xxxxx/help/crunch/index.html where xxxxx is the Tecplot home directory. You must begin HelpFileOrURL with http:/ or www. if you wish to reference something on the web. In Windows a query is made to determine the currently registered browser. In UNIX you must specify the command to use to launch your browser. To specify the browser command, add the following to your tecplot.cfg file:This requires that Netscape is already up and running and is iconified. If Netscape is not up then use:$!Interface UnixBrowserLaunchCmd = "/opt/netscape/netscape 'OpenURL(@)'".
	GoToID	Flag specifying whether or not to skip into the help file. This is only used if a WinHelp file is being loaded. Set to TRUE if you want to skip to the location in the help file identified by HelpID. If set to FALSE, then the index page appears first.
	HelpID	Location to go to in the help file. This is only used if a WinHelp file is being loaded. If GotoID is TRUE, then set this to the marker number to skip to in the .hlp file.

Precondition:

VALID_NON_ZERO_LEN_STR(HelpFName) String must have a valid address and non-zero length.

Fortran Syntax:

    SUBROUTINE TecUtilHelp(
   &           HelpFileOrURL,
   &           GoToID,
   &           HelpID)
    CHARACTER*(*)   HelpFileOrURL
    INTEGER*4       GoToID
    INTEGER*4       HelpID

Python Syntax:

  Results = TecUtil.Help(HelpFileOrURL, GoToID, HelpID)

  Input:
                  HelpFileOrURL        string
                  GoToID               boolean
                  HelpID               int
  Output:
    Results[0]    ReturnVal            NONE

Use a browser to launch the help file myaddon.html from the help sub-directory below the Tecplot home directory:

   TecUtilHelp("myaddon.html",FALSE,0);

void TecUtilInterrupt

(

void

)

Interrupt Tecplot execution.

This is mainly for use with addons which use timers.

Fortran Syntax:

    SUBROUTINE TecUtilInterrupt()

Python Syntax:

  Results = TecUtil.Interrupt()

  Output:
    Results[0]    ReturnVal            NONE

The function NewDataIsReady is assumed to be called when a timer goes off and some new data is ready to be read into Tecplot. OldDataIsNotDoneDrawingYet is a boolean which is TRUE if the previous data is still being drawn in Tecplot's workspace. Interrupt Tecplot if the new data is ready before the old data is finished redrawing.

   extern Boolean_t OldDataIsNotDoneDrawingYet;
   void NewDataIsReady (void)
   {
     if (OldDataIsNotDoneDrawingYet)
       TecUtilInterrupt();
     //  Load the new data into Tecplot and redraw
   }

Boolean_t TecUtilInterruptCheck

(

void

)

Checks if Tecplot is in an interrupted state.

This function should be called during long tasks that are performed within the add-on where the user might want to interrupt the process by pressing a key. This function is Thread Safe.

Since:

11.0-1-075

Returns:

TRUE if Tecplot is in an interrupted state, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilInterruptCheck()

Python Syntax:

  Results = TecUtil.InterruptCheck()

  Output:
    Results[0]    ReturnVal            boolean

See also:

TecUtilInterrupt, TecUtilStatusCheckPercentDone

LgIndex_t TecUtilLimitGetValue

(

const char *

LimitString

)

Convenience function to query Tecplot for a limit value.

These are the same integer values you can set using the $!LIMITS command in the Tecplot macro language.

Since:

7.5-0-6

Parameters:

LimitString

This must be one of the following: MaxPtsInALine, MaxChrsInTextLabels, MaxNumContourLevels, IPCTimeoutSeconds, MaxAvailableProcessors, MaxUsableMemory, PreloadDataTimeThresholdInMS.

Returns:

Returns the limit value as an integer.

Fortran Syntax:

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

Python Syntax:

  Results = TecUtil.LimitGetValue(LimitString)

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

Get the number of points allowed per polyline in Tecplot:

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

See also:

TecUtilStyleGetLowLevelX

void TecUtilMemoryChangeNotify

(

Int64_t

ChangeInKBytes

)

Notify Tecplot when a significant change in memory occurs that is outside Tecplot's knowledge.

The additional information allows Tecplot to make better estimates about when to perform load-on-demand house keeping. The change in kilobytes is summed with Tecplot's overall memory statistics. Therefore, it is important that an add-on provide symmetric values. In other words, at the end of the add-on's life cycle, the sum of memory increases should equal the sum of memory decreases. This function is Thread Safe.

Since:

11.0-0-089

Parameters:

ChangeInKBytes

A value indicating the change in kilobytes. A positive value indicates an increased memory change while a negative value indicate a decreased memory change. A value of zero may also be passed indicating no change.

Notify Tecplot of a large change in memory.

   size_t BytesToAllocate = NumPoints * sizeof(MyStruct_s);
   MyStruct_s *MyArray = (MyStruct_s *)malloc(BytesToAllocate);
   if (MyArray != NULL)
     {
       Int64_t ChangeInKBytes = BytesToAllocate/1024
       TecUtilMemoryChangeNotify(ChangeInKBytes);

       ...do something useful with the array

       // cleanup
       free(MyArray);
       TecUtilMemoryChangeNotify(-ChangeInKBytes);
     }

See also:

TecUtilDataValueCustomLOD()

Python Syntax:

  Results = TecUtil.MemoryChangeNotify(ChangeInKBytes)

  Input:
                  ChangeInKBytes       long
  Output:
    Results[0]    ReturnVal            NONE

Boolean_t TecUtilOnIdleQueueAddCallback	(	OnIdleCallback_pf	Callback,
		ArbParam_t	ClientData
	)

Adds the function to a list of functions that Tecplot calls only one time when Tecplot is in an idle state.

This is particularly important for any add-on that needs to perform potentially disruptive Tecplot operations (such as modifying data) in response to a particular state change. FORTRAN addons can only register one on-idle callback at a time. All other addons can register multiple on-idle callbacks.

Parameters:

	Callback	Function to be called only one time when Tecplot becomes idle (and is not locked). After the call, the function is removed from the queue. No attempt is made to ensure that only one instance of Callback is registered for a given task. It is up to the add-on to keep track of registration (see the use of the PendingMyUpdateFuncOnIdle variable in the example illustrated below).
	ClientData	This can be any value and will be passed to the on-idle callback when the on idle callback is invoked. Typically this is a pointer to a structure needed by the callback function.

Returns:

TRUE if the callback was successfully added, FALSE otherwise.

Fortran Syntax:

 C
 C  Note: Only one on-idle callback function can active for each FORTRAN add-on.
 C  Registering another on-idle callback function overwrites the first.
 C  You may use ClientData to differentiate between different on-idle situations.
 C
    INTEGER*4 FUNCTION TecUtilOnIdleQueueAddCallback(
   &                   Callback,
   &                   ClientDataPtr)
    EXTERNAL           Callback
    POINTER            (ClientDataPtr, ClientData)

Python Syntax:

    This function is not supported in Python.

   // Make sure only one on-idle function is registered at a time.
   static Boolean_t PendingMyUpdateFuncOnIdle = FALSE;

   static void MyUpdateFuncOnIdle(ArbParam_t ClientData)
   {
     // ...do some potentially disruptive work in Tecplot

     // clear the flag so we can register another update if needed
     PendingMyUpdateFuncOnIdle = FALSE;
   }

   // A state change monitor usually used to update dialogs and
   // other add-on state when Tecplot (or another add-on) changes
   // the Tecplot's current state

   void MyStateChangeMonitor(StateChange_e StateChange,
                                     ArbParam_t    CallData)
   {
     if (StateChange == StateChange_VarsAltered)
       {
         // Addon needs to do something that is disruptive so we
         // need to register an on-idle callback to do the work
         // when Tecplot is idle.

         // if one is not already registered ...
         if (!PendingMyUpdateFuncOnIdle)
           {
             // keep track of our registration
             PendingMyUpdateFuncOnIdle = TRUE;
             // Queue the callback
             TecUtilOnIdleQueueAddCallback(MyUpdateFuncOnIdle,
                                           (ArbParam_t)MyData);
           }
       }
   }

Boolean_t TecUtilOnIdleQueueRemoveCallback	(	OnIdleCallback_pf	Callback,
		ArbParam_t	ClientData
	)

Remove the oldest registered callback/client data pair from the on-idle queue if it exists.

Parameters:

	Callback	Registered callback function.
	ClientData	Client data registered with the function.

Returns:

TRUE if the callback/client data pair was found and removed, FALSE if it wasn't found.

Python Syntax:

    This function is not supported in Python.

void TecUtilPleaseWait	(	const char *	WaitMessage,
		Boolean_t	DoWait
	)

Shows or hides the wait cursor and optionally displays a wait message.

This function can be used to display an hourglass cursor and optional message during non-cancellable procedures. (If you need a cancel button and/or progress indicator, then you must use TecUtilDialogLaunchPercentDone() and TecUtilDialogDropPercentDone() rather than this function.)

This function is Thread Safe.

Note:

Although this function can be called by multiple threads it is a no-op on all threads with the exception of the main user interface thread.

Parameters:

	WaitMessage	Status message to be shown. The previous status message will be restored when the status is popped. If WaitMessage is NULL then "Working..." is placed on the status line
	DoWait	Use TRUE at the start of a wait, FALSE at the end (calls must balance).

Precondition:

WaitMessage Pointer must be a valid address or NULL.

Fortran Syntax:

    SUBROUTINE TecUtilPleaseWait(
   &           WaitMessage,
   &           DoWait)
    CHARACTER*(*)   WaitMessage
    INTEGER*4       DoWait

Python Syntax:

  Results = TecUtil.PleaseWait(WaitMessage, DoWait)

  Input:
                  WaitMessage          string
                  DoWait               boolean
  Output:
    Results[0]    ReturnVal            NONE

Show a wait message for a lengthy operation:

   {
     TecUtilLockStart(AddOnID);
     TecUtilPleaseWait("Computing the first 1,000,000 digits of PI",TRUE);
     ComputePI(1000000); // This may take awhile on a slow machine
     TecUtilPleaseWait(NULL,FALSE); // Pop the wait cursor and
          // restore it to its previous state
     TecUtilDialogMessageBox("Finished computing PI",
                              MessageBoxType_Information);
     TecUtilLockFinish(AddOnID);
   }

void TecUtilPopMainProcessWindow

(

void

)

Pop Tecplot to the top of the Z-Order.

This is Windows only and may not be called when Tecplot is running in batch mode.

Fortran Syntax:

    SUBROUTINE TecUtilPopMainProcessWindow()

Python Syntax:

  Results = TecUtil.PopMainProcessWindow()

  Output:
    Results[0]    ReturnVal            NONE

See also:

TecUtilMacroIsBatchModeActive

Boolean_t TecUtilQueryCanPlotSlices

(

void

)

Determine if slices can be ploted.

This function is Thread Safe.

Since:

14.2

Returns:

Returns TRUE if slices be plotted , FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQueryCanPlotSlices()

Python Syntax:

  Results = TecUtil.QueryCanPlotSlices()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilQueryCanPlotStreamtraces

(

void

)

Determine if streamtraces can be ploted.

This function is Thread Safe.

Since:

14.2

Returns:

Returns TRUE if streamtraces can be plotted , FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQueryCanPlotStreamtraces()

Python Syntax:

  Results = TecUtil.QueryCanPlotStreamtraces()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilQueryCanPlotVolumeStreamtraces

(

void

)

Determine if volume streamtraces can be ploted.

This function is Thread Safe.

Since:

14.2

Returns:

Returns TRUE if volume streamtraces can be plotted , FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQueryCanPlotVolumeStreamtraces()

Python Syntax:

  Results = TecUtil.QueryCanPlotVolumeStreamtraces()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilQueryContourLevelModificationsAllowed

(

void

)

Determine if contour level modification are allowed.

This function is Thread Safe.

Since:

14.2

Returns:

Returns TRUE if contour level modification are allowed, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQueryContourLevelModificationsAllowed()

Python Syntax:

  Results = TecUtil.QueryContourLevelModificationsAllowed()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilQueryIsLayoutDirty

(

void

)

Determine if the dirty layout flag was activated

Since:

14.2

Returns:

Returns TRUE if the dirty flag was activated, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQueryIsLayoutDirty()

Python Syntax:

  Results = TecUtil.QueryIsLayoutDirty()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilQueryLayoutHasStyle

(

void

)

Determine if the current layout has any style, checking if there are pages or data ser defined, as well as a base text or base geom on a current frame

Since:

14.2

Returns:

Returns TRUE if the current layout has style, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQueryLayoutHasStyle()

Python Syntax:

  Results = TecUtil.QueryLayoutHasStyle()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilQueryOkToClearPickedObjects

(

void

)

Determine if there are picked objects to clear This function is Thread Safe.

Since:

14.2

Returns:

Returns TRUE if there are picked objects to clear, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQueryOkToClearPickedObjects()

Python Syntax:

  Results = TecUtil.QueryOkToClearPickedObjects()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilQueryOkToCopyPickedObjects

(

void

)

Determine if there are picked objects to copy This function is Thread Safe.

Since:

14.2

Returns:

Returns TRUE if there are picked objects to copy, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQueryOkToCopyPickedObjects()

Python Syntax:

  Results = TecUtil.QueryOkToCopyPickedObjects()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilQueryOkToExtractPoints

(

void

)

Determine if points can be extracted.

This function is Thread Safe.

Since:

14.2

Returns:

Returns TRUE if points can be extracted , FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQueryOkToExtractPoints()

Python Syntax:

  Results = TecUtil.QueryOkToExtractPoints()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilQueryOkToPastePickedObjects

(

void

)

Determine if there are picked objects to paste This function is Thread Safe.

Since:

14.2

Returns:

Returns TRUE if there are picked objects to paste, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQueryOkToPastePickedObjects()

Python Syntax:

  Results = TecUtil.QueryOkToPastePickedObjects()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilQueryOkToPushPopPickedObjects

(

void

)

Determine if there are picked objects to send to the back or bring to the front This function is Thread Safe.

Since:

14.2

Returns:

Returns TRUE if there are picked objects to send to the back or bring to the front, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQueryOkToPushPopPickedObjects()

Python Syntax:

  Results = TecUtil.QueryOkToPushPopPickedObjects()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilQueryPlotContainsContourLines

(

void

)

Determine if the plot contains contour lines.

This function is Thread Safe.

Since:

14.2

Returns:

Returns TRUE if plot contains contour lines , FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQueryPlotContainsContourLines()

Python Syntax:

  Results = TecUtil.QueryPlotContainsContourLines()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilQueryStreamtracesAreActive

(

void

)

Determine if there are active streamtraces.

This function is Thread Safe.

Since:

14.2

Returns:

Returns TRUE if there are active streamtraces , FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQueryStreamtracesAreActive()

Python Syntax:

  Results = TecUtil.QueryStreamtracesAreActive()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilQuit

(

void

)

Terminate the execution of the Tecplot program.

Note that program control returns to your application before quitting. Calling TecUtilQuit() merely sends a suggestion to Tecplot to quit. The only code that follows a call to TecUtilQuit() should be one or more calls to TecUtilLockFinish().

Returns:

Currently TRUE is always returned.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQuit()

Python Syntax:

  Results = TecUtil.Quit()

  Output:
    Results[0]    ReturnVal            boolean

Exit Tecplot:

   TecUtilLockStart(AddOnID);
   TecUtilQuit();
   TecUtilLockFinish(AddOnID);

Boolean_t TecUtilQuitAddQueryCallback

(

MopupQueryAddOnCallback_pf

QuitQueryCallback

)

Include a function in the list of functions to call when Tecplot is considering shutting down.

If you are building an add-on that could potentially be in a state where it is not convenient to shut down, then use this function. If the add-on does not wish for Tecplot to quit then the function referenced in this call can issue an error message to the user as to why this is the case and then return FALSE. A FALSE return value back to Tecplot will abort the shutdown sequence in Tecplot. TRUE return values by all MopupQuery functions will allow the shut down sequence to occur. The quit query callback is not to be used to do mopup operations such as closing of files and freeing of memory. Instead use TecUtilStateChangeAddCallback() to register a function that will listen for the message StateChange_QuitTecplot which is sent when Tecplot has begun its shutdown sequence.

Returns:

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

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilQuitAddQueryCallback(QuitQueryCallback)
    EXTERNAL QuitQueryCallback

Python Syntax:

    This function is not supported in Python.

void TecUtilSetupTransformations

(

void

)

Initializes transformation information so that coordinate conversion functions can be used.

This function must be called before any sequence of calls to TecUtilConvert3DPositionToGrid().

Fortran Syntax:

    SUBROUTINE TecUtilSetupTransformations()

Python Syntax:

  Results = TecUtil.SetupTransformations()

  Output:
    Results[0]    ReturnVal            NONE

Convert from 3-D world coordinates to Tecplot's 3-D grid coordinates.

   {
     double ZPlaneFloor;
     double X,Y,Z;

     TecUtilLockStart(AddOnID);
     TecUtilSetupTransformations();
     ZPlaneFloor = TecUtil3DViewGetNearZPlane();

     TecUtilConvert3DPositionToGrid(1.0,1.0,ZPlaneFloor,&X,&Y,&Z);

     TecUtilLockFinish(AddOnID);
   }

char* TecUtilStringAlloc	(	int	MaxLength,
		const char *	DebugInfo
	)

Allocate a character string.

Use TecUtilStringDealloc() to deallocate strings allocated using TecUtilStringAlloc(). This function is Thread Safe.

Parameters:

	MaxLength	The usable length of the string. The size must be greater than or equal to zero
	DebugInfo	Character string identifying the reason why the string is being allocated. This parameter is not yet enabled, but you still must supply a string

Returns:

Returns the address of the string or NULL if the memory cannot be allocated.

Python Syntax:

    This function is not supported in Python.

The following example will allocate a string for displaying an error message and then deallocate it.

   char *S;
   S = TecUtilStringAlloc(80,"error message string");
   sprintf(S, "The error occurred on step %d", IStep);
   TecUtilDialogErrMsg(S);
   TecUtilStringDealloc(&S);

char* TecUtilStringConvOldFormatting	(	const char *	OldString,
		Font_e	BaseFont
	)

Convert a text string using the old formatting syntax into the new formatting syntax.

Parameters:

	OldString	Character string containing old formatting syntax.
	BaseFont	Assumed base font used by the old string.

Returns:

Returns the converted character string. You must free this string when you are finished with it.

Precondition:

OldString String must have a valid address and non-zero length.

Fortran Syntax:

    SUBROUTINE TecUtilStringConvOldFormatting(
   &           OldString,
   &           BaseFont,
   &           Result,
   &           ResultLength)
    CHARACTER*(*)   OldString
    INTEGER*4       BaseFont
    CHARACTER*(*)   Result
    INTEGER*4       ResultLength

Python Syntax:

    This function is not supported in Python.

void TecUtilStringDealloc

(

char **

S

)

Free a string previously allocated with TecUtilStringAlloc(), or one that was allocated and returned as the result of calling any other TecUtilXxx function.

This function is Thread Safe.

Parameters:

S

Reference to a valid string handle. Use TecUtilStringAlloc() to create a string

Precondition:

S Pointer must be a valid address and non-NULL.

S Pointer must be a valid address or NULL.

Fortran Syntax:

    SUBROUTINE TecUtilStringDealloc(
   &           S,
   &           SLength)
    CHARACTER*(*)   S
    INTEGER*4       SLength

Python Syntax:

    This function is not supported in Python.

char* TecUtilStringFormatTimeDate	(	double	TimeDateValue,
		const char *	TimeDateFormat
	)

Formats the data value according to the specified time/date format.

Parameters:

	TimeDateValue	Time/date value to format.
	TimeDateFormat	Time/date format to apply to the value or NULL for the default.

Returns:

Allocated string containing the time/date value formatted using the specified formatting. The client is responsible for deallocating the result when it is no longer needed using TecUtilStringDealloc().

Fortran Syntax:

    SUBROUTINE TecUtilStringFormatTimeDate(
   &                TimeDateValue,
   &                TimeDateFormat,
   &                Result,
   &                ResultLength)
    REAL*8        TimeDateValue
    CHARACTER*(*) TimeDateFormat
    CHARACTER*(*) Result
    INTEGER*4     ResultLength

Python Syntax:

    This function is not supported in Python.

See also:

TecUtilStringFormatValue(), TecUtilAxisLabelGetNumberFormat(), TecUtilAxisLabelGetTimeDateFormat()

Since:

12.2.1.10292

char* TecUtilStringFormatValue	(	double	Value,
		NumberFormat_e	Format,
		SmInteger_t	Precision
	)

Formats the data value according to the specified format and precision.

Precision is only used for NumberFormat_FixedFloat, NumberFormat_SuperScript, and NumberFormat_Exponential. Please use TecUtilStringFormatTimeDate() for NumberFormat_TimeDate.

Parameters:

	Value	Value to format.
	Format	Number format to apply to the value.
	Precision	Precision to use when using NumberFormat_FixedFloat, NumberFormat_SuperScript, or NumberFormat_Exponential.

Returns:

Allocated string containing the value formatted using the specified formatting. The client is responsible for deallocating the result when it is no longer needed using TecUtilStringDealloc().

Fortran Syntax:

    SUBROUTINE TecUtilStringFormatValue(
   &                Value,
   &                Format,
   &                Precision,
   &                Result,
   &                ResultLength)
    REAL*8        Value
    INTEGER*4     Format,
    INTEGER*4     Precision,
    CHARACTER*(*) Result
    INTEGER*4     ResultLength

Python Syntax:

    This function is not supported in Python.

See also:

TecUtilStringFormatTimeDate(), TecUtilAxisLabelGetNumberFormat(), TecUtilAxisLabelGetPrecisionFormat()

Since:

12.2.1.10292

Boolean_t TecUtilSystem	(	const char *	Command,
		Boolean_t	Wait
	)

Instruct Tecplot to submit and execute an operating system specific command.

Parameters:

	Command	Operating system specific command to execute
	Wait	If TRUE then Tecplot will wait for the command to finish processing. If FALSE then the command is run concurrently in another process and Tecplot returns immediately

Returns:

On UNIX platforms, TRUE is returned if there is a shell to execute (such as /bin/ksh). On Windows platforms, TRUE is returned if the process is successfully created. Otherwise, FALSE.

Precondition:

Command String must have a valid address and non-zero length.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilSystem(
   &                   Command,
   &                   Wait)
    CHARACTER*(*)   Command
    INTEGER*4       Wait

Python Syntax:

  Results = TecUtil.System(Command, Wait)

  Input:
                  Command              string
                  Wait                 boolean
  Output:
    Results[0]    ReturnVal            boolean

Use the polygrid utility supplied with Tecplot to translate a PolyGrid file to a Tecplot ASCII input data file.

   TecUtilSystem("polygrid < sphere.pol > sphere.dat", TRUE);

char* TecUtilTecplotGetExePath

(

void

)

Get the full path name of the Tecplot executable.

Since:

11.0-2-005

Returns:

If successful, an allocated string is returned containing the full path name to the Tecplot executable, otherwise NULL if unsuccessful.

See also:

TecUtilGetBasePath, TecUtilAddOnGetPath, TecUtilTecplotGetHomeDirectory

Fortran Syntax:

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

Python Syntax:

  Results = TecUtil.TecplotGetExePath()

  Output:
    Results[0]    ReturnVal            string

Get the full path to the Tecplot executable.

   TecUtilLockStart(AddOnID);
   TecplotExePath = TecUtilTecplotGetExePath();
   .....
   TecUtilStringDealloc(&TecplotExePath);
   TecUtilLockFinish(AddOnID);

char* TecUtilTecplotGetHomeDirectory

(

void

)

Get the Tecplot home directory.

Returns:

The Tecplot home directory. This is specified by the TECxxxHOME environment variable, or the -h flag used when launching Tecplot from the command line.

Fortran Syntax:

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

Python Syntax:

  Results = TecUtil.TecplotGetHomeDirectory()

  Output:
    Results[0]    ReturnVal            string

Get the Tecplot home directory.

   char *TecHome = NULL;

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

LgIndex_t TecUtilTecplotGetMajorRevision

(

void

)

Gets Tecplot's major revision number.

Tecplot's version number has the form: "MajorVersion.MinorVersion-MajorRevision-MinorRevision". Each part can be obtained separately.

Since:

10.0-3-129

Returns:

Tecplot's major revision number.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecplotGetMajorRevision()

Python Syntax:

  Results = TecUtil.TecplotGetMajorRevision()

  Output:
    Results[0]    ReturnVal            int

See also:

TecUtilTecplotGetMajorVersion(), TecUtilTecplotGetMinorVersion(), TecUtilTecplotGetMinorRevision()

LgIndex_t TecUtilTecplotGetMajorVersion

(

void

)

Gets Tecplot's major version number.

Tecplot's version number has the form: "MajorVersion.MinorVersion-MajorRevision-MinorRevision". Each part can be obtained separately.

Since:

10.0-3-129

Returns:

Tecplot's major version number.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecplotGetMajorVersion()

Python Syntax:

  Results = TecUtil.TecplotGetMajorVersion()

  Output:
    Results[0]    ReturnVal            int

See also:

TecUtilTecplotGetMinorVersion(), TecUtilTecplotGetMajorRevision(), TecUtilTecplotGetMinorRevision()

LgIndex_t TecUtilTecplotGetMinorRevision

(

void

)

Gets Tecplot's minor revision number.

Tecplot's version number has the form: "MajorVersion.MinorVersion-MajorRevision-MinorRevision". Each part can be obtained separately.

Since:

10.0-3-129

Returns:

Tecplot's minor revision number.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecplotGetMinorRevision()

Python Syntax:

  Results = TecUtil.TecplotGetMinorRevision()

  Output:
    Results[0]    ReturnVal            int

See also:

TecUtilTecplotGetMajorVersion(), TecUtilTecplotGetMinorVersion(), TecUtilTecplotGetMajorRevision()

LgIndex_t TecUtilTecplotGetMinorVersion

(

void

)

Gets Tecplot's minor version number.

Tecplot's version number has the form: "MajorVersion.MinorVersion-MajorRevision-MinorRevision". Each part can be obtained separately.

Since:

10.0-3-129

Returns:

Tecplot's minor version number.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecplotGetMinorVersion()

Python Syntax:

  Results = TecUtil.TecplotGetMinorVersion()

  Output:
    Results[0]    ReturnVal            int

See also:

TecUtilTecplotGetMajorVersion(), TecUtilTecplotGetMajorRevision(), TecUtilTecplotGetMinorRevision()

int TecUtilThreadPoolGetNumConcurrentJobs

(

void

)

Returns the number of jobs that can concurrently run within the thread pool.

This function is Thread Safe.

Since:

11.3-0-018

See also:

TecUtilThreadPoolAddJob(), TecUtilThreadPoolJobControlAlloc(), TecUtilThreadPoolPoolSize(), TecUtilThreadPoolJobThreadOffset()

Fortran Syntax:

   This function is not available for FORTRAN.

Python Syntax:

  Results = TecUtil.ThreadPoolGetNumConcurrentJobs()

  Output:
    Results[0]    ReturnVal            int

int TecUtilThreadPoolJobThreadOffset

(

void

)

Returns this worker thread's unique offset.

Worker threads in this thread's pool are sequentially assigned unique, one based numbers between 0 and the value of TecUtilThreadPoolPoolSize(). This thread offset can be used as an indirection into some random access storage dimensioned by the thread's thread pool value of TecUtilThreadPoolPoolSize().

IMPORTANT NOTE:

Only threads that have been created by Tecplot's thread pool may call this function.

Returns:

Zero based offset representing the unique thread offset.

Fortran Syntax:

   This function is not available for FORTRAN.

Python Syntax:

  Results = TecUtil.ThreadPoolJobThreadOffset()

  Output:
    Results[0]    ReturnVal            int

Since:

13.2.0.19661

int TecUtilThreadPoolPoolSize

(

void

)

Returns the number of worker threads assigned to this thread pool.

Returns:

Number of worker threads assigned to this pool.

Fortran Syntax:

   This function is not available for FORTRAN.

Python Syntax:

  Results = TecUtil.ThreadPoolPoolSize()

  Output:
    Results[0]    ReturnVal            int

Since:

13.2.0.19661

Boolean_t TecUtilTimerAddCallback	(	UInt32_t	Interval,
		ArbParam_t	ClientData,
		AddOnTimerCallback_pf	TimerCallback
	)

Adds a timer callback, a function which is called by Tecplot at a set interval of time.

Note:

In your timer callback you must check to see if Tecplot is locked before calling any TecUtil functions, as illustrated in the source code example.

Parameters:

	Interval	Timeout interval in milliseconds.
	ClientData	This can be any 32-bit value and will be passed to the timer callback. Typically this is a pointer to a structure
	TimerCallback	Function to be called at each timeout interval. This function should return TRUE to continue the timer, or FALSE to stop it.

Returns:

TRUE if the callback was successfully added, FALSE otherwise. This function returns FALSE only if Tecplot is unable to obtain a timer from the operating system.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTimerAddCallback(
   &                   Interval,
   &                   ClientDataPtr,
   &                   TimerCallback)
    INTEGER*4          Interval
    POINTER            (ClientDataPtr, ClientData)
    EXTERNAL           TimerCallback

Python Syntax:

    This function is not supported in Python.

Set up a timer with an interval of one second.

   static Boolean_t MyTimerCallback(ArbParam_t MyData)
   {
     if (!TecUtilLockIsOn())
       {
         // Tecplot isn't currently locked, so it's safe to call TecUtil functions
         TecUtilLockStart(AddOnID); // Lock Tecplot for ourselves

         // ... Do processing with TecUtil functions

         // Release Tecplot for other addons
         TecUtilLockFinish(AddOnID);
       }
     else
       {
         // Another add-on has locked Tecplot. It is NOT safe to
         // call any TecUtil functions, so do nothing.
       }

     // Return TRUE to continue the timer, return FALSE to stop the timer.
     return TRUE;
   }
   // Make the above function called every second.
   TecUtilTimerAddCallback(1000,NULL,MyTimerCallback);

Note:

For a complete example of an add-on which uses timers, see the timetest sample add-on.

See also:

TecUtilOnIdleQueueAddCallback()

void TecUtilWindowsAssertionFailed	(	const char *	expr,
		const char *	file,
		int	line
	)

Private: Used by Windows add-ons in checked builds to display an assertion error and copy the assertion to the Windows clipboard.

NEVER call this function directly from an add-on.

Precondition:

VALID_REF(expr) Pointer must be a valid address and non-NULL.

VALID_REF(file) Pointer must be a valid address and non-NULL.

Since:

11.2-0-054

Python Syntax:

    This function is not supported in Python.