/********************************************************************
*	Module:	winui.cpp. This is part of WinUI.
*
*	Purpose:	WinUI main module. Contains procedures relative to User Interface 
*			and general purpose procedures.
*
*	Authors:	Manu B.
*
*	License:	WinUI is covered by GNU General Public License, 
*			Copyright (C) 2001  Manu B.
*			See license.htm for more details.
*
*	Revisions:	
*			Manu B. 11/19/01	OpenDlg & SaveDlg enhancement.
*			Manu B. 12/07/01	CIniFile created.
*			Manu B. 12/15/01	CWinApp created.
*
********************************************************************/
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <commctrl.h>
#include <ctype.h>
#include "winui.h"

// Callback procedures.
LRESULT CALLBACK MainWndProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK ChildWndProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK DlgProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam);

// Declare a CMessageBox instance to use anywhere in the whole app.
CMessageBox	MsgBox;


/********************************************************************
*	Function:	char *StpCpy(char *dest, const char *src).
*
*	Purpose:	stpcpy clone.
*
*	Revisions:	
*
********************************************************************/
char *StpCpy(char *dest, const char *src){
	while (*src != '\0'){
		*dest = *src;
		src++;
		dest++;
	}
return dest;
}

size_t strcpylen(char *dest, const char *src){
	char * start = dest;
	while (*src != '\0'){
		*dest = *src;
		dest++;
		src++;
	}
	*dest = '\0';
return (dest-start);
}


/********************************************************************
*	Class:	CChrono.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CChrono::CChrono(){
	_time = 0;
}

CChrono::~CChrono(){
}

void CChrono::Start(void){
	_time = ::GetTickCount();
}

DWORD CChrono::Stop(void){
	DWORD diff = ::GetTickCount() - _time;
	_time = 0;
return diff;
}


/********************************************************************
*	Class:	Base Window class.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CWindow::CWindow(){
	_pParent		= NULL;
	_hInst 		= 0;
	_hWnd 		= 0;
	_lParam		= NULL;
}

CWindow::~CWindow(){
}

HWND CWindow::CreateEx(
				CWindow * pWindow, 
				DWORD dwExStyle, 
				LPCTSTR lpClassName, 
				LPCTSTR lpWindowName, 
				DWORD dwStyle, 
				int x, int y, int nWidth, int nHeight, 
				HMENU hMenu, 
				LPVOID lpParam){

	// Store a pointer to parent class and to lpParam.
	_pParent 	= pWindow;
	_lParam 	= lpParam;

	// Get parent class handles.
	HWND hParent;
	HINSTANCE hInst;

	if(_pParent){
		// Have a parent window.
		hParent 	= _pParent->_hWnd;
		hInst 	= _pParent->_hInst;
	}else{
		// Parent window is desktop.
		hParent = 0;
		hInst = GetModuleHandle(NULL);
	}

	_hWnd = CreateWindowEx(
		dwExStyle, 
		lpClassName, 
		lpWindowName, 
		dwStyle,
		x, 
		y, 
		nWidth, 
		nHeight, 
		hParent, 
		(HMENU) hMenu,
		hInst, 
		this); // Retrieve lpParam using this->_lParam.

return _hWnd;
}

HWND CWindow::GetId(void){
return _hWnd;
}

LONG CWindow::SetLong(int nIndex, LONG dwNewLong){
return ::SetWindowLong(_hWnd, nIndex, dwNewLong);
}

LONG CWindow::GetLong(int nIndex){
return ::GetWindowLong(_hWnd, nIndex);
}

LRESULT CWindow::SendMessage(UINT Msg, WPARAM wParam, LPARAM lParam){
return ::SendMessage(_hWnd, Msg, wParam, lParam);
}

bool CWindow::SetPosition(HWND hInsertAfter, int x, int y, int width, int height, UINT uFlags){
return ::SetWindowPos(_hWnd, hInsertAfter, x, y, width, height, uFlags);
}

bool CWindow::Show(int nCmdShow){
return ::ShowWindow(_hWnd, nCmdShow);
}

bool CWindow::Hide(void){
return ::ShowWindow(_hWnd, SW_HIDE);
}

HWND CWindow::SetFocus(void){
return ::SetFocus(_hWnd);
}

/********************************************************************
*	Class:	CWinBase.
*
*	Purpose:	Base Application class.
*
*	Revisions:	
*
********************************************************************/
CWinBase::CWinBase(){
	hPrevInst	= 0;
	lpCmdLine	= NULL;
	nCmdShow	= SW_SHOW;

	isWinNT 	= false;
	strcpy(	appName, 	"CWinBase");
}

CWinBase::~CWinBase(){
}

bool CWinBase::Init(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, 
												int nCmdShow){
	_hInst 	= hInstance;
	hPrevInst	= hPrevInstance;
	lpCmdLine	= lpCmdLine;
	nCmdShow	= nCmdShow;
return true;
}	

bool CWinBase::SetName(char * name, char * version){
	strcpy(appName, name);
	strcat(appName, " ");

	if(version)
		strcat(appName, version);
return true;
}	

bool CWinBase::IsWinNT(void){

	OSVERSIONINFO osv = {sizeof(OSVERSIONINFO), 0, 0, 0, 0, ""};
	GetVersionEx(&osv);

	isWinNT = (osv.dwPlatformId == VER_PLATFORM_WIN32_NT);
return isWinNT;
}	

void CWinBase::ParseCmdLine(char * outBuff){
	int len = 0;
	outBuff[len] = '\0';

	LPTSTR cmdLine = GetCommandLine();
	
	while (*cmdLine){
		if (*cmdLine == '\"'){
			cmdLine++;
			while (*cmdLine && *cmdLine != '\"'){
				outBuff[len] = *cmdLine;
				len++;
				cmdLine++;
			}
			break;
		}else{
			while (*cmdLine && *cmdLine != ' '){
				outBuff[len] = *cmdLine;
				len++;
				cmdLine++;
			}
			break;
		}
	}
	outBuff[len] = '\0';
	SplitFileName(outBuff, 0);
return;
}


/********************************************************************
*	Class:	CSDIBase.
*
*	Purpose:	Base SDI class.
*
*	Revisions:	
*
********************************************************************/
CSDIBase::CSDIBase(){
mainClass[0] 	= 0;
hAccel 		= NULL;
}

CSDIBase::~CSDIBase(){
}

