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)

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_NAME	The name of the interactor class to generate.
STRING_CLASS_NAME	The name of the interactor plugin to generate (see tlp::Plugin::name())
BASE_INTERACTOR_STRING_NAME	The name of the interactor to extend
VIEW_STRING_NAME	The name of the View to set the interactor compatible with
AUTHOR	see tlp::Plugin::author()
DATE	see tlp::Plugin::date()
DESCRIPTION	see tlp::Plugin::info()
VERSION	see 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)

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() {          \
  tlp::PluginLister::registerPlugin(this);     \
}             \
~C##Factory(){}          \
tlp::Plugin* createPluginObject(tlp::PluginContext* context) { \
C* tmp = new C(context);       \
return tmp;       \
}              \
};                                                      \
\
extern "C" {                                            \
C##Factory C##FactoryInitializer;               \
}

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

C	The 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 241 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

NAME	The plugin name as it will be registered into the plugins system (tlp::Plugin::name())
AUTHOR	The author of the plugin (tlp::Plugin::author())
DATE	The creation date (tlp::Plugin::date())
INFO	The plugin's description (tlp::Plugin::info())
RELEASE	The plugin's version number (tlp::Plugin::version())
GROUP	The 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

enum tlp::ParameterDirection

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.

enum tlp::ProgressState

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

className	The mangled name of a class
hideTlp	a 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

className

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