diff options
Diffstat (limited to 'doc/html/qgfx_qws-h.html')
| -rw-r--r-- | doc/html/qgfx_qws-h.html | 493 |
1 files changed, 493 insertions, 0 deletions
diff --git a/doc/html/qgfx_qws-h.html b/doc/html/qgfx_qws-h.html new file mode 100644 index 000000000..4551ca62a --- /dev/null +++ b/doc/html/qgfx_qws-h.html @@ -0,0 +1,493 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> +<!-- /home/espenr/tmp/qt-3.3.8-espenr-2499/qt-x11-free-3.3.8/include/qgfx_qws.h:1 --> +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> +<title>qgfx_qws.h Include File</title> +<style type="text/css"><!-- +fn { margin-left: 1cm; text-indent: -1cm; } +a:link { color: #004faf; text-decoration: none } +a:visited { color: #672967; text-decoration: none } +body { background: #ffffff; color: black; } +--></style> +</head> +<body> + +<table border="0" cellpadding="0" cellspacing="0" width="100%"> +<tr bgcolor="#E5E5E5"> +<td valign=center> + <a href="index.html"> +<font color="#004faf">Home</font></a> + | <a href="classes.html"> +<font color="#004faf">All Classes</font></a> + | <a href="mainclasses.html"> +<font color="#004faf">Main Classes</font></a> + | <a href="annotated.html"> +<font color="#004faf">Annotated</font></a> + | <a href="groups.html"> +<font color="#004faf">Grouped Classes</font></a> + | <a href="functions.html"> +<font color="#004faf">Functions</font></a> +</td> +<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><h1 align=center>qgfx_qws.h</h1> + +<p>This is the verbatim text of the qgfx_qws.h include file. It is provided only for illustration; the copyright remains with Trolltech. +<hr> +<pre> +/**************************************************************************** +** $Id: qt/qgfx_qws.h 3.3.8 edited Jan 11 14:38 $ +** +** Definition of TQGfx (graphics context) class +** +** Created : 940721 +** +** Copyright (C) 1992-2007 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 file LICENSE.GPL 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 retquirements 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 [email protected]. +** +** 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. +** +**********************************************************************/ + +#ifndef TQGFX_QWS_H +#define TQGFX_QWS_H + +#ifndef QT_H +#include "qwidget.h" +#include "qnamespace.h" +#include "qimage.h" +#include "qfontmanager_qws.h" +#include "qmemorymanager_qws.h" +#include "qpoint.h" +#endif // QT_H + +#include <private/qtextengine_p.h> + +class TQScreenCursor; + +#if !defined( QT_NO_IMAGE_16_BIT ) || !defined( QT_NO_QWS_DEPTH_16 ) +# ifndef QT_QWS_DEPTH16_RGB +# define QT_QWS_DEPTH16_RGB 565 +# endif +static const int qt_rbits = (QT_QWS_DEPTH16_RGB/100); +static const int qt_gbits = (QT_QWS_DEPTH16_RGB/10%10); +static const int qt_bbits = (QT_QWS_DEPTH16_RGB%10); +static const int qt_red_shift = qt_bbits+qt_gbits-(8-qt_rbits); +static const int qt_green_shift = qt_bbits-(8-qt_gbits); +static const int qt_neg_blue_shift = 8-qt_bbits; +static const int qt_blue_mask = (1<<qt_bbits)-1; +static const int qt_green_mask = (1<<(qt_gbits+qt_bbits))-((1<<qt_bbits)-1); +static const int qt_red_mask = (1<<(qt_rbits+qt_gbits+qt_bbits))-(1<<(qt_gbits+qt_bbits)); + +inline ushort qt_convRgbTo16( const int r, const int g, const int b ) +{ + const int tr = r << qt_red_shift; + const int tg = g << qt_green_shift; + const int tb = b >> qt_neg_blue_shift; + + return (tb & qt_blue_mask) | (tg & qt_green_mask) | (tr & qt_red_mask); +} + +inline ushort qt_convRgbTo16( TQRgb c ) +{ + const int tr = qRed(c) << qt_red_shift; + const int tg = qGreen(c) << qt_green_shift; + const int tb = qBlue(c) >> qt_neg_blue_shift; + + return (tb & qt_blue_mask) | (tg & qt_green_mask) | (tr & qt_red_mask); +} + +inline TQRgb qt_conv16ToRgb( ushort c ) +{ + const int r=(c & qt_red_mask); + const int g=(c & qt_green_mask); + const int b=(c & qt_blue_mask); + const int tr = r >> qt_red_shift; + const int tg = g >> qt_green_shift; + const int tb = b << qt_neg_blue_shift; + + return qRgb(tr,tg,tb); +} + +inline void qt_conv16ToRgb( ushort c, int& r, int& g, int& b ) +{ + const int tr=(c & qt_red_mask); + const int tg=(c & qt_green_mask); + const int tb=(c & qt_blue_mask); + r = tr >> qt_red_shift; + g = tg >> qt_green_shift; + b = tb << qt_neg_blue_shift; +} +#endif + + +const int SourceSolid=0; +const int SourcePixmap=1; + +#ifndef QT_NO_QWS_CURSOR + +extern bool qt_sw_cursor; + +class TQGfxRasterBase; + +#define SW_CURSOR_DATA_SIZE 4096 // 64x64 8-bit cursor + +struct SWCursorData { + unsigned char cursor[SW_CURSOR_DATA_SIZE]; + unsigned char under[SW_CURSOR_DATA_SIZE*4]; // room for 32bpp display + TQRgb clut[256]; + unsigned char translut[256]; + int colors; + int width; + int height; + int x; + int y; + int hotx; + int hoty; + bool enable; + TQRect bound; +}; + + +class TQScreenCursor +{ +public: + TQScreenCursor( ); + virtual ~TQScreenCursor(); + + virtual void init(SWCursorData *da, bool init = FALSE); + + virtual void set( const TQImage &image, int hotx, int hoty ); + virtual void move( int x, int y ); + virtual void show(); + virtual void hide(); + + virtual bool restoreUnder( const TQRect &r, TQGfxRasterBase *g = 0 ); + virtual void saveUnder(); + virtual void drawCursor(); + //void draw(); + virtual bool supportsAlphaCursor(); + + static bool enabled() { return qt_sw_cursor; } + +protected: + TQGfxRasterBase *gfx; + TQGfxRasterBase *gfxunder; + + TQImage *imgunder; + TQImage *cursor; + + uchar *fb_start; + uchar *fb_end; + bool save_under; + SWCursorData *data; + + int clipWidth; + int clipHeight; + int myoffset; + +}; + +extern TQScreenCursor * qt_screencursor; + +#endif // QT_NO_QWS_CURSOR + +struct fb_cmap; + +// A (used) chunk of offscreen memory + +class TQPoolEntry +{ +public: + unsigned int start; + unsigned int end; + int clientId; +}; + +class TQScreen; +typedef void(*ClearCacheFunc)(TQScreen *obj, int); + +class TQScreen { + +public: + + TQScreen( int display_id ); + virtual ~TQScreen(); + virtual bool initDevice() = 0; + virtual bool connect( const TQString &displaySpec ) = 0; + virtual void disconnect() = 0; + virtual int initCursor(void *, bool=FALSE); + virtual void shutdownDevice(); + virtual void setMode(int,int,int) = 0; + virtual bool supportsDepth(int) const; + virtual TQGfx * createGfx(unsigned char *,int,int,int,int); + virtual TQGfx * screenGfx(); + virtual void save(); + virtual void restore(); + virtual void blank(bool on); + + virtual int pixmapOffsetAlignment() { return 64; } + virtual int pixmapLinestepAlignment() { return 64; } + virtual int sharedRamSize(void *) { return 0; } + + virtual bool onCard(unsigned char *) const; + virtual bool onCard(unsigned char *, ulong& out_offset) const; + + // sets a single color in the colormap + virtual void set(unsigned int,unsigned int,unsigned int,unsigned int); + // allocates a color + virtual int alloc(unsigned int,unsigned int,unsigned int); + + int width() const { return w; } + int height() const { return h; } + int depth() const { return d; } + virtual int pixmapDepth() const; + int pixelType() const { return pixeltype; } + int linestep() const { return lstep; } + int deviceWidth() const { return dw; } + int deviceHeight() const { return dh; } + uchar * base() const { return data; } + // Ask for memory from card cache with alignment + virtual uchar * cache(int,int) { return 0; } + virtual void uncache(uchar *) {} + + int screenSize() const { return size; } + int totalSize() const { return mapsize; } + + TQRgb * clut() { return screenclut; } + int numCols() { return screencols; } + + virtual TQSize mapToDevice( const TQSize & ) const; + virtual TQSize mapFromDevice( const TQSize & ) const; + virtual TQPoint mapToDevice( const TQPoint &, const TQSize & ) const; + virtual TQPoint mapFromDevice( const TQPoint &, const TQSize & ) const; + virtual TQRect mapToDevice( const TQRect &, const TQSize & ) const; + virtual TQRect mapFromDevice( const TQRect &, const TQSize & ) const; + virtual TQImage mapToDevice( const TQImage & ) const; + virtual TQImage mapFromDevice( const TQImage & ) const; + virtual TQRegion mapToDevice( const TQRegion &, const TQSize & ) const; + virtual TQRegion mapFromDevice( const TQRegion &, const TQSize & ) const; + virtual int transformOrientation() const; + virtual bool isTransformed() const; + virtual bool isInterlaced() const; + + virtual void setDirty( const TQRect& ); + + virtual int memoryNeeded(const TQString&); + + int * opType() { return screen_optype; } + int * lastOp() { return screen_lastop; } + + virtual void haltUpdates(); + virtual void resumeUpdates(); + +protected: + + // Only used without QT_NO_QWS_REPEATER, but included so that + // it's binary compatible regardless. + int * screen_optype; + int * screen_lastop; + + TQRgb screenclut[256]; + int screencols; + + bool initted; + + uchar * data; + + // Table of allocated lumps, kept in sorted highest-to-lowest order + // The table itself is allocated at the bottom of offscreen memory + // i.e. it's similar to having a stack (the table) and a heap + // (the allocated blocks). Freed space is implicitly described + // by the gaps between the allocated lumps (this saves entries and + // means we don't need to worry about coalescing freed lumps) + + TQPoolEntry * entries; + int * entryp; + unsigned int * lowest; + + int w; + int lstep; + int h; + int d; + int pixeltype; + bool grayscale; + + int dw; + int dh; + + int hotx; + int hoty; + TQImage cursor; + + int size; // Screen size + int mapsize; // Total mapped memory + + int displayId; + + friend class TQWSServer; + static ClearCacheFunc clearCacheFunc; +}; + +extern TQScreen * qt_screen; + +class Q_EXPORT TQGfx : public TQt { +public: + // With loadable drivers, do probe here + static TQGfx *createGfx( int depth, unsigned char *buffer, + int w, int h, int linestep ); + + virtual ~TQGfx() {} + + virtual void setPen( const TQPen & )=0; + virtual void setBrush( const TQBrush & )=0; + virtual void setBrushPixmap( const TQPixmap * )=0; + virtual void setBrushOffset( int, int ) = 0; + virtual void setClipRect( int,int,int,int )=0; + virtual void setClipRegion( const TQRegion & )=0; + virtual void setClipDeviceRegion( const TQRegion & )=0; + virtual void setClipping (bool)=0; + // These will be called from qwidget_qws or qwidget_mac + // to update the drawing area when a widget is moved + virtual void setOffset( int,int )=0; + virtual void setWidgetRect( int,int,int,int )=0; + virtual void setWidgetRegion( const TQRegion & )=0; + virtual void setWidgetDeviceRegion( const TQRegion & )=0; + virtual void setSourceWidgetOffset(int x, int y) = 0; + virtual void setGlobalRegionIndex( int idx ) = 0; + + virtual void setDashedLines(bool d) = 0; + virtual void setDashes(char *, int) = 0; + + virtual void setOpaqueBackground(bool b)=0; + virtual void setBackgroundColor(TQColor c)=0; + + // Drawing operations + virtual void drawPoint( int,int )=0; + virtual void drawPoints( const TQPointArray &,int,int )=0; + virtual void moveTo( int,int )=0; + virtual void lineTo( int,int )=0; + virtual void drawLine( int,int,int,int )=0; + virtual void drawPolyline( const TQPointArray &,int,int )=0; + + // current position + virtual TQPoint pos() const = 0; + + // Fill operations - these use the current source (pixmap, + // color, etc), and draws outline + virtual void fillRect( int,int,int,int )=0; + virtual void drawPolygon( const TQPointArray &,bool,int,int )=0; + + virtual void setLineStep(int)=0; + + // Special case of rect-with-pixmap-fill for speed/hardware acceleration + virtual void blt( int,int,int,int,int,int )=0; + virtual void scroll( int,int,int,int,int,int )=0; + +#if !defined(QT_NO_MOVIE) || !defined(QT_NO_TRANSFORMATIONS) || !defined(QT_NO_PIXMAP_TRANSFORMATION) + virtual void stretchBlt( int,int,int,int,int,int )=0; +#endif + virtual void tiledBlt( int,int,int,int )=0; + + enum SourceType { SourcePen, SourceImage, SourceAccel }; + enum PixelType { NormalPixel, BGRPixel }; + + // Setting up source data - can be solid color or pixmap data + virtual void setSource(const TQPaintDevice *)=0; + virtual void setSource(const TQImage *)=0; + virtual void setSource(unsigned char *,int,int,int,int,TQRgb *,int); + // This one is pen + virtual void setSourcePen()=0; + + virtual void drawAlpha(int,int,int,int,int,int,int,int) {} + + virtual void hsync(int) {} + + // These apply only to blt's. For alpha values for general + // drawing operations we should probably have a separate TQGfx + // class. It's not a high priority though. + + // Enum values: Ignore alpha information, alpha information encoded in + // 32-bit rgba along with colors, alpha information in 8bpp + // format in alphabits + + enum AlphaType { IgnoreAlpha, InlineAlpha, SeparateAlpha, + LittleEndianMask, BigEndianMask, SolidAlpha }; + + // Can be no alpha, inline (32bit data), separate (for images), + // LittleEndianMask/BigEndianMask 1bpp masks, constant alpha + // value + virtual void setAlphaType(AlphaType)=0; + // Pointer to data, linestep + virtual void setAlphaSource(unsigned char *,int)=0; + virtual void setAlphaSource(int,int=-1,int=-1,int=-1)=0; + + virtual void drawGlyphs( TQMemoryManager::FontID font, glyph_t *glyphs, TQPoint *positions, int num_glyphs ) = 0; + + virtual void setClut(TQRgb *,int)=0; + + // Save and restore pen and brush state - necessary when setting + // up a bitBlt for example + virtual void save()=0; + virtual void restore()=0; + + virtual void setRop(RasterOp)=0; + virtual void setScreen(TQScreen *,TQScreenCursor *,bool,int *,int *); + void setShared(void * v) { shared_data=v; } + bool isScreenGfx() { return is_screen_gfx; } //for cursor.. + +protected: + bool is_screen_gfx; + void * shared_data; + +}; + + +// This lives in loadable modules + +#ifndef QT_LOADABLE_MODULES +extern "C" TQScreen * qt_get_screen( int display_id, const char* spec ); +#endif + +// This is in main lib, loads the right module, calls qt_get_screen +// In non-loadable cases just aliases to qt_get_screen + +const unsigned char * qt_probe_bus(); + +#endif // TQGFX_QWS_H + + + + +</pre> +<!-- eof --> +<p><address><hr><div align=center> +<table width=100% cellspacing=0 border=0><tr> +<td>Copyright © 2007 +<a href="troll.html">Trolltech</a><td align=center><a href="trademarks.html">Trademarks</a> +<td align=right><div align=right>TQt 3.3.8</div> +</table></div></address></body> +</html> |