cleanup

5 files changed, 7 insertions, 28 deletions

diff --git a/libkcal/calstorage.h b/libkcal/calstorage.h
index 72972ea..82c8682 100644
--- a/libkcal/calstorage.h
+++ b/libkcal/calstorage.h
@@ -1,52 +1,52 @@
 /*
     This file is part of libkcal.
     Copyright (c) 2002 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 #ifndef KCAL_CALSTORAGE_H
 #define KCAL_CALSTORAGE_H
 
 namespace KCal {
 
 class Calendar;
 
 /**
   This class provides the interface to the storage of a calendar.
 */
 class CalStorage
 {
   public:
     CalStorage( Calendar *calendar )
     {
       mCalendar = calendar;
     }
     virtual ~CalStorage() {}
 
     Calendar *calendar() const { return mCalendar; }
   
     virtual bool open() = 0;
-    virtual bool load(bool = false ) = 0;
+    virtual bool load( ) = 0;
     virtual bool save() = 0;
     virtual bool close() = 0;
 
   private:
     Calendar *mCalendar;
 };
 
 }
 
 #endif
diff --git a/libkcal/filestorage.cpp b/libkcal/filestorage.cpp
index 00c15d9..a139124 100644
--- a/libkcal/filestorage.cpp
+++ b/libkcal/filestorage.cpp
@@ -1,140 +1,140 @@
 /*
     This file is part of libkcal.
     Copyright (c) 2002 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 #include <stdlib.h>
 
 #include <qdatetime.h>
 #include <qstring.h>
 #include <qptrlist.h>
 
 #include <kdebug.h>
 
 #include "calendar.h"
 #include "vcaldrag.h"
 #include "vcalformat.h"
 #include "icalformat.h"
 
 #include "filestorage.h"
 
 using namespace KCal;
 
 FileStorage::FileStorage( Calendar *cal, const QString &fileName,
                             CalFormat *format )
   : CalStorage( cal ),
     mFileName( fileName ),
     mSaveFormat( format )
 {
 }
 
 FileStorage::~FileStorage()
 {
   delete mSaveFormat;
 }
 
 void FileStorage::setFileName( const QString &fileName )
 {
   mFileName = fileName;
 }
 
 QString FileStorage::fileName()const
 {
   return mFileName;
 }
 
 
 void FileStorage::setSaveFormat( CalFormat *format )
 {
   delete mSaveFormat;
   mSaveFormat = format;
 }
 
 CalFormat *FileStorage::saveFormat()const
 {
   return mSaveFormat;
 }
 
 
 bool FileStorage::open()
 {
   return true;
 }
 
-bool FileStorage::load( bool quick )
+bool FileStorage::load( )
 {
   kdDebug(5800) << "FileStorage::load(): '" << mFileName << "'" << endl;
 
   // do we want to silently accept this, or make some noise?  Dunno...
   // it is a semantical thing vs. a practical thing.
   if (mFileName.isEmpty()) return false;
 
   // Always try to load with iCalendar. It will detect, if it is actually a
   // vCalendar file.
-  ICalFormat iCal (quick );
+  ICalFormat iCal;
 
   bool success = iCal.load( calendar(), mFileName);
 
   if ( !success ) {
     if ( iCal.exception() ) {
 //      kdDebug(5800) << "---Error: " << mFormat->exception()->errorCode() << endl;
       if ( iCal.exception()->errorCode() == ErrorFormat::CalVersion1 ) {
         // Expected non vCalendar file, but detected vCalendar
         kdDebug(5800) << "FileStorage::load() Fallback to VCalFormat" << endl;
         VCalFormat vCal;
         success = vCal.load( calendar(), mFileName );
         calendar()->setLoadedProductId( vCal.productId() );
       } else {
         return false;
       }
     } else {
       kdDebug(5800) << "Warning! There should be set an exception." << endl;
       return false;
     }
   } else {
 //    kdDebug(5800) << "---Success" << endl;
     calendar()->setLoadedProductId( iCal.loadedProductId() );
   }
 
   calendar()->setModified( false );
 
   return true;
 }
 
 bool FileStorage::save()
 {
   if ( mFileName.isEmpty() ) return false;
 
   bool success;
 
   if ( mSaveFormat ) {
     success = mSaveFormat->save( calendar(), mFileName);
   } else {
     ICalFormat iCal;
     success = iCal.save( calendar(), mFileName);
   }
 
   if ( success ) calendar()->setModified( false );
 
   return success;
 }
 
 bool FileStorage::close()
 {
   return true;
 }
diff --git a/libkcal/filestorage.h b/libkcal/filestorage.h
index e9dc15e..17010ac 100644
--- a/libkcal/filestorage.h
+++ b/libkcal/filestorage.h
@@ -1,58 +1,58 @@
 /*
     This file is part of libkcal.
     Copyright (c) 2002 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 #ifndef KCAL_FILESTORAGE_H
 #define KCAL_FILESTORAGE_H
 
 #include "calstorage.h"
 
 namespace KCal {
 
 /**
   This class provides a calendar storage as a local file.
 */
 class FileStorage : public CalStorage
 {
   public:
     FileStorage( Calendar *, const QString &fileName = QString::null,
                   CalFormat *format = 0 );
     virtual ~FileStorage();
 
     void setFileName( const QString &mFileName );
     QString fileName()const;
 
     /**
       FileStorage takes ownership of format object.
     */
     void setSaveFormat( CalFormat * );
     CalFormat *saveFormat()const;
 
     bool open();
-    bool load(bool quick = false );
+    bool load( );
     bool save();
     bool close();
 
   private:
     QString mFileName;
     CalFormat *mSaveFormat;
 };
 
 }
 
 #endif
