LARS
LARS (Light Augmented Reality System) is an open-source framework for light-based interaction and real-time tracking in multi-robot experiments. Inspired by ARK, LARS extends the augmented reality paradigm to robotic collectives by projecting dynamic visual cues and environments onto the arena, enabling new experimental possibilities for collective robotics research, education, and outreach. LARS features integrated tracking, light projection, and modular experiment control with a user-friendly Qt GUI.
Loading...
Searching...
No Matches
QCPLayout Class Referenceabstract

The abstract base class for layouts. More...

Inheritance diagram for QCPLayout:
QCPLayoutElement QCPLayerable QCPLayoutGrid QCPLayoutInset QCPLegend

Public Member Functions

 QCPLayout ()
virtual void update (UpdatePhase phase) Q_DECL_OVERRIDE
virtual QList< QCPLayoutElement * > elements (bool recursive) const Q_DECL_OVERRIDE
virtual int elementCount () const =0
virtual QCPLayoutElement * elementAt (int index) const =0
virtual QCPLayoutElement * takeAt (int index)=0
virtual bool take (QCPLayoutElement *element)=0
virtual void simplify ()
bool removeAt (int index)
bool remove (QCPLayoutElement *element)
void clear ()
Public Member Functions inherited from QCPLayoutElement
 QCPLayoutElement (QCustomPlot *parentPlot=nullptr)
QCPLayout * layout () const
QRect rect () const
QRect outerRect () const
QMargins margins () const
QMargins minimumMargins () const
QCP::MarginSides autoMargins () const
QSize minimumSize () const
QSize maximumSize () const
SizeConstraintRect sizeConstraintRect () const
QCPMarginGroup * marginGroup (QCP::MarginSide side) const
QHash< QCP::MarginSide, QCPMarginGroup * > marginGroups () const
void setOuterRect (const QRect &rect)
void setMargins (const QMargins &margins)
void setMinimumMargins (const QMargins &margins)
void setAutoMargins (QCP::MarginSides sides)
void setMinimumSize (const QSize &size)
void setMinimumSize (int width, int height)
void setMaximumSize (const QSize &size)
void setMaximumSize (int width, int height)
void setSizeConstraintRect (SizeConstraintRect constraintRect)
void setMarginGroup (QCP::MarginSides sides, QCPMarginGroup *group)
virtual QSize minimumOuterSizeHint () const
virtual QSize maximumOuterSizeHint () const
virtual double selectTest (const QPointF &pos, bool onlySelectable, QVariant *details=nullptr) const Q_DECL_OVERRIDE
Public Member Functions inherited from QCPLayerable
 QCPLayerable (QCustomPlot *plot, QString targetLayer=QString(), QCPLayerable *parentLayerable=nullptr)
bool visible () const
QCustomPlot * parentPlot () const
QCPLayerable * parentLayerable () const
QCPLayer * layer () const
bool antialiased () const
void setVisible (bool on)
Q_SLOT bool setLayer (QCPLayer *layer)
bool setLayer (const QString &layerName)
void setAntialiased (bool enabled)
bool realVisibility () const

Protected Member Functions

virtual void updateLayout ()
void sizeConstraintsChanged () const
void adoptElement (QCPLayoutElement *el)
void releaseElement (QCPLayoutElement *el)
QVector< int > getSectionSizes (QVector< int > maxSizes, QVector< int > minSizes, QVector< double > stretchFactors, int totalSize) const
Protected Member Functions inherited from QCPLayoutElement
virtual int calculateAutoMargin (QCP::MarginSide side)
virtual void layoutChanged ()
virtual void applyDefaultAntialiasingHint (QCPPainter *painter) const Q_DECL_OVERRIDE
virtual void draw (QCPPainter *painter) Q_DECL_OVERRIDE
virtual void parentPlotInitialized (QCustomPlot *parentPlot) Q_DECL_OVERRIDE
Protected Member Functions inherited from QCPLayerable
virtual QCP::Interaction selectionCategory () const
virtual QRect clipRect () const
virtual void selectEvent (QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged)
virtual void deselectEvent (bool *selectionStateChanged)
virtual void mousePressEvent (QMouseEvent *event, const QVariant &details)
virtual void mouseMoveEvent (QMouseEvent *event, const QPointF &startPos)
virtual void mouseReleaseEvent (QMouseEvent *event, const QPointF &startPos)
virtual void mouseDoubleClickEvent (QMouseEvent *event, const QVariant &details)
virtual void wheelEvent (QWheelEvent *event)
void initializeParentPlot (QCustomPlot *parentPlot)
void setParentLayerable (QCPLayerable *parentLayerable)
bool moveToLayer (QCPLayer *layer, bool prepend)
void applyAntialiasingHint (QCPPainter *painter, bool localAntialiased, QCP::AntialiasedElement overrideElement) const

Static Protected Member Functions

static QSize getFinalMinimumOuterSize (const QCPLayoutElement *el)
static QSize getFinalMaximumOuterSize (const QCPLayoutElement *el)

Friends

class QCPLayoutElement

Additional Inherited Members

Public Types inherited from QCPLayoutElement
enum  UpdatePhase { upPreparation , upMargins , upLayout }
enum  SizeConstraintRect { scrInnerRect , scrOuterRect }
Signals inherited from QCPLayerable
void layerChanged (QCPLayer *newLayer)
Protected Attributes inherited from QCPLayoutElement
QCPLayout * mParentLayout
QSize mMinimumSize
QSize mMaximumSize
SizeConstraintRect mSizeConstraintRect
QRect mRect
QRect mOuterRect
QMargins mMargins
QMargins mMinimumMargins
QCP::MarginSides mAutoMargins
QHash< QCP::MarginSide, QCPMarginGroup * > mMarginGroups
Protected Attributes inherited from QCPLayerable
bool mVisible
QCustomPlot * mParentPlot
QPointer< QCPLayerable > mParentLayerable
QCPLayer * mLayer
bool mAntialiased

