HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
UT_Interrupt Class Reference

#include <UT_Interrupt.h>

+ Inheritance diagram for UT_Interrupt:

Public Types

enum  Priority { PRIORITY_TRANSIENT = 0, PRIORITY_NODE = 1, PRIORITY_PERMANENT = 2 }
 

Public Member Functions

 UT_Interrupt (const char *app_title=0)
 
virtual ~UT_Interrupt ()
 
void setEnabled (int state, int print_longtext=0)
 
bool isEnabled () const
 
void setUseLocks (int state)
 
bool setInterruptable (bool allow, bool *prev_enabled=NULL, bool allow_ui=false)
 
bool getInterruptable () const
 
UT_LockgetInterruptableLock ()
 
bool getAllowUI () const
 
void clearStickyInterrupts ()
 
bool stickyInterrupts () const
 
void setStickyInterrupts ()
 
int getOpDepth () const
 
void setAppTitle (const char *title)
 
UT_StringHolder getAppTitle () const
 
void setActiveCallback (UT_InterruptCB function)
 
void setInterruptHandler (UT_InterruptHandler *hand)
 
UT_InterruptHandlergetInterruptHandler ()
 
void pushInterruptCallback (void(*callback)())
 
void popInterruptCallback ()
 
void interrupt (int use_semaphore=0)
 
void pause (bool dopause)
 
bool isPaused () const
 
void setSignalCallback (UTsigHandler function)
 
bool testMemoryThreshold ()
 
int opStart (const char *opname=0, int npoll=0, int immediate_dialog=0, int *opid=0)
 
int opStartPriority (int priority, const char *opname=0, int npoll=0, int immediate_dialog=0, int *opid=0)
 
int opStartMessage (int priority, const UT_InterruptMessage &msg, int immediate_dialog=0, int *opid=0)
 
int opInterrupt (int percent=-1)
 
void opEnd (int opid=-1)
 
void setLongOpText (const UT_StringHolder &longoptext)
 
void setLongPercent (float percent)
 

Static Public Member Functions

static void setUpdateModeCallback (OPUI_UpdateModeCB function)
 
static void setEscapeCheckCallback (UI_CheckForEscapeCB function)
 
static bool getIsEscapeCheckCallbackSet ()
 

Protected Member Functions

const char * getSharedKey () const
 
virtual int detach ()
 
- Protected Member Functions inherited from UT_SharedMem
 UT_SharedMem (const char *keypath=0, int size=0, int keyid=0)
 
 UT_SharedMem (key_t key, int size)
 
 UT_SharedMem (int size)
 
virtual ~UT_SharedMem ()
 
int setKey (const char *path, int id=0)
 
int setKey (key_t key)
 
int setSize (int size)
 
virtual int destroy ()
 
virtual voidgetMemory (int reuse=1)
 

Additional Inherited Members

- Protected Attributes inherited from UT_SharedMem
UT_String ourKeyPath
 
int ourKeyId
 

Detailed Description

Member Enumeration Documentation

When interrupts nest, it is not always useful to display the entire stack of interrupts. Priority is used to control if the interrupt should be shown. 1) All PERMANENT messages are shown. 2) Only the topmost NODE is shown, provided it isn't shadowed by a PERMANENT. 3) Only the topmost TRANSIENT is shown, provided it isn't shadowed by a PERMANENT or NODE. Node cooking in Houdini uses the NODE level, so for most ad-hoc interrupt messages the TRANSIENT level is best.

Enumerator
PRIORITY_TRANSIENT 
PRIORITY_NODE 
PRIORITY_PERMANENT 

Definition at line 147 of file UT_Interrupt.h.

Constructor & Destructor Documentation

UT_Interrupt::UT_Interrupt ( const char *  app_title = 0)
explicit
virtual UT_Interrupt::~UT_Interrupt ( )
virtual

Member Function Documentation

void UT_Interrupt::clearStickyInterrupts ( )
virtual int UT_Interrupt::detach ( )
protectedvirtual

Reimplemented from UT_SharedMem.

bool UT_Interrupt::getAllowUI ( ) const
inline

Definition at line 180 of file UT_Interrupt.h.

UT_StringHolder UT_Interrupt::getAppTitle ( ) const
inline

Definition at line 245 of file UT_Interrupt.h.

bool UT_Interrupt::getInterruptable ( ) const
inline

Definition at line 178 of file UT_Interrupt.h.

