keepassx1/src/mainwindow.cpp

/***************************************************************************
 *   Copyright (C) 2005-2007 by Tarek Saidi                                *
 *   tarek.saidi@arcor.de                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; version 2 of the License.               *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include <QPointer>
#include <QToolBar>
#include <QStatusBar>
#include "mainwindow.h"
#include "lib/AutoType.h"
#include "import/Import_PwManager.h"
#include "import/Import_KWalletXml.h"
#include "import/Import_KeePassX_Xml.h"
#include "export/Export_Txt.h"
#include "export/Export_KeePassX_Xml.h"

#include "dialogs/AboutDlg.h"
#include "dialogs/SearchDlg.h"
#include "dialogs/SettingsDlg.h"
#include "dialogs/DatabaseSettingsDlg.h"
#include "dialogs/PasswordDlg.h"
#include "dialogs/SimplePasswordDlg.h"
#include "dialogs/PasswordGenDlg.h"
#include "dialogs/CollectEntropyDlg.h"
#include "dialogs/CustomizeDetailViewDlg.h"
#include "dialogs/ExpiredEntriesDlg.h"
//#include "dialogs/TrashCanDlg.h" //TODO TrashCan
#include "dialogs/AddBookmarkDlg.h"
#include "dialogs/ManageBookmarksDlg.h"
#include "dialogs/HelpDlg.h"

#if defined(GLOBAL_AUTOTYPE) && defined(Q_WS_MAC)
#include "lib/HelperMacX.h"
#endif

Import_KeePassX_Xml import_KeePassX_Xml;
Import_PwManager import_PwManager;
Import_KWalletXml import_KWalletXml;
Export_Txt export_Txt;
Export_KeePassX_Xml export_KeePassX_Xml;

KeepassMainWindow::KeepassMainWindow(const QString& ArgFile,bool ArgMin,bool ArgLock,QWidget *parent, Qt::WFlags flags) :QMainWindow(parent,flags){
	ShutingDown=false;
	IsLocked=false;
	EventOccurred=true;
	inactivityCounter=0;
	InUnLock=false;
	unlockDlg=NULL;
	db=NULL;
	setupUi(this);
#ifdef Q_WS_MAC
	setUnifiedTitleAndToolBarOnMac(true);
#endif
#ifdef AUTOTYPE
	initAutoType(this);
#endif
#ifdef GLOBAL_AUTOTYPE
	autoType->registerGlobalShortcut(config->globalShortcut());
#endif
	setWindowModified(false);
	QByteArray windowGeo = config->mainWindowGeometry();
	if (!windowGeo.isEmpty())
		restoreGeometry(windowGeo);
	VSplitter->restoreState(config->vSplitterPos());
	HSplitter->restoreState(config->hSplitterPos());
	SysTray=new QSystemTrayIcon(this);
	setupToolbar();
	setupIcons();
	setStateFileOpen(false);
	setupMenus();
	DetailView->setVisible(config->showEntryDetails());
	StatusBarGeneral=new QLabel(statusBar());
	//StatusBarSelection=new QLabel(statusBar());
	statusBar()->addWidget(StatusBarGeneral,15);
	//statusBar()->addWidget(StatusBarSelection,85);
	statusBar()->setVisible(config->showStatusbar());
	setStatusBarMsg(StatusBarReady);
#ifndef Q_WS_MAC
	if (config->alwaysOnTop())
		setWindowFlags(windowFlags() | Qt::WindowStaysOnTopHint);
#endif

	NormalCentralWidget=QMainWindow::centralWidget();
	LockedCentralWidget=new QWidget(this);
	WorkspaceLockedWidget.setupUi(LockedCentralWidget);
	LockedCentralWidget->setVisible(false);

	setupConnections();
	connect(qApp, SIGNAL(commitDataRequest(QSessionManager&)), SLOT(OnShutdown(QSessionManager&)));
	
	inactivityTimer = new QTimer(this);
	inactivityTimer->setInterval(500);
	connect(inactivityTimer, SIGNAL(timeout()), SLOT(OnInactivityTimer()));
	if (config->lockOnInactivity() && config->lockAfterSec()!=0)
		inactivityTimer->start();

	bool showWindow = !ArgMin;
	FileOpen=false;
	if(!ArgFile.isEmpty()){
		QString f = QDir::cleanPath(QDir::current().absoluteFilePath(ArgFile));
		if (ArgLock)
			fakeOpenDatabase(f);
		else
			openDatabase(f,false);
	}
	else if(config->openLastFile() && !config->lastFile().isEmpty()){
		QFileInfo file(config->lastFile());
		if(file.exists()){
			QString f = QDir::cleanPath(QDir::current().absoluteFilePath(config->lastFile()));
			if (!ArgMin)
				showWindow = !config->startMinimized();
			if (ArgLock || config->startLocked())
				fakeOpenDatabase(f);
			else
				openDatabase(f,true);
		}
		else
			config->setLastFile(QString());
	}
	
	// TODO HelpBrowser
	/*HelpBrowser = new QAssistantClient(QString(),this);
	HelpBrowser->setArguments(QStringList()<< "-profile" << "share/keepass/doc/keepassx.adp");*/

	createBookmarkActions();
	
	if (showWindow)
		show();
	else if (!config->showSysTrayIcon())
		showMinimized();
}

