Servers/ServerManager/vtkSMProxy.h

Go to the documentation of this file.

/*=========================================================================

  Program:   ParaView
  Module:    $RCSfile: vtkSMProxy.h,v $

  Copyright (c) Kitware, Inc.
  All rights reserved.
  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef __vtkSMProxy_h
#define __vtkSMProxy_h

#include "vtkSMObject.h"
#include "vtkClientServerID.h" // needed for vtkClientServerID

//BTX
struct vtkSMProxyInternals;
//ETX
class vtkPVXMLElement;
class vtkSMProperty;
class vtkSMPropertyIterator;
class vtkSMProxyManager;

class VTK_EXPORT vtkSMProxy : public vtkSMObject
{
public:
  static vtkSMProxy* New();
  vtkTypeRevisionMacro(vtkSMProxy, vtkSMObject);
  void PrintSelf(ostream& os, vtkIndent indent);


  vtkSetStringMacro(Name);
  vtkGetStringMacro(Name);

  void AddProperty(const char* name, vtkSMProperty* prop);


  vtkSMProperty* GetProperty(const char* name) 
    {
      return this->GetProperty(name, 0);
    }

  virtual void UpdateVTKObjects();

  virtual void UpdateSelfAndAllInputs();


  vtkGetStringMacro(VTKClassName);


  vtkSetStringMacro(VTKClassName);

  virtual void UnRegister(vtkObjectBase* obj);

  vtkClientServerID GetID(unsigned int idx);

  vtkClientServerID GetSelfID() { return this->SelfID; }

  unsigned int GetNumberOfIDs();

  vtkSMPropertyIterator* NewPropertyIterator();

  unsigned int GetNumberOfConsumers();

  vtkSMProxy* GetConsumerProxy(unsigned int idx);

  vtkSMProperty* GetConsumerProperty(unsigned int idx);


  vtkGetStringMacro(XMLName);


  vtkGetStringMacro(XMLGroup);

  virtual void UpdateInformation();

  virtual void UpdatePropertyInformation(vtkSMProperty* prop);

  virtual void MarkAllPropertiesAsModified();
  
//BTX
  void SetServers(vtkTypeUInt32 servers);
 
  vtkTypeUInt32 GetServers();


  enum
    {
    COPY_PROXY_PROPERTY_VALUES_BY_REFERENCE=0,
    COPY_PROXY_PROPERTY_VALUES_BY_CLONING
    };
//ETX


  void Copy(vtkSMProxy* src);
  void Copy(vtkSMProxy* src, const char* exceptionClass);
  virtual void Copy(vtkSMProxy* src, const char* exceptionClass, 
    int proxyPropertyCopyFlag);
  
  virtual void MarkConsumersAsModified();

protected:
  vtkSMProxy();
  ~vtkSMProxy();

  vtkSMProperty* GetExposedProperty(const char* name);

  void ExposeProperty(const char* name);

//BTX
  // These classes have been declared as friends to minimize the
  // public interface exposed by vtkSMProxy. Each of these classes
  // use a small subset of protected methods. This should be kept
  // as such.
  friend class vtkSMProperty;
  friend class vtkSMProxyManager;
  friend class vtkSMInputProperty;
  friend class vtkSMProxyProperty;
  friend class vtkSMPropertyIterator;
  friend class vtkSMProxyObserver;
  friend class vtkSMSourceProxy;
//ETX


  vtkSetStringMacro(XMLName);


  vtkSetStringMacro(XMLGroup);

  virtual void CreateVTKObjects(int numObjects);

  void UnRegisterVTKObjects();

  // IDs are used to access server objects using the stream-based wrappers.
  // The following methods manage the IDs of objects maintained by the proxy.
  // Note that the IDs are assigned by the proxy at creation time. They
  // can not be set.

  virtual void SetID(unsigned int idx, vtkClientServerID id);

  // Server IDs determine on which server(s) the VTK objects are
  // instantiated. Use the following methods to set/get the server
  // IDs. Server IDs have to be set before the object is created.
  // Changing them after creation has no effect.
  // See vtkProcessModule.h for a list of all server types.
  // To add a server, OR it's value with the servers ivar.


  void SetServersSelf(vtkTypeUInt32 servers);

//BTX
  // This is a convenience method that pushes the value of one property
  // to one server alone. This is most commonly used by sub-classes
  // to make calls on the server manager through the stream interface.
  // This method does not change the modified flag of the property.
  // If possible, use UpdateVTKObjects() instead of this.
  void PushProperty(const char* name, 
                    vtkClientServerID id, 
                    vtkTypeUInt32 servers);
//ETX

  // Note on property modified flags:
  // The modified flag of each property associated with a proxy is
  // stored in the proxy object instead of in the property itself.
  // Here is a brief explanation of how modified flags are used:
  // 1. When a property is modified, the modified flag is set
  // 2. In UpdateVTKObjects(), the proxy visits all properties and
  //    calls AppendCommandToStream() on each modified property.
  //    It also resets the modified flag.
  // The reason why the modified flag is stored in the proxy instead
  // of property is in item 2 above. If multiple proxies were sharing the same
  // property, the first one would reset the modified flag in
  // UpdateVTKObjects() and then others would not call AppendCommandToStream()
  // in their turn. Therefore, each proxy has to keep track of all
  // properties it updated.
  // This is done by adding observers to the properties. When a property
  // is modified, it invokes all observers and the observers set the
  // appropriate flags in the proxies. 


  void RemoveAllObservers();

  void SetPropertyModifiedFlag(const char* name, int flag);


  void AddProperty(const char* subProxyName,
                   const char* name, 
                   vtkSMProperty* prop);

  void RemoveProperty(const char* name);

  void AddPropertyToSelf(const char* name, vtkSMProperty* prop);

  void AddSubProxy(const char* name, vtkSMProxy* proxy);

  void RemoveSubProxy(const char* name);

  vtkSMProxy* GetSubProxy(const char* name);

  void AddConsumer(vtkSMProperty* property, vtkSMProxy* proxy);

  void RemoveConsumer(vtkSMProperty* property, vtkSMProxy* proxy);

  void RemoveAllConsumers();


  vtkSMProperty* NewProperty(const char* name);
  vtkSMProperty* NewProperty(const char* name, vtkPVXMLElement* propElement);

  virtual vtkSMProperty* GetProperty(const char* name, int selfOnly);

  virtual int ReadXMLAttributes(vtkSMProxyManager* pm, vtkPVXMLElement* element);

  int CreateSubProxiesAndProperties(vtkSMProxyManager* pm, 
    vtkPVXMLElement *element);

  char* Name;
  char* VTKClassName;
  char* XMLGroup;
  char* XMLName;
  int ObjectsCreated;
  vtkTypeUInt32 Servers;
  int DoNotModifyProperty;

  // Avoids calls to UpdateVTKObjects in UpdateVTKObjects.
  // UpdateVTKObjects call it self recursively until no
  // properties are modified.
  int InUpdateVTKObjects;

  // Flag used to help speed up UpdateVTKObjects and ArePropertiesModified
  // calls.
  int SelfPropertiesModified;
  // Indicates if any properties are modified.
  int ArePropertiesModified(int selfOnly = 0);

  vtkClientServerID SelfID;

  void SetXMLElement(vtkPVXMLElement* element);
  vtkPVXMLElement* XMLElement;

  // the name is the name with which the proxy was registered with pxm.
  // However, the proxy, uses SelfID to create a name for itself while 
  // saving the state.
  virtual void SaveState(const char* name, ostream* file, vtkIndent indent);

  void SetupSharedProperties(vtkSMProxy* subproxy, vtkPVXMLElement *element);
  void SetupExposedProperties(vtkSMProxy* subproxy, vtkPVXMLElement *element);
  

  int CreateProxyHierarchy(vtkSMProxyManager* pm, vtkPVXMLElement* element);

private:
  vtkSMProxyInternals* Internals;

  vtkSMProxy(const vtkSMProxy&); // Not implemented
  void operator=(const vtkSMProxy&); // Not implemented
};

#endif

---