This file is meant to be a place to track of medium to large-scale API changes
that we would like to make for the next binary incompatible release.

- Check for forked classes in kde pim and other modules
  (Danimo)

- Change all FooPrivate *d; -> Private * const d; and place initialization
  in the constructor (for classes that would benefit from this).  To help catch silly
  mistakes since d should never change. Also consider changing to use KStaticDeleter to
  help prevent mistakes where developers forget to delete the pointer. Maybe make use of
  Qt4 helper macros? 
  (Frerich)

- Move all utility functions away from KApplication. TBD: Make KApplication 
  a very thin wrapper around QApplication. Ideally, KApplication should go 
  away completely. The kapp pointer references everywhere must die. Find a 
  way to make that possible
  (Danimo)

  The refcounting can simply be moved to KGlobal (or something similar), as it
  only depends on the refcounter variable and KMainWindow, KIO::Job, etc. calling
  these instead of quit() directly.

  To make mixing QMainWindow with KIO::Job possible some 'registry' in KGlobal could
  keep track of the jobs and set QApplication::setQuitOnLastWindowClosed accordingly.

  (Simon, David, Danimo, Zack)

- Remove all KSocks references throughout KDE in favor of KNetwork's
  socket implementations. 
  (Thiago)

- Remove all methods marked 'deprecated' in KDE 3.x.
  (Martijn)

- Make it possible to create a KSystemTray without a KMainWindow and instead lazily
  create the main window on demand.
  (Martijn)

- Make KSystemTray add its own reference to KApp, so tray apps that adhere to the
  style guide can safely close their main window without having to worry about
  the app quitting instead.
  (Martijn)

- Sort out reference counting of applications and KMainWindows: Add a setRefCountEnabled()
  function to KApplication; deref()ing the last reference should only quit the application
  if reference counts are enabled, and the reference count should be disabled by default
  so apps that don't use a KMainWindow mostly continue to work. Make the KMainWindow
  constructor call setRefCountEnabled(true), and make each KMainWindow hold its own
  reference to the application. The KMainWindow should drop its app reference on hide, and
  regain it on show.

  Make KSysTray also hold a reference to the app. Then apps that use more than one main
  window and the tray (like KSIrc and Kopete) will quit at the right time without nasty
  hacks.
  (Richard Smith)

- Make some long-lasting operations threaded. There are some operations in KDE that
  take too long on at least ~500MHz hardware to be done using event loops. Examples
  are the use of KLibLoader to dlopen plugins and KRun to fire up other processes.
  Konqueror and KMail tend to stall occasionally too, but that's harder to refactor
  because the bulk of the work there is X11-related.
  (Martijn)

- Make it possible to use SSL-ed sockets outside KIO. KSSL isn't very suitable for
  reuse, and the certificate dialogs are not even available in public API at all,
  leading e.g. to Kopete IRC duplicating a lot of stuff and all KDE Jabber clients
  based on libpsi (PSI, Light Hawk and Kopete) using homebrewn solutions.  [How
  does this have to do with changing KIO?  It's just a request to have that
  code in a different form....]
  (Martijn)

