vlcwidget.cpp

#include "vlcwidget.h"
#include "vlckits.h"

#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QFileDialog>
#include <QDebug>
#include <QMenu>
#include <QMenuBar>
#include <QGraphicsDropShadowEffect>


void CALLBACK TimeProc(HWND hwnd,UINT msg, UINT_PTR id, DWORD time);

VLCWidget::VLCWidget(QWidget *parent)
    : CFramelessWidget(parent)
{

    Qt::WindowFlags flags = windowFlags();


    setWindowFlags(flags);
    WINBOOL WINAPI EnableWindow(HWND hWnd,WINBOOL bEnable);
    p = new VLCkits(this);
    resize(1000,800);
    setWindowTitle("天空是蔚蓝色");


    QWidget *line = new QWidget(this);
    line->setFixedHeight(1); // 设置分隔线的高度
    line->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
    line->setStyleSheet("background-color: grey;"); // 设置分隔线的颜色

    //------------------------标题栏初始化----------------------------------
    QHBoxLayout *hlayout2 = new QHBoxLayout;
    hlayout2->setContentsMargins(0, 0, 0, 0);  // 去除内边距
    hlayout2->setSpacing(0);

    QPushButton *btr = new QPushButton(this);
    QPushButton *btf = new QPushButton(this);
    QPushButton *btc = new QPushButton(this);


    QPushButton *titlog = new QPushButton(this);
    titlog->setIcon(QIcon(":/playctrlBar/back.jpg"));
    titlog->setFixedSize(50, 50); // 增加按钮大小到 50x50
    titlog->setIconSize(QSize(45, 45)); // 增加图标大小为 45x45
    titlog->setStyleSheet("QPushButton {"
                          "background-color: transparent;"
                          "border: none;"
                          "margin: 0; padding: 0;"  // 添加：去除内边距和外边距
                          "}");

    // 创建一个文字标签
    QLabel *logoText = new QLabel("千纸鹤", this);
    logoText->setStyleSheet("QLabel { color: white; font-size: 14px; font-weight: bold; }");

    hlayout2->addWidget(titlog);
    hlayout2->addSpacing(5);
    hlayout2->addWidget(logoText);
    hlayout2->addStretch();
    hlayout2->addWidget(btr);
    hlayout2->addSpacing(20);
    hlayout2->addWidget(btf);
    hlayout2->addSpacing(20);
    hlayout2->addWidget(btc);
//    hlayout2->setContentsMargins(0, 0, 0, 0);


    btr->setIcon(QIcon(":/playctrlBar/min.svg"));
    btf->setIcon(QIcon(":/playctrlBar/normal.svg"));
    btc->setIcon(QIcon(":/playctrlBar/close.svg"));
    btr->setStyleSheet("QPushButton {"
                       "background-color: transparent;" // 设置背景颜色为透明
                       "border: none;"                  // 去除边框
                       "}");
    titlog->setStyleSheet("QPushButton {"
                          "background-color: transparent;" // 设置背景颜色为透明
                          "border: none;"                  // 去除边框
                          "}");
    this->setStyleSheet("QWidget {"
                        "background-color: black;"
                        "}");


    QVBoxLayout *vlayout = new QVBoxLayout(this);
    vlayout->setContentsMargins(0, 0, 0, 10); // 移除边距


    m_videoWidget = new QWidget(this);
    m_videoWidget->setStyleSheet("background-color: #202020;"); // 黑色背景
    m_videoWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

    bt1 = new QPushButton("打开文件", this);
    bt1->setStyleSheet("QPushButton {"
                       "background-color: transparent;" // 设置背景颜色为透明
                       "border: none;"                  // 去除边框
                       "color: white;"                  // 白色字体
                       "font: bold;"
                       "}");

    QPushButton *bt2 = new QPushButton(this);//播放/暂停视频
    QPushButton *bt4 = new QPushButton(this);//停止
    QPushButton *bt5 = new QPushButton(this);//切换到上一个视频
    QPushButton *bt6 = new QPushButton(this);//切换到下一个视频
    bt7 = new QPushButton(this);//全屏按钮

    bt1->setIcon(QIcon(":/playctrlBar/openfile_hover.svg"));
    bt2->setIcon(QIcon(":/playctrlBar/pause.svg"));
    bt4->setIcon(QIcon(":/playctrlBar/stop.svg"));
    bt5->setIcon(QIcon(":/playctrlBar/pre.svg"));
    bt6->setIcon(QIcon(":/playctrlBar/next.svg"));
    bt7->setIcon(QIcon(":/playctrlBar/fullscreen.svg"));

    //时间标签
    QLabel *timelab = new QLabel("00:00/00:00");
    timelab->setStyleSheet("QLabel {"
                           "color: white;"    // 设置标签的字体颜色为白色
                           "font: bold;"
                           "}");

    //音量按钮
    volumeBtn = new QPushButton(this);
    volumeBtn->setFixedSize(30, 30);
    volumeBtn->setIcon(QIcon(":/playctrlBar/audio_open.svg"));
    volumeBtn->setIconSize(QSize(24, 24));
    volumeBtn->setFlat(true); // 去除边框

    // 音量滑块（垂直方向）
    vslider = new QSlider(Qt::Vertical, this);
    vslider->setRange(0, 100);//设置范围
    vslider->setValue(30); // 默认音量
    vslider->setFixedHeight(180);
    vslider->setFixedWidth(45);   // 显式设置滑块宽度（使其更宽）
    vslider->setStyleSheet("QSlider::groove:vertical {"
                           "    background: #555;"
                           "    width: 8px;"
                           "}"
                           "QSlider::handle:vertical {"
                           "    background: white;"
                           "    height: 15px;"
                           "    width: 18px;"  // 新增：手柄宽度设置
                           "    margin: -8px 0;"
                           "    border-radius: 12px;"
                           "}");

    // 音量弹出窗口
    volumePopup = new QWidget(this);
    volumePopup->setFixedSize(vslider->width() -2, vslider->height() -2); // 只比滑块大一点点
    volumePopup->setStyleSheet("background-color: rgba(50, 50, 50, 200); border-radius: 6px;");
    volumePopup->setWindowFlags(Qt::Popup | Qt::FramelessWindowHint);
    volumePopup->setAttribute(Qt::WA_TranslucentBackground);
    volumePopup->installEventFilter(this); // 为音量弹出窗口安装事件过滤器

    QVBoxLayout *volumeLayout = new QVBoxLayout(volumePopup);
    // volumeLayout->setContentsMargins(5, 10, 5, 10);
    volumeLayout->setContentsMargins(0, 0, 0, 0); // 无内边距
    volumeLayout->setSpacing(0); // 无间距

    volumeLayout->addWidget(vslider);
    volumePopup->hide();


    QSlider *pslider = new QSlider(Qt::Horizontal,this);
    pslider->setValue(0);
    pslider->setRange(0, 100);
    pslider->setEnabled(false);
    pslider->setObjectName("progressSlider");
    // 设置进度条样式
    pslider->setStyleSheet(
                "QSlider::groove:horizontal {"
                "    background: transparent;"
                "    height: 6px;"
                "    border-radius: 3px;"
                "}"
                "QSlider::sub-page:horizontal {"
                "    background: #808080;"
                "    border-radius: 3px;"
                "}"
                "QSlider::add-page:horizontal {"
                "    background: rgba(255, 255, 255, 0.3);"
                "    border-radius: 3px;"
                "}"
                "QSlider::handle:horizontal {"
                "    background: white;"
                "    width: 16px;"
                "    height: 16px;"
                "    margin: -5px 0;"
                "    border-radius: 8px;"
                "}"
                );

    // 初始化播放列表相关
    m_playlistVisible = false;
    m_playlistWidget = new QListWidget(this);
    m_playlistWidget->setFixedWidth(200); // 设置播放列表宽度
    m_playlistWidget->setStyleSheet("QListWidget { background-color: rgba(0, 0, 0, 180); color: white; }"
                                    "QListWidget::item:selected { background-color: rgba(100, 100, 100, 200); }");
    m_playlistWidget->hide(); // 初始隐藏

    // 切换播放列表显示的按钮
    m_togglePlaylistBtn = new QPushButton(this);
    m_togglePlaylistBtn->setIcon(QIcon(":/playctrlBar/effect.svg"));
    m_togglePlaylistBtn->setStyleSheet("QPushButton { background-color: transparent; color: white; border: none; }");

    QHBoxLayout *mainhlayout = new QHBoxLayout;
    mainhlayout->addWidget(m_videoWidget,1);
    mainhlayout->addWidget(m_playlistWidget);

    // 添加循环模式标签
    QLabel *loopLabel = new QLabel(this);
    loopLabel->setText("列表循环");
    loopLabel->setObjectName("loopLabel");
    loopLabel->setFixedWidth(60);
    loopLabel->setStyleSheet("QLabel { color: white; }");

    // 让视频区域也能触发右键菜单
    m_videoWidget->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(m_videoWidget, &QWidget::customContextMenuRequested, this, [this](const QPoint &pos) {
        QPoint globalPos = m_videoWidget->mapToGlobal(pos);
        QPoint widgetPos = this->mapFromGlobal(globalPos);
        emit customContextMenuRequested(widgetPos);
    });

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    QHBoxLayout *hlayout1 = new QHBoxLayout;

    hlayout1->addSpacing(10);
    hlayout1->addWidget(timelab);//时间标签
    hlayout1->addStretch();
    hlayout1->addWidget(bt4);//停止
    hlayout1->addWidget(bt5);//上一个
    hlayout1->addWidget(bt2);//播放/暂停
    hlayout1->addWidget(bt6);//下一个
    hlayout1->addWidget(volumeBtn);//音量进度
    hlayout1->addStretch();
    hlayout1->addWidget(loopLabel);//播放模式
    hlayout1->addSpacing(10);
    hlayout1->addWidget(m_togglePlaylistBtn);//播放列表
    hlayout1->addSpacing(10);
    hlayout1->addWidget(bt7);//全屏按钮
    hlayout1->addSpacing(10);

    //整体布局
    vlayout->addLayout(hlayout2);
    vlayout->setSpacing(0);
    vlayout->addWidget(line);
    vlayout->addLayout(mainhlayout,1);
    vlayout->addWidget(pslider);//时间进度条
    vlayout->addLayout(hlayout1);

//==============================================================================================
    connect(bt1,&QPushButton::clicked,[=]{
        QStringList paths = QFileDialog::getOpenFileNames(this,
                                                          "",
                                                          "E:/QtTest/videos",
                                                          "(*.mp4)");

        if(!paths.isEmpty())
        {
            for(QString &path :paths)
            {
                path = QDir::toNativeSeparators(path);
            }
        }else{
            return;
        }

        // 保存文件列表并开始播放第一个
        m_mediaList = paths;
        m_currentIndex = 0;
        p->setVideoWidget(m_videoWidget);

        p->open(m_videoWidget, m_mediaList[m_currentIndex]);
        //设置音量默认值
        p->setVolume(p->getcurrvl(vslider->value()));


        pslider->setEnabled(true);
        SetTimer(NULL, 1, 300, TimeProc);
        //        vslider->setEnabled(true);

        bt1->hide();
        updatePlaylist();

    });

    // 标题栏控制窗口
    connect(btf, &QPushButton::clicked, this, [this]() {
        if (isMaximized())
            showNormal();
        else
            showMaximized();
    });
//    connect(btc, &QPushButton::clicked, this, &QWidget::close);
    connect(btr, &QPushButton::clicked, this, &QWidget::showMinimized);


    //功能按钮
    connect(bt2, &QPushButton::clicked, p, &VLCkits::play);
    connect(bt4, &QPushButton::clicked, p, &VLCkits::stop);
    connect(bt5, &QPushButton::clicked, this, &VLCWidget::playPrevious);  // 上一个
    connect(bt6, &QPushButton::clicked, this, &VLCWidget::playNext);      // 下一个
    connect(bt7, &QPushButton::clicked, this, &VLCWidget::toggleFullscreen);//全屏

    //音量
    connect(vslider, &QSlider::valueChanged, p, &VLCkits::setVolume);

    // 连接 VLCkits 的信号
    connect(p, &VLCkits::sigTimeSliderPos, pslider, &QSlider::setValue);
    connect(p, &VLCkits::sigTimeText, timelab, &QLabel::setText);
    connect(p, &VLCkits::sigVolumeSliderPos, vslider, &QSlider::setValue);

    // 连接媒体结束信号
    connect(p, &VLCkits::mediaEndReached, this, &VLCWidget::onMediaEndReached);

    //进度条
    connect(pslider, &QSlider::sliderPressed, [=]() {
        p->setUserSeeking(true);
        p->pauseTimer(); // 增加一个暂停定时器的接口
    });
    connect(pslider, &QSlider::sliderReleased, [=]() {
        p->setUserSeeking(false);
        p->setPosition(pslider->value());
        p->resumeTimer(); // 恢复定时器
    });

    // 连接播放列表按钮的信号
    connect(m_togglePlaylistBtn, &QPushButton::clicked, this, &VLCWidget::togglePlaylistVisibility);
    // 连接播放列表的双击信号
    connect(m_playlistWidget, &QListWidget::itemDoubleClicked, this, &VLCWidget::onPlaylistItemDoubleClicked);

    // 添加点击功能（例如显示关于对话框）
    connect(titlog, &QPushButton::clicked, this, [](){
        QMessageBox aboutBox;
        aboutBox.setWindowTitle("关于播放器");
        aboutBox.setText("<p style='font-size: 12pt; line-height: 150%;'>"
                         "<b>千纸鹤播放器</b><br>"
                         "版本: v1.0<br>"
                         "© 2025-08-13 <br><br>"
                         "<span style='color:#999; font-size: 9pt;'>开发技术: Qt VLC框架</span>"
                         "</p>");

        // 设置对话框样式
        aboutBox.setStyleSheet(
            "QMessageBox {"
            "   background-color: #202020;"  // 深灰背景
            "}"
            "QLabel {"
            "   color: #fff;"    // 白色文本
            "   margin: 15px;"   // 增加内容边距
            "}"
            "QPushButton {"
            "   background-color: #333;"
            "   color: white;"
            "   border: 1px solid #555;"
            "   border-radius: 4px;"
            "   padding: 5px 15px;"
            "   min-width: 80px;"
            "}"
            "QPushButton:hover {"
            "   background-color: #444;"
            "}"
        );

        aboutBox.exec();
    });

//==============================================================================================

//右键菜单栏-------------------------------------------------------------------------------------
    this->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(this, &QWidget::customContextMenuRequested, this, [this](const QPoint &pos) {
        QMenu menu;
        menu.addAction("打开文件", this, &VLCWidget::openFile);
        menu.addAction("显示播放列表", this, &VLCWidget::showPlaylist);
        menu.addAction("清空播放列表", this, [this]() {
            m_mediaList.clear();
            m_currentIndex = -1;
            updatePlaylist();
            bt1->show();
            p->stop();
        });
        menu.addAction("上一个", this, &VLCWidget::playPrevious);
        menu.addAction("下一个", this, &VLCWidget::playNext);
        menu.addAction("全屏", this, &VLCWidget::toggleFullscreen);
        menu.addAction("关闭", this, &QWidget::close);

        // 添加循环模式菜单
        QMenu *loopMenu = menu.addMenu("循环模式");
        QAction *noLoopAction = loopMenu->addAction("不循环");
        QAction *loopOneAction = loopMenu->addAction("单曲循环");
        QAction *loopAllAction = loopMenu->addAction("列表循环");
        QAction *randomAction = loopMenu->addAction("随机播放");
        // 设置当前选中状态
        noLoopAction->setCheckable(true);
        loopOneAction->setCheckable(true);
        loopAllAction->setCheckable(true);
        randomAction->setCheckable(true);
        noLoopAction->setChecked(m_currentLoopMode == VLCkits::NoLoop);
        loopOneAction->setChecked(m_currentLoopMode == VLCkits::LoopOne);
        loopAllAction->setChecked(m_currentLoopMode == VLCkits::LoopAll);
        randomAction->setChecked(m_currentLoopMode == VLCkits::Random);

        // 连接循环模式设置
        connect(noLoopAction, &QAction::triggered, this, [this]() {
            setLoopMode(VLCkits::NoLoop);
        });
        connect(loopOneAction, &QAction::triggered, this, [this]() {
            setLoopMode(VLCkits::LoopOne);
        });
        connect(loopAllAction, &QAction::triggered, this, [this]() {
            setLoopMode(VLCkits::LoopAll);
        });
        connect(randomAction, &QAction::triggered, this, [this]() {
            setLoopMode(VLCkits::Random);
        });


//        QAction *deleteAction = menu.addAction("删除");

//        // 如果没有选中项，禁用删除选项
//        if (m_playlistWidget->selectedItems().isEmpty()) {
//            deleteAction->setEnabled(false);
//        }

//        if (menu.exec(m_playlistWidget->mapToGlobal(pos)) == deleteAction) {
//            deleteSelectedItems();
//        }



        QString styleSheet = "QMenu {"
                             "background-color: #333;"
                             "color: white;"
                             "border: 1px solid #666;"
                             "}"
                             "QMenu::item {"
                             "padding: 5px 25px;"
                             "}"
                             "QMenu::item:selected {"
                             "background-color: #666;"
                             "}";
        menu.setStyleSheet(styleSheet);

        menu.exec(mapToGlobal(pos));
    });


    // 为播放列表添加上下文菜单
    m_playlistWidget->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(m_playlistWidget, &QListWidget::customContextMenuRequested,
            this, [this](const QPoint &pos) {
        QMenu menu;
        menu.setStyleSheet(
            "QMenu {"
            "   background-color: #333;"
            "   color: white;"
            "   border: 1px solid #555;"
            "   border-radius: 3px;"
            "}"
            "QMenu::item {"
            "   padding: 6px 20px;"
            "}"
            "QMenu::item:selected {"
            "   background-color: #555;"
            "}"
        );

        QAction *deleteAction = menu.addAction("删除");
        menu.addAction("添加", this, &VLCWidget::openFile);

        // 如果没有选中项，禁用删除选项
        if (m_playlistWidget->selectedItems().isEmpty()) {
            deleteAction->setEnabled(false);
        }

        if (menu.exec(m_playlistWidget->mapToGlobal(pos)) == deleteAction) {
            deleteSelectedItems();
        }
    });


//----------------------------------------------------------------------------------------------

    volumeBtn->installEventFilter(this);//添加事件过滤器

    loadPlaylist();//加载播放列表

//----------------------------------------------------------------------------------------------

    connect(btc, &QPushButton::clicked, this, [this]() {
        // 创建自定义对话框
        QDialog dialog(this);
        dialog.setWindowFlags(dialog.windowFlags() | Qt::FramelessWindowHint); // 无边框
        dialog.setAttribute(Qt::WA_TranslucentBackground); // 透明背景
        dialog.setFixedSize(300, 150);

        // 主容器（用于实现圆角和阴影）
        QWidget *container = new QWidget(&dialog);
        container->setStyleSheet(
            "QWidget {"
            "   background-color: #333;"
            "   border: 1px solid #555;"
            "   border-radius: 10px;"
            "}"
        );

//        // 添加阴影效果
//        QGraphicsDropShadowEffect *shadow = new QGraphicsDropShadowEffect();
//        shadow->setBlurRadius(15);
//        shadow->setColor(QColor(0, 0, 0, 150));
//        shadow->setOffset(0, 0);
//        container->setGraphicsEffect(shadow);

        QVBoxLayout *dialogLayout = new QVBoxLayout(&dialog);
        dialogLayout->addWidget(container);
        dialogLayout->setContentsMargins(15, 15, 15, 15); // 添加边距实现阴影效果

        // 容器内部布局
        QVBoxLayout *layout = new QVBoxLayout(container);
        layout->setContentsMargins(20, 20, 20, 20);
        layout->setSpacing(15);

        // 添加内容
        QHBoxLayout *messageLayout = new QHBoxLayout();
        QLabel *iconLabel = new QLabel();

        // 使用标准警告图标
        QPixmap warningIcon = style()->standardPixmap(QStyle::SP_MessageBoxWarning);
        iconLabel->setPixmap(warningIcon.scaled(40, 40, Qt::KeepAspectRatio, Qt::SmoothTransformation));

        messageLayout->addWidget(iconLabel);

        QLabel *textLabel = new QLabel("确定要退出程序吗？");
        textLabel->setStyleSheet("QLabel { color: white; font-size: 14px; font-weight: bold; }");
        messageLayout->addWidget(textLabel, 1); // 文本标签占据剩余空间
        messageLayout->setSpacing(15);

        layout->addLayout(messageLayout);

        // 添加按钮
        QHBoxLayout *buttonLayout = new QHBoxLayout();
        QPushButton *cancelButton = new QPushButton("取消");
        QPushButton *confirmButton = new QPushButton("确认");

        cancelButton->setFixedSize(80, 30);
        confirmButton->setFixedSize(80, 30);

        cancelButton->setStyleSheet(
            "QPushButton {"
            "   background-color: #444;"
            "   color: white;"
            "   border: 1px solid #555;"
            "   border-radius: 4px;"
            "}"
            "QPushButton:hover {"
            "   background-color: #555;"
            "}"
        );

        confirmButton->setStyleSheet(
            "QPushButton {"
            "   background-color: #d9534f;" // 红色按钮
            "   color: white;"
            "   border: 1px solid #d43f3a;"
            "   border-radius: 4px;"
            "}"
            "QPushButton:hover {"
            "   background-color: #c9302c;"
            "}"
        );

        buttonLayout->addStretch();
        buttonLayout->addWidget(cancelButton);
        buttonLayout->addSpacing(10);
        buttonLayout->addWidget(confirmButton);
        buttonLayout->addStretch();

        layout->addLayout(buttonLayout);

        // 连接按钮信号
        connect(cancelButton, &QPushButton::clicked, &dialog, &QDialog::reject);
        connect(confirmButton, &QPushButton::clicked, &dialog, &QDialog::accept);

        // 设置回车键触发确认按钮
        confirmButton->setDefault(true);

        // 显示对话框并等待用户选择
        if (dialog.exec() == QDialog::Accepted) {
            // 用户点击确认，关闭程序
            this->close();
        }
    });


}

