many phone and sync fixes

14 files changed, 227 insertions, 76 deletions

diff --git a/gammu/emb/common/service/gsmcal.c b/gammu/emb/common/service/gsmcal.c
index 0375fee..7310755 100644
--- a/gammu/emb/common/service/gsmcal.c
+++ b/gammu/emb/common/service/gsmcal.c
@@ -1,521 +1,527 @@
 /* (c) 2002-2003 by Marcin Wiacek */
 
 #include <string.h>
 
 #include "gsmcal.h"
 #include "gsmmisc.h"
 #include "../misc/coding/coding.h"
 
 bool IsCalendarNoteFromThePast(GSM_CalendarEntry *note)
 {
 	bool 		Past = true;
 	int		i;
 	GSM_DateTime	DT;
 
 	GSM_GetCurrentDateTime (&DT);
 	for (i = 0; i < note->EntriesNum; i++) {
 		switch (note->Entries[i].EntryType) {
 		case CAL_RECURRANCE:
 			Past = false;
 			break;
 		case CAL_START_DATETIME :
 			if (note->Entries[i].Date.Year > DT.Year) Past = false;
 			if (note->Entries[i].Date.Year == DT.Year &&
 			    note->Entries[i].Date.Month > DT.Month) Past = false;
 			if (note->Entries[i].Date.Year == DT.Year &&
 			    note->Entries[i].Date.Month == DT.Month &&
 			    note->Entries[i].Date.Day > DT.Day) Past = false;
 			break;
 		default:
 			break;
 		}
 		if (!Past) break;
 	}
 	switch (note->Type) {
 		case GSM_CAL_BIRTHDAY:
 			Past = false;
 			break;
 		default:
 			break;
 	}
 	return Past;
 }
 
 void GSM_CalendarFindDefaultTextTimeAlarmPhoneRecurrance(GSM_CalendarEntry *entry, int *Text, int *Time, int *Alarm, int *Phone, int *Recurrance, int *EndTime, int *Location)
 {
 	int i;
 
 	*Text		= -1;
 	*Time		= -1;
 	*Alarm		= -1;
 	*Phone		= -1;
 	*Recurrance	= -1;
 	*EndTime	= -1;
 	*Location	= -1;
 	for (i = 0; i < entry->EntriesNum; i++) {
 		switch (entry->Entries[i].EntryType) {
 		case CAL_START_DATETIME :
 			if (*Time == -1) *Time = i;
 			break;
 		case CAL_END_DATETIME :
 			if (*EndTime == -1) *EndTime = i;
 			break;
 		case CAL_ALARM_DATETIME :
 		case CAL_SILENT_ALARM_DATETIME:
 			if (*Alarm == -1) *Alarm = i;
 			break;
 		case CAL_RECURRANCE:
 			if (*Recurrance == -1) *Recurrance = i;
 			break;
 		case CAL_TEXT:
 		    *Text = i;
 			break;
 		case CAL_DESCRIPTION:
 			if (*Text == -1) *Text = i;
 			break;
 		case CAL_PHONE:
 			if (*Phone == -1) *Phone = i;
 			break;
 		case CAL_LOCATION:
 			if (*Location == -1) *Location = i;
 			break;
 		default:
 			break;
 		}
 	}
 }
 
 GSM_Error GSM_EncodeVCALENDAR(char *Buffer, int *Length, GSM_CalendarEntry *note, bool header, GSM_VCalendarVersion Version)
 {
  	int 	Text, Time, Alarm, Phone, Recurrance, EndTime, Location;
 	char 	buffer[2000];
 
 	GSM_CalendarFindDefaultTextTimeAlarmPhoneRecurrance(note, &Text, &Time, &Alarm, &Phone, &Recurrance, &EndTime, &Location);
 
 	if (header) {
 		*Length+=sprintf(Buffer, "BEGIN:VCALENDAR%c%c",13,10);
 		*Length+=sprintf(Buffer+(*Length), "VERSION:1.0%c%c",13,10);
 	}
 	*Length+=sprintf(Buffer+(*Length), "BEGIN:VEVENT%c%c",13,10);
 
 	if (Version == Nokia_VCalendar) {
 		*Length+=sprintf(Buffer+(*Length), "CATEGORIES:");
 		switch (note->Type) {
 		case GSM_CAL_REMINDER:
 			*Length+=sprintf(Buffer+(*Length), "Reminder%c%c",13,10);
 			break;
 		case GSM_CAL_MEMO:
 			*Length+=sprintf(Buffer+(*Length), "Miscellaneous%c%c",13,10);
 			break;
 		case GSM_CAL_CALL:
 			*Length+=sprintf(Buffer+(*Length), "Phone Call%c%c",13,10);
 			break;
 		case GSM_CAL_BIRTHDAY:
-			*Length+=sprintf(Buffer+(*Length), "Special Occasion%c%c",13,10);
+			*Length+=sprintf(Buffer+(*Length), "Birthday%c%c",13,10);
 			break;
 		case GSM_CAL_MEETING:
 		default:
 			*Length+=sprintf(Buffer+(*Length), "MeetingDEF%c%c",13,10);
 			break;
 		}
 		if (note->Type == GSM_CAL_CALL) {
 			buffer[0] = 0;
 			buffer[1] = 0;
 		 	if (Phone != -1) CopyUnicodeString(buffer,note->Entries[Phone].Text);
 			if (Text != -1)  {
 				if (Phone != -1) EncodeUnicode(buffer+UnicodeLength(buffer)*2," ",1);
 				CopyUnicodeString(buffer+UnicodeLength(buffer)*2,note->Entries[Text].Text);
 			}
 			SaveVCALText(Buffer, Length, buffer, "SUMMARY");
 		} else {
 			SaveVCALText(Buffer, Length, note->Entries[Text].Text, "SUMMARY");
 		}
 		if (note->Type == GSM_CAL_MEETING && Location != -1) {
 			SaveVCALText(Buffer, Length, note->Entries[Location].Text, "LOCATION");
 		}
 	
 		if (Time == -1) return ERR_UNKNOWN;
 		SaveVCALDateTime(Buffer, Length, &note->Entries[Time].Date, "DTSTART");
 
 		if (EndTime != -1) {
 			SaveVCALDateTime(Buffer, Length, &note->Entries[EndTime].Date, "DTEND");
 		}
 
 		if (Alarm != -1) {
 			if (note->Entries[Alarm].EntryType == CAL_SILENT_ALARM_DATETIME) {
 				SaveVCALDateTime(Buffer, Length, &note->Entries[Alarm].Date, "DALARM");
 			} else {
 				SaveVCALDateTime(Buffer, Length, &note->Entries[Alarm].Date, "DALARM");
 			}
 		}
 
 		/* Birthday is known to be recurranced */
-		if (Recurrance != -1 && note->Type != GSM_CAL_BIRTHDAY) {
+		if (Recurrance != -1 ) {
 			switch(note->Entries[Recurrance].Number/24) {
 				case 1	 : *Length+=sprintf(Buffer+(*Length), "RRULE:D1 #0%c%c",13,10);	 break;
 				case 7	 : *Length+=sprintf(Buffer+(*Length), "RRULE:W1 #0%c%c",13,10);	 break;
 				case 14	 : *Length+=sprintf(Buffer+(*Length), "RRULE:W2 #0%c%c",13,10);	 break;
-				case 365 : *Length+=sprintf(Buffer+(*Length), "RRULE:YD1 #0%c%c",13,10); break;
+				case 365 : *Length+=sprintf(Buffer+(*Length), "RRULE:YM1 #0%c%c",13,10); break;
 			}
 		}
 	} else if (Version == Siemens_VCalendar) {
 		*Length+=sprintf(Buffer+(*Length), "CATEGORIES:");
 		switch (note->Type) {
 		case GSM_CAL_MEETING:
 			*Length+=sprintf(Buffer+(*Length), "Meeting%c%c",13,10);
 			break;
 		case GSM_CAL_CALL:
 			*Length+=sprintf(Buffer+(*Length), "Phone Call%c%c",13,10);
 			break;
 		case GSM_CAL_BIRTHDAY:
-			*Length+=sprintf(Buffer+(*Length), "Anniversary%c%c",13,10);
+			*Length+=sprintf(Buffer+(*Length), "Birthday%c%c",13,10);
 			break;
 		case GSM_CAL_MEMO:
 		default:
 			*Length+=sprintf(Buffer+(*Length), "Miscellaneous%c%c",13,10);
 			break;
 		}
 		
 		if (Time == -1) return ERR_UNKNOWN;
 		SaveVCALDateTime(Buffer, Length, &note->Entries[Time].Date, "DTSTART");
 
 		if (Alarm != -1) {
 			SaveVCALDateTime(Buffer, Length, &note->Entries[Alarm].Date, "DALARM");
 		}
 
 		if (Recurrance != -1) {
 			switch(note->Entries[Recurrance].Number/24) {
 				case 1	 : *Length+=sprintf(Buffer+(*Length), "RRULE:D1%c%c",13,10);	break;
 				case 7	 : *Length+=sprintf(Buffer+(*Length), "RRULE:D7%c%c",13,10);	break;
 				case 30	 : *Length+=sprintf(Buffer+(*Length), "RRULE:MD1%c%c",13,10);	break;
-				case 365 : *Length+=sprintf(Buffer+(*Length), "RRULE:YD1%c%c",13,10);	break;
+				case 365 : *Length+=sprintf(Buffer+(*Length), "RRULE:YM1%c%c",13,10);	break;
 			}
 		}
 	
 		if (note->Type == GSM_CAL_CALL) {
 			buffer[0] = 0;
 			buffer[1] = 0;
 		 	if (Phone != -1) CopyUnicodeString(buffer,note->Entries[Phone].Text);
 			if (Text != -1)  {
 				if (Phone != -1) EncodeUnicode(buffer+UnicodeLength(buffer)*2," ",1);
 				CopyUnicodeString(buffer+UnicodeLength(buffer)*2,note->Entries[Text].Text);
 			}
 			SaveVCALText(Buffer, Length, buffer, "SUMMARY");
 		} else {
 			SaveVCALText(Buffer, Length, note->Entries[Text].Text, "SUMMARY");
 		}
 	} else if (Version == SonyEricsson_VCalendar) {
 		*Length+=sprintf(Buffer+(*Length), "CATEGORIES:");
 		switch (note->Type) {
 		case GSM_CAL_MEETING:
 			*Length+=sprintf(Buffer+(*Length), "Meeting%c%c",13,10);
 			break;
 		case GSM_CAL_REMINDER:
 			*Length+=sprintf(Buffer+(*Length), "Date%c%c",13,10);
 			break;
 		case GSM_CAL_TRAVEL:
 			*Length+=sprintf(Buffer+(*Length), "Travel%c%c",13,10);
 			break;
 		case GSM_CAL_VACATION:
 			*Length+=sprintf(Buffer+(*Length), "Vacation%c%c",13,10);
 			break;
 		case GSM_CAL_BIRTHDAY:
-			*Length+=sprintf(Buffer+(*Length), "Anninversary%c%c",13,10);
+			*Length+=sprintf(Buffer+(*Length), "Birthday%c%c",13,10);
 			break;
 		case GSM_CAL_MEMO:
 		default:
 			*Length+=sprintf(Buffer+(*Length), "Miscellaneous%c%c",13,10);
 			break;
 		}
 		
 		if (Time == -1) return ERR_UNKNOWN;
 		SaveVCALDateTime(Buffer, Length, &note->Entries[Time].Date, "DTSTART");
 
 		if (EndTime != -1) {
 			SaveVCALDateTime(Buffer, Length, &note->Entries[EndTime].Date, "DTEND");
 		}
 
 		if (Alarm != -1) {
 			SaveVCALDateTime(Buffer, Length, &note->Entries[Alarm].Date, "AALARM");
 		}
 	
 		SaveVCALText(Buffer, Length, note->Entries[Text].Text, "SUMMARY");
 
 		if (Location != -1) {
 			SaveVCALText(Buffer, Length, note->Entries[Location].Text, "LOCATION");
 		}
 	}
 	
 	*Length+=sprintf(Buffer+(*Length), "X-PILOTID:%d%c%c",note->Location,13,10);
 	*Length+=sprintf(Buffer+(*Length), "END:VEVENT%c%c",13,10);
 	if (header) *Length+=sprintf(Buffer+(*Length), "END:VCALENDAR%c%c",13,10);
 
 	return ERR_NONE;
 }
 
 void GSM_ToDoFindDefaultTextTimeAlarmCompleted(GSM_ToDoEntry *entry, int *Text, int *Alarm, int *Completed, int *EndTime, int *Phone)
 {
 	int i;
 
 	*Text		= -1;
 	*EndTime	= -1;
 	*Alarm		= -1;
 	*Completed	= -1;
 	*Phone		= -1;
 	for (i = 0; i < entry->EntriesNum; i++) {
 		switch (entry->Entries[i].EntryType) {
 		case TODO_END_DATETIME :
 			if (*EndTime == -1) *EndTime = i;
 			break;
 		case TODO_ALARM_DATETIME :
 		case TODO_SILENT_ALARM_DATETIME:
 			if (*Alarm == -1) *Alarm = i;
 			break;
 		case TODO_TEXT:
 			if (*Text == -1) *Text = i;
 			break;
 		case TODO_COMPLETED:
 			if (*Completed == -1) *Completed = i;
 			break;
 		case TODO_PHONE:
 			if (*Phone == -1) *Phone = i;
 			break;
 		default:
 			break;
 		}
 	}
 }
 
 GSM_Error GSM_EncodeVTODO(char *Buffer, int *Length, GSM_ToDoEntry *note, bool header, GSM_VToDoVersion Version)
 {
  	int Text, Alarm, Completed, EndTime, Phone;
 
 	GSM_ToDoFindDefaultTextTimeAlarmCompleted(note, &Text, &Alarm, &Completed, &EndTime, &Phone);
 
 	if (header) {
 		*Length+=sprintf(Buffer, "BEGIN:VCALENDAR%c%c",13,10);
 		*Length+=sprintf(Buffer+(*Length), "VERSION:1.0%c%c",13,10);
 	}
 
 	*Length+=sprintf(Buffer+(*Length), "BEGIN:VTODO%c%c",13,10);
 
 	if (Version == Nokia_VToDo) {
 		if (Text == -1) return ERR_UNKNOWN;
 		SaveVCALText(Buffer, Length, note->Entries[Text].Text, "SUMMARY");
 
 		if (Completed == -1) {
 			*Length+=sprintf(Buffer+(*Length), "PERCENT-COMPLETE:0%c%c",13,10);
 		} else {
 			*Length+=sprintf(Buffer+(*Length), "PERCENT-COMPLETE:100%c%c",13,10);
 		}
 	
 		switch (note->Priority) {
 			case GSM_Priority_Low	: *Length+=sprintf(Buffer+(*Length), "PRIORITY:5%c%c",13,10); break;
 			case GSM_Priority_Medium: *Length+=sprintf(Buffer+(*Length), "PRIORITY:3%c%c",13,10); break;
 			case GSM_Priority_High	: *Length+=sprintf(Buffer+(*Length), "PRIORITY:1%c%c",13,10); break;
 		}
 
 		if (EndTime != -1) {
 			SaveVCALDateTime(Buffer, Length, &note->Entries[EndTime].Date, "DUE");
 		}
 
 		if (Alarm != -1) {
 			if (note->Entries[Alarm].EntryType == CAL_SILENT_ALARM_DATETIME) {
 				SaveVCALDateTime(Buffer, Length, &note->Entries[Alarm].Date, "DALARM");
 			} else {
 				SaveVCALDateTime(Buffer, Length, &note->Entries[Alarm].Date, "AALARM");
 			}
 		}
 	} else if (Version == SonyEricsson_VToDo) {
 		if (Text == -1) return ERR_UNKNOWN;
 		SaveVCALText(Buffer, Length, note->Entries[Text].Text, "SUMMARY");
 
 		if (Completed == -1) {
 			*Length+=sprintf(Buffer+(*Length), "PERCENT-COMPLETE:0%c%c",13,10);
 		} else {
 			*Length+=sprintf(Buffer+(*Length), "PERCENT-COMPLETE:100%c%c",13,10);
 		}
 	
 		switch (note->Priority) {
 			case GSM_Priority_Low	: *Length+=sprintf(Buffer+(*Length), "PRIORITY:5%c%c",13,10); break;
 			case GSM_Priority_Medium: *Length+=sprintf(Buffer+(*Length), "PRIORITY:3%c%c",13,10); break;
 			case GSM_Priority_High	: *Length+=sprintf(Buffer+(*Length), "PRIORITY:1%c%c",13,10); break;
 		}
 
 		if (Alarm != -1) {
 			SaveVCALDateTime(Buffer, Length, &note->Entries[Alarm].Date, "AALARM");
 		}		
 	}
 
 	*Length+=sprintf(Buffer+(*Length), "X-PILOTID:%d%c%c",note->Location,13,10);
 	*Length+=sprintf(Buffer+(*Length), "END:VTODO%c%c",13,10);
 
 	if (header) {
 		*Length+=sprintf(Buffer+(*Length), "END:VCALENDAR%c%c",13,10);
 	}
 	return ERR_NONE;
 }
 
 GSM_Error GSM_DecodeVCALENDAR_VTODO(unsigned char *Buffer, int *Pos, GSM_CalendarEntry *Calendar, GSM_ToDoEntry *ToDo, GSM_VCalendarVersion CalVer, GSM_VToDoVersion ToDoVer)
 {
 	unsigned char 	Line[2000],Buff[2000];
 	int		Level = 0;
 
 	Calendar->EntriesNum 	= 0;
 	ToDo->EntriesNum 	= 0;
 
 	while (1) {
 		MyGetLine(Buffer, Pos, Line, strlen(Buffer));
 		if (strlen(Line) == 0) break;
 		switch (Level) {
 		case 0:
 			if (strstr(Line,"BEGIN:VEVENT")) {
 				Calendar->Type 	= GSM_CAL_MEMO;
 				Level 		= 1;
 			}
 			if (strstr(Line,"BEGIN:VTODO")) {
 				ToDo->Priority 	= GSM_Priority_Medium;
 				Level 		= 2;
 			}
 			break;
 		case 1: /* Calendar note */
 			if (strstr(Line,"END:VEVENT")) {
 				if (Calendar->EntriesNum == 0) return ERR_EMPTY;
 				return ERR_NONE;
 			}	
             Calendar->Type = GSM_CAL_MEETING;
 			if (strstr(Line,"CATEGORIES:Reminder")) 	Calendar->Type = GSM_CAL_REMINDER;
 			if (strstr(Line,"CATEGORIES:Date"))	 	Calendar->Type = GSM_CAL_REMINDER;//SE
 			if (strstr(Line,"CATEGORIES:Travel"))	 	Calendar->Type = GSM_CAL_TRAVEL;  //SE
 			if (strstr(Line,"CATEGORIES:Vacation"))	 	Calendar->Type = GSM_CAL_VACATION;//SE
 			if (strstr(Line,"CATEGORIES:Miscellaneous")) 	Calendar->Type = GSM_CAL_MEMO;
 			if (strstr(Line,"CATEGORIES:Phone Call")) 	Calendar->Type = GSM_CAL_CALL;
-			if (strstr(Line,"CATEGORIES:Special Occasion")) Calendar->Type = GSM_CAL_BIRTHDAY;
 			if (strstr(Line,"CATEGORIES:Anniversary")) 	Calendar->Type = GSM_CAL_BIRTHDAY;
+			if (strstr(Line,"CATEGORIES:Birthday")) 	Calendar->Type = GSM_CAL_BIRTHDAY;
 			if (strstr(Line,"CATEGORIES:Meeting")) 		Calendar->Type = GSM_CAL_MEETING;
 			if (strstr(Line,"CATEGORIES:Appointment")) 	Calendar->Type = GSM_CAL_MEETING;
 			if (strstr(Line,"RRULE:D1")) {
 				Calendar->Entries[Calendar->EntriesNum].EntryType = CAL_RECURRANCE;
 				Calendar->Entries[Calendar->EntriesNum].Number    = 1*24;
 				Calendar->EntriesNum++;
 			}
 			if ((strstr(Line,"RRULE:W1")) || (strstr(Line,"RRULE:D7"))) {
 				Calendar->Entries[Calendar->EntriesNum].EntryType = CAL_RECURRANCE;
 				Calendar->Entries[Calendar->EntriesNum].Number    = 7*24;
 				Calendar->EntriesNum++;
 			}
 			if (strstr(Line,"RRULE:W2")) {
 				Calendar->Entries[Calendar->EntriesNum].EntryType = CAL_RECURRANCE;
 				Calendar->Entries[Calendar->EntriesNum].Number    = 14*24;
 				Calendar->EntriesNum++;
 			}
 			if (strstr(Line,"RRULE:MD1")) {
 				Calendar->Entries[Calendar->EntriesNum].EntryType = CAL_RECURRANCE;
 				Calendar->Entries[Calendar->EntriesNum].Number    = 30*24;
 				Calendar->EntriesNum++;
 			}
 			if (strstr(Line,"RRULE:YD1")) {
 				Calendar->Entries[Calendar->EntriesNum].EntryType = CAL_RECURRANCE;
 				Calendar->Entries[Calendar->EntriesNum].Number    = 365*24;
 				Calendar->EntriesNum++;
 			}
             // LR 
+			if (strstr(Line,"RRULE:YM1")) {
+				Calendar->Entries[Calendar->EntriesNum].EntryType = CAL_RECURRANCE;
+				Calendar->Entries[Calendar->EntriesNum].Number    = 365*24;
+				Calendar->EntriesNum++;
+			}
+            // LR 
 			if ((ReadVCALText(Line, "SUMMARY", Buff)) ) {
 				Calendar->Entries[Calendar->EntriesNum].EntryType = CAL_TEXT;
 				CopyUnicodeString(Calendar->Entries[Calendar->EntriesNum].Text,Buff);
 				Calendar->EntriesNum++;
 			}
 			if (ReadVCALText(Line, "DESCRIPTION", Buff)) {
 				Calendar->Entries[Calendar->EntriesNum].EntryType = CAL_DESCRIPTION;
 				CopyUnicodeString(Calendar->Entries[Calendar->EntriesNum].Text,Buff);
 				Calendar->EntriesNum++;
 			}
 			if (ReadVCALText(Line, "LOCATION", Buff)) {
 				Calendar->Entries[Calendar->EntriesNum].EntryType = CAL_LOCATION;
 				CopyUnicodeString(Calendar->Entries[Calendar->EntriesNum].Text,Buff);
 				Calendar->EntriesNum++;
 			}
 			if (ReadVCALText(Line, "DTSTART", Buff)) {
 				Calendar->Entries[Calendar->EntriesNum].EntryType = CAL_START_DATETIME;
 				ReadVCALDateTime(DecodeUnicodeString(Buff), &Calendar->Entries[Calendar->EntriesNum].Date);
 				Calendar->EntriesNum++;
 			}
 			if (ReadVCALText(Line, "DTEND", Buff)) {
 				Calendar->Entries[Calendar->EntriesNum].EntryType = CAL_END_DATETIME;
 				ReadVCALDateTime(DecodeUnicodeString(Buff), &Calendar->Entries[Calendar->EntriesNum].Date);
 				Calendar->EntriesNum++;
 			}
 			if (ReadVCALText(Line, "DALARM", Buff)) {
 				Calendar->Entries[Calendar->EntriesNum].EntryType = CAL_SILENT_ALARM_DATETIME;
 				ReadVCALDateTime(DecodeUnicodeString(Buff), &Calendar->Entries[Calendar->EntriesNum].Date);
 				Calendar->EntriesNum++;
 			}
 			if (ReadVCALText(Line, "AALARM", Buff)) {
 				Calendar->Entries[Calendar->EntriesNum].EntryType = CAL_ALARM_DATETIME;
 				ReadVCALDateTime(DecodeUnicodeString(Buff), &Calendar->Entries[Calendar->EntriesNum].Date);
 				Calendar->EntriesNum++;
 			}
 			break;
 		case 2: /* ToDo note */
 			if (strstr(Line,"END:VTODO")) {
 				if (ToDo->EntriesNum == 0) return ERR_EMPTY;
 				return ERR_NONE;
 			}
 			if (ReadVCALText(Line, "DUE", Buff)) {
 				ToDo->Entries[ToDo->EntriesNum].EntryType = TODO_END_DATETIME;
 				ReadVCALDateTime(DecodeUnicodeString(Buff), &ToDo->Entries[ToDo->EntriesNum].Date);
 				ToDo->EntriesNum++;
 			}
 			if (ReadVCALText(Line, "DALARM", Buff)) {
 				ToDo->Entries[ToDo->EntriesNum].EntryType = TODO_SILENT_ALARM_DATETIME;
 				ReadVCALDateTime(DecodeUnicodeString(Buff), &ToDo->Entries[ToDo->EntriesNum].Date);
 				ToDo->EntriesNum++;
 			}
 			if (ReadVCALText(Line, "AALARM", Buff)) {
 				ToDo->Entries[ToDo->EntriesNum].EntryType = TODO_ALARM_DATETIME;
 				ReadVCALDateTime(DecodeUnicodeString(Buff), &ToDo->Entries[ToDo->EntriesNum].Date);
 				ToDo->EntriesNum++;
 			}
 			if (ReadVCALText(Line, "SUMMARY", Buff)) {
 				ToDo->Entries[ToDo->EntriesNum].EntryType = TODO_TEXT;
 				CopyUnicodeString(ToDo->Entries[ToDo->EntriesNum].Text,Buff);
 				ToDo->EntriesNum++;
 			}
 			if (ReadVCALText(Line, "PRIORITY", Buff)) {
 				if (ToDoVer == SonyEricsson_VToDo) {
 					ToDo->Priority = GSM_Priority_Medium;
 					if (atoi(DecodeUnicodeString(Buff))>3) ToDo->Priority = GSM_Priority_Low;
 					if (atoi(DecodeUnicodeString(Buff))<3) ToDo->Priority = GSM_Priority_High;
 					dbgprintf("atoi is %i %s\n",atoi(DecodeUnicodeString(Buff)),DecodeUnicodeString(Buff));
 				} else if (ToDoVer == Nokia_VToDo) {
 					ToDo->Priority = GSM_Priority_Medium;
 					if (atoi(DecodeUnicodeString(Buff))>3) ToDo->Priority = GSM_Priority_Low;
 					if (atoi(DecodeUnicodeString(Buff))<3) ToDo->Priority = GSM_Priority_High;
 				}
 			}
 			if (strstr(Line,"PERCENT-COMPLETE:100")) {
 				ToDo->Entries[ToDo->EntriesNum].EntryType = TODO_COMPLETED;
 				ToDo->Entries[ToDo->EntriesNum].Number	  = 1;
 				ToDo->EntriesNum++;
 			}
 			break;
 		}
 	}
 
 	if (Calendar->EntriesNum == 0 && ToDo->EntriesNum == 0) return ERR_EMPTY;
 	return ERR_NONE;
 }
 
 GSM_Error GSM_EncodeVNTFile(unsigned char *Buffer, int *Length, GSM_NoteEntry *Note)
 {
 	*Length+=sprintf(Buffer+(*Length), "BEGIN:VNOTE%c%c",13,10);
 	*Length+=sprintf(Buffer+(*Length), "VERSION:1.1%c%c",13,10);
 	SaveVCALText(Buffer, Length, Note->Text, "BODY");
 	*Length+=sprintf(Buffer+(*Length), "END:VNOTE%c%c",13,10);
 
 	return ERR_NONE;
 }
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/kabc/addressee.cpp b/kabc/addressee.cpp
index 2564894..40877ef 100644
--- a/kabc/addressee.cpp
+++ b/kabc/addressee.cpp
@@ -57,512 +57,513 @@ struct Addressee::AddresseeData : public KShared
   QString prefix;
   QString suffix;
   QString nickName;
   QDateTime birthday;
   QString mailer;
   TimeZone timeZone;
   Geo geo;
   QString title;
   QString role;
   QString organization;
   QString note;
   QString productId;
   QDateTime revision;
   QString sortString;
   QString externalUID;
   QString originalExternalUID;
   KURL url;
   Secrecy secrecy;
   Picture logo;
   Picture photo;
   Sound sound;
   Agent agent;
   QString mExternalId;
   PhoneNumber::List phoneNumbers;
   Address::List addresses;
   Key::List keys;
   QStringList emails;
   QStringList categories;
   QStringList custom;
   int mTempSyncStat;
   Resource *resource;
 
   bool empty    :1;
   bool changed  :1;
   bool tagged   :1;
 };
 
 Addressee::Addressee()
 {
   mData = new AddresseeData;
   mData->empty = true;
   mData->changed = false;
   mData->resource = 0;
   mData->mExternalId = ":";
   mData->revision = QDateTime ( QDate( 2003,1,1));
   mData->mTempSyncStat =  SYNC_TEMPSTATE_INITIAL;
 }
 
 Addressee::~Addressee()
 {
 }
 
 Addressee::Addressee( const Addressee &a )
 {
   mData = a.mData;
 }
 
 Addressee &Addressee::operator=( const Addressee &a )
 {
   mData = a.mData;
   return (*this);
 }
 
 Addressee Addressee::copy()
 {
   Addressee a;
   *(a.mData) = *mData;
   return a;
 }
 
 void Addressee::detach()
 {
   if ( mData.count() == 1 ) return;
   *this = copy();
 }
 
 bool Addressee::operator==( const Addressee &a ) const
 {
   if ( uid() != a.uid() ) return false;
   if ( mData->name != a.mData->name ) return false;
   if ( mData->formattedName != a.mData->formattedName ) return false;
   if ( mData->familyName != a.mData->familyName ) return false;
   if ( mData->givenName != a.mData->givenName ) return false;
   if ( mData->additionalName != a.mData->additionalName ) return false;
   if ( mData->prefix != a.mData->prefix ) return false;
   if ( mData->suffix != a.mData->suffix ) return false;
   if ( mData->nickName != a.mData->nickName ) return false;
   if ( mData->birthday != a.mData->birthday ) return false;
   if ( mData->mailer != a.mData->mailer ) return false;
   if ( mData->timeZone != a.mData->timeZone ) return false;
   if ( mData->geo != a.mData->geo ) return false;
   if ( mData->title != a.mData->title ) return false;
   if ( mData->role != a.mData->role ) return false;
   if ( mData->organization != a.mData->organization ) return false;
   if ( mData->note != a.mData->note ) return false;
   if ( mData->productId != a.mData->productId ) return false;
   //if ( mData->revision != a.mData->revision ) return false;
   if ( mData->sortString != a.mData->sortString ) return false;
   if ( mData->secrecy != a.mData->secrecy ) return false;
   if ( mData->logo != a.mData->logo ) return false;
   if ( mData->photo != a.mData->photo ) return false;
   if ( mData->sound != a.mData->sound ) return false;
   if ( mData->agent != a.mData->agent ) return false;
   if ( ( mData->url.isValid() || a.mData->url.isValid() ) &&
        ( mData->url != a.mData->url ) ) return false;
   if ( mData->phoneNumbers != a.mData->phoneNumbers ) return false;
   if ( mData->addresses != a.mData->addresses ) return false;
   if ( mData->keys != a.mData->keys ) return false;
   if ( mData->emails != a.mData->emails ) return false;
   if ( mData->categories != a.mData->categories ) return false;
   if ( mData->custom != a.mData->custom ) return false;
 
   return true;
 }
 
 bool Addressee::operator!=( const Addressee &a ) const
 {
   return !( a == *this );
 }
 
 bool Addressee::isEmpty() const
 {
   return mData->empty;
 }
 ulong  Addressee::getCsum4List( const QStringList &  attList)
 {
     int max = attList.count();
     ulong cSum = 0;
     int j,k,i;
     int add;
     for ( i = 0; i < max ; ++i ) {
         QString s = attList[i];
         if ( ! s.isEmpty() ){
             j = s.length();
             for ( k = 0; k < j; ++k ) {
                 int mul = k +1;
                 add = s[k].unicode ();
                 if ( k < 16 )
                     mul = mul * mul;
                 int ii = i+1;
                 add = add * mul *ii*ii*ii;
                 cSum += add;
             }
         }
             
     }
     //QString dump = attList.join(",");
     //qDebug("csum: %d %s", cSum,dump.latin1()); 
     
     return cSum;
 
 }
 void Addressee::computeCsum(const QString &dev)
 {
     QStringList l;
     if ( !mData->name.isEmpty() ) l.append(mData->name);
     if ( !mData->formattedName.isEmpty() ) l.append(mData->formattedName  );
     if ( !mData->familyName.isEmpty()  ) l.append( mData->familyName );
     if ( !mData->givenName.isEmpty() ) l.append(mData->givenName  );
     if ( !mData->additionalName  ) l.append( mData->additionalName );
     if ( !mData->prefix.isEmpty()  ) l.append( mData->prefix );
     if ( !mData->suffix.isEmpty()  ) l.append( mData->suffix );
     if ( !mData->nickName.isEmpty()  ) l.append( mData->nickName );
     if ( mData->birthday.isValid()  ) l.append( mData->birthday.toString() );
     if ( !mData->mailer.isEmpty() ) l.append( mData->mailer );
     if ( mData->timeZone.isValid() ) l.append( mData->timeZone.asString() );
     if ( mData->geo.isValid() ) l.append( mData->geo.asString() );
     if ( !mData->title .isEmpty() ) l.append( mData->title );
     if ( !mData->role.isEmpty() ) l.append( mData->role );
     if ( !mData->organization.isEmpty() ) l.append( mData->organization ); 
     if ( !mData->note.isEmpty() ) l.append( mData->note ); 
     if ( !mData->productId.isEmpty() ) l.append(mData->productId ); 
     if ( !mData->sortString.isEmpty() ) l.append( mData->sortString ); 
     if ( mData->secrecy.isValid() ) l.append( mData->secrecy.asString()); 
     // if ( !mData->logo.isEmpty() ) l.append(  ); 
     //if ( !mData->photo.isEmpty() ) l.append(  );
     //if ( !mData->sound.isEmpty() ) l.append(  );
     //if ( !mData->agent.isEmpty() ) l.append(  ); 
     if (  mData->url.isValid() )
         if ( ! mData->url.path().isEmpty()) l.append( mData->url.path()  ); 
     KABC::PhoneNumber::List phoneNumbers;
     KABC::PhoneNumber::List::Iterator phoneIter;
 
     QStringList t;
     for ( phoneIter = mData->phoneNumbers.begin(); phoneIter != mData->phoneNumbers.end();
           ++phoneIter )
         t.append( ( *phoneIter ).number()+QString::number( ( *phoneIter ).type() ) );
     t.sort();
     uint iii;
     for ( iii = 0; iii < t.count(); ++iii)
         l.append( t[iii]  );
     t = mData->emails;
     t.sort();
     for ( iii = 0; iii < t.count(); ++iii)
         l.append( t[iii]  );
     t = mData->categories;
     t.sort();
     for ( iii = 0; iii < t.count(); ++iii)
         l.append( t[iii]  );
     t = mData->custom;
     t.sort();
     for ( iii = 0; iii < t.count(); ++iii)
         l.append( t[iii]  );
     KABC::Address::List::Iterator addressIter;
     for ( addressIter = mData->addresses.begin(); addressIter != mData->addresses.end();
           ++addressIter ) {
         t = (*addressIter).asList();
         t.sort();
         for ( iii = 0; iii < t.count(); ++iii)
             l.append( t[iii]  );
     }
     uint cs = getCsum4List(l);
     // qDebug("CSUM computed %d %s %s", cs,QString::number (cs ).latin1(), uid().latin1() );
     setCsum( dev, QString::number (cs ));
 }
 
 void Addressee::mergeContact( const Addressee& ad , bool isSubSet) // = false)
 {
 
     detach();
     if ( mData->name.isEmpty() ) mData->name = ad.mData->name;
     if ( mData->formattedName.isEmpty() ) mData->formattedName  = ad.mData->formattedName;
     if ( mData->familyName.isEmpty()  )  mData->familyName  = ad.mData->familyName;
     if ( mData->givenName.isEmpty() ) mData->givenName   = ad.mData->givenName ;
     if ( mData->additionalName )  mData->additionalName  = ad.mData->additionalName;
     if ( mData->prefix.isEmpty() )  mData->prefix  = ad.mData->prefix;
     if ( mData->suffix.isEmpty() )  mData->suffix  = ad.mData->suffix;
     if ( mData->nickName.isEmpty() )  mData->nickName  = ad.mData->nickName;
     if ( !mData->birthday.isValid() ) 
         if ( ad.mData->birthday.isValid()) 
             mData->birthday =  ad.mData->birthday;
     if ( mData->mailer.isEmpty() ) mData->mailer = ad.mData->mailer;
     if ( !mData->timeZone.isValid() ) mData->timeZone = ad.mData->timeZone;
     if ( !mData->geo.isValid() ) mData->geo = ad.mData->geo;
     if ( mData->title .isEmpty() ) mData->title = ad.mData->title  ;
     if ( mData->role.isEmpty() ) mData->role = ad.mData->role ;
     if ( mData->organization.isEmpty() ) mData->organization = ad.mData->organization ; 
     if ( mData->note.isEmpty() ) mData->note = ad.mData->note ; 
     if ( mData->productId.isEmpty() ) mData->productId  = ad.mData->productId; 
     if ( mData->sortString.isEmpty() )  mData->sortString  = ad.mData->sortString; 
     if ( !mData->secrecy.isValid() ) mData->secrecy = ad.mData->secrecy;
     if ( ( !mData->url.isValid() && ad.mData->url.isValid() ) ) mData->url = ad.mData->url ;
     QStringList t;
     QStringList tAD;
     uint iii;
 
     // ********** phone numbers
     PhoneNumber::List phoneAD = ad.phoneNumbers();
     PhoneNumber::List::Iterator phoneItAD;
     for ( phoneItAD = phoneAD.begin(); phoneItAD != phoneAD.end(); ++phoneItAD ) {
         bool found = false;
         PhoneNumber::List::Iterator it;
         for( it = mData->phoneNumbers.begin(); it != mData->phoneNumbers.end(); ++it ) {
             if ( ( *phoneItAD ).contains( (*it)  ) ) {
                 found = true;
                 (*it).setType( ( *phoneItAD ).type() );
+                (*it).setNumber( ( *phoneItAD ).number() );
                 break;
             }
         }
         if ( isSubSet && ! found )
             mData->phoneNumbers.append( *phoneItAD );                
     }
     if ( isSubSet ) {
         // ************* emails;
         t = mData->emails;
         tAD = ad.mData->emails;
         for ( iii = 0; iii < tAD.count(); ++iii)
             if ( !t.contains(tAD[iii] ) )
                 mData->emails.append( tAD[iii] );
     }
 
     // ************* categories;
     t = mData->categories;
     tAD = ad.mData->categories;
     for ( iii = 0; iii < tAD.count(); ++iii)
         if ( !t.contains(tAD[iii] ) )
             mData->categories.append( tAD[iii] );
     QStringList::ConstIterator it;
     for( it = ad.mData->custom.begin(); it != ad.mData->custom.end(); ++it ) {
         QString qualifiedName = (*it).left( (*it).find( ":" )); 
         bool found = false;
         QStringList::ConstIterator itL;
         for( itL = mData->custom.begin(); itL != mData->custom.end(); ++itL ) {
             if ( (*itL).startsWith( qualifiedName ) ) {
                 found = true;
                 break;
             }
         }
         if ( ! found ) {
             mData->custom.append( *it );
         }
     }
     if ( mData->logo.undefined() && !ad.mData->logo.undefined() ) mData->logo = ad.mData->logo;
     if ( mData->photo.undefined() && !ad.mData->photo.undefined() ) mData->photo = ad.mData->photo;
     if ( !mData->sound.isIntern() ) {
         if ( mData->sound.url().isEmpty() ) {
             mData->sound = ad.mData->sound;
         }
     }
     if ( !mData->agent.isIntern() ) {
         if ( mData->agent.url().isEmpty() ) {
             mData->agent = ad.mData->agent;
         }
     }
     { 
         Key::List::Iterator itA;
         for( itA = ad.mData->keys.begin(); itA != ad.mData->keys.end(); ++itA ) {
             bool found = false;
             Key::List::Iterator it;
             for( it = mData->keys.begin(); it != mData->keys.end(); ++it ) {
                 if ( (*it) == (*itA)) {
                     found = true;
                     break;
                     
                 }
             }
             if ( ! found ) {
                 mData->keys.append( *itA );
             }
         }
     }
     KABC::Address::List::Iterator addressIterA;
     for ( addressIterA = ad.mData->addresses.begin(); addressIterA != ad.mData->addresses.end(); ++addressIterA ) {
         bool found = false;
         KABC::Address::List::Iterator addressIter;
         for ( addressIter = mData->addresses.begin(); addressIter != mData->addresses.end();
               ++addressIter ) {
             if ( (*addressIter) == (*addressIterA)) {
                 found = true;
                 (*addressIter).setType( (*addressIterA).type() );
                 break;
             }
 
         }
         if ( isSubSet && ! found ) {
             mData->addresses.append( *addressIterA );
         }
     }
     //qDebug("merge contact %s ", ad.uid().latin1());
     setUid( ad.uid() );
     setRevision( ad.revision() );
 }
 
 bool Addressee::removeVoice()
 {
     PhoneNumber::List phoneN = phoneNumbers();
     PhoneNumber::List::Iterator phoneIt;
     bool found = false;
     for ( phoneIt = phoneN.begin(); phoneIt != phoneN.end(); ++phoneIt ) {
         if ( (*phoneIt).type() & PhoneNumber::Voice) { // voice found
             if ((*phoneIt).type() - PhoneNumber::Voice ) {
                 (*phoneIt).setType((*phoneIt).type() - PhoneNumber::Voice );
                 insertPhoneNumber( (*phoneIt) );
                 found = true;
             }
         }
         
     }
     return found;
 }
 
 bool Addressee::containsAdr(const Addressee& ad )
 {
     if ( ! ad.mData->familyName.isEmpty()  )  if ( mData->familyName  != ad.mData->familyName) return false;
     if ( ! ad.mData->givenName.isEmpty() )if (  mData->givenName   != ad.mData->givenName ) return false;
     if (  ad.mData->url.isValid() ) if (mData->url != ad.mData->url) return false ;
     if ( ! ad.mData->role.isEmpty() ) if (mData->role != ad.mData->role) return false ;
     if ( ! ad.mData->organization.isEmpty() ) if (mData->organization != ad.mData->organization) return false ; 
     if ( ! ad.mData->note.isEmpty() ) if (mData->note != ad.mData->note) return false ; 
     if ( ! ad.mData->title .isEmpty() ) if (mData->title != ad.mData->title ) return false ;
 
     // compare phone numbers
     PhoneNumber::List phoneN = ad.phoneNumbers();
     PhoneNumber::List::Iterator phoneIt;
     bool found = false;
     for ( phoneIt = phoneN.begin(); phoneIt != phoneN.end(); ++phoneIt ) {
         bool found = false;
         PhoneNumber::List phoneL = ad.phoneNumbers();
         PhoneNumber::List::Iterator phoneItL;
         for ( phoneItL = phoneL.begin(); phoneItL != phoneL.end(); ++phoneItL ) {
             if ( ( *phoneItL ).number() == ( *phoneIt ).number()  ) {
                 found = true;
                 break;
             }
         }
         if ( ! found )
             return false;
     }
     return true;
    
 }
 void Addressee::simplifyAddresses()
 {
 
 
     Address::List list;
     Address::List::Iterator it;
     Address::List::Iterator it2;
     for( it = mData->addresses.begin(); it != mData->addresses.end(); ++it ) {
         it2 = it;
         ++it2;
         for( ; it2 != mData->addresses.end(); ++it2 ) {
             if ( (*it) == (*it2) ) {
                 list.append( *it );
                 break;
             }
         }
     }
     for( it = list.begin(); it != list.end(); ++it ) {
         removeAddress( (*it) );
     }
 
     list.clear();
     int max = 2;
     if (  mData->url.isValid() )
         max = 1; 
     if ( mData->addresses.count() <= max ) return ;
     int count = 0;
     for( it = mData->addresses.begin(); it != mData->addresses.end(); ++it ) {
         if ( count >= max )
             list.append( *it );
         ++count;
     }
     for( it = list.begin(); it != list.end(); ++it ) {
         removeAddress( (*it) );
     }
 }
 
 // removes all emails but the first 
 // needed by phone sync
 void Addressee::simplifyEmails()
 { 
     if ( mData->emails.count() == 0 ) return ;
     QString email = mData->emails.first();
     detach();
     mData->emails.clear();
     mData->emails.append( email );
 }
 
 void Addressee::simplifyPhoneNumbers()
 {
     int max = 4;
     int inList = mData->phoneNumbers.count();
     KABC::PhoneNumber::List removeNumbers;
     KABC::PhoneNumber::List::Iterator phoneIter;
     if ( inList > max ) {
         // delete non-preferred numbers
         for ( phoneIter = mData->phoneNumbers.begin(); phoneIter != mData->phoneNumbers.end();
               ++phoneIter ) {
             if ( inList > max ) {
                 if ( ! (( *phoneIter ).type() &  PhoneNumber::Pref )) {
                     removeNumbers.append( ( *phoneIter ) );
                     --inList;
                 }
             } else
                 break;
         }
         for ( phoneIter = removeNumbers.begin(); phoneIter != removeNumbers.end();
               ++phoneIter ) {
             removePhoneNumber(( *phoneIter ));
         }
         // delete preferred numbers
         if ( inList > max ) {
             for ( phoneIter = mData->phoneNumbers.begin(); phoneIter != mData->phoneNumbers.end();
                   ++phoneIter ) {
                 if ( inList > max ) {
                         removeNumbers.append( ( *phoneIter ) );
                         --inList;
                 } else
                     break;
             }
             for ( phoneIter = removeNumbers.begin(); phoneIter != removeNumbers.end();
                   ++phoneIter ) {
                 removePhoneNumber(( *phoneIter ));
             }
         }
     }
     // remove non-numeric characters
     for ( phoneIter = mData->phoneNumbers.begin(); phoneIter != mData->phoneNumbers.end();
           ++phoneIter ) {
         if ( ! ( *phoneIter ).simplifyNumber() )
             removeNumbers.append( ( *phoneIter ) );
     }
     for ( phoneIter = removeNumbers.begin(); phoneIter != removeNumbers.end();
           ++phoneIter ) {
         removePhoneNumber(( *phoneIter ));
     }
 }
 void Addressee::simplifyPhoneNumberTypes()
 {
     KABC::PhoneNumber::List::Iterator phoneIter;
     for ( phoneIter = mData->phoneNumbers.begin(); phoneIter != mData->phoneNumbers.end();
           ++phoneIter )
         ( *phoneIter ).simplifyType();
 }
 void Addressee::removeID(const QString &prof)
 {
     detach();
     mData->mExternalId = KIdManager::removeId ( mData->mExternalId, prof);
     
 }
 void Addressee::setID( const QString & prof , const QString & id )
 {
     detach();
     mData->mExternalId = KIdManager::setId ( mData->mExternalId, prof, id );
     //qDebug("setID2 %s %s %s",mData->mExternalId.latin1(), prof.latin1(), id.latin1() );
 }
 void Addressee::setTempSyncStat( int id )
 {
     if ( mData->mTempSyncStat == id ) return;
     detach();
     mData->mTempSyncStat = id;
diff --git a/kabc/kabc.pro b/kabc/kabc.pro
index d690acc..17ebff8 100644
--- a/kabc/kabc.pro
+++ b/kabc/kabc.pro
@@ -1,220 +1,218 @@
 TEMPLATE	= lib
 CONFIG += qt warn_on 
 #release debug
 DESTDIR=../bin
 
 TARGET = microkabc
 
 include( ../variables.pri )
 
 INCLUDEPATH += . ./vcard/include ./vcard/include/generated ../microkde ../microkde/kdecore ../microkde/kio/kfile ../microkde/kio/kio ../libkdepim ../qtcompat ../microkde/kdeui ..
 
 #LIBS += -lmicrokde -lldap
 LIBS += -L$(QPEDIR)/lib
 DEFINES += KAB_EMBEDDED  DESKTOP_VERSION
 unix : {
 
 OBJECTS_DIR = obj/unix
 MOC_DIR = moc/unix
 }
 win32: {
 DEFINES += _WIN32_
 OBJECTS_DIR = obj/win
 MOC_DIR = moc/win
 }
 INTERFACES = \
 
 
 HEADERS = \
  resource.h \
  stdaddressbook.h \
  agent.h \
  geo.h \
  key.h \
  field.h \
  plugin.h \
  address.h \
  addresseelist.h \
  addresseeview.h \
 formatfactory.h \
  formatplugin.h \
  phonenumber.h \
 distributionlist.h \
 distributionlistdialog.h \
 distributionlisteditor.h \
 vcardformatplugin.h \
 formats/vcardformatplugin2.h \
  picture.h \
  secrecy.h \
  sound.h \
  addressbook.h \
- syncprefwidget.h \
  timezone.h \
  tmpaddressbook.h \
  addressee.h \
  addresseedialog.h \
  vcardconverter.h \
  vcard21parser.h \
  vcardformatimpl.h \
  plugins/file/resourcefile.h \
  plugins/file/resourcefileconfig.h \
  plugins/dir/resourcedir.h \
  plugins/dir/resourcedirconfig.h \
  vcardparser/vcardline.h \
  vcardparser/vcard.h \
  vcardparser/vcardtool.h \
  vcardparser/vcardparser.h \
 vcard/include/VCardAdrParam.h \
 vcard/include/VCardAdrValue.h \
 vcard/include/VCardAgentParam.h \
 vcard/include/VCardContentLine.h \
 vcard/include/VCardDateParam.h \
 vcard/include/VCardDateValue.h \
 vcard/include/VCardEmailParam.h \
 vcard/include/VCardGeoValue.h \
 vcard/include/VCardGroup.h \
 vcard/include/VCardImageParam.h \
 vcard/include/VCardImageValue.h \
 vcard/include/VCardLangValue.h \
 vcard/include/VCardNValue.h \
 vcard/include/VCardParam.h \
 vcard/include/VCardPhoneNumberValue.h \
 vcard/include/VCardSourceParam.h \
 vcard/include/VCardTelParam.h \
 vcard/include/VCardTextParam.h \
 vcard/include/VCardTextValue.h \
 vcard/include/VCardTextBinParam.h \
 vcard/include/VCardURIValue.h \
 vcard/include/VCardVCard.h \
 vcard/include/VCardEntity.h \
 vcard/include/VCardValue.h \
 vcard/include/VCardSoundValue.h \
 vcard/include/VCardAgentValue.h \
 vcard/include/VCardTelValue.h \
 vcard/include/VCardTextBinValue.h \
 vcard/include/VCardOrgValue.h \
 vcard/include/VCardUTCValue.h \
 vcard/include/VCardClassValue.h \
 vcard/include/VCardFloatValue.h \
 vcard/include/VCardTextListValue.h \
 vcard/include/generated/AdrParam-generated.h \
 vcard/include/generated/AdrValue-generated.h \
 vcard/include/generated/AgentParam-generated.h \
 vcard/include/generated/ContentLine-generated.h \
 vcard/include/generated/DateParam-generated.h \
 vcard/include/generated/DateValue-generated.h \
 vcard/include/generated/EmailParam-generated.h \
 vcard/include/generated/GeoValue-generated.h \
 vcard/include/generated/Group-generated.h \
 vcard/include/generated/ImageParam-generated.h \
 vcard/include/generated/ImageValue-generated.h \
 vcard/include/generated/LangValue-generated.h \
 vcard/include/generated/NValue-generated.h \
 vcard/include/generated/Param-generated.h \
 vcard/include/generated/PhoneNumberValue-generated.h \
 vcard/include/generated/SourceParam-generated.h \
 vcard/include/generated/TelParam-generated.h \
 vcard/include/generated/TextParam-generated.h \
 vcard/include/generated/TextNSParam-generated.h \
 vcard/include/generated/TextValue-generated.h \
 vcard/include/generated/TextBinParam-generated.h \
 vcard/include/generated/URIValue-generated.h \
 vcard/include/generated/VCard-generated.h \
 vcard/include/generated/VCardEntity-generated.h \
 vcard/include/generated/Value-generated.h \
 vcard/include/generated/SoundValue-generated.h \
 vcard/include/generated/AgentValue-generated.h \
 vcard/include/generated/TelValue-generated.h \
 vcard/include/generated/TextBinValue-generated.h \
 vcard/include/generated/OrgValue-generated.h \
 vcard/include/generated/UTCValue-generated.h \
 vcard/include/generated/ClassValue-generated.h \
 vcard/include/generated/FloatValue-generated.h \
 vcard/include/generated/TextListValue-generated.h
 
  
 # plugins/ldap/resourceldap.h \
 # plugins/ldap/resourceldapconfig.h \
 #formats/binary/binaryformat.h \
  
 #vcard/include/VCardTextNSParam.h \
  
 SOURCES = \
 distributionlist.cpp \
 distributionlistdialog.cpp \
 distributionlisteditor.cpp \
 vcardformatplugin.cpp \
 formats/vcardformatplugin2.cpp \
 formatfactory.cpp \
  resource.cpp \
  stdaddressbook.cpp \
  plugin.cpp \
  agent.cpp \
  geo.cpp \
  key.cpp \
  field.cpp \
  addresseeview.cpp \
  address.cpp \
  phonenumber.cpp \
  picture.cpp \
  secrecy.cpp \
  sound.cpp \
  addressbook.cpp \
- syncprefwidget.cpp \
  timezone.cpp \
  tmpaddressbook.cpp \
  addressee.cpp \
  addresseelist.cpp \
  addresseedialog.cpp \
  vcardconverter.cpp \
  vcard21parser.cpp \
  vcardformatimpl.cpp \
  plugins/file/resourcefile.cpp \
  plugins/file/resourcefileconfig.cpp \
  plugins/dir/resourcedir.cpp \
  plugins/dir/resourcedirconfig.cpp \
  vcardparser/vcardline.cpp \
  vcardparser/vcard.cpp \
  vcardparser/vcardtool.cpp \
  vcardparser/vcardparser.cpp \
 vcard/AdrParam.cpp \
 vcard/AdrValue.cpp \
 vcard/AgentParam.cpp \
 vcard/ContentLine.cpp \
 vcard/DateParam.cpp \
 vcard/DateValue.cpp \
 vcard/EmailParam.cpp \
 vcard/Entity.cpp \
 vcard/Enum.cpp \
 vcard/GeoValue.cpp \
 vcard/ImageParam.cpp \
 vcard/ImageValue.cpp \
 vcard/LangValue.cpp \
 vcard/NValue.cpp \
 vcard/Param.cpp \
 vcard/PhoneNumberValue.cpp \
 vcard/RToken.cpp \
 vcard/SourceParam.cpp \
 vcard/TelParam.cpp \
 vcard/TextParam.cpp \
 vcard/TextValue.cpp \
 vcard/TextBinParam.cpp \
 vcard/URIValue.cpp \
 vcard/VCardv.cpp \
 vcard/VCardEntity.cpp \
 vcard/Value.cpp \
 vcard/SoundValue.cpp \
 vcard/AgentValue.cpp \
 vcard/TelValue.cpp \
 vcard/TextBinValue.cpp \
 vcard/OrgValue.cpp \
 vcard/UTCValue.cpp \
 vcard/ClassValue.cpp \
 vcard/FloatValue.cpp \
 vcard/TextListValue.cpp
 
 
 # plugins/ldap/resourceldap.cpp \
 # plugins/ldap/resourceldapconfig.cpp \
 
 #formats/binary/binaryformat.cpp \
diff --git a/korganizer/calendarview.cpp b/korganizer/calendarview.cpp
index 3e0a27d..e4a11f5 100644
--- a/korganizer/calendarview.cpp
+++ b/korganizer/calendarview.cpp
@@ -877,558 +877,560 @@ Event* CalendarView::getLastSyncEvent()
 // we check, if the to delete event has a id for a profile
 //  if yes, we set this id in the profile to delete
 void CalendarView::checkExternSyncEvent( QPtrList<Event> lastSync , Incidence* toDelete )
 {
     if ( lastSync.count() == 0 ) {
         //qDebug(" lastSync.count() == 0");
         return;
     }
     if ( toDelete->type() == "Journal" )
         return;
 
     Event* eve = lastSync.first();
 
     while ( eve ) {
         QString id = toDelete->getID( eve->uid().mid( 15 ) ); // this is the sync profile name
         if ( !id.isEmpty() ) {
             QString des = eve->description();
             QString pref = "e";
             if ( toDelete->type() == "Todo" )
                 pref = "t";
             des += pref+  id  + ",";
             eve->setReadOnly( false );
             eve->setDescription( des );
             //qDebug("setdes %s ", des.latin1());
             eve->setReadOnly( true );
         }
         eve = lastSync.next();
     }
 
 }
 void CalendarView::checkExternalId( Incidence * inc )
 {
     QPtrList<Event> lastSync = mCalendar->getExternLastSyncEvents() ;
     checkExternSyncEvent( lastSync, inc );
 
 }
 bool  CalendarView::synchronizeCalendar( Calendar* local,  Calendar* remote, int mode )
 {
     bool syncOK = true;
     int addedEvent = 0;
     int addedEventR = 0;
     int deletedEventR = 0;
     int deletedEventL = 0;
     int changedLocal = 0;
     int changedRemote = 0;
     //QPtrList<Event> el = local->rawEvents(); 
     Event* eventR;
     QString uid;
     int take;
     Event* eventL;
     Event* eventRSync;
     Event* eventLSync;
     QPtrList<Event>  eventRSyncSharp = remote->getExternLastSyncEvents();
     QPtrList<Event>  eventLSyncSharp = local->getExternLastSyncEvents();
     bool fullDateRange = false;
     local->resetTempSyncStat();
     mLastCalendarSync = QDateTime::currentDateTime();
     QDateTime modifiedCalendar = mLastCalendarSync;;
     eventLSync = getLastSyncEvent();
     eventR = remote->event("last-syncEvent-"+mCurrentSyncName );
     if ( eventR ) {
         eventRSync = (Event*) eventR->clone();
         remote->deleteEvent(eventR );
 
     } else {
         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
             eventRSync = (Event*)eventLSync->clone();
         } else {
             fullDateRange = true;
             eventRSync = new Event();
             eventRSync->setSummary(mCurrentSyncName + i18n(" - sync event"));
             eventRSync->setUid("last-syncEvent-"+mCurrentSyncName ); 
             eventRSync->setDtStart( mLastCalendarSync );
             eventRSync->setDtEnd( mLastCalendarSync.addSecs( 7200 ) );
             eventRSync->setCategories( i18n("SyncEvent") );
         }
     }
     if ( eventLSync->dtStart() == mLastCalendarSync )
         fullDateRange = true;
    
     if ( ! fullDateRange  ) {
         if ( eventLSync->dtStart() != eventRSync->dtStart() ) {
             
             // qDebug("set fulldate to true %s %s" ,eventLSync->dtStart().toString().latin1(), eventRSync->dtStart().toString().latin1() ); 
             //qDebug("%d %d %d %d ", eventLSync->dtStart().time().second(), eventLSync->dtStart().time().msec() , eventRSync->dtStart().time().second(), eventRSync->dtStart().time().msec());
             fullDateRange = true;
         } 
     }
     if ( fullDateRange )
         mLastCalendarSync = QDateTime::currentDateTime().addDays( -100*365);
     else
         mLastCalendarSync = eventLSync->dtStart();
     // for resyncing if own file has changed
     if ( mCurrentSyncDevice == "deleteaftersync" ) {
         mLastCalendarSync = loadedFileVersion;
         qDebug("setting mLastCalendarSync ");
     }
     //qDebug("*************************** ");
     qDebug("mLastCalendarSync %s ",mLastCalendarSync.toString().latin1() );
     QPtrList<Incidence> er = remote->rawIncidences(); 
     Incidence* inR = er.first();
     Incidence* inL;
     QProgressBar bar( er.count(),0 );
     bar.setCaption (i18n("Syncing - close to abort!") );
     
     int w = 300;
     if ( QApplication::desktop()->width() < 320 )
         w = 220;
     int h = bar.sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     bar.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     bar.show();
     int modulo = (er.count()/10)+1;
     int incCounter = 0;
     while ( inR ) {
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         ++incCounter;
         uid = inR->uid(); 
         bool skipIncidence = false;
         if ( uid.left(15) == QString("last-syncEvent-") )
             skipIncidence = true;
         QString idS;
         qApp->processEvents();
         if ( !skipIncidence ) {
             inL = local->incidence( uid );
             if ( inL ) { // maybe conflict - same uid in both calendars
                 int maxrev = inL->revision();
                 if ( maxrev < inR->revision() )
                     maxrev = inR->revision();
                 if ( (take = takeEvent( inL, inR, mode, fullDateRange )) > 0 ) {
                     //qDebug("take %d %s ", take, inL->summary().latin1());
                     if ( take == 3 )
                         return false;
                     if ( take == 1  ) {// take local
                         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL )
                             inL->setCsum( mCurrentSyncDevice, inR->getCsum(mCurrentSyncDevice) );
                         else
                             idS = inR->IDStr();
                         remote->deleteIncidence( inR );
                         if ( inL->revision() < maxrev )
                             inL->setRevision( maxrev );
                         inR = inL->clone();
                         inR->setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
                         if ( mGlobalSyncMode != SYNC_MODE_EXTERNAL )
                             inR->setIDStr( idS );
                         remote->addIncidence(  inR );
                         ++changedRemote;
                     } else {
                         if ( inR->revision() < maxrev )
                             inR->setRevision( maxrev );
                         idS = inL->IDStr();
                         local->deleteIncidence( inL );
                         inL = inR->clone();
                         inL->setIDStr( idS );
                         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                             inL->setCsum( mCurrentSyncDevice, inR->getCsum(mCurrentSyncDevice) );
                             inL->setID( mCurrentSyncDevice, inR->getID(mCurrentSyncDevice) );
                         }
                         local->addIncidence(  inL  );
                         ++changedLocal;
                     }
                 }
             } else { //  no conflict
                 if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                     QString des = eventLSync->description(); 
                     QString pref = "e";
                     if ( inR->type() == "Todo" )
                         pref = "t";
                     if ( des.find(pref+ inR->getID(mCurrentSyncDevice)  +"," ) >= 0 && mode != 5) { // delete it
                         inR->setTempSyncStat( SYNC_TEMPSTATE_DELETE );
                         //remote->deleteIncidence( inR );
                         ++deletedEventR; 
                     } else {
                         inR->setLastModified( modifiedCalendar );
                         inL = inR->clone();
                         local->addIncidence( inL );
                         ++addedEvent;
                     }
                 } else {
                     if ( inR->lastModified() > mLastCalendarSync || mode == 5 ) {
                         inR->setLastModified( modifiedCalendar );
                         local->addIncidence( inR->clone() );
                         ++addedEvent;
                     } else {
                         checkExternSyncEvent(eventRSyncSharp, inR);
                         remote->deleteIncidence( inR );
                         ++deletedEventR; 
                     }
                 }
             }
         }
         inR =  er.next();
     }
     QPtrList<Incidence> el = local->rawIncidences(); 
     inL = el.first();
     modulo = (el.count()/10)+1;
     bar.setCaption (i18n("Add / remove events") ); 
     bar.setTotalSteps (  el.count()  ) ;
     bar.show();
     incCounter = 0;
    
     while ( inL ) {
            
         qApp->processEvents();
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         ++incCounter;
         uid = inL->uid();
         bool skipIncidence = false;
         if ( uid.left(15) == QString("last-syncEvent-") )
             skipIncidence = true;
         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL && inL->type() == "Journal" )
             skipIncidence = true;
         if ( !skipIncidence )  {
             inR = remote->incidence( uid );
             if ( ! inR ) { 
                 if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                     if ( !inL->getID(mCurrentSyncDevice).isEmpty() && mode != 4 ) {
                         checkExternSyncEvent(eventLSyncSharp, inL);
                         local->deleteIncidence( inL );
                         ++deletedEventL; 
                     } else {
                         if ( ! mSyncManager->mWriteBackExistingOnly ) {
                             inL->removeID(mCurrentSyncDevice );
                             ++addedEventR; 
                             //qDebug("remote added Incidence %s ", inL->summary().latin1());
                             inL->setLastModified( modifiedCalendar );
                             inR = inL->clone();
                             inR->setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
                             remote->addIncidence(  inR );
                         }
                     }
                 } else {
                     if ( inL->lastModified() < mLastCalendarSync && mode != 4 ) {
                         checkExternSyncEvent(eventLSyncSharp, inL);
                         local->deleteIncidence( inL );
                         ++deletedEventL; 
                     } else {
                         if ( ! mSyncManager->mWriteBackExistingOnly ) {
                             ++addedEventR; 
                             inL->setLastModified( modifiedCalendar );
                             remote->addIncidence(  inL->clone() );
                         }
                     }
                 }
             }
         }
         inL = el.next();
     }
     int delFut = 0;