int CSDIBase::Run(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, 
												int nCmdShow){
	Init(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
	if (!CustomInit()){
		Release();
		return 1;
	}

	MSG Msg;
	if (CreateUI()){
		while(GetMessage(&Msg, NULL, 0, 0)){
			if (!TranslateAccelerator(_hWnd, hAccel, &Msg)){
			 TranslateMessage(&Msg);
			 DispatchMessage(&Msg);
			}
		}
	}else{
		MsgBox.DisplayFatal("CreateUI() failed !");
	}

	Release();
return Msg.wParam;
}

bool CSDIBase::CustomInit(void){
return true;
}

bool CSDIBase::Release(void){
return true;
}

bool CSDIBase::CreateUI(void){
return false;
}

bool CSDIBase::MainRegisterEx(const char * className){
	strcpy(mainClass, className);

	// Default values.
	wc.cbSize			= sizeof(WNDCLASSEX);
	wc.lpfnWndProc		= MainWndProc;
	wc.hInstance		= _hInst;
	wc.lpszClassName	= mainClass;
	wc.cbClsExtra		= 0;
	wc.cbWndExtra		= sizeof(CSDIBase *);
return RegisterClassEx(&wc);
}

LRESULT CALLBACK CSDIBase::CMainWndProc(UINT Message, WPARAM wParam, LPARAM lParam){

	switch (Message){
		case WM_DESTROY:
		PostQuitMessage (0);
		return 0;
	}
	
return DefWindowProc(_hWnd, Message, wParam, lParam);
}

/********************************************************************
*	Callback procedure.
********************************************************************/
LRESULT CALLBACK MainWndProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam){
	// Get a pointer to the CWindow class that owns this window.
	CSDIBase * pSdiBase = (CSDIBase *) (GetWindowLong(hwnd, 0));

	if (pSdiBase == 0){	// The pointer isn't set yet.
		if (Message == WM_NCCREATE){
			// First, get the CSDIBase pointer.
			pSdiBase = (CSDIBase *) ((CREATESTRUCT *)lParam)->lpCreateParams;

			// Attach pSdiBase and lParam to the window.
			SetWindowLong(hwnd, 0, (LONG)(pSdiBase));
			SetWindowLong(hwnd, GWL_USERDATA, (LONG) pSdiBase->_lParam);

			// Store window handle.
			pSdiBase->_hWnd = hwnd;

			// Let Windows continue the job.
			return pSdiBase->CMainWndProc(Message, wParam, lParam);
		}else{
			return DefWindowProc(hwnd, Message, wParam, lParam);
		}
	}
return pSdiBase->CMainWndProc(Message, wParam, lParam);
}


/********************************************************************
*	Class:	CMDIBase.
*
*	Purpose:	Base MDI class.
*
*	Revisions:	
*
********************************************************************/
CMDIBase::CMDIBase(){
}

CMDIBase::~CMDIBase(){
}

bool CMDIBase::ChildRegisterEx(const char * className){
	strcpy(MdiClient.childClass, className);

	// Default values.
	wc.cbSize			= sizeof(WNDCLASSEX);
	wc.lpfnWndProc		= ChildWndProc;
	wc.hInstance		= _hInst;
	wc.lpszClassName	= className;
	wc.cbClsExtra		= 0;
	wc.cbWndExtra		= 8;//sizeof(CMDIBase *);
return RegisterClassEx(&wc);
}

int CMDIBase::Run(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, 
												int nCmdShow){
	Init(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
	if (!CustomInit()){
		Release();
		return 1;
	}

	MSG Msg;
	if (CreateUI()){
		while(GetMessage(&Msg, NULL, 0, 0)){
			if (!TranslateAccelerator(_hWnd, hAccel, &Msg)){
				if (!TranslateMDISysAccel(MdiClient.GetId(), &Msg)){
					 TranslateMessage(&Msg);
					 DispatchMessage(&Msg);
				}
			}
		}
	}else{
		MsgBox.DisplayFatal("CreateUI() failed !");
	}

	Release();
return Msg.wParam;
}

bool CMDIBase::CustomInit(void){
return true;
}

bool CMDIBase::Release(void){
return true;
}

bool CMDIBase::CreateUI(void){
return false;
}

LRESULT CALLBACK CMDIBase::CMainWndProc(UINT, WPARAM, LPARAM){
return 0;
}

LRESULT CALLBACK CMDIBase::CChildWndProc(CWindow *, UINT, WPARAM, LPARAM){
return 0;
}

/********************************************************************
*	Child window callback procedure.
********************************************************************/
LRESULT CALLBACK ChildWndProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam){
	// Get a pointer to the CWindow class that owns this window.
	CMDIChild * pMdiChild = (CMDIChild *) (GetWindowLong(hwnd, 0));

	if (pMdiChild == 0){	// The pointer isn't set yet.
		if (Message == WM_NCCREATE){
			// First, get the CMDIChild pointer.
			pMdiChild = (CMDIChild *) ((MDICREATESTRUCT *) ((CREATESTRUCT *)lParam)->lpCreateParams)->lParam;

			// Attach pMdiChild and lParam to the window.
			//MsgBox.DisplayLong((long) pMdiChild);

			SetWindowLong(hwnd, 0, (long)(pMdiChild));
			SetWindowLong(hwnd, GWL_USERDATA, (long) pMdiChild->_lParam);

			// Store window handle.
			pMdiChild->_hWnd = hwnd;

			// Attach to a childList so that the list can destroy all MdiChild objects.
			((CMDIClient *) pMdiChild->_pParent)->childList.InsertFirst(pMdiChild);

			// Let Windows continue the job.
			return pMdiChild->_pFrame->CChildWndProc(pMdiChild, Message, wParam, lParam);
		}else{
			return DefWindowProc(hwnd, Message, wParam, lParam);
		}

	// Free pMdiChild object.
	}else if (Message == WM_NCDESTROY){
		((CMDIClient *) pMdiChild->_pParent)->childList.Destroy(pMdiChild);
	}
return pMdiChild->_pFrame->CChildWndProc(pMdiChild, Message, wParam, lParam);
}


/********************************************************************
*	Class:	CMDIClient.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CMDIClient::CMDIClient(){
	initialized = false;
	childClass[0] = 0;
}

CMDIClient::~CMDIClient(){
}

void CMDIClient::Init(int menuIndex, UINT idFirstChild){
	nPos = menuIndex;

	// ID of first created child.
	ccs.idFirstChild = idFirstChild;
	initialized = true;
}

HWND CMDIClient::CreateEx(CWindow * pWindow, DWORD dwExStyle, DWORD dwStyle, UINT resId){

	if (!pWindow || !initialized)
		return 0;

	// Store a pointer to parent class.
	_pParent = pWindow;

	// Get parent class handles.
	_hInst = _pParent->_hInst;

	// Get our "Window menu" handle.
	ccs.hWindowMenu  = GetSubMenu(GetMenu(_pParent->_hWnd), nPos);

	_hWnd = CreateWindowEx(
		dwExStyle,
		"mdiclient", 
		NULL,
		dwStyle,
		0, 
		0, 
		100, 
		100, 
		_pParent->_hWnd,
		(HMENU) resId,
		_hInst, 
		(LPVOID) &ccs);
	
return _hWnd;
}

LPARAM CMDIClient::GetParam(LPARAM lParam){
	MDICREATESTRUCT *mcs = (MDICREATESTRUCT *) ((CREATESTRUCT *) lParam)->lpCreateParams;
return mcs->lParam;
}


/********************************************************************
*	Class:	CMDIChild.
*
*	Purpose:	Base Windows Class.
*
*	Revisions:	
*
********************************************************************/
CMDIChild::CMDIChild(){
	_pFrame = NULL;
}

