wcedbdoc.cpp

wce4.0,database,

// WCE_DatabaseDoc.cpp : implementation of the CWCEDBDoc class
//

#include "stdafx.h"

#include "wcedbtst.h"
#include "wcedbdoc.h"


// Define app-defined values
const DWORD DB_IDENT_PEOPLE  = 12345;
const WCHAR DB_NAME_PEOPLE[] = _T("People");
const WORD  PROP_LASTNAME    = 101,  
            PROP_FIRSTNAME   = 102,  
            PROP_AGE         = 103,   
            PROP_GENDER      = 104; 



#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CWCEDBDoc

IMPLEMENT_DYNCREATE(CWCEDBDoc, CDocument)

BEGIN_MESSAGE_MAP(CWCEDBDoc, CDocument)
	//{{AFX_MSG_MAP(CWCEDBDoc)
	ON_COMMAND(ID_FILE_BASICTESTS, OnFileBasicTests)
	ON_COMMAND(ID_FILE_ENUM, OnFileEnum)
	ON_COMMAND(ID_FILE_SORTTEST, OnFileSortTest)
	ON_COMMAND(ID_FILE_SEEKTEST, OnFileSeekTest)
	ON_COMMAND(ID_FILE_DELETIONTEST, OnFileDeletionTest)
	ON_COMMAND(ID_FILE_MODIFYTEST, OnFileModifyTest)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CWCEDBDoc construction/destruction

CWCEDBDoc::CWCEDBDoc()
{
}

CWCEDBDoc::~CWCEDBDoc()
{
	if(CCeDBDatabase::Exists(DB_NAME_PEOPLE)) 
	{
		CCeDBDatabase db;
		db.Open(DB_NAME_PEOPLE);
		db.Delete();
	}
}

BOOL CWCEDBDoc::OnNewDocument()
{
	if (!CDocument::OnNewDocument())
		return FALSE;

	return TRUE;
}


/////////////////////////////////////////////////////////////////////////////
// CWCEDBDoc serialization

void CWCEDBDoc::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
	}
	else
	{
	}
}

/////////////////////////////////////////////////////////////////////////////
// CWCEDBDoc diagnostics

#ifdef _DEBUG
void CWCEDBDoc::AssertValid() const
{
	CDocument::AssertValid();
}

void CWCEDBDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CWCEDBDoc commands

// Need to figure out error values
#define FAIL_AND_EXIT { Output.Add(CString((LPCTSTR)IDS_FAILEXIT)),UpdateAllViews(NULL); return; }
#define FAIL Output.Add(CString((LPCTSTR)IDS_FAILED)),UpdateAllViews(NULL)
#define OK   Output.Add(CString((LPCTSTR)IDS_OK)),UpdateAllViews(NULL)
#define PRINT(what) Output.Add(CString((LPCTSTR)what)),UpdateAllViews(NULL)
#define PRINT_BLANK() Output.Add(_T("")),UpdateAllViews(NULL)
#define PRINT_WSTR(what) Output.Add(what),UpdateAllViews(NULL)
#define START {Output.RemoveAll(); \
			  POSITION pos = GetFirstViewPosition(); \
              GetNextView(pos)->SetScrollPos(SB_VERT,0);\
              UpdateAllViews(NULL); }


