diff --git a/autotests/fbrecurring.cpp b/autotests/fbrecurring.cpp
--- a/autotests/fbrecurring.cpp
+++ b/autotests/fbrecurring.cpp
@@ -29,7 +29,7 @@
 #include <QDate>
 #include <QTimeZone>
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 using namespace std;
 
 int main()
diff --git a/autotests/incidencestest.cpp b/autotests/incidencestest.cpp
--- a/autotests/incidencestest.cpp
+++ b/autotests/incidencestest.cpp
@@ -27,7 +27,7 @@
 #include <QCoreApplication>
 #include <QCommandLineParser>
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 int main(int argc, char **argv)
 {
diff --git a/autotests/loadcalendar.cpp b/autotests/loadcalendar.cpp
--- a/autotests/loadcalendar.cpp
+++ b/autotests/loadcalendar.cpp
@@ -27,7 +27,7 @@
 #include <QCommandLineParser>
 #include <QTimeZone>
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 int main(int argc, char **argv)
 {
diff --git a/autotests/readandwrite.cpp b/autotests/readandwrite.cpp
--- a/autotests/readandwrite.cpp
+++ b/autotests/readandwrite.cpp
@@ -30,7 +30,7 @@
 #include <QCommandLineParser>
 #include <QTimeZone>
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 int main(int argc, char **argv)
 {
diff --git a/autotests/testalarm.cpp b/autotests/testalarm.cpp
--- a/autotests/testalarm.cpp
+++ b/autotests/testalarm.cpp
@@ -25,7 +25,7 @@
 #include <QTest>
 QTEST_MAIN(AlarmTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void AlarmTest::testValidity()
 {
@@ -66,7 +66,7 @@
 
 void AlarmTest::testSerializer_data()
 {
-    QTest::addColumn<KCalCore::Alarm::Ptr>("alarm");
+    QTest::addColumn<KCalendarCore::Alarm::Ptr>("alarm");
     Alarm::Ptr a1 = Alarm::Ptr(new Alarm(nullptr));
     Alarm::Ptr a2 = Alarm::Ptr(new Alarm(nullptr));
     Alarm::Ptr a3 = Alarm::Ptr(new Alarm(nullptr));
@@ -111,7 +111,7 @@
 
 void AlarmTest::testSerializer()
 {
-    QFETCH(KCalCore::Alarm::Ptr, alarm);
+    QFETCH(KCalendarCore::Alarm::Ptr, alarm);
 
     QByteArray array;
     QDataStream stream(&array, QIODevice::WriteOnly);
diff --git a/autotests/testattachment.cpp b/autotests/testattachment.cpp
--- a/autotests/testattachment.cpp
+++ b/autotests/testattachment.cpp
@@ -25,7 +25,7 @@
 #include <QTest>
 QTEST_MAIN(AttachmentTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void AttachmentTest::testValidity()
 {
@@ -72,7 +72,7 @@
 
 void AttachmentTest::testSerializer_data()
 {
-    QTest::addColumn<KCalCore::Attachment>("attachment");
+    QTest::addColumn<KCalendarCore::Attachment>("attachment");
 
     Attachment nonInline(QStringLiteral("http://www.kde.org"));
     Attachment inlineAttachment(QByteArray("foo"), QStringLiteral("image/nonsense"));
@@ -83,7 +83,7 @@
 
 void AttachmentTest::testSerializer()
 {
-    QFETCH(KCalCore::Attachment, attachment);
+    QFETCH(KCalendarCore::Attachment, attachment);
 
     QByteArray array;
     QDataStream stream(&array, QIODevice::WriteOnly);
diff --git a/autotests/testattendee.cpp b/autotests/testattendee.cpp
--- a/autotests/testattendee.cpp
+++ b/autotests/testattendee.cpp
@@ -29,7 +29,7 @@
 
 QTEST_MAIN(AttendeeTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void AttendeeTest::testValidity()
 {
diff --git a/autotests/testcalendarobserver.cpp b/autotests/testcalendarobserver.cpp
--- a/autotests/testcalendarobserver.cpp
+++ b/autotests/testcalendarobserver.cpp
@@ -30,8 +30,8 @@
 
 QTEST_MAIN(CalendarObserverTest)
 
-using namespace KCalCore;
-Q_DECLARE_METATYPE(KCalCore::Incidence::Ptr)
+using namespace KCalendarCore;
+Q_DECLARE_METATYPE(KCalendarCore::Incidence::Ptr)
 Q_DECLARE_METATYPE(const Calendar *)
 
 class SimpleObserver : public QObject, public Calendar::CalendarObserver
@@ -46,28 +46,28 @@
 
     Calendar *mCal = nullptr;
 Q_SIGNALS:
-    void incidenceAdded(const KCalCore::Incidence::Ptr &incidence);
-    void incidenceChanged(const KCalCore::Incidence::Ptr &incidence);
-    void incidenceAboutToBeDeleted(const KCalCore::Incidence::Ptr &incidence);
-    void incidenceDeleted(const KCalCore::Incidence::Ptr &incidence, const Calendar *calendar);
+    void incidenceAdded(const KCalendarCore::Incidence::Ptr &incidence);
+    void incidenceChanged(const KCalendarCore::Incidence::Ptr &incidence);
+    void incidenceAboutToBeDeleted(const KCalendarCore::Incidence::Ptr &incidence);
+    void incidenceDeleted(const KCalendarCore::Incidence::Ptr &incidence, const Calendar *calendar);
 protected:
-    void calendarIncidenceAdded(const KCalCore::Incidence::Ptr &incidence) override
+    void calendarIncidenceAdded(const KCalendarCore::Incidence::Ptr &incidence) override
     {
         Q_EMIT incidenceAdded(incidence);
     }
 
-    void calendarIncidenceChanged(const KCalCore::Incidence::Ptr &incidence) override
+    void calendarIncidenceChanged(const KCalendarCore::Incidence::Ptr &incidence) override
     {
         Q_EMIT incidenceChanged(incidence);
     }
 
-    void calendarIncidenceAboutToBeDeleted(const KCalCore::Incidence::Ptr &incidence) override
+    void calendarIncidenceAboutToBeDeleted(const KCalendarCore::Incidence::Ptr &incidence) override
     {
         QVERIFY(mCal->incidences().contains(incidence));
         Q_EMIT incidenceAboutToBeDeleted(incidence);
     }
 
-    void calendarIncidenceDeleted(const KCalCore::Incidence::Ptr &incidence, const Calendar *calendar) override
+    void calendarIncidenceDeleted(const KCalendarCore::Incidence::Ptr &incidence, const Calendar *calendar) override
     {
         QCOMPARE(calendar, mCal);
         QVERIFY(!calendar->incidences().contains(incidence));
@@ -77,7 +77,7 @@
 
 void CalendarObserverTest::testAdd()
 {
-    qRegisterMetaType<KCalCore::Incidence::Ptr>();
+    qRegisterMetaType<KCalendarCore::Incidence::Ptr>();
     MemoryCalendar::Ptr cal(new MemoryCalendar(QTimeZone::utc()));
     SimpleObserver ob(cal.data());
     QSignalSpy spy(&ob, &SimpleObserver::incidenceAdded);
@@ -88,12 +88,12 @@
     cal->addEvent(event1);
     QCOMPARE(spy.count(), 1);
     QList<QVariant> arguments = spy.takeFirst();
-    QCOMPARE(arguments.at(0).value<KCalCore::Incidence::Ptr>(), static_cast<KCalCore::Incidence::Ptr>(event1));
+    QCOMPARE(arguments.at(0).value<KCalendarCore::Incidence::Ptr>(), static_cast<KCalendarCore::Incidence::Ptr>(event1));
 }
 
 void CalendarObserverTest::testChange()
 {
-    qRegisterMetaType<KCalCore::Incidence::Ptr>();
+    qRegisterMetaType<KCalendarCore::Incidence::Ptr>();
     MemoryCalendar::Ptr cal(new MemoryCalendar(QTimeZone::utc()));
     SimpleObserver ob(cal.data());
     QSignalSpy spy(&ob, &SimpleObserver::incidenceChanged);
@@ -106,12 +106,12 @@
     event1->setDescription(QStringLiteral("desc"));
     QCOMPARE(spy.count(), 1);
     QList<QVariant> arguments = spy.takeFirst();
-    QCOMPARE(arguments.at(0).value<KCalCore::Incidence::Ptr>(), static_cast<KCalCore::Incidence::Ptr>(event1));
+    QCOMPARE(arguments.at(0).value<KCalendarCore::Incidence::Ptr>(), static_cast<KCalendarCore::Incidence::Ptr>(event1));
 }
 
 void CalendarObserverTest::testDelete()
 {
-    qRegisterMetaType<KCalCore::Incidence::Ptr>();
+    qRegisterMetaType<KCalendarCore::Incidence::Ptr>();
     qRegisterMetaType<const Calendar *>();
     MemoryCalendar::Ptr cal(new MemoryCalendar(QTimeZone::utc()));
     SimpleObserver ob(cal.data());
@@ -128,9 +128,9 @@
     QCOMPARE(spy1.count(), 1);
     QCOMPARE(spy2.count(), 1);
     QList<QVariant> arguments = spy1.takeFirst();
-    QCOMPARE(arguments.at(0).value<KCalCore::Incidence::Ptr>(), static_cast<KCalCore::Incidence::Ptr>(event1));
+    QCOMPARE(arguments.at(0).value<KCalendarCore::Incidence::Ptr>(), static_cast<KCalendarCore::Incidence::Ptr>(event1));
     arguments = spy2.takeFirst();
-    QCOMPARE(arguments.at(0).value<KCalCore::Incidence::Ptr>(), static_cast<KCalCore::Incidence::Ptr>(event1));
+    QCOMPARE(arguments.at(0).value<KCalendarCore::Incidence::Ptr>(), static_cast<KCalendarCore::Incidence::Ptr>(event1));
     QCOMPARE(arguments.at(1).value<const Calendar *>(), cal.data());
 }
 
diff --git a/autotests/testcalfilter.cpp b/autotests/testcalfilter.cpp
--- a/autotests/testcalfilter.cpp
+++ b/autotests/testcalfilter.cpp
@@ -25,7 +25,7 @@
 #include <QTest>
 QTEST_MAIN(CalFilterTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void CalFilterTest::testValidity()
 {
diff --git a/autotests/testcreateddatecompat.cpp b/autotests/testcreateddatecompat.cpp
--- a/autotests/testcreateddatecompat.cpp
+++ b/autotests/testcreateddatecompat.cpp
@@ -61,21 +61,21 @@
 
 void CreatedDateCompatTest::testCompat32()
 {
-    KCalCore::MemoryCalendar::Ptr cal(new KCalCore::MemoryCalendar(QTimeZone::utc()));
-    KCalCore::ICalFormat format;
+    KCalendarCore::MemoryCalendar::Ptr cal(new KCalendarCore::MemoryCalendar(QTimeZone::utc()));
+    KCalendarCore::ICalFormat format;
     QVERIFY(format.fromRawString(cal, QByteArray(icalFile32)));
-    KCalCore::Event::Ptr event = cal->event(QStringLiteral("uid"));
+    KCalendarCore::Event::Ptr event = cal->event(QStringLiteral("uid"));
     QVERIFY(event);
     QCOMPARE(event->created(),
              QDateTime(QDate(2003, 12, 13), QTime(20, 47, 53), Qt::UTC));
 }
 
 void CreatedDateCompatTest::testCompat33()
 {
-    KCalCore::MemoryCalendar::Ptr cal(new KCalCore::MemoryCalendar(QTimeZone::utc()));
-    KCalCore::ICalFormat format;
+    KCalendarCore::MemoryCalendar::Ptr cal(new KCalendarCore::MemoryCalendar(QTimeZone::utc()));
+    KCalendarCore::ICalFormat format;
     QVERIFY(format.fromRawString(cal, QByteArray(icalFile33)));
-    KCalCore::Event::Ptr event = cal->event(QStringLiteral("uid"));
+    KCalendarCore::Event::Ptr event = cal->event(QStringLiteral("uid"));
     QVERIFY(event);
     QCOMPARE(event->created(),
              QDateTime(QDate(2003, 12, 13), QTime(20, 41, 52), Qt::UTC));
diff --git a/autotests/testcustomproperties.cpp b/autotests/testcustomproperties.cpp
--- a/autotests/testcustomproperties.cpp
+++ b/autotests/testcustomproperties.cpp
@@ -28,7 +28,7 @@
 
 QTEST_MAIN(CustomPropertiesTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void CustomPropertiesTest::testValidity()
 {
diff --git a/autotests/testduration.cpp b/autotests/testduration.cpp
--- a/autotests/testduration.cpp
+++ b/autotests/testduration.cpp
@@ -27,7 +27,7 @@
 #include <QTest>
 QTEST_MAIN(DurationTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void DurationTest::testValidity()
 {
@@ -75,7 +75,7 @@
 
 void DurationTest::testSerializer_data()
 {
-    QTest::addColumn<KCalCore::Duration>("duration");
+    QTest::addColumn<KCalendarCore::Duration>("duration");
 
     Duration duration1;
     Duration duration2(7, Duration::Days);
@@ -92,7 +92,7 @@
 
 void DurationTest::testSerializer()
 {
-    QFETCH(KCalCore::Duration, duration);
+    QFETCH(KCalendarCore::Duration, duration);
 
     QByteArray array;
     QDataStream stream(&array, QIODevice::WriteOnly);
diff --git a/autotests/testevent.cpp b/autotests/testevent.cpp
--- a/autotests/testevent.cpp
+++ b/autotests/testevent.cpp
@@ -25,34 +25,34 @@
 #include <QTest>
 QTEST_MAIN(EventTest)
 
-Q_DECLARE_METATYPE(KCalCore::Incidence::DateTimeRole)
+Q_DECLARE_METATYPE(KCalendarCore::Incidence::DateTimeRole)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void EventTest::testSetRoles_data()
 {
     QTest::addColumn<QDateTime>("originalDtStart");
     QTest::addColumn<QDateTime>("originalDtEnd");
     QTest::addColumn<bool>("allDayEvent");
 
-    QTest::addColumn<KCalCore::Incidence::DateTimeRole>("setRole");
+    QTest::addColumn<KCalendarCore::Incidence::DateTimeRole>("setRole");
     QTest::addColumn<QDateTime>("dateTimeToSet");
     QTest::addColumn<QDateTime>("expectedDtStart");
     QTest::addColumn<QDateTime>("expectedDtEnd");
 
     const QDateTime todayDate(QDate::currentDate(), {});   // all day event
     const QDateTime todayDateTime = QDateTime::currentDateTimeUtc();
 
-    QTest::newRow("dnd 0 duration") << todayDate << todayDate << true << KCalCore::Incidence::RoleDnD
+    QTest::newRow("dnd 0 duration") << todayDate << todayDate << true << KCalendarCore::Incidence::RoleDnD
                                     << todayDateTime << todayDateTime << todayDateTime.addSecs(3600);
 }
 
 void EventTest::testSetRoles()
 {
     QFETCH(QDateTime, originalDtStart);
     QFETCH(QDateTime, originalDtEnd);
     QFETCH(bool, allDayEvent);
-    QFETCH(KCalCore::Incidence::DateTimeRole, setRole);
+    QFETCH(KCalendarCore::Incidence::DateTimeRole, setRole);
 
     QFETCH(QDateTime, dateTimeToSet);
     QFETCH(QDateTime, expectedDtStart);
@@ -176,7 +176,7 @@
 
 void EventTest::testSerializer_data()
 {
-    QTest::addColumn<KCalCore::Event::Ptr>("event");
+    QTest::addColumn<KCalendarCore::Event::Ptr>("event");
     QDateTime today = QDateTime::currentDateTimeUtc();
     QDateTime yesterday = today.addDays(-1);
 
@@ -206,15 +206,15 @@
 
 void EventTest::testSerializer()
 {
-    QFETCH(KCalCore::Event::Ptr, event);
-    IncidenceBase::Ptr incidenceBase = event.staticCast<KCalCore::IncidenceBase>();
+    QFETCH(KCalendarCore::Event::Ptr, event);
+    IncidenceBase::Ptr incidenceBase = event.staticCast<KCalendarCore::IncidenceBase>();
 
     QByteArray array;
     QDataStream stream(&array, QIODevice::WriteOnly);
     stream << incidenceBase;
 
     Event::Ptr event2 = Event::Ptr(new Event());
-    IncidenceBase::Ptr incidenceBase2 = event2.staticCast<KCalCore::IncidenceBase>();
+    IncidenceBase::Ptr incidenceBase2 = event2.staticCast<KCalendarCore::IncidenceBase>();
     QVERIFY(*event != *event2);
     QDataStream stream2(&array, QIODevice::ReadOnly);
     stream2 >> incidenceBase2;
diff --git a/autotests/testexception.cpp b/autotests/testexception.cpp
--- a/autotests/testexception.cpp
+++ b/autotests/testexception.cpp
@@ -25,7 +25,7 @@
 #include <QTest>
 QTEST_MAIN(ExceptionTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void ExceptionTest::testValidity()
 {
diff --git a/autotests/testfb.cpp b/autotests/testfb.cpp
--- a/autotests/testfb.cpp
+++ b/autotests/testfb.cpp
@@ -27,7 +27,7 @@
 
 #include <iostream>
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 int main(int, char **)
 {
diff --git a/autotests/testfilestorage.cpp b/autotests/testfilestorage.cpp
--- a/autotests/testfilestorage.cpp
+++ b/autotests/testfilestorage.cpp
@@ -26,7 +26,7 @@
 #include <QTimeZone>
 QTEST_MAIN(FileStorageTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void FileStorageTest::testValidity()
 {
diff --git a/autotests/testfreebusy.cpp b/autotests/testfreebusy.cpp
--- a/autotests/testfreebusy.cpp
+++ b/autotests/testfreebusy.cpp
@@ -24,7 +24,7 @@
 #include <QTest>
 QTEST_MAIN(FreeBusyTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void FreeBusyTest::testValidity()
 {
diff --git a/autotests/testfreebusyperiod.cpp b/autotests/testfreebusyperiod.cpp
--- a/autotests/testfreebusyperiod.cpp
+++ b/autotests/testfreebusyperiod.cpp
@@ -26,7 +26,7 @@
 #include <QTest>
 QTEST_MAIN(FreeBusyPeriodTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void FreeBusyPeriodTest::testValidity()
 {
diff --git a/autotests/testicalformat.cpp b/autotests/testicalformat.cpp
--- a/autotests/testicalformat.cpp
+++ b/autotests/testicalformat.cpp
@@ -31,7 +31,7 @@
 
 QTEST_MAIN(ICalFormatTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void ICalFormatTest::testCharsets()
 {
diff --git a/autotests/testicaltimezones.cpp b/autotests/testicaltimezones.cpp
--- a/autotests/testicaltimezones.cpp
+++ b/autotests/testicaltimezones.cpp
@@ -31,7 +31,7 @@
 extern "C" {
 #include <libical/ical.h>
 }
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 static icalcomponent *loadCALENDAR(const char *vcal);
 
diff --git a/autotests/testincidence.cpp b/autotests/testincidence.cpp
--- a/autotests/testincidence.cpp
+++ b/autotests/testincidence.cpp
@@ -26,9 +26,9 @@
 
 QTEST_MAIN(IncidenceTest)
 
-Q_DECLARE_METATYPE(KCalCore::Incidence::DateTimeRole)
+Q_DECLARE_METATYPE(KCalendarCore::Incidence::DateTimeRole)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void IncidenceTest::testDtStartChange()
 {
@@ -110,7 +110,7 @@
     QDate dt = QDate::currentDate();
     Event inc;
     inc.setDtStart(QDateTime(dt, {}));
-    KCalCore::Recurrence *r = inc.recurrence();
+    KCalendarCore::Recurrence *r = inc.recurrence();
     r->setDaily(1);
     inc.resetDirtyFields();
 
@@ -130,7 +130,7 @@
     QDate dt = QDate::currentDate();
     Event inc;
     inc.setDtStart(QDateTime(dt, {}));
-    KCalCore::Recurrence *r = inc.recurrence();
+    KCalendarCore::Recurrence *r = inc.recurrence();
     r->setDaily(1);
     r->setEndDateTime(QDateTime(dt, {}).addDays(1));
     inc.resetDirtyFields();
@@ -147,7 +147,7 @@
     QDate dt = QDate::currentDate();
     Event inc;
     inc.setDtStart(QDateTime(dt, {}));
-    KCalCore::Recurrence *r = inc.recurrence();
+    KCalendarCore::Recurrence *r = inc.recurrence();
     r->setDaily(1);
     inc.resetDirtyFields();
     QCOMPARE(r->duration(), -1);
@@ -184,7 +184,7 @@
     QDate dt = QDate::currentDate();
     Event inc;
     inc.setDtStart(QDateTime(dt, {}));
-    KCalCore::Recurrence *r = inc.recurrence();
+    KCalendarCore::Recurrence *r = inc.recurrence();
     r->setDuration(1);
     inc.resetDirtyFields();
 
@@ -200,7 +200,7 @@
     QDate dt = QDate::currentDate();
     Event inc;
     inc.setDtStart(QDateTime(dt, {}));
-    KCalCore::Recurrence *r = inc.recurrence();
+    KCalendarCore::Recurrence *r = inc.recurrence();
     r->setExDates(DateList() << dt.addDays(1) << dt.addDays(2));
     inc.resetDirtyFields();
 
@@ -216,7 +216,7 @@
     QDate dt = QDate::currentDate();
     Event inc;
     inc.setDtStart(QDateTime(dt, {}));
-    KCalCore::Recurrence *r = inc.recurrence();
+    KCalendarCore::Recurrence *r = inc.recurrence();
     r->setMonthly(1);
     r->setMonthlyDate(QList<int>() << 1 << 2 << 3);
     inc.resetDirtyFields();
@@ -236,7 +236,7 @@
     RecurrenceRule::WDayPos pos3(1, 2);
     Event inc;
     inc.setDtStart(QDateTime(dt, {}));
-    KCalCore::Recurrence *r = inc.recurrence();
+    KCalendarCore::Recurrence *r = inc.recurrence();
     r->setYearly(1);
     r->setMonthlyPos(QList<RecurrenceRule::WDayPos>() << pos1 << pos2);
     inc.resetDirtyFields();
@@ -254,7 +254,7 @@
     QDate dt = QDate::currentDate();
     Event inc;
     inc.setDtStart(QDateTime(dt, {}));
-    KCalCore::Recurrence *r = inc.recurrence();
+    KCalendarCore::Recurrence *r = inc.recurrence();
     r->setYearly(1);
     r->setYearlyDay(QList<int>() << 1 << 2 << 3);
     inc.resetDirtyFields();
@@ -271,7 +271,7 @@
     QDate dt = QDate::currentDate();
     Event inc;
     inc.setDtStart(QDateTime(dt, {}));
-    KCalCore::Recurrence *r = inc.recurrence();
+    KCalendarCore::Recurrence *r = inc.recurrence();
     r->setYearly(1);
     r->setYearlyMonth(QList<int>() << 1 << 2 << 3);
     inc.resetDirtyFields();
diff --git a/autotests/testincidencegenerator.h b/autotests/testincidencegenerator.h
--- a/autotests/testincidencegenerator.h
+++ b/autotests/testincidencegenerator.h
@@ -24,7 +24,7 @@
 #include "../event.h"
 #include "../todo.h"
 #include "../journal.h"
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 static Event *makeTestEvent()
 {
diff --git a/autotests/testincidencerelation.cpp b/autotests/testincidencerelation.cpp
--- a/autotests/testincidencerelation.cpp
+++ b/autotests/testincidencerelation.cpp
@@ -24,7 +24,7 @@
 #include <QTest>
 QTEST_MAIN(IncidenceRelationTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void IncidenceRelationTest::testRelations()
 {
diff --git a/autotests/testjournal.cpp b/autotests/testjournal.cpp
--- a/autotests/testjournal.cpp
+++ b/autotests/testjournal.cpp
@@ -24,7 +24,7 @@
 #include <QTest>
 QTEST_MAIN(JournalTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void JournalTest::testValidity()
 {
@@ -108,24 +108,24 @@
 
 void JournalTest::testSerializer_data()
 {
-    QTest::addColumn<KCalCore::Journal::Ptr>("journal");
+    QTest::addColumn<KCalendarCore::Journal::Ptr>("journal");
 
     Journal::Ptr journal1 = Journal::Ptr(new Journal());
 
     QTest::newRow("journal") << journal1;
 }
 
 void JournalTest::testSerializer()
 {
-    QFETCH(KCalCore::Journal::Ptr, journal);
-    IncidenceBase::Ptr incidenceBase = journal.staticCast<KCalCore::IncidenceBase>();
+    QFETCH(KCalendarCore::Journal::Ptr, journal);
+    IncidenceBase::Ptr incidenceBase = journal.staticCast<KCalendarCore::IncidenceBase>();
 
     QByteArray array;
     QDataStream stream(&array, QIODevice::WriteOnly);
     stream << incidenceBase;
 
     Journal::Ptr journal2 = Journal::Ptr(new Journal());
-    IncidenceBase::Ptr incidenceBase2 = journal2.staticCast<KCalCore::IncidenceBase>();
+    IncidenceBase::Ptr incidenceBase2 = journal2.staticCast<KCalendarCore::IncidenceBase>();
     QVERIFY(*journal != *journal2);
     QDataStream stream2(&array, QIODevice::ReadOnly);
     stream2 >> incidenceBase2;
diff --git a/autotests/testmemorycalendar.cpp b/autotests/testmemorycalendar.cpp
--- a/autotests/testmemorycalendar.cpp
+++ b/autotests/testmemorycalendar.cpp
@@ -30,7 +30,7 @@
 #include <QTimeZone>
 QTEST_MAIN(MemoryCalendarTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void MemoryCalendarTest::testValidity()
 {
diff --git a/autotests/testoccurrenceiterator.cpp b/autotests/testoccurrenceiterator.cpp
--- a/autotests/testoccurrenceiterator.cpp
+++ b/autotests/testoccurrenceiterator.cpp
@@ -28,7 +28,7 @@
 
 void TestOccurrenceIterator::testIterationWithExceptions()
 {
-    KCalCore::MemoryCalendar calendar(QTimeZone::utc());
+    KCalendarCore::MemoryCalendar calendar(QTimeZone::utc());
 
     QDateTime start(QDate(2013, 03, 10), QTime(10, 0, 0), Qt::UTC);
     QDateTime end(QDate(2013, 03, 10), QTime(11, 0, 0), Qt::UTC);
@@ -39,24 +39,24 @@
 
     QDateTime actualEnd(QDate(2013, 03, 12), QTime(11, 0, 0), Qt::UTC);
 
-    KCalCore::Event::Ptr event1(new KCalCore::Event());
+    KCalendarCore::Event::Ptr event1(new KCalendarCore::Event());
     event1->setUid(QStringLiteral("event1"));
     event1->setSummary(QStringLiteral("event1"));
     event1->setDtStart(start);
     event1->setDtEnd(end);
     event1->recurrence()->setDaily(1);
     calendar.addEvent(event1);
 
-    KCalCore::Event::Ptr exception(new KCalCore::Event());
+    KCalendarCore::Event::Ptr exception(new KCalendarCore::Event());
     exception->setUid(event1->uid());
     exception->setSummary(QStringLiteral("exception"));
     exception->setRecurrenceId(recurrenceId);
     exception->setDtStart(exceptionStart);
     exception->setDtEnd(exceptionEnd);
     calendar.addEvent(exception);
 
     int occurrence = 0;
-    KCalCore::OccurrenceIterator rIt(calendar, start, actualEnd);
+    KCalendarCore::OccurrenceIterator rIt(calendar, start, actualEnd);
     while (rIt.hasNext()) {
         rIt.next();
         occurrence++;
@@ -84,34 +84,34 @@
 
 void TestOccurrenceIterator::testEventsAndTodos()
 {
-    KCalCore::MemoryCalendar calendar(QTimeZone::utc());
+    KCalendarCore::MemoryCalendar calendar(QTimeZone::utc());
 
     QDateTime start(QDate(2013, 03, 10), QTime(10, 0, 0), Qt::UTC);
     QDateTime actualEnd(QDate(2013, 03, 13), QTime(11, 0, 0), Qt::UTC);
 
-    KCalCore::Event::Ptr event(new KCalCore::Event());
+    KCalendarCore::Event::Ptr event(new KCalendarCore::Event());
     event->setUid(QStringLiteral("event"));
     event->setDtStart(start);
     event->recurrence()->setDaily(1);
     event->recurrence()->setDuration(2);
     calendar.addEvent(event);
 
-    KCalCore::Todo::Ptr todo(new KCalCore::Todo());
+    KCalendarCore::Todo::Ptr todo(new KCalendarCore::Todo());
     todo->setUid(QStringLiteral("todo"));
     todo->setDtStart(start);
     todo->recurrence()->setDaily(1);
     todo->recurrence()->setDuration(2);
     calendar.addTodo(todo);
 
-    KCalCore::OccurrenceIterator rIt(calendar, start, actualEnd);
+    KCalendarCore::OccurrenceIterator rIt(calendar, start, actualEnd);
     QList<QDateTime> expectedTodoOccurrences;
     expectedTodoOccurrences << start << start.addDays(1);
     QList<QDateTime> expectedEventOccurrences;
     expectedEventOccurrences << start << start.addDays(1);
     while (rIt.hasNext()) {
         rIt.next();
         qDebug() << rIt.occurrenceStartDate().toString();
-        if (rIt.incidence()->type() == KCalCore::Incidence::TypeTodo) {
+        if (rIt.incidence()->type() == KCalendarCore::Incidence::TypeTodo) {
             QCOMPARE(expectedTodoOccurrences.removeAll(rIt.occurrenceStartDate()), 1);
         } else {
             QCOMPARE(expectedEventOccurrences.removeAll(rIt.occurrenceStartDate()), 1);
@@ -123,13 +123,13 @@
 
 void TestOccurrenceIterator::testFilterCompletedTodos()
 {
-    KCalCore::MemoryCalendar calendar(QTimeZone::utc());
-    calendar.filter()->setCriteria(KCalCore::CalFilter::HideCompletedTodos);
+    KCalendarCore::MemoryCalendar calendar(QTimeZone::utc());
+    calendar.filter()->setCriteria(KCalendarCore::CalFilter::HideCompletedTodos);
 
     QDateTime start(QDate(2013, 03, 10), QTime(10, 0, 0), Qt::UTC);
     QDateTime actualEnd(QDate(2013, 03, 13), QTime(11, 0, 0), Qt::UTC);
 
-    KCalCore::Todo::Ptr todo(new KCalCore::Todo());
+    KCalendarCore::Todo::Ptr todo(new KCalendarCore::Todo());
     todo->setUid(QStringLiteral("todo"));
     todo->setDtDue(start);
     todo->setDtStart(start);
@@ -141,26 +141,26 @@
     todo->setDtRecurrence(start.addDays(2));
     calendar.addTodo(todo);
 
-    KCalCore::OccurrenceIterator rIt(calendar, start, actualEnd);
+    KCalendarCore::OccurrenceIterator rIt(calendar, start, actualEnd);
     QVERIFY(!rIt.hasNext());
 }
 
 void TestOccurrenceIterator::testAllDayEvents()
 {
-    KCalCore::MemoryCalendar calendar(QTimeZone::utc());
+    KCalendarCore::MemoryCalendar calendar(QTimeZone::utc());
 
     QDateTime start(QDate(2013, 03, 10), QTime(), Qt::UTC);
     QDateTime actualEnd(QDate(2013, 03, 13), QTime(11, 0, 0), Qt::UTC);
 
-    KCalCore::Event::Ptr event(new KCalCore::Event());
+    KCalendarCore::Event::Ptr event(new KCalendarCore::Event());
     event->setUid(QStringLiteral("event"));
     event->setDtStart(start);
     event->setAllDay(true);
     event->recurrence()->setDaily(1);
     event->recurrence()->setDuration(2);
     calendar.addEvent(event);
 
-    KCalCore::OccurrenceIterator rIt(calendar, start, actualEnd);
+    KCalendarCore::OccurrenceIterator rIt(calendar, start, actualEnd);
     QList<QDateTime> expectedEventOccurrences;
     expectedEventOccurrences << start << start.addDays(1);
     while (rIt.hasNext()) {
@@ -173,7 +173,7 @@
 
 void TestOccurrenceIterator::testWithExceptionThisAndFuture()
 {
-    KCalCore::MemoryCalendar calendar(QTimeZone::utc());
+    KCalendarCore::MemoryCalendar calendar(QTimeZone::utc());
 
     QDateTime start(QDate(2013, 03, 10), QTime(10, 0, 0), Qt::UTC);
     QDateTime end(QDate(2013, 03, 10), QTime(11, 0, 0), Qt::UTC);
@@ -188,33 +188,33 @@
 
     QDateTime actualEnd(QDate(2013, 03, 14), QTime(11, 0, 0), Qt::UTC);
 
-    KCalCore::Event::Ptr event1(new KCalCore::Event());
+    KCalendarCore::Event::Ptr event1(new KCalendarCore::Event());
     event1->setUid(QStringLiteral("event1"));
     event1->setSummary(QStringLiteral("event1"));
     event1->setDtStart(start);
     event1->setDtEnd(end);
     event1->recurrence()->setDaily(1);
     calendar.addEvent(event1);
 
-    KCalCore::Event::Ptr exception1(new KCalCore::Event());
+    KCalendarCore::Event::Ptr exception1(new KCalendarCore::Event());
     exception1->setUid(event1->uid());
     exception1->setSummary(QStringLiteral("exception1"));
     exception1->setRecurrenceId(recurrenceId1);
     exception1->setThisAndFuture(true);
     exception1->setDtStart(exceptionStart1);
     exception1->setDtEnd(exceptionEnd1);
     calendar.addEvent(exception1);
 
-    KCalCore::Event::Ptr exception2(new KCalCore::Event());
+    KCalendarCore::Event::Ptr exception2(new KCalendarCore::Event());
     exception2->setUid(event1->uid());
     exception2->setSummary(QStringLiteral("exception2"));
     exception2->setRecurrenceId(recurrenceId2);
     exception2->setDtStart(exceptionStart2);
     exception2->setDtEnd(exceptionEnd2);
     calendar.addEvent(exception2);
 
     int occurrence = 0;
-    KCalCore::OccurrenceIterator rIt(calendar, start, actualEnd);
+    KCalendarCore::OccurrenceIterator rIt(calendar, start, actualEnd);
     while (rIt.hasNext()) {
         rIt.next();
         occurrence++;
@@ -251,19 +251,19 @@
 
 void TestOccurrenceIterator::testSubDailyRecurrences()
 {
-    KCalCore::MemoryCalendar calendar(QTimeZone::utc());
+    KCalendarCore::MemoryCalendar calendar(QTimeZone::utc());
 
     QDateTime start(QDate(2013, 03, 10), QTime(10, 0, 0), Qt::UTC);
     QDateTime actualEnd(QDate(2013, 03, 10), QTime(13, 0, 0), Qt::UTC);
 
-    KCalCore::Event::Ptr event(new KCalCore::Event());
+    KCalendarCore::Event::Ptr event(new KCalendarCore::Event());
     event->setUid(QStringLiteral("event"));
     event->setDtStart(start);
     event->recurrence()->setHourly(1);
     event->recurrence()->setDuration(2);
     calendar.addEvent(event);
 
-    KCalCore::OccurrenceIterator rIt(calendar, start, actualEnd);
+    KCalendarCore::OccurrenceIterator rIt(calendar, start, actualEnd);
     QList<QDateTime> expectedEventOccurrences;
     expectedEventOccurrences << start << start.addSecs(60 * 60);
     while (rIt.hasNext()) {
@@ -276,23 +276,23 @@
 
 void TestOccurrenceIterator::testJournals()
 {
-    KCalCore::MemoryCalendar calendar(QTimeZone::utc());
+    KCalendarCore::MemoryCalendar calendar(QTimeZone::utc());
 
     const QDateTime today = QDateTime::currentDateTimeUtc();
     const QDateTime yesterday = today.addDays(-1);
     const QDateTime tomorrow = today.addDays(1);
 
-    KCalCore::Journal::Ptr journal(new KCalCore::Journal());
+    KCalendarCore::Journal::Ptr journal(new KCalendarCore::Journal());
     journal->setUid(QStringLiteral("journal"));
     journal->setDtStart(today);
     calendar.addJournal(journal);
 
-    KCalCore::OccurrenceIterator rIt(calendar, yesterday, tomorrow);
+    KCalendarCore::OccurrenceIterator rIt(calendar, yesterday, tomorrow);
     QVERIFY(rIt.hasNext());
     rIt.next();
     QCOMPARE(rIt.occurrenceStartDate(), today);
     QVERIFY(!rIt.hasNext());
 
-    KCalCore::OccurrenceIterator rIt2(calendar, tomorrow, tomorrow.addDays(1));
+    KCalendarCore::OccurrenceIterator rIt2(calendar, tomorrow, tomorrow.addDays(1));
     QVERIFY(!rIt2.hasNext());
 }
diff --git a/autotests/testperiod.cpp b/autotests/testperiod.cpp
--- a/autotests/testperiod.cpp
+++ b/autotests/testperiod.cpp
@@ -28,7 +28,7 @@
 #include <QTest>
 QTEST_MAIN(PeriodTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void PeriodTest::testValidity()
 {
diff --git a/autotests/testperson.cpp b/autotests/testperson.cpp
--- a/autotests/testperson.cpp
+++ b/autotests/testperson.cpp
@@ -29,7 +29,7 @@
 
 QTEST_MAIN(PersonTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void PersonTest::testValidity()
 {
diff --git a/autotests/testreadrecurrenceid.cpp b/autotests/testreadrecurrenceid.cpp
--- a/autotests/testreadrecurrenceid.cpp
+++ b/autotests/testreadrecurrenceid.cpp
@@ -28,12 +28,12 @@
 
 void TestReadRecurrenceId::testReadSingleException()
 {
-    KCalCore::ICalFormat format;
+    KCalendarCore::ICalFormat format;
     QFile file(QLatin1String(ICALTESTDATADIR) + QLatin1String("test_recurrenceid_single.ics"));
     QVERIFY(file.open(QIODevice::ReadOnly));
 //   qDebug() << file.readAll();
 
-    KCalCore::Incidence::Ptr i = format.fromString(QString::fromUtf8(file.readAll()));
+    KCalendarCore::Incidence::Ptr i = format.fromString(QString::fromUtf8(file.readAll()));
     if (!i) {
         qWarning() << "Failed to parse incidence!";
         if (format.exception()) {
@@ -46,20 +46,20 @@
 
 void TestReadRecurrenceId::testReadSingleExceptionWithThisAndFuture()
 {
-    KCalCore::ICalFormat format;
+    KCalendarCore::ICalFormat format;
     QFile file(QLatin1String(ICALTESTDATADIR) + QLatin1String("test_recurrenceid_thisandfuture.ics"));
     QVERIFY(file.open(QIODevice::ReadOnly));
-    KCalCore::Incidence::Ptr i = format.fromString(QString::fromUtf8(file.readAll()));
+    KCalendarCore::Incidence::Ptr i = format.fromString(QString::fromUtf8(file.readAll()));
     QVERIFY(i);
     QVERIFY(i->hasRecurrenceId());
     QVERIFY(i->thisAndFuture());
 }
 
 void TestReadRecurrenceId::testReadWriteSingleExceptionWithThisAndFuture()
 {
-    KCalCore::MemoryCalendar::Ptr cal(new KCalCore::MemoryCalendar(QTimeZone::utc()));
-    KCalCore::ICalFormat format;
-    KCalCore::Incidence::Ptr inc(new KCalCore::Event);
+    KCalendarCore::MemoryCalendar::Ptr cal(new KCalendarCore::MemoryCalendar(QTimeZone::utc()));
+    KCalendarCore::ICalFormat format;
+    KCalendarCore::Incidence::Ptr inc(new KCalendarCore::Event);
     QTimeZone tz("Europe/Berlin");
     QDateTime startDate(QDate(2015, 1, 2), QTime(3, 4, 5), tz);
     inc->setDtStart(startDate);
@@ -69,17 +69,17 @@
     const QString result = format.toString(cal, QString());
     qDebug() << result;
 
-    KCalCore::Incidence::Ptr i = format.fromString(result);
+    KCalendarCore::Incidence::Ptr i = format.fromString(result);
     QVERIFY(i);
     QVERIFY(i->hasRecurrenceId());
     QVERIFY(i->thisAndFuture());
     QCOMPARE(i->recurrenceId(), startDate);
 }
 
 void TestReadRecurrenceId::testReadExceptionWithMainEvent()
 {
-    KCalCore::MemoryCalendar::Ptr calendar(new KCalCore::MemoryCalendar(QTimeZone::utc()));
-    KCalCore::ICalFormat format;
+    KCalendarCore::MemoryCalendar::Ptr calendar(new KCalendarCore::MemoryCalendar(QTimeZone::utc()));
+    KCalendarCore::ICalFormat format;
     QFile file(QLatin1String(ICALTESTDATADIR) + QLatin1String("test_recurrenceid.ics"));
     QVERIFY(file.open(QIODevice::ReadOnly));
     format.fromString(calendar, QString::fromUtf8(file.readAll()));
diff --git a/autotests/testrecurprevious.cpp b/autotests/testrecurprevious.cpp
--- a/autotests/testrecurprevious.cpp
+++ b/autotests/testrecurprevious.cpp
@@ -31,7 +31,7 @@
 #include <QCommandLineParser>
 #include <QTimeZone>
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 static QString dumpTime(const QDateTime &dt, const QTimeZone &viewZone);
 
diff --git a/autotests/testrecurrence.cpp b/autotests/testrecurrence.cpp
--- a/autotests/testrecurrence.cpp
+++ b/autotests/testrecurrence.cpp
@@ -30,7 +30,7 @@
 #include <QCommandLineParser>
 #include <QTimeZone>
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 static QString dumpTime(const QDateTime &dt, const QTimeZone &viewZone);
 
diff --git a/autotests/testrecurrenceexception.cpp b/autotests/testrecurrenceexception.cpp
--- a/autotests/testrecurrenceexception.cpp
+++ b/autotests/testrecurrenceexception.cpp
@@ -27,15 +27,15 @@
     const QDateTime dtdue(QDate(2013, 03, 10), QTime(11, 0, 0), Qt::UTC);
     const QDateTime recurrenceId(QDateTime(dtstart).addDays(1));
 
-    KCalCore::Todo::Ptr todo(new KCalCore::Todo());
+    KCalendarCore::Todo::Ptr todo(new KCalendarCore::Todo());
     todo->setUid(QStringLiteral("todo"));
     todo->setDtStart(dtstart);
     todo->setDtDue(dtdue);
     todo->recurrence()->setDaily(1);
     todo->recurrence()->setDuration(3);
 
-    const KCalCore::Todo::Ptr exception
-        = KCalCore::MemoryCalendar::createException(todo, recurrenceId, false).staticCast<KCalCore::Todo>();
+    const KCalendarCore::Todo::Ptr exception
+        = KCalendarCore::MemoryCalendar::createException(todo, recurrenceId, false).staticCast<KCalendarCore::Todo>();
     QCOMPARE(exception->dtStart(), recurrenceId);
     QCOMPARE(exception->dtDue(), QDateTime(dtdue).addDays(1));
     //FIXME should be done on clearing the recurrence, but we can't due to BC.
diff --git a/autotests/testrecurrencetype.cpp b/autotests/testrecurrencetype.cpp
--- a/autotests/testrecurrencetype.cpp
+++ b/autotests/testrecurrencetype.cpp
@@ -30,7 +30,7 @@
 #include <QCommandLineParser>
 #include <QTimeZone>
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 static QString dumpTime(const QDateTime &dt, const QTimeZone &viewZone);
 
diff --git a/autotests/testrecurson.cpp b/autotests/testrecurson.cpp
--- a/autotests/testrecurson.cpp
+++ b/autotests/testrecurson.cpp
@@ -33,7 +33,7 @@
 #include <QCommandLineParser>
 #include <QTimeZone>
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 int main(int argc, char **argv)
 {
diff --git a/autotests/testrecurtodo.cpp b/autotests/testrecurtodo.cpp
--- a/autotests/testrecurtodo.cpp
+++ b/autotests/testrecurtodo.cpp
@@ -27,7 +27,7 @@
 
 QTEST_MAIN(RecurTodoTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void RecurTodoTest::testAllDay()
 {
@@ -127,16 +127,16 @@
 
 void RecurTodoTest::testIsAllDay()
 {
-    KCalCore::Todo::Ptr todo(new KCalCore::Todo());
+    KCalendarCore::Todo::Ptr todo(new KCalendarCore::Todo());
     todo->setUid(QStringLiteral("todo"));
     todo->setDtStart(QDateTime(QDate(2013, 03, 10), QTime(10, 0, 0), Qt::UTC));
     todo->setDtDue(QDateTime(QDate(2013, 03, 10), QTime(10, 0, 0), Qt::UTC));
     todo->recurrence()->setDaily(1);
     todo->recurrence()->setDuration(2);
     QCOMPARE(todo->allDay(), false);
     QCOMPARE(todo->recurrence()->allDay(), false);
 
-    KCalCore::Todo::Ptr allDay(new KCalCore::Todo());
+    KCalendarCore::Todo::Ptr allDay(new KCalendarCore::Todo());
     allDay->setUid(QStringLiteral("todo"));
     allDay->setDtStart(QDateTime(QDate(2013, 03, 10), {}, Qt::UTC));
     allDay->setDtDue(QDateTime(QDate(2013, 03, 10), {}, Qt::UTC));
@@ -149,7 +149,7 @@
 
 void RecurTodoTest::testHasDueDate()
 {
-    KCalCore::Todo::Ptr todo(new KCalCore::Todo());
+    KCalendarCore::Todo::Ptr todo(new KCalendarCore::Todo());
     todo->setUid(QStringLiteral("todo"));
     todo->setDtStart(QDateTime(QDate(2013, 03, 10), QTime(10, 0, 0), Qt::UTC));
     todo->recurrence()->setDaily(1);
@@ -177,7 +177,7 @@
     QFETCH(QDateTime, dtstart);
     QFETCH(QDateTime, dtdue);
 
-    KCalCore::Todo::Ptr todo(new KCalCore::Todo());
+    KCalendarCore::Todo::Ptr todo(new KCalendarCore::Todo());
     todo->setUid(QStringLiteral("todo"));
     todo->setDtStart(dtstart);
     todo->setDtDue(dtdue);
@@ -213,14 +213,14 @@
 void RecurTodoTest::testDtStart()
 {
     QDateTime start(QDate(2013, 03, 10), QTime(10, 0, 0), Qt::UTC);
-    KCalCore::Todo::Ptr todo(new KCalCore::Todo());
+    KCalendarCore::Todo::Ptr todo(new KCalendarCore::Todo());
     todo->setUid(QStringLiteral("todo"));
     todo->setDtStart(start);
     todo->recurrence()->setDaily(1);
     todo->recurrence()->setDuration(2);
     QCOMPARE(todo->dtStart(), start);
 
-    KCalCore::Todo::Ptr todoWithDue(new KCalCore::Todo());
+    KCalendarCore::Todo::Ptr todoWithDue(new KCalendarCore::Todo());
     todoWithDue->setUid(QStringLiteral("todoWithDue"));
     todoWithDue->setDtStart(start);
     todoWithDue->setDtDue(QDateTime(start).addSecs(60));
@@ -234,7 +234,7 @@
     const QDateTime dtstart(QDate(2013, 03, 10), QTime(10, 0, 0), Qt::UTC);
     const QDateTime dtdue(QDate(2013, 03, 10), QTime(11, 0, 0), Qt::UTC);
 
-    KCalCore::Todo::Ptr todo(new KCalCore::Todo());
+    KCalendarCore::Todo::Ptr todo(new KCalendarCore::Todo());
     todo->setUid(QStringLiteral("todo"));
     todo->setDtStart(dtstart);
     todo->setDtDue(dtdue);
@@ -251,7 +251,7 @@
 {
     const QDateTime dtdue(QDate(2013, 03, 10), QTime(11, 0, 0), Qt::UTC);
 
-    KCalCore::Todo::Ptr todo(new KCalCore::Todo());
+    KCalendarCore::Todo::Ptr todo(new KCalendarCore::Todo());
     todo->setUid(QStringLiteral("todo"));
     todo->setDtDue(dtdue);
     todo->recurrence()->setDaily(1);
diff --git a/autotests/testtimesininterval.cpp b/autotests/testtimesininterval.cpp
--- a/autotests/testtimesininterval.cpp
+++ b/autotests/testtimesininterval.cpp
@@ -28,7 +28,7 @@
 #include <QTest>
 QTEST_MAIN(TimesInIntervalTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void TimesInIntervalTest::test()
 {
@@ -92,7 +92,7 @@
     const QDateTime start(QDate(2013, 03, 10), QTime(10, 0, 0), Qt::UTC);
     const QDateTime end(QDate(2013, 03, 10), QTime(11, 0, 0), Qt::UTC);
 
-    KCalCore::Event::Ptr event(new KCalCore::Event());
+    KCalendarCore::Event::Ptr event(new KCalendarCore::Event());
     event->setUid(QStringLiteral("event"));
     event->setDtStart(start);
     event->recurrence()->setHourly(1);
@@ -116,7 +116,7 @@
     const QDateTime start(QDate(2013, 03, 10), QTime(10, 2, 3), Qt::UTC);
     const QDateTime end(QDate(2013, 03, 10), QTime(13, 4, 5), Qt::UTC);
 
-    KCalCore::Event::Ptr event(new KCalCore::Event());
+    KCalendarCore::Event::Ptr event(new KCalendarCore::Event());
     event->setUid(QStringLiteral("event"));
     event->setDtStart(start);
     event->recurrence()->setHourly(1);
@@ -139,7 +139,7 @@
     const QDateTime start(QDate(2013, 03, 10), QTime(10, 2, 3), Qt::UTC);
     const QDateTime end(QDate(2013, 03, 10), QTime(12, 2, 3), Qt::UTC);
 
-    KCalCore::Event::Ptr event(new KCalCore::Event());
+    KCalendarCore::Event::Ptr event(new KCalendarCore::Event());
     event->setUid(QStringLiteral("event"));
     event->setDtStart(start);
     event->recurrence()->setHourly(1);
diff --git a/autotests/testtodo.cpp b/autotests/testtodo.cpp
--- a/autotests/testtodo.cpp
+++ b/autotests/testtodo.cpp
@@ -27,7 +27,7 @@
 #include <QTest>
 QTEST_MAIN(TodoTest)
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 void TodoTest::initTestCase()
 {
@@ -178,7 +178,7 @@
 
 void TodoTest::testSerializer_data()
 {
-    QTest::addColumn<KCalCore::Todo::Ptr>("todo");
+    QTest::addColumn<KCalendarCore::Todo::Ptr>("todo");
 
     QDateTime today = QDateTime::currentDateTimeUtc();
     QDateTime yesterday = today.addDays(-1);
@@ -257,15 +257,15 @@
 
 void TodoTest::testSerializer()
 {
-    QFETCH(KCalCore::Todo::Ptr, todo);
-    IncidenceBase::Ptr incidenceBase = todo.staticCast<KCalCore::IncidenceBase>();
+    QFETCH(KCalendarCore::Todo::Ptr, todo);
+    IncidenceBase::Ptr incidenceBase = todo.staticCast<KCalendarCore::IncidenceBase>();
 
     QByteArray array;
     QDataStream stream(&array, QIODevice::WriteOnly);
     stream << incidenceBase;
 
     Todo::Ptr todo2 = Todo::Ptr(new Todo());
-    IncidenceBase::Ptr incidenceBase2 = todo2.staticCast<KCalCore::IncidenceBase>();
+    IncidenceBase::Ptr incidenceBase2 = todo2.staticCast<KCalendarCore::IncidenceBase>();
     QVERIFY(*todo != *todo2);
     QDataStream stream2(&array, QIODevice::ReadOnly);
     stream2 >> incidenceBase2;
diff --git a/autotests/testtostring.cpp b/autotests/testtostring.cpp
--- a/autotests/testtostring.cpp
+++ b/autotests/testtostring.cpp
@@ -26,7 +26,7 @@
 
 #include <iostream>
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 int main(int, char **)
 {
diff --git a/autotests/testvcalexport.cpp b/autotests/testvcalexport.cpp
--- a/autotests/testvcalexport.cpp
+++ b/autotests/testvcalexport.cpp
@@ -30,7 +30,7 @@
 #include <QCommandLineParser>
 #include <QTimeZone>
 
-using namespace KCalCore;
+using namespace KCalendarCore;
 
 int main(int argc, char **argv)
 {