VLCWidget::~VLCWidget()
{

}

//鼠标双击进入全屏
void VLCWidget::mouseDoubleClickEvent(QMouseEvent *event)
{
    Q_UNUSED(event);
    if(this->isFullScreen()) {
        this->showNormal();
//        bt7->show();
    } else{
        this->showFullScreen();
//        bt7->hide();
    }
}

//esc退出全屏
void VLCWidget::keyPressEvent(QKeyEvent *event)
{
    if(event->key() == Qt::Key_Escape) {
        this->showNormal();
    }
}

BOOL CALLBACK EnumVLC(HWND hwnd, LPARAM lParam)
{
    Q_UNUSED(lParam);
    TCHAR  szTitle[1024];

    int nLen = GetWindowText(hwnd, szTitle, 1024);
    if(nLen > 0)
    {
        EnableWindow(hwnd, FALSE);
        KillTimer(NULL, 1);
    }
    return TRUE;
}

void CALLBACK TimeProc(HWND hwnd,UINT msg, UINT_PTR id, DWORD time)
{
    Q_UNUSED(hwnd);
    Q_UNUSED(msg);
    Q_UNUSED(id);
    Q_UNUSED(time);
    HWND vlcHwnd = FindWindowEx(NULL,NULL,NULL, L"天空是蔚蓝色");

    if(vlcHwnd)
    {
        EnumChildWindows(vlcHwnd,EnumVLC ,NULL);
    }
}

//鼠标悬停音量按钮
bool VLCWidget::eventFilter(QObject *obj, QEvent *event)
{
    if (obj == volumeBtn) {
        if (event->type() == QEvent::Enter) {
            // 鼠标进入：显示音量弹窗
            QPoint pos = volumeBtn->mapToGlobal(QPoint(0, -volumePopup->height()));
            volumePopup->move(pos);
            volumePopup->show();
            return true;
        } else if (event->type() == QEvent::Leave) {
            // 鼠标离开：延迟隐藏（防止滑动时消失）
            QTimer::singleShot(500, this, [this]() {
                if (!volumePopup->underMouse()) {
                    volumePopup->hide();
                }
            });
            return true;
        }
    }

    // 处理滑块弹窗的悬停，防止立即消失
    if (obj == volumePopup || obj == vslider) {
        if (event->type() == QEvent::Enter) {
            volumePopup->show(); // 保持显示
            return true;
        } else if (event->type() == QEvent::Leave) {
            if (obj == volumePopup) {
                QTimer::singleShot(500, this, [this]() {
                    if (!volumePopup->underMouse()) {
                        volumePopup->hide();
                    }
                });
            }
            return true;
        }
    }
    return QWidget::eventFilter(obj, event);
}


void VLCWidget::updateCurrentFileName()
{
    if (m_currentIndex >= 0 && m_currentIndex < m_mediaList.size()) {
        QFileInfo info(m_mediaList[m_currentIndex]);
    }
}

//打开文件按钮位于中心
void VLCWidget::resizeEvent(QResizeEvent *event)
{
    QWidget::resizeEvent(event);

    // 确保 m_videoWidget 和 bt1 存在
    if (m_videoWidget && bt1) {
        // 计算 m_videoWidget 在父窗口中的全局位置和大小
        QRect videoRect = m_videoWidget->geometry();

        int btnX = videoRect.x() + (videoRect.width() - bt1->width()) / 2;
        int btnY = videoRect.y() + (videoRect.height() - bt1->height()) / 2;

        bt1->move(btnX, btnY);
    }
}

void VLCWidget::toggleFullscreen()
{
    if (this->isFullScreen()) {
        // 如果当前是全屏模式，则退出全屏
        this->showNormal();
    } else {
        // 如果当前不是全屏模式，则进入全屏
        this->showFullScreen();
//        bt7->hide();

    }
}

//-----------------------------------------------------------------------------
// 切换播放列表可见性
void VLCWidget::togglePlaylistVisibility()
{
    m_playlistVisible = !m_playlistVisible;
    m_playlistWidget->setVisible(m_playlistVisible);
}

// 双击播放列表项处理
void VLCWidget::onPlaylistItemDoubleClicked(QListWidgetItem *item)
{
    int row = m_playlistWidget->row(item);
    if (row >= 0 && row < m_mediaList.size()) {
        m_currentIndex = row;
        p->open(m_videoWidget, m_mediaList[m_currentIndex]);
        updateCurrentFileName();
        bt1->hide();
    }
}

