Struct qt_widgets::QGraphicsLinearLayout

#[repr(C)]pub struct QGraphicsLinearLayout { /* fields omitted */ }

The QGraphicsLinearLayout class provides a horizontal or vertical layout for managing widgets in Graphics View.

C++ class: QGraphicsLinearLayout.

C++ documentation:

The QGraphicsLinearLayout class provides a horizontal or vertical layout for managing widgets in Graphics View.

The default orientation for a linear layout is Qt::Horizontal. You can choose a vertical orientation either by calling setOrientation(), or by passing Qt::Vertical to QGraphicsLinearLayout's constructor.

The most common way to use QGraphicsLinearLayout is to construct an object on the heap with no parent, add widgets and layouts by calling addItem(), and finally assign the layout to a widget by calling QGraphicsWidget::setLayout().

QGraphicsScene scene;
QGraphicsWidget textEdit = scene.addWidget(new QTextEdit);
QGraphicsWidget pushButton = scene.addWidget(new QPushButton);
QGraphicsLinearLayout *layout = new QGraphicsLinearLayout;
layout->addItem(textEdit);
layout->addItem(pushButton);
QGraphicsWidget *form = new QGraphicsWidget;
form->setLayout(layout);
scene.addItem(form);

You can add widgets, layouts, stretches (addStretch(), insertStretch() or setStretchFactor()), and spacings (setItemSpacing()) to a linear layout. The layout takes ownership of the items. In some cases when the layout item also inherits from QGraphicsItem (such as QGraphicsWidget) there will be a ambiguity in ownership because the layout item belongs to two ownership hierarchies. See the documentation of QGraphicsLayoutItem::setOwnedByLayout() how to handle this. You can access each item in the layout by calling count() and itemAt(). Calling removeAt() or removeItem() will remove an item from the layout, without destroying it.

Methods

impl QGraphicsLinearLayout

pub unsafe fn add_item(&self, item: impl CastInto<Ptr<QGraphicsLayoutItem>>)

This convenience function is equivalent to calling insertItem(-1, item).

Calls C++ function: void QGraphicsLinearLayout::addItem(QGraphicsLayoutItem* item).

C++ documentation:

This convenience function is equivalent to calling insertItem(-1, item).

pub unsafe fn add_stretch_1a(&self, stretch: c_int)

This convenience function is equivalent to calling insertStretch(-1, stretch).

Calls C++ function: void QGraphicsLinearLayout::addStretch(int stretch = …).

C++ documentation:

This convenience function is equivalent to calling insertStretch(-1, stretch).

pub unsafe fn add_stretch_0a(&self)

This convenience function is equivalent to calling insertStretch(-1, stretch).

Calls C++ function: void QGraphicsLinearLayout::addStretch().

C++ documentation:

This convenience function is equivalent to calling insertStretch(-1, stretch).

pub unsafe fn alignment(
    &self,
    item: impl CastInto<Ptr<QGraphicsLayoutItem>>
) -> QFlags<AlignmentFlag>

Returns the alignment for item. The default alignment is Qt::AlignTop | Qt::AlignLeft.

Calls C++ function: QFlags<Qt::AlignmentFlag> QGraphicsLinearLayout::alignment(QGraphicsLayoutItem* item) const.

C++ documentation:

Returns the alignment for item. The default alignment is Qt::AlignTop | Qt::AlignLeft.

The alignment decides how the item is positioned within its assigned space in the case where there's more space available in the layout than the widgets can occupy.

See also setAlignment().

pub unsafe fn count(&self) -> c_int

Reimplemented from QGraphicsLayout::count().

Calls C++ function: virtual int QGraphicsLinearLayout::count() const.

C++ documentation:

Reimplemented from QGraphicsLayout::count().

pub unsafe fn dump_1a(&self, indent: c_int)

Calls C++ function: void QGraphicsLinearLayout::dump(int indent = …) const.

pub unsafe fn dump_0a(&self)

Calls C++ function: void QGraphicsLinearLayout::dump() const.

pub unsafe fn insert_item(
    &self,
    index: c_int,
    item: impl CastInto<Ptr<QGraphicsLayoutItem>>
)

