| -rw-r--r-- | noncore/styles/phase/.cvsignore | 3 | ||||
| -rw-r--r-- | noncore/styles/phase/README | 47 | ||||
| -rw-r--r-- | noncore/styles/phase/bitmaps.h | 70 | ||||
| -rw-r--r-- | noncore/styles/phase/config.in | 4 | ||||
| -rw-r--r-- | noncore/styles/phase/phase.pro | 15 | ||||
| -rw-r--r-- | noncore/styles/phase/phasestyle.cpp | 1221 | ||||
| -rw-r--r-- | noncore/styles/phase/phasestyle.h | 166 | ||||
| -rw-r--r-- | noncore/styles/phase/plugin.cpp | 71 | ||||
| -rw-r--r-- | noncore/styles/phase/plugin.h | 54 |
9 files changed, 1651 insertions, 0 deletions
diff --git a/noncore/styles/phase/.cvsignore b/noncore/styles/phase/.cvsignore new file mode 100644 index 0000000..c8de896 --- a/dev/null +++ b/noncore/styles/phase/.cvsignore @@ -0,0 +1,3 @@ +Makefile* +*.moc +.obj diff --git a/noncore/styles/phase/README b/noncore/styles/phase/README new file mode 100644 index 0000000..5dc9e9c --- a/dev/null +++ b/noncore/styles/phase/README @@ -0,0 +1,47 @@ +Opie Phase is based on the style from David Johnson +and was backported to Qt2 by Holger Hans Peter Freyther + + + +Original PHASE 0.4 README + + +Phase, Version 0.x +================== + +Phase is a look and feel for KDE. It is designed to be functional but not drab +and aesthetic but not distracting. Artistic design draws upon the genius of +earlier masters. This is particularly true for minimalistic designs. Therefore +I cannot in good conscience claim this look to be truly original. But I have +done my best. + +The Phase widget style is built as a KDE plugin, but is also useful for +standalone Qt programs provided that the KDE libraries are installed. Please +read the INSTALL file for installation instructions. You can activate the +style through the KDE Control Center. + +Please note that Phase requires KDE 3.x and above. It will not build or run +under earlier versions of KDE. Full functionality requires KDE 3.2 or greater. +The Phase homepage is at <http://www.usermode.org/code.html>. + +================= + +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. diff --git a/noncore/styles/phase/bitmaps.h b/noncore/styles/phase/bitmaps.h new file mode 100644 index 0000000..28bc1db --- a/dev/null +++ b/noncore/styles/phase/bitmaps.h @@ -0,0 +1,70 @@ +////////////////////////////////////////////////////////////////////////////// +// bitmaps.h +// ------------------- +// Bitmaps for Phase +// ------------------- +// Copyright (c) 2004 David Johnson +// Please see the phasestyle.h file for copyright and license information. +////////////////////////////////////////////////////////////////////////////// + +// Note: the "light" bits are drawn with midlight color + +// Arrows (6x6) + +#include <qbitmap.h> + +static QBitmap uarrow; +static unsigned char uarrow_bits[] = { + 0x00, 0x0c, 0x1e, 0x3f, 0x3f, 0x00}; + +static QBitmap darrow; +static unsigned char darrow_bits[] = { + 0x00, 0x3f, 0x3f, 0x1e, 0x0c, 0x00}; + +static QBitmap larrow; +static unsigned char larrow_bits[] = { + 0x18, 0x1c, 0x1e, 0x1e, 0x1c, 0x18}; + +static QBitmap rarrow; +static unsigned char rarrow_bits[] = { + 0x06, 0x0e, 0x1e, 0x1e, 0x0e, 0x06}; + +// plus/minus "arrows" + +static QBitmap bplus; +static unsigned char bplus_bits[] = { + 0x0c, 0x0c, 0x3f, 0x3f, 0x0c, 0x0c}; + +static QBitmap bminus; +static unsigned char bminus_bits[] = { + 0x00, 0x00, 0x3f, 0x3f, 0x00, 0x00}; + +// checkmark (9x9) + +static QBitmap bcheck; +static unsigned char bcheck_bits[] = { + 0x00, 0x00, 0x80, 0x01, 0xc0, 0x01, 0xe0, 0x00, 0x73, 0x00, 0x3f, 0x00, + 0x1e, 0x00, 0x0c, 0x00, 0x00, 0x00}; + +// expander arrows (9x9) + +static QBitmap dexpand; +static unsigned char dexpand_bits[] = { + 0x00, 0x00, 0x00, 0x00, 0xff, 0x01, 0xfe, 0x00, 0x7c, 0x00, 0x38, 0x00, + 0x10, 0x00, 0x00, 0x00, 0x00, 0x00}; + +static QBitmap rexpand; +static unsigned char rexpand_bits[] = { + 0x04, 0x00, 0x0c, 0x00, 0x1c, 0x00, 0x3c, 0x00, 0x7c, 0x00, 0x3c, 0x00, + 0x1c, 0x00, 0x0c, 0x00, 0x04, 0x00}; + +// scrollbar doodads (4x4) + +static QBitmap doodad_mid; +static unsigned char doodad_mid_bits[] = { + 0x07, 0x01, 0x01, 0x00}; + +static QBitmap doodad_light; +static unsigned char doodad_light_bits[] = { + 0x00, 0x08, 0x08, 0x0e}; + diff --git a/noncore/styles/phase/config.in b/noncore/styles/phase/config.in new file mode 100644 index 0000000..40949e6 --- a/dev/null +++ b/noncore/styles/phase/config.in @@ -0,0 +1,4 @@ + config PHASE + boolean "Phase Style 0.4 port" + default "n" + depends ( LIBQPE || LIBQPE-X11 ) diff --git a/noncore/styles/phase/phase.pro b/noncore/styles/phase/phase.pro new file mode 100644 index 0000000..7ec3d01 --- a/dev/null +++ b/noncore/styles/phase/phase.pro @@ -0,0 +1,15 @@ +TEMPLATE = lib +CONFIG = qt plugin embedded warn_on +SOURCES = phasestyle.cpp \ + plugin.cpp +HEADERS = bitmaps.h \ + phasestyle.h \ + plugin.h + +LIBS += -lqpe +INCLUDEPATH += $(OPIEDIR)/include +DESTDIR = $(OPIEDIR)/plugins/styles +TARGET = phase +VERSION = 0.4.0 + +include ( $(OPIEDIR)/include.pro ) diff --git a/noncore/styles/phase/phasestyle.cpp b/noncore/styles/phase/phasestyle.cpp new file mode 100644 index 0000000..fb6411c --- a/dev/null +++ b/noncore/styles/phase/phasestyle.cpp @@ -0,0 +1,1221 @@ +////////////////////////////////////////////////////////////////////////////// +// 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::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::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.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->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 )); + + + bool odd = (h % 2); + drawPanel(p, w-15 , y+(h/2)-3, 10, (odd ? 7 : 6 ), + g, true , 1, sunken ? &g.brush(QColorGroup::Midlight) + : &g.brush(QColorGroup::Mid) ); + + 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::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; + else + 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 new file mode 100644 index 0000000..ab593e6 --- a/dev/null +++ b/noncore/styles/phase/phasestyle.h @@ -0,0 +1,166 @@ +////////////////////////////////////////////////////////////////////////////// +// 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* ); + + + 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 ); + + /* 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 diff --git a/noncore/styles/phase/plugin.cpp b/noncore/styles/phase/plugin.cpp new file mode 100644 index 0000000..8396c0a --- a/dev/null +++ b/noncore/styles/phase/plugin.cpp @@ -0,0 +1,71 @@ +/* + =. This file is part of the OPIE Project + .=l. Copyright (c) 2002 Holger Hans Peter Freyther <zecke@handhelds.org> + .>+-= + _;:, .> :=|. This program is free software; you can +.> <`_, > . <= redistribute it and/or modify it under +:`=1 )Y*s>-.-- : the terms of the GNU General Public +.="- .-=="i, .._ License as published by the Free Software + - . .-<_> .<> Foundation; either version 2 of the License, + ._= =} : or (at your option) any later version. + .%`+i> _;_. + .i_,=:_. -<s. This program 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 + -_. . . )=. = General Public License along with + -- :-=` this library; see the file COPYING. + If not, write to the Free Software Foundation, + Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. + +*/ + +#include "plugin.h" + +#include "phasestyle.h" + +#include <qapplication.h> + +PhaseStyleImpl::PhaseStyleImpl() + : m_style( 0l ) +{} + +/* Qt will delete the style */ +PhaseStyleImpl::~PhaseStyleImpl() +{} + +QRESULT PhaseStyleImpl::queryInterface( const QUuid& uuid, QUnknownInterface **iface ) { + *iface = 0; + + if ( uuid == IID_QUnknown || uuid == IID_Style) + *iface = this; + else + return QS_FALSE; + + (*iface)->addRef(); + + return QS_OK; +} + +QStyle* PhaseStyleImpl::style() { + if (!m_style ) + m_style = new PhaseStyle(); + return m_style; +} + +QString PhaseStyleImpl::name()const { + return qApp->translate("PhaseStyle", "Phase", "Name of the style Phase"); +} + + +Q_EXPORT_INTERFACE() +{ + Q_CREATE_INSTANCE( PhaseStyleImpl ) +} + diff --git a/noncore/styles/phase/plugin.h b/noncore/styles/phase/plugin.h new file mode 100644 index 0000000..9340737 --- a/dev/null +++ b/noncore/styles/phase/plugin.h @@ -0,0 +1,54 @@ +/* + =. This file is part of the OPIE Project + .=l. Copyright (c) 2004 Holger Hans Peter Freyther <zecke@handhelds.org> + .>+-= + _;:, .> :=|. This program is free software; you can +.> <`_, > . <= redistribute it and/or modify it under +:`=1 )Y*s>-.-- : the terms of the GNU General Public +.="- .-=="i, .._ License as published by the Free Software + - . .-<_> .<> Foundation; either version 2 of the License, + ._= =} : or (at your option) any later version. + .%`+i> _;_. + .i_,=:_. -<s. This program 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 + -_. . . )=. = General Public License along with + -- :-=` this library; see the file COPYING + If not, write to the Free Software Foundation, + Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. + +*/ + +#ifndef PHASESTYLE_PLUGIN_H +#define PHASESTYLE_PLUGIN_H + +#include <qtopia/styleinterface.h> + + +class PhaseStyle; + +/** + * Factory to create PhaseStyle + */ +class PhaseStyleImpl : public StyleInterface { +public: + PhaseStyleImpl(); + virtual ~PhaseStyleImpl(); + + QRESULT queryInterface( const QUuid&, QUnknownInterface** ); + Q_REFCOUNT + + virtual QStyle *style(); + virtual QString name()const; +private: + PhaseStyle* m_style; +}; + +#endif |