Overview     Modules     Class Hierarchy     Classes     Members  

Plugins

The Tulip plug-in system allows plug-ins to be loaded dynamically at run-time, and can check dependencies on other plug-ins, as well as multiple definitions. More...

Classes

Defines

  • #define PROPERTYPLUGINFACTORY(T, C, N, A, D, I, R, G)
    Macro for factorization of source code pf Properties plugin mechanism.
  • #define BOOLEANPLUGINOFGROUP(C, N, A, D, I, R, G)   PROPERTYPLUGINFACTORY(Boolean,C,N,A,D,I,R,G)
  • #define BOOLEANPLUGIN(C, N, A, D, I, R)   BOOLEANPLUGINOFGROUP(C,N,A,D,I,R,"")
  • #define COLORPLUGINOFGROUP(C, N, A, D, I, R, G)   PROPERTYPLUGINFACTORY(Color,C,N,A,D,I,R,G)
  • #define COLORPLUGIN(C, N, A, D, I, R)   COLORPLUGINOFGROUP(C,N,A,D,I,R,"")
  • #define DOUBLEPLUGINOFGROUP(C, N, A, D, I, R, G)   PROPERTYPLUGINFACTORY(Double,C,N,A,D,I,R,G)
  • #define DOUBLEPLUGIN(C, N, A, D, I, R)   DOUBLEPLUGINOFGROUP(C,N,A,D,I,R,"")
  • #define GRAPHPLUGINOFGROUP(C, N, A, D, I, R, G)   PROPERTYPLUGINFACTORY(Graph,C,N,A,D,I,R,G)
  • #define GRAPHPLUGIN(C, N, A, D, I, R)   GRAPHPLUGINOFGROUP(C,N,A,D,I,R,"")
  • #define INTEGERPLUGINOFGROUP(C, N, A, D, I, R, G)   PROPERTYPLUGINFACTORY(Integer,C,N,A,D,I,R,G)
  • #define INTEGERPLUGIN(C, N, A, D, I, R)   INTEGERPLUGINOFGROUP(C,N,A,D,I,R,"")
  • #define LAYOUTPLUGINOFGROUP(C, N, A, D, I, R, G)   PROPERTYPLUGINFACTORY(Layout,C,N,A,D,I,R,G)
  • #define LAYOUTPLUGIN(C, N, A, D, I, R)   LAYOUTPLUGINOFGROUP(C,N,A,D,I,R,"")
  • #define SIZEPLUGINOFGROUP(C, N, A, D, I, R, G)   PROPERTYPLUGINFACTORY(Size,C,N,A,D,I,R,G)
  • #define SIZEPLUGIN(C, N, A, D, I, R)   SIZEPLUGINOFGROUP(C,N,A,D,I,R,"")
  • #define STRINGPLUGINOFGROUP(C, N, A, D, I, R, G)   PROPERTYPLUGINFACTORY(String,C,N,A,D,I,R,G)
  • #define STRINGPLUGIN(C, N, A, D, I, R)   STRINGPLUGINOF(C,N,A,D,I,R,"")
  • #define GRAPHPLUGINFACTORY(T, C, N, A, D, I, R, G)
    Macro for factorization of source code of Graph modification plugin mechanism.
  • #define ALGORITHMPLUGINOFGROUP(C, N, A, D, I, R, G)   GRAPHPLUGINFACTORY(Algorithm,C,N,A,D,I,R,G)
  • #define ALGORITHMPLUGIN(C, N, A, D, I, R)   ALGORITHMPLUGINOFGROUP(C,N,A,D,I,R,"")
  • #define EXPORTPLUGINOFGROUP(C, N, A, D, I, R, G)   GRAPHPLUGINFACTORY(ExportModule,C,N,A,D,I,R,G)
  • #define EXPORTPLUGIN(C, N, A, D, I, R)   EXPORTPLUGINOFGROUP(C,N,A,D,I,R,"")
  • #define IMPORTPLUGINOFGROUP(C, N, A, D, I, R, G)   GRAPHPLUGINFACTORY(ImportModule,C,N,A,D,I,R,G)
  • #define IMPORTPLUGIN(C, N, A, D, I, R)   IMPORTPLUGINOFGROUP(C,N,A,D,I,R,"")