// 更新播放列表显示
void VLCWidget::updatePlaylist()
{
    m_playlistWidget->clear();

//    if (m_mediaList.isEmpty()) {
//        // 添加提示信息
//        QListWidgetItem *item = new QListWidgetItem("播放列表为空");
//        item->setFlags(item->flags() & ~Qt::ItemIsEnabled); // 禁用项
//        item->setForeground(Qt::gray); // 灰色文本
//        m_playlistWidget->addItem(item);
//        return;
//    }

    for (int i = 0; i < m_mediaList.size(); ++i) {
        QFileInfo fileInfo(m_mediaList[i]);
        QString displayText = QString("%1. %2").arg(i + 1).arg(fileInfo.fileName());

        QListWidgetItem *item = new QListWidgetItem(displayText);
        if (i == m_currentIndex) {
            item->setBackground(QColor(100, 100, 100, 200)); // 当前播放项高亮
        }
        m_playlistWidget->addItem(item);
    }

    // 保存播放列表到文件
    savePlaylist();
}

//void VLCWidget::updatePlaylist()
//{
//    m_playlistWidget->clear();

//    // 获取当前选中的索引（在清除之前）
//    QList<int> selectedIndexes;
//    for (QListWidgetItem *item : m_playlistWidget->selectedItems()) {
//        selectedIndexes.append(m_playlistWidget->row(item));
//    }

//    for (int i = 0; i < m_mediaList.size(); ++i) {
//        QFileInfo fileInfo(m_mediaList[i]);
//        QString displayText = QString("%1. %2").arg(i + 1).arg(fileInfo.fileName());

//        QListWidgetItem *item = new QListWidgetItem(displayText);

//        // 设置当前播放项的高亮（使用深灰色）
//        if (i == m_currentIndex) {
//            item->setBackground(QColor(70, 70, 70, 200));
//        }

//        // 设置选中项的高亮（使用蓝色）
//        if (selectedIndexes.contains(i)) {
//            item->setBackground(QColor(65, 105, 225, 200)); // 皇家蓝色
//        }

//        m_playlistWidget->addItem(item);
//    }

//    // 重新应用选择状态
//    for (int index : selectedIndexes) {
//        if (index < m_playlistWidget->count()) {
//            m_playlistWidget->item(index)->setSelected(true);
//        }
//    }

//    // 保存播放列表到文件
//    savePlaylist();
//}




// 保存播放列表到文件
void VLCWidget::savePlaylist()
{
    QFile file("playlist.txt");
    if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        QTextStream out(&file);
        for (const QString &path : m_mediaList) {
            out << path << "\n";
        }
        file.close();
    }else{
        QFile::remove("playlst.txt");
    }
}

