void LanguageManager::initFromContext(const ApplicationContext& ctx) { // Initialise these members _languageSettingFile = ctx.getSettingsPath() + LANGUAGE_SETTING_FILE; _curLanguage = loadLanguageSetting(); rMessage() << "Current language setting: " << _curLanguage << std::endl; // No handling of POSIX needed, since we don't use the LanguageManager on // POSIX _i18nPath = os::standardPathWithSlash( ctx.getApplicationPath() + "i18n" ); // Set the LANG environment. As GLIB/GTK+ (in Win32) is using its own C // runtime, we need to call their GLIB setenv function for the environment // variable to take effect. g_setenv("LANG", _curLanguage.c_str(), TRUE); // Tell glib to load stuff from the given i18n path bindtextdomain(GETTEXT_PACKAGE, _i18nPath.c_str()); // set encoding to utf-8 to prevent errors for Windows bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); }
// Emulates the old operator<<(ostream &, const DottedRule &) function. The // output format is a bit odd (reverse order and double spacing between symbols) // but there are scripts and tools that expect the output of -T to look like // that. void BaseManager::WriteApplicationContext(std::ostream &out, const ApplicationContext &context) const { assert(!context.empty()); ApplicationContext::const_reverse_iterator p = context.rbegin(); while (true) { out << p->second << "=" << p->first << " "; if (++p == context.rend()) { break; } out << " "; } }
void SoundManager::initialiseModule(const ApplicationContext& ctx) { globalOutputStream() << "SoundManager::initialiseModule called\n"; // Pass a SoundFileLoader to the filesystem SoundFileLoader loader(*this); GlobalFileSystem().forEachFile( SOUND_FOLDER, // directory "*", // required extension loader, // loader callback 99 // max depth ); globalOutputStream() << _soundFiles.size() << " sound files found." << std::endl; // Create the SoundPlayer if sound is not disabled const ApplicationContext::ArgumentList& args = ctx.getCmdLineArgs(); ApplicationContext::ArgumentList::const_iterator found( std::find(args.begin(), args.end(), "--disable-sound") ); if (found == args.end()) { globalOutputStream() << "SoundManager: initialising sound playback" << std::endl; _soundPlayer = boost::shared_ptr<SoundPlayer>(new SoundPlayer); } else { globalOutputStream() << "SoundManager: sound ouput disabled" << std::endl; } }
STEPEntity * ApplicationContext::Create(STEPWrapper *sw, SDAI_Application_instance *sse) { Factory::OBJECTS::iterator i; if ((i = Factory::FindObject(sse->STEPfile_id)) == Factory::objects.end()) { ApplicationContext *object = new ApplicationContext(sw, sse->STEPfile_id); Factory::AddObject(object); if (!object->Load(sw, sse)) { std::cerr << CLASSNAME << ":Error loading class in ::Create() method." << std::endl; delete object; return NULL; } return static_cast<STEPEntity *>(object); } else { return (*i).second; } }
void LanguageManager::initFromContext(const ApplicationContext& ctx) { // Initialise these members _languageSettingFile = ctx.getSettingsPath() + LANGUAGE_SETTING_FILE; _curLanguage = loadLanguageSetting(); rMessage() << "Current language setting: " << _curLanguage << std::endl; // No handling of POSIX needed, since we don't use the LanguageManager on // POSIX _i18nPath = os::standardPathWithSlash( ctx.getApplicationPath() + "i18n" ); wxFileTranslationsLoader::AddCatalogLookupPathPrefix(_i18nPath); // Keep locale set to "C" for faster stricmp in Windows builds _wxLocale.reset(new wxLocale(_curLanguage, _curLanguage, "C")); _wxLocale->AddCatalog(GETTEXT_PACKAGE); }
//-------------------------------------------------------------------------------------- // Create any D3D11 resources that aren't dependant on the back buffer //-------------------------------------------------------------------------------------- HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ) { HRESULT hr; hr = DXUTGetDXGIFactory()->MakeWindowAssociation(DXUTGetHWND(), DXGI_MWA_NO_ALT_ENTER); ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext(); V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) ); V_RETURN( g_SettingsDlg.OnD3D11CreateDevice( pd3dDevice ) ); g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 ); // Create AMD_SDK resources here g_HUD.OnCreateDevice( pd3dDevice ); g_Context.Init(pd3dDevice, pd3dImmediateContext); g_Background.Init(pd3dDevice, &g_Context); g_Character.Init(pd3dDevice, pd3dImmediateContext, &g_Context); TIMER_Init(pd3dDevice) // Generate shaders ( this is an async operation - call AMD::ShaderCache::ShadersReady() to find out if they are complete ) static bool bFirstPass = true; if( bFirstPass ) { // Add the applications shaders to the cache g_Context.m_ShaderCache.GenerateShaders(AMD::ShaderCache::CREATE_TYPE_COMPILE_CHANGES); // Only compile shaders that have changed (development mode) bFirstPass = false; } g_Context.m_Affinity.SetUseAffinity(true); // Set toggle whether to render using Affinity MGPU g_HUD.m_GUI.GetCheckBox(IDC_CHECKBOX_ENABLE_MGPU)->SetChecked(g_Context.m_Affinity.GetUseAffinity()); g_HUD.m_GUI.GetCheckBox(IDC_CHECKBOX_ENABLE_MGPU)->SetEnabled(g_Context.m_Affinity.IsEnabled()); g_HUD.m_GUI.GetRadioButton(IDC_RADIO_SYNC_TYPE_AUTOMATIC)->SetEnabled(g_Context.m_Affinity.GetUseAffinity()); g_HUD.m_GUI.GetRadioButton(IDC_RADIO_SYNC_TYPE_MANUAL)->SetEnabled(g_Context.m_Affinity.GetUseAffinity()); g_HUD.m_GUI.GetRadioButton(IDC_RADIO_SYNC_TYPE_NONE)->SetEnabled(g_Context.m_Affinity.GetUseAffinity()); wchar_t text[1000]; swprintf_s(text, _countof(text), L"%s : %s", APPLICATION_TITLE, g_Context.m_Affinity.IsEnabled() ? L"MGPU available" : L"MGPU not available"); ::SetWindowTextW(::DXUTGetHWND(), text); return S_OK; }
void SoundManager::initialiseModule(const ApplicationContext& ctx) { // Create the SoundPlayer if sound is not disabled const ApplicationContext::ArgumentList& args = ctx.getCmdLineArgs(); ApplicationContext::ArgumentList::const_iterator found( std::find(args.begin(), args.end(), "--disable-sound") ); if (found == args.end()) { rMessage() << "SoundManager: initialising sound playback" << std::endl; _soundPlayer = boost::shared_ptr<SoundPlayer>(new SoundPlayer); } else { rMessage() << "SoundManager: sound ouput disabled" << std::endl; } }
void AAssociate ::set_application_context(ApplicationContext const & value) { auto const & old_items = this->_item.as_items("Variable-items"); std::vector<Item> new_items; new_items.push_back(value.get_item()); std::copy_if( old_items.begin(), old_items.end(), std::back_inserter(new_items), [](Item const & item) { return item.as_unsigned_int_8("Item-type") == 0x21; }); std::copy_if( old_items.begin(), old_items.end(), std::back_inserter(new_items), [](Item const & item) { return item.as_unsigned_int_8("Item-type") == 0x50; }); this->_item.as_items("Variable-items") = new_items; this->_item.as_unsigned_int_32("PDU-length") = this->_compute_length(); }
HRESULT CLRPrivBinderAssemblyLoadContext::BindUsingPEImage( /* in */ PEImage *pPEImage, /* in */ BOOL fIsNativeImage, /* [retval][out] */ ICLRPrivAssembly **ppAssembly) { HRESULT hr = S_OK; EX_TRY { ReleaseHolder<BINDER_SPACE::Assembly> pCoreCLRFoundAssembly; ReleaseHolder<BINDER_SPACE::AssemblyName> pAssemblyName; ReleaseHolder<IMDInternalImport> pIMetaDataAssemblyImport; PEKIND PeKind = peNone; // Get the Metadata interface DWORD dwPAFlags[2]; IF_FAIL_GO(BinderAcquireImport(pPEImage, &pIMetaDataAssemblyImport, dwPAFlags, fIsNativeImage)); IF_FAIL_GO(AssemblyBinder::TranslatePEToArchitectureType(dwPAFlags, &PeKind)); _ASSERTE(pIMetaDataAssemblyImport != NULL); // Using the information we just got, initialize the assemblyname SAFE_NEW(pAssemblyName, AssemblyName); IF_FAIL_GO(pAssemblyName->Init(pIMetaDataAssemblyImport, PeKind)); // Validate architecture if (!BINDER_SPACE::Assembly::IsValidArchitecture(pAssemblyName->GetArchitecture())) { IF_FAIL_GO(HRESULT_FROM_WIN32(ERROR_BAD_FORMAT)); } // Ensure we are not being asked to bind to a TPA assembly // // Easy out for mscorlib if (pAssemblyName->IsMscorlib()) { IF_FAIL_GO(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)); } { SString& simpleName = pAssemblyName->GetSimpleName(); ApplicationContext *pTPAApplicationContext = m_pTPABinder->GetAppContext(); SimpleNameToFileNameMap * tpaMap = pTPAApplicationContext->GetTpaList(); if (tpaMap->LookupPtr(simpleName.GetUnicode()) != NULL) { // The simple name of the assembly being requested to be bound was found in the TPA list. // Now, perform the actual bind to see if the assembly was really in the TPA assembly or not. // Don't search app paths when using the TPA binder because the actual binder is using a host assembly resolver. hr = m_pTPABinder->BindAssemblyByNameWorker(pAssemblyName, &pCoreCLRFoundAssembly, true /* excludeAppPaths */); if (SUCCEEDED(hr)) { if (pCoreCLRFoundAssembly->GetIsInGAC()) { // If we were able to bind to a TPA assembly, then fail the load IF_FAIL_GO(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)); } } } hr = AssemblyBinder::BindUsingPEImage(&m_appContext, pAssemblyName, pPEImage, PeKind, pIMetaDataAssemblyImport, &pCoreCLRFoundAssembly); if (hr == S_OK) { _ASSERTE(pCoreCLRFoundAssembly != NULL); pCoreCLRFoundAssembly->SetBinder(this); *ppAssembly = pCoreCLRFoundAssembly.Extract(); } } Exit: ; } EX_CATCH_HRESULT(hr); return hr; }
void InitialiseApplicationContext( int localMachineID, int user, const std::string& config, paulst::LoggingService* log, UserAdvisor* userAdvisor ) { paulstdb::throwUnlessOK( CoInitializeEx( NULL, COINIT_MULTITHREADED ) ); if ( applicationContext ) { throw Exception( L"Application context already initialised." ); } else { ApplicationContext* ac = new ApplicationContext(); ac->config = new paulst::Config( config ); std::string connectionFactoryType = ac->getProperty("ConnectionFactoryType"); paulst::trim( connectionFactoryType ); if ( connectionFactoryType == "ADO" ) { ac->connectionFactory = new paulstdb::DBConnectionFactory(); } else if ( connectionFactoryType == "Mock" ) { ac->connectionFactory = new valc::MockConnectionFactory(); } else { throw Exception( L"ConnectionFactoryType (in config) is not valid. Valid values are 'ADO' or 'Mock'." ); } if ( "true" == ac->getProperty("LogAllDatabaseStatements") ) { ac->connectionFactory = new paulstdb::ConnectionFactoryWithLogging( ac->connectionFactory, log ); } if ( "true" == ac->getProperty("CacheConnections") ) { ac->connectionFactory = new paulstdb::ConnectionFactoryWithCaching( ac->connectionFactory ); } ac->localMachineID = localMachineID; ac->user = user; ac->userAdvisor = userAdvisor; ac->taskExceptionUserAdvisor = new TaskExceptionUserAdvisor( userAdvisor, log ); ac->log = log; ac->sampleRunIDResolutionService = new SampleRunIDResolutionService(); ac->initialisationQueries = new stef::ThreadPool(0, 1); ac->initialisationQueries->addDefaultTaskExceptionHandler( ac->taskExceptionUserAdvisor ); ac->dbTransactionHandler = new DBTransactionHandler( ac->connectionFactory->createConnection( ac->getProperty("DBUpdateThreadConnectionString"), ac->getProperty("DBUpdateThreadSessionReadLockSetting") ), ac->log, SnapshotUpdateHandle(), paulst::toInt(ac->getProperty("DBUpdateThreadShutdownTimeoutSecs")), std::string("true") == ac->getProperty("DBUpdateThreadCancelPendingUpdatesOnShutdown"), ac->taskExceptionUserAdvisor, ac->config ); ac->resultAttributes = new ResultAttributes(); ac->clusterIDs = new ClusterIDs(); ac->projects = new Projects(); ac->testNames = new TestNames(); ac->controlModel = new ControlModelImpl(); ac->controlModelQueueListenerAdapter = new ControlModel::RuleEngineQueueListenerAdapter( ac->controlModel ); ac->controlModelResultPublisherAdapter = new ControlModel::RuleResultPublisherAdapter( ac->controlModel ); ac->compositeRuleEngineQueueListener = new CompositeRuleEngineQueueListener(); ac->compositeRuleEngineQueueListener->add( ac->controlModelQueueListenerAdapter ); ac->compositeRuleResultPublisher = new CompositeRuleResultPublisher(); ac->compositeRuleResultPublisher->add( ac->resultAttributes ); ac->compositeRuleResultPublisher->add( ac->controlModelResultPublisherAdapter ); ac->qcGates = new QCGates( ac->initialisationQueries, ac->config, ac->connectionFactory, ac->log, ac->localMachineID ); ac->ruleEngineContainer = new RuleEngineContainer( ac->initialisationQueries, ac->config, ac->connectionFactory, ac->log, ac->compositeRuleResultPublisher, ac->compositeRuleEngineQueueListener, ac->qcGates, ac->taskExceptionUserAdvisor ); ac->initialisationQueries->addTask( new DBQueryTask( "Projects", ac->connectionFactory, ac->config, boost::bind( addProject, _1, ac->projects ) ) ); ac->initialisationQueries->addTask( new DBQueryTask( "ClusterIDs", ac->connectionFactory, ac->config, boost::bind( addCluster, _1, ac->clusterIDs ) ) ); ac->initialisationQueries->addTask( new DBQueryTask( "TestNames", ac->connectionFactory, ac->config, boost::bind( addTestName, _1, ac->testNames ) ) ); applicationContext = ac; } }
void ScriptingSystem::initialiseModule(const ApplicationContext& ctx) { rMessage() << getName() << "::initialiseModule called." << std::endl; // Subscribe to get notified as soon as Radiant is fully initialised GlobalRadiant().signal_radiantStarted().connect( sigc::mem_fun(this, &ScriptingSystem::initialise) ); // Construct the script path #if defined(POSIX) && defined(PKGLIBDIR) _scriptPath = std::string(PKGLIBDIR) + "/scripts/"; #else _scriptPath = ctx.getRuntimeDataPath() + "scripts/"; #endif // When Python asks for the object, let's register our interfaces to the py::module PythonModule::RegisterToPython( std::bind(&ScriptingSystem::addInterfacesToModule, this, std::placeholders::_1, std::placeholders::_2)); // Add the built-in interfaces (the order is important, as we don't have dependency-resolution yet) addInterface("Math", std::make_shared<MathInterface>()); addInterface("GameManager", std::make_shared<GameInterface>()); addInterface("CommandSystem", std::make_shared<CommandSystemInterface>()); addInterface("SceneGraph", std::make_shared<SceneGraphInterface>()); addInterface("GlobalRegistry", std::make_shared<RegistryInterface>()); addInterface("GlobalEntityClassManager", std::make_shared<EClassManagerInterface>()); addInterface("GlobalSelectionSystem", std::make_shared<SelectionInterface>()); addInterface("Brush", std::make_shared<BrushInterface>()); addInterface("Patch", std::make_shared<PatchInterface>()); addInterface("Entity", std::make_shared<EntityInterface>()); addInterface("Radiant", std::make_shared<RadiantInterface>()); addInterface("Map", std::make_shared<MapInterface>()); addInterface("FileSystem", std::make_shared<FileSystemInterface>()); addInterface("Grid", std::make_shared<GridInterface>()); addInterface("ShaderSystem", std::make_shared<ShaderSystemInterface>()); addInterface("Model", std::make_shared<ModelInterface>()); addInterface("ModelSkinCacheInterface", std::make_shared<ModelSkinCacheInterface>()); addInterface("SoundManager", std::make_shared<SoundManagerInterface>()); addInterface("DialogInterface", std::make_shared<DialogManagerInterface>()); addInterface("SelectionSetInterface", std::make_shared<SelectionSetInterface>()); addInterface("SelectionGroupInterface", std::make_shared<SelectionGroupInterface>()); GlobalCommandSystem().addCommand( "RunScript", std::bind(&ScriptingSystem::runScriptFile, this, std::placeholders::_1), cmd::ARGTYPE_STRING ); GlobalCommandSystem().addCommand( "ReloadScripts", std::bind(&ScriptingSystem::reloadScriptsCmd, this, std::placeholders::_1) ); GlobalCommandSystem().addCommand( "RunScriptCommand", std::bind(&ScriptingSystem::runScriptCommand, this, std::placeholders::_1), cmd::ARGTYPE_STRING ); // Bind the reloadscripts command to the menu GlobalEventManager().addCommand("ReloadScripts", "ReloadScripts"); // Add the menu item IMenuManager& mm = GlobalUIManager().getMenuManager(); mm.insert("main/file/refreshShaders", // menu location path "ReloadScripts", // name ui::menuItem, // type _("Reload Scripts"), // caption "", // icon "ReloadScripts"); // event name SceneNodeBuffer::Instance().clear(); }