diff --git a/libkcal/icalformat.cpp b/libkcal/icalformat.cpp
index f2e7dfc..3a2aac6 100644
--- a/libkcal/icalformat.cpp
+++ b/libkcal/icalformat.cpp
@@ -1,480 +1,460 @@
 /*
     This file is part of libkcal.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 #include <qdatetime.h>
 #include <qstring.h>
 #include <qptrlist.h>
 #include <qregexp.h>
 #include <qclipboard.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qtextcodec.h>
 #include <stdlib.h>
 
 #include <kdebug.h>
 #include <kglobal.h>
 #include <klocale.h>
 
 extern "C" {
   #include <ical.h>
   #include <icalss.h>
   #include <icalparser.h>
   #include <icalrestriction.h>
 }
 
 #include "calendar.h"
 #include "calendarlocal.h"
 #include "journal.h"
 
 #include "icalformat.h"
 #include "icalformatimpl.h"
 
 #define _ICAL_VERSION "2.0"
 
 using namespace KCal;
 
-ICalFormat::ICalFormat(bool quick )
+ICalFormat::ICalFormat( )
 {
-    mQuicksave = false; //quick; 
    mImpl = new ICalFormatImpl( this );
    tzOffsetMin = 0;
    //qDebug("new ICalFormat() ");
 }
 
 ICalFormat::~ICalFormat()
 {
   delete mImpl; 
   //qDebug("delete ICalFormat ");
 }
 
 bool ICalFormat::load( Calendar *calendar, const QString &fileName)
 {
 
   clearException();
 
   QFile file( fileName );  
   if (!file.open( IO_ReadOnly ) ) {
     setException(new ErrorFormat(ErrorFormat::LoadError));
     return false;
   } 
   QTextStream ts( &file );
   QString text; 
-#if 0
-  if ( !mQuicksave ) {
-      qDebug("KO: No quickload!");
-      ts.setEncoding( QTextStream::Latin1 );
-      text = ts.read(); 
-  } else {
-      ts.setCodec( QTextCodec::codecForName("utf8") );
-      text = ts.read(); 
-  }
-#endif
+
   ts.setEncoding( QTextStream::Latin1 );
   text = ts.read(); 
   file.close();
 
   return fromString( calendar, text );
 }
 
 //#include <qdatetime.h>
 bool ICalFormat::save( Calendar *calendar, const QString &fileName )
 {
     //kdDebug(5800) << "ICalFormat::save(): " << fileName << endl;
     //qDebug("ICalFormat::save ");
   clearException();
   QString text = toString( calendar );
   //return false; 
   // qDebug("to string takes ms: %d ",is.elapsed() );
   if ( text.isNull() ) return false;
 
   // TODO: write backup file
   //is.restart();
   QFile file( fileName );
   if (!file.open( IO_WriteOnly ) ) {
     setException(new ErrorFormat(ErrorFormat::SaveError,
                  i18n("Could not open file '%1'").arg(fileName)));
     return false;
   }
   QTextStream ts( &file );
 
-// #ifdef DESKTOP_VERSION
-//   mQuicksave = false;
-// #endif
-//   if ( mQuicksave ) {
-//       ts << text.utf8();
-//   } else {
-//       ts.setEncoding( QTextStream::Latin1 );
-//       ts << text;
-//       //ts << text.latin1();
-//   }
   ts.setEncoding( QTextStream::Latin1 );
   ts << text;
   file.close();
   //qDebug("saving file takes ms: %d ", is.elapsed() );
   return true;
 }
 
 bool ICalFormat::fromString( Calendar *cal, const QString &text )
 {
   setTimeZone( cal->timeZoneId(), !cal->isLocalTime() );
   // qDebug("ICalFormat::fromString tz: %s ", cal->timeZoneId().latin1());
   // Get first VCALENDAR component.
   // TODO: Handle more than one VCALENDAR or non-VCALENDAR top components
   icalcomponent *calendar;
 
   //calendar = icalcomponent_new_from_string( text.local8Bit().data());
   // good calendar = icalcomponent_new_from_string( text.utf8().data());
   calendar = icalcomponent_new_from_string( (char*)text.latin1());
   if (!calendar) {
     setException(new ErrorFormat(ErrorFormat::ParseErrorIcal));
     return false;
   }
 
   bool success = true;
 
   if (icalcomponent_isa(calendar) != ICAL_VCALENDAR_COMPONENT) {
     setException(new ErrorFormat(ErrorFormat::NoCalendar));
     success = false;
   } else {
     // put all objects into their proper places
     if ( !mImpl->populate( cal, calendar ) ) {
       if ( !exception() ) {
         setException(new ErrorFormat(ErrorFormat::ParseErrorKcal));
       } 
       success = false;
     } else
       mLoadedProductId = mImpl->loadedProductId();
   }
 
   icalcomponent_free( calendar );
 
   return success;
 }
 
 Incidence *ICalFormat::fromString( const QString &text )
 {
   CalendarLocal cal( mTimeZoneId );
   fromString(&cal, text);
   
   Incidence *ical = 0;
   QPtrList<Event> elist = cal.events();
   if ( elist.count() > 0 ) {
     ical = elist.first();
   } else {
     QPtrList<Todo> tlist = cal.todos();
     if ( tlist.count() > 0 ) {
       ical = tlist.first();
     } else {
       QPtrList<Journal> jlist = cal.journals();
       if ( jlist.count() > 0 ) {
         ical = jlist.first();
       }
     }
   }
   return ical;
 }
 #include <qapp.h>
 
 QString ICalFormat::toString( Calendar *cal )
 {
  
   setTimeZone( cal->timeZoneId(), !cal->isLocalTime() );
  
   icalcomponent *calendar = mImpl->createCalendarComponent(cal);
 
   icalcomponent *component;
  
   // todos 
   QPtrList<Todo> todoList = cal->rawTodos();
   QPtrListIterator<Todo> qlt(todoList);
   for (; qlt.current(); ++qlt) {
     component = mImpl->writeTodo(qlt.current());
     icalcomponent_add_component(calendar,component);
     //qDebug(" todos ");
     qApp->processEvents();
   }
   // events
   QPtrList<Event> events = cal->rawEvents();
   Event *ev;
   for(ev=events.first();ev;ev=events.next()) {
     component = mImpl->writeEvent(ev);
     icalcomponent_add_component(calendar,component);
     //qDebug("events ");
     qApp->processEvents();
   }
  
   // journals
   QPtrList<Journal> journals = cal->journals();
   Journal *j;
   for(j=journals.first();j;j=journals.next()) {
     component = mImpl->writeJournal(j);
     icalcomponent_add_component(calendar,component);
     //qDebug("journals ");
     qApp->processEvents(); 
   }
    const char *text; 
   QString ret =""; 
   text = icalcomponent_as_ical_string( calendar ); 
   qApp->processEvents(); 
 
   // text = "BEGIN:VCALENDAR\nPRODID\n :-//K Desktop Environment//NONSGML libkcal 3.1//EN\nVERSION\n :2.0\nBEGIN:VEVENT\nDTSTAMP\n :20031231T213514Z\nORGANIZER\n :MAILTO:lutz@putz.de\nCREATED\n :20031231T213513Z\nUID\n :libkcal-1295166342.120\nSEQUENCE\n :0\nLAST-MODIFIED\n :20031231T213513Z\nSUMMARY\n :test1\nCLASS\n :PUBLIC\nPRIORITY\n :3\nDTSTART\n :20040101T090000Z\nDTEND\n :20040101T110000Z\nTRANSP\n :OPAQUE\nEND:VEVENT\nEND:VCALENDAR\n";
 
 
    if ( text ) {
        ret = QString ( text );
    }
    icalcomponent_free( calendar );
 
   if (!text) { 
     setException(new ErrorFormat(ErrorFormat::SaveError,
                  i18n("libical error")));
     return QString::null;
   }
 
   return ret;
 }
 
 QString ICalFormat::toICalString( Incidence *incidence )
 {
   CalendarLocal cal( mTimeZoneId );
   cal.addIncidence( incidence->clone() );
   return toString( &cal );
 }
 
 QString ICalFormat::toString( Incidence *incidence )
 {
   icalcomponent *component;
 
   component = mImpl->writeIncidence( incidence );
 
   const char *text = icalcomponent_as_ical_string( component );
 
   icalcomponent_free( component );
 
   return QString::fromLocal8Bit( text );
 }
 
 QString ICalFormat::toString( Recurrence *recurrence )
 {
   icalproperty *property;
   property = mImpl->writeRecurrenceRule( recurrence );
   const char *text = icalproperty_as_ical_string( property );
   icalproperty_free( property );
   return QString::fromLocal8Bit( text );
 }
 /*
 bool ICalFormat::fromString( Recurrence * recurrence, const QString& rrule )
 {
   bool success = true;
   icalerror_clear_errno();
   struct icalrecurrencetype recur = icalrecurrencetype_from_string( rrule );
   if ( icalerrno != ICAL_NO_ERROR ) {
     kdDebug() << "Recurrence parsing error: " << icalerror_strerror( icalerrno ) << endl;
     success = false;
   }
 
   if ( success ) {
     mImpl->readRecurrence( recur, recurrence );
   }
 
   return success;
 }
 */
 
 QString ICalFormat::createScheduleMessage(IncidenceBase *incidence,
                                           Scheduler::Method method)
 {
   icalcomponent *message = mImpl->createScheduleComponent(incidence,method);
 
   QString messageText = icalcomponent_as_ical_string(message);
 
 
 
   return messageText;
 }
 
 ScheduleMessage *ICalFormat::parseScheduleMessage( Calendar *cal,
                                                    const QString &messageText )
 {
   setTimeZone( cal->timeZoneId(), !cal->isLocalTime() );
   clearException();
 
   if (messageText.isEmpty()) return 0;
 
   icalcomponent *message;
   message = icalparser_parse_string(messageText.local8Bit());
 
   if (!message) return 0;
 
   icalproperty *m = icalcomponent_get_first_property(message,
                                                      ICAL_METHOD_PROPERTY);
 
   if (!m) return 0;
 
   icalcomponent *c;
 
   IncidenceBase *incidence = 0;
   c = icalcomponent_get_first_component(message,ICAL_VEVENT_COMPONENT);
   if (c) {
     incidence = mImpl->readEvent(c);
   }
 
   if (!incidence) {
     c = icalcomponent_get_first_component(message,ICAL_VTODO_COMPONENT);
     if (c) {
       incidence = mImpl->readTodo(c);
     }
   }
 
   if (!incidence) {
     c = icalcomponent_get_first_component(message,ICAL_VFREEBUSY_COMPONENT);
     if (c) {
       incidence = mImpl->readFreeBusy(c);
     }
   }
 
   if (!incidence) {
     kdDebug() << "ICalFormat:parseScheduleMessage: object is not a freebusy, event or todo" << endl;
     return 0;
   }
 
   kdDebug(5800) << "ICalFormat::parseScheduleMessage() getting method..." << endl;
 
   icalproperty_method icalmethod = icalproperty_get_method(m);
   Scheduler::Method method;
 
   switch (icalmethod) {
     case ICAL_METHOD_PUBLISH:
       method = Scheduler::Publish;
       break;
     case ICAL_METHOD_REQUEST:
       method = Scheduler::Request;
       break;
     case ICAL_METHOD_REFRESH:
       method = Scheduler::Refresh;
       break;
     case ICAL_METHOD_CANCEL:
       method = Scheduler::Cancel;
       break;
     case ICAL_METHOD_ADD:
       method = Scheduler::Add;
       break;
     case ICAL_METHOD_REPLY:
       method = Scheduler::Reply;
       break;
     case ICAL_METHOD_COUNTER:
       method = Scheduler::Counter;
       break;
     case ICAL_METHOD_DECLINECOUNTER:
       method = Scheduler::Declinecounter;
       break;
     default:
       method = Scheduler::NoMethod;
       kdDebug(5800) << "ICalFormat::parseScheduleMessage(): Unknow method" << endl;
       break;
   }
 
 
   if (!icalrestriction_check(message)) {
     setException(new ErrorFormat(ErrorFormat::Restriction,
                                    Scheduler::translatedMethodName(method) + ": " +
                                    mImpl->extractErrorProperty(c)));
     return 0;
   }
 
   icalcomponent *calendarComponent = mImpl->createCalendarComponent(cal);
 
   Incidence *existingIncidence = cal->event(incidence->uid());
   if (existingIncidence) {
     // TODO: check, if cast is required, or if it can be done by virtual funcs.
     if (existingIncidence->type() == "Todo") {
       Todo *todo = static_cast<Todo *>(existingIncidence);
       icalcomponent_add_component(calendarComponent,
                                   mImpl->writeTodo(todo));
     }
     if (existingIncidence->type() == "Event") {
       Event *event = static_cast<Event *>(existingIncidence);
       icalcomponent_add_component(calendarComponent,
                                   mImpl->writeEvent(event));
     }
   } else {
     calendarComponent = 0;
   }
   qDebug("icalclassify commented out ");
   ScheduleMessage::Status status;
 #if 0
 
   icalclass result = icalclassify(message,calendarComponent,(char *)"");
 
 
 
   switch (result) {
     case ICAL_PUBLISH_NEW_CLASS:
       status = ScheduleMessage::PublishNew;
       break;
     case ICAL_OBSOLETE_CLASS:
       status = ScheduleMessage::Obsolete;
       break;
     case ICAL_REQUEST_NEW_CLASS:
       status = ScheduleMessage::RequestNew;
       break;
     case ICAL_REQUEST_UPDATE_CLASS:
       status = ScheduleMessage::RequestUpdate;
       break;
     case ICAL_UNKNOWN_CLASS:
     default:
       status = ScheduleMessage::Unknown;
       break;
   }
 #endif
   status = ScheduleMessage::RequestUpdate;
   return new ScheduleMessage(incidence,method,status);
 }
 
 void ICalFormat::setTimeZone( const QString &id, bool utc )
 {
 
 
     mTimeZoneId = id;
     mUtc = utc;
 
     tzOffsetMin  = KGlobal::locale()->timezoneOffset(mTimeZoneId);
   
     //qDebug("ICalFormat::setTimeZoneOffset %s %d ",mTimeZoneId.latin1(),  tzOffsetMin);
 }
 
 QString ICalFormat::timeZoneId() const
 {
   return mTimeZoneId;
 }
 
 bool ICalFormat::utc() const
 {
   return mUtc;
 }
 int ICalFormat::timeOffset()
 {
     return tzOffsetMin;
 }
 const char *ICalFormat::tzString()
 {
     const char*  ret = (const char* ) mTzString;
     return ret;
 }