BOOL CWCEDBDoc::GeneratePeopleDB() 
{
	PRINT(IDS_GENERATE_PEOPLE);
	PRINT(IDS_SORT_ORDER); 

	// Delete old database if existent
	if(CCeDBDatabase::Exists(DB_NAME_PEOPLE)) 
	{
		CCeDBDatabase db;
		db.Open(DB_NAME_PEOPLE);
		if(!db.Delete())
			return FALSE;
	}

	// Create database
	CCeDBDatabase db;
	CEOID poid;  
	CCeDBProp SortProps[3] = {
		CCeDBProp(CCeDBProp::Type_String, PROP_LASTNAME,
		           CCeDBProp::Sort_Ascending | CCeDBProp::Sort_CaseInsensitive),
		CCeDBProp(CCeDBProp::Type_UShort, PROP_AGE,      
		           CCeDBProp::Sort_Descending),
		CCeDBProp(CCeDBProp::Type_UShort, PROP_GENDER,   
		           CCeDBProp::Sort_UnknownFirst) 
	};

	if(!(poid = db.Create(DB_NAME_PEOPLE,DB_IDENT_PEOPLE,3,SortProps))) 
		return FALSE;

	if(!db.Open(poid))
		return FALSE;

	// Add records
	CCeDBRecord rec;
	CCeDBProp props[4];

	CString str;

	str.LoadString(IDS_SMITH);
	props[0] = CCeDBProp((LPWSTR)(LPCTSTR)str,PROP_LASTNAME);
	str.LoadString(IDS_BOB);
	props[1] = CCeDBProp((LPWSTR)(LPCTSTR)str,  PROP_FIRSTNAME);
	props[2] = CCeDBProp((USHORT)34, PROP_AGE);
	props[3] = CCeDBProp((USHORT)'M',PROP_GENDER);
	rec.AddProps(props,4);
	if(!db.AddRecord(&rec))
		return FALSE;

	rec.DeleteAllProps();
	str.LoadString(IDS_SMITH);
	props[0] = CCeDBProp((LPWSTR)(LPCTSTR)str,PROP_LASTNAME);
	str.LoadString(IDS_MARY);
	props[1] = CCeDBProp((LPWSTR)(LPCTSTR)str, PROP_FIRSTNAME);
	props[2] = CCeDBProp((USHORT)22, PROP_AGE);
	props[3] = CCeDBProp((USHORT)'F',PROP_GENDER);
	rec.AddProps(props,4);
	if(!db.AddRecord(&rec))
		return FALSE;

	rec.DeleteAllProps();
	str.LoadString(IDS_EMERSON);
	props[0] = CCeDBProp((LPWSTR)(LPCTSTR)str,PROP_LASTNAME);
	str.LoadString(IDS_RALPH);
	props[1] = CCeDBProp((LPWSTR)(LPCTSTR)str, PROP_FIRSTNAME);
	props[2] = CCeDBProp((USHORT)65, PROP_AGE);
	props[3] = CCeDBProp((USHORT)'M',PROP_GENDER);
	rec.AddProps(props,4);
	if(!db.AddRecord(&rec))
		return FALSE;

	rec.DeleteAllProps();
	str.LoadString(IDS_CABANA);
	props[0] = CCeDBProp((LPWSTR)(LPCTSTR)str,PROP_LASTNAME);
	str.LoadString(IDS_ANNA);
	props[1] = CCeDBProp((LPWSTR)(LPCTSTR)str, PROP_FIRSTNAME);
	props[2] = CCeDBProp((USHORT)19, PROP_AGE);
	props[3] = CCeDBProp((USHORT)'F',PROP_GENDER);
	rec.AddProps(props,4);
	if(!db.AddRecord(&rec))
		return FALSE;

	rec.DeleteAllProps();
	str.LoadString(IDS_ZIMMERMAN);
	props[0] = CCeDBProp((LPWSTR)(LPCTSTR)str,PROP_LASTNAME);
	str.LoadString(IDS_ZACH);
	props[1] = CCeDBProp((LPWSTR)(LPCTSTR)str, PROP_FIRSTNAME);
	props[2] = CCeDBProp((USHORT)25, PROP_AGE);
	props[3] = CCeDBProp((USHORT)'M',PROP_GENDER);
	rec.AddProps(props,4);
	if(!db.AddRecord(&rec))
		return FALSE;

	// Write a partial record (an unknown gender)
	rec.DeleteAllProps();
	str.LoadString(IDS_EVANS);
	props[0] = CCeDBProp((LPWSTR)(LPCTSTR)str,PROP_LASTNAME);
	str.LoadString(IDS_PAT);
	props[1] = CCeDBProp((LPWSTR)(LPCTSTR)str, PROP_FIRSTNAME);
	props[2] = CCeDBProp((USHORT)41, PROP_AGE);
	props[3] = CCeDBProp((USHORT)'F',PROP_GENDER);
	rec.AddProps(props,4);
	// We added the last prop so we can test deletion
	rec.DeleteProp(PROP_GENDER);
	if(!db.AddRecord(&rec))
		return FALSE;

	return TRUE;
}


