← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kde-workspace/utopic-proposed

« back to all changes in this revision

Viewing changes to plasma/generic/dataengines/calendar/akonadi/utils.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michał Zając
  • Date: 2011-07-09 08:31:15 UTC
  • Revision ID: james.westby@ubuntu.com-20110709083115-ohyxn6z93mily9fc
Tags: upstream-4.6.90
Import upstream version 4.6.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
plasma/generic/dataengines/calendar/akonadi/utils.cpp
 
1
/*
 
2
  Copyright (c) 2009, 2010 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
 
3
  Copyright (C) 2009 KDAB (author: Frank Osterfeld <osterfeld@kde.org>)
 
4
  Copyright (c) 2010 Andras Mantia <andras@kdab.com>
 
5
 
 
6
  This program is free software; you can redistribute it and/or modify
 
7
  it under the terms of the GNU General Public License as published by
 
8
  the Free Software Foundation; either version 2 of the License, or
 
9
  (at your option) any later version.
 
10
 
 
11
  This program is distributed in the hope that it will be useful,
 
12
  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
14
  GNU General Public License for more details.
 
15
 
 
16
  You should have received a copy of the GNU General Public License along
 
17
  with this program; if not, write to the Free Software Foundation, Inc.,
 
18
  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
19
 
 
20
  As a special exception, permission is given to link this program
 
21
  with any edition of Qt, and distribute the resulting executable,
 
22
  without including the source code for Qt in the source distribution.
 
23
*/
 
24
 
 
25
#include "utils.h"
 
26
/*#include "kcalprefs.h"
 
27
#include "mailclient.h"
 
28
#include "mailscheduler.h"
 
29
#include "publishdialog.h"*/
 
30
 
 
31
#include <Akonadi/Collection>
 
32
#include <Akonadi/CollectionDialog>
 
33
#include <Akonadi/EntityDisplayAttribute>
 
34
#include <Akonadi/EntityTreeModel>
 
35
#include <Akonadi/Item>
 
36
 
 
37
#include <KHolidays/Holidays>
 
38
 
 
39
#include <KCalCore/CalFilter>
 
40
#include <KCalCore/Event>
 
41
#include <KCalCore/FreeBusy>
 
42
#include <KCalCore/Incidence>
 
43
#include <KCalCore/Journal>
 
44
#include <KCalCore/MemoryCalendar>
 
45
#include <KCalCore/Todo>
 
46
#include <KCalCore/ICalFormat>
 
47
 
 
48
#include <KCalUtils/DndFactory>
 
49
#include <KCalUtils/ICalDrag>
 
50
#include <KCalUtils/VCalDrag>
 
51
 
 
52
#include <Mailtransport/TransportManager>
 
53
 
 
54
#include <KIconLoader>
 
55
#include <KLocale>
 
56
#include <KUrl>
 
57
 
 
58
#include <QAbstractItemModel>
 
59
#include <QDrag>
 
60
#include <QMimeData>
 
61
#include <QModelIndex>
 
62
#include <QPixmap>
 
63
#include <QPointer>
 
64
 
 
65
#include <boost/bind.hpp>
 
66
#include <KMessageBox>
 
67
#include <KPIMIdentities/IdentityManager>
 
68
#include <KFileDialog>
 
69
#include <KIO/NetAccess>
 
70
 
 
71
using namespace CalendarSupport;
 
72
using namespace KHolidays;
 
73
 
 
74
KCalCore::Incidence::Ptr CalendarSupport::incidence( const Akonadi::Item &item )
 
75
{
 
76
  return
 
77
    item.hasPayload<KCalCore::Incidence::Ptr>() ?
 
78
    item.payload<KCalCore::Incidence::Ptr>() :
 
79
    KCalCore::Incidence::Ptr();
 
80
}
 
81
 
 
82
KCalCore::Event::Ptr CalendarSupport::event( const Akonadi::Item &item )
 
83
{
 
84
  return
 
85
    item.hasPayload<KCalCore::Event::Ptr>() ?
 
86
    item.payload<KCalCore::Event::Ptr>() :
 
87
    KCalCore::Event::Ptr();
 
88
}
 
