Tulip  5.1.0
Large graphs analysis and drawing
Plugins system

Classes

class  tlp::Algorithm
 
class  tlp::AlgorithmContext
 
class  tlp::BooleanAlgorithm
 
class  tlp::ColorAlgorithm
 
struct  tlp::Dependency
 
class  tlp::DoubleAlgorithm
 
class  tlp::GlMainView
 
class  tlp::IntegerAlgorithm
 
class  tlp::Interactor
 
class  tlp::InteractorLister
 
class  tlp::LayoutAlgorithm
 
class  tlp::ParameterDescription
 
struct  tlp::ParameterDescriptionList
 
class  tlp::Perspective
 
class  tlp::PerspectiveContext
 
class  tlp::Plugin
 
class  tlp::PluginContext
 
class  tlp::PluginLister
 
struct  tlp::PluginLoader
 
struct  tlp::PluginLoaderTxt
 
class  tlp::PluginProgress
 
class  tlp::ProgressPreviewHandler
 
class  tlp::PropertyAlgorithm
 
class  tlp::SizeAlgorithm
 
class  tlp::StringAlgorithm
 
class  tlp::TemplateAlgorithm< Property >
 
class  tlp::TulipProject
 
class  tlp::View
 
class  tlp::ViewWidget
 
class  tlp::WithDependency
 
struct  tlp::WithParameter
 

Macros

#define INTERACTORPLUGINVIEWEXTENSION(CLASS_NAME, STRING_CLASS_NAME, BASE_INTERACTOR_STRING_NAME, VIEW_STRING_NAME, AUTHOR, DATE, DESCRIPTION, VERSION)
 
#define INTERACTORPLUGINVIEWEXTENSIONWITHPRIORITY(CLASS_NAME, STRING_CLASS_NAME, BASE_INTERACTOR_STRING_NAME, VIEW_STRING_NAME, AUTHOR, DATE, DESCRIPTION, VERSION, PRIORITY)
 
#define PLUGIN(C)
 
#define PLUGININFORMATION(NAME, AUTHOR, DATE, INFO, RELEASE, GROUP)
 

Enumerations

enum  tlp::ParameterDirection { IN_PARAM =0, OUT_PARAM = 1, INOUT_PARAM = 2 }
 
enum  tlp::ProgressState { tlp::TLP_CONTINUE, tlp::TLP_CANCEL, tlp::TLP_STOP }
 

Functions

std::string tlp::demangleClassName (const char *className, bool hideTlp=false)
 
std::string tlp::demangleTlpClassName (const char *className)
 
std::string tlp::getMajor (const std::string &release)
 
std::string tlp::getMinor (const std::string &release)
 
void tlp::initTulipLib (const char *appDirPath=NULL)
 

Detailed Description

Tulip plugins interfaces Classes in this group are interfaces for the plugins system. You will subclass one of them when creating your own Tulip plugins.

Macro Definition Documentation

#define INTERACTORPLUGINVIEWEXTENSION (   CLASS_NAME,
  STRING_CLASS_NAME,
  BASE_INTERACTOR_STRING_NAME,
  VIEW_STRING_NAME,
  AUTHOR,
  DATE,
  DESCRIPTION,
  VERSION 
)
Value:
class CLASS_NAME : public tlp::Interactor {\
mutable tlp::Interactor* _component;\
public:\
std::string name() const { return std::string(STRING_CLASS_NAME); } \
std::string author() const { return std::string(AUTHOR); }\
std::string date() const { return std::string(DATE); } \
std::string info() const { return std::string(DESCRIPTION); } \
std::string release() const { return std::string(VERSION); }\
std::string tulipRelease() const { return std::string(TULIP_VERSION); }\
std::string group() const { return getComponent()->group(); }\
CLASS_NAME(const PluginContext *):_component(NULL) {}\
bool isCompatible(const std::string& viewName) const { return viewName == VIEW_STRING_NAME; }\
QWidget* configurationWidget() const { return getComponent()->configurationWidget(); }\
unsigned int priority() const { return getComponent()->priority(); }\
QAction* action() const { return getComponent()->action(); }\
tlp::View* view() const { return getComponent()->view(); }\
QCursor cursor() const { return getComponent()->cursor(); }\
void construct() { getComponent()->construct(); }\
void setView(tlp::View* v) { getComponent()->setView(v); }\
void install(QObject* target) { getComponent()->install(target); }\
void uninstall() { getComponent()->uninstall(); }\
void undoIsDone() { getComponent()->undoIsDone(); }\
tlp::Interactor* getComponent() const {\
if(!_component) {\
_component = tlp::PluginLister::instance()->getPluginObject<Interactor>(BASE_INTERACTOR_STRING_NAME,NULL); assert(_component != NULL);\
}\
return _component;\
}\
};\
PLUGIN(CLASS_NAME)
virtual void install(QObject *target)=0
Install the interactor on the given target A call to this method means thatr the interactor should st...
virtual QWidget * configurationWidget() const =0
virtual void uninstall()=0
Removes the interactor from the previously set target. Interactors can be installed on only one targe...
Interactor provides a way to handle user inputs over a view. Basically, The interactor class is an ov...
Definition: Interactor.h:53
virtual std::string info() const =0
Information about the plug-in, from the plug-in author. This information can contains anything...
virtual void undoIsDone()=0
Informs the interactor when the undo command (Ctrl+Z) has been triggered.
virtual QAction * action() const =0
virtual std::string tulipRelease() const =0
The version of Tulip this plug-in was built with. Tulip versions are X.Y.Z, X being the major...
static tlp::Plugin * getPluginObject(const std::string &name, tlp::PluginContext *context)
Constructs a plug-in.
virtual void setView(tlp::View *)=0
Defines the view object associated to this interactor.
#define PLUGIN(C)
Register a plugin into the plugin system. This macro is mandatory in order to register a plugin into ...
Definition: Plugin.h:238
virtual QCursor cursor() const =0
virtual std::string date() const =0
The creation date of the plug-in. This date is in a free format, but most Tulip plug-ins use a DD/MM/...
virtual std::string name() const =0
Returns the name of the plug-in, as registered in the Tulip plug-in system. This name must be unique...
virtual bool isCompatible(const std::string &viewName) const =0
Checks the compatibility between the interactor and the given view (identified by its name)...
View plugins provide a way to dynamically add to a Tulip plateform various ways to visualize a graph...
Definition: View.h:73
virtual std::string release() const =0
The release version of the plug-in, including major and minor. The version should be X...
virtual void construct()=0
Builds up the interactor&#39;s internal state. This method should be used instead of the constructor to i...
virtual unsigned int priority() const =0
virtual std::string group() const =0
Returns the name of the group this plug-in belongs to. Groups and sub-groups are separated by two col...
virtual tlp::View * view() const =0
static tlp::PluginLister * instance()
Gets the static instance of this class. If not already done, creates it beforehand.
virtual std::string author() const =0
The name of the author of this plug-in.

Copy an existing Tulip interactor and sets it compatible with a given View.

This macro is used when you're making your own View and want to use an existing interactor with it. Interactors are declared to be compatible with a list of View. This macro extends the compatibility of an existing interactor by subclassing it.

Note
: This macro used the same interactor priority as the base interactor. To define your own priority, see INTERACTORPLUGINVIEWEXTENSIONWITHPRIORITY
Parameters
CLASS_NAMEThe name of the interactor class to generate.
STRING_CLASS_NAMEThe name of the interactor plugin to generate (see tlp::Plugin::name())
BASE_INTERACTOR_STRING_NAMEThe name of the interactor to extend
VIEW_STRING_NAMEThe name of the View to set the interactor compatible with
AUTHORsee tlp::Plugin::author()
DATEsee tlp::Plugin::date()
DESCRIPTIONsee tlp::Plugin::info()
VERSIONsee tlp::Plugin::version()

Definition at line 178 of file Interactor.h.