BOOL CWCEDBDoc::PrintPeopleDB(CCeDBDatabase *pdb) 
{
	PRINT(IDS_PRINT_PEOPLE);

	CCeDBRecord rec;

	WCHAR szBuf[100];
	CString str;
	str.LoadString(IDS_NUM_RECORD);
	wsprintf(szBuf,(LPCTSTR)str,pdb->GetNumRecords());
	PRINT_WSTR(szBuf);

	BOOL bPrev = pdb->m_bAutoSeekNext;
	pdb->m_bAutoSeekNext = TRUE;
	pdb->SeekFirst();
	while(pdb->ReadCurrRecord(&rec))
		PrintPerson(&rec);
	pdb->m_bAutoSeekNext = bPrev;

	PRINT_BLANK();
	return TRUE;
}

void CWCEDBDoc::PrintIndex(CCeDBDatabase* pdb) 
{
	WCHAR szBuf[20];
	CString str;
	str.LoadString(IDS_CURRENT_RECORD);
	wsprintf(szBuf,(LPCTSTR)str,pdb->GetCurrIndex());
	PRINT_WSTR(szBuf);
}

void CWCEDBDoc::PrintPerson(CCeDBRecord* prec) 
{
	CCeDBProp *pPropLast,*pPropFirst,*pPropAge,*pPropGender;
	WCHAR szBuf[200];

	pPropLast   = prec->GetPropFromIdent(PROP_LASTNAME);
	pPropFirst  = prec->GetPropFromIdent(PROP_FIRSTNAME);
	pPropAge    = prec->GetPropFromIdent(PROP_AGE);
	pPropGender = prec->GetPropFromIdent(PROP_GENDER);

	CString str, str2;
	str.LoadString(IDS_AGE_GENDER);
	str2.LoadString(IDS_QUESTION);
	wsprintf(szBuf,(LPCTSTR)str,
		     pPropLast?   pPropLast->GetString()   : (LPCTSTR)str2,
			 pPropFirst?  pPropFirst->GetString()  : (LPCTSTR)str2,
			 pPropAge?    pPropAge->GetUShort()    : 999,
			 pPropGender? pPropGender->GetUShort() : '?');
	PRINT_WSTR(szBuf);		
}


void CWCEDBDoc::OnFileClear() 
{
	Output.RemoveAll();
	UpdateAllViews(NULL);
	CCeDBProp DBassign;
}



void CWCEDBDoc::OnFileBasicTests()
{
	START;

	PRINT(IDS_BASIC_TEST);
	PRINT_BLANK();

	PRINT(IDS_CHECK_TEST);
	//if(!CCeDBDatabase::Exists(_T("Test Database")))
	CString str;
	str.LoadString(IDS_DATABASE);
	if(!CCeDBDatabase::Exists((LPCTSTR)str))
		FAIL;
	else
	{
		OK;
		PRINT(IDS_OPENIT);
		CCeDBDatabase temp;
		if(temp.Open((LPCTSTR)str))
			OK;
		else 
			FAIL_AND_EXIT;
		PRINT(IDS_DELETEIT);
		if(temp.Delete())
			OK;
		else
			FAIL_AND_EXIT;
	}

	PRINT(IDS_CREATING_TEST);

	CCeDBDatabase* pdb = new CCeDBDatabase; // use ptr to new

	if(!pdb->Create((LPCTSTR)str))
		FAIL_AND_EXIT;
	OK;

	PRINT(IDS_CHECK_EXIST);
	if(CCeDBDatabase::Exists((LPCTSTR)str))
		OK;
	else
		FAIL;

	PRINT(IDS_CLOSEIT);
	pdb->Close();

	delete pdb;

	CCeDBDatabase db; // use auto

	PRINT(IDS_OPEN_AGAIN);
	if(!db.Open((LPCTSTR)str))
		FAIL_AND_EXIT;
	OK;

	PRINT(IDS_DELETEIT);
	db.Delete();

	PRINT_BLANK();
	PRINT(IDS_DONE_BASIC);
}




void CWCEDBDoc::OnFileEnum() 
{
	START;
	PRINT(IDS_ENUM_TEST);
	PRINT_BLANK();