void KeepassMainWindow::setupConnections(){
	connect(FileNewAction, SIGNAL(triggered()), this, SLOT(OnFileNewKdb()));
	connect(FileOpenAction, SIGNAL(triggered()), this, SLOT(OnFileOpen()));
	connect(FileCloseAction, SIGNAL(triggered()), this, SLOT(OnFileClose()));
	connect(FileSaveAction, SIGNAL(triggered()), this, SLOT(OnFileSave()));
	connect(FileSaveAsAction, SIGNAL(triggered()), this, SLOT(OnFileSaveAs()));
	connect(FileSettingsAction, SIGNAL(triggered()), this, SLOT(OnFileSettings()));
	connect(FileChangeKeyAction, SIGNAL(triggered()), this, SLOT(OnFileChangeKey()));
	connect(FileExitAction, SIGNAL(triggered()), this, SLOT(OnFileExit()));
	connect(FileUnLockWorkspaceAction,SIGNAL(triggered()), this, SLOT(OnUnLockWorkspace()));
	connect(menuImport,SIGNAL(triggered(QAction*)),this,SLOT(OnImport(QAction*)));
	connect(menuExport,SIGNAL(triggered(QAction*)),this,SLOT(OnExport(QAction*)));
	connect(menuBookmarks,SIGNAL(triggered(QAction*)),this,SLOT(OnBookmarkTriggered(QAction*)));

	connect(EditNewGroupAction, SIGNAL(triggered()), GroupView, SLOT(OnNewGroup()));
	connect(EditNewSubgroupAction, SIGNAL(triggered()), GroupView, SLOT(OnNewSubgroup()));
	connect(EditEditGroupAction, SIGNAL(triggered()), GroupView, SLOT(OnEditGroup()));
	connect(EditDeleteGroupAction, SIGNAL(triggered()), GroupView, SLOT(OnDeleteGroup()));
	connect(EditGroupSortAction, SIGNAL(triggered()), GroupView, SLOT(OnSort()));
	connect(EditNewEntryAction, SIGNAL(triggered()), EntryView, SLOT(OnNewEntry()));
	connect(EditEditEntryAction, SIGNAL(triggered()), EntryView, SLOT(OnEditEntry()));
	connect(EntryView, SIGNAL(requestCreateGroup(QString,quint32,GroupViewItem*)),
			GroupView, SLOT(createGroup(QString,quint32,GroupViewItem*)));
	connect(EditCloneEntryAction, SIGNAL(triggered()), EntryView, SLOT(OnCloneEntry()));
	connect(EditDeleteEntryAction, SIGNAL(triggered()), EntryView, SLOT(OnDeleteEntry()));
	connect(EditUsernameToClipboardAction, SIGNAL(triggered()), EntryView, SLOT(OnUsernameToClipboard()));
	connect(EditPasswordToClipboardAction, SIGNAL(triggered()), EntryView, SLOT(OnPasswordToClipboard()));
	connect(EditOpenUrlAction, SIGNAL(triggered()), EntryView, SLOT(OnEditOpenUrl()));
	connect(EditCopyUrlAction, SIGNAL(triggered()), EntryView, SLOT(OnEditCopyUrl()));
	connect(EditSaveAttachmentAction, SIGNAL(triggered()),EntryView, SLOT(OnSaveAttachment()));
	connect(EditSearchAction, SIGNAL(triggered()), this, SLOT(OnSearch()));
	connect(EditGroupSearchAction, SIGNAL(triggered()), this, SLOT(OnGroupSearch()));
#ifdef AUTOTYPE
	connect(EditAutoTypeAction,SIGNAL(triggered()),EntryView,SLOT(OnAutoType()));
#endif

	connect(ViewShowToolbarAction,SIGNAL(toggled(bool)),this,SLOT(OnViewShowToolbar(bool)));
	connect(ViewShowEntryDetailsAction,SIGNAL(toggled(bool)),this,SLOT(OnViewShowEntryDetails(bool)));
	connect(ViewHidePasswordsAction,SIGNAL(toggled(bool)), this, SLOT(OnUsernPasswVisibilityChanged()));
	connect(ViewHideUsernamesAction,SIGNAL(toggled(bool)), this, SLOT(OnUsernPasswVisibilityChanged()));

	connect(menuColumns,SIGNAL(triggered(QAction*)),this,SLOT(OnColumnVisibilityChanged()));
	connect(ViewToolButtonSize16Action,SIGNAL(toggled(bool)), this, SLOT(OnViewToolbarIconSize16(bool)));
	connect(ViewToolButtonSize22Action,SIGNAL(toggled(bool)), this, SLOT(OnViewToolbarIconSize22(bool)));
	connect(ViewToolButtonSize28Action,SIGNAL(toggled(bool)), this, SLOT(OnViewToolbarIconSize28(bool)));
	connect(ViewShowStatusbarAction,SIGNAL(toggled(bool)),statusBar(),SLOT(setVisible(bool)));
#ifdef Q_WS_MAC
	connect(ViewMinimizeAction, SIGNAL(triggered()), SLOT(showMinimized()));
#endif

	connect(ExtrasSettingsAction,SIGNAL(triggered(bool)),this,SLOT(OnExtrasSettings()));
	connect(ExtrasPasswordGenAction,SIGNAL(triggered(bool)),this,SLOT(OnExtrasPasswordGen()));
	connect(ExtrasShowExpiredEntriesAction,SIGNAL(triggered(bool)),this,SLOT(OnExtrasShowExpiredEntries()));
	//connect(ExtrasTrashCanAction,SIGNAL(triggered(bool)),this,SLOT(OnExtrasTrashCan())); //TODO ExtrasTrashCan

	connect(HelpHandbookAction,SIGNAL(triggered()),this,SLOT(OnHelpHandbook()));
	connect(HelpAboutAction,SIGNAL(triggered()),this,SLOT(OnHelpAbout()));

	connect(QuickSearchEdit,SIGNAL(returnPressed()), this, SLOT(OnQuickSearch()));
	connect(GroupView,SIGNAL(groupChanged(IGroupHandle*)),EntryView,SLOT(OnGroupChanged(IGroupHandle*)));
	connect(GroupView,SIGNAL(groupChanged(IGroupHandle*)),this,SLOT(OnGroupSelectionChanged(IGroupHandle*)));
	connect(GroupView,SIGNAL(fileModified()),this,SLOT(OnFileModified()));
	connect(EntryView,SIGNAL(fileModified()),this,SLOT(OnFileModified()));
	connect(EntryView,SIGNAL(selectionChanged(SelectionState)),this,SLOT(OnEntryChanged(SelectionState)));
	connect(GroupView,SIGNAL(searchResultsSelected()),EntryView,SLOT(OnShowSearchResults()));
	connect(GroupView,SIGNAL(searchResultsSelected()),this,SLOT(OnShowSearchResults()));
	connect(GroupView,SIGNAL(entriesDropped()),EntryView,SLOT(removeDragItems()));
	connect(HideSearchResultsAction,SIGNAL(triggered()),GroupView,SLOT(OnHideSearchResults()));
	connect(EntryView, SIGNAL(viewModeChanged(bool)), SLOT(loadColumnVisibility()));
	connect(EntryView, SIGNAL(viewModeChanged(bool)), ViewColumnsGroupAction, SLOT(setVisible(bool)));

	connect(SysTray,SIGNAL(activated(QSystemTrayIcon::ActivationReason)),this,SLOT(OnSysTrayActivated(QSystemTrayIcon::ActivationReason)));
	connect(DetailView,SIGNAL(anchorClicked(const QUrl&)),this,SLOT(OnDetailViewUrlClicked(const QUrl&)));
	connect(WorkspaceLockedWidget.Button_Unlock,SIGNAL(clicked()),this,SLOT(OnUnLockWorkspace()));
	connect(WorkspaceLockedWidget.Button_CloseDatabase,SIGNAL(clicked()),this,SLOT(OnLockClose()));
}

