2 files changed, 7 insertions, 7 deletions

diff --git a/docs/qcop.doc b/docs/qcop.doc
index 6fe4c71..e62f91d 100644
--- a/docs/qcop.doc
+++ b/docs/qcop.doc
@@ -1,179 +1,179 @@
 /*!
 
 \page qcop.html
 
 \title QCop Messages
 
 QCop messages allow applications to communicate with each other.
 These messages are send using QCopEnvelope, and received by connecting
 to a QCopChannel.
 
 The <tt>channelname</tt> of channels within Qtopia all start with "QPE/".
 The <tt>messagename</tt> is a function identifier followed by a list of types
 in parentheses. There are no spaces in the message name.
 
 The variable names shown in this documentation are purely for information
 purposes.  A message shown as
 "messageName(Type1 varname1, Type2 varname2, Type2 varname3)" would be
 used in program code as:
 
 \code
    QCopEnvelope e(channelname, "messageName(Type1,Type2,Type2)");
    e << parameter1 << parameter2 << parameter3;
 \endcode
 
 
 The system-wide channels and messages.
 
 <dl>
 <dt><b>QPE/System</b>
  <dd>
   <ul>
     <li>busy()
         <br> Causes a wait indicator to be shown to the user.
     <li>notBusy()
         <br> Cancels the wait indicator.
     <li>linkChanged(QString)
         <br> Sent whenever a link is changed.
             It is sent by FileManager::saveFile() and others, and
             received by the Launcher.
     <li>applyStyle()
         <br> Sent when user changes style.
             It is received by QPEApplication and the application
             will redraw accordingly.
     <li>quit()
         <br> Terminates the Qtopia environment.
     <li>shutdown()
         <br> Terminates the system.
     <li>restart()
         <br> Restarts the Qtopia environment.
     <li>execute(QString)
         <br> Executes or raises the given application.
     <li>execute(QString,QString)
         <br> Executes or raises the given application, passing an argument.
             Note that you should consider using the 
             <b>QPE/Application/<i>appname</i></b> channels described below.
     <li>addAlarm(QDateTime,QCString,QCString,int)
         <br> Internal. See AlarmServer::addAlarm()
     <li>deleteAlarm(QDateTime,QCString,QCString,int)
         <br> Internal. See AlarmServer::deleteAlarm()
     <li>setDefaultRotation(int)
         <br> Internal.
     <li>grabKeyboard(QString)
         <br> Internal.
     <li>timeChange(QString)
         <br> Internal.
     <li>clockChange(bool)
         <br> Internal.
     <li>setScreenSaverInterval(int)
         <br> Internal.
     <li>language(QString)
         <br> Internal.
   </ul>
 
 <dt><b>QPE/Sync</b>
  <ul>
     <li>flush()
         <br> Sent at the start of synchronization. Synchable applications
             should save any synchable data to disk.
             <i>Note: this message is currently asynchronous. Stay tuned
                 to discussions regarding synchronization, as this message
                 may become synchronous, requiring slight midification to
                 your code. For now, just respond in a timely fashion,
                 since the sync server merely waits a small time.</i>
     <li>reload()
         <br> Sent at the end of synchronization. Synchable applications
             should reload any synchable data from disk.
  </ul>
 
 <dt><b>QPE/TaskBar</b>
  <ul>
     <li>message(QString)
         <br> Internal. See Global::statusMessage()
     <li>showInputMethod()
         <br> Internal.
     <li>hideInputMethod()
         <br> Internal.
     <li>reloadInputMethods()
         <br> Internal.
     <li>reloadApplets()
         <br> Internal.
  </ul>
 
 <dt><b>QPE/Card</b>
  <ul>
     <li>stabChanged()
         <br> Sent when <tt>/var/run/stab</tt>, <tt>/var/state/pcmcia/stab</tt>,
                 or <tt>/var/lib/pcmcia/stab</tt> may have changed.
     <li>netUp()
         <br> Sent when a network connection is running.
     <li>netDown()
         <br> Sent when a network connection is available, but not running.
     <li>netUnavailable()
         <br> Sent when a network connection is not available.
  </ul>
 
 <dt><b>Qt/Tray</b>
  This channel allows Qt applications (not just Qtopia applications)
  to show system-tray status in a cross-platform manner,
  but it is not currently supported. See TaskbarAppletInterface for
  a more powerful alternative for system tray applications.
  <ul>
     <li>popup(int,QPoint)
     <li>remove(int)
     <li>setIcon(int,QPixmap)
     <li>setToolTip(int,QString)
     <li>doubleClicked(int,QPoint)
     <li>clicked(int,QPoint)
  </ul>
 </dl>
 
 Each application listens on a channel called
 <b>QPE/Application/<i>appname</i></b>, where <b><i>appname</i></b> is
 the executable name (the application identifier). Standard messages on
 this channel are:
 
 <dl>
  <dt><b>QPE/Application/<i>appname</i></b>
   <ul>
     <li>setDocument(QString)
         <br>Internal. Causes the setDocument(const QString&) slot
             of <a href=docwidget.html>the main document widget</a>
             to be called.
     <li>nextView()
         <br>Applications connected to hardware buttons will receive
             this message if they are already visible.
     <li>raise()
         <br>Internal. Causes the the main document widget and the
             current modal widget to be raised.
     <li>quit()
         <br>Internal. Terminates the application.
     <li>quitIfInvisible()
         <br>Internal. Terminates the application if it is not shown.
   </ul>
 </dl>
 
 The QPE/Application/<i>appname</i> channel has a special property: when
 messages are sent to these channels vie QCopEnvelope, the message is
 delivered even if the application is not yet running (the application
 is run and the message is then sent).
 
 Applications also respond to messages specific to the application.
 Such messages in the base Qtopia applications are:
 
 <dl>
  <dt><b>QPE/Application/helpbrowser</b>
   <ul>
    <li>showFile(QString <i>file</i>)
     <br>Send this message to have the Help Browser show a file.
         The <i>file</i> may be an absolute filename or relative
-        to the system HTML documentation directory ($QPEDIR/help/html).
+        to the system HTML documentation directory ($OPIEDIR/help/html).
   </ul>
  <dt><b>QPE/Application/datebook</b>
   <ul>
    <li>alarm(QDateTime,int)
     <br>Internal. Causes the Calendar application to sound alarms.
   </ul>
 </dl>
 
 */
