/**************************************************************************** ** ** Implementation of TQPainter class for X11 ** ** Created : 940112 ** ** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved. ** ** This file is part of the kernel module of the TQt GUI Toolkit. ** ** 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. ** Alternatively you may (at your option) use any later version ** of the GNU General Public License if such license has been ** publicly approved by Trolltech ASA (or its successors, if any) ** and the KDE Free TQt Foundation. ** ** Please review the following information to ensure GNU General ** Public Licensing requirements will be met: ** http://trolltech.com/products/qt/licenses/licensing/opensource/. ** If you are unsure which license is appropriate for your use, please ** review the following information: ** http://trolltech.com/products/qt/licenses/licensing/licensingoverview ** or contact the sales department at sales@trolltech.com. ** ** This file may be used under the terms of the Q Public License as ** defined by Trolltech ASA and appearing in the file LICENSE.TQPL ** included in the packaging of this file. Licensees holding valid TQt ** Commercial licenses may use this file in accordance with the TQt ** Commercial License Agreement provided with the Software. ** ** 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. ** **********************************************************************/ #include "qplatformdefs.h" #include "ntqfont.h" #include "ntqpainter.h" #include "ntqwidget.h" #include "ntqbitmap.h" #include "ntqpixmapcache.h" #include "ntqtextcodec.h" #include "ntqpaintdevicemetrics.h" #include "qt_x11_p.h" #include "qtextlayout_p.h" #include "qfontdata_p.h" #include "qfontengine_p.h" #include "qtextengine_p.h" #include // paintevent magic to provide Windows semantics on X11 static TQRegion* paintEventClipRegion = 0; static TQPaintDevice* paintEventDevice = 0; void qt_set_paintevent_clipping( TQPaintDevice* dev, const TQRegion& region) { if ( !paintEventClipRegion ) paintEventClipRegion = new TQRegion( region ); else *paintEventClipRegion = region; paintEventDevice = dev; } void qt_clear_paintevent_clipping() { delete paintEventClipRegion; paintEventClipRegion = 0; paintEventDevice = 0; } class TQWFlagWidget : public TQWidget { public: void setWState( WFlags f ) { TQWidget::setWState(f); } void clearWState( WFlags f ) { TQWidget::clearWState(f); } void setWFlags( WFlags f ) { TQWidget::setWFlags(f); } void clearWFlags( WFlags f ) { TQWidget::clearWFlags(f); } }; void qt_erase_region( TQWidget* w, const TQRegion& region) { TQRegion reg = region; if ( TQPainter::redirect(w) || (!w->isTopLevel() && w->backgroundPixmap() && w->backgroundOrigin() != TQWidget::WidgetOrigin) ) { TQPoint offset = w->backgroundOffset(); int ox = offset.x(); int oy = offset.y(); bool unclipped = w->testWFlags( TQt::WPaintUnclipped ); if ( unclipped ) ((TQWFlagWidget*)w)->clearWFlags( TQt::WPaintUnclipped ); TQPainter p( w ); p.setClipRegion( region ); // automatically includes paintEventDevice if required if ( w->backgroundPixmap() ) p.drawTiledPixmap( 0, 0, w->width(), w->height(), *w->backgroundPixmap(), ox, oy ); else p.fillRect( w->rect(), w->eraseColor() ); if ( unclipped ) ((TQWFlagWidget*)w)->setWFlags( TQt::WPaintUnclipped ); return; } if ( w == paintEventDevice && paintEventClipRegion ) reg = paintEventClipRegion->intersect( reg ); TQMemArray r = reg.rects(); for (uint i=0; ix11Display(), w->winId(), rr.x(), rr.y(), rr.width(), rr.height(), False ); } } void qt_erase_rect( TQWidget* w, const TQRect& r) { if ( TQPainter::redirect(w) || w == paintEventDevice || w->backgroundOrigin() != TQWidget::WidgetOrigin ) qt_erase_region( w, r ); else XClearArea( w->x11Display(), w->winId(), r.x(), r.y(), r.width(), r.height(), False ); } #ifdef QT_NO_XFTFREETYPE static const TQt::HANDLE rendhd = 0; #endif // hack, so we don't have to make TQRegion::clipRectangles() public or include // X11 headers in ntqregion.h inline void *qt_getClipRects( const TQRegion &r, int &num ) { return r.clipRectangles( num ); } static inline void x11SetClipRegion(Display *dpy, GC gc, GC gc2, TQt::HANDLE draw, const TQRegion &r) { int num; XRectangle *rects = (XRectangle *)qt_getClipRects( r, num ); if (gc) XSetClipRectangles( dpy, gc, 0, 0, rects, num, YXBanded ); if (gc2) XSetClipRectangles( dpy, gc2, 0, 0, rects, num, YXBanded ); #ifndef QT_NO_XFTFREETYPE if (draw) XftDrawSetClipRectangles((XftDraw *) draw, 0, 0, rects, num); #else Q_UNUSED(draw); #endif // QT_NO_XFTFREETYPE } static inline void x11ClearClipRegion(Display *dpy, GC gc, GC gc2, TQt::HANDLE draw) { if (gc) XSetClipMask(dpy, gc, None); if (gc2) XSetClipMask(dpy, gc2, None); #ifndef QT_NO_XFTFREETYPE if (draw) { # ifdef QT_XFT2 XftDrawSetClip((XftDraw *) draw, None); # else // stupid Xft1 Picture pict = XftDrawPicture((XftDraw *) draw); XRenderPictureAttributes pattr; pattr.clip_mask = None; XRenderChangePicture(dpy, pict, CPClipMask, &pattr); # endif // QT_XFT2 } #else Q_UNUSED(draw); #endif // QT_NO_XFTFREETYPE } /***************************************************************************** Trigonometric function for TQPainter We have implemented simple sine and cosine function that are called from TQPainter::drawPie() and TQPainter::drawChord() when drawing the outline of pies and chords. These functions are slower and less accurate than math.h sin() and cos(), but with still around 1/70000th sec. execution time (on a 486DX2-66) and 8 digits accuracy, it should not be the bottleneck in drawing these shapes. The advantage is that you don't have to link in the math library. *****************************************************************************/ const double Q_PI = 3.14159265358979323846; // pi const double Q_2PI = 6.28318530717958647693; // 2*pi const double Q_PI2 = 1.57079632679489661923; // pi/2 #if defined(Q_CC_GNU) && defined(Q_OS_AIX) // AIX 4.2 gcc 2.7.2.3 gets internal error. static int tqRoundAIX( double d ) { return tqRound(d); } #define tqRound tqRoundAIX #endif #if defined(Q_CC_GNU) && defined(__i386__) inline double qcos( double a ) { double r; __asm__ ( "fcos" : "=t" (r) : "0" (a) ); return(r); } inline double qsin( double a ) { double r; __asm__ ( "fsin" : "=t" (r) : "0" (a) ); return(r); } double qsincos( double a, bool calcCos=FALSE ) { return calcCos ? qcos(a) : qsin(a); } #else double qsincos( double a, bool calcCos=FALSE ) { if ( calcCos ) // calculate cosine a -= Q_PI2; if ( a >= Q_2PI || a <= -Q_2PI ) { // fix range: -2*pi < a < 2*pi int m = (int)(a/Q_2PI); a -= Q_2PI*m; } if ( a < 0.0 ) // 0 <= a < 2*pi a += Q_2PI; int sign = a > Q_PI ? -1 : 1; if ( a >= Q_PI ) a = Q_2PI - a; if ( a >= Q_PI2 ) a = Q_PI - a; if ( calcCos ) sign = -sign; double a2 = a*a; // here: 0 <= a < pi/4 double a3 = a2*a; // make taylor sin sum double a5 = a3*a2; double a7 = a5*a2; double a9 = a7*a2; double a11 = a9*a2; return (a-a3/6+a5/120-a7/5040+a9/362880-a11/39916800)*sign; } inline double qsin( double a ) { return qsincos(a, FALSE); } inline double qcos( double a ) { return qsincos(a, TRUE); } #endif /***************************************************************************** TQPainter internal GC (Graphics Context) allocator. The GC allocator offers two functions; alloc_gc() and free_gc() that reuse GC objects instead of calling XCreateGC() and XFreeGC(), which are a whole lot slower. *****************************************************************************/ struct TQGC { GC gc; char in_use; bool mono; int scrn; }; const int gc_array_size = 256; static TQGC gc_array[gc_array_size]; // array of GCs static bool gc_array_init = FALSE; static void init_gc_array() { if ( !gc_array_init ) { memset( gc_array, 0, gc_array_size*sizeof(TQGC) ); gc_array_init = TRUE; } } static void cleanup_gc_array( Display *dpy ) { register TQGC *p = gc_array; int i = gc_array_size; if ( gc_array_init ) { while ( i-- ) { if ( p->gc ) // destroy GC XFreeGC( dpy, p->gc ); p++; } gc_array_init = FALSE; } } // #define DONT_USE_GC_ARRAY static GC alloc_gc( Display *dpy, int scrn, Drawable hd, bool monochrome=FALSE, bool privateGC = FALSE ) { #if defined(DONT_USE_GC_ARRAY) privateGC = TRUE; // will be slower #endif if ( privateGC ) { GC gc = XCreateGC( dpy, hd, 0, 0 ); XSetGraphicsExposures( dpy, gc, False ); return gc; } register TQGC *p = gc_array; int i = gc_array_size; if ( !gc_array_init ) // not initialized init_gc_array(); while ( i-- ) { if ( !p->gc ) { // create GC (once) p->gc = XCreateGC( dpy, hd, 0, 0 ); p->scrn = scrn; XSetGraphicsExposures( dpy, p->gc, False ); p->in_use = FALSE; p->mono = monochrome; } if ( !p->in_use && p->mono == monochrome && p->scrn == scrn ) { p->in_use = TRUE; // available/compatible GC return p->gc; } p++; } #if defined(QT_CHECK_NULL) tqWarning( "TQPainter: Internal error; no available GC" ); #endif GC gc = XCreateGC( dpy, hd, 0, 0 ); XSetGraphicsExposures( dpy, gc, False ); return gc; } static void free_gc( Display *dpy, GC gc, bool privateGC = FALSE ) { #if defined(DONT_USE_GC_ARRAY) privateGC = TRUE; // will be slower #endif if ( privateGC ) { Q_ASSERT( dpy != 0 ); XFreeGC( dpy, gc ); return; } register TQGC *p = gc_array; int i = gc_array_size; if ( gc_array_init ) { while ( i-- ) { if ( p->gc == gc ) { p->in_use = FALSE; // set available XSetClipMask( dpy, gc, None ); // make it reusable XSetFunction( dpy, gc, GXcopy ); XSetFillStyle( dpy, gc, FillSolid ); XSetTSOrigin( dpy, gc, 0, 0 ); return; } p++; } } // not found in gc_array XFreeGC(dpy, gc); } /***************************************************************************** TQPainter internal GC (Graphics Context) cache for solid pens and brushes. The GC cache makes a significant contribution to speeding up drawing. Setting new pen and brush colors will make the painter look for another GC with the same color instead of changing the color value of the GC currently in use. The cache structure is optimized for fast lookup. Only solid line pens with line width 0 and solid brushes are cached. In addition, stored GCs may have an implicit clipping region set. This prevents any drawing outside paint events. Both updatePen() and updateBrush() keep track of the validity of this clipping region by storing the clip_serial number in the cache. *****************************************************************************/ struct TQGCC // cached GC { GC gc; uint pix; int count; int hits; uint clip_serial; int scrn; }; const int gc_cache_size = 29; // multiply by 4 static TQGCC *gc_cache_buf; static TQGCC *gc_cache[4*gc_cache_size]; static bool gc_cache_init = FALSE; static uint gc_cache_clip_serial = 0; static void init_gc_cache() { if ( !gc_cache_init ) { gc_cache_init = TRUE; gc_cache_clip_serial = 0; TQGCC *g = gc_cache_buf = new TQGCC[4*gc_cache_size]; memset( g, 0, 4*gc_cache_size*sizeof(TQGCC) ); for ( int i=0; i<4*gc_cache_size; i++ ) gc_cache[i] = g++; } } // #define GC_CACHE_STAT #if defined(GC_CACHE_STAT) #include "ntqtextstream.h" #include "ntqbuffer.h" static int g_numhits = 0; static int g_numcreates = 0; static int g_numfaults = 0; #endif static void cleanup_gc_cache() { if ( !gc_cache_init ) return; #if defined(GC_CACHE_STAT) tqDebug( "Number of cache hits = %d", g_numhits ); tqDebug( "Number of cache creates = %d", g_numcreates ); tqDebug( "Number of cache faults = %d", g_numfaults ); for ( int i=0; igc ? 'X' : '-') << ',' << g->hits << ',' << g->count << '\t'; } s << '\0'; tqDebug( str ); buf.close(); } #endif delete [] gc_cache_buf; gc_cache_init = FALSE; } static bool obtain_gc( void **ref, GC *gc, uint pix, Display *dpy, int scrn, TQt::HANDLE hd, uint painter_clip_serial ) { if ( !gc_cache_init ) init_gc_cache(); int k = (pix % gc_cache_size) * 4; TQGCC *g = gc_cache[k]; TQGCC *prev = 0; #define NOMATCH (g->gc && (g->pix != pix || g->scrn != scrn || \ (g->clip_serial > 0 && g->clip_serial != painter_clip_serial))) if ( NOMATCH ) { prev = g; g = gc_cache[++k]; if ( NOMATCH ) { prev = g; g = gc_cache[++k]; if ( NOMATCH ) { prev = g; g = gc_cache[++k]; if ( NOMATCH ) { if ( g->count == 0 && g->scrn == scrn) { // steal this GC g->pix = pix; g->count = 1; g->hits = 1; g->clip_serial = 0; XSetForeground( dpy, g->gc, pix ); XSetClipMask(dpy, g->gc, None); gc_cache[k] = prev; gc_cache[k-1] = g; *ref = (void *)g; *gc = g->gc; return TRUE; } else { // all GCs in use #if defined(GC_CACHE_STAT) g_numfaults++; #endif *ref = 0; return FALSE; } } } } } #undef NOMATCH *ref = (void *)g; if ( g->gc ) { // reuse existing GC #if defined(GC_CACHE_STAT) g_numhits++; #endif *gc = g->gc; g->count++; g->hits++; if ( prev && g->hits > prev->hits ) { // maintain LRU order gc_cache[k] = prev; gc_cache[k-1] = g; } return TRUE; } else { // create new GC #if defined(GC_CACHE_STAT) g_numcreates++; #endif g->gc = alloc_gc( dpy, scrn, hd, FALSE ); g->scrn = scrn; g->pix = pix; g->count = 1; g->hits = 1; g->clip_serial = 0; *gc = g->gc; return FALSE; } } static inline void release_gc( void *ref ) { ((TQGCC*)ref)->count--; } /***************************************************************************** TQPainter member functions *****************************************************************************/ /*! \internal Internal function that initializes the painter. */ void TQPainter::initialize() { init_gc_array(); init_gc_cache(); } /*! \internal Internal function that cleans up the painter. */ void TQPainter::cleanup() { cleanup_gc_cache(); cleanup_gc_array( TQPaintDevice::x11AppDisplay() ); TQPointArray::cleanBuffers(); } /*! \internal Internal function that destroys up the painter. */ void TQPainter::destroy() { } void TQPainter::init() { d = 0; flags = IsStartingUp; bg_col = white; // default background color bg_mode = TransparentMode; // default background mode rop = CopyROP; // default ROP tabstops = 0; // default tabbing tabarray = 0; tabarraylen = 0; ps_stack = 0; wm_stack = 0; gc = gc_brush = 0; pdev = 0; dpy = 0; txop = txinv = 0; penRef = brushRef = 0; clip_serial = 0; pfont = 0; block_ext = FALSE; } /*! \fn const TQFont &TQPainter::font() const Returns the currently set painter font. \sa setFont(), TQFont */ /*! Sets the painter's font to \a font. This font is used by subsequent drawText() functions. The text color is the same as the pen color. \sa font(), drawText() */ void TQPainter::setFont( const TQFont &font ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) tqWarning( "TQPainter::setFont: Will be reset by begin()" ); #endif if ( cfont.d != font.d ) { cfont = font; cfont.x11SetScreen( scrn ); setf(DirtyFont); } } void TQPainter::updateFont() { if (!isActive()) return; clearf(DirtyFont); if ( testf(ExtDev) ) { if (pdev->devType() == TQInternal::Printer) { if ( pfont ) delete pfont; pfont = new TQFont( cfont.d, pdev ); } TQPDevCmdParam param[1]; param[0].font = &cfont; if ( !pdev->cmd( TQPaintDevice::PdcSetFont, this, param ) || !hd ) return; } setf(NoCache); if ( penRef ) updatePen(); // force a non-cached GC } void TQPainter::updatePen() { if (!isActive()) return; if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; param[0].pen = &cpen; if ( !pdev->cmd( TQPaintDevice::PdcSetPen, this, param ) || !hd ) return; } int ps = cpen.style(); bool cacheIt = !testf(ClipOn|MonoDev|NoCache) && (ps == NoPen || ps == SolidLine) && cpen.width() == 0 && rop == CopyROP; bool obtained = FALSE; bool internclipok = hasClipping(); if ( cacheIt ) { if ( gc ) { if ( penRef ) release_gc( penRef ); else free_gc( dpy, gc ); } obtained = obtain_gc(&penRef, &gc, cpen.color().pixel(scrn), dpy, scrn, hd, clip_serial); if ( !obtained && !penRef ) gc = alloc_gc( dpy, scrn, hd, FALSE ); } else { if ( gc ) { if ( penRef ) { release_gc( penRef ); penRef = 0; gc = alloc_gc( dpy, scrn, hd, testf(MonoDev) ); } else { internclipok = TRUE; } } else { gc = alloc_gc( dpy, scrn, hd, testf(MonoDev), testf(UsePrivateCx) ); } } if ( !internclipok ) { if ( pdev == paintEventDevice && paintEventClipRegion ) { if ( penRef &&((TQGCC*)penRef)->clip_serial < gc_cache_clip_serial ) { x11SetClipRegion( dpy, gc, 0, rendhd, *paintEventClipRegion ); ((TQGCC*)penRef)->clip_serial = gc_cache_clip_serial; } else if ( !penRef ) { x11SetClipRegion( dpy, gc, 0, rendhd, *paintEventClipRegion ); } } else if (penRef && ((TQGCC*)penRef)->clip_serial ) { x11ClearClipRegion(dpy, gc, 0, rendhd); ((TQGCC*)penRef)->clip_serial = 0; } } if ( obtained ) return; char dashes[10]; // custom pen dashes int dash_len = 0; // length of dash list int s = LineSolid; int cp = CapButt; int jn = JoinMiter; /* We are emulating Windows here. Windows treats cpen.width() == 1 (or 0) as a very special case. The fudge variable unifies this case with the general case. */ int dot = cpen.width(); // width of a dot int fudge = 1; bool allow_zero_lw = TRUE; if ( dot <= 1 ) { dot = 3; fudge = 2; } switch( ps ) { case NoPen: case SolidLine: s = LineSolid; break; case DashLine: dashes[0] = fudge * 3 * dot; dashes[1] = fudge * dot; dash_len = 2; allow_zero_lw = FALSE; break; case DotLine: dashes[0] = dot; dashes[1] = dot; dash_len = 2; allow_zero_lw = FALSE; break; case 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 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; } Q_ASSERT( dash_len <= (int) sizeof(dashes) ); switch ( cpen.capStyle() ) { case SquareCap: cp = CapProjecting; break; case RoundCap: cp = CapRound; break; case FlatCap: default: cp = CapButt; break; } switch ( cpen.joinStyle() ) { case BevelJoin: jn = JoinBevel; break; case RoundJoin: jn = JoinRound; break; case MiterJoin: default: jn = JoinMiter; break; } XSetForeground( dpy, gc, cpen.color().pixel(scrn) ); XSetBackground( dpy, gc, bg_col.pixel(scrn) ); if ( dash_len ) { // make dash list XSetDashes( dpy, gc, 0, dashes, dash_len ); s = bg_mode == TransparentMode ? LineOnOffDash : LineDoubleDash; } XSetLineAttributes( dpy, gc, (! allow_zero_lw && cpen.width() == 0) ? 1 : cpen.width(), s, cp, jn ); } void TQPainter::updateBrush() { if (!isActive()) return; 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 }; if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; param[0].brush = &cbrush; if ( !pdev->cmd( TQPaintDevice::PdcSetBrush, this, param ) || !hd ) return; } int bs = cbrush.style(); bool cacheIt = !testf(ClipOn|MonoDev|NoCache) && (bs == NoBrush || bs == SolidPattern) && bro.x() == 0 && bro.y() == 0 && rop == CopyROP; bool obtained = FALSE; bool internclipok = hasClipping(); if ( cacheIt ) { if ( gc_brush ) { if ( brushRef ) release_gc( brushRef ); else free_gc( dpy, gc_brush ); } obtained = obtain_gc(&brushRef, &gc_brush, cbrush.color().pixel(scrn), dpy, scrn, hd, clip_serial); if ( !obtained && !brushRef ) gc_brush = alloc_gc( dpy, scrn, hd, FALSE ); } else { if ( gc_brush ) { if ( brushRef ) { release_gc( brushRef ); brushRef = 0; gc_brush = alloc_gc( dpy, scrn, hd, testf(MonoDev) ); } else { internclipok = TRUE; } } else { gc_brush = alloc_gc( dpy, scrn, hd, testf(MonoDev), testf(UsePrivateCx)); } } if ( !internclipok ) { if ( pdev == paintEventDevice && paintEventClipRegion ) { if ( brushRef &&((TQGCC*)brushRef)->clip_serial < gc_cache_clip_serial ) { x11SetClipRegion( dpy, gc_brush, 0, rendhd, *paintEventClipRegion ); ((TQGCC*)brushRef)->clip_serial = gc_cache_clip_serial; } else if ( !brushRef ){ x11SetClipRegion( dpy, gc_brush, 0, rendhd, *paintEventClipRegion ); } } else if (brushRef && ((TQGCC*)brushRef)->clip_serial ) { x11ClearClipRegion(dpy, gc_brush, 0, rendhd); ((TQGCC*)brushRef)->clip_serial = 0; } } if ( obtained ) return; const uchar *pat = 0; // pattern int d = 0; // defalt pattern size: d*d int s = FillSolid; if ( bs >= Dense1Pattern && bs <= DiagCrossPattern ) { pat = pat_tbl[ bs-Dense1Pattern ]; if ( bs <= Dense7Pattern ) d = 8; else if ( bs <= CrossPattern ) d = 24; else d = 16; } XSetLineAttributes( dpy, gc_brush, 0, LineSolid, CapButt, JoinMiter ); XSetForeground( dpy, gc_brush, cbrush.color().pixel(scrn) ); XSetBackground( dpy, gc_brush, bg_col.pixel(scrn) ); if ( bs == CustomPattern || pat ) { TQPixmap *pm; if ( pat ) { TQString key; key.sprintf( "$qt-brush$%d", bs ); pm = TQPixmapCache::find( key ); bool del = FALSE; if ( !pm ) { // not already in pm dict pm = new TQBitmap( d, d, pat, TRUE ); TQ_CHECK_PTR( pm ); del = !TQPixmapCache::insert( key, pm ); } if ( cbrush.data->pixmap ) delete cbrush.data->pixmap; cbrush.data->pixmap = new TQPixmap( *pm ); if (del) delete pm; } pm = cbrush.data->pixmap; pm->x11SetScreen( scrn ); if ( pm->depth() == 1 ) { XSetStipple( dpy, gc_brush, pm->handle() ); s = bg_mode == TransparentMode ? FillStippled : FillOpaqueStippled; } else { XSetTile( dpy, gc_brush, pm->handle() ); s = FillTiled; } } XSetFillStyle( dpy, gc_brush, s ); } /*! Begins painting the paint device \a pd and returns TRUE if successful; otherwise returns FALSE. If \a unclipped is TRUE, the painting will not be clipped at the paint device's boundaries, (although this is not supported by all platforms). The errors that can occur are serious problems, such as these: \code p->begin( 0 ); // impossible - paint device cannot be 0 TQPixmap pm( 0, 0 ); p->begin( pm ); // impossible - pm.isNull(); p->begin( myWidget ); p2->begin( myWidget ); // impossible - only one painter at a time \endcode Note that most of the time, you can use one of the constructors instead of begin(), and that end() is automatically done at destruction. \warning A paint device can only be painted by one painter at a time. \sa end(), flush() */ bool TQPainter::begin( const TQPaintDevice *pd, bool unclipped ) { if ( isActive() ) { // already active painting #if defined(QT_CHECK_STATE) tqWarning( "TQPainter::begin: Painter is already active." "\n\tYou must end() the painter before a second begin()" ); #endif return FALSE; } if ( pd == 0 ) { #if defined(QT_CHECK_NULL) tqWarning( "TQPainter::begin: Paint device cannot be null" ); #endif return FALSE; } TQPixmap::x11SetDefaultScreen( pd->x11Screen() ); const TQWidget *copyFrom = 0; pdev = redirect( (TQPaintDevice*)pd ); if ( pdev ) { // redirected paint device? if ( pd->devType() == TQInternal::Widget ) copyFrom = (const TQWidget *)pd; // copy widget settings } else { pdev = (TQPaintDevice*)pd; } if ( pdev->isExtDev() && pdev->paintingActive() ) { // somebody else is already painting #if defined(QT_CHECK_STATE) tqWarning( "TQPainter::begin: Another TQPainter is already painting " "this device;\n\tAn extended paint device can only be " "painted by one TQPainter at a time." ); #endif return FALSE; } bool reinit = flags != IsStartingUp; // 2nd or 3rd etc. time called flags = IsActive | DirtyFont; // init flags int dt = pdev->devType(); // get the device type if ( (pdev->devFlags & TQInternal::ExternalDevice) != 0 ) setf(ExtDev); else if ( dt == TQInternal::Pixmap ) // device is a pixmap ((TQPixmap*)pdev)->detach(); // will modify it dpy = pdev->x11Display(); // get display variable scrn = pdev->x11Screen(); // get screen variable hd = pdev->handle(); // get handle to drawable rendhd = pdev->rendhd; if ( testf(ExtDev) ) { // external device if ( !pdev->cmd( TQPaintDevice::PdcBegin, this, 0 ) ) { // could not begin painting if ( reinit ) clearf( IsActive | DirtyFont ); else flags = IsStartingUp; pdev = 0; return FALSE; } if ( tabstops ) // update tabstops for device setTabStops( tabstops ); if ( tabarray ) // update tabarray for device setTabArray( tabarray ); } if ( pdev->x11Depth() != pdev->x11AppDepth( scrn ) ) { // non-standard depth setf(NoCache); setf(UsePrivateCx); } pdev->painters++; // also tell paint device bro = curPt = TQPoint( 0, 0 ); if ( reinit ) { bg_mode = TransparentMode; // default background mode rop = CopyROP; // default ROP wxmat.reset(); // reset world xform matrix xmat.reset(); ixmat.reset(); txop = txinv = 0; if ( dt != TQInternal::Widget ) { TQFont defaultFont; // default drawing tools TQPen defaultPen; TQBrush defaultBrush; cfont = defaultFont; // set these drawing tools cpen = defaultPen; cbrush = defaultBrush; bg_col = white; // default background color } } wx = wy = vx = vy = 0; // default view origins if ( dt == TQInternal::Widget ) { // device is a widget TQWidget *w = (TQWidget*)pdev; cfont = w->font(); // use widget font cpen = TQPen( w->foregroundColor() ); // use widget fg color if ( reinit ) { TQBrush defaultBrush; cbrush = defaultBrush; } bg_col = w->backgroundColor(); // use widget bg color ww = vw = w->width(); // default view size wh = vh = w->height(); if ( unclipped || w->testWFlags( WPaintUnclipped ) ) { // paint direct on device setf( NoCache ); setf(UsePrivateCx); updatePen(); updateBrush(); XSetSubwindowMode( dpy, gc, IncludeInferiors ); XSetSubwindowMode( dpy, gc_brush, IncludeInferiors ); #ifndef QT_NO_XFTFREETYPE if (rendhd) XftDrawSetSubwindowMode((XftDraw *) rendhd, IncludeInferiors); #endif } } else if ( dt == TQInternal::Pixmap ) { // device is a pixmap TQPixmap *pm = (TQPixmap*)pdev; if ( pm->isNull() ) { #if defined(QT_CHECK_NULL) tqWarning( "TQPainter::begin: Cannot paint null pixmap" ); #endif end(); return FALSE; } bool mono = pm->depth() == 1; // monochrome bitmap if ( mono ) { setf( MonoDev ); bg_col = color0; cpen.setColor( color1 ); } ww = vw = pm->width(); // default view size wh = vh = pm->height(); } else if ( testf(ExtDev) ) { // external device ww = vw = pdev->metric( TQPaintDeviceMetrics::PdmWidth ); wh = vh = pdev->metric( TQPaintDeviceMetrics::PdmHeight ); } if ( ww == 0 ) ww = wh = vw = vh = 1024; if ( copyFrom ) { // copy redirected widget cfont = copyFrom->font(); cpen = TQPen( copyFrom->foregroundColor() ); bg_col = copyFrom->backgroundColor(); } if ( testf(ExtDev) ) { // external device setBackgroundColor( bg_col ); // default background color setBackgroundMode( TransparentMode ); // default background mode setRasterOp( CopyROP ); // default raster operation } clip_serial = gc_cache_clip_serial++; updateBrush(); updatePen(); return TRUE; } /*! Ends painting. Any resources used while painting are released. Note that while you mostly don't need to call end(), the destructor will do it, there is at least one common case when it is needed, namely double buffering. \code TQPainter p( myPixmap, this ) // ... p.end(); // stops drawing on myPixmap p.begin( this ); p.drawPixmap( 0, 0, myPixmap ); \endcode Since you can't draw a TQPixmap while it is being painted, it is necessary to close the active painter. \sa begin(), isActive() */ bool TQPainter::end() // end painting { if ( !isActive() ) { #if defined(QT_CHECK_STATE) tqWarning( "TQPainter::end: Missing begin() or begin() failed" ); #endif return FALSE; } killPStack(); //#### This should not be necessary: if ( pdev->devType() == TQInternal::Widget && // ##### ((TQWidget*)pdev)->testWFlags(WPaintUnclipped) ) { if ( gc ) XSetSubwindowMode( dpy, gc, ClipByChildren ); if ( gc_brush ) XSetSubwindowMode( dpy, gc_brush, ClipByChildren ); } if ( gc_brush ) { // restore brush gc if ( brushRef ) { release_gc( brushRef ); brushRef = 0; } else { free_gc( dpy, gc_brush, testf(UsePrivateCx) ); } gc_brush = 0; } if ( gc ) { // restore pen gc if ( penRef ) { release_gc( penRef ); penRef = 0; } else { free_gc( dpy, gc, testf(UsePrivateCx) ); } gc = 0; } if ( testf(ExtDev) ) pdev->cmd( TQPaintDevice::PdcEnd, this, 0 ); #ifndef QT_NO_XFTFREETYPE if (rendhd) { // reset clipping/subwindow mode on our render picture XftDrawSetClip((XftDraw *) rendhd, None); XftDrawSetSubwindowMode((XftDraw *) rendhd, ClipByChildren); } #endif // QT_NO_XFTFREETYPE if ( pfont ) { delete pfont; pfont = 0; } flags = 0; pdev->painters--; pdev = 0; dpy = 0; return TRUE; } /*! Flushes any buffered drawing operations inside the region \a region using clipping mode \a cm. The flush may update the whole device if the platform does not support flushing to a specified region. \sa flush() CoordinateMode */ void TQPainter::flush(const TQRegion &, CoordinateMode) { flush(); } /*! \overload Flushes any buffered drawing operations. */ void TQPainter::flush() { if ( isActive() && dpy ) XFlush( dpy ); } /*! Sets the background color of the painter to \a c. The background color is the color that is filled in when drawing opaque text, stippled lines and bitmaps. The background color has no effect in transparent background mode (which is the default). \sa backgroundColor() setBackgroundMode() BackgroundMode */ void TQPainter::setBackgroundColor( const TQColor &c ) { if ( !isActive() ) { #if defined(QT_CHECK_STATE) tqWarning( "TQPainter::setBackgroundColor: Call begin() first" ); #endif return; } bg_col = c; if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; param[0].color = &bg_col; if ( !pdev->cmd( TQPaintDevice::PdcSetBkColor, this, param ) || !hd ) return; } if ( !penRef ) updatePen(); // update pen setting if ( !brushRef ) updateBrush(); // update brush setting } /*! Sets the background mode of the painter to \a m, which must be either \c TransparentMode (the default) or \c OpaqueMode. Transparent mode draws stippled lines and text without setting the background pixels. Opaque mode fills these space with the current background color. Note that in order to draw a bitmap or pixmap transparently, you must use TQPixmap::setMask(). \sa backgroundMode(), setBackgroundColor() */ void TQPainter::setBackgroundMode( BGMode m ) { if ( !isActive() ) { #if defined(QT_CHECK_STATE) tqWarning( "TQPainter::setBackgroundMode: Call begin() first" ); #endif return; } if ( m != TransparentMode && m != OpaqueMode ) { #if defined(QT_CHECK_RANGE) tqWarning( "TQPainter::setBackgroundMode: Invalid mode" ); #endif return; } bg_mode = m; if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; param[0].ival = m; if ( !pdev->cmd( TQPaintDevice::PdcSetBkMode, this, param ) || !hd ) return; } if ( !penRef ) updatePen(); // update pen setting if ( !brushRef ) updateBrush(); // update brush setting } static const short ropCodes[] = { // ROP translation table GXcopy, // CopyROP GXor, // OrROP GXxor, // XorROP GXandInverted, // NotAndROP EraseROP GXcopyInverted, // NotCopyROP GXorInverted, // NotOrROP GXequiv, // NotXorROP GXand, // AndROP GXinvert, // NotROP GXclear, // ClearROP GXset, // SetROP GXnoop, // NopROP GXandReverse, // AndNotROP GXorReverse, // OrNotROP GXnand, // NandROP GXnor // NorROP }; /*! Sets the \link TQt::RasterOp raster operation \endlink to \a r. The default is \c CopyROP. \sa rasterOp() TQt::RasterOp */ void TQPainter::setRasterOp( RasterOp r ) { if ( !isActive() ) { #if defined(QT_CHECK_STATE) tqWarning( "TQPainter::setRasterOp: Call begin() first" ); #endif return; } if ( (uint)r > LastROP ) { #if defined(QT_CHECK_RANGE) tqWarning( "TQPainter::setRasterOp: Invalid ROP code" ); #endif return; } rop = r; if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; param[0].ival = r; if ( !pdev->cmd( TQPaintDevice::PdcSetROP, this, param ) || !hd ) return; } if ( penRef ) updatePen(); // get non-cached pen GC if ( brushRef ) updateBrush(); // get non-cached brush GC XSetFunction( dpy, gc, ropCodes[rop] ); XSetFunction( dpy, gc_brush, ropCodes[rop] ); } // ### matthias - true? /*! Sets the brush origin to \a (x, y). The brush origin specifies the (0, 0) coordinate of the painter's brush. This setting only applies to pattern brushes and pixmap brushes. \sa brushOrigin() */ void TQPainter::setBrushOrigin( int x, int y ) { if ( !isActive() ) { #if defined(QT_CHECK_STATE) tqWarning( "TQPainter::setBrushOrigin: Call begin() first" ); #endif return; } bro = TQPoint(x, y); if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; param[0].point = &bro; if ( !pdev->cmd( TQPaintDevice::PdcSetBrushOrigin, this, param ) || !hd ) return; } if ( brushRef ) updateBrush(); // get non-cached brush GC XSetTSOrigin( dpy, gc_brush, x, y ); } /*! Enables clipping if \a enable is TRUE, or disables clipping if \a enable is FALSE. \sa hasClipping(), setClipRect(), setClipRegion() */ void TQPainter::setClipping( bool enable ) { if ( !isActive() ) { #if defined(QT_CHECK_STATE) tqWarning( "TQPainter::setClipping: Will be reset by begin()" ); #endif return; } if ( enable == testf(ClipOn) ) return; setf( ClipOn, enable ); if ( testf(ExtDev) ) { if ( block_ext ) return; TQPDevCmdParam param[1]; param[0].ival = enable; if ( !pdev->cmd( TQPaintDevice::PdcSetClip, this, param ) || !hd ) return; } if ( enable ) { TQRegion rgn = crgn; if ( pdev == paintEventDevice && paintEventClipRegion ) rgn = rgn.intersect( *paintEventClipRegion ); if ( penRef ) updatePen(); if ( brushRef ) updateBrush(); x11SetClipRegion( dpy, gc, gc_brush, rendhd, rgn ); } else { if ( pdev == paintEventDevice && paintEventClipRegion ) { x11SetClipRegion( dpy, gc, gc_brush , rendhd, *paintEventClipRegion ); } else { x11ClearClipRegion(dpy, gc, gc_brush, rendhd); } } } /*! \overload Sets the clip region to the rectangle \a r and enables clipping. The clip mode is set to \a m. \sa CoordinateMode */ void TQPainter::setClipRect( const TQRect &r, CoordinateMode m ) { setClipRegion( TQRegion( r ), m ); } /*! Sets the clip region to \a rgn and enables clipping. The clip mode is set to \a m. Note that the clip region is given in physical device coordinates and \e not subject to any \link coordsys.html coordinate transformation.\endlink \sa setClipRect(), clipRegion(), setClipping() CoordinateMode */ void TQPainter::setClipRegion( const TQRegion &rgn, CoordinateMode m ) { #if defined(QT_CHECK_STATE) if ( !isActive() ) tqWarning( "TQPainter::setClipRegion: Will be reset by begin()" ); #endif if ( m == CoordDevice ) crgn = rgn; else crgn = xmat * rgn; if ( testf(ExtDev) ) { if ( block_ext ) return; TQPDevCmdParam param[2]; param[0].rgn = &rgn; param[1].ival = m; if ( !pdev->cmd( TQPaintDevice::PdcSetClipRegion, this, param ) ) return; // device cannot clip } clearf( ClipOn ); // be sure to update clip rgn setClipping( TRUE ); } /*! \internal Internal function for drawing a polygon. */ void TQPainter::drawPolyInternal( const TQPointArray &a, bool close ) { if ( a.size() < 2 ) return; int x1, y1, x2, y2; // connect last to first point a.point( a.size()-1, &x1, &y1 ); a.point( 0, &x2, &y2 ); bool do_close = close && !(x1 == x2 && y1 == y2); if ( close && cbrush.style() != NoBrush ) { // draw filled polygon XFillPolygon( dpy, hd, gc_brush, (XPoint*)a.shortPoints(), a.size(), Nonconvex, CoordModeOrigin ); if ( cpen.style() == NoPen ) { // draw fake outline XDrawLines( dpy, hd, gc_brush, (XPoint*)a.shortPoints(), a.size(), CoordModeOrigin ); if ( do_close ) XDrawLine( dpy, hd, gc_brush, x1, y1, x2, y2 ); } } if ( cpen.style() != NoPen ) { // draw outline XDrawLines( dpy, hd, gc, (XPoint*)a.shortPoints(), a.size(), CoordModeOrigin); if ( do_close ) XDrawLine( dpy, hd, gc, x1, y1, x2, y2 ); } } /*! Draws/plots a single point at \a (x, y) using the current pen. \sa TQPen */ void TQPainter::drawPoint( int x, int y ) { if ( !isActive() ) return; if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; TQPoint p( x, y ); param[0].point = &p; if ( !pdev->cmd( TQPaintDevice::PdcDrawPoint, this, param ) || !hd ) return; } map( x, y, &x, &y ); } if ( cpen.style() != NoPen ) XDrawPoint( dpy, hd, gc, x, y ); } /*! Draws/plots an array of points, \a a, using the current pen. If \a index is non-zero (the default is zero) only points from \a index are drawn. If \a npoints is negative (the default) the rest of the points from \a index are drawn. If \a npoints is zero or greater, \a npoints points are drawn. \warning On X11, coordinates that do not fit into 16-bit signed values are truncated. This limitation is expected to go away in TQt 4. */ void TQPainter::drawPoints( const TQPointArray& a, int index, int npoints ) { if ( npoints < 0 ) npoints = a.size() - index; if ( index + npoints > (int)a.size() ) npoints = a.size() - index; if ( !isActive() || npoints < 1 || index < 0 ) return; TQPointArray pa = a; if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; for (int i=0; icmd( TQPaintDevice::PdcDrawPoint, this, param )) return; } if ( !hd ) return; } if ( txop != TxNone ) { pa = xForm( a, index, npoints ); if ( pa.size() != a.size() ) { index = 0; npoints = pa.size(); } } } if ( cpen.style() != NoPen ) XDrawPoints( dpy, hd, gc, (XPoint*)(pa.shortPoints( index, npoints )), npoints, CoordModeOrigin ); } /*! \obsolete Sets the current pen position to \a (x, y) \sa lineTo(), pos() */ void TQPainter::moveTo( int x, int y ) { if ( !isActive() ) return; if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; TQPoint p( x, y ); param[0].point = &p; if ( !pdev->cmd( TQPaintDevice::PdcMoveTo, this, param ) || !hd ) return; } } curPt = TQPoint( x, y ); } /*! \obsolete Use drawLine() instead. Draws a line from the current pen position to \a (x, y) and sets \a (x, y) to be the new current pen position. \sa TQPen moveTo(), drawLine(), pos() */ void TQPainter::lineTo( int x, int y ) { if ( !isActive() ) return; int cx = curPt.x(), cy = curPt.y(); curPt = TQPoint( x, y ); if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; TQPoint p( x, y ); param[0].point = &p; if ( !pdev->cmd( TQPaintDevice::PdcLineTo, this, param ) || !hd ) return; } map( x, y, &x, &y ); map( cx, cy, &cx, &cy ); } if ( cpen.style() != NoPen ) XDrawLine( dpy, hd, gc, cx, cy, x, y ); } /*! Draws a line from (\a x1, \a y1) to (\a x2, \a y2) and sets the current pen position to (\a x2, \a y2). \sa pen() */ void TQPainter::drawLine( int x1, int y1, int x2, int y2 ) { if ( !isActive() ) return; curPt = TQPoint( x2, y2 ); if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[2]; TQPoint p1(x1, y1), p2(x2, y2); param[0].point = &p1; param[1].point = &p2; if ( !pdev->cmd( TQPaintDevice::PdcDrawLine, this, param ) || !hd ) return; } map( x1, y1, &x1, &y1 ); map( x2, y2, &x2, &y2 ); } if ( cpen.style() != NoPen ) XDrawLine( dpy, hd, gc, x1, y1, x2, y2 ); } /*! Draws a rectangle with upper left corner at \a (x, y) and with width \a w and height \a h. \sa TQPen, drawRoundRect() */ void TQPainter::drawRect( int x, int y, int w, int h ) { if ( !isActive() ) return; if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; TQRect r( x, y, w, h ); param[0].rect = &r; if ( !pdev->cmd( TQPaintDevice::PdcDrawRect, this, param ) || !hd ) return; } if ( txop == TxRotShear ) { // rotate/shear polygon TQPointArray pa = xmat.mapToPolygon( TQRect(x, y, w, h) ); pa.resize( 5 ); pa.setPoint( 4, pa.point( 0 ) ); drawPolyInternal( pa ); return; } map( x, y, w, h, &x, &y, &w, &h ); } if ( w <= 0 || h <= 0 ) { if ( w == 0 || h == 0 ) return; fix_neg_rect( &x, &y, &w, &h ); } if ( cbrush.style() != NoBrush ) { if ( cpen.style() == NoPen ) { XFillRectangle( dpy, hd, gc_brush, x, y, w, h ); return; } int lw = cpen.width(); int lw2 = (lw+1)/2; if ( w > lw && h > lw ) XFillRectangle( dpy, hd, gc_brush, x+lw2, y+lw2, w-lw-1, h-lw-1 ); } if ( cpen.style() != NoPen ) XDrawRectangle( dpy, hd, gc, x, y, w-1, h-1 ); } /*! \overload Draws a Windows focus rectangle with upper left corner at (\a x, \a y) and with width \a w and height \a h. This function draws a stippled XOR rectangle that is used to indicate keyboard focus (when TQApplication::style() is \c WindowStyle). \warning This function draws nothing if the coordinate system has been \link rotate() rotated\endlink or \link shear() sheared\endlink. \sa drawRect(), TQApplication::style() */ void TQPainter::drawWinFocusRect( int x, int y, int w, int h ) { drawWinFocusRect( x, y, w, h, TRUE, color0 ); } /*! Draws a Windows focus rectangle with upper left corner at (\a x, \a y) and with width \a w and height \a h using a pen color that contrasts with \a bgColor. This function draws a stippled rectangle (XOR is not used) that is used to indicate keyboard focus (when the TQApplication::style() is \c WindowStyle). The pen color used to draw the rectangle is either white or black depending on the color of \a bgColor (see TQColor::gray()). \warning This function draws nothing if the coordinate system has been \link rotate() rotated\endlink or \link shear() sheared\endlink. \sa drawRect(), TQApplication::style() */ void TQPainter::drawWinFocusRect( int x, int y, int w, int h, const TQColor &bgColor ) { drawWinFocusRect( x, y, w, h, FALSE, bgColor ); } /*! \internal */ void TQPainter::drawWinFocusRect( int x, int y, int w, int h, bool xorPaint, const TQColor &bgColor ) { if ( !isActive() || txop == TxRotShear ) return; static char winfocus_line[] = { 1, 1 }; TQPen old_pen = cpen; RasterOp old_rop = (RasterOp)rop; if ( xorPaint ) { if ( TQColor::numBitPlanes() <= 8 ) setPen( color1 ); else setPen( white ); setRasterOp( XorROP ); } else { if ( tqGray( bgColor.rgb() ) < 128 ) setPen( white ); else setPen( black ); } if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; TQRect r( x, y, w, h ); param[0].rect = &r; if ( !pdev->cmd( TQPaintDevice::PdcDrawRect, this, param ) || !hd) { setRasterOp( old_rop ); setPen( old_pen ); return; } } map( x, y, w, h, &x, &y, &w, &h ); } if ( w <= 0 || h <= 0 ) { if ( w == 0 || h == 0 ) return; fix_neg_rect( &x, &y, &w, &h ); } XSetDashes( dpy, gc, 0, winfocus_line, 2 ); XSetLineAttributes( dpy, gc, 1, LineOnOffDash, CapButt, JoinMiter ); XDrawRectangle( dpy, hd, gc, x, y, w-1, h-1 ); XSetLineAttributes( dpy, gc, 0, LineSolid, CapButt, JoinMiter ); setRasterOp( old_rop ); setPen( old_pen ); } /*! Draws a rectangle with rounded corners at \a (x, y), with width \a w and height \a h. The \a xRnd and \a yRnd arguments specify how rounded the corners should be. 0 is angled corners, 99 is maximum roundedness. The width and height include all of the drawn lines. \sa drawRect(), TQPen */ void TQPainter::drawRoundRect( int x, int y, int w, int h, int xRnd, int yRnd ) { if ( !isActive() ) return; if ( xRnd <= 0 || yRnd <= 0 ) { drawRect( x, y, w, h ); // draw normal rectangle return; } if ( xRnd >= 100 ) // fix ranges xRnd = 99; if ( yRnd >= 100 ) yRnd = 99; if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[3]; TQRect r( x, y, w, h ); param[0].rect = &r; param[1].ival = xRnd; param[2].ival = yRnd; if ( !pdev->cmd( TQPaintDevice::PdcDrawRoundRect, this, param ) || !hd ) return; } if ( txop == TxRotShear ) { // rotate/shear polygon 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, xmat ); a[1].makeArc( x, y+h-ryy2, rxx2, ryy2, 2*16*90, 16*90, xmat ); a[2].makeArc( x+w-rxx2, y+h-ryy2, rxx2, ryy2, 3*16*90, 16*90, xmat ); a[3].makeArc( x+w-rxx2, y, rxx2, ryy2, 0*16*90, 16*90, xmat ); // ### 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; ix=px; a->y=py; a->width=w; a->height=h; a->angle1=a1; a->angle2=a2; a++ XArc arcs[4]; XArc *a = arcs; SET_ARC( x+w-rx2, y, rx2, ry2, 0, 90*64 ); SET_ARC( x, y, rx2, ry2, 90*64, 90*64 ); SET_ARC( x, y+h-ry2, rx2, ry2, 180*64, 90*64 ); SET_ARC( x+w-rx2, y+h-ry2, rx2, ry2, 270*64, 90*64 ); XFillArcs( dpy, hd, gc_brush, arcs, 4 ); #undef SET_ARC #define SET_RCT(px, py, w, h) \ r->x=px; r->y=py; r->width=w; r->height=h; r++ XRectangle rects[3]; XRectangle *r = rects; SET_RCT( x+rx, y+dp, w-rx2, ry ); SET_RCT( x+dp, y+ry, w+ds, h-ry2 ); SET_RCT( x+rx, y+h-ry, w-rx2, ry+ds ); XFillRectangles( dpy, hd, gc_brush, rects, 3 ); #undef SET_RCT } if ( cpen.style() != NoPen ) { // draw outline #define SET_ARC(px, py, w, h, a1, a2) \ a->x=px; a->y=py; a->width=w; a->height=h; a->angle1=a1; a->angle2=a2; a++ XArc arcs[4]; XArc *a = arcs; SET_ARC( x+w-rx2, y, rx2, ry2, 0, 90*64 ); SET_ARC( x, y, rx2, ry2, 90*64, 90*64 ); SET_ARC( x, y+h-ry2, rx2, ry2, 180*64, 90*64 ); SET_ARC( x+w-rx2, y+h-ry2, rx2, ry2, 270*64, 90*64 ); XDrawArcs( dpy, hd, gc, arcs, 4 ); #undef SET_ARC #define SET_SEG(xp1, yp1, xp2, yp2) \ s->x1=xp1; s->y1=yp1; s->x2=xp2; s->y2=yp2; s++ XSegment segs[4]; XSegment *s = segs; SET_SEG( x+rx, y, x+w-rx, y ); SET_SEG( x+rx, y+h, x+w-rx, y+h ); SET_SEG( x, y+ry, x, y+h-ry ); SET_SEG( x+w, y+ry, x+w, y+h-ry ); XDrawSegments( dpy, hd, gc, segs, 4 ); #undef SET_SET } } /*! Draws an ellipse with center at \a (x + w/2, y + h/2) and size \a (w, h). */ void TQPainter::drawEllipse( int x, int y, int w, int h ) { if ( !isActive() ) return; if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; TQRect r( x, y, w, h ); param[0].rect = &r; if ( !pdev->cmd( TQPaintDevice::PdcDrawEllipse, this, param ) || !hd ) return; } if ( txop == TxRotShear ) { // rotate/shear polygon TQPointArray a; a.makeArc( x, y, w, h, 0, 360*16, xmat ); drawPolyInternal( a ); return; } map( x, y, w, h, &x, &y, &w, &h ); } if ( w <= 0 || h <= 0 ) { if ( w == 0 || h == 0 ) return; fix_neg_rect( &x, &y, &w, &h ); } if ( w == 1 && h == 1 ) { XDrawPoint( dpy, hd, (cpen.style() == NoPen)?gc_brush:gc, x, y ); return; } w--; h--; if ( cbrush.style() != NoBrush ) { // draw filled ellipse XFillArc( dpy, hd, gc_brush, x, y, w, h, 0, 360*64 ); if ( cpen.style() == NoPen ) { XDrawArc( dpy, hd, gc_brush, x, y, w, h, 0, 360*64 ); return; } } if ( cpen.style() != NoPen ) // draw outline XDrawArc( dpy, hd, gc, x, y, w, h, 0, 360*64 ); } /*! Draws an arc defined by the rectangle \a (x, y, w, h), the start angle \a a and the arc length \a alen. The angles \a a and \a alen are 1/16th of a degree, i.e. a full circle equals 5760 (16*360). Positive values of \a a and \a alen mean counter-clockwise while negative values mean the clockwise direction. Zero degrees is at the 3 o'clock position. Example: \code TQPainter p( myWidget ); p.drawArc( 10,10, 70,100, 100*16, 160*16 ); // draws a "(" arc \endcode \sa drawPie(), drawChord() */ void TQPainter::drawArc( int x, int y, int w, int h, int a, int alen ) { if ( !isActive() ) return; if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[3]; TQRect r( x, y, w, h ); param[0].rect = &r; param[1].ival = a; param[2].ival = alen; if ( !pdev->cmd( TQPaintDevice::PdcDrawArc, this, param ) || !hd ) return; } if ( txop == TxRotShear ) { // rotate/shear TQPointArray pa; pa.makeArc( x, y, w, h, a, alen, xmat ); // arc polyline drawPolyInternal( pa, FALSE ); return; } map( x, y, w, h, &x, &y, &w, &h ); } w--; h--; if ( w <= 0 || h <= 0 ) { if ( w == 0 || h == 0 ) return; fix_neg_rect( &x, &y, &w, &h ); } if ( cpen.style() != NoPen ) XDrawArc( dpy, hd, gc, x, y, w, h, a*4, alen*4 ); } /*! Draws a pie defined by the rectangle \a (x, y, w, h), the start angle \a a and the arc length \a alen. The pie is filled with the current brush(). The angles \a a and \a alen are 1/16th of a degree, i.e. a full circle equals 5760 (16*360). Positive values of \a a and \a alen mean counter-clockwise while negative values mean the clockwise direction. Zero degrees is at the 3 o'clock position. \sa drawArc(), drawChord() */ void TQPainter::drawPie( int x, int y, int w, int h, int a, int alen ) { // 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); } if ( !isActive() ) return; if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[3]; TQRect r( x, y, w, h ); param[0].rect = &r; param[1].ival = a; param[2].ival = alen; if ( !pdev->cmd( TQPaintDevice::PdcDrawPie, this, param ) || !hd ) return; } if ( txop == TxRotShear ) { // rotate/shear TQPointArray pa; pa.makeArc( x, y, w, h, a, alen, xmat ); // arc polyline int n = pa.size(); int cx, cy; xmat.map(x+w/2, y+h/2, &cx, &cy); pa.resize( n+2 ); pa.setPoint( n, cx, cy ); // add legs pa.setPoint( n+1, pa.at(0) ); drawPolyInternal( pa ); return; } map( x, y, w, h, &x, &y, &w, &h ); } XSetArcMode( dpy, gc_brush, ArcPieSlice ); w--; h--; if ( w <= 0 || h <= 0 ) { if ( w == 0 || h == 0 ) return; fix_neg_rect( &x, &y, &w, &h ); } GC g = gc; bool nopen = cpen.style() == NoPen; if ( cbrush.style() != NoBrush ) { // draw filled pie XFillArc( dpy, hd, gc_brush, x, y, w, h, a*4, alen*4 ); if ( nopen ) { g = gc_brush; nopen = FALSE; } } if ( !nopen ) { // draw pie outline double w2 = 0.5*w; // with, height in ellipsis double h2 = 0.5*h; double xc = (double)x+w2; double yc = (double)y+h2; double ra1 = Q_PI/2880.0*a; // convert a, alen to radians double ra2 = ra1 + Q_PI/2880.0*alen; int xic = tqRound(xc); int yic = tqRound(yc); XDrawLine( dpy, hd, g, xic, yic, tqRound(xc + qcos(ra1)*w2), tqRound(yc - qsin(ra1)*h2)); XDrawLine( dpy, hd, g, xic, yic, tqRound(xc + qcos(ra2)*w2), tqRound(yc - qsin(ra2)*h2)); XDrawArc( dpy, hd, g, x, y, w, h, a*4, alen*4 ); } } /*! Draws a chord defined by the rectangle \a (x, y, w, h), the start angle \a a and the arc length \a alen. The chord is filled with the current brush(). The angles \a a and \a alen are 1/16th of a degree, i.e. a full circle equals 5760 (16*360). Positive values of \a a and \a alen mean counter-clockwise while negative values mean the clockwise direction. Zero degrees is at the 3 o'clock position. \sa drawArc(), drawPie() */ void TQPainter::drawChord( int x, int y, int w, int h, int a, int alen ) { if ( !isActive() ) return; if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[3]; TQRect r( x, y, w, h ); param[0].rect = &r; param[1].ival = a; param[2].ival = alen; if ( !pdev->cmd(TQPaintDevice::PdcDrawChord, this, param) || !hd ) return; } if ( txop == TxRotShear ) { // rotate/shear TQPointArray pa; pa.makeArc( x, y, w-1, h-1, a, alen, xmat ); // arc polygon int n = pa.size(); pa.resize( n+1 ); pa.setPoint( n, pa.at(0) ); // connect endpoints drawPolyInternal( pa ); return; } map( x, y, w, h, &x, &y, &w, &h ); } XSetArcMode( dpy, gc_brush, ArcChord ); w--; h--; if ( w <= 0 || h <= 0 ) { if ( w == 0 || h == 0 ) return; fix_neg_rect( &x, &y, &w, &h ); } GC g = gc; bool nopen = cpen.style() == NoPen; if ( cbrush.style() != NoBrush ) { // draw filled chord XFillArc( dpy, hd, gc_brush, x, y, w, h, a*4, alen*4 ); if ( nopen ) { g = gc_brush; nopen = FALSE; } } if ( !nopen ) { // draw chord outline double w2 = 0.5*w; // with, height in ellipsis double h2 = 0.5*h; double xc = (double)x+w2; double yc = (double)y+h2; double ra1 = Q_PI/2880.0*a; // convert a, alen to radians double ra2 = ra1 + Q_PI/2880.0*alen; XDrawLine( dpy, hd, g, tqRound(xc + qcos(ra1)*w2), tqRound(yc - qsin(ra1)*h2), tqRound(xc + qcos(ra2)*w2), tqRound(yc - qsin(ra2)*h2)); XDrawArc( dpy, hd, g, x, y, w, h, a*4, alen*4 ); } XSetArcMode( dpy, gc_brush, ArcPieSlice ); } /*! Draws \a nlines separate lines from points defined in \a a, starting at \a a[index] (\a index defaults to 0). If \a nlines is -1 (the default) all points until the end of the array are used (i.e. (a.size()-index)/2 lines are drawn). Draws the 1st line from \a a[index] to \a a[index+1]. Draws the 2nd line from \a a[index+2] to \a a[index+3] etc. \warning On X11, coordinates that do not fit into 16-bit signed values are truncated. This limitation is expected to go away in TQt 4. \sa drawPolyline(), drawPolygon(), TQPen */ void TQPainter::drawLineSegments( const TQPointArray &a, int index, int nlines ) { if ( nlines < 0 ) nlines = a.size()/2 - index/2; if ( index + nlines*2 > (int)a.size() ) nlines = (a.size() - index)/2; if ( !isActive() || nlines < 1 || index < 0 ) return; TQPointArray pa = a; if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { if ( 2*nlines != (int)pa.size() ) { pa = TQPointArray( nlines*2 ); for ( int i=0; icmd(TQPaintDevice::PdcDrawLineSegments, this, param) || !hd ) return; } if ( txop != TxNone ) { pa = xForm( a, index, nlines*2 ); if ( pa.size() != a.size() ) { index = 0; nlines = pa.size()/2; } } } if ( cpen.style() != NoPen ) XDrawSegments( dpy, hd, gc, (XSegment*)(pa.shortPoints( index, nlines*2 )), nlines ); } /*! Draws the polyline defined by the \a npoints points in \a a starting at \a a[index]. (\a index defaults to 0.) If \a npoints is -1 (the default) all points until the end of the array are used (i.e. a.size()-index-1 line segments are drawn). \warning On X11, coordinates that do not fit into 16-bit signed values are truncated. This limitation is expected to go away in TQt 4. \sa drawLineSegments(), drawPolygon(), TQPen */ void TQPainter::drawPolyline( const TQPointArray &a, int index, int npoints ) { if ( npoints < 0 ) npoints = a.size() - index; if ( index + npoints > (int)a.size() ) npoints = a.size() - index; if ( !isActive() || npoints < 2 || index < 0 ) return; TQPointArray pa = a; if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { if ( npoints != (int)pa.size() ) { pa = TQPointArray( npoints ); for ( int i=0; icmd(TQPaintDevice::PdcDrawPolyline, this, param) || !hd ) return; } if ( txop != TxNone ) { pa = xForm( pa, index, npoints ); if ( pa.size() != a.size() ) { index = 0; npoints = pa.size(); } } } if ( cpen.style() != NoPen ) { while(npoints>65535) { XDrawLines( dpy, hd, gc, (XPoint*)(pa.shortPoints( index, 65535 )), 65535, CoordModeOrigin ); npoints-=65535; index+=65535; } XDrawLines( dpy, hd, gc, (XPoint*)(pa.shortPoints( index, npoints )), npoints, CoordModeOrigin ); } } static int global_polygon_shape = Complex; /*! Draws the polygon defined by the \a npoints points in \a a starting at \a a[index]. (\a index defaults to 0.) If \a npoints is -1 (the default) all points until the end of the array are used (i.e. a.size()-index line segments define the polygon). The first point is always connected to the last point. The polygon is filled with the current brush(). If \a winding is TRUE, the polygon is filled using the winding fill algorithm. If \a winding is FALSE, the polygon is filled using the even-odd (alternative) fill algorithm. \warning On X11, coordinates that do not fit into 16-bit signed values are truncated. This limitation is expected to go away in TQt 4. \sa drawLineSegments(), drawPolyline(), TQPen */ void TQPainter::drawPolygon( const TQPointArray &a, bool winding, int index, int npoints ) { if ( npoints < 0 ) npoints = a.size() - index; if ( index + npoints > (int)a.size() ) npoints = a.size() - index; if ( !isActive() || npoints < 2 || index < 0 ) return; TQPointArray pa = a; if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { if ( npoints != (int)a.size() ) { pa = TQPointArray( npoints ); for ( int i=0; icmd(TQPaintDevice::PdcDrawPolygon, this, param) || !hd ) return; } if ( txop != TxNone ) { pa = xForm( a, index, npoints ); if ( pa.size() != a.size() ) { index = 0; npoints = pa.size(); } } } if ( winding ) // set to winding fill rule XSetFillRule( dpy, gc_brush, WindingRule ); if ( pa[index] != pa[index+npoints-1] ){ // close open pointarray pa.detach(); pa.resize( index+npoints+1 ); pa.setPoint( index+npoints, pa[index] ); npoints++; } if ( cbrush.style() != NoBrush ) { // draw filled polygon XFillPolygon( dpy, hd, gc_brush, (XPoint*)(pa.shortPoints( index, npoints )), npoints, global_polygon_shape, CoordModeOrigin ); } if ( cpen.style() != NoPen ) { // draw outline XDrawLines( dpy, hd, gc, (XPoint*)(pa.shortPoints( index, npoints )), npoints, CoordModeOrigin ); } if ( winding ) // set to normal fill rule XSetFillRule( dpy, gc_brush, EvenOddRule ); } /*! Draws the convex polygon defined by the \a npoints points in \a pa starting at \a pa[index] (\a index defaults to 0). If the supplied polygon is not convex, the results are undefined. On some platforms (e.g. X Window), this is faster than drawPolygon(). \warning On X11, coordinates that do not fit into 16-bit signed values are truncated. This limitation is expected to go away in TQt 4. */ void TQPainter::drawConvexPolygon( const TQPointArray &pa, int index, int npoints ) { global_polygon_shape = Convex; drawPolygon(pa, FALSE, index, npoints); global_polygon_shape = Complex; } /*! Draws a cubic Bezier curve defined by the control points in \a a, starting at \a a[index] (\a index defaults to 0). Control points after \a a[index + 3] are ignored. Nothing happens if there aren't enough control points. \warning On X11, coordinates that do not fit into 16-bit signed values are truncated. This limitation is expected to go away in TQt 4. */ void TQPainter::drawCubicBezier( const TQPointArray &a, int index ) { if ( !isActive() ) return; if ( a.size() - index < 4 ) { #if defined(QT_CHECK_RANGE) tqWarning( "TQPainter::drawCubicBezier: Cubic Bezier needs 4 control " "points" ); #endif return; } TQPointArray pa( a ); if ( index != 0 || a.size() > 4 ) { pa = TQPointArray( 4 ); for ( int i=0; i<4; i++ ) pa.setPoint( i, a.point(index+i) ); } if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[1]; param[0].ptarr = (TQPointArray*)&pa; if ( !pdev->cmd(TQPaintDevice::PdcDrawCubicBezier, this, param) || !hd ) return; } if ( txop != TxNone ) pa = xForm( pa ); } if ( cpen.style() != NoPen ) { pa = pa.cubicBezier(); XDrawLines( dpy, hd, gc, (XPoint*)pa.shortPoints(), pa.size(), CoordModeOrigin ); } } /*! Draws a pixmap at \a (x, y) by copying a part of \a pixmap into the paint device. \a (x, y) specifies the top-left point in the paint device that is to be drawn onto. \a (sx, sy) specifies the top-left point in \a pixmap that is to be drawn. The default is (0, 0). \a (sw, sh) specifies the size of the pixmap that is to be drawn. The default, (-1, -1), means all the way to the bottom right of the pixmap. Currently the mask of the pixmap or it's alpha channel are ignored when painting on a TQPrinter. \sa bitBlt(), TQPixmap::setMask() */ void TQPainter::drawPixmap( int x, int y, const TQPixmap &pixmap, int sx, int sy, int sw, int sh ) { if ( !isActive() || pixmap.isNull() ) return; // right/bottom if ( sw < 0 ) sw = pixmap.width() - sx; if ( sh < 0 ) sh = pixmap.height() - sy; // Sanity-check clipping if ( sx < 0 ) { x -= sx; sw += sx; sx = 0; } if ( sw + sx > pixmap.width() ) sw = pixmap.width() - sx; if ( sy < 0 ) { y -= sy; sh += sy; sy = 0; } if ( sh + sy > pixmap.height() ) sh = pixmap.height() - sy; if ( sw <= 0 || sh <= 0 ) return; if ( pdev->x11Screen() != pixmap.x11Screen() ) { TQPixmap* p = (TQPixmap*) &pixmap; p->x11SetScreen( pdev->x11Screen() ); } TQPixmap::x11SetDefaultScreen( pixmap.x11Screen() ); if ( testf(ExtDev|VxF|WxF) ) { if ( testf(ExtDev) || txop == TxScale || txop == TxRotShear ) { if ( sx != 0 || sy != 0 || sw != pixmap.width() || sh != pixmap.height() ) { TQPixmap tmp( sw, sh, pixmap.depth() ); bitBlt( &tmp, 0, 0, &pixmap, sx, sy, sw, sh, CopyROP, TRUE ); if ( pixmap.mask() ) { TQBitmap mask( sw, sh ); bitBlt( &mask, 0, 0, pixmap.mask(), sx, sy, sw, sh, CopyROP, TRUE ); tmp.setMask( mask ); } drawPixmap( x, y, tmp ); return; } if ( testf(ExtDev) ) { TQPDevCmdParam param[2]; TQRect r(x, y, pixmap.width(), pixmap.height()); param[0].rect = &r; param[1].pixmap = &pixmap; if ( !pdev->cmd(TQPaintDevice::PdcDrawPixmap, this, param) || !hd ) return; } if ( txop == TxScale || txop == TxRotShear ) { TQWMatrix mat( m11(), m12(), m21(), m22(), dx(), dy() ); mat = TQPixmap::trueMatrix( mat, sw, sh ); TQPixmap pm = pixmap.xForm( mat ); if ( !pm.mask() && txop == TxRotShear ) { TQBitmap bm_clip( sw, sh, 1 ); bm_clip.fill( color1 ); pm.setMask( bm_clip.xForm(mat) ); } map( x, y, &x, &y ); // compute position of pixmap int dx, dy; mat.map( 0, 0, &dx, &dy ); uint save_flags = flags; flags = IsActive | (save_flags & ClipOn); drawPixmap( x-dx, y-dy, pm ); flags = save_flags; return; } } map( x, y, &x, &y ); } TQBitmap *mask = (TQBitmap *)pixmap.mask(); bool mono = pixmap.depth() == 1; if ( mask && !hasClipping() && pdev != paintEventDevice ) { if ( mono ) { // needs GCs pen color bool selfmask = pixmap.data->selfmask; if ( selfmask ) { XSetFillStyle( dpy, gc, FillStippled ); XSetStipple( dpy, gc, pixmap.handle() ); } else { XSetFillStyle( dpy, gc, FillOpaqueStippled ); XSetStipple( dpy, gc, pixmap.handle() ); XSetClipMask( dpy, gc, mask->handle() ); XSetClipOrigin( dpy, gc, x-sx, y-sy ); } XSetTSOrigin( dpy, gc, x-sx, y-sy ); XFillRectangle( dpy, hd, gc, x, y, sw, sh ); XSetTSOrigin( dpy, gc, 0, 0 ); XSetFillStyle( dpy, gc, FillSolid ); if ( !selfmask ) { if ( pdev == paintEventDevice && paintEventClipRegion ) { x11SetClipRegion( dpy, gc, 0, rendhd, *paintEventClipRegion ); } else { x11ClearClipRegion(dpy, gc, 0, rendhd); } } } else { bitBlt( pdev, x, y, &pixmap, sx, sy, sw, sh, (RasterOp)rop ); } return; } TQRegion rgn = crgn; if ( mask ) { // pixmap has clip mask // Implies that clipping is on, either explicit or implicit // Create a new mask that combines the mask with the clip region if ( pdev == paintEventDevice && paintEventClipRegion ) { if ( hasClipping() ) rgn = rgn.intersect( *paintEventClipRegion ); else rgn = *paintEventClipRegion; } TQBitmap *comb = new TQBitmap( sw, sh ); comb->detach(); GC cgc = tqt_xget_temp_gc( pixmap.x11Screen(), TRUE ); // get temporary mono GC XSetForeground( dpy, cgc, 0 ); XFillRectangle( dpy, comb->handle(), cgc, 0, 0, sw, sh ); XSetBackground( dpy, cgc, 0 ); XSetForeground( dpy, cgc, 1 ); int num; XRectangle *rects = (XRectangle *)qt_getClipRects( rgn, num ); XSetClipRectangles( dpy, cgc, -x, -y, rects, num, YXBanded ); XSetFillStyle( dpy, cgc, FillOpaqueStippled ); XSetStipple( dpy, cgc, mask->handle() ); XSetTSOrigin( dpy, cgc, -sx, -sy ); XFillRectangle( dpy, comb->handle(), cgc, 0, 0, sw, sh ); XSetTSOrigin( dpy, cgc, 0, 0 ); // restore cgc XSetFillStyle( dpy, cgc, FillSolid ); XSetClipMask( dpy, cgc, None ); mask = comb; // it's deleted below XSetClipMask( dpy, gc, mask->handle() ); XSetClipOrigin( dpy, gc, x, y ); } if ( mono ) { XSetBackground( dpy, gc, bg_col.pixel(scrn) ); XSetFillStyle( dpy, gc, FillOpaqueStippled ); XSetStipple( dpy, gc, pixmap.handle() ); XSetTSOrigin( dpy, gc, x-sx, y-sy ); XFillRectangle( dpy, hd, gc, x, y, sw, sh ); XSetTSOrigin( dpy, gc, 0, 0 ); XSetFillStyle( dpy, gc, FillSolid ); } else { #if !defined(QT_NO_XFTFREETYPE) && !defined(QT_NO_XRENDER) Picture pict = rendhd ? XftDrawPicture((XftDraw *) rendhd) : None; TQPixmap *alpha = pixmap.data->alphapm; if ( pict && pixmap.x11RenderHandle() && alpha && alpha->x11RenderHandle()) { XRenderComposite(dpy, PictOpOver, pixmap.x11RenderHandle(), alpha->x11RenderHandle(), pict, sx, sy, sx, sy, x, y, sw, sh); } else #endif // !QT_NO_XFTFREETYPE && !QT_NO_XRENDER { XCopyArea( dpy, pixmap.handle(), hd, gc, sx, sy, sw, sh, x, y ); } } if ( mask ) { // restore clipping XSetClipOrigin( dpy, gc, 0, 0 ); XSetRegion( dpy, gc, rgn.handle() ); delete mask; // delete comb, created above } } /* Internal, used by drawTiledPixmap */ static void drawTile( TQPainter *p, int x, int y, int w, int h, const TQPixmap &pixmap, int xOffset, int yOffset ) { int yPos, xPos, drawH, drawW, yOff, xOff; yPos = y; yOff = yOffset; while( yPos < y + h ) { drawH = pixmap.height() - yOff; // Cropping first row if ( yPos + drawH > y + h ) // Cropping last row drawH = y + h - yPos; xPos = x; xOff = xOffset; while( xPos < x + w ) { drawW = pixmap.width() - xOff; // Cropping first column if ( xPos + drawW > x + w ) // Cropping last column drawW = x + w - xPos; p->drawPixmap( xPos, yPos, pixmap, xOff, yOff, drawW, drawH ); xPos += drawW; xOff = 0; } yPos += drawH; yOff = 0; } } #if 0 // see comment in drawTiledPixmap /* Internal, used by drawTiledPixmap */ static void fillTile( TQPixmap *tile, const TQPixmap &pixmap ) { bitBlt( tile, 0, 0, &pixmap, 0, 0, -1, -1, TQt::CopyROP, TRUE ); int x = pixmap.width(); while ( x < tile->width() ) { bitBlt( tile, x,0, tile, 0,0, x,pixmap.height(), TQt::CopyROP, TRUE ); x *= 2; } int y = pixmap.height(); while ( y < tile->height() ) { bitBlt( tile, 0,y, tile, 0,0, tile->width(),y, TQt::CopyROP, TRUE ); y *= 2; } } #endif /*! Draws a tiled \a pixmap in the specified rectangle. \a (x, y) specifies the top-left point in the paint device that is to be drawn onto; with the width and height given by \a w and \a h. \a (sx, sy) specifies the top-left point in \a pixmap that is to be drawn. The default is (0, 0). Calling drawTiledPixmap() is similar to calling drawPixmap() several times to fill (tile) an area with a pixmap, but is potentially much more efficient depending on the underlying window system. \sa drawPixmap() */ void TQPainter::drawTiledPixmap( int x, int y, int w, int h, const TQPixmap &pixmap, int sx, int sy ) { int sw = pixmap.width(); int sh = pixmap.height(); if (!sw || !sh ) return; if ( sx < 0 ) sx = sw - -sx % sw; else sx = sx % sw; if ( sy < 0 ) sy = sh - -sy % sh; else sy = sy % sh; /* Requirements for optimizing tiled pixmaps: - not an external device - not scale or rotshear - not mono pixmap - no mask */ TQBitmap *mask = (TQBitmap *)pixmap.mask(); if ( !testf(ExtDev) && txop <= TxTranslate && pixmap.depth() > 1 && mask == 0 ) { if ( txop == TxTranslate ) map( x, y, &x, &y ); #if !defined(QT_NO_XFTFREETYPE) && !defined(QT_NO_XRENDER) Picture pict = rendhd ? XftDrawPicture((XftDraw *) rendhd) : None; TQPixmap *alpha = pixmap.data->alphapm; if (pict && pixmap.x11RenderHandle() && alpha && alpha->x11RenderHandle()) { // this is essentially drawTile() from above, inlined for // the XRenderComposite call int yPos, xPos, drawH, drawW, yOff, xOff; yPos = y; yOff = sy; while( yPos < y + h ) { drawH = pixmap.height() - yOff; // Cropping first row if ( yPos + drawH > y + h ) // Cropping last row drawH = y + h - yPos; xPos = x; xOff = sx; while( xPos < x + w ) { drawW = pixmap.width() - xOff; // Cropping first column if ( xPos + drawW > x + w ) // Cropping last column drawW = x + w - xPos; XRenderComposite(dpy, PictOpOver, pixmap.x11RenderHandle(), alpha->x11RenderHandle(), pict, xOff, yOff, xOff, yOff, xPos, yPos, drawW, drawH); xPos += drawW; xOff = 0; } yPos += drawH; yOff = 0; } return; } #endif // !QT_NO_XFTFREETYPE && !QT_NO_XRENDER XSetTile( dpy, gc, pixmap.handle() ); XSetFillStyle( dpy, gc, FillTiled ); XSetTSOrigin( dpy, gc, x-sx, y-sy ); XFillRectangle( dpy, hd, gc, x, y, w, h ); XSetTSOrigin( dpy, gc, 0, 0 ); XSetFillStyle( dpy, gc, FillSolid ); return; } #if 0 // maybe there'll be point in this again, but for the time all it // does is make trouble for the postscript code. if ( sw*sh < 8192 && sw*sh < 16*w*h ) { int tw = sw; int th = sh; while( th * tw < 4096 && ( th < h || tw < w ) ) { if ( h/th > w/tw ) th *= 2; else tw *= 2; } TQPixmap tile( tw, th, pixmap.depth(), TQPixmap::NormalOptim ); fillTile( &tile, pixmap ); if ( mask ) { TQBitmap tilemask( tw, th, TQPixmap::NormalOptim ); fillTile( &tilemask, *mask ); tile.setMask( tilemask ); } drawTile( this, x, y, w, h, tile, sx, sy ); } else { drawTile( this, x, y, w, h, pixmap, sx, sy ); } #else // for now we'll just output the original and let the postscript // code make what it can of it. qpicture will be unhappy. drawTile( this, x, y, w, h, pixmap, sx, sy ); #endif } #if 0 // // Generate a string that describes a transformed bitmap. This string is used // to insert and find bitmaps in the global pixmap cache. // static TQString gen_text_bitmap_key( const TQWMatrix &m, const TQFont &font, const TQString &str, int pos, int len ) { TQString fk = font.key(); int sz = 4*2 + len*2 + fk.length()*2 + sizeof(double)*6; TQByteArray buf(sz); uchar *p = (uchar *)buf.data(); *((double*)p)=m.m11(); p+=sizeof(double); *((double*)p)=m.m12(); p+=sizeof(double); *((double*)p)=m.m21(); p+=sizeof(double); *((double*)p)=m.m22(); p+=sizeof(double); *((double*)p)=m.dx(); p+=sizeof(double); *((double*)p)=m.dy(); p+=sizeof(double); TQChar h1( '$' ); TQChar h2( 'q' ); TQChar h3( 't' ); TQChar h4( '$' ); *((TQChar*)p)=h1; p+=2; *((TQChar*)p)=h2; p+=2; *((TQChar*)p)=h3; p+=2; *((TQChar*)p)=h4; p+=2; memcpy( (char*)p, (char*)(str.unicode()+pos), len*2 ); p += len*2; memcpy( (char*)p, (char*)fk.unicode(), fk.length()*2 ); p += fk.length()*2; return TQString( (TQChar*)buf.data(), buf.size()/2 ); } static TQBitmap *get_text_bitmap( const TQString &key ) { return (TQBitmap*)TQPixmapCache::find( key ); } static void ins_text_bitmap( const TQString &key, TQBitmap *bm ) { if ( !TQPixmapCache::insert(key, bm) ) // cannot insert pixmap delete bm; } #endif void qt_draw_transformed_rect( TQPainter *p, int x, int y, int w, int h, bool fill ) { XPoint points[5]; int xp = x, yp = y; p->map( xp, yp, &xp, &yp ); points[0].x = xp; points[0].y = yp; xp = x + w; yp = y; p->map( xp, yp, &xp, &yp ); points[1].x = xp; points[1].y = yp; xp = x + w; yp = y + h; p->map( xp, yp, &xp, &yp ); points[2].x = xp; points[2].y = yp; xp = x; yp = y + h; p->map( xp, yp, &xp, &yp ); points[3].x = xp; points[3].y = yp; points[4] = points[0]; if ( fill ) XFillPolygon( p->dpy, p->hd, p->gc, points, 4, Convex, CoordModeOrigin ); else XDrawLines( p->dpy, p->hd, p->gc, points, 5, CoordModeOrigin ); } void qt_draw_background( TQPainter *p, int x, int y, int w, int h ) { if (p->testf(TQPainter::ExtDev)) { if (p->pdev->devType() == TQInternal::Printer) p->fillRect(x, y, w, h, p->bg_col); return; } XSetForeground( p->dpy, p->gc, p->bg_col.pixel(p->scrn) ); qt_draw_transformed_rect( p, x, y, w, h, TRUE); XSetForeground( p->dpy, p->gc, p->cpen.color().pixel(p->scrn) ); } /*! Draws at most \a len characters of the string \a str at position \a (x, y). \a (x, y) is the base line position. Note that the meaning of \a y is not the same for the two drawText() varieties. */ void TQPainter::drawText( int x, int y, const TQString &str, int len, TQPainter::TextDirection dir ) { drawText( x, y, str, 0, len, dir ); } /*! Draws at most \a len characters starting at position \a pos from the string \a str to position \a (x, y). \a (x, y) is the base line position. Note that the meaning of \a y is not the same for the two drawText() varieties. */ void TQPainter::drawText( int x, int y, const TQString &str, int pos, int len, TQPainter::TextDirection dir ) { if ( !isActive() ) return; if (len < 0) len = str.length() - pos; if ( len <= 0 || pos >= (int)str.length() ) // empty string return; if ( pos + len > (int)str.length() ) len = str.length() - pos; if ( testf(DirtyFont) ) { updateFont(); } if ( testf(ExtDev) && pdev->devType() != TQInternal::Printer ) { TQPDevCmdParam param[3]; TQPoint p(x, y); TQString string = str.mid( pos, len ); param[0].point = &p; param[1].str = &string; param[2].ival = TQFont::Latin; if ( !pdev->cmd(TQPaintDevice::PdcDrawText2, this, param) || !hd ) return; } bool simple = (dir == TQPainter::Auto) && str.simpleText(); // we can't take the complete string here as we would otherwise // get quadratic behaviour when drawing long strings in parts. // we do however need some chars around the part we paint to get arabic shaping correct. // ### maybe possible to remove after cursor restrictions work in TQRT int start; int end; if ( simple ) { start = pos; end = pos+len; } else { start = TQMAX( 0, pos - 8 ); end = TQMIN( (int)str.length(), pos + len + 8 ); } TQConstString cstr( str.unicode() + start, end - start ); pos -= start; TQTextEngine engine( cstr.string(), pfont ? pfont->d : cfont.d ); TQTextLayout layout( &engine ); // this is actually what beginLayout does. Inlined here, so we can // avoid the bidi algorithm if we don't need it. engine.itemize( simple ? TQTextEngine::NoBidi|TQTextEngine::SingleLine : TQTextEngine::Full|TQTextEngine::SingleLine ); engine.currentItem = 0; engine.firstItemInLine = -1; if ( dir != Auto ) { int level = dir == RTL ? 1 : 0; for ( int i = engine.items.size(); i >= 0; i-- ) engine.items[i].analysis.bidiLevel = level; } if ( !simple ) { layout.setBoundary( pos ); layout.setBoundary( pos + len ); } // small hack to force skipping of unneeded items start = 0; while ( engine.items[start].position < pos ) ++start; engine.currentItem = start; layout.beginLine( 0xfffffff ); end = start; while ( !layout.atEnd() && layout.currentItem().from() < pos + len ) { layout.addCurrentItem(); end++; } TQFontMetrics fm(fontMetrics()); int ascent = fm.ascent(), descent = fm.descent(); int left, right; layout.endLine( 0, 0, TQt::SingleLine|TQt::AlignLeft, &ascent, &descent, &left, &right ); // do _not_ call endLayout() here, as it would clean up the shaped items and we would do shaping another time // for painting. int textFlags = 0; if ( cfont.d->underline ) textFlags |= TQt::Underline; if ( cfont.d->overline ) textFlags |= TQt::Overline; if ( cfont.d->strikeOut ) textFlags |= TQt::StrikeOut; if ( bg_mode == OpaqueMode ) qt_draw_background( this, x, y-ascent, right-left, ascent+descent+1); for ( int i = start; i < end; i++ ) { TQTextItem ti; ti.item = i; ti.engine = &engine; drawTextItem( x, y - ascent, ti, textFlags ); } layout.d = 0; } /*! \internal Draws the text item \a ti at position \a (x, y ). This method ignores the painters background mode and color. drawText and qt_format_text have to do it themselves, as only they know the extents of the complete string. It ignores the font set on the painter as the text item has one of its own. The underline and strikeout parameters of the text items font are ignored aswell. You'll need to pass in the correct flags to get underlining and strikeout. */ void TQPainter::drawTextItem( int x, int y, const TQTextItem &ti, int textFlags ) { if ( testf(ExtDev) ) { TQPDevCmdParam param[2]; TQPoint p(x, y); param[0].point = &p; param[1].textItem = &ti; bool retval = pdev->cmd(TQPaintDevice::PdcDrawTextItem, this, param); if ( !retval || !hd ) return; } TQTextEngine *engine = ti.engine; TQScriptItem *si = &engine->items[ti.item]; engine->shape( ti.item ); TQFontEngine *fe = si->fontEngine; assert( fe != 0 ); x += si->x; y += si->y; fe->draw( this, x, y, engine, si, textFlags ); } #if TQT_VERSION >= 0x040000 #error "remove current position and associated methods" #endif /*! \obsolete Returns the current position of the pen. \sa moveTo() */ TQPoint TQPainter::pos() const { return curPt; }