[−][src]Struct qt_widgets::QSplitter

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

The QSplitter class implements a splitter widget.

C++ class: QSplitter.

C++ documentation:

The QSplitter class implements a splitter widget.

A splitter lets the user control the size of child widgets by dragging the boundary between them. Any number of widgets may be controlled by a single splitter. The typical use of a QSplitter is to create several widgets and add them using insertWidget() or addWidget().

The following example will show a QListView, QTreeView, and QTextEdit side by side, with two splitter handles:

      QSplitter splitter = new QSplitter(parent);
      QListView listview = new QListView;
      QTreeView treeview = new QTreeView;
      QTextEdit textedit = new QTextEdit;
      splitter->addWidget(listview);
      splitter->addWidget(treeview);
      splitter->addWidget(textedit);

If a widget is already inside a QSplitter when insertWidget() or addWidget() is called, it will move to the new position. This can be used to reorder widgets in the splitter later. You can use indexOf(), widget(), and count() to get access to the widgets inside the splitter.

A default QSplitter lays out its children horizontally (side by side); you can use setOrientation(Qt::Vertical) to lay its children out vertically.

By default, all widgets can be as large or as small as the user wishes, between the minimumSizeHint() (or minimumSize()) and maximumSize() of the widgets.

QSplitter resizes its children dynamically by default. If you would rather have QSplitter resize the children only at the end of a resize operation, call setOpaqueResize(false).

The initial distribution of size between the widgets is determined by multiplying the initial size with the stretch factor. You can also use setSizes() to set the sizes of all the widgets. The function sizes() returns the sizes set by the user. Alternatively, you can save and restore the sizes of the widgets from a QByteArray using saveState() and restoreState() respectively.

When you hide() a child, its space will be distributed among the other children. It will be reinstated when you show() it again.

Note: Adding a QLayout to a QSplitter is not supported (either through setLayout() or making the QSplitter a parent of the QLayout); use addWidget() instead (see example above).

Methods

`impl QSplitter`[src]

`pub fn splitter_moved(&self) -> Signal<(c_int, c_int)>`[src]

This signal is emitted when the splitter handle at a particular index has been moved to position pos.

Returns a built-in Qt signal QSplitter::splitterMoved that can be passed to qt_core::Signal::connect.

C++ documentation:

This signal is emitted when the splitter handle at a particular index has been moved to position pos.

For right-to-left languages such as Arabic and Hebrew, the layout of horizontal splitters is reversed. pos is then the distance from the right edge of the widget.

See also moveSplitter().

`pub unsafe fn add_widget(&self, widget: impl CastInto<Ptr<QWidget>>)`[src]

Adds the given widget to the splitter's layout after all the other items.

Calls C++ function: void QSplitter::addWidget(QWidget* widget).

C++ documentation:

Adds the given widget to the splitter's layout after all the other items.

If widget is already in the splitter, it will be moved to the new position.

Note: The splitter takes ownership of the widget.

See also insertWidget(), widget(), and indexOf().

`pub unsafe fn children_collapsible(&self) -> bool`[src]

This property holds whether child widgets can be resized down to size 0 by the user

Calls C++ function: bool QSplitter::childrenCollapsible() const.

C++ documentation:

This property holds whether child widgets can be resized down to size 0 by the user

By default, children are collapsible. It is possible to enable and disable the collapsing of individual children using setCollapsible().

Access functions:

bool	childrenCollapsible() const
void	setChildrenCollapsible(bool)

See also setCollapsible().

`pub unsafe fn count(&self) -> c_int`[src]

Returns the number of widgets contained in the splitter's layout.

Calls C++ function: int QSplitter::count() const.

C++ documentation:

Returns the number of widgets contained in the splitter's layout.

See also widget() and handle().

`pub unsafe fn get_range(&self, index: c_int, arg2: mut c_int, arg3: mut c_int)`[src]

Returns the valid range of the splitter at index in *min and *max if min and max are not 0.

Calls C++ function: void QSplitter::getRange(int index, int* arg2, int* arg3) const.

C++ documentation:

Returns the valid range of the splitter at index in *min and *max if min and max are not 0.

`pub unsafe fn handle(&self, index: c_int) -> QPtr<QSplitterHandle>`[src]

Returns the handle to the left (or above) for the item in the splitter's layout at the given index. The handle at index 0 is always hidden.

