Add d ptr

add comments and FIXMEs
three new signals for otodoaccess

17 files changed, 41 insertions, 9 deletions

diff --git a/libopie/colordialog.h b/libopie/colordialog.h
index 1a6a3fd..c825a83 100644
--- a/libopie/colordialog.h
+++ b/libopie/colordialog.h
@@ -1,89 +1,90 @@
 /****************************************************************************
 ** $Id$
 **
 ** Definition of OColorDialog class
 **
 ** Created : 990222
 **
 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the dialogs module of the Qt GUI Toolkit.
 **
 ** This file may be distributed under the terms of the Q Public License
 ** as defined by Trolltech AS of Norway and appearing in the file
 ** LICENSE.QPL included in the packaging of this file.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
 ** licenses may use this file in accordance with the Qt Commercial License
 ** Agreement provided with the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 **   information about Qt Commercial License Agreements.
 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #ifndef OColorDialog_H
 #define OColorDialog_H
 
 #ifndef QT_H
 #include <qdialog.h>
 #endif // QT_H
 
 class OColorDialogPrivate;
 
 /*
  * @class OColorDialog
  * @brief The OColorDialog class is a copy of QColorDialog for use in Opie.
  *
  * OColorDialog is a copy of TrollTech's QColorDialog for use in Opie.  The default
  * build of QT/Embedded used by Opie does not include QColorDialog, so it is provided
  * here.  It is renamed to prevent conflicts in the event the QColorDialog is included
  * at a later date in QP/E.
  *
  * See http://doc.trolltech.com/2.3/qcolordialog.html for complete documentation of
  * QColorDialog.
  */
 class Q_EXPORT OColorDialog : public QDialog
 {
     Q_OBJECT
 
 public:
     static QColor getColor( const QColor&, QWidget *parent=0, const char* name=0 );
     static QRgb getRgba( const QRgb&, bool* ok = 0,
                          QWidget *parent=0, const char* name=0 );
 
 private:
     ~OColorDialog();
 
+    // FIXME add WFlags? -zecke
     OColorDialog( QWidget* parent=0, const char* name=0, bool modal=FALSE );
     void setColor( const QColor& );
     QColor color() const;
 
 private:
     void setSelectedAlpha( int );
     int selectedAlpha() const;
 private:
     OColorDialogPrivate *d;
     friend class OColorDialogPrivate;
 
         private:// Disabled copy constructor and operator=
 #if defined(Q_DISABLE_COPY)
     OColorDialog( const OColorDialog & );
     OColorDialog& operator=( const OColorDialog & );
 #endif
 };
 
 #endif
diff --git a/libopie/colorpopupmenu.h b/libopie/colorpopupmenu.h
index 3e90c5e..98d67cc 100644
--- a/libopie/colorpopupmenu.h
+++ b/libopie/colorpopupmenu.h
@@ -53,202 +53,203 @@ class OColorPanelButton : public QFrame
 {
     Q_OBJECT
 
 public:
 
 /**
  * @fn OColorPanelButton( const QColor& color, QWidget* parent = 0, const char* name = 0 )
  * @brief Object constructor.
  *
  * @param color Desired color.
  * @param parent Pointer to parent of this control.
  * @param name Name of control.
  *
  * Constructs a new ColorPanelButton control with parent, name and desired color.
  */
     OColorPanelButton(const QColor& color, QWidget* parent = 0, const char* name = 0);
 
 /**
  * @fn ~OColorPanelButton()
  * @brief Object destructor.
  */
     ~OColorPanelButton();
 
 /**
  * @fn setActive( bool active )
  * @brief Sets button selection state.
  *
  * @param active Boolean indicator of new button state.
  *
  * Changes button selection state.  If button is selected, a highlighted border
  * is drawn.
  */
     void setActive(bool active);
 
 /**
  * @fn enterEvent( QEvent* e )
  * @brief Reimplemented for internal reasons.
  *
  * @param e Event currently being processed.
  *
  * Reimplemented to ensure correct display of button based on whether it is
  * active or not.
  */
     void enterEvent(QEvent* e);
 
 /**
  * @fn leaveEvent( QEvent* e )
  * @brief Reimplemented for internal reasons.
  *
  * @param e Event currently being processed.
  *
  * Reimplemented to ensure correct display of button based on whether it is
  * active or not.
  */
     void leaveEvent(QEvent* e);
 
 /**
  * @fn paintEvent( QPaintEvent* e )
  * @brief Reimplemented for internal reasons.
  *
  * @param e Event currently being processed.
  * @reimp
  * Reimplemented to ensure correct display of button.
  */
     void paintEvent(QPaintEvent* e);
 
 /**
  * @fn mouseReleaseEvent( QMouseEvent* e )
  * @brief Slot executed when button is pressed.
  *
  * @param e Mouse event currently being processed.
  *
  * @see selected()
  *
  * This slot executes when the button has been pressed.  It emits the selected
  * signal as notification that it has been pressed.
  */
     void mouseReleaseEvent(QMouseEvent* e);
 
 signals:
 
 /**
  * @fn selected( const QColor& color )
  * @brief Signal to indicate button has been pressed.
  *
  * @param color Button color.
  *
  * This signal is emitted when the button is pressed.  It provides the color
  * associated to this button.
  */
     void selected(const QColor&);
 
 private:
     QColor m_color;
     bool m_active : 1;
     class ColorPanelButtonPrivate;
     ColorPanelButtonPrivate *d;
 };
 
 /**
  * @class OColorPopupMenu
  * @brief The OColorPopupMenu class provides a small color selection
  *        popup menu.
  *
  * OColorPopupMenu is a derivation of TrollTech's QPopupMenu and provides
  * a small color selection popup menu which can be attached to another control
  * such as a toolbar button of menu item.
  *
  * The popup menu displays 30 default colors available in a grid, and also
  * includes an option at the bottom to display a color selection dialog box for
  * finer color control.
  */
 class OColorPopupMenu : public QPopupMenu
 {
     Q_OBJECT
 
 public:
 
 /**
  * @fn OColorPopupMenu( const QColor& color, QWidget* parent = 0, const char* name = 0 )
  * @brief Object constructor.
  *
  * @param color Initial color selected in menu.
  * @param parent Pointer to parent of this control.
  * @param name Name of control.
  *
  * Constructs a new OColorPopupMenu control with parent, name and initial color selected.
  */
+ // FIXME add Wflags? -zecke
     OColorPopupMenu( const QColor& color, QWidget* parent = 0, const char* name = 0 );
 
 /**
  * @fn ~OColorPopupMenu()
  * @brief Object destructor.
  */
     ~OColorPopupMenu();
 
 private:
     class ColorPopupMenuPrivate;
     ColorPopupMenuPrivate *d;
     QColor       m_color;
     QWidget*     colorPanel;
     QGridLayout* colorLayout;
 
 /**
  * @fn addColor( const QColor& color, int row, int col )
  * @brief Adds color selection option to popup menu.
  *
  * @param color Color to be displayed in menu.
  * @param row Row where color is to appear in menu.
  * @param col Column where color is to appear in menu.
  *
  * Adds a color selection option to popup menu.  Used internally when
  * initially constructing the menu control.
  */
     void addColor( const QColor& color, int row, int col );
 
 signals:
 
 /**
  * @fn colorSelected( const QColor& color )
  * @brief Signal to indicate color chosen from the menu.
  *
  * @param color Color selected from the menu.
  *
  * This signal is emitted when a color has been selected either directly from
  * the menu, or chosen from the color selection dialog.
  */
     void colorSelected( const QColor& color );
 
 protected slots:
 
 /**
  * @fn buttonSelected( const QColor& color )
  * @brief Slot to process selected color.
  *
  * @param color Color selected from the menu.
  *
  * @see colorSelected()
  *
  * This slot executes when a color has been selected from the menu.  It performs
  * two functions:
  * - Emit the colorSelected signal with the color selected.
  * - Hide the menu.
  */
     void buttonSelected( const QColor& color );
 
 /**
  * @fn moreColorClicked()
  * @brief Slot to process display color selection dialog.
  *
  * @see colorSelected()
  *
  * This slot executes when the 'More...' option is selected at the bottom of the menu.
  * It performs the following functions:
  * - Constructs and executes a OColorDialog to allow finer color selection.
  * - Emit the colorSelected signal with the color selected.
  * - Hide the menu.
  */
     void moreColorClicked();
 };
 
 #endif // COLORPOPUPMENUANEL_H
