pwsafedlg.cpp

一款密码保险箱源码

	CMsgRelayWnd::AddRelayedMessage(WM_REG_KEEPASSCONTROL);

	VERIFY(m_systray.Create(this, WM_MY_SYSTRAY_NOTIFY, PWM_PRODUCT_NAME_SHORT,
		m_hTrayIconNormal, IDR_SYSTRAY_MENU, FALSE,
		NULL, NULL, NIIF_NONE, 0));
	m_systray.SetMenuDefaultItem(0, TRUE);
	m_systray.MoveToRight();

	for(INT tt = 0; tt < 11; tt++) m_aHeaderOrder[tt] = tt;
	cConfig.Get(PWMKEY_HEADERORDER, szTemp);
	if(szTemp[0] != 0)
	{
		str2ar(szTemp, m_aHeaderOrder, 11);
		NewGUI_SetHeaderOrder(m_cList.m_hWnd, m_aHeaderOrder, 11);
	}

	m_pThemeHelper = new CThemeHelperST();
	ASSERT(m_pThemeHelper != NULL);
	NewGUI_SetThemeHelper((void *)m_pThemeHelper);

	NewGUI_ToolBarButton(&m_btnTbNew, IDB_TB_NEW, IDB_TB_NEW);
	NewGUI_ToolBarButton(&m_btnTbOpen, IDB_TB_OPEN, IDB_TB_OPEN);
	NewGUI_ToolBarButton(&m_btnTbSave, IDB_TB_SAVE, IDB_TB_SAVE);
	NewGUI_ToolBarButton(&m_btnTbAddEntry, IDB_TB_ADDENTRY, IDB_TB_ADDENTRY);
	NewGUI_ToolBarButton(&m_btnTbEditEntry, IDB_TB_EDITENTRY, IDB_TB_EDITENTRY);
	NewGUI_ToolBarButton(&m_btnTbDeleteEntry, IDB_TB_DELETEENTRY, IDB_TB_DELETEENTRY);
	NewGUI_ToolBarButton(&m_btnTbCopyPw, IDB_TB_COPYPW, IDB_TB_COPYPW);
	NewGUI_ToolBarButton(&m_btnTbCopyUser, IDB_TB_COPYUSER, IDB_TB_COPYUSER);
	NewGUI_ToolBarButton(&m_btnTbFind, IDB_TB_FIND, IDB_TB_FIND);
	NewGUI_ToolBarButton(&m_btnTbLock, IDB_TB_LOCK, IDB_TB_LOCK);
	NewGUI_ToolBarButton(&m_btnTbAbout, IDB_TB_ABOUT, IDB_TB_ABOUT);

	_ShowToolBar(m_bShowToolBar);

	m_hAccel = LoadAccelerators(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDR_ACCEL_MAIN));
	ASSERT(m_hAccel != NULL);

	VERIFY(m_tip.Create(this, 0x40));
	m_tip.AddTool(GetDlgItem(IDC_EDIT_QUICKFIND), TRL("Find a string in the password list."));
	m_tip.Activate(TRUE);

	m_lSplitterPosHoriz = GUI_GROUPLIST_EXT + 1;
	m_lSplitterPosVert = (rectClient.bottom - rectClient.top - PWS_DEFAULT_SPLITTER_Y) / 4;
	ASSERT(m_lSplitterPosVert > 0);

	int px, py, dx, dy; // Restore window position
	cConfig.Get(PWMKEY_WINDOWPX, szTemp);
	if(szTemp[0] != 0) px = _ttoi(szTemp); else px = -1;
	cConfig.Get(PWMKEY_WINDOWPY, szTemp);
	if(szTemp[0] != 0) py = _ttoi(szTemp); else py = -1;
	cConfig.Get(PWMKEY_WINDOWDX, szTemp);
	if(szTemp[0] != 0) dx = _ttoi(szTemp); else dx = -1;
	cConfig.Get(PWMKEY_WINDOWDY, szTemp);
	if(szTemp[0] != 0) dy = _ttoi(szTemp); else dy = -1;

	const int pxVirtScreen = GetSystemMetrics(SM_XVIRTUALSCREEN);
	const int cxVirtScreen = GetSystemMetrics(SM_CXVIRTUALSCREEN);
	const int pyVirtScreen = GetSystemMetrics(SM_YVIRTUALSCREEN);
	const int cyVirtScreen = GetSystemMetrics(SM_CYVIRTUALSCREEN);

	if((px == 3000) && (py == 3000))
	{
		px = pxVirtScreen;
		py = pyVirtScreen;
	}

	if(px >= (pxVirtScreen + cxVirtScreen)) px = pxVirtScreen;
	if(py >= (pyVirtScreen + cyVirtScreen)) py = pyVirtScreen;

	if((px != -1) && (py != -1) && (dx != -1) && (dy != -1))
	{
		if((px + dx) <= pxVirtScreen) px = pxVirtScreen;
		if((py + dy) <= pyVirtScreen) py = pyVirtScreen;

		SetWindowPos(&wndNoTopMost, px, py, dx, dy, SWP_NOOWNERZORDER | SWP_NOZORDER);
	}

	for(ul = 0; ul < 11; ul++) m_nColumnWidths[ul] = 0;

	// Restore column sizes
	cConfig.Get(PWMKEY_COLWIDTH0, szTemp);
	if(_tcslen(szTemp) != 0) m_nColumnWidths[0] = _ttoi(szTemp);
	cConfig.Get(PWMKEY_COLWIDTH1, szTemp);
	if(_tcslen(szTemp) != 0) m_nColumnWidths[1] = _ttoi(szTemp);
	cConfig.Get(PWMKEY_COLWIDTH2, szTemp);
	if(_tcslen(szTemp) != 0) m_nColumnWidths[2] = _ttoi(szTemp);
	cConfig.Get(PWMKEY_COLWIDTH3, szTemp);
	if(_tcslen(szTemp) != 0) m_nColumnWidths[3] = _ttoi(szTemp);
	cConfig.Get(PWMKEY_COLWIDTH4, szTemp);
	if(_tcslen(szTemp) != 0) m_nColumnWidths[4] = _ttoi(szTemp);
	cConfig.Get(PWMKEY_COLWIDTH5, szTemp);
	if(_tcslen(szTemp) != 0) m_nColumnWidths[5] = _ttoi(szTemp);
	cConfig.Get(PWMKEY_COLWIDTH6, szTemp);
	if(_tcslen(szTemp) != 0) m_nColumnWidths[6] = _ttoi(szTemp);
	cConfig.Get(PWMKEY_COLWIDTH7, szTemp);
	if(_tcslen(szTemp) != 0) m_nColumnWidths[7] = _ttoi(szTemp);
	cConfig.Get(PWMKEY_COLWIDTH8, szTemp);
	if(_tcslen(szTemp) != 0) m_nColumnWidths[8] = _ttoi(szTemp);
	cConfig.Get(PWMKEY_COLWIDTH9, szTemp);
	if(_tcslen(szTemp) != 0) m_nColumnWidths[9] = _ttoi(szTemp);
	cConfig.Get(PWMKEY_COLWIDTH10, szTemp);
	if(_tcslen(szTemp) != 0) m_nColumnWidths[10] = _ttoi(szTemp);

	cConfig.Get(PWMKEY_SPLITTERX, szTemp);
	if(_tcslen(szTemp) != 0) m_lSplitterPosHoriz = _ttol(szTemp);
	else m_lSplitterPosHoriz = GUI_GROUPLIST_EXT + 1;

	cConfig.Get(PWMKEY_SPLITTERY, szTemp);
	if(_tcslen(szTemp) != 0) m_lSplitterPosVert = _ttol(szTemp);
	// else m_lSplitterPosVert = PWS_DEFAULT_SPLITTER_Y; // Set above already

	// if(m_bAlwaysOnTop == TRUE)
	//	SetWindowPos(&wndTopMost, 0, 0, 0, 0,
	//		SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);

	VERIFY(m_cGroups.InitDropHandler());

	cConfig.Get(PWMKEY_GENPROFILEAUTO, szTemp);
	if(szTemp[0] != 0)
	{
		std::basic_string<TCHAR> strAutoProfile = szTemp;
		PwgStringToProfile(strAutoProfile, &CPwSafeDlg::m_pgsAutoProfile);
	}
	else PwgGetDefaultProfile(&CPwSafeDlg::m_pgsAutoProfile);

	// Support legacy auto-generation flag
	if(cConfig.GetBool(PWMKEY_AUTOPWGEN, TRUE) == FALSE)
		CPwSafeDlg::m_pgsAutoProfile.dwLength = 0;

	KP_APP_INFO kpai;
	ZeroMemory(&kpai, sizeof(KP_APP_INFO));
	kpai.dwAppVersion = PWM_VERSION_DW;
	kpai.hwndMain = this->m_hWnd;
	// kpai.pApp = (void *)AfxGetApp();
	kpai.pMainDlg = (void *)this;
	kpai.pPwMgr = (void *)&m_mgr;
	kpai.lpKPCall = KP_Call;
	kpai.lpKPQuery = KP_Query;

	CPluginManager::Instance().SetAppInfo(&kpai);
	CPluginManager::Instance().SetDirectCommandRange(WM_PLUGINS_FIRST, WM_PLUGINS_LAST);

	CString strPluginKey;
	int jj = 0;
	while(1)
	{
		strPluginKey.Format(_T("KeePlugin_%d"), jj);
		cConfig.Get(strPluginKey, szTemp);
		if(szTemp[0] == 0) break;
		if(_tcscmp(szTemp, _T("0")) == 0) break;
		if(szTemp[0] != _T('-'))
		{
			std_string strPluginName = szTemp;
			CPluginManager::Instance().m_vKnownNames.push_back(strPluginName);
		}
		jj++;
	}

	std_string strBase = Executable::instance().getPathOnly();
	VERIFY(CPluginManager::Instance().AddAllPlugins(strBase.c_str(), _T("*.dll"), TRUE));
	CPluginManager::Instance().m_vKnownNames.clear();

	// CString strPluginKey;
	// jj = 0;
	// while(1)
	// {
	//	strPluginKey.Format(_T("KeePlugin_%d"), jj);
	//	cConfig.Get(strPluginKey, szTemp);
	//	if(_tcslen(szTemp) == 0) break;
	//	if(_tcscmp(szTemp, _T("0")) == 0) break;
	//	if(szTemp[0] == _T('-'))
	//		CPluginManager::Instance().EnablePluginByStr(&szTemp[1], FALSE);
	//	else
	//		CPluginManager::Instance().EnablePluginByStr(szTemp, TRUE);
	//	jj++;
	// }

	VERIFY(CPluginManager::Instance().LoadAllPlugins());
	BuildPluginMenu();

	_CALLPLUGINS(KPM_DELAYED_INIT, 0, 0);

	_CALLPLUGINS(KPM_READ_COMMAND_ARGS, 0, 0);
	if(_ParseCommandLine() == FALSE)
	{
		if((m_bOpenLastDb == TRUE) && (m_bRememberLast == TRUE))
		{
			cConfig.Get(PWMKEY_LASTDB, szTemp);
			if(_tcslen(szTemp) != 0)
			{
				// TCHAR tszTemp[SI_REGSIZE];
				// int i;

				// GetModuleFileName(NULL, tszTemp, SI_REGSIZE - 2);
				std_string strTemp = _T("");

				if((szTemp[1] == _T(':')) && (szTemp[2] == _T('\\')))
					// _tcscpy_s(tszTemp, _countof(tszTemp), szTemp);
					strTemp = szTemp;
				else if((szTemp[0] == _T('\\')) && (szTemp[1] == _T('\\')))
					// _tcscpy_s(tszTemp, _countof(tszTemp), szTemp);
					strTemp = szTemp;
				else
				{
					// for(i = _tcslen(tszTemp) - 1; i > 1; i--)
					// {
					//	if((tszTemp[i] == _T('\\')) || (tszTemp[i] == _T('/')))
					//	{
					//		tszTemp[i + 1] = 0;
					//		break;
					//	}
					// }
					
					// _tcscat_s(tszTemp, _countof(tszTemp), szTemp);
					strTemp = Executable::instance().getPathOnly();
					strTemp += szTemp;
				}

				if(_FileAccessible(strTemp.c_str()) == TRUE)
					_OpenDatabase(NULL, strTemp.c_str(), NULL, NULL, m_bStartMinimized, NULL, FALSE);
			}
		}
	}

	m_bIgnoreSizeEvent = FALSE;

	UpdateAutoSortMenuItems();
	_UpdateToolBar(TRUE);
	ProcessResize();

	if(m_dwATHotKey != 0) RegisterGlobalHotKey(HOTKEYID_AUTOTYPE, m_dwATHotKey, FALSE, FALSE);

	m_bRestoreHotKeyRegistered = RegisterHotKey(this->m_hWnd, HOTKEYID_RESTORE, MOD_ALT | MOD_CONTROL, 'K');

	// PostMessage(WM_NULL, 0, 0);

	m_uACP = GetACP();

	m_sessionNotify.Register(this->m_hWnd);
	if(m_bCheckForUpdate == TRUE) CheckForUpdateAsync(this->m_hWnd, PWM_VERSION_DW, PWM_URL_VERSION, FALSE);

	UpdateWindow();
	RedrawWindow();

	m_bWasMaximized = cConfig.GetBool(PWMKEY_WINSTATE_MAX, FALSE);
	if(m_bWasMaximized == TRUE) ShowWindow(SW_SHOWMAXIMIZED);

	if(m_bAlwaysOnTop == TRUE)
		SetWindowPos(&wndTopMost, 0, 0, 0, 0,
			SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);

	if(m_bStartMinimized == TRUE) SetViewHideState(FALSE, FALSE);

	_CALLPLUGINS(KPM_WND_INIT_POST, 0, 0);
	m_bDisplayDialog = FALSE;

	// m_btnTbAbout.SetFocus();
	// if((m_bFileOpen == FALSE) && (m_cQuickFind.IsWindowEnabled() == TRUE)) m_cQuickFind.SetFocus();
	// else m_btnTbAbout.SetFocus();
	_SetDefaultFocus();
	return FALSE; // We set the focus ourselves
}

