compile fixes

1 files changed, 4 insertions, 1 deletions

diff --git a/pwmanager/pwmanager/pwminit.cpp b/pwmanager/pwmanager/pwminit.cpp
index 9238c8c..d775aa9 100644
--- a/pwmanager/pwmanager/pwminit.cpp
+++ b/pwmanager/pwmanager/pwminit.cpp
@@ -1,329 +1,332 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 2004 by Michael Buesch                                  *
  *   email: mbuesch@freenet.de                                             *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License version 2        *
  *   as published by the Free Software Foundation.                         *
  *                                                                         *
  ***************************************************************************/
 
 /***************************************************************************
  * copyright (C) 2004 by Ulf Schenk
  * This file is originaly based on version 1.0.1 of pwmanager
  * and was modified to run on embedded devices that run microkde
  *
  * $Id$
  **************************************************************************/  
 
 #include "pwminit.h"
 #include "randomizer.h"
 #include <qdir.h>
 
 #ifndef PWM_EMBEDDED
 #include "selftest.h"
 #include "configuration.h"
 #else
 #include "pwmprefs.h"
 #endif
 
 #include "pwm.h"
 #include "pwmexception.h"
 #include "pwmtray.h"
 #include "pwmdoc.h"
 
 #ifdef CONFIG_KWALLETIF
 # include "kwalletemu.h"
 #endif // CONFIG_KWALLETIF
 #ifdef CONFIG_KEYCARD
 # include "pwmkeycard.h"
 #endif // CONFIG_KEYCARD
 
 #include <qmessagebox.h>
 
 #include <kmessagebox.h>
 #ifndef PWM_EMBEDDED
 #include <kcmdlineargs.h>
 #include <kwin.h>
 #include <dcopclient.h>
 #endif
 
 #include <kapplication.h>
 #include <kiconloader.h>
 
 #include <signal.h>
 
 static PwMInit *sig_init_pointer;
+#ifdef _WIN32_
+static void sig_handler(int signum)
+#else
 static NOREGPARM void sig_handler(int signum)
+#endif
 {
 	switch (signum) {
 		case SIGINT:
 		case SIGTERM:
 			sig_init_pointer->shutdownApp(20 + signum);
 			break;
 		default:
 			printDebug(string("unhandled signal ")
 				   + tostr(signum));
 	}
 }
 
 
 
