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