first sketch at ODirNotification class

4 files changed, 77 insertions, 17 deletions

diff --git a/examples/opiecore/onotifydemo/onotifydemo.cpp b/examples/opiecore/onotifydemo/onotifydemo.cpp
index 0e84d80..2beda2a 100644
--- a/examples/opiecore/onotifydemo/onotifydemo.cpp
+++ b/examples/opiecore/onotifydemo/onotifydemo.cpp
@@ -1,140 +1,178 @@
 #include "onotifydemo.h"
 
 /* OPIE */
 #include <opie2/odebug.h>
 #include <opie2/oapplication.h>
 #include <opie2/ofiledialog.h>
 #include <opie2/olistview.h>
 #include <opie2/ofilenotify.h>
 using namespace Opie::Core;
 using namespace Opie::Ui;
 
 /* QT */
 #include <qcheckbox.h>
+#include <qfileinfo.h>
 #include <qvbox.h>
 #include <qhbox.h>
 #include <qhbuttongroup.h>
 #include <qvbuttongroup.h>
 #include <qmessagebox.h>
 #include <qpushbutton.h>
 
 DemoApp::DemoApp( int argc, char** argv ) : OApplication( argc, argv, "libopie2 notify demo" )
   {
 
     QVBox* vbox = new QVBox();
     setMainWidget( vbox );
 
     l = new OListView( vbox );
     l->addColumn( "Notification Path" );
     l->addColumn( "Trigger Type" );
     l->addColumn( "Trigger Mask" );
     l->setColumnAlignment( 1, AlignCenter );
     l->setColumnAlignment( 2, AlignCenter );
 
     QHBox* hbox = new QHBox( vbox );
     g2 = new QVButtonGroup( "Specify Trigger Type", hbox );
     QCheckBox* c1 = new QCheckBox( "Access", g2 );
     QCheckBox* c2 = new QCheckBox( "Modify", g2 );
     QCheckBox* c3 = new QCheckBox( "Attrib", g2 );
     QCheckBox* c4 = new QCheckBox( "CloseWrite", g2 );
     QCheckBox* c5 = new QCheckBox( "CloseNoWrite", g2 );
     QCheckBox* c6 = new QCheckBox( "MovedFrom", g2 );
     QCheckBox* c7 = new QCheckBox( "MovedTo", g2 );
     QCheckBox* c8 = new QCheckBox( "DeleteSubdir", g2 );
     QCheckBox* c9 = new QCheckBox( "DeleteFile", g2 );
     QCheckBox* c10 = new QCheckBox( "CreateSubdir", g2 );
     QCheckBox* c11 = new QCheckBox( "CreateFile", g2 );
     QCheckBox* c12 = new QCheckBox( "Unmount", g2 );
     g2->insert( c1, Access );
     g2->insert( c2, Modify );
     g2->insert( c3, Attrib );
     g2->insert( c4, CloseWrite );
     g2->insert( c5, CloseNoWrite );
     g2->insert( c6, MovedFrom );
     g2->insert( c7, MovedTo );
     g2->insert( c8, DeleteSubdir );
     g2->insert( c9, DeleteFile );
     g2->insert( c10, CreateSubdir );
     g2->insert( c11, CreateFile );
     g2->insert( c12, Unmount );
     connect( g2, SIGNAL( pressed(int) ), this, SLOT( modifierClicked(int) ) );
 
     g1 = new QVButtonGroup( "Add/Remove", hbox );
     QPushButton* plus1 = new QPushButton( "Add\n&Single", g1 );
     QPushButton* plus2 = new QPushButton( "Add\n&Multi", g1 );
     QPushButton* minus = new QPushButton( "&Remove\nIt!", g1 );
     g1->insert( plus1, 0 );
     g1->insert( plus2, 1 );
     g1->insert( minus, 2 );
     connect( plus1, SIGNAL( clicked() ), this, SLOT( addSingle() ) );
     connect( plus2, SIGNAL( clicked() ), this, SLOT( addMulti() ) );
     connect( minus, SIGNAL( clicked() ), this, SLOT( delTrigger() ) );
 
     g1->show();
     g2->show();
     l->show();
     hbox->show();
     vbox->show();
     showMainWidget( vbox );
   }
 
     void DemoApp::addTrigger( bool multi )
     {
         if ( !m )
         {
             QMessageBox::warning( 0, "Add Trigger", "<p>Can't add trigger without at least one selected trigger type</p>", "&Sorry", 0 );
             return;
         }
 
         QString filename = OFileDialog::getOpenFileName( OFileSelector::ExtendedAll );
         if ( !filename.isEmpty() )
         {
+            bool success = true;
             odebug << "Filename = " << filename << oendl;
 
             int fntype = m;
             QString modifier = QString().sprintf( " = 0x%08x", fntype );
-            new OListViewItem( l, filename, multi ? "MULTI" : "SINGLE", modifier );
-            if ( !multi )
-                OFileNotification::singleShot( filename, this, SLOT( trigger() ), (OFileNotificationType) fntype );
+
+            if ( QFileInfo( filename ).isFile() )
+            {
+                if ( !multi )
+                {
+                    success = OFileNotification::singleShot( filename, this, SLOT( unnamedTrigger() ), (OFileNotificationType) fntype );
+                }
+                else
+                {
+                    OFileNotification* fn = new OFileNotification();
+                    success = fn->watch( filename, false, (OFileNotificationType) fntype );
+                    connect( fn, SIGNAL( triggered( const QString& ) ), this, SLOT( namedTrigger( const QString& ) ) );
+                }
+            }
+            else if ( QFileInfo( filename ).isDir() )
+            {
+                ODirNotification* dn = new ODirNotification();
+                success = dn->watch( filename, !multi, (OFileNotificationType) fntype );
+                connect( dn, SIGNAL( triggered( const QString& ) ), this, SLOT( namedTrigger( const QString& ) ) );
+            }
+            else
+            {
+                odebug << "Huh!? Neither file nor directory..." << oendl;
+                return;
+            }
+
+/*            if ( !success )
+            {
+                QMessageBox::warning( 0, "Add Trigger", "<p>Couldn't add trigger :(</p>", "&Sorry", 0 );
+                return;
+            }
             else
-                odebug << "not yet implemented..." << oendl;
+*/            {
+                new OListViewItem( l, filename, multi ? "MULTI" : "SINGLE", modifier );
+            }
+            return;
         }
         else
         {
             odebug << "cancelled." << oendl;
         }
     }
 
     void DemoApp::modifierClicked( int modifier ) { m = static_cast<OFileNotificationType>( (int)m ^ int(modifier) ); };
     void DemoApp::addSingle() { addTrigger(); };
     void DemoApp::addMulti() { addTrigger( true ); };
 
     void DemoApp::delTrigger()
     {
         QListViewItem* item = l->selectedItem();
         if ( !item )
         {
             QMessageBox::warning( 0, "Del Trigger", "<p>No trigger selected!</p>", "&Sorry", 0 );
             return;
         }
         else
         {
             QString filename( item->text( 0 ) );
             odebug << "Filename = " << filename << oendl;
         }
     }
 
-    void DemoApp::trigger()
+    void DemoApp::unnamedTrigger()
+    {
+        owarn << "DemoApp::singleShotStrigger() : F I R E !!!!!" << oendl;
+    }
+
+    void DemoApp::namedTrigger( const QString& path )
     {
-        owarn << "FIRE!" << oendl;
+        owarn << "DemoApp::named trigger = " << path << " : F I R E !!!!!" << oendl;
     }
 
 int main( int argc, char** argv )
 {
     DemoApp* app = new DemoApp( argc, argv );
     app->exec();
 
     return 0;
 
 }
 
diff --git a/examples/opiecore/onotifydemo/onotifydemo.h b/examples/opiecore/onotifydemo/onotifydemo.h
index c4e3456..f6ac5ea 100644
--- a/examples/opiecore/onotifydemo/onotifydemo.h
+++ b/examples/opiecore/onotifydemo/onotifydemo.h
@@ -1,29 +1,30 @@
 /* OPIE */
 #include <opie2/olistview.h>
 #include <opie2/odebug.h>
 #include <opie2/oapplication.h>
 #include <opie2/ofilenotify.h>
 
 class QButtonGroup;
 
 class DemoApp : public Opie::Core::OApplication
 {
   Q_OBJECT
 public:
   DemoApp( int argc, char** argv );
 
 public:
     void addTrigger( bool multi = false );
 public slots:
     void modifierClicked( int modifier );
     void addSingle();
     void addMulti();
     void delTrigger();
-    void trigger();
+    void unnamedTrigger();
+    void namedTrigger( const QString& name );
 
 private:
   Opie::Ui::OListView* l;
   QButtonGroup* g1;
   QButtonGroup* g2;
   Opie::Core::OFileNotificationType m;
 };