UT_Lock& UT_Interrupt::getInterruptableLock ( )
inline

Definition at line 179 of file UT_Interrupt.h.

UT_InterruptHandler* UT_Interrupt::getInterruptHandler ( )
inline

Definition at line 259 of file UT_Interrupt.h.

static bool UT_Interrupt::getIsEscapeCheckCallbackSet ( )
inlinestatic

Definition at line 270 of file UT_Interrupt.h.

int UT_Interrupt::getOpDepth ( ) const
inline

Definition at line 193 of file UT_Interrupt.h.

const char* UT_Interrupt::getSharedKey ( ) const
protected
void UT_Interrupt::interrupt ( int  use_semaphore = 0)
bool UT_Interrupt::isEnabled ( ) const
inline

Definition at line 161 of file UT_Interrupt.h.

bool UT_Interrupt::isPaused ( ) const
void UT_Interrupt::opEnd ( int  opid = -1)

To use the long operation mechanism invoke "opStart" once, giving the name of the operation and (if possible) an estimate of the number of calls which are planned to be made to the opInterrupt method. The start method will return zero if the operation has already been terminated (possibly from a containing long operation) and should not even start. In that case, you must still call opEnd(). It will return one if the operation can proceed normally.

During the long operation, invoke the "opInterrupt" method (if possible, giving a value between 0 and 100 indicating the percentage of the operation that is complete). This method will return zero if the operation should continue and one if a request was made to terminate. When the operation is complete, invoke the "opEnd" method. This should be called even if the operation was interrupted.

The 'immediate_dialog' flag causes the idialog program to be started immediately instead of waiting for a timeout. This is the only way to start the idialog progress monitor, and should only be used for very long operations where the user would minimize Houdini (like rendering)

The opid can be used to verify nesting of interrupts. It can be passed to opEnd to verify that the nesting is proper...

These methods are now thread safe. Only the main thread will start the interrupt server.

Examples:
CHOP/CHOP_Blend.C, and CHOP/CHOP_Spring.C.
int UT_Interrupt::opInterrupt ( int  percent = -1)

To use the long operation mechanism invoke "opStart" once, giving the name of the operation and (if possible) an estimate of the number of calls which are planned to be made to the opInterrupt method. The start method will return zero if the operation has already been terminated (possibly from a containing long operation) and should not even start. In that case, you must still call opEnd(). It will return one if the operation can proceed normally.

During the long operation, invoke the "opInterrupt" method (if possible, giving a value between 0 and 100 indicating the percentage of the operation that is complete). This method will return zero if the operation should continue and one if a request was made to terminate. When the operation is complete, invoke the "opEnd" method. This should be called even if the operation was interrupted.

The 'immediate_dialog' flag causes the idialog program to be started immediately instead of waiting for a timeout. This is the only way to start the idialog progress monitor, and should only be used for very long operations where the user would minimize Houdini (like rendering)

The opid can be used to verify nesting of interrupts. It can be passed to opEnd to verify that the nesting is proper...

These methods are now thread safe. Only the main thread will start the interrupt server.

Examples:
CHOP/CHOP_Blend.C, CHOP/CHOP_Spring.C, SIM/SIM_GasAdd.C, and tetprim/GEO_PrimTetra.h.
int UT_Interrupt::opStart ( const char *  opname = 0,
int  npoll = 0,
int  immediate_dialog = 0,
int opid = 0 
)

To use the long operation mechanism invoke "opStart" once, giving the name of the operation and (if possible) an estimate of the number of calls which are planned to be made to the opInterrupt method. The start method will return zero if the operation has already been terminated (possibly from a containing long operation) and should not even start. In that case, you must still call opEnd(). It will return one if the operation can proceed normally.

During the long operation, invoke the "opInterrupt" method (if possible, giving a value between 0 and 100 indicating the percentage of the operation that is complete). This method will return zero if the operation should continue and one if a request was made to terminate. When the operation is complete, invoke the "opEnd" method. This should be called even if the operation was interrupted.

The 'immediate_dialog' flag causes the idialog program to be started immediately instead of waiting for a timeout. This is the only way to start the idialog progress monitor, and should only be used for very long operations where the user would minimize Houdini (like rendering)

The opid can be used to verify nesting of interrupts. It can be passed to opEnd to verify that the nesting is proper...

These methods are now thread safe. Only the main thread will start the interrupt server.

