categorybox.cpp

#include "categorybox.h"
#include "ui_categorybox.h"

#include <QDragEnterEvent>
#include <QDropEvent>
#include <QMimeData>
#include <QUrl>
#include <QFileInfo>
#include <QIcon>
#include <QFileIconProvider>
#include <QToolButton>
#include <QPoint>
#include <QPixmap>
#include <QStyle>
#include <QPaintEvent>
#include <QPainter>
#include <QPalette>
#include <QScrollBar>
#include <QMimeDatabase>
#include <QMimeType>
#include <QDebug>
#include <QFile>
#include <QProcess>
#include <QDir>
#include <QRadioButton>
#include <QDesktopServices>
#include <QColor>
#include <QColorDialog>
#include <QMenu>
#include <QAction>
#include <QMenuBar>
#include <QBitmap>
#include <QTimer>
#include <QPropertyAnimation>
#include <QScreen>
#include <QDateTime>

#include "util.h"
#include "suffixdialog.h"
#include "searchdialog.h"

CategoryBox::CategoryBox(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::CategoryBox)
{
    ui->setupUi(this);

    this->setWindowOpacity(0.5);
    this->setAcceptDrops(true);
    this->resize(400, 250);
    QPoint curPos = QCursor::pos();
    this->move(curPos);

    this->setWindowFlags(Qt::FramelessWindowHint | this->windowFlags());

    windowStyle = new WindowStyle(this);
    windowStyle->activateOn(ui->titleWidget);

    animGroup = new QSequentialAnimationGroup(this);
    connect(animGroup, &QSequentialAnimationGroup::finished, [=](){
        animGroup->clear();
    });
    ui->hideScroBtn->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_TitleBarShadeButton)));
    connect(ui->hideScroBtn, &QToolButton::clicked, [=](){
        if (isHideScroll == false) {
            hideScroll();
            ui->hideScroBtn->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_TitleBarUnshadeButton)));
            isHideScroll = true;
            windowStyle->setResizable(false);
        } else {
            showScroll();
            ui->hideScroBtn->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_TitleBarShadeButton)));
            isHideScroll = false;
            windowStyle->setResizable(true);
        }
    });

    ui->lockBtn->setIcon(QIcon(":/icon/img/unlock.png"));
    connect(ui->lockBtn, &QToolButton::clicked, [=](){
        if (isLock == false) {
            windowStyle->setMovable(false);
            ui->lockBtn->setIcon(QIcon(":/icon/img/lock.png"));
            isLock = true;
        } else {
            windowStyle->setMovable(true);
            ui->lockBtn->setIcon(QIcon(":/icon/img/unlock.png"));
            isLock = false;
        }
    });

    ui->lineEdit->setStyleSheet("background-color:black; color:white;");
    title = ui->lineEdit;

    QPixmap closeImg = this->style()->standardPixmap(QStyle::SP_MessageBoxCritical);
    ui->closeBtn->setIcon(closeImg);
    ui->closeBtn->resize(25,25);
    ui->closeBtn->setStyleSheet("border-style: flat;");
    connect(ui->closeBtn, &QToolButton::clicked, [=](){
        if (this->title->text() != "常用") {
            recover(Util::homePath + "/.desktop", Util::desktopPath);
        }
        this->btnList.clear();
        this->setVisible(false);
    });

    ui->menu->setStyleSheet("background-color:black; color:white;");
    m_menubar = new QMenuBar(ui->menu);
    m_menu = new QMenu("菜单");

    m_changeView = new QAction("视图方式");
    m_changeView->setIcon(QIcon(":/icon/img/view1.png"));

    m_changeColor = new QAction("盒子颜色");
    m_changeColor->setIcon(QIcon(":/icon/img/color.png"));

    m_btnSize = new QMenu("按钮大小");
    m_btnSmall = new QAction("小图标");
    m_btnMid = new QAction("中图标");
    m_btnMid->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_DialogApplyButton)));
    m_btnBig = new QAction("大图标");
    m_btnSize->addAction(m_btnSmall);
    m_btnSize->addAction(m_btnMid);
    m_btnSize->addAction(m_btnBig);

    m_changeSuffix = new QAction("配置规则");
    connect(m_changeSuffix, &QAction::triggered, [=](){
        SuffixDialog suffixDialog(suffixs, this);
        connect(&suffixDialog, &SuffixDialog::changeSuffix, [=](QStringList strList){
            suffixs = strList;
            suffixClassify();
        });
        suffixDialog.exec();
    });



    m_btnSort = new QMenu("排序");
    m_fileSortType = FileSortType::NullType;

    m_btnFileName = new QAction("文件名");
    connect(m_btnFileName, &QAction::triggered, [=](){
        switch (m_fileSortType) {
        case(FileSortType::FileName): {
            m_btnFileName->setIcon(QIcon());
            break;
        }
        case(FileSortType::FileType):{
            m_btnFileType->setIcon(QIcon());
            break;
        }
        case(FileSortType::FileSize):{
            m_btnFileSize->setIcon(QIcon());
            break;
        }
        case (FileSortType::FileTime):{
            m_btnFileTime->setIcon(QIcon());
        }
        default:
            break;
        }
        m_btnFileName->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_DialogApplyButton)));
        m_fileSortType = FileSortType::FileName;
        qSort(btnList.begin(), btnList.end(), [=](const QToolButton *t, const QToolButton *o) -> bool {
            if (m_isFileInc) {
                return t->text() < o->text();
            } else {
                return t->text() >= o->text();
            }
        });
        this->repaint();
    });

    m_btnFileType = new QAction("文件类型");
    connect(m_btnFileType, &QAction::triggered, [=](){
        switch (m_fileSortType) {
        case(FileSortType::FileName): {
            m_btnFileName->setIcon(QIcon());
            break;
        }
        case(FileSortType::FileType):{
            m_btnFileType->setIcon(QIcon());
            break;
        }
        case(FileSortType::FileSize):{
            m_btnFileSize->setIcon(QIcon());
            break;
        }
        case (FileSortType::FileTime):{
            m_btnFileTime->setIcon(QIcon());
        }
        default:
            break;
        }
        m_btnFileType->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_DialogApplyButton)));
        m_fileSortType = FileSortType::FileType;
        qSort(btnList.begin(), btnList.end(), [=](const QToolButton *t, const QToolButton *o) -> bool {
            QMimeDatabase db;
            QMimeType tMime = db.mimeTypeForFile(Util::homePath + "./desktop/" + t->text());
            QMimeType oMime = db.mimeTypeForFile(Util::homePath + "./desktop/" + o->text());
            if (m_isFileInc) {
                return tMime.name() < oMime.name();
            } else {
                return tMime.name() >= oMime.name();
            }
        });
        this->repaint();
    });

    m_btnFileSize = new QAction("文件大小");
    connect(m_btnFileSize, &QAction::triggered, [=](){
        switch (m_fileSortType) {
        case(FileSortType::FileName): {
            m_btnFileName->setIcon(QIcon());
            break;
        }
        case(FileSortType::FileType):{
            m_btnFileType->setIcon(QIcon());
            break;
        }
        case(FileSortType::FileSize):{
            m_btnFileSize->setIcon(QIcon());
            break;
        }
        case (FileSortType::FileTime):{
            m_btnFileTime->setIcon(QIcon());
        }
        default:
            break;
        }
        m_btnFileSize->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_DialogApplyButton)));
        m_fileSortType = FileSortType::FileSize;
        qSort(btnList.begin(), btnList.end(), [=](const QToolButton *t, const QToolButton *o) -> bool {
            QFileInfo tInfo(Util::homePath + "./desktop/" + t->text());
            QFileInfo oInfo(Util::homePath + "./desktop/" + o->text());
            if (m_isFileInc) {
                return tInfo.size() < oInfo.size();
            } else {
                return tInfo.size() >= oInfo.size();
            }
        });
        this->repaint();
    });

    m_btnFileTime = new QAction("修改时期");
    connect(m_btnFileTime, &QAction::triggered, [=](){
        switch (m_fileSortType) {
        case(FileSortType::FileName): {
            m_btnFileName->setIcon(QIcon());
            break;
        }
        case(FileSortType::FileType):{
            m_btnFileType->setIcon(QIcon());
            break;
        }
        case(FileSortType::FileSize):{
            m_btnFileSize->setIcon(QIcon());
            break;
        }
        case (FileSortType::FileTime):{
            m_btnFileTime->setIcon(QIcon());
        }
        default:
            break;
        }
        m_btnFileTime->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_DialogApplyButton)));
        m_fileSortType = FileSortType::FileTime;
        qSort(btnList.begin(), btnList.end(), [=](const QToolButton *t, const QToolButton *o) -> bool {
            QFileInfo tInfo(Util::homePath + "./desktop/" + t->text());
            QFileInfo oInfo(Util::homePath + "./desktop/" + o->text());
            if (m_isFileInc) {
                return tInfo.lastModified().toString("yyyy/MM/dd hh:mm:ss") < oInfo.lastModified().toString("yyyy/MM/dd hh:mm:ss");
            } else {
                return tInfo.lastModified().toString("yyyy/MM/dd hh:mm:ss") >= oInfo.lastModified().toString("yyyy/MM/dd hh:mm:ss");
            }
        });
        this->repaint();
    });

    m_btnInc = new QAction("升序");
    m_btnInc->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_DialogApplyButton)));
    m_isFileInc = true;
    connect(m_btnInc, &QAction::triggered, [=](){
        m_btnInc->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_DialogApplyButton)));
        m_btnDec->setIcon(QIcon());
        m_isFileInc = true;
        switch (m_fileSortType) {
        case(FileSortType::FileName): {
            emit m_btnFileName->triggered();
            break;
        }
        case(FileSortType::FileType):{
            emit m_btnFileType->triggered();
            break;
        }
        case(FileSortType::FileSize):{
            emit m_btnFileSize->triggered();
            break;
        }
        case (FileSortType::FileTime):{
            emit m_btnFileTime->triggered();
        }
        default:
            break;
        }
    });

    m_btnDec = new QAction("降序");
    connect(m_btnDec, &QAction::triggered, [=](){
        m_btnDec->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_DialogApplyButton)));
        m_btnInc->setIcon(QIcon());
        m_isFileInc = false;
        switch (m_fileSortType) {
        case(FileSortType::FileName): {
            emit m_btnFileName->triggered();
            break;
        }
        case(FileSortType::FileType):{
            emit m_btnFileType->triggered();
            break;
        }
        case(FileSortType::FileSize):{
            emit m_btnFileSize->triggered();
            break;
        }
        case (FileSortType::FileTime):{
            emit m_btnFileTime->triggered();
        }
        default:
            break;
        }
    });

    m_btnSort->addAction(m_btnFileName);
    m_btnSort->addAction(m_btnFileType);
    m_btnSort->addAction(m_btnFileSize);
    m_btnSort->addAction(m_btnFileTime);
    m_btnSort->addSeparator();
    m_btnSort->addAction(m_btnInc);
    m_btnSort->addAction(m_btnDec);

    m_btnSearch = new QAction("查找");

    m_menu->addAction(m_changeSuffix);
    m_menu->addSeparator();
    m_menu->addAction(m_changeView);
    m_menu->addAction(m_changeColor);
    m_menu->addMenu(m_btnSize);
    m_menu->addSeparator();
    m_menu->addAction(m_btnSearch);
    m_menu->addMenu(m_btnSort);
    m_menubar->addMenu(m_menu);


    connect(m_changeView, &QAction::triggered, [=](){
        view = !view;
        if (view) {
            m_changeView->setIcon(QIcon(":/icon/img/view2.png"));
        } else {
            m_changeView->setIcon(QIcon(":/icon/img/view1.png"));
        }
        this->repaint();
    });

    connect(m_changeColor, &QAction::triggered, [=](){
        QColor colorBack = QColorDialog::getColor(Qt::black, this, "选择颜色");
        int r, g, b;
        colorBack.getRgb(&r, &g, &b);
        ui->titleWidget->setStyleSheet("background-color:rgb(" + QString::number(r) + "," + QString::number(g) + "," + QString::number(b) + ");");
        ui->menu->setStyleSheet("background-color:rgb(" + QString::number(r) + "," + QString::number(g) + "," + QString::number(b) + ");"
                                    + "color:rgb(" + QString::number(255-r) + "," + QString::number(255-g) + "," + QString::number(255-b) + ");");
        ui->lineEdit->setStyleSheet("background-color:rgb(" + QString::number(r) + "," + QString::number(g) + "," + QString::number(b) + ");"
                                    + "color:rgb(" + QString::number(255-r) + "," + QString::number(255-g) + "," + QString::number(255-b) + ");");
    });

    connect(m_btnSmall, &QAction::triggered, [=](){
        btnWidth = 80;
        btnHeight = 25;
        m_btnSmall->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_DialogApplyButton)));
        m_btnMid->setIcon(QIcon());
        m_btnBig->setIcon(QIcon());
        this->repaint();
    });

    connect(m_btnMid, &QAction::triggered, [=](){
        btnWidth = 120;
        btnHeight = 50;
        m_btnSmall->setIcon(QIcon());
        m_btnMid->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_DialogApplyButton)));
        m_btnBig->setIcon(QIcon());
        this->repaint();
    });

    connect(m_btnBig, &QAction::triggered, [=](){
        btnWidth = 160;
        btnHeight = 100;
        m_btnSmall->setIcon(QIcon());
        m_btnMid->setIcon(QIcon());
        m_btnBig->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_DialogApplyButton)));
        this->repaint();
    });

    connect(m_btnSearch, &QAction::triggered, [=]{
        SearchDialog dialog(btnList, view, this);
        dialog.exec();
    });

    scrollWidget = new QWidget(this);
//    ui->scrollArea->setStyleSheet("background-color:white;");
    ui->scrollArea->setWidget(scrollWidget);
}

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

void CategoryBox::recover(const QString &source, const QString &destination){
    QDir directory(source);
    if (!directory.exists()) return;

    QString srcPath = QDir::toNativeSeparators(source);
    if (!srcPath.endsWith(QDir::separator()))
        srcPath += QDir::separator();
    QString dstPath = QDir::toNativeSeparators(destination);
    if (!dstPath.endsWith(QDir::separator()))
        dstPath += QDir::separator();

    QStringList fileNames = directory.entryList(QDir::AllEntries | QDir::NoDotAndDotDot);
    for (QStringList::size_type i=0; i != fileNames.size(); ++i){
        QString fileName = fileNames.at(i);

        int num = 0;
        for (num = 0; num < btnList.size(); num++){
            if (btnList[num]->text() == fileName){
                break;
            }
        }

        if (num == btnList.size()) continue;

        QString srcFilePath = srcPath + fileName;
        QString dstFilePath = dstPath + fileName;
        QFileInfo fileInfo(srcFilePath);
        if (fileInfo.isFile() || fileInfo.isSymLink()){
            QFile::rename(srcFilePath, dstFilePath);
        }
        else if (fileInfo.isDir()){
            QDir dstDir(dstFilePath);
            dstDir.mkpath(dstFilePath);
            recover(srcFilePath, dstFilePath);
            QDir srcDir(srcFilePath);
            srcDir.removeRecursively();
        }
    }
}

