Key to interacting with EnSight from within
Python is the ensight module.
This module is pre-loaded into the environment and provides a number of methods that can
be used to communicate directly with EnSight. There are a large number of examples that
use this interface included in the user-defined EnSight extensions. These can be found
in the
$CEI/ensight242/site_preferences/extensions/user_defined
directory tree.
Interpreter Startup
When the EnSight Python interpreter is initialized it performs the following operations:
Set up PYTHON_HOME/PATH.
Create the
ensightmodule.Create the
cmdlanguagemethods in theensightmodule for the native API.Import the
sys,sipandimpmodules.Import the
PyQt4.Guimodule.Add $CEI/ensight242/site_preferences/extensions to
sys.path.If it exists, add the EnSight Defaults Directory path plus the extensions subdirectory to
sys.path. The EnSight Defaults Directory path is %HOMEDRIVE%%HOMEPATH%\(username)\.ensight242 commonly C:\Users\username\.ensight242 Win10, ~/.ensight242 on Linux, and ~/Library/Application Support/ensight242 on the Mac.Import the
ensight.coremodule. This has the side effect of adding the names specified by theCEI_PYTHONPATHenvironmental variable (: separated under Unix and ; separated under Windows) tosys.path.Execute
ensight.core.load_extensions(). This walks the extension tree, loads any user defined extensions and reads in any Qt4 language files (*.qm) it finds.
EnSight Module Methods
|
|||
This method executes one or more command language commands. The function can be passed a single string or a tuple of strings. In the latter case, all the strings in the tuple will be executed. For example:
This method returns a
If the exception keyword is set to If the version keyword is set, the version of the command language will
be set to that version for the duration of this single command. The default
is to use the version set by Explicitly setting any keywords will override the defaults set by the
Note: You can send the commands that open a part of the current EnSight graphical user interface with this method. See GUI raw commands |
|||
|
|||
This method allows the caller to set the default values for the
will result in the shell: command being both logged and printed. The
commands:
By default, |
|||
|
|||
|
This method will query EnSight command language variable values and
returns a tuple containing the value, its type and the scope it was found in
(similar to the command language The TYPE of the variable will be 0 if the value is an integer, 1 if the value is a float and 2 if the value is a string. The SCOPE is an integer that specifies where the variable was found. -2: the variable is in the enscl namespace (for example,
-1: the variable is an EnSight constant variable (file, case or computed variable). 0: the variable is global in the command language interpreter (for example,
+1: the variable is local in the command language interpreter and the number is the depth in the interpreter stack where the value is defined. |
||
|
|||
|
This method causes the command language file (.enc)
specified by |
||
|
|||
|
This method is useful on X11 platforms and harmless under Windows. It causes any PyQt widgets one might create in the EnSight Python interpreter to properly layer with the EnSight windows (keeping them above the main EnSight window). Note: Calling this function with the wrong argument type can cause EnSight to crash. |
||
|
|||
|
This method allows the caller to query various attributes in EnSight. The
returned value is always a list that starts with an error code. The list
will include one or more returned values (specific to the
Valid
ensight.QUERY_PROBE_DATA
Note: An * means the
|
||
† The |
|||
The following query |
|||
|
|||
Returns the number of textures EnSight supports. |
|||
|
|||
|
|||
Returns the texture selected by param1 as an EnVe image object (see the EnVe module description of the image object). |
|||
|
|||
Returns the texture border color [R,G,B,A] selected by param1. |
|||
|
|||
Returns the current palette for the variable index (see |
|||
|
|||
Returns the current EnSight command language version number being used. The value is returned as a string. |
|||
|
|||
Returns the min, max and current histogram for the variable index (see
|
|||
|
|||
|
For the query selected by param1 (see
Example 8.1: ensight.QUERY_DATA * num_queries = ensight.query(ensight.QUERY_COUNT)
print("The number of queries is {}".format(num_queries[1])
for query_num in range(num_queries[1][0]):
query_vals = ensight.query(ensight.QUERY_DATA,query_num)
print("query vals, query num {} = {}".format(query_num, query_vals)) |
|||
|
|||
Returns the current interactive probe query values. The output is a list, one item per query value. Each item is a list of the form:
The first item in the output list contains text headers for all the columns.
The Note: Example for a simple query with two probes and two variables: print(ensight.query(ensight.QUERY_PROBE_DATA))
[
[[‘temperature’, ‘velocity’], [‘X’,’Y’,’Z’], [‘I’,’J’,’K’], ‘ID’,
‘Type’],
[[0.9, 0.9], [1.5, -2.0, 0.9], [None, None, None], None, ‘Surface
Pick’],
[[0.9, 0.9], [-0.8, -2.0, 0.9], [None, None, None], None, ‘Surface
Pick’]
] |
|||
|
|||
|
Returns information about the current dataset. The output
may be
The FILEDATA list describes the various files opened (as specified by the actual reader). The information includes the filename, its size, its date and any number of description strings. The list has the form: [[filename,file_size,file_date,["desc1","desc2",...]]
The
|
|||
|
|||
This query returns a dictionary of the current EnSight timeline. The dictionary keys include:
|
|||
|
|||
This query returns zero if EnSight is not in fullscreen mode or non-zero if it is in fullscreen mode. |
|||
|
|||
This query returns a string that is the directory name where EnSight is reading and writing preference data to. |
|||
|
|||
These four queries return the current value of the
|
|||
|
|||
This query returns a dictionary of OpenGL related information. The dictionary keys include (on most platforms):
|
|||
|
|||
This query returns a dictionary of system resource related information. The dictionary keys include (on most platforms):
|
|||
|
|||
This query returns a dictionary of system resource related information. The dictionary keys include (on most platforms):
|
|||
|
|||
This query returns a unique integer number every time it is called. This can
be useful with things like obtaining a unique, private
filter flag for the |
|||
|
|||
This query returns the number of splines currently defined. The value is
returned as with the command driver queries: |
|||
|
|||
This query returns the actual raw splince coordinates for a given spline number. For example:
returns the control points for spline number 1. The spline data itself has the following form:
|
|||
|
|||
Allows the user to query the current setting for the various EnSight data tools. The |
|||
|
Value is three floats: [x,y,z] the point |
||
|
Value is six floats: [x0,y0,z0,x1,y1,z1] two points |
||
|
Value is twelve floats: [x0,y0,z0,x1,y1,z1,x2, y2,z2,x3,y3,z3] four points (must be rectangular and co-planar) |
||
|
Value is fifteen floats: [ox,oy,oz,xx,xy,xz,yx,yy, yz,zx,zy,zz,sx,sy,sz] an origin point, three normal vectors (must be orthogonal) for the axis and three length values |
||
|
Value is seven floats: [x0,y0,z0,x1,y1,z1,rad] two points at the ends of the cylinder and the radius |
||
|
Value is six floats: [x0,y0,z0,x1,y1,z1] two points that define the diameter (and major axis) of the sphere. |
||
|
Value is seven floats: [x0,y0,z0,x1,y1,z1, cone_ang] two points at the ends of the cone and the angle at the apex. |
||
|
Value is six + 2*N floats: [x0,y0,z0,x1.y1. z1,d0,r0,d1,r1,...] two point, one at the end and the other that defines the axis followed by a variable number of distance, radius pairs that define the profile |
||
|
|||
This method is used to set various EnSight global parameters. The valid values for |
|||
|
|||
In this case, value should be a tuple of the form ( |
|||
|
|||
In this case, value should be a tuple of the form
( |
|||
|
|||
In this case, value should be a tuple of the form ( |
|||
|
|||
This method queues up an EnSight redraw for the next idle redraw of its
graphics displays. Use the following to force the redraw immediately: |
|||
|
|||
This method causes EnSight to render the current image to one or more
EnVe image objects. The return value is either a single EnVe image
object by default. If the stereo keyword is set to 1, the return value will
be a list of two image objects. The first is the left eye view and the
second the right eye view. By default, the output image(s) will be the size
of the current EnSight rendering window. The |
|||
|
|||
This function is a basic variable and mesh query mechanism. It takes a list of points as input. The list is a Python list of 3 value python lists. An example would be: [ [1,2,0], [2,4,2] ] for two points. The function will perform a query at each point in the list. The The The The return value is a list of output lists. One list for each input point. If no variables are specified, the query will be about the mesh structure and the list for each point will appear as:
The values are the part number the point was found in, a flag that is non-zero if the part is structured, the node id of the node closest to the point and the element id of the element that contains the point. If a list of variables is specified, the returned value will be a list of lists, one for each variable. If the input variables were "pressure" and "velocity" (a scalar and a vector), the output (per point) would be:
|
|||
|
|||
This function is a basic variable and mesh query mechanism. It takes a list of node ids as input. An example would be: [500, 323] for two nodes. The function will perform a query at each node in the list. Important: Each of these nodal queries makes a round trip from the client to the server, one at a time. This is not intended to be used to query large numbers of nodes and will be extremely slow for large numbers of nodes. Use EnSight python for controlling EnSight, not for replacing the EnSight server. The The The "time" keyword variable is optional. If not present, the query will be for the current time value in EnSight. The caller can also specify a specific time value using this keyword. The return value is a list of output lists. One list for each input node. If no variables are specified, the query will be about the mesh structure and the list for each node will appear as:
The values are the part number the node was found in, a flag that is non-zero if the part is structured, the coordinates of the node and a list of elements that reference that node. If a list of variables is specified, the returned value
will be a list of lists, one for each variable. If the input variables were
|
|||
|
|||
This function is a basic variable and mesh query mechanism. It takes a list of element ids as input. An example would be: [232, 4733] for two elements. The function will perform a query at each element in the list. The The The The return value is a list of output lists. One list for each input element. If no variables are specified, the query will be about the mesh structure and the list for each element will appear as:
The values are the part number the element was found in,
a flag that is non-zero if the part is structured, the type of the element,
a flag that is non-zero if the element is currently If a list of variables is specified, the returned value
will be a list of lists, one for each variable. If the input variables were
|
|||
|
|||
This function allows the user to directly query the points that make up
particle traces. The output is similar to the output generated by the
The The Note: In order to get a valid return for a given variable, it must be active, and have been activated prior to the creation of the trace. The return value is a list of output lists. One list for each input part. The list for each part will contain one list for every trace in the part. If no variables are specified, the list for each trace will contain information about the temporal and spatial location of each point on the trace in the form:
The time value t is the resident time for the trace. If a list of variables is specified, the returned value
will be a list per part of lists per trace of lists, one for each variable.
If the input variables were
Example 8.2: In the Case of Two Parts, Each with 3 Traces of 4 Points Each and the Variable Keyword Specifying a Vector and a Scalar Variable, the Full Output Would Be
|
|||
|
|||
This method returns basic information about parts as a
Python list. The The The return value is a list of output lists, one list for each selected part. The list for each part can have one of three structures, depending on the setting of the client keyword and the presence of the variables keyword. If the variables keyword is present, the return value is a list of lists, one per parts. Each list has the following structure:
The vlist list has one value for each variable being queried. The value is 1 if the variable exists, is active and has some defined values for the given part. The value is -1 if the variable not active or not defined for the given part. The value -2 is returned if the part does not contain the variable or the variable is not defined on the part, or the part has no nodes/elements at the current timestep. The value -3 can be returned if the part is a client part (vector arrows, contour lines, etc) which never has variables defined on it. Other values are returned for invalid input parameters. By default, the client keyword is 0 and results in a
server query, much like the Query →
Show Information → Part menu
selection. Client side parts (for example, groups, pathlines, vector
arrows) will not be included in this output. If the client keyword is set to
the value In the server query case (client=0), the list for each part has the following structure:
In the client query case (client=1), the list for each part has the following structure:
In both cases, the named fields are defined as:
x0,y0,z0 = the part minimum x,y,z coords
|
|||
|
|||
This method returns basic information about the current EnSight cases as a Python list. The returned list has the following format:
The first item is the current case number (zero based). There will be one subsequent item for each current case. Each of those items is a list containing the number for that case and its name. |
|||
|
|||
This function creates a new xy query in EnSight. It is similar to reading a
query from an external file, except the data is passed from
Python.
That is a list of two element lists which contain two
float values each that are interpreted as an X,Y point in space. By default,
the data is plotted as a connected line. The optional
|
|||
|
|||
This method returns |
|||
|
|||
| Returns information about EnSight | |||
Prior to version 2019 R1, the
standard way of using this function was to call
element argument is specified, the
function returns a list containing 10 items:
The contents of the If the license manager is Ansys, the user and license dictionary will contain the following items:
If the license manager is SLiM or FSI, the
An example of such a list is:
If a
string is passed as the
If an |
|||
|
|||
In the EnSight Python editor, there is an
option to set an |
|||
|
|||
This method returns a non-zero integer if the EnSight client is running in batch mode. |
|||
|
|||
This method causes EnSight to shut down the current EnSight session. |
|||
The Python Native Command Language Interface
As described in the previous section, the
ensight.sendmesg() function can be used to execute command
language from Python. The command language takes the form of
a Python string or list of strings. There exists a collection
of modules that implement a more natural Python
(native) interface to the command language. These modules
follow the form of the EnSight command language syntax. All command language commands
have the fundamental form:
category: command <args>
For example:
view_transf: rotate 9.657229e+000 2.282249e+001
0.000000e+000
has a category of 'view_transf', a command
of rotate and arguments of 9.657229e+000 2.282249e+001 0.000000e+000. The
native command language interface maps the category and command names to modules under
the 'ensight' module. For example, the above command is equivalent to the following line
of Python code:
ensight.view_transf.rotate('9.657229e+000 2.282249e+001
0.000000e+000')
Additionally, the native interface will try to map data types to
<args> strings. So the following lines of
Python code are all equivalent:
ensight.view_transf.rotate(9.657229e+000,2.282249e+001,0.000000e+000)
ensight.view_transf.rotate([9.657229,2.282249e+01,0])
a=[9.657229,2.282249e+01,0]
ensight.view_transf.rotate(a)
The use of Python native variables makes this interface much more flexible for complex scripting.
The native interface handles the
select_begin/select_end
commands very differently. The command language includes structures like:
part: select_begin
1 2 3 4 5 6 7 8
part: select_end
part: select_byname_begin
(CASE:Case 1)Block ID 7 - HEX" "(CASE:Case 1)Block ID 8 -
HEX
(CASE:Case 1)Block ID 9 - HEX" "(CASE:Case 1)Block ID 10
- HEX
(CASE:Case 1)Block ID 11 - HEX" "(CASE:Case 1)Block ID 1
- HEX
part: select_byname_end
The native Python interface is aware of
the list nature of the
select_begin/select_end
commands and maps them to a single command (the select_begin).
The above lines translate to two lines of Python:
ensight.part.select_begin(1,2,3,4,5,6,7,8)
ensight.part.select_byname_begin("(CASE:Case 1)Block ID 7
- HEX","(CASE:Case 1)Block ID 8 - HEX","(CASE:Case 1)Block ID 9 - HEX","(CASE:Case
1)Block ID 10 - HEX","(CASE:Case 1)Block ID 11 - HEX","(CASE:Case 1)Block ID 1 -
HEX")
The *_end functions are not necessary.
Additionally, a list-based syntax is also supported, so the following three lines are
also equivalent:
ensight.part.select_begin([1,2,3,4,5,6,7,8])
list = ["(CASE:Case 1)Block ID 7 -
HEX",
"(CASE:Case 1)Block ID 8 - HEX",
"(CASE:Case 1)Block ID 9 - HEX",
"(CASE:Case 1)Block ID 10 - HEX",
"(CASE:Case 1)Block ID 11 - HEX",
"(CASE:Case 1)Block ID 1 - HEX"]
ensight.part.select_byname_begin(list)
In all cases where the command language uses a
*_begin/*_end
syntax with a collection of items (numerical or strings), a
Python command structure similar to the above may be
used.
Conversion of Command Language Scripts to the Native Interface
In previous versions of EnSight, functions were provided to convert
selections of command language to ensight.sendmesg() format.
With the native interface, these have been replaced with two menu options in the
EnSight Python script editor. Under the
Edit menu, there is an option Convert selection to
sendmesg() which converts the currently selected text in the editor into
the ensight.sendmesg() form. More importantly, there is a
Convert selection to native Python option. This function will
convert command language to the native interface described here. One can convert a
.enc file by loading it into the script editor window,
selecting all of the text and converting it to native Python.
The result can be saved as a .py file. An example of the conversion
results would be:
VERSION 8.26 part: select_default part: modify_begin part: elt_representation 3D_feature_2D_full part: modify_end data: binary_files_are big_endian data: format case data: shift_time 1.000000 0.000000 0.000000 data: replace c:/Program Files/CEI/ensight102/data/cube/cube.case view_transf: rotate -6.277198e+001 6.945956e-001 0.000000e+000 part: select_all clip: begin clip: value MID-RANGE clip: domain intersect clip: tool xyz clip: end clip: create part: select_begin 2 part: select_end view_transf: rotate 1.904619e+001 3.095920e+001 0.000000e+000 part: modify_begin clip: value -0.425000 clip: tool xyz part: modify_end view: hidden_surface ON variables: activate temperature part: select_all part: modify_begin part: colorby_palette temperature part: modify_end
Translates into the following native Python code:
ensight.sendmesgoptions(version=8.26)
ensight.part.select_default()
ensight.part.modify_begin()
ensight.part.elt_representation("3D_feature_2D_full")
ensight.part.modify_end()
ensight.data.binary_files_are("big_endian")
ensight.data.format("case")
ensight.data.shift_time(1.000000,0.000000,0.000000)
ensight.data.replace("c:/Program Files/CEI/ensight102/data/cube/cube.case")
ensight.view_transf.rotate(-6.277198e+001,6.945956e-001,0.000000e+000)
ensight.part.select_all()
ensight.clip.begin()
ensight.clip.value("MID-RANGE")
ensight.clip.domain("intersect")
ensight.clip.tool("xyz")
ensight.clip.end()
ensight.clip.create()
ensight.part.select_begin(2)
ensight.view_transf.rotate(1.904619e+001,3.095920e+001,0.000000e+000)
ensight.part.modify_begin()
ensight.clip.value(-0.425000)
ensight.clip.tool("xyz")
ensight.part.modify_end()
ensight.view.hidden_surface("ON")
ensight.variables.activate("temperature")
ensight.part.select_all()
ensight.part.modify_begin()
ensight.part.colorby_palette("temperature")
ensight.part.modify_end()
ensight.sendmesgoptions(version=0)This language conversion is actually performed by the class
Cmd2Py in the Python module:
cei.cmd2py. A quick study of the
cmd2py.py file will give an overview of the conversion process
and what is and what is not handled by the conversion. Some command language cannot be
converted automatically. Files that include things like command language loops cannot be
converted automatically and the conversion system will insert comments detailing the
failures. Examples that use other command language features that cannot be directly
translated (for example, $ variables) will be converted to
ensight.sendmesg() formatted lines as a fallback. In most
cases, users are better off converting such sections of code into native
Python in any case. A command line program:
cmd2py is also provided to aid in the conversion of files
outside of EnSight.
Usage Notes on the Native Python Interface
The native interface has the same limitations listed in Limitations of the EnSight Python Interface. In general, all of the command language is supported with a few exceptions.
One exception is the test: commands. These commands are
not supported by the native interface (i.e. there is no
ensight.test module). They can of course be issued using
the ensight.sendmesg("test:...") interface.
There are a number of commands in the EnSight command language that are not valid Python names. A few examples include:
function: #_of_levels 5
annotation: 3d_label_size 10.0
command: print "hello"
viewport: raise
The reasons a name might be invalid include:
name includes an invalid character (for example, "#")
name begins with a digit (for example, "1")
name is a Python reserved word (for example, "raise")
These are transformed using the following rules:
"#" characters are replaced with the text number
names that start with a digit are prefixed with an _
names that are the same as a Python reserved word are prefixed with an _
The previous examples become:
ensight.function.number_of_levels(5)
ensight.annotation._3d_label_size(10.0)
ensight.command.print("hello")
ensight.viewport._raise()
There are a few obsolete EnSight command language functions that are not supported. One example would be:
part: symmetry_1_1_-1
Such functions can still be executed using
ensight.sendmesg().
The native interface methods do not include the
exception, record,
display or version keywords like
ensight.sendmesg(). However, they do honor the values set
by ensight.sendmesgoptions(). That function can be used to
cause the code that uses the native interface do be executed under the particular rules
of a specific command language version or to throw exceptions on errors for
instance.
EnSight Python Events
EnSight has a mechanism to execute Python code when various events occur in the main program. The module provides methods to add a callback and remove one. Each callback consists of a Python object, the name of a method on the object and a reason to be called back. An example Python class that registers itself for one rendering callback and then removes itself would be:
class cb_class:
def register(self):
self.ID = ensight.addcallback(self,"callback",ensight.ENS_EVENT_PRERENDER)
def callback(self,value):
print("Called back from EnSight {}".format(value))
ensight.removecallback(self.ID)
example = cb_class()
example.register()Note: Be aware that callback in the
addcallback() method specifies the name of the function
in the object to call. The value in the callback value
argument vary depending on the specific event it is tied to, but it will always be a
tuple that starts with the original event name passed in
addcallback(). Another example, using the
ENS_EVENT_PYTHON interface might be:
class py_cb_class:
def init (self):
self.filter = ensight.query(ensight.UNIQUE_ID)
self.ID1 = ensight.addcallback(self,"fil_cb",ensight.ENS_EVENT_PYTHON,self.filter)
self.ID2 = ensight.addcallback(self,"def_cb",ensight.ENS_EVENT_PYTHON)
def fil_cb(self,value):
print("Filtered callback {} {}".format(self.filter, value))
return 0
def def_cb(self,value):
print("Default callback {}".format(value))
return 0
def test(self):
print("immediate,filtered: {}".format(ensight.sendevent(["hello"],filter=self.filter))))
print("deferred: {}".format(ensight.sendevent(["goodbye"],deferred=1)))
example = py_cb_class()
example.test()In this example, take careful note of the position and order of the generated output to see the effects of deferred callbacks.
EnSight Python Code Methods
|
||
This method registers the specified method name will be called on the passed
object when the specified Currently defined values for |
||
|
The method will be called for all EnSight events. The callback function value will reflect the actual event type for which the callback was invoked. |
|
|
EnSight is about to exit. |
|
|
The current solution time has changed. The new time is passed as the value. |
|
|
The number of time steps has changed. The new time is passed as the value. This event is triggered due to simulation monitoring updates. This is an topic discussed in Load Transient Data. |
|
|
EnSight has just redrawn its current displays. |
|
|
EnSight is about to execute the command language string passed as the value. |
|
|
EnSight has just executed the command language string passed as the value. |
|
|
A periodic time has occurred (see below). |
|
|
The current part selection has changed to the tuple of part numbers passed as value. |
|
|
A part has either been created or destroyed. A value of 0 is passed on construction and 1 is passed on destruction. A value of 3 is passed when a part is renamed. |
|
|
A case has either been created, renamed, made current or destroyed. A value of 0 is passed on construction, 1 is passed on destruction, 2 is passed if the current case is made current and 3 is passed if a case is renamed. |
|
|
A query in ensight has been created, destroyed or updated. Two values
are passed. The first selects the type of the query. If the first value is:
|
|
|
A variable has either been created/activated or destroyed/deactivated. A value of 0 is passed on construction and 1 is passed on destruction. |
|
Special Event Types: |
||
These events come from different sources and the callback functions may have slightly different behavior from the basic event types. |
||
Python events: |
||
|
This event allows multiple Python objects running
inside of the EnSight Python interpreter to pass
information to each other. A callback function that is associated with this
event type will be passed a Python list as its
value (see: the method |
|
Low Level CVF (device) events: |
||
EnSight's rendering windows are based on a framework called CVF. This framework provides an abstraction for all user input events. These event types give a Python callback the opportunity to see these low-level device events. It also gives the callback the opportunity to suppress the handling of these events by the normal EnSight handlers. This can be useful for applications that decide they want specify control over user input in the graphics windows or want to override the default EnSight behavior for types of interaction. If the callback for one of these events returns the integer value 1, the event will not be passed on to EnSight. A return value of 0 will allow normal EnSight event processing to occur. |
||
The passed value will be the list: |
||
The passed value will be the list: |
||
The passed value will be the list: |
||
The passed value will be the list: |
||
The passed value will be the list: |
||
The passed value will be the list: |
||
The passed value will be the list: |
||
The passed value will be the list: |
||
The passed value will be the list: |
||
The passed value will be the list: |
||
The passed value will be the list: |
||
The passed value will be the list:
|
||
The passed value will be the list:
|
||
The passed value will be the list:
|
||
The passed value will be the list:
|
||
The passed value will be the list:
|
||
The passed value will be the list:
|
||
The passed value will be the list:
|
||
The passed value will be the list:
|
||
The passed value will be the list:
|
||
The passed value will be the list:
|
||
The x and y values are the location of the cursor at the time of the event.
Generally, the button value will be one of ( |
||
Timer events |
||
This is a special case in that it requires an extra |
||
|
||
This method removes the previously registered callback function. |
||
|
||
This method works in conjunction with
|
||
 |
||