fix in save vcal as local time

1 files changed, 3 insertions, 7 deletions

diff --git a/libkcal/vcalformat.cpp b/libkcal/vcalformat.cpp
index 309c699..a6ae1bc 100644
--- a/libkcal/vcalformat.cpp
+++ b/libkcal/vcalformat.cpp
@@ -1,420 +1,416 @@
 /*
     This file is part of libkcal.
     Copyright (c) 1998 Preston Brwon
     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 <qapplication.h>
 #include <qdatetime.h>
 #include <qstring.h>
 #include <qptrlist.h>
 #include <qregexp.h>
 #include <qclipboard.h>
 #include <qdialog.h>
 #include <qfile.h>
 
 #include <kdebug.h>
 #include <kglobal.h>
 #include <kmessagebox.h>
 #include <kiconloader.h>
 #include <klocale.h>
 
 #include "vcc.h"
 #include "vobject.h"
 
 #include "vcaldrag.h"
 #include "calendar.h"
 
 #include "vcalformat.h"
 
 using namespace KCal;
 
 VCalFormat::VCalFormat()
 {
     mCalendar = 0;
     useLocalTime = false;
 }
 
 VCalFormat::~VCalFormat()
 {
 }
 
 void VCalFormat::setLocalTime ( bool b )
 {
     useLocalTime = b;
 }
 bool VCalFormat::load(Calendar *calendar, const QString &fileName)
 {
   mCalendar = calendar;
   clearException();
-
-  kdDebug(5800) << "VCalFormat::load() " << fileName << endl;
-
+  useLocalTime = mCalendar->isLocalTime();
   VObject *vcal = 0;
 
   // this is not necessarily only 1 vcal.  Could be many vcals, or include
   // a vcard...
   vcal = Parse_MIME_FromFileName(const_cast<char *>(QFile::encodeName(fileName).data()));
 
   if (!vcal) {
     setException(new ErrorFormat(ErrorFormat::CalVersionUnknown));
     return FALSE;
   }
 
   // any other top-level calendar stuff should be added/initialized here
 
   // put all vobjects into their proper places
   populate(vcal);
 
   // clean up from vcal API stuff
   cleanVObjects(vcal);
   cleanStrTbl();
 
   return true;
 }
 
 
 bool VCalFormat::save(Calendar *calendar, const QString &fileName)
 {
   mCalendar = calendar;
+  useLocalTime = mCalendar->isLocalTime();
 
   QString tmpStr;
   VObject *vcal, *vo;
 
-  kdDebug(5800) << "VCalFormat::save(): " << fileName << endl;
 
   vcal = newVObject(VCCalProp);
 
   //  addPropValue(vcal,VCLocationProp, "0.0");
   addPropValue(vcal,VCProdIdProp, productId());
   tmpStr = mCalendar->getTimeZoneStr();
   //qDebug("mCalendar->getTimeZoneStr() %s",tmpStr.latin1() );
   addPropValue(vcal,VCTimeZoneProp, tmpStr.local8Bit());
   addPropValue(vcal,VCVersionProp, _VCAL_VERSION);
 
   // TODO STUFF
   QPtrList<Todo> todoList = mCalendar->rawTodos();
   QPtrListIterator<Todo> qlt(todoList);
   for (; qlt.current(); ++qlt) {
     vo = eventToVTodo(qlt.current());
     addVObjectProp(vcal, vo);
   }
 
   // EVENT STUFF
   QPtrList<Event> events = mCalendar->rawEvents();
   Event *ev;
   for(ev=events.first();ev;ev=events.next()) {
     vo = eventToVEvent(ev);
     addVObjectProp(vcal, vo);
   }
 
   writeVObjectToFile(QFile::encodeName(fileName).data() ,vcal);
   cleanVObjects(vcal);
   cleanStrTbl();
 
   if (QFile::exists(fileName)) {
-    kdDebug(5800) << "No error" << endl;
     return true;
   } else  {
-    kdDebug(5800) << "Error" << endl;
     return false; // error
   }
 }
 
 bool VCalFormat::fromString( Calendar *calendar, const QString &text )
 {
   // TODO: Factor out VCalFormat::fromString()
 
   QCString data = text.utf8();
 
   if ( !data.size() ) return false;
 
   VObject *vcal = Parse_MIME( data.data(), data.size());
   if ( !vcal ) return false;
 
   VObjectIterator i;
   VObject *curvo;
   initPropIterator( &i, vcal );
 
   // we only take the first object. TODO: parse all incidences.
   do  {
     curvo = nextVObject( &i );
   } while ( strcmp( vObjectName( curvo ), VCEventProp ) &&
             strcmp( vObjectName( curvo ), VCTodoProp ) );
 
   if ( strcmp( vObjectName( curvo ), VCEventProp ) == 0 ) {
     Event *event = VEventToEvent( curvo );
     calendar->addEvent( event );
   } else {
-    kdDebug(5800) << "VCalFormat::fromString(): Unknown object type." << endl;
+      qDebug("VCalFormat::fromString(): Unknown object type. ");
     deleteVObject( vcal );
     return false;
   }
 
   deleteVObject( vcal );
 
   return true;
 }
 
 QString VCalFormat::eventToString( Event * event, Calendar *calendar, bool useLocal)
 {
  
   if ( !event ) return QString::null;
   bool useL = useLocalTime;
   useLocalTime = useLocal;
   mCalendar = calendar;
   VObject *vevent = eventToVEvent( event );
   char *buf = writeMemVObject( 0, 0, vevent );
   QString result( buf );
   cleanVObject( vevent );
   useLocalTime =  useL;
   return result;
 }
 QString VCalFormat::todoToString( Todo * todo, Calendar *calendar, bool useLocal )
 {
  
  if ( !todo ) return QString::null;
   bool useL = useLocalTime;
   useLocalTime = useLocal;
   mCalendar = calendar;
   VObject *vevent = eventToVTodo( todo );
   char *buf = writeMemVObject( 0, 0, vevent );
   QString result( buf );
   cleanVObject( vevent );
   useLocalTime =  useL;
   return result;
 }
 
 QString VCalFormat::toString( Calendar *calendar )
 {
   // TODO: Factor out VCalFormat::asString()
 
   VObject *vcal = newVObject(VCCalProp);
 
   addPropValue( vcal, VCProdIdProp, CalFormat::productId() );
   QString tmpStr = mCalendar->getTimeZoneStr();
   addPropValue( vcal, VCTimeZoneProp, tmpStr.local8Bit() );
   addPropValue( vcal, VCVersionProp, _VCAL_VERSION );
 
   // TODO: Use all data.
   QPtrList<Event> events = calendar->events();
   Event *event = events.first();
   if ( !event ) return QString::null;
 
   VObject *vevent = eventToVEvent( event );
 
   addVObjectProp( vcal, vevent );
 
   char *buf = writeMemVObject( 0, 0, vcal );
 
   QString result( buf );
 
   cleanVObject( vcal );
 
   return result;
 }
 
 VObject *VCalFormat::eventToVTodo(const Todo *anEvent)
 {
   VObject *vtodo;
   QString tmpStr;
   QStringList tmpStrList;
 
   vtodo = newVObject(VCTodoProp);
 
   // due date
   if (anEvent->hasDueDate()) {
     tmpStr = qDateTimeToISO(anEvent->dtDue(),
                             !anEvent->doesFloat());
     addPropValue(vtodo, VCDueProp, tmpStr.local8Bit());
   }
 
   // start date
   if (anEvent->hasStartDate()) {
     tmpStr = qDateTimeToISO(anEvent->dtStart(),
 	                    !anEvent->doesFloat());
     addPropValue(vtodo, VCDTstartProp, tmpStr.local8Bit());
   }
 
   // creation date
   tmpStr = qDateTimeToISO(anEvent->created());
   addPropValue(vtodo, VCDCreatedProp, tmpStr.local8Bit());
 
   // unique id
   addPropValue(vtodo, VCUniqueStringProp,
 	       anEvent->uid().local8Bit());
 
   // revision
   tmpStr.sprintf("%i", anEvent->revision());
   addPropValue(vtodo, VCSequenceProp, tmpStr.local8Bit());
 
   // last modification date
   tmpStr = qDateTimeToISO(anEvent->lastModified());
   addPropValue(vtodo, VCLastModifiedProp, tmpStr.local8Bit());
 
   // organizer stuff
   tmpStr = "MAILTO:" + anEvent->organizer();
   addPropValue(vtodo, ICOrganizerProp, tmpStr.local8Bit());
 
   // attendees
   if (anEvent->attendeeCount() != 0) {
     QPtrList<Attendee> al = anEvent->attendees();
     QPtrListIterator<Attendee> ai(al);
     Attendee *curAttendee;
 
     for (; ai.current(); ++ai) {
       curAttendee = ai.current();
       if (!curAttendee->email().isEmpty() &&
 	  !curAttendee->name().isEmpty())
         tmpStr = "MAILTO:" + curAttendee->name() + " <" +
                  curAttendee->email() + ">";
       else if (curAttendee->name().isEmpty())
         tmpStr = "MAILTO: " + curAttendee->email();
       else if (curAttendee->email().isEmpty())
         tmpStr = "MAILTO: " + curAttendee->name();
       else if (curAttendee->name().isEmpty() &&
 	       curAttendee->email().isEmpty())
 	kdDebug(5800) << "warning! this Event has an attendee w/o name or email!" << endl;
       VObject *aProp = addPropValue(vtodo, VCAttendeeProp, tmpStr.local8Bit());
       addPropValue(aProp, VCRSVPProp, curAttendee->RSVP() ? "TRUE" : "FALSE");
       addPropValue(aProp, VCStatusProp, writeStatus(curAttendee->status()));
     }
   }
 
   // description BL:
   if (!anEvent->description().isEmpty()) {
     VObject *d = addPropValue(vtodo, VCDescriptionProp,
 			      anEvent->description().local8Bit());
     if (anEvent->description().find('\n') != -1)
       addProp(d, VCQuotedPrintableProp);
   }
 
   // summary
   if (!anEvent->summary().isEmpty())
     addPropValue(vtodo, VCSummaryProp, anEvent->summary().local8Bit());
 
   if (!anEvent->location().isEmpty())
     addPropValue(vtodo, VCLocationProp, anEvent->location().local8Bit());
 
   // completed
   // status
   // backward compatibility, KOrganizer used to interpret only these two values
   addPropValue(vtodo, VCStatusProp, anEvent->isCompleted() ? "COMPLETED" :
                                                              "NEEDS_ACTION");
   // completion date
   if (anEvent->hasCompletedDate()) {
     tmpStr = qDateTimeToISO(anEvent->completed());
     addPropValue(vtodo, VCCompletedProp, tmpStr.local8Bit());
   }
 
   // priority
   tmpStr.sprintf("%i",anEvent->priority());
   addPropValue(vtodo, VCPriorityProp, tmpStr.local8Bit());
 
   // related event
   if (anEvent->relatedTo()) {
     addPropValue(vtodo, VCRelatedToProp,
 	         anEvent->relatedTo()->uid().local8Bit());
   }
 
   // categories
   tmpStrList = anEvent->categories();
   tmpStr = "";
   QString catStr;
   for ( QStringList::Iterator it = tmpStrList.begin();
         it != tmpStrList.end();
         ++it ) {
     catStr = *it;
     if (catStr[0] == ' ')
       tmpStr += catStr.mid(1);
     else
       tmpStr += catStr;
     // this must be a ';' character as the vCalendar specification requires!
     // vcc.y has been hacked to translate the ';' to a ',' when the vcal is
     // read in.
     tmpStr += ";";
   }
   if (!tmpStr.isEmpty()) {
     tmpStr.truncate(tmpStr.length()-1);
     addPropValue(vtodo, VCCategoriesProp, tmpStr.local8Bit());
   }
 
   // alarm stuff
   kdDebug(5800) << "vcalformat::eventToVTodo was called" << endl;
   QPtrList<Alarm> alarms = anEvent->alarms();
   Alarm* alarm;
   for (alarm = alarms.first(); alarm; alarm = alarms.next()) {
     if (alarm->enabled()) {
         VObject *a;
             tmpStr = qDateTimeToISO(alarm->time());
         if (alarm->type() == Alarm::Audio) {
             a = addProp(vtodo, VCAAlarmProp);
             addPropValue(a, VCRunTimeProp, tmpStr.local8Bit());
             addPropValue(a, VCRepeatCountProp, "1");
             addPropValue(a, VCAudioContentProp, QFile::encodeName(alarm->audioFile()));
         }
         else if (alarm->type() == Alarm::Procedure) {
             a = addProp(vtodo, VCPAlarmProp);
             addPropValue(a, VCRunTimeProp, tmpStr.local8Bit());
             addPropValue(a, VCRepeatCountProp, "1");
             addPropValue(a, VCProcedureNameProp, QFile::encodeName(alarm->programFile()));
         } else {
             a = addProp(vtodo, VCDAlarmProp);
             addPropValue(a, VCRunTimeProp, tmpStr.local8Bit());
             addPropValue(a, VCRepeatCountProp, "1");
             addPropValue(a, VCDisplayStringProp, "beep!");
       }
     }
   }
 
   if (anEvent->pilotId()) {
     // pilot sync stuff
     tmpStr.sprintf("%i",anEvent->pilotId());
     addPropValue(vtodo, XPilotIdProp, tmpStr.local8Bit());
     tmpStr.sprintf("%i",anEvent->syncStatus());
     addPropValue(vtodo, XPilotStatusProp, tmpStr.local8Bit());
   }
 
   return vtodo;
 }
 
 VObject* VCalFormat::eventToVEvent(const Event *anEvent)
 {
   VObject *vevent;
   QString tmpStr;
   QStringList tmpStrList;
 
   vevent = newVObject(VCEventProp);
 
   // start and end time
   tmpStr = qDateTimeToISO(anEvent->dtStart(),
 			  !anEvent->doesFloat());
   addPropValue(vevent, VCDTstartProp, tmpStr.local8Bit());
 
   // events that have time associated but take up no time should
   // not have both DTSTART and DTEND.
   if (anEvent->dtStart() != anEvent->dtEnd()) {
     tmpStr = qDateTimeToISO(anEvent->dtEnd(),
 			    !anEvent->doesFloat());
     addPropValue(vevent, VCDTendProp, tmpStr.local8Bit());
   }
 
   // creation date
   tmpStr = qDateTimeToISO(anEvent->created());
   addPropValue(vevent, VCDCreatedProp, tmpStr.local8Bit());