Flickering when resizing window from left side QT

Question

I'm aware that have some similar questions about this topic, but I couldn't find one relative to a window being created using Qt.

I tried all suggestions in this answer: How to smooth ugly jitter/flicker/jumping when resizing windows, especially dragging left/top border (Win 7-10; bg, bitblt and DWM)?

• Modifying WM_WINDOWPOSCHANGING flag to SWP_NOCOPYBITS

       wp = reinterpret_cast<tagWINDOWPOS*>(msg->lParam);
       wp->flags |= SWP_NOCOPYBITS;

• Returning WVR_VALIDRECTS in WM_NCCALCSIZE

        if (msg->wParam == 1)
            return WVR_VALIDRECTS;

• Applying CS_HREDRAW | CS_VREDRAW styles to the window

SetWindowLongPtr(HWND(winId()), GWL_STYLE, CS_HREDRAW | CS_VREDRAW | WS_POPUPWINDOW | WS_CAPTION | WS_SIZEBOX | WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_CLIPCHILDREN);

• Apply the exstyle WS_EX_COMPOSITED
• WM_ERASEBKGND to return 1;

But the flicker persists. What else I could try?

The goal is to create a window without a caption, that can be resized/minimized.

The code below is working the problem is when the window is being resized from left/top it causes flickering.

//.h
#include <QtWidgets/QMainWindow>
#include <Windows.h>

class MainWindow : public QMainWindow
{
    Q_OBJECT


public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
    void Frameless()
    {
        // set flags that will override what Qt does, especially with the Qt::FramelessWindowHint which essentially disables WS_SIZEBOX/WS_THICKFRAME
        SetWindowLongPtr(HWND(winId()), GWL_STYLE, WS_POPUPWINDOW | WS_CAPTION | WS_SIZEBOX | WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_CLIPCHILDREN);
    }

private:
    Ui::MainWindowClass ui;

protected:
    virtual bool nativeEvent(const QByteArray& eventType, void* message, qintptr* result) override;

};

//.cpp
#include "MainWindow.h"


MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    ui.setupUi(this);
    Frameless();
    return;
}

MainWindow::~MainWindow()
{}

bool MainWindow::nativeEvent(const QByteArray& eventType, void* message, qintptr* result)
{

    MSG* msg = static_cast<MSG*>(message);

    switch (msg->message)
    {
    case WM_WINDOWPOSCHANGING:
    {
        tagWINDOWPOS* wp;
        wp = reinterpret_cast<tagWINDOWPOS*>(msg->lParam);
        wp->flags |= SWP_NOCOPYBITS;
    }
    break;

    case WM_NCCALCSIZE:
    {
        if (msg->wParam == 1)
            return WVR_VALIDRECTS;

        // Just return 0 and mark event as handled. This will draw the widget contents
        // into the full size of the frame, instead of leaving room for it.
        *result = 0;
        
        return true;
    }
    break;

    case WM_NCHITTEST:
    {
        if (isMaximized())
        {
            return false;
        }

        *result = 0;
        const LONG borderWidth = 8;
        RECT winrect;
        GetWindowRect(reinterpret_cast<HWND>(winId()), &winrect);

        // must be short to correctly work with multiple monitors (negative coordinates)
        short x = msg->lParam & 0x0000FFFF;
        short y = (msg->lParam & 0xFFFF0000) >> 16;

        bool resizeWidth = minimumWidth() != maximumWidth();
        bool resizeHeight = minimumHeight() != maximumHeight();
        if (resizeWidth)
        {
            //left border
            if (x >= winrect.left && x < winrect.left + borderWidth)
            {
                *result = HTLEFT;
            }
            //right border
            if (x < winrect.right && x >= winrect.right - borderWidth)
            {
                *result = HTRIGHT;
            }
        }
        if (resizeHeight)
        {
            //bottom border
            if (y < winrect.bottom && y >= winrect.bottom - borderWidth)
            {
                *result = HTBOTTOM;
            }
            //top border
            if (y >= winrect.top && y < winrect.top + borderWidth)
            {
                *result = HTTOP;
            }
        }
        if (resizeWidth && resizeHeight)
        {
            //bottom left corner
            if (x >= winrect.left && x < winrect.left + borderWidth &&
                y < winrect.bottom && y >= winrect.bottom - borderWidth)
            {
                *result = HTBOTTOMLEFT;
            }
            //bottom right corner
            if (x < winrect.right && x >= winrect.right - borderWidth &&
                y < winrect.bottom && y >= winrect.bottom - borderWidth)
            {
                *result = HTBOTTOMRIGHT;
            }
            //top left corner
            if (x >= winrect.left && x < winrect.left + borderWidth &&
                y >= winrect.top && y < winrect.top + borderWidth)
            {
                *result = HTTOPLEFT;
            }
            //top right corner
            if (x < winrect.right && x >= winrect.right - borderWidth &&
                y >= winrect.top && y < winrect.top + borderWidth)
            {
                *result = HTTOPRIGHT;
            }
        }

        if (*result != 0)
            return true;

        QWidget *action = QApplication::widgetAt(QCursor::pos());
        if (action == this){
            *result = HTCAPTION;
            return true;
        }

        return false;
    }
    break;

    default:
        return QWidget::nativeEvent(eventType, message, result);
    }


    return QWidget::nativeEvent(eventType, message, result);
}