void CPwSafeDlg::_SetDefaultFocus()
{
	if(m_cQuickFind.IsWindowEnabled() == TRUE) m_cQuickFind.SetFocus();
	else m_btnTbAbout.SetFocus();
}

void CPwSafeDlg::_TranslateMenu(BCMenu *pBCMenu, BOOL bAppendSuffix, BOOL *pFlags)
{
	CString strItem, strNew;
	UINT nItem = 0;
	BCMenu *pNext;
	const TCHAR *pSuffix = _T("");
	BOOL bDefaultFlag = FALSE;

	ASSERT(pBCMenu != NULL);
	if(pBCMenu == NULL) return;

	if(pFlags == NULL) pFlags = &bDefaultFlag;

	while(1)
	{
		if(pBCMenu->GetMenuText((UINT)nItem, strItem, MF_BYPOSITION) == FALSE) break;
		if(bAppendSuffix == TRUE) pSuffix = _GetCmdAccelExt(strItem);

		if((strItem == _T("&Export To")) || (strItem == _T("&Import From")) ||
			(strItem == _T("Show &Columns")) || (strItem == _T("&Rearrange")) ||
			(strItem == _T("Auto-&Sort Password List")) || (strItem == _T("TAN View &Options")))
		{
			pNext = pBCMenu->GetSubBCMenu((TCHAR *)(LPCTSTR)strItem);
			if(pNext != NULL) _TranslateMenu(pNext, TRUE, pFlags);
		}

		// Replace URL menu item if required, pFlags[0] must be a pointer to m_bCopyURLs
		if(*pFlags == TRUE)
			if(strItem == _T("Open &URL(s)"))
				strItem = _T("Copy &URL to Clipboard");

		if(strItem.GetLength() != 0) strNew = TRL_VAR(strItem);
		else strNew = _T("");

		if(_tcslen(pSuffix) != 0) { strNew += _T("\t"); strNew += pSuffix; }
		if(pBCMenu->SetMenuText(nItem, strNew, MF_BYPOSITION) == FALSE) { ASSERT(FALSE); }

		nItem++;
	}
}

