qframe | Immutable data frame for Go | Functional Programming library

The time.sleep will block the event-loop, so any GUI-related operations will be suspended until it finishes. You therefore need to explicitly force processing of any pending events, using processEvents:

The main problem with your example is that it does not set a layout on either the HolderCalendar widget or the PromoteCalendar widget. The QUiLoader.load function returns a completely separate widget which will not resize along with the top-level window unless it's contained within the main layout hierarchy. The two classes should therefore be re-written as follows:

I have found the solution. This is the new main loop:

Qt style sheets (QSS) don't provide such a feature, as it's only possible to style specific widgets without being able to consider their position within the layout. This is important in your case, as what you want to do is draw the "separation" between layout items.

It is theoretically possible to achieve this by setting a background for the container widget that will be the line color, have all its child widgets drawing their full contents with opaque colors, and ensure that the layout always has a spacing equal to the width of the line, but if the inner widgets don't respect their full size, they use an alpha channel, or some stretch or further spacing is added, the result would be ugly.

One possibility is to use a QWidget subclass, override its paintEvent() and draw those lines with QPainter.

The idea is that we cycle through all layout items, and draw lines that are placed in the middle between the "current" item and the previous.

In the following example I've created a basic QWidget subclass that implements the above concept, depending on the layout used.

Note that I had to make some changes and corrections to your original code:

• as already noted in comments, an existing QApplication is mandatory to allow the creation of a QWidget, and while it's possible to make it an attribute of the object (before calling the super().__init__()), it is still conceptually wrong;
• highly hierarchical structures in grid layouts should not use individual rows and columns for their direct child objects, but proper sub-layouts or child widgets should be added instead; in your case, the should be only two rows and columns: the header will have a 2-column-span in the first row, the menu will be on the second row (index 1) and first column, the right side in the second column, and the menu buttons will have their own layout;
• setting generic style sheet properties for parent widgets is highly discouraged, as complex widgets (such as QComboBox, QScrollBar and scroll areas children) require that all properties are set to properly work; using setStyleSheet('background: ...') should always be avoided for parents or the application;
• style sheets that are shared among many widgets should be set on the parent or the application, and proper selectors should always be used;
• the QSS width property should be used with care, as it could make widgets partially invisible and unusable;
• if you don't want any border, just use border: none;;
• only absolute units are supported for style sheet sizes (see the Length property type), percent values are ignored;
• setting fixed heights, paddings and margins can result in unexpected behavior; ensure that you carefully read the box model and do some testing to understand its behavior;
• classes should not show themselves automatically during construction, so show() should not be called within the __init__() (this is not specifically "forbidden" or discouraged, but it's still good practice);
• an if __name__ == '__main__': block should always be used, especially when dealing with programs or toolkits that rely on event loops (like all UI frameworks, as Qt is);

Here is a rewriting of your original code:

You must set a layout on chartframe, and then add chartView to that layout:

Probably the best way to do this is to use QDir.addSearchPath, which would allow you to use a simple alias in your stylesheet like this:

The main problem is that a widget can only have one layout manager, and it's not possible to set another layout if one already exists. It should also not be responsibility of a child widget to set the layout on a parent.

Another important aspect is that box layouts do not allow overlapping widgets, so the only solution is to use a grid layout and specify the span depending on how the overlapping widgets should be placed.

Considering the above, there are two possibilities: use the grid layout on the widget containing the buttons and add the labels on top of them, or the other way around. In the following example, I'm doing the latter. Note that in this case the widget with the labels will not be the child, but the parent.

The main problem with your attempt with the animation is that you created it as a local variable: as soon as handle_settings returns, the animation gets garbage collected (deleted) and nothing else will happen.

Unfortunately, that won't be enough, as there are other problems.

First of all, your code as some problems from the point of view of object structure: both Settings and LeftMenu classes are not really used, as you're actually using the widgets created in their __init__. Not only this is conceptually wrong, but it also makes your code unnecessarily convoluted and difficult to deal with.

Then there's another issue: showing a previously hidden widget makes its parent layout to instantly resize all other widgets (and nested layout, if any) based on the size of the newly shown widget, and the fact that you are trying to manually set the geometry doesn't change anything, as the layout is not affected by manual geometry changes.

The solution (besides properly structuring the classes) is to use the fixed width of the submenu for the animation, and manually set the geometry of the layout along with it.

Note that this doesn't consider the possibility of a resizable submenu, which would make things much more complex, as the animation should account for the size hints of all other sibling widgets to properly set the end value for the geometry. In this case, I only used the fixed width suggested in the provided example.

Both setStartValue and setEndValue won't "clear" the current animation, but only set new states for the start and beginnig, while leaving all other nested objects.

In order to update the current animation and reset all its keys, you need to clear the existing mapping by using setKeyValues() with an empty mapping.

This is a possible solution: