sugarmemochoosewords.c

Palm上著名的背单词软件的源码

#include <PalmOS.h>
#include "SugarMemo.h"
#include "SugarMemoRsc.h"
#include "SugarMemoDB.h"
#include "SugarMemoChooseWords.h"

#define ListChoices 10
#define Forward true
#define Backward false

UInt16 RawListItemNumbers = 0;
UInt16 rawListItemIndex[ListChoices];

/////////////////////////////////////////////////
//
// internal functions
//
/////////////////////////////////////////////////

static void ChooseFormInit();
static void RawListDraw(Int16 itemNum, RectangleType * bounds, char** itemText);
static void BuildRawListItemText();
static Boolean SearchUnlearnedWordEntry(Boolean forward, UInt16* cursor);
static void RawListForward(Boolean byline);
static void RawListBackward(Boolean byline);
static void LearnListDraw(Int16 itemNum, RectangleType* bounds, char** itemText);
static void UpdateLearnList();
static void MoveToLearnList(UInt16 itemNum);
static void MoveToRawList(UInt16 itemNum);
/*


//event handler
Boolean ChooseFormHandleEvent(EventType * event){

	FormType* frmP;
	ListType* list;
	Boolean handled = false;
	
	switch (event->eType){
		
		case frmOpenEvent:
			frmP = FrmGetActiveForm();
			ChooseFormInit();
			list = FrmGetObjectPtr(frmP, FrmGetObjectIndex(frmP, ChooseRawList));
			
			FrmDrawForm(frmP);
			break;
			
		case ctlSelectEvent:
			switch (event->data.ctlSelect.controlID){
				case ChooseLearnButton:
					FrmGotoForm(LearnForm);
					handled = true;
					break;
				
				default:
					break;
			
			}
			break;
			
		case ctlRepeatEvent:
			switch (event->data.ctlRepeat.controlID){
				case ChooseScrollUpRepeating:
					RawListBackward(true);
					break;
				case ChooseScrollDownRepeating:
					RawListForward(true);
					break;
			}
			frmP = FrmGetActiveForm();
			list = FrmGetObjectPtr(frmP, FrmGetObjectIndex(frmP, ChooseRawList));
			LstSetSelection(list, noListSelection);
			LstDrawList(list);
			handled = true;
			break;
		
		case lstSelectEvent:
			switch(event->data.lstSelect.listID){
				case ChooseRawList:
					frmP = FrmGetActiveForm();
					list = FrmGetObjectPtr(frmP, FrmGetObjectIndex(frmP, ChooseRawList));
					MoveToLearnList(LstGetSelection(list));
					break;
				case ChooseLearnList:
					frmP = FrmGetActiveForm();
					list = FrmGetObjectPtr(frmP, FrmGetObjectIndex(frmP, ChooseLearnList));
					MoveToRawList(LstGetSelection(list));
					break;
			}
			handled = true;
			break;
		
		default:
			break;
	}
	
	return handled;
}	

void ChooseFormInit(){
	FormType * frmP;
	ListType * list;
	
	//init choose raw
	frmP = FrmGetActiveForm();
	list = FrmGetObjectPtr(frmP, FrmGetObjectIndex(frmP, ChooseRawList));
	LstSetDrawFunction(list, RawListDraw);
	LstSetSelection(list, noListSelection);
	
	//init raw list text array
	RawListItemNumbers = 0;
	
	BuildRawListItemText();
	LstSetListChoices(list, NULL, RawListItemNumbers);	
	
	list = FrmGetObjectPtr(frmP, FrmGetObjectIndex(frmP, ChooseLearnList));
	LstSetDrawFunction(list, LearnListDraw);
	UpdateLearnList();
}

void LearnListDraw(Int16 itemNum, RectangleType* bounds, char** itemText){
	WordRecordType record;
	MemHandle recordH;
	
	HeaderItem item;
	UInt16 index = 0;
	
	if (itemNum < GetHeaderItemNumber(CurrentDB)){
		WordDBGetLearningItem(CurrentDB, &item, itemNum);
		DmFindRecordByID(CurrentDB, item.uniqueID, &index);

		GetWordRecord(CurrentDB, index, &record, &recordH);
		if (record.field[WordFieldQuestion] != NULL)
			WinDrawChars(record.field[WordFieldQuestion], StrLen(record.field[WordFieldQuestion]),
				bounds->topLeft.x, bounds->topLeft.y);
	}
	
	MemHandleUnlock(recordH);
}

void UpdateLearnList(){
	FormType * frmP;
	ListType * list;
	frmP = FrmGetActiveForm();
	list = FrmGetObjectPtr(frmP, FrmGetObjectIndex(frmP, ChooseLearnList));
	LstSetListChoices(list, NULL, GetHeaderItemNumber(CurrentDB));
	LstSetSelection(list, noListSelection);
	LstDrawList(list);
}
	

void RawListDraw(Int16 itemNum, RectangleType* bounds, char** itemText){
	WordRecordType record;
	MemHandle recordH;

	if (itemNum >= RawListItemNumbers) return;
	
	GetWordRecord(CurrentDB, rawListItemIndex[itemNum], &record, &recordH);
	
	WinDrawChars(record.field[WordFieldQuestion], StrLen(record.field[WordFieldQuestion]), 
		bounds->topLeft.x, bounds->topLeft.y);
	
	MemHandleUnlock(recordH);
}

void BuildRawListItemText(){
	FormType * frmP;
	ListType * list;
	UInt16 i;
	
	UInt16 cursor = 0;
	Boolean full = false;
	Boolean reachedEnd = false;
	Boolean reachedHead = false;

	if (RawListItemNumbers == 0) cursor = 0;
	else cursor = rawListItemIndex[RawListItemNumbers - 1] + 1;
//	if (cursor == 0) SndPlaySystemSound(sndError);
		
	while (SearchUnlearnedWordEntry(Forward, &cursor)){

		rawListItemIndex[RawListItemNumbers] = cursor;

		RawListItemNumbers ++;
		cursor ++;
			
		if (RawListItemNumbers == ListChoices){
			full = true;
			break;
		}	
	}
		
	if (!full) {
		
		reachedEnd = true;
	
		if (RawListItemNumbers == 0) cursor = 0;
		else cursor = rawListItemIndex[0] - 1;
	
		while (SearchUnlearnedWordEntry(Backward, &cursor)){
		
			for (i = RawListItemNumbers - 1; i > 0; i--)
				rawListItemIndex[i] = rawListItemIndex[i-1];
		
			rawListItemIndex[0] = cursor;
			RawListItemNumbers ++;
			cursor --;
		
			if (RawListItemNumbers == ListChoices){
				full = true;
				break;
			}
		}
		
		if (!full) reachedHead = true;
	}
	
		
	if (!reachedHead) {
		cursor = rawListItemIndex[0] - 1;
		reachedHead = !SearchUnlearnedWordEntry(Backward, &cursor);
	}
	
	if (!reachedEnd) {
		cursor = rawListItemIndex[RawListItemNumbers - 1] + 1;	
		reachedEnd = !SearchUnlearnedWordEntry(Forward, &cursor);
	}
	
	frmP = FrmGetActiveForm();
	FrmUpdateScrollers(frmP, FrmGetObjectIndex(frmP, ChooseScrollUpRepeating),
		FrmGetObjectIndex(frmP, ChooseScrollDownRepeating), !reachedHead, !reachedEnd);

	list = FrmGetObjectPtr(frmP, FrmGetObjectIndex(frmP, ChooseRawList));
	LstSetListChoices(list, NULL, RawListItemNumbers);
	LstSetSelection(list, noListSelection);
	LstDrawList(list);
}

void RawListForward(Boolean byline){
	
	FormType * frmP;
	UInt16 steps;
	UInt16 cursor;
	UInt16 i;
	Boolean reachedEnd;
	
	if (byline) steps = 1;
	else steps = ListChoices - 1;
	
	cursor = rawListItemIndex[RawListItemNumbers - 1] + 1;
	
	while (steps > 0){
		if (!SearchUnlearnedWordEntry(Forward, &cursor)) {
			reachedEnd = true;
			break;
		}
		
		for (i = 0; i < RawListItemNumbers - 1; i++)
			rawListItemIndex[i] = rawListItemIndex[i+1];
		
		rawListItemIndex[RawListItemNumbers -1] = cursor;  
		
		steps--;
	}	
	
	if (!reachedEnd)
		reachedEnd = !SearchUnlearnedWordEntry(Forward, &cursor);
	
	frmP = FrmGetActiveForm();
	FrmUpdateScrollers(frmP, FrmGetObjectIndex(frmP, ChooseScrollUpRepeating),
		FrmGetObjectIndex(frmP, ChooseScrollDownRepeating), true, !reachedEnd);
}

void RawListBackward(Boolean byline){
	FormType * frmP;
	UInt16 steps;
	UInt16 cursor;
	UInt16 i;
	Boolean reachedHead;

	if (byline) steps = 1;
	else steps = ListChoices - 1;
	
	cursor = rawListItemIndex[0] - 1;
	
	while (steps > 0){
		if (!SearchUnlearnedWordEntry(Backward, &cursor)) {
			reachedHead = true;
			break;
		}
		
		for (i = RawListItemNumbers - 1; i > 0; i--)
			rawListItemIndex[i] = rawListItemIndex[i-1];

		rawListItemIndex[0] = cursor;  
		steps--;
	}	
	
	if (!reachedHead)
		reachedHead = !SearchUnlearnedWordEntry(Forward, &cursor);
	
	frmP = FrmGetActiveForm();
	FrmUpdateScrollers(frmP, FrmGetObjectIndex(frmP, ChooseScrollUpRepeating), 
		FrmGetObjectIndex(frmP, ChooseScrollDownRepeating), !reachedHead, true);
	
}

Boolean SearchUnlearnedWordEntry(Boolean forward, UInt16* cursor){
	
	Boolean found = false;
	WordPackedRecord* packed;
	MemHandle recordH;
	
	//if (cursor == 0) SndPlaySystemSound(sndError);
	do {
		//the only error returned by GetWordRecord is Index out of range;
		recordH = DmQueryRecord(CurrentDB, *cursor);
		if (recordH == NULL) return false;
		packed = (WordPackedRecord*) MemHandleLock(recordH);
		
		//if header record, next
		if (GetBitMacro(packed->header.allBits, HeaderFlag) != 0){
			
			//move cursor
			if (forward) (*cursor)++;
			else (*cursor)--;
			MemPtrUnlock(packed);
			found = false;
			continue;
		}
		
		//if not idling, next
		if (packed->wordStatus.wqs.wordQueue != Idling){
			
			//move cursor
			if (forward) (*cursor)++;
			else (*cursor)--;
			MemPtrUnlock(packed);
			found = false;
			continue;
		}
		
		found = true;
		
	} while (found == false);
	
	MemPtrUnlock(packed);
	return found;
}

void MoveToLearnList(UInt16 itemNum){
	
	FormType * frmP;
	ListType * list;
	HeaderItem learningItem;
	MemHandle recordH;
	WordRecordType record;
	WordFieldFlags flag;
	UInt16 i, j;

	if (!(itemNum < RawListItemNumbers)) return;
	flag.allBits = 0;
	
	GetWordRecord(CurrentDB, rawListItemIndex[itemNum], &record, &recordH);
	RemoveBitMacro(record.header.allBits, Raw);
	SetBitMacro(record.header.allBits, Learned);
	j = record.header.allBits;
	record.wordStatus.wqs.wordQueue = Learning;
	ChangeWordRecord(CurrentDB, &rawListItemIndex[itemNum], &record, flag);
	
	//MemHandleUnlock(recordH);
	
	DmRecordInfo(CurrentDB, rawListItemIndex[itemNum], NULL, &learningItem.uniqueID, NULL);
	learningItem.learningStatus = FirstLook;
	AddHeaderItem(CurrentDB, &learningItem); 
	
	//first pack raw list item
	for ( i = itemNum; i < RawListItemNumbers - 1; i++)
		rawListItemIndex[i] = rawListItemIndex[i+1];
	
	RawListItemNumbers--;
	
	BuildRawListItemText();
	frmP = FrmGetActiveForm();
	list = FrmGetObjectPtr(frmP, FrmGetObjectIndex(frmP, ChooseRawList));
	
	LstDrawList(list);
	
	UpdateLearnList();
	list = FrmGetObjectPtr(frmP, FrmGetObjectIndex(frmP, ChooseLearnList));
	LstDrawList(list);

}

void MoveToRawList(UInt16 itemNum){
	
	FormType * frmP;
	ListType * list;
	HeaderItem learningItem;
	MemHandle recordH;
	WordRecordType record;
	WordFieldFlags flag;
	UInt16 i, index;
	Err error;
	

	WordDBGetLearningItem(CurrentDB, &learningItem, itemNum);
	RemoveHeaderItem(CurrentDB, itemNum);
	
	error = DmFindRecordByID(CurrentDB, learningItem.uniqueID, &index);
	if (error) ErrAlert(error);
	RawListItemNumbers = 0;


	flag.allBits = 0;	
	GetWordRecord(CurrentDB, index, &record, &recordH);
	RemoveBitMacro(record.header.allBits, Learned);
	SetBitMacro(record.header.allBits, Raw);

	record.wordStatus.wqs.wordQueue = Idling;
	ChangeWordRecord(CurrentDB, &index, &record, flag);

	
	UpdateLearnList();
	
	BuildRawListItemText();	
}*/