diff --git a/libopie/oclickablelabel.h b/libopie/oclickablelabel.h
index 6e7a123..f93ade0 100644
--- a/libopie/oclickablelabel.h
+++ b/libopie/oclickablelabel.h
@@ -1,64 +1,68 @@
 #ifndef CLICKABLELABEL
 #define CLICKABLELABEL
 
 #include <qlabel.h>
 
 /**
  * This class is a special QLabel which can behave
  * as a QPushButton or QToggleButton.
  * The reason to use a clickable is if you want to save space
  * or you want to skip the border of a normal button
  *
  * <pre>
  *  QLabel* lbl = new OClickableLabel( parent, "PushLabel" );
  *  lbl->setPixmap( "config" );
  *  QWhatsThis::add( lbl, tr("Click here to do something") );
  * </pre>
  *
  * @short A Label behaving as button
  * @author Hakan Ardo, Maximillian Reiß ( harlekin@handhelds.org )
  * @see QLabel
  * @see QPushButton
  * @see QToggleButton
  * @version 1.0
  */
 
 class OClickableLabel: public QLabel
 {
   Q_OBJECT
 public:
     OClickableLabel(QWidget* parent = 0, const char* name = 0,
                    WFlags fl = 0);
     void setToggleButton(bool t);
 
  protected:
     /** @internal */
     void mousePressEvent( QMouseEvent *e );
     /** @internal */
     void mouseReleaseEvent( QMouseEvent *e );
     /** @internal */
     void mouseMoveEvent( QMouseEvent *e );
 
  public slots:
     void setOn(bool on);
  signals:
     /**
      * emitted when the labels gets clicked
      */
     void clicked();
 
     /**
      * emitted when the labels gets toggled
-     * @param the new new state of the label
+     * @param on the new new state of the label
      */
     void toggled(bool on);
  private:
     bool isToggle : 1;
     bool isDown : 1;
     bool textInverted : 1;
 
     void showState(bool on);
     void setInverted(bool on);
+    
+ private:
+    class Private;
+    Private *d; // private d pointer
 };
 
 #endif
diff --git a/libopie/ocolorbutton.h b/libopie/ocolorbutton.h
index 7ff9cd2..6196c83 100644
--- a/libopie/ocolorbutton.h
+++ b/libopie/ocolorbutton.h
@@ -1,72 +1,73 @@
 /*
                =.            This file is part of the OPIE Project
              .=l.            Copyright (c)  2002 Robert Griebl <sandman@handhelds.org>
            .>+-=
  _;:,     .>    :=|.         This library is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       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 __OPIE_OCOLORBUTTON_H__
 #define __OPIE_OCOLORBUTTON_H__
 
 #include <qpushbutton.h>
 
 class OColorButtonPrivate;
 class QColor;
 
 /**
  *
  * @short A Button which will show a OColorPopupMenu
  * @author Robert Griebl ( sandman@handhelds.org )
  * @version 1.0
  * @see QPushButton
  */
 class OColorButton : public QPushButton {
         Q_OBJECT
 public:
+    // FIXME Wflags? -zecke
         OColorButton ( QWidget *parent = 0, const QColor & = black, const char *name = 0 );
         virtual ~OColorButton ( );
 
         QColor color ( ) const;
 
 signals:
     /**
      * emitted when a color gets selected
      */
         void colorSelected ( const QColor & );
 
 public slots:
         virtual void setColor ( const QColor & );
 
 protected slots:
     /**
      * @internal
      */
         virtual void updateColor ( const QColor & );
 
 private:
         OColorButtonPrivate *d;
 };
 
 #endif
 
diff --git a/libopie/odevicebutton.h b/libopie/odevicebutton.h
index cf91bbd..abe27d6 100644
--- a/libopie/odevicebutton.h
+++ b/libopie/odevicebutton.h
@@ -1,101 +1,105 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #ifndef DEVICE_BUTTON_H
 #define DEVICE_BUTTON_H
 
 #include <qpixmap.h>
 #include <qstring.h>
 
 class OQCopMessageData;
 
 namespace Opie
 {
 
 class OQCopMessage {
 public:
         OQCopMessage ( );
         OQCopMessage ( const OQCopMessage &copy );
         OQCopMessage ( const QCString &m_channel, const QCString &message, const QByteArray &args = QByteArray ( ));
 
         OQCopMessage &operator = ( const OQCopMessage &assign );
 
         void setChannel ( const QCString &channel );
         void setMessage ( const QCString &message );
         void setData ( const QByteArray &ba );
 
         QCString channel ( ) const;
         QCString message ( ) const;
         QByteArray data ( ) const;
 
         bool send ( );
 
 private:
         void init ( const QCString &m_channel, const QCString &message, const QByteArray &args );
 
         OQCopMessageData *d;
+        class Private;
+        Private* data;
 };
 
 
 /**
  * This class represents a physical button on a Qtopia device.  A device may
  * have n "user programmable" buttons, which are number 1..n.  The location
  * and number of buttons will vary from device to device.  userText() and pixmap()
  * may be used to describe this button to the user in help documentation.
  *
  * @version 1.0
  * @author Trolltech
  * @short A representation of buttons
  */
 
 class ODeviceButton
 {
 public:
         ODeviceButton();
         virtual ~ODeviceButton();
 
         ushort keycode ( ) const;
         QString userText ( ) const;
         QPixmap pixmap ( ) const;
         OQCopMessage factoryPresetPressedAction ( ) const;
         OQCopMessage pressedAction ( ) const;
         OQCopMessage factoryPresetHeldAction ( ) const;
         OQCopMessage heldAction ( ) const;
 
         void setKeycode ( ushort keycode );
         void setUserText ( const QString& text );
         void setPixmap ( const QPixmap& picture );
         void setFactoryPresetPressedAction ( const OQCopMessage& qcopMessage );
         void setPressedAction ( const OQCopMessage& qcopMessage );
         void setFactoryPresetHeldAction ( const OQCopMessage& qcopMessage );
         void setHeldAction ( const OQCopMessage& qcopMessage );
 
 private:
         ushort m_Keycode;
         QString m_UserText;
         QPixmap m_Pixmap;
         OQCopMessage m_FactoryPresetPressedAction;
         OQCopMessage m_PressedAction;
         OQCopMessage m_FactoryPresetHeldAction;
         OQCopMessage m_HeldAction;
+        class Private;
+        Private *d;
 };
 
 }
 
 #endif
diff --git a/libopie/oprocess.h b/libopie/oprocess.h
index f2853b0..af7cddb 100644
--- a/libopie/oprocess.h
+++ b/libopie/oprocess.h
@@ -181,262 +181,256 @@ public:
        NotifyOnExit,
        /**
         * The application is suspended until the started process is finished.
         */
        Block };
 
   /**
    * Constructor
    */
   OProcess(QObject *parent = 0, const char *name = 0);
   /**
    * Constructor
    */
   OProcess(const QString &arg0, QObject *parent = 0, const char *name = 0);
   /**
    * Constructor
    */
   OProcess(const QStringList &args, QObject *parent = 0, const char *name = 0);
 
   /**
    *Destructor:
    *
    *  If the process is running when the destructor for this class
    *  is called, the child process is killed with a SIGKILL, but
    *  only if the run mode is not of type @p DontCare.
    *  Processes started as @p DontCare keep running anyway.
   */
   virtual ~OProcess();
 
   /**
    @deprecated
 
          The use of this function is now deprecated. -- Please use the
          "operator<<" instead of "setExecutable".
 
          Sets the executable to be started with this OProcess object.
          Returns false if the process is currently running (in that
          case the executable remains unchanged.)
 
          @see operator<<
 
   */
   bool setExecutable(const QString& proc);
 
 
   /**
    * Sets the executable and the command line argument list for this process.
    *
    * For example, doing an "ls -l /usr/local/bin" can be achieved by:
    *  <pre>
    *  OProcess p;
    *  ...
    *  p << "ls" << "-l" << "/usr/local/bin"
    *  </pre>
    *
    **/
   OProcess &operator<<(const QString& arg);
   /**
    * Similar to previous method, takes a char *, supposed to be in locale 8 bit already.
    */
   OProcess &operator<<(const char * arg);
   /**
    * Similar to previous method, takes a QCString, supposed to be in locale 8 bit already.
    */
   OProcess &operator<<(const QCString & arg);
 
   /**
    * Sets the executable and the command line argument list for this process,
    * in a single method call, or add a list of arguments.
    **/
   OProcess &operator<<(const QStringList& args);
 
   /**
    * Clear a command line argument list that has been set by using
    * the "operator<<".
   */
   void clearArguments();
 
   /**
    *  Starts the process.
    *  For a detailed description of the
    *  various run modes and communication semantics, have a look at the
    *  general description of the OProcess class.
    *
    *  The following problems could cause this function to
    *    return false:
    *
    *  @li The process is already running.
    *  @li The command line argument list is empty.
    *  @li The starting of the process failed (could not fork).
    *  @li The executable was not found.
    *
    *  @param comm  Specifies which communication links should be
    *  established to the child process (stdin/stdout/stderr). By default,
    *  no communication takes place and the respective communication
    *  signals will never get emitted.
    *
    *  @return true on success, false on error
    *  (see above for error conditions)
    **/
   virtual bool start(RunMode  runmode = NotifyOnExit,
           Communication comm = NoCommunication);
 
   /**
    * Stop the process (by sending it a signal).
    *
            * @param signoThe signal to send. The default is SIGTERM.
    * @return @p true if the signal was delivered successfully.
   */
   virtual bool kill(int signo = SIGTERM);
 
   /**
      @return @p true if the process is (still) considered to be running
   */
   bool isRunning() const;
 
   /** Returns the process id of the process.
    *
    * If it is called after
    * the process has exited, it returns the process id of the last
    *  child process that was created by this instance of OProcess.
    *
    *  Calling it before any child process has been started by this
    *  OProcess instance causes pid() to return 0.
    **/
   pid_t pid() const;
 
   /**
-   * Use pid().
-   * @deprecated
-   */
-  pid_t getPid() const { return pid(); }
-
-  /**
    * Suspend processing of data from stdout of the child process.
    */
   void suspend();
 
   /**
    * Resume processing of data from stdout of the child process.
    */
   void resume();
 
   /**
    * @return @p true if the process has already finished and has exited
    *  "voluntarily", ie: it has not been killed by a signal.
    *
    * Note that you should check @ref OProcess::exitStatus() to determine
    * whether the process completed its task successful or not.
    */
   bool normalExit() const;
 
   /**
    * Returns the exit status of the process.
    *
    * Please use
    * @ref OProcess::normalExit() to check whether the process has exited
    * cleanly (i.e., @ref OProcess::normalExit() returns @p true) before calling
    * this function because if the process did not exit normally,
    * it does not have a valid exit status.
   */
   int  exitStatus() const;
 
 
   /**
            * Transmit data to the child process's stdin.
    *
    * OProcess::writeStdin may return false in the following cases:
    *
    *     @li The process is not currently running.
    *
    *     @li Communication to stdin has not been requested in the @ref start() call.
    *
    *     @li Transmission of data to the child process by a previous call to
    * @ref writeStdin() is still in progress.
    *
    * Please note that the data is sent to the client asynchronously,
    * so when this function returns, the data might not have been
    * processed by the child process.
    *
    * If all the data has been sent to the client, the signal
    * @ref wroteStdin() will be emitted.
    *
    * Please note that you must not free "buffer" or call @ref writeStdin()
    * again until either a @ref wroteStdin() signal indicates that the
    * data has been sent or a @ref processHasExited() signal shows that
    * the child process is no longer alive...
    **/
   bool writeStdin(const char *buffer, int buflen);
 
   void flushStdin();
 
   /**
    * This causes the stdin file descriptor of the child process to be
    * closed indicating an "EOF" to the child.
    *
    * @return @p false if no communication to the process's stdin
    *  had been specified in the call to @ref start().
   */
   bool closeStdin();
 
   /**
    * This causes the stdout file descriptor of the child process to be
    * closed.
    *
    * @return @p false if no communication to the process's stdout
    *  had been specified in the call to @ref start().
   */
   bool closeStdout();
 
   /**
    * This causes the stderr file descriptor of the child process to be
    * closed.
    *
    * @return @p false if no communication to the process's stderr
    *  had been specified in the call to @ref start().
   */
   bool closeStderr();
 
   /**
    * Lets you see what your arguments are for debugging.
    */
 
   const QValueList<QCString> &args() { return arguments; }
 
   /**
    * Controls whether the started process should drop any
    * setuid/segid privileges or whether it should keep them
    *
    * The default is @p false : drop privileges
    */
   void setRunPrivileged(bool keepPrivileges);
 
   /**
    * Returns whether the started process will drop any
    * setuid/segid privileges or whether it will keep them
    */
   bool runPrivileged() const;
 
   /**
    * Modifies the environment of the process to be started.
    * This function must be called before starting the process.
    */
   void setEnvironment(const QString &name, const QString &value);
 
   /**
    * Changes the current working directory (CWD) of the process
    * to be started.
    * This function must be called before starting the process.
    */
   void setWorkingDirectory(const QString &dir);
 
   /**
    * Specify whether to start the command via a shell or directly.
    * The default is to start the command directly.
    * If @p useShell is true @p shell will be used as shell, or
    * if shell is empty, the standard shell is used.
    * @p quote A flag indicating whether to quote the arguments.
    *
    * When using a shell, the caller should make sure that all filenames etc.
    * are properly quoted when passed as argument.
    * @see quote()
diff --git a/libopie/orecurrancewidget.h b/libopie/orecurrancewidget.h
index a5d6489..37a57f0 100644
--- a/libopie/orecurrancewidget.h
+++ b/libopie/orecurrancewidget.h
@@ -1,90 +1,93 @@
 /*
  * GPL and based on the widget from TT
  */
 
 #ifndef OPIE_RECURRANCE_WIDGET_H
 #define OPIE_RECURRANCE_WIDGET_H
 
 #include <qlist.h>
 #include <qtoolbutton.h>
 #include <qcheckbox.h>
 #include <qdatetime.h>
 #include <qbuttongroup.h>
 
 #include <qpe/datebookmonth.h>
 
 #include "orecurrancebase.h"
 #include <opie/orecur.h>
 
 // FIXME spelling!!!! -zecke
 // FIXME spelling filenames
 
 /**
  * A widget to let the user select rules for recurrences.
  * This widget can take care of weekly, monthly, daily and yearly recurrence
  * It is used inside todolist and datebook.
  *
  *
  * @short Widget of selecting Recurrance
  * @author Trolltech, Holger Freyther
  * @version 0.9
  */
 class ORecurranceWidget : public ORecurranceBase {
     Q_OBJECT
 public:
     ORecurranceWidget( bool startOnMonday,
                        const QDate& start, QWidget* parent = 0,
                        const char* name = 0,  bool modal = TRUE,
                        WFlags fl = 0 );
     ORecurranceWidget( bool startOnMonday,
                        const ORecur& rp, const QDate& start,
                        QWidget* parent = 0, const char* name =0,
                        bool modal = TRUE, WFlags = 0 );
     ~ORecurranceWidget();
     ORecur recurrence()const;
     QDate endDate()const;
 
 public slots:
     void slotSetRType( int );
     /**
      * set the new end date
      */
     void endDateChanged( int, int, int );
     /**
      * enable/disable end date
      */
     void slotNoEnd( bool unused );
     void setStartDate( const QDate& );
     void setRecurrence( const ORecur& recur, const QDate& start );
     void setRecurrence( const ORecur& recur );
 
 private slots:
     void setupRepeatLabel( const QString& );
     void setupRepeatLabel( int );
     void slotWeekLabel();
     void slotMonthLabel( int );
     void slotChangeStartOfWeek( bool onMonday );
 
 private:
     void setupNone();
     void setupDaily();
     void setupWeekly();
     void setupMonthly();
     void setupYearly();
 
     enum repeatButtons { None, Day, Week, Month, Year };
     void init();
     void hideExtras();
     void showRepeatStuff();
 
     QList<QToolButton> listRTypeButtons;
     QList<QToolButton> listExtra;
     QDate start;    // only used in one spot...
     QDate end;
     repeatButtons currInterval;
     bool startWeekOnMonday : 1;
     DateBookMonth *repeatPicker;
+    
+    class Private;
+    Private *d;
 
 };
 
 #endif
diff --git a/libopie/otabbar.h b/libopie/otabbar.h
index 0b353e2..668187b 100644
--- a/libopie/otabbar.h
+++ b/libopie/otabbar.h
@@ -1,76 +1,80 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Dan Williams <williamsdr@acm.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       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
 ..}^=.=       =       ;      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 OTABBAR_H
 #define OTABBAR_H
 
 #include <qtabbar.h>
 
 /**
  * @class OTabBar
  * @brief The OTabBar class is a derivative of QTabBar.
  *
  * OTabBar is a derivation of TrollTech's QTabBar which provides
  * a row of tabs for selection.  The only difference between this
  * class and QTabBar is that there is no dotted line box around
  * the label of the tab with the current focus.
  */
 class OTabBar : public QTabBar
 {
     Q_OBJECT
 
 public:
 /**
  * @fn OTabBar( QWidget *parent = 0, const char *name = 0 )
  * @brief Object constructor.
  *
  * @param parent Pointer to parent of this control.
  * @param name Name of control.
  *
  * Constructs a new OTabBar control with parent and name.
  */
  // FIXME Allow WFlags? -zecke
     OTabBar( QWidget * = 0, const char * = 0 );
 
 protected:
 /**
  * @fn paintLabel( QPainter* p, const QRect& br , QTab* t, bool  has_focus)const
  * @brief Internal function to draw a tab's label.
  *
  * @param p Pointer to QPainter used for drawing.
  * @param br QRect providing region to draw label in.
  * @param t Tab to draw label for.
  * @param has_focus Boolean value not used, retained for compatibility reasons.
  */
     void paintLabel( QPainter *, const QRect &, QTab *, bool ) const;
+    
+private:
+    class Private;
+    Private *d;
 };
 
 #endif
