FileMap::FileMap(uint32 _size) : size(_size) { if (!size) throw FileIOException("Filemap of 0 bytes not possible"); data = (uchar8*)_aligned_malloc(size + FILEMAP_MARGIN, 16); if (!data) { throw FileIOException("Not enough memory to open file."); } mOwnAlloc = true; }
void XercesParser::parseXMLFile(XMLHandler& handler, const String& filename, const String& schemaName, const String& resourceGroup) { XERCES_CPP_NAMESPACE_USE; XercesHandler xercesHandler(handler); // create parser SAX2XMLReader* reader = createReader(xercesHandler); try { // set up schema initialiseSchema(reader, schemaName, filename, resourceGroup); // do parse doParse(reader, filename, resourceGroup); } catch(const XMLException& exc) { if (exc.getCode() != XMLExcepts::NoError) { delete reader; char* excmsg = XMLString::transcode(exc.getMessage()); String message("XercesParser::parseXMLFile - An error occurred at line nr. " + PropertyHelper::uintToString((uint)exc.getSrcLine()) + " while parsing XML file '" + filename + "'. Additional information: "); message += excmsg; XMLString::release(&excmsg); throw FileIOException(message); } } catch(const SAXParseException& exc) { delete reader; char* excmsg = XMLString::transcode(exc.getMessage()); String message("XercesParser::parseXMLFile - An error occurred at line nr. " + PropertyHelper::uintToString((uint)exc.getLineNumber()) + " while parsing XML file '" + filename + "'. Additional information: "); message += excmsg; XMLString::release(&excmsg); throw FileIOException(message); } catch(...) { delete reader; Logger::getSingleton().logEvent("XercesParser::parseXMLFile - An unexpected error occurred while parsing XML file '" + filename + "'.", Errors); throw; } // cleanup delete reader; }
void DS::FileStream::open(const char* filename, const char* mode) { close(); m_file = fopen(filename, mode); if (!m_file) throw FileIOException(strerror(errno)); }
/** write the image to disk */ void GeoImage::write() { QString fname = value("file"); Q_ASSERT(!fname.isEmpty()); switch (type_) { case PBM: case PGM: case PPM: qDebug("GeoImage::write: Format %d not supported", type_); break; default:{ FILE *of = fopen(fname.toLatin1().constData(), "w"); if (!of) { qWarning("GeoImage::write: (ERROR) Can't open file %s for writing!\n", fname.toLatin1().constData()); throw FileIOException(FileIOException::OPEN_FAILED, fname, __FILE__":GeoImage::write", __LINE__); return; } pfm_geo_set(geoWest(),geoNorth(),geoEast(),geoSouth()); pfm_writepfm_type(of, data_, cols_, rows_, 1, -1, type_); fclose(of); break; } } }
void ThrowFIE(const char* fmt, ...) { va_list val; va_start(val, fmt); char buf[8192]; vsprintf_s(buf, 8192, fmt, val); va_end(val); _RPT1(0, "EXCEPTION: %s\n", buf); throw FileIOException(buf); }
void XercesParser::parseXML(XMLHandler& handler, const RawDataContainer& source, const String& schemaName) { XERCES_CPP_NAMESPACE_USE; XercesHandler xercesHandler(handler); // create parser SAX2XMLReader* reader = createReader(xercesHandler); CEGUI_TRY { // set up schema initialiseSchema(reader, schemaName); // do parse doParse(reader, source); } CEGUI_CATCH(const XMLException& exc) { if (exc.getCode() != XMLExcepts::NoError) { delete reader; char* excmsg = XMLString::transcode(exc.getMessage()); String message("An error occurred at line nr. " + PropertyHelper<uint>::toString((uint)exc.getSrcLine()) + " while parsing XML. Additional information: "); message += excmsg; XMLString::release(&excmsg); CEGUI_THROW(FileIOException(message)); } } CEGUI_CATCH(const SAXParseException& exc) { delete reader; char* excmsg = XMLString::transcode(exc.getMessage()); String message("An error occurred at line nr. " + PropertyHelper<uint>::toString((uint)exc.getLineNumber()) + " while parsing XML. Additional information: "); message += excmsg; XMLString::release(&excmsg); CEGUI_THROW(FileIOException(message)); }
//----------------------------------------------------------------------------// void WindowManager::saveLayoutToFile(const Window& window, const String& filename) const { std::ofstream stream(filename.c_str()); if (!stream.good()) throw FileIOException( "failed to create stream for writing."); writeLayoutToStream(window, stream); }
TinyXMLDocument::TinyXMLDocument(XMLHandler& handler, const String& filename, const String& schemaName, const String& resourceGroup) { d_handler = &handler; // use resource provider to load file data // Fixed using patch from tracker item #000057 // cegui_mk2-0.4.1-fixtinyxml.patch RawDataContainer rawXMLData; System::getSingleton().getResourceProvider()->loadRawDataContainer(filename, rawXMLData, resourceGroup); // Create a buffer with extra bytes for a newline and a terminating null size_t size = rawXMLData.getSize(); char* buf = new char[size + 2]; memcpy(buf, rawXMLData.getDataPtr(), size); // PDT: The addition of the newline is a kludge to resolve an issue // whereby parse returns 0 if the xml file has no newline at the end but // is otherwise well formed. buf[size] = '\n'; buf[size+1] = 0; // Parse the document CEGUI_TINYXML_NAMESPACE::TiXmlDocument doc; if (!doc.Parse((const char*)buf)) { // error detected, cleanup out buffers delete[] buf; System::getSingleton().getResourceProvider()-> unloadRawDataContainer(rawXMLData); // throw exception throw FileIOException("TinyXMLParser: an error occurred while " "parsing the XML document '" + filename + "' - check it for potential errors!."); } const CEGUI_TINYXML_NAMESPACE::TiXmlElement* currElement = doc.RootElement(); if (currElement) { try { // function called recursively to parse xml data processElement(currElement); } catch(...) { delete [] buf; System::getSingleton().getResourceProvider()->unloadRawDataContainer(rawXMLData); throw; } } // if (currElement) // Free memory delete [] buf; System::getSingleton().getResourceProvider()->unloadRawDataContainer(rawXMLData); }
/** load image info - not the data */ void GeoImage::load() { QString fname = filename(); qDebug("GeoImage::load(%s)", fname.toLatin1().constData()); FILE *fp; fp = fopen(fname.toLatin1().constData(), "r"); if (!fp) { qDebug("# (ERROR)GeoImage::load(%s) Can't open file for reading!", fname.toLatin1().constData()); throw FileIOException(FileIOException::FILE_NOT_EXISTS, fname); } int pxmtype; xelval max_x; freeData(); float minval_, maxval_; if (pfm_readpfm_header(fp, &cols_, &rows_, &minval_, &maxval_, &pxmtype)) type_ = (IMGTYPE) pxmtype; //0 = FALSE, 1 = TRUE else { /* now check for all the other p?m-formats */ pnm_readpnminit(fp, &cols_, &rows_, &max_x, &pxmtype); rewind(fp); minval_ = 0.0; maxval_ = (float) max_x; if (pxmtype == PBM_FORMAT || pxmtype == RPBM_FORMAT) type_ = PBM; if (pxmtype == PGM_FORMAT || pxmtype == RPGM_FORMAT) type_ = PGM; if (pxmtype == PPM_FORMAT || pxmtype == RPPM_FORMAT) type_ = PPM; } fclose(fp); qDebug("## Image: (%d, %d) %f - %f, type: %d", cols_, rows_, minval_, maxval_, type_); if (type_ == UNKNOWN) qDebug("## (ERROR) unknown image type!"); #ifdef WIN32 replace("size_x", &QString::number(cols_)); replace("size_y", &QString::number(rows_)); resolutionX_ = (geoEast_ - geoWest_) / cols_; replace("res_x", &QString::number(resolutionX_)); resolutionY_ = (geoNorth_ - geoSouth_) / rows_; replace("res_y", &QString::number(resolutionY_)); #else replace("size_x", cols_); replace("size_y", rows_); resolutionX_ = (geoEast_ - geoWest_) / cols_; replace("res_x", resolutionX_); resolutionY_ = (geoNorth_ - geoSouth_) / rows_; replace("res_y", resolutionY_); #endif }
std::string PicoJsonIF::readData(std::string fileName) { std::ifstream ifs(fileName, std::ifstream::in); //assert(!ifs.fail()); if (ifs.fail()) { throw FileIOException("PicoJsonIF::readData() : cannot open file, fileName = " + fileName); } std::string contents; ifs.seekg(0, std::ios::end); contents.resize(ifs.tellg()); ifs.seekg(0, std::ios::beg); ifs.read(&contents[0], contents.size()); ifs.close(); return (contents); }
TinyXMLDocument::TinyXMLDocument(XMLHandler& handler, const RawDataContainer& source, const String& /*schemaName*/) { d_handler = &handler; // Create a buffer with extra bytes for a newline and a terminating null size_t size = source.getSize(); char* buf = new char[size + 2]; memcpy(buf, source.getDataPtr(), size); // PDT: The addition of the newline is a kludge to resolve an issue // whereby parse returns 0 if the xml file has no newline at the end but // is otherwise well formed. buf[size] = '\n'; buf[size+1] = 0; // Parse the document TiXmlDocument doc; if (!doc.Parse((const char*)buf)) { // error detected, cleanup out buffers delete[] buf; // throw exception throw FileIOException("an error occurred while " "parsing the XML document - check it for potential errors!."); } const TiXmlElement* currElement = doc.RootElement(); if (currElement) { try { // function called recursively to parse xml data processElement(currElement); } catch (...) { delete [] buf; throw; } } // if (currElement) // Free memory delete [] buf; }
/************************************************************************* SAX2 Handler methods *************************************************************************/ void Animate_xmlHandler::elementStart(const String& element, const XMLAttributes& attributes) { // handle an Animate element (extract all element attributes and use data to define an Animate) if(element == AnimateManagerElement) { } else if(element == AnimateElement) { String name(attributes.getValueAsString(AnimateNameAttribute)); bool loop = attributes.getValueAsBool(AnimatePlayLoop); int id = attributes.getValueAsInteger(AnimateID, -1); int totalTime = attributes.getValueAsInteger(AnimateTime, -1); bool alpha = attributes.getValueAsBool( AnimateAlphaMode ); int loopType = attributes.getValueAsInteger(AnimateAlphaType, 1 ); d_animate = AnimateManager::getSingleton().createAnimate(name, id, loop, totalTime, alpha, loopType ); } else if (element == AniamteItemElement ) { if(d_animate == 0) { throw GenericException("Aniamte::xmlHandler::startElement - Invalid file struct."); } const Image* pImage = PropertyHelper::stringToImage(attributes.getValueAsString(AniamteImage)); if(pImage) { d_animate->defineAnimateKey(pImage); AnimateManager::getSingleton().addAnimateImageset(pImage->getImagesetName()); } } else { throw FileIOException("Aniamte::xmlHandler::startElement - Unexpected data was found while parsing the animatefile: '" + element + "' is unknown."); } }
/************************************************************************* Define a glyph mapping (handle a <Mapping /> XML element) *************************************************************************/ void Font::defineMapping (const XMLAttributes& attributes) { throw FileIOException("Font::defineMapping - The <Mapping> XML element is not supported for this font type"); }
//----------------------------------------------------------------------------// RapidXMLDocument::RapidXMLDocument(XMLHandler& handler, const String& filename, const String& /*schemaName*/, const String& resourceGroup) { d_handler = &handler; // use resource provider to load file data RawDataContainer rawXMLData; System::getSingleton().getResourceProvider()-> loadRawDataContainer(filename, rawXMLData, resourceGroup); // Create a buffer with extra bytes for a newline and a terminating null size_t size = rawXMLData.getSize(); char* buf = new char[size + 2]; memcpy(buf, rawXMLData.getDataPtr(), size); // PDT: The addition of the newline is a kludge to resolve an issue // whereby parse returns 0 if the xml file has no newline at the end but // is otherwise well formed. buf[size] = '\n'; buf[size + 1] = 0; // Parse the document rapidxml::xml_document<> doc; // character type defaults to char try { doc.parse<0>(buf); // 0 means default parse flags } catch (...) { // error detected, cleanup out buffers delete[] buf; System::getSingleton().getResourceProvider()-> unloadRawDataContainer(rawXMLData); // throw exception throw FileIOException("RapidXMLParser: an error occurred while " "parsing the XML document '" + filename + "' - check it for potential errors!."); } rapidxml::xml_node<>* currElement = doc.first_node(); if (currElement) { try { // function called recursively to parse xml data processElement(currElement); } catch (...) { delete[] buf; System::getSingleton().getResourceProvider()-> unloadRawDataContainer(rawXMLData); throw; } } // Free memory delete[] buf; System::getSingleton().getResourceProvider()-> unloadRawDataContainer(rawXMLData); }
/** return data */ const void *GeoImage::data() { if (data_) return (void *) data_; qDebug("GeoImage::data() - load data"); QString fname = filename(); qDebug("GeoImage::data() %s", fname.toLatin1().constData()); FILE *fp; fp = fopen(fname.toLatin1().constData(), "r"); if (!fp) { qDebug("# (ERROR)GeoImage::load(%s) Can't open file for reading!", fname.toLatin1().constData()); throw FileIOException(FileIOException::FILE_NOT_EXISTS, fname, __FILE__":GeoImage::data", __LINE__); return 0; } int cols, rows; //float minval, maxval; switch (type_) { case PFM_FLOAT: case PFM_UINT: case PFM_SINT: case PFM_SINT16: case PFM_UINT16: case PFM_BYTE: case PFM_3BYTE: data_ = pfm_readpfm_type(fp, &cols, &rows, &minval_, &maxval_, type_, 0); testSize(cols, rows, type_); break; case PBM: data_ = (void *) pbm_readpbm(fp, &cols, &rows); minval_ = 0.0, maxval_ = 1.0; testSize(cols, rows, type_); break; case PGM:{ gray maxval, **data_g; data_g = pgm_readpgm(fp, &cols, &rows, &maxval); data_ = (void *) data_g; minval_ = 0.0, maxval_ = (float) maxval; testSize(cols, rows, type_); } break; case PPM: pixval maxval; pixel **dat_p; dat_p = ppm_readppm(fp, &cols, &rows, &maxval); data_ = (void *) dat_p; minval_ = 0.0, maxval_ = (float) maxval; testSize(cols, rows, type_); break; default: qDebug("Unknown type %d",type_); fclose(fp); return 0; } fclose(fp); if (data_) dataSize_=rows_*cols_*sizeOfData(type_); cache_.useImage(this); return data_; }
/************************************************************************* SAX2 Handler methods *************************************************************************/ void Font_xmlHandler::elementStart(const String& element, const XMLAttributes& attributes) { // handle a Mapping element if (element == MappingElement) { if (!d_font->d_freetype) { String image_name(attributes.getValueAsString(MappingImageAttribute)); utf32 codepoint = (utf32)attributes.getValueAsInteger(MappingCodepointAttribute); int horzAdvance = attributes.getValueAsInteger(MappingHorzAdvanceAttribute, -1); Font::glyphDat mapDat; mapDat.d_image = &d_font->d_glyph_images->getImage(image_name); // calculate advance width if it was not specified if (horzAdvance == AutoGenerateHorzAdvance) { horzAdvance = (int)(mapDat.d_image->getWidth() + mapDat.d_image->getOffsetX()); } mapDat.d_horz_advance_unscaled = horzAdvance; mapDat.d_horz_advance = (uint)(((float)horzAdvance) * (d_font->d_autoScale ? d_font->d_horzScaling : 1.0f)); d_font->d_cp_map[codepoint] = mapDat; } else { Logger::getSingleton().logEvent((utf8*)"Mapping element encountered. This element is invalid for dynamic fonts.", Informative); } } // handle root Font element else if (element == FontElement) { // get name of font we are creating String font_name(attributes.getValueAsString(FontNameAttribute)); // get filename for the font String filename(attributes.getValueAsString(FontFilenameAttribute)); // get resource group for font file. String resourceGroup(attributes.getValueAsString(FontResourceGroupAttribute)); Logger::getSingleton().logEvent("Started creation of Font '" + font_name + "' via XML file.", Informative); // // load auto-scaling configuration // float hres, vres; bool auto_scale; // get native horizontal resolution hres = (float)attributes.getValueAsInteger(FontNativeHorzResAttribute, 640); // get native vertical resolution vres = (float)attributes.getValueAsInteger(FontNativeVertResAttribute, 480); // get auto-scaling setting auto_scale = attributes.getValueAsBool(FontAutoScaledAttribute, false); // // get type of font // String font_type(attributes.getValueAsString(FontTypeAttribute)); // dynamic (ttf) font if (font_type == FontTypeDynamic) { // get size of font uint size = (uint)attributes.getValueAsInteger(FontSizeAttribute, 12); // extract codepoint range utf32 first_codepoint = (utf32)attributes.getValueAsInteger(FontFirstCodepointAttribute, 32); utf32 last_codepoint = (utf32)attributes.getValueAsInteger(FontLastCodepointAttribute, 127); // build string containing the required code-points. for (; first_codepoint <= last_codepoint; ++first_codepoint) { d_glyphSet += first_codepoint; } uint flags = attributes.getValueAsBool(FontAntiAliasedAttribute, true) ? 0 : NoAntiAlias; // perform pre-initialisation d_font->setNativeResolution(Size(hres, vres)); d_font->setAutoScalingEnabled(auto_scale); // Finalise construction of font without glyphs. // Glyphs will defined after we know which ones we need. d_font->constructor_impl(font_name, filename, resourceGroup, size, flags, String("")); } // static (Imageset based) font else if (font_type == FontTypeStatic) { d_font->d_name = font_name; d_font->d_freetype = false; // load the Imageset d_font->d_glyph_images = ImagesetManager::getSingleton().createImageset(filename, resourceGroup); d_font->setNativeResolution(Size(hres, vres)); d_font->setAutoScalingEnabled(auto_scale); } // error (should never happen) else { throw FileIOException("Font::xmlHandler::startElement - The unknown Font:Type attribute value '" + font_type + "' was encountered while processing the Font file."); } d_font->d_sourceFilename = filename; } // Glyph element else if (element == GlyphElement) { if (d_font->d_freetype) { utf32 codepoint = (utf32)attributes.getValueAsInteger(GlyphCodepointAttribute); if (d_glyphSet.find(codepoint) == String::npos) { d_glyphSet.append(1, codepoint); } } else { Logger::getSingleton().logEvent((utf8*)"Glyph element encountered. This element is invalid for static fonts.", Informative); } } // GlyphRange element else if (element == GlyphRangeElement) { if (d_font->d_freetype) { utf32 start = (utf32)attributes.getValueAsInteger(GlyphRangeStartCodepointAttribute); utf32 end = (utf32)attributes.getValueAsInteger(GlyphRangeEndCodepointAttribute); for (utf32 codepoint = start; codepoint <= end; ++codepoint) { if (d_glyphSet.find(codepoint) == String::npos) { d_glyphSet.append(1, codepoint); } } } else { Logger::getSingleton().logEvent((utf8*)"GlyphRange element encountered. This element is invalid for static fonts.", Informative); } } // GlyphSet element else if (element == GlyphSetElement) { if (d_font->d_freetype) { String glyphs(attributes.getValueAsString(GlyphSetGlyphsAttribute)); for (String::size_type i = 0; i < glyphs.length(); ++i) { utf32 codepoint = glyphs[i]; if (d_glyphSet.find(codepoint) == String::npos) { d_glyphSet.append(1, codepoint); } } } else { Logger::getSingleton().logEvent((utf8*)"GlyphSet element encountered. This element is invalid for static fonts.", Informative); } } // anything else is an error which *should* have already been caught by XML validation else { throw FileIOException("Font::xmlHandler::startElement - Unexpected data was found while parsing the Font file: '" + element + "' is unknown."); } }
ssize_t DS::BlobStream::writeBytes(const void* buffer, size_t count) { throw FileIOException("Cannot write to read-only stream"); }
/** Generate a mask image (pbm) */ QString GeoImage::mask(float west, float north, float east, float south, int id, QString prefixDir, QString fname) { #define GenMaskBlockStorage(T) \ { \ T* iptr; \ bit *optr; \ int x,y; \ for (y = 0; y < dy; y++) { \ if (y<-ry1 || y>=rows_-ry1) iptr=0; \ else iptr = ((T*)data_p)+(y + ry1)*cols_+rx1; \ optr = dat_b_out[y]; \ for (x = 0; x < dx; x++) { \ if (!iptr || x<-rx1 || x>=cols_-rx1) *optr=0; \ else *optr=(*iptr==(T)id?1:0); \ optr ++; \ if (iptr) iptr ++; \ } \ } \ } #define GenMaskRowStorage(T) \ { \ T* iptr; \ bit *optr; \ int x,y; \ for (y = 0; y < dy; y++) { \ if (y<-ry1 || y>=rows_-ry1) iptr=0; \ else iptr = (((T**)data_p)[y + ry1]) + rx1; \ optr = dat_b_out[y]; \ for (x = 0; x < dx; x++) { \ if (!iptr || x<-rx1 || x>=cols_-rx1) *optr=0; \ else *optr=(*iptr==(T)id?1:0); \ optr ++; \ if (iptr) iptr ++; \ } \ } \ } if (fname.isEmpty()) { //create output filname Q_ASSERT(contains("key")); QString dir = CleanUp::mkdir(CleanUp::getTmpDirPID(), prefixDir); fname.sprintf("%s/%f_%f_%f_%f.pbm", dir.toLatin1().constData(), west, north, east, south); qDebug("GeoImage::mask: create output filename %s",fname.toLatin1().constData()); } qDebug("# GeoImage::mask %s (%f, %f, %f, %f)", fname.toLatin1().constData(), west, north, east, south); QFile f(fname); if (f.exists()) { qDebug("mask %s already exists",fname.toLatin1().constData()); return fname; } const void *data_p = data(); //get pointer to data Q_ASSERT(data_p); if (type_ == UNKNOWN) throw ImageException(ImageException::UnknownType, filename(), __FILE__":GeoImage::mask", __LINE__); int dx, dy, rx1, ry1, rx2, ry2; picBBox(west, north, east, south, rx1, ry2, rx2, ry1); qDebug("GeoImage::mask: picBBox: (%f, %f, %f, %f) (rx1=%d, ry2=%d, rx2=%d, ry1=%d", west, north, east, south, rx1, ry2, rx2, ry1); dx = rx2 - rx1 + 1; dy = ry2 - ry1 + 1; if (dx <= 0 || dy <= 0) { throw ImageException(ImageException::Dimension, rx1, rx2, dx, ry1, ry2, dy, __FILE__":GeoImage::mask", __LINE__); } FILE *of = fopen(fname.toLatin1().constData(), "w"); if (!of) { throw FileIOException(FileIOException::OPEN_FAILED, fname, __FILE__":GeoImage::mask", __LINE__); return ""; } bit **dat_b_out = pbm_allocarray(dx, dy); switch (type_) { case PFM_FLOAT: GenMaskBlockStorage(float); break; case PFM_UINT: GenMaskBlockStorage(unsigned int); break; case PFM_SINT: GenMaskBlockStorage(signed int); break; case PFM_UINT16: GenMaskBlockStorage(unsigned short); break; case PFM_SINT16: GenMaskBlockStorage(signed short); break; case PBM:{ bit *iptr; bit *optr; int x, y; for (y = 0; y < dy; y++) { iptr = (((bit **) data_p)[y + ry1]) + rx1; optr = dat_b_out[y]; for (x = 0; x < dx; x++) { *optr = (*iptr == (bit) id ? 1 : 0); optr++; iptr++; } } } // GenMaskRowStorage(bit); break; case PFM_BYTE: GenMaskBlockStorage(unsigned char); break; default: pbm_freearray(dat_b_out, dy); fclose(of); return ""; break; } pbm_writepbm(of, (bit **) dat_b_out, dx, dy, 0); pbm_freearray(dat_b_out, dy); fclose(of); return fname; #undef GenMaskBlockStorage #undef GenMaskRowStorage }
/** write a scrap of the data, * return the filename, * if the file exist do nothing * argument fname is optional * the coordinates of the image part are geodata e.g. Gauss Krueger **/ QString GeoImage::part(float west, float north, float east, float south, QString fname) { if (fname.isEmpty()) { //create output filname Q_ASSERT(contains("key")); QString dir = CleanUp::getTmpDir(); fname.sprintf("%s/%s_%f_%f_%f_%f", dir.toLatin1().constData(), value("key").toLatin1().constData(), west, north, east, south); } qDebug("# GeoImage::part %s (%f, %f, %f, %f)", fname.toLatin1().constData(), west, north, east, south); QFile f(fname); if (f.exists()) return fname; const void *data_p = data(); //get pointer to data Q_ASSERT(data_p); if (type_ == UNKNOWN) return 0; int dx, dy, i, j, rx1, ry1, rx2, ry2; picBBox(west, north, east, south, rx1, ry2, rx2, ry1); dx = rx2 - rx1 + 1; dy = ry2 - ry1 + 1; if (dx <= 0 || dy <= 0) { qDebug("# (ERROR) GeoImage::part: (dx=%d=%d-%d || dy=%d=%d-%d)", dx, rx2, rx1, dy, ry2, ry1); throw ImageException(rx1,rx2,dx,ry1,ry2,dy); } FILE *of = fopen(fname.toLatin1().constData(), "w"); if (!of) { throw FileIOException(FileIOException::OPEN_FAILED,fname); } switch (type_) { case PBM:{ bit *bpi, *bpo, **dat_b_out = pbm_allocarray(dx, dy); bit **dat_b = (bit **) data_p; for (i = 0; i < dy; i++) { bpi = dat_b[i + ry1] + rx1; bpo = dat_b_out[i]; for (j = 0; j < dx; j++) { *bpo = *bpi; bpo++; bpi++; } } pbm_writepbm(of, (bit **) dat_b_out, dx, dy, 0); pbm_freearray(dat_b_out, dy); } break; case PGM:{ gray *gpi, *gpo, **dat_g_out = pgm_allocarray(dx, dy); gray **dat_g = (gray **) data_p; gray maxval = 0; for (i = 0; i < dy; i++) { gpi = dat_g[i + ry1] + rx1; gpo = dat_g_out[i]; for (j = 0; j < dx; j++) { *gpo = *gpi; if (*gpi > maxval) maxval = *gpi; gpo++; gpi++; } } pgm_writepgm(of, (gray **) dat_g_out, dx, dy, maxval, 0); pgm_freearray(dat_g_out, dy); } break; case PPM:{ pixel *ppi, *ppo, **dat_p_out = ppm_allocarray(dx, dy); pixel **dat_p = (pixel **) data_p; pixval maxval = 255; //! should be calculated for (i = 0; i < dy; i++) { ppi = dat_p[i + ry1] + rx1; ppo = dat_p_out[i]; for (j = 0; j < dx; j++) { *ppo = *ppi; ppo++; ppi++; } } ppm_writeppm(of, (pixel **) dat_p_out, dx, dy, maxval, 0); ppm_freearray(dat_p_out, dy); } break; default: pfm_geo_set(geoWest(),geoNorth(),geoEast(),geoSouth()); pfm_writepfm_region_type(of, data_, cols_, rows_, minval_, maxval_, rx1, ry1, rx2, ry2, type_); break; } fclose(of); return fname; }
//----------------------------------------------------------------------------// 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); }
/************************************************************************* Handler methods *************************************************************************/ void Scheme_xmlHandler::elementStart(const String& element, const XMLAttributes& attributes) { // handle alias element if (element == WindowAliasElement) { Scheme::AliasMapping alias; alias.aliasName = attributes.getValueAsString(AliasAttribute); alias.targetName = attributes.getValueAsString(TargetAttribute); d_scheme->d_aliasMappings.push_back(alias); } // handle an Imageset element else if (element == ImagesetElement) { Scheme::LoadableUIElement imageset; imageset.name = attributes.getValueAsString(NameAttribute); imageset.filename = attributes.getValueAsString(FilenameAttribute); imageset.resourceGroup = attributes.getValueAsString(ResourceGroupAttribute); d_scheme->d_imagesets.push_back(imageset); } // handle an ImagesetFromImage element else if (element == ImagesetFromImageElement) { Scheme::LoadableUIElement imageset; imageset.name = attributes.getValueAsString(NameAttribute); imageset.filename = attributes.getValueAsString(FilenameAttribute); imageset.resourceGroup = attributes.getValueAsString(ResourceGroupAttribute); d_scheme->d_imagesetsFromImages.push_back(imageset); } // handle a font element else if (element == FontElement) { Scheme::LoadableUIElement font; font.name = attributes.getValueAsString(NameAttribute); font.filename = attributes.getValueAsString(FilenameAttribute); font.resourceGroup = attributes.getValueAsString(ResourceGroupAttribute); d_scheme->d_fonts.push_back(font); } // handle a WindowSet element else if (element == WindowSetElement) { Scheme::UIModule module; module.name = attributes.getValueAsString(FilenameAttribute); module.module = NULL; module.factories.clear(); d_scheme->d_widgetModules.push_back(module); } // handle a WindowFactory element else if (element == WindowFactoryElement) { Scheme::UIElementFactory factory; factory.name = attributes.getValueAsString(NameAttribute); d_scheme->d_widgetModules[d_scheme->d_widgetModules.size() - 1].factories.push_back(factory); } // handle root Scheme element else if (element == GUISchemeElement) { // get name of scheme we are creating d_scheme->d_name = attributes.getValueAsString(NameAttribute); Logger::getSingleton().logEvent("Started creation of Scheme '" + d_scheme->d_name + "' via XML file.", Informative); if (SchemeManager::getSingleton().isSchemePresent(d_scheme->d_name)) { throw AlreadyExistsException((utf8*)"A GUI Scheme named '" + d_scheme->d_name + "' is already present in the system."); } } else if (element == FalagardMappingElement) { Scheme::FalagardMapping fmap; fmap.windowName = attributes.getValueAsString(WindowTypeAttribute); fmap.targetName = attributes.getValueAsString(TargetTypeAttribute); fmap.lookName = attributes.getValueAsString(LookNFeelAttribute); d_scheme->d_falagardMappings.push_back(fmap); } else if (element == LookNFeelElement) { Scheme::LoadableUIElement lnf; lnf.filename = attributes.getValueAsString(FilenameAttribute); lnf.resourceGroup = attributes.getValueAsString(ResourceGroupAttribute); d_scheme->d_looknfeels.push_back(lnf); } // anything else is an error which *should* have already been caught by XML validation else { throw FileIOException("Scheme::xmlHandler::startElement - Unexpected data was found while parsing the Scheme file: '" + element + "' is unknown."); } }