10 files changed, 95 insertions, 33 deletions

diff --git a/bin/kdepim/WhatsNew.txt b/bin/kdepim/WhatsNew.txt
index fbe16d8..adbfd67 100644
--- a/bin/kdepim/WhatsNew.txt
+++ b/bin/kdepim/WhatsNew.txt
@@ -1,194 +1,211 @@
 Info about the changes in new versions of KDE-Pim/Pi
 
+********** VERSION 1.9.20 ************
+
+KO/Pi:
+Made it possible to delete a Todo, which has sub-todos.
+Fixed two small problems in the todo view.
+Added missing German translation for filter edit and print dialog.
+Made search dialog closeable by cancel key.
+
+Made it possible to select in the date picker the (ligt grey )
+dates of the prev./next month with the mouse.
+
+Added for the "dislplay one day" agenda mode info in the caption:
+Now it is displayed, if the selected day is from "day before yesterday"
+to "day after tomorrow".
+
+
+
 ********** VERSION 1.9.19 ************
 
 Added a lot of missing translations to KA/Pi, 
 Added some missing translations to KO/Pi and OM/Pi.
 
 Fixed some minor problems in KA/Pi + KO/Pi.
 
 Fixed a crash when closing PwM/Pi.
 Added German translation for PwM/Pi.
 
 Made view change and Month View update faster in KO/Pi.
 
 
 ********** VERSION 1.9.18 ************
 
 FYI: The VERSION 1.9.17 was a testing release only.
 Please read the changelog of VERSION 1.9.17 as well.
 
 Cleaned up the syncing config dialog.
 Added sync config options for date range for events.
 Added sync config options for filters on incoming data.
 Added sync config options for filters on outgoing data.
 Please read the updated SyncHowTo about the new filter settings.
 These filter settings make it now possible to sync with shared
 calendars without writing back private or confidential data
 (via the outgoing filters).
 To sync only with particular parts of a shared calendar, 
 the incoming filter settings can be used.
 An example can be found in the SyncHowTo.
 Same for shared addressbooks.
 
 Added a setting for the global kdepim data storage.
 Usually the data is stored in (yourhomedir/kdepim).
 Now you can set in the Global config dialog TAB, subTAB "Data storage path"
 a directory where all the kdepim data is stored.
 That makes it easy to save all kdepim data on a SD card on the Z, for example.
 
 KO/Pi:
 The timeedit input has a pulldown list for times.
 If opened, this pulldown list should now has the right time highlighted.
 Added the possibility to exclude events/todos/journals in a filter.
 You should exclude journals, if you do not want them to sync with a  public calendar.
 
 KA/Pi:
 Added the possibility to in/exclude public/private/confidential contacts to a filter.
 If you have already defined filterrules in KA/Pi you have to adjust them all by setting the "include public/private/confidential" property manually. Sorry for that ...
 Added printing of card view and details view on desktop.
 Printing of list view is not working...
 Added button for removing pictures in contact editor.
 Parsing data fix of KA/Pi version 1.9.17.
 Fixed the "parse name automatically" problem of KA/Pi version 1.9.17.
 Fixed some syncing merging problems.
 
 
 ********** VERSION 1.9.17 ************
 
 KO/Pi:
 Fixed that tooltips were not updated after moving an item in agenda view.
 Fixed a bug in sorting start date for recurring events in list view.
 Changed the left button in todo viewer from "Agenda" to "Set completed".
 This makes it possible to change a todo in the What's Next View quickly to the completed state without leaving the What's Next View.
 Added more info in the todo viewer: Startdate, parent/sub todos.
  
 
 KA/Pi:
 All fields search does now actually search all the (possible) fields, 
 not only those listed in the contact list.
 Made is possible to inline a picture in a vcard on the Z.
 This was only possible on the desktop, now is it possible on the Z as well.
 Fixed of missing save settings after filter configuration.
 Made saving of addressbook much faster.
 Fixed extension widget layout problem.
 Fixed saving of default formatted name settings.
 Fixed formatted name handling in edit dialog.
 Added an option for changing formatted names of many contacts
 (menu: File - Change - Set formatted name).
 
 QWhatsThis was not working on the Z ( only black rectangle was shown).
 This is Fixed.
 
 KDE-Sync:
 Now readonly KDE resources are synced as well.
 (They are not changed in KDE itself, of course).
 
  
 
 ********** VERSION 1.9.16 ************
 
 KO/Pi:
 Fixed search dialog size on Z 6000 (480x640 display).
 Added setting to hide/show time in agenda items.
 Added setting to hide not running todos in todo view.
 Added columns for start date/time in todo view.
 Replaced the solid half-hour lines in agenda view by dot lines.
 Added possibility of printing the What's Next View on the desktop
 (i.e. Windows and Linux).
 Fixed a crash in KO/Pi when starting KO/Pi with What's Next view.
 Added tooltips in month view.(Tooltips only available on desktop)
 
 Fixed a strange problem in KO/Pi alarm applet.
 Did not find the actual problem, 
 such that now Qtopia reboots again if deinstalling the alarm applet.
 But the alarm applet should work again.
 
 KA/Pi:
 Fixed the problem, that internal pictures were not saved.
 
 Fixed a problem in the pi-sync mode by increasing the timeout for data transfer from 20 seconds to 5 minutes.
 
 Fixed some minor problems. (Like word wrap in help text windows).
 
 Fixed a compiling problem in microkde/kresources.
 
 KO/Pi is using zdbat (renamed to db2file) for syncing with Sharp DTM.
 This version now includes zdbat 1.0.0 (old version was zdbat 0.2.9)
 such that now syncing KO/Pi with Sharp DTM should work on the 
 Zaurus C 3000 model.
 
 ********** VERSION 1.9.15 ************
 
 Usebilty enhancements in KO/Pi:
 When clicking on the date in a month view cell, the day view is shown.
 Old behaviour was, that the "new event" dialog popped up.
 
 Added a one step "undo delete" in KO/Pi (Accessable in the "Action" menu). 
 That means, you can restore the latest
 event/todo/journal you have deleted.
 A journal is deleted, if you clear all the text of the journal.
 
 Fixed the bug of the editor dialogs in KO/Pi of version 1.9.14.
 
 KA/Pi  starting in 480x640 resolution:
 Hide the filter action in toolbar
 and added icons for undo/delete/redo in toolbar.
 
 Change in OM/Pi ViewMail dialog:
 When clicking on the "delete" icon the mail is deleted after confirmation as usual. 
 But the edit dialog is not closed as before, now the next mail in the folder is shown automatically (if there is any).
 
 Fixed a crash when deleting mail-accounts in OM/Pi.
 
 
 ********** VERSION 1.9.14 ************
 
 Fixed some problems with the dialog sizes when switching 
 portrait/landscape mode on 640x480 PDA display.
 
 Fixed some other small bugs in KA/Pi KO/Pi and OM/Pi and PwM/Pi.
 
 Fixed an ugly bug in KOpieMail: 
 KOpieMail was not able to write files (mails) to MSDOS file system, 
 like on an usual preformatted SD card. That should work now.
 To save your mail data on the Sd card do the following:
 Create a dir on the SD card:
 mkdir /mnt/card/localmail
 Go to your home dir:
 cd
 Go to kopiemail data storage dir:
 cd kdepim/apps/kopiemail
 Create a symlink to the SD card:
 ls -s /mnt/card/localmail
 Now KOpieMail will store all mails on the SD card.
 
 KO/Pi Monthview:
 Now "Go to Today" selects the current month from day 1-end,
 not the current date + some days.
 I.e. "Go to Today" shows now always
 the current month with first day of month in the first row. 
 
 Added missing German translation.
 
 Fixed icons of executeable on Wintendo.
 
 Added a "Show next Mail" button to the OM/Pi 
 mail viewer such that the mail below the current mail
 in the mail list view of the current folder
 can be read with a single click.
 
 
 ********** VERSION 1.9.13 ************
 
 Fixed nasty PwM/Pi file reading bug, when
 the used hash algo of file is different then the global 
 hash algo.
 
 Added KA/Pi support for opie mailit mailapplication.
 
 Fixed some bugs in OM/Pi.
 Now character conversion tables are available for the Zaurus
 to make OM/Pi working properly.
 To get the character conversion in OM/Pi working, please download
 at the sourceforge project site the package
diff --git a/bin/kdepim/korganizer/germantranslation.txt b/bin/kdepim/korganizer/germantranslation.txt
index 0eb46e8..d260be3 100644
--- a/bin/kdepim/korganizer/germantranslation.txt
+++ b/bin/kdepim/korganizer/germantranslation.txt
@@ -1,281 +1,280 @@
 { "10 minutes","10 Minuten" },
 { "10th","10." },
 { "11th","11." },
 { "12 pm Format","12 AM/PM Format" },
 { "12th","12." },
 { "13th","13." },
 { "14th","14." },
 { "15th","15." },
 { "16th","16." },
 { "17th","17." },
 { "18th","18." },
 { "19th","19." },
 { "1 Day","1 Tag" },
 { "1 h","1 Std" },
 { "1 (high)","1 (hoch)" },
 { "5 (low)","5" },
 { "1st","1." },
 { "20th","20." },
 { "21st","21." },
 { "22nd","22." },
 { "23rd","23." },
 { "24:00 Hour Format","24:00 Stunden Format" },
 { "24th","24." },
 { "25th","25." },
 { "26th","26." },
 { "27th","27." },
 { "28th","28." },
 { "29th","29." },
 { "2nd","2." },
 { "30 minutes","30 Minuten" },
 { "30th","30." },
 { "31st","31." },
 { "3rd","3." },
 { "4th","4." },
 { "5 (lowest)","5 (Niedrigster)" },
 { "5th","5." },
 { "6th","6." },
 { "7th","7." },
 { "8th","8." },
 { "9th","9." },
 { "About...","Über..." },
 { "&Accept","&Akzeptieren" },
 { "Accept","Akzeptieren" },
 { "Accept A&ll","A&lles Akzepieren" },
 { "Access:","Zugriff:" },
 { "A corresponding event is missing in your calendar!","Ein zugehöriger Termin fehlt in ihrem Kalender!" },
 { "Actions","Aktionen" },
 { "Add Filter","Filter Hinzufügen" },
 { "&Add","Hinzufügen" },
 { "Add","Hinzufügen" },
 { "Additional email addresses:","Zusätzliche E-Mail Adressen:" },
 { "Additional email address:","Zusätzliche E-Mail Adresse:" },
 { "&Addressbook","&Adressbuch" },
 { "Address &Book...","Adress&buch..." },
 { "Agenda Size","Agende Größe" },
 { "Agenda Size:","Größe der Agenda:" },
 { "Agenda view:","Agenda Ansicht:" },
 { "Agenda view background color:","Hintergrund der Agenda Ansicht:" },
 { "All attendees","Alle Teilnehmer" },
 { "AllDayAgenda Height:","Höhe Ganztages Agenda:" },
 { "Allday","Ganztägig" },
 { "Anonymous","Anonym" },
 { "Apply","Anwenden" },
 { "Apr","Apr" },
 { "April","April" },
 {"Ask for every entry on conflict","Frage bei Konflikten nach"},
 { "Ask for preferences before syncing","Vor dem Syncronisieren nachfragen" },
 { "Ask for quit when closing KO/Pi","Vor dem Beenden von KO/Pi nachfragen" },
 { "Attendees","Teilnehmer" },
 { "Aug","Aug" },
 { "August","August" },
 { "Auto-Save","Automatisches Abspeichern" },
 { "Auto save delay in minutes:","Verzög.autom.Speichern in Min" },
 { "Auto saving...","Automatische Sicherung..." },
 { "Begin on:","Starte mit:" },
 { "Begins on: %1","Starte mit: %1" },
 { "<b>From:</b> %1 <b>To:</b> %2","<b>Vom:</b> %1 <b>Zum:</b> %2" },
 { "Bigger","Größer" },
 { "Biggest","Riesig" },
 { "Big","Groß" },
 { "<b>On:</b> %1","<b>Am:</b> %1" },
 { "<b>On:</b> %1 <b>From:S</b> %2 <b>To:</b> %3","<b>Am:</b> %1 <b>Vom:S</b> %2 <b>Zum:</b> %3" },
 { "<b>Original event:</b><p>","<b>Original Termin:</b><p>" },
 { " - both are modified after last sync"," - beide wurden nach der letzten Syncronisation verändert" },
 { "Busy","Belegt" },
 { "&Cancel","Abbre&chen" },
 { "Cancel","Abbrechen" },
 { "Cannot delete To-Do\nwhich has children.","Kann Todo nicht löschen,\n da noch Einträge vorhanden sind" },
-{ "Cannot delete To-Do which has children.","Kann Todo nicht löschen, da noch Einträge vorhanden sind" },
 { "Can't generate mail:\nNo event selected.","Kann e-Mail nicht erstellen:\nKein Termin ausgewählt." },
 { "Categories...","Kategorien..." },
 { "Categories","Kategorien" },
 { "Category","Kategorie" },
 { "Center View","Zentriere Ansicht" },
 { "Change","Ändere" },
 { "Cinema","Kino" },
 { "Click to add a new Todo","Hier klicken, um ein neues Todo anzulegen" },
 { "Clone Item","Klone Eintrag" },
 { "&Close","S&chließen" },
 { "Close","Schließen" },
 { "Close this dialog to abort deletion!","Zum Abbrechen des Löschvorganges Dialog schließen!" },
 { "Colors","Farben" },
 { "completed","erledigt" },
 { "completed on %1","erledigt am %1" },
 { "Complete","Erledigt" },
 { "Confidential","Vertraulich" },
 { "Configure...","Einstellungen..." },
 { "Confirm &deletes","Löschvogang bestätigen" },
 { "Couldn't load calendar\n '%1'.","Kann Kalender\n '%1' nicht laden." },
 { "Counter-event Viewer","Terminzähler Ansicht" },
 { "Daily ending hour:","Feierabend:" },
 { "Daily starting hour:","Anfangszeit:" },
 { "Daily","Täglich" },
 { "Date Format","Datums Format" },
 { "Date Format:","Datums Format:" },
 { "DateNavigator:(nr)","Datums Navigator" },
 { "Dates: ","Datum: " },
 { "Date && Time","Datum && Zeit" },
 { "Day begins at:","Der Tag beginnt um:" },
 { "Days in Next-X-Days:","Tage in Nächste-X-Tage:" },
 { "Days in What's Next:","Tage in What's Next:" },
 { "day(s)","Tag(e)" },
 { "Days to show in Next-X-Days view:","Welche Tage in Nächste-X-Tagen anzeigen:" },
 { "day","Tag" },
 { "Dec","Dez" },
 { "December","Dezember" },
 { "Default alarm time:","Standard Alarmzeit:" },
 { "Default appointment time:","Standard Termin Startzeit:" },
 { "Default event color:","Standard Terminfarbe:"   },
 { "Default","Standard" },
 { "Def. duration of new app.:","Standard Termin Länge:" },
 { "Delete all completed To-Dos?","Alle bereits erledigten Todos löschen?" },
 { "Delete All","Lösche alles" },
 { "Delete all selected","Lösche alle Selektierten" },
 { "Delete Current","Aktuellen löschen" },
 { "Delete Event...","Lösche Termin..." },
 { "Delete Event","Lösche Termin" },
 { "&Delete","Löschen" },
 { "Delete...","Löschen..." },
 { "Delete","Löschen" },
 { "Delete Todo...","Lösche Todo..." },
 { "Delete To-Do","Lösche Todo" },
 { "Deleting item %d ...","Lösche Eintrag %d..." },
 { "Descriptions","Beschreibungen" },
 { "Deselect All","Deselektiere Alle" },
 { "Details","Details" },
 { "Dinner","Abendessen" },
 { "Do you really want\nto close KO/Pi?","Möchten Sie wirklich\nKO/PI verlassen?" },
 { "Due Date","Fällig am" },
 { "Due: ","Fällig: "},
 { "Due Time","Fällig um"  },
 { "Due:","Fällig:"},
 { "Duration: ","Dauer: " },
 { "Edit...","Bearbeite..." },
 { "Edit","Bearbeite" },
 { "Edit Event...","Bearbeite Termin..." },
 { "Edit Event","Bearbeite Termin" },
 { "Edit exceptions","Bearbeite Ausnahmen" },
 { "EditorBox:","Editor Fenster:" },
 { "Edit Recurrence Range","Bearbeite Wiederholung"  },
 { "Edit Todo...","Berabeite Todo..." },
 { "Edit To-Do","Todo bearbeiten" },
 { "E&mail address:","E&mail Adresse:" },
 { "(EmptyEmail)","(KeineEmail)" },
 { "(EmptyName)","(KeinName)" },
 { "Enable Recurrence","Wiederholender Termin" },
 { "End after","Endet nach"},
 { "End by:","Endet am"},
 { "End Date","End Datum" },
 { "End:","Ende:" },
 { "End Time","End Zeit" },
 { "English","Englisch" },
 { "Event","Termin" },
 { "Event list","Termin Liste" },
 { "Events","Termine" },
 { "Event Viewer:","Termin Übersicht:" },
 { "every","jede" },
 { "Exceptions...","Ausnahmen..." },
 { "Exceptions","Ausnahmen" },
 { "Exclude holidays","Ohne freie Tage" },
 { "Exclude Saturdays","Ohne Samstage" },
 { "Feb","Feb" },
 { "February","Februar" },
 { "&Find","Suche!" },
 { "Fonts","Schriftart" },
 { "Force take local entry always","Erzwinge:Nimm immer lokalen Eintrag" },
 { "Force take remote entry always","Erzwinge:Nimm immer fernen Eintrag"},
 { "Free","Frei" },
 { "Friday","Freitag" },
 { "Fri","Fr" },
 { "From:","Vom:" },
 { "Full &name:","Vor- und &Nachname:" },
 { "General","Allgemein" },
 { "German","Deutsch" },
 { "Gifts","Geschenke" },
 { "Go to Today","Heute anzeigen" },
 { "Help","Hilfe" },
 { "Hide Dates","Daten ausblenden" },
 { "Highlight color:","Markierungen:" },
 { "Holiday color:","Freie Tage:" },
 { "hour(s)","Stunde(n)" },
 { "In %1 days: ","In %1 Tagen: " },
 { "Incomplete Todo:","Unerledigte Aufgaben:" },
 { "Information","Information" },
 { "Invalid search expression,\ncannot perform ","Kann Suche nicht ausführen" },
 { "Jan","Jan" },
 { "January","Januar" },
 { "JournalView:","Journal Ansicht:" },
 { "Journals","Journale" },
 { "Jul","Jul" },
 { "July","Juli" },
 { "Jump to date","Springe zum Datum" },
 { "June","Juni" },
 { "Jun","Jun" },
 { "Key Bindings...","Tastenzuordnung..." },
 { "Kids","Kinder" },
 { "Known Problems...","Bekannte Probleme..." },
 { "KO/Pi Find ","KO/Pi Suchdialog " },
 { "KO/Pi Find: ","KO/Pi Suchen: " },
 { "KO/Pi is starting ... ","  KO/Pi startet ... \n... Zeit für eine Kaffeepause ..." },
 { "Language:(needs restart)","Sprache (Neustart!)" },
 { "Language:","Sprache" },
 { "Large","Etwas mehr" },
 { "List View:","Listenansicht:" },
 { "List View","Listenansicht" },
 { "Load/Save","Laden/Speichern" },
 { "Load Template","Lade Vorlage" },
 { "Locale","Localisation" },
 { "Local temp file:","Lokale temp. Datei:" },
 { "Location: ","Ort: " },
 { "Location:","Ort:" },
 { "Mail client","Mail Programm" },
 { "Mail Client","Mail Programm" },
 { "March","März" },
 { "Mar","Mär" },
 { "May","Mai" },
 { "M. Bains line:","M. Bains Linie:" },
 { "Medium","Medium" },
 { "Method","Methode" },
 { "minute(s)","Minute(n)" },
 { "Monday","Montag" },
 { "Mon","Mo" },
 { "Monthly","Monatlich" },
 { "Month not long enough","Monat ist nicht lang genug" },
 { "month(s)","Monat(e)" },
 { "Month view:","Monatsansicht:" },
 { "Month view uses category colors","Monatsansicht zeigt Kategorie Farben" },
 { "Todo view uses category colors","To-Do Ansicht zeigt Kategorie Farben" },
 { "Move &Down","Nach unten verschieben" },
 { "Move &Up","Nach oben verschieben" },
 { "Name:","Name:" },
 { "Name","Name" },
 { "\nAre you sure you want\nto delete this event?","\nSind Sie sicher, dass Sie\nden Termin löschen möchten?" },
 { "%n Days","%n Tage" },
 { "Never","Nie" },
 { "New event...","Neuer Termin..." },
 { "New event","Neuer Termin" },
 { "New Event...","Neuer Termin..." },
 { "New Events/Todos should","Neue Termine/Todos sollten" },
 { "&New","&Neu" },
 { "New","Neu", },
 { "New Sub-Todo...","Neues Sub-Todo..." },
 { "New Todo...","Neues Todo..." },
 { "Next Alarm: ","Nächster Alarm: ", },
 { "&Next Day","&Nächster Tag", },
 { "Next days view uses full window","Nächste-X-Tage nutzt Vollbild" },
 { "Next month","Nächster Monat" },
 { "&Next Week","&Nächste Woche" },
 { "Next year","Nächstes Jahr" },
 { "Next Year","Nächstes Jahr" },
 { "%n h","%n Std" },
 { "No ending date","Kein End-Datum", },
 { "No event, nothing to do.","Kein Termin, nichts zu tun.", },
 { "No event selected.","Kein Termin selektiert" },
 { "No","Nein" },
 { "No program set","Kein Programm ausgewählt", },
 { "Normal","Normal" },
 { "[No selection]","Keine Selektion", },
 { "No sound set","Kein Sound ausgewählt", },
 { "no time ","keine Zeit ", },
 { "no time","keine Zeit", },
