maxscript/util/OLE.h File Reference
 
 
 
maxscript/util/OLE.h File Reference
#include "../foundation/arrays.h"
#include "../foundation/functions.h"
#include "OLE.classids.h"
#include "../macros/define_implementations.h"

Classes

class   MSClassFactory
class   MSOLEObject

Defines

#define  MS_E_EXCEPTION   MAKE_SCODE(SEVERITY_ERROR, FACILITY_ITF, 0x0200)
#define  MS_E_ILLEGAL_RETURN_VALUE   MS_E_EXCEPTION + 0x001
#define  is_OLEObject(v)   ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(OLEObject))
#define  is_OLEMethod(v)   ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(OLEMethod))
#define  is_SafeArrayWrapper(v)   ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(SafeArrayWrapper))
#define  UNUSED(X)   (X)

Functions

  visible_class (OLEObject) class OLEObject
  visible_class (OLEMethod) class OLEMethod
  applyable_class_debug_ok (SafeArrayWrapper) class SafeArrayWrapper
BOOL  init_MAXScript_OLE ()
void  uninit_OLE ()

Define Documentation

#define MS_E_EXCEPTION   MAKE_SCODE(SEVERITY_ERROR, FACILITY_ITF, 0x0200)
#define MS_E_ILLEGAL_RETURN_VALUE   MS_E_EXCEPTION + 0x001
#define is_OLEObject (   v )    ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(OLEObject))
#define is_OLEMethod (   v )    ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(OLEMethod))
#define is_SafeArrayWrapper (   v )    ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(SafeArrayWrapper))
#define UNUSED (   X )    (X)

Function Documentation

visible_class ( OLEObject  )
                : public Value
{
public:
    Value*              progID;         // user-supplied progID string
        CLSID           clsid;          // CLSID of ActiveX object.
    LPDISPATCH  pdisp;          // IDispatch of ActiveX object.

                                OLEObject(Value* progID, CLSID cslid, LPDISPATCH pdisp);
                                OLEObject(Value* progID, LPDISPATCH pdisp);
                           ~OLEObject();
        #define         is_OLEObject(v) ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(OLEObject))

                                classof_methods (OLEObject, Value);
        void            collect();
        void            gc_trace();
        ScripterExport void             sprin1(CharStream* s);

        Value*          get_property(Value** arg_list, int count);
        Value*          set_property(Value** arg_list, int count);
        Value*          get_fn_property(Value* prop);
};
visible_class ( OLEMethod  )
                : public Function
{
public:
        OLEObject*      ole_obj;        // my OLE object
    DISPID              dispid;         // method dispatch ID

                                OLEMethod() { }
                                OLEMethod(const MCHAR* name, OLEObject* ole_obj, DISPID mth_id);
        #define         is_OLEMethod(v) ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(OLEMethod))

                                classof_methods (OLEMethod, Function);
        void            collect();
        void            gc_trace();

        Value*          apply(Value** arglist, int count, CallContext* cc=NULL);
};
applyable_class_debug_ok ( SafeArrayWrapper  )

Define an equal operator (i.e. '==') for maxscript visible values.

Define a NOT equal operator (i.e. '!=') for maxscript visible values.

                       : public Value
{
        friend SafeArrayWrapperClass;
public:
        Value*  dataArray;
        Value*  lBoundsArray;
        int             numDims;

// Creates SafeArrayWrapper with empty data and lBounds arrays.
        ScripterExport SafeArrayWrapper();
// Creates SafeArrayWrapper with data array and empty lBounds array.
// \pre dataArray must be non-null
// \param[in] dataArray The data array
// \param[in] nDims The dimensions of the data array
        ScripterExport SafeArrayWrapper(Array* dataArray, int nDims);
// Creates SafeArrayWrapper with data and lBounds array.
// \pre dataArray must be non-null
// \pre lboundsArray must be non-null
// \param[in] dataArray The data array
// \param[in] lBoundsArray The lBounds array
// \param[in] nDims The dimensions of the data and lBounds array
        ScripterExport SafeArrayWrapper(Array* dataArray, Array* lBoundsArray, int nDims);
// Creates SafeArrayWrapper from SAFEARRAY.
// \pre psa must be non-null
// \param[in] psa The SAFEARRAY to build the data and lBounds array from
// \param[in] progID user-supplied progID string of the creating object 
        ScripterExport SafeArrayWrapper(SAFEARRAY *psa, Value* progID);
// Creates OLE SAFEARRAY based on data and lBounds array.
// if dataArray is 'undefined', throws exception
// if lBoundsArray is 'undefined', lower bounds of 0 used
// if dataArray is not "square", throws exception
// \return the SAFEARRAY
        ScripterExport SAFEARRAY* to_SAFEARRAY();

// Calculates number of dimensions of input Array.
// \pre testArray must be non-null
// \param[in] testArray Array to calculate the dimensions of
// \return Number of dimensions
        ScripterExport static int               GetDataArrayDimensions(Array* testArray);
// Calculates the array size for each dimension.
// Verifies the arrays size in each dimension is consistent across array - throws runtime error if not.
// \pre testArray can be null
// \pre pCount must be non-null
// \post pCount is filled with array size for each dimension
// \param[in] testArray Array to calculate the dimensions of
// \param[in] nDims The dimensions of the Array
// \param[in,out] pCount pointer to nDims size int array. Method fills array with array size for each dimension
        ScripterExport static void              CheckDataArray(Array* testArray, int nDims, int* pCount = NULL);

#define         is_SafeArrayWrapper(v) ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(SafeArrayWrapper))

        classof_methods (SafeArrayWrapper, Value);
        void            collect();
        void            gc_trace();
        ScripterExport void sprin1(CharStream* s);

        /* operations */

#include "../macros/define_implementations.h"
        use_generic( copy,              "copy");

        Value*          get_property(Value** arg_list, int count);
        Value*          set_property(Value** arg_list, int count);

};
BOOL init_MAXScript_OLE ( )
void uninit_OLE ( )