wfwiz.c

vc环境下的pgp源码

					break;
				}

			}
			break;
		}

		case WM_DESTROY:
		{
			break;
		}

		case WM_PAINT:
		{
			if (data->palette)
			{
				PAINTSTRUCT ps;
				HDC	hDC = BeginPaint (hwnd, &ps);
				SelectPalette (hDC, data->palette, FALSE);
				RealizePalette (hDC);
				EndPaint (hwnd, &ps);
				bReturnValue = TRUE;
			}

			break;
		}

		case WM_NOTIFY:
		{
			LPNMHDR pnmh;

			pnmh = (LPNMHDR) lParam;

			switch(pnmh->code)
			{
				case PSN_SETACTIVE:
				{
					char StrRes[500];
					VOLINFO vi;

					SetWindowText(GetDlgItem(hwnd,IDC_RESTARTINGTEXT),
						"");

					WipeProgress(0);
					PassProgress(0, data->passes);

					LoadString (g_hinst, IDS_DISKSTAT, StrRes, sizeof(StrRes));

					strcat(StrRes, data->drive);
					SetWindowText(group, StrRes);
	
					WipeFree(hwnd,
						&vi,
						data->drive,
						NULL,
						FALSE);

					DisplayDiskStats(&vi);

					LoadString (g_hinst, IDS_BEGINWIPE, StrRes, sizeof(StrRes));

					StatusMessage(StrRes, FALSE);
					WipeProgress(0);

					// Initialize window
					PostMessage(GetParent(hwnd), 
								PSM_SETWIZBUTTONS, 
								0, 
								PSWIZB_DISABLEDFINISH|PSWIZB_BACK);

					SendDlgItemMessage(	hwnd, 
										IDC_WIZBITMAP, 
										STM_SETIMAGE, 
										IMAGE_BITMAP, 
										(LPARAM) data->bmp);

					bReturnValue = TRUE;
					break;
				}

				case PSN_KILLACTIVE:
				{
					// Save user data for this page
					break;
				}

				case PSN_WIZFINISH:
				{
					// Save user data for all pages
					PGPContextRef	context = data->context;
					PGPError		error;
					PGPPrefRef		prefRef;
					PGPMemoryMgrRef memoryMgr;

					memoryMgr = PGPGetContextMemoryMgr(context);

					error = PGPclOpenClientPrefs(	memoryMgr,
									&prefRef );

					if(IsntPGPError(error) )
					{
						PGPSetPrefNumber (	prefRef,
											kPGPPrefDiskWipePasses, 
											data->passes);

						PGPclCloseClientPrefs (prefRef, TRUE);

					}

					break;
				}

				case PSN_HELP:
				{
					// Display help
					break;
				}

				case PSN_QUERYCANCEL:
				{
					NMHDR* nmhdr = (NMHDR*) lParam;

					// User wants to quit
					if( g_bWiping )
					{
						bGlobalCancel=TRUE;
						bReturnValue = TRUE;
						SetWindowLong(hwnd, DWL_MSGRESULT, TRUE);
					}
					break;
				}
			}
			
			break;
		}

	}

	return bReturnValue;
}

