2 files changed, 57 insertions, 40 deletions

diff --git a/noncore/tools/clock/clock.cpp b/noncore/tools/clock/clock.cpp
index 5b901c1..d69c56f 100644
--- a/noncore/tools/clock/clock.cpp
+++ b/noncore/tools/clock/clock.cpp
@@ -260,272 +260,288 @@ void Clock::slotSet()
         }
         else {
                 swatch_start.start();
                 set
                         ->setText( tr( "Stop" ) );
                 t->start( 1000 );
                 swatch_running = TRUE;
                 // disable screensaver while stop watch is running
                 toggleScreenSaver( FALSE );
         }
 }
 
 void Clock::slotReset()
 {
         t->stop();
         swatch_start.start();
         swatch_totalms = 0;
 
         if ( swatch_running )
                 t->start( 1000 );
 
         updateClock();
 }
 
 void Clock::modeSelect( int m )
 {
         if ( m ) {
                 lcd->setNumDigits( 8 + 1 + sw_prec );
                 lcd->setMinimumWidth( lcd->sizeHint().width() );
                 set
                         ->setEnabled( TRUE );
                 reset->setEnabled( TRUE );
                 ampmLabel->hide();
 
                 if ( !swatch_running )
                         t->stop();
         }
         else {
                 lcd->setNumDigits( 5 );
                 lcd->setMinimumWidth( lcd->sizeHint().width() );
                 set
                         ->setEnabled( FALSE );
                 reset->setEnabled( FALSE );
                 t->start( 1000 );
         }
         updateClock();
 }
 
 //this sets the alarm time
 void Clock::slotSetAlarm()
 {
         if ( !snoozeBtn->isHidden() )
                 slotToggleAlarm();
         Set_Alarm *setAlarmDlg;
         setAlarmDlg = new Set_Alarm( this, "SetAlarm", TRUE );
         int result = setAlarmDlg->exec();
         if ( result == 1 ) {
                 Config config( "qpe" );
                 config.setGroup( "Time" );
                 QString tmp;
                 hour = setAlarmDlg->Hour_Slider->value();
                 minute = setAlarmDlg->Minute_Slider->value();
                 snoozeTime = setAlarmDlg->SnoozeSlider->value();
                 if ( ampm ) {
                         if ( hour == 12 )
                                 hour = 0;
 
                         if ( setAlarmDlg->Pm_RadioButton->isChecked() && hour < 12 )
                                 hour += 12;
                 }
                 config.writeEntry( "clockAlarmHour", tmp.setNum( hour ), 10 );
                 config.writeEntry( "clockAlarmMinute", tmp.setNum( minute ), 10 );
                 config.writeEntry( "clockAlarmSnooze", tmp.setNum( snoozeTime ), 10 );
                 config.write();
         }
 }
 
 void Clock::slotSnooze()
 {
         bSound = FALSE;
         int warn = 0;
         QTime t = QTime::currentTime();
         QDateTime whenl( when.date(), t.addSecs( snoozeTime * 60 ) );
         when = whenl;
         AlarmServer::addAlarm( when,
                                "QPE/Application/clock",
                                "alarm(QDateTime,int)", warn );
 
 }
 
 //toggles alarm on/off
 void Clock::slotToggleAlarm()
 {
         Config config( "qpe" );
         config.setGroup( "Time" );
         if ( alarmBool ) {
                 config.writeEntry( "clockAlarmSet", "FALSE" );
                 alarmOffBtn->setText( tr( "Alarm Is Off" ) );
                 snoozeBtn->hide();
                 alarmBool = FALSE;
                 alarmOff();
         }
         else {
                 config.writeEntry( "clockAlarmSet", "TRUE" );
                 alarmOffBtn->setText( tr( "Alarm Is On" ) );
                 snoozeBtn->show();
                 alarmBool = TRUE;
                 alarmOn();
         }
         config.write();
 }
 
 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::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 ) ) {
 
                         QCopEnvelope e( "QPE/Application/opieplayer", "setDocument(QString)" );
                         e << config.readEntry( "mp3File", "" );
                 }
                 else {
 
                         Sound::soundAlarm();
                         stopTimer = startTimer( timerStay );
                 }
         }
         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() );
                 alarmOffBtn->setText( tr( "Alarm Is Off" ) );
                 alarmBool = FALSE;
                 snoozeBtn->hide();
                 setCaption( tr( "Clock: Alarm was missed." ) );
         }
 }
 
 
 QSizePolicy AnalogClock::sizePolicy() const
 {
         return QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
 }
 
 void AnalogClock::drawContents( QPainter *p )
 {
         QRect r = contentsRect();
-        QPoint center( r.x() + r.width() / 2, r.y() + r.height() / 2 );
-
-        QPoint l1( r.x() + r.width() / 2, r.y() + 2 );
-        QPoint l2( r.x() + r.width() / 2, r.y() + 8 );
-
-        QPoint h1( r.x() + r.width() / 2, r.y() + r.height() / 4 );
-        QPoint h2( r.x() + r.width() / 2, r.y() + r.height() / 2 );
+        QRect fr;
 
-        QPoint m1( r.x() + r.width() / 2, r.y() + r.height() / 8 );
-        QPoint m2( r.x() + r.width() / 2, r.y() + r.height() / 2 );
+        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 );
 
-        QPoint s1( r.x() + r.width() / 2, r.y() + 8 );
-        QPoint s2( r.x() + r.width() / 2, r.y() + r.height() / 2 );
 
-        QColor color( clear ? backgroundColor() : black );
-        QTime time = clear ? prevTime : currTime;
 
         if ( clear ) {
-                erase( rect() );
-                return ;
-        }
+                erase ( r );
+                p-> setPen ( NoPen );
+                p-> setBrush ( colorGroup ( ). color ( QColorGroup::Base ));
+                p-> drawEllipse ( fr );
+                        p-> setBrush ( NoBrush );
 
-        if ( !clear ) {
                 // draw ticks
-                p->setPen( QPen( color, 1 ) );
+                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.x() + r.width() / 2, r.y() + r.height() / 2 );
 
-        if ( !clear || prevTime.minute() != currTime.minute() ||
-                prevTime.hour() != currTime.hour() ) {
+        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 * ( time.hour() % 12 ) + time.minute() / 2 );
-                h2 = rotate( center, h2, 30 * ( time.hour() % 12 ) + time.minute() / 2 );
-                p->setPen( QPen( color, 3 ) );
-                p->drawLine( h1, h2 );
+                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 ( !clear || prevTime.minute() != currTime.minute() ) {
+        if ( !t2 || ( t. minute ( ) != t2-> minute ( ))) {
                 // draw minute pointer
-                m1 = rotate( center, m1, time.minute() * 6 );
-                m2 = rotate( center, m2, time.minute() * 6 );
-                p->setPen( QPen( color, 2 ) );
-                p->drawLine( m1, m2 );
+                m1 = rotate( center, m1, t.minute() * 6 );
+                m2 = rotate( center, m2, t.minute() * 6 );
+                p-> setPen ( QPen ( c, 2 ));
+                p-> drawLine ( m1, m2 );
         }
 
-        // draw second pointer
-        s1 = rotate( center, s1, time.second() * 6 );
-        s2 = rotate( center, s2, time.second() * 6 );
-        p->setPen( QPen( color, 1 ) );
-        p->drawLine( s1, s2 );
-
-        if ( !clear )
-                prevTime = currTime;
+        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 = true;
-        repaint( false );
         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 be71b9d..092d84f 100644
--- a/noncore/tools/clock/clock.h
+++ b/noncore/tools/clock/clock.h
@@ -1,98 +1,99 @@
 /**********************************************************************
 ** 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>
 
 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(false) {}
+  : QFrame( parent, name ), clear(true) {}
 
     QSizePolicy sizePolicy() const;
 
     void display( const QTime& time );
 
 protected:
     void drawContents( QPainter *p );
 
 private:
     QPoint rotate( QPoint center, QPoint p, int angle );
+    void drawPointers ( QPainter *, const QRect &r, const QColor &c, const QTime &t, const QTime *t2 = 0 );
 
     QTime currTime;
     QTime prevTime;
     bool clear;
 };
 
 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();
 private:
     void clearClock();
 
     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;
 };
 
 #endif