SAFEARRAY data type
SAFEARRAY data type described below is recognized by most development
environments. It is used by DInsight software to pass references to buffers of
data to and from the user application. The structure is described blow. Normally
in Microsoft Visual Studio it should not be created directly. Use
SafeArrayCreate() function (See online documentation for Visual Studio) to
allocate the array. Then use SafeArrayLock() to access the data in the array.
Use SafeArrayUnlock() and SafeArrayDestroy() to release and delete the data.
Sample below uses IModelEx::SaveToMemory()
method to obtain copy of persistent data of the current model as a SAFEARRAY.
void MyDialog::DoSave(int format)
{
IModel * pIModel = (IModel*)m_ctrlCAD.GetModel();
IModelEx* pIModelEx = NULL;
pIModel->QueryInterface(IID_IModelEx, (void**)&pIModelEx );
SAFEARRAY* pData = NULL;
pIModelEx->SaveToMemory( &pData, format); // SaveToMemory() returns the array unlocked with zero lock counter
// Access the data in the array
VERIFY( SafeArrayLock( pData ) == S_OK );
// At this point data of the model is located at pData->pvData and has length of
// pData->rgsabound[0].cElements bytes. Do embedding the model into the application document,
// If the format is other than .MDG it might make sense to encrypt the data to keep you models
// accessible by your applications only
// Unlock the data
VERIFY( SafeArrayUnlock( pData ) == S_OK );
// Release the memory
VERIFY( SafeArrayDestroy( pData ) == S_OK );
Invalidate(FALSE);
UpdateWindow();
pIModelEx->Release();
pIModel->Release();
}
Sample below uses IModelEx::LoadFromMemory()
method to reload the current model from data in a SAFEARRAY.
void MyDialog::DoLoad(int format)
{
IModel * pIModel = (IModel*)m_ctrlCAD.GetModel();
IModelEx* pIModelEx = NULL;
pIModel->QueryInterface(IID_IModelEx, (void**)&pIModelEx );
SAFEARRAYBOUND rgsabound[1];
// One dimensional array
rgsabound[0].lLbound = 0;
// The lower bound is always 0
rgsabound[0].cElements = myModelSize;
// myModelSize would be same as file.GetLength();
// if the model was loaded from a model file
// Create array of the above size
SAFEARRAY* psa = SafeArrayCreate(VT_UI1, 1, rgsabound);
if(psa == NULL)
return;
VERIFY( SafeArrayLock( psa ) == S_OK );
// Before this call the data in psa->pvData is not accessible
//Copy, load etc data of the model from your application into psa->pvData
here
pIModelEx->LoadFromMemory( &psa, format);
// Pass it to the component
VERIFY( SafeArrayUnlock( psa ) == S_OK );
// Unlock the data
VERIFY( SafeArrayDestroy( psa ) == S_OK );
// Release the memory
Invalidate(FALSE);
UpdateWindow();
pIModelEx->Release();
pIModel->Release();
}
This is how the SAFEARRAY type is described in Microsoft SDK
documentation:
The definition for a safearray varies, depending on the target operating system platform. On 32-bit Windows systems, both the cbElements and cLocks parameters are unsigned long integers, and the handle parameter is omitted. On 16-bit Windows systems, cbElements and cLocks are unsigned short integers The handle parameter is retained for compatibility with earlier software. For example:
typedef struct FARSTRUCT tagSAFEARRAY {
unsigned short cDims; // Count of dimensions in this array.
unsigned short fFeatures; // Flags used by the
SafeArray. routines documented below.
unsigned long cbElements; // Size of an element of the array.
Does not include size of pointed-to data.
unsigned long cLocks; // Number of times the array has been.
Locked without corresponding unlock.
void HUGEP* pvData; // Pointer to the data.
SAFEARRAYBOUND rgsabound[1]; // One bound for each dimension.
} SAFEARRAY;
Remarks
The array rgsabound is stored with the left-most dimension in rgsabound[0] and the right-most dimension in rgsabound[cDims - 1]. If an array was specified in a C-like syntax as a [2][5], it would have two elements in the rgsabound vector. Element 0 has an lLbound of 0 and a cElements of 2. Element 1 has an lLbound of 0 and a cElements of 5.
The fFeatures flags describe attributes of an array that can affect how the array is released. The fFeatures field describes what type of data is stored in the SAFEARRAY and how the array is allocated. This allows freeing the array without referencing its containing variant. The bits are accessed using the following constants:
fFeatures Flags Description
FADF_AUTO 0x0001
An array that is allocated on the stack.
FADF_STATIC 0x0002 An array that is statically allocated.
FADF_EMBEDDED 0x0004 An array that is embedded in a structure.
FADF_FIXEDSIZE 0x0010
An array that may not be resized or reallocated.
FADF_RECORD 0x0020 An array containing records. When set there will be a pointer to the IRecordinfo interface at negative offset 4 in the array descriptor.
FADF_HAVEIID 0x0040 An array that has an IID identifying interface. When set there will be a guid at negative offset 16 in the safearray descriptor. Flag is set only when FADF_DISPATCH or FADF_UNKNOWN is also set.
FADF_HAVEVARTYPE 0x0080 An array that has a VT type. When set there will be a VT tag at negative offset 4 in the array descriptor that specifies the element type.
FADF_BSTR 0x0100 An array of BSTRs.
FADF_UNKNOWN 0x0200 An array of IUnknown*.
FADF_DISPATCH 0x0400 An array of IDispatch*.
FADF_VARIANT 0x0800 An array of VARIANTs.
FADF_RESERVED 0xF0E8 Bits reserved for future use.
typedef struct tagSAFEARRAYBOUND {
unsigned long cElements;
long lLbound;
} SAFEARRAYBOUND;
|