89
 
 
90
KCalCore::Event::List CalendarSupport::eventsFromItems( const Akonadi::Item::List &items )
 
91
{
 
92
  KCalCore::Event::List events;
 
93
  Q_FOREACH ( const Akonadi::Item &item, items ) {
 
94
    if ( const KCalCore::Event::Ptr e = CalendarSupport::event( item ) ) {
 
95
      events.push_back( e );
 
96
    }
 
97
  }
 
98
  return events;
 
99
}
 
100
 
 
101
KCalCore::Incidence::List CalendarSupport::incidencesFromItems( const Akonadi::Item::List &items )
 
102
{
 
103
  KCalCore::Incidence::List incidences;
 
104
  Q_FOREACH ( const Akonadi::Item &item, items ) {
 
105
    if ( const KCalCore::Incidence::Ptr e = CalendarSupport::incidence( item ) ) {
 
106
      incidences.push_back( e );
 
107
    }
 
108
  }
 
109
  return incidences;
 
110
}
 
111
 
 
112
KCalCore::Todo::Ptr CalendarSupport::todo( const Akonadi::Item &item )
 
113
{
 
114
  return
 
115
    item.hasPayload<KCalCore::Todo::Ptr>() ?
 
116
    item.payload<KCalCore::Todo::Ptr>() :
 
117
    KCalCore::Todo::Ptr();
 
118
}
 
119
 
 
120
KCalCore::Journal::Ptr CalendarSupport::journal( const Akonadi::Item &item )
 
121
{
 
122
  return
 
123
    item.hasPayload<KCalCore::Journal::Ptr>() ?
 
124
    item.payload<KCalCore::Journal::Ptr>() :
 
125
    KCalCore::Journal::Ptr();
 
126
}
 
127
 
 
128
bool CalendarSupport::hasIncidence( const Akonadi::Item &item )
 
129
{
 
130
  return item.hasPayload<KCalCore::Incidence::Ptr>();
 
131
}
 
132
 
 
133
bool CalendarSupport::hasEvent( const Akonadi::Item &item )
 
134
{
 
135
  return item.hasPayload<KCalCore::Event::Ptr>();
 
136
}
 
137
 
 
138
bool CalendarSupport::hasTodo( const Akonadi::Item &item )
 
139
{
 
140
  return item.hasPayload<KCalCore::Todo::Ptr>();
 
141
}
 
142
 
 
143
bool CalendarSupport::hasJournal( const Akonadi::Item &item )
 
144
{
 
145
  return item.hasPayload<KCalCore::Journal::Ptr>();
 
146
}
 
147
 
 
148
QMimeData *CalendarSupport::createMimeData( const Akonadi::Item::List &items,
 
149
                                            const KDateTime::Spec &timeSpec )
 
150
{
 
151
  if ( items.isEmpty() ) {
 
152
    return 0;
 
153
  }
 
154
 
 
155
  KCalCore::MemoryCalendar::Ptr cal( new KCalCore::MemoryCalendar( timeSpec ) );
 
156
 
 
157
  QList<QUrl> urls;
 
158
  int incidencesFound = 0;
 
159
  Q_FOREACH ( const Akonadi::Item &item, items ) {
 
160
    const KCalCore::Incidence::Ptr incidence( CalendarSupport::incidence( item ) );
 
161
    if ( !incidence ) {
 
162
      continue;
 
163
    }
 
164
    ++incidencesFound;
 
165
    urls.push_back( item.url() );
 
166
    KCalCore::Incidence::Ptr i( incidence->clone() );
 
167
    cal->addIncidence( i );
 
168
  }
 
169
 
 
170
  if ( incidencesFound == 0 ) {
 
171
    return 0;
 
172
  }
 
173
 
 
174
  std::auto_ptr<QMimeData> mimeData( new QMimeData );
 
175
 
 
176
  mimeData->setUrls( urls );
 
177
 
 
178
  KCalUtils::ICalDrag::populateMimeData( mimeData.get(), cal );
 
179
  KCalUtils::VCalDrag::populateMimeData( mimeData.get(), cal );
 
180
 
 
181
  return mimeData.release();
 
182
}
 
