Overview     Modules     Class Hierarchy     Classes     Members  

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
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::AcyclicTestClass for testing if the graph is acyclic
tlp::AlgorithmThis 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::AlgorithmContextParameter for calling clustering plugins
tlp::AlgorithmFactoryA 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::BiconnectedTestClass for testing if the graph is biconnected
tlp::BooleanAlgorithmInterface for selection plug-ins
tlp::BooleanProperty
tlp::BooleanType
tlp::BooleanVectorProperty
tlp::BooleanVectorType
tlp::BoundingBoxThis 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::ColorAlgorithmInterface for color plug-ins
tlp::ColorProperty
tlp::ColorScaleUse 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::ConnectedTestClass for testing if the graph is connected
tlp::CoordThis class represents a point in 3-D space, with float precision
tlp::CoordVectorProperty
tlp::CoordVectorType
tlp::DataMem
tlp::DataSetA container which can store data of any type, as long as it has a well-defined copy constructor
tlp::DataType
tlp::DataTypeSerializer
tlp::DependencyRepresents a single Tulip plug-in
tlp::DoubleAlgorithmInterface for metric plug-ins
tlp::DoubleProperty
tlp::DoubleType
tlp::DoubleVectorProperty
tlp::DoubleVectorType
tlp::VoronoiDiagram::Edge
tlp::edgeClass edge
tlp::EdgeSetType
tlp::ExportModuleInterface for exportModule plug-ins
tlp::ExportModuleFactory
tlp::FaceClass face
tlp::GraphInterface for a graph
tlp::GraphObserverThat class receives a message (call back/handler function) after each modification of a Graph
tlp::GraphProperty
tlp::GraphStorageThat class provide a simple implementation for the storage of graph elts (nodes edges)
tlp::GraphStorageIdsMementoThat 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::ImportModuleInterface for importModule plug-ins
tlp::ImportModuleFactory
tlp::IntegerAlgorithmInterface for int plug-ins
tlp::IntegerProperty
tlp::IntegerType
tlp::IntegerVectorProperty
tlp::IntegerVectorType
tlp::Iterator< itType >Interface of Iterators
tlp::LayoutAlgorithmInterface 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 >::MetaValueCalculatorThis class is used to delegate the computation of the values associated to meta nodes or edges
tlp::MutableContainer< TYPE >
tlp::nodeClass node
tlp::Observable
tlp::ObservableGraphThat class enables to easily implement several type of Observable graph
tlp::ObservablePropertyObservable object for Property
tlp::Observer
tlp::OuterPlanarTestClass for testing the outerplanarity of a graph
tlp::PlanarityTestClass for testing the planarity of a graph
tlp::PluginBase 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::PluginProgressInterface to notify and control the progression of a process
tlp::PointType
tlp::PreferenceManagerClass to manage preference Singleton class to load/store preference need by Tulip
tlp::PropertyAlgorithmThis base class describes plug-ins who only modify one property, e.g. selection
tlp::PropertyContextThis 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::PropertyObserverObserver for Property
tlp::QuadTreeNode< TYPE >QuadTree template class
tlp::VoronoiDiagram::Ray
tlp::Rectangle< Obj >Class for rectangle
tlp::SelfLoops
tlp::SimplePluginProgressBasic implementation for PluginProgress interface
tlp::SimpleTest
tlp::Size
tlp::SizeAlgorithmInterface for sizes plug-ins
tlp::SizeProperty
tlp::SizeType
tlp::SizeVectorProperty
tlp::SizeVectorType
tlp::SortNodeIteratorInterface of Sortiterator,
tlp::SortTargetEdgeIteratorInterface 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::StringAlgorithmInterface for String plug-ins
tlp::StringCollection
tlp::StringProperty
tlp::StringType
tlp::StringVectorProperty
tlp::StringVectorType
tlp::StructDefThis class enables to define a structure
tlp::TemplateFactory< ObjectFactory, ObjectType, Context >This template class takes 3 parameters :
tlp::TemplateFactoryInterfaceThis interface lists functions used to regroup plug-ins
tlp::TreeTestClass for testing if the graph is a tree
tlp::TriconnectedTestClass for testing if a graph is triconnected
tlp::TypedData< T >
tlp::TypedDataSerializer< T >
tlp::TypedValueContainer< TYPE >
tlp::VectorClass for mathematical vector
tlp::VectorCastClass for mathematical vector
tlp::VoronoiDiagram
tlp::WithDependencyDescribes 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::WithParameterThis 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


Tulip Software by LaBRI Visualization Team    2001 - 2011