FavoriteView.cpp

// Author: Kang Lin <kl222@126.com>
 
#include <QFileDialog>
#include <QToolBar>
#include <QMouseEvent>
#include <QDrag>
#include <QMimeData>
#include <QApplication>
#include <QHeaderView>
#include <QSettings>
#include <QSettings>
#include <QMenu>
#include <QAction>
#include <QInputDialog>
#include <QMessageBox>
#include <QDir>
#include <QLoggingCategory>
#include <QVBoxLayout>
 
#include "RabbitCommonDir.h"
#include "FavoriteMimeData.h"
#include "TitleBar.h"
#include "FavoriteView.h"
#include "ParameterGlobal.h"
#include "Database.h"
 
static Q_LOGGING_CATEGORY(log, "Favorite")
 
CFavoriteView::CFavoriteView(CParameterApp *pPara, QWidget *parent)
    : QWidget(parent)
    , m_pParaApp(pPara)
    , m_pDockTitleBar(nullptr)
    , m_pTreeView(nullptr)
    , m_pModel(nullptr)
    , m_pDatabase(nullptr)
    , m_pStartAction(nullptr)
    , m_pEidtStartAction(nullptr)
    , m_pAddFolderAction(nullptr)
    , m_pEditAction(nullptr)
    , m_pDeleteAction(nullptr)
    , m_pImportAction(nullptr)
    , m_pExportAction(nullptr)
    , m_pRefresh(nullptr)
    , m_pShowToolbar(nullptr)
    , m_pMenu(nullptr)
{
    bool check = false;
 
    setWindowTitle(tr("Favorite"));
 
    m_pDockTitleBar = new RabbitCommon::CTitleBar(parent);
    // Create tools pushbutton in title bar
    m_pMenu = new QMenu(tr("Tools"), m_pDockTitleBar);
    check = connect(m_pMenu, SIGNAL(aboutToShow()), this, SLOT(slotMenu()));
    Q_ASSERT(check);
    QPushButton* pTools = m_pDockTitleBar->CreateSmallPushButton(
        QIcon::fromTheme("tools"), m_pDockTitleBar);
    pTools->setToolTip(tr("Tools"));
    pTools->setMenu(m_pMenu);
    QList<QWidget*> lstWidget;
    lstWidget << pTools;
    m_pDockTitleBar->AddWidgets(lstWidget);
 
    setupUI();
}
 
CFavoriteView::~CFavoriteView()
{
    if(m_pDatabase) {
        delete m_pDatabase;
        m_pDatabase = nullptr;
    }
}
 
void CFavoriteView::setupUI()
{
    QVBoxLayout *pMainLayout = new QVBoxLayout(this);
    if(!pMainLayout) return;
 
    setupToolBar(pMainLayout);
 
    setupTreeView(pMainLayout);
}
 
