/* 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 );
}
void IntlInit(void)
{
Err result;
MemHandle localeCodeH;
MemHandle tableListH;
MemHandle featureTableH;
ROMFtrTableType* featureTableP;
ROMFtrCreatorType* creatorTableP;
UInt16 creators;
Boolean fastSort = true;
Boolean fastSearch = true;
Boolean fastAttr = true;
UInt16 index;
UInt32 intlFtrFlags;
#if (EMULATION_LEVEL == EMULATION_NONE)
UInt16 systemCard;
LocalID systemID;
DmSearchStateType* searchStateP;
MemHandle localeNameH;
LocalID moduleID;
DmOpenRef moduleRef;
// Locate the system DB, so that we know where to look (which card)
// for the locale module.
searchStateP = (DmSearchStateType*)MemPtrNew(sizeof(DmSearchStateType));
result = DmGetNextDatabaseByTypeCreator( true,
searchStateP,
sysFileTSystem,
sysFileCSystem,
true, // onlyLatestVers
&systemCard,
&systemID);
ErrNonFatalDisplayIf((result != errNone) || (systemID == 0), "Can't find system DB");
MemPtrFree((MemPtr)searchStateP);
localeNameH = DmGetResource(strRsc, localeModuleNameStrID);
ErrNonFatalDisplayIf(localeNameH == NULL, "Missing locale module name string");
moduleID = DmFindDatabaseWithTypeCreator( systemCard,
(Char*)MemHandleLock(localeNameH),
sysFileTLocaleModule,
sysFileCSystem);
MemHandleUnlock(localeNameH);
if (moduleID != 0)
{
moduleRef = DmOpenDatabase(systemCard, moduleID, dmModeReadOnly | dmModeLeaveOpen);
ErrNonFatalDisplayIf(moduleRef == 0, "Can't open locale module");
if (ResLoadConstant(kIntlLMVersResID) != kIntlLMVersion)
{
DmCloseDatabase(moduleRef);
moduleID = 0;
}
}
// If we couldn't find the locale module, or it has the wrong version, then
// default to the ROM locale's locale module.
if (moduleID == 0)
{
SysNVParamsType* romParamsP;
OmLocaleType romLocale;
Char* overlayName;
LocalID overlayID;
DmOpenRef overlayRef;
Char* systemName;
// Open up the system overlay that corresponds to the ROM's locale.
// Note that (assuming the ROM locale != current locale) we have to
// try to open up the overlay explicitly, since the Overlay Mgr
// won't be opening it automatically. We also have to handle the case
// of a ROM built without overlays, in which case the ROM locale's
// locale module name string is located in the base, which means we
// have to make a low-level resource call to get it (otherwise we'll
// get the string from the system overlay).
romParamsP = (SysNVParamsType*)MemPtrNew(sizeof(SysNVParamsType));
MemGetRomNVParams(romParamsP);
romLocale.country = romParamsP->localeCountry;
romLocale.language = romParamsP->localeLanguage;
MemPtrFree((MemPtr)romParamsP);
// Get the name of the system DB, so that we can construct the overlay
// name.
systemName = (Char*)MemPtrNew(dmDBNameLength);
overlayName = (Char*)MemPtrNew(dmDBNameLength);
result = DmDatabaseInfo(systemCard, systemID, systemName,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
ErrNonFatalDisplayIf(result != errNone, "Can't get system DB info");
result = OmLocaleToOverlayDBName(systemName, &romLocale, overlayName);
ErrNonFatalDisplayIf(result != errNone, "Can't make ROM locale system overlay name");
overlayID = DmFindDatabaseWithTypeCreator(systemCard,
overlayName,
sysFileTOverlay,
sysFileCSystem);
MemPtrFree(systemName);
MemPtrFree((MemPtr)overlayName);
if (overlayID != 0)
{
overlayRef = DmOpenDatabase(systemCard, overlayID, dmModeReadOnly);
ErrNonFatalDisplayIf(overlayRef == 0, "Can't open system overlay");
// Now load the locale module name string from this overlay, and use
// it to find the locale module.
localeNameH = DmGet1Resource(strRsc, localeModuleNameStrID);
ErrNonFatalDisplayIf(localeNameH == NULL, "Missing locale module name string");
moduleID = DmFindDatabaseWithTypeCreator( systemCard,
(Char*)MemHandleLock(localeNameH),
sysFileTLocaleModule,
sysFileCSystem);
MemHandleUnlock(localeNameH);
DmCloseDatabase(overlayRef);
}
else
{
// Assume it's a ROM built without overlays, in which case we need to
// get the locale name handle from the system base.
DmOpenRef sysRef = NULL;
Int16 index;
do
{
LocalID dbID;
sysRef = DmNextOpenResDatabase(sysRef);
if ((sysRef != NULL)
&& (DmOpenDatabaseInfo(sysRef, &dbID, NULL, NULL, NULL, NULL) == errNone)
&& (dbID == systemID))
{
break;
}
} while (sysRef != NULL);
ErrNonFatalDisplayIf(sysRef == NULL, "Can't find system DB");
index = DmFindResource(sysRef, strRsc, localeModuleNameStrID, NULL);
ErrNonFatalDisplayIf(index == -1, "Missing locale module name string");
localeNameH = DmGetResourceIndex(sysRef, index);
ErrNonFatalDisplayIf(localeNameH == NULL, "Missing locale module name string");
moduleID = DmFindDatabaseWithTypeCreator( systemCard,
(Char*)MemHandleLock(localeNameH),
sysFileTLocaleModule,
sysFileCSystem);
}
// If we found the locale module DB, open it up and make sure it has
// the right version.
if (moduleID != 0)
{
moduleRef = DmOpenDatabase(systemCard, moduleID, dmModeReadOnly | dmModeLeaveOpen);
if ((moduleRef == 0)
|| (ResLoadConstant(kIntlLMVersResID) != kIntlLMVersion))
{
// Trigger fatal alert below. No need to close the DB in that case.
moduleID = 0;
}
else
{
// We found a valid locale module, using the ROM locale, so set
// the current locale to be the ROM locale.
result = FtrSet(sysFtrCreator, sysFtrNumLanguage, romLocale.language);
if (result == errNone)
{
result = FtrSet(sysFtrCreator, sysFtrNumCountry, romLocale.country);
}
ErrNonFatalDisplayIf(result != errNone, "Can't switch current locale to ROM locale");
}
}
ErrFatalDisplayIf(moduleID == 0, "No valid locale module");
}
result = DmDatabaseProtect(systemCard, moduleID, true);
if (result != dmErrROMBased)
{
ErrNonFatalDisplayIf(result != errNone, "Can't protect locale module");
}
#else
// Give the locale module code in the Simulator a chance to
// initialize itself. If there's no such code (e.g. with latin) then the
// routine in SimStubs.cp does nothing.
StubPalmOSInitLocaleModule();
#endif
// If there's a locale module code resource, load & call it now.
localeCodeH = DmGet1Resource(kIntlLMCodeType, kIntlLMCodeResID);
if (localeCodeH != NULL)
{
ProcPtr localeCodeP = (ProcPtr)MemHandleLock(localeCodeH);
(*localeCodeP)();
MemHandleUnlock(localeCodeH);
}
// If the IntlMgr data ptr hasn't been set up by the locale module code,
// allocate it now.
if (GIntlMgrGlobalsP == NULL)
{
UInt16 numCustomTransTables;
MemPtr globalPtr;
numCustomTransTables = ResLoadConstant(kIntlLMCustomTransCountID);
ErrNonFatalDisplayIf(numCustomTransTables > kIntlMaxCustomTransliterations,
"Too many custom transliterations");
globalPtr = MemPtrNew(sizeof(IntlGlobalsType) + (numCustomTransTables * sizeof(void*)));
ErrNonFatalDisplayIf(globalPtr == NULL, "Out of memory");
MemSet(globalPtr, sizeof(IntlGlobalsType) + (numCustomTransTables * sizeof(void*)), 0);
GIntlMgrGlobalsP = globalPtr;
GIntlData->numCustomTransliterations = numCustomTransTables;
}
else
{
// If any of the sorting tables are already configured, we can't do
// our fast sorting optimization.
for (index = 0; index < kIntlMaxSortLevels; index++)
{
if (GIntlData->sortTables[index] != NULL)
{
fastSort = false;
break;
}
}
// If the word start or word match tables are already configured, we
// can't do our fast word search optimization.
if ((GIntlData->findWordStartTable != NULL)
|| (GIntlData->findWordMatchTable != NULL))
{
fastSearch = false;
}
// If the character attribute table is already configured, we can't do
// our fast attribute optimization.
if (GIntlData->charAttrTable != NULL)
{
fastAttr = false;
}
}
// Loop over all of the table resources, locking & setting up pointers in
// the IntlMgr global data structure.
tableListH = DmGet1Resource(kIntlLMTableListType, kIntlLMTableListResID);
if (tableListH != NULL)
{
IntlLMTableEntryType* curTable;
UInt8* globalsP = (UInt8*)GIntlMgrGlobalsP;
IntlLMTableResType* tableListP = (IntlLMTableResType*)MemHandleLock(tableListH);
for (index = 0, curTable = tableListP->resources; index < tableListP->numResources; index++, curTable++)
{
void** ptrLocation;
MemHandle tableH;
tableH = DmGet1Resource(curTable->resType, curTable->resID);
ErrFatalDisplayIf(tableH == NULL, "Missing table resource from locale module");
ErrFatalDisplayIf(curTable->tableIndex >= intlLMNumTableIndexes, "Invalid table index");
ptrLocation = (void**)(globalsP + kIntlGlobalOffsets[curTable->tableIndex]);
ErrFatalDisplayIf(*ptrLocation != NULL, "Resource overriding existing table ptr");
*ptrLocation = MemHandleLock(tableH);
}
MemHandleUnlock(tableListH);
}
// Note that we can't check for the presence of tables here, as a table that
// is required by a Text Mgr routine might be NULL if the locale module has
// patched out that routine.
// As an optimization, see if all of the sorting tables are byte-indexed 8-bit
// values. If so, then replace the table ptrs with ptrs to the actual data,
// and set the fast sorting intl mgr flag.
for (index = 0; (index < kIntlMaxSortLevels) && fastSort; index++)
{
void* sortTable = GIntlData->sortTables[index];
if (sortTable == NULL)
{
break;
}
else if (PrvGetByteIndexedTable(sortTable, 8) == NULL)
{
fastSort = false;
}
}
if (fastSort)
{
GIntlData->intlFlags |= kByteSortingFlag;
for (index = 0; index < kIntlMaxSortLevels; index++)
{
GIntlData->sortTables[index] = PrvGetByteIndexedTable(GIntlData->sortTables[index], 8);
}
}
// As an optimization, see if all of the searching tables are byte-indexed 8-bit
// values. If so, then replace the table ptrs with ptrs to the actual data,
// and set the fast searching intl mgr flag. Note that PrvGetByteIndexedTable
// will return NULL if findWordMatchTable is NULL, which is OK because then
// TxtFindString must be patched out anyway. The findWordStartTable is optional,
// and thus it can either be NULL or a byte indexed byte table.
if ((fastSearch)
&& ((GIntlData->findWordStartTable == NULL)
|| (PrvGetByteIndexedTable(GIntlData->findWordStartTable, 8) != NULL))
&& (PrvGetByteIndexedTable(GIntlData->findWordMatchTable, 8) != NULL))
{
GIntlData->intlFlags |= kByteSearchingFlag;
GIntlData->findWordStartTable = PrvGetByteIndexedTable(GIntlData->findWordStartTable, 8);
GIntlData->findWordMatchTable = PrvGetByteIndexedTable(GIntlData->findWordMatchTable, 8);
}
// As an optimization, see if the character attribute table is a byte-indexed
// table of 16-bit values. If so, then replace the table ptr with a ptr to
// the data, and set the kByteCharAttrFlag flag.
if (fastAttr && (PrvGetByteIndexedTable(GIntlData->charAttrTable, 16) != NULL))
{
GIntlData->intlFlags |= kByteCharAttrFlag;
GIntlData->charAttrTable = PrvGetByteIndexedTable(GIntlData->charAttrTable, 16);
// As an optimization, see if the character attribute table is a stage index map
// table of 16-bit values. If so, then replace the table ptr with a ptr to
// the sub-table offsets, set up the result table ptr, and set the
// kStageCharAttrFlag flag.
}
else if (fastAttr && PrvGetStageIndexMapTable(GIntlData->charAttrTable, 16))
{
GIntlData->intlFlags |= kStageCharAttrFlag;
GIntlData->charAttrTable = PrvGetStageIndexMapTable(GIntlData->charAttrTable, 16);
}
// If there's a doubleCharTable, we want to (a) verify that it's a byte-indexed
// byte table, and (b) set up the pointer now.
if (GIntlData->doubleCharTable != NULL)
{
void* tableP = PrvGetByteIndexedTable(GIntlData->doubleCharTable, 8);
ErrNonFatalDisplayIf(tableP == NULL, "Double-char table isn't byte-indexed byte table");
GIntlData->doubleCharTable = tableP;
}
// Load the 'feat' resource from the locale module, and use it to initialize
// various locale-specific features. Typically this includes sysFtrNumCharEncodingFlags,
// sysFtrNumEncoding, sysFtrDefaultFont, and sysFtrDefaultBoldFont.
// Try to load the 'feat' resource.
featureTableH = DmGet1Resource(sysResTFeatures, kIntlLMFeatureResID);
ErrFatalDisplayIf(featureTableH == NULL, "Missing feature table");
featureTableP = (ROMFtrTableType*)MemHandleLock(featureTableH);
creatorTableP = featureTableP->creator;
for (creators = 0; creators < featureTableP->numEntries; creators++)
{
UInt16 features;
for (features = 0; features < creatorTableP->numEntries; features++)
{
result = FtrSet( creatorTableP->creator,
creatorTableP->feature[features].num,
creatorTableP->feature[features].value);
ErrNonFatalDisplayIf(result != errNone, "Can't set locale feature");
}
// Advance to next creator table.
creatorTableP = (ROMFtrCreatorType*)((UInt8*)creatorTableP
+ sizeof(ROMFtrCreatorType)
+ (creatorTableP->numEntries * sizeof(ROMFtrFeatureType)));
}
MemHandleUnlock(featureTableH);
// Now, set up our internal kByteSearchingFlag flag based on the sysFtrNumCharEncodingFlags
// feature value. This means that sysFtrNumCharEncodingFlags is read-only, since if
// anybody uses FtrSet to change the settings of the flags, that won't update
// our internal flag(s).
if ((FtrGet(sysFtrCreator, sysFtrNumCharEncodingFlags, &intlFtrFlags) == errNone)
&& ((intlFtrFlags & charEncodingOnlySingleByte) != 0))
{
GIntlData->intlFlags |= kSingleByteOnlyFlag;
}
// Finally set the bit that tells everybody we're ready to support IntlMgr/TextMgr calls.
FtrSet(sysFtrCreator, sysFtrNumIntlMgr, intlMgrExists);
} // IntlInit