CMDIChild::~CMDIChild(){
}

HWND CMDIChild::CreateEx(CMDIClient * pMdiClient, DWORD dwExStyle, DWORD dwStyle, char * caption, UINT resId, LPVOID lParam){

	if (!pMdiClient || !pMdiClient->initialized)
		return 0;

	// Store pointers, lParam and _hInst.
	_pParent = pMdiClient;
	_pFrame = (CMDIBase *) pMdiClient->_pParent; // Owner of CChildWndProc.
	_lParam = lParam;
	_hInst = _pParent->_hInst;

	HWND hwnd = CreateWindowEx(
				dwExStyle,
				pMdiClient->childClass,
				caption,
				dwStyle,
				0, 
				0, 
				100, 
				100, 
				_pParent->_hWnd, 
				(HMENU) resId,
				_hInst,
				this);
	
return hwnd;
}


/********************************************************************
*	Class:	CDlgBase.
*
*	Purpose:
*
*	Revisions:	
*
********************************************************************/
CDlgBase::CDlgBase(){
}

CDlgBase::~CDlgBase(){
}

HWND CDlgBase::Create(CWindow * pWindow, WORD wResId, RECT * Pos, LPARAM lParam){
	HWND hwnd = 0;
	if (pWindow){
		hwnd = CreateParam(pWindow, wResId, lParam);
		if (Pos)
			SetPosition(0, Pos->left, Pos->top, Pos->right, Pos->bottom, 0);
	}
return hwnd;
}

int CDlgBase::CreateModal(CWindow * pWindow, WORD wResId, LPARAM lParam){
	if (pWindow == NULL)
		return 0;

	// Don't create a modal dialog if a modeless one already exists.
	else if (_hWnd != 0)
		return 0;

	// Store a pointer to parent class.
	_pParent = pWindow;
	_lParam = (LPVOID) lParam;

	// Get parent class handles.
	_hInst = _pParent->_hInst;

return ::DialogBoxParam(_hInst, MAKEINTRESOURCE(wResId), _pParent->_hWnd,
				(DLGPROC) DlgProc, (long) this);
}

HWND CDlgBase::CreateParam(CWindow * pWindow, WORD wResId, LPARAM lParam){
	if (pWindow == NULL)
		return 0;
	// Don't create a dialog twice.
	else if (_hWnd != 0)
		return _hWnd;

	// Store a pointer to parent class.
	_pParent = pWindow;
	_lParam = (LPVOID) lParam;

	// Get parent class handles.
	_hInst = _pParent->_hInst;

	HWND hwnd = CreateDialogParam(_hInst,
	                                   MAKEINTRESOURCE(wResId),
	                                   _pParent->_hWnd,
	                                   (DLGPROC) DlgProc,
	                                   (long) this);
return hwnd;
}

BOOL CDlgBase::EndDlg(int nResult){
	if (_hWnd){
		BOOL result = ::EndDialog(_hWnd, nResult);
		_hWnd = 0;
		return result;
	}
return false;
}

HWND CDlgBase::GetItem(int nIDDlgItem){
return ::GetDlgItem(_hWnd, nIDDlgItem);
}

BOOL CDlgBase::SetItemText(HWND hItem, LPCTSTR lpString){
return ::SendMessage(hItem, WM_SETTEXT, 0, (long)lpString);
}

UINT CDlgBase::GetItemText(HWND hItem, LPTSTR lpString, int nMaxCount){
return ::SendMessage(hItem, WM_GETTEXT, nMaxCount, (long)lpString);
}

LRESULT CALLBACK CDlgBase::CDlgProc(UINT Message, WPARAM, LPARAM){

	switch(Message){
		case WM_INITDIALOG:
			return TRUE;
	
		case WM_CLOSE:
			EndDlg(0); 
			break;
	}
return FALSE;
}


/********************************************************************
*	Class:	CTabbedDlg.
*
*	Purpose:
*
*	Revisions:	
*
********************************************************************/
CTabbedDlg::CTabbedDlg(){
	_hWndTab = 0;
	Pos.left 	= 0;
	Pos.top 	= 0;
	Pos.right 	= 100;
	Pos.bottom	= 100;
}

CTabbedDlg::~CTabbedDlg(){
}

bool CTabbedDlg::SetChildPosition(HWND hChild){
	if (!_hWndTab)
		return false;
	// Get tab's display area.
	RECT area;
	::GetWindowRect(_hWndTab, &area);
	::ScreenToClient(_hWnd, (POINT *) &area.left);
	::ScreenToClient(_hWnd, (POINT *) &area.right);
	::SendMessage(_hWndTab, TCM_ADJUSTRECT, FALSE, (LPARAM) &area);
	::CopyRect(&Pos, &area);

	// Get child dialog's rect.
	RECT child;
	::GetWindowRect(hChild, &child);
	::ScreenToClient(_hWnd, (POINT *) &child.left);
	::ScreenToClient(_hWnd, (POINT *) &child.right);

	// Center child dialog.
	int childWidth = child.right-child.left;
	int childHeight = child.bottom-child.top;
	int hMargin = ((area.right-area.left)-childWidth)/2;
	int vMargin = ((area.bottom-area.top)-childHeight)/2;
	Pos.left += hMargin;
	Pos.top += vMargin;
	Pos.right = childWidth;
	Pos.bottom = childHeight;

return ::SetWindowPos(hChild, 0, Pos.left, Pos.top, Pos.right, Pos.bottom, 0);
}

void CTabbedDlg::OnNotify(int, LPNMHDR notify){
	// Dispatch tab control messages.
	switch (notify->code){
		case TCN_SELCHANGING:
			OnSelChanging(notify);
		break;

		case TCN_SELCHANGE:
			OnSelChange(notify);
		break;
	}
}

void CTabbedDlg::OnSelChanging(LPNMHDR notify){
	// Hide child dialog that is deselected.
	if (notify->hwndFrom == _hWndTab){
		CWindow * pPaneDlg = (CWindow *) GetParam();
		if (pPaneDlg){
			if (pPaneDlg->_hWnd)
				pPaneDlg->Hide();
		}
	}
}

void CTabbedDlg::OnSelChange(LPNMHDR notify){
	// Show child dialog that is selected.
	if (notify->hwndFrom == _hWndTab){
		CWindow * pPaneDlg = (CWindow *) GetParam();
		if (pPaneDlg){
			if (pPaneDlg->_hWnd)
				pPaneDlg->Show();
				pPaneDlg->SetFocus();
		}
	}
}

LPARAM CTabbedDlg::GetParam(void){
	if (!_hWndTab)
		return false;
	int iItem = ::SendMessage(_hWndTab, TCM_GETCURSEL, 0, 0);

	tcitem.mask = TCIF_PARAM;
	BOOL result = ::SendMessage(_hWndTab, TCM_GETITEM, iItem, (long) &tcitem);
	if (result)
		return tcitem.lParam;
return 0;
}


