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; }