1 files changed, 16 insertions, 0 deletions

diff --git a/libkcal/alarm.cpp b/libkcal/alarm.cpp
index 07812c2..29e6205 100644
--- a/libkcal/alarm.cpp
+++ b/libkcal/alarm.cpp
@@ -207,192 +207,208 @@ void Alarm::setMailAddresses(const QValueList<Person> &mailAddresses)
 void Alarm::addMailAddress(const Person &mailAddress)
 {
   if (mType == Email) {
     mMailAddresses += mailAddress;
     mParent->updated();
   }
 }
 
 QValueList<Person> Alarm::mailAddresses() const
 {
   return (mType == Email) ? mMailAddresses : QValueList<Person>();
 }
 
 void Alarm::setMailSubject(const QString &mailAlarmSubject)
 {
   if (mType == Email) {
     mMailSubject = mailAlarmSubject;
     mParent->updated();
   }
 }
 
 QString Alarm::mailSubject() const
 {
   return (mType == Email) ? mMailSubject : QString::null;
 }
 
 void Alarm::setMailAttachment(const QString &mailAttachFile)
 {
   if (mType == Email) {
     mMailAttachFiles.clear();
     mMailAttachFiles += mailAttachFile;
     mParent->updated();
   }
 }
 
 void Alarm::setMailAttachments(const QStringList &mailAttachFiles)
 {
   if (mType == Email) {
     mMailAttachFiles = mailAttachFiles;
     mParent->updated();
   }
 }
 
 void Alarm::addMailAttachment(const QString &mailAttachFile)
 {
   if (mType == Email) {
     mMailAttachFiles += mailAttachFile;
     mParent->updated();
   }
 }
 
 QStringList Alarm::mailAttachments() const
 {
   return (mType == Email) ? mMailAttachFiles : QStringList();
 }
 
 void Alarm::setMailText(const QString &text)
 {
   if (mType == Email) {
     mDescription = text;
     mParent->updated();
   }
 }
 
 QString Alarm::mailText() const
 {
   return (mType == Email) ? mDescription : QString::null;
 }
 
 void Alarm::setDisplayAlarm(const QString &text)
 {
   mType = Display;
   mDescription = text;
   mParent->updated();
 }
 
 void Alarm::setText(const QString &text)
 {
   if (mType == Display) {
     mDescription = text;
     mParent->updated();
   }
 }
 
 QString Alarm::text() const
 {
   return (mType == Display) ? mDescription : QString::null;
 }
 
 void Alarm::setTime(const QDateTime &alarmTime)
 {
   mAlarmTime = alarmTime;
   mHasTime = true;
 
   mParent->updated();
 }
+int Alarm::offset() 
+{
+    if ( hasTime() ) {
+        if (mParent->type()=="Todo") {
+            Todo *t = static_cast<Todo*>(mParent);
+            return  t->dtDue().secsTo( mAlarmTime ) ;
+        } else
+            return mParent->dtStart().secsTo( mAlarmTime ) ;
+    }
+    else
+        {
+            return mOffset.asSeconds();
+        }
+    
+}
+
 
 QDateTime Alarm::time() const
 {
   if ( hasTime() )
     return mAlarmTime;
   else
   {
     if (mParent->type()=="Todo") {
       Todo *t = static_cast<Todo*>(mParent);
       return mOffset.end( t->dtDue() );
     } else if (mEndOffset) {
       return mOffset.end( mParent->dtEnd() );
     } else {
       return mOffset.end( mParent->dtStart() );
     }
   }
 }
 
 bool Alarm::hasTime() const
 {
   return mHasTime;
 }
 
 void Alarm::setSnoozeTime(int alarmSnoozeTime)
 {
   mAlarmSnoozeTime = alarmSnoozeTime;
   mParent->updated();
 }
 
 int Alarm::snoozeTime() const
 {
   return mAlarmSnoozeTime;
 }
 
 void Alarm::setRepeatCount(int alarmRepeatCount)
 {
   kdDebug(5800) << "Alarm::setRepeatCount(): " << alarmRepeatCount << endl;
 
   mAlarmRepeatCount = alarmRepeatCount;
   mParent->updated();
 }
 
 int Alarm::repeatCount() const
 {
   kdDebug(5800) << "Alarm::repeatCount(): " << mAlarmRepeatCount << endl;
   return mAlarmRepeatCount;
 }
 
 void Alarm::toggleAlarm()
 {
   mAlarmEnabled = !mAlarmEnabled;
   mParent->updated();
 }
 
 void Alarm::setEnabled(bool enable)
 {
   mAlarmEnabled = enable;
   mParent->updated();
 }
 
 bool Alarm::enabled() const
 {
   return mAlarmEnabled;
 }
 
 void Alarm::setStartOffset( const Duration &offset )
 {
   mOffset = offset;
   mEndOffset = false;
   mHasTime = false;
   mParent->updated();
 }
 
 Duration Alarm::startOffset() const
 {
   return (mHasTime || mEndOffset) ? 0 : mOffset;
 }
 
 bool Alarm::hasStartOffset() const
 {
   return !mHasTime && !mEndOffset;
 }
 
 bool Alarm::hasEndOffset() const
 {
   return !mHasTime && mEndOffset;
 }
 
 void Alarm::setEndOffset( const Duration &offset )
 {
   mOffset = offset;
   mEndOffset = true;
   mHasTime = false;
   mParent->updated();
 }