You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2067 lines
66 KiB
2067 lines
66 KiB
/****************************************************************************
|
|
**
|
|
** Implementation of TQt3CairoPaintDevice class
|
|
**
|
|
** Copyright (C) 2012 Timothy Pearson. All rights reserved.
|
|
**
|
|
** This file is part of the TDE GTK3 style interface
|
|
**
|
|
** This file may be used under the terms of the GNU General
|
|
** Public License versions 2.0 or 3.0 as published by the Free
|
|
** Software Foundation and appearing in the files LICENSE.GPL2
|
|
** and LICENSE.GPL3 included in the packaging of this file.
|
|
**
|
|
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
|
|
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
|
|
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
|
|
** herein.
|
|
**
|
|
**********************************************************************/
|
|
|
|
// If USE_TDE_SPECIFIC_LIBRARIES is set, the painter will use certain TDE libraries
|
|
// to increase painting performance. If this dependency is not desired and you can
|
|
// live with the corresponding performance loss, comment out the following line:
|
|
#define USE_TDE_SPECIFIC_LIBRARIES 1
|
|
|
|
#include "tqtcairopainter.h"
|
|
|
|
#define TQT_NO_COMPAT_NAMES
|
|
#include "tqpainter.h"
|
|
#include "tqpixmap.h"
|
|
#include "tqbitmap.h"
|
|
#include "tqimage.h"
|
|
#include "tqfile.h"
|
|
#include "tqpaintdevicemetrics.h"
|
|
|
|
#ifdef USE_TDE_SPECIFIC_LIBRARIES
|
|
#include <kpixmapio.h>
|
|
#endif // USE_TDE_SPECIFIC_LIBRARIES
|
|
|
|
#undef Qt
|
|
|
|
#define CAIRO_PEN_PIXEL_OFFSET (0.5)
|
|
#define CAIRO_BRUSH_PIXEL_OFFSET (0.0)
|
|
#define CAIRO_FONT_SIZE_FUDGE_FACTOR (1.4)
|
|
|
|
#define SET_BIT(x, y) (x |= 1 << y)
|
|
#define TEST_BIT(x, y) ((x & (1 << y)) >> y)
|
|
|
|
// SLOW BUT VERIFIED CORRECT
|
|
//#define FASTEST_AVAILABLE_PAINTER (m_painter)
|
|
// FAST BUT EXPERIMENTAL AND UNVERIFIED
|
|
#define FASTEST_AVAILABLE_PAINTER (intermediateSurfaceInUse()?m_painter:m_devicePainter)
|
|
|
|
// Little endian
|
|
#define ARGB_A_BYTE_NUMBER 3
|
|
#define ARGB_R_BYTE_NUMBER 2
|
|
#define ARGB_G_BYTE_NUMBER 1
|
|
#define ARGB_B_BYTE_NUMBER 0
|
|
|
|
inline int cairoPainterRectSubtraction(TQPen* pen) {
|
|
return ((pen->style() != TQt::NoPen) && ((pen->width() == 0) || (pen->width() == 1))) ? 1 : 0;
|
|
}
|
|
|
|
inline void standardAlphaToPremultipliedAlpha(unsigned char *a, unsigned char *r, unsigned char *g, unsigned char *b) {
|
|
register double alpha_adjust;
|
|
|
|
alpha_adjust = (*a / 255.0);
|
|
*r = char( *r * alpha_adjust );
|
|
*g = char( *g * alpha_adjust );
|
|
*b = char( *b * alpha_adjust );
|
|
*a = char( *a * 1.0 );
|
|
}
|
|
|
|
inline void premultipliedAlphaToStandardAlpha(unsigned char *a, unsigned char *r, unsigned char *g, unsigned char *b) {
|
|
register double alpha_adjust;
|
|
|
|
alpha_adjust = (*a / 255.0);
|
|
*r = char( *r / alpha_adjust );
|
|
*g = char( *g / alpha_adjust );
|
|
*b = char( *b / alpha_adjust );
|
|
*a = char( *a / 1.0 );
|
|
}
|
|
|
|
cairo_surface_t* TQImageToCairoSurface(TQImage origimg) {
|
|
cairo_surface_t* ret;
|
|
|
|
TQImage img;
|
|
if (origimg.depth() < 24) {
|
|
img = origimg.convertDepth(32);
|
|
}
|
|
else {
|
|
img = origimg;
|
|
}
|
|
|
|
int depth = img.depth();
|
|
if (depth == 32) {
|
|
// Convert ARGB to premultiplied ARGB
|
|
// SLOW
|
|
int x;
|
|
int y;
|
|
for (x=0; x<img.width(); x++) {
|
|
for (y=0; y<img.height(); y++) {
|
|
unsigned int pixel = img.pixel(x, y);
|
|
unsigned char a = (pixel & 0xff000000) >> 24;
|
|
unsigned char r = (pixel & 0x00ff0000) >> 16;
|
|
unsigned char g = (pixel & 0x0000ff00) >> 8;
|
|
unsigned char b = (pixel & 0x000000ff) >> 0;
|
|
standardAlphaToPremultipliedAlpha(&a, &r, &g, &b);
|
|
pixel = (a << 24) | (r << 16) | (g << 8) | (b << 0);
|
|
img.setPixel(x, y, pixel);
|
|
}
|
|
}
|
|
}
|
|
|
|
cairo_format_t cairo_format;
|
|
if (depth == 32) {
|
|
cairo_format = CAIRO_FORMAT_ARGB32;
|
|
}
|
|
else if (depth == 24) {
|
|
cairo_format = CAIRO_FORMAT_RGB24;
|
|
}
|
|
else {
|
|
cairo_format = CAIRO_FORMAT_RGB24;
|
|
}
|
|
|
|
int stride = cairo_format_stride_for_width(cairo_format, img.width());
|
|
ret = cairo_image_surface_create_for_data(img.bits(), cairo_format, img.width(), img.height(), stride);
|
|
|
|
return ret;
|
|
}
|
|
|
|
TQImage CairoSurfaceToTQImage(cairo_surface_t* surface) {
|
|
cairo_surface_flush(surface);
|
|
|
|
cairo_format_t cairo_format = cairo_image_surface_get_format(surface);
|
|
int height = cairo_image_surface_get_height(surface);
|
|
int width = cairo_image_surface_get_width(surface);
|
|
int depth;
|
|
if (cairo_format == CAIRO_FORMAT_ARGB32) {
|
|
depth = 32;
|
|
}
|
|
else if (cairo_format == CAIRO_FORMAT_RGB24) {
|
|
depth = 24;
|
|
}
|
|
else {
|
|
// FIXME
|
|
// Force Cairo to convert the surface to a format that TQImage can read!
|
|
printf("[WARNING] Tried to convert a Cairo surface of format %d to a TQImage (NULL image returned!)\n\r", cairo_format); fflush(stdout);
|
|
return TQImage();
|
|
}
|
|
|
|
return TQImage(cairo_image_surface_get_data(surface), width, height, depth, (TQRgb*)NULL, 0, TQImage::BigEndian);
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::resetIntermediateSurface() {
|
|
if (m_intermediateSurface) {
|
|
cairo_surface_destroy(m_intermediateSurface);
|
|
}
|
|
|
|
updateSurfaceDimensions();
|
|
int height = m_height;
|
|
int width = m_width;
|
|
m_intermediateSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
|
|
}
|
|
|
|
// FIXME
|
|
// transferIntermediateSurface should only be used when clipping is active or ROP != CopyROP
|
|
// Cairo however does not allow the target surface of a context to be switched, effectively preventing
|
|
// direct drawing with dynamic switching to and from the intermediate surface on clip or ROP set/unset
|
|
// See upstream Cairo bug report https://bugs.freedesktop.org/show_bug.cgi?id=57289
|
|
// NOTE
|
|
// This has been worked around by applying the same transformations, saves, and restores to both the device and intermediate surface contexts
|
|
// If there is not much performance penalty from doing so, this method should probably be left alone
|
|
void TQt3CairoPaintDevice::transferIntermediateSurface() {
|
|
bool overlayMerge = true;
|
|
cairo_surface_flush(m_intermediateSurface);
|
|
|
|
if (m_rop != TQPainter::CopyROP) {
|
|
overlayMerge = false;
|
|
cairo_surface_flush(m_surface);
|
|
cairo_surface_flush(m_intermediateSurface);
|
|
updateSurfaceDimensions();
|
|
register int height = m_height;
|
|
register int width = m_width;
|
|
register int stride = cairo_format_stride_for_width(cairo_image_surface_get_format(m_surface), width);
|
|
cairo_surface_t *usableDeviceSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
|
|
cairo_t *copyPainter = cairo_create(usableDeviceSurface);
|
|
cairo_set_source_surface(copyPainter, m_surface, 0, 0);
|
|
cairo_set_operator(copyPainter, CAIRO_OPERATOR_SOURCE);
|
|
cairo_paint(copyPainter);
|
|
cairo_surface_flush(usableDeviceSurface);
|
|
cairo_destroy(copyPainter);
|
|
unsigned char* device_surface_data = cairo_image_surface_get_data(usableDeviceSurface);
|
|
unsigned char* intermediate_surface_data = cairo_image_surface_get_data(m_intermediateSurface);
|
|
register int x;
|
|
register int y;
|
|
register long long offset;
|
|
register unsigned char devicePixel_a;
|
|
register unsigned char devicePixel_r;
|
|
register unsigned char devicePixel_g;
|
|
register unsigned char devicePixel_b;
|
|
register unsigned char intermediatePixel_a;
|
|
register unsigned char intermediatePixel_r;
|
|
register unsigned char intermediatePixel_g;
|
|
register unsigned char intermediatePixel_b;
|
|
register unsigned char combinedPixel_a;
|
|
register unsigned char combinedPixel_r;
|
|
register unsigned char combinedPixel_g;
|
|
register unsigned char combinedPixel_b;
|
|
// Execute the desired raster operation
|
|
// WARNING
|
|
// This is VERY SLOW
|
|
for (y=0; y<height; y++) {
|
|
for (x=0; x<stride; x=x+4) {
|
|
offset = (y*stride)+x;
|
|
|
|
// Convert from premultiplied ARGB
|
|
premultipliedAlphaToStandardAlpha(intermediate_surface_data+offset+ARGB_A_BYTE_NUMBER, intermediate_surface_data+offset+ARGB_R_BYTE_NUMBER, intermediate_surface_data+offset+ARGB_G_BYTE_NUMBER, intermediate_surface_data+offset+ARGB_B_BYTE_NUMBER);
|
|
intermediatePixel_a = (*(intermediate_surface_data+offset+ARGB_A_BYTE_NUMBER));
|
|
intermediatePixel_r = (*(intermediate_surface_data+offset+ARGB_R_BYTE_NUMBER));
|
|
intermediatePixel_g = (*(intermediate_surface_data+offset+ARGB_G_BYTE_NUMBER));
|
|
intermediatePixel_b = (*(intermediate_surface_data+offset+ARGB_B_BYTE_NUMBER));
|
|
if (intermediatePixel_a != 0) {
|
|
// Alpha channel of intermediate pixel was set; gather data for bitwise operation
|
|
premultipliedAlphaToStandardAlpha(device_surface_data+offset+ARGB_A_BYTE_NUMBER, device_surface_data+offset+ARGB_R_BYTE_NUMBER, device_surface_data+offset+ARGB_G_BYTE_NUMBER, device_surface_data+offset+ARGB_B_BYTE_NUMBER);
|
|
devicePixel_a = (*(device_surface_data+offset+ARGB_A_BYTE_NUMBER));
|
|
devicePixel_r = (*(device_surface_data+offset+ARGB_R_BYTE_NUMBER));
|
|
devicePixel_g = (*(device_surface_data+offset+ARGB_G_BYTE_NUMBER));
|
|
devicePixel_b = (*(device_surface_data+offset+ARGB_B_BYTE_NUMBER));
|
|
|
|
// Perform requested bitwise operation
|
|
if (m_rop == TQPainter::OrROP) {
|
|
combinedPixel_a = ((devicePixel_a != 0) || (intermediatePixel_a != 0))?0xff:0x00;
|
|
combinedPixel_r = devicePixel_r | intermediatePixel_r;
|
|
combinedPixel_g = devicePixel_g | intermediatePixel_g;
|
|
combinedPixel_b = devicePixel_b | intermediatePixel_b;
|
|
}
|
|
else if (m_rop == TQPainter::XorROP) {
|
|
combinedPixel_a = ((devicePixel_a != 0) || (intermediatePixel_a != 0))?0xff:0x00;
|
|
combinedPixel_r = devicePixel_r ^ intermediatePixel_r;
|
|
combinedPixel_g = devicePixel_g ^ intermediatePixel_g;
|
|
combinedPixel_b = devicePixel_b ^ intermediatePixel_b;
|
|
}
|
|
else if (m_rop == TQPainter::NotAndROP) {
|
|
combinedPixel_a = ((devicePixel_a != 0) || (intermediatePixel_a != 0))?0xff:0x00;
|
|
combinedPixel_r = devicePixel_r & (~intermediatePixel_r);
|
|
combinedPixel_g = devicePixel_g & (~intermediatePixel_g);
|
|
combinedPixel_b = devicePixel_b & (~intermediatePixel_b);
|
|
}
|
|
else if (m_rop == TQPainter::NotCopyROP) {
|
|
combinedPixel_a = intermediatePixel_a;
|
|
combinedPixel_r = ~intermediatePixel_r;
|
|
combinedPixel_g = ~intermediatePixel_g;
|
|
combinedPixel_b = ~intermediatePixel_b;
|
|
}
|
|
else if (m_rop == TQPainter::NotOrROP) {
|
|
combinedPixel_a = ((devicePixel_a != 0) || (intermediatePixel_a != 0))?0xff:0x00;
|
|
combinedPixel_r = devicePixel_r | (~intermediatePixel_r);
|
|
combinedPixel_g = devicePixel_g | (~intermediatePixel_g);
|
|
combinedPixel_b = devicePixel_b | (~intermediatePixel_b);
|
|
}
|
|
else if (m_rop == TQPainter::NotXorROP) {
|
|
combinedPixel_a = ((devicePixel_a != 0) || (intermediatePixel_a != 0))?0xff:0x00;
|
|
combinedPixel_r = devicePixel_r ^ (~intermediatePixel_r);
|
|
combinedPixel_g = devicePixel_g ^ (~intermediatePixel_g);
|
|
combinedPixel_b = devicePixel_b ^ (~intermediatePixel_b);
|
|
}
|
|
else if (m_rop == TQPainter::AndROP) {
|
|
combinedPixel_a = ((devicePixel_a != 0) || (intermediatePixel_a != 0))?0xff:0x00;
|
|
combinedPixel_r = devicePixel_r & intermediatePixel_r;
|
|
combinedPixel_g = devicePixel_g & intermediatePixel_g;
|
|
combinedPixel_b = devicePixel_b & intermediatePixel_b;
|
|
}
|
|
else if (m_rop == TQPainter::NotROP) {
|
|
combinedPixel_a = ((devicePixel_a != 0) || (intermediatePixel_a != 0))?0xff:0x00;
|
|
combinedPixel_r = ~devicePixel_r;
|
|
combinedPixel_g = ~devicePixel_g;
|
|
combinedPixel_b = ~devicePixel_b;
|
|
}
|
|
else if (m_rop == TQPainter::ClearROP) {
|
|
combinedPixel_a = 0x0;
|
|
combinedPixel_r = 0x0;
|
|
combinedPixel_g = 0x0;
|
|
combinedPixel_b = 0x0;
|
|
}
|
|
else if (m_rop == TQPainter::SetROP) {
|
|
combinedPixel_a = 0xff;
|
|
combinedPixel_r = 0xff;
|
|
combinedPixel_g = 0xff;
|
|
combinedPixel_b = 0xff;
|
|
}
|
|
else if (m_rop == TQPainter::NopROP) {
|
|
combinedPixel_a = ((devicePixel_a != 0) || (intermediatePixel_a != 0))?0xff:0x00;
|
|
combinedPixel_r = devicePixel_r;
|
|
combinedPixel_g = devicePixel_g;
|
|
combinedPixel_b = devicePixel_b;
|
|
}
|
|
else if (m_rop == TQPainter::AndNotROP) {
|
|
combinedPixel_a = ((devicePixel_a != 0) || (intermediatePixel_a != 0))?0xff:0x00;
|
|
combinedPixel_r = (~devicePixel_r) & intermediatePixel_r;
|
|
combinedPixel_g = (~devicePixel_g) & intermediatePixel_g;
|
|
combinedPixel_b = (~devicePixel_b) & intermediatePixel_b;
|
|
}
|
|
else if (m_rop == TQPainter::OrNotROP) {
|
|
combinedPixel_a = ((devicePixel_a != 0) || (intermediatePixel_a != 0))?0xff:0x00;
|
|
combinedPixel_r = (~devicePixel_r) | intermediatePixel_r;
|
|
combinedPixel_g = (~devicePixel_g) | intermediatePixel_g;
|
|
combinedPixel_b = (~devicePixel_b) | intermediatePixel_b;
|
|
}
|
|
else if (m_rop == TQPainter::NandROP) {
|
|
combinedPixel_a = ((devicePixel_a != 0) || (intermediatePixel_a != 0))?0xff:0x00;
|
|
combinedPixel_r = ~(devicePixel_r & intermediatePixel_r);
|
|
combinedPixel_g = ~(devicePixel_g & intermediatePixel_g);
|
|
combinedPixel_b = ~(devicePixel_b & intermediatePixel_b);
|
|
}
|
|
else if (m_rop == TQPainter::NorROP) {
|
|
combinedPixel_a = ((devicePixel_a != 0) || (intermediatePixel_a != 0))?0xff:0x00;
|
|
combinedPixel_r = ~(devicePixel_r | intermediatePixel_r);
|
|
combinedPixel_g = ~(devicePixel_g | intermediatePixel_g);
|
|
combinedPixel_b = ~(devicePixel_b | intermediatePixel_b);
|
|
}
|
|
else {
|
|
tqWarning("TQt3CairoPaintDevice::cmd: Unhandled raster operation [Was attempting to use raster operation %d\n\r", m_rop);
|
|
combinedPixel_a = devicePixel_a;
|
|
combinedPixel_r = devicePixel_r;
|
|
combinedPixel_g = devicePixel_g;
|
|
combinedPixel_b = devicePixel_b;
|
|
}
|
|
|
|
// Convert to premultiplied ARGB
|
|
(*(intermediate_surface_data+offset+ARGB_A_BYTE_NUMBER)) = combinedPixel_a;
|
|
(*(intermediate_surface_data+offset+ARGB_R_BYTE_NUMBER)) = combinedPixel_r;
|
|
(*(intermediate_surface_data+offset+ARGB_G_BYTE_NUMBER)) = combinedPixel_g;
|
|
(*(intermediate_surface_data+offset+ARGB_B_BYTE_NUMBER)) = combinedPixel_b;
|
|
standardAlphaToPremultipliedAlpha(intermediate_surface_data+offset+ARGB_A_BYTE_NUMBER, intermediate_surface_data+offset+ARGB_R_BYTE_NUMBER, intermediate_surface_data+offset+ARGB_G_BYTE_NUMBER, intermediate_surface_data+offset+ARGB_B_BYTE_NUMBER);
|
|
}
|
|
else {
|
|
// Lossless copy of premultiplied ARGB pixel values
|
|
(*(intermediate_surface_data+offset+ARGB_A_BYTE_NUMBER)) = (*(device_surface_data+offset+ARGB_A_BYTE_NUMBER));
|
|
(*(intermediate_surface_data+offset+ARGB_R_BYTE_NUMBER)) = (*(device_surface_data+offset+ARGB_R_BYTE_NUMBER));
|
|
(*(intermediate_surface_data+offset+ARGB_G_BYTE_NUMBER)) = (*(device_surface_data+offset+ARGB_G_BYTE_NUMBER));
|
|
(*(intermediate_surface_data+offset+ARGB_B_BYTE_NUMBER)) = (*(device_surface_data+offset+ARGB_B_BYTE_NUMBER));
|
|
}
|
|
}
|
|
}
|
|
cairo_surface_mark_dirty(m_intermediateSurface);
|
|
cairo_surface_destroy(usableDeviceSurface);
|
|
}
|
|
|
|
if (!m_clipRegionEnabled) {
|
|
// Clipping disabled
|
|
cairo_save(m_devicePainter);
|
|
cairo_reset_clip(m_devicePainter);
|
|
cairo_set_matrix(m_devicePainter, &m_deviceMatrix);
|
|
|
|
cairo_set_source_surface(m_devicePainter, m_intermediateSurface, m_offsetX, m_offsetY);
|
|
cairo_set_operator(m_devicePainter, overlayMerge?CAIRO_OPERATOR_OVER:CAIRO_OPERATOR_SOURCE);
|
|
cairo_paint(m_devicePainter);
|
|
|
|
cairo_restore(m_devicePainter);
|
|
}
|
|
else {
|
|
// Clipping enabled
|
|
cairo_save(m_devicePainter);
|
|
cairo_reset_clip(m_devicePainter);
|
|
cairo_set_matrix(m_devicePainter, &m_deviceMatrix);
|
|
|
|
cairo_surface_t* maskSurface = TQImageToCairoSurface(m_clipRegion);
|
|
cairo_set_source_surface(m_devicePainter, m_intermediateSurface, m_offsetX, m_offsetY);
|
|
cairo_set_operator(m_devicePainter, overlayMerge?CAIRO_OPERATOR_OVER:CAIRO_OPERATOR_SOURCE);
|
|
|
|
// Clipping enabled
|
|
if (m_worldMatrixEnabled || m_viewportMatrixEnabled) {
|
|
// The mask needs to be transformed before application
|
|
cairo_surface_t* maskSurface = TQImageToCairoSurface(m_clipRegion);
|
|
cairo_surface_t *transformedMaskSurface;
|
|
cairo_t *cr2;
|
|
int maxSize;
|
|
int w = cairo_image_surface_get_width(maskSurface);
|
|
int h = cairo_image_surface_get_height(maskSurface);
|
|
if (w>h) {
|
|
maxSize = w*2;
|
|
}
|
|
else {
|
|
maxSize = h*2;
|
|
}
|
|
transformedMaskSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, maxSize, maxSize);
|
|
cr2 = cairo_create(transformedMaskSurface);
|
|
setCairoTransformations(cr2);
|
|
cairo_set_source_surface (cr2, maskSurface, 0, 0);
|
|
cairo_set_operator(cr2, CAIRO_OPERATOR_SOURCE);
|
|
cairo_paint(cr2);
|
|
|
|
// Paint intermediate surface to final surface through mask
|
|
cairo_set_source_surface(m_devicePainter, m_intermediateSurface, m_offsetX, m_offsetY);
|
|
cairo_set_operator(m_devicePainter, overlayMerge?CAIRO_OPERATOR_OVER:CAIRO_OPERATOR_SOURCE);
|
|
cairo_mask_surface(m_devicePainter, transformedMaskSurface, m_offsetX, m_offsetY);
|
|
cairo_surface_destroy(transformedMaskSurface);
|
|
}
|
|
else {
|
|
// Paint intermediate surface to final surface through mask
|
|
cairo_surface_t* maskSurface = TQImageToCairoSurface(m_clipRegion);
|
|
cairo_set_source_surface(m_devicePainter, m_intermediateSurface, m_offsetX, m_offsetY);
|
|
cairo_set_operator(m_devicePainter, overlayMerge?CAIRO_OPERATOR_OVER:CAIRO_OPERATOR_SOURCE);
|
|
cairo_mask_surface(m_devicePainter, maskSurface, m_offsetX, m_offsetY);
|
|
}
|
|
cairo_surface_destroy(maskSurface);
|
|
|
|
cairo_restore(m_devicePainter);
|
|
}
|
|
|
|
// Clear intermediate surface
|
|
cairo_t *clearPainter = cairo_create(m_intermediateSurface);
|
|
cairo_set_operator(clearPainter, CAIRO_OPERATOR_SOURCE);
|
|
cairo_set_source_rgba(clearPainter, 0.0, 0.0, 0.0, 0.0);
|
|
cairo_paint(clearPainter);
|
|
cairo_surface_flush(m_intermediateSurface);
|
|
cairo_destroy(clearPainter);
|
|
|
|
m_transferNeeded = false;
|
|
}
|
|
|
|
bool TQt3CairoPaintDevice::intermediateSurfaceInUse() const {
|
|
return (m_clipRegionEnabled || (m_rop != TQPainter::CopyROP));
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::dualStrokePen() {
|
|
if (m_bgColorMode == TQt::OpaqueMode) {
|
|
// Draw background
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
updatePen(TRUE);
|
|
cairo_stroke(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
// Draw foreground
|
|
updatePen(FALSE);
|
|
cairo_stroke(FASTEST_AVAILABLE_PAINTER);
|
|
m_transferNeeded = true;
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::dualStrokeBrush(cairo_fill_rule_t fillMethod) {
|
|
if (m_bgColorMode == TQt::OpaqueMode) {
|
|
// Draw background
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
updateBrush(TRUE, fillMethod);
|
|
cairo_fill(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
// Draw foreground
|
|
updateBrush(FALSE, fillMethod);
|
|
cairo_fill(FASTEST_AVAILABLE_PAINTER);
|
|
m_transferNeeded = true;
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::updatePen(bool backgroundStroke) {
|
|
if (!m_painter) {
|
|
return;
|
|
}
|
|
|
|
int ps = m_pen.style();
|
|
|
|
double dashes[10]; // custom pen dashes
|
|
int dash_len = 0; // length of dash list
|
|
int dash_offset = 0;
|
|
cairo_line_cap_t cp = CAIRO_LINE_CAP_BUTT;
|
|
cairo_line_join_t jn = CAIRO_LINE_JOIN_MITER;
|
|
|
|
/*
|
|
We are emulating Windows here. Windows treats m_pen.width() == 1
|
|
(or 0) as a very special case. The fudge variable unifies this
|
|
case with the general case.
|
|
*/
|
|
int dot = m_pen.width(); // width of a dot
|
|
int fudge = 1;
|
|
//bool allow_zero_lw = TRUE;
|
|
bool allow_zero_lw = FALSE;
|
|
if ( dot <= 1 ) {
|
|
dot = 3;
|
|
fudge = 2;
|
|
}
|
|
|
|
switch( ps ) {
|
|
case TQPainter::NoPen:
|
|
case TQPainter::SolidLine:
|
|
break;
|
|
case TQPainter::DashLine:
|
|
dashes[0] = fudge * 3 * dot;
|
|
dashes[1] = fudge * dot;
|
|
dash_len = 2;
|
|
allow_zero_lw = FALSE;
|
|
break;
|
|
case TQPainter::DotLine:
|
|
dashes[0] = dot;
|
|
dashes[1] = dot;
|
|
dash_len = 2;
|
|
allow_zero_lw = FALSE;
|
|
break;
|
|
case TQPainter::DashDotLine:
|
|
dashes[0] = 3 * dot;
|
|
dashes[1] = fudge * dot;
|
|
dashes[2] = dot;
|
|
dashes[3] = fudge * dot;
|
|
dash_len = 4;
|
|
allow_zero_lw = FALSE;
|
|
break;
|
|
case TQPainter::DashDotDotLine:
|
|
dashes[0] = 3 * dot;
|
|
dashes[1] = dot;
|
|
dashes[2] = dot;
|
|
dashes[3] = dot;
|
|
dashes[4] = dot;
|
|
dashes[5] = dot;
|
|
dash_len = 6;
|
|
allow_zero_lw = FALSE;
|
|
break;
|
|
case TQPainter::FineDotLine:
|
|
dot = 1;
|
|
dashes[0] = dot;
|
|
dashes[1] = dot;
|
|
dash_len = 2;
|
|
allow_zero_lw = FALSE;
|
|
}
|
|
Q_ASSERT( dash_len <= (int) sizeof(dashes) );
|
|
|
|
switch ( m_pen.capStyle() ) {
|
|
case TQPainter::SquareCap:
|
|
cp = CAIRO_LINE_CAP_SQUARE;
|
|
break;
|
|
case TQPainter::RoundCap:
|
|
cp = CAIRO_LINE_CAP_ROUND;
|
|
break;
|
|
case TQPainter::FlatCap:
|
|
default:
|
|
cp = CAIRO_LINE_CAP_BUTT;
|
|
break;
|
|
}
|
|
|
|
switch ( m_pen.joinStyle() ) {
|
|
case TQPainter::BevelJoin:
|
|
jn = CAIRO_LINE_JOIN_BEVEL;
|
|
break;
|
|
case TQPainter::RoundJoin:
|
|
jn = CAIRO_LINE_JOIN_ROUND;
|
|
break;
|
|
case TQPainter::MiterJoin:
|
|
default:
|
|
jn = CAIRO_LINE_JOIN_MITER;
|
|
break;
|
|
}
|
|
|
|
if (backgroundStroke) {
|
|
dash_len = 0;
|
|
|
|
}
|
|
|
|
TQRgb color = (backgroundStroke)?m_bgColor.rgb():m_pen.color().rgb();
|
|
|
|
cairo_set_dash(m_painter, dashes, dash_len, dash_offset);
|
|
cairo_set_line_cap(m_painter, cp);
|
|
cairo_set_line_join(m_painter, jn);
|
|
cairo_set_line_width(m_painter, ((!allow_zero_lw) && (m_pen.width() == 0)) ? 1 : m_pen.width());
|
|
cairo_set_source_rgba(m_painter, tqRed(color)/255.0, tqGreen(color)/255.0, tqBlue(color)/255.0, tqAlpha(color)/255.0);
|
|
|
|
// BEGIN DUPLICATE
|
|
cairo_set_dash(m_devicePainter, dashes, dash_len, dash_offset);
|
|
cairo_set_line_cap(m_devicePainter, cp);
|
|
cairo_set_line_join(m_devicePainter, jn);
|
|
cairo_set_line_width(m_devicePainter, ((!allow_zero_lw) && (m_pen.width() == 0)) ? 1 : m_pen.width());
|
|
cairo_set_source_rgba(m_devicePainter, tqRed(color)/255.0, tqGreen(color)/255.0, tqBlue(color)/255.0, tqAlpha(color)/255.0);
|
|
// END DUPLICATE
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::updateBrush(bool backgroundStroke, cairo_fill_rule_t fillMethod) {
|
|
if (!m_painter) {
|
|
return;
|
|
}
|
|
|
|
if (backgroundStroke) {
|
|
TQRgb color = m_bgColor.rgb();
|
|
cairo_pattern_t* pattern = cairo_pattern_create_rgba(tqRed(color)/255.0, tqGreen(color)/255.0, tqBlue(color)/255.0, tqAlpha(color)/255.0);
|
|
cairo_set_source(m_painter, pattern);
|
|
cairo_set_source(m_devicePainter, pattern);
|
|
cairo_pattern_set_extend(cairo_get_source(m_painter), CAIRO_EXTEND_REPEAT);
|
|
cairo_pattern_set_extend(cairo_get_source(m_devicePainter), CAIRO_EXTEND_REPEAT);
|
|
cairo_pattern_destroy(pattern);
|
|
}
|
|
else {
|
|
static const uchar dense1_pat[] = { 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff };
|
|
static const uchar dense2_pat[] = { 0x77, 0xff, 0xdd, 0xff, 0x77, 0xff, 0xdd, 0xff };
|
|
static const uchar dense3_pat[] = { 0x55, 0xbb, 0x55, 0xee, 0x55, 0xbb, 0x55, 0xee };
|
|
static const uchar dense4_pat[] = { 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa };
|
|
static const uchar dense5_pat[] = { 0xaa, 0x44, 0xaa, 0x11, 0xaa, 0x44, 0xaa, 0x11 };
|
|
static const uchar dense6_pat[] = { 0x88, 0x00, 0x22, 0x00, 0x88, 0x00, 0x22, 0x00 };
|
|
static const uchar dense7_pat[] = { 0x00, 0x44, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00 };
|
|
static const uchar hor_pat[] = { // horizontal pattern
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
|
static const uchar ver_pat[] = { // vertical pattern
|
|
0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20,
|
|
0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20,
|
|
0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20,
|
|
0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20,
|
|
0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20,
|
|
0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20 };
|
|
static const uchar cross_pat[] = { // cross pattern
|
|
0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0xff, 0xff, 0xff,
|
|
0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20,
|
|
0x08, 0x82, 0x20, 0xff, 0xff, 0xff, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20,
|
|
0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0xff, 0xff, 0xff,
|
|
0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20,
|
|
0x08, 0x82, 0x20, 0xff, 0xff, 0xff, 0x08, 0x82, 0x20, 0x08, 0x82, 0x20 };
|
|
static const uchar bdiag_pat[] = { // backward diagonal pattern
|
|
0x20, 0x20, 0x10, 0x10, 0x08, 0x08, 0x04, 0x04, 0x02, 0x02, 0x01, 0x01,
|
|
0x80, 0x80, 0x40, 0x40, 0x20, 0x20, 0x10, 0x10, 0x08, 0x08, 0x04, 0x04,
|
|
0x02, 0x02, 0x01, 0x01, 0x80, 0x80, 0x40, 0x40 };
|
|
static const uchar fdiag_pat[] = { // forward diagonal pattern
|
|
0x02, 0x02, 0x04, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x20, 0x40, 0x40,
|
|
0x80, 0x80, 0x01, 0x01, 0x02, 0x02, 0x04, 0x04, 0x08, 0x08, 0x10, 0x10,
|
|
0x20, 0x20, 0x40, 0x40, 0x80, 0x80, 0x01, 0x01 };
|
|
static const uchar dcross_pat[] = { // diagonal cross pattern
|
|
0x22, 0x22, 0x14, 0x14, 0x08, 0x08, 0x14, 0x14, 0x22, 0x22, 0x41, 0x41,
|
|
0x80, 0x80, 0x41, 0x41, 0x22, 0x22, 0x14, 0x14, 0x08, 0x08, 0x14, 0x14,
|
|
0x22, 0x22, 0x41, 0x41, 0x80, 0x80, 0x41, 0x41 };
|
|
static const uchar * const pat_tbl[] = {
|
|
dense1_pat, dense2_pat, dense3_pat, dense4_pat, dense5_pat,
|
|
dense6_pat, dense7_pat,
|
|
hor_pat, ver_pat, cross_pat, bdiag_pat, fdiag_pat, dcross_pat };
|
|
|
|
int bs = m_brush.style();
|
|
|
|
const uchar *pat = 0; // pattern
|
|
int d = 0; // defalt pattern size: d*d
|
|
if ( bs >= TQBrush::Dense1Pattern && bs <= TQBrush::DiagCrossPattern ) {
|
|
pat = pat_tbl[ bs-TQBrush::Dense1Pattern ];
|
|
if ( bs <= TQBrush::Dense7Pattern ) {
|
|
d = 8;
|
|
}
|
|
else if ( bs <= TQBrush::CrossPattern ) {
|
|
d = 24;
|
|
}
|
|
else {
|
|
d = 16;
|
|
}
|
|
}
|
|
|
|
if ( (bs == TQBrush::CustomPattern) || pat ) {
|
|
TQImage brushImage;
|
|
if ( pat ) {
|
|
TQRgb color = m_brush.color().rgb();
|
|
brushImage = TQImage(d, d, 32);
|
|
int x;
|
|
int y;
|
|
int byte = 0;
|
|
int bit = 7;
|
|
for (x=0; x<d; x++) {
|
|
for (y=0; y<d; y++) {
|
|
brushImage.setPixel(y, x, (TEST_BIT(pat[byte], bit))?color:0x00000000);
|
|
bit--;
|
|
if (bit < 0) {
|
|
bit = 7;
|
|
byte++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
TQPixmap *pm;
|
|
pm = m_brush.pixmap();
|
|
#ifdef USE_TDE_SPECIFIC_LIBRARIES
|
|
brushImage = tdePixmapIO->convertToImage(*pm);
|
|
#else // USE_TDE_SPECIFIC_LIBRARIES
|
|
brushImage = pm->convertToImage();
|
|
#endif
|
|
}
|
|
|
|
cairo_surface_t* brushSurface = TQImageToCairoSurface(brushImage);
|
|
cairo_pattern_t* pattern = cairo_pattern_create_for_surface(brushSurface);
|
|
cairo_matrix_t brush_translation_matrix;
|
|
cairo_matrix_init_translate(&brush_translation_matrix, m_brushOrigin.x()+1, m_brushOrigin.y());
|
|
cairo_pattern_set_matrix(pattern, &brush_translation_matrix);
|
|
cairo_set_source(m_painter, pattern);
|
|
cairo_set_source(m_devicePainter, pattern);
|
|
cairo_pattern_set_extend(cairo_get_source(m_painter), CAIRO_EXTEND_REPEAT);
|
|
cairo_pattern_set_extend(cairo_get_source(m_devicePainter), CAIRO_EXTEND_REPEAT);
|
|
cairo_pattern_destroy(pattern);
|
|
cairo_surface_destroy(brushSurface);
|
|
}
|
|
else {
|
|
TQRgb color = m_brush.color().rgb();
|
|
cairo_pattern_t* pattern = cairo_pattern_create_rgba(tqRed(color)/255.0, tqGreen(color)/255.0, tqBlue(color)/255.0, tqAlpha(color)/255.0);
|
|
cairo_set_source(m_painter, pattern);
|
|
cairo_set_source(m_devicePainter, pattern);
|
|
cairo_pattern_set_extend(cairo_get_source(m_painter), CAIRO_EXTEND_REPEAT);
|
|
cairo_pattern_set_extend(cairo_get_source(m_devicePainter), CAIRO_EXTEND_REPEAT);
|
|
cairo_pattern_destroy(pattern);
|
|
}
|
|
}
|
|
cairo_set_fill_rule(m_painter, fillMethod);
|
|
cairo_set_fill_rule(m_devicePainter, fillMethod);
|
|
}
|
|
|
|
static inline void fix_neg_rect( int *x, int *y, int *w, int *h ) {
|
|
if ( *w < 0 ) {
|
|
*w = -*w + 2;
|
|
*x -= *w - 1;
|
|
}
|
|
if ( *h < 0 ) {
|
|
*h = -*h + 2;
|
|
*y -= *h - 1;
|
|
}
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::drawPolygon(const TQPointArray* pointarray, bool winding, bool fill, bool close) {
|
|
int i;
|
|
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
if (pointarray) {
|
|
int x;
|
|
int y;
|
|
bool first;
|
|
if ((m_brush.style() != TQBrush::NoBrush) && fill) {
|
|
first = true;
|
|
for (i=0;i<pointarray->count();i++) {
|
|
pointarray->point(i, &x, &y);
|
|
if (first) {
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
first = false;
|
|
}
|
|
else {
|
|
cairo_line_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
}
|
|
}
|
|
if (close) {
|
|
cairo_close_path(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
dualStrokeBrush((winding)?CAIRO_FILL_RULE_EVEN_ODD:CAIRO_FILL_RULE_WINDING);
|
|
}
|
|
if (m_pen.style() != TQPen::NoPen) {
|
|
first = true;
|
|
for (i=0;i<pointarray->count();i++) {
|
|
pointarray->point(i, &x, &y);
|
|
if (first) {
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
first = false;
|
|
}
|
|
else {
|
|
cairo_line_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
}
|
|
}
|
|
if (close) {
|
|
cairo_close_path(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
dualStrokePen();
|
|
|
|
// WARNING
|
|
// The Cairo anti-aliasing code fights back--HARD--when drawing 0px lines!
|
|
// See http://projecthamster.wordpress.com/2009/12/22/getting-sharp-pixels-and-actually-something-drawn-using-cairo/ for more details.
|
|
// This code works around the problem by overstriking the line end points with a single pixel, thereby ensuring they are properly drawn.
|
|
if (m_pen.width() < 1) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_set_line_cap(FASTEST_AVAILABLE_PAINTER, CAIRO_LINE_CAP_ROUND);
|
|
cairo_set_line_join(FASTEST_AVAILABLE_PAINTER, CAIRO_LINE_JOIN_ROUND);
|
|
cairo_set_line_width(FASTEST_AVAILABLE_PAINTER, 1);
|
|
for (i=0;i<pointarray->count();i++) {
|
|
pointarray->point(i, &x, &y);
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_line_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
}
|
|
cairo_stroke(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
}
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::drawRoundRect(int x, int y, int w, int h, int xRnd, int yRnd) {
|
|
if (!FASTEST_AVAILABLE_PAINTER) {
|
|
return;
|
|
}
|
|
|
|
w=w+2;
|
|
h=h+2;
|
|
|
|
if ( xRnd <= 0 || yRnd <= 0 ) {
|
|
// Draw normal rectangle
|
|
TQPDevCmdParam param[2];
|
|
int command = PdcDrawRect;
|
|
TQRect rectangle(x, y, w, h);
|
|
param[0].rect = &rectangle;
|
|
cmd(command, NULL, param);
|
|
return;
|
|
}
|
|
|
|
if ( xRnd >= 100 ) { // fix ranges
|
|
xRnd = 99;
|
|
}
|
|
if ( yRnd >= 100 ) {
|
|
yRnd = 99;
|
|
}
|
|
|
|
if ( w <= 0 || h <= 0 ) {
|
|
fix_neg_rect( &x, &y, &w, &h );
|
|
}
|
|
w--;
|
|
h--;
|
|
int rxx = w*xRnd/200;
|
|
int ryy = h*yRnd/200;
|
|
// were there overflows?
|
|
if ( rxx < 0 ) {
|
|
rxx = w/200*xRnd;
|
|
}
|
|
if ( ryy < 0 ) {
|
|
ryy = h/200*yRnd;
|
|
}
|
|
int rxx2 = 2*rxx;
|
|
int ryy2 = 2*ryy;
|
|
TQPointArray a[4];
|
|
a[0].makeArc( x, y, rxx2, ryy2, 1*16*90, 16*90 );
|
|
a[1].makeArc( x, y+h-ryy2, rxx2, ryy2, 2*16*90, 16*90 );
|
|
a[2].makeArc( x+w-rxx2, y+h-ryy2, rxx2, ryy2, 3*16*90, 16*90 );
|
|
a[3].makeArc( x+w-rxx2, y, rxx2, ryy2, 0*16*90, 16*90 );
|
|
// ### is there a better way to join TQPointArrays?
|
|
TQPointArray aa;
|
|
aa.resize( a[0].size() + a[1].size() + a[2].size() + a[3].size() );
|
|
uint j = 0;
|
|
for ( int k=0; k<4; k++ ) {
|
|
for ( uint i=0; i<a[k].size(); i++ ) {
|
|
aa.setPoint( j, a[k].point(i) );
|
|
j++;
|
|
}
|
|
}
|
|
|
|
// Draw polygon
|
|
drawPolygon(&aa, false, true, true);
|
|
|
|
return;
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::drawEllipse(int x, int y, int w, int h) {
|
|
if (!FASTEST_AVAILABLE_PAINTER) {
|
|
return;
|
|
}
|
|
|
|
TQPointArray a;
|
|
a.makeArc(x, y, w+1, h+1, 0, 360*16);
|
|
|
|
// Draw polygon
|
|
drawPolygon(&a, false, true, true);
|
|
|
|
return;
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::drawArc(int x, int y, int w, int h, int a, int alen) {
|
|
if (!FASTEST_AVAILABLE_PAINTER) {
|
|
return;
|
|
}
|
|
|
|
TQPointArray pa;
|
|
pa.makeArc(x, y, w, h, a, alen); // arc polyline
|
|
|
|
// Draw polygon
|
|
drawPolygon(&pa, false, false, false);
|
|
|
|
return;
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::drawPie(int x, int y, int w, int h, int a, int alen) {
|
|
if (!FASTEST_AVAILABLE_PAINTER) {
|
|
return;
|
|
}
|
|
|
|
// Make sure "a" is 0..360*16, as otherwise a*4 may overflow 16 bits.
|
|
if ( a > (360*16) ) {
|
|
a = a % (360*16);
|
|
}
|
|
else if ( a < 0 ) {
|
|
a = a % (360*16);
|
|
if ( a < 0 ) {
|
|
a += (360*16);
|
|
}
|
|
}
|
|
|
|
TQPointArray pa;
|
|
pa.makeArc(x, y, w, h, a, alen); // arc polyline
|
|
int n = pa.size();
|
|
int cx, cy;
|
|
cx = (x+w/2)+1;
|
|
cy = (y+h/2)+1;
|
|
pa.resize(n+2);
|
|
pa.setPoint(n, cx, cy); // add legs
|
|
pa.setPoint(n+1, pa.at(0));
|
|
|
|
// Draw polygon
|
|
drawPolygon(&pa, false, true, true);
|
|
|
|
return;
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::drawChord(int x, int y, int w, int h, int a, int alen) {
|
|
if (!FASTEST_AVAILABLE_PAINTER) {
|
|
return;
|
|
}
|
|
|
|
TQPointArray pa;
|
|
pa.makeArc(x, y, w, h, a, alen); // arc polygon
|
|
int n = pa.size();
|
|
pa.resize(n+1);
|
|
pa.setPoint(n, pa.at(0)); // connect endpoints
|
|
|
|
// Draw polygon
|
|
drawPolygon(&pa, false, true, true);
|
|
|
|
return;
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::pangoSetupTextPath(PangoLayout *layout, const char* text) {
|
|
PangoFontDescription *desc;
|
|
|
|
pango_layout_set_text(layout, text, -1);
|
|
|
|
desc = pango_font_description_new();
|
|
|
|
// FIXME
|
|
// overline and a handful of other flags are not supported by Pango!
|
|
// https://bugzilla.gnome.org/show_bug.cgi?id=577190
|
|
TQString family = m_font.family();
|
|
// bool bold = m_font.bold();
|
|
bool italic = m_font.italic();
|
|
bool underline = m_font.underline();
|
|
// bool overline = m_font.overline();
|
|
bool strikeout = m_font.strikeOut();
|
|
// bool fixedPitch = m_font.fixedPitch();
|
|
int stretch = m_font.stretch();
|
|
int weight = m_font.weight();
|
|
|
|
int pixelSize = m_font.pixelSize();
|
|
bool usePixelSize = (pixelSize>=0);
|
|
float pointSizeFloat = m_font.pointSizeFloat();
|
|
bool usePointSize = (pointSizeFloat>=0);
|
|
|
|
TQFont::StyleStrategy qt3fontstrategy = m_font.styleStrategy();
|
|
|
|
PangoWeight pangoWeight;
|
|
switch (weight) {
|
|
case TQFont::Light:
|
|
pangoWeight = PANGO_WEIGHT_LIGHT;
|
|
break;
|
|
case TQFont::Normal:
|
|
pangoWeight = PANGO_WEIGHT_NORMAL;
|
|
break;
|
|
case TQFont::DemiBold:
|
|
pangoWeight = PANGO_WEIGHT_SEMIBOLD;
|
|
break;
|
|
case TQFont::Bold:
|
|
pangoWeight = PANGO_WEIGHT_BOLD;
|
|
break;
|
|
case TQFont::Black:
|
|
pangoWeight = PANGO_WEIGHT_HEAVY;
|
|
break;
|
|
}
|
|
|
|
PangoStretch pangoStretch;
|
|
switch (stretch) {
|
|
case TQFont::UltraCondensed:
|
|
pangoStretch = PANGO_STRETCH_ULTRA_CONDENSED;
|
|
break;
|
|
case TQFont::ExtraCondensed:
|
|
pangoStretch = PANGO_STRETCH_EXTRA_CONDENSED;
|
|
break;
|
|
case TQFont::Condensed:
|
|
pangoStretch = PANGO_STRETCH_CONDENSED;
|
|
break;
|
|
case TQFont::SemiCondensed:
|
|
pangoStretch = PANGO_STRETCH_SEMI_CONDENSED;
|
|
break;
|
|
case TQFont::Unstretched:
|
|
pangoStretch = PANGO_STRETCH_NORMAL;
|
|
break;
|
|
case TQFont::SemiExpanded:
|
|
pangoStretch = PANGO_STRETCH_SEMI_EXPANDED;
|
|
break;
|
|
case TQFont::Expanded:
|
|
pangoStretch = PANGO_STRETCH_EXPANDED;
|
|
break;
|
|
case TQFont::ExtraExpanded:
|
|
pangoStretch = PANGO_STRETCH_EXTRA_EXPANDED;
|
|
break;
|
|
case TQFont::UltraExpanded:
|
|
pangoStretch = PANGO_STRETCH_ULTRA_EXPANDED;
|
|
break;
|
|
}
|
|
|
|
pango_font_description_set_family(desc, family.ascii());
|
|
if (usePixelSize) {
|
|
pango_font_description_set_absolute_size(desc, pixelSize*PANGO_SCALE);
|
|
}
|
|
if (usePointSize) {
|
|
pango_font_description_set_absolute_size(desc, pointSizeFloat*PANGO_SCALE*CAIRO_FONT_SIZE_FUDGE_FACTOR);
|
|
}
|
|
pango_font_description_set_style(desc, (italic)?PANGO_STYLE_ITALIC:PANGO_STYLE_NORMAL);
|
|
pango_font_description_set_weight(desc, pangoWeight);
|
|
pango_font_description_set_stretch(desc, pangoStretch);
|
|
|
|
#if 0
|
|
if (qt3fontstrategy & TQFont::PreferDefault) // FIXME Set Cairo/Pango to follow this hint
|
|
if (qt3fontstrategy & TQFont::PreferBitmap) // FIXME Set Cairo/Pango to follow this hint
|
|
if (qt3fontstrategy & TQFont::PreferDevice) // FIXME Set Cairo/Pango to follow this hint
|
|
if (qt3fontstrategy & TQFont::PreferMatch) // FIXME Set Cairo/Pango to follow this hint
|
|
if (qt3fontstrategy & TQFont::PreferQuality) // FIXME Set Cairo/Pango to follow this hint
|
|
if (qt3fontstrategy & TQFont::PreferAntialias) // FIXME Set Cairo/Pango to follow this hint
|
|
if (qt3fontstrategy & TQFont::NoAntialias) // FIXME Set Cairo/Pango to follow this hint
|
|
if (qt3fontstrategy & TQFont::OpenGLCompatible) // FIXME Set Cairo/Pango to follow this hint
|
|
#endif
|
|
|
|
pango_layout_set_font_description(layout, desc);
|
|
pango_font_description_free(desc);
|
|
|
|
PangoAttrList* attr_list = pango_attr_list_new();
|
|
pango_attr_list_insert(attr_list, pango_attr_underline_new((underline)?PANGO_UNDERLINE_SINGLE:PANGO_UNDERLINE_NONE));
|
|
pango_attr_list_insert(attr_list, pango_attr_strikethrough_new(strikeout));
|
|
pango_layout_set_attributes(layout, attr_list);
|
|
pango_attr_list_unref(attr_list);
|
|
|
|
if (m_tabStopArrayValid) {
|
|
pango_layout_set_tabs(layout, m_tabStopArray);
|
|
}
|
|
else if (m_tabStopsValid) {
|
|
pango_layout_set_tabs(layout, m_tabStops);
|
|
}
|
|
else {
|
|
pango_layout_set_tabs(layout, NULL);
|
|
}
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::drawText(TQPainter *p, int x, int y, const TQString &str) {
|
|
if ((!FASTEST_AVAILABLE_PAINTER) || (!p)) {
|
|
return;
|
|
}
|
|
|
|
PangoLayout *layout;
|
|
layout = pango_cairo_create_layout(FASTEST_AVAILABLE_PAINTER);
|
|
|
|
TQFont::StyleStrategy qt3fontstrategy = m_font.styleStrategy();
|
|
pangoSetupTextPath(layout, str.utf8());
|
|
|
|
int baseline_y = pango_layout_get_baseline(layout)/PANGO_SCALE;
|
|
cairo_new_path(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x, y-baseline_y);
|
|
updatePen(FALSE);
|
|
|
|
pango_cairo_update_layout(FASTEST_AVAILABLE_PAINTER, layout);
|
|
pango_cairo_layout_path(FASTEST_AVAILABLE_PAINTER, layout);
|
|
|
|
if ((qt3fontstrategy & TQFont::PreferOutline) || (qt3fontstrategy & TQFont::ForceOutline)) {
|
|
cairo_stroke_preserve(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
else {
|
|
cairo_fill(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
|
|
g_object_unref(layout);
|
|
|
|
m_transferNeeded = true;
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::drawTextInRect(TQPainter *p, TQRect rect, int textFlags, const TQString &str) {
|
|
if ((!FASTEST_AVAILABLE_PAINTER) || (!p)) {
|
|
return;
|
|
}
|
|
|
|
PangoLayout *layout;
|
|
layout = pango_cairo_create_layout(FASTEST_AVAILABLE_PAINTER);
|
|
|
|
TQFont::StyleStrategy qt3fontstrategy = m_font.styleStrategy();
|
|
pangoSetupTextPath(layout, str.utf8());
|
|
|
|
pango_layout_set_width(layout, rect.width()*PANGO_SCALE);
|
|
|
|
int fudgedOffsetY = 0;
|
|
|
|
// Layout flags
|
|
if (textFlags & TQt::SingleLine) {
|
|
// Pango special case to force rendering of only one line of text
|
|
pango_layout_set_height(layout, 0);
|
|
}
|
|
if (!(textFlags & TQt::DontClip)) {
|
|
cairo_rectangle(FASTEST_AVAILABLE_PAINTER, rect.x()+CAIRO_PEN_PIXEL_OFFSET, rect.y()+CAIRO_PEN_PIXEL_OFFSET, rect.width(), rect.height());
|
|
cairo_clip(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
if (textFlags & TQt::ExpandTabs) {
|
|
// FIXME
|
|
}
|
|
if (textFlags & TQt::ShowPrefix) {
|
|
// FIXME
|
|
}
|
|
if (textFlags & TQt::WordBreak) {
|
|
pango_layout_set_wrap(layout, PANGO_WRAP_WORD);
|
|
}
|
|
if (textFlags & TQt::BreakAnywhere) {
|
|
pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
|
|
}
|
|
if (textFlags & TQt::NoAccel) {
|
|
// FIXME
|
|
}
|
|
|
|
PangoRectangle inkRect;
|
|
PangoRectangle logicalRect;
|
|
pango_layout_get_pixel_extents(layout, &inkRect, &logicalRect);
|
|
|
|
int stockWidth = logicalRect.x + logicalRect.width;
|
|
int stockHeight = logicalRect.y + logicalRect.height;
|
|
|
|
pango_layout_set_height(layout, rect.height()*PANGO_SCALE);
|
|
|
|
// Position flags
|
|
if (textFlags & TQt::AlignAuto) {
|
|
// FIXME
|
|
}
|
|
if (textFlags & TQt::AlignLeft) {
|
|
pango_layout_set_alignment(layout, PANGO_ALIGN_LEFT);
|
|
}
|
|
if (textFlags & TQt::AlignRight) {
|
|
pango_layout_set_alignment(layout, PANGO_ALIGN_RIGHT);
|
|
}
|
|
if (textFlags & TQt::AlignHCenter) {
|
|
pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
|
|
}
|
|
if (textFlags & TQt::AlignJustify) {
|
|
// FIXME
|
|
}
|
|
if (textFlags & TQt::AlignTop) {
|
|
fudgedOffsetY = 0;
|
|
}
|
|
if (textFlags & TQt::AlignBottom) {
|
|
fudgedOffsetY = (rect.height()-stockHeight);
|
|
}
|
|
if (textFlags & TQt::AlignVCenter) {
|
|
fudgedOffsetY = ((rect.height()-stockHeight)/2);
|
|
}
|
|
|
|
cairo_new_path(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, rect.x(), rect.y() + fudgedOffsetY);
|
|
updatePen(FALSE);
|
|
|
|
pango_cairo_update_layout(FASTEST_AVAILABLE_PAINTER, layout);
|
|
pango_cairo_layout_path(FASTEST_AVAILABLE_PAINTER, layout);
|
|
|
|
if ((qt3fontstrategy & TQFont::PreferOutline) || (qt3fontstrategy & TQFont::ForceOutline)) {
|
|
cairo_stroke_preserve(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
else {
|
|
cairo_fill(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
cairo_reset_clip(FASTEST_AVAILABLE_PAINTER);
|
|
|
|
g_object_unref(layout);
|
|
|
|
m_transferNeeded = true;
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::setCairoTransformations(cairo_t* cr, bool forceDisable, bool applyBaseDeviceTransform) {
|
|
cairo_matrix_t combinedMatrix;
|
|
cairo_matrix_t tempMatrix;
|
|
|
|
cairo_matrix_init_identity(&combinedMatrix);
|
|
if (!forceDisable) {
|
|
if (applyBaseDeviceTransform) {
|
|
// Handle specified offsets
|
|
cairo_matrix_t offsetMatrix;
|
|
cairo_matrix_init_identity(&offsetMatrix);
|
|
cairo_matrix_init_translate(&offsetMatrix, m_offsetX, m_offsetY);
|
|
|
|
cairo_matrix_multiply(&tempMatrix, &combinedMatrix, &m_deviceMatrix);
|
|
combinedMatrix = tempMatrix;
|
|
|
|
cairo_matrix_multiply(&tempMatrix, &combinedMatrix, &offsetMatrix);
|
|
combinedMatrix = tempMatrix;
|
|
}
|
|
if (m_worldMatrixEnabled) {
|
|
cairo_matrix_multiply(&tempMatrix, &combinedMatrix, &m_worldMatrix);
|
|
combinedMatrix = tempMatrix;
|
|
}
|
|
if (m_viewportMatrixEnabled) {
|
|
cairo_matrix_multiply(&tempMatrix, &combinedMatrix, &m_viewportMatrix);
|
|
combinedMatrix = tempMatrix;
|
|
}
|
|
}
|
|
|
|
cairo_set_matrix(cr, &combinedMatrix);
|
|
}
|
|
|
|
/*!
|
|
\class TQt3CairoPaintDevice tdeqt4painter.h
|
|
\brief The TQt3CairoPaintDevice class is a paint device that translates
|
|
Qt paint events to a TQt painter.
|
|
|
|
\ingroup graphics
|
|
\ingroup shared
|
|
|
|
*/
|
|
|
|
/*!
|
|
Constructs TQt3CairoPaintDevice on an existing QPainter
|
|
*/
|
|
|
|
TQt3CairoPaintDevice::TQt3CairoPaintDevice( cairo_surface_t *cairosurface, int x, int y, int width, int height, cairo_t *overridepainter )
|
|
: TQPaintDevice( TQInternal::Picture | TQInternal::ExternalDevice )
|
|
{
|
|
init();
|
|
|
|
m_offsetX = x;
|
|
m_offsetY = y;
|
|
if (width >= 0) {
|
|
m_width = width;
|
|
}
|
|
if (height >= 0) {
|
|
m_height = height;
|
|
}
|
|
if (overridepainter) {
|
|
m_overridePainter = overridepainter;
|
|
m_surface = cairo_get_group_target(overridepainter);
|
|
}
|
|
else {
|
|
m_surface = cairosurface;
|
|
}
|
|
m_worldMatrixStack.setAutoDelete(TRUE);
|
|
|
|
m_tabStops = pango_tab_array_new(0, false);
|
|
m_tabStopArray = pango_tab_array_new(0, false);
|
|
}
|
|
|
|
/*!
|
|
Destroys the TQt3CairoPaintDevice.
|
|
*/
|
|
TQt3CairoPaintDevice::~TQt3CairoPaintDevice()
|
|
{
|
|
if (m_tabStops) {
|
|
pango_tab_array_free(m_tabStops);
|
|
}
|
|
if (m_tabStopArray) {
|
|
pango_tab_array_free(m_tabStopArray);
|
|
}
|
|
|
|
if (m_painter) {
|
|
cairo_destroy(m_painter);
|
|
m_painter = NULL;
|
|
}
|
|
if (m_devicePainter) {
|
|
cairo_destroy(m_devicePainter);
|
|
m_devicePainter = NULL;
|
|
}
|
|
if (m_intermediateSurface) {
|
|
cairo_surface_destroy(m_intermediateSurface);
|
|
}
|
|
#ifdef USE_TDE_SPECIFIC_LIBRARIES
|
|
if (tdePixmapIO) {
|
|
delete tdePixmapIO;
|
|
}
|
|
#endif // USE_TDE_SPECIFIC_LIBRARIES
|
|
}
|
|
|
|
/*!
|
|
Initializes all data structures
|
|
*/
|
|
void TQt3CairoPaintDevice::init() {
|
|
m_width = -1;
|
|
m_height = -1;
|
|
m_offsetX = 0;
|
|
m_offsetY = 0;
|
|
|
|
m_intermediateSurface = NULL;
|
|
m_painter = NULL;
|
|
m_devicePainter = NULL;
|
|
m_overridePainter = NULL;
|
|
m_tabStops = NULL;
|
|
m_tabStopArray = NULL;
|
|
|
|
m_transferNeeded = false;
|
|
|
|
#ifdef USE_TDE_SPECIFIC_LIBRARIES
|
|
tdePixmapIO = new KPixmapIO();
|
|
#else // USE_TDE_SPECIFIC_LIBRARIES
|
|
tdePixmapIO = NULL;
|
|
#endif // USE_TDE_SPECIFIC_LIBRARIES
|
|
}
|
|
|
|
void TQt3CairoPaintDevice::updateSurfaceDimensions() const {
|
|
if ((m_width < 0) || (m_height < 0)) {
|
|
m_width = cairo_image_surface_get_width(m_surface);
|
|
m_height = cairo_image_surface_get_height(m_surface);
|
|
}
|
|
if ((m_width < 1) || (m_height < 1)) {
|
|
printf("[WARNING] Cairo surface height or width less than 0; drawing will not be possible!\n\r"); fflush(stdout);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Implementation of the function forwarded above to the internal data struct.
|
|
*/
|
|
|
|
bool TQt3CairoPaintDevice::cmd( int c, TQPainter *pt, TQPDevCmdParam *p )
|
|
{
|
|
unsigned int i;
|
|
|
|
double x;
|
|
double y;
|
|
double x2;
|
|
double y2;
|
|
double width;
|
|
double height;
|
|
|
|
int index;
|
|
int count;
|
|
int lineCount;
|
|
|
|
// Convert data types
|
|
if (p) {
|
|
if ((c == PdcDrawPoint) || (c == PdcMoveTo) || (c == PdcLineTo) || (c == PdcSetBrushOrigin)) {
|
|
x = p[0].point->x();
|
|
y = p[0].point->y();
|
|
}
|
|
if (c == PdcDrawLine) {
|
|
x = p[0].point->x();
|
|
y = p[0].point->y();
|
|
x2 = p[1].point->x();
|
|
y2 = p[1].point->y();
|
|
}
|
|
if ((c == PdcDrawRect) || (c == PdcDrawRoundRect) || (c == PdcDrawEllipse) || (c == PdcDrawArc) || (c == PdcDrawPie) || (c == PdcDrawChord)) {
|
|
x = p[0].rect->x();
|
|
y = p[0].rect->y();
|
|
width = p[0].rect->width();
|
|
height = p[0].rect->height();
|
|
}
|
|
}
|
|
|
|
// Perform drawing operation
|
|
switch ( c ) { // exec cmd
|
|
case PdcNOP:
|
|
break;
|
|
case PdcDrawPoint:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
if (m_pen.style() != TQPen::NoPen) {
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_line_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
updatePen(FALSE);
|
|
cairo_set_line_cap(FASTEST_AVAILABLE_PAINTER, CAIRO_LINE_CAP_ROUND);
|
|
cairo_stroke(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
m_transferNeeded = true;
|
|
}
|
|
break;
|
|
case PdcMoveTo:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
if (m_pen.style() != TQPen::NoPen) {
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcLineTo:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
if (m_pen.style() != TQPen::NoPen) {
|
|
bool has_current_point = cairo_has_current_point(FASTEST_AVAILABLE_PAINTER);
|
|
double cr_x2;
|
|
double cr_y2;
|
|
cairo_get_current_point(FASTEST_AVAILABLE_PAINTER, &cr_x2, &cr_y2);
|
|
int x2 = cr_x2-CAIRO_PEN_PIXEL_OFFSET;
|
|
int y2 = cr_y2-CAIRO_PEN_PIXEL_OFFSET;
|
|
|
|
cairo_line_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
dualStrokePen();
|
|
|
|
// WARNING
|
|
// The Cairo anti-aliasing code fights back--HARD--when drawing 0px lines!
|
|
// See http://projecthamster.wordpress.com/2009/12/22/getting-sharp-pixels-and-actually-something-drawn-using-cairo/ for more details.
|
|
// This code works around the problem by overstriking the line end points with a single pixel, thereby ensuring they are properly drawn.
|
|
if (m_pen.width() < 1) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_set_line_cap(FASTEST_AVAILABLE_PAINTER, CAIRO_LINE_CAP_ROUND);
|
|
cairo_set_line_join(FASTEST_AVAILABLE_PAINTER, CAIRO_LINE_JOIN_ROUND);
|
|
cairo_set_line_width(FASTEST_AVAILABLE_PAINTER, 1);
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_line_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x2+CAIRO_PEN_PIXEL_OFFSET, y2+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_line_to(FASTEST_AVAILABLE_PAINTER, x2+CAIRO_PEN_PIXEL_OFFSET, y2+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_stroke(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcDrawLine:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
if (m_pen.style() != TQPen::NoPen) {
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_line_to(FASTEST_AVAILABLE_PAINTER, x2+CAIRO_PEN_PIXEL_OFFSET, y2+CAIRO_PEN_PIXEL_OFFSET);
|
|
dualStrokePen();
|
|
|
|
// WARNING
|
|
// The Cairo anti-aliasing code fights back--HARD--when drawing 0px lines!
|
|
// See http://projecthamster.wordpress.com/2009/12/22/getting-sharp-pixels-and-actually-something-drawn-using-cairo/ for more details.
|
|
// This code works around the problem by overstriking the line end points with a single pixel, thereby ensuring they are properly drawn.
|
|
if (m_pen.width() < 1) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_set_line_cap(FASTEST_AVAILABLE_PAINTER, CAIRO_LINE_CAP_ROUND);
|
|
cairo_set_line_join(FASTEST_AVAILABLE_PAINTER, CAIRO_LINE_JOIN_ROUND);
|
|
cairo_set_line_width(FASTEST_AVAILABLE_PAINTER, 1);
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_line_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x2+CAIRO_PEN_PIXEL_OFFSET, y2+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_line_to(FASTEST_AVAILABLE_PAINTER, x2+CAIRO_PEN_PIXEL_OFFSET, y2+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_stroke(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcDrawRect:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
int adjustment = cairoPainterRectSubtraction(&m_pen);
|
|
if (m_brush.style() != TQBrush::NoBrush) {
|
|
int line_width = m_pen.width();
|
|
cairo_rectangle(FASTEST_AVAILABLE_PAINTER, x+line_width+CAIRO_BRUSH_PIXEL_OFFSET, y+line_width+CAIRO_BRUSH_PIXEL_OFFSET, width-(line_width*2)-adjustment, height-(line_width*2)-adjustment);
|
|
dualStrokeBrush(CAIRO_FILL_RULE_EVEN_ODD);
|
|
}
|
|
if (m_pen.style() != TQPen::NoPen) {
|
|
cairo_rectangle(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET, width-adjustment, height-adjustment);
|
|
dualStrokePen();
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
else {
|
|
#if defined(QT_CHECK_RANGE)
|
|
tqWarning( "TQt3CairoPaintDevice::cmd: TQPainter::begin must be called before PdcDrawRect" );
|
|
#endif
|
|
}
|
|
break;
|
|
case PdcDrawRoundRect:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
int adjustment = cairoPainterRectSubtraction(&m_pen);
|
|
if (p) {
|
|
drawRoundRect(x, y, width-adjustment, height-adjustment, p[1].ival, p[2].ival);
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcDrawEllipse:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
int adjustment = cairoPainterRectSubtraction(&m_pen);
|
|
if (p) {
|
|
drawEllipse(x, y, width-adjustment, height-adjustment);
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcDrawArc:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
int adjustment = cairoPainterRectSubtraction(&m_pen);
|
|
if (p) {
|
|
drawArc(x, y, width-adjustment, height-adjustment, p[1].ival, p[2].ival);
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcDrawPie:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
int adjustment = cairoPainterRectSubtraction(&m_pen);
|
|
if (p) {
|
|
drawPie(x, y, width-adjustment, height-adjustment, p[1].ival, p[2].ival);
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcDrawChord:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
int adjustment = cairoPainterRectSubtraction(&m_pen);
|
|
if (p) {
|
|
drawChord(x, y, width-adjustment, height-adjustment, p[1].ival, p[2].ival);
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcDrawLineSegments:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
if (p) {
|
|
int x;
|
|
int y;
|
|
int x2;
|
|
int y2;
|
|
const TQPointArray* pointarray = p[0].ptarr;
|
|
if (pointarray) {
|
|
if (m_pen.style() != TQPen::NoPen) {
|
|
for (i=0;i<pointarray->count();i=i+2) {
|
|
pointarray->point(i+0, &x, &y);
|
|
pointarray->point(i+1, &x2, &y2);
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_line_to(FASTEST_AVAILABLE_PAINTER, x2+CAIRO_PEN_PIXEL_OFFSET, y2+CAIRO_PEN_PIXEL_OFFSET);
|
|
dualStrokePen();
|
|
|
|
// WARNING
|
|
// The Cairo anti-aliasing code fights back--HARD--when drawing 0px lines!
|
|
// See http://projecthamster.wordpress.com/2009/12/22/getting-sharp-pixels-and-actually-something-drawn-using-cairo/ for more details.
|
|
// This code works around the problem by overstriking the line end points with a single pixel, thereby ensuring they are properly drawn.
|
|
if (m_pen.width() < 1) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_set_line_cap(FASTEST_AVAILABLE_PAINTER, CAIRO_LINE_CAP_ROUND);
|
|
cairo_set_line_join(FASTEST_AVAILABLE_PAINTER, CAIRO_LINE_JOIN_ROUND);
|
|
cairo_set_line_width(FASTEST_AVAILABLE_PAINTER, 1);
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_line_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x2+CAIRO_PEN_PIXEL_OFFSET, y2+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_line_to(FASTEST_AVAILABLE_PAINTER, x2+CAIRO_PEN_PIXEL_OFFSET, y2+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_stroke(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcDrawPolyline:
|
|
if (p) {
|
|
drawPolygon(p[0].ptarr, false, false, false);
|
|
}
|
|
break;
|
|
case PdcDrawPolygon:
|
|
if (p) {
|
|
drawPolygon(p[0].ptarr, p[1].ival, true, true);
|
|
}
|
|
break;
|
|
case PdcDrawCubicBezier:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
if (p) {
|
|
int x;
|
|
int y;
|
|
int x2;
|
|
int y2;
|
|
int x3;
|
|
int y3;
|
|
int x4;
|
|
int y4;
|
|
const TQPointArray* pointarray = p[0].ptarr;
|
|
if (pointarray) {
|
|
if (m_pen.style() != TQPen::NoPen) {
|
|
for (i=0;i<pointarray->count();i=i+4) {
|
|
pointarray->point(i+0, &x, &y);
|
|
pointarray->point(i+1, &x2, &y2);
|
|
pointarray->point(i+2, &x3, &y3);
|
|
pointarray->point(i+3, &x4, &y4);
|
|
cairo_move_to(FASTEST_AVAILABLE_PAINTER, x+CAIRO_PEN_PIXEL_OFFSET, y+CAIRO_PEN_PIXEL_OFFSET);
|
|
cairo_curve_to(FASTEST_AVAILABLE_PAINTER, x2+CAIRO_PEN_PIXEL_OFFSET, y2+CAIRO_PEN_PIXEL_OFFSET, x3+CAIRO_PEN_PIXEL_OFFSET, y3+CAIRO_PEN_PIXEL_OFFSET, x4+CAIRO_PEN_PIXEL_OFFSET, y4+CAIRO_PEN_PIXEL_OFFSET);
|
|
dualStrokePen();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcDrawText:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
if (p) {
|
|
TQString string = *p[1].str;
|
|
drawText(pt, p[0].rect->x()+CAIRO_PEN_PIXEL_OFFSET, p[0].rect->y()+CAIRO_PEN_PIXEL_OFFSET, string);
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcDrawTextFormatted:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
if (p) {
|
|
TQRect rect = *p[0].rect;
|
|
TQString string = *p[2].str;
|
|
drawTextInRect(pt, rect, p[1].ival, string);
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcDrawText2:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
if (p) {
|
|
TQString string = *p[1].str;
|
|
drawText(pt, p[0].rect->x()+CAIRO_PEN_PIXEL_OFFSET, p[0].rect->y()+CAIRO_PEN_PIXEL_OFFSET, string);
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcDrawText2Formatted:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
if (p) {
|
|
TQRect rect = *p[0].rect;
|
|
TQString string = *p[2].str;
|
|
drawTextInRect(pt, rect, p[1].ival, string);
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
}
|
|
break;
|
|
case PdcDrawPixmap:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
if (p) {
|
|
TQImage sourceImage;
|
|
const TQBitmap* bitmap = dynamic_cast<const TQBitmap*>(p[1].pixmap);
|
|
if (bitmap) {
|
|
TQPixmap mergedPixmap = TQPixmap(bitmap->width(), bitmap->height());
|
|
mergedPixmap.fill(m_pen.color());
|
|
mergedPixmap.setMask(*bitmap);
|
|
|
|
#ifdef USE_TDE_SPECIFIC_LIBRARIES
|
|
sourceImage = tdePixmapIO->convertToImage(mergedPixmap);
|
|
#else // USE_TDE_SPECIFIC_LIBRARIES
|
|
sourceImage = mergedPixmap.convertToImage();
|
|
#endif
|
|
}
|
|
else {
|
|
#ifdef USE_TDE_SPECIFIC_LIBRARIES
|
|
sourceImage = tdePixmapIO->convertToImage(*p[1].pixmap);
|
|
#else // USE_TDE_SPECIFIC_LIBRARIES
|
|
sourceImage = p[1].pixmap->convertToImage();
|
|
#endif
|
|
}
|
|
cairo_surface_t* sourceSurface = TQImageToCairoSurface(sourceImage);
|
|
cairo_rectangle(FASTEST_AVAILABLE_PAINTER, p[0].rect->x(), p[0].rect->y(), p[0].rect->width(), p[0].rect->height());
|
|
cairo_set_source_surface(FASTEST_AVAILABLE_PAINTER, sourceSurface, p[0].rect->x(), p[0].rect->y());
|
|
cairo_fill(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_surface_destroy(sourceSurface);
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
m_transferNeeded = true;
|
|
}
|
|
break;
|
|
case PdcDrawImage:
|
|
if (FASTEST_AVAILABLE_PAINTER) {
|
|
cairo_save(FASTEST_AVAILABLE_PAINTER);
|
|
if (p) {
|
|
TQRect rect = *p[0].rect;
|
|
TQImage image = *p[1].image;
|
|
cairo_surface_t* sourceSurface = TQImageToCairoSurface(image);
|
|
cairo_rectangle(FASTEST_AVAILABLE_PAINTER, rect.x(), rect.y(), rect.width(), rect.height());
|
|
cairo_set_source_surface(FASTEST_AVAILABLE_PAINTER, sourceSurface, rect.x(), rect.y());
|
|
cairo_fill(FASTEST_AVAILABLE_PAINTER);
|
|
cairo_surface_destroy(sourceSurface);
|
|
}
|
|
cairo_restore(FASTEST_AVAILABLE_PAINTER);
|
|
m_transferNeeded = true;
|
|
}
|
|
break;
|
|
case PdcBegin:
|
|
if (!m_painter) {
|
|
m_transferNeeded = false;
|
|
m_bgColor = TQColor(0,0,0);
|
|
m_bgColorMode = TQt::TransparentMode;
|
|
resetIntermediateSurface();
|
|
m_painter = cairo_create(m_intermediateSurface);
|
|
cairo_set_operator(m_painter, CAIRO_OPERATOR_OVER);
|
|
if (m_overridePainter) {
|
|
m_devicePainter = m_overridePainter;
|
|
}
|
|
else {
|
|
m_devicePainter = cairo_create(m_surface);
|
|
}
|
|
cairo_get_matrix(m_devicePainter, &m_deviceMatrix);
|
|
cairo_set_antialias(m_devicePainter, CAIRO_ANTIALIAS_NONE);
|
|
m_pen = TQPen();
|
|
m_brush = TQBrush();
|
|
m_brushOrigin = TQPoint(0,0);
|
|
m_worldMatrixEnabled = false;
|
|
m_viewportMatrixEnabled = false;
|
|
cairo_matrix_init_identity(&m_worldMatrix);
|
|
cairo_matrix_init_identity(&m_viewportMatrix);
|
|
setCairoTransformations(m_painter);
|
|
setCairoTransformations(m_devicePainter, false, true);
|
|
m_rop = TQPainter::CopyROP;
|
|
m_clipRegion = TQImage();
|
|
m_clipRegionEnabled = false;
|
|
m_worldMatrixStack.clear();
|
|
m_tabStopsValid = false;
|
|
m_tabStopArrayValid = false;
|
|
}
|
|
break;
|
|
case PdcEnd:
|
|
if (m_painter) {
|
|
if (m_transferNeeded) {
|
|
transferIntermediateSurface();
|
|
}
|
|
cairo_destroy(m_painter);
|
|
m_painter = NULL;
|
|
}
|
|
if (m_devicePainter) {
|
|
if (!m_overridePainter) {
|
|
cairo_destroy(m_devicePainter);
|
|
}
|
|
else {
|
|
cairo_set_matrix(m_devicePainter, &m_deviceMatrix);
|
|
}
|
|
m_devicePainter = NULL;
|
|
}
|
|
break;
|
|
case PdcSave:
|
|
cairo_save(m_painter);
|
|
cairo_save(m_devicePainter);
|
|
break;
|
|
case PdcRestore:
|
|
cairo_restore(m_painter);
|
|
cairo_restore(m_devicePainter);
|
|
break;
|
|
case PdcSetBkColor:
|
|
if (p) {
|
|
const TQColor* color = p[0].color;
|
|
if (color) {
|
|
m_bgColor = *color;
|
|
}
|
|
}
|
|
break;
|
|
case PdcSetBkMode:
|
|
if (p) {
|
|
m_bgColorMode = (TQt::BGMode)p[0].ival;
|
|
}
|
|
break;
|
|
case PdcSetROP:
|
|
if ((p) && (m_painter)) {
|
|
if (m_transferNeeded) {
|
|
transferIntermediateSurface();
|
|
}
|
|
|
|
TQt::RasterOp rop = (TQt::RasterOp)p[0].ival;
|
|
m_rop = rop;
|
|
}
|
|
break;
|
|
case PdcSetBrushOrigin:
|
|
if (p) {
|
|
const TQPoint* point = p[0].point;
|
|
if (point) {
|
|
m_brushOrigin = *point;
|
|
}
|
|
}
|
|
break;
|
|
case PdcSetFont:
|
|
if (p) {
|
|
const TQFont* font = p[0].font;
|
|
if (font) {
|
|
m_font = *font;
|
|
}
|
|
}
|
|
break;
|
|
case PdcSetPen:
|
|
if (p) {
|
|
const TQPen* pen = p[0].pen;
|
|
if (pen) {
|
|
m_pen = *pen;
|
|
}
|
|
}
|
|
break;
|
|
case PdcSetBrush:
|
|
if (p) {
|
|
const TQBrush* brush = p[0].brush;
|
|
if (brush) {
|
|
m_brush = *brush;
|
|
}
|
|
}
|
|
break;
|
|
case PdcSetTabStops:
|
|
if (p) {
|
|
int tabspacing = p[0].ival;
|
|
if (tabspacing > 0) {
|
|
// Set up a repeating tab stop pattern
|
|
pango_tab_array_resize(m_tabStops, 2);
|
|
pango_tab_array_set_tab(m_tabStops, 0, PANGO_TAB_LEFT, (tabspacing*1)*PANGO_SCALE);
|
|
pango_tab_array_set_tab(m_tabStops, 1, PANGO_TAB_LEFT, (tabspacing*2)*PANGO_SCALE);
|
|
m_tabStopsValid = true;
|
|
}
|
|
else {
|
|
pango_tab_array_resize(m_tabStops, 0);
|
|
m_tabStopsValid = false;
|
|
}
|
|
}
|
|
break;
|
|
case PdcSetTabArray:
|
|
if (p) {
|
|
int tabcount = p[0].ival;
|
|
if (tabcount > 0) {
|
|
int* tabarray = p[1].ivec;
|
|
pango_tab_array_resize(m_tabStopArray, tabcount);
|
|
int i;
|
|
for (i=0;i<tabcount;i++) {
|
|
pango_tab_array_set_tab(m_tabStopArray, i, PANGO_TAB_LEFT, tabarray[i]*PANGO_SCALE);
|
|
}
|
|
m_tabStopArrayValid = true;
|
|
}
|
|
else {
|
|
pango_tab_array_resize(m_tabStopArray, 0);
|
|
m_tabStopArrayValid = false;
|
|
}
|
|
}
|
|
break;
|
|
case PdcSetVXform:
|
|
if ((p) && (m_painter)) {
|
|
m_viewportMatrixEnabled = p[0].ival;
|
|
setCairoTransformations(m_painter);
|
|
setCairoTransformations(m_devicePainter, false, true);
|
|
}
|
|
break;
|
|
case PdcSetWindow:
|
|
if ((p) && (m_painter) && (pt)) {
|
|
TQRect viewportRect = pt->viewport();
|
|
int wx = p[0].rect->x();
|
|
int wy = p[0].rect->y();
|
|
int ww = p[0].rect->width();
|
|
int wh = p[0].rect->height();
|
|
int vx = viewportRect.x();
|
|
int vy = viewportRect.y();
|
|
int vw = viewportRect.width();
|
|
int vh = viewportRect.height();
|
|
double scaleW = (double)vw/(double)ww;
|
|
double scaleH = (double)vh/(double)wh;
|
|
cairo_matrix_init(&m_viewportMatrix, scaleW, 0, 0, scaleH, vx - wx*scaleW, vy - wy*scaleH);
|
|
setCairoTransformations(m_painter);
|
|
setCairoTransformations(m_devicePainter, false, true);
|
|
}
|
|
break;
|
|
case PdcSetViewport:
|
|
if ((p) && (m_painter) && (pt)) {
|
|
TQRect windowRect = pt->window();
|
|
int wx = windowRect.x();
|
|
int wy = windowRect.y();
|
|
int ww = windowRect.width();
|
|
int wh = windowRect.height();
|
|
int vx = p[0].rect->x();
|
|
int vy = p[0].rect->y();
|
|
int vw = p[0].rect->width();
|
|
int vh = p[0].rect->height();
|
|
double scaleW = (double)vw/(double)ww;
|
|
double scaleH = (double)vh/(double)wh;
|
|
cairo_matrix_init(&m_viewportMatrix, scaleW, 0, 0, scaleH, vx - wx*scaleW, vy - wy*scaleH);
|
|
setCairoTransformations(m_painter);
|
|
setCairoTransformations(m_devicePainter, false, true);
|
|
}
|
|
break;
|
|
case PdcSetWXform:
|
|
if ((p) && (m_painter)) {
|
|
m_worldMatrixEnabled = p[0].ival;
|
|
setCairoTransformations(m_painter);
|
|
setCairoTransformations(m_devicePainter, false, true);
|
|
}
|
|
break;
|
|
case PdcSetWMatrix:
|
|
if ((p) && (m_painter)) {
|
|
const TQWMatrix* tqt3matrix = p[0].matrix;
|
|
if (tqt3matrix) {
|
|
if (p[1].ival) {
|
|
// Combine
|
|
cairo_matrix_t new_matrix;
|
|
cairo_matrix_t original_matrix = m_worldMatrix;
|
|
cairo_matrix_init(&new_matrix, tqt3matrix->m11(), tqt3matrix->m12(), tqt3matrix->m21(), tqt3matrix->m22(), tqt3matrix->dx(), tqt3matrix->dy());
|
|
cairo_matrix_multiply(&m_worldMatrix, &original_matrix, &new_matrix);
|
|
}
|
|
else {
|
|
// Replace
|
|
cairo_matrix_init(&m_worldMatrix, tqt3matrix->m11(), tqt3matrix->m12(), tqt3matrix->m21(), tqt3matrix->m22(), tqt3matrix->dx(), tqt3matrix->dy());
|
|
}
|
|
setCairoTransformations(m_painter);
|
|
setCairoTransformations(m_devicePainter, false, true);
|
|
}
|
|
}
|
|
break;
|
|
case PdcSaveWMatrix:
|
|
if (p) {
|
|
const TQWMatrix* tqt3matrix = p[0].matrix;
|
|
m_worldMatrixStack.push(new TQWMatrix(*tqt3matrix));
|
|
}
|
|
break;
|
|
case PdcRestoreWMatrix:
|
|
if (p) {
|
|
if (!m_worldMatrixStack.isEmpty()) {
|
|
TQWMatrix* matrix = m_worldMatrixStack.pop();
|
|
|
|
// Set world matrix
|
|
TQPDevCmdParam param[2];
|
|
int command = PdcSetWMatrix;
|
|
param[0].matrix = matrix;
|
|
param[1].ival = 0;
|
|
cmd(command, pt, param);
|
|
|
|
delete matrix;
|
|
}
|
|
}
|
|
break;
|
|
case PdcSetClip:
|
|
if ((p) && (m_painter)) {
|
|
if (m_transferNeeded) {
|
|
transferIntermediateSurface();
|
|
}
|
|
m_clipRegionEnabled = p[0].ival;
|
|
}
|
|
break;
|
|
case PdcSetClipRegion:
|
|
if ((p) && (m_painter)) {
|
|
if (m_transferNeeded) {
|
|
transferIntermediateSurface();
|
|
}
|
|
// SLOW
|
|
TQRect tqt3br = p[0].rgn->boundingRect();
|
|
if (!tqt3br.isNull()) {
|
|
m_clipRegion = TQImage(tqt3br.x()+tqt3br.width(), tqt3br.y()+tqt3br.height(), 32);
|
|
int x;
|
|
int y;
|
|
for (x=0; x<m_clipRegion.width(); x++) {
|
|
for (y=0; y<m_clipRegion.height(); y++) {
|
|
TQPoint point(x,y);
|
|
m_clipRegion.setPixel(x, y, (p[0].rgn->contains(point))?0xffffffff:0x00000000);
|
|
}
|
|
}
|
|
m_clipRegionEnabled = true;
|
|
}
|
|
else {
|
|
m_clipRegion = TQImage();
|
|
m_clipRegionEnabled = false;
|
|
}
|
|
}
|
|
break;
|
|
case PdcFlush:
|
|
case PdcFlushRegion:
|
|
if (m_transferNeeded) {
|
|
transferIntermediateSurface();
|
|
}
|
|
default:
|
|
#if defined(QT_CHECK_RANGE)
|
|
tqWarning( "TQt3CairoPaintDevice::cmd: Invalid command %d", c );
|
|
#endif
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*!
|
|
Internal implementation of the virtual TQPaintDevice::metric()
|
|
function.
|
|
|
|
Use the TQPaintDeviceMetrics class instead.
|
|
|
|
A picture has the following hard-coded values: dpi=72,
|
|
numcolors=16777216 and depth=24.
|
|
|
|
\a m is the metric to get.
|
|
*/
|
|
|
|
int TQt3CairoPaintDevice::metric( int m ) const
|
|
{
|
|
int val;
|
|
|
|
if (m_surface) {
|
|
double x_pixels_per_inch;
|
|
double y_pixels_per_inch;
|
|
cairo_format_t format;
|
|
switch ( m ) {
|
|
// ### hard coded dpi and color depth values !
|
|
case TQPaintDeviceMetrics::PdmWidth:
|
|
updateSurfaceDimensions();
|
|
val = m_width;
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmHeight:
|
|
updateSurfaceDimensions();
|
|
val = m_height;
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmWidthMM:
|
|
updateSurfaceDimensions();
|
|
cairo_surface_get_fallback_resolution(m_surface, &x_pixels_per_inch, &y_pixels_per_inch);
|
|
val = ((m_width/x_pixels_per_inch)*25.4);
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmHeightMM:
|
|
updateSurfaceDimensions();
|
|
cairo_surface_get_fallback_resolution(m_surface, &x_pixels_per_inch, &y_pixels_per_inch);
|
|
val = ((m_height/y_pixels_per_inch)*25.4);
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmDpiX:
|
|
cairo_surface_get_fallback_resolution(m_surface, &x_pixels_per_inch, &y_pixels_per_inch);
|
|
val = x_pixels_per_inch;
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmPhysicalDpiX:
|
|
cairo_surface_get_fallback_resolution(m_surface, &x_pixels_per_inch, &y_pixels_per_inch);
|
|
val = x_pixels_per_inch;
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmDpiY:
|
|
cairo_surface_get_fallback_resolution(m_surface, &x_pixels_per_inch, &y_pixels_per_inch);
|
|
val = y_pixels_per_inch;
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmPhysicalDpiY:
|
|
cairo_surface_get_fallback_resolution(m_surface, &x_pixels_per_inch, &y_pixels_per_inch);
|
|
val = y_pixels_per_inch;
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmNumColors:
|
|
format = cairo_image_surface_get_format(m_surface);
|
|
if (format == CAIRO_FORMAT_ARGB32) {
|
|
val = INT_MAX;
|
|
}
|
|
else if (format == CAIRO_FORMAT_RGB24) {
|
|
val = 16777216;
|
|
}
|
|
else if (format == CAIRO_FORMAT_RGB16_565) {
|
|
val = 65536;
|
|
}
|
|
else {
|
|
val = 65536;
|
|
}
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmDepth:
|
|
format = cairo_image_surface_get_format(m_surface);
|
|
if (format == CAIRO_FORMAT_ARGB32) {
|
|
val = 32;
|
|
}
|
|
else if (format == CAIRO_FORMAT_RGB24) {
|
|
val = 24;
|
|
}
|
|
else if (format == CAIRO_FORMAT_RGB16_565) {
|
|
val = 16;
|
|
}
|
|
else {
|
|
val = 16;
|
|
}
|
|
break;
|
|
default:
|
|
val = 0;
|
|
#if defined(QT_CHECK_RANGE)
|
|
tqWarning( "TQt3CairoPaintDevice::metric: Invalid metric command" );
|
|
#endif
|
|
}
|
|
}
|
|
else {
|
|
val = 0;
|
|
#if defined(QT_CHECK_RANGE)
|
|
tqWarning( "TQt3CairoPaintDevice::metric: No Cairo surface available" );
|
|
#endif
|
|
}
|
|
return val;
|
|
}
|
|
|