void CategoryBox::paintEvent(QPaintEvent *event){
    QPainter painter(this);
    painter.drawPixmap(QRect(0, 0, this->width(), ui->title->height()+18), QPixmap(":/img/background.jpg"));
    QBitmap bmp(this->size());
    bmp.fill();
    QPainter p(&bmp);
    p.setPen(Qt::NoPen);
    p.setBrush(Qt::black);
    p.drawRoundedRect(bmp.rect(),15,15);
    setMask(bmp);

    if (!isHideScroll) {
        ui->scrollArea->resize(this->width(), this->height() - ui->title->height());

        if (!view){
            rowCnt = this->width() / btnWidth;

            for (int i = 0; i < btnList.size(); i++){
                int row = i / rowCnt;
                int col = i % rowCnt;

    //            if ((row+1) * btnWidth > scrollWidget->height()) {
    //                scrollWidget->resize(ui->scrollArea->width() - 3, (row+1) * btnWidth);
    //                ui->scrollArea->verticalScrollBar()->setValue(ui->scrollArea->verticalScrollBar()->maximum());
    //            }

                btnList[i]->setIconSize(QSize(45, 45));
                btnList[i]->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
                btnList[i]->setGeometry(col * btnWidth, row * btnWidth, btnWidth, btnWidth);
                btnList[i]->resize(btnWidth, btnWidth);
                btnList[i]->show();
            }

            scrollWidget->resize(ui->scrollArea->width() - 3, ((btnList.size() - 1) / rowCnt + 1) * btnWidth);
    //        ui->scrollArea->verticalScrollBar()->setValue(ui->scrollArea->verticalScrollBar()->maximum());
        } else {
            for (int i = 0; i < btnList.size(); i++){
                if ((i+1) * btnHeight > scrollWidget->height()) {
                    scrollWidget->resize(ui->scrollArea->width() - 3, (i+1) * btnHeight + 15);
                    ui->scrollArea->verticalScrollBar()->setValue(ui->scrollArea->verticalScrollBar()->maximum());
                }

                btnList[i]->setIconSize(QSize(30, 30));
                btnList[i]->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
                btnList[i]->setGeometry(0, i * btnHeight, this->width(), btnHeight);
                btnList[i]->resize(this->width(), btnHeight);
                btnList[i]->show();
            }
            scrollWidget->resize(ui->scrollArea->width() - 3, btnList.size() * btnHeight + 15);
    //        ui->scrollArea->verticalScrollBar()->setValue(ui->scrollArea->verticalScrollBar()->maximum());
        }
    }

}

