← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kde-workspace/utopic-proposed

« back to all changes in this revision

Viewing changes to kstyles/light/lightstyle-v3.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michał Zając
  • Date: 2011-07-09 08:31:15 UTC
  • Revision ID: james.westby@ubuntu.com-20110709083115-ohyxn6z93mily9fc
Tags: upstream-4.6.90
Import upstream version 4.6.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
kstyles/light/lightstyle-v3.cpp
 
1
/*
 
2
  Copyright (c) 2000-2001 Trolltech AS (info@trolltech.com)
 
3
 
 
4
  Permission is hereby granted, free of charge, to any person obtaining a
 
5
  copy of this software and associated documentation files (the "Software"),
 
6
  to deal in the Software without restriction, including without limitation
 
7
  the rights to use, copy, modify, merge, publish, distribute, sublicense,
 
8
  and/or sell copies of the Software, and to permit persons to whom the
 
9
  Software is furnished to do so, subject to the following conditions:
 
10
 
 
11
  The above copyright notice and this permission notice shall be included in
 
12
  all copies or substantial portions of the Software.
 
13
 
 
14
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
15
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
16
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 
17
  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
18
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 
19
  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 
20
  DEALINGS IN THE SOFTWARE.
 
21
*/
 
22
 
 
23
#include "lightstyle-v3.h"
 
24
 
 
25
#include <QtGui/QMenuBar>
 
26
#include <QtGui/QApplication>
 
27
#include <QtGui/QCheckBox>
 
28
#include <QtGui/QPainter>
 
29
#include <QtGui/QColorGroup>
 
30
#include <QtGui/QPushButton>
 
31
#include <QtGui/qdrawutil.h>
 
32
#include <QtGui/QProgressBar>
 
33
#include <QtGui/QScrollBar>
 
34
#include <QtGui/QTabBar>
 
35
#include <QtCore/QPointer>
 
36
#include <QtGui/QLayout>
 
37
#include <QtGui/QLineEdit>
 
38
#include <QtGui/QImage>
 
39
#include <QtGui/QComboBox>
 
40
#include <QtGui/QSlider>
 
41
#include <QtGui/QStyleFactory>
 
42
#include <Qt3Support/Q3PointArray>
 
43
 
 
44
 
 
45
// The Light Style, 3rd revision
 
46
 
 
47
LightStyleV3::LightStyleV3()
 
48
    : KStyle(AllowMenuTransparency)
 
49
{
 
50
    basestyle = QStyleFactory::create( "Windows" );
 
51
    if ( ! basestyle )
 
52
        basestyle = QStyleFactory::create( QStyleFactory::keys().first() );
 
53
    if ( ! basestyle )
 
54
        qFatal( "LightStyle: could not find a basestyle!" );
 
55
}
 
56
 
 
57
LightStyleV3::~LightStyleV3()
 
58
{
 
59
    delete basestyle;
 
60
}
 
61
 
 
62
void LightStyleV3::polishPopupMenu( QMenu * menu)
 
63
{
 
64
    KStyle::polishPopupMenu(menu);
 
65
    // empty to satisy pure virtual requirements
 
66
}
 
67
 
 
68
/*
 
69
  A LightBevel looks like this:
 
70
 
 
71
  EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
 
72
  ESSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSE
 
73
  ESBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBSE
 
74
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
75
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
76
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
77
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
78
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
79
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
80
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
81
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
82
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
83
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
84
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
85
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
86
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
87
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
88
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
89
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
90
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
91
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
92
  ESBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBSE
 
93
  ESBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBSE
 
94
  ESSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSE
 
95
  EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
 
96
 
 
97
  where:
 
98
      E is the sunken etching ( optional, not drawn by default )
 
99
      S is the border (optional, drawn by default )
 
100
      B is the bevel (draw with the line width, minus the width of
 
101
                      the etching and border )
 
102
      F is the fill ( optional, not drawn by default )
 
103
*/
 
104
static void drawLightEtch( QPainter *p,
 
105
                           const QRect &rect,
 
106
                           const QColor &color,
 
107
                           bool sunken )
 
108
{
 
109
    Q3PointArray pts( 4 );
 
110
 
 
111
    pts.setPoint( 0, rect.left(),     rect.bottom() - 1);
 
112
    pts.setPoint( 1, rect.left(),     rect.top() );
 
113
    pts.setPoint( 2, rect.left() + 1, rect.top() );
 
114
    pts.setPoint( 3, rect.right(),    rect.top() );
 
115
    p->setPen( sunken ? color.dark( 115 ) : color.light( 115 ) );
 
116
    p->drawLineSegments( pts );
 
117
 
 
118
    pts.setPoint( 0, rect.left(),     rect.bottom() );
 
119
    pts.setPoint( 1, rect.right(),    rect.bottom() );
 
120
    pts.setPoint( 2, rect.right(),    rect.bottom() - 1 );
 
121
    pts.setPoint( 3, rect.right(),    rect.top() + 1 );
 
122
    p->setPen( sunken ? color.light( 115 ) : color.dark( 115 ) );
 
123
    p->drawLineSegments( pts );
 
124
}
 
125
 
 
126
static void drawLightBevel( QPainter *p,
 
127
                            const QRect &rect,
 
128
                            const QColorGroup &cg,
 
129
                            QStyle::State flags,
 
130
                            int linewidth,
 
131
                            bool etch = false,       // light sunken bevel around border
 
132
                            bool border = true,      // rectangle around bevel
 
133
                            const QBrush *fill = 0 ) // contents fill
 
134
{
 
135
    QRect br = rect;
 
136
    bool bevel = ( flags & ( QStyle::State_Down | QStyle::State_On |
 
137
                             QStyle::State_Sunken | QStyle::State_Raised ) );
 
138
    bool sunken = (flags & (QStyle::State_Down | QStyle::State_On |
 
139
                            QStyle::State_Sunken));
 
140
 
 
141
    if ( etch && linewidth > 0 ) {
 
142
        drawLightEtch( p, br, cg.background(), true );
 
143
        linewidth--;
 
144
        br.adjust( 1, 1, -1, -1 );
 
145
    }
 
146
 
 
147
    if ( ! br.isValid() )
 
148
        return;
 
149
    if ( border && linewidth > 0 ) {
 
150
        p->setPen( cg.dark() );
 
151
        p->drawRect( br );
 
152
        linewidth--;
 
153
        br.adjust( 1, 1, -1, -1 );
 
154
    }
 
155
 
 
156
    if ( ! br.isValid() )
 
157
        return;
 
158
    if ( bevel && linewidth > 0 ) {
 
159
        // draw a bevel
 
160
        int x, y, w, h;
 
161
        br.getRect( &x, &y, &w, &h );
 
162
 
 
163
        // copied form qDrawShadePanel - just changed the highlight colors...
 
164
        Q3PointArray a( 4*linewidth );
 
165
        if ( sunken )
 
166
            p->setPen( border ? cg.mid() : cg.dark() );
 
167
        else
 
168
            p->setPen( cg.light() );
 
169
        int x1, y1, x2, y2;
 
170
        int i;
 
171
        int n = 0;
 
172
        x1 = x;
 
173
        y1 = y2 = y;
 
174
        x2 = x+w-2;
 
175
        for ( i=0; i<linewidth; i++ ) {         // top shadow
 
176
            a.setPoint( n++, x1, y1++ );
 
177
            a.setPoint( n++, x2--, y2++ );
 
178
        }
 
179
        x2 = x1;
 
180
        y1 = y+h-2;
 
181
        for ( i=0; i<linewidth; i++ ) {         // left shadow
 
182
            a.setPoint( n++, x1++, y1 );
 
183
            a.setPoint( n++, x2++, y2-- );
 
184
        }
 
185
        p->drawLineSegments( a );
 
186
        n = 0;
 
187
        if ( sunken )
 
188
            p->setPen( cg.light() );
 
189
        else
 
190
            p->setPen( border ? cg.mid() : cg.dark() );
 
191
        x1 = x;
 
192
        y1 = y2 = y+h-1;
 
193
        x2 = x+w-1;
 
194
        for ( i=0; i<linewidth; i++ ) {         // bottom shadow
 
195
            a.setPoint( n++, x1++, y1-- );
 
196
            a.setPoint( n++, x2, y2-- );
 
197
        }
 
198
        x1 = x2;
 
199
        y1 = y;
 
200
        y2 = y+h-linewidth-1;
 
201
        for ( i=0; i<linewidth; i++ ) {         // right shadow
 
202
            a.setPoint( n++, x1--, y1++ );
 
203
            a.setPoint( n++, x2--, y2 );
 
204
        }
 
205
        p->drawLineSegments( a );
 
206
 
 
207
        br.adjust( linewidth, linewidth, -linewidth, -linewidth );
 
208
    }
 
209
 
 
210
    // fill
 
211
    if ( fill )
 
212
        p->fillRect( br, *fill );
 
213
}
 
214
 
 
215
void LightStyleV3::drawPrimitive( PrimitiveElement pe,
 
216
                                QPainter *p,
 
217
                                const QRect &r,
 
218
                                const QColorGroup &cg,
 
219
                                SFlags flags,
 
220
                                const QStyleOption &data ) const
 
