Add background to the clock.

3 files changed, 9 insertions, 2 deletions

diff --git a/noncore/tools/clock/clock.cpp b/noncore/tools/clock/clock.cpp
index 74b7147..41c99a8 100644
--- a/noncore/tools/clock/clock.cpp
+++ b/noncore/tools/clock/clock.cpp
@@ -423,203 +423,209 @@ void Clock::alarmOn()
 {
   QDate d = QDate::currentDate();
   QTime tm( ( int ) hour, ( int ) minute, 0 );
   qDebug( "Time set " + tm.toString() );
   QTime t = QTime::currentTime();
   if ( t > tm )
     d = d.addDays( 1 );
   int warn = 0;
   QDateTime whenl( d, tm );
   when = whenl;
   AlarmServer::addAlarm( when,
                          "QPE/Application/clock",
                          "alarm(QDateTime,int)", warn );
   setCaption( "Alarm set: " + whenl.toString() );
 }
 
 void Clock::alarmOff()
 {
   int warn = 0;
   bSound = FALSE;
   AlarmServer::deleteAlarm( when,
                             "QPE/Application/clock",
                             "alarm(QDateTime,int)", warn );
   qDebug( "Alarm Off " + when.toString() );
   setCaption( "Clock" );
 }
 
 void Clock::clearTimer()
 {
   alarmOffBtn->setText( tr( "Alarm Is Off" ) );
   alarmBool = FALSE;
   snoozeBtn->hide();
   setCaption( "Clock" );
 }
 
 void Clock::appMessage( const QCString& msg, const QByteArray& /*data*/ )
 {
   int stopTimer = 0;
   int timerStay = 5000;
   bSound = TRUE;
   qDebug( "Message received in clock" );
   if ( msg == "alarm(QDateTime,int)" )
     {
       Config config( "qpe" );
       config.setGroup( "Time" );
       if ( config.readBoolEntry( "mp3Alarm", 0 ) )
         {
           clearTimer();
           pthread_t thread;
           pthread_create(&thread, NULL,  (void * (*) (void *))startPlayer, NULL/* &*/);
 
         }
       else
         {
 
           Sound::soundAlarm();
           stopTimer = startTimer( timerStay );
         }
     }
 
   if ( msg == "timerStart()" )
     {
       slotStartTimer();
     }
   if ( msg == "timerStop()" )
     {
       slotStopTimer();
     }
   if ( msg == "timerReset()" )
     {
       slotResetTimer();
     }
 
   show();
   raise();
   QPEApplication::setKeepRunning();
   setActiveWindow();
 }
 
 void Clock::timerEvent( QTimerEvent *e )
 {
   static int stop = 0;
   if ( stop < 120 && bSound )
     {
       Sound::soundAlarm();
       stop++;
     }
   else
     {
       stop = 0;
       killTimer( e->timerId() );
       clearTimer();
       setCaption( tr( "Clock: Alarm was missed." ) );
     }
 }
 
