author | zecke <zecke> | 2004-08-02 18:32:18 (UTC) |
---|---|---|
committer | zecke <zecke> | 2004-08-02 18:32:18 (UTC) |
commit | d3cc020707bd4743cacd11f1d01d024b62deef8c (patch) (unidiff) | |
tree | c7a77113f852c3b53bd0bde1ac92a181cda22acb /noncore/styles/webstyle.cpp | |
parent | bef879b6de5bfba274c8e5ac2cebf14366db2826 (diff) | |
download | opie-d3cc020707bd4743cacd11f1d01d024b62deef8c.zip opie-d3cc020707bd4743cacd11f1d01d024b62deef8c.tar.gz opie-d3cc020707bd4743cacd11f1d01d024b62deef8c.tar.bz2 |
Initial revision
-rw-r--r-- | noncore/styles/webstyle.cpp | 1183 |
1 files changed, 1183 insertions, 0 deletions
diff --git a/noncore/styles/webstyle.cpp b/noncore/styles/webstyle.cpp new file mode 100644 index 0000000..10d9791 --- a/dev/null +++ b/noncore/styles/webstyle.cpp | |||
@@ -0,0 +1,1183 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2001 Rik Hemsley (rikkus) <rik@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 as published by the Free Software Foundation; either | ||
7 | * version 2 of the License, or (at your option) any later version. | ||
8 | * | ||
9 | * This library is distributed in the hope that it will be useful, | ||
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
12 | * Library General Public License for more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU Library General Public License | ||
15 | * along with this library; see the file COPYING.LIB. If not, write to | ||
16 | * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | ||
17 | * Boston, MA 02111-1307, USA. | ||
18 | */ | ||
19 | |||
20 | #ifndef INCLUDE_MENUITEM_DEF | ||
21 | #define INCLUDE_MENUITEM_DEF | ||
22 | #endif | ||
23 | |||
24 | #include <qmenudata.h> | ||
25 | #include <qpalette.h> | ||
26 | #include <qbitmap.h> | ||
27 | #include <qtabbar.h> | ||
28 | #include <qpointarray.h> | ||
29 | #include <qscrollbar.h> | ||
30 | #include <qframe.h> | ||
31 | #include <qpushbutton.h> | ||
32 | #include <qdrawutil.h> | ||
33 | #include <qpainter.h> | ||
34 | |||
35 | #include "webstyle.h" | ||
36 | |||
37 | static const int _indicatorSize = 13; | ||
38 | static QButton * _highlightedButton = 0; | ||
39 | static const int _scrollBarExtent = 12; | ||
40 | |||
41 | static QFrame * _currentFrame = 0; | ||
42 | static int _savedFrameLineWidth; | ||
43 | static int _savedFrameMidLineWidth; | ||
44 | static ulong _savedFrameStyle; | ||
45 | |||
46 | static QColor contrastingForeground(const QColor & fg, const QColor & bg) | ||
47 | { | ||
48 | int h, s, vbg, vfg; | ||
49 | |||
50 | bg.hsv(&h, &s, &vbg); | ||
51 | fg.hsv(&h, &s, &vfg); | ||
52 | |||
53 | int diff(vbg - vfg); | ||
54 | |||
55 | if ((diff > -72) && (diff < 72)) | ||
56 | { | ||
57 | return (vbg < 128) ? Qt::white : Qt::black; | ||
58 | } | ||
59 | else | ||
60 | { | ||
61 | return fg; | ||
62 | } | ||
63 | } | ||
64 | |||
65 | // Gotta keep it separated. | ||
66 | |||
67 | static void | ||
68 | scrollBarControlsMetrics | ||
69 | ( | ||
70 | const QScrollBar * sb, | ||
71 | int sliderStart, | ||
72 | int /* sliderMin */, | ||
73 | int sliderMax, | ||
74 | int sliderLength, | ||
75 | int buttonDim, | ||
76 | QRect & rSub, | ||
77 | QRect & rAdd, | ||
78 | QRect & rSubPage, | ||
79 | QRect & rAddPage, | ||
80 | QRect & rSlider | ||
81 | ) | ||
82 | { | ||
83 | bool horizontal = sb->orientation() == QScrollBar::Horizontal; | ||
84 | |||
85 | int len = horizontal ? sb->width() : sb->height(); | ||
86 | |||
87 | int extent = horizontal ? sb->height() : sb->width(); | ||
88 | |||
89 | QColorGroup g = sb->colorGroup(); | ||
90 | |||
91 | if (sliderStart > sliderMax) | ||
92 | sliderStart = sliderMax; | ||
93 | |||
94 | int sliderEnd = sliderStart + sliderLength; | ||
95 | |||
96 | int addX, addY; | ||
97 | int subX, subY; | ||
98 | int subPageX, subPageY, subPageW, subPageH; | ||
99 | int addPageX, addPageY, addPageW, addPageH; | ||
100 | int sliderX, sliderY, sliderW, sliderH; | ||
101 | |||
102 | if (horizontal) | ||
103 | { | ||
104 | subY = 0; | ||
105 | addY = 0; | ||
106 | subX = 0; | ||
107 | addX = buttonDim; | ||
108 | |||
109 | subPageX = buttonDim * 2; | ||
110 | subPageY = 0; | ||
111 | subPageW = sliderStart - 1; | ||
112 | subPageH = extent; | ||
113 | |||
114 | addPageX = sliderEnd; | ||
115 | addPageY = 0; | ||
116 | addPageW = len - sliderEnd; | ||
117 | addPageH = extent; | ||
118 | |||
119 | sliderX = sliderStart; | ||
120 | sliderY = 0; | ||
121 | sliderW = sliderLength; | ||
122 | sliderH = extent; | ||
123 | } | ||
124 | else | ||
125 | { | ||
126 | subX = 0; | ||
127 | addX = 0; | ||
128 | subY = len - buttonDim * 2; | ||
129 | addY = len - buttonDim; | ||
130 | |||
131 | subPageX = 0; | ||
132 | subPageY = 0; | ||
133 | subPageW = extent; | ||
134 | subPageH = sliderStart; | ||
135 | |||
136 | addPageX = 0; | ||
137 | addPageY = sliderEnd; | ||
138 | addPageW = extent; | ||
139 | addPageH = subY - sliderEnd; | ||
140 | |||
141 | sliderX = 0; | ||
142 | sliderY = sliderStart; | ||
143 | sliderW = extent; | ||
144 | sliderH = sliderLength; | ||
145 | } | ||
146 | |||
147 | rSub .setRect( subX, subY, buttonDim, buttonDim); | ||
148 | rAdd .setRect( addX, addY, buttonDim, buttonDim); | ||
149 | rSubPage .setRect(subPageX, subPageY, subPageW, subPageH); | ||
150 | rAddPage .setRect(addPageX, addPageY, addPageW, addPageH); | ||
151 | rSlider .setRect( sliderX, sliderY, sliderW, sliderH); | ||
152 | } | ||
153 | |||
154 | // Rounded rects my way. | ||
155 | |||
156 | static void | ||
157 | drawFunkyRect | ||
158 | ( | ||
159 | QPainter * p, | ||
160 | int x, | ||
161 | int y, | ||
162 | int w, | ||
163 | int h, | ||
164 | bool small | ||
165 | ) | ||
166 | { | ||
167 | p->translate(x, y); | ||
168 | |||
169 | if (small) | ||
170 | { | ||
171 | p->drawLine( 2, 0, w - 3, 0 ); | ||
172 | p->drawLine( w - 1, 2, w - 1, h - 3 ); | ||
173 | p->drawLine( w - 3, h - 1, 2, h - 1 ); | ||
174 | p->drawLine( 0, h - 3, 0, 2 ); | ||
175 | |||
176 | // Use an array of points so that there's only one round-trip with the | ||
177 | // X server. | ||
178 | |||
179 | QCOORD pointList[] = | ||
180 | { | ||
181 | 1, 1, | ||
182 | w - 2, 1, | ||
183 | w - 2, h - 2, | ||
184 | 1, h - 2 | ||
185 | }; | ||
186 | |||
187 | p->drawPoints(QPointArray(4, pointList)); | ||
188 | } | ||
189 | else | ||
190 | { | ||
191 | p->drawLine( 3, 0, w - 4, 0 ); | ||
192 | p->drawLine( w - 1, 3, w - 1, h - 4 ); | ||
193 | p->drawLine( w - 4, h - 1, 3, h - 1 ); | ||
194 | p->drawLine( 0, h - 4, 0, 3 ); | ||
195 | |||
196 | QCOORD pointList[] = | ||
197 | { | ||
198 | 1, 2, | ||
199 | 2, 1, | ||
200 | w - 3, 1, | ||
201 | w - 2, 2, | ||
202 | w - 2, h - 3, | ||
203 | w - 3, h - 2, | ||
204 | 2, h - 2, | ||
205 | 1, h - 3 | ||
206 | }; | ||
207 | |||
208 | p->drawPoints(QPointArray(8, pointList)); | ||
209 | } | ||
210 | |||
211 | p->translate(-x, -y); | ||
212 | } | ||
213 | |||
214 | WebStyle::WebStyle() | ||
215 | : QWindowsStyle() | ||
216 | { | ||
217 | setButtonDefaultIndicatorWidth(1); | ||
218 | setScrollBarExtent(_scrollBarExtent, _scrollBarExtent); | ||
219 | setButtonMargin( 3 ); | ||
220 | setSliderThickness(_scrollBarExtent ); | ||
221 | } | ||
222 | |||
223 | WebStyle::~WebStyle() | ||
224 | { | ||
225 | // Empty. | ||
226 | } | ||
227 | |||
228 | void | ||
229 | WebStyle::polish(QApplication *) | ||
230 | { | ||
231 | // Empty. | ||
232 | } | ||
233 | |||
234 | void | ||
235 | WebStyle::polish(QPalette &) | ||
236 | { | ||
237 | // Empty. | ||
238 | } | ||
239 | |||
240 | void | ||
241 | WebStyle::unPolish(QApplication *) | ||
242 | { | ||
243 | // Empty. | ||
244 | } | ||
245 | |||
246 | void | ||
247 | WebStyle::polish(QWidget * w) | ||
248 | { | ||
249 | if (w->inherits("QPushButton")) | ||
250 | w->installEventFilter(this); | ||
251 | |||
252 | else if (w->inherits("QGroupBox") || w->inherits("QFrame")) | ||
253 | { | ||
254 | QFrame * f(static_cast<QFrame *>(w)); | ||
255 | |||
256 | if (f->frameStyle() != QFrame::NoFrame) | ||
257 | { | ||
258 | _currentFrame = f; | ||
259 | |||
260 | _savedFrameLineWidth = f->lineWidth(); | ||
261 | _savedFrameMidLineWidth = f->midLineWidth(); | ||
262 | _savedFrameStyle = f->frameStyle(); | ||
263 | |||
264 | if (f->frameShape() == QFrame::HLine || f->frameShape() == QFrame::VLine) | ||
265 | { | ||
266 | f->setMidLineWidth(1); | ||
267 | f->setFrameStyle(f->frameShape() | QFrame::Plain); | ||
268 | } | ||
269 | else | ||
270 | { | ||
271 | f->setLineWidth(1); | ||
272 | f->setFrameStyle(QFrame::Box | QFrame::Plain); | ||
273 | } | ||
274 | } | ||
275 | } | ||
276 | } | ||
277 | |||
278 | void | ||
279 | WebStyle::unPolish(QWidget * w) | ||
280 | { | ||
281 | if (w->inherits("QPushButton")) | ||
282 | w->removeEventFilter(this); | ||
283 | |||
284 | else if (w == _currentFrame) | ||
285 | { | ||
286 | QFrame * f(static_cast<QFrame *>(w)); | ||
287 | |||
288 | f->setLineWidth(_savedFrameLineWidth); | ||
289 | f->setMidLineWidth(_savedFrameMidLineWidth); | ||
290 | f->setFrameStyle(_savedFrameStyle); | ||
291 | } | ||
292 | } | ||
293 | |||
294 | bool | ||
295 | WebStyle::eventFilter(QObject * o, QEvent * e) | ||
296 | { | ||
297 | QPushButton * pb(static_cast<QPushButton *>(o)); | ||
298 | |||
299 | if (e->type() == QEvent::Enter) | ||
300 | { | ||
301 | _highlightedButton = pb; | ||
302 | pb->repaint(false); | ||
303 | } | ||
304 | else if (e->type() == QEvent::Leave) | ||
305 | { | ||
306 | _highlightedButton = 0; | ||
307 | pb->repaint(false); | ||
308 | } | ||
309 | |||
310 | return false; | ||
311 | } | ||
312 | |||
313 | void | ||
314 | WebStyle::drawButton | ||
315 | ( | ||
316 | QPainter * p, | ||
317 | int x, | ||
318 | int y, | ||
319 | int w, | ||
320 | int h, | ||
321 | const QColorGroup & g, | ||
322 | bool sunken, | ||
323 | const QBrush * fill | ||
324 | ) | ||
325 | { | ||
326 | p->save(); | ||
327 | |||
328 | if (sunken) | ||
329 | p->setPen(contrastingForeground(g.light(), g.button())); | ||
330 | else | ||
331 | p->setPen(contrastingForeground(g.mid(), g.button())); | ||
332 | |||
333 | p->setBrush(0 == fill ? NoBrush : *fill); | ||
334 | |||
335 | drawFunkyRect(p, x, y, w, h, true); | ||
336 | |||
337 | p->restore(); | ||
338 | } | ||
339 | |||
340 | QRect | ||
341 | WebStyle::buttonRect(int x, int y, int w, int h) | ||
342 | { | ||
343 | return QRect(x + 2, y + 2, w - 4, h - 4); | ||
344 | } | ||
345 | |||
346 | void | ||
347 | WebStyle::drawBevelButton | ||
348 | ( | ||
349 | QPainter * p, | ||
350 | int x, | ||
351 | int y, | ||
352 | int w, | ||
353 | int h, | ||
354 | const QColorGroup & g, | ||
355 | bool sunken, | ||
356 | const QBrush * fill | ||
357 | ) | ||
358 | { | ||
359 | drawButton(p, x, y, w, h, g, sunken, fill); | ||
360 | } | ||
361 | |||
362 | void | ||
363 | WebStyle::drawPushButton(QPushButton * b, QPainter * p) | ||
364 | { | ||
365 | // Note: painter is already translated for us. | ||
366 | |||
367 | bool sunken(b->isDown() || b->isOn()); | ||
368 | bool hl(_highlightedButton == b); | ||
369 | |||
370 | QColor bg(b->colorGroup().button()); | ||
371 | |||
372 | p->save(); | ||
373 | p->fillRect(b->rect(), b->colorGroup().brush(QColorGroup::Background)); | ||
374 | |||
375 | if (b->isDefault()) | ||
376 | { | ||
377 | QColor c(hl ? b->colorGroup().highlight() : b->colorGroup().mid()); | ||
378 | |||
379 | p->setPen(contrastingForeground(c, bg)); | ||
380 | |||
381 | drawFunkyRect(p, 0, 0, b->width(), b->height(), false); | ||
382 | } | ||
383 | |||
384 | p->fillRect | ||
385 | ( | ||
386 | 4, | ||
387 | 4, | ||
388 | b->width() - 8, | ||
389 | b->height() - 8, | ||
390 | b->colorGroup().brush(QColorGroup::Button) | ||
391 | ); | ||
392 | |||
393 | if (b->isEnabled()) | ||
394 | { | ||
395 | if (sunken) | ||
396 | { | ||
397 | p->setPen(contrastingForeground(b->colorGroup().light(), bg)); | ||
398 | } | ||
399 | else | ||
400 | { | ||
401 | if (hl) | ||
402 | p->setPen(contrastingForeground(b->colorGroup().highlight(), bg)); | ||
403 | else | ||
404 | p->setPen(contrastingForeground(b->colorGroup().mid(), bg)); | ||
405 | } | ||
406 | } | ||
407 | else | ||
408 | { | ||
409 | p->setPen(b->colorGroup().button()); | ||
410 | } | ||
411 | |||
412 | drawFunkyRect(p, 3, 3, b->width() - 6, b->height() - 6, true); | ||
413 | |||
414 | p->restore(); | ||
415 | } | ||
416 | |||
417 | void | ||
418 | WebStyle::drawPushButtonLabel(QPushButton * b, QPainter * p) | ||
419 | { | ||
420 | // This is complicated stuff and we don't really want to mess with it. | ||
421 | |||
422 | QWindowsStyle::drawPushButtonLabel(b, p); | ||
423 | } | ||
424 | |||
425 | void | ||
426 | WebStyle::drawScrollBarControls | ||
427 | ( | ||
428 | QPainter * p, | ||
429 | const QScrollBar * sb, | ||
430 | int sliderStart, | ||
431 | uint controls, | ||
432 | uint activeControl | ||
433 | ) | ||
434 | { | ||
435 | p->save(); | ||
436 | |||
437 | int sliderMin, sliderMax, sliderLength, buttonDim; | ||
438 | |||
439 | scrollBarMetrics(sb, sliderMin, sliderMax, sliderLength, buttonDim); | ||
440 | |||
441 | QRect rSub, rAdd, rSubPage, rAddPage, rSlider; | ||
442 | |||
443 | scrollBarControlsMetrics | ||
444 | ( | ||
445 | sb, | ||
446 | sliderStart, | ||
447 | sliderMin, | ||
448 | sliderMax, | ||
449 | sliderLength, | ||
450 | buttonDim, | ||
451 | rSub, | ||
452 | rAdd, | ||
453 | rSubPage, | ||
454 | rAddPage, | ||
455 | rSlider | ||
456 | ); | ||
457 | |||
458 | QColorGroup g(sb->colorGroup()); | ||
459 | |||
460 | if (controls & AddLine && rAdd.isValid()) | ||
461 | { | ||
462 | bool active(activeControl & AddLine); | ||
463 | |||
464 | QColor c(active ? g.highlight() : g.dark()); | ||
465 | |||
466 | p->setPen(c); | ||
467 | p->setBrush(g.button()); | ||
468 | p->drawRect(rAdd); | ||
469 | |||
470 | Qt::ArrowType t = | ||
471 | sb->orientation() == Horizontal ? Qt::RightArrow : Qt::DownArrow; | ||
472 | |||
473 | // Is it me or is KStyle::drawArrow broken ? | ||
474 | |||
475 | drawArrow | ||
476 | ( | ||
477 | p, | ||
478 | t, | ||
479 | true, // FIXME - down ? | ||
480 | rAdd.x(), | ||
481 | rAdd.y(), | ||
482 | rAdd.width(), | ||
483 | rAdd.height(), | ||
484 | g, | ||
485 | true // FIXME - enabled ? | ||
486 | ); | ||
487 | } | ||
488 | |||
489 | if (controls & SubLine && rSub.isValid()) | ||
490 | { | ||
491 | bool active(activeControl & SubLine); | ||
492 | |||
493 | QColor c(active ? g.highlight() : g.dark()); | ||
494 | |||
495 | p->setPen(c); | ||
496 | p->setBrush(g.button()); | ||
497 | p->drawRect(rSub); | ||
498 | |||
499 | Qt::ArrowType t = | ||
500 | sb->orientation() == Horizontal ? Qt::LeftArrow : Qt::UpArrow; | ||
501 | |||
502 | drawArrow | ||
503 | ( | ||
504 | p, | ||
505 | t, | ||
506 | true, // FIXME - down ? | ||
507 | rSub.x(), | ||
508 | rSub.y(), | ||
509 | rSub.width(), | ||
510 | rSub.height(), | ||
511 | g, | ||
512 | true // FIXME - enabled ? | ||
513 | ); | ||
514 | } | ||
515 | |||
516 | if (controls & SubPage && rSubPage.isValid()) | ||
517 | { | ||
518 | p->setPen(g.mid()); | ||
519 | p->setBrush(g.base()); | ||
520 | p->drawRect(rSubPage); | ||
521 | } | ||
522 | |||
523 | if (controls & AddPage && rAddPage.isValid()) | ||
524 | { | ||
525 | p->setPen(g.mid()); | ||
526 | p->setBrush(g.base()); | ||
527 | p->drawRect(rAddPage); | ||
528 | } | ||
529 | |||
530 | if (controls & Slider && rSlider.isValid()) | ||
531 | { | ||
532 | p->setPen(activeControl & Slider ? g.highlight() : g.dark()); | ||
533 | |||
534 | p->setBrush(g.button()); | ||
535 | p->drawRect(rSlider); | ||
536 | |||
537 | p->setBrush(g.light()); | ||
538 | p->setPen(g.dark()); | ||
539 | |||
540 | if (sliderLength > _scrollBarExtent * 2) | ||
541 | { | ||
542 | int ellipseSize = | ||
543 | Horizontal == sb->orientation() | ||
544 | ? | ||
545 | rSlider.height() - 4 | ||
546 | : | ||
547 | rSlider.width() - 4 | ||
548 | ; | ||
549 | |||
550 | QPoint center(rSlider.center()); | ||
551 | |||
552 | if (Horizontal == sb->orientation()) | ||
553 | { | ||
554 | p->drawEllipse | ||
555 | ( | ||
556 | center.x() - ellipseSize / 2, rSlider.y() + 2, | ||
557 | ellipseSize, ellipseSize | ||
558 | ); | ||
559 | } | ||
560 | else | ||
561 | { | ||
562 | p->drawEllipse | ||
563 | ( | ||
564 | rSlider.x() + 2, center.y() - ellipseSize / 2, | ||
565 | ellipseSize, ellipseSize | ||
566 | ); | ||
567 | } | ||
568 | } | ||
569 | } | ||
570 | |||
571 | p->restore(); | ||
572 | } | ||
573 | |||
574 | QStyle::ScrollControl | ||
575 | WebStyle::scrollBarPointOver | ||
576 | ( | ||
577 | const QScrollBar * sb, | ||
578 | int sliderStart, | ||
579 | const QPoint & point | ||
580 | ) | ||
581 | { | ||
582 | if (!sb->rect().contains(point)) | ||
583 | return NoScroll; | ||
584 | |||
585 | int sliderMin, sliderMax, sliderLength, buttonDim; | ||
586 | |||
587 | scrollBarMetrics(sb, sliderMin, sliderMax, sliderLength, buttonDim); | ||
588 | |||
589 | if (sb->orientation() == QScrollBar::Horizontal) | ||
590 | { | ||
591 | int x = point.x(); | ||
592 | |||
593 | if (x <= buttonDim) | ||
594 | return SubLine; | ||
595 | |||
596 | else if (x <= buttonDim * 2) | ||
597 | return AddLine; | ||
598 | |||
599 | else if (x < sliderStart) | ||
600 | return SubPage; | ||
601 | |||
602 | else if (x < sliderStart+sliderLength) | ||
603 | return Slider; | ||
604 | |||
605 | return AddPage; | ||
606 | } | ||
607 | else | ||
608 | { | ||
609 | int y = point.y(); | ||
610 | |||
611 | if (y < sliderStart) | ||
612 | return SubPage; | ||
613 | |||
614 | else if (y < sliderStart + sliderLength) | ||
615 | return Slider; | ||
616 | |||
617 | else if (y < sliderMax + sliderLength) | ||
618 | return AddPage; | ||
619 | |||
620 | else if (y < sliderMax + sliderLength + buttonDim) | ||
621 | return SubLine; | ||
622 | |||
623 | return AddLine; | ||
624 | } | ||
625 | } | ||
626 | |||
627 | void | ||
628 | WebStyle::scrollBarMetrics | ||
629 | ( | ||
630 | const QScrollBar * sb, | ||
631 | int & sliderMin, | ||
632 | int & sliderMax, | ||
633 | int & sliderLength, | ||
634 | int & buttonDim | ||
635 | ) | ||
636 | { | ||
637 | // return QWindowsStyle::scrollBarMetrics(sb, sliderMin, sliderMax, | ||
638 | // sliderLength, buttonDim ); | ||
639 | int maxlen; | ||
640 | |||
641 | bool horizontal = sb->orientation() == QScrollBar::Horizontal; | ||
642 | |||
643 | int len = (horizontal) ? sb->width() : sb->height(); | ||
644 | |||
645 | int extent = (horizontal) ? sb->height() : sb->width(); | ||
646 | |||
647 | if (len > (extent - 1) * 2) | ||
648 | buttonDim = extent; | ||
649 | else | ||
650 | buttonDim = len / 2 - 1; | ||
651 | |||
652 | if (horizontal) | ||
653 | sliderMin = buttonDim * 2; | ||
654 | else | ||
655 | sliderMin = 1; | ||
656 | |||
657 | maxlen = len - buttonDim * 2 - 1; | ||
658 | |||
659 | int div = QMAX(1, (sb->maxValue() - sb->minValue() + sb->pageStep() ) ); | ||
660 | |||
661 | sliderLength = | ||
662 | (sb->pageStep() * maxlen) / div; | ||
663 | |||
664 | if (sliderLength < _scrollBarExtent) | ||
665 | sliderLength = _scrollBarExtent; | ||
666 | |||
667 | if (sliderLength > maxlen) | ||
668 | sliderLength = maxlen; | ||
669 | |||
670 | sliderMax = sliderMin + maxlen - sliderLength; | ||
671 | } | ||
672 | |||
673 | QSize | ||
674 | WebStyle::indicatorSize() const | ||
675 | { | ||
676 | return QSize(_indicatorSize, _indicatorSize); | ||
677 | } | ||
678 | |||
679 | void | ||
680 | WebStyle::drawIndicator | ||
681 | ( | ||
682 | QPainter * p, | ||
683 | int x, | ||
684 | int y, | ||
685 | int w, | ||
686 | int h, | ||
687 | const QColorGroup & g, | ||
688 | int state, | ||
689 | bool down, | ||
690 | bool enabled | ||
691 | ) | ||
692 | { | ||
693 | p->save(); | ||
694 | |||
695 | p->fillRect(x, y, w, h, g.background()); | ||
696 | |||
697 | if (enabled) | ||
698 | { | ||
699 | p->setPen(down ? g.highlight() : contrastingForeground(g.dark(), g.background())); | ||
700 | } | ||
701 | else | ||
702 | { | ||
703 | g.mid(); | ||
704 | } | ||
705 | |||
706 | p->drawRect(x, y, w, h); | ||
707 | |||
708 | if (state != QButton::Off) | ||
709 | { | ||
710 | p->fillRect(x + 2, y + 2, w - 4, h - 4, enabled ? g.highlight() : g.mid()); | ||
711 | |||
712 | if (state == QButton::NoChange) | ||
713 | { | ||
714 | p->fillRect(x + 4, y + 4, w - 8, h - 8, g.background()); | ||
715 | } | ||
716 | } | ||
717 | |||
718 | p->restore(); | ||
719 | } | ||
720 | |||
721 | QSize | ||
722 | WebStyle::exclusiveIndicatorSize() const | ||
723 | { | ||
724 | return QSize(_indicatorSize, _indicatorSize); | ||
725 | } | ||
726 | |||
727 | void | ||
728 | WebStyle::drawExclusiveIndicator | ||
729 | ( | ||
730 | QPainter * p, | ||
731 | int x, | ||
732 | int y, | ||
733 | int w, | ||
734 | int h, | ||
735 | const QColorGroup & g, | ||
736 | bool on, | ||
737 | bool down, | ||
738 | bool enabled | ||
739 | ) | ||
740 | { | ||
741 | p->save(); | ||
742 | |||
743 | p->fillRect(x, y, w, h, g.background()); | ||
744 | |||
745 | if (enabled) | ||
746 | { | ||
747 | p->setPen(down ? g.highlight() : contrastingForeground(g.dark(), g.background())); | ||
748 | } | ||
749 | else | ||
750 | { | ||
751 | p->setPen(g.mid()); | ||
752 | } | ||
753 | |||
754 | p->setBrush(g.brush(QColorGroup::Background)); | ||
755 | |||
756 | // Avoid misshapen ellipses. Qt or X bug ? Who knows... | ||
757 | |||
758 | if (0 == w % 2) | ||
759 | --w; | ||
760 | |||
761 | if (0 == h % 2) | ||
762 | --h; | ||
763 | |||
764 | p->drawEllipse(x, y, w, h); | ||
765 | |||
766 | if (on) | ||
767 | { | ||
768 | p->setPen(enabled ? g.highlight() : g.mid()); | ||
769 | p->setBrush(enabled ? g.highlight() : g.mid()); | ||
770 | p->drawEllipse(x + 3, y + 3, w - 6, h - 6); | ||
771 | } | ||
772 | |||
773 | p->restore(); | ||
774 | } | ||
775 | |||
776 | void | ||
777 | WebStyle::drawIndicatorMask | ||
778 | ( | ||
779 | QPainter * p, | ||
780 | int x, | ||
781 | int y, | ||
782 | int w, | ||
783 | int h, | ||
784 | int /* state */ | ||
785 | ) | ||
786 | { | ||
787 | p->fillRect(x, y, w, h, Qt::color1); | ||
788 | } | ||
789 | |||
790 | void | ||
791 | WebStyle::drawExclusiveIndicatorMask | ||
792 | ( | ||
793 | QPainter * p, | ||
794 | int x, | ||
795 | int y, | ||
796 | int w, | ||
797 | int h, | ||
798 | bool /* on */ | ||
799 | ) | ||
800 | { | ||
801 | if (0 == w % 2) | ||
802 | --w; | ||
803 | |||
804 | if (0 == h % 2) | ||
805 | --h; | ||
806 | |||
807 | p->setPen(Qt::color1); | ||
808 | p->setBrush(Qt::color1); | ||
809 | p->drawEllipse(x, y, w, h); | ||
810 | } | ||
811 | |||
812 | void | ||
813 | WebStyle::drawComboButton | ||
814 | ( | ||
815 | QPainter * p, | ||
816 | int x, | ||
817 | int y, | ||
818 | int w, | ||
819 | int h, | ||
820 | const QColorGroup & g, | ||
821 | bool sunken, | ||
822 | bool editable, | ||
823 | bool enabled, | ||
824 | const QBrush * fill | ||
825 | ) | ||
826 | { | ||
827 | p->save(); | ||
828 | |||
829 | p->setPen(NoPen); | ||
830 | p->setBrush(0 == fill ? g.brush(QColorGroup::Background) : *fill); | ||
831 | p->drawRect(x, y, w, h); | ||
832 | |||
833 | if (enabled) | ||
834 | { | ||
835 | if (sunken) | ||
836 | p->setPen(contrastingForeground(g.highlight(), g.background())); | ||
837 | else | ||
838 | p->setPen(contrastingForeground(g.mid(), g.background())); | ||
839 | } | ||
840 | else | ||
841 | { | ||
842 | p->setPen(contrastingForeground(g.mid(), g.background())); | ||
843 | } | ||
844 | |||
845 | drawFunkyRect(p, x, y, w, h, true); | ||
846 | |||
847 | p->drawPoint(w - 10, h - 6); | ||
848 | p->drawPoint(w - 9, h - 6); | ||
849 | p->drawPoint(w - 8, h - 6); | ||
850 | p->drawPoint(w - 7, h - 6); | ||
851 | p->drawPoint(w - 6, h - 6); | ||
852 | |||
853 | p->drawPoint(w - 9, h - 7); | ||
854 | p->drawPoint(w - 8, h - 7); | ||
855 | p->drawPoint(w - 7, h - 7); | ||
856 | p->drawPoint(w - 6, h - 7); | ||
857 | |||
858 | p->drawPoint(w - 8, h - 8); | ||
859 | p->drawPoint(w - 7, h - 8); | ||
860 | p->drawPoint(w - 6, h - 8); | ||
861 | |||
862 | p->drawPoint(w - 7, h - 9); | ||
863 | p->drawPoint(w - 6, h - 9); | ||
864 | |||
865 | p->drawPoint(w - 6, h - 10); | ||
866 | |||
867 | if (editable) | ||
868 | p->fillRect(comboButtonFocusRect(x, y, w, h), Qt::red); | ||
869 | |||
870 | p->restore(); | ||
871 | } | ||
872 | |||
873 | QRect | ||
874 | WebStyle::comboButtonRect(int x, int y, int w, int h) | ||
875 | { | ||
876 | return QRect(x + 2, y + 2, w - 20, h - 4); | ||
877 | } | ||
878 | |||
879 | QRect | ||
880 | WebStyle::comboButtonFocusRect(int x, int y, int w, int h) | ||
881 | { | ||
882 | return QRect(x + 2, y + 2, w - 20, h - 4); | ||
883 | } | ||
884 | |||
885 | int | ||
886 | WebStyle::sliderLength() const | ||
887 | { | ||
888 | return 13; | ||
889 | } | ||
890 | |||
891 | void | ||
892 | WebStyle::drawSliderGroove | ||
893 | ( | ||
894 | QPainter * p, | ||
895 | int x, | ||
896 | int y, | ||
897 | int w, | ||
898 | int h, | ||
899 | const QColorGroup & g, | ||
900 | QCOORD /* c */, | ||
901 | Orientation o | ||
902 | ) | ||
903 | { | ||
904 | p->save(); | ||
905 | |||
906 | p->setPen(QPen(g.dark(), 0, Qt::DotLine)); | ||
907 | |||
908 | if( o == Qt::Horizontal ) | ||
909 | p->drawLine(x, y + h / 2, w, y + h / 2); | ||
910 | else | ||
911 | if( o == Qt::Vertical ) | ||
912 | p->drawLine(x + w / 2, y, x + w / 2, h); | ||
913 | |||
914 | p->restore(); | ||
915 | } | ||
916 | |||
917 | void | ||
918 | WebStyle::drawArrow | ||
919 | ( | ||
920 | QPainter * p, | ||
921 | Qt::ArrowType type, | ||
922 | bool down, | ||
923 | int x, | ||
924 | int y, | ||
925 | int w, | ||
926 | int h, | ||
927 | const QColorGroup & g, | ||
928 | bool enabled, | ||
929 | const QBrush * fill | ||
930 | ) | ||
931 | { | ||
932 | QWindowsStyle::drawArrow(p, type, down, x, y, w, h, g, enabled, fill); | ||
933 | } | ||
934 | |||
935 | void | ||
936 | WebStyle::drawSlider | ||
937 | ( | ||
938 | QPainter * p, | ||
939 | int x, | ||
940 | int y, | ||
941 | int w, | ||
942 | int h, | ||
943 | const QColorGroup & g, | ||
944 | Orientation o, | ||
945 | bool /* tickAbove */, | ||
946 | bool /* tickBelow */ | ||
947 | ) | ||
948 | { | ||
949 | p->save(); | ||
950 | |||
951 | p->fillRect(x + 1, y + 1, w - 2, h - 2, g.background()); | ||
952 | p->setPen(g.dark()); | ||
953 | p->setBrush(g.light()); | ||
954 | |||
955 | int sl = sliderLength(); | ||
956 | |||
957 | if( o == Qt::Horizontal ) | ||
958 | p->drawEllipse(x, y + h / 2 - sl / 2, sl, sl); | ||
959 | else | ||
960 | if( o == Qt::Vertical ) | ||
961 | p->drawEllipse(x + w / 2 - sl / 2, y, sl, sl); | ||
962 | |||
963 | p->restore(); | ||
964 | } | ||
965 | |||
966 | void | ||
967 | WebStyle::drawPopupMenuItem | ||
968 | ( | ||
969 | QPainter * p, | ||
970 | bool checkable, | ||
971 | int maxpmw, | ||
972 | int tab, | ||
973 | QMenuItem * mi, | ||
974 | const QPalette & pal, | ||
975 | bool act, | ||
976 | bool enabled, | ||
977 | int x, | ||
978 | int y, | ||
979 | int w, | ||
980 | int h | ||
981 | ) | ||
982 | { | ||
983 | // TODO | ||
984 | QWindowsStyle::drawPopupMenuItem(p, checkable, maxpmw, tab, mi, pal, act, enabled, x, y, w, h); | ||
985 | } | ||
986 | |||
987 | void | ||
988 | WebStyle::drawFocusRect | ||
989 | ( | ||
990 | QPainter * p, | ||
991 | const QRect & r, | ||
992 | const QColorGroup & g, | ||
993 | const QColor * pen, | ||
994 | bool atBorder | ||
995 | ) | ||
996 | { | ||
997 | p->save(); | ||
998 | |||
999 | if (0 != pen) | ||
1000 | p->setPen(0 == pen ? g.foreground() : *pen); | ||
1001 | p->setBrush(NoBrush); | ||
1002 | |||
1003 | if (atBorder) | ||
1004 | { | ||
1005 | p->drawRect(QRect(r.x() + 1, r.y() + 1, r.width() - 2, r.height() - 2)); | ||
1006 | } | ||
1007 | else | ||
1008 | { | ||
1009 | p->drawRect(r); | ||
1010 | } | ||
1011 | |||
1012 | p->restore(); | ||
1013 | } | ||
1014 | |||
1015 | void | ||
1016 | WebStyle::drawPanel | ||
1017 | ( | ||
1018 | QPainter * p, | ||
1019 | int x, | ||
1020 | int y, | ||
1021 | int w, | ||
1022 | int h, | ||
1023 | const QColorGroup & g, | ||
1024 | bool /* sunken */, | ||
1025 | int /* lineWidth */, | ||
1026 | const QBrush * fill | ||
1027 | ) | ||
1028 | { | ||
1029 | p->save(); | ||
1030 | |||
1031 | p->setPen(g.dark()); | ||
1032 | |||
1033 | p->setBrush(0 == fill ? NoBrush : *fill); | ||
1034 | |||
1035 | p->drawRect(x, y, w, h); | ||
1036 | |||
1037 | p->restore(); | ||
1038 | } | ||
1039 | |||
1040 | void | ||
1041 | WebStyle::drawPopupPanel | ||
1042 | ( | ||
1043 | QPainter * p, | ||
1044 | int x, | ||
1045 | int y, | ||
1046 | int w, | ||
1047 | int h, | ||
1048 | const QColorGroup & g, | ||
1049 | int /* lineWidth */, | ||
1050 | const QBrush * fill | ||
1051 | ) | ||
1052 | { | ||
1053 | p->save(); | ||
1054 | |||
1055 | p->setPen(g.dark()); | ||
1056 | |||
1057 | p->setBrush(0 == fill ? NoBrush : *fill); | ||
1058 | |||
1059 | p->drawRect(x, y, w, h); | ||
1060 | |||
1061 | p->restore(); | ||
1062 | } | ||
1063 | |||
1064 | void | ||
1065 | WebStyle::drawSeparator | ||
1066 | ( | ||
1067 | QPainter * p, | ||
1068 | int x, | ||
1069 | int y, | ||
1070 | int w, | ||
1071 | int h, | ||
1072 | const QColorGroup & g, | ||
1073 | bool /* sunken */, | ||
1074 | int /* lineWidth */, | ||
1075 | int /* midLineWidth */ | ||
1076 | ) | ||
1077 | { | ||
1078 | p->save(); | ||
1079 | |||
1080 | p->setPen(g.dark()); | ||
1081 | |||
1082 | if (w > h) | ||
1083 | { | ||
1084 | p->drawLine(x, y + h / 2, x + w, y + h / 2); | ||
1085 | } | ||
1086 | else | ||
1087 | { | ||
1088 | p->drawLine(x + w / 2, y, x + w / 2, y + h); | ||
1089 | } | ||
1090 | |||
1091 | p->restore(); | ||
1092 | } | ||
1093 | |||
1094 | void | ||
1095 | WebStyle::drawTab | ||
1096 | ( | ||
1097 | QPainter * p, | ||
1098 | const QTabBar * tabBar, | ||
1099 | QTab * tab, | ||
1100 | bool selected | ||
1101 | ) | ||
1102 | { | ||
1103 | QRect r(tab->rect()); | ||
1104 | |||
1105 | QColorGroup g(tabBar->colorGroup()); | ||
1106 | |||
1107 | p->save(); | ||
1108 | |||
1109 | p->setPen(selected ? g.dark() : g.mid()); | ||
1110 | p->fillRect(r, g.brush(QColorGroup::Background)); | ||
1111 | |||
1112 | switch (tabBar->shape()) | ||
1113 | { | ||
1114 | case QTabBar::RoundedAbove: | ||
1115 | case QTabBar::TriangularAbove: | ||
1116 | p->drawLine(r.left(), r.top(), r.left(), r.bottom()); | ||
1117 | p->drawLine(r.left(), r.top(), r.right(), r.top()); | ||
1118 | p->drawLine(r.right(), r.top(), r.right(), r.bottom()); | ||
1119 | if (!selected) | ||
1120 | { | ||
1121 | p->setPen(g.dark()); | ||
1122 | p->drawLine(r.left(), r.bottom(), r.right(), r.bottom()); | ||
1123 | } | ||
1124 | break; | ||
1125 | case QTabBar::RoundedBelow: | ||
1126 | case QTabBar::TriangularBelow: | ||
1127 | if (!selected) | ||
1128 | { | ||
1129 | p->setPen(g.dark()); | ||
1130 | p->drawLine(r.left(), r.top(), r.right(), r.top()); | ||
1131 | } | ||
1132 | p->drawLine(r.left(), r.top(), r.left(), r.bottom()); | ||
1133 | p->drawLine(r.left(), r.bottom(), r.right(), r.bottom()); | ||
1134 | p->drawLine(r.right(), r.top(), r.right(), r.bottom()); | ||
1135 | break; | ||
1136 | } | ||
1137 | |||
1138 | p->restore(); | ||
1139 | } | ||
1140 | |||
1141 | void | ||
1142 | WebStyle::drawTabMask | ||
1143 | ( | ||
1144 | QPainter * p, | ||
1145 | const QTabBar *, | ||
1146 | QTab * tab, | ||
1147 | bool | ||
1148 | ) | ||
1149 | { | ||
1150 | p->fillRect(tab->rect(), Qt::color1); | ||
1151 | } | ||
1152 | |||
1153 | |||
1154 | int | ||
1155 | WebStyle::popupMenuItemHeight(bool, QMenuItem * i, const QFontMetrics & fm) | ||
1156 | { | ||
1157 | if (i->isSeparator()) | ||
1158 | return 1; | ||
1159 | |||
1160 | int h = 0; | ||
1161 | |||
1162 | if (0 != i->pixmap()) | ||
1163 | { | ||
1164 | h = i->pixmap()->height(); | ||
1165 | } | ||
1166 | |||
1167 | if (0 != i->iconSet()) | ||
1168 | { | ||
1169 | h = QMAX | ||
1170 | ( | ||
1171 | i->iconSet()->pixmap(QIconSet::Small, QIconSet::Normal).height(), | ||
1172 | h | ||
1173 | ); | ||
1174 | } | ||
1175 | |||
1176 | h = QMAX(fm.height() + 4, h); | ||
1177 | |||
1178 | h = QMAX(18, h); | ||
1179 | |||
1180 | return h; | ||
1181 | |||
1182 | } | ||
1183 | |||