// 从文件加载播放列表
void VLCWidget::loadPlaylist()
{
    QFile file("playlist.txt");
    if (file.exists() && file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        m_mediaList.clear();
        QTextStream in(&file);
        while (!in.atEnd()) {
            QString path = in.readLine();
            if (!path.isEmpty() && QFile::exists(path)) {
                m_mediaList.append(path);
            }
        }
        file.close();

        if (!m_mediaList.isEmpty()) {
            m_currentIndex = 0;
            updatePlaylist();
        }
    }
}

void VLCWidget::openFile()
{
    QStringList paths = QFileDialog::getOpenFileNames(this,
                                                      "",
                                                      "E:/QtTest/videos",
                                                      "(*.mp4)");
    if(!paths.isEmpty())
    {
        if(m_mediaList.isEmpty())
        {
            m_currentIndex = 0;
        }

        for(QString &path :paths)
        {
            path = QDir::toNativeSeparators(path);
            // 添加到播放列表（如果不存在）
            if (!m_mediaList.contains(path)) {
                m_mediaList.append(path);
            }
        }
                updatePlaylist();

        // 如果当前没有在播放，开始播放第一个文件
        if (!p->isPlaying() && !m_mediaList.isEmpty()) {
//            m_currentIndex = 0;
            p->setVideoWidget(m_videoWidget);
            p->open(m_videoWidget, m_mediaList[m_currentIndex]);
            p->setVolume(p->getcurrvl(vslider->value()));
            SetTimer(NULL, 1, 300, TimeProc);
            bt1->hide();
        }

        // 更新播放列表显示
        updatePlaylist();
    }
}

void VLCWidget::playPrevious()
{
    if (m_mediaList.isEmpty()){
        openFile();
        return;
    }
    m_currentIndex = (m_currentIndex - 1 + m_mediaList.size()) % m_mediaList.size();
    p->open(m_videoWidget, m_mediaList[m_currentIndex]);
    updateCurrentFileName();
    updatePlaylist(); // 更新播放列表显示
}