+AnalogClock::AnalogClock(QWidget * parent, const char * name) : QFrame( parent, name ), clear(true)
+{
+  bg = Resource::loadPixmap("clock/bg");
+}
 
 QSizePolicy AnalogClock::sizePolicy() const
 {
   return QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
 }
 
 void AnalogClock::drawContents( QPainter *p )
 {
   QRect r = contentsRect();
   QRect fr;
 
+  p->drawPixmap(QPoint(0, 0), bg, r);
+
   if ( r. width ( ) > r. height ( ))
     fr. setRect (( r. width ( ) - r. height ( )) / 2, r. y ( ), r. height ( ), r. height ( ));
   else
     fr. setRect ( r. x ( ), ( r. height ( ) - r. width ( )) / 2, r. width ( ), r. width ( ));
 
   QPoint center = fr. center ( ); // ( fr.x() + fr.width() / 2, fr.y() + fr.height() / 2 );
   QPoint l1 ( center. x ( ), fr. y ( ) + 2 );
   QPoint l2 ( center. x ( ), fr. y ( ) + 8 );
 
 
 
   if ( clear )
     {
       erase ( r );
       p-> setPen ( NoPen );
       p-> setBrush ( colorGroup ( ). color ( QColorGroup::Base ));
       p-> drawEllipse ( fr );
       p-> setBrush ( NoBrush );
 
         // draw ticks
       p->setPen( QPen( colorGroup ( ). color ( QColorGroup::Text ), 1 ) );
       for ( int i = 0; i < 12; i++ )
         p->drawLine( rotate( center, l1, i * 30 ), rotate( center, l2, i * 30 ) );
     }
   else
     {
       drawPointers ( p, fr, colorGroup ( ). color ( QColorGroup::Base ), prevTime, &currTime );
     }
 
   drawPointers ( p, fr, colorGroup ( ). color ( QColorGroup::Text ), currTime );
 
   prevTime = currTime;
 }
 
 void AnalogClock::drawPointers ( QPainter *p, const QRect &r, const QColor &c, const QTime &t, const QTime *t2 )
 {
   QPoint center = r. center ( );
 
   QPoint h1( center. x ( ), r. y ( ) + r. height ( ) / 4 );
   QPoint h2( center. x ( ), center. y ( ) );
 
   QPoint m1( center. x ( ), r.y() + r.height() / 8 );
   QPoint m2( center. x ( ), center. y ( ) );
 
   QPoint s1( center. x ( ), r. y ( ) + 8 );
   QPoint s2( center. x ( ), center. y ( ) );
 
 
   if ( !t2 || ( t. minute ( ) != t2-> minute ( ) || t. hour ( ) != t2-> hour ( ))) {
       // draw hour pointer
     h1 = rotate( center, h1, 30 * ( t.hour() % 12 ) + t.minute() / 2 );
     h2 = rotate( center, h2, 30 * ( t.hour() % 12 ) + t.minute() / 2 );
     p-> setPen ( QPen ( c, 3 ));
     p-> drawLine ( h1, h2 );
   }
 
   if ( !t2 || ( t. minute ( ) != t2-> minute ( ))) {
       // draw minute pointer
     m1 = rotate( center, m1, t.minute() * 6 );
     m2 = rotate( center, m2, t.minute() * 6 );
     p-> setPen ( QPen ( c, 2 ));
     p-> drawLine ( m1, m2 );
   }
 
   if ( !t2 || ( t. second ( ) != t2-> second ( ))) {
       // draw second pointer
     s1 = rotate( center, s1, t.second() * 6 );
     s2 = rotate( center, s2, t.second() * 6 );
     p-> setPen ( QPen ( c, 1 ));
     p-> drawLine ( s1, s2 );
   }
 }
 
 void AnalogClock::display( const QTime& t )
 {
   currTime = t;
   clear = false;
   repaint( false );
   clear = true;
 }
 
 QPoint AnalogClock::rotate( QPoint c, QPoint p, int a )
 {
   double angle = deg2rad * ( - a + 180 );
   double nx = c.x() - ( p.x() - c.x() ) * cos( angle ) -
               ( p.y() - c.y() ) * sin( angle );
   double ny = c.y() - ( p.y() - c.y() ) * cos( angle ) +
               ( p.x() - c.x() ) * sin( angle );
   return QPoint( nx, ny );
 }
 
 void Clock::slotAdjustTime()
 {
   QCopEnvelope e( "QPE/System", "execute(QString)" );
   e << QString( "systemtime" );
 }
diff --git a/noncore/tools/clock/clock.h b/noncore/tools/clock/clock.h
index 1e5aa2c..fa12b61 100644
--- a/noncore/tools/clock/clock.h
+++ b/noncore/tools/clock/clock.h
@@ -1,108 +1,109 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #ifndef CLOCK_H
 #define CLOCK_H
 
 #include <qdatetime.h>
 #include <qvbox.h>
+#include <qpixmap.h>
 
 class QLCDNumber;
 class QLabel;
 class QTimer;
 class QRadioButton;
 class QPushButton;
 class QDateTime;
 
 class AnalogClock : public QFrame
 {
     Q_OBJECT
 
 public:
-    AnalogClock( QWidget * parent = 0, const char * name = 0 )
-  : QFrame( parent, name ), clear(true) {}
+    AnalogClock( QWidget * parent = 0, const char * name = 0 );
 
     QSizePolicy sizePolicy() const;
 
     void display( const QTime& time );
 
 protected:
     void drawContents( QPainter *p );
 
 private:
 
+    QPixmap bg;
     QTime currTime;
     QTime prevTime;
     bool clear;
 
         QPoint rotate( QPoint center, QPoint p, int angle );
         void drawPointers ( QPainter *, const QRect &r, const QColor &c, const QTime &t, const QTime *t2 = 0 );
 
 };
 
 class Clock : public QVBox
 {
     Q_OBJECT
 
 public:
     Clock( QWidget * parent = 0, const char * name = 0, WFlags f=0 );
     ~Clock();
     QDateTime when;
     bool bSound;
     int hour, minute, snoozeTime;
 private slots:
     void slotSet();
     void slotReset();
     void modeSelect(int);
     void updateClock();
     void changeClock( bool );
     void slotSetAlarm();
     void slotSnooze();
     void slotToggleAlarm();
     void alarmOn();
     void alarmOff();
     void appMessage(const QCString& msg, const QByteArray& data);
     void timerEvent( QTimerEvent *e );
     void slotAdjustTime();
 
         void slotStartTimer();
         void slotStopTimer();
         void slotResetTimer();
         void setSwatchMode( int );
 private:
     bool alarmBool;
     QTimer *t;
     QLCDNumber *lcd;
     QLabel *date;
     QLabel *ampmLabel;
     QPushButton *set, *reset, *alarmBtn, *snoozeBtn, *alarmOffBtn;
     QRadioButton *clockRB, *swatchRB;
     AnalogClock *aclock;
     QTime swatch_start;
     int swatch_totalms;
     bool swatch_running;
     bool ampm;
     void clearClock();
     void clearTimer();
     void startSWatch();
     void stopSWatch();
 };
 
 #endif
 
diff --git a/pics/clock/bg.png b/pics/clock/bg.png
new file mode 100644
index 0000000..0954ca6
--- a/dev/null
+++ b/pics/clock/bg.png