void CFavoriteView::setupToolBar(QLayout *layout)
{
    if(!layout) return;
    bool check = false;
    QToolBar* pToolBar = new QToolBar(this);
    if(!pToolBar) return;
    layout->addWidget(pToolBar);
 
    m_pShowToolbar = new QAction(tr("Show tool bar"), this);
    m_pShowToolbar->setCheckable(true);
    m_pShowToolbar->setChecked(m_pParaApp->GetDockListFavoriteShowToolBar());
    pToolBar->setVisible(m_pShowToolbar->isChecked());
    check = connect(m_pShowToolbar, &QAction::triggered, this, [&, pToolBar]() {
        if(m_pShowToolbar && m_pParaApp) {
            pToolBar->setVisible(m_pShowToolbar->isChecked());
            m_pParaApp->SetDockListFovoriteShowToolBar(m_pShowToolbar->isChecked());
            m_pParaApp->Save();
        }
    });
    Q_ASSERT(check);
 
    m_pStartAction = pToolBar->addAction(
        QIcon::fromTheme("media-playback-start"), tr("Start"));
    if(m_pStartAction) {
        m_pStartAction->setToolTip(m_pStartAction->text());
        m_pStartAction->setStatusTip(m_pStartAction->text());
        check = connect(m_pStartAction, &QAction::triggered,
                        this, &CFavoriteView::slotStart);
        Q_ASSERT(check);
    }
 
    m_pEidtStartAction = pToolBar->addAction(
        QIcon::fromTheme("system-settings"), tr("Open settings and Start"));
    if(m_pEidtStartAction) {
        m_pEidtStartAction->setToolTip(m_pEidtStartAction->text());
        m_pEidtStartAction->setStatusTip(m_pEidtStartAction->text());
        check = connect(m_pEidtStartAction, &QAction::triggered,
                        this, &CFavoriteView::slotOpenStart);
        Q_ASSERT(check);
    }
 
    pToolBar->addSeparator();
 
    m_pAddFolderAction = pToolBar->addAction(
        QIcon::fromTheme("folder-new"), tr("New group"));
    if(m_pAddFolderAction) {
        m_pAddFolderAction->setToolTip(m_pAddFolderAction->text());
        m_pAddFolderAction->setStatusTip(m_pAddFolderAction->text());
        check = connect(m_pAddFolderAction, &QAction::triggered,
                        this, &CFavoriteView::slotNewGroup);
        Q_ASSERT(check);
    }
 
    m_pEditAction = pToolBar->addAction(QIcon::fromTheme("edit"), tr("Edit"));
    if(m_pEditAction) {
        m_pEditAction->setToolTip(m_pEditAction->text());
        m_pEditAction->setStatusTip(m_pEditAction->text());
        check = connect(m_pEditAction, &QAction::triggered,
                        this, &CFavoriteView::slotEdit);
        Q_ASSERT(check);
    }
 
    m_pDeleteAction = pToolBar->addAction(QIcon::fromTheme("edit-delete"), tr("Delete"));
    if(m_pDeleteAction) {
        m_pDeleteAction->setToolTip(m_pDeleteAction->text());
        m_pDeleteAction->setStatusTip(m_pDeleteAction->text());
        check = connect(m_pDeleteAction, &QAction::triggered, this, &CFavoriteView::slotDelete);
        Q_ASSERT(check);
    }
 
    pToolBar->addSeparator();
 
    m_pImportAction = pToolBar->addAction(QIcon::fromTheme("import"), tr("Import"));
    if(m_pImportAction) {
        m_pImportAction->setToolTip(m_pImportAction->text());
        m_pImportAction->setStatusTip(m_pImportAction->text());
        check = connect(m_pImportAction, &QAction::triggered, this, &CFavoriteView::slotImport);
        Q_ASSERT(check);
    }
 
    m_pExportAction = pToolBar->addAction(QIcon::fromTheme("export"), tr("Export"));
    if(m_pExportAction) {
        m_pExportAction->setToolTip(m_pExportAction->text());
        m_pExportAction->setStatusTip(m_pExportAction->text());
        check = connect(m_pExportAction, &QAction::triggered, this, &CFavoriteView::slotExport);
        Q_ASSERT(check);
    }
 
    pToolBar->addSeparator();
    m_pRefresh = pToolBar->addAction(QIcon::fromTheme("view-refresh"), tr("Refresh"), this, [&](){
        if(m_pModel)
            m_pModel->Refresh();
    });
}
 
void CFavoriteView::setupTreeView(QLayout *layout)
{
    if(!layout) return;
    m_pTreeView = new QTreeView(this);
    if(!m_pTreeView)
        return;
    layout->addWidget(m_pTreeView);
 
    InitialDragDrop();
 
    m_pTreeView->setUniformRowHeights(true);
    m_pTreeView->setHeaderHidden(true);
 
    //m_pTreeView->setExpandsOnDoubleClick(true);
    // 如果需要自动展开第一层
    //m_pTreeView->expandAll(); // 或者根据需要展开特定节点
    //m_pTreeView->expandToDepth(1);
 
    m_pTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
    bool check = connect(m_pTreeView,
                         SIGNAL(customContextMenuRequested(const QPoint &)),
                         this, SLOT(slotCustomContextMenu(const QPoint &)));
    Q_ASSERT(check);
    check = connect(m_pTreeView, SIGNAL(clicked(const QModelIndex&)),
                    this, SLOT(slotFavrtieClicked(const QModelIndex&)));
    Q_ASSERT(check);
    check = connect(m_pTreeView, SIGNAL(doubleClicked(const QModelIndex&)),
                    this, SLOT(slotFavortiedoubleClicked(const QModelIndex&)));
    Q_ASSERT(check);
 
    //m_pTreeView->installEventFilter(this);
}
 