Inserts item into the layout at index, or before any item that is currently at index.

Calls C++ function: void QGraphicsLinearLayout::insertItem(int index, QGraphicsLayoutItem* item).

C++ documentation:

Inserts item into the layout at index, or before any item that is currently at index.

See also addItem(), itemAt(), insertStretch(), and setItemSpacing().

pub unsafe fn insert_stretch_2a(&self, index: c_int, stretch: c_int)

Inserts a stretch of stretch at index, or before any item that is currently at index.

Calls C++ function: void QGraphicsLinearLayout::insertStretch(int index, int stretch = …).

C++ documentation:

Inserts a stretch of stretch at index, or before any item that is currently at index.

See also addStretch(), setStretchFactor(), setItemSpacing(), and insertItem().

pub unsafe fn insert_stretch_1a(&self, index: c_int)

Inserts a stretch of stretch at index, or before any item that is currently at index.

Calls C++ function: void QGraphicsLinearLayout::insertStretch(int index).

C++ documentation:

Inserts a stretch of stretch at index, or before any item that is currently at index.

See also addStretch(), setStretchFactor(), setItemSpacing(), and insertItem().

pub unsafe fn invalidate(&self)

Reimplemented from QGraphicsLayout::invalidate().

Calls C++ function: virtual void QGraphicsLinearLayout::invalidate().

C++ documentation:

Reimplemented from QGraphicsLayout::invalidate().

pub unsafe fn item_at(&self, index: c_int) -> Ptr<QGraphicsLayoutItem>

Reimplemented from QGraphicsLayout::itemAt().

Calls C++ function: virtual QGraphicsLayoutItem* QGraphicsLinearLayout::itemAt(int index) const.

C++ documentation:

Reimplemented from QGraphicsLayout::itemAt().

When iterating from 0 and up, it will return the items in the visual arranged order.

pub unsafe fn item_spacing(&self, index: c_int) -> c_double

Returns the spacing after item at index.

Calls C++ function: double QGraphicsLinearLayout::itemSpacing(int index) const.

C++ documentation:

Returns the spacing after item at index.

See also setItemSpacing().

pub unsafe fn from_q_graphics_layout_item(
    parent: impl CastInto<Ptr<QGraphicsLayoutItem>>
) -> CppBox<QGraphicsLinearLayout>

Constructs a QGraphicsLinearLayout instance using Qt::Horizontal orientation. parent is passed to QGraphicsLayout's constructor.

Calls C++ function: [constructor] void QGraphicsLinearLayout::QGraphicsLinearLayout(QGraphicsLayoutItem* parent = …).

C++ documentation:

Constructs a QGraphicsLinearLayout instance using Qt::Horizontal orientation. parent is passed to QGraphicsLayout's constructor.

pub unsafe fn from_orientation_q_graphics_layout_item(
    orientation: Orientation,
    parent: impl CastInto<Ptr<QGraphicsLayoutItem>>
) -> CppBox<QGraphicsLinearLayout>

Constructs a QGraphicsLinearLayout instance. You can pass the orientation for the layout, either horizontal or vertical, and parent is passed to QGraphicsLayout's constructor.

Calls C++ function: [constructor] void QGraphicsLinearLayout::QGraphicsLinearLayout(Qt::Orientation orientation, QGraphicsLayoutItem* parent = …).

C++ documentation:

Constructs a QGraphicsLinearLayout instance. You can pass the orientation for the layout, either horizontal or vertical, and parent is passed to QGraphicsLayout's constructor.

pub unsafe fn new() -> CppBox<QGraphicsLinearLayout>

The QGraphicsLinearLayout class provides a horizontal or vertical layout for managing widgets in Graphics View.

Calls C++ function: [constructor] void QGraphicsLinearLayout::QGraphicsLinearLayout().

C++ documentation:

The QGraphicsLinearLayout class provides a horizontal or vertical layout for managing widgets in Graphics View.

The default orientation for a linear layout is Qt::Horizontal. You can choose a vertical orientation either by calling setOrientation(), or by passing Qt::Vertical to QGraphicsLinearLayout's constructor.

