fixxx

1 files changed, 115 insertions, 0 deletions

diff --git a/libkcal/event.cpp b/libkcal/event.cpp
index 7cd81fa..235ae55 100644
--- a/libkcal/event.cpp
+++ b/libkcal/event.cpp
@@ -171,6 +171,121 @@ void Event::setDuration(int seconds)
   setHasEndDate(false);
   Incidence::setDuration(seconds);
 }
+bool Event::isOverlapping (  Event* testEvent,  QDateTime* overlapDT, bool inFutureOnly )
+{
+    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() );
+            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() )
+            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() )
+                            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() )
+            testduration += 86400;
+    bool computeThis = false;
+    if ( incidenceStart < testincidenceStart )
+        computeThis = true;
+    bool ok = true;
+    if ( computeThis )
+        incidenceStart = incidenceStart.addSecs( -300 );
+    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() )
+                        return true;
+                } else
+                    return true;
+            }
+            computeThis =  ( incidenceStart < testincidenceStart );
+        }
+        
+    }
+    return false;
+}
 QDateTime Event::getNextAlarmDateTime( bool * ok, int * offset, QDateTime start_dt ) const
 {
     *ok = false;