Changeset View
Changeset View
Standalone View
Standalone View
src/utils.cpp
Show All 34 Lines | |||||
35 | #include <AkonadiCore/AgentManager> | 35 | #include <AkonadiCore/AgentManager> | ||
36 | #include <AkonadiCore/EntityDisplayAttribute> | 36 | #include <AkonadiCore/EntityDisplayAttribute> | ||
37 | #include <Akonadi/Calendar/ETMCalendar> | 37 | #include <Akonadi/Calendar/ETMCalendar> | ||
38 | #include <Akonadi/Calendar/PublishDialog> | 38 | #include <Akonadi/Calendar/PublishDialog> | ||
39 | #include <akonadi/calendar/calendarsettings.h> | 39 | #include <akonadi/calendar/calendarsettings.h> | ||
40 | 40 | | |||
41 | #include <KHolidays/HolidayRegion> | 41 | #include <KHolidays/HolidayRegion> | ||
42 | 42 | | |||
43 | #include <KCalCore/CalFilter> | 43 | #include <KCalendarCore/CalFilter> | ||
44 | #include <KCalCore/Event> | 44 | #include <KCalendarCore/Event> | ||
45 | #include <KCalCore/FreeBusy> | 45 | #include <KCalendarCore/FreeBusy> | ||
46 | #include <KCalCore/Incidence> | 46 | #include <KCalendarCore/Incidence> | ||
47 | #include <KCalCore/Journal> | 47 | #include <KCalendarCore/Journal> | ||
48 | #include <KCalCore/MemoryCalendar> | 48 | #include <KCalendarCore/MemoryCalendar> | ||
49 | #include <KCalCore/Todo> | 49 | #include <KCalendarCore/Todo> | ||
50 | #include <KCalCore/ICalFormat> | 50 | #include <KCalendarCore/ICalFormat> | ||
51 | #include <KCalCore/FileStorage> | 51 | #include <KCalendarCore/FileStorage> | ||
52 | 52 | | |||
53 | #include <KCalUtils/DndFactory> | 53 | #include <KCalUtils/DndFactory> | ||
54 | #include <KCalUtils/ICalDrag> | 54 | #include <KCalUtils/ICalDrag> | ||
55 | #include <KCalUtils/VCalDrag> | 55 | #include <KCalUtils/VCalDrag> | ||
56 | 56 | | |||
57 | #include <KMessageBox> | 57 | #include <KMessageBox> | ||
58 | #include <KIO/FileCopyJob> | 58 | #include <KIO/FileCopyJob> | ||
59 | #include <KIconLoader> | 59 | #include <KIconLoader> | ||
Show All 9 Lines | |||||
69 | #include <QUrlQuery> | 69 | #include <QUrlQuery> | ||
70 | #include <QRegularExpression> | 70 | #include <QRegularExpression> | ||
71 | #include <QTimeZone> | 71 | #include <QTimeZone> | ||
72 | 72 | | |||
73 | #include "calendarsupport_debug.h" | 73 | #include "calendarsupport_debug.h" | ||
74 | 74 | | |||
75 | using namespace CalendarSupport; | 75 | using namespace CalendarSupport; | ||
76 | using namespace KHolidays; | 76 | using namespace KHolidays; | ||
77 | using namespace KCalCore; | 77 | using namespace KCalendarCore; | ||
78 | 78 | | |||
79 | KCalCore::Incidence::Ptr CalendarSupport::incidence(const Akonadi::Item &item) | 79 | KCalendarCore::Incidence::Ptr CalendarSupport::incidence(const Akonadi::Item &item) | ||
80 | { | 80 | { | ||
81 | //relying on exception for performance reasons | 81 | //relying on exception for performance reasons | ||
82 | try { | 82 | try { | ||
83 | return item.payload<KCalCore::Incidence::Ptr>(); | 83 | return item.payload<KCalendarCore::Incidence::Ptr>(); | ||
84 | } catch (const Akonadi::PayloadException &) { | 84 | } catch (const Akonadi::PayloadException &) { | ||
85 | return KCalCore::Incidence::Ptr(); | 85 | return KCalendarCore::Incidence::Ptr(); | ||
86 | } | 86 | } | ||
87 | } | 87 | } | ||
88 | 88 | | |||
89 | KCalCore::Event::Ptr CalendarSupport::event(const Akonadi::Item &item) | 89 | KCalendarCore::Event::Ptr CalendarSupport::event(const Akonadi::Item &item) | ||
90 | { | 90 | { | ||
91 | //relying on exception for performance reasons | 91 | //relying on exception for performance reasons | ||
92 | try { | 92 | try { | ||
93 | KCalCore::Incidence::Ptr incidence = item.payload<KCalCore::Incidence::Ptr>(); | 93 | KCalendarCore::Incidence::Ptr incidence = item.payload<KCalendarCore::Incidence::Ptr>(); | ||
94 | if (hasEvent(incidence)) { | 94 | if (hasEvent(incidence)) { | ||
95 | return item.payload<KCalCore::Event::Ptr>(); | 95 | return item.payload<KCalendarCore::Event::Ptr>(); | ||
96 | } | 96 | } | ||
97 | } catch (const Akonadi::PayloadException &) { | 97 | } catch (const Akonadi::PayloadException &) { | ||
98 | return KCalCore::Event::Ptr(); | 98 | return KCalendarCore::Event::Ptr(); | ||
99 | } | 99 | } | ||
100 | return KCalCore::Event::Ptr(); | 100 | return KCalendarCore::Event::Ptr(); | ||
101 | } | 101 | } | ||
102 | 102 | | |||
103 | KCalCore::Event::Ptr CalendarSupport::event(const KCalCore::Incidence::Ptr &incidence) | 103 | KCalendarCore::Event::Ptr CalendarSupport::event(const KCalendarCore::Incidence::Ptr &incidence) | ||
104 | { | 104 | { | ||
105 | if (hasEvent(incidence)) { | 105 | if (hasEvent(incidence)) { | ||
106 | return incidence.staticCast<KCalCore::Event>(); | 106 | return incidence.staticCast<KCalendarCore::Event>(); | ||
107 | } | 107 | } | ||
108 | return KCalCore::Event::Ptr(); | 108 | return KCalendarCore::Event::Ptr(); | ||
109 | } | 109 | } | ||
110 | 110 | | |||
111 | KCalCore::Incidence::List CalendarSupport::incidencesFromItems(const Akonadi::Item::List &items) | 111 | KCalendarCore::Incidence::List CalendarSupport::incidencesFromItems(const Akonadi::Item::List &items) | ||
112 | { | 112 | { | ||
113 | KCalCore::Incidence::List incidences; | 113 | KCalendarCore::Incidence::List incidences; | ||
114 | for (const Akonadi::Item &item : items) { | 114 | for (const Akonadi::Item &item : items) { | ||
115 | if (const KCalCore::Incidence::Ptr e = CalendarSupport::incidence(item)) { | 115 | if (const KCalendarCore::Incidence::Ptr e = CalendarSupport::incidence(item)) { | ||
116 | incidences.push_back(e); | 116 | incidences.push_back(e); | ||
117 | } | 117 | } | ||
118 | } | 118 | } | ||
119 | return incidences; | 119 | return incidences; | ||
120 | } | 120 | } | ||
121 | 121 | | |||
122 | KCalCore::Todo::Ptr CalendarSupport::todo(const Akonadi::Item &item) | 122 | KCalendarCore::Todo::Ptr CalendarSupport::todo(const Akonadi::Item &item) | ||
123 | { | 123 | { | ||
124 | try { | 124 | try { | ||
125 | KCalCore::Incidence::Ptr incidence = item.payload<KCalCore::Incidence::Ptr>(); | 125 | KCalendarCore::Incidence::Ptr incidence = item.payload<KCalendarCore::Incidence::Ptr>(); | ||
126 | if (hasTodo(incidence)) { | 126 | if (hasTodo(incidence)) { | ||
127 | return item.payload<KCalCore::Todo::Ptr>(); | 127 | return item.payload<KCalendarCore::Todo::Ptr>(); | ||
128 | } | 128 | } | ||
129 | } catch (const Akonadi::PayloadException &) { | 129 | } catch (const Akonadi::PayloadException &) { | ||
130 | return KCalCore::Todo::Ptr(); | 130 | return KCalendarCore::Todo::Ptr(); | ||
131 | } | 131 | } | ||
132 | return KCalCore::Todo::Ptr(); | 132 | return KCalendarCore::Todo::Ptr(); | ||
133 | } | 133 | } | ||
134 | 134 | | |||
135 | KCalCore::Todo::Ptr CalendarSupport::todo(const KCalCore::Incidence::Ptr &incidence) | 135 | KCalendarCore::Todo::Ptr CalendarSupport::todo(const KCalendarCore::Incidence::Ptr &incidence) | ||
136 | { | 136 | { | ||
137 | if (hasTodo(incidence)) { | 137 | if (hasTodo(incidence)) { | ||
138 | return incidence.staticCast<KCalCore::Todo>(); | 138 | return incidence.staticCast<KCalendarCore::Todo>(); | ||
139 | } | 139 | } | ||
140 | return KCalCore::Todo::Ptr(); | 140 | return KCalendarCore::Todo::Ptr(); | ||
141 | } | 141 | } | ||
142 | 142 | | |||
143 | KCalCore::Journal::Ptr CalendarSupport::journal(const Akonadi::Item &item) | 143 | KCalendarCore::Journal::Ptr CalendarSupport::journal(const Akonadi::Item &item) | ||
144 | { | 144 | { | ||
145 | try { | 145 | try { | ||
146 | KCalCore::Incidence::Ptr incidence = item.payload<KCalCore::Incidence::Ptr>(); | 146 | KCalendarCore::Incidence::Ptr incidence = item.payload<KCalendarCore::Incidence::Ptr>(); | ||
147 | if (hasJournal(incidence)) { | 147 | if (hasJournal(incidence)) { | ||
148 | return item.payload<KCalCore::Journal::Ptr>(); | 148 | return item.payload<KCalendarCore::Journal::Ptr>(); | ||
149 | } | 149 | } | ||
150 | } catch (const Akonadi::PayloadException &) { | 150 | } catch (const Akonadi::PayloadException &) { | ||
151 | return KCalCore::Journal::Ptr(); | 151 | return KCalendarCore::Journal::Ptr(); | ||
152 | } | 152 | } | ||
153 | return KCalCore::Journal::Ptr(); | 153 | return KCalendarCore::Journal::Ptr(); | ||
154 | } | 154 | } | ||
155 | 155 | | |||
156 | KCalCore::Journal::Ptr CalendarSupport::journal(const KCalCore::Incidence::Ptr &incidence) | 156 | KCalendarCore::Journal::Ptr CalendarSupport::journal(const KCalendarCore::Incidence::Ptr &incidence) | ||
157 | { | 157 | { | ||
158 | if (hasJournal(incidence)) { | 158 | if (hasJournal(incidence)) { | ||
159 | return incidence.staticCast<KCalCore::Journal>(); | 159 | return incidence.staticCast<KCalendarCore::Journal>(); | ||
160 | } | 160 | } | ||
161 | return KCalCore::Journal::Ptr(); | 161 | return KCalendarCore::Journal::Ptr(); | ||
162 | } | 162 | } | ||
163 | 163 | | |||
164 | bool CalendarSupport::hasIncidence(const Akonadi::Item &item) | 164 | bool CalendarSupport::hasIncidence(const Akonadi::Item &item) | ||
165 | { | 165 | { | ||
166 | return item.hasPayload<KCalCore::Incidence::Ptr>(); | 166 | return item.hasPayload<KCalendarCore::Incidence::Ptr>(); | ||
167 | } | 167 | } | ||
168 | 168 | | |||
169 | bool CalendarSupport::hasEvent(const Akonadi::Item &item) | 169 | bool CalendarSupport::hasEvent(const Akonadi::Item &item) | ||
170 | { | 170 | { | ||
171 | return item.hasPayload<KCalCore::Event::Ptr>(); | 171 | return item.hasPayload<KCalendarCore::Event::Ptr>(); | ||
172 | } | 172 | } | ||
173 | 173 | | |||
174 | bool CalendarSupport::hasEvent(const KCalCore::Incidence::Ptr &incidence) | 174 | bool CalendarSupport::hasEvent(const KCalendarCore::Incidence::Ptr &incidence) | ||
175 | { | 175 | { | ||
176 | return incidence && incidence->type() == KCalCore::Incidence::TypeEvent; | 176 | return incidence && incidence->type() == KCalendarCore::Incidence::TypeEvent; | ||
177 | } | 177 | } | ||
178 | 178 | | |||
179 | bool CalendarSupport::hasTodo(const Akonadi::Item &item) | 179 | bool CalendarSupport::hasTodo(const Akonadi::Item &item) | ||
180 | { | 180 | { | ||
181 | return item.hasPayload<KCalCore::Todo::Ptr>(); | 181 | return item.hasPayload<KCalendarCore::Todo::Ptr>(); | ||
182 | } | 182 | } | ||
183 | 183 | | |||
184 | bool CalendarSupport::hasTodo(const KCalCore::Incidence::Ptr &incidence) | 184 | bool CalendarSupport::hasTodo(const KCalendarCore::Incidence::Ptr &incidence) | ||
185 | { | 185 | { | ||
186 | return incidence && incidence->type() == KCalCore::Incidence::TypeTodo; | 186 | return incidence && incidence->type() == KCalendarCore::Incidence::TypeTodo; | ||
187 | } | 187 | } | ||
188 | 188 | | |||
189 | bool CalendarSupport::hasJournal(const Akonadi::Item &item) | 189 | bool CalendarSupport::hasJournal(const Akonadi::Item &item) | ||
190 | { | 190 | { | ||
191 | return item.hasPayload<KCalCore::Journal::Ptr>(); | 191 | return item.hasPayload<KCalendarCore::Journal::Ptr>(); | ||
192 | } | 192 | } | ||
193 | 193 | | |||
194 | bool CalendarSupport::hasJournal(const KCalCore::Incidence::Ptr &incidence) | 194 | bool CalendarSupport::hasJournal(const KCalendarCore::Incidence::Ptr &incidence) | ||
195 | { | 195 | { | ||
196 | return incidence && incidence->type() == KCalCore::Incidence::TypeJournal; | 196 | return incidence && incidence->type() == KCalendarCore::Incidence::TypeJournal; | ||
197 | } | 197 | } | ||
198 | 198 | | |||
199 | QMimeData *CalendarSupport::createMimeData(const Akonadi::Item::List &items) | 199 | QMimeData *CalendarSupport::createMimeData(const Akonadi::Item::List &items) | ||
200 | { | 200 | { | ||
201 | if (items.isEmpty()) { | 201 | if (items.isEmpty()) { | ||
202 | return nullptr; | 202 | return nullptr; | ||
203 | } | 203 | } | ||
204 | 204 | | |||
205 | KCalCore::MemoryCalendar::Ptr cal(new KCalCore::MemoryCalendar(QTimeZone::systemTimeZone())); | 205 | KCalendarCore::MemoryCalendar::Ptr cal(new KCalendarCore::MemoryCalendar(QTimeZone::systemTimeZone())); | ||
206 | 206 | | |||
207 | QList<QUrl> urls; | 207 | QList<QUrl> urls; | ||
208 | int incidencesFound = 0; | 208 | int incidencesFound = 0; | ||
209 | for (const Akonadi::Item &item : items) { | 209 | for (const Akonadi::Item &item : items) { | ||
210 | const KCalCore::Incidence::Ptr incidence(CalendarSupport::incidence(item)); | 210 | const KCalendarCore::Incidence::Ptr incidence(CalendarSupport::incidence(item)); | ||
211 | if (!incidence) { | 211 | if (!incidence) { | ||
212 | continue; | 212 | continue; | ||
213 | } | 213 | } | ||
214 | ++incidencesFound; | 214 | ++incidencesFound; | ||
215 | urls.push_back(item.url()); | 215 | urls.push_back(item.url()); | ||
216 | KCalCore::Incidence::Ptr i(incidence->clone()); | 216 | KCalendarCore::Incidence::Ptr i(incidence->clone()); | ||
217 | cal->addIncidence(i); | 217 | cal->addIncidence(i); | ||
218 | } | 218 | } | ||
219 | 219 | | |||
220 | if (incidencesFound == 0) { | 220 | if (incidencesFound == 0) { | ||
221 | return nullptr; | 221 | return nullptr; | ||
222 | } | 222 | } | ||
223 | 223 | | |||
224 | std::unique_ptr<QMimeData> mimeData(new QMimeData); | 224 | std::unique_ptr<QMimeData> mimeData(new QMimeData); | ||
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Line(s) | 275 | } else if (common == "Todo") { | |||
276 | drag->setPixmap(BarIcon(QStringLiteral("view-calendar-tasks"))); | 276 | drag->setPixmap(BarIcon(QStringLiteral("view-calendar-tasks"))); | ||
277 | } | 277 | } | ||
278 | 278 | | |||
279 | return drag.release(); | 279 | return drag.release(); | ||
280 | } | 280 | } | ||
281 | 281 | | |||
282 | #endif | 282 | #endif | ||
283 | 283 | | |||
284 | static bool itemMatches(const Akonadi::Item &item, const KCalCore::CalFilter *filter) | 284 | static bool itemMatches(const Akonadi::Item &item, const KCalendarCore::CalFilter *filter) | ||
285 | { | 285 | { | ||
286 | assert(filter); | 286 | assert(filter); | ||
287 | KCalCore::Incidence::Ptr inc = CalendarSupport::incidence(item); | 287 | KCalendarCore::Incidence::Ptr inc = CalendarSupport::incidence(item); | ||
288 | if (!inc) { | 288 | if (!inc) { | ||
289 | return false; | 289 | return false; | ||
290 | } | 290 | } | ||
291 | return filter->filterIncidence(inc); | 291 | return filter->filterIncidence(inc); | ||
292 | } | 292 | } | ||
293 | 293 | | |||
294 | Akonadi::Item::List CalendarSupport::applyCalFilter(const Akonadi::Item::List &items_, | 294 | Akonadi::Item::List CalendarSupport::applyCalFilter(const Akonadi::Item::List &items_, | ||
295 | const KCalCore::CalFilter *filter) | 295 | const KCalendarCore::CalFilter *filter) | ||
296 | { | 296 | { | ||
297 | Q_ASSERT(filter); | 297 | Q_ASSERT(filter); | ||
298 | Akonadi::Item::List items(items_); | 298 | Akonadi::Item::List items(items_); | ||
299 | items.erase(std::remove_if(items.begin(), items.end(), [filter](const Akonadi::Item &item) { | 299 | items.erase(std::remove_if(items.begin(), items.end(), [filter](const Akonadi::Item &item) { | ||
300 | return !itemMatches(item, filter); | 300 | return !itemMatches(item, filter); | ||
301 | }), items.end()); | 301 | }), items.end()); | ||
302 | return items; | 302 | return items; | ||
303 | } | 303 | } | ||
Show All 10 Lines | 307 | { | |||
314 | } | 314 | } | ||
315 | 315 | | |||
316 | return supportedMimeTypes.contains(QUrlQuery(url).queryItemValue(QStringLiteral("type"))); | 316 | return supportedMimeTypes.contains(QUrlQuery(url).queryItemValue(QStringLiteral("type"))); | ||
317 | } | 317 | } | ||
318 | 318 | | |||
319 | bool CalendarSupport::isValidIncidenceItemUrl(const QUrl &url) | 319 | bool CalendarSupport::isValidIncidenceItemUrl(const QUrl &url) | ||
320 | { | 320 | { | ||
321 | return isValidIncidenceItemUrl(url, | 321 | return isValidIncidenceItemUrl(url, | ||
322 | QStringList() << KCalCore::Event::eventMimeType() | 322 | QStringList() << KCalendarCore::Event::eventMimeType() | ||
323 | << KCalCore::Todo::todoMimeType() | 323 | << KCalendarCore::Todo::todoMimeType() | ||
324 | << KCalCore::Journal::journalMimeType() | 324 | << KCalendarCore::Journal::journalMimeType() | ||
325 | << KCalCore::FreeBusy::freeBusyMimeType()); | 325 | << KCalendarCore::FreeBusy::freeBusyMimeType()); | ||
326 | } | 326 | } | ||
327 | 327 | | |||
328 | static bool containsValidIncidenceItemUrl(const QList<QUrl> &urls) | 328 | static bool containsValidIncidenceItemUrl(const QList<QUrl> &urls) | ||
329 | { | 329 | { | ||
330 | return | 330 | return | ||
331 | std::find_if(urls.begin(), urls.end(), [](const QUrl &url) { | 331 | std::find_if(urls.begin(), urls.end(), [](const QUrl &url) { | ||
332 | return CalendarSupport::isValidIncidenceItemUrl(url); | 332 | return CalendarSupport::isValidIncidenceItemUrl(url); | ||
333 | }) != urls.constEnd(); | 333 | }) != urls.constEnd(); | ||
Show All 24 Lines | |||||
358 | } | 358 | } | ||
359 | 359 | | |||
360 | QList<QUrl> CalendarSupport::todoItemUrls(const QMimeData *mimeData) | 360 | QList<QUrl> CalendarSupport::todoItemUrls(const QMimeData *mimeData) | ||
361 | { | 361 | { | ||
362 | QList<QUrl> urls; | 362 | QList<QUrl> urls; | ||
363 | 363 | | |||
364 | const QList<QUrl> urlList = mimeData->urls(); | 364 | const QList<QUrl> urlList = mimeData->urls(); | ||
365 | for (const QUrl &i : urlList) { | 365 | for (const QUrl &i : urlList) { | ||
366 | if (isValidIncidenceItemUrl(i, QStringList() << KCalCore::Todo::todoMimeType())) { | 366 | if (isValidIncidenceItemUrl(i, QStringList() << KCalendarCore::Todo::todoMimeType())) { | ||
367 | urls.push_back(i); | 367 | urls.push_back(i); | ||
368 | } | 368 | } | ||
369 | } | 369 | } | ||
370 | return urls; | 370 | return urls; | ||
371 | } | 371 | } | ||
372 | 372 | | |||
373 | bool CalendarSupport::mimeDataHasIncidence(const QMimeData *mimeData) | 373 | bool CalendarSupport::mimeDataHasIncidence(const QMimeData *mimeData) | ||
374 | { | 374 | { | ||
375 | return !incidenceItemUrls(mimeData).isEmpty() | 375 | return !incidenceItemUrls(mimeData).isEmpty() | ||
376 | || !incidences(mimeData).isEmpty(); | 376 | || !incidences(mimeData).isEmpty(); | ||
377 | } | 377 | } | ||
378 | 378 | | |||
379 | KCalCore::Todo::List CalendarSupport::todos(const QMimeData *mimeData) | 379 | KCalendarCore::Todo::List CalendarSupport::todos(const QMimeData *mimeData) | ||
380 | { | 380 | { | ||
381 | KCalCore::Todo::List todos; | 381 | KCalendarCore::Todo::List todos; | ||
382 | 382 | | |||
383 | #ifndef QT_NO_DRAGANDDROP | 383 | #ifndef QT_NO_DRAGANDDROP | ||
384 | KCalCore::Calendar::Ptr cal(KCalUtils::DndFactory::createDropCalendar(mimeData)); | 384 | KCalendarCore::Calendar::Ptr cal(KCalUtils::DndFactory::createDropCalendar(mimeData)); | ||
385 | if (cal) { | 385 | if (cal) { | ||
386 | const KCalCore::Todo::List calTodos = cal->todos(); | 386 | const KCalendarCore::Todo::List calTodos = cal->todos(); | ||
387 | todos.reserve(calTodos.count()); | 387 | todos.reserve(calTodos.count()); | ||
388 | for (const KCalCore::Todo::Ptr &i : calTodos) { | 388 | for (const KCalendarCore::Todo::Ptr &i : calTodos) { | ||
389 | todos.push_back(KCalCore::Todo::Ptr(i->clone())); | 389 | todos.push_back(KCalendarCore::Todo::Ptr(i->clone())); | ||
390 | } | 390 | } | ||
391 | } | 391 | } | ||
392 | #endif | 392 | #endif | ||
393 | 393 | | |||
394 | return todos; | 394 | return todos; | ||
395 | } | 395 | } | ||
396 | 396 | | |||
397 | KCalCore::Incidence::List CalendarSupport::incidences(const QMimeData *mimeData) | 397 | KCalendarCore::Incidence::List CalendarSupport::incidences(const QMimeData *mimeData) | ||
398 | { | 398 | { | ||
399 | KCalCore::Incidence::List incidences; | 399 | KCalendarCore::Incidence::List incidences; | ||
400 | 400 | | |||
401 | #ifndef QT_NO_DRAGANDDROP | 401 | #ifndef QT_NO_DRAGANDDROP | ||
402 | KCalCore::Calendar::Ptr cal(KCalUtils::DndFactory::createDropCalendar(mimeData)); | 402 | KCalendarCore::Calendar::Ptr cal(KCalUtils::DndFactory::createDropCalendar(mimeData)); | ||
403 | if (cal) { | 403 | if (cal) { | ||
404 | const KCalCore::Incidence::List calIncidences = cal->incidences(); | 404 | const KCalendarCore::Incidence::List calIncidences = cal->incidences(); | ||
405 | incidences.reserve(calIncidences.count()); | 405 | incidences.reserve(calIncidences.count()); | ||
406 | for (const KCalCore::Incidence::Ptr &i : calIncidences) { | 406 | for (const KCalendarCore::Incidence::Ptr &i : calIncidences) { | ||
407 | incidences.push_back(KCalCore::Incidence::Ptr(i->clone())); | 407 | incidences.push_back(KCalendarCore::Incidence::Ptr(i->clone())); | ||
408 | } | 408 | } | ||
409 | } | 409 | } | ||
410 | #endif | 410 | #endif | ||
411 | 411 | | |||
412 | return incidences; | 412 | return incidences; | ||
413 | } | 413 | } | ||
414 | 414 | | |||
415 | Akonadi::Collection CalendarSupport::selectCollection(QWidget *parent, int &dialogCode, | 415 | Akonadi::Collection CalendarSupport::selectCollection(QWidget *parent, int &dialogCode, | ||
▲ Show 20 Lines • Show All 287 Lines • ▼ Show 20 Line(s) | 702 | } else { | |||
703 | str += i18nc("the calendar is read and write", "read+write"); | 703 | str += i18nc("the calendar is read and write", "read+write"); | ||
704 | } | 704 | } | ||
705 | str += QLatin1String("</br>"); | 705 | str += QLatin1String("</br>"); | ||
706 | 706 | | |||
707 | str += QLatin1String("</qt>"); | 707 | str += QLatin1String("</qt>"); | ||
708 | return str; | 708 | return str; | ||
709 | } | 709 | } | ||
710 | 710 | | |||
711 | QString CalendarSupport::subMimeTypeForIncidence(const KCalCore::Incidence::Ptr &incidence) | 711 | QString CalendarSupport::subMimeTypeForIncidence(const KCalendarCore::Incidence::Ptr &incidence) | ||
712 | { | 712 | { | ||
713 | return incidence->mimeType(); | 713 | return incidence->mimeType(); | ||
714 | } | 714 | } | ||
715 | 715 | | |||
716 | QList<QDate> CalendarSupport::workDays(const QDate &startDate, const QDate &endDate) | 716 | QList<QDate> CalendarSupport::workDays(const QDate &startDate, const QDate &endDate) | ||
717 | { | 717 | { | ||
718 | QList<QDate> result; | 718 | QList<QDate> result; | ||
719 | 719 | | |||
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Line(s) | 761 | for (int i = 0; i < listCount; ++i) { | |||
785 | } | 785 | } | ||
786 | } | 786 | } | ||
787 | } | 787 | } | ||
788 | } | 788 | } | ||
789 | 789 | | |||
790 | return hdays; | 790 | return hdays; | ||
791 | } | 791 | } | ||
792 | 792 | | |||
793 | QStringList CalendarSupport::categories(const KCalCore::Incidence::List &incidences) | 793 | QStringList CalendarSupport::categories(const KCalendarCore::Incidence::List &incidences) | ||
794 | { | 794 | { | ||
795 | QStringList cats, thisCats; | 795 | QStringList cats, thisCats; | ||
796 | // @TODO: For now just iterate over all incidences. In the future, | 796 | // @TODO: For now just iterate over all incidences. In the future, | ||
797 | // the list of categories should be built when reading the file. | 797 | // the list of categories should be built when reading the file. | ||
798 | for (const KCalCore::Incidence::Ptr &incidence : incidences) { | 798 | for (const KCalendarCore::Incidence::Ptr &incidence : incidences) { | ||
799 | thisCats = incidence->categories(); | 799 | thisCats = incidence->categories(); | ||
800 | const QStringList::ConstIterator send(thisCats.constEnd()); | 800 | const QStringList::ConstIterator send(thisCats.constEnd()); | ||
801 | for (QStringList::ConstIterator si = thisCats.constBegin(); | 801 | for (QStringList::ConstIterator si = thisCats.constBegin(); | ||
802 | si != send; ++si) { | 802 | si != send; ++si) { | ||
803 | if (!cats.contains(*si)) { | 803 | if (!cats.contains(*si)) { | ||
804 | cats.append(*si); | 804 | cats.append(*si); | ||
805 | } | 805 | } | ||
806 | } | 806 | } | ||
807 | } | 807 | } | ||
808 | return cats; | 808 | return cats; | ||
809 | } | 809 | } | ||
810 | 810 | | |||
811 | bool CalendarSupport::mergeCalendar(const QString &srcFilename, | 811 | bool CalendarSupport::mergeCalendar(const QString &srcFilename, | ||
812 | const KCalCore::Calendar::Ptr &destCalendar) | 812 | const KCalendarCore::Calendar::Ptr &destCalendar) | ||
813 | { | 813 | { | ||
814 | if (srcFilename.isEmpty()) { | 814 | if (srcFilename.isEmpty()) { | ||
815 | qCCritical(CALENDARSUPPORT_LOG) << "Empty filename."; | 815 | qCCritical(CALENDARSUPPORT_LOG) << "Empty filename."; | ||
816 | return false; | 816 | return false; | ||
817 | } | 817 | } | ||
818 | 818 | | |||
819 | if (!QFile::exists(srcFilename)) { | 819 | if (!QFile::exists(srcFilename)) { | ||
820 | qCCritical(CALENDARSUPPORT_LOG) << "File'" << srcFilename << "' doesn't exist."; | 820 | qCCritical(CALENDARSUPPORT_LOG) << "File'" << srcFilename << "' doesn't exist."; | ||
821 | } | 821 | } | ||
822 | 822 | | |||
823 | // merge in a file | 823 | // merge in a file | ||
824 | destCalendar->startBatchAdding(); | 824 | destCalendar->startBatchAdding(); | ||
825 | KCalCore::FileStorage storage(destCalendar); | 825 | KCalendarCore::FileStorage storage(destCalendar); | ||
826 | storage.setFileName(srcFilename); | 826 | storage.setFileName(srcFilename); | ||
827 | bool loadedSuccesfully = storage.load(); | 827 | bool loadedSuccesfully = storage.load(); | ||
828 | destCalendar->endBatchAdding(); | 828 | destCalendar->endBatchAdding(); | ||
829 | 829 | | |||
830 | return loadedSuccesfully; | 830 | return loadedSuccesfully; | ||
831 | } | 831 | } |