void KeepassMainWindow::setupToolbar(){
	toolBar=new QToolBar(this);
	toolBar->setMovable(false);
	addToolBar(toolBar);
	toolBar->setIconSize(QSize(config->toolbarIconSize(),config->toolbarIconSize()));
	ViewShowToolbarAction=toolBar->toggleViewAction();
	toolBar->addAction(FileNewAction);
	toolBar->addAction(FileOpenAction);
	toolBar->addAction(FileSaveAction);
	toolBar->addSeparator();
	toolBar->addAction(EditNewEntryAction);
	toolBar->addAction(EditEditEntryAction);
	toolBar->addAction(EditDeleteEntryAction);
	toolBar->addSeparator();
	toolBar->addAction(EditUsernameToClipboardAction);
	toolBar->addAction(EditPasswordToClipboardAction);
	toolBar->addSeparator();
	toolBar->addAction(FileUnLockWorkspaceAction);
	toolBar->addSeparator();
	QuickSearchEdit=new QLineEdit(toolBar);
	QuickSearchEdit->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed);
	toolBar->addWidget(QuickSearchEdit);
	toolBar->setVisible(config->showToolbar());
}

void KeepassMainWindow::setupIcons(){
	setWindowIcon(getIcon("keepassx_small"));
	FileNewAction->setIcon(getIcon("filenew"));
	FileOpenAction->setIcon(getIcon("fileopen"));
	FileSaveAction->setIcon(getIcon("filesave"));
	FileSaveAsAction->setIcon(getIcon("filesaveas"));
	FileCloseAction->setIcon(getIcon("fileclose"));
	FileSettingsAction->setIcon(getIcon("dbsettings"));
	FileUnLockWorkspaceAction->setIcon(getIcon("lock"));
	FileExitAction->setIcon(getIcon("exit"));
	EditNewEntryAction->setIcon(getIcon("newentry"));
	EditEditEntryAction->setIcon(getIcon("editentry"));
	EditDeleteEntryAction->setIcon(getIcon("deleteentry"));
	EditGroupSortAction->setIcon(getIcon("swap"));
	EditUsernameToClipboardAction->setIcon(getIcon("copyusername"));
	EditPasswordToClipboardAction->setIcon(getIcon("copypwd"));
	EditCloneEntryAction->setIcon(getIcon("cloneentry"));
	EditOpenUrlAction->setIcon(getIcon("openurl"));
	EditSaveAttachmentAction->setIcon(getIcon("filesave"));
	EditNewGroupAction->setIcon(getIcon("newgroup"));
	EditNewSubgroupAction->setIcon(getIcon("newgroup"));
	EditEditGroupAction->setIcon(getIcon("editgroup"));
	EditDeleteGroupAction->setIcon(getIcon("deletegroup"));
	EditSearchAction->setIcon(getIcon("dbsearch"));
	EditGroupSearchAction->setIcon(getIcon("groupsearch"));
	ExtrasShowExpiredEntriesAction->setIcon(getIcon("expired"));
	ExtrasPasswordGenAction->setIcon(getIcon("generator"));
	//ExtrasTrashCanAction->setIcon(getIcon("trashcan")); //TODO ExtrasTrashCan
	ExtrasSettingsAction->setIcon(getIcon("appsettings"));
#ifdef AUTOTYPE
	EditAutoTypeAction->setIcon(getIcon("autotype"));
#else
	EditAutoTypeAction->setVisible(false);
#endif
	HelpHandbookAction->setIcon(getIcon("manual"));
	HelpAboutAction->setIcon(getIcon("help_about"));
	menuBookmarks->menuAction()->setIcon(getIcon("bookmark_folder"));
	AddThisAsBookmarkAction->setIcon(getIcon("bookmark_this"));
	AddBookmarkAction->setIcon(getIcon("bookmark_add"));
	ManageBookmarksAction->setIcon(getIcon("bookmark"));
	SysTray->setIcon(getIcon("keepassx"));
	if(config->showSysTrayIcon())
		SysTray->show();
}