/********************************************************************
*	Callback procedure.
********************************************************************/
LRESULT CALLBACK DlgProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam){
	// Get a pointer to the CWindow class that owns this window.
	CDlgBase * pDlgBase = (CDlgBase *) (GetWindowLong(hwnd, DWL_USER));

	if (pDlgBase == 0){	// The pointer isn't set yet.
		if (Message == WM_INITDIALOG){
			// First, get the CDlgBase pointer.
			pDlgBase = (CDlgBase *) lParam;

			// Attach pDlgBase and lParam to the window.
			SetWindowLong(hwnd, DWL_USER, (LONG) pDlgBase);
			SetWindowLong(hwnd, GWL_USERDATA, (LONG) pDlgBase->_lParam);

			// Store window handle.
			pDlgBase->_hWnd = hwnd;

			// Let Windows continue the job.
			return pDlgBase->CDlgProc(Message, wParam, (LONG) pDlgBase->_lParam);
		}else{
			return FALSE;
		}
	}
return pDlgBase->CDlgProc(Message, wParam, lParam);
}


/********************************************************************
*	Class:	CToolBar.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CToolBar::CToolBar(){
}

CToolBar::~CToolBar(){
}

HWND CToolBar::CreateEx(CWindow * pWindow, DWORD dwExStyle, DWORD dwStyle, UINT resId){

	if (!pWindow)
		return 0;

	// Store a pointer to parent class.
	_pParent = pWindow;

	// Get parent class handles.
	_hInst = _pParent->_hInst;

	_hWnd = CreateWindowEx(
		dwExStyle, 
		TOOLBARCLASSNAME, 
		NULL, 
		dwStyle,
		0, 
		0, 
		100, 
		100, 
		_pParent->_hWnd, 
		(HMENU) resId,
		_hInst, 
		NULL); 

	if(_hWnd)
	// For backward compatibility. 
		::SendMessage(_hWnd, TB_BUTTONSTRUCTSIZE, (WPARAM) sizeof(TBBUTTON), 0); 
return _hWnd; 
} 
 
LRESULT CToolBar::AddBitmap(UINT resId, int nBmp, HINSTANCE hInstance){
	if (!_hWnd)
		return -1;

	// Add the bitmap containing button images to the toolbar. 
	TBADDBITMAP tbab; 
	if (hInstance == HINST_COMMCTRL)
		tbab.hInst	= hInstance; 
	else
		tbab.hInst	= _hInst; 
	tbab.nID	= resId;
return ::SendMessage(_hWnd, TB_ADDBITMAP, (WPARAM) nBmp, (WPARAM) &tbab); 
}

BOOL CToolBar::AddButtons(TBBUTTON * tbButtons, UINT numButtons){
	if (!_hWnd)
		return FALSE;

	// Add the buttons to the toolbar. 
return ::SendMessage(_hWnd, TB_ADDBUTTONS, (WPARAM) numButtons, (LPARAM) tbButtons); 
}


/********************************************************************
*	Class:	CStatusBar.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CStatusBar::CStatusBar(){
	numParts = 0;
}

CStatusBar::~CStatusBar(){
}

HWND CStatusBar::CreateEx(CWindow * pWindow, DWORD dwExStyle, DWORD dwStyle, UINT resId){

	if (!pWindow)
		return 0;

	// Store a pointer to parent class.
	_pParent = pWindow;

	// Get parent class handles.
	_hInst = _pParent->_hInst;

	_hWnd = CreateWindowEx(
		dwExStyle,
		STATUSCLASSNAME, 
		NULL,
		dwStyle,
		0, 
		0, 
		100, 
		100, 
		_pParent->_hWnd,
		(HMENU) resId,
		_hInst,
		NULL);

return _hWnd;
}

void CStatusBar::SetParts(int nParts, int * aWidths){
	numParts = nParts;
	::SendMessage(_hWnd, SB_SETPARTS, nParts, (LPARAM) aWidths);
}

void CStatusBar::WriteString(char * string, int part){
	if (part <= numParts)
		::SendMessage(_hWnd, SB_SETTEXT, part, (LPARAM) string);
}

void CStatusBar::WriteLong(long number, int part){
	char longbuf[10];
	itoa (number, longbuf, 10);
	WriteString(longbuf, part);
}


/********************************************************************
*	Class:	CTabCtrl.
*
*	Purpose:	Tab control.
*
*	Revisions:	
*
********************************************************************/
CTabCtrl::CTabCtrl(){
}

CTabCtrl::~CTabCtrl(){
}

HWND CTabCtrl::CreateEx(CWindow * pWindow, DWORD dwExStyle, DWORD dwStyle, UINT resId, LPVOID lpParam){

	if (!pWindow)
		return 0;

	// TODO also use lpParam for each control ?
	// Store a pointer to parent class and to lpParam.
	_pParent 	= pWindow;
	_lParam 	= lpParam;

	// Get parent class handles.
	_hInst = _pParent->_hInst;

	_hWnd = CreateWindowEx(
		dwExStyle,
		WC_TABCONTROL, 
		NULL,
		dwStyle,
		0, 
		0, 
		100, 
		100, 
		_pParent->_hWnd,
		(HMENU) resId,
		_hInst,
		lpParam);

return _hWnd;
}

int CTabCtrl::InsertItem(int iItem, UINT mask, DWORD dwState, DWORD dwStateMask, 
				LPTSTR pszText, int cchTextMax, int iImage, LPARAM lParam){

	tcitem.mask 			= mask;

		#if (_WIN32_IE >= 0x0300)
		tcitem.dwState 		= dwState;
		tcitem.dwStateMask 	= dwStateMask;
		#else
		tcitem.lpReserved1 = 0;
		tcitem.lpReserved2 = 0;
		#endif

	tcitem.pszText 			= pszText;
	tcitem.cchTextMax 		= cchTextMax;
	tcitem.iImage 			= iImage;
	tcitem.lParam 			= lParam;

return ::SendMessage(_hWnd, TCM_INSERTITEM, iItem, (long) &tcitem);
}

BOOL CTabCtrl::SetItem_Param(int iItem, LPARAM lParam){

	tcitem.mask = TCIF_PARAM;
	tcitem.lParam = lParam;

return ::SendMessage(_hWnd, TCM_SETITEM, iItem, (long) &tcitem);
}

int CTabCtrl::GetCurSel(void){

return ::SendMessage(_hWnd, TCM_GETCURSEL, 0, 0);
}

LPARAM CTabCtrl::GetItem_Param(int iItem){

	tcitem.mask = TCIF_PARAM;
	BOOL result = ::SendMessage(_hWnd, TCM_GETITEM, iItem, (long) &tcitem);
	if (result)
		return tcitem.lParam;
return 0;
}