The most common way to use QGraphicsLinearLayout is to construct an object on the heap with no parent, add widgets and layouts by calling addItem(), and finally assign the layout to a widget by calling QGraphicsWidget::setLayout().

QGraphicsScene scene;
QGraphicsWidget textEdit = scene.addWidget(new QTextEdit);
QGraphicsWidget pushButton = scene.addWidget(new QPushButton);
QGraphicsLinearLayout *layout = new QGraphicsLinearLayout;
layout->addItem(textEdit);
layout->addItem(pushButton);
QGraphicsWidget *form = new QGraphicsWidget;
form->setLayout(layout);
scene.addItem(form);

You can add widgets, layouts, stretches (addStretch(), insertStretch() or setStretchFactor()), and spacings (setItemSpacing()) to a linear layout. The layout takes ownership of the items. In some cases when the layout item also inherits from QGraphicsItem (such as QGraphicsWidget) there will be a ambiguity in ownership because the layout item belongs to two ownership hierarchies. See the documentation of QGraphicsLayoutItem::setOwnedByLayout() how to handle this. You can access each item in the layout by calling count() and itemAt(). Calling removeAt() or removeItem() will remove an item from the layout, without destroying it.

pub unsafe fn from_orientation(
    orientation: Orientation
) -> CppBox<QGraphicsLinearLayout>

Constructs a QGraphicsLinearLayout instance. You can pass the orientation for the layout, either horizontal or vertical, and parent is passed to QGraphicsLayout's constructor.

Calls C++ function: [constructor] void QGraphicsLinearLayout::QGraphicsLinearLayout(Qt::Orientation orientation).

C++ documentation:

Constructs a QGraphicsLinearLayout instance. You can pass the orientation for the layout, either horizontal or vertical, and parent is passed to QGraphicsLayout's constructor.

pub unsafe fn orientation(&self) -> Orientation

Returns the layout orientation.

Calls C++ function: Qt::Orientation QGraphicsLinearLayout::orientation() const.

C++ documentation:

Returns the layout orientation.

See also setOrientation().

pub unsafe fn remove_at(&self, index: c_int)

Reimplemented from QGraphicsLayout::removeAt().

Calls C++ function: virtual void QGraphicsLinearLayout::removeAt(int index).

C++ documentation:

Reimplemented from QGraphicsLayout::removeAt().

Removes the item at index without destroying it. Ownership of the item is transferred to the caller.

See also removeItem() and insertItem().

pub unsafe fn remove_item(&self, item: impl CastInto<Ptr<QGraphicsLayoutItem>>)

Removes item from the layout without destroying it. Ownership of item is transferred to the caller.

Calls C++ function: void QGraphicsLinearLayout::removeItem(QGraphicsLayoutItem* item).

C++ documentation:

Removes item from the layout without destroying it. Ownership of item is transferred to the caller.

See also removeAt() and insertItem().

pub unsafe fn set_alignment(
    &self,
    item: impl CastInto<Ptr<QGraphicsLayoutItem>>,
    alignment: QFlags<AlignmentFlag>
)

Sets the alignment of item to alignment. If item's alignment changes, the layout is automatically invalidated.

Calls C++ function: void QGraphicsLinearLayout::setAlignment(QGraphicsLayoutItem* item, QFlags<Qt::AlignmentFlag> alignment).

C++ documentation:

Sets the alignment of item to alignment. If item's alignment changes, the layout is automatically invalidated.

See also alignment() and invalidate().

pub unsafe fn set_geometry(&self, rect: impl CastInto<Ref<QRectF>>)

Reimplemented from QGraphicsLayoutItem::setGeometry().

Calls C++ function: virtual void QGraphicsLinearLayout::setGeometry(const QRectF& rect).

C++ documentation:

Reimplemented from QGraphicsLayoutItem::setGeometry().

pub unsafe fn set_item_spacing(&self, index: c_int, spacing: c_double)

Sets the spacing after item at index to spacing.

Calls C++ function: void QGraphicsLinearLayout::setItemSpacing(int index, double spacing).

C++ documentation:

Sets the spacing after item at index to spacing.

See also itemSpacing().

pub unsafe fn set_orientation(&self, orientation: Orientation)

