void PicoModelLoader::initialiseModule(const ApplicationContext& ctx) { rMessage() << "PicoModelLoader: " << getName() << " initialised." << std::endl; std::string extLower = boost::to_lower_copy(_extension); std::string filter("*." + extLower); // Register the model file extension in the FileTypRegistry GlobalFiletypes().registerPattern("model", FileTypePattern(_module->displayName, extLower, filter)); GlobalFiletypes().registerModule("model", extLower, getName()); }
void MD5ModelLoader::initialiseModule(const ApplicationContext& ctx) { rMessage() << "MD5Model::initialiseModule called." << std::endl; std::string extLower = "md5mesh"; std::string filter = "*." + extLower; // Register the model file extension in the FileTypRegistry GlobalFiletypes().registerPattern("model", FileTypePattern("MD5 Meshes", extLower, filter)); GlobalFiletypes().registerModule("model", extLower, getName()); }
void Doom3PrefabFormat::initialiseModule(const ApplicationContext& ctx) { rMessage() << getName() << ": initialiseModule called." << std::endl; // Register ourselves as map format GlobalMapFormatManager().registerMapFormat("pfb", shared_from_this()); // Register the prefab file extension for the "map" filetype GlobalFiletypes().registerPattern("map", FileTypePattern(_("Doom 3 prefab"), "pfb", "*.pfb")); // Register the prefab file extensions for the "prefab" filetype GlobalFiletypes().registerPattern("prefab", FileTypePattern(_("Doom 3 prefab"), "pfb", "*.pfb")); GlobalFiletypes().registerPattern("prefab", FileTypePattern(_("Doom 3 map"), "map", "*.map")); GlobalFiletypes().registerPattern("prefab", FileTypePattern(_("Doom 3 region"), "reg", "*.reg")); }
NodeSmartReference Model_load(ModelLoader* loader, const char* path, const char* name, const char* type) { if(loader != 0) { return ModelResource_load(loader, name); } else { const char* moduleName = findModuleName(&GlobalFiletypes(), MapFormat::Name(), type); if(string_not_empty(moduleName)) { const MapFormat* format = ReferenceAPI_getMapModules().findModule(moduleName); if(format != 0) { return MapResource_load(*format, path, name); } else { globalErrorStream() << "ERROR: Map type incorrectly registered: \"" << moduleName << "\"\n"; return g_nullModel; } } else { if(string_not_empty(type)) { globalErrorStream() << "Model type not supported: \"" << name << "\"\n"; } return g_nullModel; } } }
void PicoModelLoader::initialiseModule(const ApplicationContext& ctx) { globalOutputStream() << "PicoModelLoader: " << getName().c_str() << " initialised.\n"; std::string filter("*." + boost::to_lower_copy(_extension)); // Register the model file extension in the FileTypRegistry GlobalFiletypes().addType( "model", getName(), FileTypePattern(_module->displayName, filter.c_str()) ); }
/** * @brief Returns the model loader for the model \p type or 0 if the model \p type has no loader module */ ModelLoader* ModelLoader_forType (const std::string& type) { const std::string moduleName = findModuleName(&GlobalFiletypes(), std::string(ModelLoader::Name()), type); if (!moduleName.empty()) { ModelLoader* table = ReferenceAPI_getModelModules().findModule(moduleName); if (table != 0) { return table; } else { globalErrorStream() << "ERROR: Model type incorrectly registered: " << moduleName << "\n"; return &g_NullModelLoader; } } return 0; }
NodeSmartReference Model_load (ModelLoader* loader, const std::string& path, const std::string& name, const std::string& type) { if (loader != 0) { return ModelResource_load(loader, name); } else { // Get a loader module name for this type, if possible. If none is // found, try again with the "map" type, since we might be loading a // map with a different extension std::string moduleName = findModuleName(&GlobalFiletypes(), MapFormat::Name(), type); // Empty, try again with "map" type if (moduleName.empty()) { moduleName = findModuleName(&GlobalFiletypes(), MapFormat::Name(), "map"); } const MapFormat* format = ReferenceAPI_getMapModules().findModule(moduleName); if (format != 0) { return MapResource_load(*format, path, name); } else { globalErrorStream() << "ERROR: Map type incorrectly registered: " << moduleName << "\n"; return g_nullModel; } } }
// Utility method to select a map file std::string MapFileManager::selectFile(bool open, const std::string& title, const std::string& type, const std::string& defaultFile) { // Check, if the lastdir contains at least anything and load // the default map path if it's empty if (_lastDirs.find(type) == _lastDirs.end()) { // Default to the map path, if the type is not yet associated _lastDirs[type] = GlobalRegistry().get(RKEY_MAP_PATH); } // Get the first extension from the list of possible patterns (e.g. *.pfb or *.map) FileTypePatterns patterns = GlobalFiletypes().getPatternsForType(type); std::string defaultExt = ""; if (!patterns.empty()) { defaultExt = "." + patterns.begin()->extension; // ".map" } // Display a file chooser dialog to get a new path gtkutil::FileChooser fileChooser(GlobalMainFrame().getTopLevelWindow(), title, open, false, type, defaultExt); fileChooser.setCurrentFile(defaultFile); fileChooser.setCurrentPath(_lastDirs[type]); // For prefabs, add a preview widget if (open && type == "prefab") { // Instantiate a new preview object MapFileChooserPreviewPtr preview(new MapFileChooserPreview()); // attach the preview object fileChooser.attachPreview(preview); } std::string filePath = fileChooser.display(); // If a filename was chosen, update the last path if (!filePath.empty()) { _lastDirs[type] = filePath.substr(0, filePath.rfind("/")); } return gtkutil::IConv::localeFromUTF8(filePath); }
/// \brief Returns the model loader for the model \p type or 0 if the model \p type has no loader module ModelLoader* ModelLoader_forType(const char* type) { const char* moduleName = findModuleName(&GlobalFiletypes(), ModelLoader::Name(), type); if(string_not_empty(moduleName)) { ModelLoader* table = ReferenceAPI_getModelModules().findModule(moduleName); if(table != 0) { return table; } else { globalErrorStream() << "ERROR: Model type incorrectly registered: \"" << moduleName << "\"\n"; return &g_NullModelLoader; } } return 0; }
ModelLoaderPtr ModelCache::getModelLoaderForType(const std::string& type) { // Get the module name from the Filetype registry std::string moduleName = GlobalFiletypes().findModule("model", type); if (!moduleName.empty()) { ModelLoaderPtr modelLoader = boost::static_pointer_cast<ModelLoader>( module::GlobalModuleRegistry().getModule(moduleName) ); if (modelLoader != NULL) { return modelLoader; } else { rError() << "ERROR: Model type incorrectly registered: \"" << moduleName << "\"" << std::endl; } } return NullModelLoader::InstancePtr(); }
// Look for a module which loads the given extension, by searching under the // given type category std::string RadiantFileTypeRegistry::findModuleName( const std::string& moduleType, const std::string& extension) { // Convert the file extension to lowercase std::string ext = boost::algorithm::to_lower_copy(extension); // Get the list of types for the type category ModuleTypeListPtr list = GlobalFiletypes().getTypesFor(moduleType); // Search in the list for the given extension for (ModuleTypeList::const_iterator i = list->begin(); i != list->end(); ++i) { std::string patternExt = os::getExtension(i->filePattern.pattern); if (patternExt == ext) { // Match return i->moduleName; } } // Not found, return empty string return ""; }
const char* file_dialog_show(GtkWidget* parent, bool open, const char* title, const char* path, const char* pattern) { filetype_t type; if(pattern == 0) { pattern = "*"; } FileTypeList typelist; GlobalFiletypes().getTypeList(pattern, &typelist); GTKMasks masks(typelist); if (title == 0) title = open ? "Open File" : "Save File"; GtkWidget* dialog; if (open) { dialog = gtk_file_chooser_dialog_new(title, GTK_WINDOW(parent), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); } else { dialog = gtk_file_chooser_dialog_new(title, GTK_WINDOW(parent), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "unnamed"); } gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); // we expect an actual path below, if the path is 0 we might crash if (path != 0 && !string_empty(path)) { ASSERT_MESSAGE(path_is_absolute(path), "file_dialog_show: path not absolute: " << makeQuoted(path)); Array<char> new_path(strlen(path)+1); // copy path, replacing dir separators as appropriate Array<char>::iterator w = new_path.begin(); for(const char* r = path; *r != '\0'; ++r) { *w++ = (*r == '/') ? G_DIR_SEPARATOR : *r; } // remove separator from end of path if required if(*(w-1) == G_DIR_SEPARATOR) { --w; } // terminate string *w = '\0'; gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), new_path.data()); } // we should add all important paths as shortcut folder... // gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog), "/tmp/", NULL); for(std::size_t i = 0; i < masks.m_filters.size(); ++i) { GtkFileFilter* filter = gtk_file_filter_new(); gtk_file_filter_add_pattern(filter, masks.m_filters[i].c_str()); gtk_file_filter_set_name(filter, masks.m_masks[i].c_str()); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); } if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { strcpy(g_file_dialog_file, gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog))); if(!string_equal(pattern, "*")) { GtkFileFilter* filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog)); if(filter != 0) // no filter set? some file-chooser implementations may allow the user to set no filter, which we treat as 'all files' { type = masks.GetTypeForGTKMask(gtk_file_filter_get_name(filter)).m_type; // last ext separator const char* extension = path_get_extension(g_file_dialog_file); // no extension if(string_empty(extension)) { strcat(g_file_dialog_file, type.pattern+1); } else { strcpy(g_file_dialog_file + (extension - g_file_dialog_file), type.pattern+2); } } } // convert back to unix format for(char* w = g_file_dialog_file; *w!='\0'; w++) { if(*w=='\\') { *w = '/'; } } } else { g_file_dialog_file[0] = '\0'; } gtk_widget_destroy(dialog); // don't return an empty filename if(g_file_dialog_file[0] == '\0') return NULL; return g_file_dialog_file; }