summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/styles/phase/phasestyle.cpp22
-rw-r--r--noncore/styles/phase/phasestyle.h8
2 files changed, 21 insertions, 9 deletions
diff --git a/noncore/styles/phase/phasestyle.cpp b/noncore/styles/phase/phasestyle.cpp
index ba8c460..906ccee 100644
--- a/noncore/styles/phase/phasestyle.cpp
+++ b/noncore/styles/phase/phasestyle.cpp
@@ -1,1226 +1,1236 @@
//////////////////////////////////////////////////////////////////////////////
// phasestyle.h
// -------------------
// A style for KDE
// -------------------
// Copyright (c) 2004 David Johnson <david@usermode.org>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//////////////////////////////////////////////////////////////////////////////
#include "phasestyle.h"
#include "bitmaps.h"
#define INCLUDE_MENUITEM_DEF
#include <qpopupmenu.h>
#include <qpushbutton.h>
#include <qtoolbutton.h>
#include <qpainter.h>
#include <qbrush.h>
#include <qiconset.h>
#include <qtabbar.h>
#include <qscrollbar.h>
/* Spacing and sizeHint */
static unsigned contrast = 110;
static const int ITEMFRAME = 1; // menu stuff
static const int ITEMHMARGIN = 3;
static const int ITEMVMARGIN = 0;
static const int ARROWMARGIN = 6;
static const int RIGHTBORDER = 10;
static const int MINICONSIZE = 12;
static const int CHECKSIZE = 9;
static const int SCROLLBAR_EXTENT = 12;
/*
* Copyright (C) 1999 Daniel M. Duley <mosfet@kde.org>
* LGPLv2 from kdelibs/kdefx/kdrawutil.cpp
*/
void kColorBitmaps(QPainter *p, const QColorGroup &g, int x, int y,
QBitmap *lightColor, QBitmap *midColor,
QBitmap *midlightColor, QBitmap *darkColor,
QBitmap *blackColor, QBitmap *whiteColor)
{
QBitmap *bitmaps[]={lightColor, midColor, midlightColor, darkColor,
blackColor, whiteColor};
QColor colors[]={g.light(), g.mid(), g.midlight(), g.dark(),
Qt::black, Qt::white};
int i;
for(i=0; i < 6; ++i){
if(bitmaps[i]){
if(!bitmaps[i]->mask())
bitmaps[i]->setMask(*bitmaps[i]);
p->setPen(colors[i]);
p->drawPixmap(x, y, *bitmaps[i]);
}
}
}
/*
* drawMenuBarItem is not virtual
* this way we define our draw handler
*/
typedef void (QStyle::*QDrawMenuBarItemImpl) (QPainter *, int, int, int, int, QMenuItem *,
QColorGroup &, bool, bool);
extern QDrawMenuBarItemImpl qt_set_draw_menu_bar_impl(QDrawMenuBarItemImpl impl);
PhaseStyle::PhaseStyle()
: QWindowsStyle()
{
setName( "PhaseStyle" );
/* small default sizes */
setButtonDefaultIndicatorWidth(1);
setScrollBarExtent(SCROLLBAR_EXTENT, SCROLLBAR_EXTENT);
setSliderThickness(12);
setButtonMargin( 1 );
// create bitmaps
uarrow = QBitmap(6, 6, uarrow_bits, true);
uarrow.setMask(uarrow);
darrow = QBitmap(6, 6, darrow_bits, true);
darrow.setMask(darrow);
larrow = QBitmap(6, 6, larrow_bits, true);
larrow.setMask(larrow);
rarrow = QBitmap(6, 6, rarrow_bits, true);
rarrow.setMask(rarrow);
bplus = QBitmap(6, 6, bplus_bits, true);
bplus.setMask(bplus);
bminus = QBitmap(6, 6, bminus_bits, true);
bminus.setMask(bminus);
bcheck = QBitmap(9, 9, bcheck_bits, true);
bcheck.setMask(bcheck);
dexpand = QBitmap(9, 9, dexpand_bits, true);
dexpand.setMask(dexpand);
rexpand = QBitmap(9, 9, rexpand_bits, true);
rexpand.setMask(rexpand);
doodad_mid = QBitmap(4, 4, doodad_mid_bits, true);
doodad_light = QBitmap(4, 4, doodad_light_bits, true);
}
PhaseStyle::~PhaseStyle() {
/* deleted by Qt */
}
void PhaseStyle::drawCheckMark ( QPainter * p, int x, int y, int w,
int h, const QColorGroup & g,
bool , bool) {
p->setPen(g.text());
p->drawPixmap(x+w/2-4, y+h/2-4, bcheck);
}
void PhaseStyle::drawArrow(QPainter *painter, Qt::ArrowType type, bool down,
int x, int y, int w, int h, const QColorGroup &group,
bool enabled , const QBrush * ) {
switch( type ) {
case UpArrow:
if (enabled)
painter->setPen(down ? group.midlight() : group.dark());
else painter->setPen(group.mid());
painter->drawPixmap(x+w/2-3, y+h/2-3, uarrow);
break;
case DownArrow:
if (enabled) painter->setPen(down ? group.midlight() : group.dark());
else painter->setPen(group.mid());
painter->drawPixmap(x+w/2-3, y+h/2-3, darrow);
break;
case LeftArrow:
if (enabled) painter->setPen(down ? group.midlight() : group.dark());
else painter->setPen(group.mid());
painter->drawPixmap(x+w/2-3, y+h/2-3, larrow);
break;
case RightArrow:
if (enabled) painter->setPen(down ? group.midlight() : group.dark());
else painter->setPen(group.mid());
painter->drawPixmap(x+w/2-3, y+h/2-3, rarrow);
break;
}
}
void PhaseStyle::drawPushButton(QPushButton *btn, QPainter *painter) {
QRect r = btn->rect();
int x = r.x();
int y = r.y();
int h = r.height();
int w = r.width();
bool depress = btn->isOn() || btn->isDown();
QColorGroup group = btn->colorGroup();
QBrush brush(group.button() );
// int bd = pixelMetric(PM_ButtonDefaultIndicator, widget) + 1;
static int bd = 2;
if (btn->isDefault() && !depress) {
drawPanel(painter, x, y, h, w, group,
&group.brush(QColorGroup::Mid), true);
drawBevelButton(painter, x+bd, y+bd, w-bd*2, h-bd*2, group,
false, &brush );
} else {
drawButton(painter, x, y, w, h, group, depress,
&brush );
}
if (btn->hasFocus() ) { // draw focus
QColor col;
drawFocusRect(painter, r, group,
&col, false );
}
}
void PhaseStyle::drawPanel(QPainter* painter, int x, int y, int w, int h,
const QColorGroup& group, bool sunken,
int , const QBrush* fill) {
int x2 = x + w - 1;
int y2 = y + h - 1;
painter->save();
if (sunken) {
painter->setPen(group.dark());
painter->drawRect(x+1, y+1, w-2, h-2);
painter->setPen(group.midlight());
painter->drawLine(x+1, y2, x2, y2);
painter->drawLine(x2, y+1, x2, y2-1);
painter->setPen(group.mid());
painter->drawLine(x, y, x, y2-1);
painter->drawLine(x+1, y, x2-1, y);
painter->setPen(group.background());
painter->drawPoint(x, y2);
painter->drawPoint(x2, y);
} else {
painter->setPen(group.dark());
painter->drawRect(x, y, w, h);
painter->setPen(group.midlight());
painter->drawLine(x+1, y+1, x2-2, y+1);
painter->drawLine(x+1, y+2, x+1, y2-2);
painter->setPen(group.mid());
painter->drawLine(x+2, y2-1, x2-1, y2-1);
painter->drawLine(x2-1, y+2, x2-1, y2-2);
painter->setPen(group.background());
painter->drawPoint(x+1, y2-1);
painter->drawPoint(x2-1, y+1);
}
if (fill) {
painter->fillRect(x+2, y+2, w-4, h-4, *fill );
}
painter->restore();
}
void PhaseStyle::drawButton(QPainter *p, int x, int y, int w, int h,
const QColorGroup &group, bool sunken ,
const QBrush *fill ) {
int x2 = x + w - 1;
int y2 = y + h - 1;
p->setPen(group.midlight());
p->drawLine(x+1, y2, x2, y2);
p->drawLine(x2, y+1, x2, y2-1);
p->setPen(group.mid());
p->drawLine(x, y, x2-1, y);
p->drawLine(x, y+1, x, y2-1);
p->setPen(group.button());
p->drawPoint(x, y2);
p->drawPoint(x2, y);
drawBevelButton(p, x+1, y+1, w-2, h-2, group, sunken,
fill);
}
void PhaseStyle::drawButtonMask( QPainter* p, int x, int y,
int w, int h ) {
QRect rect(x, y, w, h );
p->fillRect(rect, Qt::color1);
p->setPen(Qt::color0);
}
void PhaseStyle::drawBevelButton(QPainter* p, int x, int y,
int w, int h, const QColorGroup& group,
bool sunken, const QBrush* fill ) {
int x2 = x + w - 1;
int y2 = y + h - 1;
p->save();
p->setPen(group.dark());
p->drawRect(x, y, w, h);
p->setPen(sunken ? group.mid() : group.midlight());
p->drawLine(x+1, y+1, x2-2, y+1);
p->drawLine(x+1, y+2, x+1, y2-2);
p->setPen(sunken ? group.midlight() : group.mid());
p->drawLine(x+2, y2-1, x2-1, y2-1);
p->drawLine(x2-1, y+2, x2-1, y2-2);
p->setPen(group.button());
p->drawPoint(x+1, y2-1);
p->drawPoint(x2-1, y+1);
QBrush b = fill ? *fill : group.brush( QColorGroup::Button );
if (sunken) {
// sunken bevels don't get gradients
p->fillRect(x+2, y+2, w-4, h-4, b);
} else
drawPhaseGradient(p, QRect(x+2, y+2, w-4, h-4), b.color() );
p->restore();
}
void PhaseStyle::drawPhaseGradient(QPainter* painter,
const QRect& rect,
const QColor& color )const {
painter->fillRect(rect, color);
}
void PhaseStyle::polish( QWidget* widget ) {
QWindowsStyle::polish(widget );
#if 0
if (widget->inherits("QMenuBar") ||
widget->inherits("QPopupMenu" ) ||
widget->inherits("QToolButton") ||
widget->inherits("QHeader" ) ) {
widget->setBackgroundMode(QWidget::NoBackground);
}
// else if (widget->inherits("QFrame") ) {
// widget->installEventFilter(this);
// }
#endif
}
+void PhaseStyle::unPolish( QWidget *w )
+{
+ QWindowsStyle::unPolish( w );
+}
+
void PhaseStyle::polish( QPalette &pal ) {
QWindowsStyle::polish( pal );
// lighten up a bit, so the look is not so "crisp"
if (QPixmap::defaultDepth() > 8) { // but not on low color displays
pal.setColor(QPalette::Disabled, QColorGroup::Dark,
pal.color(QPalette::Disabled, QColorGroup::Dark).light(contrast));
pal.setColor(QPalette::Active, QColorGroup::Dark,
pal.color(QPalette::Active, QColorGroup::Dark).light(contrast));
pal.setColor(QPalette::Inactive, QColorGroup::Dark,
pal.color(QPalette::Inactive, QColorGroup::Dark).light(contrast));
}
}
void PhaseStyle::polish( QApplication* app ) {
QWindowsStyle::polish( app );
qt_set_draw_menu_bar_impl((QDrawMenuBarItemImpl)&PhaseStyle::drawMenuBarItem);
}
+void PhaseStyle::unPolish( QApplication* app ) {
+ QWindowsStyle::unPolish(app);
+ qt_set_draw_menu_bar_impl ( 0 );
+}
+
void PhaseStyle::drawPushButtonLabel (QPushButton *button, QPainter *painter) {
bool active = button->isOn() || button->isDown();
QRect r = pushButtonContentsRect( button );
QColorGroup group = button->colorGroup();
int x, y, w, h;
r.rect( &x, &y, &w, &h );
bool sunken = false;
QIconSet::Mode mode;
QPixmap pixmap;
if (active) {// shift contents
x++; y++;
sunken = true;
}
if (button->isMenuButton()) { // draw the indicator
//dx = pixelMetric(PM_MenuButtonIndicator, widget);
int dx = menuButtonIndicatorWidth( button->height() );
drawArrow(painter, Qt::DownArrow, active,
x+w-dx, y+2, dx-4, h-4, group,button->isEnabled() );
w -= dx;
}
if (button->iconSet() && !button->iconSet()->isNull()) { // draw icon
if (button->isEnabled()) {
if (button->hasFocus()) {
mode = QIconSet::Active;
} else {
mode = QIconSet::Normal;
}
} else {
mode = QIconSet::Disabled;
}
#if 0
if (button->isToggleButton() && button->isOn()) {
state = true;
} else {
state = false;
}
#endif
pixmap = button->iconSet()->pixmap(QIconSet::Small, mode);
if (button->text().isEmpty() && !button->pixmap()) {
painter->drawPixmap(x+w/2 - pixmap.width()/2,
y+h/2 - pixmap.height()/2, pixmap);
} else {
painter->drawPixmap(x+4, y+h/2 - pixmap.height()/2, pixmap);
}
x += pixmap.width() + 4;
w -= pixmap.width() + 4;
}
if (active || button->isDefault()) { // default button
for(int n=0; n<2; n++) {
drawItem(painter, x+n, y, w, h,
AlignCenter | ShowPrefix,
button->colorGroup(),
button->isEnabled(),
button->pixmap(),
button->text(), -1,
(button->isEnabled()) ?
&button->colorGroup().buttonText() :
&button->colorGroup().mid());
}
} else { // normal button
drawItem(painter, x, y, w, h,
AlignCenter | ShowPrefix,
button->colorGroup(),
button->isEnabled(),
button->pixmap(),
button->text(), -1,
(button->isEnabled()) ?
&button->colorGroup().buttonText() :
&button->colorGroup().mid());
}
}
void PhaseStyle::drawFocusRect(QPainter *painter, const QRect &rect,
const QColorGroup &group,
const QColor *, bool atBorder) {
QPen old = painter->pen();
painter->setPen(group.highlight().dark(contrast));
painter->setBrush(NoBrush);
if ( atBorder )
painter->drawRect(QRect(rect.x()+1, rect.y()+1,
rect.width()-2, rect.height()-2 ));
else
painter->drawRect(rect);
painter->setPen(old);
}
void PhaseStyle::drawSeperator( QPainter* painter, int x, int y, int w,
int h, const QColorGroup& group, bool,
int , int ) {
qWarning( "Seperator" );
QRect rect(x, y, w, h);
int x2 = rect.right();
int y2 = rect.bottom();
painter->setPen(group.dark());
if (w < h)
painter->drawLine(w/2, y, w/2, y2);
else
painter->drawLine(x, h/2, x2, h/2);
}
void PhaseStyle::drawMenuBarItem(QPainter* p, int x, int y, int w, int h,
QMenuItem *mi, QColorGroup& g, bool enabled,
bool act ) {
return QWindowsStyle::drawMenuBarItem(p, x, y, w, h, mi, g, enabled, act);
}
void PhaseStyle::drawIndicator(QPainter* painter, int x, int y, int w, int h,
const QColorGroup &group, int state, bool,
bool enabled ) {
drawPanel(painter, x, y, w, h, group, true, 1, enabled ?
&group.brush(QColorGroup::Base) :
&group.brush(QColorGroup::Background));
if (QButton::On == state ) {
painter->setPen(group.dark());
painter->drawRect(x+3, y+3, w-6, h-6);
painter->fillRect(x+4, y+4, w-8, h-8,
group.brush(QColorGroup::Highlight));
}
}
void PhaseStyle::drawExclusiveIndicator(QPainter* painter, int x, int y, int w, int h,
const QColorGroup &group, bool on,
bool /*down*/, bool enabled) {
QRect r(x, y, w, h );
/*
* As Polygon and Polyline are broken in Qt2 lets use
* something not that spectacilur -> ellipse
*/
painter->save();
painter->fillRect(x, y, w, h, group.background());
painter->setBrush(enabled
? group.brush(QColorGroup::Base)
: group.brush(QColorGroup::Background));
painter->setPen(group.dark());
if (0 == w % 2) --w;
if (0 == h % 2) --h;
painter->drawEllipse(x, y, w, h );
if(on) {
painter->setBrush(group.brush(QColorGroup::Highlight));
painter->drawEllipse(x+3,y+3,w-6,h-6);
}
painter->restore();
}
/*
* Does not get called in QWS as it seems
*/
void PhaseStyle::drawExclusiveIndicatorMask(QPainter *painter, int x, int y, int w,
int h, bool /*on*/ ) {
return;
if (0 != w%2) --w;
if (0 != h%2) --h;
QRect r(x, y, w, h );
int x2 = r.right();
int y2 = r.bottom();
int cx = (x + x2) / 2;
int cy = (y + y2) / 2;
QPointArray parray;
painter->setBrush(Qt::color1);
painter->setPen(Qt::color1);
parray.putPoints(0, 8,
x,cy+1, x,cy, cx,y, cx+1,y,
x2,cy, x2,cy+1, cx+1,y2, cx,y2);
painter->drawPolygon(parray, 0, 8);
}
int PhaseStyle::defaultFrameWidth()const {
return 1;
}
int PhaseStyle::popupMenuItemHeight ( bool ,
QMenuItem * mi,
const QFontMetrics & fm ) {
int h = 0;
if (mi->custom() ) {
h = mi->custom()->sizeHint().height();
if (!mi->custom()->fullSpan() )
h += ITEMVMARGIN*2 + ITEMFRAME*2;
}else if (mi->isSeparator() ) {
h = 1;
}else {
if ( mi->pixmap() ) {
h = QMAX(h, mi->pixmap()->height() + ITEMFRAME*2);
}else {
h = QMAX(h, MINICONSIZE+ITEMFRAME*2 );
h = QMAX(h, fm.height()
+ ITEMVMARGIN*2 + ITEMFRAME*2 );
}
if ( mi->iconSet() )
h = QMAX(h, mi->iconSet()->
pixmap(QIconSet::Small, QIconSet::Normal ).height()
+ ITEMFRAME*2 );
}
return h;
}
int PhaseStyle::extraPopupMenuItemWidth(bool checkable, int maxpmw,
QMenuItem* mi, const QFontMetrics& ) {
int w = 0;
if (mi->isSeparator() )
return 3;
else if ( mi->pixmap() )
w = mi->pixmap()->width();
if (!mi->text().isNull() &&
mi->text().find('\t' ) >= 0 )
w += 12;
else if ( mi->popup() )
w += 2*ARROWMARGIN;
if ( maxpmw )
w += maxpmw +4;
if ( maxpmw > 0 || checkable )
w += ITEMHMARGIN*2+8;
w += RIGHTBORDER;
return w;
}
QSize PhaseStyle::indicatorSize()const {
return QSize( 11, 11 );
}
QSize PhaseStyle::exclusiveIndicatorSize()const {
return QSize( 11, 11 );
}
void PhaseStyle::getButtonShift( int &x, int &y ) {
x++;
y++;
}
void PhaseStyle::drawPopupMenuItem ( QPainter * p, bool checkable,
int maxpmw,int tabwidth,
QMenuItem * mi, const QPalette & pal,
bool act, bool enabled, int x,
int y, int w, int h ) {
if ( !mi )
return;
QRect rect(x, y, w, h );
int x2, y2;
x2 = rect.right();
y2 = rect.bottom();
const QColorGroup& g = pal.active();
QColorGroup itemg = !enabled ? pal.disabled() : pal.active();
if ( checkable || maxpmw ) maxpmw = QMAX(maxpmw, 20);
if (act && enabled )
p->fillRect(x, y, w, h, g.highlight() );
else
p->fillRect(x, y, w, h, g.background() );
// draw seperator
if (mi->isSeparator() ) {
- p->setPen( g.dark() );
- p->drawLine( x+8, y+1, x+w-8, y+1 );
+ p->setPen( g.dark() );
+ p->drawLine( x+8, y+1, x+w-8, y+1 );
p->setPen( g.mid() );
p->drawLine( x+8, y, x+w-8, y );
p->drawPoint(x+w,y+1);
- p->setPen( g.midlight() );
- p->drawLine( x+8, y-1, x+w-8, y-1 );
+ p->setPen( g.midlight() );
+ p->drawLine( x+8, y-1, x+w-8, y-1 );
p->drawPoint(x+8, y );
return;
}
// draw icon
QIconSet::Mode mode;
if ( mi->iconSet() && !mi->isChecked() ) {
if ( act )
mode = enabled ? QIconSet::Active : QIconSet::Disabled;
else
mode = enabled ? QIconSet::Normal : QIconSet::Disabled;
QPixmap pixmap = mi->iconSet()->pixmap(QIconSet::Small, mode );
QRect pmrect(0, 0, pixmap.width(), pixmap.height() );
QRect cr(x, y, maxpmw, h );
pmrect.moveCenter( cr.center() );
p->drawPixmap(pmrect.topLeft(), pixmap);
}
// draw check
if(mi->isChecked() ) {
drawCheckMark(p, x, y, maxpmw, h, itemg, act, !enabled );
}
// draw text
int xm = maxpmw + 2;
int xp = x + xm;
int tw = w -xm - 2;
p->setPen( enabled ? ( act ? g.highlightedText() : g.buttonText() ) :
g.mid() );
if ( mi->custom() ) {
p->save();
mi->custom()->paint(p, g, act, enabled,
xp, y+1, tw, h-2 );
p->restore();
}else { // draw label
QString text = mi->text();
if (!text.isNull() ) {
int t = text.find('\t');
const int tflags = AlignVCenter | DontClip |
ShowPrefix | SingleLine |
AlignLeft;
if (t >= 0) {
int tabx = x + w - tabwidth - RIGHTBORDER -
ITEMHMARGIN - ITEMFRAME;
p->drawText(tabx, y+ITEMVMARGIN, tabwidth,
h-2*ITEMVMARGIN, tflags,
text.mid(t+1) );
text = text.left(t );
}
// draw left label
p->drawText(xp, y+ITEMVMARGIN,
tw, h-2*ITEMVMARGIN,
tflags, text, t);
}else if ( mi->pixmap() ) { // pixmap as label
QPixmap pixmap = *mi->pixmap();
if ( pixmap.depth() == 1 )
p->setBackgroundMode( OpaqueMode );
int dx = ((w-pixmap.width() ) /2 ) +
((w - pixmap.width()) %2 );
p->drawPixmap(x+dx, y+ITEMFRAME, pixmap );
if ( pixmap.depth() == 1 )
p->setBackgroundMode( TransparentMode );
}
}
if ( mi->popup() ) { // draw submenu arrow
int dim = (h-2*ITEMFRAME) / 2;
drawArrow( p, RightArrow, false,
x+w-ARROWMARGIN-ITEMFRAME-dim,
y+h/2-dim/2, dim, dim, g, enabled );
}
}
QRect PhaseStyle::comboButtonRect ( int x, int y, int w, int h ) {
return QRect(x+2, y+2, w-4-17, h-5 );
}
void PhaseStyle::drawComboButton( QPainter * p, int x, int y,
int w, int h,
const QColorGroup & g,
bool sunken,
bool editable,
bool,
const QBrush *) {
drawButton(p, x, y, w, h, g,
sunken, &g.brush(QColorGroup::Button ));
for ( int n = 0; n < 2; ++n )
kColorBitmaps(p, g, w-16+(6*n), y+(h/2)-2,
0, &doodad_mid, &doodad_light, 0, 0, 0 );
if (editable ) {
const int x2 = x+w-1; const int y2 = y+h-1;
p->setPen(g.dark());
p->drawLine(x2+1, y, x2+1, y2);
p->setPen(g.midlight());
p->drawLine(x2+2, y, x2+2, y2-1);
p->setPen(g.button());
p->drawPoint(x2+2, y2);
}
p->setPen(g.buttonText() );
}
void PhaseStyle::tabbarMetrics( const QTabBar* t, int &hframe, int &vframe, int& ov ) {
QCommonStyle::tabbarMetrics( t, hframe, vframe, ov );
hframe -= 2;
vframe += 1;
}
void PhaseStyle::drawTab(QPainter* painter, const QTabBar* bar, QTab* tab,
bool selected ) {
bool edge = false;
int x, y, w, h;
QRect r = tab->rect();
r.rect(&x,&y,&w,&h);
const int x2 = x+w-1;
const int y2 = y+h-1;
const QColorGroup &group = bar->colorGroup();
painter->save();
// what position is the tab?
if ((bar->count() == 1 ))
- edge = true;
+ edge = true;
else
- edge = false;
+ edge = false;
switch (QTabBar::Shape(bar->shape())) {
case QTabBar::RoundedAbove:
case QTabBar::TriangularAbove: {
if (!selected) { // shorten
y += 2; h -= 2;
}
if (selected) {
painter->setPen(Qt::NoPen);
painter->fillRect(x+1, y+1, w-1, h-1,
group.brush(QColorGroup::Background));
} else
drawPhaseGradient(painter, QRect(x+1, y+1, w-1, h-2),
group.background().dark(contrast) );
// draw tab
painter->setPen(group.dark());
painter->drawLine(x, y, x, y2-2);
painter->drawLine(x+1, y, x2, y);
painter->drawLine(x2, y+1, x2, y2-2);
painter->setPen(group.mid());
painter->drawLine(x2-1, y+2, x2-1, y2-2);
painter->setPen(group.midlight());
painter->drawLine(x+1, y+1, x2-2, y+1);
if ((selected) || edge) painter->drawLine(x+1, y+2, x+1, y2-2);
// finish off bottom
if (selected) {
painter->setPen(group.dark());
painter->drawPoint(x, y2-1);
painter->drawPoint(x2, y2-1);
painter->setPen(group.midlight());
painter->drawPoint(x, y2);
painter->drawLine(x+1, y2-1, x+1, y2);
painter->drawPoint(x2, y2);
painter->setPen(group.mid());
painter->drawPoint(x2-1, y2-1);
if (edge) {
painter->setPen(group.dark());
painter->drawLine(x, y2-1, x, y2);
painter->setPen(group.midlight());
painter->drawPoint(x+1, y2);
}
} else {
painter->setPen(group.dark());
painter->drawLine(x, y2-1, x2, y2-1);
painter->setPen(group.midlight());
painter->drawLine(x, y2, x2, y2);
if (edge) {
painter->setPen(group.dark());
painter->drawLine(x, y2-1, x, y2);
}
}
break;
}
case QTabBar::RoundedBelow:
case QTabBar::TriangularBelow: {
painter->setBrush( group.background().dark(contrast));
painter->setPen(Qt::NoPen);
painter->fillRect(x+1, y+1, w-1, h-1, painter->brush());
// draw tab
painter->setPen(group.dark());
painter->drawLine(x, y+1, x, y2);
painter->drawLine(x+1, y2, x2, y2);
painter->drawLine(x2, y+1, x2, y2-1);
painter->setPen(group.mid());
painter->drawLine(x2-1, y+1, x2-1, y2-1);
painter->drawLine(x+2, y2-1, x2-1, y2-1);
painter->drawPoint(x, y);
painter->drawPoint(x2, y);
if ((selected) || edge) {
painter->setPen(group.midlight());
painter->drawLine(x+1, y+1, x+1, y2-2);
}
// finish off top
if (selected) {
if (edge) {
painter->setPen(group.dark());
painter->drawPoint(x, y);
painter->setPen(group.midlight());
painter->drawPoint(x+1, y);
}
} else {
painter->setPen(group.dark());
painter->drawLine(x, y+1, x2, y+1);
painter->setPen(group.mid());
painter->drawLine(x, y, x2, y);
if (edge) {
painter->setPen(group.dark());
painter->drawPoint(x, y);
}
}
break;
}
}
painter->restore();
}
void PhaseStyle::drawTabMask( QPainter* p, const QTabBar*, QTab* tab,
bool ) {
p->fillRect(tab->rect(), Qt::color1);
}
void PhaseStyle::drawToolButton(QPainter * p, int x, int y,
int w, int h, const QColorGroup & g,
bool sunken,
const QBrush * fill ) {
QRect r(x, y, w, h );
p->fillRect(r, g.background());
drawPanel(p, x, y, w, h, g, sunken, 1,
fill ? fill : &g.brush(QColorGroup::Button) );
p->setPen(g.text() );
}
/*
* LGPLv2 Copyright (C) 2001 Rik Hemsley (rikkus) <rik@kde.org>
*
* ../web/webstyle.cpp
*/
void PhaseStyle::scrollBarMetrics(const QScrollBar* sb, int& sliderMin,
int& sliderMax, int &sliderLength,
int& buttonDim ) {
int maxlen;
bool horizontal = sb->orientation() == QScrollBar::Horizontal;
int len = (horizontal) ? sb->width() : sb->height();
int extent = (horizontal) ? sb->height() : sb->width();
if (len > (extent - 1) * 2)
buttonDim = extent;
else
buttonDim = len / 2 - 1;
if (horizontal)
sliderMin = buttonDim * 2;
else
sliderMin = 1;
maxlen = len - buttonDim * 2 - 1;
int div = QMAX(1, (sb->maxValue() - sb->minValue() + sb->pageStep() ) );
sliderLength =
(sb->pageStep() * maxlen) / div;
if (sliderLength < SCROLLBAR_EXTENT)
sliderLength = SCROLLBAR_EXTENT;
if (sliderLength > maxlen)
sliderLength = maxlen;
sliderMax = sliderMin + maxlen - sliderLength;
}
void PhaseStyle::drawScrollBarControls( QPainter* p, const QScrollBar *sb,
int sliderStart, uint controls,
uint activeControl) {
const bool horizontal = (sb->orientation() == Qt::Horizontal );
int sliderMin, sliderMax, sliderLength, buttonDim;
const QColorGroup& g = sb->colorGroup();
QRect sub, add, subPage, addPage, slider;
int x, y, x2, y2;
scrollBarMetrics( sb, sliderMin, sliderMax, sliderLength, buttonDim );
/* lets get the positions */
scrollBarItemPositions(sb, horizontal, sliderStart,
sliderMax, sliderLength, buttonDim,
sub, add, subPage, addPage,
slider );
/* sanity */
if ( sliderStart > sliderMax )
sliderStart = sliderMax;
// addline
if ( controls & AddLine && add.isValid() ) {
x = add.x(); y = add.y();
x2 = add.width(); y2 = add.height();
const bool down = (activeControl & AddLine );
drawBevelButton(p, x, y, x2, y2, g, down,
&g.brush(QColorGroup::Button));
Qt::ArrowType arrow = horizontal ? RightArrow : DownArrow;
if (down ) {
switch (arrow ) {
case DownArrow: y++; break;
case RightArrow: x++; break;
default: break;
}
}
drawArrow( p, arrow, down, x, y, x2, y2, g, true );
}
if ( controls & SubLine && sub.isValid() ) {
x = sub.x(); y = sub.y();
x2 = sub.width(); y2 = sub.height();
const bool down = (activeControl & SubLine );
drawBevelButton(p, x, y, x2, y2, g, down,
&g.brush(QColorGroup::Button));
Qt::ArrowType arrow = horizontal ? LeftArrow : UpArrow;
if (down ) {
switch (arrow ) {
case UpArrow: y--; break;
case LeftArrow: x--; break;
default: break;
}
}
drawArrow( p, arrow, down, x, y, x2, y2, g, true );
}
if ( controls & AddPage && addPage.isValid() ) {
x = addPage.x(); y = addPage.y();
x2 = addPage.right(); y2 = addPage.bottom();
p->fillRect(addPage, g.mid());
p->setPen(g.dark());
if (horizontal) { // vertical
p->drawLine(x, y, x2, y);
p->drawLine(x, y2, x2, y2);
} else { // horizontal
p->drawLine(x, y, x, y2);
p->drawLine(x2, y, x2, y2);
}
}
if ( controls & SubPage && subPage.isValid() ) {
x = subPage.x(); y = subPage.y();
x2 = subPage.right(); y2 = subPage.bottom();
p->fillRect(subPage, g.mid());
p->setPen(g.dark());
if (horizontal) { // vertical
p->drawLine(x, y, x2, y);
p->drawLine(x, y2, x2, y2);
} else { // horizontal
p->drawLine(x, y, x, y2);
p->drawLine(x2, y, x2, y2);
}
}
if ( controls & Slider && slider.isValid() ) {
x = slider.x(); y = slider.y();
x2 = slider.width(); y2 = slider.height();
const bool down = ( activeControl & Slider );
int cx = x + x2/2 -2; int cy = y + y2/2 -2;
drawBevelButton(p, x, y, x2, y2, g, down,
&g.brush(QColorGroup::Button) );
if (horizontal && (x2 >=20)) {
for (int n = -5; n <= 5; n += 5)
kColorBitmaps(p, g, cx+n, cy,
0, &doodad_mid, &doodad_light, 0, 0, 0);
} else if (!horizontal && (y2 >= 20)) {
for (int n = -5; n <= 5; n += 5)
kColorBitmaps(p, g, cx, cy+n,
0, &doodad_mid, &doodad_light, 0, 0, 0);
}
if ( sb->hasFocus() && down ) {
slider = QRect(slider.x()+2, slider.y()+2,
slider.width()-2, slider.height()-2 );
drawFocusRect(p, slider, g, false );
}
}
}
/*
* LGPLv2 Copyright (C) 2001 Rik Hemsley (rikkus) <rik@kde.org>
*
* ../web/webstyle.cpp
*/
QStyle::ScrollControl PhaseStyle::scrollBarPointOver( const QScrollBar * sb,
int sliderStart,
const QPoint & point ) {
if (!sb->rect().contains(point))
return NoScroll;
int sliderMin, sliderMax, sliderLength, buttonDim;
scrollBarMetrics(sb, sliderMin, sliderMax, sliderLength, buttonDim);
if (sb->orientation() == QScrollBar::Horizontal) {
int x = point.x();
if (x <= buttonDim)
return SubLine;
else if (x <= buttonDim * 2)
return AddLine;
else if (x < sliderStart)
return SubPage;
else if (x < sliderStart+sliderLength)
return Slider;
else
return AddPage;
} else {
int y = point.y();
if (y < sliderStart)
return SubPage;
else if (y < sliderStart + sliderLength)
return Slider;
else if (y < sliderMax + sliderLength)
return AddPage;
else if (y < sliderMax + sliderLength + buttonDim)
return SubLine;
else
return AddLine;
}
}
/*
* LGPLv2 Copyright (C) 2001 Rik Hemsley (rikkus) <rik@kde.org>
*
* ../web/webstyle.cpp
* scrollBarControlsMetrics
*/
void PhaseStyle::scrollBarItemPositions( const QScrollBar* sb, const bool horizontal,
int sliderStart, int sliderMax,
int sliderLength, int buttonDim,
QRect &rSub, QRect& rAdd, QRect& rSubPage,
QRect &rAddPage, QRect& rSlider ) {
int len = horizontal ? sb->width() : sb->height();
int extent = horizontal ? sb->height() : sb->width();
QColorGroup g = sb->colorGroup();
if (sliderStart > sliderMax)
sliderStart = sliderMax;
int sliderEnd = sliderStart + sliderLength;
int addX, addY;
int subX, subY;
int subPageX, subPageY, subPageW, subPageH;
int addPageX, addPageY, addPageW, addPageH;
int sliderX, sliderY, sliderW, sliderH;
if (horizontal){
subY = 0;
addY = 0;
subX = 0;
addX = buttonDim;
subPageX = buttonDim * 2;
subPageY = 0;
subPageW = sliderStart - 1;
subPageH = extent;
addPageX = sliderEnd;
addPageY = 0;
addPageW = len - sliderEnd;
addPageH = extent;
sliderX = sliderStart;
sliderY = 0;
sliderW = sliderLength;
sliderH = extent;
}else {
subX = 0;
addX = 0;
subY = len - buttonDim * 2;
addY = len - buttonDim;
subPageX = 0;
subPageY = 0;
subPageW = extent;
subPageH = sliderStart;
addPageX = 0;
addPageY = sliderEnd;
addPageW = extent;
addPageH = subY - sliderEnd;
sliderX = 0;
sliderY = sliderStart;
sliderW = extent;
sliderH = sliderLength;
}
rSub .setRect( subX, subY, buttonDim, buttonDim);
rAdd .setRect( addX, addY, buttonDim, buttonDim);
rSubPage .setRect(subPageX, subPageY, subPageW, subPageH);
rAddPage .setRect(addPageX, addPageY, addPageW, addPageH);
rSlider .setRect( sliderX, sliderY, sliderW, sliderH);
}
void PhaseStyle::drawSlider (QPainter * p, int x, int y,
int w, int h, const QColorGroup &g,
Orientation o, bool, bool ) {
int cx = x + w/2;
int cy = y + h/2;
QBrush brush = g.brush( QColorGroup::Button );
if ( o == Horizontal ) {
drawBevelButton(p, cx-5, y, 6, h, g, false,
&brush );
drawBevelButton(p, cx, y, 6, h, g, false,
&brush );
}else {
drawBevelButton(p, x, cy-5, w, 6, g, false,
&brush );
drawBevelButton(p, x, cy, w, 6, g, false,
&brush );
}
}
void PhaseStyle::drawSliderGroove(QPainter* p, int x, int y,
int w, int h, const QColorGroup& g,
QCOORD , Orientation o ) {
int cx = x + w/2;
int cy = y + h/2;
if ( o == Horizontal ) {
y = cy-3; h = 7;
}else {
x = cx-3; w = 7;
}
drawPanel(p, x, y, w, h, g, true, 1,
&g.brush(QColorGroup::Mid ) );
}
diff --git a/noncore/styles/phase/phasestyle.h b/noncore/styles/phase/phasestyle.h
index cbaa534..ae53efe 100644
--- a/noncore/styles/phase/phasestyle.h
+++ b/noncore/styles/phase/phasestyle.h
@@ -1,167 +1,169 @@
//////////////////////////////////////////////////////////////////////////////
// phasestyle.h
// -------------------
// A style for KDE
// -------------------
// Copyright (c) 2004 David Johnson <david@usermode.org>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//////////////////////////////////////////////////////////////////////////////
#ifndef PHASESTYLE_H
#define PHASESTYLE_H
#include <qstyle.h>
#include <qwindowsstyle.h>
#include <qcolor.h>
class KPixmap;
class PhaseStyle : public QWindowsStyle
{
Q_OBJECT
public:
PhaseStyle();
virtual ~PhaseStyle();
- void polish( QWidget * );
- void polish( QPalette& );
- void polish( QApplication* );
+ virtual void polish( QWidget * );
+ virtual void polish( QPalette& );
+ virtual void polish( QApplication* a);
+ virtual void unPolish( QWidget * );
+ virtual void unPolish(QApplication *a);
void drawCheckMark ( QPainter * p, int x, int y, int w,
int h, const QColorGroup & g,
bool act, bool dis );
void drawArrow(QPainter *p, Qt::ArrowType type, bool down,
int x, int y, int w, int h, const QColorGroup &g,
bool enabled=true, const QBrush *fill = 0);
void drawPushButton(QPushButton* btn, QPainter* p );
void drawPushButtonLabel(QPushButton* btn, QPainter* p );
void drawPanel(QPainter* p, int , int, int, int,
const QColorGroup&, bool sunken = false,
int lineWidth = 1, const QBrush *b = 0l );
void drawButton( QPainter*, int x, int y, int w, int h,
const QColorGroup&, bool sunken = false,
const QBrush* fill = 0);
void drawBevelButton(QPainter*, int, int, int, int,
const QColorGroup&, bool sunken = false,
const QBrush* fill = 0 );
void drawFocusRect( QPainter* p, const QRect& r,
const QColorGroup&, const QColor* = 0,
bool atBorder = false );
void drawButtonMask( QPainter* p, int x, int y,
int w, int h );
/* Menu Stuff */
void drawSeperator( QPainter* p, int x, int y, int w,
int h, const QColorGroup& group, bool sunken = true,
int lineWidth = 1, int midLineWidtth = 0 );
void drawMenuBarItem(QPainter* p, int x, int y, int w, int h,
QMenuItem *mi, QColorGroup& g, bool enabled,
bool act);
/* RadioButton, CheckBox... */
void drawIndicator(QPainter* p, int x, int y, int w, int h,
const QColorGroup &g, int state, bool down = FALSE,
bool enabled = TRUE );
void drawExclusiveIndicator( QPainter*, int, int, int, int,
const QColorGroup&, bool on,
bool down = false,bool enabled = true );
void drawExclusiveIndicatorMask (QPainter*, int, int, int, int, bool );
/* spacing,dimensions */
int defaultFrameWidth () const;
int popupMenuItemHeight ( bool checkable,
QMenuItem * mi,
const QFontMetrics & fm );
int extraPopupMenuItemWidth(bool checkable, int maxpmw,
QMenuItem* mi, const QFontMetrics& fm );
QSize indicatorSize()const;
QSize exclusiveIndicatorSize()const;
void getButtonShift( int &x, int &y );
/* popup drawing */
void drawPopupMenuItem ( QPainter * p, bool checkable, int maxpmw,
int tab, QMenuItem * mi,
const QPalette & pal, bool act,
bool enabled, int x, int y,
int w, int h );
/* combo box */
QRect comboButtonRect ( int x, int y, int w, int h );
void drawComboButton( QPainter * p, int x, int y,
int w, int h,
const QColorGroup & g,
bool sunken = FALSE,
bool editable = FALSE,
bool enabled = TRUE,
const QBrush * fill = 0 );
/* tabbar */
void drawTab(QPainter*, const QTabBar*, QTab*,
bool selected );
void drawTabMask( QPainter*, const QTabBar*, QTab*,
bool );
void tabbarMetrics( const QTabBar* t, int &hframe, int &vframe, int &overlap);
/* tool button */
void drawToolButton ( QPainter * p, int x, int y,
int w, int h,
const QColorGroup & g,
bool sunken = FALSE,
const QBrush * fill = 0 );
/* scrollbar */
void drawScrollBarControls ( QPainter *, const QScrollBar *,
int sliderStart, uint controls,
uint activeControl );
void scrollBarMetrics( const QScrollBar*, int&, int&, int&, int& );
QStyle::ScrollControl scrollBarPointOver( const QScrollBar*, int sliderStart,
const QPoint& );
/* slider drawing */
void drawSlider ( QPainter * p, int x, int y, int w, int h,
const QColorGroup & g, Orientation,
bool tickAbove, bool tickBelow );
void drawSliderGroove ( QPainter * p, int x, int y, int w,
int h, const QColorGroup & g,
QCOORD c, Orientation );
private:
void drawPhaseGradient(QPainter* p,
const QRect& rec,
const QColor& col )const;
static void scrollBarItemPositions( const QScrollBar *,
const bool horizontal,
int sliderStart,
int sliderMax,
int sliderLength,
int buttomDim,
QRect& sub,
QRect& add,
QRect& subPage,
QRect& addPage,
QRect& slider );
};
#endif