BOOL CALLBACK FinishDlgProc(HWND hwnd, 
							UINT msg, 
							WPARAM wParam, 
							LPARAM lParam)
{
	BOOL bReturnValue = FALSE;
	static HFONT boldfont;
	static wizard_data* data = NULL;

	switch(msg)
	{
		case WM_INITDIALOG:
		{
			PROPSHEETPAGE* psp = (PROPSHEETPAGE*) lParam;
			HWND finish = GetDlgItem(hwnd, IDC_FINISH);
			HWND hwndParent = GetParent(hwnd);
			HFONT defaultfont;
			LOGFONT	lf;

			data = (wizard_data*) psp->lParam;

			defaultfont = GetStockObject(DEFAULT_GUI_FONT);

			GetObject(defaultfont, sizeof(LOGFONT), &lf);

			lf.lfWeight = FW_BOLD;

			boldfont = CreateFontIndirect(&lf);

			SendMessage(finish, 
						WM_SETFONT, 
						(WPARAM)boldfont,
						MAKELPARAM(TRUE, 0));

			bReturnValue = TRUE;
			break;
		}

		case WM_DESTROY:
		{
			DeleteObject(boldfont);
			break;
		}

		case WM_PAINT:
		{
			if (data->palette)
			{
				PAINTSTRUCT ps;
				HDC	hDC = BeginPaint (hwnd, &ps);
				SelectPalette (hDC, data->palette, FALSE);
				RealizePalette (hDC);
				EndPaint (hwnd, &ps);
				bReturnValue = TRUE;
			}

			break;
		}

		case WM_NOTIFY:
		{
			LPNMHDR pnmh;

			pnmh = (LPNMHDR) lParam;

			switch(pnmh->code)
			{
				case PSN_SETACTIVE:
				{
					// Initialize window
					PostMessage(GetParent(hwnd), 
						PSM_SETWIZBUTTONS, 0, PSWIZB_FINISH);

					SendDlgItemMessage(	hwnd, 
										IDC_WIZBITMAP, 
										STM_SETIMAGE, 
										IMAGE_BITMAP, 
										(LPARAM) data->bmp);

					bReturnValue = TRUE;
					break;
				}

				case PSN_KILLACTIVE:
				{
					// Save user data for this page
					break;
				}

				case PSN_WIZFINISH:
				{
					// Save user data for all pages
					break;
				}

				case PSN_HELP:
				{
					// Display help
					break;
				}

				case PSN_QUERYCANCEL:
				{
					// User wants to quit
					break;
				}
			}
			
			break;
		}

	}

	return bReturnValue;
}

void StatusMessage(char *msg, BOOL bold)
{
	if(bold)
	{
		SendMessage(g_status, 
				WM_SETFONT, 
				(WPARAM)g_boldfont,
				MAKELPARAM(TRUE, 0));
	}
	else
	{
		SendMessage(g_status, 
				WM_SETFONT, 
				(WPARAM)g_defaultfont,
				MAKELPARAM(TRUE, 0));
	}

	SetWindowText(g_status, msg);
}

void WipeProgress(int pos)
{
	if(pos==10)
	{
		SetWindowText(
			GetDlgItem(GetParent(g_wipe_progress),IDC_RESTARTINGTEXT),
			"");
	}

	SendMessage(g_wipe_progress,
				PBM_SETPOS ,
				(WPARAM)pos,
				0);	
}

void PassProgress(int pass, int total)
{
	char msg[] = "Pass: %d/%d";
	char buf[128];

	SendMessage(g_pass_progress,
				PBM_SETRANGE,
				0,
				MAKELPARAM(0, total));	

	SendMessage(g_pass_progress,
				PBM_SETPOS ,
				(WPARAM)pass,
				0);	

	pass=pass+1;  // now one based instead of zero based
	if(pass>total)
		pass=total;

	wsprintf(buf, msg, pass , total); 

	SetWindowText(g_pass_status, buf);
}

BOOL DisplayDiskStats(VOLINFO *vi)
{
	char buf[256];

	switch(vi->dwFS)
	{
		case FS_FAT12:
			strcpy(buf,"FAT 12");
			break;

		case FS_FAT16:
			strcpy(buf,"FAT 16");
			break;

		case FS_FAT32:
			strcpy(buf,"FAT 32");
			break;

		case FS_NTFS:
			strcpy(buf,"NTFS");
			break;

		default: // Should never get here
			strcpy(buf,"Unknown"); 
	}

	SendMessage(GetDlgItem(vi->hwnd,IDC_FSDATA),
				WM_SETTEXT,
				(WPARAM)0,
				(LPARAM)buf);

	sprintf(buf,"%d",vi->no_of_clusters);
	SendMessage(GetDlgItem(vi->hwnd,IDC_NCDATA),
				WM_SETTEXT,
				(WPARAM)0,
				(LPARAM)buf);

	sprintf(buf,"%d",vi->sectors_per_clus);
	SendMessage(GetDlgItem(vi->hwnd,IDC_SCDATA),
				WM_SETTEXT,
				(WPARAM)0,
				(LPARAM)buf);

	sprintf(buf,"%d",vi->sector_size);
	SendMessage(GetDlgItem(vi->hwnd,IDC_BSDATA),
				WM_SETTEXT,
				(WPARAM)0,
				(LPARAM)buf);

	sprintf(buf,"%.0f K",vi->fTotalCapacity/1024);
	SendMessage(GetDlgItem(vi->hwnd,IDC_TCDATA),
				WM_SETTEXT,
				(WPARAM)0,
				(LPARAM)buf);

	return TRUE;
}