Examples:
CHOP/CHOP_Blend.C, and CHOP/CHOP_Spring.C.
int UT_Interrupt::opStartMessage ( int  priority,
const UT_InterruptMessage msg,
int  immediate_dialog = 0,
int opid = 0 
)

To use the long operation mechanism invoke "opStart" once, giving the name of the operation and (if possible) an estimate of the number of calls which are planned to be made to the opInterrupt method. The start method will return zero if the operation has already been terminated (possibly from a containing long operation) and should not even start. In that case, you must still call opEnd(). It will return one if the operation can proceed normally.

During the long operation, invoke the "opInterrupt" method (if possible, giving a value between 0 and 100 indicating the percentage of the operation that is complete). This method will return zero if the operation should continue and one if a request was made to terminate. When the operation is complete, invoke the "opEnd" method. This should be called even if the operation was interrupted.

The 'immediate_dialog' flag causes the idialog program to be started immediately instead of waiting for a timeout. This is the only way to start the idialog progress monitor, and should only be used for very long operations where the user would minimize Houdini (like rendering)

The opid can be used to verify nesting of interrupts. It can be passed to opEnd to verify that the nesting is proper...

These methods are now thread safe. Only the main thread will start the interrupt server.

int UT_Interrupt::opStartPriority ( int  priority,
const char *  opname = 0,
int  npoll = 0,
int  immediate_dialog = 0,
int opid = 0 
)

To use the long operation mechanism invoke "opStart" once, giving the name of the operation and (if possible) an estimate of the number of calls which are planned to be made to the opInterrupt method. The start method will return zero if the operation has already been terminated (possibly from a containing long operation) and should not even start. In that case, you must still call opEnd(). It will return one if the operation can proceed normally.

During the long operation, invoke the "opInterrupt" method (if possible, giving a value between 0 and 100 indicating the percentage of the operation that is complete). This method will return zero if the operation should continue and one if a request was made to terminate. When the operation is complete, invoke the "opEnd" method. This should be called even if the operation was interrupted.

The 'immediate_dialog' flag causes the idialog program to be started immediately instead of waiting for a timeout. This is the only way to start the idialog progress monitor, and should only be used for very long operations where the user would minimize Houdini (like rendering)

The opid can be used to verify nesting of interrupts. It can be passed to opEnd to verify that the nesting is proper...

These methods are now thread safe. Only the main thread will start the interrupt server.

void UT_Interrupt::pause ( bool  dopause)
void UT_Interrupt::popInterruptCallback ( )
void UT_Interrupt::pushInterruptCallback ( void(*)()  callback)
void UT_Interrupt::setActiveCallback ( UT_InterruptCB  function)
inline

Definition at line 250 of file UT_Interrupt.h.

void UT_Interrupt::setAppTitle ( const char *  title)
void UT_Interrupt::setEnabled ( int  state,
int  print_longtext = 0 
)
static void UT_Interrupt::setEscapeCheckCallback ( UI_CheckForEscapeCB  function)
inlinestatic

Definition at line 268 of file UT_Interrupt.h.

bool UT_Interrupt::setInterruptable ( bool  allow,
bool *  prev_enabled = NULL,
bool  allow_ui = false 
)
void UT_Interrupt::setInterruptHandler ( UT_InterruptHandler hand)
inline

Definition at line 253 of file UT_Interrupt.h.

void UT_Interrupt::setLongOpText ( const UT_StringHolder longoptext)

Call this before a new set of opStart()s are called. It will also cause idialog to configure the user interface with two text boxes instead of the usual single line. After that, you can call setLongOpText() to modify the second line message.

void UT_Interrupt::setLongPercent ( float  percent)

Call this before a new set of opStart()s are called. It will also cause idialog to configure the user interface with two text boxes instead of the usual single line. After that, you can call setLongOpText() to modify the second line message.

void UT_Interrupt::setSignalCallback ( UTsigHandler  function)
void UT_Interrupt::setStickyInterrupts ( )
static void UT_Interrupt::setUpdateModeCallback ( OPUI_UpdateModeCB  function)
inlinestatic

Definition at line 263 of file UT_Interrupt.h.

void UT_Interrupt::setUseLocks ( int  state)
inline

Definition at line 165 of file UT_Interrupt.h.

bool UT_Interrupt::stickyInterrupts ( ) const
inline

Definition at line 190 of file UT_Interrupt.h.

bool UT_Interrupt::testMemoryThreshold ( )
inline

Definition at line 297 of file UT_Interrupt.h.


The documentation for this class was generated from the following file: