#include <QGuiApplication>
#include <private/qdrawhelper_p.h>
#include <private/qimage_p.h>
#include <private/qimagepixmapcleanuphooks_p.h>
#include "qxcbnativepainting.h"
#include "qpixmap_x11_p.h"
#include "qcolormap_x11_p.h"
#include "qpaintengine_x11_p.h"

Include dependency graph for qpixmap_x11.cpp:

Classes
struct	QXImageWrapper

struct	QX11AlphaDetector

Macros
#define	GET_PIXEL

#define	GET_PIXEL_DITHER_TC

#define	GET_PIXEL_DITHER_TC_OPT(red_shift, green_shift, blue_shift, red_mask, green_mask, blue_mask, rbits, gbits, bbits)

#define	CYCLE(body)

Functions
QT_BEGIN_NAMESPACE Q_ALWAYS_INLINE uint	PREMUL (uint x)

QPixmap	qt_toX11Pixmap (const QImage &image)

QPixmap	qt_toX11Pixmap (const QPixmap &pixmap)

static void	qSafeXDestroyImage (XImage *x)

Drawable	qt_x11Handle (const QPixmap &pixmap)

static int	highest_bit (uint v)

static uint	n_bits (uint v)

static void	cleanup_scale_tables ()

static void	build_scale_table (uint **table, uint nBits)

int	qt_x11SetDefaultScreen (int screen)

void	qt_x11SetScreen (QPixmap &pixmap, int screen)

Variables
static uint *	red_scale_table = nullptr

static uint *	green_scale_table = nullptr

static uint *	blue_scale_table = nullptr

static int	defaultScreen = -1

QBasicAtomicInt	qt_pixmap_serial = Q_BASIC_ATOMIC_INITIALIZER(0)

int Q_GUI_EXPORT	qt_x11_preferred_pixmap_depth = 0

Macro Definition Documentation

◆ CYCLE

#define CYCLE ( body )

Value:

        for (int y=0; y<h; y++) {                               \
            const uchar* src = cimage.scanLine(y);              \
            uchar* dst = newbits + xi->bytes_per_line*y;        \
            const QRgb* p = (const QRgb *)src;                  \
            body                                                \
                }

◆ GET_PIXEL

#define GET_PIXEL

Value:

        uint pixel;                                                     \
        if (d8) pixel = pix[*src++];                                    \
        else {                                                          \
            int r = qRed  (*p);                                         \
            int g = qGreen(*p);                                         \
            int b = qBlue (*p++);                                       \
            r = red_shift   > 0                                         \
                ? r << red_shift   : r >> -red_shift;                   \
            g = green_shift > 0                                         \
                ? g << green_shift : g >> -green_shift;                 \
            b = blue_shift  > 0                                         \
                ? b << blue_shift  : b >> -blue_shift;                  \
            pixel = (r & red_mask)|(g & green_mask) | (b & blue_mask)   \
                    | ~(blue_mask | green_mask | red_mask);             \
        }

◆ GET_PIXEL_DITHER_TC

#define GET_PIXEL_DITHER_TC

Value:

        int r = qRed  (*p);                                             \
        int g = qGreen(*p);                                             \
        int b = qBlue (*p++);                                           \
        const int thres = D[x%16][y%16];                                \
        if (r <= (255-(1<<(8-rbits))) && ((r<<rbits) & 255)             \
            > thres)                                                    \
            r += (1<<(8-rbits));                                        \
        if (g <= (255-(1<<(8-gbits))) && ((g<<gbits) & 255)             \
            > thres)                                                    \
            g += (1<<(8-gbits));                                        \
        if (b <= (255-(1<<(8-bbits))) && ((b<<bbits) & 255)             \
            > thres)                                                    \
            b += (1<<(8-bbits));                                        \
        r = red_shift   > 0                                             \
            ? r << red_shift   : r >> -red_shift;                       \
        g = green_shift > 0                                             \
            ? g << green_shift : g >> -green_shift;                     \
        b = blue_shift  > 0                                             \
            ? b << blue_shift  : b >> -blue_shift;                      \
        uint pixel = (r & red_mask)|(g & green_mask) | (b & blue_mask);

◆ GET_PIXEL_DITHER_TC_OPT

#define GET_PIXEL_DITHER_TC_OPT	(	red_shift,
		green_shift,
		blue_shift,
		red_mask,
		green_mask,
		blue_mask,
		rbits,
		gbits,
		bbits
	)

Value:

        const int thres = D[x%16][y%16];                                \
        int r = qRed  (*p);                                             \
        if (r <= (255-(1<<(8-rbits))) && ((r<<rbits) & 255)             \
            > thres)                                                    \
            r += (1<<(8-rbits));                                        \
        int g = qGreen(*p);                                             \
        if (g <= (255-(1<<(8-gbits))) && ((g<<gbits) & 255)             \
            > thres)                                                    \
            g += (1<<(8-gbits));                                        \
        int b = qBlue (*p++);                                           \
        if (b <= (255-(1<<(8-bbits))) && ((b<<bbits) & 255)             \
            > thres)                                                    \
            b += (1<<(8-bbits));                                        \
        uint pixel = ((r red_shift) & red_mask)                         \
                     | ((g green_shift) & green_mask)                   \
                     | ((b blue_shift) & blue_mask);