183
 
 
184
QMimeData *CalendarSupport::createMimeData( const Akonadi::Item &item,
 
185
                                            const KDateTime::Spec &timeSpec )
 
186
{
 
187
  return createMimeData( Akonadi::Item::List() << item, timeSpec );
 
188
}
 
189
 
 
190
#ifndef QT_NO_DRAGANDDROP
 
191
QDrag *CalendarSupport::createDrag( const Akonadi::Item &item,
 
192
                                    const KDateTime::Spec &timeSpec, QWidget *parent )
 
193
{
 
194
  return createDrag( Akonadi::Item::List() << item, timeSpec, parent );
 
195
}
 
196
#endif
 
197
 
 
198
static QByteArray findMostCommonType( const Akonadi::Item::List &items )
 
199
{
 
200
  QByteArray prev;
 
201
  if ( items.isEmpty() ) {
 
202
    return "Incidence";
 
203
  }
 
204
 
 
205
  Q_FOREACH( const Akonadi::Item &item, items ) {
 
206
    if ( !CalendarSupport::hasIncidence( item ) ) {
 
207
      continue;
 
208
    }
 
209
    const QByteArray type = CalendarSupport::incidence( item )->typeStr();
 
210
    if ( !prev.isEmpty() && type != prev ) {
 
211
      return "Incidence";
 
212
    }
 
213
    prev = type;
 
214
  }
 
215
  return prev;
 
216
}
 
217
 
 
218
#ifndef QT_NO_DRAGANDDROP
 
219
QDrag *CalendarSupport::createDrag( const Akonadi::Item::List &items,
 
220
                                    const KDateTime::Spec &timeSpec, QWidget *parent )
 
221
{
 
222
  std::auto_ptr<QDrag> drag( new QDrag( parent ) );
 
223
  drag->setMimeData( CalendarSupport::createMimeData( items, timeSpec ) );
 
224
 
 
225
  const QByteArray common = findMostCommonType( items );
 
226
  if ( common == "Event" ) {
 
227
    drag->setPixmap( BarIcon( QLatin1String( "view-calendar-day" ) ) );
 
228
  } else if ( common == "Todo" ) {
 
229
    drag->setPixmap( BarIcon( QLatin1String( "view-calendar-tasks" ) ) );
 
230
  }
 
231
 
 
232
  return drag.release();
 
233
}
 
234
#endif
 
235
 
 
236
static bool itemMatches( const Akonadi::Item &item, const KCalCore::CalFilter *filter )
 
237
{
 
238
  assert( filter );
 
239
  KCalCore::Incidence::Ptr inc = CalendarSupport::incidence( item );
 
240
  if ( !inc ) {
 
241
    return false;
 
242
  }
 
243
  return filter->filterIncidence( inc );
 
244
}
 
245
 
 
246
Akonadi::Item::List CalendarSupport::applyCalFilter( const Akonadi::Item::List &items_,
 
247
                                                     const KCalCore::CalFilter *filter )
 
248
{
 
249
  Q_ASSERT( filter );
 
250
  Akonadi::Item::List items( items_ );
 
251
  items.erase( std::remove_if( items.begin(), items.end(),
 
252
                               !bind( itemMatches, _1, filter ) ), items.end() );
 
253
  return items;
 
254
}
 
255
 
 
256
bool CalendarSupport::isValidIncidenceItemUrl( const KUrl &url,
 
257
                                               const QStringList &supportedMimeTypes )
 
258
{
 
259
  if ( !url.isValid() ) {
 
260
    return false;
 
261
  }
 
262
 
 
263
  if ( url.scheme() != QLatin1String( "akonadi" ) ) {
 
264
    return false;
 
265
  }
 
266
 
 
267
  return supportedMimeTypes.contains( url.queryItem( QLatin1String( "type" ) ) );
 
268
}
 
269
 
 
270
bool CalendarSupport::isValidIncidenceItemUrl( const KUrl &url )
 
