在同一线程即处理界面的UI,又要处理加载对话框的paint事件，去显示正在加载，发现加载对话框显示不出来

最新推荐文章于 2025-08-11 07:35:41 发布
原创 最新推荐文章于 2025-08-11 07:35:41 发布 · 496 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文探讨了使用QTreeWidget实现实时目录树加载时的优化技巧。在主线程中，通过在for循环内调用QCoreApplication::processEvents()，有效地避免了UI阻塞，实现了平滑的加载体验。文章深入解析了事件处理机制，并提供了具体代码示例。

在用QTreeWidget实现目录树时，点击目录，逐级展开需要一个加载对话框，表明正在加载数据，此时主线程一直在for循环里添加下一级目录的子节点，导致没有工作线程去执行加载对话框的paintEvent的绘制，就没有加载效果出现。

如下程序代码：

在for循环里，添加        QCoreApplication::processEvents();//添加处理事件

每添加一次节点，就调 QCoreApplication::processEvents();去处理其他需要响应的事件，就如单核CPU,多线程正在使用时，每个线程只使用一段CPU的时间片，时间一到就会被切出去，而这里是通过事件消息循环，去处理其他事件的消息

void CLocalDirTreeWgt::UpdateLeftTree(QTreeWidgetItem *item)
{
    m_bLeftChange = true;
    Qt::CheckState cs = item->checkState(0);
    Qt::CheckState checkstate;

    FILE_NODE iteminfo = item->data(0, FILE_TYPE).value<FILE_NODE>();
    m_path = iteminfo.qFilePath;

    /*添加path路径文件*/
    QDir dir(m_path);          //遍历各级子目录
    if (ShowHiddenFolderAndFile() && ShowHiddenProtectedOSSystemFile())
    {
        dir.setFilter(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot | QDir::Hidden | QDir::System); //先过滤目录和文件
    }
    else if (ShowHiddenFolderAndFile())
    {
        dir.setFilter(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot | QDir::Hidden); //先过滤目录和文件
    }
    else if (ShowHiddenProtectedOSSystemFile())
    {
        dir.setFilter(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot | QDir::System); //先过滤目录和文件
    }
    else
    {
        dir.setFilter(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot); //先过滤目录和文件
    }

    dir.setSorting(QDir::DirsFirst);//优先显示目录
    QFileInfoList folder_list = dir.entryInfoList();   //获取当前所有目录


    FILE_NODE info;

    for (int i = 0; i != folder_list.size(); i++)         //自动递归添加各目录到上一级目录
    {
        QCoreApplication::processEvents();//添加处理事件

        QFileInfo folderinfo = folder_list.at(i);

        if (folderinfo.isDir() && !folderinfo.isSymLink())
        {
            QString namepath = folder_list.at(i).absoluteFilePath();    //获取路径

            QString name = folderinfo.fileName();      //获取目录名

            if (ChildWidgetItemIsCombinedTree(item, namepath))
            {
                continue;
            }

            info.bFolder = true;
            info.qFilePath = namepath;
            QVariant var;
            var.setValue(info);
            QTreeWidgetItem* childDirItem = new QTreeWidgetItem(QStringList() << name);

            QIcon icon = GetFolderFileIcon(namepath);
            childDirItem->setIcon(0, icon);
            childDirItem->setText(0, name);
            childDirItem->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable);
            childDirItem->setData(0, FILE_TYPE, var);

            if (cs == Qt::PartiallyChecked)
            {
                //checkstate = GetCheckStateFormLeftTree(namepath);
                //获取当前项item是否绑定了节点数据
                SELECT_TREE_NODE *selectItemNode = item->data(0, NODE_PTR).value<SELECT_TREE_NODE*>();
                if (NULL != selectItemNode)
                {
                    checkstate = GetWidgetItemState(selectItemNode, childDirItem);
                }

                childDirItem->setCheckState(0, checkstate);
            }
            else
            {
                childDirItem->setCheckState(0, cs);
            }

            item->addChild(childDirItem);              //将当前目录添加成path的子项    

            QString qstrpath = info.qFilePath;
            qstrpath.replace("/", "\\");
            bool bHaveSubDir = isHaveSubDir(qstrpath);
            if (bHaveSubDir)
            {
                QTreeWidgetItem * childChildItem = new QTreeWidgetItem;
                childChildItem->setText(0, FAKER_ITEM_TEXT);
                childDirItem->addChild(childChildItem);
            }
        }
        else
        {
            INT64 filesize = folderinfo.size();
            QString name2 = folderinfo.fileName();

            if (ChildWidgetItemIsCombinedTree(item, folderinfo.absoluteFilePath()))
            {
                continue;
            }

            info.bFolder = false;
            info.qFilePath = folderinfo.absoluteFilePath();
            QVariant var;
            var.setValue(info);

            QString filePath = folderinfo.filePath();
            filePath.replace("/", "\\");
            QIcon icon = GetFolderFileIcon(filePath);
            QTreeWidgetItem *fileWgtItem = new QTreeWidgetItem();
            fileWgtItem->setCheckState(0, Qt::Unchecked); //初始状态没有被选中
            fileWgtItem->setIcon(0, icon);
            fileWgtItem->setText(0, name2);
            fileWgtItem->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable);   //设置树形控件子项的属性
            fileWgtItem->setData(0, FILE_TYPE, var);
            if (cs == Qt::PartiallyChecked)
            {
                //获取当前项item是否绑定了节点数据
                SELECT_TREE_NODE *selectItemNode = item->data(0, NODE_PTR).value<SELECT_TREE_NODE*>();
                if (NULL != selectItemNode)
                {
                    checkstate = GetWidgetItemState(selectItemNode, fileWgtItem);
                }

                fileWgtItem->setCheckState(0, checkstate);
            }
            else
            {
                fileWgtItem->setCheckState(0, cs);
            }
            item->addChild(fileWgtItem);
            fileWgtItem->setHidden(true);
        }
    }    

}