void KeepassMainWindow::setupMenus(){
	GroupView->ContextMenu->addAction(EditNewSubgroupAction);
	GroupView->ContextMenu->addAction(EditEditGroupAction);
	GroupView->ContextMenu->addAction(EditDeleteGroupAction);
	GroupView->ContextMenu->addAction(EditGroupSortAction);
	GroupView->ContextMenu->addSeparator();
	GroupView->ContextMenu->addAction(EditNewEntryAction);
	GroupView->ContextMenu->addSeparator();
	GroupView->ContextMenu->addAction(EditGroupSearchAction);
	GroupView->ContextMenuSearchGroup->addAction(HideSearchResultsAction);

	EntryView->ContextMenu->addAction(EditUsernameToClipboardAction);
	EntryView->ContextMenu->addAction(EditPasswordToClipboardAction);
	EntryView->ContextMenu->addAction(EditOpenUrlAction);
	EntryView->ContextMenu->addAction(EditCopyUrlAction);
	EntryView->ContextMenu->addAction(EditSaveAttachmentAction);
#ifdef AUTOTYPE
	EntryView->ContextMenu->addAction(EditAutoTypeAction);
#endif
	EntryView->ContextMenu->addSeparator();
	EntryView->ContextMenu->addAction(EditNewEntryAction);
	EntryView->ContextMenu->addAction(EditEditEntryAction);
	EntryView->ContextMenu->addAction(EditCloneEntryAction);
	EntryView->ContextMenu->addAction(EditDeleteEntryAction);

	ViewShowToolbarAction->setText(tr("Show &Toolbar"));
	ViewMenu->insertAction(ViewShowEntryDetailsAction,ViewShowToolbarAction);
	ViewShowToolbarAction->setChecked(config->showToolbar());
	ViewShowEntryDetailsAction->setChecked(config->showEntryDetails());
	ViewHidePasswordsAction->setChecked(config->hidePasswords());
	ViewHideUsernamesAction->setChecked(config->hideUsernames());
	loadColumnVisibility();
	ViewShowStatusbarAction->setChecked(config->showStatusbar());

	switch(config->toolbarIconSize()){
		case 16: ViewToolButtonSize16Action->setChecked(true); break;
		case 22: ViewToolButtonSize22Action->setChecked(true); break;
		case 28: ViewToolButtonSize28Action->setChecked(true); break;
	}
	
#ifdef Q_WS_MAC
	ViewMenu->addSeparator();
	ViewMenu->addAction(ViewMinimizeAction);
#endif

	SysTrayMenu = new QMenu(APP_DISPLAY_NAME,this);
	SysTrayMenu->addAction(FileUnLockWorkspaceAction);
	SysTrayMenu->addSeparator();
	SysTrayMenu->addAction(FileExitAction);
	SysTray->setContextMenu(SysTrayMenu);
	updateTrayTooltip();

	#define _add_import(name){\
	QAction* import=new QAction(this);\
	import->setData(qVariantFromValue(dynamic_cast<QObject*>(&name)));\
	import->setText(name.title());\
	menuImport->addAction(import);}

	#define _add_export(name){\
	QAction* Export=new QAction(this);\
	Export->setData(qVariantFromValue(dynamic_cast<QObject*>(&name)));\
	Export->setText(name.title());\
	menuExport->addAction(Export);}

	_add_import(import_KeePassX_Xml)
	_add_import(import_PwManager)
	_add_import(import_KWalletXml)
	_add_export(export_Txt);
	_add_export(export_KeePassX_Xml);

	FileNewAction->setShortcut(tr("Ctrl+N"));
	FileOpenAction->setShortcut(tr("Ctrl+O"));
	FileCloseAction->setShortcut(tr("Ctrl+W"));
	FileSaveAction->setShortcut(tr("Ctrl+S"));
	FileUnLockWorkspaceAction->setShortcut(tr("Ctrl+L"));
	FileExitAction->setShortcut(tr("Ctrl+Q"));
	EditNewGroupAction->setShortcut(tr("Ctrl+G"));
	EditPasswordToClipboardAction->setShortcut(tr("Ctrl+C"));
	EditUsernameToClipboardAction->setShortcut(tr("Ctrl+B"));
	EditOpenUrlAction->setShortcut(tr("Ctrl+U"));
	EditCopyUrlAction->setShortcut(tr("Ctrl+I"));
	EditNewEntryAction->setShortcut(tr("Ctrl+Y"));
	EditEditEntryAction->setShortcut(tr("Ctrl+E"));
	EditDeleteEntryAction->setShortcut(tr("Ctrl+D"));
	EditCloneEntryAction->setShortcut(tr("Ctrl+K"));
	EditSearchAction->setShortcut(tr("Ctrl+F"));
	ExtrasPasswordGenAction->setShortcut(tr("Ctrl+P"));
	ExtrasShowExpiredEntriesAction->setShortcut(tr("Ctrl+X"));