BOOL CPwSafeDlg::_ParseCommandLine()
{
	/* CString str;
	LPCTSTR lpPassword = NULL;
	LPCTSTR lpKeyFile = NULL;
	LPCTSTR lpPreSelectPath = NULL;

	if(CPwSafeApp::ParseCurrentCommandLine(&str, &lpPassword, &lpKeyFile, &lpPreSelectPath) == FALSE) return FALSE;

	if(_FileAccessible(str) == TRUE)
		_OpenDatabase(NULL, str, lpPassword, lpKeyFile, FALSE, lpPreSelectPath, FALSE); */

	m_bFileReadOnly = (CmdArgs::instance().readonlyIsInEffect() ? TRUE : FALSE);

	const FullPathName& fpnDatabase = CmdArgs::instance().getDatabase();
	const bool bFileNameExists = (fpnDatabase.getState() == FullPathName::PATH_AND_FILENAME);
	if(!bFileNameExists) return FALSE;

	const TCHAR* const lpFileName = fpnDatabase.getFullPathName().c_str();
	if(_FileAccessible(lpFileName) == FALSE)
	{
		std_string strMsg = TRL("File access error: failed to open file in read mode");
		strMsg += _T("!\r\n\r\n");
		strMsg += lpFileName;

		MessageBox(strMsg.c_str(), PWM_PRODUCT_NAME_SHORT, MB_OK |
			MB_ICONWARNING);

		return TRUE;
	}

	const std_string& strPassword = CmdArgs::instance().getPassword();
	const FullPathName& fpnKeyFile = CmdArgs::instance().getKeyfile();
	enum { PATH_EXISTS = FullPathName::PATH_ONLY | FullPathName::PATH_AND_FILENAME };
	const TCHAR* const lpKeyFile = (fpnKeyFile.getState() & PATH_EXISTS ?
		fpnKeyFile.getFullPathName().c_str() : NULL);
	const bool bPreSelectIsInEffect = CmdArgs::instance().preselectIsInEffect();

	_OpenDatabase(NULL, lpFileName, strPassword.empty() ? NULL : strPassword.c_str(),
		(!bPreSelectIsInEffect) ? lpKeyFile : NULL, FALSE, 
		bPreSelectIsInEffect ? lpKeyFile : NULL, FALSE);