- Use of the C++ keyword "explicit". Make all ctors explicit which can be used
  with one parameter to minimize wrong use of the class (i.e. have a look at 
  Dirk's work on KUrl).
  KGuiItem has one of these dangerous ctors, too. KUser has a whole bunch
  of them.
  (André Wöbbeking)

- Solve need for casting when using bitfield enums (e.g. KProcess::Communication)
  by the use of Q_DECLARE_FLAGS/Q_DECLARE_OPERATORS_FOR_FLAGS
  (Simon)

- Merge kdelibs/kdecore/kuser.h and kdeadmin/kuser/kuser.h.
  (Frans)

- Simplify memory management with KParts. The part and the widget delete each other,
  which in fact makes it more complex to handle. The part owns the widget so it
  should delete it, but not the other way round.
  (David)

- KParts: remove plugin loading from setInstance, add an explicit loadPlugins() call
  in all parts that should load plugins (at the end of the derived-part ctor).
  (David)

- KParts: come up with better names for ReadOnlyPart and ReadWritePart, ReadOnly
  is a minimum requirement, but this does not become clear until you dig deeper
  into the class. With QTextEdit and QTextBrowser for instance, the inheritance is
  the other way around. E.g.: ReaderPart? ViewerPart?
  (David)

- Other ideas in this thread: http://lists.kde.org/?l=kde-core-devel&m=107608067302571&w=2
  (Contributors to that thread, please add specific items here.)
  (Waldo)

- Change classes that store bool data using strings ("true"/"false") to use bool 
  calls (readBoolEntry()).  Although not technicaly a binary incompatiblity... 
  just something to bring up for possible change (for the better)

  Use KConfigXT instead! /FransE

- Is it really necessary to bother people using the KCM APIs with withFallback? I have
  never heard of it failing and when would you not like to have that fallback? I think
  a default of 'true' would be fine(and remove the argument in the APIs).
  (Frans)

- Do we need to have factory arguments in the KCM API? (who would use it anyway?)
  (Frans)

- KCModuleInfo should use d-pointer. Perhaps there are more classes.
  (Frans)

- The config options in kdeglobals needs to be cleaned up a little. Perhaps I'm being picky..
	* They should be named properly, for example "enableIcons" instead of "EnableIcons". Or atleast
		settle on one thing.
	* AFAICT it would be the right thing if KWin had its own rc file instead of having its "WM" 
		section in kdeglobals.
	* Shouldn't KSpell have its own rc file instead of kdeglobals?
	* Should we allow spaces in option names?
	* Some option names are too short for being understandable. fixed->fixedFont; font->systemWideFont
	* Perhaps an own font section?
  (Frans)

- kpassworddialog.h needs a facelift - see the comments in kpassworddialog.{h,cpp}
  (Frans)

- Replace KPasswordEdit with KLineEdit and adjust KPasswordDialog accordingly.
  (Waldo)

- KProcess needs a major facelift. Not all of these items need to be BIC, but not needing to
  worry about legacy will certainly allow an overall cleaner solution.
  - the internals need to be encapsulated properly. many of the virtuals shouldn't be virtual;
    lots of protected members should be accessible only via accessors. the current model is
    theoretically super-flexible, but in fact it is only super-fragile.
  - clear up pipe() vs. socketpair() usage.
  - move the draining loop from commClose() to wait()
  - add additional "channels" beyond std*, with the built-in capability of passing the fd on the
    command line
  - redirections, including piping multiple kprocesses together. this should make most cases of
    reimplementing commSetupDone{P,C} superfluous.
  - possibly create KForkProcess that covers most/all of the remaining commSetupDoneC
    reimplementations.
  - do something about the NoRead comm mode
  - add setComm(); remove comm arg from start(). as a side effect, this will allow for using
    writeStdin() in Block mode.
  - merge KProcIO into KProcess; add setBuffered() for separate channels.
  - use QByteArray for writeStdin(). better than the buf+len arg, as it is ref-counted.
  (Oswald)

- To discuss: Migrate the about dialog to use qhtml or khtml rather then the current
  setup of all of the widgets and sub widgets.  Might be a lot simpler, require a lot
  less code and be much more flexible for additions/enhancments.  Sidenote: currently
  the about information seems to be duplicated.
  (Scott)

- KKeyDialog needs to be improved. It should simplify using KKeyChooser by not having to instantiate
  KDialogBase without restricting the possibilities of KKeyChooser (for instance, being able to
  configure global and application accels in one dialog). If there is only little time, simply
  expose the KKeyChooser object instead of making it private and inaccessible.
  (Michael Brade)

- Fix the APIs taking Matthias Ettrich's hints into account, most importantly fix the massive
  amount of bool-usage in the CTORs
  (Michael Brade)

- Implement a "default" ctor for the widgets i.e. explicit Foo(QWidget* parent = 0).
  (André Wöbbeking)

- KWallet::Wallet::* functions - remove the default = 0 argument for mainwindow for the dialog
  (Lubos)

- Make libkwalletclient part of libkio and get rid of libkwalletclient.
  (Waldo)

- Get rid of libkdesu dependency in libkio, get rid of KIO::SessionData::AuthData*
  (Waldo)

- Make functions in KHelpMenu virtual so they can be overridden (ex: to provide
  an alternative help->contents action)
  (George Staikos)

- Make sure all GUI classes adopt well to palette changes.
  (Danimo)

- Rework KPanelExtension and KPanelApplet to have a sane set of global position
  enums, make the geometry handling less spaghetti like and extend the API so
  requests for things like re-reading the config of a KPanelExtension can be
  done by its parent.
  (Aaron)

- Fix KUrlRequester API to use KUrl for urls instead of QString to make clear that
  we work with URLs and not with paths.
  (Waldo)

- K3ListView: merge setDropHighlighter and setDropVisualizer, add a setDnDMode to choose between
  "dnd to move items" (e.g. keditbookmarks) and "dnd onto items" (e.g. kmail). Unless Qt4 does it all :)
  (David)

- Move KIO::findDeviceMountPoint, findPathMoundPoint, probably_slow_mounted, and testFileSystemFlag to KMountPoint,
  to merge that code.
  (David / Joseph Wenninger)

- Rename the parameters to KDEDesktopMimeType::pixmap so that they use meaningful names rather than
  just a, b, c, and d. Probably not something that has to wait for KDE 4, but seems like a good idea
  to have here for later doing.
  (Matt Rogers)

- Add the concept of a session to KIO, in particular for KHTML so that it can
  have all of its jobs associated in some way (a unique key of sorts).  Will
  make SSL much easier to implement and allow removal of many hacks, mostly
  involving metadata.
  (George Staikos)

- KDE 4: Check if QTemporaryFile is good enough to dump KTempFile
  (Albert Astals Cid)