#define INTERACTORPLUGINVIEWEXTENSIONWITHPRIORITY (   CLASS_NAME,
  STRING_CLASS_NAME,
  BASE_INTERACTOR_STRING_NAME,
  VIEW_STRING_NAME,
  AUTHOR,
  DATE,
  DESCRIPTION,
  VERSION,
  PRIORITY 
)
Value:
class CLASS_NAME : public tlp::Interactor {\
mutable tlp::Interactor* _component;\
public:\
std::string name() const { return std::string(STRING_CLASS_NAME); } \
std::string author() const { return std::string(AUTHOR); }\
std::string date() const { return std::string(DATE); } \
std::string info() const { return std::string(DESCRIPTION); } \
std::string release() const { return std::string(VERSION); }\
std::string tulipRelease() const { return std::string(TULIP_VERSION); }\
std::string group() const { return getComponent()->group(); }\
CLASS_NAME(const PluginContext *):_component(NULL) {}\
bool isCompatible(const std::string& viewName) const { return viewName == VIEW_STRING_NAME; }\
QWidget* configurationWidget() const { return getComponent()->configurationWidget(); }\
unsigned int priority() const { return PRIORITY; }\
QAction* action() const { return getComponent()->action(); }\
tlp::View* view() const { return getComponent()->view(); }\
QCursor cursor() const { return getComponent()->cursor(); }\
void construct() { getComponent()->construct(); }\
void setView(tlp::View* v) { getComponent()->setView(v); }\
void install(QObject* target) { getComponent()->install(target); }\
void uninstall() { getComponent()->uninstall(); }\
void undoIsDone() { getComponent()->undoIsDone(); }\
tlp::Interactor* getComponent() const {\
if(!_component) {\
_component = tlp::PluginLister::instance()->getPluginObject<Interactor>(BASE_INTERACTOR_STRING_NAME,NULL); assert(_component != NULL);\
}\
return _component;\
}\
};\
PLUGIN(CLASS_NAME)
virtual void install(QObject *target)=0
Install the interactor on the given target A call to this method means thatr the interactor should st...
virtual QWidget * configurationWidget() const =0
virtual void uninstall()=0
Removes the interactor from the previously set target. Interactors can be installed on only one targe...
Interactor provides a way to handle user inputs over a view. Basically, The interactor class is an ov...
Definition: Interactor.h:53
virtual std::string info() const =0
Information about the plug-in, from the plug-in author. This information can contains anything...
virtual void undoIsDone()=0
Informs the interactor when the undo command (Ctrl+Z) has been triggered.
virtual QAction * action() const =0
virtual std::string tulipRelease() const =0
The version of Tulip this plug-in was built with. Tulip versions are X.Y.Z, X being the major...
static tlp::Plugin * getPluginObject(const std::string &name, tlp::PluginContext *context)
Constructs a plug-in.
virtual void setView(tlp::View *)=0
Defines the view object associated to this interactor.
#define PLUGIN(C)
Register a plugin into the plugin system. This macro is mandatory in order to register a plugin into ...
Definition: Plugin.h:238
virtual QCursor cursor() const =0
virtual std::string date() const =0
The creation date of the plug-in. This date is in a free format, but most Tulip plug-ins use a DD/MM/...
virtual std::string name() const =0
Returns the name of the plug-in, as registered in the Tulip plug-in system. This name must be unique...
virtual bool isCompatible(const std::string &viewName) const =0
Checks the compatibility between the interactor and the given view (identified by its name)...
View plugins provide a way to dynamically add to a Tulip plateform various ways to visualize a graph...
Definition: View.h:73
virtual std::string release() const =0
The release version of the plug-in, including major and minor. The version should be X...
virtual void construct()=0
Builds up the interactor&#39;s internal state. This method should be used instead of the constructor to i...
virtual unsigned int priority() const =0
virtual std::string group() const =0
Returns the name of the group this plug-in belongs to. Groups and sub-groups are separated by two col...
virtual tlp::View * view() const =0
static tlp::PluginLister * instance()
Gets the static instance of this class. If not already done, creates it beforehand.
virtual std::string author() const =0
The name of the author of this plug-in.

Similar to INTERACTORPLUGINVIEWEXTENSION but allows to define the generated interactor's priority.

See also
tlp::Interactor::priority()
INTERACTORPLUGINVIEWEXTENSION

Definition at line 217 of file Interactor.h.

#define PLUGIN (   C)
Value:
class C##Factory : public tlp::FactoryInterface { \
public: \
C##Factory() { \
} \
~C##Factory(){} \
tlp::Plugin* createPluginObject(tlp::PluginContext* context) { \
C* tmp = new C(context); \
return tmp; \
} \
}; \
\
extern "C" { \
C##Factory C##FactoryInitializer; \
}
static void registerPlugin(FactoryInterface *objectFactory)
Registers a plugin into Tulip.
Contains runtime parameters for a plugin.
Definition: PluginContext.h:39

Register a plugin into the plugin system. This macro is mandatory in order to register a plugin into Tulip. This will generate a Factory that will handle the plugin's creation.

Parameters
CThe classname of the plugin.
Note
This macro should be called outside of the class body
// This sample shows a basic skeleton for a plugin class declaration:
class MyPlugin: public tlp::PluginBase { // tlp::PluginBase is replaced by the actual Plugin interface (tlp::Algorithm, tlp::View, etc)
public:
PLUGININFORMATION("My plugin", "Me", "28/09/2012", "My first plugin example", "1.0", "")
// Class declaration and extra methods
};
PLUGIN(MyPlugin) // Register MyPlugin into Tulip
See also
tlp::Plugin
PLUGININFORMATION
Examples:
clique_import/cliqueimport.cpp, and interactor_plugin/interactor_plugin.cpp.

