/*----------------------------------------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;
}
void GlbClose() {
GlbReleaseAll();
if (gVars->globals[GBVARS_COMMON])
DmCloseDatabase(gVars->globals[GBVARS_COMMON]);
if (gVars->globals[GBVARS_ENGINE])
DmCloseDatabase(gVars->globals[GBVARS_ENGINE]);
}
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);
}
Err ZDicFontRelease ( UInt16 refNum, ZDicFontType* fontP )
{
#pragma unused(refNum)
Err err = errNone;
//Release the phonic font resource when app quits.
if ( fontP->phonicSmallFontH != NULL )
{
MemHandleUnlock ( fontP->phonicSmallFontH );
DmReleaseResource ( fontP->phonicSmallFontH );
}
if ( fontP->phonicLargeFontH != NULL )
{
MemHandleUnlock ( fontP->phonicLargeFontH );
DmReleaseResource ( fontP->phonicLargeFontH );
}
if ( fontP->fontLibP != 0 )
{
err = DmCloseDatabase ( fontP->fontLibP );
}
return err;
}
static void ModSetStack(UInt32 newSize, UInt16 cardNo, LocalID dbID) {
DmOpenRef dbRef = DmOpenDatabase(cardNo, dbID, dmModeReadWrite);
if (dbRef) {
MemHandle pref = DmGetResource('pref',0);
UInt32 size = 0;
if (pref) {
SysAppPrefsType *data = (SysAppPrefsType *)MemHandleLock(pref);
size = data->stackSize;
if (newSize) {
SysAppPrefsType newData;
MemMove(&newData, data, sizeof(SysAppPrefsType));
newData.stackSize = newSize;
DmWrite(data, 0, &newData, sizeof(SysAppPrefsType));
}
MemPtrUnlock(data);
DmReleaseResource(pref);
}
DmCloseDatabase(dbRef);
}
}
/*
** Handle Security command
*/
static void ThumbnailDoCmdSecurity(void) {
FormType* frm = FrmGetActiveForm();
Boolean wasHiding = d.privateRecordStatus == hidePrivateRecords;
UInt16 mode;
d.privateRecordStatus = SecSelectViewStatus();
if (wasHiding ^ (d.privateRecordStatus == hidePrivateRecords)) {
/* We have to close the database first */
if (DmCloseDatabase(d.dbR) != errNone) abort();
mode = dmModeReadWrite;
if (d.privateRecordStatus != hidePrivateRecords)
mode |= dmModeShowSecret;
/* Re-open the database */
if ((d.dbR = DmOpenDatabaseByTypeCreator(DBType, AppType, mode)) == NULL)
abort();
/* Update cached values */
d.records_in_cat = DmNumRecordsInCategory(d.dbR, p.category);
if (d.privateRecordStatus == hidePrivateRecords)
SetTopVisibleRecord(0);
ThumbnailViewLoadRecords (frm);
}
}
PrefsStoreReader::~PrefsStoreReader()
{
if (_recHandle)
MemHandleUnlock(_recHandle);
if (_db)
DmCloseDatabase(_db);
}
/**********************************************************************
* Function: getDatabase
* Description: pass the function the necessare database information,
* and it will either open an existing database or create a new one if
* neccessary. "created" will be true if a new database was created
* *******************************************************************/
Err getDatabaseByTypeCreatorName (DmOpenRef * DBptr, UInt32 type,
UInt32 creator, UInt32 mode, char *name) {
Err errors;
LocalID id;
UInt16 cardNum, attr;
DmSearchStateType srch;
Char db_name[32];
errors = DmGetNextDatabaseByTypeCreator(true, &srch, type, creator, false,
&cardNum, &id);
while(!errors && id) {
*DBptr = DmOpenDatabase (cardNum, id, mode);
DmDatabaseInfo (cardNum, id, db_name, &attr, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL);
if(StrCompare(name, db_name) == 0) {
attr |= dmHdrAttrBackup;
DmSetDatabaseInfo (cardNum, id, NULL, &attr, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL);
return 0;
}
if(*DBptr) DmCloseDatabase(*DBptr);
errors = DmGetNextDatabaseByTypeCreator(false, &srch, type, creator, false,
&cardNum, &id);
}
return 1;
}
void CloseTransliterations( void )
{
UInt16 i;
if ( 0 < numXlits ) {
for ( i = 0 ; i < numXlits ; i++ ) {
MemHandleUnlock( xlitData[ i ].handle );
DmReleaseRecord( xlitData[ i ].dbRef, xlitData[ i ].index, false );
}
for ( i = 0 ; i < numXlits ; i++ ) {
DmOpenRef dbRef;
dbRef = xlitData[ i ].dbRef;
if ( dbRef != NULL ) {
UInt16 j;
DmCloseDatabase( dbRef );
for ( j = i + 1 ; j < numXlits ; j++ ) {
if ( xlitData[ j ].dbRef == dbRef )
xlitData[ j ].dbRef = NULL;
}
}
}
SafeMemPtrFree( xlitData );
}
for ( i = 0 ; i < numXlits + 1 ; i++ ) {
SafeMemPtrFree( xlitNames[ i ] );
}
SafeMemPtrFree( xlitNames );
numXlits = 0;
}
/* Finds and opens database,
* calls plugin specific code to create new item,
* then fills in GoTo parameters.
*/
static UInt16
PickBooger(KleenexPtr kleenexP)
{
DmOpenRef dbR;
DmSearchStateType searchstate;
UInt32 creatorID, dbtype;
UInt16 cardNo;
LocalID dbID;
Boolean closedb = false;
UInt16 err, index;
/* Check for the correct version */
if (!((kleenexP->version) & IBVERSION_ORIG))
return (boogerErrorVersionMismatch);
/* Open the database */
if (DmGetNextDatabaseByTypeCreator(true, &searchstate, DB_TYPE,
DB_CREATOR, true, &cardNo, &dbID))
return (1);
if ((dbR = DmOpenDatabase(cardNo, dbID, dmModeReadWrite))) {
closedb = true;
} else if (DmGetLastErr() == dmErrAlreadyOpenForWrites) {
dbR = NULL;
while ((dbR = DmNextOpenDatabase(dbR))) {
DmOpenDatabaseInfo(dbR, &dbID, NULL, NULL, &cardNo, NULL);
DmDatabaseInfo(cardNo, dbID, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, &dbtype, &creatorID);
if ((dbtype == DB_TYPE) && (creatorID == DB_CREATOR))
break;
}
if (!dbR)
return (1);
}
/* Call plugin specific routine to create item in database */
err = DoTheBoogie(kleenexP, dbR, &index);
/* Close the database */
if (closedb)
DmCloseDatabase(dbR);
/* Did it work? */
if (err)
return (1);
/* Load the GoTo parameters */
if (!(kleenexP->booger.cmdPBP = MemPtrNew(sizeof(GoToParamsType))))
return (1);
MemSet(kleenexP->booger.cmdPBP, sizeof(GoToParamsType), 0);
((GoToParamsType *)(kleenexP->booger.cmdPBP))->dbCardNo = cardNo;
((GoToParamsType *)(kleenexP->booger.cmdPBP))->dbID = dbID;
((GoToParamsType *)(kleenexP->booger.cmdPBP))->recordNum = index;
MemPtrSetOwner(kleenexP->booger.cmdPBP, 0);
return (errNone);
}
/* Finds and opens database,
* calls plugin specific code to create new item,
* then fills in GoTo parameters.
*/
static UInt16
PickBooger(KleenexPtr kleenexP)
{
DmOpenRef dbR;
UInt32 creatorID;
UInt16 cardNo;
LocalID dbID;
Boolean closedb = false;
UInt16 err, index;
Char name[dmDBNameLength];
/* Check for the correct version */
if (!((kleenexP->version) & IBVERSION_PICTURE))
return (boogerErrorVersionMismatch);
/* Open the database */
cardNo = 0;
if (!(dbID = DmFindDatabase(cardNo, "DiddleIDB")))
return 1;
if ((dbR = DmOpenDatabase(cardNo, dbID, dmModeReadWrite))) {
closedb = true;
} else if (DmGetLastErr() == dmErrAlreadyOpenForWrites) {
dbR = NULL;
while ((dbR = DmNextOpenDatabase(dbR))) {
DmOpenDatabaseInfo(dbR, &dbID, NULL, NULL, &cardNo, NULL);
DmDatabaseInfo(cardNo, dbID, name, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, &creatorID);
if (!StrCompare(name, "DiddleIDB") && (creatorID == DB_CREATOR))
break;
}
if (!dbR)
return 1;
}
/* Call plugin specific routine to create item in database */
err = DoTheBoogie(kleenexP, dbR, &index);
/* Close the database */
if (closedb)
DmCloseDatabase(dbR);
/* Did it work? */
if (err)
return (1);
/* Load the GoTo parameters */
if (!(kleenexP->booger.cmdPBP = MemPtrNew(sizeof(GoToParamsType))))
return (1);
MemSet(kleenexP->booger.cmdPBP, sizeof(GoToParamsType), 0);
((GoToParamsType *)(kleenexP->booger.cmdPBP))->dbCardNo = cardNo;
((GoToParamsType *)(kleenexP->booger.cmdPBP))->dbID = dbID;
((GoToParamsType *)(kleenexP->booger.cmdPBP))->recordNum = index;
MemPtrSetOwner(kleenexP->booger.cmdPBP, 0);
return (errNone);
}
static void
SaveButtonClick (void)
{
DmOpenRef openRef;
UInt16 recIndex;
MemHandle recH;
Err err;
if (EditorMidi.dbID == 0) {
debugPrintf("dbID==0, create a new record in Palmano DB\n");
/* create new record in palmano DB */
err = getPalmanoDatabase(&openRef, dmModeReadWrite | dmModeExclusive);
if (err != 0) {
ErrAlert(err);
return;
}
/* allocate new record in DB */
recIndex = dmMaxRecordIndex;
recH = DmNewRecord(openRef, &recIndex, 5); /* initial size is 5 bytes */
ErrFatalDisplayIf(!recH, "SaveButtonClick(): can't get new record by index!");
}
else {
/* replace old song in-place */
openRef = DmOpenDatabase (EditorMidi.cardNo, EditorMidi.dbID,
dmModeReadWrite | dmModeExclusive);
ErrFatalDisplayIf(!openRef, "SaveButtonClick(): "
"Can't open old song database for record");
err = DmFindRecordByID(openRef, EditorMidi.uniqueRecID, &recIndex);
ErrFatalDisplayIf(err, "Can't find record by ID");
recH = DmGetRecord(openRef, recIndex);
ErrFatalDisplayIf(!recH, "SaveButtonClick(): "
"Can't get old song record for writing");
}
// save midi to recH
GetFieldTextToStr(EditorMidi.name, ID_EditorNameField, sndMidiNameLength);
debugPrintf("SaveButtonClick(): smfutils_save(recH=%lx, name=%s\n",
recH, EditorMidi.name);
smfutils_save(recH, EditorMidi.name, ¬elist);
debugPrintf("SaveButtonClick(): return from smfutils_save()\n");
DmReleaseRecord (openRef, recIndex, 1);
DmCloseDatabase (openRef);
FrmGotoForm(ID_MainForm);
}
// 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;
}
Err CloseBookmarksDB(AppContext* appContext)
{
if (appContext->bookmarksDb != NULL)
{
Assert( bkmInvalid != appContext->currBookmarkDbType );
DmCloseDatabase(appContext->bookmarksDb);
appContext->bookmarksDb = NULL;
appContext->currBookmarkDbType = bkmInvalid;
}
return errNone;
}
void buildAll() {
Err err;
LocalID olddb;
olddb = DmFindDatabase(0, "Glbs::" BUILD_NAME);
if (olddb) {
DmDeleteDatabase(0,olddb);
FrmCustomAlert(1000,"delete old " BUILD_NAME " DB",0,0);
}
err = DmCreateDatabase (0, "Glbs::" BUILD_NAME, 'ScVM', 'GLBS', false);
olddb = DmFindDatabase(0, "Glbs::" BUILD_NAME);
dbP[BUILD_RES] = DmOpenDatabase(0, olddb, dmModeReadWrite);
#if defined(BUILD_COMMON)
addNewGui();
#elif defined(BUILD_SCUMM)
addDimuseTables();
// temp removed
// TODO ::scummvm use sizeof(OLD256_MIDI_HACK) so i need to fix it
// directly in the code or call MemHandleSize but it may slow down
// code execution
addAkos();
addDimuseCodecs();
addCodec47();
addGfx();
addDialogs();
addCharset();
addCostume();
addPlayerV2();
addScummTables();
#elif defined(BUILD_SIMON)
addSimon();
Simon_addCharset();
#elif defined(BUILD_SKY)
Sky_addHufftext();
#elif defined(BUILD_QUEEN)
Queen_addTalk();
Queen_addRestables();
Queen_addGraphics();
Queen_addDisplay();
Queen_addMusicdata();
#elif defined(BUILD_SWORD1)
Sword1_addStaticres();
#endif
DmCloseDatabase(dbP[BUILD_RES]);
}
void CloseSkins( void )
{
DmOpenRef dbRef;
if ( NULL == resourceDBList )
return;
dbRef = ListFirst( resourceDBList );
while ( dbRef != NULL ) {
DmCloseDatabase( dbRef );
dbRef = ListNext( resourceDBList, dbRef );
}
ListDelete( resourceDBList );
}
void Memo_WriteClose(void) {
MemoWriteLen("", 0); // Make sure it is null terminated.
// Release handle on record, resize to amount used...
if (s_RecHandle) {
(void) DmReleaseRecord(s_pMemoDb, s_iRecNum, true);
if (s_iOffset+1 < s_iAllocSize &&
(s_RecHandle = DmResizeRecord(s_pMemoDb, s_iRecNum, s_iOffset+1)))
(void) DmReleaseRecord(s_pMemoDb, s_iRecNum, true);
s_RecHandle = NULL;
}
if (s_pMemoDb)
(void) DmCloseDatabase(s_pMemoDb);
s_pMemoDb = NULL;
}
/*
** DrawPlugBitmap
*/
static void DrawPlugBitmap(Int16 plugindex, UInt16 rscID, Coord x, Coord y) {
SysDBListItemType *pluglistP = MemHandleLock(d.xfer.pluglistH);
DmOpenRef dbR = DmOpenDatabase(pluglistP[plugindex].cardNo,
pluglistP[plugindex].dbID, dmModeReadOnly);
MemHandle plugH = DmGet1Resource('BooG', rscID);
ASSERT(dbR);
ASSERT(plugH);
WinDrawBitmap(MemHandleLock(plugH), x, y);
/* Clean up */
MemHandleUnlock(d.xfer.pluglistH);
MemHandleUnlock(plugH);
DmReleaseResource(plugH);
DmCloseDatabase(dbR);
}
/*
** GetPlugString
*/
static void GetPlugString(Int16 plugindex, UInt16 rscID, Char* chrP) {
SysDBListItemType* pluglistP = MemHandleLock(d.xfer.pluglistH);
DmOpenRef dbR = DmOpenDatabase(pluglistP[plugindex].cardNo,
pluglistP[plugindex].dbID, dmModeReadOnly);
MemHandle plugH = DmGet1Resource('BooG', rscID);
ASSERT(dbR);
ASSERT(plugH);
if (!plugH) {
StrCopy(chrP, "");
} else {
StrNCopy(chrP, MemHandleLock(plugH), 48); // FIXME constant should be symbolic
MemHandleUnlock(plugH);
}
/* Clean up */
MemHandleUnlock(d.xfer.pluglistH);
DmCloseDatabase(dbR);
}
NCSError NCSFileClose(NCS_FILE_HANDLE hFile)
{
#ifdef WIN32
if( CloseHandle( hFile ) )
return(NCS_FILE_CLOSE_ERROR);
else
return(NCS_SUCCESS);
#elif defined MACINTOSH
FSClose((short)hFile);
hFile = NULL;
return NCS_SUCCESS;
#elif defined PALM
if(hFile && hFile->dbRef) {
if(hFile->hRecord) {
if(hFile->pData) {
MemHandleUnlock(hFile->hRecord);
}
DmReleaseRecord(hFile->dbRef, hFile->iRecord, false);
}
DmCloseDatabase(hFile->dbRef);
}
NCSFree((void*)hFile);
#elif defined(POSIX)
if(close(hFile) == 0) {
return(NCS_SUCCESS);
} else {
return(NCS_FILE_CLOSE_ERROR);
}
#else /* SOLARIS||IRIX */
#error ERROR: EcwFileOpen() routine is not defined for this platform
#endif /* WIN32 */
}
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;
}
/* Remove preferences from the Preferences database */
static void RemovePref
(
UInt16 prefID /* preference to remove */
)
{
DmOpenRef ref;
DmSearchStateType state;
LocalID dbID;
UInt16 cardNo;
Int16 index;
DmGetNextDatabaseByTypeCreator( true, &state, 'sprf', 'psys', false,
&cardNo, &dbID );
ref = DmOpenDatabase( cardNo, dbID, dmModeReadWrite );
if ( ref == NULL )
return;
index = DmFindResource( ref, ViewerAppID, prefID, NULL );
if ( index != -1 )
DmRemoveResource( ref, index );
DmCloseDatabase( ref );
}
/*------------------------------------------------------CIRexxApp::FindLaunch-+
| |
+----------------------------------------------------------------------------*/
Err CIRexxApp::FindLaunch(FindParamsPtr pFindParams)
{
//<<<JAL TODO: This is currently dependent on the Rexx category.
// I'm not sure if we'll ever need to change/add-to this,
// but if we do, then this code will have to be changed
// along with the GoTo command.
Err err;
LocalID dbID;
UInt16 cardNo = 0;
DmOpenRef dbP;
DmSearchStateType searchState;
UInt16 recordNum;
MemHandle hRecord;
UInt32 pos;
UInt16 matchLength;
Boolean match, full;
RectangleType r;
UInt32 type;
UInt32 creator;
// Open our database (should we search MemoPad and pedit, too?)
// and do our Find. We define the semantics of Find, so
// instead of searching the whole records for the search string,
// let's just search for scripts with the search string as their "name."
if (FindDrawHeader(pFindParams, "Rexx Scripts")) {
goto m_return;
}
if ((err = DmGetNextDatabaseByTypeCreator(
true, &searchState, 'data', CREATORID, true, &cardNo, &dbID)) != errNone) {
pFindParams->more = false;
return errNone;
}
if ((err = DmDatabaseInfo(0, dbID, 0, 0, 0, 0, 0, 0, 0, 0, 0, &type, &creator)) != errNone ||
(type != 'data' && creator != CREATORID)) {
pFindParams->more = false;
return errNone;
}
if ((dbP = DmOpenDatabase(cardNo, dbID, pFindParams->dbAccesMode)) == 0 ||
DmGetAppInfoID(dbP) == 0) { /* if categories not initialized then CategoryGetName throws fatal error */
pFindParams->more = false;
return errNone;
}
UInt16 category;
char categoryName[dmCategoryLength];
for (category = 0; category < dmRecNumCategories; ++category) {
CategoryGetName(dbP, category, categoryName);
if (!StrCaselessCompare(categoryName, "REXX")) { break; }
}
if (category == dmRecNumCategories) { goto m_return; }
// set it to dmAllCategories?
UInt32 romVersion;
FtrGet(sysFtrCreator, sysFtrNumROMVersion, &romVersion);
full = false;
recordNum = pFindParams->recordNum;
while (true) {
// Because applications can take a long time to finish a Find when
// the result may already be on the screen, or for other reasons,
// users like to be able to stop the Find. So, stop it if any event
// is pending, i.e., if the user does something with the device.
// Because actually checking if an event is pending slows the
// search itself, just check it every so many records.
if ((recordNum & 0x000f) == 0 && EvtSysEventAvail(true)) {
pFindParams->more = true;
break;
}
if (!(hRecord = DmQueryNextInCategory(dbP, &recordNum, category))) {
pFindParams->more = false;
break;
}
Char * p = (char *)MemHandleLock(hRecord);
UInt32 isInternational;
err = FtrGet(sysFtrCreator, sysFtrNumIntlMgr, &isInternational);
if (err == errNone && isInternational) {
match = TxtFindString(p, pFindParams->strToFind, &pos, &matchLength);
} else {
match = TxtGlueFindString(p, pFindParams->strToFind, &pos, &matchLength);
}
if (match) {
// Add the match to the find paramter block.
// If there is no room to display the match
// then the following function will return true.
full = FindSaveMatch(pFindParams, recordNum, (UInt16)pos, 0, 0, cardNo, dbID);
if (!full) {
// Get the bounds of the region where we will draw the results, and
// display the title of the description neatly in that area.
FindGetLineBounds(pFindParams, &r);
Int16 x = r.topLeft.x + 1;
Int16 y = r.topLeft.y;
Int16 w = r.extent.x - 2;
Char * cr = StrChr(p, linefeedChr);
UInt16 titleLen = (cr == 0)? StrLen(p) : cr - p;
Int16 fntWidthToOffset;
if (romVersion >= sysMakeROMVersion(3, 1, 0, sysROMStageRelease, 0)) {
fntWidthToOffset = FntWidthToOffset(p, titleLen, w, 0, 0);
} else {
fntWidthToOffset = FntGlueWidthToOffset(p, titleLen, w, 0, 0);
}
if (fntWidthToOffset == titleLen) {
WinDrawChars(p, titleLen, x, y);
} else {
Int16 titleWidth;
titleLen = FntWidthToOffset(p, titleLen, w - FntCharWidth(chrEllipsis), 0, &titleWidth);
WinDrawChars(p, titleLen, x, y);
WinDrawChar (chrEllipsis, x + titleWidth, y);
}
++pFindParams->lineNumber;
}
}
MemHandleUnlock(hRecord);
if (full) { break; }
++recordNum;
}
m_return:
DmCloseDatabase(dbP);
return errNone;
}
// Save preferences previously set via ErrSet*() calls to a database.
// If something goes wrong, returns an error
// Possible errors:
// memErrNotEnoughSpace - not enough memory to allocate needed structures
// errors from Dm*() calls
Err PrefsStoreWriter::ErrSavePreferences()
{
Err err = errNone;
long blobSize;
void * prefsBlob = SerializeItems(_items, _itemsCount, &blobSize);
if ( NULL == prefsBlob )
return memErrNotEnoughSpace;
DmOpenRef db = DmOpenDatabaseByTypeCreator(_dbType, _dbCreator, dmModeReadWrite);
if (!db)
{
err = DmCreateDatabase(0, _dbName, _dbCreator, _dbType, false);
if ( err)
return err;
db = DmOpenDatabaseByTypeCreator(_dbType, _dbCreator, dmModeReadWrite);
if (!db)
return DmGetLastErr();
}
// set backup bit on the database. code adapted from DataStore.cpp
// DataStore::open()
if (errNone == err)
{
LocalID localId;
UInt16 cardNo;
UInt16 attribs;
err = DmOpenDatabaseInfo(db, &localId, NULL, NULL, &cardNo, NULL);
if (errNone != err)
goto Continue;
err = DmDatabaseInfo(cardNo, localId, NULL, &attribs, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
if (errNone != err)
goto Continue;
if (0 != attribs & dmHdrAttrBackup)
goto Continue;
attribs |= dmHdrAttrBackup;
err = DmSetDatabaseInfo(cardNo, localId, NULL, &attribs, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
Continue:
err = errNone;
}
UInt16 recNo = 0;
UInt16 recsCount = DmNumRecords(db);
MemHandle recHandle;
Boolean fRecordBusy = false;
Boolean fRecFound = false;
void * recData;
long recSize;
while (recNo < recsCount)
{
recHandle = DmGetRecord(db, recNo);
fRecordBusy = true;
recData = MemHandleLock(recHandle);
recSize = MemHandleSize(recHandle);
if (IsValidPrefRecord(recData))
{
fRecFound = true;
break;
}
MemPtrUnlock(recData);
DmReleaseRecord(db, recNo, true);
fRecordBusy = false;
++recNo;
}
if (fRecFound && blobSize>recSize)
{
/* need to resize the record */
MemPtrUnlock(recData);
DmReleaseRecord(db,recNo,true);
fRecordBusy = false;
recHandle = DmResizeRecord(db, recNo, blobSize);
if ( NULL == recHandle )
return DmGetLastErr();
recData = MemHandleLock(recHandle);
Assert( MemHandleSize(recHandle) == blobSize );
}
if (!fRecFound)
{
recNo = 0;
recHandle = DmNewRecord(db, &recNo, blobSize);
if (!recHandle)
{
err = DmGetLastErr();
goto CloseDbExit;
}
recData = MemHandleLock(recHandle);
fRecordBusy = true;
}
err = DmWrite(recData, 0, prefsBlob, blobSize);
MemPtrUnlock(recData);
if (fRecordBusy)
DmReleaseRecord(db, recNo, true);
CloseDbExit:
// if had error before - preserve that error
// otherwise return error code from DmCloseDatabase()
if (err)
DmCloseDatabase(db);
else
err = DmCloseDatabase(db);
new_free( prefsBlob );
return err;
}
NCSError NCSFileOpen(const NCSTChar *szFilename, int iFlags, NCS_FILE_HANDLE *phFile)
{
#ifdef WIN32
DWORD dwMode = GENERIC_READ;
DWORD dwCreate = OPEN_EXISTING;
if(iFlags & NCS_FILE_READ) dwMode = GENERIC_READ;
if(iFlags & NCS_FILE_READ_WRITE) dwMode = GENERIC_READ|GENERIC_WRITE;
if(iFlags & NCS_FILE_CREATE) dwCreate = CREATE_ALWAYS;
if(iFlags & NCS_FILE_CREATE_UNIQUE) dwCreate = CREATE_NEW;
if(iFlags & NCS_FILE_APPEND) dwCreate = OPEN_ALWAYS;
*phFile = CreateFile(szFilename, // file name
dwMode, // Generic read mode
FILE_SHARE_READ, // Let anyone access and share the file
NULL, // No security info (so can't be inherited by child process)
dwCreate, // File must exist to be opened
FILE_FLAG_RANDOM_ACCESS, // Going to be doing lots of random access
NULL); // And no template file for attributes
if( *phFile == INVALID_HANDLE_VALUE ) {
return( NCS_FILE_OPEN_FAILED );
} else {
return( NCS_SUCCESS );
}
#elif defined MACINTOSH
#if __POWERPC__
int i,length, result;
Str255 pascalString;
FSSpec fileSpec;
// We have a C string, we need a PASCAL string.
length = strlen(szFilename) + 1;
for(i = 1; i < length; ++i)
pascalString[i] = szFilename[i - 1];
pascalString[0] = strlen(szFilename);
// Create a File Specification Record, then create a File
result = FSMakeFSSpec(0,0,pascalString,&fileSpec); // return is meaningless, since the only possible error doesn't effect processing in this case
switch(result) {
case noErr:
// we could dRes pFile here, but we are the only user
result =FSpOpenDF(&fileSpec, fsRdPerm, (short *)phFile);
if(result) return NCS_FILE_OPEN_FAILED;
else return NCS_SUCCESS;
break;
default:
return NCS_SUCCESS;
break;
}
#else /* __POWERPC__ */
int i,length, result;
Str255 pascalString;
// We have a C string, we need a PASCAL string.
length = strlen(szFilename) + 1;
for(i = 1; i < length; ++i)
pascalString[i] = szFilename[i - 1];
pascalString[0] = strlen(szFilename);
result =FSOpen(pascalString, 0, (short *)phFile);
if(result) return TRUE;
else return FALSE;
#endif /* __POWERPC__ */
#elif defined PALM
NCS_FILE_HANDLE hFile;
Err eErr;
UInt32 nMode = 0;
if(hFile = (NCS_FILE_HANDLE)NCSMalloc(sizeof(NCS_FILE_HANDLE_STRUCT), TRUE)) {
hFile->dbID = DmFindDatabase(0, szFilename);
if(hFile->dbID) {
Char nameP[dmDBNameLength];
UInt16 attributes;
UInt16 version;
UInt32 crDate;
UInt32 modDate;
UInt32 bckUpDate;
UInt32 modNum;
LocalID appInfoID;
LocalID sortInfoID;
UInt32 type;
UInt32 creator;
DmDatabaseInfo(0, hFile->dbID, nameP,
&attributes,
&version,
&crDate,
&modDate,
&bckUpDate,
&modNum,
&appInfoID,
&sortInfoID,
&type,
&creator);
if(creator == NCS_PALM_CREATOR_ID) {
if(hFile->dbRef = DmOpenDatabase(0, hFile->dbID, dmModeReadOnly|dmModeShowSecret)) {
UInt32 nRecords;
UInt32 nTotalBytes;
UInt32 nDataBytes;
eErr = DmDatabaseSize(0, hFile->dbID, &nRecords, &nTotalBytes, &nDataBytes);
if(eErr == errNone) {
MemHandle hRecord;
hFile->nRecords = nRecords;
hFile->nDBSize = nDataBytes;
#ifdef NOTDEF
if(hRecord = DmGetRecord(hFile->dbRef, 0)) {
MemPtr pData;
if(pData = MemHandleLock(hRecord)) {
hFile->nRecordSize = ((UINT16*)pData)[0];
MemHandleUnlock(hRecord);
}
DmReleaseRecord(hFile->dbRef, 0, false);
}
#endif
*phFile = hFile;
return(NCS_SUCCESS);
}
DmCloseDatabase(hFile->dbRef);
return(NCSPalmGetNCSError(eErr));
}
}
}
} else {
return(NCS_COULDNT_ALLOC_MEMORY);
}
/*
if(iFlags & NCS_FILE_READ) nMode = fileModeReadOnly|fileModeAnyTypeCreator;
if(iFlags & NCS_FILE_READ_WRITE) nMode = fileModeUpdate|fileModeAnyTypeCreator;
if(iFlags & NCS_FILE_CREATE) nMode = fileModeReadWrite|fileModeAnyTypeCreator;
if(iFlags & NCS_FILE_CREATE_UNIQUE) nMode = fileModeReadWrite|fileModeDontOverwrite|fileModeAnyTypeCreator;
if(iFlags & NCS_FILE_APPEND) nMode = fileModeAppend|fileModeAnyTypeCreator;
*phFile = FileOpen(0, (char*)szFilename, 0, 0, nMode, &eErr);
return(NCSPalmGetNCSError(eErr));
*/
#elif defined(POSIX)
int flags = O_RDONLY;
if(iFlags & NCS_FILE_READ) flags = O_RDONLY;
if(iFlags & NCS_FILE_READ_WRITE) flags = O_RDWR;
if(iFlags & NCS_FILE_CREATE) flags |= O_CREAT;
if(iFlags & NCS_FILE_CREATE_UNIQUE) flags |= O_CREAT|O_EXCL;
if(iFlags & NCS_FILE_APPEND) flags |= O_APPEND;
#if defined SOLARIS || (defined(HPUX) && !defined(__LP64__))
// Enable 64bit!
flags |= O_LARGEFILE;
#endif
#ifdef HPUX
*phFile = open64((const char*)CHAR_STRING(szFilename), (int)flags);
#ifdef NOTDEF
if (*phFile < 0) {
fprintf(stderr, "Error opening file : %ld\n", errno);
if (errno == EOVERFLOW) {
fprintf(stderr, "The named file is a regular file and the size "
"of the file cannot be represented correctly in an object of "
"size off_t.");
}
}
#endif
#else
*phFile = open((const char*)CHAR_STRING(szFilename), (int)flags, S_IRUSR|S_IWUSR);
#endif
if(*phFile != -1) {
return(NCS_SUCCESS);
} else {
return(NCS_FILE_OPEN_FAILED);
}
#else /* SOLARIS||IRIX */
#error ERROR EcwFileCreate() routine is not defined for this platform
#endif /* WIN32 */
}
void fini_gb2312_table(DmOpenRef db, gb2312_table& table)
{
int i = 0;
for (i = 0; i < 9; ++i) MemHandleUnlock(table.memHandle[i]);
DmCloseDatabase(db);
}
/***************************************************************************
* Function: cryptSwitch
* Description: handles changing the system password based upon the
* password change screen. Basically checks that current password is correct,
* checks that the new password was entered correctly, then re-encrypts the
* databases based upon the new password.
* ************************************************************************/
static void
cryptSwitch (int v)
{
// total number of records to re-write
UInt16 totalAItems = DmNumRecordsInCategory (AccountDB, dmAllCategories);
UInt16 totalSItems = DmNumRecordsInCategory (SystemDB, dmAllCategories);
MemPtr pac = NULL, scratch = NULL, scratch2 = NULL;
UInt16 i = 0, senc = 0, aenc = 0;
MemHandle rH;
char s[5], a[5];
StripPrefType prefs;
UInt16 prefsSize, prefsVersion;
FormType *preF = FrmGetActiveForm ();
FormType *f = FrmInitForm (pleaseWait);
FrmDrawForm (f);
// re-encrypt the password
if ((rH = DmGetRecord (PasswordDB, 0)))
{
if ((scratch = MemPtrNew (getSCSize(sizeof(md_hash)))))
{
PackPassword (scratch, &NewSysPass);
writeRecord (scratch, rH);
MemPtrFree (scratch);
}
DmReleaseRecord (PasswordDB, 0, true);
}
// loop through the systems and re-encrypt
for (i = 0; i < totalSItems; i++)
{
System_old sys;
if ((rH = DmGetRecord (SystemDB, i)))
{
pac = MemHandleLock (rH);
if ((scratch = MemPtrNew (MemPtrSize (pac))))
{
// decrypt the system with old password
switch (v)
{
case 0:
UnpackSystem_old (&sys, pac, scratch, SysPass,
MemHandleSize (rH), true, 1);
scratch2 = MemPtrNew (getSystemSize((System *)&sys, true));
break;
case 1:
UnpackSystem_old (&sys, pac, scratch, SysPass,
MemHandleSize (rH), true, 2);
scratch2 = MemPtrNew (getSystemSize ((System *)&sys,true) );
break;
case 2:
UnpackSystem_old (&sys, pac, scratch, SysPass,
MemHandleSize (rH), true, 0);
scratch2 = MemPtrNew (getSystemSize ((System *)&sys, true ));
break;
}
if (scratch2)
{
PackSystem(scratch2, *((System *) &sys), &NewSysPass, true);
MemHandleUnlock (rH);
writeRecord (scratch2, rH);
senc++;
MemPtrFree (scratch2);
}
MemPtrFree (scratch);
}
DmReleaseRecord (SystemDB, i, true);
}
}
// loop through the accounts and re-encrypt
for (i = 0; i < totalAItems; i++)
{
Account_old ac;
Account ac_new;
if ((rH = DmGetRecord (AccountDB, i)))
{
pac = MemHandleLock (rH);
if ((scratch = MemPtrNew (MemPtrSize (pac))))
{
// decrypt the system with old password
switch (v)
{
case 0:
UnpackAccount_old(&ac, pac, scratch, SysPass,
MemHandleSize (rH), true, true, 1);
ChangeAccountFormat(i, &ac, &ac_new);
scratch2 = MemPtrNew (getAccountSize(&ac_new, true));
break;
case 1:
UnpackAccount_old (&ac, pac, scratch, SysPass,
MemHandleSize (rH), true, true, 2);
ChangeAccountFormat(i, &ac, &ac_new);
scratch2 = MemPtrNew (getAccountSize(&ac_new, true));
break;
case 2:
UnpackAccount_old(&ac, pac, scratch, SysPass,
MemHandleSize (rH), true, true, 0);
ChangeAccountFormat(i, &ac, &ac_new);
scratch2 = MemPtrNew (getAccountSize(&ac_new,true));
break;
}
if (scratch2)
{
PackAccount(scratch2, ac_new, &NewSysPass, true);
MemHandleUnlock (rH);
writeRecord (scratch2, rH);
aenc++;
MemPtrFree (scratch2);
}
MemPtrFree (scratch);
}
DmReleaseRecord (AccountDB, i, true);
}
}
FrmEraseForm (f);
FrmDeleteForm (f);
FrmSetActiveForm (preF);
// close databases.
DmCloseDatabase (SystemDB);
DmCloseDatabase (AccountDB);
DmCloseDatabase (PasswordDB);
{
UInt16 cardNo;
UInt32 type;
LocalID dbID;
DmSearchStateType search;
type = systemDBType;
DmGetNextDatabaseByTypeCreator(true, &search, systemDBTypeOld,
StripCreator, true, &cardNo, &dbID);
DmSetDatabaseInfo(cardNo, dbID, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, &type, NULL);
type = accountDBType;
DmGetNextDatabaseByTypeCreator(true, &search, accountDBTypeOld,
StripCreator, true, &cardNo, &dbID);
DmSetDatabaseInfo(cardNo, dbID, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, &type, NULL);
type = passwordDBType;
DmGetNextDatabaseByTypeCreator(true, &search, passwordDBTypeOld,
StripCreator, true, &cardNo, &dbID);
DmSetDatabaseInfo(cardNo, dbID, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, &type, NULL);
}
prefsSize = sizeof (StripPrefType);
prefsVersion = PrefGetAppPreferences (StripCreator, StripPrefID, &prefs, &prefsSize, true);
if (prefsVersion != StripVersionNumber) {
prefs.smart_beaming = false;
PrefSetAppPreferences (StripCreator, StripPrefID, StripVersionNumber,
&prefs, sizeof (StripPrefType), true);
prefsVersion = PrefGetAppPreferences (StripCreator, StripPrefID,
&prefs, &prefsSize, true);
}
StrIToA (s, senc);
StrIToA (a, aenc);
FrmCustomAlert (infoDialog, s, a, NULL);
StopApplication ();
SysReset ();
}
void ClosePrefsDatabase(void) {
DmCloseDatabase(JMPalmPrefs);
}
/***********************************************************************
* main function
***********************************************************************/
UInt32
PilotMain(UInt16 cmd, MemPtr cmdPBP, UInt16 launchFlags)
{
UInt16 error = RomVersionCompatible (MINVERSION, launchFlags);
if (error) return (error);
/***
* NORMAL STARTUP
****/
if ( cmd == sysAppLaunchCmdNormalLaunch ) {
error = StartApplication ();
if (error) {
// PalmOS before 3.5 will continuously relaunch this app unless we switch to
// another safe one.
if (error != dmErrCorruptDatabase) {
FrmCustomAlert(ALERT_debug, "Please reports this bug! Give your Palm device and PalmOS version, this BadBug(TM) should not happen.", "", "");
}
StopApplication();
AppLaunchWithCommand(sysFileCDefaultApp, sysAppLaunchCmdNormalLaunch, NULL);
return error;
}
FrmGotoForm(FORM_main);
AppEventLoop ();
StopApplication ();
/***
* FIND
****/
/*
} else if (cmd == sysAppLaunchCmdSaveData) {
FrmSaveAllForms();
} else if (cmd == sysAppLaunchCmdFind) {
PalmGlobalFind((FindParamsPtr)cmdPBP);
*/
/***
* GoTo
****/
/*
} else if (cmd == sysAppLaunchCmdGoTo) {
Boolean launched = launchFlags & sysAppLaunchFlagNewGlobals;
if (launched) {
error = StartApplication();
if (! error) {
GoToItem((GoToParamsPtr)cmdPBP, launched);
AppEventLoop();
StopApplication();
}
} else {
GoToItem((GoToParamsPtr)cmdPBP, launched);
}
*/
/***
* BEAMING
****/
} else if (cmd == sysAppLaunchCmdSyncNotify) {
// Register with the Exchange Manager
ExgRegisterData(APP_CREATOR, exgRegExtensionID, "umx");
} else if (cmd == sysAppLaunchCmdExgAskUser) {
// Always assume "Yes" as answer to the accept dialog since we display our
// own on which the user can cancel the data
ExgAskParamType *exgAskParam = (ExgAskParamType *)cmdPBP;
exgAskParam->result=exgAskOk;
} else if (cmd == sysAppLaunchCmdExgReceiveData) {
DmOpenRef cats=NULL, dogs=NULL;
// Is app active?
if (launchFlags & sysAppLaunchFlagSubCall) {
// Quit Forms
FrmSaveAllForms();
cats = DatabaseGetRefN(DB_MAIN);
dogs = DatabaseGetRefN(DB_DATA);
error = BeamReceive(cats, dogs, (ExgSocketPtr) cmdPBP);
CacheReset();
FrmGotoForm(FORM_main);
} else {
// Another app was running when we were called
cats = DmOpenDatabaseByTypeCreator(DATABASE_TYPE, APP_CREATOR, dmModeReadWrite);
dogs = DmOpenDatabaseByTypeCreator(DATABASE_DATA_TYPE, APP_CREATOR, dmModeReadWrite);
if (! (cats && dogs)) {
FrmAlert(ALERT_beamdbfail);
} else {
error=BeamReceive(cats, dogs, (ExgSocketPtr)cmdPBP);
}
if (cats) DmCloseDatabase(cats);
if (dogs) DmCloseDatabase(dogs);
}
/***
* ALARM
****/
} else if (cmd == sysAppLaunchCmdAlarmTriggered) {
// Is app active?
if (launchFlags & sysAppLaunchFlagSubCall) {
AlarmTriggered(DatabaseGetRefN(DB_MAIN), (SysAlarmTriggeredParamType *)cmdPBP);
} else {
DmOpenRef cats = DmOpenDatabaseByTypeCreator(DATABASE_TYPE, APP_CREATOR, dmModeReadWrite);
AlarmTriggered(cats, (SysAlarmTriggeredParamType *)cmdPBP);
DmCloseDatabase(cats);
}
/***
* ATTENTION
****/
} else if (cmd == sysAppLaunchCmdAttention) {
// Is app active?
if (launchFlags & sysAppLaunchFlagSubCall) {
AttentionBottleNeckProc(DatabaseGetRefN(DB_MAIN), (AttnLaunchCodeArgsType *)cmdPBP);
} else {
// Another app was running when we were called
DmOpenRef cats = DmOpenDatabaseByTypeCreator(DATABASE_TYPE, APP_CREATOR, dmModeReadWrite);
AttentionBottleNeckProc(cats, (AttnLaunchCodeArgsType *)cmdPBP);
DmCloseDatabase(cats);
}
/***
* ATTENTION GOTO
****/
} else if (cmd == appLaunchCmdAlarmEventGoto) {
error = StartApplication ();
if (error) {
// PalmOS before 3.5 will continuously relaunch this app unless we switch to
// another safe one.
if (error != dmErrCorruptDatabase) {
FrmCustomAlert(ALERT_debug, "Please reports this bug! Give your Palm device and PalmOS version, this BadBug(TM) should not happen.", "", "");
}
StopApplication();
AppLaunchWithCommand(sysFileCDefaultApp, sysAppLaunchCmdNormalLaunch, NULL);
return error;
}
ExamSetGoto(*(UInt32 *)cmdPBP);
FrmGotoForm(FORM_exams);
AppEventLoop ();
StopApplication ();
/***
* TIME CHANGE
****/
// Launch code sent when the system time is changed.
} else if (cmd == sysAppLaunchCmdTimeChange) {
// reset the trigger for the next alarm to fire
if (launchFlags & sysAppLaunchFlagSubCall) {
AlarmReset(DatabaseGetRefN(DB_MAIN));
// Remove any "future" alarms from the attention manager queue
// (ie alarms that will trigger after the new time setting)
//AlarmUpdatePosted(DeviceTimeChanged);
} else {
// Another app was running when we were called
DmOpenRef cats = DmOpenDatabaseByTypeCreator(DATABASE_TYPE, APP_CREATOR, dmModeReadWrite);
if (cats != 0) {
AlarmReset(cats);
//AlarmUpdatePosted(DeviceTimeChanged);
DmCloseDatabase(cats);
}
}
/***
* RESET
****/
// This action code is sent after the system is reset.
} else if (cmd == sysAppLaunchCmdSystemReset) {
if (! ((SysAppLaunchCmdSystemResetType*)cmdPBP)->hardReset) {
if (launchFlags & sysAppLaunchFlagSubCall) {
AlarmReset(DatabaseGetRefN(DB_MAIN));
} else {
// Another app was running when we were called
DmOpenRef cats = DmOpenDatabaseByTypeCreator(DATABASE_TYPE, APP_CREATOR, dmModeReadWrite);
if (cats != 0) {
AlarmReset(cats);
DmCloseDatabase(cats);
}
}
}
}
return 0;
}
TDataMgr::~TDataMgr()
{
ErrFatalDisplayIf(m_db == NULL, "No open db");
DmCloseDatabase(m_db);
}