You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
497 lines
14 KiB
497 lines
14 KiB
/****************************************************************************
|
|
**
|
|
** Definition of TQPixmap class
|
|
**
|
|
** Created : 940501
|
|
**
|
|
** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
|
|
**
|
|
** 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.
|
|
**
|
|
**********************************************************************/
|
|
|
|
#ifndef TQPIXMAP_H
|
|
#define TQPIXMAP_H
|
|
|
|
#include "tqtglobaldefines.h"
|
|
|
|
#ifndef TQT_H
|
|
#include "tqpaintdevice.h"
|
|
#include "tqcolor.h" // char*->TQColor conversion
|
|
#include "tqstring.h" // char*->TQString conversion
|
|
#include "tqnamespace.h"
|
|
#endif // TQT_H
|
|
|
|
class TQGfx;
|
|
class TQPixmapPrivate;
|
|
|
|
#if defined(TQ_WS_WIN)
|
|
// Internal pixmap memory optimization class for Windows 9x
|
|
class TQMultiCellPixmap;
|
|
#endif
|
|
|
|
#ifdef USE_QT4
|
|
|
|
#include <Qt/qpixmap.h>
|
|
#include <Qt/qbitmap.h>
|
|
|
|
class TQBitmap;
|
|
|
|
// #include "tqimage.h"
|
|
|
|
#endif // USE_QT4
|
|
|
|
#ifdef USE_QT4
|
|
|
|
class TQ_EXPORT TQPixmap : public QPixmap, virtual public TQt
|
|
{
|
|
public:
|
|
enum ColorMode { Auto, Color, Mono };
|
|
enum Optimization { DefaultOptim, NoOptim, MemoryOptim=NoOptim, NormalOptim, BestOptim };
|
|
|
|
TQPixmap();
|
|
TQPixmap( const QImage& image );
|
|
TQPixmap( int w, int h, int depth = -1, Optimization o=DefaultOptim );
|
|
TQPixmap( const QSize &s, int depth = -1, Optimization o=DefaultOptim );
|
|
#ifndef TQT_NO_IMAGEIO
|
|
TQPixmap( const QString& fileName, const char *format=0, ColorMode mode=Auto );
|
|
TQPixmap( const QString& fileName, const char *format, int conversion_flags );
|
|
TQPixmap( const char *xpm[] );
|
|
TQPixmap( const QByteArray &data );
|
|
#endif
|
|
TQPixmap( const TQPixmap &p );
|
|
TQPixmap( const QPixmap p );
|
|
virtual ~TQPixmap();
|
|
|
|
#ifndef TQT_NO_MIME
|
|
static TQPixmap fromMimeSource( const TQString& abs_name );
|
|
#endif
|
|
|
|
#ifndef TQT_NO_IMAGE_HEURISTIC_MASK
|
|
TQBitmap createHeuristicMask( bool clipTight = TRUE ) const;
|
|
#endif
|
|
|
|
const TQBitmap *mask() const;
|
|
TQImage convertToImage() const;
|
|
bool selfMask() const;
|
|
|
|
// inline QImage convertToImage() const { return toImage(); }
|
|
// bool convertFromImage(const QImage &, ColorMode mode); // Needs some code in the cpp file...
|
|
bool convertFromImage(const QImage &img, Qt::ImageConversionFlags flags = Qt::AutoColor);
|
|
bool convertFromImage(const QImage &img, int flags);
|
|
|
|
operator TQImage() const;
|
|
// inline operator TQImage() const { return toImage(); }
|
|
TQPixmap xForm(const QMatrix &matrix) const;
|
|
|
|
// These four functions no longer have any purpose
|
|
// inline Optimization optimization() const {}
|
|
void setOptimization( Optimization );
|
|
// inline static Optimization defaultOptimization() {}
|
|
static void setDefaultOptimization( Optimization );
|
|
|
|
private:
|
|
void resize_helper(const QSize s);
|
|
public:
|
|
void resize(const QSize s);
|
|
void resize(int width, int height);
|
|
|
|
// From TQQPaintDevice
|
|
public:
|
|
static void *x11AppVisual( void );
|
|
static void *x11AppVisual( int screen );
|
|
static int x11AppCells( void );
|
|
static int x11AppCells( int screen );
|
|
static int x11AppDepth( void );
|
|
static int x11AppDepth( int screen );
|
|
static Display *x11AppDisplay( void );
|
|
static int x11AppScreen( void );
|
|
static bool x11AppDefaultVisual( void );
|
|
static bool x11AppDefaultVisual( int screen );
|
|
static TQt::HANDLE x11AppColormap( void );
|
|
static TQt::HANDLE x11AppColormap( int screen );
|
|
static bool x11AppDefaultColormap( void );
|
|
static bool x11AppDefaultColormap( int screen );
|
|
static TQt::HANDLE x11AppRootWindow( void );
|
|
static TQt::HANDLE x11AppRootWindow( int screen );
|
|
|
|
#if defined(TQ_WS_X11)
|
|
Display *x11Display() const;
|
|
int x11Screen() const;
|
|
int x11Depth() const;
|
|
int x11Cells() const;
|
|
Qt::HANDLE x11Colormap() const;
|
|
bool x11DefaultColormap() const;
|
|
void *x11Visual() const;
|
|
bool x11DefaultVisual() const;
|
|
|
|
static int x11AppDpiX(int screen = -1);
|
|
static int x11AppDpiY(int screen = -1);
|
|
static void x11SetAppDpiX(int, int);
|
|
static void x11SetAppDpiY(int, int);
|
|
#endif
|
|
|
|
// Windows: get tqdevice context
|
|
// X-Windows: get drawable
|
|
#if defined(TQ_WS_WIN)
|
|
// virtual HDC handle() const;
|
|
#elif defined(TQ_WS_X11)
|
|
virtual TQt::HANDLE handle() const;
|
|
virtual TQt::HANDLE x11RenderHandle() const;
|
|
#elif defined(TQ_WS_MAC)
|
|
// virtual TQt::HANDLE handle() const;
|
|
#elif defined(TQ_WS_TQWS)
|
|
// virtual TQt::HANDLE handle() const;
|
|
#endif
|
|
|
|
private:
|
|
mutable TQBitmap* tqt_tqbitmap_ptr;
|
|
|
|
public:
|
|
// Interoperability
|
|
static const TQPixmap& convertFromQPixmap( QPixmap& qpm );
|
|
};
|
|
|
|
// Interoperability
|
|
inline static const TQPixmap& convertFromQPixmap( const QPixmap& qpm ) {
|
|
return (*static_cast<const TQPixmap*>(&qpm));
|
|
}
|
|
|
|
void copyBlt(QPixmap *dst, int dx, int dy, const QPixmap *src, int sx=0, int sy=0, int sw=-1, int sh=-1);
|
|
|
|
#ifndef TQT_NO_PIXMAP_TRANSFORMATION
|
|
# define TQT_XFORM_TYPE_MSBFIRST 0
|
|
# define TQT_XFORM_TYPE_LSBFIRST 1
|
|
# if defined(TQ_WS_WIN)
|
|
# define TQT_XFORM_TYPE_WINDOWSPIXMAP 2
|
|
# endif
|
|
#endif
|
|
|
|
#else // USE_QT4
|
|
|
|
class TQ_EXPORT TQPixmap : public TQPaintDevice, public TQt
|
|
{
|
|
public:
|
|
enum ColorMode { Auto, Color, Mono };
|
|
enum Optimization { DefaultOptim, NoOptim, MemoryOptim=NoOptim,
|
|
NormalOptim, BestOptim };
|
|
|
|
TQPixmap();
|
|
TQPixmap( const TQImage& image );
|
|
TQPixmap( int w, int h, int depth = -1, Optimization = DefaultOptim );
|
|
TQPixmap( const TQSize &, int depth = -1, Optimization = DefaultOptim );
|
|
#ifndef TQT_NO_IMAGEIO
|
|
TQPixmap( const TQString& fileName, const char *format=0,
|
|
ColorMode mode=Auto );
|
|
TQPixmap( const TQString& fileName, const char *format,
|
|
int conversion_flags );
|
|
TQPixmap( const char *xpm[] ); // ### in 4.0, 'const char * const xpm[]'?
|
|
TQPixmap( const TQByteArray &data );
|
|
#endif
|
|
TQPixmap( const TQPixmap & );
|
|
~TQPixmap();
|
|
|
|
TQPixmap &operator=( const TQPixmap & );
|
|
TQPixmap &operator=( const TQImage & );
|
|
|
|
bool isNull() const;
|
|
|
|
int width() const { return data->w; }
|
|
int height() const { return data->h; }
|
|
TQSize size() const { return TQSize(data->w,data->h); }
|
|
TQRect rect() const { return TQRect(0,0,data->w,data->h); }
|
|
int depth() const { return data->d; }
|
|
static int defaultDepth();
|
|
|
|
void fill( const TQColor &fillColor = TQt::white );
|
|
void fill( const TQWidget *, int xofs, int yofs );
|
|
void fill( const TQWidget *, const TQPoint &ofs );
|
|
void resize( int width, int height );
|
|
void resize( const TQSize & );
|
|
|
|
const TQBitmap *mask() const;
|
|
void setMask( const TQBitmap & );
|
|
bool selfMask() const;
|
|
bool hasAlpha() const;
|
|
bool hasAlphaChannel() const;
|
|
#ifndef TQT_NO_IMAGE_HEURISTIC_MASK
|
|
TQBitmap createHeuristicMask( bool clipTight = TRUE ) const;
|
|
#endif
|
|
#ifndef TQT_NO_MIME
|
|
static TQPixmap fromMimeSource( const TQString& abs_name );
|
|
#endif
|
|
static TQPixmap grabWindow( WId, int x=0, int y=0, int w=-1, int h=-1 );
|
|
static TQPixmap grabWidget( TQWidget * widget,
|
|
int x=0, int y=0, int w=-1, int h=-1 );
|
|
|
|
#ifndef TQT_NO_PIXMAP_TRANSFORMATION
|
|
TQPixmap xForm( const TQWMatrix & ) const;
|
|
static TQWMatrix trueMatrix( const TQWMatrix &, int w, int h );
|
|
#endif
|
|
|
|
TQImage convertToImage() const;
|
|
bool convertFromImage( const TQImage &, ColorMode mode=Auto );
|
|
bool convertFromImage( const TQImage &, int conversion_flags );
|
|
#ifndef TQT_NO_IMAGEIO
|
|
static const char* imageFormat( const TQString &fileName );
|
|
bool load( const TQString& fileName, const char *format=0,
|
|
ColorMode mode=Auto );
|
|
bool load( const TQString& fileName, const char *format,
|
|
int conversion_flags );
|
|
bool loadFromData( const uchar *buf, uint len,
|
|
const char* format=0,
|
|
ColorMode mode=Auto );
|
|
bool loadFromData( const uchar *buf, uint len,
|
|
const char* format,
|
|
int conversion_flags );
|
|
bool loadFromData( const TQByteArray &data,
|
|
const char* format=0,
|
|
int conversion_flags=0 );
|
|
bool save( const TQString& fileName, const char* format, int quality = -1 ) const;
|
|
bool save( TQIODevice* tqdevice, const char* format, int quality = -1 ) const;
|
|
#endif
|
|
|
|
#if defined(TQ_WS_WIN)
|
|
HBITMAP hbm() const;
|
|
#endif
|
|
|
|
int serialNumber() const;
|
|
|
|
Optimization optimization() const;
|
|
void setOptimization( Optimization );
|
|
static Optimization defaultOptimization();
|
|
static void setDefaultOptimization( Optimization );
|
|
|
|
virtual void detach();
|
|
|
|
bool isTQBitmap() const;
|
|
|
|
#if defined(TQ_WS_WIN)
|
|
// These functions are internal and used by Windows 9x only
|
|
bool isMultiCellPixmap() const;
|
|
HDC multiCellHandle() const;
|
|
HBITMAP multiCellBitmap() const;
|
|
int multiCellOffset() const;
|
|
int allocCell();
|
|
void freeCell( bool = FALSE );
|
|
#endif
|
|
|
|
#if defined(TQ_WS_TQWS)
|
|
virtual TQGfx * graphicsContext(bool clip_tqchildren=TRUE) const;
|
|
virtual unsigned char * scanLine(int) const;
|
|
virtual int bytesPerLine() const;
|
|
TQRgb * clut() const;
|
|
int numCols() const;
|
|
#elif defined(TQ_WS_X11)
|
|
static int x11SetDefaultScreen( int screen );
|
|
void x11SetScreen( int screen );
|
|
#endif
|
|
|
|
#ifndef TQ_TQDOC
|
|
TQ_DUMMY_COMPARISON_OPERATOR(TQPixmap)
|
|
#endif
|
|
|
|
protected:
|
|
TQPixmap( int w, int h, const uchar *data, bool isXbitmap );
|
|
int metric( int ) const;
|
|
|
|
#if defined(TQ_WS_WIN)
|
|
struct TQMCPI { // mem optim for win9x
|
|
TQMultiCellPixmap *mcp;
|
|
int offset;
|
|
};
|
|
#endif
|
|
|
|
struct TQPixmapData : public TQShared { // internal pixmap data
|
|
TQCOORD w, h;
|
|
short d;
|
|
uint uninit : 1;
|
|
uint bitmap : 1;
|
|
uint selfmask : 1;
|
|
#if defined(TQ_WS_WIN)
|
|
uint mcp : 1;
|
|
#endif
|
|
int ser_no;
|
|
TQBitmap *mask;
|
|
#if defined(TQ_WS_WIN)
|
|
TQPixmap *maskpm;
|
|
union {
|
|
HBITMAP hbm; // if mcp == FALSE
|
|
TQMCPI *mcpi; // if mcp == TRUE
|
|
} hbm_or_mcpi;
|
|
uchar *realAlphaBits;
|
|
#ifdef TQ_OS_TEMP
|
|
uchar* ppvBits; // Pointer to DIBSection bits
|
|
#endif
|
|
#elif defined(TQ_WS_X11)
|
|
void *ximage;
|
|
void *maskgc;
|
|
TQPixmap *alphapm;
|
|
#elif defined(TQ_WS_MAC)
|
|
ColorTable *clut;
|
|
TQPixmap *alphapm;
|
|
#elif defined(TQ_WS_TQWS)
|
|
int id; // ### should use TQPaintDevice::hd, since it is there
|
|
TQRgb * clut;
|
|
int numcols;
|
|
int rw;
|
|
int rh;
|
|
bool hasAlpha;
|
|
#endif
|
|
Optimization optim;
|
|
#if defined(TQ_WS_WIN)
|
|
HBITMAP old_hbm;
|
|
#endif
|
|
} *data;
|
|
private:
|
|
#ifndef TQT_NO_IMAGEIO
|
|
bool doImageIO( TQImageIO* io, int quality ) const;
|
|
#endif
|
|
TQPixmap( int w, int h, int depth, bool, Optimization );
|
|
void init( int, int, int, bool, Optimization );
|
|
void deref();
|
|
TQPixmap copy( bool ignoreMask = FALSE ) const;
|
|
#if defined(TQ_WS_WIN)
|
|
void initAlphaPixmap( uchar *bytes, int length, struct tagBITMAPINFO *bmi );
|
|
void convertToAlphaPixmap( bool initAlpha=TRUE );
|
|
static void bitBltAlphaPixmap( TQPixmap *dst, int dx, int dy,
|
|
const TQPixmap *src, int sx, int sy,
|
|
int sw, int sh, bool useDstAlpha );
|
|
#endif
|
|
static Optimization defOptim;
|
|
friend TQ_EXPORT void bitBlt( TQPaintDevice *, int, int,
|
|
const TQPaintDevice *,
|
|
int, int, int, int, RasterOp, bool );
|
|
friend TQ_EXPORT void bitBlt( TQPaintDevice *, int, int,
|
|
const TQImage* src,
|
|
int, int, int, int, int conversion_flags );
|
|
friend TQ_EXPORT void copyBlt( TQPixmap *dst, int dx, int dy,
|
|
const TQPixmap *src, int sx, int sy,
|
|
int sw, int sh );
|
|
|
|
#if defined(TQ_WS_MAC)
|
|
friend void unclippedScaledBitBlt(TQPaintDevice *, int, int, int, int,
|
|
const TQPaintDevice *, int, int, int, int,
|
|
TQt::RasterOp, bool, bool);
|
|
#endif
|
|
|
|
friend class TQBitmap;
|
|
friend class TQPaintDevice;
|
|
friend class TQPainter;
|
|
friend class TQGLWidget;
|
|
};
|
|
|
|
|
|
inline bool TQPixmap::isNull() const
|
|
{
|
|
return data->w == 0;
|
|
}
|
|
|
|
inline void TQPixmap::fill( const TQWidget *w, const TQPoint &ofs )
|
|
{
|
|
fill( w, ofs.x(), ofs.y() );
|
|
}
|
|
|
|
inline void TQPixmap::resize( const TQSize &s )
|
|
{
|
|
resize( s.width(), s.height() );
|
|
}
|
|
|
|
inline const TQBitmap *TQPixmap::mask() const
|
|
{
|
|
return data->mask;
|
|
}
|
|
|
|
inline bool TQPixmap::selfMask() const
|
|
{
|
|
return data->selfmask;
|
|
}
|
|
|
|
#if defined(TQ_WS_WIN)
|
|
inline HBITMAP TQPixmap::hbm() const
|
|
{
|
|
return data->mcp ? 0 : data->hbm_or_mcpi.hbm;
|
|
}
|
|
#endif
|
|
|
|
inline int TQPixmap::serialNumber() const
|
|
{
|
|
return data->ser_no;
|
|
}
|
|
|
|
inline TQPixmap::Optimization TQPixmap::optimization() const
|
|
{
|
|
return data->optim;
|
|
}
|
|
|
|
inline bool TQPixmap::isTQBitmap() const
|
|
{
|
|
return data->bitmap;
|
|
}
|
|
|
|
#if defined(TQ_WS_WIN)
|
|
inline bool TQPixmap::isMultiCellPixmap() const
|
|
{
|
|
return data->mcp;
|
|
}
|
|
#endif
|
|
|
|
|
|
/*****************************************************************************
|
|
TQPixmap stream functions
|
|
*****************************************************************************/
|
|
|
|
#if !defined(TQT_NO_DATASTREAM) && !defined(TQT_NO_IMAGEIO)
|
|
TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQPixmap & );
|
|
TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQPixmap & );
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
TQPixmap (and TQImage) helper functions
|
|
*****************************************************************************/
|
|
|
|
#ifndef TQT_NO_PIXMAP_TRANSFORMATION
|
|
# define TQT_XFORM_TYPE_MSBFIRST 0
|
|
# define TQT_XFORM_TYPE_LSBFIRST 1
|
|
# if defined(TQ_WS_WIN)
|
|
# define TQT_XFORM_TYPE_WINDOWSPIXMAP 2
|
|
# endif
|
|
bool qt_xForm_helper( const TQWMatrix&, int, int, int, uchar*, int, int, int, uchar*, int, int, int );
|
|
#endif
|
|
|
|
TQ_EXPORT void copyBlt( TQPixmap *dst, int dx, int dy,
|
|
const TQPixmap *src, int sx = 0, int sy = 0,
|
|
int sw = -1, int sh = -1 );
|
|
|
|
#endif // USE_QT4
|
|
|
|
#endif // TQPIXMAP_H
|