int CFavoriteView::Initial()
{
    int nRet = 0;
    m_pDatabase = new CFavoriteDatabase(this);
    if(m_pDatabase) {
        bool bRet = false;
        //bRet = m_pDatabase->OpenDatabase(&m_pParaApp->GetGlobalParameters()->m_Database, "favorite_connect");
        auto pg = m_pParaApp->GetGlobalParameters();
        bRet = m_pDatabase->SetDatabase(&pg->m_DatabaseRemote);
        if(!bRet) return -1;
    }
    if(m_pDatabase) {
        m_pModel = new CFavoriteModel(m_pDatabase, this);
        m_pTreeView->setModel(m_pModel);
    }
 
    EnableAction();
    return nRet;
}
 
void CFavoriteView::EnableAction(const QModelIndex &index)
{
    if(!m_pModel) return;
    if(index.isValid()) {
        CFavoriteDatabase::Item item =
            m_pModel->data(index, CFavoriteModel::RoleItem)
                                           .value<CFavoriteDatabase::Item>();
        if(item.isFavorite()) {
            m_pStartAction->setEnabled(true);
            m_pEidtStartAction->setEnabled(true);
        } else {
            m_pStartAction->setEnabled(false);
            m_pEidtStartAction->setEnabled(false);
        }
        m_pEditAction->setEnabled(true);
        m_pDeleteAction->setEnabled(true);
        return;
    }
 
    if(m_pStartAction)
        m_pStartAction->setEnabled(false);
    if(m_pEidtStartAction)
        m_pEidtStartAction->setEnabled(false);
    if(m_pEditAction)
        m_pEditAction->setEnabled(false);
    if(m_pDeleteAction)
        m_pDeleteAction->setEnabled(false);
}
 
void CFavoriteView::slotAddToFavorite(const QString &file,
                                      const QString &szName,
                                      const QString &szDescription,
                                      const QIcon &icon
                                      )
{
    if(!m_pModel || !m_pTreeView) return;
 
    QString szFile = CDatabaseFile::SetFile(file);
 
    int parentId = 0;
    QString szGroup = tr("Root");
    auto indexes = m_pTreeView->selectionModel()->selectedIndexes();
    if(!indexes.isEmpty())
    {
        QModelIndex idx = indexes.at(0);
        while (idx.isValid()) {
            CFavoriteDatabase::Item item =
                m_pModel->data(idx, CFavoriteModel::RoleItem).value<CFavoriteDatabase::Item>();
            if(item.isFolder() && item.id > 0) {
                parentId = item.id;
                szGroup = item.szName;
                break;
            }
            idx = idx.parent();
        }
    }
    // Check if it already exists
    auto item = m_pModel->GetFavorite(szFile);
    if(item.id > 0) {
        if(item.parentId == parentId) {
            QMessageBox::information(
                nullptr, tr("Add favorite"),
                tr("\"%1\" already exists in \"%2\"").arg(szName, szGroup));
            return;
        }
        int ret = QMessageBox::warning(
            nullptr, tr("Add favorite"),
            tr("\"%1\" already exists, do you want to move it to \"%2\"?").arg(szName, szGroup),
            QMessageBox::Ok | QMessageBox::No);
        if(QMessageBox::Ok != ret)
            return;
    }
 
    m_pModel->AddFavorite(szFile, szName, icon, szDescription, parentId);
 
    return;
}
 
void CFavoriteView::slotUpdateFavorite(
    const QString &szFile, const QString &szName,
    const QString &szDescription, const QIcon &icon)
{
    if(!m_pModel || !m_pTreeView || szFile.isEmpty()) return;
    m_pModel->UpdateFavorite(CDatabaseFile::SetFile(szFile), szName, szDescription, icon);
}
 
void CFavoriteView::slotFavrtieClicked(const QModelIndex &index)
{
    EnableAction(index);
}
 
void CFavoriteView::slotFavortiedoubleClicked(const QModelIndex &index)
{
    if(!index.isValid()) return;
    if(m_pTreeView->editTriggers() != QTreeView::NoEditTriggers)
        return;
    QString szFile = m_pModel->data(index, CFavoriteModel::RoleFile).toString();
    if(!szFile.isEmpty())
        emit sigStart(CDatabaseFile::GetFile(szFile), false);
}
 
void CFavoriteView::slotDoubleEditNode(bool bEdit)
{
    if(bEdit)
        m_pTreeView->setEditTriggers(QTreeView::DoubleClicked);
    else
        m_pTreeView->setEditTriggers(QTreeView::NoEditTriggers);
}
 
