1.HGImgView：不处理dropEvent事件，改为信号，由调用者处理

2.HGImgThumb：增加多张图片添加和插入函数

app/Scanner/Scanner/mainwindow.cpp

 #include "mainwindow.h"
 #include "ui_mainwindow.h"
-#include "../../../imgfmt/HGImgFmt.h"
-#include <math.h>
 #include <QDockWidget>
+#include <QFileDialog>
+#include "../../../imgfmt/HGPdf.h"
+#include "../../../imgfmt/HGImgFmt.h"
 
 MainWindow::MainWindow(QWidget *parent)
     : QMainWindow(parent)
     , ui(new Ui::MainWindow)
+    , m_currIndex(-1)
+    , m_multiIndex(-1)
 {
     ui->setupUi(this);
 
@@ -41,6 +44,7 @@ MainWindow::MainWindow(QWidget *parent)
     ui->dockWidget->setTitleBarWidget(new QWidget());
     ui->dockWidget->titleBarWidget()->setVisible(false);
 
+    connect(m_view, SIGNAL(drop(const QString &)), this, SLOT(on_viewerDrop(const QString &)));
     connect(m_thumb, SIGNAL(currItemChanged(int)), this, SLOT(on_currItemChanged(int)));
     connect(m_thumb, SIGNAL(itemDoubleClicked(int)), this, SLOT(on_itemDoubleClicked(int)));
 
@@ -107,28 +111,12 @@ MainWindow::MainWindow(QWidget *parent)
                                    &vScrollSliderHotImage, &vSliderStretchRect, &vScrollSliderPushImage, &vSliderStretchRect);
     m_view->setVScrollSliderImage(&vScrollSliderNormalImage, &vSliderStretchRect,
                                    &vScrollSliderHotImage, &vSliderStretchRect, &vScrollSliderPushImage, &vSliderStretchRect);
-
-#ifdef HG_CMP_MSC
-
-    HGImage img = NULL;
-    HGImgFmt_LoadImage("D:\\1.jpg", 0, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
-    m_view->addImage(img);
-    HGBase_DestroyImage(img);
-
-    for (int i = 0; i < 10; ++i)
-    {
-        char fileName[256];
-        sprintf(fileName, "D:\\Pictures\\%d.jpg", i);
-        m_thumb->addItem(fileName);
-    }
-
-    m_thumb->setCurrItem(0);
-
-#endif
 }
 
 MainWindow::~MainWindow()
 {
+    m_thumb->removeAllItems(HGImgThumb::ThumbRemoveFlag_NULL);
+
     delete ui;
 }
 
@@ -194,12 +182,69 @@ void MainWindow::on_act_fullscreen_triggered()
 
 void MainWindow::on_currItemChanged(int index)
 {
-    Q_UNUSED(index);
+    m_currIndex = index;
+    m_multiIndex = (-1 != m_currIndex) ? 0 : -1;
+
+    if (-1 != m_currIndex)
+    {
+        HGImage img = createImage();
+        if (NULL != img)
+        {
+            m_view->addImage(img);
+            HGBase_DestroyImage(img);
+        }
+        else
+        {
+            m_view->clearImage();
+        }
+    }
+    else
+    {
+        m_view->clearImage();
+    }
 }
 
 void MainWindow::on_itemDoubleClicked(int index)
 {
-    openImageFile(index);
+    (void)index;
+}
+
+void MainWindow::on_viewerDrop(const QString &fileName)
+{
+    HGImage img = NULL;
+
+    HGUInt imgFmt = 0;
+    HGImgFmt_GetImgFmtType(fileName.toStdString().c_str(), &imgFmt);
+    if (HGIMGFMT_TYPE_PDF == imgFmt)
+    {
+        HGPdfReader pdfReader = NULL;
+        HGImgFmt_OpenPdfReader(fileName.toStdString().c_str(), &pdfReader);
+        if (NULL != pdfReader)
+        {
+            HGPdfPageInfo pageInfo = {0, 0};
+            if (HGBASE_ERR_OK == HGImgFmt_GetPdfPageInfo(pdfReader, 0, &pageInfo))
+            {
+                float scale = 1.0f;
+                if (pageInfo.width < 1600)
+                    scale = 1600.0f / (float)pageInfo.width;
+                HGImgFmt_LoadImageFromPdfReader(pdfReader, 0, scale, scale, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
+            }
+
+            HGImgFmt_ClosePdfReader(pdfReader);
+        }
+    }
+    else
+    {
+        HGImgFmt_LoadImage(fileName.toStdString().c_str(), 0, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
+    }
+
+    if (NULL == img)
+    {
+        return;
+    }
+
+    m_view->addImage(img);
+    HGBase_DestroyImage(img);
 }
 
 void MainWindow::on_act_thumbnailBar_triggered(bool checked)
@@ -209,12 +254,11 @@ void MainWindow::on_act_thumbnailBar_triggered(bool checked)
 
 void MainWindow::on_act_previous_triggered()
 {
-    int curIndex = -1;
-    m_thumb->getCurrItem(&curIndex);
-    if (curIndex > 0)
+    int count = 0;
+    m_thumb->getItemCount(&count);
+    if (count > 0 && m_currIndex > 0)
     {
-        m_thumb->setCurrItem(curIndex - 1);
-        openImageFile(curIndex - 1);
+        m_thumb->setCurrItem(m_currIndex - 1);
     }
 }
 
@@ -222,44 +266,245 @@ void MainWindow::on_act_next_triggered()
 {
     int count = 0;
     m_thumb->getItemCount(&count);
-
-    int curIndex = -1;
-    m_thumb->getCurrItem(&curIndex);
-    if (curIndex != -1 && curIndex < count - 1)
+    if (count > 0 && m_currIndex != -1 && m_currIndex < count - 1)
     {
-        m_thumb->setCurrItem(curIndex + 1);
-        openImageFile(curIndex + 1);
+        m_thumb->setCurrItem(m_currIndex + 1);
     }
 }
 
 void MainWindow::on_act_first_triggered()
 {
-    m_thumb->setCurrItem(0);
-    openImageFile(0);
+    int count = 0;
+    m_thumb->getItemCount(&count);
+    if (count > 0)
+    {
+        m_thumb->setCurrItem(0);
+    }
 }
 
 void MainWindow::on_act_last_triggered()
 {
     int count = 0;
     m_thumb->getItemCount(&count);
+    if (count > 0)
+    {
+        m_thumb->setCurrItem(count - 1);
+    }
+}
+
+HGImage MainWindow::createImage()
+{
+    assert(-1 != m_currIndex);
+
+    QString fileName;
+    m_thumb->getItemFileName(m_currIndex, fileName);
+    assert(!fileName.isEmpty());
+
+    HGImage img = NULL;
+
+    HGUInt imgFmt = 0;
+    HGImgFmt_GetImgFmtType(fileName.toStdString().c_str(), &imgFmt);
+    if (HGIMGFMT_TYPE_PDF == imgFmt)
+    {
+        HGPdfReader pdfReader = NULL;
+        HGImgFmt_OpenPdfReader(fileName.toStdString().c_str(), &pdfReader);
+        if (NULL != pdfReader)
+        {
+            HGPdfPageInfo pageInfo = {0, 0};
+            if (HGBASE_ERR_OK == HGImgFmt_GetPdfPageInfo(pdfReader, (HGUInt)m_multiIndex, &pageInfo))
+            {
+                float scale = 1.0f;
+                if (pageInfo.width < 1600)
+                    scale = 1600.0f / (float)pageInfo.width;
+                HGImgFmt_LoadImageFromPdfReader(pdfReader, (HGUInt)m_multiIndex, scale, scale, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
+            }
+        }
+
+        HGImgFmt_ClosePdfReader(pdfReader);
+    }
+    else
+    {
+        HGImgFmtReader imgFmtReader = NULL;
+        HGImgFmt_OpenImageReader(fileName.toStdString().c_str(), 0, &imgFmtReader);
+        if (NULL != imgFmtReader)
+        {
+            HGImgFmt_LoadImageFromReader(imgFmtReader, (HGUInt)m_multiIndex, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
+            HGImgFmt_CloseImageReader(imgFmtReader);
+        }
+    }
 
-    m_thumb->setCurrItem(count - 1);
-    openImageFile(count - 1);
+    return img;
 }
 
-void MainWindow::openImageFile(int index)
+int MainWindow::getMultiPageCount()
 {
-    if (-1 != index)
+    assert(-1 != m_currIndex);
+
+    QString fileName;
+    m_thumb->getItemFileName(m_currIndex, fileName);
+    assert(!fileName.isEmpty());
+
+    int count = 0;
+
+    HGImgFmtReader imgFmtReader = NULL;
+    HGImgFmt_OpenImageReader(fileName.toStdString().c_str(), 0, &imgFmtReader);
+    if (NULL != imgFmtReader)
     {
-        QString fileName;
-        m_thumb->getItemFileName(index, fileName);
+        HGImgFmt_GetImagePageCount(imgFmtReader, (HGUInt *)&count);
+        HGImgFmt_CloseImageReader(imgFmtReader);
+    }
 
-        HGImage img = NULL;
-        HGImgFmt_LoadImage(fileName.toStdString().c_str(), 0, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
+    return count;
+}
+
+void MainWindow::on_act_openPageNum_triggered()
+{
+
+}
+
+void MainWindow::on_act_previousPage_triggered()
+{
+    if (-1 == m_currIndex)
+    {
+        return;
+    }
+
+    int multiCount = getMultiPageCount();
+    if (multiCount > 0 && m_multiIndex > 0)
+    {
+        --m_multiIndex;
+
+        HGImage img = createImage();
+        if (NULL != img)
+        {
+            m_view->addImage(img);
+            HGBase_DestroyImage(img);
+        }
+        else
+        {
+            m_view->clearImage();
+        }
+    }
+}
+
+void MainWindow::on_act_nextPage_triggered()
+{
+    if (-1 == m_currIndex)
+    {
+        return;
+    }
+
+    int multiCount = getMultiPageCount();
+    if (multiCount > 0 && -1 != m_multiIndex && m_multiIndex < multiCount - 1)
+    {
+        ++m_multiIndex;
+
+        HGImage img = createImage();
+        if (NULL != img)
+        {
+            m_view->addImage(img);
+            HGBase_DestroyImage(img);
+        }
+        else
+        {
+            m_view->clearImage();
+        }
+    }
+}
+
+void MainWindow::on_act_firstPage_triggered()
+{
+    if (-1 == m_currIndex)
+    {
+        return;
+    }
+
+    int multiCount = getMultiPageCount();
+    if (multiCount > 0 && 0 != m_multiIndex)
+    {
+        m_multiIndex = 0;
+
+        HGImage img = createImage();
+        if (NULL != img)
+        {
+            m_view->addImage(img);
+            HGBase_DestroyImage(img);
+        }
+        else
+        {
+            m_view->clearImage();
+        }
+    }
+}
+
+void MainWindow::on_act_lastPage_triggered()
+{
+    if (-1 == m_currIndex)
+    {
+        return;
+    }
+
+    int multiCount = getMultiPageCount();
+    if (multiCount > 0 && m_multiIndex != multiCount - 1)
+    {
+        m_multiIndex = multiCount - 1;
+
+        HGImage img = createImage();
         if (NULL != img)
         {
             m_view->addImage(img);
             HGBase_DestroyImage(img);
         }
+        else
+        {
+            m_view->clearImage();
+        }
+    }
+}
+
+void MainWindow::on_act_adjust_triggered()
+{
+
+}
+
+void MainWindow::on_act_open_triggered()
+{
+    QStringList fileNames = QFileDialog::getOpenFileNames(nullptr, tr("Open images"), "", "(*.jpg *.jpeg *.png *.bmp *.pdf *.tif *.tiff *.ofd)");
+    m_thumb->addItems(fileNames);
+}
+
+void MainWindow::on_act_insert_triggered()
+{
+    QStringList fileNames = QFileDialog::getOpenFileNames(nullptr, tr("Insert images"), "", "(*.jpg *.jpeg *.png *.bmp *.pdf *.tif *.tiff *.ofd)");
+    if (-1 != m_currIndex)
+        m_thumb->insertItems(fileNames, m_currIndex);
+    else
+        m_thumb->addItems(fileNames);
+}
+
+void MainWindow::on_act_closeFile_triggered()
+{
+    std::vector<int> selectIndexs;
+
+    int count = 0;
+    m_thumb->getItemCount(&count);
+    for (int i = 0; i < count; ++i)
+    {
+        bool select = false;
+        m_thumb->itemIsSelect(i, &select);
+        if (select)
+            selectIndexs.push_back(i);
     }
+
+    m_thumb->removeItems(selectIndexs, HGImgThumb::ThumbRemoveFlag_NULL);
+}
+
+void MainWindow::on_act_closeAll_triggered()
+{
+    m_thumb->removeAllItems(HGImgThumb::ThumbRemoveFlag_NULL);
+}
+
+void MainWindow::on_act_exit_triggered()
+{
+    close();
 }

app/Scanner/Scanner/mainwindow.h

@@ -45,6 +45,7 @@ private slots:
 private slots:
     void on_currItemChanged(int index);
     void on_itemDoubleClicked(int index);
+    void on_viewerDrop(const QString &fileName);
 
     void on_act_thumbnailBar_triggered(bool checked);
 
@@ -56,12 +57,38 @@ private slots:
 
     void on_act_last_triggered();
 
+    void on_act_openPageNum_triggered();
+
+    void on_act_previousPage_triggered();
+
+    void on_act_nextPage_triggered();
+
+    void on_act_firstPage_triggered();
+
+    void on_act_lastPage_triggered();
+
+    void on_act_adjust_triggered();
+
+    void on_act_open_triggered();
+
+    void on_act_insert_triggered();
+
+    void on_act_closeFile_triggered();
+
+    void on_act_closeAll_triggered();
+
+    void on_act_exit_triggered();
+
 private:
-    void openImageFile(int index);
+    HGImage createImage();
+    int getMultiPageCount();
 
 private:
     Ui::MainWindow *ui;
     HGImgView *m_view;
     HGImgThumb *m_thumb;
+
+    int m_currIndex;
+    int m_multiIndex;
 };
 #endif // MAINWINDOW_H

build/windows/HGTwainUser/HGImgFmt.def

@@ -4,6 +4,7 @@ EXPORTS
 
 HGImgFmt_GetImgFmtType
 HGImgFmt_GetImgFmtTypeFromFileName
+HGImgFmt_IsMultiImgFmtType
 HGImgFmt_LoadImage
 HGImgFmt_SaveImage
 HGImgFmt_OpenImageReader

ui/HGImgThumb.cpp

@@ -24,20 +24,20 @@ HGImgThumb::HGImgThumb(QWidget* parent)
     m_minScrollSliderSize = 8;
     m_itemSize = 120;
     m_itemTextHeight = 20;
-    m_defItemImage = NULL;
-    m_itemImage = NULL;
+    m_defItemImage = nullptr;
+    m_itemImage = nullptr;
     for (int i = 0; i < 3; ++i)
     {
-        m_hScrollLeftImage[i] = NULL;
-        m_hScrollRightImage[i] = NULL;
-        m_vScrollTopImage[i] = NULL;
-        m_vScrollBottomImage[i] = NULL;
-        m_hScrollSliderImage[i] = NULL;
-        m_vScrollSliderImage[i] = NULL;
+        m_hScrollLeftImage[i] = nullptr;
+        m_hScrollRightImage[i] = nullptr;
+        m_vScrollTopImage[i] = nullptr;
+        m_vScrollBottomImage[i] = nullptr;
+        m_hScrollSliderImage[i] = nullptr;
+        m_vScrollSliderImage[i] = nullptr;
     }
-    m_hScrollImage = NULL;
-    m_vScrollImage = NULL;
-    m_nullScrollImage = NULL;
+    m_hScrollImage = nullptr;
+    m_vScrollImage = nullptr;
+    m_nullScrollImage = nullptr;
     m_type = ThumbType_Grid;
 
     m_mouseOn = false;
@@ -79,42 +79,42 @@ HGImgThumb::~HGImgThumb()
     m_stopThread = true;
     HGBase_SetEvent(m_event);
     HGBase_CloseThread(m_thread);
-    m_thread = NULL;
+    m_thread = nullptr;
 
     delete m_hScrollImage;
-    m_hScrollImage = NULL;
+    m_hScrollImage = nullptr;
     delete m_vScrollImage;
-    m_vScrollImage = NULL;
+    m_vScrollImage = nullptr;
     delete m_nullScrollImage;
-    m_nullScrollImage = NULL;
+    m_nullScrollImage = nullptr;
     for (int i = 0; i < 3; ++i)
     {
         delete m_hScrollLeftImage[i];
-        m_hScrollLeftImage[i] = NULL;
+        m_hScrollLeftImage[i] = nullptr;
         delete m_hScrollRightImage[i];
-        m_hScrollRightImage[i] = NULL;
+        m_hScrollRightImage[i] = nullptr;
         delete m_vScrollTopImage[i];
-        m_vScrollTopImage[i] = NULL;
+        m_vScrollTopImage[i] = nullptr;
         delete m_vScrollBottomImage[i];
-        m_vScrollBottomImage[i] = NULL;
+        m_vScrollBottomImage[i] = nullptr;
         delete m_hScrollSliderImage[i];
-        m_hScrollSliderImage[i] = NULL;
+        m_hScrollSliderImage[i] = nullptr;
         delete m_vScrollSliderImage[i];
-        m_vScrollSliderImage[i] = NULL;
+        m_vScrollSliderImage[i] = nullptr;
     }
     delete m_itemImage;
-    m_itemImage = NULL;
+    m_itemImage = nullptr;
     delete m_defItemImage;
-    m_defItemImage = NULL;
+    m_defItemImage = nullptr;
 
     HGBase_DestroyEvent(m_event);
-    m_event = NULL;
+    m_event = nullptr;
     HGBase_DestroyLock(m_lockItemSize);
-    m_lockItemSize = NULL;
+    m_lockItemSize = nullptr;
     HGBase_DestroyLock(m_lockBack);
-    m_lockBack = NULL;
+    m_lockBack = nullptr;
     HGBase_DestroyLock(m_lockFront);
-    m_lockFront = NULL;
+    m_lockFront = nullptr;
 
     qDebug("~HGImgThumb");
 }
@@ -207,12 +207,12 @@ HGResult HGImgThumb::setItemSize(int size)
     HGBase_EnterLock(m_lockItemSize);
     m_itemSize = size;
     HGBase_LeaveLock(m_lockItemSize);
-    if (NULL != m_defItemImage)
+    if (nullptr != m_defItemImage)
     {
-        assert(NULL != m_itemImage);
+        assert(nullptr != m_itemImage);
         delete m_itemImage;
         m_itemImage = createItemImage(m_defItemImage, m_itemSize);
-        assert(NULL != m_itemImage);
+        assert(nullptr != m_itemImage);
     }
 
     return HGBASE_ERR_OK;
@@ -251,12 +251,12 @@ HGResult HGImgThumb::setDefItemImage(const QImage *image)
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == image)
+    if (nullptr == image)
     {
         delete m_itemImage;
-        m_itemImage = NULL;
+        m_itemImage = nullptr;
         delete m_defItemImage;
-        m_defItemImage = NULL;
+        m_defItemImage = nullptr;
         return HGBASE_ERR_OK;
     }
 
@@ -267,20 +267,20 @@ HGResult HGImgThumb::setDefItemImage(const QImage *image)
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL != m_defItemImage)
+    if (nullptr != m_defItemImage)
     {
-        assert(NULL != m_itemImage);
+        assert(nullptr != m_itemImage);
         delete m_itemImage;
         delete m_defItemImage;
     }
     else
     {
-        assert(NULL == m_itemImage);
+        assert(nullptr == m_itemImage);
     }
 
     m_defItemImage = img;
     m_itemImage = createItemImage(m_defItemImage, m_itemSize);
-    assert(NULL != m_itemImage);
+    assert(nullptr != m_itemImage);
     return HGBASE_ERR_OK;
 }
 