271
{
 
272
  return isValidIncidenceItemUrl( url,
 
273
                                  QStringList() << KCalCore::Event::eventMimeType()
 
274
                                                << KCalCore::Todo::todoMimeType()
 
275
                                                << KCalCore::Journal::journalMimeType()
 
276
                                                << KCalCore::FreeBusy::freeBusyMimeType() );
 
277
}
 
278
 
 
279
static bool containsValidIncidenceItemUrl( const QList<QUrl>& urls )
 
280
{
 
281
  return
 
282
    std::find_if( urls.begin(), urls.end(),
 
283
                  bind( CalendarSupport::isValidIncidenceItemUrl, _1 ) ) != urls.constEnd();
 
284
}
 
285
 
 
286
bool CalendarSupport::isValidTodoItemUrl( const KUrl &url )
 
287
{
 
288
  if ( !url.isValid() || url.scheme() != QLatin1String( "akonadi" ) ) {
 
289
    return false;
 
290
  }
 
291
 
 
292
  return url.queryItem( QLatin1String( "type" ) ) == KCalCore::Todo::todoMimeType();
 
293
}
 
294
 
 
295
bool CalendarSupport::canDecode( const QMimeData *md )
 
296
{
 
297
  Q_ASSERT( md );
 
298
  return
 
299
    containsValidIncidenceItemUrl( md->urls() ) ||
 
300
    KCalUtils::ICalDrag::canDecode( md ) ||
 
301
    KCalUtils::VCalDrag::canDecode( md );
 
302
}
 
303
 
 
304
QList<KUrl> CalendarSupport::incidenceItemUrls( const QMimeData *mimeData )
 
305
{
 
306
  QList<KUrl> urls;
 
307
  Q_FOREACH( const KUrl &i, mimeData->urls() ) {
 
308
    if ( isValidIncidenceItemUrl( i ) ) {
 
309
      urls.push_back( i );
 
310
    }
 
311
  }
 
312
  return urls;
 
313
}
 
314
 
 
315
QList<KUrl> CalendarSupport::todoItemUrls( const QMimeData *mimeData )
 
316
{
 
317
  QList<KUrl> urls;
 
318
 
 
319
  Q_FOREACH( const KUrl &i, mimeData->urls() ) {
 
320
    if ( isValidIncidenceItemUrl( i, QStringList() << KCalCore::Todo::todoMimeType() ) ) {
 
321
      urls.push_back( i );
 
322
    }
 
323
  }
 
324
  return urls;
 
325
}
 
326
 
 
327
bool CalendarSupport::mimeDataHasTodo( const QMimeData *mimeData )
 
328
{
 
329
  return !todoItemUrls( mimeData ).isEmpty() || !todos( mimeData, KDateTime::Spec() ).isEmpty();
 
330
}
 
331
 
 
332
KCalCore::Todo::List CalendarSupport::todos( const QMimeData *mimeData,
 
333
                                             const KDateTime::Spec &spec )
 
334
{
 
335
  KCalCore::Todo::List todos;
 
336
 
 
337
#ifndef QT_NO_DRAGANDDROP
 
338
  KCalCore::Calendar::Ptr cal( KCalUtils::DndFactory::createDropCalendar( mimeData, spec ) );
 
339
  if ( cal ) {
 
340
    Q_FOREACH( const KCalCore::Todo::Ptr &i, cal->todos() ) {
 
341
      todos.push_back( KCalCore::Todo::Ptr( i->clone() ) );
 
342
    }
 
343
  }
 
344
#endif
 
345
 
 
346
  return todos;
 
347
}
 
348
 
 
349
Akonadi::Collection CalendarSupport::selectCollection( QWidget *parent,
 
350
                                                       int &dialogCode,
 
351
                                                       const QStringList &mimeTypes,
 
352
                                                       const Akonadi::Collection &defCollection )
 
