5 files changed, 55 insertions, 3 deletions
diff --git a/bin/kdepim/WhatsNew.txt b/bin/kdepim/WhatsNew.txt
index 683de7c..c0078be 100644
--- a/bin/kdepim/WhatsNew.txt
+++ b/bin/kdepim/WhatsNew.txt
@@ -1,748 +1,755 @@
 Info about the changes in new versions of KDE-Pim/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.
 If KO/Pi or OM/Pi want to get some name/email data, they request KA/Pi to open the  name/email selection dialog and send it back to them.
 If you click on an attendee in a meeting, its contact data is displayed in KA/Pi directly.
 That means, if KO/Pi or OM/Pi want to access contact data, KA/Pi is started first.
 New in the KO/Pi alarm applet:
 Configure your own timer popup menu!
 (Text and minutes for timer countdown)
 Just edit the file
 (yourhomedir)/.kopialarmtimerrc
 and start/stop a timer to get a new menu with the data of this file.
 ********** VERSION 1.9.3 ************
 1)
 Now KO/Pi on Windows imports directly the calendar data of
 an installed Outlook. Should work with OL version >= 2000.
 
 ********** VERSION 1.9.2 ************
 1)
 KDE-Pim/Pi has got a new member:
 KmicroMail (KM/Pi) is a mail program, 
 which can handle IMAP and POP mail access.
 It is based on Opie-Mail v3.
 All dependencies to the Opie libraries ar removed, 
 such that no additional Opie lib is needed.
 It is already integrated in KO/Pi and KA/Pi.
 It it now available for the Zaurus,probably it 
 will be available for other platforms later.
 Hint:
 Create your own contact (name + email)
 in KA/Pi, select this contact and choose menu:
 Settings - Set Who Am I.
 Now the settings of this contact are used as 
 the sender data in KM/Pi.
 2)
 KDE-Pim/Pi is split up in five different
 packages now precompiled for Sharp Zaurus:
 --kmicrokdelibs_1.9.2_arm.ipk
 The libs are needed for any 
 of the following programs:
 --kaddressbook_1.9.2_arm.ipk
 --kmicromail_1.9.2_arm.ipk
 --korganizer_1.9.2_arm.ipk
 Independ from that, there is the alarm applet
 available for KO/Pi, which also offers
 quick access for a new mail or
 showing the addressbook.:
 --korganizer-alarm_1.9.2_arm.ipk
 Independend means, that the alarm applet
 does not need any of the libs or programs above to run.
 But it would be quite useless without these programs.
 NOTE:
 If you get a
 "This application depends on other programs"
 during installation of 
 --kmicrokdelibs_1.9.2_arm.ipk
 you probably do not have to care about that.
 kmicrokdelibs_1.9.2 will come with some
 resource plugins, which needs additional libraries.
 (E.g. libopie1, if you want to use the 
 opie resource connector in KA/Pi).
 If you do not have this libraries installed,
 you simply cannot use the resource.
 To make it clear:
 If the libraries are missing, the applications
 using kmicrokdelibs will start, 
 because the resources are plugins.
 3)
 KO/Pi and friends are now installable on SD-Card!
 It is recommended to install all libs and apps
 on the SD card or all in the internal storage.
 There may be problems, if this is mixed.
 4)
 Fixed two bugs in the alarm notification on Windows.
 5)
 Great improvement!
 KO/Pi uses now the latest version of libical.
 Libical is the library which actually reads 
 the calendar files and extract the data from it.
 With the old version, there were problems
 (crashes or program hangs) when licical did read
 files, which were not stored from KO/Pi.
 I do not know, if the new libical works perfect,
 but actually it works much better than
 the old version.
 There are no problems with compatibility with 
 old calendar files of KO/Pi, of course!
 6)
 New in KA/Pi:
 Opie addressbook resource connector available!
 You will need libopie1 and the opie addressbook,
 of course.
 With the Opie addressbook resource connector,
 you can access the Opie addressbook readonly in KA/Pi.
 If you want to edit or import the data into KA/Pi,
 do this:
 a) Create an Opie resource.
   (Menu: Settings-Configure Resources).
 After configuration and restarting KA/Pi you should see
 the Opie contacts in KA/Pi.
 b) Select some or all Opie contacts.
 (NOTE: +++++
 To know exactly, what contacts are Opie contacts, 
 do this: Choose menu: 
 View-Modify View - TAB Fields.
 Select in the above list "Resource" and click
 down arrow to add it to the "Selected fields".
 Click OK.
 Now you have a new column "Resource" in your list,
 where you can see, what an Opie resource is.
 ++++ NOTE end.)
 Ok, we do have now some Opie contacts seleted.
 (Use SHIFT or CTRL key in order to multiple select).
 c) Choose menu: Edit-Copy.
 d) Choose menu: Edit-Paste.
 e) Select the resource, you want to add the contacts to.
 Congrats! Now you have read/write access to the copied 
 opie contacts as "real" KA/Pi contacts.
 ********** VERSION 1.9.1 ************
 1)
       +++ IMPORTANT 1 +++
 The storing place of the default calendar 
 file has changed!
 The default calendar file was
 Applications/korganizer/mycalendar.ics 
 on Zaurus and 
 (yourHomeDir)/korganizer/mycalendar.ics 
 on Windows/Linux desktop. Now it is
 (yourHomeDir)/kdepim/korganizer/mycalendar.ics
 on Zaurus, Windows and Linux.
 To load the old file, choose menu
 File-Load calendar backup.
 (It should be loaded automatically
 at startup with a warning message displayed).
 The place of the configuration file has changed too.
 If you want to use your old KO/Pi config,
 copy it to 
 (yourHomeDir)/kdepim/config/korganizerrc
 Please read VERSION 1.9.0 - topic 3) as well!
       +++ IMPORTANT 2 +++
 Because of the new paths, you will need
 a new version of the KO/Pi alarm applet
 for Zaurus.
 Use version >= 1.9.1
 2)
 Now the QWhat'sThis Icon works for items
 in the month view as well.
 (See VERSION 1.7.8 Topic 1) ).
 3)
 You can import birtsdays/anniversaries
 from KA/Pi into KO/Pi.
 Choose menu File-Import birthdays.
 If you import twice, already imported items
 will not be imported again, if they 
 have not been changed in KO/Pi.
 4)
 When syncing with sharp DTM, now a progress 
 is shown, when the data is written back.
 If there is much data in KO/Pi and no data
 in DTM, that can take a long time.
 (But only for the first time ).
 5)
 In the search dialog, you can search 
 now for the name/email of an attendee
 of an event/todo.
 To get more space for displaying
 search results, the buttons
 for "search" and "close" on the 
 bottom are removed in the PDA version. 
 You have to click OK in the top right
 corner to do a search.
 6)
 Now it is possible to disable the displaying
 of todo items in the Allday part of the Agenda.
 Choose Menu Action-Configure,
 TAB Todo View, checkbox
 "Allday Agenda view shows todos"
 7)
 If FastLoad is enabled, now the settings and the 
 calendar data are saved, when KO/Pi is closed.
 (If no Fastload is enabled, KO/Pi saves
 the data as well, of course)
 8)
 The Agenda View has a minimize-splitter now,
 such that the height of the allday part can be
 changed quickly.
 ********** VERSION 1.9.0 ************
 1)
 KO/Pi is now merged with the new microKDE from KA/Pi.
 KO/Pi accesses now KA/Pi as the addressbook.
 The other ddressbook-plugins are not working any longer.
 (It is planned, that later KA/Pi itself uses these plugins)
 New versions of KO/Pi are only available
 together with KA/Pi as the KDE-Pim/Pi package. 
 2)
 If you click on an attendee of a meeting in the
 event viewer, a detailed summary of the 
 attendee is shown.
 3)
 The place of the configuration file has changed.
 If you want to use your old KO/Pi config, copy
 Applications/korganizer/config_korganizerrc
 to
 Applications/korganizer/config/korganizerrc
 ********** VERSION 1.7.8 ************
 1)
 Now the QWhat'sThis ist working.
 Enable the QWhat'sThis icon in the toolbar.
 (You have to restart to reload the changed toolbar config).
 Now click on the QWhat'sThis Icon 
 in the top right corner of KO/Pi.
 Then click on an item in the Agenda View:
 You will get a detailed display of the items content.
 2)
 Some other very minor changes.
 But I have forgotten the details ...
 For that reason I start this log here:
 To document my changes, when I am doing it.
 ********** VERSION 1.7.7 ************
 Stable Version of KO/Pi
diff --git a/libkdepim/kcmconfigs/kdepimconfigwidget.cpp b/libkdepim/kcmconfigs/kdepimconfigwidget.cpp
index 20594c6..d097078 100644
--- a/libkdepim/kcmconfigs/kdepimconfigwidget.cpp
+++ b/libkdepim/kcmconfigs/kdepimconfigwidget.cpp
@@ -1,799 +1,837 @@
 /*
    This file is part of KdePim/Pi.
    Copyright (c) 2004 Ulf Schenk
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    As a special exception, permission is given to link this program
    with any edition of Qt, and distribute the resulting executable,
    without including the source code for Qt in the source distribution.
 */
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 $Id$
 */
 #include <qlayout.h>
 #include <qtabwidget.h>
 #include <qcombobox.h>
 #include <qgroupbox.h>
 #include <qlabel.h>
 #include <qlineedit.h>
 #include <qbuttongroup.h>
 #include <qfile.h>
+#include <qvbox.h>
+#include <qdir.h>
 #include <qregexp.h>
 #include <kdialog.h>
 #include <klocale.h>
 #include <kdateedit.h>
 #include <kglobal.h>
 #include <stdlib.h>
 /*US
 #include <qcheckbox.h>
 #include <qframe.h>
 #include <qpushbutton.h>
 #include <qcombobox.h>
 #include <qlineedit.h>
 #include <qlabel.h>
 #include <qfile.h>
 #include <kconfig.h>
 #include <kdebug.h>
 #include <kdialog.h>
 #include <klistview.h>
 #include <klocale.h>
 #include <kglobal.h>
 #include <kmessagebox.h>
 #include <kstandarddirs.h>
 #ifndef KAB_EMBEDDED
 #include <ktrader.h>
 #else // KAB_EMBEDDED
 #include <mergewidget.h>
 #include <distributionlistwidget.h>
 #endif // KAB_EMBEDDED
 #include "addresseewidget.h"
 #include "extensionconfigdialog.h"
 #include "extensionwidget.h"
 */
 #include "qapplication.h"
 #include "kpimglobalprefs.h"
 #include "kdepimconfigwidget.h"
 KDEPIMConfigWidget::KDEPIMConfigWidget(KPimGlobalPrefs *prefs, QWidget *parent, const char *name )
  : KPrefsWidget(prefs, parent, name )
 {
  mExternalAppsMap.insert(ExternalAppHandler::EMAIL, i18n("Email"));
  mExternalAppsMap.insert(ExternalAppHandler::PHONE, i18n("Phone"));
  mExternalAppsMap.insert(ExternalAppHandler::SMS, i18n("SMS"));
  mExternalAppsMap.insert(ExternalAppHandler::FAX, i18n("Fax"));
  mExternalAppsMap.insert(ExternalAppHandler::PAGER, i18n("Pager"));
  mExternalAppsMap.insert(ExternalAppHandler::SIP, i18n("SIP"));
  QVBoxLayout *topLayout = new QVBoxLayout( this, 0,
                                            KDialog::spacingHint() );
  tabWidget = new QTabWidget( this );
  topLayout->addWidget( tabWidget );
  setupLocaleTab();
  setupLocaleDateTab();
  setupTimeZoneTab();
  setupExternalAppTab();
+  setupStoreTab();
 }
 void KDEPIMConfigWidget::showTimeZoneTab()
 {
    tabWidget->setCurrentPage ( 3 ) ;
 }
