QBitmap Class Reference

#include <qbitmap.h>

Inheritance diagram for QBitmap:

[legend]Collaboration diagram for QBitmap:

[legend]List of all members.

---

Detailed Description

The QBitmap class provides monochrome (1-bit depth) pixmaps.

The QBitmap class is a monochrome off-screen paint device used mainly for creating custom QCursor and QBrush objects, constructing QRegion objects, and for setting masks for pixmaps and widgets.

QBitmap is a QPixmap subclass ensuring a depth of 1, except for null objects which have a depth of 0. If a pixmap with a depth greater than 1 is assigned to a bitmap, the bitmap will be dithered automatically.

Use the QColor objects Qt::color0 and Qt::color1 when drawing on a QBitmap object (or a QPixmap object with depth 1).

Painting with Qt::color0 sets the bitmap bits to 0, and painting with Qt::color1 sets the bits to 1. For a bitmap, 0-bits indicate background (or transparent pixels) and 1-bits indicate foreground (or opaque pixels). Use the clear() function to set all the bits to Qt::color0. Note that using the Qt::black and Qt::white colors make no sense because the QColor::pixel() value is not necessarily 0 for black and 1 for white.

The QBitmap class provides the transformed() function returning a transformed copy of the bitmap; use the QMatrix argument to translate, scale, shear, and rotate the bitmap. In addition, QBitmap provides the static fromData() function which returns a bitmap constructed from the given uchar data, and the static fromImage() function returning a converted copy of a QImage object.

Just like the QPixmap class, QBitmap is optimized by the use of implicit data sharing. For more information, see the {Implicit Data Sharing} documentation.

See also:

QPixmap, QImage, QImageReader, QImageWriter

Definition at line 35 of file qbitmap.h.

Public Member Functions
	QBitmap ()
	QBitmap (const QPixmap &)
	QBitmap (int w, int h)
	QBitmap (const QSize &)
	QBitmap (const QString &fileName, const char *format=0)
	~QBitmap ()
QBitmap &	operator= (const QPixmap &)
	operator QVariant () const
void	clear ()
QBitmap	transformed (const QMatrix &) const
Static Public Member Functions
static QBitmap	fromImage (const QImage &image, Qt::ImageConversionFlags flags=Qt::AutoColor)
static QBitmap	fromData (const QSize &size, const uchar *bits, QImage::Format monoFormat=QImage::Format_MonoLSB)

---

Constructor & Destructor Documentation

QBitmap::QBitmap

(

)

Constructs a null bitmap.

See also:

QPixmap::isNull()

Definition at line 83 of file qbitmap.cpp.

Referenced by fromImage().

    : QPixmap(QSize(0, 0), BitmapType)
{
}

QBitmap::QBitmap

(

const QPixmap &

pixmap

)

Constructs a bitmap that is a copy of the given pixmap.

If the pixmap has a depth greater than 1, the resulting bitmap will be dithered automatically.

See also:

QPixmap::depth(), fromImage(), fromData()

Definition at line 129 of file qbitmap.cpp.

References operator=().

{
    QBitmap::operator=(pixmap);
}

Here is the call graph for this function:

QBitmap::QBitmap	(	int	width,
		int	height
	)

Constructs a bitmap with the given width and height. The pixels inside are uninitialized.

See also:

clear()

Definition at line 97 of file qbitmap.cpp.

    : QPixmap(QSize(w, h), BitmapType)
{
}

QBitmap::QBitmap

(

const QSize &

size

)

[explicit]

Constructs a bitmap with the given size. The pixels in the bitmap are uninitialized.

See also:

clear()

Definition at line 109 of file qbitmap.cpp.

    : QPixmap(size, BitmapType)
{
}

QBitmap::QBitmap	(	const QString &	fileName,
		const char *	format = 0
	)			[explicit]

Constructs a bitmap from the file specified by the given fileName. If the file does not exist, or has an unknown format, the bitmap becomes a null bitmap.

The fileName and format parameters are passed on to the QPixmap::load() function. If the file format uses more than 1 bit per pixel, the resulting bitmap will be dithered automatically.

See also:

QPixmap::isNull(), QImageReader::imageFormat()

Definition at line 154 of file qbitmap.cpp.

References QPixmap::load(), and Qt::MonoOnly.

    : QPixmap(QSize(0, 0), BitmapType)
{
    load(fileName, format, Qt::MonoOnly);
}

Here is the call graph for this function:

QBitmap::~QBitmap

(

)

Destroys the bitmap.

Definition at line 204 of file qbitmap.cpp.

{
}

---

Member Function Documentation

QBitmap & QBitmap::operator=

(

const QPixmap &

pixmap

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Assigns the given pixmap to this bitmap and returns a reference to this bitmap.

If the pixmap has a depth greater than 1, the resulting bitmap will be dithered automatically.

See also:

QPixmap::depth()

Reimplemented from QPixmap.

Definition at line 172 of file qbitmap.cpp.

References QPixmap::depth(), fromImage(), image, QPixmap::isNull(), and QPixmap::toImage().

Referenced by QBitmap().

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

Here is the call graph for this function:

QBitmap::operator QVariant

(

)

const

Returns the bitmap as a QVariant.

Reimplemented from QPixmap.

Definition at line 211 of file qbitmap.cpp.

References QVariant::Bitmap.

{
    return QVariant(QVariant::Bitmap, this);
}

QBitmap::clear

(

)

[inline]

Clears the bitmap, setting all its bits to Qt::color0.

Definition at line 48 of file qbitmap.h.

References Qt::color0.

Referenced by qdesigner_internal::CursorProperty::cursorPixmap(), and QWindowsStyle::drawComplexControl().

{ fill(Qt::color0); }

QBitmap QBitmap::fromImage	(	const QImage &	image,
		Qt::ImageConversionFlags	flags = Qt::AutoColor
	)			[static]

Returns a copy of the given image converted to a bitmap using the specified image conversion flags.

See also:

fromData()

Reimplemented from QPixmap.

Definition at line 232 of file qbitmap.cpp.

References b, QImage::bits(), Qt::black, QImage::bytesPerLine(), QImage::color(), Qt::color0, Qt::color1, QImage::Format_MonoLSB, QPixmap::fromImage(), QImage::height(), image, QImage::invertPixels(), Qt::MonoOnly, p, QBitmap(), qGray(), QRgb, QImage::scanLine(), QImage::setColor(), Qt::white, QImage::width(), X11, and y.

Referenced by convert(), QPixmap::copy(), QPixmap::createHeuristicMask(), QPixmap::createMaskFromColor(), fromData(), QPixmap::load(), QPixmap::loadFromData(), QPixmap::mask(), operator=(), operator>>(), QCursor::QCursor(), QPixmap::QPixmap(), and qt_patternForAlpha().

{
    if (image.isNull())
        return QBitmap();
    QImage img = image.convertToFormat(QImage::Format_MonoLSB, flags);
#if defined (Q_WS_WIN) || defined (Q_WS_QWS)
    QBitmap bm;
    bm.data->image = img;

    // Swap colors to match so that default config draws more correctly.
    // black bits -> black pen in QPainter
    if (image.numColors() == 2 && qGray(image.color(0)) < qGray(image.color(1))) {
        QRgb color0 = image.color(0);
        QRgb color1 = image.color(1);
        bm.data->image.setColor(0, color1);
        bm.data->image.setColor(1, color0);
        bm.data->image.invertPixels();
    }
    return bm;
#elif defined(Q_WS_X11)
    QBitmap bm;
    // make sure image.color(0) == Qt::color0 (white) and image.color(1) == Qt::color1 (black)
    const QRgb c0 = QColor(Qt::black).rgb();
    const QRgb c1 = QColor(Qt::white).rgb();
    if (img.color(0) == c0 && img.color(1) == c1) {
        img.invertPixels();
        img.setColor(0, c1);
        img.setColor(1, c0);
    }

    char  *bits;
    uchar *tmp_bits;
    int w = img.width();
    int h = img.height();
    int bpl = (w+7)/8;
    int ibpl = img.bytesPerLine();
    if (bpl != ibpl) {
        tmp_bits = new uchar[bpl*h];
        bits = (char *)tmp_bits;
        uchar *p, *b;
        int y;
        b = tmp_bits;
        p = img.scanLine(0);
        for (y = 0; y < h; y++) {
            memcpy(b, p, bpl);
            b += bpl;
            p += ibpl;
        }
    } else {
        bits = (char *)img.bits();
        tmp_bits = 0;
    }
    bm.data->hd = (Qt::HANDLE)XCreateBitmapFromData(bm.data->xinfo.display(),
                                                    RootWindow(bm.data->xinfo.display(), bm.data->xinfo.screen()),
                                                    bits, w, h);

#ifndef QT_NO_XRENDER
    if (X11->use_xrender)
        bm.data->picture = XRenderCreatePicture(X11->display, bm.data->hd,
                                                XRenderFindStandardFormat(X11->display, PictStandardA1), 0, 0);
#endif // QT_NO_XRENDER

    if (tmp_bits)                                // Avoid purify complaint
        delete [] tmp_bits;
    bm.data->w = w;  bm.data->h = h;  bm.data->d = 1;

    return bm;
#else
    const QRgb c0 = QColor(Qt::black).rgb();
    const QRgb c1 = QColor(Qt::white).rgb();
    if (img.color(0) == c0 && img.color(1) == c1) {
        img.invertPixels();
        img.setColor(0, c1);
        img.setColor(1, c0);
    }
    return QBitmap(QPixmap::fromImage(img, flags|Qt::MonoOnly));
#endif
}

Here is the call graph for this function:

QBitmap QBitmap::fromData	(	const QSize &	size,
		const uchar *	bits,
		QImage::Format	monoFormat = QImage::Format_MonoLSB
	)			[static]

Constructs a bitmap with the given size, and sets the contents to the bits supplied.

The bitmap data has to be byte aligned and provided in in the bit order specified by monoFormat. The mono format must be either QImage::Format_Mono or QImage::Format_MonoLSB. Use QImage::Format_Mono to specify data on the XBM format.

See also:

fromImage()

Definition at line 323 of file qbitmap.cpp.

References Qt::color0, Qt::color1, QImage::Format_Mono, QImage::Format_MonoLSB, fromImage(), QSize::height(), image, QPixmap::size(), QSize::width(), and y.

Referenced by TrWindow::pageCurl(), and qt_pixmapForBrush().

{
    Q_ASSERT(monoFormat == QImage::Format_Mono || monoFormat == QImage::Format_MonoLSB);

    QImage image(size, monoFormat);
    image.setColor(0, Qt::color0);
    image.setColor(1, Qt::color1);

    // Need to memcpy each line separatly since QImage is 32bit aligned and
    // this data is only byte aligned...
    int bytesPerLine = (size.width() + 7) / 8;
    for (int y = 0; y < size.height(); ++y)
        memcpy(image.scanLine(y), bits + bytesPerLine * y, bytesPerLine);
    return QBitmap::fromImage(image);
}

Here is the call graph for this function:

QBitmap QBitmap::transformed

(

const QMatrix &

matrix

)

const

Returns a copy of this bitmap, transformed according to the given matrix.

See also:

QPixmap::transformed()

Definition at line 347 of file qbitmap.cpp.

References QPixmap::transformed().

{
    QBitmap bm = QPixmap::transformed(matrix);
    return bm;
}

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• src/gui/image/qbitmap.h
• src/gui/image/qbitmap.cpp

---