//////////////////////////////////////////////////////////////
//
//  Description	: PDF2HTML/BMP software
//  Author	: verypdf.com Inc
//  Version	: Ver1.2
//  Platform	: Windows95/98/Me/NT/2000/XP
//  Environment	: Visual C++ 6.0
//  Date	: 2002/04/03
//
//  Copyright(C) 2000--2003 verypdf.com Inc
//      
//  Contact infomation:
//        http://www.verypdf.com/
//        support@verypdf.com
//
//  This program is shareware; you can redistribute and/or 
//  modify it under the terms of the GNU General Public License.
//  See the GNU General Public License for more details.
//
//               Portion base on Xpdf code
//         Copyright 1996-2003 Glyph && Cog, LLC
//////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "resource.h"

//Config file info
#define SERIAL_FILE	"pdf2word.DAT"
#define CONFIG_FILE	"pdf2word.ini"
#define SOFTWARE_NAME	"pdf2word v1.4"
char szMailTo[] = "mailto:support@verypdf.com";

#if 1
char szEnglishHomepage[260] = "http://www.verypdf.com/pdf2word/index.html";
char szEnglishRegister[260] = "http://www.verypdf.com/pdf2word/index.html";
#else
//char szEnglishHomepage[260] = "http://www.regnow.com/softsell/nph-softsell.cgi?item=8554-10&affiliate=24301";
//char szEnglishRegister[260] = "http://www.regnow.com/softsell/nph-softsell.cgi?item=8554-10&affiliate=24301";
#endif

#define INCNAME		"verypdf.com Inc."
char szMailContent[] = 
	"Dear verypdf.com Inc:%0a"
	"I want register "SOFTWARE_NAME" software,...%0a"
	"%0a"
	"%0a"
	"%0a"
	"Best regard%0a"
	SOFTWARE_NAME" user";

#define REGISTER	"Please register"
#define REGISTERED	"Thank you registered"
#define SOFTREG		"Software register"
#define SERIESERR	"Series number error, please check it and try again."
#define REGREQUEST	"Register request"
#define SOFTEXPIRED	"Your software has expired, please register it, thank you!";
#define TRYTIMES	"Your have %d times to try, please register %s, thanks for your support!"

#define MAX_TRY_COUNT	100

BOOL    GetRightSerialNo(LPBYTE Feature,char* lpPassword);
int	LocalCompare(LPBYTE FileFeature);
BOOL	ReadFileFeature(LPBYTE FileFeature);
BOOL	IsRegistered = FALSE;

LONG MyGetRegKey(HKEY key, LPCTSTR subkey, LPTSTR retdata)
{
    HKEY hkey;
    LONG retval = RegOpenKeyEx(key, subkey, 0, KEY_QUERY_VALUE, &hkey);

    if (retval == ERROR_SUCCESS) {
        long datasize = MAX_PATH;
        TCHAR data[MAX_PATH];
        RegQueryValue(hkey, NULL, data, &datasize);
        lstrcpy(retdata,data);
        RegCloseKey(hkey);
    }

    return retval;
}

HINSTANCE MyGotoURL(LPCTSTR url, int showcmd)
{
    TCHAR key[MAX_PATH + MAX_PATH];

    // First try ShellExecute()
    HINSTANCE result = ShellExecute(NULL, _T("open"), url, NULL,NULL, showcmd);

    // If it failed, get the .htm regkey and lookup the program
    if ((UINT)result <= HINSTANCE_ERROR) {

        if (MyGetRegKey(HKEY_CLASSES_ROOT, _T(".htm"), key) == ERROR_SUCCESS) {
            lstrcat(key, _T("\\shell\\open\\command"));

            if (MyGetRegKey(HKEY_CLASSES_ROOT,key,key) == ERROR_SUCCESS) {
                TCHAR *pos;
                pos = _tcsstr(key, _T("\"%1\""));
                if (pos == NULL) {                     // No quotes found
                    pos = strstr(key, _T("%1"));       // Check for %1, without quotes 
                    if (pos == NULL)                   // No parameter at all...
                        pos = key+lstrlen(key)-1;
                    else
                        *pos = '\0';                   // Remove the parameter
                }
                else
                    *pos = '\0';                       // Remove the parameter

                lstrcat(pos, _T(" "));
                lstrcat(pos, url);
                result = (HINSTANCE) WinExec(key,showcmd);
            }
        }
    }

    return result;
}

