2963 lines
94 KiB
C
2963 lines
94 KiB
C
|
/* Copyright 2001-2016 The MathWorks, Inc. */
|
||
|
|
|
||
|
|
#ifndef _MCLCOMCLASS_H_
|
||
|
|
#define _MCLCOMCLASS_H_
|
||
|
|
|
||
|
|
#pragma warning( disable : 4786 )
|
||
|
|
#include "mclmcrrt.h"
|
||
|
|
#include "mwcomutil.h"
|
||
|
|
#include <olectl.h>
|
||
|
|
#include <wchar.h>
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
|
||
|
|
#include <iostream>
|
||
|
|
#include <vector>
|
||
|
|
#include <map>
|
||
|
|
#include <set>
|
||
|
|
#include <queue>
|
||
|
|
|
||
|
|
#ifndef HWND_MESSAGE
|
||
|
|
#define HWND_MESSAGE (HWND)NULL
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// Structure used to pass supporting info for objects into CMCLModule Init method.
|
||
|
|
|
||
|
|
typedef struct _MCLOBJECT_MAP_ENTRY
|
||
|
|
{
|
||
|
|
// Pointer to CLSID value
|
||
|
|
|
||
|
|
const CLSID* pclsid;
|
||
|
|
// Pointer to function responsible for registering the class
|
||
|
|
|
||
|
|
HRESULT (__stdcall* pfnRegisterClass)(const GUID*, unsigned short, unsigned short,
|
||
|
|
const char*, const char*, const char*, const char*);
|
||
|
|
// Pointer to function responsible for unregistering the class
|
||
|
|
|
||
|
|
HRESULT (__stdcall* pfnUnregisterClass)(const char*, const char*);
|
||
|
|
// Pointer to function responsible for returning an instance of the object's class factory
|
||
|
|
|
||
|
|
HRESULT (__stdcall* pfnGetClassObject)(REFCLSID, REFIID, void**);
|
||
|
|
// Class's friendly name
|
||
|
|
|
||
|
|
const char* lpszFriendlyName;
|
||
|
|
// Class's version independent ProgID
|
||
|
|
|
||
|
|
const char* lpszVerIndProgID;
|
||
|
|
// Class's ProgID
|
||
|
|
|
||
|
|
const char* lpszProgID;
|
||
|
|
} _MCLOBJECT_MAP_ENTRY, *MCLOBJECT_MAP_ENTRY;
|
||
|
|
|
||
|
|
class mwLock
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
mwLock()
|
||
|
|
{
|
||
|
|
mclAcquireMutex();
|
||
|
|
}
|
||
|
|
virtual ~mwLock()
|
||
|
|
{
|
||
|
|
mclReleaseMutex();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
class IMCLFeval
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
virtual bool Feval(HMCRINSTANCE hinst, const char* name, int nlhs, mxArray** plhs, int nrhs, mxArray** prhs) = 0;
|
||
|
|
virtual const char* getErrorMessage() const = 0;
|
||
|
|
virtual void RaiseEvent(OLECHAR* lpwszName, DISPID dispid, IDispatch* pDisp, DISPPARAMS* pDispParams) = 0;
|
||
|
|
virtual bool init(HINSTANCE hInstance) = 0;
|
||
|
|
virtual bool stop() = 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
class IMCLEvent
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
virtual void mclRaiseEventA(const char* lpszName, DISPID dispid, int nargin, mxArray** prhs) = 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
class IMCLEventMap
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
virtual int size() = 0;
|
||
|
|
virtual void add(void *context, IMCLEvent* pEvent) = 0;
|
||
|
|
virtual void remove(void *context, IMCLEvent* pEvent) = 0;
|
||
|
|
virtual void invokeA(void *context, const char* lpszName, DISPID dispid, int nargin, mxArray** prhs) = 0;
|
||
|
|
};
|
||
|
|
|
||
|
|
typedef bool (*MCLInitializeInstancePtr)(HMCRINSTANCE*, const char* path_to_component);
|
||
|
|
typedef bool (*MCLInitializeInstanceExPtr)(HMCRINSTANCE*, const char* path_to_component,
|
||
|
|
mclCtfStream ctfStream);
|
||
|
|
typedef bool (*MCLTerminateInstancePtr)(HMCRINSTANCE*);
|
||
|
|
|
||
|
|
#define WM_FEVALCOMPLETE WM_USER
|
||
|
|
#define WM_EVENTPENDING WM_USER+1
|
||
|
|
|
||
|
|
// Class for managing global list of event listeners.
|
||
|
|
class mclEventMap : public IMCLEventMap
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
mclEventMap(){}
|
||
|
|
virtual ~mclEventMap(){}
|
||
|
|
// Returns current number of listeners
|
||
|
|
int size()
|
||
|
|
{
|
||
|
|
mwLock lock;
|
||
|
|
return (int)m_events.size();
|
||
|
|
}
|
||
|
|
// Adds a listener
|
||
|
|
void add(void *context, IMCLEvent* pEvent)
|
||
|
|
{
|
||
|
|
mwLock lock;
|
||
|
|
if (!pEvent)
|
||
|
|
return;
|
||
|
|
std::map<void *, IMCLEvent*>::iterator it = m_events.find(context);
|
||
|
|
if (it == m_events.end())
|
||
|
|
m_events[context] = pEvent;
|
||
|
|
}
|
||
|
|
// Removes a listener
|
||
|
|
void remove(void *context, IMCLEvent* pEvent)
|
||
|
|
{
|
||
|
|
(void)pEvent;
|
||
|
|
mwLock lock;
|
||
|
|
std::map<void *, IMCLEvent*>::iterator it = m_events.find(context);
|
||
|
|
if (it != m_events.end())
|
||
|
|
m_events.erase(it);
|
||
|
|
}
|
||
|
|
// Invokes the named event in the listener of current call context.
|
||
|
|
void invokeA(void *context, const char* lpszName, DISPID dispid, int nargin, mxArray** prhs)
|
||
|
|
{
|
||
|
|
mwLock lock;
|
||
|
|
std::map<void *, IMCLEvent*>::iterator it = m_events.find(context);
|
||
|
|
if (it != m_events.end())
|
||
|
|
{
|
||
|
|
((*it).second)->mclRaiseEventA(lpszName, dispid, nargin, prhs);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
std::map<void *, IMCLEvent*> m_events; // Array of listeners
|
||
|
|
};
|
||
|
|
|
||
|
|
// Class for managing global list of event listeners for singleton MCR case.
|
||
|
|
class mclSingleEventMap : public IMCLEventMap
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
mclSingleEventMap(){}
|
||
|
|
virtual ~mclSingleEventMap(){}
|
||
|
|
// Returns current number of listeners
|
||
|
|
int size()
|
||
|
|
{
|
||
|
|
mwLock lock;
|
||
|
|
return (int)m_events.size();
|
||
|
|
}
|
||
|
|
// Adds a listener
|
||
|
|
void add(void *context, IMCLEvent* pEvent)
|
||
|
|
{
|
||
|
|
mwLock lock;
|
||
|
|
if (!pEvent)
|
||
|
|
return;
|
||
|
|
m_events.insert(pEvent);
|
||
|
|
}
|
||
|
|
// Removes a listener
|
||
|
|
void remove(void *context, IMCLEvent* pEvent)
|
||
|
|
{
|
||
|
|
context;
|
||
|
|
mwLock lock;
|
||
|
|
std::set<IMCLEvent*>::iterator it = m_events.find(pEvent);
|
||
|
|
if (it != m_events.end())
|
||
|
|
m_events.erase(it);
|
||
|
|
}
|
||
|
|
// Invokes the named event in the listener of current call context.
|
||
|
|
void invokeA(void *context, const char* lpszName, DISPID dispid, int nargin, mxArray** prhs)
|
||
|
|
{
|
||
|
|
context;
|
||
|
|
mwLock lock;
|
||
|
|
std::set<IMCLEvent*>::iterator it = m_events.begin();
|
||
|
|
while (it != m_events.end())
|
||
|
|
{
|
||
|
|
(*it)->mclRaiseEventA(lpszName, dispid, nargin, prhs);
|
||
|
|
it++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
std::set<IMCLEvent*> m_events; // Array of listeners
|
||
|
|
};
|
||
|
|
|
||
|
|
// Stack proxy for a mutex
|
||
|
|
class ModuleLock
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
ModuleLock()
|
||
|
|
{
|
||
|
|
#if defined (mclcommain_h) || defined (mclxlmain_published_api_h)
|
||
|
|
RequestGlobalLock();
|
||
|
|
#else
|
||
|
|
mclRequestGlobalLock();
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
virtual ~ModuleLock()
|
||
|
|
{
|
||
|
|
#if defined (mclcommain_h) || defined (mclxlmain_published_api_h)
|
||
|
|
ReleaseGlobalLock();
|
||
|
|
#else
|
||
|
|
mclReleaseGlobalLock();
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
ModuleLock(const ModuleLock& ml);
|
||
|
|
ModuleLock& operator=(const ModuleLock& ml);
|
||
|
|
};
|
||
|
|
|
||
|
|
class mclSimpleFeval : public IMCLFeval
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
mclSimpleFeval(){}
|
||
|
|
virtual ~mclSimpleFeval(){}
|
||
|
|
// Calls feval.
|
||
|
|
virtual bool Feval(HMCRINSTANCE hinst, const char* name, int nlhs, mxArray** plhs, int nrhs, mxArray** prhs)
|
||
|
|
{
|
||
|
|
return mclFeval(hinst, name, nlhs, plhs, nrhs, prhs);
|
||
|
|
}
|
||
|
|
// Makes an event callback.
|
||
|
|
virtual void RaiseEvent(OLECHAR* lpwszName, DISPID mdispid, IDispatch* pDisp, DISPPARAMS* pDispParams)
|
||
|
|
{
|
||
|
|
DISPID dispid = 0;
|
||
|
|
VARIANT varResult;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
|
||
|
|
VariantInit(&varResult);
|
||
|
|
if (SUCCEEDED(hr = pDisp->GetIDsOfNames(IID_NULL, &lpwszName, 1, LOCALE_USER_DEFAULT, &dispid)))
|
||
|
|
{
|
||
|
|
hr = pDisp->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, pDispParams,
|
||
|
|
&varResult, NULL, NULL);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
virtual const char* getErrorMessage() const
|
||
|
|
{
|
||
|
|
return mclGetLastErrorMessage();
|
||
|
|
}
|
||
|
|
virtual bool init(HINSTANCE hInstance)
|
||
|
|
{
|
||
|
|
(void)hInstance;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
virtual bool stop()
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
// Feval with events. Creates a thread on which all
|
||
|
|
// feval calls are made. Calling thread waits on feval
|
||
|
|
// thread to complete feval call. If an event arrives
|
||
|
|
// before the feval call returns, the calling thread
|
||
|
|
// executes the callback, then resumes waiting for the
|
||
|
|
// the feval to finish. This ensures that synchronous
|
||
|
|
// callbacks are always executed by the same thread that
|
||
|
|
// made the original feval call. This is needed because
|
||
|
|
// Visual Basic does not allow callbacks to be executed
|
||
|
|
// on a seperate thread, and the MCR always calls back on
|
||
|
|
// its thread, not the caller's.
|
||
|
|
class mclFevalWithEvents : public IMCLFeval
|
||
|
|
{
|
||
|
|
private:
|
||
|
|
// Class used to pass feval args when being called by
|
||
|
|
// Same thread as the message window runs on. When
|
||
|
|
// feval is complete, posts a message to the window.
|
||
|
|
class FevalArgs
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
FevalArgs(HMCRINSTANCE hinst, const char* name, int nlhs, mxArray** plhs, int nrhs, mxArray** prhs, HWND hWnd)
|
||
|
|
: m_hinst(hinst), m_name(name), m_nlhs(nlhs), m_plhs(plhs), m_nrhs(nrhs), m_prhs(prhs), m_retval(false), m_hWnd(hWnd), m_errorMessage(""){}
|
||
|
|
virtual ~FevalArgs(){}
|
||
|
|
virtual bool execute()
|
||
|
|
{
|
||
|
|
m_retval = mclFeval(m_hinst, m_name, m_nlhs, m_plhs, m_nrhs, m_prhs);
|
||
|
|
|
||
|
|
if(!m_retval)
|
||
|
|
{
|
||
|
|
m_errorMessage = mclGetLastErrorMessage();
|
||
|
|
}
|
||
|
|
|
||
|
|
PostMessage(m_hWnd, WM_FEVALCOMPLETE, 0, 0);
|
||
|
|
return m_retval;
|
||
|
|
}
|
||
|
|
bool retval() const {return m_retval;}
|
||
|
|
const char* getErrorMessage() const {return m_errorMessage;}
|
||
|
|
private:
|
||
|
|
HMCRINSTANCE m_hinst;
|
||
|
|
const char* m_name;
|
||
|
|
int m_nlhs;
|
||
|
|
mxArray** m_plhs;
|
||
|
|
int m_nrhs;
|
||
|
|
mxArray** m_prhs;
|
||
|
|
bool m_retval;
|
||
|
|
HWND m_hWnd;
|
||
|
|
const char* m_errorMessage;
|
||
|
|
private:
|
||
|
|
FevalArgs();
|
||
|
|
};
|
||
|
|
// Class used to pass event args
|
||
|
|
class EventArgs
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
EventArgs(OLECHAR* lpwszName, DISPID dispid, IDispatch* pDisp, DISPPARAMS* pDispParams)
|
||
|
|
: m_lpwszName(lpwszName), m_dispid(dispid), m_pDisp(pDisp), m_pDispParams(pDispParams), m_hr(S_OK)
|
||
|
|
{
|
||
|
|
VariantInit(&m_varResult);
|
||
|
|
}
|
||
|
|
virtual ~EventArgs()
|
||
|
|
{
|
||
|
|
VariantClear(&m_varResult);
|
||
|
|
}
|
||
|
|
virtual bool execute()
|
||
|
|
{
|
||
|
|
DISPID dispid = 0;
|
||
|
|
|
||
|
|
m_hr = m_pDisp->Invoke(m_dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, m_pDispParams,
|
||
|
|
&m_varResult, NULL, NULL);
|
||
|
|
return (SUCCEEDED(m_hr));
|
||
|
|
}
|
||
|
|
HRESULT retval() {return m_hr;}
|
||
|
|
private:
|
||
|
|
OLECHAR* m_lpwszName;
|
||
|
|
IDispatch* m_pDisp;
|
||
|
|
DISPPARAMS* m_pDispParams;
|
||
|
|
VARIANT m_varResult;
|
||
|
|
HRESULT m_hr;
|
||
|
|
DISPID m_dispid;
|
||
|
|
private:
|
||
|
|
EventArgs();
|
||
|
|
};
|
||
|
|
public:
|
||
|
|
mclFevalWithEvents() : m_hInstance(NULL), m_hThread(NULL), m_hWnd(NULL), m_errorMessage("") {}
|
||
|
|
virtual ~mclFevalWithEvents()
|
||
|
|
{
|
||
|
|
stop();
|
||
|
|
}
|
||
|
|
// Calls feval. Queues up the request, then
|
||
|
|
// waits for the call to finish.
|
||
|
|
virtual bool Feval(HMCRINSTANCE hinst, const char* name, int nlhs, mxArray** plhs, int nrhs, mxArray** prhs)
|
||
|
|
{
|
||
|
|
HWND hWnd = NULL;
|
||
|
|
BOOL bRet = FALSE;
|
||
|
|
MSG msg = {0, 0, 0, 0, 0, {0,0}};
|
||
|
|
if (!(hWnd = get_thread_window()))
|
||
|
|
return false;
|
||
|
|
FevalArgs Args(hinst, name, nlhs, plhs, nrhs, prhs, hWnd);
|
||
|
|
// Queue the request
|
||
|
|
add(&Args);
|
||
|
|
// Start timer to periodically refresh windows owned by this thread
|
||
|
|
SetTimer(hWnd, 1, 100, NULL);
|
||
|
|
// Process window message loop. Break when feval is finished.
|
||
|
|
while ((bRet = GetMessage(&msg, hWnd, 0, 0)) != 0)
|
||
|
|
{
|
||
|
|
if (bRet == -1)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
else if (msg.message == WM_FEVALCOMPLETE)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else if (msg.message == WM_TIMER)
|
||
|
|
{
|
||
|
|
DoEvents();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
TranslateMessage(&msg);
|
||
|
|
DispatchMessage(&msg);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Stop timer
|
||
|
|
KillTimer(hWnd, 1);
|
||
|
|
m_errorMessage = Args.getErrorMessage();
|
||
|
|
return Args.retval();
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual const char* getErrorMessage() const
|
||
|
|
{
|
||
|
|
return m_errorMessage;
|
||
|
|
}
|
||
|
|
// Makes an event callback. Queues up the call,
|
||
|
|
// then waits for it to finish.
|
||
|
|
virtual void RaiseEvent(OLECHAR* lpwszName, DISPID dispid, IDispatch* pDisp, DISPPARAMS* pDispParams)
|
||
|
|
{
|
||
|
|
EventArgs Args(lpwszName, dispid, pDisp, pDispParams);
|
||
|
|
SendMessage(m_hWnd, WM_EVENTPENDING, 0, (LPARAM)(&Args));
|
||
|
|
}
|
||
|
|
// Performs idle processing.
|
||
|
|
void DoEvents()
|
||
|
|
{
|
||
|
|
EnumThreadWindows(GetCurrentThreadId(), EnumThreadWndProc, NULL);
|
||
|
|
}
|
||
|
|
// Starts the feval thread
|
||
|
|
virtual bool init(HINSTANCE hInstance)
|
||
|
|
{
|
||
|
|
m_hInstance = hInstance;
|
||
|
|
if (!(m_hExit = CreateEvent(NULL, FALSE, FALSE, NULL)))
|
||
|
|
return false;
|
||
|
|
if (!(m_hFevalPending = CreateEvent(NULL, FALSE, FALSE, NULL)))
|
||
|
|
return false;
|
||
|
|
WNDCLASS wc = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||
|
|
if (!GetClassInfo(m_hInstance, "feval_window_class", &wc))
|
||
|
|
{
|
||
|
|
WNDCLASS wc_new = {0, (WNDPROC)ModuleWndProc, 0, 0, m_hInstance, NULL, NULL, NULL, NULL, "feval_window_class"};
|
||
|
|
if (!RegisterClass(&wc_new))
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (!(m_hWnd = get_thread_window()))
|
||
|
|
return false;
|
||
|
|
if (!(m_hThread = CreateThread(NULL, 0, FevalProc, (LPVOID)this, 0, &m_dwThreadID)))
|
||
|
|
return false;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
// Stops the feval thread, destroys window
|
||
|
|
virtual bool stop()
|
||
|
|
{
|
||
|
|
SetEvent(m_hExit);
|
||
|
|
WaitForSingleObject(m_hThread, INFINITE);
|
||
|
|
CloseHandle(m_hThread);
|
||
|
|
std::map<DWORD, HWND>::iterator it = m_ThreadData.begin();
|
||
|
|
while(it != m_ThreadData.end())
|
||
|
|
{
|
||
|
|
HWND hWnd = (*it).second;
|
||
|
|
if (hWnd)
|
||
|
|
DestroyWindow(hWnd);
|
||
|
|
it++;
|
||
|
|
}
|
||
|
|
UnregisterClass("feval_window_class", m_hInstance);
|
||
|
|
m_hWnd = NULL;
|
||
|
|
m_ThreadData.clear();
|
||
|
|
CloseHandle(m_hExit);
|
||
|
|
CloseHandle(m_hFevalPending);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
// Returns the HWND associated with the current thread
|
||
|
|
// A new HWND is created by this function the first time
|
||
|
|
// it gets called on a given thread.
|
||
|
|
HWND get_thread_window()
|
||
|
|
{
|
||
|
|
ModuleLock lock;
|
||
|
|
DWORD dwThreadID = GetCurrentThreadId();
|
||
|
|
HWND hWnd = NULL;
|
||
|
|
std::map<DWORD, HWND>::iterator it = m_ThreadData.find(dwThreadID);
|
||
|
|
if (it == m_ThreadData.end())
|
||
|
|
{
|
||
|
|
char tmp[128];
|
||
|
|
char window_name[128];
|
||
|
|
sprintf(tmp, "%u", dwThreadID);
|
||
|
|
strcpy(window_name, "feval_");
|
||
|
|
strcat(window_name, tmp);
|
||
|
|
strcat(window_name, "_window");
|
||
|
|
hWnd = CreateWindowEx(0, "feval_window_class", window_name, 0,
|
||
|
|
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
|
||
|
|
HWND_MESSAGE, (HMENU)NULL, m_hInstance, NULL);
|
||
|
|
if (!hWnd)
|
||
|
|
{
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
m_ThreadData[dwThreadID] = hWnd;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
hWnd = (*it).second;
|
||
|
|
return hWnd;
|
||
|
|
}
|
||
|
|
// Adds an feval call
|
||
|
|
void add(FevalArgs* pArgs)
|
||
|
|
{
|
||
|
|
ModuleLock lock;
|
||
|
|
m_fevalQueue.push(pArgs);
|
||
|
|
SetEvent(m_hFevalPending);
|
||
|
|
}
|
||
|
|
// Gets the next available feval call
|
||
|
|
FevalArgs* get_next()
|
||
|
|
{
|
||
|
|
ModuleLock lock;
|
||
|
|
if (m_fevalQueue.size() == 0)
|
||
|
|
return NULL;
|
||
|
|
FevalArgs* pArgs = m_fevalQueue.front();
|
||
|
|
m_fevalQueue.pop();
|
||
|
|
return pArgs;
|
||
|
|
}
|
||
|
|
// Feval thread function. Executes fevals as they become available,
|
||
|
|
// Exits when signaled to.
|
||
|
|
static DWORD WINAPI FevalProc(LPVOID pThis)
|
||
|
|
{
|
||
|
|
mclFevalWithEvents* pf = static_cast<mclFevalWithEvents*>(pThis);
|
||
|
|
HANDLE hEvents[2] = {pf->m_hFevalPending, pf->m_hExit};
|
||
|
|
DWORD dwWait = 0;
|
||
|
|
|
||
|
|
for (;;)
|
||
|
|
{
|
||
|
|
dwWait = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE);
|
||
|
|
if (dwWait == WAIT_OBJECT_0)
|
||
|
|
{
|
||
|
|
FevalArgs* pArgs = NULL;
|
||
|
|
while ((pArgs = pf->get_next()))
|
||
|
|
pArgs->execute();
|
||
|
|
}
|
||
|
|
else if (dwWait == WAIT_OBJECT_0+1)
|
||
|
|
break;
|
||
|
|
else
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
// Window process for HWNDs created by this class.
|
||
|
|
static LRESULT CALLBACK ModuleWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
||
|
|
{
|
||
|
|
switch (uMsg)
|
||
|
|
{
|
||
|
|
case WM_EVENTPENDING:
|
||
|
|
{
|
||
|
|
EventArgs* pArgs = (EventArgs*)lParam;
|
||
|
|
if (pArgs)
|
||
|
|
pArgs->execute();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
// This function clears all WM_PAINT messages from the window
|
||
|
|
static BOOL CALLBACK EnumThreadWndProc(HWND hWnd, LPARAM lParam)
|
||
|
|
{
|
||
|
|
BOOL bRet = FALSE;
|
||
|
|
MSG msg = {0, 0, 0, 0, 0, {0,0}};
|
||
|
|
while((bRet = PeekMessage(&msg, hWnd, WM_PAINT, WM_PAINT, PM_REMOVE)))
|
||
|
|
{
|
||
|
|
if (bRet == -1)
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
TranslateMessage(&msg);
|
||
|
|
DispatchMessage(&msg);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
HINSTANCE m_hInstance; // HINSTANCE passed from DLLMain
|
||
|
|
HANDLE m_hThread;
|
||
|
|
DWORD m_dwThreadID;
|
||
|
|
HANDLE m_hExit;
|
||
|
|
HANDLE m_hFevalPending;
|
||
|
|
std::queue<FevalArgs*> m_fevalQueue;
|
||
|
|
HWND m_hWnd;
|
||
|
|
std::map<DWORD, HWND> m_ThreadData;
|
||
|
|
const char* m_errorMessage;
|
||
|
|
};
|
||
|
|
/*------------------------------------------------------------------------------
|
||
|
|
CMCLModule class definition. The CMCLModule class is used as the global
|
||
|
|
DLL controller object for all COM DLL's. Manages global lock count,
|
||
|
|
registration/de-registration, and class factory services for the DLL.
|
||
|
|
------------------------------------------------------------------------------*/
|
||
|
|
class CMCLModule
|
||
|
|
{
|
||
|
|
/*--------------------------------------
|
||
|
|
Construction/destruction
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
CMCLModule(bool with_events = false)
|
||
|
|
{
|
||
|
|
InitializeData(NULL, with_events);
|
||
|
|
m_pEvents = new mclEventMap();
|
||
|
|
}
|
||
|
|
CMCLModule(IMCLEventMap* pEvents, bool with_events = false)
|
||
|
|
{
|
||
|
|
InitializeData(NULL, with_events);
|
||
|
|
m_pEvents = pEvents;
|
||
|
|
}
|
||
|
|
CMCLModule(MCLInitializeInstancePtr pInit, MCLTerminateInstancePtr pTerm, bool with_events = false)
|
||
|
|
{
|
||
|
|
InitializeData(pTerm, with_events);
|
||
|
|
m_pInitialize = pInit;
|
||
|
|
m_pEvents = new mclEventMap();
|
||
|
|
}
|
||
|
|
CMCLModule(MCLInitializeInstancePtr pInit, MCLTerminateInstancePtr pTerm, IMCLEventMap* pEvents, bool with_events = false)
|
||
|
|
{
|
||
|
|
InitializeData(pTerm, with_events);
|
||
|
|
m_pInitialize = pInit;
|
||
|
|
m_pEvents = pEvents;
|
||
|
|
}
|
||
|
|
|
||
|
|
CMCLModule(MCLInitializeInstanceExPtr pInit, MCLTerminateInstancePtr pTerm, bool with_events = false)
|
||
|
|
{
|
||
|
|
InitializeData(pTerm, with_events);
|
||
|
|
m_pInitializeEx = pInit;
|
||
|
|
m_pEvents = new mclEventMap();
|
||
|
|
}
|
||
|
|
CMCLModule(MCLInitializeInstanceExPtr pInit, MCLTerminateInstancePtr pTerm, IMCLEventMap* pEvents, bool with_events = false)
|
||
|
|
{
|
||
|
|
InitializeData(pTerm, with_events);
|
||
|
|
m_pInitializeEx = pInit;
|
||
|
|
m_pEvents = pEvents;
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual ~CMCLModule()
|
||
|
|
{
|
||
|
|
if (m_pFeval)
|
||
|
|
delete m_pFeval;
|
||
|
|
if (m_pEvents)
|
||
|
|
delete m_pEvents;
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
Methods
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// Initialization/uninitialization method to be called from DLLMain
|
||
|
|
virtual BOOL InitMain(MCLOBJECT_MAP_ENTRY pobjectmap, const GUID* plibid, WORD wMajor, WORD wMinor,
|
||
|
|
HINSTANCE hInstance, DWORD dwReason, void* pv)
|
||
|
|
{
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
if (dwReason == DLL_PROCESS_ATTACH)
|
||
|
|
{
|
||
|
|
char szDllPath[_MAX_PATH];
|
||
|
|
char szDir[_MAX_DIR];
|
||
|
|
if (!Init(pobjectmap, hInstance, plibid, wMajor, wMinor))
|
||
|
|
return FALSE;
|
||
|
|
DisableThreadLibraryCalls(hInstance);
|
||
|
|
if (GetModuleFileName(hInstance, szDllPath, _MAX_PATH) > 0)
|
||
|
|
{
|
||
|
|
_splitpath(szDllPath, m_szPath, szDir, NULL, NULL);
|
||
|
|
strcat(m_szPath, szDir);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (dwReason == DLL_PROCESS_DETACH)
|
||
|
|
{
|
||
|
|
Term();
|
||
|
|
}
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
// Initializes the class with object, instance, and type lib info
|
||
|
|
virtual bool Init(MCLOBJECT_MAP_ENTRY pobjectmap, HINSTANCE hInstance, const GUID* plibid, WORD wMajor, WORD wMinor)
|
||
|
|
{
|
||
|
|
if (isInitialized())
|
||
|
|
return true;
|
||
|
|
m_hInstance = hInstance;
|
||
|
|
m_plibid = plibid;
|
||
|
|
m_wMajor = wMajor;
|
||
|
|
m_wMinor = wMinor;
|
||
|
|
m_pObjectMap = pobjectmap;
|
||
|
|
if (!m_pFeval->init(hInstance))
|
||
|
|
return false;
|
||
|
|
m_bInitialized = TRUE;
|
||
|
|
m_bCompatibilitySet = FALSE;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
// Uninitializes the class
|
||
|
|
virtual void Term()
|
||
|
|
{
|
||
|
|
if (!isInitialized())
|
||
|
|
return;
|
||
|
|
m_hInstance = NULL;
|
||
|
|
m_plibid = NULL;
|
||
|
|
m_wMajor = 0;
|
||
|
|
m_wMinor = 0;
|
||
|
|
m_bInitialized = FALSE;
|
||
|
|
}
|
||
|
|
// Returns the current lock count
|
||
|
|
long GetLockCount()
|
||
|
|
{
|
||
|
|
long cCount = 0;
|
||
|
|
InterlockedExchange(&cCount, m_cLockCount);
|
||
|
|
return cCount;
|
||
|
|
}
|
||
|
|
// Updates the registry for all classes in list and type lib. TRUE = Register, FALSE = Unregister
|
||
|
|
virtual HRESULT UpdateRegistry(BOOL bRegister)
|
||
|
|
{
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
|
||
|
|
if (!isInitialized())
|
||
|
|
return E_FAIL;
|
||
|
|
if (bRegister)
|
||
|
|
{
|
||
|
|
char szDllPath[MAX_PATH];
|
||
|
|
OLECHAR *wDllPath=NULL;
|
||
|
|
ITypeLib* pTypeLib = 0;
|
||
|
|
|
||
|
|
GetModuleFileName(m_hInstance, szDllPath, MAX_PATH);
|
||
|
|
try
|
||
|
|
{
|
||
|
|
int wLength = (int)strlen (szDllPath) + 1; // +1 means don't forget the terminating null character
|
||
|
|
wDllPath = new OLECHAR[wLength];
|
||
|
|
MultiByteToWideChar (
|
||
|
|
CP_ACP, // code page
|
||
|
|
MB_PRECOMPOSED, // character-type options
|
||
|
|
szDllPath, // address of string to map
|
||
|
|
wLength, // number of characters in string
|
||
|
|
wDllPath, // address of wide-character buffer
|
||
|
|
wLength); // size of buffer
|
||
|
|
hr = LoadTypeLibEx(wDllPath, REGKIND_REGISTER, &pTypeLib);
|
||
|
|
if(FAILED(hr)) {
|
||
|
|
delete wDllPath;
|
||
|
|
wDllPath = NULL;
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
pTypeLib->Release();
|
||
|
|
if (m_pObjectMap == NULL)
|
||
|
|
return S_OK;
|
||
|
|
int i = 0;
|
||
|
|
while (m_pObjectMap[i].pclsid != NULL)
|
||
|
|
{
|
||
|
|
hr = m_pObjectMap[i].pfnRegisterClass(m_plibid, m_wMajor, m_wMinor, m_pObjectMap[i].lpszFriendlyName,
|
||
|
|
m_pObjectMap[i].lpszVerIndProgID, m_pObjectMap[i].lpszProgID, szDllPath);
|
||
|
|
if (FAILED(hr))
|
||
|
|
return hr;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
delete wDllPath;
|
||
|
|
wDllPath = NULL;
|
||
|
|
}
|
||
|
|
catch(...) {
|
||
|
|
if(wDllPath != NULL) {
|
||
|
|
delete wDllPath;
|
||
|
|
wDllPath = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
#ifdef _WIN64
|
||
|
|
hr = UnRegisterTypeLib(*m_plibid, m_wMajor, m_wMinor, LANG_NEUTRAL, SYS_WIN64);
|
||
|
|
//since we add a "win32" key under typelib at the time of registration,
|
||
|
|
//we need to remove them here.
|
||
|
|
hr = UnRegisterTypeLib(*m_plibid, m_wMajor, m_wMinor, LANG_NEUTRAL, SYS_WIN32);
|
||
|
|
#else
|
||
|
|
hr = UnRegisterTypeLib(*m_plibid, m_wMajor, m_wMinor, LANG_NEUTRAL, SYS_WIN32);
|
||
|
|
#endif
|
||
|
|
int i = 0;
|
||
|
|
while (m_pObjectMap[i].pclsid != NULL)
|
||
|
|
{
|
||
|
|
hr = m_pObjectMap[i].pfnUnregisterClass(m_pObjectMap[i].lpszVerIndProgID, m_pObjectMap[i].lpszProgID);
|
||
|
|
if (FAILED(hr))
|
||
|
|
return hr;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
// Returns a class factory pointer for the specified CLSID
|
||
|
|
virtual HRESULT GetClassObject(REFCLSID clsid, REFIID iid, void** ppv)
|
||
|
|
{
|
||
|
|
if (!mclmcrInitialize2(mclStandaloneContainer))
|
||
|
|
return CLASS_E_CLASSNOTAVAILABLE;
|
||
|
|
|
||
|
|
//COM application should be run in compatibility mode
|
||
|
|
if(!m_bCompatibilitySet)
|
||
|
|
{
|
||
|
|
mclSetInterleavedCompatibility(true);
|
||
|
|
m_bCompatibilitySet = TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!isInitialized())
|
||
|
|
return CLASS_E_CLASSNOTAVAILABLE;
|
||
|
|
if (m_pObjectMap == NULL)
|
||
|
|
return CLASS_E_CLASSNOTAVAILABLE;
|
||
|
|
int i = 0;
|
||
|
|
while (m_pObjectMap[i].pclsid != NULL)
|
||
|
|
{
|
||
|
|
if (*(m_pObjectMap[i].pclsid) == clsid)
|
||
|
|
return m_pObjectMap[i].pfnGetClassObject(clsid, iid, ppv);
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
return CLASS_E_CLASSNOTAVAILABLE;
|
||
|
|
}
|
||
|
|
// Increments the lock count
|
||
|
|
long Lock() {return InterlockedIncrement(&m_cLockCount);}
|
||
|
|
// Decrements the lock count
|
||
|
|
long Unlock() {return InterlockedDecrement(&m_cLockCount);}
|
||
|
|
// Returns a new type info pointer for the module's type lib
|
||
|
|
HRESULT GetTypeInfo(REFGUID riid, ITypeInfo** ppTypeInfo)
|
||
|
|
{
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
ITypeLib* pTypeLib = NULL;
|
||
|
|
|
||
|
|
if (!isInitialized())
|
||
|
|
return E_FAIL;
|
||
|
|
if(FAILED(hr = LoadRegTypeLib(*m_plibid, m_wMajor, m_wMinor, LANG_NEUTRAL, &pTypeLib)))
|
||
|
|
return hr;
|
||
|
|
hr = pTypeLib->GetTypeInfoOfGuid(riid, ppTypeInfo);
|
||
|
|
pTypeLib->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
// Returns the progid for a given clsid, returns null if invalid clsid
|
||
|
|
const char* GetProgID(REFCLSID clsid)
|
||
|
|
{
|
||
|
|
int i = 0;
|
||
|
|
while (m_pObjectMap[i].pclsid != NULL)
|
||
|
|
{
|
||
|
|
if (*(m_pObjectMap[i].pclsid) == clsid)
|
||
|
|
return m_pObjectMap[i].lpszProgID;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
// Initializes the MCR instance. Called by object constructors
|
||
|
|
virtual bool InitializeComponentInstance(HMCRINSTANCE* inst)
|
||
|
|
{
|
||
|
|
if (!m_pInitialize || !inst)
|
||
|
|
return false;
|
||
|
|
return m_pInitialize(inst, getPath());
|
||
|
|
}
|
||
|
|
// Initializes the MCR instance with CTF embedded in resource file.
|
||
|
|
// Called by object constructors
|
||
|
|
virtual bool InitializeComponentInstanceEx(HMCRINSTANCE* inst)
|
||
|
|
{
|
||
|
|
if (!m_pInitializeEx || !inst)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
DWORD ctfSize = 0;
|
||
|
|
char* ctfData = GetEmbeddedCtf(ctfSize);
|
||
|
|
if(ctfData == NULL || ctfSize <= 0)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
mclCtfStream ctfStream = mclGetStreamFromArraySrc(ctfData, ctfSize);
|
||
|
|
bool bResult = m_pInitializeEx(inst, getPath(), ctfStream);
|
||
|
|
|
||
|
|
if(ctfStream != NULL)
|
||
|
|
{
|
||
|
|
mclDestroyStream(ctfStream);
|
||
|
|
}
|
||
|
|
return bResult;
|
||
|
|
}
|
||
|
|
// Terminates an MCR instance. Called by object destructors.
|
||
|
|
virtual bool TerminateInstance(HMCRINSTANCE* inst)
|
||
|
|
{
|
||
|
|
if (!m_pTerminate || !inst)
|
||
|
|
return false;
|
||
|
|
return m_pTerminate(inst);
|
||
|
|
}
|
||
|
|
virtual BOOL isInitialized()
|
||
|
|
{
|
||
|
|
return m_bInitialized;
|
||
|
|
}
|
||
|
|
virtual void setInitialized(BOOL bInit)
|
||
|
|
{
|
||
|
|
m_bInitialized = bInit;
|
||
|
|
}
|
||
|
|
// Returns the path to the Dll
|
||
|
|
const char* getPath()
|
||
|
|
{
|
||
|
|
return m_szPath;
|
||
|
|
}
|
||
|
|
// Returns a reference to the Event map
|
||
|
|
virtual IMCLEventMap* getEventMap()
|
||
|
|
{
|
||
|
|
return m_pEvents;
|
||
|
|
}
|
||
|
|
virtual bool Feval(HMCRINSTANCE hinst, const char* name, int nlhs, mxArray** plhs, int nrhs, mxArray** prhs)
|
||
|
|
{
|
||
|
|
return m_pFeval->Feval(hinst, name, nlhs, plhs, nrhs, prhs);
|
||
|
|
}
|
||
|
|
virtual const char* getErrorMessage()
|
||
|
|
{
|
||
|
|
return m_pFeval->getErrorMessage();
|
||
|
|
}
|
||
|
|
virtual void RaiseEvent(OLECHAR* lpwszName, long dispid, IDispatch* pDisp, DISPPARAMS* pDispParams)
|
||
|
|
{
|
||
|
|
m_pFeval->RaiseEvent(lpwszName, dispid, pDisp, pDispParams);
|
||
|
|
}
|
||
|
|
|
||
|
|
char* GetEmbeddedCtf(DWORD& ctfSize)
|
||
|
|
{
|
||
|
|
DWORD err = 0;
|
||
|
|
ctfSize = 0;
|
||
|
|
|
||
|
|
HRSRC rsrc = FindResource(m_hInstance, MAKEINTRESOURCE(2),"RT_RCDATA");
|
||
|
|
if(!rsrc)
|
||
|
|
{
|
||
|
|
err = GetLastError();
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
ctfSize = SizeofResource(m_hInstance, rsrc);
|
||
|
|
HGLOBAL MemoryHandle = LoadResource(m_hInstance, rsrc);
|
||
|
|
if(MemoryHandle == NULL)
|
||
|
|
{
|
||
|
|
err = GetLastError();
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
char *ctfData = (char *) LockResource(MemoryHandle);
|
||
|
|
if(ctfData == NULL)
|
||
|
|
{
|
||
|
|
err = GetLastError();
|
||
|
|
}
|
||
|
|
|
||
|
|
return ctfData;
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
void InitializeData(MCLTerminateInstancePtr pTerm, bool with_events)
|
||
|
|
{
|
||
|
|
m_cLockCount = 0;
|
||
|
|
m_hInstance = NULL;
|
||
|
|
m_pObjectMap = NULL;
|
||
|
|
m_plibid = NULL;
|
||
|
|
m_wMajor = 0;
|
||
|
|
m_wMinor = 0;
|
||
|
|
m_bInitialized = FALSE;
|
||
|
|
m_szPath[0] = '\0';
|
||
|
|
m_pTerminate = pTerm;
|
||
|
|
m_pFeval = (with_events ? static_cast<IMCLFeval*>(new mclFevalWithEvents())
|
||
|
|
: static_cast<IMCLFeval*>(new mclSimpleFeval()));
|
||
|
|
}
|
||
|
|
|
||
|
|
/*--------------------------------------
|
||
|
|
Properties
|
||
|
|
--------------------------------------*/
|
||
|
|
protected:
|
||
|
|
MCLInitializeInstancePtr m_pInitialize; // Function used to create an MCR instance
|
||
|
|
MCLInitializeInstanceExPtr m_pInitializeEx; // Function used to create an MCR instance with embedded ctf
|
||
|
|
MCLTerminateInstancePtr m_pTerminate; // Function to destroy an MCR instance
|
||
|
|
private:
|
||
|
|
long m_cLockCount; // Lock count on module
|
||
|
|
HINSTANCE m_hInstance; // HINSTANCE passed from DLLMain
|
||
|
|
MCLOBJECT_MAP_ENTRY m_pObjectMap; // Object info array
|
||
|
|
const GUID* m_plibid; // LIBID of type lib
|
||
|
|
BOOL m_bInitialized; // Is-initialized flag
|
||
|
|
BOOL m_bCompatibilitySet; // Set-compatibility mode flag
|
||
|
|
WORD m_wMajor; // Major rev number of type lib
|
||
|
|
WORD m_wMinor; // Minor rev number of type lib
|
||
|
|
char m_szPath[_MAX_PATH]; // Stores the location of the Dll
|
||
|
|
IMCLEventMap* m_pEvents; // event map
|
||
|
|
IMCLFeval* m_pFeval;
|
||
|
|
};
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------------
|
||
|
|
CMCLSingleModule class definition. The CMCLSingleModule class specializes
|
||
|
|
the CMCLModule class for the case of a singleton MCR instance.
|
||
|
|
------------------------------------------------------------------------------*/
|
||
|
|
class CMCLSingleModule : public CMCLModule
|
||
|
|
{
|
||
|
|
/*--------------------------------------
|
||
|
|
Construction/destruction
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
CMCLSingleModule(bool with_events = false) : CMCLModule(new mclSingleEventMap(), with_events), m_mcrInstance(NULL)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
CMCLSingleModule(MCLInitializeInstancePtr pInit, MCLTerminateInstancePtr pTerm, bool with_events = false)
|
||
|
|
: CMCLModule(pInit, pTerm, new mclSingleEventMap(), with_events), m_mcrInstance(NULL)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
CMCLSingleModule(MCLInitializeInstanceExPtr pInit, MCLTerminateInstancePtr pTerm, bool with_events = false)
|
||
|
|
: CMCLModule(pInit, pTerm, new mclSingleEventMap(), with_events), m_mcrInstance(NULL)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
virtual ~CMCLSingleModule()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
Methods
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// Uninitializes the class
|
||
|
|
void Term()
|
||
|
|
{
|
||
|
|
if (!isInitialized())
|
||
|
|
return;
|
||
|
|
CMCLModule::Term();
|
||
|
|
ModuleLock lock;
|
||
|
|
if (m_mcrInstance)
|
||
|
|
m_mcrInstance = NULL;
|
||
|
|
}
|
||
|
|
// Initializes the MCR instance. Called by object constructors
|
||
|
|
bool InitializeComponentInstance(HMCRINSTANCE* inst)
|
||
|
|
{
|
||
|
|
if (!inst)
|
||
|
|
return false;
|
||
|
|
bool ret = false;
|
||
|
|
ModuleLock lock;
|
||
|
|
if (!m_mcrInstance)
|
||
|
|
{
|
||
|
|
if (!m_pInitialize)
|
||
|
|
return false;
|
||
|
|
ret = m_pInitialize(&m_mcrInstance, getPath());
|
||
|
|
}
|
||
|
|
*inst = m_mcrInstance;
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
// Initializes the MCR instance with CTF embedded in resource file.
|
||
|
|
// Called by object constructors
|
||
|
|
bool InitializeComponentInstanceEx(HMCRINSTANCE* inst)
|
||
|
|
{
|
||
|
|
if (!inst)
|
||
|
|
return false;
|
||
|
|
bool ret = false;
|
||
|
|
ModuleLock lock;
|
||
|
|
if (!m_mcrInstance)
|
||
|
|
{
|
||
|
|
if (!m_pInitializeEx)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
DWORD ctfSize = 0;
|
||
|
|
char* ctfData = GetEmbeddedCtf(ctfSize);
|
||
|
|
if(ctfData == NULL || ctfSize <= 0)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
mclCtfStream ctfStream = mclGetStreamFromArraySrc(ctfData, ctfSize);
|
||
|
|
ret = m_pInitializeEx(&m_mcrInstance, getPath(), ctfStream);
|
||
|
|
|
||
|
|
if(ctfStream != NULL)
|
||
|
|
{
|
||
|
|
mclDestroyStream(ctfStream);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
*inst = m_mcrInstance;
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
// Terminates an MCR instance. Called by object destructors.
|
||
|
|
bool TerminateInstance(HMCRINSTANCE* inst)
|
||
|
|
{
|
||
|
|
if (!inst)
|
||
|
|
return false;
|
||
|
|
*inst = NULL;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
Properties
|
||
|
|
--------------------------------------*/
|
||
|
|
private:
|
||
|
|
HMCRINSTANCE m_mcrInstance; // Module-level MCR instance
|
||
|
|
};
|
||
|
|
|
||
|
|
class mclmxarray_list {
|
||
|
|
int count;
|
||
|
|
mxArray **list;
|
||
|
|
public:
|
||
|
|
mclmxarray_list( int icount, mxArray **ilist ) : count(icount), list(ilist) { }
|
||
|
|
~mclmxarray_list( ) {
|
||
|
|
for (int i =0; i<count; i++) {
|
||
|
|
mxDestroyArray( list[i] );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
class CMCLEnumConnectionPoints : public IEnumConnectionPoints
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
/*--------------------------------------
|
||
|
|
Construction/destruction
|
||
|
|
--------------------------------------*/
|
||
|
|
// CMCLEnumConnectionPoints default constructor
|
||
|
|
CMCLEnumConnectionPoints()
|
||
|
|
{
|
||
|
|
m_cRef = 1;
|
||
|
|
m_nIndex = 0;
|
||
|
|
m_pThis = NULL;
|
||
|
|
m_rgpcn = NULL;
|
||
|
|
m_cConnections = 0;
|
||
|
|
}
|
||
|
|
// CMCLEnumConnectionPoints constructor from container reference and array of connection points
|
||
|
|
CMCLEnumConnectionPoints(IUnknown* pThis, ULONG cConnections, IConnectionPoint** rgpcn)
|
||
|
|
{
|
||
|
|
m_cRef = 1;
|
||
|
|
m_nIndex = 0;
|
||
|
|
m_pThis = pThis;
|
||
|
|
m_rgpcn = NULL;
|
||
|
|
m_cConnections = 0;
|
||
|
|
if (cConnections > 0 && rgpcn != NULL)
|
||
|
|
{
|
||
|
|
m_cConnections = cConnections;
|
||
|
|
m_rgpcn = new IConnectionPoint*[m_cConnections];
|
||
|
|
if (m_rgpcn != NULL)
|
||
|
|
{
|
||
|
|
for(ULONG i=0;i<cConnections;i++)
|
||
|
|
{
|
||
|
|
m_rgpcn[i] = NULL;
|
||
|
|
if (rgpcn[i] != NULL)
|
||
|
|
rgpcn[i]->QueryInterface(IID_IConnectionPoint, (void**)&m_rgpcn[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
m_cConnections = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// CMCLEnumConnectionPoints destructor
|
||
|
|
virtual ~CMCLEnumConnectionPoints()
|
||
|
|
{
|
||
|
|
if (m_rgpcn != NULL)
|
||
|
|
{
|
||
|
|
for (size_t i=0;i<m_cConnections;i++)
|
||
|
|
{
|
||
|
|
if (m_rgpcn[i] != NULL)
|
||
|
|
m_rgpcn[i]->Release();
|
||
|
|
}
|
||
|
|
delete [] m_rgpcn;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
IUnknown implementation
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// IUnknown::AddRef implementation
|
||
|
|
ULONG __stdcall AddRef()
|
||
|
|
{
|
||
|
|
if (m_pThis != NULL)
|
||
|
|
m_pThis->AddRef();
|
||
|
|
return InterlockedIncrement(&m_cRef);
|
||
|
|
}
|
||
|
|
// IUnknown::Release implementation
|
||
|
|
ULONG __stdcall Release()
|
||
|
|
{
|
||
|
|
if (m_pThis != NULL)
|
||
|
|
m_pThis->Release();
|
||
|
|
ULONG cRef = InterlockedDecrement(&m_cRef);
|
||
|
|
if(cRef != 0)
|
||
|
|
return cRef;
|
||
|
|
delete this;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
// IUnknown::QueryInterface implementation
|
||
|
|
HRESULT __stdcall QueryInterface(REFIID riid, void** ppv)
|
||
|
|
{
|
||
|
|
if(riid == IID_IEnumConnectionPoints)
|
||
|
|
*ppv = static_cast<IEnumConnectionPoints*>(this);
|
||
|
|
else if(riid == IID_IUnknown)
|
||
|
|
*ppv = static_cast<IUnknown*>(this);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*ppv = NULL;
|
||
|
|
return E_NOINTERFACE;
|
||
|
|
}
|
||
|
|
AddRef();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
IEnumConnectionPoints implementation
|
||
|
|
--------------------------------------*/
|
||
|
|
// IEnumConnectionPoints::Next implementation
|
||
|
|
HRESULT __stdcall Next(ULONG cConnections, IConnectionPoint** rgpcn, ULONG* pcFetched)
|
||
|
|
{
|
||
|
|
LONG nIndex = 0;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
|
||
|
|
if(rgpcn == NULL || pcFetched == NULL)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
*pcFetched = 0;
|
||
|
|
if (cConnections == 0)
|
||
|
|
return S_OK;
|
||
|
|
for (ULONG i=0;i<cConnections;i++)
|
||
|
|
{
|
||
|
|
InterlockedExchange(&nIndex, m_nIndex);
|
||
|
|
if (nIndex >= (LONG)m_cConnections)
|
||
|
|
{
|
||
|
|
hr = S_FALSE;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
rgpcn[i] = m_rgpcn[nIndex];
|
||
|
|
if(rgpcn[i] != NULL)
|
||
|
|
rgpcn[i]->AddRef();
|
||
|
|
(*pcFetched)++;
|
||
|
|
InterlockedIncrement(&m_nIndex);
|
||
|
|
}
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
// IEnumConnectionPoints::Skip implementation
|
||
|
|
HRESULT __stdcall Skip(ULONG cConnections)
|
||
|
|
{
|
||
|
|
LONG nIndex = 0;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
|
||
|
|
InterlockedExchange(&nIndex, m_nIndex);
|
||
|
|
if (nIndex >= (LONG)m_cConnections)
|
||
|
|
return S_FALSE;
|
||
|
|
for (ULONG i=0;i<cConnections;i++)
|
||
|
|
{
|
||
|
|
nIndex = InterlockedIncrement(&m_nIndex);
|
||
|
|
if (nIndex >= (LONG)m_cConnections)
|
||
|
|
{
|
||
|
|
hr = S_FALSE;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
// IEnumConnectionPoints::Reset implementation
|
||
|
|
HRESULT __stdcall Reset()
|
||
|
|
{
|
||
|
|
InterlockedExchange(&m_nIndex, 0);
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
// IEnumConnectionPoints::Clone implementation
|
||
|
|
HRESULT __stdcall Clone(IEnumConnectionPoints** ppEnum)
|
||
|
|
{
|
||
|
|
CMCLEnumConnectionPoints* pNew = NULL;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
|
||
|
|
if(ppEnum == NULL)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
*ppEnum = NULL;
|
||
|
|
pNew = new CMCLEnumConnectionPoints(m_pThis, (ULONG)m_cConnections, m_rgpcn);
|
||
|
|
if(pNew == NULL)
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
pNew->m_nIndex = m_nIndex;
|
||
|
|
hr = pNew->QueryInterface(IID_IEnumConnectionPoints, (void**)ppEnum);
|
||
|
|
pNew->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
CMCLEnumConnectionPoints Properties
|
||
|
|
--------------------------------------*/
|
||
|
|
private:
|
||
|
|
long m_cRef;
|
||
|
|
IUnknown* m_pThis; // Containing IUnknown for ref counting
|
||
|
|
long m_nIndex; // Index of current element
|
||
|
|
IConnectionPoint** m_rgpcn; // Array of connection points
|
||
|
|
ULONG m_cConnections; // Number of connection points in the array
|
||
|
|
};
|
||
|
|
|
||
|
|
class CMCLEnumConnections : public IEnumConnections
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
/*--------------------------------------
|
||
|
|
Construction/destruction
|
||
|
|
--------------------------------------*/
|
||
|
|
// CMCLEnumConnections default constructor
|
||
|
|
CMCLEnumConnections()
|
||
|
|
{
|
||
|
|
m_cRef = 1;
|
||
|
|
m_nIndex = 0;
|
||
|
|
m_pThis = NULL;
|
||
|
|
m_rgpcd = NULL;
|
||
|
|
m_cConnections = 0;
|
||
|
|
}
|
||
|
|
// CMCLEnumConnections constructor from parent connection point reference and array of CONNECTDATA's
|
||
|
|
CMCLEnumConnections(IUnknown* pThis, ULONG cConnections, CONNECTDATA* rgpcd)
|
||
|
|
{
|
||
|
|
m_cRef = 1;
|
||
|
|
m_nIndex = 0;
|
||
|
|
m_pThis = pThis;
|
||
|
|
m_rgpcd = NULL;
|
||
|
|
m_cConnections = 0;
|
||
|
|
if (cConnections > 0 && rgpcd != NULL)
|
||
|
|
{
|
||
|
|
m_cConnections = cConnections;
|
||
|
|
m_rgpcd = new CONNECTDATA[m_cConnections];
|
||
|
|
if (m_rgpcd != NULL)
|
||
|
|
{
|
||
|
|
for(ULONG i=0;i<cConnections;i++)
|
||
|
|
{
|
||
|
|
m_rgpcd[i] = rgpcd[i];
|
||
|
|
if (m_rgpcd[i].pUnk != NULL)
|
||
|
|
m_rgpcd[i].pUnk->AddRef();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
m_cConnections = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// CMCLEnumConnections constructor from parent connection point reference and vector class of CONNECTDATA's
|
||
|
|
CMCLEnumConnections(IUnknown* pThis, std::vector<CONNECTDATA*>& vecpcd)
|
||
|
|
{
|
||
|
|
std::vector<CONNECTDATA*>::iterator it;
|
||
|
|
CONNECTDATA* pConnData = NULL;
|
||
|
|
int i = 0;
|
||
|
|
|
||
|
|
m_cRef = 1;
|
||
|
|
m_nIndex = 0;
|
||
|
|
m_pThis = pThis;
|
||
|
|
m_rgpcd = NULL;
|
||
|
|
m_cConnections = 0;
|
||
|
|
if (vecpcd.size() > 0)
|
||
|
|
{
|
||
|
|
m_cConnections = (ULONG)vecpcd.size();
|
||
|
|
m_rgpcd = new CONNECTDATA[m_cConnections];
|
||
|
|
if (m_rgpcd != NULL)
|
||
|
|
{
|
||
|
|
for(it = vecpcd.begin(); it != vecpcd.end(); it++)
|
||
|
|
{
|
||
|
|
pConnData = *it;
|
||
|
|
if (pConnData != NULL)
|
||
|
|
{
|
||
|
|
m_rgpcd[i] = *pConnData;
|
||
|
|
if (m_rgpcd[i].pUnk != NULL)
|
||
|
|
m_rgpcd[i].pUnk->AddRef();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_rgpcd[i].pUnk = NULL;
|
||
|
|
m_rgpcd[i].dwCookie = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
m_cConnections = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// CMCLEnumConnections destructor
|
||
|
|
virtual ~CMCLEnumConnections()
|
||
|
|
{
|
||
|
|
if (m_rgpcd != NULL)
|
||
|
|
{
|
||
|
|
for (size_t i=0;i<m_cConnections;i++)
|
||
|
|
{
|
||
|
|
if (m_rgpcd[i].pUnk != NULL)
|
||
|
|
m_rgpcd[i].pUnk->Release();
|
||
|
|
}
|
||
|
|
delete [] m_rgpcd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
IUnknown implementation
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// IUnknown::AddRef implementation
|
||
|
|
ULONG __stdcall AddRef()
|
||
|
|
{
|
||
|
|
if (m_pThis != NULL)
|
||
|
|
m_pThis->AddRef();
|
||
|
|
return InterlockedIncrement(&m_cRef);
|
||
|
|
}
|
||
|
|
// IUnknown::Release implementation
|
||
|
|
ULONG __stdcall Release()
|
||
|
|
{
|
||
|
|
if (m_pThis != NULL)
|
||
|
|
m_pThis->Release();
|
||
|
|
|
||
|
|
ULONG cRef = InterlockedDecrement(&m_cRef);
|
||
|
|
|
||
|
|
if(cRef != 0)
|
||
|
|
return cRef;
|
||
|
|
|
||
|
|
delete this;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
// IUnknown::QueryInterface implementation
|
||
|
|
HRESULT __stdcall QueryInterface(REFIID riid, void** ppv)
|
||
|
|
{
|
||
|
|
if(riid == IID_IEnumConnections)
|
||
|
|
*ppv = static_cast<IEnumConnections*>(this);
|
||
|
|
else if(riid == IID_IUnknown)
|
||
|
|
*ppv = static_cast<IUnknown*>(this);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*ppv = NULL;
|
||
|
|
return E_NOINTERFACE;
|
||
|
|
}
|
||
|
|
AddRef();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
IEnumConnections implementation
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// IEnumConnections::Next implementation
|
||
|
|
HRESULT __stdcall Next(ULONG cConnections, CONNECTDATA* rgpcd, ULONG* pcFetched)
|
||
|
|
{
|
||
|
|
LONG nIndex = 0;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
|
||
|
|
if(rgpcd == NULL || pcFetched == NULL)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
*pcFetched = 0;
|
||
|
|
if (cConnections == 0)
|
||
|
|
return S_OK;
|
||
|
|
for (ULONG i=0;i<cConnections;i++)
|
||
|
|
{
|
||
|
|
InterlockedExchange(&nIndex, m_nIndex);
|
||
|
|
if (nIndex >= (LONG)m_cConnections)
|
||
|
|
{
|
||
|
|
hr = S_FALSE;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
rgpcd[i] = m_rgpcd[nIndex];
|
||
|
|
if(rgpcd[i].pUnk != NULL)
|
||
|
|
rgpcd[i].pUnk->AddRef();
|
||
|
|
(*pcFetched)++;
|
||
|
|
InterlockedIncrement(&m_nIndex);
|
||
|
|
}
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
// IEnumConnections::Skip implementation
|
||
|
|
HRESULT __stdcall Skip(ULONG cConnections)
|
||
|
|
{
|
||
|
|
LONG nIndex = 0;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
|
||
|
|
InterlockedExchange(&nIndex, m_nIndex);
|
||
|
|
if (nIndex >= (LONG)m_cConnections)
|
||
|
|
return S_FALSE;
|
||
|
|
for (ULONG i=0;i<cConnections;i++)
|
||
|
|
{
|
||
|
|
nIndex = InterlockedIncrement(&m_nIndex);
|
||
|
|
if (nIndex >= (LONG)m_cConnections)
|
||
|
|
{
|
||
|
|
hr = S_FALSE;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
// IEnumConnections::Reset implementation
|
||
|
|
HRESULT __stdcall Reset()
|
||
|
|
{
|
||
|
|
InterlockedExchange(&m_nIndex, 0);
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
// IEnumConnections::Clone implementation
|
||
|
|
HRESULT __stdcall Clone(IEnumConnections** ppEnum)
|
||
|
|
{
|
||
|
|
CMCLEnumConnections* pNew = NULL;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
|
||
|
|
if(ppEnum == NULL)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
*ppEnum = NULL;
|
||
|
|
pNew = new CMCLEnumConnections(m_pThis,(ULONG) m_cConnections, m_rgpcd);
|
||
|
|
if(pNew == NULL)
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
pNew->m_nIndex = m_nIndex;
|
||
|
|
hr = pNew->QueryInterface(IID_IEnumConnections, (void**)ppEnum);
|
||
|
|
pNew->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
CMCLEnumConnectionPoints Properties
|
||
|
|
--------------------------------------*/
|
||
|
|
private:
|
||
|
|
long m_cRef;
|
||
|
|
IUnknown* m_pThis; // Containing IUnknown for ref counting
|
||
|
|
long m_nIndex; // Index of current element
|
||
|
|
ULONG m_cConnections; // Number of connections in the array
|
||
|
|
CONNECTDATA* m_rgpcd; // Array of connections
|
||
|
|
};
|
||
|
|
|
||
|
|
// Globals
|
||
|
|
extern CMCLModule* g_pModule;
|
||
|
|
|
||
|
|
template<const IID* piid>
|
||
|
|
class CMCLConnectionPointImpl : public IConnectionPoint
|
||
|
|
{
|
||
|
|
/*--------------------------------------
|
||
|
|
Construction/destruction
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// CMCLConnectionPointImpl default constructor
|
||
|
|
CMCLConnectionPointImpl()
|
||
|
|
{
|
||
|
|
m_cRef = 1;
|
||
|
|
m_pCPC = NULL;
|
||
|
|
m_nNextCookie = 0;
|
||
|
|
}
|
||
|
|
// CMCLConnectionPointImpl constructor from container reference
|
||
|
|
CMCLConnectionPointImpl(IConnectionPointContainer* pCPC)
|
||
|
|
{
|
||
|
|
m_cRef = 1;
|
||
|
|
m_pCPC = NULL;
|
||
|
|
m_nNextCookie = 0;
|
||
|
|
m_pCPC = pCPC;
|
||
|
|
}
|
||
|
|
// CMCLConnectionPointImpl destructor
|
||
|
|
virtual ~CMCLConnectionPointImpl()
|
||
|
|
{
|
||
|
|
std::vector<CONNECTDATA*>::iterator it;
|
||
|
|
CONNECTDATA* pConnData = NULL;
|
||
|
|
|
||
|
|
for(it = m_vecpcd.begin(); it != m_vecpcd.end(); it++)
|
||
|
|
{
|
||
|
|
pConnData = *it;
|
||
|
|
if (pConnData != NULL)
|
||
|
|
{
|
||
|
|
if (pConnData->pUnk != NULL)
|
||
|
|
pConnData->pUnk->Release();
|
||
|
|
delete pConnData;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
m_vecpcd.clear();
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
IUnknown implementation
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// IUnknown::AddRef implementation
|
||
|
|
ULONG __stdcall AddRef()
|
||
|
|
{
|
||
|
|
return InterlockedIncrement(&m_cRef);
|
||
|
|
}
|
||
|
|
// IUnknown::Release implementation
|
||
|
|
ULONG __stdcall Release()
|
||
|
|
{
|
||
|
|
ULONG cRef = InterlockedDecrement(&m_cRef);
|
||
|
|
if(cRef != 0)
|
||
|
|
return cRef;
|
||
|
|
delete this;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
// IUnknown::QueryInterface implementation
|
||
|
|
HRESULT __stdcall QueryInterface(REFIID riid, void** ppv)
|
||
|
|
{
|
||
|
|
if(riid == IID_IConnectionPoint)
|
||
|
|
*ppv = static_cast<IConnectionPoint*>(this);
|
||
|
|
else if(riid == IID_IUnknown)
|
||
|
|
*ppv = static_cast<IUnknown*>(this);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*ppv = NULL;
|
||
|
|
return E_NOINTERFACE;
|
||
|
|
}
|
||
|
|
AddRef();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*--------------------------------------
|
||
|
|
IConnectionPoint implementation
|
||
|
|
--------------------------------------*/
|
||
|
|
// IConnectionPoint::GetConnectionInterface implementation
|
||
|
|
HRESULT __stdcall GetConnectionInterface(IID *pIID)
|
||
|
|
{
|
||
|
|
if (pIID == NULL)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
*pIID = *piid;
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
// IConnectionPoint::GetConnectionPointContainer implementation
|
||
|
|
HRESULT __stdcall GetConnectionPointContainer(IConnectionPointContainer** ppCPC)
|
||
|
|
{
|
||
|
|
if (ppCPC == NULL)
|
||
|
|
return E_POINTER;
|
||
|
|
if (m_pCPC == NULL)
|
||
|
|
return E_UNEXPECTED;
|
||
|
|
*ppCPC = m_pCPC;
|
||
|
|
if (*ppCPC != NULL)
|
||
|
|
(*ppCPC)->AddRef();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
// IConnectionPoint::Advise implementation
|
||
|
|
HRESULT __stdcall Advise(IUnknown* pUnk, DWORD* pdwCookie)
|
||
|
|
{
|
||
|
|
IUnknown* pSink = NULL;
|
||
|
|
long nCookie = 0;
|
||
|
|
CONNECTDATA* pConnData = NULL;
|
||
|
|
|
||
|
|
ModuleLock lock;
|
||
|
|
if (pUnk == NULL || pdwCookie == NULL)
|
||
|
|
return E_POINTER;
|
||
|
|
*pdwCookie = 0;
|
||
|
|
if(FAILED(pUnk->QueryInterface(*piid, (void**)&pSink)))
|
||
|
|
return CONNECT_E_CANNOTCONNECT;
|
||
|
|
pConnData = new CONNECTDATA;
|
||
|
|
if (pConnData == NULL)
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
nCookie = InterlockedIncrement(&m_nNextCookie);
|
||
|
|
pConnData->dwCookie = (DWORD)nCookie;
|
||
|
|
pConnData->pUnk = pUnk;
|
||
|
|
m_vecpcd.push_back(pConnData);
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
// IConnectionPoint::Unadvise implementation
|
||
|
|
HRESULT __stdcall Unadvise(DWORD dwCookie)
|
||
|
|
{
|
||
|
|
std::vector<CONNECTDATA*>::iterator it;
|
||
|
|
CONNECTDATA* pConnData = NULL;
|
||
|
|
bool bFound = false;
|
||
|
|
|
||
|
|
ModuleLock lock;
|
||
|
|
if(dwCookie == 0)
|
||
|
|
return CONNECT_E_NOCONNECTION;
|
||
|
|
for(it = m_vecpcd.begin(); it != m_vecpcd.end(); it++)
|
||
|
|
{
|
||
|
|
pConnData = *it;
|
||
|
|
if (pConnData != NULL)
|
||
|
|
{
|
||
|
|
if (pConnData->dwCookie == dwCookie)
|
||
|
|
{
|
||
|
|
bFound = true;
|
||
|
|
if (pConnData->pUnk != NULL)
|
||
|
|
pConnData->pUnk->Release();
|
||
|
|
delete pConnData;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (bFound)
|
||
|
|
{
|
||
|
|
m_vecpcd.erase(it);
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
return CONNECT_E_NOCONNECTION;
|
||
|
|
}
|
||
|
|
// IConnectionPoint::EnumConnections implementation
|
||
|
|
HRESULT __stdcall EnumConnections(IEnumConnections** ppEnum)
|
||
|
|
{
|
||
|
|
CMCLEnumConnections* pEnum = NULL;
|
||
|
|
|
||
|
|
ModuleLock lock;
|
||
|
|
if (ppEnum == NULL)
|
||
|
|
return E_POINTER;
|
||
|
|
*ppEnum = NULL;
|
||
|
|
pEnum = new CMCLEnumConnections(this, m_vecpcd);
|
||
|
|
if (pEnum == NULL)
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
if (FAILED(pEnum->QueryInterface(IID_IEnumConnections, (void**)ppEnum)))
|
||
|
|
return E_UNEXPECTED;
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
CConnectionPoint Properties
|
||
|
|
--------------------------------------*/
|
||
|
|
private:
|
||
|
|
long m_cRef; // Reference count
|
||
|
|
IConnectionPointContainer* m_pCPC; // Pointer to parent container
|
||
|
|
long m_nNextCookie; // Next available cookie value
|
||
|
|
std::vector<CONNECTDATA*> m_vecpcd; // Array of connections
|
||
|
|
};
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------------
|
||
|
|
Begin: Standard Class factory implementation.
|
||
|
|
------------------------------------------------------------------------------*/
|
||
|
|
template<class T>
|
||
|
|
class CMCLFactoryImpl : public IClassFactory
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
// Construction/destruction
|
||
|
|
CMCLFactoryImpl() : m_cRef(1) { }
|
||
|
|
virtual ~CMCLFactoryImpl() { }
|
||
|
|
|
||
|
|
// IClassFactory::AddRef implementation
|
||
|
|
ULONG __stdcall AddRef()
|
||
|
|
{
|
||
|
|
return InterlockedIncrement(&m_cRef);
|
||
|
|
}
|
||
|
|
// IClassFactory::Release implementation
|
||
|
|
ULONG __stdcall Release()
|
||
|
|
{
|
||
|
|
ULONG cRef = InterlockedDecrement(&m_cRef);
|
||
|
|
if(cRef != 0)
|
||
|
|
return cRef;
|
||
|
|
delete this;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
// IClassFactory::QueryInterface implementation
|
||
|
|
HRESULT __stdcall QueryInterface(REFIID iid, void** ppv)
|
||
|
|
{
|
||
|
|
if((iid == IID_IUnknown) || (iid == IID_IClassFactory))
|
||
|
|
*ppv = (IClassFactory*)this;
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*ppv = NULL;
|
||
|
|
return E_NOINTERFACE;
|
||
|
|
}
|
||
|
|
AddRef();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
// IClassFactory::CreateInstance implementation
|
||
|
|
virtual HRESULT __stdcall CreateInstance(IUnknown *pUnknownOuter, REFIID iid, void** ppv)
|
||
|
|
{
|
||
|
|
if(pUnknownOuter != NULL)
|
||
|
|
return CLASS_E_NOAGGREGATION;
|
||
|
|
|
||
|
|
#if defined (mclcommain_h) || defined (mclxlmain_published_api_h)
|
||
|
|
if (!mclComCheckMWComUtil())
|
||
|
|
{
|
||
|
|
const char* mcrversion=NULL;
|
||
|
|
mclGetMCRVersion(&mcrversion);
|
||
|
|
std::string errmsg;
|
||
|
|
errmsg = "MWComUtil ";
|
||
|
|
errmsg.append(mcrversion);
|
||
|
|
errmsg.append(" could not be found in the registry. Please refer to MATLAB Compiler SDK documentation for instructions on how to install and register MWComUtil.");
|
||
|
|
T::Error(errmsg.c_str());
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
T* p = new T;
|
||
|
|
|
||
|
|
if(p == NULL)
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
|
||
|
|
// Call the Init method to load the type information
|
||
|
|
if (!p->Init())
|
||
|
|
{
|
||
|
|
delete p;
|
||
|
|
return E_UNEXPECTED;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT hr = p->QueryInterface(iid, ppv);
|
||
|
|
p->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
// IClassFactory::LockServer implementation
|
||
|
|
HRESULT __stdcall LockServer(BOOL bLock)
|
||
|
|
{
|
||
|
|
if(bLock)
|
||
|
|
g_pModule->Lock();
|
||
|
|
else
|
||
|
|
g_pModule->Unlock();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
long m_cRef; // Ref count
|
||
|
|
};
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------------
|
||
|
|
End: Standard Class factory implementation.
|
||
|
|
------------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
// Add piidEvents so that Function Wizard works correctly (g1465604)
|
||
|
|
template<typename T, const IID* piid, typename T1, const CLSID* pclsid, const IID* piidEvents = nullptr>
|
||
|
|
class CMCLBaseImpl: public T, public ISupportErrorInfo, public IConnectionPointContainer
|
||
|
|
{
|
||
|
|
/*--------------------------------------
|
||
|
|
Construction/destruction
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// CMCLBaseImpl constructor
|
||
|
|
CMCLBaseImpl()
|
||
|
|
{
|
||
|
|
m_cRef = 1;
|
||
|
|
m_pTypeInfo = NULL;
|
||
|
|
m_pEvents = NULL;
|
||
|
|
g_pModule->Lock();
|
||
|
|
}
|
||
|
|
// CMCLBaseImpl destructor
|
||
|
|
virtual ~CMCLBaseImpl()
|
||
|
|
{
|
||
|
|
if (m_pEvents != NULL)
|
||
|
|
m_pEvents->Release();
|
||
|
|
if (m_pTypeInfo != NULL)
|
||
|
|
m_pTypeInfo->Release();
|
||
|
|
g_pModule->Unlock();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*--------------------------------------
|
||
|
|
IUnknown implementation
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// IUnknown::AddRef implementation
|
||
|
|
ULONG __stdcall AddRef()
|
||
|
|
{
|
||
|
|
return InterlockedIncrement(&m_cRef);
|
||
|
|
}
|
||
|
|
// IUnknown::Release implementation
|
||
|
|
ULONG __stdcall Release()
|
||
|
|
{
|
||
|
|
ULONG cRef = InterlockedDecrement(&m_cRef);
|
||
|
|
if(cRef != 0)
|
||
|
|
return cRef;
|
||
|
|
delete this;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
// IUnknown::QueryInterface implementation
|
||
|
|
HRESULT __stdcall QueryInterface(REFIID riid, void** ppv)
|
||
|
|
{
|
||
|
|
if(riid == *piid)
|
||
|
|
*ppv = static_cast<T*>(this);
|
||
|
|
else if(riid == IID_IUnknown)
|
||
|
|
*ppv = reinterpret_cast<IUnknown*>(this);
|
||
|
|
else if(riid == IID_IDispatch)
|
||
|
|
*ppv = reinterpret_cast<IDispatch*>(this);
|
||
|
|
else if(riid == IID_ISupportErrorInfo)
|
||
|
|
*ppv = static_cast<ISupportErrorInfo*>(this);
|
||
|
|
else if (riid == IID_IConnectionPointContainer)
|
||
|
|
*ppv = static_cast<IConnectionPointContainer*>(this);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*ppv = NULL;
|
||
|
|
return E_NOINTERFACE;
|
||
|
|
}
|
||
|
|
AddRef();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
IDispatch implementation
|
||
|
|
--------------------------------------*/
|
||
|
|
// IDispatch::GetTypeInfoCount implementation
|
||
|
|
HRESULT __stdcall GetTypeInfoCount(UINT* pCountTypeInfo)
|
||
|
|
{
|
||
|
|
if (pCountTypeInfo != NULL)
|
||
|
|
*pCountTypeInfo = 1;
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
// IDispatch::GetTypeInfo implementation
|
||
|
|
HRESULT __stdcall GetTypeInfo(UINT iTypeInfo, LCID lcid, ITypeInfo** ppITypeInfo)
|
||
|
|
{
|
||
|
|
if (ppITypeInfo != NULL)
|
||
|
|
{
|
||
|
|
*ppITypeInfo = NULL;
|
||
|
|
if(iTypeInfo != 0)
|
||
|
|
return DISP_E_BADINDEX;
|
||
|
|
if (m_pTypeInfo != NULL)
|
||
|
|
m_pTypeInfo->AddRef();
|
||
|
|
*ppITypeInfo = m_pTypeInfo;
|
||
|
|
}
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
// IDispatch::GetIDsOfNames implementation
|
||
|
|
HRESULT __stdcall GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames,
|
||
|
|
LCID lcid, DISPID* rgDispId)
|
||
|
|
{
|
||
|
|
if(riid != IID_NULL)
|
||
|
|
return DISP_E_UNKNOWNINTERFACE;
|
||
|
|
return DispGetIDsOfNames(m_pTypeInfo, rgszNames, cNames, rgDispId);
|
||
|
|
}
|
||
|
|
// IDispatch::Invoke implementation
|
||
|
|
HRESULT __stdcall Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
|
||
|
|
DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo,
|
||
|
|
UINT* puArgErr)
|
||
|
|
{
|
||
|
|
if(riid != IID_NULL)
|
||
|
|
return DISP_E_UNKNOWNINTERFACE;
|
||
|
|
return DispInvoke(this, m_pTypeInfo, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
ISupportErrorInfo implementation
|
||
|
|
--------------------------------------*/
|
||
|
|
// ISupportErrorInfo::InterfaceSupportsErrorInfo implementation
|
||
|
|
HRESULT __stdcall InterfaceSupportsErrorInfo(REFIID riid)
|
||
|
|
{
|
||
|
|
if(riid == *piid)
|
||
|
|
return S_OK;
|
||
|
|
else
|
||
|
|
return S_FALSE;
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
IConnectionPointContainer implementation
|
||
|
|
--------------------------------------*/
|
||
|
|
// IConnectionPointContainer::EnumConnectionPoints implementation
|
||
|
|
HRESULT __stdcall EnumConnectionPoints(IEnumConnectionPoints** ppEnum)
|
||
|
|
{
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
ULONG cConnections = 0;
|
||
|
|
CMCLEnumConnectionPoints* pEnum = NULL;
|
||
|
|
|
||
|
|
if (ppEnum == NULL)
|
||
|
|
return E_POINTER;
|
||
|
|
if (m_pEvents != NULL)
|
||
|
|
cConnections = 1;
|
||
|
|
pEnum = new CMCLEnumConnectionPoints(reinterpret_cast<IUnknown*>(this), cConnections, &m_pEvents);
|
||
|
|
if (pEnum == NULL)
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
hr = pEnum->QueryInterface(IID_IEnumConnectionPoints, (void**)ppEnum);
|
||
|
|
pEnum->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
// IConnectionPointContainer::FindConnectionPoint implementation
|
||
|
|
HRESULT __stdcall FindConnectionPoint(REFIID riid, IConnectionPoint** ppCP)
|
||
|
|
{
|
||
|
|
if (ppCP == NULL)
|
||
|
|
return E_POINTER;
|
||
|
|
if (piidEvents == NULL)
|
||
|
|
return CONNECT_E_NOCONNECTION;
|
||
|
|
if (riid == *piidEvents)
|
||
|
|
{
|
||
|
|
if (m_pEvents == NULL)
|
||
|
|
return CONNECT_E_NOCONNECTION;
|
||
|
|
*ppCP = m_pEvents;
|
||
|
|
(*ppCP)->AddRef();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
return CONNECT_E_NOCONNECTION;
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
CMCLBaseImpl Methods
|
||
|
|
--------------------------------------*/
|
||
|
|
// Initializes class, loads type info stuff and initializes connection point if necessary.
|
||
|
|
// Put any additional init stuff in here.
|
||
|
|
virtual bool Init(void)
|
||
|
|
{
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
|
||
|
|
hr = g_pModule->GetTypeInfo(*piid, &m_pTypeInfo);
|
||
|
|
|
||
|
|
if(FAILED(hr))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
if (piidEvents != NULL)
|
||
|
|
{
|
||
|
|
CMCLConnectionPointImpl<piidEvents>* pEvents
|
||
|
|
= new CMCLConnectionPointImpl<piidEvents>(static_cast<IConnectionPointContainer*>(this));
|
||
|
|
if (pEvents == NULL)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
if (pEvents != NULL)
|
||
|
|
{
|
||
|
|
if (FAILED(pEvents->QueryInterface(IID_IConnectionPoint, (void**)&m_pEvents)))
|
||
|
|
return false;
|
||
|
|
pEvents->Release();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
// Registers the class
|
||
|
|
static HRESULT __stdcall RegisterClass(const GUID* plibid, unsigned short wMajor, unsigned short wMinor, const char* lpszFriendlyName,
|
||
|
|
const char* lpszVerIndProgID, const char* lpszProgID, const char* lpszModuleName)
|
||
|
|
{
|
||
|
|
return mclRegisterServer(lpszModuleName, *pclsid, *plibid, wMajor, wMinor, lpszFriendlyName,
|
||
|
|
lpszVerIndProgID, lpszProgID, "Both");
|
||
|
|
}
|
||
|
|
// Unregisters the class
|
||
|
|
static HRESULT __stdcall UnregisterClass(const char* lpszVerIndProgID, const char* lpszProgID)
|
||
|
|
{
|
||
|
|
return mclUnregisterServer(*pclsid, lpszVerIndProgID, lpszProgID);
|
||
|
|
}
|
||
|
|
// Called by COM framework to get IClassFactory pointer on which to create new instances of object
|
||
|
|
static HRESULT __stdcall GetClassObject(REFCLSID clsid, REFIID iid, void** ppv)
|
||
|
|
{
|
||
|
|
if(clsid != *pclsid)
|
||
|
|
return CLASS_E_CLASSNOTAVAILABLE;
|
||
|
|
|
||
|
|
CMCLFactoryImpl<T1>* pFactory = new CMCLFactoryImpl<T1>;
|
||
|
|
if(pFactory == NULL)
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
|
||
|
|
// QueryInterface for IClassFactory
|
||
|
|
HRESULT hr = pFactory->QueryInterface(iid, ppv);
|
||
|
|
pFactory->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
// Method to report an error
|
||
|
|
static HRESULT __stdcall Error(const char* lpszMessage)
|
||
|
|
{
|
||
|
|
ICreateErrorInfo* pCreateErrorInfo = NULL;
|
||
|
|
IErrorInfo* pErrorInfo = NULL;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
OLECHAR* lpwszMessage = NULL;
|
||
|
|
OLECHAR* lpwszSource = NULL;
|
||
|
|
const char* lpszSource = NULL;
|
||
|
|
int nLen = 0;
|
||
|
|
|
||
|
|
if (FAILED(hr = CreateErrorInfo(&pCreateErrorInfo)))
|
||
|
|
goto EXIT;
|
||
|
|
// Set message text
|
||
|
|
if (lpszMessage != NULL)
|
||
|
|
{
|
||
|
|
pwcsStackPointer slpwszMessage = NULL;
|
||
|
|
initializeWcsStackPointer(&slpwszMessage);
|
||
|
|
if(mwMbstowcs(slpwszMessage, lpszMessage) < 0) {
|
||
|
|
deleteWcsStackPointer(slpwszMessage);
|
||
|
|
pCreateErrorInfo->SetDescription(L"Error converting multibyte string to wide character string.");
|
||
|
|
} else {
|
||
|
|
lpwszMessage = _wcsdup(reinterpret_cast<wchar_t*>(slpwszMessage->hPtr));
|
||
|
|
deleteWcsStackPointer(slpwszMessage);
|
||
|
|
pCreateErrorInfo->SetDescription(lpwszMessage);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
else
|
||
|
|
pCreateErrorInfo->SetDescription(L"");
|
||
|
|
// Set IID
|
||
|
|
pCreateErrorInfo->SetGUID(*piid);
|
||
|
|
// Set error source
|
||
|
|
lpszSource = g_pModule->GetProgID(*pclsid);
|
||
|
|
if (lpszSource != NULL)
|
||
|
|
{
|
||
|
|
pwcsStackPointer slpwszSource = NULL;
|
||
|
|
initializeWcsStackPointer(&slpwszSource);
|
||
|
|
if ( mwMbstowcs(slpwszSource, lpszSource) < 0){
|
||
|
|
deleteWcsStackPointer( slpwszSource );
|
||
|
|
pCreateErrorInfo->SetDescription(L"Error converting multibyte string to wide character string");
|
||
|
|
} else {
|
||
|
|
lpwszSource=_wcsdup(reinterpret_cast<wchar_t*>(slpwszSource->hPtr));
|
||
|
|
deleteWcsStackPointer( slpwszSource );
|
||
|
|
pCreateErrorInfo->SetSource(lpwszSource);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
else
|
||
|
|
pCreateErrorInfo->SetSource(L"");
|
||
|
|
// Set error info
|
||
|
|
if (FAILED(hr = pCreateErrorInfo->QueryInterface(IID_IErrorInfo, (void**)&pErrorInfo)))
|
||
|
|
goto EXIT;
|
||
|
|
hr = SetErrorInfo(0, pErrorInfo);
|
||
|
|
EXIT:
|
||
|
|
if (lpwszMessage != NULL)
|
||
|
|
delete lpwszMessage;
|
||
|
|
if (lpwszSource != NULL)
|
||
|
|
delete lpwszSource;
|
||
|
|
if (pErrorInfo != NULL)
|
||
|
|
pErrorInfo->Release();
|
||
|
|
if (pCreateErrorInfo != NULL)
|
||
|
|
pCreateErrorInfo->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
// Method to report an error from an EXCEPINFO structure (note: does not use template *piid in SetGUID)
|
||
|
|
static HRESULT __stdcall Error(REFIID riid, EXCEPINFO* pExcepInfo)
|
||
|
|
{
|
||
|
|
ICreateErrorInfo* pCreateErrorInfo = NULL;
|
||
|
|
IErrorInfo* pErrorInfo = NULL;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
|
||
|
|
if (pExcepInfo == NULL)
|
||
|
|
goto EXIT;
|
||
|
|
if (FAILED(hr = CreateErrorInfo(&pCreateErrorInfo)))
|
||
|
|
goto EXIT;
|
||
|
|
// Set message text
|
||
|
|
pCreateErrorInfo->SetDescription(pExcepInfo->bstrDescription);
|
||
|
|
// Set IID
|
||
|
|
pCreateErrorInfo->SetGUID(riid);
|
||
|
|
// Set error source
|
||
|
|
pCreateErrorInfo->SetSource(pExcepInfo->bstrSource);
|
||
|
|
// Set error info
|
||
|
|
if (FAILED(hr = pCreateErrorInfo->QueryInterface(IID_IErrorInfo, (void**)&pErrorInfo)))
|
||
|
|
goto EXIT;
|
||
|
|
hr = SetErrorInfo(0, pErrorInfo);
|
||
|
|
EXIT:
|
||
|
|
if (pErrorInfo != NULL)
|
||
|
|
pErrorInfo->Release();
|
||
|
|
if (pCreateErrorInfo != NULL)
|
||
|
|
pCreateErrorInfo->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
protected:
|
||
|
|
int RequestLocalLock()
|
||
|
|
{
|
||
|
|
mclAcquireMutex();
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
int ReleaseLocalLock()
|
||
|
|
{
|
||
|
|
mclReleaseMutex();
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
CMCLBaseImpl Properties
|
||
|
|
--------------------------------------*/
|
||
|
|
private:
|
||
|
|
long m_cRef; // Reference count
|
||
|
|
ITypeInfo* m_pTypeInfo; // Type Info pointer
|
||
|
|
protected:
|
||
|
|
IConnectionPoint* m_pEvents;// Connection point for objects that implement an event interface
|
||
|
|
};
|
||
|
|
|
||
|
|
template<class T>
|
||
|
|
class CMCLSingleFactoryImpl : public CMCLFactoryImpl<T>
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
// IClassFactory::CreateInstance implementation
|
||
|
|
HRESULT __stdcall CreateInstance(IUnknown *pUnknownOuter, REFIID iid, void** ppv)
|
||
|
|
{
|
||
|
|
ModuleLock lock;
|
||
|
|
if(pUnknownOuter != NULL)
|
||
|
|
return CLASS_E_NOAGGREGATION;
|
||
|
|
if (m_p == NULL)
|
||
|
|
{
|
||
|
|
m_p = new T;
|
||
|
|
if(m_p == NULL)
|
||
|
|
{
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
}
|
||
|
|
if (!m_p->Init())
|
||
|
|
{
|
||
|
|
delete m_p;
|
||
|
|
m_p = NULL;
|
||
|
|
return E_UNEXPECTED;
|
||
|
|
}
|
||
|
|
m_p->AddRef();
|
||
|
|
}
|
||
|
|
HRESULT hr = m_p->QueryInterface(iid, ppv);
|
||
|
|
m_p->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
private:
|
||
|
|
long m_cRef; // Ref count
|
||
|
|
static T* m_p; // Static instance of T
|
||
|
|
};
|
||
|
|
|
||
|
|
template<class T, const IID* piid, class T1, const CLSID* pclsid>
|
||
|
|
class CMCLSingleBaseImpl: public CMCLBaseImpl<T, piid, T1, pclsid>
|
||
|
|
{
|
||
|
|
/*--------------------------------------
|
||
|
|
Construction/destruction
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// CMCLSingleBaseImpl constructor
|
||
|
|
CMCLSingleBaseImpl(){}
|
||
|
|
// CMCLSingleBaseImpl destructor
|
||
|
|
virtual ~CMCLSingleBaseImpl(){}
|
||
|
|
/*--------------------------------------
|
||
|
|
IUnknown implementation
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// IUnknown::AddRef implementation
|
||
|
|
ULONG __stdcall AddRef()
|
||
|
|
{
|
||
|
|
return 2;
|
||
|
|
}
|
||
|
|
// IUnknown::Release implementation
|
||
|
|
ULONG __stdcall Release()
|
||
|
|
{
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
// Called by COM framework to get IClassFactory pointer on which to create new instances of object
|
||
|
|
static HRESULT __stdcall GetClassObject(REFCLSID clsid, REFIID iid, void** ppv)
|
||
|
|
{
|
||
|
|
if(clsid != *pclsid)
|
||
|
|
return CLASS_E_CLASSNOTAVAILABLE;
|
||
|
|
|
||
|
|
CMCLSingleFactoryImpl<T1>* pFactory = new CMCLSingleFactoryImpl<T1>;
|
||
|
|
if(pFactory == NULL)
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
|
||
|
|
// QueryInterface for IClassFactory
|
||
|
|
HRESULT hr = pFactory->QueryInterface(iid, ppv);
|
||
|
|
pFactory->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template<class T, const IID* piid, class T1, const CLSID* pclsid>
|
||
|
|
class CMCLClassImpl: public CMCLBaseImpl<T, piid, T1, pclsid>, public IMCLEvent
|
||
|
|
{
|
||
|
|
/*--------------------------------------
|
||
|
|
Construction/destruction
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// CMCLClassImpl constructor
|
||
|
|
CMCLClassImpl()
|
||
|
|
{
|
||
|
|
m_pFlags = NULL;
|
||
|
|
m_hinst = NULL;
|
||
|
|
}
|
||
|
|
// CMCLClassImpl destructor
|
||
|
|
virtual ~CMCLClassImpl()
|
||
|
|
{
|
||
|
|
if (m_pFlags != NULL)
|
||
|
|
m_pFlags->Release();
|
||
|
|
}
|
||
|
|
protected:
|
||
|
|
void RegisterListener()
|
||
|
|
{
|
||
|
|
g_pModule->getEventMap()->add(m_hinst, static_cast<IMCLEvent*>(this));
|
||
|
|
}
|
||
|
|
void UnregisterListener()
|
||
|
|
{
|
||
|
|
g_pModule->getEventMap()->remove(m_hinst, static_cast<IMCLEvent*>(this));
|
||
|
|
}
|
||
|
|
public:
|
||
|
|
/*--------------------------------------
|
||
|
|
CMCLClassImpl Methods
|
||
|
|
--------------------------------------*/
|
||
|
|
// Registers the class and adds it to the MatLab XL component catagory
|
||
|
|
static HRESULT __stdcall RegisterClass(const GUID* plibid, unsigned short wMajor, unsigned short wMinor, const char* lpszFriendlyName,
|
||
|
|
const char* lpszVerIndProgID, const char* lpszProgID, const char* lpszModuleName)
|
||
|
|
{
|
||
|
|
return mclRegisterMatLabComponent(lpszModuleName, pclsid, plibid, wMajor, wMinor, lpszFriendlyName, lpszVerIndProgID, lpszProgID);
|
||
|
|
}
|
||
|
|
// Unregisters the class and removes it from the MatLab XL component catagory
|
||
|
|
static HRESULT __stdcall UnregisterClass(const char* lpszVerIndProgID, const char* lpszProgID)
|
||
|
|
{
|
||
|
|
return mclUnRegisterMatLabComponent(pclsid, lpszVerIndProgID, lpszProgID);
|
||
|
|
}
|
||
|
|
// Returns a pointer to the contained MWFlags object
|
||
|
|
HRESULT __stdcall get_MWFlags(IMWFlags** ppFlags)
|
||
|
|
{
|
||
|
|
HRESULT hr = S_OK; // Return code
|
||
|
|
ModuleLock lock;
|
||
|
|
if (ppFlags == NULL)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
*ppFlags = NULL;
|
||
|
|
// If there is not one already allocated, creat a new one.
|
||
|
|
if (m_pFlags == NULL)
|
||
|
|
{
|
||
|
|
hr = CoCreateInstance(CLSID_MWFlags, NULL, CLSCTX_INPROC_SERVER,
|
||
|
|
IID_IMWFlags, (void**)&m_pFlags);
|
||
|
|
if (FAILED(hr))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
*ppFlags = m_pFlags;
|
||
|
|
m_pFlags->AddRef();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
// Sets the array-formatting-object
|
||
|
|
HRESULT __stdcall put_MWFlags(IMWFlags* pFlags)
|
||
|
|
{
|
||
|
|
HRESULT hr = S_OK; // Return code
|
||
|
|
ModuleLock lock;
|
||
|
|
if (pFlags == NULL)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
// Set internal object to new one.
|
||
|
|
if (m_pFlags != NULL)
|
||
|
|
m_pFlags->Release();
|
||
|
|
m_pFlags = pFlags;
|
||
|
|
m_pFlags->AddRef();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
// Call the MatLab mex funtion pointed to by mlxF
|
||
|
|
HRESULT CallComFcn(const char* name, int nargout, int fnout, int fnin, ...)
|
||
|
|
{
|
||
|
|
mxArray **plhs;
|
||
|
|
//int nargout: comes in as ip param to this function
|
||
|
|
int alloc_nargout = (nargout == 0) ? 1: nargout;
|
||
|
|
mxArray **prhs;
|
||
|
|
int nargin = 0;
|
||
|
|
|
||
|
|
VARIANT **plvar;
|
||
|
|
const VARIANT **prvar;
|
||
|
|
|
||
|
|
bool bVarargout = fnout < 0;
|
||
|
|
bool bVarargin = fnin < 0;
|
||
|
|
|
||
|
|
mxArray *varargout = NULL;
|
||
|
|
mxArray *varargin = NULL;
|
||
|
|
|
||
|
|
int i;
|
||
|
|
int new_nargin;
|
||
|
|
va_list ap;
|
||
|
|
bool bFoundDefault = false;
|
||
|
|
HRESULT retval = S_OK;
|
||
|
|
_MCLCONVERSION_FLAGS flags;
|
||
|
|
IMWFlags* pFlags = NULL;
|
||
|
|
bool bRet = false;
|
||
|
|
int dc_status = 0;
|
||
|
|
|
||
|
|
// Check MCR instance
|
||
|
|
if (!m_hinst)
|
||
|
|
{
|
||
|
|
this->Error("MCR instance is not available");
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
// Get Conversion flags
|
||
|
|
if (FAILED(get_MWFlags(&pFlags)))
|
||
|
|
{
|
||
|
|
this->Error("Error getting data conversion flags");
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
if (FAILED(GetConversionFlags(pFlags, &flags)))
|
||
|
|
{
|
||
|
|
this->Error("Error getting data conversion flags");
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
pFlags->Release();
|
||
|
|
try
|
||
|
|
{
|
||
|
|
// O/P from mclMlxFeval (lhs)
|
||
|
|
va_start( ap, fnin );
|
||
|
|
if (bVarargout)
|
||
|
|
{
|
||
|
|
fnout = -fnout;
|
||
|
|
}
|
||
|
|
plvar = (VARIANT **) _alloca( fnout * sizeof( VARIANT * ) );
|
||
|
|
for (i=0; i< fnout; i++)
|
||
|
|
{
|
||
|
|
plvar[i] = va_arg( ap, VARIANT *);
|
||
|
|
}
|
||
|
|
plhs = (mxArray **) _alloca( alloc_nargout * sizeof( mxArray * ));
|
||
|
|
for (i=0; i< alloc_nargout; i++)
|
||
|
|
{
|
||
|
|
plhs[i] = NULL;
|
||
|
|
}
|
||
|
|
// I/P to mclMlxFeval (rhs)
|
||
|
|
if (bVarargin)
|
||
|
|
{
|
||
|
|
fnin = -fnin;
|
||
|
|
}
|
||
|
|
prvar = (const VARIANT **) _alloca( fnin * sizeof(VARIANT *));
|
||
|
|
for (i = 0; i< fnin; i++)
|
||
|
|
{
|
||
|
|
prvar[i] = va_arg( ap, VARIANT *);
|
||
|
|
if (IsVisualBasicDefault( prvar[i] ))
|
||
|
|
{
|
||
|
|
bFoundDefault = true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (bFoundDefault)
|
||
|
|
{
|
||
|
|
this->Error( "Error: Arguments may only be defaulted at the end of an argument list" );
|
||
|
|
retval = E_FAIL;
|
||
|
|
goto finish;
|
||
|
|
}
|
||
|
|
nargin++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (bVarargin && !bFoundDefault)
|
||
|
|
{
|
||
|
|
//g830130 - if there is only one varargin, and MCLUtil.MWPack() is not called,
|
||
|
|
//the varargin won't be passed in as an array. In this case, the conversion flag's
|
||
|
|
//nInputInd shoulnd't be incremented.
|
||
|
|
if (prvar[fnin-1]->vt == (VT_VARIANT|VT_BYREF))
|
||
|
|
{
|
||
|
|
if ((prvar[fnin-1]->pvarVal != NULL) && (prvar[fnin-1]->pvarVal->vt & VT_ARRAY))
|
||
|
|
{
|
||
|
|
flags.nInputInd += 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ((dc_status = Variant2mxArray( prvar[fnin-1], &varargin, &flags)) < 0)
|
||
|
|
{
|
||
|
|
mclSetLastErrIdAndMsg("", GetCOMErrorMessage(dc_status));
|
||
|
|
retval = E_FAIL;
|
||
|
|
goto finish;
|
||
|
|
}
|
||
|
|
flags.nInputInd -= 1;
|
||
|
|
if (varargin == NULL)
|
||
|
|
nargin -= 1;
|
||
|
|
/*Empty varargin should be passed to MATLAB as a empty cell array*/
|
||
|
|
else if(mxIsEmpty(varargin))
|
||
|
|
{
|
||
|
|
varargin = NULL;
|
||
|
|
nargin -= 1;
|
||
|
|
}
|
||
|
|
else if (mxGetClassID(varargin) == mxCELL_CLASS)
|
||
|
|
nargin += static_cast<int>(mxGetN( varargin )) - 1;
|
||
|
|
}
|
||
|
|
prhs = (mxArray **) _alloca( nargin * sizeof(mxArray *));
|
||
|
|
for (i = 0; i< nargin; i++)
|
||
|
|
prhs[i] = NULL;
|
||
|
|
mclmxarray_list protect_plhs( nargout, plhs );
|
||
|
|
mclmxarray_list protect_prhs( nargin, prhs );
|
||
|
|
for (i = 0; i< nargin; i++)
|
||
|
|
{
|
||
|
|
if (i < fnin-1 || (!bVarargin && i == fnin-1))
|
||
|
|
{
|
||
|
|
if ((dc_status = Variant2mxArray( prvar[i], &prhs[i], &flags)) < 0)
|
||
|
|
{
|
||
|
|
mclSetLastErrIdAndMsg("", GetCOMErrorMessage(dc_status));
|
||
|
|
retval = E_FAIL;
|
||
|
|
goto finish;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if ( varargin != NULL && mxGetClassID(varargin) == mxCELL_CLASS )
|
||
|
|
prhs[i] = mclCreateSharedCopy(((mxArray **)mxGetData(varargin))[i-fnin+1]);
|
||
|
|
else
|
||
|
|
prhs[i] = mclCreateSharedCopy(varargin);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
bFoundDefault = false;
|
||
|
|
new_nargin = nargin;
|
||
|
|
for (i = 0; i< nargin; i++)
|
||
|
|
{
|
||
|
|
if (!bFoundDefault) {
|
||
|
|
if (prhs[i] == NULL) {
|
||
|
|
bFoundDefault = true;
|
||
|
|
new_nargin = i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
if (prhs[i] != NULL) {
|
||
|
|
this->Error( "Error: Arguments may only be defaulted at the end of an argument list" );
|
||
|
|
retval = E_FAIL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (retval != E_FAIL) {
|
||
|
|
nargin = new_nargin;
|
||
|
|
// call mclMlxFeval
|
||
|
|
bRet = g_pModule->Feval(m_hinst, name, nargout, plhs, nargin, prhs);
|
||
|
|
if (!bRet)
|
||
|
|
goto finish;
|
||
|
|
// translate o/p (lhs) of mclMlxFeval back to variant
|
||
|
|
if (nargout == 0 && plhs[0] != NULL )
|
||
|
|
{
|
||
|
|
mxDestroyArray( plhs[0] );
|
||
|
|
plhs[0] = NULL;
|
||
|
|
}
|
||
|
|
if (bVarargout && nargout >= fnout)
|
||
|
|
{
|
||
|
|
varargout = mclCreateCellArrayFromArrayList(nargout-fnout+1, &plhs[fnout-1]);
|
||
|
|
}
|
||
|
|
for (i = 0; i<fnout && i<nargout; i++)
|
||
|
|
{
|
||
|
|
if (i < fnout -1 || (!bVarargout && i == fnout-1 ))
|
||
|
|
{
|
||
|
|
if ((dc_status = mxArray2Variant( plhs[i], plvar[i], &flags)) < 0)
|
||
|
|
{
|
||
|
|
mclSetLastErrIdAndMsg("", GetCOMErrorMessage(dc_status));
|
||
|
|
retval = E_FAIL;
|
||
|
|
goto finish;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
flags.nOutputInd += 1;
|
||
|
|
flags.nTransposeInd += 1;
|
||
|
|
if ((dc_status = mxArray2Variant( varargout, plvar[i], &flags)) < 0)
|
||
|
|
{
|
||
|
|
mclSetLastErrIdAndMsg("", GetCOMErrorMessage(dc_status));
|
||
|
|
retval = E_FAIL;
|
||
|
|
goto finish;
|
||
|
|
}
|
||
|
|
flags.nOutputInd -= 1;
|
||
|
|
flags.nTransposeInd -= 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (...)
|
||
|
|
{
|
||
|
|
this->Error("Unexpected Error Thrown");
|
||
|
|
retval = E_FAIL;
|
||
|
|
}
|
||
|
|
finish:
|
||
|
|
if (varargin != NULL)
|
||
|
|
mxDestroyArray( varargin );
|
||
|
|
if (varargout != NULL)
|
||
|
|
mxDestroyArray( varargout );
|
||
|
|
if (!bRet)
|
||
|
|
{
|
||
|
|
const char* msg = g_pModule->getErrorMessage();
|
||
|
|
|
||
|
|
//If there is no error message on the CMCLModule (which might
|
||
|
|
// have run its work on a different thread), then check the
|
||
|
|
// local thread for an error message.
|
||
|
|
if(!msg)
|
||
|
|
{
|
||
|
|
msg = mclGetLastErrorMessage();
|
||
|
|
}
|
||
|
|
//If the g_pModule has an error (the thread that actually called feval),
|
||
|
|
// use that, otherwise see if this thread has an error,
|
||
|
|
// if all else fails, give a generic message.
|
||
|
|
this->Error((msg ? msg : "Unspecified error"));
|
||
|
|
retval = E_FAIL;
|
||
|
|
}
|
||
|
|
return(retval);
|
||
|
|
}
|
||
|
|
void mclRaiseEventA(const char* lpszName, DISPID dispid, int nargin, mxArray** prhs)
|
||
|
|
{
|
||
|
|
HRESULT hr = S_OK; // Return code
|
||
|
|
IEnumConnections* pEnum = NULL; // Pointer to enum of all connections
|
||
|
|
CONNECTDATA ConnData = {0,0}; // CONNECTDATA structure for each connection
|
||
|
|
ULONG cFetched = 0; // Number of connections fetched in a call
|
||
|
|
IDispatch* pDisp = NULL; // IDispatch pointer to make call on
|
||
|
|
VARIANT varResult; // Result from call
|
||
|
|
VARIANT* pvars = NULL; // Varaibles to send into call
|
||
|
|
DISPPARAMS disp = {NULL,NULL,0,0};// Disparams used to make call
|
||
|
|
// DISPID dispid = 0; // DISPID of method to invoke
|
||
|
|
OLECHAR* lpwszName = NULL; // Temp buffer for method name
|
||
|
|
int nLen = 0; // Length of name string
|
||
|
|
int i = 0; // Loop counter
|
||
|
|
_MCLCONVERSION_FLAGS flags; // Temp flags struct
|
||
|
|
IMWFlags* pFlags = NULL; // Temp flags object
|
||
|
|
|
||
|
|
pwcsStackPointer slpwszName = NULL;
|
||
|
|
initializeWcsStackPointer(&slpwszName);
|
||
|
|
|
||
|
|
// If no connection point available or invalid name, return
|
||
|
|
if (this->m_pEvents == NULL || lpszName == NULL)
|
||
|
|
return;
|
||
|
|
if (nargin < 0 || (prhs == NULL && nargin > 0))
|
||
|
|
nargin = 0;
|
||
|
|
// Get Conversion flags
|
||
|
|
if (FAILED(get_MWFlags(&pFlags)))
|
||
|
|
InitConversionFlags(&flags);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (FAILED(GetConversionFlags(pFlags, &flags)))
|
||
|
|
InitConversionFlags(&flags);
|
||
|
|
pFlags->Release();
|
||
|
|
}
|
||
|
|
// Enum all connections
|
||
|
|
hr = this->m_pEvents->EnumConnections(&pEnum);
|
||
|
|
if (FAILED(hr))
|
||
|
|
goto EXIT;
|
||
|
|
VariantInit(&varResult);
|
||
|
|
// Create Array of Variants for call
|
||
|
|
if (nargin > 0)
|
||
|
|
{
|
||
|
|
pvars = new VARIANT[nargin];
|
||
|
|
if (pvars == NULL)
|
||
|
|
goto EXIT;
|
||
|
|
for (i=0;i<nargin;i++)
|
||
|
|
VariantInit(&pvars[i]);
|
||
|
|
disp.rgvarg = pvars;
|
||
|
|
disp.cArgs = nargin;
|
||
|
|
}
|
||
|
|
for (i=0;i<nargin;i++)
|
||
|
|
{
|
||
|
|
if (prhs[i] != NULL)
|
||
|
|
{
|
||
|
|
if (mxArray2Variant(prhs[i], &pvars[nargin-i-1], &flags) < 0)
|
||
|
|
goto EXIT;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Get name
|
||
|
|
if (mwMbstowcs(slpwszName,lpszName) < 0) {
|
||
|
|
deleteWcsStackPointer(slpwszName);
|
||
|
|
goto EXIT;
|
||
|
|
}
|
||
|
|
lpwszName=_wcsdup(reinterpret_cast<wchar_t*>(slpwszName->hPtr));
|
||
|
|
deleteWcsStackPointer(slpwszName);
|
||
|
|
|
||
|
|
// Loop over all connections and call each one
|
||
|
|
pEnum->Reset();
|
||
|
|
for(;;)
|
||
|
|
{
|
||
|
|
hr = pEnum->Next(1, &ConnData, &cFetched);
|
||
|
|
if (cFetched == 0)
|
||
|
|
break;
|
||
|
|
if (ConnData.pUnk != NULL)
|
||
|
|
{
|
||
|
|
hr = ConnData.pUnk->QueryInterface(IID_IDispatch, (void**)&pDisp);
|
||
|
|
ConnData.pUnk->Release();
|
||
|
|
if (SUCCEEDED(hr) && pDisp != NULL)
|
||
|
|
{
|
||
|
|
g_pModule->RaiseEvent(lpwszName, dispid, pDisp, &disp);
|
||
|
|
pDisp->Release();
|
||
|
|
pDisp = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
EXIT:
|
||
|
|
if (pEnum != NULL)
|
||
|
|
pEnum->Release();
|
||
|
|
if (pDisp != NULL)
|
||
|
|
pDisp->Release();
|
||
|
|
if (lpwszName != NULL)
|
||
|
|
delete lpwszName;
|
||
|
|
if (pvars != NULL)
|
||
|
|
{
|
||
|
|
for (i=0;i<nargin;i++)
|
||
|
|
VariantClear(&pvars[i]);
|
||
|
|
delete [] pvars;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Gets a property from the array
|
||
|
|
HRESULT GetProperty(const char* name, VARIANT* pvarValue)
|
||
|
|
{
|
||
|
|
_MCLCONVERSION_FLAGS flags;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
IMWFlags* pFlags = NULL;
|
||
|
|
mxArray* px = NULL;
|
||
|
|
int dc_status = 0;
|
||
|
|
const char* msg = NULL;
|
||
|
|
|
||
|
|
mwLock lock;
|
||
|
|
// Check MCR instance
|
||
|
|
if (!m_hinst)
|
||
|
|
{
|
||
|
|
this->Error("MCR instance is not available");
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
if (pvarValue == NULL)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
// Get Conversion flags
|
||
|
|
if (FAILED(get_MWFlags(&pFlags)))
|
||
|
|
{
|
||
|
|
this->Error("Error getting data conversion flags");
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
if (FAILED(GetConversionFlags(pFlags, &flags)))
|
||
|
|
{
|
||
|
|
this->Error("Error getting data conversion flags");
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
pFlags->Release();
|
||
|
|
try
|
||
|
|
{
|
||
|
|
if (!mclGetGlobal(m_hinst, name, &px))
|
||
|
|
{
|
||
|
|
const char* msg = mclGetLastErrorMessage();
|
||
|
|
this->Error((msg ? msg : "Unspecified error"));
|
||
|
|
hr = E_FAIL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (pvarValue->vt != VT_EMPTY)
|
||
|
|
VariantClear(pvarValue);
|
||
|
|
if ((dc_status = mxArray2Variant(px, pvarValue, &flags)) < 0)
|
||
|
|
{
|
||
|
|
msg = GetCOMErrorMessage(dc_status);
|
||
|
|
this->Error((msg ? msg : "Unspecified error"));
|
||
|
|
hr = E_FAIL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (...)
|
||
|
|
{
|
||
|
|
this->Error("Unexpected Error Thrown");
|
||
|
|
hr = E_FAIL;
|
||
|
|
}
|
||
|
|
if (px)
|
||
|
|
mxDestroyArray(px);
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
// Sets a property in the array
|
||
|
|
HRESULT PutProperty(const char* name, const VARIANT* pvarValue)
|
||
|
|
{
|
||
|
|
_MCLCONVERSION_FLAGS flags;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
IMWFlags* pFlags = NULL;
|
||
|
|
mxArray* px = NULL;
|
||
|
|
int dc_status = 0;
|
||
|
|
const char* msg = NULL;
|
||
|
|
|
||
|
|
mwLock lock;
|
||
|
|
// Check MCR instance
|
||
|
|
if (!m_hinst)
|
||
|
|
{
|
||
|
|
this->Error("MCR instance is not available");
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
if (pvarValue == NULL)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
// Get Conversion flags
|
||
|
|
if (FAILED(get_MWFlags(&pFlags)))
|
||
|
|
{
|
||
|
|
this->Error("Error getting data conversion flags");
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
if (FAILED(GetConversionFlags(pFlags, &flags)))
|
||
|
|
{
|
||
|
|
this->Error("Error getting data conversion flags");
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
pFlags->Release();
|
||
|
|
try
|
||
|
|
{
|
||
|
|
if ((dc_status = Variant2mxArray(pvarValue, &px, &flags)) < 0)
|
||
|
|
{
|
||
|
|
msg = GetCOMErrorMessage(dc_status);
|
||
|
|
this->Error((msg ? msg : "Unspecified error"));
|
||
|
|
hr = E_FAIL;
|
||
|
|
}
|
||
|
|
else if (!mclSetGlobal(m_hinst, name, px))
|
||
|
|
{
|
||
|
|
msg = mclGetLastErrorMessage();
|
||
|
|
this->Error((msg ? msg : "Unspecified error"));
|
||
|
|
hr = E_FAIL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (...)
|
||
|
|
{
|
||
|
|
this->Error("Unexpected Error Thrown");
|
||
|
|
hr = E_FAIL;
|
||
|
|
}
|
||
|
|
if (px)
|
||
|
|
mxDestroyArray(px);
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
/*--------------------------------------
|
||
|
|
CMCLClassImpl Properties
|
||
|
|
--------------------------------------*/
|
||
|
|
private:
|
||
|
|
IMWFlags* m_pFlags; // Pointer to a formatting/conversion-flags object
|
||
|
|
protected:
|
||
|
|
HMCRINSTANCE m_hinst; // MCR instance
|
||
|
|
};
|
||
|
|
|
||
|
|
template<class T, const IID* piid, class T1, const CLSID* pclsid>
|
||
|
|
class CMCLSingleImpl: public CMCLClassImpl<T, piid, T1, pclsid>
|
||
|
|
{
|
||
|
|
/*--------------------------------------
|
||
|
|
Construction/destruction
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// CMCLSingleImpl constructor
|
||
|
|
CMCLSingleImpl(){}
|
||
|
|
// CMCLSingleImpl destructor
|
||
|
|
virtual ~CMCLSingleImpl(){}
|
||
|
|
/*--------------------------------------
|
||
|
|
IUnknown implementation
|
||
|
|
--------------------------------------*/
|
||
|
|
public:
|
||
|
|
// IUnknown::AddRef implementation
|
||
|
|
ULONG __stdcall AddRef()
|
||
|
|
{
|
||
|
|
return 2;
|
||
|
|
}
|
||
|
|
// IUnknown::Release implementation
|
||
|
|
ULONG __stdcall Release()
|
||
|
|
{
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
// Called by COM framework to get IClassFactory pointer on which to create new instances of object
|
||
|
|
static HRESULT __stdcall GetClassObject(REFCLSID clsid, REFIID iid, void** ppv)
|
||
|
|
{
|
||
|
|
if(clsid != *pclsid)
|
||
|
|
return CLASS_E_CLASSNOTAVAILABLE;
|
||
|
|
|
||
|
|
CMCLSingleFactoryImpl<T1>* pFactory = new CMCLSingleFactoryImpl<T1>;
|
||
|
|
if(pFactory == NULL)
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
|
||
|
|
// QueryInterface for IClassFactory
|
||
|
|
HRESULT hr = pFactory->QueryInterface(iid, ppv);
|
||
|
|
pFactory->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/*------------------------------------------------------------------------------
|
||
|
|
Singleton Class factory implementation.
|
||
|
|
------------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
template<typename Iterface>
|
||
|
|
struct MarshalHelperDelegate
|
||
|
|
{
|
||
|
|
template<typename Derived>
|
||
|
|
static HRESULT copyMWFlags(MCLCONVERSION_FLAGS flags, void * receiver)
|
||
|
|
{
|
||
|
|
HRESULT hr;
|
||
|
|
Derived * derivedObject = static_cast<Derived*>(/*this*/receiver);
|
||
|
|
IMWFlags * mwflags = NULL;
|
||
|
|
if(FAILED(hr = derivedObject->get_MWFlags(&mwflags)))
|
||
|
|
goto EXIT;
|
||
|
|
HRESULT mclPutConversionFlags(IMWFlags* pFlags, MCLCONVERSION_FLAGS flags);
|
||
|
|
if(FAILED(hr = mclPutConversionFlags(mwflags, flags)))
|
||
|
|
goto EXIT;
|
||
|
|
if(FAILED(derivedObject->put_MWFlags(mwflags)))
|
||
|
|
goto EXIT;
|
||
|
|
EXIT:
|
||
|
|
if(mwflags)
|
||
|
|
mwflags->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template<>
|
||
|
|
struct MarshalHelperDelegate<IMWStruct>
|
||
|
|
{
|
||
|
|
template<typename Derived>
|
||
|
|
static HRESULT copyMWFlags(MCLCONVERSION_FLAGS, void *)
|
||
|
|
{
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
template<typename Interface, typename Derived>
|
||
|
|
struct MarshalHelper
|
||
|
|
{
|
||
|
|
HRESULT copyMWFlags(MCLCONVERSION_FLAGS flags, void * receiver)
|
||
|
|
{
|
||
|
|
return MarshalHelperDelegate<Interface>::template copyMWFlags<Derived>(flags,receiver);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
template<typename T, const IID* piid, typename T1, const CLSID* pclsid>
|
||
|
|
class CMCLMarshalImpl: public CMCLBaseImpl<T, piid, T1, pclsid>, public IMarshal, public MarshalHelper<T, T1>
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
CMCLMarshalImpl()
|
||
|
|
{
|
||
|
|
m_serializedData = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// IUnknown
|
||
|
|
ULONG __stdcall AddRef()
|
||
|
|
{
|
||
|
|
return typename CMCLBaseImpl<T, piid, T1, pclsid>::AddRef();
|
||
|
|
}
|
||
|
|
ULONG __stdcall Release()
|
||
|
|
{
|
||
|
|
return typename CMCLBaseImpl<T, piid, T1, pclsid>::Release();
|
||
|
|
}
|
||
|
|
HRESULT __stdcall QueryInterface(REFIID riid, void** ppv)
|
||
|
|
{
|
||
|
|
if(riid == IID_IMarshal)
|
||
|
|
{
|
||
|
|
*ppv = static_cast<IMarshal*>(this);
|
||
|
|
AddRef();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
return typename CMCLBaseImpl<T, piid, T1, pclsid>::QueryInterface(riid, ppv);
|
||
|
|
}
|
||
|
|
|
||
|
|
// IMarshal
|
||
|
|
HRESULT __stdcall GetUnmarshalClass(REFIID riid, void* pv, DWORD dwDestContext, void* pvDestContext, DWORD dwFlags, CLSID* pClsid)
|
||
|
|
{
|
||
|
|
if(dwDestContext == MSHCTX_DIFFERENTMACHINE || dwDestContext == MSHCTX_INPROC)
|
||
|
|
{
|
||
|
|
IMarshal* pMarshal;
|
||
|
|
CoGetStandardMarshal(riid, (T*)pv, dwDestContext, pvDestContext, dwFlags, &pMarshal);
|
||
|
|
HRESULT hr = pMarshal->GetUnmarshalClass(riid, pv, dwDestContext, pvDestContext, dwFlags, pClsid);
|
||
|
|
pMarshal->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
*pClsid = *(const_cast<CLSID*>(pclsid));
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT __stdcall GetMarshalSizeMax(REFIID riid, void* pv, DWORD dwDestContext, void* pvDestContext, DWORD dwFlags, DWORD* pSize)
|
||
|
|
{
|
||
|
|
if(dwDestContext == MSHCTX_DIFFERENTMACHINE || dwDestContext == MSHCTX_INPROC)
|
||
|
|
{
|
||
|
|
IMarshal* pMarshal;
|
||
|
|
CoGetStandardMarshal(riid, (T*)pv, dwDestContext, pvDestContext, dwFlags, &pMarshal);
|
||
|
|
HRESULT hr = pMarshal->GetMarshalSizeMax(riid, pv, dwDestContext, pvDestContext, dwFlags, pSize);
|
||
|
|
pMarshal->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
//serialize the data the first time, this method is called twice during a marshalling operation
|
||
|
|
if(m_serializedData == NULL)
|
||
|
|
{
|
||
|
|
if(FAILED(Serialize(pv)))
|
||
|
|
{
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
*pSize = static_cast<DWORD>(mxGetN(m_serializedData) + 4);
|
||
|
|
T1 * derivedObject = dynamic_cast<T1*>(this);
|
||
|
|
if(derivedObject->getCurrentMWFlags())
|
||
|
|
{
|
||
|
|
*pSize += sizeof(_MCLCONVERSION_FLAGS);
|
||
|
|
}
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT __stdcall MarshalInterface(IStream* pStream, REFIID riid, void* pv, DWORD dwDestContext, void* pvDestContext, DWORD dwFlags)
|
||
|
|
{
|
||
|
|
if(dwDestContext == MSHCTX_DIFFERENTMACHINE || dwDestContext == MSHCTX_INPROC)
|
||
|
|
{
|
||
|
|
IMarshal* pMarshal;
|
||
|
|
CoGetStandardMarshal(riid, (T*)pv, dwDestContext, pvDestContext, dwFlags, &pMarshal);
|
||
|
|
HRESULT hr = pMarshal->MarshalInterface(pStream, riid, pv, dwDestContext, pvDestContext, dwFlags);
|
||
|
|
pMarshal->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
DWORD sizeOfPacket = static_cast<DWORD>(mxGetN(m_serializedData));
|
||
|
|
unsigned long bytesWritten = 0;
|
||
|
|
if(FAILED(hr = pStream->Write(&sizeOfPacket, 4, &bytesWritten))
|
||
|
|
|| bytesWritten != 4)
|
||
|
|
{
|
||
|
|
this->Error("Unable to write the size of the packet during serialization.");
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
if(FAILED(hr = pStream->Write(mxGetData(m_serializedData), sizeOfPacket, &bytesWritten))
|
||
|
|
|| bytesWritten != sizeOfPacket)
|
||
|
|
{
|
||
|
|
this->Error("Unable to write the packet during serialization.");
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
T1 * derivedObject = dynamic_cast<T1*>(this);
|
||
|
|
|
||
|
|
IMWFlags * mwflags;
|
||
|
|
if((mwflags = static_cast<IMWFlags*>(derivedObject->getCurrentMWFlags())) != NULL)
|
||
|
|
{
|
||
|
|
HRESULT hr;
|
||
|
|
_MCLCONVERSION_FLAGS flags;
|
||
|
|
if((hr = this->mclGetConversionFlags(mwflags,&flags)) != S_OK)
|
||
|
|
return hr;
|
||
|
|
if(FAILED(hr = pStream->Write(&flags, sizeof(_MCLCONVERSION_FLAGS), &bytesWritten))
|
||
|
|
|| bytesWritten != sizeof(_MCLCONVERSION_FLAGS))
|
||
|
|
{
|
||
|
|
this->Error("Unable to write the conversion flags during serialization.");
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT __stdcall DisconnectObject(DWORD dwReserved)
|
||
|
|
{
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
HRESULT __stdcall UnmarshalInterface(IStream* pStream, REFIID riid, void** ppv)
|
||
|
|
{
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
DWORD sizeOfPacket = 0;
|
||
|
|
unsigned long bytesRead = 0;
|
||
|
|
if(FAILED(hr = pStream->Read(&sizeOfPacket, 4, &bytesRead)))
|
||
|
|
{
|
||
|
|
this->Error("Unable to read the size of the packet during deserialization.");
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
char * unmarshalledPacket = new char[sizeOfPacket];
|
||
|
|
|
||
|
|
if(FAILED(pStream->Read(unmarshalledPacket, sizeOfPacket, &bytesRead)))
|
||
|
|
{
|
||
|
|
this->Error("Unable to read the packet during deserialization.");
|
||
|
|
delete [] unmarshalledPacket;
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
mxArray * unmarshalledMxArray = mclMxDeserialize(unmarshalledPacket, sizeOfPacket);
|
||
|
|
delete [] unmarshalledPacket;
|
||
|
|
|
||
|
|
_MCLCONVERSION_FLAGS flags;
|
||
|
|
this->mclInitConversionFlags(&flags);
|
||
|
|
VARIANT out;
|
||
|
|
VariantInit(&out);
|
||
|
|
if(this->mclmxArray2Variant(unmarshalledMxArray, &out, &flags) < 0)
|
||
|
|
{
|
||
|
|
this->Error("Deserialization error");
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
if(unmarshalledMxArray != NULL)
|
||
|
|
mxDestroyArray(unmarshalledMxArray);
|
||
|
|
|
||
|
|
|
||
|
|
//Try to unmarshall MWFlags from pStream. This should only be true for data types
|
||
|
|
//which have a MWFlags and it was not NULL during marshalling.
|
||
|
|
hr = pStream->Read(&flags, sizeof(_MCLCONVERSION_FLAGS), &bytesRead);
|
||
|
|
if(!(hr == S_OK || hr == S_FALSE))
|
||
|
|
{
|
||
|
|
this->Error("Unable to read the conversion flags during deserialization.");
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
//if unmarshalledMxArray == NULL, it means that the Variant type was default constructed
|
||
|
|
//but no value was assigned. So we can simply assign the this pointer to *ppv
|
||
|
|
if(unmarshalledMxArray != NULL)
|
||
|
|
{
|
||
|
|
if(bytesRead == sizeof(_MCLCONVERSION_FLAGS))
|
||
|
|
{
|
||
|
|
this->copyMWFlags(&flags, out.pdispVal);
|
||
|
|
}
|
||
|
|
*ppv = static_cast<T*>(out.pdispVal);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if(bytesRead == sizeof(_MCLCONVERSION_FLAGS))
|
||
|
|
{
|
||
|
|
copyMWFlags(&flags, this);
|
||
|
|
}
|
||
|
|
return QueryInterface(*piid, ppv);
|
||
|
|
}
|
||
|
|
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT __stdcall ReleaseMarshalData(IStream* pStream)
|
||
|
|
{
|
||
|
|
if(m_serializedData != NULL)
|
||
|
|
mxDestroyArray(m_serializedData);
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
|
||
|
|
HRESULT __stdcall Serialize(void * pv)
|
||
|
|
{
|
||
|
|
VARIANT wrapper;
|
||
|
|
wrapper.vt = VT_DISPATCH;
|
||
|
|
wrapper.pdispVal = static_cast<IDispatch *>(pv);
|
||
|
|
mxArray * temp = NULL;
|
||
|
|
_MCLCONVERSION_FLAGS flags;
|
||
|
|
this->mclInitConversionFlags(&flags);
|
||
|
|
if(this->mclVariant2mxArray(&wrapper,&temp,&flags) < 0)
|
||
|
|
{
|
||
|
|
this->Error("Error in data conversion");
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_serializedData = mclMxSerialize(temp);
|
||
|
|
if(temp != NULL)
|
||
|
|
mxDestroyArray(temp);
|
||
|
|
|
||
|
|
if(m_serializedData == NULL)
|
||
|
|
{
|
||
|
|
this->Error("Error in internal data serialization");
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
mxArray * m_serializedData;
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
#endif //ifdef __cplusplus
|
||
|
|
#endif //ifndef _MCLCOMCLASS_H_
|
||
|
|
|