kscreensaver/kdesavers/kclock.cpp

   1 // kclock - Clock screen saver for KDE
   2 //
   3 // Copyright (c) 2003, 2006, 2007, 2008 Melchior FRANZ <mfranz # kde : org>
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18
  19 #include <QCheckBox>
  20 #include <QColor>
  21 #include <QGridLayout>
  22 #include <QGroupBox>
  23 #include <QHBoxLayout>
  24 #include <QImage>
  25 #include <QLabel>
  26 #include <QSlider>
  27 #include <QVBoxLayout>
  28
  29 #include <KColorButton>
  30 #include <KConfig>
  31 #include <KGlobal>
  32 #include <KHBox>
  33 #include <KLocale>
  34 #include <KMessageBox>
  35
  36 #include "kclock.h"
  37 #include "kclock.moc"
  38
  39
  40 const int COLOR_BUTTON_WIDTH = 80;
  41 const int TIMER_INTERVAL = 100;
  42 const int MAX_CLOCK_SIZE = 10;
  43 const unsigned int DEFAULT_CLOCK_SIZE = 8;
  44 const bool DEFAULT_KEEP_CENTERED = false;
  45
  46
  47
  48 class KClockSaverInterface : public KScreenSaverInterface {
  49 public:
  50         virtual KAboutData *aboutData() {
  51                 return new KAboutData("kclock.kss", 0, ki18n("Clock"), "2.0", ki18n("Clock"));
  52         }
  53
  54         virtual KScreenSaver *create(WId id) {
  55                 return new KClockSaver(id);
  56         }
  57
  58         virtual QDialog *setup() {
  59                 return new KClockSetup();
  60         }
  61 };
  62
  63
  64 int main(int argc, char *argv[])
  65 {
  66         KClockSaverInterface kss;
  67         return kScreenSaverMain(argc, argv, kss);
  68 }
  69
  70
  71 //-----------------------------------------------------------------------------
  72
  73
  74 KClockSetup::KClockSetup(QWidget *parent) :
  75         KDialog(parent),
  76         _saver(0)
  77 {
  78         setCaption(i18n("Setup Clock Screen Saver"));
  79         setModal(true);
  80         setButtons(Ok|Cancel|Help);
  81         setDefaultButton(Ok);
  82
  83         readSettings();
  84
  85         setButtonText(Help, i18n("A&bout"));
  86         QWidget *main = new QWidget(this);
  87         setMainWidget(main);
  88
  89         QVBoxLayout *top = new QVBoxLayout(main);
  90
  91         QHBoxLayout *hbox = new QHBoxLayout;
  92         top->addLayout(hbox);
  93
  94
  95         QGroupBox *colgroup = new QGroupBox(i18n("Colors"), main);
  96         QGridLayout *grid = new QGridLayout();
  97
  98         QLabel *label;
  99         KColorButton *colorButton;
 100
 101         label = new QLabel(i18n("&Hour-hand:"));
 102         colorButton = new KColorButton(_hourColor);
 103         colorButton->setFixedWidth(COLOR_BUTTON_WIDTH);
 104         label->setBuddy(colorButton);
 105         connect(colorButton, SIGNAL(changed(const QColor &)),
 106                         SLOT(slotHourColor(const QColor &)));
 107         grid->addWidget(label, 1, 1);
 108         grid->addWidget(colorButton, 1, 2);
 109
 110         label = new QLabel(i18n("&Minute-hand:"));
 111         colorButton = new KColorButton(_minColor);
 112         colorButton->setFixedWidth(COLOR_BUTTON_WIDTH);
 113         label->setBuddy(colorButton);
 114         connect(colorButton, SIGNAL(changed(const QColor &)),
 115                         SLOT(slotMinColor(const QColor &)));
 116         grid->addWidget(label, 2, 1);
 117         grid->addWidget(colorButton, 2, 2);
 118
 119         label = new QLabel(i18n("&Second-hand:"));
 120         colorButton = new KColorButton(_secColor);
 121         colorButton->setFixedWidth(COLOR_BUTTON_WIDTH);
 122         label->setBuddy(colorButton);
 123         connect(colorButton, SIGNAL(changed(const QColor &)),
 124                         SLOT(slotSecColor(const QColor &)));
 125         grid->addWidget(label, 3, 1);
 126         grid->addWidget(colorButton, 3, 2);
 127
 128         label = new QLabel(i18n("Scal&e:"));
 129         colorButton = new KColorButton(_scaleColor);
 130         colorButton->setFixedWidth(COLOR_BUTTON_WIDTH);
 131         label->setBuddy(colorButton);
 132         connect(colorButton, SIGNAL(changed(const QColor &)),
 133                         SLOT(slotScaleColor(const QColor &)));
 134         grid->addWidget(label, 4, 1);
 135         grid->addWidget(colorButton, 4, 2);
 136
 137         label = new QLabel(i18n("&Background:"));
 138         colorButton = new KColorButton(_bgndColor);
 139         colorButton->setFixedWidth(COLOR_BUTTON_WIDTH);
 140         label->setBuddy(colorButton);
 141         connect(colorButton, SIGNAL(changed(const QColor &)),
 142                         SLOT(slotBgndColor(const QColor &)));
 143         grid->addWidget(label, 5, 1);
 144         grid->addWidget(colorButton, 5, 2);
 145
 146         hbox->addWidget(colgroup);
 147         colgroup->setLayout(grid);
 148
 149
 150         QWidget *_preview = new QWidget(main);
 151         _preview->setFixedSize(220, 165);
 152         _preview->show();
 153         _saver = new KClockSaver(_preview->winId());
 154         hbox->addWidget(_preview);
 155
 156         label = new QLabel(i18n("Si&ze:"), main);
 157         top->addWidget(label);
 158         QSlider *qs = new QSlider(Qt::Horizontal);
 159         label->setBuddy(qs);
 160         qs->setRange(0, MAX_CLOCK_SIZE);
 161         qs->setSliderPosition(_size);
 162         qs->setTickInterval(1);
 163         qs->setTickPosition(QSlider::TicksBelow);
 164         connect(qs, SIGNAL(valueChanged(int)), this, SLOT(slotSliderMoved(int)));
 165         top->addWidget(qs);
 166
 167         KHBox *qsscale = new KHBox(main);
 168         label = new QLabel(i18n("Small"), qsscale);
 169         label->setAlignment(Qt::AlignLeading);
 170         label = new QLabel(i18n("Medium"), qsscale);
 171         label->setAlignment(Qt::AlignHCenter);
 172         label = new QLabel(i18n("Big"), qsscale);
 173         label->setAlignment(Qt::AlignTrailing);
 174         top->addWidget(qsscale);
 175
 176         QCheckBox *keepCentered = new QCheckBox(i18n("&Keep clock centered"), main);
 177         keepCentered->setChecked(_keepCentered);
 178         connect(keepCentered, SIGNAL(stateChanged(int)), SLOT(slotKeepCenteredChanged(int)));
 179         top->addWidget(keepCentered);
 180         top->addStretch();
 181
 182         connect(this, SIGNAL(okClicked()), this, SLOT(slotOk()));
 183         connect(this, SIGNAL(helpClicked()), this, SLOT(slotHelp()));
 184 }
 185
 186
 187 KClockSetup::~KClockSetup()
 188 {
 189         delete _saver;
 190 }
 191
 192
 193 void KClockSetup::readSettings()
 194 {
 195         KConfigGroup settings(KGlobal::config(), "Settings");
 196
 197         _keepCentered = settings.readEntry("KeepCentered", DEFAULT_KEEP_CENTERED);
 198         _size = settings.readEntry("Size", DEFAULT_CLOCK_SIZE);
 199         if (_size > MAX_CLOCK_SIZE)
 200                 _size = MAX_CLOCK_SIZE;
 201
 202         KConfigGroup colors(KGlobal::config(), "Colors");
 203         QColor c = Qt::black;
 204         _bgndColor = colors.readEntry("Background", c);
 205
 206         c = Qt::white;
 207         _scaleColor = colors.readEntry("Scale", c);
 208         _hourColor = colors.readEntry("HourHand", c);
 209         _minColor = colors.readEntry("MinuteHand", c);
 210
 211         c = Qt::red;
 212         _secColor = colors.readEntry("SecondHand", c);
 213
 214         if (_saver) {
 215                 _saver->setBgndColor(_bgndColor);
 216                 _saver->setScaleColor(_scaleColor);
 217                 _saver->setHourColor(_hourColor);
 218                 _saver->setMinColor(_minColor);
 219                 _saver->setSecColor(_secColor);
 220         }
 221 }
 222
 223
 224 void KClockSetup::slotOk()
 225 {
 226         KConfigGroup settings(KGlobal::config(), "Settings");
 227         settings.writeEntry("Size", _size);
 228         settings.writeEntry("KeepCentered", _keepCentered);
 229         settings.sync();
 230
 231         KConfigGroup colors(KGlobal::config(), "Colors");
 232         colors.writeEntry("Background", _bgndColor);
 233         colors.writeEntry("Scale", _scaleColor);
 234         colors.writeEntry("HourHand", _hourColor);
 235         colors.writeEntry("MinuteHand", _minColor);
 236         colors.writeEntry("SecondHand", _secColor);
 237         colors.sync();
 238         accept();
 239 }
 240
 241
 242 void KClockSetup::slotHelp()
 243 {
 244         KMessageBox::about(this, "<qt>" + i18n(
 245                         "Clock Screen Saver<br>"
 246                         "Version 2.0<br>"
 247                         "<nobr>Melchior FRANZ (c) 2003, 2006, 2007</nobr>") +
 248                         "<br><a href=\"mailto:mfranz@kde.org\">mfranz@kde.org</a>"
 249                         "</qt>", QString(), KMessageBox::AllowLink);
 250 }
 251
 252
 253 void KClockSetup::slotBgndColor(const QColor &color)
 254 {
 255         _bgndColor = color;
 256         if (_saver)
 257                 _saver->setBgndColor(_bgndColor);
 258 }
 259
 260
 261 void KClockSetup::slotScaleColor(const QColor &color)
 262 {
 263         _scaleColor = color;
 264         if (_saver)
 265                 _saver->setScaleColor(_scaleColor);
 266 }
 267
 268
 269 void KClockSetup::slotHourColor(const QColor &color)
 270 {
 271         _hourColor = color;
 272         if (_saver)
 273                 _saver->setHourColor(_hourColor);
 274 }
 275
 276
 277 void KClockSetup::slotMinColor(const QColor &color)
 278 {
 279         _minColor = color;
 280         if (_saver)
 281                 _saver->setMinColor(_minColor);
 282 }
 283
 284
 285 void KClockSetup::slotSecColor(const QColor &color)
 286 {
 287         _secColor = color;
 288         if (_saver)
 289                 _saver->setSecColor(_secColor);
 290 }
 291
 292
 293 void KClockSetup::slotSliderMoved(int v)
 294 {
 295         if (_saver)
 296                 _saver->resizeClock(_size = v);
 297 }
 298
 299
 300 void KClockSetup::slotKeepCenteredChanged(int c)
 301 {
 302         if (_saver)
 303                 _saver->setKeepCentered(_keepCentered = c);
 304 }
 305
 306
 307 //-----------------------------------------------------------------------------
 308
 309
 310 ClockPainter::ClockPainter(QPaintDevice *device, int diameter) :
 311         QPainter(device)
 312 {
 313         setRenderHint(QPainter::Antialiasing);
 314         translate(diameter / 2.0, diameter / 2.0);
 315         scale(diameter / 2000.0, -diameter / 2000.0);
 316         setPen(Qt::NoPen);
 317 }
 318
 319
 320 void ClockPainter::drawTick(double angle, double from, double to, double width, const QColor &color, bool shadow)
 321 {
 322         save();
 323         rotate(90.0 - angle);
 324
 325         if (shadow) {
 326                 width += 1.0;
 327                 setBrush(QColor(100, 100, 100));
 328         } else {
 329                 setBrush(color);
 330         }
 331         drawRect(QRectF(from, -width / 2.0, to - from, width));
 332         restore();
 333 }
 334
 335
 336 void ClockPainter::drawDisc(double width, const QColor &color, bool shadow)
 337 {
 338         if (shadow) {
 339                 width += 1.0;
 340                 setBrush(QColor(100, 100, 100));
 341         } else {
 342                 setBrush(color);
 343         }
 344         drawEllipse(QRectF(-width, -width, 2.0 * width, 2.0 * width));
 345 }
 346
 347
 348 void ClockPainter::drawHand(double angle, double length, double width, const QColor &color, bool disc)
 349 {
 350         if (disc)
 351                 drawDisc(width * 1.3, color, true);
 352         drawTick(angle, 0.0, length, width, color, true);
 353
 354         if (disc)
 355                 drawDisc(width * 1.3, color, false);
 356         drawTick(angle, 0.0, length, width, color, false);
 357
 358 }
 359
 360
 361 void ClockPainter::drawScale(const QColor &color)
 362 {
 363         for (int i = 0; i < 360; i += 6)
 364                 if (i % 30)
 365                         drawTick(i, 920.0, 980.0, 15.0, color);
 366                 else
 367                         drawTick(i, 825.0, 980.0, 40.0, color);
 368 }
 369
 370
 371
 372 //-----------------------------------------------------------------------------
 373
 374
 375
 376 KClockSaver::KClockSaver(WId id) :
 377         KScreenSaver(id),
 378         _timer(this),
 379         _xstep(1),
 380         _ystep(-1),
 381         _hour(-1),
 382         _minute(-1),
 383         _second(-1)
 384 {
 385         setAttribute(Qt::WA_NoSystemBackground);
 386         setMinimumSize(50, 50);
 387         readSettings();
 388         resizeClock(_size);
 389
 390         QPalette p = palette();
 391         p.setColor(backgroundRole(), _bgndColor);
 392         setPalette(p);
 393
 394         connect(&_timer, SIGNAL(timeout()), this, SLOT(slotTimeout()));
 395         show();
 396 }
 397
 398
 399 void KClockSaver::readSettings()
 400 {
 401         KConfigGroup settings(KGlobal::config(), "Settings");
 402         _keepCentered = settings.readEntry("KeepCentered", DEFAULT_KEEP_CENTERED);
 403         _size = settings.readEntry("Size", DEFAULT_CLOCK_SIZE);
 404         if (_size > MAX_CLOCK_SIZE)
 405                 _size = MAX_CLOCK_SIZE;
 406
 407         KConfigGroup colors(KGlobal::config(), "Colors");
 408         QColor c = Qt::black;
 409         setBgndColor(colors.readEntry("Background", c));
 410
 411         c = Qt::white;
 412         setScaleColor(colors.readEntry("Scale", c));
 413         setHourColor(colors.readEntry("HourHand", c));
 414         setMinColor(colors.readEntry("MinuteHand", c));
 415
 416         c = Qt::red;
 417         setSecColor(colors.readEntry("SecondHand", c));
 418 }
 419
 420
 421 void KClockSaver::setKeepCentered(bool b)
 422 {
 423         _keepCentered = b;
 424         if (b) {
 425                 _x = (width() - _diameter) / 2;
 426                 _y = (height() - _diameter) / 2;
 427         }
 428         update();
 429 }
 430
 431
 432 void KClockSaver::resizeClock(int size)
 433 {
 434         _size = size;
 435         _diameter = qMin(width(), height()) * (_size + 4) / 14;
 436         _x = (width() - _diameter) / 2;
 437         _y = (height() - _diameter) / 2;
 438         update();
 439 }
 440
 441
 442 void KClockSaver::resizeEvent(QResizeEvent *)
 443 {
 444         resizeClock(_size);
 445 }
 446
 447
 448 void KClockSaver::showEvent(QShowEvent *)
 449 {
 450         _second = -1;
 451         slotTimeout();
 452         _timer.start(TIMER_INTERVAL);
 453 }
 454
 455
 456 void KClockSaver::hideEvent(QHideEvent *)
 457 {
 458         _timer.stop();
 459 }
 460
 461
 462 void KClockSaver::slotTimeout()
 463 {
 464         QTime t = QTime::currentTime();
 465         int s = t.second();
 466         if (s == _second)
 467                 return;
 468
 469         _second = _secColor != _bgndColor ? s : 0;
 470         _hour = t.hour();
 471         _minute = t.minute();
 472
 473         if (!_keepCentered) {
 474                 int i;
 475                 _x += _xstep;
 476                 if (_x <= 0)
 477                         _x = 0, _xstep = 1;
 478                 else if (_x >= (i = width() - _diameter))
 479                         _x = i, _xstep = -1;
 480
 481                 _y += _ystep;
 482                 if (_y <= 0)
 483                         _y = 0, _ystep = 1;
 484                 else if (_y >= (i = height() - _diameter))
 485                         _y = i, _ystep = -1;
 486         }
 487         update();
 488 }
 489
 490
 491 void KClockSaver::paintEvent(QPaintEvent *)
 492 {
 493         double hour_angle = _hour * 30.0 + _minute * .5 + _second / 120.0;
 494         double minute_angle = _minute * 6.0 + _second * .1;
 495         double second_angle = _second * 6.0;
 496
 497         QImage clock(_diameter, _diameter, QImage::Format_RGB32);
 498         ClockPainter c(&clock, _diameter);
 499         c.fillRect(-1000, -1000, 2000, 2000, _bgndColor);
 500
 501         if (_scaleColor != _bgndColor)
 502                 c.drawScale(_scaleColor);
 503         if (_hourColor != _bgndColor)
 504                 c.drawHand(hour_angle, 600.0, 55.0, _hourColor, false);
 505         if (_minColor != _bgndColor)
 506                 c.drawHand(minute_angle, 900.0, 40.0, _minColor);
 507         if (_secColor != _bgndColor)
 508                 c.drawHand(second_angle, 900.0, 30.0, _secColor);
 509
 510         QPainter p(this);
 511         p.drawImage(_x, _y, clock);
 512         p.eraseRect(0, 0, _x, height());                                        // left ver
 513         p.eraseRect(_x + _diameter, 0, width(), height());                      // right ver
 514         p.eraseRect(_x, 0, _diameter, _y);                                      // top hor
 515         p.eraseRect(_x, _y + _diameter, _diameter, height() - _y - _diameter);  // bottom hor
 516 }
 517
 518