void FileDialogDisplayer::DisplayFileDialog( const Helium::FileDialogArgs& args ) { int32_t style = 0; switch ( args.m_Type ) { case FileDialogTypes::OpenFile: style = FileDialogStyles::DefaultOpen; break; case FileDialogTypes::SaveFile: style = FileDialogStyles::DefaultSave; break; default: HELIUM_ASSERT( false ); } FileDialog saveDlg( NULL, args.m_Caption.c_str(), args.m_DefaultDirectory.c_str(), args.m_DefaultFile.c_str(), TXT( "" ), style ); saveDlg.AddFilter( args.m_Filters ); Helium::Path path; if ( saveDlg.ShowModal() == wxID_OK ) { path.Set( saveDlg.GetFilePath() ); } args.m_Result = path; }
///////////////////////////////////////////////////////////////////////////// // Helper function to convert a file ref to an appropriate string // representation. // tstring Editor::PathToLabel( const Helium::Path& path, const FilePathOption filePathOption ) { tstring filePath = path.Get(); // Determine whether to show full path or not... if ( !filePath.empty() ) { switch ( filePathOption ) { case FilePathOptions::Basename: filePath = path.Basename(); break; case FilePathOptions::Filename: filePath = path.Filename(); break; case FilePathOptions::PartialPath: //FileSystem::StripPrefix( Finder::ProjectAssets(), filePath ); #pragma TODO( "Make this aware of the project root somehow, maybe the application/program options" ) break; case FilePathOptions::FullPath: // Do nothing, it's already good to go break; } } return filePath; }
AssetClassPtr MeshAssetFactory::Create( const Helium::Path& path ) { Helium::Path assetPath = path; assetPath.ReplaceExtension( TXT( "entity.nrb" ) ); if ( assetPath.Exists() ) { return AssetClass::LoadAssetClass( assetPath ); } EntityPtr entity = new Entity(); entity->SetPath( path.Filename() ); // we're dropping this guy relative to the data file MeshProcessingComponentPtr meshProcessingComponent = new MeshProcessingComponent(); entity->SetComponent( meshProcessingComponent ); try { Reflect::Archive::ToFile( entity, assetPath ); entity->SetSerializationPath( assetPath ); } catch( Helium::Exception& ) { delete entity; return NULL; } return entity; }
void ProjectViewModelNode::SetPath( const Helium::Path& path ) { if ( _tcsicmp( m_Path.c_str(), path.c_str() ) != 0 ) { m_Path = path; } }
bool ProjectViewModel::RemoveChildItem( const wxDataViewItem& parenItem, const Helium::Path& path ) { ProjectViewModelNode *parentNode = static_cast< ProjectViewModelNode* >( parenItem.GetID() ); if ( !parentNode ) { HELIUM_ASSERT( m_RootNode ); parentNode = m_RootNode.Ptr(); } S_ProjectViewModelNodeChildren::const_iterator foundChild = parentNode->GetChildren().end(); for ( S_ProjectViewModelNodeChildren::const_iterator itr = parentNode->GetChildren().begin(), end = parentNode->GetChildren().end(); itr != end; ++itr ) { if ( _tcsicmp( (*itr)->GetPath().Get().c_str(), path.Get().c_str() ) == 0 ) { foundChild = itr; break; } } if ( foundChild != parentNode->GetChildren().end() ) { RemoveItem( wxDataViewItem( (void*)(*foundChild) ) ); return true; } return false; }
Helium::Path Path::GetRelativePath( const Helium::Path& basisPath ) const { std::vector< tstring > targetDirectories = this->DirectoryAsVector(); std::vector< tstring > baseDirectories = basisPath.DirectoryAsVector(); size_t i = 0; while( targetDirectories.size() > i && baseDirectories.size() > i && ( targetDirectories[ i ] == baseDirectories[ i ] ) ) { ++i; } if ( i == 0 ) { return *this; } tstring newPathString; for ( size_t j = 0; j < ( baseDirectories.size() - i ); ++j ) { newPathString += tstring( TXT( ".." ) ) + s_InternalPathSeparator; } for ( size_t j = i; j < targetDirectories.size(); ++j ) { newPathString += targetDirectories[ j ] + s_InternalPathSeparator; } newPathString += Filename(); return Helium::Path( newPathString ); }
Helium::Path Path::GetAbsolutePath( const Helium::Path& basisPath ) const { HELIUM_ASSERT( !IsAbsolute() ); // shouldn't call this on an already-absolute path tstring newPathString; Helium::GetFullPath( tstring( basisPath.Directory() + m_Path ).c_str(), newPathString ); return Helium::Path( newPathString ); }
bool Helium::GetPreferencesDirectory( Helium::Path& preferencesDirectory ) { tstring prefDirectory; if ( !Helium::GetPreferencesDirectory( prefDirectory ) ) { return false; } prefDirectory += TXT( "/.Helium/" ); preferencesDirectory.Set( prefDirectory ); return true; }
tstring DetailsColumn::Size( const Helium::Path& path ) { i64 size = path.Size(); tstringstream printSize; if ( size == 0 ) { printSize << "0 KB"; } else if ( size <= 1024 ) { printSize << "1 KB"; } else { size = size / 1024; printSize << size << " KB"; } return printSize.str().c_str(); }
bool ProjectViewModel::AddChildItem( const wxDataViewItem& parenItem, const Helium::Path& path ) { // Get the parent node ProjectViewModelNode *parentNode = static_cast< ProjectViewModelNode* >( parenItem.GetID() ); if ( !parentNode ) { HELIUM_ASSERT( m_RootNode ); parentNode = m_RootNode.Ptr(); } bool isContainer = path.HasExtension( TXT( "HeliumScene" ) ); // Create the child node const Document* document = m_DocumentManager->FindDocument( path ); Helium::StdInsert<S_ProjectViewModelNodeChildren>::Result inserted = parentNode->GetChildren().insert( new ProjectViewModelNode( this, parentNode, path, document, isContainer ) ); if ( inserted.second ) { ProjectViewModelNode* childNode = (*inserted.first); // See if the document is already open //MM_ProjectViewModelNodesByPath::iterator findNode = m_MM_ProjectViewModelNodesByPath.find( path ); //if ( findNode != m_MM_ProjectViewModelNodesByPath.end() // && findNode->first == path // && findNode->second->GetDocument() ) //{ // childNode->ConnectDocument( findNode->second->GetDocument() ); //} // Add the node to the multimap and call ItemAdded m_MM_ProjectViewModelNodesByPath.insert( MM_ProjectViewModelNodesByPath::value_type( path, childNode )); if ( parentNode == m_RootNode.Ptr() ) { parentNode = NULL; } ItemAdded( (void*)parentNode, (void*)childNode ); return true; } return false; }
tstring DetailsColumn::Path( const Helium::Path& path ) { return path.Get(); }
bool Path::Copy( const Helium::Path& target, bool overwrite ) const { return Helium::Copy( Native().c_str(), target.Native().c_str(), overwrite ); }
tstring DetailsColumn::Directory( const Helium::Path& path ) { return path.Directory(); }
tstring DetailsColumn::Filename( const Helium::Path& path ) { return path.Filename(); }
bool Path::Move( const Helium::Path& target ) const { return Helium::Move( Native().c_str(), target.Native().c_str() ); }
void* ThumbnailLoader::LoadThread::Entry() { #ifdef HELIUM_ASSERT_ENABLED bool emptyQueuePollingCheck = false; #endif while ( true ) { m_Loader.m_Signal.Decrement(); if ( m_Loader.m_Quit ) { break; } // the device is gone, our glorious benefactor is probably cleaning up IDirect3DDevice9* device = m_Loader.m_DeviceManager->GetD3DDevice(); if ( !device ) { // You should stop this thread before letting go of the window that // owns the device. HELIUM_BREAK(); break; } // while the device is lost, just wait for it to come back while ( device->TestCooperativeLevel() != D3D_OK ) { if ( m_Loader.m_Quit ) { break; } wxThread::Sleep( 100 ); continue; } if ( m_Loader.m_Quit ) { break; } Helium::Path path; { Helium::Locker< Helium::OrderedSet< Helium::Path > >::Handle queue( m_Loader.m_FileQueue ); if ( !queue->Empty() ) { #ifdef HELIUM_ASSERT_ENABLED emptyQueuePollingCheck = false; #endif path = queue->Front(); } else { // if you hit this then the bookkeeping of the counting semaphore is broken HELIUM_ASSERT( !emptyQueuePollingCheck ); #ifdef HELIUM_ASSERT_ENABLED emptyQueuePollingCheck = true; #endif continue; } queue->Remove( path ); } ResultArgs args; args.m_Path = path; args.m_Cancelled = false; if ( SceneGraph::IsSupportedTexture( path.Get() ) ) { IDirect3DTexture9* texture = NULL; if ( texture = LoadTexture( device, path.Get() ) ) { ThumbnailPtr thumbnail = new Thumbnail( m_Loader.m_DeviceManager, texture ); args.m_Textures.push_back( thumbnail ); } } else { #pragma TODO( "When we store the thumbnail in the asset file, fix this." ) if ( path.Extension() == TXT( "HeliumEntity" ) ) { Path thumbnailPath( path.Directory() + path.Basename() + TXT( "_thumbnail.png" ) ); if ( thumbnailPath.Exists() ) { IDirect3DTexture9* texture = NULL; if ( texture = LoadTexture( device, thumbnailPath.Get() ) ) { ThumbnailPtr thumbnail = new Thumbnail( m_Loader.m_DeviceManager, texture ); args.m_Textures.push_back( thumbnail ); } } } // Include the color map of a shader as a possible thumbnail image else if ( path.Extension() == TXT( "HeliumShader" ) ) { Asset::ShaderAssetPtr shader = NULL; try { shader = Asset::AssetClass::LoadAssetClass< Asset::ShaderAsset >( path ); } catch( const Exception& ) { shader = NULL; } if ( shader ) { Asset::TexturePtr colorMap = Asset::AssetClass::LoadAssetClass< Asset::Texture >( shader->m_ColorMapPath ); if ( colorMap.ReferencesObject() ) { if ( colorMap->GetContentPath().Exists() && SceneGraph::IsSupportedTexture( colorMap->GetContentPath().Get() ) ) { IDirect3DTexture9* texture = NULL; if ( texture = LoadTexture( device, colorMap->GetContentPath().Get() ) ) { ThumbnailPtr thumbnail = new Thumbnail( m_Loader.m_DeviceManager, texture ); args.m_Textures.push_back( thumbnail ); } } } } } else if ( path.Extension() == TXT( "HeliumTexture" ) ) { Asset::TexturePtr textureAsset = NULL; try { textureAsset = Asset::AssetClass::LoadAssetClass< Asset::Texture >( path ); } catch( const Exception& ) { textureAsset = NULL; } if ( textureAsset.ReferencesObject() ) { if ( textureAsset->GetContentPath().Exists() && SceneGraph::IsSupportedTexture( textureAsset->GetContentPath().Get() ) ) { IDirect3DTexture9* texture = NULL; if ( texture = LoadTexture( device, textureAsset->GetContentPath().Get() ) ) { ThumbnailPtr thumbnail = new Thumbnail( m_Loader.m_DeviceManager, texture ); args.m_Textures.push_back( thumbnail ); } } } } } m_Loader.m_Result.Raise( args ); } return NULL; }
Helium::Path Path::operator+( const Helium::Path& rhs ) const { // you shouldn't use this on an absolute path HELIUM_ASSERT( !rhs.IsAbsolute() ); return rhs.GetAbsolutePath( *this ); }