diff --git a/libopie2/opiecore/ofilenotify.cpp b/libopie2/opiecore/ofilenotify.cpp
index efd041a..11d4f87 100644
--- a/libopie2/opiecore/ofilenotify.cpp
+++ b/libopie2/opiecore/ofilenotify.cpp
@@ -48,107 +48,107 @@ using namespace Opie::Core;
 #include <errno.h>
 #include <unistd.h>
 
 static QIntDict<OFileNotification> notification_list;
 
 QSocketNotifier* OFileNotification::_sn;
 int OFileNotification::_fd = -1;
 
 #define INOTIFY_DEVICE "/dev/inotify"
 
 namespace Opie {
 namespace Core {
 
 OFileNotification::OFileNotification( QObject* parent, const char* name )
                   :QObject( parent, name ), _active( false ), _multi( true )
 {
     qDebug( "OFileNotification::OFileNotification()" );
 }
 
 
 OFileNotification::~OFileNotification()
 {
     stop();
     qDebug( "OFileNotification::~OFileNotification()" );
 }
 
 
 bool OFileNotification::isActive() const
 {
     return _active;
 }
 
 
 int OFileNotification::watch( const QString& path, bool sshot, OFileNotificationType type )
 {
     // check if path exists and is a regular file
     struct stat s;
     if ( ::stat( (const char*) path, &s ) == -1 )
     {
         qWarning( "OFileNotification::watch(): Can't watch '%s': %s.", (const char*) path, strerror( errno ) );
         return -1;
     }
     if ( !S_ISREG( s.st_mode ) )
     {
         qWarning( "OFileNotification::watch(): Can't watch '%s': %s.", (const char*) path, "not a regular file" );
         return -1;
     }
 
-    if ( notification_list.isEmpty() )
-    {
-        OFileNotification::registerEventHandler();
-    }
-
     return startWatching( path, sshot, type );
 }
 
 
 int OFileNotification::startWatching( const QString& path, bool sshot, OFileNotificationType type )
 {
+    if ( notification_list.isEmpty() )
+    {
+        OFileNotification::registerEventHandler();
+    }
+
     struct inotify_watch_request iwr;
     ::memset( &iwr, 0, sizeof iwr );
     iwr.name = const_cast<char*>( (const char*) path );
     iwr.mask = type;
 
     _wd = ::ioctl( OFileNotification::_fd, INOTIFY_WATCH, &iwr );
 
     if ( _wd < 0 )
     {
         qWarning( "OFileNotification::watch(): inotify can't watch '%s': %s.", (const char*) path, strerror( errno ) );
         return -1;
     }
 
     notification_list.insert( _wd, this );
     _path = path;
     _multi = !sshot;
     _type = type;
     _active = true;
     qDebug( "OFileNotification::watch(): watching '%s' [wd=%d].", (const char*) path, _wd );
     return _wd;
 }
 
 
 void OFileNotification::stop()
 {
     notification_list.remove( _wd );
     _path = QString::null;
     _wd = 0;
     _active = false;
     if ( notification_list.isEmpty() )
     {
         OFileNotification::unregisterEventHandler();
     }
 }
 
 
 OFileNotificationType OFileNotification::type() const
 {
     return _type;
 }
 
 
 QString OFileNotification::path() const
 {
     return _path;
 }
 
 
@@ -210,54 +210,69 @@ void OFileNotification::inotifyEventHandler()
     return;
 }
 
 
 bool OFileNotification::registerEventHandler()
 {
     OFileNotification::_fd = ::open( INOTIFY_DEVICE, O_RDONLY );
     if ( OFileNotification::_fd < 0 )
     {
         qWarning( "OFileNotification::registerEventHandler(): couldn't register event handler: %s", strerror( errno ) );
         return false;
     }
 
     OFileNotification::_sn = new QSocketNotifier( _fd, QSocketNotifier::Read, this, "inotify event" );
     connect( OFileNotification::_sn, SIGNAL( activated(int) ), this, SLOT( inotifyEventHandler() ) );
 
     qDebug( "OFileNotification::registerEventHandler(): done" );
     return true;
 }
 
 
 void OFileNotification::unregisterEventHandler()
 {
     if ( _sn ) delete _sn;
     if ( OFileNotification::_fd )
     ::close( OFileNotification::_fd );
     qDebug( "OFileNotification::unregisterEventHandler(): done" );
 }
 
 //=================================================================================================
 // ODirNotification
 //=================================================================================================
 ODirNotification::ODirNotification( QObject* parent, const char* name )
                   :QObject( parent, name )
 {
     qDebug( "ODirNotification::ODirNotification()" );
 }
 
 
 ODirNotification::~ODirNotification()
 {
     qDebug( "ODirNotification::~ODirNotification()" );
 }
 
 
 int ODirNotification::watch( const QString& path, bool sshot, OFileNotificationType type, int recurse )
 {
     qDebug( "ODirNotification::watch( %s, %d, 0x%08x, %d )", (const char*) path, sshot, type, recurse );
-    return 0;
-}
 
+    if ( recurse == 0 )
+    {
+        OFileNotification* fn = new OFileNotification( this, "ODirNotification delegate" );
+        int result = fn->startWatching( path, sshot, type );
+        if ( result != -1 )
+        {
+            connect( fn, SIGNAL( triggered( const QString& ) ), this, SIGNAL( triggered( const QString& ) ) );
+            return result;
+        }
+    }
+    else
+    {
+        qDebug( "ODirNotification::watch(), recursion not yet implemented... :)" );
+        return -1;
+    }
 }
 
