fixed layout problem

3 files changed, 31 insertions, 2 deletions

diff --git a/bin/kdepim/WhatsNew.txt b/bin/kdepim/WhatsNew.txt
index 05c1afd..28029ee 100644
--- a/bin/kdepim/WhatsNew.txt
+++ b/bin/kdepim/WhatsNew.txt
@@ -1,773 +1,774 @@
 Info about the changes in new versions of KDE-Pim/Pi
 
 ********** VERSION 2.0.12 ************
 
 Fixed a bug in todo start/due date handling for non recurring todos with a start and due date.
+Fixed some layout problems in the KO/Pi agenda view when there were many conflicting itmes. 
 
 
 ********** VERSION 2.0.11 ************
 
 Fixed some problems in pi-sync mode
 (e.g. details of events were not synced properly)
 
 ********** VERSION 2.0.10 ************
 
 KO/Pi:
 In the desktop versions the context menu in the search dialog was broken after introducing the What'sThis info for the list view.
 This is fixed.
 Changed the search dialog a bit to make it more user friendly.
 (E.g.: Removed message box about "no items found" and set key focus to search line edit after search).
 
 Added config option to hide the week number in KO/Pi toolbar.
 
 ********** VERSION 2.0.9 ************
 
 Made month view icons for multiday events a bit nicer.
 Some minor fixes in KO/Pi
 (e.g. go to today did not work for new week view properly).
 
 
 ********** VERSION 2.0.8 ************
 
 Fixed a problem in dependency info in the ipk files for the Zaurus.
 
 Added icon for the stealth new week view and made navigation more user friendly in monthview by adding a prev/next week button to the navigator bar.
 
 Added a "go today" button to the datepicker.
 
 Added "created" and "last modified" to event/todo viewer (and What'sThis viewer)
 and made it configureable to show these values.
 
 Fixed a problem for events (from external iCal files) that do have a duration but no end date.
 
 
 ********** VERSION 2.0.7 ************
 
 Added global application font settings 
 (for all KDE-Pim/Pi apps) to the general settings.
 
 Fixed a problem in OM/Pi when trying to login to some IMAP servers
 (like the IMAP server of Apple: mail.mac.com )
 
 Added recurring todos to KO/Pi.
 
 
 ********** VERSION 2.0.6 ************
 
 Some bugfixes in the pi-sync mode.
 Added German translation for pi-sync mode.
 
 KO/Pi:
 Made the todolist using alternate background.
 
 Other minor fixes in KO/Pi.
 
 
 ********** VERSION 2.0.5 ************
 
 Bugfixes in KO/Pi.
 
 ********** VERSION 2.0.4 ************
 
 KO/Pi:
 Fixed problem loading translations for summary/location edit boxes in event/todo editor.
 
 Added a general "select week number" to the toolbar.
 
 Fixed some small problem of the new features introduced in version 2.0.3.
 
 Made it possible to specify one specific category as category color,
 if more than one categories are selected.
 
 Fixed a bug in saving colors for categories with non-ascii characters.
 (Like, e.g. German Umlauts).
 Propably you have to set your colors again for those categories. 
 
 
 ********** VERSION 2.0.3 ************
 
 KO/Pi:
 Added feature for changing alarm settings for many items at once:
 Open list view (or search dialog), select the desired items and choose in
 the popup menu: Set alarm for selected...
 
 Added to the event/todo viewer the option to send an email to 
 all attendees or all selected (with RSVP) attendees. 
 
 Made the week-month mode changing in month view faster.
 
 Made month view better useable with keyboard.
 Now TAB key jumps to next cell with an event/todo.
 Scroll in cell with coursor keys, scroll in time (next week) with
 Shift/Control + coursorkeys.
 
 Fixed bug that the todo view flat mode was reset after first view update.
 
 If a todo is displayed closed in the todo view, 
 it is now displayed in overdue/due today color depending on the subtodos overdue/due today properties.
 
 Added info about the numbers of years to the caption (title) information about a birthday event.
 
 Made completion date in todo editor editable.
 
 Added possibility to save/load templates for journals.
 (Which is just a simple "save text to file" or "insert text from file".
 
 ********** VERSION 2.0.2 ************
 
 KO/Pi:
 Fixed the layout problem of the day label buttons 
 of the agenda view introduced in version 2.0.1.
 
 Added WhatsThis support for the todo view and the list view.
 
 Added a quite useful feature to the montview.
 Just click on the week numbers on the left.
 And in the top right corner of month view/agenda view 
 there is now a "week number quick selector".
 (Click on the black triangle).
 
 Made the quite difficult timezone change in KO/Pi easy.
 
 OM/Pi:
 Fixed too small icons on desktop.
 Fixed non visible icons in mainwindow on Z with fastload enabled.
 Added signature file setting to smtp account config.
 And the signature can be edited and saved in the edit mail dialog.
 That does mean:
 Simply edit the signature for the selected smtp account in the
 edit new mail dialog and press the "save signature" button there.
 Then the signature is saved to the file specified in the smtp account settings.
 If there is no file specified, it is saved automatically to the file
 kdepim/apps/kopiemail/<accountname>.sig.
 
 
 
 ********** VERSION 2.0.1 ************
 
 Oooops ... I forgot to test on the Zaurus 5500 ...
 
 Fixed many problems of new (english) strings (and german translations)
 introduced in the latest versions, where the text was not fitting on the 
 240x320 display of the Zaurus 5500.
 
 KO/Pi:
 Added a popup menu ( press pen and hold to get popup ) to the agenda view
 with many useful items (add event/todo, show next week, two weeks, month, journal).
 
 Added items to the todolist popup menu for:
 Display all opened, all closed or all todos flat.
 The "flat" view makes is possible to sort all todos after ,e.g., prio or date.
 Made the reparenting of todos on the desktop possible via Drag&Drop.
 Fixed several bugs in setting the completed datetime for todos.
 Added info about completed datetime of todos to the todo viewer.
 Now displaying a completed todo (with completed datetime set) in the agenda view
 at the time of the completion. Such that now it is possible to see in the agenda view
 when what todo was completed.
 Fixed behaviour of automatic setting completion of todos with sub-todos/parent todos.
 Now the behaviour is:
 Setting a parent to complete  sets all (sub)childs to complete. 
 Setting a parent to uncomplete does not change the childs.
 Setting a child to uncomplete sets all parent to uncomplete.
 Setting a child to complete does not change the parents.
 
 Smart updating and double buffering of the daymatrix.
 Showing holidays in the day matrix.
 Many other small performance updates.
 
 Made day labels in agenda clickable. By clicking a label, the day is displayed in single day mode.
 
 Now the translation file usertranslation.txt is supposed to be in utf8 format.
 If you want to translate a language from western europe, just change the germantranslation.txt file. Please read the updated Usertranslation HowTo in KO/Pi Help menu.
 
 
 ********** VERSION 2.0.0 ************
 
 Stable release 2.0.0!
 
 KO/Pi:
 Fixed problem in edit dialog recreation at startup.
 Made "toggle view*" menu items enabled context sensitive.
 Changed agenda size menu to items 1-10.
 Made it possible to change agenda size quickly by pressing mouse on timelabels in agenda view and move mouse up/down.
 Usebility enhancements in the KO/Pi menus.
 Birthday import now adds year to summary.
 What's Next view shows age in years for birthday.
 
 OM/Pi:
 Added three info lines to display subject, from and to of selected mails.
 
 KA/Pi:
 Fixed jump bar behaviour on Zaurus.
 Now KA/Pi search field supports searching for a range of starting characters.
 E.g. to search for all contact beginning with b to n, type 
 b-n
 in the search field.
 
 ********** VERSION 1.9.20 ************
 
 KO/Pi:
 Added for the "dislplay one day" agenda mode 
 info in the caption and in the day lables:
 Now it is displayed, if the selected day is from "day before yesterday"
 to "day after tomorrow".
 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.
 
 OM/Pi:
 "Delete mail" icon in main window now deletes all selected mails.
 Fixed the problem, that the state flag of imap mails was ignored.
 Now mails with "FLAG_SEEN" on the imap server get no icon in the list view
 to indecate that they are already seen.
 Fixed the problem that the body of some mails was not displayed in the
 mail viewer when fetching them from the imap server directly to read them.
 Made it (configurable) possible  to show the "To:" field in the list view.
 Added to the mail viewer the option "View Source" to make it possible to see the raw mail data.
 Added a "Download Mail" button to the mail viewer to quickly download the viewed mail to the
 local storage folder (specified in account settings) of the account of the mail.
 Removed some memory leaks in OM/Pi.
 
 
 ********** 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
 sr-character-conversion_SharpROM_arm.ipk.zip
 (or oz-character-conversion_OZ-gcc3xx_arm.ipk.zip for OZ roms)
 from the section "general files for KDE/Pim"
 Instructions how to install this package are in a ReadMe in this file.
 
 
 Fixed the orientation change problem in KA/Pi when switching
 portrait/landscape mode.
 
 French translation available for KA/Pi and OM/Pi.
 
 Fixed some problems with categories in KO/Pi in DTM sync.
 
 Added selection dialog for export to phone in KA/Pi.
 
 If in KO/Pi is an attendee selected to add to a meeting and this
 attendee is already in the list of attendees, this person is not added
 again.
 
 Some menu cleanup in KA/Pi.
 
 ********** VERSION 1.9.12 ************
 
 Fix for the bug in KO/Pi What's Next view of version 1.9.11.
 
 Bugfix: Licence file is now shown again.
 
 OM/Pi now supports Unicode (utf8 charset).
 Fixed some bugs in OM/Pi.
 
 KA/Pi has more German translation.
 
 
 ********** VERSION 1.9.11 ************
 
 Fixed several problems in PWM/Pi, like
 asking the user, if unsaved changed are pending
 when closing the app.
 And PwM/Pi handles now different texts for the
 fields Description, Username, Password, configurable per category.
 
 Fixed a crash in KO/Pi , when importing/loading vcs files
 which have an entry with an attendee with state:
 NEEDS ACTION
 
 Fixed some problems in the German translation of OM/Pi,
 which makes some dialogs not fitting on the screen
 of the Z 5500.
 
 Fixed Qtopia crash, when disabling/deinstalling
 KO/Pi alarm applet.
 
 Implemented direct KDE<->KA/Pi sync for KA/Pi running 
 on Linux desktop.
 
 Added feature "remove sync info" to sync menu.
 
 Tweaked the KO/Pi What's next view a bit, added
 setting to hide events that are done.
 
 Disabled "beam receive enabled" on startup to 
 avoid problems if Fastload is enabled.
 Please set "beam receive enabled",
 if you want to receive data via IR.
 
 Fixed bug in  direct KDE<->KO/Pi sync for KO/Pi running 
 on Linux desktop.
 
 Made in KA/Pi scrolling possible, if details view is selected.
 (The keyboard focus is set automatically to the search line)
 
 Fixed a bug in DMT sync, that a new entry in DTM was added 
 on every sync to Kx/Pi.
 
 Fixed missing writing of KA/Pi categories to DMT entries when syncing.
 
 Fixed a bug in DMT sync with todos created in KO/Pi containing
 non-latin1 characters.
 
 Rearranged package contents of Sharp-ipks and made all
 packages installable on SD again.
 
 Fixed the writing of addressbook data in DTM sync.
 Empty fields in KA/Pi were not removed. 
 
 Added better category handling in KA/Pi:
 Added item 
 Edit Categories and
 Manage new categories
 to the settings menu.
 Possible to configure a view to display categories.
 
 Added detailed "KDE Sync Howto" and "Multi Sync Howto" to Help menu.
 
 Fixed displaying of "free" days and time in KO Monthview and Agendaview.
 
 ... and many other bugfixes.
 
 ********** VERSION 1.9.10 ************
 
 Many internal small bugfixes.
 And fix of the "big" bug in KO/Pi, 
 that after Syncing the appointments had an offset by several hours.
 That was a problem with the internal timezone setting,
 introduced by the changed timezone configuration settings.
 
 German translation for OM/Pi is now available.
 
 
 ********** VERSION 1.9.9 ************
 
 KDE-Pim/Pi has a new Member!
 It is called PWM/Pi (Passwordmanager/platform-independent) 
 and it is available for the Zaurus.
 It is planned, that it will be available later for Windows.
 (And for Linux, of course).
 It is a port of the Passwordmanager of KDE.
 It will need the MicroKDElibs to run.
 
 Made loading of addressbooks in KA/Pi up to 7 times faster!
 The bigger your addressbook file, the more starting speed 
 will you gain. (relatively)
 
 The Qtopia addressbook connector is now platform independend
 as well and should work on any platform for importing/exporting
 Qtopia and Opie XML files.
 
 Added a +30min feature to the timezone settings to make 
 KDE-Pim/Pi useable in Australia and other parts on the 
 world with strange timezones ;-)
 
 German "Umlaute" should now be sorted correctly on the Z in KA/Pi.
 
 It is now possible to disable the
 "receive data via infrared" feature, such that syncing with
 Outlook is now possible again with Kx/Pi runing.
 Please disable it, before syncing Sharp DTM with Outlook.
 For your convenience, the "receive data via infrared" feature
 is disabled automatically, if you sync Kx/Pi with DTM.
 You have to enable it again manually after syncing.
 Enabling this feature makes it impossible to start the
 Sharp DTM apps. If this feature is enabled, you will only get the 
 alarm notification from KO/Pi and not from the Sharp calendar.
 This is very useful if you sync KO/Pi with Sharp DTM,
 because after syncing you usually would get notified about
 an alarm by KO/Pi and the Sharp Calendar.
 
 Together with the Linux desktop version of KO/Pi
 it is now possible to sync KO/Pi on the Zaurus
 with the complete KDE-desktop (3.3 or later)
 calendar data easily.
 That makes it possible to sync the Z with one 
 click of a mouse with the KDE-Desktop.
 This feature it available for all Zaurus platforms KO/Pi
 is running on.
 The only thing needed is a running KO/Pi on Linux and
 a compiled version of the small 
 KDE-Pim/Pi<->KDE-Desktop access command line program, 
 which is in the KDE-Pim/Pi sources available.
 
 The "KDE-desktop" syncing feature for KA/Pi will follow
 in the next releases.
 
 Fixed the vcard export bug, which had the version 1.9.8.
 
 Added missing GERMAN translation to KO/Pi.
 Hi PsionX, could you add the missing french translation?Thx!
 
 Translation files for KA/Pi are available as well.
 GERMAN translation will be available in the next release.
 PsionX ( yres, you again ;-) ), could you start translating
 KA/Pi? Thx!
 
 You can download the version 1.9.9 at
 
 http://sourceforge.net/project/showfiles.php?group_id=104103&package_id=112604
 
 Note:
 To run the mail program OM/Pi you need libopenssl.
 A link to a download loaction is available at
 ZSI at www.killefiz.de
 
 
 ********** VERSION 1.9.8 ************
 
 Fixed character decoding in OM/Pi.
 (e.g. German "Umlaute" were not displayed properly.)
 
 Made is possible to reparent todos in KO/Pi.
 Use contextmenu or keys (look at Help-Keys + Colors) for that.
 
 Added the missing Sync-Howto and WhatsNew to the packages.
 
 KO/Pi on Linux desktop can now sync with KDE desktop.
 That means: When using KO/Pi on Linux desktop for syncing with
 KDE desktop and the Zaurus, the Zaurus can be synced now
 with all KDE-Calendar resources, not only with one local file.
 (That makes it possible to sync the Zaurus with the 
 calendar data on a Kolab server) 
 
 KA/Pi syncing with KDE desktop will be available in the next version.
 
 
 ********** VERSION 1.9.7 ************
 
 KO/Pi - KA/Pi on Windows:
 Now a directory can be defined by the user, where the 
 application/config data should be saved.
   Define your desired path in the evironment variable
   MICROKDEHOME
   before starting KO/Pi or KA/Pi.
 
 An easy Kx/Pi to Kx/Pi syncing is now possible 
 (it is called Pi-Sync) via network.
 Please look at the Sync Howto.
 
 Exporting of calendar data and contacts to mobile phones is now possible.
 The SyncHowto is updated with information howto
 access/sync mobile phones. 
 Please look at the Sync Howto.
 
 Now KO/Pi and KA/Pi on the Zaurus can receive data via infrared directly.
 Please disable Fastload for the original contact/calendar applications
 and close them.
 KO/Pi and KA/Pi must be running in order to receive the data.
 (KO/Pi and KA/Pi are always running if Fastload for them is enabled!)
 
 In the KA/Pi details view are now the preferred tel. numbers displayed on top 
 of the other data ( emails/tel.numbers/addresses)
 
 Fixed some syncing problems in KA/Pi.
 
 Added font settings for the KA/Pi details view.
 Added fields "children's name" and "gender" to KA/Pi.
 
 Made searching in KA/Pi better:
 Now the first item in a view is selected after a search automatically and
 the views can be scrolled up/down when the search input field has the keyboard focus.
 
 And, of course, fixed a bunch of reported bugs in KO/Pi and KA/Pi.
 
 
 ********** VERSION 1.9.6 ************
 
 Changes in the external application communication on the Zaurus 
 in order to use less RAM when the apps are running.
 First syncing of addressbooks (KA/Pi) is possible.
 
 
 ********** VERSION 1.9.5a ************
 
 Fixed a bug in KO/Pi in the SharpDTM sync of version 1.9.5.
 Fixed some small bugs.
 KA/Pi shows now the birthday in summary view.
 Now OM/Pi and KA/Pi are using the date format defined in KO/Pi
 for displaying dates.
 
 
 ********** VERSION 1.9.5 ************
 
 There is still no Addressbook syncing!
 
 New in 1.9.5:
 
 Many bugfixes.
 Better searching in KA/Pi.
 You can configure in KA/Pi if you want to search only after 
 <return> key pressed.
 
 Better mail downloading in OM/Pi.
 
 First experimental alpha version of sync of KO/Pi with mobile phones.
 See gammu documentation for supported phones.
 You need to install the package kammu_1.9.5_arm.ipk for sync of KO/Pi with mobile phones. kammu_1.9.5_arm.ipk needs libbluetooth and libsdp.
 Quick hint how to use:
 NOTE: MOBILE PHONE SYNC IS EXPERIMENTAL!
 Install kammu_1.9.5_arm.ipk , libbluetooth and libsdp.
 Create syncprofile - mobile device
 Remove entry for model. (Leave empty ).
 Enable infrared on Zaurus and your Phone.
 Sync.
 To get a more detailed log, start kopi from konsole.
 
 ********** VERSION 1.9.4 ************
 
 This is the version 1.9.4 of KDE-Pim/Pi for the Zaurus.
 
 WARNING:
 PLEASE BACKUP ALL YOUR DATA!
 We have changed a lot and maybe there are some unknown problems.
 
 SYNC HANDLING HAS CHANGED!
 Such that, if you sync now with an already synded device, you will duplicated entries after the first sync.
 (This change was introduced to make it possible to sync with mobile phones, which will be available later (maybe in 4 weeks).
 
 You need the kmicrokdelibs_1.9.4_arm.ipk as a base for the other programs.
 If you get the error: "Install only possible in main memory", just try it again to install it on SD card. That worked for me. And it was reported that rebooting Qtopia did help in this case as well. 
 
 As programs are available:
 KO/Pi (korganizer ipk) - a calendar program.
 KA/Pi (kaddressbook ipk ) - an addressbook
 OM/Pi (kopiemail ipk ) an email program with pop/smtp and IMAP support.
 
 An alarm notification program ( korganizer-alarm ipk ) for KO/Pi that notifies you about alarms, even if the Zaurus is in suspend mode.
 (If you do not see an icon in the taskbar after installing korganizer-alarm, please restart Qtopia)
 
 All the applications are installed in a "Pim" TAB.
 If this TAB is new on your system, you can get an icon in this TAB by installing pim_TAB_icon_1.9.4_arm.ipk
 
 All the application are integrated.
 Such that you can choose in KO/Pi the attendees of a  meeting from the addresses in KA/Pi. When you click in KA/Pi on the email address, OM/Pi is started to write the mail.
 
 HINT:
 If you install KPhone/Pi 0.9.7, it will be called, if you click in KA/Pi on a phone number.
 
 What's new?
 
 SYNC HANDLING HAS CHANGED!
 Such that, if you sync now with an already synded device, you will duplicated entries after the first sync.
 (This change was introduced to make it possible to sync with mobile phones, which will be available later (maybe in 4 weeks).
 
 New in OM/Pi:
 When copying(i.e. downloading mails) , you can specify, that only mails of a given size should be downloaded. Added mail copy possibility for selected mails.
 
 New in KO/Pi:
 French is now available for KO/Pi.
 Choose menu:Actions - Configure:TAB locale
 Syncing has changed.
 Phone sync available soon.
 Not much changes, I cannot remember them ...
 
 New in KA/Pi:
 Beaming possible.
 Sharp DTM readonly access possible( create a new DTM resource );
 Better searching possible.
 Search is performed only after pressing the return key.
 Use wildcard * to specify parts of a name.
 
 Better name/email selection dialog (called from KO/Pi or OM/Pi). In this dialog, now searching is possible. Like in KA/Pi, use return key and wildcard * .
 
 A big improvement is the new management of the contact access.
 In version 1.9.3, every application was using their own addressbook access data.
 That means, the addressbook was loaded up to three times in the memory, when accessed by  KA/Pi, KO/Pi and OM/Pi.
 That was wasting of memory, if you had several hundreds of contacts.
 
 Now only KA/Pi accesses the addressbook.
diff --git a/korganizer/koagenda.cpp b/korganizer/koagenda.cpp
index a72e470..195b1fa 100644
--- a/korganizer/koagenda.cpp
+++ b/korganizer/koagenda.cpp
@@ -314,1557 +314,1584 @@ void KOAgenda::init()
   }
 }
 
 void KOAgenda::clear()
 {
   KOAgendaItem *item;
   for ( item=mItems.first(); item != 0; item=mItems.next() ) {
     mUnusedItems.append( item );
     //item->hide();
   }
   mItems.clear();
   mSelectedItem = 0;
   clearSelection();
 }
 
 void KOAgenda::clearSelection()
 {
   mSelectionCellX = 0;
   mSelectionYTop = 0;
   mSelectionHeight = 0;
 }
 
 void KOAgenda::marcus_bains()
 {
     if(mMarcusBains) mMarcusBains->updateLocation(true);
 }
 
 
 void KOAgenda::changeColumns(int columns)
 {
   if (columns == 0) {
     kdDebug() << "KOAgenda::changeColumns() called with argument 0" << endl;
     return;
   }
 
   clear();
   
   mColumns = columns;
 //  setMinimumSize(mColumns * 10, mGridSpacingY + 1);
 //  init();
 //  update();
   //qDebug("KOAgenda::changeColumns ");
     computeSizes();
     // QResizeEvent event( size(), size() );
 
     //QApplication::sendEvent( this, &event );
 }
 
 /*
   This is the eventFilter function, which gets all events from the KOAgendaItems
   contained in the agenda. It has to handle moving and resizing for all items.
 */
 bool KOAgenda::eventFilter ( QObject *object, QEvent *event )
 {
 //  kdDebug() << "KOAgenda::eventFilter" << endl;
   switch(event->type()) {
     case QEvent::MouseButtonPress:
     case QEvent::MouseButtonDblClick:
     case QEvent::MouseButtonRelease:
     case QEvent::MouseMove:
       return eventFilter_mouse(object, static_cast<QMouseEvent *>(event));
 
     case (QEvent::Leave):
       if (!mActionItem)
         setCursor(arrowCursor);
       return true;
 
     default:
       return QScrollView::eventFilter(object,event);
   }
 }
 
 
 bool KOAgenda::eventFilter_mouse(QObject *object, QMouseEvent *me)
 {
     //qDebug("KOAgenda::eventFilter_mous ");
     QPoint viewportPos;
     if (object != viewport()) {
         viewportPos = ((QWidget *)object)->mapToParent(me->pos());
     } else {
         viewportPos = me->pos();
     }
     static int startX = 0;
     static int startY = 0;
     static bool block = true;
     switch (me->type())  {
     case QEvent::MouseButtonPress:
         //qDebug("QEvent::MouseButtonPress: ");
         //        kdDebug() << "koagenda: filtered button press" << endl;
         if (object != viewport()) {
             if (me->button() == RightButton) {
                 mClickedItem = (KOAgendaItem *)object;
                 if (mClickedItem) {
                     selectItem(mClickedItem);
                     // emit showIncidencePopupSignal(mClickedItem->incidence());
                 }
                 //mItemPopup->popup(QCursor::pos());
             } else {
                 mActionItem = (KOAgendaItem *)object;
                 if (mActionItem) {
                     if ( mSelectionHeight > 0 ) { 
                         int selectionCellX = mSelectionCellX * mGridSpacingX;
                         int selectionYTop = mSelectionYTop;
                         int gridSpacingX = mGridSpacingX;
                         int selectionHeight = mSelectionHeight;
                         clearSelection();
                         repaintContents( selectionCellX, selectionYTop,
                                          gridSpacingX, selectionHeight,false );
                     }
                     selectItem(mActionItem);
                     Incidence *incidence = mActionItem->incidence();
                     if ( incidence->isReadOnly() /*|| incidence->recurrence()->doesRecur() */) {
                         mActionItem = 0;
                     } else {
                         startItemAction(viewportPos);
                         startX = viewportPos.x();
                         startY = viewportPos.y(); 
                         block = true;
                     }
                 }
             }
         } else {
             selectItem(0);
             mActionItem = 0;
             if (me->button() == RightButton ) {
                 blockNewEvent = true;
                 block = false;
             } else {
                 blockNewEvent = false;
                 setCursor(arrowCursor);
                 startSelectAction(viewportPos);
             }
         }
         break;
 
     case QEvent::MouseButtonRelease:
         //qDebug("QEvent::MouseButtonRelease: %d",blockNewEvent );
         if (me->button() == RightButton && blockNewEvent && !block) {
             int x,y;
             viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
             int gx,gy;
             contentsToGrid(x,y,gx,gy);
             if ( object == viewport() ) {
                 if (  mCurrentCellY < mStartCellY +1 ) {
                     //qDebug("mCurrentCellY %d mStartCellY %d ", mCurrentCellY,mStartCellY);
                     mCurrentCellX = gx;
                     mCurrentCellY = gy;
                     mStartCellX = gx;
                     mStartCellY = gy;
                     mNewItemPopup->popup( viewport()->mapToGlobal( me->pos() ) );
                     break;
                 } else {
                     blockNewEvent = false;
                 }
             } else {
                 mClickedItem = (KOAgendaItem *)object;
                 if (mActionItem ) {
                     endItemAction();
                 }
                 if (mClickedItem) {
                     selectItem(mClickedItem);
                     emit showIncidencePopupSignal(mClickedItem->incidence());
                 } 
             }
         } else if (me->button() == RightButton && block ) {
             if (object != viewport()) {
                 mClickedItem = (KOAgendaItem *)object;
                 if (mActionItem ) {
                     endItemAction();
                 }
                 if (mClickedItem) {
                     selectItem(mClickedItem);
                     emit showIncidencePopupSignal(mClickedItem->incidence());
                 } 
             } 
             break;
         }
         block = true;
         if (mActionItem) {  
             QPoint clipperPos = clipper()->mapFromGlobal(viewport()->mapToGlobal(viewportPos));
             //qDebug(" %d %d %d  ",clipperPos.y(),visibleHeight() , 9  );
             if ( mActionType == MOVE && (clipperPos.y() > visibleHeight()-2 ||clipperPos.y() < 0 ) ) {
                 mScrollUpTimer.stop();
                 mScrollDownTimer.stop();
                 mActionItem->resetMove();
                 placeSubCells( mActionItem );
                 // emit startDragSignal( mActionItem->incidence() );
                 setCursor( arrowCursor );
                 mActionItem = 0;
                 mActionType = NOP;
                 mItemMoved = 0;
                 return true;
             }
             endItemAction();
         } else   if ( mActionType == SELECT ) {
             if (me->button() == RightButton ) {
             } else {
                 endSelectAction( !blockNewEvent   );
             }
         }
         break;
 
     case QEvent::MouseMove:
         if (object != viewport()) {
             KOAgendaItem *moveItem = (KOAgendaItem *)object;
             //qDebug("moveItem %d ",moveItem );
             if (!moveItem->incidence()->isReadOnly() /*&&
                                                        !moveItem->incidence()->recurrence()->doesRecur()*/ )
                 if (!mActionItem)
                     setNoActionCursor(moveItem,viewportPos);
                 else {
                     if ( block ) {
                         int dX, dY; 
                         dX = startX - viewportPos.x();
                         if ( dX < 0   )
                             dX = -dX;
                         dY = viewportPos.y() - startY;
                         if ( dY < 0 )
                             dY = -dY;
                         int diff = 30;
                         if ( QApplication::desktop()->width() < 480 )
                             diff = 15;
                         // qDebug(" %d %d ",dX, dY );
                         if (  dX > diff  || dY > diff  ) {
                             block = false;
                         }
                     }
                     if ( !block )
                         performItemAction(viewportPos);
                 }
         } else {
             if ( mActionType == SELECT ) {
                 performSelectAction( viewportPos );
             }
         }
         break;
 
     case QEvent::MouseButtonDblClick:
         if (object == viewport()) {
             selectItem(0);
             int x,y;
             viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
             int gx,gy;
             contentsToGrid(x,y,gx,gy);
             emit newEventSignal(gx,gy);
         } else {
             KOAgendaItem *doubleClickedItem = (KOAgendaItem *)object;
             selectItem(doubleClickedItem);
             if ( KOPrefs::instance()->mEditOnDoubleClick )
                 emit editIncidenceSignal(doubleClickedItem->incidence());
             else
                 emit showIncidenceSignal(doubleClickedItem->incidence());
         }
         break;
 
     default:
         break;
     }
 
     return true;
 }
 
 void KOAgenda::newItem( int item )
 {
     if ( item == 1 ) { //new event
         newEventSignal(mStartCellX ,mStartCellY  );
     } else
         if ( item == 2 ) { //new event
             newTodoSignal(mStartCellX ,mStartCellY  );
         } else 
             {
                 QDate day = mSelectedDates[mStartCellX];
                 emit showDateView( item, day );
                 // 3Day view
                 // 4Week view
                 // 5Month view
                 // 6Journal view
             }
 }
 void KOAgenda::startSelectAction(QPoint viewportPos)
 {
     //emit newStartSelectSignal();
 
   mActionType = SELECT;
 
   int x,y;
   viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
   int gx,gy;
   contentsToGrid(x,y,gx,gy);
 
   mStartCellX = gx;
   mStartCellY = gy;
   mCurrentCellX = gx;
   mCurrentCellY = gy;
 
   // Store coordinates of old selection
   int selectionX = mSelectionCellX * mGridSpacingX;
   int selectionYTop = mSelectionYTop;
   int selectionHeight = mSelectionHeight;
 
   // Store new selection
   mSelectionCellX = gx;
   mSelectionYTop = gy * mGridSpacingY;
   mSelectionHeight = mGridSpacingY;
   
   // Clear old selection
   repaintContents( selectionX, selectionYTop,
                    mGridSpacingX, selectionHeight,false );
 
   // Paint new selection
   //  repaintContents( mSelectionCellX * mGridSpacingX, mSelectionYTop,
   //               mGridSpacingX, mSelectionHeight );
 }
 
 void KOAgenda::performSelectAction(QPoint viewportPos)
 {
   int x,y;
   viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
   int gx,gy;
   contentsToGrid(x,y,gx,gy);
 
   QPoint clipperPos = clipper()->
                       mapFromGlobal(viewport()->mapToGlobal(viewportPos));
   
   // Scroll if cursor was moved to upper or lower end of agenda.
   if (clipperPos.y() < mScrollBorderWidth) {
     mScrollUpTimer.start(mScrollDelay);
   } else if (visibleHeight() - clipperPos.y() <
              mScrollBorderWidth) {
     mScrollDownTimer.start(mScrollDelay);
   } else {
     mScrollUpTimer.stop();
     mScrollDownTimer.stop();
   }
 
   if ( gy > mCurrentCellY ) {
     mSelectionHeight = ( gy + 1 ) * mGridSpacingY - mSelectionYTop;
 
 #if 0
     // FIXME: Repaint only the newly selected region
     repaintContents( mSelectionCellX * mGridSpacingX,
                      mCurrentCellY + mGridSpacingY,
                      mGridSpacingX,
                      mSelectionHeight - ( gy - mCurrentCellY - 1 ) * mGridSpacingY );
 #else
     repaintContents( (KOGlobals::self()->reverseLayout() ?
                      mColumns - 1 - mSelectionCellX : mSelectionCellX) *
                      mGridSpacingX, mSelectionYTop,
                      mGridSpacingX, mSelectionHeight , false);
 #endif
 
     mCurrentCellY = gy;
   } else if ( gy < mCurrentCellY ) {
     if ( gy >= mStartCellY ) {
       int selectionHeight = mSelectionHeight;
       mSelectionHeight = ( gy + 1 ) * mGridSpacingY - mSelectionYTop;
 
       repaintContents( (KOGlobals::self()->reverseLayout() ?
                        mColumns - 1 - mSelectionCellX : mSelectionCellX) *
                        mGridSpacingX, mSelectionYTop,
                        mGridSpacingX, selectionHeight,false );
     
       mCurrentCellY = gy;
     } else {
     }
   }
 }
 
 void KOAgenda::endSelectAction( bool emitNewEvent )
 {
   mActionType = NOP;
   mScrollUpTimer.stop();
   mScrollDownTimer.stop();
   
   emit newTimeSpanSignal(mStartCellX,mStartCellY,mCurrentCellX,mCurrentCellY);
   if ( emitNewEvent && mStartCellY < mCurrentCellY )
       emit newEventSignal(mStartCellX,mStartCellY,mCurrentCellX,mCurrentCellY);
 }
 
 void KOAgenda::startItemAction(QPoint viewportPos)
 {
   int x,y;
   viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
   int gx,gy;
   contentsToGrid(x,y,gx,gy);
 
   mStartCellX = gx;
   mStartCellY = gy;
   mCurrentCellX = gx;
   mCurrentCellY = gy;
 
   if (mAllDayMode) {
     int gridDistanceX = (x - gx * mGridSpacingX);
     if (gridDistanceX < mResizeBorderWidth &&
         mActionItem->cellX() == mCurrentCellX) {
       mActionType = RESIZELEFT;
       setCursor(sizeHorCursor);
     } else if ((mGridSpacingX - gridDistanceX) < mResizeBorderWidth &&
                mActionItem->cellXWidth() == mCurrentCellX) {
       mActionType = RESIZERIGHT;
       setCursor(sizeHorCursor);
     } else {
       mActionType = MOVE;
       mActionItem->startMove();
       setCursor(sizeAllCursor);
     }
   } else {
     int gridDistanceY = (y - gy * mGridSpacingY);
     bool allowResize = ( mActionItem->incidence()->type() != "Todo" );
     if (allowResize && gridDistanceY < mResizeBorderWidth &&
         mActionItem->cellYTop() == mCurrentCellY &&
         !mActionItem->firstMultiItem()) {
       mActionType = RESIZETOP;
       setCursor(sizeVerCursor);
     } else if (allowResize &&(mGridSpacingY - gridDistanceY) < mResizeBorderWidth &&
                mActionItem->cellYBottom() == mCurrentCellY &&
                !mActionItem->lastMultiItem())  {
       mActionType = RESIZEBOTTOM;
       setCursor(sizeVerCursor);
     } else {
       mActionType = MOVE;
       mActionItem->startMove();
       setCursor(sizeAllCursor);
     }
   }
 }
 
 void KOAgenda::performItemAction(QPoint viewportPos)
 {
 //  kdDebug() << "viewportPos: " << viewportPos.x() << "," << viewportPos.y() << endl;
 //  QPoint point = viewport()->mapToGlobal(viewportPos);
 //  kdDebug() << "Global: " << point.x() << "," << point.y() << endl;
 //  point = clipper()->mapFromGlobal(point);
 //  kdDebug() << "clipper: " << point.x() << "," << point.y() << endl;
 //  kdDebug() << "visible height: " << visibleHeight() << endl;
   int x,y;
   viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
 //  kdDebug() << "contents: " << x << "," << y << "\n" << endl;
   int gx,gy;
   contentsToGrid(x,y,gx,gy);
   QPoint clipperPos = clipper()->
                       mapFromGlobal(viewport()->mapToGlobal(viewportPos));
 
   // Cursor left active agenda area.
   // This starts a drag.
   if ( /*clipperPos.y() < 0 || clipperPos.y() > visibleHeight() ||*/
        clipperPos.x() < 0 || clipperPos.x() > visibleWidth() ) {
     if ( mActionType == MOVE ) {
       mScrollUpTimer.stop();
       mScrollDownTimer.stop();
       mActionItem->resetMove();
       placeSubCells( mActionItem );
       // emit startDragSignal( mActionItem->incidence() );
       setCursor( arrowCursor );
       mActionItem = 0;
       mActionType = NOP;
       mItemMoved = 0;
       return;
     }
   } else {
     switch ( mActionType ) {
       case MOVE:
         setCursor( sizeAllCursor );
         break;
       case RESIZETOP:
       case RESIZEBOTTOM:
         setCursor( sizeVerCursor );
         break;
       case RESIZELEFT:
       case RESIZERIGHT:
         setCursor( sizeHorCursor );
         break;
       default:
         setCursor( arrowCursor );
     }
   }
 
   // Scroll if item was moved to upper or lower end of agenda.
   if (clipperPos.y() < mScrollBorderWidth) {
     mScrollUpTimer.start(mScrollDelay);
   } else if (visibleHeight() - clipperPos.y() <
              mScrollBorderWidth) {
     mScrollDownTimer.start(mScrollDelay);
   } else {
     mScrollUpTimer.stop();
     mScrollDownTimer.stop();
   }
 
   // Move or resize item if necessary
   if (mCurrentCellX != gx || mCurrentCellY != gy) {
     mItemMoved = true;
     mActionItem->raise();
     if (mActionType == MOVE) {
       // Move all items belonging to a multi item
       KOAgendaItem *moveItem = mActionItem->firstMultiItem();
       bool isMultiItem = (moveItem || mActionItem->lastMultiItem());
       if (!moveItem) moveItem = mActionItem;
       while (moveItem) {
         int dy;
         if (isMultiItem) dy = 0;
         else dy = gy - mCurrentCellY;
         moveItem->moveRelative(gx - mCurrentCellX,dy);
         int x,y;
         gridToContents(moveItem->cellX(),moveItem->cellYTop(),x,y);
         moveItem->resize(mGridSpacingX * moveItem->cellWidth(),
                          mGridSpacingY * moveItem->cellHeight());
         moveChild(moveItem,x,y);
         moveItem = moveItem->nextMultiItem();
       }
     } else if (mActionType == RESIZETOP) {
       if (mCurrentCellY <= mActionItem->cellYBottom()) {
         mActionItem->expandTop(gy - mCurrentCellY);
         mActionItem->resize(mActionItem->width(),
                             mGridSpacingY * mActionItem->cellHeight());
         int x,y;
         gridToContents(mCurrentCellX,mActionItem->cellYTop(),x,y);
         //moveChild(mActionItem,childX(mActionItem),y);
         QScrollView::moveChild( mActionItem,childX(mActionItem),y );
       }
     } else if (mActionType == RESIZEBOTTOM) {
       if (mCurrentCellY >= mActionItem->cellYTop()) {
         mActionItem->expandBottom(gy - mCurrentCellY);
         mActionItem->resize(mActionItem->width(),
                             mGridSpacingY * mActionItem->cellHeight());
       }
     } else if (mActionType == RESIZELEFT) {
        if (mCurrentCellX <= mActionItem->cellXWidth()) {
          mActionItem->expandLeft(gx - mCurrentCellX);
          mActionItem->resize(mGridSpacingX * mActionItem->cellWidth(),
                              mActionItem->height());
         int x,y;
         gridToContents(mActionItem->cellX(),mActionItem->cellYTop(),x,y);
         moveChild(mActionItem,x,childY(mActionItem));
        }
     } else if (mActionType == RESIZERIGHT) {
        if (mCurrentCellX >= mActionItem->cellX()) {
          mActionItem->expandRight(gx - mCurrentCellX);
          mActionItem->resize(mGridSpacingX * mActionItem->cellWidth(),
                              mActionItem->height());
        }
     }
     mCurrentCellX = gx;
     mCurrentCellY = gy;
   }
 }
 
 void KOAgenda::endItemAction()
 {
  
     if ( mItemMoved ) {
         KOAgendaItem *placeItem = mActionItem->firstMultiItem();
         if ( !placeItem ) {
             placeItem = mActionItem;      
         }
         if ( placeItem->incidence()->recurrence()->doesRecur() ) {
             Incidence* oldInc =  placeItem->incidence();
             placeItem->recreateIncidence();
             emit addToCalSignal(placeItem->incidence(), oldInc );
         }
         int type = mActionType;
         if ( mAllDayMode )
             type = -1;
         KOAgendaItem *modifiedItem = placeItem;
         //emit itemModified( placeItem, mActionType /*KOGlobals::EVENTEDITED */);
         QPtrList<KOAgendaItem> oldconflictItems ;//= placeItem->conflictItems();
         KOAgendaItem *item;
   
         if ( placeItem->incidence()->type() == "Todo" ) {
             mSelectedItem = 0;
             //qDebug("todo %d %d %d ", mCurrentCellX, modifiedItem->cellX() ,modifiedItem->cellXWidth());
             modifiedItem->mLastMoveXPos = mCurrentCellX;
             emit itemModified( modifiedItem, mActionType ); 
         }  
         else {  
 #if 0
             for ( item=oldconflictItems.first(); item != 0;
                   item=oldconflictItems.next() ) {
                 placeSubCells(item);    
             } 
             while ( placeItem ) { 
                 //qDebug("placeItem  %s ", placeItem->incidence()->summary().latin1());  
                 placeSubCells( placeItem );
                 placeItem = placeItem->nextMultiItem();
             }  
 #endif
 
             globalFlagBlockAgendaItemPaint = 1;
             for ( item=oldconflictItems.first(); item != 0;
                   item=oldconflictItems.next() ) {
                 placeSubCells(item);    
             } 
             while ( placeItem ) { 
                 //qDebug("placeItem  %s ", placeItem->incidence()->summary().latin1());  
                 oldconflictItems = placeItem->conflictItems();
                 for ( item=oldconflictItems.first(); item != 0;
                       item=oldconflictItems.next() ) {
                     placeSubCells(item);    
                 } 
                 placeSubCells( placeItem );
                 placeItem = placeItem->nextMultiItem();
             } 
             globalFlagBlockAgendaItemPaint = 0;
             for ( item=oldconflictItems.first(); item != 0;
                   item=oldconflictItems.next() ) {
                 globalFlagBlockAgendaItemUpdate = 0;
                 item->repaintMe();
                 globalFlagBlockAgendaItemUpdate = 1;
                 item->repaint( false );    
             } 
             placeItem = modifiedItem;
         
             while ( placeItem ) { 
                 //qDebug("placeItem  %s ", placeItem->incidence()->summary().latin1());  
                 globalFlagBlockAgendaItemUpdate = 0;
                 placeItem->repaintMe();
                 globalFlagBlockAgendaItemUpdate = 1;
                 placeItem->repaint(false);
                 placeItem = placeItem->nextMultiItem();
             }  
             emit itemModified( modifiedItem, mActionType ); 
          
 
             placeItem = modifiedItem;
             while ( placeItem ) {
                 oldconflictItems = placeItem->conflictItems();
                 for ( item=oldconflictItems.first(); item != 0;
                       item=oldconflictItems.next() ) {
                     placeSubCells(item);    
                 } 
                 placeSubCells( placeItem );
                 placeItem = placeItem->nextMultiItem();
 
             } 
             placeItem = modifiedItem;
             while ( placeItem ) {
                 oldconflictItems = placeItem->conflictItems();
                 for ( item=oldconflictItems.first(); item != 0;
                       item=oldconflictItems.next() ) {
                     globalFlagBlockAgendaItemUpdate = 0;
                     item->repaintMe();
                     globalFlagBlockAgendaItemUpdate = 1;
                     item->repaint(false);    
                 }
                 placeItem = placeItem->nextMultiItem();
             } 
             /*
 
             oldconflictItems = modifiedItem->conflictItems();
             for ( item=oldconflictItems.first(); item != 0;
             item=oldconflictItems.next() ) {
             globalFlagBlockAgendaItemUpdate = 0;
             item->paintMe(false);
             globalFlagBlockAgendaItemUpdate = 1;
             item->repaint(false);    
             }
             */
 
  
         }
      
     }
 
     mScrollUpTimer.stop();
     mScrollDownTimer.stop();
     setCursor( arrowCursor );
     mActionItem = 0;
     mActionType = NOP;
     mItemMoved = 0;
 
 }
 
 void KOAgenda::setNoActionCursor(KOAgendaItem *moveItem,QPoint viewportPos)
 {
 //  kdDebug() << "viewportPos: " << viewportPos.x() << "," << viewportPos.y() << endl;
 //  QPoint point = viewport()->mapToGlobal(viewportPos);
 //  kdDebug() << "Global: " << point.x() << "," << point.y() << endl;
 //  point = clipper()->mapFromGlobal(point);
 //  kdDebug() << "clipper: " << point.x() << "," << point.y() << endl;
 
   int x,y;
   viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
 //  kdDebug() << "contents: " << x << "," << y << "\n" << endl;
   int gx,gy;
   contentsToGrid(x,y,gx,gy);
 
   // Change cursor to resize cursor if appropriate
   if (mAllDayMode) {
     int gridDistanceX = (x - gx * mGridSpacingX);
     if (gridDistanceX < mResizeBorderWidth &&
         moveItem->cellX() == gx) {
       setCursor(sizeHorCursor);
     } else if ((mGridSpacingX - gridDistanceX) < mResizeBorderWidth &&
              moveItem->cellXWidth() == gx) {
       setCursor(sizeHorCursor);
     } else {
       setCursor(arrowCursor);
     }
   } else {
     int gridDistanceY = (y - gy * mGridSpacingY);
     if (gridDistanceY < mResizeBorderWidth &&
         moveItem->cellYTop() == gy &&
         !moveItem->firstMultiItem()) {
       setCursor(sizeVerCursor);
     } else if ((mGridSpacingY - gridDistanceY) < mResizeBorderWidth &&
                moveItem->cellYBottom() == gy &&
                !moveItem->lastMultiItem()) {
       setCursor(sizeVerCursor);
     } else {
       setCursor(arrowCursor);
     }
   }
 }
 
 
 /*
   Place item in cell and take care that multiple items using the same cell do
   not overlap. This method is not yet optimal. It doesn´t use the maximum space
   it can get in all cases.
   At the moment the method has a bug: When an item is placed only the sub cell
   widths of the items are changed, which are within the Y region the item to
   place spans. When the sub cell width change of one of this items affects a
   cell, where other items are, which do not overlap in Y with the item to place,
   the display gets corrupted, although the corruption looks quite nice.
 */
 void KOAgenda::placeSubCells(KOAgendaItem *placeItem)
 {
 
     QPtrList<KOAgendaItem> conflictItems;
     int maxSubCells = 0;
     QIntDict<KOAgendaItem> subCellDict(5);
 
     KOAgendaItem *item;
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
         if (item != placeItem) {
             if (placeItem->cellX() <= item->cellXWidth() &&
                 placeItem->cellXWidth() >= item->cellX()) {
                 if ((placeItem->cellYTop() <= item->cellYBottom()) &&
                     (placeItem->cellYBottom() >= item->cellYTop())) {
                     conflictItems.append(item);
                     if (item->subCells() > maxSubCells)
                         maxSubCells = item->subCells();
                     subCellDict.insert(item->subCell(),item);
                 }
             }
         }
     }
 
     if (conflictItems.count() > 0) {
         // Look for unused sub cell and insert item
         int i;
         for(i=0;i<maxSubCells;++i) {
             if (!subCellDict.find(i)) {
                 placeItem->setSubCell(i);
                 break;
             }
         }
         if (i == maxSubCells) {
             placeItem->setSubCell(maxSubCells);
             maxSubCells++;  // add new item to number of sub cells
         }
 
         // Prepare for sub cell geometry adjustment
         int newSubCellWidth;
         if (mAllDayMode) newSubCellWidth = mGridSpacingY / maxSubCells;
         else newSubCellWidth = mGridSpacingX / maxSubCells;
         conflictItems.append(placeItem);
 
 
-        // Adjust sub cell geometry of all items
+        // Adjust sub cell geometry of all direct conflict items
         for ( item=conflictItems.first(); item != 0;
               item=conflictItems.next() ) {
             item->setSubCells(maxSubCells);
             if (mAllDayMode) {
                 item->resize(item->cellWidth() * mGridSpacingX, newSubCellWidth);
             } else {
                 item->resize(newSubCellWidth, item->cellHeight() * mGridSpacingY);
             }
             int x,y;
             gridToContents(item->cellX(),item->cellYTop(),x,y);
             if (mAllDayMode) {
                 y += item->subCell() * newSubCellWidth;
             } else {
                 x += item->subCell() * newSubCellWidth;
             }
             moveChild(item,x,y);  
             // qDebug("moveChild %s %d %d ", item->incidence()->summary().latin1() ,x,y);  
             //item->updateItem();
         }
-
+        // Adjust sub cell geometry of all conflict items of all conflict items
+        for ( item=conflictItems.first(); item != 0;
+              item=conflictItems.next() ) {
+            if ( placeItem != item ) {
+                KOAgendaItem *item2;
+                QPtrList<KOAgendaItem> conflictItems2 = item->conflictItems();
+                for ( item2=conflictItems2.first(); item2 != 0;
+                      item2=conflictItems2.next() ) {
+                    if ( item2->subCells() != maxSubCells) {
+                        item2->setSubCells(maxSubCells);
+                        if (mAllDayMode) {
+                            item2->resize(item2->cellWidth() * mGridSpacingX, newSubCellWidth);
+                        } else {
+                            item2->resize(newSubCellWidth, item2->cellHeight() * mGridSpacingY);
+                        }
+                        int x,y;
+                        gridToContents(item2->cellX(),item2->cellYTop(),x,y);
+                        if (mAllDayMode) {
+                            y += item2->subCell() * newSubCellWidth;
+                        } else {
+                            x += item2->subCell() * newSubCellWidth;
+                        }
+                        moveChild(item2,x,y);  
+                        //qDebug("setttttt %d %s",maxSubCells, item2->text().latin1() );
+                    }
+                }
+            }
+        }
     } else {
         placeItem->setSubCell(0);
         placeItem->setSubCells(1);
         if (mAllDayMode) placeItem->resize(placeItem->width(),mGridSpacingY);
         else placeItem->resize(mGridSpacingX,placeItem->height());
         int x,y;
         gridToContents(placeItem->cellX(),placeItem->cellYTop(),x,y);
         moveChild(placeItem,x,y);
     }
     placeItem->setConflictItems(conflictItems);
   //   for ( item=conflictItems.first(); item != 0;
 //           item=conflictItems.next() ) {
 //         //item->updateItem();
 //         //qDebug("xxx item->updateItem() %s %d %d", item->incidence()->summary().latin1(),item->x(), item->y() );  
 //     }
 //     placeItem->updateItem();
 } 
 
 void KOAgenda::drawContents(QPainter* p, int cx, int cy, int cw, int ch)
 {
     if ( globalFlagBlockAgenda )
         return;
     //qDebug("KOAgenda::drawContents ");
     if (  mCurPixWid != contentsWidth() || mCurPixHei != contentsHeight() )
         ;//drawContentsToPainter();
    
     QPaintDevice* pd = p->device();
     p->end();
     int vx, vy; 
     int selectionX = KOGlobals::self()->reverseLayout() ?
             (mColumns - 1 - mSelectionCellX) * mGridSpacingX : 
             mSelectionCellX * mGridSpacingX;
     contentsToViewport ( cx, cy, vx,vy); 
     // qDebug("  %d %d %d %d ",  cx, cy, cw,ch) ;
     if ( !(selectionX ==  cx &&  cy == mSelectionYTop  &&  cw ==mGridSpacingX && ch == mSelectionHeight ) )
         bitBlt ( pd, vx, vy, &mPaintPixmap, cx, cy, cw, ch ,CopyROP);
     
     if ( mSelectionHeight > 0 ) { 
         //qDebug("----  %d %d %d %d ", selectionX, mSelectionYTop, mGridSpacingX, mSelectionHeight );
         if ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
              ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) {
             contentsToViewport ( selectionX, mSelectionYTop, vx,vy); 
             bitBlt ( pd, vx+1, vy, &mHighlightPixmap, 0, mSelectionYTop, mGridSpacingX-1, mSelectionHeight ,CopyROP); 
         }     
     } 
     //qDebug("btbl ");  
     p->begin( pd );
     //qDebug("end "); 
 }
 
 void KOAgenda::finishUpdate()
 {
 
     KOAgendaItem *item;
     globalFlagBlockAgendaItemPaint = 1;
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
         if ( !item->isVisible() )
             item->show();
        
     }
     globalFlagBlockAgendaItemUpdate = 0;
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
             item->repaintMe( );
     }
     globalFlagBlockAgendaItemUpdate = 1;
     qApp->processEvents(); 
     globalFlagBlockAgendaItemPaint = 0;
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
         item->repaint( false );
     }
     
 }
 
 /*
   Draw grid in the background of the agenda.
 */
 void KOAgenda::drawContentsToPainter( QPainter* paint, bool backgroundOnly )// int cx, int cy, int cw, int ch)
 {
 
  
     if ( ! mGridSpacingX || ! mGridSpacingY ||! mHolidayMask )
         return;
     if ( globalFlagBlockAgenda > 1 && globalFlagBlockAgenda < 4 )
         return;
     int cx = 0, cy = 0,  cw = contentsWidth(),  ch = contentsHeight();
     if ( ch < 1 )
         ch = 1;
     if (  mPaintPixmap.width() < contentsWidth()+42 || mPaintPixmap.height() < ch ) {
         mPaintPixmap.resize( contentsWidth()+42, ch );
     }
     mCurPixWid = contentsWidth();
     mCurPixHei = ch;
     if ( mHighlightPixmap.width() < mGridSpacingX-1 ||  mHighlightPixmap.height() < ch ) {
         mHighlightPixmap.resize( mGridSpacingX-1, ch );
         mHighlightPixmap.fill ( KOPrefs::instance()->mHighlightColor );
     }
     mPixPainter.begin( &mPaintPixmap) ;
     //qDebug("wid %d hei %d ",mPaintPixmap.width(),mPaintPixmap.height()  );
     QPainter * p ;
     if (paint == 0) {
         mPaintPixmap.fill(KOPrefs::instance()->mAgendaBgColor);
         p = &mPixPainter;
     }
     else
         p = paint ;
     // qDebug("++++++KOAgenda::drawContentsTo Painter %d %d %d %d ",  cx, cy, cw, ch); 
    
     //--cx;++cw;
   int lGridSpacingY = mGridSpacingY*2;
   int selDay;
   if ( !backgroundOnly )
   for ( selDay = 0; selDay < mSelectedDates.count();  ++selDay)
       {
           if ( mSelectedDates[selDay] == QDateTime::currentDateTime ().date() && KOPrefs::instance()->mHighlightCurrentDay) {
               int x1 = cx;
               int y1 = 0;
               if (y1 < cy) y1 = cy;
               int x2 = cx+cw-1;
               int y2 = contentsHeight();
               if (y2 > cy+ch-1) y2=cy+ch-1;
               if (x2 >= x1 && y2 >= y1) {
                   int gxStart = selDay;
                   int gxEnd = gxStart ;
                   int xStart = KOGlobals::self()->reverseLayout() ?
                       (mColumns - 1 - gxStart)*mGridSpacingX :
                       gxStart*mGridSpacingX;
                   if (xStart < x1) xStart = x1;
                   int xEnd = KOGlobals::self()->reverseLayout() ?
                       (mColumns - gxStart)*mGridSpacingX-1 :
                       (gxStart+1)*mGridSpacingX-1;
                   if (xEnd > x2) xEnd = x2;
                   if ( KOPrefs::instance()->mUseHighlightLightColor )
                       p->fillRect(xStart,y1,xEnd-xStart+1,y2-y1+1,
                                   KOPrefs::instance()->mAgendaBgColor.light());
                   else
                       p->fillRect(xStart,y1,xEnd-xStart+1,y2-y1+1,
                                   KOPrefs::instance()->mAgendaBgColor.dark());
                       
               } 
           }
       }
   // Highlight working hours
 
   if ( !backgroundOnly )
   if (mWorkingHoursEnable) {
     int x1 = cx;
     int y1 = mWorkingHoursYTop;
     if (y1 < cy) y1 = cy;
     int x2 = cx+cw-1;
     //  int x2 = mGridSpacingX * 5 - 1;
     //  if (x2 > cx+cw-1) x2 = cx + cw - 1;
     int y2 = mWorkingHoursYBottom;
     if (y2 > cy+ch-1) y2=cy+ch-1;
 
     if (x2 >= x1 && y2 >= y1) {
         // qDebug("x1 %d mGridSpacingX %d ", x1, mGridSpacingX );
       int gxStart = x1/mGridSpacingX;
       int gxEnd = x2/mGridSpacingX;
       while(gxStart <= gxEnd) {
         if (gxStart < int(mHolidayMask->count()) &&
             !mHolidayMask->at(gxStart)) {
           int xStart = KOGlobals::self()->reverseLayout() ?
                                     (mColumns - 1 - gxStart)*mGridSpacingX :
                                      gxStart*mGridSpacingX;
           if (xStart < x1) xStart = x1;
           int xEnd = KOGlobals::self()->reverseLayout() ?
                                     (mColumns - gxStart)*mGridSpacingX-1 :
                                     (gxStart+1)*mGridSpacingX-1;
           if (xEnd > x2) xEnd = x2;
           if ( mSelectedDates[gxStart] == QDateTime::currentDateTime ().date()&& KOPrefs::instance()->mHighlightCurrentDay ) {
               if ( KOPrefs::instance()->mUseHighlightLightColor )
                   p->fillRect(xStart,y1,xEnd-xStart+1,y2-y1+1,
                               KOPrefs::instance()->mWorkingHoursColor.light());
               else
                   p->fillRect(xStart,y1,xEnd-xStart+1,y2-y1+1,
                               KOPrefs::instance()->mWorkingHoursColor.dark());
           } else {
               p->fillRect(xStart,y1,xEnd-xStart+1,y2-y1+1,
                           KOPrefs::instance()->mWorkingHoursColor);
           }
         }
         ++gxStart;
       }
     }
   }
   /*
   int selectionX = KOGlobals::self()->reverseLayout() ?
                    (mColumns - 1 - mSelectionCellX) * mGridSpacingX : 
                     mSelectionCellX * mGridSpacingX;
 
   // Draw selection
   if ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
        ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) {
     // TODO: paint only part within cx,cy,cw,ch
     p->fillRect( selectionX, mSelectionYTop, mGridSpacingX,
                  mSelectionHeight, KOPrefs::instance()->mHighlightColor );
   }
   */
   // Draw vertical lines of grid
  
   int x = ((int)(cx/mGridSpacingX))*mGridSpacingX;
   if ( mGridSpacingX > 0 ) {
       while (x < cx + cw) {
           p->drawLine(x,cy,x,cy+ch);
           x+=mGridSpacingX;
       }
   }
   // Draw horizontal lines of grid
   int y = ((int)(cy/lGridSpacingY))*lGridSpacingY;
   if ( lGridSpacingY > 0 ) {
       while (y < cy + ch) {
           p->setPen( SolidLine );
           p->drawLine(cx,y,cx+cw,y);
           y+=lGridSpacingY;
           p->setPen( DotLine );
           p->drawLine(cx,y,cx+cw,y);
           y+=lGridSpacingY;
       } 
       p->setPen( SolidLine );
   }
    mPixPainter.end() ;
 }
 
 /*
   Convert srcollview contents coordinates to agenda grid coordinates.
 */
 void KOAgenda::contentsToGrid (int x, int y, int& gx, int& gy)
 {
   gx = KOGlobals::self()->reverseLayout() ? mColumns - 1 - x/mGridSpacingX :
                                                         x/mGridSpacingX;
   gy = y/mGridSpacingY;
 }
 
 /*
   Convert agenda grid coordinates to scrollview contents coordinates.
 */
 void KOAgenda::gridToContents (int gx, int gy, int& x, int& y)
 {
   x = KOGlobals::self()->reverseLayout() ? (mColumns - 1 - gx)*mGridSpacingX:
                                                          gx*mGridSpacingX;
   y = gy*mGridSpacingY;
 }
 
 
 /*
   Return Y coordinate corresponding to time. Coordinates are rounded to fit into
   the grid.
 */
 int KOAgenda::timeToY(const QTime &time)
 {
   int minutesPerCell = 24 * 60 / mRows;
   int timeMinutes = time.hour() * 60 + time.minute();
   int Y = (timeMinutes + (minutesPerCell / 2)) / minutesPerCell;
   return Y;
 }
 
 
 /*
   Return time corresponding to cell y coordinate. Coordinates are rounded to
   fit into the grid.
 */
 QTime KOAgenda::gyToTime(int gy)
 {
 
   int secondsPerCell = 24 * 60 * 60/ mRows;
 
   int timeSeconds = secondsPerCell * gy;
 
   QTime time( 0, 0, 0 );
   if ( timeSeconds < 24 * 60 * 60 ) {
     time = time.addSecs(timeSeconds);
   } else {
     time.setHMS( 23, 59, 59 );
   }
 
   return time;
 }
 
 void KOAgenda::setStartHour(int startHour)
 {
   int startCell = startHour * mRows / 24;
   setContentsPos(0,startCell * gridSpacingY());
 }
 void KOAgenda::hideUnused()
 {
     // experimental only
     // return;
     KOAgendaItem *item;
     for ( item=mUnusedItems.first(); item != 0; item=mUnusedItems.next() ) {
         item->hide();
     }
 }
 
 
 KOAgendaItem *KOAgenda::getNewItem(Incidence * event,QDate qd, QWidget* view)
 {
 
     KOAgendaItem *fi;
     for ( fi=mUnusedItems.first(); fi != 0; fi=mUnusedItems.next() ) {
         if ( fi->incidence() ==  event ) {
             mUnusedItems.remove();
             fi->init( event, qd );
             return fi;
         }
     }
     fi=mUnusedItems.first();
     if ( fi ) {
         mUnusedItems.remove();
         fi->init( event, qd );
         return fi;
     }
     // qDebug("new KOAgendaItem ");
 
     KOAgendaItem* agendaItem = new KOAgendaItem( event, qd, view, mAllDayMode );
     agendaItem->installEventFilter(this);
     addChild(agendaItem,0,0);
     return  agendaItem;
 }
 KOAgendaItem * KOAgenda::getItemForTodo ( Todo * todo )
 {
     KOAgendaItem *item;
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
         if ( item->incidence() == todo ) {
             mItems.remove();
             return item;
         }
     }
     return 0;
 }
 
 
 void KOAgenda::updateTodo( Todo * todo, int days, bool remove) 
 { 
       // ( todo->hasCompletedDate() && todo->completed().date() == currentDate )||
     KOAgendaItem *item;
     item = getItemForTodo ( todo );
     //qDebug("KOAgenda::updateTodo %d %d %d %d", this, todo, days, remove);
     if ( item ) {
         blockSignals( true );
         //qDebug("item found ");
         item->hide();
         item->setCellX(-2, -1 );
         item->select(false);
         mUnusedItems.append( item );
         mItems.remove( item );
         QPtrList<KOAgendaItem> oldconflictItems = item->conflictItems();
         KOAgendaItem *itemit; 
         //globalFlagBlockAgendaItemPaint = 1;
         for ( itemit=oldconflictItems.first(); itemit != 0;
               itemit=oldconflictItems.next() ) {
             if ( itemit != item )
                 placeSubCells(itemit); 
         }  
         qApp->processEvents();
         //globalFlagBlockAgendaItemPaint = 0;
         for ( itemit=oldconflictItems.first(); itemit != 0;
               itemit=oldconflictItems.next() ) {
             globalFlagBlockAgendaItemUpdate = 0;
             if ( itemit != item )
                 itemit->repaintMe();
             globalFlagBlockAgendaItemUpdate = 1;
             itemit->repaint(); 
         }
         blockSignals( false );
     }
     if ( remove ) {
         //qDebug("remove****************************************** ");
         return;
     }
     //qDebug("updateTodo+++++++++++++++++++++++++++++++++++++ ");
     bool overdue = (!todo->isCompleted()) && (todo->dtDue() < QDate::currentDate())&&  ( KOPrefs::instance()->mShowTodoInAgenda );
     QDate currentDate;
     QDateTime dt;
     if ( todo->hasCompletedDate() )
         dt =  todo->completed();
     else
         dt = todo->dtDue();
     if ( overdue ) {
         currentDate = QDate::currentDate();
         days += todo->dtDue().date().daysTo( currentDate );
     }
     else
         currentDate = dt.date();
     
     if (( todo->doesFloat() || overdue) && !todo->hasCompletedDate() ) {  
         if ( ! mAllDayMode ) return;
         // aldayagenda
         globalFlagBlockAgendaItemPaint = 1;
         item = insertAllDayItem(todo, currentDate,days, days);
         item->show();
       
     }
     else {
         if (  mAllDayMode ) return;
         // mAgenda
         globalFlagBlockAgendaItemPaint = 1;
         int endY = timeToY(dt.time()) - 1; 
         int hi = 12/KOPrefs::instance()->mHourSize;
         int startY = endY - 1-hi;
         item = insertItem(todo,currentDate,days,startY,endY);
         item->show();
     }
     qApp->processEvents();
     globalFlagBlockAgendaItemPaint = 0; 
     QPtrList<KOAgendaItem> oldconflictItems = item->conflictItems();
     KOAgendaItem *itemit; 
     for ( itemit=oldconflictItems.first(); itemit != 0;
           itemit=oldconflictItems.next() ) {
         globalFlagBlockAgendaItemUpdate = 0;
         itemit->repaintMe();
         globalFlagBlockAgendaItemUpdate = 1;
         itemit->repaint(); 
     } 
     globalFlagBlockAgendaItemUpdate = 0;
     item->repaintMe();
     globalFlagBlockAgendaItemUpdate = 1;
     item->repaint();
 }
 /*
   Insert KOAgendaItem into agenda.
 */
 KOAgendaItem *KOAgenda::insertItem (Incidence *event,QDate qd,int X,int YTop,int YBottom)
 {
   //kdDebug() << "KOAgenda::insertItem:" << event->summary() << "-" << qd.toString() << " ;top, bottom:" << YTop << "," << YBottom << endl;
 
   if (mAllDayMode) {
     kdDebug() << "KOAgenda: calling insertItem in all-day mode is illegal." << endl;
     return 0;
   }
 
   KOAgendaItem *agendaItem = getNewItem(event,qd,viewport());
   //agendaItem->setFrameStyle(WinPanel|Raised);
 
   int YSize = YBottom - YTop + 1;
   if (YSize < 0) {
     kdDebug() << "KOAgenda::insertItem(): Text: " << agendaItem->text() << " YSize<0" << endl;
     YSize = 1;
   }
   int iheight = mGridSpacingY * YSize;
  
   agendaItem->resize(mGridSpacingX,iheight );
   agendaItem->setCellXY(X,YTop,YBottom);
   agendaItem->setCellXWidth(X);
 
   //addChild(agendaItem,X*mGridSpacingX,YTop*mGridSpacingY);
   mItems.append(agendaItem);
 
   placeSubCells(agendaItem);
 
   //agendaItem->show();
 
   marcus_bains();
 
   return agendaItem;
 }
 
 
 /*
   Insert all-day KOAgendaItem into agenda.
 */
 KOAgendaItem *KOAgenda::insertAllDayItem (Incidence *event,QDate qd,int XBegin,int XEnd)
 {
    if (!mAllDayMode) {
     return 0;
   }
 
   KOAgendaItem *agendaItem = getNewItem(event,qd,viewport());
 
   agendaItem->setCellXY(XBegin,0,0);
   agendaItem->setCellXWidth(XEnd);
   agendaItem->resize(mGridSpacingX * agendaItem->cellWidth(),mGridSpacingY);
 
   //addChild(agendaItem,XBegin*mGridSpacingX,0);
   mItems.append(agendaItem);
 
   placeSubCells(agendaItem);
 
   //agendaItem->show();
 
   return agendaItem;
 }
 
 
 void KOAgenda::insertMultiItem (Event *event,QDate qd,int XBegin,int XEnd,
                                 int YTop,int YBottom)
 {
     if (mAllDayMode) {
         ;
     return;
   }
 
   int cellX,cellYTop,cellYBottom;
   QString newtext;
   int width = XEnd - XBegin + 1;
   int count = 0;
   KOAgendaItem *current = 0;
   QPtrList<KOAgendaItem> multiItems;
   for (cellX = XBegin;cellX <= XEnd;++cellX) {
     if (cellX == XBegin) cellYTop = YTop;
     else cellYTop = 0;
     if (cellX == XEnd) cellYBottom = YBottom;
     else cellYBottom = rows() - 1;
     newtext = QString("(%1/%2): ").arg(++count).arg(width);
     newtext.append(event->summary());
     current = insertItem(event,qd,cellX,cellYTop,cellYBottom);
     current->setText(newtext);
     multiItems.append(current);
   }
 
   KOAgendaItem *next = 0;
   KOAgendaItem *last = multiItems.last();
   KOAgendaItem *first = multiItems.first();
   KOAgendaItem *setFirst,*setLast;
   current = first;
   while (current) {
     next = multiItems.next();
     if (current == first) setFirst = 0;
     else setFirst = first;
     if (current == last) setLast = 0;
     else setLast = last;
 
     current->setMultiItem(setFirst,next,setLast);
     current = next;
   }
 
   marcus_bains();
 }
 
 
 //QSizePolicy KOAgenda::sizePolicy() const
 //{
   // Thought this would make the all-day event agenda minimum size and the
   // normal agenda take the remaining space. But it doesn´t work. The QSplitter
   // don´t seem to think that an Expanding widget needs more space than a
   // Preferred one.
   // But it doesn´t hurt, so it stays.
 //  if (mAllDayMode) {
 //    return QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Preferred);
 //  } else {
 //    return QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
 //  }
 //}
 void KOAgenda::finishResize ( )
 {
     //qDebug("finishResize+++++++++++++++++++++++++++++++ ( ) ");
     if ( globalFlagBlockAgenda ==  0 ) {
         finishUpdate();
         //qDebug("finishUpdate() called ");
     }
 }
 /*
   Overridden from QScrollView to provide proper resizing of KOAgendaItems.
 */
 void KOAgenda::resizeEvent ( QResizeEvent *ev )
 {
    
     mResizeTimer.start( 150 , true );
     computeSizes(); 
     return;
 
 }
 void KOAgenda::computeSizes()
 {   
     if ( globalFlagBlockStartup )
         return;
 
   if (mAllDayMode) {
     mGridSpacingX = (width()-3) / mColumns;
     mGridSpacingY = height() - 2 * frameWidth() - 1;
     resizeContents( mGridSpacingX * mColumns + 1 , mGridSpacingY + 1);
 //    mGridSpacingY = height();
 //    resizeContents( mGridSpacingX * mColumns + 1 , mGridSpacingY * mRows + 1 );
 
     KOAgendaItem *item;
     int subCellWidth;
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
       subCellWidth = mGridSpacingY / item->subCells();
       item->resize(mGridSpacingX * item->cellWidth(),subCellWidth);
       moveChild(item,KOGlobals::self()->reverseLayout() ?
                      (mColumns - 1 - item->cellX()) * mGridSpacingX :
                       item->cellX() * mGridSpacingX,
                       item->subCell() * subCellWidth);
     }
     KOPrefs::instance()->mAllDaySize = mGridSpacingY;
   } else {
     mGridSpacingX = (width() - verticalScrollBar()->width()-3)/mColumns;
     if (height() >   mGridSpacingY * mRows + 1 ) {
         KOPrefs::instance()->mHourSize = ((height())/mRows)+1;
         mGridSpacingY = KOPrefs::instance()->mHourSize ;
         resizeContents( mGridSpacingX * mColumns + 1 , mGridSpacingY * mRows + 1 );
         emit resizedSignal();
     } else
         resizeContents( mGridSpacingX * mColumns + 1 , mGridSpacingY * mRows + 1 );
     KOAgendaItem *item;
     int subCellWidth;
     
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
       subCellWidth = mGridSpacingX / item->subCells();
       item->resize(subCellWidth,item->height());
       moveChild(item,(KOGlobals::self()->reverseLayout() ?
                      (mColumns - 1 - item->cellX()) * mGridSpacingX :
                      item->cellX() * mGridSpacingX) +
                      item->subCell() * subCellWidth,childY(item));
     }
   }
   int cw = contentsWidth();
   int ch = contentsHeight();
   if ( mAllDayMode ) { 
       QPixmap* paintPixAll = KOAgendaItem::paintPixAllday();
       if ( (paintPixAll->width() < cw || paintPixAll->height() <  ch) && cw > 0  && ch > 0  )
           paintPixAll->resize( cw, ch ); 
   } else {
       QPixmap* paintPix = KOAgendaItem::paintPix();
       if ( paintPix->width() < cw || paintPix->height() <  ch )
           KOAgendaItem::resizePixmap( cw , ch );
   }
 
   checkScrollBoundaries();
   marcus_bains();
   drawContentsToPainter();
   viewport()->repaint(false);
 }
 
 void KOAgenda::scrollUp()
 {
   scrollBy(0,-mScrollOffset);
 }
 
 
 void KOAgenda::scrollDown()
 {
   scrollBy(0,mScrollOffset);
 }
 
 void KOAgenda::popupAlarm()
 {
   if (!mClickedItem) {
       qDebug("KOAgenda::popupAlarm() called without having a clicked item ");
     return;
   }
 // TODO: deal correctly with multiple alarms
   Alarm* alarm;
   QPtrList<Alarm> list(mClickedItem->incidence()->alarms());
   for(alarm=list.first();alarm;alarm=list.next()) {
       alarm->toggleAlarm();
   }
   emit itemModified( mClickedItem , KOGlobals::EVENTEDITED );
   mClickedItem->paintMe( true );
   mClickedItem->repaint( false );
 }
 
 /*
   Calculates the minimum width
 */
 int KOAgenda::minimumWidth() const
 {
   // TODO:: develop a way to dynamically determine the minimum width
   int min = 100;
 
   return min;
 }
 
 void KOAgenda::updateConfig()
 {
    if ( viewport()->backgroundColor() != KOPrefs::instance()->mAgendaBgColor)
        viewport()->setBackgroundColor(KOPrefs::instance()->mAgendaBgColor);
   if ( mAllDayMode ) {
       mGridSpacingY = height() - 1 ;// KOPrefs::instance()->mAllDaySize;
       //mGridSpacingY = KOPrefs::instance()->mAllDaySize;
       resizeContents( mGridSpacingX * mColumns + 1 , mGridSpacingY+1 );
       // setMaximumHeight(  mGridSpacingY+1 );
       viewport()->repaint( false );
       //setFixedHeight( mGridSpacingY+1 );
       //qDebug("KOPrefs:aaaaa:instance()->mAllDaySize %d  ", KOPrefs::instance()->mAllDaySize);
   }
   else {
       mGridSpacingY = KOPrefs::instance()->mHourSize;
       calculateWorkingHours();
       marcus_bains();
   }
 }
 
 void KOAgenda::checkScrollBoundaries()
 {
   // Invalidate old values to force update
   mOldLowerScrollValue = -1;
   mOldUpperScrollValue = -1;
 
   checkScrollBoundaries(verticalScrollBar()->value());
 }
 
 void KOAgenda::checkScrollBoundaries(int v)
 {
     if ( mGridSpacingY ==  0 )
         return;
   int yMin = v/mGridSpacingY;
   int yMax = (v+visibleHeight())/mGridSpacingY;
 
 //  kdDebug() << "--- yMin: " << yMin << "  yMax: " << yMax << endl;
 
   if (yMin != mOldLowerScrollValue) {
     mOldLowerScrollValue = yMin;
     emit lowerYChanged(yMin);
   }
   if (yMax != mOldUpperScrollValue) {
     mOldUpperScrollValue = yMax;
     emit upperYChanged(yMax);
   }
 }
 
 void KOAgenda::deselectItem()
 {
   if (mSelectedItem.isNull()) return;
   mSelectedItem->select(false);
   mSelectedItem = 0;
 }
 
 void KOAgenda::selectItem(KOAgendaItem *item)
 {
   if ((KOAgendaItem *)mSelectedItem == item) return;
   deselectItem();
   if (item == 0) {
     emit incidenceSelected( 0 );
     return;
   }
   mSelectedItem = item;
   mSelectedItem->select();
   emit incidenceSelected( mSelectedItem->incidence() );
 }
 
 // This function seems never be called.
 void KOAgenda::keyPressEvent( QKeyEvent *kev )
 {
   switch(kev->key()) {
     case Key_PageDown:
       verticalScrollBar()->addPage();
       break;
     case Key_PageUp:
       verticalScrollBar()->subtractPage();
       break;
     case Key_Down:
       verticalScrollBar()->addLine();
       break;
     case Key_Up:
       verticalScrollBar()->subtractLine();
       break;
     default:
       ;
   }
 }
 
 void KOAgenda::calculateWorkingHours()
 {
 //  mWorkingHoursEnable = KOPrefs::instance()->mEnableWorkingHours;
   mWorkingHoursEnable = !mAllDayMode;
 
   mWorkingHoursYTop = mGridSpacingY *
                       KOPrefs::instance()->mWorkingHoursStart * 4;
   mWorkingHoursYBottom = mGridSpacingY *
                          KOPrefs::instance()->mWorkingHoursEnd * 4 - 1;
 }
 
 
 DateList KOAgenda::dateList() const
 {
     return mSelectedDates;
 }
 