//事件处理函数

void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags)
{
    QThreadData *data = QThreadData::current();
    if (!data->hasEventDispatcher())
        return;
    data->eventDispatcher.load()->processEvents(flags);
}

bool QWindowsGuiEventDispatcher::processEvents(QEventLoop::ProcessEventsFlags flags)
{
    const QEventLoop::ProcessEventsFlags oldFlags = m_flags;  //将原来的事件标记保留
    m_flags = flags;                  //存放新的事件标记
    const bool rc = QEventDispatcherWin32::processEvents(flags);  //处理新的事件标记
    m_flags = oldFlags;         //处理完后返回原来的事件标记
    return rc;
}

 

bool QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags flags)
{
    Q_D(QEventDispatcherWin32);

    if (!d->internalHwnd) {
        createInternalHwnd();
        wakeUp(); // trigger a call to sendPostedEvents()
    }

    d->interrupt = false;
    emit awake();

    bool canWait;
    bool retVal = false;
    bool seenWM_QT_SENDPOSTEDEVENTS = false;
    bool needWM_QT_SENDPOSTEDEVENTS = false;
    do {
        DWORD waitRet = 0;
        HANDLE pHandles[MAXIMUM_WAIT_OBJECTS - 1];
        QVarLengthArray<MSG> processedTimers;
        while (!d->interrupt) {
            DWORD nCount = d->winEventNotifierList.count();
            Q_ASSERT(nCount < MAXIMUM_WAIT_OBJECTS - 1);

            MSG msg;
            bool haveMessage;

            if (!(flags & QEventLoop::ExcludeUserInputEvents) && !d->queuedUserInputEvents.isEmpty()) {
                // process queued user input events
                haveMessage = true;
                msg = d->queuedUserInputEvents.takeFirst();
            } else if(!(flags & QEventLoop::ExcludeSocketNotifiers) && !d->queuedSocketEvents.isEmpty()) {
                // process queued socket events
                haveMessage = true;
                msg = d->queuedSocketEvents.takeFirst();
            } else {
                haveMessage = PeekMessage(&msg, 0, 0, 0, PM_REMOVE);
                if (haveMessage) {
                    if ((flags & QEventLoop::ExcludeUserInputEvents)
                        && ((msg.message >= WM_KEYFIRST
                             && msg.message <= WM_KEYLAST)
                            || (msg.message >= WM_MOUSEFIRST
                                && msg.message <= WM_MOUSELAST)
                            || msg.message == WM_MOUSEWHEEL
                            || msg.message == WM_MOUSEHWHEEL
                            || msg.message == WM_TOUCH
#ifndef QT_NO_GESTURES
                            || msg.message == WM_GESTURE
                            || msg.message == WM_GESTURENOTIFY
#endif
                            || msg.message == WM_CLOSE)) {
                        // queue user input events for later processing
                        d->queuedUserInputEvents.append(msg);
                        continue;
                    }
                    if ((flags & QEventLoop::ExcludeSocketNotifiers)
                        && (msg.message == WM_QT_SOCKETNOTIFIER && msg.hwnd == d->internalHwnd)) {
                        // queue socket events for later processing
                        d->queuedSocketEvents.append(msg);
                        continue;
                    }
                }
            }
            if (!haveMessage) {
                // no message - check for signalled objects
                for (int i=0; i<(int)nCount; i++)
                    pHandles[i] = d->winEventNotifierList.at(i)->handle();
                waitRet = MsgWaitForMultipleObjectsEx(nCount, pHandles, 0, QS_ALLINPUT, MWMO_ALERTABLE);
                if ((haveMessage = (waitRet == WAIT_OBJECT_0 + nCount))) {
                    // a new message has arrived, process it
                    continue;
                }
            }
            if (haveMessage) {
                // WinCE doesn't support hooks at all, so we have to call this by hand :(
                if (!d->getMessageHook)
                    (void) qt_GetMessageHook(0, PM_REMOVE, (LPARAM) &msg);

                if (d->internalHwnd == msg.hwnd && msg.message == WM_QT_SENDPOSTEDEVENTS) {
                    if (seenWM_QT_SENDPOSTEDEVENTS) {
                        // when calling processEvents() "manually", we only want to send posted
                        // events once
                        needWM_QT_SENDPOSTEDEVENTS = true;
                        continue;
                    }
                    seenWM_QT_SENDPOSTEDEVENTS = true;
                } else if (msg.message == WM_TIMER) {
                    // avoid live-lock by keeping track of the timers we've already sent
                    bool found = false;
                    for (int i = 0; !found && i < processedTimers.count(); ++i) {
                        const MSG processed = processedTimers.constData()[i];
                        found = (processed.wParam == msg.wParam && processed.hwnd == msg.hwnd && processed.lParam == msg.lParam);
                    }
                    if (found)
                        continue;
                    processedTimers.append(msg);
                } else if (msg.message == WM_QUIT) {
                    if (QCoreApplication::instance())
                        QCoreApplication::instance()->quit();
                    return false;
                }

               //在这里过滤事件，翻译，派发消息，去响应其他事件

                if (!filterNativeEvent(QByteArrayLiteral("windows_generic_MSG"), &msg, 0)) {
                    TranslateMessage(&msg);
                    DispatchMessage(&msg);
                }
            } else if (waitRet - WAIT_OBJECT_0 < nCount) {
                d->activateEventNotifier(d->winEventNotifierList.at(waitRet - WAIT_OBJECT_0));
            } else {
                // nothing todo so break
                break;
            }
            retVal = true;
        }

        // still nothing - wait for message or signalled objects
        canWait = (!retVal
                   && !d->interrupt
                   && (flags & QEventLoop::WaitForMoreEvents));
        if (canWait) {
            DWORD nCount = d->winEventNotifierList.count();
            Q_ASSERT(nCount < MAXIMUM_WAIT_OBJECTS - 1);
            for (int i=0; i<(int)nCount; i++)
                pHandles[i] = d->winEventNotifierList.at(i)->handle();

            emit aboutToBlock();
            waitRet = MsgWaitForMultipleObjectsEx(nCount, pHandles, INFINITE, QS_ALLINPUT, MWMO_ALERTABLE | MWMO_INPUTAVAILABLE);
            emit awake();
            if (waitRet - WAIT_OBJECT_0 < nCount) {
                d->activateEventNotifier(d->winEventNotifierList.at(waitRet - WAIT_OBJECT_0));
                retVal = true;
            }
        }
    } while (canWait);

    if (!seenWM_QT_SENDPOSTEDEVENTS && (flags & QEventLoop::EventLoopExec) == 0) {
        // when called "manually", always send posted events
        sendPostedEvents();
    }

    if (needWM_QT_SENDPOSTEDEVENTS)
        PostMessage(d->internalHwnd, WM_QT_SENDPOSTEDEVENTS, 0, 0);

    return retVal;
}

 

 

 

 