@@ -296,17 +296,17 @@ HGResult HGImgThumb::setHScrollLeftImage(const QImage *normalImage, const QImage
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == normalImage)
+    if (nullptr == normalImage)
     {
         delete m_hScrollLeftImage[0];
-        m_hScrollLeftImage[0] = NULL;
+        m_hScrollLeftImage[0] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*normalImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollLeftImage[0])
+            if (nullptr != m_hScrollLeftImage[0])
                 delete m_hScrollLeftImage[0];
             m_hScrollLeftImage[0] = img;
         }
@@ -316,17 +316,17 @@ HGResult HGImgThumb::setHScrollLeftImage(const QImage *normalImage, const QImage
         }
     }
 
-    if (NULL == hotImage)
+    if (nullptr == hotImage)
     {
         delete m_hScrollLeftImage[1];
-        m_hScrollLeftImage[1] = NULL;
+        m_hScrollLeftImage[1] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*hotImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollLeftImage[1])
+            if (nullptr != m_hScrollLeftImage[1])
                 delete m_hScrollLeftImage[1];
             m_hScrollLeftImage[1] = img;
         }
@@ -336,17 +336,17 @@ HGResult HGImgThumb::setHScrollLeftImage(const QImage *normalImage, const QImage
         }
     }
 
-    if (NULL == pushImage)
+    if (nullptr == pushImage)
     {
         delete m_hScrollLeftImage[2];
-        m_hScrollLeftImage[2] = NULL;
+        m_hScrollLeftImage[2] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*pushImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollLeftImage[2])
+            if (nullptr != m_hScrollLeftImage[2])
                 delete m_hScrollLeftImage[2];
             m_hScrollLeftImage[2] = img;
         }
@@ -371,17 +371,17 @@ HGResult HGImgThumb::setHScrollRightImage(const QImage *normalImage, const QImag
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == normalImage)
+    if (nullptr == normalImage)
     {
         delete m_hScrollRightImage[0];
-        m_hScrollRightImage[0] = NULL;
+        m_hScrollRightImage[0] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*normalImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollRightImage[0])
+            if (nullptr != m_hScrollRightImage[0])
                 delete m_hScrollRightImage[0];
             m_hScrollRightImage[0] = img;
         }
@@ -391,17 +391,17 @@ HGResult HGImgThumb::setHScrollRightImage(const QImage *normalImage, const QImag
         }
     }
 
-    if (NULL == hotImage)
+    if (nullptr == hotImage)
     {
         delete m_hScrollRightImage[1];
-        m_hScrollRightImage[1] = NULL;
+        m_hScrollRightImage[1] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*hotImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollRightImage[1])
+            if (nullptr != m_hScrollRightImage[1])
                 delete m_hScrollRightImage[1];
             m_hScrollRightImage[1] = img;
         }
@@ -411,17 +411,17 @@ HGResult HGImgThumb::setHScrollRightImage(const QImage *normalImage, const QImag
         }
     }
 
-    if (NULL == pushImage)
+    if (nullptr == pushImage)
     {
         delete m_hScrollRightImage[2];
-        m_hScrollRightImage[2] = NULL;
+        m_hScrollRightImage[2] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*pushImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollRightImage[2])
+            if (nullptr != m_hScrollRightImage[2])
                 delete m_hScrollRightImage[2];
             m_hScrollRightImage[2] = img;
         }
@@ -446,17 +446,17 @@ HGResult HGImgThumb::setVScrollTopImage(const QImage *normalImage, const QImage
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == normalImage)
+    if (nullptr == normalImage)
     {
         delete m_vScrollTopImage[0];
-        m_vScrollTopImage[0] = NULL;
+        m_vScrollTopImage[0] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*normalImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollTopImage[0])
+            if (nullptr != m_vScrollTopImage[0])
                 delete m_vScrollTopImage[0];
             m_vScrollTopImage[0] = img;
         }
@@ -466,17 +466,17 @@ HGResult HGImgThumb::setVScrollTopImage(const QImage *normalImage, const QImage
         }
     }
 
-    if (NULL == hotImage)
+    if (nullptr == hotImage)
     {
         delete m_vScrollTopImage[1];
-        m_vScrollTopImage[1] = NULL;
+        m_vScrollTopImage[1] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*hotImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollTopImage[1])
+            if (nullptr != m_vScrollTopImage[1])
                 delete m_vScrollTopImage[1];
             m_vScrollTopImage[1] = img;
         }
@@ -486,17 +486,17 @@ HGResult HGImgThumb::setVScrollTopImage(const QImage *normalImage, const QImage
         }
     }
 
-    if (NULL == pushImage)
+    if (nullptr == pushImage)
     {
         delete m_vScrollTopImage[2];
-        m_vScrollTopImage[2] = NULL;
+        m_vScrollTopImage[2] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*pushImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollTopImage[2])
+            if (nullptr != m_vScrollTopImage[2])
                 delete m_vScrollTopImage[2];
             m_vScrollTopImage[2] = img;
         }
@@ -521,17 +521,17 @@ HGResult HGImgThumb::setVScrollBottomImage(const QImage *normalImage, const QIma
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == normalImage)
+    if (nullptr == normalImage)
     {
         delete m_vScrollBottomImage[0];
-        m_vScrollBottomImage[0] = NULL;
+        m_vScrollBottomImage[0] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*normalImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollBottomImage[0])
+            if (nullptr != m_vScrollBottomImage[0])
                 delete m_vScrollBottomImage[0];
             m_vScrollBottomImage[0] = img;
         }
@@ -541,17 +541,17 @@ HGResult HGImgThumb::setVScrollBottomImage(const QImage *normalImage, const QIma
         }
     }
 
-    if (NULL == hotImage)
+    if (nullptr == hotImage)
     {
         delete m_vScrollBottomImage[1];
-        m_vScrollBottomImage[1] = NULL;
+        m_vScrollBottomImage[1] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*hotImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollBottomImage[1])
+            if (nullptr != m_vScrollBottomImage[1])
                 delete m_vScrollBottomImage[1];
             m_vScrollBottomImage[1] = img;
         }
@@ -561,17 +561,17 @@ HGResult HGImgThumb::setVScrollBottomImage(const QImage *normalImage, const QIma
         }
     }
 
-    if (NULL == pushImage)
+    if (nullptr == pushImage)
     {
         delete m_vScrollBottomImage[2];
-        m_vScrollBottomImage[2] = NULL;
+        m_vScrollBottomImage[2] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*pushImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollBottomImage[2])
+            if (nullptr != m_vScrollBottomImage[2])
                 delete m_vScrollBottomImage[2];
             m_vScrollBottomImage[2] = img;
         }
@@ -596,21 +596,21 @@ HGResult HGImgThumb::setHScrollImage(const QImage *image, const HGRect *stretch)
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == image)
+    if (nullptr == image)
     {
         delete m_hScrollImage;
-        m_hScrollImage = NULL;
+        m_hScrollImage = nullptr;
     }
     else
     {
         QImage *img = new QImage(*image);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollImage)
+            if (nullptr != m_hScrollImage)
                 delete m_hScrollImage;
             m_hScrollImage = img;
 
