Mac-4.7.4/src/activeqt/control/qaxservermain.cpp - platform/external/qt - Git at Google

 /****************************************************************************
 **
 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the ActiveQt framework of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:BSD$
 ** You may use this file under the terms of the BSD license as follows:
 **
 ** "Redistribution and use in source and binary forms, with or without
 ** modification, are permitted provided that the following conditions are
 ** met:
 **   * Redistributions of source code must retain the above copyright
 **     notice, this list of conditions and the following disclaimer.
 **   * Redistributions in binary form must reproduce the above copyright
 **     notice, this list of conditions and the following disclaimer in
 **     the documentation and/or other materials provided with the
 **     distribution.
 **   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
 **     the names of its contributors may be used to endorse or promote
 **     products derived from this software without specific prior written
 **     permission.
 **
 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include <qstringlist.h>
 #include <qvector.h>

 #include "qaxfactory.h"

 #ifndef QT_NO_WIN_ACTIVEQT

 #include <qt_windows.h>

 QT_BEGIN_NAMESPACE

 static DWORD *classRegistration = 0;
 static DWORD dwThreadID;
 static bool qAxActivity = false;
 static HANDLE hEventShutdown;

 #ifdef QT_DEBUG
 QT_STATIC_CONST DWORD dwTimeOut = 1000;
 QT_STATIC_CONST DWORD dwPause = 500;
 #else
 QT_STATIC_CONST DWORD dwTimeOut = 5000; // time for EXE to be idle before shutting down
 QT_STATIC_CONST DWORD dwPause = 1000; // time to wait for threads to finish up
 #endif

 extern HANDLE hEventShutdown;
 extern bool qAxActivity;
 extern HANDLE qAxInstance;
 extern bool qAxIsServer;
 extern bool qAxOutProcServer;
 extern wchar_t qAxModuleFilename[MAX_PATH];
 extern QString qAxInit();
 extern void qAxCleanup();
 extern HRESULT UpdateRegistry(BOOL bRegister);
 extern HRESULT GetClassObject(const GUID &clsid, const GUID &iid, void **ppUnk);
 extern ulong qAxLockCount();
 extern bool qax_winEventFilter(void *message);

 #if defined(Q_CC_BOR)
 extern "C" __stdcall HRESULT DumpIDL(const QString &outfile, const QString &ver);
 #else
 STDAPI DumpIDL(const QString &outfile, const QString &ver);
 #endif

 // Monitors the shutdown event
 static DWORD WINAPI MonitorProc(void* pv)
 {
     while (1) {
         WaitForSingleObject(hEventShutdown, INFINITE);
         DWORD dwWait=0;
         do {
             qAxActivity = false;
             dwWait = WaitForSingleObject(hEventShutdown, dwTimeOut);
         } while (dwWait == WAIT_OBJECT_0);
         // timed out
         if (!qAxActivity && !qAxLockCount()) // if no activity let's really bail
             break;
     }
     CloseHandle(hEventShutdown);
     PostThreadMessage(dwThreadID, WM_QUIT, 0, 0);
     PostQuitMessage(0);

     return 0;
 }

 // Starts the monitoring thread
 static bool StartMonitor()
 {
     dwThreadID = GetCurrentThreadId();
     hEventShutdown = CreateEvent(0, false, false, 0);
     if (hEventShutdown == 0)
         return false;
     DWORD dwThreadID;
     HANDLE h = CreateThread(0, 0, MonitorProc, 0, 0, &dwThreadID);
     return (h != NULL);
 }

 void qax_shutDown()
 {
     qAxActivity = true;
     if (hEventShutdown)
         SetEvent(hEventShutdown); // tell monitor that we transitioned to zero
 }

 /*
     Start the COM server (if necessary).
 */
 bool qax_startServer(QAxFactory::ServerType type)
 {
     if (qAxIsServer)
         return true;

     const QStringList keys = qAxFactory()->featureList();
     if (!keys.count())
         return false;

     if (!qAxFactory()->isService())
         StartMonitor();

     classRegistration = new DWORD[keys.count()];
     int object = 0;
     for (QStringList::ConstIterator key = keys.begin(); key != keys.end(); ++key, ++object) {
         IUnknown* p = 0;
         CLSID clsid = qAxFactory()->classID(*key);

         // Create a QClassFactory (implemented in qaxserverbase.cpp)
         HRESULT hRes = GetClassObject(clsid, IID_IClassFactory, (void**)&p);
         if (SUCCEEDED(hRes))
             hRes = CoRegisterClassObject(clsid, p, CLSCTX_LOCAL_SERVER,
                 type == QAxFactory::MultipleInstances ? REGCLS_MULTIPLEUSE : REGCLS_SINGLEUSE,
                 classRegistration+object);
         if (p)
             p->Release();
     }

     qAxIsServer = true;
     return true;
 }

 /*
     Stop the COM server (if necessary).
 */
 bool qax_stopServer()
 {
     if (!qAxIsServer || !classRegistration)
         return true;

     qAxIsServer = false;

     const QStringList keys = qAxFactory()->featureList();
     int object = 0;
     for (QStringList::ConstIterator key = keys.begin(); key != keys.end(); ++key, ++object)
         CoRevokeClassObject(classRegistration[object]);

     delete []classRegistration;
     classRegistration = 0;

     Sleep(dwPause); //wait for any threads to finish

     return true;
 }

 #if defined(Q_OS_WINCE)
 extern void __cdecl qWinMain(HINSTANCE, HINSTANCE, LPSTR, int, int &, QVector<char *> &);
 #else
 extern void qWinMain(HINSTANCE, HINSTANCE, LPSTR, int, int &, QVector<char *> &);
 #endif

 QT_END_NAMESPACE

 #if defined(QT_NEEDS_QMAIN)
 int qMain(int, char **);
 #define main qMain
 #else
 #if defined(Q_OS_WINCE)
 extern "C" int __cdecl main(int, char **);
 #else
 extern "C" int main(int, char **);
 #endif
 #endif


 EXTERN_C int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR, int nShowCmd)
 {
     QT_USE_NAMESPACE

     qAxOutProcServer = true;
     GetModuleFileName(0, qAxModuleFilename, MAX_PATH);
     qAxInstance = hInstance;

     QByteArray cmdParam = QString::fromWCharArray(GetCommandLine()).toLocal8Bit();
     QList<QByteArray> cmds = cmdParam.split(' ');
     QByteArray unprocessed;

     int nRet = 0;
     bool run = true;
     bool runServer = false;
     for (int i = 0; i < cmds.count(); ++i) {
         QByteArray cmd = cmds.at(i).toLower();
         if (cmd == "-activex" || cmd == "/activex" || cmd == "-embedding" || cmd == "/embedding") {
             runServer = true;
         } else if (cmd == "-unregserver" || cmd == "/unregserver") {
             nRet = UpdateRegistry(false);
             run = false;
             break;
         } else if (cmd == "-regserver" || cmd == "/regserver") {
             nRet = UpdateRegistry(true);
             run = false;
             break;
         } else if (cmd == "-dumpidl" || cmd == "/dumpidl") {
             ++i;
             if (i < cmds.count()) {
                 QByteArray outfile = cmds.at(i);
                 ++i;
                 QByteArray version;
                 if (i < cmds.count() && (cmds.at(i) == "-version" || cmds.at(i) == "/version")) {
                     ++i;
                     if (i < cmds.count())
                         version = cmds.at(i);
                     else
                         version = "1.0";
                 }

                 nRet = DumpIDL(QString::fromLatin1(outfile.constData()), QString::fromLatin1(version.constData()));
             } else {
                 qWarning("Wrong commandline syntax: <app> -dumpidl <idl file> [-version <x.y.z>]");
             }
             run = false;
             break;
         } else {
             unprocessed += cmds.at(i) + ' ';
         }
     }

     if (run) {
         HRESULT hRes = CoInitialize(0);

         int argc;
         QVector<char*> argv(8);
         qWinMain(hInstance, hPrevInstance, unprocessed.data(), nShowCmd, argc, argv);
         qAxInit();
         if (runServer)
             QAxFactory::startServer();
         nRet = ::main(argc, argv.data());
         QAxFactory::stopServer();
         qAxCleanup();
         CoUninitialize();

     }

     return nRet;
 }

 #endif // QT_NO_WIN_ACTIVEQT
	/****************************************************************************
	**
	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
	** All rights reserved.
	** Contact: Nokia Corporation (qt-info@nokia.com)
	**
	** This file is part of the ActiveQt framework of the Qt Toolkit.
	**
	** $QT_BEGIN_LICENSE:BSD$
	** You may use this file under the terms of the BSD license as follows:
	**
	** "Redistribution and use in source and binary forms, with or without
	** modification, are permitted provided that the following conditions are
	** met:
	** * Redistributions of source code must retain the above copyright
	** notice, this list of conditions and the following disclaimer.
	** * Redistributions in binary form must reproduce the above copyright
	** notice, this list of conditions and the following disclaimer in
	** the documentation and/or other materials provided with the
	** distribution.
	** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
	** the names of its contributors may be used to endorse or promote
	** products derived from this software without specific prior written
	** permission.
	**
	** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
	** $QT_END_LICENSE$
	**
	****************************************************************************/

	#include <qstringlist.h>
	#include <qvector.h>

	#include "qaxfactory.h"

	#ifndef QT_NO_WIN_ACTIVEQT

	#include <qt_windows.h>

	QT_BEGIN_NAMESPACE

	static DWORD *classRegistration = 0;
	static DWORD dwThreadID;
	static bool qAxActivity = false;
	static HANDLE hEventShutdown;

	#ifdef QT_DEBUG
	QT_STATIC_CONST DWORD dwTimeOut = 1000;
	QT_STATIC_CONST DWORD dwPause = 500;
	#else
	QT_STATIC_CONST DWORD dwTimeOut = 5000; // time for EXE to be idle before shutting down
	QT_STATIC_CONST DWORD dwPause = 1000; // time to wait for threads to finish up
	#endif

	extern HANDLE hEventShutdown;
	extern bool qAxActivity;
	extern HANDLE qAxInstance;
	extern bool qAxIsServer;
	extern bool qAxOutProcServer;
	extern wchar_t qAxModuleFilename[MAX_PATH];
	extern QString qAxInit();
	extern void qAxCleanup();
	extern HRESULT UpdateRegistry(BOOL bRegister);
	extern HRESULT GetClassObject(const GUID &clsid, const GUID &iid, void **ppUnk);
	extern ulong qAxLockCount();
	extern bool qax_winEventFilter(void *message);

	#if defined(Q_CC_BOR)
	extern "C" __stdcall HRESULT DumpIDL(const QString &outfile, const QString &ver);
	#else
	STDAPI DumpIDL(const QString &outfile, const QString &ver);
	#endif

	// Monitors the shutdown event
	static DWORD WINAPI MonitorProc(void* pv)
	{
	while (1) {
	WaitForSingleObject(hEventShutdown, INFINITE);
	DWORD dwWait=0;
	do {
	qAxActivity = false;
	dwWait = WaitForSingleObject(hEventShutdown, dwTimeOut);
	} while (dwWait == WAIT_OBJECT_0);
	// timed out
	if (!qAxActivity && !qAxLockCount()) // if no activity let's really bail
	break;
	}
	CloseHandle(hEventShutdown);
	PostThreadMessage(dwThreadID, WM_QUIT, 0, 0);
	PostQuitMessage(0);

	return 0;
	}

	// Starts the monitoring thread
	static bool StartMonitor()
	{
	dwThreadID = GetCurrentThreadId();
	hEventShutdown = CreateEvent(0, false, false, 0);
	if (hEventShutdown == 0)
	return false;
	DWORD dwThreadID;
	HANDLE h = CreateThread(0, 0, MonitorProc, 0, 0, &dwThreadID);
	return (h != NULL);
	}

	void qax_shutDown()
	{
	qAxActivity = true;
	if (hEventShutdown)
	SetEvent(hEventShutdown); // tell monitor that we transitioned to zero
	}

	/*
	Start the COM server (if necessary).
	*/
	bool qax_startServer(QAxFactory::ServerType type)
	{
	if (qAxIsServer)
	return true;

	const QStringList keys = qAxFactory()->featureList();
	if (!keys.count())
	return false;

	if (!qAxFactory()->isService())
	StartMonitor();

	classRegistration = new DWORD[keys.count()];
	int object = 0;
	for (QStringList::ConstIterator key = keys.begin(); key != keys.end(); ++key, ++object) {
	IUnknown* p = 0;
	CLSID clsid = qAxFactory()->classID(*key);

	// Create a QClassFactory (implemented in qaxserverbase.cpp)
	HRESULT hRes = GetClassObject(clsid, IID_IClassFactory, (void**)&p);
	if (SUCCEEDED(hRes))
	hRes = CoRegisterClassObject(clsid, p, CLSCTX_LOCAL_SERVER,
	type == QAxFactory::MultipleInstances ? REGCLS_MULTIPLEUSE : REGCLS_SINGLEUSE,
	classRegistration+object);
	if (p)
	p->Release();
	}

	qAxIsServer = true;
	return true;
	}

	/*
	Stop the COM server (if necessary).
	*/
	bool qax_stopServer()
	{
	if (!qAxIsServer \|\| !classRegistration)
	return true;

	qAxIsServer = false;

	const QStringList keys = qAxFactory()->featureList();
	int object = 0;
	for (QStringList::ConstIterator key = keys.begin(); key != keys.end(); ++key, ++object)
	CoRevokeClassObject(classRegistration[object]);

	delete []classRegistration;
	classRegistration = 0;

	Sleep(dwPause); //wait for any threads to finish

	return true;
	}

	#if defined(Q_OS_WINCE)
	extern void __cdecl qWinMain(HINSTANCE, HINSTANCE, LPSTR, int, int &, QVector<char *> &);
	#else
	extern void qWinMain(HINSTANCE, HINSTANCE, LPSTR, int, int &, QVector<char *> &);
	#endif

	QT_END_NAMESPACE

	#if defined(QT_NEEDS_QMAIN)
	int qMain(int, char **);
	#define main qMain
	#else
	#if defined(Q_OS_WINCE)
	extern "C" int __cdecl main(int, char **);
	#else
	extern "C" int main(int, char **);
	#endif
	#endif


	EXTERN_C int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR, int nShowCmd)
	{
	QT_USE_NAMESPACE

	qAxOutProcServer = true;
	GetModuleFileName(0, qAxModuleFilename, MAX_PATH);
	qAxInstance = hInstance;

	QByteArray cmdParam = QString::fromWCharArray(GetCommandLine()).toLocal8Bit();
	QList<QByteArray> cmds = cmdParam.split(' ');
	QByteArray unprocessed;

	int nRet = 0;
	bool run = true;
	bool runServer = false;
	for (int i = 0; i < cmds.count(); ++i) {
	QByteArray cmd = cmds.at(i).toLower();
	if (cmd == "-activex" \|\| cmd == "/activex" \|\| cmd == "-embedding" \|\| cmd == "/embedding") {
	runServer = true;
	} else if (cmd == "-unregserver" \|\| cmd == "/unregserver") {
	nRet = UpdateRegistry(false);
	run = false;
	break;
	} else if (cmd == "-regserver" \|\| cmd == "/regserver") {
	nRet = UpdateRegistry(true);
	run = false;
	break;
	} else if (cmd == "-dumpidl" \|\| cmd == "/dumpidl") {
	++i;
	if (i < cmds.count()) {
	QByteArray outfile = cmds.at(i);
	++i;
	QByteArray version;
	if (i < cmds.count() && (cmds.at(i) == "-version" \|\| cmds.at(i) == "/version")) {
	++i;
	if (i < cmds.count())
	version = cmds.at(i);
	else
	version = "1.0";
	}

	nRet = DumpIDL(QString::fromLatin1(outfile.constData()), QString::fromLatin1(version.constData()));
	} else {
	qWarning("Wrong commandline syntax: <app> -dumpidl <idl file> [-version <x.y.z>]");
	}
	run = false;
	break;
	} else {
	unprocessed += cmds.at(i) + ' ';
	}
	}

	if (run) {
	HRESULT hRes = CoInitialize(0);

	int argc;
	QVector<char*> argv(8);
	qWinMain(hInstance, hPrevInstance, unprocessed.data(), nShowCmd, argc, argv);
	qAxInit();
	if (runServer)
	QAxFactory::startServer();
	nRet = ::main(argc, argv.data());
	QAxFactory::stopServer();
	qAxCleanup();
	CoUninitialize();

	}

	return nRet;
	}

	#endif // QT_NO_WIN_ACTIVEQT