void CFavoriteView::slotMenu()
{
    if(!m_pTreeView)
        return;
 
    m_pMenu->clear();
    m_pMenu->addAction(m_pStartAction);
    m_pMenu->addAction(m_pEidtStartAction);
 
    m_pMenu->addSeparator();
    m_pMenu->addAction(m_pAddFolderAction);
    m_pMenu->addAction(m_pEditAction);
    m_pMenu->addAction(m_pDeleteAction);
 
    m_pMenu->addSeparator();
    m_pMenu->addAction(m_pImportAction);
    m_pMenu->addAction(m_pExportAction);
 
    m_pMenu->addSeparator();
    m_pMenu->addAction(m_pRefresh);
 
    m_pMenu->addSeparator();
    m_pMenu->addAction(m_pShowToolbar);
}
 
void CFavoriteView::slotCustomContextMenu(const QPoint &pos)
{
    slotMenu();
    m_pMenu->exec(m_pTreeView->mapToGlobal(pos));
}
 
void CFavoriteView::slotStart()
{
    auto lstIndex = m_pTreeView->selectionModel()->selectedIndexes();
    foreach(auto index, lstIndex)
    {
        QString szFile = m_pModel->data(index, CFavoriteModel::RoleFile).toString();
        if(!szFile.isEmpty())
            emit sigStart(CDatabaseFile::GetFile(szFile), false);
    }
}
 
void CFavoriteView::slotOpenStart()
{
    auto lstIndex = m_pTreeView->selectionModel()->selectedIndexes();
    foreach(auto index, lstIndex)
    {
        QString szFile = m_pModel->data(index, CFavoriteModel::RoleFile).toString();
        if(!szFile.isEmpty())
            emit sigStart(CDatabaseFile::GetFile(szFile), true);
    }
}
 
void CFavoriteView::slotEdit()
{
    auto lstIndex = m_pTreeView->selectionModel()->selectedIndexes();
    foreach(auto index, lstIndex)
    {
        QString szName = m_pModel->data(index).toString();
        szName = QInputDialog::getText(
            this, tr("Edit"), tr("Enter the modified name"), QLineEdit::Normal, szName);
        if(szName.isEmpty())
            return;
        m_pModel->setData(index, szName);
    }
}
 
void CFavoriteView::slotDelete()
{
    auto lstIndex = m_pTreeView->selectionModel()->selectedIndexes();
    if(1 == lstIndex.size()) {
        CFavoriteDatabase::Item item =
            m_pModel->data(lstIndex.at(0), CFavoriteModel::RoleItem)
                                           .value<CFavoriteDatabase::Item>();
        if(0 < item.id) {
            int ret = QMessageBox::warning(
                nullptr, tr("Delete"), tr("Will be delete \"%1\"").arg(item.szName),
                QMessageBox::Ok|QMessageBox::No);
            if(QMessageBox::Ok != ret)
                return;
        }
    }
    foreach(auto index, lstIndex)
        m_pModel->removeRow(index.row(), index.parent());
}
 
void CFavoriteView::slotNewGroup()
{
    if(!m_pModel) return;
    QString szGroup = QInputDialog::getText(
        this, tr("New group"), tr("Input group name"));
    if(szGroup.isEmpty()) return;
 
    int parentId = 0;
    auto lstIndex = m_pTreeView->selectionModel()->selectedIndexes();
    if(!lstIndex.isEmpty())
    {
        CFavoriteDatabase::Item item =
            m_pModel->data(lstIndex.at(0), CFavoriteModel::RoleItem)
                                           .value<CFavoriteDatabase::Item>();
        if(0 < item.id && item.isFolder())
            parentId = item.id;
    }
 
    m_pModel->AddNode(szGroup, parentId);
}
 
void CFavoriteView::slotRefresh()
{
    if(m_pModel)
        m_pModel->Refresh();
}
 
void CFavoriteView::slotImport()
{
    QString filename = QFileDialog::getOpenFileName(
        this, tr("Import favorite"),
        RabbitCommon::CDir::Instance()->GetDirUserDocument(),
        tr("JSON (*.json)"));
 
    if (!filename.isEmpty()) {
        QFileInfo fi(filename);
        if(0 == fi.suffix().compare("json", Qt::CaseInsensitive)) {
            if (m_pDatabase->ImportFromJsonFile(filename)) {
                slotRefresh();
                QMessageBox::information(
                    this, tr("Success"),
                    tr("Successfully imported favorite from JSON file: %1").arg(filename));
            } else {
                QString szErr = tr("Failed to import favorite from JSON file: %1").arg(filename) + "\n";
                if(!m_pDatabase->GetError().isEmpty())
                    szErr += "\n" + tr("Error: ") + m_pDatabase->GetError();
                QMessageBox::critical(this, tr("Failure"), szErr);
            }
            return;
        }
        QMessageBox::warning(this, tr("Import favorite"),
                             tr("Invalid file: %1").arg(filename) + "\n\n"
                                 + tr("Please use JSON file"));
    }
}
 