#ifdef AUTOTYPE
	EditAutoTypeAction->setShortcut(tr("Ctrl+V"));
#endif
#ifdef Q_WS_MAC
	FileSaveAsAction->setShortcut(tr("Shift+Ctrl+S"));
	EditGroupSearchAction->setShortcut(tr("Shift+Ctrl+F"));
	ViewMinimizeAction->setShortcut(tr("Ctrl+M"));
#endif

	//ExtrasTrashCanAction->setVisible(false); //TODO For KP 2.x only
	menuBookmarks->menuAction()->setVisible(config->featureBookmarks());
}

void KeepassMainWindow::loadColumnVisibility() {
	ViewColumnsTitleAction->setChecked(EntryView->columnVisible(0));
	ViewColumnsUsernameAction->setChecked(EntryView->columnVisible(1));
	ViewColumnsUrlAction->setChecked(EntryView->columnVisible(2));
	ViewColumnsPasswordAction->setChecked(EntryView->columnVisible(3));
	ViewColumnsCommentAction->setChecked(EntryView->columnVisible(4));
	ViewColumnsExpireAction->setChecked(EntryView->columnVisible(5));
	ViewColumnsCreationAction->setChecked(EntryView->columnVisible(6));
	ViewColumnsLastChangeAction->setChecked(EntryView->columnVisible(7));
	ViewColumnsLastAccessAction->setChecked(EntryView->columnVisible(8));
	ViewColumnsAttachmentAction->setChecked(EntryView->columnVisible(9));
	ViewColumnsGroupAction->setChecked(EntryView->columnVisible(10));
}