void WipeThread(void* pvoid)
{
	wizard_data* data = (wizard_data*)pvoid;
	HWND hwnd = data->hwnd;
	HWND hwndParent = GetParent(hwnd);
	VOLINFO vi;
	long err;
	char buf[512];
	int passes = data->passes;
	PGPError		error			= kPGPError_NoErr;
	PGPError		entropyErr		= kPGPError_NoErr;
	PGPDiskWipeRef	wipeRef			= kPGPInvalidRef;
	PGPInt32		pattern[256];
	char StrRes[500];

	EnableWindow(GetDlgItem(hwnd, IDC_BEGIN), FALSE);
	EnableWindow(GetDlgItem(hwnd, IDC_SCHEDULE), FALSE);

	SendMessage(hwndParent, 
				PSM_SETWIZBUTTONS,
				0, 
				PSWIZB_DISABLEDFINISH);

	g_bWiping = TRUE;

	do{
		error = PGPCreateDiskWiper(data->context, &wipeRef, passes);

		if(error == kPGPError_OutOfEntropy)
		{
			if(data->cmdline)
				break;

			entropyErr = PGPclRandom(data->context, hwnd, 300);
		}

	}while(	error == kPGPError_OutOfEntropy && 
			entropyErr != kPGPError_UserAbort);
	
	err = WFE_NOERROR;

	if( IsntPGPError(error) )
	{
		int count = 0;

		do
		{
			WipeProgress(0);
			PassProgress(data->passes - passes, data->passes);

			if(err != WFE_DISKMODIFIED)
			{
				PGPGetDiskWipeBuffer(wipeRef, pattern);
			}

			err = WipeFree(	hwnd,
							&vi,
							data->drive,
							pattern,
							TRUE);

			if(err == WFE_DISKMODIFIED)
			{
				data->restarts=data->restarts+1;

				if(data->restarts>10)
					break;
				else
					SetWindowText(GetDlgItem(hwnd,IDC_RESTARTINGTEXT),
						"Write detected!  Restarting pass.");

//				PGPscMessageBox (hwnd,IDS_PGPERROR,IDS_DETECTEDWRITE,
//							MB_OK|MB_ICONEXCLAMATION);
			}
			else if(err==WFE_NOERROR)
			{
				SetWindowText(GetDlgItem(hwnd,IDC_RESTARTINGTEXT),
					"");

				passes--;
			}

		}while(((err==WFE_NOERROR) || (err==WFE_DISKMODIFIED)) && (passes!=0) );

		data->restarts=0;

		SetWindowText(GetDlgItem(hwnd,IDC_RESTARTINGTEXT),
			"");

		error = PGPDestroyDiskWiper(wipeRef);
	}
	else
	{
		err = error;
	}

	g_bWiping = FALSE;

	switch(err)
	{
		case kPGPError_OutOfEntropy:
		{
			LoadString (g_hinst, IDS_NOENTROPY, StrRes, sizeof(StrRes));

			wsprintf(buf, StrRes, data->drive);
			
			// Success.. Enable finish button
			if(!data->cmdline)
				SendMessage(hwndParent, 
					PSM_SETWIZBUTTONS, 
					0, 
					PSWIZB_BACK | PSWIZB_FINISH);
			break;
		}

		case WFE_NOERROR:
		{
			LoadString (g_hinst, IDS_WIPECONGRATS, StrRes, sizeof(StrRes));

			wsprintf(buf, StrRes, data->drive);
			
			// Success.. Enable finish button
			if(!data->cmdline)
				SendMessage(hwndParent, 
					PSM_SETWIZBUTTONS, 
					0, 
					PSWIZB_BACK | PSWIZB_FINISH);
			break;
		}

		case WFE_USERCANCEL:
		{
			LoadString (g_hinst, IDS_WIPECANCEL, StrRes, sizeof(StrRes));

			wsprintf(buf, StrRes);

			if(!data->cmdline)
				SendMessage(hwndParent, 
					PSM_SETWIZBUTTONS, 
					0, 
					PSWIZB_BACK | PSWIZB_DISABLEDFINISH);
			break;
		}

		default:
		{
			char msg[256];

			if(IsPGPError(error))
			{
				PGPclErrorToString (error, msg, sizeof(msg));
		
			}
			else
			{

				LoadString(	data->hinst,
						err -1 + IDS_FSNOTSUPPORTED,
						msg,
						sizeof(msg));	
			}

			LoadString (g_hinst, IDS_WIPENOTSUCCESSFUL, StrRes, sizeof(StrRes));
			wsprintf(buf, StrRes, msg);

			if(!data->cmdline)
				SendMessage(hwndParent, 
					PSM_SETWIZBUTTONS, 
					0, 
					PSWIZB_BACK | PSWIZB_DISABLEDFINISH);
			break;
		}
	}

	
	StatusMessage(buf, TRUE);
	WipeProgress(0);
	PassProgress(data->passes - passes, data->passes);

	// Command line. Set the return value and close everything down
	if(data->cmdline)
	{
		if((err==WFE_NOERROR)||(err==WFE_USERCANCEL))
			data->result=TRUE;

		// Wait 5 seconds to show user error
		Sleep(5000);

		SendMessage(hwndParent,WM_CLOSE,0,0);
		return;
	}

	// Not command line.. proceed to finish and reset everything
	EnableWindow(GetDlgItem(hwnd, IDC_BEGIN), TRUE);
	EnableWindow(GetDlgItem(hwnd, IDC_SCHEDULE), TRUE);
}