diff --git a/libkcal/icalformat.h b/libkcal/icalformat.h
index 236efbf..485ab6e 100644
--- a/libkcal/icalformat.h
+++ b/libkcal/icalformat.h
@@ -1,116 +1,115 @@
 /*
     This file is part of libkcal.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 #ifndef ICALFORMAT_H
 #define ICALFORMAT_H
 
 #include <qstring.h>
 
 #include "scheduler.h"
 
 #include "calformat.h"
 
 namespace KCal {
 
 class ICalFormatImpl;
 
 /**
   This class implements the iCalendar format. It provides methods for
   loading/saving/converting iCalendar format data into the internal KOrganizer
   representation as Calendar and Events.
 
   @short iCalendar format implementation
 */
 class ICalFormat : public CalFormat {
   public:
     /** Create new iCalendar format. */
-    ICalFormat( bool quick = false );
+    ICalFormat( );
     virtual ~ICalFormat();
 
     /**
       Loads a calendar on disk in iCalendar format into calendar.
       Returns true if successful, else returns false. Provides more error
       information by exception().
       @param calendar Calendar object to be filled.
       @param fileName The name of the calendar file on disk.
     */
     bool load( Calendar *, const QString &fileName );
     /**
       Writes out the calendar to disk in iCalendar format. Returns true if
      successful and false on error.
      
      @param calendar The Calendar object to be written.
      @param fileName The name of the calendar file on disk.
     */
     bool save( Calendar *, const QString &fileName );
 
     /**
       Parse string and populate calendar with that information.
     */
     bool fromString( Calendar *, const QString & );  
     /**
       Parse string and return first ical component.
     */
     Incidence *fromString( const QString & );  
     /**
       Return calendar information as string.
     */
     QString toString( Calendar * );
     /**
       Return incidence as full iCalendar formatted text.
     */
     QString toICalString( Incidence * );
     /**
       Return incidence as iCalendar formatted text.
     */
     QString toString( Incidence * );
     /**
       Return recurrence as iCalendar formatted text.
     */
     QString toString( Recurrence * );
     /**
       Parse string and fill recurrence object with
       that information
     */
     //bool fromString ( Recurrence *, const QString& );
   
     /** Create a scheduling message for event \a e using method \m */
     QString createScheduleMessage(IncidenceBase *e,Scheduler::Method m);
     /** Parse scheduling message provided as string \s */
     ScheduleMessage *parseScheduleMessage( Calendar *, const QString &s);
     
     /** Set id of used time zone and whether this time zone is UTC or not. */
     void setTimeZone( const QString &id, bool utc );
     QString timeZoneId() const;
     int timeOffset();
     const char * tzString();
     bool utc() const;
 
   private:
     ICalFormatImpl *mImpl;
-    bool mQuicksave;
     QString mTimeZoneId;
     QCString mTzString;
     int tzOffsetMin;
     bool mUtc;
 };
 
 }
 
 #endif