Diffstat (limited to 'noncore/styles/theme/othemestyle.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r-- | noncore/styles/theme/othemestyle.cpp | 1532 |
1 files changed, 1532 insertions, 0 deletions
diff --git a/noncore/styles/theme/othemestyle.cpp b/noncore/styles/theme/othemestyle.cpp new file mode 100644 index 0000000..61127b8 --- a/dev/null +++ b/noncore/styles/theme/othemestyle.cpp | |||
@@ -0,0 +1,1532 @@ | |||
1 | /* This file is part of the KDE libraries | ||
2 | Copyright (C) 1999 Daniel M. Duley <mosfet@kde.org> | ||
3 | |||
4 | This library is free software; you can redistribute it and/or | ||
5 | modify it under the terms of the GNU Library General Public | ||
6 | License version 2 as published by the Free Software Foundation. | ||
7 | |||
8 | This library is distributed in the hope that it will be useful, | ||
9 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
10 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
11 | Library General Public License for more details. | ||
12 | |||
13 | You should have received a copy of the GNU Library General Public License | ||
14 | along with this library; see the file COPYING.LIB. If not, write to | ||
15 | the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | ||
16 | Boston, MA 02111-1307, USA. | ||
17 | */ | ||
18 | |||
19 | #include "othemestyle.h" | ||
20 | #include "othemebase.h" | ||
21 | #include <qpe/qpeapplication.h> | ||
22 | #include <qbitmap.h> | ||
23 | #define INCLUDE_MENUITEM_DEF | ||
24 | #include <qmenudata.h> | ||
25 | #include <qpopupmenu.h> | ||
26 | #include <qtabbar.h> | ||
27 | #include <qglobal.h> | ||
28 | |||
29 | #include <limits.h> | ||
30 | #include <stdio.h> | ||
31 | |||
32 | #define QCOORDARRLEN(x) sizeof(x)/(sizeof(QCOORD)*2) | ||
33 | |||
34 | OThemeStyle::OThemeStyle( const QString &configFile ) | ||
35 | : OThemeBase( configFile ) | ||
36 | { | ||
37 | setScrollBarExtent( getSBExtent(), getSBExtent() ); | ||
38 | setButtonDefaultIndicatorWidth( 0 ); // We REALLY should support one, see drawPushButton() below! | ||
39 | } | ||
40 | |||
41 | OThemeStyle::~OThemeStyle() | ||
42 | {} | ||
43 | |||
44 | void OThemeStyle::polish( QApplication * /*app*/ ) | ||
45 | {} | ||
46 | |||
47 | void OThemeStyle::polish( QPalette &p ) | ||
48 | { | ||
49 | oldPalette = p; | ||
50 | |||
51 | QColor bg = oldPalette. color ( QPalette::Normal, QColorGroup::Background ); | ||
52 | |||
53 | if ( bgcolor. isValid ( )) | ||
54 | bg = bgcolor; | ||
55 | |||
56 | if ( isColor ( Background )) | ||
57 | bg = colorGroup ( oldPalette. active ( ), Background )-> background ( ); | ||
58 | |||
59 | p = QPalette ( bg, bg ); | ||
60 | |||
61 | if ( isPixmap( Background ) ) | ||
62 | p. setBrush ( QColorGroup::Background, QBrush ( bg, *uncached ( Background ))); | ||
63 | |||
64 | if ( fgcolor. isValid ( )) { | ||
65 | p. setColor ( QColorGroup::Foreground, fgcolor ); | ||
66 | p. setColor ( QColorGroup::ButtonText, fgcolor ); | ||
67 | } | ||
68 | if ( selfgcolor. isValid ( )) | ||
69 | p. setColor ( QColorGroup::HighlightedText, selfgcolor ); | ||
70 | if ( selbgcolor. isValid ( )) | ||
71 | p. setColor ( QColorGroup::Highlight, selbgcolor ); | ||
72 | if ( winfgcolor. isValid ( )) | ||
73 | p. setColor ( QColorGroup::Text, winfgcolor ); | ||
74 | if ( winbgcolor. isValid ( )) | ||
75 | p. setColor ( QColorGroup::Base, winbgcolor ); | ||
76 | |||
77 | } | ||
78 | |||
79 | |||
80 | void OThemeStyle::unPolish( QApplication *app ) | ||
81 | { | ||
82 | app->setPalette( oldPalette, true ); | ||
83 | } | ||
84 | |||
85 | void OThemeStyle::polish( QWidget *w ) | ||
86 | { | ||
87 | if ( !w->isTopLevel() ) { | ||
88 | if ( w->inherits( "QGroupBox" ) | ||
89 | || w->inherits( "QTabWidget" ) ) { | ||
90 | w->setAutoMask( TRUE ); | ||
91 | return ; | ||
92 | } | ||
93 | if ( w->inherits( "QLabel" ) | ||
94 | || w->inherits( "QSlider" ) | ||
95 | || w->inherits( "QButton" ) | ||
96 | || w->inherits( "QProgressBar" ) | ||
97 | ) { | ||
98 | w->setBackgroundOrigin( QWidget::ParentOrigin ); | ||
99 | } | ||
100 | } | ||
101 | if ( w->inherits( "QPopupMenu" ) ) { | ||
102 | popupPalette = w->palette(); | ||
103 | if ( isColor( MenuItem ) || isColor( MenuItemDown ) ) { | ||
104 | QPalette newPal( w->palette() ); | ||
105 | w->setPalettePropagation( QWidget::SamePalette ); | ||
106 | if ( isColor( MenuItem ) ) { | ||
107 | newPal.setNormal( *colorGroup( newPal.normal(), MenuItem ) ); | ||
108 | newPal.setDisabled( *colorGroup( newPal.normal(), MenuItem ) ); | ||
109 | } | ||
110 | if ( isColor( MenuItemDown ) ) | ||
111 | newPal.setActive( *colorGroup( newPal.active(), MenuItemDown ) ); | ||
112 | w->setPalette( newPal ); | ||
113 | } | ||
114 | } | ||
115 | if ( w->inherits( "QCheckBox" ) ) { | ||
116 | if ( isColor( IndicatorOff ) || isColor( IndicatorOn ) ) { | ||
117 | QPalette newPal( w->palette() ); | ||
118 | w->setPalettePropagation( QWidget::SamePalette ); | ||
119 | if ( isColor( IndicatorOff ) ) { | ||
120 | newPal.setNormal( *colorGroup( newPal.normal(), IndicatorOff ) ); | ||
121 | newPal.setDisabled( *colorGroup( newPal.normal(), IndicatorOff ) ); | ||
122 | } | ||
123 | if ( isColor( IndicatorOn ) ) | ||
124 | newPal.setActive( *colorGroup( newPal.active(), IndicatorOn ) ); | ||
125 | w->setPalette( newPal ); | ||
126 | } | ||
127 | } | ||
128 | if ( w->inherits( "QRadioButton" ) ) { | ||
129 | if ( isColor( ExIndicatorOff ) || isColor( ExIndicatorOn ) ) { | ||
130 | QPalette newPal( w->palette() ); | ||
131 | w->setPalettePropagation( QWidget::SamePalette ); | ||
132 | if ( isColor( ExIndicatorOff ) ) { | ||
133 | newPal.setNormal( *colorGroup( newPal.normal(), ExIndicatorOff ) ); | ||
134 | newPal.setDisabled( *colorGroup( newPal.normal(), | ||
135 | ExIndicatorOff ) ); | ||
136 | } | ||
137 | if ( isColor( ExIndicatorOn ) ) | ||
138 | newPal.setActive( *colorGroup( newPal.active(), ExIndicatorOn ) ); | ||
139 | w->setPalette( newPal ); | ||
140 | } | ||
141 | } | ||
142 | } | ||
143 | |||
144 | void OThemeStyle::unPolish( QWidget* w ) | ||
145 | { | ||
146 | if ( !w->isTopLevel() ) { | ||
147 | if ( w->inherits( "QGroupBox" ) | ||
148 | || w->inherits( "QTabWidget" ) ) { | ||
149 | w->setAutoMask( FALSE ); | ||
150 | return ; | ||
151 | } | ||
152 | if ( w->inherits( "QLabel" ) | ||
153 | || w->inherits( "QSlider" ) | ||
154 | || w->inherits( "QButton" ) | ||
155 | || w->inherits( "QProgressBar" ) | ||
156 | ) { | ||
157 | w->setBackgroundOrigin( QWidget::WidgetOrigin ); | ||
158 | } | ||
159 | } | ||
160 | if ( w->inherits( "QPopupMenu" ) ) | ||
161 | w->unsetPalette(); | ||
162 | if ( w->inherits( "QCheckBox" ) ) | ||
163 | w->unsetPalette(); | ||
164 | if ( w->inherits( "QRadioButton" ) ) | ||
165 | w->unsetPalette(); | ||
166 | } | ||
167 | |||
168 | void OThemeStyle::drawBaseButton( QPainter *p, int x, int y, int w, int h, | ||
169 | const QColorGroup &g, bool sunken, bool | ||
170 | rounded, WidgetType type, const QBrush * ) | ||
171 | { | ||
172 | int offset = borderPixmap( type ) ? 0 : decoWidth( type ); | ||
173 | QPen oldPen = p->pen(); | ||
174 | |||
175 | // handle reverse bevel here since it uses decowidth differently | ||
176 | if ( gradientHint( type ) == GrReverseBevel ) { | ||
177 | int i; | ||
178 | bitBlt( p->device(), x, y, scalePixmap( w, h, type ), 0, 0, w, h, | ||
179 | Qt::CopyROP, true ); | ||
180 | p->setPen( g.text() ); | ||
181 | for ( i = 0; i < borderWidth( type ); ++i, ++x, ++y, w -= 2, h -= 2 ) | ||
182 | p->drawRect( x, y, w, h ); | ||
183 | } | ||
184 | // same with KDE style borders | ||
185 | else if ( !borderPixmap( type ) && shade() == KDE ) { | ||
186 | qDrawWinButton( p, x, y, w, h, g, sunken ); | ||
187 | if ( isPixmap( type ) ) | ||
188 | p->drawTiledPixmap( x + 4, y + 4, w - 6, h - 6, | ||
189 | *scalePixmap( w - 6, h - 6, | ||
190 | type ) ); | ||
191 | else | ||
192 | p->fillRect( x + 4, y + 4, w - 6, h - offset * 6, | ||
193 | g.brush( QColorGroup::Button ) ); | ||
194 | |||
195 | } | ||
196 | else { | ||
197 | if ( ( w - offset * 2 ) > 0 && ( h - offset * 2 ) > 0 ) { | ||
198 | if ( isPixmap( type ) ) | ||
199 | if ( rounded ) | ||
200 | p->drawTiledPixmap( x, y, w, h, *scalePixmap( w, h, type ) ); | ||
201 | else | ||
202 | p->drawTiledPixmap( x + offset, y + offset, w - offset * 2, | ||
203 | h - offset * 2, | ||
204 | *scalePixmap( w - offset * 2, h - offset * 2, | ||
205 | type ) ); | ||
206 | else | ||
207 | p->fillRect( x + offset, y + offset, w - offset * 2, h - offset * 2, | ||
208 | g.brush( QColorGroup::Button ) ); | ||
209 | } | ||
210 | if ( borderPixmap( type ) ) | ||
211 | bitBlt( p->device(), x, y, scaleBorder( w, h, type ), 0, 0, w, h, | ||
212 | Qt::CopyROP, false ); | ||
213 | else | ||
214 | drawShade( p, x, y, w, h, g, sunken, rounded, | ||
215 | highlightWidth( type ), borderWidth( type ), shade() ); | ||
216 | } | ||
217 | p->setPen( oldPen ); | ||
218 | } | ||
219 | |||
220 | void OThemeStyle::drawButton( QPainter *p, int x, int y, int w, int h, | ||
221 | const QColorGroup &g, bool sunken, | ||
222 | const QBrush *fill ) | ||
223 | { | ||
224 | drawBaseButton( p, x, y, w, h, g, sunken, roundButton(), sunken ? | ||
225 | PushButtonDown : PushButton, fill ); | ||
226 | } | ||
227 | |||
228 | void OThemeStyle::drawPushButton( QPushButton* btn, QPainter *p ) | ||
229 | { | ||
230 | bool sunken = btn->isOn() || btn->isDown(); | ||
231 | int diw = buttonDefaultIndicatorWidth(); | ||
232 | drawBaseButton( p, diw, diw, btn->width() - 2 * diw, btn->height() - 2 * diw, | ||
233 | *colorGroup( btn->colorGroup(), sunken ? PushButtonDown : | ||
234 | PushButton ), sunken, roundButton(), | ||
235 | sunken ? PushButtonDown : PushButton, NULL ); | ||
236 | // TODO if diw, draw fancy default button indicator | ||
237 | } | ||
238 | |||
239 | void OThemeStyle::drawBaseMask( QPainter *p, int x, int y, int w, int h, | ||
240 | bool round ) | ||
241 | { | ||
242 | // round edge fills | ||
243 | static const QCOORD btm_left_fill[] = { | ||
244 | 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 0, 1, 1, 1, 2, 1, 3, 1, 4, 1, | ||
245 | 1, 2, 2, 2, 3, 2, 4, 2, 2, 3, 3, 3, 4, 3, 3, 4, 4, 4 | ||
246 | }; | ||
247 | |||
248 | static const QCOORD btm_right_fill[] = { | ||
249 | 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 0, 1, 1, 1, 2, 1, 3, 1, 4, | ||
250 | 1, 0, 2, 1, 2, 2, 2, 3, 2, 0, 3, 1, 3, 2, 3, 0, 4, 1, 4 | ||
251 | }; | ||
252 | |||
253 | static const QCOORD top_left_fill[] = { | ||
254 | 3, 0, 4, 0, 2, 1, 3, 1, 4, 1, 1, 2, 2, 2, 3, 2, 4, 2, 0, 3, | ||
255 | 1, 3, 2, 3, 3, 3, 4, 3, 0, 4, 1, 4, 2, 4, 3, 4, 4, 4 | ||
256 | }; | ||
257 | |||
258 | static const QCOORD top_right_fill[] = { | ||
259 | 0, 0, 1, 0, 0, 1, 1, 1, 2, 1, 0, 2, 1, 2, 2, 2, 3, 2, 0, | ||
260 | 3, 1, 3, 2, 3, 3, 3, 4, 3, 0, 4, 1, 4, 2, 4, 3, 4, 4, 4 | ||
261 | }; | ||
262 | |||
263 | QBrush fillBrush( color1, SolidPattern ); | ||
264 | p->setPen( color1 ); | ||
265 | if ( round && w > 19 && h > 19 ) { | ||
266 | int x2 = x + w - 1; | ||
267 | int y2 = y + h - 1; | ||
268 | QPointArray a( QCOORDARRLEN( top_left_fill ), top_left_fill ); | ||
269 | a.translate( 1, 1 ); | ||
270 | p->drawPoints( a ); | ||
271 | a.setPoints( QCOORDARRLEN( btm_left_fill ), btm_left_fill ); | ||
272 | a.translate( 1, h - 6 ); | ||
273 | p->drawPoints( a ); | ||
274 | a.setPoints( QCOORDARRLEN( top_right_fill ), top_right_fill ); | ||
275 | a.translate( w - 6, 1 ); | ||
276 | p->drawPoints( a ); | ||
277 | a.setPoints( QCOORDARRLEN( btm_right_fill ), btm_right_fill ); | ||
278 | a.translate( w - 6, h - 6 ); | ||
279 | p->drawPoints( a ); | ||
280 | |||
281 | p->fillRect( x + 6, y, w - 12, h, fillBrush ); | ||
282 | p->fillRect( x, y + 6, x + 6, h - 12, fillBrush ); | ||
283 | p->fillRect( x2 - 6, y + 6, x2, h - 12, fillBrush ); | ||
284 | p->drawLine( x + 6, y, x2 - 6, y ); | ||
285 | p->drawLine( x + 6, y2, x2 - 6, y2 ); | ||
286 | p->drawLine( x, y + 6, x, y2 - 6 ); | ||
287 | p->drawLine( x2, y + 6, x2, y2 - 6 ); | ||
288 | |||
289 | } | ||
290 | else | ||
291 | p->fillRect( x, y, w, h, fillBrush ); | ||
292 | } | ||
293 | |||
294 | void OThemeStyle::drawButtonMask( QPainter *p, int x, int y, int w, int h ) | ||
295 | { | ||
296 | drawBaseMask( p, x, y, w, h, roundButton() ); | ||
297 | } | ||
298 | |||
299 | void OThemeStyle::drawComboButtonMask( QPainter *p, int x, int y, int w, int h ) | ||
300 | { | ||
301 | drawBaseMask( p, x, y, w, h, roundComboBox() ); | ||
302 | } | ||
303 | |||
304 | void OThemeStyle::drawBevelButton( QPainter *p, int x, int y, int w, int h, | ||
305 | const QColorGroup &g, bool sunken, | ||
306 | const QBrush * ) | ||
307 | { | ||
308 | WidgetType type = sunken ? BevelDown : Bevel; | ||
309 | drawBaseButton( p, x, y, w, h, *colorGroup( g, type ), sunken, false, type ); | ||
310 | } | ||
311 | |||
312 | #if 0 | ||
313 | void OThemeStyle::drawKToolBarButton( QPainter *p, int x, int y, int w, int h, | ||
314 | const QColorGroup &g, bool sunken, | ||
315 | bool raised, bool enabled, bool popup, | ||
316 | KToolButtonType type, const QString &btext, | ||
317 | const QPixmap *pixmap, QFont *font, | ||
318 | QWidget * ) | ||
319 | { | ||
320 | QFont tmp_font( QString::fromLatin1( "Helvetica" ), 10 ); | ||
321 | if ( font ) | ||
322 | tmp_font = *font; | ||
323 | QFontMetrics fm( tmp_font ); | ||
324 | WidgetType widget = sunken ? ToolButtonDown : ToolButton; | ||
325 | |||
326 | drawBaseButton( p, x, y, w, h, *colorGroup( g, widget ), sunken, false, | ||
327 | widget ); | ||
328 | int dx, dy; | ||
329 | if ( type == Icon ) { // icon only | ||
330 | if ( pixmap ) { | ||
331 | dx = ( w - pixmap->width() ) / 2; | ||
332 | dy = ( h - pixmap->height() ) / 2; | ||
333 | if ( sunken ) { | ||
334 | ++dx; | ||
335 | ++dy; | ||
336 | } | ||
337 | p->drawPixmap( x + dx, y + dy, *pixmap ); | ||
338 | } | ||
339 | } | ||
340 | else if ( type == IconTextRight ) { // icon and text (if any) | ||
341 | if ( pixmap ) { | ||
342 | dx = 4; | ||
343 | dy = ( h - pixmap->height() ) / 2; | ||
344 | if ( sunken ) { | ||
345 | ++dx; | ||
346 | ++dy; | ||
347 | } | ||
348 | p->drawPixmap( x + dx, y + dy, *pixmap ); | ||
349 | } | ||
350 | if ( !btext.isNull() ) { | ||
351 | int tf = AlignVCenter | AlignLeft; | ||
352 | if ( pixmap ) | ||
353 | dx = 4 + pixmap->width() + 2; | ||
354 | else | ||
355 | dx = 4; | ||
356 | dy = 0; | ||
357 | if ( sunken ) { | ||
358 | ++dx; | ||
359 | ++dy; | ||
360 | } | ||
361 | if ( font ) | ||
362 | p->setFont( *font ); | ||
363 | if ( raised ) | ||
364 | p->setPen( KGlobalSettings::toolBarHighlightColor() ); | ||
365 | p->drawText( x + dx, y + dy, w - dx, h, tf, btext ); | ||
366 | } | ||
367 | } | ||
368 | else if ( type == Text ) { // only text, even if there is a icon | ||
369 | if ( !btext.isNull() ) { | ||
370 | int tf = AlignTop | AlignLeft; | ||
371 | if ( !enabled ) | ||
372 | p->setPen( g.dark() ); | ||
373 | dx = ( w - fm.width( btext ) ) / 2; | ||
374 | dy = ( h - fm.lineSpacing() ) / 2; | ||
375 | if ( sunken ) { | ||
376 | ++dx; | ||
377 | ++dy; | ||
378 | } | ||
379 | if ( font ) | ||
380 | p->setFont( *font ); | ||
381 | if ( raised ) | ||
382 | p->setPen( KGlobalSettings::toolBarHighlightColor() ); | ||
383 | p->drawText( x + dx, y + dy, fm.width( btext ), fm.lineSpacing(), tf, btext ); | ||
384 | } | ||
385 | } | ||
386 | else if ( type == IconTextBottom ) { | ||
387 | if ( pixmap ) { | ||
388 | dx = ( w - pixmap->width() ) / 2; | ||
389 | dy = ( h - fm.lineSpacing() - pixmap->height() ) / 2; | ||
390 | if ( sunken ) { | ||
391 | ++dx; | ||
392 | ++dy; | ||
393 | } | ||
394 | p->drawPixmap( x + dx, y + dy, *pixmap ); | ||
395 | } | ||
396 | if ( !btext.isNull() ) { | ||
397 | int tf = AlignBottom | AlignHCenter; | ||
398 | dx = ( w - fm.width( btext ) ) / 2; | ||
399 | dy = h - fm.lineSpacing() - 4; | ||
400 | if ( sunken ) { | ||
401 | ++dx; | ||
402 | ++dy; | ||
403 | } | ||
404 | if ( font ) | ||
405 | p->setFont( *font ); | ||
406 | if ( raised ) | ||
407 | p->setPen( KGlobalSettings::toolBarHighlightColor() ); | ||
408 | p->drawText( x + dx, y + dy, fm.width( btext ), fm.lineSpacing(), tf, btext ); | ||
409 | } | ||
410 | } | ||
411 | if ( popup ) { | ||
412 | if ( enabled ) | ||
413 | qDrawArrow ( p, DownArrow, WindowsStyle, false, w - 5, h - 5, 0, 0, | ||
414 | g, true ); | ||
415 | else | ||
416 | qDrawArrow ( p, DownArrow, WindowsStyle, false, w - 5, h - 5, | ||
417 | 0, 0, g, false ); | ||
418 | } | ||
419 | } | ||
420 | |||
421 | void OThemeStyle::drawKBarHandle( QPainter *p, int x, int y, int w, int h, | ||
422 | const QColorGroup &g, KToolBarPos, QBrush * ) | ||
423 | { | ||
424 | if ( w > h ) | ||
425 | drawBaseButton( p, x, y, w, h, *colorGroup( g, HBarHandle ), false, false, | ||
426 | HBarHandle ); | ||
427 | else | ||
428 | drawBaseButton( p, x, y, w, h, *colorGroup( g, VBarHandle ), false, false, | ||
429 | VBarHandle ); | ||
430 | } | ||
431 | |||
432 | void OThemeStyle::drawKToolBar( QPainter *p, int x, int y, int w, int h, | ||
433 | const QColorGroup &g, KToolBarPos, QBrush * ) | ||
434 | { | ||
435 | drawBaseButton( p, x, y, w, h, *colorGroup( g, ToolBar ), false, false, | ||
436 | ToolBar ); | ||
437 | } | ||
438 | #endif | ||
439 | |||
440 | QRect OThemeStyle::buttonRect( int x, int y, int w, int h ) | ||
441 | { | ||
442 | int spacing = decoWidth( PushButton ) > decoWidth( PushButtonDown ) ? | ||
443 | decoWidth( PushButton ) : decoWidth( PushButtonDown ); | ||
444 | return ( QRect( x + spacing, y + spacing, w - ( spacing * 2 ), h - ( spacing * 2 ) ) ); | ||
445 | } | ||
446 | |||
447 | void OThemeStyle::drawComboButton( QPainter *p, int x, int y, int w, int h, | ||
448 | const QColorGroup &g, bool sunken, bool, | ||
449 | bool, const QBrush * ) | ||
450 | { | ||
451 | WidgetType widget = sunken ? ComboBoxDown : ComboBox; | ||
452 | drawBaseButton( p, x, y, w, h, *colorGroup( g, widget ), sunken, | ||
453 | roundComboBox(), widget ); | ||
454 | if ( !sunken && isPixmap( ComboDeco ) ) | ||
455 | p->drawPixmap( w - uncached( ComboDeco ) ->width() - | ||
456 | decoWidth( ComboBox ) - 2, | ||
457 | y + ( h - uncached( ComboDeco ) -> | ||
458 | height() ) / 2, *uncached( ComboDeco ) ); | ||
459 | else if ( sunken && isPixmap( ComboDecoDown ) ) | ||
460 | p->drawPixmap( w - uncached( ComboDecoDown ) ->width() - | ||
461 | decoWidth( ComboBoxDown ) - 2, | ||
462 | y + ( h - uncached( ComboDecoDown ) -> | ||
463 | height() ) / 2, *uncached( ComboDecoDown ) ); | ||
464 | else { | ||
465 | qDrawArrow( p, Qt::DownArrow, Qt::MotifStyle, false, w - 15, y + 6, 10, | ||
466 | h - 15, *colorGroup( g, widget ), true ); | ||
467 | qDrawShadeRect( p, w - 14, y + 7 + ( h - 15 ), 10, 3, *colorGroup( g, widget ) ); | ||
468 | } | ||
469 | } | ||
470 | |||
471 | void OThemeStyle::drawScrollBarControls( QPainter *p, const QScrollBar *sb, | ||
472 | int sliderStart, uint controls, | ||
473 | uint activeControl ) | ||
474 | { | ||
475 | int sliderMin, sliderMax, sliderLength, buttonDim; | ||
476 | QRect add | ||
477 | , sub, addPage, subPage, slider; | ||
478 | int addX, addY, subX, subY; | ||
479 | bool horizontal = sb->orientation() == QScrollBar::Horizontal; | ||
480 | int len = ( horizontal ) ? sb->width() : sb->height(); | ||
481 | int extent = ( horizontal ) ? sb->height() : sb->width(); | ||
482 | int offset = decoWidth( horizontal ? HScrollGroove : VScrollGroove ); | ||
483 | QColorGroup g = sb->colorGroup(); | ||
484 | |||
485 | scrollBarMetrics( sb, sliderMin, sliderMax, sliderLength, buttonDim ); | ||
486 | if ( sliderStart > sliderMax ) | ||
487 | sliderStart = sliderMax; | ||
488 | |||
489 | int sliderEnd = sliderStart + sliderLength; | ||
490 | int sliderWidth = extent - offset * 2; | ||
491 | |||
492 | // Scary button placement code >:-P Feel free to improve this if you | ||
493 | // want. I get a headache just looking at it... (mosfet) | ||
494 | if ( scrollBarLayout() == SBOpposite ) { | ||
495 | if ( horizontal ) { | ||
496 | subY = addY = ( extent - buttonDim ) / 2; | ||
497 | subX = offset; | ||
498 | addX = len - buttonDim - offset; | ||
499 | } | ||
500 | else { | ||
501 | subX = addX = ( extent - buttonDim ) / 2; | ||
502 | subY = offset; | ||
503 | addY = len - buttonDim - offset; | ||
504 | } | ||
505 | sub.setRect( subX, subY, buttonDim, buttonDim ); | ||
506 | add.setRect( addX, addY, buttonDim, buttonDim ); | ||
507 | if ( horizontal ) { | ||
508 | subPage.setRect( sub.right() + 1, offset, | ||
509 | sliderStart - sub.right() - 1 , sliderWidth ); | ||
510 | addPage.setRect( sliderEnd, offset, addX - sliderEnd, sliderWidth ); | ||
511 | slider.setRect( sliderStart, offset, sliderLength, sliderWidth ); | ||
512 | } | ||
513 | else { | ||
514 | subPage.setRect( offset, sub.bottom() + 1, sliderWidth, | ||
515 | sliderStart - sub.bottom() - 1 ); | ||
516 | addPage.setRect( offset, sliderEnd, sliderWidth, addY - sliderEnd ); | ||
517 | slider.setRect( offset, sliderStart, sliderWidth, sliderLength ); | ||
518 | } | ||
519 | } | ||
520 | else if ( horizontal ) { | ||
521 | subY = addY = ( extent - buttonDim ) / 2; | ||
522 | if ( scrollBarLayout() == SBBottomLeft ) { | ||
523 | subX = offset; | ||
524 | addX = buttonDim + offset; | ||
525 | subPage.setRect( buttonDim * 2, 0, sliderStart - 1, extent ); | ||
526 | addPage.setRect( sliderEnd, 0, len - sliderEnd, extent ); | ||
527 | slider.setRect( sliderStart, 0, sliderLength, extent ); | ||
528 | } | ||
529 | else { | ||
530 | subX = len - buttonDim - buttonDim - offset; | ||
531 | addX = len - buttonDim - offset; | ||
532 | subPage.setRect( offset + 1, offset, sliderStart - 1 , sliderWidth ); | ||
533 | addPage.setRect( sliderEnd, offset, subX - sliderEnd, sliderWidth ); | ||
534 | slider.setRect( sliderStart, offset, sliderLength, sliderWidth ); | ||
535 | } | ||
536 | sub.setRect( subX, subY, buttonDim, buttonDim ); | ||
537 | add.setRect( addX, addY, buttonDim, buttonDim ); | ||
538 | } | ||
539 | else { // BottomLeft and BottomRight vertical bars are the same. | ||
540 | subX = addX = ( extent - buttonDim ) / 2; | ||
541 | subY = len - buttonDim - buttonDim - offset; | ||
542 | addY = len - buttonDim - offset; | ||
543 | subPage.setRect( offset, offset + 1, sliderWidth, | ||
544 | sliderStart - offset - 1 ); | ||
545 | addPage.setRect( offset, sliderEnd, sliderWidth, subY - sliderEnd ); | ||
546 | slider.setRect( offset, sliderStart, sliderWidth, sliderLength ); | ||
547 | sub.setRect( subX, subY, buttonDim, buttonDim ); | ||
548 | add.setRect( addX, addY, buttonDim, buttonDim ); | ||
549 | } | ||
550 | // End of the button placement code | ||
551 | |||
552 | bool active; | ||
553 | if ( ( controls & QStyle::SubPage ) ) { | ||
554 | drawScrollBarGroove( p, sb, horizontal, subPage, g ); | ||
555 | } | ||
556 | if ( ( controls & QStyle::AddPage ) ) { | ||
557 | drawScrollBarGroove( p, sb, horizontal, addPage, g ); | ||
558 | } | ||
559 | if ( controls & QStyle::AddLine ) { | ||
560 | active = activeControl == QStyle::AddLine; | ||
561 | drawBaseButton( p, add.x(), add.y(), add.width(), add.height(), | ||
562 | *colorGroup( g, active ? ScrollButtonDown : ScrollButton ), | ||
563 | active, false, active ? ScrollButtonDown : ScrollButton ); | ||
564 | drawArrow( p, ( horizontal ) ? RightArrow : DownArrow, active, add.x() + 3, | ||
565 | add.y() + 3, add.width() - 6, add.height() - 6, | ||
566 | *colorGroup( g, active ? ScrollButtonDown : ScrollButton ) ); | ||
567 | } | ||
568 | if ( controls & QStyle::SubLine ) { | ||
569 | active = activeControl == QStyle::SubLine; | ||
570 | p->setPen( g.dark() ); | ||
571 | p->drawRect( sub ); | ||
572 | drawBaseButton( p, sub.x(), sub.y(), sub.width(), sub.height(), | ||
573 | *colorGroup( g, active ? ScrollButtonDown : ScrollButton ), | ||
574 | active, false, active ? ScrollButtonDown : ScrollButton ); | ||
575 | drawArrow( p, ( horizontal ) ? LeftArrow : UpArrow, active, sub.x() + 3, | ||
576 | sub.y() + 3, sub.width() - 6, sub.height() - 6, | ||
577 | *colorGroup( g, active ? ScrollButtonDown : ScrollButton ) ); | ||
578 | } | ||
579 | if ( controls & QStyle::Slider ) { | ||
580 | active = activeControl == QStyle::Slider; | ||
581 | WidgetType widget = horizontal ? | ||
582 | active ? HScrollBarSliderDown : HScrollBarSlider : | ||
583 | active ? VScrollBarSliderDown : VScrollBarSlider; | ||
584 | |||
585 | drawBaseButton( p, slider.x(), slider.y(), slider.width(), | ||
586 | slider.height(), *colorGroup( g, widget ), active, false, | ||
587 | widget ); | ||
588 | int spaceW = horizontal ? slider.width() - decoWidth( widget ) - 4 : | ||
589 | slider.width(); | ||
590 | int spaceH = horizontal ? slider.height() : | ||
591 | slider.height() - decoWidth( widget ) - 4; | ||
592 | widget = active ? horizontal ? HScrollDecoDown : VScrollDecoDown : | ||
593 | horizontal ? HScrollDeco : VScrollDeco; | ||
594 | if ( isPixmap( widget ) ) { | ||
595 | if ( spaceW >= uncached( widget ) ->width() && | ||
596 | spaceH >= uncached( widget ) ->height() ) { | ||
597 | p->drawPixmap( slider.x() + ( slider.width() - | ||
598 | uncached( widget ) ->width() ) / 2, | ||
599 | slider.y() + ( slider.height() - | ||
600 | uncached( widget ) ->height() ) / 2, | ||
601 | *uncached( widget ) ); | ||
602 | } | ||
603 | } | ||
604 | } | ||
605 | } | ||
606 | |||
607 | void OThemeStyle::drawScrollBarGroove( QPainter *p, const QScrollBar *sb, | ||
608 | bool horizontal, QRect r, QColorGroup g ) | ||
609 | |||
610 | { | ||
611 | WidgetType widget = ( horizontal ) ? HScrollGroove : VScrollGroove; | ||
612 | if ( !isPixmap( widget ) ) { | ||
613 | p->fillRect( r, colorGroup( g, widget ) ->brush( QColorGroup::Background ) ); | ||
614 | } | ||
615 | else { | ||
616 | // If the groove is pixmapped we make a full-sized image (it gets | ||
617 | // cached) then bitBlt it to the appropriate rect. | ||
618 | QPixmap buffer( sb->size() ); | ||
619 | QPainter bPainter( &buffer ); | ||
620 | bPainter.drawTiledPixmap( 0, 0, buffer.width(), buffer.height(), | ||
621 | *scalePixmap( buffer.width(), buffer.height(), | ||
622 | widget ) ); | ||
623 | bitBlt( p->device(), r.x(), r.y(), &buffer, r.x(), r.y(), r.width(), | ||
624 | r.height(), Qt::CopyROP ); | ||
625 | } | ||
626 | // Do the borders and frame | ||
627 | drawShade( p, sb->rect().x(), sb->rect().y(), sb->rect().width(), | ||
628 | sb->rect().height(), *colorGroup( g, widget ), true, false, | ||
629 | highlightWidth( widget ), borderWidth( widget ), shade() ); | ||
630 | } | ||
631 | |||
632 | void OThemeStyle::scrollBarMetrics( const QScrollBar *sb, int &sliderMin, | ||
633 | int &sliderMax, int &sliderLength, | ||
634 | int &buttonDim ) | ||
635 | { | ||
636 | bool horizontal = sb->orientation() == QScrollBar::Horizontal; | ||
637 | int offset = decoWidth( horizontal ? HScrollGroove : VScrollGroove ); | ||
638 | int maxlen; | ||
639 | int len = horizontal ? sb->width() : sb->height(); | ||
640 | int extent = horizontal ? sb->height() : sb->width(); | ||
641 | |||
642 | if ( len > ( extent - offset * 2 - 1 ) * 2 + offset * 2 ) | ||
643 | buttonDim = extent - offset * 2; | ||
644 | else | ||
645 | buttonDim = ( len - offset * 2 ) / 2 - 1; | ||
646 | maxlen = len - offset * 2 - buttonDim * 2 - 1; | ||
647 | |||
648 | switch ( scrollBarLayout() ) { | ||
649 | case SBBottomLeft: | ||
650 | sliderMin = ( horizontal ) ? buttonDim * 2 + offset + 1 : offset + 1; | ||
651 | break; | ||
652 | case SBBottomRight: | ||
653 | sliderMin = offset + 1; | ||
654 | break; | ||
655 | case SBOpposite: | ||
656 | default: | ||
657 | sliderMin = offset + buttonDim; | ||
658 | break; | ||
659 | } | ||
660 | if ( sb->maxValue() == sb->minValue() ) | ||
661 | sliderLength = maxlen; | ||
662 | else | ||
663 | sliderLength = ( sb->pageStep() * maxlen ) / ( sb->maxValue() - | ||
664 | sb->minValue() + sb->pageStep() ); | ||
665 | if ( sliderLength < 12 || ( sb->maxValue() - sb->minValue() ) > INT_MAX / 2 ) | ||
666 | sliderLength = 12; | ||
667 | if ( sliderLength > maxlen ) | ||
668 | sliderLength = maxlen; | ||
669 | sliderMax = sliderMin + maxlen - sliderLength; | ||
670 | } | ||
671 | |||
672 | QStyle::ScrollControl OThemeStyle::scrollBarPointOver( const QScrollBar *sb, | ||
673 | int sliderStart, | ||
674 | const QPoint &p ) | ||
675 | { | ||
676 | if ( !sb->rect().contains( p ) ) | ||
677 | return ( QStyle::NoScroll ); | ||
678 | int sliderMin, sliderMax, sliderLength, buttonDim; | ||
679 | int pos = ( sb->orientation() == QScrollBar::Horizontal ) ? p.x() : p.y(); | ||
680 | scrollBarMetrics( sb, sliderMin, sliderMax, sliderLength, buttonDim ); | ||
681 | |||
682 | if ( scrollBarLayout() == SBOpposite ) { | ||
683 | if ( pos < sliderMin ) | ||
684 | return QStyle::SubLine; | ||
685 | if ( pos < sliderStart ) | ||
686 | return SubPage; | ||
687 | if ( pos < sliderStart + sliderLength ) | ||
688 | return QStyle::Slider; | ||
689 | if ( pos < sliderMax + sliderLength ) | ||
690 | return QStyle::AddPage; | ||
691 | return QStyle::AddLine; | ||
692 | } | ||
693 | if ( scrollBarLayout() == SBBottomLeft && sb->orientation() == | ||
694 | QScrollBar::Horizontal ) { | ||
695 | if ( pos <= buttonDim ) | ||
696 | return ( QStyle::SubLine ); | ||
697 | else if ( pos <= buttonDim * 2 ) | ||
698 | return ( QStyle::AddLine ); | ||
699 | else if ( pos < sliderStart ) | ||
700 | return ( QStyle::SubPage ); | ||
701 | else if ( pos < sliderStart + sliderLength ) | ||
702 | return ( QStyle::Slider ); | ||
703 | return ( AddPage ); | ||
704 | } | ||
705 | else { | ||
706 | if ( pos < sliderStart ) | ||
707 | return QStyle::SubPage; | ||
708 | if ( pos < sliderStart + sliderLength ) | ||
709 | return QStyle::Slider; | ||
710 | if ( pos < sliderMax + sliderLength ) | ||
711 | return QStyle::AddPage; | ||
712 | if ( pos < sliderMax + sliderLength + buttonDim ) | ||
713 | return QStyle::SubLine; | ||
714 | return QStyle::AddLine; | ||
715 | } | ||
716 | } | ||
717 | |||
718 | QSize OThemeStyle::exclusiveIndicatorSize() const | ||
719 | { | ||
720 | if ( isPixmap( ExIndicatorOn ) ) | ||
721 | return ( uncached( ExIndicatorOn ) ->size() ); | ||
722 | else | ||
723 | return ( QWindowsStyle::exclusiveIndicatorSize() ); | ||
724 | } | ||
725 | |||
726 | QSize OThemeStyle::indicatorSize() const | ||
727 | { | ||
728 | if ( isPixmap( IndicatorOn ) ) | ||
729 | return ( uncached( IndicatorOn ) ->size() ); | ||
730 | else | ||
731 | return ( QWindowsStyle::indicatorSize() ); | ||
732 | } | ||
733 | |||
734 | void OThemeStyle::drawExclusiveIndicator( QPainter* p, int x, int y, int w, | ||
735 | int h, const QColorGroup &g, bool on, | ||
736 | bool down, bool enabled ) | ||
737 | { | ||
738 | if ( isPixmap( ( on || down ) ? ExIndicatorOn : ExIndicatorOff ) ) { | ||
739 | p->drawPixmap( x, y, *uncached( ( on || down ) ? ExIndicatorOn : | ||
740 | ExIndicatorOff ) ); | ||
741 | } | ||
742 | else { | ||
743 | QWindowsStyle::drawExclusiveIndicator( p, x, y, w, h, | ||
744 | *colorGroup( g, ExIndicatorOn ), | ||
745 | on, down, enabled ); | ||
746 | } | ||
747 | |||
748 | } | ||
749 | |||
750 | void OThemeStyle::drawIndicator( QPainter* p, int x, int y, int w, int h, | ||
751 | const QColorGroup &g, int state, bool down, | ||
752 | bool enabled ) | ||
753 | { | ||
754 | if ( isPixmap( ( down || state != QButton::Off ) ? | ||
755 | IndicatorOn : IndicatorOff ) ) { | ||
756 | p->drawPixmap( x, y, *uncached( ( down || state != QButton::Off ) ? | ||
757 | IndicatorOn : IndicatorOff ) ); | ||
758 | } | ||
759 | else { | ||
760 | QWindowsStyle::drawIndicator( p, x, y, w, h, | ||
761 | *colorGroup( g, IndicatorOn ), state, | ||
762 | down, enabled ); | ||
763 | } | ||
764 | } | ||
765 | |||
766 | void OThemeStyle::drawExclusiveIndicatorMask( QPainter *p, int x, int y, int w, | ||
767 | int h, bool on ) | ||
768 | { | ||
769 | if ( isPixmap( ( on ) ? ExIndicatorOn : ExIndicatorOff ) ) { | ||
770 | const QBitmap * mask = uncached( ( on ) ? ExIndicatorOn : ExIndicatorOff ) -> | ||
771 | mask(); | ||
772 | if ( mask ) { | ||
773 | p->drawPixmap( x, y, *mask ); | ||
774 | } | ||
775 | else | ||
776 | p->fillRect( x, y, w, h, QBrush( color1, SolidPattern ) ); | ||
777 | } | ||
778 | else | ||
779 | QWindowsStyle::drawExclusiveIndicatorMask( p, x, y, w, h, on ); | ||
780 | } | ||
781 | |||
782 | void OThemeStyle::drawIndicatorMask( QPainter *p, int x, int y, int w, int h, | ||
783 | int state ) | ||
784 | { | ||
785 | if ( isPixmap( ( state != QButton::Off ) ? IndicatorOn : IndicatorOff ) ) { | ||
786 | const QBitmap * mask = uncached( ( state != QButton::Off ) ? IndicatorOn : | ||
787 | IndicatorOff ) ->mask(); | ||
788 | if ( mask ) | ||
789 | p->drawPixmap( x, y, *mask ); | ||
790 | else | ||
791 | p->fillRect( x, y, w, h, QBrush( color1, SolidPattern ) ); | ||
792 | } | ||
793 | else | ||
794 | QWindowsStyle::drawIndicatorMask( p, x, y, w, h, state ); | ||
795 | } | ||
796 | |||
797 | void OThemeStyle::drawSliderGroove( QPainter *p, int x, int y, int w, int h, | ||
798 | const QColorGroup& g, QCOORD c, | ||
799 | Orientation orient ) | ||
800 | { | ||
801 | if ( roundSlider() ) | ||
802 | QWindowsStyle::drawSliderGroove( p, x, y, w, h, | ||
803 | *colorGroup( g, SliderGroove ), | ||
804 | c, orient ); | ||
805 | else | ||
806 | drawBaseButton( p, x, y, w, h, *colorGroup( g, SliderGroove ), true, | ||
807 | false, SliderGroove ); | ||
808 | } | ||
809 | |||
810 | void OThemeStyle::drawSlider( QPainter *p, int x, int y, int w, int h, | ||
811 | const QColorGroup &g, Orientation orient, | ||
812 | bool tickAbove, bool tickBelow ) | ||
813 | { | ||
814 | if ( isPixmap( Slider ) ) { | ||
815 | if ( orient == Qt::Horizontal ) | ||
816 | p->drawPixmap( x, y + ( h - uncached( Slider ) ->height() ) / 2, | ||
817 | *uncached( Slider ) ); | ||
818 | else | ||
819 | p->drawPixmap( x + ( w - uncached( Slider ) ->width() ) / 2, | ||
820 | y, *uncached( Slider ) ); | ||
821 | } | ||
822 | else { | ||
823 | QWindowsStyle::drawSlider( p, x, y, w, h, *colorGroup( g, Slider ), | ||
824 | orient, tickAbove, tickBelow ); | ||
825 | } | ||
826 | } | ||
827 | |||
828 | void OThemeStyle::drawSliderMask( QPainter *p, int x, int y, int w, int h, | ||
829 | Orientation orient, bool tickAbove, | ||
830 | bool tickBelow ) | ||
831 | { | ||
832 | // This is odd. If we fill in the entire region it still masks the slider | ||
833 | // properly. I have no idea, this used to be different in Qt betas... | ||
834 | if ( isPixmap( Slider ) ) | ||
835 | p->fillRect( x, y, w, h, QBrush( color1, SolidPattern ) ); | ||
836 | else | ||
837 | QWindowsStyle::drawSliderMask( p, x, y, w, h, orient, tickAbove, | ||
838 | tickBelow ); | ||
839 | } | ||
840 | |||
841 | int OThemeStyle::defaultFrameWidth() const | ||
842 | { | ||
843 | return ( frameWidth() ); | ||
844 | } | ||
845 | |||
846 | void OThemeStyle::getButtonShift( int &x, int &y ) | ||
847 | { | ||
848 | x = buttonXShift(); | ||
849 | y = buttonYShift(); | ||
850 | } | ||
851 | |||
852 | int OThemeStyle::sliderLength() const | ||
853 | { | ||
854 | return ( sliderButtonLength() ); | ||
855 | } | ||
856 | |||
857 | void OThemeStyle::drawArrow( QPainter *p, Qt::ArrowType type, bool down, int x, | ||
858 | int y, int w, int h, const QColorGroup &g, | ||
859 | bool enabled, const QBrush * ) | ||
860 | { | ||
861 | // Handles pixmapped arrows. A little inefficent because you can specify | ||
862 | // some as pixmaps and some as default types. | ||
863 | WidgetType widget; | ||
864 | switch ( type ) { | ||
865 | case UpArrow: | ||
866 | widget = enabled ? down ? SunkenArrowUp : ArrowUp : DisArrowUp; | ||
867 | break; | ||
868 | case DownArrow: | ||
869 | widget = enabled ? down ? SunkenArrowDown : ArrowDown : DisArrowDown; | ||
870 | break; | ||
871 | case LeftArrow: | ||
872 | widget = enabled ? down ? SunkenArrowLeft : ArrowLeft : DisArrowLeft; | ||
873 | break; | ||
874 | case RightArrow: | ||
875 | default: | ||
876 | widget = enabled ? down ? SunkenArrowRight : ArrowRight : DisArrowRight; | ||
877 | break; | ||
878 | } | ||
879 | if ( isPixmap( widget ) ) { | ||
880 | p->drawPixmap( x + ( w - uncached( widget ) ->width() ) / 2, | ||
881 | y + ( h - uncached( widget ) ->height() ) / 2, | ||
882 | *uncached( widget ) ); | ||
883 | return ; | ||
884 | } | ||
885 | const QColorGroup *cg = colorGroup( g, widget ); | ||
886 | // Standard arrow types | ||
887 | if ( arrowType() == MotifArrow ) | ||
888 | qDrawArrow( p, type, Qt::MotifStyle, down, x, y, w, h, *cg, enabled ); | ||
889 | else if ( arrowType() == SmallArrow ) { | ||
890 | QColorGroup tmp( *cg ); | ||
891 | tmp.setBrush( QColorGroup::Button, QBrush( NoBrush ) ); | ||
892 | QWindowsStyle::drawArrow( p, type, false, x, y, w, h, | ||
893 | tmp, true ); | ||
894 | } | ||
895 | else { | ||
896 | QPointArray a; | ||
897 | int x2 = x + w - 1, y2 = y + h - 1; | ||
898 | switch ( type ) { | ||
899 | case Qt::UpArrow: | ||
900 | a.setPoints( 4, x, y2, x2, y2, x + w / 2, y, x, y2 ); | ||
901 | break; | ||
902 | case Qt::DownArrow: | ||
903 | a.setPoints( 4, x, y, x2, y, x + w / 2, y2, x, y ); | ||
904 | break; | ||
905 | case Qt::LeftArrow: | ||
906 | a.setPoints( 4, x2, y, x2, y2, x, y + h / 2, x2, y ); | ||
907 | break; | ||
908 | default: | ||
909 | a.setPoints( 4, x, y, x, y2, x2, y + h / 2, x, y ); | ||
910 | break; | ||
911 | } | ||
912 | QBrush oldBrush = p->brush(); | ||
913 | QPen oldPen = p->pen(); | ||
914 | p->setBrush( cg->brush( QColorGroup::Shadow ) ); | ||
915 | p->setPen( cg->shadow() ); | ||
916 | p->drawPolygon( a ); | ||
917 | p->setBrush( oldBrush ); | ||
918 | p->setPen( oldPen ); | ||
919 | } | ||
920 | } | ||
921 | |||
922 | /* This is where we draw the borders and highlights. The new round button | ||
923 | * code is a pain in the arse. We don't want to be calculating arcs so | ||
924 | * use a whole lotta QPointArray's ;-) The code is made a lot more complex | ||
925 | * because you can have variable width border and highlights... | ||
926 | * I may want to cache this if round buttons are used, but am concerned | ||
927 | * about excessive cache misses. This is a memory/speed tradeoff that I | ||
928 | * have to test. | ||
929 | */ | ||
930 | void OThemeStyle::drawShade( QPainter *p, int x, int y, int w, int h, | ||
931 | const QColorGroup &g, bool sunken, bool rounded, | ||
932 | int hWidth, int bWidth, ShadeStyle style ) | ||
933 | { | ||
934 | int i, sc, bc, x2, y2; | ||
935 | QPen highPen, lowPen; | ||
936 | |||
937 | if ( style == Motif ) { | ||
938 | highPen.setColor( sunken ? g.dark() : g.light() ); | ||
939 | lowPen.setColor( sunken ? g.light() : g.dark() ); | ||
940 | } | ||
941 | else { | ||
942 | highPen.setColor( sunken ? g.shadow() : g.light() ); | ||
943 | lowPen.setColor( sunken ? g.light() : g.shadow() ); | ||
944 | } | ||
945 | |||
946 | // Advanced round buttons | ||
947 | if ( rounded && w > 19 && h > 19 ) { | ||
948 | x2 = x + w - 1, y2 = y + h - 1; | ||
949 | QPointArray bPntArray, hPntArray, lPntArray; | ||
950 | QPointArray bLineArray, hLineArray, lLineArray; | ||
951 | // borders | ||
952 | for ( i = 0, bc = 0; i < bWidth; ++i ) { | ||
953 | bPntArray.putPoints( bc, 24, x + 4, y + 1, x + 5, y + 1, x + 3, y + 2, x + 2, y + 3, | ||
954 | x + 1, y + 4, x + 1, y + 5, x + 1, y2 - 5, x + 1, y2 - 4, x + 2, y2 - 3, | ||
955 | x2 - 5, y + 1, x2 - 4, y + 1, x2 - 3, y + 2, x2 - 5, y2 - 1, | ||
956 | x2 - 4, y2 - 1, x2 - 3, y2 - 2, x2 - 2, y2 - 3, x2 - 1, y2 - 5, | ||
957 | x2 - 1, y2 - 4, x + 3, y2 - 2, x + 4, y2 - 1, x + 5, y2 - 1, | ||
958 | x2 - 2, y + 3, x2 - 1, y + 4, x2 - 1, y + 5 ); | ||
959 | bc += 24; | ||
960 | // ellispe edges don't match exactly, so fill in blanks | ||
961 | if ( i < bWidth - 1 || hWidth != 0 ) { | ||
962 | bPntArray.putPoints( bc, 20, x + 6, y + 1, x + 4, y + 2, x + 3, y + 3, | ||
963 | x + 2, y + 4, x + 1, y + 6, x2 - 6, y + 1, x2 - 4, y + 2, | ||
964 | x2 - 3, y + 3, x + 2, y2 - 4, x + 1, y2 - 6, x2 - 6, y2 - 1, | ||
965 | x2 - 4, y2 - 2, x2 - 3, y2 - 3, x2 - 2, y2 - 4, x2 - 1, y2 - 6, | ||
966 | x + 6, y2 - 1, x + 4, y2 - 2, x + 3, y2 - 3, x2 - 1, y + 6, | ||
967 | x2 - 2, y + 4 ); | ||
968 | bc += 20; | ||
969 | } | ||
970 | bLineArray.putPoints( i * 8, 8, x + 6, y, x2 - 6, y, x, y + 6, x, y2 - 6, | ||
971 | x + 6, y2, x2 - 6, y2, x2, y + 6, x2, y2 - 6 ); | ||
972 | ++x, ++y; | ||
973 | --x2, --y2; | ||
974 | } | ||
975 | // highlights | ||
976 | for ( i = 0, sc = 0; i < hWidth; ++i ) { | ||
977 | hPntArray.putPoints( sc, 12, x + 4, y + 1, x + 5, y + 1, // top left | ||
978 | x + 3, y + 2, x + 2, y + 3, x + 1, y + 4, x + 1, y + 5, | ||
979 | x + 1, y2 - 5, x + 1, y2 - 4, x + 2, y2 - 3, // half corners | ||
980 | x2 - 5, y + 1, x2 - 4, y + 1, x2 - 3, y + 2 ); | ||
981 | lPntArray.putPoints( sc, 12, x2 - 5, y2 - 1, x2 - 4, y2 - 1, // btm right | ||
982 | x2 - 3, y2 - 2, x2 - 2, y2 - 3, x2 - 1, y2 - 5, x2 - 1, y2 - 4, | ||
983 | x + 3, y2 - 2, x + 4, y2 - 1, x + 5, y2 - 1, //half corners | ||
984 | x2 - 2, y + 3, x2 - 1, y + 4, x2 - 1, y + 5 ); | ||
985 | sc += 12; | ||
986 | if ( i < hWidth - 1 ) { | ||
987 | hPntArray.putPoints( sc, 10, x + 6, y + 1, x + 4, y + 2, // top left | ||
988 | x + 3, y + 3, x + 2, y + 4, x + 1, y + 6, | ||
989 | x2 - 6, y + 1, x2 - 4, y + 2, // half corners | ||
990 | x2 - 3, y + 3, x + 2, y2 - 4, x + 1, y2 - 6 ); | ||
991 | lPntArray.putPoints( sc, 10, x2 - 6, y2 - 1, x2 - 4, y2 - 2, // btm right | ||
992 | x2 - 3, y2 - 3, x2 - 2, y2 - 4, x2 - 1, y2 - 6, | ||
993 | x + 6, y2 - 1, x + 4, y2 - 2, // half corners | ||
994 | x + 3, y2 - 3, x2 - 1, y + 6, x2 - 2, y + 4 ); | ||
995 | sc += 10; | ||
996 | } | ||
997 | hLineArray.putPoints( i * 4, 4, x + 6, y, x2 - 6, y, x, y + 6, x, y2 - 6 ); | ||
998 | lLineArray.putPoints( i * 4, 4, x + 6, y2, x2 - 6, y2, x2, y + 6, x2, y2 - 6 ); | ||
999 | ++x, ++y; | ||
1000 | --x2, --y2; | ||
1001 | } | ||
1002 | p->setPen( Qt::black ); | ||
1003 | p->drawPoints( bPntArray ); | ||
1004 | p->drawLineSegments( bLineArray ); | ||
1005 | p->setPen( highPen ); | ||
1006 | p->drawPoints( hPntArray ); | ||
1007 | p->drawLineSegments( hLineArray ); | ||
1008 | p->setPen( lowPen ); | ||
1009 | p->drawPoints( lPntArray ); | ||
1010 | p->drawLineSegments( lLineArray ); | ||
1011 | } | ||
1012 | // Rectangular buttons | ||
1013 | else { | ||
1014 | QPointArray highShade( hWidth * 4 ); | ||
1015 | QPointArray lowShade( hWidth * 4 ); | ||
1016 | |||
1017 | p->setPen( g.shadow() ); | ||
1018 | for ( i = 0; i < bWidth && w > 2 && h > 2; ++i, ++x, ++y, w -= 2, h -= 2 ) | ||
1019 | p->drawRect( x, y , w, h ); | ||
1020 | |||
1021 | if ( !hWidth ) | ||
1022 | return ; | ||
1023 | |||
1024 | x2 = x + w - 1, y2 = y + h - 1; | ||
1025 | for ( i = 0; i < hWidth; ++i, ++x, ++y, --x2, --y2 ) { | ||
1026 | highShade.putPoints( i * 4, 4, x, y, x2, y, x, y, x, y2 ); | ||
1027 | lowShade.putPoints( i * 4, 4, x, y2, x2, y2, x2, y, x2, y2 ); | ||
1028 | } | ||
1029 | if ( style == Windows && hWidth > 1 ) { | ||
1030 | p->setPen( highPen ); | ||
1031 | p->drawLineSegments( highShade, 0, 2 ); | ||
1032 | p->setPen( lowPen ); | ||
1033 | p->drawLineSegments( lowShade, 0, 2 ); | ||
1034 | |||
1035 | p->setPen( ( sunken ) ? g.dark() : g.mid() ); | ||
1036 | p->drawLineSegments( highShade, 4 ); | ||
1037 | p->setPen( ( sunken ) ? g.mid() : g.dark() ); | ||
1038 | p->drawLineSegments( lowShade, 4 ); | ||
1039 | } | ||
1040 | else { | ||
1041 | p->setPen( ( sunken ) ? g.dark() : g.light() ); | ||
1042 | p->drawLineSegments( highShade ); | ||
1043 | p->setPen( ( sunken ) ? g.light() : g.dark() ); | ||
1044 | p->drawLineSegments( lowShade ); | ||
1045 | } | ||
1046 | } | ||
1047 | } | ||
1048 | |||
1049 | void OThemeStyle::drawPushButtonLabel( QPushButton *btn, QPainter *p ) | ||
1050 | { | ||
1051 | WidgetType widget = btn->isDown() || btn->isOn() ? PushButtonDown : | ||
1052 | PushButton; | ||
1053 | const QColorGroup *cg = colorGroup( btn->colorGroup(), widget ); | ||
1054 | int x, y, w, h; | ||
1055 | |||
1056 | QRect r = btn->rect(); | ||
1057 | r.rect( &x, &y, &w, &h ); | ||
1058 | x += decoWidth( widget ); | ||
1059 | y += decoWidth( widget ); | ||
1060 | w -= decoWidth( widget ) * 2; | ||
1061 | h -= decoWidth( widget ) * 2; | ||
1062 | bool act = btn->isOn() || btn->isDown(); | ||
1063 | |||
1064 | // If this is a button with an associated popup menu, draw an arrow first | ||
1065 | if ( btn->popup() ) { | ||
1066 | int dx = menuButtonIndicatorWidth( btn->height() ); | ||
1067 | |||
1068 | QColorGroup g( btn->colorGroup() ); | ||
1069 | int xx = x + w - dx - 4; | ||
1070 | int yy = y - 3; | ||
1071 | int hh = h + 6; | ||
1072 | |||
1073 | if ( !act ) { | ||
1074 | p->setPen( g.light() ); | ||
1075 | p->drawLine( xx, yy + 3, xx, yy + hh - 4 ); | ||
1076 | } | ||
1077 | else { | ||
1078 | p->setPen( g.button() ); | ||
1079 | p->drawLine( xx, yy + 4, xx, yy + hh - 4 ); | ||
1080 | } | ||
1081 | drawArrow( p, DownArrow, FALSE, | ||
1082 | x + w - dx - 2, y + 2, dx, h - 4, | ||
1083 | btn->colorGroup(), | ||
1084 | btn->isEnabled() ); | ||
1085 | w -= dx; | ||
1086 | } | ||
1087 | |||
1088 | // Next, draw iconset, if any | ||
1089 | if ( btn->iconSet() && !btn->iconSet() ->isNull() ) { | ||
1090 | QIconSet::Mode mode = btn->isEnabled() | ||
1091 | ? QIconSet::Normal : QIconSet::Disabled; | ||
1092 | if ( mode == QIconSet::Normal && btn->hasFocus() ) | ||
1093 | mode = QIconSet::Active; | ||
1094 | QPixmap pixmap = btn->iconSet() ->pixmap( QIconSet::Small, mode ); | ||
1095 | int pixw = pixmap.width(); | ||
1096 | int pixh = pixmap.height(); | ||
1097 | |||
1098 | p->drawPixmap( x + 6, y + h / 2 - pixh / 2, pixmap ); | ||
1099 | x += pixw + 8; | ||
1100 | w -= pixw + 8; | ||
1101 | } | ||
1102 | |||
1103 | if ( widget == PushButtonDown ) { | ||
1104 | drawItem( p, x + buttonXShift(), y + buttonYShift(), | ||
1105 | w, h, AlignCenter | ShowPrefix, *cg, btn->isEnabled(), | ||
1106 | btn->pixmap(), btn->text(), -1, &cg->buttonText() ); | ||
1107 | } | ||
1108 | else { | ||
1109 | drawItem( p, x, y, w, h, AlignCenter | ShowPrefix, *cg, | ||
1110 | btn->isEnabled(), btn->pixmap(), btn->text(), -1, | ||
1111 | &cg->buttonText() ); | ||
1112 | } | ||
1113 | } | ||
1114 | |||
1115 | int OThemeStyle::splitterWidth() const | ||
1116 | { | ||
1117 | return ( splitWidth() ); | ||
1118 | } | ||
1119 | |||
1120 | void OThemeStyle::drawSplitter( QPainter *p, int x, int y, int w, int h, | ||
1121 | const QColorGroup &g, Orientation ) | ||
1122 | { | ||
1123 | drawBaseButton( p, x, y, w, h, *colorGroup( g, Splitter ), false, false, | ||
1124 | Splitter ); | ||
1125 | } | ||
1126 | |||
1127 | void OThemeStyle::drawCheckMark( QPainter *p, int x, int y, int w, int h, | ||
1128 | const QColorGroup &g, bool act, bool dis ) | ||
1129 | { | ||
1130 | if ( isPixmap( CheckMark ) ) { | ||
1131 | if ( !dis ) | ||
1132 | p->drawPixmap( x + ( w - uncached( CheckMark ) ->width() ) / 2, | ||
1133 | y + ( h - uncached( CheckMark ) ->height() ) / 2, | ||
1134 | *uncached( CheckMark ) ); | ||
1135 | } | ||
1136 | else | ||
1137 | QWindowsStyle::drawCheckMark( p, x, y, w, h, *colorGroup( g, CheckMark ), | ||
1138 | act, dis ); | ||
1139 | } | ||
1140 | |||
1141 | int OThemeStyle::popupMenuItemHeight( bool /*checkable*/, QMenuItem *mi, | ||
1142 | const QFontMetrics &fm ) | ||
1143 | { | ||
1144 | int h2, h = 0; | ||
1145 | int offset = QMAX( decoWidth( MenuItemDown ), decoWidth( MenuItem ) ) + 4; | ||
1146 | |||
1147 | if ( mi->isSeparator() ) | ||
1148 | return ( 2 ); | ||
1149 | if ( mi->isChecked() ) | ||
1150 | h = isPixmap( CheckMark ) ? uncached( CheckMark ) ->height() + offset : | ||
1151 | offset + 16; | ||
1152 | if ( mi->pixmap() ) { | ||
1153 | h2 = mi->pixmap() ->height() + offset; | ||
1154 | h = h2 > h ? h2 : h; | ||
1155 | } | ||
1156 | if ( mi->iconSet() ) { | ||
1157 | h2 = mi->iconSet() -> | ||
1158 | pixmap( QIconSet::Small, QIconSet::Normal ).height() + offset; | ||
1159 | h = h2 > h ? h2 : h; | ||
1160 | } | ||
1161 | h2 = fm.height() + offset; | ||
1162 | h = h2 > h ? h2 : h; | ||
1163 | return ( h ); | ||
1164 | } | ||
1165 | |||
1166 | void OThemeStyle::drawPopupMenuItem( QPainter* p, bool checkable, int maxpmw, | ||
1167 | int tab, QMenuItem* mi, | ||
1168 | const QPalette& pal, bool act, | ||
1169 | bool enabled, int x, int y, int w, int h ) | ||
1170 | { | ||
1171 | // I changed the following method to be based from Qt's instead of my own | ||
1172 | // wacky code. Works much better now :P (mosfet) | ||
1173 | static const int motifItemFrame = 2; // menu item frame width | ||
1174 | static const int motifItemHMargin = 5; // menu item hor text margin | ||
1175 | static const int motifItemVMargin = 4; // menu item ver text margin | ||
1176 | |||
1177 | static const int motifArrowHMargin = 6; // arrow horizontal margin | ||
1178 | static const int windowsRightBorder = 12; // right border on windowsstatic const int windowsCheckMarkWidth = 12; // checkmarks width on windows | ||
1179 | bool dis = !enabled; | ||
1180 | const QColorGroup &g = dis ? *colorGroup( pal.normal(), MenuItem ) : | ||
1181 | *colorGroup( pal.normal(), MenuItemDown ); | ||
1182 | |||
1183 | QColorGroup itemg = dis ? *colorGroup( pal.disabled(), MenuItem ) | ||
1184 | : act ? *colorGroup( pal.active(), MenuItemDown ) | ||
1185 | : *colorGroup( pal.normal(), MenuItem ); | ||
1186 | |||
1187 | maxpmw = QMAX( maxpmw, 20 ); | ||
1188 | int checkcol = maxpmw; | ||
1189 | |||
1190 | if ( mi && mi->isSeparator() ) { | ||
1191 | p->setPen( g.dark() ); | ||
1192 | p->drawLine( x, y, x + w, y ); | ||
1193 | p->setPen( g.light() ); | ||
1194 | p->drawLine( x, y + 1, x + w, y + 1 ); | ||
1195 | return ; | ||
1196 | } | ||
1197 | if ( act ) { | ||
1198 | drawBaseButton( p, x, y, w, h, g, true, false, MenuItemDown ); | ||
1199 | } | ||
1200 | else { | ||
1201 | drawShade( p, x, y, w, h, *colorGroup( g, MenuItem ), false, false, | ||
1202 | highlightWidth( MenuItem ), borderWidth( MenuItem ), | ||
1203 | shade() ); | ||
1204 | int dw = decoWidth( MenuItem ); | ||
1205 | if ( !isPixmap( MenuItem ) ) | ||
1206 | p->fillRect( x + dw, y + dw, w - dw * 2, h - dw * 2, | ||
1207 | colorGroup( g, MenuItem ) -> | ||
1208 | brush( QColorGroup::Background ) ); | ||
1209 | else { | ||
1210 | // process inactive item pixmaps as one large item | ||
1211 | p->drawTiledPixmap( x + dw, y + dw, w - dw * 2, h - dw * 2, *scalePixmap | ||
1212 | // (w, p->window().height(), MenuItem), | ||
1213 | ( w, p->clipRegion().boundingRect().height(), MenuItem ), | ||
1214 | x, y ); | ||
1215 | } | ||
1216 | |||
1217 | if ( checkable && mi && mi->isChecked() ) { | ||
1218 | // draw 'pressed' border around checkable items | ||
1219 | // This is extremely important for items that have an iconset | ||
1220 | // because the checkmark isn't drawn in that case | ||
1221 | // An alternative would be superimposing the checkmark over | ||
1222 | // the iconset instead or not drawing the iconset at all. | ||
1223 | int mw = checkcol + motifItemFrame; | ||
1224 | drawShade( p, x, y, mw, h, g, true, false, | ||
1225 | highlightWidth( MenuItemDown ), | ||
1226 | borderWidth( MenuItemDown ), shade() ); | ||
1227 | } | ||
1228 | } | ||
1229 | if ( !mi ) | ||
1230 | return ; | ||
1231 | if ( mi->iconSet() ) { | ||
1232 | QIconSet::Mode mode = dis ? QIconSet::Disabled : QIconSet::Normal; | ||
1233 | if ( act && !dis ) | ||
1234 | mode = QIconSet::Active; | ||
1235 | QPixmap pixmap = mi->iconSet() ->pixmap( QIconSet::Small, mode ); | ||
1236 | int pixw = pixmap.width(); | ||
1237 | int pixh = pixmap.height(); | ||
1238 | QRect cr( x, y, checkcol, h ); | ||
1239 | QRect pmr( 0, 0, pixw, pixh ); | ||
1240 | pmr.moveCenter( cr.center() ); | ||
1241 | p->setPen( itemg.text() ); | ||
1242 | p->drawPixmap( pmr.topLeft(), pixmap ); | ||
1243 | |||
1244 | } | ||
1245 | else if ( checkable ) { | ||
1246 | int mw = checkcol + motifItemFrame; | ||
1247 | int mh = h - 2 * motifItemFrame; | ||
1248 | if ( mi->isChecked() ) { | ||
1249 | drawCheckMark( p, x + motifItemFrame, | ||
1250 | y + motifItemFrame, mw, mh, itemg, act, dis ); | ||
1251 | } | ||
1252 | } | ||
1253 | |||
1254 | p->setPen( colorGroup( g, act ? MenuItemDown : MenuItem ) ->text() ); | ||
1255 | |||
1256 | QColor discol; | ||
1257 | if ( dis ) { | ||
1258 | discol = itemg.text(); | ||
1259 | p->setPen( discol ); | ||
1260 | } | ||
1261 | |||
1262 | int xm = motifItemFrame + checkcol + motifItemHMargin; | ||
1263 | |||
1264 | QString s = mi->text(); | ||
1265 | if ( !s.isNull() ) { | ||
1266 | int t = s.find( '\t' ); | ||
1267 | int m = motifItemVMargin; | ||
1268 | const int text_flags = AlignVCenter | ShowPrefix | DontClip | SingleLine; | ||
1269 | if ( t >= 0 ) { | ||
1270 | if ( dis && !act ) { | ||
1271 | p->setPen( g.light() ); | ||
1272 | p->drawText( x + w - tab - windowsRightBorder - motifItemHMargin - motifItemFrame + 1, | ||
1273 | y + m + 1, tab, h - 2 * m, text_flags, s.mid( t + 1 ) ); | ||
1274 | p->setPen( discol ); | ||
1275 | } | ||
1276 | p->drawText( x + w - tab - windowsRightBorder - motifItemHMargin - motifItemFrame, | ||
1277 | y + m, tab, h - 2 * m, text_flags, s.mid( t + 1 ) ); | ||
1278 | } | ||
1279 | if ( dis && !act ) { | ||
1280 | p->setPen( g.light() ); | ||
1281 | p->drawText( x + xm + 1, y + m + 1, w - xm + 1, h - 2 * m, text_flags, s, t ); | ||
1282 | p->setPen( discol ); | ||
1283 | } | ||
1284 | p->drawText( x + xm, y + m, w - xm - tab + 1, h - 2 * m, text_flags, s, t ); | ||
1285 | } | ||
1286 | else if ( mi->pixmap() ) { | ||
1287 | QPixmap * pixmap = mi->pixmap(); | ||
1288 | if ( pixmap->depth() == 1 ) | ||
1289 | p->setBackgroundMode( OpaqueMode ); | ||
1290 | p->drawPixmap( x + xm, y + motifItemFrame, *pixmap ); | ||
1291 | if ( pixmap->depth() == 1 ) | ||
1292 | p->setBackgroundMode( TransparentMode ); | ||
1293 | } | ||
1294 | if ( mi->popup() ) { | ||
1295 | int dim = ( h - 2 * motifItemFrame ) / 2; | ||
1296 | if ( act ) { | ||
1297 | if ( !dis ) | ||
1298 | discol = colorGroup( g, MenuItemDown ) ->text(); | ||
1299 | //discol = white; | ||
1300 | QColorGroup g2( discol, g.highlight(), | ||
1301 | white, white, | ||
1302 | dis ? discol : white, | ||
1303 | discol, white ); | ||
1304 | drawArrow( p, RightArrow, true, | ||
1305 | x + w - motifArrowHMargin - motifItemFrame - dim, y + h / 2 - dim / 2, | ||
1306 | dim, dim, g2, TRUE ); | ||
1307 | } | ||
1308 | else { | ||
1309 | drawArrow( p, RightArrow, | ||
1310 | false, | ||
1311 | x + w - motifArrowHMargin - motifItemFrame - dim, y + h / 2 - dim / 2, | ||
1312 | dim, dim, g, mi->isEnabled() ); | ||
1313 | } | ||
1314 | } | ||
1315 | } | ||
1316 | |||
1317 | void OThemeStyle::drawFocusRect( QPainter *p, const QRect &r, | ||
1318 | const QColorGroup &g, const QColor *c, | ||
1319 | bool atBorder ) | ||
1320 | { | ||
1321 | p->setPen( g.dark() ); | ||
1322 | if ( !is3DFocus() ) | ||
1323 | QWindowsStyle::drawFocusRect( p, r, g, c, atBorder ); | ||
1324 | else { | ||
1325 | int i = focusOffset(); | ||
1326 | p->drawLine( r.x() + i, r.y() + 1 + i, r.x() + i, r.bottom() - 1 - i ); | ||
1327 | p->drawLine( r.x() + 1 + i, r.y() + i, r.right() - 1 - i, r.y() + i ); | ||
1328 | p->setPen( g.light() ); | ||
1329 | p->drawLine( r.right() - i, r.y() + 1 + i, r.right() - i, r.bottom() - 1 - i ); | ||
1330 | p->drawLine( r.x() + 1 + i, r.bottom() - i, r.right() - 1 - i, r.bottom() - i ); | ||
1331 | } | ||
1332 | } | ||
1333 | |||
1334 | #if 0 | ||
1335 | void OThemeStyle::drawKMenuBar( QPainter *p, int x, int y, int w, int h, | ||
1336 | const QColorGroup &g, bool, QBrush * ) | ||
1337 | { | ||
1338 | drawBaseButton( p, x, y, w, h, *colorGroup( g, MenuBar ), false, false, | ||
1339 | MenuBar ); | ||
1340 | } | ||
1341 | |||
1342 | void OThemeStyle::drawKMenuItem( QPainter *p, int x, int y, int w, int h, | ||
1343 | const QColorGroup &g, bool active, | ||
1344 | QMenuItem *mi, QBrush * ) | ||
1345 | { | ||
1346 | const QColorGroup * cg = colorGroup( g, active ? MenuBarItem : MenuBar ); | ||
1347 | QColor btext = cg->buttonText(); | ||
1348 | if ( active ) | ||
1349 | drawBaseButton( p, x, y, w, h, *cg, false, false, MenuBarItem ); | ||
1350 | //qDrawShadePanel(p, x, y, w, h, *cg, false, 1); | ||
1351 | |||
1352 | drawItem( p, x, y, w, h, AlignCenter | ShowPrefix | DontClip | SingleLine, | ||
1353 | *cg, mi->isEnabled(), mi->pixmap(), mi->text(), | ||
1354 | -1, &btext ); | ||
1355 | ; | ||
1356 | } | ||
1357 | |||
1358 | void OThemeStyle::drawKProgressBlock( QPainter *p, int x, int y, int w, int h, | ||
1359 | const QColorGroup &g, QBrush * ) | ||
1360 | { | ||
1361 | drawBaseButton( p, x, y, w, h, *colorGroup( g, ProgressBar ), false, false, | ||
1362 | ProgressBar ); | ||
1363 | } | ||
1364 | |||
1365 | void OThemeStyle::getKProgressBackground( const QColorGroup &g, QBrush &bg ) | ||
1366 | { | ||
1367 | const QColorGroup * cg = colorGroup( g, ProgressBg ); | ||
1368 | bg.setColor( cg->color( QColorGroup::Background ) ); | ||
1369 | if ( isPixmap( ProgressBg ) ) | ||
1370 | bg.setPixmap( *uncached( ProgressBg ) ); | ||
1371 | } | ||
1372 | #endif | ||
1373 | |||
1374 | void OThemeStyle::tabbarMetrics( const QTabBar* t, int& hframe, int& vframe, int& overlap ) | ||
1375 | { | ||
1376 | QCommonStyle::tabbarMetrics( t, hframe, vframe, overlap ); | ||
1377 | } | ||
1378 | |||
1379 | void OThemeStyle::drawTab( QPainter* p, const QTabBar* tb, QTab* t , | ||
1380 | bool selected ) | ||
1381 | { | ||
1382 | WidgetType widget = selected ? ActiveTab : InactiveTab; | ||
1383 | const QColorGroup *cg = colorGroup( tb->colorGroup(), widget ); | ||
1384 | int i; | ||
1385 | int x = t->r.x(), y = t->r.y(); | ||
1386 | int x2 = t->r.right(), y2 = t->r.bottom(); | ||
1387 | int bWidth = borderWidth( widget ); | ||
1388 | int hWidth = highlightWidth( widget ); | ||
1389 | if ( tb->shape() == QTabBar::RoundedAbove ) { | ||
1390 | if ( !selected ) { | ||
1391 | p->fillRect( x, y, x2 - x + 1, 2, | ||
1392 | tb->palette().normal().brush( QColorGroup::Background ) ); | ||
1393 | y += 2; | ||
1394 | } | ||
1395 | p->setPen( cg->text() ); | ||
1396 | i = 0; | ||
1397 | if ( i < bWidth ) { | ||
1398 | p->drawLine( x, y + 1, x, y2 ); | ||
1399 | p->drawLine( x2, y + 1, x2, y2 ); | ||
1400 | p->drawLine( x + 1, y, x2 - 1, y ); | ||
1401 | if ( selected ? activeTabLine() : inactiveTabLine() ) { | ||
1402 | p->drawLine( x, y2, x2, y2 ); | ||
1403 | --y2; | ||
1404 | } | ||
1405 | ++i, ++x, ++y, --x2; | ||
1406 | } | ||
1407 | for ( ; i < bWidth; ++i, ++x, ++y, --x2 ) { | ||
1408 | p->drawLine( x, y, x, y2 ); | ||
1409 | p->drawLine( x2, y, x2, y2 ); | ||
1410 | p->drawLine( x, y, x2, y ); | ||
1411 | if ( selected ? activeTabLine() : inactiveTabLine() ) { | ||
1412 | p->drawLine( x, y2, x2, y2 ); | ||
1413 | --y2; | ||
1414 | } | ||
1415 | } | ||
1416 | i = 0; | ||
1417 | if ( i < hWidth && bWidth == 0 ) { | ||
1418 | p->setPen( cg->light() ); | ||
1419 | p->drawLine( x, y + 1, x, y2 ); | ||
1420 | p->drawLine( x + 1, y, x2 - 1, y ); | ||
1421 | p->setPen( cg->dark() ); | ||
1422 | p->drawLine( x2, y + 1, x2, y2 ); | ||
1423 | if ( selected ? activeTabLine() : inactiveTabLine() ) { | ||
1424 | p->drawLine( x, y2, x2, y2 ); | ||
1425 | --y2; | ||
1426 | } | ||
1427 | ++i, ++x, ++y, --x2; | ||
1428 | } | ||
1429 | for ( ; i < hWidth; ++i, ++x, ++y, --x2 ) { | ||
1430 | p->setPen( cg->light() ); | ||
1431 | p->drawLine( x, y, x, y2 ); | ||
1432 | p->drawLine( x, y, x2, y ); | ||
1433 | p->setPen( cg->dark() ); | ||
1434 | p->drawLine( x2, y + 1, x2, y2 ); | ||
1435 | if ( selected ? activeTabLine() : inactiveTabLine() ) { | ||
1436 | p->drawLine( x, y2, x2, y2 ); | ||
1437 | --y2; | ||
1438 | } | ||
1439 | } | ||
1440 | if ( isPixmap( widget ) ) | ||
1441 | p->drawTiledPixmap( x, y, x2 - x + 1, y2 - y + 1, | ||
1442 | *scalePixmap( x2 - x + 1, y2 - y + 1, widget ) ); | ||
1443 | else | ||
1444 | p->fillRect( x, y, x2 - x + 1, y2 - y + 1, cg->background() ); | ||
1445 | } | ||
1446 | else if ( tb->shape() == QTabBar::RoundedBelow ) { | ||
1447 | if ( !selected ) { | ||
1448 | p->fillRect( x, y2 - 2, x2 - x + 1, 2, | ||
1449 | tb->palette().normal().brush( QColorGroup::Background ) ); | ||
1450 | y2 -= 2; | ||
1451 | } | ||
1452 | p->setPen( cg->text() ); | ||
1453 | i = 0; | ||
1454 | if ( i < bWidth ) { | ||
1455 | p->drawLine( x, y, x, y2 - 1 ); | ||
1456 | p->drawLine( x2, y, x2, y2 - 1 ); | ||
1457 | p->drawLine( x + 1, y2, x2 - 1, y2 ); | ||
1458 | if ( selected ? activeTabLine() : inactiveTabLine() ) { | ||
1459 | p->drawLine( x, y, x2, y ); | ||
1460 | ++y; | ||
1461 | } | ||
1462 | } | ||
1463 | for ( ; i < bWidth; ++i, ++x, --x2, --y2 ) { | ||
1464 | p->drawLine( x, y, x, y2 ); | ||
1465 | p->drawLine( x2, y, x2, y2 ); | ||
1466 | p->drawLine( x, y2, x2, y2 ); | ||
1467 | if ( selected ? activeTabLine() : inactiveTabLine() ) { | ||
1468 | p->drawLine( x, y, x2, y ); | ||
1469 | ++y; | ||
1470 | } | ||
1471 | } | ||
1472 | i = 0; | ||
1473 | if ( i < hWidth && bWidth == 0 ) { | ||
1474 | p->setPen( cg->dark() ); | ||
1475 | p->drawLine( x + 1, y2, x2 - 1, y2 ); | ||
1476 | p->drawLine( x2, y, x2, y2 - 1 ); | ||
1477 | p->setPen( cg->light() ); | ||
1478 | p->drawLine( x, y, x, y2 - 1 ); | ||
1479 | if ( selected ? activeTabLine() : inactiveTabLine() ) { | ||
1480 | p->drawLine( x, y, x2, y ); | ||
1481 | ++y; | ||
1482 | } | ||
1483 | ++i, ++x, --x2, --y2; | ||
1484 | } | ||
1485 | for ( ; i < hWidth; ++i, ++x, --x2, --y2 ) { | ||
1486 | p->setPen( cg->dark() ); | ||
1487 | p->drawLine( x, y2, x2, y2 ); | ||
1488 | p->drawLine( x2, y, x2, y2 ); | ||
1489 | p->setPen( cg->light() ); | ||
1490 | p->drawLine( x, y, x, y2 ); | ||
1491 | if ( selected ? activeTabLine() : inactiveTabLine() ) { | ||
1492 | p->drawLine( x, y, x2, y ); | ||
1493 | ++y; | ||
1494 | } | ||
1495 | } | ||
1496 | if ( isPixmap( widget ) ) | ||
1497 | p->drawTiledPixmap( x, y, x2 - x + 1, y2 - y + 1, | ||
1498 | *scalePixmap( x2 - x + 1, y2 - y + 1, widget ) ); | ||
1499 | else | ||
1500 | p->fillRect( x, y, x2 - x + 1, y2 - y + 1, cg->background() ); | ||
1501 | } | ||
1502 | else | ||
1503 | QCommonStyle::drawTab( p, tb, t, selected ); | ||
1504 | } | ||
1505 | |||
1506 | void OThemeStyle::drawTabMask( QPainter* p, const QTabBar* tb, QTab* t, | ||
1507 | bool selected ) | ||
1508 | { | ||
1509 | QRect r( t->r ); | ||
1510 | |||
1511 | if ( tb->shape() == QTabBar::RoundedAbove ) { | ||
1512 | if ( !selected ) | ||
1513 | r.setTop( r.top() + 2 ); | ||
1514 | p->drawLine( r.left() + 1, r.top(), r.right() - 1, r.top() ); | ||
1515 | QBrush b( color1, SolidPattern ); | ||
1516 | p->fillRect( r.left(), r.top() + 1, r.width(), r.height() - 1, b ); | ||
1517 | } | ||
1518 | else if ( tb->shape() == QTabBar::RoundedBelow ) { | ||
1519 | if ( !selected ) | ||
1520 | r.setBottom( r.bottom() - 2 ); | ||
1521 | p->drawLine( r.left() + 1, r.bottom(), r.right() - 1, r.bottom() ); | ||
1522 | QBrush b( color1, SolidPattern ); | ||
1523 | p->fillRect( r.left(), r.top(), r.width(), r.height() - 1, b ); | ||
1524 | } | ||
1525 | else | ||
1526 | QCommonStyle::drawTabMask( p, tb, t, selected ); | ||
1527 | |||
1528 | } | ||
1529 | |||
1530 | |||
1531 | //#include "kthemestyle.moc" | ||
1532 | |||