Calls C++ function: QSplitterHandle* QSplitter::handle(int index) const.

C++ documentation:

Returns the handle to the left (or above) for the item in the splitter's layout at the given index. The handle at index 0 is always hidden.

For right-to-left languages such as Arabic and Hebrew, the layout of horizontal splitters is reversed. The handle will be to the right of the widget at index.

See also count(), widget(), indexOf(), createHandle(), and setHandleWidth().

`pub unsafe fn handle_width(&self) -> c_int`[src]

This property holds the width of the splitter handles

Calls C++ function: int QSplitter::handleWidth() const.

C++ documentation:

This property holds the width of the splitter handles

By default, this property contains a value that depends on the user's platform and style preferences.

If you set handleWidth to 1 or 0, the actual grab area will grow to overlap a few pixels of its respective widgets.

Access functions:

int	handleWidth() const
void	setHandleWidth(int)

`pub unsafe fn index_of(&self, w: impl CastInto<Ptr<QWidget>>) -> c_int`[src]

Returns the index in the splitter's layout of the specified widget. This also works for handles.

Calls C++ function: int QSplitter::indexOf(QWidget* w) const.

C++ documentation:

Returns the index in the splitter's layout of the specified widget. This also works for handles.

Handles are numbered from 0. There are as many handles as there are child widgets, but the handle at position 0 is always hidden.

See also count() and widget().

`pub unsafe fn insert_widget( &self, index: c_int, widget: impl CastInto<Ptr<QWidget>> )`[src]

Inserts the widget specified into the splitter's layout at the given index.

Calls C++ function: void QSplitter::insertWidget(int index, QWidget* widget).

C++ documentation:

Inserts the widget specified into the splitter's layout at the given index.

If widget is already in the splitter, it will be moved to the new position.

If index is an invalid index, then the widget will be inserted at the end.

Note: The splitter takes ownership of the widget.

See also addWidget(), indexOf(), and widget().

`pub unsafe fn is_collapsible(&self, index: c_int) -> bool`[src]

Returns true if the widget at index is collapsible, otherwise returns false.

Calls C++ function: bool QSplitter::isCollapsible(int index) const.

C++ documentation:

Returns true if the widget at index is collapsible, otherwise returns false.

`pub unsafe fn meta_object(&self) -> Ptr<QMetaObject>`[src]

Calls C++ function: virtual const QMetaObject* QSplitter::metaObject() const.

`pub unsafe fn minimum_size_hint(&self) -> CppBox<QSize>`[src]

Reimplemented from QWidget::minimumSizeHint().

Calls C++ function: virtual QSize QSplitter::minimumSizeHint() const.

C++ documentation:

Reimplemented from QWidget::minimumSizeHint().

`pub unsafe fn from_q_widget( parent: impl CastInto<Ptr<QWidget>> ) -> QBox<QSplitter>`[src]

Constructs a horizontal splitter with the parent argument passed on to the QFrame constructor.

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

C++ documentation:

Constructs a horizontal splitter with the parent argument passed on to the QFrame constructor.

See also setOrientation().

`pub unsafe fn from_orientation_q_widget( arg1: Orientation, parent: impl CastInto<Ptr<QWidget>> ) -> QBox<QSplitter>`[src]

Constructs a splitter with the given orientation and parent.

Calls C++ function: [constructor] void QSplitter::QSplitter(Qt::Orientation arg1, QWidget* parent = …).

C++ documentation:

Constructs a splitter with the given orientation and parent.

See also setOrientation().

`pub unsafe fn new() -> QBox<QSplitter>`[src]

The QSplitter class implements a splitter widget.

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

C++ documentation:

The QSplitter class implements a splitter widget.

A splitter lets the user control the size of child widgets by dragging the boundary between them. Any number of widgets may be controlled by a single splitter. The typical use of a QSplitter is to create several widgets and add them using insertWidget() or addWidget().

The following example will show a QListView, QTreeView, and QTextEdit side by side, with two splitter handles:

      QSplitter splitter = new QSplitter(parent);
      QListView listview = new QListView;
      QTreeView treeview = new QTreeView;
      QTextEdit textedit = new QTextEdit;
      splitter->addWidget(listview);
      splitter->addWidget(treeview);
      splitter->addWidget(textedit);

If a widget is already inside a QSplitter when insertWidget() or addWidget() is called, it will move to the new position. This can be used to reorder widgets in the splitter later. You can use indexOf(), widget(), and count() to get access to the widgets inside the splitter.

A default QSplitter lays out its children horizontally (side by side); you can use setOrientation(Qt::Vertical) to lay its children out vertically.

By default, all widgets can be as large or as small as the user wishes, between the minimumSizeHint() (or minimumSize()) and maximumSize() of the widgets.

QSplitter resizes its children dynamically by default. If you would rather have QSplitter resize the children only at the end of a resize operation, call setOpaqueResize(false).

The initial distribution of size between the widgets is determined by multiplying the initial size with the stretch factor. You can also use setSizes() to set the sizes of all the widgets. The function sizes() returns the sizes set by the user. Alternatively, you can save and restore the sizes of the widgets from a QByteArray using saveState() and restoreState() respectively.

When you hide() a child, its space will be distributed among the other children. It will be reinstated when you show() it again.

Note: Adding a QLayout to a QSplitter is not supported (either through setLayout() or making the QSplitter a parent of the QLayout); use addWidget() instead (see example above).

`pub unsafe fn from_orientation(arg1: Orientation) -> QBox<QSplitter>`[src]

Constructs a splitter with the given orientation and parent.

Calls C++ function: [constructor] void QSplitter::QSplitter(Qt::Orientation arg1).

C++ documentation:

Constructs a splitter with the given orientation and parent.

See also setOrientation().

`pub unsafe fn opaque_resize(&self) -> bool`[src]

This property holds whether resizing is opaque

Calls C++ function: bool QSplitter::opaqueResize() const.

C++ documentation:

This property holds whether resizing is opaque

The default resize behavior is style dependent (determined by the SH_Splitter_OpaqueResize style hint). However, you can override it by calling setOpaqueResize()

Access functions:

bool	opaqueResize() const
void	setOpaqueResize(bool opaque = true)

See also QStyle::StyleHint.

`pub unsafe fn orientation(&self) -> Orientation`[src]

This property holds the orientation of the splitter

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

C++ documentation:

This property holds the orientation of the splitter

By default, the orientation is horizontal (i.e., the widgets are laid out side by side). The possible orientations are Qt::Horizontal and Qt::Vertical.

Access functions:

Qt::Orientation	orientation() const
void	setOrientation(Qt::Orientation)

See also QSplitterHandle::orientation().

`pub unsafe fn qt_metacall( &self, arg1: Call, arg2: c_int, arg3: mut mut c_void ) -> c_int`[src]

Calls C++ function: virtual int QSplitter::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3).

`pub unsafe fn qt_metacast(&self, arg1: const c_char) -> mut c_void`[src]

Calls C++ function: virtual void* QSplitter::qt_metacast(const char* arg1).

`pub unsafe fn refresh(&self)`[src]

Updates the splitter's state. You should not need to call this function.

Calls C++ function: void QSplitter::refresh().

C++ documentation:

Updates the splitter's state. You should not need to call this function.

`pub unsafe fn replace_widget( &self, index: c_int, widget: impl CastInto<Ptr<QWidget>> ) -> QPtr<QWidget>`[src]

Replaces the widget in the splitter's layout at the given index by widget.

Calls C++ function: QWidget* QSplitter::replaceWidget(int index, QWidget* widget).

C++ documentation:

Replaces the widget in the splitter's layout at the given index by widget.

Returns the widget that has just been replaced if index is valid and widget is not already a child of the splitter. Otherwise, it returns null and no replacement or addition is made.

The geometry of the newly inserted widget will be the same as the widget it replaces. Its visible and collapsed states are also inherited.

Note: The splitter takes ownership of widget and sets the parent of the replaced widget to null.

Note: Because widget gets reparented into the splitter, its geometry may not be set right away, but only after widget will receive the appropriate events.

This function was introduced in Qt 5.9.

See also insertWidget() and indexOf().

`pub unsafe fn restore_state( &self, state: impl CastInto<Ref<QByteArray>> ) -> bool`[src]

Restores the splitter's layout to the state specified. Returns true if the state is restored; otherwise returns false.

Calls C++ function: bool QSplitter::restoreState(const QByteArray& state).

C++ documentation:

Restores the splitter's layout to the state specified. Returns true if the state is restored; otherwise returns false.

Typically this is used in conjunction with QSettings to restore the size from a past session. Here is an example:

Restore the splitter's state:

      QSettings settings;
      splitter->restoreState(settings.value("splitterSizes").toByteArray());

A failure to restore the splitter's layout may result from either invalid or out-of-date data in the supplied byte array.

See also saveState().

`pub unsafe fn save_state(&self) -> CppBox<QByteArray>`[src]

Saves the state of the splitter's layout.

Calls C++ function: QByteArray QSplitter::saveState() const.

C++ documentation:

Saves the state of the splitter's layout.

Typically this is used in conjunction with QSettings to remember the size for a future session. A version number is stored as part of the data. Here is an example:

      QSettings settings;
      settings.setValue("splitterSizes", splitter->saveState());

See also restoreState().

`pub unsafe fn set_children_collapsible(&self, arg1: bool)`[src]

This property holds whether child widgets can be resized down to size 0 by the user

Calls C++ function: void QSplitter::setChildrenCollapsible(bool arg1).

C++ documentation:

This property holds whether child widgets can be resized down to size 0 by the user

By default, children are collapsible. It is possible to enable and disable the collapsing of individual children using setCollapsible().

Access functions:

bool	childrenCollapsible() const
void	setChildrenCollapsible(bool)

See also setCollapsible().

`pub unsafe fn set_collapsible(&self, index: c_int, arg2: bool)`[src]

Sets whether the child widget at index is collapsible to collapse.

Calls C++ function: void QSplitter::setCollapsible(int index, bool arg2).

C++ documentation:

Sets whether the child widget at index is collapsible to collapse.

By default, children are collapsible, meaning that the user can resize them down to size 0, even if they have a non-zero minimumSize() or minimumSizeHint(). This behavior can be changed on a per-widget basis by calling this function, or globally for all the widgets in the splitter by setting the childrenCollapsible property.

See also isCollapsible() and childrenCollapsible.

`pub unsafe fn set_handle_width(&self, arg1: c_int)`[src]

This property holds the width of the splitter handles

Calls C++ function: void QSplitter::setHandleWidth(int arg1).

C++ documentation:

This property holds the width of the splitter handles

By default, this property contains a value that depends on the user's platform and style preferences.

If you set handleWidth to 1 or 0, the actual grab area will grow to overlap a few pixels of its respective widgets.

Access functions:

int	handleWidth() const
void	setHandleWidth(int)

`pub unsafe fn set_opaque_resize_1a(&self, opaque: bool)`[src]

This property holds whether resizing is opaque

Calls C++ function: void QSplitter::setOpaqueResize(bool opaque = …).

C++ documentation:

This property holds whether resizing is opaque

The default resize behavior is style dependent (determined by the SH_Splitter_OpaqueResize style hint). However, you can override it by calling setOpaqueResize()

Access functions:

bool	opaqueResize() const
void	setOpaqueResize(bool opaque = true)

See also QStyle::StyleHint.

`pub unsafe fn set_opaque_resize_0a(&self)`[src]

This property holds whether resizing is opaque

Calls C++ function: void QSplitter::setOpaqueResize().

C++ documentation:

This property holds whether resizing is opaque

The default resize behavior is style dependent (determined by the SH_Splitter_OpaqueResize style hint). However, you can override it by calling setOpaqueResize()

Access functions:

bool	opaqueResize() const
void	setOpaqueResize(bool opaque = true)

See also QStyle::StyleHint.

`pub unsafe fn set_orientation(&self, arg1: Orientation)`[src]

This property holds the orientation of the splitter

Calls C++ function: void QSplitter::setOrientation(Qt::Orientation arg1).

C++ documentation:

This property holds the orientation of the splitter

By default, the orientation is horizontal (i.e., the widgets are laid out side by side). The possible orientations are Qt::Horizontal and Qt::Vertical.

Access functions:

Qt::Orientation	orientation() const
void	setOrientation(Qt::Orientation)

See also QSplitterHandle::orientation().

`pub unsafe fn set_sizes(&self, list: impl CastInto<Ref<QListOfInt>>)`[src]

Sets the child widgets' respective sizes to the values given in the list.

Calls C++ function: void QSplitter::setSizes(const QList<int>& list).

C++ documentation:

Sets the child widgets' respective sizes to the values given in the list.

If the splitter is horizontal, the values set the width of each widget in pixels, from left to right. If the splitter is vertical, the height of each widget is set, from top to bottom.