Change the layout orientation to orientation. Changing the layout orientation will automatically invalidate the layout.

Calls C++ function: void QGraphicsLinearLayout::setOrientation(Qt::Orientation orientation).

C++ documentation:

Change the layout orientation to orientation. Changing the layout orientation will automatically invalidate the layout.

See also orientation().

pub unsafe fn set_spacing(&self, spacing: c_double)

Sets the layout's spacing to spacing. Spacing refers to the vertical and horizontal distances between items.

Calls C++ function: void QGraphicsLinearLayout::setSpacing(double spacing).

C++ documentation:

Sets the layout's spacing to spacing. Spacing refers to the vertical and horizontal distances between items.

See also spacing(), setItemSpacing(), setStretchFactor(), and QGraphicsGridLayout::setSpacing().

pub unsafe fn set_stretch_factor(
    &self,
    item: impl CastInto<Ptr<QGraphicsLayoutItem>>,
    stretch: c_int
)

Sets the stretch factor for item to stretch. If an item's stretch factor changes, this function will invalidate the layout.

Calls C++ function: void QGraphicsLinearLayout::setStretchFactor(QGraphicsLayoutItem* item, int stretch).

C++ documentation:

Sets the stretch factor for item to stretch. If an item's stretch factor changes, this function will invalidate the layout.

Setting stretch to 0 removes the stretch factor from the item, and is effectively equivalent to setting stretch to 1.

See also stretchFactor().

pub unsafe fn size_hint_2a(
    &self,
    which: SizeHint,
    constraint: impl CastInto<Ref<QSizeF>>
) -> CppBox<QSizeF>

Reimplemented from QGraphicsLayoutItem::sizeHint().

Calls C++ function: virtual QSizeF QGraphicsLinearLayout::sizeHint(Qt::SizeHint which, const QSizeF& constraint = …) const.

C++ documentation:

Reimplemented from QGraphicsLayoutItem::sizeHint().

pub unsafe fn size_hint_1a(&self, which: SizeHint) -> CppBox<QSizeF>

Reimplemented from QGraphicsLayoutItem::sizeHint().

Calls C++ function: virtual QSizeF QGraphicsLinearLayout::sizeHint(Qt::SizeHint which) const.

C++ documentation:

Reimplemented from QGraphicsLayoutItem::sizeHint().

pub unsafe fn spacing(&self) -> c_double

Returns the layout's spacing. Spacing refers to the vertical and horizontal distances between items.

Calls C++ function: double QGraphicsLinearLayout::spacing() const.

C++ documentation:

Returns the layout's spacing. Spacing refers to the vertical and horizontal distances between items.

See also setSpacing().

pub unsafe fn stretch_factor(
    &self,
    item: impl CastInto<Ptr<QGraphicsLayoutItem>>
) -> c_int

Returns the stretch factor for item. The default stretch factor is 0, meaning that the item has no assigned stretch factor.

Calls C++ function: int QGraphicsLinearLayout::stretchFactor(QGraphicsLayoutItem* item) const.

C++ documentation:

Returns the stretch factor for item. The default stretch factor is 0, meaning that the item has no assigned stretch factor.

See also setStretchFactor().

Methods from Deref<Target = QGraphicsLayout>

pub unsafe fn activate(&self)

Activates the layout, causing all items in the layout to be immediately rearranged. This function is based on calling count() and itemAt(), and then calling setGeometry() on all items sequentially. When activated, the layout will adjust its geometry to its parent's contentsRect(). The parent will then invalidate any layout of its own.

Calls C++ function: void QGraphicsLayout::activate().

C++ documentation:

Activates the layout, causing all items in the layout to be immediately rearranged. This function is based on calling count() and itemAt(), and then calling setGeometry() on all items sequentially. When activated, the layout will adjust its geometry to its parent's contentsRect(). The parent will then invalidate any layout of its own.

If called in sequence or recursively, e.g., by one of the arranged items in response to being resized, this function will do nothing.

Note that the layout is free to use geometry caching to optimize this process. To forcefully invalidate any such cache, you can call invalidate() before calling activate().

See also invalidate().

pub unsafe fn count(&self) -> c_int