+void KDEPIMConfigWidget::setupStoreTab()
+{
+    QVBox *storePage = new QVBox( this );
+    new QLabel( i18n("Your current storage dir is:\n%1\nYour mail is stored in:\n(storagedir)/apps/kopiemail/localmail").arg(KGlobal::dirs()->localkdedir()), storePage  );
+    new QLabel( i18n("<b>Set new data storage dir:</b>"), storePage );
+    mStoreUrl = new KURLRequester( storePage );
+    mStoreUrl->setURL( KGlobal::dirs()->localkdedir() );
+    new QLabel( i18n("Not existing dirs are created automatically"), storePage  );
+    QHBox *bb = new QHBox( storePage );
+    QPushButton * pb = new QPushButton ( i18n("Save settings"), bb  );
+    connect(pb, SIGNAL( clicked() ), this, SLOT ( saveStoreSettings() ) );
+    pb = new QPushButton ( i18n("Save standard"), bb  );
+    connect(pb, SIGNAL( clicked() ), this, SLOT ( setStandardStore() ) );
+    new QLabel( i18n("<b>New settings are used\nafter a restart</b>"), storePage );
+    new QLabel( i18n("The settings of the storage\ndir is saved in the file\n%1").arg(QDir::homeDirPath() + "/.microkdehome" ), storePage  );
+    tabWidget->addTab( storePage, i18n( "Data storage path" ) );
+}
+void KDEPIMConfigWidget::setStandardStore()
+{
+    mStoreUrl->setURL(  QDir::homeDirPath() + "/kdepim"  );
+    saveStoreSettings();
+}
+void KDEPIMConfigWidget::saveStoreSettings()
+{
+    if ( !mStoreUrl->url().isEmpty() ) {
+        KConfig cfg (   QDir::homeDirPath() + "/.microkdehome" );
+        cfg.setGroup("Global");
+        cfg.writeEntry( "MICROKDEHOME", mStoreUrl->url() ); 
+        qDebug("cfg.writeEntry( MICROKDEHOME, mStoreUrl->url() );  ");
+        cfg.sync();
+    } else {
+        mStoreUrl->setURL(  QDir::homeDirPath() + "/kdepim"  );
+        saveStoreSettings();
+    }
+}
 void KDEPIMConfigWidget::setupExternalAppTab()
 {
  QWidget *externalAppsPage = new QWidget( this );
  QVBoxLayout* layout = new QVBoxLayout( externalAppsPage, KDialog::marginHintSmall(),
                                            KDialog::spacingHintSmall() );
  mExternalApps = new QComboBox( externalAppsPage );
  QMap<ExternalAppHandler::Types, QString>::Iterator it;
  for( it = mExternalAppsMap.begin(); it != mExternalAppsMap.end(); ++it )
    mExternalApps->insertItem( it.data(), it.key() );
  layout->addWidget( mExternalApps );
  connect( mExternalApps, SIGNAL( activated( int ) ),
           this, SLOT (externalapp_changed( int ) ) );
  mExternalAppGroupBox = new QGroupBox( 0, Qt::Vertical, i18n( "Used Mail Client" ), externalAppsPage );
  QGridLayout *boxLayout = new QGridLayout( mExternalAppGroupBox->layout(), 4, 2,    -1, "gridlayout" );
  mExternalAppGroupBox->layout()->setMargin(5);
  mClient = new QComboBox( mExternalAppGroupBox );
  boxLayout->addMultiCellWidget( mClient, 0, 0, 0, 1 );
  connect( mClient, SIGNAL( activated( int ) ),
           this, SLOT (client_changed( int ) ) );
  QLabel* lab = new QLabel( i18n("Channel:"), mExternalAppGroupBox);
  boxLayout->addWidget( lab, 1, 0 );
  mChannel = new QLineEdit(mExternalAppGroupBox);
  mChannel->setReadOnly(true);
  boxLayout->addMultiCellWidget( mChannel, 2 , 2, 0, 1 );
  lab = new QLabel( i18n("Message:"), mExternalAppGroupBox);
  boxLayout->addWidget( lab, 3, 0 );
  mMessage = new QLineEdit(mExternalAppGroupBox);
  mMessage->setReadOnly(true);
  boxLayout->addWidget( mMessage , 4, 0);
  lab = new QLabel( i18n("Parameters:"), mExternalAppGroupBox);
  boxLayout->addWidget( lab, 3, 1 );
  mParameters = new QLineEdit(mExternalAppGroupBox);
  mParameters->setReadOnly(true);
  boxLayout->addWidget( mParameters, 4, 1 );
  lab = new QLabel( i18n("HINT: Delimiter=; Name=%1,Email=%2"), mExternalAppGroupBox);
  boxLayout->addMultiCellWidget( lab, 5, 5, 0, 1 );
  lab = new QLabel( i18n("extra Message:"), mExternalAppGroupBox);
  boxLayout->addWidget( lab, 6, 0 );
  mMessage2 = new QLineEdit(mExternalAppGroupBox);
  mMessage2->setReadOnly(true);
  boxLayout->addWidget( mMessage2 , 7, 0);
  lab = new QLabel( i18n("extra Parameters:"), mExternalAppGroupBox);
  boxLayout->addWidget( lab, 6, 1 );
  mParameters2 = new QLineEdit(mExternalAppGroupBox);
  mParameters2->setReadOnly(true);
  boxLayout->addWidget( mParameters2, 7, 1 );
  lab = new QLabel( i18n("HINT: Emails=%1,Attachments=%2"), mExternalAppGroupBox);
  boxLayout->addMultiCellWidget( lab, 8, 8, 0, 1 );
  connect( mChannel, SIGNAL( textChanged ( const QString & )), this, SLOT( textChanged ( const QString & ))  );
  connect( mMessage, SIGNAL( textChanged ( const QString & )), this, SLOT( textChanged ( const QString & ))  );
  connect( mParameters, SIGNAL( textChanged ( const QString & )), this, SLOT( textChanged ( const QString & ))  );
  connect( mMessage2, SIGNAL( textChanged ( const QString & )), this, SLOT( textChanged ( const QString & ))  );
  connect( mParameters2, SIGNAL( textChanged ( const QString & )), this, SLOT( textChanged ( const QString & ))  );
  layout->addWidget( mExternalAppGroupBox );
  tabWidget->addTab( externalAppsPage, i18n( "External Apps." ) );
 }
  
 void KDEPIMConfigWidget::setupLocaleDateTab()
 {
  QWidget *topFrame = new QWidget( this );
  QGridLayout *topLayout = new QGridLayout( topFrame, 3, 2);
   topLayout->setSpacing(KDialog::spacingHintSmall());
   topLayout->setMargin(KDialog::marginHintSmall());  
   int iii = 0;
   
   KPrefsWidRadios *syncPrefsGroup =
       addWidRadios(i18n("Date Format:"),&(KPimGlobalPrefs::instance()->mPreferredDate),topFrame);
   QString format;
   if ( QApplication::desktop()->width() < 480 )
       format = "(%d.%m.%Y)";
   else 
       format = "(%d.%m.%Y|%A %d %B %Y)";
   syncPrefsGroup->addRadio(i18n("24.03.2004 "+format));
   if ( QApplication::desktop()->width() < 480 )
       format = "(%m.%d.%Y)";
   else 
       format = "(%m.%d.%Y|%A %B %d %Y)";
   syncPrefsGroup->addRadio(i18n("03.24.2004 "+format));
   if ( QApplication::desktop()->width() < 480 )
       format = "(%Y-%m-%d)";
   else 
       format = "(%Y-%m-%d|%A %Y %B %d)";
   syncPrefsGroup->addRadio(i18n("2004-03-24 "+format));
   syncPrefsGroup->addRadio(i18n("User defined"));
   if ( QApplication::desktop()->width() < 480 ) {
       syncPrefsGroup->groupBox()->layout()->setMargin( 5 );
       syncPrefsGroup->groupBox()->layout()->setSpacing( 0 );
   }  
   topLayout->addMultiCellWidget( (QWidget*)syncPrefsGroup->groupBox(),iii,iii,0,1);
   ++iii;   
   ++iii;
   QLabel * lab;
   mUserDateFormatLong = new QLineEdit(topFrame);
   lab = new QLabel(mUserDateFormatLong, i18n("User long date:"), topFrame);
   topLayout->addWidget(lab ,iii,0);
   topLayout->addWidget(mUserDateFormatLong,iii,1);
   ++iii;
   mUserDateFormatShort = new QLineEdit(topFrame);
   lab = new QLabel(mUserDateFormatShort, i18n("User short date:"), topFrame);
   topLayout->addWidget(lab ,iii,0);
   topLayout->addWidget(mUserDateFormatShort,iii,1);
   ++iii;
   lab = new QLabel( i18n("Monday 19 April 2004: %A %d %B %Y"), topFrame);
   topLayout->addMultiCellWidget(lab ,iii,iii,0,1);
   ++iii;
   lab = new QLabel( i18n("Mon 19.04.04: %a %d.%m.%y"), topFrame);
   topLayout->addMultiCellWidget(lab ,iii,iii,0,1);
   ++iii;  
   lab = new QLabel( i18n("Mon, 19.Apr.04: %a, %d.%b.%y"), topFrame);
   topLayout->addMultiCellWidget(lab ,iii,iii,0,1);
   ++iii;
  connect( mUserDateFormatLong, SIGNAL( textChanged ( const QString & )), this, SLOT( textChanged ( const QString & ))  );
  connect( mUserDateFormatShort, SIGNAL( textChanged ( const QString & )), this, SLOT( textChanged ( const QString & ))  );
   tabWidget->addTab( topFrame, i18n( "Date Format" ) );
 }
 void KDEPIMConfigWidget::setupLocaleTab()
 {
  QWidget *topFrame = new QWidget( this );
   QGridLayout *topLayout = new QGridLayout(topFrame,4,2);
   topLayout->setSpacing(KDialog::spacingHint());
   topLayout->setMargin(KDialog::marginHint());  
   int iii = 0;
 KPrefsWidRadios *syncPrefsGroup =
      addWidRadios(i18n("Language:(needs restart)"),&(KPimGlobalPrefs::instance()->mPreferredLanguage),topFrame);
   syncPrefsGroup->addRadio(i18n("English"));
   syncPrefsGroup->addRadio(i18n("German")); 
   syncPrefsGroup->addRadio(i18n("French")); 
   syncPrefsGroup->addRadio(i18n("Italian")); 
   syncPrefsGroup->addRadio(i18n("User defined (usertranslation.txt)")); 
   if (  QApplication::desktop()->width() <  300   ) {
       syncPrefsGroup->groupBox()->layout()->setMargin( 5 );
       syncPrefsGroup->groupBox()->layout()->setSpacing( 0 );
   }
   topLayout->addMultiCellWidget( (QWidget*)syncPrefsGroup->groupBox(),iii,iii,0,1);
   ++iii;   
 
   tabWidget->addTab( topFrame, i18n( "Language" ) );
   topFrame = new QWidget( this );
   topLayout = new QGridLayout(topFrame,4,2);
   
   topLayout->setSpacing(KDialog::spacingHint());
   topLayout->setMargin(KDialog::marginHint());  
   iii = 0;
   syncPrefsGroup =
       addWidRadios(i18n("Time Format(nr):"),&(KPimGlobalPrefs::instance()->mPreferredTime),topFrame);
   if (  QApplication::desktop()->width() >  300   )
       syncPrefsGroup->groupBox()->setOrientation (Qt::Vertical);
   syncPrefsGroup->addRadio(i18n("24:00"));
   syncPrefsGroup->addRadio(i18n("12:00am"));
   syncPrefsGroup->groupBox()->setOrientation (Qt::Vertical);
   topLayout->addMultiCellWidget( syncPrefsGroup->groupBox(),iii,iii,0,1);
   ++iii;   
   KPrefsWidBool *sb = addWidBool(i18n("Week starts on Sunday"),
                      &(KPimGlobalPrefs::instance()->mWeekStartsOnSunday),topFrame);
   topLayout->addMultiCellWidget((QWidget*)sb->checkBox(), iii,iii,0,1);
   ++iii;   
   tabWidget->addTab( topFrame, i18n( "Time Format" ) );
 }
 void KDEPIMConfigWidget::setupTimeZoneTab()
 {
  QWidget *topFrame = new QWidget( this );
  QGridLayout *topLayout = new QGridLayout( topFrame, 5, 2);
  topLayout->setSpacing(KDialog::spacingHintSmall());
  topLayout->setMargin(KDialog::marginHintSmall());
  QHBox *timeZoneBox = new QHBox( topFrame );
  topLayout->addMultiCellWidget( timeZoneBox, 0, 0, 0, 1 );
  new QLabel( i18n("Timezone:"), timeZoneBox );
  mTimeZoneCombo = new QComboBox( timeZoneBox ); 
  if ( QApplication::desktop()->width() <  300 ) {
       mTimeZoneCombo->setMaximumWidth(150);
    }
  QStringList list;
  list = KGlobal::locale()->timeZoneList();
  mTimeZoneCombo->insertStringList(list);
    // find the currently set time zone and select it
  QString sCurrentlySet = KPimGlobalPrefs::instance()->mTimeZoneId;
  int nCurrentlySet = 11;
  for (int i = 0; i < mTimeZoneCombo->count(); i++)
    {
      if (mTimeZoneCombo->text(i) == sCurrentlySet)
        {
         nCurrentlySet = i;
         break;
        }
    }
  mTimeZoneCombo->setCurrentItem(nCurrentlySet);
  int iii = 1;
  KPrefsWidBool *sb =
      addWidBool(i18n("Add 30 min to selected Timezone"),
                 &(KPimGlobalPrefs::instance()->mTimeZoneAdd30min),topFrame);
  topLayout->addMultiCellWidget((QWidget*)sb->checkBox(), iii,iii,0,1);
  ++iii;  
  sb =
      addWidBool(i18n("Timezone has daylight saving"),
                 &(KPimGlobalPrefs::instance()->mUseDaylightsaving),topFrame);
  topLayout->addMultiCellWidget((QWidget*)sb->checkBox(), iii,iii,0,1);
  ++iii; 
  QLabel* lab; 
  lab = new QLabel(  i18n("Actual start and end is the\nsunday before this date."), topFrame );
  topLayout->addMultiCellWidget(lab, iii,iii,0,1);
  ++iii;
 
  lab = new QLabel(  i18n("The year in the date is ignored."), topFrame );
  topLayout->addMultiCellWidget(lab, iii,iii,0,1);
  ++iii; 
  lab = new QLabel(  i18n("Daylight start:"), topFrame );
  topLayout->addWidget(lab, iii,0);
  mStartDateSavingEdit = new KDateEdit(topFrame);
  topLayout->addWidget(mStartDateSavingEdit, iii,1);
  ++iii;
  lab = new QLabel(  i18n("Daylight end:"), topFrame );
  topLayout->addWidget(lab, iii,0);
  mEndDateSavingEdit = new KDateEdit(topFrame);
  topLayout->addWidget(mEndDateSavingEdit, iii,1);
  ++iii;
  QDate current ( 2001, 1,1);
  mStartDateSavingEdit->setDate(current.addDays(KPimGlobalPrefs::instance()->mDaylightsavingStart-1));
  mEndDateSavingEdit->setDate(current.addDays(KPimGlobalPrefs::instance()->mDaylightsavingEnd-1));
  connect( mStartDateSavingEdit, SIGNAL(  dateChanged(QDate)), this, SLOT( modified())  );
  connect( mEndDateSavingEdit, SIGNAL(  dateChanged(QDate)), this, SLOT( modified())  );
  connect( mTimeZoneCombo, SIGNAL( activated( int ) ), this, SLOT (modified() ) );
  tabWidget->addTab( topFrame, i18n( "Time Zone" ) );
 
 }
 void KDEPIMConfigWidget::externalapp_changed( int newApp )
 {
  // first store the current data
  saveEditFieldSettings();
  // set mCurrentApp
  mCurrentApp = (ExternalAppHandler::Types)newApp;
  // set mCurrentClient
  switch(mCurrentApp)
  {
    case(ExternalAppHandler::EMAIL):
      mCurrentClient = mEmailClient;
      break;
    case(ExternalAppHandler::PHONE):
      mCurrentClient = mPhoneClient;
      break;
    case(ExternalAppHandler::SMS):
      mCurrentClient = mSMSClient;
      break;
    case(ExternalAppHandler::FAX):
      mCurrentClient = mFaxClient;
      break;
    case(ExternalAppHandler::PAGER):
      mCurrentClient = mPagerClient;
      break;
    case(ExternalAppHandler::SIP):
      mCurrentClient = mSipClient;
      break;
    default:
      return;
  }
  // and at last update the widgets
  updateClientWidgets();
 }
 void KDEPIMConfigWidget::client_changed( int newClient )
 {
  if (newClient == mCurrentClient)
    return;
  // first store the current data
  saveEditFieldSettings();
  //then reset the clientvariable
  mCurrentClient = newClient;
  // and at last update the widgets
  updateClientWidgets();
  KPrefsWidget::modified();
 }
 void KDEPIMConfigWidget::saveEditFieldSettings()
 {
  switch(mCurrentApp)
  {
    case(ExternalAppHandler::EMAIL):
      mEmailClient = mClient->currentItem();
      break;
    case(ExternalAppHandler::PHONE):
      mPhoneClient= mClient->currentItem();
      break;
    case(ExternalAppHandler::SMS):
      mSMSClient = mClient->currentItem();
      break;
    case(ExternalAppHandler::FAX):
      mFaxClient = mClient->currentItem();
      break;
    case(ExternalAppHandler::PAGER):
      mPagerClient = mClient->currentItem();
      break;
    case(ExternalAppHandler::SIP):
      mSipClient = mClient->currentItem();
      break;
    default:
      return;
  }
  //store the current data back to the apropriate membervariables if we had set it to "other"
  if ((mCurrentApp == ExternalAppHandler::EMAIL) && (mCurrentClient == KPimGlobalPrefs::OTHER_EMC))
  {
    mEmailOtherChannel = mChannel->text();
    mEmailOtherMessage = mMessage->text();
    mEmailOtherMessageParameters = mParameters->text();
    mEmailOtherMessage2 = mMessage2->text();
    mEmailOtherMessageParameters2 = mParameters2->text();
  }
  else if ((mCurrentApp == ExternalAppHandler::PHONE) && (mCurrentClient == KPimGlobalPrefs::OTHER_PHC))
  {
    mPhoneOtherChannel = mChannel->text();
    mPhoneOtherMessage = mMessage->text();
    mPhoneOtherMessageParameters = mParameters->text();
  }
  else if ((mCurrentApp == ExternalAppHandler::SMS) && (mCurrentClient == KPimGlobalPrefs::OTHER_SMC))
  {
    mSMSOtherChannel = mChannel->text();
    mSMSOtherMessage = mMessage->text();
    mSMSOtherMessageParameters = mParameters->text();
  }
  else if ((mCurrentApp == ExternalAppHandler::FAX) && (mCurrentClient == KPimGlobalPrefs::OTHER_FAC))
  {
    mFaxOtherChannel = mChannel->text();
    mFaxOtherMessage = mMessage->text();
    mFaxOtherMessageParameters = mParameters->text();
  }
  else if ((mCurrentApp == ExternalAppHandler::PAGER) && (mCurrentClient == KPimGlobalPrefs::OTHER_PAC))
  {
    mPagerOtherChannel = mChannel->text();
    mPagerOtherMessage = mMessage->text();
    mPagerOtherMessageParameters = mParameters->text();
  }
  else if ((mCurrentApp == ExternalAppHandler::SIP) && (mCurrentClient == KPimGlobalPrefs::OTHER_SIC))
  {
    mSipOtherChannel = mChannel->text();
    mSipOtherMessage = mMessage->text();
    mSipOtherMessageParameters = mParameters->text();
  }
 }
 void KDEPIMConfigWidget::updateClientWidgets()
 {
  bool blocked = signalsBlocked();
  blockSignals( true );
  // at this point we assume, that mCurrentApp and mCurrentClient are set to the values that we want to display
  QMap<ExternalAppHandler::Types, QString>::Iterator it = mExternalAppsMap.find ( mCurrentApp );
  if (it == mExternalAppsMap.end())
    return;
  // update group box
  mExternalAppGroupBox->setTitle(i18n( "Used %1 Client" ).arg(it.data()));
  //update the entries in the client combobox
  mClient->clear();
  QList<DefaultAppItem> items = ExternalAppHandler::instance()->getAvailableDefaultItems(mCurrentApp);
  DefaultAppItem* dai;
  for ( dai=items.first(); dai != 0; dai=items.next() )
  {
    mClient->insertItem( i18n(dai->_label), dai->_id );
    if (dai->_id == mCurrentClient)
    {
      //restore the edit fields with the data of the local membervariables if we had set it to "other".
      //Otherwise take the default data from externalapphandler.
      mChannel->setText(dai->_channel);
      mMessage->setText(dai->_message);
      mParameters->setText(dai->_parameters);
      mMessage2->setText(dai->_message2);
      mParameters2->setText(dai->_parameters2);
      if ((mCurrentApp == ExternalAppHandler::EMAIL) && (mCurrentClient == KPimGlobalPrefs::OTHER_EMC))
      {
        mChannel->setText(mEmailOtherChannel);
        mMessage->setText(mEmailOtherMessage);
        mParameters->setText(mEmailOtherMessageParameters);
        mMessage2->setText(mEmailOtherMessage2);
        mParameters2->setText(mEmailOtherMessageParameters2);
      }
      else if ((mCurrentApp == ExternalAppHandler::PHONE) && (mCurrentClient == KPimGlobalPrefs::OTHER_PHC))
      {
        mChannel->setText(mPhoneOtherChannel);
        mMessage->setText(mPhoneOtherMessage);
        mParameters->setText(mPhoneOtherMessageParameters);
      }
      else if ((mCurrentApp == ExternalAppHandler::SMS) && (mCurrentClient == KPimGlobalPrefs::OTHER_SMC))
      {
        mChannel->setText(mSMSOtherChannel);
        mMessage->setText(mSMSOtherMessage);
        mParameters->setText(mSMSOtherMessageParameters);
      }
      else if ((mCurrentApp == ExternalAppHandler::FAX) && (mCurrentClient == KPimGlobalPrefs::OTHER_FAC))
      {
        mChannel->setText(mFaxOtherChannel);
        mMessage->setText(mFaxOtherMessage);
        mParameters->setText(mFaxOtherMessageParameters);
      }
      else if ((mCurrentApp == ExternalAppHandler::PAGER) && (mCurrentClient == KPimGlobalPrefs::OTHER_PAC))
      {
        mChannel->setText(mPagerOtherChannel);
        mMessage->setText(mPagerOtherMessage);
        mParameters->setText(mPagerOtherMessageParameters);
      }
      else if ((mCurrentApp == ExternalAppHandler::SIP) && (mCurrentClient == KPimGlobalPrefs::OTHER_SIC))
      {
        mChannel->setText(mSipOtherChannel);
        mMessage->setText(mSipOtherMessage);
        mParameters->setText(mSipOtherMessageParameters);
      }
    }
  }
  bool readonly;
  bool enabled;
  if ( ((mCurrentApp == ExternalAppHandler::EMAIL) && (mCurrentClient == KPimGlobalPrefs::OTHER_EMC))
     ||((mCurrentApp == ExternalAppHandler::PHONE) && (mCurrentClient == KPimGlobalPrefs::OTHER_PHC))
     ||((mCurrentApp == ExternalAppHandler::SMS) && (mCurrentClient == KPimGlobalPrefs::OTHER_SMC))
     ||((mCurrentApp == ExternalAppHandler::FAX) && (mCurrentClient == KPimGlobalPrefs::OTHER_FAC))
     ||((mCurrentApp == ExternalAppHandler::PAGER) && (mCurrentClient == KPimGlobalPrefs::OTHER_PAC))
     ||((mCurrentApp == ExternalAppHandler::SIP) && (mCurrentClient == KPimGlobalPrefs::OTHER_SIC)))
     {
       readonly = false;
         }
         else
         {
       readonly = true;
         }
  if ( ((mCurrentApp == ExternalAppHandler::EMAIL) && (mCurrentClient == KPimGlobalPrefs::NONE_EMC))
     ||((mCurrentApp == ExternalAppHandler::PHONE) && (mCurrentClient == KPimGlobalPrefs::NONE_PHC))
     ||((mCurrentApp == ExternalAppHandler::SMS) && (mCurrentClient == KPimGlobalPrefs::NONE_SMC))
     ||((mCurrentApp == ExternalAppHandler::FAX) && (mCurrentClient == KPimGlobalPrefs::NONE_FAC))
     ||((mCurrentApp == ExternalAppHandler::PAGER) && (mCurrentClient == KPimGlobalPrefs::NONE_PAC))
     ||((mCurrentApp == ExternalAppHandler::SIP) && (mCurrentClient == KPimGlobalPrefs::NONE_SIC)))
     {
       enabled = false;
         }
         else
         {
       enabled = true;
         }
  mChannel->setReadOnly(readonly);
  mMessage->setReadOnly(readonly);
  mParameters->setReadOnly(readonly);
  mMessage2->setReadOnly(readonly);
  mParameters2->setReadOnly(readonly);
  mChannel->setEnabled(enabled);
  mMessage->setEnabled(enabled);
  mParameters->setEnabled(enabled);
  mMessage2->setEnabled(enabled);
  mParameters2->setEnabled(enabled);
  mClient->setCurrentItem(mCurrentClient);
  // enable/disable the extra message/parameter field
  if (mCurrentApp == ExternalAppHandler::EMAIL)
  {
  }
  else
  {
    mMessage2->setText( "" );
    mParameters2->setText( "" );
  }
  if (enabled == true) {
    mMessage2->setEnabled(mCurrentApp == ExternalAppHandler::EMAIL);
    mParameters2->setEnabled(mCurrentApp == ExternalAppHandler::EMAIL);
  }
  blockSignals( blocked );
 }
 void KDEPIMConfigWidget::usrReadConfig()
 {
  KPimGlobalPrefs* prefs = KPimGlobalPrefs::instance();
  bool blocked = signalsBlocked();
  blockSignals( true );
  QString dummy = prefs->mUserDateFormatLong;
  mUserDateFormatLong->setText(dummy.replace( QRegExp("K"), QString(",") ));
  dummy = prefs->mUserDateFormatShort;
  mUserDateFormatShort->setText(dummy.replace( QRegExp("K"), QString(",") ));
  QDate current ( 2001, 1,1);
  mStartDateSavingEdit->setDate(current.addDays(prefs->mDaylightsavingStart-1));
  mEndDateSavingEdit->setDate(current.addDays(prefs->mDaylightsavingEnd-1));
  setCombo(mTimeZoneCombo,i18n(prefs->mTimeZoneId));
  mEmailClient = prefs->mEmailClient;
  mEmailOtherChannel = prefs->mEmailOtherChannel;
  mEmailOtherMessage = prefs->mEmailOtherMessage;
  mEmailOtherMessageParameters = prefs->mEmailOtherMessageParameters;
  mEmailOtherMessage2 = prefs->mEmailOtherMessage2;
  mEmailOtherMessageParameters2 = prefs->mEmailOtherMessageParameters2;
  mPhoneClient = prefs->mPhoneClient;
  mPhoneOtherChannel = prefs->mPhoneOtherChannel;
  mPhoneOtherMessage = prefs->mPhoneOtherMessage;
  mPhoneOtherMessageParameters = prefs->mPhoneOtherMessageParameters;
  mFaxClient = prefs->mFaxClient;
  mFaxOtherChannel = prefs->mFaxOtherChannel;
  mFaxOtherMessage = prefs->mFaxOtherMessage;
  mFaxOtherMessageParameters = prefs->mFaxOtherMessageParameters;
  mSMSClient = prefs->mSMSClient;
  mSMSOtherChannel = prefs->mSMSOtherChannel;
  mSMSOtherMessage = prefs->mSMSOtherMessage;
  mSMSOtherMessageParameters = prefs->mSMSOtherMessageParameters;
  mPagerClient = prefs->mPagerClient;
  mPagerOtherChannel = prefs->mPagerOtherChannel;
  mPagerOtherMessage = prefs->mPagerOtherMessage;
  mPagerOtherMessageParameters = prefs->mPagerOtherMessageParameters;
  mSipClient = prefs->mSipClient;
  mSipOtherChannel = prefs->mSipOtherChannel;
  mSipOtherMessage = prefs->mSipOtherMessage;
  mSipOtherMessageParameters = prefs->mSipOtherMessageParameters;
  mCurrentApp = ExternalAppHandler::EMAIL;
  mCurrentClient = mEmailClient;
  updateClientWidgets();
  blockSignals( blocked );
 }
 void KDEPIMConfigWidget::usrWriteConfig()
 {
  KPimGlobalPrefs* prefs = KPimGlobalPrefs::instance();
  saveEditFieldSettings();
  prefs->mUserDateFormatShort = mUserDateFormatShort->text().replace( QRegExp(","), QString("K") );
  prefs->mUserDateFormatLong = mUserDateFormatLong->text().replace( QRegExp(","), QString("K") );
  prefs->mTimeZoneId = mTimeZoneCombo->currentText();
  QDate date;
  date = mStartDateSavingEdit->date();
  int sub = 0;
  if ( QDate::leapYear( date.year() ) && date.dayOfYear() > 59 )
      sub = 1;
  prefs->mDaylightsavingStart = date.dayOfYear()-sub;
  date = mEndDateSavingEdit->date();
  if ( QDate::leapYear( date.year() ) && date.dayOfYear() > 59  )
      sub = 1;
  else 
      sub = 0;
  prefs->mDaylightsavingEnd = date.dayOfYear()-sub;
  prefs->mEmailClient = mEmailClient;
  prefs->mEmailOtherChannel = mEmailOtherChannel;
  prefs->mEmailOtherMessage = mEmailOtherMessage;
  prefs->mEmailOtherMessageParameters = mEmailOtherMessageParameters;
  prefs->mEmailOtherMessage2 = mEmailOtherMessage2;
  prefs->mEmailOtherMessageParameters2 = mEmailOtherMessageParameters2;
  prefs->mPhoneClient = mPhoneClient;
  prefs->mPhoneOtherChannel = mPhoneOtherChannel;
  prefs->mPhoneOtherMessage = mPhoneOtherMessage;
  prefs->mPhoneOtherMessageParameters = mPhoneOtherMessageParameters;
  prefs->mFaxClient = mFaxClient;
  prefs->mFaxOtherChannel = mFaxOtherChannel;
  prefs->mFaxOtherMessage = mFaxOtherMessage;
  prefs->mFaxOtherMessageParameters = mFaxOtherMessageParameters;
  prefs->mSMSClient = mSMSClient;
  prefs->mSMSOtherChannel = mSMSOtherChannel;
  prefs->mSMSOtherMessage = mSMSOtherMessage;
  prefs->mSMSOtherMessageParameters = mSMSOtherMessageParameters;
  prefs->mPagerClient = mPagerClient;
  prefs->mPagerOtherChannel = mPagerOtherChannel;
  prefs->mPagerOtherMessage = mPagerOtherMessage;
  prefs->mPagerOtherMessageParameters = mPagerOtherMessageParameters;
  prefs->mSipClient = mSipClient;
  prefs->mSipOtherChannel = mSipOtherChannel;
  prefs->mSipOtherMessage = mSipOtherMessage;
  prefs->mSipOtherMessageParameters = mSipOtherMessageParameters;
  //release the cache that other views can access the changed values instantanious
  ExternalAppHandler::instance()->loadConfig();
  KPimGlobalPrefs::instance()->setGlobalConfig();
 }
 void KDEPIMConfigWidget::setCombo(QComboBox *combo, const QString & text,
                               const QStringList *tags)
 {
  if (tags) {
    int i = tags->findIndex(text);
    if (i > 0) combo->setCurrentItem(i);
  } else {
    for(int i=0;i<combo->count();++i) {
      if (combo->text(i) == text) {
        combo->setCurrentItem(i);
        break;
      }
    }
  }
 }
 void KDEPIMConfigWidget::textChanged( const QString& text )
 {
  emit changed( true );
 }
