CopyFile Code

Brought to you by: samepaul
[r25]: / main.cpp Maximize Restore History

666 lines (572 with data), 19.5 kB

#include <windows.h>
#include "Dialog.h"
#include "Registry.h"
#include "Queue.h"
#include "resource.h"
#include <commctrl.h>
#include "Helpers.h"
#include "Netman.h"
#include <crtdbg.h>
//#include "Token.h"
/*
#include <stdio.h>
#include <tchar.h>
*/
//#define _WIN32_DCOM 
#include <objbase.h>

HINSTANCE hInstance;

BOOL CALLBACK OnDraw(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
BOOL CALLBACK OnMeasure(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
BOOL CALLBACK OnResize(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
BOOL CALLBACK OnCtlEvent(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
BOOL CALLBACK OnCompare(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

LRESULT CALLBACK OnTextDrop(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK OnListDrop(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

void SettingsSave(RegKey& root);
void SettingsLoad(RegKey& root);

extern Dialog *netman;
Dialog *jobman;
Queue *queue;

bool EditMode =  false;
bool LongFormat = false;

LONG WINAPI MainExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo);
DWORD ThreadGUI;

bool ParseCmdLine(void)
{
#ifdef UNICODE

	LPTSTR cmdline = GetCommandLine();
	int cmdcount;
	LPWSTR *cmds = CommandLineToArgvW(cmdline, &cmdcount);
	if (cmds) {
		int i;
		queue->AutoAdvance = false;
		for (i=1; i< cmdcount; i++) {
			Job *p = queue->AddItem(cmds[i], NULL);
			if (p == NULL) {
				OutputDebugString(TEXT("AddJob from ParseCmdLine failed\n"));
				break;
			} else {
				p->Start();
			}
		}
		
		GlobalFree(cmds);
		return (cmdcount > 1);
	}
#else
	#pragma message("Command line parsing is not supported yet in ANSI")
#endif
	return false;
	
}
int PASCAL WinMain (HINSTANCE this_inst, HINSTANCE prev_inst, LPSTR cmdline, int cmdshow)
{
	// catch all exceptions
	ThreadGUI = GetCurrentThreadId();
	SetUnhandledExceptionFilter(MainExceptionFilter);
	
	EVENT_HANDLER 
		handlers[] = {
			{WM_DRAWITEM,			OnDraw},
			{WM_MEASUREITEM,		OnMeasure},
			{WM_COMMAND,			OnCtlEvent},
			{WM_COMPAREITEM,		OnCompare},
			{0,NULL}};

	hInstance=this_inst;
	RegKey root;

	INITCOMMONCONTROLSEX iccx = {sizeof(INITCOMMONCONTROLSEX), ICC_WIN95_CLASSES | ICC_INTERNET_CLASSES};
//	CToken token(TEXT("*Trainspot*.s*"));
//	bool cmp = token.IsMatch(TEXT("\\\\DOMINOS\\downloads\\American pie.ace"));
	
	//CoInitializeEx(NULL,COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
	//CoInitialize(NULL);
	
	BOOL initres = InitCommonControlsEx(&iccx);
	
	jobman = new Dialog(IDD_MAIN,handlers);
	HWND hwndTest = jobman->Handle();
	
	if (jobman && jobman->Ready()) {
		//jobman->resizer.Enable(false);
		jobman->resizer.SetBoth(jobman->GetItem(IDC_JOBS), ANCHOR_BOTH, ANCHOR_BOTH);
		//SHAutoComplete(jobman->GetItem(IDC_ED_SRC), SHACF_AUTOSUGGEST_FORCE_ON | SHACF_FILESYS_ONLY);
		//SetWindowLong(netman->Handle(), GWL_HWNDPARENT, (LONG)jobman->Handle());
		queue = new Queue(jobman->GetItem(IDC_JOBS));

		if (ParseCmdLine()) {
			OutputDebugString(TEXT("Command line parsed\n"));
		}
		
		CreateNetManager(root);
		if (queue) {
			SettingsLoad(root);
			//queue->Load();
			OutputDebugString(TEXT("Application initialized\n"));
			
			jobman->Show();
			//netman->Show(true);
			OutputDebugString(TEXT("Save queue & settings\n"));
			queue->Save();

			SettingsSave(root);
			OutputDebugString(TEXT("Destroy queue\n"));
			DeletePtr(queue);
		}
		OutputDebugString(TEXT("Destroy netman\n"));
		DestroyNetManager(true);
	}
	OutputDebugString(TEXT("Destroy jobman\n"));
	DeletePtr(jobman);
	
	//OutputDebugString(TEXT("CoUnitialize\n"));
	//CoUninitialize();
	OutputDebugString(TEXT("All done - application finished\n"));
#ifdef DEBUG
	_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF  | _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG));
#endif

	return 0;
}

void SettingsLoad(RegKey& root)
{
	RegValue regval;
	HWND hCtl;
	UDACCEL accel[]={{1,1},
					{2,10},
					{3,100},
					{4,1000},
					{5,10000},
					{6,100000},
					{7,1000000},
					{8,10000000}};
	jobman->SetIconFromRes(IDI_MAIN);
	root.LoadWindowPos(jobman->Handle());
	root.LoadWindowPos(netman->Handle());

	regval = root.GetValue(TEXT("Position\\NetManSizer"));
	if (regval.Type == REG_DWORD) {
		netman->resizer.SetSizerPos(regval.v.dword);
	}

	hCtl = jobman->GetItem(IDC_SPIN_START);
	SendMessage(hCtl, UDM_SETRANGE32, 0, MAXINT_PTR);
	SendMessage(hCtl, UDM_SETACCEL, sizeof(accel)/sizeof(UDACCEL), (LPARAM)accel);
	hCtl = jobman->GetItem(IDC_SPIN_END);
	SendMessage(hCtl, UDM_SETRANGE32, 0, MAXINT_PTR);
	SendMessage(hCtl, UDM_SETACCEL, sizeof(accel)/sizeof(UDACCEL), (LPARAM)accel);


	jobman->SubclassItem(IDC_ED_SRC, OnTextDrop);
	jobman->SubclassItem(IDC_ED_DST, OnTextDrop);
	//jobman->SubclassItem(IDC_JOBS, OnListDrop);

	regval = root.GetValue(TEXT("Recent\\Source"));
	if (regval.Type==REG_SZ) {
		jobman->SetItemText(IDC_ED_SRC, regval.v.str);
	}
	regval = root.GetValue(TEXT("Recent\\Destination"));
	if (regval.Type==REG_SZ) {
		jobman->SetItemText(IDC_ED_DST, regval.v.str);
	}
	regval = root.GetValue(TEXT_OPT_SEEK_GOOD);
	AUTO_SEEK_GOOD = regval.v.logic;
	jobman->BtnSetCheck(IDC_CHECK_SEEKGOOD, AUTO_SEEK_GOOD);

	regval = root.GetValue(TEXT("Options\\AutoAdvance"));
	queue->AutoAdvance = regval.v.logic;
	jobman->BtnSetCheck(IDC_CHECK_AUTONEXT,queue->AutoAdvance);

	regval = root.GetValue(TEXT("Options\\LongFormat"));
	LongFormat = regval.v.logic;
	jobman->BtnSetCheck(IDC_CHECK_LONGFORMAT, LongFormat);

	jobman->SpinSetRange(IDC_SPIN_RETRIES,0,1000);
	regval = root.GetValue(TEXT("Options\\Retries"));
	if (regval.Type==REG_DWORD) {
		jobman->SpinSetValue(IDC_SPIN_RETRIES, regval.v.dword);
	} else {
		jobman->SpinSetValue(IDC_SPIN_RETRIES, 10);
	}
	// graph
	hCtl = jobman->GetItem(IDC_SPIN_MAX_SPEED);
	SendMessage(hCtl, UDM_SETRANGE32, 1, 100000);
	SendMessage(hCtl, UDM_SETACCEL, sizeof(accel)/sizeof(UDACCEL), (LPARAM)accel);

	regval = root.GetValue(TEXT_OPT_MAX_SPEED);
	if (regval.Type==REG_DWORD) {
		jobman->SpinSetValue(IDC_SPIN_MAX_SPEED, (regval.v.dword>>10));
	} else {
		jobman->SpinSetValue(IDC_SPIN_MAX_SPEED, MAX_SPEED>>10);
	}

	jobman->SpinSetRange(IDC_SPIN_BAR_WIDTH, 2, MAX_BAR);
	regval = root.GetValue(TEXT_OPT_BAR);
	if (regval.Type==REG_DWORD) {
		jobman->SpinSetValue(IDC_SPIN_BAR_WIDTH, regval.v.dword);
	} else {
		jobman->SpinSetValue(IDC_SPIN_BAR_WIDTH, BAR);
	}

	jobman->SpinSetRange(IDC_SPIN_HISTORY_LEN, 5, MAX_HISTORY);
	regval = root.GetValue(TEXT_OPT_HISTORY_LEN);
	if (regval.Type==REG_DWORD) {
		jobman->SpinSetValue(IDC_SPIN_HISTORY_LEN, regval.v.dword);
	} else {
		jobman->SpinSetValue(IDC_SPIN_HISTORY_LEN, HISTORY_LEN);
	}

	//-----------------------

	// Netman settings
	regval = root.GetValue(TEXT("Recent\\Mask"));
	if (regval.Type==REG_SZ) {
		netman->SetItemText(IDC_ED_MASK, regval.v.str);
	} else {
		netman->SetItemText(IDC_ED_MASK,TEXT("*.avi"));
	}
	regval = root.GetValue(TEXT("Options\\AutoSearch"));
	netman->BtnSetCheck(IDC_CHK_AUTO, regval.v.logic);

	regval = root.GetValue(TEXT("Options\\NoSound"));
	netman->BtnSetCheck(IDC_CHK_NOSOUND, regval.v.logic);

 	return;
}

void SettingsSave(RegKey& root)
{
	RegValue regval;
	netman->Hide();
	root.SaveWindowPos(jobman->Handle());
	root.SaveWindowPos(netman->Handle());

	regval.Type = REG_DWORD;
	regval.v.dword = netman->resizer.GetSizerPos();
	regval.Length = sizeof(regval.v.dword);
	root.SetValue(TEXT("Position\\NetManSizer"), regval);

	regval.v.logic = queue->AutoAdvance;
	regval.Length = sizeof(regval.v.logic);
	root.SetValue(TEXT("Options\\AutoAdvance"), regval);
	regval.v.logic = LongFormat;
	root.SetValue(TEXT("Options\\LongFormat"), regval);
	regval.v.logic = AUTO_SEEK_GOOD;
	root.SetValue(TEXT_OPT_SEEK_GOOD, regval);

	// graph
	regval.Type = REG_DWORD;
	regval.v.dword = MAX_SPEED; //(jobman->SpinGetValue(IDC_SPIN_MAX_SPEED))>>10;
	regval.Length = sizeof(regval.v.dword);
	root.SetValue(TEXT_OPT_MAX_SPEED, regval);

	regval.v.dword = BAR; //jobman->SpinGetValue(IDC_SPIN_BAR_WIDTH);
	root.SetValue(TEXT_OPT_BAR, regval);

	regval.v.dword = HISTORY_LEN;// jobman->SpinGetValue(IDC_SPIN_HISTORY_LEN);
	root.SetValue(TEXT_OPT_HISTORY_LEN, regval);
	//-----------------------

	regval.Type = REG_DWORD;
	regval.v.dword = jobman->SpinGetValue(IDC_SPIN_RETRIES);
	regval.Length = sizeof(regval.v.dword);
	root.SetValue(TEXT("Options\\Retries"), regval);
	
	regval.Type = REG_SZ;
	regval.v.str = jobman->GetItemText(IDC_ED_SRC);
	if (regval.v.str) {
		regval.Length = StrLen(regval.v.str)*sizeof(TCHAR);
		root.SetValue(TEXT("Recent\\Source"), regval);
		delete regval.v.str;
	}

	regval.Type = REG_SZ;
	regval.v.str = jobman->GetItemText(IDC_ED_DST);
	if (regval.v.str) {
		regval.Length = StrLen(regval.v.str)*sizeof(TCHAR);
		root.SetValue(TEXT("Recent\\Destination"), regval);
		delete regval.v.str;
	}
	// Netman settings
	regval.Type = REG_SZ;
	regval.v.str = netman->GetItemText(IDC_ED_MASK);
	if (regval.v.str) {
		regval.Length = StrLen(regval.v.str)*sizeof(TCHAR);
		root.SetValue(TEXT("Recent\\Mask"),regval);
		delete regval.v.str;
	}
	 
	regval.Type = REG_DWORD;
	regval.v.logic = netman->BtnGetCheck(IDC_CHK_AUTO);
	regval.Length = sizeof(regval.v.logic);
	root.SetValue(TEXT("Options\\AutoSearch"), regval);

	regval.Type = REG_DWORD;
	regval.v.logic = netman->BtnGetCheck(IDC_CHK_NOSOUND);
	regval.Length = sizeof(regval.v.logic);
	root.SetValue(TEXT("Options\\NoSound"), regval);

	regval.Type = REG_DWORD;
	regval.v.dword = netman->SpinGetValue(IDC_SPIN_THREADS);
	regval.Length = sizeof(regval.v.dword);
	root.SetValue(TEXT_OPT_THREADLIMIT, regval);

	regval.Type = REG_DWORD;
	regval.v.dword = netman->IP_GetValue(IDC_IP_FROM, true);
	root.SetValue(TEXT_OPT_RANGE_START, regval);

	regval.Type = REG_DWORD;
	regval.v.dword = netman->IP_GetValue(IDC_IP_TO, true);
	root.SetValue(TEXT_OPT_RANGE_END, regval);

	return;
}

BOOL CALLBACK OnCompare(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{	
	Job *pjob1=(Job*)((LPCOMPAREITEMSTRUCT)lParam)->itemData1,
		*pjob2=(Job*)((LPCOMPAREITEMSTRUCT)lParam)->itemData2;
	return pjob1->Compare(*pjob2);
}


BOOL CALLBACK OnDraw(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	LPDRAWITEMSTRUCT pDis=(LPDRAWITEMSTRUCT) lParam;
	switch (pDis->CtlType) {
	case ODT_LISTBOX:
		if (pDis->itemData) {
			((Job*)pDis->itemData)->Draw(pDis->hDC, pDis->rcItem, pDis->itemState, LongFormat);
		}
		return TRUE;
	case ODT_MENU:		break;
	}
	return FALSE;
	
}

BOOL CALLBACK OnMeasure(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	LPMEASUREITEMSTRUCT pMsr=(LPMEASUREITEMSTRUCT)lParam;
	/*
	if (wParam) { // it's control
		return queue->MeasureItem(pMsr);
	} else { // it's menu
		//
	}*/
	switch (pMsr->CtlType) {
	case ODT_LISTBOX:	return queue->MeasureItem(pMsr);
	case ODT_MENU:		break;
	}

	return FALSE;
}

BOOL CALLBACK OnResize(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	RECT rcDlg, rcList;
	POINT pt={0, 0};
	HWND hList=GetDlgItem(hwndDlg, IDC_JOBS);

	ClientToScreen(hwndDlg, &pt);
	GetClientRect(hwndDlg, &rcDlg);
	GetWindowRect(hList,&rcList);

	OffsetRect(&rcList, -pt.x,-pt.y);
	SetWindowPos(hList, 0, rcList.left, rcList.top, rcDlg.right-rcList.left*2, rcDlg.bottom-rcList.top-rcList.left, SWP_NOZORDER);
	InvalidateRect(hList,NULL,FALSE);


	return FALSE;
}
bool BrowseForFile(int EditID, bool SaveBox)
{
	TCHAR lpInit[MAX_PATH];
	DWORD len = jobman->GetItemText(EditID, lpInit, MAX_PATH);
	
	OPENFILENAME ofn={sizeof(ofn)};
	BOOL ret;

	if (lpInit[len-1]=='\\') {
		StrCopy(lpInit+len,TEXT("*.*\0"));
	}

	//ofn.lStructSize=
	ofn.hwndOwner = jobman->Handle();
	ofn.hInstance = hInstance;
	ofn.lpstrFilter = TEXT("All files\0*.*\0Movies\0*.avi,*.mpg,*.mpeg,*.divx\0CD Images\0*.iso,*.bin\0\0");
	ofn.nFilterIndex = 1; // all
	ofn.lpstrFile = lpInit ;
	ofn.nMaxFile = MAX_PATH;
	//ofn.lpstrCustomFilter = NULL;
	//ofn.nMaxCustFilter = 0;
	//ofn.lpstrFileTitle = NULL;
	//ofn.nMaxFileTitle;
	//ofn.lpstrInitialDir = NULL;
	//ofn.lpstrTitle = NULL;
	//ofn.nFileOffset;
	//ofn.nFileExtension;
	//ofn.lpstrDefExt;
	//ofn.lCustData;
	//ofn.lpfnHook;
	//ofn.lpTemplateName;
	ofn.Flags = OFN_ENABLESIZING | OFN_EXPLORER | OFN_HIDEREADONLY | OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST; //|OFN_NOTESTFILECREATE;
	if (SaveBox) {
		ofn.Flags |= (OFN_NOTESTFILECREATE |OFN_NOVALIDATE);//OFN_NOREADONLYRETURN );
		ret = GetSaveFileName(&ofn);
	} else {
		ofn.Flags |= (OFN_FILEMUSTEXIST);
		ret = GetOpenFileName(&ofn);
	}
	if (ret) {
		if (ofn.lpstrFile[ofn.nFileOffset] == '*' || ofn.lpstrFile[ofn.nFileExtension] == '*') {
			ofn.lpstrFile[ofn.nFileOffset] = 0;
		}
		jobman->SetItemText(EditID, ofn.lpstrFile);// lpTmp);
		return true;
	} else {
		DWORD errcode = CommDlgExtendedError();
		wsprintf(lpInit,TEXT("GetOpenFielName failed: %d\n"), errcode);
		OutputDebugString(lpInit);
	}
	//delete lpTmp;
	return false;
}

void CopyScreen(HWND hwnd)
{
 
	HDC hdcRef = GetDC(NULL); 
 
 
	int iWidthMM = GetDeviceCaps(hdcRef, HORZSIZE),
		iHeightMM = GetDeviceCaps(hdcRef, VERTSIZE),
		iWidthPels = GetDeviceCaps(hdcRef, HORZRES),
		iHeightPels = GetDeviceCaps(hdcRef, VERTRES); 
	int i=0;
 
	// Retrieve the coordinates of the client 
	// rectangle, in pixels. 
 
	RECT rcBound={0,0, iWidthPels, iHeightPels};

	//GetWindowRect(hwnd, &rcBound);

	//OffsetRect(&rcBound, -rcBound.left, -rcBound.top);
	RECT rc ={(rcBound.left * iWidthMM * 100)/iWidthPels,
			  (rcBound.top * iHeightMM * 100)/iHeightPels,
			  (rcBound.right * iWidthMM * 100)/iWidthPels,
			  (rcBound.bottom * iHeightMM * 100)/iHeightPels
	};
	 

	//
	HDC dcMeta = CreateEnhMetaFile(hdcRef, TEXT("C:\\Apps\\Temp\\screen.emf"), &rc, TEXT("CopyFile\0Screenshot\0\0"));
	//ReleaseDC(hwnd, hdcRef);	
	i = SendMessage(hwnd, WM_PRINT,(WPARAM) dcMeta, PRF_CHILDREN | PRF_CLIENT | PRF_NONCLIENT | PRF_ERASEBKGND);
	
	
	HENHMETAFILE hMeta = CloseEnhMetaFile(dcMeta);

	//hdcRef = GetWindowDC(NULL);
	//SendMessage(netman->Handle(), WM_PRINT,(WPARAM) hdcRef, PRF_CHILDREN | PRF_CLIENT | PRF_NONCLIENT);
	//rc.left = rc.top = 0;
	//rc.right = 1024;
	//rc.bottom = 768;
	i = PlayEnhMetaFile(hdcRef, hMeta, &rcBound);

	//i = SendMessage(hwnd, WM_PRINT,(WPARAM) hdcRef, PRF_CHILDREN | PRF_CLIENT | PRF_NONCLIENT | PRF_ERASEBKGND);

	ReleaseDC(NULL, hdcRef);	

	i = DeleteEnhMetaFile(hMeta);

}

BOOL CALLBACK OnCtlEvent(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	if (jobman==NULL || queue==NULL) return FALSE;

	WORD	wCode = HIWORD(wParam),
			wID = LOWORD(wParam);
	TCHAR buf[15];
	Job &job = queue->GetCurrent();

	switch (wCode) {
//	case 0: // menu
//		break;
	case 1: // accelerator
		break;
	default: // this is notify code of control
		switch (wID) {
		case IDC_JOBS:
			wsprintf(buf, TEXT("%u bps"), queue->speed);
			jobman->SetItemText(IDC_ED_SPEED,buf);
			break;
		case IDC_ED_RETRIES:
			MAX_RETRIES=jobman->SpinGetValue(IDC_SPIN_RETRIES);
			break;
		case IDC_CHECK_AUTONEXT:
			queue->AutoAdvance=jobman->BtnGetCheck(IDC_CHECK_AUTONEXT);
			break;
		case IDC_CHECK_LONGFORMAT:
			LongFormat = jobman->BtnGetCheck(IDC_CHECK_LONGFORMAT);
			break;
		case IDC_CHECK_SEEKGOOD:
			AUTO_SEEK_GOOD = jobman->BtnGetCheck(IDC_CHECK_SEEKGOOD);
			break;
		//case IDC_BTN_ENUM:
		//	netman->Show(false);
		//	break;
		case IDC_ED_SRC:
		case IDC_ED_DST:
			//hCtl=jobman->GetItem(wID);
			//hr=SHAutoComplete(hCtl,SHACF_AUTOSUGGEST_FORCE_ON  | SHACF_FILESYS_ONLY);
			//hr=0;
			if (!EditMode && queue) {
				jobman->GetItemText(IDC_ED_DST, queue->DefaultDestination,MAX_PATH);
			}
			break;
		case IDC_BTN_UPDATE: 
			if (job.Ready()){
				jobman->EnableItem(IDC_JOBS, EditMode);
				jobman->EnableItem(IDC_BTN_ADD, EditMode);
				jobman->EnableItem(IDC_BTN_REMOVE, EditMode);
				jobman->EnableItem(IDC_BTN_START, EditMode);
				jobman->EnableItem(IDC_BTN_STOP, EditMode);
				jobman->EnableItem(IDC_BTN_PRUNE, EditMode);

				EditMode = !EditMode;
				if (EditMode) {
					jobman->SetItemText(IDC_ED_SRC, job.GetFileName(true));
					jobman->SetItemText(IDC_ED_DST, job.GetFileName(false));
					jobman->SetItemText(IDC_BTN_UPDATE, TEXT("Update"));
				} else {
					LPTSTR	lpSrc = jobman->GetItemText(IDC_ED_SRC),
							lpDst = jobman->GetItemText(IDC_ED_DST);
					job.UpdateFileNames(lpSrc, lpDst);
					delete lpSrc;
					delete lpDst;
					jobman->SetItemText(IDC_ED_DST, queue->DefaultDestination);
					jobman->SetItemText(IDC_BTN_UPDATE, TEXT("Edit"));
					queue->Save();
				}
			}
			break;
		case IDC_BTN_ADD:
			LPTSTR lpSrc, lpDst;
			lpSrc = jobman->GetItemText(IDC_ED_SRC);
			lpDst = jobman->GetItemText(IDC_ED_DST);
			queue->AddItem(lpSrc,lpDst);
			delete lpSrc;
			delete lpDst;
			break;
		case IDC_BTN_REMOVE:
			queue->RemoveSelected();
			break;
		case IDC_BTN_PRUNE:
			queue->Prune();
			//CopyScreen(jobman->Handle());//GetItem(IDC_JOBS));
			break;
		case IDC_BTN_START:
			queue->StartSelected();
			break;
		case IDC_BTN_STOP:
			queue->StopSelected();
			break;
		case IDC_BTN_RANGE:
		case IDC_BTN_RANGE_DEL: 
		{
			Job::RANGE range = {0};
			if (wID == IDC_BTN_RANGE) {
				range.start =  jobman->SpinGetValue(IDC_SPIN_START);
				range.end =  jobman->SpinGetValue(IDC_SPIN_END);
			}
			queue->SelSetRange(range);
			break;
		}
		case IDC_BTN_SRC:
			BrowseForFile(IDC_ED_SRC, false);
			break;
		case IDC_BTN_DST:
			BrowseForFile(IDC_ED_DST, true);
			break;
		case IDC_BTN_ENUM:
			netman->Show(false);
			break;
		case ID_COMPLETED_OPEN:	
			if (job.Ready()) {
				LPTSTR text = StrDup(job.GetFileName(false));
				CloseHandle(CreateThread(NULL, 0, AsyncExec, text, 0 , NULL));
			}
			break;
		case IDC_ED_MAX_SPEED:
			MAX_SPEED = jobman->SpinGetValue(IDC_SPIN_MAX_SPEED)<<10;
			break;
		case IDC_ED_BAR_WIDTH:
			BAR = jobman->SpinGetValue(IDC_SPIN_BAR_WIDTH);
			break;
		case IDC_ED_HISTORY_LEN:
			HISTORY_LEN = jobman->SpinGetValue(IDC_SPIN_HISTORY_LEN);
			break;
		}
		return TRUE;
	}
	return FALSE;
}
/*
bool PrepareDirectory(LPTSTR lpDir)
{
	return true;
}
*/
LRESULT CALLBACK OnTextDrop(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	if (uMsg == WM_DROPFILES) {
		TCHAR lpText[MAX_PATH];
		if (DragQueryFile((HDROP)wParam, 0, lpText, sizeof(lpText)) > 0) {
			SetWindowText(hwnd, lpText);
		} else { // DragQuery failed...
		}
		DragFinish((HDROP)wParam);
		return TRUE; // no need to call old win proc.
	}
	return Dialog::CallOldWndProc(hwnd, uMsg, wParam, lParam);
}

LONG WINAPI MainExceptionFilter(PEXCEPTION_POINTERS info)
{
	if (ThreadGUI == GetCurrentThreadId()) {
		MessageBox(NULL, 
				TEXT("Unexpected error occured.\nCurrent state will be saved and the program will end"),
				TEXT("Exception in GUI"),
				MB_OKCANCEL | MB_ICONERROR);
		
		return EXCEPTION_CONTINUE_SEARCH;
	}
	
	int ret = MessageBox(NULL, 
						TEXT("Unhandled exception occured. Current thread will exit.\nPress Cancel if you want to debug"),
						TEXT("Exception"),
						MB_OKCANCEL | MB_ICONERROR);
	if (ret==IDOK) 	ExitThread(2);
	
	return EXCEPTION_CONTINUE_SEARCH;
}