void CFavoriteView::slotExport()
{
    QString filename = QFileDialog::getSaveFileName(
        this, tr("Export favorite"),
        RabbitCommon::CDir::Instance()->GetDirUserDocument(),
        tr("JSON (*.json)"));
 
    if (!filename.isEmpty()) {
        QFileInfo fi(filename);
        if(0 == fi.suffix().compare("json", Qt::CaseInsensitive)) {
            if (m_pDatabase->ExportToJsonFile(filename)) {
                QMessageBox::information(
                    this, tr("Success"),
                    tr("Favorite successfully exported to JSON file: %1").arg(filename));
            } else {
                QString szErr = tr("Failed to import favorite from JSON file: %1").arg(filename) + "\n";
                if(!m_pDatabase->GetError().isEmpty())
                    szErr += "\n" + tr("Error: ") + m_pDatabase->GetError();
                QMessageBox::critical(this, tr("Failure"), szErr);
            }
            return;
        }
        QMessageBox::critical(this, tr("Failure"),
                              tr("Invalid file: %1").arg(filename) + "\n\n"
                                  + tr("Please use JSON file"));
    }
}
 
void CFavoriteView::InitialDragDrop()
{
    if(!m_pTreeView || !m_pTreeView->viewport())
        return;
    //m_pTreeView->installEventFilter(this);
    m_pTreeView->viewport()->installEventFilter(this);
    m_pTreeView->setAcceptDrops(true);
    m_pTreeView->setDragEnabled(true);
    m_pTreeView->setDragDropMode(QTreeView::InternalMove);
    m_pTreeView->setDefaultDropAction(Qt::MoveAction);
    m_pTreeView->setDropIndicatorShown(true);
}
 
void CFavoriteView::dragEnterEvent(QDragEnterEvent *event)
{
    qDebug(log) << Q_FUNC_INFO;
    auto urls = event->mimeData()->urls();
    if(event->mimeData()->hasUrls() && urls.length() == 1) {
        //qDebug(log) << event->mimeData()->urls();
        event->acceptProposedAction();
        return;
    }
 
    const CFavoriteMimeData* pData =
        qobject_cast<const CFavoriteMimeData*>(event->mimeData());
    if (pData)
    {
        qDebug(log) << "dragEnterEvent acceptProposedAction";
        event->acceptProposedAction();
        /*
        // 设置拖拽时的光标
        if (event->proposedAction() == Qt::MoveAction) {
            setCursor(Qt::DragMoveCursor);
        } else {
            setCursor(Qt::DragCopyCursor);
        }//*/
    }
}
 
void CFavoriteView::dragMoveEvent(QDragMoveEvent *event)
{
    // qDebug(log) << Q_FUNC_INFO;
    // const CFavoriteMimeData* pData =
    //     qobject_cast<const CFavoriteMimeData*>(event->mimeData());
    // if (!pData)
    // {
    //     event->ignore();
    //     return;
    // }
}
 
void CFavoriteView::dropEvent(QDropEvent *event)
{
    qDebug(log) << Q_FUNC_INFO << "drop action:" << event->dropAction();
    bool bRet = false;
    auto urls = event->mimeData()->urls();
    foreach(auto url, urls)
    {
        if(url.isLocalFile()) {
            QString filename = url.toLocalFile();
            if (m_pDatabase->ImportFromJsonFile(filename)) {
                slotRefresh();
                emit sigShowMessageBox(tr("Success"), tr("Successfully imported favorite from JSON file: %1").arg(filename), QMessageBox::Information);
            } else {
                QString szErr = tr("Failed to import favorite from JSON file: %1").arg(filename) + "\n";
                if(!m_pDatabase->GetError().isEmpty())
                    szErr += "\n" + tr("Error: ") + m_pDatabase->GetError();
                emit sigShowMessageBox(tr("Failure"), szErr, QMessageBox::Critical);
            }
        }
    }
    if(bRet)
        event->accept();
 
    const CFavoriteMimeData *pData = qobject_cast<const CFavoriteMimeData*>(event->mimeData());
    if(!pData || pData->m_Items.isEmpty() || !m_pTreeView || !m_pModel) {
        event->ignore();
        return;
    }
 
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    auto idxParent = m_pTreeView->indexAt(event->position().toPoint());
#else
    auto idxParent = m_pTreeView->indexAt(event->pos());
#endif
    QVariant v = m_pModel->data(idxParent, CFavoriteModel::RoleItem);
    CFavoriteDatabase::Item item(TreeItem::TYPE::Node);
    if(v.isValid())
        item = v.value<CFavoriteDatabase::Item>();
    if(0 <= item.id && item.isFolder())
    {
        foreach(auto i, pData->m_Items)
        {
            if(i == idxParent) {
                qWarning(log) << "Don't drag, the same node.";
                break;
            }
            if (event->dropAction() == Qt::MoveAction)
                bRet = m_pModel->Move(i, idxParent);
            else if (event->dropAction() == Qt::CopyAction)
                bRet = m_pModel->Copy(i, idxParent);
            if(!bRet) break;
        }
    } else {
        qWarning(log) << "Don't group node. the id:" << item.id
                      << " Folder:" << item.isFolder();
    }
 
    if(bRet)
        event->accept();
    else
        event->ignore();
}
 
void CFavoriteView::mousePressEvent(QMouseEvent *event)
{
    qDebug(log) << "mousePressEvent";
    if (m_pTreeView && m_pTreeView->selectionModel()
        && event->button() == Qt::LeftButton) {
 
        // 获取选中的索引
        QModelIndexList indexes = m_pTreeView->selectionModel()->selectedIndexes();
        if (!indexes.isEmpty()) {
 
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
            auto curIndex = m_pTreeView->indexAt(event->position().toPoint());
#else
            auto curIndex = m_pTreeView->indexAt(event->pos());
#endif
            if(indexes.contains(curIndex)) {
                QDrag *drag = new QDrag(this);
                do {
                    if(!drag) break;
                    m_DragStartPosition = event->pos();
                    CFavoriteMimeData *pData = new CFavoriteMimeData();
                    pData->m_Items = indexes;
                    drag->setMimeData(pData);
                    Qt::DropAction dropAction = Qt::MoveAction;
                    /*
                    if(event->modifiers() & Qt::ControlModifier) {
                        dropAction = Qt::CopyAction;
                        // 设置拖拽时的光标
                        // QIcon icon = QIcon::fromTheme("edit-copy");
                        // QSize size(16, 16);
                        // if(!icon.availableSizes().isEmpty())
                        //     size = icon.availableSizes().at(0);
                        // drag->setDragCursor(icon.pixmap(size), Qt::MoveAction);
                    }//*/
                    drag->exec(dropAction);
                } while(0);
                if(drag)
                    delete drag;
            }
        }
    }
    QWidget::mousePressEvent(event);
}
 
void CFavoriteView::mouseMoveEvent(QMouseEvent *event)
{
    qDebug(log) << "mouseMoveEvent";
    do{
        if (!(event->buttons() & Qt::LeftButton))
            break;
        if ((event->pos() - m_DragStartPosition).manhattanLength()
                < QApplication::startDragDistance())
            break;
        qDebug(log) << "mouseMoveEvent drag";
        
    } while (false);
    
    QWidget::mouseMoveEvent(event);
}
 
bool CFavoriteView::eventFilter(QObject *watched, QEvent *event)
{
    // 处理 treeview 的事件
    if (watched == m_pTreeView->viewport()) { // 处理 viewport 的事件
        //qDebug(log) << Q_FUNC_INFO << "Viewport event:" << event->type();
 
        switch (event->type()) {
        case QEvent::DragEnter:
            dragEnterEvent(static_cast<QDragEnterEvent*>(event));
            return true;
        case QEvent::DragMove:
            dragMoveEvent(static_cast<QDragMoveEvent*>(event));
            return true;
        case QEvent::Drop:
            dropEvent(static_cast<QDropEvent*>(event));
            return true;
        case QEvent::MouseButtonPress:
            mousePressEvent(static_cast<QMouseEvent*>(event));
            // 不返回true，让 viewport 也处理
            break;
        case QEvent::MouseMove:
            mouseMoveEvent(static_cast<QMouseEvent*>(event));
            // 不返回true，让 viewport 也处理
            break;
        default:
            break;
        }
    }
 
    return QWidget::eventFilter(watched, event);
}