void CategoryBox::enterEvent(QEvent* event){
    this->setWindowOpacity(1.0);

    if (!(this->y() < 10 || this->y() + this->height() > QGuiApplication::primaryScreen()->geometry().height() - 50)){
        isInEdge = false;
    }

    if (isInEdge) {
        if (this->y() > 10) {
            this->move(this->x(), this->y() - lastScrollHeight);
        }
        if (isHideScroll == true) {
            showScroll();
        }
        ui->hideScroBtn->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_TitleBarShadeButton)));
        isHideScroll = false;
        windowStyle->setResizable(true);
    }
}
void CategoryBox::leaveEvent(QEvent* event){
    this->setWindowOpacity(0.5);

    if (this->y() < 10) {
        this->move(this->x(), 0);
        isInEdge = true;

        if (isHideScroll == false) {
            hideScroll();
        }

        ui->hideScroBtn->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_TitleBarUnshadeButton)));
        isHideScroll = true;
        windowStyle->setResizable(false);
    } else if (this->y() + this->height() > QGuiApplication::primaryScreen()->geometry().height() - 50) {
        isInEdge = true;

        this->move(this->x(), QGuiApplication::primaryScreen()->geometry().height() - ui->titleWidget->height());
        if (isHideScroll == false) {
            hideScroll();
        }
        ui->hideScroBtn->setIcon(QIcon(this->style()->standardPixmap(QStyle::SP_TitleBarUnshadeButton)));
        isHideScroll = true;
        windowStyle->setResizable(false);
    } else {
        isInEdge = false;
    }
}

