fixxx

2 files changed, 9 insertions, 9 deletions

diff --git a/libkcal/event.cpp b/libkcal/event.cpp
index 235ae55..46e8174 100644
--- a/libkcal/event.cpp
+++ b/libkcal/event.cpp
@@ -158,96 +158,96 @@ void Event::setTransparency(Event::Transparency transparency)
 {
   if (mReadOnly) return;
   mTransparency = transparency;
   updated();
 }
 
 Event::Transparency Event::transparency() const
 {
   return mTransparency;
 }
 
 void Event::setDuration(int seconds)
 {
   setHasEndDate(false);
   Incidence::setDuration(seconds);
 }
-bool Event::isOverlapping (  Event* testEvent,  QDateTime* overlapDT, bool inFutureOnly )
+bool Event::isOverlapping (  Event* testEvent,  QDateTime* overlapDT, QDateTime* startDT )
 {
     if ( testEvent == this )
         return false;
     if ( ! doesRecur() && !testEvent->doesRecur() ) {
         QDateTime te;
         if ( testEvent->doesFloat() )
             te = testEvent->mDtEnd.addDays( 1 );
         else
             te = testEvent->mDtEnd;
         QDateTime e; 
         if ( doesFloat() )
             e = mDtEnd.addDays( 1 );
         else
             e = mDtEnd;
         if ( mDtStart < te && testEvent->mDtStart < e ) {
             if ( mDtStart < testEvent->mDtStart )
                 *overlapDT =  testEvent->mDtStart;
             else
                 *overlapDT =  mDtStart;
-            if ( inFutureOnly )
-                return (*overlapDT >= QDateTime::currentDateTime() );
+            if ( startDT )
+                return (*overlapDT >= *startDT );
             return true;
         }
         return false;
     }
     Event *nonRecur = 0;
     Event *recurEvent = 0;
     if ( ! doesRecur() ) {
         nonRecur = this;
         recurEvent = testEvent;
     }
     else if ( !testEvent->doesRecur() ) {
         nonRecur = testEvent;
         recurEvent = this;
     }
     if ( nonRecur ) {
         QDateTime enr; 
         if ( nonRecur->doesFloat() )
             enr = nonRecur->mDtEnd.addDays( 1 );
         else
             enr = nonRecur->mDtEnd;
         if ( enr < recurEvent->mDtStart )
             return false;
-        if ( inFutureOnly && enr < QDateTime::currentDateTime() )
+        if ( startDT && enr < *startDT )
             return false;
         int recDuration = recurEvent->mDtStart.secsTo( recurEvent->mDtEnd );
         if ( recurEvent->doesFloat() )
             recDuration += 86400;
         bool ok = true;
         QDateTime recStart = recurEvent->mDtStart.addSecs( -300);;
         while ( ok ) {
             recStart = recurEvent->getNextOccurence( recStart.addSecs( 60 ), &ok );
             if ( ok ) {
                 if ( recStart > enr )
                     return false;
                 QDateTime recEnd = recStart.addSecs( recDuration  );
                 if ( nonRecur->mDtStart < recEnd && recStart < nonRecur->mDtEnd ) {
                     if ( nonRecur->mDtStart < recStart )
                         *overlapDT =  recStart;
                     else
                         *overlapDT =  nonRecur->mDtStart;
-                    if ( inFutureOnly ) {
-                        if ( *overlapDT >= QDateTime::currentDateTime() )
+                    if ( startDT  ) {
+                        if ( *overlapDT >= *startDT )
                             return true;
                     } else
                         return true;
                 }
             }
         }
         return false;
     }
     
     QDateTime incidenceStart = mDtStart;
     int duration = mDtStart.secsTo( mDtEnd );
     if ( doesFloat() )
             duration += 86400;
     QDateTime testincidenceStart = testEvent->mDtStart;
     int testduration = testEvent->mDtStart.secsTo( testEvent->mDtEnd );
     if ( testEvent->doesFloat() )
@@ -261,34 +261,34 @@ bool Event::isOverlapping (  Event* testEvent,  QDateTime* overlapDT, bool inFut
     else
         testincidenceStart = testincidenceStart.addSecs( -300 );
     int count = 0;
     while ( ok ) {
         ++count;
         if ( count > 1000 ) break;
         if ( computeThis )
             incidenceStart = getNextOccurence( incidenceStart.addSecs( 60 ), &ok );
         else
             testincidenceStart = testEvent->getNextOccurence( testincidenceStart.addSecs( 60 ), &ok );
         if ( ok ) {
             if ( incidenceStart < testincidenceStart.addSecs( testduration ) && testincidenceStart < incidenceStart.addSecs( duration ) ) {
                 if ( incidenceStart < testincidenceStart )
                     *overlapDT =  testincidenceStart;
                 else
                     *overlapDT =  incidenceStart; 
-                if ( inFutureOnly ) {
-                    if ( *overlapDT >= QDateTime::currentDateTime() )
+                if (  startDT ) {
+                    if ( *overlapDT >= *startDT )
                         return true;
                 } else
                     return true;
             }
             computeThis =  ( incidenceStart < testincidenceStart );
         }
         
     }
     return false;
 }
 QDateTime Event::getNextAlarmDateTime( bool * ok, int * offset, QDateTime start_dt ) const
 {
     *ok = false;
     if ( !alarmEnabled() )
         return QDateTime ();
     bool yes;
diff --git a/libkcal/event.h b/libkcal/event.h
index 80c11c4..e6055a5 100644
--- a/libkcal/event.h
+++ b/libkcal/event.h
@@ -61,33 +61,33 @@ class Event : public Incidence
     void setHasEndDate(bool);
     /** Return whether the event has an end date/time. */
     bool hasEndDate() const;
 
     /** Return true if the event spans multiple days, otherwise return false. */
     bool isMultiDay() const;
 
     /** set the event's time transparency level. */
     void setTransparency(Transparency transparency);
     /** get the event's time transparency level. */
     Transparency transparency() const;
 
     void setDuration(int seconds);
 
     bool contains ( Event*);
 
-    bool isOverlapping (  Event*,  QDateTime*, bool inFutureOnly );
+    bool isOverlapping (  Event*,  QDateTime*, QDateTime* );
 
   private:
     bool accept(Visitor &v) { return v.visit(this); }
 
     QDateTime mDtEnd;
     bool mHasEndDate;
     Transparency mTransparency;
 };
 
 bool operator==( const Event&, const Event& );
 
 
 }
 
 
 #endif