+    int remRem = 0;
     if ( mSyncManager->mWriteBackInFuture ) {
         er = remote->rawIncidences(); 
+        remRem = er.count();
         inR = er.first();
         QDateTime dt;
         QDateTime cur = QDateTime::currentDateTime().addDays( -7 );
         QDateTime end = cur.addDays( (mSyncManager->mWriteBackInFuture +1 ) *7 );
         while ( inR ) {
             if ( inR->type() == "Todo" ) {
                 Todo * t = (Todo*)inR;
                 if ( t->hasDueDate() )
                     dt = t->dtDue();
                 else
                     dt = cur.addSecs( 62 );
             }
             else if (inR->type() == "Event" ) {
                 bool ok;
                 dt =  inR->getNextOccurence( cur, &ok );
                     if ( !ok )
                         dt = cur.addSecs( -62 );
                 }
             else
                 dt = inR->dtStart();
             if ( dt < cur || dt > end ) {
                 remote->deleteIncidence( inR );
                 ++delFut;
             }
             inR =  er.next();
         }
     }
     bar.hide();
     mLastCalendarSync = QDateTime::currentDateTime().addSecs( 1 );
     eventLSync->setReadOnly( false );
     eventLSync->setDtStart( mLastCalendarSync );
     eventRSync->setDtStart( mLastCalendarSync );
     eventLSync->setDtEnd( mLastCalendarSync.addSecs( 3600 ) );
     eventRSync->setDtEnd( mLastCalendarSync.addSecs( 3600 ) );
     eventRSync->setLocation( i18n("Remote from: ")+mCurrentSyncName ) ;
     eventLSync->setLocation(i18n("Local from: ") + mCurrentSyncName  );
     eventLSync->setReadOnly( true );
     if ( mGlobalSyncMode ==  SYNC_MODE_NORMAL)
         remote->addEvent( eventRSync );
     QString mes;
     mes .sprintf(  i18n("Synchronization summary:\n\n %d items added to local\n %d items added to remote\n %d items updated on local\n %d items updated on remote\n %d items deleted on local\n %d items deleted on remote\n"),addedEvent, addedEventR, changedLocal, changedRemote, deletedEventL, deletedEventR ); 
     QString delmess;
     if ( delFut  ) {
-        delmess.sprintf(  i18n("%d items skipped on remote,\nbecause they are in the past or\nmore than %d weeks in the future.\n"),delFut, mSyncManager->mWriteBackInFuture ); 
+        delmess.sprintf(  i18n("%d items skipped on remote,\nbecause they are in the past or\nmore than %d weeks in the future.\nAfter skipping, remote has\n%d calendar/todo items."), delFut,mSyncManager->mWriteBackInFuture, remRem-delFut); 
         mes += delmess;
     }
     if ( mSyncManager->mShowSyncSummary ) {
         KMessageBox::information(this, mes, i18n("KO/Pi Synchronization") );
     }
     qDebug( mes );
     mCalendar->checkAlarmForIncidence( 0, true );
     return syncOK;
 }
 
 void CalendarView::setSyncDevice( QString s )
 {
     mCurrentSyncDevice= s;
 }
 void CalendarView::setSyncName( QString s )
 {
     mCurrentSyncName= s;
 }
 bool CalendarView::syncCalendar(QString filename, int mode)
 {
     //qDebug("syncCalendar %s ", filename.latin1());
     mGlobalSyncMode = SYNC_MODE_NORMAL;
     CalendarLocal* calendar = new CalendarLocal();
     calendar->setTimeZoneId(KOPrefs::instance()->mTimeZoneId);
     FileStorage* storage = new FileStorage( calendar );
     bool syncOK = false;
     storage->setFileName( filename );
     // qDebug("loading ... ");
     if ( storage->load() ) {
         getEventViewerDialog()->setSyncMode( true );
         syncOK = synchronizeCalendar( mCalendar, calendar, mode );
         getEventViewerDialog()->setSyncMode( false );
         if (  syncOK ) {
            if ( mSyncManager->mWriteBackFile )
             {
                 storage->setSaveFormat( new ICalFormat() );
                 storage->save();
             }
         }
         setModified( true );
     }
     delete storage;
     delete calendar;
     if ( syncOK )
         updateView();
     return syncOK;
 }
 
 void CalendarView::syncExternal( int mode  )
 {
     mGlobalSyncMode = SYNC_MODE_EXTERNAL;
    
     qApp->processEvents();
     CalendarLocal* calendar = new CalendarLocal();
     calendar->setTimeZoneId(KOPrefs::instance()->mTimeZoneId);
     bool syncOK = false;
     bool loadSuccess = false;
     PhoneFormat* phoneFormat = 0;
 #ifndef DESKTOP_VERSION
     SharpFormat* sharpFormat = 0;
     if ( mode == 0 ) { // sharp
         sharpFormat = new SharpFormat () ;
         loadSuccess = sharpFormat->load( calendar, mCalendar ); 
 
     } else 
 #endif
         if ( mode == 1 ) { // phone 
         phoneFormat = new PhoneFormat (mCurrentSyncDevice,
                                          mSyncManager->mPhoneDevice,
                                          mSyncManager->mPhoneConnection,
                                          mSyncManager->mPhoneModel);
         loadSuccess = phoneFormat->load( calendar,mCalendar); 
         
     } else 
         return;
     if ( loadSuccess ) {
         getEventViewerDialog()->setSyncMode( true );
         syncOK = synchronizeCalendar( mCalendar, calendar, mSyncManager->mSyncAlgoPrefs );
         getEventViewerDialog()->setSyncMode( false );
         qApp->processEvents();
         if (  syncOK ) {
             if ( mSyncManager->mWriteBackFile )
             {
                 QPtrList<Incidence> iL = mCalendar->rawIncidences(); 
                 Incidence* inc = iL.first();
                 if ( phoneFormat ) {
                     while ( inc ) {
                         inc->removeID(mCurrentSyncDevice);
                         inc =  iL.next();
                     }
                 }
 #ifndef DESKTOP_VERSION
                 if ( sharpFormat )
                     sharpFormat->save(calendar);
 #endif
                 if ( phoneFormat )
                     phoneFormat->save(calendar);
                 iL = calendar->rawIncidences(); 
                 inc = iL.first();
                 Incidence* loc;
                 while ( inc ) {
                     if ( inc->tempSyncStat() == SYNC_TEMPSTATE_NEW_ID ) {
                         loc = mCalendar->incidence(inc->uid() );
                         if ( loc ) {
                             loc->setID(mCurrentSyncDevice, inc->getID(mCurrentSyncDevice) );
                             loc->setCsum( mCurrentSyncDevice, inc->getCsum(mCurrentSyncDevice) );
                         }
                     }
                     inc =  iL.next();
                 }
                 Incidence* lse = getLastSyncEvent();
                 if ( lse ) {
                     lse->setReadOnly( false );
                     lse->setDescription( "" );
                     lse->setReadOnly( true );
                 }
             }
         }
         setModified( true );
     } else {
         QString question = i18n("Sorry, the database access\ncommand failed!\n\nNothing synced!\n") ;
         QMessageBox::information( 0, i18n("KO/Pi Import - ERROR"),
                                       question, i18n("Ok")) ;
 
     }
     delete calendar;
     updateView();
     return ;//syncOK;
 
 }
 
 bool CalendarView::importBday()
 {
 #ifndef KORG_NOKABC
 
 #ifdef DESKTOP_VERSION
     KABC::StdAddressBook* AddressBook = KABC::StdAddressBook::self( true );
     KABC::AddressBook::Iterator it;
     int count = 0;
     for( it = AddressBook->begin(); it != AddressBook->end(); ++it ) { 
         ++count;
     }
     QProgressBar bar(count,0 );
     int w = 300;
     if ( QApplication::desktop()->width() < 320 )
         w = 220;
     int h = bar.sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     bar.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     bar.show();
     bar.setCaption (i18n("Reading addressbook - close to abort!") );
     qApp->processEvents();
     count = 0;
     int addCount = 0;
     KCal::Attendee* a = 0;
     for( it = AddressBook->begin(); it != AddressBook->end(); ++it ) { 
         if ( ! bar.isVisible() )
             return false;
         bar.setProgress( count++ );
         qApp->processEvents();
         //qDebug("add BDay %s %s", (*it).realName().latin1(),(*it).birthday().date().toString().latin1() );
         if ( (*it).birthday().date().isValid() ){
             a = new KCal::Attendee( (*it).realName(), (*it).preferredEmail(),false,KCal::Attendee::NeedsAction,KCal::Attendee::ReqParticipant,(*it).uid()) ;
             if ( addAnniversary(  (*it).birthday().date(), (*it).assembledName(),  a, true ) )
             ++addCount;
         } 
         QDate anni = KGlobal::locale()->readDate( (*it).custom("KADDRESSBOOK", "X-Anniversary" ), "%Y-%m-%d"); 
         if ( anni.isValid() ){ 
             a = new KCal::Attendee( (*it).realName(), (*it).preferredEmail(),false,KCal::Attendee::NeedsAction,KCal::Attendee::ReqParticipant,(*it).uid()) ;
             if ( addAnniversary(  anni, (*it).assembledName(),  a, false ) )
             ++addCount;
         }
     }
     updateView(); 
     topLevelWidget()->setCaption(QString::number( addCount )+ i18n(" birthdays/anniversaries added!"));
 #else //DESKTOP_VERSION
 
   ExternalAppHandler::instance()->requestBirthdayListFromKAPI("QPE/Application/kopi", this->name() /* name is here the unique uid*/);
   // the result should now arrive through method insertBirthdays
 
 #endif //DESKTOP_VERSION
 
 #endif //KORG_NOKABC
 
 
     return true;
 }
  
 // This method will be called from Ka/Pi as a response to requestBirthdayListFromKAPI
 void CalendarView::insertBirthdays(const QString& uid, const QStringList& birthdayList, 
 				   const QStringList& anniversaryList, const QStringList& realNameList,
 				   const QStringList& emailList, const QStringList& assembledNameList, 
 				   const QStringList& uidList)
 {
   qDebug("CalendarView::insertBirthdays");
   if (uid == this->name())
   {
     int count = birthdayList.count();
     int addCount = 0;
     KCal::Attendee* a = 0;
 
     qDebug("CalView 1 %i", count);
 
     QProgressBar bar(count,0 );
     int w = 300;
     if ( QApplication::desktop()->width() < 320 )
         w = 220;
     int h = bar.sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     bar.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     bar.show();
     bar.setCaption (i18n("inserting birthdays - close to abort!") );
     qApp->processEvents();
 
     QDate birthday;
     QDate anniversary;
     QString realName;
     QString email;
     QString assembledName;
     QString uid;
     bool ok = true;
     for ( int i = 0; i < count; i++)
         {
             if ( ! bar.isVisible() )
                 return;
             bar.setProgress( i );
             qApp->processEvents();
 
             birthday = KGlobal::locale()->readDate(birthdayList[i], KLocale::ISODate, &ok);
             if (!ok) {
                 ;//qDebug("CalendarView::insertBirthdays found invalid birthday: %s",birthdayList[i].latin1());
             }
 
             anniversary = KGlobal::locale()->readDate(anniversaryList[i], KLocale::ISODate, &ok);
             if (!ok) {
                 ;//qDebug("CalendarView::insertBirthdays found invalid anniversary: %s",anniversaryList[i].latin1());
             }
             realName = realNameList[i]; 
             email = emailList[i];
             assembledName = assembledNameList[i];
             uid = uidList[i];
             //qDebug("insert birthday in KO/Pi: %s,%s,%s,%s: %s, %s", realName.latin1(), email.latin1(), assembledName.latin1(), uid.latin1(), birthdayList[i].latin1(), anniversaryList[i].latin1() );
 
             if ( birthday.isValid() ){
                 a = new KCal::Attendee( realName, email,false,KCal::Attendee::NeedsAction,
                                         KCal::Attendee::ReqParticipant,uid) ;
                 if ( addAnniversary(  birthday, assembledName,  a, true ) )
                     ++addCount;
             } 
 
             if ( anniversary.isValid() ){ 
                 a = new KCal::Attendee( realName, email,false,KCal::Attendee::NeedsAction,
                                         KCal::Attendee::ReqParticipant,uid) ;
                 if ( addAnniversary(  anniversary, assembledName,  a, false ) )
diff --git a/libkcal/event.cpp b/libkcal/event.cpp
index dfa265b..7256f05 100644
--- a/libkcal/event.cpp
+++ b/libkcal/event.cpp
@@ -1,177 +1,223 @@
 /*
     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 <kglobal.h>
 #include <klocale.h>
 #include <kdebug.h>
 
 #include "event.h"
 
 using namespace KCal;
 
 Event::Event() :
   mHasEndDate( false ), mTransparency( Opaque )
 {
 }
 
 Event::Event(const Event &e) : Incidence(e)
 {
   mDtEnd = e.mDtEnd;
   mHasEndDate = e.mHasEndDate;
   mTransparency = e.mTransparency;
 }
 
 Event::~Event()
 {
 }
 
 Incidence *Event::clone()
 {
   return new Event(*this);
 }
 
 bool KCal::operator==( const Event& e1, const Event& e2 )
 {
     return operator==( (const Incidence&)e1, (const Incidence&)e2 ) &&
         e1.dtEnd() == e2.dtEnd() &&
         e1.hasEndDate() == e2.hasEndDate() &&
         e1.transparency() == e2.transparency();
 }
 
 
+bool Event::contains ( Event* from )
+{
+
+    if ( !from->summary().isEmpty() )
+        if (  !summary().startsWith(  from->summary() ))
+            return false; 
+    if ( from->dtStart().isValid() )
+        if (dtStart() != from->dtStart() )
+            return false;
+    if ( from->dtEnd().isValid() )
+        if ( dtEnd() !=  from->dtEnd() )
+            return false;
+    if ( !from->location().isEmpty() )
+        if (  !location().startsWith( from->location() ) )
+            return false;
+    if ( !from->description().isEmpty() )
+        if (  !description().startsWith(  from->description() ))
+            return false;
+    if ( from->alarms().count() ) {
+        Alarm *a = from->alarms().first();
+        if (  a->enabled()  ){
+            if ( !alarms().count() )
+                return false;
+            Alarm *b = alarms().first();
+            if( ! b->enabled() )
+                return false;
+            if ( ! (a->offset() == b->offset() ))
+                return false;
+        }
+    }
+    QStringList cat = categories();
+    QStringList catFrom = from->categories();
+    QString nCat;
+    int iii;
+    for ( iii = 0; iii < catFrom.count();++iii ) {
+        nCat = catFrom[iii];
+        if ( !nCat.isEmpty() )
+            if ( !cat.contains( nCat )) {
+                return false;
+            }
+    }
+    if ( from->doesRecur() ) 
+        if ( from->doesRecur() != doesRecur() && ! (from->doesRecur()== Recurrence::rYearlyMonth && doesRecur()== Recurrence::rYearlyDay) )
+            return false;
+    return true;
+}
 
 void Event::setDtEnd(const QDateTime &dtEnd)
 {
   if (mReadOnly) return;
 
   mDtEnd = getEvenTime( dtEnd );
 
   setHasEndDate(true);
   setHasDuration(false);
 
   updated();
 }
 
 QDateTime Event::dtEnd() const
 {
   if (hasEndDate()) return mDtEnd;
   if (hasDuration()) return dtStart().addSecs(duration());
 
   kdDebug(5800) << "Warning! Event '" << summary()
             << "' does have neither end date nor duration." << endl;
   return dtStart();
 }
 
 QString Event::dtEndTimeStr() const
 {
   return KGlobal::locale()->formatTime(mDtEnd.time());
 }
 
 QString Event::dtEndDateStr(bool shortfmt) const
 {
   return KGlobal::locale()->formatDate(mDtEnd.date(),shortfmt);
 }
 
 QString Event::dtEndStr(bool shortfmt) const
 {
   return KGlobal::locale()->formatDateTime(mDtEnd, shortfmt);
 }
 
 void Event::setHasEndDate(bool b)
 {
   mHasEndDate = b;
 }
 
 bool Event::hasEndDate() const
 {
   return mHasEndDate;
 }
 
 bool Event::isMultiDay() const
 {
   bool multi = !(dtStart().date() == dtEnd().date());
   return multi;
 }
 
 void Event::setTransparency(Event::Transparency transparency)
 {
   if (mReadOnly) return;
   mTransparency = transparency;
   updated();
 }
 
 Event::Transparency Event::transparency() const
 {
   return mTransparency;
 }
 
 void Event::setDuration(int seconds)
 {
   setHasEndDate(false);
   Incidence::setDuration(seconds);
 }
 QDateTime Event::getNextAlarmDateTime( bool * ok, int * offset ) const
 {
   
     bool yes;
      QDateTime incidenceStart = getNextOccurence( QDateTime::currentDateTime(), &yes );
      if ( ! yes || cancelled() ) {
          *ok = false;
          return QDateTime ();
      }
   
      bool enabled = false;
      Alarm* alarm;
      int off;
      QDateTime alarmStart = QDateTime::currentDateTime().addDays( 3650 );;
     //  if ( QDateTime::currentDateTime() > incidenceStart ){
 //          *ok = false;
 //          return incidenceStart;
 //      }
      for (QPtrListIterator<Alarm> it(mAlarms); (alarm = it.current()) != 0; ++it) {
          if (alarm->enabled()) {
              if ( alarm->hasTime () ) {
                  if ( alarm->time() < alarmStart ) {
                      alarmStart = alarm->time();
                      enabled = true;
                      off = alarmStart.secsTo( incidenceStart );
                  }
 
              } else {
                  int secs = alarm->startOffset().asSeconds();
                  if ( incidenceStart.addSecs( secs ) < alarmStart ) {
                      alarmStart = incidenceStart.addSecs( secs );
                      enabled = true;
                      off = -secs;
                  }
              }
          }
      }
      if ( enabled ) {
          if ( alarmStart >  QDateTime::currentDateTime()  ) {
              *ok = true;
              * offset = off;
              return alarmStart;
          }
      }
      *ok = false;
      return QDateTime ();
 
 }
diff --git a/libkcal/event.h b/libkcal/event.h
index 2a8bd95..3bc8adc 100644
--- a/libkcal/event.h
+++ b/libkcal/event.h
@@ -1,88 +1,90 @@
 /*
     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 EVENT_H
 #define EVENT_H
 //
 // Event component, representing a VEVENT object
 //
 
 #include "incidence.h"
 namespace KCal {
 
 /**
   This class provides an Event in the sense of RFC2445.
 */
 class Event : public Incidence
 {
   public:
     enum Transparency { Opaque, Transparent };
     typedef ListBase<Event> List;
     Event();
     Event(const Event &);
     ~Event();
 
     QCString type() const { return "Event"; }
 
     Incidence *clone();
     QDateTime getNextAlarmDateTime( bool * ok, int * offset  ) const;
 
     /** for setting an event's ending date/time with a QDateTime. */
     void setDtEnd(const QDateTime &dtEnd);
     /** Return the event's ending date/time as a QDateTime. */
     virtual QDateTime dtEnd() const;
     /** returns an event's end time as a string formatted according to the
      users locale settings */
     QString dtEndTimeStr() const;
     /** returns an event's end date as a string formatted according to the
      users locale settings */
     QString dtEndDateStr(bool shortfmt=true) const;
     /** returns an event's end date and time as a string formatted according
      to the users locale settings */
     QString dtEndStr(bool shortfmt=true) const;
     void setHasEndDate(bool);
     /** Return whether the event has an end date/time. */
     bool hasEndDate() const;
 
     /** Return true if the event spans multiple days, otherwise return false. */
     bool isMultiDay() const;
 
     /** set the event's time transparency level. */
     void setTransparency(Transparency transparency);
     /** get the event's time transparency level. */
     Transparency transparency() const;
 
     void setDuration(int seconds);
 
+    bool contains ( Event*);
+
   private:
     bool accept(Visitor &v) { return v.visit(this); }
 
     QDateTime mDtEnd;
     bool mHasEndDate;
     Transparency mTransparency;
 };
 
 bool operator==( const Event&, const Event& );
 
 
 }
 
 
 #endif
diff --git a/libkcal/phoneformat.cpp b/libkcal/phoneformat.cpp
index 281434e..101db57 100644
--- a/libkcal/phoneformat.cpp
+++ b/libkcal/phoneformat.cpp
@@ -59,576 +59,562 @@ public:
         QString datestr;
         QString timestr;
         int offset =  KGlobal::locale()->localTimeOffset( dti );
         QDateTime   dt;
         if (useTZ)
             dt =  dti.addSecs ( -(offset*60));
         else
             dt =  dti;
         if(dt.date().isValid()){
             const QDate& date = dt.date();
             datestr.sprintf("%04d%02d%02d",
                             date.year(), date.month(), date.day());
         }
         if(dt.time().isValid()){
             const QTime& time = dt.time();
             timestr.sprintf("T%02d%02d%02d",
                             time.hour(), time.minute(), time.second());
         }
         return datestr + timestr;
     }
 
 
 };
 
   
 
 PhoneFormat::PhoneFormat(QString profileName, QString device,QString connection, QString model )
 {
     mProfileName = profileName;
     PhoneAccess::writeConfig( device, connection, model );
 }
 
 PhoneFormat::~PhoneFormat()
 {
 }
 
 #if 0
 int PhoneFormat::initDevice(GSM_StateMachine *s)
 {
     GSM_ReadConfig(NULL, &s->Config[0], 0);
 	s->ConfigNum 	= 1;
     GSM_Config *cfg = &s->Config[0];
     if ( ! mConnection.isEmpty() ) {
         cfg->Connection = strdup(mConnection.latin1());
 		cfg->DefaultConnection = false;
         qDebug("Connection set %s ", cfg->Connection );
 
     }
     if ( ! mDevice.isEmpty() ) {
         cfg->Device = strdup(mDevice.latin1());
 		cfg->DefaultDevice = false;
         qDebug("Device  set %s ", cfg->Device);
 
     }
     if ( ! mModel.isEmpty() ) {
 		strcpy(cfg->Model,mModel.latin1() );
 		cfg->DefaultModel = false;
         qDebug("Model  set %s ",cfg->Model );
     }
     int error=GSM_InitConnection(s,3);
     return error;
 }
 #endif
 ulong PhoneFormat::getCsumTodo( Todo* todo )
 {
     QStringList  attList;
     if ( todo->hasDueDate() )
         attList << PhoneParser::dtToString ( todo->dtDue() );
     attList << todo->summary();
     QString completedString = "no";
     if ( todo->isCompleted() )
         completedString = "yes";
     attList << completedString; 
     int prio = todo->priority();
     if( prio == 2 ) prio = 1;
     if (prio == 4 ) prio = 5 ;
     attList << QString::number( prio ); 
     QString alarmString = "na";
     Alarm *alarm;
     if (  todo->alarms().count() > 0 ) {
         alarm = todo->alarms().first();
         if ( alarm->enabled() ) {
             alarmString = QString::number(alarm->offset() );
         }
     }
     attList << alarmString;
     attList << todo->categoriesStr();
     attList << todo->secrecyStr(); 
     return PhoneFormat::getCsum(attList );  
 
 }
 ulong PhoneFormat::getCsumEvent( Event* event )
 {
     QStringList  attList;
     attList << PhoneParser::dtToString ( event->dtStart() );
     attList << PhoneParser::dtToString ( event->dtEnd() );
     attList <<  event->summary();
     attList <<  event->location();
     QString alarmString = "na";
     Alarm *alarm;
     if (  event->alarms().count() > 0 ) {
         alarm = event->alarms().first();
         if ( alarm->enabled() ) {
             alarmString = QString::number( alarm->offset() );
         }
     }
     attList <<  alarmString;
     Recurrence* rec = event->recurrence();
     QStringList  list;
     bool writeEndDate = false;
     switch ( rec->doesRecur() )
         {
         case Recurrence::rDaily: // 0
             list.append( "0" );
             list.append( QString::number( rec->frequency() ));//12
             list.append( "0" );
             list.append( "0" );
             writeEndDate = true;
             break;
         case Recurrence::rWeekly:// 1
             list.append( "1" );
             list.append( QString::number( rec->frequency()) );//12
             list.append( "0" );
             {
                 int days = 0;
                 QBitArray weekDays = rec->days(); 
                 int i;
                 for( i = 1; i <= 7; ++i ) {
                     if ( weekDays[i-1] ) {
                         days += 1 << (i-1);
                     }
                 }
                 list.append( QString::number( days ) );
             }
             //pending weekdays
             writeEndDate = true;
            
             break;
         case Recurrence::rMonthlyPos:// 2
             list.append( "2" );
             list.append( QString::number( rec->frequency()) );//12
            
             writeEndDate = true; 
             {
                 int count = 1;
                 QPtrList<Recurrence::rMonthPos> rmp;
                 rmp = rec->monthPositions();
                 if ( rmp.first()->negative )
                     count = 5 - rmp.first()->rPos - 1;
                 else
                     count = rmp.first()->rPos - 1;
                 list.append( QString::number( count ) );
            
             }
 
             list.append( "0" );
             break;
         case Recurrence::rMonthlyDay:// 3
             list.append( "3" );
             list.append( QString::number( rec->frequency()) );//12
             list.append( "0" );
             list.append( "0" );
             writeEndDate = true;
             break;
         case Recurrence::rYearlyMonth://4
             list.append( "4" );
             list.append( QString::number( rec->frequency()) );//12
             list.append( "0" );
             list.append( "0" );
             writeEndDate = true;
             break;
        
         default:
             list.append( "255" );
             list.append( QString() );
             list.append( "0" );
             list.append( QString() );
             list.append( "0" );
             list.append( "20991231T000000" );
             break;
         }
     if  ( writeEndDate ) {
         
         if ( rec->endDate().isValid() ) { // 15 + 16
             list.append( "1" );
             list.append( PhoneParser::dtToString( rec->endDate()) );
         } else {
             list.append( "0" );
             list.append( "20991231T000000" );
         }
         
     }
     attList << list.join("");
     attList << event->categoriesStr();
     //qDebug("csum cat %s", event->categoriesStr().latin1()); 
 
     attList << event->secrecyStr();
     return PhoneFormat::getCsum(attList );  
 }
 ulong PhoneFormat::getCsum( const QStringList &  attList)
 {
     int max = attList.count();
     ulong cSum = 0;
     int j,k,i;
     int add;
     for ( i = 0; i < max ; ++i ) {
         QString s = attList[i];
         if ( ! s.isEmpty() ){
             j = s.length();
             for ( k = 0; k < j; ++k ) {
                 int mul = k +1;
                 add = s[k].unicode ();
                 if ( k < 16 )
                     mul = mul * mul;
                 int ii = i+1;
                 add = add * mul *ii*ii*ii;
                 cSum += add;
             }
         }
             
     }
     //QString dump = attList.join(",");
     //qDebug("csum: %d %s", cSum,dump.latin1()); 
     
     return cSum;
 
 }
 //extern "C" GSM_Error GSM_InitConnection(GSM_StateMachine *s, int ReplyNum);
 #include <stdlib.h>
 #define DEBUGMODE false
 bool PhoneFormat::load( Calendar *calendar, Calendar *existingCal)
 {
 
     QString fileName;
 #ifdef _WIN32_
     fileName = locateLocal("tmp", "phonefile.vcs");
 #else
     fileName = "/tmp/phonefile.vcs";
 #endif
     QString command;
     if ( ! PhoneAccess::readFromPhone( fileName )) {
         return false;
     }
     VCalFormat vfload;
     vfload.setLocalTime ( true ); 
     qDebug("loading file ..."); 
 
     if ( ! vfload.load( calendar, fileName ) )
         return false;
     QPtrList<Event> er = calendar->rawEvents();
     Event* ev = er.first();  
     qDebug("reading events... "); 
     while ( ev ) {
         QStringList cat = ev->categories();
         if ( cat.contains( "MeetingDEF" )) {
             ev->setCategories( QStringList() );
+        } else 
+        if ( cat.contains( "Birthday" )) {
+            ev->setFloats( true );
+            QDate da = ev->dtStart().date();
+            ev->setDtStart( QDateTime( da)  );
+            ev->setDtEnd( QDateTime( da.addDays(1))  );
+            
         }
+        uint cSum;
+        cSum = PhoneFormat::getCsumEvent( ev );
         int id = ev->pilotId();
         Event *event;
         event = existingCal->event( mProfileName ,QString::number( id ) );
         if ( event ) {
             event = (Event*)event->clone();
             copyEvent( event,  ev );
             calendar->deleteEvent( ev );
             calendar->addEvent( event);
         }
         else
             event = ev;
-        uint cSum;
-        cSum = PhoneFormat::getCsumEvent( event );
         event->setCsum( mProfileName, QString::number( cSum ));
         event->setTempSyncStat( SYNC_TEMPSTATE_NEW_EXTERNAL );
         event->setID( mProfileName,QString::number( id ) );
         ev =  er.next();
     }
     {
         qDebug("reading todos... "); 
         QPtrList<Todo> tr = calendar->rawTodos();
         Todo* ev = tr.first();  
         while ( ev ) {
 
             QStringList cat = ev->categories();
             if ( cat.contains( "MeetingDEF" )) {
                 ev->setCategories( QStringList() );
             }
             int id = ev->pilotId();
+            uint cSum;
+            cSum = PhoneFormat::getCsumTodo( ev );
             Todo *event;
             event = existingCal->todo( mProfileName ,QString::number( id ) );
             if ( event ) {
                 //qDebug("copy todo %s ", event->summary().latin1()); 
 
                 event = (Todo*)event->clone();
                 copyTodo( event,  ev );
                 calendar->deleteTodo( ev );
                 calendar->addTodo( event);
             }
             else
                 event = ev;
-            uint cSum;
-            cSum = PhoneFormat::getCsumTodo( event );
             event->setCsum( mProfileName, QString::number( cSum ));
             event->setTempSyncStat( SYNC_TEMPSTATE_NEW_EXTERNAL );
             event->setID( mProfileName,QString::number( id ) );
             ev =  tr.next();
         }
     }
     return true;
 }
 void PhoneFormat::copyEvent( Event* to,  Event* from )
 {
     if ( from->dtStart().isValid() )
         to->setDtStart(  from->dtStart() );
     if ( from->dtEnd().isValid() )
         to->setDtEnd(  from->dtEnd() );
     if ( !from->location().isEmpty() )
         to->setLocation(  from->location() );
     if ( !from->description().isEmpty() )
         to->setDescription(  from->description() );
     if ( !from->summary().isEmpty() )
         to->setSummary(  from->summary() );
 
     if ( from->alarms().count() ) {
         to->clearAlarms();
         Alarm *a = from->alarms().first();
         Alarm *b = to->newAlarm( );
         b->setEnabled( a->enabled()  );
-        if ( a->hasStartOffset() ) {
-            b->setStartOffset( a->startOffset() );
-        }
-        if ( a->hasTime() )
-            b->setTime( a->time() );
+        b->setStartOffset(Duration( a->offset() ) );
     
     }
     QStringList cat = to->categories();
     QStringList catFrom = from->categories();
     QString nCat;
     int iii;
     for ( iii = 0; iii < catFrom.count();++iii ) {
         nCat = catFrom[iii];
         if ( !nCat.isEmpty() )
             if ( !cat.contains( nCat )) {
                 cat << nCat;
             }
     }
     to->setCategories( cat );
+    if ( from->doesRecur() ) {
     Recurrence * r = new Recurrence( *from->recurrence(),to);
     to->setRecurrence( r ) ;
+    }
 
 
 }
 void PhoneFormat::copyTodo( Todo* to,  Todo* from )
 {
-    if ( from->dtStart().isValid() )
+    if ( from->hasStartDate() ) {
+        to->setHasStartDate( true );
         to->setDtStart(  from->dtStart() );
-    if ( from->dtDue().isValid() )
+    }
+    if ( from->hasDueDate() ){
+        to->setHasDueDate( true );
         to->setDtDue(  from->dtDue() );
+    }
     if ( !from->location().isEmpty() )
         to->setLocation(  from->location() );
     if ( !from->description().isEmpty() )
         to->setDescription(  from->description() );
     if ( !from->summary().isEmpty() )
         to->setSummary(  from->summary() );
 
     if ( from->alarms().count() ) {
         to->clearAlarms();
         Alarm *a = from->alarms().first();
         Alarm *b = to->newAlarm( );
         b->setEnabled( a->enabled()  );
-        if ( a->hasStartOffset() )
-            b->setStartOffset( a->startOffset() );
-        if ( a->hasTime() )
-            b->setTime( a->time() );
+        b->setStartOffset(Duration( a->offset() ) );
     }
    
     QStringList cat = to->categories();
     QStringList catFrom = from->categories();
     QString nCat;
     int iii;
     for ( iii = 0; iii < catFrom.count();++iii ) {
         nCat = catFrom[iii];
         if ( !nCat.isEmpty() )
             if ( !cat.contains( nCat )) {
                 cat << nCat;
             }
     }
     to->setCategories( cat );
     if ( from->isCompleted() ) {
         to->setCompleted( true );
         if( from->completed().isValid() )
             to->setCompleted( from->completed() );
     } else {
         // set percentcomplete only, if to->isCompleted()
         if ( to->isCompleted() )
             to->setPercentComplete(from->percentComplete()); 
     }
     if( to->priority() == 2 && from->priority() == 1 )
         ; //skip
     else if (to->priority() == 4 && from->priority() == 5 )
         ;
     else
         to->setPriority(from->priority());
 
 }
 #include <qcstring.h>
 
-void PhoneFormat::afterSave( Incidence* inc)
+void PhoneFormat::afterSave( Incidence* inc,const QString& id ,const QString& csum)
 {
-    uint csum;
-    inc->removeID( mProfileName );
-    if ( inc->type() == "Event")
-        csum = PhoneFormat::getCsumEvent( (Event*) inc );
-    else
-        csum = PhoneFormat::getCsumTodo( (Todo*) inc );
-    inc->setCsum( mProfileName, QString::number( csum ));
-
+    inc->setID( mProfileName, id );
+    inc->setCsum( mProfileName, csum);
     inc->setTempSyncStat( SYNC_TEMPSTATE_NEW_ID );
 
 }
 
 bool PhoneFormat::writeToPhone( Calendar *  calendar)
 {
 #ifdef _WIN32_
-    QString  fileName = locateLocal("tmp", "tempfile.vcs");
+    QString  fileName = locateLocal("tmp", "phonefile.vcs");
 #else
-    QString  fileName = "/tmp/kdepimtemp.vcs";
+    QString  fileName = "/tmp/phonefile.vcs";
 #endif
 
     VCalFormat vfsave;
     vfsave.setLocalTime ( true ); 
     QString id = calendar->timeZoneId();
     calendar->setLocalTime();
     if ( ! vfsave.save( calendar, fileName ) )
         return false;
     calendar->setTimeZoneId( id );
     return PhoneAccess::writeToPhone( fileName );
 }
 bool PhoneFormat::save( Calendar *calendar)
 {
-    QLabel status ( i18n(" Opening device ..."), 0 );
-    int w = status.sizeHint().width()+20 ;
-    if ( w < 200 ) w = 230;
-    int h = status.sizeHint().height()+20 ;
-    int dw = QApplication::desktop()->width();
-    int dh = QApplication::desktop()->height();
-    status.setCaption(i18n("Writing to phone...") );
-    status.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
-    status.show();
-    status.raise();
-    qApp->processEvents();
-    QString message;
+   
 
     // 1 remove events which should be deleted
     QPtrList<Event> er = calendar->rawEvents();
     Event* ev = er.first();  
     while ( ev ) {
         if ( ev->tempSyncStat() == SYNC_TEMPSTATE_DELETE ) { 
             calendar->deleteEvent( ev );
         } else {
 
         }
         ev =  er.next();
     }
     //  2 remove todos which should be deleted
     QPtrList<Todo> tl = calendar->rawTodos(); 
     Todo* to = tl.first();
     while ( to ) {
         if ( to->tempSyncStat() == SYNC_TEMPSTATE_DELETE ) {
             calendar->deleteTodo( to );   
         } else {
             if ( to->isCompleted()) {
                 calendar->deleteTodo( to );   
             }
         }
         to = tl.next();
     } 
     //  3 save file 
     if ( !writeToPhone( calendar ) )
         return false;
-    
+    QLabel status ( i18n(" Opening device ..."), 0 );
+    int w = status.sizeHint().width()+20 ;
+    if ( w < 200 ) w = 230;
+    int h = status.sizeHint().height()+20 ;
+    int dw = QApplication::desktop()->width();
+    int dh = QApplication::desktop()->height();
+    status.setCaption(i18n("Writing to phone...") );
+    status.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
+    QString message;
+    status.show();
+    status.raise();
+    qApp->processEvents();
     // 5 reread data
     message = i18n(" Rereading all data ... ");
     status.setText ( message  );
     qApp->processEvents();
     CalendarLocal* calendarTemp = new CalendarLocal(); 
     calendarTemp->setTimeZoneId( calendar->timeZoneId());
     if ( ! load( calendarTemp,calendar) ){
         qDebug("error reloading calendar ");
         delete calendarTemp;
         return false;
     }
     // 6 compare data
 
 //algo 6 compare event
     er = calendar->rawEvents();
     ev = er.first(); 
     message = i18n(" Comparing event # ");
     QPtrList<Event> er1 = calendarTemp->rawEvents();
     Event* ev1; 
     int procCount = 0;
     while ( ev ) {
         //qDebug("event new ID %s",ev->summary().latin1()); 
             status.setText ( message + QString::number ( ++procCount ) );
             qApp->processEvents();
-            uint csum;
-            csum = PhoneFormat::getCsumEvent( ev );
-            QString cSum = QString::number( csum );
-            //ev->setCsum( mProfileName,  cSum );
-            //qDebug("Event cSum %s ", cSum.latin1());
             ev1 = er1.first(); 
             while ( ev1 ) {
-                if (  ev1->getCsum( mProfileName ) == cSum ) {
+                if (  ev->contains( ev1 ) ) {
+                    afterSave( ev ,ev1->getID(mProfileName),ev1->getCsum(mProfileName));
                     er1.remove( ev1 );
-                    afterSave( ev );
-                    ev->setID(mProfileName, ev1->getID(mProfileName) );
-                    //qDebug("Event found  on phone for %s ", ev->summary().latin1());
-
                     break;
                 }
                 ev1 =  er1.next();
             } 
             if ( ! ev1 ) {
                 // ev->removeID(mProfileName);
                 qDebug("ERROR: No event found  on phone for %s ", ev->summary().latin1());
             }
             
         
         ev =  er.next();
     }
     //algo 6 compare todo
     tl = calendar->rawTodos(); 
     to = tl.first();
     procCount = 0;
     QPtrList<Todo> tl1 = calendarTemp->rawTodos(); 
     Todo* to1 ;
     message = i18n(" Comparing todo # ");
     while ( to  ) {
             status.setText ( message + QString::number ( ++procCount ) );
             qApp->processEvents();
-            uint csum;
-            csum = PhoneFormat::getCsumTodo( to );
-            QString cSum = QString::number( csum );
-            //to->setCsum( mProfileName,  cSum );
-            //qDebug("Todo cSum %s ", cSum.latin1());
             Todo* to1 = tl1.first(); 
             while ( to1 ) {
-                if (  to1->getCsum( mProfileName ) == cSum ) {
+                if (  to->contains( to1 ) ) {
+                    afterSave( to ,to1->getID(mProfileName),to1->getCsum(mProfileName));
                     tl1.remove( to1 );
-                    afterSave( to );
-                    to->setID(mProfileName, to1->getID(mProfileName) );
                     break;
                 }
                 to1 =  tl1.next();
             }
             if ( ! to1 ) {
                 //to->removeID(mProfileName);
                 qDebug("ERROR: No todo found on phone for %s ", to->summary().latin1());
             }
         
         to = tl.next();
     }
     delete calendarTemp;
     return true;
 
 
 
 }
 
 
 QString PhoneFormat::toString( Calendar * )
 {
     return QString::null;
 }
 bool PhoneFormat::fromString( Calendar *calendar, const QString & text)
 {
     return false;
 }
diff --git a/libkcal/phoneformat.h b/libkcal/phoneformat.h
index 001fd81..d11f68b 100644
--- a/libkcal/phoneformat.h
+++ b/libkcal/phoneformat.h
@@ -1,62 +1,62 @@
 /*
     This file is part of libkcal.
 
     Copyright (c) 2003 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 PHONEFORMAT_H
 #define PHONEFORMAT_H
 
 #include <qstring.h>
 
 #include "scheduler.h"
 
 #include "vcalformat.h"
 #include "calformat.h"
 
 namespace KCal {
 
 /**
   This class implements the calendar format used by Phone.
 */
     class Event;
     class Todo;
 class PhoneFormat : public QObject {
   public:
     /** Create new iCalendar format. */
     PhoneFormat(QString profileName, QString device,QString connection, QString model);
     virtual ~PhoneFormat();
 
     bool load( Calendar * ,Calendar * );
     bool save( Calendar * );
     bool fromString( Calendar *, const QString & );  
     QString toString( Calendar * );
     static ulong getCsum( const QStringList & );
     static ulong getCsumTodo( Todo* to );
     static ulong getCsumEvent( Event* ev );
     static bool writeToPhone( Calendar * );
   private:
     void copyEvent( Event* to,  Event* from );
     void copyTodo( Todo* to,  Todo* from );
     //int initDevice(GSM_StateMachine *s);
     QString mProfileName;
-    void afterSave( Incidence* );
+    void afterSave( Incidence* ,const QString&,const QString&);
 };
 
 }
 
 #endif
diff --git a/libkcal/todo.cpp b/libkcal/todo.cpp
index 0c1e3e4..3d2de61 100644
--- a/libkcal/todo.cpp
+++ b/libkcal/todo.cpp
@@ -1,315 +1,373 @@
 /*
     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 <kglobal.h>
 #include <klocale.h>
 #include <kdebug.h>
 
 #include "todo.h"
 
 using namespace KCal;
 
 Todo::Todo(): Incidence()
 {
 //  mStatus = TENTATIVE;
 
   mHasDueDate = false;
   setHasStartDate( false );
   mCompleted = getEvenTime(QDateTime::currentDateTime());
   mHasCompletedDate = false;
   mPercentComplete = 0;
 }
 
 Todo::Todo(const Todo &t) : Incidence(t)
 {
   mDtDue = t.mDtDue;
   mHasDueDate = t.mHasDueDate;
   mCompleted = t.mCompleted;
   mHasCompletedDate = t.mHasCompletedDate;
   mPercentComplete = t.mPercentComplete;
 }
 
 Todo::~Todo()
 {
 
 }
 
 Incidence *Todo::clone()
 {
   return new Todo(*this);
 }
 
+bool Todo::contains ( Todo* from )
+{ 
 
+    if ( !from->summary().isEmpty() )
+        if (  !summary().startsWith(  from->summary() ))
+            return false;
+    if ( from->hasStartDate() ) {
+        if ( !hasStartDate() )
+            return false;
+        if ( from->dtStart() != dtStart())
+            return false;      
+    }
+    if ( from->hasDueDate() ){
+        if ( !hasDueDate() )
+            return false;
+        if ( from->dtDue() != dtDue())
+            return false;  
+    }
+    if ( !from->location().isEmpty() )
+        if (  !location().startsWith( from->location() ) )
+            return false;
+    if ( !from->description().isEmpty() )
+        if (  !description().startsWith(  from->description() ))
+            return false;
+     if ( from->alarms().count() ) {
+        Alarm *a = from->alarms().first();
+        if (  a->enabled()  ){
+            if ( !alarms().count() )
+                return false;
+            Alarm *b = alarms().first();
+            if( ! b->enabled() )
+                return false;
+            if ( ! (a->offset() == b->offset() ))
+                return false;
+        }
+    }
+   
+    QStringList cat = categories();
+    QStringList catFrom = from->categories();
+    QString nCat;
+    int iii;
+    for ( iii = 0; iii < catFrom.count();++iii ) {
+        nCat = catFrom[iii];
+        if ( !nCat.isEmpty() )
+            if ( !cat.contains( nCat )) {
+                return false;
+            }
+    }
+    if ( from->isCompleted() ) {
+        if ( !isCompleted() )
+            return false;
+    }
+    if( priority() !=  from->priority() )
+        return false;
+
+
+    return true;
+
+}
 bool KCal::operator==( const Todo& t1, const Todo& t2 )
 {
 
     bool ret = operator==( (const Incidence&)t1, (const Incidence&)t2 );
     if ( ! ret )
         return false;
     if (  t1.hasDueDate() == t2.hasDueDate() ) {
         if ( t1.hasDueDate() ) {
             if ( t1.doesFloat() == t2.doesFloat() ) {
                 if ( t1.doesFloat() ) {
                     if ( t1.dtDue().date() != t2.dtDue().date() )
                         return false;
                 } else
                     if ( t1.dtDue() != t2.dtDue() ) 
                         return false;
             } else
                 return false;// float !=
         }
         
     } else
         return false;
     if ( t1.percentComplete() != t2.percentComplete() )
         return false;
     if ( t1.isCompleted() ) {
         if (  t1.hasCompletedDate() == t2.hasCompletedDate() ) {
             if ( t1.hasCompletedDate() ) {
                 if ( t1.completed() != t2.completed() )
                     return false;
             }
             
         } else
             return false;
     }
     return true;
 
 }
 
 void Todo::setDtDue(const QDateTime &dtDue)
 {
   //int diffsecs = mDtDue.secsTo(dtDue);
 
   /*if (mReadOnly) return;
   const QPtrList<Alarm>& alarms = alarms();
   for (Alarm* alarm = alarms.first(); alarm; alarm = alarms.next()) {
     if (alarm->enabled()) {
       alarm->setTime(alarm->time().addSecs(diffsecs));
     }
   }*/
   mDtDue = getEvenTime(dtDue);
 
   //kdDebug(5800) << "setDtDue says date is " << mDtDue.toString() << endl;
 
   /*const QPtrList<Alarm>& alarms = alarms();
   for (Alarm* alarm = alarms.first(); alarm; alarm = alarms.next())
     alarm->setAlarmStart(mDtDue);*/
 
   updated();
 }
 
 QDateTime Todo::dtDue() const
 {
   return mDtDue;
 }
 
 QString Todo::dtDueTimeStr() const
 {
   return KGlobal::locale()->formatTime(mDtDue.time());
 }
 
 QString Todo::dtDueDateStr(bool shortfmt) const
 {
   return KGlobal::locale()->formatDate(mDtDue.date(),shortfmt);
 }
 
 QString Todo::dtDueStr(bool shortfmt) const
 {
   return KGlobal::locale()->formatDateTime(mDtDue, shortfmt);
 }
 
 bool Todo::hasDueDate() const
 {
   return mHasDueDate;
 }
 
 void Todo::setHasDueDate(bool f)
 {
   if (mReadOnly) return;
   mHasDueDate = f;
   updated();
 }
 
 
 #if 0
 void Todo::setStatus(const QString &statStr)
 {
   if (mReadOnly) return;
   QString ss(statStr.upper());
 
   if (ss == "X-ACTION")
     mStatus = NEEDS_ACTION;
   else if (ss == "NEEDS ACTION")
     mStatus = NEEDS_ACTION;
   else if (ss == "ACCEPTED")
     mStatus = ACCEPTED;
   else if (ss == "SENT")
     mStatus = SENT;
   else if (ss == "TENTATIVE")
     mStatus = TENTATIVE;
   else if (ss == "CONFIRMED")
     mStatus = CONFIRMED;
   else if (ss == "DECLINED")
     mStatus = DECLINED;
   else if (ss == "COMPLETED")
     mStatus = COMPLETED;
   else if (ss == "DELEGATED")
     mStatus = DELEGATED;
 
   updated();
 }
 
 void Todo::setStatus(int status)
 {
   if (mReadOnly) return;
   mStatus = status;
   updated();
 }
 
 int Todo::status() const
 {
   return mStatus;
 }
 
 QString Todo::statusStr() const
 {
   switch(mStatus) {
   case NEEDS_ACTION:
     return QString("NEEDS ACTION");
     break;
   case ACCEPTED:
     return QString("ACCEPTED");
     break;
   case SENT:
     return QString("SENT");
     break;
   case TENTATIVE:
     return QString("TENTATIVE");
     break;
   case CONFIRMED:
     return QString("CONFIRMED");
     break;
   case DECLINED:
     return QString("DECLINED");
     break;
   case COMPLETED:
     return QString("COMPLETED");
     break;
   case DELEGATED:
     return QString("DELEGATED");
     break;
   }
   return QString("");
 }
 #endif
 
 bool Todo::isCompleted() const
 {
   if (mPercentComplete == 100) return true;
   else return false;
 }
 
 void Todo::setCompleted(bool completed)
 {
   if (completed) mPercentComplete = 100;
   else mPercentComplete = 0;
   updated();
 }
 
 QDateTime Todo::completed() const
 {
   return mCompleted;
 }
 
 QString Todo::completedStr() const
 {
   return KGlobal::locale()->formatDateTime(mCompleted);
 }
 
 void Todo::setCompleted(const QDateTime &completed)
 {
   mHasCompletedDate = true;
   mPercentComplete = 100;
   mCompleted = getEvenTime(completed);
   updated();
 }
 
 bool Todo::hasCompletedDate() const
 {
   return mHasCompletedDate;
 }
 
 int Todo::percentComplete() const
 {
   return mPercentComplete;
 }
 
 void Todo::setPercentComplete(int v)
 {
   mPercentComplete = v;
   updated();
 }
 QDateTime Todo::getNextAlarmDateTime( bool * ok, int * offset ) const
 {
     if ( isCompleted() || ! hasDueDate() || cancelled() ) {
          *ok = false;
          return QDateTime ();
      }
      QDateTime incidenceStart;
      incidenceStart = dtDue(); 
      bool enabled = false;
      Alarm* alarm;
      int off;
      QDateTime alarmStart = QDateTime::currentDateTime().addDays( 3650 );;
     //  if ( QDateTime::currentDateTime() > incidenceStart ){
 //          *ok = false;
 //          return incidenceStart;
 //      }
      for (QPtrListIterator<Alarm> it(mAlarms); (alarm = it.current()) != 0; ++it) {
          if (alarm->enabled()) {
              if ( alarm->hasTime () ) {
                  if ( alarm->time() < alarmStart ) {
                      alarmStart = alarm->time();
                      enabled = true;
                      off = alarmStart.secsTo( incidenceStart );
                  }
 
              } else {
                  int secs = alarm->startOffset().asSeconds();
                  if ( incidenceStart.addSecs( secs ) < alarmStart ) {
                      alarmStart = incidenceStart.addSecs( secs );
                      enabled = true;
                      off = -secs;
                  }
              }
          }
      }
      if ( enabled ) {
          if ( alarmStart >  QDateTime::currentDateTime()  ) {
              *ok = true;
              * offset = off;
              return alarmStart;
          }
      }
      *ok = false;
      return QDateTime ();
 
 }
diff --git a/libkcal/todo.h b/libkcal/todo.h
index 9aa92f8..0f22c59 100644
--- a/libkcal/todo.h
+++ b/libkcal/todo.h
@@ -1,121 +1,122 @@
 /*
     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 TODO_H
 #define TODO_H
 //
 // Todo component, representing a VTODO object
 //
 
 #include "incidence.h"
 
 namespace KCal {
 
 /**
   This class provides a Todo in the sense of RFC2445.
 */
 class Todo : public Incidence
 {
   public:
     Todo();
     Todo(const Todo &);
     ~Todo();
     typedef ListBase<Todo> List;
     QCString type() const { return "Todo"; }
 
     /** Return an exact copy of this todo. */
     Incidence *clone();
     QDateTime getNextAlarmDateTime( bool * ok, int * offset ) const;
 
     /** for setting the todo's due date/time with a QDateTime. */
     void setDtDue(const QDateTime &dtDue);
     /** returns an event's Due date/time as a QDateTime. */
     QDateTime dtDue() const;
     /** returns an event's due time as a string formatted according to the
      users locale settings */
     QString dtDueTimeStr() const;
     /** returns an event's due date as a string formatted according to the
      users locale settings */
     QString dtDueDateStr(bool shortfmt=true) const;
     /** returns an event's due date and time as a string formatted according
      to the users locale settings */
     QString dtDueStr(bool shortfmt=true) const;
 
     /** returns TRUE or FALSE depending on whether the todo has a due date */
     bool hasDueDate() const;
     /** sets the event's hasDueDate value. */
     void setHasDueDate(bool f);
 
  
     /** sets the event's status to the string specified.  The string
      * must be a recognized value for the status field, i.e. a string
      * equivalent of the possible status enumerations previously described. */
 //    void setStatus(const QString &statStr);
     /** sets the event's status to the value specified.  See the enumeration
      * above for possible values. */
 //    void setStatus(int);
     /** return the event's status. */
 //    int status() const;
     /** return the event's status in string format. */
 //    QString statusStr() const;
 
     /** return, if this todo is completed */
     bool isCompleted() const;
     /** set completed state of this todo */
     void setCompleted(bool);
     
     /**
       Return how many percent of the task are completed. Returns a value
       between 0 and 100.
     */
     int percentComplete() const;
     /**
       Set how many percent of the task are completed. Valid values are in the
       range from 0 to 100.
     */
     void setPercentComplete(int);
 
     /** return date and time when todo was completed */
     QDateTime completed() const;
     QString completedStr() const;
     /** set date and time of completion */
     void setCompleted(const QDateTime &completed);
 
     /** Return true, if todo has a date associated with completion */
     bool hasCompletedDate() const;
+    bool contains ( Todo*);
     
   private:
     bool accept(Visitor &v) { return v.visit(this); }
 
     QDateTime mDtDue;                     // due date of todo
 
     bool mHasDueDate;                    // if todo has associated due date
 
 //    int  mStatus;                         // confirmed/delegated/tentative/etc
 
     QDateTime mCompleted;
     bool mHasCompletedDate;
 
     int mPercentComplete;
 };
 
     bool operator==( const Todo&, const Todo& );
 }
 
 #endif
