Plugins system

Classes
class	tlp::Algorithm
class	tlp::AlgorithmContext
class	tlp::BooleanAlgorithm
class	tlp::ColorAlgorithm
class	tlp::DoubleAlgorithm
class	tlp::GlMainView
class	tlp::IntegerAlgorithm
class	tlp::Interactor
class	tlp::LayoutAlgorithm
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::View
class	tlp::ViewWidget

Macros
#define	PLUGIN(C)
#define	PLUGININFORMATION(NAME, AUTHOR, DATE, INFO, RELEASE, GROUP)

Enumerations
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=nullptr)

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

PLUGIN

#define PLUGIN

(

C

)

Value:

  class C##Factory : public tlp::PluginFactory {                                                   \
  public:                                                                                          \
    C##Factory() {                                                                                 \
      registerFactory(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 @endnote

// 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

Definition at line 298 of file Plugin.h.

PLUGININFORMATION

#define PLUGININFORMATION	(		NAME,
			AUTHOR,
			DATE,
			INFO,
			RELEASE,
			GROUP
	)

Value:

  std::string name() const override {                                                              \
    return NAME;                                                                                   \
  }                                                                                                \
  std::string author() const override {                                                            \
    return AUTHOR;                                                                                 \
  }                                                                                                \
  std::string date() const override {                                                              \
    return DATE;                                                                                   \
  }                                                                                                \
  std::string info() const override {                                                              \
    return INFO;                                                                                   \
  }                                                                                                \
  std::string release() const override {                                                           \
    return RELEASE;                                                                                \
  }                                                                                                \
  std::string tulipRelease() const override {                                                      \
    return TULIP_VERSION;                                                                          \
  }                                                                                                \
  std::string group() const override {                                                             \
    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

Definition at line 234 of file Plugin.h.

Enumeration Type Documentation

ProgressState

enum tlp::ProgressState

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

• 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 @endlist

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 62 of file PluginProgress.h.

Function Documentation

demangleClassName()

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:

demangleTlpClassName()

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 90 of file TlpTools.h.

Here is the call graph for this function:

getMajor()

std::string tlp::getMajor

(

const std::string &

release

)

Splits the string and returns everything before 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.

getMinor()

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.

initTulipLib()

void tlp::initTulipLib

(

const char *

appDirPath = nullptr

)

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