@@ -610,387 +609,387 @@
 {"Business","Geschäft" },
 {"Business Travel","Geschäftsreise" },
 {"Cinema","Kino" },
 {"Customer","Kunde" },
 {"Break","Pause" },
 {"Breakfast","Frühstück" },
 {"Competition","Wettkampf" },
 {"Dinner","Abendessen" },
 {"Education","Erziehung" },
 {"Family","Familie" },
 {"Favorites","Favoriten" },
 {"Festival","Festival" },
 {"Fishing","Angeln" },
 {"Flight","Flug" },
 {"Gifts","Geschenk" },
 {"Holiday","Feiertag" },
 {"Holiday Cards","Ansichtskarten" },
 {"Hot Contacts","Heisse Kontakte" },
 {"Hiking","Wandern" },
 {"Hunting","Jagen" },
 {"Key Customer","Wichtiger Kunde" },
 {"Kids","Kinder" },
 {"Lunch","Mittagessen" },
 {"Meeting","Treffen" },
 {"Miscellaneous","Verschiedenes" },
 {"Partner","Partner" },
 {"Party","Partie" },
 {"Personal","Privat" },
 {"Personal Travel","Privatreise"},
 {"PHB","PHB" },
 {"Phone Calls","Telefonanruf" },
 {"Projects","Projekt" },
 {"Recurring","Wiederholend" },
 {"School","Schule" },
 {"Shopping","Einkaufen" },
 {"Speach","Rede" },
 {"Special Occasion","Spez.Gelegenheit" },
 {"Sports","Sport" },
 {"Talk","Vortrag" },
 {"Travel","Reise" },
 {"TV","TV" },
 {"Germany","Deutschland" },
 {"Sweden","Schweden" },
 {"Forest","Wald" },
 { "Desert","Wüste" },
 { "Kitchen","Küche" },
 { "Lake","See" },
 {"University","Universität"},
 {"Vacation","Urlaub" },
 {"VIP","VIP" },
 { "Import Sharp Calendar","Importiere Sharp Kalender" },
 { "This todo has been cancelled!","Dieses Todo wurde gecancelt!" },
 { "This event has been cancelled!","Dieser Termin wurde gecancelt!" },
 { "Cancelled","Gecancelt" },
 { "Multiple sync","Mehrfach Sync" },
 { "Local file","Lokale Datei" },
 { "Last file","Letzte Datei" },
 { "Keys + Colors...","Tasten + Farben..." },
 { "Mini icons in toolbar(nr)","Mini Icons in ToolBar(bn)" },
 { "Quick load/save (w/o Unicode)","Schnelles Laden/Speichern (o Unicode)" },
 { "Choose...","Wähle..." },
 { "Use colors for application:","Setze Farben für Programm:" },
 { "Buttons, menus, etc.:","Knöpfe, Menu, etc.:" },
 { "Frames, labels, etc.:","Rahmen, Label, etc.:" },
 { "Show parent To-Do's in What's Next view","Zeige Ober-Todo in What's Next Anz." },
 { "Show location in What's Next view","Zeige Ort in What's Next Anz." },
 { "Show events that recur ","Zeige Termine, die sich wiederholen:" },
 { "Show in every cell ","Zeige in jeder Zelle " },
 { "short month","kurzen Monat" },
 { "icons","Icons" },
 { "Show Sat/Sun together","Zeige Sam/Son zusammen" },
 { "Categorie colors are applied to text","Kategorie Farben färben Text" },
 { "Month view uses day colors","Monatsansicht zeigt Tagesfarben" },
 { "Day color odd months","Tagesfarbe ungerade Monate" },
 { "Day color even months","Tagesfarbe gerade Monate" },
 { "Color for Sundays + category \"Holiday\"","Farbe für Sonntag + Kateg.\" Feiertag\"" },
 { "To-do view shows complete as 'xx %'","Zeige Prozent erledigt als 'xx %'" },
 { "Small To-do view uses smaller font","Kleine To-do Ansicht nutzt kleineren Font" },
 { "Colors are applied to text","Farben werden auf Text angewendet" },
 { "Use internal alarm notification","Nutze interne Alarm Benachrichtigung" },
 { "Note: KO/Pi must be running to notify you about an alarm. Recommended for use on Zaurus: Disable this option and install KO/Pi alarm applet.\n","Achtung: KO/Pi muß ausgeführt werden damit die Benachrichtigung funktioniert. Empfehlung für Zaurus: Diese Option nicht wählen und KO/Pi Alarm Applet installieren.\n" },
 { "Play beeps count:","Anzahl der Alarmpiepse: " },
 { "Beeps interval in sec:","Zeitintervall der Alarmpiepse: " },
 { "Default suspend time in min:","Standard Supendierungs Zeit: " },
 { "Auto suspend count:","Anzahl der auto Suspendierungen" },
 { "Alarm *.wav file for newly created alarm:","Alarm *.wav Datei für neu angelegte Alarme:" },
 { "New profile","Neues Profil" },
 { "Clone profile","Klone Profil" },
 { "Delete profile","Lösche Profil" },
 { "Profile:","Profil:" },
 { "Include in multiple sync","Beziehe Profil in mehrfach Sync mit ein" },
 { "Force: Take local entry always","Erzwinge: Nimm immer lokalen Eintrag" },
 { "Force: Take remote entry always","Erzwinge: Nimm immer fernen Eintrag" },
 { "Show summary after sync","Zeige Zusammenfassung nach dem Synchronisieren" },
 { "Write back file","Schreibe Datei zurück" },
 { "Remote file (w down/upload command)","Entfernte Datei (via down/upload Kommando)" },
 { "Pre sync (download) command:","Bevor Sync (download) Kommando:" },
 { "Local device name:","Name dieses Gerätes:" },
 { "Ask for preferences before sync","Frage nach Synchronisationseinstellungen vor dem Syncen" },
 { "Sync preferences","Synchronisations Einstellungen" },
 { "Profile kind","Profil Art" },
 { "Local file","Lokale Datei" },
 { "Local file:","Lokale Datei:" },
 { "Post sync (upload) command:","Nach Sync (upload) Kommando:" },
 { "Fill in default values for:","Setze Beispiel Werte ein für:" },
 { "Hint: Use $PWD$ for placeholder of password!","Hinweis: Benutze $PWD$ als Platzhalter für ein Passwort!" },
 { "Synchronization Preferences","Einstellungen der Synchronisationsprofile"},
 { "Device","Gerät:" },
 { "Sync with file \n...%1\nfrom:\n%2\n","Sync mit Datei \n...%1\nvom:\n%2\n" },
 { "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","Synchronisationsübersicht:\n\n %d items lokal hinzugefügt\n %d items entfernt hinzugefügt\n %d items lokal geändert\n %d items entfernt geändert\n %d items lokal gelöscht\n %d items entfernt gelöscht\n" },
 { "Synchronization successful","Synchronisation erfolgreich" },
 { "Sync cancelled or failed. Nothing synced.","Sync abgebrochen oder fehlgeschlagen. Nichts wurde gesynced." },
 { "Sync file \n...%1\ndoes not exist!\nNothing synced!\n","Sync Datei \n...%1\nexistiert nicht!\nNichts wurde gesynced!\n" },
 { "Sync filename(*.ics/*.vcs)","Sync Dateiname(*.ics/*.vcs)" },
 { "Enter password","Passwort eingeben" },
 { "Do you really want\nto remote sync\nwith profile \n","Wollen Sie wirklich\nmit dem entfernten\nProfil syncen: \n" },
 { "Copy remote file to local machine...","Kopiere entfernte Datei auf lokalen Rechner..." },
 { "Sorry, the copy command failed!\nCommand was:\n%1\n \nTry command on console to get more\ndetailed info about the reason.\n","Sorry, das Kopierkommando schlug fehl!\nKommando war:\n%1\n \nVersuche Kommando von Kosole um\nDetails für das Fehlschlagen\nzu erfahren.\n" },
 { "Writing back file result: ","Resultat des Dateizurückschreibens: " },
 { "Syncronization sucessfully completed","Synchronisation erfolgreich abgeschlossen" },
 { "Edit Calendar Filters","Editiere Kalendar Filter" },
 { "Enter filter name:","Neuer Filter Name:" },
 { "Add Filter","Filter hinzufügen" },
 { "Question","Frage" },
 { "Filter position: ","Filter Position: " },
 { "Month View","Monatsansicht" },
 { "This profil cannot be deleted!\n","Dieses Profil kann\nnicht gelöscht werden!" },
 { "KO/Pi config error","KO/Pi Konfig. Fehler" },
 { "Local device name undefined!\nPlease define device name!","Name dieses Gerätes undefiniert!\nBitte Namen angeben!" },
 { "Multiple profiles with same name!\nPlease use unique profile names!","Mehrere Profile haben denselben Namen!\nBitte unterschiedliche Namen wählen!" },
 { "Access: ","Zugriff: " },
 { "Needs Action","Aktion notwendig" },
 { "Accepted","Akzeptiert" },
 { "Declined","Abgelehnt" },
 { "Tentative","Vorläufig" },
 { "Delegated","Beauftragt" },
 { "Completed","Vollständig" },
 { "In Process","In Bearbeitung" },
 { "Participant","Teilnehmer" },
 { "Optional Participant","Möglicher Teilnehmer" },
 { "Observer","Beobachter" },
 { "Chair","Vorsitzender" },
 { "Not supported \non desktop!\n","" },
 { "Nothing selected!\n\nThis prints the full width of the Agenda view as you see it!\n\nTo determine the vertical range of the printing, please select\na vertical range (with the left mouse button down) in one column. ","Es ist nichts selektiert!\nDieses druckt die volle Breite der Agenda View, so wie man sie sieht.\nUm die verticale Auswahl zum Drucken zu bestimmen,\nbitte einen verticalen Zeitraum (mit gedrückter linker Maustaste)\nin einer Spalte auswählen. " },
 { "Date range: ","Datums Zeitspanne: " },
 { "Not supported \non  PDA!\n","Nicht verfügbar\nauf dem PDA. " },
 { "Syncing - close to abort!","Syncing-schließe um abzubrechen." },
 { "Add / remove events","Add./entferne Termine" },
 { "File does not exist:\n '%1'.","Datei existiert nicht:\n '%1'." },
 { "Couldn't load calendar\n '%1'.","Kann Kalender nicht laden:\n '%1'." },
 { "\nThe file on disk has changed!\nFile size: %1 bytes.\nLast modified: %2\nDo you want to:\n\n - Save and overwrite file?\n - Sync with file, then save?\n - Cancel without saving? \n","\nDie gepeicherte Datei wurde verändert!\nDatei Grösse: %1 Bytes.\nZuletzt geändert: %2\nMöchten Sie:\n\n - Speichern und die Datei überschreiben?\n - Mit Datei Synchronisieren, dann speichern?\n - Abbrechen ohne zu speichern? \n" },
 { "Overwrite","Überschreiben" },
 { "Sync+save","Syncen+speichern" },
 { "Default","Standard" },
 { " Categories added to list! "," Kategorien zur Liste hinzugefügt! " },
 { "  %d items?","  %d Einträge?" },
 { "\nThis event recurs\nover multiple dates.\nAre you sure you want\nto delete this event\nand all its recurrences?","\nDieses ist ein\nwiederholender Termin!.\nSind Sie sicher, dass Sie\ndiesen Termin und alle\nWiederholungen löschen möchten?" },
 { " ?\n\nDelete:\n"," ?\n\nLösche:\n" },
 { "Current","Aktuelle" },
 { "\nThis event recurs\nover multiple dates.\nDo you want to delete\nall it's recurrences,\nor only the current one on:\n","\nDieses ist ein\nwiederholender Termin!\nMöchten sie alle Wiederholungen\nlöschen, oder nur die aktuelle am:\n" }, 
 { "All","Alle" },
 { "Data Loss Warning","Datenverlust Warnung" },
 { "Proceed","Weitermachen" },
 { "The journal entries can not be\nexported to a vCalendar file.","Die Journal Einträge können\nnicht in eine vCalendar\nDatei exportiert werden!" },
 { "Filter disabled ","Filter abgeschaltet" },
 { "Filter selected: ","Gewählter Filter: " },
 { "Toggle Cancel","Gecancelt ändern" },
 { "&Toggle Cancel","Gecancel&t ändern" },
 { "Configure Toolbar","Konfiguriere Toolbar" },
 { "Stretched TB","Gedehnte TB" },
 { "Import file \n...%1\ndoes not exist!\nNothing imported!\n","Import Datei \n...%1\nexistiert nicht!\nNichts importiert!\n" },
 { "Import filename(*.ics/*.vcs)","Import Dateiname(*.ics/*.vcs)" },
 { "When importing a calendar twice\nduplicated events will be ignored!\nYou can create a backup file with\nFile - Save Calendar Backup\nto revert importing","Wenn ein Kalender doppelt importiert\nwird, werden doppelte Einträge ignoriert!\nSie können eine Backup Datei anlegen unter\nDatei - Speichere Kalender Backup\num den Import rückgängig machen zu können.\n" },
 { "Not supported \non desktop!\n","Nur verfügbar auf PDA!" },
 { "Imported file successfully","Datei erfolgreich importiert" },
 { "Error importing file","Fehler beim Importieren der Datei" },
 { "Export vcal filename(*.vcs)","Export vcal Dateiname(*.vcs)" },
 { "Save file\nalready exists!\nOld save file from:\n%1\nOverwrite?\n","Zu speichernde Datei\existiert bereits!\nExist. Datei vom:\n%1\nÜberschreiben?\n" },
 { "Overwrite!","Überschreiben!" },
 { "Import file \n...%1\nfrom:\n%2\nDuplicated entries\nwill not be imported!\n","Import Datei \n...%1\nvom:\n%2\nDuplizierte Einträge\nwerden nicht importiert!\n" },
 { "Load backup filename","Lade Backup Dateiname" },
 { "Backup file\ndoes not exist!\nNothing loaded!","Backup Datei\nexistiert nicht!\nNichts geladen!" },
 { "KO/Pi:Loaded %1","KO/Pi:Geladen %1" },
 { "Save backup filename","Speichere Backup Dateiname" },
 { "Backup file\nalready exists!\nOld backup file from:\n%1\nOverwrite?\n","Backup Datei\nexistiert bereits!\nAlte Backup Datei vom:\n%1\nÜberschreiben?\n" },
 { "KO/Pi:Saved %1","KO/Pi:Gespeichert %1" },
 { "Details of attendee","Teilnehmerdetails" },
 { "Work phone:\n","Telefon Arbeit:\n" },
 { "Work mobile phone:\n","Mobiltelefon Arbeit:\n" },
 { "Home phone:\n","Telefon privat:\n" },
 { "Mobile home phone:\n","Mobiltelefon privat:\n" },
 { "Email:\n","Email:\n" },
-{ "Alarm disabled","Alarm deaktiviert" },
-{ "Audio.Al.: ","Audio Al.: " },
-{ "Proc.Al.: ","Proc.Al.: " },
+{ "Alarm disabled for this item","Alarm deaktiviert für dieses Item" },
+{ "Audio Al.: ","Audio Al.: " },
+{ "Proc.Al.: ","Proz.Al.: " },
 { "No sound set","Kein Sound definiert" },
 { "*.wav|Wav Files","*.wav|Wav Dateien" },
 { "No program set","Kein Programm definiert" },
 { "Running '%1'","Ausführen '%1'" },
 { "Playing '%1'","Abspielen '%1'" },
 { "Show Sync Events in WN/Agenda view","Zeige Sync Events in WN/Agenda Ansicht" },
 { "User defined (usertranslation.txt)","Benutzerdefiniert (usertranslation.txt)" },
 { "Load!","Laden!" },
 { "Backup file from:\n%1\nLoading  backup\nfile will delete\nyour current Data!\n","Backup Datei vom:\n%1\nDas Laden der Backup Datei\nlöscht die aktuellen Daten!\n" },
 { "KO/Pi Features and hints","KO/Pi Eigenschaften und Tipps" },
 { "KO/Pi User translation HowTo","KO/Pi Benutzer-Übersetzung HowTo" },
 { "KO/Pi Synchronization HowTo","KO/Pi Synchronisation HowTo" },
 { "Features + hints...","Eigenschaften + Tipps..." },
 { "User translation...","Benutzer Übersetzung..." },
 { "Sync HowTo...","Synchronisation HowTo..." },
 { "Print calendar...","Drucke Kalender..." },
 { "Anniversary","Jahrestag" },
 { "When importing birthdays twice\nduplicated events will be ignored,\nif the event has not been\nchanged in KO/Pi!\n","Wenn Geburtstage mehrfach importiert\nwerden, werden doppelte Einträge ignoriert\nwenn sie nicht verändert wurden.\n" },
 { "Import Birthdays (KA/Pi)","Importiere Geburtstage (KA/Pi)" },
 { "Next recurrence is on: ","Nächste Wiederholung ist am:" },
 { "<b>Alarm on:  </b>","<b>Alarm am:  </b>" },
 { "<b>Access: </b>","<b>Zugriff: </b>" },
 { "(%1 min before)","(%1 min vorher)" },
 { "<b>Categories: </b>","<b>Kategorien: </b>" },
 { "Save Journal/Description...","Speichere Journal/Details..." },
 { "This saves the text/details of selected\nJournals and Events/Todos\nto a text file.","Das speichert den Text bzw.\ndie Details von selektierten\nJournalen und Events/Todos\nin eine Textdatei." },
 { "Continue","Weitermachen" },
 { " birthdays/anniversaries added!"," Geburts-/Jahrestage hinzugefügt" },
 { "Attendee:","Teilnehmer:" },
 { "Click OK to search ->","Klicke zum Suchen auf OK ->" },
 { "On day ","Am Tag " },
 { "%1 of ","%1 des Monats" },
 { "%1 of the year","%1 des Jahres" },
 { "Anonymous","Anonymo" },
 { "nobody@nowhere","niemand@nirgendwo" },
 { "calendar.html","calendar.html" },
 { " Local Time"," Locale Zeit" },
 { "Unknown Name","Unbekannter Name" },
 { "unknown@nowhere","unbekannt@nirgendwo" },
 { "Beam via IR!","Beam via IR!" },
 { "Next Month","Nächster Monat" },
 { "Prio","Prio" },
 { "Reparent Todo","Mache Sub-Todo" },
 { "tomorrow","morgen" },
 { "today","heute" },
 { "yesterday","gestern" },
 { "Ok","Ok" },
 { "Ok+Agenda","Ok+Agenda" },
 { "Email","Email" },
 { "RSVP","RSVP" },
 { "Email:","Email:" },
 { "Appointment Time ","Termin Zeit " },
 { "2","2" },
 { "3","3" },
 { "4","4" },
 { "  0 %","  0 %" },
 { " 20 %"," 20 %" },
 { " 40 %"," 40 %" },
 { " 60 %"," 60 %" },
 { " 80 %"," 80 %" },
 { "100 %","100 %" },
 { "Filter","Filter" },
 { "Configure","Konfiguriere" },
 { "What's Next","What's Next" },
 { "Complete calendar...","Kompletten Kalender..." },
 { "Filtered calendar...","Gefilterten Kalender..." },
 { "Export to phone","Exportiere zum Handy" },
 { "Beam receive enabled","Beam Empfang an" },
 { "What's new?","Was ist neu?" },
 { "FAQ...","FAQ..." },
 { "Licence...","Licence..." },
 { "What's This?","What's This?" },
 { "&Edit...","&Editiere..." },
 { "Oktober","Oktober" },
 { "Title","Titel" },
 { "%1 %","%1 %" },
 { "Enable Pi-Sync","Schalte Pi-Sync an" },
 { "Import!","Importiere!" },
 { "inserting birthdays - close to abort!","Burzeltage werden eingefügt - schließe um abzubrechen!" },
 { "Export to phone options","Export ans Handy Optionen" },
 { "Please read Help-Sync Howto\nto know what settings to use.","Bitte lese Hilfe-Sync Howto\num zu erfahren welche Einstellungen\ndie richtigen sind." },
 { "I/O device: ","I/O device: " },
 { "Connection: ","Connection: " },
 { "Model(opt.): ","Model(opt.): " },
 { "Write back events in future only","Schreibe nur zukünftige Termine zurück" },
 { "Max. weeks in future: ","Max. Wochen in der Zukunft: " },
 { "NOTE: This will remove all old\ntodo/calendar data on phone!","ACHTUNG: Das löscht alle alten\nToDo/Kalender Daten auf dem Handy!" },
 { "Export to mobile phone!","Exportiere auf das Handy!" },
 { "Export complete calendar","Exportiere kompletten Kalender" },
 { "Writing to phone...","Sende Daten ans Handy..." },
 { " This may take 1-3 minutes!"," Das kann 1-3 Minuten dauern!" },
 { "Retry","Nochmal versuchen" },
 { "KDE/Pim phone access","KDE/Pim Handy Zugriff" },
 { "Error accessing device!\nPlease turn on connection\nand retry!","Fehler beim Zugriff auf das Gerät!\nBitte die Verbindung aktivieren\nund nochmal versuchen!" },
 { "Error exporting to phone!","Fehler beim Export auf das Handy!" },
 { "Export filtered calendar","Exportiere gefilterten Kalender" },
 { "Preferences","Vorlieben" },
 { "Global","Global" },
 { "Phone","Phone" },
 { "SMS","SMS" },
 { "Fax","Fax" },
 { "Pager","Pager" },
 { "SIP","SIP" },
 { "Italian","Italienisch" },
 { "24:00","24:00" },
 { "12:00am","12:00am" },
 { "24.03.2004 (%d.%m.%Y|%A %d %B %Y)","24.03.2004 (%d.%m.%Y|%A %d %B %Y)" },
 { "03.24.2004 (%m.%d.%Y|%A %B %d %Y)","03.24.2004 (%m.%d.%Y|%A %B %d %Y)" },
 { "2004-03-24 (%Y-%m-%d|%A %Y %B %d)","2004-03-24 (%Y-%m-%d|%A %Y %B %d)" },
 { "Mon 19.04.04: %a %d.%m.%y","Mon 19.04.04: %a %d.%m.%y" },
 { "Mon, 19.Apr.04: %a, %d.%b.%y","Mon, 19.Apr.04: %a, %d.%b.%y" },
 { "Add 30 min to selected Timezone","Addiere 30 min zur Zeitzone" },
 { "Used Mail Client","Benutzter Mail Client" },
 { "Channel:","Channel:" },
 { "Message:","Message:" },
 { "Parameters:","Parameter:" },
 { "HINT: Delimiter=; Name=%1,Email=%2","Hinweis: Begrenzer=; Name=%1,Email=%2" },
 { "extra Message:","extra Message:" },
 { "extra Parameters:","extra Parameter:" },
 { "HINT: Emails=%1,Attachments=%2","Hinweis: Emails=%1,Attachments=%2" },
 { "External Apps.","Externe Appl." },
 { "24 hours","24 Std." },
 { "3 hours","3 Std." },
 { "1 hour","1 Std." },
 { "15 minutes","15 Min." },
 { "5 minutes","5 Min." },
 { "1 minute","1 Min." },
 { "23","23" },
 { "Mon 15","Mon 15" },
 { "Configure KO","Konfiguriere KO" },
 { "Event text","Termin Text" },
 { "ToDo","ToDo" },
 { "Today","Heute" },
 { "What's Next View","What's Next Ansicht" },
 { "Show Sync Events in \nWhat's Next/Agenda view","Zeige Sync Termine in \nWhat's Next/Agenda view" },
 { "Use short date in \nWhat's Next/Event view","Zeige Kurzdatum in \nWhat's Next/Event view" },
 { "Allday Agenda view shows todos","Ganztag Agenda zeigt Todos" },
 { "Alarm","Alarm" },
 { "Used %1 Client","Benutzter %1 Client" },
 { "No email client installed","Kein Email Klient installiert" },
 { "Userdefined email client","Benutzerdef. Email Klient" },
 { "OM/Pi email client","OM/Pi Email Klient" },
 { "Include in multiple ","Beziehe in multiple " },
 { "calendar  ","Kalender  " },
 { "addressbook  ","Adressbuch  " },
 { "pwmanager","PWmanager" },
 { " sync"," Sync ein" },
 { "Write back synced data","Schreibe gesyncte Daten zurück" },
 { "-- Write back (on remote) existing entries only","-- Schreibe nur existierende (entfernte) Einträge zurück" },
 { "-- Write back (calendar) entries in future only","-- Schreibe nur zukünftige Kalender-Einträge zurück" },
 { "---- Max. weeks in future: ","---- Max. wochen in der Zukunft: " },
 { "Pi-Sync ( direct Kx/Pi to Kx/Pi sync )","Pi-Sync ( direktes Kx/Pi zu Kx/Pi sync )" },
 { "Mobile device (cell phone)","Mobiles Gerät (Handy)" },
 { "Help...","Hilfe..." },
 { "Local file Cal:","Lokale Datei Kal:" },
 { "Local file ABook:","Lokale Datei ABuch:" },
 { "Local file PWMgr:","Lokale Datei PWMgr:" },
 { "Addressbook file (*.vcf) is used by KA/Pi","Adressbuch Datei (*.vcf) wird von KA/Pi genutzt" },
 { "Calendar:","Kalender:" },
 { "AddressBook:","AdressBuch:" },
 { "PWManager:","PWManager:" },
 { "Addressbook file is used by KA/Pi","Adressbuch Datei wird von KA/Pi genutzt" },
 { "ssh/scp","ssh/scp" },
 { "ftp","ftp" },
 { "Password for remote access: (could be the same for each)","Passwort für entfernten Zugriff: (kann dasselbe sein für alle)" },
 { "Remote IP address: (could be the same for each)","Entfernte IP Adresse: (kann dasselbe sein für alle)" },
 { "Remote port number: (should be different for each)","Entfernte Port Nummer: (Sollte für alle unterschiedlich sein)" },
 { "command for downloading remote file to local device","Kommando zum Download der entfernten Datei zum lokalen Gerät" },
 { "command for uploading local temp file to remote device","Kommando zum Upload der lokalen temp. Datei zum entfernten Gerät" },
 { "Insert device where\nphone is connected. E.g.:\n","Füge Device ein, an dem\ndas Handy angeschlossen ist. Z.B.:\n" },
 { "KDE-Pim sync config","KDE-Pim sync Konfig" },
 { "Insert kind of connection,e.g.:\n","Füge Art der Verbindung ein,z.B.:\n" },
 { "Recommended: Leave empty!\n(Such that model can\nbe auto detected)\nOr insert name of model:\n","Empfohlen: Leer lassen!\n(So dass das Model\nautomatisch erkannt\nwerden kann)\nOder füge Model Name ein:\n" },
 { "Port number (Default: %1)","Port Nummer (Default: %1)" },
 { "Password to enable\naccess from remote:","Passwort um entfernten\nZugriff zuzulassen:" },
 { "Automatically start\nat application startup","Starte automatisch\nbeim Programmstart" },
 { "Automatically sync\nwith KDE-Desktop","Automatischer Sync\nmit dem KDE-Desktop" },
 { "Enter port for Pi-Sync","Port Nummer für Pi-Sync" },
 { "Disable Pi-Sync","Schalte Pi-Sync aus" },
 { "Do you really want\nto multiple sync\nwith all checked profiles?\nSyncing takes some\ntime - all profiles\nare synced twice!","Wollen Sie wirklich\nmit allen selektierten\nProfilen \"Multi-Syncen\"?\nDas Syncen dauert einige Zeit -\nalle Profile werden zweimal gesynct!" },
 { "KDE-Pim Sync","KDE-Pim Sync" },
 { "Multiple profiles","Multi-Sync Profile" },
 { "Device: ","Gerät: " },
 { "Multiple sync started.","Multi-Sync gestartet." },
 { "Nothing synced! No profiles defined for multisync!","Nichts gesynct! Keine Profile\nselektiert für Multi-Sync" },
 { "Turn filter on","Schalte Filter an" },
 { "Turn filter off","Schalte Filter aus" },
 { "Key bindings  KOrganizer/Pi","Tastatur Belegung KOrganizer/Pi" },
 { "<p><b>White</b>: Item readonly</p>\n","<p><b>Weiss</b>: Eintrag schreibgeschützt</p>\n" },
 { "<p><b>Dark yellow</b>:  Event/todo with attendees.</p>\n","<p><b>Dunkelgelb</b>:  Termin/Todo mit Teilnehmern.</p>\n" },
 { "<p><b>Black</b>: Event/todo with attendees. You are the organizer!</p>\n","<p><b>Schwarz</b>: Termin/Todo mit Teilnehmern. Sie sind der Organisator!</p>\n" },
 { "<p><b>Dark green</b>: Information(description) available.([i] in WN view)</p>\n","<p><b>Dunkelgrün</b>: Information(Beschreibung) verfügbar.([i] in WN Ansicht)</p>\n" },
