bool QGLPixmapData::fromFile(const QString &filename, const char *format,
Qt::ImageConversionFlags flags)
{
if (pixelType() == QPixmapData::BitmapType)
return QPixmapData::fromFile(filename, format, flags);
QFile file(filename);
if (!file.open(QIODevice::ReadOnly))
return false;
QByteArray data = file.peek(64);
bool alpha;
if (m_texture.canBindCompressedTexture
(data.constData(), data.size(), format, &alpha)) {
resize(0, 0);
data = file.readAll();
file.close();
QGLShareContextScope ctx(qt_gl_share_widget()->context());
QSize size = m_texture.bindCompressedTexture
(data.constData(), data.size(), format);
if (!size.isEmpty()) {
w = size.width();
h = size.height();
is_null = false;
d = 32;
m_hasAlpha = alpha;
m_source = QImage();
m_dirty = isValid();
return true;
}
return false;
}
fromImage(QImageReader(&file, format).read(), flags);
return !isNull();
}
void QMeeGoRasterPixmapData::copy(const QPixmapData *data, const QRect &rect)
{
if (data->classId() == QPixmapData::OpenGLClass)
fromImage(data->toImage(rect).copy(), Qt::NoOpaqueDetection);
else
QRasterPixmapData::copy(data, rect);
}
/*
void CPixmap::toLuminosity(int value) {
m_effects.push_back(...);
QImage img = this->toImage();
QImage dest(img.size(), img.format());
QColor pixel;
for(int x=0; x<img.width();x++) {
for (int y=0; y<img.height(); y++) {
pixel = img.pixel(x, y);
int green = pixel.green() + value;
int red = pixel.red() + value;
int blue = pixel.blue() + value;
if(green > 255) green = 255;
else if(green < 0) green = 0;
if(red > 255) red = 255;
else if(red < 0) red = 0;
if(blue > 255) blue = 255;
else if(blue <0) blue = 0;
pixel.setGreen(green);
pixel.setBlue(blue);
pixel.setRed(red);
dest.setPixel(x,y,pixel.rgb());
}
}
updateImage(dest);
}
*/
void CPixmap::updateImage(QImage &newImage) {
QString copyFilePath = m_filePath;
QList<CEffect> copyEffects = m_effects;
*this = fromImage(newImage);
m_filePath = copyFilePath;
m_effects = copyEffects;
}
bool QPlatformPixmap::fromFile(const QString &fileName, const char *format,
Qt::ImageConversionFlags flags)
{
QImage image = QImageReader(fileName, format).read();
if (image.isNull())
return false;
fromImage(makeBitmapCompliantIfNeeded(this, image, flags), flags);
return !isNull();
}
void CPixmap::updateImage(QImage &newImage)
{
QImage copyImage = m_image;
QString copyFilePath = m_filePath;
QList<PictureEffect> copyEffects = m_effects;
*this = fromImage(newImage);
m_image = copyImage;
m_filePath = copyFilePath;
m_effects = copyEffects;
}
bool QPlatformPixmap::fromData(const uchar *buf, uint len, const char *format, Qt::ImageConversionFlags flags)
{
QByteArray a = QByteArray::fromRawData(reinterpret_cast<const char *>(buf), len);
QBuffer b(&a);
b.open(QIODevice::ReadOnly);
QImage image = QImageReader(&b, format).read();
if (image.isNull())
return false;
fromImage(makeBitmapCompliantIfNeeded(this, image, flags), flags);
return !isNull();
}
QBitmap &QBitmap::operator=(const QPixmap &pixmap)
{
if (pixmap.isNull()) { // a null pixmap
QBitmap bm(0, 0);
QBitmap::operator=(bm);
} else if (pixmap.depth() == 1) { // 1-bit pixmap
QPixmap::operator=(pixmap); // shallow assignment
} else { // n-bit depth pixmap
QImage image;
image = pixmap.toImage(); // convert pixmap to image
*this = fromImage(image); // will dither image
}
return *this;
}
void
RadialMap::Map::invalidate(const bool desaturateTheImage)
{
delete [] m_signature;
m_signature = 0;
if (desaturateTheImage) {
QImage img = this->toImage();
KIconEffect::deSaturate(img, 0.7);
KIconEffect::toGray(img, true);
this->QPixmap::operator=(fromImage(img, Qt::AutoColor));
}
m_visibleDepth = Config::defaultRingDepth;
}
void QVGPixmapData::copy(const QPixmapData *data, const QRect &rect)
{
// toImage() is potentially expensive with QVolatileImage so provide a
// more efficient implementation of copy() that does not rely on it.
if (!data) {
return;
}
if (data->classId() != OpenVGClass) {
fromImage(data->toImage(rect), Qt::NoOpaqueDetection);
return;
}
const QVGPixmapData *pd = static_cast<const QVGPixmapData *>(data);
QRect r = rect;
if (r.isNull() || r.contains(QRect(0, 0, pd->w, pd->h))) {
r = QRect(0, 0, pd->w, pd->h);
}
resize(r.width(), r.height());
recreate = true;
if (!pd->source.isNull()) {
source = QVolatileImage(r.width(), r.height(), pd->source.format());
source.copyFrom(&pd->source, r);
}
}
void QMacPixmapData::fromImage(const QImage &img,
Qt::ImageConversionFlags flags)
{
setSerialNumber(++qt_pixmap_serial);
// the conversion code only handles format >=
// Format_ARGB32_Premultiplied at the moment..
if (img.format() > QImage::Format_ARGB32_Premultiplied) {
QImage image;
if (img.hasAlphaChannel())
image = img.convertToFormat(QImage::Format_ARGB32_Premultiplied);
else
image = img.convertToFormat(QImage::Format_RGB32);
fromImage(image, flags);
return;
}
w = img.width();
h = img.height();
is_null = (w <= 0 || h <= 0);
d = (pixelType() == BitmapType ? 1 : img.depth());
QImage image = img;
int dd = QPixmap::defaultDepth();
bool force_mono = (dd == 1 ||
(flags & Qt::ColorMode_Mask)==Qt::MonoOnly);
if (force_mono) { // must be monochrome
if (d != 1) {
image = image.convertToFormat(QImage::Format_MonoLSB, flags); // dither
d = 1;
}
} else { // can be both
bool conv8 = false;
if(d > 8 && dd <= 8) { // convert to 8 bit
if ((flags & Qt::DitherMode_Mask) == Qt::AutoDither)
flags = (flags & ~Qt::DitherMode_Mask)
| Qt::PreferDither;
conv8 = true;
} else if ((flags & Qt::ColorMode_Mask) == Qt::ColorOnly) {
conv8 = d == 1; // native depth wanted
} else if (d == 1) {
if (image.colorCount() == 2) {
QRgb c0 = image.color(0); // Auto: convert to best
QRgb c1 = image.color(1);
conv8 = qMin(c0,c1) != qRgb(0,0,0) || qMax(c0,c1) != qRgb(255,255,255);
} else {
// eg. 1-color monochrome images (they do exist).
conv8 = true;
}
}
if (conv8) {
image = image.convertToFormat(QImage::Format_Indexed8, flags);
d = 8;
}
}
if (image.depth()==1) {
image.setColor(0, QColor(Qt::color0).rgba());
image.setColor(1, QColor(Qt::color1).rgba());
}
if (d == 16 || d == 24) {
image = image.convertToFormat(QImage::Format_RGB32, flags);
fromImage(image, flags);
return;
}
// different size or depth, make a new pixmap
resize(w, h);
quint32 *dptr = pixels, *drow;
const uint dbpr = bytesPerRow;
const QImage::Format sfmt = image.format();
const unsigned short sbpr = image.bytesPerLine();
// use const_cast to prevent a detach
const uchar *sptr = const_cast<const QImage &>(image).bits(), *srow;
for (int y = 0; y < h; ++y) {
drow = dptr + (y * (dbpr / 4));
srow = sptr + (y * sbpr);
switch(sfmt) {
case QImage::Format_MonoLSB:
case QImage::Format_Mono:{
for (int x = 0; x < w; ++x) {
char one_bit = *(srow + (x / 8));
if (sfmt == QImage::Format_Mono)
one_bit = one_bit >> (7 - (x % 8));
else
one_bit = one_bit >> (x % 8);
if ((one_bit & 0x01))
*(drow+x) = 0xFF000000;
else
*(drow+x) = 0xFFFFFFFF;
}
break;
}
case QImage::Format_Indexed8: {
int numColors = image.numColors();
if (numColors > 0) {
for (int x = 0; x < w; ++x) {
int index = *(srow + x);
*(drow+x) = PREMUL(image.color(qMin(index, numColors)));
}
}
} break;
case QImage::Format_RGB32:
for (int x = 0; x < w; ++x)
*(drow+x) = *(((quint32*)srow) + x) | 0xFF000000;
break;
case QImage::Format_ARGB32:
case QImage::Format_ARGB32_Premultiplied:
for (int x = 0; x < w; ++x) {
if(sfmt == QImage::Format_RGB32)
*(drow+x) = 0xFF000000 | (*(((quint32*)srow) + x) & 0x00FFFFFF);
else if(sfmt == QImage::Format_ARGB32_Premultiplied)
*(drow+x) = *(((quint32*)srow) + x);
else
*(drow+x) = PREMUL(*(((quint32*)srow) + x));
}
break;
default:
qWarning("Qt: internal: Oops: Forgot a format [%d] %s:%d", sfmt,
__FILE__, __LINE__);
break;
}
}
QPixmap QPixmap::fromWinHBITMAP(HBITMAP bitmap, HBitmapFormat format)
{
// Verify size
BITMAP bitmap_info;
memset(&bitmap_info, 0, sizeof(BITMAP));
int res = GetObject(bitmap, sizeof(BITMAP), &bitmap_info);
if (!res) {
qErrnoWarning("QPixmap::fromWinHBITMAP(), failed to get bitmap info");
return QPixmap();
}
int w = bitmap_info.bmWidth;
int h = bitmap_info.bmHeight;
BITMAPINFO bmi;
memset(&bmi, 0, sizeof(bmi));
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = w;
bmi.bmiHeader.biHeight = -h;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 32;
bmi.bmiHeader.biCompression = BI_RGB;
bmi.bmiHeader.biSizeImage = w * h * 4;
QImage result;
// Get bitmap bits
uchar *data = (uchar *) qMalloc(bmi.bmiHeader.biSizeImage);
HDC display_dc = GetDC(0);
if (GetDIBits(display_dc, bitmap, 0, h, data, &bmi, DIB_RGB_COLORS)) {
QImage::Format imageFormat = QImage::Format_ARGB32_Premultiplied;
uint mask = 0;
if (format == NoAlpha) {
imageFormat = QImage::Format_RGB32;
mask = 0xff000000;
}
// Create image and copy data into image.
QImage image(w, h, imageFormat);
if (!image.isNull()) { // failed to alloc?
int bytes_per_line = w * sizeof(QRgb);
for (int y=0; y<h; ++y) {
QRgb *dest = (QRgb *) image.scanLine(y);
const QRgb *src = (const QRgb *) (data + y * bytes_per_line);
for (int x=0; x<w; ++x) {
const uint pixel = src[x];
if ((pixel & 0xff000000) == 0 && (pixel & 0x00ffffff) != 0)
dest[x] = pixel | 0xff000000;
else
dest[x] = pixel | mask;
}
}
}
result = image;
} else {
qWarning("QPixmap::fromWinHBITMAP(), failed to get bitmap bits");
}
ReleaseDC(0, display_dc);
qFree(data);
return fromImage(result);
}
QPixmap QPixmap::fromImage(const QImage &img, Qt::ImageConversionFlags flags)
{
QPixmap pixmap;
if(img.isNull()) {
qWarning("QPixmap::convertFromImage: Cannot convert a null image");
return pixmap;
}
QImage image = img;
int d = image.depth();
int dd = defaultDepth();
bool force_mono = (dd == 1 ||
(flags & Qt::ColorMode_Mask)==Qt::MonoOnly);
if(force_mono) { // must be monochrome
if(d != 1) {
image = image.convertToFormat(QImage::Format_MonoLSB, flags); // dither
d = 1;
}
} else { // can be both
bool conv8 = false;
if(d > 8 && dd <= 8) { // convert to 8 bit
if((flags & Qt::DitherMode_Mask) == Qt::AutoDither)
flags = (flags & ~Qt::DitherMode_Mask)
| Qt::PreferDither;
conv8 = true;
} else if((flags & Qt::ColorMode_Mask) == Qt::ColorOnly) {
conv8 = d == 1; // native depth wanted
} else if(d == 1) {
if(image.numColors() == 2) {
QRgb c0 = image.color(0); // Auto: convert to best
QRgb c1 = image.color(1);
conv8 = qMin(c0,c1) != qRgb(0,0,0) || qMax(c0,c1) != qRgb(255,255,255);
} else {
// eg. 1-color monochrome images (they do exist).
conv8 = true;
}
}
if(conv8) {
image = image.convertToFormat(QImage::Format_Indexed8, flags);
d = 8;
}
}
if(image.depth()==1) {
image.setColor(0, QColor(Qt::color0).rgba());
image.setColor(1, QColor(Qt::color1).rgba());
}
if (d == 16) {
QImage im = image.convertToFormat(QImage::Format_RGB32, flags);
return fromImage(im);
}
int w = image.width();
int h = image.height();
// different size or depth, make a new pixmap
if (d == 1)
pixmap = QBitmap(w, h);
else
pixmap = QPixmap(w, h);
quint32 *dptr = pixmap.data->pixels, *drow;
const uint dbpr = pixmap.data->nbytes / h;
const QImage::Format sfmt = image.format();
const unsigned short sbpr = image.bytesPerLine();
uchar *sptr = image.bits(), *srow;
for(int y=0;y<h;y++) {
drow = dptr + (y * (dbpr / 4));
srow = sptr + (y * sbpr);
switch(sfmt) {
case QImage::Format_MonoLSB:
case QImage::Format_Mono:{
for(int x=0;x<w;++x) {
char one_bit = *(srow + (x / 8));
if(sfmt == QImage::Format_Mono)
one_bit = one_bit >> (7 - (x % 8));
else
one_bit = one_bit >> (x % 8);
if((one_bit & 0x01))
*(drow+x) = 0x00000000;
else
*(drow+x) = 0xFFFFFFFF;
}
break; }
case QImage::Format_Indexed8:
for(int x=0;x<w;++x) {
*(drow+x) = PREMUL(image.color(*(srow + x)));
}
break;
case QImage::Format_RGB32:
for(int x=0;x<w;++x)
*(drow+x) = *(((quint32*)srow) + x) | 0xFF000000;
break;
case QImage::Format_ARGB32:
case QImage::Format_ARGB32_Premultiplied:
for(int x=0;x<w;++x) {
if(sfmt == QImage::Format_RGB32)
*(drow+x) = 0xFF000000 | (*(((quint32*)srow) + x) & 0x00FFFFFF);
else if(sfmt == QImage::Format_ARGB32_Premultiplied)
*(drow+x) = *(((quint32*)srow) + x);
else
*(drow+x) = PREMUL(*(((quint32*)srow) + x));
}
break;
default:
qWarning("Qt: internal: Oops: Forgot a format [%d] %s:%d", sfmt,
__FILE__, __LINE__);
break;
}
}
void
RadialMap::Map::paint(unsigned int scaleFactor)
{
if (scaleFactor == 0) //just in case
scaleFactor = 1;
QPainter paint;
QRect rect = m_rect;
int step = m_ringBreadth;
int excess = -1;
//scale the pixmap, or do intelligent distribution of excess to prevent nasty resizing
if (scaleFactor > 1) {
int x1, y1, x2, y2;
rect.getCoords(&x1, &y1, &x2, &y2);
x1 *= scaleFactor;
y1 *= scaleFactor;
x2 *= scaleFactor;
y2 *= scaleFactor;
rect.setCoords(x1, y1, x2, y2);
step *= scaleFactor;
QPixmap::operator=(QPixmap(this->size() * (int)scaleFactor));
} else if (m_ringBreadth != MAX_RING_BREADTH && m_ringBreadth != MIN_RING_BREADTH) {
excess = rect.width() % m_ringBreadth;
++step;
}
//**** best option you can think of is to make the circles slightly less perfect,
// ** i.e. slightly eliptic when resizing inbetween
paint.begin(this);
fill(); //erase background
for (int x = m_visibleDepth; x >= 0; --x) {
int width = rect.width() / 2;
//clever geometric trick to find largest angle that will give biggest arrow head
int a_max = int(acos((double)width / double((width + 5) * scaleFactor)) * (180 * 16 / M_PI));
for (ConstIterator<Segment> it = m_signature[x].constIterator(); it != m_signature[x].end(); ++it) {
//draw the pie segments, most of this code is concerned with drawing the little
//arrows on the ends of segments when they have hidden files
paint.setPen((*it)->pen());
if ((*it)->hasHiddenChildren()) {
//draw arrow head to indicate undisplayed files/directories
QPolygon pts(3);
QPoint pos, cpos = rect.center();
int a[3] = {static_cast<int>((*it)->start()), static_cast<int>((*it)->length()), 0 };
a[2] = a[0] + (a[1] / 2); //assign to halfway between
if (a[1] > a_max) {
a[1] = a_max;
a[0] = a[2] - a_max / 2;
}
a[1] += a[0];
for (int i = 0, radius = width; i < 3; ++i) {
double ra = M_PI / (180 * 16) * a[i], sinra, cosra;
if (i == 2)
radius += 5 * scaleFactor;
#if 0
sincos(ra, &sinra, &cosra);
#endif
sinra = sin(ra); cosra = cos(ra);
pos.rx() = cpos.x() + static_cast<int>(cosra * radius);
pos.ry() = cpos.y() - static_cast<int>(sinra * radius);
pts.setPoint(i, pos);
}
paint.setBrush((*it)->pen());
paint.drawPolygon(pts);
}
paint.setBrush((*it)->brush());
paint.drawPie(rect, (*it)->start(), (*it)->length());
if ((*it)->hasHiddenChildren()) {
//**** code is bloated!
paint.save();
QPen pen = paint.pen();
int width = 2 * scaleFactor;
pen.setWidth(width);
paint.setPen(pen);
QRect rect2 = rect;
width /= 2;
rect2.adjust(width, width, -width, -width);
paint.drawArc(rect2, (*it)->start(), (*it)->length());
paint.restore();
}
}
if (excess >= 0) { //excess allows us to resize more smoothly (still crud tho)
if (excess < 2) //only decrease rect by more if even number of excesses left
--step;
excess -= 2;
}
rect.adjust(step, step, -step, -step);
}
// if( excess > 0 ) rect.adjust( excess, excess, 0, 0 ); //ugly
paint.setPen(COLOR_GREY);
paint.setBrush(Qt::white);
paint.drawEllipse(rect);
if (scaleFactor > 1) {
//have to end in order to smoothscale()
paint.end();
int x1, y1, x2, y2;
rect.getCoords(&x1, &y1, &x2, &y2);
x1 /= scaleFactor;
y1 /= scaleFactor;
x2 /= scaleFactor;
y2 /= scaleFactor;
rect.setCoords(x1, y1, x2, y2);
QImage img = this->toImage();
img = img.scaled(this->size() / (int)scaleFactor, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
this->QPixmap::operator=(fromImage(img, Qt::AutoColor));
paint.begin(this);
paint.setPen(COLOR_GREY);
paint.setBrush(Qt::white);
}
paint.drawText(rect, Qt::AlignCenter, m_centerText);
m_innerRadius = rect.width() / 2; //rect.width should be multiple of 2
paint.end();
}
LayerTileSet LayerTileSet::fromImage(const QImage &image)
{
return fromImage(image, image.size(), QPoint());
}
void QVGPixmapData::fromNativeType(void* pixmap, NativeType type)
{
if (type == QPixmapData::SgImage && pixmap) {
#if defined(QT_SYMBIAN_SUPPORTS_SGIMAGE) && !defined(QT_NO_EGL)
RSgImage *sgImage = reinterpret_cast<RSgImage*>(pixmap);
destroyImages();
prevSize = QSize();
TInt err = 0;
RSgDriver driver;
err = driver.Open();
if (err != KErrNone) {
cleanup();
return;
}
if (sgImage->IsNull()) {
cleanup();
driver.Close();
return;
}
TSgImageInfo sgImageInfo;
err = sgImage->GetInfo(sgImageInfo);
if (err != KErrNone) {
cleanup();
driver.Close();
return;
}
pfnVgCreateEGLImageTargetKHR vgCreateEGLImageTargetKHR = (pfnVgCreateEGLImageTargetKHR) eglGetProcAddress("vgCreateEGLImageTargetKHR");
if (eglGetError() != EGL_SUCCESS || !(QEgl::hasExtension("EGL_KHR_image") || QEgl::hasExtension("EGL_KHR_image_pixmap")) || !vgCreateEGLImageTargetKHR) {
cleanup();
driver.Close();
return;
}
const EGLint KEglImageAttribs[] = {EGL_IMAGE_PRESERVED_SYMBIAN, EGL_TRUE, EGL_NONE};
EGLImageKHR eglImage = QEgl::eglCreateImageKHR(QEgl::display(),
EGL_NO_CONTEXT,
EGL_NATIVE_PIXMAP_KHR,
(EGLClientBuffer)sgImage,
(EGLint*)KEglImageAttribs);
if (eglGetError() != EGL_SUCCESS) {
cleanup();
driver.Close();
return;
}
vgImage = vgCreateEGLImageTargetKHR(eglImage);
if (vgGetError() != VG_NO_ERROR) {
cleanup();
QEgl::eglDestroyImageKHR(QEgl::display(), eglImage);
driver.Close();
return;
}
w = sgImageInfo.iSizeInPixels.iWidth;
h = sgImageInfo.iSizeInPixels.iHeight;
d = 32; // We always use ARGB_Premultiplied for VG pixmaps.
is_null = (w <= 0 || h <= 0);
source = QImage();
recreate = false;
prevSize = QSize(w, h);
setSerialNumber(++qt_vg_pixmap_serial);
// release stuff
QEgl::eglDestroyImageKHR(QEgl::display(), eglImage);
driver.Close();
#endif
} else if (type == QPixmapData::FbsBitmap) {
CFbsBitmap *bitmap = reinterpret_cast<CFbsBitmap*>(pixmap);
bool deleteSourceBitmap = false;
#ifdef Q_SYMBIAN_HAS_EXTENDED_BITMAP_TYPE
// Rasterize extended bitmaps
TUid extendedBitmapType = bitmap->ExtendedBitmapType();
if (extendedBitmapType != KNullUid) {
bitmap = createBlitCopy(bitmap);
deleteSourceBitmap = true;
}
#endif
if (bitmap->IsCompressedInRAM()) {
bitmap = createBlitCopy(bitmap);
deleteSourceBitmap = true;
}
TDisplayMode displayMode = bitmap->DisplayMode();
QImage::Format format = qt_TDisplayMode2Format(displayMode);
TSize size = bitmap->SizeInPixels();
bitmap->BeginDataAccess();
uchar *bytes = (uchar*)bitmap->DataAddress();
QImage img = QImage(bytes, size.iWidth, size.iHeight, format);
img = img.copy();
bitmap->EndDataAccess();
if(displayMode == EGray2) {
//Symbian thinks set pixels are white/transparent, Qt thinks they are foreground/solid
//So invert mono bitmaps so that masks work correctly.
img.invertPixels();
} else if(displayMode == EColor16M) {
img = img.rgbSwapped(); // EColor16M is BGR
}
fromImage(img, Qt::AutoColor);
if(deleteSourceBitmap)
delete bitmap;
}
}
FFTWMatrix::FFTWMatrix(const QImage& image) : data(0), m_width(0), m_height(0)
{
(void)fromImage(image);
}
void QRasterPlatformPixmap::copy(const QPlatformPixmap *data, const QRect &rect)
{
fromImage(data->toImage(rect).copy(), Qt::NoOpaqueDetection);
}
bool Drawing::DrawingImpl::loadRoom(const char *name)
{
fromImage(name);
return true;
}
void QPlatformPixmap::fromImageReader(QImageReader *imageReader,
Qt::ImageConversionFlags flags)
{
const QImage image = imageReader->read();
fromImage(image, flags);
}
bool Drawing::DrawingImpl::loadProject(QXmlStreamReader *reader)
{
if (!reader->isStartElement()) {
return false;
}
if (reader->name().toString() != "drawing") {
return false;
}
reader->readNextStartElement();
if (reader->name().toString() != "image") {
return false;
}
reader->readNext();
fromImage(reader->text().toString().toStdString().c_str());
reader->readNext();
if (!reader->isEndElement() || reader->name().toString() != "image") {
return false;
}
reader->readNextStartElement();
std::map<int, bool> showMap;
while (true) {
if (reader->isStartElement()) {
QString name = reader->name().toString();
if (name == "algorithm") {
reader->readNext();
if (!reader->isCharacters()) {
return false;
}
if (reader->text().toString() == "Dijkstra") {
room->setAlgorithm(Room::Dijkstra);
} else if (reader->text().toString() == "A*") {
room->setAlgorithm(Room::AStar);
}
reader->readNext();
if (!reader->isEndElement() || reader->name().toString() != "algorithm") {
return false;
}
reader->readNextStartElement();
continue;
}
QXmlStreamAttributes attributes = reader->attributes();
QString showValue = attributes.value("show").toString();
bool showValueInt = showValue.toInt();
if (name == "show_triangulation") {
showMap[ShowTriangulation] = showValueInt;
} else if (name == "show_room_triangulation") {
showMap[ShowRoomTriangulation] = showValueInt;
} else if (name == "show_waypoints") {
showMap[ShowWaypoints] = showValueInt;
} else if (name == "show_path") {
showMap[ShowPath] = showValueInt;
} else if (name == "show_neighbours") {
showMap[ShowNeighbours] = showValueInt;
}
} else if (reader->isEndElement() && reader->name().toString() == "drawing") {
reader->readNextStartElement();
bool result = room->loadProject(reader);
if (result) {
for (std::map<int, bool>::const_iterator i = showMap.begin(); i != showMap.end(); i++) {
show_[i->first] = i->second;
}
}
return result;
}
reader->readNext();
if (!reader->isEndElement()) {
return false;
}
reader->readNextStartElement();
}
return false;
}