Typedefs

Functions

Variables


Detailed Description

The Tulip plug-in system allows plug-ins to be loaded dynamically at run-time, and can check dependencies on other plug-ins, as well as multiple definitions.

This file is part of Tulip (www.tulip-software.org)

Authors: David Auber and the Tulip development Team from LaBRI, University of Bordeaux 1 and Inria Bordeaux - Sud Ouest

Tulip is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Tulip 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 General Public License for more details.

The Tulip plug-in system can be decomposed in 4 layers:

1: Tulip, who knows about TemplateFactories

2: TemplateFactories, who know about Plugin subclasses, usually called factories.

3: Plugin subclasses, who know about the plugin itself

4: The plugin itself, a subclass of Algorithm (more likely IntegerAlgorithm, DoubleAlgorithm, ...), View, ControllerViewsManager, ...


Define Documentation

#define ALGORITHMPLUGIN ( C,
N,
A,
D,
I,
 )     ALGORITHMPLUGINOFGROUP(C,N,A,D,I,R,"")
#define ALGORITHMPLUGINOFGROUP ( C,
N,
A,
D,
I,
R,
 )     GRAPHPLUGINFACTORY(Algorithm,C,N,A,D,I,R,G)
#define BOOLEANPLUGIN ( C,
N,
A,
D,
I,
 )     BOOLEANPLUGINOFGROUP(C,N,A,D,I,R,"")
#define BOOLEANPLUGINOFGROUP ( C,
N,
A,
D,
I,
R,
 )     PROPERTYPLUGINFACTORY(Boolean,C,N,A,D,I,R,G)
#define COLORPLUGIN ( C,
N,
A,
D,
I,
 )     COLORPLUGINOFGROUP(C,N,A,D,I,R,"")
#define COLORPLUGINOFGROUP ( C,
N,
A,
D,
I,
R,
 )     PROPERTYPLUGINFACTORY(Color,C,N,A,D,I,R,G)
#define DOUBLEPLUGIN ( C,
N,
A,
D,
I,
 )     DOUBLEPLUGINOFGROUP(C,N,A,D,I,R,"")
#define DOUBLEPLUGINOFGROUP ( C,
N,
A,
D,
I,
R,
 )     PROPERTYPLUGINFACTORY(Double,C,N,A,D,I,R,G)
#define EXPORTPLUGIN ( C,
N,
A,
D,
I,
 )     EXPORTPLUGINOFGROUP(C,N,A,D,I,R,"")
#define EXPORTPLUGINOFGROUP ( C,
N,
A,
D,
I,
R,
 )     GRAPHPLUGINFACTORY(ExportModule,C,N,A,D,I,R,G)
#define GRAPHPLUGIN ( C,
N,
A,
D,
I,
 )     GRAPHPLUGINOFGROUP(C,N,A,D,I,R,"")
#define GRAPHPLUGINFACTORY ( T,
C,
N,
A,
D,
I,
R,
 ) 
Value:
class C##T##Factory:public tlp::T##Factory              \
{                                                       \
 public:                                  \
  C##T##Factory(){                              \
    initFactory();                              \
    factory->registerPlugin(this);              \
  }                                       \
  ~C##T##Factory(){}                            \
  std::string getName() const { return std::string(N);}     \
  std::string getGroup() const { return std::string(G);}\
  std::string getAuthor() const {return std::string(A);}\
  std::string getDate() const {return std::string(D);}      \
  std::string getInfo() const {return std::string(I);}      \
  std::string getRelease() const {return std::string(R);}\
  std::string getTulipRelease() const {return std::string(TULIP_RELEASE);}\
  tlp::T * createPluginObject(tlp::AlgorithmContext context)            \
   {                                      \
     C *tmp=new C(context);                     \
     return ((tlp::T *) tmp);                   \
   }                                      \
};                                                      \
extern "C" {                                            \
  C##T##Factory C##T##FactoryInitializer;               \
}