@@ -1002,197 +1001,201 @@
 { "<p><b>E</b>:  Edit item</p>\n","<p><b>E</b>:  Editiere Eintrag</p>\n" },
 { "<p><b>A</b>: Show agenda view.</p>\n","<p><b>A</b>: Zeige Agenda Ansicht.</p>\n" },
 { "<p><b>I,C</b>: Close dialog.</p>\n","<p><b>I,C</b>: Schließe Dialog.</p>\n" },
 { "<p><h3>In event/todo viewer:</h3></p>\n","<p><h3>In Termin/Todo Detail-Anzeige:</h3></p>\n" },
 { "<p><b>shift+up/down</b>: Goto first/last item</p>\n","<p><b>shift+up/down</b>: Gehe zum ersten/letzten Eintrag</p>\n" },
 { "<p><b>ctrl+up/down</b>:  Goto up/down by 20% of items</p>\n","<p><b>ctrl+up/down</b>:  Gehe hoch/runter 20% aller Einträge</p>\n" },
 { "<p><b>up/down</b>: Next/prev item</p>\n","<p><b>up/down</b>: Nächster/vorheriger Eintrag</p>\n" },
 { "<p><b>return+shift</b>: Deselect item+one step down</p>\n","<p><b>return+shift</b>: Deselektiere Item+Cursor einen Eintrag runter</p>\n" },
 { "<p><b>return</b>: Select item+one step down</p>\n","<p><b>return</b>: Selektiere Item+Cursor einen Eintrag runter</p>\n" },
 { "<p><b>I</b>: Show info of current item+one step down.</p>\n","<p><b>I</b>: Zeige Detail-Ansicht vom sel.Eintrag+Cursor einen Eintrag runter.</p>\n" },
 { "<p><h3>In list view:</h3></p>\n","<p><h3>In Listen Ansicht:</h3></p>\n" },
 { "<p><b>return+shift</b>:  Mark item as not completed+one step down</p>\n","<p><b>return+shift</b>:  Markiere Todo als nicht erledigt+Cursor einen Eintrag runter</p>\n" },
 { "<p><b>return</b>: Mark item as completed+one step down.</p>\n","<p><b>return</b>: Markiere Todo als erledigt+Cursor einen Eintrag runter.</p>\n" },
 { "<p><b>Q</b>: Toggle quick todo line edit.</p>\n","<p><b>Q</b>: Zeige/verstecke Quick Todo Eingabe Zeile.</p>\n" },
 { "<p><b>shift+P</b>: Make new <b>P</b>arent for todo selected with shift+S</p>\n","<p><b>shift+P</b>: Mache Todo zum neuen <b>P</b>arent Todo für das Todo, welches mit shift+Sselektiert wurde.</p>\n" },
 { "<p><b>shift+S</b>: Make <b>S</b>ubtodo (reparent todo)</p>\n","<p><b>shift+S</b>: Mache Todo zum <b>S</b>ubtodo</p>\n" },
 { "<p><b>shift+U</b>: <b>U</b>nparent todo (make root todo)</p>\n","<p><b>shift+U</b>: <b>U</b>nparent Todo (Mache Sub-Todo zum Toplevel Todo)</p>\n" },
 { "<p><h3>In todo view:</h3></p>\n","<p><h3>In Todo Anzige:</h3></p>\n" },
 { "<p><b>ctrl+up/down</b>: Scroll small todo view</p>\n","<p><b>ctrl+up/down</b>: Scrolle kleine Todo Ansicht</p>\n" },
 { "<p><b>up/down</b>: Scroll agenda view</p>\n","<p><b>up/down</b>: Scrolle Agenda Ansicht</p>\n" },
 { "<p><h3>In agenda view:</h3></p>\n","<p><h3>In Agenda Ansicht:</h3></p>\n" },
 { "<p><b>del,backspace</b>: Delete selected item</p>\n","<p><b>del,backspace</b>: Lösche selektiertes Item</p>\n" },
 { "<p><b>left</b>: Prev. week | <b>left+ctrl</b>: Prev. month</p>\n","<p><b>left</b>: Vorh. Woche | <b>left+ctrl</b>: Vorh. Monat</p>\n" },
 { "<p><b>right</b>: Next week | <b>right+ctrl</b>: Next month</p>\n","<p><b>right</b>: Nächste Woche | <b>right+ctrl</b>: Nächste Woche</p>\n" },
 { "<p><b>B</b>: Edit description (details) of selected item</p>\n","<p><b>B</b>: Editiere Beschreibung (Details) des selektierten Items</p>\n" },
 { "<p><b>C</b>: Show current time in agenda view</p>\n","<p><b>C</b>: Zeige aktuelle Zeit in Agenda Ansicht</p>\n" },
 { "<p><b>+,-</b> : Zoom in/out agenda | <b>A</b>: Toggle allday agenda height</p>\n","<p><b>+,-</b> : Zoom rein/raus Agenda | <b>A</b>: Wechsle Ganztag Agenda Höhe</p>\n" },
 { "<p><b>S+ctrl</b>: Add sub-todo | <b>X</b>: Toggle datenavigator</p>\n","<p><b>S+ctrl</b>: Füge Sub-Todo hinzu | <b>X</b>: Zeige/verstecke Datenavigator</p>\n" },
 { "<p><b>T</b>: Goto today | <b>T+ctrl</b>: New Todo</p>\n","<p><b>T</b>: Gehe zu Heute | <b>T+ctrl</b>: Neues Todo</p>\n" },
 { "<p><b>E</b>: Edit selected item |<b> E+ctrl</b>: New Event</p>\n","<p><b>E</b>: Editiere selektiertes Item |<b> E+ctrl</b>: Neuer Termin</p>\n" },
 { "<p><b>D</b>: One day view | <b>M</b>: Month view</p>\n","<p><b>D</b>: Ein-Tages Ansicht | <b>M</b>: Monats Ansicht</p>\n" },
 { "<p><b>Z,Y</b>: Work week view | <b>U</b>: Week view</p>\n","<p><b>Z,Y</b>: Arbeitswochen Ansicht | <b>U</b>: Wochen Ansicht</p>\n" },
 { "<p><b>V</b>: Todo view | <b>L</b>: Event list view</p>\n","<p><b>V</b>: Todo Ansicht | <b>L</b>: Termin Listen Ansicht</p>\n" },
 { "<p><b>N</b>: Next days view| <b>W</b>: What's next view\n ","<p><b>N</b>: Nächste-Tage Ansicht days view| <b>W</b>: What's next Ansicht\n " },
 { "<p><b>1-0</b> (+<b>ctrl</b>): Select filter 1-10 (11-20)</p>\n","<p><b>1-0</b> (+<b>ctrl</b>): Selektiere Filter 1-10 (11-20)</p>\n" },
 { "<p><b>O</b>: Filter On/Off | <b>J</b>: Journal view</p>\n","<p><b>O</b>: Filter An/Aus | <b>J</b>: Journal Ansicht</p>\n" },
 { "<p><b>F</b>: Toggle filterview |<b>F+ctrl</b>: Edit filter </p>\n","<p><b>F</b>: Zeige/verstecke Filter Ansicht |<b>F+ctrl</b>: Editiere Filter </p>\n" },
 { "<p><b>Space</b>: Toggle fullscreen | <b>P</b>: Date picker</p>\n","<p><b>Space</b>: Zeige fullscreen | <b>P</b>: Datums Picker</p>\n" },
 { "<p><b>I</b>: Show info for selected event/todo</p>\n","<p><b>I</b>: Zeige Info (Details) für selektiertes Item</p>\n" },
 { "<p><b>H</b>: This help dialog | <b>S</b>: Search dialog</p>\n","<p><b>H</b>: Dieser Hilfe Dialog | <b>S</b>: Such Dialog</p>\n" },
 { "<p><h2>KO/Pi key shortcuts:</h2></p>\n","<p><h2>KO/Pi Tastatur Kurzbefehle:</h2></p>\n" },
 { "After changing something, the data is\nautomatically saved to the file\n~/kdepim/apps/korganizer/mycalendar.ics\nafter (configurable) three minutes.\nFor safety reasons there is  one autosaving\nafter 10 minutes (of idle time) again. The \ndata is saved automatically when closing KO/Pi\nYou can create a backup file \nwith: File - Save Calendar Backup\n","Nachdem etwas geändert wurde, werden die\nDaten automatisch in die Datei abgespeichert\n~/kdepim/apps/korganizer/mycalendar.ics\nnach (konfigurierbar) drei Minuten.\nAus Sicherheitsgründen wird noch einmal\nnach 10 Min. abgespeichert, wenn keine\nÄnderungen vorgenommen wurden. Die \nDaten werden automatisch gespeichert,\nwenn KO/Pi beendet wird.\nSie können eine Backup-Datei erstellen im\nMenu: Datei - Speichere Kalender Backup\n" },
 { "Auto Saving in  KOrganizer/Pi","Auto Speichern in  KOrganizer/Pi" },
 { "\nhttp://sourceforge.net/projects/kdepimpi\n","\nhttp://sourceforge.net/projects/kdepimpi\n" },
 { "\nor report them in the bugtracker on\n","\noder trage sie in dem Bugtracker ein auf\n" },
 { "\nPlease report unexpected behaviour to\nlutz@pi-sync.net\n","\nBitte melde fehlerhaftes Verhalten an\nlutz@pi-sync.net\n" },
 { "2) Audio alarm daemon\nfor Zaurus is available!\nas an additional small application\n","2) Ein Audio Alarm Daemon\nfür den Zaurus ist verfügbar\nals zusätzliche Anwendung\n" },
 { "1) Importing *.vcs or *.ics files from\nother applications may not work properly,\nif there are events with properties\nKO/Pi does not support.\n","1) Importieren von *.vcs oder *.ics Dateien von\nanderen Anwendungen kann möglicherweise\n nicht richtig funktionieren,\nwenn die Termine Eigenschaften haben,\ndie KO/Pi nicht unterstützt.\n" },
 { "Known Problems in  KOrganizer/Pi","Bekannte Probleme in  KOrganizer/Pi" },
 { "KO/Pi FAQ","KO/Pi FAQ" },
 { "(c) 2004 Lutz Rogowski\nEmail:lutz@pi-sync.net\nKO/Pi is based on KOrganizer\n(c) 2002,2003 Cornelius Schumacher\nEmail: schumacher@kde.org\nKOrganizer/Pi is licensed\nunder the GPL.\nKO/Pi can be compiled for\nLinux, Zaurus-PDA and Windows\nwww.korganizer.org\nwww.pi-sync.net\n","(c) 2004 Lutz Rogowski\nEmail:lutz@pi-sync.net\nKO/Pi basiert auf KOrganizer\n(c) 2002,2003 Cornelius Schumacher\nEmail: schumacher@kde.org\nKOrganizer/Pi ist lizensiert unter der GPL.\nKO/Pi kann kompiliert werden für\nLinux, Zaurus-PDA und Windows\nwww.korganizer.org\nwww.pi-sync.net\n" },
 { "PDA-Edition\nfor: Zaurus 5x00 / 7x0 / 8x0\n","PDA-Edition\nfür: Zaurus 5x00 / 7x0 / 8x0\n" },
 { "KOrganizer/Platform-independent\n","KOrganizer/Platform-independent\n" },
 { "About KOrganizer/Pi","Über KOrganizer/Pi" },
 { "From: ","Von: " },
 { "Remove sync info","Entferne Sync Info" },
 { "For all profiles","Für alle Profile" },
 { "Hide not Running","Verstecke nicht Laufende" },
 { "ME","ME" },
 { "Toolbar","Toolbar" },
 { "Undo Delete...","Löschen rückgängig machen..." },
 { "Undo Delete","Löschen rückgängig machen" },
 { "KDE Sync HowTo...","KDE Sync HowTo..." },
 { "Multi Sync HowTo...","Multi Sync HowTo..." },
 { "Januar","Januar" },
 { "KO/Pi Keys + Colors","KO/Pi Tasten + Farben" },
 { "No Filter","Kein Filter" },
 { "Multiple Sync options","Multi Sync Optionen" },
 { "Sync algo options","Sync Ablauf Optionen" },
 { "Apply filter when adding data to local:","Filter für das Hinzufügen von Daten zu Lokal:" },
 { "Incoming calendar filter:","Eingehender Kalender Filter:" },
 { "Incoming addressbook filter:","Eingehender Adressbuch Filter:" },
 { "Write back options","Optionen zum Zurückschreiben" },
 { "Write back (on remote) existing entries only","Schreibe nur existierende (auf Entfernt) Einträge zurück" },
 { "Apply filter when adding data to remote:","Filter für das Hinzufügen von Daten zu Entfernt:" },
 { "Outgoing calendar filter:","Ausgehender Kalender Filter:" },
 { "Outgoing addressbook filter:","Ausgehender Adressbuch Filter:" },
 { "Write back (calendar) entries for time period only","Schreibe nur Kalender Einträge für Zeitspanne zurück" },
 { "Time period","Zeitspanne" },
 { "From ","Von " },
 { " weeks in the past to "," Wochen in der Vergangenheit bis zu " },
 { " weeks in the future "," Wochen in der Zukunft " },
 { "Profile kind specific settings","Profil Art abhängige Einstellungen" },
 { "Local temp file:","Lokale temp Datei:" },
 { "Multiple profiles with same name!\nPlease use unique profile names!","Mehrere Profile mit demselben Namen!\nBitte verschiedene Namen benutzen!" },
 { "Aborted! Nothing synced!","Abgebrochen! Nichts wurde gesynct!" },
 
 
 
 
 { "Language","Sprache" },
 { "Time Format","Zeit Format" },
 { "Time Zone","Zeit Zone" },
 { "Your current storage dir is:\n%1\nYour mail is stored in:\n(storagedir)/apps/kopiemail/localmail","Ihr gerade genutztes Speicherverzeichnis ist:\n%1\nIhre Mail wird gespeichert in:\n(speicherverzeichnis)/apps/kopiemail/localmail" },
 { "<b>Set new data storage dir:</b>","<b>Setze neues Datenspeicherverzeichnis:</b>" },
 { "Not existing dirs are created automatically","Nicht existierende Verzeichnisse werden erstellt" },
 { "Save settings","Speichere Einstellungen" },
 { "Save standard","Speichere Standard" },
 { "<b>New settings are used\nafter a restart</b>","<b>Neue Einstellungen werden nach\neinem Neustart genutzt</b>" },
 { "The settings of the storage\ndir is saved in the file\n%1","Die Einstellungen des Speicherverzeichnisses\nwerden in folgender Datei gespeichert:\n%1" },
 { "Data storage path","Daten Speicherpfad" },
 { "Language","Sprache" },
 { "Show time in agenda items","Zeige Zeit in Agenda Items" },
 { "Color for Sundays + category "Holiday"","Farbe für Sonntags + Kategorie "Feiertag"" },
 { "Show events, that are done in \nWhat's Next view","Zeige abgelaufene Termine in\nWhat's Next Ansicht" },
 { "Hide not running Todos in To-do view","Verstecke nicht laufende Todos in To-do Ansicht" },
 { "+01:00 Europe/Oslo(CET)","+01:00 Europe/Oslo(CET)" },
 { "KO/Pi","KO/Pi" },
 { "There is nothing to undo!","Es gibt nichts zum\nRückgängigmachen!" },
 { "Recreating edit dialog. Please wait...","Recreating edit dialog. Please wait..." },
 { "Sound.Al.: ","Sound.Al.: " },
 { "From: %1   To: %2   %3","Von: %1   Bis: %2   %3" },
 { "Restore","Wiederherstellen" },
 { "\nAre you sure you want\nto restore this?","\nMöchten Sie das wirklicht\nwiederherstellen?" },
 { "% completed","% komplett" },
 { "%d item(s) found.","%d Item(s) gefunden." },
 { "Set complete","Setze auf erledigt" },
 { "(cancelled)","(gecancelt)" },
 { "Click on the week number to\nshow week in agenda view","Klicke auf die Wochennummer\num die Woche in der Agenda anzuzeigen" },
 { " Local time "," Locale Zeit " },
 { "Form2","Form2" },
 { "Filter enabled","Filter angeschaltet" },
 { "Edit Filters","Ändere Filter" },
 { "Print What's Next View...","Drucke What's Next Ansicht..." },
 { "Agenda","Agenda" },
 { " ("," (" },
 { "<p><b>Due on:</b> %1</p>","<p><b>Fällig am:</b> %1</p>" },
 { "Print","Print" },
 { "&Setup Printer...","Drucker &Setup..." },
 { "View Type","Zeige Typ" },
 { "Page &orientation:","Seiten Ausrichtung:" },
 { "Use Default of Selected Style","Default des selektierten Stils" },
 { "Use Default Setting of Printer","Default Einstellung des Druckers" },
 { "Portrait","Portrait" },
 { "Landscape","Landschaft" },
 { "Print day","Drucke Tag" },
 { "CalPrintDay_Base","CalPrintDay_Base" },
 { "Date && Time Range","Datum && Zeitspanne" },
 { "&End date:","&Enddatum:" },
 { "&Start date:","&Startdatum:" },
 { "Start &time:","Startzeit:" },
 { "End ti&me:","Endzeit:" },
 { "E&xtend time range to include all events","Erweitere Zeitspanne um alle Ereignisse einzuschliessen" },
 { "Include to&dos that are due on the printed day(s)","Inclusive To&dos, die an den selektierten Tagen fällig sind" },
 { "Alt+D","Alt+D" },
 { "&Use colors","Nutze Farben" },
 { "Alt+U","Alt+U" },
 { "Print week","Drucke Woche" },
 { "CalPrintWeek_Base","CalPrintWeek_Base" },
 { "Use &colors","Nutze Farben" },
 { "Type of View","Typ der Ansicht" },
 { "Print as &Filofax page","Drucke als &Filofax Seite" },
 { "Alt+F","Alt+F" },
 { "Print as &timetable view:","Drucke als Zeittabelle:" },
 { "Alt+T","Alt+T" },
 { "Print as split week view","Drucke als gesplittete Wochenansicht" },
 { "Print month","Drucke Monat" },
 { "CalPrintMonth_Base","CalPrintMonth_Base" },
 { "&Start month:","&Startmonat:" },
 { "&End month:","&Endmonat:" },
 { "Print week &numbers","Drucke Wochen Nummer(n)" },
 { "Print todos","Drucke Todos" },
 { "CalPrintTodoConfig_Base","CalPrintTodoConfig_Base" },
 { "Include &description of the item","Inclusive Itembeschreibung" },
 { "Include d&ue date of the item","Inclusive Fälligkeitsdatum des Items" },
 { "Include &priority of the item","Inclusive Priorität des Items" },
 { "Items to Print","Zu druckende Items" },
 { "&From:","Von:" },
 { "&To:","Bis:" },
 { "Print &all todo items","Drucke alle Todo Items" },
 { "Print only &uncompleted items","Drucke nur nicht erledigte Todos" },
 { "Only items due in the &range:","Nur Items in dem Zeitraum:" },
 { "Todo List","Todo Liste" },
 { "&Title:","&Titel:" },
 { "Co&nnect subtodos with its parent","Verbinde Unter-Todos mit ihren Ober-Todos" },
 { "Todo list","Todo Liste" },
 { "&Print...","Drucke..." },
 { "<qt>Printing on printer <b>%1</b></qt>","<qt>Drucke auf Drucker <b>%1</b></qt>" },
 { "[Unconfigured]","[Unkonfiguriert]" },
 { "OK","OK" },
 { "FilterEditor","FilterEditor" },
 { "Include","Inclusive" },
 { "Exclude","Exclusive" },
 { "Edit Selection...","Editiere Selektion..." },
 { "recurring events","wiederholende Ereignisse" },
 { "completed to-dos","erledigte Todos" },
 { "events","Ereignisse" },
 { "todos","Todos" },
 { "journals","Journale" },
 { "public","öffentlich" },
 { "private","privat" },
 { "confidential","vertraulich" },
-{ "","" },
+{ "\nhas sub-todos.\nAll completed sub-todos\nwill be deleted as well!","\nhat Unter-Todos.\nAlle erledigten Unter-Todos\nwerden auch gelöscht!" },
+{ "Yesterday","Gestern" },
+{ "Day after tomorrow","Übermorgen" },
+{ "Tomorrow","Morgen" },
+{ "Day before yesterday","Vorgestern" },
 { "","" },
 { "","" },
 { "","" },
 { "","" },
