/*************************************************************************
Check if all window factory aliases are registered
*************************************************************************/
bool Scheme::areFactoryAliasesLoaded() const
{
WindowFactoryManager& wfmgr = WindowFactoryManager::getSingleton();
std::vector<AliasMapping>::const_iterator alias = d_aliasMappings.begin();
// check aliases
for (;alias != d_aliasMappings.end(); ++alias)
{
// get iterator
WindowFactoryManager::TypeAliasIterator iter = wfmgr.getAliasIterator();
// look for this alias
while (!iter.isAtEnd() && (iter.getCurrentKey() != (*alias).aliasName))
++iter;
// if the alias exists
if (!iter.isAtEnd())
{
// if the current target type matches
if (iter.getCurrentValue().getActiveTarget() == (*alias).targetName)
// target matches, assume we set it and continue to next alias
continue;
}
// no alias or target type does not match
return false;
}
return true;
}
/*************************************************************************
Create all window factory aliases
*************************************************************************/
void Scheme::loadFactoryAliases()
{
WindowFactoryManager& wfmgr = WindowFactoryManager::getSingleton();
// check aliases
std::vector<AliasMapping>::iterator alias = d_aliasMappings.begin();
for (;alias != d_aliasMappings.end(); ++alias)
{
// get iterator
WindowFactoryManager::TypeAliasIterator iter = wfmgr.getAliasIterator();
// look for this alias
while (!iter.isAtEnd() && (iter.getCurrentKey() != (*alias).aliasName))
++iter;
// if the alias exists
if (!iter.isAtEnd())
{
// if the current target type matches
if (iter.getCurrentValue().getActiveTarget() == (*alias).targetName)
{
// assume this mapping is ours and skip to next alias
continue;
}
}
// create a new alias entry
wfmgr.addWindowTypeAlias((*alias).aliasName, (*alias).targetName);
}
}
/*************************************************************************
Load all resources for this scheme
*************************************************************************/
void Scheme::loadResources(void)
{
Logger::getSingleton().logEvent((utf8*)"---- Begining resource loading for GUI scheme '" + d_name + "' ----", Informative);
ImagesetManager& ismgr = ImagesetManager::getSingleton();
FontManager& fntmgr = FontManager::getSingleton();
WindowFactoryManager& wfmgr = WindowFactoryManager::getSingleton();
WidgetLookManager& wlfMgr = WidgetLookManager::getSingleton();
std::vector<LoadableUIElement>::const_iterator pos;
// check imagesets
for (pos = d_imagesets.begin(); pos != d_imagesets.end(); ++pos)
{
if (!ismgr.isImagesetPresent((*pos).name))
{
Imageset* iset = ismgr.createImageset((*pos).filename, (*pos).resourceGroup);
// check for wrong imageset for specified name
String realname = iset->getName();
if (realname != (*pos).name)
{
ismgr.destroyImageset(iset);
throw InvalidRequestException((utf8*)"Scheme::loadResources - The Imageset created by file '" +
(*pos).filename + "' is named '" + realname + "', not '" + (*pos).name + "' as required by Scheme '" + d_name + "'.");
}
}
}
// check imagesets that are created directly from image files
for (pos = d_imagesetsFromImages.begin(); pos != d_imagesetsFromImages.end(); ++pos)
{
if (!ismgr.isImagesetPresent((*pos).name))
ismgr.createImagesetFromImageFile((*pos).name, (*pos).filename, (*pos).resourceGroup);
}
// check fonts
for (pos = d_fonts.begin(); pos != d_fonts.end(); ++pos)
{
if (!fntmgr.isFontPresent((*pos).name))
{
Font* font = fntmgr.createFont((*pos).filename, (*pos).resourceGroup);
// check for wrong font for specified name
String realname = font->getName();
if (realname != (*pos).name)
{
fntmgr.destroyFont(font);
throw InvalidRequestException((utf8*)"Scheme::loadResources - The Font created by file '" +
(*pos).filename + "' is named '" + realname + "', not '" + (*pos).name + "' as required by Scheme '" + d_name + "'.");
}
}
}
// load look'n'feels (can't actually check these, so just re-parse data; it does no harm except maybe wase a bit of time)
for (pos = d_looknfeels.begin(); pos != d_looknfeels.end(); ++pos)
{
wlfMgr.parseLookNFeelSpecification((*pos).filename, (*pos).resourceGroup);
}
// check factories
std::vector<UIModule>::iterator cmod = d_widgetModules.begin();
for (; cmod != d_widgetModules.end(); ++cmod)
{
// create and load dynamic module as required
if ((*cmod).module == NULL)
{
(*cmod).module = new FactoryModule((*cmod).name);
}
// see if we should just register all factories available in the module (i.e. No factories explicitly specified)
if ((*cmod).factories.size() == 0)
{
Logger::getSingleton().logEvent("No window factories specified for module '" + (*cmod).name + "' - adding all available factories...");
(*cmod).module->registerAllFactories();
}
// some names were explicitly given, so only register those.
else
{
std::vector<UIElementFactory>::const_iterator elem = (*cmod).factories.begin();
for (; elem != (*cmod).factories.end(); ++elem)
{
if (!wfmgr.isFactoryPresent((*elem).name))
{
(*cmod).module->registerFactory((*elem).name);
}
}
}
}
// check aliases
std::vector<AliasMapping>::iterator alias = d_aliasMappings.begin();
for (; alias != d_aliasMappings.end(); ++alias)
{
// get iterator
WindowFactoryManager::TypeAliasIterator iter = wfmgr.getAliasIterator();
// look for this alias
while (!iter.isAtEnd() && (iter.getCurrentKey() != (*alias).aliasName))
++iter;
// if the alias exists
if (!iter.isAtEnd())
{
// if the current target type matches
if (iter.getCurrentValue().getActiveTarget() == (*alias).targetName)
{
// assume this mapping is ours and skip to next alias
continue;
}
}
// create a new alias entry
wfmgr.addWindowTypeAlias((*alias).aliasName, (*alias).targetName);
}
// check falagard window mappings.
std::vector<FalagardMapping>::iterator falagard = d_falagardMappings.begin();
for (; falagard != d_falagardMappings.end(); ++falagard)
{
// get iterator
WindowFactoryManager::FalagardMappingIterator iter = wfmgr.getFalagardMappingIterator();
// look for this mapping
while (!iter.isAtEnd() && (iter.getCurrentKey() != (*falagard).windowName))
++iter;
// if the alias exists
if (!iter.isAtEnd())
{
// if the current target and looks match
if ((iter.getCurrentValue().d_baseType == (*falagard).targetName) &&
(iter.getCurrentValue().d_lookName == (*falagard).lookName))
{
// assume this mapping is ours and skip to next
continue;
}
}
// create a new mapping entry
wfmgr.addFalagardWindowMapping((*falagard).windowName, (*falagard).targetName, (*falagard).lookName);
}
Logger::getSingleton().logEvent((utf8*)"---- Resource loading for GUI scheme '" + d_name + "' completed ----", Informative);
}
/*************************************************************************
Check if all resources for this Scheme are loaded
*************************************************************************/
bool Scheme::resourcesLoaded(void) const
{
ImagesetManager& ismgr = ImagesetManager::getSingleton();
FontManager& fntmgr = FontManager::getSingleton();
WindowFactoryManager& wfmgr = WindowFactoryManager::getSingleton();
std::vector<LoadableUIElement>::const_iterator pos;
// check imagesets
for (pos = d_imagesets.begin(); pos != d_imagesets.end(); ++pos)
{
if (!ismgr.isImagesetPresent((*pos).name))
{
return false;
}
}
// check fonts
for (pos = d_fonts.begin(); pos != d_fonts.end(); ++pos)
{
if (!fntmgr.isFontPresent((*pos).name))
{
return false;
}
}
// check factories
std::vector<UIModule>::const_iterator cmod = d_widgetModules.begin();
for (; cmod != d_widgetModules.end(); ++cmod)
{
std::vector<UIElementFactory>::const_iterator elem = (*cmod).factories.begin();
for (; elem != (*cmod).factories.end(); ++elem)
{
if (!wfmgr.isFactoryPresent((*elem).name))
{
return false;
}
}
}
// check aliases
std::vector<AliasMapping>::const_iterator alias = d_aliasMappings.begin();
for (; alias != d_aliasMappings.end(); ++alias)
{
// get iterator
WindowFactoryManager::TypeAliasIterator iter = wfmgr.getAliasIterator();
// look for this alias
while (!iter.isAtEnd() && (iter.getCurrentKey() != (*alias).aliasName))
++iter;
// if the alias exists
if (!iter.isAtEnd())
{
// if the current target type matches
if (iter.getCurrentValue().getActiveTarget() == (*alias).targetName)
{
// target matches, assume we set it and continue to next alias
continue;
}
}
// no alias or target type does not match
return false;
}
return true;
}