-}
\ No newline at end of file
+} // namespace Ui
+
+} // namespace Opie
diff --git a/libopie2/opiecore/ofilenotify.h b/libopie2/opiecore/ofilenotify.h
index 41ba84d..3eb917e 100644
--- a/libopie2/opiecore/ofilenotify.h
+++ b/libopie2/opiecore/ofilenotify.h
@@ -84,149 +84,155 @@ enum OFileNotificationType
     DeleteFile      =   IN_DELETE_FILE,
     CreateSubdir    =   IN_CREATE_SUBDIR,
     CreateFile      =   IN_CREATE_FILE,
     DeleteSelf      =   IN_DELETE_SELF,
     Unmount         =   IN_UNMOUNT,
     _QueueOverflow  =   IN_Q_OVERFLOW,  /* Internal, don't use this in client code */
     _Ignored        =   IN_IGNORED,     /* Internal, don't use this in client code */
 };
 
 /*======================================================================================
  * OFileNotification
  *======================================================================================*/
 
 /**
  * @brief Represents a file notification
  *
  * This class allows to watch for events happening to files.
  * It uses the inotify linux (2.6.x) kernel interface.
  *
  * @see http://www.kernel.org/pub/linux/kernel/people/rml/inotify/
  *
  * @author Michael 'Mickey' Lauer <mickey@vanille.de>
  *
  **/
 
 class OFileNotification : public QObject
 {
   Q_OBJECT
 
   public:
     OFileNotification( QObject* parent = 0, const char* name = 0 );
     ~OFileNotification();
     /**
      * This static function calls a slot when an event with @a type happens to file @a path.
      *
      *  It is very convenient to use this function because you do not need to
      *  bother with a timerEvent or to create a local QTimer object.
      *
      *  Example:
      *  <pre>
      *
      *     #include <opie2/oapplication.h>
      *     #include <opie2/ofilenotify.h>
      *     using namespace Opie::Core;
      *
      *     int main( int argc, char **argv )
      *     {
      *         OApplication a( argc, argv, "File Notification Example" );
-     *         OFileNotification::singleShot( "/tmp/quit", &a, SLOT(quit()), Create );
+     *         OFileNotification::singleShot( "/tmp/quit", &a, SLOT(quit()), Access );
      *         ... // create and show your widgets
      *         return a.exec();
      *     }
      *  </pre>
      *
-     * This sample program automatically terminates when the file "/tmp/quit" has been created.
+     * This sample program automatically terminates when the file "/tmp/quit" has been accessed.
      *
      *
      * The @a receiver is the receiving object and the @a member is the slot.
      **/
     static bool singleShot( const QString& path, QObject* receiver, const char* member, OFileNotificationType type = Modify );
     /**
      * Starts to watch for @a type changes to @a path. Set @a sshot to True if you want to be notified only once.
      * Note that in that case it may be more convenient to use @ref OFileNotification::singleShot() then.
      **/
     int watch( const QString& path, bool sshot = false, OFileNotificationType type = Modify );
     /**
      * Stop watching for file events.
      **/
     void stop();
     /**
      * @returns the notification type as set by @ref start().
      **/
     OFileNotificationType type() const;
     /**
      * @returns the path to the file being watched by this instance.
      **/
     QString path() const;
     /**
      * @returns if a file is currently being watched.
      **/
     bool isActive() const;
     /**
       * @internal
       */
     int startWatching( const QString& path, bool sshot = false, OFileNotificationType type = Modify );
 
   signals:
     /**
      * This signal is emitted if an event happens of the specified type happens to the file being watched.
      **/
     void triggered( const QString& name );
 
   protected:
     bool activate();
 
   private slots:
     void inotifyEventHandler();
 
   private:
     bool registerEventHandler();
     void unregisterEventHandler();
 
     QString _path;
     OFileNotificationType _type;
     QSignal _signal;
     bool _active;
     bool _multi;
     static QSocketNotifier* _sn;
     int _wd; // inotify watch descriptor
     static int _fd; // inotify device descriptor
 };
 
 /*======================================================================================
  * ODirNotification
  *======================================================================================*/
 
 /**
  * @brief Represents a directory notification
  *
  * This class allows to watch for events happening to directories
  * It uses the OFileNotification class
  *
  * @see http://www.kernel.org/pub/linux/kernel/people/rml/inotify/
  *
  * @author Michael 'Mickey' Lauer <mickey@vanille.de>
  *
  **/
 
 class ODirNotification : public QObject
 {
   Q_OBJECT
 
   public:
     ODirNotification( QObject* parent = 0, const char* name = 0 );
     ~ODirNotification();
     /**
      * Starts to watch for @a type changes to @a path. Recurse @a recurse levels down the filesystem tree,
      * use 0 for no recursion and -1 for unlimited recursion.
      * Set @a sshot to True if you want to be notified only once.
      **/
     int watch( const QString& path, bool sshot = false, OFileNotificationType type = Modify, int recurse = 0 );
+
+  signals:
+    /**
+     * This signal is emitted if an event happens of the specified type happens to the directory being watched.
+     **/
+    void triggered( const QString& name );
 };
 
 
 }
 }
 
 #endif