summaryrefslogtreecommitdiffstats
path: root/experimental/tqtinterface/qt4/src/kernel/tqbitmap.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'experimental/tqtinterface/qt4/src/kernel/tqbitmap.cpp')
-rw-r--r--experimental/tqtinterface/qt4/src/kernel/tqbitmap.cpp435
1 files changed, 435 insertions, 0 deletions
diff --git a/experimental/tqtinterface/qt4/src/kernel/tqbitmap.cpp b/experimental/tqtinterface/qt4/src/kernel/tqbitmap.cpp
new file mode 100644
index 000000000..3e2ee39f0
--- /dev/null
+++ b/experimental/tqtinterface/qt4/src/kernel/tqbitmap.cpp
@@ -0,0 +1,435 @@
+/****************************************************************************
+**
+** Implementation of TQBitmap class
+**
+** Created : 941020
+**
+** 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.
+**
+**********************************************************************/
+
+#include "tqbitmap.h"
+#include "tqimage.h"
+
+#ifdef USE_QT4
+
+TQBitmap::TQBitmap() : QBitmap() {
+}
+
+TQBitmap::TQBitmap( int w, int h, bool clear, TQPixmap::Optimization o ) : QBitmap( w, h ) {
+ TQ_UNUSED(o);
+ if (clear)
+ QBitmap::clear();
+}
+
+TQBitmap::TQBitmap( const QSize &s, bool clear, TQPixmap::Optimization o ) : QBitmap( s ) {
+ TQ_UNUSED(o);
+ if (clear)
+ QBitmap::clear();
+}
+
+TQBitmap::TQBitmap( int w, int h, const uchar *bits, bool isXbitmap ) : QBitmap( QBitmap::fromData ( QSize(w, h), bits, (isXbitmap)?QImage::Format_MonoLSB:QImage::Format_Mono ) ) {
+}
+
+TQBitmap::TQBitmap( const QSize &s, const uchar *bits, bool isXbitmap ) : QBitmap( QBitmap::fromData ( s, bits, (isXbitmap)?QImage::Format_MonoLSB:QImage::Format_Mono ) ) {
+}
+
+TQBitmap::TQBitmap( const QBitmap &b ) : QBitmap( b ) {
+}
+
+#ifndef TQT_NO_IMAGEIO
+TQBitmap::TQBitmap( const QString &fileName, const char *format ) : QBitmap( fileName, format ) {
+}
+#endif
+
+QImage TQBitmap::convertToImage() const {
+ return toImage();
+}
+
+bool TQBitmap::convertFromImage(const QImage &img, int flags) {
+ return QPixmap::convertFromImage(img, (Qt::ImageConversionFlag)flags);
+}
+
+TQBitmap TQBitmap::xForm(const QMatrix &matrix) const {
+ return transformed(QTransform(matrix));
+}
+
+void TQBitmap::resize(const QSize &s) {
+ resize_helper(s);
+}
+
+void TQBitmap::resize(int width, int height) {
+ resize_helper(QSize(width, height));
+}
+
+// void TQBitmap::resize_helper(const QSize &s)
+// {
+// int w = s.width();
+// int h = s.height();
+// if (w < 1 || h < 1) {
+// *this = TQBitmap();
+// return;
+// }
+//
+// *this = TQBitmap(copy(0, 0, w, h));
+// }
+
+void TQBitmap::resize_helper(const QSize s)
+{
+ int w = s.width();
+ int h = s.height();
+
+ if (w < 1 || h < 1) {
+ *this = TQBitmap();
+ return;
+ }
+
+ if (size() == s)
+ return;
+
+ TQBitmap pm(QSize(w, h));
+ if (!isNull()) {
+ // Copy old bitmap
+ pm.fill(Qt::color0);
+ QPainter p(&pm);
+ p.setBrush(Qt::color1);
+ p.drawPixmap(0, 0, *this, 0, 0, qMin(width(), w), qMin(height(), h));
+ p.end();
+ }
+
+ // Mask too....
+ if (!mask().isNull()) {
+ TQBitmap m = mask();
+ if (m.size() != QSize(w,h)) {
+ TQBitmap pmr(QSize(w, h));
+ pmr.fill(Qt::color0);
+ QPainter pr(&pmr);
+ pr.setBrush(Qt::color1);
+ pr.drawPixmap(0, 0, m, 0, 0, qMin(m.width(), w), qMin(m.height(), h));
+ pr.end();
+ pm.setMask(pmr);
+ }
+ else {
+ pm.setMask(m);
+ }
+ }
+
+ // [FIXME]
+ // Note that the Xorg pixmap and/or gc (if any) is not created via the above process
+ // Therefore resize is more of a copy operation than a true resize
+ #warning TQPixmap::resize() partially implemented
+
+ *this = pm;
+}
+
+// This is the only correct way to return a pointer to an object returned by another function
+const TQBitmap *TQBitmap::tqmask() const {
+ const QBitmap& ptrRef = mask();
+ if (ptrRef.isNull() == true) {
+ return 0;
+ }
+ return static_cast<const TQBitmap*>(&ptrRef);
+}
+
+TQBitmap TQBitmap::operator=( const TQPixmap &pixmap )
+{
+ return TQBitmap(QBitmap::operator=(pixmap));
+}
+
+TQBitmap &TQBitmap::operator=( const TQImage &image )
+{
+ convertFromImage( image );
+ return *this;
+}
+
+#else // USE_QT4
+
+/*!
+ \class TQBitmap tqbitmap.h
+ \brief The TQBitmap class provides monochrome (1-bit depth) pixmaps.
+
+ \ingroup graphics
+ \ingroup images
+ \ingroup shared
+
+ The TQBitmap class is a monochrome off-screen paint tqdevice used
+ mainly for creating custom TQCursor and TQBrush objects, in
+ TQPixmap::setMask() and for TQRegion.
+
+ A TQBitmap is a TQPixmap with a \link TQPixmap::depth() depth\endlink
+ of 1. If a pixmap with a depth greater than 1 is assigned to a
+ bitmap, the bitmap will be dithered automatically. A TQBitmap is
+ guaranteed to always have the depth 1, unless it is
+ TQPixmap::isNull() which has depth 0.
+
+ When drawing in a TQBitmap (or TQPixmap with depth 1), we recommend
+ using the TQColor objects \c TQt::color0 and \c TQt::color1.
+ Painting with \c color0 sets the bitmap bits to 0, and painting
+ with \c color1 sets the bits to 1. For a bitmap, 0-bits indicate
+ background (or transtqparent) and 1-bits indicate foreground (or
+ opaque). Using the \c black and \c white TQColor objects make no
+ sense because the TQColor::pixel() value is not necessarily 0 for
+ black and 1 for white.
+
+ The TQBitmap can be transformed (translated, scaled, sheared or
+ rotated) using xForm().
+
+ Just like the TQPixmap class, TQBitmap is optimized by the use of
+ \link shclass.html implicit sharing\endlink, so it is very
+ efficient to pass TQBitmap objects as arguments.
+
+ \sa TQPixmap, TQPainter::drawPixmap(), bitBlt(), \link shclass.html Shared Classes\endlink
+*/
+
+
+/*!
+ Constructs a null bitmap.
+
+ \sa TQPixmap::isNull()
+*/
+
+TQBitmap::TQBitmap()
+{
+ data->bitmap = TRUE;
+}
+
+
+/*!
+ Constructs a bitmap with width \a w and height \a h.
+
+ The contents of the bitmap is uninitialized if \a clear is FALSE;
+ otherwise it is filled with pixel value 0 (the TQColor \c
+ TQt::color0).
+
+ The optional \a optimization argument specifies the optimization
+ setting for the bitmap. The default optimization should be used in
+ most cases. Games and other pixmap-intensive applications may
+ benefit from setting this argument; see \l{TQPixmap::Optimization}.
+
+ \sa TQPixmap::setOptimization(), TQPixmap::setDefaultOptimization()
+*/
+
+TQBitmap::TQBitmap( int w, int h, bool clear,
+ TQPixmap::Optimization optimization )
+ : TQPixmap( w, h, 1, optimization )
+{
+ data->bitmap = TRUE;
+ if ( clear )
+ fill( TQt::color0 );
+}
+
+
+/*!
+ \overload
+
+ Constructs a bitmap with the size \a size.
+
+ The contents of the bitmap is uninitialized if \a clear is FALSE;
+ otherwise it is filled with pixel value 0 (the TQColor \c
+ TQt::color0).
+
+ The optional \a optimization argument specifies the optimization
+ setting for the bitmap. The default optimization should be used in
+ most cases. Games and other pixmap-intensive applications may
+ benefit from setting this argument; see \l{TQPixmap::Optimization}.
+*/
+
+TQBitmap::TQBitmap( const TQSize &size, bool clear,
+ TQPixmap::Optimization optimization )
+ : TQPixmap( size, 1, optimization )
+{
+ data->bitmap = TRUE;
+ if ( clear )
+ fill( TQt::color0 );
+}
+
+
+/*!
+ Constructs a bitmap with width \a w and height \a h and sets the
+ contents to \a bits.
+
+ The \a isXbitmap flag should be TRUE if \a bits was generated by
+ the X11 bitmap program. The X bitmap bit order is little endian.
+ The TQImage documentation discusses bit order of monochrome images.
+
+ Example (creates an arrow bitmap):
+ \code
+ uchar arrow_bits[] = { 0x3f, 0x1f, 0x0f, 0x1f, 0x3b, 0x71, 0xe0, 0xc0 };
+ TQBitmap bm( 8, 8, arrow_bits, TRUE );
+ \endcode
+*/
+
+TQBitmap::TQBitmap( int w, int h, const uchar *bits, bool isXbitmap )
+ : TQPixmap( w, h, bits, isXbitmap )
+{
+ data->bitmap = TRUE;
+}
+
+
+/*!
+ \overload
+
+ Constructs a bitmap with the size \a size and sets the contents to
+ \a bits.
+
+ The \a isXbitmap flag should be TRUE if \a bits was generated by
+ the X11 bitmap program. The X bitmap bit order is little endian.
+ The TQImage documentation discusses bit order of monochrome images.
+*/
+
+TQBitmap::TQBitmap( const TQSize &size, const uchar *bits, bool isXbitmap )
+ : TQPixmap( size.width(), size.height(), bits, isXbitmap )
+{
+ data->bitmap = TRUE;
+}
+
+
+/*!
+ Constructs a bitmap that is a copy of \a bitmap.
+*/
+
+TQBitmap::TQBitmap( const TQBitmap &bitmap )
+ : TQPixmap( bitmap )
+{
+}
+
+#ifndef TQT_NO_IMAGEIO
+/*!
+ Constructs a bitmap from the file \a fileName. If the file does
+ not exist or is of an unknown format, the bitmap becomes a null
+ bitmap.
+
+ The parameters \a fileName and \a format are passed on to
+ TQPixmap::load(). Dithering will be performed if the file format
+ uses more than 1 bit per pixel.
+
+ \sa TQPixmap::isNull(), TQPixmap::load(), TQPixmap::loadFromData(),
+ TQPixmap::save(), TQPixmap::imageFormat()
+*/
+
+TQBitmap::TQBitmap( const TQString& fileName, const char *format )
+ : TQPixmap() // Will set bitmap to null bitmap, explicit call for clarity
+{
+ data->bitmap = TRUE;
+ load( fileName, format, Mono );
+}
+#endif
+
+/*!
+ Assigns the bitmap \a bitmap to this bitmap and returns a
+ reference to this bitmap.
+*/
+
+TQBitmap &TQBitmap::operator=( const TQBitmap &bitmap )
+{
+ TQPixmap::operator=(bitmap);
+#if defined(TQT_CHECK_STATE)
+ TQ_ASSERT( data->bitmap );
+#endif
+ return *this;
+}
+
+
+/*!
+ \overload
+
+ Assigns the pixmap \a pixmap to this bitmap and returns a
+ reference to this bitmap.
+
+ Dithering will be performed if the pixmap has a TQPixmap::depth()
+ greater than 1.
+*/
+
+TQBitmap &TQBitmap::operator=( const TQPixmap &pixmap )
+{
+ if ( pixmap.isNull() ) { // a null pixmap
+ TQBitmap bm( 0, 0, FALSE, pixmap.optimization() );
+ TQBitmap::operator=(bm);
+ } else if ( pixmap.depth() == 1 ) { // 1-bit pixmap
+ if ( pixmap.isTQBitmap() ) { // another TQBitmap
+ TQPixmap::operator=(pixmap); // shallow assignment
+ } else { // not a TQBitmap, but 1-bit
+ TQBitmap bm( pixmap.size(), FALSE, pixmap.optimization() );
+ bitBlt( &bm, 0,0, &pixmap, 0,0,pixmap.width(),pixmap.height() );
+ TQBitmap::operator=(bm);
+ }
+ } else { // n-bit depth pixmap
+ TQImage image;
+ image = pixmap; // convert pixmap to image
+ *this = image; // will dither image
+ }
+ return *this;
+}
+
+
+/*!
+ \overload
+
+ Converts the image \a image to a bitmap and assigns the result to
+ this bitmap. Returns a reference to the bitmap.
+
+ Dithering will be performed if the image has a TQImage::depth()
+ greater than 1.
+*/
+
+TQBitmap &TQBitmap::operator=( const TQImage &image )
+{
+ convertFromImage( image );
+ return *this;
+}
+
+
+#ifndef TQT_NO_PIXMAP_TRANSFORMATION
+/*!
+ Returns a transformed copy of this bitmap by using \a matrix.
+
+ This function does exactly the same as TQPixmap::xForm(), except
+ that it returns a TQBitmap instead of a TQPixmap.
+
+ \sa TQPixmap::xForm()
+*/
+
+TQBitmap TQBitmap::xForm( const TQWMatrix &matrix ) const
+{
+ TQPixmap pm = TQPixmap::xForm( matrix );
+ TQBitmap bm;
+ // Here we fake the pixmap to think it's a TQBitmap. With this trick,
+ // the TQBitmap::operator=(const TQPixmap&) will just refer the
+ // pm.data and we do not need to perform a bitBlt.
+ pm.data->bitmap = TRUE;
+ bm = pm;
+ return bm;
+}
+#endif // TQT_NO_TRANSFORMATIONS
+
+#endif // USE_QT4
generated by cgit v1.2.1 (git 2.18.0) at 2024-08-21 19:52:29 +0000