BOOL IsCorrect(LPBYTE FileFeature)
{
		return FALSE;
}
void	WriteFileFeature(LPBYTE FileFeature)
{
	char TempFileName[MAX_PATH];
	GetSystemDirectory(TempFileName,MAX_PATH);
	if(TempFileName[strlen(TempFileName)-1] != '\\')
		strcat(TempFileName,"\\");
	strcat(TempFileName,SERIAL_FILE);
	FILE* hFile = fopen(TempFileName,"wb");
	if(hFile == NULL)
		return;
	fwrite(FileFeature,1,1024,hFile);
	fclose(hFile);
}
VOID	RegisterMagicMirror(HWND hWnd,char* szPassword)
{
	BYTE		Feature[1024];
	GetRightSerialNo((LPBYTE)&Feature,szPassword);
	LPBYTE lpFeature = (LPBYTE)&Feature;
	WriteFileFeature(lpFeature);
}
BOOL CenterWindow (HWND hwndChild, HWND hwndParent)
{
	RECT    rChild, rParent;
	int     wChild, hChild, wParent, hParent;
	int     wScreen, hScreen, xNew, yNew;
	HDC     hdc;
	
	// Get the Height and Width of the child window
	GetWindowRect (hwndChild, &rChild);
	wChild = rChild.right - rChild.left;
	hChild = rChild.bottom - rChild.top;
	
	// Get the Height and Width of the parent window
	GetWindowRect (hwndParent, &rParent);
	wParent = rParent.right - rParent.left;
	hParent = rParent.bottom - rParent.top;
	
	// Get the display limits
	hdc = GetDC (hwndChild);
	wScreen = GetDeviceCaps (hdc, HORZRES);
	hScreen = GetDeviceCaps (hdc, VERTRES);
	ReleaseDC (hwndChild, hdc);
	
	// Calculate new X position, then adjust for screen
	xNew = rParent.left + ((wParent - wChild) /2);
	if (xNew < 0)
		xNew = 0;
	else if ((xNew+wChild) > wScreen)
		xNew = wScreen - wChild;
	
	// Calculate new Y position, then adjust for screen
	yNew = rParent.top  + ((hParent - hChild) /2);
	if (yNew < 0)
		yNew = 0;
	else if ((yNew+hChild) > hScreen)
		yNew = hScreen - hChild;
	
	// Set it, and return
	return SetWindowPos (hwndChild, NULL, xNew, yNew, 0, 0,
		SWP_NOSIZE | SWP_NOZORDER);
}

int	GetTrailCount()
{
	BYTE	FileFeature[1024];
	char	nTrial[5];

	if(ReadFileFeature((LPBYTE)&FileFeature) == FALSE)
		return -1;
	memcpy(nTrial,&FileFeature[300],sizeof(int));
	nTrial[4] = '\0';
	return atoi(nTrial);
}
void	WriteTrailCount(int nTrial)
{
	BYTE	FileFeature[1024];

	memset(FileFeature,0,1024);
	sprintf((char *)&FileFeature[300],"%d",nTrial);
	WriteFileFeature((LPBYTE)&FileFeature);
}
BOOL	ReadFileFeature(LPBYTE FileFeature)
{
	HFILE		hFile;
	OFSTRUCT	OpenStruct;
	char		TempFileName[MAX_PATH];

	GetSystemDirectory(TempFileName,MAX_PATH);
	if(TempFileName[strlen(TempFileName)-1] != '\\')
		strcat(TempFileName,"\\");
	strcat(TempFileName,SERIAL_FILE);
	hFile = OpenFile(TempFileName,&OpenStruct,OF_EXIST);
	if(hFile==HFILE_ERROR)
		return FALSE;
	hFile=_lopen(TempFileName,OF_READ);
	_lread(hFile,FileFeature,1024);
	_lclose(hFile);
	return TRUE;
}
////////////////////////////////////////////////////////////////////////
//
//	ǖ��: INT	CheckSerialNo()
//	�ݎ�: ���������ѕ�ѧ�
//	�毝��:
//		0:���㯀�����,Ҁ�����ǯ�
//		1:���ǯ�ў���яؽ�׎��
//		2:����яؽ�׎�������
//		3:��櫒�Ӗ掯�����
//
////////////////////////////////////////////////////////////////////////
INT WINAPI CheckSerialNo()
{
	return 0;
}
static	void	EncodeXORAdd(LPBYTE Feature)
{
	int	i;
	for(i=0;i<512;i++)
		Feature[512+i] = Feature[i]^(~i);
}
static	int	LocalCompare(LPBYTE FileFeature)
{
	int	i;
	unsigned char	Data;
	int	Ret=1;
	for(i=0;i<512;i++)
	{
		Data = FileFeature[512+i]^(~i);
		if(Data!=FileFeature[i])
		{
			Ret=0;
			break;
		}
	}
	return	Ret;
}
BOOL GetRightSerialNo(LPBYTE Feature,char* lpPassword)
{
	if(Feature == NULL)
		return FALSE;
	//��Ҭ��яؽ�잂
	memset(Feature,'X',1024);
	for(INT i = 0; i < 512; i++)
		Feature[i]=i^'H';
	memcpy(&Feature[260],lpPassword,16);
	/////////////XOR++/////////////
	EncodeXORAdd(Feature);
	////////////////////////////////
	return TRUE;

}
DWORD GetDiskSerialNo(LPSTR lpFileSystemNameBuffer,LPSTR lpVolumeNameBuffer)
{
	LPCTSTR lpRootPathName		= "c:\\"; //ԭC���ѕ�ѧ�
	DWORD nVolumeNameSize		= 12;
	DWORD VolumeSerialNumber;//�ѕ�ѧ�
	DWORD MaximumComponentLength;
	DWORD nFileSystemNameSize	= 10;
	DWORD FileSystemFlags;

	if(GetVolumeInformation(lpRootPathName,
		lpVolumeNameBuffer, nVolumeNameSize,
		&VolumeSerialNumber, &MaximumComponentLength,
		&FileSystemFlags,
		lpFileSystemNameBuffer,
		nFileSystemNameSize) == FALSE)
		return 0;

	VolumeSerialNumber^=0x90909090;//��㯞���,
	return  VolumeSerialNumber;
}
BOOL GetSerialNoString(char* lpPassword)
{
	BYTE Feature[1024];
	//���
	CHAR lpFileSystemNameBuffer[10];
	CHAR lpVolumeNameBuffer[12];
	ZeroMemory(lpFileSystemNameBuffer,sizeof(CHAR)*10);
	ZeroMemory(lpVolumeNameBuffer,sizeof(CHAR)*12);
	DWORD VolumeSerialNumber = GetDiskSerialNo((LPSTR)&lpFileSystemNameBuffer,(LPSTR)&lpVolumeNameBuffer);
	//��Ҭ��яؽ�잂
	memset(Feature,'X',sizeof(BYTE)*1024);
	for(INT i = 0; i < 256; i++)
		Feature[i]=i^'U';
	//FileSystem Name
	for(i = 0; i < 10; i++)
		Feature[256+i] = lpFileSystemNameBuffer[i];
	//Volume Name
	for(i = 0; i < 12; i++)
		Feature[266+i] = lpVolumeNameBuffer[i];
	//Volume Serial Number
	WORD hWord = HIWORD(VolumeSerialNumber);
	WORD lWord = LOWORD(VolumeSerialNumber);
	BYTE hWord_hByte = HIBYTE(hWord);
	BYTE hWord_lByte = LOBYTE(hWord);
	BYTE lWord_hByte = HIBYTE(lWord);
	BYTE lWord_lByte = LOBYTE(lWord);
	Feature[278] = hWord_hByte;
	Feature[279] = hWord_lByte;
	Feature[280] = lWord_hByte;
	Feature[281] = lWord_lByte;
	//Password( 15 BYTEs)
	BYTE CharPalette[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	char TextFile[10];
	int count = 0;
	count = 16;
	for(i = 282; i < 282+count; i++)
	{
		Feature[i] = Feature[i-count]^(~i);
		//�����׎��
		wsprintf(TextFile,"%c",CharPalette[Feature[i]%36]);
		Feature[i] = TextFile[0];
		lpPassword[i-282] = Feature[i];
	}
	return TRUE;
}

VOID SendEmail(HWND hWnd,LPCTSTR pszSubject)
{
	char szMailToContent[1024];
	sprintf(szMailToContent,"%s?subject=%s&Body=%s",szMailTo,pszSubject,szMailContent);
	ShellExecute(NULL,"open",szMailToContent,NULL,NULL,SW_SHOWNORMAL);
}
char szPassword[200];
BOOL CALLBACK RegisterDlgFunc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
	case WM_INITDIALOG:
		{
			SetWindowText(hDlg,REGISTER" "SOFTWARE_NAME);
			GetSerialNoString(szPassword);
			szPassword[16] = 0;
			//CBase64 m_base64;
			//m_base64.Encode(szPassword,16,Feature);
			char szPassword1[200];
			sprintf(szPassword1,"[%s]",szPassword);
			SetDlgItemText(hDlg,IDC_EDIT_PRODUCTID,szPassword1);
			if(CheckSerialNo() == 0)
			{
				IsRegistered = TRUE;
				EndDialog(hDlg,IDOK);
			}
			else
			{
				SetDlgItemText(hDlg,IDC_EDIT_SERIALNO,"");
				SetDlgItemText(hDlg,IDC_STATIC_INFO1,
					"You can receive your registration key of this product only"
					" after buy it first, if you haven't bought it, please click"
					" 'Buy Now' button to buy.");
			}
			CenterWindow(hDlg,GetDesktopWindow());
			SetWindowPos( hDlg, HWND_TOPMOST, 0, 0, 0, 0,
					 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);

			return TRUE;
		}
	case WM_COMMAND:
		{
			INT wmId    = LOWORD(wParam);
			switch(wmId)
			{
			case	IDOK:
				{
					memset(szPassword,0,200);
					GetDlgItemText(hDlg,IDC_EDIT_SERIALNO,szPassword,200);
					if(IsCorrect((LPBYTE)szPassword))
					{//OK
						MessageBox(hDlg,
							REGISTERED" "SOFTWARE_NAME".",
							REGISTERED,MB_OK|MB_ICONINFORMATION);
					}
					else
					{
						MessageBox(hDlg,SERIESERR,NULL,MB_OK|MB_ICONERROR);
						SetFocus(GetDlgItem(hDlg,IDC_EDIT_SERIALNO));
						return 0;
					}

					RegisterMagicMirror(hDlg,szPassword);
					IsRegistered = TRUE;

					EndDialog(hDlg,wmId);
					break;
				}
/*			case	IDC_BUTTON_REQUEST:
				{
					char szID[200];
					GetDlgItemText(hDlg,IDC_EDIT_PRODUCTID,szID,200);
					CString subject;
					subject = SOFTWARE_NAME" "REGREQUEST":";
					subject += szID;
					SendEmail(hDlg,subject);
					break;
				}
*/			case	IDCANCEL:
				{
					memset(szPassword,0,200);
					GetDlgItemText(hDlg,IDC_EDIT_SERIALNO,szPassword,200);
					if(IsCorrect((LPBYTE)szPassword))
						IsRegistered = TRUE;
					else
					{
						MessageBox(hDlg,
							REGISTER" "SOFTWARE_NAME"!",
							SOFTREG,MB_OK|MB_ICONWARNING);
						ExitProcess(0);
					}
					EndDialog(hDlg,wmId);
					break;
				}
			case	IDC_BUTTON_TRY:
				{
					int	iTrail = GetTrailCount();
					if(iTrail == -1)
						iTrail = 0;
					if(iTrail >= MAX_TRY_COUNT)
					{
						CString szMessage;
						szMessage = SOFTEXPIRED;
						MessageBox(hDlg,szMessage,SOFTREG,MB_OK|MB_ICONWARNING);
						ExitProcess(0);
					}
					else if(iTrail >= 0)
					{
						CString szMessage;
						szMessage.Format(TRYTIMES,MAX_TRY_COUNT-iTrail,SOFTWARE_NAME);
						MessageBox(hDlg,szMessage,SOFTREG,MB_OK|MB_ICONWARNING);

						iTrail++;
						WriteTrailCount(iTrail);
					}
					EndDialog(hDlg,wmId);
					break;
				}
			case IDC_BUTTON_BUYNOW:
				MyGotoURL(szEnglishRegister,SW_SHOWNORMAL);
				break;
			}
			break;
		}
	case WM_CLOSE:
		SendMessage(hDlg,WM_COMMAND,IDCANCEL,0);
		break;
	}
	return FALSE;
}

BOOL WINAPI ShowRegisterDlg(BOOL _IsRegistered,HWND hWnd)
{
	IsRegistered = _IsRegistered;
	DialogBox(AfxGetInstanceHandle(),
		MAKEINTRESOURCE(IDD_DIALOG_REGISTER),hWnd,RegisterDlgFunc);
	return IsRegistered;
}