diff --git a/libopie/otabinfo.h b/libopie/otabinfo.h
index eebaf8e..00bb06d 100644
--- a/libopie/otabinfo.h
+++ b/libopie/otabinfo.h
@@ -1,132 +1,134 @@
 /*
                             This file is part of the Opie Project
 
                              Copyright (c)  2002 Dan Williams <williamsdr@acm.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       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
 ..}^=.=       =       ;      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 OTABINFO_H
 #define OTABINFO_H
 
 #include <qlist.h>
 #include <qstring.h>
 
 class QWidget;
 
 /**
  * @class OTabInfo
  * @brief The OTabInfo class is used internally by OTabWidget to keep track
  *        of widgets added to the control.
  *
  * OTabInfo provides the following information about a widget added to an
  * OTabWidget control:
  *
  *  ID - integer tab bar ID
  *  Control - QWidget pointer to child widget
  *  Label - QString text label for OTabWidget selection control
  *  Icon - QString name of icon file
  */
 class OTabInfo
 {
 public:
 /**
  * @fn OTabInfo()
  * @brief Object constructor.
  *
  * @param parent Pointer to parent of this control.
  * @param name Name of control.
  * @param s Style of widget selection control.
  * @param p Position of the widget selection control.
  */
     OTabInfo() : i( -1 ), c( 0 ), p( 0 ), l( QString::null ) {}
 
 /**
  * @fn OTabInfo( int id, QWidget *control, const QString &icon, const QString &label )
  * @brief Object constructor.
  *
  * @param id TabBar identifier for widget.
  * @param control QWidget pointer to widget.
  * @param icon QString name of icon file.
  * @param label QString text label for OTabWidget selection control.
  */
     OTabInfo( int id, QWidget *control, const QString &icon, const QString &label )
         : i( id ), c( control ), p( icon ), l( label ) {}
 
 /**
  * @fn id()const
  * @brief Returns TabBar ID.
  */
     int            id()      const { return i; }
 
 /**
  * @fn label()const
  * @brief Returns text label for widget.
  */
     const QString &label()   const { return l; }
 
 /**
  * @fn setLabel( const QString &label )
  * @brief Set label for tab.
  *
  * @param label QString text label for OTabWidget selection control.
  */
     void setLabel( const QString &label ) { l = label; }
 
 /**
  * @fn control()const
  * @brief Returns pointer to widget.
  */
     QWidget       *control() const { return c; }
 
 /**
  * @fn icon()const
  * @brief Returns name of icon file.
  */
     const QString &icon()    const { return p; }
 
 /**
  * @fn setIcon( const QString &icon )
  * @brief Set icon for tab.
  *
  * @param icon QString name of icon file.
  */
     void setIcon( const QString &icon ) { p = icon; }
 
 private:
     int      i;
     QWidget *c;
     QString  p;
     QString  l;
+    class Private;
+    Private *d;
 };
 
 /**
  * @class OTabInfoList
  * @brief A list of OTabInfo objects used by OTabWidget.
  */
 typedef QList<OTabInfo> OTabInfoList;
 
 #endif
diff --git a/libopie/otabwidget.h b/libopie/otabwidget.h
index a67fe06..c140c0b 100644
--- a/libopie/otabwidget.h
+++ b/libopie/otabwidget.h
@@ -96,181 +96,183 @@ public:
  * @param s Style of widget selection control.
  * @param p Position of the widget selection control.
  *
  * Constructs a new OTabWidget control with parent and name.  The style and position parameters
  * determine how the widget selection control will be displayed.
  */
  // FIXME WFlags? -zecke
     OTabWidget( QWidget * = 0, const char * = 0, TabStyle = Global, TabPosition = Top );
 
 /**
  * @fn ~OTabWidget()
  * @brief Object destructor.
  */
     ~OTabWidget();
 
 /**
  * @fn addTab( QWidget *child, const QString &icon, const QString &label )
  * @brief Add new widget to control.
  *
  * @param child Widget control.
  * @param icon Path to icon.
  * @param label Text label.
  */
     void addTab( QWidget *, const QString &, const QString & );
 
 /**
  * @fn removePage( QWidget *widget )
  * @brief Remove widget from control.  Does not delete widget.
  *
  * @param widget Widget control to be removed.
  */
     void removePage( QWidget * );
 
 /**
  * @fn changeTab( QWidget *widget, const QString &icon, const QString &label )
  * @brief Change text and/or icon for existing tab
  *
  * @param child Widget control.
  * @param icon Path to icon.
  * @param label Text label.
  */
     void changeTab( QWidget *, const QString &, const QString & );
 
 /**
  * @fn tabStyle()const
  * @brief Returns current widget selection control style.
  */
     TabStyle tabStyle() const;
 
 /**
  * @fn setTabStyle( TabStyle s )
  * @brief Set the current widget selection control style.
  *
  * @param s New style to be used.
  */
     void setTabStyle( TabStyle );
 
 /**
  * @fn tabPosition()const
  * @brief Returns current widget selection control position.
  */
     TabPosition tabPosition() const;
 
 /**
  * @fn setTabPosition( TabPosition p )
  * @brief Set the current widget selection control position.
  *
  * @param p New position of widget selection control.
  */
     void setTabPosition( TabPosition );
 
 /**
  * @fn setCurrentTab( QWidget *childwidget )
  * @brief Selects and brings to top the desired widget by using widget pointer.
  *
  * @param childwidget Widget to select.
  */
     void setCurrentTab( QWidget * );
 
 /**
  * @fn setCurrentTab( const QString &tabname )
  * @brief Selects and brings to top the desired widget, by using label.
  *
  * @param tabname Text label for widget to select.
  */
     void setCurrentTab( const QString & );
 
 /**
  * @fn setCurrentTab( int )
  * @brief Selects and brings to top the desired widget, by using id.
  *
  * @param tab id for widget to select.
  */
     void setCurrentTab(int);
 
 /**
  * @fn sizeHint()const
  * @brief Reimplemented for internal purposes.
  */
     QSize sizeHint() const;
 
 /**
  * @fn currentTab( )
  * @brief returns current tab id.
  */
     int currentTab();
 
 
 protected:
 
 /**
  * @fn resizeEvent( QResizeEvent * )
  * @brief Reimplemented for internal purposes.
  */
     void resizeEvent( QResizeEvent * );
 
 private:
     OTabInfoList  tabs;
     OTabInfo     *currTab;
 
     TabStyle    tabBarStyle;
     TabPosition tabBarPosition;
 
     QWidgetStack *tabBarStack;
     OTabBar      *tabBar;
     QComboBox    *tabList;
 
     QWidgetStack *widgetStack;
