qxpmhandler.cpp File Reference

#include "private/qxpmhandler_p.h"
#include <private/qcolor_p.h>
#include <qimage.h>
#include <qmap.h>
#include <qtextstream.h>
#include <qvariant.h>

Go to the source code of this file.

Classes
struct	XPMRGBData

Macros
#define	QRGB(r, g, b)   (r*65536 + g*256 + b)

Functions
static QString	fbname (const QString &fileName)
static bool	is_xpm_color_spec_prefix (const QByteArray &prefix)
bool	operator< (const char *name, const XPMRGBData &data)
bool	operator< (const XPMRGBData &data, const char *name)
static bool	qt_get_named_xpm_rgb (const char *name_no_space, QRgb *rgb)
bool	qt_read_xpm_image_or_array (QIODevice *device, const char *const *source, QImage &image)
static bool	read_xpm_body (QIODevice *device, const char *const *source, int &index, QByteArray &state, int cpp, int ncols, int w, int h, QImage &image)
static bool	read_xpm_header (QIODevice *device, const char *const *source, int &index, QByteArray &state, int *cpp, int *ncols, int *w, int *h)
static bool	read_xpm_string (QByteArray &buf, QIODevice *d, const char *const *source, int &index, QByteArray &state)
static bool	write_xpm_image (const QImage &sourceImage, QIODevice *device, const QString &fileName)
static const char *	xpm_color_name (int cpp, int index)
static quint64	xpmHash (const QString &str)
static quint64	xpmHash (char *str)

Variables
static const struct XPMRGBData	xpmRgbTbl []
static const int	xpmRgbTblSize = 657

Macro Definition Documentation

QRGB

#define QRGB	(		r,
			g,
			b
	)		(r*65536 + g*256 + b)

Definition at line 82 of file qxpmhandler.cpp.

Function Documentation

fbname()

static QString fbname ( const QString &  fileName )

static

Definition at line 767 of file qxpmhandler.cpp.

Referenced by write_xpm_image().

{
    QString s = fileName;
    if (!s.isEmpty()) {
        int i;
        if ((i = s.lastIndexOf(QLatin1Char('/'))) >= 0)
            s = s.mid(i);
        if ((i = s.lastIndexOf(QLatin1Char('\\'))) >= 0)
            s = s.mid(i);
        QRegExp r(QLatin1String("[a-zA-Z][a-zA-Z0-9_]*"));
        int p = r.indexIn(s);
        if (p == -1)
            s.clear();
        else
            s = s.mid(p, r.matchedLength());
    }
    if (s.isEmpty())
        s = QString::fromLatin1("dummy");
    return s;
}

is_xpm_color_spec_prefix()

static bool is_xpm_color_spec_prefix ( const QByteArray &  prefix )

static

Definition at line 828 of file qxpmhandler.cpp.

Referenced by read_xpm_body().

{
    return prefix == "c" ||
           prefix == "g" ||
           prefix == "g4" ||
           prefix == "m" ||
           prefix == "s";
}

operator<() [1/2]

bool operator< ( const char *  name, const XPMRGBData &  data  )

inline

Definition at line 748 of file qxpmhandler.cpp.

{ return qstrcmp(name, data.name) < 0; }

operator<() [2/2]

bool operator< ( const XPMRGBData &  data, const char *  name  )

inline

Definition at line 750 of file qxpmhandler.cpp.

{ return qstrcmp(data.name, name) < 0; }

qt_get_named_xpm_rgb()

static bool qt_get_named_xpm_rgb ( const char *  name_no_space, QRgb *  rgb  )

inlinestatic

Definition at line 753 of file qxpmhandler.cpp.

Referenced by read_xpm_body().

{
    const XPMRGBData *r = qBinaryFind(xpmRgbTbl, xpmRgbTbl + xpmRgbTblSize, name_no_space);
    if (r != xpmRgbTbl + xpmRgbTblSize) {
        *rgb = r->value;
        return true;
    } else {
        return false;
    }
}

qt_read_xpm_image_or_array()

bool qt_read_xpm_image_or_array	(	QIODevice *	device,
		const char *const *	source,
		QImage &	image
	)

Definition at line 1025 of file qxpmhandler.cpp.

Referenced by QImage::QImage().

{
    if (!source)
        return true;

    QByteArray buf(200, 0);
    QByteArray state;

    int cpp, ncols, w, h, index = 0;

    if (device) {
        // "/* XPM */"
        int readBytes;
        if ((readBytes = device->readLine(buf.data(), buf.size())) < 0)
            return false;

        if (buf.indexOf("/* XPM") != 0) {
            while (readBytes > 0) {
                device->ungetChar(buf.at(readBytes - 1));
                --readBytes;
            }
            return false;
        }// bad magic
    }

    if (!read_xpm_header(device, source, index, state, &cpp, &ncols, &w, &h))
        return false;

    return read_xpm_body(device, source, index, state, cpp, ncols, w, h, image);
}

read_xpm_body()

static bool read_xpm_body ( QIODevice *  device, const char *const *  source, int &  index, QByteArray &  state, int  cpp, int  ncols, int  w, int  h, QImage &  image  )

static

Definition at line 860 of file qxpmhandler.cpp.

Referenced by qt_read_xpm_image_or_array(), and QXpmHandler::readImage().

{
    QByteArray buf(200, 0);
    int i;

    if (cpp < 0 || cpp > 15)
        return false;

    // For > 256 colors, we delay creation of the image until
    // after we have read the color specifications, so that we can
    // create it in correct format (Format_RGB32 vs Format_ARGB32,
    // depending on absence or presence of "c none", respectively)
    if (ncols <= 256) {
        if (image.size() != QSize(w, h) || image.format() != QImage::Format_Indexed8) {
            image = QImage(w, h, QImage::Format_Indexed8);
            if (image.isNull())
                return false;
        }
        image.setColorCount(ncols);
    }

    QMap<quint64, int> colorMap;
    int currentColor;
    bool hasTransparency = false;

    for(currentColor=0; currentColor < ncols; ++currentColor) {
        if (!read_xpm_string(buf, device, source, index, state)) {
            qWarning("QImage: XPM color specification missing");
            return false;
        }
        QByteArray index;
        index = buf.left(cpp);
        buf = buf.mid(cpp).simplified().trimmed().toLower();
        QList<QByteArray> tokens = buf.split(' ');
        i = tokens.indexOf("c");
        if (i < 0)
            i = tokens.indexOf("g");
        if (i < 0)
            i = tokens.indexOf("g4");
        if (i < 0)
            i = tokens.indexOf("m");
        if (i < 0) {
            qWarning("QImage: XPM color specification is missing: %s", buf.constData());
            return false;        // no c/g/g4/m specification at all
        }
        QByteArray color;
        while ((++i < tokens.size()) && !is_xpm_color_spec_prefix(tokens.at(i))) {
            color.append(tokens.at(i));
        }
        if (color.isEmpty()) {
            qWarning("QImage: XPM color value is missing from specification: %s", buf.constData());
            return false;        // no color value
        }
        buf = color;
        if (buf == "none") {
            hasTransparency = true;
            int transparentColor = currentColor;
            if (ncols <= 256) {
                image.setColor(transparentColor, 0);
                colorMap.insert(xpmHash(QLatin1String(index.constData())), transparentColor);
            } else {
                colorMap.insert(xpmHash(QLatin1String(index.constData())), 0);
            }
        } else {
            QRgb c_rgb;
            if (((buf.length()-1) % 3) && (buf[0] == '#')) {
                buf.truncate(((buf.length()-1) / 4 * 3) + 1); // remove alpha channel left by imagemagick
            }
            if (buf[0] == '#') {
                qt_get_hex_rgb(buf, &c_rgb);
            } else {
                qt_get_named_xpm_rgb(buf, &c_rgb);
            }
            if (ncols <= 256) {
                image.setColor(currentColor, 0xff000000 | c_rgb);
                colorMap.insert(xpmHash(QLatin1String(index.constData())), currentColor);
            } else {
                colorMap.insert(xpmHash(QLatin1String(index.constData())), 0xff000000 | c_rgb);
            }
        }
    }

    if (ncols > 256) {
        // Now we can create 32-bit image of appropriate format
        QImage::Format format = hasTransparency ?
                                QImage::Format_ARGB32 : QImage::Format_RGB32;
        if (image.size() != QSize(w, h) || image.format() != format) {
            image = QImage(w, h, format);
            if (image.isNull())
                return false;
        }
    }

    // Read pixels
    for(int y=0; y<h; y++) {
        if (!read_xpm_string(buf, device, source, index, state)) {
            qWarning("QImage: XPM pixels missing on image line %d", y);
            return false;
        }
        if (image.depth() == 8) {
            uchar *p = image.scanLine(y);
            uchar *d = (uchar *)buf.data();
            uchar *end = d + buf.length();
            int x;
            if (cpp == 1) {
                char b[2];
                b[1] = '\0';
                for (x=0; x<w && d<end; x++) {
                    b[0] = *d++;
                    *p++ = (uchar)colorMap[xpmHash(b)];
                }
            } else {
                char b[16];
                b[cpp] = '\0';
                for (x=0; x<w && d<end; x++) {
                    memcpy(b, (char *)d, cpp);
                    *p++ = (uchar)colorMap[xpmHash(b)];
                    d += cpp;
                }
            }
            // avoid uninitialized memory for malformed xpms
            if (x < w) {
                qWarning("QImage: XPM pixels missing on image line %d (possibly a C++ trigraph).", y);
                memset(p, 0, w - x);
            }
        } else {
            QRgb *p = (QRgb*)image.scanLine(y);
            uchar *d = (uchar *)buf.data();
            uchar *end = d + buf.length();
            int x;
            char b[16];
            b[cpp] = '\0';
            for (x=0; x<w && d<end; x++) {
                memcpy(b, (char *)d, cpp);
                *p++ = (QRgb)colorMap[xpmHash(b)];
                d += cpp;
            }
            // avoid uninitialized memory for malformed xpms
            if (x < w) {
                qWarning("QImage: XPM pixels missing on image line %d (possibly a C++ trigraph).", y);
                memset(p, 0, (w - x)*4);
            }
        }
    }

    if (device) {
        // Rewind unused characters, and skip to the end of the XPM struct.
        for (int i = state.size() - 1; i >= 0; --i)
            device->ungetChar(state[i]);
        char c;
        while (device->getChar(&c) && c != ';') {}
        while (device->getChar(&c) && c != '\n') {}
    }
    return true;
}

read_xpm_header()

static bool read_xpm_header ( QIODevice *  device, const char *const *  source, int &  index, QByteArray &  state, int *  cpp, int *  ncols, int *  w, int *  h  )

static

Definition at line 839 of file qxpmhandler.cpp.

Referenced by qt_read_xpm_image_or_array(), and QXpmHandler::readHeader().

{
    QByteArray buf(200, 0);

    if (!read_xpm_string(buf, device, source, index, state))
        return false;

#if defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(Q_OS_WINCE)
        if (sscanf_s(buf, "%d %d %d %d", w, h, ncols, cpp) < 4)
#else
    if (sscanf(buf, "%d %d %d %d", w, h, ncols, cpp) < 4)
#endif
        return false;                                        // < 4 numbers parsed

    return true;
}

read_xpm_string()

static bool read_xpm_string ( QByteArray &  buf, QIODevice *  d, const char *const *  source, int &  index, QByteArray &  state  )

static

Definition at line 791 of file qxpmhandler.cpp.

Referenced by read_xpm_body(), and read_xpm_header().

{
    if (source) {
        buf = source[index++];
        return true;
    }

    buf = "";
    bool gotQuote = false;
    int offset = 0;
    forever {
        if (offset == state.size() || state.isEmpty()) {
            char buf[2048];
            qint64 bytesRead = d->read(buf, sizeof(buf));
            if (bytesRead <= 0)
                return false;
            state = QByteArray(buf, int(bytesRead));
            offset = 0;
        }

        if (!gotQuote) {
            if (state.at(offset++) == '"')
                gotQuote = true;
        } else {
            char c = state.at(offset++);
            if (c == '"')
                break;
            buf += c;
        }
    }
    state.remove(0, offset);
    return true;
}

write_xpm_image()

static bool write_xpm_image ( const QImage &  sourceImage, QIODevice *  device, const QString &  fileName  )

static

Definition at line 1089 of file qxpmhandler.cpp.

Referenced by QXpmHandler::write().

