TDE
/
tdeartwork
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdeartwork
0
0
Fork 0
Code Issues Releases Wiki Activity
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.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '714ac1f0c4'
${ noResults }
tdeartwork/styles/phase2/phase2style.cpp

2986 lines
100 KiB
Raw Blame History

//////////////////////////////////////////////////////////////////////////////
// phase2style.cpp
// -------------------
// TQt/TDE widget style
// -------------------
// Copyright (c) 2004 David Johnson
// Please see the header file for copyright and license information.
//////////////////////////////////////////////////////////////////////////////
//
// Some miscellaneous notes
//
// Reimplemented scrollbar metric and drawing routines from TDEStyle to allow
// better placement of subcontrols. This is because the subcontrols slightly
// overlap to share part of their border.
//
// Menu and toolbars are painted with the background color by default. This
// differs from the TQt default of giving them PaletteButton backgrounds.
// Menubars have normal gradients, toolbars have reverse.
//
// Some toolbars are not part of a TQMainWindows, such as in a TDE file dialog.
// In these cases we treat the toolbar as "floating" and paint it flat.
//
//////////////////////////////////////////////////////////////////////////////
#include <kdrawutil.h>
#include <kpixmap.h>
#include <kpixmapeffect.h>
#include <tqapplication.h>
#include <tqintdict.h>
#include <tqpainter.h>
#include <tqpointarray.h>
#include <tqsettings.h>
#include <tqstyleplugin.h>
#include <tqcheckbox.h>
#include <tqcombobox.h>
#include <tqheader.h>
#include <tqmainwindow.h>
#include <tqmenubar.h>
#include <tqpopupmenu.h>
#include <tqprogressbar.h>
#include <tqpushbutton.h>
#include <tqradiobutton.h>
#include <tqscrollbar.h>
#include <tqslider.h>
#include <tqsplitter.h>
#include <tqtabbar.h>
#include <tqtabwidget.h>
#include <tqtextcodec.h>
#include <tqtoolbar.h>
#include <tqtoolbox.h>
#include <tqtoolbutton.h>
#include "phase2style.h"
static const char* TQSPLITTERHANDLE = TQSPLITTERHANDLE_OBJECT_NAME_STRING;
static const char* TQTOOLBAREXTENSION = "TQToolBarExtensionWidget";
static const char* KTOOLBARWIDGET = "tde toolbar widget";
// some convenient constants
static const int ITEMFRAME = 1; // menu stuff
static const int ITEMHMARGIN = 3;
static const int ITEMVMARGIN = 0;
//OBE: static const int ARROWMARGIN = 6;
static const int RIGHTBORDER = 6;
static const int MINICONSIZE = 16;
static const int CHECKSIZE = 9;
static const int MAXGRADIENTSIZE = 64;
static unsigned contrast = 110;
#include "scaling.h"
#include "shapes.h"
/**************************** TO-DO **********************************
* (1) The above "constants" should be re-scaled by the scaling.h
* function Generate_Scaling_Metrics()
* (2) Should the same function pre-draw other basic shapes in sizes
* relative to FONT_Scale?
*********************************************************************/
//#include "plastik-excerpt.cpp"
//////////////////////////////////////////////////////////////////////////////
// Construction, Destruction, Initialization //
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// Phase2Style()
// -----------
// Constructor
Phase2Style::Phase2Style()
: TDEStyle(FilledFrameWorkaround | AllowMenuTransparency,
ThreeButtonScrollBar),
gradients_(TQPixmap::defaultDepth() > 8), kicker_(false)
{
TQSettings settings;
Set_QT3SCALE() ;
Generate_Scaling_Metrics(0) ;
Initialize_Shapes() ;
if (gradients_) { // don't bother setting if already false
gradients_ =
settings.readBoolEntry("/phasestyle/Settings/gradients", true);
contrast = 100 + settings.readNumEntry("/TQt/TDE/contrast", 5);
}
highlights_ =
settings.readBoolEntry("/phasestyle/Settings/highlights", true);
gradients = new TQMap<unsigned int, TQIntDict<GradientSet> >;
reverse_ = TQApplication::reverseLayout();
}
Phase2Style::~Phase2Style()
{
delete gradients;
gradients = 0;
if (KPE_ListViewExpander_ArrowLeft) {
delete KPE_ListViewExpander_ArrowLeft ;
KPE_ListViewExpander_ArrowLeft = 0 ;
}
if (KPE_ListViewExpander_ArrowRight) {
delete KPE_ListViewExpander_ArrowRight ;
KPE_ListViewExpander_ArrowLeft = 0 ;
}
}
//////////////////////////////////////////////////////////////////////////////
// Polishing //
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// polish()
// --------
// Initialize application specific
void Phase2Style::applicationPolish(const TQStyleControlElementData &ceData, ControlElementFlags, void *ptr)
{
if (ceData.widgetObjectTypes.contains(TQAPPLICATION_OBJECT_NAME_STRING)) {
TQApplication *app = reinterpret_cast<TQApplication*>(ptr);
if (!qstrcmp(app->argv()[0], "kicker")) kicker_ = true;
}
}
//////////////////////////////////////////////////////////////////////////////
// polish()
// --------
// Initialize the appearance of a widget
void Phase2Style::polish(const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr)
{
if (ceData.widgetObjectTypes.contains(TQWIDGET_OBJECT_NAME_STRING)) {
TQWidget *widget = reinterpret_cast<TQWidget*>(ptr);
if (::tqqt_cast<TQMenuBar*>(widget) ||
::tqqt_cast<TQPopupMenu*>(widget)) {
// anti-flicker optimization
widget->setBackgroundMode(NoBackground);
} else if (::tqqt_cast<TQFrame*>(widget) ||
widget->inherits(TQTOOLBAREXTENSION) ||
(!qstrcmp(widget->name(), KTOOLBARWIDGET))) {
// needs special handling on paint events
installObjectEventHandler(ceData, elementFlags, ptr, this);
} else if (highlights_ &&
(::tqqt_cast<TQPushButton*>(widget) ||
::tqqt_cast<TQComboBox*>(widget) ||
::tqqt_cast<TQSpinWidget*>(widget) ||
::tqqt_cast<TQCheckBox*>(widget) ||
::tqqt_cast<TQRadioButton*>(widget) ||
::tqqt_cast<TQSlider*>(widget) ||
widget->inherits(TQSPLITTERHANDLE))) {
// mouseover highlighting
installObjectEventHandler(ceData, elementFlags, ptr, this);
} else if (highlights_ && ::tqqt_cast<TQTabBar*>(widget)) {
// highlighting needing mouse tracking
widget->setMouseTracking(true);
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
}
TDEStyle::polish(ceData, elementFlags, ptr);
}
//////////////////////////////////////////////////////////////////////////////
// polish()
// --------
// Initialize the palette
void Phase2Style::polish(TQPalette &pal)
{
// clear out gradients on a color change
gradients->clear();
// lighten up a bit, so the look is not so "crisp"
if (TQPixmap::defaultDepth() > 8) { // but not on low color displays
pal.setColor(TQPalette::Disabled, TQColorGroup::Dark,
pal.color(TQPalette::Disabled, TQColorGroup::Dark).light(contrast));
pal.setColor(TQPalette::Active, TQColorGroup::Dark,
pal.color(TQPalette::Active, TQColorGroup::Dark).light(contrast));
pal.setColor(TQPalette::Inactive, TQColorGroup::Dark,
pal.color(TQPalette::Inactive, TQColorGroup::Dark).light(contrast));
}
TQStyle::polish(pal);
}
//////////////////////////////////////////////////////////////////////////////
// unPolish()
// ----------
// Undo the initialization of a widget's appearance
void Phase2Style::unPolish(const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr)
{
if (ceData.widgetObjectTypes.contains(TQWIDGET_OBJECT_NAME_STRING)) {
TQWidget *widget = reinterpret_cast<TQWidget*>(ptr);
if (::tqqt_cast<TQMenuBar*>(widget) ||
::tqqt_cast<TQPopupMenu*>(widget)) {
widget->setBackgroundMode(PaletteBackground);
} else if (::tqqt_cast<TQFrame*>(widget) ||
widget->inherits(TQTOOLBAREXTENSION) ||
(!qstrcmp(widget->name(), KTOOLBARWIDGET))) {
removeObjectEventHandler(ceData, elementFlags, ptr, this);
} else if (highlights_ && // highlighting
(::tqqt_cast<TQPushButton*>(widget) ||
::tqqt_cast<TQComboBox*>(widget) ||
::tqqt_cast<TQSpinWidget*>(widget) ||
::tqqt_cast<TQCheckBox*>(widget) ||
::tqqt_cast<TQRadioButton*>(widget) ||
::tqqt_cast<TQSlider*>(widget) ||
widget->inherits(TQSPLITTERHANDLE))) {
removeObjectEventHandler(ceData, elementFlags, ptr, this);
} else if (highlights_ && ::tqqt_cast<TQTabBar*>(widget)) {
widget->setMouseTracking(false);
removeObjectEventHandler(ceData, elementFlags, ptr, this);
}
}
TDEStyle::unPolish(ceData, elementFlags, ptr);
}
//////////////////////////////////////////////////////////////////////////////
// Drawing //
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// drawPhaseGradient()
// ------------------
// Draw gradient
void Phase2Style::drawPhaseGradient(TQPainter *painter,
const TQRect &rect,
TQColor color,
bool horizontal,
int px, int py,
int pw, int ph,
bool reverse) const
{
if (!gradients_) {
painter->fillRect(rect, color);
return;
}
// px, py, pw, ph used for parent-relative pixmaps
int size;
if (horizontal)
size = (pw > 0) ? pw : rect.width();
else
size = (ph > 0) ? ph : rect.height();
if (size > MAXGRADIENTSIZE) { // keep it sensible
painter->fillRect(rect, color);
} else {
// lazy allocation
GradientSet *set = (*gradients)[color.rgb()][size];
if (!set) {
set = new GradientSet(color, size);
(*gradients)[color.rgb()].setAutoDelete(true);
(*gradients)[color.rgb()].insert(size, set);
}
painter->drawTiledPixmap(rect, *set->gradient(horizontal, reverse),
TQPoint(px, py));
}
}
//////////////////////////////////////////////////////////////////////////////
// drawPhaseBevel()
// ----------------
// Draw the basic Phase bevel
void Phase2Style::drawPhaseBevel(TQPainter *painter,
int x, int y, int w, int h,
const TQColorGroup &group,
const TQColor &fill,
bool sunken,
bool horizontal,
bool reverse) const
{
int x2 = x + w - 1;
int y2 = y + h - 1;
painter->save();
painter->setPen(group.dark());
painter->drawRect(x, y, w, h);
painter->setPen(sunken ? group.mid() : group.midlight());
painter->drawLine(x+1, y+1, x2-2, y+1);
painter->drawLine(x+1, y+2, x+1, y2-2);
painter->setPen(sunken ? group.midlight() : 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.button());
painter->drawPoint(x+1, y2-1);
painter->drawPoint(x2-1, y+1);
if (sunken) {
// sunken bevels don't get gradients
painter->fillRect(x+2, y+2, w-4, h-4, fill);
} else {
drawPhaseGradient(painter, TQRect(x+2, y+2, w-4, h-4), fill,
horizontal, 0, 0, w-4, h-4, reverse);
}
painter->restore();
}
//////////////////////////////////////////////////////////////////////////////
// drawPhaseButton()
// ----------------
// Draw the basic Phase button
void Phase2Style::drawPhaseButton(TQPainter *painter,
int x, int y, int w, int h,
const TQColorGroup &group,
const TQColor &fill,
bool sunken) const
{
int x2 = x + w - 1;
int y2 = y + h - 1;
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, x2-1, y);
painter->drawLine(x, y+1, x, y2-1);
painter->setPen(group.button());
painter->drawPoint(x, y2);
painter->drawPoint(x2, y);
drawPhaseBevel(painter, x+1, y+1, w-2, h-2, group, fill,
sunken, false, false);
}
//////////////////////////////////////////////////////////////////////////////
// drawPhasePanel()
// ----------------
// Draw the basic Phase panel
void Phase2Style::drawPhasePanel(TQPainter *painter,
int x, int y, int w, int h,
const TQColorGroup &group,
bool sunken,
const TQBrush *fill) const
{
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->color());
}
painter->restore();
}
//////////////////////////////////////////////////////////////////////////////
// drawPhaseTab()
// -------------
// Draw a Phase style tab
void Phase2Style::drawPhaseTab(TQPainter *painter,
int x, int y, int w, int h,
const TQColorGroup &group,
const TQStyleControlElementData &ceData,
ControlElementFlags /*elementFlags*/,
const TQStyleOption &option,
SFlags flags) const
{
bool selected = (flags & Style_Selected);
bool edge; // tab is at edge of bar
const int x2 = x + w - 1;
const int y2 = y + h - 1;
painter->save();
// what position is the tab?
if ((ceData.tabBarData.tabCount == 1)
|| (ceData.tabBarData.identIndexMap[option.tab()->identifier()] == 0)) {
edge = true;
} else {
edge = false;
}
switch (TQTabBar::Shape(ceData.tabBarData.shape)) {
case TQTabBar::RoundedAbove:
case TQTabBar::TriangularAbove: {
// is there a corner widget?
if (!ceData.tabBarData.cornerWidgets[reverse_ ? TQStyleControlElementTabBarData::CWL_TopRight : TQStyleControlElementTabBarData::CWL_TopLeft].widgetObjectTypes.isEmpty()) {
edge = false;
}
if (!selected) { // shorten
y += 2; h -= 2;
}
if (selected) {
painter->setPen(TQt::NoPen);
painter->fillRect(x+1, y+1, w-1, h-1,
group.brush(TQColorGroup::Background));
} else {
drawPhaseGradient(painter, TQRect(x+1, y+1, w-1, h-2),
(flags & Style_MouseOver)
? group.background()
: TQColor(group.background().dark(contrast)),
false, 0, 0, 0, h*2, false);
}
// 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 (!reverse_ && 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 (!reverse_ && edge) {
painter->setPen(group.dark());
painter->drawLine(x, y2-1, x, y2);
}
}
if (reverse_ && edge) {
painter->setPen(group.dark());
painter->drawPoint(x2, y2);
painter->setPen(selected ? group.mid() : group.background());
painter->drawPoint(x2-1, y2);
}
break;
}
case TQTabBar::RoundedBelow:
case TQTabBar::TriangularBelow: {
// is there a corner widget?
if (!ceData.tabBarData.cornerWidgets[reverse_ ? TQStyleControlElementTabBarData::CWL_BottomRight : TQStyleControlElementTabBarData::CWL_BottomLeft].widgetObjectTypes.isEmpty()) {
edge = false;
}
painter->setBrush((selected || (flags & Style_MouseOver))
? group.background()
: TQColor(group.background().dark(contrast)));
painter->setPen(TQt::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 (!reverse_ && 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 (!reverse_ && edge) {
painter->setPen(group.dark());
painter->drawPoint(x, y);
}
}
if (reverse_ && edge) {
painter->setPen(group.dark());
painter->drawPoint(x2, y);
painter->setPen(group.mid());
painter->drawPoint(x2-1, y);
}
break;
}
}
painter->restore();
}
//////////////////////////////////////////////////////////////////////////////
// drawPrimitive()
// ---------------
// Draw the primitive element
void Phase2Style::drawPrimitive(TQ_PrimitiveElement element,
TQPainter *painter,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQRect &rect,
const TQColorGroup &group,
SFlags flags,
const TQStyleOption &option) const
{
// common locals
bool down = flags & Style_Down;
bool on = flags & Style_On;
bool depress = (down || on);
bool enabled = flags & Style_Enabled;
bool horiz = flags & Style_Horizontal;
bool active = flags & Style_Active;
bool mouseover = highlights_ && (flags & Style_MouseOver);
int x, y, w, h, x2, y2, n, cx, cy;
TQPointArray parray;
TQWidget* widget;
rect.rect(&x, &y, &w, &h);
x2 = rect.right();
y2 = rect.bottom();
switch(element) {
case PE_ButtonBevel:
case PE_ButtonDefault:
case PE_ButtonDropDown:
case PE_ButtonTool:
drawPhaseBevel(painter, x,y,w,h, group, group.button(),
depress, false, false);
break;
case PE_ButtonCommand:
drawPhaseButton(painter, x, y, w, h, group,
mouseover ?
TQColor(group.button().light(contrast)) :
group.button(), depress);
break;
case PE_FocusRect: {
TQPen old = painter->pen();
painter->setPen(group.highlight().dark(contrast));
painter->drawRect(rect);
painter->setPen(old);
break;
}
case PE_HeaderSection: {
// covers kicker taskbar buttons and menu titles
TQHeader* header = dynamic_cast<TQHeader*>(painter->device());
widget =dynamic_cast<TQWidget*>(painter->device());
if (header) {
horiz = (header->orientation() ==Qt::Horizontal);
} else {
horiz = true;
}
if ((ceData.widgetObjectTypes.contains(TQPOPUPMENU_OBJECT_NAME_STRING)) ||
(ceData.widgetObjectTypes.contains("TDEPopupTitle"))) {
// kicker/kdesktop menu titles
drawPhaseBevel(painter, x,y,w,h,
group, group.background(), depress, !horiz);
} else if (kicker_) {
// taskbar buttons (assuming no normal headers used in kicker)
if (depress) {
painter->setPen(group.dark());
painter->setBrush(group.brush(TQColorGroup::Mid));
painter->drawRect(x-1, y-1, w+1, h+1);
}
else {
drawPhaseBevel(painter, x-1, y-1, w+1, h+1,
group, group.button(), false, !horiz, true);
}
} else {
// other headers
if (depress) {
painter->setPen(group.dark());
painter->setBrush(group.brush(TQColorGroup::Mid));
painter->drawRect(x-1, y-1, w+1, h+1);
}
else {
drawPhaseBevel(painter, x-1, y-1, w+1, h+1, group,
group.background(), false, !horiz, true);
}
}
break;
}
case PE_HeaderArrow: {
//--- Determine arrow size & position
int arrowSize = ARROW_Size2 ;
int arrowScaling = 0 ;
int vdelta = ( h - arrowSize ) ;
int hdelta = ( w - arrowSize ) ;
int voffset = y + vdelta / 2 ; // vertical alignment: centered
int hoffset = x + hdelta / 2 ; // horizontal alignment: centered
TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ;
//--- Determine arrow direction
TQStyle::PrimitiveElement arrow = PE_ArrowDown ;
if (flags & Style_Up) arrow = PE_ArrowUp ;
//--- Determine arrow color
if (enabled) painter->setPen(
(flags & Style_Sunken) ? group.midlight() : darkBlue );
// ? group.midlight() : group.dark());
else painter->setPen( group.mid() );
//--- Draw arrow
drawArrow(painter, frame, arrow, arrowScaling );
break ;
//--------------------------------------------------------------------
/* Previous code: * /
//--------------------------------------------------------------------
if (flags & Style_Up)
drawArrow(painter, TQRect(x,y,h,w), PE_ArrowUp, 0) ;
//drawPrimitive(PE_ArrowUp, painter, ceData, elementFlags, rect, group, Style_Enabled);
else
drawArrow(painter, TQRect(x,y,h,w), PE_ArrowDown, 0) ;
//drawPrimitive(PE_ArrowDown, painter, ceData, elementFlags, rect, group, Style_Enabled);
break ; /* End of previous code */
}
case PE_ScrollBarAddPage:
case PE_ScrollBarSubPage:
if (h) { // has a height, thus visible
painter->fillRect(rect, group.mid());
painter->setPen(group.dark());
if (horiz) { // vertical
painter->drawLine(x, y, x2, y);
painter->drawLine(x, y2, x2, y2);
} else { // horizontal
painter->drawLine(x, y, x, y2);
painter->drawLine(x2, y, x2, y2);
}
}
break;
case PE_ScrollBarAddLine:
case PE_ScrollBarSubLine: {
drawPhaseBevel(painter, x, y, w, h,
group, group.button(), down, !horiz, true);
//--- Determine arrow direction
TQ_PrimitiveElement arrow = ((horiz) ?
((element == PE_ScrollBarAddLine) ?
PE_ArrowRight : PE_ArrowLeft) :
((element == PE_ScrollBarAddLine) ?
PE_ArrowDown : PE_ArrowUp));
if (down) { // shift arrow
switch (arrow) {
case PE_ArrowRight: x++; break;
case PE_ArrowLeft: x--; break;
case PE_ArrowDown: y++; break;
case PE_ArrowUp: y--; break;
default: break;
}
}
//--- Determine arrow size & position
int arrowSize = ARROW_Size2 ;
int arrowScaling = 0 ;
int vdelta = ( h - arrowSize ) ;
int hdelta = ( w - arrowSize ) ;
int voffset = y + vdelta / 2 ; // vertical alignment: centered
int hoffset = x + hdelta / 2 ; // horizontal alignment: centered
TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ;
//--- Determine arrow color
if (enabled) painter->setPen(
(flags & Style_Sunken) ? group.midlight() : darkBlue );
// ? group.midlight() : group.dark());
else painter->setPen( group.mid() );
//--- Draw arrow
drawArrow(painter, frame, arrow, arrowScaling );
break;
//--------------------------------------------------------------------
/* Previous code: * /
//--------------------------------------------------------------------
//drawPrimitive(arrow, painter, ceData, elementFlags, TQRect(x,y,h,w), group, flags);
drawArrow(painter, TQRect(x,y,h,w), arrow, 4) ;
break ; /* End of previous code */
}
case PE_ScrollBarSlider:
drawPhaseBevel(painter, x, y, w, h, group, group.button(),
false, !horiz, true);
// draw doodads
cx = x + w/2 - 2; cy = y + h/2 - 2;
if (horiz && (w >=20)) {
for (n = -5; n <= 5; n += 5) {
kColorBitmaps(painter, group, cx+n, cy,
0, &doodad_mid, &doodad_light, 0, 0, 0);
}
} else if (!horiz && (h >= 20)) {
for (n = -5; n <= 5; n += 5) {
kColorBitmaps(painter, group, cx, cy+n,
0, &doodad_mid, &doodad_light, 0, 0, 0);
}
}
break;
case PE_Indicator:
drawPhasePanel(painter, x+1, y+1, w-2, h-2, group, true, enabled ?
&group.brush(TQColorGroup::Base) :
&group.brush(TQColorGroup::Background));
if (on) {
painter->setPen(mouseover
? TQColor(group.highlight().dark(contrast))
: group.dark());
painter->drawRect(x+4, y+4, w-8, h-8);
painter->fillRect(x+5, y+5, w-10, h-10,
group.brush(TQColorGroup::Highlight));
} else if (mouseover) {
painter->setPen(TQColor(group.highlight().dark(contrast)));
painter->drawRect(x+4, y+4, w-8, h-8);
}
break;
case PE_IndicatorMask:
painter->fillRect(x+1, y+1, w-2, h-2, TQt::color1);
painter->setPen(TQt::color0);
break;
case PE_ExclusiveIndicator: {
// note that this requires an even size from pixelMetric
cx = (x + x2) / 2;
cy = (y + y2) / 2;
painter->setBrush(enabled
? group.brush(TQColorGroup::Base)
: group.brush(TQColorGroup::Background));
painter->setPen(group.dark());
parray.putPoints(0, 8,
x+1,cy+1, x+1,cy, cx,y+1, cx+1,y+1,
x2-1,cy, x2-1,cy+1, cx+1,y2-1, cx,y2-1);
painter->drawConvexPolygon(parray, 0, 8);
painter->setPen(group.mid());
parray.putPoints(0, 4, x,cy, cx,y, cx+1,y, x2,cy);
painter->drawPolyline(parray, 0, 4);
painter->setPen(group.midlight());
parray.putPoints(0, 4, x2,cy+1, cx+1,y2, cx,y2, x,cy+1);
painter->drawPolyline(parray, 0, 4);
if (on) {
painter->setBrush(group.brush(TQColorGroup::Highlight));
painter->setPen(mouseover
? TQColor(group.highlight().dark(contrast))
: group.dark());
parray.putPoints(0, 8,
x+4,cy+1, x+4,cy, cx,y+4, cx+1,y+4,
x2-4,cy, x2-4,cy+1, cx+1,y2-4, cx,y2-4);
painter->drawConvexPolygon(parray, 0, 8);
} else if (mouseover) {
painter->setPen(TQColor(group.highlight().dark(contrast)));
parray.putPoints(0, 9,
x+4,cy+1, x+4,cy, cx,y+4, cx+1,y+4,
x2-4,cy, x2-4,cy+1, cx+1,y2-4, cx,y2-4,
x+4,cy+1);
painter->drawPolyline(parray, 0, 9);
}
break;
}
case PE_ExclusiveIndicatorMask:
cx = (x + x2) / 2;
cy = (y + y2) / 2;
painter->setBrush(TQt::color1);
painter->setPen(TQt::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->drawConvexPolygon(parray, 0, 8);
painter->setPen(TQt::color0);
break;
case PE_DockWindowResizeHandle:
drawPhasePanel(painter, x, y, w, h, group, false,
&group.brush(TQColorGroup::Background));
break;
case PE_Splitter:
cx = x + w/2 - 2; cy = y + h/2 - 2;
painter->fillRect(rect,
(flags & Style_MouseOver)
? TQColor(group.background().light(contrast))
: group.background());
if (!horiz && (w >=20)) {
for (n = -5; n <= 5; n += 5) {
kColorBitmaps(painter, group, cx+n, cy,
0, &doodad_mid, &doodad_light, 0, 0, 0);
}
} else if (horiz && (h >= 20)) {
for (n = -5; n <= 5; n += 5) {
kColorBitmaps(painter, group, cx, cy+n,
0, &doodad_mid, &doodad_light, 0, 0, 0);
}
}
break;
case PE_Panel:
case PE_PanelLineEdit:
case PE_PanelTabWidget:
case PE_TabBarBase:
drawPhasePanel(painter, x, y, w, h, group, flags & Style_Sunken);
break;
case PE_PanelPopup:
case PE_WindowFrame:
drawPhasePanel(painter, x, y, w, h, group, false);
break;
case PE_GroupBoxFrame:
case PE_PanelGroupBox:
painter->setPen(group.dark());
painter->drawRect(rect);
break;
case PE_Separator:
painter->setPen(group.dark());
if (w < h)
painter->drawLine(w/2, y, w/2, y2);
else
painter->drawLine(x, h/2, x2, h/2);
break;
case PE_StatusBarSection:
painter->setPen(group.mid());
painter->drawLine(x, y, x2-1, y);
painter->drawLine(x, y+1, x, y2-1);
painter->setPen(group.midlight());
painter->drawLine(x+1, y2, x2, y2);
painter->drawLine(x2, y+1, x2, y2-1);
break;
case PE_PanelMenuBar:
case PE_PanelDockWindow:
if (kicker_ && (w == 2)) { // kicker handle separator
painter->setPen(group.mid());
painter->drawLine(x, y, x, y2);
painter->setPen(group.midlight());
painter->drawLine(x+1, y, x+1, y2);
} else if (kicker_ && (h == 2)) { // kicker handle separator
painter->setPen(group.mid());
painter->drawLine(x, y, x2, y);
painter->setPen(group.midlight());
painter->drawLine(x, y+1, x2, y+1);
} else {
--x; --y; ++w; ++h; // adjust rect so we can use bevel
drawPhaseBevel(painter, x, y, w, h,
group, group.background(), false, (w < h),
(element==PE_PanelDockWindow) ? true : false);
}
break;
case PE_DockWindowSeparator: {
widget = dynamic_cast<TQWidget*>(painter->device());
bool flat = true;
if (ceData.parentWidgetData.widgetObjectTypes.contains(TQTOOLBAR_OBJECT_NAME_STRING)) {
TQToolBar *toolbar = ::tqqt_cast<TQToolBar*>(widget->parent());
if (toolbar) {
// toolbar not floating or in a TQMainWindow
flat = flatToolbar(ceData, elementFlags, toolbar);
}
}
if (flat)
painter->fillRect(rect, group.background());
else
drawPhaseGradient(painter, rect, group.background(),
!(horiz), 0, 0, -1, -1, true);
if (horiz) {
int cx = w/2 - 1;
painter->setPen(group.mid());
painter->drawLine(cx, 0, cx, h-2);
if (!flat) painter->drawLine(0, h-1, w-1, h-1);
painter->setPen(group.midlight());
painter->drawLine(cx+1, 0, cx+1, h-2);
} else {
int cy = h/2 - 1;
painter->setPen(group.mid());
painter->drawLine(0, cy, w-2, cy);
if (!flat) painter->drawLine(w-1, 0, w-1, h-1);
painter->setPen(group.midlight());
painter->drawLine(0, cy+1, w-2, cy+1);
}
break;
}
case PE_SizeGrip: {
int sw = TQMIN(h, w) - 1;
y = y2 - sw;
if (reverse_) {
x2 = x + sw;
for (int n = 0; n < 4; ++n) {
painter->setPen(group.dark());
painter->drawLine(x, y, x2, y2);
painter->setPen(group.midlight());
painter->drawLine(x, y+1, x2-1, y2);
y += 3;;
x2 -= 3;;
}
} else {
x = x2 - sw;
for (int n = 0; n < 4; ++n) {
painter->setPen(group.dark());
painter->drawLine(x, y2, x2, y);
painter->setPen(group.midlight());
painter->drawLine(x+1, y2, x2, y+1);
x += 3;
y += 3;
}
}
break;
}
case PE_CheckMark:
drawCheckmark(painter, rect, 4 );
break ;
painter->setPen(group.text());
painter->drawPixmap(x+w/2-4, y+h/2-4, bcheck);
break;
case PE_SpinWidgetPlus:
case PE_SpinWidgetMinus:
if (enabled)
painter->setPen((flags & Style_Sunken)
? group.midlight() : group.dark());
else
painter->setPen(group.mid());
painter->drawPixmap(x+w/2-3, y+h/2-3,
(element==PE_SpinWidgetPlus) ? bplus : bminus);
break;
case PE_SpinWidgetUp: {
// painter->drawPixmap(x+w/2-3, y+h/2-3, uarrow); break ;
//--- Determine arrow size & position
//int arrowSize = ARROW_Size4x3 ;
//int arrowScaling = 1 ;
int arrowSize = ARROW_Size2 ;
int arrowScaling = 1 ;
int vdelta = ( h - arrowSize ) ;
int hdelta = ( w - arrowSize ) ;
int voffset = y + vdelta ; // vertical alignment: top
int hoffset = x + hdelta / 2 ; // horizontal alignment: centered
TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ;
//--- Determine arrow direction
TQStyle::PrimitiveElement arrow = PE_ArrowUp ;
//--- Determine arrow color
if (flags & Style_Enabled) {
painter->setPen((flags & Style_Sunken)
? group.midlight() : group.dark());
painter->setPen(darkBlue) ;
}
else {
painter->setPen(group.mid());
}
//--- Draw arrow
drawArrow(painter, frame, arrow, arrowScaling );
break ;
//--------------------------------------------------------------------
/* Previous code: * /
//--------------------------------------------------------------------
drawArrow(painter, rect, element, 3) ;
//drawArrow(painter, TQRect(x+w/2,y+h/2+3,h,w), element, 1) ;
//painter->drawPixmap(x+w/2-3, y+h/2-3, uarrow);
//drawArrow(painter, TQRect(x,y,h,w), element, 1) ;
break ; /* End of previous code */
}
case PE_SpinWidgetDown: {
// painter->drawPixmap(x+w/2-3, y+h/2-3, darrow); break ;
//--- Determine arrow size & position
//int arrowSize = ARROW_Size4x3 ;
//int arrowScaling = 1 ;
int arrowSize = ARROW_Size2 ;
int arrowScaling = 1 ;
int vdelta = ( h - arrowSize ) ;
int hdelta = ( w - arrowSize ) ;
int voffset = y ; ; // vertical alignment: bottom
int hoffset = x + hdelta / 2 ; // horizontal alignment: centered
TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ;
//--- Determine arrow direction
TQStyle::PrimitiveElement arrow = PE_ArrowDown ;
//--- Determine arrow color
if (flags & Style_Enabled) {
painter->setPen((flags & Style_Sunken)
? group.midlight() : group.dark());
painter->setPen(darkBlue) ;
}
else {
painter->setPen(group.mid());
}
//--- Draw arrow
drawArrow(painter, frame, arrow, arrowScaling );
break ;
//--------------------------------------------------------------------
/* Previous code: * /
//--------------------------------------------------------------------
if (flags & Style_Enabled) {
painter->setPen((flags & Style_Sunken)
? group.midlight() : group.dark());
painter->setPen(blue) ;
}
else {
painter->setPen(group.mid());
}
drawArrow(painter, rect, element, 3) ;
//drawArrow(painter, TQRect(x+w/2,y+h/2-3,h,w), element, 1) ;
//painter->drawPixmap(x+w/2-3, y+h/2-3, darrow);
//drawArrow(painter, TQRect(x,y,h,w), element, 1) ;
break ; /* End of previous code */
}
case PE_ArrowUp:
case PE_ArrowDown:
case PE_ArrowLeft:
case PE_ArrowRight: {
//--- Determine arrow size & position
int arrowSize = ARROW_Size4 ;
int arrowScaling = -1 ;
int vdelta = ( h - arrowSize ) ;
int hdelta = ( w - arrowSize ) ;
int voffset = y + vdelta / 2 ; // vertical alignment: centered
int hoffset = x + hdelta / 2 ; // horizontal alignment: centered
TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ;
//--- Determine arrow color
if (flags & Style_Enabled) {
painter->setPen((flags & Style_Sunken)
? group.midlight() : group.dark());
}
else {
painter->setPen(group.mid());
}
//--- Draw arrow
if ( FONT_Scale <= 1.00 )
//--- Invoke legacy code that relies on hardcoded bitmaps
drawArrowBitmap( painter, frame, element ) ;
else
//--- Invoke new code that relies on dynamic drawing routines
drawArrow(painter, frame, element, arrowScaling );
break ;
//--------------------------------------------------------------------
/* Previous code: * /
//--------------------------------------------------------------------
if (flags & Style_Enabled) {
// painter->setPen((flags & Style_Sunken)
// ? group.midlight() : group.dark());
painter->setPen(black) ;
}
else {
painter->setPen(group.mid());
}
drawArrow(painter, rect, element, -1) ;
// painter->drawPixmap(x+w/2-3, y+h/2-3, uarrow);
// painter->drawPixmap(x+w/2-3, y+h/2-3, darrow);
// painter->drawPixmap(x+w/2-3, y+h/2-3, larrow);
// painter->drawPixmap(x+w/2-3, y+h/2-3, rarrow);
break ; /* End of previous code */
}
case PE_MenuItemIndicatorFrame: {
// Draw nothing
break;
}
case PE_MenuItemIndicatorIconFrame: {
// Draw nothing
break;
}
case PE_MenuItemIndicatorCheck: {
int checkwidth = styleHint(SH_MenuIndicatorColumnWidth, ceData, elementFlags, option, NULL, NULL);
int cx = reverse_ ? x+w - checkwidth : x;
drawPrimitive(PE_CheckMark, painter, ceData, elementFlags,
TQRect(cx + ITEMFRAME, y + ITEMFRAME,
checkwidth - ITEMFRAME*2, h - ITEMFRAME*2),
group, Style_Default |
(active ? Style_Enabled : Style_On));
break;
}
default:
TDEStyle::drawPrimitive(element, painter, ceData, elementFlags, rect, group, flags, option);
}
}
//////////////////////////////////////////////////////////////////////////////
// drawTDEStylePrimitive()
// ---------------------
// Draw the element
void Phase2Style::drawTDEStylePrimitive(TDEStylePrimitive element,
TQPainter *painter,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQRect &rect,
const TQColorGroup &group,
SFlags flags,
const TQStyleOption &option,
const TQWidget *widget) const
{
bool horiz = flags & Style_Horizontal;
int x, y, w, h, x2, y2, n, cx, cy;
rect.rect(&x, &y, &w, &h);
x2 = rect.right();
y2 = rect.bottom();
cx = x + w/2;
cy = y + h/2;
switch (element) {
case KPE_ToolBarHandle:
cx-=2; cy-=2;
drawPhaseGradient(painter, rect, group.background(),
!horiz, 0, 0, w-1, h-1, true);
if (horiz) {
for (n = -5; n <= 5; n += 5) {
kColorBitmaps(painter, group, cx, cy+n,
0, &doodad_mid, &doodad_light, 0, 0, 0);
}
painter->setPen(group.mid());
painter->drawLine(x, y2, x2, y2);
} else {
for (n = -5; n <= 5; n += 5) {
kColorBitmaps(painter, group, cx+n, cy,
0, &doodad_mid, &doodad_light, 0, 0, 0);
}
painter->setPen(group.mid());
painter->drawLine(x2, y, x2, y2);
}
break;
//case KPE_DockWindowHandle:
case KPE_GeneralHandle:
cx-=2; cy-=2;
painter->fillRect(rect, group.brush(TQColorGroup::Background));
if (horiz) {
for (n = -5; n <= 5; n += 5) {
kColorBitmaps(painter, group, cx, cy+n,
0, &doodad_mid, &doodad_light, 0, 0, 0);
}
} else {
for (n = -5; n <= 5; n += 5) {
kColorBitmaps(painter, group, cx+n, cy,
0, &doodad_mid, &doodad_light, 0, 0, 0);
}
}
break;
case KPE_ListViewExpander:
{
//--------------------------------------------------------------------
/* METHOD 0: Let TDE draw the default style /
//--------------------------------------------------------------------
TDEStyle::drawTDEStylePrimitive(element, painter, ceData, elementFlags, rect,
group, flags, option, widget);
break ; /* End of METHOD 0 */
//--- Determine arrow size & position
int arrowSize = ARROW_Size2 ;
int arrowScaling = 1 ;
int vdelta = ( h - arrowSize ) ;
int hdelta = ( w - arrowSize ) ;
int voffset = y + vdelta / 2 ; // vertical alignment: centered
int hoffset = x + hdelta / 2 ; // horizontal alignment: centered
TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ;
/**************************** FIXME **********************************
* First tree view suffers from a visible and relatively prolonged
* "rippling" effect that NONE of the methods below seem to address.
* This actually seems to be a problem with most widget styles!
*
* We are still encountering challenges drawing appropriately scaled
* +|- (i.e. scaled relative to FONT_Size). For some reason, the
* rectangle we are passed is *ALWAYS* 9x9 px and we have not been
* able find the reason why. Debugging statements we have used:
fprintf(stderr,
"Rectangle pos (size): H - %3d + %3d x V - %3d + %3d\n",
x, h, y, w
);
fprintf(stderr,
"Arrow position (siz): H - %3d + %3d x V - %3d + %3d\n",
hoffset, arrowSize, voffset, arrowSize
);
fprintf(stderr,
"Pixelmetrics:\n PE_CheckListController='%d'\n PE_CheckListIndicator='%d'\n PE_CheckListExclusiveIndicator='%d'\n\n",
(int)PE_CheckListController, (int)PE_CheckListIndicator, (int)PE_CheckListExclusiveIndicator
) ;
fprintf(stderr, "Checkbox size = %d \n\n", FONT_Size & 0xfffe);
*********************************************************************/
//--------------------------------------------------------------------
/* METHOD 1: Directly draw the arrows */
//--------------------------------------------------------------------
//--- Determine arrow direction
TQStyle::PrimitiveElement arrow = PE_ArrowLeft ;
if (flags & Style_On) arrow = PE_ArrowRight ;
//--- Determine arrow color
painter->setPen(group.mid());
//--- Draw arrow vector
drawArrow(painter, frame, arrow, arrowScaling );
break ; /* End of METHOD 1 */
//--------------------------------------------------------------------
/* METHOD 2a: Generate reusable arrow pixmaps, then "draw" them * /
//--------------------------------------------------------------------
//--- Generate reusable arrow pixmaps
if (! KPE_ListViewExpander_ArrowLeft ) {
KPE_ListViewExpander_ArrowLeft =
Create_Arrow_Pix(PE_ArrowLeft, arrowSize, arrowScaling) ;
}
if (!KPE_ListViewExpander_ArrowRight ) {
KPE_ListViewExpander_ArrowRight =
Create_Arrow_Pix(PE_ArrowRight, arrowSize, arrowScaling) ;
}
//--- Determine arrow direction
TQPixmap * arrow_pix = KPE_ListViewExpander_ArrowLeft ;
if (flags & Style_On) arrow_pix = KPE_ListViewExpander_ArrowRight ;
//--- Determine arrow color
painter->setPen(group.mid());
//--- Draw arrow pixmap
painter->drawPixmap(frame, *arrow_pix );
break ;
/* End of METHOD 2a */
//--------------------------------------------------------------------
/* METHOD 2b: Generate reusable arrow pixmaps, then "bitBlt" them * /
// (inspired by Asteroid CC_Slider code)
//--------------------------------------------------------------------
//--- Generate reusable arrow pixmaps
if (! KPE_ListViewExpander_ArrowLeft ) {
KPE_ListViewExpander_ArrowLeft =
Create_Arrow_Pix(PE_ArrowLeft, arrowSize, arrowScaling) ;
}
if (!KPE_ListViewExpander_ArrowRight ) {
KPE_ListViewExpander_ArrowRight =
Create_Arrow_Pix(PE_ArrowRight, arrowSize, arrowScaling) ;
}
//--- Determine arrow direction
TQPixmap * arrow_pix = KPE_ListViewExpander_ArrowLeft ;
if (flags & Style_On) arrow_pix = KPE_ListViewExpander_ArrowRight ;
//--- Determine arrow color
painter->setPen(group.mid());
//--- BitBlt arrow pixmap (allegedly faster)
bitBlt(
painter->device(), hoffset, voffset,
arrow_pix, 0, 0, arrowSize, arrowSize,
Qt::CopyROP, true
) ;
// FIXME: draws only black arrows - maybe color needs to aready be in pixmap?
break ; /* End of METHOD 2b */
//--------------------------------------------------------------------
/* METHOD 3: Generate reusable arrow images, then "draw" them * /
//--------------------------------------------------------------------
//--- Generate reusable arrow images
if (! iKPE_ListViewExpander_ArrowLeft )
iKPE_ListViewExpander_ArrowLeft =
Create_Arrow_Image(PE_ArrowLeft, arrowSize, arrowScaling) ;
if (! iKPE_ListViewExpander_ArrowRight )
iKPE_ListViewExpander_ArrowRight =
Create_Arrow_Image(PE_ArrowRight, arrowSize, arrowScaling) ;
//--- Determine arrow direction
TQImage * arrow_img = iKPE_ListViewExpander_ArrowLeft ;
if (flags & Style_On) arrow_img = iKPE_ListViewExpander_ArrowRight ;
//--- Determine arrow color
painter->setPen(group.mid());
//--- Draw arrow image
painter->drawImage(frame, *arrow_img );
break /* End of METHOD 3 */ ;
//--------------------------------------------------------------------
/* METHOD 4a: Draw +|- instead of arrows (cribbed from Plastik) * /
//--------------------------------------------------------------------
arrowSize = ARROW_Size2 ;
arrowScaling = 0 ;
vdelta = ( h - arrowSize ) ;
hdelta = ( w - arrowSize ) ;
voffset = y + vdelta / 2 ; // vertical alignment: centered
hoffset = x + hdelta / 2 ; // horizontal alignment: centered
frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ;
// Typical Windows style expand/collapse element.
int radius = (frame.width() - 4) / 2;
int centerx = rect.x() + rect.width()/2;
int centery = rect.y() + rect.height()/2;
// Outer box
painter->setPen( group.mid() );
painter->drawRect( frame );
// plus or minus
painter->setPen( group.text() );
painter->drawLine( centerx - radius, centery, centerx + radius, centery );
if ( flags & Style_On ) // Collapsed = On
painter->drawLine( centerx, centery - radius, centerx, centery + radius );
break ; /* End of METHOD 4a */
//--------------------------------------------------------------------
/* METHOD 4b: Draw +|- instead of arrows (cribbed from Plastik) * /
//--------------------------------------------------------------------
TQPen mypen ; mypen.setWidth(1) ; mypen.setColor(black) ;
painter->setPen(mypen) ;
//frame = TQRect(hoffset-1, voffset-1, arrowSize, arrowSize) ;
int radius = frame.width() / 2 ;
int centerx = rect.x() + rect.width()/2;
int centery = rect.y() + rect.height()/2 ;
painter->drawRect( frame );
painter->drawLine( centerx - radius , centery, centerx + radius, centery );
if (flags & Style_On)
painter->drawLine( centerx, centery - radius, centerx, centery + radius ) ;
break ; /* End of METHOD 4b */
//--------------------------------------------------------------------
/* Previous code: * /
//--------------------------------------------------------------------
if (flags & Style_On) {
// drawArrow(painter, rect, PE_ArrowRight, -(QT3SCALE-0)) ;
drawArrow(painter, TQRect(x+offset, y+offset, arrowSize, arrowSize), PE_ArrowRight, 1 );
// painter->drawPixmap(x+w/2-4, y+h/2-4, rexpand);
} else {
drawArrow(painter, rect, PE_ArrowLeft, -(QT3SCALE-0)) ;
// painter->drawPixmap(x+w/2-4, y+h/2-4, dexpand);
}
break ; /* End of previous code */
}
case KPE_ListViewBranch:
painter->setPen(group.mid());
if (flags & Style_Horizontal) {
painter->drawLine(x, cy, x2, cy);
} else {
painter->drawLine(cx, y, cx, y2);
}
break;
case KPE_SliderGroove: {
if (ceData.orientation == TQt::Horizontal) {
y = cy - 3;
h = 7;
} else {
x = cx - 3;
w = 7;
}
drawPhasePanel(painter, x, y, w, h, group, true,
&group.brush(TQColorGroup::Mid));
break;
}
case KPE_SliderHandle: {
TQColor color = (flags & Style_MouseOver)
? TQColor(group.button().light(contrast))
: group.button();
if (ceData.orientation == TQt::Horizontal) {
drawPhaseBevel(painter, cx-5, y, 6, h, group, color,
false, false, false);
drawPhaseBevel(painter, cx, y, 6, h, group, color,
false, false, false);
} else {
drawPhaseBevel(painter, x, cy-5, w, 6, group, color,
false, true, false);
drawPhaseBevel(painter, x, cy, w, 6, group, color,
false, true, false);
}
break;
}
default:
TDEStyle::drawTDEStylePrimitive(element, painter, ceData, elementFlags, rect,
group, flags, option, widget);
}
}
//////////////////////////////////////////////////////////////////////////////
// drawControl()
// -------------
// Draw the control
void Phase2Style::drawControl(TQ_ControlElement element,
TQPainter *painter,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQRect &rect,
const TQColorGroup &group,
SFlags flags,
const TQStyleOption &option,
const TQWidget *widget) const
{
bool active, enabled, depress;
int x, y, w, h, x2, y2, dx;
TQMenuItem *mi;
TQIconSet::Mode mode;
TQIconSet::State state;
TQPixmap pixmap;
rect.rect(&x, &y, &w, &h);
x2 = rect.right();
y2 = rect.bottom();
switch (element) {
case CE_PushButton: {
depress = flags & (Style_Down | Style_On);
int bd = pixelMetric(PM_ButtonDefaultIndicator, ceData, elementFlags, widget) + 1;
if ((flags & Style_ButtonDefault) && !depress) {
drawPhasePanel(painter, x, y, w, h, group, true,
&group.brush(TQColorGroup::Mid));
drawPhaseBevel(painter, x+bd, y+bd, w-bd*2, h-bd*2, group,
(flags & Style_MouseOver)
? TQColor(group.button().light(contrast))
: group.button(),
false, false, false);
} else {
drawPhaseButton(painter, x, y, w, h, group,
(flags & Style_MouseOver)
? TQColor(group.button().light(contrast))
: group.button(), depress);
}
if (flags & Style_HasFocus) { // draw focus
drawPrimitive(PE_FocusRect, painter, ceData, elementFlags,
subRect(SR_PushButtonFocusRect, ceData, elementFlags, widget),
group, flags);
}
break;
}
case CE_PushButtonLabel: {
const TQPushButton* button = ::tqqt_cast<const TQPushButton*>(widget);
if (!button) {
TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group,
flags, option, widget);
return;
}
active = button->isOn() || button->isDown();
if (active) { // shift contents
x++; y++;
flags |= Style_Sunken;
}
if (button->isMenuButton()) { // menu indicator
int dx = pixelMetric(PM_MenuButtonIndicator, ceData, elementFlags, widget);
//drawPrimitive(PE_ArrowDown, painter, ceData, elementFlags,
// TQRect(x+w-dx-2, y+2, dx, h-4),
// group, flags, option);
if (flags & Style_Enabled) {
painter->setPen(green) ;
}
else {
painter->setPen(yellow) ;
}
drawArrow(painter, TQRect(x+w-dx-2, y+2, dx, h-4), PE_ArrowDown, 3) ;
w -= dx;
}
/**************************** FIXME **********************************
*********************************************************************/
if (button->iconSet() && !button->iconSet()->isNull()) { // draw icon
if (button->isEnabled()) {
if (button->hasFocus()) {
mode = TQIconSet::Active;
} else {
mode = TQIconSet::Normal;
}
} else {
mode = TQIconSet::Disabled;
}
if (button->isToggleButton() && button->isOn()) {
state = TQIconSet::On;
} else {
state = TQIconSet::Off;
}
pixmap = button->iconSet()->pixmap(TQIconSet::Small, mode, state);
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, TQRect(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, TQRect(x, y, w, h),
AlignCenter | ShowPrefix,
button->colorGroup(),
button->isEnabled(),
button->pixmap(),
button->text(), -1,
(button->isEnabled()) ?
&button->colorGroup().buttonText() :
&button->colorGroup().mid());
}
break;
}
case CE_CheckBoxLabel:
case CE_RadioButtonLabel: {
const TQButton *b = ::tqqt_cast<const TQButton*>(widget);
if (!b) return;
int alignment = reverse_ ? AlignRight : AlignLeft;
drawItem(painter, rect, alignment | AlignVCenter | ShowPrefix,
group, flags & Style_Enabled, b->pixmap(), b->text());
// only draw focus if content (forms on html won't)
if ((flags & Style_HasFocus) && ((!b->text().isNull()) || b->pixmap())) {
drawPrimitive(PE_FocusRect, painter, ceData, elementFlags,
visualRect(subRect(SR_RadioButtonFocusRect, ceData, elementFlags,
widget), ceData, elementFlags),
group, flags);
}
break;
}
case CE_DockWindowEmptyArea: {
const TQToolBar *tb = ::tqqt_cast<const TQToolBar*>(widget);
if (tb) {
// toolbar not floating or in a TQMainWindow
if (flatToolbar(ceData, elementFlags, tb)) {
if (tb->backgroundMode() == PaletteButton)
// force default button color to background color
painter->fillRect(rect, group.background());
else
painter->fillRect(rect, tb->paletteBackgroundColor());
}
}
break;
}
case CE_MenuBarEmptyArea:
drawPhaseGradient(painter, TQRect(x, y, w, h), group.background(),
(w<h), 0, 0, 0, 0, false);
break;
case CE_MenuBarItem: {
const TQMenuBar *mbar = ::tqqt_cast<const TQMenuBar*>(widget);
if (!mbar) {
TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group,
flags, option, widget);
return;
}
mi = option.menuItem();
TQRect prect = mbar->rect();
if ((flags & Style_Active) && (flags & Style_HasFocus)) {
if (flags & Style_Down) {
drawPhasePanel(painter, x, y, w, h, group, true,
&group.brush(TQColorGroup::Background));
} else {
drawPhaseBevel(painter, x, y, w, h,
group, group.background(),
false, false, false);
}
} else {
drawPhaseGradient(painter, rect, group.background(), false, x, y,
prect.width()-2, prect.height()-2, false);
}
drawItem(painter, rect,
AlignCenter | AlignVCenter |
DontClip | ShowPrefix | SingleLine,
group, flags & Style_Enabled,
mi->pixmap(), mi->text());
break;
}
case CE_PopupMenuItem: {
if (!ceData.widgetObjectTypes.contains(TQPOPUPMENU_OBJECT_NAME_STRING)) {
TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group,
flags, option, widget);
return;
}
// We'll need these values for both arrows and text, so define them here
int arrowSize = ARROW_Size2 ;
int arrowRmargin = arrowSize / 2 ;
mi = option.menuItem();
if (!mi) {
painter->fillRect(rect, group.button());
break;
}
int tabwidth = option.tabWidth();
int checkwidth = option.maxIconWidth();
bool checkable = (elementFlags & CEF_IsCheckable);
bool etchtext = styleHint(SH_EtchDisabledText, ceData, elementFlags);
active = flags & Style_Active;
enabled = mi->isEnabled();
TQRect vrect;
if (checkable) checkwidth = TQMAX(checkwidth, 20);
// draw background
if (active && enabled) {
painter->fillRect(x, y, w, h, group.highlight());
} else if (!ceData.bgPixmap.isNull()) {
painter->drawPixmap(x, y, ceData.bgPixmap, x, y, w, h);
} else {
painter->fillRect(x, y, w, h, group.background());
}
// draw separator
if (mi->isSeparator()) {
painter->setPen(group.dark());
painter->drawLine(x+checkwidth+1, y+1, x2-checkwidth-1, y+1);
painter->setPen(group.mid());
painter->drawLine(x+checkwidth, y, x2-checkwidth-1, y);
painter->drawPoint(x+checkwidth, y+1);
painter->setPen(group.midlight());
painter->drawLine(x+checkwidth+1, y2, x2-checkwidth, y2);
painter->drawPoint(x2-checkwidth, y2-1);
break;
}
// draw icon
if (mi->iconSet() && !mi->isChecked()) {
if (active)
mode = enabled ? TQIconSet::Active : TQIconSet::Disabled;
else
mode = enabled ? TQIconSet::Normal : TQIconSet::Disabled;
pixmap = mi->iconSet()->pixmap(TQIconSet::Small, mode);
TQRect pmrect(0, 0, pixmap.width(), pixmap.height());
vrect = visualRect(TQRect(x, y, checkwidth, h), rect);
pmrect.moveCenter(vrect.center());
painter->drawPixmap(pmrect.topLeft(), pixmap);
}
// draw check
if (mi->isChecked()) {
drawPrimitive(PE_MenuItemIndicatorCheck, painter, ceData, elementFlags, TQRect(x, y, checkwidth, h), group, flags, option);
}
// draw text
int xm = ITEMFRAME + checkwidth + ITEMHMARGIN;
int xp = reverse_ ?
x + tabwidth + RIGHTBORDER + ITEMHMARGIN + ITEMFRAME - 1 :
x + xm;
int offset = reverse_ ? -1 : 1;
int tw = w - xm - tabwidth - (arrowSize + arrowRmargin)
- ITEMHMARGIN * 3 - ITEMFRAME + 1 ;
painter->setPen(enabled ? (active ? group.highlightedText() :
group.buttonText()) : group.mid());
if (mi->custom()) { // draws own label
painter->save();
if (etchtext && !enabled && !active) {
painter->setPen(group.light());
mi->custom()->paint(painter, group, active, enabled,
xp+offset, y+ITEMVMARGIN+1,
tw, h-2*ITEMVMARGIN);
painter->setPen(group.mid());
}
mi->custom()->paint(painter, group, active, enabled,
xp, y+ITEMVMARGIN, tw, h-2*ITEMVMARGIN);
painter->restore();
}
else { // draw label
TQString text = mi->text();
if (!text.isNull()) {
int t = text.find('\t');
int tflags = AlignVCenter | DontClip |
ShowPrefix | SingleLine |
(reverse_ ? AlignRight : AlignLeft);
if (t >= 0) {
int tabx = reverse_ ?
x + RIGHTBORDER + ITEMHMARGIN + ITEMFRAME :
x + w - tabwidth - RIGHTBORDER - ITEMHMARGIN
- ITEMFRAME;
// draw right label (accerator)
if (etchtext && !enabled) { // etched
painter->setPen(group.light());
painter->drawText(tabx+offset, y+ITEMVMARGIN+1,
tabwidth, h-2*ITEMVMARGIN,
tflags, text.mid(t+1));
painter->setPen(group.mid());
}
painter->drawText(tabx, y+ITEMVMARGIN,
tabwidth, h-2*ITEMVMARGIN,
tflags, text.mid(t+1));
text = text.left(t);
}
// draw left label
if (etchtext && !enabled) { // etched
painter->setPen(group.light());
painter->drawText(xp+offset, y+ITEMVMARGIN+1,
tw, h-2*ITEMVMARGIN,
tflags, text, t);
painter->setPen(group.mid());
}
painter->drawText(xp, y+ITEMVMARGIN,
tw, h-2*ITEMVMARGIN,
tflags, text, t);
}
else if (mi->pixmap()) { // pixmap as label
pixmap = *mi->pixmap();
if (pixmap.depth() == 1)
painter->setBackgroundMode(Qt::OpaqueMode);
dx = ((w - pixmap.width()) / 2) + ((w - pixmap.width()) % 2);
painter->drawPixmap(x+dx, y+ITEMFRAME, pixmap);
if (pixmap.depth() == 1)
painter->setBackgroundMode(Qt::TransparentMode);
}
}
if (mi->popup()) { // draw submenu arrow
TQ_PrimitiveElement arrow = reverse_ ? PE_ArrowLeft : PE_ArrowRight;
// arrowSize & arrowRmargin were defined earlier
int arrowScaling = 1 ;
int vdelta = ( h - arrowSize ) ;
int hdelta = ( w - arrowSize - arrowRmargin ) ;
int voffset = y + vdelta / 2 ; // vertical alignment: centered
int hoffset = x + hdelta ; // horizontal alignment: right
TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ;
/* CUT - Debugging statements
fprintf(stderr,
"Rectangle pos (size): V - %3d + %3d x H - %3d + %3d\n",
x, h, y, w
);
fprintf(stderr,
"Arrow position (siz): V - %3d + %3d x H- %3d + %3d\n",
voffset, arrowSize, hoffset, arrowSize
);
//fprintf(stderr, " or at %d (h) x %d (v)\n", vrect.left(), vrect.top());
CUT */
if (flags & Style_Enabled) {
painter->setPen(black) ;
}
else {
painter->setPen(group.mid());
}
drawArrow(painter, frame, arrow, arrowScaling );
//--------------------------------------------------------------------
/* Previous code: * /
//--------------------------------------------------------------------
int dim = (h-2*ITEMFRAME) / 2;
vrect = visualRect(TQRect(x + w - ARROWMARGIN - ITEMFRAME - dim,
y + h / 2 - dim / 2, dim, dim), rect);
// drawPrimitive(arrow, painter, ceData, elementFlags, vrect, group,
// enabled ? Style_Enabled : Style_Default);
if (flags & Style_Enabled) {
painter->setPen(red) ;
}
else {
painter->setPen(group.mid());
}
drawArrow(painter, vrect, arrow, -3+(QT3SCALE*3)) ;
// drawArrow(painter, vrect, arrow, 3) ;
/* End of previous code */
}
break;
}
case CE_TabBarTab: {
if (ceData.widgetObjectTypes.contains(TQTABBAR_OBJECT_NAME_STRING)) {
// this guy can get complicated, we we do it elsewhere
drawPhaseTab(painter, x, y, w, h, group, ceData, elementFlags, option,
flags);
} else { // not a tabbar
TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group,
flags, option, widget);
return;
}
break;
}
case CE_ProgressBarGroove: {
drawPhasePanel(painter, x, y, w, h, group, true,
&group.brush(TQColorGroup::Base));
break;
}
case CE_ProgressBarContents: {
if (!ceData.widgetObjectTypes.contains(TQPROGRESSBAR_OBJECT_NAME_STRING)) {
TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group,
flags, option, widget);
return;
}
subRect(SR_ProgressBarContents, ceData, elementFlags, widget).rect(&x, &y, &w, &h);
painter->setBrush(group.brush(TQColorGroup::Highlight));
painter->setPen(group.dark());
if (!ceData.totalSteps) {
// busy indicator
int bar = pixelMetric(PM_ProgressBarChunkWidth, ceData, elementFlags, widget) + 2;
int progress = ceData.currentStep % ((w-bar) * 2);
if (progress > (w-bar)) progress = 2 * (w-bar) - progress;
painter->drawRect(x+progress+1, y+1, bar-2, h-2);
} else {
double progress = static_cast<double>(ceData.currentStep) /
static_cast<double>(ceData.totalSteps);
dx = static_cast<int>(w * progress);
if (dx < 4) break;
if (reverse_) x += w - dx;
painter->drawRect(x+1, y+1, dx-2, h-2);
}
break;
}
case CE_ToolBoxTab: {
const TQToolBox *box = ::tqqt_cast<const TQToolBox*>(widget);
if (!box) {
TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group,
flags, option, widget);
return;
}
const int rx = x2 - 20;
const int cx = rx - h + 1;
TQPointArray parray(6);
parray.putPoints(0, 6,
x-1,y, cx,y, rx-2,y2-2, x2+1,y2-2,
x2+1,y2+2, x-1,y2+2);
if (box->currentItem() && (flags & Style_Selected)) {
painter->setPen(group.dark());
painter->setBrush(box->currentItem()->paletteBackgroundColor());
painter->drawConvexPolygon(parray, 0, 6);
painter->setBrush(NoBrush);
} else {
painter->setClipRegion(parray, TQPainter::CoordPainter);
drawPhaseGradient(painter, rect,
group.background(),
false, 0, 0, 0, h*2, false);
painter->setClipping(false);
painter->drawPolyline(parray, 0, 4);
}
parray.putPoints(0, 4, x,y+1, cx,y+1, rx-2,y2-1, x2,y2-1);
painter->setPen(group.midlight());
painter->drawPolyline(parray, 0, 4);
break;
}
default:
TDEStyle::drawControl(element, painter, ceData, elementFlags, rect, group,
flags, option, widget);
}
}
//////////////////////////////////////////////////////////////////////////////
// drawControlMask()
// -----------------
// Draw a bitmask for the element
void Phase2Style::drawControlMask(TQ_ControlElement element,
TQPainter *painter,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQRect &rect,
const TQStyleOption &option,
const TQWidget *widget) const
{
switch (element) {
case CE_PushButton:
painter->fillRect(rect, TQt::color1);
painter->setPen(TQt::color0);
break;
default:
TDEStyle::drawControlMask(element, painter, ceData, elementFlags, rect, option, widget);
}
}
//////////////////////////////////////////////////////////////////////////////
// drawComplexControl()
// --------------------
// Draw a complex control
void Phase2Style::drawComplexControl(TQ_ComplexControl control,
TQPainter *painter,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQRect &rect,
const TQColorGroup &group,
SFlags flags,
SCFlags controls,
SCFlags active,
const TQStyleOption &option,
const TQWidget *widget) const
{
bool down = flags & Style_Down;
bool on = flags & Style_On;
bool raised = flags & Style_Raised;
bool sunken = flags & Style_Sunken;
TQRect subrect;
int x, y, w, h, x2, y2;
rect.rect(&x, &y, &w, &h);
switch (control) {
case CC_ComboBox: {
sunken = (active == SC_ComboBoxArrow);
drawPhaseButton(painter, x, y, w, h, group,
(flags & Style_MouseOver)
? TQColor(group.button().light(contrast))
: group.button(), sunken);
if (controls & SC_ComboBoxArrow) { // draw arrow box
TQ_PrimitiveElement arrow = PE_ArrowDown;
int arrowSize = ARROW_Size2 ;
int arrowRmargin = arrowSize / 2 ;
int arrowScaling = 0 ;
int vdelta = ( h - arrowSize ) ;
int hdelta = ( w - arrowSize - arrowRmargin ) ;
int voffset = y + vdelta / 2 ; // vertical alignment: centered
int hoffset = x + hdelta ; // horizontal alignment: right
TQRect frame = TQRect(hoffset, voffset, arrowSize, arrowSize) ;
painter->setPen(darkBlue);
drawArrow(painter, frame, arrow, arrowScaling );
//--------------------------------------------------------------------
/* Previous code: * /
//--------------------------------------------------------------------
subrect = visualRect(querySubControlMetrics(CC_ComboBox, ceData, elementFlags,
SC_ComboBoxArrow, TQStyleOption::Default, widget), ceData, elementFlags);
subrect.rect(&x, &y, &w, &h);
int slot = TQMAX(h/4, 6) + (h % 2);
drawPhasePanel(painter, x+3, y+(h/2)-(slot/2), w-6,
slot, group, true,
sunken ? &group.brush(TQColorGroup::Midlight)
: &group.brush(TQColorGroup::Mid));
/* End of previous code */
}
if (controls & SC_ComboBoxEditField) { // draw edit box
if (elementFlags & CEF_IsEditable) { // editable box
subrect = visualRect(querySubControlMetrics(CC_ComboBox,
ceData, elementFlags, SC_ComboBoxEditField, TQStyleOption::Default, widget), ceData, elementFlags);
x2 = subrect.right(); y2 = subrect.bottom();
painter->setPen(group.dark());
painter->drawLine(x2+1, y, x2+1, y2);
painter->setPen(group.midlight());
painter->drawLine(x2+2, y, x2+2, y2-1);
painter->setPen(group.button());
painter->drawPoint(x2+2, y2);
} else if (elementFlags & CEF_HasFocus) { // non editable box
subrect = visualRect(subRect(SR_ComboBoxFocusRect, ceData, elementFlags,
widget), ceData, elementFlags);
drawPrimitive(PE_FocusRect, painter, ceData, elementFlags, subrect, group,
Style_FocusAtBorder,
TQStyleOption(group.highlight()));
}
}
painter->setPen(group.buttonText()); // for subsequent text
break;
}
case CC_ScrollBar: {
// always a three button scrollbar
TQRect srect;
bool horizontal = (ceData.orientation == TQt::Horizontal);
SFlags scrollflags = (horizontal ? Style_Horizontal : Style_Default);
if (ceData.minSteps == ceData.maxSteps) scrollflags |= Style_Default;
else scrollflags |= Style_Enabled;
// addline
if (controls & SC_ScrollBarAddLine) {
srect = querySubControlMetrics(control, ceData, elementFlags,
SC_ScrollBarAddLine, option, widget);
if (srect.isValid())
drawPrimitive(PE_ScrollBarAddLine, painter, ceData, elementFlags, srect, group,
scrollflags | ((active == SC_ScrollBarAddLine)
? Style_Down : Style_Default));
}
// subline (two of them)
if (controls & SC_ScrollBarSubLine) {
// top/left subline
srect = querySubControlMetrics(control, ceData, elementFlags,
SC_ScrollBarSubLine, option, widget);
if (srect.isValid())
drawPrimitive(PE_ScrollBarSubLine, painter, ceData, elementFlags, srect, group,
scrollflags | ((active == SC_ScrollBarSubLine)
? Style_Down : Style_Default));
// bottom/right subline
srect = querySubControlMetrics(control, ceData, elementFlags,
SC_ScrollBarAddLine, option, widget);
if (srect.isValid()) {
if (horizontal) srect.moveBy(-srect.width()+1, 0);
else srect.moveBy(0, -srect.height()+1);
drawPrimitive(PE_ScrollBarSubLine, painter, ceData, elementFlags, srect, group,
scrollflags | ((active == SC_ScrollBarSubLine)
? Style_Down : Style_Default));
}
}
// addpage
if (controls & SC_ScrollBarAddPage) {
srect = querySubControlMetrics(control, ceData, elementFlags,
SC_ScrollBarAddPage, option, widget);
if (srect.isValid()) {
if (horizontal) srect.addCoords(1, 0, 1, 0);
else srect.addCoords(0, 1, 0, 1);
drawPrimitive(PE_ScrollBarAddPage, painter, ceData, elementFlags, srect, group,
scrollflags | ((active == SC_ScrollBarAddPage)
? Style_Down : Style_Default));
}
}
// subpage
if (controls & SC_ScrollBarSubPage) {
srect = querySubControlMetrics(control, ceData, elementFlags,
SC_ScrollBarSubPage, option, widget);
if (srect.isValid()) {
drawPrimitive(PE_ScrollBarSubPage, painter, ceData, elementFlags, srect, group,
scrollflags | ((active == SC_ScrollBarSubPage)
? Style_Down : Style_Default));
}
}
// slider
if (controls & SC_ScrollBarSlider) {
if (ceData.minSteps == ceData.maxSteps) {
// maxed out
srect = querySubControlMetrics(control, ceData, elementFlags,
SC_ScrollBarGroove, option, widget);
} else {
srect = querySubControlMetrics(control, ceData, elementFlags,
SC_ScrollBarSlider, option, widget);
}
if (srect.isValid()) {
if (horizontal) srect.addCoords(0, 0, 1, 0);
else srect.addCoords(0, 0, 0, 1);
drawPrimitive(PE_ScrollBarSlider, painter, ceData, elementFlags, srect, group,
scrollflags | ((active == SC_ScrollBarSlider)
? Style_Down : Style_Default));
// focus
if (elementFlags & CEF_HasFocus) {
srect.addCoords(2, 2, -2, -2);
drawPrimitive(PE_FocusRect, painter, ceData, elementFlags, srect, group,
Style_Default);
}
}
}
break;
}
case CC_SpinWidget: {
//-Former experiment: #include "plastik-CC_SpinWidget.cpp"
const TQSpinWidget *spin = ::tqqt_cast<const TQSpinWidget*>(widget);
if (!spin) {
TDEStyle::drawComplexControl(control, painter, ceData, elementFlags, rect, group,
flags, controls, active, option, widget);
return;
}
TQ_PrimitiveElement element;
// draw frame
if (controls & SC_SpinWidgetFrame) {
drawPhasePanel(painter, x, y, w, h, group, true, NULL);
}
// draw button field
if (controls & SC_SpinWidgetButtonField) {
subrect = querySubControlMetrics(CC_SpinWidget, ceData, elementFlags,
SC_SpinWidgetButtonField,
option, widget);
if (reverse_) subrect.moveLeft(spin->upRect().left());
drawPhaseBevel(painter, subrect.x(), subrect.y(),
subrect.width(), subrect.height(), group,
(flags & Style_MouseOver)
? TQColor(group.button().light(contrast))
: group.button(), false, false, false);
}
// draw up arrow
if (controls & SC_SpinWidgetUp) {
subrect = spin->upRect();
sunken = (active == SC_SpinWidgetUp);
if (spin->buttonSymbols() == TQSpinWidget::PlusMinus)
element = PE_SpinWidgetPlus;
else
element = PE_SpinWidgetUp;
drawPrimitive(element, painter, ceData, elementFlags, subrect, group, flags
| ((active == SC_SpinWidgetUp)
? Style_On | Style_Sunken : Style_Raised));
}
// draw down button
if (controls & SC_SpinWidgetDown) {
subrect = spin->downRect();
sunken = (active == SC_SpinWidgetDown);
if (spin->buttonSymbols() == TQSpinWidget::PlusMinus)
element = PE_SpinWidgetMinus;
else
element = PE_SpinWidgetDown;
drawPrimitive(element, painter, ceData, elementFlags, subrect, group, flags
| ((active == SC_SpinWidgetDown)
? Style_On | Style_Sunken : Style_Raised));
}
break;
}
case CC_ToolButton: {
const TQToolButton *btn = ::tqqt_cast<const TQToolButton*>(widget);
TQToolBar *toolbar;
bool horiz = true;
bool normal = !(down || on || raised); // normal button state
x2 = rect.right();
y2 = rect.bottom();
// check for TQToolBar parent
if (ceData.parentWidgetData.widgetObjectTypes.contains(TQTOOLBAR_OBJECT_NAME_STRING)) {
toolbar = (btn)?::tqqt_cast<TQToolBar*>(btn->parent()):NULL;
horiz = (ceData.toolBarData.orientation == TQt::Horizontal);
if (normal) { // draw background
if (toolbar && flatToolbar(ceData, elementFlags, toolbar)) {
// toolbar not floating or in a TQMainWindow
painter->fillRect(rect, group.background());
} else {
drawPhaseGradient(painter, rect, group.background(),
!horiz, 0, 0,
ceData.parentWidgetData.rect.width()-3,
ceData.parentWidgetData.rect.height()-3, true);
painter->setPen(group.mid());
if (horiz) {
painter->drawLine(x, y2, x2, y2);
} else {
painter->drawLine(x2, y, x2, y2);
}
}
}
}
// check for TQToolBarExtensionWidget parent
else if (btn && ceData.parentWidgetData.widgetObjectTypes.contains(TQTOOLBAREXTENSION)) {
TQWidget *extension;
if ((extension = ::tqqt_cast<TQWidget*>(btn->parent()))) {
toolbar = ::tqqt_cast<TQToolBar*>(extension->parent());
if (toolbar) {
horiz = (toolbar->orientation() == Qt::Horizontal);
if (normal) { // draw background
drawPhaseGradient(painter, rect, group.background(),
!horiz, 0, 0, toolbar->width()-3,
toolbar->height()-3, true);
}
}
}
}
// check for background pixmap
else if (normal &&
!ceData.parentWidgetData.bgPixmap.isNull()) {
TQPixmap pixmap = ceData.parentWidgetData.bgPixmap;
painter->drawTiledPixmap(rect, pixmap, ceData.pos);
}
// everything else
else if (normal) {
// toolbutton not on a toolbar
painter->fillRect(rect, group.background());
}
// now draw active buttons
if (down || on) {
drawPhasePanel(painter, x, y, w, h, group, true,
&group.brush(TQColorGroup::Button));
} else if (raised) {
drawPhaseBevel(painter, x, y, w, h, group, group.button(),
false, !horiz, true);
}
painter->setPen(group.text());
break;
}
default:
TDEStyle::drawComplexControl(control, painter, ceData, elementFlags, rect, group,
flags, controls, active, option, widget);
break;
}
}
//////////////////////////////////////////////////////////////////////////////
// drawComplexControlMask()
// ------------------------
// Draw a bitmask for the control
void Phase2Style::drawComplexControlMask(TQ_ComplexControl control,
TQPainter *painter,
const TQStyleControlElementData &ceData,
const ControlElementFlags elementFlags,
const TQRect &rect,
const TQStyleOption &option,
const TQWidget *widget) const
{
switch (control) {
case CC_ComboBox:
case CC_ToolButton: {
painter->fillRect(rect, TQt::color1);
painter->setPen(TQt::color0);
break;
}
default:
TDEStyle::drawComplexControlMask(control,painter,ceData,elementFlags,rect,option,widget);
}
}
//////////////////////////////////////////////////////////////////////////////
// pixelMetric()
// -------------
// Get the pixel metric for metric
int Phase2Style::pixelMetric(PixelMetric metric, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQWidget *widget) const
{
// not using widget's font, so that all metrics are uniform
int em = FONT_Size ;
//-Instead of: int em = TQMAX(TQApplication::fontMetrics().strikeOutPos() * 3, 17);
switch (metric) {
case PM_DefaultFrameWidth:
return 2; //*QT3SCALE;
case PM_ButtonDefaultIndicator: // size of default indicator
return 2*FONT_Scale;
case PM_ButtonMargin: // Space betweeen frame and label
return 3*FONT_Scale;
case PM_TabBarTabOverlap: // Amount of tab overlap
return 1*FONT_Scale;
case PM_TabBarTabHSpace: // extra tab spacing
return 24*FONT_Scale;
case PM_TabBarTabVSpace:
if (ceData.widgetObjectTypes.contains(TQTABBAR_OBJECT_NAME_STRING)) {
if (ceData.tabBarData.shape == TQTabBar::RoundedAbove) {
return 10*FONT_Scale;
} else {
return 6*FONT_Scale;
}
}
return 0;
case PM_ExclusiveIndicatorWidth: // radiobutton size
case PM_ExclusiveIndicatorHeight:
case PM_IndicatorWidth: // checkbox size
case PM_IndicatorHeight:
case PM_CheckListButtonSize: // checkbox size in qlistview items
case PM_ScrollBarExtent: // base width of a vertical scrollbar
return em & 0xfffe;
case PM_SplitterWidth: // width of spitter
return (em / 3) & 0xfffe;
case PM_ScrollBarSliderMin: // minimum length of slider
return em * 2;
case PM_SliderThickness: // slider thickness
case PM_SliderControlThickness:
return em;
case PM_MenuIndicatorFrameHBorder:
case PM_MenuIndicatorFrameVBorder:
case PM_MenuIconIndicatorFrameHBorder:
case PM_MenuIconIndicatorFrameVBorder:
return ITEMFRAME*FONT_Scale;
default:
return TDEStyle::pixelMetric(metric, ceData, elementFlags, widget)*FONT_Scale;
}
}
//////////////////////////////////////////////////////////////////////////////
// subRect()
// ---------
// Return subrect for the widget in logical coordinates
TQRect Phase2Style::subRect(SubRect rect, const TQStyleControlElementData &ceData, const ControlElementFlags elementFlags, const TQWidget *widget) const
{
switch (rect) {
case SR_ComboBoxFocusRect: {
TQRect r = querySubControlMetrics(CC_ComboBox, ceData, elementFlags,
SC_ComboBoxEditField, TQStyleOption::Default, widget);
r.addCoords(1, 1,-1,-1);
return r;
}
default:
return TDEStyle::subRect(rect, ceData, elementFlags, widget);
}
}
//////////////////////////////////////////////////////////////////////////////
// querySubControlMetrics()
// ------------------------
// Get metrics for subcontrols of complex controls
TQRect Phase2Style::querySubControlMetrics(TQ_ComplexControl control,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
SubControl subcontrol,
const TQStyleOption &option,
const TQWidget *widget) const
{
TQRect rect;
const int fw = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget);
int w = ceData.rect.width(), h = ceData.rect.height();
int xc;
switch (control) {
case CC_ComboBox: {
xc = h; // position between edit and arrow
switch (subcontrol) {
case SC_ComboBoxFrame: // total combobox area
rect = ceData.rect;
break;
case SC_ComboBoxArrow: // the right side
rect.setRect(w-xc, fw, xc-fw, h-(fw*2));
break;
case SC_ComboBoxEditField: // the left side
rect.setRect(fw, fw, w*FONT_Scale-xc-fw-1, h-(fw*2));
break;
case SC_ComboBoxListBoxPopup: // the list popup box
rect = option.rect();
break;
default:
break;
}
break;
}
case CC_ScrollBar: {
bool horizontal = (ceData.orientation == TQt::Horizontal);
rect = TDEStyle::querySubControlMetrics(control, ceData, elementFlags,
subcontrol, option, widget);
// adjust the standard metrics so controls can "overlap"
if (subcontrol == SC_ScrollBarGroove) {
if (horizontal) rect.addCoords(-1, 0, 1, 0);
else rect.addCoords(0, -1, 0, 1);
}
break;
}
#if 0
/**************************** FIXME **********************************
The SpinWidgets were formerly clickable only around the base of the
triangular arrow image, both of which exist near the center line
of the enclosing rectangle. The problem appears to be resolved
by removing the code below and falling back to the QT3 defaults.
See also the corresponding draw* (PE|CC)_SpinWidget* code above.
*********************************************************************/
case CC_SpinWidget: {
/*
fw = 2;
const bool heightDividable = ((rect.height()%2) == 0);
TQSize bs;
if(heightDividable)
bs.setHeight(TQMAX(8, (rect.height()-2)/2));
else
bs.setHeight(TQMAX(8, (rect.height()-2-1)/2));
bs.setWidth(15);
const int buttonsLeft = rect.right()-bs.width();
*/
bool odd = ceData.rect.height() % 2;
xc = (h * 3 / 4) + odd; // position between edit and arrows
switch (subcontrol) {
case SC_SpinWidgetButtonField:
//rect.setRect(w-xc, 1, xc-1, h-2);
rect.setRect(buttonsLeft, rect.top()+1, bs.width(), rect.height()-2);
break;
case SC_SpinWidgetEditField:
rect.setRect(fw, fw, w-xc-fw, h-(fw*2));
/*
rect.setRect(rect.left()+fw, rect.top()+fw,
rect.width()-(bs.width()+1+2*fw), rect.height()-2*fw);
*/
break;
case SC_SpinWidgetFrame:
rect = ceData.rect;
break;
case SC_SpinWidgetUp:
rect.setRect(w-xc, (h/2)-(odd ? 6 : 7), xc-1, 6);
/*
rect.setRect(buttonsLeft, rect.top()+1, bs.width(), bs.height() );
*/
break;
case SC_SpinWidgetDown:
rect.setRect(w-xc, (h/2)+1, xc-1, odd ? 7 : 6);
/*
if(heightDividable)
rect.setRect(buttonsLeft, rect.top()+1+bs.height(),
bs.width(), rect.height()-(bs.height()+2) );
else
rect.setRect(buttonsLeft, rect.top()+1+bs.height()+1,
bs.width(), rect.height()-(bs.height()+2+1) );
*/
break;
default:
break;
}
break;
}
#endif
default:
rect = TDEStyle::querySubControlMetrics(control, ceData, elementFlags, subcontrol,
option, widget);
}
return rect;
}
//////////////////////////////////////////////////////////////////////////////
// sizeFromContents()
// ------------------
// Returns the size of widget based on the contentsize
TQSize Phase2Style::sizeFromContents(ContentsType contents,
const TQStyleControlElementData &ceData,
ControlElementFlags elementFlags,
const TQSize &contentsize,
const TQStyleOption &option,
const TQWidget* widget ) const
{
int w = contentsize.width();
int h = contentsize.height();
switch (contents) {
case CT_PushButton: {
const TQPushButton* button = ::tqqt_cast<const TQPushButton*>(widget);
if (!button) {
return TDEStyle::sizeFromContents(contents, ceData, elementFlags, contentsize,
option, widget);
}
int margin = pixelMetric(PM_ButtonMargin, ceData, elementFlags, widget)
+ pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget) + 4;
w += margin + 6; // add room for bold font
h += margin;
// standard width and heights
if (button->isDefault() || button->autoDefault()) {
if (w < 80 && !button->pixmap()) w = 80;
}
if (h < 22) h = 22;
return TQSize(w, h);
}
case CT_PopupMenuItem: {
if (!widget || option.isDefault()) return contentsize;
if (!ceData.widgetObjectTypes.contains(TQPOPUPMENU_OBJECT_NAME_STRING)) {
return TDEStyle::sizeFromContents(contents, ceData, elementFlags, contentsize,
option, widget);
}
TQMenuItem *item = option.menuItem();
if (item->custom()) {
w = item->custom()->sizeHint().width();
h = item->custom()->sizeHint().height();
if (!item->custom()->fullSpan())
h += ITEMVMARGIN*2 + ITEMFRAME*2;
} else if (item->widget()) { // a menu item that is a widget
w = contentsize.width();
h = contentsize.height();
} else if (item->isSeparator()) {
w = h = 3;
} else {
if (item->pixmap()) {
h = TQMAX(h, item->pixmap()->height() + ITEMFRAME*2);
} else {
h = TQMAX(h, MINICONSIZE + ITEMFRAME*2);
h = TQMAX(h, TQFontMetrics(ceData.font).height()
+ ITEMVMARGIN*2 + ITEMFRAME*2);
}
if (item->iconSet())
h = TQMAX(h, item->iconSet()->
pixmap(TQIconSet::Small, TQIconSet::Normal).height()
+ ITEMFRAME*2);
}
if (!item->text().isNull() && item->text().find('\t') >= 0)
w += 12;
else if (item->popup())
w += 2 * + ARROW_Size1 ;
if (option.maxIconWidth() || (elementFlags & CEF_IsCheckable)) {
w += TQMAX(option.maxIconWidth(),
TQIconSet::iconSize(TQIconSet::Small).width())
+ ITEMHMARGIN*2;
}
w += RIGHTBORDER;
return TQSize(w, h);
}
default:
return TDEStyle::sizeFromContents(contents, ceData, elementFlags, contentsize,
option, widget);
}
}
//////////////////////////////////////////////////////////////////////////////
// Miscellaneous //
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// flatToolbar()
// -------------
// Is the toolbar "flat"
bool Phase2Style::flatToolbar(const TQStyleControlElementData &ceData, const ControlElementFlags elementFlags, const TQToolBar *toolbar) const
{
if (!toolbar) return true; // not on a toolbar
if (!toolbar->isMovingEnabled()) return true; // immobile toolbars are flat
if (!toolbar->area()) return true; // not docked
if (toolbar->place() == TQDockWindow::OutsideDock) return true; // ditto
if (!toolbar->mainWindow()) return true; // not in a main window
return false;
}
int Phase2Style::styleHint(StyleHint sh, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQStyleOption &opt, TQStyleHintReturn *returnData, const TQWidget *w) const
{
int ret;
switch (sh) {
case SH_MenuIndicatorColumnWidth:
{
int checkwidth = opt.maxIconWidth();
bool checkable = (elementFlags & CEF_IsCheckable);
if (checkable) checkwidth = TQMAX(checkwidth, 20);
ret = checkwidth;
}
break;
default:
ret = TDEStyle::styleHint(sh, ceData, elementFlags, opt, returnData, w);
break;
}
return ret;
}
//////////////////////////////////////////////////////////////////////////////
// eventFilter()
// -------------
// Grab events we are interested in. Most of this routine is to handle the
// exceptions to the normal styling rules.
bool Phase2Style::objectEventHandler( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void* source, TQEvent *event )
{
if (ceData.widgetObjectTypes.contains(TQOBJECT_OBJECT_NAME_STRING)) {
TQObject* object = reinterpret_cast<TQObject*>(source);
if (TDEStyle::objectEventHandler(ceData, elementFlags, source, event)) return true;
if (!object->isWidgetType()) return false;
bool horiz;
int x, y, w, h;
TQFrame *frame;
TQToolBar *toolbar;
TQWidget *widget;
// painting events
if (event->type() == TQEvent::Paint) {
// make sure we do the most specific stuff first
// TDE Toolbar Widget
// patch by Daniel Brownlees <dbrownlees@paradise.net.nz>
if (object->parent() && !qstrcmp(object->name(), KTOOLBARWIDGET)) {
if (0 == (widget = ::tqqt_cast<TQWidget*>(object))) return false;
TQWidget *parent = ::tqqt_cast<TQWidget*>(object->parent());
int px = ceData.rect.x(), py = ceData.rect.y();
// find the toolbar
while (parent && parent->parent()
&& !::tqqt_cast<TQToolBar*>(parent)) {
px += parent->x();
py += parent->y();
parent = ::tqqt_cast<TQWidget*>(parent->parent());
}
if (!parent) return false;
TQT_TQRECT_OBJECT(ceData.rect).rect(&x, &y, &w, &h);
TQRect prect = parent->rect();
toolbar = ::tqqt_cast<TQToolBar*>(parent);
horiz = (toolbar) ? (toolbar->orientation() == Qt::Horizontal)
: (prect.height() < prect.width());
TQPainter painter(widget);
if (flatToolbar(ceData, elementFlags, toolbar)) {
painter.fillRect(ceData.rect,
parent->colorGroup().background());
} else {
drawPhaseGradient(&painter, ceData.rect,
parent->colorGroup().background(),
!horiz, px, py,
prect.width(), prect.height(), true);
if (horiz && (h==prect.height()-2)) {
painter.setPen(parent->colorGroup().mid());
painter.drawLine(x, h-1, w-1, h-1);
} else if (!horiz && (w==prect.width()-2)) {
painter.setPen(parent->colorGroup().mid());
painter.drawLine(w-1, y, w-1, h-1);
}
}
}
// TQToolBarExtensionWidget
else if (object && object->isWidgetType() && object->parent() &&
(toolbar = ::tqqt_cast<TQToolBar*>(object->parent()))) {
if (0 == (widget = ::tqqt_cast<TQWidget*>(object))) return false;
horiz = (toolbar->orientation() == Qt::Horizontal);
TQPainter painter(widget);
TQT_TQRECT_OBJECT(ceData.rect).rect(&x, &y, &w, &h);
// draw the extension
drawPhaseGradient(&painter, ceData.rect,
toolbar->colorGroup().background(),
!horiz, x, y, w-1, h-1, true);
if (horiz) {
painter.setPen(toolbar->colorGroup().dark());
painter.drawLine(w-1, 0, w-1, h-1);
painter.setPen(toolbar->colorGroup().mid());
painter.drawLine(w-2, 0, w-2, h-2);
painter.drawLine(x, h-1, w-2, h-1);
painter.drawLine(x, y, x, h-2);
painter.setPen(toolbar->colorGroup().midlight());
painter.drawLine(x+1, y, x+1, h-2);
} else {
painter.setPen(toolbar->colorGroup().dark());
painter.drawLine(0, h-1, w-1, h-1);
painter.setPen(toolbar->colorGroup().mid());
painter.drawLine(0, h-2, w-2, h-2);
painter.drawLine(w-1, y, w-1, h-2);
painter.drawLine(x, y, w-2, y);
painter.setPen(toolbar->colorGroup().midlight());
painter.drawLine(x, y+1, w-2, y+1);
}
}
// TQFrame lines (do this guy last)
else if (0 != (frame = ::tqqt_cast<TQFrame*>(object))) {
TQFrame::Shape shape = frame->frameShape();
switch (shape) {
case TQFrame::HLine:
case TQFrame::VLine: {
// NOTE: assuming lines have no content
TQPainter painter(frame);
TQT_TQRECT_OBJECT(frame->rect()).rect(&x, &y, &w, &h);
painter.setPen(frame->colorGroup().dark());
if (shape == TQFrame::HLine) {
painter.drawLine(0, h/2, w, h/2);
} else if (shape == TQFrame::VLine) {
painter.drawLine(w/2, 0, w/2, h);
}
return true;
}
default:
break;
}
}
}
}
return false;
}
//////////////////////////////////////////////////////////////////////////////
// GradientSet //
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// GradientSet()
// -------------
// Constructor
GradientSet::GradientSet(const TQColor &color, int size)
: color_(color), size_(size)
{
for (int n=0; n<GradientTypeCount; ++n) set[n] = 0;
}
//////////////////////////////////////////////////////////////////////////////
// ~GradientSet()
// --------------
// Destructor
GradientSet::~GradientSet()
{
for (int n=0; n<GradientTypeCount; ++n) if (set[n]) delete set[n];
}
//////////////////////////////////////////////////////////////////////////////
// gradient()
// ----------
// Return the appropriate gradient pixmap
KPixmap* GradientSet::gradient(bool horizontal, bool reverse)
{
GradientType type;
if (horizontal) {
type = (reverse) ? HorizontalReverse : Horizontal;
} else {
type = (reverse) ? VerticalReverse : Vertical;
}
// lazy allocate
if (!set[type]) {
set[type] = new KPixmap();
switch (type) {
case Horizontal:
set[type]->resize(size_, 16);
KPixmapEffect::gradient(*set[type],
color_.light(contrast),
color_.dark(contrast),
KPixmapEffect::HorizontalGradient);
break;
case HorizontalReverse:
set[type]->resize(size_, 16);
KPixmapEffect::gradient(*set[type],
color_.dark(contrast),
color_.light(contrast),
KPixmapEffect::HorizontalGradient);
break;
case Vertical:
set[type]->resize(16, size_);
KPixmapEffect::gradient(*set[type],
color_.light(contrast),
color_.dark(contrast),
KPixmapEffect::VerticalGradient);
break;
case VerticalReverse:
set[type]->resize(16, size_);
KPixmapEffect::gradient(*set[type],
color_.dark(contrast),
color_.light(contrast),
KPixmapEffect::VerticalGradient);
break;
default:
break;
}
}
return (set[type]);
}
//////////////////////////////////////////////////////////////////////////////
// Plugin Stuff //
//////////////////////////////////////////////////////////////////////////////
class Phase2StylePlugin : public TQStylePlugin
{
public:
Phase2StylePlugin();
TQStringList keys() const;
TQStyle *create(const TQString &key);
};
Phase2StylePlugin::Phase2StylePlugin() : TQStylePlugin() { ; }
TQStringList Phase2StylePlugin::keys() const
{
return TQStringList() << "Phase2";
}
TQStyle* Phase2StylePlugin::create(const TQString& key)
{
if (key.lower() == "phase2")
return new Phase2Style();
return 0;
}
KDE_Q_EXPORT_PLUGIN(Phase2StylePlugin)
#include "phase2style.moc"
View Git Blame Copy Permalink