353
{
 
354
  QPointer<Akonadi::CollectionDialog> dlg( new Akonadi::CollectionDialog( parent ) );
 
355
 
 
356
  kDebug() << "selecting collections with mimeType in " << mimeTypes;
 
357
 
 
358
  dlg->setMimeTypeFilter( mimeTypes );
 
359
  dlg->setAccessRightsFilter( Akonadi::Collection::CanCreateItem );
 
360
  if ( defCollection.isValid() ) {
 
361
    dlg->setDefaultCollection( defCollection );
 
362
  }
 
363
  Akonadi::Collection collection;
 
364
 
 
365
  // FIXME: don't use exec.
 
366
  dialogCode = dlg->exec();
 
367
  if ( dialogCode == QDialog::Accepted ) {
 
368
    collection = dlg->selectedCollection();
 
369
 
 
370
    if ( !collection.isValid() ) {
 
371
      kWarning() <<"An invalid collection was selected!";
 
372
    }
 
373
  }
 
374
  delete dlg;
 
375
 
 
376
  return collection;
 
377
}
 
378
 
 
379
Akonadi::Item CalendarSupport::itemFromIndex( const QModelIndex &idx )
 
380
{
 
381
  Akonadi::Item item = idx.data( Akonadi::EntityTreeModel::ItemRole ).value<Akonadi::Item>();
 
382
  item.setParentCollection(
 
383
    idx.data( Akonadi::EntityTreeModel::ParentCollectionRole ).value<Akonadi::Collection>() );
 
384
  return item;
 
385
}
 
386
 
 
387
Akonadi::Collection::List CalendarSupport::collectionsFromModel( const QAbstractItemModel *model,
 
388
                                                                 const QModelIndex &parentIndex,
 
389
                                                                 int start, int end )
 
390
{
 
391
  const int endRow = end >= 0 ? end : model->rowCount( parentIndex ) - 1;
 
392
  Akonadi::Collection::List collections;
 
393
  int row = start;
 
394
  QModelIndex i = model->index( row, 0, parentIndex );
 
395
  while ( row <= endRow ) {
 
396
    const Akonadi::Collection collection = collectionFromIndex( i );
 
397
    if ( collection.isValid() ) {
 
398
      collections << collection;
 
399
      QModelIndex childIndex = i.child( 0, 0 );
 
400
      if ( childIndex.isValid() ) {
 
401
        collections << collectionsFromModel( model, i );
 
402
      }
 
403
    }
 
404
    ++row;
 
405
    i = i.sibling( row, 0 );
 
406
  }
 
407
  return collections;
 
408
}
 
409
 
 
410
Akonadi::Item::List CalendarSupport::itemsFromModel( const QAbstractItemModel * model,
 
411
                                                     const QModelIndex &parentIndex,
 
412
                                                     int start, int end )
 
413
{
 
414
  const int endRow = end >= 0 ? end : model->rowCount( parentIndex ) - 1;
 
415
  Akonadi::Item::List items;
 
416
  int row = start;
 
417
  QModelIndex i = model->index( row, 0, parentIndex );
 
418
  while ( row <= endRow ) {
 
419
    const Akonadi::Item item = itemFromIndex( i );
 
420
    if ( CalendarSupport::hasIncidence( item ) ) {
 
421
      items << item;
 
422
    } else {
 
423
      QModelIndex childIndex = i.child( 0, 0 );
 
424
      if ( childIndex.isValid() ) {
 
425
        items << itemsFromModel( model, i );
 
426
      }
 
427
    }
 
428
 
 
429
    ++row;
 
430
    i = i.sibling( row, 0 );
 
431
  }
 
432
  return items;
 
433
}
 
434
 
 
435
Akonadi::Collection CalendarSupport::collectionFromIndex( const QModelIndex &index )
 
436
{
 
437
  return index.data( Akonadi::EntityTreeModel::CollectionRole ).value<Akonadi::Collection>();
 
438
}
 
439
 
 
440
Akonadi::Collection::Id CalendarSupport::collectionIdFromIndex( const QModelIndex &index )
 
441
{
 
442
  return index.data( Akonadi::EntityTreeModel::CollectionIdRole ).value<Akonadi::Collection::Id>();
 
443
}
 