static HPALETTE 
CreateDIBPalette (LPBITMAPINFO lpbmi, 
				  LPINT lpiNumColors) 
{
	LPBITMAPINFOHEADER lpbi;
	LPLOGPALETTE lpPal;
	HANDLE hLogPal;
	HPALETTE hPal = NULL;
	INT i;
 
	lpbi = (LPBITMAPINFOHEADER)lpbmi;
	if (lpbi->biBitCount <= 8) {
		*lpiNumColors = (1 << lpbi->biBitCount);
	}
	else
		*lpiNumColors = 0;  // No palette needed for 24 BPP DIB
 
	if (*lpiNumColors) {
		hLogPal = GlobalAlloc (GHND, sizeof (LOGPALETTE) +
                             sizeof (PALETTEENTRY) * (*lpiNumColors));
		lpPal = (LPLOGPALETTE) GlobalLock (hLogPal);
		lpPal->palVersion = 0x300;
		lpPal->palNumEntries = *lpiNumColors;
 
		for (i = 0;  i < *lpiNumColors;  i++) {
			lpPal->palPalEntry[i].peRed   = lpbmi->bmiColors[i].rgbRed;
			lpPal->palPalEntry[i].peGreen = lpbmi->bmiColors[i].rgbGreen;
			lpPal->palPalEntry[i].peBlue  = lpbmi->bmiColors[i].rgbBlue;
			lpPal->palPalEntry[i].peFlags = 0;
		}
		hPal = CreatePalette (lpPal);
		GlobalUnlock (hLogPal);
		GlobalFree (hLogPal);
   }
   return hPal;
}


static HBITMAP 
LoadResourceBitmap (HINSTANCE hInstance, 
					LPSTR lpString,
					HPALETTE FAR* lppalette) 
{
	HRSRC  hRsrc;
	HGLOBAL hGlobal;
	HBITMAP hBitmapFinal = NULL;
	LPBITMAPINFOHEADER lpbi;
	HDC hdc;
    INT iNumColors;
 
	if (hRsrc = FindResource (hInstance, lpString, RT_BITMAP)) {
		hGlobal = LoadResource (hInstance, hRsrc);
		lpbi = (LPBITMAPINFOHEADER)LockResource (hGlobal);
 
		hdc = GetDC(NULL);
		*lppalette =  CreateDIBPalette ((LPBITMAPINFO)lpbi, &iNumColors);
		if (*lppalette) {
			SelectPalette (hdc,*lppalette,FALSE);
			RealizePalette (hdc);
		}
 
		hBitmapFinal = CreateDIBitmap (hdc,
                   (LPBITMAPINFOHEADER)lpbi,
                   (LONG)CBM_INIT,
                   (LPSTR)lpbi + lpbi->biSize + iNumColors * sizeof(RGBQUAD),
                   (LPBITMAPINFO)lpbi,
                   DIB_RGB_COLORS );
 
		ReleaseDC (NULL,hdc);
		UnlockResource (hGlobal);
		FreeResource (hGlobal);
	}
	return (hBitmapFinal);
}


/*__Editor_settings____

	Local Variables:
	tab-width: 4
	End:
	vi: ts=4 sw=4
	vim: si
_____________________*/