/********************************************************************
*	Class:	CTreeView.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CTreeView::CTreeView(){
}

CTreeView::~CTreeView(){
}

HWND CTreeView::CreateEx(CWindow * pWindow, DWORD dwExStyle, DWORD dwStyle, UINT resId, LPVOID lpParam){

	if (!pWindow)
		return 0;

	// Store a pointer to parent class.
	_pParent = pWindow;

	// Get parent class handles.
	_hInst = _pParent->_hInst;

	_hWnd = CreateWindowEx(
		dwExStyle,
		WC_TREEVIEW, 
		NULL,
		dwStyle,
		0, 
		0, 
		100, 
		100, 
		_pParent->_hWnd,
		(HMENU) resId,
		_hInst,
		lpParam);

return _hWnd;
}

HTREEITEM CTreeView::CreateItem(HTREEITEM hParent, HTREEITEM hInsertAfter, int iImage, LPTSTR pszText, LPARAM lParam){

	tvi.hParent			= hParent; 
	tvi.hInsertAfter		= hInsertAfter;

	tvi.item.mask		= TVIF_STATE | TVIF_TEXT | TVIF_IMAGE
					| TVIF_SELECTEDIMAGE | TVIF_PARAM ;
	tvi.item.stateMask 	= TVIS_EXPANDED;
	tvi.item.state 		= TVIS_EXPANDED;
	tvi.item.pszText		= pszText; 
	tvi.item.iImage		= iImage; 
	tvi.item.iSelectedImage	= iImage; 
	tvi.item.lParam		= (LPARAM) lParam; 

return (HTREEITEM) ::SendMessage(_hWnd, TVM_INSERTITEM, 0, (LPARAM)&tvi);
}

LPARAM CTreeView::GetSelectedItemParam(void){
	_TvItem.hItem  = TreeView_GetSelection(_hWnd);
	_TvItem.mask   = TVIF_PARAM;
	_TvItem.lParam = 0; 
	TreeView_GetItem(_hWnd, (long) &_TvItem); 
return _TvItem.lParam;
}

/********************************************************************
*	Class:	CListView.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CListView::CListView(){
	lastRow = 0;
}

CListView::~CListView(){
}

HWND CListView::CreateEx(CWindow * pWindow, DWORD dwExStyle, DWORD dwStyle, UINT resId){

	if (!pWindow)
		return 0;

	// Store a pointer to parent class.
	_pParent = pWindow;

	// Get parent class handles.
	_hInst = _pParent->_hInst;

	_hWnd = CreateWindowEx(
		dwExStyle, 
		WC_LISTVIEW, 
		NULL, 
		dwStyle,
		0, 
		0, 
		100, 
		100, 
		_pParent->_hWnd, 
		(HMENU) resId,
		_hInst, 
		NULL);

return _hWnd;
}

void CListView::Clear(void){
	// Win9x ListView clear is too slow.
	int numitems = ::SendMessage(_hWnd, LVM_GETITEMCOUNT, 0, 0);
	for (int n = 0; n < numitems; n++){
		::SendMessage(_hWnd, LVM_DELETEITEM, (WPARAM) 0, 0);
	}
	lastRow = 0;
}


/********************************************************************
*	Class:	CScintilla.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CScintilla::CScintilla(){
}

CScintilla::~CScintilla(){
}

HWND CScintilla::CreateEx(CWindow * pWindow, DWORD dwExStyle, DWORD dwStyle, UINT resId, LPVOID lpParam){

	if (!pWindow)
		return 0;

	// Store a pointer to parent class.
	_pParent = pWindow;

	// Get parent class handles.
	_hInst = _pParent->_hInst;

	_hWnd = CreateWindowEx(
		dwExStyle,
		"Scintilla", 
		NULL,
		dwStyle,
		0, 
		0, 
		100, 
		100, 
		_pParent->_hWnd,
		(HMENU) resId,
		_hInst,
		lpParam);

return _hWnd;
}


/********************************************************************
*	Class:	CSplitter.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CSplitter::CSplitter(){
	Pane1 	= NULL;
	Pane2 	= NULL;
	size		= 4;
	p		= 0;
	isActive	= false;
	initialized	= false;
}

CSplitter::~CSplitter(){
}

void CSplitter::Init(CWindow * pane1, CWindow * pane2, bool vertical, 
				int barPos, int barMode){
	Pane1 = pane1;
	Pane2 = pane2;

	if(Pane1 && Pane2)
		initialized = true;

	isVertical = vertical;

	p = barPos;
	mode = barMode;
}

bool CSplitter::Show(int){
return false;
}

bool CSplitter::Hide(void){
return false;
}

bool CSplitter::SetPosition(HWND, int x, int y, int width, int height, UINT){
	pos.left	= x; 
	pos.top	= y; 
	pos.right	= width; 
	pos.bottom = height; 

	if(isVertical)
		SetVertPosition();
	else
		SetHorzPosition();
return true;
}

void CSplitter::SetVertPosition(void){
	psize			= p+size;

	barPos.left		= pos.left+p; 
	barPos.top		= pos.top; 
	barPos.right	= size; 
	barPos.bottom 	= pos.bottom;

	Pane1->SetPosition(0,	
		pos.left,
		pos.top,
					p,
		pos.bottom,
		0);

	Pane2->SetPosition(0,
		pos.left		+psize,
		pos.top, 
		pos.right	-psize,
		pos.bottom,
		0);
}

void CSplitter::SetHorzPosition(void){
	psize			= p+size;

	barPos.left		= pos.left; 
	barPos.top		= pos.top+pos.bottom-psize; 
	barPos.right	= pos.right; 
	barPos.bottom 	= size;

	Pane1->SetPosition(0,
		pos.left,
		pos.top,
		pos.right,
		pos.bottom	-psize,
		0);

	Pane2->SetPosition(0,
		pos.left,
		pos.top		+pos.bottom-p, 
		pos.right,
					p,
		0);
}

bool CSplitter::HaveMouse(HWND hwnd, short, short){
	POINT ptCursor;
	::GetCursorPos(&ptCursor);
	POINT ptClient = ptCursor;
	::ScreenToClient(hwnd, &ptClient);

	if (	ptClient.x >= barPos.left 
		&& ptClient.x <= barPos.left+barPos.right
		&& ptClient.y >= barPos.top
		&& ptClient.y <= barPos.top+barPos.bottom){
	return true;
	}
return false;
}

bool CSplitter::OnSetCursor(HWND hwnd, LPARAM){
	if(HaveMouse(hwnd, 0, 0)){
		if (isVertical){
			::SetCursor(::LoadCursor(NULL, IDC_SIZEWE));
			return true;
		}else{
			::SetCursor(::LoadCursor(NULL, IDC_SIZENS));
			return true;
		}
	}
return false;
}

bool CSplitter::OnLButtonDown(HWND hwnd, short xPos, short yPos){
	if (HaveMouse(hwnd, 0, 0)){
		// Begin of mouse capture.
		isActive = true;
		::SetCapture(hwnd);

		// Save initial mouse position.
		initialPos.x = xPos;
		initialPos.y = yPos;

		// Converts bar position for Xor bar.
		POINT xorPos;
		RECT rect;
		xorPos.x = barPos.left;
		xorPos.y = barPos.top;
	
		ClientToWindow(hwnd, &xorPos, &rect);

		// Draw the Xor bar.
		HDC hdc;
		hdc = GetWindowDC(hwnd);
		DrawXorBar(hdc, xorPos.x, xorPos.y, barPos.right, barPos.bottom);

		// Save initial position for future erasing.
		initialXorPos.x = xorPos.x;
		initialXorPos.y = xorPos.y;

		ReleaseDC(hwnd, hdc);
	}
return isActive;
}

void CSplitter::OnLButtonUp(HWND hwnd, short xPos, short yPos){
	if (isActive) {
	
		// Erase the Xor bar *********************
		HDC hdc;
		hdc = GetWindowDC(hwnd);
		DrawXorBar(hdc, initialXorPos.x, initialXorPos.y, barPos.right, barPos.bottom);
		ReleaseDC(hwnd, hdc);

		// Move Splitter to new position *******************
		newPos.x = xPos;
		newPos.y = yPos;

		if(isVertical)
			deltaPos = newPos.x - initialPos.x;
		else
			deltaPos = newPos.y - initialPos.y;/**/

		if (deltaPos != 0)
			Move(barPos.left + deltaPos, barPos.top + deltaPos);

		// End of capture.
		::ReleaseCapture();
		isActive = false;
	}
}

void CSplitter::OnMouseMove(HWND hwnd, short xPos, short yPos){
	if (isActive) {
		newPos.x = xPos;
		newPos.y = yPos;
	
		// Draw the Xor bar *********************
		POINT xorPos;
		RECT rect;

		if(isVertical){
			deltaPos = newPos.x - initialPos.x;
			xorPos.x = barPos.left + deltaPos;
			xorPos.y = barPos.top;

			// Convert coordinates.
			ClientToWindow(hwnd, &xorPos, &rect);
		
			// Convert rect.
			OffsetRect(&rect, -rect.left, -rect.top);
		
			if(xorPos.x < 20) 
				xorPos.x = 20;
			if(xorPos.x > rect.right-24) 
				xorPos.x = rect.right-24;
		}else{
			deltaPos = newPos.y - initialPos.y;
			xorPos.x = barPos.left;
			xorPos.y = barPos.top + deltaPos;

			// Convert coordinates.
			ClientToWindow(hwnd, &xorPos, &rect);
		
			// Convert rect.
			OffsetRect(&rect, -rect.left, -rect.top);
	
			if(xorPos.y < 20) 
				xorPos.y = 20;
			if(xorPos.y > rect.bottom-24) 
				xorPos.y = rect.bottom-24;
		}

		HDC hdc;
		hdc = GetWindowDC(hwnd);
		DrawXorBar(hdc, initialXorPos.x, initialXorPos.y, barPos.right, barPos.bottom);
		DrawXorBar(hdc, xorPos.x, xorPos.y, barPos.right, barPos.bottom);
		initialXorPos.x = xorPos.x;
		initialXorPos.y = xorPos.y;
		ReleaseDC(hwnd, hdc);
	}
}

void CSplitter::Move(int mouseX, int mouseY){

	if(isVertical){
		p = mouseX;
		SetVertPosition();
	}else{
		p = pos.bottom - size - mouseY+pos.top;
		SetHorzPosition();
	}
}

void CSplitter::ClientToWindow(HWND hwnd, POINT * pt, RECT * rect){
	// Bar position.
	ClientToScreen(hwnd, pt);
	// Window rect.
	GetWindowRect(hwnd, rect);

	// Convert the bar coordinates relative to the top-left of the window.
	pt->x -= rect->left;
	pt->y -= rect->top;
}

void CSplitter::DrawXorBar(HDC hdc, int x1, int y1, int width, int height){
	static WORD _dotPatternBmp[8] = 
	{ 
		0x00aa, 0x0055, 0x00aa, 0x0055, 
		0x00aa, 0x0055, 0x00aa, 0x0055
	};

	HBITMAP hbm;
	HBRUSH  hbr, hbrushOld;

	hbm = CreateBitmap(8, 8, 1, 1, _dotPatternBmp);
	hbr = CreatePatternBrush(hbm);
	
	SetBrushOrgEx(hdc, x1, y1, 0);
	hbrushOld = (HBRUSH)SelectObject(hdc, hbr);
	
	PatBlt(hdc, x1, y1, width, height, PATINVERT);
	
	SelectObject(hdc, hbrushOld);
	
	DeleteObject(hbr);
	DeleteObject(hbm);
}


/********************************************************************
*	Class:	CBitmap.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CBitmap::CBitmap(){
	hBitmap = NULL;
}

CBitmap::~CBitmap(){
	if (hBitmap)
		DeleteObject(hBitmap);
}

HBITMAP CBitmap::Load(CWindow * pWindow, LPCTSTR lpBitmapName){
	if (!hBitmap)	// Don't create twice.
		hBitmap = ::LoadBitmap(pWindow->_hInst, lpBitmapName);	
return hBitmap;
}

HBITMAP CBitmap::Load(CWindow * pWindow, WORD wResId){
	if (!hBitmap)	//Don't create twice.
		hBitmap = ::LoadBitmap(pWindow->_hInst, MAKEINTRESOURCE(wResId));	
return hBitmap;
}

BOOL CBitmap::Destroy(void){
	BOOL result = false;
	if (hBitmap)
		result = DeleteObject(hBitmap);
return result;
}


/********************************************************************
*	Class:	CImageList.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CImageList::CImageList(){
	hImgList = NULL;
}

CImageList::~CImageList(){
	if (hImgList)
		ImageList_Destroy(hImgList);
}

HIMAGELIST CImageList::Create(int cx, int cy, UINT flags, int cInitial, int cGrow){
	if (!hImgList)	// Don't create twice.
		hImgList = ::ImageList_Create(cx, cy, flags, cInitial, cGrow);	
return hImgList;
}

int CImageList::AddMasked(CBitmap * pBitmap, COLORREF crMask){
return ImageList_AddMasked(hImgList, pBitmap->hBitmap, crMask);
}


/********************************************************************
*	Class:	CMessageBox.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CMessageBox::CMessageBox(){
	hParent = 0;
	strcpy(caption, "CMessageBox");
}

CMessageBox::~CMessageBox(){
}

void CMessageBox::SetParent(HWND hwnd){
	hParent = hwnd;
}

void CMessageBox::SetCaption(char * string){
	strcpy(caption, string);
}

void CMessageBox::DisplayString(char * string, char * substring, UINT uType){
	if(!substring){
		MessageBox (hParent, string, caption, uType);
	}else{
		sprintf(msgBuf, string, substring);
		MessageBox (hParent, msgBuf, caption, uType);
	}
}

void CMessageBox::DisplayFatal(char * string, char * substring){
	DisplayString(string, substring, MB_OK | MB_ICONERROR);
}

void CMessageBox::DisplayWarning(char * string, char * substring){
	DisplayString(string, substring, MB_OK | MB_ICONWARNING);
}

void CMessageBox::DisplayLong(long number){
	char longbuf[10];
	itoa (number, longbuf, 10);
	DisplayString(longbuf);
}

void CMessageBox::DisplayRect(RECT * rect){
	if (!rect)
		return;
	sprintf(msgBuf, "left: %ld top: %ld right: %ld bottom: %ld", rect->left, rect->top, rect->right, rect->bottom);
	MessageBox (hParent, msgBuf, caption, MB_OK);
}

int CMessageBox::Ask(char * question, bool canCancel){

	if (canCancel){
		// Cancel button.
		return MessageBox(hParent, question, caption, MB_YESNOCANCEL | MB_ICONWARNING);
	}else{
		// No cancel.
		return MessageBox(hParent, question, caption, MB_YESNO | MB_ICONWARNING);
	}
}

int CMessageBox::AskToSave(bool canCancel){

	char question[] = "Save changes ?";

	if (canCancel){
		// Cancel button.
		return Ask(question, true);
	}else{
		// No cancel.
		return Ask(question, false);
	}
}


/********************************************************************
*	Class:	CFileDlgBase.
*
*	Purpose:	Open/Save Dlg.
*
*	Revisions:	
*
********************************************************************/
CFileDlgBase::CFileDlgBase(){
	ofn.lStructSize = sizeof(OPENFILENAME);	// DWORD
	Reset();
}

CFileDlgBase::~CFileDlgBase(){
}

void CFileDlgBase::Reset(void){
	// Set methods.
	ofn.lpstrTitle 		= 0;					// LPCTSTR
	ofn.nFilterIndex 		= 0;					// DWORD
	ofn.lpstrFilter 		= 0;					// LPCTSTR
	ofn.lpstrDefExt 		= 0;					// LPCTSTR
	ofn.Flags 			= 0;					// DWORD

	ofn.lpstrInitialDir 		= 0;					// LPCTSTR

	// Get methods.
	nNextFileOffset		= 0;
	ofn.nFileOffset 		= 0;					// WORD
	ofn.nFileExtension 	= 0;					// WORD

	// Unused.
	ofn.hInstance 		= 0;					// HINSTANCE
	ofn.lpstrCustomFilter 	= 0;					// LPTSTR
	ofn.nMaxCustFilter 	= 0;					// DWORD
	ofn.lpstrFileTitle 		= 0;					// LPTSTR
	ofn.nMaxFileTitle 		= 0;					// DWORD
	ofn.lCustData 		= 0;					// DWORD
	ofn.lpfnHook 		= 0;					// LPOFNHOOKPROC
	ofn.lpTemplateName	= 0;					// LPCTSTR
}

void CFileDlgBase::SetData(char * filter, char * defExt, DWORD flags){
	SetFilter(filter);
	SetDefExt(defExt);
	SetFlags(flags);
}

void CFileDlgBase::SetTitle(char * title){
	ofn.lpstrTitle = title;
}

void CFileDlgBase::SetFilterIndex(DWORD filterIndex){
	ofn.nFilterIndex	= filterIndex;
}

void CFileDlgBase::SetFilter(char * filter){
	ofn.lpstrFilter = filter;
}

void CFileDlgBase::SetDefExt(char * defExt){
	ofn.lpstrDefExt = defExt;
}

void CFileDlgBase::SetFlags(DWORD flags){
	ofn.Flags = flags;
}

void CFileDlgBase::SetInitialDir(char * lpstrInitialDir){
	ofn.lpstrInitialDir = lpstrInitialDir;
}

WORD CFileDlgBase::GetFileOffset(void){
return ofn.nFileOffset;
}

WORD CFileDlgBase::GetFileExtension(void){
return ofn.nFileExtension;
}

WORD CFileDlgBase::GetNextFileOffset(void){
	// Analyses a "path\0file1\0file2\0file[...]\0\0" string returned by Open/SaveDlg.
	char * srcFiles = ofn.lpstrFile;
	if (srcFiles){
		if ((ofn.Flags & OFN_ALLOWMULTISELECT) == OFN_ALLOWMULTISELECT){
			// Initialize first call.
			if (!nNextFileOffset)
				nNextFileOffset = ofn.nFileOffset;
			// Parse the string.
			while (srcFiles[nNextFileOffset] != '\0')
				nNextFileOffset++;
			// Get next char.
			nNextFileOffset++;
			// End of string ?
			if (srcFiles[nNextFileOffset] == '\0')
				nNextFileOffset = 0;
			return nNextFileOffset;
		}
	}
return 0;
}

bool CFileDlgBase::OpenFileName(CWindow * pWindow, char * pszFileName, DWORD nMaxFile){
	if (!pWindow)
		return false;

	ofn.hwndOwner 		= pWindow->_hWnd;		// HWND
	ofn.lpstrFile 		= pszFileName;			// LPTSTR
	ofn.nMaxFile 		= nMaxFile;				// DWORD

return ::GetOpenFileName(&ofn);
}

bool CFileDlgBase::SaveFileName(CWindow * pWindow, char * pszFileName, DWORD nMaxFile){
	if (!pWindow)
		return false;
	pszFileName[0] = '\0';
	ofn.hwndOwner 		= pWindow->_hWnd;		// HWND
	ofn.lpstrFile 		= pszFileName;			// LPTSTR
	ofn.nMaxFile 		= nMaxFile;				// DWORD

return ::GetSaveFileName(&ofn);
}


/********************************************************************
*	Class:	CPath.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CPath::CPath(){
}

CPath::~CPath(){
}

bool CPath::ChangeDirectory(char * dir){
	return SetCurrentDirectory(dir);
}


/********************************************************************
*	Paths.
********************************************************************/
void SplitFileName(char * dirName, char * fileName){
	int n;
	int len = strlen (dirName);

	for (n = len; n > 2; n--){
		if (dirName[n] == '\\' ){
			if (fileName)
				strcpy (fileName, &dirName[n+1]);
			dirName[n+1] = 0;
			break;
		}
	}
}

bool ChangeFileExt(char * fileName, char * ext){
	int len = strlen(fileName);
	for (int n=len; n > 0; n--){
		if (fileName[n] == '.'){
			fileName[n+1] = 0;
			strcat(fileName, ext);
			return true;
		}
	}
return false;	// No file extension.
}


/********************************************************************
*	Class:	CIniFile.
*
*	Purpose:	"GetPrivateProfileString()" like procedure.
*
*	Revisions:	
*
********************************************************************/
CIniFile::CIniFile(){
	buffer	= NULL;
	pcurrent 	= NULL;
	psection 	= NULL;
}

CIniFile::~CIniFile(){
	Close();
}

void CIniFile::Close(void){
	if (buffer)
		free(buffer);
	buffer	= NULL;
	pcurrent 	= NULL;
	psection 	= NULL;
}