Extra values in the list are ignored. If list contains too few values, the result is undefined, but the program will still be well-behaved.

The overall size of the splitter widget is not affected. Instead, any additional/missing space is distributed amongst the widgets according to the relative weight of the sizes.

If you specify a size of 0, the widget will be invisible. The size policies of the widgets are preserved. That is, a value smaller than the minimal size hint of the respective widget will be replaced by the value of the hint.

See also sizes().

`pub unsafe fn set_stretch_factor(&self, index: c_int, stretch: c_int)`[src]

Updates the size policy of the widget at position index to have a stretch factor of stretch.

Calls C++ function: void QSplitter::setStretchFactor(int index, int stretch).

C++ documentation:

Updates the size policy of the widget at position index to have a stretch factor of stretch.

stretch is not the effective stretch factor; the effective stretch factor is calculated by taking the initial size of the widget and multiplying it with stretch.

This function is provided for convenience. It is equivalent to

QWidget *widget = splitter->widget(index);
QSizePolicy policy = widget->sizePolicy();
policy.setHorizontalStretch(stretch);
policy.setVerticalStretch(stretch);
widget->setSizePolicy(policy);

See also setSizes() and widget().

`pub unsafe fn size_hint(&self) -> CppBox<QSize>`[src]

Reimplemented from QWidget::sizeHint().

Calls C++ function: virtual QSize QSplitter::sizeHint() const.

C++ documentation:

Reimplemented from QWidget::sizeHint().

`pub unsafe fn sizes(&self) -> CppBox<QListOfInt>`[src]

Returns a list of the size parameters of all the widgets in this splitter.

Calls C++ function: QList<int> QSplitter::sizes() const.

C++ documentation:

Returns a list of the size parameters of all the widgets in this splitter.

If the splitter's orientation is horizontal, the list contains the widgets width in pixels, from left to right; if the orientation is vertical, the list contains the widgets' heights in pixels, from top to bottom.

Giving the values to another splitter's setSizes() function will produce a splitter with the same layout as this one.

Note that invisible widgets have a size of 0.

See also setSizes().

`pub unsafe fn static_meta_object() -> Ref<QMetaObject>`[src]

Returns a reference to the staticMetaObject field.

`pub unsafe fn tr( s: const c_char, c: const c_char, n: c_int ) -> CppBox<QString>`[src]

Calls C++ function: static QString QSplitter::tr(const char* s, const char* c, int n).

`pub unsafe fn tr_utf8( s: const c_char, c: const c_char, n: c_int ) -> CppBox<QString>`[src]

Calls C++ function: static QString QSplitter::trUtf8(const char* s, const char* c, int n).

`pub unsafe fn widget(&self, index: c_int) -> QPtr<QWidget>`[src]

Returns the widget at the given index in the splitter's layout.

Calls C++ function: QWidget* QSplitter::widget(int index) const.

C++ documentation:

Returns the widget at the given index in the splitter's layout.

See also count(), handle(), indexOf(), and insertWidget().

Methods from Deref<Target = QFrame>

`pub unsafe fn frame_rect(&self) -> CppBox<QRect>`[src]

This property holds the frame's rectangle

Calls C++ function: QRect QFrame::frameRect() const.

C++ documentation:

This property holds the frame's rectangle

The frame's rectangle is the rectangle the frame is drawn in. By default, this is the entire widget. Setting the rectangle does does not cause a widget update. The frame rectangle is automatically adjusted when the widget changes size.

If you set the rectangle to a null rectangle (for example, QRect(0, 0, 0, 0)), then the resulting frame rectangle is equivalent to the widget rectangle.

Access functions:

QRect	frameRect() const
void	setFrameRect(const QRect &)

`pub unsafe fn frame_shadow(&self) -> Shadow`[src]

This property holds the frame shadow value from the frame style

Calls C++ function: QFrame::Shadow QFrame::frameShadow() const.

C++ documentation:

This property holds the frame shadow value from the frame style

Access functions:

Shadow	frameShadow() const
void	setFrameShadow(Shadow)

See also frameStyle() and frameShape().

`pub unsafe fn frame_shape(&self) -> Shape`[src]

This property holds the frame shape value from the frame style

Calls C++ function: QFrame::Shape QFrame::frameShape() const.

C++ documentation:

This property holds the frame shape value from the frame style

Access functions:

Shape	frameShape() const
void	setFrameShape(Shape)

