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

• 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::AlgorithmFactory

  A base class for algorithm plug-ins factory. Each plug-in declares (through a macro) its own factory. 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 to factorize code. 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

  Interface for importModule 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::Plugin

  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 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::PropertyContext

  This class is used as only parameter when calling Property plug-ins. It contains a Graph on whyich to run the plug-in, a PropertyInterface which will hold the result of the plug-in, and a PluginProgress to give feedback on the plug-in's progress. 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...
  

• class tlp::PropertyFactory< T >
• 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...
  

• struct tlp::WithParameter

  This class describes parameters on a plug-in. These parameters can be of any type, and are used to generate a GUI that will be shown when the plug-in in invoked by the user. It is mainly used by algorithms to display options to the user, e.g. a clustering algorithm can let the user choose which measure to use. More...
  

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,"")

Functions

• virtual tlp::BooleanAlgorithm::~BooleanAlgorithm ()
• tlp::BooleanAlgorithm::BooleanAlgorithm (const PropertyContext &)

Variables

• BooleanProperty * tlp::BooleanAlgorithm::booleanResult

  The result of the algorithm is stored in this member.
  

---

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,
		R		)	ALGORITHMPLUGINOFGROUP(C,N,A,D,I,R,"")

#define ALGORITHMPLUGINOFGROUP	(	C,
		N,
		A,
		D,
		I,
		R,
		G		)	GRAPHPLUGINFACTORY(Algorithm,C,N,A,D,I,R,G)

#define BOOLEANPLUGIN	(	C,
		N,
		A,
		D,
		I,
		R		)	BOOLEANPLUGINOFGROUP(C,N,A,D,I,R,"")

#define BOOLEANPLUGINOFGROUP	(	C,
		N,
		A,
		D,
		I,
		R,
		G		)	PROPERTYPLUGINFACTORY(Boolean,C,N,A,D,I,R,G)

#define COLORPLUGIN	(	C,
		N,
		A,
		D,
		I,
		R		)	COLORPLUGINOFGROUP(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 DOUBLEPLUGIN	(	C,
		N,
		A,
		D,
		I,
		R		)	DOUBLEPLUGINOFGROUP(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 EXPORTPLUGIN	(	C,
		N,
		A,
		D,
		I,
		R		)	EXPORTPLUGINOFGROUP(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 GRAPHPLUGIN	(	C,
		N,
		A,
		D,
		I,
		R		)	GRAPHPLUGINOFGROUP(C,N,A,D,I,R,"")

#define GRAPHPLUGINFACTORY	(	T,
		C,
		N,
		A,
		D,
		I,
		R,
		G		)

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,
		G		)	PROPERTYPLUGINFACTORY(Graph,C,N,A,D,I,R,G)

#define IMPORTPLUGIN	(	C,
		N,
		A,
		D,
		I,
		R		)	IMPORTPLUGINOFGROUP(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 INTEGERPLUGIN	(	C,
		N,
		A,
		D,
		I,
		R		)	INTEGERPLUGINOFGROUP(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 LAYOUTPLUGIN	(	C,
		N,
		A,
		D,
		I,
		R		)	LAYOUTPLUGINOFGROUP(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 PROPERTYPLUGINFACTORY	(	T,
		C,
		N,
		A,
		D,
		I,
		R,
		G		)

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,
		R		)	SIZEPLUGINOFGROUP(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 STRINGPLUGIN	(	C,
		N,
		A,
		D,
		I,
		R		)	STRINGPLUGINOF(C,N,A,D,I,R,"")

#define STRINGPLUGINOFGROUP	(	C,
		N,
		A,
		D,
		I,
		R,
		G		)	PROPERTYPLUGINFACTORY(String,C,N,A,D,I,R,G)

---

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.