bool CIniFile::Load(char * fullPath){
	if (buffer)
		Close();

	FILE * file;

	/* FIXME: 	ZeroMemory because open/close projects can cause
			GetString to found data from previous projects. */
//	ZeroMemory(buffer, MAX_BLOC_SIZE);

	file = fopen(fullPath, "rb");
	if (file){
		buffer = (char *) malloc(MAX_BLOC_SIZE);
		if (!buffer)
			return false;
		fread(buffer, 1, MAX_BLOC_SIZE, file);
		if (0 != fread(buffer, 1, sizeof(buffer), file)){
			MsgBox.DisplayString("CIniFile ERROR: OVERFOW");
			fclose(file);
			Close();
			return false;
		}
		fclose(file);

		// Initialize current pointer.
		pcurrent = buffer;
		return true;
	}
return false;
}

int CIniFile::GetInt(char * key, char * section){

	char integer[32];

	if (GetString(integer, key, section)){
		return atoi(integer);
	}

return 0;
}

//******************************************************
//	Reminder :
//	GetPrivateProfileString("Section", "Key", "default_string", data, size, iniFilePath);
//******************************************************
bool CIniFile::GetString(char * data, char * key, char * section){
	/* Copies data and returns true if successfull */
	char *pstop;
	if (section){
		/* Parse from pcurrent until the end of buffer */
		pstop = pcurrent;
		for ( ; ; ){
			if (*pcurrent == '\0'){
				/* Parse again from beginning to pstop */
				pcurrent = buffer;
				for ( ; ; ){
					if (FindSection(pcurrent, section))
						break; // Found !
					if (pcurrent >= pstop)
						return false; // Not found !
				}
			}
			if (FindSection(pcurrent, section))
				break; // Found !
		}
	}

	if (psection){
		/* Section Found */
		pstop = pcurrent;
		//MsgBox.DisplayString(pcurrent);
		for ( ; ; ){
			if (*pcurrent == '\0' || *pcurrent == '['){
				/* Parse again from beginning to pstop */
				pcurrent = psection;
				for ( ; ; ){
					if (FindData(pcurrent, key, data))
						break; // Found !
					if (pcurrent >= pstop)
						return false; // Not found !
				}
			}
			if (FindData(pcurrent, key, data))
				break; // Found !
		}
	}
	//MsgBox.DisplayString(pcurrent);
return true;
}

bool CIniFile::FindSection(char * s, char * section){
	/* Search the section through one line of text */
	/* Returns true if successful, false otherwise */
	/* This procedure increments current pointer to the end of line */

	if (!section)
		return false;

	bool sectionFound = false;
	psection = NULL;

	/* Skip spaces and comments */
	s = SkipUnwanted(s);

	/* End of buffer ? */
	if (*s == '\0'){
		pcurrent = s;
		return false;

	/* A section ? */
	}else if (*s == '['){
		s++;
		if (*s == '\0'){
			pcurrent = s;
			return false;
		}

		/* Parse the section name */
		int len = strlen(section);
		if (!strncmp(s, section, len)){
			s+=len;
			if (*s == ']'){
				/* Section found ! */
				sectionFound = true;
			}
		}
	}

	/* Increment current pointer until the end of current line */
	while (*s != '\0' && *s != '\n')
		s++;
	pcurrent = s;

	if (sectionFound)
		psection = pcurrent;
return sectionFound;
}

bool CIniFile::FindData(char * s, char * key, char * data){
	/* Search the key through one line of text */
	/* Returns true if successful, false otherwise */
	/* This procedure increments current pointer to the end of line */

	bool keyFound = false;
	/* Skip spaces and comments */
	s = SkipUnwanted(s);

	/* End of buffer ? End of section ? */
	if (*s == '\0' || *s == '['){
		pcurrent = s;
		return false;

	/* Search the key */
	}else{
		int len = strlen(key);
		/* Compare key and s */
		if (!strncmp(s, key, len)){
			s+=len;
			/* Search an '=' sign */
			while (isspace(*s)){
				if (*s == '\n')
					break;
				s++;
			}

			if (*s == '='){
				/* Key found ! */
				keyFound = true;
				s++;
				while (isspace(*s)){
					if (*s == '\n')
						break;
					s++;
				}

				/* Copy data ! */
				s += CopyData(data, s);
			}
		}
	}

	/* Increment current pointer until the end of current line */
	while (*s != '\0' && *s != '\n')
		s++;
	pcurrent = s;
return keyFound;
}

long CIniFile::CopyData(char * data, char * s){
/* Returns the number of characters copied not including the terminating null char */
	char *pdata = data;
	while (*s != '\0' && *s != '\r' && *s != '\n'){
		*pdata = *s;
		pdata++;
		s++;

		/* @@ Overflow @@
		n++;
		if (n == n_max){
			*data = '\0';
			return 
		}*/
	}
	*pdata = '\0';
return (pdata-data);
}

char * CIniFile::SkipUnwanted(char *s){
	for ( ; ; ){		
		/* End of buffer ? */
		if (*s == '\0')
			return s;
		if (isspace(*s)){
			/* Skip spaces */
			s++;
		}else if (*s == ';'){
			/* Skip comments */
			char * end_of_line = strchr(s, '\n');
			if (end_of_line){
				/* End of comment */
				s = end_of_line+1;
				continue;
			}else{
				/* End of buffer */
				return end_of_line;
			}
		/* Done */
		}else{
			return s;
		}
	}
}


/********************************************************************
*	Class:	CShellDlg.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CShellDlg::CShellDlg(){
	// Get shell task allocator.
	if(SHGetMalloc(&pMalloc) == (HRESULT) E_FAIL)
		pMalloc = NULL;
}

CShellDlg::~CShellDlg(){
	// Decrements the reference count.
	if (pMalloc)
		pMalloc->Release();
}

bool CShellDlg::BrowseForFolder(CWindow * pWindow, LPSTR pszDisplayName, 
		LPCSTR lpszTitle, UINT ulFlags, BFFCALLBACK lpfn, LPARAM lParam, int iImage){

	// Initialize output buffer.
	*pszDisplayName = '\0';
	// BROWSEINFO.
	if (!pWindow)
		bi.hwndOwner = 0;
	else
		bi.hwndOwner = pWindow->_hWnd;
	bi.pidlRoot = NULL;
	bi.pszDisplayName = pszDisplayName;
	bi.lpszTitle = lpszTitle;
	bi.ulFlags = ulFlags;
	bi.lpfn = lpfn;
	bi.lParam = lParam;
	bi.iImage = iImage;

	LPITEMIDLIST pidl = SHBrowseForFolder(&bi);
	if(!pidl)
		return false;
	
	if(!SHGetPathFromIDList(pidl, pszDisplayName))
		return false;

	pMalloc->Free(pidl);
return true;
}

CCriticalSection::CCriticalSection(){
	::InitializeCriticalSection(&cs);
}

CCriticalSection::~CCriticalSection(){
	::DeleteCriticalSection(&cs);
}

void CCriticalSection::Enter(){
	::EnterCriticalSection(&cs);
}

void CCriticalSection::Leave(){
	::LeaveCriticalSection(&cs);
}