Skip to content

Commit

Permalink
Browse files Browse the repository at this point in the history
[nemo-qml-plugin-calendar] Include recurrences in agenda model
  • Loading branch information
Aaron Kennedy committed Jul 1, 2013
1 parent 325ddac commit 709dfc5
Show file tree
Hide file tree
Showing 4 changed files with 169 additions and 25 deletions.
50 changes: 26 additions & 24 deletions src/calendaragendamodel.cpp
Expand Up @@ -46,6 +46,7 @@ NemoCalendarAgendaModel::NemoCalendarAgendaModel(QObject *parent)
mRerefreshNeeded(false)
{
mRoleNames[EventObjectRole] = "event";
mRoleNames[OccurrenceObjectRole] = "occurrence";
mRoleNames[SectionBucketRole] = "sectionBucket";
mRoleNames[NotebookColorRole] = "notebookColor";

Expand Down Expand Up @@ -116,42 +117,38 @@ void NemoCalendarAgendaModel::refresh()
}
}

static bool eventsEqual(const KCalCore::Event::Ptr &e1, const KCalCore::Event::Ptr &e2)
static bool eventsEqual(const mKCal::ExtendedCalendar::ExpandedIncidence &e1,
const mKCal::ExtendedCalendar::ExpandedIncidence &e2)
{
return e1 == e2 || e1->uid() == e2->uid();
return e1.first.dtStart == e2.first.dtStart &&
e1.first.dtEnd == e2.first.dtEnd &&
e1.second->uid() == e2.second->uid();
}

static bool eventsLessThan(const KCalCore::Event::Ptr &e1, const KCalCore::Event::Ptr &e2)
static bool eventsLessThan(const mKCal::ExtendedCalendar::ExpandedIncidence &e1,
const mKCal::ExtendedCalendar::ExpandedIncidence &e2)
{
const KDateTime d1 = e1->dtStart();
KDateTime::Comparison res = d1.compare(e2->dtStart());
if (res == KDateTime::Equal) {
int cmp = QString::compare(e1->summary(), e2->summary(), Qt::CaseInsensitive);
if (cmp == 0) return QString::compare(e1->uid(), e2->uid()) < 0;
if (e1.first.dtStart == e2.first.dtStart) {
int cmp = QString::compare(e1.second->summary(), e2.second->summary(), Qt::CaseInsensitive);
if (cmp == 0) return QString::compare(e1.second->uid(), e2.second->uid()) < 0;
else return cmp < 0;
} else {
return (res & KDateTime::Before || res & KDateTime::AtStart);
return e1.first.dtStart < e2.first.dtStart;
}
}

void NemoCalendarAgendaModel::doRefresh()
{
mKCal::ExtendedCalendar::Ptr calendar = NemoCalendarDb::calendar();

// Sorting function
bool (*lessThan)(const KCalCore::Event::Ptr &e1, const KCalCore::Event::Ptr &e2);
lessThan = eventsLessThan;
QDate endDate = mEndDate.isValid()?mEndDate:mStartDate;

// Matching function
bool (*equal)(const KCalCore::Event::Ptr &e1, const KCalCore::Event::Ptr &e2);
equal = eventsEqual;
mKCal::ExtendedCalendar::ExpandedIncidenceList newEvents =
calendar->rawExpandedEvents(mStartDate, endDate, false, false, KDateTime::Spec(KDateTime::LocalZone));

qSort(newEvents.begin(), newEvents.end(), eventsLessThan);

KCalCore::Event::List newEvents = calendar->rawEvents(mStartDate, mEndDate.isValid()?mEndDate:mStartDate,
KDateTime::Spec(KDateTime::LocalZone));
qSort(newEvents.begin(), newEvents.end(), lessThan);

QList<NemoCalendarEvent *> events = mEvents;
QList<NemoCalendarEventOccurrence *> events = mEvents;

int newEventsCounter = 0;
int eventsCounter = 0;
Expand All @@ -163,7 +160,8 @@ void NemoCalendarAgendaModel::doRefresh()
int removeCount = 0;
while ((eventsCounter + removeCount) < events.count() &&
(newEventsCounter >= newEvents.count() ||
lessThan(events.at(eventsCounter + removeCount)->event(), newEvents.at(newEventsCounter))))
eventsLessThan(events.at(eventsCounter + removeCount)->expandedEvent(),
newEvents.at(newEventsCounter))))
removeCount++;

