implement progress

4 files changed, 36 insertions, 4 deletions

diff --git a/libopie/oprocess.h b/libopie/oprocess.h
index ce3c87d..fd726b4 100644
--- a/libopie/oprocess.h
+++ b/libopie/oprocess.h
@@ -1,805 +1,805 @@
 /* This file is part of the KDE libraries
     Copyright (C) 1997 Christian Czezakte (e9025461@student.tuwien.ac.at)
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 //
 //  KPROCESS -- A class for handling child processes in KDE without
 //  having to take care of Un*x specific implementation details
 //
 //  version 0.3.1, Jan 8th 1998
 //
 //  (C) Christian Czezatke
 //  e9025461@student.tuwien.ac.at
-//  Ported by Holger Freyther
+//  Ported by Holger Freyther to the Open Palmtop Integrated Environment
 //
 
 #ifndef __kprocess_h__
 #define __kprocess_h__
 
 #include <sys/types.h> // for pid_t
 #include <sys/wait.h>
 #include <signal.h>
 #include <unistd.h>
 #include <qvaluelist.h>
 #include <qcstring.h>
 #include <qobject.h>
 
 class QSocketNotifier;
 class OProcessPrivate;
 
 /**
  * Child process invocation, monitoring and control.
  *
  * @sect General usage and features
  *
  *This class allows a KDE 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 *)));
  *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
  *
  *
  **/
 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();
 
   /**
    *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 signo	The signal to send. The default is SIGTERM.
    * @return @p true if the signal was delivered successfully.
   */
   virtual bool kill(int signo = SIGTERM);
 
   /**
      @return @p true if the process is (still) considered to be running
   */
   bool isRunning() const;
 
   /** Returns the process id of the process.
    *
    * If it is called after
    * the process has exited, it returns the process id of the last
    *  child process that was created by this instance of OProcess.
    *
    *  Calling it before any child process has been started by this
    *  OProcess instance causes pid() to return 0.
    **/
   pid_t pid() const;
 
   /**
    * Use pid().
    * @deprecated
    */
   pid_t getPid() const { return pid(); }
 
   /**
    * Suspend processing of data from stdout of the child process.
    */
   void suspend();
 
   /**
    * Resume processing of data from stdout of the child process.
    */
   void resume();
 
   /**
    * @return @p true if the process has already finished and has exited
    *  "voluntarily", ie: it has not been killed by a signal.
    *
    * Note that you should check @ref OProcess::exitStatus() to determine
    * whether the process completed its task successful or not.
    */
   bool normalExit() const;
 
   /**
    * Returns the exit status of the process.
    *
    * Please use
    * @ref OProcess::normalExit() to check whether the process has exited
    * cleanly (i.e., @ref OProcess::normalExit() returns @p true) before calling
    * this function because if the process did not exit normally,
    * it does not have a valid exit status.
   */
   int  exitStatus() const;
 
 
   /**
    *	 Transmit data to the child process's stdin.
    *
    * OProcess::writeStdin may return false in the following cases:
    *
    *     @li The process is not currently running.
    *
    *     @li Communication to stdin has not been requested in the @ref start() call.
    *
    *     @li Transmission of data to the child process by a previous call to
    * @ref writeStdin() is still in progress.
    *
    * Please note that the data is sent to the client asynchronously,
    * so when this function returns, the data might not have been
    * processed by the child process.
    *
    * If all the data has been sent to the client, the signal
    * @ref wroteStdin() will be emitted.
    *
    * Please note that you must not free "buffer" or call @ref writeStdin()
    * again until either a @ref wroteStdin() signal indicates that the
    * data has been sent or a @ref processHasExited() signal shows that
    * the child process is no longer alive...
    **/
   bool writeStdin(const char *buffer, int buflen);
 
   /**
    * This causes the stdin file descriptor of the child process to be
    * closed indicating an "EOF" to the child.
    *
    * @return @p false if no communication to the process's stdin
    *  had been specified in the call to @ref start().
   */
   bool closeStdin();
 
   /**
    * This causes the stdout file descriptor of the child process to be
    * closed.
    *
    * @return @p false if no communication to the process's stdout
    *  had been specified in the call to @ref start().
   */
   bool closeStdout();
 
   /**
    * This causes the stderr file descriptor of the child process to be
    * closed.
    *
    * @return @p false if no communication to the process's stderr
    *  had been specified in the call to @ref start().
   */
   bool closeStderr();
 
   /**
    * Lets you see what your arguments are for debugging.
    */
 
   const QValueList<QCString> &args() { return arguments; }
 
   /**
    * Controls whether the started process should drop any
    * setuid/segid privileges or whether it should keep them
    *
    * The default is @p false : drop privileges
    */
   void setRunPrivileged(bool keepPrivileges);
 
   /**
    * Returns whether the started process will drop any
    * setuid/segid privileges or whether it will keep them
    */
   bool runPrivileged() const;
   
   /**
    * Modifies the environment of the process to be started.
    * This function must be called before starting the process.
    */
   void setEnvironment(const QString &name, const QString &value);
 
   /**
    * Changes the current working directory (CWD) of the process 
    * to be started.
    * This function must be called before starting the process.
    */
   void setWorkingDirectory(const QString &dir);
 
   /**
    * Specify whether to start the command via a shell or directly.
    * The default is to start the command directly.
    * If @p useShell is true @p shell will be used as shell, or
    * if shell is empty, the standard shell is used.
    * @p quote A flag indicating whether to quote the arguments.
    *
    * When using a shell, the caller should make sure that all filenames etc.
    * are properly quoted when passed as argument.
    * @see quote()
    */
   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(); 
 
 
 
 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);
 
 
   /**
    * 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);
 
   /**
    * 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);
 
   /**
    * 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);
 
 
 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 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& );
 
 protected:
   virtual void virtual_hook( int id, void* data );
 private:
   OProcessPrivate *d;
 };
 
 class KShellProcessPrivate;
 
 /**
 * @obsolete
 *
 * This class is obsolete. Use OProcess and OProcess::setUseShell(true)
 * instead.
 *
 *   @short A class derived from @ref OProcess to start child
 *   	processes through a shell.
 *   @author Christian Czezakte <e9025461@student.tuwien.ac.at>
 *   @version $Id$
 */
 class KShellProcess: public OProcess
 {
   Q_OBJECT
 
 public:
 
   /**
    * Constructor
    *
    * By specifying the name of a shell (like "/bin/bash") you can override
    * the mechanism for finding a valid shell as described in OProcess::searchShell()
    */
   KShellProcess(const char *shellname=0);
 
   /**
    * Destructor.
    */
   ~KShellProcess();
 
   /**
    * Starts up the process. -- For a detailed description
    * have a look at the "start" member function and the detailed
    * description of @ref OProcess .
    */
   virtual bool start(RunMode  runmode = NotifyOnExit,
 		  Communication comm = NoCommunication);
 
   /**
    * 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);
 
 private:
 
   QCString shell;
 
   // Disallow assignment and copy-construction
   KShellProcess( const KShellProcess& );
   KShellProcess& operator= ( const KShellProcess& );
 
 protected:
   virtual void virtual_hook( int id, void* data );
 private:
   KShellProcessPrivate *d;
 };
 
 
 
 #endif
 
diff --git a/libopie/tododb.cpp b/libopie/tododb.cpp
index 6b10ec2..1e40c40 100644
--- a/libopie/tododb.cpp
+++ b/libopie/tododb.cpp
@@ -1,258 +1,266 @@
 
 #include <qdir.h>
 #include <opie/tododb.h>
 #include <opie/xmltree.h>
 #include <opie/todoresource.h>
 #include <qpe/palmtoprecord.h>
 #include <qpe/global.h>
 
 using namespace Opie;
 
 namespace {
 
 class FileToDoResource : public ToDoResource {
 public:
   FileToDoResource() {};
     // FIXME better parsing
   bool save(const QString &name, const QValueList<ToDoEvent> &m_todos ){
     // prepare the XML
     XMLElement *tasks = new XMLElement( );
     tasks->setTagName("Tasks" );
     for( QValueList<ToDoEvent>::ConstIterator it = m_todos.begin(); it != m_todos.end(); ++it ){
 	XMLElement::AttributeMap map;
 	XMLElement *task = new XMLElement();
 	map.insert( "Completed", QString::number((int)(*it).isCompleted() ) );
 	map.insert( "HasDate", QString::number((int)(*it).hasDate() ) );
 	map.insert( "Priority", QString::number( (*it).priority() ) );
+        map.insert( "Progress", QString::number( (*it).progress() ) );
         map.insert( "Summary", (*it).summary() );
 	QArray<int> arrat = (*it).categories();
 	QString attr;
 	for(uint i=0; i < arrat.count(); i++ ){
 	  attr.append(QString::number(arrat[i])+";" );
 	}
 	if(!attr.isEmpty() ) // remove the last ;
 	  attr.remove(attr.length()-1, 1 );
 	map.insert( "Categories", attr );
 	//else
 	//map.insert( "Categories", QString::null );
 	map.insert( "Description", (*it).description() );
 	if( (*it).hasDate() ){
 	  map.insert("DateYear",  QString::number( (*it).date().year()  ) );
 	  map.insert("DateMonth", QString::number( (*it).date().month() ) );
 	  map.insert("DateDay", QString::number( (*it).date().day()  ) );
 	}
 	map.insert("Uid", QString::number( (*it).uid() ) );
 	task->setTagName("Task" );
 	task->setAttributes( map );
 	tasks->appendChild(task);
     }
     QFile file( name);
     if( file.open(IO_WriteOnly ) ){
       QTextStream stream(&file );
       stream.setEncoding( QTextStream::UnicodeUTF8 );
       stream << "<!DOCTYPE Tasks>" << endl;
       tasks->save(stream );
       delete tasks;
       stream << "</Tasks>" << endl;
       file.close();
       return true;
     }
     return false;
   }
   QValueList<ToDoEvent> load( const QString &name ){
     qWarning("loading tododb" );
     QValueList<ToDoEvent> m_todos;
     XMLElement *root = XMLElement::load( name );
     if(root != 0l ){ // start parsing
       qWarning("ToDoDB::load tagName(): %s", root->tagName().latin1()  );
 	//if( root->tagName() == QString::fromLatin1("Tasks" ) ){// Start
       XMLElement *element = root->firstChild();
       element = element->firstChild();
       while( element ){
 	if( element->tagName() != QString::fromLatin1("Task") ){
 	  element = element->nextChild();
 	  continue;
 	}
 	qWarning("ToDoDB::load element tagName() : %s", element->tagName().latin1() );
 	QString dummy;
 	ToDoEvent event;
 	bool ok;
 	int dumInt;
 	// completed
 	dummy = element->attribute("Completed" );
 	dumInt = dummy.toInt(&ok );
 	if(ok ) event.setCompleted( dumInt == 0 ? false : true );
+        // progress
+        dummy = element->attribute("Progress" );
+        {
+            ushort dumShort = dummy.toUShort(&ok);
+            event.setProgress( dumShort );
+
+        }
 	// hasDate
 	dummy = element->attribute("HasDate" );
 	dumInt = dummy.toInt(&ok );
 	if(ok ) event.setHasDate( dumInt == 0 ? false: true );
 	// set the date
 	bool hasDa = dumInt;
 	if ( hasDa ) { //parse the date
 	  int year, day, month = 0;
 	  year = day = month;
 	  // year
 	  dummy = element->attribute("DateYear" );
 	  dumInt = dummy.toInt(&ok );
 	  if( ok ) year = dumInt;
 	  // month
 	  dummy = element->attribute("DateMonth" );
 	  dumInt = dummy.toInt(&ok );
 	  if(ok ) month = dumInt;
 	  dummy = element->attribute("DateDay" );
 	  dumInt = dummy.toInt(&ok );
 	  if(ok ) day = dumInt;
 	  // set the date
 	  QDate date( year, month, day );
 	  event.setDate( date);
 	}
 	dummy = element->attribute("Priority" );
 	dumInt = dummy.toInt(&ok );
 	if(!ok ) dumInt = ToDoEvent::NORMAL;
 	event.setPriority( dumInt );
 	//description
 	dummy = element->attribute("Description" );
 	event.setDescription( dummy );
         dummy = element->attribute("Summary" );
         event.setSummary( dummy );
 	// category
 	dummy = element->attribute("Categories" );
 	QStringList ids = QStringList::split(";", dummy );
 	event.setCategories( ids );
 
 	//uid
 	dummy = element->attribute("Uid" );
 	dumInt = dummy.toInt(&ok );
 	if(ok ) event.setUid( dumInt );
 	m_todos.append( event );
 	element = element->nextChild(); // next element
       }
       //}
     }else {
       qWarning("could not load" );
     }
     delete root;
     qWarning("returning" );
     return m_todos;
   }
 };
 
 }
 
 ToDoDB::ToDoDB(const QString &fileName, ToDoResource *res ){
     m_fileName = fileName;
     if( fileName.isEmpty() && res == 0 ){
 	m_fileName = Global::applicationFileName("todolist","todolist.xml");
 	res = new FileToDoResource();
 	//qWarning("%s", m_fileName.latin1() );
     }else if(res == 0 ){ // let's create a ToDoResource for xml
       res = new FileToDoResource();
     }
     m_res = res;
     load();
 }
 ToDoResource* ToDoDB::resource(){
   return m_res;
 };
 void ToDoDB::setResource( ToDoResource *res )
 {
   delete m_res;
   m_res = res;
 }
 ToDoDB::~ToDoDB()
 {
   delete m_res;
 }
 QValueList<ToDoEvent> ToDoDB::effectiveToDos(const QDate &from, const QDate &to,
 					     bool all )
 {
     QValueList<ToDoEvent> events;
     for( QValueList<ToDoEvent>::Iterator it = m_todos.begin(); it!= m_todos.end(); ++it ){
 	if( (*it).hasDate() ){
 	    if( (*it).date() >= from && (*it).date() <= to )
 		events.append( (*it) );
 	}else if( all ){
 	    events.append( (*it) );
 	}
     }
     return events;
 }
 QValueList<ToDoEvent> ToDoDB::effectiveToDos(const QDate &from,
 					     bool all)
 {
     return effectiveToDos( from, QDate::currentDate(), all );
 }
 QValueList<ToDoEvent> ToDoDB::overDue()
 {
     QValueList<ToDoEvent> events;
     for( QValueList<ToDoEvent>::Iterator it = m_todos.begin(); it!= m_todos.end(); ++it ){
 	if( (*it).isOverdue() )
 	    events.append((*it) );
     }
     return events;
 }
 QValueList<ToDoEvent> ToDoDB::rawToDos()
 {
     return m_todos;
 }
 void ToDoDB::addEvent( const ToDoEvent &event )
 {
     m_todos.append( event );
 }
 void ToDoDB::editEvent( const ToDoEvent &event )
 {
     m_todos.remove( event );
     m_todos.append( event );
 }
 void ToDoDB::removeEvent( const ToDoEvent &event )
 {
     m_todos.remove( event );
 }
 void ToDoDB::replaceEvent(const ToDoEvent &event )
 {
   QValueList<ToDoEvent>::Iterator it;
   int uid = event.uid();
   // == is not overloaded as we would like :( so let's search for the uid
   for(it = m_todos.begin(); it != m_todos.end(); ++it ){
     if( (*it).uid() == uid ){
       m_todos.remove( (*it) );
       break; // should save us the iterate is now borked
     }
   }
   m_todos.append(event);
 }
 void ToDoDB::reload()
 {
     load();
 }
 void ToDoDB::mergeWith(const QValueList<ToDoEvent>& events )
 {
   QValueList<ToDoEvent>::ConstIterator it;
   for( it = events.begin(); it != events.end(); ++it ){
     replaceEvent( (*it) );
   }
 }
 void ToDoDB::setFileName(const QString &file )
 {
     m_fileName =file;
 }
 QString ToDoDB::fileName()const
 {
     return m_fileName;
 }
 void ToDoDB::load()
 {
   m_todos = m_res->load( m_fileName );
 }
 bool ToDoDB::save()
 {
   return m_res->save( m_fileName, m_todos );
 }
 
 
 
 
 
 
 
 
diff --git a/libopie/todoevent.cpp b/libopie/todoevent.cpp
index fb7073c..b35ac9d 100644
--- a/libopie/todoevent.cpp
+++ b/libopie/todoevent.cpp
@@ -1,269 +1,282 @@
 
 #include <opie/todoevent.h>
 
 
 #include <qpe/palmtopuidgen.h>
 #include <qpe/stringutil.h>
 #include <qpe/palmtoprecord.h>
 
 #include <qpe/stringutil.h>
 #include <qpe/categories.h>
 #include <qpe/categoryselect.h>
 
 #include <qobject.h>
 
 ToDoEvent::ToDoEvent(const ToDoEvent &event )
 {
   *this = event;
 }
 
 ToDoEvent::ToDoEvent(bool completed, int priority,
                      const QStringList &category,
                      const QString& summary,
                      const QString &description,
+                     ushort progress,
                      bool hasDate, QDate date, int uid )
 {
     m_date = date;
     m_isCompleted = completed;
     m_hasDate = hasDate;
     m_priority = priority;
     m_category = category;
     m_sum = summary;
+    m_prog = progress;
     m_desc = Qtopia::simplifyMultiLineSpace(description );
     if (uid == -1 ) {
 	Qtopia::UidGen *uidgen = new Qtopia::UidGen();
 	uid = uidgen->generate();
 	delete uidgen;
     }// generate the ids
     m_uid = uid;
 }
 QArray<int> ToDoEvent::categories()const
 {
   QArray<int> array(m_category.count() ); // currently the datebook can be only in one category
     array = Qtopia::Record::idsFromString( m_category.join(";") );
   return array;
 }
 bool ToDoEvent::match( const QRegExp &regExp )const
 {
   if( QString::number( m_priority ).find( regExp ) != -1 ){
     return true;
   }else if( m_hasDate && m_date.toString().find( regExp) != -1 ){
     return true;
   }else if(m_desc.find( regExp ) != -1 ){
     return true;
   }
   return false;
 }
 bool ToDoEvent::isCompleted() const
 {
     return m_isCompleted;
 }
 bool ToDoEvent::hasDate() const
 {
     return m_hasDate;
 }
 int ToDoEvent::priority()const
 {
     return m_priority;
 }
 QStringList ToDoEvent::allCategories()const
 {
     return m_category;
 }
 QString ToDoEvent::extra(const QString& )const
 {
     return QString::null;
 }
 QString ToDoEvent::summary() const
 {
     return m_sum;
 }
+ushort ToDoEvent::progress() const
+{
+    return m_prog;
+}
 void ToDoEvent::insertCategory(const QString &str )
 {
   m_category.append( str );
 }
 void ToDoEvent::clearCategories()
 {
   m_category.clear();
 }
 void ToDoEvent::setCategories(const QStringList &list )
 {
   m_category = list;
 }
 QDate ToDoEvent::date()const
 {
     return m_date;
 }
 
 QString ToDoEvent::description()const
 {
     return m_desc;
 }
 void ToDoEvent::setCompleted( bool completed )
 {
     m_isCompleted = completed;
 }
 void ToDoEvent::setHasDate( bool hasDate )
 {
     m_hasDate = hasDate;
 }
 void ToDoEvent::setDescription(const QString &desc )
 {
     m_desc = Qtopia::simplifyMultiLineSpace(desc );
 }
 void ToDoEvent::setExtra( const QString&, const QString& )
 {
 
 }
 void ToDoEvent::setSummary( const QString& sum )
 {
     m_sum = sum;
 }
 void ToDoEvent::setCategory( const QString &cat )
 {
   qWarning("setCategory %s", cat.latin1() );
   m_category.clear();
   m_category << cat;
 }
 void ToDoEvent::setPriority(int prio )
 {
     m_priority = prio;
 }
 void ToDoEvent::setDate( QDate date )
 {
     m_date = date;
 }
 bool ToDoEvent::isOverdue( )
 {
     if( m_hasDate )
 	return QDate::currentDate() > m_date;
     return false;
 }
-
+void ToDoEvent::setProgress(ushort progress )
+{
+    m_prog = progress;
+}
 /*!
   Returns a richt text string
 */
 QString ToDoEvent::richText() const
 {
   QString text;
   QStringList catlist;
 
   // Description of the todo
   if ( !description().isEmpty() ){
     text += "<b>" + QObject::tr( "Summary:") + "</b><br>";
     text += Qtopia::escapeString(summary() ).replace(QRegExp( "[\n]"),  "<br>" ) + "<br>";
     text += "<b>" + QObject::tr( "Description:" ) + "</b><br>";
-    text += Qtopia::escapeString(description() ).replace(QRegExp( "[\n]"), "<br>" ) + "<br>";
+    text += Qtopia::escapeString(description() ).replace(QRegExp( "[\n]"), "<br>" ) + "<br><br><br>";
   }
   text += "<b>" + QObject::tr( "Priority:") +" </b>"
     +  QString::number( priority() ) + "<br>";
+  text += "<b>" + QObject::tr( "Progress:") + " </b>"
+          + QString::number( progress() ) + " %<br>";
   if (hasDate() ){
     text += "<b>" + QObject::tr( "Deadline:") + " </b>";
     text += date().toString();
     text += "<br>";
   }
 
   // Open database of all categories and get the list of
   // the categories this todoevent belongs to.
   // Then print them...
   // I am not sure whether there is no better way doing this !?
   Categories catdb;
   bool firstloop = true;
   catdb.load( categoryFileName() );
   catlist = allCategories();
 
   text += "<b>" + QObject::tr( "Category:") + "</b> ";
   for ( QStringList::Iterator it = catlist.begin(); it != catlist.end(); ++it ) {
     if (!firstloop){
       text += ", ";
     }
     firstloop = false;
     text += catdb.label ("todo", (*it).toInt());
   }
   text += "<br>";
   return text;
 }
 
 bool ToDoEvent::operator<( const ToDoEvent &toDoEvent )const{
     if( !hasDate() && !toDoEvent.hasDate() ) return true;
-    if( !hasDate() && toDoEvent.hasDate() ) return true;
+    if( !hasDate() && toDoEvent.hasDate() ) return false;
     if( hasDate() && toDoEvent.hasDate() ){
 	if( date() == toDoEvent.date() ){ // let's the priority decide
 	    return priority() < toDoEvent.priority();
 	}else{
 	    return date() < toDoEvent.date();
 	}
     }
     return false;
 }
 bool ToDoEvent::operator<=(const ToDoEvent &toDoEvent )const
 {
     if( !hasDate() && !toDoEvent.hasDate() ) return true;
     if( !hasDate() && toDoEvent.hasDate() ) return true;
     if( hasDate() && toDoEvent.hasDate() ){
 	if( date() == toDoEvent.date() ){ // let's the priority decide
 	    return priority() <= toDoEvent.priority();
 	}else{
 	    return date() <= toDoEvent.date();
 	}
     }
     return true;
 }
 bool ToDoEvent::operator>(const ToDoEvent &toDoEvent )const
 {
     if( !hasDate() && !toDoEvent.hasDate() ) return false;
     if( !hasDate() && toDoEvent.hasDate() ) return false;
     if( hasDate() && toDoEvent.hasDate() ){
 	if( date() == toDoEvent.date() ){ // let's the priority decide
 	    return priority() > toDoEvent.priority();
 	}else{
 	    return date() > toDoEvent.date();
 	}
     }
     return false;
 }
 bool ToDoEvent::operator>=(const ToDoEvent &toDoEvent )const
 {
     if( !hasDate() && !toDoEvent.hasDate() ) return true;
     if( !hasDate() && toDoEvent.hasDate() ) return false;
     if( hasDate() && toDoEvent.hasDate() ){
 	if( date() == toDoEvent.date() ){ // let's the priority decide
 	    return priority() > toDoEvent.priority();
 	}else{
 	    return date() > toDoEvent.date();
 	}
     }
     return true;
 }
 bool ToDoEvent::operator==(const ToDoEvent &toDoEvent )const
 {
     if( m_priority == toDoEvent.m_priority &&
+        m_priority == toDoEvent.m_prog &&
         m_isCompleted == toDoEvent.m_isCompleted &&
         m_hasDate == toDoEvent.m_hasDate &&
         m_date == toDoEvent.m_date &&
         m_category == toDoEvent.m_category &&
         m_sum == toDoEvent.m_sum &&
         m_desc == toDoEvent.m_desc )
 	return true;
     return false;
 }
 ToDoEvent &ToDoEvent::operator=(const ToDoEvent &item )
 {
     m_date = item.m_date;
     m_isCompleted = item.m_isCompleted;
     m_hasDate = item.m_hasDate;
     m_priority = item.m_priority;
     m_category = item.m_category;
     m_desc = item.m_desc;
     m_uid = item.m_uid;
     m_sum = item.m_sum;
+    m_prog = item.m_prog;
     return *this;
 }
 
 
 
 
 
 
 
 
diff --git a/libopie/todoevent.h b/libopie/todoevent.h
index 7454241..de4623f 100644
--- a/libopie/todoevent.h
+++ b/libopie/todoevent.h
@@ -1,151 +1,162 @@
 
 #ifndef todoevent_h
 #define todoevent_h
 
 #include <qmap.h>
 #include <qregexp.h>
 #include <qstringlist.h>
 #include <qdatetime.h>
 
 class ToDoEvent {
     friend class ToDoDB;
  public:
     // priorities from Very low to very high
     enum Priority { VERYHIGH=1, HIGH, NORMAL, LOW, VERYLOW };
     /* Constructs a new ToDoEvent
        @param completed Is the TodoEvent completed
        @param priority What is the priority of this ToDoEvent
        @param category Which category does it belong( uid )
        @param summary A small summary of the todo
        @param description What is this ToDoEvent about
        @param hasDate Does this Event got a deadline
        @param date what is the deadline?
        @param uid what is the UUID of this Event
     **/
     ToDoEvent( bool completed = false, int priority = NORMAL,
 	       const QStringList &category = QStringList(),
 	       const QString &summary = QString::null ,
                const QString &description = QString::null,
+               ushort progress = 0,
 	       bool hasDate = false, QDate date = QDate::currentDate(), int uid = -1 );
     /* Copy c'tor
 
     **/
     ToDoEvent(const ToDoEvent & );
 
     /*
        Is this event completed?
     **/
     bool isCompleted() const;
 
     /*
        Does this Event have a deadline
     **/
     bool hasDate() const;
 
     /*
       What is the priority?
     **/
     int priority()const ;
 
+    /**
+     * progress as ushort 0, 20, 40, 60, 80 or 100%
+     */
+    ushort progress() const;
     /*
       All category numbers as QString in a List
     **/
     QStringList allCategories()const;
 
     /*
       * Same as above but with QArray<int>
       */
     QArray<int> categories() const;
 
     /**
      * The end Date
      */
     QDate date()const;
 
     /**
      * The description of the todo
      */
     QString description()const;
 
     /**
      * A small summary of the todo
      */
     QString summary() const;
 
     /**
      * Return this todoevent in a RichText formatted QString
      */
     QString richText() const;
 
     /**
      * Returns the UID of the Todo
      */
     int uid()const { return m_uid;};
 
 
     QString extra(const  QString& )const;
     /**
      * Set if this Todo is completed
      */
     void setCompleted(bool completed );
 
     /**
      * set if this todo got an end data
      */
     void setHasDate( bool hasDate );
     // if the category doesn't exist we will create it
     // this sets the the Category after this call category will be the only category
     void setCategory( const QString &category );
     // adds a category to the Categories of this event
     void insertCategory(const QString &category );
 
     /**
      * Removes this event from all categories
      */
     void clearCategories();
 
     /**
      * This todo belongs to xxx categories
      */
     void setCategories(const QStringList& );
 
     /**
      * Set the priority of the Todo
      */
     void setPriority(int priority );
 
     /**
+     * Set the progress.
+     */
+    void setProgress( ushort progress );
+
+    /**
      * set the end date
      */
     void setDate( QDate date );
     void setDescription(const QString& );
     void setSummary(const QString& );
     void setExtra( const QString&,  const QString& );
     bool isOverdue();
 
     bool match( const QRegExp &r )const;
 
     void setUid(int id) {m_uid = id; };
     bool operator<(const ToDoEvent &toDoEvent )const;
     bool operator<=(const ToDoEvent &toDoEvent )const;
     bool operator!=(const ToDoEvent &toDoEvent )const { return !(*this == toDoEvent); };
     bool operator>(const ToDoEvent &toDoEvent )const;
     bool operator>=(const ToDoEvent &toDoEvent)const;
     bool operator==(const ToDoEvent &toDoEvent )const;
     ToDoEvent &operator=(const ToDoEvent &toDoEvent );
  private:
     class ToDoEventPrivate;
     ToDoEventPrivate *d;
     QDate m_date;
     bool m_isCompleted:1;
     bool m_hasDate:1;
     int m_priority;
     QStringList m_category;
     QString m_desc;
     QString m_sum;
     QMap<QString, QString> m_extra;
     int m_uid;
+    ushort m_prog;
 };
 
 
 #endif