summaryrefslogtreecommitdiffstats
path: root/tqtinterface/qt4/src/styles/tqwindowsstyle.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tqtinterface/qt4/src/styles/tqwindowsstyle.cpp')
-rw-r--r--tqtinterface/qt4/src/styles/tqwindowsstyle.cpp2166
1 files changed, 2166 insertions, 0 deletions
diff --git a/tqtinterface/qt4/src/styles/tqwindowsstyle.cpp b/tqtinterface/qt4/src/styles/tqwindowsstyle.cpp
new file mode 100644
index 0000000..aa65a5b
--- /dev/null
+++ b/tqtinterface/qt4/src/styles/tqwindowsstyle.cpp
@@ -0,0 +1,2166 @@
+/****************************************************************************
+**
+** Implementation of Windows-like style class
+**
+** Created : 981231
+**
+** Copyright (C) 1998-2008 Trolltech ASA. All rights reserved.
+**
+** This file is part of the widgets module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+// ** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file. Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqwindowsstyle.h"
+
+#if !defined(TQT_NO_STYLE_WINDOWS) || defined(TQT_PLUGIN)
+
+#include "tqpopupmenu.h"
+#include "tqapplication.h"
+#include "tqpainter.h"
+#include "tqdrawutil.h" // for now
+#include "tqpixmap.h" // for now
+#include "tqwidget.h"
+#include "tqbrush.h"
+#include "tqlabel.h"
+#include "tqimage.h"
+#include "tqpushbutton.h"
+#include "tqcombobox.h"
+#include "tqlistbox.h"
+#include "tqwidget.h"
+#include "tqrangecontrol.h"
+#include "tqscrollbar.h"
+#include "tqslider.h"
+#include "tqtabwidget.h"
+#include "tqtabbar.h"
+#include "tqlistview.h"
+#include "tqbitmap.h"
+#include "tqcleanuphandler.h"
+#include "tqdockwindow.h"
+#include "tqobjectlist.h"
+#include "tqmenubar.h"
+
+#if defined(TQ_WS_WIN)
+#include "tqt_windows.h"
+#endif
+
+#include <limits.h>
+
+
+static const int windowsItemFrame = 2; // menu item frame width
+static const int windowsSepHeight = 2; // separator item height
+static const int windowsItemHMargin = 3; // menu item hor text margin
+static const int windowsItemVMargin = 2; // menu item ver text margin
+static const int windowsArrowHMargin = 6; // arrow horizontal margin
+static const int windowsTabSpacing = 12; // space between text and tab
+static const int windowsCheckMarkHMargin = 2; // horiz. margins of check mark
+static const int windowsRightBorder = 12; // right border on windows
+static const int windowsCheckMarkWidth = 12; // checkmarks width on windows
+
+static bool use2000style = TRUE;
+
+enum TQSliderDirection { SlUp, SlDown, SlLeft, SlRight };
+
+// A friendly class providing access to TQMenuData's protected member.
+class FriendlyMenuData : public TQMenuData
+{
+ friend class TQWindowsStyle;
+};
+
+// Private class
+class TQWindowsStyle::Private : public TQObject
+{
+public:
+ Private(TQWindowsStyle *tqparent);
+
+ bool hasSeenAlt(const TQWidget *widget) const;
+ bool altDown() const { return alt_down; }
+
+protected:
+ bool eventFilter(TQObject *o, TQEvent *e);
+
+private:
+ TQPtrList<TQWidget> seenAlt;
+ bool alt_down;
+ int menuBarTimer;
+};
+
+TQWindowsStyle::Private::Private(TQWindowsStyle *tqparent)
+: TQObject(tqparent, "TQWindowsStylePrivate"), alt_down(FALSE), menuBarTimer(0)
+{
+}
+
+// Returns true if the toplevel tqparent of \a widget has seen the Alt-key
+bool TQWindowsStyle::Private::hasSeenAlt(const TQWidget *widget) const
+{
+ widget = widget->tqtopLevelWidget();
+ return seenAlt.tqcontains(widget);
+}
+
+// Records Alt- and Focus events
+bool TQWindowsStyle::Private::eventFilter(TQObject *o, TQEvent *e)
+{
+ if (!o->isWidgetType())
+ return TQObject::eventFilter(o, e);
+
+ TQWidget *widget = ::tqqt_cast<TQWidget*>(o);
+
+ switch(e->type()) {
+ case TQEvent::KeyPress:
+ if (((TQKeyEvent*)e)->key() == Qt::Key_Alt) {
+ widget = widget->tqtopLevelWidget();
+
+ // Alt has been pressed - tqfind all widgets that care
+ TQObjectList *l = widget->queryList("TQWidget");
+ TQObjectListIt it( *l );
+ TQWidget *w;
+ while ( (w = (TQWidget*)it.current()) != 0 ) {
+ ++it;
+ if (w->isTopLevel() || !w->isVisible() ||
+ w->tqstyle().tqstyleHint(SH_UnderlineAccelerator, w))
+ l->removeRef(TQT_TQOBJECT(w));
+ }
+ // Update states before repainting
+ seenAlt.append(widget);
+ alt_down = TRUE;
+
+ // Repaint all relevant widgets
+ it.toFirst();
+ while ( (w = (TQWidget*)it.current()) != 0 ) {
+ ++it;
+ w->tqrepaint(FALSE);
+ }
+ delete l;
+ }
+ break;
+ case TQEvent::KeyRelease:
+ if (((TQKeyEvent*)e)->key() == Qt::Key_Alt) {
+ widget = widget->tqtopLevelWidget();
+
+ // Update state
+ alt_down = FALSE;
+ // Repaint only menubars
+ TQObjectList *l = widget->queryList("TQMenuBar");
+ TQObjectListIt it( *l );
+ TQMenuBar *menuBar;
+ while ( (menuBar = (TQMenuBar*)it.current()) != 0) {
+ ++it;
+ menuBar->tqrepaint(FALSE);
+ }
+ }
+ break;
+ case TQEvent::FocusIn:
+ case TQEvent::FocusOut:
+ {
+ // Menubars toggle based on focus
+ TQMenuBar *menuBar = ::tqqt_cast<TQMenuBar*>(o);
+ if (menuBar && !menuBarTimer) // delayed tqrepaint to avoid flicker
+ menuBarTimer = menuBar->startTimer(0);
+ }
+ break;
+ case TQEvent::Close:
+ // Reset widget when closing
+ seenAlt.removeRef(TQT_TQWIDGET(widget));
+ seenAlt.removeRef(TQT_TQWIDGET(widget->tqtopLevelWidget()));
+ break;
+ case TQEvent::Timer:
+ {
+ TQMenuBar *menuBar = ::tqqt_cast<TQMenuBar*>(o);
+ TQTimerEvent *te = (TQTimerEvent*)e;
+ if (menuBar && te->timerId() == menuBarTimer) {
+ menuBar->killTimer(te->timerId());
+ menuBarTimer = 0;
+ menuBar->tqrepaint(FALSE);
+ return TRUE;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+
+ return TQObject::eventFilter(o, e);
+}
+
+/*!
+ \class TQWindowsStyle tqwindowsstyle.h
+ \brief The TQWindowsStyle class provides a Microsoft Windows-like look and feel.
+
+ \ingroup appearance
+
+ This style is TQt's default GUI style on Windows.
+*/
+
+/*!
+ Constructs a TQWindowsStyle
+*/
+TQWindowsStyle::TQWindowsStyle() : TQCommonStyle(), d(0)
+{
+#if defined(TQ_OS_WIN32)
+ use2000style = qWinVersion() != TQt::WV_NT && qWinVersion() != TQt::WV_95;
+#endif
+}
+
+/*! \reimp */
+TQWindowsStyle::~TQWindowsStyle()
+{
+ delete d;
+}
+
+/*! \reimp */
+void TQWindowsStyle::polish(TQApplication *app)
+{
+ // We only need the overhead when shortcuts are sometimes hidden
+ if (!tqstyleHint(SH_UnderlineAccelerator, 0)) {
+ d = new Private(this);
+ app->installEventFilter(d);
+ }
+}
+
+/*! \reimp */
+void TQWindowsStyle::unPolish(TQApplication *)
+{
+ delete d;
+ d = 0;
+}
+
+/*! \reimp */
+void TQWindowsStyle::polish(TQWidget *widget)
+{
+ TQCommonStyle::polish(widget);
+}
+
+/*! \reimp */
+void TQWindowsStyle::unPolish(TQWidget *widget)
+{
+ TQCommonStyle::polish(widget);
+}
+
+/*! \reimp */
+void TQWindowsStyle::polish( TQPalette &pal )
+{
+ TQCommonStyle::polish(pal);
+}
+
+/*! \reimp */
+void TQWindowsStyle::tqdrawPrimitiveBase( TQ_PrimitiveElement pe,
+ TQPainter *p,
+ const TQRect &r,
+ const TQColorGroup &cg,
+ SFlags flags,
+ const TQStyleOption& opt ) const
+{
+ TQRect rr( r );
+ switch (pe) {
+ case PE_ButtonCommand:
+ {
+ TQBrush fill;
+
+ if (! (flags & Style_Down) && (flags & Style_On))
+ fill = TQBrush(cg.light(), Qt::Dense4Pattern);
+ else
+ fill = cg.brush(TQColorGroup::Button);
+
+ if (flags & Style_ButtonDefault && flags & Style_Down) {
+ p->setPen(cg.dark());
+ p->setBrush(fill);
+ p->drawRect(r);
+ } else if (flags & (Style_Raised | Style_Down | Style_On | Style_Sunken))
+ qDrawWinButton(p, r, cg, flags & (Style_Sunken | Style_Down |
+ Style_On), &fill);
+ else
+ p->fillRect(r, fill);
+ break;
+ }
+
+ case PE_ButtonBevel:
+ case PE_HeaderSection:
+ {
+ TQBrush fill;
+
+ if (! (flags & Style_Down) && (flags & Style_On))
+ fill = TQBrush(cg.light(), Qt::Dense4Pattern);
+ else
+ fill = cg.brush(TQColorGroup::Button);
+
+ if (flags & (Style_Raised | Style_Down | Style_On | Style_Sunken))
+ qDrawWinButton(p, r, cg, flags & (Style_Down | Style_On), &fill);
+ else
+ p->fillRect(r, fill);
+ break;
+ }
+#if defined(TQ_WS_WIN)
+ case PE_HeaderArrow:
+ p->save();
+ if ( flags & Style_Up ) { // invert logic to follow Windows style guide
+ TQPointArray pa( 3 );
+ p->setPen( cg.light() );
+ p->drawLine( r.x() + r.width(), r.y(), r.x() + r.width() / 2, r.height() );
+ p->setPen( cg.dark() );
+ pa.setPoint( 0, r.x() + r.width() / 2, r.height() );
+ pa.setPoint( 1, r.x(), r.y() );
+ pa.setPoint( 2, r.x() + r.width(), r.y() );
+ p->drawPolyline( pa );
+ } else {
+ TQPointArray pa( 3 );
+ p->setPen( cg.light() );
+ pa.setPoint( 0, r.x(), r.height() );
+ pa.setPoint( 1, r.x() + r.width(), r.height() );
+ pa.setPoint( 2, r.x() + r.width() / 2, r.y() );
+ p->drawPolyline( pa );
+ p->setPen( cg.dark() );
+ p->drawLine( r.x(), r.height(), r.x() + r.width() / 2, r.y() );
+ }
+ p->restore();
+ break;
+#endif
+
+ case PE_ButtonDefault:
+ p->setPen(cg.shadow());
+ p->drawRect(r);
+ break;
+
+ case PE_ButtonTool:
+ {
+ TQBrush fill;
+ bool stippled = FALSE;
+
+ if (! (flags & (Style_Down | Style_MouseOver)) &&
+ (flags & Style_On) &&
+ use2000style) {
+ fill = TQBrush(cg.light(), Qt::Dense4Pattern);
+ stippled = TRUE;
+ } else
+ fill = cg.brush(TQColorGroup::Button);
+
+ if (flags & (Style_Raised | Style_Down | Style_On)) {
+ if (flags & Style_AutoRaise) {
+ qDrawShadePanel(p, r, cg, flags & (Style_Down | Style_On),
+ 1, &fill);
+
+ if (stippled) {
+ p->setPen(cg.button());
+ p->drawRect(r.x() + 1, r.y() + 1, r.width() - 2, r.height() - 2);
+ }
+ } else
+ qDrawWinButton(p, r, cg, flags & (Style_Down | Style_On),
+ &fill);
+ } else
+ p->fillRect(r, fill);
+
+ break;
+ }
+
+ case PE_FocusRect:
+ if (opt.isDefault())
+ p->drawWinFocusRect(r);
+#ifndef USE_QT4 // [FIXME]
+ else
+ p->drawWinFocusRect(r, opt.color());
+#endif // USE_QT4
+ break;
+
+ case PE_Indicator:
+ {
+ TQBrush fill;
+ if (flags & Style_NoChange) {
+ TQBrush b = p->brush();
+ TQColor c = p->backgroundColor();
+ p->setBackgroundMode( Qt::TransparentMode );
+ p->setBackgroundColor( Qt::green );
+ fill = TQBrush(cg.base(), Qt::Dense4Pattern);
+ p->setBackgroundColor( c );
+ p->setBrush( b );
+ } else if (flags & Style_Down)
+ fill = cg.brush( TQColorGroup::Button );
+ else if (flags & Style_Enabled)
+ fill = cg.brush( TQColorGroup::Base );
+ else
+ fill = cg.brush( TQColorGroup::Background );
+
+ qDrawWinPanel( p, r, cg, TRUE, &fill );
+
+ if (flags & Style_NoChange )
+ p->setPen( cg.dark() );
+ else
+ p->setPen( cg.text() );
+ } // FALLTHROUGH
+ case PE_CheckListIndicator:
+ if ( pe == PE_CheckListIndicator ) { //since we fall through from PE_Indicator
+ if ( flags & Style_Enabled )
+ p->setPen( TQPen( cg.text(), 1 ) );
+ else
+ p->setPen( TQPen( cg.dark(), 1 ) );
+ if ( flags & Style_NoChange )
+ p->setBrush( cg.brush( TQColorGroup::Button ) );
+ p->drawRect( r.x()+1, r.y()+1, 11, 11 );
+ }
+ if (! (flags & Style_Off)) {
+ TQPointArray a( 7*2 );
+ int i, xx, yy;
+ xx = rr.x() + 3;
+ yy = rr.y() + 5;
+
+ for ( i=0; i<3; i++ ) {
+ a.setPoint( 2*i, xx, yy );
+ a.setPoint( 2*i+1, xx, yy+2 );
+ xx++; yy++;
+ }
+
+ yy -= 2;
+ for ( i=3; i<7; i++ ) {
+ a.setPoint( 2*i, xx, yy );
+ a.setPoint( 2*i+1, xx, yy+2 );
+ xx++; yy--;
+ }
+
+ p->drawLineSegments( a );
+ }
+ break;
+
+ case PE_ExclusiveIndicator:
+ {
+#define TQCOORDARRLEN(x) sizeof(x)/(sizeof(TQCOORD)*2)
+ static const TQCOORD pts1[] = { // dark lines
+ 1,9, 1,8, 0,7, 0,4, 1,3, 1,2, 2,1, 3,1, 4,0, 7,0, 8,1, 9,1 };
+ static const TQCOORD pts2[] = { // black lines
+ 2,8, 1,7, 1,4, 2,3, 2,2, 3,2, 4,1, 7,1, 8,2, 9,2 };
+ static const TQCOORD pts3[] = { // background lines
+ 2,9, 3,9, 4,10, 7,10, 8,9, 9,9, 9,8, 10,7, 10,4, 9,3 };
+ static const TQCOORD pts4[] = { // white lines
+ 2,10, 3,10, 4,11, 7,11, 8,10, 9,10, 10,9, 10,8, 11,7,
+ 11,4, 10,3, 10,2 };
+ static const TQCOORD pts5[] = { // inner fill
+ 4,2, 7,2, 9,4, 9,7, 7,9, 4,9, 2,7, 2,4 };
+
+ // make sure the indicator is square
+ TQRect ir = r;
+
+ if (r.width() < r.height()) {
+ ir.setTop(r.top() + (r.height() - r.width()) / 2);
+ ir.setHeight(r.width());
+ } else if (r.height() < r.width()) {
+ ir.setLeft(r.left() + (r.width() - r.height()) / 2);
+ ir.setWidth(r.height());
+ }
+
+ p->eraseRect(ir);
+ bool down = flags & Style_Down;
+ bool enabled = flags & Style_Enabled;
+ bool on = flags & Style_On;
+ TQPointArray a;
+ a.setPoints( TQCOORDARRLEN(pts1), pts1 );
+ a.translate( ir.x(), ir.y() );
+ p->setPen( cg.dark() );
+ p->drawPolyline( a );
+ a.setPoints( TQCOORDARRLEN(pts2), pts2 );
+ a.translate( ir.x(), ir.y() );
+ p->setPen( cg.shadow() );
+ p->drawPolyline( a );
+ a.setPoints( TQCOORDARRLEN(pts3), pts3 );
+ a.translate( ir.x(), ir.y() );
+ p->setPen( cg.midlight() );
+ p->drawPolyline( a );
+ a.setPoints( TQCOORDARRLEN(pts4), pts4 );
+ a.translate( ir.x(), ir.y() );
+ p->setPen( cg.light() );
+ p->drawPolyline( a );
+ a.setPoints( TQCOORDARRLEN(pts5), pts5 );
+ a.translate( ir.x(), ir.y() );
+ TQColor fillColor = ( down || !enabled ) ? cg.button() : cg.base();
+ p->setPen( fillColor );
+ p->setBrush( fillColor ) ;
+ p->drawPolygon( a );
+ if ( on ) {
+ p->setPen( Qt::NoPen );
+ p->setBrush( cg.text() );
+ p->drawRect( ir.x() + 5, ir.y() + 4, 2, 4 );
+ p->drawRect( ir.x() + 4, ir.y() + 5, 4, 2 );
+ }
+ break;
+ }
+
+ case PE_Panel:
+ case PE_PanelPopup:
+ {
+ int lw = opt.isDefault() ? tqpixelMetric(PM_DefaultFrameWidth)
+ : opt.lineWidth();
+
+ if (lw == 2) {
+ TQColorGroup popupCG = cg;
+ if ( pe == PE_PanelPopup ) {
+ popupCG.setColor( TQColorGroup::Light, cg.background() );
+ popupCG.setColor( TQColorGroup::Midlight, cg.light() );
+ }
+ qDrawWinPanel(p, r, popupCG, flags & Style_Sunken);
+ } else {
+ TQCommonStyle::tqdrawPrimitive(pe, p, r, cg, flags, opt);
+ }
+ break;
+ }
+
+ case PE_Splitter:
+ {
+ TQPen oldPen = p->pen();
+ p->setPen( cg.light() );
+ if ( flags & Style_Horizontal ) {
+ p->drawLine( r.x() + 1, r.y(), r.x() + 1, r.height() );
+ p->setPen( cg.dark() );
+ p->drawLine( r.x(), r.y(), r.x(), r.height() );
+ p->drawLine( r.right()-1, r.y(), r.right()-1, r.height() );
+ p->setPen( cg.shadow() );
+ p->drawLine( r.right(), r.y(), r.right(), r.height() );
+ } else {
+ p->drawLine( r.x(), r.y() + 1, r.width(), r.y() + 1 );
+ p->setPen( cg.dark() );
+ p->drawLine( r.x(), r.bottom() - 1, r.width(), r.bottom() - 1 );
+ p->setPen( cg.shadow() );
+ p->drawLine( r.x(), r.bottom(), r.width(), r.bottom() );
+ }
+ p->setPen( oldPen );
+ break;
+ }
+#ifndef USE_QT4 // [FIXME]
+ case PE_DockWindowResizeHandle:
+ {
+ TQPen oldPen = p->pen();
+ p->setPen( cg.light() );
+ if ( flags & Style_Horizontal ) {
+ p->drawLine( r.x(), r.y(), r.width(), r.y() );
+ p->setPen( cg.dark() );
+ p->drawLine( r.x(), r.bottom() - 1, r.width(), r.bottom() - 1 );
+ p->setPen( cg.shadow() );
+ p->drawLine( r.x(), r.bottom(), r.width(), r.bottom() );
+ } else {
+ p->drawLine( r.x(), r.y(), r.x(), r.height() );
+ p->setPen( cg.dark() );
+ p->drawLine( r.right()-1, r.y(), r.right()-1, r.height() );
+ p->setPen( cg.shadow() );
+ p->drawLine( r.right(), r.y(), r.right(), r.height() );
+ }
+ p->setPen( oldPen );
+ break;
+ }
+#endif // USE_QT4
+
+ case PE_ScrollBarSubLine:
+ if (use2000style) {
+ if (flags & Style_Down) {
+ p->setPen( cg.dark() );
+ p->setBrush( cg.brush( TQColorGroup::Button ) );
+ p->drawRect( r );
+ } else
+ tqdrawPrimitive(PE_ButtonBevel, p, r, cg, flags | Style_Raised);
+ } else
+ tqdrawPrimitive(PE_ButtonBevel, p, r, cg, (flags & Style_Enabled) |
+ ((flags & Style_Down) ? Style_Down : Style_Raised));
+
+ tqdrawPrimitive(((flags & Style_Horizontal) ? PE_ArrowLeft : PE_ArrowUp),
+ p, r, cg, flags);
+ break;
+
+ case PE_ScrollBarAddLine:
+ if (use2000style) {
+ if (flags & Style_Down) {
+ p->setPen( cg.dark() );
+ p->setBrush( cg.brush( TQColorGroup::Button ) );
+ p->drawRect( r );
+ } else
+ tqdrawPrimitive(PE_ButtonBevel, p, r, cg, flags | Style_Raised);
+ } else
+ tqdrawPrimitive(PE_ButtonBevel, p, r, cg, (flags & Style_Enabled) |
+ ((flags & Style_Down) ? Style_Down : Style_Raised));
+
+ tqdrawPrimitive(((flags & Style_Horizontal) ? PE_ArrowRight : PE_ArrowDown),
+ p, r, cg, flags);
+ break;
+
+ case PE_ScrollBarAddPage:
+ case PE_ScrollBarSubPage:
+ {
+ TQBrush br;
+ TQColor c = p->backgroundColor();
+
+ p->setPen(Qt::NoPen);
+ p->setBackgroundMode(Qt::OpaqueMode);
+
+ if (flags & Style_Down) {
+ br = TQBrush(cg.shadow(), Qt::Dense4Pattern);
+ p->setBackgroundColor( cg.dark() );
+ p->setBrush( TQBrush(cg.shadow(), Qt::Dense4Pattern) );
+ } else {
+ br = (TQT_TQBRUSH_OBJECT(cg.brush(TQColorGroup::Light)).pixmap() ?
+ cg.brush(TQColorGroup::Light) :
+ TQBrush(cg.light(), Qt::Dense4Pattern));
+ p->setBrush(br);
+ }
+
+ p->drawRect(r);
+ p->setBackgroundColor(c);
+ break;
+ }
+
+ case PE_ScrollBarSlider:
+ if (! (flags & Style_Enabled)) {
+ TQBrush br = (TQT_TQBRUSH_OBJECT(cg.brush(TQColorGroup::Light)).pixmap() ?
+ cg.brush(TQColorGroup::Light) :
+ TQBrush(cg.light(), Qt::Dense4Pattern));
+ p->setPen(Qt::NoPen);
+ p->setBrush(br);
+ p->setBackgroundMode(Qt::OpaqueMode);
+ p->drawRect(r);
+ } else
+ tqdrawPrimitive(PE_ButtonBevel, p, r, cg, Style_Enabled | Style_Raised);
+ break;
+
+ case PE_WindowFrame:
+ {
+ TQColorGroup popupCG = cg;
+ popupCG.setColor( TQColorGroup::Light, cg.background() );
+ popupCG.setColor( TQColorGroup::Midlight, cg.light() );
+ qDrawWinPanel(p, r, popupCG, flags & Style_Sunken);
+ }
+ break;
+
+ default:
+ if (pe >= PE_ArrowUp && pe <= PE_ArrowLeft) {
+ TQPointArray a;
+
+ switch ( pe ) {
+ case PE_ArrowUp:
+ a.setPoints( 7, -4,1, 2,1, -3,0, 1,0, -2,-1, 0,-1, -1,-2 );
+ break;
+
+ case PE_ArrowDown:
+ a.setPoints( 7, -4,-2, 2,-2, -3,-1, 1,-1, -2,0, 0,0, -1,1 );
+ break;
+
+ case PE_ArrowRight:
+ a.setPoints( 7, -2,-3, -2,3, -1,-2, -1,2, 0,-1, 0,1, 1,0 );
+ break;
+
+ case PE_ArrowLeft:
+ a.setPoints( 7, 0,-3, 0,3, -1,-2, -1,2, -2,-1, -2,1, -3,0 );
+ break;
+
+ default:
+ break;
+ }
+
+ if (a.isNull())
+ return;
+
+ p->save();
+ if ( flags & Style_Down )
+ p->translate( tqpixelMetric( PM_ButtonShiftHorizontal ),
+ tqpixelMetric( PM_ButtonShiftVertical ) );
+
+ if ( flags & Style_Enabled ) {
+ a.translate( r.x() + r.width() / 2, r.y() + r.height() / 2 );
+ p->setPen( cg.buttonText() );
+ p->drawLineSegments( a, 0, 3 ); // draw arrow
+ p->drawPoint( a[6] );
+ } else {
+ a.translate( r.x() + r.width() / 2 + 1, r.y() + r.height() / 2 + 1 );
+ p->setPen( cg.light() );
+ p->drawLineSegments( a, 0, 3 ); // draw arrow
+ p->drawPoint( a[6] );
+ a.translate( -1, -1 );
+ p->setPen( cg.mid() );
+ p->drawLineSegments( a, 0, 3 ); // draw arrow
+ p->drawPoint( a[6] );
+ }
+ p->restore();
+ } else
+ TQCommonStyle::tqdrawPrimitive(pe, p, r, cg, flags, opt);
+ }
+}
+
+
+/*!
+ \reimp
+*/
+void TQWindowsStyle::tqdrawControl( TQ_ControlElement element,
+ TQPainter *p,
+ const TQWidget *widget,
+ const TQRect &r,
+ const TQColorGroup &cg,
+ SFlags flags,
+ const TQStyleOption& opt ) const
+{
+ switch (element) {
+#ifndef TQT_NO_TABBAR
+ case CE_TabBarTab:
+ {
+ if ( !widget || !widget->parentWidget() || !opt.tab() )
+ break;
+
+ const TQTabBar * tb = (const TQTabBar *) widget;
+ const TQTab * t = opt.tab();
+ bool selected = flags & Style_Selected;
+ bool lastTab = (tb->indexOf( t->identifier() ) == tb->count()-1) ?
+ TRUE : FALSE;
+ TQRect r2( r );
+ if ( tb->tqshape() == TQTabBar::RoundedAbove ) {
+ p->setPen( cg.midlight() );
+
+ p->drawLine( r2.left(), r2.bottom(), r2.right(), r2.bottom() );
+ p->setPen( cg.light() );
+ p->drawLine( r2.left(), r2.bottom()-1, r2.right(), r2.bottom()-1 );
+ if ( r2.left() == 0 )
+ p->drawPoint( tb->rect().bottomLeft() );
+
+ if ( selected ) {
+ p->fillRect( TQRect( r2.left()+1, r2.bottom()-1, r2.width()-3, 2),
+ cg.brush( TQColorGroup::Background ));
+ p->setPen( cg.background() );
+ p->drawLine( r2.left()+1, r2.bottom(), r2.left()+1, r2.top()+2 );
+ p->setPen( cg.light() );
+ } else {
+ p->setPen( cg.light() );
+ r2.setRect( r2.left() + 2, r2.top() + 2,
+ r2.width() - 4, r2.height() - 2 );
+ }
+
+ int x1, x2;
+ x1 = r2.left();
+ x2 = r2.right() - 2;
+ p->drawLine( x1, r2.bottom()-1, x1, r2.top() + 2 );
+ x1++;
+ p->drawPoint( x1, r2.top() + 1 );
+ x1++;
+ p->drawLine( x1, r2.top(), x2, r2.top() );
+ if ( r2.left() > 0 ) {
+ p->setPen( cg.midlight() );
+ }
+ x1 = r2.left();
+ p->drawPoint( x1, r2.bottom());
+
+ p->setPen( cg.midlight() );
+ x1++;
+ p->drawLine( x1, r2.bottom(), x1, r2.top() + 2 );
+ x1++;
+ p->drawLine( x1, r2.top()+1, x2, r2.top()+1 );
+
+ p->setPen( cg.dark() );
+ x2 = r2.right() - 1;
+ p->drawLine( x2, r2.top() + 2, x2, r2.bottom() - 1 +
+ (selected ? 1:-1) );
+ p->setPen( cg.shadow() );
+ p->drawPoint( x2, r2.top() + 1 );
+ p->drawPoint( x2, r2.top() + 1 );
+ x2++;
+ p->drawLine( x2, r2.top() + 2, x2, r2.bottom() -
+ (selected ? (lastTab ? 0:1) :2));
+ } else if ( tb->tqshape() == TQTabBar::RoundedBelow ) {
+ bool rightAligned = tqstyleHint( SH_TabBar_Alignment, tb ) == TQt::AlignRight;
+ bool firstTab = tb->indexOf( t->identifier() ) == 0;
+ if ( selected ) {
+ p->fillRect( TQRect( r2.left()+1, r2.top(), r2.width()-3, 1),
+ cg.brush( TQColorGroup::Background ));
+ p->setPen( cg.background() );
+ p->drawLine( r2.left()+1, r2.top(), r2.left()+1, r2.bottom()-2 );
+ p->setPen( cg.dark() );
+ } else {
+ p->setPen( cg.shadow() );
+ p->drawLine( r2.left() +
+ (rightAligned && firstTab ? 0 : 1),
+ r2.top() + 1,
+ r2.right() - (lastTab ? 0 : 2),
+ r2.top() + 1 );
+
+ if ( rightAligned && lastTab )
+ p->drawPoint( r2.right(), r2.top() );
+ p->setPen( cg.dark() );
+ p->drawLine( r2.left(), r2.top(), r2.right() - 1,
+ r2.top() );
+ r2.setRect( r2.left() + 2, r2.top(),
+ r2.width() - 4, r2.height() - 2 );
+ }
+
+ p->drawLine( r2.right() - 1, r2.top() + (selected ? 0: 2),
+ r2.right() - 1, r2.bottom() - 2 );
+ p->drawPoint( r2.right() - 2, r2.bottom() - 2 );
+ p->drawLine( r2.right() - 2, r2.bottom() - 1,
+ r2.left() + 1, r2.bottom() - 1 );
+
+ p->setPen( cg.midlight() );
+ p->drawLine( r2.left() + 1, r2.bottom() - 2,
+ r2.left() + 1, r2.top() + (selected ? 0 : 2) );
+
+ p->setPen( cg.shadow() );
+ p->drawLine( r2.right(),
+ r2.top() + (lastTab && rightAligned &&
+ selected) ? 0 : 1,
+ r2.right(), r2.bottom() - 1 );
+ p->drawPoint( r2.right() - 1, r2.bottom() - 1 );
+ p->drawLine( r2.right() - 1, r2.bottom(),
+ r2.left() + 2, r2.bottom() );
+
+ p->setPen( cg.light() );
+ p->drawLine( r2.left(), r2.top() + (selected ? 0 : 2),
+ r2.left(), r2.bottom() - 2 );
+ } else {
+ TQCommonStyle::tqdrawControl(element, p, widget, r, cg, flags, opt);
+ }
+ break;
+ }
+#endif // TQT_NO_TABBAR
+ case CE_ToolBoxTab:
+ {
+ qDrawShadePanel( p, r, cg, flags & (Style_Sunken | Style_Down | Style_On) , 1,
+ &cg.brush(TQColorGroup::Button));
+ break;
+ }
+
+#ifndef TQT_NO_POPUPMENU
+ case CE_PopupMenuItem:
+ {
+ if (! widget || opt.isDefault())
+ break;
+
+ const TQPopupMenu *popupmenu = (const TQPopupMenu *) widget;
+ TQMenuItem *mi = opt.menuItem();
+ if ( !mi )
+ break;
+
+ int tab = opt.tabWidth();
+ int maxpmw = opt.maxIconWidth();
+ bool dis = !(flags&Style_Enabled);
+ bool checkable = popupmenu->isCheckable();
+ bool act = flags & Style_Active;
+ int x, y, w, h;
+
+ r.rect(&x, &y, &w, &h);
+
+ if ( checkable ) {
+ // space for the checkmarks
+ if (use2000style)
+ maxpmw = TQMAX( maxpmw, 20 );
+ else
+ maxpmw = TQMAX( maxpmw, 12 );
+ }
+
+ int checkcol = maxpmw;
+
+ if ( mi && mi->isSeparator() ) { // draw separator
+ p->setPen( cg.dark() );
+ p->drawLine( x, y, x+w, y );
+ p->setPen( cg.light() );
+ p->drawLine( x, y+1, x+w, y+1 );
+ return;
+ }
+
+ TQBrush fill = (act ?
+ cg.brush( TQColorGroup::Highlight ) :
+ cg.brush( TQColorGroup::Button ));
+ p->fillRect( x, y, w, h, fill);
+
+ if ( !mi )
+ return;
+
+ int xpos = x;
+ TQRect vrect = tqvisualRect( TQRect( xpos, y, checkcol, h ), r );
+ int xvis = vrect.x();
+ if ( mi->isChecked() ) {
+ if ( act && !dis )
+ qDrawShadePanel( p, xvis, y, checkcol, h,
+ cg, TRUE, 1, &cg.brush( TQColorGroup::Button ) );
+ else {
+ TQBrush fill( cg.light(), Qt::Dense4Pattern );
+ // set the brush origin for the hash pattern to the x/y coordinate
+ // of the menu item's checkmark... this way, the check marks have
+ // a consistent look
+ TQPoint origin = p->brushOrigin();
+ p->setBrushOrigin( xvis, y );
+ qDrawShadePanel( p, xvis, y, checkcol, h, cg, TRUE, 1,
+ &fill );
+ // restore the previous brush origin
+ p->setBrushOrigin( origin );
+ }
+ } else if (! act)
+ p->fillRect(xvis, y, checkcol , h, cg.brush( TQColorGroup::Button ));
+
+ if ( mi->iconSet() ) { // draw iconset
+ TQIconSet::Mode mode = dis ? TQIconSet::Disabled : TQIconSet::Normal;
+ if (act && !dis )
+ mode = TQIconSet::Active;
+ TQPixmap pixmap;
+ if ( checkable && mi->isChecked() )
+ pixmap = mi->iconSet()->pixmap( TQIconSet::Small, mode, TQIconSet::On );
+ else
+ pixmap = mi->iconSet()->pixmap( TQIconSet::Small, mode );
+ int pixw = pixmap.width();
+ int pixh = pixmap.height();
+ if ( act && !dis && !mi->isChecked() )
+ qDrawShadePanel( p, xvis, y, checkcol, h, cg, FALSE, 1,
+ &cg.brush( TQColorGroup::Button ) );
+ TQRect pmr( 0, 0, pixw, pixh );
+ pmr.moveCenter( vrect.center() );
+ p->setPen( cg.text() );
+ p->drawPixmap( pmr.topLeft(), pixmap );
+
+ fill = (act ?
+ cg.brush( TQColorGroup::Highlight ) :
+ cg.brush( TQColorGroup::Button ));
+ int xp = xpos + checkcol + 1;
+ p->fillRect( tqvisualRect( TQRect( xp, y, w - checkcol - 1, h ), r ), fill);
+ } else if ( checkable ) { // just "checking"...
+ if ( mi->isChecked() ) {
+ int xp = xpos + windowsItemFrame;
+
+ SFlags cflags = Style_Default;
+ if (! dis)
+ cflags |= Style_Enabled;
+ if (act)
+ cflags |= Style_On;
+
+ tqdrawPrimitive(PE_CheckMark, p,
+ tqvisualRect( TQRect(xp, y + windowsItemFrame,
+ checkcol - 2*windowsItemFrame,
+ h - 2*windowsItemFrame), r ), cg, cflags);
+ }
+ }
+
+ p->setPen( act ? cg.highlightedText() : cg.buttonText() );
+
+ TQColor discol;
+ if ( dis ) {
+ discol = cg.text();
+ p->setPen( discol );
+ }
+
+ int xm = windowsItemFrame + checkcol + windowsItemHMargin;
+ xpos += xm;
+
+ vrect = tqvisualRect( TQRect( xpos, y+windowsItemVMargin, w-xm-tab+1, h-2*windowsItemVMargin ), r );
+ xvis = vrect.x();
+ if ( mi->custom() ) {
+ p->save();
+ if ( dis && !act ) {
+ p->setPen( cg.light() );
+ mi->custom()->paint( p, cg, act, !dis,
+ xvis+1, y+windowsItemVMargin+1, w-xm-tab+1, h-2*windowsItemVMargin );
+ p->setPen( discol );
+ }
+ mi->custom()->paint( p, cg, act, !dis,
+ xvis, y+windowsItemVMargin, w-xm-tab+1, h-2*windowsItemVMargin );
+ p->restore();
+ }
+ TQString s = mi->text();
+ if ( !s.isNull() ) { // draw text
+ int t = s.tqfind( '\t' );
+ int text_flags = TQt::AlignVCenter|TQt::ShowPrefix | TQt::DontClip | TQt::SingleLine;
+ if (!tqstyleHint(SH_UnderlineAccelerator, widget))
+ text_flags |= TQt::NoAccel;
+ text_flags |= (TQApplication::reverseLayout() ? TQt::AlignRight : TQt::AlignLeft );
+ if ( t >= 0 ) { // draw tab text
+ int xp = x + w - tab - windowsItemHMargin - windowsItemFrame + 1;
+ if ( use2000style )
+ xp -= 20;
+ else
+ xp -= windowsRightBorder;
+ int xoff = tqvisualRect( TQRect( xp, y+windowsItemVMargin, tab, h-2*windowsItemVMargin ), r ).x();
+ if ( dis && !act ) {
+ p->setPen( cg.light() );
+ p->drawText( xoff+1, y+windowsItemVMargin+1, tab, h-2*windowsItemVMargin, text_flags, s.mid( t+1 ));
+ p->setPen( discol );
+ }
+ p->drawText( xoff, y+windowsItemVMargin, tab, h-2*windowsItemVMargin, text_flags, s.mid( t+1 ) );
+ s = s.left( t );
+ }
+ if ( dis && !act ) {
+ p->setPen( cg.light() );
+ p->drawText( xvis+1, y+windowsItemVMargin+1, w-xm-tab+1, h-2*windowsItemVMargin, text_flags, s, t );
+ p->setPen( discol );
+ }
+ p->drawText( xvis, y+windowsItemVMargin, w-xm-tab+1, h-2*windowsItemVMargin, text_flags, s, t );
+ } else if ( mi->pixmap() ) { // draw pixmap
+ TQPixmap *pixmap = mi->pixmap();
+ if ( pixmap->depth() == 1 )
+ p->setBackgroundMode( Qt::OpaqueMode );
+ p->drawPixmap( xvis, y+windowsItemFrame, *pixmap );
+ if ( pixmap->depth() == 1 )
+ p->setBackgroundMode( Qt::TransparentMode );
+ }
+ if ( mi->popup() ) { // draw sub menu arrow
+ int dim = (h-2*windowsItemFrame) / 2;
+ PrimitiveElement arrow;
+ arrow = ( TQApplication::reverseLayout() ? PE_ArrowLeft : PE_ArrowRight );
+ xpos = x+w - windowsArrowHMargin - windowsItemFrame - dim;
+ vrect = tqvisualRect( TQRect(xpos, y + h / 2 - dim / 2, dim, dim), r );
+ if ( act ) {
+ TQColorGroup g2 = cg;
+ g2.setColor( TQColorGroup::ButtonText, g2.highlightedText() );
+ tqdrawPrimitive(arrow, p, vrect,
+ g2, dis ? Style_Default : Style_Enabled);
+ } else {
+ tqdrawPrimitive(arrow, p, vrect,
+ cg, dis ? Style_Default : Style_Enabled );
+ }
+ }
+
+ break;
+ }
+#endif
+
+ case CE_MenuBarItem:
+ {
+ bool active = flags & Style_Active;
+ bool hasFocus = flags & Style_HasFocus;
+ bool down = flags & Style_Down;
+ TQRect pr = r;
+
+ p->fillRect( r, cg.brush( TQColorGroup::Button ) );
+ if ( active || hasFocus ) {
+ TQBrush b = cg.brush( TQColorGroup::Button );
+ if ( active && down )
+ p->setBrushOrigin(p->brushOrigin() + TQPoint(1,1));
+ if ( active && hasFocus )
+ qDrawShadeRect( p, r.x(), r.y(), r.width(), r.height(),
+ cg, active && down, 1, 0, &b );
+ if ( active && down ) {
+ pr.moveBy( tqpixelMetric(PM_ButtonShiftHorizontal, widget),
+ tqpixelMetric(PM_ButtonShiftVertical, widget) );
+ p->setBrushOrigin(p->brushOrigin() - TQPoint(1,1));
+ }
+ }
+ TQCommonStyle::tqdrawControl(element, p, widget, pr, cg, flags, opt);
+ break;
+ }
+
+ default:
+ TQCommonStyle::tqdrawControl(element, p, widget, r, cg, flags, opt);
+ }
+}
+
+
+/*!
+ \reimp
+*/
+int TQWindowsStyle::tqpixelMetric(PixelMetric metric, const TQWidget *widget) const
+{
+ int ret;
+
+ switch (metric) {
+ case PM_ButtonDefaultIndicator:
+ case PM_ButtonShiftHorizontal:
+ case PM_ButtonShiftVertical:
+ ret = 1;
+ break;
+
+ case PM_MaximumDragDistance:
+ ret = 60;
+ break;
+
+#ifndef TQT_NO_SLIDER
+ case PM_SliderLength:
+ ret = 11;
+ break;
+
+ // Returns the number of pixels to use for the business part of the
+ // slider (i.e., the non-tickmark portion). The remaining space is shared
+ // equally between the tickmark regions.
+ case PM_SliderControlThickness:
+ {
+ const TQSlider * sl = (const TQSlider *) widget;
+ int space = (sl->orientation() == Qt::Horizontal) ? sl->height()
+ : sl->width();
+ int ticks = sl->tickmarks();
+ int n = 0;
+ if ( ticks & TQSlider::Above ) n++;
+ if ( ticks & TQSlider::Below ) n++;
+ if ( !n ) {
+ ret = space;
+ break;
+ }
+
+ int thick = 6; // Magic constant to get 5 + 16 + 5
+ if ( ticks != TQSlider::Both && ticks != TQSlider::NoMarks )
+ thick += tqpixelMetric( PM_SliderLength, sl ) / 4;
+
+ space -= thick;
+ //### the two sides may be unequal in size
+ if ( space > 0 )
+ thick += (space * 2) / (n + 2);
+ ret = thick;
+ break;
+ }
+#endif // TQT_NO_SLIDER
+
+ case PM_MenuBarFrameWidth:
+ ret = 0;
+ break;
+
+#if defined(TQ_WS_WIN)
+ case PM_TitleBarHeight:
+ if ( widget && ( widget->testWFlags( WStyle_Tool ) || ::tqqt_cast<TQDockWindow*>(widget) ) ) {
+ // MS always use one less than they say
+#if defined(TQ_OS_TEMP)
+ ret = GetSystemMetrics( SM_CYCAPTION ) - 1;
+#else
+ ret = GetSystemMetrics( SM_CYSMCAPTION ) - 1;
+#endif
+ } else {
+ ret = GetSystemMetrics( SM_CYCAPTION ) - 1;
+ }
+ break;
+
+ case PM_ScrollBarExtent:
+ {
+#ifndef TQ_OS_TEMP
+ NONCLIENTMETRICS ncm;
+ ncm.cbSize = sizeof(NONCLIENTMETRICS);
+ if ( SystemParametersInfo( SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0 ) )
+ ret = TQMAX( ncm.iScrollHeight, ncm.iScrollWidth );
+ else
+#endif
+ ret = TQCommonStyle::tqpixelMetric( metric, widget );
+ }
+ break;
+#endif
+
+ case PM_SplitterWidth:
+ ret = TQMAX( 6, TQApplication::globalStrut().width() );
+ break;
+
+#if defined(TQ_WS_WIN)
+ case PM_MDIFrameWidth:
+ ret = GetSystemMetrics(SM_CYFRAME);
+ break;
+#endif
+
+ default:
+ ret = TQCommonStyle::tqpixelMetric(metric, widget);
+ break;
+ }
+
+ return ret;
+}
+
+
+/*!
+ \reimp
+*/
+TQSize TQWindowsStyle::tqsizeFromContents( ContentsType contents,
+ const TQWidget *widget,
+ const TQSize &contentsSize,
+ const TQStyleOption& opt ) const
+{
+ TQSize sz(contentsSize);
+
+ switch (contents) {
+ case CT_PushButton:
+ {
+#ifndef TQT_NO_PUSHBUTTON
+ const TQPushButton *button = (const TQPushButton *) widget;
+ sz = TQCommonStyle::tqsizeFromContents(contents, widget, contentsSize, opt);
+ int w = sz.width(), h = sz.height();
+
+ int defwidth = 0;
+ if (button->isDefault() || button->autoDefault())
+ defwidth = 2*tqpixelMetric( PM_ButtonDefaultIndicator, widget );
+
+ if (w < 80+defwidth && !button->pixmap())
+ w = 80+defwidth;
+ if (h < 23+defwidth)
+ h = 23+defwidth;
+
+ sz = TQSize(w, h);
+#endif
+ break;
+ }
+
+ case CT_PopupMenuItem:
+ {
+#ifndef TQT_NO_POPUPMENU
+ if (! widget || opt.isDefault())
+ break;
+
+ const TQPopupMenu *popup = (const TQPopupMenu *) widget;
+ bool checkable = popup->isCheckable();
+ TQMenuItem *mi = opt.menuItem();
+ int maxpmw = opt.maxIconWidth();
+ int w = sz.width(), h = sz.height();
+
+ if (mi->custom()) {
+ w = mi->custom()->tqsizeHint().width();
+ h = mi->custom()->tqsizeHint().height();
+ if (! mi->custom()->fullSpan())
+ h += 2*windowsItemVMargin + 2*windowsItemFrame;
+ } else if ( mi->widget() ) {
+ } else if (mi->isSeparator()) {
+ w = 10; // arbitrary
+ h = windowsSepHeight;
+ } else {
+ if (mi->pixmap())
+ h = TQMAX(h, mi->pixmap()->height() + 2*windowsItemFrame);
+ else if (! mi->text().isNull())
+ h = TQMAX(h, popup->fontMetrics().height() + 2*windowsItemVMargin +
+ 2*windowsItemFrame);
+
+ if (mi->iconSet() != 0)
+ h = TQMAX(h, mi->iconSet()->pixmap(TQIconSet::Small,
+ TQIconSet::Normal).height() +
+ 2*windowsItemFrame);
+ }
+
+ if (! mi->text().isNull() && mi->text().tqfind('\t') >= 0) {
+ if ( use2000style )
+ w += 20;
+ else
+ w += windowsTabSpacing;
+ } else if (mi->popup()) {
+ w += 2*windowsArrowHMargin;
+ }
+
+ if (use2000style) {
+ if (checkable && maxpmw < 20)
+ w += 20 - maxpmw;
+ } else {
+ if (checkable && maxpmw < windowsCheckMarkWidth)
+ w += windowsCheckMarkWidth - maxpmw;
+ }
+ if (checkable || maxpmw > 0)
+ w += windowsCheckMarkHMargin;
+ if (use2000style)
+ w += 20;
+ else
+ w += windowsRightBorder;
+
+ sz = TQSize(w, h);
+#endif
+ break;
+ }
+
+ default:
+ sz = TQCommonStyle::tqsizeFromContents(contents, widget, sz, opt);
+ break;
+ }
+
+ return sz;
+}
+
+/*! \reimp
+*/
+void TQWindowsStyle::polishPopupMenu( TQPopupMenu* p)
+{
+#ifndef TQT_NO_POPUPMENU
+ if ( !p->testWState( TQt::WState_Polished ) )
+ p->setCheckable( TRUE );
+#endif
+}
+
+#ifndef TQT_NO_IMAGEIO_XPM
+static const char * const qt_close_xpm[] = {
+"12 12 2 1",
+"# c #000000",
+". c None",
+"............",
+"............",
+"..##....##..",
+"...##..##...",
+"....####....",
+".....##.....",
+"....####....",
+"...##..##...",
+"..##....##..",
+"............",
+"............",
+"............"};
+
+static const char * const qt_maximize_xpm[]={
+"12 12 2 1",
+"# c #000000",
+". c None",
+"............",
+".#########..",
+".#########..",
+".#.......#..",
+".#.......#..",
+".#.......#..",
+".#.......#..",
+".#.......#..",
+".#.......#..",
+".#########..",
+"............",
+"............"};
+
+
+static const char * const qt_minimize_xpm[] = {
+"12 12 2 1",
+"# c #000000",
+". c None",
+"............",
+"............",
+"............",
+"............",
+"............",
+"............",
+"............",
+"............",
+"..######....",
+"..######....",
+"............",
+"............"};
+
+static const char * const qt_normalizeup_xpm[] = {
+"12 12 2 1",
+"# c #000000",
+". c None",
+"............",
+"....######..",
+"....######..",
+"....#....#..",
+"..######.#..",
+"..######.#..",
+"..#....###..",
+"..#....#....",
+"..#....#....",
+"..######....",
+"............",
+"............"};
+
+
+static const char * const qt_shade_xpm[] = {
+"12 12 2 1",
+"# c #000000",
+". c None",
+"............",
+"............",
+"............",
+"............",
+"............",
+".....#......",
+"....###.....",
+"...#####....",
+"..#######...",
+"............",
+"............",
+"............"};
+
+static const char * const qt_unshade_xpm[] = {
+"12 12 2 1",
+"# c #000000",
+". c None",
+"............",
+"............",
+"............",
+"............",
+"..#######...",
+"...#####....",
+"....###.....",
+".....#......",
+"............",
+"............",
+"............",
+"............"};
+
+static const char * dock_window_close_xpm[] = {
+"8 8 2 1",
+"# c #000000",
+". c None",
+"........",
+".##..##.",
+"..####..",
+"...##...",
+"..####..",
+".##..##.",
+"........",
+"........"};
+
+/* XPM */
+static const char * const information_xpm[]={
+"32 32 5 1",
+". c None",
+"c c #000000",
+"* c #999999",
+"a c #ffffff",
+"b c #0000ff",
+"...........********.............",
+"........***aaaaaaaa***..........",
+"......**aaaaaaaaaaaaaa**........",
+".....*aaaaaaaaaaaaaaaaaa*.......",
+"....*aaaaaaaabbbbaaaaaaaac......",
+"...*aaaaaaaabbbbbbaaaaaaaac.....",
+"..*aaaaaaaaabbbbbbaaaaaaaaac....",
+".*aaaaaaaaaaabbbbaaaaaaaaaaac...",
+".*aaaaaaaaaaaaaaaaaaaaaaaaaac*..",
+"*aaaaaaaaaaaaaaaaaaaaaaaaaaaac*.",
+"*aaaaaaaaaabbbbbbbaaaaaaaaaaac*.",
+"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
+"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
+"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
+"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
+"*aaaaaaaaaaaabbbbbaaaaaaaaaaac**",
+".*aaaaaaaaaaabbbbbaaaaaaaaaac***",
+".*aaaaaaaaaaabbbbbaaaaaaaaaac***",
+"..*aaaaaaaaaabbbbbaaaaaaaaac***.",
+"...caaaaaaabbbbbbbbbaaaaaac****.",
+"....caaaaaaaaaaaaaaaaaaaac****..",
+".....caaaaaaaaaaaaaaaaaac****...",
+"......ccaaaaaaaaaaaaaacc****....",
+".......*cccaaaaaaaaccc*****.....",
+"........***cccaaaac*******......",
+"..........****caaac*****........",
+".............*caaac**...........",
+"...............caac**...........",
+"................cac**...........",
+".................cc**...........",
+"..................***...........",
+"...................**..........."};
+/* XPM */
+static const char* const warning_xpm[]={
+"32 32 4 1",
+". c None",
+"a c #ffff00",
+"* c #000000",
+"b c #999999",
+".............***................",
+"............*aaa*...............",
+"...........*aaaaa*b.............",
+"...........*aaaaa*bb............",
+"..........*aaaaaaa*bb...........",
+"..........*aaaaaaa*bb...........",
+".........*aaaaaaaaa*bb..........",
+".........*aaaaaaaaa*bb..........",
+"........*aaaaaaaaaaa*bb.........",
+"........*aaaa***aaaa*bb.........",
+".......*aaaa*****aaaa*bb........",
+".......*aaaa*****aaaa*bb........",
+"......*aaaaa*****aaaaa*bb.......",
+"......*aaaaa*****aaaaa*bb.......",
+".....*aaaaaa*****aaaaaa*bb......",
+".....*aaaaaa*****aaaaaa*bb......",
+"....*aaaaaaaa***aaaaaaaa*bb.....",
+"....*aaaaaaaa***aaaaaaaa*bb.....",
+"...*aaaaaaaaa***aaaaaaaaa*bb....",
+"...*aaaaaaaaaa*aaaaaaaaaa*bb....",
+"..*aaaaaaaaaaa*aaaaaaaaaaa*bb...",
+"..*aaaaaaaaaaaaaaaaaaaaaaa*bb...",
+".*aaaaaaaaaaaa**aaaaaaaaaaa*bb..",
+".*aaaaaaaaaaa****aaaaaaaaaa*bb..",
+"*aaaaaaaaaaaa****aaaaaaaaaaa*bb.",
+"*aaaaaaaaaaaaa**aaaaaaaaaaaa*bb.",
+"*aaaaaaaaaaaaaaaaaaaaaaaaaaa*bbb",
+"*aaaaaaaaaaaaaaaaaaaaaaaaaaa*bbb",
+".*aaaaaaaaaaaaaaaaaaaaaaaaa*bbbb",
+"..*************************bbbbb",
+"....bbbbbbbbbbbbbbbbbbbbbbbbbbb.",
+".....bbbbbbbbbbbbbbbbbbbbbbbbb.."};
+/* XPM */
+static const char* const critical_xpm[]={
+"32 32 4 1",
+". c None",
+"a c #999999",
+"* c #ff0000",
+"b c #ffffff",
+"...........********.............",
+".........************...........",
+".......****************.........",
+"......******************........",
+".....********************a......",
+"....**********************a.....",
+"...************************a....",
+"..*******b**********b*******a...",
+"..******bbb********bbb******a...",
+".******bbbbb******bbbbb******a..",
+".*******bbbbb****bbbbb*******a..",
+"*********bbbbb**bbbbb*********a.",
+"**********bbbbbbbbbb**********a.",
+"***********bbbbbbbb***********aa",
+"************bbbbbb************aa",
+"************bbbbbb************aa",
+"***********bbbbbbbb***********aa",
+"**********bbbbbbbbbb**********aa",
+"*********bbbbb**bbbbb*********aa",
+".*******bbbbb****bbbbb*******aa.",
+".******bbbbb******bbbbb******aa.",
+"..******bbb********bbb******aaa.",
+"..*******b**********b*******aa..",
+"...************************aaa..",
+"....**********************aaa...",
+"....a********************aaa....",
+".....a******************aaa.....",
+"......a****************aaa......",
+".......aa************aaaa.......",
+".........aa********aaaaa........",
+"...........aaaaaaaaaaa..........",
+".............aaaaaaa............"};
+/* XPM */
+static const char *const question_xpm[] = {
+"32 32 5 1",
+". c None",
+"c c #000000",
+"* c #999999",
+"a c #ffffff",
+"b c #0000ff",
+"...........********.............",
+"........***aaaaaaaa***..........",
+"......**aaaaaaaaaaaaaa**........",
+".....*aaaaaaaaaaaaaaaaaa*.......",
+"....*aaaaaaaaaaaaaaaaaaaac......",
+"...*aaaaaaaabbbbbbaaaaaaaac.....",
+"..*aaaaaaaabaaabbbbaaaaaaaac....",
+".*aaaaaaaabbaaaabbbbaaaaaaaac...",
+".*aaaaaaaabbbbaabbbbaaaaaaaac*..",
+"*aaaaaaaaabbbbaabbbbaaaaaaaaac*.",
+"*aaaaaaaaaabbaabbbbaaaaaaaaaac*.",
+"*aaaaaaaaaaaaabbbbaaaaaaaaaaac**",
+"*aaaaaaaaaaaaabbbaaaaaaaaaaaac**",
+"*aaaaaaaaaaaaabbaaaaaaaaaaaaac**",
+"*aaaaaaaaaaaaabbaaaaaaaaaaaaac**",
+"*aaaaaaaaaaaaaaaaaaaaaaaaaaaac**",
+".*aaaaaaaaaaaabbaaaaaaaaaaaac***",
+".*aaaaaaaaaaabbbbaaaaaaaaaaac***",
+"..*aaaaaaaaaabbbbaaaaaaaaaac***.",
+"...caaaaaaaaaabbaaaaaaaaaac****.",
+"....caaaaaaaaaaaaaaaaaaaac****..",
+".....caaaaaaaaaaaaaaaaaac****...",
+"......ccaaaaaaaaaaaaaacc****....",
+".......*cccaaaaaaaaccc*****.....",
+"........***cccaaaac*******......",
+"..........****caaac*****........",
+".............*caaac**...........",
+"...............caac**...........",
+"................cac**...........",
+".................cc**...........",
+"..................***...........",
+"...................**...........",
+};
+#endif //TQT_NO_IMAGEIO_XPM
+
+/*!
+ \reimp
+ */
+TQPixmap TQWindowsStyle::stylePixmap(StylePixmap stylepixmap,
+ const TQWidget *widget,
+ const TQStyleOption& opt) const
+{
+#ifndef TQT_NO_IMAGEIO_XPM
+ switch (stylepixmap) {
+ case SP_TitleBarShadeButton:
+ return TQPixmap( (const char **)qt_shade_xpm );
+ case SP_TitleBarUnshadeButton:
+ return TQPixmap( (const char **)qt_unshade_xpm );
+ case SP_TitleBarNormalButton:
+ return TQPixmap( (const char **)qt_normalizeup_xpm );
+ case SP_TitleBarMinButton:
+ return TQPixmap( (const char **)qt_minimize_xpm );
+ case SP_TitleBarMaxButton:
+ return TQPixmap( (const char **)qt_maximize_xpm );
+ case SP_TitleBarCloseButton:
+ return TQPixmap( (const char **)qt_close_xpm );
+ case SP_DockWindowCloseButton:
+ return TQPixmap( (const char **)dock_window_close_xpm );
+ case SP_MessageBoxInformation:
+ return TQPixmap( (const char **)information_xpm);
+ case SP_MessageBoxWarning:
+ return TQPixmap( (const char **)warning_xpm );
+ case SP_MessageBoxCritical:
+ return TQPixmap( (const char **)critical_xpm );
+ case SP_MessageBoxQuestion:
+ return TQPixmap( (const char **)question_xpm );
+ default:
+ break;
+ }
+#endif //TQT_NO_IMAGEIO_XPM
+ return TQCommonStyle::stylePixmap(stylepixmap, widget, opt);
+}
+
+/*!\reimp
+*/
+void TQWindowsStyle::tqdrawComplexControl( TQ_ComplexControl ctrl, TQPainter *p,
+ const TQWidget *widget,
+ const TQRect &r,
+ const TQColorGroup &cg,
+ SFlags flags,
+ SCFlags sub,
+ SCFlags subActive,
+ const TQStyleOption& opt ) const
+{
+ switch (ctrl) {
+#ifndef TQT_NO_LISTVIEW
+ case CC_ListView:
+ {
+ if ( sub & SC_ListView ) {
+ TQCommonStyle::tqdrawComplexControl( ctrl, p, widget, r, cg, flags, sub, subActive, opt );
+ }
+ if ( sub & ( SC_ListViewBranch | SC_ListViewExpand ) ) {
+ if (opt.isDefault())
+ break;
+
+ TQListViewItem *item = opt.listViewItem(),
+ *child = item->firstChild();
+
+ int y = r.y();
+ int c;
+ int dotoffset = 0;
+ TQPointArray dotlines;
+ if ( subActive == (uint)SC_All && sub == SC_ListViewExpand ) {
+ c = 2;
+ dotlines.resize(2);
+ dotlines[0] = TQPoint( r.right(), r.top() );
+ dotlines[1] = TQPoint( r.right(), r.bottom() );
+ } else {
+ int linetop = 0, linebot = 0;
+ // each branch needs at most two lines, ie. four end points
+ dotoffset = (item->itemPos() + item->height() - y) %2;
+ dotlines.resize( item->childCount() * 4 );
+ c = 0;
+
+ // skip the stuff above the exposed rectangle
+ while ( child && y + child->height() <= 0 ) {
+ y += child->totalHeight();
+ child = child->nextSibling();
+ }
+
+ int bx = r.width() / 2;
+
+ // paint stuff in the magical area
+ TQListView* v = item->listView();
+ while ( child && y < r.height() ) {
+ if (child->isVisible()) {
+ int lh;
+ if ( !item->multiLinesEnabled() )
+ lh = child->height();
+ else
+ lh = p->fontMetrics().height() + 2 * v->itemMargin();
+ lh = TQMAX( lh, TQApplication::globalStrut().height() );
+ if ( lh % 2 > 0 )
+ lh++;
+ linebot = y + lh/2;
+ if ( (child->isExpandable() || child->childCount()) &&
+ (child->height() > 0) ) {
+ // needs a box
+ p->setPen( cg.mid() );
+ p->drawRect( bx-4, linebot-4, 9, 9 );
+ // plus or minus
+ p->setPen( cg.text() );
+ p->drawLine( bx - 2, linebot, bx + 2, linebot );
+ if ( !child->isOpen() )
+ p->drawLine( bx, linebot - 2, bx, linebot + 2 );
+ // dotlinery
+ p->setPen( cg.mid() );
+ dotlines[c++] = TQPoint( bx, linetop );
+ dotlines[c++] = TQPoint( bx, linebot - 4 );
+ dotlines[c++] = TQPoint( bx + 5, linebot );
+ dotlines[c++] = TQPoint( r.width(), linebot );
+ linetop = linebot + 5;
+ } else {
+ // just dotlinery
+ dotlines[c++] = TQPoint( bx+1, linebot -1);
+ dotlines[c++] = TQPoint( r.width(), linebot -1);
+ }
+ y += child->totalHeight();
+ }
+ child = child->nextSibling();
+ }
+
+ // Expand line height to edge of rectangle if there's any
+ // visible child below
+ while ( child && child->height() <= 0)
+ child = child->nextSibling();
+ if ( child )
+ linebot = r.height();
+
+ if ( linetop < linebot ) {
+ dotlines[c++] = TQPoint( bx, linetop );
+ dotlines[c++] = TQPoint( bx, linebot );
+ }
+ }
+ p->setPen( cg.text() );
+
+ static TQBitmap *verticalLine = 0, *horizontalLine = 0;
+ static TQCleanupHandler<TQBitmap> qlv_cleanup_bitmap;
+ if ( !verticalLine ) {
+ // make 128*1 and 1*128 bitmaps that can be used for
+ // drawing the right sort of lines.
+ verticalLine = new TQBitmap( 1, 129, TRUE );
+ horizontalLine = new TQBitmap( 128, 1, TRUE );
+ TQPointArray a( 64 );
+ TQPainter p;
+ p.begin( verticalLine );
+ int i;
+ for( i=0; i<64; i++ )
+ a.setPoint( i, 0, i*2+1 );
+ p.setPen( Qt::color1 );
+ p.drawPoints( a );
+ p.end();
+ TQApplication::flushX();
+ verticalLine->setMask( *verticalLine );
+ p.begin( horizontalLine );
+ for( i=0; i<64; i++ )
+ a.setPoint( i, i*2+1, 0 );
+ p.setPen( Qt::color1 );
+ p.drawPoints( a );
+ p.end();
+ TQApplication::flushX();
+ horizontalLine->setMask( *horizontalLine );
+ qlv_cleanup_bitmap.add( &verticalLine );
+ qlv_cleanup_bitmap.add( &horizontalLine );
+ }
+
+ int line; // index into dotlines
+ if ( sub & SC_ListViewBranch ) for( line = 0; line < c; line += 2 ) {
+ // assumptions here: lines are horizontal or vertical.
+ // lines always start with the numerically lowest
+ // coordinate.
+
+ // point ... relevant coordinate of current point
+ // end ..... same coordinate of the end of the current line
+ // other ... the other coordinate of the current point/line
+ if ( dotlines[line].y() == dotlines[line+1].y() ) {
+ int end = dotlines[line+1].x();
+ int point = dotlines[line].x();
+ int other = dotlines[line].y();
+ while( point < end ) {
+ int i = 128;
+ if ( i+point > end )
+ i = end-point;
+ p->drawPixmap( point, other, *horizontalLine,
+ 0, 0, i, 1 );
+ point += i;
+ }
+ } else {
+ int end = dotlines[line+1].y();
+ int point = dotlines[line].y();
+ int other = dotlines[line].x();
+ int pixmapoffset = ((point & 1) != dotoffset ) ? 1 : 0;
+ while( point < end ) {
+ int i = 128;
+ if ( i+point > end )
+ i = end-point;
+ p->drawPixmap( other, point, *verticalLine,
+ 0, pixmapoffset, 1, i );
+ point += i;
+ }
+ }
+ }
+ }
+ }
+ break;
+#endif //TQT_NO_LISTVIEW
+
+#ifndef TQT_NO_COMBOBOX
+ case CC_ComboBox:
+ if ( sub & SC_ComboBoxArrow ) {
+ SFlags flags = Style_Default;
+
+ qDrawWinPanel( p, r, cg, TRUE, widget->isEnabled() ?
+ &cg.brush( TQColorGroup::Base ):
+ &cg.brush( TQColorGroup::Background ) );
+
+ TQRect ar =
+ TQStyle::tqvisualRect( querySubControlMetrics( CC_ComboBox, widget,
+ SC_ComboBoxArrow ), widget );
+ if ( subActive == SC_ComboBoxArrow ) {
+ p->setPen( cg.dark() );
+ p->setBrush( cg.brush( TQColorGroup::Button ) );
+ p->drawRect( ar );
+ } else
+ qDrawWinPanel( p, ar, cg, FALSE,
+ &cg.brush( TQColorGroup::Button ) );
+
+ ar.addCoords( 2, 2, -2, -2 );
+ if ( widget->isEnabled() )
+ flags |= Style_Enabled;
+
+ if ( subActive == SC_ComboBoxArrow ) {
+ flags |= Style_Sunken;
+ }
+ tqdrawPrimitive( PE_ArrowDown, p, ar, cg, flags );
+ }
+
+ if ( sub & SC_ComboBoxEditField ) {
+ const TQComboBox * cb = (const TQComboBox *) widget;
+ TQRect re =
+ TQStyle::tqvisualRect( querySubControlMetrics( CC_ComboBox, widget,
+ SC_ComboBoxEditField ), widget );
+ if ( cb->hasFocus() && !cb->editable() )
+ p->fillRect( re.x(), re.y(), re.width(), re.height(),
+ cg.brush( TQColorGroup::Highlight ) );
+
+ if ( cb->hasFocus() ) {
+ p->setPen( cg.highlightedText() );
+ p->setBackgroundColor( cg.highlight() );
+
+ } else {
+ p->setPen( cg.text() );
+ p->setBackgroundColor( cg.background() );
+ }
+
+ if ( cb->hasFocus() && !cb->editable() ) {
+ TQRect re =
+ TQStyle::tqvisualRect( subRect( SR_ComboBoxFocusRect, cb ), widget );
+ tqdrawPrimitive( PE_FocusRect, p, re, cg, Style_FocusAtBorder, TQStyleOption(cg.highlight()));
+ }
+ }
+
+ break;
+#endif // TQT_NO_COMBOBOX
+
+#ifndef TQT_NO_SLIDER
+ case CC_Slider:
+ {
+ const TQSlider *sl = (const TQSlider *) widget;
+ int thickness = tqpixelMetric( PM_SliderControlThickness, widget );
+ int len = tqpixelMetric( PM_SliderLength, widget );
+ int ticks = sl->tickmarks();
+
+ TQRect groove = querySubControlMetrics(CC_Slider, widget, SC_SliderGroove,
+ opt),
+ handle = querySubControlMetrics(CC_Slider, widget, SC_SliderHandle,
+ opt);
+
+ if ((sub & SC_SliderGroove) && groove.isValid()) {
+ int mid = thickness / 2;
+
+ if ( ticks & TQSlider::Above )
+ mid += len / 8;
+ if ( ticks & TQSlider::Below )
+ mid -= len / 8;
+
+ p->setPen( cg.shadow() );
+ if ( sl->orientation() == Qt::Horizontal ) {
+ qDrawWinPanel( p, groove.x(), groove.y() + mid - 2,
+ groove.width(), 4, cg, TRUE );
+ p->drawLine( groove.x() + 1, groove.y() + mid - 1,
+ groove.x() + groove.width() - 3, groove.y() + mid - 1 );
+ } else {
+ qDrawWinPanel( p, groove.x() + mid - 2, groove.y(),
+ 4, groove.height(), cg, TRUE );
+ p->drawLine( groove.x() + mid - 1, groove.y() + 1,
+ groove.x() + mid - 1,
+ groove.y() + groove.height() - 3 );
+ }
+ }
+
+ if (sub & SC_SliderTickmarks)
+ TQCommonStyle::tqdrawComplexControl(ctrl, p, widget, r, cg, flags,
+ SC_SliderTickmarks, subActive,
+ opt );
+
+ if ( sub & SC_SliderHandle ) {
+ // 4444440
+ // 4333310
+ // 4322210
+ // 4322210
+ // 4322210
+ // 4322210
+ // *43210*
+ // **410**
+ // ***0***
+ const TQColor c0 = cg.shadow();
+ const TQColor c1 = cg.dark();
+ // const TQColor c2 = g.button();
+ const TQColor c3 = cg.midlight();
+ const TQColor c4 = cg.light();
+
+ int x = handle.x(), y = handle.y(),
+ wi = handle.width(), he = handle.height();
+
+ int x1 = x;
+ int x2 = x+wi-1;
+ int y1 = y;
+ int y2 = y+he-1;
+
+ Qt::Orientation orient = sl->orientation();
+ bool tickAbove = sl->tickmarks() == TQSlider::Above;
+ bool tickBelow = sl->tickmarks() == TQSlider::Below;
+
+ p->fillRect( x, y, wi, he, cg.brush( TQColorGroup::Background ) );
+
+ if ( flags & Style_HasFocus ) {
+ TQRect re = subRect( SR_SliderFocusRect, sl );
+ tqdrawPrimitive( PE_FocusRect, p, re, cg );
+ }
+
+ if ( (tickAbove && tickBelow) || (!tickAbove && !tickBelow) ) {
+ qDrawWinButton( p, TQRect(x,y,wi,he), cg, FALSE,
+ &cg.brush( TQColorGroup::Button ) );
+ return;
+ }
+
+ TQSliderDirection dir;
+
+ if ( orient == Qt::Horizontal )
+ if ( tickAbove )
+ dir = SlUp;
+ else
+ dir = SlDown;
+ else
+ if ( tickAbove )
+ dir = SlLeft;
+ else
+ dir = SlRight;
+
+ TQPointArray a;
+
+ int d = 0;
+ switch ( dir ) {
+ case SlUp:
+ y1 = y1 + wi/2;
+ d = (wi + 1) / 2 - 1;
+ a.setPoints(5, x1,y1, x1,y2, x2,y2, x2,y1, x1+d,y1-d );
+ break;
+ case SlDown:
+ y2 = y2 - wi/2;
+ d = (wi + 1) / 2 - 1;
+ a.setPoints(5, x1,y1, x1,y2, x1+d,y2+d, x2,y2, x2,y1 );
+ break;
+ case SlLeft:
+ d = (he + 1) / 2 - 1;
+ x1 = x1 + he/2;
+ a.setPoints(5, x1,y1, x1-d,y1+d, x1,y2, x2,y2, x2,y1);
+ break;
+ case SlRight:
+ d = (he + 1) / 2 - 1;
+ x2 = x2 - he/2;
+ a.setPoints(5, x1,y1, x1,y2, x2,y2, x2+d,y1+d, x2,y1 );
+ break;
+ }
+
+ TQBrush oldBrush = p->brush();
+ p->setBrush( cg.brush( TQColorGroup::Button ) );
+ p->setPen( Qt::NoPen );
+ p->drawRect( x1, y1, x2-x1+1, y2-y1+1 );
+ p->drawPolygon( a );
+ p->setBrush( oldBrush );
+
+ if ( dir != SlUp ) {
+ p->setPen( c4 );
+ p->drawLine( x1, y1, x2, y1 );
+ p->setPen( c3 );
+ p->drawLine( x1, y1+1, x2, y1+1 );
+ }
+ if ( dir != SlLeft ) {
+ p->setPen( c3 );
+ p->drawLine( x1+1, y1+1, x1+1, y2 );
+ p->setPen( c4 );
+ p->drawLine( x1, y1, x1, y2 );
+ }
+ if ( dir != SlRight ) {
+ p->setPen( c0 );
+ p->drawLine( x2, y1, x2, y2 );
+ p->setPen( c1 );
+ p->drawLine( x2-1, y1+1, x2-1, y2-1 );
+ }
+ if ( dir != SlDown ) {
+ p->setPen( c0 );
+ p->drawLine( x1, y2, x2, y2 );
+ p->setPen( c1 );
+ p->drawLine( x1+1, y2-1, x2-1, y2-1 );
+ }
+
+ switch ( dir ) {
+ case SlUp:
+ p->setPen( c4 );
+ p->drawLine( x1, y1, x1+d, y1-d);
+ p->setPen( c0 );
+ d = wi - d - 1;
+ p->drawLine( x2, y1, x2-d, y1-d);
+ d--;
+ p->setPen( c3 );
+ p->drawLine( x1+1, y1, x1+1+d, y1-d );
+ p->setPen( c1 );
+ p->drawLine( x2-1, y1, x2-1-d, y1-d);
+ break;
+ case SlDown:
+ p->setPen( c4 );
+ p->drawLine( x1, y2, x1+d, y2+d);
+ p->setPen( c0 );
+ d = wi - d - 1;
+ p->drawLine( x2, y2, x2-d, y2+d);
+ d--;
+ p->setPen( c3 );
+ p->drawLine( x1+1, y2, x1+1+d, y2+d );
+ p->setPen( c1 );
+ p->drawLine( x2-1, y2, x2-1-d, y2+d);
+ break;
+ case SlLeft:
+ p->setPen( c4 );
+ p->drawLine( x1, y1, x1-d, y1+d);
+ p->setPen( c0 );
+ d = he - d - 1;
+ p->drawLine( x1, y2, x1-d, y2-d);
+ d--;
+ p->setPen( c3 );
+ p->drawLine( x1, y1+1, x1-d, y1+1+d );
+ p->setPen( c1 );
+ p->drawLine( x1, y2-1, x1-d, y2-1-d);
+ break;
+ case SlRight:
+ p->setPen( c4 );
+ p->drawLine( x2, y1, x2+d, y1+d);
+ p->setPen( c0 );
+ d = he - d - 1;
+ p->drawLine( x2, y2, x2+d, y2-d);
+ d--;
+ p->setPen( c3 );
+ p->drawLine( x2, y1+1, x2+d, y1+1+d );
+ p->setPen( c1 );
+ p->drawLine( x2, y2-1, x2+d, y2-1-d);
+ break;
+ }
+ }
+
+ break;
+ }
+#endif // TQT_NO_SLIDER
+
+ default:
+ TQCommonStyle::tqdrawComplexControl( ctrl, p, widget, r, cg, flags, sub,
+ subActive, opt );
+ break;
+ }
+}
+
+
+/*! \reimp */
+int TQWindowsStyle::tqstyleHint( TQ_StyleHint hint,
+ const TQWidget *widget,
+ const TQStyleOption &opt,
+ TQStyleHintReturn *returnData ) const
+{
+ int ret;
+
+ switch (hint) {
+ case SH_EtchDisabledText:
+ case SH_Slider_SnapToValue:
+ case SH_PrintDialog_RightAlignButtons:
+ case SH_MainWindow_SpaceBelowMenuBar:
+ case SH_FontDialog_SelectAssociatedText:
+ case SH_PopupMenu_AllowActiveAndDisabled:
+ case SH_MenuBar_AltKeyNavigation:
+ case SH_MenuBar_MouseTracking:
+ case SH_PopupMenu_MouseTracking:
+ case SH_ComboBox_ListMouseTracking:
+ case SH_ScrollBar_StopMouseOverSlider:
+ ret = 1;
+ break;
+
+ case SH_ItemView_ChangeHighlightOnFocus:
+#if defined(TQ_WS_WIN)
+ if ( qWinVersion() != WV_95 && qWinVersion() != WV_NT )
+ ret = 1;
+ else
+#endif
+ ret = 0;
+ break;
+
+ case SH_ToolBox_SelectedPageTitleBold:
+ ret = 0;
+ break;
+
+#if defined(TQ_WS_WIN)
+ case SH_UnderlineAccelerator:
+ ret = 1;
+ if ( qWinVersion() != WV_95 && qWinVersion() != WV_98 && qWinVersion() != WV_NT ) {
+ BOOL cues;
+ SystemParametersInfo(SPI_GETKEYBOARDCUES, 0, &cues, 0);
+ ret = cues ? 1 : 0;
+ // Do nothing if we always paint underlines
+ if (!ret && widget && d) {
+ TQMenuBar *menuBar = ::tqqt_cast<TQMenuBar*>(widget);
+ TQPopupMenu *popupMenu = 0;
+ if (!menuBar)
+ popupMenu = ::tqqt_cast<TQPopupMenu*>(widget);
+
+ // If we paint a menubar draw underlines if it has focus, or if alt is down,
+ // or if a popup menu belonging to the menubar is active and paints underlines
+ if (menuBar) {
+ if (menuBar->hasFocus()) {
+ ret = 1;
+ } else if (d->altDown()) {
+ ret = 1;
+ } else if (tqApp->tqfocusWidget() && tqApp->tqfocusWidget()->isPopup()) {
+ popupMenu = ::tqqt_cast<TQPopupMenu*>(tqApp->tqfocusWidget());
+ TQMenuData *pm = popupMenu ? (TQMenuData*)popupMenu->tqqt_cast("TQMenuData") : 0;
+ if (pm && ((FriendlyMenuData*)pm)->parentMenu == menuBar) {
+ if (d->hasSeenAlt(menuBar))
+ ret = 1;
+ }
+ }
+ // If we paint a popup menu draw underlines if the respective menubar does
+ } else if (popupMenu) {
+ TQMenuData *pm = (TQMenuData*)popupMenu->tqqt_cast("TQMenuData");
+ while (pm) {
+ if (((FriendlyMenuData*)pm)->isMenuBar) {
+ menuBar = (TQMenuBar*)pm;
+ if (d->hasSeenAlt(menuBar))
+ ret = 1;
+ break;
+ }
+ pm = ((FriendlyMenuData*)pm)->parentMenu;
+ }
+ // Otherwise draw underlines if the toplevel widget has seen an alt-press
+ } else if (d->hasSeenAlt(widget)) {
+ ret = 1;
+ }
+ }
+
+ }
+ break;
+#endif
+
+ default:
+ ret = TQCommonStyle::tqstyleHint(hint, widget, opt, returnData);
+ break;
+ }
+
+ return ret;
+}
+
+/*! \reimp */
+TQRect TQWindowsStyle::subRect(SubRect r, const TQWidget *widget) const
+{
+ TQRect rect;
+
+ switch (r) {
+#ifndef TQT_NO_SLIDER
+ case SR_SliderFocusRect:
+ {
+ rect = widget->rect();
+ break;
+ }
+#endif // TQT_NO_SLIDER
+ case SR_ToolBoxTabContents:
+ rect = widget->rect();
+ break;
+ default:
+ rect = TQCommonStyle::subRect( r, widget );
+ break;
+ }
+
+ return rect;
+}
+
+#endif
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-05 23:14:28 +0000