7 files changed, 34 insertions, 35 deletions

diff --git a/libopie2/examples/opieui/osplitter_example/osplitter_example.cpp b/libopie2/examples/opieui/osplitter_example/osplitter_example.cpp
index 4a1468d..07c7e51 100644
--- a/libopie2/examples/opieui/osplitter_example/osplitter_example.cpp
+++ b/libopie2/examples/opieui/osplitter_example/osplitter_example.cpp
@@ -1,33 +1,34 @@
 #include "osplitter_example.h"
 
 /* OPIE */
 
 #include <opie2/osplitter.h>
 #include <opie2/ofileselector.h>
 #include <qpe/qpeapplication.h>
 #include <opie2/oapplicationfactory.h>
 
 /* QT*/
 #include <qdir.h>
 #include <qlayout.h>
 
 using namespace Opie::Ui;
+using namespace Opie::Core;
 
 OPIE_EXPORT_APP( OApplicationFactory<OSplitterExample> )
 
 OSplitterExample::OSplitterExample( QWidget *w,const char* n,WFlags f )
     : QWidget( w, n, f ){
     QVBoxLayout * lay = new QVBoxLayout(this);
     OSplitter * splitter = new OSplitter( Horizontal, this );
     lay->addWidget( splitter );
     
     OFileSelector *selector = new OFileSelector( splitter, OFileSelector::FileSelector,
                                                 OFileSelector::Normal, QDir::homeDirPath(),
                                                 QString::null );
     splitter->addWidget( selector, "zoom", tr("Selector 1") );
     
     selector = new OFileSelector( splitter, OFileSelector::FileSelector, OFileSelector::Normal,
                                 QDir::homeDirPath(), QString::null );
     splitter->addWidget( selector, "zoom", tr("Selector 2") );
     
 }
diff --git a/libopie2/examples/opieui/owidgetstack_example/owidgetstack_example.cpp b/libopie2/examples/opieui/owidgetstack_example/owidgetstack_example.cpp
index 50cc11b..272e42b 100644
--- a/libopie2/examples/opieui/owidgetstack_example/owidgetstack_example.cpp
+++ b/libopie2/examples/opieui/owidgetstack_example/owidgetstack_example.cpp
@@ -1,132 +1,133 @@
 /*
  * You may use, modify and distribute this example without any limitation
  */
 
 #include "owidgetstack_example.h"
 
 /* OPIE */
 #include <opie2/oapplicationfactory.h>
 #include <opie2/owidgetstack.h>
 #include <qpe/resource.h>
 
 /* QT */
 #include <qaction.h>
 #include <qtoolbar.h>
 #include <qpopupmenu.h>
 #include <qmenubar.h>
 #include <qlayout.h>
 #include <qlabel.h>
 #include <qpushbutton.h>
 #include <qsignalmapper.h>
 
+using namespace Opie::Core;
 using namespace Opie::Ui;
 
 OPIE_EXPORT_APP( OApplicationFactory<StackExample> )
 
 StackExample::StackExample( QWidget* parent, const char* name, WFlags fl )
     : QMainWindow( parent, name, fl )
 {
     m_stack = new OWidgetStack( this );
     setCentralWidget( m_stack );
 
     /* nice Signal Mapper ;) */
     QSignalMapper *sm = new QSignalMapper(this);
     connect(sm, SIGNAL(mapped(int) ), m_stack, SLOT(raiseWidget(int)) );
 
     /* toolbar first but this should be known from the other examples */
     setToolBarsMovable( false );
 
     /* only a menubar here */
     QToolBar* holder = new QToolBar( this );
     holder->setHorizontalStretchable( true );
 
     QMenuBar *bar = new QMenuBar( holder );
     QPopupMenu *menu = new QPopupMenu( this );
 
     QAction* a = new QAction( tr("Show MainWidget"), Resource::loadPixmap("zoom"),
                               QString::null, 0, this, 0 );
     sm->setMapping(a, 1 );
     connect(a, SIGNAL(activated() ),
             sm, SLOT(map() ) );
     a->addTo( menu );
 
     a = new QAction( tr("Show Details Small"), Resource::loadPixmap("zoom"),
                      QString::null, 0, this, 0 );
     sm->setMapping(a, 2 );
     connect(a, SIGNAL(activated() ),
             sm, SLOT(map() ) );
     a->addTo( menu );
 
     a = new QAction( tr("Show Details More"), Resource::loadPixmap("zoom"),
                      QString::null, 0, this, 0 );
     sm->setMapping(a, 3 );
     connect(a, SIGNAL(activated() ),
             sm, SLOT(map() ) );
     a->addTo( menu );
 
     a =  new QAction( tr("Show Details All"), Resource::loadPixmap("zoom"),
                       QString::null, 0, this, 0 );
     sm->setMapping(a, 4 );
     connect(a, SIGNAL(activated() ),
             sm, SLOT(map() ) );
 
     bar->insertItem( tr("Actions"), menu );
 
     /* now the gui */
 
     /* first widget, main widget */
     QWidget * wid = new QWidget( m_stack );
     QGridLayout *grid = new QGridLayout(wid, 2, 2 );
 
     QPushButton *btn = new QPushButton( tr("Show Details Small"), wid, "details1" );
     sm->setMapping(btn, 2 );
     connect(btn, SIGNAL(clicked()), sm, SLOT(map() ) );
     grid->addWidget( btn, 0, 0 );
 
     btn = new QPushButton( tr("Show Details Medium"), wid, "details2");
     sm->setMapping(btn, 3 );
     connect(btn, SIGNAL(clicked()), sm, SLOT(map() ) );
     grid->addWidget( btn, 0, 1 );
 
     btn = new QPushButton( tr("Show Details All"), wid, "details3");
     sm->setMapping(btn, 4 );
     connect(btn, SIGNAL(clicked()), sm, SLOT(map() ) );
     grid->addWidget( btn, 1, 1 );
 
     m_stack->addWidget( wid, 1 );
     m_main = wid;
 
     QLabel *lbl = new QLabel(m_stack );
     lbl->setText(tr("Only small Details are shown here. Määh") );
     m_stack->addWidget( lbl, 2 );
 
     lbl = new QLabel( m_stack );
     lbl->setText( tr("Some more details....Wo ist das Schaf?") );
     m_stack->addWidget( lbl, 3 );
 
     lbl = new QLabel( m_stack );
     lbl->setText( tr("<qt>Ne nicht in Bayerisch Gmain sondern in Berlin<br>Vermiss und meine Augen werden nicht eckig, da mein Bildschirm abgerundet ist<br>Es lebe Hamburg Süd,weiss du, verstehst du? ;)<br>Susi ist dOOf, es lebe die Ofenecke...", "hard to translate that") );
     m_stack->addWidget( lbl, 4 );
 
 
     /* THE signal mapper does all the magic */
     m_stack->raiseWidget( m_main );
 }
 
 
 StackExample::~StackExample() {
 
 }
 
 
 
 void StackExample::closeEvent( QCloseEvent* ev) {
     /* if the close even came when we displayed a details */
     if (m_stack->visibleWidget() != m_main ) {
         m_stack->raiseWidget( m_main );
         ev->ignore();
         return;
     }
 
     ev->accept();
 }
diff --git a/libopie2/opiecore/oprocess.h b/libopie2/opiecore/oprocess.h
index eb56b03..e23f98c 100644
--- a/libopie2/opiecore/oprocess.h
+++ b/libopie2/opiecore/oprocess.h
@@ -1,761 +1,761 @@
 /*
                             This file is part of the Opie Project
                             Copyright (C) 2003-2004 Holger Freyther <zecke@handhelds.org>
                             Copyright (C) The Opie Team <opie-devel@handhelds.org>
              =.             Based on KProcess (C) 1997 Christian Czezatke (e9025461@student.tuwien.ac.at)
            .=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 OPROCESS_H
 #define OPROCESS_H
 
 /* 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 Private {
 class OProcessController;
 class OProcessPrivate;
 }
 
 /**
  * Child process invocation, monitoring and control.
  *
  * @sect 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.
  *
  *Be aware: When the OProcess objects gets destructed, the child
  *process will be killed if it is still running!
  *This means in particular, that you cannot use a OProcess on the stack
  *with OProcess::NotifyOnExit.
  *
  *@li  OProcess::Block -- The child process starts and the parent process
  *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(OProcess *)),
- *                      pointer_to_my_object, SLOT(my_objects_slot(OProcess *)));
+ *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
  *
  *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:
  *
  *@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.
      *
      * If communication for more than one channel is required,
      * the values have to be or'ed together, for example to get
      * communication with stdout as well as with stdin, you would
      * specify @p Stdin @p | @p Stdout
      *
      * If @p NoRead is specified in conjunction with @p Stdout,
      * no data is actually read from @p Stdout but only
      * the signal @ref childOutput(int fd) is emitted.
      */
     enum Communication { NoCommunication = 0, Stdin = 1, Stdout = 2, Stderr = 4,
                          AllOutput = 6, All = 7,
                          NoRead };
 
     /**
      * Run-modes for a child process.
      */
     enum RunMode {
         /**
          * The application does not receive notifications from the subprocess when
          * it is finished or aborted.
          */
         DontCare,
         /**
          * The application is notified when the subprocess dies.
          */
         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;
 
     /**
      * 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.
      * \todo make const
      */
 
     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()
      */
     void setUseShell( bool useShell, const char *shell = 0 );
 
     /**
      * This function can be used to quote an argument string such that
      * the shell processes it properly. This is e. g. necessary for
      * user-provided file names which may contain spaces or quotes.
      * It also prevents expansion of wild cards and environment variables.
      */
     static QString quote( const QString &arg );
 
     /**
      * Detaches OProcess from child process. All communication is closed.
      * No exit notification is emitted any more for the child process.
      * Deleting the OProcess will no longer kill the child process.
      * Note that the current process remains the parent process of the
      * child process.
      */
     void detach();
 
     /**
      * @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( OProcess *proc );
+    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 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( OProcess *proc, char *buffer, int buflen );
+    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 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( OProcess *proc, char *buffer, int buflen );
+    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( OProcess *proc );
+    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 );
 
     /**
      * This slot gets activated when data from the child's stderr arrives.
      * It usually calls "childError"
      */
     void slotChildError( int fdno );
     /*
     Slot functions for capturing stdout and stderr of the child
     */
 
     /**
      * Called when another bulk of data can be sent to the child's
      * stdin. If there is no more data to be sent to stdin currently
      * available, this function must disable the QSocketNotifier "innot".
      */
     void slotSendData( int dummy );
 
 protected:
 
     /**
      * Sets up the environment according to the data passed via
      * setEnvironment(...)
      */
     void setupEnvironment();
 
     /**
      * The list of the process' command line arguments. The first entry
      * in this list is the executable itself.
      */
     QValueList<QCString> arguments;
     /**
      * How to run the process (Block, NotifyOnExit, DontCare). You should
      *  not modify this data member directly from derived classes.
      */
     RunMode run_mode;
     /**
      * true if the process is currently running. You should not
      * modify this data member directly from derived classes. For
      * reading the value of this data member, please use "isRunning()"
      * since "runs" will probably be made private in later versions
      * of OProcess.
      */
     bool runs;
 
     /**
      * The PID of the currently running process (see "getPid()").
      * You should not modify this data member in derived classes.
      * Please use "getPid()" instead of directly accessing this
      * member function since it will probably be made private in
      * later versions of OProcess.
      */
     pid_t pid_;
 
     /**
      * The process' exit status as returned by "waitpid". You should not
      * modify the value of this data member from derived classes. You should
      * rather use @ref exitStatus than accessing this data member directly
      * since it will probably be made private in further versions of
      * OProcess.
      */
     int status;
 
 
     /**
      * See setRunPrivileged()
      */
     bool keepPrivs;
 
     /*
     Functions for setting up the sockets for communication.
     setupCommunication
     -- is called from "start" before "fork"ing.
     commSetupDoneP
     -- completes communication socket setup in the parent
     commSetupDoneC
     -- completes communication setup in the child process
     commClose
     -- frees all allocated communication resources in the parent
     after the process has exited
     */
 
     /**
      * This function is called from "OProcess::start" right before a "fork" takes
      * place. According to
      * the "comm" parameter this function has to initialize the "in", "out" and
      * "err" data member of OProcess.
      *
      * This function should return 0 if setting the needed communication channels
      * was successful.
      *
      * The default implementation is to create UNIX STREAM sockets for the communication,
      * but you could overload this function and establish a TCP/IP communication for
      * network communication, for example.
      */
     virtual int setupCommunication( Communication comm );
 
     /**
      * Called right after a (successful) fork on the parent side. This function
      * will usually do some communications cleanup, like closing the reading end
      * of the "stdin" communication channel.
      *
      * Furthermore, it must also create the QSocketNotifiers "innot", "outnot" and
      * "errnot" and connect their Qt slots to the respective OProcess member functions.
      *
      * For a more detailed explanation, it is best to have a look at the default
      * implementation of "setupCommunication" in kprocess.cpp.
      */
     virtual int commSetupDoneP();
 
     /**
      * Called right after a (successful) fork, but before an "exec" on the child
      * process' side. It usually just closes the unused communication ends of
      * "in", "out" and "err" (like the writing end of the "in" communication
      * channel.
      */
     virtual int commSetupDoneC();
 
 
     /**
      * Immediately called after a process has exited. This function normally
      * calls commClose to close all open communication channels to this
      * process and emits the "processExited" signal (if the process was
      * not running in the "DontCare" mode).
      */
     virtual void processHasExited( int state );
 
     /**
      * Should clean up the communication links to the child after it has
      * exited. Should be called from "processHasExited".
      */
     virtual void commClose();
 
 
     /**
      * the socket descriptors for stdin/stdout/stderr.
      */
     int out[ 2 ];
     int in[ 2 ];
     int err[ 2 ];
 
     /**
      * The socket notifiers for the above socket descriptors.
      */
     QSocketNotifier *innot;
     QSocketNotifier *outnot;
     QSocketNotifier *errnot;
 
     /**
      * Lists the communication links that are activated for the child
      * process.  Should not be modified from derived classes.
      */
     Communication communication;
 
     /**
      * Called by "slotChildOutput" this function copies data arriving from the
      * child process's stdout to the respective buffer and emits the signal
      * "@ref receivedStderr".
      */
     int childOutput( int fdno );
 
     /**
      * Called by "slotChildOutput" this function copies data arriving from the
      * child process's stdout to the respective buffer and emits the signal
      * "@ref receivedStderr"
      */
     int childError( int fdno );
 
     // information about the data that has to be sent to the child:
 
     const char *input_data;  // the buffer holding the data
     int input_sent;    // # of bytes already transmitted
     int input_total;   // total length of input_data
 
     /**
      * @ref OProcessController is a friend of OProcess because it has to have
      * access to various data members.
      */
     friend class Private::OProcessController;
 
 private:
     /**
      * Searches for a valid shell.
      * Here is the algorithm used for finding an executable shell:
      *
      *    @li Try the executable pointed to by the "SHELL" environment
      *    variable with white spaces stripped off
      *
      *    @li If your process runs with uid != euid or gid != egid, a shell
      *    not listed in /etc/shells will not used.
      *
      *    @li If no valid shell could be found, "/bin/sh" is used as a last resort.
      */
     QCString searchShell();
 
     /**
      * Used by @ref searchShell in order to find out whether the shell found
      * is actually executable at all.
      */
     bool isExecutable( const QCString &filename );
 
     // Disallow assignment and copy-construction
     OProcess( const OProcess& );
     OProcess& operator= ( const OProcess& );
 
 private:
     void init ( );
     Private::OProcessPrivate *d;
 };
 }
 }
 
 #endif
 