-
 PwMInit::PwMInit(PwMApplication *_app)
  : runStatus (unknown)
  , _curWidget (0)
  , _dcopClient (0)
  , _kwalletEmu (0)
  , _keycard (0)
  , _tray (0)
 {
 	sig_init_pointer = this;
 	app = _app;
 }
 
 PwMInit::~PwMInit()
 {
 #ifndef PWM_EMBEDDED
 	SelfTest::cancel();
 	// close all open mainwnds
 	QValueList<PwM *>::iterator i = _mainWndList.begin(),
 				    end = _mainWndList.end();
 
 #else
 	// close all open mainwnds
 	QValueList<PwM *>::Iterator i = _mainWndList.begin(),
 				    end = _mainWndList.end();
 #endif
 	while (i != end) {
 		disconnect(*i, SIGNAL(closed(PwM *)),
 			   this, SLOT(mainWndClosed(PwM *)));
 		delete *i;
 		++i;
 	}
 	_mainWndList.clear();
 	// close all remaining open documents
 	PwMDocList *_dl = PwMDoc::getOpenDocList();
 	vector<PwMDocList::listItem> dl = *(_dl->getList());
 	vector<PwMDocList::listItem>::iterator i2 = dl.begin(),
 					       end2 = dl.end();
 	while (i2 != end2) {
 		delete (*i2).doc;
 		++i2;
 	}
 
 #ifdef CONFIG_KWALLETIF
 	delete_ifnot_null(_kwalletEmu);
 #endif // CONFIG_KWALLETIF
 #ifdef CONFIG_KEYCARD
 	delete_ifnot_null(_keycard);
 #endif // CONFIG_KEYCARD
 	delete_ifnot_null(_tray);
 
 	Randomizer::cleanup();
 #ifndef PWM_EMBEDDED
 	Configuration::cleanup();
 #endif
 }
 
 void PwMInit::initializeApp()
 {
     //qDebug("PwMInit::initializeApp() ");
 	PWM_ASSERT(runStatus == unknown);
 	runStatus = init;
 	initPosixSignalHandler();
 	Randomizer::init();
 #ifndef PWM_EMBEDDED
 	Configuration::init();
 #endif
 	initDCOP();
 	initKWalletEmu();
 	initKeycard();
 	initTray();
 	handleCmdLineArgs();
 	bool openDeeplocked = false;
 	if (conf()->confGlobAutostartDeepLocked() ||
 	    savedCmd.open_deeplocked)
 		openDeeplocked = true;
     if ( false ){
     // LR is not working
 	//if (conf()->confWndAutoMinimizeOnStart() ||
     //   savedCmd.minToTray) {
 		PwMDoc *newDoc = createDoc();
         qDebug("  createDoc()");
 		if (!newDoc->openDocUi(newDoc,
 				       conf()->confGlobAutoStart(),
 				       openDeeplocked)) {
 			delete newDoc;
         }
 
 			//US ENH for embedded devices: in the case of failure, open a document the default way  
 			createMainWnd(conf()->confGlobAutoStart(),
 			      openDeeplocked,
 			      true,
 			      0,
 			      savedCmd.minimized);
 			
 
 
 
             //	}
 	} else {
 		createMainWnd(conf()->confGlobAutoStart(),
 			      openDeeplocked,
 			      true,
 			      0,
 			      savedCmd.minimized);
 	}
 
 	runStatus = running;
 }
 
 void PwMInit::shutdownApp(int exitStatus)
 {
 	printDebug(string("PwMInit::shutdownApp(")
 		   + tostr(exitStatus) + ") called.");
 	PWM_ASSERT((runStatus == running) || (runStatus == init));
 	runStatus = shutdown;
 	QApplication::exit(exitStatus);
 	/* The destructor of PwMInit is called when control
 	 * leaves main()
 	 */
 }
 
 void PwMInit::initPosixSignalHandler()
 {
 	signal(SIGINT, sig_handler);
 	signal(SIGTERM, sig_handler);
 }
 
 void PwMInit::initDCOP()
 {
 #ifndef PWM_EMBEDDED
 	_dcopClient = app->dcopClient();
 	_dcopClient->setNotifications(true);
 #endif
 
 }
 
 void PwMInit::initKWalletEmu(bool forceDisable, bool forceReload)
 {
 #ifdef CONFIG_KWALLETIF
 	if (!conf()->confGlobKwalletEmu() ||
 	    forceDisable) {
 		delete_ifnot_null(_kwalletEmu);
 		return;
 	}
 	try {
 		if (_kwalletEmu && forceReload)
 			delete_and_null(_kwalletEmu);
 		if (!_kwalletEmu)
 			_kwalletEmu = new KWalletEmu(this);
 	} catch (PwMException e) {
 		string errMsg("initializing KWallet emulation failed.  ID: ");
 		errMsg += tostr(static_cast<int>(e.getId()));
 		errMsg += "  err-message: ";
 		errMsg += e.getMessage();
 		printWarn(errMsg);
 		return;
 	}
 #else // CONFIG_KWALLETIF
 	PARAM_UNUSED(forceDisable);
 	PARAM_UNUSED(forceReload);
 #endif // CONFIG_KWALLETIF
 }
 
 void PwMInit::initKeycard()
 {
 #ifdef CONFIG_KEYCARD
 	PWM_ASSERT(!_keycard);
 	_keycard = new PwMKeyCard(this);
 #endif // CONFIG_KEYCARD
 }
 
 void PwMInit::initTray()
 {
 #ifdef PWM_EMBEDDED
   //US ENH : embedded version does not support a tray
   return;
 #endif
 
 	if (!conf()->confGlobTray()) {
 		if (!_tray)
 			return;
 		_tray->hide();
 		delete_and_null(_tray);
 		return;
 	}
 	if (_tray)
 		return;
 	_tray = new PwMTray(this);
 	connect(_tray, SIGNAL(quitSelected()),
 		this, SLOT(removeTrayAndQuit()));
 	connect(_tray, SIGNAL(closed(PwMTray *)),
 		this, SLOT(trayIconClosed(PwMTray *)));
 	KIconLoader icons;
 #ifndef PWM_EMBEDDED
 	_tray->setPixmap(icons.loadIcon(PACKAGE_NAME, KIcon::Small));
 #endif
 	_tray->show();
 	// connect the signals of all open documents.
 	const vector<PwMDocList::listItem> *dl = PwMDoc::getOpenDocList()->getList();
 	vector<PwMDocList::listItem>::const_iterator i = dl->begin(),
 						     end = dl->end();
 	while (i != end) {
 		_tray->connectDocToTray((*i).doc);
 		++i;
 	}
 }
 
 void PwMInit::removeTrayAndQuit()
 {
 	PWM_ASSERT(_tray);
 	// _tray is deleted in ~PwMInit
 	shutdownApp(0);
 }
 
 PwM * PwMInit::createMainWnd(const QString &loadFile,
 			     bool loadFileDeepLocked,
 			     bool virginity,
 			     PwMDoc *doc,
 			     bool minimized)
 {
 	PwM *newWnd;
 	if (!doc)
 		doc = createDoc();
 	newWnd = new PwM(this, doc, virginity);
 #ifndef PWM_EMBEDDED
 	_mainWndList.push_back(newWnd);
 #else
 	_mainWndList.append(newWnd);
 #endif
 	connect(newWnd, SIGNAL(closed(PwM *)),
 		this, SLOT(mainWndClosed(PwM *)));
 	connect(newWnd, SIGNAL(gotFocus(PwM *)),
 		this, SLOT(setCurWidget(PwM *)));
 	connect(newWnd, SIGNAL(lostFocus(PwM *)),
 		this, SLOT(resetCurWidget()));
 
 	//US ENH
 #ifndef PWM_EMBEDDED
 	if (minimized)
 		newWnd->showMinimized();
 	else
 		newWnd->show();
 
 #else //PWM_EMBEDDED
 
 #ifndef DESKTOP_VERSION
        app->showMainWidget( newWnd );
 #else //DESKTOP_VERSION
        app->setMainWidget( newWnd );
        newWnd->resize (640, 480 );
        newWnd->show();
        qDebug("show ");
 #endif //DESKTOP_VERSION
 
 #endif //PWM_EMBEDDED