Change return type of ctkVTKObjectEventsObserver methods

The block*Connection* methods now return the previous state of blocking

Libs/Visualization/VTK/Core/ctkVTKObject.h

@@ -87,24 +87,31 @@ void qvtkBlock(const QString& id, bool blocked)                          \
 
 //-----------------------------------------------------------------------------
 #define QVTK_OBJECT_BLOCKALL_CONNECTION_METHOD                          \
-void qvtkBlockAll()                                                     \
+bool qvtkBlockAll()                                                     \
 {                                                                       \
-  MyQVTK.blockAllConnections(true);                                     \
+  return MyQVTK.blockAllConnections(true);                              \
 }
 
 //-----------------------------------------------------------------------------
-#define QVTK_OBJECT_UNBLOCK_CONNECTION_METHOD                             \
-void qvtkUnblock(vtkObject* vtk_obj, unsigned long vtk_event,             \
-  const QObject* qt_obj)                                                  \
-{                                                                         \
-  MyQVTK.blockConnection(false, vtk_obj, vtk_event, qt_obj);              \
+#define QVTK_OBJECT_BLOCKALL_CONNECTION_METHOD2                         \
+bool qvtkBlockAll(bool block)                                           \
+{                                                                       \
+  return MyQVTK.blockAllConnections(block);                             \
+}
+
+//-----------------------------------------------------------------------------
+#define QVTK_OBJECT_UNBLOCK_CONNECTION_METHOD                           \
+void qvtkUnblock(vtkObject* vtk_obj, unsigned long vtk_event,           \
+  const QObject* qt_obj)                                                \
+{                                                                       \
+  MyQVTK.blockConnection(false, vtk_obj, vtk_event, qt_obj);            \
 }
 
 //-----------------------------------------------------------------------------
 #define QVTK_OBJECT_UNBLOCKALL_CONNECTION_METHOD                        \
-void qvtkUnblockAll()                                                   \
+bool qvtkUnblockAll()                                                   \
 {                                                                       \
-  MyQVTK.blockAllConnections(false);                                    \
+  return MyQVTK.blockAllConnections(false);                             \
 }
 
 //-----------------------------------------------------------------------------
@@ -119,6 +126,7 @@ protected:                                         \
   QVTK_OBJECT_BLOCK_CONNECTION_METHOD2             \
   QVTK_OBJECT_UNBLOCK_CONNECTION_METHOD            \
   QVTK_OBJECT_BLOCKALL_CONNECTION_METHOD           \
+  QVTK_OBJECT_BLOCKALL_CONNECTION_METHOD2          \
   QVTK_OBJECT_UNBLOCKALL_CONNECTION_METHOD         \
 private:                                           \
   ctkVTKObjectEventsObserver MyQVTK;

Libs/Visualization/VTK/Core/ctkVTKObjectEventsObserver.cpp

@@ -42,31 +42,31 @@ protected:
 public:
   ctkVTKObjectEventsObserverPrivate(ctkVTKObjectEventsObserver& object);
 
-  /// 
+  ///
   /// Check if a connection has already been added
   bool containsConnection(vtkObject* vtk_obj, unsigned long vtk_event,
     const QObject* qt_obj, const char* qt_slot);
 
-  /// 
+  ///
   /// Return a reference toward the corresponding connection or 0 if doesn't exist
   ctkVTKConnection* findConnection(const QString& id);
 
-  /// 
+  ///
   /// Return a reference toward the corresponding connection or 0 if doesn't exist
   ctkVTKConnection* findConnection(vtkObject* vtk_obj, unsigned long vtk_event,
     const QObject* qt_obj, const char* qt_slot);
 
-  /// 
+  ///
   /// Return all the references that match the given parameters
   QList<ctkVTKConnection*> findConnections(vtkObject* vtk_obj, unsigned long vtk_event,
     const QObject* qt_obj, const char* qt_slot);
-  
+
   inline QList<ctkVTKConnection*> connections()const
   {
     Q_Q(const ctkVTKObjectEventsObserver);
     return q->findChildren<ctkVTKConnection*>();
   }
-  
+
   bool AllBlocked;
   bool ObserveDeletion;
 };
@@ -125,21 +125,21 @@ QString ctkVTKObjectEventsObserver::addConnection(vtkObject* old_vtk_obj, vtkObj
     {
     connectionId = this->addConnection(vtk_obj, vtk_event, qt_obj, qt_slot, priority);
     }
-  return connectionId; 
+  return connectionId;
 }
 
 //-----------------------------------------------------------------------------
 QString ctkVTKObjectEventsObserver::reconnection(vtkObject* vtk_obj,
-  unsigned long vtk_event, const QObject* qt_obj, 
+  unsigned long vtk_event, const QObject* qt_obj,
   const char* qt_slot, float priority)
 {
-  QString connectionId; 
+  QString connectionId;
   this->removeConnection(0, vtk_event, qt_obj, qt_slot);
   if (vtk_obj)
     {
     connectionId = this->addConnection(vtk_obj, vtk_event, qt_obj, qt_slot, priority);
     }
-  return connectionId; 
+  return connectionId;
 }
 
 //-----------------------------------------------------------------------------