See also frameStyle() and frameShadow().

`pub unsafe fn frame_style(&self) -> c_int`[src]

Returns the frame style.

Calls C++ function: int QFrame::frameStyle() const.

C++ documentation:

Returns the frame style.

The default value is QFrame::Plain.

See also setFrameStyle(), frameShape(), and frameShadow().

`pub unsafe fn frame_width(&self) -> c_int`[src]

This property holds the width of the frame that is drawn.

Calls C++ function: int QFrame::frameWidth() const.

C++ documentation:

This property holds the width of the frame that is drawn.

Note that the frame width depends on the frame style, not only the line width and the mid-line width. For example, the style specified by NoFrame always has a frame width of 0, whereas the style Panel has a frame width equivalent to the line width.

Access functions:

int	frameWidth() const

See also lineWidth(), midLineWidth(), and frameStyle().

`pub unsafe fn line_width(&self) -> c_int`[src]

This property holds the line width

Calls C++ function: int QFrame::lineWidth() const.

C++ documentation:

This property holds the line width

Note that the total line width for frames used as separators (HLine and VLine) is specified by frameWidth.

The default value is 1.

Access functions:

int	lineWidth() const
void	setLineWidth(int)

See also midLineWidth and frameWidth.

`pub unsafe fn meta_object(&self) -> Ptr<QMetaObject>`[src]

Calls C++ function: virtual const QMetaObject* QFrame::metaObject() const.

`pub unsafe fn mid_line_width(&self) -> c_int`[src]

This property holds the width of the mid-line

Calls C++ function: int QFrame::midLineWidth() const.

C++ documentation:

This property holds the width of the mid-line

The default value is 0.

Access functions:

int	midLineWidth() const
void	setMidLineWidth(int)

See also lineWidth and frameWidth.

`pub unsafe fn qt_metacall( &self, arg1: Call, arg2: c_int, arg3: mut mut c_void ) -> c_int`[src]

Calls C++ function: virtual int QFrame::qt_metacall(QMetaObject::Call arg1, int arg2, void** arg3).

`pub unsafe fn qt_metacast(&self, arg1: const c_char) -> mut c_void`[src]

Calls C++ function: virtual void* QFrame::qt_metacast(const char* arg1).

`pub unsafe fn set_frame_rect(&self, arg1: impl CastInto<Ref<QRect>>)`[src]

This property holds the frame's rectangle

Calls C++ function: void QFrame::setFrameRect(const QRect& arg1).

C++ documentation:

This property holds the frame's rectangle

The frame's rectangle is the rectangle the frame is drawn in. By default, this is the entire widget. Setting the rectangle does does not cause a widget update. The frame rectangle is automatically adjusted when the widget changes size.

If you set the rectangle to a null rectangle (for example, QRect(0, 0, 0, 0)), then the resulting frame rectangle is equivalent to the widget rectangle.

Access functions:

QRect	frameRect() const
void	setFrameRect(const QRect &)

`pub unsafe fn set_frame_shadow(&self, arg1: Shadow)`[src]

This property holds the frame shadow value from the frame style

Calls C++ function: void QFrame::setFrameShadow(QFrame::Shadow arg1).

C++ documentation:

This property holds the frame shadow value from the frame style

Access functions:

Shadow	frameShadow() const
void	setFrameShadow(Shadow)

See also frameStyle() and frameShape().

`pub unsafe fn set_frame_shape(&self, arg1: Shape)`[src]

This property holds the frame shape value from the frame style

Calls C++ function: void QFrame::setFrameShape(QFrame::Shape arg1).

C++ documentation:

This property holds the frame shape value from the frame style

Access functions:

Shape	frameShape() const
void	setFrameShape(Shape)

See also frameStyle() and frameShadow().

`pub unsafe fn set_frame_style(&self, arg1: c_int)`[src]

Sets the frame style to style.

Calls C++ function: void QFrame::setFrameStyle(int arg1).

C++ documentation:

Sets the frame style to style.

The style is the bitwise OR between a frame shape and a frame shadow style. See the picture of the frames in the main class documentation.

The frame shapes are given in QFrame::Shape and the shadow styles in QFrame::Shadow.

If a mid-line width greater than 0 is specified, an additional line is drawn for Raised or Sunken Box, HLine, and VLine frames. The mid-color of the current color group is used for drawing middle lines.

See also frameStyle().