Qt处理密集时的相应保持：processEvents()函数
yl_abc的博客
02-11 4807
Qt主线程处理耗时操作时，由于时间太长导致界面处于“假死”状态，不再响应其它操作；在这种情况下一般会使用多线程，既在子线程中进行耗时操作，如果不想使用多线程，最简单的办法就是使用QApplication::processEvents()。
QEventLoop的高阶使用——在UI线程使用时过滤用户输入事件
jdljldsflj的专栏
09-08 4595
在网络编程中，往往有这种需求，给服务器发送命令1，然后等待服务器应答命令1，然后根据应答的结果判断是否需要发送命令2，命令3.....要求不卡顿界面。 伪代码： //发送命令1 syncSendData(command_1); //向服务器发送command_1 //命令1收到服务器的应答，发送命令2 syncSendData(command_2); //命令2收到服务器的应答，发送命令3 syncSendData(command_3); . ...
QT 绘画：在UI界面画图形 paintEvent 使用说明
Eric_
05-07 3826
在QT的UI界面上画图形需要步骤、方法、及注意事项 1）需要重写虚函数paintEvent （注意：若不在paintEvent函数中执行绘画操作，是无法显示的） 2）设置QPainter，下面是划线操作 QPainter paint(this); paint.setPen(QPen(Qt::black,3));//设置画笔为黑色，大小为3 ...
ElementUI树状表格按选择层级展开
我啥都不会
07-04 4353
实现的功能是按照选择的层级对树状表格进行展开。 效果如下图所示 不展开 展开一层 展开2层 下面放代码。 <el-select v-model="ExpandedNum" @change="handleExpandNumChange" placeholder="选择展开级别" size="mini" style="widt
Qt常见不合理写法导致崩溃
tim_e的博客
06-20 1429
Qt崩溃常见的原因
MFC消息机制+UI线程和工作线程+模式对话框原理
Jiangislogining的博客
10-21 6494
MFC消息机制，UI线程，工作线程，模式对话框原理，非模式对话框原理
c++中MFC消息机制，UI线程和工作线程，模式对话框原理
u011555996的博客
10-13 2128
c++
Application.DoEvents() 是 Windows Forms 提供的一个静态方法，用于强制 UI 线程处理当前消息队列中的所有待处理消息
最新发布
专注于前沿技术的探索与实践，热衷于从代码逻辑、架构设计到行业应用等多维度深挖技术本质。期待在技术之路上与你共同成长～
08-11 1064
你的代码中的 Application.DoEvents()在你的 ControlMonitor 类中，Application.DoEvents() 出现在 _MonitorHardWareStatus 方法的轮询循环中：csharp。3. Application.DoEvents() 在你的场景中的问题在你的 ControlMonitor 类中，Application.DoEvents() 用于 _MonitorHardWareStatus 轮询循环，结合 BeginInvoke 更新 UI。
VC++图形用户界面高级特效案例集
weixin_36427956的博客
05-12 797
MFC（Microsoft Foundation Classes）库为Windows平台上的C++开发者提供了一个面向对象的框架，用于快速开发GUI应用程序。在这一章，我们将探讨MFC的基础架构，包括它如何封装Windows API、MFC程序的基本组成部分以及如何通过MFC实现高效的事件处理和消息循环。在MFC（Microsoft Foundation Classes）库中，控件的绘制过程是由一系列的函数调用和消息传递机制构成的。对于自定义控件，理解绘制流程是至关重要的。
Qt QApplication::processEvents()作用
等风来的博客
01-29 4203
Qt QApplication::processEvents()作用
解决QProcess运行外部程序阻塞界面
weixin_43828438的博客
10-03 3518
以下例子QEventLoop可以防止QProcess运行外部程序使得界面阻塞 QProcess process; process.start(QString(cmd));//执行外部程序 QEventLoop loop; connect(&process,static_cast<void(QProcess::*)(int,QProcess::ExitStatus)>(&QProcess::finished), [=]() { .
react-native-popup-dialog实现通用加载层
举世武双的博客
01-20 1323
2019-01-20 加载层组件效果如图：       react-native-popup-dialog是一个很不错的对话框库，我借用它的遮盖层实现了加载层效果。 地址：https://github.com/jacklam718/react-native-popup-dialog/blob/master/README.md 使用demo代码: import React ...
QT中窗口刷新事件的学习总结(http://wuguangchao.spaces.live.com/blog/cns!6F7400464FEEC42A!144.entry)
热门推荐
向远处看的专栏
01-04 1万+
一．主要理解一下几个方法和属性：   1．QWidget * QScrollView::viewport () const 2．void QWidget::paintEvent ( QPaintEvent * ) [虚 保护] 3．void QWidget::repaint ( int x, int y, int w, int h, bool erase = TRU
QFileDialog 阻塞 windows QXmpp 解决方案
Jimmy的小黑屋
07-09 1660
背景 使用了 QXmpp 实现 IM，QXmpp 需要与 服务器保持联通，方法就是 ping。app 发送 ping 后固定时间内若没有收到响应，则认为服务器失连，则断开链接；同样，服务器发送 ping 给 client，固定时间内若没有收到响应，则认为 app 失联，则断开链接。 问题： 1、发送文件时，需要阻塞用户输入，因此选择 模态 显示 QFileDialog。 2、模态显示 ...
Qt3.2中的多线程编程
freshman_fantom_ywj的专栏
05-23 861
<br />Qt 作为一种基于 C++ 的跨平台 GUI 系统，能够提供给用户构造图形用户界面的强大功能。为了满足用户构造复杂图形界面系统的需求，Qt 提供了丰富的多线程编程支持。从 2.2 版本开始，Qt 主要从下面三个方面对多线程编程提供支持：一、构造了一些基本的与平台无关的线程类；二、提交用户自定义事件的 Thread-safe 方式；三、多种线程间同步机制，如信号量，全局锁。这些都给用户提供了极大的方便。不过，在某些情况下，使用定时器机制能够比利用 Qt 本身的多线程机制更方便地实现所需要
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值