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

class  tlp::Algorithm
 This abstract class describes a basic algorithm plugin. It inherits on WithParameter and WithDependency for convenience. Basic functionality consists in checking the algorithm can run on the current Graph (e.g. is the graph simple ?), running the algorithm and resetting the algorithm to re-apply it. The algorithm can and should report progress and which task it is performing if it is decomposed in multiple phases (e.g. layouting the graph, coloring it, ...). More...
class  tlp::AlgorithmPlugin
 A class for algorithm plug-ins The factory the registers itself in the Tulip plug-in system (through the static initFactory() method when the library is loaded.. The actual registration is delegated to a TemplateFactory for code factorization. More...
class  tlp::BooleanAlgorithm
 Interface for selection plug-ins. More...
class  tlp::ColorAlgorithm
 Interface for color plug-ins. More...
class  tlp::DoubleAlgorithm
 Interface for metric plug-ins. More...
class  tlp::ExportModule
 Interface for exportModule plug-ins. More...
class  tlp::ExportModuleFactory
class  tlp::ImportModule
 Base class for import plug-ins. More...
class  tlp::ImportModuleFactory
class  tlp::IntegerAlgorithm
 Interface for int plug-ins. More...
class  tlp::LayoutAlgorithm
 Interface for layout plug-ins. More...
class  tlp::PluginInfoInterface
 Base interface for plug-in description. This class is not intented to be subclassed by plug-ins themselves, but by the factories who create the plug-ins. This class holds user informations, such as name of the author, date of creation, and miscellaneous informations. It also holds informations for the Tulip plug-in system, such as the version (used to know when there is an update for a plug-in), the name (used as unique identifier to register the plug-in), the Tulip version the plug-in was built with (to know whether the plug-in is compatible with the currently running version of TUlip), and the group this plug-in belongs to (e.g. trees). More...
class  tlp::AlgorithmContext
 Parameter for calling clustering plugins. More...
class  tlp::PropertyAlgorithm
 This base class describes plug-ins who only modify one property, e.g. selection. More...
class  tlp::SizeAlgorithm
 Interface for sizes plug-ins. More...
class  tlp::StringAlgorithm
 Interface for String plug-ins. More...
class  tlp::TemplateFactoryInterface
 This interface lists functions used to regroup plug-ins. More...
class  tlp::TemplateFactory< ObjectFactory, ObjectType, Context >
 This template class takes 3 parameters : More...
struct  tlp::Dependency
 Represents a single Tulip plug-in. More...
class  tlp::WithDependency
 Describes the dependencies of a plug-in on other plug-ins, identified by their name. This allows to have a plug-in inner workings depend on other plug-ins without linking them statically, or hoping depended plug-in will be there. More...
class  tlp::ParameterDescription
 Describes a parameter with a type, default value, whether or not is it mandatory and a help string describing what this parameter should be used for. More...
struct  tlp::ParameterDescriptionList
 This class describes parameters taken by a plugin. More...
struct  tlp::WithParameter
 This class describes parameters on a plug-in. More...

Macros

#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

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

Enumerations

enum  tlp::ParameterDirection { tlp::IN_PARAM = 0, tlp::OUT_PARAM = 1, tlp::INOUT_PARAM = 2 }

Functions

virtual tlp::BooleanAlgorithm::~BooleanAlgorithm ()
 tlp::BooleanAlgorithm::BooleanAlgorithm (const AlgorithmContext &)

Variables

BooleanProperty * tlp::BooleanAlgorithm::booleanResult
 The result of the algorithm is stored in this member.

Friends

class tlp::BooleanAlgorithm::BooleanProperty

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, ...


Macro Definition 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);}\
{ \
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 ( )
inlinevirtual

Variable Documentation

BooleanProperty* tlp::BooleanAlgorithm::booleanResult

The result of the algorithm is stored in this member.


Friends

friend class BooleanProperty
friend


Tulip Software by LaBRI Visualization Team    2001 - 2012