diff --git a/korganizer/koagendaitem.cpp b/korganizer/koagendaitem.cpp
index d0a7b07..38bd93a 100644
--- a/korganizer/koagendaitem.cpp
+++ b/korganizer/koagendaitem.cpp
@@ -1,765 +1,766 @@
 /*
     This file is part of KOrganizer.
     Copyright (c) 2000,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.
 */
 
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qhbox.h>
 #include <qvbox.h>
 #include <qtooltip.h>
 #include <qwhatsthis.h>
 #include <qdragobject.h>
 #include <qdrawutil.h> 
 #include <qpainter.h> 
 
 #include <kiconloader.h>
 #include <kdebug.h>
 #include <kglobal.h>
 #include <klocale.h>
 #ifndef DESKTOP_VERSION
 #include <qpe/qpeapplication.h>
 #define AGENDA_ICON_SIZE 5
 #else
 #define AGENDA_ICON_SIZE 7
 #endif
 #include <libkcal/icaldrag.h>
 #include <libkcal/vcaldrag.h>
 #include <libkcal/kincidenceformatter.h>
 extern int globalFlagBlockAgenda;
 extern int globalFlagBlockAgendaItemPaint;
 extern int globalFlagBlockAgendaItemUpdate;
 
 #include "koprefs.h"
 
 #include "koagendaitem.h"
 //#include "koagendaitem.moc"
 
 
 //--------------------------------------------------------------------------
 
 QToolTipGroup *KOAgendaItem::mToolTipGroup = 0;
 
 //--------------------------------------------------------------------------
 
 class KOAgendaItemWhatsThis :public QWhatsThis
 {
 public:
   KOAgendaItemWhatsThis( KOAgendaItem* view ) : QWhatsThis( view ),_view (view) { };
 
 protected:
   virtual QString text( const QPoint& )
   {
     return _view->getWhatsThisText() ;
   }
 private:
   KOAgendaItem * _view;
 };
 
 KOAgendaItem::KOAgendaItem(Incidence *incidence, QDate qd, QWidget *parent,bool allday,
                            const char *name,WFlags) :
     QWidget(parent, name), mIncidence(incidence), mDate(qd)
 {
 #ifndef DESKTOP_VERSION
     QPEApplication::setStylusOperation( this, QPEApplication::RightOnHold );
 #endif
     new KOAgendaItemWhatsThis(this);
     int wflags = getWFlags() |WRepaintNoErase;// WResizeNoErase
     setWFlags ( wflags);
     mAllDay = allday;
     init ( incidence, qd );
     setMouseTracking(true);
     //setAcceptDrops(true);
     xPaintCoord = -1;
     yPaintCoord = -1;
 }
 QString KOAgendaItem::getWhatsThisText()
 {
     if ( mIncidence )
         return KIncidenceFormatter::instance()->getFormattedText( mIncidence, 
                                                                   KOPrefs::instance()->mWTshowDetails,
                                                                   KOPrefs::instance()->mWTshowCreated,
                                                                   KOPrefs::instance()->mWTshowChanged);
     return "KOAgendaItem::getWhatsThisText()::internal error";
 }
 void KOAgendaItem::init ( Incidence *incidence, QDate qd )
 {
     mIncidence = incidence;
     mDate = qd;
     mFirstMultiItem = 0;
     mNextMultiItem = 0;
     mLastMultiItem = 0;  
     computeText();
    
     if ( (incidence->type() == "Todo") &&
          ( !((static_cast<Todo*>(incidence))->isCompleted()) &&
            ((static_cast<Todo*>(incidence))->dtDue().date() <=  QDate::currentDate()) ) ) {
         if (  (static_cast<Todo*>(incidence))->dtDue() <  QDateTime::currentDateTime().date()) 
             mBackgroundColor = KOPrefs::instance()->mTodoOverdueColor ;
         else 
             mBackgroundColor = KOPrefs::instance()->mTodoDueTodayColor;
     }
     else {
         QStringList categories = mIncidence->categories();
         QString cat = categories.first();
         if (cat.isEmpty()) {
             if ( (incidence->type() == "Todo") &&((static_cast<Todo*>(incidence))->isCompleted()) )
                 mBackgroundColor =KOPrefs::instance()->mTodoDoneColor;
             else
                 mBackgroundColor =KOPrefs::instance()->mEventColor;
         } else {
             mBackgroundColor = *KOPrefs::instance()->categoryColor(cat);
             if ( (incidence->type() == "Todo") &&((static_cast<Todo*>(incidence))->isCompleted()) ) {
                 if ( mBackgroundColor == KOPrefs::instance()->mEventColor )
                     mBackgroundColor =KOPrefs::instance()->mTodoDoneColor;
             }
         }
             
     }
     mColorGroup  = QColorGroup( mBackgroundColor.light(), 
                                 mBackgroundColor.dark(),mBackgroundColor.light(),
                                 mBackgroundColor.dark(),mBackgroundColor, black, mBackgroundColor) ;
     setBackgroundColor( mBackgroundColor );
    
+    mConflictItems.clear();
     setCellXY(0,0,1);
     setCellXWidth(0);
     setSubCell(0);
     setSubCells(1);
     setMultiItem(0,0,0);
     startMove();
     mSelected = true;
     select(false);
     QFontMetrics fontinf(KOPrefs::instance()->mAgendaViewFont);
     mFontPixelSize = fontinf.height();;
     hide();
     xPaintCoord = -1;
     yPaintCoord = -1;
 }
 
 
 KOAgendaItem::~KOAgendaItem()
 {
     // qDebug("deleteKOAgendaItem::~KOAgendaItem(  ");
 
 }
 
 void KOAgendaItem::recreateIncidence()
 {
 #if 0
     Incidence* newInc = mIncidence->clone();
     newInc->recreate();
     if ( mIncidence->doesRecur() ) {
         mIncidence->addExDate( mDate );
         newInc->recurrence()->unsetRecurs();
         int len = mIncidence->dtStart().secsTo( ((Event*)mIncidence)->dtEnd());
         QTime tim = mIncidence->dtStart().time();
         newInc->setDtStart( QDateTime(mDate, tim) );
         ((Event*)newInc)->setDtEnd( newInc->dtStart().addSecs( len ) );
     }
 #endif
     mIncidence = mIncidence->recreateCloneException( mDate );
 }
 bool KOAgendaItem::updateIcons(QPainter * p, bool horLayout)
 {
     int size = AGENDA_ICON_SIZE;
 
     int yOff = 0;
     int xOff = 0;
     int x = pos().x() +3; 
     int y;
     if ( mAllDay )
         y = pos().y()+3;
     else
         y =  mCellYTop * ( height() / cellHeight() ) +3;
     if (mIncidence->cancelled()) {
         int xpos = xOff*( 1 +AGENDA_ICON_SIZE )+x;
         int ypos = yOff*( 1 +AGENDA_ICON_SIZE)+y;
         p->drawLine( xpos, ypos, xpos+AGENDA_ICON_SIZE-1, ypos+AGENDA_ICON_SIZE-1  );
         p->drawLine( xpos, ypos+AGENDA_ICON_SIZE-1, xpos+AGENDA_ICON_SIZE-1, ypos );
         if ( horLayout )
             ++xOff;
         else
             ++yOff;
     }
     if (mIncidence->isAlarmEnabled()) {
         p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, red );
         if ( horLayout )
             ++xOff;
         else
             ++yOff;
     }
     if (mIncidence->recurrence()->doesRecur()) {
         p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, blue );
         if ( horLayout )
             ++xOff;
         else
             ++yOff;
     }
     if (mIncidence->description().length() > 0) {
         p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, darkGreen );
         if ( horLayout )
             ++xOff;
         else
             ++yOff;
     }
    if (mIncidence->isReadOnly()) {
         p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, white );
         if ( horLayout )
             ++xOff;
         else
             ++yOff;
     }
 
     if (mIncidence->attendeeCount()>0) {
         
         if (mIncidence->organizer() == KOPrefs::instance()->email()) {
             p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, black );
             if ( horLayout )
                 ++xOff;
             else
                 ++yOff;
         } else {
             Attendee *me = mIncidence->attendeeByMails(KOPrefs::instance()->mAdditionalMails,KOPrefs::instance()->email());
             if (me!=0) {
 
 
             } else {
                 p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, yellow  );
                 if ( horLayout )
                     ++xOff;
                 else
                     ++yOff;
 
             }
             p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, darkYellow );
             if ( horLayout )
                 ++xOff;
             else
                 ++yOff;
 
         }
 
     }
   return ( yOff || xOff );
 }
 
 
 void KOAgendaItem::select(bool selected)
 {
     //qDebug("select %d %d",firstMultiItem(), nextMultiItem() );
     if (mSelected == selected) return;
     mSelected = selected;
     if ( ! isVisible() )
         return;
     if ( firstMultiItem() )
         firstMultiItem()->select( selected );
     if ( !firstMultiItem() && nextMultiItem() ) {
         KOAgendaItem *  placeItem = nextMultiItem();
         while ( placeItem ) { 
             placeItem->select( selected );
             placeItem = placeItem->nextMultiItem();
         }  
     }
     globalFlagBlockAgendaItemUpdate = 0;
     paintMe( selected );
     globalFlagBlockAgendaItemUpdate = 1;
     repaint( false );
 }
 
 
 /*
   The eventFilter has to filter the mouse events of the agenda item childs. The
   events are fed into the event handling method of KOAgendaItem. This allows the
   KOAgenda to handle the KOAgendaItems by using an eventFilter.
 */
 bool KOAgendaItem::eventFilter ( QObject *object, QEvent *e )
 {
     if (e->type() == QEvent::MouseButtonPress ||
         e->type() == QEvent::MouseButtonDblClick ||
         e->type() == QEvent::MouseButtonRelease ||
         e->type() == QEvent::MouseMove) {
         QMouseEvent *me = (QMouseEvent *)e;
         QPoint itemPos = this->mapFromGlobal(((QWidget *)object)->
                                              mapToGlobal(me->pos()));
         QMouseEvent returnEvent (e->type(),itemPos,me->button(),me->state());
         return event(&returnEvent);
     } else {
         return false;
     }
 }
 void KOAgendaItem::repaintMe( )
 { 
     paintMe ( mSelected );
 }
 void KOAgendaItem::paintMe( bool selected, QPainter* paint )
 {    
     if ( globalFlagBlockAgendaItemUpdate && ! selected)
       return;
     QPainter pa;
     
     if ( mSelected ) {
         pa.begin( paintPixSel() );
     } else {
         if ( mAllDay )
             pa.begin( paintPixAllday() );
         else
             pa.begin( paintPix() );
     }
     int x, yy, w,  h;
     float nfh = 7.0;
     x = pos().x(); w = width(); h = height ();
     if ( mAllDay )
         yy = y();
     else
         yy = mCellYTop * ( height() / cellHeight() );
     xPaintCoord= x;
     yPaintCoord = yy;
     wPaintCoord = width();
     hPaintCoord = height();
     //qDebug("paintMe %s %d %d %d %d",incidence()->summary().latin1(), x, yy, width(), height());
     if ( paint == 0 )
         paint = &pa;
     bool horLayout = ( w < h );
     int maxhei = mFontPixelSize+4;
     if (  horLayout )
         maxhei +=  AGENDA_ICON_SIZE -4;
     bool small = ( h < maxhei  );
     if ( ! small ) 
         paint->setFont(KOPrefs::instance()->mAgendaViewFont);
     else {
         QFont f =  KOPrefs::instance()->mAgendaViewFont;
         f.setBold( false );
         int fh = f.pointSize();
         nfh = (((float)height())/(float)(mFontPixelSize+4))*fh;
         if ( nfh < 6 )
             nfh = 6;
         f.setPointSize( nfh );
         paint->setFont(f);
     }
     paint->fillRect ( x, yy,  w, h, mBackgroundColor );
     static const  QPixmap completedPxmp = SmallIcon("greenhook16");
     static const QPixmap overduePxmp = SmallIcon("redcross16");
     if ( mIncidence->type() == "Todo" ) {
         Todo* tempTodo = static_cast<Todo*>(mIncidence);
         int xx = pos().x()+(width()-completedPxmp.width()-3 );
         int yyy =  yy+3;
         if ( tempTodo->isCompleted() )
             paint->drawPixmap ( xx, yyy, completedPxmp );
         else {
             paint->drawPixmap ( xx, yyy, overduePxmp );
             
         }
     }
     bool addIcon = false;
     if ( ! small || w > 3 * h || h > 3* w )
        addIcon =  updateIcons(  paint, horLayout );
 
     qDrawShadePanel (paint, x,  yy,  w,  h, mColorGroup, selected , 2, 0);
     //qDebug("draw rect %d %d %d %d ",x,  yy,  w,  h );
     if ( ! small ) {
         x += 3; yy += 3;w -= 6;  h-= 5;
     } else {
         x += 2; yy += 1;w -= 4;  h-= 4; 
         if ( nfh < 6.01 ) {
             yy -= 2;
             h += 4;
         }
         else
             if ( nfh < h -2 )
                 ++yy;
     }
     int align;
 #ifndef DESKTOP_VERSION
     align = ( AlignLeft|WordBreak|AlignTop);
 #else
     align = ( AlignLeft|BreakAnywhere|WordBreak|AlignTop);
 #endif
     if (  addIcon  ) {
         if ( ! horLayout ) {
             x += AGENDA_ICON_SIZE+3;
             w -= (AGENDA_ICON_SIZE+3);
         }
         else {
             yy+= AGENDA_ICON_SIZE+2;
             h -=(AGENDA_ICON_SIZE+3);
         }
     } 
     int colsum = mBackgroundColor.red() + mBackgroundColor.green() + mBackgroundColor.blue();
     if ( colsum < 250 )
         paint->setPen ( white); 
     if ( x < 0 ) {
         w = w+x-3;
         x = 3;
         if ( w > parentWidget()->width() ){
             w = parentWidget()->width() - 6;
 #ifndef DESKTOP_VERSION
     align = ( AlignHCenter|WordBreak|AlignTop);
 #else
     align = ( AlignHCenter|BreakAnywhere|WordBreak|AlignTop);
 #endif
 
         }
     }
     QRect dr;
     if ( w + x > parentWidget()->width() )
         w = parentWidget()->width()-x;
      paint->drawText ( x, yy, w, h, align, mDisplayedText, -1, &dr );
      //qDebug("%d %d %d %d ",   x, yy, w, h );
      if ( mIncidence->cancelled() ){
          if ( ! small ) {
              QFontMetrics fm ( paint->font() );
              paint->drawLine(dr.left(), yy+fm.height()/2, dr.right()-2, yy+fm.height()/2);
          }
 
      }
     pa.end();
  
 }
 void KOAgendaItem::resizePixmap( int w , int h )
 {
     paintPix()->resize( w, h ); 
     paintPixSel()->resize( w, h ); 
 
 }
 QPixmap * KOAgendaItem::paintPix()
 {
     static QPixmap* mPaintPix = 0;
     if ( ! mPaintPix )
         mPaintPix = new QPixmap(1,1);
     return mPaintPix ; 
 }
 QPixmap * KOAgendaItem::paintPixAllday()
 {
     static QPixmap* mPaintPixA = 0;
     if ( ! mPaintPixA ) 
         mPaintPixA = new QPixmap(1,1);
     return mPaintPixA ; 
 }
 QPixmap * KOAgendaItem::paintPixSel()
 {
     static QPixmap* mPaintPixSel = 0;
     if ( ! mPaintPixSel )
         mPaintPixSel = new QPixmap(1,1);
     return mPaintPixSel ; 
 }
 void KOAgendaItem::paintEvent ( QPaintEvent *e )
 {  
 
     if ( globalFlagBlockAgendaItemPaint )
         return; 
     if ( globalFlagBlockAgenda > 0 &&  globalFlagBlockAgenda < 5 )
       return;
     int yy;
     if ( mAllDay )
         yy = y();
     else
         yy = mCellYTop * ( height() / cellHeight() );
     int xx = x();
     if ( xPaintCoord != xx || yPaintCoord != yy || 
          wPaintCoord != width() ||  hPaintCoord != height()) {
         xPaintCoord= xx;
         yPaintCoord = yy;
         wPaintCoord = width();
         hPaintCoord = height();
         globalFlagBlockAgendaItemUpdate = 0;
         paintMe( mSelected );
         //qDebug("calling paintMe ");
         globalFlagBlockAgendaItemUpdate = 1;
     }
     int rx, ry, rw, rh;
     rx =  e->rect().x();
     ry =  e->rect().y();
     rw =  e->rect().width();
     rh =  e->rect().height();
     //qDebug("   paintevent %s %d %d    %d  %d", mIncidence->summary().latin1(), x(), yy, width(), height()); 
 
     QPixmap* paintFrom ;
     if ( mSelected ) {
         paintFrom =  paintPixSel();
     } else {
         if ( mAllDay )
             paintFrom =  paintPixAllday();
         else
             paintFrom =  paintPix();
     }
     bitBlt (this, rx, ry, paintFrom, x()+rx ,yPaintCoord+ry, rw, rh ,CopyROP); 
 }
 void KOAgendaItem::computeText()
 {
  
     mDisplayedText =  mIncidence->summary();
     if ( (mIncidence->type() == "Todo") ) {
         if ( static_cast<Todo*>(mIncidence)->hasDueDate() ) {
             if ( static_cast<Todo*>(mIncidence)->dtDue().date() < QDate::currentDate() )
                 mDisplayedText += i18n(" (") +KGlobal::locale()->formatDate((static_cast<Todo*>(mIncidence))->dtDue().date(), true)+")";
             else if ( !(mIncidence->doesFloat()))
                 mDisplayedText += i18n(" (") +KGlobal::locale()->formatTime((static_cast<Todo*>(mIncidence))->dtDue().time())+")";
         } 
     } else {
         if ( !(mIncidence->doesFloat()) &&  KOPrefs::instance()->mShowTimeInAgenda)
             mDisplayedText += ": " +KGlobal::locale()->formatTime((static_cast<Event*>(mIncidence))->dtStart().time()) + "-" + KGlobal::locale()->formatTime((static_cast<Event*>(mIncidence))->dtEnd().time()) ;
 
         if (  mAllDay ) {
             if ( mIncidence->dtStart().date().addDays(3) < mIncidence->dtEnd().date() ) {
                 mDisplayedText += ": " +KGlobal::locale()->formatDate((static_cast<Event*>(mIncidence))->dtStart().date(), true) + " - " + KGlobal::locale()->formatDate((static_cast<Event*>(mIncidence))->dtEnd().date(), true) ;
             }
         }
 
     }
     
     if ( !mIncidence->location().isEmpty() ) {
         if ( mAllDay )
             mDisplayedText += " (";
         else
             mDisplayedText += "\n(";
         mDisplayedText += mIncidence->location() +")";
     }
 
     QString tipText = mIncidence->summary();
     if ( !mIncidence->doesFloat() ) {
         if ( mIncidence->type() == "Event" ) {
             if ( (static_cast<Event*>(mIncidence))->isMultiDay() ) {
                 tipText += "\n"+i18n("From: ")+mIncidence->dtStartStr();
                 tipText += "\n"+i18n("To: ")+(static_cast<Event*>(mIncidence))->dtEndStr();
             }
             else {
                 tipText += "\n"+i18n("Time: ")+mIncidence->dtStartTimeStr();
                 tipText += " - "+(static_cast<Event*>(mIncidence))->dtEndTimeStr();
             }
         }
         else if ( mIncidence->type() == "Todo" ) {
             if (mIncidence->hasStartDate())
                 tipText += "\n"+i18n("Start: ")+ (static_cast<Todo*>(mIncidence))->dtStartStr();
             if (((Todo*)mIncidence)->hasDueDate())
                 tipText += "\n"+i18n("Due: ")+ (static_cast<Todo*>(mIncidence))->dtDueStr();
         }
     } else if ( mIncidence->type() == "Todo" ) {
             if (mIncidence->hasStartDate())
                 tipText += "\n"+i18n("Start: ")+ (static_cast<Todo*>(mIncidence))->dtStartDateStr();
             if (((Todo*)mIncidence)->hasDueDate())
                 tipText += "\n"+i18n("Due: ")+ (static_cast<Todo*>(mIncidence))->dtDueDateStr();
         }
 
     if (!mIncidence->location().isEmpty()) {
         tipText += "\n"+i18n("Location: ")+mIncidence->location();
     }
     QToolTip::add(this,tipText,toolTipGroup(),""); 
 
 }
 void KOAgendaItem::updateItem()
 {  
     computeText();
      
     //qDebug("KOAgendaItem:: updateItem() %s %d %d ",incidence()->summary().latin1(), x(), y());
     paintMe( mSelected );
     repaint( false);
 }
   
 void KOAgendaItem::resizeEvent ( QResizeEvent *ev )
 {
     //qDebug("KOAgendaItem::resizeEvent %s ",  mIncidence->summary().latin1());
     paintMe( mSelected );
     repaint( false );
 } 
 
 /*
   Return height of item in units of agenda cells
 */
 int KOAgendaItem::cellHeight()
 {
     int ret = mCellYBottom - mCellYTop + 1;
     if ( ret <= 0 ) {
         ret = 1;
         mCellYBottom = 0;
         mCellYTop = 0;
     }
     return ret;
 }
 
 /*
   Return height of item in units of agenda cells
 */
 int KOAgendaItem::cellWidth()
 {
     return mCellXWidth - mCellX + 1;
 }
 
 void KOAgendaItem::setItemDate(QDate qd)
 {
   mDate = qd;
 }
 
 void KOAgendaItem::setCellXY(int X, int YTop, int YBottom)
 {
   mCellX = X;
   mCellYTop = YTop;
   mCellYBottom = YBottom;
 }
 
 void KOAgendaItem::setCellXWidth(int xwidth)
 {
   mCellXWidth = xwidth;
 }
 
 void KOAgendaItem::setCellX(int XLeft, int XRight)
 {
   mCellX = XLeft;
   mCellXWidth = XRight;
 }
 
 void KOAgendaItem::setCellY(int YTop, int YBottom)
 {
   mCellYTop = YTop;
   mCellYBottom = YBottom;
 }
 
 void KOAgendaItem::setSubCell(int subCell)
 {
   mSubCell = subCell;
 }
 
 void KOAgendaItem::setSubCells(int subCells)
 {
   mSubCells = subCells;
 }
 
 void KOAgendaItem::setMultiItem(KOAgendaItem *first,KOAgendaItem *next,
                                 KOAgendaItem *last)
 {
   mFirstMultiItem = first;
   mNextMultiItem = next;
   mLastMultiItem = last;
 }
 
 void KOAgendaItem::startMove()
 {
   mStartCellX = mCellX;
   mStartCellXWidth = mCellXWidth;
   mStartCellYTop = mCellYTop;
   mStartCellYBottom = mCellYBottom;
 }
 
 void KOAgendaItem::resetMove()
 {
   mCellX = mStartCellX;
   mCellXWidth = mStartCellXWidth;
   mCellYTop = mStartCellYTop;
   mCellYBottom = mStartCellYBottom;
 }
 
 void KOAgendaItem::moveRelative(int dx, int dy)
 {
   int newX = cellX() + dx;
   int newXWidth = cellXWidth() + dx;
   int newYTop = cellYTop() + dy;
   int newYBottom = cellYBottom() + dy;
   setCellXY(newX,newYTop,newYBottom);
   setCellXWidth(newXWidth);
 }
 
 void KOAgendaItem::expandTop(int dy)
 {
   int newYTop = cellYTop() + dy;
   int newYBottom = cellYBottom();
   if (newYTop > newYBottom) newYTop = newYBottom;
   setCellY(newYTop, newYBottom);
 }
 
 void KOAgendaItem::expandBottom(int dy)
 {
   int newYTop = cellYTop();
   int newYBottom = cellYBottom() + dy;
   if (newYBottom < newYTop) newYBottom = newYTop;
   setCellY(newYTop, newYBottom);
 }
 
 void KOAgendaItem::expandLeft(int dx)
 {
   int newX = cellX() + dx;
   int newXWidth = cellXWidth();
   if (newX > newXWidth) newX = newXWidth;
   setCellX(newX,newXWidth);
 }
 
 void KOAgendaItem::expandRight(int dx)
 {
   int newX = cellX();
   int newXWidth = cellXWidth() + dx;
   if (newXWidth < newX) newXWidth = newX;
   setCellX(newX,newXWidth);
 }
 
 QToolTipGroup *KOAgendaItem::toolTipGroup()
 {
   if (!mToolTipGroup) mToolTipGroup = new QToolTipGroup(0);
   return mToolTipGroup;
 }
 
 void KOAgendaItem::dragEnterEvent( QDragEnterEvent *e )
 {
 #ifndef KORG_NODND
   if ( ICalDrag::canDecode( e ) || VCalDrag::canDecode( e ) ||
        !QTextDrag::canDecode( e ) ) {
     e->ignore();
     return;
   }
   e->accept();
 #endif
 }
 
 void KOAgendaItem::dropEvent( QDropEvent *e )
 {
 #ifndef KORG_NODND
   QString text;
   if(QTextDrag::decode(e,text))
   {
     kdDebug() << "Dropped : " << text << endl;
     QStringList emails = QStringList::split(",",text);
     for(QStringList::ConstIterator it = emails.begin();it!=emails.end();++it) {
       kdDebug() << " Email: " << (*it) << endl;
       int pos = (*it).find("<");
       QString name = (*it).left(pos);
       QString email = (*it).mid(pos);
       if (!email.isEmpty()) {
         mIncidence->addAttendee(new Attendee(name,email));
       }
     }
   }
 #endif
 }
 
 
 QPtrList<KOAgendaItem> KOAgendaItem::conflictItems()
 {
   return mConflictItems;
 }
 
 void KOAgendaItem::setConflictItems(QPtrList<KOAgendaItem> ci)
 {
   mConflictItems = ci;
   KOAgendaItem *item;
   for ( item=mConflictItems.first(); item != 0;
         item=mConflictItems.next() ) {
     item->addConflictItem(this);
   }
 }
 
 void KOAgendaItem::addConflictItem(KOAgendaItem *ci)
 {
   if (mConflictItems.find(ci)<0)
     mConflictItems.append(ci);
 }