removed two debug output

1 files changed, 2 insertions, 2 deletions

diff --git a/libkcal/icalformatimpl.cpp b/libkcal/icalformatimpl.cpp
index 964ffe3..3437f45 100644
--- a/libkcal/icalformatimpl.cpp
+++ b/libkcal/icalformatimpl.cpp
@@ -1246,559 +1246,559 @@ void ICalFormatImpl::readIncidence(icalcomponent *parent,Incidence *incidence)
         incidence->addExDate(readICalDate(icaltime));
         break;
 
     case ICAL_CLASS_PROPERTY: {
         int inttext = icalproperty_get_class(p);
         if (inttext == ICAL_CLASS_PUBLIC ) {
           incidence->setSecrecy(Incidence::SecrecyPublic);
         } else if (inttext == ICAL_CLASS_CONFIDENTIAL ) {
           incidence->setSecrecy(Incidence::SecrecyConfidential);
         } else {
           incidence->setSecrecy(Incidence::SecrecyPrivate);
         }
     }
         break;
 
       case ICAL_ATTACH_PROPERTY:  // attachments
         incidence->addAttachment(readAttachment(p));
         break;
  
       default:
 //        kdDebug(5800) << "ICALFormat::readIncidence(): Unknown property: " << kind
 //                  << endl;
         break;
     }
 
     p = icalcomponent_get_next_property(parent,ICAL_ANY_PROPERTY);
   }
   if ( readrec ) {
       readRecurrenceRule(rectype,incidence);
   }
   // kpilot stuff
 // TODO: move this application-specific code to kpilot
   QString kp = incidence->nonKDECustomProperty("X-PILOTID");
   if (!kp.isNull()) {
     incidence->setPilotId(kp.toInt());
   }
   kp = incidence->nonKDECustomProperty("X-PILOTSTAT");
   if (!kp.isNull()) {
     incidence->setSyncStatus(kp.toInt());
   }
   kp = incidence->nonKDECustomProperty("X-ZAURUSID");
   if (!kp.isNull()) {
     incidence->setZaurusId(kp.toInt());
   }
 
   kp = incidence->nonKDECustomProperty("X-ZAURUSUID");
   if (!kp.isNull()) {
     incidence->setZaurusUid(kp.toInt());
   }
 
   kp = incidence->nonKDECustomProperty("X-ZAURUSSTAT");
   if (!kp.isNull()) {
     incidence->setZaurusStat(kp.toInt());
   }
 
   // Cancel backwards compatibility mode for subsequent changes by the application
   incidence->recurrence()->setCompatVersion();
 
   // add categories
   incidence->setCategories(categories);
 
   // iterate through all alarms
   for (icalcomponent *alarm = icalcomponent_get_first_component(parent,ICAL_VALARM_COMPONENT);
        alarm;
        alarm = icalcomponent_get_next_component(parent,ICAL_VALARM_COMPONENT)) {
     readAlarm(alarm,incidence);
   }
 }
 
 void ICalFormatImpl::readIncidenceBase(icalcomponent *parent,IncidenceBase *incidenceBase)
 {
   icalproperty *p = icalcomponent_get_first_property(parent,ICAL_ANY_PROPERTY);
 
   while (p) {
     icalproperty_kind kind = icalproperty_isa(p);
     switch (kind) {
 
       case ICAL_UID_PROPERTY:  // unique id
         incidenceBase->setUid(QString::fromUtf8(icalproperty_get_uid(p)));
         break;
 
       case ICAL_ORGANIZER_PROPERTY:  // organizer
         incidenceBase->setOrganizer(QString::fromUtf8(icalproperty_get_organizer(p)));
         break;
 
       case ICAL_ATTENDEE_PROPERTY:  // attendee
         incidenceBase->addAttendee(readAttendee(p));
         break;
 
       default:
         break;
     }
 
     p = icalcomponent_get_next_property(parent,ICAL_ANY_PROPERTY);
   }
 
   // custom properties
   readCustomProperties(parent, incidenceBase);
 }
 
 void ICalFormatImpl::readCustomProperties(icalcomponent *parent,CustomProperties *properties)
 {
   QMap<QCString, QString> customProperties;
 
   icalproperty *p = icalcomponent_get_first_property(parent,ICAL_X_PROPERTY);
 
   while (p) {
     QString value = QString::fromUtf8(icalproperty_get_x(p));
     customProperties[icalproperty_get_x_name(p)] = value;
     //qDebug("ICalFormatImpl::readCustomProperties %s %s",value.latin1(), icalproperty_get_x_name(p) );
 
     p = icalcomponent_get_next_property(parent,ICAL_X_PROPERTY);
   }
 
   properties->setCustomProperties(customProperties);
 }
 
 void ICalFormatImpl::readRecurrenceRule(struct icalrecurrencetype rrule,Incidence *incidence)
 {
 //  kdDebug(5800) << "Read recurrence for " << incidence->summary() << endl;
 
   Recurrence *recur = incidence->recurrence();
   recur->setCompatVersion(mCalendarVersion);
   recur->unsetRecurs();
 
   struct icalrecurrencetype r = rrule;
 
   dumpIcalRecurrence(r);
   readRecurrence( r, recur, incidence);
 }
 
 void ICalFormatImpl::readRecurrence( const struct icalrecurrencetype &r, Recurrence* recur, Incidence *incidence)
 {
     int wkst;
     int index = 0;
     short day = 0;
     QBitArray qba(7);
     int frequ = r.freq;
     int interv = r.interval;
     // preprocessing for odd recurrence definitions
     
     if ( r.freq == ICAL_MONTHLY_RECURRENCE ) {
         if ( r.by_month[0] != ICAL_RECURRENCE_ARRAY_MAX) {
             interv = 12;
         }
     }
     if ( r.freq == ICAL_YEARLY_RECURRENCE ) {
         if ( r.by_month[0] != ICAL_RECURRENCE_ARRAY_MAX && r.by_day[0] != ICAL_RECURRENCE_ARRAY_MAX ) {
             frequ = ICAL_MONTHLY_RECURRENCE;
             interv = 12* r.interval;
         }
     }
   
     switch (frequ) {
     case ICAL_MINUTELY_RECURRENCE:
         if (!icaltime_is_null_time(r.until)) {
             recur->setMinutely(interv,readICalDateTime(r.until));
         } else {
             if (r.count == 0)
                 recur->setMinutely(interv,-1);
             else
                 recur->setMinutely(interv,r.count);
         }
         break;
     case ICAL_HOURLY_RECURRENCE:
         if (!icaltime_is_null_time(r.until)) {
             recur->setHourly(interv,readICalDateTime(r.until));
         } else {
             if (r.count == 0)
                 recur->setHourly(interv,-1);
             else
                 recur->setHourly(interv,r.count);
         }
         break;
     case ICAL_DAILY_RECURRENCE:
         if (!icaltime_is_null_time(r.until)) {
             recur->setDaily(interv,readICalDate(r.until));
         } else {
             if (r.count == 0)
                 recur->setDaily(interv,-1);
             else
                 recur->setDaily(interv,r.count);
         }
         break;
     case ICAL_WEEKLY_RECURRENCE:
         //      kdDebug(5800) << "WEEKLY_RECURRENCE" << endl;
         wkst = (r.week_start + 5)%7 + 1;
         if (!icaltime_is_null_time(r.until)) {
             recur->setWeekly(interv,qba,readICalDate(r.until),wkst);
         } else {
             if (r.count == 0)
                 recur->setWeekly(interv,qba,-1,wkst);
             else
                 recur->setWeekly(interv,qba,r.count,wkst);
         } 
         if ( r.by_day[0] == ICAL_RECURRENCE_ARRAY_MAX) {
             int wday = incidence->dtStart().date().dayOfWeek ()-1;
             //qDebug("weekly error found ");
             qba.setBit(wday);  
         } else {
             while((day = r.by_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
                 //        kdDebug(5800) << " " << day << endl;
                 qba.setBit((day+5)%7);    // convert from Sunday=1 to Monday=0
             }
         }
         break;
     case ICAL_MONTHLY_RECURRENCE:
        
         if (r.by_day[0] != ICAL_RECURRENCE_ARRAY_MAX) {
             if (!icaltime_is_null_time(r.until)) {
                 recur->setMonthly(Recurrence::rMonthlyPos,interv,
                                   readICalDate(r.until));
             } else {
                 if (r.count == 0)
                     recur->setMonthly(Recurrence::rMonthlyPos,interv,-1);
                 else
                     recur->setMonthly(Recurrence::rMonthlyPos,interv,r.count);
             }
             bool useSetPos = false;
             short pos = 0;
             while((day = r.by_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
                 //          kdDebug(5800) << "----a " << index << ": " << day << endl;
                 pos = icalrecurrencetype_day_position(day);
                 if (pos) {
                     day = icalrecurrencetype_day_day_of_week(day);
                     QBitArray ba(7);          // don't wipe qba
                     ba.setBit((day+5)%7);     // convert from Sunday=1 to Monday=0
                     recur->addMonthlyPos(pos,ba);
                 } else {
                     qba.setBit((day+5)%7);    // convert from Sunday=1 to Monday=0
                     useSetPos = true;
                 }
             }
             if (useSetPos) {
                 if (r.by_set_pos[0] != ICAL_RECURRENCE_ARRAY_MAX) {
                     recur->addMonthlyPos(r.by_set_pos[0],qba);
                 }
             }
         } else if (r.by_month_day[0] != ICAL_RECURRENCE_ARRAY_MAX) {
             if (!icaltime_is_null_time(r.until)) {
                 recur->setMonthly(Recurrence::rMonthlyDay,interv,
                                   readICalDate(r.until));
             } else {
                 if (r.count == 0)
                     recur->setMonthly(Recurrence::rMonthlyDay,interv,-1);
                 else
                     recur->setMonthly(Recurrence::rMonthlyDay,interv,r.count);
             }
             while((day = r.by_month_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
                 //          kdDebug(5800) << "----b " << day << endl;
                 recur->addMonthlyDay(day);
             }
         }
         break;
     case ICAL_YEARLY_RECURRENCE:
         if (r.by_year_day[0] != ICAL_RECURRENCE_ARRAY_MAX) {
-            qDebug(" YEARLY  DAY OF YEAR");
+            //qDebug(" YEARLY  DAY OF YEAR");
             if (!icaltime_is_null_time(r.until)) {
                 recur->setYearly(Recurrence::rYearlyDay,interv,
                                  readICalDate(r.until));
             } else {
                 if (r.count == 0)
                     recur->setYearly(Recurrence::rYearlyDay,interv,-1);
                 else
                     recur->setYearly(Recurrence::rYearlyDay,interv,r.count);
             }
             while((day = r.by_year_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
                 recur->addYearlyNum(day);
             }
         } else if ( true /*r.by_month[0] != ICAL_RECURRENCE_ARRAY_MAX*/) {
             if (r.by_day[0] != ICAL_RECURRENCE_ARRAY_MAX) {
                 qDebug("YEARLY POS NOT SUPPORTED BY GUI");
                 if (!icaltime_is_null_time(r.until)) {
                     recur->setYearly(Recurrence::rYearlyPos,interv,
                                      readICalDate(r.until));
                 } else {
                     if (r.count == 0)
                         recur->setYearly(Recurrence::rYearlyPos,interv,-1);
                     else
                         recur->setYearly(Recurrence::rYearlyPos,interv,r.count);
                 }
                 bool useSetPos = false;
                 short pos = 0;
                 while((day = r.by_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
                     //            kdDebug(5800) << "----a " << index << ": " << day << endl;
                     pos = icalrecurrencetype_day_position(day);
                     if (pos) {
                         day = icalrecurrencetype_day_day_of_week(day);
                         QBitArray ba(7);          // don't wipe qba
                         ba.setBit((day+5)%7);     // convert from Sunday=1 to Monday=0
                         recur->addYearlyMonthPos(pos,ba);
                     } else {
                         qba.setBit((day+5)%7);    // convert from Sunday=1 to Monday=0
                         useSetPos = true;
                     }
                 }
                 if (useSetPos) {
                     if (r.by_set_pos[0] != ICAL_RECURRENCE_ARRAY_MAX) {
                         recur->addYearlyMonthPos(r.by_set_pos[0],qba);
                     }
                 }
             } else { 
-                qDebug("YEARLY MONTH ");
+                //qDebug("YEARLY MONTH ");
                 if (!icaltime_is_null_time(r.until)) {
                     recur->setYearly(Recurrence::rYearlyMonth,interv,
                                      readICalDate(r.until));
                 } else {
                     if (r.count == 0)
                         recur->setYearly(Recurrence::rYearlyMonth,interv,-1);
                     else
                         recur->setYearly(Recurrence::rYearlyMonth,interv,r.count);
                 }
                 if ( r.by_month[0] != ICAL_RECURRENCE_ARRAY_MAX ) {
                     index = 0;
                     while((day = r.by_month[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
                         recur->addYearlyNum(day);
                     }
                 } else {
                     recur->addYearlyNum(incidence->dtStart().date().month());
                 }
             }
 
         }
       break;
   default:
       ;
       break;
   }
 }
 
 void ICalFormatImpl::readAlarm(icalcomponent *alarm,Incidence *incidence)
 {
   //kdDebug(5800) << "Read alarm for " << incidence->summary() << endl;
 
   Alarm* ialarm = incidence->newAlarm();
   ialarm->setRepeatCount(0);
   ialarm->setEnabled(true);
 
   // Determine the alarm's action type
   icalproperty *p = icalcomponent_get_first_property(alarm,ICAL_ACTION_PROPERTY);
   if ( !p ) {
     return;
   }
 
   icalproperty_action action = icalproperty_get_action(p);
   Alarm::Type type = Alarm::Display;
   switch ( action ) {
     case ICAL_ACTION_DISPLAY:   type = Alarm::Display;  break;
     case ICAL_ACTION_AUDIO:     type = Alarm::Audio;  break;
     case ICAL_ACTION_PROCEDURE: type = Alarm::Procedure;  break;
     case ICAL_ACTION_EMAIL:     type = Alarm::Email;  break;
     default:
         ;
       return;
   }
   ialarm->setType(type);
 
   p = icalcomponent_get_first_property(alarm,ICAL_ANY_PROPERTY);
   while (p) {
     icalproperty_kind kind = icalproperty_isa(p);
 
     switch (kind) {
       case ICAL_TRIGGER_PROPERTY: {
         icaltriggertype trigger = icalproperty_get_trigger(p);
         if (icaltime_is_null_time(trigger.time)) {
           if (icaldurationtype_is_null_duration(trigger.duration)) {
             kdDebug(5800) << "ICalFormatImpl::readAlarm(): Trigger has no time and no duration." << endl;
           } else {
             Duration duration = icaldurationtype_as_int( trigger.duration );
             icalparameter *param = icalproperty_get_first_parameter(p,ICAL_RELATED_PARAMETER);
             if (param && icalparameter_get_related(param) == ICAL_RELATED_END)
               ialarm->setEndOffset(duration);
             else
               ialarm->setStartOffset(duration);
           }
         } else {
           ialarm->setTime(readICalDateTime(trigger.time));
         }
         break;
       }
       case ICAL_DURATION_PROPERTY: {
         icaldurationtype duration = icalproperty_get_duration(p);
         ialarm->setSnoozeTime(icaldurationtype_as_int(duration)/60);
         break;
       }
       case ICAL_REPEAT_PROPERTY:
         ialarm->setRepeatCount(icalproperty_get_repeat(p));
         break;
 
       // Only in DISPLAY and EMAIL and PROCEDURE alarms
       case ICAL_DESCRIPTION_PROPERTY: {
         QString description = QString::fromUtf8(icalproperty_get_description(p));
         switch ( action ) {
           case ICAL_ACTION_DISPLAY:
             ialarm->setText( description );
             break;
           case ICAL_ACTION_PROCEDURE:
             ialarm->setProgramArguments( description );
             break;
           case ICAL_ACTION_EMAIL:
             ialarm->setMailText( description );
             break;
           default:
             break;
         }
         break;
       }
       // Only in EMAIL alarm
       case ICAL_SUMMARY_PROPERTY:
         ialarm->setMailSubject(QString::fromUtf8(icalproperty_get_summary(p)));
         break;
 
       // Only in EMAIL alarm
       case ICAL_ATTENDEE_PROPERTY: {
         QString email = QString::fromUtf8(icalproperty_get_attendee(p));
         QString name;
         icalparameter *param = icalproperty_get_first_parameter(p,ICAL_CN_PARAMETER);
         if (param) {
           name = QString::fromUtf8(icalparameter_get_cn(param));
         }
         ialarm->addMailAddress(Person(name, email));
         break;
       }
       // Only in AUDIO and EMAIL and PROCEDURE alarms
       case ICAL_ATTACH_PROPERTY: {
         icalattach *attach = icalproperty_get_attach(p);
         QString url = QFile::decodeName(icalattach_get_url(attach));
         switch ( action ) {
           case ICAL_ACTION_AUDIO:
             ialarm->setAudioFile( url );
             break;
           case ICAL_ACTION_PROCEDURE:
             ialarm->setProgramFile( url );
             break;
           case ICAL_ACTION_EMAIL:
             ialarm->addMailAttachment( url );
             break;
           default:
             break;
         }
         break;
       }
       default:
         break;
     }
 
     p = icalcomponent_get_next_property(alarm,ICAL_ANY_PROPERTY);
   }
 
   // custom properties
   readCustomProperties(alarm, ialarm);
 
   // TODO: check for consistency of alarm properties
 }
 
 icaltimetype ICalFormatImpl::writeICalDate(const QDate &date)
 {
   icaltimetype t;
 
   t.year = date.year();
   t.month = date.month();
   t.day = date.day();
 
   t.hour = 0;
   t.minute = 0;
   t.second = 0;
 
   t.is_date = 1;
 
   t.is_utc = 0;
 
   t.zone = 0;
 
   return t;
 }
 
 icaltimetype ICalFormatImpl::writeICalDateTime(const QDateTime &dt )
 {
   icaltimetype t;
   t.is_date = 0;
   t.zone = 0;
   QDateTime  datetime;
   if ( mParent->utc() ) {
       int offset =  KGlobal::locale()->localTimeOffset( dt );
       datetime =  dt.addSecs ( -offset*60);
       t.is_utc = 1;
   }
   else {
       datetime = dt;
       t.is_utc = 0;
 
   }
   t.year = datetime.date().year();
   t.month = datetime.date().month();
   t.day = datetime.date().day();
 
   t.hour = datetime.time().hour();
   t.minute = datetime.time().minute();
   t.second = datetime.time().second();
 
   //qDebug("*** time %s   localtime %s ",dt .toString().latin1()     ,datetime .toString().latin1() );
 
 //   if ( mParent->utc() ) {
 //      datetime =  KGlobal::locale()->localTime( dt );
 //      qDebug("*** time %s   localtime %s ",dt .toString().latin1()     ,datetime .toString().latin1() );
 //     if (mParent->timeZoneId().isEmpty())
 //       t = icaltime_as_utc(t, 0);
 //     else
 //       t = icaltime_as_utc(t,mParent->timeZoneId().local8Bit());
 //   }
 
   return t;
 }
 
 QDateTime ICalFormatImpl::readICalDateTime(icaltimetype t)
 {
     QDateTime dt (QDate(t.year,t.month,t.day),
                   QTime(t.hour,t.minute,t.second) );
 
   if (t.is_utc) {
       int offset = KGlobal::locale()->localTimeOffset( dt );
        dt = dt.addSecs ( offset*60);
   }
 
   return dt;
 }
 
 QDate ICalFormatImpl::readICalDate(icaltimetype t)
 {
   return QDate(t.year,t.month,t.day);
 }
 
 icaldurationtype ICalFormatImpl::writeICalDuration(int seconds)
 {
   icaldurationtype d;
 
   d.weeks    = seconds   % gSecondsPerWeek;
   seconds   -= d.weeks   * gSecondsPerWeek;
   d.days     = seconds   % gSecondsPerDay;
   seconds   -= d.days    * gSecondsPerDay;
   d.hours    = seconds   % gSecondsPerHour;
   seconds   -= d.hours   * gSecondsPerHour;
   d.minutes  = seconds   % gSecondsPerMinute;
   seconds   -= d.minutes * gSecondsPerMinute;
   d.seconds  = seconds;
   d.is_neg = 0;
 
   return d;
 }
 
 int ICalFormatImpl::readICalDuration(icaldurationtype d)
 {
   int result = 0;
 
   result += d.weeks   * gSecondsPerWeek;
   result += d.days    * gSecondsPerDay;
   result += d.hours   * gSecondsPerHour;
   result += d.minutes * gSecondsPerMinute;
   result += d.seconds;