| -rw-r--r-- | libopie2/opiecore/oapplicationfactory.h | 2 | ||||
| -rw-r--r-- | libopie2/opiecore/oprocess.h | 4 |
2 files changed, 3 insertions, 3 deletions
diff --git a/libopie2/opiecore/oapplicationfactory.h b/libopie2/opiecore/oapplicationfactory.h index cabaf79..8516565 100644 --- a/libopie2/opiecore/oapplicationfactory.h +++ b/libopie2/opiecore/oapplicationfactory.h @@ -1,335 +1,335 @@ /* This file is part of the Opie Project Copyright (C) Holger Freyther <zecke@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. */ /* This work is derived from: ---- The Loki Library Copyright (c) 2001 by Andrei Alexandrescu This code accompanies the book: Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design Patterns Applied". Copyright (c) 2001. Addison-Wesley. Permission to use, copy, modify, distribute and sell this software for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The author or Addison-Welsey Longman make no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. ---- And KGenericFactor et all from Simon Hausmann <tronical@kde.org> */ #include <qstring.h> #include <qmetaobject.h> #include <qtopia/qcom.h> #include <qtopia/applicationinterface.h> namespace Opie { namespace Core { struct NullType; template <class T, class U> struct Typelist { typedef T Head; typedef U Tail; }; template< typename T1 = NullType, typename T2 = NullType, typename T3 = NullType, typename T4 = NullType, typename T5 = NullType, typename T6 = NullType, typename T7 = NullType, typename T8 = NullType, typename T9 = NullType, typename T10 = NullType, typename T11 = NullType, typename T12 = NullType, typename T13 = NullType, typename T14 = NullType, typename T15 = NullType, typename T16 = NullType, typename T17 = NullType, typename T18 = NullType > struct MakeTypelist{ private: typedef typename MakeTypelist < T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10, T11, T12, T13, T14, T15, T16, T17, T18 > ::Result TailResult; public: typedef Typelist<T1, TailResult> Result; }; template<> struct MakeTypelist<> { typedef NullType Result; }; /** * To allow your application to be quick launched some one needs * to create the QWidget. * This is this factory. Make surce your widget has static QString Widget::appName() * as one of its functions. * * This template takes one QWidget and initialized it in the form of * MyWidget::MyWidget( QWidget* parent, const char* name, WFlags f ); * * To use it on your app do that: * typedef OApplicationFactory<MyWidget> MyFactory; * OPIE_EXPORT_APP( MyFactory ) * */ template <class Product> struct OApplicationFactory : public ApplicationInterface { QRESULT queryInterface( const QUuid &uuid, QUnknownInterface **iface ) { *iface = 0; if ( uuid == IID_QUnknown ) *iface = this; else if ( uuid == IID_QtopiaApplication ) *iface = this; else return QS_FALSE; (*iface)->addRef(); return QS_OK; } /* * */ virtual QWidget *createMainWindow( const QString& appName, QWidget* parent, const char* name, Qt::WFlags f ) { if (appName == Product::appName() ) return new Product(parent, name, f ); else return 0l; } virtual QStringList applications()const { QStringList list; list << Product::appName() ; return list; } Q_REFCOUNT }; /* Internal */ template< class Product > struct OPrivate { inline static QWidget *multiFactory( const QString& appName, QWidget* parent, const char* name, Qt::WFlags fl ) { if ( appName == Product::appName() ) return new Product( parent, name, fl ); else return 0; } inline static QStringList multiString( const QStringList& _list ) { QStringList list = _list; list << Product::appName(); return list; } }; template <> struct OPrivate<Opie::Core::NullType > { inline static QWidget* multiFactory ( const QString& , QWidget* , const char* , Qt::WFlags ) { return 0l; } inline static QStringList multiString( const QStringList& _list ) { return _list; } }; /* template <> struct OPrivate <Opie::NullType, Opie::NullType > { inline static QWidget* multiFactory( const QString& , QWidget* , const char* , Qt::WFlags ) { return 0l; } inline static QStringList multiString( const QStringList& _list ) { return _list; } }; */ template <class Product, class ProductListTail> struct OPrivate< Opie::Core::Typelist<Product, ProductListTail> > { inline static QWidget* multiFactory( const QString& appName, QWidget* parent, const char* name, Qt::WFlags fl) { QWidget* wid = OPrivate<Product>::multiFactory( appName, parent, name, fl ); if (!wid ) wid = OPrivate<ProductListTail>::multiFactory( appName, parent, name, fl ); return wid; } inline static QStringList multiString( const QStringList& _list ) { QStringList list = _list; list = OPrivate<Product>::multiString( list ); list = OPrivate<ProductListTail>::multiString( list ); return list; } }; /* Internal END */ /* * If you want to export more than one Widget use that function * Make sure all your Widgets provide the appName() static method * otherwise you'll get a compiler error * - * typedef Opie::MakeTypeList<MyWidget, MyDialog, MyMediaPlayer >::Result MyTypes; + * typedef Opie::Core::MakeTypelist<MyWidget, MyDialog, MyMediaPlayer >::Result MyTypes; * OPIE_EXPORT_APP( OApplicationFactory<MyTypes> ) */ template<class Product, class ProductListTail> struct OApplicationFactory< Opie::Core::Typelist<Product, ProductListTail > > : ApplicationInterface { QRESULT queryInterface( const QUuid &uuid, QUnknownInterface **iface ) { *iface = 0; if ( uuid == IID_QUnknown ) *iface = this; else if ( uuid ==IID_QtopiaApplication ) *iface = this; else return QS_FALSE; (*iface)->addRef(); return QS_OK; } QWidget* createMainWindow ( const QString& appName, QWidget* parent, const char* name, Qt::WFlags fl ) { qWarning("StringList is %s", applications().join(":").latin1() ); return OPrivate< Opie::Core::Typelist<Product, ProductListTail > >::multiFactory( appName, parent, name, fl ); } QStringList applications()const { QStringList _list; return OPrivate< Opie::Core::Typelist<Product, ProductListTail> >::multiString( _list ); } Q_REFCOUNT }; } } /* If the library version should be build */ #ifdef OPIE_APP_INTERFACE #define OPIE_EXPORT_APP( factory ) Q_EXPORT_INTERFACE() { Q_CREATE_INSTANCE( factory ) } #else #include <qpe/qpeapplication.h> #define OPIE_EXPORT_APP( Factory ) \ int main( int argc, char **argv ) { \ QPEApplication a(argc, argv ); \ QWidget *mw = 0;\ \ /* method from TT */ \ QString executableName = QString::fromLatin1( argv[0] ); \ executableName = executableName.right(executableName.length() \ - executableName.findRev('/') - 1); \ \ Factory f; \ QStringList list = f.applications(); \ if (list.contains(executableName) ) \ mw = f.createMainWindow(executableName, 0, 0, 0 ); \ else \ mw = f.createMainWindow( list[0], 0, 0, 0 ); \ \ if( mw ) { \ if ( mw->metaObject()->slotNames().contains("setDocument(const QString&)" ) ) \ a.showMainDocumentWidget( mw ); \ else \ a.showMainWidget( mw ); \ \ int rv = a.exec(); \ delete mw; \ return rv; \ }else \ return -1; \ } #endif #ifdef OPIE_APP_INTERFACE #define OPIE_EXPORT_APP_V2( factory,name ) Q_EXPORT_INTERFACE() { Q_CREATE_INSTANCE( factory ) } #else #include <opie2/oapplication.h> #define OPIE_EXPORT_APP_V2( Factory,name ) \ int main( int argc, char **argv ) { \ Opie::Core::OApplication a(argc, argv, name ); \ QWidget *mw = 0;\ \ /* method from TT */ \ QString executableName = QString::fromLatin1( argv[0] ); \ executableName = executableName.right(executableName.length() \ - executableName.findRev('/') - 1); \ \ Factory f; \ QStringList list = f.applications(); \ if (list.contains(executableName) ) \ mw = f.createMainWindow(executableName, 0, 0, 0 ); \ else \ mw = f.createMainWindow( list[0], 0, 0, 0 ); \ \ if( mw ) { \ if ( mw->metaObject()->slotNames().contains("setDocument(const QString&)" ) ) \ a.showMainDocumentWidget( mw ); \ else \ a.showMainWidget( mw ); \ \ int rv = a.exec(); \ delete mw; \ return rv; \ }else \ return -1; \ } #endif #define OPIE_EXPORT_APPNAME static QString appName() { return QString::fromLatin1( QUICKAPP_NAME ); } diff --git a/libopie2/opiecore/oprocess.h b/libopie2/opiecore/oprocess.h index ac6be98..23e9b10 100644 --- a/libopie2/opiecore/oprocess.h +++ b/libopie2/opiecore/oprocess.h @@ -1,361 +1,361 @@ /* 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 Internal { class OProcessController; class OProcessPrivate; } /** * Child process invocation, monitoring and control. * * @par General usage and features * *This class allows a KDE and OPIE application to start child processes without having *to worry about UN*X signal handling issues and zombie process reaping. * *@see KProcIO * *Basically, this class distinguishes three different ways of running *child processes: * *@li OProcess::DontCare -- The child process is invoked and both the child *process and the parent process continue concurrently. * *Starting a DontCare child process means that the application is *not interested in any notification to determine whether the *child process has already exited or not. * *@li OProcess::NotifyOnExit -- The child process is invoked and both the *child and the parent process run concurrently. * *When the child process exits, the OProcess instance *corresponding to it emits the Qt signal @ref processExited(). * *Since this signal is @em not emitted from within a UN*X *signal handler, arbitrary function calls can be made. * *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(Opie::Core::OProcess *)), - * pointer_to_my_object, SLOT(my_objects_slot(Opie::Core::OProcess *))); + *QObject::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. * *@par Communication with the child process * *OProcess supports communication with the child process through *stdin/stdout/stderr. * *The following functions are provided for getting data from the child *process or sending data to the child's stdin (For more information, *have a look at the documentation of each function): * *@li bool @ref writeStdin(char *buffer, int buflen); *@li -- Transmit data to the child process's stdin. * *@li bool @ref closeStdin(); *@li -- Closes the child process's stdin (which causes it to see an feof(stdin)). *Returns false if you try to close stdin for a process that has been started *without a communication channel to stdin. * *@li bool @ref closeStdout(); *@li -- Closes the child process's stdout. *Returns false if you try to close stdout for a process that has been started *without a communication channel to stdout. * *@li bool @ref closeStderr(); *@li -- Closes the child process's stderr. *Returns false if you try to close stderr for a process that has been started *without a communication channel to stderr. * * *@par QT signals: * *@li void @ref receivedStdout(OProcess *proc, char *buffer, int buflen); *@li void @ref receivedStderr(OProcess *proc, char *buffer, int buflen); *@li -- Indicates that new data has arrived from either the *child process's stdout or stderr. * *@li void @ref wroteStdin(OProcess *proc); *@li -- Indicates that all data that has been sent to the child process *by a prior call to @ref writeStdin() has actually been transmitted to the *client . * *@author Christian Czezakte e9025461@student.tuwien.ac.at *@author Holger Freyther (Opie Port) * **/ class OProcess : public QObject { Q_OBJECT public: /** * Modes in which the communication channel can be opened. * * 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 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; /** * 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, |