diff --git a/korganizer/calendarview.cpp b/korganizer/calendarview.cpp
index 8f05276..038da54 100644
--- a/korganizer/calendarview.cpp
+++ b/korganizer/calendarview.cpp
@@ -1996,387 +1996,387 @@ void CalendarView::readFilterSettings(KConfig *config)
     mFilterView->updateFilters();
     config->setGroup("FilterView");
 
     mFilterView->blockSignals(true);
     mFilterView->setFiltersEnabled(config->readBoolEntry("FilterEnabled"));
     mFilterView->setSelectedFilter(config->readEntry("Current Filter"));
     mFilterView->blockSignals(false);
     // We do it manually to avoid it being done twice by the above calls
     updateFilter();
 }
 
 void CalendarView::writeFilterSettings(KConfig *config)
 {
     //  kdDebug() << "CalendarView::writeFilterSettings()" << endl;
 
     QStringList filterList;
 
     CalFilter *filter = mFilters.first();
     while(filter) {
         //    kdDebug() << " fn: " << filter->name() << endl;
         filterList << filter->name();
         config->setGroup("Filter_" + filter->name());
         config->writeEntry("Criteria",filter->criteria());
         config->writeEntry("CategoryList",filter->categoryList());
         filter = mFilters.next();
     }
     config->setGroup("General");
     config->writeEntry("CalendarFilters",filterList);
 
     config->setGroup("FilterView");
     config->writeEntry("FilterEnabled",mFilterView->filtersEnabled());
     config->writeEntry("Current Filter",mFilterView->selectedFilter()->name());
 }
 
 
 void CalendarView::goToday()
 {
     if ( mViewManager->currentView()->isMonthView() )
         mNavigator->selectTodayMonth();
     else
         mNavigator->selectToday();
 }
 
 void CalendarView::goNext()
 {
     mNavigator->selectNext();
 }
 
 void CalendarView::goPrevious()
 {
     mNavigator->selectPrevious();
 }
 void CalendarView::goNextMonth()
 {
     mNavigator->selectNextMonth();
 }
 
 void CalendarView::goPreviousMonth()
 {
     mNavigator->selectPreviousMonth();
 }
 void CalendarView::writeLocale() 
 {
     //KPimGlobalPrefs::instance()->setGlobalConfig();
 #if 0
     KGlobal::locale()->setHore24Format( !KOPrefs::instance()->mPreferredTime );
     KGlobal::locale()->setWeekStartMonday( !KOPrefs::instance()->mWeekStartsOnSunday );
     KGlobal::locale()->setIntDateFormat( (KLocale::IntDateFormat)KOPrefs::instance()->mPreferredDate );
     KGlobal::locale()->setLanguage( KOPrefs::instance()->mPreferredLanguage );
     QString dummy = KOPrefs::instance()->mUserDateFormatLong;
     KGlobal::locale()->setDateFormat(dummy.replace( QRegExp("K"), QString(",") ));
     dummy = KOPrefs::instance()->mUserDateFormatShort;
     KGlobal::locale()->setDateFormatShort(dummy.replace( QRegExp("K"), QString(",") ));
     KGlobal::locale()->setDaylightSaving( KOPrefs::instance()->mUseDaylightsaving,
                                           KOPrefs::instance()->mDaylightsavingStart,
                                           KOPrefs::instance()->mDaylightsavingEnd );
     KGlobal::locale()->setTimezone( KPimGlobalPrefs::instance()->mTimeZoneId );
 #endif
 }
 void CalendarView::updateConfig()
 {
     writeLocale();
     if ( KOPrefs::instance()->mUseAppColors )
         QApplication::setPalette( QPalette (KOPrefs::instance()->mAppColor1, KOPrefs::instance()->mAppColor2), true );
     emit configChanged();
     mTodoList->updateConfig();
     // mDateNavigator->setFont ( KOPrefs::instance()->mDateNavigatorFont);
     mCalendar->setTimeZoneId(KPimGlobalPrefs::instance()->mTimeZoneId);
     // To make the "fill window" configurations work
     //mViewManager->raiseCurrentView();
 }
 
 
 void CalendarView::eventChanged(Event *event)
 {
     changeEventDisplay(event,KOGlobals::EVENTEDITED);
     //updateUnmanagedViews();
 }
 
 void CalendarView::eventAdded(Event *event)
 {
     changeEventDisplay(event,KOGlobals::EVENTADDED);
 }
 
 void CalendarView::eventToBeDeleted(Event *)
 {
     kdDebug() << "CalendarView::eventToBeDeleted(): to be implemented" << endl;
 }
 
 void CalendarView::eventDeleted()
 {
     changeEventDisplay(0,KOGlobals::EVENTDELETED);
 }
 void CalendarView::changeTodoDisplay(Todo *which, int action)
 {
     changeIncidenceDisplay((Incidence *)which,  action);
     mDateNavigator->updateView(); //LR
     //mDialogManager->updateSearchDialog();
 
     if (which) {
         mViewManager->updateWNview();
         //mTodoList->updateView();
     }
    
 }
 
 void CalendarView::changeIncidenceDisplay(Incidence *which, int action)
 {
     updateUnmanagedViews();
     //qDebug(" CalendarView::changeIncidenceDisplay++++++++++++++++++++++++++  %d  %d ",which, action );
     if ( action == KOGlobals::EVENTDELETED ) { //delete
         mCalendar->checkAlarmForIncidence( 0, true );
         if ( mEventViewerDialog )
             mEventViewerDialog->hide();
     } 
     else
         mCalendar->checkAlarmForIncidence( which , false );
 }
 
 // most of the changeEventDisplays() right now just call the view's
 // total update mode, but they SHOULD be recoded to be more refresh-efficient.
 void CalendarView::changeEventDisplay(Event *which, int action)
 {
     //  kdDebug() << "CalendarView::changeEventDisplay" << endl;
     changeIncidenceDisplay((Incidence *)which,  action);
     mDateNavigator->updateView();
     //mDialogManager->updateSearchDialog();
 
     if (which) {
         // If there is an event view visible update the display
         mViewManager->currentView()->changeEventDisplay(which,action);
         // TODO: check, if update needed
         //    if (which->getTodoStatus()) {
         mTodoList->updateView();
         //    }
     } else {
         mViewManager->currentView()->updateView();
     }
 }
 
 
 void CalendarView::updateTodoViews()
 {
    
     mTodoList->updateView();
     mViewManager->currentView()->updateView();
  
 }
 
 
 void CalendarView::updateView(const QDate &start, const QDate &end)
 {
     mTodoList->updateView();
     mViewManager->updateView(start, end);
     //mDateNavigator->updateView();
 }
 
 void CalendarView::updateView()
 {
     DateList tmpList = mNavigator->selectedDates();
 
     if ( KOPrefs::instance()->mHideNonStartedTodos ) 
         mTodoList->updateView();
     // We assume that the navigator only selects consecutive days.
     updateView( tmpList.first(), tmpList.last() );
 }
 
 void CalendarView::updateUnmanagedViews()
 {
     mDateNavigator->updateDayMatrix();
 }
 