void CategoryBox::dragEnterEvent(QDragEnterEvent *event){
    //拖动的东西有url
    //qDebug() << "enter";
    if (event->mimeData()->hasUrls()){
        for (int i = 0; i < event->mimeData()->urls().size(); i++){
            QUrl url = event->mimeData()->urls()[i];
            QFileInfo info(url.toLocalFile());
            QString fileName = info.absoluteFilePath();
            if (title->isInitWindowTitle){
                if (info.isFile()){
                    //qDebug() << "文件";
                    QMimeDatabase db;
                    QMimeType mime = db.mimeTypeForFile(fileName);
                    if (mime.name().startsWith("text/") && this->title->text() == "文本") {
                        this->setWindowOpacity(1.0);
                        event->acceptProposedAction();
                    } else if (mime.name().startsWith("image/") && this->title->text() == "图片"){
                        this->setWindowOpacity(1.0);
                        event->acceptProposedAction();
                    } else if (mime.name().startsWith("audio") && this->title->text() == "音频"){
                        this->setWindowOpacity(1.0);
                        event->acceptProposedAction();
                    } else if (mime.name().startsWith("video") && this->title->text() == "视频"){
                        this->setWindowOpacity(1.0);
                        event->acceptProposedAction();
                    } else if (mime.name().startsWith("application") && this->title->text() == "WPS"){
                        this->setWindowOpacity(1.0);
                        event->acceptProposedAction();
                    }
                }
                else if (info.isDir() && this->title->text() == "文件夹"){
                    this->setWindowOpacity(1.0);
                    event->acceptProposedAction();
                }
            } else {    //用户定义的窗口
                QString suffix = info.suffix();
                QStringList suffixs = this->getSuffixs();
                bool isAllEmpty = true;
                for (QString str : suffixs) {
                    if (!str.isEmpty()) {
                        isAllEmpty = false;
                    }
                    if (suffix == i) {
                        this->setWindowOpacity(1.0);
                        event->acceptProposedAction();
                        break;
                    }
                }

                if (isAllEmpty) {
                    this->setWindowOpacity(1.0);
                    event->acceptProposedAction();
                }

            }
        }
    }

}