This pure virtual function must be reimplemented in a subclass of QGraphicsLayout to return the number of items in the layout.

Calls C++ function: pure virtual int QGraphicsLayout::count() const.

C++ documentation:

This pure virtual function must be reimplemented in a subclass of QGraphicsLayout to return the number of items in the layout.

The subclass is free to decide how to store the items.

See also itemAt() and removeAt().

pub unsafe fn get_contents_margins(
    &self,
    left: *mut c_double,
    top: *mut c_double,
    right: *mut c_double,
    bottom: *mut c_double
)

Reimplemented from QGraphicsLayoutItem::getContentsMargins().

Calls C++ function: virtual void QGraphicsLayout::getContentsMargins(double* left, double* top, double* right, double* bottom) const.

C++ documentation:

Reimplemented from QGraphicsLayoutItem::getContentsMargins().

pub unsafe fn invalidate(&self)

Clears any cached geometry and size hint information in the layout, and posts a LayoutRequest event to the managed parent QGraphicsLayoutItem.

Calls C++ function: virtual void QGraphicsLayout::invalidate().

C++ documentation:

Clears any cached geometry and size hint information in the layout, and posts a LayoutRequest event to the managed parent QGraphicsLayoutItem.

See also activate() and setGeometry().

pub unsafe fn is_activated(&self) -> bool

Returns true if the layout is currently being activated; otherwise, returns false. If the layout is being activated, this means that it is currently in the process of rearranging its items (i.e., the activate() function has been called, and has not yet returned).

Calls C++ function: bool QGraphicsLayout::isActivated() const.

C++ documentation:

Returns true if the layout is currently being activated; otherwise, returns false. If the layout is being activated, this means that it is currently in the process of rearranging its items (i.e., the activate() function has been called, and has not yet returned).

See also activate() and invalidate().

pub unsafe fn item_at(&self, i: c_int) -> Ptr<QGraphicsLayoutItem>

This pure virtual function must be reimplemented in a subclass of QGraphicsLayout to return a pointer to the item at index i. The reimplementation can assume that i is valid (i.e., it respects the value of count()). Together with count(), it is provided as a means of iterating over all items in a layout.

Calls C++ function: pure virtual QGraphicsLayoutItem* QGraphicsLayout::itemAt(int i) const.

C++ documentation:

This pure virtual function must be reimplemented in a subclass of QGraphicsLayout to return a pointer to the item at index i. The reimplementation can assume that i is valid (i.e., it respects the value of count()). Together with count(), it is provided as a means of iterating over all items in a layout.

The subclass is free to decide how to store the items, and the visual arrangement does not have to be reflected through this function.

See also count() and removeAt().

pub unsafe fn remove_at(&self, index: c_int)

This pure virtual function must be reimplemented in a subclass of QGraphicsLayout to remove the item at index. The reimplementation can assume that index is valid (i.e., it respects the value of count()).

Calls C++ function: pure virtual void QGraphicsLayout::removeAt(int index).

C++ documentation:

This pure virtual function must be reimplemented in a subclass of QGraphicsLayout to remove the item at index. The reimplementation can assume that index is valid (i.e., it respects the value of count()).

The implementation must ensure that the parentLayoutItem() of the removed item does not point to this layout, since the item is considered to be removed from the layout hierarchy.

If the layout is to be reused between applications, we recommend that the layout deletes the item, but the graphics view framework does not depend on this.

The subclass is free to decide how to store the items.

See also itemAt() and count().

pub unsafe fn set_contents_margins(
    &self,
    left: c_double,
    top: c_double,
    right: c_double,
    bottom: c_double
)

Sets the contents margins to left, top, right and bottom. The default contents margins for toplevel layouts are style dependent (by querying the pixelMetric for QStyle::PM_LayoutLeftMargin, QStyle::PM_LayoutTopMargin, QStyle::PM_LayoutRightMargin and QStyle::PM_LayoutBottomMargin).

Calls C++ function: void QGraphicsLayout::setContentsMargins(double left, double top, double right, double bottom).

C++ documentation:

Sets the contents margins to left, top, right and bottom. The default contents margins for toplevel layouts are style dependent (by querying the pixelMetric for QStyle::PM_LayoutLeftMargin, QStyle::PM_LayoutTopMargin, QStyle::PM_LayoutRightMargin and QStyle::PM_LayoutBottomMargin).

For sublayouts the default margins are 0.

Changing the contents margins automatically invalidates the layout.

See also invalidate().

pub unsafe fn update_geometry(&self)

Reimplemented from QGraphicsLayoutItem::updateGeometry().

Calls C++ function: virtual void QGraphicsLayout::updateGeometry().

C++ documentation:

Reimplemented from QGraphicsLayoutItem::updateGeometry().

pub unsafe fn widget_event(&self, e: impl CastInto<Ptr<QEvent>>)

This virtual event handler receives all events for the managed widget. QGraphicsLayout uses this event handler to listen for layout related events such as geometry changes, layout changes or layout direction changes.

Calls C++ function: virtual void QGraphicsLayout::widgetEvent(QEvent* e).

C++ documentation:

This virtual event handler receives all events for the managed widget. QGraphicsLayout uses this event handler to listen for layout related events such as geometry changes, layout changes or layout direction changes.

e is a pointer to the event.

You can reimplement this event handler to track similar events for your own custom layout.

See also QGraphicsWidget::event() and QGraphicsItem::sceneEvent().

Trait Implementations

impl CppDeletable for QGraphicsLinearLayout

unsafe fn delete(&self)

Destroys the QGraphicsLinearLayout object.

Calls C++ function: virtual [destructor] void QGraphicsLinearLayout::~QGraphicsLinearLayout().

C++ documentation:

Destroys the QGraphicsLinearLayout object.

impl Deref for QGraphicsLinearLayout

type Target = QGraphicsLayout

The resulting type after dereferencing.

fn deref(&self) -> &QGraphicsLayout

Calls C++ function: QGraphicsLayout* static_cast<QGraphicsLayout*>(QGraphicsLinearLayout* ptr).

impl DynamicCast<QGraphicsLinearLayout> for QGraphicsLayout

unsafe fn dynamic_cast(ptr: Ptr<QGraphicsLayout>) -> Ptr<QGraphicsLinearLayout>

Calls C++ function: QGraphicsLinearLayout* dynamic_cast<QGraphicsLinearLayout*>(QGraphicsLayout* ptr).

impl DynamicCast<QGraphicsLinearLayout> for QGraphicsLayoutItem

unsafe fn dynamic_cast(
    ptr: Ptr<QGraphicsLayoutItem>
) -> Ptr<QGraphicsLinearLayout>

Calls C++ function: QGraphicsLinearLayout* dynamic_cast<QGraphicsLinearLayout*>(QGraphicsLayoutItem* ptr).

impl StaticDowncast<QGraphicsLinearLayout> for QGraphicsLayout

unsafe fn static_downcast(
    ptr: Ptr<QGraphicsLayout>
) -> Ptr<QGraphicsLinearLayout>

Calls C++ function: QGraphicsLinearLayout* static_cast<QGraphicsLinearLayout*>(QGraphicsLayout* ptr).

impl StaticDowncast<QGraphicsLinearLayout> for QGraphicsLayoutItem

unsafe fn static_downcast(
    ptr: Ptr<QGraphicsLayoutItem>
) -> Ptr<QGraphicsLinearLayout>

Calls C++ function: QGraphicsLinearLayout* static_cast<QGraphicsLinearLayout*>(QGraphicsLayoutItem* ptr).

impl StaticUpcast<QGraphicsLayout> for QGraphicsLinearLayout

unsafe fn static_upcast(ptr: Ptr<QGraphicsLinearLayout>) -> Ptr<QGraphicsLayout>

Calls C++ function: QGraphicsLayout* static_cast<QGraphicsLayout*>(QGraphicsLinearLayout* ptr).

impl StaticUpcast<QGraphicsLayoutItem> for QGraphicsLinearLayout

unsafe fn static_upcast(
    ptr: Ptr<QGraphicsLinearLayout>
) -> Ptr<QGraphicsLayoutItem>

Calls C++ function: QGraphicsLayoutItem* static_cast<QGraphicsLayoutItem*>(QGraphicsLinearLayout* ptr).