| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the documentation of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:FDL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Free Documentation License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Free |
| ** Documentation License version 1.3 as published by the Free Software |
| ** Foundation and appearing in the file included in the packaging of |
| ** this file. Please review the following information to ensure |
| ** the GNU Free Documentation License version 1.3 requirements |
| ** will be met: https://www.gnu.org/licenses/fdl-1.3.html. |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| /*! |
| \example widgets/windowflags |
| \title Window Flags Example |
| \ingroup examples-widgets |
| \brief The Window Flags example shows how to use the window flags |
| available in Qt. |
| |
| A window flag is either a type or a hint. A type is used to |
| specify various window-system properties for the widget. A widget |
| can only have one type, and the default is Qt::Widget. However, a |
| widget can have zero or more hints. The hints are used to |
| customize the appearance of top-level windows. |
| |
| A widget's flags are stored in a Qt::WindowFlags type which stores |
| an OR combination of the flags. |
| |
| \borderedimage windowflags-example.png |
| \caption Screenshot of the Window Flags example |
| |
| The example consists of two classes: |
| |
| \list |
| \li \c ControllerWindow is the main application widget that allows |
| the user to choose among the available window flags, and displays |
| the effect on a separate preview window. |
| \li \c PreviewWindow is a custom widget displaying the name of |
| its currently set window flags in a read-only text editor. |
| \endlist |
| |
| We will start by reviewing the \c ControllerWindow class, then we |
| will take a look at the \c PreviewWindow class. |
| |
| \section1 ControllerWindow Class Definition |
| |
| \snippet widgets/windowflags/controllerwindow.h 0 |
| |
| The \c ControllerWindow class inherits QWidget. The widget allows |
| the user to choose among the available window flags, and displays |
| the effect on a separate preview window. |
| |
| We declare a private \c updatePreview() slot to refresh the |
| preview window whenever the user changes the window flags. |
| |
| We also declare several private functions to simplify the |
| constructor: We call the \c createTypeGroupBox() function to |
| create a radio button for each available window type, using the |
| private \c createButton() function, and gather them within a group |
| box. In a similar way we use the \c createHintsGroupBox() function |
| to create a check box for each available hint, using the private |
| \c createCheckBox() function. |
| |
| In addition to the various radio buttons and checkboxes, we need |
| an associated \c PreviewWindow to show the effect of the currently |
| chosen window flags. |
| |
| \image windowflags_controllerwindow.png Screenshot of the Controller Window |
| |
| \section1 ControllerWindow Class Implementation |
| |
| \snippet widgets/windowflags/controllerwindow.cpp 0 |
| |
| In the constructor we first create the preview window. Then we |
| create the group boxes containing the available window flags using |
| the private \c createTypeGroupBox() and \c createHintsGroupBox() |
| functions. In addition we create a \uicontrol Quit button. We put the |
| button and a stretchable space in a separate layout to make the |
| button appear in the \c WindowFlag widget's right bottom corner. |
| |
| Finally, we add the button's layout and the two goup boxes to a |
| QVBoxLayout, set the window title and refresh the preview window |
| using the \c updatePreview() slot. |
| |
| \snippet widgets/windowflags/controllerwindow.cpp 1 |
| \snippet widgets/windowflags/controllerwindow.cpp 2 |
| |
| The \c updatePreview() slot is called whenever the user changes |
| any of the window flags. First we create an empty Qt::WindowFlags |
| \c flags, then we determine which one of the types that is checked |
| and add it to \c flags. |
| |
| \snippet widgets/windowflags/controllerwindow.cpp 3 |
| |
| We also determine which of the hints that are checked, and add |
| them to \c flags using an OR operator. We use \c flags to set the |
| window flags for the preview window. |
| |
| \snippet widgets/windowflags/controllerwindow.cpp 4 |
| |
| We adjust the position of the preview window. The reason we do |
| that, is that playing around with the window's frame may on some |
| platforms cause the window's position to be changed behind our |
| back. If a window is located in the upper left corner of the |
| screen, parts of the window may not be visible. So we adjust the |
| widget's position to make sure that, if this happens, the window |
| is moved within the screen's boundaries. Finally, we call |
| QWidget::show() to make sure the preview window is visible. |
| |
| \omit |
| \skipto pos |
| \printuntil /^\}/ |
| \endomit |
| |
| \snippet widgets/windowflags/controllerwindow.cpp 5 |
| |
| The private \c createTypeGroupBox() function is called from the |
| constructor. |
| |
| First we create a group box, and then we create a radio button |
| (using the private \c createRadioButton() function) for each of |
| the available types among the window flags. We make Qt::Window the |
| initially applied type. We put the radio buttons into a |
| QGridLayout and install the layout on the group box. |
| |
| We do not include the default Qt::Widget type. The reason is that |
| it behaves somewhat different than the other types. If the type is |
| not specified for a widget, and it has no parent, the widget is a |
| window. However, if it has a parent, it is a standard child |
| widget. The other types are all top-level windows, and since the |
| hints only affect top-level windows, we abandon the Qt::Widget |
| type. |
| |
| \snippet widgets/windowflags/controllerwindow.cpp 6 |
| |
| The private \c createHintsGroupBox() function is also called from |
| the constructor. |
| |
| Again, the first thing we do is to create a group box. Then we |
| create a checkbox, using the private \c createCheckBox() function, |
| for each of the available hints among the window flags. We put the |
| checkboxes into a QGridLayout and install the layout on the group |
| box. |
| |
| \snippet widgets/windowflags/controllerwindow.cpp 7 |
| |
| The private \c createCheckBox() function is called from \c |
| createHintsGroupBox(). |
| |
| We simply create a QCheckBox with the provided text, connect it to |
| the private \c updatePreview() slot, and return a pointer to the |
| checkbox. |
| |
| \snippet widgets/windowflags/controllerwindow.cpp 8 |
| |
| In the private \c createRadioButton() function it is a |
| QRadioButton we create with the provided text, and connect to the |
| private \c updatePreview() slot. The function is called from \c |
| createTypeGroupBox(), and returns a pointer to the button. |
| |
| \section1 PreviewWindow Class Definition |
| |
| \snippet widgets/windowflags/previewwindow.h 0 |
| |
| The \c PreviewWindow class inherits QWidget. It is a custom widget |
| that displays the names of its currently set window flags in a |
| read-only text editor. It is also provided with a QPushbutton that |
| closes the window. |
| |
| We reimplement the constructor to create the \uicontrol Close button and |
| the text editor, and the QWidget::setWindowFlags() function to |
| display the names of the window flags. |
| |
| \image windowflags_previewwindow.png Screenshot of the Preview Window |
| |
| \section1 PreviewWindow Class Implementation |
| |
| \snippet widgets/windowflags/previewwindow.cpp 0 |
| |
| In the constructor, we first create a QTextEdit and make sure that |
| it is read-only. |
| |
| We also prohibit any line wrapping in the text editor using the |
| QTextEdit::setLineWrapMode() function. The result is that a |
| horizontal scrollbar appears when a window flag's name exceeds the |
| width of the editor. This is a reasonable solution since we |
| construct the displayed text with built-in line breaks. If no line |
| breaks were guaranteed, using another QTextEdit::LineWrapMode |
| would perhaps make more sense. |
| |
| Then we create the \uicontrol Close button, and put both the widgets |
| into a QVBoxLayout before we set the window title. |
| |
| \snippet widgets/windowflags/previewwindow.cpp 1 |
| |
| In our reimplementation of the \c setWindowFlags() function, we |
| first set the widgets flags using the QWidget::setWindowFlags() |
| function. Then we run through the available window flags, creating |
| a text that contains the names of the flags that matches the \c |
| flags parameter. Finally, we display the text in the widgets text |
| editor. |
| */ |