221
{
 
222
    QRect br = r;
 
223
    const QBrush *fill = 0;
 
224
 
 
225
    switch (pe) {
 
226
    case PE_HeaderSection:
 
227
        // don't draw any headers sunken
 
228
        flags = ((flags | Style_Sunken) ^ Style_Sunken) | Style_Raised;
 
229
 
 
230
        p->setPen( cg.background() );
 
231
        // hard border at the bottom/right of the header
 
232
        if ( flags & Style_Horizontal ) {
 
233
            p->drawLine( br.bottomLeft(), br.bottomRight() );
 
234
            br.adjust( 0, 0, 0, -1 );
 
235
        } else {
 
236
            p->drawLine( br.topRight(), br.bottomRight() );
 
237
            br.adjust( 0, 0, -1, 0 );
 
238
        }
 
239
 
 
240
        // draw the header ( just an etching )
 
241
        if ( ! br.isValid() )
 
242
            break;
 
243
        drawLightEtch( p, br, ( ( flags & Style_Down ) ?
 
244
                                cg.midlight() : cg.button() ),
 
245
                       ( flags & Style_Down ) );
 
246
        br.adjust( 1, 1, -1, -1 );
 
247
 
 
248
        // fill the header
 
249
        if ( ! br.isValid() )
 
250
            break;
 
251
        p->fillRect( br, cg.brush( ( flags & Style_Down ) ?
 
252
                                   QPalette::Midlight : QPalette::Button ) );
 
253
 
 
254
        // the taskbuttons in kicker seem to allow the style to set the pencolor
 
255
        // here, which will be used to draw the text for focused window buttons...
 
256
        // how utterly silly
 
257
        p->setPen( cg.buttonText() );
 
258
        break;
 
259
 
 
260
    case PE_ButtonCommand:
 
261
        {
 
262
            QRect br = r;
 
263
 
 
264
            if (flags & QStyle::State_Enabled) {
 
265
                if (flags & (QStyle::State_Down |
 
266
                             QStyle::State_On |
 
267
                             QStyle::State_Sunken))
 
268
                    fill = &cg.brush(QPalette::Midlight);
 
269
                else
 
270
                    fill = &cg.brush(QPalette::Button);
 
271
            } else
 
272
                fill = &cg.brush(QPalette::Background);
 
273
 
 
274
            bool etch = true;
 
275
            if ( flags & Style_ButtonDefault ) {
 
276
                etch = false;
 
277
                br.adjust( 1, 1, -1, -1 );
 
278
            }
 
279
            drawLightBevel( p, br, cg, flags,
 
280
                            pixelMetric( PM_DefaultFrameWidth ) + ( etch ? 1 : 0 ),
 
281
                            etch, true, fill );
 
282
            break;
 
283
        }
 
284
 
 
285
    case PE_ButtonBevel:
 
286
    case PE_ButtonTool:
 
287
        if (flags & QStyle::State_Enabled) {
 
288
            if (flags & (QStyle::State_Down |
 
289
                         QStyle::State_On |
 
290
                         QStyle::State_Sunken))
 
291
                fill = &cg.brush(QPalette::Midlight);
 
292
            else
 
293
                fill = &cg.brush(QPalette::Button);
 
294
        } else
 
295
            fill = &cg.brush(QPalette::Background);
 
296
        drawLightBevel( p, r, cg, flags, pixelMetric( PM_DefaultFrameWidth ),
 
297
                        false, true, fill );
 
298
        break;
 
299
 
 
300
    case PE_ButtonDropDown:
 
301
        {
 
302
            QBrush thefill;
 
303
            bool sunken =
 
304
                (flags & (QStyle::State_Down | QStyle::State_On | QStyle::State_Sunken));
 
305
 
 
306
            if (flags & QStyle::State_Enabled) {
 
307
                if (sunken)
 
308
                    thefill = cg.brush(QPalette::Midlight);
 
309
                else
 
310
                    thefill = cg.brush(QPalette::Button);
 
311
            } else
 
312
                thefill = cg.brush(QPalette::Background);
 
313
 
 
314
            p->setPen( cg.dark() );
 
315
            p->drawLine(r.topLeft(),     r.topRight());
 
316
            p->drawLine(r.topRight(),    r.bottomRight());
 
317
            p->drawLine(r.bottomRight(), r.bottomLeft());
 
318
 
 
319
            if (flags & (QStyle::State_Down | QStyle::State_On |
 
320
                         QStyle::State_Sunken | QStyle::State_Raised)) {
 
321
                // button bevel
 
322
                if (sunken)
 
323
                    p->setPen(cg.mid());
 
324
                else
 
325
                    p->setPen(cg.light());
 
326
 
 
327
                p->drawLine(r.x(), r.y() + 2,
 
328
                            r.x(), r.y() + r.height() - 3); // left
 
329
                p->drawLine(r.x(), r.y() + 1,
 
330
                            r.x() + r.width() - 2, r.y() + 1); // top
 
331
 
 
332
                if (sunken)
 
333
                    p->setPen(cg.light());
 
334
                else
 
335
                    p->setPen(cg.mid());
 
336
 
 
337
                p->drawLine(r.x() + r.width() - 2, r.y() + 2,
 
338
                            r.x() + r.width() - 2, r.y() + r.height() - 3); // right
 
339
                p->drawLine(r.x() + 1, r.y() + r.height() - 2,
 
340
                            r.x() + r.width() - 2, r.y() + r.height() - 2); // bottom
 
341
            }
 
342
 
 
343
            p->fillRect(r.x() + 1, r.y() + 2, r.width() - 3, r.height() - 4, thefill);
 
344
            break;
 
345
        }
 
346
 
 
347
    case PE_ButtonDefault:
 
348
        p->setPen( cg.shadow() );
 
349
        p->drawRect( r );
 
350
        break;
 
351
 
 
352
    case PE_Indicator:
 
353
        const QBrush *fill;
 
354
        if (! (flags & Style_Enabled))
 
355
            fill = &cg.brush(QPalette::Background);
 
356
        else if (flags & Style_Down)
 
357
            fill = &cg.brush(QPalette::Mid);
 
358
        else
 
359
            fill = &cg.brush(QPalette::Base);
 
360
        drawLightBevel( p, r, cg, flags | Style_Sunken, 2, true, true, fill );
 
361
 
 
362
        p->setPen(cg.text());
 
363
        if (flags & Style_NoChange) {
 
364
            p->drawLine(r.x() + 3, r.y() + r.height() / 2,
 
365
                        r.x() + r.width() - 4, r.y() + r.height() / 2);
 
366
            p->drawLine(r.x() + 3, r.y() + 1 + r.height() / 2,
 
367
                        r.x() + r.width() - 4, r.y() + 1 + r.height() / 2);
 
368
            p->drawLine(r.x() + 3, r.y() - 1 + r.height() / 2,
 
369
                        r.x() + r.width() - 4, r.y() - 1 + r.height() / 2);
 
370
        } else if (flags & Style_On) {
 
371
            p->drawLine(r.x() + 4, r.y() + 3,
 
372
                        r.x() + r.width() - 4, r.y() + r.height() - 5);
 
373
            p->drawLine(r.x() + 3, r.y() + 3,
 
374
                        r.x() + r.width() - 4, r.y() + r.height() - 4);
 
375
            p->drawLine(r.x() + 3, r.y() + 4,
 
376
                        r.x() + r.width() - 5, r.y() + r.height() - 4);
 
377
            p->drawLine(r.x() + 3, r.y() + r.height() - 5,
 
378
                        r.x() + r.width() - 5, r.y() + 3);
 
379
            p->drawLine(r.x() + 3, r.y() + r.height() - 4,
 
380
                        r.x() + r.width() - 4, r.y() + 3);
 
381
            p->drawLine(r.x() + 4, r.y() + r.height() - 4,
 
382
                        r.x() + r.width() - 4, r.y() + 4);
 
383
        }
 
384
 
 
385
        break;
 
386
 
 
387
    case PE_ExclusiveIndicator:
 
388
        {
 
389
            QRect br = r, // bevel rect
 
390
                  lr = r, // outline rect
 
391
                  cr = r, // contents rect
 
392
                  ir = r; // indicator rect
 
393
            lr.adjust( 1, 1, -1, -1 );
 
394
            cr.adjust( 2, 2, -2, -2 );
 
395
            ir.adjust( 3, 3, -3, -3 );
 
396
 
 
397
            p->fillRect( r, cg.brush( QPalette::Background ) );
 
398
 
 
399
            p->setPen( flags & Style_Down ? cg.mid() :
 
400
                       ( flags & Style_Enabled ? cg.base() : cg.background() ) );
 
401
            p->setBrush( flags & Style_Down ? cg.mid() :
 
402
                         ( flags & Style_Enabled ? cg.base() : cg.background() ) );
 
403
            p->drawEllipse( lr );
 
404
 
 
405
            p->setPen( cg.background().dark( 115 ) );
 
406
            p->drawArc( br, 45*16, 180*16 );
 
407
            p->setPen( cg.background().light( 115 ) );
 
408
            p->drawArc( br, 235*16, 180*16 );
 
409
 
 
410
            p->setPen( cg.dark() );
 
411
            p->drawArc( lr, 0, 16*360 );
 
412
 
 
413
            if ( flags & Style_On ) {
 
414
                p->setPen( flags & Style_Down ? cg.mid() :
 
415
                           ( flags & Style_Enabled ? cg.base() : cg.background() ) );
 
416
                p->setBrush( cg.text() );
 
417
                p->drawEllipse( ir );
 
418
            }
 
419
 
 
420
            break;
 
421
        }
 
422
 
 
423
    case PE_DockWindowHandle:
 
424
        {
 
425
            QString title;
 
426
            bool drawTitle = false;
 
427
            if ( p && p->device()->devType() == QInternal::Widget ) {
 
428
                QWidget *w = (QWidget *) p->device();
 
429
                QWidget *p = w->parentWidget();
 
430
                if (p->inherits("QDockWindow") && ! p->inherits("QToolBar")) {
 
431
                    drawTitle = true;
 
432
                    title = p->caption();
 
433
                }
 
434
            }
 
435
 
 
436
            flags |= Style_Raised;
 
437
            if (flags & Style_Horizontal) {
 
438
                if (drawTitle) {
 
439
                    QPixmap pm(r.height(), r.width());
 
440
                    QPainter p2(&pm);
 
441
                    p2.fillRect(0, 0, pm.width(), pm.height(),
 
442
                                cg.brush(QPalette::Highlight));
 
443
                    p2.setPen(cg.highlightedText());
 
444
                    p2.drawText(0, 0, pm.width(), pm.height(), Qt::AlignCenter, title);
 
445
                    p2.end();
 
446
 
 
447
                    QMatrix m;
 
448
                    m.rotate(270.0);
 
449
                    pm = pm.xForm(m);
 
450
                    p->drawPixmap(r.x(), r.y(), pm);
 
451
                } else {
 
452
                    for ( int i = r.left() - 1; i < r.right(); i += 3 ) {
 
453
                        p->setPen( cg.midlight() );
 
454
                        p->drawLine( i, r.top(), i, r.bottom() );
 
455
                        p->setPen( cg.background() );
 
456
                        p->drawLine( i + 1, r.top(), i + 1, r.bottom() );
 
457
                        p->setPen( cg.mid() );
 
458
                        p->drawLine( i + 2, r.top(), i + 2, r.bottom() );
 
459
                    }
 
460
                }
 
461
            } else {
 
462
                if (drawTitle) {
 
463
                    p->fillRect(r, cg.brush(QPalette::Highlight));
 
464
                    p->setPen(cg.highlightedText());
 
465
                    p->drawText(r, Qt::AlignCenter, title);
 
466
                } else {
 
467
                    for ( int i = r.top() - 1; i < r.bottom(); i += 3 ) {
 
468
                        p->setPen( cg.midlight() );
 
469
                        p->drawLine( r.left(), i, r.right(), i );
 
470
                        p->setPen( cg.background() );
 
471
                        p->drawLine( r.left(), i + 1, r.right(), i + 1);
 
472
                        p->setPen( cg.mid() );
 
473
                        p->drawLine( r.left(), i + 2, r.right(), i + 2 );
 
474
                    }
 
475
 
 
476
                }
 
477
            }
 
478
            break;
 
479
        }
 
480
 
 
481
    case PE_DockWindowSeparator:
 
482
        {
 
483
            if (flags & Style_Horizontal) {
 
484
                int hw = r.width() / 2;
 
485
                p->setPen( cg.mid() );
 
486
                p->drawLine( hw,     r.top() + 6, hw,     r.bottom() - 6 );
 
487
                p->setPen( cg.light() );
 
488
                p->drawLine( hw + 1, r.top() + 6, hw + 1, r.bottom() - 6 );
 
489
            } else {
 
490
                int hh = r.height() / 2;
 
491
                p->setPen( cg.mid() );
 
492
                p->drawLine( r.left() + 6, hh,     r.right() - 6, hh     );
 
493
                p->setPen( cg.light() );
 
494
                p->drawLine( r.left() + 6, hh + 1, r.right() - 6, hh + 1 );
 
495
            }
 
496
            break;
 
497
        }
 
498
 
 
499
    case PE_Splitter:
 
500
        if (flags & Style_Horizontal)
 
501
            flags &= ~Style_Horizontal;
 
502
        else
 
503
            flags |= Style_Horizontal;
 
504
        // fall through intended
 
505
 
 
506
    case PE_DockWindowResizeHandle:
 
507
        {
 
508
            QRect br = r;
 
509
 
 
510
            p->setPen( cg.shadow() );
 
511
            p->drawRect( br );
 
512
 
 
513
            br.adjust( 1, 1, -1, -1 );
 
514
 
 
515
            if ( ! br.isValid() )
 
516
                break;
 
517
            p->setPen( cg.light() );
 
518
            p->drawLine( br.left(), br.top(), br.right() - 1, br.top() );
 
519
            p->drawLine( br.left(), br.top() + 1, br.left(), br.bottom() );
 
520
            p->setPen( cg.mid() );
 
521
            p->drawLine( br.bottomLeft(), br.bottomRight() );
 
522
            p->drawLine( br.right(), br.top(), br.right(), br.bottom() - 1 );
 
523
 
 
524
            br.adjust( 1, 1, -1, -1 );
 
525
 
 
526
            if ( ! br.isValid() )
 
527
                break;
 
528
            p->fillRect( br, cg.brush( QPalette::Button ) );
 
529
            break;
 
530
        }
 
531
 
 
532
    case PE_PanelPopup:
 
533
        drawLightBevel( p, r, cg, flags,
 
534
                        ( data.isDefault() ? pixelMetric(PM_DefaultFrameWidth) :
 
535
                          data.lineWidth() ), false, true );
 
536
        break;
 
537
 
 
538
    case PE_Panel:
 
539
    case PE_PanelLineEdit:
 
540
    case PE_PanelTabWidget:
 
541
    case PE_WindowFrame:
 
542
        {
 
543
            QRect br = r;
 
544
 
 
545
            int cover = 0;
 
546
            int reallw = ( data.isDefault() ?
 
547
                           pixelMetric( PM_DefaultFrameWidth ) : data.lineWidth() );
 
548
            cover = reallw - 1;
 
549
 
 
550
            if ( ! ( flags & Style_Sunken ) )
 
551
                flags |= Style_Raised;
 
552
            drawLightBevel( p, br, cg, flags, 1, false, false );
 
553
            br.adjust( 1, 1, -1, -1 );
 
554
 
 
555
            while ( cover-- > 0 ) {
 
556
                Q3PointArray pts( 8 );
 
557
                pts.setPoint( 0, br.left(),     br.bottom() - 1);
 
558
                pts.setPoint( 1, br.left(),     br.top() );
 
559
                pts.setPoint( 2, br.left() + 1, br.top() );
 
560
                pts.setPoint( 3, br.right(),    br.top() );
 
561
                pts.setPoint( 4, br.left(),     br.bottom() );
 
562
                pts.setPoint( 5, br.right(),    br.bottom() );
 
563
                pts.setPoint( 6, br.right(),    br.bottom() - 1 );
 
564
                pts.setPoint( 7, br.right(),    br.top() + 1 );
 
565
                p->setPen( cg.background() );
 
566
                p->drawLineSegments( pts );
 
567
 
 
568
                br.adjust( 1, 1, -1, -1 );
 
569
            }
 
570
            break;
 
571
        }
 
572
 
 
573
    case PE_PanelDockWindow:
 
574
        drawLightBevel( p, r, cg, flags, ( data.isDefault() ?
 
575
                                           pixelMetric(PM_DefaultFrameWidth) :
 
576
                                           data.lineWidth() ), false, false,
 
577
                        &cg.brush( QPalette::Button ) );
 
578
        break;
 
579
 
 
580
    case PE_PanelMenuBar:
 
581
        drawLightBevel( p, r, cg, flags, ( data.isDefault() ?
 
582
                                           pixelMetric(PM_MenuBarFrameWidth) :
 
583
                                           data.lineWidth() ), false, false,
 
584
                        &cg.brush( QPalette::Button ) );
 
585
        break;
 
586
 
 
587
    case PE_ScrollBarSubLine:
 
588
        {
 
589
            QRect br = r;
 
590
            PrimitiveElement pe;
 
591
 
 
592
            p->setPen( cg.background() );
 
593
            if (flags & Style_Horizontal) {
 
594
                pe = PE_ArrowLeft;
 
595
                p->drawLine( br.topLeft(), br.topRight() );
 
596
                br.adjust( 0, 1, 0, 0 );
 
597
            } else {
 
598
                pe = PE_ArrowUp;
 
599
                p->drawLine( br.topLeft(), br.bottomLeft() );
 
600
                br.adjust( 1, 0, 0, 0 );
 
601
            }
 
602
 
 
603
            if ( ! br.isValid() )
 
604
                break;
 
605
            drawLightEtch( p, br, cg.button(), false );
 
606
            br.adjust( 1, 1, -1, -1 );
 
607
 
 
608
            if ( ! br.isValid() )
 
609
                break;
 
610
            p->fillRect( br, cg.brush( ( flags & Style_Down ) ?
 
611
                                       QPalette::Midlight :
 
612
                                       QPalette::Button ) );
 
613
            br.adjust( 2, 2, -2, -2 );
 
614
 
 
615
            if ( ! br.isValid() )
 
616
                break;
 
617
            drawPrimitive( pe, p, br, cg, flags );
 
618
            break;
 
619
        }
 
620
 
 
621
    case PE_ScrollBarAddLine:
 
622
        {
 
623
            QRect br = r;
 
624
            PrimitiveElement pe;
 
625
 
 
626
            p->setPen( cg.background() );
 
627
            if (flags & Style_Horizontal) {
 
628
                pe = PE_ArrowRight;
 
629
                p->drawLine( br.topLeft(), br.topRight() );
 
630
                br.adjust( 0, 1, 0, 0 );
 
631
            } else {
 
632
                pe = PE_ArrowDown;
 
633
                p->drawLine( br.topLeft(), br.bottomLeft() );
 
634
                br.adjust( 1, 0, 0, 0 );
 
635
            }
 
636
 
 
637
            if ( ! br.isValid() )
 
638
                break;
 
639
            drawLightEtch( p, br, cg.button(), false );
 
640
            br.adjust( 1, 1, -1, -1 );
 
641
 
 
642
            if ( ! br.isValid() )
 
643
                break;
 
644
            p->fillRect( br, cg.brush( ( flags & Style_Down ) ?
 
645
                                       QPalette::Midlight :
 
646
                                       QPalette::Button ) );
 
647
            br.adjust( 2, 2, -2, -2 );
 
648
 
 
649
            if ( ! br.isValid() )
 
650
                break;
 
651
            drawPrimitive( pe, p, br, cg, flags );
 
652
            break;
 
653
        }
 
654
 
 
655
    case PE_ScrollBarSubPage:
 
656
        {
 
657
            QRect br = r;
 
658
 
 
659
            p->setPen( cg.background() );
 
660
            if (flags & Style_Horizontal) {
 
661
                p->drawLine( br.topLeft(), br.topRight() );
 
662
                br.adjust( 0, 1, 0, 0 );
 
663
            } else {
 
664
                p->drawLine( br.topLeft(), br.bottomLeft() );
 
665
                br.adjust( 1, 0, 0, 0 );
 
666
            }
 
667
 
 
668
            if ( ! br.isValid() )
 
669
                break;
 
670
            drawLightEtch( p, br, cg.button(), false );
 
671
            br.adjust( 1, 1, -1, -1 );
 
672
 
 
673
            if ( ! br.isValid() )
 
674
                break;
 
675
            p->fillRect( br, cg.brush( ( flags & Style_Down ) ?
 
676
                                       QPalette::Midlight :
 
677
                                       QPalette::Button ) );
 
678
            break;
 
679
        }
 
680
 
 
681
    case PE_ScrollBarAddPage:
 
682
        {
 
683
            QRect br = r;
 
684
 
 
685
            p->setPen( cg.background() );
 
686
            if (flags & Style_Horizontal) {
 
687
                p->drawLine( br.topLeft(), br.topRight() );
 
688
                br.adjust( 0, 1, 0, 0 );
 
689
            } else {
 
690
                p->drawLine( br.topLeft(), br.bottomLeft() );
 
691
                br.adjust( 1, 0, 0, 0 );
 
692
            }
 
693
 
 
694
            if ( ! br.isValid() )
 
695
                break;
 
696
            drawLightEtch( p, br, cg.button(), false );
 
697
            br.adjust( 1, 1, -1, -1 );
 
698
 
 
699
            if ( ! br.isValid() )
 
700
                break;
 
701
            p->fillRect( br, cg.brush( ( flags & Style_Down ) ?
 
702
                                       QPalette::Midlight :
 
703
                                       QPalette::Button ) );
 
704
            break;
 
705
        }
 
706
 
 
707
    case PE_ScrollBarSlider:
 
708
        {
 
709
            QRect br = r;
 
710
 
 
711
            p->setPen( cg.background() );
 
712
            if (flags & Style_Horizontal) {
 
713
                p->drawLine( br.topLeft(), br.topRight() );
 
714
                br.adjust( 0, 1, 0, 0 );
 
715
            } else {
 
716
                p->drawLine( br.topLeft(), br.bottomLeft() );
 
717
                br.adjust( 1, 0, 0, 0 );
 
718
            }
 
719
 
 
720
            if ( ! br.isValid() )
 
721
                break;
 
722
            p->setPen( cg.highlight().light() );
 
723
            p->drawLine( br.topLeft(), br.topRight() );
 
724
            p->drawLine( br.left(), br.top() + 1, br.left(), br.bottom() - 1 );
 
725
 
 
726
            p->setPen( cg.highlight().dark() );
 
727
            p->drawLine( br.left(), br.bottom(), br.right() - 1, br.bottom() );
 
728
            p->drawLine( br.topRight(), br.bottomRight() );
 
729
            br.adjust( 1, 1, -1, -1 );
 
730
 
 
731
            p->fillRect( br, cg.brush( QPalette::Highlight ) );
 
732
            break;
 
733
        }
 
734
 
 
735
    case PE_FocusRect:
 
736
        p->setBrush( Qt::NoBrush );
 
737
        if ( flags & Style_FocusAtBorder )
 
738
            p->setPen( cg.shadow() );
 
739
        else
 
740
            p->setPen( cg.dark() );
 
741
        p->drawRect( r );
 
742
        break;
 
743
 
 
744
    case PE_ProgressBarChunk:
 
745
        p->fillRect(r.x(), r.y() + 2, r.width(), r.height() - 4, cg.highlight());
 
746
        break;
 
747
 
 
748
    default:
 
749
        if (pe == PE_HeaderArrow) {
 
750
            if (flags & Style_Down)
 
751
                pe = PE_ArrowDown;
 
752
            else
 
753
                pe = PE_ArrowUp;
 
754
        }
 
755
        
 
756
        if (pe >= PE_ArrowUp && pe <= PE_ArrowLeft) {
 
757
            Q3PointArray a;
 
758
 
 
759
            switch ( pe ) {
 
760
            case PE_ArrowUp:
 
761
                a.setPoints( 7, -4,1, 2,1, -3,0, 1,0, -2,-1, 0,-1, -1,-2 );
 
762
                break;
 
763
 
 
764
            case PE_ArrowDown:
 
765
                a.setPoints( 7, -4,-2, 2,-2, -3,-1, 1,-1, -2,0, 0,0, -1,1 );
 
766
                break;
 
767
 
 
768
            case PE_ArrowRight:
 
769
                a.setPoints( 7, -2,-3, -2,3, -1,-2, -1,2, 0,-1, 0,1, 1,0 );
 
770
                break;
 
771
 
 
772
            case PE_ArrowLeft:
 
773
                a.setPoints( 7, 0,-3, 0,3, -1,-2, -1,2, -2,-1, -2,1, -3,0 );
 
774
                break;
 
775
 
 
776
            default:
 
777
                break;
 
778
            }
 
779
 
 
780
            if (a.isNull())
 
781
                return;
 
782
 
 
783
            p->save();
 
784
            if ( flags & Style_Enabled ) {
 
785
                a.translate( r.x() + r.width() / 2, r.y() + r.height() / 2 );
 
786
                p->setPen( cg.buttonText() );
 
787
                p->drawLineSegments( a, 0, 3 );         // draw arrow
 
788
                p->drawPoint( a[6] );
 
789
            } else {
 
790
                a.translate( r.x() + r.width() / 2 + 1, r.y() + r.height() / 2 + 1 );
 
791
                p->setPen( cg.light() );
 
792
                p->drawLineSegments( a, 0, 3 );         // draw arrow
 
793
                p->drawPoint( a[6] );
 
794
                a.translate( -1, -1 );
 
795
                p->setPen( cg.mid() );
 
796
                p->drawLineSegments( a, 0, 3 );         // draw arrow
 
797
                p->drawPoint( a[6] );
 
798
            }
 
799
            p->restore();
 
800
        } else
 
801
            QCommonStyle::drawPrimitive(pe, p, r, cg, flags, data);
 
802
        break;
 
803
    }
 
804
}
 
805
 
 
806
void LightStyleV3::drawControl( ControlElement control,
 
807
                              QPainter *p,
 
808
                              const QWidget *widget,
 
809
                              const QRect &r,
 
810
                              const QColorGroup &cg,
 
811
                              SFlags flags,
 
812
                              const QStyleOption &data ) const
 
813
{
 
814
    switch (control) {
 
815
    case CE_TabBarTab:
 
816
        {
 
817
            const QTabBar *tb = (const QTabBar *) widget;
 
818
            QRect br = r;
 
819
 
 
820
            if ( tb->shape() == QTabBar::RoundedNorth ) {
 
821
                if ( ! ( flags & Style_Selected ) ) {
 
822
                    p->setPen( cg.background() );
 
823
                    p->drawLine( br.left(),  br.bottom(),
 
824
                                 br.right(), br.bottom() );
 
825
                    p->setPen( cg.light() );
 
826
                    p->drawLine( br.left(),  br.bottom() - 1,
 
827
                                 br.right(), br.bottom() - 1);
 
828
                    br.adjust( 0, 2, -1, -2 );
 
829
                    if ( br.left() == 0 )
 
830
                        p->drawPoint( br.left(), br.bottom() + 2 );
 
831
                } else {
 
832
                    p->setPen( cg.background() );
 
833
                    p->drawLine( br.bottomLeft(), br.bottomRight() );
 
834
                    if ( br.left() == 0 ) {
 
835
                        p->setPen( cg.light() );
 
836
                        p->drawPoint( br.bottomLeft() );
 
837
                    }
 
838
                    br.adjust( 0, 0, 0, -1 );
 
839
                }
 
840
 
 
841
                p->setPen( cg.light() );
 
842
                p->drawLine( br.bottomLeft(), br.topLeft() );
 
843
                p->drawLine( br.topLeft(), br.topRight() );
 
844
                p->setPen( cg.dark() );
 
845
                p->drawLine( br.right(), br.top() + 1, br.right(), br.bottom() );
 
846
 
 
847
                if ( flags & Style_Selected )
 
848
                {
 
849
                    p->fillRect( br.right() - 3, br.top() + 1, 3, br.height() - 1, cg.brush(QPalette::Highlight));
 
850
                    br.adjust( 1, 1, -4, 0 );
 
851
                }
 
852
                else
 
853
                    br.adjust( 1, 1, -1, 0 );
 
854
                p->fillRect( br, cg.background() );
 
855
            } else if ( tb->shape() == QTabBar:: RoundedSouth ) {
 
856
                if ( ! ( flags & Style_Selected ) ) {
 
857
                    p->setPen( cg.background() );
 
858
                    p->drawLine( br.left(),  br.top(),
 
859
                                 br.right(), br.top() );
 
860
                    p->setPen( cg.dark() );
 
861
                    p->drawLine( br.left(),  br.top() + 1,
 
862
                                 br.right(), br.top() + 1);
 
863
                    br.adjust( 0, 2, -1, -2 );
 
864
                    if ( br.left() == 0 ) {
 
865
                        p->setPen( cg.light() );
 
866
                        p->drawPoint( br.left(), br.top() - 2 );
 
867
                    }
 
868
                } else {
 
869
                    p->setPen( cg.background() );
 
870
                    p->drawLine( br.topLeft(), br.topRight() );
 
871
                    if ( br.left() == 0 ) {
 
872
                        p->setPen( cg.light() );
 
873
                        p->drawPoint( br.topLeft() );
 
874
                    }
 
875
                    br.adjust( 0, 1, 0, 0 );
 
876
                }
 
877
 
 
878
                p->setPen( cg.light() );
 
879
                p->drawLine( br.topLeft(), br.bottomLeft() );
 
880
                p->setPen( cg.dark() );
 
881
                p->drawLine( br.bottomLeft(), br.bottomRight() );
 
882
                p->drawLine( br.right(), br.top(), br.right(), br.bottom() - 1 );
 
883
                br.adjust( 1, 0, -1, -1 );
 
884
 
 
885
                if ( flags & Style_Selected )
 
886
                {
 
887
                    p->fillRect( br.right() - 2, br.top(), 3, br.height(), cg.brush(QPalette::Highlight));
 
888
                    br.adjust( 1, 0, -3, -1 );
 
889
                }
 
890
                else
 
891
                    br.adjust( 1, 0, -1, -1 );
 
892
 
 
893
                p->fillRect( br, cg.background() );
 
894
            } else
 
895
                QCommonStyle::drawControl( control, p, widget, r, cg, flags, data );
 
896
            break;
 
897
        }
 
898
 
 
899
    case CE_PopupMenuItem:
 
900
        {
 
901
            if (! widget || data.isDefault())
 
902
                break;
 
903
 
 
904
            const QMenu *popupmenu = (const QMenu *) widget;
 
905
            QMenuItem *mi = data.menuItem();
 
906
            int tab = data.tabWidth();
 
907
            int maxpmw = data.maxIconWidth();
 
908
 
 
909
            if ( mi && mi->isSeparator() ) {
 
910
                if ( widget->erasePixmap() && !widget->erasePixmap()->isNull() )
 
911
                        p->drawPixmap( r.topLeft(), *widget->erasePixmap(), r );
 
912
                else
 
913
                        p->fillRect(r, cg.brush(QPalette::Button));
 
914
                p->setPen( cg.mid() );
 
915
                p->drawLine(r.left() + 12,  r.top() + 1,
 
916
                            r.right() - 12, r.top() + 1);
 
917
                p->setPen( cg.light() );
 
918
                p->drawLine(r.left() + 12,  r.top() + 2,
 
919
                            r.right() - 12, r.top() + 2);
 
920
                break;
 
921
            }
 
922
 
 
923
            if (flags & Style_Active)
 
924
                qDrawShadePanel(p, r, cg, true, 1,
 
925
                                &cg.brush(QPalette::Midlight));
 
926
             else if ( widget->erasePixmap() && !widget->erasePixmap()->isNull() )
 
927
                p->drawPixmap( r.topLeft(), *widget->erasePixmap(), r );
 
928
            else
 
929
                p->fillRect(r, cg.brush(QPalette::Button));
 
930
 
 
931
            if ( !mi )
 
932
                break;
 
933
 
 
934
            maxpmw = qMax(maxpmw, 16);
 
935
 
 
936
            QRect cr, ir, tr, sr;
 
937
            // check column
 
938
            cr.setRect(r.left(), r.top(), maxpmw, r.height());
 
939
            // submenu indicator column
 
940
            sr.setCoords(r.right() - maxpmw, r.top(), r.right(), r.bottom());
 
941
            // tab/accelerator column
 
942
            tr.setCoords(sr.left() - tab - 4, r.top(), sr.left(), r.bottom());
 
943
            // item column
 
944
            ir.setCoords(cr.right() + 4, r.top(), tr.right() - 4, r.bottom());
 
945
 
 
946
            bool reverse = QApplication::isRightToLeft();
 
947
            if ( reverse ) {
 
948
                cr = visualRect( cr, r );
 
949
                sr = visualRect( sr, r );
 
950
                tr = visualRect( tr, r );
 
951
                ir = visualRect( ir, r );
 
952
            }
 
953
 
 
954
            if (mi->isChecked() &&
 
955
                ! (flags & Style_Active) &
 
956
                (flags & Style_Enabled))
 
957
                qDrawShadePanel(p, cr, cg, true, 1, &cg.brush(QPalette::Midlight));
 
958
 
 
959
            if (mi->iconSet()) {
 
960
                QIcon::Mode mode =
 
961
                    (flags & Style_Enabled) ? QIcon::Normal : QIcon::Disabled;
 
962
                if ((flags & Style_Active) && (flags & Style_Enabled))
 
963
                    mode = QIcon::Active;
 
964
                QPixmap pixmap;
 
965
                if (popupmenu->isCheckable() && mi->isChecked())
 
966
                    pixmap =
 
967
                        mi->iconSet()->pixmap( QIcon::Small, mode, QIcon::On );
 
968
                else
 
969
                    pixmap =
 
970
                        mi->iconSet()->pixmap( QIcon::Small, mode );
 
971
                QRect pmr(QPoint(0, 0), pixmap.size());
 
972
                pmr.moveCenter(cr.center());
 
973
                p->setPen(cg.text());
 
974
                p->drawPixmap(pmr.topLeft(), pixmap);
 
975
            } else if (popupmenu->isCheckable() && mi->isChecked())
 
976
                drawPrimitive(PE_CheckMark, p, cr, cg,
 
977
                              (flags & Style_Enabled) | Style_On);
 
978
 
 
979
            QColor textcolor;
 
980
            QColor embosscolor;
 
981
            if (flags & Style_Active) {
 
982
                if (! (flags & Style_Enabled))
 
983
                    textcolor = cg.midlight().dark();
 
984
                else
 
985
                    textcolor = cg.buttonText();
 
986
                embosscolor = cg.midlight().light();
 
987
            } else if (! (flags & Style_Enabled)) {
 
988
                textcolor = cg.text();
 
989
                embosscolor = cg.light();
 
990
            } else
 
991
                textcolor = embosscolor = cg.buttonText();
 
992
            p->setPen(textcolor);
 
993
 
 
994
            if (mi->custom()) {
 
995
                p->save();
 
996
                if (! (flags & Style_Enabled)) {
 
997
                    p->setPen(cg.light());
 
998
                    mi->custom()->paint(p, cg, flags & Style_Active,
 
999
                                        flags & Style_Enabled,
 
1000
                                        ir.x() + 1, ir.y() + 1,
 
1001
                                        ir.width() - 1, ir.height() - 1);
 
1002
                    p->setPen(textcolor);
 
1003
                }
 
1004
                mi->custom()->paint(p, cg, flags & Style_Active,
 
1005
                                    flags & Style_Enabled,
 
1006
                                    ir.x(), ir.y(),
 
1007
                                    ir.width(), ir.height());
 
1008
                p->restore();
 
1009
            }
 
1010
 
 
1011
            QString text = mi->text();
 
1012
            if (! text.isNull()) {
 
1013
                int t = text.find('\t');
 
1014
 
 
1015
                // draw accelerator/tab-text
 
1016
                if (t >= 0) {
 
1017
                    int alignFlag = Qt::AlignVCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine;
 
1018
                    alignFlag |= ( reverse ? Qt::AlignLeft : Qt::AlignRight );
 
1019
                    if (! (flags & Style_Enabled)) {
 
1020
                        p->setPen(embosscolor);
 
1021
                        tr.translate(1, 1);
 
1022
                        p->drawText(tr, alignFlag, text.mid(t + 1));
 
1023
                        tr.translate(-1, -1);
 
1024
                        p->setPen(textcolor);
 
1025
                    }
 
1026
 
 
1027
                    p->drawText(tr, alignFlag, text.mid(t + 1));
 
1028
                }
 
1029
 
 
1030
                int alignFlag = Qt::AlignVCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine;
 
1031
                alignFlag |= ( reverse ? Qt::AlignRight : Qt::AlignLeft );
 
1032
 
 
1033
                if (! (flags & Style_Enabled)) {
 
1034
                    p->setPen(embosscolor);
 
1035
                    ir.translate(1, 1);
 
1036
                    p->drawText(ir, alignFlag, text, t);
 
1037
                    ir.translate(-1, -1);
 
1038
                    p->setPen(textcolor);
 
1039
                }
 
1040
 
 
1041
                p->drawText(ir, alignFlag, text, t);
 
1042
            } else if (mi->pixmap()) {
 
1043
                QPixmap pixmap = *mi->pixmap();
 
1044
                if (pixmap.depth() == 1)
 
1045
                    p->setBackgroundMode(Qt::OpaqueMode);
 
1046
                p->drawPixmap(ir.x(), ir.y() + (ir.height() - pixmap.height()) / 2, pixmap);
 
1047
                if (pixmap.depth() == 1)
 
1048
                    p->setBackgroundMode(Qt::TransparentMode);
 
1049
            }
 
1050
 
 
1051
            if (mi->popup())
 
1052
                drawPrimitive( (QApplication::isRightToLeft() ? PE_ArrowLeft : PE_ArrowRight),
 
1053
                               p, sr, cg, flags);
 
1054
            break;
 
1055
        }
 
1056
 
 
1057
    case CE_MenuBarEmptyArea:
 
1058
        {
 
1059
            p->fillRect(r, cg.brush(QPalette::Button));
 
1060
            break;
 
1061
        }
 
1062
 
 
1063
    case CE_MenuBarItem:
 
1064
        {
 
1065
            if ( flags & Style_Active )
 
1066
                qDrawShadePanel(p, r, cg, true, 1, &cg.brush(QPalette::Midlight));
 
1067
            else
 
1068
                p->fillRect( r, cg.brush( QPalette::Button ) );
 
1069
 
 
1070
            if (data.isDefault())
 
1071
                break;
 
1072
 
 
1073
            QMenuItem *mi = data.menuItem();
 
1074
            drawItem(p, r, Qt::AlignCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine, cg,
 
1075
                     flags & Style_Enabled, mi->pixmap(), mi->text(), -1,
 
1076
                     &cg.buttonText());
 
1077
            break;
 
1078
        }
 
1079
 
 
1080
    case CE_ProgressBarGroove:
 
1081
        drawLightBevel( p, r, cg, Style_Sunken, pixelMetric( PM_DefaultFrameWidth ),
 
1082
                        true, true, &cg.brush( QPalette::Background ) );
 
1083
        break;
 
1084
 
 
1085
    default:
 
1086
        QCommonStyle::drawControl(control, p, widget, r, cg, flags, data);
 
1087
        break;
 
1088
    }
 
1089
}
 
1090
 
 
1091
void LightStyleV3::drawControlMask( ControlElement control,
 
1092
                                  QPainter *p,
 
1093
                                  const QWidget *widget,
 
1094
                                  const QRect &r,
 
1095
                                  const QStyleOption &data ) const
 
1096
{
 
1097
    switch (control) {
 
1098
    case CE_PushButton:
 
1099
        p->fillRect(r, Qt::color1);
 
1100
        break;
 
1101
 
 
1102
    default:
 
1103
        QCommonStyle::drawControlMask(control, p, widget, r, data);
 
1104
        break;
 
1105
    }
 
1106
}
 
1107
 
 
1108
QRect LightStyleV3::subElementRect(SubElement subelement, const QWidget *widget) const
 
1109
{
 
1110
    QRect rect;
 
1111
 
 
1112
    switch (subelement) {
 
1113
    case SR_PushButtonFocusRect:
 
1114
        {
 
1115
            rect = QCommonStyle::subElementRect( SR_PushButtonContents, widget );
 
1116
            int bm = pixelMetric( PM_ButtonMargin, widget ), hbm = bm / 2;
 
1117
            rect.adjust( hbm, hbm, -hbm, -hbm );
 
1118
            break;
 
1119
        }
 
1120
 
 
1121
    case SR_ComboBoxFocusRect:
 
1122
        {
 
1123
            rect = QCommonStyle::subElementRect( SR_ComboBoxFocusRect, widget );
 
1124
            rect.adjust( -1, -1, 1, 1 );
 
1125
            break;
 
1126
        }
 
1127
 
 
1128
        case SR_CheckBoxFocusRect:
 
1129
        {
 
1130
                const QCheckBox* cb = static_cast<const QCheckBox*>(widget);
 
1131
 
 
1132
                //Only checkbox, no label
 
1133
                if (cb->text().isEmpty() && (cb->pixmap() == 0) )
 
1134
                {
 
1135
                        QRect bounding = cb->rect();
 
1136
                        QRect checkbox(bounding.x(), bounding.y() + (bounding.height() - 13)/2,
 
1137
                                                        13, 13);
 
1138
 
 
1139
                        return checkbox;
 
1140
                }
 
1141
                //Fallthrough intentional
 
1142
        }
 
1143
 
 
1144
 
 
1145
    default:
 
1146
        rect = QCommonStyle::subElementRect(subelement, widget);
 
1147
        break;
 
1148
    }
 
1149
 
 
1150
    return rect;
 
1151
}
 
1152
 
 
1153
void LightStyleV3::drawComplexControl( ComplexControl control,
 
1154
                                     QPainter* p,
 
1155
                                     const QWidget* widget,
 
1156
                                     const QRect& r,
 
1157
                                     const QColorGroup& cg,
 
1158
                                     SFlags flags,
 
1159
                                     SCFlags controls,
 
1160
                                     SCFlags active,
 
1161
                                     const QStyleOption &data ) const
 
1162
{
 
1163
    switch (control) {
 
1164
    case CC_ComboBox:
 
1165
        {
 
1166
            const QComboBox *combobox = (const QComboBox *) widget;
 
1167
            QRect frame, arrow, field;
 
1168
            frame =
 
1169
                QStyle::visualRect(querySubControlMetrics(CC_ComboBox, widget,
 
1170
                                                          SC_ComboBoxFrame, data),
 
1171
                                   widget);
 
1172
            arrow =
 
1173
                QStyle::visualRect(querySubControlMetrics(CC_ComboBox, widget,
 
1174
                                                          SC_ComboBoxArrow, data),
 
1175
                                   widget);
 
1176
            field =
 
1177
                QStyle::visualRect(querySubControlMetrics(CC_ComboBox, widget,
 
1178
                                                          SC_ComboBoxEditField, data),
 
1179
                                   widget);
 
1180
 
 
1181
            if ((controls & SC_ComboBoxFrame) && frame.isValid())
 
1182
                drawPrimitive( PE_Panel, p, frame, cg, flags | Style_Sunken );
 
1183
 
 
1184
            if ((controls & SC_ComboBoxArrow) && arrow.isValid()) {
 
1185
                drawLightEtch( p, arrow, cg.button(), ( active == SC_ComboBoxArrow ) );
 
1186
                arrow.adjust( 1, 1, -1, -1 );
 
1187
                p->fillRect( arrow, cg.brush( QPalette::Button ) );
 
1188
                arrow.adjust(3, 1, -1, -1);
 
1189
                drawPrimitive(PE_ArrowDown, p, arrow, cg, flags);
 
1190
            }
 
1191
 
 
1192
            if ((controls & SC_ComboBoxEditField) && field.isValid()) {
 
1193
                if (flags & Style_HasFocus) {
 
1194
                    if (! combobox->editable()) {
 
1195
                        QRect fr =
 
1196
                            QStyle::visualRect( subRect( SR_ComboBoxFocusRect, widget ),
 
1197
                                                widget );
 
1198
                        p->fillRect( fr, cg.brush( QPalette::Highlight ) );
 
1199
                        drawPrimitive( PE_FocusRect, p, fr, cg,
 
1200
                                       flags | Style_FocusAtBorder,
 
1201
                                       QStyleOption(cg.highlight()));
 
1202
                    }
 
1203
 
 
1204
                    p->setPen(cg.highlightedText());
 
1205
                } else {
 
1206
                    p->fillRect( field, ( ( flags & Style_Enabled ) ?
 
1207
                                          cg.brush( QPalette::Base ) :
 
1208
                                          cg.brush( QPalette::Background ) ) );
 
1209
                    p->setPen( cg.text() );
 
1210
                }
 
1211
            }
 
1212
 
 
1213
            break;
 
1214
        }
 
1215
 
 
1216
    case CC_SpinWidget:
 
1217
        {
 
1218
            const Q3SpinWidget *spinwidget = (const Q3SpinWidget *) widget;
 
1219
            QRect frame, up, down;
 
1220
 
 
1221
            frame = querySubControlMetrics(CC_SpinWidget, widget,
 
1222
                                           SC_SpinWidgetFrame, data);
 
1223
            up = spinwidget->upRect();
 
1224
            down = spinwidget->downRect();
 
1225
 
 
1226
            if ((controls & SC_SpinWidgetFrame) && frame.isValid())
 
1227
                drawPrimitive( PE_Panel, p, frame, cg, flags | Style_Sunken );
 
1228
 
 
1229
            if ((controls & SC_SpinWidgetUp) && up.isValid()) {
 
1230
                PrimitiveElement pe = PE_SpinWidgetUp;
 
1231
                if ( spinwidget->buttonSymbols() == Q3SpinWidget::PlusMinus )
 
1232
                    pe = PE_SpinWidgetPlus;
 
1233
 
 
1234
                p->setPen( cg.background() );
 
1235
                p->drawLine( up.topLeft(), up.bottomLeft() );
 
1236
 
 
1237
                up.adjust( 1, 0, 0, 0 );
 
1238
                p->fillRect( up, cg.brush( QPalette::Button ) );
 
1239
                drawLightEtch( p, up, cg.button(), ( active == SC_SpinWidgetUp ) );
 
1240
 
 
1241
                up.addCoords( 1, 0, 0, 0 );
 
1242
                drawPrimitive(pe, p, up, cg, flags |
 
1243
                              ((active == SC_SpinWidgetUp) ?
 
1244
                               Style_On | Style_Sunken : Style_Raised));
 
1245
            }
 
1246
 
 
1247
            if ((controls & SC_SpinWidgetDown) && down.isValid()) {
 
1248
                PrimitiveElement pe = PE_SpinWidgetDown;
 
1249
                if ( spinwidget->buttonSymbols() == Q3SpinWidget::PlusMinus )
 
1250
                    pe = PE_SpinWidgetMinus;
 
1251
 
 
1252
                p->setPen( cg.background() );
 
1253
                p->drawLine( down.topLeft(), down.bottomLeft() );
 
1254
 
 
1255
                down.adjust( 1, 0, 0, 0 );
 
1256
                p->fillRect( down, cg.brush( QPalette::Button ) );
 
1257
                drawLightEtch( p, down, cg.button(), ( active == SC_SpinWidgetDown ) );
 
1258
 
 
1259
                down.adjust( 1, 0, 0, 0 );
 
1260
                drawPrimitive(pe, p, down, cg, flags |
 
1261
                              ((active == SC_SpinWidgetDown) ?
 
1262
                               Style_On | Style_Sunken : Style_Raised));
 
1263
            }
 
1264
 
 
1265
            break;
 
1266
        }
 
1267
 
 
1268
    case CC_ScrollBar:
 
1269
        {
 
1270
            const QScrollBar *scrollbar = (const QScrollBar *) widget;
 
1271
            QRect addline, subline, subline2, addpage, subpage, slider, first, last;
 
1272
            bool maxedOut = (scrollbar->minValue() == scrollbar->maxValue());
 
1273
 
 
1274
            subline = querySubControlMetrics(control, widget, SC_ScrollBarSubLine, data);
 
1275
            addline = querySubControlMetrics(control, widget, SC_ScrollBarAddLine, data);
 
1276
            subpage = querySubControlMetrics(control, widget, SC_ScrollBarSubPage, data);
 
1277
            addpage = querySubControlMetrics(control, widget, SC_ScrollBarAddPage, data);
 
1278
            slider  = querySubControlMetrics(control, widget, SC_ScrollBarSlider,  data);
 
1279
            first   = querySubControlMetrics(control, widget, SC_ScrollBarFirst,   data);
 
1280
            last    = querySubControlMetrics(control, widget, SC_ScrollBarLast,    data);
 
1281
 
 
1282
            subline2 = addline;
 
1283
            if (scrollbar->orientation() == Qt::Horizontal)
 
1284
                subline2.translate(-addline.width(), 0);
 
1285
            else
 
1286
                subline2.translate(0, -addline.height());
 
1287
 
 
1288
            if ((controls & SC_ScrollBarSubLine) && subline.isValid()) {
 
1289
                drawPrimitive(PE_ScrollBarSubLine, p, subline, cg,
 
1290
                              Style_Enabled | ((active == SC_ScrollBarSubLine) ?
 
1291
                                               Style_Down : Style_Default) |
 
1292
                              ((scrollbar->orientation() == Qt::Horizontal) ?
 
1293
                               Style_Horizontal : 0));
 
1294
 
 
1295
                if (subline2.isValid())
 
1296
                    drawPrimitive(PE_ScrollBarSubLine, p, subline2, cg,
 
1297
                                  Style_Enabled | ((active == SC_ScrollBarSubLine) ?
 
1298
                                                   Style_Down : Style_Default) |
 
1299
                                  ((scrollbar->orientation() == Qt::Horizontal) ?
 
1300
                                   Style_Horizontal : 0));
 
1301
            }
 
1302
            if ((controls & SC_ScrollBarAddLine) && addline.isValid())
 
1303
                drawPrimitive(PE_ScrollBarAddLine, p, addline, cg,
 
1304
                              Style_Enabled | ((active == SC_ScrollBarAddLine) ?
 
1305
                                               Style_Down : Style_Default) |
 
1306
                              ((scrollbar->orientation() == Qt::Horizontal) ?
 
1307
                               Style_Horizontal : 0));
 
1308
            if ((controls & SC_ScrollBarSubPage) && subpage.isValid())
 
1309
                drawPrimitive(PE_ScrollBarSubPage, p, subpage, cg,
 
1310
                              Style_Enabled | ((active == SC_ScrollBarSubPage) ?
 
1311
                                               Style_Down : Style_Default) |
 
1312
                              ((scrollbar->orientation() == Qt::Horizontal) ?
 
1313
                               Style_Horizontal : 0));
 
1314
            if ((controls & SC_ScrollBarAddPage) && addpage.isValid())
 
1315
                drawPrimitive(PE_ScrollBarAddPage, p, addpage, cg,
 
1316
                              ((maxedOut) ? Style_Default : Style_Enabled) |
 
1317
                              ((active == SC_ScrollBarAddPage) ?
 
1318
                               Style_Down : Style_Default) |
 
1319
                              ((scrollbar->orientation() == Qt::Horizontal) ?
 
1320
                               Style_Horizontal : 0));
 
1321
            if ((controls & SC_ScrollBarFirst) && first.isValid())
 
1322
                drawPrimitive(PE_ScrollBarFirst, p, first, cg,
 
1323
                              Style_Enabled | ((active == SC_ScrollBarFirst) ?
 
1324
                                               Style_Down : Style_Default) |
 
1325
                              ((scrollbar->orientation() == Qt::Horizontal) ?
 
1326
                               Style_Horizontal : 0));
 
1327
            if ((controls & SC_ScrollBarLast) && last.isValid())
 
1328
                drawPrimitive(PE_ScrollBarLast, p, last, cg,
 
1329
                              Style_Enabled | ((active == SC_ScrollBarLast) ?
 
1330
                                               Style_Down : Style_Default) |
 
1331
                              ((scrollbar->orientation() == Qt::Horizontal) ?
 
1332
                               Style_Horizontal : 0));
 
1333
            if ((controls & SC_ScrollBarSlider) && slider.isValid()) {
 
1334
                drawPrimitive(PE_ScrollBarSlider, p, slider, cg,
 
1335
                              Style_Enabled | ((active == SC_ScrollBarSlider) ?
 
1336
                                               Style_Down : Style_Default) |
 
1337
                              ((scrollbar->orientation() == Qt::Horizontal) ?
 
1338
                               Style_Horizontal : 0));
 
1339
 
 
1340
                // ### perhaps this should not be able to accept focus if maxedOut?
 
1341
                if (scrollbar->hasFocus()) {
 
1342
                    QRect fr(slider.x() + 2, slider.y() + 2,
 
1343
                             slider.width() - 5, slider.height() - 5);
 
1344
                    drawPrimitive(PE_FocusRect, p, fr, cg, Style_Default);
 
1345
                }
 
1346
            }
 
1347
 
 
1348
            break;
 
1349
        }
 
1350
 
 
1351
    case CC_Slider:
 
1352
        {
 
1353
            const QSlider *slider = (const QSlider *) widget;
 
1354
            QRect groove = querySubControlMetrics(CC_Slider, widget, SC_SliderGroove,
 
1355
                                                  data),
 
1356
                  handle = querySubControlMetrics(CC_Slider, widget, SC_SliderHandle,
 
1357
                                                  data);
 
1358
 
 
1359
            if ((controls & SC_SliderGroove) && groove.isValid()) {
 
1360
                QColor grooveColor = cg.midlight();
 
1361
                if (!(flags & Style_Enabled))
 
1362
                    grooveColor = cg.background();
 
1363
 
 
1364
 
 
1365
                QBrush brush(grooveColor);
 
1366
                drawLightBevel( p, groove, cg,
 
1367
                                ( ( flags | Style_Raised ) ^ Style_Raised ) |
 
1368
                                ( ( flags & Style_Enabled ) ? Style_Sunken :
 
1369
                                  Style_Default ), 2, true, true,
 
1370
                                &brush );
 
1371
                groove.adjust( 2, 2, -2, -2 );
 
1372
                drawLightEtch( p, groove, grooveColor, false );
 
1373
 
 
1374
                if (flags & Style_HasFocus) {
 
1375
                    groove.adjust( -2, -2, 2, 2 );
 
1376
                    drawPrimitive( PE_FocusRect, p, groove, cg, flags );
 
1377
                }
 
1378
            }
 
1379
 
 
1380
            if ((controls & SC_SliderHandle) && handle.isValid()) {
 
1381
                QColor sliderColor = cg.highlight();
 
1382
                if (!(flags & Style_Enabled))
 
1383
                    sliderColor = cg.button();
 
1384
 
 
1385
                p->setPen( sliderColor.light() );
 
1386
 
 
1387
                p->drawLine( handle.topLeft(), handle.topRight() );
 
1388
                p->drawLine( handle.left(), handle.top() + 1,
 
1389
                             handle.left(), handle.bottom() - 1 );
 
1390
                p->setPen( sliderColor.dark() );
 
1391
                p->drawLine( handle.left(), handle.bottom(),
 
1392
                             handle.right() - 1, handle.bottom() );
 
1393
                p->drawLine( handle.topRight(), handle.bottomRight() );
 
1394
                handle.adjust( 1, 1, -1, -1 );
 
1395
                p->fillRect( handle, sliderColor );
 
1396
                p->setPen( cg.midlight() );
 
1397
 
 
1398
                if ( slider->orientation() == Qt::Horizontal )
 
1399
                    p->drawLine( handle.left() + handle.width() / 2,
 
1400
                                 handle.top() + 1,
 
1401
                                 handle.left() + handle.width() / 2,
 
1402
                                 handle.bottom() - 1 );
 
1403
                else
 
1404
                    p->drawLine( handle.left() + 1,
 
1405
                                 handle.top() + handle.height() / 2,
 
1406
                                 handle.right() - 1,
 
1407
                                 handle.top() + handle.height() / 2 );
 
1408
            }
 
1409
 
 
1410
            if (controls & SC_SliderTickmarks)
 
1411
                QCommonStyle::drawComplexControl(control, p, widget, r, cg, flags,
 
1412
                                                 SC_SliderTickmarks, active, data );
 
1413
            break;
 
1414
        }
 
1415
 
 
1416
    case CC_ListView:
 
1417
        // use the base style for CC_ListView
 
1418
        basestyle->drawComplexControl(control, p, widget, r, cg, flags,
 
1419
                                      controls, active, data);
 
1420
        break;
 
1421
 
 
1422
    default:
 
1423
        QCommonStyle::drawComplexControl(control, p, widget, r, cg, flags,
 
1424
                                      controls, active, data);
 
1425
        break;
 
1426
    }
 
1427
}
 
1428
 
 
1429
QRect LightStyleV3::querySubControlMetrics( ComplexControl control,
 
1430
                                          const QWidget *widget,
 
1431
                                          SubControl sc,
 
1432
                                          const QStyleOption &data ) const
 
1433
{
 
1434
    QRect ret;
 
1435
 
 
1436
    switch (control) {
 
1437
    case CC_ComboBox:
 
1438
        {
 
1439
            int fw = pixelMetric( PM_DefaultFrameWidth, widget );
 
1440
            int sb = pixelMetric( PM_ScrollBarExtent ); // width of the arrow
 
1441
 
 
1442
            switch ( sc ) {
 
1443
            case SC_ComboBoxFrame:
 
1444
                ret = widget->rect();
 
1445
                break;
 
1446
            case SC_ComboBoxArrow:
 
1447
                ret.setRect( widget->width() - fw - sb, fw,
 
1448
                             sb, widget->height() - fw*2 );
 
1449
                break;
 
1450
            case SC_ComboBoxEditField:
 
1451
                ret.setRect( fw, fw, widget->width() - fw*2 - sb - 1,
 
1452
                             widget->height() - fw*2 );
 
1453
                break;
 
1454
            default:
 
1455
                break;
 
1456
            }
 
1457
 
 
1458
            break;
 
1459
        }
 
1460
 
 
1461
    case CC_ScrollBar:
 
1462
        {
 
1463
            const QScrollBar *scrollbar = (const QScrollBar *) widget;
 
1464
            int sliderstart = scrollbar->sliderStart();
 
1465
            int sbextent = pixelMetric(PM_ScrollBarExtent, widget);
 
1466
            int maxlen = ((scrollbar->orientation() == Qt::Horizontal) ?
 
1467
                          scrollbar->width() : scrollbar->height()) - (sbextent * 3);
 
1468
            int sliderlen;
 
1469
 
 
1470
            // calculate slider length
 
1471
            if (scrollbar->maxValue() != scrollbar->minValue()) {
 
1472
                uint range = scrollbar->maxValue() - scrollbar->minValue();
 
1473
                sliderlen = (scrollbar->pageStep() * maxlen) /
 
1474
                            (range + scrollbar->pageStep());
 
1475
 
 
1476
                int slidermin = pixelMetric( PM_ScrollBarSliderMin, widget );
 
1477
                if ( sliderlen < slidermin || range > INT_MAX / 2 )
 
1478
                    sliderlen = slidermin;
 
1479
                if ( sliderlen > maxlen )
 
1480
                    sliderlen = maxlen;
 
1481
            } else
 
1482
                sliderlen = maxlen;
 
1483
 
 
1484
            switch (sc) {
 
1485
            case SC_ScrollBarSubLine:
 
1486
                // top/left button
 
1487
                ret.setRect(0, 0, sbextent, sbextent);
 
1488
                break;
 
1489
 
 
1490
            case SC_ScrollBarAddLine:
 
1491
                // bottom/right button
 
1492
                if (scrollbar->orientation() == Qt::Horizontal)
 
1493
                    ret.setRect(scrollbar->width() - sbextent, 0, sbextent, sbextent);
 
1494
                else
 
1495
                    ret.setRect(0, scrollbar->height() - sbextent, sbextent, sbextent);
 
1496
                break;
 
1497
 
 
1498
            case SC_ScrollBarSubPage:
 
1499
                // between top/left button and slider
 
1500
                if (scrollbar->orientation() == Qt::Horizontal)
 
1501
                    ret.setRect(sbextent, 0, sliderstart - sbextent, sbextent);
 
1502
                else
 
1503
                    ret.setRect(0, sbextent, sbextent, sliderstart - sbextent);
 
1504
                break;
 
1505
 
 
1506
            case SC_ScrollBarAddPage:
 
1507
                // between bottom/right button and slider
 
1508
                if (scrollbar->orientation() == Qt::Horizontal)
 
1509
                    ret.setRect(sliderstart + sliderlen, 0, maxlen - sliderstart -
 
1510
                                sliderlen + sbextent, sbextent);
 
1511
                else
 
1512
                    ret.setRect(0, sliderstart + sliderlen, sbextent, maxlen -
 
1513
                                sliderstart - sliderlen + sbextent);
 
1514
                break;
 
1515
 
 
1516
            case SC_ScrollBarGroove:
 
1517
                if (scrollbar->orientation() == Qt::Horizontal)
 
1518
                    ret.setRect(sbextent, 0, maxlen, sbextent );
 
1519
                else
 
1520
                    ret.setRect(0, sbextent, sbextent, maxlen );
 
1521
                break;
 
1522
 
 
1523
            case SC_ScrollBarSlider:
 
1524
                if (scrollbar->orientation() == Qt::Horizontal)
 
1525
                    ret.setRect(sliderstart, 0, sliderlen, sbextent);
 
1526
                else
 
1527
                    ret.setRect(0, sliderstart, sbextent, sliderlen);
 
1528
                break;
 
1529
 
 
1530
            default:
 
1531
                break;
 
1532
            }
 
1533
 
 
1534
            break;
 
1535
        }
 
1536
 
 
1537
    case CC_Slider:
 
1538
        {
 
1539
            const QSlider *slider = (const QSlider *) widget;
 
1540
            int tickOffset = pixelMetric( PM_SliderTickmarkOffset, widget );
 
1541
            int thickness = pixelMetric( PM_SliderControlThickness, widget );
 
1542
 
 
1543
            switch ( sc ) {
 
1544
            case SC_SliderGroove:
 
1545
                if ( slider->orientation() == Qt::Horizontal )
 
1546
                    ret.setRect( 0, tickOffset, slider->width(), thickness );
 
1547
                else
 
1548
                    ret.setRect( tickOffset, 0, thickness, slider->height() );
 
1549
                break;
 
1550
 
 
1551
            case SC_SliderHandle:
 
1552
                {
 
1553
                    int pos = slider->sliderStart();
 
1554
                    int len = pixelMetric( PM_SliderLength, widget );
 
1555
 
 
1556
                    if ( slider->orientation() == Qt::Horizontal )
 
1557
                        ret.setRect( pos + 2, tickOffset + 2, len - 4, thickness - 4 );
 
1558
                    else
 
1559
                        ret.setRect( tickOffset + 2, pos + 2, thickness - 4, len - 4 );
 
1560
                    break;
 
1561
                }
 
1562
 
 
1563
            default:
 
1564
                ret = QCommonStyle::querySubControlMetrics(control, widget, sc, data);
 
1565
                break;
 
1566
            }
 
1567
 
 
1568
            break;
 
1569
        }
 
1570
 
 
1571
    default:
 
1572
        ret = QCommonStyle::querySubControlMetrics(control, widget, sc, data);
 
1573
        break;
 
1574
    }
 
1575
 
 
1576
    return ret;
 
1577
}
 
1578
 
 
1579
QStyle::SubControl LightStyleV3::querySubControl( ComplexControl control,
 
1580
                                                const QWidget *widget,
 
1581
                                                const QPoint &pos,
 
1582
                                                const QStyleOption &data ) const
 
1583
{
 
1584
    QStyle::SubControl ret =
 
1585
        QCommonStyle::querySubControl(control, widget, pos, data);
 
1586
 
 
1587
    // this is an ugly hack, but i really don't care, it's the quickest way to
 
1588
    // enabled the third button
 
1589
    if (control == CC_ScrollBar &&
 
1590
        ret == SC_None)
 
1591
        ret = SC_ScrollBarSubLine;
 
1592
 
 
1593
    return ret;
 
1594
}
 
1595
 
 
1596
int LightStyleV3::pixelMetric( PixelMetric metric,
 
1597
                             const QWidget *widget ) const
 
1598
{
 
1599
    int ret;
 
1600
 
 
1601
    switch (metric) {
 
1602
    case PM_ButtonMargin:
 
1603
        ret = 6;
 
1604
        break;
 
1605
 
 
1606
    case PM_ButtonShiftHorizontal:
 
1607
    case PM_ButtonShiftVertical:
 
1608
        ret = 0;
 
1609
        break;
 
1610
 
 
1611
    case PM_ButtonDefaultIndicator:
 
1612
        ret = 0;
 
1613
        break;
 
1614
 
 
1615
    case PM_DefaultFrameWidth:
 
1616
        ret = 2;
 
1617
        break;
 
1618
 
 
1619
    case PM_IndicatorWidth:
 
1620
    case PM_IndicatorHeight:
 
1621
    case PM_ExclusiveIndicatorWidth:
 
1622
    case PM_ExclusiveIndicatorHeight:
 
1623
        ret = 13;
 
1624
        break;
 
1625
 
 
1626
    case PM_TabBarTabOverlap:
 
1627
    case PM_TabBarBaseOverlap:
 
1628
        ret = 0;
 
1629
        break;
 
1630
 
 
1631
    case PM_ScrollBarExtent:
 
1632
    case PM_ScrollBarSliderMin:
 
1633
        ret = 15;
 
1634
        break;
 
1635
 
 
1636
    case PM_MenuBarFrameWidth:
 
1637
        ret = 1;
 
1638
        break;
 
1639
 
 
1640
    case PM_ProgressBarChunkWidth:
 
1641
        ret = 1;
 
1642
        break;
 
1643
 
 
1644
    case PM_DockWindowHandleExtent:
 
1645
        ret = 8;
 
1646
        break;
 
1647
 
 
1648
    case PM_DockWindowSeparatorExtent:
 
1649
        ret = 8;
 
1650
        break;
 
1651
 
 
1652
    case PM_SplitterWidth:
 
1653
        ret = 8;
 
1654
        break;
 
1655
 
 
1656
    case PM_SliderLength:
 
1657
        ret = 25;
 
1658
        break;
 
1659
 
 
1660
    case PM_SliderThickness:
 
1661
        ret = 11;
 
1662
        break;
 
1663
 
 
1664
    case PM_SliderControlThickness:
 
1665
        {
 
1666
            const QSlider * sl = (const QSlider *) widget;
 
1667
            int space = (sl->orientation() == Qt::Horizontal) ? sl->height()
 
1668
                        : sl->width();
 
1669
            int ticks = sl->tickmarks();
 
1670
            int n = 0;
 
1671
            if ( ticks & QSlider::TicksAbove ) n++;
 
1672
            if ( ticks & QSlider::TicksBelow ) n++;
 
1673
            if ( !n ) {
 
1674
                ret = space;
 
1675
                break;
 
1676
            }
 
1677
 
 
1678
            int thick = 6;      // Magic constant to get 5 + 16 + 5
 
1679
 
 
1680
            space -= thick;
 
1681
            //### the two sides may be unequal in size
 
1682
            if ( space > 0 )
 
1683
                thick += (space * 2) / (n + 2);
 
1684
            ret = thick;
 
1685
            break;
 
1686
        }
 
1687
 
 
1688
   case PM_MaximumDragDistance:
 
1689
        ret = -1;
 
1690
        break;
 
1691
 
 
1692
    default:
 
1693
        ret = QCommonStyle::pixelMetric(metric, widget);
 
1694
        break;
 
1695
    }
 
1696
 
 
1697
    return ret;
 
1698
}
 