EDIT

I was testing the GUI compiling the project as debug when I changed to release the flicker reduced a lot but still persists, and now it flickers from the right instead of the left.

Testing with QT 6.3.1 static debug:

https://www.youtube.com/watch?v=a5fmXKsKDaY&feature=youtu.be

Testing with QT 6.3.1 static release:

https://www.youtube.com/watch?v=OwpxmCsLLRQ

Computer settings, os version: https://i.stack.imgur.com/3DXmd.png

I tested on two different machines using win10, and the flicker happens on both.

The same issue happens with the frameless.h from jdfa answer, the difference is that my method the GUI resizing is way more 'smoothly'/fast.

Answer 1

I would suggest to avoid this kind of mix of Qt and WinAPI. Not only it is not portable, but it is also produce your issue.

This problem can be avoided by solving original task (frameless resizeble window) in Qt way by using Qt::FramelessWindowHint. Unfortunately, resizing functionality will be lost together with frame in that case. So you need to reimplement it by overriding mouse event handlers (mousePressEvent, mouseMoveEvent). You are basically doing similar thing already, just using WinAPI.

That problem is already solved here: https://gist.github.com/Nico-Duduf/b8c799f1f2a694732abd1238843b1d70

Here is my result with it: https://i.imgur.com/ovbG2hI.mp4

Edit: here is how I tested it:

#include <QApplication>

#include <QtWidgets/QMainWindow>

#include "FrameLess.h"

class MainWindow : public QMainWindow {
public:
    MainWindow(QWidget* parent = nullptr)
        : QMainWindow(parent)
    {
        setStyleSheet("border-image:url(\"bg.png\");");
    }
};

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);

    MainWindow main;
    FrameLess f(&main);
    main.show();

    return app.exec();
}

Answer 2

I created a project in 6.4 that doesn't have the jittery effect you describe and showed in the video. I tested it on windows 10.

Please create a folder, let's call it TestImage, and save the following files:

main.cpp

#include "mainwindow.h"

#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
 Qt::WindowFlags flags;
 flags = Qt::Window;
 //flags |= Qt::FramelessWindowHint;
 flags |= Qt::CustomizeWindowHint;
 this->setWindowFlags(flags);
}

MainWindow::~MainWindow()
{
    delete ui;
}

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private:
    Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H

TestImage.pro

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

CONFIG += c++17

# You can make your code fail to compile if it uses deprecated APIs.
# In order to do so, uncomment the following line.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

SOURCES += \
    main.cpp \
    mainwindow.cpp

HEADERS += \
    mainwindow.h

FORMS += \
    mainwindow.ui

# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

RESOURCES += \
    resources.qrc

earth.jpeg (save the image in the same folder)

resources.qrc

<RCC>
    <qresource prefix="/image">
        <file>earth.jpeg</file>
    </qresource>
</RCC>

mainwindow.ui

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>MainWindow</class>
 <widget class="QMainWindow" name="MainWindow">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>2068</width>
    <height>1599</height>
   </rect>
  </property>
  <property name="sizePolicy">
   <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
    <horstretch>0</horstretch>
    <verstretch>0</verstretch>
   </sizepolicy>
  </property>
  <property name="windowTitle">
   <string>MainWindow</string>
  </property>
  <widget class="QWidget" name="centralwidget">
   <layout class="QGridLayout" name="gridLayout_2">
    <item row="0" column="0">
     <layout class="QGridLayout" name="gridLayout">
      <property name="sizeConstraint">
       <enum>QLayout::SetNoConstraint</enum>
      </property>
      <item row="0" column="0">
       <widget class="QLabel" name="label">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Ignored" vsizetype="Ignored">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string/>
        </property>
        <property name="pixmap">
         <pixmap resource="resources.qrc">:/image/earth.jpeg</pixmap>
        </property>
        <property name="scaledContents">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <widget class="QMenuBar" name="menubar">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>2068</width>
     <height>22</height>
    </rect>
   </property>
  </widget>
  <widget class="QStatusBar" name="statusbar"/>
 </widget>
 <resources>
  <include location="resources.qrc"/>
 </resources>
 <connections/>
</ui>

Answer 3

Probably you only need to modify processing the WM_NCCALCSIZE message as follows. Perhaps it looks strange, but give it a try. It seems that when you return HTLEFT, HTTOP etc from WM_NCHITTEST, then the system expects that the first rect in NCCALCSIZE_PARAMS.rgrc contains the client area, as if there were borders. I've used this solution several times and it worked on all Windows versions I've tried so far.

case WM_NCCALCSIZE:
{
    if (msg->wParam == 1)
    {
        NCCALCSIZE_PARAMS& pms = *(NCCALCSIZE_PARAMS*)msg->lParam;
        RECT& r = pms.rgrc[0];

        int borderWidth = GetSystemMetrics(SM_CXSIZEFRAME);
        int borderHeight = GetSystemMetrics(SM_CYSIZEFRAME);
        r.left += borderWidth;
        r.top += borderHeight;
        r.right -= borderWidth;
        r.bottom -= borderHeight;

        *result = WVR_VALIDRECTS;
        return true;
    }

    // Just return 0 and mark event as handled. This will draw the widget contents
    // into the full size of the frame, instead of leaving room for it.
    *result = 0;
    return true;
}
break;