- Make KLibLoader default to RTLD_GLOBAL and make necessary changes to make KDE namespace clean.
  (Coolo)
  Maybe just make sure we don't emit multiple copies of per-class data (vtable,RTTI), then
  RTLD_LOCAL should do as well, and it should(?) be simpler this way.
  (Lubos)

- Replacing QPtrList with QList<*> is tricky for places where the old list used autoDelete().  It
  may be worthwhile to create a convenience class which mimics QList but allows for autoDeleting.
  (Caleb Tennis)
  I disagree, a list property is very confusing, especially when code toggles it on and off all
  the time, and remove() changes semantics depending on the current state of the autodelete setting...
  Let's just port it all to QList like Qt4 did. 
  (David)

- Many instances of creating containers on the heap instead of stack, can be replaced? (Caleb Tennis) [where?]

- Remove all of the (const char *name) arguments to QObject derived classes. (Caleb Tennis)

- Caleb KGuiItem be replaced by QAction?  They seem to encompass the exact same data.

- Qt4 has no QWizard (only Q3Wizard left). Add a new KDE standards-compliant wizard with 
  a bit more powerful API and features like "Steps list" pane on the left hand of the wizard
  (user can click any step if developer allowed such action). Example from OO.org:
  http://www.openoffice.org/dev_docs/features/2.0/images/mail_merge.jpg
  We could add more consistency (using themes, guidelines) in this area, 
  as in KDE3 some apps implement wizard's features like left-hand funky pictures 
  or help text again and again
  (see http://www.kolab.org/doc/kde-client-manual-0.9cvs20030801-html/c43.html).
  Other ideas: 
  * use nonintrusive "watermark" effect on the 1st or all pages 
  (http://images.apple.com/macosx/features/setup/images/index_setup20050412.jpg), 
  * allow to disable steps on the left-side list as an answer to calling setAppropriate().
  * QWizard's API is mostly ok for the new class, just avoid requiring to pass a pointer 
  to page widget (as in setAppropriate()) but allow to pass QString names or IDs instead.
  (Jaroslaw Staniek)

- K3IconView/K3ListView equivalents based on Qt4 interview. As discussed on kde-core-devel,
  this probably means a custom QItemDelegate instead, to handle single-click/double-click,
  execute-mode/select-mode (cf K3IconView), number of lines used for wrapping, "held" signal.
  In short, rewriting k3iconview features to be based on interview.
  For K3ListView we need to check if QTreeView supports both modes of drag-n-drop (dropping
  onto items, and dropping between items like in the bookmark editor).
  (David, Till etc.)

- CMake:
   * install man pages (e.g. doc/kdelibs/man-kbuildsycoca.8.docbook)
   * compile and install documentation (doc/kspell)
   * install /share/apps/ksgmltools2/customization/entities/kde-standard-accels.entities

- Increase version numbers in sonames of our libraries (*.so.version). 
  Unless we rename them all anyway, see next item.

- Keep in mind the big picture: http://developer.kde.org/~danimo/kde4foundation.png
  i.e. core/gui separation, and possibly components/framework separation.

  Many KIO classes are "core only" and should move to kdecore
  KArchive and derivatives, KACL -> core (probably components/core)
  KURIFilter, KEMailSettings, K*Share -> core  (probably framework/core)
  So before moving things to kdecore, I want to make sure everyone's ok (at least aware :) )
  of the planned components / framework separation and then we can start moving 
  stuff to the right place. To do this smoothly we could start with moving everything
  to framework for now, and considering moving individual things to components
  as we go along. Reminder: the idea of components is simply that those classes
  should be useable without dependencies on other kde classes. Think "would I
  be able to use this class in a Qt-only project, by just copying it over". This excludes
  anything KConfig/KStandardDirs-based, or anything KIO-based of course.

  For KIO jobs it's more tricky, we'll have to think of a way to split core from gui, 
  not sure how yet. Proposals welcome. (David)
  When doing the reorganization, we could also rename the last .cc files to .cpp. (David)

- Installing camelcase forwarding headers (e.g. the file KMainWindow would include kmainwindow.h),
  for instance using a modified version of $QTDIR/bin/syncqt

- Merge kdecore classes KWin and KWinModule into KWinModule, turn NET class into namespace (Lubos)

- Is the malloc.c implementation still needed now that glibc 2.3 is widely
  available and glibc 2.4 is around the corner?  Also, there is a more recent
  version of Doug Lea's malloc.c available, so perhaps updating to that
  version would be a good move (bug fixes)? (Caleb)

- It looks like most of the functions KStringHandler can be removed.  At least, insword, setword, 
  remrange, and remword could be removed.  Those four don't seem to be used anywhere inside of KDE.  Other
  functions like capitalize and reverse seem to be sparsely used.  And the squeeze methods can be redone
  per Simon's note above. (Caleb)

- Prevent re-entering event loop in kded to avoid reentrancy problems like with kwallet in KDE3 (Lubos).