void CategoryBox::dragLeaveEvent(QDragLeaveEvent *event){
    this->setWindowOpacity(0.5);
}

void CategoryBox::dropEvent(QDropEvent *event){
    if (event->mimeData()->hasUrls()){
        for (int i = 0; i < event->mimeData()->urls().size(); i++){
            QUrl url = event->mimeData()->urls()[i];
            QFileInfo info(url.toLocalFile());

            //获取绝对路径
            QString path = info.absoluteFilePath();
            //
            QString filename = info.fileName();
            //如果是链接就找到实际路径
            if (info.isSymLink()){
                path = info.symLinkTarget();
            }
            //获取文件的icon
            //先从本地的icon开始查找
            QIcon icon  = getFileIcon(path);
//            QFileIconProvider iconProvider;
//            QIcon icon = iconProvider.icon(path);

            QToolButton *btn = new QToolButton(scrollWidget);
            btnList.push_back(btn);
            btnCnt++;
            btn->setAutoRaise(true);
            btn->setIcon(icon);
            btn->setText(filename);

            this->repaint();
            ui->scrollArea->verticalScrollBar()->setValue(ui->scrollArea->verticalScrollBar()->maximum());

            QProcess *term = new QProcess(this);
            term->start("mv", QStringList() << path << Util::homePath + "/.desktop");
            term->waitForFinished();

            connect(btn, &QToolButton::clicked, [=](){
                this->clickBtn(Util::homePath + "/.desktop/" + filename);
            });
        }
        this->setWindowOpacity(0.5);
    }
}

void CategoryBox::mousePressEvent(QMouseEvent *event){
    if (event->button() == Qt::RightButton){
        m_menu->exec(QCursor::pos());
    }
}

void CategoryBox::addBtn(QFileInfo info){
    //获取绝对路径
    QString path = info.absoluteFilePath();

    QString filename = info.fileName();
    //如果是链接就找到实际路径
    if (info.isSymLink()){
        path = info.symLinkTarget();
    }
    //获取文件的icon
    QIcon icon = getFileIcon(path);

    QToolButton *btn = new QToolButton(scrollWidget);
    btnList.push_back(btn);
    btnCnt++;
    btn->setAutoRaise(true);
    btn->setIcon(icon);
    btn->setText(filename);

    this->repaint();
    ui->scrollArea->verticalScrollBar()->setValue(ui->scrollArea->verticalScrollBar()->maximum());

    QProcess *term = new QProcess(this);
    term->start("mv", QStringList() << path << Util::homePath + "/.desktop");

    connect(btn, &QToolButton::clicked, [=](){
        this->clickBtn(Util::homePath + "/.desktop/" + filename);
    });
}