Detailed Description

The abstract base class for layouts.

This is an abstract base class for layout elements whose main purpose is to define the position and size of other child layout elements. In most cases, layouts don't draw anything themselves (but there are exceptions to this, e.g. QCPLegend).

QCPLayout derives from QCPLayoutElement, and thus can itself be nested in other layouts.

QCPLayout introduces a common interface for accessing and manipulating the child elements. Those functions are most notably elementCount, elementAt, takeAt, take, simplify, removeAt, remove and clear. Individual subclasses may add more functions to this interface which are more specialized to the form of the layout. For example, QCPLayoutGrid adds functions that take row and column indices to access cells of the layout grid more conveniently.

Since this is an abstract base class, you can't instantiate it directly. Rather use one of its subclasses like QCPLayoutGrid or QCPLayoutInset.

For a general introduction to the layout system, see the dedicated documentation page The Layout System.

Constructor & Destructor Documentation

◆ QCPLayout()

QCPLayout::QCPLayout ( )
explicit

Creates an instance of QCPLayout and sets default values. Note that since QCPLayout is an abstract base class, it can't be instantiated directly.

Member Function Documentation

◆ clear()

void QCPLayout::clear ( )

Removes and deletes all layout elements in this layout. Finally calls simplify to make sure all empty cells are collapsed.

See also
remove, removeAt

◆ elementAt()

virtual QCPLayoutElement * QCPLayout::elementAt ( int index) const
pure virtual

Returns the element in the cell with the given index. If index is invalid, returns nullptr.

Note that even if index is valid, the respective cell may be empty in some layouts (e.g. QCPLayoutGrid), so this function may return nullptr in those cases. You may use this function to check whether a cell is empty or not.

See also
elements, elementCount, takeAt

Implemented in QCPLayoutGrid, and QCPLayoutInset.

◆ elementCount()

virtual int QCPLayout::elementCount ( ) const
pure virtual

Returns the number of elements/cells in the layout.

See also
elements, elementAt

Implemented in QCPLayoutGrid, and QCPLayoutInset.

◆ elements()

QList< QCPLayoutElement * > QCPLayout::elements ( bool recursive) const
virtual

Returns a list of all child elements in this layout element. If recursive is true, all sub-child elements are included in the list, too.

Warning
There may be nullptr entries in the returned list. For example, QCPLayoutGrid may have empty cells which yield nullptr at the respective index.

Reimplemented from QCPLayoutElement.

Reimplemented in QCPLayoutGrid.

◆ remove()

bool QCPLayout::remove ( QCPLayoutElement * element)

Removes and deletes the provided element. Returns true on success. If element is not in the layout, returns false.

This function internally uses takeAt to remove the element from the layout and then deletes the element. Note that some layouts don't remove the respective cell right away but leave an empty cell after successful removal of the layout element. To collapse empty cells, use simplify.

See also
removeAt, take

◆ removeAt()

bool QCPLayout::removeAt ( int index)

Removes and deletes the element at the provided index. Returns true on success. If index is invalid or points to an empty cell, returns false.

This function internally uses takeAt to remove the element from the layout and then deletes the returned element. Note that some layouts don't remove the respective cell right away but leave an empty cell after successful removal of the layout element. To collapse empty cells, use simplify.

See also
remove, takeAt

◆ simplify()

void QCPLayout::simplify ( )
virtual

Simplifies the layout by collapsing empty cells. The exact behavior depends on subclasses, the default implementation does nothing.

Not all layouts need simplification. For example, QCPLayoutInset doesn't use explicit simplification while QCPLayoutGrid does.

Reimplemented in QCPLayoutGrid, and QCPLayoutInset.

◆ sizeConstraintsChanged()

void QCPLayout::sizeConstraintsChanged ( ) const
protected

Subclasses call this method to report changed (minimum/maximum) size constraints.

If the parent of this layout is again a QCPLayout, forwards the call to the parent's sizeConstraintsChanged. If the parent is a QWidget (i.e. is the QCustomPlot::plotLayout of QCustomPlot), calls QWidget::updateGeometry, so if the QCustomPlot widget is inside a Qt QLayout, it may update itself and resize cells accordingly.

◆ take()

virtual bool QCPLayout::take ( QCPLayoutElement * element)
pure virtual

Removes the specified element from the layout and returns true on success.

If the element isn't in this layout, returns false.

Note that some layouts don't remove the respective cell right away but leave an empty cell after successful removal of the layout element. To collapse empty cells, use simplify.

See also
takeAt

Implemented in QCPLayoutGrid, and QCPLayoutInset.

◆ takeAt()

virtual QCPLayoutElement * QCPLayout::takeAt ( int index)
pure virtual

Removes the element with the given index from the layout and returns it.

If the index is invalid or the cell with that index is empty, returns nullptr.

Note that some layouts don't remove the respective cell right away but leave an empty cell after successful removal of the layout element. To collapse empty cells, use simplify.

See also
elementAt, take

Implemented in QCPLayoutGrid, and QCPLayoutInset.

◆ update()

void QCPLayout::update ( UpdatePhase phase)
virtual

If phase is upLayout, calls updateLayout, which subclasses may reimplement to reposition and resize their cells.

Finally, the call is propagated down to all child QCPLayoutElements.

For details about this method and the update phases, see the documentation of QCPLayoutElement::update.

Reimplemented from QCPLayoutElement.

The documentation for this class was generated from the following files: