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.
368 lines
9.3 KiB
368 lines
9.3 KiB
/*
|
|
Copyright (c) 2002 Malte Starostik <malte@kde.org>
|
|
|
|
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;
|