+    class Private;
+    Private* d;
 
 /**
  * @fn loadSmooth( const QString &name )
  * @brief Loads icon for widget.
  *
  * @param name Name of icon image file.
  */
     QPixmap loadSmooth( const QString & );
 
 /**
  * @fn selectTab( OTabInfo *tab )
  * @brief Internal function to select desired widget.
  *
  * @param tab Pointer to data for widget.
  */
     void    selectTab( OTabInfo * );
 
 /**
  * @fn setUpLayout()
  * @brief Internal function to adjust layout.
  */
     void    setUpLayout();
 
 
 signals:
 /**
  * @fn currentChanegd( QWidget *widget )
  * @brief This signal is emitted whenever the widget has changed.
  *
  * @param widget Pointer to new current widget.
  */
     void currentChanged( QWidget * );
 
 private slots:
 
 /**
  * @fn slotTabBarSelected( int id )
  * @brief Slot which is called when a tab is selected.
  *
  * @param id ID of widget selected.
  */
     void slotTabBarSelected( int );
 
 /**
  * @fn slotTabListSelected( int index )
  * @brief Slot which is called when a drop down selection is made.
  *
  * @param id Index of widget selected.
  */
     void slotTabListSelected( int );
 };
 
 #endif
diff --git a/libopie/oticker.h b/libopie/oticker.h
index c848654..c52e317 100644
--- a/libopie/oticker.h
+++ b/libopie/oticker.h
@@ -1,147 +1,148 @@
 /*
                             This file is part of the Opie Project
                              Copyright (c)  2002 L. Potter <ljp@llornkcor.com>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       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
 ..}^=.=       =       ;      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 OTICKER_H
 #define OTICKER_H
 
 #include <qwidget.h>
 #include <qpainter.h>
 #include <qdrawutil.h>
 #include <qpixmap.h>
 #include <qstring.h>
 #include <qslider.h>
 #include <qlabel.h>
 #include <qframe.h>
 #include <qcolor.h>
 
 /**
  * @class OTicker
  * @brief The OTicker class provides a QLabel widget that scroll its contents
  *
  */
 class OTicker : public QLabel {
     Q_OBJECT
 
 public:
 
 /*!
  * @fn OTicker( QWidget* parent = 0 )
  * @brief Object constructor.
  *
  * @param parent Pointer to parent of this control.
 
  * Constructs a new OTicker control with parent
  */
     OTicker( QWidget* parent=0 );
 /*!
  * @fn ~OTicker()
  * @brief Object destructor.
  */
     ~OTicker();
 /*!
  * @fn setText(const QString& )
  * @brief sets text to be displayed
  * @param text QString text to be displayed.
  *
  */
     void setText( const QString& text ) ;
 /*!
  * @fn setBackgroundColor(QColor color)
  * @brief sets color of the ticker's background
  * @param color QColor color to be set.
  *
  */
     //FIXME const QColor& please -zecke
     void setBackgroundColor(QColor color);
 /*!
  * @fn setForegroundColor(QColor color)
  * @brief sets color of text
  * @param color QColor color of text
  *
  */
+    // FIXME const QColor& please -zecke
     void setForegroundColor(QColor color);
 /*!
  * @fn setFrame(int style)
  * @brief sets frame style
  * @param style int Frame style to be see. See Qt::WidgetFlags.
  *
  */
     void setFrame(int style);
 /*!
  * @fn setUpdateTime(int timeout)
  * @brief sets time of update
  * @param timeout int time in milliseconds between updates.
  *
  */
     void setUpdateTime(int timeout);
 /*!
  * @fn setScrollLength(int length)
  * @brief sets amount of scrolling default is 1
  * @param length int scroll length.
  *
  */
     void setScrollLength(int length);
 signals:
 /*!
  * @fn mousePressed()
  * @brief signal mouse press event
  *
  */
     void mousePressed();
 protected:
 /*!
  * @fn timerEvent( QTimerEvent * e)
  * @brief timer timeout event
  * @param e QEvent see QEvent.
  *
  */
     void timerEvent( QTimerEvent * e);
 /*!
  * @fn drawContents( QPainter *p )
  * @brief draws widget contents
  * @param p QPainter. see QPainter
  *
  */
     void drawContents( QPainter *p );
 /*!
  * @fn mouseReleaseEvent( QMouseEvent *e)
  * @brief mouse release event
  * @param e QMouseEvent. see QMouseEvent.
  *
  */
     void mouseReleaseEvent( QMouseEvent *e);
 private:
     QColor backgroundcolor, foregroundcolor;
     QString scrollText;
     QPixmap scrollTextPixmap;
     int pos, updateTimerTime, scrollLength;
 };
 
 #endif
diff --git a/libopie/otimepicker.h b/libopie/otimepicker.h
index d501a95..6a9e040 100644
--- a/libopie/otimepicker.h
+++ b/libopie/otimepicker.h
@@ -1,81 +1,83 @@
 #ifndef OTIMEPICKER_H
 #define OTIMEPICKER_H
 
 #include <qwidget.h>
 #include <qvaluelist.h>
 #include <qdatetime.h>
 #include <qdialog.h>
 
 #include <opie/oclickablelabel.h>
 #include "otimepickerbase.h"
 
 /**
  * A class to pick time. It uses clickable labels
  * internally to allow a quick selection of a time.
  * A time can be selected by two clicks of a user
  *
  * @short A widget to quickly pick a QTime
  * @version 1.0
  * @see QWidget
  * @see QTime
  * @author Hakan Ardo, Stefan Eilers
  */
 class OTimePicker: public QWidget {
   Q_OBJECT
 
  public:
     OTimePicker(QWidget* parent = 0, const char* name = 0,
                WFlags fl = 0);
 
  public slots:
     void setHour(int h);
     void setMinute(int m);
     void setTime( const QTime& );
     void setTime( int h,  int m );
 
  public:
     QTime time()const;
 
  private:
     QValueList<OClickableLabel *> hourLst;
     QValueList<OClickableLabel *> minuteLst;
     QTime tm;
     struct Private;
     Private *d;
 
  private slots:
     void slotHour(bool b);
     void slotMinute(bool b);
 
  signals:
     /**
      * gets emitted when the time got changed by the user
      */
     void timeChanged(const QTime &);
 };
 
 /**
  *
  * @short A small dialog to pick a time
  * @version 1.0
  * @author Stefan Eilers
  */
 
 class OTimePickerDialog: public OTimePickerDialogBase {
   Q_OBJECT
 
  public:
         OTimePickerDialog ( QWidget* parent = 0, const char* name = NULL, WFlags fl = 0 );
         ~OTimePickerDialog() { };
 
         QTime time()const;
 
  public slots:
         void setTime( const QTime& time );
         void setHour( const QString& hour );
         void setMinute( const QString& minute );
 
  private:
         QTime m_time;
+        class Private;
+        Private* d;
 };
 #endif