diff --git a/docs/start.doc b/docs/start.doc
index 9745d9a..01b6ab1 100644
--- a/docs/start.doc
+++ b/docs/start.doc
@@ -1,191 +1,191 @@
 /*!
 
 \page start.html
 
 \title Getting Started
 
 <html>
 <title>Qtopia - The Qt palmtop environment</title>
 
 <body>
 <h1><i>Qtopia</i> - The Qt palmtop environment</h1>
 
 <p>
 <i>Qtopia</i> is a windowing system for handheld devices. It offers
 developers the powerful Qt API, and provides users with fast and
 intuitive interaction.
 
 <h2>Developing for <i>Qtopia</i></h2>
 
 <p>
 The Qt API includes rich GUI functionality, and is suitable for
 both large and small applications.
 
 <p> 
 Since <i>Qtopia</i> offers the complete Qt API, you can do much of
 your development on any of the other platforms for which Qt is
 available - Windows, Unix/X11, or Mac OS X. However, for optimal
 tailoring of your application to the smaller screen and other
 demands of a handheld environment, you should use the <i>Qtopia
 SDK</i>.
 
 <p>
 The <i>Qtopia SDK</i> allows you to develop <i>Qtopia</i>
 applications under the Linux desktop environment using the Qt Virtual
 Framebuffer, which completely emulates the handheld <i>Qtopia</i>
 environment. It also includes cross-compiler software so that you can
 compile your application to run on the target handheld device.
 If you do not already have the Qtopia SDK (this document is normally
 part of the SDK), contact info@trolltech.com, or see the
 <a href=http://www.trolltech.com>Trolltech</a> web site.
 
 <p>To build applications for the SHARP SL5000 or similar StrongARM-based devices,
 you will also need a StrongARM cross compiler. Entrants in the programming
 contest for this device will have received both the SDK and a cross-compiler.
 
 <p>
 The SDK includes an example program. We recommend that you compile and
 run this example to learn how things work, before tackling your own
 projects.
 
 <p>
 To compile the example program for running on the Linux desktop:
 
 <ol>
  <li>
     <p>
     Check the environment is correct:
 
     <p>
 <pre>
-    export QPEDIR=/opt/Qtopia
+    export OPIEDIR=/opt/Qtopia
     export QTDIR=/opt/Qtopia
     export PATH=$QTDIR/bin:$PATH
     export TMAKEPATH=/opt/Qtopia/tmake/lib/qws/linux-generic-g++
     export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH
 </pre>
 
  <li> Take a copy of the example:
 
 <pre>
    cd somewhere
-   cp -r $QPEDIR/example .
+   cp -r $OPIEDIR/example .
    cd example
 </pre>
 
  <li> Generate a Makefile:
 
 <pre>
    tmake -o Makefile example.pro
 </pre>
 
  <li> Build the example:
 
 <pre>
    make
 </pre>
 
  <li> Install it:
 
 <pre>
    su # root privileges required to install
-   cp example.desktop $QPEDIR/apps/Applications
-   cp Example.png $QPEDIR/pics
-   cp example $QPEDIR/bin
+   cp example.desktop $OPIEDIR/apps/Applications
+   cp Example.png $OPIEDIR/pics
+   cp example $OPIEDIR/bin
    exit # no need to be root anymore
 </pre>
 
  <li> To run it, first run the Qt Virtual Framebuffer:
 
 <pre>
    qvfb &amp;
 </pre>
 
  <li> Then run the <i>Qtopia</i> environment:
 
 <pre>
    qpe
 </pre>
 
 <p>
  Your application should be available in the Applications tab visible
 inside the Qt Virtual Framebuffer window.
 </p>
 
  <li> If you want to distribute your applications to others, build an RPM package, e.g.:
 <pre>
    mkipks -rpm -arch i386 example.control
 </pre>
 </ol>
 
 <p>
 To make your own application, use the example program as a model. Make sure that
 when you add files to your project, you also add them
 to your project file (e.g. <tt>example.pro</tt>) and rerun the
 <tt>tmake</tt> command to update the <tt>Makefile</tt>.
 
 <p>
 To build you application for the SHARP SL5000 rather than just running
 on the desktop, the process is similar:
 
 <ol>
  <li>
     <p>
     Check the environment is correctly set for the SHARP SL5000:
 
     <p>
 <pre>
-    export QPEDIR=/opt/Qtopia/sharp
+    export OPIEDIR=/opt/Qtopia/sharp
     export QTDIR=/opt/Qtopia/sharp
     export PATH=$QTDIR/bin:/usr/local/arm/bin:$PATH
     export TMAKEPATH=/opt/Qtopia/tmake/lib/qws/linux-sharp-g++
 </pre>
 
  <li> Build and install exactly the same as you did for the desktop
     (note that the generated Makefile is different):
 <pre>
    make clean
    tmake -o Makefile example.pro
    ... <i>etc.</i>
 </pre>
 
  <li> To install it on a device, build an ipk package file (you should be root
         to do this, since then it will strip the executable for you):
 <pre>
    mkipks example.control
 </pre>
 
 <p>
   The resulting <tt>example-1.0.0.ipk</tt> can be installed on the
 SL5000 by using <i>Qtopia Desktop</i>.
 </p>
 
 </ol>
 
 <h3>Building Your Own Applications</h3>
 
 Once you have built the example, you can proceed with writing
 your own applicatons. If you are not familiar with Qt, you should
 consult the Qt documentation by pointing your web browser at
 <a href=file:/opt/Qtopia/doc/html/index.html><tt>/opt/Qtopia/doc/html/index.html</tt></a>
 when you have installed the SDK, or use the online
 <a href=http://doc.trolltech.com/>Trolltech Documentation Site</a>.
 The <a href="http://www.trolltech.com/products/qt/whitepaper.html">Qt
 Whitepaper</a> provides a good overview of, and introduction to, the
 Qt API.
 
 <p>
 When you add more files to your application, just edit the project
 file (e.g. <tt>example.pro</tt>) and rerun the <tt>tmake</tt>
 command.
 
 <p>
 The <tt>.ui</tt> files are <i>Qt Designer</i> user interface files.
 You can create and edit these using <i>Qt Designer</i>:
 <pre>
    designer example.ui
 </pre>
 <i>Qt Designer</i>'s online documentation includes a complete
 tutorial.
 
 */