-            if (NULL == stretch || stretch->left < 0 || stretch->top < 0
+            if (nullptr == stretch || stretch->left < 0 || stretch->top < 0
                     || stretch->right > m_hScrollImage->width() || stretch->bottom > m_hScrollImage->height()
                     || stretch->left >= stretch->right || stretch->top >= stretch->bottom)
             {
@@ -649,21 +649,21 @@ HGResult HGImgThumb::setHScrollSliderImage(const QImage *normalImage, const HGRe
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == normalImage)
+    if (nullptr == normalImage)
     {
         delete m_hScrollSliderImage[0];
-        m_hScrollSliderImage[0] = NULL;
+        m_hScrollSliderImage[0] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*normalImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollSliderImage[0])
+            if (nullptr != m_hScrollSliderImage[0])
                 delete m_hScrollSliderImage[0];
             m_hScrollSliderImage[0] = img;
 
-            if (NULL == normalStretch || normalStretch->left < 0 || normalStretch->top < 0
+            if (nullptr == normalStretch || normalStretch->left < 0 || normalStretch->top < 0
                     || normalStretch->right > m_hScrollSliderImage[0]->width() || normalStretch->bottom > m_hScrollSliderImage[0]->height()
                     || normalStretch->left >= normalStretch->right || normalStretch->top >= normalStretch->bottom)
             {
@@ -686,21 +686,21 @@ HGResult HGImgThumb::setHScrollSliderImage(const QImage *normalImage, const HGRe
         }
     }
 
-    if (NULL == hotImage)
+    if (nullptr == hotImage)
     {
         delete m_hScrollSliderImage[1];
-        m_hScrollSliderImage[1] = NULL;
+        m_hScrollSliderImage[1] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*hotImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollSliderImage[1])
+            if (nullptr != m_hScrollSliderImage[1])
                 delete m_hScrollSliderImage[1];
             m_hScrollSliderImage[1] = img;
 
-            if (NULL == hotStretch || hotStretch->left < 0 || hotStretch->top < 0
+            if (nullptr == hotStretch || hotStretch->left < 0 || hotStretch->top < 0
                     || hotStretch->right > m_hScrollSliderImage[1]->width() || hotStretch->bottom > m_hScrollSliderImage[1]->height()
                     || hotStretch->left >= hotStretch->right || hotStretch->top >= hotStretch->bottom)
             {
@@ -723,21 +723,21 @@ HGResult HGImgThumb::setHScrollSliderImage(const QImage *normalImage, const HGRe
         }
     }
 
-    if (NULL == pushImage)
+    if (nullptr == pushImage)
     {
         delete m_hScrollSliderImage[2];
-        m_hScrollSliderImage[2] = NULL;
+        m_hScrollSliderImage[2] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*pushImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollSliderImage[2])
+            if (nullptr != m_hScrollSliderImage[2])
                 delete m_hScrollSliderImage[2];
             m_hScrollSliderImage[2] = img;
 
-            if (NULL == pushStretch || pushStretch->left < 0 || pushStretch->top < 0
+            if (nullptr == pushStretch || pushStretch->left < 0 || pushStretch->top < 0
                     || pushStretch->right > m_hScrollSliderImage[2]->width() || pushStretch->bottom > m_hScrollSliderImage[2]->height()
                     || pushStretch->left >= pushStretch->right || pushStretch->top >= hotStretch->bottom)
             {
@@ -775,21 +775,21 @@ HGResult HGImgThumb::setVScrollImage(const QImage *image, const HGRect *stretch)
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == image)
+    if (nullptr == image)
     {
         delete m_vScrollImage;
-        m_vScrollImage = NULL;
+        m_vScrollImage = nullptr;
     }
     else
     {
         QImage *img = new QImage(*image);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollImage)
+            if (nullptr != m_vScrollImage)
                 delete m_vScrollImage;
             m_vScrollImage = img;
 
-            if (NULL == stretch || stretch->left < 0 || stretch->top < 0
+            if (nullptr == stretch || stretch->left < 0 || stretch->top < 0
                     || stretch->right > m_vScrollImage->width() || stretch->bottom > m_vScrollImage->height()
                     || stretch->left >= stretch->right || stretch->top >= stretch->bottom)
             {
@@ -828,21 +828,21 @@ HGResult HGImgThumb::setVScrollSliderImage(const QImage *normalImage, const HGRe
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == normalImage)
+    if (nullptr == normalImage)
     {
         delete m_vScrollSliderImage[0];
-        m_vScrollSliderImage[0] = NULL;
+        m_vScrollSliderImage[0] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*normalImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollSliderImage[0])
+            if (nullptr != m_vScrollSliderImage[0])
                 delete m_vScrollSliderImage[0];
             m_vScrollSliderImage[0] = img;
 
-            if (NULL == normalStretch || normalStretch->left < 0 || normalStretch->top < 0
+            if (nullptr == normalStretch || normalStretch->left < 0 || normalStretch->top < 0
                     || normalStretch->right > m_vScrollSliderImage[0]->width() || normalStretch->bottom > m_vScrollSliderImage[0]->height()
                     || normalStretch->left >= normalStretch->right || normalStretch->top >= normalStretch->bottom)
             {
@@ -865,21 +865,21 @@ HGResult HGImgThumb::setVScrollSliderImage(const QImage *normalImage, const HGRe
         }
     }
 
-    if (NULL == hotImage)
+    if (nullptr == hotImage)
     {
         delete m_vScrollSliderImage[1];
-        m_vScrollSliderImage[1] = NULL;
+        m_vScrollSliderImage[1] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*hotImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollSliderImage[1])
+            if (nullptr != m_vScrollSliderImage[1])
                 delete m_vScrollSliderImage[1];
             m_vScrollSliderImage[1] = img;
 
-            if (NULL == hotStretch || hotStretch->left < 0 || hotStretch->top < 0
+            if (nullptr == hotStretch || hotStretch->left < 0 || hotStretch->top < 0
                     || hotStretch->right > m_vScrollSliderImage[1]->width() || hotStretch->bottom > m_vScrollSliderImage[1]->height()
                     || hotStretch->left >= hotStretch->right || hotStretch->top >= hotStretch->bottom)
             {
@@ -902,21 +902,21 @@ HGResult HGImgThumb::setVScrollSliderImage(const QImage *normalImage, const HGRe
         }
     }
 
-    if (NULL == pushImage)
+    if (nullptr == pushImage)
     {
         delete m_vScrollSliderImage[2];
-        m_vScrollSliderImage[2] = NULL;
+        m_vScrollSliderImage[2] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*pushImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollSliderImage[2])
+            if (nullptr != m_vScrollSliderImage[2])
                 delete m_vScrollSliderImage[2];
             m_vScrollSliderImage[2] = img;
 
-            if (NULL == pushStretch || pushStretch->left < 0 || pushStretch->top < 0
+            if (nullptr == pushStretch || pushStretch->left < 0 || pushStretch->top < 0
                     || pushStretch->right > m_vScrollSliderImage[2]->width() || pushStretch->bottom > m_vScrollSliderImage[2]->height()
                     || pushStretch->left >= pushStretch->right || pushStretch->top >= hotStretch->bottom)
             {
@@ -954,17 +954,17 @@ HGResult HGImgThumb::setNullScrollImage(const QImage *image)
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == image)
+    if (nullptr == image)
     {
         delete m_nullScrollImage;
-        m_nullScrollImage = NULL;
+        m_nullScrollImage = nullptr;
     }
     else
     {
         QImage *img = new QImage(*image);
         if (!img->isNull())
         {
-            if (NULL != m_nullScrollImage)
+            if (nullptr != m_nullScrollImage)
                 delete m_nullScrollImage;
             m_nullScrollImage = img;
         }
@@ -1035,12 +1035,12 @@ HGResult HGImgThumb::zoomIn()
     HGBase_EnterLock(m_lockItemSize);
     m_itemSize = newItemSize;
     HGBase_LeaveLock(m_lockItemSize);
-    if (NULL != m_defItemImage)
+    if (nullptr != m_defItemImage)
     {
-        assert(NULL != m_itemImage);
+        assert(nullptr != m_itemImage);
         delete m_itemImage;
         m_itemImage = createItemImage(m_defItemImage, m_itemSize);
-        assert(NULL != m_itemImage);
+        assert(nullptr != m_itemImage);
     }
 
     int showWidth = 0, showHeight = 0;
@@ -1090,12 +1090,12 @@ HGResult HGImgThumb::zoomOut()
     HGBase_EnterLock(m_lockItemSize);
     m_itemSize = newItemSize;
     HGBase_LeaveLock(m_lockItemSize);
-    if (NULL != m_defItemImage)
+    if (nullptr != m_defItemImage)
     {
-        assert(NULL != m_itemImage);
+        assert(nullptr != m_itemImage);
         delete m_itemImage;
         m_itemImage = createItemImage(m_defItemImage, m_itemSize);
-        assert(NULL != m_itemImage);
+        assert(nullptr != m_itemImage);
     }
 
     int showWidth = 0, showHeight = 0;
@@ -1123,7 +1123,7 @@ HGResult HGImgThumb::zoomOut()
 
 HGResult HGImgThumb::getItemCount(int *count)
 {
-    if (NULL == count)
+    if (nullptr == count)
     {
         return HGBASE_ERR_INVALIDARG;
     }
@@ -1134,110 +1134,154 @@ HGResult HGImgThumb::getItemCount(int *count)
 
 HGResult HGImgThumb::addItem(const QString &fileName)
 {
-    if (fileName.isEmpty())
+    QStringList fileNames;
+    fileNames.append(fileName);
+    return addItems(fileNames);
+}
+
+HGResult HGImgThumb::addItems(const QStringList &fileNames)
+{
+    return insertItems(fileNames, (int)m_frontItems.size());
+}
+
+HGResult HGImgThumb::insertItem(const QString &fileName, int pos)
+{
+    QStringList fileNames;
+    fileNames.append(fileName);
+    return insertItems(fileNames, pos);
+}
+
+HGResult HGImgThumb::insertItems(const QStringList &fileNames, int pos)
+{
+    if (pos < 0 || pos > (int)m_frontItems.size())
     {
         return HGBASE_ERR_INVALIDARG;
     }
 
-    QString stdFileName = getStdFileName(fileName);
-    if (-1 != findIndex(stdFileName))
+    std::vector<QString> stdFileNames;
+    for (int i = 0; i < (int)fileNames.size(); ++i)
     {
-        return HGBASE_ERR_FAIL;
+        if (fileNames[i].isEmpty())
+        {
+            return HGBASE_ERR_INVALIDARG;
+        }
+
+        QString stdFileName = getStdFileName(fileNames[i]);
+
+        bool find = false;
+        for (int j = 0; j < (int)stdFileNames.size(); ++j)
+        {
+            if (stdFileNames[j] == stdFileName)
+            {
+                find = true;
+                break;
+            }
+        }
+
+        if (!find)
+        {
+            stdFileNames.push_back(stdFileName);
+        }
+    }
+
+    if (stdFileNames.empty())
+    {
+        return HGBASE_ERR_INVALIDARG;
     }
 
     reset();
+
+    bool emitItemCount = false;
+    bool emitCurrItemChange = false;
+    bool emitSelectChanged = false;
+
     for (int i = 0; i < (int)m_frontItems.size(); ++i)
     {
         m_frontItems[i]->selected = false;
     }
 
-    HGImgThumbItem *item = new HGImgThumbItem;
-    item->fileName = stdFileName;
-    item->selected = true;
+    int posEx = pos;
 
-    HGBase_EnterLock(m_lockFront);
-    m_frontItems.push_back(item);
-    HGBase_LeaveLock(m_lockFront);
+    for (int i = 0; i < (int)stdFileNames.size(); ++i)
+    {
+        const QString &stdFileName = stdFileNames[i];
+        int oldIndex = findIndex(stdFileName);
+        if (-1 == oldIndex)
+        {
+            HGImgThumbItem *item = new HGImgThumbItem;
+            item->fileName = stdFileName;
+            item->selected = true;
 
-    HGBase_EnterLock(m_lockBack);
-    m_backList.push_back(stdFileName);
-    HGBase_LeaveLock(m_lockBack);
-    HGBase_SetEvent(m_event);
+            HGBase_EnterLock(m_lockFront);
+            item->selected = true;
+            if (posEx != (int)m_frontItems.size())
+                m_frontItems.insert(m_frontItems.begin() + posEx, item);
+            else
+                m_frontItems.push_back(item);
+            HGBase_LeaveLock(m_lockFront);
 
-    m_curItemIndex = (int)m_frontItems.size() - 1;
-    m_signItemIndex = (int)m_frontItems.size() - 1;
+            HGBase_EnterLock(m_lockBack);
+            m_backList.push_back(stdFileName);
+            HGBase_LeaveLock(m_lockBack);
+            HGBase_SetEvent(m_event);
 
-    int showWidth = 0, showHeight = 0;
-    calcShowSize(this->width(), this->height(), m_gapSize, m_scrollSize, m_itemSize, m_itemTextHeight, m_type, (int)m_frontItems.size(),
-        showWidth, showHeight, m_hScroll, m_vScroll);
-    assert(showWidth > 0 && showHeight > 0);
-    m_showThumb = true;
-    m_thumbRect.right = m_thumbRect.left + (double)showWidth;
-    m_thumbRect.bottom = m_thumbRect.top + (double)showHeight;
-    locateItem((int)m_frontItems.size() - 1);
-    recalcShowRect(this->width(), this->height(), m_scrollSize, m_type, m_hScroll, m_vScroll, m_showThumb, m_thumbRect);
+            ++posEx;
+        }
+        else
+        {
+            HGImgThumbItem *item = m_frontItems[oldIndex];
+            item->selected = true;
 
-    m_hotItemIndex = getItemIndex(mapFromGlobal(QCursor::pos()), m_mouseMoveStatus);
-    Show();
-    emit itemCountChanged((int)m_frontItems.size());
-    emit currItemChanged(m_curItemIndex);
-    emit itemSelectingChanged();
-    return HGBASE_ERR_OK;
-}
+            if (oldIndex < posEx)
+            {
+                if (pos == posEx)
+                {
+                    --pos;
+                }
 
-HGResult HGImgThumb::insertItem(const QString &fileName, int pos)
-{
-    if (fileName.isEmpty() || pos < 0 || pos > (int)m_frontItems.size())
-    {
-        return HGBASE_ERR_INVALIDARG;
-    }
+                --posEx;
+            }
 
-    QString stdFileName = getStdFileName(fileName);
-    if (-1 != findIndex(stdFileName))
-    {
-        return HGBASE_ERR_FAIL;
-    }
+            HGBase_EnterLock(m_lockFront);
+            m_frontItems.erase(m_frontItems.begin() + oldIndex);
+            if (posEx != (int)m_frontItems.size())
+                m_frontItems.insert(m_frontItems.begin() + posEx, item);
+            else
+                m_frontItems.push_back(item);
+            HGBase_LeaveLock(m_lockFront);
 
-    reset();
-    for (int i = 0; i < (int)m_frontItems.size(); ++i)
-    {
-        m_frontItems[i]->selected = false;
+            ++posEx;
+        }
     }
 
-    HGImgThumbItem *item = new HGImgThumbItem;
-    item->fileName = stdFileName;
-    item->selected = true;
-
-    HGBase_EnterLock(m_lockFront);
-    if (pos != (int)m_frontItems.size())
-        m_frontItems.insert(m_frontItems.begin() + pos, item);
-    else
-        m_frontItems.push_back(item);
-    HGBase_LeaveLock(m_lockFront);
-
-    HGBase_EnterLock(m_lockBack);
-    m_backList.push_back(stdFileName);
-    HGBase_LeaveLock(m_lockBack);
-    HGBase_SetEvent(m_event);
+    if (pos != posEx)
+    {
+        m_curItemIndex = posEx - 1;
+        m_signItemIndex = posEx - 1;
 
-    m_curItemIndex = pos;
-    m_signItemIndex = pos;
+        int showWidth = 0, showHeight = 0;
+        calcShowSize(this->width(), this->height(), m_gapSize, m_scrollSize, m_itemSize, m_itemTextHeight, m_type, (int)m_frontItems.size(),
+            showWidth, showHeight, m_hScroll, m_vScroll);
+        assert(showWidth > 0 && showHeight > 0);
+        m_showThumb = true;
+        m_thumbRect.right = m_thumbRect.left + (double)showWidth;
+        m_thumbRect.bottom = m_thumbRect.top + (double)showHeight;
+        locateItem(posEx - 1);
+        recalcShowRect(this->width(), this->height(), m_scrollSize, m_type, m_hScroll, m_vScroll, m_showThumb, m_thumbRect);
 
-    int showWidth = 0, showHeight = 0;
-    calcShowSize(this->width(), this->height(), m_gapSize, m_scrollSize, m_itemSize, m_itemTextHeight, m_type, (int)m_frontItems.size(),
-        showWidth, showHeight, m_hScroll, m_vScroll);
-    assert(showWidth > 0 && showHeight > 0);
-    m_showThumb = true;
-    m_thumbRect.right = m_thumbRect.left + (double)showWidth;
-    m_thumbRect.bottom = m_thumbRect.top + (double)showHeight;
-    locateItem(pos);
-    recalcShowRect(this->width(), this->height(), m_scrollSize, m_type, m_hScroll, m_vScroll, m_showThumb, m_thumbRect);
+        emitItemCount = true;
+        emitCurrItemChange = true;
+        emitSelectChanged = true;
+    }
 
     m_hotItemIndex = getItemIndex(mapFromGlobal(QCursor::pos()), m_mouseMoveStatus);
     Show();
-    emit itemCountChanged((int)m_frontItems.size());
-    emit currItemChanged(m_curItemIndex);
-    emit itemSelectingChanged();
+    if (emitItemCount)
+        emit itemCountChanged((int)m_frontItems.size());
+    if (emitCurrItemChange)
+        emit currItemChanged(m_curItemIndex);
+    if (emitSelectChanged)
+        emit itemSelectingChanged();
     return HGBASE_ERR_OK;
 }
 
@@ -1254,7 +1298,7 @@ HGResult HGImgThumb::getItemFileName(int index, QString &fileName)
 
 HGResult HGImgThumb::getCurrItem(int *index)
 {
-    if (NULL == index)
+    if (nullptr == index)
     {
         return HGBASE_ERR_INVALIDARG;
     }
@@ -1314,59 +1358,103 @@ HGResult HGImgThumb::setCurrItem(int index)
 }
 
 HGResult HGImgThumb::removeItem(int index, ThumbRemoveFlag flag)
+{
+    std::vector<int> indexs;
+    indexs.push_back(index);
+    return removeItems(indexs, flag);
+}
+
+HGResult HGImgThumb::removeItems(const std::vector<int> &indexs, ThumbRemoveFlag flag)
 {
     if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || m_frameSelection)
     {
         return HGBASE_ERR_FAIL;
     }
 
-    if (index < 0 || index >= (int)m_frontItems.size())
+    std::vector<int> indexs2;
+    for (int i = 0; i < (int)indexs.size(); ++i)
+    {
+        if (indexs[i] < 0 || indexs[i] >= (int)m_frontItems.size())
+        {
+            return HGBASE_ERR_INVALIDARG;
+        }
+
+        bool find = false;
+        for (int j = 0; j < (int)indexs2.size(); ++j)
+        {
+            if (indexs2[j] == indexs[i])
+            {
+                find = true;
+                break;
+            }
+        }
+
+        if (!find)
+        {
+            indexs2.push_back(indexs[i]);
+        }
+    }
+
+    if (indexs2.empty())
     {
         return HGBASE_ERR_INVALIDARG;
     }
 
     bool emitItemSelectingChange = false;
-    if (m_frontItems[index]->selected)
-        emitItemSelectingChange = true;
+    bool emitCurrItemChange = false;
 
-    HGBase_EnterLock(m_lockBack);
-    std::list<QString>::iterator iter;
-    for (iter = m_backList.begin(); iter != m_backList.end(); ++iter)
+    for (int i = 0; i < (int)indexs2.size(); ++i)
     {
-        if (0 == (*iter).compare(m_frontItems[index]->fileName))
+        int index = indexs2[i];
+        if (m_frontItems[index]->selected)
+            emitItemSelectingChange = true;
+
+        HGBase_EnterLock(m_lockBack);
+        std::list<QString>::iterator iter;
+        for (iter = m_backList.begin(); iter != m_backList.end(); ++iter)
         {
-            m_backList.erase(iter);
-            break;
+            if (0 == (*iter).compare(m_frontItems[index]->fileName))
+            {
+                m_backList.erase(iter);
+                break;
+            }
         }
-    }
-    HGBase_LeaveLock(m_lockBack);
+        HGBase_LeaveLock(m_lockBack);
 
-    if (flag == ThumbRemoveFlag::ThumbRemoveFlag_AllowUndo)
-        ;
-    else if (flag == ThumbRemoveFlag::ThumbRemoveFlag_Delete)
-        QFile::remove(m_frontItems[index]->fileName);
+        if (flag == ThumbRemoveFlag_AllowUndo)
+            ;
+        else if (flag == ThumbRemoveFlag_Delete)
+            QFile::remove(m_frontItems[index]->fileName);
 
-    HGBase_EnterLock(m_lockFront);
-    delete m_frontItems[index];
-    m_frontItems.erase(m_frontItems.begin() + index);
-    HGBase_LeaveLock(m_lockFront);
+        HGBase_EnterLock(m_lockFront);
+        delete m_frontItems[index];
+        m_frontItems.erase(m_frontItems.begin() + index);
+        HGBase_LeaveLock(m_lockFront);
 
-    bool emitItemChange = false;
-    if (m_curItemIndex == index)
-    {
-        m_curItemIndex = -1;
-        emitItemChange = true;
-    }
-    else if (m_curItemIndex > index)
-    {
-        --m_curItemIndex;
-        emitItemChange = true;
-    }
+        if (m_curItemIndex == index)
+        {
+            m_curItemIndex = -1;
+            emitCurrItemChange = true;
+        }
+        else if (m_curItemIndex > index)
+        {
+            --m_curItemIndex;
+            emitCurrItemChange = true;
+        }
 
-    if (m_signItemIndex == index)
-        m_signItemIndex = -1;
-    else if (m_signItemIndex > index)
-        --m_signItemIndex;
+        if (m_signItemIndex == index)
+            m_signItemIndex = -1;
+        else if (m_signItemIndex > index)
+            --m_signItemIndex;
+
+        for (int j = i + 1; j < (int)indexs2.size(); ++j)
+        {
+            if (indexs2[j] > index)
+            {
+                --indexs2[j];
+            }
+        }
+    }
 
     int showWidth = 0, showHeight = 0;
     calcShowSize(this->width(), this->height(), m_gapSize, m_scrollSize, m_itemSize, m_itemTextHeight, m_type, (int)m_frontItems.size(),
@@ -1386,7 +1474,7 @@ HGResult HGImgThumb::removeItem(int index, ThumbRemoveFlag flag)
     m_hotItemIndex = getItemIndex(mapFromGlobal(QCursor::pos()), m_mouseMoveStatus);
     Show();
     emit itemCountChanged((int)m_frontItems.size());
-    if (emitItemChange)
+    if (emitCurrItemChange)
         emit currItemChanged(m_curItemIndex);
     if (emitItemSelectingChange)
         emit itemSelectingChanged();
@@ -1413,9 +1501,9 @@ HGResult HGImgThumb::removeAllItems(ThumbRemoveFlag flag)
         if (m_frontItems[0]->selected)
             emitItemSelectingChange = true;
 
-        if (flag == ThumbRemoveFlag::ThumbRemoveFlag_AllowUndo)
+        if (flag == ThumbRemoveFlag_AllowUndo)
             ;
-        else if (flag == ThumbRemoveFlag::ThumbRemoveFlag_Delete)
+        else if (flag == ThumbRemoveFlag_Delete)
             QFile::remove(m_frontItems[0]->fileName);
 
         HGBase_EnterLock(m_lockFront);
@@ -1472,7 +1560,7 @@ HGResult HGImgThumb::selectItem(int index, bool select)
 
 HGResult HGImgThumb::itemIsSelect(int index, bool *select)
 {
-    if (index < 0 || index >= (int)m_frontItems.size() || NULL == select)
+    if (index < 0 || index >= (int)m_frontItems.size() || nullptr == select)
     {
         return HGBASE_ERR_INVALIDARG;
     }
@@ -1531,15 +1619,15 @@ HGResult HGImgThumb::refreshItem(int index)
         return HGBASE_ERR_INVALIDARG;
     }
 
-    HGImage image = NULL;
-    HGResult ret = HGImgFmt_LoadImage(m_frontItems[index]->fileName.toStdString().c_str(), 0, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &image);
-    if (NULL == image)
+    HGImage image = nullptr;
+    HGResult ret = HGImgFmt_LoadImage(m_frontItems[index]->fileName.toStdString().c_str(), 0, nullptr, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &image);
+    if (nullptr == image)
     {
         return ret;
     }
 
     QImage *img = createItemImage(image, m_itemSize);
-    if (NULL == img)
+    if (nullptr == img)
     {
         HGBase_DestroyImage(image);
         return HGBASE_ERR_FAIL;
@@ -1908,9 +1996,9 @@ void HGImgThumb::mouseMoveEvent(QMouseEvent* e)
             QPixmap pixmap;
             HGBase_EnterLock(m_lockFront);
             QImage *img = m_frontItems[m_curItemIndex]->image;
-            if (NULL == img)
+            if (nullptr == img)
                 img = m_itemImage;
-            if (NULL != img)
+            if (nullptr != img)
                 pixmap = QPixmap::fromImage(*img);
             HGBase_LeaveLock(m_lockFront);
 
@@ -2203,7 +2291,7 @@ void HGImgThumb::paintEvent(QPaintEvent* e)
 
     QPainter painter(this);
     QRect rcWnd(0, 0, this->width(), this->height());
-    painter.fillRect(rcWnd, qRgb(255, 255, 255));
+    painter.fillRect(rcWnd, qRgb(250, 250, 250));
     QFont font("微软雅黑", 8);
     painter.setFont(font);
 
@@ -2223,14 +2311,14 @@ void HGImgThumb::paintEvent(QPaintEvent* e)
         int imgOriginWidth = m_frontItems[i]->width;
         int imgOriginHeight = m_frontItems[i]->height;
         QImage *img = m_frontItems[i]->image;
-        if (NULL == img && NULL != m_itemImage)
+        if (nullptr == img && nullptr != m_itemImage)
         {
-            assert(NULL != m_defItemImage);
+            assert(nullptr != m_defItemImage);
             imgOriginWidth = m_defItemImage->width();
             imgOriginHeight = m_defItemImage->height();
             img = m_itemImage;
         }
-        if (NULL != img)
+        if (nullptr != img)
         {
             HGRect rcShow;
             HGRect rcItemShow = {pt.x(), pt.y(), pt.x() + m_itemSize, pt.y() + m_itemSize};
@@ -2869,7 +2957,7 @@ void HGImgThumb::dropEvent(QDropEvent *e)
     QList<QUrl> urls = e->mimeData()->urls();
     if (-1 != m_curInsertPos && !urls.isEmpty())
     {
-        for (int i = 0 ; i < (int)m_frontItems.size(); ++i)
+        for (int i = 0; i < (int)m_frontItems.size(); ++i)
         {
             m_frontItems[i]->selected = false;
         }
@@ -3000,9 +3088,9 @@ QString HGImgThumb::getStdFileName(const QString &fileName)
 
 QImage* HGImgThumb::createItemImage(const QImage *srcImage, int itemSize)
 {
-    assert(NULL != srcImage);
+    assert(nullptr != srcImage);
 
-    QImage *img = NULL;
+    QImage *img = nullptr;
     if (srcImage->width() > itemSize || srcImage->height() > itemSize)
     {
         int width, height;
@@ -3028,7 +3116,7 @@ QImage* HGImgThumb::createItemImage(const QImage *srcImage, int itemSize)
     if (img->isNull())
     {
         delete img;
-        return NULL;
+        return nullptr;
     }
 
     return img;
@@ -3036,7 +3124,7 @@ QImage* HGImgThumb::createItemImage(const QImage *srcImage, int itemSize)
 
 QImage* HGImgThumb::createItemImage(HGImage srcImage, int itemSize)
 {
-    assert(NULL != srcImage);
+    assert(nullptr != srcImage);
 
     HGImageInfo info;
     HGBase_GetImageInfo(srcImage, &info);
@@ -3048,15 +3136,15 @@ QImage* HGImgThumb::createItemImage(HGImage srcImage, int itemSize)
         fmt = QImage::Format_RGB888;
     if (QImage::Format_Invalid == fmt)
     {
-        return NULL;
+        return nullptr;
     }
 
-    HGByte *data = NULL;
+    HGByte *data = nullptr;
     HGBase_GetImageData(srcImage, &data);
     QImage img(data, info.width, info.height, info.widthStep, fmt);
     if (img.isNull())
     {
-        return NULL;
+        return nullptr;
     }
 
     return createItemImage(&img, itemSize);
@@ -3440,22 +3528,22 @@ void HGImgThumb::DrawScroll(QPainter &painter)
 
     if (m_hScroll)
     {
-        if (NULL == imgHScroll)
+        if (nullptr == imgHScroll)
             painter.fillRect(getHScrollPos(), clrHScroll);
         else
             DrawImage(painter, getHScrollPos(), imgHScroll, m_hScrollImageStretch);
 
-        if (NULL == imgHScrollLeft)
+        if (nullptr == imgHScrollLeft)
             painter.fillRect(getHScrollLeftPos(), clrHScrollLeft);
         else
             painter.drawImage(getHScrollLeftPos(), *imgHScrollLeft);
 
-        if (NULL == imgHScrollRight)
+        if (nullptr == imgHScrollRight)
             painter.fillRect(getHScrollRightPos(), clrHScrollRight);
         else
             painter.drawImage(getHScrollRightPos(), *imgHScrollRight);
 
-        if (NULL == imgHScrollSlider)
+        if (nullptr == imgHScrollSlider)
             painter.fillRect(getHScrollSliderPos(), clrHScrollSlider);
         else
             DrawImage(painter, getHScrollSliderPos(), imgHScrollSlider, hScrollSliderStretch);
@@ -3463,22 +3551,22 @@ void HGImgThumb::DrawScroll(QPainter &painter)
 
     if (m_vScroll)
     {
-        if (NULL == imgVScroll)
+        if (nullptr == imgVScroll)
             painter.fillRect(getVScrollPos(), clrVScroll);
         else
             DrawImage(painter, getVScrollPos(), imgVScroll, m_vScrollImageStretch);
 
-        if (NULL == imgVScrollTop)
+        if (nullptr == imgVScrollTop)
             painter.fillRect(getVScrollTopPos(), clrVScrollTop);
         else
             painter.drawImage(getVScrollTopPos(), *imgVScrollTop);
 
-        if (NULL == imgVScrollBottom)
+        if (nullptr == imgVScrollBottom)
             painter.fillRect(getVScrollBottomPos(), clrVScrollBottom);
         else
             painter.drawImage(getVScrollBottomPos(), *imgVScrollBottom);
 
-        if (NULL == imgVScrollSlider)
+        if (nullptr == imgVScrollSlider)
             painter.fillRect(getVScrollSliderPos(), clrVScrollSlider);
         else
             DrawImage(painter, getVScrollSliderPos(), imgVScrollSlider, vScrollSliderStretch);
@@ -3486,7 +3574,7 @@ void HGImgThumb::DrawScroll(QPainter &painter)
 
     if (m_hScroll && m_vScroll)
     {
-        if (NULL == nullScrollImage)
+        if (nullptr == nullScrollImage)
             painter.fillRect(getNullScrollPos(), clrNullScroll);
         else
             painter.drawImage(getNullScrollPos(), *nullScrollImage);
@@ -4212,15 +4300,15 @@ void HGImgThumb::ThreadFunc(HGThread thread, HGPointer param)
 
         if (!fileName.isEmpty())
         {
-            HGImage image = NULL;
-            HGImgFmt_LoadImage(fileName.toStdString().c_str(), 0, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &image);
-            if (NULL != image)
+            HGImage image = nullptr;
+            HGImgFmt_LoadImage(fileName.toStdString().c_str(), 0, nullptr, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &image);
+            if (nullptr != image)
             {
                 HGBase_EnterLock(p->m_lockItemSize);
                 int itemSize = p->m_itemSize;
                 HGBase_LeaveLock(p->m_lockItemSize);
                 QImage *img = createItemImage(image, itemSize);
-                if (NULL != img)
+                if (nullptr != img)
                 {
                     HGImageInfo imgInfo;
                     HGBase_GetImageInfo(image, &imgInfo);

ui/HGImgThumb.hpp

@@ -54,11 +54,14 @@ public:
 
     HGResult getItemCount(int *count);
     HGResult addItem(const QString &fileName);
+    HGResult addItems(const QStringList &fileNames);
     HGResult insertItem(const QString &fileName, int pos);
+    HGResult insertItems(const QStringList &fileNames, int pos);
     HGResult getItemFileName(int index, QString &fileName);
     HGResult getCurrItem(int *index);
     HGResult setCurrItem(int index);
     HGResult removeItem(int index, ThumbRemoveFlag flag);
+    HGResult removeItems(const std::vector<int> &indexs, ThumbRemoveFlag flag);
     HGResult removeAllItems(ThumbRemoveFlag flag);
     HGResult selectItem(int index, bool select);
     HGResult itemIsSelect(int index, bool *select);

ui/HGImgView.cpp

@@ -4,7 +4,7 @@
 #include <QPainter>
 #include <QToolTip>
 #include <QMimeData>
-#include "../imgfmt/HGImgFmt.h"
+#include "../base/HGUtility.h"
 
 HGImgView::HGImgView(QWidget* parent)
     : QWidget(parent)
@@ -13,22 +13,22 @@ HGImgView::HGImgView(QWidget* parent)
     m_minScrollSliderSize = 8;
     for (int i = 0; i < 3; ++i)
     {
-        m_hScrollLeftImage[i] = NULL;
-        m_hScrollRightImage[i] = NULL;
-        m_vScrollTopImage[i] = NULL;
-        m_vScrollBottomImage[i] = NULL;
-        m_hScrollSliderImage[i] = NULL;
-        m_vScrollSliderImage[i] = NULL;
+        m_hScrollLeftImage[i] = nullptr;
+        m_hScrollRightImage[i] = nullptr;
+        m_vScrollTopImage[i] = nullptr;
+        m_vScrollBottomImage[i] = nullptr;
+        m_hScrollSliderImage[i] = nullptr;
+        m_vScrollSliderImage[i] = nullptr;
     }
-    m_hScrollImage = NULL;
-    m_vScrollImage = NULL;
-    m_nullScrollImage = NULL;
+    m_hScrollImage = nullptr;
+    m_vScrollImage = nullptr;
+    m_nullScrollImage = nullptr;
 
     m_enableScroll = false;
     m_mouseOn = false;
     m_hScroll = false;
     m_vScroll = false;
-    m_image = NULL;
+    m_image = nullptr;
     m_showImage = false;
     memset(&m_showRect, 0, sizeof(HGRectF));
     m_mouseMoveStatus = MouseStatus_Null;
@@ -51,25 +51,25 @@ HGImgView::~HGImgView()
     clearImage();
 
     delete m_hScrollImage;
-    m_hScrollImage = NULL;
+    m_hScrollImage = nullptr;
     delete m_vScrollImage;
-    m_vScrollImage = NULL;
+    m_vScrollImage = nullptr;
     delete m_nullScrollImage;
-    m_nullScrollImage = NULL;
+    m_nullScrollImage = nullptr;
     for (int i = 0; i < 3; ++i)
     {
         delete m_hScrollLeftImage[i];
-        m_hScrollLeftImage[i] = NULL;
+        m_hScrollLeftImage[i] = nullptr;
         delete m_hScrollRightImage[i];
-        m_hScrollRightImage[i] = NULL;
+        m_hScrollRightImage[i] = nullptr;
         delete m_vScrollTopImage[i];
-        m_vScrollTopImage[i] = NULL;
+        m_vScrollTopImage[i] = nullptr;
         delete m_vScrollBottomImage[i];
-        m_vScrollBottomImage[i] = NULL;
+        m_vScrollBottomImage[i] = nullptr;
         delete m_hScrollSliderImage[i];
-        m_hScrollSliderImage[i] = NULL;
+        m_hScrollSliderImage[i] = nullptr;
         delete m_vScrollSliderImage[i];
-        m_vScrollSliderImage[i] = NULL;
+        m_vScrollSliderImage[i] = nullptr;
     }
 
     qDebug("~HGImgView");
@@ -87,7 +87,7 @@ HGResult HGImgView::setScrollSize(int size)
         return HGBASE_ERR_INVALIDARG;
     }
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         return HGBASE_ERR_FAIL;
     }
@@ -108,7 +108,7 @@ HGResult HGImgView::setMinScrollSliderSize(int size)
         return HGBASE_ERR_INVALIDARG;
     }
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         return HGBASE_ERR_FAIL;
     }
@@ -124,22 +124,22 @@ HGResult HGImgView::setHScrollLeftImage(const QImage *normalImage, const QImage
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == normalImage)
+    if (nullptr == normalImage)
     {
         delete m_hScrollLeftImage[0];
-        m_hScrollLeftImage[0] = NULL;
+        m_hScrollLeftImage[0] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*normalImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollLeftImage[0])
+            if (nullptr != m_hScrollLeftImage[0])
                 delete m_hScrollLeftImage[0];
             m_hScrollLeftImage[0] = img;
         }
@@ -149,17 +149,17 @@ HGResult HGImgView::setHScrollLeftImage(const QImage *normalImage, const QImage
         }
     }
 
-    if (NULL == hotImage)
+    if (nullptr == hotImage)
     {
         delete m_hScrollLeftImage[1];
-        m_hScrollLeftImage[1] = NULL;
+        m_hScrollLeftImage[1] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*hotImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollLeftImage[1])
+            if (nullptr != m_hScrollLeftImage[1])
                 delete m_hScrollLeftImage[1];
             m_hScrollLeftImage[1] = img;
         }
@@ -169,17 +169,17 @@ HGResult HGImgView::setHScrollLeftImage(const QImage *normalImage, const QImage
         }
     }
 
-    if (NULL == pushImage)
+    if (nullptr == pushImage)
     {
         delete m_hScrollLeftImage[2];
-        m_hScrollLeftImage[2] = NULL;
+        m_hScrollLeftImage[2] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*pushImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollLeftImage[2])
+            if (nullptr != m_hScrollLeftImage[2])
                 delete m_hScrollLeftImage[2];
             m_hScrollLeftImage[2] = img;
         }
@@ -199,22 +199,22 @@ HGResult HGImgView::setHScrollRightImage(const QImage *normalImage, const QImage
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == normalImage)
+    if (nullptr == normalImage)
     {
         delete m_hScrollRightImage[0];
-        m_hScrollRightImage[0] = NULL;
+        m_hScrollRightImage[0] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*normalImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollRightImage[0])
+            if (nullptr != m_hScrollRightImage[0])
                 delete m_hScrollRightImage[0];
             m_hScrollRightImage[0] = img;
         }
@@ -224,17 +224,17 @@ HGResult HGImgView::setHScrollRightImage(const QImage *normalImage, const QImage
         }
     }
 
-    if (NULL == hotImage)
+    if (nullptr == hotImage)
     {
         delete m_hScrollRightImage[1];
-        m_hScrollRightImage[1] = NULL;
+        m_hScrollRightImage[1] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*hotImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollRightImage[1])
+            if (nullptr != m_hScrollRightImage[1])
                 delete m_hScrollRightImage[1];
             m_hScrollRightImage[1] = img;
         }
@@ -244,17 +244,17 @@ HGResult HGImgView::setHScrollRightImage(const QImage *normalImage, const QImage
         }
     }
 
-    if (NULL == pushImage)
+    if (nullptr == pushImage)
     {
         delete m_hScrollRightImage[2];
-        m_hScrollRightImage[2] = NULL;
+        m_hScrollRightImage[2] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*pushImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollRightImage[2])
+            if (nullptr != m_hScrollRightImage[2])
                 delete m_hScrollRightImage[2];
             m_hScrollRightImage[2] = img;
         }
@@ -274,22 +274,22 @@ HGResult HGImgView::setVScrollTopImage(const QImage *normalImage, const QImage *
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == normalImage)
+    if (nullptr == normalImage)
     {
         delete m_vScrollTopImage[0];
-        m_vScrollTopImage[0] = NULL;
+        m_vScrollTopImage[0] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*normalImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollTopImage[0])
+            if (nullptr != m_vScrollTopImage[0])
                 delete m_vScrollTopImage[0];
             m_vScrollTopImage[0] = img;
         }
@@ -299,17 +299,17 @@ HGResult HGImgView::setVScrollTopImage(const QImage *normalImage, const QImage *
         }
     }
 
-    if (NULL == hotImage)
+    if (nullptr == hotImage)
     {
         delete m_vScrollTopImage[1];
-        m_vScrollTopImage[1] = NULL;
+        m_vScrollTopImage[1] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*hotImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollTopImage[1])
+            if (nullptr != m_vScrollTopImage[1])
                 delete m_vScrollTopImage[1];
             m_vScrollTopImage[1] = img;
         }
@@ -319,17 +319,17 @@ HGResult HGImgView::setVScrollTopImage(const QImage *normalImage, const QImage *
         }
     }
 
-    if (NULL == pushImage)
+    if (nullptr == pushImage)
     {
         delete m_vScrollTopImage[2];
-        m_vScrollTopImage[2] = NULL;
+        m_vScrollTopImage[2] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*pushImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollTopImage[2])
+            if (nullptr != m_vScrollTopImage[2])
                 delete m_vScrollTopImage[2];
             m_vScrollTopImage[2] = img;
         }
@@ -349,22 +349,22 @@ HGResult HGImgView::setVScrollBottomImage(const QImage *normalImage, const QImag
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == normalImage)
+    if (nullptr == normalImage)
     {
         delete m_vScrollBottomImage[0];
-        m_vScrollBottomImage[0] = NULL;
+        m_vScrollBottomImage[0] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*normalImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollBottomImage[0])
+            if (nullptr != m_vScrollBottomImage[0])
                 delete m_vScrollBottomImage[0];
             m_vScrollBottomImage[0] = img;
         }
@@ -374,17 +374,17 @@ HGResult HGImgView::setVScrollBottomImage(const QImage *normalImage, const QImag
         }
     }
 
-    if (NULL == hotImage)
+    if (nullptr == hotImage)
     {
         delete m_vScrollBottomImage[1];
-        m_vScrollBottomImage[1] = NULL;
+        m_vScrollBottomImage[1] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*hotImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollBottomImage[1])
+            if (nullptr != m_vScrollBottomImage[1])
                 delete m_vScrollBottomImage[1];
             m_vScrollBottomImage[1] = img;
         }
@@ -394,17 +394,17 @@ HGResult HGImgView::setVScrollBottomImage(const QImage *normalImage, const QImag
         }
     }
 
-    if (NULL == pushImage)
+    if (nullptr == pushImage)
     {
         delete m_vScrollBottomImage[2];
-        m_vScrollBottomImage[2] = NULL;
+        m_vScrollBottomImage[2] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*pushImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollBottomImage[2])
+            if (nullptr != m_vScrollBottomImage[2])
                 delete m_vScrollBottomImage[2];
             m_vScrollBottomImage[2] = img;
         }
@@ -424,26 +424,26 @@ HGResult HGImgView::setHScrollImage(const QImage *image, const HGRect *stretch)
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == image)
+    if (nullptr == image)
     {
         delete m_hScrollImage;
-        m_hScrollImage = NULL;
+        m_hScrollImage = nullptr;
     }
     else
     {
         QImage *img = new QImage(*image);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollImage)