diff --git a/libopie/owait.h b/libopie/owait.h
index 6217e31..cbfc8d6 100644
--- a/libopie/owait.h
+++ b/libopie/owait.h
@@ -1,74 +1,77 @@
 /*  This file is part of the OPIE libraries
     Copyright (C) 2003 Maximilian Reiss  (harlekin@handhelds.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 WAITPOPUP_H
 #define WAITPOPUP_H
 
 #include <qdialog.h>
 #include <qpixmap.h>
 #include <qlabel.h>
 #include <qtimer.h>
 
 /**
  * This class displays a animated waiting icon in the middle of the screen.
  *
  * @short modal hour glass dialog
  * @see QDialog
  * @author Maximilian Reiß
  */
 class OWait : public QDialog {
 
     Q_OBJECT
 
 public:
+    // FIXME Wflags -zecke?
     OWait(QWidget *parent=0,const char* name=0, bool dispIcon=TRUE);
     ~OWait();
 
     /**
      * reimplemented for control reasons
      */
     void show();
 
     /**
      * Set the time before the icon will be automaticly hidden
      * The timer will be started once the widget will be shown.
      * @param length - time in seconds
      */
     void setTimerLength( int length );
 
     public slots:
     /**
      * reimplemented for control reasons
      */
     void hide();
 
  private:
     void timerEvent( QTimerEvent * ) ;
     void paintEvent( QPaintEvent * );
 
     QPixmap m_pix;
     QLabel *m_lb;
     QTimer *m_waitTimer;
     int m_timerLength;
     int m_aniSize;
+    class Private;
+    Private *d;
 };
 
 #endif
diff --git a/libopie/pim/otodoaccess.h b/libopie/pim/otodoaccess.h
index 2bb87dc..a626731 100644
--- a/libopie/pim/otodoaccess.h
+++ b/libopie/pim/otodoaccess.h
@@ -1,87 +1,90 @@
 #ifndef OPIE_TODO_ACCESS_H
 #define OPIE_TODO_ACCESS_H
 
 #include <qobject.h>
 #include <qvaluelist.h>
 
 #include "otodo.h"
 #include "otodoaccessbackend.h"
 #include "opimaccesstemplate.h"
 
 
 /**
  * OTodoAccess
  * the class to get access to
  * the todolist
  */
 class OTodoAccess : public QObject, public OPimAccessTemplate<OTodo> {
     Q_OBJECT
 public:
     enum SortOrder { Completed = 0,
                      Priority,
                      Description,
                      Deadline };
     enum SortFilter{ Category =1,
                      OnlyOverDue= 2,
                      DoNotShowCompleted =4  };
     /**
      * if you use 0l
      * the default resource will be
      * picked up
      */
     OTodoAccess( OTodoAccessBackend* = 0l, enum Access acc = Random );
     ~OTodoAccess();
 
 
     /* our functions here */
     /**
      * include todos from start to end
      * includeNoDates whether or not to include
      * events with no dates
      */
     List effectiveToDos( const QDate& start,
                          const QDate& end,
                          bool includeNoDates = true );
 
     /**
      * start
      * end date taken from the currentDate()
      */
     List effectiveToDos( const QDate& start,
                          bool includeNoDates = true );
 
 
     /**
      * return overdue OTodos
      */
     List overDue();
 
     /**
      *
      */
     List sorted( bool ascending, int sortOrder, int sortFilter, int cat );
 
     /**
      * merge a list of OTodos into
      * the resource
      */
     void mergeWith( const QValueList<OTodo>& );
 
     /**
      * delete all already completed items
      */
     void removeAllCompleted();
 
 signals:
     /**
      * if the OTodoAccess was changed
      */
-    void signalChanged( const OTodoAccess* );
+    void changed( const OTodoAccess* );
+    void changed( const OTodoAccess*, int uid );
+    void added( const OTodoAccess*,  int uid );
+    void removed( const OTodoAccess*, int uid );
 private:
     int m_cat;
     OTodoAccessBackend* m_todoBackEnd;
     class OTodoAccessPrivate;
     OTodoAccessPrivate* d;
 };
 
 #endif
diff --git a/libopie/xmltree.h b/libopie/xmltree.h
index 4a6b6d9..4b6bdfa 100644
--- a/libopie/xmltree.h
+++ b/libopie/xmltree.h
@@ -1,117 +1,119 @@
 /*  This file is part of the KDE project
     Copyright (C) 2000,2001 Simon Hausmann <hausmann@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 __bookmarks_h__
 #define __bookmarks_h__
 
 #include <qstring.h>
 #include <qmap.h>
 #include <qtextstream.h>
 
 namespace Opie
 {
 
 /**
  *  A small xml lib written by Simon Hausmann.
  */ 
 class XMLElement
 {
 public:
     typedef QMap<QString, QString> AttributeMap;
 
     /**
      *  The constructor of XMLElement
      */
     XMLElement();
     ~XMLElement();
 
     /** appendChild appends a child to the XMLElement behind the last element.
      *  The ownership of the child get's transfered to the
      *  this XMLElement.
      *  If child is already the child of another parent
      *  it's get removed from the other parent first. 
      */
     void appendChild( XMLElement *child );
 
     /** inserts newChild after refChild. If newChild is the child
      *  of another parent the child will get removed.
      *  The ownership of child gets transfered.
      *
      */
     void insertAfter( XMLElement *newChild, XMLElement *refChild );
 
     /** same as insertAfter but the element get's inserted before refChild.
      *
      */
     void insertBefore( XMLElement *newChild, XMLElement *refChild );
 
     /** removeChild removes the child from the XMLElement.
      *  The ownership gets dropped. You need to delete the
      *  child yourself.
      */
     void removeChild( XMLElement *child );
 
     /** parent() returns the parent of this XMLElement
      *  If there is no parent 0l gets returned
      */
     XMLElement *parent() const { return m_parent; }
     XMLElement *firstChild() const { return m_first; }
     XMLElement *nextChild() const { return m_next; }
     XMLElement *prevChild() const { return m_prev; }
     XMLElement *lastChild() const { return m_last; }
 
     void setTagName( const QString &tag ) { m_tag = tag; }
     QString tagName() const { return m_tag; }
 
     void setValue( const QString &val ) { m_value = val; }
     QString value() const { return m_value; }
 
     void setAttributes( const AttributeMap &attrs ) { m_attributes = attrs; }
     AttributeMap attributes() const { return m_attributes; }
     AttributeMap &attributes() { return m_attributes; }
 
     QString attribute( const QString & ) const;
     void setAttribute( const QString &attr, const QString &value );
     void save( QTextStream &stream, uint indent = 0 );
 
     XMLElement *namedItem( const QString &name );
 
     XMLElement *clone() const;
 
     static XMLElement *load( const QString &fileName );
 
 private:
     QString m_tag;
     QString m_value;
     AttributeMap m_attributes;
 
     XMLElement *m_parent;
     XMLElement *m_next;
     XMLElement *m_prev;
     XMLElement *m_first;
     XMLElement *m_last;
 
     XMLElement( const XMLElement &rhs );
     XMLElement &operator=( const XMLElement &rhs );
+    class Private;
+    Private* d;
 };
 
 } // namespace Opie
 
 #endif