444
 
 
445
Akonadi::Collection::List CalendarSupport::collectionsFromIndexes( const QModelIndexList &indexes )
 
446
{
 
447
  Akonadi::Collection::List l;
 
448
  Q_FOREACH( const QModelIndex &idx, indexes ) {
 
449
    l.push_back( collectionFromIndex( idx ) );
 
450
  }
 
451
  return l;
 
452
}
 
453
 
 
454
QString CalendarSupport::displayName( const Akonadi::Collection &c )
 
455
{
 
456
  const Akonadi::EntityDisplayAttribute *attr = c.attribute<Akonadi::EntityDisplayAttribute>();
 
457
  return ( attr && !attr->displayName().isEmpty() ) ? attr->displayName() : c.name();
 
458
}
 
459
 
 
460
QString CalendarSupport::subMimeTypeForIncidence( const KCalCore::Incidence::Ptr &incidence )
 
461
{
 
462
  return incidence->mimeType();
 
463
}
 
464
 
 
465
QList<QDate> CalendarSupport::workDays( const QDate &startDate,
 
466
                                        const QDate &endDate )
 
467
{
 
468
  QList<QDate> result;
 
469
 
 
470
/*  const int mask( ~( KCalPrefs::instance()->mWorkWeekMask ) );
 
471
  const int numDays = startDate.daysTo( endDate ) + 1;
 
472
 
 
473
  for ( int i = 0; i < numDays; ++i ) {
 
474
    const QDate date = startDate.addDays( i );
 
475
    if ( !( mask & ( 1 << ( date.dayOfWeek() - 1 ) ) ) ) {
 
476
      result.append( date );
 
477
    }
 
478
  }
 
479
 
 
480
  if ( KCalPrefs::instance()->mExcludeHolidays ) {
 
481
    // NOTE: KOGlobals, where this method comes from, used to hold a pointer to
 
482
    //       a KHolidays object. I'm not sure about how expensive it is, just
 
483
    //       creating one here.
 
484
    const HolidayRegion holidays( KCalPrefs::instance()->mHolidays );
 
485
    const Holiday::List list = holidays.holidays( startDate, endDate );
 
486
    for ( int i = 0; i < list.count(); ++i ) {
 
487
      const Holiday &h = list.at( i );
 
488
      const QString dateString = h.date().toString();
 
489
      if ( h.dayType() == Holiday::NonWorkday ) {
 
490
        result.removeAll( h.date() );
 
491
      }
 
492
    }
 
493
  }*/
 
494
 
 
495
  return result;
 
496
}
 
497
 
 
498
QStringList CalendarSupport::holiday( const QDate &date )
 
499
{
 
500
  QStringList hdays;
 
501
 
 
502
/*  const HolidayRegion holidays( KCalPrefs::instance()->mHolidays );
 
503
  const Holiday::List list = holidays.holidays( date );
 
504
 
 
505
  for ( int i = 0; i < list.count(); ++i ) {
 
506
    hdays.append( list.at( i ).text() );
 
507
  }*/
 
508
  return hdays;
 
509
}
 
510
 
 
511
void CalendarSupport::sendAsICalendar(const Akonadi::Item& item, KPIMIdentities::IdentityManager* identityManager, QWidget* parentWidget)
 
512
{
 
513
/*  Incidence::Ptr incidence = CalendarSupport::incidence( item );
 
514
 
 
515
  if ( !incidence ) {
 
516
    KMessageBox::information(
 
517
      parentWidget,
 
518
      i18n( "No item selected." ),
 
519
      i18n( "Forwarding" ),
 
520
      "ForwardNoEventSelected" );
 
521
    return;
 
522
  }
 
523
 
 
524
  QPointer<PublishDialog> publishdlg = new PublishDialog;
 
525
  if ( publishdlg->exec() == QDialog::Accepted ) {
 
526
    const QString recipients = publishdlg->addresses();
 
527
    if ( incidence->organizer()->isEmpty() ) {
 
528
      incidence->setOrganizer( Person::Ptr( new Person( CalendarSupport::KCalPrefs::instance()->fullName(),
 
529
                                                        CalendarSupport::KCalPrefs::instance()->email() ) ) );
 
530
    }
 
531
 
 
532
    ICalFormat format;
 
533
    const QString from = CalendarSupport::KCalPrefs::instance()->email();
 
534
    const bool bccMe = CalendarSupport::KCalPrefs::instance()->mBcc;
 
535
    const QString messageText = format.createScheduleMessage( incidence, iTIPRequest );
 
536
    CalendarSupport::MailClient mailer;
 
537
    if ( mailer.mailTo(
 
538
           incidence,
 
539
           identityManager->identityForAddress( from ),
 
540
           from, bccMe, recipients, messageText, MailTransport::TransportManager::self()->defaultTransportName() ) ) {
 
541
      KMessageBox::information(
 
542
        parentWidget,
 
543
        i18n( "The item information was successfully sent." ),
 
544
        i18n( "Forwarding" ),
 
545
        "IncidenceForwardSuccess" );
 
546
    } else {
 
547
      KMessageBox::error(
 
548
        parentWidget,
 
549
        i18n( "Unable to forward the item '%1'", incidence->summary() ),
 
550
        i18n( "Forwarding Error" ) );
 
551
    }
 
552
  }
 
553
  delete publishdlg;*/
 
554
}
 
555
 
 
556
void  CalendarSupport::publishItemInformation(const Akonadi::Item& item, Calendar* calendar, QWidget* parentWidget)
 
557
{
 
558
/*  Incidence::Ptr incidence = CalendarSupport::incidence( item );
 
559
 
 
560
  if ( !incidence ) {
 
561
    KMessageBox::information(
 
562
      parentWidget,
 
563
      i18n( "No item selected." ),
 
564
      "PublishNoEventSelected" );
 
565
    return;
 
566
  }
 
567
 
 
568
  QPointer<PublishDialog> publishdlg = new PublishDialog();
 
569
  if ( incidence->attendeeCount() > 0 ) {
 
570
    Attendee::List attendees = incidence->attendees();
 
571
    Attendee::List::ConstIterator it;
 
572
    for ( it = attendees.constBegin(); it != attendees.constEnd(); ++it ) {
 
573
      publishdlg->addAttendee( *it );
 
574
    }
 
575
  }
 
576
  if ( publishdlg->exec() == QDialog::Accepted ) {
 
577
    Incidence::Ptr inc( incidence->clone() );
 
578
    inc->registerObserver( 0 );
 
579
    inc->clearAttendees();
 
580
 
 
581
    // Send the mail
 
582
    CalendarSupport::MailScheduler scheduler( calendar );
 
583
    if ( scheduler.publish( incidence, publishdlg->addresses() ) ) {
 
584
      KMessageBox::information(
 
585
        parentWidget,
 
586
        i18n( "The item information was successfully sent." ),
 
587
        i18n( "Publishing" ),
 
588
        "IncidencePublishSuccess" );
 
589
    } else {
 
590
      KMessageBox::error(
 
591
        parentWidget,
 
592
        i18n( "Unable to publish the item '%1'", incidence->summary() ) );
 
593
    }
 
594
  }
 
595
  delete publishdlg;*/
 
596
}
 
597
 
 
598
void CalendarSupport::scheduleiTIPMethods( KCalCore::iTIPMethod method, const Akonadi::Item& item, CalendarSupport::Calendar* calendar, QWidget* parentWidget )
 