if (removeCount) {
Expand All @@ -177,7 +175,7 @@ void NemoCalendarAgendaModel::doRefresh()

// Skip matching events
while (eventsCounter < events.count() && newEventsCounter < newEvents.count() &&
equal(newEvents.at(newEventsCounter), events.at(eventsCounter)->event())) {
eventsEqual(newEvents.at(newEventsCounter), events.at(eventsCounter)->expandedEvent())) {
eventsCounter++;
newEventsCounter++;
mEventsIndex++;
Expand All @@ -187,13 +185,15 @@ void NemoCalendarAgendaModel::doRefresh()
int insertCount = 0;
while ((newEventsCounter + insertCount) < newEvents.count() &&
(eventsCounter >= events.count() ||
lessThan(newEvents.at(newEventsCounter + insertCount), events.at(eventsCounter)->event())))
eventsLessThan(newEvents.at(newEventsCounter + insertCount),
events.at(eventsCounter)->expandedEvent())))
insertCount++;

if (insertCount) {
beginInsertRows(QModelIndex(), mEventsIndex, mEventsIndex + insertCount - 1);
for (int ii = 0; ii < insertCount; ++ii) {
NemoCalendarEvent *event = new NemoCalendarEvent(newEvents.at(newEventsCounter + ii));
NemoCalendarEventOccurrence *event =
new NemoCalendarEventOccurrence(newEvents.at(newEventsCounter + ii));
mEvents.insert(mEventsIndex++, event);
}
newEventsCounter += insertCount;
Expand Down Expand Up @@ -244,6 +244,8 @@ QVariant NemoCalendarAgendaModel::data(const QModelIndex &index, int role) const

switch (role) {
case EventObjectRole:
return QVariant::fromValue<QObject *>(mEvents.at(index.row())->event());
case OccurrenceObjectRole:
return QVariant::fromValue<QObject *>(mEvents.at(index.row()));
case SectionBucketRole:
return mEvents.at(index.row())->startTime().date();
Expand Down
4 changes: 3 additions & 1 deletion src/calendaragendamodel.h
Expand Up @@ -37,6 +37,7 @@

#include "calendarabstractmodel.h"
class NemoCalendarEvent;
class NemoCalendarEventOccurrence;

class NemoCalendarAgendaModel : public NemoCalendarAbstractModel
{
Expand All @@ -51,6 +52,7 @@ class NemoCalendarAgendaModel : public NemoCalendarAbstractModel
public:
enum {
EventObjectRole = Qt::UserRole,
OccurrenceObjectRole,
SectionBucketRole,
NotebookColorRole
};
Expand Down Expand Up @@ -95,7 +97,7 @@ private slots:
QDate mStartDate;
QDate mEndDate;
int mBuffer;
QList<NemoCalendarEvent *> mEvents;
QList<NemoCalendarEventOccurrence *> mEvents;
QHash<int,QByteArray> mRoleNames;

bool mRefreshingModel:1;
Expand Down
91 changes: 91 additions & 0 deletions src/calendarevent.cpp
Expand Up @@ -31,6 +31,8 @@
*/

#include "calendarevent.h"

#include <QQmlInfo>
#include "calendardb.h"

NemoCalendarEvent::NemoCalendarEvent(QObject *parent)
Expand Down Expand Up @@ -115,6 +117,72 @@ void NemoCalendarEvent::setAllDay(bool a)
emit allDayChanged();
}

NemoCalendarEvent::Recur NemoCalendarEvent::recur() const
{
if (mEvent->recurs()) {
if (mEvent->recurrence()->rRules().count() != 1) {
return RecurCustom;
} else {
ushort rt = mEvent->recurrence()->recurrenceType();
int freq = mEvent->recurrence()->frequency();

if (rt == KCalCore::Recurrence::rDaily && freq == 1) {
return RecurDaily;
} else if (rt == KCalCore::Recurrence::rWeekly && freq == 1) {
return RecurWeekly;
} else if (rt == KCalCore::Recurrence::rWeekly && freq == 2) {
return RecurBiweekly;
} else if (rt == KCalCore::Recurrence::rMonthlyDay && freq == 1) {
return RecurMonthly;
} else if (rt == KCalCore::Recurrence::rYearlyMonth && freq == 1) {
return RecurYearly;
} else {
return RecurCustom;
}
}
} else {
return RecurOnce;
}
}

void NemoCalendarEvent::setRecur(Recur r)
{
Recur oldRecur = recur();

if (r == RecurCustom) {
qmlInfo(this) << "Cannot assign RecurCustom";
r = RecurOnce;
}

if (r == RecurOnce)
mEvent->recurrence()->clear();

if (oldRecur == r)
return;

switch (r) {
case RecurOnce:
break;
case RecurDaily:
mEvent->recurrence()->setDaily(1);
break;
case RecurWeekly:
mEvent->recurrence()->setWeekly(1);
break;
case RecurBiweekly:
mEvent->recurrence()->setWeekly(2);
break;
case RecurMonthly:
mEvent->recurrence()->setMonthly(1);
break;
case RecurYearly:
mEvent->recurrence()->setYearly(1);
break;
}

emit recurChanged();
}

void NemoCalendarEvent::save()
{
if (mEvent->revision() == 0) {
Expand All @@ -127,3 +195,26 @@ void NemoCalendarEvent::save()
// TODO: this sucks
NemoCalendarDb::storage()->save();
}

NemoCalendarEventOccurrence::NemoCalendarEventOccurrence(const mKCal::ExtendedCalendar::ExpandedIncidence &o,
QObject *parent)
: QObject(parent), mOccurrence(o), mEvent(0)
{
}

QDateTime NemoCalendarEventOccurrence::startTime() const
{
return mOccurrence.first.dtStart;
}

QDateTime NemoCalendarEventOccurrence::endTime() const
{
return mOccurrence.first.dtEnd;
}

NemoCalendarEvent *NemoCalendarEventOccurrence::event()
{
if (!mEvent) mEvent = new NemoCalendarEvent(mOccurrence.second.dynamicCast<KCalCore::Event>(), this);
return mEvent;
}

49 changes: 49 additions & 0 deletions src/calendarevent.h
Expand Up @@ -38,12 +38,24 @@

// mkcal
#include <event.h>
#include <extendedcalendar.h>

class NemoCalendarEvent : public QObject
{
Q_OBJECT
Q_ENUMS(Recur)

public:
enum Recur {
RecurOnce,
RecurDaily,
RecurWeekly,
RecurBiweekly,
RecurMonthly,
RecurYearly,
RecurCustom
};

explicit NemoCalendarEvent(QObject *parent = 0);
NemoCalendarEvent(const KCalCore::Event::Ptr &event, QObject *parent = 0);

Expand All @@ -67,6 +79,10 @@ class NemoCalendarEvent : public QObject
bool allDay() const;
void setAllDay(bool);

Q_PROPERTY(Recur recur READ recur WRITE setRecur NOTIFY recurChanged)
Recur recur() const;
void setRecur(Recur);

Q_INVOKABLE void save();

inline KCalCore::Event::Ptr &event();
Expand All @@ -77,11 +93,34 @@ class NemoCalendarEvent : public QObject
void startTimeChanged();
void endTimeChanged();
void allDayChanged();
void recurChanged();

private:
KCalCore::Event::Ptr mEvent;
};

class NemoCalendarEventOccurrence : public QObject
{
Q_OBJECT
Q_PROPERTY(QDateTime startTime READ startTime CONSTANT)
Q_PROPERTY(QDateTime endTime READ endTime CONSTANT)
Q_PROPERTY(NemoCalendarEvent *event READ event CONSTANT)

public:
NemoCalendarEventOccurrence(const mKCal::ExtendedCalendar::ExpandedIncidence &,
QObject *parent = 0);

QDateTime startTime() const;
QDateTime endTime() const;
NemoCalendarEvent *event();

inline mKCal::ExtendedCalendar::ExpandedIncidence &expandedEvent();
inline const mKCal::ExtendedCalendar::ExpandedIncidence &expandedEvent() const;
private:
mKCal::ExtendedCalendar::ExpandedIncidence mOccurrence;
NemoCalendarEvent *mEvent;
};

KCalCore::Event::Ptr &NemoCalendarEvent::event()
{
return mEvent;
Expand All @@ -92,4 +131,14 @@ const KCalCore::Event::Ptr &NemoCalendarEvent::event() const
return mEvent;
}

mKCal::ExtendedCalendar::ExpandedIncidence &NemoCalendarEventOccurrence::expandedEvent()
{
return mOccurrence;
}

const mKCal::ExtendedCalendar::ExpandedIncidence &NemoCalendarEventOccurrence::expandedEvent() const
{
return mOccurrence;
}

#endif // CALENDAREVENT_H

0 comments on commit 709dfc5

Please sign in to comment.