diff --git a/libopie2/opiecore/xmltree.h b/libopie2/opiecore/xmltree.h
index 4a6b6d9..4b6bdfa 100644
--- a/libopie2/opiecore/xmltree.h
+++ b/libopie2/opiecore/xmltree.h
@@ -1,117 +1,119 @@
 /*  This file is part of the KDE project
     Copyright (C) 2000,2001 Simon Hausmann <hausmann@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 __bookmarks_h__
 #define __bookmarks_h__
 
 #include <qstring.h>
 #include <qmap.h>
 #include <qtextstream.h>
 
 namespace Opie
 {
 
 /**
  *  A small xml lib written by Simon Hausmann.
  */ 
 class XMLElement
 {
 public:
     typedef QMap<QString, QString> AttributeMap;
 
     /**
      *  The constructor of XMLElement
      */
     XMLElement();
     ~XMLElement();
 
     /** appendChild appends a child to the XMLElement behind the last element.
      *  The ownership of the child get's transfered to the
      *  this XMLElement.
      *  If child is already the child of another parent
      *  it's get removed from the other parent first. 
      */
     void appendChild( XMLElement *child );
 
     /** inserts newChild after refChild. If newChild is the child
      *  of another parent the child will get removed.
      *  The ownership of child gets transfered.
      *
      */
     void insertAfter( XMLElement *newChild, XMLElement *refChild );
 
     /** same as insertAfter but the element get's inserted before refChild.
      *
      */
     void insertBefore( XMLElement *newChild, XMLElement *refChild );
 
     /** removeChild removes the child from the XMLElement.
      *  The ownership gets dropped. You need to delete the
      *  child yourself.
      */
     void removeChild( XMLElement *child );
 
     /** parent() returns the parent of this XMLElement
      *  If there is no parent 0l gets returned
      */
     XMLElement *parent() const { return m_parent; }
     XMLElement *firstChild() const { return m_first; }
     XMLElement *nextChild() const { return m_next; }
     XMLElement *prevChild() const { return m_prev; }
     XMLElement *lastChild() const { return m_last; }
 
     void setTagName( const QString &tag ) { m_tag = tag; }
     QString tagName() const { return m_tag; }
 
     void setValue( const QString &val ) { m_value = val; }
     QString value() const { return m_value; }
 
     void setAttributes( const AttributeMap &attrs ) { m_attributes = attrs; }
     AttributeMap attributes() const { return m_attributes; }
     AttributeMap &attributes() { return m_attributes; }
 
     QString attribute( const QString & ) const;
     void setAttribute( const QString &attr, const QString &value );
     void save( QTextStream &stream, uint indent = 0 );
 
     XMLElement *namedItem( const QString &name );
 
     XMLElement *clone() const;
 
     static XMLElement *load( const QString &fileName );
 
 private:
     QString m_tag;
     QString m_value;
     AttributeMap m_attributes;
 
     XMLElement *m_parent;
     XMLElement *m_next;
     XMLElement *m_prev;
     XMLElement *m_first;
     XMLElement *m_last;
 
     XMLElement( const XMLElement &rhs );
     XMLElement &operator=( const XMLElement &rhs );
+    class Private;
+    Private* d;
 };
 
 } // namespace Opie
 
 #endif
diff --git a/libopie2/opiepim/core/otodoaccess.h b/libopie2/opiepim/core/otodoaccess.h
index 2bb87dc..a626731 100644
--- a/libopie2/opiepim/core/otodoaccess.h
+++ b/libopie2/opiepim/core/otodoaccess.h
@@ -1,87 +1,90 @@
 #ifndef OPIE_TODO_ACCESS_H
 #define OPIE_TODO_ACCESS_H
 
 #include <qobject.h>
 #include <qvaluelist.h>
 
 #include "otodo.h"
 #include "otodoaccessbackend.h"
 #include "opimaccesstemplate.h"
 
 
 /**
  * OTodoAccess
  * the class to get access to
  * the todolist
  */
 class OTodoAccess : public QObject, public OPimAccessTemplate<OTodo> {
     Q_OBJECT
 public:
     enum SortOrder { Completed = 0,
                      Priority,
                      Description,
                      Deadline };
     enum SortFilter{ Category =1,
                      OnlyOverDue= 2,
                      DoNotShowCompleted =4  };
     /**
      * if you use 0l
      * the default resource will be
      * picked up
      */
     OTodoAccess( OTodoAccessBackend* = 0l, enum Access acc = Random );
     ~OTodoAccess();
 
 
     /* our functions here */
     /**
      * include todos from start to end
      * includeNoDates whether or not to include
      * events with no dates
      */
     List effectiveToDos( const QDate& start,
                          const QDate& end,
                          bool includeNoDates = true );
 
     /**
      * start
      * end date taken from the currentDate()
      */
     List effectiveToDos( const QDate& start,
                          bool includeNoDates = true );
 
 
     /**
      * return overdue OTodos
      */
     List overDue();
 
     /**
      *
      */
     List sorted( bool ascending, int sortOrder, int sortFilter, int cat );
 
     /**
      * merge a list of OTodos into
      * the resource
      */
     void mergeWith( const QValueList<OTodo>& );
 
     /**
      * delete all already completed items
      */
     void removeAllCompleted();
 
 signals:
     /**
      * if the OTodoAccess was changed
      */
-    void signalChanged( const OTodoAccess* );
+    void changed( const OTodoAccess* );
+    void changed( const OTodoAccess*, int uid );
+    void added( const OTodoAccess*,  int uid );
+    void removed( const OTodoAccess*, int uid );
 private:
     int m_cat;
     OTodoAccessBackend* m_todoBackEnd;
     class OTodoAccessPrivate;
     OTodoAccessPrivate* d;
 };
 
 #endif