-int CalendarView::msgItemDelete()
+int CalendarView::msgItemDelete(const QString name)
 {
-    return KMessageBox::warningContinueCancel(this,
+    return KMessageBox::warningContinueCancel(this,name +"\n\n"+
                                               i18n("This item will be\npermanently deleted."),
                                               i18n("KO/Pi Confirmation"),i18n("Delete"));
 }
 
 
 void CalendarView::edit_cut()
 {
     Event *anEvent=0;
 
     Incidence *incidence = mViewManager->currentView()->selectedIncidences().first();
 
     if (mViewManager->currentView()->isEventView()) {
         if ( incidence && incidence->type() == "Event" ) {
             anEvent = static_cast<Event *>(incidence);
         }
     }
 
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
     DndFactory factory( mCalendar );
     factory.cutEvent(anEvent);
     changeEventDisplay(anEvent, KOGlobals::EVENTDELETED);
 }
 
 void CalendarView::edit_copy()
 {
     Event *anEvent=0;
 
     Incidence *incidence = mViewManager->currentView()->selectedIncidences().first();
 
     if (mViewManager->currentView()->isEventView()) {
         if ( incidence && incidence->type() == "Event" ) {
             anEvent = static_cast<Event *>(incidence);
         }
     }
 
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
     DndFactory factory( mCalendar );
     factory.copyEvent(anEvent);
 }
 
 void CalendarView::edit_paste()
 {
     QDate date = mNavigator->selectedDates().first();
 
     DndFactory factory( mCalendar );
     Event *pastedEvent = factory.pasteEvent( date );
 
     changeEventDisplay( pastedEvent, KOGlobals::EVENTADDED );
 }
 
 void CalendarView::edit_options()
 {
     mDialogManager->showOptionsDialog();
     //writeSettings();
 }
 
 
 void  CalendarView::slotSelectPickerDate( QDate  d)
 {
     mDateFrame->hide();
     if ( mDatePickerMode == 1 ) {
         mNavigator->slotDaySelect( d );
     } else  if ( mDatePickerMode == 2 ) {
         if ( mMoveIncidence->type() == "Todo" ) {
             Todo * to = (Todo *) mMoveIncidence;
             QTime tim;
             if ( to->hasDueDate() ) 
                 tim = to->dtDue().time();
             else {
                 tim = QTime ( 0,0,0 );
                 to->setFloats( true );
                 to->setHasDueDate( true );
             }
             QDateTime dt ( d,tim );
             to->setDtDue( dt );
             todoChanged( to );
         } else { 
             if ( mMoveIncidence->doesRecur() ) {
 #if 0 
                 // PENDING implement this
                 Incidence* newInc = mMoveIncidence->recreateCloneException( mMoveIncidenceOldDate );
                 mCalendar()->addIncidence( newInc ); 
                 if ( mMoveIncidence->type() == "Todo" )
                     emit  todoMoved((Todo*)mMoveIncidence,  KOGlobals::EVENTEDITED );
                 else
                     emit incidenceChanged(mMoveIncidence, KOGlobals::EVENTEDITED);
                 mMoveIncidence = newInc;
             
 #endif 
             }
             QTime tim = mMoveIncidence->dtStart().time(); 
             int secs = mMoveIncidence->dtStart().secsTo(  mMoveIncidence->dtEnd());
             QDateTime dt ( d,tim );
             mMoveIncidence->setDtStart( dt );
             ((Event*)mMoveIncidence)->setDtEnd( dt.addSecs( secs ) );
             changeEventDisplay((Event*)mMoveIncidence, KOGlobals::EVENTEDITED);
         }
         
         mMoveIncidence->setRevision( mMoveIncidence->revision()+1  );
     }
 }
 
 void CalendarView::removeCategories()
 {
     QPtrList<Incidence> incList  = mCalendar->rawIncidences(); 
     QStringList catList = KOPrefs::instance()->mCustomCategories;
     QStringList catIncList;
     QStringList newCatList;
     Incidence* inc = incList.first();
     int i;
     int count = 0;
     while ( inc ) {
         newCatList.clear();
         catIncList =  inc->categories() ;
         for( i = 0; i<   catIncList.count(); ++i ) {
             if ( catList.contains (catIncList[i]))
                 newCatList.append( catIncList[i] );
         }
         newCatList.sort();
         inc->setCategories( newCatList.join(",") );
         inc = incList.next();
     }
 }
 
 int CalendarView::addCategories()
 { 
     QPtrList<Incidence> incList  = mCalendar->rawIncidences(); 
     QStringList catList = KOPrefs::instance()->mCustomCategories;
     QStringList catIncList;
     Incidence* inc = incList.first();
     int i;
     int count = 0;
      while ( inc ) {
         catIncList = inc->categories() ;
         for( i = 0; i<   catIncList.count(); ++i ) {
             if ( !catList.contains (catIncList[i])) {
                 catList.append( catIncList[i] );
                 //qDebug("add cat %s ",  catIncList[i].latin1());
                 ++count;
             }
         }
         inc = incList.next();
     }
     catList.sort();
     KOPrefs::instance()->mCustomCategories = catList;
     return count;
 }
 
 void CalendarView::manageCategories()
 {
     KOCatPrefs* cp = new KOCatPrefs(); 
     cp->show();
     int w =cp->sizeHint().width() ;
     int h = cp->sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     cp->setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     if ( !cp->exec() ) {
         delete cp;
         return;
     }
     int count = 0;
     if ( cp->addCat() ) {
         count = addCategories();
         if ( count ) {
             topLevelWidget()->setCaption(QString::number( count )+ i18n(" Categories added to list! "));
             writeSettings();
         } else
             topLevelWidget()->setCaption(QString::number( 0 )+ i18n(" Categories added to list! "));
     } else {
         removeCategories();
         updateView();
     }
     delete cp;
 }
 
 void CalendarView::beamIncidence(Incidence * Inc) 
 {
     QPtrList<Incidence> delSel ;
     delSel.append(Inc);
     beamIncidenceList( delSel );
 } 
 void CalendarView::beamCalendar() 
 {
     QPtrList<Incidence> delSel  = mCalendar->rawIncidences(); 
     //qDebug("beamCalendar()  ");
@@ -2699,418 +2699,421 @@ void CalendarView::newSubTodo()
     Todo *todo = selectedTodo();
     if ( todo ) newSubTodo( todo );
 }
 
 void CalendarView::newSubTodo(Todo *parentEvent)
 {
   
     showTodoEditor();
     mTodoEditor->newTodo(QDateTime::currentDateTime().addDays(7),parentEvent,true);
 }
 
 void CalendarView::newFloatingEvent()
 {
     DateList tmpList = mNavigator->selectedDates();
     QDate date = tmpList.first();
 
     newEvent( QDateTime( date, QTime( 12, 0, 0 ) ),
               QDateTime( date, QTime( 12, 0, 0 ) ), true );
 }
 
 
 void CalendarView::editEvent( Event *event )
 {
 
     if ( !event ) return;
     if ( event->isReadOnly() ) {
         showEvent( event );
         return;
     }
     showEventEditor();
     mEventEditor->editEvent( event , mFlagEditDescription);
 }
 void CalendarView::editJournal( Journal *jour )
 { 
     if ( !jour ) return;
     mDialogManager->hideSearchDialog();
     mViewManager->showJournalView();
     mNavigator->slotDaySelect( jour->dtStart().date() );
 }
 void CalendarView::editTodo( Todo *todo )
 {
     if ( !todo ) return;
  
     if ( todo->isReadOnly() ) {
         showTodo( todo );
         return;
     }
     showTodoEditor();
     mTodoEditor->editTodo( todo ,mFlagEditDescription);
 
 }
 
 KOEventViewerDialog* CalendarView::getEventViewerDialog()
 {
     if ( !mEventViewerDialog ) {
         mEventViewerDialog = new KOEventViewerDialog(this);
         connect( mEventViewerDialog, SIGNAL(  editIncidence( Incidence* )), this, SLOT(editIncidence( Incidence* )  ) );
         connect( this, SIGNAL(configChanged()), mEventViewerDialog, SLOT(updateConfig()));
         connect( mEventViewerDialog, SIGNAL(jumpToTime( const QDate &)), 
                  dateNavigator(), SLOT( selectWeek( const QDate & ) ) );
         connect( mEventViewerDialog, SIGNAL(showAgendaView( bool ) ), 
                  viewManager(), SLOT( showAgendaView( bool ) ) );
         connect( mEventViewerDialog, SIGNAL( todoCompleted(Todo *) ), 
                  this, SLOT( todoChanged(Todo *) ) );
         mEventViewerDialog->resize( 640, 480 );
         
     }
     return mEventViewerDialog;
 }
 void CalendarView::showEvent(Event *event)
 {
     getEventViewerDialog()->setEvent(event);
     getEventViewerDialog()->showMe();
 }
 
 void CalendarView::showTodo(Todo *event)
 {
     getEventViewerDialog()->setTodo(event);
     getEventViewerDialog()->showMe();
 }
 void CalendarView::showJournal( Journal *jour )
 { 
     getEventViewerDialog()->setJournal(jour);
     getEventViewerDialog()->showMe();
    
 }
 // void CalendarView::todoModified (Todo *event, int changed)
 // {
 //  //  if (mDialogList.find (event) != mDialogList.end ()) {
 // //     kdDebug() << "Todo modified and open" << endl;
 // //     KOTodoEditor* temp = (KOTodoEditor *) mDialogList[event];
 // //     temp->modified (changed);
 
 // //   }
 
 //   mViewManager->updateView();
 // }
 
 void CalendarView::appointment_show()
 {
     Event *anEvent = 0;
 
     Incidence *incidence = mViewManager->currentView()->selectedIncidences().first();
 
     if (mViewManager->currentView()->isEventView()) {
         if ( incidence && incidence->type() == "Event" ) {
             anEvent = static_cast<Event *>(incidence);
         }
     }
 
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
 
     showEvent(anEvent);
 }
 
 void CalendarView::appointment_edit()
 {
     Event *anEvent = 0;
 
     Incidence *incidence = mViewManager->currentView()->selectedIncidences().first();
 
     if (mViewManager->currentView()->isEventView()) {
         if ( incidence && incidence->type() == "Event" ) {
             anEvent = static_cast<Event *>(incidence);
         }
     }
 
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
 
     editEvent(anEvent);
 }
 
 void CalendarView::appointment_delete()
 {
     Event *anEvent = 0;
 
     Incidence *incidence = mViewManager->currentView()->selectedIncidences().first();
 
     if (mViewManager->currentView()->isEventView()) {
         if ( incidence && incidence->type() == "Event" ) {
             anEvent = static_cast<Event *>(incidence);
         }
     }
 
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
 
     deleteEvent(anEvent);
 }
 
 void CalendarView::todo_resub( Todo * parent, Todo * sub )
 {
     if (!sub) return;
     if (!parent) return;
     if ( sub->relatedTo() )
         sub->relatedTo()->removeRelation(sub);
     sub->setRelatedTo(parent);
     sub->setRelatedToUid(parent->uid());
     parent->addRelation(sub);
     sub->updated();
     parent->updated();
     setModified(true);
     updateView();
 }
 void CalendarView::todo_unsub(Todo *anTodo )
 {
     // Todo *anTodo = selectedTodo();
     if (!anTodo) return;
     if (!anTodo->relatedTo()) return;
     anTodo->relatedTo()->removeRelation(anTodo);
     anTodo->setRelatedTo(0);
     anTodo->updated();
     anTodo->setRelatedToUid("");
     setModified(true);
     updateView();
 }
 
 void CalendarView::deleteTodo(Todo *todo)
 {
     if (!todo) {
         KNotifyClient::beep();
         return;
     }
     if (KOPrefs::instance()->mConfirm) {
-        switch (msgItemDelete()) {
+        QString text = todo->summary().left(20);
+        if (!todo->relations().isEmpty()) {
+            text += i18n("\nhas sub-todos.\nAll completed sub-todos\nwill be deleted as well!");
+
+        }
+        switch (msgItemDelete(text)) {
         case KMessageBox::Continue: // OK
+            bool deleteT = false;
             if (!todo->relations().isEmpty()) {
-                KMessageBox::sorry(this,i18n("Cannot delete To-Do\nwhich has children."),
-                                   i18n("Delete To-Do"));
-            } else {
+                deleteT = removeCompletedSubTodos( todo );
+            } 
+            // deleteT == true: todo already deleted in removeCompletedSubTodos
+            if ( !deleteT ) {
                 checkExternalId(  todo );
                 calendar()->deleteTodo(todo);
                 changeTodoDisplay( todo,KOGlobals::EVENTDELETED );
                 updateView();
             }
             break;
         } // switch
     } else {
-        if (!todo->relations().isEmpty()) {
-            KMessageBox::sorry(this,i18n("Cannot delete To-Do\nwhich has children."),
-                               i18n("Delete To-Do"));
-        } else {
-            checkExternalId(  todo );
-            mCalendar->deleteTodo(todo);
-            changeTodoDisplay( todo,KOGlobals::EVENTDELETED );
-            updateView();
-        }
+        checkExternalId(  todo );
+        mCalendar->deleteTodo(todo);
+        changeTodoDisplay( todo,KOGlobals::EVENTDELETED );
+        updateView();
     }
+    
     emit updateSearchDialog();
 }
 void CalendarView::deleteJournal(Journal *jour)
 {
     if (!jour) {
         KNotifyClient::beep();
         return;
     }
     if (KOPrefs::instance()->mConfirm) {
-        switch (msgItemDelete()) {
+        switch (msgItemDelete( jour->description().left(20))) {
         case KMessageBox::Continue: // OK
             calendar()->deleteJournal(jour);
             updateView();
             break;
         } // switch
     } else {
         calendar()->deleteJournal(jour);;
         updateView();
     }
     emit updateSearchDialog();
 }
 
 void CalendarView::deleteEvent(Event *anEvent)
 {
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
 
     if (anEvent->recurrence()->doesRecur()) {
         QDate itemDate = mViewManager->currentSelectionDate();
         int km;
         if (!itemDate.isValid()) {
             //kdDebug() << "Date Not Valid" << endl;
             if (KOPrefs::instance()->mConfirm) {
                 km = KMessageBox::warningContinueCancel(this,anEvent->summary().left(25) +
                                                         i18n("\nThis event recurs\nover multiple dates.\nAre you sure you want\nto delete this event\nand all its recurrences?"),
                                                         i18n("KO/Pi Confirmation"),i18n("Delete All"));
                 if ( km == KMessageBox::Continue )
                     km = KMessageBox::No; // No = all below
             } else
                 km = KMessageBox::No;
         } else {
             km = KMessageBox::warningYesNoCancel(this,anEvent->summary().left(25) +
                                                  i18n("\nThis event recurs\nover multiple dates.\nDo you want to delete\nall it's recurrences,\nor only the current one on:\n")+
                                                       KGlobal::locale()->formatDate(itemDate)+i18n(" ?\n\nDelete:\n"),
                                                  i18n("KO/Pi Confirmation"),i18n("Current"),
                                                  i18n("All"));
         }
         switch(km) {
 
         case KMessageBox::No: // Continue // all
             //qDebug("KMessageBox::No ");
             if (anEvent->organizer()==KOPrefs::instance()->email() && anEvent->attendeeCount()>0)
                 schedule(Scheduler::Cancel,anEvent);
 
             checkExternalId( anEvent);
             mCalendar->deleteEvent(anEvent);
             changeEventDisplay(anEvent,KOGlobals::EVENTDELETED);
             break;
 
             // Disabled because it does not work
             //#if 0
         case KMessageBox::Yes: // just this one
             //QDate qd = mNavigator->selectedDates().first();
             //if (!qd.isValid()) {
             //  kdDebug() << "no date selected, or invalid date" << endl;
             //  KNotifyClient::beep();
             //  return;
             //}
             //while (!anEvent->recursOn(qd)) qd = qd.addDays(1);
             if (itemDate!=QDate(1,1,1) || itemDate.isValid()) {
                 anEvent->addExDate(itemDate);
                 int duration = anEvent->recurrence()->duration();
                 if ( duration > 0 ) {
                     anEvent->recurrence()->setDuration( duration - 1 );
                 }
                 changeEventDisplay(anEvent, KOGlobals::EVENTEDITED);
             }
             break;
             //#endif
         } // switch
     } else {
         if (KOPrefs::instance()->mConfirm) {
             switch (KMessageBox::warningContinueCancel(this,anEvent->summary().left(25) +
                                                        i18n("\nAre you sure you want\nto delete this event?"),
                                                        i18n("KO/Pi Confirmation"),i18n("Delete"))) {
             case KMessageBox::Continue: // OK
                 if (anEvent->organizer()==KOPrefs::instance()->email() && anEvent->attendeeCount()>0)
                     schedule(Scheduler::Cancel,anEvent);
                 checkExternalId( anEvent);
                 mCalendar->deleteEvent(anEvent);
                 changeEventDisplay(anEvent, KOGlobals::EVENTDELETED);
                 break;
             } // switch
         } else {
             if (anEvent->organizer()==KOPrefs::instance()->email() && anEvent->attendeeCount()>0)
                 schedule(Scheduler::Cancel,anEvent);
             checkExternalId( anEvent);
             mCalendar->deleteEvent(anEvent);
             changeEventDisplay(anEvent, KOGlobals::EVENTDELETED);
         }
     } // if-else
     emit updateSearchDialog();
 }
 
 bool CalendarView::deleteEvent(const QString &uid)
 {
     Event *ev = mCalendar->event(uid);
     if (ev) {
         deleteEvent(ev);
         return true;
     } else {
         return false;
     }
 }
 
 /*****************************************************************************/
 
 void CalendarView::action_mail()
 {
 #ifndef KORG_NOMAIL
     KOMailClient mailClient;
 
     Incidence *incidence = currentSelection();
 
     if (!incidence) {
         KMessageBox::sorry(this,i18n("Can't generate mail:\nNo event selected."));
         return;
     }
     if(incidence->attendeeCount() == 0 ) {
         KMessageBox::sorry(this,
                            i18n("Can't generate mail:\nNo attendees defined.\n"));
         return;
     }
 
     CalendarLocal cal_tmp;
     Event *event = 0;
     Event *ev = 0;
     if ( incidence && incidence->type() == "Event" ) {
         event = static_cast<Event *>(incidence);
         ev = new Event(*event);
         cal_tmp.addEvent(ev);
     }
     ICalFormat mForm();
     QString attachment = mForm.toString( &cal_tmp );
     if (ev) delete(ev);
 
     mailClient.mailAttendees(currentSelection(), attachment);
 
 #endif
 
 #if 0
     Event *anEvent = 0;
     if (mViewManager->currentView()->isEventView()) {
         anEvent = dynamic_cast<Event *>((mViewManager->currentView()->selectedIncidences()).first());
     }
 
     if (!anEvent) {
         KMessageBox::sorry(this,i18n("Can't generate mail:\nNo event selected."));
         return;
     }
     if(anEvent->attendeeCount() == 0 ) {
         KMessageBox::sorry(this,
                            i18n("Can't generate mail:\nNo attendees defined.\n"));
         return;
     }
 
     mailobject.emailEvent(anEvent);
 #endif
 }
 
 
 void CalendarView::schedule_publish(Incidence *incidence)
 {
     Event *event = 0;
     Todo *todo = 0;
 
     if (incidence == 0) {
         incidence = mViewManager->currentView()->selectedIncidences().first();
         if (incidence == 0) {
             incidence = mTodoList->selectedIncidences().first();
         }
     }
     if ( incidence && incidence->type() == "Event" ) {
         event = static_cast<Event *>(incidence);
     } else {
         if ( incidence && incidence->type() == "Todo" ) {
             todo = static_cast<Todo *>(incidence);
         }
     }
 
     if (!event && !todo) {
         KMessageBox::sorry(this,i18n("No event selected."));
         return;
     }
 
     PublishDialog *publishdlg = new PublishDialog();
     if (incidence->attendeeCount()>0) {
         QPtrList<Attendee> attendees = incidence->attendees();
         attendees.first();
         while ( attendees.current()!=0 ) {
@@ -3294,384 +3297,401 @@ void CalendarView::setReadOnly(bool readOnly)
         emit readOnlyChanged(mReadOnly);
     }
 }
 
 bool CalendarView::isModified()
 {
     return mModified;
 }
 
 void CalendarView::printSetup()
 {
 #ifndef KORG_NOPRINTER
     createPrinter();
 
     mCalPrinter->setupPrinter();
 #endif
 }
 
 void CalendarView::print()
 {
 #ifndef KORG_NOPRINTER
     createPrinter();
 
     DateList tmpDateList = mNavigator->selectedDates();
     mCalPrinter->print(CalPrinter::Month,
                        tmpDateList.first(), tmpDateList.last());
 #endif
 }
 
 void CalendarView::printPreview()
 {
 #ifndef KORG_NOPRINTER
     kdDebug() << "CalendarView::printPreview()" << endl;
 
     createPrinter();
 
     DateList tmpDateList = mNavigator->selectedDates();
 
     mViewManager->currentView()->printPreview(mCalPrinter,tmpDateList.first(),
                                               tmpDateList.last());
 #endif
 }
 
 void CalendarView::exportICalendar()
 {
     QString filename = KFileDialog::getSaveFileName("icalout.ics",i18n("*.ics|ICalendars"),this);
 
     // Force correct extension
     if (filename.right(4) != ".ics") filename += ".ics";
 
     FileStorage storage( mCalendar, filename, new ICalFormat() );
     storage.save();
 }
 
 bool CalendarView::exportVCalendar( QString filename )
 {
     if (mCalendar->journals().count() > 0) {
         int result = KMessageBox::warningContinueCancel(this,
                                                         i18n("The journal entries can not be\nexported to a vCalendar file."),
                                                         i18n("Data Loss Warning"),i18n("Proceed"),i18n("Cancel"),
                                                         true);
         if (result != KMessageBox::Continue) return false;
     }
 
     //QString filename = KFileDialog::getSaveFileName("vcalout.vcs",i18n("*.vcs|VCalendars"),this);
 
     // Force correct extension
     if (filename.right(4) != ".vcs") filename += ".vcs";
 
     FileStorage storage( mCalendar, filename, new VCalFormat );
     return storage.save();
  
 }
 
 void CalendarView::eventUpdated(Incidence *)
 {
     setModified();
     // Don't call updateView here. The code, which has caused the update of the
     // event is responsible for updating the view.
     //  updateView();
 }
 
 void CalendarView::adaptNavigationUnits()
 {
     if (mViewManager->currentView()->isEventView()) {
         int days = mViewManager->currentView()->currentDateCount();
         if (days == 1) {
             emit changeNavStringPrev(i18n("&Previous Day"));
             emit changeNavStringNext(i18n("&Next Day"));
         } else {
             emit changeNavStringPrev(i18n("&Previous Week"));
             emit changeNavStringNext(i18n("&Next Week"));
         }
     }
 }
 
 void CalendarView::processMainViewSelection( Incidence *incidence )
 {
     if ( incidence ) mTodoList->clearSelection();
     processIncidenceSelection( incidence );
 }
 
 void CalendarView::processTodoListSelection( Incidence *incidence )
 {
     if ( incidence && mViewManager->currentView() ) {
         mViewManager->currentView()->clearSelection();
     }
     processIncidenceSelection( incidence );
 }
 
 void CalendarView::processIncidenceSelection( Incidence *incidence )
 {
     if ( incidence == mSelectedIncidence ) return;
 
     mSelectedIncidence = incidence;
 
     emit incidenceSelected( mSelectedIncidence );
 
     if ( incidence && incidence->type() == "Event" ) {
         Event *event = static_cast<Event *>( incidence );
         if ( event->organizer() == KOPrefs::instance()->email() ) {
             emit organizerEventsSelected( true );
         } else {
             emit organizerEventsSelected(false);
         }
         if (event->attendeeByMails( KOPrefs::instance()->mAdditionalMails,
                                     KOPrefs::instance()->email() ) ) {
             emit groupEventsSelected( true );
         } else {
             emit groupEventsSelected(false);
         }
         return;
     } else {
         if  ( incidence && incidence->type() == "Todo" ) {
             emit todoSelected( true );
             Todo *event = static_cast<Todo *>( incidence );
             if ( event->organizer() == KOPrefs::instance()->email() ) {
                 emit organizerEventsSelected( true );
             } else {
                 emit organizerEventsSelected(false);
             }
             if (event->attendeeByMails( KOPrefs::instance()->mAdditionalMails,
                                         KOPrefs::instance()->email() ) ) {
                 emit groupEventsSelected( true );
             } else {
                 emit groupEventsSelected(false);
             }
             return;
         } else {
             emit todoSelected( false );
             emit organizerEventsSelected(false);
             emit groupEventsSelected(false);
         }
         return;
     }
 
     /*  if  ( incidence && incidence->type() == "Todo" ) {
         emit todoSelected( true );
         } else {
         emit todoSelected( false );
         }*/
 }
 
 
 void CalendarView::checkClipboard()
 {
 #ifndef KORG_NODND
     if (ICalDrag::canDecode(QApplication::clipboard()->data())) {
         emit pasteEnabled(true);
     } else {
         emit pasteEnabled(false);
     }
 #endif
 }
 
 void CalendarView::showDates(const DateList &selectedDates)
 {
     //  kdDebug() << "CalendarView::selectDates()" << endl;
   
 
     if ( !mBlockShowDates ) {
         if ( mViewManager->currentView() ) {
             updateView( selectedDates.first(), selectedDates.last() );
         } else {
             mViewManager->showAgendaView();
         }
     }
 
     QString selDates;
     selDates = KGlobal::locale()->formatDate( selectedDates.first(), true);
     if  (selectedDates.first() < selectedDates.last() )
         selDates += " - " + KGlobal::locale()->formatDate( selectedDates.last(),true);
+    else {
+        QString addString;
+        if ( selectedDates.first() == QDateTime::currentDateTime().date() )
+            addString = i18n("Today");
+        else if ( selectedDates.first() == QDateTime::currentDateTime().date().addDays(1) )
+            addString = i18n("Tomorrow");
+        else if ( selectedDates.first() == QDateTime::currentDateTime().date().addDays(-1) )
+            addString = i18n("Yesterday");
+        else if ( selectedDates.first() == QDateTime::currentDateTime().date().addDays(-2) )
+            addString = i18n("Day before yesterday");
+        else if ( selectedDates.first() == QDateTime::currentDateTime().date().addDays(2) )
+            addString = i18n("Day after tomorrow");
+        if ( !addString.isEmpty() ) {
+            topLevelWidget()->setCaption( addString+", " + selDates );
+            return;
+        }
+    }
     topLevelWidget()->setCaption( i18n("Dates: ") + selDates );
   
 }
 
 QPtrList<CalFilter> CalendarView::filters()
 {
     return mFilters;
 
 }
 void CalendarView::editFilters()
 {
     //  kdDebug() << "CalendarView::editFilters()" << endl;
 
     CalFilter *filter = mFilters.first();
     while(filter) {
         kdDebug() << " Filter: " << filter->name() << endl;
         filter = mFilters.next();
     }
 
     mDialogManager->showFilterEditDialog(&mFilters);
 }
 void CalendarView::toggleFilter()
 {
     showFilter(! mFilterView->isVisible());
 }
 
 KOFilterView *CalendarView::filterView()
 {
     return mFilterView;
 }
 void CalendarView::selectFilter( int fil )
 {
     mFilterView->setSelectedFilter( fil );
 }
 void CalendarView::showFilter(bool visible)
 {
     if (visible) mFilterView->show();
     else mFilterView->hide();
 }
 void CalendarView::toggleFilerEnabled( )
 {
     mFilterView->setFiltersEnabled ( !mFilterView->filtersEnabled()  );
     if ( !mFilterView->filtersEnabled()   ) 
         topLevelWidget()->setCaption( i18n("Filter disabled ") );
         
 }
 void CalendarView::updateFilter()
 {
     CalFilter *filter = mFilterView->selectedFilter();
     if (filter) {
         if (mFilterView->filtersEnabled()) {
             topLevelWidget()->setCaption( i18n("Filter selected: ")+filter->name() );
             filter->setEnabled(true);
         }
         else filter->setEnabled(false);
         mCalendar->setFilter(filter);
         updateView();
     }
 }
 
 void CalendarView::filterEdited()
 {
     mFilterView->updateFilters();
     updateFilter();
     writeSettings();
 }
 
 
 void CalendarView::takeOverEvent()
 {
     Incidence *incidence = currentSelection();
 
     if (!incidence) return;
 
     incidence->setOrganizer(KOPrefs::instance()->email());
     incidence->recreate();
     incidence->setReadOnly(false);
 
     updateView();
 }
 
 void CalendarView::takeOverCalendar()
 {
     // TODO: Create Calendar::allIncidences() function and use it here
 
     QPtrList<Event> events = mCalendar->events();
     for(uint i=0; i<events.count(); ++i) {
         events.at(i)->setOrganizer(KOPrefs::instance()->email());
         events.at(i)->recreate();
         events.at(i)->setReadOnly(false);
     }
 
     QPtrList<Todo> todos = mCalendar->todos();
     for(uint i=0; i<todos.count(); ++i) {
         todos.at(i)->setOrganizer(KOPrefs::instance()->email());
         todos.at(i)->recreate();
         todos.at(i)->setReadOnly(false);
     }
 
     QPtrList<Journal> journals = mCalendar->journals();
     for(uint i=0; i<journals.count(); ++i) {
         journals.at(i)->setOrganizer(KOPrefs::instance()->email());
         journals.at(i)->recreate();
         journals.at(i)->setReadOnly(false);
     }
 
     updateView();
 }
 
 void CalendarView::showIntro()
 {
     kdDebug() << "To be implemented." << endl;
 }
 
 QWidgetStack *CalendarView::viewStack()
 {
     return mRightFrame;
 }
 
 QWidget *CalendarView::leftFrame()
 {
     return mLeftFrame;
 }
 
 DateNavigator *CalendarView::dateNavigator()
 {
     return mNavigator;
 }
 
 KDateNavigator* CalendarView::dateNavigatorWidget()
 {
     return mDateNavigator;
 }
 void CalendarView::toggleDateNavigatorWidget()
 {
     KOPrefs::instance()->mShowDateNavigator = !KOPrefs::instance()->mShowDateNavigator ;
     if (!KOPrefs::instance()->mShowDateNavigator )
         mDateNavigator->hide();
     else
         mDateNavigator->show();
 }
 void CalendarView::addView(KOrg::BaseView *view)
 {
     mViewManager->addView(view);
 }
 
 void CalendarView::showView(KOrg::BaseView *view)
 {
     mViewManager->showView(view, mLeftFrame->isVisible());
 }
 
 Incidence *CalendarView::currentSelection()
 {
     return mViewManager->currentSelection();
 }
 void CalendarView::toggleAllDaySize()
 {
     /*
     if ( KOPrefs::instance()->mAllDaySize > 47 )
         KOPrefs::instance()->mAllDaySize = KOPrefs::instance()->mAllDaySize /2;
     else
         KOPrefs::instance()->mAllDaySize = KOPrefs::instance()->mAllDaySize *2;
     */
     viewManager()->agendaView()->toggleAllDay();
 }
 void CalendarView::toggleExpand()
 {
     //  if ( mLeftFrame->isHidden() ) {
     //     mLeftFrame->show(); 
     //     emit calendarViewExpanded( false );
     //   } else {
     //     mLeftFrame->hide();
     //     emit calendarViewExpanded( true );
     //   }
 
     globalFlagBlockAgenda = 1;
     emit calendarViewExpanded( !mLeftFrame->isHidden() );
     globalFlagBlockAgenda = 5;
     mViewManager->raiseCurrentView( !mLeftFrame->isHidden() );
     //mViewManager->showView( 0, true );
 }
 
 void CalendarView::calendarModified( bool modified, Calendar * )
 {
     setModified( modified );
 }
 
 Todo *CalendarView::selectedTodo()
 {
     Incidence *incidence = currentSelection();
     if ( incidence && incidence->type() == "Todo" ) {
         return static_cast<Todo *>( incidence );
diff --git a/korganizer/calendarview.h b/korganizer/calendarview.h
index e27da9a..c8d6bdd 100644
--- a/korganizer/calendarview.h
+++ b/korganizer/calendarview.h
@@ -296,315 +296,315 @@ class CalendarView : public KOrg::CalendarViewBase, public KCal::Calendar::Obser
     void eventChanged(Event *);
     void eventToBeDeleted(Event *);
     void eventDeleted();
   
     void todoAdded(Todo *);
     void todoChanged(Todo *);
     void todoToBeDeleted(Todo *);
     void todoDeleted();
 
     void updateView(const QDate &start, const QDate &end);
     void updateView();
   
     /** Full update of visible todo views */
     void updateTodoViews();
 
     void updateUnmanagedViews();
   
     /** cut the current appointment to the clipboard */
     void edit_cut();
   
     /** copy the current appointment(s) to the clipboard */
     void edit_copy();
 
     /** paste the current vobject(s) in the clipboard buffer into calendar */
     void edit_paste();
   
     /** edit viewing and configuration options. */
     void edit_options();
     /**
       Functions for printing, previewing a print, and setting up printing
       parameters.
     */
     void print();
     void printSetup();
     void printPreview();
 
     /** Export as iCalendar file */
     void exportICalendar();
   
     /** Export as vCalendar file */
     bool exportVCalendar( QString fn);
   
     /** pop up a dialog to show an existing appointment. */
     void appointment_show();
     /**
              * pop up an Appointment Dialog to edit an existing appointment.Get
      * information on the appointment from the list of unique IDs that is
      * currently in the View, called currIds.
      */
     void appointment_edit();
     /**
      * pop up dialog confirming deletion of currently selected event in the
      * View.
      */
     void appointment_delete();
 
     /** mails the currently selected event to a particular user as a vCalendar
       attachment. */
     void action_mail();
 
     /* frees a subtodo from it's relation */
     void todo_unsub( Todo * );
     void todo_resub( Todo * parent, Todo * sub );
 
     /** Take ownership of selected event. */
     void takeOverEvent();
 
     /** Take ownership of all events in calendar. */
     void takeOverCalendar();
   
     /** query whether or not the calendar is "dirty". */
     bool isModified();
     /** set the state of calendar. Modified means "dirty", i.e. needing a save. */
     void setModified(bool modified=true);
 
     /** query if the calendar is read-only. */
     bool isReadOnly();
     /** set state of calendar to read-only */
     void setReadOnly(bool readOnly=true);
 
     void eventUpdated(Incidence *);
 
     /* iTIP scheduling actions */
     void schedule_publish(Incidence *incidence = 0);
     void schedule_request(Incidence *incidence = 0);
     void schedule_refresh(Incidence *incidence = 0);
     void schedule_cancel(Incidence *incidence = 0);
     void schedule_add(Incidence *incidence = 0);
     void schedule_reply(Incidence *incidence = 0);
     void schedule_counter(Incidence *incidence = 0);
     void schedule_declinecounter(Incidence *incidence = 0);
     void schedule_publish_freebusy(int daysToPublish = 30);
 
     void openAddressbook();
 
     void editFilters();
     void toggleFilerEnabled();
     QPtrList<CalFilter> filters();
     void toggleFilter();
     void showFilter(bool visible);
     void updateFilter();
     void filterEdited();
     void selectFilter( int );
     KOFilterView *filterView();
 
     void showIntro();
 
     /** Move the curdatepient view date to today */
     void goToday();
 
     /** Move to the next date(s) in the current view */
     void goNext();
   
     /** Move to the previous date(s) in the current view */
     void goPrevious();
   /** Move to the next date(s) in the current view */
     void goNextMonth();
   
     /** Move to the previous date(s) in the current view */
     void goPreviousMonth();
 
     void toggleExpand();
     void toggleDateNavigatorWidget();
     void toggleAllDaySize();
     void dialogClosing(Incidence *);
   
     /** Look for new messages in the inbox */
     void lookForIncomingMessages();
    /** Look for new messages in the outbox */
     void lookForOutgoingMessages();
 
     void processMainViewSelection( Incidence * );
     void processTodoListSelection( Incidence * );
     
     void processIncidenceSelection( Incidence * );
 
     void purgeCompleted();
     bool removeCompletedSubTodos( Todo* );
     void slotCalendarChanged();
     bool importBday();
     bool addAnniversary( QDate data, QString name, KCal::Attendee* a , bool birthday  );
     bool importQtopia( const QString &categoriesFile,
                        const QString &datebookFile,
                        const QString &tasklistFile );
     void syncExternal( int mode );
     void slotSelectPickerDate( QDate ) ;
     void showDatePicker( ) ;
     void moveIncidence(Incidence *) ;
     void beamIncidence(Incidence *) ;
     void beamCalendar() ;
     void beamFilteredCalendar() ;
     void beamIncidenceList(QPtrList<Incidence>) ;
     void manageCategories();
     int addCategories();
     void removeCategories();
     void setSyncDevice( QString );
     void setSyncName( QString );
     void showDay( QDate );
     void undo_delete();
   protected slots:
     void timerAlarm();
     void suspendAlarm();
     void beamDone( Ir *ir );
     /** Select a view or adapt the current view to display the specified dates. */
     void showDates( const KCal::DateList & );
     void selectWeekNum ( int );
   
   public:
     // show a standard warning
     // returns KMsgBox::yesNoCancel()
     int msgCalModified(); 
     virtual bool sync(KSyncManager* manager, QString filename, int mode);
 
     virtual bool syncExternal(KSyncManager* manager, QString resource);
     virtual void removeSyncInfo( QString syncProfile);
     void setSyncManager(KSyncManager* manager);
     void setLoadedFileVersion(QDateTime);
     bool checkFileVersion(QString fn);
     bool checkFileChanged(QString fn);
     Event* getLastSyncEvent();
     /** Adapt navigation units correpsonding to step size of navigation of the
      * current view.
      */
     void adaptNavigationUnits();
     bool synchronizeCalendar( Calendar* local,  Calendar* remote, int mode );
     int  takeEvent( Incidence* local,  Incidence* remote, int mode, bool full = false );
     //Attendee* getYourAttendee(Event *event);
     void setBlockShowDates( bool b ) { mBlockShowDates = b ;}
   protected:
     void schedule(Scheduler::Method, Incidence *incidence = 0);
     
     // returns KMsgBox::OKCandel()
-    int msgItemDelete();
+    int msgItemDelete(const QString name);
     void showEventEditor();
     void showTodoEditor();
     void writeLocale();
     Todo *selectedTodo();
 
   private:
     bool mBlockShowDates;
     KSyncManager* mSyncManager;
     AlarmDialog * mAlarmDialog;
     QString mAlarmNotification;
     QString mSuspendAlarmNotification;
     QTimer* mSuspendTimer;
     QTimer* mAlarmTimer;
     QTimer* mRecheckAlarmTimer;
     void computeAlarm( QString );
     void startAlarm( QString, QString );
     void setSyncEventsReadOnly();
     
     QDateTime loadedFileVersion;
     void checkExternSyncEvent( QPtrList<Event> lastSync , Incidence* toDelete );
     void checkExternalId( Incidence * inc );
     int mGlobalSyncMode;
     QString  mCurrentSyncDevice;
     QString  mCurrentSyncName;
     KOBeamPrefs* beamDialog;
     void init();
     int mDatePickerMode;
     bool mFlagEditDescription;
     QDateTime mLastCalendarSync;
     void createPrinter();
 
     void calendarModified( bool, Calendar * );
 
     CalPrinter *mCalPrinter;
 
     QSplitter    *mPanner;
     QSplitter    *mLeftSplitter;
     QWidget      *mLeftFrame;
     QWidgetStack *mRightFrame;
 
     KDatePicker* mDatePicker;
     QVBox* mDateFrame;
     NavigatorBar *mNavigatorBar;
 
     KDateNavigator *mDateNavigator;       // widget showing small month view.
 
     KOFilterView *mFilterView;
 
     ResourceView *mResourceView;
 
     // calendar object for this viewing instance
     Calendar      *mCalendar;
 
     CalendarResourceManager *mResourceManager;
 
     FileStorage *mStorage;
 
     DateNavigator *mNavigator;
 
     KOViewManager *mViewManager;
     KODialogManager *mDialogManager;
 
     // Calendar filters
     QPtrList<CalFilter> mFilters;
 
     // various housekeeping variables.
             bool            mModified;   // flag indicating if calendar is modified
     bool            mReadOnly; // flag indicating if calendar is read-only
     QDate mSaveSingleDate;
 
     Incidence *mSelectedIncidence;
     Incidence *mMoveIncidence;
     QDate mMoveIncidenceOldDate;
     KOTodoView *mTodoList;
     KOEventEditor * mEventEditor;
     KOTodoEditor  * mTodoEditor;
     KOEventViewerDialog * mEventViewerDialog;
     void keyPressEvent ( QKeyEvent *e) ;
     //QMap<Incidence*,KOIncidenceEditor*> mDialogList;
 };
 
 
 class CalendarViewVisitor : public Incidence::Visitor
 {
   public:
     CalendarViewVisitor() : mView( 0 ) {}
 
     bool act( Incidence *incidence, CalendarView *view )
     {
       mView = view;
       return incidence->accept( *this );
     }
     
   protected:
     CalendarView *mView;
 };
 
 class ShowIncidenceVisitor : public CalendarViewVisitor
 {
   protected:
     bool visit( Event *event ) { mView->showEvent( event ); return true; }  
     bool visit( Todo *todo ) { mView->showTodo( todo ); return true; }  
     bool visit( Journal * j ) { mView->showJournal( j );return true; }
 };
 
 class EditIncidenceVisitor : public CalendarViewVisitor
 {
   protected:
     bool visit( Event *event ) { mView->editEvent( event ); return true; }  
     bool visit( Todo *todo ) { mView->editTodo( todo ); return true; }  
     bool visit( Journal *j ) {  mView->editJournal( j); return true; }
 };
 
 class DeleteIncidenceVisitor : public CalendarViewVisitor
 {
   protected:
     bool visit( Event *event ) { mView->deleteEvent( event ); return true; }  
     bool visit( Todo *todo ) { mView->deleteTodo( todo ); return true; }  
     bool visit( Journal * j) {mView->deleteJournal( j ); return true; }
 };
 
 #endif
diff --git a/korganizer/koeditorgeneral.cpp b/korganizer/koeditorgeneral.cpp
index 94e1f4c..b4fe965 100644
--- a/korganizer/koeditorgeneral.cpp
+++ b/korganizer/koeditorgeneral.cpp
@@ -94,404 +94,418 @@ void KOEditorGeneral::initHeader(QWidget *parent,QBoxLayout *topLayout)
     headerLayout->addWidget(locationLabel,2,0);
 
     mLocationEdit = new KOLocationBox(TRUE,parent,10); 
     mLocationEdit->setSizePolicy( QSizePolicy( QSizePolicy::Preferred  ,QSizePolicy::MinimumExpanding  ,FALSE) );
     if ( QApplication::desktop()->width() > 320 ) 
         mLocationEdit->setMaximumHeight( hei + 6);
 
     //   mLocationEdit = new QLineEdit(parent);
     connect ( mLocationEdit->lineEdit(), SIGNAL ( returnPressed() ), this, SIGNAL (allAccepted () ) );
     headerLayout->addWidget(mLocationEdit,2,1);
     headerLayout->setColStretch( 1, 10);
 }
 void KOEditorGeneral::setFocusOn( int i )
 {
     qApp->processEvents();
     if ( i == 1 ) {
         mDescriptionEdit->setFocus();
         mDescriptionEdit->setCursorPosition( mDescriptionEdit->numLines (), 333);
     } 
     if ( i == 2 ) {
         mSummaryEdit->setFocus();
     }
 
 }
 void KOEditorGeneral::editCategories()
 {
     // qDebug("KOEditorGeneral::editCategories() ");
     KPIM::CategorySelectDialog* csd = new KPIM::CategorySelectDialog( KOPrefs::instance(), 0 );
     connect(csd,SIGNAL(categoriesSelected(const QString &)), this ,SLOT(setCategories(const QString &)));
     //KOGlobals::fitDialogToScreen( csd );
     csd->setSelected( QStringList::split (",", mCategoriesLabel->text()) );
     csd->exec();
     delete csd;
 }
 void KOEditorGeneral::initCategories(QWidget *parent, QBoxLayout *topLayout)
 {
     QBoxLayout *categoriesLayout = new QHBoxLayout( topLayout );
 
     mCategoriesButton = new QPushButton(parent);
     mCategoriesButton->setText(i18n("Categories..."));
     connect(mCategoriesButton,SIGNAL(clicked()),this, SLOT(editCategories() ));
     categoriesLayout->addWidget(mCategoriesButton);
 
     mCategoriesLabel = new QLabel(parent);
     mCategoriesLabel->setFrameStyle(QFrame::Panel|QFrame::Sunken);
     categoriesLayout->addWidget(mCategoriesLabel,1);
 }
 
 void KOEditorGeneral::initSecrecy(QWidget *parent, QBoxLayout *topLayout)
 {
     QBoxLayout *secrecyLayout = new QHBoxLayout( topLayout );
 
     QLabel *secrecyLabel = new QLabel(i18n("Access:"),parent);
     mCancelBox = new QCheckBox ( i18n("Cancelled"), parent);
     secrecyLayout->addWidget(mCancelBox);
     secrecyLayout->addWidget(secrecyLabel);
 
     mSecrecyCombo = new QComboBox(parent);
     mSecrecyCombo->insertStringList(Incidence::secrecyList());
     secrecyLayout->addWidget(mSecrecyCombo);
 }
 
 void KOEditorGeneral::initDescription(QWidget *parent,QBoxLayout *topLayout)
 {
     mDescriptionEdit = new KTextEdit(parent);
     mDescriptionEdit->setFont(KOPrefs::instance()->mEditBoxFont );
     mDescriptionEdit->append("");
     mDescriptionEdit->setReadOnly(false);
     mDescriptionEdit->setOverwriteMode(false);
     mDescriptionEdit->setWordWrap( KTextEdit::WidgetWidth ); 
     topLayout->addWidget(mDescriptionEdit); 
 #ifndef DESKTOP_VERSION
     QPEApplication::setStylusOperation( mDescriptionEdit, QPEApplication::RightOnHold );
 #endif
  
 }
 
 void KOEditorGeneral::initAlarm(QWidget *parent,QBoxLayout *topLayout)
 {
     QBoxLayout *alarmLayout = new QHBoxLayout(topLayout);
 
     //mAlarmBell = new QLabel(parent);
     //mAlarmBell->setPixmap(SmallIcon("bell"));
     //alarmLayout->addWidget(mAlarmBell);
     if ( QApplication::desktop()->width() < 320 ) 
         mAlarmButton = new QCheckBox(i18n("Rem."),parent);
     else
         mAlarmButton = new QCheckBox(i18n("Reminder:"),parent);
       
     connect(mAlarmButton, SIGNAL(toggled(bool)), SLOT(enableAlarmEdit(bool)));
     alarmLayout->addWidget(mAlarmButton);
 
     mAlarmTimeEdit = new QSpinBox ( 0, 9999, 1, parent, "mAlarmTimeEdit  "  ) ;
     alarmLayout->addWidget(mAlarmTimeEdit);
     mAlarmIncrCombo = new QComboBox(false, parent);
     if ( QApplication::desktop()->width() < 320 ) {
         mAlarmIncrCombo->insertItem(i18n("min"));
         mAlarmIncrCombo->insertItem(i18n("hou"));
         mAlarmIncrCombo->insertItem(i18n("day"));
         mAlarmTimeEdit->setMaximumWidth( mAlarmTimeEdit->sizeHint().width() );
         mAlarmIncrCombo->setMaximumWidth( mAlarmIncrCombo->sizeHint().width() );
     } else {
         mAlarmIncrCombo->insertItem(i18n("minute(s)"));
         mAlarmIncrCombo->insertItem(i18n("hour(s)"));
         mAlarmIncrCombo->insertItem(i18n("day(s)"));
     }
 
     //  mAlarmIncrCombo->setMinimumHeight(20);
     alarmLayout->addWidget(mAlarmIncrCombo);
     mAlarmSoundButton = new QPushButton(parent);
     mAlarmSoundButton->setPixmap(SmallIcon("playsound"));
     mAlarmSoundButton->setToggleButton(true);
     QToolTip::add(mAlarmSoundButton, i18n("No sound set"));
     connect(mAlarmSoundButton, SIGNAL(clicked()), SLOT(pickAlarmSound()));
     alarmLayout->addWidget(mAlarmSoundButton);
 
     mAlarmProgramButton = new QPushButton(parent);
     mAlarmProgramButton->setPixmap(SmallIcon("run"));
     mAlarmProgramButton->setToggleButton(true);
     QToolTip::add(mAlarmProgramButton, i18n("No program set"));
     connect(mAlarmProgramButton, SIGNAL(clicked()), SLOT(pickAlarmProgram()));
     alarmLayout->addWidget(mAlarmProgramButton);
     mAlarmSoundButton->setMaximumWidth( mAlarmSoundButton->sizeHint().width() + 4 );
     mAlarmProgramButton->setMaximumWidth(mAlarmProgramButton->sizeHint().width() + 4 );
     //   if ( KOPrefs::instance()->mCompactDialogs ) {
     //     mAlarmSoundButton->hide();
     //     mAlarmProgramButton->hide();
     //   }
 }
 
 void KOEditorGeneral::pickAlarmSound()
 {
 
     //QString prefix = mAlarmSound;
     if (!mAlarmSoundButton->isOn()) {
         //mAlarmSound = "";
         QToolTip::remove(mAlarmSoundButton);
         QToolTip::add(mAlarmSoundButton, i18n("No sound set"));
         mAlarmProgramButton->setOn(true);
         mAlarmSoundButton->setOn(false);
     } else {
         QString fileName(KFileDialog::getOpenFileName(mAlarmSound,
                                                       i18n("*.wav|Wav Files"), 0));
         if (!fileName.isEmpty()) {
             mAlarmSound = fileName;
             QToolTip::remove(mAlarmSoundButton);
             QString dispStr = i18n("Playing '%1'").arg(fileName);
             QToolTip::add(mAlarmSoundButton, dispStr);
             mAlarmProgramButton->setOn(false);
             mAlarmSoundButton->setOn(true);
         } else {
             mAlarmProgramButton->setOn(true);
             mAlarmSoundButton->setOn(false);
            
         }
     }
    
     if (mAlarmProgramButton->isOn())
         ((QWidget*)parent())->topLevelWidget()->setCaption(i18n("Proc.Al.: ") + mAlarmProgram );
     if ( mAlarmSoundButton->isOn())
         ((QWidget*)parent())->topLevelWidget()->setCaption(i18n("Audio.Al.: ") + mAlarmSound );
 }
 
 void KOEditorGeneral::pickAlarmProgram()
 {
     if (!mAlarmProgramButton->isOn()) {
         //mAlarmProgram = "";
         QToolTip::remove(mAlarmProgramButton);
         QToolTip::add(mAlarmProgramButton, i18n("No program set"));
         mAlarmProgramButton->setOn(false);
         mAlarmSoundButton->setOn(true);
     } else {
         QString fileName(KFileDialog::getOpenFileName(mAlarmProgram,i18n("Procedure Alarm.: ")  , 0));
         if (!fileName.isEmpty()) {
             mAlarmProgram = fileName;
             QToolTip::remove(mAlarmProgramButton);
             QString dispStr = i18n("Running '%1'").arg(fileName);
             QToolTip::add(mAlarmProgramButton, dispStr);
             mAlarmSoundButton->setOn(false);
             mAlarmProgramButton->setOn(true);
         }  else {
             mAlarmProgramButton->setOn(false);
             mAlarmSoundButton->setOn(true);
         }
     }
     if (mAlarmProgramButton->isOn())
         ((QWidget*)parent())->topLevelWidget()->setCaption(i18n("Proc.Al.: ") + mAlarmProgram );
     if ( mAlarmSoundButton->isOn())
         ((QWidget*)parent())->topLevelWidget()->setCaption(i18n("Sound.Al.: ") + mAlarmSound );
 }
 
 
+QString KOEditorGeneral::getFittingPath( const QString  s ) 
+{
+    int maxlen = 50;
+    if ( QApplication::desktop()->width() < 640 ) {
+        if ( QApplication::desktop()->width() < 320 )
+            maxlen = 22;
+        else
+            maxlen = 35;
+    }
+    if ( s.length() > maxlen ) {
+        return "..."+s.right(maxlen -3);
+    }
+    return s;
+}
 
 void KOEditorGeneral::enableAlarmEdit(bool enable)
 {
     if (  enable ) {
         if (!mAlarmProgramButton->isOn() && !mAlarmSoundButton->isOn()) {
             mAlarmSoundButton->setOn( true );
             if ( mAlarmSound.isEmpty() )
                 mAlarmSound = KOPrefs::instance()->mDefaultAlarmFile;
             else {
                 if ( ! QFile::exists( mAlarmSound ) )
                     mAlarmSound = KOPrefs::instance()->mDefaultAlarmFile;
             }
         }
         if (mAlarmProgramButton->isOn())
-            ((QWidget*)parent())->topLevelWidget()->setCaption(i18n("Proc.Al.: ") + mAlarmProgram );
+            ((QWidget*)parent())->topLevelWidget()->setCaption(i18n("Proc.Al.: ") + getFittingPath(mAlarmProgram) );
         if (!mAlarmSound.isEmpty() && mAlarmSoundButton->isOn())
-            ((QWidget*)parent())->topLevelWidget()->setCaption(i18n("Sound.Al.: ") + mAlarmSound );
+            ((QWidget*)parent())->topLevelWidget()->setCaption(i18n("Audio Al.: ") + getFittingPath(mAlarmSound) );
     }
     else {
-        ((QWidget*)parent())->topLevelWidget()->setCaption(i18n("Alarm disabled"));
+        ((QWidget*)parent())->topLevelWidget()->setCaption(i18n("Alarm disabled for this item"));
 
     }
     mAlarmTimeEdit->setEnabled(enable);
     mAlarmSoundButton->setEnabled(enable);
     mAlarmProgramButton->setEnabled(enable);
     mAlarmIncrCombo->setEnabled(enable);
 }
 
 void KOEditorGeneral::disableAlarmEdit(bool disable)
 {
     enableAlarmEdit( !disable );
 }
 
 void KOEditorGeneral::enableAlarm( bool enable )
 {
     enableAlarmEdit( enable );
 }
 
 void KOEditorGeneral::alarmDisable(bool disable)
 {
     if (!disable) {
         //mAlarmBell->setEnabled(true);
         mAlarmButton->setEnabled(true);
     } else {
         //mAlarmBell->setEnabled(false);
         mAlarmButton->setEnabled(false);
         mAlarmButton->setChecked(false);
         mAlarmTimeEdit->setEnabled(false);
         mAlarmSoundButton->setEnabled(false);
         mAlarmProgramButton->setEnabled(false);
         mAlarmIncrCombo->setEnabled(false);
     }
 }
 
 void KOEditorGeneral::setCategories(const QString &str)
 {
     mCategoriesLabel->setText(str);
 }
 
 void KOEditorGeneral::setDefaults(bool allDay)
 {
 #if 0
     mOwnerLabel->setText(i18n("Owner: ") + KOPrefs::instance()->fullName());
 #endif
 
     enableAlarmEdit( !allDay );
 
     // TODO: Implement a KPrefsComboItem to solve this in a clean way.
     int alarmTime;
     int a[] = { 1,5,10,15,30,60,180, 1440 };
     int index = KOPrefs::instance()->mAlarmTime;
     if (index < 0 || index > 7) {
         alarmTime = 15;
     } else {
         alarmTime = a[index];
     }
     mAlarmButton ->setChecked( false );
     mAlarmTimeEdit->setValue(alarmTime);
     mAlarmIncrCombo->setCurrentItem(0);
     enableAlarmEdit( false );
     //alarmDisable (false);
     mSecrecyCombo->setCurrentItem(Incidence::SecrecyPublic);
     mCancelBox->setChecked( false ); 
     mSummaryEdit->setEditText("");
     mLocationEdit->setEditText("");
     mDescriptionEdit->setText("");
     mAlarmSound = KOPrefs::instance()->mDefaultAlarmFile;
     setCategories("");
 }
 void KOEditorGeneral::setSecrecy( int num )
 {
     mSecrecyCombo->setCurrentItem(num);
 }
 void KOEditorGeneral::readIncidence(Incidence *event)
 {
 
     mAlarmIncrCombo->setCurrentItem(0);
     mSummaryEdit->setEditText(event->summary());
     mLocationEdit->setEditText(event->location());
     mDescriptionEdit->setText(event->description());
 
 #if 0
     // organizer information
     mOwnerLabel->setText(i18n("Owner: ") + event->organizer());
 #endif
   
     enableAlarmEdit( event->isAlarmEnabled() );
     //qDebug("KOEditorGeneral::readIncidence(Incidence *event) ");
     if(!event->isAlarmEnabled()) {
         // TODO: Implement a KPrefsComboItem to solve this in a clean way.
         int alarmTime;
         int a[] = { 1,5,10,15,30,60,180, 1440 };
         int index = KOPrefs::instance()->mAlarmTime;
         if (index < 0 || index > 7) {
             alarmTime = 15;
         } else {
             alarmTime = a[index];
         }
         mAlarmTimeEdit->setValue(alarmTime);
     }
     mAlarmButton->setChecked( event->isAlarmEnabled() );
     mSecrecyCombo->setCurrentItem(event->secrecy());
     mCancelBox->setChecked( event->cancelled() ); 
     mAlarmProgramButton->setOn(false);
     mAlarmSoundButton->setOn(false);
 
     // set up alarm stuff
     QPtrList<Alarm> alarms = event->alarms();
     Alarm* alarm;
     mAlarmIncrCombo->setCurrentItem(0);
     for ( alarm = alarms.first(); alarm; alarm = alarms.next() ) {
         int offset;
         if ( alarm->hasTime() ) {
             QDateTime t = alarm->time();
             offset = event->dtStart().secsTo( t );
         } else {
             offset = alarm->startOffset().asSeconds();
         }
         if ( offset != 0 ) {
             offset = offset / -60; // make minutes
             if (offset % 60 == 0) { // divides evenly into hours?
                 offset = offset / 60;
                 mAlarmIncrCombo->setCurrentItem(1);
                 if (offset % 24 == 0) { // divides evenly into days?
                     offset = offset / 24;
                     mAlarmIncrCombo->setCurrentItem(2);
                 }
             }
         }
         mAlarmTimeEdit->setValue( offset );
         if (alarm->type() == Alarm::Procedure) {
       
             mAlarmProgram = alarm->programFile();
             mAlarmProgramButton->setOn(true);
             QString dispStr = i18n("Running '%1'").arg(mAlarmProgram);
             QToolTip::add(mAlarmProgramButton, dispStr);
         }
         else if (alarm->type() == Alarm::Audio) {
             mAlarmSound = alarm->audioFile(); 
             if ( ! QFile::exists( mAlarmSound ) )
                 mAlarmSound = KOPrefs::instance()->mDefaultAlarmFile;
             mAlarmSoundButton->setOn(true);
             QString dispStr = i18n("Playing '%1'").arg(mAlarmSound);
             QToolTip::add(mAlarmSoundButton, dispStr);
         }
         mAlarmButton->setChecked(alarm->enabled());
         enableAlarmEdit( alarm->enabled() );
         //qDebug("nableAlarmEdit( alarm->enabled() )********* ");
         // TODO: Deal with multiple alarms
         break; // For now, stop after the first alarm
     }
 
     setCategories(event->categoriesStr());
 }
 
 void KOEditorGeneral::writeIncidence(Incidence *event)
 {
     //  kdDebug() << "KOEditorGeneral::writeEvent()" << endl;
     mLocationEdit->save(KOLocationBox::LOCATION);
     event->setSummary(mSummaryEdit->currentText());
     event->setLocation(mLocationEdit->currentText());
     event->setDescription(mDescriptionEdit->text());
     event->setCategories(mCategoriesLabel->text());
     event->setSecrecy(mSecrecyCombo->currentItem());
     event->setCancelled(mCancelBox->isChecked() );; 
     // alarm stuff
     if (mAlarmButton->isChecked()) {
         if (event->alarms().count() == 0) 
             event->newAlarm();
         QPtrList<Alarm> alarms = event->alarms();
         Alarm *alarm;
         for (alarm = alarms.first(); alarm; alarm = alarms.next() ) {
             alarm->setEnabled(true);
             int j = mAlarmTimeEdit->value()* -60;
             if (mAlarmIncrCombo->currentItem() == 1)
                 j = j * 60;
             else if (mAlarmIncrCombo->currentItem() == 2)
                 j = j * (60 * 24);
             alarm->setStartOffset( j );
 
             if (!mAlarmProgram.isEmpty() && mAlarmProgramButton->isOn()) {
                 alarm->setProcedureAlarm(mAlarmProgram);
             }
             else if (!mAlarmSound.isEmpty() && mAlarmSoundButton->isOn())
                 alarm->setAudioAlarm(mAlarmSound);
             else
                 alarm->setType(Alarm::Invalid);
             //alarm->setAudioAlarm("default");
             // TODO: Deal with multiple alarms
             break; // For now, stop after the first alarm
         }
     } else {
diff --git a/korganizer/koeditorgeneral.h b/korganizer/koeditorgeneral.h
index c58335e..de8edaf 100644
--- a/korganizer/koeditorgeneral.h
+++ b/korganizer/koeditorgeneral.h
@@ -1,112 +1,113 @@
 /*
     This file is part of KOrganizer.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program 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 General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
     As a special exception, permission is given to link this program
     with any edition of Qt, and distribute the resulting executable,
     without including the source code for Qt in the source distribution.
 */
 #ifndef KOEDITORGENERAL_H
 #define KOEDITORGENERAL_H
 
 #include <qframe.h>
 #include <qlabel.h>
 #include <qcheckbox.h>
 #include <qpushbutton.h>
 #include <qgroupbox.h>
 #include <qlineedit.h>
 #include <qcombobox.h>
 #include <qlistview.h>
 #include <qradiobutton.h>
 #include <qlayout.h>
 #include <qspinbox.h>
 
 #include <ktextedit.h>
 #include <krestrictedline.h>
 
 #include <libkcal/incidence.h>
 
 #include "ktimeedit.h"
 
 class KDateEdit;
 class KOLocationBox;
 using namespace KCal;
 
 class KOEditorGeneral : public QObject
 {
     Q_OBJECT
   public:
     KOEditorGeneral (QObject* parent=0,const char* name=0);
     virtual ~KOEditorGeneral();
     void setFocusOn( int i );
     void initHeader(QWidget *,QBoxLayout *);
     void initDescription(QWidget *,QBoxLayout *);
     void initSecrecy(QWidget *,QBoxLayout *);
     void initCategories(QWidget *,QBoxLayout *);    
     void initAlarm(QWidget *,QBoxLayout *);
 
     /** Set widgets to default values */
     void setDefaults(bool allDay);
     /** Read event object and setup widgets accordingly */
     void readIncidence(Incidence *);
     /** Write event settings to event object */
     void writeIncidence(Incidence *);
 
     /** Check if the input is valid. */
     bool validateInput() { return true; }
 
     void enableAlarm( bool enable );
     void setSecrecy( int num );
   public slots:
     void setCategories(const QString &);
     void editCategories();
 
   protected slots:
     void enableAlarmEdit( bool enable );
     void disableAlarmEdit( bool disable );
     void alarmDisable( bool disable );
     void pickAlarmSound();
     void pickAlarmProgram();
 
   signals:
     void openCategoryDialog();
     void allAccepted();
 
   protected:
     //QLineEdit               *mSummaryEdit;
     //QLineEdit               *mLocationEdit;
     KOLocationBox             *mSummaryEdit;
     KOLocationBox             *mLocationEdit;
     QLabel                  *mAlarmBell;
     QCheckBox               *mAlarmButton;
     QSpinBox                *mAlarmTimeEdit;
     QPushButton             *mAlarmSoundButton;
     QPushButton             *mAlarmProgramButton;
     QComboBox               *mAlarmIncrCombo;
     KTextEdit               *mDescriptionEdit;
     QLabel                  *mOwnerLabel;
     QComboBox               *mSecrecyCombo;
     QCheckBox               *mCancelBox;
     QPushButton             *mCategoriesButton;
     QLabel                  *mCategoriesLabel;
      
   private:
+    QString getFittingPath( const QString ) ;
     QString mAlarmSound;
     QString mAlarmProgram;
 };
 
 #endif
diff --git a/korganizer/kotodoview.cpp b/korganizer/kotodoview.cpp
index 97b4a03..30adb06 100644
--- a/korganizer/kotodoview.cpp
+++ b/korganizer/kotodoview.cpp
@@ -629,390 +629,385 @@ void KOTodoView::restoreItemState( QListViewItem *item )
 {
     pendingSubtodo = 0;
   while( item ) {
     KOTodoViewItem *todoItem = (KOTodoViewItem *)item;
     todoItem->setOpen( mDocPrefs->readBoolEntry( todoItem->todo()->uid() ) );
     if( item->childCount() > 0 ) restoreItemState( item->firstChild() );
     item = item->nextSibling();
   }
 }
 
 
 QMap<Todo *,KOTodoViewItem *>::ConstIterator
   KOTodoView::insertTodoItem(Todo *todo)
 {
 
 //  kdDebug() << "KOTodoView::insertTodoItem(): " << todo->getSummary() << endl;
   // TODO: Check, if dynmaic cast is necessary
 
     pendingSubtodo = 0;
   Incidence *incidence = todo->relatedTo();
   if (incidence && incidence->type() == "Todo") {
     Todo *relatedTodo = static_cast<Todo *>(incidence);
 
 //    kdDebug() << "  has Related" << endl;
     QMap<Todo *,KOTodoViewItem *>::ConstIterator itemIterator;
     itemIterator = mTodoMap.find(relatedTodo);
     if (itemIterator == mTodoMap.end()) {
 //      kdDebug() << "    related not yet in list" << endl;
       itemIterator = insertTodoItem (relatedTodo);
     }
     // isn't this pretty stupid? We give one Todo  to the KOTodoViewItem
     // and one into the map. Sure finding is more easy but why? -zecke
     KOTodoViewItem *todoItem = new KOTodoViewItem(*itemIterator,todo,this);
     return mTodoMap.insert(todo,todoItem);
   } else {
 //    kdDebug() << "  no Related" << endl;
       // see above -zecke
     KOTodoViewItem *todoItem = new KOTodoViewItem(mTodoListView,todo,this);
     return mTodoMap.insert(todo,todoItem);
   }
 }
 
 
 void KOTodoView::updateConfig()
 {
     updateView();
   mTodoListView->repaintContents();
 }
 
 QPtrList<Incidence> KOTodoView::selectedIncidences()
 {
   QPtrList<Incidence> selected;
 
   KOTodoViewItem *item = (KOTodoViewItem *)(mTodoListView->selectedItem());
 //  if (!item) item = mActiveItem;
   if (item) selected.append(item->todo());
 
   return selected;
 }
 
 QPtrList<Todo> KOTodoView::selectedTodos()
 {
   QPtrList<Todo> selected;
 
   KOTodoViewItem *item = (KOTodoViewItem *)(mTodoListView->selectedItem());
 //  if (!item) item = mActiveItem;
   if (item) selected.append(item->todo());
 
   return selected;
 }
 
 void KOTodoView::changeEventDisplay(Event *, int)
 {
   updateView();
 }
 
 void KOTodoView::showDates(const QDate &, const QDate &)
 {
 }
 
 void KOTodoView::showEvents(QPtrList<Event>)
 {
   kdDebug() << "KOTodoView::selectEvents(): not yet implemented" << endl;
 }
 
 void KOTodoView::printPreview(CalPrinter *calPrinter, const QDate &fd,
                               const QDate &td)
 {
 #ifndef KORG_NOPRINTER
   calPrinter->preview(CalPrinter::Todolist, fd, td);
 #endif
 }
 
 void KOTodoView::editItem(QListViewItem *item )
 {
     // qDebug("editItem(QListViewItem *item ) ");
   emit editTodoSignal(((KOTodoViewItem *)item)->todo());
 }
 
 void KOTodoView::showItem(QListViewItem *item,const QPoint &,int)
 {
   emit showTodoSignal(((KOTodoViewItem *)item)->todo());
 }
 
 void KOTodoView::popupMenu(QListViewItem *item,const QPoint &,int column)
 {
     pendingSubtodo = 0;
   mActiveItem = (KOTodoViewItem *)item;
   if (item) {
     switch (column){
     case 1:
       mPriorityPopupMenu->popup(QCursor::pos ()); break;
     case 2:
       mPercentageCompletedPopupMenu->popup(QCursor::pos ()); break;
     case 3:
          moveTodo();
         break;
     case 8:
       getCategoryPopupMenu((KOTodoViewItem *)item)->popup(QCursor::pos ()); break;
     default:
       mItemPopupMenu->popup(QCursor::pos());
     }
  } else mPopupMenu->popup(QCursor::pos());
 }
 void KOTodoView::newTodo()
 {
   emit newTodoSignal();
 }
 
 void KOTodoView::newSubTodo()
 {
   if (mActiveItem) {
     emit newSubTodoSignal(mActiveItem->todo());
   }
 }
 void KOTodoView::unparentTodo()
 {
  if (mActiveItem) {
     emit unparentTodoSignal(mActiveItem->todo());
   }
 }
 
 void KOTodoView::reparentTodo()
 { 
     if (mActiveItem) {
         qDebug("KOTodoView::reparentTodo() ");
         topLevelWidget()->setCaption(i18n("Click on new parent item"));
         pendingSubtodo = mActiveItem;
     }
 }
 void KOTodoView::editTodo()
 {
   if (mActiveItem) {
     emit editTodoSignal(mActiveItem->todo());
   }
 }
 void KOTodoView::cloneTodo()
 {
   if (mActiveItem) {
     emit cloneTodoSignal((Incidence*)mActiveItem->todo());
   }
 }
 void KOTodoView::cancelTodo()
 {
   if (mActiveItem) {
     emit cancelTodoSignal((Incidence*)mActiveItem->todo());
   }
 }
 void KOTodoView::moveTodo()
 {
   if (mActiveItem) {
     emit moveTodoSignal((Incidence*)mActiveItem->todo());
   }
 }
 void KOTodoView::beamTodo()
 {
   if (mActiveItem) {
     emit beamTodoSignal((Incidence*)mActiveItem->todo());
   }
 }
 
 
 void KOTodoView::showTodo()
 {
   if (mActiveItem) {
     emit showTodoSignal(mActiveItem->todo());
   }
 }
 
 void KOTodoView::deleteTodo()
 {
   if (mActiveItem) {
-    if (mActiveItem->childCount()) {
-      KMessageBox::sorry(this,i18n("Cannot delete To-Do which has children."),
-                         i18n("Delete To-Do"));
-    } else {
       emit deleteTodoSignal(mActiveItem->todo());
-    }
   }
 }
 
 void KOTodoView::setNewPriority(int index)
 {
   if (mActiveItem && !mActiveItem->todo()->isReadOnly ()) {
     mActiveItem->todo()->setPriority(mPriority[index]);
     mActiveItem->construct();
    todoModified (mActiveItem->todo(), KOGlobals::PRIORITY_MODIFIED);
    mActiveItem->todo()->setRevision( mActiveItem->todo()->revision()+1  );
   }
 }
 
 void KOTodoView::setNewPercentage(int index)
 {
   if (mActiveItem && !mActiveItem->todo()->isReadOnly ()) {
     if (mPercentage[index] == 100) {
       mActiveItem->todo()->setCompleted(QDateTime::currentDateTime());
     } else {
       mActiveItem->todo()->setCompleted(false);
     }
     mActiveItem->todo()->setPercentComplete(mPercentage[index]);
     mActiveItem->construct();
     todoModified (mActiveItem->todo (), KOGlobals::COMPLETION_MODIFIED);
     mActiveItem->todo()->setRevision( mActiveItem->todo()->revision()+1  );
   }
 }
 
 
 QPopupMenu * KOTodoView::getCategoryPopupMenu (KOTodoViewItem *todoItem)
 {
   QPopupMenu* tempMenu = new QPopupMenu (this);
   QStringList checkedCategories = todoItem->todo()->categories ();
 
   tempMenu->setCheckable (true);
   for (QStringList::Iterator it = KOPrefs::instance()->mCustomCategories.begin ();
        it != KOPrefs::instance()->mCustomCategories.end ();
        ++it) {
     int index = tempMenu->insertItem (*it);
     mCategory[index] = *it;
     if (checkedCategories.find (*it) != checkedCategories.end ()) tempMenu->setItemChecked (index, true);
   }
 
   connect (tempMenu, SIGNAL (activated (int)), SLOT (changedCategories (int)));
   return tempMenu;
 
 
 }
 void KOTodoView::changedCategories(int index)
 {
   if (mActiveItem && !mActiveItem->todo()->isReadOnly ()) {
     QStringList categories = mActiveItem->todo()->categories ();
     if (categories.find (mCategory[index]) != categories.end ())
       categories.remove (mCategory[index]);
     else
       categories.insert (categories.end(), mCategory[index]);
     categories.sort ();
     mActiveItem->todo()->setCategories (categories);
     mActiveItem->construct();
     mActiveItem->todo()->setRevision( mActiveItem->todo()->revision()+1  );
     todoModified (mActiveItem->todo (), KOGlobals::CATEGORY_MODIFIED);
   }
 }
 void KOTodoView::itemDoubleClicked(QListViewItem *item)
 {
     if ( pendingSubtodo != 0 ) {
         topLevelWidget()->setCaption(i18n("Reparenting aborted!"));
     }
     pendingSubtodo = 0;
     if (!item) {
         newTodo();
         return;
     }
     if ( KOPrefs::instance()->mEditOnDoubleClick )
         editItem( item );
     else
         showItem( item , QPoint(), 0 );
 }
 void KOTodoView::itemClicked(QListViewItem *item)
 {
 
   if (!item) {
       if ( pendingSubtodo != 0 ) {
           topLevelWidget()->setCaption(i18n("Reparenting aborted!"));
       }
       pendingSubtodo = 0;
       return;
   }
   KOTodoViewItem *todoItem = (KOTodoViewItem *)item;
   if ( pendingSubtodo != 0 ) {
       bool allowReparent = true;
       QListViewItem *par = item;
       while ( par ) {
           if ( par ==  pendingSubtodo ) {
               allowReparent = false;
               break;
           }
           par = par->parent();
       }
       if ( !allowReparent  ) {
           topLevelWidget()->setCaption(i18n("Recursive reparenting not possible!"));
           qDebug("Recursive reparenting not possible ");
           pendingSubtodo = 0;
       } else {
           Todo* newParent = todoItem->todo();
           Todo* newSub = pendingSubtodo->todo();
           pendingSubtodo = 0;
           emit reparentTodoSignal( newParent,newSub  );
           return;
       }
   }
   int completed = todoItem->todo()->isCompleted();  // Completed or not?
 
   if (todoItem->isOn()) {
     if (!completed) {
       todoItem->todo()->setCompleted(QDateTime::currentDateTime());
     }
   } else {
     if (completed) {
       todoItem->todo()->setCompleted(false);
     }
   }
 }
 
 void KOTodoView::setDocumentId( const QString &id )
 {
   kdDebug() << "KOTodoView::setDocumentId()" << endl;
 
   mDocPrefs->setDoc( id );
 }
 
 void KOTodoView::itemStateChanged( QListViewItem *item )
 {
   if (!item) return;
 
   KOTodoViewItem *todoItem = (KOTodoViewItem *)item;
 
 //  kdDebug() << "KOTodoView::itemStateChanged(): " << todoItem->todo()->summary() << endl;
 
   if( mDocPrefs ) mDocPrefs->writeEntry( todoItem->todo()->uid(), todoItem->isOpen() );
 }
 
 void KOTodoView::saveLayout(KConfig *config, const QString &group) const
 {
   mTodoListView->saveLayout(config,group);
 }
 
 void KOTodoView::restoreLayout(KConfig *config, const QString &group)
 {
   mTodoListView->restoreLayout(config,group);
 }
 
 void KOTodoView::processSelectionChange()
 {
 //  kdDebug() << "KOTodoView::processSelectionChange()" << endl;
 
   KOTodoViewItem *item =
     static_cast<KOTodoViewItem *>( mTodoListView->selectedItem() );
 
   if ( !item ) {
     emit incidenceSelected( 0 );
   } else {
     emit incidenceSelected( item->todo() );
   }
 }
 
 void KOTodoView::modified(bool b)
 {
   emit isModified(b);
 }
 void KOTodoView::setTodoModified( Todo* todo )
 {
   todoModified( todo, KOGlobals::UNKNOWN_MODIFIED );
 }
 void KOTodoView::clearSelection()
 {
   mTodoListView->selectAll( false );
 }
 
 void KOTodoView::purgeCompleted()
 {
   emit purgeCompletedSignal();
 }
 void KOTodoView::toggleQuickTodo()
 {
     if ( mQuickAdd->isVisible() ) {
         mQuickAdd->hide();
         KOPrefs::instance()->mEnableQuickTodo = false;
     }
     else {
         mQuickAdd->show();
         KOPrefs::instance()->mEnableQuickTodo = true;
diff --git a/korganizer/mainwindow.cpp b/korganizer/mainwindow.cpp
index 151b55b..7b07a2e 100644
--- a/korganizer/mainwindow.cpp
+++ b/korganizer/mainwindow.cpp
@@ -1515,385 +1515,394 @@ void MainWindow::keyPressEvent ( QKeyEvent * e )
         mView->toggleFilerEnabled( );
         break;
     case Qt::Key_0:
     case Qt::Key_1:
     case Qt::Key_2:
     case Qt::Key_3:
     case Qt::Key_4:
     case Qt::Key_5:
     case Qt::Key_6:
     case Qt::Key_7:
     case Qt::Key_8:
     case Qt::Key_9:
         pro =  e->key()-48;
         if ( pro == 0 )
             pro = 10;
         if ( e->state() == Qt::ControlButton)
             pro += 10;
         break;
     case Qt::Key_M:
         mView->viewManager()->showMonthView();
         showSelectedDates = true;
         break;
     case Qt::Key_Insert:
         mView->newEvent();
         break;
     case Qt::Key_S :
         if ( e->state() == Qt::ControlButton ||  e->state() == Qt::ShiftButton)
             mView->newSubTodo();
         else
             mView->dialogManager()->showSearchDialog();
         break;
     case Qt::Key_Y :
     case Qt::Key_Z :
         mView->viewManager()->showWorkWeekView();
         showSelectedDates = true;
         break;
     case Qt::Key_U :
         mView->viewManager()->showWeekView();
         showSelectedDates = true;
         break;
     case Qt::Key_H :
         keyBindings();
         break;
     case Qt::Key_W:
         mView->viewManager()->showWhatsNextView();
         break;
     case Qt::Key_L:
         mView->viewManager()->showListView();
         break;
     case Qt::Key_N:
         mView->viewManager()->showNextXView();
         showSelectedDates = true;
         break;
     case Qt::Key_V:
         mView->viewManager()->showTodoView();
         break;
     case Qt::Key_C:
         mView->viewManager()->agendaView()->setStartHour( QTime::currentTime ().hour() );
         break;
     case Qt::Key_P:
         mView->showDatePicker( );
         break;
     case Qt::Key_F:
         if ( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton )
             mView->editFilters();
         else
             mView->toggleFilter();
         break;
     case Qt::Key_X:
         mView->toggleDateNavigatorWidget();
         break;
     case Qt::Key_Space:
         mView->toggleExpand();
         break;
     case Qt::Key_A:
         mView->toggleAllDaySize();
         break;
     case Qt::Key_T:
         if ( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton )
             mView->newTodo();
         else {
             mView->goToday();
             showSelectedDates = true;
         }
         break;
     case Qt::Key_J:
         mView->viewManager()->showJournalView();
         break;
     case Qt::Key_B:
         mView->editIncidenceDescription();;
         break;
         // case Qt::Key_Return:
     case Qt::Key_E:
         if ( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton )
             mView->newEvent();
         else
             mView->editIncidence();
         break;
     case Qt::Key_Plus:
         size = p->mHourSize +2;
         if ( size <= 18 )
             configureAgenda( size );
         break;
     case Qt::Key_Minus:
         size = p->mHourSize - 2;
         if ( size >= 4 )
             configureAgenda( size );
         break;
 
 
     default:
         e->ignore();
     }
     if ( pro > 0 ) {
         mView->selectFilter(  pro-1 );
     }
     if ( showSelectedDates ) {
         ;//  setCaptionToDates();
     }
 
 }
 
 void MainWindow::fillFilterMenu()
 {
     selectFilterMenu->clear();
     bool disable = false;
     selectFilterMenu->insertItem(i18n ( "Edit Filters" ),  0 );
     selectFilterMenu->insertSeparator();
     if ( mView->filterView()->filtersEnabled()   ) {
         selectFilterMenu->insertItem(i18n ( "Turn filter off" ),  1 );
     }
     else {
         selectFilterMenu->insertItem(i18n ( "Turn filter on" ),  1 );
         disable = true;
     }
     selectFilterMenu->insertSeparator();
     QPtrList<CalFilter> fili = mView->filters();
     CalFilter *curfilter = mView->filterView()->selectedFilter();
     CalFilter *filter = fili.first();
     int iii = 2;
     while(filter) {
         selectFilterMenu->insertItem( filter->name(),  iii );
         if ( filter == curfilter)
             selectFilterMenu->setItemChecked( iii, true );
         if ( disable )
             selectFilterMenu->setItemEnabled( iii, false );
         filter = fili.next();
         ++iii;
     }
 }
 void MainWindow::selectFilter( int fil )
 {
     if ( fil == 0 ) {
         mView->editFilters( );
     } else if ( fil == 1 ){
         mView->toggleFilerEnabled( );
     } else {
         mView->selectFilter(  fil-2 );
     }
 }
 void MainWindow::configureToolBar( int item  )
 {
 
     configureToolBarMenu->setItemChecked( item, !configureToolBarMenu-> isItemChecked ( item ) );
     KOPrefs *p = KOPrefs::instance();
     p-> mShowIconStretch= configureToolBarMenu->isItemChecked( 5 );
     p-> mShowIconNewEvent= configureToolBarMenu->isItemChecked( 10 );
     p->mShowIconNewTodo = configureToolBarMenu->isItemChecked( 20 );
     p-> mShowIconSearch= configureToolBarMenu->isItemChecked( 120 );
     p-> mShowIconList= configureToolBarMenu->isItemChecked( 30 );
     p-> mShowIconDay1= configureToolBarMenu->isItemChecked( 40 );
     p-> mShowIconDay5= configureToolBarMenu->isItemChecked( 50 );
     p-> mShowIconDay7= configureToolBarMenu->isItemChecked( 60 );
     p-> mShowIconMonth= configureToolBarMenu->isItemChecked( 70 );
     p-> mShowIconTodoview= configureToolBarMenu->isItemChecked( 80 );
     p-> mShowIconBackFast= configureToolBarMenu->isItemChecked( 200 );
     p-> mShowIconBack = configureToolBarMenu->isItemChecked( 210 );
     p-> mShowIconToday= configureToolBarMenu->isItemChecked( 130 );
     p-> mShowIconForward= configureToolBarMenu->isItemChecked( 220 );
     p-> mShowIconForwardFast= configureToolBarMenu->isItemChecked( 230 );
     p-> mShowIconNextDays= configureToolBarMenu->isItemChecked( 100 );
     p-> mShowIconNext= configureToolBarMenu->isItemChecked( 110 );
     p-> mShowIconJournal= configureToolBarMenu->isItemChecked( 90 );
     p-> mShowIconWhatsThis= configureToolBarMenu->isItemChecked( 300 );
     // initActions();
 }
 
 void MainWindow::setCaptionToDates()
 {
     QString selDates;
     selDates = KGlobal::locale()->formatDate(mView->startDate(), true);
     if  (mView->startDate() < mView->endDate() )
-        selDates += " - " + KGlobal::locale()->formatDate(mView->endDate(), true);
+        selDates += " - " + KGlobal::locale()->formatDate(mView->endDate(), true); 
+    else {
+        QString addString;
+        if ( mView->startDate() == QDateTime::currentDateTime().date() )
+            addString = i18n("Today");
+        else if ( mView->startDate() == QDateTime::currentDateTime().date().addDays(1) )
+            addString = i18n("Tomorrow");
+        if ( !addString.isEmpty() )
+            selDates = addString+", "+selDates ;
+    }
     setCaption( i18n("Dates: ") + selDates );
 
 }
 // parameter item == 0: reinit
 void MainWindow::configureAgenda( int item )
 {
 
     KOPrefs *p = KOPrefs::instance();
 
     int i;
     // do not allow 4 for widgets higher than 480
  //    if ( QApplication::desktop()->height() > 480 ) {
 //         if ( item == 4 )
 //             item = 6;
 //     }
     for ( i = 4; i <= 18; i= i+2 )
         configureAgendaMenu->setItemChecked( i, false );
     configureAgendaMenu->setItemChecked( item, true );
     if ( p->mHourSize == item )
         return;
     p->mHourSize=item;
     mView->viewManager()->agendaView()->updateConfig();
 }
 
 void  MainWindow::saveCalendar()
 {
     QString fn =  KOPrefs::instance()->mLastSaveFile;
     fn =  KFileDialog::getSaveFileName( fn, i18n("Save backup filename"), this );
 
     if ( fn == "" )
         return;
     QFileInfo info;
     info.setFile( fn );
     QString mes;
     bool createbup = true;
     if ( info. exists() ) {
         mes =  i18n("Backup file\nalready exists!\nOld backup file from:\n%1\nOverwrite?\n").arg(KGlobal::locale()->formatDateTime(info.lastModified (), true, false )) ;
         int result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),mes,
                                            i18n("Overwrite!"), i18n("Cancel"), 0,
                                            0, 1 );
         if ( result != 0 ) {
             createbup = false;
         }
     }
     if ( createbup ) {
         mView->saveCalendar( fn );
         mes = i18n("KO/Pi:Saved %1").arg(fn);
         KOPrefs::instance()->mLastSaveFile = fn;
         setCaption(mes);
     }
 }
 void  MainWindow::loadCalendar()
 {
 
     QString fn =   KOPrefs::instance()->mLastLoadFile;
     fn =  KFileDialog::getOpenFileName( fn, i18n("Load backup filename"), this );
 
     if ( fn == "" )
         return;
     QFileInfo info;
     info.setFile( fn );
     QString mess;
     bool loadbup = true;
     if ( info. exists() ) {
         mess =   i18n("Backup file from:\n%1\nLoading  backup\nfile will delete\nyour current Data!\n").arg(KGlobal::locale()->formatDateTime(info.lastModified (), true, false ));
         int result = QMessageBox::warning( this, "KO/Pi: Warning!",
                                            mess,
                                            i18n("Load!"), i18n("Cancel"), 0,
                                            0, 1 );
         if ( result != 0 ) {
             loadbup = false;
         }
     } else {
         QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
                               i18n("Backup file\ndoes not exist!\nNothing loaded!"), 0, 0,
                               0, 1 );
 
         return;
     }
     if ( loadbup ) {
         mView->openCalendar( fn );
         KOPrefs::instance()->mLastLoadFile = fn;
         mess = i18n("KO/Pi:Loaded %1").arg(fn) ;
         setCaption(mess);
     }
 
 }
 void  MainWindow::quickImportIcal()
 {
     importFile( KOPrefs::instance()->mLastImportFile, false );
 }
 void MainWindow::importFile( QString  fn, bool quick )
 {
     QFileInfo info;
     info.setFile( fn );
     QString mess;
     bool loadbup = true;
     if ( !info. exists() ) {
         mess =  i18n("Import file \n...%1\ndoes not exist!\nNothing imported!\n").arg(fn.right( 30));
         int result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
                                            mess );
         return;
     }
     int result = 0;
     if ( !quick ) {
         mess = i18n(  "Import file \n...%1\nfrom:\n%2\nDuplicated entries\nwill not be imported!\n").arg(fn.right( 25)).arg(KGlobal::locale()->formatDateTime(info.lastModified (), true, false ));
         result = QMessageBox::warning( this, "KO/Pi: Warning!",
                                        mess,
                                        "Import", "Cancel", 0,
                                        0, 1 );
     }
     if ( result == 0 ) {
         if ( mView->openCalendar( fn, true )) {
             KOPrefs::instance()->mLastImportFile = fn;
             setCaption(i18n("Imported file successfully"));
         } else {
             setCaption(i18n("Error importing file"));
         }
     }
 }
 
 void   MainWindow::importIcal()
 {
 
     QString fn =KOPrefs::instance()->mLastImportFile;
 
     fn =KFileDialog:: getOpenFileName( fn, i18n("Import filename(*.ics/*.vcs)"), this );
     if ( fn == "" )
         return;
     importFile(  fn, true );
 
 }
 
 void MainWindow::exportVCalendar()
 {
     QString fn =  KOPrefs::instance()->mLastVcalFile;
     fn =  KFileDialog::getSaveFileName( fn, i18n("Export vcal filename(*.vcs)"), this );
     if ( fn == "" )
         return;
     QFileInfo info;
     info.setFile( fn );
     QString mes;
     bool createbup = true;
     if ( info. exists() ) {
         mes = i18n("Save file\nalready exists!\nOld save file from:\n%1\nOverwrite?\n").arg (KGlobal::locale()->formatDateTime(info.lastModified (), true, false ) );
         int result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),mes,
                                            i18n("Overwrite!"), i18n("Cancel"), 0,
                                            0, 1 );
         if ( result != 0 ) {
             createbup = false;
         }
     }
     if ( createbup ) {
         if ( mView->exportVCalendar( fn ) ) {
             KOPrefs::instance()->mLastVcalFile = fn;
             if ( fn.length() > 20 )
                 mes = i18n("KO/Pi:Exported to ...%1").arg(fn.right(20)) ;
             else
                 mes = i18n("KO/Pi:Exported to %1").arg(fn );
             setCaption(mes);
         }
     }
 
 }
 
 void MainWindow::syncFileRequest()
 {
     if ( KOPrefs::instance()->mPassiveSyncWithDesktop ) {
         mSyncManager->slotSyncMenu( 999 );
     } 
     save();
 }
 void MainWindow::getFile( bool success )
 {
     if ( ! success ) {
         setCaption( i18n("Error receiving file. Nothing changed!") );
         return;
     }
     mView->openCalendar( defaultFileName() ); 
     if ( KOPrefs::instance()->mPassiveSyncWithDesktop ) {
         mSyncManager->slotSyncMenu( 999 );
     } 
     setCaption( i18n("Pi-Sync successful!") );
 } 
 
 void MainWindow::printSel( )
 {
     mView->viewManager()->agendaView()->agenda()->printSelection();
 }
 
 void MainWindow::printCal()
 {
diff --git a/libkcal/calendarlocal.cpp b/libkcal/calendarlocal.cpp
index 12294c0..0eba6a9 100644
--- a/libkcal/calendarlocal.cpp
+++ b/libkcal/calendarlocal.cpp
@@ -13,386 +13,386 @@
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 #include <qdatetime.h>
 #include <qstring.h>
 #include <qptrlist.h>
 
 #include <kdebug.h>
 #include <kconfig.h>
 #include <kglobal.h>
 #include <klocale.h>
 
 #include "vcaldrag.h"
 #include "vcalformat.h"
 #include "icalformat.h"
 #include "exceptions.h"
 #include "incidence.h"
 #include "journal.h"
 #include "filestorage.h"
 #include "calfilter.h"
 
 #include "calendarlocal.h"
 
 // #ifndef DESKTOP_VERSION
 // #include <qtopia/alarmserver.h> 
 // #endif
 using namespace KCal;
 
 CalendarLocal::CalendarLocal()
   : Calendar()
 {
   init();
 }
 
 CalendarLocal::CalendarLocal(const QString &timeZoneId)
   : Calendar(timeZoneId)
 {
   init();
 }
 
 void CalendarLocal::init()
 {
     mNextAlarmIncidence = 0;
 }
 
 
 CalendarLocal::~CalendarLocal()
 {
   close();
 }
 
 bool CalendarLocal::load( const QString &fileName )
 {
   FileStorage storage( this, fileName );
   return storage.load();
 }
 
 bool CalendarLocal::save( const QString &fileName, CalFormat *format )
 {
   FileStorage storage( this, fileName, format );
   return storage.save();
 }
 
 void CalendarLocal::close()
 {
   mEventList.setAutoDelete( true );
   mTodoList.setAutoDelete( true );
   mJournalList.setAutoDelete( false );
 
   mEventList.clear();
   mTodoList.clear();
   mJournalList.clear();
 
   mEventList.setAutoDelete( false );
   mTodoList.setAutoDelete( false );
   mJournalList.setAutoDelete( false );
 
   setModified( false );
 }
     
 bool CalendarLocal::addAnniversaryNoDup( Event *event )
 {
     QString cat;
     bool isBirthday = true;
     if(  event->categoriesStr() == i18n( "Anniversary" ) ) {
         isBirthday = false;
         cat = i18n( "Anniversary" );
     } else if(  event->categoriesStr() == i18n( "Birthday" ) ) {
         isBirthday = true;
         cat = i18n( "Birthday" );
     } else {
         qDebug("addAnniversaryNoDup called without fitting category! ");
         return false;
     }
     Event * eve;
     for ( eve = mEventList.first(); eve ; eve = mEventList.next() ) {
         if ( !(eve->categories().contains( cat ) ))
             continue;
         // now we have an event with fitting category
         if ( eve->dtStart().date() != event->dtStart().date() )
             continue;
         // now we have an event with fitting category+date
         if ( eve->summary() != event->summary() )
             continue;
         // now we have an event with fitting category+date+summary
         return false;
     }
     return addEvent( event );
 
 }
 bool CalendarLocal::addEventNoDup( Event *event )
 {
     Event * eve;
     for ( eve = mEventList.first(); eve ; eve = mEventList.next() ) {
         if ( *eve == *event ) {
             //qDebug("CalendarLocal::Duplicate event found! Not inserted! ");
             return false;
         }
     }
     return addEvent( event );
 }
 
 bool CalendarLocal::addEvent( Event *event )
 {
   insertEvent( event );
 
   event->registerObserver( this );
 
   setModified( true );
 
   return true;
 }
 
 void CalendarLocal::deleteEvent( Event *event )
 {
     if ( mUndoIncidence ) delete mUndoIncidence;
     mUndoIncidence = event->clone();
     if ( mEventList.removeRef( event ) ) {
         setModified( true );
     }
 }
 
 
 Event *CalendarLocal::event( const QString &uid )
 {
 
   Event *event;
 
   for ( event = mEventList.first(); event; event = mEventList.next() ) {
     if ( event->uid() == uid ) {
       return event;
     }
   }
 
   return 0;
 }
 bool CalendarLocal::addTodoNoDup( Todo *todo )
 {
   Todo * eve;
     for ( eve = mTodoList.first(); eve ; eve = mTodoList.next() ) {
         if ( *eve == *todo ) {
             //qDebug("duplicate todo found! not inserted! ");
             return false;
         }
     }
     return addTodo( todo );
 }
 bool CalendarLocal::addTodo( Todo *todo )
 {
   mTodoList.append( todo );
 
   todo->registerObserver( this );
 
   // Set up subtask relations
   setupRelations( todo );
 
   setModified( true );
 
   return true;
 }
 
 void CalendarLocal::deleteTodo( Todo *todo )
 {
   // Handle orphaned children
     if ( mUndoIncidence ) delete mUndoIncidence;
-    mUndoIncidence = todo->clone();
     removeRelations( todo );
+    mUndoIncidence = todo->clone();
 
   if ( mTodoList.removeRef( todo ) ) {
     setModified( true );
   }
 }
 
 QPtrList<Todo> CalendarLocal::rawTodos()
 {
   return mTodoList;
 }
 Todo *CalendarLocal::todo( QString syncProf, QString id )
 {
   Todo *todo;
   for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) {
       if ( todo->getID( syncProf ) == id ) return todo;
   }
 
   return 0;
 }
 void CalendarLocal::removeSyncInfo( QString syncProfile)
 {
     QPtrList<Incidence> all = rawIncidences() ;
     Incidence *inc;
     for ( inc = all.first(); inc; inc = all.next() ) {
         inc->removeID( syncProfile );
     }
     if ( syncProfile.isEmpty() ) {
         QPtrList<Event> el;
         Event *todo;
         for ( todo = mEventList.first(); todo; todo = mEventList.next() ) {
             if ( todo->uid().left( 15 ) == QString("last-syncEvent-") )
                     el.append( todo );
         }
         for ( todo = el.first(); todo; todo = el.next() ) {
            deleteIncidence ( todo );
         }
     } else {
         Event *lse = event( "last-syncEvent-"+ syncProfile);
         deleteIncidence ( lse );
     }
 }
 QPtrList<Event> CalendarLocal::getExternLastSyncEvents()
 {
     QPtrList<Event> el;
     Event *todo;
     for ( todo = mEventList.first(); todo; todo = mEventList.next() ) {
         if ( todo->uid().left( 15 ) == QString("last-syncEvent-") )
             if ( todo->summary().left(3) == "E: " )
                 el.append( todo );
     }
 
     return el;
 
 }
 Event *CalendarLocal::event( QString syncProf,  QString id )
 {
   Event *todo;
   for ( todo = mEventList.first(); todo; todo = mEventList.next() ) {
       if ( todo->getID( syncProf ) == id ) return todo;
   }
 
   return 0;
 }
 Todo *CalendarLocal::todo( const QString &uid )
 {
   Todo *todo;
   for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) {
     if ( todo->uid() == uid ) return todo;
   }
 
   return 0;
 }
 QString CalendarLocal::nextSummary() const
 {
     return mNextSummary;
 }
 QDateTime CalendarLocal::nextAlarmEventDateTime()  const
 {
     return mNextAlarmEventDateTime;
 }
 void  CalendarLocal::checkAlarmForIncidence( Incidence * incidence, bool deleted)
 {
     //mNextAlarmIncidence
     //mNextAlarmDateTime
     //return mNextSummary;
     //return mNextAlarmEventDateTime;
     bool newNextAlarm = false; 
     bool computeNextAlarm = false;
     bool ok;
     int offset;
     QDateTime nextA;
     // QString nextSum;
     //QDateTime nextEvent;
     if ( mNextAlarmIncidence == 0 || incidence == 0 ) {
         computeNextAlarm = true;
     } else {
         if ( ! deleted ) {
             nextA = incidence->getNextAlarmDateTime(& ok, &offset ) ;
             if ( ok ) {
                 if ( nextA < mNextAlarmDateTime  ) {
                     deRegisterAlarm();
                     mNextAlarmDateTime = nextA;
                     mNextSummary  = incidence->summary();
                     mNextAlarmEventDateTime = nextA.addSecs(offset ) ; 
                     mNextAlarmEventDateTimeString = KGlobal::locale()->formatDateTime(mNextAlarmEventDateTime);
                     newNextAlarm = true;
                     mNextAlarmIncidence = incidence;
                 } else {
                     if ( incidence == mNextAlarmIncidence ) {
                         computeNextAlarm = true;
                     }
                 }
             } else {
                 if ( mNextAlarmIncidence == incidence ) {
                     computeNextAlarm = true;
                 }
             }
         } else { // deleted
             if ( incidence == mNextAlarmIncidence ) {
                 computeNextAlarm = true;
             }
         }
     }
     if ( computeNextAlarm ) {
         deRegisterAlarm();
         nextA = nextAlarm( 1000 );  
         if (! mNextAlarmIncidence ) {
             return;
         }
         newNextAlarm = true;
     }
     if ( newNextAlarm )
         registerAlarm();
 }
 QString CalendarLocal:: getAlarmNotification()
 { 
     QString ret;
     // this should not happen
     if (! mNextAlarmIncidence ) 
             return "cal_alarm"+ mNextSummary.left( 25 )+"\n"+mNextAlarmEventDateTimeString;
     Alarm* alarm =  mNextAlarmIncidence->alarms().first();
     if ( alarm->type() == Alarm::Procedure ) {
         ret = "proc_alarm" + alarm->programFile()+"+++";
     } else {
         ret = "audio_alarm" +alarm->audioFile() +"+++";
     }
     ret += "cal_alarm"+ mNextSummary.left( 25 );
     if ( mNextSummary.length() > 25 )
         ret += "\n" + mNextSummary.mid(25, 25 );
     ret+= "\n"+mNextAlarmEventDateTimeString;
     return ret;
 }
 void CalendarLocal::registerAlarm()
 {
     mLastAlarmNotificationString = getAlarmNotification();
     // qDebug("++ register Alarm %s %s",mNextAlarmDateTime.toString().latin1(), mLastAlarmNotificationString.latin1() );
     emit addAlarm ( mNextAlarmDateTime, mLastAlarmNotificationString );
 // #ifndef DESKTOP_VERSION
 //     AlarmServer::addAlarm ( mNextAlarmDateTime,"koalarm", mLastAlarmNotificationString.latin1() );
 // #endif     
 }
 void CalendarLocal::deRegisterAlarm()
 {
     if ( mLastAlarmNotificationString.isNull() )
         return;
     //qDebug("-- deregister Alarm %s ", mLastAlarmNotificationString.latin1() );
 
     emit removeAlarm ( mNextAlarmDateTime, mLastAlarmNotificationString );
 // #ifndef DESKTOP_VERSION
 //     AlarmServer::deleteAlarm (mNextAlarmDateTime ,"koalarm" ,mLastAlarmNotificationString.latin1() );
 // #endif     
 }
 
 QPtrList<Todo> CalendarLocal::todos( const QDate &date )
 {
   QPtrList<Todo> todos;
 
   Todo *todo;
   for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) {
     if ( todo->hasDueDate() && todo->dtDue().date() == date ) {
       todos.append( todo );
     }
   }
 
  filter()->apply( &todos );
   return todos;
 }
 void CalendarLocal::reInitAlarmSettings()
 {
     if ( !mNextAlarmIncidence  ) {
         nextAlarm( 1000 );
     }
diff --git a/microkde/kdatetbl.cpp b/microkde/kdatetbl.cpp
index 146291b..508ce31 100644
--- a/microkde/kdatetbl.cpp
+++ b/microkde/kdatetbl.cpp
@@ -155,396 +155,399 @@ KDateTable::paintCell(QPainter *painter, int row, int col)
       if(pos<firstday || (firstday+numdays<=pos))
         { // we are either
           // ° painting a day of the previous month or
           // ° painting a day of the following month
           if(pos<firstday)
             { // previous month
               text.setNum(numDaysPrevMonth+pos-firstday+1);
             } else { // following month
               text.setNum(pos-firstday-numdays+1);
             }
           painter->setPen(gray);
         } else { // paint a day of the current month
           text.setNum(pos-firstday+1);
           painter->setPen(black);
         }
 
       pen=painter->pen();
       if(firstday+date.day()-1==pos)
         {
             if(mMarkCurrent && firstday+QDate::currentDate().day()-1==pos)
                 painter->setPen(green);
             else
                 painter->setPen(red);
           if(hasFocus())
               {  
                   painter->setBrush(darkRed);
                   pen=white;
             } else {
               painter->setBrush(darkGray);
               pen=white;
             }
         } else {
           if(mMarkCurrent && firstday+QDate::currentDate().day()-1==pos)
               {
                   painter->setPen(green);
                   painter->setBrush(darkGreen);
                   pen=white;
               } else {
               painter->setBrush(QColor(220,245,255));
               painter->setPen(QColor(220,245,255));
           }
       }
       painter->drawRect(0, 0, w, h);
       painter->setPen(pen);
       painter->drawText(0, 0, w, h, AlignCenter, text, -1, &rect);
     }
   if(rect.width()>maxCell.width()) maxCell.setWidth(rect.width());
   if(rect.height()>maxCell.height()) maxCell.setHeight(rect.height());
 }
 
 void
 KDateTable::keyPressEvent( QKeyEvent *e )
 {
     /*
     // not working properly
     if ( e->key() == Qt::Key_Prior ) {
         if ( date.month() == 1 ) {
             KNotifyClient::beep();
             return;
         }
         int day = date.day();
         if ( day > 27 )
             while ( !QDate::isValid( date.year(), date.month()-1, day ) )
                 day--;
         setDate(QDate(date.year(), date.month()-1, day));
         return;
     }
     if ( e->key() == Qt::Key_Next ) {
         if ( date.month() == 12 ) {
             KNotifyClient::beep();
             return;
         }
         int day = date.day();
         if ( day > 27 )
             while ( !QDate::isValid( date.year(), date.month()+1, day ) )
                 day--;
         setDate(QDate(date.year(), date.month()+1, day));
         return;
     }
     */
     int dayoff = KGlobal::locale()->weekStartsMonday() ? 1 : 0;
 
     int temp=firstday+date.day()-dayoff;
     int pos = temp;
     bool irgnore = true;
     if ( e->state() != Qt::ControlButton ) {
     if ( e->key() == Qt::Key_Up ) {
         pos -= 7;
         irgnore = false;
     }
     if ( e->key() == Qt::Key_Down ) {
         pos += 7;
         irgnore = false;
     }
     if ( e->key() == Qt::Key_Left ) {
         pos--;
         irgnore = false;
     }
     if ( e->key() == Qt::Key_Right ) {
         pos++;
         irgnore = false;
     }
     } 
     if ( irgnore )
         e->ignore();
 
     if(pos+dayoff<=firstday)
     { // this day is in the previous month
         KNotifyClient::beep();
         return;
     }
     if(firstday+numdays<pos+dayoff)
     { // this date is in the next month
         KNotifyClient::beep(i18n( "Month not long enough" ));
         return;
     }
 
     if ( pos == temp )
         return;
 
     setDate(QDate(date.year(), date.month(), pos-firstday+dayoff));
     updateCell(temp/7+1, temp%7); // Update the previously selected cell
     updateCell(pos/7+1, pos%7); // Update the selected cell
     assert(QDate(date.year(), date.month(), pos-firstday+dayoff).isValid());
   
 
 }
 
 void
 KDateTable::viewportResizeEvent(QResizeEvent * e)
 {
   QGridView::viewportResizeEvent(e);
 
   setCellWidth(viewport()->width()/7);
   setCellHeight(viewport()->height()/7);
 }
 
 void
 KDateTable::setFontSize(int size)
 {
   int count;
   QRect rect;
   // ----- store rectangles:
   fontsize=size;
   QFont font = KGlobalSettings::generalFont();
   font.setPointSize(fontsize);
   font.setBold( true );
   QFontMetrics metrics(font);
 
   // ----- find largest day name:
   maxCell.setWidth(0);
   maxCell.setHeight(0);
   for(count=0; count<7; ++count)
     {
       rect=metrics.boundingRect(KGlobal::locale()->weekDayName(count+1, true));
       maxCell.setWidth(QMAX(maxCell.width(), rect.width()));
       maxCell.setHeight(QMAX(maxCell.height(), rect.height()));
     }
   // ----- compare with a real wide number and add some space:
   rect=metrics.boundingRect(QString::fromLatin1("88"));
   maxCell.setWidth(QMAX(maxCell.width()+2, rect.width()));
   maxCell.setHeight(QMAX(maxCell.height()+4, rect.height()));
   if ( maxCell.width() * 1000 / maxCell.height()  > 1900 )
       maxCell.setHeight(maxCell.width() * 1000 / 1900 );
 }
 
 void
 KDateTable::contentsMousePressEvent(QMouseEvent *e)
 {
   if(e->type()!=QEvent::MouseButtonPress)
     { // the KDatePicker only reacts on mouse press events:
       return;
     }
   if(!isEnabled())
     {
       KNotifyClient::beep();
       return;
     }
 
   int dayoff = KGlobal::locale()->weekStartsMonday() ? 1 : 0;
   // -----
   int row, col, pos, temp;
   QPoint mouseCoord;
   // -----
   mouseCoord = e->pos();
   row=rowAt(mouseCoord.y());
   col=columnAt(mouseCoord.x());
   if(row<0 || col<0)
     { // the user clicked on the frame of the table
       return;
     }
   pos=7*(row-1)+col+1;
+#if 0
   if(pos+dayoff<=firstday)
     { // this day is in the previous month
       KNotifyClient::beep();
       return;
     }
   if(firstday+numdays<pos+dayoff)
     { // this date is in the next month
       KNotifyClient::beep();
       return;
     }
+#endif
   temp=firstday+date.day()-dayoff-1;
-  setDate(QDate(date.year(), date.month(), pos-firstday+dayoff));
+  QDate da = QDate(date.year(), date.month(),1);
+  setDate(da.addDays( pos-firstday+dayoff-1));
   updateCell(temp/7+1, temp%7); // Update the previously selected cell
   updateCell(row, col); // Update the selected cell
   // assert(QDate(date.year(), date.month(), pos-firstday+dayoff).isValid());
   emit(tableClicked());
 }
 
 bool
 KDateTable::setDate(const QDate& date_)
 {
   bool changed=false;
   QDate temp;
   mMarkCurrent = false;
   // -----
   if(!date_.isValid())
     {
       kdDebug() << "KDateTable::setDate: refusing to set invalid date." << endl;
       return false;
     }
   if(date!=date_)
     {
       date=date_;
       changed=true;
     }
   mMarkCurrent = ( date.month() ==  QDate::currentDate().month() && date.year() ==  QDate::currentDate().year() );
   temp.setYMD(date.year(), date.month(), 1);
   firstday=temp.dayOfWeek();
   if(firstday==1) firstday=8;
   numdays=date.daysInMonth();
   if(date.month()==1)
     { // set to december of previous year
       temp.setYMD(date.year()-1, 12, 1);
     } else { // set to previous month
       temp.setYMD(date.year(), date.month()-1, 1);
     }
   numDaysPrevMonth=temp.daysInMonth();
   if(changed)
     {
       repaintContents(false);
     }
   emit(dateChanged(date));
   return true;
 }
 
 const QDate&
 KDateTable::getDate() const
 {
   return date;
 }
 
 void KDateTable::focusInEvent( QFocusEvent *e )
 {
     repaintContents(false);
     QGridView::focusInEvent( e );
 }
 
 void KDateTable::focusOutEvent( QFocusEvent *e )
 {
     repaintContents(false);
     QGridView::focusOutEvent( e );
 }
 
 QSize
 KDateTable::sizeHint() const
 {
   if(maxCell.height()>0 && maxCell.width()>0)
     {
       return QSize((maxCell.width()+2)*numCols()+2*frameWidth(),
              (maxCell.height()+4)*numRows()+2*frameWidth());
     } else {
       return QSize(-1, -1);
     }
 }
 
 KDateInternalMonthPicker::KDateInternalMonthPicker
 (int fontsize, QWidget* parent, const char* name)
   : QGridView(parent, name),
     result(0) // invalid
 {
   QRect rect;
   QFont font;
   // -----
   activeCol = -1;
   activeRow = -1;
   font=KGlobalSettings::generalFont();
   font.setPointSize(fontsize);
   setFont(font);
   setHScrollBarMode(AlwaysOff);
   setVScrollBarMode(AlwaysOff);
   setFrameStyle(QFrame::NoFrame);
   setNumRows(4);
   setNumCols(3);
   // enable to find drawing failures:
   // setTableFlags(Tbl_clipCellPainting);
 #if 0
   viewport()->setEraseColor(lightGray); // for consistency with the datepicker
 #endif
   // ----- find the preferred size
   //       (this is slow, possibly, but unfortunatly it is needed here):
   QFontMetrics metrics(font);
   for(int i=1; i <= 12; ++i)
     {
       rect=metrics.boundingRect(KGlobal::locale()->monthName(i, false));
       if(max.width()<rect.width()) max.setWidth(rect.width());
       if(max.height()<rect.height()) max.setHeight(rect.height());
     }
 
 }
 
 QSize
 KDateInternalMonthPicker::sizeHint() const
 {
   return QSize((max.width()+6)*numCols()+2*frameWidth(),
          (max.height()+6)*numRows()+2*frameWidth());
 }
 
 int
 KDateInternalMonthPicker::getResult() const
 {
   return result;
 }
 
 void
 KDateInternalMonthPicker::setupPainter(QPainter *p)
 {
   p->setPen(black);
 }
 
 void
 KDateInternalMonthPicker::viewportResizeEvent(QResizeEvent*)
 {
   setCellWidth(width()/3);
   setCellHeight(height()/4);
 }
 
 void
 KDateInternalMonthPicker::paintCell(QPainter* painter, int row, int col)
 {
   int index;
   QString text;
   // ----- find the number of the cell:
   index=3*row+col+1;
   text=KGlobal::locale()->monthName(index, false);
   painter->drawText(0, 0, cellWidth(), cellHeight(), AlignCenter, text);
   if ( activeCol == col && activeRow == row )
       painter->drawRect( 0, 0, cellWidth(), cellHeight() );
 }
 
 void
 KDateInternalMonthPicker::contentsMousePressEvent(QMouseEvent *e)
 {
   if(!isEnabled() || e->button() != LeftButton)
     {
       KNotifyClient::beep();
       return;
     }
   // -----
   int row, col;
   QPoint mouseCoord;
   // -----
   mouseCoord = e->pos();
   row=rowAt(mouseCoord.y());
   col=columnAt(mouseCoord.x());
 
   if(row<0 || col<0)
     { // the user clicked on the frame of the table
       activeCol = -1;
       activeRow = -1;
     } else {
       activeCol = col;
       activeRow = row;
       updateCell( row, col /*, false */ );
   }
 }
 
 void
 KDateInternalMonthPicker::contentsMouseMoveEvent(QMouseEvent *e)
 {
   if (e->state() & LeftButton)
     {
       int row, col;
       QPoint mouseCoord;
       // -----
       mouseCoord = e->pos();
       row=rowAt(mouseCoord.y());
       col=columnAt(mouseCoord.x());
       int tmpRow = -1, tmpCol = -1;
       if(row<0 || col<0)
         { // the user clicked on the frame of the table
           if ( activeCol > -1 )
             {
               tmpRow = activeRow;
               tmpCol = activeCol;