small documentation format fixes

12 files changed, 33 insertions, 37 deletions

diff --git a/core/launcher/qprocess.cpp b/core/launcher/qprocess.cpp
index 3fe1238..aef7967 100644
--- a/core/launcher/qprocess.cpp
+++ b/core/launcher/qprocess.cpp
@@ -40,49 +40,49 @@
   This is a temporary class. This will be replaced by Qt 3's QProcess class.
 
   \ingroup qtopiaemb
 */
 
 /*!
   \enum QProcess::Communication
 
   This enum type defines the communication channels connected to the
   process.
 
   \value Stdin  Data can be written to the process's standard input.
 
   \value Stdout  Data can be read from the process's standard output.
 
   \value Stderr  Data can be read from the process's standard error.
 
   \value DupStderr  Duplicates standard error to standard output for new
   processes; i.e.  everything that the process writes to standard error, is
   reported by QProcess on standard output instead. This is especially useful if
   your application requires that the output on standard output and standard
   error is read in the same order as the process output it. Please note that
   this is a binary flag, so if you want to activate this together with standard
   input, output and error redirection (the default), you have to specify
-  \c{Stdin|Stdout|Stderr|DupStderr} for the setCommunication() call.
+  \c {Stdin|Stdout|Stderr|DupStderr} for the setCommunication() call.
 
   \sa setCommunication() communication()
 */
 
 /*!
   Constructs a QProcess object. The \a parent and \a name parameters are passed
   to the QObject constructor.
 
   \sa setArguments() addArgument() start()
 */
 QProcess::QProcess( QObject *parent, const char *name )
     : QObject( parent, name ), ioRedirection( FALSE ), notifyOnExit( FALSE ),
     wroteToStdinConnected( FALSE ),
     readStdoutCalled( FALSE ), readStderrCalled( FALSE ),
     comms( Stdin|Stdout|Stderr )
 {
     init();
 }
 
 /*!
   Constructs a QProcess with \a arg0 as the command to be executed. The
   \a parent and \a name parameters are passed to the QObject constructor.
 
   The process is not started. You must call start() or launch()
@@ -191,49 +191,49 @@ QDir QProcess::workingDirectory() const
 
   \sa workingDirectory() start()
 */
 void QProcess::setWorkingDirectory( const QDir& dir )
 {
     workingDir = dir;
 }
 #endif //QT_NO_DIR
 
 /*!
   Returns the communication required with the process.
 
   \sa setCommunication()
 */
 int QProcess::communication() const
 {
     return comms;
 }
 
 /*!
   Sets \a commFlags as the communication required with the process.
 
   \a commFlags is a bitwise OR between the flags defined in \c Communication.
 
-  The default is \c{Stdin|Stdout|Stderr}.
+  The default is \c {Stdin|Stdout|Stderr}.
 
   \sa communication()
 */
 void QProcess::setCommunication( int commFlags )
 {
     comms = commFlags;
 }
 
 /*!
   Returns TRUE if the process has exited normally; otherwise returns
   FALSE. This implies that this function returns FALSE if the process
   is still running.
 
   \sa isRunning() exitStatus() processExited()
 */
 bool QProcess::normalExit() const
 {
     // isRunning() has the side effect that it determines the exit status!
     if ( isRunning() )
 	return FALSE;
     else
 	return exitNormal;
 }
 
@@ -350,49 +350,49 @@ QString QProcess::readLineStdout()
     return s;
 }
 
 /*!
   Reads a line of text from standard error, excluding any trailing newline or
   carriage return characters and returns it. Returns QString::null if
   canReadLineStderr() returns FALSE.
 
   \sa canReadLineStderr() readyReadStderr() readStderr() readLineStdout()
 */
 QString QProcess::readLineStderr()
 {
     QByteArray a;
     QString s;
     if ( scanNewline( FALSE, &a ) ) {
 	if ( a.isEmpty() )
 	    s = "";
 	else
 	    s = QString( a );
     }
     return s;
 }
 
 /*!
-  This private function scans for any occurrence of \n or \r\n in the
+  This private function scans for any occurrence of \\n or \\r\\n in the
   buffer \e buf. It stores the text in the byte array \a store if it is
   non-null.
 */
 bool QProcess::scanNewline( bool stdOut, QByteArray *store )
 {
     QByteArray *buf;
     if ( stdOut )
 	buf = bufStdout();
     else
 	buf = bufStderr();
     uint n = buf->size();
     uint i;
     for ( i=0; i<n; i++ ) {
 	if ( buf->at(i) == '\n' ) {
 	    break;
 	}
     }
     if ( i >= n )
 	return FALSE;
 
     if ( store ) {
 	uint lineLength = i;
 	if ( lineLength>0 && buf->at(lineLength-1) == '\r' )
 	    lineLength--; // (if there are two \r, let one stay)
diff --git a/libopie2/opiecore/device/odevice.cpp b/libopie2/opiecore/device/odevice.cpp
index b5ae4e5..8b64c41 100644
--- a/libopie2/opiecore/device/odevice.cpp
+++ b/libopie2/opiecore/device/odevice.cpp
@@ -313,54 +313,54 @@ bool ODevice::suspend()
 bool ODevice::setDisplayStatus ( bool on )
 {
     qDebug("ODevice::setDisplayStatus(%d)", on);
 
     if ( d->m_model == Model_Unknown )
         return false;
 
     bool res = false;
     int fd;
 
 #ifdef QT_QWS_DEVFS
     if (( fd = ::open ( "/dev/fb/0", O_RDWR )) >= 0 ) {
 #else
     if (( fd = ::open ( "/dev/fb0", O_RDWR )) >= 0 ) {
 #endif
         res = ( ::ioctl ( fd, FBIOBLANK, on ? VESA_NO_BLANKING : VESA_POWERDOWN ) == 0 );
         ::close ( fd );
     }
     return res;
 }
 
 /**
 * This sets the display brightness
 *
-* @param p The brightness to be set on a scale from 0 to 255
+* @param b The brightness to be set on a scale from 0 to 255
 * @return success or failure
 */
-bool ODevice::setDisplayBrightness ( int p)
+bool ODevice::setDisplayBrightness ( int b)
 {
-        Q_UNUSED( p )
+        Q_UNUSED( b )
     return false;
 }
 
 /**
  * 
  * @return Returns the number of steppings on the brightness slider
  * in the Light-'n-Power settings. Values smaller zero and bigger
  * than 255 do not make sense.
  *
  * \sa QSlider::setLineStep
  * \sa QSlider::setPageStep
  */
 int ODevice::displayBrightnessResolution() const
 {
     return 16;
 }
 
 /**
 * This sets the display contrast
 * @param p The contrast to be set on a scale from 0 to 255
 * @return success or failure
 */
 bool ODevice::setDisplayContrast ( int p)
 {
diff --git a/libopie2/opiecore/oconfig.h b/libopie2/opiecore/oconfig.h
index ab95dc3..05a1a25 100644
--- a/libopie2/opiecore/oconfig.h
+++ b/libopie2/opiecore/oconfig.h
@@ -106,49 +106,49 @@ private:
  * out of scope, the group will automatically be restored. If you
  * want to use several different groups within a function or method,
  * you can still use OConfigGroupSaver: Simply enclose all work with
  * one group (including the creation of the OConfigGroupSaver object)
  * in one block.
  *
  * \code
  * OConfigGroupSaver saver(cfg,"TheGroupThatInWhat");
  * \endcode
  *
  * Note that OConfigGroupSaver (cfg,"TheGroupThatInWhat"); would get imediately
  * destructed after created and that you would save in the old group which
  * is unwished.
  *
  * @author Matthias Kalle Dalheimer <Kalle@kde.org>
  * @version $Id$
  * @see OConfig
  */
 
 class OConfigGroupSaver
 {
   public:
     /**
      * Constructor.
-     * Create the object giving a @config object and a @a group to become
+     * Create the object giving a OConfig object and a @a group to become
      * the current group.
      */
     OConfigGroupSaver( OConfig* config, QString group ) :_config(config), _oldgroup(config->group() )
         { _config->setGroup( group ); }
 
     OConfigGroupSaver( OConfig* config, const char *group ) :_config(config), _oldgroup(config->group())
         { _config->setGroup( group ); }
 
     OConfigGroupSaver( OConfig* config, const QCString &group ) : _config(config), _oldgroup(config->group())
         { _config->setGroup( group ); }
     /**
      * Destructor.
      * Restores the last current group.
      * @todo make it not inline for bc reasons. See KDE BC guide
      */
     ~OConfigGroupSaver() { _config->setGroup( _oldgroup ); }
 
     OConfig* config() { return _config; };
 
   private:
     OConfig* _config;
     QString _oldgroup;
 
     OConfigGroupSaver( const OConfigGroupSaver& );
diff --git a/libopie2/opiecore/odebug.h b/libopie2/opiecore/odebug.h
index 21a6c26..18dc09e 100644
--- a/libopie2/opiecore/odebug.h
+++ b/libopie2/opiecore/odebug.h
@@ -395,79 +395,79 @@ class ondbgstream {
     ondbgstream &form(const char *, ...) { return *this; }
 
     ondbgstream& operator<<( const QDateTime& ) { return *this; }
     ondbgstream& operator<<( const QDate&     ) { return *this; }
     ondbgstream& operator<<( const QTime&     ) { return *this; }
     ondbgstream& operator<<( const QPoint & )  { return *this; }
     ondbgstream& operator<<( const QSize & )  { return *this; }
     ondbgstream& operator<<( const QRect & )  { return *this; }
     ondbgstream& operator<<( const QRegion & ) { return *this; }
     ondbgstream& operator<<( const QStringList & ) { return *this; }
     ondbgstream& operator<<( const QColor & ) { return *this; }
     ondbgstream& operator<<( const QBrush & ) { return *this; }
 
 private:
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * related functions
  *======================================================================================*/
 
 /**
  * Does nothing.
- * @param a stream
+ * @param s stream
  * @return the given @p s
  */
 inline ondbgstream& endl( ondbgstream & s) { return s; }
 /**
  * Does nothing.
- * @param a stream
+ * @param s stream
  * @return the given @p s
  */
 inline ondbgstream& flush( ondbgstream & s) { return s; }
 inline ondbgstream& perror( ondbgstream & s) { return s; }
 
 /**
  * Returns a debug stream. You can use it to print debug
  * information.
  * @param area an id to identify the output, 0 for default
  */
 odbgstream odDebug(int area = 0);
 odbgstream odDebug(bool cond, int area = 0);
 /**
  * Returns a backtrace.
  * @param levels the number of levels (-1 for unlimited) of the backtrace
  * @return a backtrace
  */
 QString odBacktrace(int levels = -1);
 /**
  * Returns a dummy debug stream. The stream does not print anything.
  * @param area an id to identify the output, 0 for default
  * @see odDebug()
  */
-inline ondbgstream ondDebug(int = 0) { return ondbgstream(); }
+inline ondbgstream ondDebug(int area = 0) { return ondbgstream(); }
 inline ondbgstream ondDebug(bool , int  = 0) { return ondbgstream(); }
 inline QString ondBacktrace() { return QString::null; }
 inline QString ondBacktrace(int) { return QString::null; }
 
 /**
  * Returns a warning stream. You can use it to print warning
  * information.
  * @param area an id to identify the output, 0 for default
  */
 odbgstream odWarning(int area = 0);
 odbgstream odWarning(bool cond, int area = 0);
 /**
  * Returns an error stream. You can use it to print error
  * information.
  * @param area an id to identify the output, 0 for default
  */
 odbgstream odError(int area = 0);
 odbgstream odError(bool cond, int area = 0);
 /**
  * Returns a fatal error stream. You can use it to print fatal error
  * information.
  * @param area an id to identify the output, 0 for default
  */
 odbgstream odFatal(int area = 0);
diff --git a/libopie2/opiecore/okeyconfigmanager.cpp b/libopie2/opiecore/okeyconfigmanager.cpp
index 891cda7..48546bd 100644
--- a/libopie2/opiecore/okeyconfigmanager.cpp
+++ b/libopie2/opiecore/okeyconfigmanager.cpp
@@ -76,49 +76,49 @@ int OKeyPair::keycode()const {
  * to the Qt::ButtonState
  *
  * @see Qt::ButtonState
  * @see setModifier
  */
 int OKeyPair::modifier()const {
     return m_mod;
 }
 
 
 /**
  * Set the keycode
  * @param key The Keycode to set
  *
  * @see keycode()
  * @see Qt::Key
  */
 void OKeyPair::setKeycode( int key ) {
     m_key = key;
 }
 
 /**
  * Set the modifier key
  *
- * @param the Modifier key
+ * @param mod the Modifier key
  * @see Qt::ButtonState
  * @see modifier()
  */
 void OKeyPair::setModifier( int mod ) {
     m_mod = mod;
 }
 
 /**
  * Return  an OKeyPair for the Return Key without any modifier.
  */
 OKeyPair OKeyPair::returnKey() {
     return OKeyPair( Qt::Key_Return, 0 );
 }
 
 /**
  * Return an OKeyPair for the Left Arrow Key
  * without any modifier Key
  */
 OKeyPair OKeyPair::leftArrowKey() {
     return OKeyPair( Qt::Key_Left, 0 );
 }
 
 /**
  * Return an OKeyPair for the Right Arrow Key
diff --git a/libopie2/opiecore/okeyfilter.h b/libopie2/opiecore/okeyfilter.h
index d183641..1871247 100644
--- a/libopie2/opiecore/okeyfilter.h
+++ b/libopie2/opiecore/okeyfilter.h
@@ -44,57 +44,57 @@ namespace Core {
  * @author Rajko Albrecht
  * @version 1.0
  */
 class OKeyFilter
 {
     friend class Opie::Core::ODevice;
 
 protected:
     /**
      * Protected constructor - generate class via inst()
      * @see inst()
      */
     OKeyFilter();
     /**
      * Protected constructor - generate class via inst()
      * @see inst()
      */
     OKeyFilter(const OKeyFilter&){};
     /**
      * Append filter to the primary list.
      * This is only allowed for friend classes from odevice
      * @param aFilter a filter to append
      * @see addHandler
      */
-    virtual void addPreHandler(QWSServer::KeyboardFilter*aFilter)=0;
+    virtual void addPreHandler(QWSServer::KeyboardFilter *aFilter)=0;
     /**
      * Remove the specified filter from list and give back ownership.
      * This is only allowed for friend classes from odevice
      * @param aFilter a filter to remove
      * @see remHandler
      */
-    virtual void remPreHandler(QWSServer::KeyboardFilter*aFilter)=0;
+    virtual void remPreHandler(QWSServer::KeyboardFilter *aFilter)=0;
 
 public:
     virtual ~OKeyFilter();
     /**
      * Append filter to the secondary list.
      * @param aFilter a filter to append
      * @see addPreHandler
      */
-    virtual void addHandler(QWSServer::KeyboardFilter*)=0;
+    virtual void addHandler(QWSServer::KeyboardFilter *aFilter)=0;
     /**
      * Remove the specified filter from list and give back ownership.
      * @param aFilter a filter to remove
      * @see remPreHandler
      */
-    virtual void remHandler(QWSServer::KeyboardFilter*)=0;
+    virtual void remHandler(QWSServer::KeyboardFilter *aFilter)=0;
 
     /**
      * Returns a handler to an instance of OKeyFilter
      * @return a pointer to a working OKeyFilter
      */
     static OKeyFilter*inst();
 };
 
 }
 }
diff --git a/libopie2/opiecore/opluginloader.cpp b/libopie2/opiecore/opluginloader.cpp
index ec19fa0..2a6e369 100644
--- a/libopie2/opiecore/opluginloader.cpp
+++ b/libopie2/opiecore/opluginloader.cpp
@@ -502,49 +502,49 @@ bool OGenericPluginLoader::isSorted()const{
  * make libfoo.so.1.0.0 -> foo on UNIX
  * make libfoo.dylib    -> foo on MAC OS X Unix
  * windows is obviously missing
  */
 /**
  * @internal
  */
 QString OGenericPluginLoader::unlibify( const QString& str ) {
     QString st = str.mid( str.find( "lib" )+3 );
 #ifdef Q_OS_MACX
     return st.left( st.findRev( ".dylib" ) );
 #else
     return st.left( st.findRev( ".so" ) );
 #endif
 }
 
 /**
  * @internal
  *
  * \brief method to return available plugins. Internal and for reeimplementations
  *
  *Return a List of Plugins for a dir and add positions and remove disabled.
  * If a plugin is on the excluded list assign position -2
  *
- * @param dir The dir to look in
+ * @param _dir The dir to look in
  * @param sorted Should positions be read?
  * @param disabled Remove excluded from the list
  */
 OPluginItem::List OGenericPluginLoader::plugins( const QString& _dir, bool sorted, bool disabled )const {
 #ifdef Q_OS_MACX
     QDir dir( _dir, "lib*.dylib" );
 #else
     QDir dir( _dir, "lib*.so" );
 #endif
 
 
     OPluginItem::List lst;
 
     /*
      * get excluded list and then iterate over them
      * Excluded list contains the name
      * Position is a list with 'name.pos.name.pos.name.pos'
      *
      * For the look up we will create two QMap<QString,pos>
      */
     QMap<QString, int> positionMap;
     QMap<QString, int> excludedMap;
 
 
@@ -660,49 +660,48 @@ void OGenericPluginLoader::installTranslators(const QString& type) {
  * @param name The name of your plugin class
  * @param sorted If plugins are sorted
  *
  * @see OGenericPluginLoader
  */
 OPluginLoader::OPluginLoader( const QString& name,  bool sorted )
     : OGenericPluginLoader( name, sorted )
 {
 }
 
 /**
  * d'tor
  * @see OGenericPluginLoader::~OGenericPluginLoader
  */
 OPluginLoader::~OPluginLoader() {
 }
 
 /**
  * \brief C'Tor using a OGenericPluginLoader
  * The C'tor. Pass your OGenericPluginLoader to manage
  * OGenericPluginLoader::allAvailable plugins.
  *
  *
  * @param loader A Pointer to your OGenericPluginLoader
- * @param name The name
  */
 OPluginManager::OPluginManager(  OGenericPluginLoader* loader)
     : m_loader( loader ), m_isSorted( false )
 {
 }
 
 /**
  * \brief Overloaded c'tor using a List of Plugins and a type name
  * Overloaded Constructor to work with a 'Type' of plugins
  * and a correspending list of those. In this case calling load
  * is a no operation.
  *
  * @param name The name of your plugin ('today','inputmethods','applets')
  * @param lst A List with plugins of your type to manage
  * @param isSorted If the List should be treated sorted
  */
 OPluginManager::OPluginManager( const QString& name, const OPluginItem::List& lst,  bool isSorted)
     : m_loader( 0l ), m_cfgName( name ), m_plugins( lst ), m_isSorted( isSorted )
 {
 }
 
 /**
  * \brief A simple d'tor
  */
@@ -736,49 +735,49 @@ OPluginItem::List OPluginManager::managedPlugins()const {
 }
 
 /**
  * \brief Set the position of the items
  *
  * Replace the OPluginItem  with the name and path and this way
  * apply the new position. The search is linear and this way O(n/2)
  * You still need to call save()  to make your changes effective. After saving
  * a call to OGenericPluginLoader::filtered() returns the newly configured order and items
  *
  * @param item The  OPluginItem to be replaced internall
  *
  */
 void OPluginManager::setPosition( const OPluginItem& item) {
     replace( item );
 }
 
 /**
  * \brief Enable the item specified as argument
  *
  * This will make sure that OPluginItem::setEnabled is called and then will replace
  * the item with one that matches name and path internally.
  * @see setPosition
  *
- * @param the Item to enable
+ * @param item the Item to enable
  */
 void OPluginManager::enable(  const OPluginItem& item ) {
     setEnabled( item, true );
 }
 
 /**
  * \brief disable the Item.
  *
  * Disable the OPluginItem. Same applies as in
  * @see setPosition and @see enable
  *
  * @param item Item to disable
  */
 void OPluginManager::disable( const OPluginItem& item) {
     setEnabled( item, false );
 }
 
 /**
  * \brief Enable or disable the OPluginItem.
  * Depending on the value of the parameter this will either disable
  * or enable the pluginitem.
  * Beside that same as in @see disable,  @see enable, @see setPosition
  * applies.
  *
diff --git a/libopie2/opiecore/oprocess.h b/libopie2/opiecore/oprocess.h
index be1436c..ac6be98 100644
--- a/libopie2/opiecore/oprocess.h
+++ b/libopie2/opiecore/oprocess.h
@@ -33,49 +33,49 @@ _;:,     .>    :=|.         This program is free software; you can
 
 /* QT */
 #include <qcstring.h>
 #include <qobject.h>
 #include <qvaluelist.h>
 
 /* STD */
 #include <sys/types.h> // for pid_t
 #include <sys/wait.h>
 #include <signal.h>
 #include <unistd.h>
 
 class QSocketNotifier;
 
 namespace Opie {
 namespace Core {
 namespace Internal {
 class OProcessController;
 class OProcessPrivate;
 }
 
 /**
  * Child process invocation, monitoring and control.
  *
- * @sect General usage and features
+ * @par General usage and features
  *
  *This class allows a KDE and OPIE application to start child processes without having
  *to worry about UN*X signal handling issues and zombie process reaping.
  *
  *@see KProcIO
  *
  *Basically, this class distinguishes three different ways of running
  *child processes:
  *
  *@li  OProcess::DontCare -- The child process is invoked and both the child
  *process and the parent process continue concurrently.
  *
  *Starting a  DontCare child process means that the application is
  *not interested in any notification to determine whether the
  *child process has already exited or not.
  *
  *@li  OProcess::NotifyOnExit -- The child process is invoked and both the
  *child and the parent process run concurrently.
  *
  *When the child process exits, the OProcess instance
  *corresponding to it emits the Qt signal @ref processExited().
  *
  *Since this signal is @em not emitted from within a UN*X
  *signal handler, arbitrary function calls can be made.
@@ -89,77 +89,77 @@ class OProcessPrivate;
  *is suspended until the child process exits. (@em Really not recommended
  *for programs with a GUI.)
  *
  *OProcess also provides several functions for determining the exit status
  *and the pid of the child process it represents.
  *
  *Furthermore it is possible to supply command-line arguments to the process
  *in a clean fashion (no null -- terminated stringlists and such...)
  *
  *A small usage example:
  *<pre>
  *OProcess *proc = new OProcess;
  *
  **proc << "my_executable";
  **proc << "These" << "are" << "the" << "command" << "line" << "args";
  *QApplication::connect(proc, SIGNAL(processExited(Opie::Core::OProcess *)),
  *                      pointer_to_my_object, SLOT(my_objects_slot(Opie::Core::OProcess *)));
  *proc->start();
  *</pre>
  *
  *This will start "my_executable" with the commandline arguments "These"...
  *
  *When the child process exits, the respective Qt signal will be emitted.
  *
- *@sect Communication with the child process
+ *@par Communication with the child process
  *
  *OProcess supports communication with the child process through
  *stdin/stdout/stderr.
  *
  *The following functions are provided for getting data from the child
  *process or sending data to the child's stdin (For more information,
  *have a look at the documentation of each function):
  *
  *@li bool @ref writeStdin(char  *buffer, int  buflen);
  *@li  -- Transmit data to the child process's stdin.
  *
  *@li bool @ref closeStdin();
  *@li -- Closes the child process's stdin (which causes it to see an  feof(stdin)).
  *Returns false if you try to close stdin for a process that has been started
  *without a communication channel to stdin.
  *
  *@li bool @ref closeStdout();
  *@li -- Closes the child process's stdout.
  *Returns false if you try to close stdout for a process that has been started
  *without a communication channel to stdout.
  *
  *@li bool @ref closeStderr();
  *@li -- Closes the child process's stderr.
  *Returns false if you try to close stderr for a process that has been started
  *without a communication channel to stderr.
  *
  *
- *@sect QT signals:
+ *@par QT signals:
  *
  *@li void @ref receivedStdout(OProcess  *proc, char  *buffer, int  buflen);
  *@li  void @ref receivedStderr(OProcess  *proc, char  *buffer, int  buflen);
  *@li  -- Indicates that new data has arrived from either the
  *child process's stdout or stderr.
  *
  *@li  void @ref wroteStdin(OProcess  *proc);
  *@li  -- Indicates that all data that has been sent to the child process
  *by a prior call to @ref writeStdin() has actually been transmitted to the
  *client .
  *
  *@author Christian Czezakte e9025461@student.tuwien.ac.at
  *@author Holger Freyther (Opie Port)
  *
  **/
 class OProcess : public QObject
 {
     Q_OBJECT
 
 public:
 
     /**
      * Modes in which the communication channel can be opened.
      *
@@ -470,81 +470,83 @@ public:
 
     /**
      * @return the PID of @a process, or -1 if the process is not running
      */
     static int processPID( const QString& process );
 
 signals:
 
     /**
      * Emitted after the process has terminated when
      * the process was run in the @p NotifyOnExit  (==default option to
      * @ref start()) or the @ref Block mode.
      **/
     void processExited( Opie::Core::OProcess *proc );
 
 
     /**
      * Emitted, when output from the child process has
      * been received on stdout.
      *
      *  To actually get
      * these signals, the respective communication link (stdout/stderr)
      * has to be turned on in @ref start().
      *
+     * @param proc The process
      * @param buffer The data received.
      * @param buflen The number of bytes that are available.
      *
      * You should copy the information contained in @p buffer to your private
      * data structures before returning from this slot.
      **/
     void receivedStdout( Opie::Core::OProcess *proc, char *buffer, int buflen );
 
     /**
      * Emitted when output from the child process has
      * been received on stdout.
      *
      * To actually get these signals, the respective communications link
      * (stdout/stderr) has to be turned on in @ref start() and the
      * @p NoRead flag should have been passed.
      *
      * You will need to explicitly call resume() after your call to start()
      * to begin processing data from the child process's stdout.  This is
      * to ensure that this signal is not emitted when no one is connected
      * to it, otherwise this signal will not be emitted.
      *
      * The data still has to be read from file descriptor @p fd.
      **/
     void receivedStdout( int fd, int &len );
 
 
     /**
      * Emitted, when output from the child process has
      * been received on stderr.
      * To actually get
      * these signals, the respective communication link (stdout/stderr)
      * has to be turned on in @ref start().
      *
+     * @param proc The process
      * @param buffer The data received.
      * @param buflen The number of bytes that are available.
      *
      * You should copy the information contained in @p buffer to your private
      * data structures before returning from this slot.
     */
     void receivedStderr( Opie::Core::OProcess *proc, char *buffer, int buflen );
 
     /**
      * Emitted after all the data that has been
      * specified by a prior call to @ref writeStdin() has actually been
      * written to the child process.
      **/
     void wroteStdin( Opie::Core::OProcess *proc );
 
 protected slots:
 
     /**
      * This slot gets activated when data from the child's stdout arrives.
      * It usually calls "childOutput"
      */
     void slotChildOutput( int fdno );
 
     /**
diff --git a/libopie2/opieui/oimageeffect.h b/libopie2/opieui/oimageeffect.h
index 4f86d5b..4422741 100644
--- a/libopie2/opieui/oimageeffect.h
+++ b/libopie2/opieui/oimageeffect.h
@@ -198,49 +198,49 @@ public:
      * Blend an image into another one, using alpha in the expected way and
      * over coordinates @p x and @p y with respect to the lower image.
      * The output is painted in the own @p lower image. This is an optimization
      * of the blend method above provided by convenience.
      */
     static bool blendOnLower(int x, int y, const QImage & upper, const QImage & lower);
 
     /**
      * Modifies the intensity of a pixmap's RGB channel component.
      *
      * @author Daniel M. Duley (mosfet)
      * @param image The QImage to process.
      * @param percent Percent value. Use a negative value to dim.
      * @param channel Which channel(s) should be modified
      * @return The @p image, provided for convenience.
      */
     static QImage& channelIntensity(QImage &image, float percent,
                                     RGBComponent channel);
 
     /**
      * Fade an image to a certain background color.
      *
      * The number of colors will not be changed.
      *
-     * @param image The QImage to process.
+     * @param img The QImage to process.
      * @param val The strength of the effect. 0 <= val <= 1.
      * @param color The background color.
      * @return Returns the @ref image(), provided for convenience.
      */
     static QImage& fade(QImage &img, float val, const QColor &color);
 
 
     /**
      * This recolors a pixmap. The most dark color will become color a,
      * the most bright one color b, and in between.
      *
      * @param image A QImage to process.
      * @param ca Color a
      * @param cb Color b
      */
     static QImage& flatten(QImage &image, const QColor &ca,
            const QColor &cb, int ncols=0);
 
     /**
      * Build a hash on any given @ref QImage
      *
      * @param image The QImage to process
      * @param lite The hash faces the indicated lighting (cardinal poles).
      * @param spacing How many unmodified pixels inbetween hashes.
@@ -287,49 +287,49 @@ public:
 
     /**
      * Desaturate an image evenly.
      *
      * @param image The QImage to process.
      * @param desat A value between 0 and 1 setting the degree of desaturation
      * @return Returns the @ref image(), provided for convenience.
      */
     static QImage& desaturate(QImage &image, float desat = 0.3);
 
     /**
      * Fast, but low quality contrast of an image. Also see contrastHSV.
      *
      * @author Daniel M. Duley (mosfet)
      * @param image The QImage to process.
      * @param c A contrast value between -255 to 255.
      * @return The @ref image(), provided for convenience.
      */
     static QImage& contrast(QImage &image, int c);
 
     /**
      * Dither an image using Floyd-Steinberg dithering for low-color
      * situations.
      *
-     * @param image The QImage to process.
+     * @param img The QImage to process.
      * @param palette The color palette to use
      * @param size The size of the palette
      * @return Returns the @ref image(), provided for convenience.
      */
     static QImage& dither(QImage &img, const QColor *palette, int size);
 
     /**
      * Calculate the image for a selected image, for instance a selected icon
      * on the desktop.
      * @param img the QImage to select
      * @param col the selected color, usually from QColorGroup::highlight().
      */
     static QImage& selectedImage( QImage &img, const QColor &col );
 
     /**
      * High quality, expensive HSV contrast. You can do a faster one by just
      * taking a intensity threshold (ie: 128) and incrementing RGB color
      * channels above it and decrementing those below it, but this gives much
      * better results.
      *
      * @author Daniel M. Duley (mosfet)
      * @param img The QImage to process.
      * @param sharpen If true sharpness is increase, (spiffed). Otherwise
      * it is decreased, (dulled).
@@ -509,49 +509,49 @@ public:
      * @param elevation Determines the light source and direction.
      * @return The shaded image. The original is not changed.
      */
     static QImage shade(QImage &src, bool color_shading=true, double azimuth=30.0,
                         double elevation=30.0);
     /**
      * Swirls the image by a specified amount
      *
      * @author Daniel M. Duley (mosfet)
      * @param src The QImage to process.
      * @param degrees The tightness of the swirl.
      * @param background An RGBA value to use for the background. After the
      * effect some pixels may be "empty". This value is used for those pixels.
      * @return The swirled image. The original is not changed.
      */
      static QImage swirl(QImage &src, double degrees=50.0, unsigned int background =
                          0xFFFFFFFF);
 
      /**
       * Modifies the pixels along a sine wave.
       *
       * @author Daniel M. Duley (mosfet)
       * @param src The QImage to process.
       * @param amplitude The amplitude of the sine wave.
-      * @param wavelength The frequency of the sine wave.
+      * @param frequency The frequency of the sine wave.
       * @return The new image. The original is not changed.
       */
      static QImage wave(QImage &src, double amplitude=25.0, double frequency=150.0,
                         unsigned int background = 0xFFFFFFFF);
 
 private:
 
     /**
      * Helper function to fast calc some altered (lighten, shaded) colors
      *
      */
     static unsigned int lHash(unsigned int c);
     static unsigned int uHash(unsigned int c);
 
     /**
      * Helper function to find the nearest color to the RBG triplet
      */
     static int nearestColor( int r, int g, int b, const QColor *pal, int size );
 
     static void hull(const int x_offset, const int y_offset, const int polarity,
                      const int width, const int height,
                      unsigned int *f, unsigned int *g);
     static unsigned int generateNoise(unsigned int pixel, NoiseType type);
     static unsigned int interpolateColor(QImage *image, double x, double y,
diff --git a/libopie2/opieui/opixmapeffect.h b/libopie2/opieui/opixmapeffect.h
index b780f9f..85a1e25 100644
--- a/libopie2/opieui/opixmapeffect.h
+++ b/libopie2/opieui/opixmapeffect.h
@@ -131,58 +131,53 @@ public:
      * @param lite The hash faces the indicated lighting (cardinal poles)
      * @param spacing How many unmodified pixels inbetween hashes.
      * @return Returns The @ref pixmap(), provided for convenience.
      */
     static OPixmap& hash(OPixmap& pixmap, Lighting lite=NorthLite,
                         unsigned int spacing=0, int ncols=3);
 
     /**
      * Creates a pattern from a pixmap.
      *
      * The given pixmap is "flattened"
      * between color a to color b.
      *
      * @param pixmap The pixmap to process.
      * @param ca Color a.
      * @param cb Color b.
      * @param ncols The number of colors to use. The image will be
      * dithered to this depth. Pass zero to prevent dithering.
      * @return The @ref pixmap(), provided for convenience.
      */
     static OPixmap pattern(const OPixmap& pixmap, QSize size,
                    const QColor &ca, const QColor &cb, int ncols=8);
 
     /**
-     * Recolors a pixmap.
-     *
-     * The most dark color will become color a,
-     * the most bright one color b, and in between.
+     * Fades a pixmap to a certain color.
      *
      * @param pixmap The pixmap to process.
-     * @param ca Color a.
-     * @param cb Color b.
-     * @param ncols The number of colors to use. Pass zero to prevent
-     * dithering.
+     * @param val The strength of the effect. 0 <= val <= 1.
+     * @param color The color to blend to.
      * @return Returns the @ref pixmap(), provided for convenience.
      */
     static OPixmap& fade(OPixmap& pixmap, double val, const QColor &color);
 
     /**
      * Converts a pixmap to grayscale.
      *
      * @param pixmap The pixmap to process.
      * @param fast Set to @p true in order to use a faster but non-photographic
      * quality algorithm. Appropriate for things such as toolbar icons.
      * @return Returns the @ref pixmap(), provided for convenience.
      */
     static OPixmap& toGray(OPixmap& pixmap, bool fast=false);
 
     /**
      * Desaturates a pixmap.
      *
      * @param pixmap The pixmap to process.
      * @param desat A value between 0 and 1 setting the degree of desaturation
      * @return Returns The @ref pixmap(), provided for convenience.
      */
     static OPixmap& desaturate(OPixmap& pixmap, float desat = 0.3);
 
     /**
diff --git a/libopie2/qt3/opieui/ocombobox.h b/libopie2/qt3/opieui/ocombobox.h
index 4e35b61..3f60f54 100644
--- a/libopie2/qt3/opieui/ocombobox.h
+++ b/libopie2/qt3/opieui/ocombobox.h
@@ -32,93 +32,93 @@
 
 #ifndef OCOMBOBOX_H
 #define OCOMBOBOX_H
 
 /* QT */
 
 #include <qcombobox.h>
 
 /* OPIE */
 
 #include <opie2/olineedit.h>
 #include <opie2/ocompletion.h>
 #include <opie2/ocompletionbase.h>
 
 /* FORWARDS */
 
 class QListBoxItem;
 class QPopupMenu;
 class OCompletionBox;
 typedef QString OURL;
 
 /**
  * A combined button, line-edit and a popup list widget.
  *
- * @sect Detail
+ * @par Detail
  *
  * This widget inherits from @ref QComboBox and implements
  * the following additional functionalities:  a completion
  * object that provides both automatic and manual text
  * completion as well as text rotation features, configurable
  * key-bindings to activate these features, and a popup-menu
  * item that can be used to allow the user to set text completion
  * modes on the fly based on their preference.
  *
  * To support these new features OComboBox also emits a few
  * more additional signals as well.  The main ones are the
  * @ref completion( const QString& ) and @ref textRotation( KeyBindingType )
  * signals.  The completion signal is intended to be connected to a slot
  * that will assist the user in filling out the remaining text while
  * the rotation signals is intended to be used to traverse through all
  * possible matches whenever text completion results in multiple matches.
  * The @ref returnPressed() and @ref returnPressed( const QString& )
  * signal is emitted when the user presses the Enter/Return key.
  *
  * This widget by default creates a completion object when you invoke
  * the @ref completionObject( bool ) member function for the first time
  * or use @ref setCompletionObject( OCompletion*, bool ) to assign your
  * own completion object.  Additionally, to make this widget more functional,
  * OComboBox will by default handle the text rotation and completion
  * events internally whenever a completion object is created through either
  * one of the methods mentioned above.  If you do not need this functionality,
  * simply use @ref OCompletionBase::setHandleSignals( bool ) or alternatively
  * set the boolean parameter in the above methods to FALSE.
  *
  * The default key-bindings for completion and rotation is determined
  * from the global settings in @ref OStdAccel.  These values, however,
  * can be overriden locally by invoking @ref OCompletionBase::setKeyBinding().
  * The values can easily be reverted back to the default setting, by simply
  * calling @ref useGlobalSettings(). An alternate method would be to default
  * individual key-bindings by usning @ref setKeyBinding() with the default
  * second argument.
  *
  * Note that if this widget is not editable ( i.e. select-only ), then only
  * one completion mode, @p CompletionAuto, will work.  All the other modes are
  * simply ignored.  The @p CompletionAuto mode in this case allows you to
  * automatically select an item from the list by trying to match the pressed
  * keycode with the first letter of the enteries in the combo box.
  *
- * @sect Useage
+ * @par Usage
  *
  * To enable the basic completion feature:
  *
  * <pre>
  * OComboBox *combo = new OComboBox( true, this, "mywidget" );
  * OCompletion *comp = combo->completionObject();
  * // Connect to the return pressed signal - optional
  * connect(combo,SIGNAL(returnPressed(const QString&)),comp,SLOT(addItem(const QString&));
  * </pre>
  *
  * To use your own completion object:
  *
  * <pre>
  * OComboBox *combo = new OComboBox( this,"mywidget" );
  * OURLCompletion *comp = new OURLCompletion();
  * combo->setCompletionObject( comp );
  * // Connect to the return pressed signal - optional
  * connect(combo,SIGNAL(returnPressed(const QString&)),comp,SLOT(addItem(const QString&));
  * </pre>
  *
  * Note that you have to either delete the allocated completion object
  * when you don't need it anymore, or call
  * setAutoDeleteCompletionObject( true );
  *
diff --git a/libopie2/qt3/opieui/olineedit.h b/libopie2/qt3/opieui/olineedit.h
index ecfca27..db3d7ef 100644
--- a/libopie2/qt3/opieui/olineedit.h
+++ b/libopie2/qt3/opieui/olineedit.h
@@ -29,124 +29,124 @@
                              Boston, MA 02111-1307, USA.
 
 */
 
 #ifndef OLINEEDIT_H
 #define OLINEEDIT_H
 
 /* QT */
 
 #include <qlineedit.h>
 
 /* OPIE */
 
 #include <opie2/ocompletion.h>
 #include <opie2/ocompletionbase.h>
 
 class QPopupMenu;
 
 class OCompletionBox;
 typedef QString KURL; //class KURL;
 
 /**
  * An enhanced QLineEdit widget for inputting text.
  *
- * @sect Detail
+ * @par Detail
  *
  * This widget inherits from @ref QLineEdit and implements the following
  * additional functionalities: q completion object that provides both
  * automatic and manual text completion as well as multiple match iteration
  * features, configurable key-bindings to activate these features and a
  * popup-menu item that can be used to allow the user to set text completion
  * modes on the fly based on their preference.
  *
  * To support these new features OLineEdit also emits a few more
  * additional signals.  These are: @ref completion( const QString& ),
  * textRotation( KeyBindingType ), and @ref returnPressed( const QString& ).
  * The completion signal can be connected to a slot that will assist the
  * user in filling out the remaining text.  The text rotation signal is
  * intended to be used to iterate through the list of all possible matches
  * whenever there is more than one match for the entered text.  The
  * @p returnPressed( const QString& ) signals are the same as QLineEdit's
  * except it provides the current text in the widget as its argument whenever
  * appropriate.
  *
  * This widget by default creates a completion object when you invoke
  * the @ref completionObject( bool ) member function for the first time or
  * use @ref setCompletionObject( OCompletion*, bool ) to assign your own
  * completion object.  Additionally, to make this widget more functional,
  * OLineEdit will by default handle the text rotation and completion
  * events internally when a completion object is created through either one
  * of the methods mentioned above.  If you do not need this functionality,
  * simply use @ref OCompletionBase::setHandleSignals( bool ) or set the
  * boolean parameter in the above functions to FALSE.
  *
  * The default key-bindings for completion and rotation is determined
  * from the global settings in @ref OStdAccel.  These values, however,
  * can be overriden locally by invoking @ref OCompletionBase::setKeyBinding().
  * The values can easily be reverted back to the default setting, by simply
  * calling @ref useGlobalSettings(). An alternate method would be to default
  * individual key-bindings by usning @ref setKeyBinding() with the default
  * second argument.
  *
  * NOTE that if the @p EchoMode for this widget is set to something other
  * than @p QLineEdit::Normal, the completion mode will always be defaulted
  * to @ref PGlobalSettings::CompletionNone.  This is done purposefully to guard
  * against protected entries such as passwords being cached in @ref OCompletion's
  * list. Hence, if the @p EchoMode is not @ref QLineEdit::Normal, the completion
  * mode is automatically disabled.
  *
- * @sect Useage
+ * @par Usage
  *
  * To enable the basic completion feature :
  *
  * <pre>
  * OLineEdit *edit = new OLineEdit( this, "mywidget" );
  * OCompletion *comp = edit->completionObject();
  * // Fill the completion object with a list of possible matches
  * QStringList list;
  * list << "mickeyl@handhelds.org" << "mickey@tm.informatik.uni-frankfurt.de>" << "mickey@Vanille.de";
  * comp->setItems( list );
  * // Connect to the return pressed signal (optional)
  * connect(edit,SIGNAL(returnPressed(const QString&)),comp,SLOT(addItem(const QString&));
  * </pre>
  *
  * To use a customized completion objects or your
  * own completion object :
  *
  * <pre>
  * OLineEdit *edit = new OLineEdit( this,"mywidget" );
  * KURLCompletion *comp = new KURLCompletion();
  * edit->setCompletionObject( comp );
  * // Connect to the return pressed signal - optional
  * connect(edit,SIGNAL(returnPressed(const QString&)),comp,SLOT(addItem(const QString&));
  * </pre>
  *
  * Note that you have to either delete the allocated completion object
  * when you don't need it anymore, or call
  * setAutoDeleteCompletionObject( true );
  *
- * @sect Miscellaneous function calls :
+ * @par Miscellaneous function calls :
  *
  * <pre>
  * // Tell the widget not to handle completion and
  * // iteration internally.
  * edit->setHandleSignals( false );
  * // Set your own completion key for manual completions.
  * edit->setKeyBinding( OCompletionBase::TextCompletion, Qt::End );
  * // Hide the context (popup) menu
  * edit->setContextMenuEnabled( false );
  * // Temporarly disable signal emitions
  * // (both completion & iteration signals)
  * edit->disableSignals();
  * // Default the key-bindings to system settings.
  * edit->useGlobalKeyBindings();
  * </pre>
  *
  * @short An enhanced single line input widget.
  * @author Dawit Alemayehu <adawit@kde.org>
  * @author Opie adaption by Michael Lauer <mickey@tm.informatik.uni-frankfurt.de>
  */
 
 class OLineEdit : public QLineEdit, public OCompletionBase
 {
     friend class OComboBox;