tlp::AbstractProperty< Tnode, Tedge, TPROPERTY > | This class is used to store a property of a graph. It implements PropertyInterface and add new methods to deal with two distinct type of values :
|
tlp::AbstractVectorProperty< vectType, eltType > | |
tlp::AcyclicTest | Class for testing if the graph is acyclic |
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, ...) |
tlp::AlgorithmContext | Parameter for calling clustering plugins |
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 |
tlp::Array< Obj, SIZE > | Fixed-size array encapsulation. In debug mode, a bound check is performed at each access |
tlp::Bfs | |
tlp::BiconnectedTest | Class for testing if the graph is biconnected |
tlp::BooleanAlgorithm | Interface for selection plug-ins |
tlp::BooleanProperty | |
tlp::BooleanType | |
tlp::BooleanVectorProperty | |
tlp::BooleanVectorType | |
tlp::BoundingBox | This class represents the 3D bounding box of an object. It is mostly used to determine whether or not two object are in a state of collision |
tlp::VoronoiDiagram::Cell | |
tlp::Circle< Obj > | Class for circle |
tlp::Color | |
tlp::ColorAlgorithm | Interface for color plug-ins |
tlp::ColorProperty | |
tlp::ColorScale | Use this class to create a color scale and perform color mapping. The color scale can be either gradient or predefined colors steps. If the color scale is a gradient, returned color are interpolated in function of the position. If the color scale isn't a gradient returned colors are the predefined colors steps |
tlp::ColorType | |
tlp::ColorVectorProperty | |
tlp::ColorVectorType | |
tlp::ConcatIterator< itType > | |
tlp::ConnectedTest | Class for testing if the graph is connected |
tlp::Coord | This class represents a point in 3-D space, with float precision |
tlp::CoordVectorProperty | |
tlp::CoordVectorType | |
tlp::DataMem | |
tlp::DataSet | A container which can store data of any type, as long as it has a well-defined copy constructor |
tlp::DataType | |
tlp::DataTypeSerializer | |
tlp::Dependency | Represents a single Tulip plug-in |
tlp::DoubleAlgorithm | Interface for metric plug-ins |
tlp::DoubleProperty | |
tlp::DoubleType | |
tlp::DoubleVectorProperty | |
tlp::DoubleVectorType | |
tlp::VoronoiDiagram::Edge | |
tlp::edge | Class edge |
tlp::EdgeSetType | |
tlp::ExportModule | Interface for exportModule plug-ins |
tlp::ExportModuleFactory | |
tlp::Face | Class face |
tlp::Graph | Interface for a graph |
tlp::GraphObserver | That class receives a message (call back/handler function) after each modification of a Graph |
tlp::GraphProperty | |
tlp::GraphStorage | That class provide a simple implementation for the storage of graph elts (nodes edges) |
tlp::GraphStorageIdsMemento | That class provides a simple interface to save the state of the ids manage by the GraphStorage class |
tlp::GraphType | |
stdext::hash< const std::string > | |
stdext::hash< double > | |
stdext::hash< std::string > | |
tlp::ImportModule | Interface for importModule plug-ins |
tlp::ImportModuleFactory | |
tlp::IntegerAlgorithm | Interface for int plug-ins |
tlp::IntegerProperty | |
tlp::IntegerType | |
tlp::IntegerVectorProperty | |
tlp::IntegerVectorType | |
tlp::Iterator< itType > | Interface of Iterators |
tlp::LayoutAlgorithm | Interface for layout plug-ins |
tlp::LayoutProperty | |
tlp::LineType | |
tlp::Matrix< Obj, SIZE > | Class for mathematical square matrix |
tlp::MemoryPool< TYPE > | That class enables to easily create a memory pool for an a class |
tlp::PropertyInterface::MetaValueCalculator | |
tlp::AbstractProperty< Tnode, Tedge, TPROPERTY >::MetaValueCalculator | This class is used to delegate the computation of the values associated to meta nodes or edges |
tlp::MutableContainer< TYPE > | |
tlp::node | Class node |
tlp::Observable | |
tlp::ObservableGraph | That class enables to easily implement several type of Observable graph |
tlp::ObservableProperty | Observable object for Property |
tlp::Observer | |
tlp::OuterPlanarTest | Class for testing the outerplanarity of a graph |
tlp::PlanarityTest | Class for testing the planarity of a graph |
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) |
tlp::PluginLoader | |
tlp::PluginLoaderTxt | |
tlp::PluginProgress | Interface to notify and control the progression of a process |
tlp::PointType | |
tlp::PreferenceManager | Class to manage preference Singleton class to load/store preference need by Tulip |
tlp::PropertyAlgorithm | This base class describes plug-ins who only modify one property, e.g. selection |
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 |
tlp::PropertyFactory< T > | |
tlp::PropertyInterface | |
tlp::PropertyObserver | Observer for Property |
tlp::QuadTreeNode< TYPE > | QuadTree template class |
tlp::VoronoiDiagram::Ray | |
tlp::Rectangle< Obj > | Class for rectangle |
tlp::SelfLoops | |
tlp::SimplePluginProgress | Basic implementation for PluginProgress interface |
tlp::SimpleTest | |
tlp::Size | |
tlp::SizeAlgorithm | Interface for sizes plug-ins |
tlp::SizeProperty | |
tlp::SizeType | |
tlp::SizeVectorProperty | |
tlp::SizeVectorType | |
tlp::SortNodeIterator | Interface of Sortiterator, |
tlp::SortTargetEdgeIterator | Interface of Sortiterator, |
tlp::StableIterator< itType > | That class enables to store elements of an iterator and to iterate on a copy |
tlp::StlIterator< VALUE, ITERATOR > | |
tlp::StlMapIterator< KEY, VALUE > | |
tlp::StringAlgorithm | Interface for String plug-ins |
tlp::StringCollection | |
tlp::StringProperty | |
tlp::StringType | |
tlp::StringVectorProperty | |
tlp::StringVectorType | |
tlp::StructDef | This class enables to define a structure |
tlp::TemplateFactory< ObjectFactory, ObjectType, Context > | This template class takes 3 parameters : |
tlp::TemplateFactoryInterface | This interface lists functions used to regroup plug-ins |
tlp::TreeTest | Class for testing if the graph is a tree |
tlp::TriconnectedTest | Class for testing if a graph is triconnected |
tlp::TypedData< T > | |
tlp::TypedDataSerializer< T > | |
tlp::TypedValueContainer< TYPE > | |
tlp::Vector | Class for mathematical vector |
tlp::VectorCast | Class for mathematical vector |
tlp::VoronoiDiagram | |
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 |
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 |