@@ -177,29 +177,45 @@ QString ctkVTKObjectEventsObserver::addConnection(vtkObject* vtk_obj, unsigned l
 }
 
 //-----------------------------------------------------------------------------
-void ctkVTKObjectEventsObserver::blockAllConnections(bool block)
+bool ctkVTKObjectEventsObserver::blockAllConnections(bool block)
 {
   Q_D(ctkVTKObjectEventsObserver);
-  this->printAdditionalInfo();
-  if (d->AllBlocked == block) { return; }
+
+  if (d->AllBlocked == block)
+    {
+    return d->AllBlocked;
+    }
+
+  bool oldAllBlocked = d->AllBlocked;
 
   foreach (ctkVTKConnection* connection, d->connections())
     {
     connection->setBlocked(block);
     }
   d->AllBlocked = block;
+  return oldAllBlocked;
+}
+
+//-----------------------------------------------------------------------------
+bool ctkVTKObjectEventsObserver::connectionsBlocked()const
+{
+  Q_D(const ctkVTKObjectEventsObserver);
+  return d->AllBlocked;
 }
 
 //-----------------------------------------------------------------------------
-void ctkVTKObjectEventsObserver::blockConnection(const QString& id, bool blocked)
+bool ctkVTKObjectEventsObserver::blockConnection(const QString& id, bool blocked)
 {
   Q_D(ctkVTKObjectEventsObserver);
   ctkVTKConnection* connection = d->findConnection(id);
   if (connection == 0)
     {
-    return;
+    qWarning() << "no connection for id " << id;
+    return false;
     }
+  bool oldBlocked = connection->isBlocked();
   connection->setBlocked(blocked);
+  return oldBlocked;
 }
 
 //-----------------------------------------------------------------------------
@@ -231,7 +247,7 @@ int ctkVTKObjectEventsObserver::removeConnection(vtkObject* vtk_obj, unsigned lo
 
   QList<ctkVTKConnection*> connections =
     d->findConnections(vtk_obj, vtk_event, qt_obj, qt_slot);
-  
+
   foreach (ctkVTKConnection* connection, connections)
     {
     delete connection;
@@ -300,9 +316,9 @@ ctkVTKObjectEventsObserverPrivate::findConnections(
   // Loop through all connection
   foreach (ctkVTKConnection* connection, this->connections())
     {
-    if (connection->isEqual(vtk_obj, vtk_event, qt_obj, qt_slot)) 
+    if (connection->isEqual(vtk_obj, vtk_event, qt_obj, qt_slot))
       {
-      foundConnections.append(connection); 
+      foundConnections.append(connection);
       if (all_info)
         {
         break;

Libs/Visualization/VTK/Core/ctkVTKObjectEventsObserver.h

@@ -49,7 +49,7 @@ public:
 
   virtual void printAdditionalInfo();
 
-  /// 
+  ///
   /// Add a connection, an Id allowing to uniquely identify the connection is also returned
   /// Warning the slot must have its signature order:
   /// vtkObject*, vtkObject* : sender, callData
@@ -82,27 +82,37 @@ public:
   /// Of course the slot can contain less parameters, but always the same order
   /// though.
   QString reconnection(vtkObject* vtk_obj, unsigned long vtk_event,
-                       const QObject* qt_obj, const char* qt_slot, 
+                       const QObject* qt_obj, const char* qt_slot,
                        float priority = 0.0);
 
-  /// 
+  ///
   /// Remove a connection
   int removeConnection(vtkObject* vtk_obj, unsigned long vtk_event = vtkCommand::NoEvent,
                        const QObject* qt_obj = 0, const char* qt_slot = 0);
 
-  /// 
+  ///
   /// Remove all the connections
   inline int removeAllConnections();
 
   ///
   /// Temporarilly block all the connection
-  void blockAllConnections(bool block);
-  
-  /// 
-  /// Block/Unblock a connection.
+  /// Returns the previous value of connectionsBlocked()
+  bool blockAllConnections(bool block);
+
+  ///
+  /// Returns true if connections are blocked; otherwise returns false.
+  /// Connections are not blocked by default.
+  bool connectionsBlocked()const;
+
+  ///
+  /// Block/Unblock one or multiple connection.
+  /// Return the number of connections blocked/unblocked
   int blockConnection(bool block, vtkObject* vtk_obj,
                       unsigned long vtk_event, const QObject* qt_obj);
-  void blockConnection(const QString& id, bool blocked);
+  /// Block/Unblock a connection
+  /// Return true if the connection exists and was blocked, otherwise returns
+  /// false.
+  bool blockConnection(const QString& id, bool blocked);
 
 protected:
   QScopedPointer<ctkVTKObjectEventsObserverPrivate> d_ptr;
@@ -116,7 +126,7 @@ private:
 //-----------------------------------------------------------------------------
 int ctkVTKObjectEventsObserver::removeAllConnections()
 {
-  return this->removeConnection(0);
+  return this->removeConnection(0, vtkCommand::NoEvent, 0, 0);
 }
 
 #endif