Overview     Modules     Class Hierarchy     Classes     Members  

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]
virtual tlp::BooleanAlgorithm::~BooleanAlgorithm ( ) [inline, virtual]

Variable Documentation

The result of the algorithm is stored in this member.



Tulip Software by LaBRI Visualization Team    2001 - 2012