## wxAutomationObject

The wxAutomationObject class represents an OLE automation object containing a single data member, an IDispatch pointer. It contains a number of functions that make it easy to perform automation operations, and set and get properties. The class makes heavy use of the wxVariant class.

The usage of these classes is quite close to OLE automation usage in Visual Basic. The API is high-level, and the application can specify multiple properties in a single string. The following example gets the current Excel instance, and if it exists, makes the active cell bold.

      wxAutomationObject excelObject;
      if (excelObject.GetInstance("Excel.Application"))
          excelObject.PutProperty("ActiveCell.Font.Bold", TRUE);

Note that this class works under Windows only, and currently only for Visual C++.

Derived from

wxObject

Include files

<wx/msw/ole/automtn.h>

See also

wxVariant

Members

wxAutomationObject::wxAutomationObject
wxAutomationObject::~wxAutomationObject
wxAutomationObject::CallMethod
wxAutomationObject::CreateInstance
wxAutomationObject::GetDispatchPtr
wxAutomationObject::GetInstance
wxAutomationObject::GetObject
wxAutomationObject::GetProperty
wxAutomationObject::Invoke
wxAutomationObject::PutProperty
wxAutomationObject::SetDispatchPtr

### wxAutomationObject::wxAutomationObject

wxAutomationObject(WXIDISPATCH* dispatchPtr = NULL)

Constructor, taking an optional IDispatch pointer which will be released when the object is deleted.

### wxAutomationObject::~wxAutomationObject

~wxAutomationObject()

Destructor. If the internal IDispatch pointer is non-null, it will be released.

### wxAutomationObject::CallMethod

wxVariant CallMethod(const wxString& method, int noArgs, wxVariant args[]) const

wxVariant CallMethod(const wxString& method, ...) const

Calls an automation method for this object. The first form takes a method name, number of arguments, and an array of variants. The second form takes a method name and zero to six constant references to variants. Since the variant class has constructors for the basic data types, and C++ provides temporary objects automatically, both of the following lines are syntactically valid:

      wxVariant res = obj.CallMethod("Sum", wxVariant(1.2), wxVariant(3.4));
      wxVariant res = obj.CallMethod("Sum", 1.2, 3.4);

Note that method can contain dot-separated property names, to save the application needing to call GetProperty several times using several temporary objects. For example:

      object.CallMethod("ActiveCell.Font.ShowDialog", "My caption");

### wxAutomationObject::CreateInstance

bool CreateInstance(const wxString& classId) const

Creates a new object based on the class id, returning TRUE if the object was successfully created, or FALSE if not.

### wxAutomationObject::GetDispatchPtr

IDispatch* GetDispatchPtr() const

Gets the IDispatch pointer.

### wxAutomationObject::GetInstance

bool GetInstance(const wxString& classId) const

Retrieves the current object associated with a class id, and attaches the IDispatch pointer to this object. Returns TRUE if a pointer was succesfully retrieved, FALSE otherwise.

Note that this cannot cope with two instances of a given OLE object being active simultaneously, such as two copies of Excel running. Which object is referenced cannot currently be specified.

### wxAutomationObject::GetObject

bool GetObject(wxAutomationObject&obj const wxString& property, int noArgs = 0, wxVariant args[] = NULL) const

Retrieves a property from this object, assumed to be a dispatch pointer, and initialises obj with it. To avoid having to deal with IDispatch pointers directly, use this function in preference to wxAutomationObject::GetProperty when retrieving objects from other objects.

Note that an IDispatch pointer is stored as a void* pointer in wxVariant objects.

See also

wxAutomationObject::GetProperty

### wxAutomationObject::GetProperty

wxVariant GetProperty(const wxString& property, int noArgs, wxVariant args[]) const

wxVariant GetProperty(const wxString& property, ...) const

Gets a property value from this object. The first form takes a property name, number of arguments, and an array of variants. The second form takes a property name and zero to six constant references to variants. Since the variant class has constructors for the basic data types, and C++ provides temporary objects automatically, both of the following lines are syntactically valid:

      wxVariant res = obj.GetProperty("Range", wxVariant("A1"));
      wxVariant res = obj.GetProperty("Range", "A1");

Note that property can contain dot-separated property names, to save the application needing to call GetProperty several times using several temporary objects.

### wxAutomationObject::Invoke

bool Invoke(const wxString& member, int action, wxVariant& retValue, int noArgs, wxVariant args[], const wxVariant* ptrArgs[] = 0) const

This function is a low-level implementation that allows access to the IDispatch Invoke function. It is not meant to be called directly by the application, but is used by other convenience functions.

Parameters

member

The member function or property name.

action

Bitlist: may contain DISPATCH_PROPERTYPUT, DISPATCH_PROPERTYPUTREF, DISPATCH_METHOD.

retValue

Return value (ignored if there is no return value)

.

noArgs

Number of arguments in args or ptrArgs.

args

If non-null, contains an array of variants.

ptrArgs

If non-null, contains an array of constant pointers to variants.

Return value

TRUE if the operation was successful, FALSE otherwise.

Remarks

Two types of argument array are provided, so that when possible pointers are used for efficiency.

### wxAutomationObject::PutProperty

bool PutProperty(const wxString& property, int noArgs, wxVariant args[]) const

bool PutProperty(const wxString& property, ...)

Puts a property value into this object. The first form takes a property name, number of arguments, and an array of variants. The second form takes a property name and zero to six constant references to variants. Since the variant class has constructors for the basic data types, and C++ provides temporary objects automatically, both of the following lines are syntactically valid:

      obj.PutProperty("Value", wxVariant(23));
      obj.PutProperty("Value", 23);

Note that property can contain dot-separated property names, to save the application needing to call GetProperty several times using several temporary objects.

### wxAutomationObject::SetDispatchPtr

void SetDispatchPtr(WXIDISPATCH* dispatchPtr)

Sets the IDispatch pointer. This function does not check if there is already an IDispatch pointer.

You may need to cast from IDispatch* to WXIDISPATCH* when calling this function.