static void LoadPreferencesNoahPro(AppContext* appContext)
{
DmOpenRef db;
UInt recNo;
void * recData;
MemHandle recHandle;
UInt recsCount;
Boolean fRecFound = false;
appContext->fFirstRun = true;
db = DmOpenDatabaseByTypeCreator(NOAH_PREF_TYPE, NOAH_PRO_CREATOR, dmModeReadWrite);
if (!db) return;
recsCount = DmNumRecords(db);
for (recNo = 0; (recNo < recsCount) && !fRecFound; recNo++)
{
recHandle = DmQueryRecord(db, recNo);
recData = MemHandleLock(recHandle);
if ( (MemHandleSize(recHandle)>=PREF_REC_MIN_SIZE) && IsValidPrefRecord( recData ) )
{
LogG( "LoadPreferencesNoahPro(), found prefs record" );
fRecFound = true;
appContext->fFirstRun = false;
DeserializePreferencesNoahPro(appContext, (unsigned char*)recData, MemHandleSize(recHandle) );
}
MemPtrUnlock(recData);
}
DmCloseDatabase(db);
}
void GlbReleaseRecord(UInt16 index, UInt16 id) {
if (gVars->globals[id]) {
MemHandle recordH = DmQueryRecord(gVars->globals[id], index);
if (recordH)
MemHandleUnlock(recordH);
}
}
/*----------------------------------------CIRexxApp::copyScriptFromFindResult-+
| |
+----------------------------------------------------------------------------*/
void CIRexxApp::copyScriptFromFindResult(GoToParamsPtr pGoToParams)
{
Err err;
LocalID dbID;
UInt16 cardNo = 0;
DmOpenRef dbP;
DmSearchStateType searchState;
MemHandle hRecord;
if ((err = DmGetNextDatabaseByTypeCreator(
true, &searchState, 'data', CREATORID, true, &cardNo, &dbID)) != errNone) {
return;
}
if ((dbP = DmOpenDatabase(cardNo, dbID, dmModeReadOnly)) == 0) {
return;
}
if (!(hRecord = DmQueryRecord(dbP, pGoToParams->recordNum))) {
DmCloseDatabase(dbP);
return;
}
Char * p = (char *)MemHandleLock(hRecord);
UInt32 size = MemHandleSize(hRecord);
if (p[size - 1] == '\0') { --size; }
emptyScript();
appendScript(p, size);
MemHandleUnlock(hRecord);
DmCloseDatabase(dbP);
return;
}
/* Delete a bookmark for a given word in a bookmark database indicated by sortType */
static Err DeleteBookmarkInDB(AppContext* appContext, BookmarkSortType sortType, char *word)
{
Err err;
UInt16 recsCount, i;
MemHandle recHandle;
char * wordInRecord;
err = OpenBookmarksDB(appContext, sortType);
if ( errNone != err )
return err;
recsCount = DmNumRecords(appContext->bookmarksDb);
for (i = 0; i < recsCount; i++)
{
recHandle = DmQueryRecord(appContext->bookmarksDb, i);
if (!recHandle)
{
err = DmGetLastErr();
goto OnError;
}
wordInRecord = (char*)MemHandleLock(recHandle);
Assert(wordInRecord);
if (0 == StrCompare(wordInRecord, word))
{
MemHandleUnlock(recHandle);
DmRemoveRecord(appContext->bookmarksDb, i);
break;
}
MemHandleUnlock(recHandle);
}
OnError:
CloseBookmarksDB(appContext);
return err;
}
static void
ExamDelete(void)
{
MemHandle mex, m;
ExamDBRecord *ex;
UInt16 index=0, pressedButton=0;
Char *courseName, timeTemp[timeStringLength], dateTemp[longDateStrLength];
DmFindRecordByID(DatabaseGetRefN(DB_MAIN), gExamsLastSelRowUID, &index);
mex = DmQueryRecord(DatabaseGetRefN(DB_MAIN), index);
ex = (ExamDBRecord *)MemHandleLock(mex);
m=MemHandleNew(1);
CourseGetName(ex->course, &m, true);
courseName = MemHandleLock(m);
DateToAscii(ex->date.month, ex->date.day, ex->date.year+MAC_SHIT_YEAR_CONSTANT, PrefGetPreference(prefLongDateFormat), dateTemp);
TimeToAscii(ex->begin.hours, ex->begin.minutes, PrefGetPreference(prefTimeFormat), timeTemp);
pressedButton = FrmCustomAlert(ALERT_ex_dodel, courseName, dateTemp, timeTemp);
MemHandleUnlock(m);
MemHandleFree(m);
MemHandleUnlock(mex);
if (pressedButton == 0) {
// OK, the user really wants us to delete the record
NoteDelete(&index);
DmRemoveRecord(DatabaseGetRefN(DB_MAIN), index);
gExamsSelRow=0;
FrmUpdateForm(FORM_exams, frmRedrawUpdateCode);
}
}
void *GlbGetRecord(UInt16 index, UInt16 id) {
if (gVars->globals[id]) {
MemHandle recordH = DmQueryRecord(gVars->globals[id], index);
if (recordH)
return MemHandleLock(recordH);
}
return NULL;
}
static void
TableDrawData(void *table, Int16 row, Int16 column, RectangleType *bounds)
{
UInt16 index=TblGetRowID(table, row);
ExamDBRecord *ex;
MemHandle mex;
RGBColorType fore={0x00, 0x00, 0x00, 0x00}, back={0x00, 0xFF, 0xFF, 0xFF};
if (! TblRowUsable(table, row)) return;
TNSetBackColorRGB(&back, NULL);
TNSetForeColorRGB(&back, NULL);
WinDrawRectangle(bounds, 0);
mex = DmQueryRecord(DatabaseGetRefN(DB_MAIN), index);
ex = (ExamDBRecord *)MemHandleLock(mex);
if (column == EXCOL_COURSE) {
Char *temp;
MemHandle m=MemHandleNew(1);
CourseGetName(ex->course, &m, true);
temp = MemHandleLock(m);
TNSetForeColorRGB(&fore, NULL);
TNDrawCharsToFitWidth(temp, bounds);
MemHandleUnlock(m);
MemHandleFree(m);
} else if (column == EXCOL_NOTE) {
if (ex->note) {
Char noteSymb[2] = { GADGET_NOTESYMBOL, 0 };
FontID oldFont = FntSetFont(symbolFont);
TNDrawCharsToFitWidth(noteSymb, bounds);
FntSetFont(oldFont);
}
} else if (column == EXCOL_DATE) {
Char dateTemp[dateStringLength];
DateToAscii(ex->date.month, ex->date.day, ex->date.year+MAC_SHIT_YEAR_CONSTANT, PrefGetPreference(prefDateFormat), dateTemp);
TNDrawCharsToFitWidth(dateTemp, bounds);
} else if (column == EXCOL_TIME) {
Char timeTemp[timeStringLength];
TimeToAscii(ex->begin.hours, ex->begin.minutes, PrefGetPreference(prefTimeFormat), timeTemp);
TNDrawCharsToFitWidth(timeTemp, bounds);
}
if (ex->flags & EX_FLAG_DONE) {
RGBColorType red = {0x00, 0xFF, 0x00, 0x00}, old;
Int16 yCoord=bounds->topLeft.y+(bounds->extent.y / 2);
TNSetForeColorRGB(&red, &old);
WinDrawLine(bounds->topLeft.x, yCoord, bounds->topLeft.x+bounds->extent.x, yCoord);
TNSetForeColorRGB(&old, NULL);
}
MemHandleUnlock(mex);
}
/* Save a given word in bookmarks database. */
Err AddBookmark(AppContext* appContext, char * word)
{
Err err;
UInt16 pos;
Boolean fWordAlreadyBookmarked;
MemHandle recHandle;
char * wordInRec;
BookmarkSortType currDbOpen;
currDbOpen = appContext->currBookmarkDbType;
// 1. See if we already have the record in bookmarks.
// We assume that if the record wasn't found in sorted-by-name database, it doesn't exist in the other.
// The sorted-by-name database is quicker to scan, because we can use binary search.
err = OpenBookmarksDB(appContext, bkmSortByName);
if (errNone != err)
goto Exit;
pos = DmFindSortPosition(appContext->bookmarksDb, word, NULL, (DmComparF *) BookmarksByNameCompare, 0);
fWordAlreadyBookmarked = false;
// DmFindSortPosition returns the position there the new record should be placed
// so if the record exist its position is (pos - 1)
recHandle = DmQueryRecord(appContext->bookmarksDb, pos>0 ? pos-1 : pos);
// it's ok if we don't get handle - this might be an empty database
if (recHandle)
{
wordInRec = (char*)MemHandleLock(recHandle);
if (0 == StrCompare(word, wordInRec))
fWordAlreadyBookmarked = true;
MemHandleUnlock(recHandle);
}
if (fWordAlreadyBookmarked)
{
err = errNone;
goto Exit;
}
// 2. If we haven't found the record, we add it to databases
WriteWordInRecord(appContext->bookmarksDb, pos, word);
CloseBookmarksDB(appContext);
err = OpenBookmarksDB(appContext, bkmSortByTime);
if (errNone != err)
goto Exit;
// the record must be put chronogically, so we add it at the beginning of the database
WriteWordInRecord(appContext->bookmarksDb, 0, word);
CloseBookmarksDB(appContext);
Exit:
if (bkmInvalid != currDbOpen)
OpenBookmarksDB(appContext, currDbOpen);
return err;
}
/**************************************************************************
* Function: getHashFromAccountIndex
* Description: returns the unique has for the account located at a given
* index. Remember that the first few bytes of an account record are the
* system ID of the account. Just skip these an pop off the AID.
* ************************************************************************/
md_hash * getHashFromAccountIndex (DmOpenRef AccountDB, UInt16 index) {
static md_hash ret;
MemHandle rec = DmQueryRecord (AccountDB, index);
if (rec) {
MemPtr buff = MemHandleLock (rec);
MemMove (ret, buff+sizeof(UInt16)+sizeof(UInt16), sizeof (ret));
MemHandleUnlock (rec);
}
return &ret;
}
/**************************************************************************
* Function: getAIDFromAccountIndex
* Description: returns the account id for the account located at a given
* index. Remember that the first few bytes of an account record are the
* system ID of the account. Just skip these an pop off the AID.
* ************************************************************************/
UInt16 getAIDFromAccountIndex(DmOpenRef AccountDB, UInt16 index) {
UInt16 ret = 0;
MemHandle rec = DmQueryRecord (AccountDB, index);
if (rec) {
MemPtr buff = MemHandleLock (rec);
MemMove (&ret, buff+sizeof(ret), sizeof (ret));
MemHandleUnlock (rec);
}
return ret;
}
/******************************************************************************
* Function: getSIDForSystemIndex
* Description: this will get the system id for a given index in the
* system database.
* ****************************************************************************/
UInt16 getSIDForSystemIndex (DmOpenRef SystemDB, UInt16 i) {
UInt16 ret;
MemHandle rec = DmQueryRecord (SystemDB, i);
if (rec) {
MemPtr buff = MemHandleLock (rec);
MemMove (&ret, buff, sizeof (ret));
MemHandleUnlock (rec);
}
return ret;
}
/*
** Load the record data (flags, ...) - but not the picture
*/
static void LoadRecordData(void) {
MemHandle t = NULL;
MemPtr ptr = NULL;
UInt16 attr = 0;
UInt32 highDataOffset = 0;
Int16 len = 0;
PRINT("Loading Record Data for %hd", p.dbI);
/* Clear unmasked flag */
d.unmaskedCurrentRecord = false;
/* Open and lock the record */
t = DmQueryRecord(d.dbR, p.dbI);
if (!t) abort();
ptr = MemHandleLock(t);
/* Is the record private? */
DmRecordInfo(d.dbR, p.dbI, &attr, NULL, NULL);
d.record_private = attr & dmRecAttrSecret;
/* Read the header data */
MemMove(&d.record, ptr, sizeof(DiddleBugRecordType));
/* Read the additional alarm info */
highDataOffset = sketchDataOffset + d.record.sketchLength;
len = StrLen((Char*)(ptr + highDataOffset)) + 1; /* +1 for null char */
if (d.record_name) MemHandleFree(d.record_name);
d.record_name = MemHandleNew(len);
ASSERT(d.record_name);
MemMove(MemHandleLock(d.record_name), ptr + highDataOffset, len);
MemHandleUnlock(d.record_name);
highDataOffset += len;
len = StrLen((Char*)(ptr + highDataOffset)) + 1; /* +1 for null char */
if (d.record_note) MemHandleFree(d.record_note);
d.record_note = MemHandleNew(len);
ASSERT(d.record_note);
MemMove(MemHandleLock(d.record_note), ptr + highDataOffset, len);
MemHandleUnlock(d.record_note);
highDataOffset += len;
/* Clear old data since there may not be an extra-data block yet */
MemSet(&d.record_sound, sizeof(AlarmSoundInfoType), 0);
d.record_sound.listIndex = -1; /* default */
/* Read new extra-data (if it exists and is from a compatible version) */
if (d.record.extraLength == sizeof(AlarmSoundInfoType))
MemMove(&d.record_sound, ptr + highDataOffset, d.record.extraLength);
/* Unlock record */
MemHandleUnlock(t);
}
// Open preferences database and find a record that contains preferences.
// Return errNone if opened succesfully, otherwise an error:
// psErrNoPrefDatabase - pref database couldn't be found
// devnote: it scans through all records even though we only store preferences
// in one record because I want to be able to use preferences database used
// in earlier versions of Noah Pro/Thes.
Err PrefsStoreReader::ErrOpenPrefsDatabase()
{
if (_db)
{
Assert(_recHandle);
Assert(_recData);
return errNone;
}
// we already tried to open the database but couldn't, so don't try again
if (_fDbNotFound)
return psErrNoPrefDatabase;
LocalID dbId;
Err err = ErrFindDatabaseByNameTypeCreator(_dbName, _dbType, _dbCreator, &dbId);
if (dmErrCantFind==err)
{
err = psErrNoPrefDatabase;
goto ExitAndMarkNotFound;
}
if (err)
goto ExitAndMarkNotFound;
Assert(0!=dbId);
_db = DmOpenDatabase(0, dbId, dmModeReadWrite);
if (!_db)
{
err = DmGetLastErr();
Assert(err);
goto ExitAndMarkNotFound;
}
UInt16 recsCount = DmNumRecords(_db);
for (UInt16 recNo = 0; recNo < recsCount; recNo++)
{
_recHandle = DmQueryRecord(_db, recNo);
_recData = (unsigned char*)MemHandleLock(_recHandle);
if ( (MemHandleSize(_recHandle)>=4) && FValidPrefsStoreRecord(_recData) )
{
// we found the record with prefernces so remember _recData and _recHandle
// those must be freed in destructor
return errNone;
}
MemHandleUnlock(_recHandle);
_recHandle = NULL;
}
DmCloseDatabase(_db);
_db = 0;
err = psErrNoPrefDatabase;
ExitAndMarkNotFound:
_fDbNotFound = true;
return err;
}
static Boolean
CourseListHandleSelection(void)
{
MemHandle m, mWebsite, mEmail, old;
CourseDBRecord c;
FieldType *fldWebsite, *fldEmail;
Char *buffer;
m = DmQueryRecord(DatabaseGetRefN(DB_MAIN), gCourseInd[LstGetSelection(GetObjectPtr(LIST_courses))]);
if (! m) return true;
UnpackCourse(&c, MemHandleLock(m));
fldWebsite = GetObjectPtr(FIELD_cl_website);
fldEmail = GetObjectPtr(FIELD_cl_email);
if (StrLen(c.website) == 0) {
mWebsite = MemHandleNew(4);
buffer=MemHandleLock(mWebsite);
MemSet(buffer, 4, 0);
StrCopy(buffer, "-?-");
} else {
mWebsite = MemHandleNew(StrLen(c.website)+1);
buffer = MemHandleLock(mWebsite);
MemSet(buffer, StrLen(c.website)+1, 0);
StrCopy(buffer, c.website);
}
MemHandleUnlock(mWebsite);
old = FldGetTextHandle(fldWebsite);
FldSetTextHandle(fldWebsite, mWebsite);
if (old != NULL) MemHandleFree(old);
FldDrawField(fldWebsite);
if (StrLen(c.teacherEmail) == 0) {
mEmail = MemHandleNew(4);
buffer = MemHandleLock(mEmail);
MemSet(buffer, 4, 0);
StrCopy(buffer, "-?-");
} else {
mEmail = MemHandleNew(StrLen(c.teacherEmail)+1);
buffer = MemHandleLock(mEmail);
MemSet(buffer, StrLen(c.teacherEmail)+1, 0);
StrCopy(buffer, c.teacherEmail);
}
MemHandleUnlock(mEmail);
old = FldGetTextHandle(fldEmail);
FldSetTextHandle(fldEmail, mEmail);
if (old != NULL) MemHandleFree(old);
FldDrawField(fldEmail);
MemHandleUnlock(m);
return false;
}
static void
ExamBeam(void)
{
MemHandle mex;
ExamDBRecord *ex;
UInt16 index=0;
DmFindRecordByID(DatabaseGetRefN(DB_MAIN), gExamsLastSelRowUID, &index);
mex = DmQueryRecord(DatabaseGetRefN(DB_MAIN), index);
ex = (ExamDBRecord *)MemHandleLock(mex);
MemHandleUnlock(mex);
BeamCourseByCID(ex->course);
}
/**************************************************************************
* Function: getSystemFromIndex
* Description: based upon a system database index, this will locate the
* system for that index, unpack and decrypt it and initialize s
* ************************************************************************/
void getSystemFromIndex (DmOpenRef SystemDB, md_hash * SysPass, UInt16 index, MemHandle tmp, System * s) {
MemHandle rec = DmQueryRecord (SystemDB, index);
if (rec) {
MemPtr scratch, buff = MemHandleLock (rec);
/* resize the buffer */
if (MemHandleResize (tmp, MemPtrSize (buff)) == 0) {
scratch = MemHandleLock (tmp);
/* unpack and decrypt the account */
UnpackSystem (s, buff, scratch, SysPass, MemHandleSize (rec), true);
}
MemHandleUnlock (rec);
}
}
/**************************************************************************
* Function: getAccountFromIndex
* Description: based upon an account index, this will locate the
* account for that index, unpack and decrypt it and initialize acc
* ************************************************************************/
void getAccountFromIndex (DmOpenRef AccountDB, md_hash * SysPass, UInt16 index, MemHandle tmp, Account * acc) {
/* query the record from the database */
MemHandle rec = DmQueryRecord (AccountDB, index);
if (rec){
MemPtr scratch, buff = MemHandleLock (rec);
/* resize buffer */
if (MemHandleResize (tmp, MemPtrSize (buff)) == 0) {
scratch = MemHandleLock (tmp);
/* unpack the account */
UnpackAccount (acc, buff, scratch, SysPass, MemHandleSize (rec), true, true);
}
MemHandleUnlock (rec);
}
}
UInt8
CourseGetType(UInt16 courseID)
{
MemHandle m;
UInt16 index=0;
if (CourseGetIndex(DatabaseGetRefN(DB_MAIN), DatabaseGetCat(), courseID, &index)) {
// Found it, put it into the string
CourseDBRecord c;
MemPtr mp;
m = DmQueryRecord(DatabaseGetRefN(DB_MAIN), index);
mp = MemHandleLock(m);
UnpackCourse(&c, mp);
MemHandleUnlock(m);
return c.ctype;
}
return 0;
}
/************************************************************
*
* FUNCTION: ApptGetRecord
*
* DESCRIPTION: Get a record from a Appointment Database
*
* PARAMETERS: database pointer
* database index
* database record
*
* RETURNS: ##0 if successful, errorcode if not
*
* CREATED: 1/25/95
*
* BY: Roger Flores
*
*************************************************************/
Err ApptGetRecord (DmOpenRef dbP, UInt16 index, ApptDBRecordPtr r,
MemHandle * handleP) {
MemHandle handle;
ApptPackedDBRecordPtr src;
handle = DmQueryRecord(dbP, index);
ErrFatalDisplayIf(DmGetLastErr(), "Error Querying record");
src = (ApptPackedDBRecordPtr) MemHandleLock (handle);
if (DmGetLastErr()) {
*handleP = 0;
return DmGetLastErr();
}
ApptUnpack(src, r);
*handleP = handle;
return 0;
}
static Int16
LoadSMF(SndMidiListItemType midi, NoteListPtr list)
{
Err err = false;
DmOpenRef dbP;
UInt16 recIndex;
MemHandle midiH;
debugPrintf("LoadSMF: open db cardNo=%d dbID=%d for readOnly\n",
midi.cardNo, midi.dbID);
dbP = DmOpenDatabase (midi.cardNo, midi.dbID, dmModeReadOnly);
if (!dbP)
err = true;
if (!err)
err = DmFindRecordByID(dbP, midi.uniqueRecID, &recIndex);
debugPrintf("LoadSMF: find record with uniqueRecID=%ld\n",
midi.uniqueRecID);
if (!err) {
midiH = DmQueryRecord (dbP, recIndex);
if (!midiH)
err = true;
}
debugPrintf("LoadSMF: midiH=%lx size=%ld\n",
midiH, MemHandleSize(midiH));
if (!err)
smfutils_load(midiH, list);
if (dbP)
DmCloseDatabase (dbP);
if (err)
ErrDisplay ("LoadSMF(): error occure in function.");
return true;
}
static void MusicFormInit(UInt16 index) {
TabType *tabP;
FormType *frmP = FrmGetActiveForm();
if (index != dmMaxRecordIndex) {
MemHandle recordH = NULL;
GameInfoType *ogameInfoP;
recordH = DmQueryRecord(gameDB, index);
ogameInfoP = (GameInfoType *)MemHandleLock(recordH);
if (!ogameInfoP) {
FrmCustomAlert(FrmErrorAlert, "An error occured.",0,0);
return;
}
gameInfoP = (GameInfoType *)MemPtrNew(sizeof(GameInfoType));
MemMove(gameInfoP, ogameInfoP, sizeof(GameInfoType));
MemHandleUnlock(recordH);
} else {
FrmCustomAlert(FrmWarnAlert, "Select an entry first.",0,0);
FrmReturnToMain();
return;
}
tabP = TabNewTabs(3);
TabAddContent(&frmP, tabP, "Sound", TabMusicForm);
TabAddContent(&frmP, tabP, "Volume", TabVolumeForm);
TabAddContent(&frmP, tabP, "Audio CD", TabAudioCDForm);
MusicTabInit();
AudioCDTabInit();
VolumeTabInit();
FrmDrawForm(frmP);
TabSetActive(frmP, tabP, lastTab);
myTabP = tabP;
}
static void BookmarksListDrawFunc(Int16 itemNum, RectangleType * bounds, char **data)
{
Int16 stringWidthP = 160; // max width of the string in the list selection window
Int16 stringLenP;
Boolean truncatedP = false;
MemHandle recHandle;
char * str;
AppContext* appContext=GetAppContext();
Assert(itemNum >= 0);
recHandle = DmQueryRecord(appContext->bookmarksDb, itemNum);
Assert(recHandle); // no reason it shouldn't work
if (recHandle)
{
str = (char*)MemHandleLock(recHandle);
stringLenP = StrLen(str);
FntCharsInWidth(str, &stringWidthP, &stringLenP, &truncatedP);
WinDrawChars(str, stringLenP, bounds->topLeft.x, bounds->topLeft.y);
MemHandleUnlock(recHandle);
}
}
static void
ExamDetailsFormInit(FormType *frm)
{
UInt16 selectedCourse=0;
ListType *course;
ControlType *course_tr, *date_tr, *time_tr;
course = GetObjectPtr(LIST_exd_course);
course_tr = GetObjectPtr(LIST_exd_course_trigger);
date_tr = GetObjectPtr(SELECTOR_exd_date);
time_tr = GetObjectPtr(SELECTOR_exd_time);
gExamDetailsNumCourses = CountCourses();
gExamDetailsItemList = (Char **) MemPtrNew(gExamDetailsNumCourses * sizeof(Char *));
gExamDetailsItemIDs = (UInt16 *) MemPtrNew(gExamDetailsNumCourses * sizeof(UInt16));
gExamDetailsItemInd = (UInt16 *) MemPtrNew(gExamDetailsNumCourses * sizeof(UInt16));
if (gExamsLastSelRowUID == 0) {
// ADD
DateTimeType dt;
selectedCourse = CourseListGen(gExamDetailsItemList, gExamDetailsItemIDs, gExamDetailsItemInd, gExamDetailsNumCourses, 0, CLIST_SEARCH_INDEX);
TimSecondsToDateTime(TimGetSeconds(), &dt);
gExamDetailsDate.year=dt.year-MAC_SHIT_YEAR_CONSTANT;
gExamDetailsDate.month=dt.month;
gExamDetailsDate.day=dt.day;
gExamDetailsBegin.hours=14;
gExamDetailsBegin.minutes=0;
gExamDetailsEnd.hours=15;
gExamDetailsEnd.minutes=30;
} else {
MemHandle mex, mRoom, old;
ExamDBRecord *ex;
UInt16 index=0;
Char *buffer;
FieldType *fldRoom;
fldRoom=GetObjectPtr(FIELD_exd_room);
DmFindRecordByID(DatabaseGetRefN(DB_MAIN), gExamsLastSelRowUID, &index);
mex = DmQueryRecord(DatabaseGetRefN(DB_MAIN), index);
ex = (ExamDBRecord *)MemHandleLock(mex);
selectedCourse = CourseListGen(gExamDetailsItemList, gExamDetailsItemIDs, gExamDetailsItemInd, gExamDetailsNumCourses, ex->course, CLIST_SEARCH_ID);
gExamDetailsDate.year=ex->date.year;
gExamDetailsDate.month=ex->date.month;
gExamDetailsDate.day=ex->date.day;
gExamDetailsBegin.hours=ex->begin.hours;
gExamDetailsBegin.minutes=ex->begin.minutes;
gExamDetailsEnd.hours=ex->end.hours;
gExamDetailsEnd.minutes=ex->end.minutes;
// Copy contents to the memory handle
mRoom=MemHandleNew(StrLen(ex->room)+1);
buffer=(Char *)MemHandleLock(mRoom);
MemSet(buffer, MemPtrSize(buffer), 0);
StrNCopy(buffer, ex->room, StrLen(ex->room));
MemHandleUnlock(mRoom);
// Load fields
old = FldGetTextHandle(fldRoom);
FldSetTextHandle(fldRoom, mRoom);
if (old != NULL) MemHandleFree(old);
MemHandleUnlock(mex);
}
LstSetListChoices(course, gExamDetailsItemList, gExamDetailsNumCourses);
if (gExamDetailsNumCourses < 5) LstSetHeight(course, gExamDetailsNumCourses);
else LstSetHeight(course, 5);
LstSetSelection(course, selectedCourse);
CtlSetLabel(course_tr, LstGetSelectionText(course, selectedCourse));
ExamDetailsSetTriggers(date_tr, time_tr);
EditTimeSetSelectorText(time_tr, &gExamDetailsBegin, &gExamDetailsEnd, gExamDetailsTimeTrigger);
}
Boolean StartScummVM() {
Char **argvP;
UInt8 lightspeed, argc = 0;
UInt32 stackSize;
Boolean toLauncher, direct, isARM;
UInt8 engine;
Char num[6];
UInt16 index = GamGetSelected();
argvP = ArgsInit();
direct = false;
// start command line (exec name)
ArgsAdd(&argvP[argc], "-", NULL, &argc);
// no game selected
if (index == dmMaxRecordIndex) {
ListPtr listP;
UInt16 whichButton;
// init form
FormPtr frmP = FrmInitForm(EngineForm);
listP = (ListType *)FrmGetObjectPtr(frmP, FrmGetObjectIndex(frmP, EngineListList));
itemsText = (Char **)MemPtrNew(ENGINE_COUNT * sizeof(Char *));
for (int i = 0; i < ENGINE_COUNT; i++)
itemsText[i] = (Char *)engines[i].nameP;
LstSetListChoices (listP, itemsText, ENGINE_COUNT);
LstSetSelection(listP, 0);
whichButton = FrmDoDialog(frmP);
engine = LstGetSelection(listP);
FrmDeleteForm(frmP);
MemPtrFree(itemsText);
itemsText = NULL;
if (whichButton == EngineCancelButton) {
if (bDirectMode) {
// and force exit if nothing selected
EventType event;
event.eType = keyDownEvent;
event.data.keyDown.chr = vchrLaunch;
event.data.keyDown.modifiers = commandKeyMask;
EvtAddUniqueEventToQueue(&event, 0, true);
}
// free args
ArgsFree(argvP);
return false;
}
// default values
if (bDirectMode)
gPrefs->card.volRefNum = parseCards(); // always use the first removable card available (?)
gVars->filter = true;
gVars->palmVolume = 50;
gVars->fmQuality = FM_QUALITY_INI;
direct = true;
// somthing selected
} else {
Char pathP[256];
MemHandle recordH;
GameInfoType *gameInfoP;
recordH = DmQueryRecord(gameDB,index);
gameInfoP = (GameInfoType *)MemHandleLock(recordH);
engine = gameInfoP->engine;
// build path
StrCopy(pathP,"/Palm/Programs/ScummVM/Games/");
if (gameInfoP->pathP[0] == '/')
StrCopy(pathP, gameInfoP->pathP);
else if (!(gameInfoP->pathP[0] == '.' && StrLen(gameInfoP->pathP) == 1))
StrCat(pathP, gameInfoP->pathP);
// path
ArgsAdd(&argvP[argc], "-p", pathP, &argc);
// language
if (gameInfoP->language > 0) {
const Char *lang = "zh\0cz\0gb\0en\0fr\0de\0hb\0it\0jp\0kr\0pl\0pt\0ru\0es\0se\0";
ArgsAdd(&argvP[argc], "-q", (lang + (gameInfoP->language - 1) * 3), &argc);
}
// fullscreen ?
if (gameInfoP->fullscreen)
ArgsAdd(&argvP[argc], "-f", NULL, &argc);
// aspect-ratio ?
ArgsAdd(&argvP[argc], (gameInfoP->aspectRatio ? "--aspect-ratio" : "--no-aspect-ratio"), NULL, &argc);
// gfx mode
gVars->filter = gameInfoP->filter;
switch (gameInfoP->renderMode) {
case 1:
ArgsAdd(&argvP[argc], "--render-mode=", "amiga", &argc);
break;
case 2:
ArgsAdd(&argvP[argc], "--render-mode=", "cga", &argc);
break;
case 3:
ArgsAdd(&argvP[argc], "--render-mode=", "ega", &argc);
break;
case 4:
ArgsAdd(&argvP[argc], "--render-mode=", "hercAmber", &argc);
break;
case 5:
ArgsAdd(&argvP[argc], "--render-mode=", "hercGreen", &argc);
break;
}
switch (gameInfoP->gfxMode) {
case 1:
ArgsAdd(&argvP[argc], "-g", "wide", &argc);
break;
default:
ArgsAdd(&argvP[argc], "-g", "1x", &argc);
break;
}
// load state
if (gameInfoP->autoLoad) {
StrIToA(num, gameInfoP->loadSlot);
ArgsAdd(&argvP[argc], "-x", num, &argc);
}
// boot script parameter
if (gameInfoP->bootParam) {
StrIToA(num, gameInfoP->bootValue);
ArgsAdd(&argvP[argc], "-b", num, &argc);
}
// not a PC version
if (gameInfoP->setPlatform) {
static const char *platform[] = {
"3do",
"acorn",
"amiga",
"atari",
"c64",
"pc",
"fmtowns",
"linux",
"mac",
"nes",
"segacd",
"windows"
};
ArgsAdd(&argvP[argc], "--platform=", platform[gameInfoP->platform], &argc);
}
// subtitles
if (gameInfoP->subtitles)
ArgsAdd(&argvP[argc], "-n", NULL, &argc);
// multi midi ?
if (gameInfoP->musicInfo.sound.multiMidi)
ArgsAdd(&argvP[argc], "--multi-midi", NULL, &argc);
if (engine == ENGINE_SCUMM) {
// music tempo
StrIToA(num, gameInfoP->musicInfo.sound.tempo);
ArgsAdd(&argvP[argc], "--tempo=", num, &argc);
}
// talk speed
if (gameInfoP->talkSpeed) {
StrIToA(num, gameInfoP->talkValue);
ArgsAdd(&argvP[argc], "--talkspeed=", num, &argc);
}
// music driver
if (gameInfoP->musicInfo.sound.music) {
static char *drv[] = {
"auto",
"null",
"adlib",
"towns",
"pcjr",
"native",
"pcspk"
};
if (StrCompare(drv[gameInfoP->musicInfo.sound.drvMusic], "native") == 0) {
if (OPTIONS_TST(kOptDeviceZodiac))
ArgsAdd(&argvP[argc], "-e", "zodiac", &argc); // Tapwave Zodiac
else if (OPTIONS_TST(kOptSonyPa1LibAPI))
ArgsAdd(&argvP[argc], "-e", "ypa1", &argc); // Pa1Lib devices
else
ArgsAdd(&argvP[argc], "-e", "auto", &argc); // no driver, switch to auto
} else {
ArgsAdd(&argvP[argc], "-e", drv[gameInfoP->musicInfo.sound.drvMusic], &argc);
}
// output rate
UInt32 rates[] = {4000, 8000, 11025, 22050, 44100};
StrIToA(num, rates[gameInfoP->musicInfo.sound.rate]);
ArgsAdd(&argvP[argc], "--output-rate=", num, &argc);
// FM quality
gVars->fmQuality = gameInfoP->fmQuality;
} else {
ArgsAdd(&argvP[argc], "-e", "null", &argc);
}
// volume control
StrIToA(num, gameInfoP->musicInfo.volume.sfx);
ArgsAdd(&argvP[argc], "-s", num, &argc);
StrIToA(num, gameInfoP->musicInfo.volume.music);
ArgsAdd(&argvP[argc], "-m", num, &argc);
StrIToA(num, gameInfoP->musicInfo.volume.speech);
ArgsAdd(&argvP[argc], "-r", num, &argc);
// game name
ArgsAdd(&argvP[argc], gameInfoP->gameP, NULL, &argc);
// others globals data
gVars->CD.enable = gameInfoP->musicInfo.sound.CD;
gVars->CD.driver = gameInfoP->musicInfo.sound.drvCD;
gVars->CD.format = gameInfoP->musicInfo.sound.frtCD;
gVars->CD.volume = gameInfoP->musicInfo.volume.audiocd;
gVars->CD.defaultTrackLength = gameInfoP->musicInfo.sound.defaultTrackLength;
gVars->CD.firstTrack = gameInfoP->musicInfo.sound.firstTrack;
gVars->palmVolume = gameInfoP->musicInfo.sound.music ? gameInfoP->musicInfo.volume.palm : 0;
MemHandleUnlock(recordH);
} // end no game / game selected
// common command line options
// debug level
if (gPrefs->debug) {
StrIToA(num, gPrefs->debugLevel);
ArgsAdd(&argvP[argc], "-d", num, &argc);
}
if (engine == ENGINE_QUEEN || engine == ENGINE_SKY) {
// alternative intro ?
if (gPrefs->altIntro)
ArgsAdd(&argvP[argc], "--alt-intro", NULL, &argc);
}
if (engine == ENGINE_SCUMM) {
// demo mode ?
if (gPrefs->demoMode)
ArgsAdd(&argvP[argc], "--demo-mode", NULL, &argc);
}
// copy protection ?
if (gPrefs->copyProtection)
ArgsAdd(&argvP[argc], "--copy-protection", NULL, &argc);
// exceed max args ?
if (argc > MAX_ARG)
FrmCustomAlert(FrmErrorAlert, "Too many parameters.",0,0);
// set some common options
stackSize = (gPrefs->setStack ? STACK_LARGER : STACK_DEFAULT);
lightspeed= (gPrefs->lightspeed.enable ? gPrefs->lightspeed.mode : 255);
toLauncher= (gPrefs->exitLauncher);
// gVars values
// (gVars->HRrefNum defined in checkHRmode on Clié)
gVars->VFS.volRefNum = gPrefs->card.volRefNum;
gVars->vibrator = gPrefs->vibrator;
gVars->stdPalette = gPrefs->stdPalette;
gVars->VFS.cacheSize = (gPrefs->card.useCache ? gPrefs->card.cacheSize : 0);
gVars->indicator.showLED= gPrefs->card.showLED;
gVars->stylusClick = gPrefs->stylusClick;
gVars->autoSave = (gPrefs->autoSave ? gPrefs->autoSavePeriod : -1);
gVars->advancedMode = gPrefs->advancedMode;
gVars->arrowKeys = gPrefs->arrowKeys;
// user params
HWR_RSTALL();
if (gPrefs->goLCD)
HWR_SET(INIT_GOLCD);
else
OPTIONS_RST(kOptGoLcdAPI);
if (!gPrefs->autoOff)
HWR_SET(INIT_AUTOOFF);
if (gVars->vibrator)
HWR_SET(INIT_VIBRATOR);
/* ????
if ( musicDriver == 1 ||
musicDriver == 3 ||
musicDriver == 4 ||
musicDriver == sysInvalidRefNum) {
HWR_SET(INIT_PA1LIB);
}
*/
if (ModImport(gVars->VFS.volRefNum, engine, &isARM) != errNone) {
if (bDirectMode) {
// and force exit if nothing selected
EventType event;
event.eType = keyDownEvent;
event.data.keyDown.chr = vchrLaunch;
event.data.keyDown.modifiers = commandKeyMask;
EvtAddUniqueEventToQueue(&event, 0, true);
}
ArgsFree(argvP);
return false;
}
// reset mode if screen rotation occured (DIA only)
if (!direct && OPTIONS_TST(kOptCollapsible)) {
UInt8 mode = PalmScreenSize(0,0, &(gVars->screenFullWidth), &(gVars->screenFullHeight));
OPTIONS_RST(kOptModeLandscape);
OPTIONS_SET((mode == PALM_LANDSCAPE) ? kOptModeLandscape : kOptNone);
}
// free and save globals pref memory
GamCloseDatabase(false);
FrmCloseAllForms();
SavePrefs();
{
UInt16 cardNo;
UInt32 dbID;
LaunchParamType *cmdPBP = (LaunchParamType *)MemPtrNew(sizeof(LaunchParamType));
MemPtrSetOwner(cmdPBP, 0);
MemPtrSetOwner(gVars, 0);
ArgsSetOwner(argvP, 0);
cardNo = 0;
dbID = DmFindDatabase(0, "ScummVM-Engine");
if (isARM)
FtrSet(appFileCreator, ftrStack , (stackSize * 4));
else
ModSetStack(stackSize, cardNo, dbID);
cmdPBP->args.argc = argc;
cmdPBP->args.argv = argvP;
cmdPBP->gVars = gVars;
cmdPBP->lightspeed = lightspeed;
cmdPBP->exitLauncher = toLauncher;
SysUIAppSwitch(cardNo, dbID, sysAppLaunchCmdNormalLaunch, cmdPBP);
bLaunched = true;
}
return false;
}
/********************************************************************************
* Description: this is the function responsible for checking the
* input password value of the authentication form.
* ******************************************************************************/
static void
checkPassword (void)
{
MemPtr pass1, scratch = NULL;
char *input;
UInt16 index = 0;
MemHandle rec;
mdKey in;
ListType *list;
// compact text and get a pointer.
FldCompactText (GetObjectFromActiveForm (PasswordField));
input = FldGetTextPtr (GetObjectFromActiveForm (PasswordField));
list = GetObjectFromActiveForm (selPopupList);
// if SysPass is defined, free it. this happens when Strip locks
// itself after the timeout.
if (SysPass)
MemPtrFree (SysPass);
// if its the first time the user has used the program we need
// to set some things up.
if (input && StrLen (input))
{
// read the password from the database, decrypt with the input text.
if ((rec = DmQueryRecord (PasswordDB, index)))
{
pass1 = MemHandleLock (rec);
if ((scratch = MemPtrNew (24)))
{
UInt16 chk = LstGetSelection (list);
//printf("%d\n", LstGetSelection(list));
switch (chk)
{
case 0:
UnpackPassword_old (pass1, scratch, input, 1);
break;
case 1:
UnpackPassword_old (pass1, scratch, input, 2);
break;
case 2:
UnpackPassword_old (pass1, scratch, input, 0);
break;
}
}
MemHandleUnlock (rec);
}
// the message digest of the password they provided should be exactly the
// same as the message digest that was just decrypted out of the password
// database. Do a MemCmp to make sure they are the same.
md5_string (input, in);
if ((!MemCmp (in, scratch, 16)) && input)
{
// if so, copy the password onto the system-password
if ((SysPass = MemPtrNew (StrLen (input) + 1)))
StrCopy (SysPass, input);
if (scratch)
MemPtrFree (scratch);
md_string(SysPass, NewSysPass);
cryptSwitch (LstGetSelection (list));
}
else
{
// FAILURE!!!!!!
// free the memory and tell the user they entered the wrong password.
FieldType *fld = GetObjectFromActiveForm (PasswordField);
FrmCustomAlert (GenericError,
"The password you entered is incorrect", NULL,
NULL);
FldSetSelection (fld, 0, FldGetTextLength (fld));
LstDrawList (list);
if (scratch)
{
MemPtrFree (scratch);
SysPass = NULL;
}
}
}
// null string is always wrong!!!
else
{
FrmCustomAlert (GenericError, "You forgot to enter a password!!",
NULL, NULL);
LstDrawList (list);
}
}
Boolean BookmarksFormHandleEvent(EventType * event)
{
Boolean handled = false;
FormType * frm;
ListType * bkmList, * sortTypeList;
char * listTxt;
UInt16 bookmarksCount;
AppContext* appContext = GetAppContext();
frm = FrmGetActiveForm();
switch (event->eType)
{
case frmOpenEvent:
OpenBookmarksDB(appContext, appContext->prefs.bookmarksSortType);
bkmList = (ListType *) FrmGetObjectPtr(frm, FrmGetObjectIndex(frm, listBookmarks));
bookmarksCount = BookmarksWordCount(appContext);
Assert( 0 != bookmarksCount );
LstSetDrawFunction(bkmList, BookmarksListDrawFunc);
LstSetListChoices(bkmList, NULL, bookmarksCount);
sortTypeList = (ListType *) FrmGetObjectPtr(frm, FrmGetObjectIndex(frm, listSortBy));
// list position matches enums for simplicity
LstSetSelection(sortTypeList, (Int16)appContext->prefs.bookmarksSortType);
listTxt = LstGetSelectionText(sortTypeList, appContext->prefs.bookmarksSortType);
CtlSetLabel((ControlType *)FrmGetObjectPtr(frm,FrmGetObjectIndex(frm,popupSortBy)), listTxt);
FrmDrawForm(frm);
handled = true;
break;
case winDisplayChangedEvent:
handled= BookmarksFormDisplayChanged(appContext, frm);
break;
case ctlSelectEvent:
switch (event->data.ctlSelect.controlID)
{
case buttonCancel:
CloseBookmarksDB(appContext);
FrmReturnToForm(0);
handled = true;
break;
case popupSortBy:
// do nothing
break;
default:
Assert(false);
break;
}
break;
case popSelectEvent:
switch (event->data.popSelect.listID)
{
case listSortBy:
Assert( appContext->currBookmarkDbType == appContext->prefs.bookmarksSortType );
if ((BookmarkSortType) event->data.popSelect.selection != appContext->prefs.bookmarksSortType)
{
// we changed sorting type
sortTypeList = (ListType *) FrmGetObjectPtr(frm, FrmGetObjectIndex(frm, listSortBy));
listTxt = LstGetSelectionText(sortTypeList, event->data.popSelect.selection);
CtlSetLabel((ControlType *)FrmGetObjectPtr(frm,FrmGetObjectIndex(frm,popupSortBy)), listTxt);
// list position matches enums for simplicity
OpenBookmarksDB(appContext, (BookmarkSortType) event->data.popSelect.selection);
appContext->prefs.bookmarksSortType = (BookmarkSortType) event->data.popSelect.selection;
#ifdef DEBUG
// word count shouldn't change
bookmarksCount = BookmarksWordCount(appContext);
bkmList = (ListType *) FrmGetObjectPtr(frm, FrmGetObjectIndex(frm, listBookmarks));
Assert( LstGetNumberOfItems(bkmList) == bookmarksCount );
#endif
FrmDrawForm(frm);
}
handled = true;
break;
default:
Assert(false);
break;
}
break;
case lstSelectEvent:
{
MemHandle recHandle;
char * word;
recHandle = DmQueryRecord(appContext->bookmarksDb, event->data.lstSelect.selection);
Assert( recHandle ); // no reason it shouldn't work
if (recHandle)
{
word = (char*)MemHandleLock(recHandle);
Assert(word);
#ifndef I_NOAH
appContext->currentWord = dictGetFirstMatching(GetCurrentFile(appContext), word);
MemHandleUnlock(recHandle);
SendEvtWithType(evtNewWordSelected);
#else
FrmReturnToForm(0);
StartWordLookup(appContext, word);
MemHandleUnlock(recHandle);
#endif
}
CloseBookmarksDB(appContext);
#ifndef I_NOAH
FrmReturnToForm(0);
#endif
handled = true;
}
default:
break;
}
return handled;
}
/***********************************************************************
*
* FUNCTION: ApptGetAppointments
*
* DESCRIPTION: This routine returns a list of appointments that are on
* the date specified
*
* PARAMETERS: dbP - pointer to the database
* date - date to search for
* countP - number of appointments on the specified
* day (returned value)
*
* RETURNED: handle of the appointment list (ApptInfoType)
*
* REVISION HISTORY:
* Name Date Description
* ---- ---- -----------
* art 6/15/95 Initial Revision
*
***********************************************************************/
MemHandle ApptGetAppointments (DmOpenRef dbP, DateType date, UInt16 * countP) {
Err error;
Int16 result;
Int16 count = 0;
UInt16 recordNum;
Boolean repeats;
MemHandle recordH;
MemHandle apptListH;
ApptInfoPtr apptList;
ApptDBRecordType apptRec;
ApptPackedDBRecordPtr r;
// Allocated a block to hold the appointment list.
apptListH = MemHandleNew (sizeof (ApptInfoType) * apptMaxPerDay);
ErrFatalDisplayIf(!apptListH, "Out of memory");
if (! apptListH) return (0);
apptList = MemHandleLock (apptListH);
// Find the first non-repeating appointment of the day.
if (ApptFindFirst (dbP, date, &recordNum)) {
while (count < apptMaxPerDay) {
// Check if the appointment is on the date passed, if it is
// add it to the appointment list.
recordH = DmQueryRecord (dbP, recordNum);
r = MemHandleLock (recordH);
result = DateCompare (r->when.date, date);
if (result == 0) {
// Add the record to the appoitment list.
apptList[count].startTime = r->when.startTime;
apptList[count].endTime = r->when.endTime;
apptList[count].recordNum = recordNum;
count++;
}
MemHandleUnlock (recordH);
if (result != 0) break;
// Get the next record.
error = DmSeekRecordInCategory (dbP, &recordNum, 1,
dmSeekForward,
dmAllCategories);
if (error == dmErrSeekFailed) break;
}
}
// Add the repeating appointments to the list. Repeating appointments
// are stored at the beginning of the database.
recordNum = 0;
while (count < apptMaxPerDay) {
recordH = DmQueryNextInCategory (dbP, &recordNum, dmAllCategories);
if (! recordH) break;
r = (ApptPackedDBRecordPtr) MemHandleLock (recordH);
repeats = (r->flags.repeat != 0);
if (repeats) {
ApptUnpack (r, &apptRec);
if (ApptRepeatsOnDate (&apptRec, date)) {
// Add the record to the appoitment list.
apptList[count].startTime = r->when.startTime;
apptList[count].endTime = r->when.endTime;
apptList[count].recordNum = recordNum;
count++;
}
}
MemHandleUnlock (recordH);
// If the record has no repeating info we've reached the end of the
// repeating appointments.
if (! repeats) break;
recordNum++;
}
// Sort the list by start time.
// SysInsertionSort (apptList, count, sizeof (ApptInfoType),
// ApptListCompare, 0L);
// If there are no appointments on the specified day, free the appointment
// list.
if (count == 0) {
MemPtrFree (apptList);
apptListH = 0;
}
// Resize the appointment list block to release any unused space.
else {
MemHandleUnlock (apptListH);
MemHandleResize (apptListH, count * sizeof (ApptInfoType));
}
*countP = count;
return (apptListH);
}
/************************************************************
*
* FUNCTION: ApptChangeRecord
*
* DESCRIPTION: Change a record in the Appointment Database
*
* PARAMETERS: database pointer
* database index
* database record
* changed fields
*
* RETURNS: ##0 if successful, errorcode if not
*
* CREATED: 1/25/95
*
* BY: Roger Flores
*
* COMMENTS: Records are not stored with extra padding - they
* are always resized to their exact storage space. This avoids
* a database compression issue. The code works as follows:
*
* 1) get the size of the new record
* 2) make the new record
* 3) pack the packed record plus the changes into the new record
* 4) if the sort position is changes move to the new position
* 5) attach in position
*
*************************************************************/
Err ApptChangeRecord(DmOpenRef dbP, UInt16 *index, ApptDBRecordPtr r,
ApptDBRecordFlags changedFields) {
Err result;
Int16 newIndex;
UInt16 attributes;
Boolean dontMove;
MemHandle oldH;
MemHandle srcH;
MemHandle dstH;
ApptDBRecordType src;
ApptPackedDBRecordPtr dst = 0;
ApptPackedDBRecordPtr cmp;
// We do not assume that r is completely valid so we get a valid
// ApptDBRecordPtr...
if ((result = ApptGetRecord(dbP, *index, &src, &srcH)) != 0)
return result;
// and we apply the changes to it.
if (changedFields.when)
src.when = r->when;
if (changedFields.alarm)
src.alarm = r->alarm;
if (changedFields.repeat)
src.repeat = r->repeat;
if (changedFields.exceptions)
src.exceptions = r->exceptions;
if (changedFields.description)
src.description = r->description;
if (changedFields.note)
src.note = r->note;
// Allocate a new chunk with the correct size and pack the data from
// the unpacked record into it.
dstH = DmNewHandle(dbP, (UInt32) ApptPackedSize(&src));
if (dstH) {
dst = MemHandleLock (dstH);
ApptPack (&src, dst);
}
MemHandleUnlock (srcH);
if (dstH == NULL)
return dmErrMemError;
// If the sort position is changed move to the new position.
// Check if any of the key fields have changed.
if ((!changedFields.when) && (! changedFields.repeat))
goto attachRecord; // repeating events aren't in sorted order
// Make sure *index-1 < *index < *index+1, if so it's in sorted
// order. Leave it there.
if (*index > 0) {
// This record wasn't deleted and deleted records are at the end of the
// database so the prior record may not be deleted!
cmp = MemHandleLock (DmQueryRecord(dbP, *index-1));
dontMove = (ApptComparePackedRecords (cmp, dst, 0, NULL, NULL, 0)
<= 0);
MemPtrUnlock (cmp);
} else
dontMove = true;
if (dontMove && (*index+1 < DmNumRecords (dbP))) {
DmRecordInfo(dbP, *index+1, &attributes, NULL, NULL);
if ( ! (attributes & dmRecAttrDelete) ) {
cmp = MemHandleLock (DmQueryRecord(dbP, *index+1));
dontMove &= (ApptComparePackedRecords (dst, cmp, 0, NULL, NULL,
0) <= 0);
MemPtrUnlock (cmp);
}
}
if (dontMove)
goto attachRecord;
// The record isn't in the right position. Move it.
newIndex = ApptFindSortPosition (dbP, dst);
DmMoveRecord (dbP, *index, newIndex);
if (newIndex > *index) newIndex--;
*index = newIndex; // return new position
attachRecord:
// Attach the new record to the old index, the preserves the
// category and record id.
result = DmAttachRecord (dbP, index, dstH, &oldH);
MemPtrUnlock(dst);
if (result) return result;
MemHandleFree(oldH);
return 0;
}
Boolean
ExamsFormHandleEvent(EventPtr event)
{
FormPtr frm=FrmGetActiveForm();
Boolean handled = false;
Boolean categoryEdited, reDraw=false;
UInt16 category, numRecords;
ControlType *ctl;
UInt32 *recordList;
if (event->eType == ctlSelectEvent) {
// button handling
switch (event->data.ctlSelect.controlID) {
case BUTTON_ex_back:
handled=true;
FrmGotoForm(FORM_main);
break;
case BUTTON_ex_add:
handled=true;
if (CountCourses() > 0) {
gExamsLastSelRowUID=0;
FrmPopupForm(FORM_exam_details);
} else {
FrmAlert(ALERT_nocourses);
}
break;
case BUTTON_ex_edit:
handled=true;
gExamsLastSelRowUID=TblGetRowData(GetObjectPtr(TABLE_exams), gExamsSelRow);
FrmPopupForm(FORM_exam_details);
break;
case BUTTON_ex_note:
{
UInt16 index=0;
handled=true;
gExamsLastSelRowUID=TblGetRowData(GetObjectPtr(TABLE_exams), gExamsSelRow);
DmFindRecordByID(DatabaseGetRefN(DB_MAIN), gExamsLastSelRowUID, &index);
NoteSet(index, FORM_exams);
FrmPopupForm(NewNoteView);
break;
}
case BUTTON_ex_del:
handled=true;
gExamsLastSelRowUID=TblGetRowData(GetObjectPtr(TABLE_exams), gExamsSelRow);
ExamDelete();
break;
case BUTTON_ex_beam:
handled=true;
gExamsLastSelRowUID=TblGetRowData(GetObjectPtr(TABLE_exams), gExamsSelRow);
ExamBeam();
break;
case LIST_ex_cat_trigger:
handled=true;
category=DatabaseGetCat();
numRecords=DmNumRecordsInCategory(DatabaseGetRef(), DELETE_CATEGORY);
recordList=(UInt32 *)MemPtrNew(numRecords * sizeof(UInt32));
CatPreEdit(numRecords, recordList);
categoryEdited = CategorySelect(DatabaseGetRef(), frm,
LIST_ex_cat_trigger, LIST_ex_cat, false,
&category, gCategoryName, 0,
STRING_cat_edit); // categoryDefaultEditCategoryString
if (categoryEdited || (category != DatabaseGetCat())) {
reDraw=true;
DatabaseSetCat(category);
ctl = GetObjectPtr(LIST_ex_cat_trigger);
CategoryGetName(DatabaseGetRef(), category, gCategoryName);
CategorySetTriggerLabel(ctl, gCategoryName);
}
CatPostEdit(numRecords, recordList);
if (reDraw) {
gExamsOffset=0;
gExamsSelRow=0;
FrmUpdateForm(FORM_exams, frmRedrawUpdateCode);
}
if (recordList != NULL) MemPtrFree((MemPtr)recordList);
break;
default:
break;
}
} else if (event->eType == tblEnterEvent) {
UInt16 i;
if (event->data.tblEnter.column == EXCOL_DONE) {
handled=false;
} else if (event->data.tblEnter.column == EXCOL_NOTE) {
MemHandle m;
Boolean hasNote=false;
gExamsSelRow=event->data.tblEnter.row;
for (i=0; i < TblGetNumberOfRows(event->data.tblEnter.pTable); ++i) {
RectangleType r;
TblGetItemBounds(event->data.tblEnter.pTable, i, EXCOL_SELI, &r);
TableDrawSelection(event->data.tblEnter.pTable, i, event->data.tblEnter.column, &r);
}
m = DmQueryRecord(DatabaseGetRefN(DB_MAIN), TblGetRowID(event->data.tblEnter.pTable, event->data.tblEnter.row));
if (m) {
ExamDBRecord *ex = (ExamDBRecord *)MemHandleLock(m);
if (ex->note) hasNote = true;
else hasNote = false;
MemHandleUnlock(m);
}
if (hasNote) {
Coord newPointX, newPointY;
Boolean isPenDown=false, drawn=false;
RectangleType fieldBounds;
IndexedColorType curForeColor, curBackColor, curTextColor;
Char noteSymb[2] = { GADGET_NOTESYMBOL, 0 };
FontID oldFont;
EvtGetPen(&newPointX, &newPointY, &isPenDown);
TblGetItemBounds(event->data.tblEnter.pTable, event->data.tblEnter.row, EXCOL_NOTE, &fieldBounds);
oldFont = FntSetFont(symbolFont);
while (isPenDown){
if (! drawn && RctPtInRectangle(newPointX, newPointY, &fieldBounds)) {
curForeColor = WinSetForeColor(UIColorGetTableEntryIndex(UIObjectSelectedForeground));
curBackColor = WinSetBackColor(UIColorGetTableEntryIndex(UIObjectSelectedFill));
curTextColor = WinSetTextColor(UIColorGetTableEntryIndex(UIObjectSelectedForeground));
TNDrawCharsToFitWidth(noteSymb, &fieldBounds);
WinSetForeColor(curForeColor);
WinSetForeColor(curBackColor);
WinSetForeColor(curTextColor);
drawn = true;
} else if (drawn && ! RctPtInRectangle(newPointX, newPointY, &fieldBounds)) {
curForeColor = WinSetForeColor(UIColorGetTableEntryIndex(UIObjectForeground));
curBackColor = WinSetBackColor(UIColorGetTableEntryIndex(UIObjectFill));
curTextColor = WinSetTextColor(UIColorGetTableEntryIndex(UIObjectForeground));
TNDrawCharsToFitWidth(noteSymb, &fieldBounds);
WinSetForeColor(curForeColor);
WinSetForeColor(curBackColor);
WinSetForeColor(curTextColor);
drawn = false;
}
EvtGetPen(&newPointX, &newPointY, &isPenDown);
}
FntSetFont(oldFont);
} else {
handled = true;
}
} else {
gExamsSelRow=event->data.tblEnter.row;
for (i=0; i < TblGetNumberOfRows(event->data.tblEnter.pTable); ++i) {
RectangleType r;
TblGetItemBounds(event->data.tblEnter.pTable, i, EXCOL_SELI, &r);
TableDrawSelection(event->data.tblEnter.pTable, i, event->data.tblEnter.column, &r);
}
handled=true;
}
} else if (event->eType == tblSelectEvent) {
if (event->data.tblEnter.column == EXCOL_DONE) {
MemHandle mex;
ExamDBRecord *ex;
Boolean done=(TblGetItemInt(event->data.tblSelect.pTable, event->data.tblSelect.row, event->data.tblSelect.column) == 0) ? false : true;
UInt16 flags, index=TblGetRowID(event->data.tblSelect.pTable, event->data.tblSelect.row);
mex=DmGetRecord(DatabaseGetRefN(DB_MAIN), index);
ex = MemHandleLock(mex);
flags = ex->flags;
if (done) {
flags |= EX_FLAG_DONE;
} else {
flags &= (EX_FLAG_DONE ^ 0xFFFF);
}
DmWrite(ex, offsetof(ExamDBRecord, flags), &flags, sizeof(flags));
DmReleaseRecord(DatabaseGetRefN(DB_MAIN), index, false);
TblMarkRowInvalid(event->data.tblSelect.pTable, event->data.tblSelect.row);
TblRedrawTable(event->data.tblSelect.pTable);
MemHandleUnlock(mex);
} else if (event->data.tblEnter.column == EXCOL_NOTE) {
ControlType *ctl=GetObjectPtr(BUTTON_ex_note);
// Don't need code twice, just read ctlSelect Event for BUTTON_ex_note
CtlHitControl(ctl);
}
handled=true;
} else if (event->eType == ctlRepeatEvent) {
// Repeat buttons pressed
if( event->data.ctlRepeat.controlID == REPEAT_ex_up )
gExamsOffset -= 1;
else
gExamsOffset += 1;
ExamsTableInit();
TblMarkTableInvalid(GetObjectPtr(TABLE_exams));
TblRedrawTable(GetObjectPtr(TABLE_exams));
} else if (event->eType == keyDownEvent) {
// We have a hard button assigned and it was pressed
if (TxtCharIsHardKey(event->data.keyDown.modifiers, event->data.keyDown.chr)) {
if (! (event->data.keyDown.modifiers & poweredOnKeyMask)) {
FrmGotoForm(FORM_main);
handled = true;
}
}
} else if (event->eType == menuOpenEvent) {
return HandleMenuOpenEvent(event);
} else if (event->eType == menuEvent) {
// forwarding of menu events
return HandleMenuEvent(event->data.menu.itemID);
} else if (event->eType == frmOpenEvent) {
// initializes and draws the form
ControlType *ctl;
gExamsOffset=0;
ExamsTableInit();
FrmDrawForm (frm);
ctl = GetObjectPtr(LIST_ex_cat_trigger);
CategoryGetName (DatabaseGetRef(), DatabaseGetCat(), gCategoryName);
CategorySetTriggerLabel (ctl, gCategoryName);
handled = true;
} else if (event->eType == frmUpdateEvent) {
// redraws the form if needed
gExamsOffset=0;
ExamsTableInit();
FrmDrawForm(frm);
handled = false;
} else if (event->eType == frmCloseEvent) {
// this is done if form is closed
// TblEraseTable(GetObjectPtr(TABLE_exams));
// ExamsFormFree();
FrmEraseForm(frm);
}
return (handled);
}
/***********************************************************************
*
* FUNCTION: ApptFindFirst
*
* DESCRIPTION: This routine finds the first appointment on the specified
* day.
*
* PARAMETERS: dbP - pointer to the database
* date - date to search for
* indexP - pointer to the index of the first record on the
* specified day (returned value)
*
* RETURNED: true if a record has found
*
* REVISION HISTORY:
* Name Date Description
* ---- ---- -----------
* art 6/15/95 Initial Revision
*
***********************************************************************/
Boolean ApptFindFirst (DmOpenRef dbP, DateType date, UInt16 * indexP) {
Err err;
Int16 numOfRecords;
Int16 kmin, probe, i; // all positions in the database.
Int16 result = 0; // result of comparing two records
UInt16 index;
MemHandle recordH;
Boolean found = false;
ApptPackedDBRecordPtr r;
kmin = probe = 0;
numOfRecords = DmNumRecords(dbP);
while (numOfRecords > 0) {
i = numOfRecords >> 1;
probe = kmin + i;
index = probe;
recordH = DmQueryNextInCategory (dbP, &index, dmAllCategories);
if (recordH) {
r = (ApptPackedDBRecordPtr) MemHandleLock (recordH);
if (r->flags.repeat)
result = 1;
else
result = DateCompare (date, r->when.date);
MemHandleUnlock (recordH);
}
// If no handle, assume the record is deleted, deleted records
// are greater.
else
result = -1;
// If the date passed is less than the probe's date, keep searching.
if (result < 0)
numOfRecords = i;
// If the date passed is greater than the probe's date, keep searching.
else if (result > 0) {
kmin = probe + 1;
numOfRecords = numOfRecords - i - 1;
}
// If the records are equal find the first record on the day.
else {
found = true;
*indexP = index;
while (true) {
err = DmSeekRecordInCategory (dbP, &index, 1, dmSeekBackward,
dmAllCategories);
if (err == dmErrSeekFailed) break;
recordH = DmQueryRecord(dbP, index);
r = (ApptPackedDBRecordPtr) MemHandleLock (recordH);
if (r->flags.repeat)
result = 1;
else
result = DateCompare (date, r->when.date);
MemHandleUnlock (recordH);
if (result != 0) break;
*indexP = index;
}
break;
}
}
// If that were no appointments on the specified day, return the
// index of the next appointment (on a future day).
if (! found) {
if (result < 0)
*indexP = probe;
else
*indexP = probe + 1;
}
return (found);
}
