CORE::CString
GetUniqueFileName( const CORE::CString& filename )
{GUCEF_TRACE;
CORE::CString fileExt = CORE::ExtractFileExtention( filename );
CORE::CString fileWithoutExt;
if ( fileExt.IsNULLOrEmpty() )
{
fileWithoutExt = filename;
}
else
{
fileWithoutExt = filename.CutChars( fileExt.Length()+1, false );
}
CORE::UInt32 i = 2;
CORE::CString filenameToTest = filename;
while ( CORE::FileExists( filenameToTest ) )
{
filenameToTest = fileWithoutExt + '(' + CORE::UInt32ToString( i ) + ")." + fileExt;
++i;
}
return filenameToTest;
}
void
Win32EnumPorts( std::list<Int32>& portlist )
{
portlist.clear();
// use querydosdevice on NT/2000/xp (no need to open ports...)
if ( VER_PLATFORM_WIN32_NT == Win32GetOSVersion() )
{
const int bufferSize = 65535;
CORE::CDynamicBuffer deviceNameBuffer( bufferSize, true );
// Read the list of devices into the buffer
Int32 len = ::QueryDosDevice( 0, deviceNameBuffer.AsTypePtr< char >(), bufferSize );
for ( Int32 n=0; n<len; ++n )
{
// if found "COM", then add number to list
if ( 0 == _stricmp( deviceNameBuffer.AsConstTypePtr< char >( n ), "COM" ) )
{
portlist.push_back( atoi( deviceNameBuffer.AsConstTypePtr< char >( n+3 ) ) );
}
// find next null pointer
while ( deviceNameBuffer.AsConstType< char >( n ) != '\0' )
{
++n;
}
}
}
// else, open port 1-255
else
{
CORE::CString basePath( "\\\\.\\COM" );
for ( Int32 i=1; i<255; ++i )
{
CORE::CString portPath = basePath + CORE::Int32ToString( i );
// try to open port
bool result = false;
::HANDLE handle = ::CreateFile( portPath.C_String(), GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0 );
if ( INVALID_HANDLE_VALUE == handle ) continue;
::CloseHandle( handle );
portlist.push_back( i );
}
}
}
bool
RenameFileAsBackup( const CORE::CString& filepath )
{GUCEF_TRACE;
CORE::CString newFilepath = filepath + ".backup";
if ( 0 != CORE::Move_File( newFilepath.C_String() ,
filepath.C_String() ) )
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "File \"" + filepath + "\" has been renamed to \"" + newFilepath + "\"" );
return true;
}
else
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "Failed to rename file \"" + filepath + "\" to \"" + newFilepath + "\"" );
return false;
}
}
bool
DeleteFileBackup( const CORE::CString& filepath )
{GUCEF_TRACE;
CORE::CString newFilepath = filepath + ".backup";
if ( CORE::FileExists( newFilepath ) )
{
if ( 0 != CORE::Delete_File( newFilepath.C_String() ) )
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "File \"" + newFilepath + "\" has been deleted" );
return true;
}
else
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "Failed to delete file \"" + newFilepath + "\"" );
return false;
}
}
return true;
}
bool
CLogSvcClient::OnTaskCycleLog( const TLogMsgType logMsgType ,
const CORE::Int32 logLevel ,
const CORE::CString& logMessage ,
const CORE::UInt32 threadId )
{GUCEF_TRACE;
CORE::Int16 logMsgTypeValue = logMsgType;
CORE::Int8 msgHeader[ 16 ]; // 16 = 1+4+1+2+4+4
CORE::UInt32 logMsgLength = logMessage.Length() + 11;
msgHeader[ 0 ] = (CORE::Int8) LOGSVCMSGTYPE_DELIMITER; // set delimiter for message: 1 byte
memcpy( msgHeader+1, &logMsgLength, 4 ); // set the total message length : 4 bytes
msgHeader[ 5 ] = (CORE::Int8) LOGSVCMSGTYPE_LOGMSG; // set TCP msg type: 1 byte
memcpy( msgHeader+6, &logMsgTypeValue, 2 ); // set log msg type: 2 bytes
memcpy( msgHeader+8, &logLevel, 4 ); // set log level: 4 bytes
memcpy( msgHeader+12, &threadId, 4 ); // set thread id: 4 bytes
if ( m_connectionInitialized )
{
// Send the logging msg header
if ( m_tcpClient.Send( msgHeader, 16 ) )
{
// Now send the logging text
m_tcpClient.Send( logMessage.C_String() ,
logMessage.Length() );
}
}
else
{
// The logging connection is not initialized yet
// queue the msg until the connection is initialized
TLogMessage queueItem;
memcpy( queueItem.msgHeader, msgHeader, 16 );
queueItem.logMsg = logMessage;
m_logQueue.push_back( queueItem );
}
return true;
}
bool
LoadConfig( const CORE::CString& configPath ,
CORE::CValueList& keyValueList )
{GUCEF_TRACE;
#ifdef GUCEF_DEBUG_MODE
const CORE::CString configFile = "ProjectGenerator_d.ini";
#else
const CORE::CString configFile = "ProjectGenerator.ini";
#endif
CORE::CString configFilePath;
bool foundViaParam = false;
if ( !configPath.IsNULLOrEmpty() )
{
GUCEF_LOG( CORE::LOGLEVEL_BELOW_NORMAL, "Checking for config file @ " + configPath );
foundViaParam = CORE::FileExists( configPath );
configFilePath = configPath;
}
if ( !foundViaParam )
{
CORE::CString configFilePath = CORE::CombinePath( "$CURWORKDIR$", configFile );
configFilePath = CORE::RelativePath( configFilePath );
GUCEF_LOG( CORE::LOGLEVEL_BELOW_NORMAL, "Checking for config file @ " + configFilePath );
if ( !CORE::FileExists( configFilePath ) )
{
configFilePath = CORE::CombinePath( "$MODULEDIR$", configFile );
configFilePath = CORE::RelativePath( configFilePath );
GUCEF_LOG( CORE::LOGLEVEL_BELOW_NORMAL, "Checking for config file @ " + configFilePath );
if ( !FileExists( configFilePath ) )
{
GUCEF_WARNING_LOG( CORE::LOGLEVEL_NORMAL, "Unable to locate any config file, will rely on params" );
return false;
}
}
}
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Located config file @ " + configFilePath );
keyValueList.SetConfigNamespace( "Bootstrap/Main/AppArgs" );
keyValueList.SetUseGlobalConfig( true );
keyValueList.SetAllowDuplicates( false );
keyValueList.SetAllowMultipleValues( true );
CORE::CConfigStore& configStore = CORE::CCoreGlobal::Instance()->GetConfigStore();
configStore.SetConfigFile( configFilePath );
return configStore.LoadConfig();
}
bool
CResArchive::LoadArchive( const VFS::CString& archiveName ,
const VFS::CString& archivePath ,
const bool writableRequest )
{GUCEF_TRACE;
// We do not support writable archives
if ( writableRequest ) return false;
// Since we always need both the index file and the resource file
// already construct the paths for both
CORE::CString fileExt = CORE::ExtractFileExtention( archivePath ).Uppercase();
if ( fileExt.IsNULLOrEmpty() )
{
m_idxPath = m_resPath = archivePath;
m_idxPath += ".IDX";
m_resPath += ".RES";
}
else
if ( fileExt.Equals( "RES", false ) )
{
m_resPath = archivePath;
m_idxPath = archivePath.CutChars( 4, false, 0 ) + ".IDX";
}
else
if ( fileExt.Equals( "IDX", false ) )
{
m_idxPath = archivePath;
m_resPath = archivePath.CutChars( 4, false, 0 ) + ".RES";
}
m_archiveName = archiveName;
m_archivePath = archivePath;
return LoadIndex();
}
bool
CGUIDriverOgre::Init( GUI::TWindowContextPtr windowContext )
{
if ( !m_ceGuiInitialized )
{
try
{
Ogre::RenderTarget* renderTarget = nullptr;
CORE::CString renderTargetPtrStr = windowContext->GetProperty( "Ogre::RenderTarget" );
if ( !renderTargetPtrStr.IsNULLOrEmpty() )
{
renderTarget = static_cast< Ogre::RenderTarget* >( CORE::StringToPointer( renderTargetPtrStr ) );
if ( NULL == renderTarget )
return false;
}
Ogre::SceneManager* sceneManager = nullptr;
CORE::CString sceneManagerPtrStr = windowContext->GetProperty( "Ogre::SceneManager" );
if ( !sceneManagerPtrStr.IsNULLOrEmpty() )
{
sceneManager = static_cast< Ogre::SceneManager* >( CORE::StringToPointer( sceneManagerPtrStr ) );
if ( NULL == sceneManager )
return false;
}
// Auto-create a viewport here if none exists yet
unsigned short viewportCount = renderTarget->getNumViewports();
if ( 0 == viewportCount )
{
Ogre::Camera* camera = sceneManager->createCamera( "CEGUI" );
camera->setPosition( Ogre::Vector3( 0, 0, 500 ) );
camera->lookAt( Ogre::Vector3( 0, 0, -300 ) );
camera->setNearClipDistance( 5 );
// Create a viewport covering whole window
Ogre::Viewport* viewport = renderTarget->addViewport( camera );
viewport->setBackgroundColour( Ogre::ColourValue( 0.0f, 0.0f, 0.0f, 0.0f ) );
viewport->setOverlaysEnabled( true );
// Update the camera aspect ratio to that of the viewport
camera->setAspectRatio( Ogre::Real( viewport->getActualWidth() ) / Ogre::Real( viewport->getActualHeight() ) );
}
CEGUI::Sizef displaySize( (float) windowContext->GetWidth(), (float) windowContext->GetHeight() );
m_guiRenderer = &CEGUI::OgreRenderer::create( *renderTarget );// displaySize );//, CEGUI::OpenGLRenderer::TTT_AUTO );
m_guiRenderer->setDefaultRootRenderTarget( *renderTarget );
m_guiSystem = &CEGUI::System::create( *m_guiRenderer, &m_vfsResourceProvider, &m_xmlParserAdapter, m_imageCodecAdapter );
// setup default group for validation schemas
CEGUI::XMLParser* parser = m_guiSystem->getXMLParser();
if ( nullptr != parser && parser->isPropertyPresent( "SchemaDefaultResourceGroup" ) )
parser->setProperty( "SchemaDefaultResourceGroup", m_schemasResourceGroup );
// Load the fonts
CEGUI::FontManager::getSingleton().createAll( m_defaultFont, CEGUI::Font::getDefaultResourceGroup() );
// Load the scheme
try
{
CEGUI::SchemeManager::getSingleton().createFromFile( "Generic.scheme" );
}
catch ( CEGUI::Exception& e )
{
CORE::CString info = e.getMessage() + " - at - " + e.getFileName() + ":" + e.getFunctionName() + ":" + CORE::UInt32ToString( e.getLine() ).STL_String();
GUCEF_EXCEPTION_LOG( CORE::LOGLEVEL_IMPORTANT, "Unhandled exception during CEGUI initialization: " + info );
}
CEGUI::SchemeManager::getSingleton().createFromFile( m_schemeToUse );
// Set the defaults
CEGUI::System::getSingleton().getDefaultGUIContext().setDefaultFont( m_defaultFont );
CEGUI::System::getSingleton().getDefaultGUIContext().getMouseCursor().setDefaultImage( m_defaultCursorImage );
CEGUI::Window* rootWindow = CEGUI::WindowManager::getSingleton().createWindow( "DefaultWindow", "root" );
CEGUI::System::getSingleton().getDefaultGUIContext().setRootWindow( rootWindow );
// clearing this queue actually makes sure it's created(!)
CEGUI::System::getSingleton().getDefaultGUIContext().clearGeometry( CEGUI::RQ_OVERLAY );
m_ceGuiInitialized = true;
}
catch ( CEGUI::Exception& e )
{
CORE::CString info = e.getMessage() + " - at - " + e.getFileName() + ":" + e.getFunctionName() + ":" + CORE::UInt32ToString( e.getLine() ).STL_String();
GUCEF_EXCEPTION_LOG( CORE::LOGLEVEL_IMPORTANT, "Unhandled exception during CEGUI initialization: " + info );
m_ceGuiInitialized = false;
}
}
return m_ceGuiInitialized;
}
bool
COgreWindowContext::Initialize( const GUI::CString& title ,
const GUI::CVideoSettings& videoSettings ,
const GUI::CString& ogreRenderSystem )
{GUCEF_TRACE;
// Do not initialize twice
Shutdown();
// First create a regular O/S window
if ( m_osWindow->WindowCreate( title ,
0 ,
0 ,
videoSettings.GetResolutionWidthInPixels() ,
videoSettings.GetResolutionHeightInPixels() ) )
{
// Display the new window
m_osWindow->Show();
m_osWindow->SendToForegound();
m_osWindow->GrabFocus();
// Now proceed with setting up the Ogre specifics
// We grab the O/S window identifier 'the handle'
// This is passed to Ogre to tie things together
CORE::Int64 windowRef = 0;
CORE::CString windowIntStr = m_osWindow->GetProperty( "WINDOWINT" );
if ( !windowIntStr.IsNULLOrEmpty() )
{
windowRef = CORE::StringToInt64( windowIntStr );
}
Ogre::NameValuePairList options;
options[ "externalWindowHandle" ] = Ogre::StringConverter::toString( (size_t) windowRef );
Ogre::Root* ogreRoot = Ogre::Root::getSingletonPtr();
if ( ogreRoot == nullptr )
{
ogreRoot = OGRE_NEW Ogre::Root( "", "", "" );
}
if ( !ogreRoot->isInitialised() )
{
// Load any Ogre plugins not loaded yet from the bootstrap group
CORE::CCoreGlobal::Instance()->GetPluginControl().LoadPluginGroup( "Ogre" );
const Ogre::RenderSystemList& rsList = ogreRoot->getAvailableRenderers();
if ( rsList.size() == 0 )
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_IMPORTANT, "OgreWindowContext: No Ogre render systems are available, cannot initialize" );
return false;
}
Ogre::RenderSystem* renderSystem = nullptr;
Ogre::RenderSystemList::const_iterator i = rsList.begin();
while ( i != rsList.end() )
{
GUCEF_SYSTEM_LOG( CORE::LOGLEVEL_NORMAL, "OgreWindowContext: Available Ogre render system: " + (*i)->getFriendlyName() );
if ( ogreRenderSystem == (*i)->getName() )
{
GUCEF_SYSTEM_LOG( CORE::LOGLEVEL_NORMAL, "OgreWindowContext: Found desired/preferred Ogre render system: " + (*i)->getFriendlyName() );
renderSystem = (*i);
}
++i;
}
if ( renderSystem == nullptr )
{
GUCEF_WARNING_LOG( CORE::LOGLEVEL_IMPORTANT, "OgreWindowContext: Preferred Ogre render systems not available, using first available alternative: " + (*rsList.begin())->getFriendlyName() );
renderSystem = *rsList.begin();
}
ogreRoot->setRenderSystem( renderSystem );
m_sceneManager = ogreRoot->createSceneManager( Ogre::ST_GENERIC );
m_renderWindow = ogreRoot->initialise( false, title );
}
m_renderWindow = ogreRoot->createRenderWindow( title,
videoSettings.GetResolutionWidthInPixels(),
videoSettings.GetResolutionHeightInPixels(),
videoSettings.GetFullscreenState(),
&options );
// Grab the main app pulse generator and set the update interval for the context to the desired refresh rate
CORE::CPulseGenerator& pulseGenerator = CORE::CCoreGlobal::Instance()->GetPulseGenerator();
pulseGenerator.RequestPeriodicPulses( this, 1000 / videoSettings.GetFrequency() );
SubscribeTo( &pulseGenerator );
GUCEF_SYSTEM_LOG( CORE::LOGLEVEL_NORMAL, "OgreWindowContext: Succesfully created Ogre rendering context" );
m_initialized = true;
return true;
}
return false;
}
void
MirrorDirsAndFiles( const CORE::CString& srcDir ,
const CORE::CString& dstDir ,
bool mirrorExistingFilesOnly ,
const TStringSet* fileTypes ,
const TStringSet* dirsToIgnore )
{GUCEF_TRACE;
if ( mirrorExistingFilesOnly )
{
// We have a seperare function for mirroring existing files only
// It is more efficient since it can use the destination as the template
// avoiding unnessary operations
MirrorExistingDirsAndFiles( srcDir ,
dstDir ,
fileTypes ,
dirsToIgnore );
return;
}
// Get a list of all source files
TFileEntryVector files;
BuildFileList( srcDir ,
files ,
fileTypes ,
dirsToIgnore );
// Iterate the list of files and make sure we mirror all of them
TFileEntryVector::iterator i = files.begin();
while ( i != files.end() )
{
TFileEntry& fileEntry = (*i);
CORE::CString srcFilePath = srcDir;
CORE::AppendToPath( srcFilePath, fileEntry.filedir );
CORE::AppendToPath( srcFilePath, fileEntry.filename );
CORE::CString destFilePath = dstDir;
CORE::AppendToPath( destFilePath, fileEntry.filedir );
// Make sure destination directory exists
if ( CORE::CreateDirs( destFilePath ) )
{
CORE::AppendToPath( destFilePath, fileEntry.filename );
bool fileExisted = CORE::FileExists( destFilePath );
if ( fileExisted )
{
if ( !RenameFileAsBackup( destFilePath ) )
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "Unable to rename existing destination file: " + destFilePath );
++i;
continue;
}
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Successfully renamed destination file \"" + destFilePath + "\"" );
}
if ( 0 != CORE::Copy_File( destFilePath.C_String() ,
srcFilePath.C_String() ) )
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Successfully copied file from \"" + srcFilePath + "\" to \"" + destFilePath + "\"" );
if ( fileExisted )
{
if ( DeleteFileBackup( destFilePath ) )
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Successfully deleted backup file after successfull copy for file \"" + destFilePath + "\"" );
}
}
}
else
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Failed to copy file from \"" + srcFilePath + "\" to \"" + destFilePath + "\"" );
if ( fileExisted )
{
if ( !UndoRenameFileAsBackup( destFilePath ) )
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "Failed to undo renaming of file: " + destFilePath );
}
}
}
}
else
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "Unable to create directory: " + destFilePath );
}
++i;
}
}
void
MirrorExistingDirsAndFiles( const CORE::CString& srcDir ,
const CORE::CString& dstDir ,
const TStringSet* fileTypes ,
const TStringSet* dirsToIgnore )
{
// Get a list of all destination files
TFileEntryVector files;
BuildFileList( dstDir ,
files ,
fileTypes ,
dirsToIgnore );
// Iterate the list of files and make sure we mirror all of them
TFileEntryVector::iterator i = files.begin();
while ( i != files.end() )
{
TFileEntry& fileEntry = (*i);
CORE::CString srcFilePath = srcDir;
CORE::AppendToPath( srcFilePath, fileEntry.filedir );
CORE::AppendToPath( srcFilePath, fileEntry.filename );
CORE::CString destFilePath = dstDir;
CORE::AppendToPath( destFilePath, fileEntry.filedir );
CORE::AppendToPath( destFilePath, fileEntry.filename );
if ( !CORE::FileExists( srcFilePath ) )
{
// Skip this one, we are configured to only mirror files for which
// a target file already exists
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Skipping file \"" + destFilePath + "\" because there is no source file available" );
++i;
continue;
}
if ( !RenameFileAsBackup( destFilePath ) )
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "Unable to rename existing destination file: " + destFilePath );
++i;
continue;
}
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Successfully renamed destination file \"" + destFilePath + "\"" );
if ( 0 != CORE::Copy_File( destFilePath.C_String() ,
srcFilePath.C_String() ) )
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Successfully copied file from \"" + srcFilePath + "\" to \"" + destFilePath + "\"" );
if ( DeleteFileBackup( destFilePath ) )
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Successfully deleted backup file after successfull copy for file \"" + destFilePath + "\"" );
}
}
else
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Failed to copy file from \"" + srcFilePath + "\" to \"" + destFilePath + "\"" );
if ( !UndoRenameFileAsBackup( destFilePath ) )
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "Failed to undo renaming of file: " + destFilePath );
}
}
++i;
}
}
void
CopyOverMatchedFiles( const CORE::CString& srcDirRoot ,
const CORE::CString& destDirRoot ,
TMatchEntryVector& matches )
{GUCEF_TRACE;
TMatchEntryVector::iterator i = matches.begin();
while ( i != matches.end() )
{
TMatchEntry& matchEntry = (*i);
CORE::CString sourceFilePath = srcDirRoot;
CORE::AppendToPath( sourceFilePath, matchEntry.source.filedir );
CORE::AppendToPath( sourceFilePath, matchEntry.source.filename );
TFileEntryVector& destinations = matchEntry.destinations;
if ( destinations.empty() )
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "File \"" + sourceFilePath + "\" cannot be copied since it doesnt have any destination locations" );
}
else
{
TFileEntryVector::iterator n = destinations.begin();
while ( n != destinations.end() )
{
TFileEntry& destEntry = (*n);
CORE::CString destFilePath = destDirRoot;
CORE::AppendToPath( destFilePath, destEntry.filedir );
CORE::AppendToPath( destFilePath, destEntry.filename );
// Delete whatever backup file might have gotten left behind from a previous run
DeleteFileBackup( destFilePath );
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Preparing to copy file from \"" + sourceFilePath + "\" to \"" + destFilePath + "\"" );
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Backing up destination file \"" + destFilePath + "\"" );
if ( RenameFileAsBackup( destFilePath ) )
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Successfully renamed destination file \"" + destFilePath + "\"" );
if ( 0 != CORE::Copy_File( destFilePath.C_String() ,
sourceFilePath.C_String() ) )
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Successfully copied file from \"" + sourceFilePath + "\" to \"" + destFilePath + "\"" );
DeleteFileBackup( destFilePath );
}
else
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Failed to copy file from \"" + sourceFilePath + "\" to \"" + destFilePath + "\"" );
UndoRenameFileAsBackup( destFilePath );
}
}
else
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Failed to delete destination file \"" + destFilePath + "\"" );
}
++n;
}
}
++i;
}
}
CORE::CString
GenerateContentForAndroidProjectMakefile( const CORE::CString& projectName ,
const TModuleInfoEntryPairVector& mergeLinks ,
const CORE::CString& outputDir ,
bool addGeneratorCompileTimeToOutput ,
const TStringSet& ndkModulesUsed )
{GUCEF_TRACE;
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Generating Android makefile content for overall project file regarding project \"" + projectName + "\"" );
CORE::CString contentPrefix = makefileHeader;
contentPrefix +=
"#\n"
"# This is the project makefile which includes all modules which are part of this project\n"
"#\n";
contentPrefix +=
"# PROJECT: \"" + projectName + "\"\n#\n\n";
if ( addGeneratorCompileTimeToOutput )
{
contentPrefix +=
"#"
"# The project generator version used was compiled on " __TIME__ __DATE__ "\n"
"#\n\n";
}
contentPrefix +=
"ifndef PROJECT_ROOT_PATH\n"
" PROJECT_ROOT_PATH := $(call my-dir)\n"
"endif\n\n"
"include $(CLEAR_VARS)\n\n";
// Include makefiles for NDK modules used
CORE::CString moduleListSection;
/* -> Not needed
if ( !ndkModulesUsed.empty() )
{
TStringSet::iterator i = ndkModulesUsed.find( "android_native_app_glue" );
if ( i != ndkModulesUsed.end() )
{
moduleListSection += "MY_MODULE_PATH := $(ANDROIDNDK)/sources/android/native_app_glue\n";
moduleListSection += "include $(MY_MODULE_PATH)/Android.mk\n\n";
}
i = ndkModulesUsed.find( "cpufeatures" );
if ( i != ndkModulesUsed.end() )
{
moduleListSection += "MY_MODULE_PATH := $(ANDROIDNDK)/sources/android/cpufeatures\n";
moduleListSection += "include $(MY_MODULE_PATH)/Android.mk\n\n";
}
}
*/
// Include each module's makefile in the order listed as their build order
const TModuleInfo* currentModule = FindFirstModuleAccordingToBuildOrder( mergeLinks );
while ( NULL != currentModule )
{
if ( ( MODULETYPE_HEADER_INCLUDE_LOCATION != currentModule->moduleType ) &&
( MODULETYPE_HEADER_INTEGRATE_LOCATION != currentModule->moduleType ) &&
( MODULETYPE_CODE_INTEGRATE_LOCATION != currentModule->moduleType ) )
{
// Get relative path from the outputDir to the other module
const TModuleInfoEntry* fullModuleInfo = FindModuleInfoEntryForMergedInfo( mergeLinks, *currentModule );
CORE::CString relativePathToModule = CORE::GetRelativePathToOtherPathRoot( outputDir, fullModuleInfo->rootDir );
relativePathToModule = relativePathToModule.ReplaceChar( '\\', '/' );
// Add entry for this module to the project file
moduleListSection += "MY_MODULE_PATH := $(PROJECT_ROOT_PATH)/" + relativePathToModule + "\n";
moduleListSection += "include $(MY_MODULE_PATH)/Android.mk\n\n";
}
// Done with this module, go to the next one
currentModule = FindNextModuleAccordingToBuildOrder( mergeLinks, *currentModule );
}
return contentPrefix + moduleListSection;
}
CORE::CString
GenerateContentForAndroidMakefile( const TModuleInfoEntryPairVector& mergeLinks ,
const TModuleInfo& moduleInfo ,
const CORE::CString& moduleRoot ,
bool addGeneratorCompileTimeToOutput ,
TStringSet& ndkModulesUsed )
{GUCEF_TRACE;
CORE::CString contentPrefix = makefileHeader;
if ( addGeneratorCompileTimeToOutput )
{
contentPrefix +=
"#"
"# The project generator version used was compiled on " __TIME__ __DATE__ "\n"
"#\n\n";
}
contentPrefix +=
"ifndef MY_MODULE_PATH\n"
" MY_MODULE_PATH := $(call my-dir)\n"
"endif\n"
"LOCAL_PATH := $(MY_MODULE_PATH)\n\n"
"include $(CLEAR_VARS)\n\n"
"@echo Module path: $(MY_MODULE_PATH)\n"
"LOCAL_MODULE := " + moduleInfo.name + "\n";
if ( ( MODULETYPE_SHARED_LIBRARY == moduleInfo.moduleType ) ||
( MODULETYPE_STATIC_LIBRARY == moduleInfo.moduleType ) )
{
contentPrefix += "LOCAL_MODULE_FILENAME := lib" + moduleInfo.name + "\n";
}
contentPrefix += "@echo Module name: $(LOCAL_MODULE)\n\n";
// Generate the source files section
CORE::CString srcFilesSection = "LOCAL_SRC_FILES := \\\n";
bool firstLoop = true;
TStringVectorMap::const_iterator i = moduleInfo.sourceDirs.begin();
while ( i != moduleInfo.sourceDirs.end() )
{
const CORE::CString& srcDir = (*i).first;
const TStringVector& srcFiles = (*i).second;
TStringVector::const_iterator n = srcFiles.begin();
while ( n != srcFiles.end() )
{
if ( !firstLoop )
{
srcFilesSection += " \\\n";
}
firstLoop = false;
CORE::CString relFilePath = srcDir;
CORE::AppendToPath( relFilePath, (*n) );
srcFilesSection += " " + relFilePath.ReplaceChar( '\\', '/' );
++n;
}
++i;
}
// Add some spacing for readability
srcFilesSection += "\n\n";
// Generate the included files section
// for android make files we only need the path
// it will locate the header file on its own
CORE::CString includeFilesSection = "LOCAL_C_INCLUDES := \\\n";
i = moduleInfo.includeDirs.begin();
firstLoop = true;
while ( i != moduleInfo.includeDirs.end() )
{
if ( !firstLoop )
{
includeFilesSection += " \\\n";
}
firstLoop = false;
const CORE::CString& dir = (*i).first;
if ( !dir.IsNULLOrEmpty() )
{
includeFilesSection += " $(MY_MODULE_PATH)/" + dir.ReplaceChar( '\\', '/' );
}
else
{
// Support the use-case where the include dir is empty because the moduleinfo dir == include dir
includeFilesSection += " $(MY_MODULE_PATH)";
}
++i;
}
// We also need to add the include paths required to find headers
// refered to because of dependencies
TStringSet::const_iterator n = moduleInfo.dependencyIncludeDirs.begin();
while ( n != moduleInfo.dependencyIncludeDirs.end() )
{
if ( !firstLoop )
{
includeFilesSection += " \\\n";
}
firstLoop = false;
includeFilesSection += " $(MY_MODULE_PATH)/" + (*n).ReplaceChar( '\\', '/' );
++n;
}
// Add some spacing for readability
includeFilesSection += "\n\n";
// Now we add the preprocessor definitions
CORE::CString preprocessorSection;
if ( !moduleInfo.preprocessorSettings.defines.empty() )
{
preprocessorSection = "LOCAL_CFLAGS :=";
TStringSet::const_iterator m = moduleInfo.preprocessorSettings.defines.begin();
while ( m != moduleInfo.preprocessorSettings.defines.end() )
{
preprocessorSection += " -D" + (*m);
++m;
}
// Add some spacing for readability
preprocessorSection += "\n\n";
}
// Now we add the compiler flags, if any
// For Android we only support the GCC compilers
CORE::CString compilerSection;
TStringMap::const_iterator p = moduleInfo.compilerSettings.compilerFlags.find( "GCC" );
if ( p != moduleInfo.compilerSettings.compilerFlags.end() )
{
compilerSection = "LOCAL_CFLAGS +=" + (*p).second + "\n\n";
}
p = moduleInfo.compilerSettings.compilerFlags.find( "G++" );
if ( p != moduleInfo.compilerSettings.compilerFlags.end() )
{
compilerSection = "LOCAL_CPPFLAGS +=" + (*p).second + "\n\n";
}
// Now we will add all the dependency linking instructions.
// For some reason it matters, at specification time, to Android's build
// system whether the module you are linking to is a dynamically linked module
// or a statically linked module. As such we have to figure out which is which.
//
// We make an alphabetical list instead of creating the section right away because
// we dont want the order to vary in the makefile because such changes cause the NDK
// to build the code again for no reason.
CORE::CString linkingErrorSection;
TStringSet linkedSharedLibraries;
TStringSet linkedStaticLibraries;
TStringSet linkedRuntimeLibraries;
TModuleTypeMap::const_iterator m = moduleInfo.linkerSettings.linkedLibraries.begin();
while ( m != moduleInfo.linkerSettings.linkedLibraries.end() )
{
const CORE::CString& linkedLibName = (*m).first;
TModuleType linkedLibType = (*m).second;
switch ( linkedLibType )
{
case MODULETYPE_EXECUTABLE:
{
// This is really nasty but the best option for now...
// It is possible to link to exported symbols from an executable
// under linux and as such we will leverage this here
linkedSharedLibraries.insert( linkedLibName );
break;
}
case MODULETYPE_SHARED_LIBRARY:
{
linkedSharedLibraries.insert( linkedLibName );
break;
}
case MODULETYPE_STATIC_LIBRARY:
{
linkedStaticLibraries.insert( linkedLibName );
break;
}
case MODULETYPE_CODE_INTEGRATE_LOCATION:
case MODULETYPE_HEADER_INTEGRATE_LOCATION:
case MODULETYPE_HEADER_INCLUDE_LOCATION:
{
// Skip this, no linking required
break;
}
default:
{
// Since the depedendency module type was not predefined we will investigate among
// the other modules to try to determine the nature of the linked module
const TModuleInfo* linkedDependency = FindModuleByName( mergeLinks, linkedLibName );
if ( NULL != linkedDependency )
{
// The module we are linking too is part of this project.
// As such we can simply check the other module's info
// to find out wheter its a dynamically linked module or not
// which in turn tells us how to instruct the Android build system
// to link.
switch( linkedDependency->moduleType )
{
case MODULETYPE_SHARED_LIBRARY:
{
linkedSharedLibraries.insert( linkedLibName );
break;
}
case MODULETYPE_STATIC_LIBRARY:
{
linkedStaticLibraries.insert( linkedLibName );
break;
}
case MODULETYPE_EXECUTABLE:
{
// This is really nasty but the best option for now...
// It is possible to link to exported symbols from an executable
// under linux and as such we will leverage this here
linkedSharedLibraries.insert( linkedLibName );
break;
}
case MODULETYPE_HEADER_INTEGRATE_LOCATION:
case MODULETYPE_CODE_INTEGRATE_LOCATION:
{
// Dont do anything.
// The files for this 'module' have already been merged into the dependent module
break;
}
case MODULETYPE_HEADER_INCLUDE_LOCATION:
{
// Don't have to do anything.
// Due to the auto-dependency tracking of include paths the header paths will have been added to
// whatever module depends on this 'module'
break;
}
default:
{
linkingErrorSection +=
"# *** ERROR *** Finish me\n"
"# Unable to determing module type from the source information\n"
"# Please edit the line below to manually set the correct linking method for this dependency\n";
linkingErrorSection += "#LOCAL_<(LDLIBS???)> += " + moduleInfo.name + "\n\n";
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "Error: the module " + moduleInfo.name + " does not have a useable module type set, you will have to manually edit the file to correct the error" );
break;
}
}
}
else
{
// If we get here then this dependency is not on a module which is part of the project
// As such we cannot build this module thus the only approriote linking method would seem
// to be the one where we simply instruct the linker to load this dependency at runtime.
// This will typically be the case for any Android NDK modules we have to link to.
linkedRuntimeLibraries.insert( linkedLibName );
}
}
}
++m;
}
CORE::CString linkingSection;
CORE::CString linkedSharedLibrariesSection = "\nLOCAL_SHARED_LIBRARIES := \\\n";
CORE::CString linkedStaticLibrariesSection = "\nLOCAL_STATIC_LIBRARIES := \\\n";
CORE::CString linkedRuntimeLibrariesSection = "\nLOCAL_LDLIBS := \\\n";
// Based on what was found we will construct the linking section
bool first = true;
n = linkedSharedLibraries.begin();
while ( n != linkedSharedLibraries.end() )
{
if ( !first )
{
linkedSharedLibrariesSection += " \\\n";
}
linkedSharedLibrariesSection += " " + (*n);
first = false;
++n;
}
first = true;
n = linkedStaticLibraries.begin();
while ( n != linkedStaticLibraries.end() )
{
if ( !first )
{
linkedStaticLibrariesSection += " \\\n";
}
linkedStaticLibrariesSection += " " + (*n);
first = false;
++n;
}
first = true;
n = linkedRuntimeLibraries.begin();
while ( n != linkedRuntimeLibraries.end() )
{
if ( !first )
{
linkedRuntimeLibrariesSection += " \\\n";
}
linkedRuntimeLibrariesSection += " -l" + (*n);
first = false;
++n;
}
if ( !linkedSharedLibraries.empty() )
{
linkingSection += linkedSharedLibrariesSection + "\n\n";
}
if ( !linkedStaticLibraries.empty() )
{
linkingSection += linkedStaticLibrariesSection + "\n\n";
}
if ( !linkedRuntimeLibraries.empty() )
{
linkingSection += linkedRuntimeLibrariesSection + "\n\n";
}
linkingSection += linkingErrorSection;
// Check if we have a file on disk of information which is to be inserted into
// our automatically generated make file
CORE::CString manualContent;
CORE::CString manualContentFilePath = moduleRoot;
CORE::AppendToPath( manualContentFilePath, "AndroidAddition.mk" );
if ( CORE::FileExists( manualContentFilePath ) )
{
if ( CORE::LoadTextFileAsString( manualContentFilePath ,
manualContent ) )
{
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Successfully loaded manually defined content for module " + moduleInfo.name + " from addition file " + manualContentFilePath );
}
else
{
manualContent =
"# *** ERROR *** Finish me\n"
"# Unable to load manually defined content from detected AndroidAddition.mk file\n"
"# Please manually insert its contents here\n\n";
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "Error: the module " + moduleInfo.name + " has manually defined content in a AndroidAddition.mk file but it could not be loaded, you will have to manually edit the file to correct the error" );
}
}
// Now generate the latter part of the file which contains more meta data about the module
CORE::CString contentSuffix;
switch ( moduleInfo.moduleType )
{
case MODULETYPE_SHARED_LIBRARY:
{
contentSuffix += "include $(BUILD_SHARED_LIBRARY)\n\n";
break;
}
case MODULETYPE_STATIC_LIBRARY:
{
contentSuffix += "include $(BUILD_STATIC_LIBRARY)\n\n";
break;
}
case MODULETYPE_EXECUTABLE:
{
contentSuffix += "include $(BUILD_EXECUTABLE)\n\n";
break;
}
default:
{
contentSuffix +=
"# *** ERROR *** Finish me\n"
"# Unable to determine module type from the source information\n"
"# Please edit the line below to manually set the correct module type to build\n"
"#include $(BUILD_???)\n\n";
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "Error: the module " + moduleInfo.name + " does not have a useable module type set, you will have to manually edit the file to correct the error" );
break;
}
}
// Check for NDK static libraries to import
if ( !linkedStaticLibraries.empty() )
{
TStringSet::iterator a = linkedStaticLibraries.find( "android_native_app_glue" );
if ( a != linkedStaticLibraries.end() )
{
ndkModulesUsed.insert( "android_native_app_glue" );
contentSuffix += "$(call import-module,android/native_app_glue)\n";
}
a = linkedStaticLibraries.find( "cpufeatures" );
if ( a != linkedStaticLibraries.end() )
{
ndkModulesUsed.insert( "cpufeatures" );
contentSuffix += "$(call import-module,android/cpufeatures)\n";
}
}
return contentPrefix + srcFilesSection + includeFilesSection + preprocessorSection + compilerSection + linkingSection + manualContent + contentSuffix;
}
void
BuildFileList( const CORE::CString& srcDir ,
const CORE::CString& relativeSrcDir ,
TFileEntryVector& files ,
const TStringSet* fileTypes ,
const TStringSet* dirsToIgnore )
{GUCEF_TRACE;
struct CORE::SDI_Data* dirEntry = CORE::DI_First_Dir_Entry( srcDir.C_String() );
if ( dirEntry != NULL )
{
do
{
CORE::CString entryName = CORE::DI_Name( dirEntry );
if ( ( entryName != "." ) &&
( entryName != ".." ) )
{
// Check if this is a dir we have to ignore
if ( 0 == CORE::DI_Is_It_A_File( dirEntry ) )
{
if ( NULL != dirsToIgnore )
{
if ( dirsToIgnore->find( entryName.Lowercase() ) != dirsToIgnore->end() )
{
// do not process further
CORE::CString ignoredDir = srcDir;
CORE::AppendToPath( ignoredDir, entryName );
GUCEF_LOG( CORE::LOGLEVEL_NORMAL, "Ignoring directory \"" + ignoredDir + "\"" );
continue;
}
}
}
if ( 0 != CORE::DI_Is_It_A_File( dirEntry ) )
{
if ( NULL != fileTypes )
{
CORE::CString fileExt = CORE::Extract_File_Ext( entryName.C_String() );
fileExt = fileExt.Lowercase();
if ( fileTypes->find( fileExt ) == fileTypes->end() )
{
// skip this entry as instructed, not a matching filetype
continue;
}
}
TFileEntry fileEntry;
fileEntry.filedir = relativeSrcDir;
fileEntry.filename = entryName;
files.push_back( fileEntry );
}
else
{
// We found a sub-dir, process it
CORE::CString subDirPath = srcDir;
CORE::AppendToPath( subDirPath, entryName );
CORE::CString subRelSrcDir = relativeSrcDir;
CORE::AppendToPath( subRelSrcDir, entryName );
BuildFileList( subDirPath ,
subRelSrcDir ,
files ,
fileTypes ,
dirsToIgnore );
}
}
}
while ( CORE::DI_Next_Dir_Entry( dirEntry ) != 0 );
// clean up our toys
CORE::DI_Cleanup( dirEntry );
}
}
bool
CCEGUIDriver::LoadConfig( const CORE::CDataNode& treeroot )
{GUCEF_TRACE;
const CORE::CDataNode* ceguiConfig = treeroot.Find( "CEGUI" );
if ( nullptr == ceguiConfig )
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_IMPORTANT, "CGUIDriver:LoadConfig: Cannot find CEGUI config and as such will not be able to initialize" );
return false;
}
m_schemeToUse = ceguiConfig->GetAttributeValueOrChildValueByName( "Scheme" );
m_defaultFont = ceguiConfig->GetAttributeValueOrChildValueByName( "DefaultFont" );
m_defaultCursorImage = ceguiConfig->GetAttributeValueOrChildValueByName( "DefaultCursorImage" );
// the default is the fallback resource group if none is passed to the adapter
CORE::CString defaultResourceGroup = ceguiConfig->GetAttributeValueOrChildValueByName( "DefaultResourceGroup" );
if ( defaultResourceGroup.IsNULLOrEmpty() )
defaultResourceGroup = "CEGUI";
m_vfsResourceProvider.setDefaultResourceGroup( defaultResourceGroup );
CORE::CString imageSetsResourceGroup = ceguiConfig->GetAttributeValueOrChildValueByName( "ImageSetsResourceGroup" );
CORE::CString fontsResourceGroup = ceguiConfig->GetAttributeValueOrChildValueByName( "FontsResourceGroup" );
CORE::CString schemesResourceGroup = ceguiConfig->GetAttributeValueOrChildValueByName( "SchemesResourceGroup" );
CORE::CString lookNFeelResourceGroup = ceguiConfig->GetAttributeValueOrChildValueByName( "LookNFeelsResourceGroup" );
CORE::CString layoutsResourceGroup = ceguiConfig->GetAttributeValueOrChildValueByName( "LayoutsResourceGroup" );
CORE::CString animationsResourceGroup = ceguiConfig->GetAttributeValueOrChildValueByName( "AnimationsResourceGroup" );
CORE::CString scriptsResourceGroup = ceguiConfig->GetAttributeValueOrChildValueByName( "ScriptsResourceGroup" );
m_schemasResourceGroup = ceguiConfig->GetAttributeValueOrChildValueByName( "SchemasResourceGroup" );
// set the default resource groups to be used
CEGUI::ImageManager::setImagesetDefaultResourceGroup( imageSetsResourceGroup );
CEGUI::Font::setDefaultResourceGroup( fontsResourceGroup );
CEGUI::Scheme::setDefaultResourceGroup( schemesResourceGroup );
CEGUI::WidgetLookManager::setDefaultResourceGroup( lookNFeelResourceGroup );
CEGUI::WindowManager::setDefaultResourceGroup( layoutsResourceGroup );
CEGUI::AnimationManager::setDefaultResourceGroup( animationsResourceGroup );
CEGUI::ScriptModule::setDefaultResourceGroup( scriptsResourceGroup );
// setup default group for validation schemas
CEGUI::System* ceguiSystem = CEGUI::System::getSingletonPtr();
if ( nullptr != ceguiSystem )
{
CEGUI::XMLParser* parser = ceguiSystem->getXMLParser();
if ( nullptr != parser && parser->isPropertyPresent( "SchemaDefaultResourceGroup" ) )
parser->setProperty( "SchemaDefaultResourceGroup", m_schemasResourceGroup );
}
const CORE::CDataNode* ceguiVfsConfig = treeroot.Search( "CEGUI/VFSAdapter", '/', false );
if ( nullptr != ceguiVfsConfig )
{
CORE::CDataNode::TConstDataNodeSet grpNodes = ceguiVfsConfig->FindChildrenOfType( "ResourceGroup" );
CORE::CDataNode::TConstDataNodeSet::iterator i = grpNodes.begin();
while ( i != grpNodes.end() )
{
CORE::CString groupName = (*i)->GetAttributeValueOrChildValueByName( "Name" );
CORE::CString vfsPath = (*i)->GetAttributeValueOrChildValueByName( "Path" );
m_vfsResourceProvider.setResourceGroupDirectory( groupName, vfsPath );
++i;
}
}
return true;
}
bool
CPatcherAppConfig::LoadConfig( const CORE::CDataNode& treeroot )
{GUCEF_TRACE;
CORE::CDataNode::TConstDataNodeSet configNodes( treeroot.FindChildrenOfType( "PatcherAppConfig", true ) );
CORE::CDataNode::TConstDataNodeSet::iterator i = configNodes.begin();
if ( i != configNodes.end() )
{
const CORE::CDataNode* configNode = (*i);
CORE::CString value = configNode->GetAttributeValueOrChildValueByName( "LogFilePath" );
if ( !value.IsNULLOrEmpty() )
{
m_logfilePath = value;
}
value = configNode->GetAttributeValueOrChildValueByName( "IsFileLoggerEnabled" );
if ( !value.IsNULLOrEmpty() )
{
m_isFileLoggerEnabled = CORE::StringToBool( value );
}
value = configNode->GetAttributeValueOrChildValueByName( "IsConsoleLoggerEnabled" );
if ( !value.IsNULLOrEmpty() )
{
m_isConsoleLoggerEnabled = CORE::StringToBool( value );
}
value = configNode->GetAttributeValueOrChildValueByName( "IsConsoleWindowEnabled" );
if ( !value.IsNULLOrEmpty() )
{
m_isConsoleWindowEnabled = CORE::StringToBool( value );
}
value = configNode->GetAttributeValueOrChildValueByName( "WindowManager" );
if ( !value.IsNULLOrEmpty() )
{
m_windowManagerName = value;
}
CORE::CDataNode::TConstDataNodeSet nodeSet( configNode->FindChildrenOfType( "InitialForm", true ) );
CORE::CDataNode::TConstDataNodeSet::iterator n = nodeSet.begin();
if ( n != nodeSet.end() )
{
const CORE::CDataNode* formInfoNode = (*n);
m_guiBackendName = formInfoNode->GetAttributeValueOrChildValueByName( "GuiBackend" );
if ( !m_guiBackendName.IsNULLOrEmpty() )
{
m_initialFormTypeName = formInfoNode->GetChildValueByName( "FormTypeName" );
m_initialFormResourcePath = formInfoNode->GetChildValueByName( "FormResource" );
}
}
nodeSet = configNode->FindChildrenOfType( "FontsToLoadFromAssets", true );
n = nodeSet.begin();
while ( n != nodeSet.end() )
{
const CORE::CDataNode* fontInfoNode = (*n);
CString fontAsset = fontInfoNode->GetAttributeValueOrChildValueByName( "FontAsset" );
if ( !fontAsset.IsNULLOrEmpty() )
{
m_fontAssetsToLoad.push_back( fontAsset );
}
++n;
}
}
return true;
}
void
CLogSvcServer::ProcessReceivedMessage( TClientInfo& clientInfo ,
COMCORE::CTCPServerConnection* connection ,
const CORE::CDynamicBuffer& messageBuffer )
{GUCEF_TRACE;
try
{
// First read the message type and handle accordingly
CORE::UInt8 msgType = messageBuffer.AsConstType< CORE::UInt8 >( 0 );
switch ( msgType )
{
case LOGSVCMSGTYPE_CLIENTINFO:
{
CClientInitMessage initMessage;
if ( initMessage.ReadFromBuffer( messageBuffer, false ) )
{
clientInfo.logClientVersion = initMessage.GetClientVersion();
clientInfo.appName = initMessage.GetApplicationName();
clientInfo.processId = initMessage.GetProcessId();
clientInfo.processName = initMessage.GetProcessName();
// Set the client's address and port for easy unique addressability
clientInfo.addressAndPort = connection->GetRemoteIP().AddressAndPortAsString();
// If we got here without an exception then the we successfully received all info required to
// consider the connection as initialized.
clientInfo.initialized = true;
// tell the loggers we have a new client for which we can begin logging
TLoggerList::iterator i = m_loggers.begin();
while ( i != m_loggers.end() )
{
(*i)->StartOfLoggingForClient( clientInfo );
++i;
}
// Send notification to the client that the initialization was successfull
CORE::UInt8 statusCode = LOGSVCMSGTYPE_INITIALIZED;
connection->Send( &statusCode, 1 );
}
else
{
// Something is wrong with this msg buffer, kill the connection
connection->Close();
}
break;
}
case LOGSVCMSGTYPE_FLUSHLOG:
{
// We are being asked to flush the log
TLoggerList::iterator i = m_loggers.begin();
while ( i != m_loggers.end() )
{
(*i)->FlushLog( clientInfo );
++i;
}
break;
}
case LOGSVCMSGTYPE_LOGMSG:
{
// This is what its all about, we have been given a log message.
// Parse the log message from the transmission
CORE::UInt32 offset = 1;
CILogSvcServerLogger::TLogMsgType logMsgTypeValue = (CILogSvcServerLogger::TLogMsgType) messageBuffer.AsConstType< CORE::Int16 >( offset );
offset += 2;
CORE::Int32 logLevel = messageBuffer.AsConstType< CORE::Int32 >( offset );
offset += 4;
CORE::UInt32 threadId = messageBuffer.AsConstType< CORE::UInt32 >( offset );
offset += 4;
CORE::CString logMessage;
CORE::UInt32 strLength = messageBuffer.GetDataSize() - offset;
logMessage.Set( messageBuffer.AsConstTypePtr< char >( offset, strLength ), strLength );
// Now send the log message to all loggers
TLoggerList::iterator i = m_loggers.begin();
while ( i != m_loggers.end() )
{
(*i)->Log( clientInfo, logMsgTypeValue, logLevel, logMessage, threadId );
++i;
}
break;
}
default:
{
// We should not get here if the protocol is correctly adhered to and there is no
// corruption in the stream. This is a fatal error for the connection.
connection->Close();
}
}
}
catch ( CORE::CDynamicBuffer::EIllegalCast& )
{
// Something is wrong with this msg buffer, kill the connection
connection->Close();
}
}
CEGUI::Texture*
ImageCodecAdapter::load( const CEGUI::RawDataContainer& data ,
CEGUI::Texture* result )
{GUCEF_TRACE;
if ( NULL == result )
{
GUCEF_WARNING_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: Unable to load texture since no texture object was provided" );
return NULL;
}
CORE::CString imgType = CORE::ExtractFileExtention( result->getName() );
if ( imgType.IsNULLOrEmpty() )
{
if ( NULL != m_vfsResourceProvider )
{
VfsResourceProvider::DataContainerInfoPtr containerInfo = m_vfsResourceProvider->GetInfoOnLoadedContainer( data );
if ( !containerInfo.IsNULL() )
{
imgType = CORE::ExtractFileExtention( containerInfo->requestFilename );
}
}
}
if ( imgType.IsNULLOrEmpty() )
{
GUCEF_WARNING_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: Unable to load texture since no image type could be derived from the the texture name" );
return NULL;
}
IMAGE::CImageCodecRegistry& codecRegistry = IMAGE::CImageGlobal::Instance()->GetImageCodecRegistry();
IMAGE::CImageCodecRegistry::TImageCodecPtr codec;
if ( !codecRegistry.TryLookup( imgType, codec ) )
{
GUCEF_WARNING_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: Unable to load texture since no image codec could be found for type: " + imgType );
return NULL;
}
CORE::CDynamicBufferAccess bufferAccess;
bufferAccess.LinkTo( data.getDataPtr(), data.getSize() );
IMAGE::CImage image;
if ( !codec->Decode( bufferAccess, image ) )
{
GUCEF_WARNING_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: Unable to load texture since the image codec decoding failed for type: " + imgType );
return NULL;
}
IMAGE::TPixelMapPtr pixelMap;
if ( !image.TryGetPixelMap( 0, 0, pixelMap ) )
{
GUCEF_WARNING_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: Unable to get the pixel map from the image" );
return NULL;
}
// CEGUI does not support single channel formats
if ( pixelMap->GetNumberOfChannelsPerPixel() < 3 )
{
GUCEF_WARNING_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: CEGUI cannot handle images with less than 3 channels per pixels" );
return NULL;
}
// CEGUI only supports a subset of formats, convert as needed
IMAGE::TPixelStorageFormat sourceFormat = pixelMap->GetPixelStorageFormat();
switch ( sourceFormat )
{
case IMAGE::PSF_BGR:
{
IMAGE::TPixelMapPtr newPixelMap;
if ( !pixelMap->ConvertFormatTo( IMAGE::PSF_RGB, MT::DATATYPE_UINT8, newPixelMap ) )
{
GUCEF_WARNING_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: CEGUI cannot handle BGR images and we were unable to convert" );
return NULL;
}
if ( newPixelMap )
{
GUCEF_DEBUG_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: CEGUI cannot handle BGR images, we successfully converted the image" );
pixelMap = newPixelMap;
}
break;
}
case IMAGE::PSF_BGRA:
{
IMAGE::TPixelMapPtr newPixelMap;
if ( !pixelMap->ConvertFormatTo( IMAGE::PSF_RGBA, MT::DATATYPE_UINT8, newPixelMap ) )
{
GUCEF_WARNING_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: CEGUI cannot handle BGRA images and we were unable to convert" );
return NULL;
}
if ( newPixelMap )
{
GUCEF_DEBUG_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: CEGUI cannot handle BGRA images, we sucecssfully converted the image" );
pixelMap = newPixelMap;
}
break;
}
}
// CEGUI only supports a subset of channel sizes, convert as needed
// If we get here then the pixels are stored in a supported format either due to conversion or they were already
// However the channelsize can still be wrong in the latter case
CORE::UInt32 channelSize = pixelMap->GetPixelChannelSize();
if ( channelSize > 1 )
{
IMAGE::TPixelStorageFormat sourceFormat = pixelMap->GetPixelStorageFormat();
IMAGE::TPixelMapPtr newPixelMap;
if ( !pixelMap->ConvertFormatTo( sourceFormat, MT::DATATYPE_UINT8, newPixelMap ) )
{
GUCEF_WARNING_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: CEGUI cannot handle images with multi-byte channels and we were unable to convert" );
return NULL;
}
if ( newPixelMap )
{
GUCEF_DEBUG_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: CEGUI cannot handle images with multi-byte channels, we sucecssfully converted the image to single byte" );
pixelMap = newPixelMap;
}
channelSize = pixelMap->GetPixelChannelSize();
}
// Now that we have the image in a format we know CEGUI can handle,.. convert the type enum
CEGUI::Texture::PixelFormat ceguiPixelFormat;
if ( !TryConvertPixelFormat( pixelMap->GetPixelStorageFormat(), channelSize, ceguiPixelFormat ) )
{
GUCEF_WARNING_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: Failed to map pixel storage format to a CEGUI supported type" );
return NULL;
}
CEGUI::Sizef imageSizeInPixels( (float) pixelMap->GetWidthInPixels(), (float) pixelMap->GetHeightInPixels() );
result->loadFromMemory( pixelMap->GetDataPtr(), imageSizeInPixels, ceguiPixelFormat );
GUCEF_DEBUG_LOG( CORE::LOGLEVEL_NORMAL, "ImageCodecAdapter:load: Successfully loaded image into texture obj" );
return result;
}