static void AudioCDTabInit() {
ControlType *cck3P;
FieldType *fld2P, *fld3P;
ListType *list1P, *list2P;
MemHandle lengthH, firstTrackH;
Char *lengthP, *firstTrackP;
cck3P = (ControlType *)GetObjectPtr(TabAudioCDMP3Checkbox);
fld2P = (FieldType *)GetObjectPtr(TabAudioCDLengthSecsField);
fld3P = (FieldType *)GetObjectPtr(TabAudioCDFirstTrackField);
list1P = (ListType *)GetObjectPtr(TabAudioCDDriverList);
list2P = (ListType *)GetObjectPtr(TabAudioCDFormatList);
LstSetSelection(list1P, gameInfoP->musicInfo.sound.drvCD);
CtlSetLabel((ControlType *)GetObjectPtr(TabAudioCDDriverPopTrigger), LstGetSelectionText(list1P, LstGetSelection(list1P)));
LstSetSelection(list2P, gameInfoP->musicInfo.sound.frtCD);
CtlSetLabel((ControlType *)GetObjectPtr(TabAudioCDFormatPopTrigger), LstGetSelectionText(list2P, LstGetSelection(list2P)));
CtlSetValue(cck3P, gameInfoP->musicInfo.sound.CD);
lengthH = MemHandleNew(FldGetMaxChars(fld2P)+1);
lengthP = (Char *)MemHandleLock(lengthH);
StrIToA(lengthP, gameInfoP->musicInfo.sound.defaultTrackLength);
MemHandleUnlock(lengthH);
FldSetTextHandle(fld2P, lengthH);
firstTrackH = MemHandleNew(FldGetMaxChars(fld3P)+1);
firstTrackP = (Char *)MemHandleLock(firstTrackH);
StrIToA(firstTrackP, gameInfoP->musicInfo.sound.firstTrack);
MemHandleUnlock(firstTrackH);
FldSetTextHandle(fld3P, firstTrackH);
}
/*
** 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);
}
/*****************************************************************************
* Function: GadgetDrawTime
*
* Description: Show a time in the grid
*****************************************************************************/
void
GadgetDrawTime(TimeType begin, TimeType end, UInt8 day, RGBColorType *color, UInt16 courseID, UInt8 num_times, UInt8 pos)
{
RectangleType rect;
RGBColorType prevColor, inverted;
// Sort out bogus requests, could be more intelligent, maybe later...
if (day >= gGadgetDaysNum) return;
// do nothing if Gadget has not yet been GadgetSet
if (! gForm) return;
if (! gGadgetID) return;
GadgetTimeSetRect(&rect, begin, end, day, num_times, pos);
TNSetForeColorRGB(color, &prevColor);
WinDrawRectangle(&rect, 0);
if ( (gPrefs.showTypes || gPrefs.showShortNames) && (rect.extent.y >= FntLineHeight())) {
RGBColorType oldBack, oldText;
// Get inverted color
inverted.r = 255 - color->r;
inverted.g = 255 - color->g;
inverted.b = 255 - color->b;
RctSetRectangle(&rect, rect.topLeft.x+2, rect.topLeft.y, rect.extent.x-4, rect.extent.y);
TNSetTextColorRGB(&inverted, &oldText);
TNSetBackColorRGB(color, &oldBack);
if (gPrefs.showTypes) {
MemHandle shortName=MemHandleNew(1);;
CourseTypeGetShortByCourseID(&shortName, courseID);
TNDrawCharsToFitWidth((Char *)MemHandleLock(shortName), &rect);
MemHandleUnlock(shortName);
MemHandleFree(shortName);
} else if (gPrefs.showShortNames) {
MemHandle courseName=MemHandleNew(1);
CourseGetName(courseID, &courseName, false);
TNDrawCharsToFitWidth((Char *)MemHandleLock(courseName), &rect);
MemHandleUnlock(courseName);
MemHandleFree(courseName);
}
TNSetBackColorRGB(&oldBack, NULL);
TNSetTextColorRGB(&oldText, NULL);
}
TNSetForeColorRGB(&prevColor, NULL);
}
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;
}
// Get user name e.g. Julian Smart
bool wxGetUserName(wxChar *buf, int maxSize)
{
*buf = wxT('\0');
// buffer allocation
MemHandle handle = MemHandleNew(maxSize-1);
if( handle == NULL )
return false;
// lock the buffer
char *id = (char *)MemHandleLock(handle);
if( id == NULL )
return false;
// get user's name
if( DlkGetSyncInfo(NULL, NULL, NULL, id, NULL, NULL) != errNone )
{
MemPtrUnlock(id);
return false;
}
wxStrlcpy(buf, wxSafeConvertMB2WX(id), maxSize);
// free the buffer
MemPtrUnlock(id);
return true;
}
void wxControl::SetFieldLabel(const wxString& label)
{
FieldType* field = (FieldType*)GetObjectPtr();
if(field==NULL)
return;
uint16_t newSize = label.Length() + 1;
MemHandle strHandle = FldGetTextHandle(field);
FldSetTextHandle(field, NULL );
if (strHandle)
{
if(MemHandleResize(strHandle, newSize)!=errNone)
strHandle = 0;
}
else
{
strHandle = MemHandleNew( newSize );
}
if(!strHandle)
return;
char* str = (char*) MemHandleLock( strHandle );
if(str==NULL)
return;
strcpy(str, label.c_str());
MemHandleUnlock(strHandle);
FldSetTextHandle(field, strHandle);
FldRecalculateField(field, true);
}
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);
}
}
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);
}
/***********************************************************************
*
* FUNCTION: MainFormInit
*
* DESCRIPTION: This routine initializes the MainForm form.
*
* PARAMETERS: frm - pointer to the MainForm form.
*
* RETURNED: nothing
*
* REVISION HISTORY:
*
*
***********************************************************************/
static void MainFormInit(FormPtr frmP)
{
FieldPtr fld;
char *ptr;
MemHandle mh = MemHandleNew (10);
fld = GetObjectPtr (MainSymbolField);
ptr = MemHandleLock (mh);
strcpy(ptr,"IBM");
FldSetTextHandle (fld, mh);
MemHandleUnlock(mh);
}
Err vfsFileDBGetRecord
(
FileRef ref,
UInt16 recIndex,
MemHandle *recHP,
UInt8 *recAttrP,
UInt32 *uniqueIDP
)
{
UInt32 offset;
UInt32 length;
MemPtr mp;
Char* buf;
file_rec_t axxFileRec;
Err err;
if (GetFileProperties (ref,&axxFileRec)!=errNone)
return dmErrNotRecordDB;
if (currFileDesc != axxFileRec.fd)
LoadOffsets(axxFileRec.fd);
/*Get the record byte position withing the file */
mp = MemHandleLock(moff);
ASSERT_MSG("AIM0", mp != 0);
offset = ((UInt32*)mp)[recIndex * 2];
length = recIndex < nrec ? ((UInt32*)mp)[recIndex * 2 + 2] :
axxFileRec.size;
MemHandleUnlock(moff);
if ( nrec < recIndex) {
return dmErrIndexOutOfRange;
}
length -= offset;
err=axxPacSeek(LibRef, axxFileRec.fd, offset, SEEK_SET);
if (err==AXXPAC_ERR_FILE_CLOSED) {
axxPacFD FileDesc;
/*This happens when the axxPac has entered into sleep mode */
FileDesc = axxPacOpen(LibRef, axxFileRec.name,axxFileRec.mode);
if (FileDesc<0)
return dmErrNotRecordDB;
/*The axxPac could have assigned a FileDesc different from before */
if (FileDesc!=axxFileRec.fd) {
UpdateFileDesc (ref,FileDesc);
axxFileRec.fd=FileDesc;
}
err=axxPacSeek(LibRef, FileDesc, offset, SEEK_SET);
}
*recHP = MemHandleNew(length);
buf = MemHandleLock(*recHP);
axxPacRead (LibRef, axxFileRec.fd, buf, length);
MemHandleUnlock(*recHP);
return errNone;
}
/*****************************************************************************
* Function: DrawCourses
*
* Description: local function to fill the course list
*****************************************************************************/
static void
DrawCourses(ListType *lst)
{
MemHandle mWebsite, mEmail, old;
Char *buffer;
FieldType *fldWebsite, *fldEmail;
gNumCourses=CountCourses();
gCourseList = (Char **) MemPtrNew(gNumCourses * sizeof(Char *));
gCourseInd = (UInt16 *) MemPtrNew(gNumCourses * sizeof(UInt16));
CourseListGen(gCourseList, NULL, gCourseInd, gNumCourses, 0, CLIST_SEARCH_INDEX);
LstSetListChoices(lst, gCourseList, gNumCourses);
LstSetSelection(lst, -1);
fldWebsite = GetObjectPtr(FIELD_cl_website);
fldEmail = GetObjectPtr(FIELD_cl_email);
mWebsite = MemHandleNew(4);
buffer = MemHandleLock(mWebsite);
MemSet(buffer, 4, 0);
StrCopy(buffer, "-?-");
MemHandleUnlock(mWebsite);
old = FldGetTextHandle(fldWebsite);
FldSetTextHandle(fldWebsite, mWebsite);
if (old != NULL) MemHandleFree(old);
mEmail = MemHandleNew(4);
buffer = MemHandleLock(mEmail);
MemSet(buffer, 4, 0);
StrCopy(buffer, "-?-");
MemHandleUnlock(mEmail);
old = FldGetTextHandle(fldEmail);
FldSetTextHandle(fldEmail, mEmail);
if (old != NULL) MemHandleFree(old);
}
FF_CM_Class *FF_CM_New(long sizeofCache, int *errCode)
{
FF_CM_Class *pCmGlobals = NULL;
tsiMemObject *mem = NULL;
char *cacheptr = NULL;
/* Create the memory object that will hold the cache */
mem = tsi_NewMemhandler( errCode );
assert( *errCode == 0 );
if (!*errCode)
{
/* Now actually allocate the memory for the cache */
#ifdef PALM
memH = MemHandleNew((UInt32)sizeofCache);
if (memH)
cacheptr = (char *)MemHandleLock(memH);
#else
cacheptr = (char *)tsi_AllocMem( mem, (size_t)sizeofCache );
#endif
if (cacheptr)
{
/* Using this memory block go and assemble the cache */
/* initialize pointers, setup data structures, etc. */
/* Prototype of CmInitializeCache has been change */
/* Original: void() (void **, size_t, char*) */
/* New : void*() (size_t, char*) */
/* It seems when GNU compiler inserting static func */
/* into body of caller, position of storing result */
/* are not decided correctly. */
/* DO NOT USE following type of functions */
#if 0
CmInitializeCache((void **)&pCmGlobals, sizeofCache, cacheptr);
#endif
pCmGlobals = CmInitializeCache(sizeofCache, cacheptr);
/* Save this pointer to the cache context within the global */
/* cache structure itself -- wild huh? */
pCmGlobals->mem = mem;
pCmGlobals->BitmapFilter = NULL;
pCmGlobals->filterParamsPtr = NULL;
}
else
{
*errCode = T2K_ERR_MEM_MALLOC_FAILED;
}
}
/* Return the self pointer back to the creating application */
return (pCmGlobals);
}
void SetFieldFromInt ( UInt16 fieldID, int data ) {
/* Temporary place in heap in order to store the string data */
MemHandle txtH;
txtH = MemHandleNew ( 10 );
if ( !txtH) return;
StrPrintF ( MemHandleLock(txtH), "%i", data);
SetFieldFromHandle ( fieldID, txtH);
MemHandleUnlock (txtH);
}
/* SetFieldTextFromStr -- Fills a field with a string
* Args:
* Word fieldID -- ID of field to fill, see cwimp.rpc file
* CharPtr strP -- String to fill ID with
* Returns:
* FieldPtr -- Ptr to the field set.
*/
FieldPtr SetFieldTextFromStr(Word fieldID, CharPtr strP)
{
VoidHand txtH;
txtH = MemHandleNew(StrLen(strP) + 1);
if(!txtH) return NULL;
StrCopy(MemHandleLock(txtH), strP);
// ToDo: SetFieldTextFromHandle should happen *before* unlock
MemHandleUnlock(txtH);
return SetFieldTextFromHandle(fieldID, txtH);
}
/***************************************************************
md_malloc
IN:
n = size to allocate
OUT:
pointer to the locked chunk
PURPOSE:
Allocate and lock a moveable chunk of memory.
****************************************************************/
Char * md_malloc(Int n)
{
VoidHand h;
VoidPtr p;
h = MemHandleNew((ULong) n); /* will this cast work?? apparently. */
if (!h) {
/* the caller might want to check this and die. */
return NULL;
}
p = MemHandleLock(h);
MemSet(p, n, 0); /* just to make really sure the memory is zeroed */
return p;
}
Boolean DoRenameFigure(void)
{
FormPtr prevFrm = FrmGetActiveForm();
int numFigures = TFigurerecordGetCount();
if ((currentFigure != noListSelection) && (currentFigure < numFigures)) {
TFigure_type *t1 = TFigurerecordGet(currentFigure);
if (t1) {
FormPtr frm = FrmInitForm(formRenameFigure);
FieldPtr field = (FieldPtr) FrmGetObjectPtr(frm,
FrmGetObjectIndex
(frm,
fieldFigureName));
MemHandle oldhText=FldGetTextHandle(field);
MemHandle hText = MemHandleNew(DESCSIZE);
char *titleptr = (char *) MemHandleLock(hText);
StrNCopy(titleptr, t1->name, DESCSIZE);
titleptr[DESCSIZE - 1] = 0;
MemPtrUnlock(titleptr);
FldSetTextHandle(field, (MemHandle) hText);
if (oldhText!=NULL) {
MemHandleFree(oldhText);
}
if (FrmDoDialog(frm) == buttonRFOK) {
hText = FldGetTextHandle(field);
titleptr = (char *) MemHandleLock(hText);
if ((titleptr) && StrLen(titleptr) > 0) {
StrNCopy(t1->name, titleptr, DESCSIZE);
t1->name[DESCSIZE - 1] = 0;
TFigurerecordChange(currentFigure, t1);
}
MemPtrUnlock(titleptr);
}
TFigureFree(t1);
if (prevFrm)
FrmSetActiveForm(prevFrm);
FrmDeleteForm(frm);
}
return true;
}
return false;
}
static ZDicFontGlobalsType * PrvMakeGlobals(UInt16 refNum)
{
ZDicFontGlobalsType * gP = NULL;
MemHandle gH;
SysLibTblEntryType * libEntryP;
/* Get library globals */
libEntryP = SysLibTblEntry(refNum);
ErrFatalDisplayIf(libEntryP == NULL, "invalid ZDicFont refNum");
/* Error check to make sure the globals don't already exist */
ErrFatalDisplayIf(libEntryP->globalsP, "ZDicFont globals already exist");
/* Allocate and initialize our library globals. */
gH = MemHandleNew(sizeof(ZDicFontGlobalsType));
if ( !gH )
return( NULL );
/* Save the handle of our library globals in the system library table */
/* entry so we can later retrieve it using SysLibTblEntry(). */
libEntryP->globalsP = (void*)gH;
/* Lock our globals (should not fail) */
gP = PrvLockGlobals(refNum);
ErrFatalDisplayIf(gP == NULL, "failed to lock ZDicFont globals");
/* Set the owner of our globals memory chunk to "system" (zero), so it won't get
* freed automatically by Memory Manager when the first application to call
* ZDicFontOpen exits. This is important if the library is going to stay open
* between apps. */
MemPtrSetOwner(gP, 0);
/* Initialize our library globals */
MemSet(gP, sizeof(ZDicFontGlobalsType), 0);
/* for convenience and debugging, save ref in globals structure */
gP->thisLibRefNum = refNum;
/* initial open count */
gP->openCount = 0;
/* return a pointer to our *locked* globals */
return( gP );
}
void setFieldFromStr ( UInt16 fieldID, Char * strP )
{
/* Temporary place in heap in order to store the string data */
MemHandle txtH;
/* Create new heap space */
txtH = MemHandleNew ( StrLen (strP) + 1 ) ;
if ( !txtH )
return;
/* Copy string to the heap, in order to be useful */
StrCopy (MemHandleLock(txtH), strP); /* Lock the current memory position, in order to accomply the specified task of setting text */
/* Set text of field to the selected heap data */
SetFieldFromHandle (fieldID, txtH);
/* Free lock for this (text) item */
MemHandleUnlock(txtH);
return;
}
static Err PrvCreateClientContext(ZDicFontGlobalsType * gP, UInt32 * clientContextP)
{
Err err = errNone;
MemHandle contextH;
ZDicFontClientContextType * contextP;
/* Error-check our parameters */
ErrFatalDisplayIf(gP == NULL, "null globals pointer");
ErrFatalDisplayIf(clientContextP == NULL, "null context variable pointer");
/* Initialize return variable */
*clientContextP = 0;
/* Allocate a new client context structure */
contextH = MemHandleNew(sizeof(ZDicFontClientContextType));
if ( !contextH )
{
err = memErrNotEnoughSpace;
}
else
{
/* save context chunk handle in return variable */
*clientContextP = (UInt32)contextH;
/* Initialize the context chunk */
contextP = (ZDicFontClientContextType *)MemHandleLock(contextH);
/* save address of open routine as signature to validate context */
contextP->libSignature = (void *)&ZDicFontOpen;
/* TODO: Insert code to initialize context members */
PrvUnlockContext(contextP);
/* increment context count (for debugging) */
gP->contextCount++;
ErrFatalDisplayIf(gP->contextCount == 0, "context count overflow");
}
return( err );
}
/*******************************************************************
* Function: getIndexForSystemID
* Description: return an index for a unique system id.
* ****************************************************************/
UInt16 getIndexForSystemID (DmOpenRef SystemDB, UInt16 sysid) {
UInt16 i, id, index = 0;
/* get the number of system records. note that we cant just
use totalItems++ because systems can be added and deleted
at will... */
UInt16 totalItems = DmNumRecordsInCategory (SystemDB, dmAllCategories);
Boolean stop = false;
/* iterate through the records, and we will return the highest
one it higher than the highest current value. */
for (i = 0; i < totalItems && !stop; i++) {
MemHandle scr;
if ((scr = MemHandleNew (1))) {
id = getSIDForSystemIndex (SystemDB, i);
if (id == sysid) index = i;
freeHandle (scr);
}
}
return index;
}
/*******************************************************************
* Function: getUniqueSystemID
* Description: return a unique system id that can be assigned to a
* new system.
* Note: SystemID 0 is reserved for the Unfiled system. Unfiled is
* where beamed accounts go when they are first received if they
* dont have anywhere else to go.
* ****************************************************************/
UInt16 getUniqueSystemID (DmOpenRef SystemDB) {
UInt16 i, id;
/* get the number of system records. note that we cant just
use totalItems++ because systems can be added and deleted
at will... */
UInt16 totalItems = DmNumRecordsInCategory (SystemDB, dmAllCategories);
UInt16 max = 0;
/* iterate through the records, and we will return the highest
one it higher than the highest current value. */
for (i = 0; i < totalItems; i++) {
MemHandle scr;
if ((scr = MemHandleNew (1))) {
id = getSIDForSystemIndex (SystemDB, i);
if (id > max) max = id;
freeHandle (scr);
}
}
return max + 1;
}
/* stores the table of offsets for all records of the current file for
faster access. */
static void LoadOffsets(axxPacFD fd)
{
MemPtr mp;
/* assumption: there is just one file being read */
ASSERT_MSG("AIM6", currFileDesc == -1);
axxPacSeek(LibRef, fd, 76, SEEK_SET);
axxPacRead(LibRef, fd, &nrec, 2);
moff = MemHandleNew(nrec * 8L);
ASSERT_MSG("AIM3", moff != 0);
mp = MemHandleLock(moff);
ASSERT_MSG("AIM4", mp != 0);
axxPacSeek(LibRef, fd, 78, SEEK_SET);
axxPacRead(LibRef, fd, mp, nrec * 8L);
MemHandleUnlock(moff);
currFileDesc = fd;
nrec--;
}
static void MusicTabInit() {
ControlType *cck1P, *cck2P;
ListType *list1P, *list2P, *list3P;
FieldType *fld1P;
MemHandle tempoH;
Char *tempoP;
cck1P = (ControlType *)GetObjectPtr(TabMusicMusicCheckbox);
cck2P = (ControlType *)GetObjectPtr(TabMusicMultiMidiCheckbox);
list1P = (ListType *)GetObjectPtr(TabMusicDriverList);
list2P = (ListType *)GetObjectPtr(TabMusicRateList);
list3P = (ListType *)GetObjectPtr(TabMusicQualityList);
fld1P = (FieldType *)GetObjectPtr(TabMusicTempoField);
CtlSetValue(cck1P, gameInfoP->musicInfo.sound.music);
CtlSetValue(cck2P, gameInfoP->musicInfo.sound.multiMidi);
if (gameInfoP->musicInfo.sound.drvMusic > 5)
gameInfoP->musicInfo.sound.drvMusic = 0;
LstSetSelection(list1P, gameInfoP->musicInfo.sound.drvMusic);
LstSetTopItem(list1P, gameInfoP->musicInfo.sound.drvMusic);
CtlSetLabel((ControlType *)GetObjectPtr(TabMusicDriverPopTrigger), LstGetSelectionText(list1P, LstGetSelection(list1P)));
LstSetSelection(list2P, gameInfoP->musicInfo.sound.rate);
LstSetTopItem(list2P, gameInfoP->musicInfo.sound.rate);
CtlSetLabel((ControlType *)GetObjectPtr(TabMusicRatePopTrigger), LstGetSelectionText(list2P, LstGetSelection(list2P)));
LstSetSelection(list3P, gameInfoP->fmQuality);
CtlSetLabel((ControlType *)GetObjectPtr(TabMusicQualityPopTrigger), LstGetSelectionText(list3P, LstGetSelection(list3P)));
tempoH = MemHandleNew(FldGetMaxChars(fld1P)+1);
tempoP = (Char *)MemHandleLock(tempoH);
StrIToA(tempoP, gameInfoP->musicInfo.sound.tempo);
MemHandleUnlock(tempoH);
FldSetTextHandle(fld1P, tempoH);
}
/* Set the silkscreen to contain the toolbar buttons */
void HanderaSetSilkScreen( void )
{
UInt16 defaultSize;
PenBtnListType* defaultButtons;
UInt16 numNewButtons;
UInt16 newSize;
PenBtnListType* newButtons;
/* currently only handeraSilkScreen supported */
if ( GetDIAHardware() != DIA_HARDWARE_HANDERA )
return;
currentSilkStatus = ( GetDIAState() == DIA_STATE_MAX ?
HANDERA_SILK_UP : HANDERA_SILK_DOWN );
/* if we already have defaultButtonsHandle stored in memory, there
is no point in doing everything again, since its already done */
if ( defaultButtonsHandle[ currentSilkStatus ] != NULL )
return;
defaultSize = SilkGetButtonListSize( (Boolean) currentSilkStatus );
defaultButtonsHandle[ currentSilkStatus ] = MemHandleNew( defaultSize );
defaultButtons = MemHandleLock( defaultButtonsHandle[ currentSilkStatus ] );
SilkGetButtonList( defaultButtons, (Boolean) currentSilkStatus );
numNewButtons = defaultButtons->numButtons + TOTAL_ICONS;
newSize = sizeof( PenBtnListType ) +
( sizeof( PenBtnInfoType ) * ( numNewButtons - 1 ) );
newButtons = SafeMemPtrNew( newSize );
MemMove( newButtons, defaultButtons, defaultSize );
GetButtons();
DrawButtons();
SetButtons( newButtons );
SilkSetButtonList( newButtons, (Boolean) currentSilkStatus );
MemPtrUnlock( defaultButtons );
SafeMemPtrFree( newButtons );
}
/*!
* \brief Set up the new file form.
* \param form pointer to the form.
* \return the form pointer.
*/
static FormPtr
cityNewSetup(FormPtr form)
{
int i;
MemHandle hText;
MemPtr pText;
FrmSetFocus(form, FrmGetObjectIndex(form, fieldID_newGameName));
FrmSetControlValue(form, FrmGetObjectIndex(form, buttonID_Easy), 1);
FrmSetControlValue(form, FrmGetObjectIndex(form, buttonID_dis_one), 1);
for (i = 0; i < 2; i++) {
hText = MemHandleNew(5);
pText = MemHandleLock(hText);
StrPrintF((char *)pText, "%u", 100);
MemHandleUnlock(hText);
FldSetTextHandle((FieldPtr)GetObjectPtr(form,
(UInt16)(fieldID_width + i)), hText);
}
return (form);
}
/**
* FUNCTION: smCreate
*
* Creates a new memory block with name memName and size memSize.
*
* PRE-Condition: OS does not know memName; memSize > 0
*
* POST-Condition: memName exists with size memSize;
* memH refers to new memory block.
*
* IN: memName
* Name of new memory block<BR>
* Palm version: Name is ignored
* IN: memSize
* Size of new memory block
*
* OUT: memH
* Handle to new memory block
*
* RETURN: SML_ERR_OK, if O.K.
* SML_ERR_WRONG_USAGE, if memName is already known to the OS
* SML_ERR_INVALID_SIZE, if memSize <= 0
* SML_ERR_NOT_ENOUGH_SPACE, if available memory < memSize
*
* @see smDestroy
*/
Ret_t smCreate (String_t memName, MemSize_t memSize, MemHandle_t *memH) {
if ( memSize <= 0 ) {
return SML_ERR_INVALID_SIZE;
}
// only one create call does make sense under Palm OS
if ( smMemH != 0 ) {
return SML_ERR_WRONG_USAGE;
}
// set new values
smLocked = 0;
smMemH = 1;
*memH = smMemH;
// create memory
if ( (smPalmH=(Handle)MemHandleNew(memSize)) == 0 ) {
return SML_ERR_NOT_ENOUGH_SPACE;
}
return SML_ERR_OK;
}
int AppendField( FieldPtr fld, CharPtr str, UInt len )
{
Err err=0;
CharPtr s;
VoidHand h;
UInt prevlen;
h=(VoidHand)FldGetTextHandle(fld);
if(h==NULL) {
h=MemHandleNew(len+1);
if(h==NULL) return(-1);
s=MemHandleLock(h);
StrNCopy(s, str, len);
s[len]=0;
MemHandleUnlock(h);
} else {
prevlen=FldGetTextLength(fld);
FldSetTextHandle(fld, NULL);
if( MemHandleSize(h)<=(prevlen+len)) {
err=MemHandleResize( h, prevlen+len+1 );
}
if( err!=0 ) return(-1);
s=MemHandleLock(h);
StrNCopy(s+prevlen, str, len);
s[len+prevlen]=0;
MemHandleUnlock(h);
}
FldSetTextHandle(fld, (Handle)h);
/* FldDrawField(fld); */
return( 0 );
}
/*
* FUNCTION: PrvMakeGlobals
*
* DESCRIPTION: Create our library globals.
*
* PARAMETERS:
*
* refNum
* Library reference number returned by SysLibLoad() or SysLibFind().
*
* CALLED BY: internal
*
* RETURNS:
*
* pointer to our *locked* library globals
* NULL if our globals could not be created.
*/
FlickrGlobals* PrvMakeGlobals(UInt16 refNum)
{
SysLibTblEntryType* libEntry = SysLibTblEntry(refNum);
ErrFatalDisplayIf(libEntry == NULL, "invalid InfoMan Flickr Uploader refNum");
/* Error check to make sure the globals don't already exist */
ErrFatalDisplayIf(libEntry->globalsP != NULL, "InfoMan Flickr Uploader globals already exist");
/* Allocate and initialize our library globals. */
MemHandle handle = MemHandleNew(sizeof(FlickrGlobals));
if (NULL == handle)
return NULL;
FlickrGlobals* globals = (FlickrGlobals*)MemHandleLock(handle);
if (NULL == globals)
{
MemHandleFree(handle);
return NULL;
}
Err err = globals->Init(refNum);
if (errNone != err)
{
MemPtrUnlock(globals);
MemHandleFree(handle);
return NULL;
}
/* Set the owner of our globals memory chunk to "system" (zero), so it won't get
* freed automatically by Memory Manager when the first application to call
* FlickrOpen exits. This is important if the library is going to stay open
* between apps. */
MemPtrSetOwner(globals, 0);
libEntry->globalsP = (MemPtr)handle;
return globals;
}
/*
** Initiates transfer mode.
*/
void StartXferMode(void) {
FormType* frm = FrmGetActiveForm();
FieldType* fld = GetObjectPointer(frm, XferField);
const UInt32 len = MemHandleSize(d.record_name);
MemHandle textH = MemHandleNew(len);
ASSERT(textH);
FlushToBuffer();
FrmSetMenu(frm, XferMenu);
d.is_xfer_mode = true;
ToggleButtonBar(frm, false);
ResetDrawingAreaRectangle(p.formID == DiddleTForm, true);
FrmUpdateForm(p.formID, 0);
InitXferList();
ToggleXferBar(frm, true);
FrmSetFocus(frm, FrmGetObjectIndex(frm, XferField));
/* Init field with record title */
MemMove(MemHandleLock(textH), MemHandleLock(d.record_name), len);
MemHandleUnlock(textH);
MemHandleUnlock(d.record_name);
FldSetTextHandle(fld, textH);
}
static void SetField(UInt16 formID, UInt16 fieldID, const char *str)
{
FormPtr frm;
FieldPtr fld;
UInt16 obj;
CharPtr p;
VoidHand h;
frm = FrmGetFormPtr(formID);
obj = FrmGetObjectIndex(frm, fieldID);
fld = (FieldPtr)FrmGetObjectPtr(frm, obj);
h = (VoidHand)FldGetTextHandle(fld);
if (h == NULL)
{
h = MemHandleNew (FldGetMaxChars(fld)+1);
ErrFatalDisplayIf(!h, "No Memory");
}
p = (CharPtr)MemHandleLock(h);
StrCopy(p, str);
MemHandleUnlock(h);
FldSetTextHandle(fld, (Handle)h);
}
