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 PLUGINFACTORY(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)   PLUGINFACTORY(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)   PLUGINFACTORY(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)   PLUGINFACTORY(Double,C,N,A,D,I,R,G)
  • #define DOUBLEPLUGIN(C, N, A, D, I, R)   DOUBLEPLUGINOFGROUP(C,N,A,D,I,R,"")
  • #define INTEGERPLUGINOFGROUP(C, N, A, D, I, R, G)   PLUGINFACTORY(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)   PLUGINFACTORY(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)   PLUGINFACTORY(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)   PLUGINFACTORY(String,C,N,A,D,I,R,G)
  • #define STRINGPLUGIN(C, N, A, D, I, R)   STRINGPLUGINOF(C,N,A,D,I,R,"")
  • #define ALGORITHMPLUGINOFGROUP(C, N, A, D, I, R, G)   PLUGINFACTORY(Algorithm,C,N,A,D,I,R,G)
  • #define ALGORITHMPLUGIN(C, N, A, D, I, R)   ALGORITHMPLUGINOFGROUP(C,N,A,D,I,R,"")
  • #define OTHERPLUGINFACTORY(T, C, N, A, D, I, R, G)
  • #define EXPORTPLUGINOFGROUP(C, N, A, D, I, R, G)   OTHERPLUGINFACTORY(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)   OTHERPLUGINFACTORY(ImportModule,C,N,A,D,I,R,G)
  • #define IMPORTPLUGIN(C, N, A, D, I, R)   IMPORTPLUGINOFGROUP(C,N,A,D,I,R,"")
  • #define HTML_HELP_OPEN()
  • #define HTML_HELP_DEF(A, B)   "<tr><td><b>" A "</b></td><td><FONT COLOR=\"red\">" B "</td></tr>"
  • #define HTML_HELP_BODY()   "</table></td><td>"
  • #define HTML_HELP_CLOSE()   "</td></tr></table>"

Typedefs

Enumerations

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,
 )     PLUGINFACTORY(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,
 )     PLUGINFACTORY(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,
 )     PLUGINFACTORY(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,
 )     PLUGINFACTORY(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,
 )     OTHERPLUGINFACTORY(ExportModule,C,N,A,D,I,R,G)
 
#define HTML_HELP_BODY (  )     "</table></td><td>"
 
#define HTML_HELP_CLOSE (  )     "</td></tr></table>"
#define HTML_HELP_DEF ( A,
 )     "<tr><td><b>" A "</b></td><td><FONT COLOR=\"red\">" B "</td></tr>"
 
#define HTML_HELP_OPEN (  ) 
Value:
"<table><tr><td>" \
"<table CELLSPACING=5 bgcolor=\"#EEEEEE\">"
#define IMPORTPLUGIN ( C,
N,
A,
D,
I,
 )     IMPORTPLUGINOFGROUP(C,N,A,D,I,R,"")
#define IMPORTPLUGINOFGROUP ( C,
N,
A,
D,
I,
R,
 )     OTHERPLUGINFACTORY(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,
 )     PLUGINFACTORY(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,
 )     PLUGINFACTORY(Layout,C,N,A,D,I,R,G)
#define OTHERPLUGINFACTORY ( 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;               \
}
#define PLUGINFACTORY ( T,
C,
N,
A,
D,
I,
R,
 ) 
Value:
class C##T##Factory:public tlp::AlgorithmPlugin \
{                                               \
 public:            \
  C##T##Factory(){          \
    initFactory();      \
    factory->registerPlugin(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);}\
  tlp::Algorithm * createPluginObject(const tlp::AlgorithmContext &context)\
   {              \
     return new C(context);       \
   }              \
};                                                      \
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,
 )     PLUGINFACTORY(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,
 )     PLUGINFACTORY(String,C,N,A,D,I,R,G)

Typedef Documentation

typedef _DEPRECATED PluginInfoInterface tlp::Plugin
typedef AlgorithmContext tlp::PropertyContext

Enumeration Type Documentation

Enumerator:
IN_PARAM 
OUT_PARAM 
INOUT_PARAM 

Function Documentation

tlp::BooleanAlgorithm::BooleanAlgorithm ( const AlgorithmContext  )  [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 - 2012