{
    if (!device->isWritable())
        return false;

    QImage image;
    if (sourceImage.depth() != 32)
        image = sourceImage.convertToFormat(QImage::Format_RGB32);
    else
        image = sourceImage;

    QMap<QRgb, int> colorMap;

    int w = image.width(), h = image.height(), ncolors = 0;
    int x, y;

    // build color table
    for(y=0; y<h; y++) {
        QRgb * yp = (QRgb *)image.scanLine(y);
        for(x=0; x<w; x++) {
            QRgb color = *(yp + x);
            if (!colorMap.contains(color))
                colorMap.insert(color, ncolors++);
        }
    }

    // number of 64-bit characters per pixel needed to encode all colors
    int cpp = 1;
    for (int k = 64; ncolors > k; k *= 64) {
        ++cpp;
        // limit to 4 characters per pixel
        // 64^4 colors is enough for a 4096x4096 image
         if (cpp > 4)
            break;
    }

    QString line;

    // write header
    QTextStream s(device);
    s << "/* XPM */" << endl
      << "static char *" << fbname(fileName) << "[]={" << endl
      << '\"' << w << ' ' << h << ' ' << ncolors << ' ' << cpp << '\"';

    // write palette
    QMap<QRgb, int>::Iterator c = colorMap.begin();
    while (c != colorMap.end()) {
        QRgb color = c.key();
        if (image.format() != QImage::Format_RGB32 && !qAlpha(color))
            line.sprintf("\"%s c None\"",
                          xpm_color_name(cpp, *c));
        else
            line.sprintf("\"%s c #%02x%02x%02x\"",
                          xpm_color_name(cpp, *c),
                          qRed(color),
                          qGreen(color),
                          qBlue(color));
        ++c;
        s << ',' << endl << line;
    }

    // write pixels, limit to 4 characters per pixel
    line.truncate(cpp*w);
    for(y=0; y<h; y++) {
        QRgb * yp = (QRgb *) image.scanLine(y);
        int cc = 0;
        for(x=0; x<w; x++) {
            int color = (int)(*(yp + x));
            QByteArray chars(xpm_color_name(cpp, colorMap[color]));
            line[cc++] = QLatin1Char(chars[0]);
            if (cpp > 1) {
                line[cc++] = QLatin1Char(chars[1]);
                if (cpp > 2) {
                    line[cc++] = QLatin1Char(chars[2]);
                    if (cpp > 3) {
                        line[cc++] = QLatin1Char(chars[3]);
                    }
                }
            }
        }
        s << ',' << endl << '\"' << line << '\"';
    }
    s << "};" << endl;
    return (s.status() == QTextStream::Ok);
}

xpm_color_name()

static const char* xpm_color_name ( int  cpp, int  index  )

static

Definition at line 1056 of file qxpmhandler.cpp.

Referenced by write_xpm_image().

{
    static char returnable[5];
    static const char code[] = ".#abcdefghijklmnopqrstuvwxyzABCD"
                               "EFGHIJKLMNOPQRSTUVWXYZ0123456789";
    // cpp is limited to 4 and index is limited to 64^cpp
    if (cpp > 1) {
        if (cpp > 2) {
            if (cpp > 3) {
                returnable[3] = code[index % 64];
                index /= 64;
            } else
                returnable[3] = '\0';
            returnable[2] = code[index % 64];
            index /= 64;
        } else
            returnable[2] = '\0';
        // the following 4 lines are a joke!
        if (index == 0)
            index = 64*44+21;
        else if (index == 64*44+21)
            index = 0;
        returnable[1] = code[index % 64];
        index /= 64;
    } else
        returnable[1] = '\0';
    returnable[0] = code[index];

    return returnable;
}

xpmHash() [1/2]

static quint64 xpmHash ( const QString &  str )

static

Definition at line 59 of file qxpmhandler.cpp.

Referenced by read_xpm_body().

{
    unsigned int hashValue = 0;
    for (int i = 0; i < str.size(); ++i) {
        hashValue <<= 8;
        hashValue += (unsigned int)str.at(i).unicode();
    }
    return hashValue;
}

xpmHash() [2/2]

static quint64 xpmHash ( char *  str )

static

Definition at line 68 of file qxpmhandler.cpp.

{
    unsigned int hashValue = 0;
    while (*str != '\0') {
        hashValue <<= 8;
        hashValue += (unsigned int)*str;
        ++str;
    }
    return hashValue;
}

Variable Documentation

xpmRgbTbl

const struct XPMRGBData xpmRgbTbl[]

static

Referenced by qt_get_named_xpm_rgb().

xpmRgbTblSize

const int xpmRgbTblSize = 657

static

Definition at line 84 of file qxpmhandler.cpp.

Referenced by qt_get_named_xpm_rgb().