+            if (nullptr != m_hScrollImage)
                 delete m_hScrollImage;
             m_hScrollImage = img;
 
-            if (NULL == stretch || stretch->left < 0 || stretch->top < 0
+            if (nullptr == stretch || stretch->left < 0 || stretch->top < 0
                     || stretch->right > m_hScrollImage->width() || stretch->bottom > m_hScrollImage->height()
                     || stretch->left >= stretch->right || stretch->top >= stretch->bottom)
             {
@@ -477,26 +477,26 @@ HGResult HGImgView::setHScrollSliderImage(const QImage *normalImage, const HGRec
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == normalImage)
+    if (nullptr == normalImage)
     {
         delete m_hScrollSliderImage[0];
-        m_hScrollSliderImage[0] = NULL;
+        m_hScrollSliderImage[0] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*normalImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollSliderImage[0])
+            if (nullptr != m_hScrollSliderImage[0])
                 delete m_hScrollSliderImage[0];
             m_hScrollSliderImage[0] = img;
 
-            if (NULL == normalStretch || normalStretch->left < 0 || normalStretch->top < 0
+            if (nullptr == normalStretch || normalStretch->left < 0 || normalStretch->top < 0
                     || normalStretch->right > m_hScrollSliderImage[0]->width() || normalStretch->bottom > m_hScrollSliderImage[0]->height()
                     || normalStretch->left >= normalStretch->right || normalStretch->top >= normalStretch->bottom)
             {
@@ -519,21 +519,21 @@ HGResult HGImgView::setHScrollSliderImage(const QImage *normalImage, const HGRec
         }
     }
 
-    if (NULL == hotImage)
+    if (nullptr == hotImage)
     {
         delete m_hScrollSliderImage[1];
-        m_hScrollSliderImage[1] = NULL;
+        m_hScrollSliderImage[1] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*hotImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollSliderImage[1])
+            if (nullptr != m_hScrollSliderImage[1])
                 delete m_hScrollSliderImage[1];
             m_hScrollSliderImage[1] = img;
 
-            if (NULL == hotStretch || hotStretch->left < 0 || hotStretch->top < 0
+            if (nullptr == hotStretch || hotStretch->left < 0 || hotStretch->top < 0
                     || hotStretch->right > m_hScrollSliderImage[1]->width() || hotStretch->bottom > m_hScrollSliderImage[1]->height()
                     || hotStretch->left >= hotStretch->right || hotStretch->top >= hotStretch->bottom)
             {
@@ -556,21 +556,21 @@ HGResult HGImgView::setHScrollSliderImage(const QImage *normalImage, const HGRec
         }
     }
 
-    if (NULL == pushImage)
+    if (nullptr == pushImage)
     {
         delete m_hScrollSliderImage[2];
-        m_hScrollSliderImage[2] = NULL;
+        m_hScrollSliderImage[2] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*pushImage);
         if (!img->isNull())
         {
-            if (NULL != m_hScrollSliderImage[2])
+            if (nullptr != m_hScrollSliderImage[2])
                 delete m_hScrollSliderImage[2];
             m_hScrollSliderImage[2] = img;
 
-            if (NULL == pushStretch || pushStretch->left < 0 || pushStretch->top < 0
+            if (nullptr == pushStretch || pushStretch->left < 0 || pushStretch->top < 0
                     || pushStretch->right > m_hScrollSliderImage[2]->width() || pushStretch->bottom > m_hScrollSliderImage[2]->height()
                     || pushStretch->left >= pushStretch->right || pushStretch->top >= hotStretch->bottom)
             {
@@ -603,26 +603,26 @@ HGResult HGImgView::setVScrollImage(const QImage *image, const HGRect *stretch)
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == image)
+    if (nullptr == image)
     {
         delete m_vScrollImage;
-        m_vScrollImage = NULL;
+        m_vScrollImage = nullptr;
     }
     else
     {
         QImage *img = new QImage(*image);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollImage)
+            if (nullptr != m_vScrollImage)
                 delete m_vScrollImage;
             m_vScrollImage = img;
 
-            if (NULL == stretch || stretch->left < 0 || stretch->top < 0
+            if (nullptr == stretch || stretch->left < 0 || stretch->top < 0
                     || stretch->right > m_vScrollImage->width() || stretch->bottom > m_vScrollImage->height()
                     || stretch->left >= stretch->right || stretch->top >= stretch->bottom)
             {
@@ -656,26 +656,26 @@ HGResult HGImgView::setVScrollSliderImage(const QImage *normalImage, const HGRec
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == normalImage)
+    if (nullptr == normalImage)
     {
         delete m_vScrollSliderImage[0];
-        m_vScrollSliderImage[0] = NULL;
+        m_vScrollSliderImage[0] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*normalImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollSliderImage[0])
+            if (nullptr != m_vScrollSliderImage[0])
                 delete m_vScrollSliderImage[0];
             m_vScrollSliderImage[0] = img;
 
-            if (NULL == normalStretch || normalStretch->left < 0 || normalStretch->top < 0
+            if (nullptr == normalStretch || normalStretch->left < 0 || normalStretch->top < 0
                     || normalStretch->right > m_vScrollSliderImage[0]->width() || normalStretch->bottom > m_vScrollSliderImage[0]->height()
                     || normalStretch->left >= normalStretch->right || normalStretch->top >= normalStretch->bottom)
             {
@@ -698,21 +698,21 @@ HGResult HGImgView::setVScrollSliderImage(const QImage *normalImage, const HGRec
         }
     }
 
-    if (NULL == hotImage)
+    if (nullptr == hotImage)
     {
         delete m_vScrollSliderImage[1];
-        m_vScrollSliderImage[1] = NULL;
+        m_vScrollSliderImage[1] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*hotImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollSliderImage[1])
+            if (nullptr != m_vScrollSliderImage[1])
                 delete m_vScrollSliderImage[1];
             m_vScrollSliderImage[1] = img;
 
-            if (NULL == hotStretch || hotStretch->left < 0 || hotStretch->top < 0
+            if (nullptr == hotStretch || hotStretch->left < 0 || hotStretch->top < 0
                     || hotStretch->right > m_vScrollSliderImage[1]->width() || hotStretch->bottom > m_vScrollSliderImage[1]->height()
                     || hotStretch->left >= hotStretch->right || hotStretch->top >= hotStretch->bottom)
             {
@@ -735,21 +735,21 @@ HGResult HGImgView::setVScrollSliderImage(const QImage *normalImage, const HGRec
         }
     }
 
-    if (NULL == pushImage)
+    if (nullptr == pushImage)
     {
         delete m_vScrollSliderImage[2];
-        m_vScrollSliderImage[2] = NULL;
+        m_vScrollSliderImage[2] = nullptr;
     }
     else
     {
         QImage *img = new QImage(*pushImage);
         if (!img->isNull())
         {
-            if (NULL != m_vScrollSliderImage[2])
+            if (nullptr != m_vScrollSliderImage[2])
                 delete m_vScrollSliderImage[2];
             m_vScrollSliderImage[2] = img;
 
-            if (NULL == pushStretch || pushStretch->left < 0 || pushStretch->top < 0
+            if (nullptr == pushStretch || pushStretch->left < 0 || pushStretch->top < 0
                     || pushStretch->right > m_vScrollSliderImage[2]->width() || pushStretch->bottom > m_vScrollSliderImage[2]->height()
                     || pushStretch->left >= pushStretch->right || pushStretch->top >= hotStretch->bottom)
             {
@@ -782,22 +782,22 @@ HGResult HGImgView::setNullScrollImage(const QImage *image)
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL == image)
+    if (nullptr == image)
     {
         delete m_nullScrollImage;
-        m_nullScrollImage = NULL;
+        m_nullScrollImage = nullptr;
     }
     else
     {
         QImage *img = new QImage(*image);
         if (!img->isNull())
         {
-            if (NULL != m_nullScrollImage)
+            if (nullptr != m_nullScrollImage)
                 delete m_nullScrollImage;
             m_nullScrollImage = img;
         }
@@ -817,7 +817,7 @@ HGResult HGImgView::enableScroll(bool enable)
         return HGBASE_ERR_FAIL;
     }
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         return HGBASE_ERR_FAIL;
     }
@@ -828,7 +828,7 @@ HGResult HGImgView::enableScroll(bool enable)
 
 HGResult HGImgView::addImage(HGImage image)
 {
-    HGImage img = NULL;
+    HGImage img = nullptr;
     HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
     if (ret != HGBASE_ERR_OK)
     {
@@ -837,7 +837,7 @@ HGResult HGImgView::addImage(HGImage image)
 
     reset();
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
         HGBase_DestroyImage(m_image);
     m_image = img;
 
@@ -860,10 +860,10 @@ HGResult HGImgView::clearImage()
 {
     reset();
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         HGBase_DestroyImage(m_image);
-        m_image = NULL;
+        m_image = nullptr;
     }
 
     m_hScroll = false;
@@ -880,7 +880,7 @@ HGResult HGImgView::clearImage()
 
 HGResult HGImgView::getImage(HGImage *image)
 {
-    if (NULL == image)
+    if (nullptr == image)
     {
         return HGBASE_ERR_INVALIDARG;
     }
@@ -891,7 +891,7 @@ HGResult HGImgView::getImage(HGImage *image)
 
 HGResult HGImgView::rotateLeft()
 {
-    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || NULL == m_image)
+    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
     {
         return HGBASE_ERR_FAIL;
     }
@@ -899,7 +899,7 @@ HGResult HGImgView::rotateLeft()
     HGImageInfo info;
     HGBase_GetImageInfo(m_image, &info);
 
-    HGImage img = NULL;
+    HGImage img = nullptr;
     HGResult ret = HGBase_CreateImage(info.height, info.width, info.type, HGBASE_IMGORIGIN_TOP, &img);
     if (ret != HGBASE_ERR_OK)
     {
@@ -927,7 +927,7 @@ HGResult HGImgView::rotateLeft()
 
 HGResult HGImgView::rotateRight()
 {
-    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || NULL == m_image)
+    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
     {
         return HGBASE_ERR_FAIL;
     }
@@ -935,7 +935,7 @@ HGResult HGImgView::rotateRight()
     HGImageInfo info;
     HGBase_GetImageInfo(m_image, &info);
 
-    HGImage img = NULL;
+    HGImage img = nullptr;
     HGResult ret = HGBase_CreateImage(info.height, info.width, info.type, HGBASE_IMGORIGIN_TOP, &img);
     if (ret != HGBASE_ERR_OK)
     {
@@ -963,7 +963,7 @@ HGResult HGImgView::rotateRight()
 
 HGResult HGImgView::rotate180()
 {
-    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || NULL == m_image)
+    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
     {
         return HGBASE_ERR_FAIL;
     }
@@ -976,7 +976,7 @@ HGResult HGImgView::rotate180()
 
 HGResult HGImgView::zoomIn(const HGPoint *pCenter)
 {
-    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || NULL == m_image)
+    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
     {
         return HGBASE_ERR_FAIL;
     }
@@ -1038,7 +1038,7 @@ HGResult HGImgView::zoomIn(const HGPoint *pCenter)
 
 HGResult HGImgView::zoomOut(const HGPoint *pCenter)
 {
-    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || NULL == m_image)
+    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
     {
         return HGBASE_ERR_FAIL;
     }
@@ -1104,7 +1104,7 @@ HGResult HGImgView::zoomOut(const HGPoint *pCenter)
 
 HGResult HGImgView::realSize()
 {
-    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || NULL == m_image)
+    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
     {
         return HGBASE_ERR_FAIL;
     }
@@ -1133,7 +1133,7 @@ HGResult HGImgView::realSize()
         }
     }
 
-    ResizeShowImageRect(m_showImage, m_showRect, (float)info.width, (float)info.height, NULL);
+    ResizeShowImageRect(m_showImage, m_showRect, (float)info.width, (float)info.height, nullptr);
     recalcShowRect(this->width(), this->height(), m_scrollSize, m_hScroll, m_vScroll, m_showImage, m_showRect);
     double scale = 1.0;
 
@@ -1145,7 +1145,7 @@ HGResult HGImgView::realSize()
 
 HGResult HGImgView::fitWndSize()
 {
-    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || NULL == m_image)
+    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
     {
         return HGBASE_ERR_FAIL;
     }
@@ -1167,7 +1167,7 @@ HGResult HGImgView::fitWndSize()
 
 HGResult HGImgView::fitWndWidth()
 {
-    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || NULL == m_image)
+    if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
     {
         return HGBASE_ERR_FAIL;
     }
@@ -1214,7 +1214,7 @@ HGResult HGImgView::fitWndWidth()
         }
     }
 
-    ResizeShowImageRect(m_showImage, m_showRect, fNewWidth, fNewHeight, NULL);
+    ResizeShowImageRect(m_showImage, m_showRect, fNewWidth, fNewHeight, nullptr);
     recalcShowRect(this->width(), this->height(), m_scrollSize, m_hScroll, m_vScroll, m_showImage, m_showRect);
     double scale = (double)(m_showRect.right - m_showRect.left) / (double)info.width;
 
@@ -1257,7 +1257,7 @@ void HGImgView::mousePressEvent(QMouseEvent* e)
     }
 
     assert(0 == m_operate);
-    if (NULL == m_image || !m_showImage)
+    if (nullptr == m_image || !m_showImage)
     {
         return;
     }
@@ -1342,7 +1342,7 @@ void HGImgView::mouseMoveEvent(QMouseEvent* e)
 
     if (1 == m_operate)
     {
-        assert(NULL != m_image && m_showImage);
+        assert(nullptr != m_image && m_showImage);
 
         int lXAmount = e->pos().x() - m_beginX;
         int lYAmount = e->pos().y() - m_beginY;
@@ -1362,7 +1362,7 @@ void HGImgView::mouseMoveEvent(QMouseEvent* e)
         assert(0 == m_operate);
 
         MouseStatus mouseStatus = getMouseStatus(e->pos());
-        if (NULL != m_image && m_showImage && !m_draging
+        if (nullptr != m_image && m_showImage && !m_draging
                 && MouseStatus_Null == m_mousePressStatus && MouseStatus_Null == mouseStatus)
         {
             HGImageInfo info;
@@ -1380,7 +1380,7 @@ void HGImgView::mouseMoveEvent(QMouseEvent* e)
 
                 if (m_showColorInfo)
                 {
-                    HGByte *data = NULL;
+                    HGByte *data = nullptr;
                     HGBase_GetImageData(m_image, &data);
                     HGByte *pixel = data + yImg * info.widthStep + xImg * 3;
 
@@ -1480,9 +1480,9 @@ void HGImgView::paintEvent(QPaintEvent* e)
     Q_UNUSED(e);
 
     QPainter painter(this);
-    painter.fillRect(0, 0, this->width(), this->height(), qRgb(255, 255, 255));
+    painter.fillRect(0, 0, this->width(), this->height(), qRgb(250, 250, 250));
 
-    if (NULL == m_image || !m_showImage)
+    if (nullptr == m_image || !m_showImage)
     {
         return;
     }
@@ -1500,7 +1500,7 @@ void HGImgView::paintEvent(QPaintEvent* e)
         return;
     }
 
-    HGByte *data = NULL;
+    HGByte *data = nullptr;
     HGBase_GetImageData(m_image, &data);
     QImage img(data, info.width, info.height, info.widthStep, fmt);
     if (img.isNull())
@@ -1562,11 +1562,11 @@ void HGImgView::paintEvent(QPaintEvent* e)
 
     QRect srcRect(xSrc, ySrc, wSrc, hSrc);
     QRect destRect(xDest, yDest, wDest, hDest);
-    painter.setRenderHint(QPainter::SmoothPixmapTransform);
+    //painter.setRenderHint(QPainter::SmoothPixmapTransform);
     painter.drawImage(destRect, img, srcRect);
 #else
     QRectF destRect(m_showRect.left, m_showRect.top, m_showRect.right - m_showRect.left, m_showRect.bottom - m_showRect.top);
-    painter.setRenderHint(QPainter::SmoothPixmapTransform);
+    //painter.setRenderHint(QPainter::SmoothPixmapTransform);
     painter.drawImage(destRect, img);
 #endif
 
@@ -1638,7 +1638,7 @@ void HGImgView::resizeEvent(QResizeEvent* e)
 
     reset();
 
-    if (NULL != m_image)
+    if (nullptr != m_image)
     {
         HGImageInfo info;
         HGBase_GetImageInfo(m_image, &info);
@@ -1698,35 +1698,23 @@ void HGImgView::dropEvent(QDropEvent *e)
 {
     Q_UNUSED(e);
 
+    QString fileName;
     QList<QUrl> urls = e->mimeData()->urls();
     if (urls.size() != 0)
     {
-        QString fileName = urls.first().toLocalFile();
-
-        HGImage img = NULL;
-        HGImgFmt_LoadImage(fileName.toStdString().c_str(), 0, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
-        if (NULL != img)
-        {
-            if (NULL != m_image)
-                HGBase_DestroyImage(m_image);
-            m_image = img;
-
-            HGImageInfo info;
-            HGBase_GetImageInfo(m_image, &info);
-            HGRect rcWnd = {0, 0, this->width(), this->height()};
-
-            m_hScroll = false;
-            m_vScroll = false;
-            GetMinShowImageRect(&rcWnd, info.width, info.height, m_showImage, m_showRect);
-            double scale = (double)(m_showRect.right - m_showRect.left) / (double)info.width;
-
-            updateMoveStatusAndCursor();
-            Show();
-            emit scaleChanged(scale);
-        }
+        fileName = getStdFileName(urls.first().toLocalFile());
     }
 
     m_draging = false;
+    if (!fileName.isEmpty())
+        emit drop(fileName);
+}
+
+QString HGImgView::getStdFileName(const QString &fileName)
+{
+    char result[512] = {0};
+    HGBase_StandardiseFileName(fileName.toStdString().c_str(), result, 512);
+    return result;
 }
 
 void HGImgView::GetMinShowImageRect(const HGRect *pWnd, int nImgWidth, int nImgHeight, bool &bShowImage, HGRectF &rcShowImage)
@@ -1734,7 +1722,7 @@ void HGImgView::GetMinShowImageRect(const HGRect *pWnd, int nImgWidth, int nImgH
     bShowImage = false;
     memset(&rcShowImage, 0, sizeof(HGRectF));
 
-    assert(NULL != pWnd);
+    assert(nullptr != pWnd);
 
     int nWndWidth = pWnd->right - pWnd->left;
     int nWndHeight = pWnd->bottom - pWnd->top;
@@ -1806,7 +1794,7 @@ void HGImgView::ResizeShowImageRect(bool &bShowImage, HGRectF &rcShowImage, floa
     float fCurWidth = rcShowImage.right - rcShowImage.left;
     float fCurHeight = rcShowImage.bottom - rcShowImage.top;
 
-    if (NULL != pCenter)
+    if (nullptr != pCenter)
     {
         rcShowImage.left = (float)pCenter->x - ((float)pCenter->x - rcShowImage.left) * fNewWidth / fCurWidth;
         rcShowImage.top = (float)pCenter->y - ((float)pCenter->y - rcShowImage.top) * fNewHeight / fCurHeight;
@@ -2060,22 +2048,22 @@ void HGImgView::DrawScroll(QPainter &painter)
 
     if (m_hScroll)
     {
-        if (NULL == imgHScroll)
+        if (nullptr == imgHScroll)
             painter.fillRect(getHScrollPos(), clrHScroll);
         else
             DrawImage(painter, getHScrollPos(), imgHScroll, m_hScrollImageStretch);
 
-        if (NULL == imgHScrollLeft)
+        if (nullptr == imgHScrollLeft)
             painter.fillRect(getHScrollLeftPos(), clrHScrollLeft);
         else
             painter.drawImage(getHScrollLeftPos(), *imgHScrollLeft);
 
-        if (NULL == imgHScrollRight)
+        if (nullptr == imgHScrollRight)
             painter.fillRect(getHScrollRightPos(), clrHScrollRight);
         else
             painter.drawImage(getHScrollRightPos(), *imgHScrollRight);
 
-        if (NULL == imgHScrollSlider)
+        if (nullptr == imgHScrollSlider)
             painter.fillRect(getHScrollSliderPos(), clrHScrollSlider);
         else
             DrawImage(painter, getHScrollSliderPos(), imgHScrollSlider, hScrollSliderStretch);
@@ -2083,22 +2071,22 @@ void HGImgView::DrawScroll(QPainter &painter)
 
     if (m_vScroll)
     {
-        if (NULL == imgVScroll)
+        if (nullptr == imgVScroll)
             painter.fillRect(getVScrollPos(), clrVScroll);
         else
             DrawImage(painter, getVScrollPos(), imgVScroll, m_vScrollImageStretch);
 
-        if (NULL == imgVScrollTop)
+        if (nullptr == imgVScrollTop)
             painter.fillRect(getVScrollTopPos(), clrVScrollTop);
         else
             painter.drawImage(getVScrollTopPos(), *imgVScrollTop);
 
-        if (NULL == imgVScrollBottom)
+        if (nullptr == imgVScrollBottom)
             painter.fillRect(getVScrollBottomPos(), clrVScrollBottom);
         else
             painter.drawImage(getVScrollBottomPos(), *imgVScrollBottom);
 
-        if (NULL == imgVScrollSlider)
+        if (nullptr == imgVScrollSlider)
             painter.fillRect(getVScrollSliderPos(), clrVScrollSlider);
         else
             DrawImage(painter, getVScrollSliderPos(), imgVScrollSlider, vScrollSliderStretch);
@@ -2106,7 +2094,7 @@ void HGImgView::DrawScroll(QPainter &painter)
 
     if (m_hScroll && m_vScroll)
     {
-        if (NULL == nullScrollImage)
+        if (nullptr == nullScrollImage)
             painter.fillRect(getNullScrollPos(), clrNullScroll);
         else
             painter.drawImage(getNullScrollPos(), *nullScrollImage);
@@ -2138,7 +2126,7 @@ void HGImgView::updateMoveStatusAndCursor()
     else
     {
         QRect rcWnd(0, 0, this->width(), this->height());
-        if (NULL == m_image || !m_showImage
+        if (nullptr == m_image || !m_showImage
                 || !m_showColorInfo || MouseStatus_Null != m_mouseMoveStatus
                 || !rcWnd.contains(mapFromGlobal(QCursor::pos())))
         {

ui/HGImgView.hpp

@@ -47,6 +47,7 @@ public:
 signals:
     void mousePos(int x, int y);
     void scaleChanged(double scale);
+    void drop(const QString &fileName);
 
 private:
 
@@ -80,6 +81,7 @@ protected:
     virtual void dropEvent(QDropEvent *e);
 
 private:
+    static QString getStdFileName(const QString &fileName);
     static void GetMinShowImageRect(const HGRect *pWnd, int nImgWidth, int nImgHeight, bool &bShowImage, HGRectF &rcShowImage);
     static void ResizeShowImageRect(bool &bShowImage, HGRectF &rcShowImage, float fNewWidth, float fNewHeight, const HGPoint *pCenter);
     static void recalcShowRect(int wndWidth, int wndHeight, int scrollSize, bool hScroll, bool vScroll, bool showImage, HGRectF &imageRect);