Definition at line 238 of file Plugin.h.

#define PLUGININFORMATION (   NAME,
  AUTHOR,
  DATE,
  INFO,
  RELEASE,
  GROUP 
)
Value:
std::string name() const { return NAME; } \
std::string author() const { return AUTHOR; }\
std::string date() const { return DATE; } \
std::string info() const { return INFO; } \
std::string release() const { return RELEASE; }\
std::string tulipRelease() const { return TULIP_VERSION; }\
std::string group() const { return GROUP; }

Declare meta-information for a plugin This is an helper macro that defines every function related to a plugin meta-information (Plugin name, author, etc). When creating a new plugin, this macro avoids having to define pure-virtual methods located into the Plugin interface and put them on the same line.

Note
PLUGINIFORMATION should be declared into the Plugin's class body into the public scope
Parameters
NAMEThe plugin name as it will be registered into the plugins system (tlp::Plugin::name())
AUTHORThe author of the plugin (tlp::Plugin::author())
DATEThe creation date (tlp::Plugin::date())
INFOThe plugin's description (tlp::Plugin::info())
RELEASEThe plugin's version number (tlp::Plugin::version())
GROUPThe plugin's group (tlp::Plugin::group()). If the plugin does not belong to any group, set GROUP to "".
See also
tlp::Plugin
PLUGIN
Examples:
clique_import/cliqueimport.cpp, and interactor_plugin/interactor_plugin.cpp.

Definition at line 203 of file Plugin.h.

Enumeration Type Documentation

The ParameterDirection enum describes how a parameter is passed to a plugin The parameter can be seen as passing parameters to a C++ functions and works as follow: .

  • IN_PARAM: The parameter is passes by value
  • OUT_PARAM: The parameter is a return value
  • INOUT_PARAM: The parameter is passed by reference.

Definition at line 46 of file WithParameter.h.

This enum describes callback actions for the underlaying system when calling tlp::PluginProgress::progress(); .

  • TLP_CONTINUE: tells that the process monitored by the the progress should continue.
  • TLP_CANCEL: The process should be cancelled, reverting all changes since it was started.
  • TLP_STOP: The process should stop, leaving all the changes made since the beginning
See also
tlp::PluginProgress
Enumerator
TLP_CONTINUE 

The plugin should continue its execution.

TLP_CANCEL 

The plugin should cancel, reverting all performed changes since the plugin was called.

TLP_STOP 

The plugin should stop, leaving the graph in its current state.

Definition at line 57 of file PluginProgress.h.

Function Documentation

std::string tlp::demangleClassName ( const char *  className,
bool  hideTlp = false 
)

Demangles the name of a C++ class.

Parameters
classNameThe mangled name of a class
hideTlpa flag to indicate if the 'tlp::' prefix
Returns
string The demangled name of a Tulip C++ class.

+ Here is the caller graph for this function:

std::string tlp::demangleTlpClassName ( const char *  className)
inline

Demangles the name of a C++ class defined in the tlp namespace.

Parameters
classNameThe mangled name of a class
Returns
string The demangled name of a Tulip C++ class without the tlp:: prefix

Definition at line 75 of file TlpTools.h.

+ Here is the call graph for this function:

std::string tlp::getMajor ( const std::string &  release)

Splits the string and returns everything befor the first dot ('.'). This is used to return major version number, as version numbers are formatted as X.Y.Z, X being the major, Y the minor, and Z the patch version.

Returns
string The part of the string before the first dot.
std::string tlp::getMinor ( const std::string &  release)

Splits the string and return the minor version. If the string does not contain any dot, then 0 is returned. If the string contains only one dot (X.Y), then everything after the first dot is returned (Y). If the string is a full version with two dots (X.Y.Z), everything between the first and last dots is returned (Y). If there are more than two dots, everything between the first and last dots is returned.

void tlp::initTulipLib ( const char *  appDirPath = NULL)

Initializes the Tulip library. Looks for the Tulip plug-ins directory. The plug-ins directory can be defined in different ways, given by order of prevalence :

  1. the TLP_DIR environment variable, if it has a value
  2. the appDirPath parameter, if it is not NULL
  3. at that point, the Tulip paths will be retrieved from the path of the loaded Tulip shared library (you must dispose of a standard Tulip installation for that feature to work).
  4. a fallback value of 'C:/Tulip/lib/' on windows, or '/usr/local/lib/' on Unix.