diff --git a/libopie2/opienet/opcap.h b/libopie2/opienet/opcap.h
index dc609a3..72a78de 100644
--- a/libopie2/opienet/opcap.h
+++ b/libopie2/opienet/opcap.h
@@ -1,721 +1,721 @@
 /*
                              This file is part of the Opie Project
                              Copyright (C) 2003 by Michael 'Mickey' Lauer <mickey@Vanille.de>
               =.
             .=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 OPCAP_H
 #define OPCAP_H
 
 /* OPIE */
 #include <opie2/onetutils.h>
 
 /* QT */
 #include <qevent.h>
 #include <qfile.h>
 #include <qhostaddress.h>
 #include <qobject.h>
 #include <qstring.h>
 #include <qtextstream.h>
 #include <qmap.h>
 
 /* STD */
 extern "C"  // work around a bpf/pcap conflict in recent headers
 {
     #include <pcap.h>
 }
 #include <netinet/ether.h>
 #include <netinet/ip.h>
 #include <netinet/udp.h>
 #include <netinet/tcp.h>
 #include <time.h>
 
 /* Custom Network Includes (must go here, don't reorder!) */
 #include "802_11_user.h"
 #include "dhcp.h"
 
 
 /* TYPEDEFS */
 typedef struct timeval timevalstruct;
 typedef struct pcap_pkthdr packetheaderstruct;
 
 /* FORWARDS */
 class QSocketNotifier;
 namespace Opie {
 namespace Net  {
 class OPacketCapturer;
 
 /*======================================================================================
  * OPacket - A frame on the wire
  *======================================================================================*/
 
 /** @brief A class representing a data frame on the wire.
  *
  * The whole family of the packet classes are used when capturing frames from a network.
  * Most standard network protocols in use share a common architecture, which mostly is
  * a packet header and then the packet payload. In layered architectures, each lower layer
  * encapsulates data from its upper layer - that is it
  * treats the data from its upper layer as payload and prepends an own header to the packet,
  * which - again - is treated as the payload for the layer below. The figure below is an
  * example for how such a data frame is composed out of packets, e.g. when sending a mail.
  *
  * <pre>
  *                                                       | User Data |     == Mail Data
  *                                         | SMTP Header | User Data |     == SMTP
  *                           | TCP Header  | SMTP Header | User Data |     == TCP
  *               | IP Header | TCP Header  | SMTP Header | User Data |     == IP
  *  | MAC Header | IP Header | TCP Header  | SMTP Header | User Data |     == MAC
  *
  * </pre>
  *
  * The example is trimmed for simplicity, because the MAC (Medium Access Control) layer
  * also contains a few more levels of encapsulation.
  * Since the type of the payload is more or less independent from the encapsulating protocol,
  * the header must be inspected before attempting to decode the payload. Hence, the
  * encapsulation level varies and can't be deduced without actually looking into the packets.
  *
  * For actually working with captured frames, it's useful to identify the packets via names and
  * insert them into a parent/child - relationship based on the encapsulation. This is why
  * all packet classes derive from QObject. The amount of overhead caused by the QObject is
  * not a problem in this case, because we're talking about a theoratical maximum of about
  * 10 packets per captured frame. We need to stuff them into a searchable list anyway and the
  * QObject also cares about destroying the sub-, (child-) packets.
  *
  * This enables us to perform a simple look for packets of a certain type:
  * @code
  * OPacketCapturer* pcap = new OPacketCapturer();
  * pcap->open( "eth0" );
  * OPacket* p = pcap->next();
  * OIPPacket* ip = (OIPPacket*) p->child( "IP" ); // returns 0, if no such child exists
  * odebug << "got ip packet from " << ip->fromIPAddress().toString() << " to " << ip->toIPAddress().toString() << oendl;
  *
  */
 
 class OPacket : public QObject
 {
   Q_OBJECT
 
   friend class OPacketCapturer;
   friend QTextStream& operator<<( QTextStream& s, const OPacket& p );
 
   public:
     OPacket( int datalink, packetheaderstruct, const unsigned char*, QObject* parent );
     virtual ~OPacket();
 
     timevalstruct timeval() const;
 
     int caplen() const;
     int len() const;
     QString dump( int = 32 ) const;
 
     void updateStats( QMap<QString,int>&, QObjectList* );
 
   private:
 
     QString dumpStructure() const;
     QString _dumpStructure( QObjectList* ) const;
 
   private:
     const packetheaderstruct _hdr;  // pcap packet header
     const unsigned char* _data;     // pcap packet data
     const unsigned char* _end;      // end of pcap packet data
   private:
     class Private;
     Private *d;
 };
 
 QTextStream& operator<<( QTextStream& s, const OPacket& p );
 
 /*======================================================================================
  * OEthernetPacket - DLT_EN10MB frame
  *======================================================================================*/
 
 class OEthernetPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OEthernetPacket( const unsigned char*, const struct ether_header*, QObject* parent = 0 );
     virtual ~OEthernetPacket();
 
     OMacAddress sourceAddress() const;
     OMacAddress destinationAddress() const;
     int type() const;
 
   private:
     const struct ether_header* _ether;
   private:
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OPrismHeaderPacket - DLT_PRISM_HEADER frame
  *======================================================================================*/
 
 class OPrismHeaderPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OPrismHeaderPacket( const unsigned char*, const struct prism_hdr*, QObject* parent = 0 );
     virtual ~OPrismHeaderPacket();
 
     unsigned int signalStrength() const;
 
   private:
     const struct prism_hdr* _header;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OWaveLanPacket - DLT_IEEE802_11 frame
  *======================================================================================*/
 
 class OWaveLanPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanPacket( const unsigned char*, const struct ieee_802_11_header*, QObject* parent = 0 );
     virtual ~OWaveLanPacket();
 
     int duration() const;
     bool fromDS() const;
     bool toDS() const;
     virtual OMacAddress macAddress1() const;
     virtual OMacAddress macAddress2() const;
     virtual OMacAddress macAddress3() const;
     virtual OMacAddress macAddress4() const;
     bool usesPowerManagement() const;
     int type() const;
     int subType() const;
     int version() const;
     bool usesWep() const;
 
   private:
     const struct ieee_802_11_header* _wlanhdr;
     class Private;
     Private *d;
 };
 
 
 /*======================================================================================
  * OWaveLanManagementPacket - type: management (T_MGMT)
  *======================================================================================*/
 
 class OWaveLanManagementPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementPacket( const unsigned char*, const struct ieee_802_11_mgmt_header*, OWaveLanPacket* parent = 0 );
     virtual ~OWaveLanManagementPacket();
 
     QString managementType() const;
 
     int beaconInterval() const;
     int capabilities() const; // generic
 
     bool canESS() const;
     bool canIBSS() const;
     bool canCFP() const;
     bool canCFP_REQ() const;
     bool canPrivacy() const;
 
   private:
     const struct ieee_802_11_mgmt_header* _header;
     const struct ieee_802_11_mgmt_body* _body;
     class Private;
     Private *d;
 };
 
 
 /*======================================================================================
  * OWaveLanManagementSSID
  *======================================================================================*/
 
 class OWaveLanManagementSSID : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementSSID( const unsigned char*, const struct ssid_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementSSID();
 
     QString ID( bool decloak = false ) const;
 
   private:
     const struct ssid_t* _data;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OWaveLanManagementRates
  *======================================================================================*/
 
 class OWaveLanManagementRates : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementRates( const unsigned char*, const struct rates_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementRates();
 
   private:
     const struct rates_t* _data;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OWaveLanManagementCF
  *======================================================================================*/
 
 class OWaveLanManagementCF : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementCF( const unsigned char*, const struct cf_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementCF();
 
   private:
     const struct cf_t* _data;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OWaveLanManagementFH
  *======================================================================================*/
 
 class OWaveLanManagementFH : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementFH( const unsigned char*, const struct fh_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementFH();
 
   private:
     const struct fh_t* _data;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OWaveLanManagementDS
  *======================================================================================*/
 
 class OWaveLanManagementDS : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementDS( const unsigned char*, const struct ds_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementDS();
 
     int channel() const;
 
   private:
     const struct ds_t* _data;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OWaveLanManagementTim
  *======================================================================================*/
 
 class OWaveLanManagementTim : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementTim( const unsigned char*, const struct tim_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementTim();
 
   private:
     const struct tim_t* _data;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OWaveLanManagementIBSS
  *======================================================================================*/
 
 class OWaveLanManagementIBSS : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementIBSS( const unsigned char*, const struct ibss_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementIBSS();
 
   private:
     const struct ibss_t* _data;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OWaveLanManagementChallenge
  *======================================================================================*/
 
 class OWaveLanManagementChallenge : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanManagementChallenge( const unsigned char*, const struct challenge_t*, QObject* parent = 0 );
     virtual ~OWaveLanManagementChallenge();
 
   private:
     const struct challenge_t* _data;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OWaveLanDataPacket - type: data (T_DATA)
  *======================================================================================*/
 
 class OWaveLanDataPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanDataPacket( const unsigned char*, const struct ieee_802_11_data_header*, OWaveLanPacket* parent = 0 );
     virtual ~OWaveLanDataPacket();
 
   private:
     const struct ieee_802_11_data_header* _header;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OWaveLanControlPacket - type: control (T_CTRL)
  *======================================================================================*/
 
 class OWaveLanControlPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OWaveLanControlPacket( const unsigned char*, const struct ieee_802_11_control_header*, OWaveLanPacket* parent = 0 );
     virtual ~OWaveLanControlPacket();
 
     QString controlType() const;
 
   private:
     const struct ieee_802_11_control_header* _header;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OLLCPacket - IEEE 802.2 Link Level Control
  *======================================================================================*/
 
 class OLLCPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OLLCPacket( const unsigned char*, const struct ieee_802_11_802_2_header* data, QObject* parent = 0 );
     virtual ~OLLCPacket();
 
   private:
     const struct ieee_802_11_802_2_header* _header;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OIPPacket
  *======================================================================================*/
 
 class OIPPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OIPPacket( const unsigned char*, const struct iphdr*, QObject* parent = 0 );
     virtual ~OIPPacket();
 
     QHostAddress fromIPAddress() const;
     QHostAddress toIPAddress() const;
 
     int tos() const;
     int len() const;
     int id() const;
     int offset() const;
     int ttl() const;
     int protocol() const;
     int checksum() const;
 
   private:
     const struct iphdr* _iphdr;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OARPPacket
  *======================================================================================*/
 
 class OARPPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OARPPacket( const unsigned char*, const struct myarphdr*, QObject* parent = 0 );
     virtual ~OARPPacket();
 
     QHostAddress senderIPV4Address() const;
     OMacAddress senderMacAddress() const;
     QHostAddress targetIPV4Address() const;
     OMacAddress targetMacAddress() const;
 
     //int type() const;
     QString type() const;
 
   private:
     const struct myarphdr* _arphdr;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OUDPPacket
  *======================================================================================*/
 
 class OUDPPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OUDPPacket( const unsigned char*, const struct udphdr*, QObject* parent = 0 );
     virtual ~OUDPPacket();
 
     int fromPort() const;
     int toPort() const;
     int length() const;
     int checksum() const;
 
   private:
     const struct udphdr* _udphdr;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * ODHCPPacket
  *======================================================================================*/
 
 class ODHCPPacket : public QObject
 {
   Q_OBJECT
 
   public:
     ODHCPPacket( const unsigned char*, const struct dhcp_packet*, QObject* parent = 0 );
     virtual ~ODHCPPacket();
 
     QHostAddress clientAddress() const;
     QHostAddress yourAddress() const;
     QHostAddress serverAddress() const;
     QHostAddress relayAddress() const;
 
     OMacAddress clientMacAddress() const;
 
     bool isRequest() const;
     bool isReply() const;
     QString type() const;
 
   private:
     const struct dhcp_packet* _dhcphdr;
     unsigned char _type;
     class Private;
     Private *d;
 };
 
 /*======================================================================================
  * OTCPPacket
  *======================================================================================*/
 
 class OTCPPacket : public QObject
 {
   Q_OBJECT
 
   public:
     OTCPPacket( const unsigned char*, const struct tcphdr*, QObject* parent = 0 );
     virtual ~OTCPPacket();
 
     int fromPort() const;
     int toPort() const;
     int seq() const;
     int ack() const;
     int window() const;
     int checksum() const;
 
   private:
     const struct tcphdr* _tcphdr;
     class Private;
     Private *d;
 };
 
 
 /*======================================================================================
  * OPacketCapturer
  *======================================================================================*/
 
 /**
  * @brief A class based wrapper for network packet capturing.
  *
  * This class is the base of a high-level interface to the well known packet capturing
  * library libpcap.
  * @see http://tcpdump.org
  */
 class OPacketCapturer : public QObject
 {
   Q_OBJECT
 
   public:
     /**
      * Constructor.
      */
     OPacketCapturer( QObject* parent = 0, const char* name = 0 );
     /**
      * Destructor.
      */
     ~OPacketCapturer();
     /**
      * Set the packet capturer to use blocking or non-blocking IO. This can be useful when
      * not using the socket notifier, e.g. without an application object.
      */
     void setBlocking( bool );
     /**
      * @returns true if the packet capturer uses blocking IO calls.
      */
     bool blocking() const;
     /**
      * Close the packet capturer. This is automatically done in the destructor.
      */
     void close();
     /**
      * Close the output capture file.
      */
     void closeDumpFile();
     /**
      * @returns the data link type.
      * @see <pcap.h> for possible values.
      */
     int dataLink() const;
     /**
      * Dump a packet to the output capture file.
      */
     void dump( OPacket* );
     /**
      * @returns the file descriptor of the packet capturer. This is only useful, if
      * not using the socket notifier, e.g. without an application object.
      */
     int fileno() const;
     /**
      * @returns the next @ref OPacket from the packet capturer.
      * @note If blocking mode is true then this call might block.
      */
     OPacket* next();
     /**
      * @returns the next @ref OPacket from the packet capturer, if
      * one arrives within @a time milliseconds.
      */
     OPacket* next( int time );
     /**
      * Open the packet capturer to capture packets in live-mode from @a interface.
      */
     bool open( const QString& interface );
     /**
      * Open the packet capturer to capture packets in offline-mode from @a file.
      */
     bool open( const QFile& file );
     /**
      * Open a prerecorded tcpdump compatible capture file for use with @ref dump()
      */
     bool openDumpFile( const QString& filename );
     /**
      * @returns true if the packet capturer is open
      */
     bool isOpen() const;
     /**
      * @returns the snapshot length of this packet capturer
      */
     int snapShot() const;
     /**
      * @returns true if the input capture file has a different byte-order
      * than the byte-order of the running system.
      */
     bool swapped() const;
     /**
      * @returns the libpcap version string used to write the input capture file.
      */
     QString version() const;
     /**
      * @returns the packet statistic database.
      * @see QMap
      */
     const QMap<QString,int>& statistics() const;
 
   signals:
     /**
      * This signal is emitted, when a packet has been received.
      */
-    void receivedPacket( OPacket* );
+    void receivedPacket( Opie::Net::OPacket* );
 
   protected slots:
     void readyToReceive();
 
   protected:
     QString _name;                                  // devicename
     bool _open;                                     // check this before doing pcap calls
     pcap_t* _pch;                                   // pcap library handle
     pcap_dumper_t* _pcd;                            // pcap dumper handle
     QSocketNotifier* _sn;                           // socket notifier for main loop
     mutable char _errbuf[PCAP_ERRBUF_SIZE];         // holds error strings from libpcap
     QMap<QString, int> _stats;                      // statistics;
             class Private;                             // Private Forward declaration
             Private *d;                                     // if we need to add data
 };
 }
 }
 
 #endif // OPCAP_H
 
diff --git a/libopie2/opieui/opopupmenu.h b/libopie2/opieui/opopupmenu.h
index 419a954..294edcc 100644
--- a/libopie2/opieui/opopupmenu.h
+++ b/libopie2/opieui/opopupmenu.h
@@ -1,264 +1,264 @@
 //FIXME what is ODE? ODE Desktop Environemt? -zecke
 //FIXME do we need titles? space is limited that is only eyecandy? -zecke
 //FIXME keyboard navigation is also not that popular on a PDA might be with a keyboard (tuxphone) -zecke
 /* This file is part of the ODE libraries
    Copyright (C) 2000 Daniel M. Duley <mosfet@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
 */
 #ifndef _OPOPUP_H
 #define _OPOPUP_H
 
 #define INCLUDE_MENUITEM_DEF
 
 /* QT */
 
 #include <qpopupmenu.h>
 
 /* OPIE */
 
 #include <opie2/opixmapeffect.h>
 
 namespace Opie {
 namespace Ui   {
 /**
  * Title widget for use in @ref OPopupMenu.
  *
  * You usually don't have to create this manually since
  * @ref OPopupMenu::insertTitle will do it for you, but it is allowed if
  * you wish to customize it's look.
  *
  * @author Daniel M. Duley <mosfet@kde.org>
  * @short OPopupMenu title widget.
  */
 class OPopupTitle : public QWidget
 {
     Q_OBJECT
 
 public:
     /**
      * Constructs a title widget with the user specified gradient, pixmap,
      * and colors.
      */
     OPopupTitle(QWidget *parent=0, const char *name=0);
     /**
      * @deprecated
      * Constructs a title widget with the specified gradient and colors.
      */
     OPopupTitle(OPixmapEffect::GradientType gradient, const QColor &color,
                 const QColor &textColor, QWidget *parent=0,
                 const char *name=0);
     /**
      * @deprecated
      * Constructs a title widget with the specified pixmap and colors.
      */
     OPopupTitle(const OPixmap &background, const QColor &color,
                 const QColor &textColor, QWidget *parent=0,
                 const char *name=0);
     /**
      * Sets the title string and optional icon for the title widget.
      *
      * You will want to call this before inserting into a menu.
      */
     void setTitle(const QString &text, const QPixmap *icon=NULL);
     /**
      * Returns the current title.
      */
     QString title() const { return(titleStr); }
     /**
      * Returns the current icon.
      */
     QPixmap icon() const { return(miniicon); }
 
     QSize sizeHint() const;
 
 public slots:
     /// @since 3.1
     void setText( const QString &text );
     /// @since 3.1
     void setIcon( const QPixmap &pix );
 
 protected:
     void paintEvent(QPaintEvent *ev);
 
     QString titleStr;
     QPixmap miniicon;
     
     // Remove in KDE4
     OPixmapEffect::GradientType grType;
     QPixmap fill;
     QColor fgColor, bgColor, grHigh, grLow;
     bool useGradient;
 
 protected:
     virtual void virtual_hook( int id, void* data );
 private:
     class OPopupTitlePrivate;
     OPopupTitlePrivate *d;
 };
 
 /**
  * OPopupMenu is a class for menus with standard title items and keyboard
  * accessibility for popups with many options and/or varying options. It acts
  * identically to QPopupMenu, with the addition of insertTitle(),
  * changeTitle(), setKeyboardShortcutsEnabled() and
  * setKeyboardShortcutsExecute() methods.
  *
  * The titles support a text string, an icon, plus user defined gradients,
  * colors, and background pixmaps.
  *
  * The keyboard search algorithm is incremental with additional underlining
  * for user feedback.
  *
  * @short A menu with title items.
  * @author Daniel M. Duley <mosfet@kde.org>
  * @author Hamish Rodda <meddie@yoyo.its.monash.edu.au>
  */
 class OPopupMenu : public QPopupMenu {
     Q_OBJECT
 public:
     /**
      * Constructs a OPopupMenu.
      */
     OPopupMenu(QWidget *parent=0, const char *name=0);
 
     /**
      * Destructs the object
      */
     ~OPopupMenu();
 
     /**
      * Inserts a title item with no icon.
      */
     int insertTitle(const QString &text, int id=-1, int index=-1);
     /**
      * Inserts a title item with the given icon and title.
      */
     int insertTitle(const QPixmap &icon, const QString &text, int id=-1,
                     int index=-1);
     /**
      * Changes the title of the item at the specified id. If a icon was
      * previously set it is cleared.
      */
     void changeTitle(int id, const QString &text);
     /**
      * Changes the title and icon of the title item at the specified id.
      */
     void changeTitle(int id, const QPixmap &icon, const QString &text);
     /**
      * Returns the title of the title item at the specified id. The default
      * id of -1 is for backwards compatibility only, you should always specify
      * the id.
      */
     QString title(int id=-1) const;
     /**
      * Returns the icon of the title item at the specified id.
      */
     QPixmap titlePixmap(int id) const;
 
     /**
      * Enables keyboard navigation by searching for the entered key sequence.
      * Also underlines the currently selected item, providing feedback on the search.
      *
      * Defaults to off.
      *
      * WARNING: calls to text() of currently keyboard-selected items will
      * contain additional ampersand characters.
      *
      * WARNING: though pre-existing keyboard shortcuts will not interfere with the
      * operation of this feature, they may be confusing to the user as the existing
      * shortcuts will not work.
      * @since 3.1
      */
     void setKeyboardShortcutsEnabled(bool enable);
 
     /**
      * Enables execution of the menu item once it is uniquely specified.
      * Defaults to off.
      * @since 3.1
      */
     void setKeyboardShortcutsExecute(bool enable);
 
     /**
      * Obsolete method provided for backwards compatibility only. Use the
      * normal constructor and insertTitle instead.
      */
     OPopupMenu(const QString &title, QWidget *parent=0, const char *name=0);
     /**
      * Obsolete method provided for backwards compatibility only. Use
      * insertTitle and changeTitle instead.
      */
     void setTitle(const QString &title);
 
     /**
      * Returns the context menu associated with this menu
      * @since 3.2
      */
     QPopupMenu* contextMenu();
 
     /**
      * Hides the context menu if shown
      * @since 3.2
      */
     void cancelContextMenuShow();
 
     /**
      * Returns the OPopupMenu associated with the current context menu
      * @since 3.2
      */
     static OPopupMenu* contextMenuFocus();
 
     /**
      * returns the ID of the menuitem associated with the current context menu
      * @since 3.2
      */
     static int contextMenuFocusItem();
 
 signals:
     /**
      * connect to this signal to be notified when a context menu is about to be shown
      * @param menu The menu that the context menu is about to be shown for
      * @param menuItem The menu item that the context menu is currently on
      * @param ctxMenu The context menu itself
      * @since 3.2
      */
-    void aboutToShowContextMenu(OPopupMenu* menu, int menuItem, QPopupMenu* ctxMenu);
+    void aboutToShowContextMenu(Opie::Ui::OPopupMenu* menu, int menuItem, QPopupMenu* ctxMenu);
 
 protected:
     virtual void closeEvent(QCloseEvent *);
     virtual void keyPressEvent(QKeyEvent* e);
     virtual bool eventFilter(QObject* obj, QEvent* event);
     virtual void hideEvent(QHideEvent*);
 
     virtual void virtual_hook( int id, void* data );
 
 protected slots:
     /// @since 3.1
     QString underlineText(const QString& text, uint length);
     /// @since 3.1 
     void resetKeyboardVars(bool noMatches = false);
     void itemHighlighted(int whichItem);
     void showCtxMenu(QPoint pos);
     void ctxMenuHiding();
 
 private:
     class OPopupMenuPrivate;
     OPopupMenuPrivate *d;
 };
 
 }
 }
 
 #endif
diff --git a/libopie2/opieui/otimepicker.h b/libopie2/opieui/otimepicker.h
index 01bb557..fb20781 100644
--- a/libopie2/opieui/otimepicker.h
+++ b/libopie2/opieui/otimepicker.h
@@ -1,132 +1,129 @@
 /*
                              This file is part of the Opie Project
                              Copyright (C) Stefan Eilers <eilers.stefan@epost.de>
               =.             Copyright (C) The Opie Team <opie-devel@handhelds.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 OTIMEPICKER_H
 #define OTIMEPICKER_H
 
 /* OPIE */
 #include <opie2/oclickablelabel.h>
 #include <opie2/otimepickerbase.h>
 
 /* QT */
 #include <qwidget.h>
 #include <qvaluelist.h>
 #include <qdatetime.h>
 #include <qdialog.h>
 
 
 namespace Opie {
 namespace Ui   {
 
 /**
  * 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:
     OTimePicker *m_timePicker;
     QTime m_time;
     class Private;
     Private* d;
 };
 
 }
 }
 
 /* for Qt2  */
 #if ( QT_VERSION-0 >= 0x030000 )
 #error "Fix the UI File to use namespaces"
-#else
-typedef Opie::Ui::OTimePicker OUIOTimePicker;
 #endif
 #endif
-
diff --git a/libopie2/opieui/oversatileview.h b/libopie2/opieui/oversatileview.h
index 61b61db..8cba65c 100644
--- a/libopie2/opieui/oversatileview.h
+++ b/libopie2/opieui/oversatileview.h
@@ -1,399 +1,399 @@
 /*
                              This file is part of the Opie Project
 
               =.             (C) 2003 Michael 'Mickey' Lauer <mickey@tm.informatik.uni-frankfurt.de>
             .=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 OVERSATILEVIEW_H
 #define OVERSATILEVIEW_H
 
 /* QT */
 
 #include <qwidgetstack.h>
 #include <qiconview.h>
 
 /* OPIE */
 
 #include <opie2/oapplication.h>
 
 /* FORWARDS */
 
 class QHeader;
 class QIconSet;
 class QIconViewItem;
 class QListViewItem;
 class QPopupMenu;
 class QString;
 
 #ifndef QT_NO_DRAGANDDROP
 class QIconDragItem;
 #endif
 
 namespace Opie {
 namespace Ui   {
 class OListView;
 
 class OVersatileView : public QWidgetStack
 {
   Q_OBJECT
 
   friend class OVersatileViewItem;
 
   //==============================================================================================//
   // OVersatileView High Level API
   //==============================================================================================//
 
   public:
     OVersatileView( QWidget* parent = 0, const char* name = 0, int mode = 0 );
     ~OVersatileView();
 
     QPopupMenu* contextMenu() const;
 
     void setSynchronization( bool sync );
     bool synchronization();
 
     enum ViewMode { Tree = 0, Icons };
     int viewMode();
 
     QIconView* iconView() const;
     OListView* listView() const;
 
     enum WarningPolicy { None = 0, Warn, WarnReturn };
 
     void setWarningPolicy( int ) const;  // warn, if calling a method which doesn't apply to the current viewmode
     bool warningPolicy() const;
 
     void setDefaultPixmaps( int mode, QPixmap& leaf, QPixmap& opened, QPixmap& closed );
 
   public slots:
     void setViewMode( int mode );
     void setIconViewMode();
     void setTreeViewMode();
 
   protected:
     virtual bool isValidViewMode( int mode ) const;
     virtual void popupContextMenu( OVersatileViewItem* item, const QPoint& pos, int col = 0 );
 
   private:
     int _viewmode;
     bool _synchronization;
     mutable int _warningpolicy;
 
     OListView* _listview;
     QIconView* _iconview;
 
     QPixmap _treeleaf;
     QPixmap _treeopened;
     QPixmap _treeclosed;
 
     QPixmap _iconleaf;
     QPixmap _iconopened;
     QPixmap _iconclosed;
 
     QPopupMenu* _contextmenu;
 
     int _iconstyle;
     int _treestyle;
 
   private slots:
 
     void contextMenuRequested( QListViewItem*, const QPoint&, int );
     void contextMenuRequested( QIconViewItem*, const QPoint& );
 
     // type converting signal forwarders
 
     void selectionChanged( QListViewItem * );
     void currentChanged( QListViewItem * );
     void clicked( QListViewItem * );
     void pressed( QListViewItem * );
     void doubleClicked( QListViewItem * );
     void returnPressed( QListViewItem * );
     void onItem( QListViewItem * );
 
     void selectionChanged( QIconViewItem * );
     void currentChanged( QIconViewItem * );
     void clicked( QIconViewItem * );
     void pressed( QIconViewItem * );
     void doubleClicked( QIconViewItem * );
     void returnPressed( QIconViewItem * );
     void onItem( QIconViewItem * );
 
     void expanded( QListViewItem * item ); // QListView
     void collapsed( QListViewItem * item ); // QListView
 
   signals:
 
-    void contextMenuRequested( OVersatileViewItem * item, const QPoint& pos, int col );
+    void contextMenuRequested( Opie::Ui::OVersatileViewItem * item, const QPoint& pos, int col );
 
     /*#ifndef QT_NO_DRAGANDDROP
     void dropped( QDropEvent *e, const QValueList<QIconDragItem> &lst );  // QIconView
     #endif
     void itemRenamed( OVersatileViewItem *item, const QString & );  // QIconView
     void itemRenamed( OVersatileViewItem *item );  // QIconView
     */
 
   //==============================================================================================//
   // "Derived" API - Case 1: Methods existing either only in QListView or only in QIconView
   //==============================================================================================//
 
 public:
 
     /*
     enum Arrangement {  // QIconView
     LeftToRight = 0,
     TopToBottom
     };
     enum ResizeMode {   // QIconView
     Fixed = 0,
     Adjust
     };
     enum ItemTextPos {  // QIconView
     Bottom = 0,
     Right
     };
     */
 
     //
     // only in QListView
     //
 
     int treeStepSize() const;  // QListView
     virtual void setTreeStepSize( int );  // QListView
 
     QHeader * header() const;  // QListView
 
     virtual int addColumn( const QString &label, int size = -1);  // QListView
     virtual int addColumn( const QIconSet& iconset, const QString &label, int size = -1);  // QListView
     void removeColumn( int index ); // #### make virtual in next major release!  // QListView
     virtual void setColumnText( int column, const QString &label );  // QListView
     virtual void setColumnText( int column, const QIconSet& iconset, const QString &label );  // QListView
     QString columnText( int column ) const;  // QListView
     virtual void setColumnWidth( int column, int width );  // QListView
     int columnWidth( int column ) const;  // QListView
     enum WidthMode { Manual, Maximum };  // QListView
     virtual void setColumnWidthMode( int column, WidthMode );  // QListView
     WidthMode columnWidthMode( int column ) const;  // QListView
     int columns() const;  // QListView
 
     virtual void setColumnAlignment( int, int );  // QListView
     int columnAlignment( int ) const;  // QListView
 
     OVersatileViewItem * itemAt( const QPoint & screenPos ) const;  // QListView
     QRect itemRect( const OVersatileViewItem * ) const;  // QListView
     int itemPos( const OVersatileViewItem * );  // QListView
 
     bool isSelected( const OVersatileViewItem * ) const;  // QListView  // also in QIconViewItem but not in QIconView *shrug*
 
     virtual void setMultiSelection( bool enable );  // QListView
     bool isMultiSelection() const;  // QListView
 
     OVersatileViewItem * selectedItem() const;  // QListView
     virtual void setOpen( OVersatileViewItem *, bool );  // QListView
     bool isOpen( const OVersatileViewItem * ) const;  // QListView
 
     OVersatileViewItem * firstChild() const;  // QListView
     int childCount() const;  // QListView
 
     virtual void setAllColumnsShowFocus( bool );  // QListView
     bool allColumnsShowFocus() const;  // QListView
 
     virtual void setItemMargin( int );  // QListView
     int itemMargin() const;  // QListView
 
     virtual void setRootIsDecorated( bool );  // QListView
     bool rootIsDecorated() const;  // QListView
 
     void setShowSortIndicator( bool show );  // QListView
     bool showSortIndicator() const;  // QListView
 
     int index( const OVersatileViewItem *item ) const;  // QIconView
 
   public slots:
     void triggerUpdate();  // QListView
 
   signals:
-    void expanded( OVersatileViewItem *item ); // QListView
-    void collapsed( OVersatileViewItem *item ); // QListView
+    void expanded( Opie::Ui::OVersatileViewItem *item ); // QListView
+    void collapsed( Opie::Ui::OVersatileViewItem *item ); // QListView
 
     //
     // only in QIconView
     //
 
   public:
     uint count() const;  // QIconView
 
     OVersatileViewItem *firstItem() const;  // QIconView
     OVersatileViewItem *lastItem() const;  // QIconView
 
     OVersatileViewItem *findItem( const QPoint &pos ) const; // QIconView
     OVersatileViewItem *findItem( const QString &text ) const; // QIconView
 
     OVersatileViewItem* findFirstVisibleItem( const QRect &r ) const;  // QIconView
     OVersatileViewItem* findLastVisibleItem( const QRect &r ) const;  // QIconView
 
     virtual void setGridX( int rx );  // QIconView
     virtual void setGridY( int ry );  // QIconView
     int gridX() const;  // QIconView
     int gridY() const;  // QIconView
     virtual void setSpacing( int sp );  // QIconView
     int spacing() const;  // QIconView
     virtual void setItemTextPos( QIconView::ItemTextPos pos );  // QIconView
     QIconView::ItemTextPos itemTextPos() const;  // QIconView
     virtual void setItemTextBackground( const QBrush &b );  // QIconView
     QBrush itemTextBackground() const;  // QIconView
     virtual void setArrangement( QIconView::Arrangement am );  // QIconView
     QIconView::Arrangement arrangement() const;  // QIconView
     virtual void setResizeMode( QIconView::ResizeMode am );  // QIconView
     QIconView::ResizeMode resizeMode() const;  // QIconView
     virtual void setMaxItemWidth( int w );  // QIconView
     int maxItemWidth() const;  // QIconView
     virtual void setMaxItemTextLength( int w );  // QIconView
     int maxItemTextLength() const;  // QIconView
     virtual void setAutoArrange( bool b );  // QIconView
     bool autoArrange() const;  // QIconView
     virtual void setShowToolTips( bool b );  // QIconView
     bool showToolTips() const;  // QIconView
 
     bool sorting() const;  // QIconView
     bool sortDirection() const;  // QIconView
 
     virtual void setItemsMovable( bool b );  // QIconView
     bool itemsMovable() const;  // QIconView
     virtual void setWordWrapIconText( bool b );  // QIconView
     bool wordWrapIconText() const;  // QIconView
 
   public slots:
     virtual void arrangeItemsInGrid( const QSize &grid, bool update = TRUE );  // QIconView
     virtual void arrangeItemsInGrid( bool update = TRUE );  // QIconView
     virtual void updateContents();  // QIconView
 
   signals:
     /*#ifndef QT_NO_DRAGANDDROP
     void dropped( QDropEvent *e, const QValueList<QIconDragItem> &lst );  // QIconView
     #endif
     */
     void moved();  // QIconView
-    void itemRenamed( OVersatileViewItem *item, const QString & );  // QIconView
-    void itemRenamed( OVersatileViewItem *item );  // QIconView
+    void itemRenamed( Opie::Ui::OVersatileViewItem *item, const QString & );  // QIconView
+    void itemRenamed( Opie::Ui::OVersatileViewItem *item );  // QIconView
 
   //==============================================================================================//
   // "Derived" API - Case 2: Methods existing in QListView and QIconView with the same signatures
   //==============================================================================================//
 
   public:
     enum SelectionMode {
     Single = 0,
     Multi,
     Extended,
     NoSelection
     };
 
     virtual void clear();
 
     virtual void setFont( const QFont & );
     virtual void setPalette( const QPalette & );
 
     virtual void takeItem( OVersatileViewItem * );
 
     void setSelectionMode( SelectionMode mode );
     SelectionMode selectionMode() const;
 
     virtual void selectAll( bool select );
     virtual void clearSelection();
     virtual void invertSelection();
 
     void ensureItemVisible( const OVersatileViewItem * );
     virtual void repaintItem( const OVersatileViewItem * ) const;
 
     virtual void setCurrentItem( OVersatileViewItem * );
     OVersatileViewItem * currentItem() const;
 
     // bool eventFilter( QObject * o, QEvent * );   // use QWidgetStack implementation
 
     // QSize minimumSizeHint() const;               // use QWidgetStack implementation
     // QSizePolicy sizePolicy() const;              // use QWidgetStack implementation
     // QSize sizeHint() const;                      // use QWidgetStack implementation
 
   signals:
     void selectionChanged();
-    void selectionChanged( OVersatileViewItem * );
-    void currentChanged( OVersatileViewItem * );
-    void clicked( OVersatileViewItem * );
-    void pressed( OVersatileViewItem * );
+    void selectionChanged( Opie::Ui::OVersatileViewItem * );
+    void currentChanged( Opie::Ui::OVersatileViewItem * );
+    void clicked( Opie::Ui::OVersatileViewItem * );
+    void pressed( Opie::Ui::OVersatileViewItem * );
 
-    void doubleClicked( OVersatileViewItem * );
-    void returnPressed( OVersatileViewItem * );
+    void doubleClicked( Opie::Ui::OVersatileViewItem * );
+    void returnPressed( Opie::Ui::OVersatileViewItem * );
 
-    void onItem( OVersatileViewItem * );
+    void onItem( Opie::Ui::OVersatileViewItem * );
     void onViewport();
 
   //==============================================================================================//
   // "Derived" API - Case 2: Methods existing in QListView and QIconView with differing signatures
   //==============================================================================================//
 
   /*
 
   public:
     virtual void insertItem( OVersatileViewItem * );  // QListView
     virtual void insertItem( OVersatileViewItem *item, OVersatileViewItem *after = 0L );  // QIconView
 
     virtual void setSelected( OVersatileViewItem *, bool );  // QListView
     virtual void setSelected( OVersatileViewItem *item, bool s, bool cb = FALSE );  // QIconView
 
     virtual void setSorting( int column, bool increasing = TRUE );  // QListView
     void setSorting( bool sort, bool ascending = TRUE );  // QIconView
 
     void sort(); // #### make virtual in next major release  // QListView
     virtual void sort( bool ascending = TRUE );  // QIconView
 
   */
 
   signals:
-    void clicked( OVersatileViewItem *, const QPoint &, int );  // QListView
-    void clicked( OVersatileViewItem *, const QPoint & );  // QIconView
+    void clicked( Opie::Ui::OVersatileViewItem *, const QPoint &, int );  // QListView
+    void clicked( Opie::Ui::OVersatileViewItem *, const QPoint & );  // QIconView
 
-    void pressed( OVersatileViewItem *, const QPoint &, int );  // QListView
-    void pressed( OVersatileViewItem *, const QPoint & );  // QIconView
+    void pressed( Opie::Ui::OVersatileViewItem *, const QPoint &, int );  // QListView
+    void pressed( Opie::Ui::OVersatileViewItem *, const QPoint & );  // QIconView
 
-    void rightButtonClicked( OVersatileViewItem* item, const QPoint& pos );  // QIconView
-    void rightButtonClicked( OVersatileViewItem *, const QPoint&, int );  // QListView
+    void rightButtonClicked( Opie::Ui::OVersatileViewItem* item, const QPoint& pos );  // QIconView
+    void rightButtonClicked( Opie::Ui::OVersatileViewItem *, const QPoint&, int );  // QListView
 
-    void rightButtonPressed( OVersatileViewItem* item, const QPoint& pos );  // QIconView
-    void rightButtonPressed( OVersatileViewItem *, const QPoint&, int );  // QListView
+    void rightButtonPressed( Opie::Ui::OVersatileViewItem* item, const QPoint& pos );  // QIconView
+    void rightButtonPressed( Opie::Ui::OVersatileViewItem *, const QPoint&, int );  // QListView
 
-    void mouseButtonPressed( int, OVersatileViewItem *, const QPoint& , int );  // QListView
-    void mouseButtonPressed( int button, OVersatileViewItem* item, const QPoint& pos );  // QIconView
+    void mouseButtonPressed( int, Opie::Ui::OVersatileViewItem *, const QPoint& , int );  // QListView
+    void mouseButtonPressed( int button, Opie::Ui::OVersatileViewItem* item, const QPoint& pos );  // QIconView
 
-    void mouseButtonClicked( int, OVersatileViewItem *,  const QPoint&, int );  // QListView
-    void mouseButtonClicked( int button, OVersatileViewItem* item, const QPoint& pos );  // QIconView
+    void mouseButtonClicked( int, Opie::Ui::OVersatileViewItem *,  const QPoint&, int );  // QListView
+    void mouseButtonClicked( int button, Opie::Ui::OVersatileViewItem* item, const QPoint& pos );  // QIconView
 
 };
 
 }
 }
 #endif