diff --git a/libkcal/vcalformat.cpp b/libkcal/vcalformat.cpp
index a6ae1bc..df93209 100644
--- a/libkcal/vcalformat.cpp
+++ b/libkcal/vcalformat.cpp
@@ -1,348 +1,350 @@
 /*
     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();
+  if ( ! useLocalTime )
   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;
+  if ( ! useLocalTime )
   useLocalTime = mCalendar->isLocalTime();
 
   QString tmpStr;
   VObject *vcal, *vo;
 
 
   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)) {
     return true;
   } else  {
     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 {
       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()) {
@@ -919,795 +921,800 @@ Event* VCalFormat::VEventToEvent(VObject *vevent)
   // unique id
   vo = isAPropertyOf(vevent, VCUniqueStringProp);
   // while the UID property is preferred, it is not required.  We'll use the
   // default Event UID if none is given.
   if (vo) {
     anEvent->setUid(s = fakeCString(vObjectUStringZValue(vo)));
     deleteStr(s);
   }
 
   // revision
   // again NSCAL doesn't give us much to work with, so we improvise...
   if ((vo = isAPropertyOf(vevent, VCSequenceProp)) != 0) {
     anEvent->setRevision(atoi(s = fakeCString(vObjectUStringZValue(vo))));
     deleteStr(s);
   }
   else
     anEvent->setRevision(0);
 
   // last modification date
   if ((vo = isAPropertyOf(vevent, VCLastModifiedProp)) != 0) {
     anEvent->setLastModified(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo))));
     deleteStr(s);
   }
   else
     anEvent->setLastModified(QDateTime(QDate::currentDate(),
 				       QTime::currentTime()));
 
   // organizer
   // if our extension property for the event's ORGANIZER exists, add it.
   if ((vo = isAPropertyOf(vevent, ICOrganizerProp)) != 0) {
     anEvent->setOrganizer(s = fakeCString(vObjectUStringZValue(vo)));
     deleteStr(s);
   } else {
     anEvent->setOrganizer(mCalendar->getEmail());
   }
 
   // deal with attendees.
   initPropIterator(&voi, vevent);
   while (moreIteration(&voi)) {
     vo = nextVObject(&voi);
     if (strcmp(vObjectName(vo), VCAttendeeProp) == 0) {
       Attendee *a;
       VObject *vp;
       s = fakeCString(vObjectUStringZValue(vo));
       QString tmpStr = QString::fromLocal8Bit(s);
       deleteStr(s);
       tmpStr = tmpStr.simplifyWhiteSpace();
       int emailPos1, emailPos2;
       if ((emailPos1 = tmpStr.find('<')) > 0) {
 	// both email address and name
 	emailPos2 = tmpStr.findRev('>');
 	a = new Attendee(tmpStr.left(emailPos1 - 1),
 			 tmpStr.mid(emailPos1 + 1,
 				    emailPos2 - (emailPos1 + 1)));
       } else if (tmpStr.find('@') > 0) {
 	// just an email address
 	a = new Attendee(0, tmpStr);
       } else {
 	// just a name
         QString email = tmpStr.replace( QRegExp(" "), "." );
 	a = new Attendee(tmpStr,email);
       }
 
       // is there an RSVP property?
       if ((vp = isAPropertyOf(vo, VCRSVPProp)) != 0)
 	a->setRSVP(vObjectStringZValue(vp));
       // is there a status property?
       if ((vp = isAPropertyOf(vo, VCStatusProp)) != 0)
 	a->setStatus(readStatus(vObjectStringZValue(vp)));
       // add the attendee
       anEvent->addAttendee(a);
     }
   }
 
   // This isn't strictly true.  An event that doesn't have a start time
   // or an end time doesn't "float", it has an anchor in time but it doesn't
   // "take up" any time.
   /*if ((isAPropertyOf(vevent, VCDTstartProp) == 0) ||
       (isAPropertyOf(vevent, VCDTendProp) == 0)) {
     anEvent->setFloats(TRUE);
     } else {
     }*/
 
   anEvent->setFloats(FALSE);
 
   // start time
   if ((vo = isAPropertyOf(vevent, VCDTstartProp)) != 0) {
     anEvent->setDtStart(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo))));
     //    kdDebug(5800) << "s is " << //	  s << ", ISO is " << ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo))).toString() << endl;
     deleteStr(s);
     if (anEvent->dtStart().time().isNull())
       anEvent->setFloats(TRUE);
   }
 
   // stop time
   if ((vo = isAPropertyOf(vevent, VCDTendProp)) != 0) {
     anEvent->setDtEnd(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo))));
       deleteStr(s);
       if (anEvent->dtEnd().time().isNull())
 	anEvent->setFloats(TRUE);
   }
 
   // at this point, there should be at least a start or end time.
   // fix up for events that take up no time but have a time associated
   if (!(vo = isAPropertyOf(vevent, VCDTstartProp)))
     anEvent->setDtStart(anEvent->dtEnd());
   if (!(vo = isAPropertyOf(vevent, VCDTendProp)))
     anEvent->setDtEnd(anEvent->dtStart());
 
   ///////////////////////////////////////////////////////////////////////////
 
   // repeat stuff
   if ((vo = isAPropertyOf(vevent, VCRRuleProp)) != 0) {
     QString tmpStr = (s = fakeCString(vObjectUStringZValue(vo)));
     deleteStr(s);
     tmpStr.simplifyWhiteSpace();
     tmpStr = tmpStr.upper();
 
     /********************************* DAILY ******************************/
     if (tmpStr.left(1) == "D") {
       int index = tmpStr.find(' ');
       int rFreq = tmpStr.mid(1, (index-1)).toInt();
       index = tmpStr.findRev(' ') + 1; // advance to last field
       if (tmpStr.mid(index,1) == "#") index++;
       if (tmpStr.find('T', index) != -1) {
 	QDate rEndDate = (ISOToQDateTime(tmpStr.mid(index, tmpStr.length()-index))).date();
 	anEvent->recurrence()->setDaily(rFreq, rEndDate);
       } else {
 	int rDuration = tmpStr.mid(index, tmpStr.length()-index).toInt();
 	if (rDuration == 0) // VEvents set this to 0 forever, we use -1
 	  anEvent->recurrence()->setDaily(rFreq, -1);
 	else
 	  anEvent->recurrence()->setDaily(rFreq, rDuration);
       }
     }
     /********************************* WEEKLY ******************************/
     else if (tmpStr.left(1) == "W") {
       int index = tmpStr.find(' ');
       int last = tmpStr.findRev(' ') + 1;
       int rFreq = tmpStr.mid(1, (index-1)).toInt();
       index += 1; // advance to beginning of stuff after freq
       QBitArray qba(7);
       QString dayStr;
       if( index == last ) {
 	// e.g. W1 #0
 	qba.setBit(anEvent->dtStart().date().dayOfWeek() - 1);
       }
       else {
 	// e.g. W1 SU #0
 	while (index < last) {
 	  dayStr = tmpStr.mid(index, 3);
 	  int dayNum = numFromDay(dayStr);
 	  qba.setBit(dayNum);
 	  index += 3; // advance to next day, or possibly "#"
 	}
       }
       index = last; if (tmpStr.mid(index,1) == "#") index++;
       if (tmpStr.find('T', index) != -1) {
 	QDate rEndDate = (ISOToQDateTime(tmpStr.mid(index, tmpStr.length()-index))).date();
 	anEvent->recurrence()->setWeekly(rFreq, qba, rEndDate);
       } else {
 	int rDuration = tmpStr.mid(index, tmpStr.length()-index).toInt();
 	if (rDuration == 0)
 	  anEvent->recurrence()->setWeekly(rFreq, qba, -1);
 	else
 	  anEvent->recurrence()->setWeekly(rFreq, qba, rDuration);
       }
     }
     /**************************** MONTHLY-BY-POS ***************************/
     else if (tmpStr.left(2) == "MP") {
       int index = tmpStr.find(' ');
       int last = tmpStr.findRev(' ') + 1;
       int rFreq = tmpStr.mid(2, (index-1)).toInt();
       index += 1; // advance to beginning of stuff after freq
       QBitArray qba(7);
       short tmpPos;
       if( index == last ) {
 	// e.g. MP1 #0
 	tmpPos = anEvent->dtStart().date().day()/7 + 1;
 	if( tmpPos == 5 )
 	  tmpPos = -1;
 	qba.setBit(anEvent->dtStart().date().dayOfWeek() - 1);
 	anEvent->recurrence()->addMonthlyPos(tmpPos, qba);
       }
       else {
 	// e.g. MP1 1+ SU #0
 	while (index < last) {
 	  tmpPos = tmpStr.mid(index,1).toShort();
 	  index += 1;
 	  if (tmpStr.mid(index,1) == "-")
 	    // convert tmpPos to negative
 	    tmpPos = 0 - tmpPos;
 	  index += 2; // advance to day(s)
 	  while (numFromDay(tmpStr.mid(index,3)) >= 0) {
 	    int dayNum = numFromDay(tmpStr.mid(index,3));
 	    qba.setBit(dayNum);
 	    index += 3; // advance to next day, or possibly pos or "#"
 	  }
 	  anEvent->recurrence()->addMonthlyPos(tmpPos, qba);
 	  qba.detach();
 	  qba.fill(FALSE); // clear out
 	} // while != "#"
       }
       index = last; if (tmpStr.mid(index,1) == "#") index++;
       if (tmpStr.find('T', index) != -1) {
 	QDate rEndDate = (ISOToQDateTime(tmpStr.mid(index, tmpStr.length() -
 						    index))).date();
 	anEvent->recurrence()->setMonthly(Recurrence::rMonthlyPos, rFreq, rEndDate);
       } else {
 	int rDuration = tmpStr.mid(index, tmpStr.length()-index).toInt();
 	if (rDuration == 0)
 	  anEvent->recurrence()->setMonthly(Recurrence::rMonthlyPos, rFreq, -1);
 	else
 	  anEvent->recurrence()->setMonthly(Recurrence::rMonthlyPos, rFreq, rDuration);
       }
     }
 
     /**************************** MONTHLY-BY-DAY ***************************/
     else if (tmpStr.left(2) == "MD") {
       int index = tmpStr.find(' ');
       int last = tmpStr.findRev(' ') + 1;
       int rFreq = tmpStr.mid(2, (index-1)).toInt();
       index += 1;
       short tmpDay;
       if( index == last ) {
 	// e.g. MD1 #0
 	tmpDay = anEvent->dtStart().date().day();
 	anEvent->recurrence()->addMonthlyDay(tmpDay);
       }
       else {
 	// e.g. MD1 3 #0
 	while (index < last) {
 	  int index2 = tmpStr.find(' ', index);
 	  tmpDay = tmpStr.mid(index, (index2-index)).toShort();
 	  index = index2-1;
 	  if (tmpStr.mid(index, 1) == "-")
 	    tmpDay = 0 - tmpDay;
 	  index += 2; // advance the index;
 	  anEvent->recurrence()->addMonthlyDay(tmpDay);
 	} // while != #
       }
       index = last; if (tmpStr.mid(index,1) == "#") index++;
       if (tmpStr.find('T', index) != -1) {
 	QDate rEndDate = (ISOToQDateTime(tmpStr.mid(index, tmpStr.length()-index))).date();
 	anEvent->recurrence()->setMonthly(Recurrence::rMonthlyDay, rFreq, rEndDate);
       } else {
 	int rDuration = tmpStr.mid(index, tmpStr.length()-index).toInt();
 	if (rDuration == 0)
 	  anEvent->recurrence()->setMonthly(Recurrence::rMonthlyDay, rFreq, -1);
 	else
 	  anEvent->recurrence()->setMonthly(Recurrence::rMonthlyDay, rFreq, rDuration);
       }
     }
 
     /*********************** YEARLY-BY-MONTH *******************************/
     else if (tmpStr.left(2) == "YM") {
+        // we have to set this such that recurrence accepts addYearlyNum(tmpDay);
+        anEvent->recurrence()->setYearly(Recurrence::rYearlyMonth, 1, -1);
       int index = tmpStr.find(' ');
       int last = tmpStr.findRev(' ') + 1;
       int rFreq = tmpStr.mid(2, (index-1)).toInt();
       index += 1;
       short tmpMonth;
       if( index == last ) {
 	// e.g. YM1 #0
 	tmpMonth = anEvent->dtStart().date().month();
 	anEvent->recurrence()->addYearlyNum(tmpMonth);
       }
       else {
 	// e.g. YM1 3 #0
 	while (index < last) {
 	  int index2 = tmpStr.find(' ', index);
 	  tmpMonth = tmpStr.mid(index, (index2-index)).toShort();
 	  index = index2+1;
 	  anEvent->recurrence()->addYearlyNum(tmpMonth);
 	} // while != #
       }
       index = last; if (tmpStr.mid(index,1) == "#") index++;
       if (tmpStr.find('T', index) != -1) {
 	QDate rEndDate = (ISOToQDateTime(tmpStr.mid(index, tmpStr.length()-index))).date();
 	anEvent->recurrence()->setYearly(Recurrence::rYearlyMonth, rFreq, rEndDate);
       } else {
 	int rDuration = tmpStr.mid(index, tmpStr.length()-index).toInt();
 	if (rDuration == 0)
 	  anEvent->recurrence()->setYearly(Recurrence::rYearlyMonth, rFreq, -1);
 	else
 	  anEvent->recurrence()->setYearly(Recurrence::rYearlyMonth, rFreq, rDuration);
       }
     }
 
     /*********************** YEARLY-BY-DAY *********************************/
     else if (tmpStr.left(2) == "YD") {
+        // we have to set this such that recurrence accepts addYearlyNum(tmpDay);
+        anEvent->recurrence()->setYearly(Recurrence::rYearlyDay, 1, -1);
       int index = tmpStr.find(' ');
       int last = tmpStr.findRev(' ') + 1;
       int rFreq = tmpStr.mid(2, (index-1)).toInt();
       index += 1;
       short tmpDay;
       if( index == last ) {
 	// e.g. YD1 #0
 	tmpDay = anEvent->dtStart().date().dayOfYear();
 	anEvent->recurrence()->addYearlyNum(tmpDay);
       }
       else {
 	// e.g. YD1 123 #0
 	while (index < last) {
 	  int index2 = tmpStr.find(' ', index);
 	  tmpDay = tmpStr.mid(index, (index2-index)).toShort();
 	  index = index2+1;
 	  anEvent->recurrence()->addYearlyNum(tmpDay);
 	} // while != #
       }
       index = last; if (tmpStr.mid(index,1) == "#") index++;
       if (tmpStr.find('T', index) != -1) {
 	QDate rEndDate = (ISOToQDateTime(tmpStr.mid(index, tmpStr.length()-index))).date();
 	anEvent->recurrence()->setYearly(Recurrence::rYearlyDay, rFreq, rEndDate);
       } else {
 	int rDuration = tmpStr.mid(index, tmpStr.length()-index).toInt();
 	if (rDuration == 0)
 	  anEvent->recurrence()->setYearly(Recurrence::rYearlyDay, rFreq, -1);
 	else
 	  anEvent->recurrence()->setYearly(Recurrence::rYearlyDay, rFreq, rDuration);
       }
     } else {
       kdDebug(5800) << "we don't understand this type of recurrence!" << endl;
     } // if
   } // repeats
 
 
   // recurrence exceptions
   if ((vo = isAPropertyOf(vevent, VCExpDateProp)) != 0) {
     s = fakeCString(vObjectUStringZValue(vo));
     QStringList exDates = QStringList::split(",",s);
     QStringList::ConstIterator it;
     for(it = exDates.begin(); it != exDates.end(); ++it ) {
       anEvent->addExDate(ISOToQDate(*it));
     }
     deleteStr(s);
   }
 
   // summary
   if ((vo = isAPropertyOf(vevent, VCSummaryProp))) {
     s = fakeCString(vObjectUStringZValue(vo));
     anEvent->setSummary(QString::fromLocal8Bit(s));
     deleteStr(s);
   }
   if ((vo = isAPropertyOf(vevent, VCLocationProp))) {
     s = fakeCString(vObjectUStringZValue(vo));
     anEvent->setLocation(QString::fromLocal8Bit(s));
     deleteStr(s);
   }
 
   // description
   if ((vo = isAPropertyOf(vevent, VCDescriptionProp)) != 0) {
     s = fakeCString(vObjectUStringZValue(vo));
     if (!anEvent->description().isEmpty()) {
       anEvent->setDescription(anEvent->description() + "\n" +
 			      QString::fromLocal8Bit(s));
     } else {
       anEvent->setDescription(QString::fromLocal8Bit(s));
     }
     deleteStr(s);
   }
 
   // some stupid vCal exporters ignore the standard and use Description
   // instead of Summary for the default field.  Correct for this.
   if (anEvent->summary().isEmpty() &&
       !(anEvent->description().isEmpty())) {
     QString tmpStr = anEvent->description().simplifyWhiteSpace();
     anEvent->setDescription("");
     anEvent->setSummary(tmpStr);
   }
 
 #if 0
   // status
   if ((vo = isAPropertyOf(vevent, VCStatusProp)) != 0) {
     QString tmpStr(s = fakeCString(vObjectUStringZValue(vo)));
     deleteStr(s);
 // TODO: Define Event status
 //    anEvent->setStatus(tmpStr);
   }
   else
 //    anEvent->setStatus("NEEDS ACTION");
 #endif
 
   // secrecy
   int secrecy = Incidence::SecrecyPublic;
   if ((vo = isAPropertyOf(vevent, VCClassProp)) != 0) {
     s = fakeCString(vObjectUStringZValue(vo));
     if (strcmp(s,"PRIVATE") == 0) {
       secrecy = Incidence::SecrecyPrivate;
     } else if (strcmp(s,"CONFIDENTIAL") == 0) {
       secrecy = Incidence::SecrecyConfidential;
     }
     deleteStr(s);
   }
   anEvent->setSecrecy(secrecy);
 
   // categories
   QStringList tmpStrList;
   int index1 = 0;
   int index2 = 0;
   if ((vo = isAPropertyOf(vevent, VCCategoriesProp)) != 0) {
     s = fakeCString(vObjectUStringZValue(vo));
     QString categories = QString::fromLocal8Bit(s);
     deleteStr(s);
     //const char* category;
     QString category;
     while ((index2 = categories.find(',', index1)) != -1) {
 	//category = (const char *) categories.mid(index1, (index2 - index1));
       category = categories.mid(index1, (index2 - index1));
       tmpStrList.append(category);
       index1 = index2+1;
     }
     // get last category
     category = categories.mid(index1, (categories.length()-index1));
     tmpStrList.append(category);
     anEvent->setCategories(tmpStrList);
   }
 
   // attachments
   tmpStrList.clear();
   initPropIterator(&voi, vevent);
   while (moreIteration(&voi)) {
     vo = nextVObject(&voi);
     if (strcmp(vObjectName(vo), VCAttachProp) == 0) {
       s = fakeCString(vObjectUStringZValue(vo));
       anEvent->addAttachment(new Attachment(QString(s)));
       deleteStr(s);
     }
   }
 
   // resources
   if ((vo = isAPropertyOf(vevent, VCResourcesProp)) != 0) {
     QString resources = (s = fakeCString(vObjectUStringZValue(vo)));
     deleteStr(s);
     tmpStrList.clear();
     index1 = 0;
     index2 = 0;
     QString resource;
     while ((index2 = resources.find(';', index1)) != -1) {
       resource = resources.mid(index1, (index2 - index1));
       tmpStrList.append(resource);
       index1 = index2;
     }
     anEvent->setResources(tmpStrList);
   }
 
   /* alarm stuff */
   if ((vo = isAPropertyOf(vevent, VCDAlarmProp))) {
     Alarm* alarm = anEvent->newAlarm();
     VObject *a;
     if ((a = isAPropertyOf(vo, VCRunTimeProp))) {
       alarm->setTime(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(a))));
       deleteStr(s);
     }
     alarm->setEnabled(true);
     if ((vo = isAPropertyOf(vevent, VCPAlarmProp))) {
       if ((a = isAPropertyOf(vo, VCProcedureNameProp))) {
 	s = fakeCString(vObjectUStringZValue(a));
 	alarm->setProcedureAlarm(QFile::decodeName(s));
 	deleteStr(s);
       }
     }
     if ((vo = isAPropertyOf(vevent, VCAAlarmProp))) {
       if ((a = isAPropertyOf(vo, VCAudioContentProp))) {
 	s = fakeCString(vObjectUStringZValue(a));
 	alarm->setAudioAlarm(QFile::decodeName(s));
 	deleteStr(s);
       }
     }
   }
 
   // priority
   if ((vo = isAPropertyOf(vevent, VCPriorityProp))) {
     anEvent->setPriority(atoi(s = fakeCString(vObjectUStringZValue(vo))));
     deleteStr(s);
   }
 
   // transparency
   if ((vo = isAPropertyOf(vevent, VCTranspProp)) != 0) {
     int i = atoi(s = fakeCString(vObjectUStringZValue(vo)));
     anEvent->setTransparency( i == 1 ? Event::Transparent : Event::Opaque );
     deleteStr(s);
   }
 
   // related event
   if ((vo = isAPropertyOf(vevent, VCRelatedToProp)) != 0) {
     anEvent->setRelatedToUid(s = fakeCString(vObjectUStringZValue(vo)));
     deleteStr(s);
     mEventsRelate.append(anEvent);
   }
 
   /* PILOT SYNC STUFF */
   if ((vo = isAPropertyOf(vevent, XPilotIdProp))) {
     anEvent->setPilotId(atoi(s = fakeCString(vObjectUStringZValue(vo))));
     deleteStr(s);
   }
   else
     anEvent->setPilotId(0);
 
   if ((vo = isAPropertyOf(vevent, XPilotStatusProp))) {
     anEvent->setSyncStatus(atoi(s = fakeCString(vObjectUStringZValue(vo))));
     deleteStr(s);
   }
   else
     anEvent->setSyncStatus(Event::SYNCMOD);
 
   return anEvent;
 }
 
 
 QString VCalFormat::qDateToISO(const QDate &qd)
 {
   QString tmpStr;
 
   ASSERT(qd.isValid());
 
   tmpStr.sprintf("%.2d%.2d%.2d",
 		 qd.year(), qd.month(), qd.day());
   return tmpStr;
 
 }
 
 QString VCalFormat::qDateTimeToISO(const QDateTime &qdt, bool zulu)
 {
   QString tmpStr;
 
   ASSERT(qdt.date().isValid());
   ASSERT(qdt.time().isValid());
   if (zulu && !useLocalTime ) {
     QDateTime tmpDT = qdt.addSecs ( -KGlobal::locale()->localTimeOffset( qdt )*60);
     tmpStr.sprintf("%.2d%.2d%.2dT%.2d%.2d%.2dZ",
 		   tmpDT.date().year(), tmpDT.date().month(),
 		   tmpDT.date().day(), tmpDT.time().hour(),
 		   tmpDT.time().minute(), tmpDT.time().second());
   } else {
     tmpStr.sprintf("%.2d%.2d%.2dT%.2d%.2d%.2d",
 		   qdt.date().year(), qdt.date().month(),
 		   qdt.date().day(), qdt.time().hour(),
 		   qdt.time().minute(), qdt.time().second());
   }
   return tmpStr;
 }
 
 QDateTime VCalFormat::ISOToQDateTime(const QString & dtStr)
 {
   QDate tmpDate;
   QTime tmpTime;
   QString tmpStr;
   int year, month, day, hour, minute, second;
 
   tmpStr = dtStr;
   year = tmpStr.left(4).toInt();
   month = tmpStr.mid(4,2).toInt();
   day = tmpStr.mid(6,2).toInt();
   hour = tmpStr.mid(9,2).toInt();
   minute = tmpStr.mid(11,2).toInt();
   second = tmpStr.mid(13,2).toInt();
   tmpDate.setYMD(year, month, day);
   tmpTime.setHMS(hour, minute, second);
 
   ASSERT(tmpDate.isValid());
   ASSERT(tmpTime.isValid());
   QDateTime tmpDT(tmpDate, tmpTime);
   // correct for GMT if string is in Zulu format
   if (dtStr.at(dtStr.length()-1) == 'Z')
     tmpDT = tmpDT.addSecs (KGlobal::locale()->localTimeOffset( tmpDT )*60);
   return tmpDT;
 }
 
 QDate VCalFormat::ISOToQDate(const QString &dateStr)
 {
   int year, month, day;
 
   year = dateStr.left(4).toInt();
   month = dateStr.mid(4,2).toInt();
   day = dateStr.mid(6,2).toInt();
 
   return(QDate(year, month, day));
 }
 
 // take a raw vcalendar (i.e. from a file on disk, clipboard, etc. etc.
 // and break it down from it's tree-like format into the dictionary format
 // that is used internally in the VCalFormat.
 void VCalFormat::populate(VObject *vcal)
 {
   // this function will populate the caldict dictionary and other event
   // lists. It turns vevents into Events and then inserts them.
 
   VObjectIterator i;
   VObject *curVO, *curVOProp;
   Event *anEvent;
 
   if ((curVO = isAPropertyOf(vcal, ICMethodProp)) != 0) {
     char *methodType = 0;
     methodType = fakeCString(vObjectUStringZValue(curVO));
     kdDebug() << "This calendar is an iTIP transaction of type '"
               << methodType << "'" << endl;
     delete methodType;
   }
 
   // warn the user that we might have trouble reading non-known calendar.
   if ((curVO = isAPropertyOf(vcal, VCProdIdProp)) != 0) {
     char *s = fakeCString(vObjectUStringZValue(curVO));
     if (strcmp(productId().local8Bit(), s) != 0)
       kdDebug() << "This vCalendar file was not created by KOrganizer "
                    "or any other product we support. Loading anyway..." << endl;
     mLoadedProductId = s;
     deleteStr(s);
   }
 
   // warn the user we might have trouble reading this unknown version.
   if ((curVO = isAPropertyOf(vcal, VCVersionProp)) != 0) {
     char *s = fakeCString(vObjectUStringZValue(curVO));
     if (strcmp(_VCAL_VERSION, s) != 0)
       kdDebug() << "This vCalendar file has version " << s
                 << "We only support " << _VCAL_VERSION << endl;
     deleteStr(s);
   }
 
   // set the time zone
   if ((curVO = isAPropertyOf(vcal, VCTimeZoneProp)) != 0) {
+      if ( vObjectUStringZValue(curVO) != 0 ) {
     char *s = fakeCString(vObjectUStringZValue(curVO));
     mCalendar->setTimeZone(s);
     deleteStr(s);
   }
-
+  }
 
   // Store all events with a relatedTo property in a list for post-processing
   mEventsRelate.clear();
   mTodosRelate.clear();
 
   initPropIterator(&i, vcal);
 
   // go through all the vobjects in the vcal
   while (moreIteration(&i)) {
     curVO = nextVObject(&i);
 
     /************************************************************************/
 
     // now, check to see that the object is an event or todo.
     if (strcmp(vObjectName(curVO), VCEventProp) == 0) {
 
       if ((curVOProp = isAPropertyOf(curVO, XPilotStatusProp)) != 0) {
 	char *s;
 	s = fakeCString(vObjectUStringZValue(curVOProp));
 	// check to see if event was deleted by the kpilot conduit
 	if (atoi(s) == Event::SYNCDEL) {
 	  deleteStr(s);
 	  kdDebug(5800) << "skipping pilot-deleted event" << endl;
 	  goto SKIP;
 	}
 	deleteStr(s);
       }
 
       // this code checks to see if we are trying to read in an event
       // that we already find to be in the calendar.  If we find this
       // to be the case, we skip the event.
       if ((curVOProp = isAPropertyOf(curVO, VCUniqueStringProp)) != 0) {
 	char *s = fakeCString(vObjectUStringZValue(curVOProp));
 	QString tmpStr(s);
 	deleteStr(s);
 
 	if (mCalendar->event(tmpStr)) {
 	  goto SKIP;
 	}
 	if (mCalendar->todo(tmpStr)) {
 	  goto SKIP;
 	}
       }
 
       if ((!(curVOProp = isAPropertyOf(curVO, VCDTstartProp))) &&
 	  (!(curVOProp = isAPropertyOf(curVO, VCDTendProp)))) {
 	kdDebug(5800) << "found a VEvent with no DTSTART and no DTEND! Skipping..." << endl;
 	goto SKIP;
       }
 
       anEvent = VEventToEvent(curVO);
       // we now use addEvent instead of insertEvent so that the
       // signal/slot get connected.
       if (anEvent) {
       	if ( !anEvent->dtStart().isValid() || !anEvent->dtEnd().isValid() ) {
 	  kdDebug() << "VCalFormat::populate(): Event has invalid dates."
 	            << endl;
 	} else {
           mCalendar->addEvent(anEvent);
       	}
       } else {
 	// some sort of error must have occurred while in translation.
 	goto SKIP;
       }
     } else if (strcmp(vObjectName(curVO), VCTodoProp) == 0) {
       Todo *aTodo = VTodoToEvent(curVO);
       mCalendar->addTodo(aTodo);
     } else if ((strcmp(vObjectName(curVO), VCVersionProp) == 0) ||
 	       (strcmp(vObjectName(curVO), VCProdIdProp) == 0) ||
 	       (strcmp(vObjectName(curVO), VCTimeZoneProp) == 0)) {
       // do nothing, we know these properties and we want to skip them.
       // we have either already processed them or are ignoring them.
       ;
     } else {
       kdDebug(5800) << "Ignoring unknown vObject \"" << vObjectName(curVO) << "\"" << endl;
     }
   SKIP:
     ;
   } // while
 
   // Post-Process list of events with relations, put Event objects in relation
   Event *ev;
   for ( ev=mEventsRelate.first(); ev != 0; ev=mEventsRelate.next() ) {
     ev->setRelatedTo(mCalendar->event(ev->relatedToUid()));
   }
   Todo *todo;
   for ( todo=mTodosRelate.first(); todo != 0; todo=mTodosRelate.next() ) {
     todo->setRelatedTo(mCalendar->todo(todo->relatedToUid()));
   }
 }
 
 const char *VCalFormat::dayFromNum(int day)
 {
   const char *days[7] = { "MO ", "TU ", "WE ", "TH ", "FR ", "SA ", "SU " };
 
   return days[day];
 }
 
 int VCalFormat::numFromDay(const QString &day)
 {
   if (day == "MO ") return 0;
   if (day == "TU ") return 1;
   if (day == "WE ") return 2;
   if (day == "TH ") return 3;
   if (day == "FR ") return 4;
   if (day == "SA ") return 5;
   if (day == "SU ") return 6;
 
   return -1; // something bad happened. :)
 }
 
 Attendee::PartStat VCalFormat::readStatus(const char *s) const
 {
   QString statStr = s;
   statStr = statStr.upper();
   Attendee::PartStat status;
 
   if (statStr == "X-ACTION")
     status = Attendee::NeedsAction;
   else if (statStr == "NEEDS ACTION")
     status = Attendee::NeedsAction;
   else if (statStr== "ACCEPTED")
     status = Attendee::Accepted;
   else if (statStr== "SENT")
     status = Attendee::NeedsAction;
   else if (statStr== "TENTATIVE")
     status = Attendee::Tentative;
   else if (statStr== "CONFIRMED")
     status = Attendee::Accepted;
   else if (statStr== "DECLINED")
     status = Attendee::Declined;
   else if (statStr== "COMPLETED")
     status = Attendee::Completed;
   else if (statStr== "DELEGATED")
     status = Attendee::Delegated;
   else {
     kdDebug(5800) << "error setting attendee mStatus, unknown mStatus!" << endl;
     status = Attendee::NeedsAction;
   }
 
   return status;
 }
 
 QCString VCalFormat::writeStatus(Attendee::PartStat status) const
 {
   switch(status) {
     default:
     case Attendee::NeedsAction:
       return "NEEDS ACTION";
       break;
     case Attendee::Accepted:
       return "ACCEPTED";
       break;
     case Attendee::Declined:
       return "DECLINED";
       break;
     case Attendee::Tentative:
       return "TENTATIVE";
       break;
     case Attendee::Delegated:
       return "DELEGATED";
       break;
     case Attendee::Completed:
       return "COMPLETED";
       break;
     case Attendee::InProcess:
       return "NEEDS ACTION";
       break;
   }
 }
diff --git a/libkdepim/phoneaccess.cpp b/libkdepim/phoneaccess.cpp
index 8298aa6..e24ad9e 100644
--- a/libkdepim/phoneaccess.cpp
+++ b/libkdepim/phoneaccess.cpp
@@ -1,173 +1,216 @@
 /*
     This file is part of libkdepim.
 
     Copyright (c) 2004 Lutz Rogowski <rogowski@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 <qstring.h>
 #include <qapplication.h>
 #include <qptrlist.h>
 #include <qregexp.h>
 #include <qfile.h>
+#include <qlabel.h>
 #include <qtextstream.h>
 #include <qtextcodec.h>
 #include <qdir.h>
 #include <kmessagebox.h>
 #include <stdlib.h>
 #include "phoneaccess.h"
 
 void PhoneAccess::writeConfig( QString device, QString connection, QString model )
 {
 #ifdef _WIN32_
     QString fileName = qApp->applicationDirPath () +"\\gammurc";
 #else
     QString fileName = QDir::homeDirPath() +"/.gammurc";
 #endif
     //qDebug("save %d ", load );
     QString content = "[gammu]\n";;
     bool write = false;
     bool addPort = true, addConnection = true, addModel = true;
     QFile file( fileName );
     if ( QFile::exists(  fileName) ) {
         if (!file.open( IO_ReadOnly ) ) {
             qDebug("Error: cannot open %s ", fileName.latin1() );
             return;
         } 
         QString line;
         while ( file.readLine( line, 1024 ) > 0 ) {
             //qDebug("*%s* ", line.latin1() );
             if ( line.left(7 ) == "[gammu]" ) {
                ; 
             } else 
             if ( line.left(4 ) == "port" ) {
                 if ( line == "port = " + device+"\n" ) {
                     content += line ;
                     addPort = false;  
                     //qDebug("port found" );
                 }
                
             } else  if ( line.left(5 ) == "model" )  {
                 if ( line == "model = " + model +"\n") {
                     content += line ;
                     addModel = false;  
                     //qDebug("model found" );
                 }
               
             } else  if ( line.left( 10 ) == "connection" )  {
                 if ( line == "connection = " + connection +"\n") {
                     addConnection = false; 
                     content += line ;
                     //qDebug("con found" );
                 }
               
             } else {
                 content += line ;
             }
         }
         file.close();
     } else {
         if ( ! connection.isEmpty() ) {
             addConnection = true; 
         }
         if ( ! device.isEmpty() ) {
             addPort = true; 
 
         }
         if ( ! model.isEmpty() ) {
             addModel = true; 
         }
     }
    
     if ( addConnection ) {
         write = true;
         content += "connection = ";
         content += connection;
         content += "\n";
     }
     if ( addPort ) {
         write = true;
         content += "port = ";
         content += device;
         content += "\n";
 
     }
     if ( addModel ) {
         write = true;
         content += "model = ";
         content += model;
         content += "\n";
     }
     if ( write ) {
         if (!file.open( IO_WriteOnly ) ) {
             qDebug("Error: cannot write file  %s ", fileName.latin1() );
             return;
         } 
         qDebug("Writing file  %s ", fileName.latin1() );
         QTextStream ts( &file );
         ts << content ;
         file.close();
     }
 
 }
 
 
 bool PhoneAccess::writeToPhone( QString fileName)
 {
 
 #ifdef DESKTOP_VERSION
 #ifdef _WIN32_ 
     QString command ="kammu --restore " + fileName ;
 #else
     QString command ="./kammu --restore " + fileName ;
 #endif
 #else
     QString command ="kammu --restore " + fileName ;
 #endif
-    int ret;
-    while ( (ret = system (  command.latin1())) != 0 ) {
+    int ret = 1;
+    while ( ret != 0 ) {
+        QLabel* status = new QLabel( i18n(" This may take 1-3 minutes!"), 0 );
+        int w = 235;
+        int h = status->sizeHint().height()+20 ;
+        int dw = QApplication::desktop()->width();
+        int dh = QApplication::desktop()->height();
+        if ( dw > 310 )
+            w = 310;
+        status->setCaption(i18n("Writing to phone...") );
+        status->setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
+        status->show();
+        status->raise();
+        status->update();
+        qApp->processEvents();
+        status->update();
+        qApp->processEvents();
+        ret = system (  command.latin1());
+        delete status;
+        qApp->processEvents();
+        if ( ret ) {
         qDebug("Error S::command returned %d.", ret); 
         int retval = KMessageBox::warningContinueCancel(0,
                                                         i18n("Error accessing device!\nPlease turn on connection\nand retry!"),i18n("KDE/Pim phone access"),i18n("Retry"),i18n("Cancel"));
         if ( retval != KMessageBox::Continue )
             return false;
     }
+    }
     return true;
 }
 bool PhoneAccess::readFromPhone( QString fileName)
 {
 
 #ifdef DESKTOP_VERSION
 #ifdef _WIN32_ 
     QString command ="kammu --backup " + fileName + " -yes" ;
 #else
     QString command ="./kammu --backup " + fileName + " -yes" ;
 #endif
 #else
     QString command ="kammu --backup " + fileName + " -yes" ;
 #endif
     int ret;
-    while ( (ret = system (  command.latin1())) != 0 ) {
+    while ( ret != 0 ) {
+        QLabel* status = new QLabel( i18n(" This may take 1-3 minutes!"), 0 );
+        int w = 235;
+        int h = status->sizeHint().height()+20 ;
+        int dw = QApplication::desktop()->width();
+        int dh = QApplication::desktop()->height();
+        if ( dw > 310 )
+            w = 310;
+        status->setCaption(i18n("Reading from phone...") );
+        status->setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
+        status->show();
+        status->raise();
+        status->update();
+        qApp->processEvents();
+        status->update();
+        qApp->processEvents();
+        ret = system (  command.latin1() );
+        delete status;
+        qApp->processEvents();
+        if ( ret ) {
         qDebug("Error reading from phone:Command returned %d", ret); 
         int retval = KMessageBox::warningContinueCancel(0,
                                                         i18n("Error accessing device!\nPlease turn on connection\nand retry!"),i18n("KDE/Pim phone access"),i18n("Retry"),i18n("Cancel"));
         if ( retval != KMessageBox::Continue )
             return false;
+
+        }
     }
+    qApp->processEvents();
     return true;
 }
diff --git a/microkde/microkde.pro b/microkde/microkde.pro
index 71d662b..21da158 100644
--- a/microkde/microkde.pro
+++ b/microkde/microkde.pro
@@ -1,176 +1,174 @@
 TEMPLATE	= lib
 CONFIG		+= qt warn_on 
 #INCLUDEPATH     += $(QTDIR)/include .
 #DEPENDPATH      += $(QTDIR)/include
 INCLUDEPATH     += .  ../  ../kabc ./kdecore ./kdeui ./kio/kfile ./kio/kio
 #LIBS            += -lqtcompat
 
 TARGET		= microkde
 DESTDIR= ../bin
 DEFINES += DESKTOP_VERSION KDE_QT_ONLY
 unix : {
 OBJECTS_DIR = obj/unix
 MOC_DIR = moc/unix
 }
 win32: {
 DEFINES += _WIN32_
 OBJECTS_DIR = obj/win
 MOC_DIR = moc/win
 }
 include( ../variables.pri )
 
 
 
 HEADERS = \
 qlayoutengine_p.h \
 KDGanttMinimizeSplitter.h \
  kapplication.h \
  kaudioplayer.h \
  kcalendarsystem.h \
  kcalendarsystemgregorian.h \
  kcolorbutton.h \
  kcolordialog.h \
  kcombobox.h \
  kconfig.h \
  kdatetbl.h \
  kdebug.h \
  kdialog.h \
  kdialogbase.h \
  keditlistbox.h \
  kemailsettings.h \
  kfiledialog.h \
  kfontdialog.h \
  kglobal.h \
  kglobalsettings.h \
  kiconloader.h \
  klineedit.h \
  klineeditdlg.h \
  kmessagebox.h \
  knotifyclient.h \
  kprinter.h \
  kprocess.h \
  krestrictedline.h \
  krun.h \
  ksimpleconfig.h \
  kstaticdeleter.h \
  ksystemtray.h \
  ktempfile.h \
  ktextedit.h \
  kunload.h \
  kurl.h \
  kdeui/kguiitem.h \
  kdeui/kcmodule.h \
  kdeui/kbuttonbox.h \
  kdeui/klistbox.h \
  kdeui/klistview.h \
  kdeui/kjanuswidget.h \
  kdeui/kseparator.h \
  kdeui/knuminput.h \
  kdeui/knumvalidator.h \
  kdeui/ksqueezedtextlabel.h \
  kio/job.h \
  kio/kio/kdirwatch.h \
  kio/kio/kdirwatch_p.h \
  kio/kfile/kurlrequester.h \
  kresources/resource.h \
  kresources/factory.h \
  kresources/managerimpl.h \
  kresources/manager.h \
  kresources/selectdialog.h \
  kresources/configpage.h \
  kresources/configwidget.h \ 
  kresources/configdialog.h \
  kresources/kcmkresources.h \
- kresources/syncwidget.h \
  kdecore/kmdcodec.h \
  kdecore/kconfigbase.h \
  kdecore/klocale.h \
  kdecore/kcatalogue.h \
  kdecore/ksharedptr.h \
  kdecore/kshell.h \
  kdecore/kstandarddirs.h \
  kdecore/kstringhandler.h \
  kdecore/kshortcut.h \
  kutils/kcmultidialog.h \
  kdeui/kxmlguiclient.h \
  kdeui/kstdaction.h \
  kdeui/kmainwindow.h \
  kdeui/ktoolbar.h \
  kdeui/ktoolbarbutton.h \
  kdeui/ktoolbarhandler.h \
  kdeui/kaction.h \
  kdeui/kactionclasses.h \
  kdeui/kactioncollection.h \
  kdecore/kprefs.h \
  kdecore/klibloader.h \
  kidmanager.h    
  
 
 # kdecore/klibloader.h \
 
 
 SOURCES = \
 KDGanttMinimizeSplitter.cpp \
  kapplication.cpp \
  kcalendarsystem.cpp \
  kcalendarsystemgregorian.cpp \
  kcolorbutton.cpp \
  kcolordialog.cpp \
  kconfig.cpp \
  kdatetbl.cpp \
  kdialog.cpp \
  kdialogbase.cpp \
  keditlistbox.cpp \
  kemailsettings.cpp \
  kfontdialog.cpp \
  kfiledialog.cpp \
  kglobal.cpp \
  kglobalsettings.cpp \
  kiconloader.cpp \
  kmessagebox.cpp \
  ktextedit.cpp \
  kprocess.cpp \
  krun.cpp \
  ksystemtray.cpp \
  ktempfile.cpp \
  kurl.cpp \
  kdecore/kcatalogue.cpp \
  kdecore/klocale.cpp \
  kdecore/kmdcodec.cpp \
  kdecore/kshell.cpp \
  kdecore/kstandarddirs.cpp \
  kdecore/kstringhandler.cpp \
  kdeui/kbuttonbox.cpp \
  kdeui/kcmodule.cpp \
  kdeui/kguiitem.cpp \
  kdeui/kjanuswidget.cpp \
  kdeui/klistbox.cpp \
  kdeui/klistview.cpp \
  kdeui/knuminput.cpp \
  kdeui/knumvalidator.cpp \
  kdeui/kseparator.cpp \
  kdeui/ksqueezedtextlabel.cpp \
  kio/kio/kdirwatch.cpp \
  kio/kfile/kurlrequester.cpp \
  kresources/configpage.cpp \
  kresources/configdialog.cpp \
  kresources/configwidget.cpp \
  kresources/factory.cpp \
  kresources/kcmkresources.cpp \
  kresources/managerimpl.cpp \
  kresources/resource.cpp \
  kresources/selectdialog.cpp \
- kresources/syncwidget.cpp \
  kutils/kcmultidialog.cpp \
  kdeui/kaction.cpp \
  kdeui/kactionclasses.cpp \
  kdeui/kactioncollection.cpp \
  kdeui/kmainwindow.cpp \
  kdeui/ktoolbar.cpp \
  kdeui/ktoolbarbutton.cpp \
  kdeui/ktoolbarhandler.cpp \
  kdeui/kstdaction.cpp \
  kdeui/kxmlguiclient.cpp \
  kdecore/kprefs.cpp \
  kdecore/klibloader.cpp \
  kidmanager.cpp   
diff --git a/microkde/ofileselector_p.cpp b/microkde/ofileselector_p.cpp
index cf6074d..fd5f965 100644
--- a/microkde/ofileselector_p.cpp
+++ b/microkde/ofileselector_p.cpp
@@ -1,746 +1,749 @@
 #include <qcombobox.h>
 #include <qdir.h>
 #include <qhbox.h>
 #include <qheader.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qlineedit.h>
 #include <qlistview.h>
 #include <qpopupmenu.h>
 #include <qwidgetstack.h>
 #include <qregexp.h>
 #include <qobjectlist.h>
 
 /* hacky but we need to get FileSelector::filter */
 #define private public
 #include <qpe/fileselector.h>
 #undef private
 
 #include <qpe/qpeapplication.h>
 #include <qpe/mimetype.h>
 #include <qpe/resource.h>
 #include <qpe/storage.h>