diff --git a/libkdepim/kcmconfigs/kdepimconfigwidget.h b/libkdepim/kcmconfigs/kdepimconfigwidget.h
index 619f3d7..c545207 100644
--- a/libkdepim/kcmconfigs/kdepimconfigwidget.h
+++ b/libkdepim/kcmconfigs/kdepimconfigwidget.h
@@ -1,155 +1,160 @@
 /*
    This file is part of KDEPim/Pi.
    Copyright (c) 2004 Ulf Schenk
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    As a special exception, permission is given to link this program
    with any edition of Qt, and distribute the resulting executable,
    without including the source code for Qt in the source distribution.
 */
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 $Id$
 */
 #ifndef KDEPIMCONFIGWIDGET_H
 #define KDEPIMCONFIGWIDGET_H
 #include <kprefswidget.h>
+#include <kio/kfile/kurlrequester.h>
 #include <qmap.h>
 #include "externalapphandler.h"
 class QComboBox;
 class QLineEdit;
 class KPimGlobalPrefs;
 class QGroupBox;
 class QTabWidget;
 class KDateEdit;
 class KDEPIMConfigWidget : public KPrefsWidget
 {
  Q_OBJECT
  public:
    KDEPIMConfigWidget(KPimGlobalPrefs *prefs, QWidget *parent, const char *name = 0 );
  public slots:
    void textChanged( const QString& text );
    void showTimeZoneTab();
  protected:
    /** Implement this to read custom configuration widgets. */
  virtual void usrReadConfig();
    /** Implement this to write custom configuration widgets. */
  virtual void usrWriteConfig();
  private slots:
 //    void configureExtension();
 //    void selectionChanged( QListViewItem* );
 //    void itemClicked( QListViewItem* );
    void client_changed( int newClient );
    void externalapp_changed( int newApp );
+    void saveStoreSettings();
+    void setStandardStore();
  private:
    void setupExternalAppTab();
    void setupLocaleDateTab();
    void setupLocaleTab();
    void setupTimeZoneTab();
+    void setupStoreTab();
+    KURLRequester* mStoreUrl;
    void setCombo(QComboBox *combo,const QString & text, const QStringList *tags = 0);
    void saveEditFieldSettings();
    void updateClientWidgets();
    QTabWidget *tabWidget;
    QLineEdit* mUserDateFormatShort;
    QLineEdit* mUserDateFormatLong;
    QComboBox* mTimeZoneCombo;
    KDateEdit* mStartDateSavingEdit;
    KDateEdit* mEndDateSavingEdit; 
 //    void restoreExtensionSettings();
 //    void saveExtensionSettings();
 //    KListView *mExtensionView;
 //    QCheckBox *mNameParsing;
 //    QCheckBox *mViewsSingleClickBox;
 //    QPushButton *mConfigureButton;
        QComboBox* mExternalApps;
        QGroupBox* mExternalAppGroupBox;
    QComboBox* mClient;
    QLineEdit* mChannel;
    QLineEdit* mMessage;
    QLineEdit* mParameters;
    QLineEdit* mMessage2;
    QLineEdit* mParameters2;
    ExternalAppHandler::Types mCurrentApp;
    int mCurrentClient;
    int mEmailClient;
    QString mEmailOtherChannel;
    QString mEmailOtherMessage;
    QString mEmailOtherMessageParameters;
    QString mEmailOtherMessage2;
    QString mEmailOtherMessageParameters2;
    int mPhoneClient;
    QString mPhoneOtherChannel;
    QString mPhoneOtherMessage;
    QString mPhoneOtherMessageParameters;
    int mFaxClient;
    QString mFaxOtherChannel;
    QString mFaxOtherMessage;
    QString mFaxOtherMessageParameters;
    int mSMSClient;
    QString mSMSOtherChannel;
    QString mSMSOtherMessage;
    QString mSMSOtherMessageParameters;
    int mPagerClient;
    QString mPagerOtherChannel;
    QString mPagerOtherMessage;
    QString mPagerOtherMessageParameters;
    int mSipClient;
    QString mSipOtherChannel;
    QString mSipOtherMessage;
    QString mSipOtherMessageParameters;
    QMap<ExternalAppHandler::Types, QString> mExternalAppsMap;
 //    AddresseeWidget *mAddresseeWidget;
 };
 #endif
