small documentation format fixes

11 files changed, 30 insertions, 34 deletions

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
@@ -321,38 +321,38 @@ bool ODevice::setDisplayStatus ( bool on )
     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;
 }
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
@@ -114,33 +114,33 @@ private:
  * \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 ); }
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
@@ -403,63 +403,63 @@ class ondbgstream {
     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
  */
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
@@ -84,33 +84,33 @@ int OKeyPair::modifier()const {
 
 
 /**
  * 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
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
@@ -52,49 +52,49 @@ 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
@@ -510,33 +510,33 @@ 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
@@ -668,33 +668,32 @@ OPluginLoader::OPluginLoader( const QString& name,  bool 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
  */
@@ -744,33 +743,33 @@ OPluginItem::List OPluginManager::managedPlugins()const {
  * 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 );
 }
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
@@ -41,33 +41,33 @@ _;:,     .>    :=|.         This program is free software; you can
 #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.
  *
@@ -97,61 +97,61 @@ class OProcessPrivate;
  *
  *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
@@ -478,32 +478,33 @@ 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.
      *
@@ -511,32 +512,33 @@ signals:
      * 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:
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
@@ -206,33 +206,33 @@ public:
      * 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,
@@ -295,33 +295,33 @@ public:
     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
@@ -517,33 +517,33 @@ public:
      * @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
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
@@ -139,42 +139,37 @@ public:
      * 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.
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
@@ -40,33 +40,33 @@
 /* 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.
@@ -84,33 +84,33 @@ typedef QString OURL;
  * 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 );
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
@@ -37,33 +37,33 @@
 
 #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
@@ -82,63 +82,63 @@ typedef QString KURL; //class KURL;
  *
  * 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>
  *