+#include <kglobal.h>
+#include <klocale.h>
 
 #include "ofileselector_p.h"
 //US#include "ofileselector.h"
 
 #include "klocale.h"
 
 OFileViewInterface::OFileViewInterface( OFileSelector* selector )
     : m_selector( selector ) {
 }
 OFileViewInterface::~OFileViewInterface() {
 }
 QString OFileViewInterface::name()const{
     return m_name;
 }
 void OFileViewInterface::setName( const QString& name ) {
     m_name = name;
 }
 OFileSelector* OFileViewInterface::selector()const {
     return m_selector;
 }
 
 DocLnk OFileViewInterface::selectedDocument()const {
     return DocLnk( selectedName() );
 }
 
 bool OFileViewInterface::showNew()const {
     return selector()->showNew();
 }
 bool OFileViewInterface::showClose()const {
     return selector()->showClose();
 }
 MimeTypes OFileViewInterface::mimeTypes()const {
     return selector()->mimeTypes();
 }
 QStringList OFileViewInterface::currentMimeType()const {
     return selector()->currentMimeType();
 }
 void OFileViewInterface::activate( const QString& ) {
     // not implemented here
 }
 void OFileViewInterface::ok() {
     emit selector()->ok();
 }
 void OFileViewInterface::cancel() {
     emit selector()->cancel();
 }
 void OFileViewInterface::closeMe() {
     emit selector()->closeMe();
 }
 void OFileViewInterface::fileSelected( const QString& str) {
     emit selector()->fileSelected( str);
 }
 void OFileViewInterface::fileSelected( const DocLnk& lnk) {
     emit selector()->fileSelected( lnk );
 }
 void OFileViewInterface::setCurrentFileName( const QString& str ) {
     selector()->m_lneEdit->setText( str );
 }
 QString OFileViewInterface::currentFileName()const{
     return selector()->m_lneEdit->text();
 }
 QString OFileViewInterface::startDirectory()const{
     return selector()->m_startDir;
 }
 
 
 ODocumentFileView::ODocumentFileView( OFileSelector* selector )
     : OFileViewInterface( selector ) {
     m_selector = 0;
     setName( i18n("Documents") );
 }
 ODocumentFileView::~ODocumentFileView() {
 
 }
 QString ODocumentFileView::selectedName()const {
     if (!m_selector)
         return QString::null;
 
     return m_selector->selected()->file();
 }
 QString ODocumentFileView::selectedPath()const {
     return QPEApplication::documentDir();
 }
 QString ODocumentFileView::directory()const {
     return selectedPath();
 }
 void ODocumentFileView::reread() {
     if (!m_selector)
         return;
 
     m_selector->setNewVisible( showNew() );
     m_selector->setCloseVisible( showClose() );
     m_selector->filter = currentMimeType().join(";");
     m_selector->reread();
 }
 int ODocumentFileView::fileCount()const {
     if (!m_selector)
         return -1;
 
     return m_selector->fileCount();
 }
 
 DocLnk ODocumentFileView::selectedDocument()const {
     if (!m_selector)
         return DocLnk();
     DocLnk lnk = *m_selector->selected();
     return lnk;
 }
 
 QWidget* ODocumentFileView::widget( QWidget* parent ) {
     if (!m_selector ) {
         m_selector = new FileSelector(currentMimeType().join(";"), parent, "fileselector", showNew(), showClose() );
         QObject::connect(m_selector, SIGNAL(fileSelected( const DocLnk& ) ),
                          selector(), SLOT(slotDocLnkBridge(const DocLnk&) ) );
         QObject::connect(m_selector, SIGNAL(closeMe() ),
                          selector(), SIGNAL(closeMe() ) );
         QObject::connect(m_selector, SIGNAL(newSelected(const DocLnk& ) ),
                          selector(), SIGNAL(newSelected(const DocLnk& ) ) );
     }
 
     return m_selector;
 }
 
 /*
  * This is the file system view used
  * we use a QListView + QListViewItems for it
  */
 
 OFileSelectorItem::OFileSelectorItem( QListView* view, const QPixmap& pixmap,
                                       const QString& path, const QString& date,
                                       const QString& size, const QString& dir,
                                       bool isLocked, bool isDir )
     : QListViewItem( view )
 {
     setPixmap(0, pixmap );
     setText(1, path );
     setText(2, size );
     setText(3, date );
     m_isDir = isDir;
     m_dir = dir;
     m_locked = isLocked;
 }
 OFileSelectorItem::~OFileSelectorItem() {
 
 }
 bool OFileSelectorItem::isLocked()const {
     return m_locked;
 }
 QString OFileSelectorItem::directory()const {
     return m_dir;
 }
 bool OFileSelectorItem::isDir()const {
     return m_isDir;
 }
 QString OFileSelectorItem::path()const {
     return text( 1 );
 }
 QString OFileSelectorItem::key( int id, bool )const {
     QString ke;
     if( id == 0 || id == 1 ){ // name
         if( m_isDir ){
             ke.append("0" );
             ke.append( text(1) );
         }else{
             ke.append("1" );
             ke.append( text(1) );
         }
         return ke;
     }else
         return text( id );
 
 }
 
 OFileViewFileListView::OFileViewFileListView( QWidget* parent, const QString& startDir,
                                               OFileSelector* sel)
     : QWidget( parent ), m_sel( sel ) {
     m_all = false;
     QVBoxLayout* lay = new QVBoxLayout( this );
     m_currentDir = startDir;
 
     /*
      * now we add a special bar
      * One Button For Up
      * Home
      * Doc
      * And a dropdown menu with FileSystems
      * FUTURE: one to change dir with lineedit
      * Bookmarks
      * Create Dir
      */
     QHBox* box = new QHBox(this );
     box->setBackgroundMode( PaletteButton );
     box->setSpacing( 0 );
 
     QToolButton *btn = new QToolButton( box );
     btn->setIconSet( Resource::loadPixmap("up") );
     connect(btn, SIGNAL(clicked() ),
             this, SLOT( cdUP() ) );
 
     btn = new QToolButton( box );
     btn->setIconSet( Resource::loadPixmap("home") );
     connect(btn, SIGNAL(clicked() ),
             this, SLOT( cdHome() ) );
 
     btn = new QToolButton( box );
     btn->setIconSet( Resource::loadPixmap("DocsIcon") );
     connect(btn, SIGNAL(clicked() ),
             this, SLOT(cdDoc() ) );
 
     m_btnNew = new QToolButton( box );
     m_btnNew->setIconSet( Resource::loadPixmap("new") );
     connect(m_btnNew, SIGNAL(clicked() ),
             this, SLOT(slotNew() ) );
 
 
     m_btnClose = new QToolButton( box );
     m_btnClose->setIconSet( Resource::loadPixmap("close") );
     connect(m_btnClose, SIGNAL(clicked() ),
             selector(), SIGNAL(closeMe() ) );
 
     btn = new QToolButton( box );
     btn->setIconSet( Resource::loadPixmap("cardmon/pcmcia") );
 
     /* let's fill device parts */
     QPopupMenu* pop = new QPopupMenu(this);
     connect(pop, SIGNAL( activated(int) ),
             this, SLOT(slotFSActivated(int) ) );
 
     StorageInfo storage;
     const QList<FileSystem> &fs = storage.fileSystems();
     QListIterator<FileSystem> it(fs);
     for ( ; it.current(); ++it ) {
         const QString disk = (*it)->name();
         const QString path = (*it)->path();
         m_dev.insert( disk, path );
         pop->insertItem( disk );
     }
     m_fsPop = pop;
 
 
     btn->setPopup( pop );
     btn->setPopupDelay ( 0 );
     lay->addWidget( box );
 
     m_view = new QListView( this );
 
     m_view->installEventFilter(this);
 
     QPEApplication::setStylusOperation( m_view->viewport(),
                                         QPEApplication::RightOnHold);
     m_view->addColumn(" " );
     m_view->addColumn(i18n("Name"), 135 );
     m_view->addColumn(i18n("Size"), -1 );
     m_view->addColumn(i18n("Date"), 60 );
     m_view->addColumn(i18n("Mime Type"), -1 );
 
 
     m_view->setSorting( 1 );
     m_view->setAllColumnsShowFocus( TRUE );
 
     lay->addWidget( m_view, 1000 );
     connectSlots();
 }
 OFileViewFileListView::~OFileViewFileListView() {
 }
 void OFileViewFileListView::slotNew() {
     DocLnk lnk;
     emit selector()->newSelected( lnk );
 }
 OFileSelectorItem* OFileViewFileListView::currentItem()const{
     QListViewItem* item = m_view->currentItem();
     if (!item )
         return 0l;
 
     return static_cast<OFileSelectorItem*>(item);
 }
 void OFileViewFileListView::reread( bool all ) {
     m_view->clear();
 
     if (selector()->showClose() )
         m_btnClose->show();
     else
         m_btnClose->hide();
 
     if (selector()->showNew() )
         m_btnNew->show();
     else
         m_btnNew->hide();
 
     m_mimes = selector()->currentMimeType();
     m_all = all;
 
     QDir dir( m_currentDir );
     if (!dir.exists() )
         return;
     topLevelWidget()->setCaption( dir.path() );
     dir.setSorting( QDir::Name | QDir::DirsFirst | QDir::Reversed );
     int filter;
     if (m_all )
         filter = QDir::Files | QDir::Dirs | QDir::Hidden | QDir::All;
     else
         filter = QDir::Files | QDir::Dirs | QDir::All;
     dir.setFilter( filter );
 
     // now go through all files
     const QFileInfoList *list = dir.entryInfoList();
     if (!list) {
         cdUP();
         return;
     }
     QFileInfoListIterator it( *list );
     QFileInfo *fi;
     while( (fi=it.current() ) ){
       if( fi->fileName() == QString::fromLatin1("..") || fi->fileName() == QString::fromLatin1(".") ){
           ++it;
           continue;
       }
 
       /*
        * It is a symlink we try to resolve it now but don't let us attack by DOS
        *
        */
       if( fi->isSymLink() ){
           QString file = fi->dirPath( true ) + "/" + fi->readLink();
           for( int i = 0; i<=4; i++) { // 5 tries to prevent dos
               QFileInfo info( file );
               if( !info.exists() ){
                   addSymlink( fi, TRUE );
                   break;
               }else if( info.isDir() ){
                   addDir( fi, TRUE );
                   break;
               }else if( info.isFile() ){
                   addFile( fi, TRUE );
                   break;
               }else if( info.isSymLink() ){
                   file = info.dirPath(true ) + "/" + info.readLink() ;
                   break;
               }else if( i == 4){ // couldn't resolve symlink add it as symlink
                   addSymlink( fi );
               }
         } // off for loop for symlink resolving
       }else if( fi->isDir() )
           addDir(  fi );
       else if( fi->isFile() )
         addFile( fi );
 
       ++it;
     } // of while loop
   m_view->sort();
 
 }
 int OFileViewFileListView::fileCount()const{
     return m_view->childCount();
 }
 QString OFileViewFileListView::currentDir()const{
     return m_currentDir;
 }
 OFileSelector* OFileViewFileListView::selector() {
     return m_sel;
 }
 
 bool OFileViewFileListView::eventFilter (QObject *o, QEvent *e) {
     if ( e->type() == QEvent::KeyPress ) {
         QKeyEvent *k = (QKeyEvent *)e;
         if ( (k->key()==Key_Enter) || (k->key()==Key_Return)) {
             slotClicked( Qt::LeftButton,m_view->currentItem(),QPoint(0,0),0);
             return true;
         }
     }
     return false;
 }
 
 
 void OFileViewFileListView::connectSlots() {
     connect(m_view, SIGNAL(clicked(QListViewItem*) ),
             this, SLOT(slotCurrentChanged(QListViewItem*) ) );
     connect(m_view, SIGNAL(mouseButtonClicked(int, QListViewItem*, const QPoint&, int ) ),
             this, SLOT(slotClicked(int, QListViewItem*, const QPoint&, int ) ) );
 }
 void OFileViewFileListView::slotCurrentChanged( QListViewItem* item) {
     if (!item)
         return;
 #if 0
 
     OFileSelectorItem *sel = static_cast<OFileSelectorItem*>(item);
 
     if (!sel->isDir() ) {
         selector()->m_lneEdit->setText( sel->text(1) );
         // if in fileselector mode we will emit selected
         if ( selector()->mode() == OFileSelector::FileSelector ) {
             qWarning("slot Current Changed");
             QStringList str = QStringList::split("->", sel->text(1) );
             QString path = sel->directory() + "/" + str[0].stripWhiteSpace();
             emit selector()->fileSelected( path );
             DocLnk lnk( path );
             emit selector()->fileSelected( lnk );
         }
     }
 #endif
 }
 void OFileViewFileListView::slotClicked(int button , QListViewItem* item, const QPoint&, int ) {
     if (!item || ( button != Qt::LeftButton) )
         return;
 
     OFileSelectorItem *sel = static_cast<OFileSelectorItem*>(item);
     if (!sel->isLocked() ) {
         QStringList str = QStringList::split("->", sel->text(1) );
         if (sel->isDir() ) {
             m_currentDir = sel->directory() + "/" + str[0].stripWhiteSpace();
             emit selector()->dirSelected( m_currentDir );
             reread( m_all );
         }else { // file
             qWarning("slot Clicked");
             selector()->m_lneEdit->setText( str[0].stripWhiteSpace() );
             QString path = sel->directory() + "/" + str[0].stripWhiteSpace();
             emit selector()->fileSelected( path );
             DocLnk lnk( path );
             emit selector()->fileSelected( lnk );
         }
     } // not locked
 }
 void OFileViewFileListView::addFile( QFileInfo* info, bool symlink ) {
     MimeType type( info->absFilePath() );
     if (!compliesMime( type.id() ) )
         return;
 
     QPixmap pix = type.pixmap();
     QString dir, name; bool locked;
     if ( pix.isNull() ) {
         QWMatrix matrix;
         QPixmap pixer(Resource::loadPixmap("UnknownDocument") );
         matrix.scale( .4, .4 );
         pix = pixer.xForm( matrix );
     }
     dir = info->dirPath( true );
     locked = false;
     if ( symlink )
         name = info->fileName() + " -> " + info->dirPath() + "/" + info->readLink();
     else{
         name = info->fileName();
         if ( ( (selector()->mode() == OFileSelector::Open)&& !info->isReadable() ) ||
              ( (selector()->mode() == OFileSelector::Save)&& !info->isWritable() ) ) {
             locked = true; pix = Resource::loadPixmap("locked");
         }
     }
     (void)new OFileSelectorItem( m_view, pix, name,
-                                 info->lastModified().toString(), QString::number( info->size() ),
+                                 KGlobal::locale()->formatDateTime(info->lastModified(),true, true, KLocale::ISODate),
+                                 QString::number( info->size() ),
                                  dir, locked );
 }
 void OFileViewFileListView::addDir( QFileInfo* info, bool symlink ) {
     bool locked = false; QString name; QPixmap pix;
 
     if ( ( ( selector()->mode() == OFileSelector::Open )  && !info->isReadable() ) ||
          ( ( selector()->mode() == OFileSelector::Save )  && !info->isWritable() ) ) {
         locked = true;
         if ( symlink )
             pix = Resource::loadPixmap( "symlink" );
         else
             pix = Resource::loadPixmap( "lockedfolder" );
     }else
         pix = symlink ? Resource::loadPixmap( "symlink") : Resource::loadPixmap("folder");
 
     name = symlink ? info->fileName() + " -> " + info->dirPath(true) + "/" + info->readLink() :
            info->fileName();
 
     (void)new OFileSelectorItem( m_view, pix, name,
-                                 info->lastModified().toString(),
+                                 KGlobal::locale()->formatDateTime(info->lastModified(),true, true, KLocale::ISODate),
                                  QString::number( info->size() ),
                                  info->dirPath( true ), locked, true );
 
 
 }
 void OFileViewFileListView::addSymlink( QFileInfo* , bool ) {
 
 }
 void OFileViewFileListView::cdUP() {
     QDir dir( m_currentDir );
     dir.cdUp();
 
     if (!dir.exists() )
         m_currentDir = "/";
     else
         m_currentDir = dir.absPath();
 
     emit selector()->dirSelected( m_currentDir );
     reread( m_all );
 }
 void OFileViewFileListView::cdHome() {
     m_currentDir = QDir::homeDirPath();
     emit selector()->dirSelected( m_currentDir );
     reread( m_all );
 }
 void OFileViewFileListView::cdDoc() {
     m_currentDir = QPEApplication::documentDir();
     emit selector()->dirSelected( m_currentDir );
     reread( m_all );
 }
 void OFileViewFileListView::changeDir( const QString& dir ) {
     m_currentDir = dir;
     emit selector()->dirSelected( m_currentDir );
     reread( m_all );
 }
 void OFileViewFileListView::slotFSActivated( int id ) {
     changeDir ( m_dev[m_fsPop->text(id)]  );
 }
 
 /*  check if the mimetype in mime
  *  complies with the  one which is current
  */
 /*
  * We've the mimetype of the file
  * We need to get the stringlist of the current mimetype
  *
  * mime = image@slashjpeg
  * QStringList = 'image@slash*'
  * or QStringList = image/jpeg;image/png;application/x-ogg
  * or QStringList = application/x-ogg;image@slash*;
  * with all these mime filters it should get acceptes
  * to do so we need to look if mime is contained inside
  * the stringlist
  * if it's contained return true
  * if not ( I'm no RegExp expert at all ) we'll look if a '@slash*'
  * is contained in the mimefilter and then we will
  * look if both are equal until the '/'
  */
 bool OFileViewFileListView::compliesMime( const QString& str) {
     if (str.isEmpty() || m_mimes.isEmpty() || str.stripWhiteSpace().isEmpty() )
         return true;
 
     for (QStringList::Iterator it = m_mimes.begin(); it != m_mimes.end(); ++it ) {
         QRegExp reg( (*it) );
         reg.setWildcard( true );
         if ( str.find( reg ) != -1 )
             return true;
 
     }
     return false;
 }
 /*
  * The listView giving access to the file system!
  */
 class OFileViewFileSystem : public OFileViewInterface {
 public:
     OFileViewFileSystem( OFileSelector* );
     ~OFileViewFileSystem();
 
     QString selectedName() const;
     QString selectedPath() const;
 
     QString directory()const;
     void reread();
     int fileCount()const;
 
     QWidget* widget( QWidget* parent );
     void activate( const QString& );
 private:
     OFileViewFileListView* m_view;
     bool m_all : 1;
 };
 OFileViewFileSystem::OFileViewFileSystem( OFileSelector* sel)
     : OFileViewInterface( sel ) {
     m_view = 0;
     m_all = false;
 }
 OFileViewFileSystem::~OFileViewFileSystem() {
 }
 QString OFileViewFileSystem::selectedName()const{
     if (!m_view )
         return QString::null;
 
     QString cFN=currentFileName();
     if (cFN.startsWith("/")) return cFN;
     return m_view->currentDir() + "/" + cFN;
 }
 QString OFileViewFileSystem::selectedPath()const{
     return QString::null;
 }
 QString OFileViewFileSystem::directory()const{
     if (!m_view)
         return QString::null;
 
     OFileSelectorItem* item = m_view->currentItem();
     if (!item )
         return QString::null;
 
     return QDir(item->directory() ).absPath();
 }
 void OFileViewFileSystem::reread() {
     if (!m_view)
         return;
 
     m_view->reread( m_all );
 }
 int OFileViewFileSystem::fileCount()const{
     if (!m_view )
         return -1;
     return m_view->fileCount();
 }
 QWidget* OFileViewFileSystem::widget( QWidget* parent ) {
     if (!m_view ) {
         m_view = new OFileViewFileListView( parent, startDirectory(), selector() );
     }
     return m_view;
 }
 void OFileViewFileSystem::activate( const QString& str) {
     m_all =  (str !=i18n("Files") );
 
 
 }
 
 /* Selector */
 OFileSelector::OFileSelector( QWidget* parent, int mode, int sel,
                               const QString& dirName, const QString& fileName,
                               const MimeTypes& mimetypes,
                               bool showNew,  bool showClose)
     : QWidget( parent, "OFileSelector" )
 {
     m_current = 0;
     m_shNew = showNew;
     m_shClose = showClose;
     m_mimeType = mimetypes;
     m_startDir = dirName;
     m_mode = mode;
     m_selector = sel;
 
     initUI();
     m_lneEdit->setText( fileName );
     initMime();
     initViews();
 
     QString str;
     switch ( m_selector ) {
     default:
     case Normal:
         str = i18n("Documents");
         m_cmbView->setCurrentItem( 0 );
         break;
     case Extended:
         str = i18n("Files");
         m_cmbView->setCurrentItem( 1 );
         break;
     case ExtendedAll:
         str = i18n("All Files");
         m_cmbView->setCurrentItem( 2 );
         break;
     }
     slotViewChange( str );
 
 }
 OFileSelector::OFileSelector( const QString& mimeFilter, QWidget* parent, const char* name,
                               bool showNew, bool showClose )
     : QWidget( parent, name )
 {
     m_current = 0;
     m_shNew   = showNew;
     m_shClose = showClose;
     m_startDir = QPEApplication::documentDir();
 
     if (!mimeFilter.isEmpty() )
         m_mimeType.insert(mimeFilter, QStringList::split(";", mimeFilter ) );
 
     m_mode = OFileSelector::FileSelector;
     m_selector = OFileSelector::Normal;
 
     initUI();
     initMime();
     initViews();
     m_cmbView->setCurrentItem( 0 );
     slotViewChange( i18n("Documents") );
 }
 /*
  * INIT UI will set up the basic GUI
  * Layout: Simple VBoxLayout
  * On top a WidgetStack containing the Views...
  *  - List View
  *  - Document View
  * Below we will have a Label + LineEdit
  * Below we will have two ComoBoxes one for choosing the view one for
  *       choosing the mimetype
  */
 void OFileSelector::initUI() {
     QVBoxLayout* lay = new QVBoxLayout( this );
 
     m_stack = new QWidgetStack( this );
     lay->addWidget( m_stack, 1000 );
 
     m_nameBox = new QHBox( this );
     (void)new QLabel( i18n("Name:"), m_nameBox );
     m_lneEdit = new QLineEdit( m_nameBox );
     m_lneEdit ->installEventFilter(this);
     lay->addWidget( m_nameBox );
 
     m_cmbBox = new QHBox( this );
     m_cmbView = new QComboBox( m_cmbBox );
     m_cmbMime = new QComboBox( m_cmbBox );
     lay->addWidget( m_cmbBox );
 }
 
 /*
  * This will make sure that the return key in the name edit causes dialogs to close
  */
 
 bool OFileSelector::eventFilter (QObject *o, QEvent *e) {
     if ( e->type() == QEvent::KeyPress ) {
         QKeyEvent *k = (QKeyEvent *)e;
         if ( (k->key()==Key_Enter) || (k->key()==Key_Return)) {
             emit ok();
             return true;
         }
     }
     return false;
 }
 
 /*
  * This will insert the MimeTypes into the Combo Box
  * And also connect the changed signal
  *
  * AutoMimeTyping is disabled for now. It used to reparse a dir and then set available mimetypes
  */
 void OFileSelector::initMime() {
     MimeTypes::Iterator it;
     for ( it = m_mimeType.begin(); it != m_mimeType.end(); ++it ) {
         m_cmbMime->insertItem( it.key() );