void XMLParser::parseXMLString(XMLHandler& handler, const String& source, const String& schemaName) { // Put the source string into a RawDataContainer RawDataContainer rawXMLData; const char* c_str = source.c_str(); rawXMLData.setData((uint8*)c_str); rawXMLData.setSize(strlen(c_str)); try { // The actual parsing action (this is overridden and depends on the specific parser) parseXML(handler, rawXMLData, schemaName); } catch(...) { // make sure we don't allow rawXMLData to release String owned data no matter what! rawXMLData.setData(0); rawXMLData.setSize(0); CEGUI_RETHROW; } // !!! We must not allow DataContainer to delete String owned data, // therefore, we set it's data to 0 to avoid double-deletion rawXMLData.setData(0); rawXMLData.setSize(0); }
void GUIRenderer::initialize() { // BOOTSTRAP MANUAL guiRenderer = &Direct3D11Renderer::create(renderContext.device, renderContext.context); System::performVersionTest(CEGUI_VERSION_ABI, 208, CEGUI_FUNCTION_NAME); if (System::getSingletonPtr()) CEGUI_THROW(InvalidRequestException("CEGUI::System object is already initialised.")); System::create(*guiRenderer, &ceguiResourceProvider); // BOOTSTRAP MANUAL WindowManager& windowManager = WindowManager::getSingleton(); CEGUI::Window* rootWindow = windowManager.createWindow( "DefaultWindow", "root" ); System::getSingleton().getDefaultGUIContext().setRootWindow( rootWindow ); ImageManager::setImagesetDefaultResourceGroup("imagesets"); Font::setDefaultResourceGroup("fonts"); Scheme::setDefaultResourceGroup("schemes"); WidgetLookManager::setDefaultResourceGroup("looknfeels"); WindowManager::setDefaultResourceGroup("layouts"); DataContainer dllData = DLLResourceLoader::loadCEGUI_scheme(resourcesHmodule); RawDataContainer cScheme; cScheme.setData((CEGUI::uint8*) dllData.dataBlob); cScheme.setSize((size_t) dllData.dataSize); SchemeManager::getSingleton().createFromContainer(cScheme); cScheme.setData(0); cScheme.setSize(0); }
//----------------------------------------------------------------------------// void OgreResourceProvider::loadRawDataContainer(const String& filename, RawDataContainer& output, const String& resourceGroup) { String orpGroup; if (resourceGroup.empty()) orpGroup = d_defaultResourceGroup.empty() ? Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME.c_str() : d_defaultResourceGroup; else orpGroup = resourceGroup; Ogre::DataStreamPtr input = Ogre::ResourceGroupManager::getSingleton(). openResource(filename.c_str(), orpGroup.c_str()); if (input.isNull()) CEGUI_THROW(InvalidRequestException( "Unable to open resource file '" + filename + "' in resource group '" + orpGroup + "'.")); Ogre::String buf = input->getAsString(); const size_t memBuffSize = buf.length(); unsigned char* mem = new unsigned char[memBuffSize]; memcpy(mem, buf.c_str(), memBuffSize); output.setData(mem); output.setSize(memBuffSize); }
//----------------------------------------------------------------------------// void DefaultResourceProvider::unloadRawDataContainer(RawDataContainer& data) { uint8* const ptr = data.getDataPtr(); delete[] ptr; data.setData(0); data.setSize(0); }
//----------------------------------------------------------------------------// void OgreResourceProvider::unloadRawDataContainer(RawDataContainer& data) { if (data.getDataPtr()) { delete[] data.getDataPtr(); data.setData(0); data.setSize(0); } }
void DefaultResourceProvider::loadRawDataContainer(const String& filename, RawDataContainer& output, const String& resourceGroup) { if (filename.empty() || (filename == (utf8*)"")) { throw InvalidRequestException((utf8*) "DefaultResourceProvider::load - Filename supplied for data loading must be valid"); } std::wstring strFilename1 = filename.c_wstring (); std::wstring strFilename2 = System::getSingleton ().GetGuiWorkingDirectory().c_wstring () + strFilename1; // If supplied filename looks like it is absolute, try that first bool bIsAbsolutePath = false; { SString strTemp = PathConform ( filename.c_str () ); if ( strTemp.Contains ( ":" ) || strTemp.BeginsWith ( "\\" ) ) std::swap ( strFilename1, strFilename2 ); } std::ifstream dataFile; dataFile.open(strFilename2.c_str (), std::ios::binary|std::ios::ate); if( dataFile.fail()) { dataFile.clear(); dataFile.open(strFilename1.c_str (), std::ios::binary|std::ios::ate); if( dataFile.fail()) { throw InvalidRequestException((utf8*) "DefaultResourceProvider::load - " + filename + " does not exist"); } } std::streampos size = dataFile.tellg(); dataFile.seekg (0, std::ios::beg); unsigned char* buffer = new unsigned char [(uint)size]; try { dataFile.read(reinterpret_cast<char*>(buffer), size); } catch(std::ifstream::failure e) { delete [] buffer; throw GenericException((utf8*) "DefaultResourceProvider::loadRawDataContainer - Problem reading " + filename); } dataFile.close(); //memcpy(container->getDataPtr(), buffer, size); output.setData(buffer); output.setSize((size_t)size); //delete [] buffer; }
void IrrlichtResourceProvider::loadRawDataContainer(const String& filename, RawDataContainer& output, const String& resourceGroup) { if(!fsys->existFile(filename.c_str())) { String sMsg=(utf8*)"IrrlichtResourceProvider::loadRawDataContainer - Filename supplied for loading must be valid"; sMsg+=(utf8*)" ["+filename+(utf8*)"]"; throw InvalidRequestException(sMsg); } else { irr::u8* input; irr::u32 input_size; irr::io::IReadFile* f=fsys->createAndOpenFile(filename.c_str()); input_size=f->getSize(); input= new irr::u8[input_size]; f->read(input,input_size); output.setData(input); output.setSize(input_size); } }
//----------------------------------------------------------------------------// void DefaultResourceProvider::loadRawDataContainer(const String& filename, RawDataContainer& output, const String& resourceGroup) { if (filename.empty()) CEGUI_THROW(InvalidRequestException("DefaultResourceProvider::load: " "Filename supplied for data loading must be valid")); const String final_filename(getFinalFilename(filename, resourceGroup)); #if defined(__WIN32__) || defined(_WIN32) FILE* file = _wfopen(Utf8ToUtf16(final_filename.c_str()).c_str(), L"rb"); #else FILE* file = fopen(final_filename.c_str(), "rb"); #endif if (file == 0) CEGUI_THROW(InvalidRequestException("DefaultResourceProvider::load: " + final_filename + " does not exist")); fseek(file, 0, SEEK_END); const long size = ftell(file); fseek(file, 0, SEEK_SET); unsigned char* const buffer = new unsigned char[size]; const size_t size_read = fread(buffer, sizeof(char), size, file); fclose(file); if (size_read != size) { delete[] buffer; CEGUI_THROW(GenericException( "DefaultResourceProvider::loadRawDataContainer: " "A problem occurred while reading file: " + final_filename)); } output.setData(buffer); output.setSize(size); }
void NeLResourceProvider::loadRawDataContainer(const String &filename, RawDataContainer &output, const String& resourceGroup) { if(!NLMISC::CPath::exists(filename.c_str())) { nlinfo("Scheme::Scheme - Filename supplied for Scheme loading must be valid [%s]",filename.c_str()); String sMsg=(utf8*)"Scheme::Scheme - Filename supplied for Scheme loading must be valid"; sMsg+=(utf8*)" ["+filename+(utf8*)"]"; throw InvalidRequestException(sMsg); } uint32 input_size; std::string fname=NLMISC::CPath::lookup(filename.c_str()); NLMISC::CIFile f(NLMISC::CPath::lookup(filename.c_str())); // get the size of the file and create a temp container. input_size=f.getFileSize(); uint8 *input=new uint8[input_size+1]; input[input_size]=0; f.serialBuffer(input,input_size); f.close(); output.setData(input); output.setSize(input_size); }
//----------------------------------------------------------------------------// void MinizipResourceProvider::loadRawDataContainer(const String& filename, RawDataContainer& output, const String& resourceGroup) { const String final_filename = getFinalFilename(filename, resourceGroup); if (d_pimpl->d_loadLocal && doesFileExist(final_filename)) { DefaultResourceProvider::loadRawDataContainer(filename, output, resourceGroup); return; } if (d_pimpl->d_zfile == 0) { throw InvalidRequestException( "'" + final_filename + "' cannot be " "loaded because the archive has not been set"); } #if CEGUI_STRING_CLASS == CEGUI_STRING_CLASS_STD if (unzLocateFile(d_pimpl->d_zfile, final_filename.c_str(), 0) != UNZ_OK) #elif CEGUI_STRING_CLASS == CEGUI_STRING_CLASS_UNICODE if (unzLocateFile(d_pimpl->d_zfile, final_filename.toUtf8String().c_str(), 0) != UNZ_OK) #endif { throw InvalidRequestException("'" + final_filename + "' does not exist"); } unz_file_info file_info; if (unzGetCurrentFileInfo(d_pimpl->d_zfile, &file_info, 0, 0, 0, 0, 0, 0) != UNZ_OK) { throw FileIOException("'" + final_filename + "' error reading file header"); } if (unzOpenCurrentFile(d_pimpl->d_zfile) != Z_OK) { throw FileIOException("'" + final_filename + "' error opening file"); } std::uint64_t size = file_info.uncompressed_size; std::uint8_t* buffer = new std::uint8_t[size]; if (unzReadCurrentFile(d_pimpl->d_zfile, buffer, size) < 0) { throw FileIOException("'" + final_filename + "' error reading file"); } if (unzCloseCurrentFile(d_pimpl->d_zfile) != UNZ_OK) { throw GenericException("'" + final_filename + "' error validating file"); } output.setData(buffer); output.setSize(size); }