void CategoryBox::clickBtn(QString path){
    QDesktopServices::openUrl(QUrl::fromLocalFile(path));
    QMimeDatabase db;

    QMimeType mime = db.mimeTypeForFile(path);
    QString fileType = mime.name();
    qDebug() << fileType;

    //LRU
    bool find = false;
    int min = 0;
    int line_count = 0;
    QFile infoFile(Util::homePath + "/.desktop/commonState.info");
    QString write_str = "";
    QString min_str = "";
    if (!infoFile.exists()) {
        infoFile.open(QIODevice::WriteOnly);
        QTextStream stream(&infoFile);
        stream << path << ",0\n";
    } else {
        infoFile.open(QIODevice::ReadOnly);
        QTextStream stream(&infoFile);
        QString str;
        while (!stream.atEnd()) {
            str = stream.readLine();
            line_count++;
            //qDebug() << str;
            QStringList list = str.split(",");
            if (list[0] != path) {
                write_str += list[0];
                write_str += ",";
                int newcount = list[1].toInt() - 1;
                write_str += QString::number(newcount);
                if (newcount < min) {
                    min = newcount;
                    min_str = list[0] + "," + QString::number(newcount);
                    //qDebug() << min_str;
                }
                write_str += "\n";
            } else {
                write_str += str + "\n";
                find = true;
            }
        }
        if (!find && line_count < 10) {
            write_str += path + ",0" + "\n";
        } else if(!find && line_count >= 10) {
            //qDebug() << "min_str: " + min_str;
            write_str.replace(min_str, path + ",0");
        }
        infoFile.close();
        QFile outFile(Util::homePath + "/.desktop/commonState.info");
        outFile.open(QIODevice::WriteOnly);
        QTextStream outStream(&outFile);
        //qDebug() << "write_str: " << write_str;
        outStream << write_str;
    }

}

void CategoryBox::hideScroll(){
    if (animGroup == nullptr) {
        animGroup = new QSequentialAnimationGroup (this);
    }


    lastScrollHeight = ui->bodyWidget->height();
    QPropertyAnimation * anim = new QPropertyAnimation(this, "geometry");
    anim->setStartValue(this->geometry());
    anim->setEndValue(QRect(this->geometry().x(), this->geometry().y(), this->width(), this->height() - lastScrollHeight));
    anim->setDuration(260);
    anim->setEasingCurve(QEasingCurve::Linear);
//    anim->start(QAbstractAnimation::DeleteWhenStopped);
    animGroup->addAnimation(anim);
    animGroup->start();

    QTimer *timer = new QTimer(this);
    connect(timer, &QTimer::timeout, [this](){
        ui->bodyWidget->setVisible(false);
    });
    timer->setSingleShot(true);
    timer->start(250);


}

void CategoryBox::showScroll(){
    if (animGroup == nullptr) {
        animGroup = new QSequentialAnimationGroup (this);
    }

    QPropertyAnimation * anim = new QPropertyAnimation(this, "geometry");
    anim->setStartValue(this->geometry());
    anim->setEndValue(QRect(this->geometry().x(), this->geometry().y(), this->width(), this->height() + lastScrollHeight));
    anim->setDuration(260);
    anim->setEasingCurve(QEasingCurve::Linear);
//    anim->start(QAbstractAnimation::DeleteWhenStopped);
    animGroup->addAnimation(anim);
    animGroup->start();

    QTimer *timer = new QTimer(this);
    connect(timer, &QTimer::timeout, [this](){
        ui->bodyWidget->setVisible(true);
    });
    timer->setSingleShot(true);
    timer->start(10);
}

QIcon CategoryBox::getFileIcon(QString path){
    QMimeDatabase db;
    QMimeType mimeType = db.mimeTypeForFile(path);
    QString type = mimeType.name();
    type.replace("/", "-");
    if (type.contains("image")){
        type = "image";
    }
    QString iconPath = ":/mimetypes/img/" + type + ".png";
    qDebug() << iconPath;
    QPixmap *pix = new QPixmap(iconPath);
    if (!pix->isNull()){
        return QIcon(*pix);
    } else {
        QFileInfo file_info(path);
        QFileIconProvider icon_provider;
        QIcon icon = icon_provider.icon(file_info);
        return icon;
    }
}

void CategoryBox::suffixClassify(){
    QDir directory(Util::desktopPath);
    if (!directory.exists()) return;
    qDebug() << "exits";

    QStringList fileNames = directory.entryList(QDir::AllEntries | QDir::NoDotAndDotDot);
    for (QStringList::size_type i=0; i != fileNames.size(); ++i){
        QString fileName = fileNames.at(i);
        QFileInfo fileInfo(Util::desktopPath + "/" + fileName);
        //按用户自定义规则分类
        QString suffix = fileInfo.suffix();
        if (suffixs.contains(suffix)) {
            this->addBtn(fileInfo);
        }
    }
}