diff --git a/microkde/kdecore/kstandarddirs.cpp b/microkde/kdecore/kstandarddirs.cpp
index 4c03c15..f3584d7 100644
--- a/microkde/kdecore/kstandarddirs.cpp
+++ b/microkde/kdecore/kstandarddirs.cpp
@@ -1,1662 +1,1664 @@
 /* This file is part of the KDE libraries
   Copyright (C) 1999 Sirtaj Singh Kang <taj@kde.org>
   Copyright (C) 1999 Stephan Kulow <coolo@kde.org>
   Copyright (C) 1999 Waldo Bastian <bastian@kde.org>
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.
 */
 /*
 * Author: Stephan Kulow <coolo@kde.org> and Sirtaj Singh Kang <taj@kde.org>
         * Version:$Id$
         * Generated:Thu Mar  5 16:05:28 EST 1998
 */
 //US #include "config.h"
 #include <stdlib.h>
 #include <assert.h>
 //US#include <errno.h>
 //US #ifdef HAVE_SYS_STAT_H
 //US #include <sys/stat.h>
 //US #endif
 //US#include <sys/types.h>
 //US#include <dirent.h>
 //US#include <pwd.h>
 #include <qregexp.h>
 #include <qasciidict.h>
 #include <qdict.h>
 #include <qdir.h>
 #include <qfileinfo.h>
 #include <qstring.h>
 #include <qmessagebox.h>
 #include <qapplication.h>
 #include <qstringlist.h>
 #include "kstandarddirs.h"
 #include "kconfig.h"
 #include "kdebug.h"
 //US #include "kinstance.h"
 #include "kshell.h"
 //US#include <sys/param.h>
 //US#include <unistd.h>
 //US
 QString KStandardDirs::mAppDir = QString::null;
 template class QDict<QStringList>;
 #if 0
 #include <qtextedit.h>
 void ddd( QString op )
 {
  static QTextEdit * dot = 0;
  if ( ! dot )
  dot = new QTextEdit();
  dot->show();
  dot->append( op );
 }
 #endif
 class KStandardDirs::KStandardDirsPrivate
 {
 public:
   KStandardDirsPrivate()
    : restrictionsActive(false),
      dataRestrictionActive(false)
   { }
   bool restrictionsActive;
   bool dataRestrictionActive;
   QAsciiDict<bool> restrictions;
   QStringList xdgdata_prefixes;
   QStringList xdgconf_prefixes;
 };
 static const char* const types[] = {"html", "icon", "apps", "sound",
                              "data", "locale", "services", "mime",
                              "servicetypes", "config", "exe", "tmp",
                              "wallpaper", "lib", "pixmap", "templates",
                              "module", "qtplugins",
                              "xdgdata-apps", "xdgdata-dirs", "xdgconf-menu", 0 };
 static int tokenize( QStringList& token, const QString& str,
                const QString& delim );
 KStandardDirs::KStandardDirs( ) : addedCustoms(false)
 {
    d = new KStandardDirsPrivate;
    dircache.setAutoDelete(true);
    relatives.setAutoDelete(true);
    absolutes.setAutoDelete(true);
    savelocations.setAutoDelete(true);
    addKDEDefaults();
 }
 KStandardDirs::~KStandardDirs()
 {
    delete d;
 }
 bool KStandardDirs::isRestrictedResource(const char *type, const QString& relPath) const
 {
   if (!d || !d->restrictionsActive)
      return false;
   if (d->restrictions[type])
      return true;
   if (strcmp(type, "data")==0)
   {
      applyDataRestrictions(relPath);
      if (d->dataRestrictionActive)
      {
         d->dataRestrictionActive = false;
         return true;
      }
   }
   return false;
 }
 void KStandardDirs::applyDataRestrictions(const QString &relPath) const
 {
   QString key;
   int i = relPath.find('/');
   if (i != -1)
      key = "data_"+relPath.left(i);
   else
      key = "data_"+relPath;
   if (d && d->restrictions[key.latin1()])
      d->dataRestrictionActive = true;
 }
 QStringList KStandardDirs::allTypes() const
 {
    QStringList list;
    for (int i = 0; types[i] != 0; ++i)
        list.append(QString::fromLatin1(types[i]));
    return list;
 }
 void KStandardDirs::addPrefix( const QString& _dir )
 {
    if (_dir.isNull())
        return;
    QString dir = _dir;
    if (dir.at(dir.length() - 1) != '/')
        dir += '/';
    if (!prefixes.contains(dir)) {
        prefixes.append(dir);
        dircache.clear();
    }
 }
 void KStandardDirs::addXdgConfigPrefix( const QString& _dir )
 {
    if (_dir.isNull())
        return;
    QString dir = _dir;
    if (dir.at(dir.length() - 1) != '/')
        dir += '/';
    if (!d->xdgconf_prefixes.contains(dir)) {
        d->xdgconf_prefixes.append(dir);
        dircache.clear();
    }
 }
 void KStandardDirs::addXdgDataPrefix( const QString& _dir )
 {
    if (_dir.isNull())
        return;
    QString dir = _dir;
    if (dir.at(dir.length() - 1) != '/')
        dir += '/';
    if (!d->xdgdata_prefixes.contains(dir)) {
        d->xdgdata_prefixes.append(dir);
        dircache.clear();
    }
 }
 QString KStandardDirs::kfsstnd_prefixes()
 {
   return prefixes.join(":");
 }
 bool KStandardDirs::addResourceType( const char *type,
                                     const QString& relativename )
 {
    if (relativename.isNull())
       return false;
    QStringList *rels = relatives.find(type);
    if (!rels) {
        rels = new QStringList();
        relatives.insert(type, rels);
    }
    QString copy = relativename;
    if (copy.at(copy.length() - 1) != '/')
        copy += '/';
    if (!rels->contains(copy)) {
        rels->prepend(copy);
        dircache.remove(type); // clean the cache
        return true;
    }
    return false;
 }
 bool KStandardDirs::addResourceDir( const char *type,
                                    const QString& absdir)
 {
    QStringList *paths = absolutes.find(type);
    if (!paths) {
        paths = new QStringList();
        absolutes.insert(type, paths);
    }
    QString copy = absdir;
    if (copy.at(copy.length() - 1) != '/')
      copy += '/';
    if (!paths->contains(copy)) {
        paths->append(copy);
        dircache.remove(type); // clean the cache
        return true;
    }
    return false;
 }
 QString KStandardDirs::findResource( const char *type,
                                     const QString& filename ) const
 {
    if (filename.at(0) == '/')
        return filename; // absolute dirs are absolute dirs, right? :-/
 #if 0
 kdDebug() << "Find resource: " << type << endl;
 for (QStringList::ConstIterator pit = prefixes.begin();
     pit != prefixes.end();
     pit++)
 {
  kdDebug() << "Prefix: " << *pit << endl;
 }
 #endif
    QString dir = findResourceDir(type, filename);
    if (dir.isNull())
        return dir;
    else return dir + filename;
 }
 /*US
 static Q_UINT32 updateHash(const QString &file, Q_UINT32 hash)
 {
    QCString cFile = QFile::encodeName(file);
 //US     struct stat buff;
 //US    if ((access(cFile, R_OK) == 0) &&
 //US        (stat( cFile, &buff ) == 0) &&
 //US        (S_ISREG( buff.st_mode )))
    QFileInfo pathfnInfo(cFile);
    if (( pathfnInfo.isReadable() == true ) &&
       ( pathfnInfo.isFile()) )
    {
 //US       hash = hash + (Q_UINT32) buff.st_ctime;
       hash = hash + (Q_UINT32) pathfnInfo.lastModified();
    }
    return hash;
 }
 */
 /*US
 Q_UINT32 KStandardDirs::calcResourceHash( const char *type,
                              const QString& filename, bool deep) const
 {
    Q_UINT32 hash = 0;
    if (filename.at(0) == '/')
    {
        // absolute dirs are absolute dirs, right? :-/
        return updateHash(filename, hash);
    }
    if (d && d->restrictionsActive && (strcmp(type, "data")==0))
       applyDataRestrictions(filename);
    QStringList candidates = resourceDirs(type);
    QString fullPath;
    for (QStringList::ConstIterator it = candidates.begin();
         it != candidates.end(); it++)
    {
        hash = updateHash(*it + filename, hash);
        if (!deep && hash)
           return hash;
    }
    return hash;
 }
 */
 QStringList KStandardDirs::findDirs( const char *type,
                                     const QString& reldir ) const
 {
    QStringList list;
    checkConfig();
    if (d && d->restrictionsActive && (strcmp(type, "data")==0))
       applyDataRestrictions(reldir);
    QStringList candidates = resourceDirs(type);
    QDir testdir;
    for (QStringList::ConstIterator it = candidates.begin();
         it != candidates.end(); it++) {
        testdir.setPath(*it + reldir);
        if (testdir.exists())
            list.append(testdir.absPath() + '/');
    }
    return list;
 }
 QString KStandardDirs::findResourceDir( const char *type,
                                        const QString& filename) const
 {
 #ifndef NDEBUG
    if (filename.isEmpty()) {
      kdWarning() << "filename for type " << type << " in KStandardDirs::findResourceDir is not supposed to be empty!!" << endl;
      return QString::null;
    }
 #endif
    if (d && d->restrictionsActive && (strcmp(type, "data")==0))
       applyDataRestrictions(filename);
    QStringList candidates = resourceDirs(type);
    QString fullPath;
 #ifdef DESKTOP_VERSION
 #ifdef _WIN32_
    candidates.prepend( qApp->applicationDirPath () +"\\");
 #else
    candidates.prepend( qApp->applicationDirPath () +"/");
 #endif
 #endif
    for (QStringList::ConstIterator it = candidates.begin(); it != candidates.end(); it++)
    {
        //qDebug("looking for dir %s  - file %s", (*it).latin1(),  filename.latin1());
      if (exists(*it + filename))
        return *it;
    }
 #ifndef NDEBUG
    if(false && type != "locale")
        qDebug("KStdDirs::findResDir(): can't find %s ", filename.latin1());
 #endif
    return QString::null;
 }
 bool KStandardDirs::exists(const QString &fullPath)
 {
 //US    struct stat buff;
    QFileInfo fullPathInfo(QFile::encodeName(fullPath));
 //US    if (access(QFile::encodeName(fullPath), R_OK) == 0 && fullPathInfo.isReadable())
    if (fullPathInfo.isReadable())
          {
      if (fullPath.at(fullPath.length() - 1) != '/') {
        //US      if (S_ISREG( buff.st_mode ))
              if (fullPathInfo.isFile())
                      return true;
            }
      else {
        //US      if (S_ISDIR( buff.st_mode ))
              if (fullPathInfo.isDir())
                      return true;
      }
    }
    return false;
 }
 static void lookupDirectory(const QString& path, const QString &relPart,
                            const QRegExp &regexp,
                            QStringList& list,
                            QStringList& relList,
                            bool recursive, bool uniq)
 {
  QString pattern = regexp.pattern();
  if (recursive || pattern.contains('?') || pattern.contains('*'))
  {
    // We look for a set of files.
 //US    DIR *dp = opendir( QFile::encodeName(path));
    QDir dp(QFile::encodeName(path));
    if (!dp.exists())
      return;
    static int iii = 0;
    ++iii;
    if ( iii == 5 )
        abort();
    assert(path.at(path.length() - 1) == '/');
 //US    struct dirent *ep;
 //US    struct stat buff;
    QString _dot(".");
    QString _dotdot("..");
 //US    while( ( ep = readdir( dp ) ) != 0L )
    QStringList direntries = dp.entryList();
    QStringList::Iterator it = direntries.begin();
    while ( it != list.end() )            // for each file...
    {
 //US      QString fn( QFile::decodeName(ep->d_name));
      QString fn = (*it); // dp.entryList already decodes
      it++;
      if ( fn.isNull() )
          break;
      if (fn == _dot || fn == _dotdot || fn.at(fn.length() - 1).latin1() == '~'   )
        continue;
 /*US
      if (!recursive && !regexp.exactMatch(fn))
        continue; // No match
 */
 //US this should do the same:
      int pos = regexp.match(fn);
      if (!recursive && !pos == 0)
        continue; // No match
      QString pathfn = path + fn;
 /*US
      if ( stat( QFile::encodeName(pathfn), &buff ) != 0 ) {
        kdDebug() << "Error stat'ing " << pathfn << " : " << perror << endl;
        continue; // Couldn't stat (e.g. no read permissions)
      }
      if ( recursive )
      {
        if ( S_ISDIR( buff.st_mode )) {
          lookupDirectory(pathfn + '/', relPart + fn + '/', regexp, list, relList, recursive, uniq);
      }
 */
 //US replacement:
      QFileInfo pathfnInfo(QFile::encodeName(pathfn));
      if ( pathfnInfo.isReadable() == false )
      {
 //US        kdDebug() << "Error stat'ing " << pathfn << " : " << perror << endl;
        continue; // Couldn't stat (e.g. no read permissions)
      }
      if ( recursive )
      {
        if ( pathfnInfo.isDir()) {
          lookupDirectory(pathfn + '/', relPart + fn + '/', regexp, list, relList, recursive, uniq);
      }
 /*US
        if (!regexp.exactMatch(fn))
          continue; // No match
 */
 //US this should do the same:
        pos = regexp.match(fn);
        if (!pos == 0)
          continue; // No match
      }
 //US      if ( S_ISREG( buff.st_mode))
      if ( pathfnInfo.isFile())
      {
        if (!uniq || !relList.contains(relPart + fn))
        {
          list.append( pathfn );
          relList.append( relPart + fn );
        }
      }
    }
 //US    closedir( dp );
  }
  else
  {
     // We look for a single file.
     QString fn = pattern;
     QString pathfn = path + fn;
 //US     struct stat buff;
      QFileInfo pathfnInfo(QFile::encodeName(pathfn));
 //US     if ( stat( QFile::encodeName(pathfn), &buff ) != 0 )
      if ( pathfnInfo.isReadable() == false )
        return; // File not found
 //US     if ( S_ISREG( buff.st_mode))
     if ( pathfnInfo.isFile())
     {
       if (!uniq || !relList.contains(relPart + fn))
       {
         list.append( pathfn );
         relList.append( relPart + fn );
       }
     }
  }
 }
 static void lookupPrefix(const QString& prefix, const QString& relpath,
                         const QString& relPart,
                         const QRegExp &regexp,
                         QStringList& list,
                         QStringList& relList,
                         bool recursive, bool uniq)
 {
    if (relpath.isNull()) {
       lookupDirectory(prefix, relPart, regexp, list,
                       relList, recursive, uniq);
       return;
    }
    QString path;
    QString rest;
    if (relpath.length())
    {
       int slash = relpath.find('/');
       if (slash < 0)
           rest = relpath.left(relpath.length() - 1);
       else {
           path = relpath.left(slash);
           rest = relpath.mid(slash + 1);
       }
    }
    assert(prefix.at(prefix.length() - 1) == '/');
 //US    struct stat buff;
    if (path.contains('*') || path.contains('?')) {
        QRegExp pathExp(path, true, true);
        //USDIR *dp = opendir( QFile::encodeName(prefix) );
  QDir dp(QFile::encodeName(prefix));
        //USif (!dp)
  if (!dp.exists())
  {
            return;
        }
        //USstruct dirent *ep;
        QString _dot(".");
        QString _dotdot("..");
        //USwhile( ( ep = readdir( dp ) ) != 0L )
    QStringList direntries = dp.entryList();
    QStringList::Iterator it = direntries.begin();
    while ( it != list.end() )            // for each file...
    {
 //US      QString fn( QFile::decodeName(ep->d_name));
      QString fn = (*it); // dp.entryList() already encodes the strings
      it++;
                if (fn == _dot || fn == _dotdot || fn.at(fn.length() - 1) == '~')
                    continue;
 #ifdef DESKTOP_VERSION
                if (pathExp.search(fn) == -1)
                    continue; // No match
 #else
 //US this should do the same:
        if (pathExp.find(fn, 0) == -1)
          continue; // No match
 #endif
                QString rfn = relPart+fn;
                fn = prefix + fn;
 //US    if ( stat( QFile::encodeName(fn), &buff ) != 0 )
      QFileInfo fnInfo(QFile::encodeName(fn));
    if ( fnInfo.isReadable() == false )
    {
 //US        kdDebug() << "Error statting " << fn << " : " << perror << endl;
                    continue; // Couldn't stat (e.g. no permissions)
                }
        //US    if ( S_ISDIR( buff.st_mode ))
    if ( fnInfo.isDir() )
                    lookupPrefix(fn + '/', rest, rfn + '/', regexp, list, relList, recursive, uniq);
            }
        //USclosedir( dp );
    } else {
        // Don't stat, if the dir doesn't exist we will find out
        // when we try to open it.
        lookupPrefix(prefix + path + '/', rest,
                     relPart + path + '/', regexp, list,
                     relList, recursive, uniq);
    }
 }
 QStringList
 KStandardDirs::findAllResources( const char *type,
                                 const QString& filter,
                                 bool recursive,
                                 bool uniq,
                                 QStringList &relList) const
 {
    QStringList list;
    if (filter.at(0) == '/') // absolute paths we return
    {
        list.append( filter);
        return list;
    }
    QString filterPath;
    QString filterFile;
    if (filter.length())
    {
       int slash = filter.findRev('/');
       if (slash < 0)
           filterFile = filter;
       else {
           filterPath = filter.left(slash + 1);
           filterFile = filter.mid(slash + 1);
       }
    }
    checkConfig();
    if (d && d->restrictionsActive && (strcmp(type, "data")==0))
       applyDataRestrictions(filter);
    QStringList candidates = resourceDirs(type);
    if (filterFile.isEmpty())
        filterFile = "*";
    QRegExp regExp(filterFile, true, true);
    for (QStringList::ConstIterator it = candidates.begin();
         it != candidates.end(); it++)
    {
        lookupPrefix(*it, filterPath, "", regExp, list,
                     relList, recursive, uniq);
    }
    return list;
 }
 QStringList
 KStandardDirs::findAllResources( const char *type,
                                 const QString& filter,
                                 bool recursive,
                                 bool uniq) const
 {
    QStringList relList;
    return findAllResources(type, filter, recursive, uniq, relList);
 }
 QString
 KStandardDirs::realPath(const QString &dirname)
 {
 #ifdef _WIN32_
  return dirname;
 #else
 //US    char realpath_buffer[MAXPATHLEN + 1];
 //US    memset(realpath_buffer, 0, MAXPATHLEN + 1);
    char realpath_buffer[250 + 1];
    memset(realpath_buffer, 0, 250 + 1);
    /* If the path contains symlinks, get the real name */
    if (realpath( QFile::encodeName(dirname).data(), realpath_buffer) != 0) {
        // succes, use result from realpath
        int len = strlen(realpath_buffer);
        realpath_buffer[len] = '/';
        realpath_buffer[len+1] = 0;
        return QFile::decodeName(realpath_buffer);
    }
    return dirname;
 #endif
 }
 /*US
 void KStandardDirs::createSpecialResource(const char *type)
 {
   char hostname[256];
   hostname[0] = 0;
   gethostname(hostname, 255);
   QString dir = QString("%1%2-%3").arg(localkdedir()).arg(type).arg(hostname);
   char link[1024];
   link[1023] = 0;
   int result = readlink(QFile::encodeName(dir).data(), link, 1023);
   if ((result == -1) && (errno == ENOENT))
   {
      QString srv = findExe(QString::fromLatin1("lnusertemp"), KDEDIR+QString::fromLatin1("/bin"));
      if (srv.isEmpty())
         srv = findExe(QString::fromLatin1("lnusertemp"));
      if (!srv.isEmpty())
      {
         system(QFile::encodeName(srv)+" "+type);
         result = readlink(QFile::encodeName(dir).data(), link, 1023);
      }
   }
   if (result > 0)
   {
      link[result] = 0;
      if (link[0] == '/')
         dir = QFile::decodeName(link);
      else
         dir = QDir::cleanDirPath(dir+QFile::decodeName(link));
   }
   addResourceDir(type, dir+'/');
 }
 */
 QStringList KStandardDirs::resourceDirs(const char *type) const
 {
    QStringList *candidates = dircache.find(type);
    if (!candidates) { // filling cache
 /*US
        if (strcmp(type, "socket") == 0)
           const_cast<KStandardDirs *>(this)->createSpecialResource(type);
        else if (strcmp(type, "tmp") == 0)
           const_cast<KStandardDirs *>(this)->createSpecialResource(type);
        else if (strcmp(type, "cache") == 0)
           const_cast<KStandardDirs *>(this)->createSpecialResource(type);
 */
        QDir testdir;
        candidates = new QStringList();
        QStringList *dirs;
        bool restrictionActive = false;
        if (d && d->restrictionsActive)
        {
           if (d->dataRestrictionActive)
              restrictionActive = true;
           else if (d->restrictions["all"])
              restrictionActive = true;
           else if (d->restrictions[type])
              restrictionActive = true;
           d->dataRestrictionActive = false; // Reset
        }
        dirs = relatives.find(type);
        if (dirs)
        {
            bool local = true;
            const QStringList *prefixList = 0;
            if (strncmp(type, "xdgdata-", 8) == 0)
                prefixList = &(d->xdgdata_prefixes);
            else if (strncmp(type, "xdgconf-", 8) == 0)
                prefixList = &(d->xdgconf_prefixes);
            else
                prefixList = &prefixes;
            for (QStringList::ConstIterator pit = prefixList->begin();
                 pit != prefixList->end();
                 pit++)
            {
                for (QStringList::ConstIterator it = dirs->begin();
                     it != dirs->end(); ++it) {
                    QString path = realPath(*pit + *it);
                    testdir.setPath(path);
                    if (local && restrictionActive)
                       continue;
                    if ((local || testdir.exists()) && !candidates->contains(path))
                        candidates->append(path);
                }
                local = false;
            }
        }
        dirs = absolutes.find(type);
        if (dirs)
            for (QStringList::ConstIterator it = dirs->begin();
                 it != dirs->end(); ++it)
            {
                testdir.setPath(*it);
                if (testdir.exists())
                {
                    QString filename = realPath(*it);
                    if (!candidates->contains(filename))
                        candidates->append(filename);
                }
            }
        dircache.insert(type, candidates);
    }
 #if 0
    kdDebug() << "found dirs for resource " << type << ":" << endl;
    for (QStringList::ConstIterator pit = candidates->begin();
         pit != candidates->end();
         pit++)
    {
        fprintf(stderr, "%s\n", (*pit).latin1());
    }
 #endif
  return *candidates;
 }
 /*US
 QString KStandardDirs::findExe( const QString& appname,
                                const QString& pstr, bool ignore)
 {
    QFileInfo info;
    // absolute path ?
    if (appname.startsWith(QString::fromLatin1("/")))
    {
        info.setFile( appname );
        if( info.exists() && ( ignore || info.isExecutable() )
            && info.isFile() ) {
            return appname;
        }
        return QString::null;
    }
 //US    QString p = QString("%1/%2").arg(__KDE_BINDIR).arg(appname);
    QString p = QString("%1/%2").arg(appname).arg(appname);
    qDebug("KStandardDirs::findExe this is probably wrong");
    info.setFile( p );
    if( info.exists() && ( ignore || info.isExecutable() )
         && ( info.isFile() || info.isSymLink() )  ) {
         return p;
    }
    QStringList tokens;
    p = pstr;
    if( p.isNull() ) {
        p = getenv( "PATH" );
    }
    tokenize( tokens, p, ":\b" );
    // split path using : or \b as delimiters
    for( unsigned i = 0; i < tokens.count(); i++ ) {
        p = tokens[ i ];
        if ( p[ 0 ] == '~' )
        {
            int len = p.find( '/' );
            if ( len == -1 )
                len = p.length();
            if ( len == 1 )
                p.replace( 0, 1, QDir::homeDirPath() );
            else
            {
                QString user = p.mid( 1, len - 1 );
                struct passwd *dir = getpwnam( user.local8Bit().data() );
                if ( dir && strlen( dir->pw_dir ) )
                    p.replace( 0, len, QString::fromLocal8Bit( dir->pw_dir ) );
            }
        }
        p += "/";
        p += appname;
        // Check for executable in this tokenized path
        info.setFile( p );
        if( info.exists() && ( ignore || info.isExecutable() )
           && ( info.isFile() || info.isSymLink() )  ) {
            return p;
        }
    }
    // If we reach here, the executable wasn't found.
    // So return empty string.
    return QString::null;
 }
 int KStandardDirs::findAllExe( QStringList& list, const QString& appname,
                        const QString& pstr, bool ignore )
 {
    QString p = pstr;
    QFileInfo info;
    QStringList tokens;
    if( p.isNull() ) {
        p = getenv( "PATH" );
    }
    list.clear();
    tokenize( tokens, p, ":\b" );
    for ( unsigned i = 0; i < tokens.count(); i++ ) {
        p = tokens[ i ];
        p += "/";
        p += appname;
        info.setFile( p );
        if( info.exists() && (ignore || info.isExecutable())
            && info.isFile() ) {
            list.append( p );
        }
    }
    return list.count();
 }
 */
 static int tokenize( QStringList& tokens, const QString& str,
                     const QString& delim )
 {
    int len = str.length();
    QString token = "";
    for( int index = 0; index < len; index++)
    {
        if ( delim.find( str[ index ] ) >= 0 )
        {
            tokens.append( token );
            token = "";
        }
        else
        {
            token += str[ index ];
        }
    }
    if ( token.length() > 0 )
    {
        tokens.append( token );
    }
    return tokens.count();
 }
 QString KStandardDirs::kde_default(const char *type) {
    if (!strcmp(type, "data"))
        return "apps/";
    if (!strcmp(type, "html"))
        return "share/doc/HTML/";
    if (!strcmp(type, "icon"))
        return "share/icons/";
    if (!strcmp(type, "config"))
        return "config/";
    if (!strcmp(type, "pixmap"))
        return "share/pixmaps/";
    if (!strcmp(type, "apps"))
        return "share/applnk/";
    if (!strcmp(type, "sound"))
        return "share/sounds/";
    if (!strcmp(type, "locale"))
        return "share/locale/";
    if (!strcmp(type, "services"))
        return "share/services/";
    if (!strcmp(type, "servicetypes"))
        return "share/servicetypes/";
    if (!strcmp(type, "mime"))
        return "share/mimelnk/";
    if (!strcmp(type, "cgi"))
        return "cgi-bin/";
    if (!strcmp(type, "wallpaper"))
        return "share/wallpapers/";
    if (!strcmp(type, "templates"))
        return "share/templates/";
    if (!strcmp(type, "exe"))
        return "bin/";
    if (!strcmp(type, "lib"))
              return "lib/";
    if (!strcmp(type, "module"))
              return "lib/kde3/";
    if (!strcmp(type, "qtplugins"))
        return "lib/kde3/plugins";
    if (!strcmp(type, "xdgdata-apps"))
        return "applications/";
    if (!strcmp(type, "xdgdata-dirs"))
        return "desktop-directories/";
    if (!strcmp(type, "xdgconf-menu"))
        return "menus/";
    if (!strcmp(type, "tmp"))
        return "tmp/";
    qFatal("unknown resource type %s", type);
    return QString::null;
 }
 QString KStandardDirs::saveLocation(const char *type,
                                    const QString& suffix,
                                    bool create) const
 {
    //qDebug("KStandardDirs::saveLocation called %s %s", type,suffix.latin1() );
    //return "";
    checkConfig();
    QString *pPath = savelocations.find(type);
    if (!pPath)
    {
       QStringList *dirs = relatives.find(type);
       if (!dirs && (
                     (strcmp(type, "socket") == 0) ||
                     (strcmp(type, "tmp") == 0) ||
                     (strcmp(type, "cache") == 0) ))
       {
          (void) resourceDirs(type); // Generate socket|tmp|cache resource.
          dirs = relatives.find(type); // Search again.
       }
       if (dirs)
       {
          // Check for existance of typed directory + suffix
          if (strncmp(type, "xdgdata-", 8) == 0)
             pPath = new QString(realPath(localxdgdatadir() + dirs->last()));
          else if (strncmp(type, "xdgconf-", 8) == 0)
             pPath = new QString(realPath(localxdgconfdir() + dirs->last()));
          else
             pPath = new QString(realPath(localkdedir() + dirs->last()));
       }
       else {
          dirs = absolutes.find(type);
          if (!dirs)
             qFatal("KStandardDirs: The resource type %s is not registered", type);
          pPath = new QString(realPath(dirs->last()));
       }
       savelocations.insert(type, pPath);
    }
    QString fullPath = *pPath + suffix;
 //US    struct stat st;
 //US    if (stat(QFile::encodeName(fullPath), &st) != 0 || !(S_ISDIR(st.st_mode)))
      QFileInfo fullPathInfo(QFile::encodeName(fullPath));
      if (fullPathInfo.isReadable() || !fullPathInfo.isDir())
    {
        if(!create) {
 #ifndef NDEBUG
            qDebug("save location %s doesn't exist", fullPath.latin1());
 #endif
            return fullPath;
        }
        if(!makeDir(fullPath, 0700)) {
            qWarning("failed to create %s", fullPath.latin1());
            return fullPath;
        }
        dircache.remove(type);
    }
    return fullPath;
 }
 QString KStandardDirs::relativeLocation(const char *type, const QString &absPath)
 {
    QString fullPath = absPath;
    int i = absPath.findRev('/');
    if (i != -1)
    {
       fullPath = realPath(absPath.left(i+1))+absPath.mid(i+1); // Normalize
    }
    QStringList candidates = resourceDirs(type);
    for (QStringList::ConstIterator it = candidates.begin();
         it != candidates.end(); it++)
      if (fullPath.startsWith(*it))
      {
        return fullPath.mid((*it).length());
      }
    return absPath;
 }
 bool KStandardDirs::makeDir(const QString& dir2, int mode)
 {
  QString dir = QDir::convertSeparators( dir2  );
 #if 0
    //LR
    // we want an absolute path
    if (dir.at(0) != '/')
        return false;
    QString target = dir;
    uint len = target.length();
    // append trailing slash if missing
    if (dir.at(len - 1) != '/')
        target += '/';
    QString base("");
    uint i = 1;
    while( i < len )
    {
 //US        struct stat st;
        int pos = target.find('/', i);
        base += target.mid(i - 1, pos - i + 1);
        QCString baseEncoded = QFile::encodeName(base);
        // bail out if we encountered a problem
 //US        if (stat(baseEncoded, &st) != 0)
        QFileInfo baseEncodedInfo(baseEncoded);
        if (!baseEncodedInfo.exists())
        {
          // Directory does not exist....
          // Or maybe a dangling symlink ?
 //US          if (lstat(baseEncoded, &st) == 0)
          if (baseEncodedInfo.isSymLink()) {
 //US              (void)unlink(baseEncoded); // try removing
              QFile(baseEncoded).remove();
          }
        //US  if ( mkdir(baseEncoded, (mode_t) mode) != 0)
    QDir dirObj;
          if ( dirObj.mkdir(baseEncoded) != true )
    {
        //US    perror("trying to create local folder");
            return false; // Couldn't create it :-(
          }
        }
        i = pos + 1;
    }
    return true;
 #endif
    // ********************************************
    // new code for WIN32
  QDir dirObj;
    // we want an absolute path
 #ifndef _WIN32_
    if (dir.at(0) != '/')
        return false;
 #endif
    QString target = dir;
    uint len = target.length();
 #ifndef _WIN32_
    // append trailing slash if missing
    if (dir.at(len - 1) != '/')
        target += '/';
 #endif
    QString base("");
    uint i = 1;
    while( i < len )
    {
 //US        struct stat st;
 #ifndef _WIN32_
        int pos = target.find('/', i);
 #else
        int pos = target.find('\\', i);
 #endif
        if ( pos < 0 )
          return true;
        base += target.mid(i - 1, pos - i + 1);
        //QMessageBox::information( 0,"cap111", base, 1 );
 /*US
        QCString baseEncoded = QFile::encodeName(base);
        // bail out if we encountered a problem
        if (stat(baseEncoded, &st) != 0)
        {
          // Directory does not exist....
          // Or maybe a dangling symlink ?
          if (lstat(baseEncoded, &st) == 0)
              (void)unlink(baseEncoded); // try removing
          if ( mkdir(baseEncoded, (mode_t) mode) != 0) {
            perror("trying to create local folder");
            return false; // Couldn't create it :-(
          }
        }
 */
        if (dirObj.exists(base) == false)
        {
            //qDebug("KStandardDirs::makeDir try to create : %s" , base.latin1());
          if (dirObj.mkdir(base) != true)
          {
            qDebug("KStandardDirs::makeDir could not create: %s" , base.latin1());
            return false;
          }
        }
        i = pos + 1;
    }
    return true;
 }
 static QString readEnvPath(const char *env)
 {
  //#ifdef _WIN32_
  //    return "";
  //#else
  QCString c_path;
  if ( getenv(env) != NULL )
    c_path = QString ( getenv(env) );
  if (c_path.isEmpty())
    return QString::null;
  return QFile::decodeName(c_path);
   //#endif
 }
 void KStandardDirs::addKDEDefaults()
 {
 
    //qDebug("ERROR: KStandardDirs::addKDEDefaults() called ");
    //return;
    QStringList kdedirList;
    // begin KDEDIRS
    QString kdedirs = readEnvPath("MICROKDEDIRS");
    if (!kdedirs.isEmpty())
    {
        tokenize(kdedirList, kdedirs, ":");
    }
    else
    {
        QString kdedir = readEnvPath("MICROKDEDIR");
        if (!kdedir.isEmpty())
        {
           kdedir = KShell::tildeExpand(kdedir);
           kdedirList.append(kdedir);
        }
    }
 //US    kdedirList.append(KDEDIR);
 //US for embedded, add qtopia dir as kdedir
 #ifndef DESKTOP_VERSION
    QString tmp = readEnvPath("QPEDIR");
    if (!tmp.isEmpty())
      kdedirList.append(tmp);
    tmp = readEnvPath("QTDIR");
    if (!tmp.isEmpty())
      kdedirList.append(tmp);
    tmp = readEnvPath("OPIEDIR");
    if (!tmp.isEmpty())
      kdedirList.append(tmp);
 #endif
 #ifdef __KDE_EXECPREFIX
    QString execPrefix(__KDE_EXECPREFIX);
    if (execPrefix!="NONE")
       kdedirList.append(execPrefix);
 #endif
    QString localKdeDir;
 //US    if (getuid())
    if (true)
    {
       localKdeDir = readEnvPath("MICROKDEHOME");
       if (!localKdeDir.isEmpty())
       {
 #ifdef _WIN32_
          if (localKdeDir.at(localKdeDir.length()-1) != '\\')
             localKdeDir += '\\';
 #else
          if (localKdeDir.at(localKdeDir.length()-1) != '/')
             localKdeDir += '/';
 #endif
          //QMessageBox::information( 0,"localKdeDir",localKdeDir, 1 );
       }
       else
       {
-          localKdeDir =  QDir::homeDirPath() + "/kdepim/";
+           KConfig cfg (   QDir::homeDirPath() + "/.microkdehome" );
+           cfg.setGroup("Global");
+           localKdeDir = cfg.readEntry( "MICROKDEHOME", QDir::homeDirPath() + "/kdepim/" );
       }
    }
    else
    {
       // We treat root different to prevent root messing up the
       // file permissions in the users home directory.
       localKdeDir = readEnvPath("MICROKDEROOTHOME");
       if (!localKdeDir.isEmpty())
       {
          if (localKdeDir.at(localKdeDir.length()-1) != '/')
             localKdeDir += '/';
       }
       else
       {
 //US          struct passwd *pw = getpwuid(0);
 //US          localKdeDir =  QFile::decodeName((pw && pw->pw_dir) ? pw->pw_dir : "/root")  + "/.microkde/";
              qDebug("KStandardDirs::addKDEDefaults: 1 has to be fixed");
       }
    }
 //US    localKdeDir =  appDir();
 //US
 //  qDebug("KStandardDirs::addKDEDefaults: localKdeDir=%s", localKdeDir.latin1());
    if (localKdeDir != "-/")
    {
        localKdeDir = KShell::tildeExpand(localKdeDir);
        addPrefix(localKdeDir);
    }
    for (QStringList::ConstIterator it = kdedirList.begin();
         it != kdedirList.end(); it++)
    {
        QString dir = KShell::tildeExpand(*it);
        addPrefix(dir);
    }
    // end KDEDIRS
    // begin XDG_CONFIG_XXX
    QStringList xdgdirList;
    QString xdgdirs = readEnvPath("XDG_CONFIG_DIRS");
    if (!xdgdirs.isEmpty())
    {
        tokenize(xdgdirList, xdgdirs, ":");
    }
    else
    {
        xdgdirList.clear();
        xdgdirList.append("/etc/xdg");
    }
    QString localXdgDir = readEnvPath("XDG_CONFIG_HOME");
    if (!localXdgDir.isEmpty())
    {
       if (localXdgDir.at(localXdgDir.length()-1) != '/')
          localXdgDir += '/';
    }
    else
    {
 //US       if (getuid())
       if (true)
       {
          localXdgDir =  QDir::homeDirPath() + "/.config/";
       }
       else
       {
 //US          struct passwd *pw = getpwuid(0);
 //US          localXdgDir =  QFile::decodeName((pw && pw->pw_dir) ? pw->pw_dir : "/root")  + "/.config/";
              qDebug("KStandardDirs::addKDEDefaults: 2 has to be fixed");
       }
    }
    localXdgDir = KShell::tildeExpand(localXdgDir);
    addXdgConfigPrefix(localXdgDir);
    for (QStringList::ConstIterator it = xdgdirList.begin();
         it != xdgdirList.end(); it++)
    {
        QString dir = KShell::tildeExpand(*it);
        addXdgConfigPrefix(dir);
    }
    // end XDG_CONFIG_XXX
    // begin XDG_DATA_XXX
    xdgdirs = readEnvPath("XDG_DATA_DIRS");
    if (!xdgdirs.isEmpty())
    {
        tokenize(xdgdirList, xdgdirs, ":");
    }
    else
    {
        xdgdirList.clear();
        for (QStringList::ConstIterator it = kdedirList.begin();
           it != kdedirList.end(); it++)
        {
           QString dir = *it;
           if (dir.at(dir.length()-1) != '/')
             dir += '/';
           xdgdirList.append(dir+"share/");
        }
        xdgdirList.append("/usr/local/share/");
        xdgdirList.append("/usr/share/");
    }
    localXdgDir = readEnvPath("XDG_DATA_HOME");
    if (!localXdgDir.isEmpty())
    {
       if (localXdgDir.at(localXdgDir.length()-1) != '/')
          localXdgDir += '/';
    }
    else
    {
 //US       if (getuid())
       if (true)
       {
          localXdgDir =  QDir::homeDirPath() + "/.local/share/";
       }
       else
       {
 //US          struct passwd *pw = getpwuid(0);
 //US          localXdgDir =  QFile::decodeName((pw && pw->pw_dir) ? pw->pw_dir : "/root")  + "/.local/share/";
              qDebug("KStandardDirs::addKDEDefaults: 3 has to be fixed");
       }
    }
    localXdgDir = KShell::tildeExpand(localXdgDir);
    addXdgDataPrefix(localXdgDir);
    for (QStringList::ConstIterator it = xdgdirList.begin();
         it != xdgdirList.end(); it++)
    {
        QString dir = KShell::tildeExpand(*it);
        addXdgDataPrefix(dir);
    }
    // end XDG_DATA_XXX
    uint index = 0;
    while (types[index] != 0) {
        addResourceType(types[index], kde_default(types[index]));
        index++;
    }
    addResourceDir("home", QDir::homeDirPath());
 }
 void KStandardDirs::checkConfig() const
 {
 /*US
    if (!addedCustoms && KGlobal::_instance && KGlobal::_instance->_config)
        const_cast<KStandardDirs*>(this)->addCustomized(KGlobal::_instance->_config);
 */
    if (!addedCustoms && KGlobal::config())
        const_cast<KStandardDirs*>(this)->addCustomized(KGlobal::config());
 }
 bool KStandardDirs::addCustomized(KConfig *config)
 {
    if (addedCustoms) // there are already customized entries
        return false; // we just quite and hope they are the right ones
    // save the numbers of config directories. If this changes,
    // we will return true to give KConfig a chance to reparse
    uint configdirs = resourceDirs("config").count();
    // reading the prefixes in
    QString oldGroup = config->group();
    config->setGroup("Directories");
    QStringList list;
    QStringList::ConstIterator it;
    list = config->readListEntry("prefixes");
    for (it = list.begin(); it != list.end(); it++)
        addPrefix(*it);
    // iterating over all entries in the group Directories
    // to find entries that start with dir_$type
 /*US
    QMap<QString, QString> entries = config->entryMap("Directories");
    QMap<QString, QString>::ConstIterator it2;
    for (it2 = entries.begin(); it2 != entries.end(); it2++)
    {
      QString key = it2.key();
      if (key.left(4) == "dir_") {
        // generate directory list, there may be more than 1.
        QStringList dirs = QStringList::split(',', *it2);
        QStringList::Iterator sIt(dirs.begin());
        QString resType = key.mid(4, key.length());
        for (; sIt != dirs.end(); ++sIt) {
          addResourceDir(resType.latin1(), *sIt);
        }
      }
    }
    // Process KIOSK restrictions.
    config->setGroup("KDE Resource Restrictions");
    entries = config->entryMap("KDE Resource Restrictions");
    for (it2 = entries.begin(); it2 != entries.end(); it2++)
    {
        QString key = it2.key();
        if (!config->readBoolEntry(key, true))
        {
           d->restrictionsActive = true;
           d->restrictions.insert(key.latin1(), &d->restrictionsActive); // Anything will do
           dircache.remove(key.latin1());
        }
    }
 */
    // save it for future calls - that will return
    addedCustoms = true;
    config->setGroup(oldGroup);
    // return true if the number of config dirs changed
    return (resourceDirs("config").count() != configdirs);
 }
 QString KStandardDirs::localkdedir() const
 {
    // Return the prefix to use for saving
    return prefixes.first();
 }
 QString KStandardDirs::localxdgdatadir() const
 {
    // Return the prefix to use for saving
    return d->xdgdata_prefixes.first();
 }
 QString KStandardDirs::localxdgconfdir() const
 {
    // Return the prefix to use for saving
    return d->xdgconf_prefixes.first();
 }
 void KStandardDirs::setAppDir( const QString &appDir )
 {
  mAppDir = appDir;
  if ( mAppDir.right( 1 ) != "/" )
    mAppDir += "/";
 }
 QString KStandardDirs::appDir()
 {
  return mAppDir;
 }
 // just to make code more readable without macros
 QString locate( const char *type,
                const QString& filename/*US , const KInstance* inst*/ )
 {
 //US    return inst->dirs()->findResource(type, filename);
    return KGlobal::dirs()->findResource(type, filename);
 }
 QString locateLocal( const char *type,
                     const QString& filename/*US , const KInstance* inst*/ )
 {
     QString path = locateLocal(type, filename, true /*US, inst*/);
 /*
     static int ccc = 0;
     ++ccc;
     if ( ccc > 13 )
         abort();
 */
     //qDebug("locatelocal: %s" , path.latin1());
     return path;
 /*US why do we put all files into one directory. It is quit complicated.
 why not staying with the original directorystructure ?
  QString escapedFilename = filename;
  escapedFilename.replace( QRegExp( "/" ), "_" );
  QString path = KStandardDirs::appDir() + type + "_" + escapedFilename;
  kdDebug() << "locate: '" << path << "'" << endl;
  qDebug("locate: %s" , path.latin1());
  return path;
 */
 //US so my proposal is this:
 //  QString escapedFilename = filename;
 //  escapedFilename.replace( QRegExp( "/" ), "_" );
 #if 0
 #ifdef _WIN32_
  QString path = QDir::convertSeparators(KStandardDirs::appDir() + type + "/" + filename);
 #else
  QString path = KStandardDirs::appDir() + type + "/" + filename;
 #endif
  //US Create the containing dir if needed
  QFileInfo fi ( path );
  // QString dir=pathurl.directory();
          //QMessageBox::information( 0,"path", path, 1 );
 #ifdef _WIN32_
  KStandardDirs::makeDir(path);
 #else
  KStandardDirs::makeDir(fi.dirPath( true ));
 #endif
  qDebug("locate22: %s" , path.latin1());
  return path;
 #endif
 }
 QString locateLocal( const char *type,
                     const QString& filename, bool createDir/*US , const KInstance* inst*/ )
 {
    // try to find slashes. If there are some, we have to
    // create the subdir first
    int slash = filename.findRev('/')+1;
    if (!slash) // only one filename
        //USreturn inst->dirs()->saveLocation(type, QString::null, createDir) + filename;
      return KGlobal::dirs()->saveLocation(type, QString::null, createDir) + filename;
    // split path from filename
    QString dir = filename.left(slash);
    QString file = filename.mid(slash);
 //US    return inst->dirs()->saveLocation(type, dir, createDir) + file;
    return KGlobal::dirs()->saveLocation(type, dir, createDir) + file;
    // ***************************************************************
 #if 0
 /*US why do we put all files into one directory. It is quit complicated.
 why not staying with the original directorystructure ?
  QString escapedFilename = filename;
  escapedFilename.replace( QRegExp( "/" ), "_" );
  QString path = KStandardDirs::appDir() + type + "_" + escapedFilename;
  kdDebug() << "locate: '" << path << "'" << endl;
  qDebug("locate: %s" , path.latin1());
  return path;
 */
 //US so my proposal is this:
 //  QString escapedFilename = filename;
 //  escapedFilename.replace( QRegExp( "/" ), "_" );
 #ifdef _WIN32_
  QString path = QDir::convertSeparators(KStandardDirs::appDir() + type + "/" + filename);
 #else
  QString path = KStandardDirs::appDir() + type + "/" + filename;
 #endif
  //US Create the containing dir if needed
  KURL pathurl;
  pathurl.setPath(path);
  QString dir=pathurl.directory();
          //QMessageBox::information( 0,"path", path, 1 );
 #ifdef _WIN32_
  KStandardDirs::makeDir(path);
 #else
  KStandardDirs::makeDir(dir);
 #endif
  return path;
 #endif
 }