1699
 
 
1700
QSize LightStyleV3::sizeFromContents( ContentsType contents,
 
1701
                                    const QWidget *widget,
 
1702
                                    const QSize &contentsSize,
 
1703
                                    const QStyleOption &data ) const
 
1704
{
 
1705
    QSize ret;
 
1706
 
 
1707
    switch (contents) {
 
1708
    case CT_ComboBox:
 
1709
        {
 
1710
            int fw = pixelMetric( PM_DefaultFrameWidth, widget ) * 2;
 
1711
            int sb = pixelMetric( PM_ScrollBarExtent ); // width of the arrow
 
1712
            int w = contentsSize.width();
 
1713
            int h = contentsSize.height();
 
1714
 
 
1715
            w += fw + sb + 1;
 
1716
            h += fw;
 
1717
 
 
1718
            // try to keep a similar height to buttons
 
1719
            if ( h < 21 )
 
1720
                h = 21;
 
1721
 
 
1722
            ret = QSize( w, h );
 
1723
            break;
 
1724
        }
 
1725
 
 
1726
    case CT_PushButton:
 
1727
        {
 
1728
            const QPushButton *button = (const QPushButton *) widget;
 
1729
            ret = QCommonStyle::sizeFromContents( contents, widget, contentsSize, data );
 
1730
            int w = ret.width(), h = ret.height();
 
1731
            int dbi = pixelMetric( PM_ButtonDefaultIndicator, widget ) * 2;
 
1732
            int mw = 80 - dbi, mh = 25 - dbi;
 
1733
 
 
1734
            // only expand the button if we are displaying text...
 
1735
            if ( ! button->text().isEmpty() ) {
 
1736
                // button minimum size
 
1737
                if ( w < mw )
 
1738
                    w = mw;
 
1739
                if ( h < mh )
 
1740
                    h = mh;
 
1741
            }
 
1742
 
 
1743
            ret = QSize( w, h );
 
1744
            break;
 
1745
        }
 
1746
 
 
1747
    case CT_PopupMenuItem:
 
1748
        {
 
1749
            if (! widget || data.isDefault())
 
1750
                break;
 
1751
 
 
1752
            QMenuItem *mi = data.menuItem();
 
1753
            const QMenu *popupmenu = (const QMenu *) widget;
 
1754
            int maxpmw = data.maxIconWidth();
 
1755
            int w = contentsSize.width(), h = contentsSize.height();
 
1756
 
 
1757
            if (mi->custom()) {
 
1758
                w = mi->custom()->sizeHint().width();
 
1759
                h = mi->custom()->sizeHint().height();
 
1760
                if (! mi->custom()->fullSpan() && h < 22)
 
1761
                    h = 22;
 
1762
            } else if(mi->widget()) {
 
1763
            } else if (mi->isSeparator()) {
 
1764
                w = 10;
 
1765
                h = 4;
 
1766
            } else {
 
1767
                // check is at least 16x16
 
1768
                if (h < 16)
 
1769
                    h = 16;
 
1770
                if (mi->pixmap())
 
1771
                    h = qMax(h, mi->pixmap()->height());
 
1772
                else if (! mi->text().isNull())
 
1773
                    h = qMax(h, popupmenu->fontMetrics().height() + 2);
 
1774
                if (mi->iconSet() != 0)
 
1775
                    h = qMax(h, mi->iconSet()->pixmap(QIcon::Small,
 
1776
                                                      QIcon::Normal).height());
 
1777
                h += 2;
 
1778
            }
 
1779
 
 
1780
            // check | 4 pixels | item | 8 pixels | accel | 4 pixels | check
 
1781
 
 
1782
            // check is at least 16x16
 
1783
            maxpmw = qMax(maxpmw, 16);
 
1784
            w += (maxpmw * 2) + 8;
 
1785
 
 
1786
            if (! mi->text().isNull() && mi->text().find('\t') >= 0)
 
1787
                w += 8;
 
1788
 
 
1789
            ret = QSize(w, h);
 
1790
            break;
 
1791
        }
 
1792
        
 
1793
    case CT_ProgressBar:
 
1794
        {
 
1795
            const QProgressBar* pb = static_cast<const QProgressBar*>(widget);
 
1796
            
 
1797
            //If we have to display the indicator, and we do it on RHS, give some more room
 
1798
            //for it. This tries to match the logic and the spacing in SR_ProgressBarGroove/Contents
 
1799
            //sizing in QCommonStyle.
 
1800
            if (pb->percentageVisible() && 
 
1801
                (pb->indicatorFollowsStyle() || ! pb->centerIndicator()))
 
1802
            {
 
1803
                int addw = pb->fontMetrics().width("100%") + 6;
 
1804
                return QSize(contentsSize.width() + addw, contentsSize.height());
 
1805
            }
 
1806
            else
 
1807
                return contentsSize; //Otherwise leave unchanged
 
1808
            
 
1809
            break;
 
1810
        }    
 
1811
 
 
1812
    default:
 
1813
        ret = QCommonStyle::sizeFromContents(contents, widget, contentsSize, data);
 
1814
        break;
 
1815
    }
 
1816
 
 
1817
    return ret;
 
1818
}
 
1819
 
 
1820
int LightStyleV3::styleHint( StyleHint stylehint,
 
1821
                           const QWidget *widget,
 
1822
                           const QStyleOption &option,
 
1823
                           QStyleHintReturn* returnData ) const
 
1824
{
 
1825
    int ret;
 
1826
 
 
1827
    switch (stylehint) {
 
1828
    case SH_EtchDisabledText:
 
1829
    case SH_Slider_SnapToValue:
 
1830
    case SH_PrintDialog_RightAlignButtons:
 
1831
    case SH_FontDialog_SelectAssociatedText:
 
1832
    case SH_MenuBar_AltKeyNavigation:
 
1833
    case SH_MenuBar_MouseTracking:
 
1834
    case SH_PopupMenu_MouseTracking:
 
1835
    case SH_ComboBox_ListMouseTracking:
 
1836
    case SH_ScrollBar_MiddleClickAbsolutePosition:
 
1837
        ret = 1;
 
1838
        break;
 
1839
 
 
1840
    case SH_MainWindow_SpaceBelowMenuBar:
 
1841
        ret = 0;
 
1842
        break;
 
1843
 
 
1844
    case SH_ScrollBar_BackgroundMode:
 
1845
        ret = Qt::NoBackground;
 
1846
        break;
 
1847
 
 
1848
    default:
 
1849
        ret = QCommonStyle::styleHint(stylehint, widget, option, returnData);
 
1850
        break;
 
1851
    }
 
1852
 
 
1853
    return ret;
 
1854
}
 
1855
 
 
1856
QPixmap LightStyleV3::standardPixmap( StandardPixmap standardpixmap,
 
1857
                                   const QWidget *widget,
 
1858
                                   const QStyleOption &data ) const
 
1859
{
 
1860
    return basestyle->standardPixmap( standardpixmap, widget, data );
 
1861
}
 
1862
#include "lightstyle-v3.moc"