sendmsgwndproc.c

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.

	$Id: SendMsgWndProc.c,v 1.22 2002/10/03 04:18:05 sdas Exp $
____________________________________________________________________________*/

#include <windows.h>
#include <commctrl.h>
#include <process.h>
#include "PluginInfo.h"
#include "HookProcs.h"
#include "UIutils.h"
#include "TextIO.h"
#include "Recipients.h"
#include "resource.h"
#include "EncryptSign.h"
#include "commctrl.h"
#include "pgpdebug.h"

static BOOL EncryptSignMessage(HWND hwnd);
static void DoubleLineFeeds(char *szOriginal, char *szNew);
static void UpdateMenus(HWND hwnd, PluginInfo *plugin);
int LoadAppropriateBitmaps(PluginInfo *plugin, UINT uiCommandId);
void RemoveSendToolbarButtons(PluginInfo *lppilPlugInf);
void DumpToolbarInfo(HWND hTBWnd);
void DumpImageListInfo(HIMAGELIST hilImgList);

typedef struct _AttStruct
{
	char *String0;
	char *String1;
	HANDLE hFile0;
	HANDLE hFile1;
} AttStruct;


LRESULT CALLBACK SendMsgWndProc(HWND hDlg, 
								UINT msg,
								WPARAM wParam, 
								LPARAM lParam)
{
	WNDPROC lpOldProc;
	PluginInfo *plugin;

	lpOldProc = (WNDPROC)GetProp( hDlg, "oldproc" );
	plugin = GetPluginInfo(hDlg);

	if (plugin != NULL)
	{
		if (msg == plugin->nCopyDoneMsg)
		{
			if (wParam)
			{
				if (plugin->nAction == PluginAction_Encrypt)
				{
					if (EncryptSignMessage(hDlg))
					{
						plugin->nRetryCount = 0;
						_beginthread(DoPasteThread, 0, hDlg);
					}
					else
					{
						RestoreClipboardText(hDlg);
						SetWindowPos(hDlg, HWND_NOTOPMOST, 0, 0, 0, 0, 
							SWP_NOMOVE | SWP_NOSIZE);
					}
				}
				else if (plugin->nAction == PluginAction_Check)
				{
					char *szCheck;
					BOOL bOK = FALSE;
					UINT nOutLength = strlen(plugin->szOutput);
					UINT nCheckLength;

					GetMessageText(hDlg, FALSE, &szCheck);
					nCheckLength = strlen(szCheck);
					RestoreClipboardText(hDlg);

					if (!strncmp(plugin->szOutput, szCheck, nOutLength))
						bOK = TRUE;
					else if (nOutLength < nCheckLength)
					{
						int nIndex;
						int nDiff = nCheckLength - nOutLength;

						for (nIndex=0; nIndex<nDiff; nIndex++)
						{
							if (plugin->szOutput[0] == szCheck[nIndex])
							{
								if (!strncmp(plugin->szOutput, 
									&szCheck[nIndex], nOutLength))
								{
									bOK = TRUE;
									break;
								}
							}
						}
					}

					if (bOK)
					{
						free(plugin->szOutput);
						plugin->szOutput = NULL;
						plugin->bEncrypt = FALSE;
						plugin->bSign = FALSE;
						
						if (plugin->hDlg != NULL)
							return CallWindowProc(lpOldProc, plugin->hDlg, 
										plugin->nMsg, plugin->wParam, 
										plugin->lParam);
						else
							return 0;
					}
					else
					{
						plugin->nRetryCount++;
						if (plugin->nRetryCount < MAX_PASTE_RETRIES)
						{
							if (!SetMessageText(hDlg, plugin->szOutput))
								return 0;
							else
							{
								plugin->nAction = PluginAction_Encrypt;
								_beginthread(DoPasteThread, 0, hDlg);
							}
						}
						else
						{
							char szTitle[256];
							char szMsg[256];

							UIGetString(szTitle, sizeof(szTitle), IDS_TITLE);
							UIGetString(szMsg, sizeof(szMsg), IDS_E_PASTEFAILED);
							MessageBox(hDlg, szMsg, szTitle, MB_ICONEXCLAMATION);

							free(plugin->szOutput);
							plugin->szOutput = NULL;
							SetWindowPos(hDlg, HWND_NOTOPMOST, 0, 0, 0, 0, 
								SWP_NOMOVE | SWP_NOSIZE);
							return 0;
						}
					}
				}
				else if (plugin->nAction == PluginAction_Reply)
				{
					char *szText;

					szText = GetReplyText();
					if (szText != NULL)
					{
						char *szReplyText=NULL;
						char *szReplyHeader=NULL;
						
						GetMessageText(hDlg, FALSE, &szReplyHeader);
						if (FindReplyHeader(szReplyHeader))
						{
							szReplyText = (char *) 
								calloc(strlen(szReplyHeader) +
									strlen(szText) * 2 + 1, 1);
							
							if(NULL != szReplyText)
							{
								strcpy(szReplyText, szReplyHeader);
								AddReply(szReplyText, szText);
								SetMessageText(hDlg, szReplyText);
								free(szReplyText);
								szReplyText = NULL;
							}
							_beginthread(DoPasteThread, 0, hDlg);
						}
						else
							RestoreClipboardText(hDlg);
						
						free(szReplyHeader);
						FreeReplyText();
					}
					else
						RestoreClipboardText(hDlg);
				}
				else
					RestoreClipboardText(hDlg);
			}
			else
				RestoreClipboardText(hDlg);

			return 0;
		}
	
		if (msg == plugin->nPasteDoneMsg)
		{
			if (plugin->nAction == PluginAction_Encrypt)
			{
				plugin->nAction = PluginAction_Check;
				_beginthread(DoCopyThread, 0, hDlg);
				return 0;
			}
			else
				SetWindowPos(hDlg, HWND_NOTOPMOST, 0, 0, 0, 0, 
					SWP_NOMOVE | SWP_NOSIZE);
		}
	}

	switch(msg)
	{
	case WM_DESTROY:
		{
			KillTimer(hDlg, WATCH_TOOLBAR_TIMER);
			break;
		}

	case WM_TIMER:
		if (wParam == CORRECT_TOOLBAR_TIMER)
		{
			KillTimer(hDlg, CORRECT_TOOLBAR_TIMER);

			SendMessage(plugin->hToolbar, TB_SETBUTTONWIDTH, 0,
				MAKELONG(24, 24));
			SendMessage(plugin->hToolbar, TB_AUTOSIZE, 0, 0);
			UpdateMenus(hDlg, plugin);

			return 0;
		}
		else if (wParam == PASTE_REPLY_TIMER)
		{
			char *szText;

			// REALLY ugly hack here to get buttons to appear on OE6 on XP. Basically we just
			// hit the rebar control and that (for some reason) updates the toolbar, just like
			// clicking the rebar manually works.
			SendMessage(GetParent(plugin->hToolbar),WM_LBUTTONDOWN,(WPARAM)MK_LBUTTON,(LPARAM)MAKELPARAM(1,54));
			SendMessage(GetParent(plugin->hToolbar),WM_LBUTTONUP,(WPARAM)0,(LPARAM)MAKELPARAM(1,54));
			
			// Paste any reply text
			KillTimer(hDlg, PASTE_REPLY_TIMER);

			szText = GetReplyText();
			if (szText != NULL)
			{
				if (!SaveClipboardText(hDlg))
					return 0;
				
				plugin->nAction = PluginAction_Reply;
				plugin->hDlg = NULL;

				_beginthread(DoCopyThread, 0, hDlg);
			}

			return 0;
		}
		break;

	case WM_MENUSELECT:
		{
			UINT uFlags = (UINT) HIWORD(wParam);
			char szText[255];
			BOOL bPluginMenu = FALSE;

			if (uFlags & MF_POPUP)
			{
				if (LOWORD(wParam) == plugin->nPGPPosition+1)
					UpdateMenus(hDlg, plugin);
			}

			switch(LOWORD(wParam))
			{
				case IDC_ENCRYPT_SMIME:
				case IDC_OE5_ENCRYPT_SMIME:
				{
					UIGetString(szText, 254, IDS_STATUS_SMIME_ENCRYPT);
					bPluginMenu = TRUE;
					break;
				}
								
				case IDC_SIGN_SMIME:
				case IDC_OE5_SIGN_SMIME:
				{
					UIGetString(szText, 254, IDS_STATUS_SMIME_SIGN);
					bPluginMenu = TRUE;
					break;
				}

				case IDC_ENCRYPT_PGP:
				{
					UIGetString(szText, 254, IDS_STATUS_PGP_ENCRYPT);
					bPluginMenu = TRUE;
					break;
				}
								
				case IDC_SIGN_PGP:
				{
					UIGetString(szText, 254, IDS_STATUS_PGP_SIGN);
					bPluginMenu = TRUE;
					break;
				}

				case IDC_PGPKEYS:
				{
					UIGetString(szText, 254, IDS_TOOLTIP_PGPKEYS);
					bPluginMenu = TRUE;
					break;
				}

			}	

			if (bPluginMenu)
			{
				CallWindowProc(lpOldProc, hDlg, msg, wParam, lParam);
				SendMessage(plugin->hStatusBar, SB_SETTEXT, 
					255 | SBT_NOBORDERS, (LPARAM) szText);

				return 0;
			}

			break;
		}

		case WM_COMMAND:
		{
			switch(LOWORD(wParam))
			{
			case IDC_SENDMESSAGE_MENU:
			case IDC_SENDMESSAGE_BUTTON:
			case IDC_SENDLATER:
			case IDC_POSTARTICLE_MENU:
			case IDC_POSTARTICLE_BUTTON:
			case IDC_POSTLATER:
			case IDC_OE5_SENDMESSAGE:
			case IDC_OE5_SENDLATER:
				{
					if (plugin->bEncrypt || plugin->bSign)
					{
						if (!SaveClipboardText(hDlg))
							return 0;

						plugin->nAction = PluginAction_Encrypt;
						plugin->hDlg = hDlg;
						plugin->nMsg = msg;
						plugin->wParam = wParam;
						plugin->lParam = lParam;

						_beginthread(DoCopyThread, 0, hDlg);
						return 0;
					}

					break;
				}

			case IDC_ENCRYPT_PGP:
				if (plugin->bOE5)
				{
					plugin->bEncrypt = !(plugin->bEncrypt);
					SendMessage(plugin->hToolbar, TB_CHECKBUTTON, 
						IDC_ENCRYPT_PGP, MAKELONG(plugin->bEncrypt, 0));
					return 0;
				}
				else
				{
					MENUITEMINFO menuInfo;

					menuInfo.cbSize = sizeof(MENUITEMINFO);
					menuInfo.fMask = MIIM_STATE;
					GetMenuItemInfo(plugin->hToolsMenu, IDC_ENCRYPT_PGP, 
						FALSE, &menuInfo);
					
					if (menuInfo.fState & MFS_CHECKED)
						plugin->bEncrypt = FALSE;
					else
						plugin->bEncrypt = TRUE;

					UpdateMenus(hDlg, plugin);
					return 0;
				}

			case IDC_SIGN_PGP:
				if (plugin->bOE5)
				{
					plugin->bSign = !(plugin->bSign);
					SendMessage(plugin->hToolbar, TB_CHECKBUTTON, 
						IDC_SIGN_PGP, MAKELONG(plugin->bSign, 0));
					return 0;
				}
				else
				{
					MENUITEMINFO menuInfo;

					menuInfo.cbSize = sizeof(MENUITEMINFO);
					menuInfo.fMask = MIIM_STATE;
					GetMenuItemInfo(plugin->hToolsMenu, IDC_SIGN_PGP, 
						FALSE, &menuInfo);
					
					if (menuInfo.fState & MFS_CHECKED)
						plugin->bSign = FALSE;
					else
						plugin->bSign = TRUE;

					UpdateMenus(hDlg, plugin);
					return 0;
				}
			}
			break;
		}
		
	case WM_INITMENUPOPUP:
		if (plugin->bOE5)
		{
			int nNumItems;
			MENUITEMINFO menuInfo;
			char szEncrypt[256];
			char szMenu[256];
			LRESULT lResult;
			int nIndex;
			BOOL bGotEncrypt = FALSE;
			BOOL bGotPGP = FALSE;
			int nEncryptPos;

			UIGetString(szEncrypt, 254, IDS_MENU_OEENCRYPT);
			nNumItems = GetMenuItemCount((HMENU) wParam);
			
			for (nIndex=0; nIndex<nNumItems; nIndex++)
			{
				menuInfo.cbSize = sizeof(MENUITEMINFO);
				menuInfo.fMask = MIIM_TYPE;
				menuInfo.dwTypeData = szMenu;
				menuInfo.cch = 255;
			
				GetMenuItemInfo((HMENU) wParam, nIndex, TRUE, &menuInfo);
				if (!strcmp(szMenu, szEncrypt))
				{
					bGotEncrypt = TRUE;
					nEncryptPos = nIndex;
					break;
				}

				if (!strcmp(szMenu, "&PGP"))
				{
					bGotPGP = TRUE;
					break;
				}
			}
			
			if (bGotEncrypt)
			{
				lResult = CallWindowProc(lpOldProc, hDlg, msg, wParam, 
							lParam);
				
				strcpy(szMenu, "&PGP");
				
				menuInfo.cbSize = sizeof(MENUITEMINFO);
				menuInfo.fMask = MIIM_TYPE | MIIM_ID | MIIM_SUBMENU | 
									MIIM_STATE;
				menuInfo.fType = MFT_STRING;
				menuInfo.wID = IDC_PGPMENU;
				menuInfo.fState = MFS_ENABLED;
				menuInfo.hSubMenu = plugin->hPGPMenu;
				menuInfo.dwTypeData = szMenu;

				InsertMenuItem((HMENU) wParam, nNumItems, TRUE, &menuInfo);
				plugin->nPGPPosition = nNumItems;

				UIGetString(szMenu, 254, IDS_MENU_SMIME_ENCRYPT);
				menuInfo.fMask = MIIM_TYPE;
				menuInfo.fType = MFT_STRING;
				menuInfo.dwTypeData = szMenu;

				SetMenuItemInfo((HMENU) wParam, nEncryptPos-1, TRUE, 
					&menuInfo);

				UIGetString(szMenu, 254, IDS_MENU_SMIME_SIGN);
				menuInfo.fMask = MIIM_TYPE;
				menuInfo.fType = MFT_STRING;
				menuInfo.dwTypeData = szMenu;

				SetMenuItemInfo((HMENU) wParam, nEncryptPos, TRUE, 
					&menuInfo);

				UIGetString(szMenu, 254, IDS_MENU_PGP_ENCRYPT);
				menuInfo.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
				menuInfo.fType = MFT_STRING;
				menuInfo.wID = IDC_ENCRYPT_PGP;
				menuInfo.dwTypeData = szMenu;
				
				if (plugin->bEncrypt)
					menuInfo.fState = MFS_ENABLED | MFS_CHECKED;
				else
					menuInfo.fState = MFS_ENABLED;

				InsertMenuItem((HMENU) wParam, nEncryptPos+1, TRUE, 
					&menuInfo);

				UIGetString(szMenu, 254, IDS_MENU_PGP_SIGN);
				menuInfo.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
				menuInfo.fType = MFT_STRING;
				menuInfo.wID = IDC_SIGN_PGP;
				menuInfo.dwTypeData = szMenu;
				
				if (plugin->bSign)
					menuInfo.fState = MFS_ENABLED | MFS_CHECKED;
				else
					menuInfo.fState = MFS_ENABLED;

				InsertMenuItem((HMENU) wParam, nEncryptPos+2, TRUE, 
					&menuInfo);

				return lResult;
			}
			else if (bGotPGP)
			{
				lResult = CallWindowProc(lpOldProc, hDlg, msg, wParam, 
							lParam);
				
				menuInfo.cbSize = sizeof(MENUITEMINFO);
				menuInfo.fMask = MIIM_STATE;
				
				if (plugin->bEncrypt)
					menuInfo.fState = MFS_ENABLED | MFS_CHECKED;
				else
					menuInfo.fState = MFS_ENABLED;

				SetMenuItemInfo((HMENU) wParam, IDC_ENCRYPT_PGP, FALSE, 
					&menuInfo);

				if (plugin->bSign)
					menuInfo.fState = MFS_ENABLED | MFS_CHECKED;
				else
					menuInfo.fState = MFS_ENABLED;

				SetMenuItemInfo((HMENU) wParam, IDC_SIGN_PGP, FALSE, 
					&menuInfo);
				
				menuInfo.fState = MFS_ENABLED;

				SetMenuItemInfo((HMENU) wParam, IDC_PGPMENU, FALSE, 
					&menuInfo);
				
				SetMenuItemInfo(plugin->hPGPMenu, IDC_PREFS, FALSE, 
					&menuInfo);