diff options
author | Darrell Anderson <[email protected]> | 2013-08-18 10:14:48 -0500 |
---|---|---|
committer | Darrell Anderson <[email protected]> | 2013-08-18 10:14:48 -0500 |
commit | dad42352f4ad47d34caf50040367dc2a95772baa (patch) | |
tree | 6d2887d13f9b1403b8ce15be48a6ea7cec32fd96 /tdestyles/keramik/pixmaploader.h | |
parent | 365f03061337a81bcffb4a45c4ad637edad27019 (diff) | |
download | tdelibs-dad42352f4ad47d34caf50040367dc2a95772baa.tar.gz tdelibs-dad42352f4ad47d34caf50040367dc2a95772baa.zip |
Rename KStyle to TDEStyle to avoid conflicts with KDE4.
Diffstat (limited to 'tdestyles/keramik/pixmaploader.h')
-rw-r--r-- | tdestyles/keramik/pixmaploader.h | 367 |
1 files changed, 367 insertions, 0 deletions
diff --git a/tdestyles/keramik/pixmaploader.h b/tdestyles/keramik/pixmaploader.h new file mode 100644 index 000000000..ab0bb4223 --- /dev/null +++ b/tdestyles/keramik/pixmaploader.h @@ -0,0 +1,367 @@ +/* + Copyright (c) 2002 Malte Starostik <[email protected]> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// $Id$ + +#ifndef __pixmaploader_h__ +#define __pixmaploader_h__ + +#include <tqintcache.h> +#include <tqdict.h> +#include <tqimage.h> + +class TQPixmap; +class TQImage; + +#include "keramikrc.h" + +namespace Keramik +{ + class PixmapLoader + { + public: + PixmapLoader(); + + TQPixmap pixmap( int name, const TQColor& color, const TQColor& bg, + bool disabled = false, bool blend = true ); + + TQPixmap scale( int name, int width, int height, const TQColor& color, const TQColor& bg, + bool disabled = false, bool blend = true ); + TQSize size( int id ); + + void clear(); + + static PixmapLoader& the() + { + if (!s_instance) + s_instance = new PixmapLoader; + return *s_instance; + } + + static void release() + { + delete s_instance; + s_instance = 0; + } + + private: + + struct KeramikCacheEntry + { + int m_id; + int m_width; + int m_height; + QRgb m_colorCode; + QRgb m_bgCode; + bool m_disabled; + bool m_blended; + + TQPixmap* m_pixmap; + + KeramikCacheEntry(int id, const TQColor& color, const TQColor& bg, bool disabled, + bool blended, int width, int height, TQPixmap* pixmap = 0 ): + m_id(id), m_width(width), m_height(height), m_colorCode(color.rgb()),m_bgCode(bg.rgb()), + m_disabled(disabled), m_blended(blended), m_pixmap(pixmap) + {} + + int key() + { + return (int)m_disabled ^ (m_blended << 1) ^ (m_id<<2) ^ (m_width<<14) ^ (m_height<<24) ^ m_colorCode ^ (m_bgCode<<8); + } + + bool operator == (const KeramikCacheEntry& other) + { + return (m_id == other.m_id) && + (m_width == other.m_width) && + (m_height == other.m_height) && + (m_blended == other.m_blended) && + (m_bgCode == other.m_bgCode) && + (m_colorCode == other.m_colorCode) && + (m_disabled == other.m_disabled); + } + + ~KeramikCacheEntry() + { + delete m_pixmap; + } + }; + + + + TQImage* getColored(int id, const TQColor& color, const TQColor& bg, bool blended); + TQImage* getDisabled(int id, const TQColor& color, const TQColor& bg, bool blended); + TQIntCache <KeramikCacheEntry> m_pixmapCache; + + + unsigned char clamp[540]; + + static PixmapLoader* s_instance; + }; + + class TilePainter + { + public: + TilePainter( int name ) : m_columns(1),m_rows(1),m_name( name ) {}; + virtual ~TilePainter() {}; + + enum PaintMode + { + PaintNormal, + PaintMask, + PaintFullBlend, + PaintTrivialMask + }; + + void draw( TQPainter *p, int x, int y, int width, int height, const TQColor& color, const TQColor& bg, + bool disabled = false, PaintMode mode = PaintNormal ); + void draw( TQPainter *p, const TQRect& rect, const TQColor& color, const TQColor& bg, bool disabled = false, PaintMode mode = PaintNormal ) + { + draw( p, rect.x(), rect.y(), rect.width(), rect.height(), color, bg, disabled, mode ); + } + + protected: + enum TileMode { Fixed, Scaled, Tiled }; + + unsigned int columns() const { return m_columns; } + unsigned int rows() const { return m_rows; } + + /** + The idea behind all this stuff is that for performance reasons, we want to + use only integers to refer to widgets. So we give each widget a base ID + that's divisible by 256, and have all the various tiles be referred to as that ID + + some small number. + + genembed generates and assigns the base widget IDs, and maps various pixmaps suffixes + into the adjustment numbers; using that info it writes out the tables mapping + the IDs to pixmaps, and keramikrc.h, which provides nice symbolic constants for base IDs. + + When painting, however, we essentially represent the widget as a table, providing + fixed/tiled/stretched modes for each column and row. So to draw the widget knowing its + base ID, we need to know how many rows and columns there, what the scaling modes + are, and how to get to each of the tiles -- i.e. the tiles' offset from the base ID. + + The various painter subclasses simply fill in most of that info into the members + here during their construction, and implement the virtual tileName to get the offsets. + + Note that the IDs and offsets are separated since we can reuse the same code in many + cases by splitting the widget identify from tile identity (as there are many + different widgets that have the same or similar tile layout) + */ + virtual int tileName( unsigned int, unsigned int ) const { return 0; } + + TileMode columnMode( unsigned int col) const + { + return colMde[col]; + } + + TileMode rowMode( unsigned int row) const + { + return rowMde[row]; + } + + protected: + TileMode colMde[5], rowMde[5]; + unsigned int m_columns; + unsigned int m_rows; + private: + + int absTileName( unsigned int column, unsigned int row ) const + { + int name = tileName( column, row ); + return m_name + name; + } + + + TQPixmap tile( unsigned int column, unsigned int row, const TQColor& color, const TQColor& bg, bool disabled, bool blend) + { return PixmapLoader::the().pixmap( absTileName( column, row ), color, bg, disabled, blend ); } + TQPixmap scale( unsigned int column, unsigned int row, int width, int height, const TQColor& color, const TQColor& bg, + bool disabled, bool blend ) + { return PixmapLoader::the().scale( absTileName( column, row ), width, height, color, + bg, disabled, blend ); } + + int m_name; + + }; + + class ScaledPainter : public TilePainter + { + public: + enum Direction { Horizontal = 1, Vertical = 2, Both = Horizontal | Vertical }; + ScaledPainter( int name, Direction direction = Both ) + : TilePainter( name ), m_direction( direction ) + { + colMde[0] = ( m_direction & Horizontal ) ? Scaled : Tiled; + rowMde[0] = ( m_direction & Vertical ) ? Scaled : Tiled; + } + + virtual ~ScaledPainter() {}; + + private: + Direction m_direction; + }; + + class CenteredPainter : public TilePainter + { + public: + CenteredPainter( int name ) : TilePainter( name ) { + colMde[0] = colMde[1] = colMde[2] = colMde[3] = Fixed; + rowMde[0] = rowMde[1] = rowMde[2] = rowMde[3] = Fixed; + }; + virtual ~CenteredPainter() {}; + + protected: + }; + + class RectTilePainter : public TilePainter + { + public: + RectTilePainter( int name, + bool scaleH = true, bool scaleV = true, + unsigned int columns = 3, unsigned int rows = 3 ); + + virtual ~RectTilePainter() {}; + + protected: + virtual int tileName( unsigned int column, unsigned int row ) const; + private: + bool m_scaleH; + bool m_scaleV; + }; + + class RowPainter: public TilePainter + { + public: + RowPainter(int name): TilePainter(name) + { + colMde[0] = colMde[2] = Fixed; + colMde[1] = Tiled; + rowMde[0] = Scaled; + m_columns = 3; + } + + virtual ~RowPainter() {}; + protected: + virtual int tileName( unsigned int column, unsigned int /*row*/) const + { + return column + 3; //So can use cl, cc, cr + } + }; + + class ProgressBarPainter: public TilePainter + { + public: + ProgressBarPainter(int name, bool reverse): TilePainter(name), m_reverse(reverse) + { + //We use only of the tip bitmaps.. + if (reverse) + { + colMde[0] = Fixed; + colMde[1] = Tiled; + } + else + { + colMde[0] = Tiled; + colMde[1] = Fixed; + } + rowMde[0] = Scaled; + + m_columns = 2; + } + + virtual ~ProgressBarPainter() {}; + protected: + virtual int tileName( unsigned int column, unsigned int /*row*/ ) const + { + if (m_reverse) + { + return column + 3; //So can use cl, cc, cr + } + else + return column + 4; //So can use cl, cc, cr + we start from cc. + + } + + bool m_reverse; + }; + + + class ActiveTabPainter : public RectTilePainter + { + public: + ActiveTabPainter( bool bottom ); + virtual ~ActiveTabPainter() {}; + + protected: + virtual int tileName( unsigned int column, unsigned int row ) const; + + private: + bool m_bottom; + }; + + class InactiveTabPainter : public RectTilePainter + { + public: + enum Mode { First, Middle, Last }; + InactiveTabPainter( Mode mode, bool bottom ); + virtual ~InactiveTabPainter() {}; + + protected: + virtual int tileName( unsigned int column, unsigned int row ) const; + + private: + Mode m_mode; + bool m_bottom; + }; + + class ScrollBarPainter : public TilePainter + { + public: + ScrollBarPainter( int type, int count, bool horizontal ); + virtual ~ScrollBarPainter() {}; + + static int name( bool horizontal ); + + protected: + virtual int tileName( unsigned int column, unsigned int row ) const; + private: + int m_type; + int m_count; + bool m_horizontal; + }; + + class SpinBoxPainter : public TilePainter + { + public: + SpinBoxPainter() : TilePainter( keramik_spinbox ) { + colMde[0] = colMde[2] = Fixed; + colMde[1] = Scaled; + rowMde[0]=rowMde[1]=rowMde[2] = Scaled; + m_columns = 3; + }; + virtual ~SpinBoxPainter() {}; + + protected: + virtual int tileName( unsigned int column, unsigned int row ) const; + }; +} + +#endif + +// vim: ts=4 sw=4 noet +// kate: indent-width 4; replace-tabs off; tab-width 4; |