void KeepassMainWindow::setupDatabaseConnections(IDatabase* DB){
	ICustomIcons* CustomIconsDb=dynamic_cast<ICustomIcons*>(DB);
	if(CustomIconsDb){
		connect(CustomIconsDb,SIGNAL(iconsModified()),this,SLOT(OnFileModified()));
		connect(CustomIconsDb,SIGNAL(iconsModified()),EntryView,SLOT(updateIcons()));
		connect(CustomIconsDb,SIGNAL(iconsModified()),GroupView,SLOT(updateIcons()));
	}
}


bool KeepassMainWindow::openDatabase(QString filename,bool IsAuto){
	if (!QFile::exists(filename)){
		QMessageBox::critical(this, tr("Error"), tr("The database file does not exist."));
		return false;
	}
	
	dbReadOnly = false;
	
	if (QFile::exists(filename+".lock")){
		QMessageBox msgBox(this);
		msgBox.setIcon(QMessageBox::Question);
		msgBox.setWindowTitle(tr("Database locked"));
		msgBox.setText(tr("The database you are trying to open is locked.\n"
				"This means that either someone else has opened the file or KeePassX crashed last time it opened the database.\n\n"
				"Do you want to open it anyway?"
		));
		msgBox.addButton(QMessageBox::Yes);
		msgBox.addButton(QMessageBox::No);
		QPushButton* readOnlyButton = new QPushButton(tr("Open read-only"), &msgBox);
		msgBox.addButton(readOnlyButton, QMessageBox::AcceptRole);
		msgBox.setDefaultButton(readOnlyButton);
#if defined(GLOBAL_AUTOTYPE) && defined(Q_WS_MAC)
		// On MacX, QMessageBox is not brought to foreground on exec() when app not already there
		HelperMacX::processToFront(HelperMacX::getKeepassxPID());
#endif
		msgBox.exec();
		
		if (!msgBox.clickedButton() || msgBox.clickedButton() == msgBox.button(QMessageBox::No))
			return false;
		else if (msgBox.clickedButton() == readOnlyButton)
			dbReadOnly = true;
	}
	
	if(!IsAuto){
		config->setLastKeyLocation(QString());
		config->setLastKeyType(PASSWORD);
	}
	db = new Kdb3Database();
	PasswordDialog::DlgFlags flags=PasswordDialog::Flag_None;
	if(IsAuto)
		flags = PasswordDialog::Flag_Auto;
	PasswordDialog dlg(this,PasswordDialog::Mode_Ask,flags,filename);
	if (InUnLock){
		dlg.setWindowModality(Qt::WindowModal);
		unlockDlg = &dlg;
	}
#if defined(GLOBAL_AUTOTYPE) && defined(Q_WS_MAC)
	// On MacX, QMessageBox is not brought to foreground on exec() when app not already there
	HelperMacX::processToFront(HelperMacX::getKeepassxPID());
#endif
	bool rejected = (dlg.exec()==PasswordDialog::Exit_Cancel);
	if (InUnLock)
		unlockDlg = NULL;
	if (rejected)
		return false;
	
	if(dlg.selectedBookmark()!=QString())
		filename=dlg.selectedBookmark();

	GroupView->db=db;
	EntryView->db=db;
	setupDatabaseConnections(db);
	QString err;
	setStatusBarMsg(StatusBarLoading);
	db->setKey(dlg.password(),dlg.keyFile());
	
	if (!dbReadOnly && !QFile::exists(filename+".lock")){
		QFile lock(filename+".lock");
		if (!lock.open(QIODevice::WriteOnly)){
			setStatusBarMsg(StatusBarReadOnlyLock);
			dbReadOnly = true;
		}
	}
	
	if(db->load(filename, dbReadOnly)){
		if (IsLocked)
			resetLock();
		updateCurrentFile(filename);
		saveLastFilename(filename);
		GroupView->createItems();
		EntryView->showGroup(NULL);
		setStateFileOpen(true);
		setStateFileModified(static_cast<Kdb3Database*>(db)->hasPasswordEncodingChanged());
	}
	else{
		if (!dbReadOnly && QFile::exists(filename+".lock"))
			QFile::remove(filename+".lock");
		setStatusBarMsg(StatusBarLoadingFailed);
		QString error=db->getError();
		if(error.isEmpty())error=tr("Unknown error while loading database.");
		QMessageBox::critical(this,tr("Error"),
		                      QString("%1\n%2").arg(tr("The following error occured while opening the database:"))
		                      .arg(error));
		if(db->isKeyError()){
			delete db;
			return openDatabase(filename,IsAuto);
		}
		else{
			delete db;
			return false;
		}
	}
	if (statusbarState != StatusBarReadOnlyLock)
		setStatusBarMsg(StatusBarReady);
	inactivityCounter = 0;
	
	GroupView->selectFirstGroup();
	
	return true;
}

void KeepassMainWindow::fakeOpenDatabase(const QString& filename){
	if (!QFile::exists(filename)){
		QMessageBox::critical(this, tr("Error"), tr("The database file does not exist."));
		return;
	}
	
	config->setLastFile(filename);
	updateCurrentFile(filename);
	setLock();
}

bool KeepassMainWindow::closeDatabase(bool lock){
	Q_ASSERT(FileOpen);
	Q_ASSERT(db!=NULL);
	if(ModFlag){
		if(config->autoSave() && db->file()){
			if(!OnFileSave()) return false;
		}
		else{
			QMessageBox::StandardButton r=QMessageBox::question(this,tr("Save modified file?"),
							tr("The current file was modified.\nDo you want to save the changes?"),
							QMessageBox::Yes|QMessageBox::No|QMessageBox::Cancel, QMessageBox::Yes);
			if(r==QMessageBox::Cancel) return false; //Cancel
			if(r==QMessageBox::Yes){ //Yes (Save file)
				if (dbReadOnly) {
					if(!OnFileSaveAs()) return false;
				}
				else {