Macro for factorization of source code of Graph modification plugin mechanism.

#define GRAPHPLUGINOFGROUP ( C,
N,
A,
D,
I,
R,
 )     PROPERTYPLUGINFACTORY(Graph,C,N,A,D,I,R,G)
#define IMPORTPLUGIN ( C,
N,
A,
D,
I,
 )     IMPORTPLUGINOFGROUP(C,N,A,D,I,R,"")
#define IMPORTPLUGINOFGROUP ( C,
N,
A,
D,
I,
R,
 )     GRAPHPLUGINFACTORY(ImportModule,C,N,A,D,I,R,G)
#define INTEGERPLUGIN ( C,
N,
A,
D,
I,
 )     INTEGERPLUGINOFGROUP(C,N,A,D,I,R,"")
#define INTEGERPLUGINOFGROUP ( C,
N,
A,
D,
I,
R,
 )     PROPERTYPLUGINFACTORY(Integer,C,N,A,D,I,R,G)
#define LAYOUTPLUGIN ( C,
N,
A,
D,
I,
 )     LAYOUTPLUGINOFGROUP(C,N,A,D,I,R,"")
#define LAYOUTPLUGINOFGROUP ( C,
N,
A,
D,
I,
R,
 )     PROPERTYPLUGINFACTORY(Layout,C,N,A,D,I,R,G)
#define PROPERTYPLUGINFACTORY ( T,
C,
N,
A,
D,
I,
R,
 ) 
Value:
class C##T##Factory:public tlp::PropertyFactory<tlp::T##Algorithm>      \
{                                                       \
 public:                                  \
  C##T##Factory(){                              \
    tlp::T##Property::initFactory();                  \
    tlp::T##Property::factory->registerPlugin((tlp::PropertyFactory<tlp::T##Algorithm> *) this); \
  }                                       \
  ~C##T##Factory(){}                            \
  std::string getClassName() const { return std::string(#T);} \
  std::string getName() const { return std::string(N);}     \
  std::string getGroup() const { return std::string(G);}\
  std::string getAuthor() const {return std::string(A);}\
  std::string getDate() const {return std::string(D);}      \
  std::string getInfo() const {return std::string(I);}      \
  std::string getRelease() const {return std::string(R);}\
  std::string getTulipRelease() const {return std::string(TULIP_RELEASE);}\
  tlp::T##Algorithm * createPluginObject(const tlp::PropertyContext &context)\
   {                                      \
     C *tmp=new C(context);                     \
     return ((tlp::T##Algorithm *) tmp);        \
   }                                      \
};                                                      \
extern "C" {                                            \
  C##T##Factory C##T##FactoryInitializer;               \
}

Macro for factorization of source code pf Properties plugin mechanism.

#define SIZEPLUGIN ( C,
N,
A,
D,
I,
 )     SIZEPLUGINOFGROUP(C,N,A,D,I,R,"")
#define SIZEPLUGINOFGROUP ( C,
N,
A,
D,
I,
R,
 )     PROPERTYPLUGINFACTORY(Size,C,N,A,D,I,R,G)
#define STRINGPLUGIN ( C,
N,
A,
D,
I,
 )     STRINGPLUGINOF(C,N,A,D,I,R,"")
#define STRINGPLUGINOFGROUP ( C,
N,
A,
D,
I,
R,
 )     PROPERTYPLUGINFACTORY(String,C,N,A,D,I,R,G)

Typedef Documentation

typedef _DEPRECATED PluginInfoInterface tlp::Plugin

Function Documentation

tlp::BooleanAlgorithm::BooleanAlgorithm ( const PropertyContext  )  [protected, inherited]
virtual tlp::BooleanAlgorithm::~BooleanAlgorithm (  )  [inline, virtual, inherited]

Variable Documentation

BooleanProperty* tlp::BooleanAlgorithm::booleanResult [inherited]

The result of the algorithm is stored in this member.



Tulip Software by LaBRI Visualization Team    2001 - 2011