diff --git a/microkde/kdecore/kstandarddirs.h b/microkde/kdecore/kstandarddirs.h
index c4e1108..bee864e 100644
--- a/microkde/kdecore/kstandarddirs.h
+++ b/microkde/kdecore/kstandarddirs.h
@@ -1,681 +1,681 @@
 /*
  This file is part of the KDE libraries
  Copyright (C) 1999 Sirtaj Singh Kang <taj@kde.org>
                     Stephan Kulow <coolo@kde.org>
                     Waldo Bastian <bastian@kde.org>
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Library General Public License for more details.
  You should have received a copy of the GNU Library General Public License
  along with this library; see the file COPYING.LIB.  If not, write to
  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA 02111-1307, USA.
 */
 #ifndef SSK_KSTDDIRS_H
 #define SSK_KSTDDIRS_H
 #include <qstring.h>
 #include <qdict.h>
 #include <qstringlist.h>
 #include <kglobal.h>
 class KConfig;
 class KStandardDirsPrivate;
 /**
 * @short Site-independent access to standard KDE directories.
 * @author Stephan Kulow <coolo@kde.org> and Sirtaj Singh Kang <taj@kde.org>
 * @version $Id$
 *
 * This is one of the most central classes in kdelibs as
 * it provides a basic service: It knows where the files
 * reside on the user's hard disk. And it's meant to be the
 * only one that knows -- to make the real location as
 * transparent as possible to both the user and the applications.
 *
 * To this end it insulates the application from all information
 * and applications always refer to a file with a resource type
 * (e.g. icon) and a filename (e.g. khexdit.xpm). In an ideal world
 * the application would make no assumption where this file is and
 * leave it up to @ref KStandardDirs::findResource("apps", "Home.desktop")
 * to apply this knowledge to return /opt/kde/share/applnk/Home.desktop
 * or ::locate("data", "kgame/background.jpg") to return
 * /opt/kde/share/apps/kgame/background.jpg
 *
 * The main idea behind KStandardDirs is that there are several
 * toplevel prefixes below which the files lie. One of these prefixes is
 * the one where the user installed kdelibs, one is where the
 * application was installed, and one is $HOME/.kde, but there
 * may be even more. Under these prefixes there are several well
 * defined suffixes where specific resource types are to be found.
 * For example, for the resource type "html" the suffixes could be
 * share/doc/HTML and share/doc/kde/HTML.
 * So the search algorithm basicly appends to each prefix each registered
 * suffix and tries to locate the file there.
 * To make the thing even more complex, it's also possible to register
 * absolute paths that KStandardDirs looks up after not finding anything
 * in the former steps. They can be useful if the user wants to provide
 * specific directories that aren't in his $HOME/.kde directory for,
 * for example, icons.
 *
 * @sect Standard resources that kdelibs allocates are:
 *
 * @li apps - Applications menu (.desktop files).
 * @li cache - Cached information (e.g. favicons, web-pages)
 * @li cgi - CGIs to run from kdehelp.
 * @li config - Configuration files.
 * @li data - Where applications store data.
 * @li exe - Executables in $prefix/bin. @ref findExe() for a function that takes $PATH into account.
 * @li html - HTML documentation.
 * @li icon - Icons, see @ref KIconLoader.
 * @li lib - Libraries.
 * @li locale - Translation files for @ref KLocale.
 * @li mime - Mime types.
 * @li module - Module (dynamically loaded library).
 * @li qtplugins - Qt plugins (dynamically loaded objects for Qt)
 * @li services - Services.
 * @li servicetypes - Service types.
 * @li scripts - Application scripting additions.
 * @li sound - Application sounds.
 * @li templates - Templates
 * @li wallpaper - Wallpapers.
 * @li tmp - Temporary files (specfic for both current host and current user)
 * @li socket - UNIX Sockets (specific for both current host and current user)
 *
 * A type that is added by the class @ref KApplication if you use it, is
 * appdata. This one makes the use of the type data a bit easier as it
 * appends the name of the application.
 * So while you had to ::locate("data", "appname/filename") so you can
 * also write ::locate("appdata", "filename") if your KApplication instance
 * is called "appname" (as set via KApplication's constructor or KAboutData, if
 * you use the global KStandardDirs object @ref KGlobal::dirs()).
 * Please note though that you cannot use the "appdata"
 * type if you intend to use it in an applet for Kicker because 'appname' would
 * be "Kicker" instead of the applet's name. Therefore, for applets, you've got
 * to work around this by using ::locate("data", "appletname/filename").
 *
 * @sect KStandardDirs supports the following environment variables:
 *
 * @li KDEDIRS: This may set an additional number of directory prefixes to
 *          search for resources. The directories should be seperated
 *          by ':'. The directories are searched in the order they are
 *          specified.
 * @li KDEDIR:  Used for backwards compatibility. As KDEDIRS but only a single
 *          directory may be specified. If KDEDIRS is set KDEDIR is
 *          ignored.
 * @li KDEHOME: The directory where changes are saved to. This directory is
 *          used to search for resources first. If KDEHOME is not
 *          specified it defaults to "$HOME/.kde"
 * @li KDEROOTHOME: Like KDEHOME, but used for the root user.
 *          If KDEROOTHOME is not set it defaults to the .kde directory in the
 *          home directory of root, usually "/root/.kde".
 *          Note that the setting of $HOME is ignored in this case.
 *
 * @see KGlobalSettings
 */
 class KStandardDirs
 {
 public:
        /**
         * KStandardDirs' constructor. It just initializes the caches.
         **/
        KStandardDirs( );
        /**
         * KStandardDirs' destructor.
         */
        virtual ~KStandardDirs();
        /**
         * Adds another search dir to front of the @p fsstnd list.
         *
         * @li When compiling kdelibs, the prefix is added to this.
         * @li KDEDIRS or KDEDIR is taking into account
         * @li Additional dirs may be loaded from kdeglobals.
         *
         * @param dir The directory to append relative paths to.
         */
        void addPrefix( const QString& dir );
        /**
         * Adds another search dir to front of the XDG_CONFIG_XXX list 
         * of prefixes.
         * This prefix is only used for resources that start with "xdgconf-"
         *
         * @param dir The directory to append relative paths to.
         */
        void addXdgConfigPrefix( const QString& dir );
        /**
         * Adds another search dir to front of the XDG_DATA_XXX list 
         * of prefixes.
         * This prefix is only used for resources that start with "xdgdata-"
         *
         * @param dir The directory to append relative paths to.
         */
        void addXdgDataPrefix( const QString& dir );
        /**
         * Adds suffixes for types.
         *
         * You may add as many as you need, but it is advised that there
         * is exactly one to make writing definite.
         * All basic types (@ref kde_default) are added by @ref addKDEDefaults(),
         * but for those you can add more relative paths as well.
         *
         * The later a suffix is added, the higher its priority. Note, that the
         * suffix should end with / but doesn't have to start with one (as prefixes
         * should end with one). So adding a suffix for app_pics would look
         * like KGlobal::dirs()->addResourceType("app_pics", "share/app/pics");
         *
         * @param type Specifies a short descriptive string to access
         * files of this type.
         * @param relativename Specifies a directory relative to the root
         * of the KFSSTND.
         * @return true if successful, false otherwise.
         */
        bool addResourceType( const char *type,
                              const QString& relativename );
        /**
         * Adds absolute path at the end of the search path for
         * particular types (for example in case of icons where
         * the user specifies extra paths).
         *
         * You shouldn't need this
         * function in 99% of all cases besides adding user-given
         * paths.
         *
         * @param type Specifies a short descriptive string to access files
         * of this type.
         * @param absdir Points to directory where to look for this specific
         * type. Non-existant directories may be saved but pruned.
         * @return true if successful, false otherwise.
         */
        bool addResourceDir( const char *type,
                             const QString& absdir);
        /**
         * Tries to find a resource in the following order:
         * @li All PREFIX/\<relativename> paths (most recent first).
         * @li All absolute paths (most recent first).
         *
         * The filename should be a filename relative to the base dir
         * for resources. So is a way to get the path to libkdecore.la
         * to findResource("lib", "libkdecore.la"). KStandardDirs will
         * then look into the subdir lib of all elements of all prefixes
         * ($KDEDIRS) for a file libkdecore.la and return the path to
         * the first one it finds (e.g. /opt/kde/lib/libkdecore.la)
         *
         * @param type The type of the wanted resource
         * @param filename A relative filename of the resource.
         *
         * @return A full path to the filename specified in the second
         *         argument, or QString::null if not found.
         */
        QString findResource( const char *type,
                              const QString& filename ) const;
        /**
         * Checks whether a resource is restricted as part of the KIOSK
         * framework. When a resource is restricted it means that user-
         * specific files in the resource are ignored.
         *
         * E.g. by restricting the "wallpaper" resource, only system-wide
         * installed wallpapers will be found by this class. Wallpapers
         * installed under the $KDEHOME directory will be ignored.
         *
         * @param type The type of the resource to check
         * @param relPath A relative path in the resource.
         *
         * @return True if the resource is restricted.
         * @since 3.1
         */
        bool isRestrictedResource( const char *type,
                              const QString& relPath=QString::null ) const;
        /**
         * Returns a number that identifies this version of the resource.
         * When a change is made to the resource this number will change.
         *
         * @param type The type of the wanted resource
         * @param filename A relative filename of the resource.
         * @param deep If true, all resources are taken into account
         *        otherwise only the one returned by findResource().
         *
         * @return A number identifying the current version of the
         *          resource.
         */
 /*US   
        Q_UINT32 calcResourceHash( const char *type,
                              const QString& filename, bool deep) const;
 */
        /**
         * Tries to find all directories whose names consist of the
         * specified type and a relative path. So would
         * findDirs("apps", "Settings") return
         * @li /opt/kde/share/applnk/Settings/
         * @li /home/joe/.kde/share/applnk/Settings/
         *
         * Note that it appends / to the end of the directories,
         * so you can use this right away as directory names.
         *
         * @param type The type of the base directory.
         * @param reldir Relative directory.
         *
         * @return A list of matching directories, or an empty
         *         list if the resource specified is not found.
         */
        QStringList findDirs( const char *type,
                              const QString& reldir ) const;
        /**
         * Tries to find the directory the file is in.
         * It works the same as @ref findResource(), but it doesn't
         * return the filename but the name of the directory.
         *
         * This way the application can access a couple of files
         * that have been installed into the same directory without
         * having to look for each file.
         *
         * findResourceDir("lib", "libkdecore.la") would return the
         * path of the subdir libkdecore.la is found first in
         * (e.g. /opt/kde/lib/)
         *
         * @param type The type of the wanted resource
         * @param filename A relative filename of the resource.
         * @return The directory where the file specified in the second
         *         argument is located, or QString::null if the type
         *         of resource specified is unknown or the resource
         *         cannot be found.
         */
        QString findResourceDir( const char *type,
                                 const QString& filename) const;
        /**
         * Tries to find all resources with the specified type.
         *
         * The function will look into all specified directories
         * and return all filenames in these directories.
         *
         * @param type The type of resource to locate directories for.
         * @param filter Only accept filenames that fit to filter. The filter
         *        may consist of an optional directory and a @ref QRegExp
         *        wildcard expression. E.g. "images\*.jpg". Use QString::null
         *        if you do not want a filter.
         * @param recursive Specifies if the function should decend
         *        into subdirectories.
         * @param uniq If specified,  only return items which have
         *        unique suffixes - suppressing duplicated filenames.
         *
         * @return A list of directories matching the resource specified,
         *         or an empty list if the resource type is unknown.
         */
        QStringList findAllResources( const char *type,
                                       const QString& filter = QString::null,
                                       bool recursive = false,
                                       bool uniq = false) const;
        /**
         * Tries to find all resources with the specified type.
         *
         * The function will look into all specified directories
         * and return all filenames (full and relative paths) in
         * these directories.
         *
         * @param type The type of resource to locate directories for.
         * @param filter Only accept filenames that fit to filter. The filter
         *        may consist of an optional directory and a @ref QRegExp
         *        wildcard expression. E.g. "images\*.jpg". Use QString::null
         *        if you do not want a filter.
         * @param recursive Specifies if the function should decend
         *        into subdirectories.
         * @param uniq If specified,  only return items which have
         *        unique suffixes.
         * @param list Of relative paths for the given type.
         * @param relPaths The list to store the relative paths into
         *        These can be used later to ::locate() the file
         *
         * @return A list of directories matching the resource specified,
         *         or an empty list if the resource type is unknown.
         */
        QStringList findAllResources( const char *type,
                                       const QString& filter,
                                       bool recursive,
                                       bool uniq,
                                       QStringList &relPaths) const;
        /**
         * Finds the executable in the system path.
         *
         * A valid executable must
         * be a file and have its executable bit set.
         *
         * @param appname The name of the executable file for which to search.
         * @param pathstr The path which will be searched. If this is
                 *      null (default), the $PATH environment variable will
                 *      be searched.
                 * @param ignoreExecBitIf true, an existing file will be returned
                 *              even if its executable bit is not set.
         *
         * @return The path of the executable. If it was not found,
         *         it will return QString::null.
         * @see findAllExe()
         */
 /*US   
        static QString findExe( const QString& appname,
                                const QString& pathstr=QString::null,
                                bool ignoreExecBit=false );
 */
        /**
         * Finds all occurences of an executable in the system path.
         *
                 * @param listWill be filled with the pathnames of all the
                 *      executables found. Will be empty if the executable
                 *      was not found.
                 * @param appnameThe name of the executable for which to
                 *              search.
                 * @param pathstrThe path list which will be searched. If this
                 *      is 0 (default), the $PATH environment variable will
                 *      be searched.
         * @param ignoreExecBit If true, an existing file will be returned
                 *              even if its executable bit is not set.
         *
         * @return The number of executables found, 0 if none were found.
         *
                 * @seefindExe()
         */
        static int findAllExe( QStringList& list, const QString& appname,
                               const QString& pathstr=QString::null,
                               bool ignoreExecBit=false );
        /**
         * This function adds the defaults that are used by the current
         * KDE version.
         *
         * It's a series of @ref addResourceTypes()
         * and @ref addPrefix() calls.
         * You normally wouldn't call this function because it's called
         * for you from @ref KGlobal.
         */
        void addKDEDefaults();
        /**
         * Reads customized entries out of the given config object and add
         * them via @ref addResourceDirs().
         *
         * @param config The object the entries are read from. This should
         *        contain global config files
         * @return true if new config paths have been added
         * from @p config.
         **/
        bool addCustomized(KConfig *config);
        /**
         * This function is used internally by almost all other function as
         * it serves and fills the directories cache.
         *
         * @param type The type of resource
         * @return The list of possible directories for the specified @p type.
         * The function updates the cache if possible.  If the resource
         * type specified is unknown, it will return an empty list.
         * Note, that the directories are assured to exist beside the save
         * location, which may not exist, but is returned anyway.
         */
        QStringList resourceDirs(const char *type) const;
        /**
         * This function will return a list of all the types that KStandardDirs
         * supports.
         *
         * @return All types that KDE supports
         */
        QStringList allTypes() const;
        /**
         * Finds a location to save files into for the given type
         * in the user's home directory.
         *
         * @param type The type of location to return.
         * @param suffix A subdirectory name.
         *             Makes it easier for you to create subdirectories.
         *   You can't pass filenames here, you _have_ to pass
         *       directory names only and add possible filename in
         *       that directory yourself. A directory name always has a
          *       trailing slash ('/').
         * @param create If set, saveLocation() will create the directories
         *        needed (including those given by @p suffix).
         *
         * @return A path where resources of the specified type should be
         *         saved, or QString::null if the resource type is unknown.
         */
         QString saveLocation(const char *type,
                              const QString& suffix = QString::null,
                              bool create = true) const;
        /**
         * Converts an absolute path to a path relative to a certain
         * resource.
         *
         * If "abs = ::locate(resource, rel)"
         * then "rel = relativeLocation(resource, abs)" and vice versa.
         *
         * @param type The type of resource.
         *
         * @param absPath An absolute path to make relative.
         *
         * @return A relative path relative to resource @p type that
         * will find @p absPath. If no such relative path exists, absPath
         * will be returned unchanged.
         */
         QString relativeLocation(const char *type, const QString &absPath);
        /**
         * Recursively creates still-missing directories in the given path.
         *
         * The resulting permissions will depend on the current umask setting.
         * permission = mode & ~umask.
         *
         * @param dir Absolute path of the directory to be made.
         * @param mode Directory permissions.
         * @return true if successful, false otherwise
         */
        static bool makeDir(const QString& dir, int mode = 0755);
        /**
         * This returns a default relative path for the standard KDE
         * resource types. Below is a list of them so you get an idea
         * of what this is all about.
         *
         * @li data - share/apps
         * @li html - share/doc/HTML
         * @li icon - share/icon
         * @li config - share/config
         * @li pixmap - share/pixmaps
         * @li apps - share/applnk
         * @li sound - share/sounds
         * @li locale - share/locale
         * @li services - share/services
         * @li servicetypes - share/servicetypes
         * @li mime - share/mimelnk
         * @li wallpaper - share/wallpapers
         * @li templates - share/templates
         * @li exe - bin
         * @li lib - lib
         *
         * @returns Static default for the specified resource.  You
         *          should probably be using locate() or locateLocal()
         *          instead.
         * @see locate()
         * @see locateLocal()
         */
        static QString kde_default(const char *type);
        /**
         * @internal (for use by sycoca only)
         */
        QString kfsstnd_prefixes();
        /**
         * Returns the toplevel directory in which KStandardDirs
         * will store things. Most likely $HOME/.kde
         * Don't use this function if you can use locateLocal
         * @return the toplevel directory
         */
        QString localkdedir() const;
        /**
         * @return $XDG_DATA_HOME
         * See also http://www.freedesktop.org/standards/basedir/draft/basedir-spec/basedir-spec.html
         */
        QString localxdgdatadir() const;
        /**
         * @return $XDG_CONFIG_HOME
         * See also http://www.freedesktop.org/standards/basedir/draft/basedir-spec/basedir-spec.html
         */
        QString localxdgconfdir() const;
        /**
         * Checks for existence and accessability.
         * Faster than creating a QFileInfo first.
         * @param fullPath the path to check
         * @return true if the directory exists
         */
        static bool exists(const QString &fullPath);
        /**
         * Expands all symbolic links and resolves references to 
         * '/./', '/../' and extra  '/' characters in @p dirname
         * and returns the canonicalized absolute pathname.
         * The resulting path will have no symbolic link, '/./' 
         * or '/../' components.
         * @since 3.1
         */
        static QString realPath(const QString &dirname);
        
    static void setAppDir( const QString & );
    static QString appDir();
-        
+         
 private:
        QStringList prefixes;
        // Directory dictionaries
        QDict<QStringList> absolutes;
        QDict<QStringList> relatives;
        mutable QDict<QStringList> dircache;
        mutable QDict<QString> savelocations;
        // Disallow assignment and copy-construction
        KStandardDirs( const KStandardDirs& );
        KStandardDirs& operator= ( const KStandardDirs& );
        bool addedCustoms;
        class KStandardDirsPrivate;
        KStandardDirsPrivate *d;
 //US    
    static QString mAppDir;
        void checkConfig() const;
        void applyDataRestrictions(const QString &) const;
        //US void createSpecialResource(const char*);
 };
 /**
 * \addtogroup locates Locate Functions
 *  @{
 * On The Usage Of 'locate' and 'locateLocal'
 *
 * Typical KDE applications use resource files in one out of
 * three ways:
 *
 * 1) A resource file is read but is never written. A system
 *    default is supplied but the user can override this
 *    default in his local .kde directory:
 *
 *    \code
 *    // Code example
 *    myFile = locate("appdata", "groups.lst");
 *    myData =  myReadGroups(myFile); // myFile may be null
 *    \endcode
 *
 * 2) A resource file is read and written. If the user has no
 *    local version of the file the system default is used.
 *    The resource file is always written to the users local
 *    .kde directory.
 *
 *    \code
 *    // Code example
 *    myFile = locate("appdata", "groups.lst")
 *    myData =  myReadGroups(myFile);
 *    ...
 *    doSomething(myData);
 *    ...
 *    myFile = locateLocal("appdata", "groups.lst");
 *    myWriteGroups(myFile, myData);
 *    \endcode
 *
 * 3) A resource file is read and written. No system default
 *    is used if the user has no local version of the file.
 *    The resource file is always written to the users local
 *    .kde directory.
 *
 *    \code
 *    // Code example
 *    myFile = locateLocal("appdata", "groups.lst");
 *    myData =  myReadGroups(myFile);
 *    ...
 *    doSomething(myData);
 *    ...
 *    myFile = locateLocal("appdata", "groups.lst");
 *    myWriteGroups(myFile, myData);
 *    \endcode
 **/
 /*!
 * \relates KStandardDirs
 * This function is just for convenience. It simply calls
 *instance->dirs()->\link KStandardDirs::findResource() findResource\endlink(type, filename).
 **/
 QString locate( const char *type, const QString& filename /*US , const KInstance* instance = KGlobal::instance()*/ );
 /*!
 * \relates KStandardDirs
 * This function is much like locate. However it returns a
 * filename suitable for writing to. No check is made if the
 * specified filename actually exists. Missing directories
 * are created. If filename is only a directory, without a
 * specific file, filename must have a trailing slash.
 *
 **/
 QString locateLocal( const char *type, const QString& filename /*US , const KInstance* instance = KGlobal::instance() */ );
 /*!
 * \relates KStandardDirs
 * This function is much like locate. No check is made if the
 * specified filename actually exists. Missing directories
 * are created if @p createDir is true. If filename is only 
 * a directory, without a specific file, 
 * filename must have a trailing slash.
 *
 **/
 QString locateLocal( const char *type, const QString& filename, bool createDir /*US , const KInstance* instance = KGlobal::instance() */);
 /*! @} */
 #endif // SSK_KSTDDIRS_H