599
{
 
600
/*  Incidence::Ptr incidence = CalendarSupport::incidence( item );
 
601
 
 
602
  if ( !incidence ) {
 
603
    KMessageBox::sorry(
 
604
      parentWidget,
 
605
      i18n( "No item selected." ),
 
606
      "ScheduleNoEventSelected" );
 
607
    return;
 
608
  }
 
609
 
 
610
  if ( incidence->attendeeCount() == 0 && method != iTIPPublish ) {
 
611
    KMessageBox::information(
 
612
      parentWidget,
 
613
      i18n( "The item has no attendees." ),
 
614
      "ScheduleNoIncidences" );
 
615
    return;
 
616
  }
 
617
 
 
618
  Incidence *inc = incidence->clone();
 
619
  inc->registerObserver( 0 );
 
620
  inc->clearAttendees();
 
621
 
 
622
  // Send the mail
 
623
  CalendarSupport::MailScheduler scheduler( calendar );
 
624
  if ( scheduler.performTransaction( incidence, method ) ) {
 
625
    KMessageBox::information(
 
626
      parentWidget,
 
627
      i18n( "The groupware message for item '%1' "
 
628
            "was successfully sent.\nMethod: %2",
 
629
            incidence->summary(),
 
630
            ScheduleMessage::methodName( method ) ),
 
631
      i18n( "Sending Free/Busy" ),
 
632
      "FreeBusyPublishSuccess" );
 
633
  } else {
 
634
    KMessageBox::error(
 
635
      parentWidget,
 
636
      i18nc( "Groupware message sending failed. "
 
637
             "%2 is request/reply/add/cancel/counter/etc.",
 
638
             "Unable to send the item '%1'.\nMethod: %2",
 
639
             incidence->summary(),
 
640
             ScheduleMessage::methodName( method ) ) );
 
641
  }*/
 
642
}
 
643
 
 
644
void CalendarSupport::saveAttachments(const Akonadi::Item& item, QWidget* parentWidget)
 
645
{
 
646
/*  Incidence::Ptr incidence = CalendarSupport::incidence( item );
 
647
 
 
648
  if ( !incidence ) {
 
649
    KMessageBox::sorry(
 
650
      parentWidget,
 
651
      i18n( "No item selected." ),
 
652
      "SaveAttachments" );
 
653
    return;
 
654
  }
 
655
 
 
656
  Attachment::List attachments = incidence->attachments();
 
657
 
 
658
  if ( attachments.empty() )
 
659
    return;
 
660
 
 
661
  QString targetFile, targetDir;
 
662
  if ( attachments.count() > 1 ) {
 
663
    // get the dir
 
664
    targetDir = KFileDialog::getExistingDirectory( KUrl( "kfiledialog:///saveAttachment" ),
 
665
                                                   parentWidget,
 
666
                                                   i18n( "Save Attachments To" ) );
 
667
    if ( targetDir.isEmpty() ) {
 
668
      return;
 
669
    }
 
670
 
 
671
    // we may not get a slash-terminated url out of KFileDialog
 
672
    if ( !targetDir.endsWith('/') )
 
673
      targetDir.append('/');
 
674
  }
 
675
  else {
 
676
    // only one item, get the desired filename
 
677
    QString fileName = attachments.first()->label();
 
678
    if ( fileName.isEmpty() ) {
 
679
      fileName = i18nc( "filename for an unnamed attachment", "attachment.1" );
 
680
    }
 
681
    targetFile = KFileDialog::getSaveFileName( KUrl( "kfiledialog:///saveAttachment/" + fileName ),
 
682
                                   QString(),
 
683
                                   parentWidget,
 
684
                                   i18n( "Save Attachment" ) );
 
685
    if ( targetFile.isEmpty() ) {
 
686
      return;
 
687
    }
 
688
 
 
689
    targetDir = QFileInfo( targetFile ).absolutePath() + "/";
 
690
  }
 
691
 
 
692
  Q_FOREACH( Attachment::Ptr attachment, attachments ) {
 
693
    targetFile = targetDir + attachment->label();
 
694
    KUrl sourceUrl;
 
695
    if ( attachment->isUri() ) {
 
696
      sourceUrl = attachment->uri();
 
697
    } else {
 
698
      sourceUrl = incidence->writeAttachmentToTempFile( attachment );
 
699
    }
 
700
    // save the attachment url
 
701
    if ( !KIO::NetAccess::file_copy( sourceUrl, KUrl( targetFile ) ) &&
 
702
        KIO::NetAccess::lastError() ) {
 
703
      KMessageBox::error( parentWidget, KIO::NetAccess::lastErrorString() );
 
704
    }
 
705
  }*/
 
706
 
 
707
}