tools/qtconfig/paletteeditoradvanced.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the tools applications of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "paletteeditoradvanced.h"
  43 #include "colorbutton.h"
  44
  45 #include <QCheckBox>
  46 #include <QComboBox>
  47 #include <QApplication>
  48 #include <QPushButton>
  49 #include <QPainter>
  50 #include <QGroupBox>
  51
  52 QT_BEGIN_NAMESPACE
  53
  54 PaletteEditorAdvanced::PaletteEditorAdvanced( QWidget * parent,
  55                                               const char * name, bool modal, Qt::WindowFlags f )
  56     : PaletteEditorAdvancedBase( parent, name, modal, f ), selectedPalette(0)
  57 {
  58     // work around buggy UI file
  59     comboEffect->setEnabled(false);
  60     buttonEffect->setEnabled(false);
  61     onToggleBuildEffects(true);
  62
  63     editPalette = QApplication::palette();
  64     setPreviewPalette( editPalette );
  65 }
  66
  67 PaletteEditorAdvanced::~PaletteEditorAdvanced()
  68 {
  69 }
  70
  71 void PaletteEditorAdvanced::onToggleBuildInactive( bool v )
  72 {
  73     if (selectedPalette == 1) {
  74         groupCentral->setDisabled(v);
  75         groupEffect->setDisabled(v);
  76     }
  77
  78     if (v) {
  79         buildInactive();
  80         updateColorButtons();
  81     }
  82 }
  83
  84 void PaletteEditorAdvanced::onToggleBuildDisabled( bool v )
  85 {
  86     if (selectedPalette == 2) {
  87         groupCentral->setDisabled(v);
  88         groupEffect->setDisabled(v);
  89     }
  90
  91     if (v) {
  92         buildDisabled();
  93         updateColorButtons();
  94     }
  95 }
  96
  97 void PaletteEditorAdvanced::paletteSelected(int p)
  98 {
  99     selectedPalette = p;
 100
 101     if(p == 1) { // inactive
 102         groupCentral->setDisabled(checkBuildInactive->isChecked());
 103         groupEffect->setDisabled(checkBuildInactive->isChecked());
 104     }
 105     else if (p == 2) { // disabled
 106         groupCentral->setDisabled(checkBuildDisabled->isChecked());
 107         groupEffect->setDisabled(checkBuildDisabled->isChecked());
 108     }
 109     else {
 110         groupCentral->setEnabled(true);
 111         groupEffect->setEnabled(true);
 112     }
 113     updateColorButtons();
 114 }
 115
 116 void PaletteEditorAdvanced::onChooseCentralColor()
 117 {
 118     switch(selectedPalette) {
 119     case 0:
 120     default:
 121         mapToActiveCentralRole( buttonCentral->color() );
 122         break;
 123     case 1:
 124         mapToInactiveCentralRole( buttonCentral->color() );
 125         break;
 126     case 2:
 127         mapToDisabledCentralRole( buttonCentral->color() );
 128         break;
 129     }
 130     updateColorButtons();
 131 }
 132
 133 void PaletteEditorAdvanced::onChooseEffectColor()
 134 {
 135     switch(selectedPalette) {
 136     case 0:
 137     default:
 138         mapToActiveEffectRole( buttonEffect->color() );
 139         break;
 140     case 1:
 141         mapToInactiveEffectRole( buttonEffect->color() );
 142         break;
 143     case 2:
 144         mapToDisabledEffectRole( buttonEffect->color() );
 145         break;
 146     }
 147     updateColorButtons();
 148 }
 149
 150 void PaletteEditorAdvanced::onToggleBuildEffects( bool on )
 151 {
 152     if (!on) return;
 153     buildActiveEffect();
 154     buildInactiveEffect();
 155     buildDisabledEffect();
 156 }
 157
 158 QColorGroup::ColorRole PaletteEditorAdvanced::centralFromItem( int item )
 159 {
 160     switch( item ) {
 161         case 0:
 162             return QColorGroup::Window;
 163         case 1:
 164             return QColorGroup::WindowText;
 165         case 2:
 166             return QColorGroup::Button;
 167         case 3:
 168             return QColorGroup::Base;
 169         case 4:
 170             return QColorGroup::Text;
 171         case 5:
 172             return QColorGroup::BrightText;
 173         case 6:
 174             return QColorGroup::ButtonText;
 175         case 7:
 176             return QColorGroup::Highlight;
 177         case 8:
 178             return QColorGroup::HighlightedText;
 179         default:
 180             return QColorGroup::NColorRoles;
 181     }
 182 }
 183
 184 QColorGroup::ColorRole PaletteEditorAdvanced::effectFromItem( int item )
 185 {
 186     switch( item ) {
 187     case 0:
 188         return QColorGroup::Light;
 189     case 1:
 190         return QColorGroup::Midlight;
 191     case 2:
 192         return QColorGroup::Mid;
 193     case 3:
 194         return QColorGroup::Dark;
 195     case 4:
 196         return QColorGroup::Shadow;
 197     default:
 198         return QColorGroup::NColorRoles;
 199     }
 200 }
 201
 202 void PaletteEditorAdvanced::onCentral( int item )
 203 {
 204     QColor c;
 205
 206     switch(selectedPalette) {
 207     case 0:
 208     default:
 209         c = editPalette.active().color( centralFromItem(item) );
 210         break;
 211     case 1:
 212         c = editPalette.inactive().color( centralFromItem(item) );
 213         break;
 214     case 2:
 215         c =  editPalette.disabled().color( centralFromItem(item) );
 216         break;
 217     }
 218
 219     buttonCentral->setColor(c);
 220 }
 221
 222 void PaletteEditorAdvanced::onEffect( int item )
 223 {
 224     QColor c;
 225     switch(selectedPalette) {
 226     case 0:
 227     default:
 228         c = editPalette.active().color( effectFromItem(item) );
 229         break;
 230     case 1:
 231         editPalette.inactive().color( effectFromItem(item) );
 232         break;
 233     case 2:
 234         editPalette.disabled().color( effectFromItem(item) );
 235         break;
 236     }
 237     buttonEffect->setColor(c);
 238 }
 239
 240 void PaletteEditorAdvanced::mapToActiveCentralRole( const QColor& c )
 241 {
 242     QColorGroup cg = editPalette.active();
 243     cg.setColor( centralFromItem(comboCentral->currentItem()), c );
 244     editPalette.setActive( cg );
 245
 246     buildActiveEffect();
 247     if(checkBuildInactive->isChecked())
 248         buildInactive();
 249     if(checkBuildDisabled->isChecked())
 250         buildDisabled();
 251
 252     setPreviewPalette( editPalette );
 253 }
 254
 255 void PaletteEditorAdvanced::mapToActiveEffectRole( const QColor& c )
 256 {
 257     QColorGroup cg = editPalette.active();
 258     cg.setColor( effectFromItem(comboEffect->currentItem()), c );
 259     editPalette.setActive( cg );
 260
 261     if(checkBuildInactive->isChecked())
 262         buildInactive();
 263     if(checkBuildDisabled->isChecked())
 264         buildDisabled();
 265
 266     setPreviewPalette( editPalette );
 267 }
 268
 269 void PaletteEditorAdvanced::mapToActivePixmapRole( const QPixmap& pm )
 270 {
 271     QColorGroup::ColorRole role = centralFromItem(comboCentral->currentItem());
 272     QColorGroup cg = editPalette.active();
 273     if (  !pm.isNull()  )
 274         cg.setBrush( role, QBrush( cg.color( role ), pm ) );
 275     else
 276         cg.setBrush( role, QBrush( cg.color( role ) ) );
 277     editPalette.setActive( cg );
 278
 279
 280     buildActiveEffect();
 281     if(checkBuildInactive->isChecked())
 282         buildInactive();
 283     if(checkBuildDisabled->isChecked())
 284         buildDisabled();
 285
 286     setPreviewPalette( editPalette );
 287 }
 288
 289 void PaletteEditorAdvanced::mapToInactiveCentralRole( const QColor& c )
 290 {
 291     QColorGroup cg = editPalette.inactive();
 292     cg.setColor( centralFromItem(comboCentral->currentItem()), c );
 293     editPalette.setInactive( cg );
 294
 295     buildInactiveEffect();
 296
 297     setPreviewPalette( editPalette );
 298 }
 299
 300 void PaletteEditorAdvanced::mapToInactiveEffectRole( const QColor& c )
 301 {
 302     QColorGroup cg = editPalette.inactive();
 303     cg.setColor( effectFromItem(comboEffect->currentItem()), c );
 304     editPalette.setInactive( cg );
 305
 306     setPreviewPalette( editPalette );
 307 }
 308
 309 void PaletteEditorAdvanced::mapToInactivePixmapRole( const QPixmap& pm )
 310 {
 311     QColorGroup::ColorRole role = centralFromItem(comboCentral->currentItem());
 312     QColorGroup cg = editPalette.inactive();
 313     if (  !pm.isNull()  )
 314         cg.setBrush( role, QBrush( cg.color( role ), pm ) );
 315     else
 316         cg.setBrush( role, QBrush( cg.color( role ) ) );
 317     editPalette.setInactive( cg );
 318
 319     setPreviewPalette( editPalette );
 320 }
 321
 322 void PaletteEditorAdvanced::mapToDisabledCentralRole( const QColor& c )
 323 {
 324     QColorGroup cg = editPalette.disabled();
 325     cg.setColor( centralFromItem(comboCentral->currentItem()), c );
 326     editPalette.setDisabled( cg );
 327
 328     buildDisabledEffect();
 329
 330     setPreviewPalette( editPalette );
 331 }
 332
 333 void PaletteEditorAdvanced::mapToDisabledEffectRole( const QColor& c )
 334 {
 335     QColorGroup cg = editPalette.disabled();
 336     cg.setColor( effectFromItem(comboEffect->currentItem()), c );
 337     editPalette.setDisabled( cg );
 338
 339     setPreviewPalette( editPalette );
 340 }
 341
 342 void PaletteEditorAdvanced::mapToDisabledPixmapRole( const QPixmap& pm )
 343 {
 344     QColorGroup::ColorRole role = centralFromItem(comboCentral->currentItem());
 345     QColorGroup cg = editPalette.disabled();
 346     if (  !pm.isNull()  )
 347         cg.setBrush( role, QBrush( cg.color( role ), pm ) );
 348     else
 349         cg.setBrush( role, QBrush( cg.color( role ) ) );
 350
 351     editPalette.setDisabled( cg );
 352
 353     setPreviewPalette( editPalette );
 354 }
 355
 356 void PaletteEditorAdvanced::buildActiveEffect()
 357 {
 358     QColorGroup cg = editPalette.active();
 359     QColor btn = cg.color( QColorGroup::Button );
 360
 361     QPalette temp( btn, btn );
 362
 363     for (int i = 0; i<5; i++)
 364         cg.setColor( effectFromItem(i), temp.active().color( effectFromItem(i) ) );
 365
 366     editPalette.setActive( cg );
 367     setPreviewPalette( editPalette );
 368
 369     updateColorButtons();
 370 }
 371
 372 void PaletteEditorAdvanced::buildInactive()
 373 {
 374     editPalette.setInactive( editPalette.active() );
 375     if ( checkBuildEffect->isChecked() )
 376         buildInactiveEffect();
 377     else {
 378         setPreviewPalette( editPalette );
 379         updateColorButtons();
 380     }
 381
 382 }
 383
 384 void PaletteEditorAdvanced::buildInactiveEffect()
 385 {
 386     QColorGroup cg = editPalette.inactive();
 387
 388     QColor light, midlight, mid, dark, shadow;
 389     QColor btn = cg.color( QColorGroup::Button );
 390
 391     light = btn.light(150);
 392     midlight = btn.light(115);
 393     mid = btn.dark(150);
 394     dark = btn.dark();
 395     shadow = Qt::black;
 396
 397     cg.setColor( QColorGroup::Light, light );
 398     cg.setColor( QColorGroup::Midlight, midlight );
 399     cg.setColor( QColorGroup::Mid, mid );
 400     cg.setColor( QColorGroup::Dark, dark );
 401     cg.setColor( QColorGroup::Shadow, shadow );
 402
 403     editPalette.setInactive( cg );
 404     setPreviewPalette( editPalette );
 405     updateColorButtons();
 406 }
 407
 408 void PaletteEditorAdvanced::buildDisabled()
 409 {
 410     QColorGroup cg = editPalette.active();
 411     cg.setColor( QColorGroup::ButtonText, Qt::darkGray );
 412     cg.setColor( QColorGroup::WindowText, Qt::darkGray );
 413     cg.setColor( QColorGroup::Text, Qt::darkGray );
 414     cg.setColor( QColorGroup::HighlightedText, Qt::darkGray );
 415     editPalette.setDisabled( cg );
 416
 417     if ( checkBuildEffect->isChecked() )
 418         buildDisabledEffect();
 419     else {
 420         setPreviewPalette( editPalette );
 421         updateColorButtons();
 422     }
 423 }
 424
 425 void PaletteEditorAdvanced::buildDisabledEffect()
 426 {
 427     QColorGroup cg = editPalette.disabled();
 428
 429     QColor light, midlight, mid, dark, shadow;
 430     QColor btn = cg.color( QColorGroup::Button );
 431
 432     light = btn.light(150);
 433     midlight = btn.light(115);
 434     mid = btn.dark(150);
 435     dark = btn.dark();
 436     shadow = Qt::black;
 437
 438     cg.setColor( QColorGroup::Light, light );
 439     cg.setColor( QColorGroup::Midlight, midlight );
 440     cg.setColor( QColorGroup::Mid, mid );
 441     cg.setColor( QColorGroup::Dark, dark );
 442     cg.setColor( QColorGroup::Shadow, shadow );
 443
 444     editPalette.setDisabled( cg );
 445     setPreviewPalette( editPalette );
 446     updateColorButtons();
 447 }
 448
 449 void PaletteEditorAdvanced::setPreviewPalette( const QPalette& pal )
 450 {
 451     QColorGroup cg;
 452
 453     switch (selectedPalette) {
 454     case 0:
 455     default:
 456         cg = pal.active();
 457         break;
 458     case 1:
 459         cg = pal.inactive();
 460         break;
 461     case 2:
 462         cg = pal.disabled();
 463         break;
 464     }
 465     previewPalette.setActive( cg );
 466     previewPalette.setInactive( cg );
 467     previewPalette.setDisabled( cg );
 468 }
 469
 470 void PaletteEditorAdvanced::updateColorButtons()
 471 {
 472     QColor central, effect;
 473     switch (selectedPalette) {
 474     case 0:
 475     default:
 476         central = editPalette.active().color( centralFromItem( comboCentral->currentItem() ) );
 477         effect = editPalette.active().color( effectFromItem( comboEffect->currentItem() ) );
 478         break;
 479     case 1:
 480         central = editPalette.inactive().color( centralFromItem( comboCentral->currentItem() ) );
 481         effect = editPalette.inactive().color( effectFromItem( comboEffect->currentItem() ) );
 482         break;
 483     case 2:
 484         central = editPalette.disabled().color( centralFromItem( comboCentral->currentItem() ) );
 485         effect = editPalette.disabled().color( effectFromItem( comboEffect->currentItem() ) );
 486         break;
 487     }
 488
 489     buttonCentral->setColor(central);
 490     buttonEffect->setColor(effect);
 491 }
 492
 493 void PaletteEditorAdvanced::setPal( const QPalette& pal )
 494 {
 495     editPalette = pal;
 496     setPreviewPalette( pal );
 497     updateColorButtons();
 498 }
 499
 500 QPalette PaletteEditorAdvanced::pal() const
 501 {
 502     return editPalette;
 503 }
 504
 505 void PaletteEditorAdvanced::setupBackgroundMode( Qt::BackgroundMode mode )
 506 {
 507     int initRole = 0;
 508
 509     switch( mode ) {
 510     case Qt::PaletteBackground:
 511         initRole = 0;
 512         break;
 513     case Qt::PaletteForeground:
 514         initRole = 1;
 515         break;
 516     case Qt::PaletteButton:
 517         initRole = 2;
 518         break;
 519     case Qt::PaletteBase:
 520         initRole = 3;
 521         break;
 522     case Qt::PaletteText:
 523         initRole = 4;
 524         break;
 525     case Qt::PaletteBrightText:
 526         initRole = 5;
 527         break;
 528     case Qt::PaletteButtonText:
 529         initRole = 6;
 530         break;
 531     case Qt::PaletteHighlight:
 532         initRole = 7;
 533         break;
 534     case Qt::PaletteHighlightedText:
 535         initRole = 8;
 536         break;
 537     case Qt::PaletteLight:
 538         initRole = 9;
 539         break;
 540     case Qt::PaletteMidlight:
 541         initRole = 10;
 542         break;
 543     case Qt::PaletteDark:
 544         initRole = 11;
 545         break;
 546     case Qt::PaletteMid:
 547         initRole = 12;
 548         break;
 549     case Qt::PaletteShadow:
 550         initRole = 13;
 551         break;
 552     default:
 553         initRole = -1;
 554         break;
 555     }
 556
 557     if ( initRole <= -1 ) return;
 558
 559     if (initRole > 8 ) {
 560         comboEffect->setCurrentItem( initRole - 9 );
 561     }
 562     else {
 563         comboCentral->setCurrentItem( initRole );
 564     }
 565 }
 566
 567 QPalette PaletteEditorAdvanced::getPalette( bool *ok, const QPalette &init,
 568                                             Qt::BackgroundMode mode, QWidget* parent,
 569                                             const char* name )
 570 {
 571     PaletteEditorAdvanced* dlg = new PaletteEditorAdvanced( parent, name, true );
 572     dlg->setupBackgroundMode( mode );
 573
 574     if ( init != QPalette() )
 575         dlg->setPal( init );
 576     int resultCode = dlg->exec();
 577
 578     QPalette result = init;
 579     if ( resultCode == QDialog::Accepted ) {
 580         if ( ok )
 581             *ok = true;
 582         result = dlg->pal();
 583     } else {
 584         if ( ok )
 585             *ok = false;
 586     }
 587     delete dlg;
 588     return result;
 589 }
 590
 591 QT_END_NAMESPACE