void VLCWidget::playNext()
{
    if (m_mediaList.isEmpty()){
        openFile();
        return;}
    m_currentIndex = (m_currentIndex + 1) % m_mediaList.size();
    p->open(m_videoWidget, m_mediaList[m_currentIndex]);
    updateCurrentFileName();
    updatePlaylist(); // 更新播放列表显示
}

void VLCWidget::showPlaylist()
{
    if (!m_playlistVisible) {
        togglePlaylistVisibility();
    }
}

void VLCWidget::closeEvent(QCloseEvent *event)
{
    // 清空播放列表
    m_mediaList.clear();
    m_currentIndex = -1;

    // 保存空播放列表
    savePlaylist();

    // 停止播放
    if (p) {
        p->stop();
    }

    // 接受关闭事件
    event->accept();
}

void VLCWidget::onMediaEndReached()
{
    if (m_mediaList.isEmpty()) {
        return;
    }

    switch (m_currentLoopMode) {
    case VLCkits::LoopOne:
        // 单曲循环：重新播放当前视频
        p->open(m_videoWidget, m_mediaList[m_currentIndex]);
        break;

    case VLCkits::LoopAll:
        // 列表循环：播放下一个视频
        playNext();
        break;

    case VLCkits::NoLoop:
        // 不循环：停止播放
        p->stop();
        break;
    case VLCkits::Random:
        // 随机播放：随机选择一个视频
        if (m_mediaList.size() > 1) {
            int newIndex;
            do {
                newIndex = QRandomGenerator::global()->bounded(m_mediaList.size());
            } while (newIndex == m_currentIndex && m_mediaList.size() > 1);

            m_currentIndex = newIndex;
        }
        p->open(m_videoWidget, m_mediaList[m_currentIndex]);
        break;
    }
}

// 实现设置循环模式函数
void VLCWidget::setLoopMode(VLCkits::LoopMode mode)
{
    m_currentLoopMode = mode;
    p->setLoopMode(mode);

    updateLoopModeDisplay();
    // 更新状态栏显示当前循环模式
    // 这里可以添加状态栏更新代码
}

void VLCWidget::updateLoopModeDisplay()
{
    QLabel *loopLabel = findChild<QLabel*>("loopLabel");
    if (!loopLabel) return;

    switch (m_currentLoopMode) {
    case VLCkits::NoLoop:
        loopLabel->setText("不循环");
        break;
    case VLCkits::LoopOne:
        loopLabel->setText("单曲循环");
        break;
    case VLCkits::LoopAll:
        loopLabel->setText("列表循环");
        break;
    case VLCkits::Random:
        loopLabel->setText("随机播放");
        break;

    }
}

// 删除选中视频文件
void VLCWidget::deleteSelectedItems()
{
    // 获取所有选中项
    QList<QListWidgetItem*> selectedItems = m_playlistWidget->selectedItems();
    if (selectedItems.isEmpty()) return;

    // 从后往前删除（避免索引变化导致问题）
    QList<int> indexes;
    for (QListWidgetItem *item : selectedItems) {
        indexes.append(m_playlistWidget->row(item));
    }

    // 排序索引（从大到小）
    std::sort(indexes.begin(), indexes.end(), std::greater<int>());

    // 记录删除前是否正在播放
    bool wasPlaying = (m_currentIndex >= 0) && p->isPlaying();
    int oldCurrentIndex = m_currentIndex;

    // 删除项
    for (int index : indexes) {
        // 如果删除的是当前播放项，停止播放
        if (index == m_currentIndex) {
            p->stop();
            m_currentIndex = -1;
        }

        // 从列表中移除
        m_mediaList.removeAt(index);

        // 调整当前播放索引
        if (m_currentIndex > index) {
            m_currentIndex--;
        }
    }

    // 更新播放列表显示
    updatePlaylist();

    // 如果播放列表为空，显示打开文件按钮
    if (m_mediaList.isEmpty()) {
        bt1->show();
        return; // 列表已空，直接返回
    }

    // 处理播放逻辑
    if (m_currentIndex == -1) {
        // 当前播放项被删除，需要选择新项播放
        if (oldCurrentIndex < m_mediaList.size()) {
            // 如果原位置后面还有文件，播放原位置的文件（即下一个文件）
            m_currentIndex = oldCurrentIndex;
        } else {
            // 如果删除的是最后一个，播放第一个
            m_currentIndex = 0;
        }
        p->open(m_videoWidget, m_mediaList[m_currentIndex]);

        // 恢复播放状态
        if (wasPlaying) {
            p->play();
        }
    }
    else if (wasPlaying) {
        // 确保播放没有被意外停止
        p->play();
    }
}