2399 lines
73 KiB
C++
2399 lines
73 KiB
C++
#include "HGImgView.h"
|
|
#include <QMouseEvent>
|
|
#include <QPainter>
|
|
#include <QToolTip>
|
|
#include <QMimeData>
|
|
#include <QMessageBox>
|
|
#include <QFileInfo>
|
|
#include "base/HGInc.h"
|
|
#include "imgfmt/HGImgFmt.h"
|
|
#include "HGUIGlobal.h"
|
|
|
|
HGImgView::HGImgView(QWidget* parent)
|
|
: QWidget(parent)
|
|
{
|
|
m_scrollSize = 10;
|
|
m_minScrollSliderSize = 8;
|
|
for (int i = 0; i < 3; ++i)
|
|
{
|
|
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 = nullptr;
|
|
m_vScrollImage = nullptr;
|
|
m_nullScrollImage = nullptr;
|
|
|
|
m_enableScroll = false;
|
|
m_mouseOn = false;
|
|
m_hScroll = false;
|
|
m_vScroll = false;
|
|
m_image = nullptr;
|
|
m_showImage = false;
|
|
memset(&m_showRect, 0, sizeof(HGRectF));
|
|
m_mouseMoveStatus = MouseStatus_Null;
|
|
m_mousePressStatus = MouseStatus_Null;
|
|
m_mousePressBeginX = -1;
|
|
m_mousePressBeginY = -1;
|
|
m_showColorInfo = false;
|
|
m_operate = 0;
|
|
m_beginX = -1;
|
|
m_beginY = -1;
|
|
m_draging = false;
|
|
|
|
setFocusPolicy(Qt::ClickFocus);
|
|
setMouseTracking(true);
|
|
setAcceptDrops(true);
|
|
}
|
|
|
|
HGImgView::~HGImgView()
|
|
{
|
|
clearImage();
|
|
|
|
delete m_hScrollImage;
|
|
m_hScrollImage = nullptr;
|
|
delete m_vScrollImage;
|
|
m_vScrollImage = nullptr;
|
|
delete m_nullScrollImage;
|
|
m_nullScrollImage = nullptr;
|
|
for (int i = 0; i < 3; ++i)
|
|
{
|
|
delete m_hScrollLeftImage[i];
|
|
m_hScrollLeftImage[i] = nullptr;
|
|
delete m_hScrollRightImage[i];
|
|
m_hScrollRightImage[i] = nullptr;
|
|
delete m_vScrollTopImage[i];
|
|
m_vScrollTopImage[i] = nullptr;
|
|
delete m_vScrollBottomImage[i];
|
|
m_vScrollBottomImage[i] = nullptr;
|
|
delete m_hScrollSliderImage[i];
|
|
m_hScrollSliderImage[i] = nullptr;
|
|
delete m_vScrollSliderImage[i];
|
|
m_vScrollSliderImage[i] = nullptr;
|
|
}
|
|
|
|
qDebug("~HGImgView");
|
|
}
|
|
|
|
HGResult HGImgView::setScrollSize(int size)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (size < 10 || size > 20)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
m_scrollSize = size;
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::setMinScrollSliderSize(int size)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (size < 8 || size > 64)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
m_minScrollSliderSize = size;
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::setHScrollLeftImage(const QImage *normalImage, const QImage *hotImage, const QImage *pushImage)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr == normalImage)
|
|
{
|
|
delete m_hScrollLeftImage[0];
|
|
m_hScrollLeftImage[0] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*normalImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_hScrollLeftImage[0])
|
|
delete m_hScrollLeftImage[0];
|
|
m_hScrollLeftImage[0] = img;
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
if (nullptr == hotImage)
|
|
{
|
|
delete m_hScrollLeftImage[1];
|
|
m_hScrollLeftImage[1] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*hotImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_hScrollLeftImage[1])
|
|
delete m_hScrollLeftImage[1];
|
|
m_hScrollLeftImage[1] = img;
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
if (nullptr == pushImage)
|
|
{
|
|
delete m_hScrollLeftImage[2];
|
|
m_hScrollLeftImage[2] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*pushImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_hScrollLeftImage[2])
|
|
delete m_hScrollLeftImage[2];
|
|
m_hScrollLeftImage[2] = img;
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::setHScrollRightImage(const QImage *normalImage, const QImage *hotImage, const QImage *pushImage)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr == normalImage)
|
|
{
|
|
delete m_hScrollRightImage[0];
|
|
m_hScrollRightImage[0] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*normalImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_hScrollRightImage[0])
|
|
delete m_hScrollRightImage[0];
|
|
m_hScrollRightImage[0] = img;
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
if (nullptr == hotImage)
|
|
{
|
|
delete m_hScrollRightImage[1];
|
|
m_hScrollRightImage[1] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*hotImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_hScrollRightImage[1])
|
|
delete m_hScrollRightImage[1];
|
|
m_hScrollRightImage[1] = img;
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
if (nullptr == pushImage)
|
|
{
|
|
delete m_hScrollRightImage[2];
|
|
m_hScrollRightImage[2] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*pushImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_hScrollRightImage[2])
|
|
delete m_hScrollRightImage[2];
|
|
m_hScrollRightImage[2] = img;
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::setVScrollTopImage(const QImage *normalImage, const QImage *hotImage, const QImage *pushImage)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr == normalImage)
|
|
{
|
|
delete m_vScrollTopImage[0];
|
|
m_vScrollTopImage[0] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*normalImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_vScrollTopImage[0])
|
|
delete m_vScrollTopImage[0];
|
|
m_vScrollTopImage[0] = img;
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
if (nullptr == hotImage)
|
|
{
|
|
delete m_vScrollTopImage[1];
|
|
m_vScrollTopImage[1] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*hotImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_vScrollTopImage[1])
|
|
delete m_vScrollTopImage[1];
|
|
m_vScrollTopImage[1] = img;
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
if (nullptr == pushImage)
|
|
{
|
|
delete m_vScrollTopImage[2];
|
|
m_vScrollTopImage[2] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*pushImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_vScrollTopImage[2])
|
|
delete m_vScrollTopImage[2];
|
|
m_vScrollTopImage[2] = img;
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::setVScrollBottomImage(const QImage *normalImage, const QImage *hotImage, const QImage *pushImage)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr == normalImage)
|
|
{
|
|
delete m_vScrollBottomImage[0];
|
|
m_vScrollBottomImage[0] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*normalImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_vScrollBottomImage[0])
|
|
delete m_vScrollBottomImage[0];
|
|
m_vScrollBottomImage[0] = img;
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
if (nullptr == hotImage)
|
|
{
|
|
delete m_vScrollBottomImage[1];
|
|
m_vScrollBottomImage[1] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*hotImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_vScrollBottomImage[1])
|
|
delete m_vScrollBottomImage[1];
|
|
m_vScrollBottomImage[1] = img;
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
if (nullptr == pushImage)
|
|
{
|
|
delete m_vScrollBottomImage[2];
|
|
m_vScrollBottomImage[2] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*pushImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_vScrollBottomImage[2])
|
|
delete m_vScrollBottomImage[2];
|
|
m_vScrollBottomImage[2] = img;
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::setHScrollImage(const QImage *image, const HGRect *stretch)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr == image)
|
|
{
|
|
delete m_hScrollImage;
|
|
m_hScrollImage = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*image);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_hScrollImage)
|
|
delete m_hScrollImage;
|
|
m_hScrollImage = img;
|
|
|
|
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)
|
|
{
|
|
m_hScrollImageStretch.setX(0);
|
|
m_hScrollImageStretch.setY(0);
|
|
m_hScrollImageStretch.setWidth(m_hScrollImage->width());
|
|
m_hScrollImageStretch.setHeight(m_hScrollImage->height());
|
|
}
|
|
else
|
|
{
|
|
m_hScrollImageStretch.setX(stretch->left);
|
|
m_hScrollImageStretch.setY(stretch->top);
|
|
m_hScrollImageStretch.setWidth(stretch->right - stretch->left);
|
|
m_hScrollImageStretch.setHeight(stretch->bottom - stretch->top);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::setHScrollSliderImage(const QImage *normalImage, const HGRect *normalStretch, const QImage *hotImage, const HGRect *hotStretch,
|
|
const QImage *pushImage, const HGRect *pushStretch)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr == normalImage)
|
|
{
|
|
delete m_hScrollSliderImage[0];
|
|
m_hScrollSliderImage[0] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*normalImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_hScrollSliderImage[0])
|
|
delete m_hScrollSliderImage[0];
|
|
m_hScrollSliderImage[0] = img;
|
|
|
|
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)
|
|
{
|
|
m_hScrollSliderImageStretch[0].setX(0);
|
|
m_hScrollSliderImageStretch[0].setY(0);
|
|
m_hScrollSliderImageStretch[0].setWidth(m_hScrollSliderImage[0]->width());
|
|
m_hScrollSliderImageStretch[0].setHeight(m_hScrollSliderImage[0]->height());
|
|
}
|
|
else
|
|
{
|
|
m_hScrollSliderImageStretch[0].setX(normalStretch->left);
|
|
m_hScrollSliderImageStretch[0].setY(normalStretch->top);
|
|
m_hScrollSliderImageStretch[0].setWidth(normalStretch->right - normalStretch->left);
|
|
m_hScrollSliderImageStretch[0].setHeight(normalStretch->bottom - normalStretch->top);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
if (nullptr == hotImage)
|
|
{
|
|
delete m_hScrollSliderImage[1];
|
|
m_hScrollSliderImage[1] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*hotImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_hScrollSliderImage[1])
|
|
delete m_hScrollSliderImage[1];
|
|
m_hScrollSliderImage[1] = img;
|
|
|
|
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)
|
|
{
|
|
m_hScrollSliderImageStretch[1].setX(0);
|
|
m_hScrollSliderImageStretch[1].setY(0);
|
|
m_hScrollSliderImageStretch[1].setWidth(m_hScrollSliderImage[1]->width());
|
|
m_hScrollSliderImageStretch[1].setHeight(m_hScrollSliderImage[1]->height());
|
|
}
|
|
else
|
|
{
|
|
m_hScrollSliderImageStretch[1].setX(hotStretch->left);
|
|
m_hScrollSliderImageStretch[1].setY(hotStretch->top);
|
|
m_hScrollSliderImageStretch[1].setWidth(hotStretch->right - hotStretch->left);
|
|
m_hScrollSliderImageStretch[1].setHeight(hotStretch->bottom - hotStretch->top);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
if (nullptr == pushImage)
|
|
{
|
|
delete m_hScrollSliderImage[2];
|
|
m_hScrollSliderImage[2] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*pushImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_hScrollSliderImage[2])
|
|
delete m_hScrollSliderImage[2];
|
|
m_hScrollSliderImage[2] = img;
|
|
|
|
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)
|
|
{
|
|
m_hScrollSliderImageStretch[2].setX(0);
|
|
m_hScrollSliderImageStretch[2].setY(0);
|
|
m_hScrollSliderImageStretch[2].setWidth(m_hScrollSliderImage[2]->width());
|
|
m_hScrollSliderImageStretch[2].setHeight(m_hScrollSliderImage[2]->height());
|
|
}
|
|
else
|
|
{
|
|
m_hScrollSliderImageStretch[2].setX(pushStretch->left);
|
|
m_hScrollSliderImageStretch[2].setY(pushStretch->top);
|
|
m_hScrollSliderImageStretch[2].setWidth(pushStretch->right - pushStretch->left);
|
|
m_hScrollSliderImageStretch[2].setHeight(pushStretch->bottom - pushStretch->top);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::setVScrollImage(const QImage *image, const HGRect *stretch)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr == image)
|
|
{
|
|
delete m_vScrollImage;
|
|
m_vScrollImage = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*image);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_vScrollImage)
|
|
delete m_vScrollImage;
|
|
m_vScrollImage = img;
|
|
|
|
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)
|
|
{
|
|
m_vScrollImageStretch.setX(0);
|
|
m_vScrollImageStretch.setY(0);
|
|
m_vScrollImageStretch.setWidth(m_vScrollImage->width());
|
|
m_vScrollImageStretch.setHeight(m_vScrollImage->height());
|
|
}
|
|
else
|
|
{
|
|
m_vScrollImageStretch.setX(stretch->left);
|
|
m_vScrollImageStretch.setY(stretch->top);
|
|
m_vScrollImageStretch.setWidth(stretch->right - stretch->left);
|
|
m_vScrollImageStretch.setHeight(stretch->bottom - stretch->top);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::setVScrollSliderImage(const QImage *normalImage, const HGRect *normalStretch, const QImage *hotImage, const HGRect *hotStretch,
|
|
const QImage *pushImage, const HGRect *pushStretch)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr == normalImage)
|
|
{
|
|
delete m_vScrollSliderImage[0];
|
|
m_vScrollSliderImage[0] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*normalImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_vScrollSliderImage[0])
|
|
delete m_vScrollSliderImage[0];
|
|
m_vScrollSliderImage[0] = img;
|
|
|
|
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)
|
|
{
|
|
m_vScrollSliderImageStretch[0].setX(0);
|
|
m_vScrollSliderImageStretch[0].setY(0);
|
|
m_vScrollSliderImageStretch[0].setWidth(m_vScrollSliderImage[0]->width());
|
|
m_vScrollSliderImageStretch[0].setHeight(m_vScrollSliderImage[0]->height());
|
|
}
|
|
else
|
|
{
|
|
m_vScrollSliderImageStretch[0].setX(normalStretch->left);
|
|
m_vScrollSliderImageStretch[0].setY(normalStretch->top);
|
|
m_vScrollSliderImageStretch[0].setWidth(normalStretch->right - normalStretch->left);
|
|
m_vScrollSliderImageStretch[0].setHeight(normalStretch->bottom - normalStretch->top);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
if (nullptr == hotImage)
|
|
{
|
|
delete m_vScrollSliderImage[1];
|
|
m_vScrollSliderImage[1] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*hotImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_vScrollSliderImage[1])
|
|
delete m_vScrollSliderImage[1];
|
|
m_vScrollSliderImage[1] = img;
|
|
|
|
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)
|
|
{
|
|
m_vScrollSliderImageStretch[1].setX(0);
|
|
m_vScrollSliderImageStretch[1].setY(0);
|
|
m_vScrollSliderImageStretch[1].setWidth(m_vScrollSliderImage[1]->width());
|
|
m_vScrollSliderImageStretch[1].setHeight(m_vScrollSliderImage[1]->height());
|
|
}
|
|
else
|
|
{
|
|
m_vScrollSliderImageStretch[1].setX(hotStretch->left);
|
|
m_vScrollSliderImageStretch[1].setY(hotStretch->top);
|
|
m_vScrollSliderImageStretch[1].setWidth(hotStretch->right - hotStretch->left);
|
|
m_vScrollSliderImageStretch[1].setHeight(hotStretch->bottom - hotStretch->top);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
if (nullptr == pushImage)
|
|
{
|
|
delete m_vScrollSliderImage[2];
|
|
m_vScrollSliderImage[2] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*pushImage);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_vScrollSliderImage[2])
|
|
delete m_vScrollSliderImage[2];
|
|
m_vScrollSliderImage[2] = img;
|
|
|
|
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)
|
|
{
|
|
m_vScrollSliderImageStretch[2].setX(0);
|
|
m_vScrollSliderImageStretch[2].setY(0);
|
|
m_vScrollSliderImageStretch[2].setWidth(m_vScrollSliderImage[2]->width());
|
|
m_vScrollSliderImageStretch[2].setHeight(m_vScrollSliderImage[2]->height());
|
|
}
|
|
else
|
|
{
|
|
m_vScrollSliderImageStretch[2].setX(pushStretch->left);
|
|
m_vScrollSliderImageStretch[2].setY(pushStretch->top);
|
|
m_vScrollSliderImageStretch[2].setWidth(pushStretch->right - pushStretch->left);
|
|
m_vScrollSliderImageStretch[2].setHeight(pushStretch->bottom - pushStretch->top);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::setNullScrollImage(const QImage *image)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr == image)
|
|
{
|
|
delete m_nullScrollImage;
|
|
m_nullScrollImage = nullptr;
|
|
}
|
|
else
|
|
{
|
|
QImage *img = new QImage(*image);
|
|
if (!img->isNull())
|
|
{
|
|
if (nullptr != m_nullScrollImage)
|
|
delete m_nullScrollImage;
|
|
m_nullScrollImage = img;
|
|
}
|
|
else
|
|
{
|
|
delete img;
|
|
}
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::enableScroll(bool enable)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
m_enableScroll = enable;
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::addImage(HGImage image)
|
|
{
|
|
HGImage img = nullptr;
|
|
HGResult ret = HGBase_CloneImage(image, 0, HGBASE_IMGORIGIN_TOP, &img);
|
|
if (ret != HGBASE_ERR_OK)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
reset();
|
|
|
|
if (nullptr != 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);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::clearImage()
|
|
{
|
|
reset();
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
HGBase_DestroyImage(m_image);
|
|
m_image = nullptr;
|
|
}
|
|
|
|
m_hScroll = false;
|
|
m_vScroll = false;
|
|
m_showImage = false;
|
|
memset(&m_showRect, 0, sizeof(HGRectF));
|
|
double scale = 0.0;
|
|
|
|
updateMoveStatusAndCursor();
|
|
Show();
|
|
emit scaleChanged(scale);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::getImage(HGImage *image)
|
|
{
|
|
if (nullptr == image)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
*image = m_image;
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::rotateLeft()
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGImageInfo info;
|
|
HGBase_GetImageInfo(m_image, &info);
|
|
|
|
HGImage img = nullptr;
|
|
HGResult ret = HGBase_CreateImage(info.height, info.width, info.type, HGBASE_IMGORIGIN_TOP, &img);
|
|
if (ret != HGBASE_ERR_OK)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
HGBase_ImageRotateLeft(m_image, img);
|
|
|
|
HGBase_DestroyImage(m_image);
|
|
m_image = img;
|
|
|
|
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);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::rotateRight()
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGImageInfo info;
|
|
HGBase_GetImageInfo(m_image, &info);
|
|
|
|
HGImage img = nullptr;
|
|
HGResult ret = HGBase_CreateImage(info.height, info.width, info.type, HGBASE_IMGORIGIN_TOP, &img);
|
|
if (ret != HGBASE_ERR_OK)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
HGBase_ImageRotateRight(m_image, img);
|
|
|
|
HGBase_DestroyImage(m_image);
|
|
m_image = img;
|
|
|
|
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);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::rotate180()
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGBase_ImageRotate180(m_image, m_image);
|
|
|
|
Show();
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::zoomIn(const HGPoint *pCenter)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGImageInfo info;
|
|
HGBase_GetImageInfo(m_image, &info);
|
|
|
|
// 获取最大值
|
|
float fMaxWidth = info.width * 20.0f;
|
|
float fMaxHeight = info.height * 20.0f;
|
|
// 获取当前值
|
|
float fCurWidth = m_showRect.right - m_showRect.left;
|
|
float fCurHeight = m_showRect.bottom - m_showRect.top;
|
|
// 新值
|
|
float fNewWidth = fCurWidth * 1.2f;
|
|
float fNewHeight = fCurHeight * 1.2f;
|
|
|
|
if (fabs(fMaxWidth - fCurWidth) > 1e-3 || fabs(fMaxHeight - fCurHeight) > 1e-3)
|
|
{
|
|
if (fNewWidth - fMaxWidth > -1e-3 || fNewHeight - fMaxHeight > -1e-3
|
|
|| round(100.0f * fNewWidth / (float)info.width) == round(100.0f * fMaxWidth / (float)info.width))
|
|
{
|
|
fNewWidth = fMaxWidth;
|
|
fNewHeight = fMaxHeight;
|
|
}
|
|
|
|
m_hScroll = false;
|
|
m_vScroll = false;
|
|
if (m_enableScroll)
|
|
{
|
|
if (fNewWidth > this->width())
|
|
{
|
|
m_hScroll = true;
|
|
if (fNewHeight > this->height() - m_scrollSize)
|
|
m_vScroll = true;
|
|
}
|
|
else
|
|
{
|
|
if (fNewHeight > this->height())
|
|
{
|
|
m_vScroll = true;
|
|
if (fNewWidth > this->width() - m_scrollSize)
|
|
m_hScroll = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
ResizeShowImageRect(m_showImage, m_showRect, fNewWidth, fNewHeight, pCenter);
|
|
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;
|
|
|
|
updateMoveStatusAndCursor();
|
|
Show();
|
|
emit scaleChanged(scale);
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::zoomOut(const HGPoint *pCenter)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGImageInfo info;
|
|
HGBase_GetImageInfo(m_image, &info);
|
|
HGRect rcWnd = {0, 0, this->width(), this->height()};
|
|
|
|
// 获取最小值
|
|
bool bMinShow;
|
|
HGRectF rcMinShow;
|
|
GetMinShowImageRect(&rcWnd, info.width, info.height, bMinShow, rcMinShow);
|
|
float fMinWidth = rcMinShow.right - rcMinShow.left;
|
|
float fMinHeight = rcMinShow.bottom - rcMinShow.top;
|
|
// 获取当前值
|
|
float fCurWidth = m_showRect.right - m_showRect.left;
|
|
float fCurHeight = m_showRect.bottom - m_showRect.top;
|
|
// 新值
|
|
float fNewWidth = fCurWidth * 1.0f / 1.2f;
|
|
float fNewHeight = fCurHeight * 1.0f / 1.2f;
|
|
|
|
if (fabs(fMinWidth - fCurWidth) > 1e-3 || fabs(fMinHeight - fCurHeight) > 1e-3)
|
|
{
|
|
if (fNewWidth - fMinWidth < 1e-3 || fNewHeight - fMinHeight < 1e-3
|
|
|| round(100.0f * fNewWidth / (float)info.width) == round(100.0f * fMinWidth / (float)info.width))
|
|
{
|
|
fNewWidth = fMinWidth;
|
|
fNewHeight = fMinHeight;
|
|
}
|
|
|
|
m_hScroll = false;
|
|
m_vScroll = false;
|
|
if (m_enableScroll)
|
|
{
|
|
if (fNewWidth > this->width())
|
|
{
|
|
m_hScroll = true;
|
|
if (fNewHeight > this->height() - m_scrollSize)
|
|
m_vScroll = true;
|
|
}
|
|
else
|
|
{
|
|
if (fNewHeight > this->height())
|
|
{
|
|
m_vScroll = true;
|
|
if (fNewWidth > this->width() - m_scrollSize)
|
|
m_hScroll = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
ResizeShowImageRect(m_showImage, m_showRect, fNewWidth, fNewHeight, pCenter);
|
|
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;
|
|
|
|
updateMoveStatusAndCursor();
|
|
Show();
|
|
emit scaleChanged(scale);
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::realSize()
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGImageInfo info;
|
|
HGBase_GetImageInfo(m_image, &info);
|
|
|
|
m_hScroll = false;
|
|
m_vScroll = false;
|
|
if (m_enableScroll)
|
|
{
|
|
if ((int)info.width > this->width())
|
|
{
|
|
m_hScroll = true;
|
|
if ((int)info.height > this->height() - m_scrollSize)
|
|
m_vScroll = true;
|
|
}
|
|
else
|
|
{
|
|
if ((int)info.height > this->height())
|
|
{
|
|
m_vScroll = true;
|
|
if ((int)info.width > this->width() - m_scrollSize)
|
|
m_hScroll = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
updateMoveStatusAndCursor();
|
|
Show();
|
|
emit scaleChanged(scale);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::fitWndSize()
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
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);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::fitWndWidth()
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging || nullptr == m_image)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGImageInfo info;
|
|
HGBase_GetImageInfo(m_image, &info);
|
|
HGRect rcWnd = {0, 0, this->width(), this->height()};
|
|
|
|
// 获取最小值
|
|
bool bMinShow;
|
|
HGRectF rcMinShow;
|
|
GetMinShowImageRect(&rcWnd, info.width, info.height, bMinShow, rcMinShow);
|
|
float fMinWidth = rcMinShow.right - rcMinShow.left;
|
|
float fMinHeight = rcMinShow.bottom - rcMinShow.top;
|
|
// 获取最大值
|
|
float fMaxWidth = info.width * 20.0f;
|
|
float fMaxHeight = info.height * 20.0f;
|
|
// 新值
|
|
float fNewWidth = (float)this->width();
|
|
float fNewHeight = fNewWidth * (float)info.height / (float)info.width;
|
|
fNewWidth = HGMIN(fMaxWidth, HGMAX(fMinWidth, fNewWidth));
|
|
fNewHeight = HGMIN(fMaxHeight, HGMAX(fMinHeight, fNewHeight));
|
|
|
|
m_hScroll = false;
|
|
m_vScroll = false;
|
|
if (m_enableScroll)
|
|
{
|
|
if (fNewHeight > this->height())
|
|
{
|
|
m_vScroll = true;
|
|
fNewWidth = this->width() - m_scrollSize;
|
|
fNewHeight = fNewWidth * (float)info.height / (float)info.width;
|
|
fNewWidth = HGMIN(fMaxWidth, HGMAX(fMinWidth, fNewWidth));
|
|
fNewHeight = HGMIN(fMaxHeight, HGMAX(fMinHeight, fNewHeight));
|
|
|
|
if (fNewHeight <= this->height())
|
|
{
|
|
m_vScroll = false;
|
|
fNewWidth = (float)this->width();
|
|
fNewHeight = fNewWidth * (float)info.height / (float)info.width;
|
|
fNewWidth = HGMIN(fMaxWidth, HGMAX(fMinWidth, fNewWidth));
|
|
fNewHeight = HGMIN(fMaxHeight, HGMAX(fMinHeight, fNewHeight));
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
updateMoveStatusAndCursor();
|
|
Show();
|
|
emit scaleChanged(scale);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGImgView::showColorInfo(bool show)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
m_showColorInfo = show;
|
|
QToolTip::hideText();
|
|
updateMoveStatusAndCursor();
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
void HGImgView::mousePressEvent(QMouseEvent* e)
|
|
{
|
|
if (e->button() != Qt::LeftButton)
|
|
{
|
|
return;
|
|
}
|
|
|
|
MouseStatus mouseStatus = getMouseStatus(e->pos());
|
|
if (MouseStatus_Null != mouseStatus)
|
|
{
|
|
// 如果鼠标点到滚动条区域
|
|
m_mousePressStatus = mouseStatus;
|
|
m_mousePressBeginX = e->pos().x();
|
|
m_mousePressBeginY = e->pos().y();
|
|
updateMoveStatusAndCursor();
|
|
Show();
|
|
return;
|
|
}
|
|
|
|
assert(0 == m_operate);
|
|
if (nullptr == m_image || !m_showImage)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_operate = 1;
|
|
m_beginX = e->pos().x();
|
|
m_beginY = e->pos().y();
|
|
updateMoveStatusAndCursor();
|
|
}
|
|
|
|
void HGImgView::mouseMoveEvent(QMouseEvent* e)
|
|
{
|
|
// 处理滚动条
|
|
if (MouseStatus_HScrollSlider == m_mousePressStatus)
|
|
{
|
|
int lXAmount = e->pos().x() - m_mousePressBeginX;
|
|
double offset;
|
|
if (!m_vScroll)
|
|
{
|
|
int rollTotalLen = this->width() - 2 * m_scrollSize;
|
|
int rollLeft = round((double)rollTotalLen * (-m_showRect.left) / (double)(m_showRect.right - m_showRect.left));
|
|
int rollRight = round((double)rollTotalLen * (-m_showRect.left + this->width()) / (double)(m_showRect.right - m_showRect.left));
|
|
int rollLen = rollRight - rollLeft;
|
|
if (rollLen >= m_minScrollSliderSize)
|
|
offset = lXAmount * (m_showRect.right - m_showRect.left) / rollTotalLen;
|
|
else
|
|
offset = lXAmount * (m_showRect.right - m_showRect.left - this->width()) / (rollTotalLen - m_minScrollSliderSize);
|
|
}
|
|
else
|
|
{
|
|
int rollTotalLen = this->width() - 3 * m_scrollSize;
|
|
int rollLeft = round((double)rollTotalLen * (-m_showRect.left) / (double)(m_showRect.right - m_showRect.left));
|
|
int rollRight = round((double)rollTotalLen * (-m_showRect.left + this->width() - m_scrollSize) / (double)(m_showRect.right - m_showRect.left));
|
|
int rollLen = rollRight - rollLeft;
|
|
if (rollLen >= m_minScrollSliderSize)
|
|
offset = lXAmount * (m_showRect.right - m_showRect.left) / rollTotalLen;
|
|
else
|
|
offset = lXAmount * (m_showRect.right - m_showRect.left - this->width() + m_scrollSize) / (rollTotalLen - m_minScrollSliderSize);
|
|
}
|
|
m_showRect.left -= offset;
|
|
m_showRect.right -= offset;
|
|
recalcShowRect(this->width(), this->height(), m_scrollSize, m_hScroll, m_vScroll, m_showImage, m_showRect);
|
|
|
|
Show();
|
|
m_mousePressBeginX = e->pos().x();
|
|
m_mousePressBeginY = e->pos().y();
|
|
}
|
|
else if (MouseStatus_VScrollSlider == m_mousePressStatus)
|
|
{
|
|
int lYAmount = e->pos().y() - m_mousePressBeginY;
|
|
double offset;
|
|
if (!m_hScroll)
|
|
{
|
|
int rollTotalLen = this->height() - 2 * m_scrollSize;
|
|
int rollTop = round((double)rollTotalLen * (-m_showRect.top) / (double)(m_showRect.bottom - m_showRect.top));
|
|
int rollBottom = round((double)rollTotalLen * (-m_showRect.top + this->height()) / (double)(m_showRect.bottom - m_showRect.top));
|
|
int rollLen = rollBottom - rollTop;
|
|
if (rollLen >= m_minScrollSliderSize)
|
|
offset = lYAmount * (m_showRect.bottom - m_showRect.top) / rollTotalLen;
|
|
else
|
|
offset = lYAmount * (m_showRect.bottom - m_showRect.top - this->height()) / (rollTotalLen - m_minScrollSliderSize);
|
|
}
|
|
else
|
|
{
|
|
int rollTotalLen = this->height() - 3 * m_scrollSize;
|
|
int rollTop = round((double)rollTotalLen * (-m_showRect.top) / (double)(m_showRect.bottom - m_showRect.top));
|
|
int rollBottom = round((double)rollTotalLen * (-m_showRect.top + this->height() - m_scrollSize) / (double)(m_showRect.bottom - m_showRect.top));
|
|
int rollLen = rollBottom - rollTop;
|
|
if (rollLen >= m_minScrollSliderSize)
|
|
offset = lYAmount * (m_showRect.bottom - m_showRect.top) / rollTotalLen;
|
|
else
|
|
offset = lYAmount * (m_showRect.bottom - m_showRect.top - this->height() + m_scrollSize) / (rollTotalLen - m_minScrollSliderSize);
|
|
}
|
|
m_showRect.top -= offset;
|
|
m_showRect.bottom -= offset;
|
|
recalcShowRect(this->width(), this->height(), m_scrollSize, m_hScroll, m_vScroll, m_showImage, m_showRect);
|
|
|
|
Show();
|
|
m_mousePressBeginX = e->pos().x();
|
|
m_mousePressBeginY = e->pos().y();
|
|
}
|
|
|
|
if (1 == m_operate)
|
|
{
|
|
assert(nullptr != m_image && m_showImage);
|
|
|
|
int lXAmount = e->pos().x() - m_beginX;
|
|
int lYAmount = e->pos().y() - m_beginY;
|
|
|
|
m_showRect.left += lXAmount;
|
|
m_showRect.right += lXAmount;
|
|
m_showRect.top += lYAmount;
|
|
m_showRect.bottom += lYAmount;
|
|
recalcShowRect(this->width(), this->height(), m_scrollSize, m_hScroll, m_vScroll, m_showImage, m_showRect);
|
|
|
|
Show();
|
|
m_beginX = e->pos().x();
|
|
m_beginY = e->pos().y();
|
|
}
|
|
else
|
|
{
|
|
assert(0 == m_operate);
|
|
|
|
MouseStatus mouseStatus = getMouseStatus(e->pos());
|
|
if (nullptr != m_image && m_showImage && !m_draging
|
|
&& MouseStatus_Null == m_mousePressStatus && MouseStatus_Null == mouseStatus)
|
|
{
|
|
HGImageInfo info;
|
|
HGBase_GetImageInfo(m_image, &info);
|
|
|
|
int xShow = e->pos().x() - m_showRect.left;
|
|
int yShow = e->pos().y() - m_showRect.top;
|
|
int xImg = xShow * (int)info.width / (m_showRect.right - m_showRect.left);
|
|
int yImg = yShow * (int)info.height / (m_showRect.bottom - m_showRect.top);
|
|
|
|
if (xImg >= 0 && xImg < (int)info.width && yImg >= 0 && yImg < (int)info.height)
|
|
{
|
|
//qDebug("mousePos, x=%d, y=%d", xImg, yImg);
|
|
emit mousePos(xImg, yImg);
|
|
|
|
if (m_showColorInfo)
|
|
{
|
|
HGByte *data = nullptr;
|
|
HGBase_GetImageData(m_image, &data);
|
|
HGByte *pixel = data + yImg * info.widthStep + xImg * 3;
|
|
|
|
HGByte r = pixel[0];
|
|
HGByte g = pixel[1];
|
|
HGByte b = pixel[2];
|
|
//qDebug("colorInfo, r=%d, g=%d, b=%d", r, g, b);
|
|
|
|
char colorInfo[1024];
|
|
sprintf(colorInfo, "X: %d, Y: %d\nRGB(%d, %d, %d)\nHTML(#%02X%02X%02X)",
|
|
xImg, yImg, r, g, b, r, g, b);
|
|
QToolTip::showText(e->globalPos(), colorInfo, this);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
emit mousePos(0, 0);
|
|
QToolTip::hideText();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
emit mousePos(0, 0);
|
|
QToolTip::hideText();
|
|
}
|
|
|
|
updateMoveStatusAndCursor();
|
|
Show();
|
|
}
|
|
}
|
|
|
|
void HGImgView::mouseReleaseEvent(QMouseEvent* e)
|
|
{
|
|
Q_UNUSED(e);
|
|
|
|
m_draging = false;
|
|
|
|
m_beginX = -1;
|
|
m_beginY = -1;
|
|
m_operate = 0;
|
|
|
|
MouseStatus oldMousePressStatus = m_mousePressStatus;
|
|
m_mousePressStatus = MouseStatus_Null;
|
|
m_mousePressBeginX = -1;
|
|
m_mousePressBeginY = -1;
|
|
|
|
// 处理按滚动条区域
|
|
MouseStatus mouseMoveStatus = getMouseStatus(e->pos());
|
|
if (MouseStatus_HScrollLeft == oldMousePressStatus && MouseStatus_HScrollLeft == mouseMoveStatus)
|
|
{
|
|
double width = m_showRect.right - m_showRect.left;
|
|
m_showRect.left += width / 10.0;
|
|
m_showRect.right += width / 10.0;
|
|
recalcShowRect(this->width(), this->height(), m_scrollSize, m_hScroll, m_vScroll, m_showImage, m_showRect);
|
|
}
|
|
else if (MouseStatus_HScrollRight == oldMousePressStatus && MouseStatus_HScrollRight == mouseMoveStatus)
|
|
{
|
|
double width = m_showRect.right - m_showRect.left;
|
|
m_showRect.left -= width / 10.0;
|
|
m_showRect.right -= width / 10.0;
|
|
recalcShowRect(this->width(), this->height(), m_scrollSize, m_hScroll, m_vScroll, m_showImage, m_showRect);
|
|
}
|
|
else if (MouseStatus_VScrollTop == oldMousePressStatus && MouseStatus_VScrollTop == mouseMoveStatus)
|
|
{
|
|
double height = m_showRect.bottom - m_showRect.top;
|
|
m_showRect.top += height / 10.0;
|
|
m_showRect.bottom += height / 10.0;
|
|
recalcShowRect(this->width(), this->height(), m_scrollSize, m_hScroll, m_vScroll, m_showImage, m_showRect);
|
|
}
|
|
else if (MouseStatus_VScrollBottom == oldMousePressStatus && MouseStatus_VScrollBottom == mouseMoveStatus)
|
|
{
|
|
double height = m_showRect.bottom - m_showRect.top;
|
|
m_showRect.top -= height / 10.0;
|
|
m_showRect.bottom -= height / 10.0;
|
|
recalcShowRect(this->width(), this->height(), m_scrollSize, m_hScroll, m_vScroll, m_showImage, m_showRect);
|
|
}
|
|
|
|
updateMoveStatusAndCursor();
|
|
Show();
|
|
}
|
|
|
|
void HGImgView::enterEvent(QEvent *e)
|
|
{
|
|
Q_UNUSED(e);
|
|
m_mouseOn = true;
|
|
}
|
|
|
|
void HGImgView::leaveEvent(QEvent *e)
|
|
{
|
|
Q_UNUSED(e);
|
|
|
|
// 拖动状态不能重置
|
|
//m_draging = false;
|
|
|
|
m_operate = 0;
|
|
m_beginX = -1;
|
|
m_beginY = -1;
|
|
|
|
m_mouseOn = false;
|
|
m_mouseMoveStatus = MouseStatus_Null;
|
|
Show();
|
|
emit mousePos(0, 0);
|
|
}
|
|
|
|
void HGImgView::paintEvent(QPaintEvent* e)
|
|
{
|
|
Q_UNUSED(e);
|
|
|
|
QPainter painter(this);
|
|
painter.fillRect(0, 0, this->width(), this->height(), qRgb(250, 250, 250));
|
|
|
|
if (nullptr == m_image || !m_showImage)
|
|
{
|
|
return;
|
|
}
|
|
|
|
HGImageInfo info;
|
|
HGBase_GetImageInfo(m_image, &info);
|
|
|
|
QImage::Format fmt = QImage::Format_Invalid;
|
|
if (info.type == HGBASE_IMGTYPE_GRAY)
|
|
fmt = QImage::Format_Grayscale8;
|
|
else if (info.type == HGBASE_IMGTYPE_RGB)
|
|
fmt = QImage::Format_RGB888;
|
|
if (QImage::Format_Invalid == fmt)
|
|
{
|
|
return;
|
|
}
|
|
|
|
HGByte *data = nullptr;
|
|
HGBase_GetImageData(m_image, &data);
|
|
QImage img(data, info.width, info.height, info.widthStep, fmt);
|
|
if (img.isNull())
|
|
{
|
|
return;
|
|
}
|
|
#if 0
|
|
HGRect rcWnd = {0, 0, this->width(), this->height()};
|
|
int nImgWidth = info.width;
|
|
int nImgHeight = info.height;
|
|
|
|
// 绘制Image
|
|
int xDest, yDest, wDest, hDest;
|
|
int xSrc, ySrc, wSrc, hSrc;
|
|
|
|
HGRect rcShowImage; // 绘制的图像区域
|
|
rcShowImage.left = round(m_showRect.left);
|
|
rcShowImage.top = round(m_showRect.top);
|
|
rcShowImage.right = round(m_showRect.right);
|
|
rcShowImage.bottom = round(m_showRect.bottom);
|
|
int nShowWidth = rcShowImage.right - rcShowImage.left;
|
|
int nShowHeight = rcShowImage.bottom - rcShowImage.top;
|
|
|
|
if (rcShowImage.left <= rcWnd.left)
|
|
{
|
|
float fPixel = (float)nImgWidth * (rcWnd.left - rcShowImage.left) / nShowWidth;
|
|
float fPixelR = (float)nImgWidth * (rcShowImage.right - rcWnd.right) / nShowWidth;
|
|
xDest = rcShowImage.left + round((int)fPixel * (float)nShowWidth / nImgWidth);
|
|
int xDestR = rcShowImage.right - round((int)fPixelR * (float)nShowWidth / nImgWidth);
|
|
wDest = xDestR - xDest;
|
|
wSrc = round((float)nImgWidth * wDest / nShowWidth);
|
|
xSrc = round((float)(xDest - rcShowImage.left) * nImgWidth / nShowWidth);
|
|
}
|
|
else
|
|
{
|
|
xDest = rcShowImage.left;
|
|
wDest = nShowWidth;
|
|
xSrc = 0;
|
|
wSrc = nImgWidth;
|
|
}
|
|
|
|
if (rcShowImage.top <= rcWnd.top)
|
|
{
|
|
float fPixel = (float)nImgHeight * (rcWnd.top - rcShowImage.top) / nShowHeight;
|
|
float fPixelB = (float)nImgHeight * (rcShowImage.bottom - rcWnd.bottom) / nShowHeight;
|
|
yDest = rcShowImage.top + round((int)fPixel * (float)nShowHeight / nImgHeight);
|
|
int yDestB = rcShowImage.bottom - round((int)fPixelB * (float)nShowHeight / nImgHeight);
|
|
hDest = yDestB - yDest;
|
|
hSrc = round((float)nImgHeight * hDest / nShowHeight);
|
|
ySrc = round((float)(yDest - rcShowImage.top) * nImgHeight / nShowHeight);
|
|
}
|
|
else
|
|
{
|
|
yDest = rcShowImage.top;
|
|
hDest = nShowHeight;
|
|
ySrc = 0;
|
|
hSrc = nImgHeight;
|
|
}
|
|
|
|
QRect srcRect(xSrc, ySrc, wSrc, hSrc);
|
|
QRect destRect(xDest, yDest, wDest, hDest);
|
|
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.drawImage(destRect, img);
|
|
#endif
|
|
|
|
DrawScroll(painter);
|
|
}
|
|
|
|
void HGImgView::wheelEvent(QWheelEvent* e)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return;
|
|
}
|
|
|
|
MouseStatus mouseStatus = getMouseStatus(e->pos());
|
|
if (MouseStatus_Null != mouseStatus)
|
|
{
|
|
if (MouseStatus_HScroll == mouseStatus || MouseStatus_HScrollSlider == mouseStatus
|
|
|| MouseStatus_HScrollLeft == mouseStatus || MouseStatus_HScrollRight == mouseStatus)
|
|
{
|
|
double width = m_showRect.right - m_showRect.left;
|
|
|
|
if (e->delta() > 0)
|
|
{
|
|
m_showRect.left += width / 10.0;
|
|
m_showRect.right += width / 10.0;
|
|
}
|
|
else
|
|
{
|
|
m_showRect.left -= width / 10.0;
|
|
m_showRect.right -= width / 10.0;
|
|
}
|
|
|
|
recalcShowRect(this->width(), this->height(), m_scrollSize, m_hScroll, m_vScroll, m_showImage, m_showRect);
|
|
}
|
|
else if (MouseStatus_VScroll == mouseStatus || MouseStatus_VScrollSlider == mouseStatus
|
|
|| MouseStatus_VScrollTop == mouseStatus || MouseStatus_VScrollBottom == mouseStatus)
|
|
{
|
|
double height = m_showRect.bottom - m_showRect.top;
|
|
|
|
if (e->delta() > 0)
|
|
{
|
|
m_showRect.top += height / 10.0;
|
|
m_showRect.bottom += height / 10.0;
|
|
}
|
|
else
|
|
{
|
|
m_showRect.top -= height / 10.0;
|
|
m_showRect.bottom -= height / 10.0;
|
|
}
|
|
|
|
recalcShowRect(this->width(), this->height(), m_scrollSize, m_hScroll, m_vScroll, m_showImage, m_showRect);
|
|
}
|
|
|
|
Show();
|
|
return;
|
|
}
|
|
|
|
HGPoint pt = {e->pos().x(), e->pos().y()};
|
|
|
|
if (e->delta() > 0)
|
|
zoomIn(&pt);
|
|
else
|
|
zoomOut(&pt);
|
|
}
|
|
|
|
void HGImgView::resizeEvent(QResizeEvent* e)
|
|
{
|
|
Q_UNUSED(e);
|
|
|
|
reset();
|
|
|
|
if (nullptr != m_image)
|
|
{
|
|
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;
|
|
|
|
emit scaleChanged(scale);
|
|
}
|
|
|
|
updateMoveStatusAndCursor();
|
|
Show();
|
|
}
|
|
|
|
void HGImgView::keyPressEvent(QKeyEvent *e)
|
|
{
|
|
Q_UNUSED(e);
|
|
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (e->key() == Qt::Key_Escape)
|
|
{
|
|
emit escape();
|
|
}
|
|
}
|
|
|
|
void HGImgView::dragEnterEvent(QDragEnterEvent *e)
|
|
{
|
|
qDebug("dragEnterEvent");
|
|
|
|
if (e->mimeData()->hasUrls())
|
|
{
|
|
m_draging = true;
|
|
e->accept();
|
|
}
|
|
}
|
|
|
|
void HGImgView::dragMoveEvent(QDragMoveEvent *e)
|
|
{
|
|
//qDebug("dragMoveEvent");
|
|
Q_UNUSED(e);
|
|
|
|
//Show();
|
|
}
|
|
|
|
void HGImgView::dragLeaveEvent(QDragLeaveEvent *e)
|
|
{
|
|
qDebug("dragLeaveEvent");
|
|
Q_UNUSED(e);
|
|
|
|
m_draging = false;
|
|
//Show();
|
|
}
|
|
|
|
void HGImgView::dropEvent(QDropEvent *e)
|
|
{
|
|
Q_UNUSED(e);
|
|
|
|
QStringList fileNames;
|
|
QList<QUrl> urls = e->mimeData()->urls();
|
|
for (QUrl url : urls)
|
|
{
|
|
fileNames.append(url.toLocalFile());
|
|
}
|
|
|
|
m_draging = false;
|
|
emit drop(e->source(), fileNames);
|
|
}
|
|
|
|
void HGImgView::mouseDoubleClickEvent(QMouseEvent* e)
|
|
{
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return;
|
|
}
|
|
|
|
MouseStatus mouseMoveStatus = getMouseStatus(e->pos());
|
|
if (MouseStatus_Null == mouseMoveStatus)
|
|
{
|
|
emit doubleClicked();
|
|
}
|
|
else
|
|
{
|
|
QWidget::mouseDoubleClickEvent(e);
|
|
}
|
|
}
|
|
|
|
void HGImgView::GetMinShowImageRect(const HGRect *pWnd, int nImgWidth, int nImgHeight, bool &bShowImage, HGRectF &rcShowImage)
|
|
{
|
|
bShowImage = false;
|
|
memset(&rcShowImage, 0, sizeof(HGRectF));
|
|
|
|
assert(nullptr != pWnd);
|
|
|
|
int nWndWidth = pWnd->right - pWnd->left;
|
|
int nWndHeight = pWnd->bottom - pWnd->top;
|
|
if (nWndWidth <= 0 || nWndHeight <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (nImgWidth <= 0 || nImgHeight <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
float fLeft, fTop, fRight, fBottom;
|
|
|
|
if (nImgWidth > nWndWidth || nImgHeight > nWndHeight)
|
|
{
|
|
if (nImgWidth * nWndHeight < nImgHeight * nWndWidth)
|
|
{
|
|
float fWidth = (float)nWndHeight * nImgWidth / nImgHeight;
|
|
fLeft = (pWnd->left + pWnd->right - fWidth) / 2.0f;
|
|
fRight = (pWnd->left + pWnd->right + fWidth) / 2.0f;
|
|
fTop = (float)pWnd->top;
|
|
fBottom = (float)pWnd->bottom;
|
|
}
|
|
else
|
|
{
|
|
float fHeight = (float)nWndWidth * nImgHeight / nImgWidth;
|
|
fLeft = (float)pWnd->left;
|
|
fRight = (float)pWnd->right;
|
|
fTop = (pWnd->top + pWnd->bottom - fHeight) / 2.0f;
|
|
fBottom = (pWnd->top + pWnd->bottom + fHeight) / 2.0f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fLeft = (pWnd->left + pWnd->right - nImgWidth) / 2.0f;
|
|
fRight = (pWnd->left + pWnd->right + nImgWidth) / 2.0f;
|
|
fTop = (pWnd->top + pWnd->bottom - nImgHeight) / 2.0f;
|
|
fBottom = (pWnd->top + pWnd->bottom + nImgHeight) / 2.0f;
|
|
}
|
|
|
|
if (fRight - fLeft < 1e-3 || fBottom - fTop < 1e-3)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bShowImage = true;
|
|
rcShowImage.left = fLeft;
|
|
rcShowImage.top = fTop;
|
|
rcShowImage.right = fRight;
|
|
rcShowImage.bottom = fBottom;
|
|
}
|
|
|
|
void HGImgView::ResizeShowImageRect(bool &bShowImage, HGRectF &rcShowImage, float fNewWidth, float fNewHeight, const HGPoint *pCenter)
|
|
{
|
|
if (!bShowImage)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (fNewWidth <= 0 || fNewHeight <= 0)
|
|
{
|
|
bShowImage = false;
|
|
memset(&rcShowImage, 0, sizeof(HGRectF));
|
|
return;
|
|
}
|
|
|
|
float fCurWidth = rcShowImage.right - rcShowImage.left;
|
|
float fCurHeight = rcShowImage.bottom - rcShowImage.top;
|
|
|
|
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;
|
|
}
|
|
else
|
|
{
|
|
rcShowImage.left = rcShowImage.left - (fNewWidth - fCurWidth) / 2.0f;
|
|
rcShowImage.top = rcShowImage.top - (fNewHeight - fCurHeight) / 2.0f;
|
|
}
|
|
|
|
rcShowImage.right = rcShowImage.left + fNewWidth;
|
|
rcShowImage.bottom = rcShowImage.top + fNewHeight;
|
|
|
|
if (rcShowImage.right - rcShowImage.left < 1e-3 || rcShowImage.bottom - rcShowImage.top < 1e-3)
|
|
{
|
|
bShowImage = false;
|
|
memset(&rcShowImage, 0, sizeof(HGRectF));
|
|
}
|
|
}
|
|
|
|
void HGImgView::recalcShowRect(int wndWidth, int wndHeight, int scrollSize, bool hScroll, bool vScroll, bool showImage, HGRectF &imageRect)
|
|
{
|
|
if (!showImage)
|
|
return;
|
|
|
|
double width = imageRect.right - imageRect.left;
|
|
double height = imageRect.bottom - imageRect.top;
|
|
|
|
int vScorllSize = vScroll ? scrollSize : 0;
|
|
if (width <= (double)(wndWidth - vScorllSize))
|
|
{
|
|
imageRect.left = (wndWidth - vScorllSize - width) / 2.0;
|
|
imageRect.right = imageRect.left + width;
|
|
}
|
|
else
|
|
{
|
|
if (imageRect.right < (double)(wndWidth - vScorllSize))
|
|
{
|
|
imageRect.right = wndWidth - vScorllSize;
|
|
imageRect.left = imageRect.right - width;
|
|
}
|
|
if (imageRect.left > 0)
|
|
{
|
|
imageRect.left = 0;
|
|
imageRect.right = imageRect.left + width;
|
|
}
|
|
}
|
|
|
|
int hScorllSize = hScroll ? scrollSize : 0;
|
|
if (height <= (double)(wndHeight - hScorllSize))
|
|
{
|
|
imageRect.top = (wndHeight - hScorllSize - height) / 2.0;
|
|
imageRect.bottom = imageRect.top + height;
|
|
}
|
|
else
|
|
{
|
|
if (imageRect.bottom < (double)(wndHeight - hScorllSize))
|
|
{
|
|
imageRect.bottom = wndHeight - hScorllSize;
|
|
imageRect.top = imageRect.bottom - height;
|
|
}
|
|
if (imageRect.top > 0)
|
|
{
|
|
imageRect.top = 0;
|
|
imageRect.bottom = imageRect.top + height;
|
|
}
|
|
}
|
|
}
|
|
|
|
void HGImgView::DrawImage(QPainter &painter, const QRect &destRect, const QImage *image, const QRect &stretchRect)
|
|
{
|
|
if (destRect.width() < image->width() - stretchRect.width()
|
|
|| destRect.height() < image->height() - stretchRect.height())
|
|
{
|
|
painter.drawImage(destRect, *image);
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < 9; ++i)
|
|
{
|
|
int DestX = destRect.left(), DestY = destRect.top(), DestWidth = destRect.width(), DestHeight = destRect.height();
|
|
int SrcX = 0, SrcY = 0, SrcWidth = image->width(), SrcHeight = image->height();
|
|
|
|
if (0 == i % 3)
|
|
{
|
|
DestX = destRect.left();
|
|
DestWidth = stretchRect.left();
|
|
SrcX = 0;
|
|
SrcWidth = stretchRect.left();
|
|
}
|
|
else if (1 == i % 3)
|
|
{
|
|
DestX = destRect.left() + stretchRect.left();
|
|
DestWidth = destRect.width() + stretchRect.width() - image->width();
|
|
SrcX = stretchRect.left();
|
|
SrcWidth = stretchRect.width();
|
|
}
|
|
else if (2 == i % 3)
|
|
{
|
|
DestX = destRect.left() + destRect.width() + stretchRect.left() + stretchRect.width() - image->width();
|
|
DestWidth = image->width() - (stretchRect.left() + stretchRect.width());
|
|
SrcX = stretchRect.left() + stretchRect.width();
|
|
SrcWidth = image->width() - (stretchRect.left() + stretchRect.width());
|
|
}
|
|
|
|
if (0 == i / 3)
|
|
{
|
|
DestY = destRect.top();
|
|
DestHeight = stretchRect.top();
|
|
SrcY = 0;
|
|
SrcHeight = stretchRect.top();
|
|
}
|
|
else if (1 == i / 3)
|
|
{
|
|
DestY = destRect.top() + stretchRect.top();
|
|
DestHeight = destRect.height() + stretchRect.height() - image->height();
|
|
SrcY = stretchRect.top();
|
|
SrcHeight = stretchRect.height();
|
|
}
|
|
else if (2 == i / 3)
|
|
{
|
|
DestY = destRect.top() + destRect.height() + stretchRect.top() + stretchRect.height() - image->height();
|
|
DestHeight = image->height() - (stretchRect.top() + stretchRect.height());
|
|
SrcY = stretchRect.top() + stretchRect.height();
|
|
SrcHeight = image->height() - (stretchRect.top() + stretchRect.height());
|
|
}
|
|
|
|
QRect dest(DestX, DestY, DestWidth, DestHeight);
|
|
QRect src(SrcX, SrcY, SrcWidth, SrcHeight);
|
|
painter.drawImage(dest, *image, src);
|
|
}
|
|
}
|
|
|
|
void HGImgView::DrawScroll(QPainter &painter)
|
|
{
|
|
// 滚动条背景
|
|
QColor clrHScroll = qRgb(220, 220, 220);
|
|
QImage *imgHScroll = m_hScrollImage;
|
|
QColor clrVScroll = qRgb(220, 220, 220);
|
|
QImage *imgVScroll = m_vScrollImage;
|
|
QColor clrNullScroll = qRgb(255, 255, 255);
|
|
QImage *nullScrollImage = m_nullScrollImage;
|
|
|
|
// 水平滑块
|
|
QColor clrHScrollSlider = qRgb(180, 180, 180);
|
|
QImage *imgHScrollSlider = m_hScrollSliderImage[0];
|
|
QRect hScrollSliderStretch = m_hScrollSliderImageStretch[0];
|
|
if (MouseStatus_HScrollSlider == m_mousePressStatus)
|
|
{
|
|
clrHScrollSlider = qRgb(100, 100, 100);
|
|
imgHScrollSlider = m_hScrollSliderImage[2];
|
|
hScrollSliderStretch = m_hScrollSliderImageStretch[2];
|
|
}
|
|
else if (MouseStatus_HScrollLeft == m_mousePressStatus || MouseStatus_HScrollRight == m_mousePressStatus
|
|
|| MouseStatus_HScroll == m_mousePressStatus
|
|
|| MouseStatus_HScrollSlider == m_mouseMoveStatus || MouseStatus_HScroll == m_mouseMoveStatus
|
|
|| MouseStatus_HScrollLeft == m_mouseMoveStatus || MouseStatus_HScrollRight == m_mouseMoveStatus)
|
|
{
|
|
clrHScrollSlider = qRgb(140, 140, 140);
|
|
imgHScrollSlider = m_hScrollSliderImage[1];
|
|
hScrollSliderStretch = m_hScrollSliderImageStretch[1];
|
|
}
|
|
|
|
// 垂直滑块
|
|
QColor clrVScrollSlider = qRgb(180, 180, 180);
|
|
QImage *imgVScrollSlider = m_vScrollSliderImage[0];
|
|
QRect vScrollSliderStretch = m_vScrollSliderImageStretch[0];
|
|
if (MouseStatus_VScrollSlider == m_mousePressStatus)
|
|
{
|
|
clrVScrollSlider = qRgb(100, 100, 100);
|
|
imgVScrollSlider = m_vScrollSliderImage[2];
|
|
vScrollSliderStretch = m_vScrollSliderImageStretch[2];
|
|
}
|
|
else if (MouseStatus_VScrollTop == m_mousePressStatus || MouseStatus_VScrollBottom == m_mousePressStatus
|
|
|| MouseStatus_VScroll == m_mousePressStatus
|
|
|| MouseStatus_VScrollSlider == m_mouseMoveStatus || MouseStatus_VScroll == m_mouseMoveStatus
|
|
|| MouseStatus_VScrollTop == m_mouseMoveStatus || MouseStatus_VScrollBottom == m_mouseMoveStatus)
|
|
{
|
|
clrVScrollSlider = qRgb(140, 140, 140);
|
|
imgVScrollSlider = m_vScrollSliderImage[1];
|
|
vScrollSliderStretch = m_vScrollSliderImageStretch[1];
|
|
}
|
|
|
|
// 水平左键
|
|
QColor clrHScrollLeft = qRgb(220, 220, 220);
|
|
QImage *imgHScrollLeft = m_hScrollLeftImage[0];
|
|
if (MouseStatus_HScrollLeft == m_mousePressStatus)
|
|
{
|
|
clrHScrollLeft = qRgb(140, 140, 140);
|
|
imgHScrollLeft = m_hScrollLeftImage[2];
|
|
}
|
|
else if (MouseStatus_HScrollRight == m_mousePressStatus || MouseStatus_HScrollSlider == m_mousePressStatus
|
|
|| MouseStatus_HScroll == m_mousePressStatus
|
|
|| MouseStatus_HScrollSlider == m_mouseMoveStatus || MouseStatus_HScroll == m_mouseMoveStatus
|
|
|| MouseStatus_HScrollLeft == m_mouseMoveStatus || MouseStatus_HScrollRight == m_mouseMoveStatus)
|
|
{
|
|
clrHScrollLeft = qRgb(180, 180, 180);
|
|
imgHScrollLeft = m_hScrollLeftImage[1];
|
|
}
|
|
|
|
// 水平右键
|
|
QColor clrHScrollRight = qRgb(220, 220, 220);
|
|
QImage *imgHScrollRight = m_hScrollRightImage[0];
|
|
if (MouseStatus_HScrollRight == m_mousePressStatus)
|
|
{
|
|
clrHScrollRight = qRgb(140, 140, 140);
|
|
imgHScrollRight = m_hScrollRightImage[2];
|
|
}
|
|
else if (MouseStatus_HScrollLeft == m_mousePressStatus || MouseStatus_HScrollSlider == m_mousePressStatus
|
|
|| MouseStatus_HScroll == m_mousePressStatus
|
|
|| MouseStatus_HScrollSlider == m_mouseMoveStatus || MouseStatus_HScroll == m_mouseMoveStatus
|
|
|| MouseStatus_HScrollLeft == m_mouseMoveStatus || MouseStatus_HScrollRight == m_mouseMoveStatus)
|
|
{
|
|
clrHScrollRight = qRgb(180, 180, 180);
|
|
imgHScrollRight = m_hScrollRightImage[1];
|
|
}
|
|
|
|
// 垂直上键
|
|
QColor clrVScrollTop = qRgb(220, 220, 220);
|
|
QImage *imgVScrollTop = m_vScrollTopImage[0];
|
|
if (MouseStatus_VScrollTop == m_mousePressStatus)
|
|
{
|
|
clrVScrollTop = qRgb(140, 140, 140);
|
|
imgVScrollTop = m_vScrollTopImage[2];
|
|
}
|
|
else if (MouseStatus_VScrollSlider == m_mousePressStatus || MouseStatus_VScrollBottom == m_mousePressStatus
|
|
|| MouseStatus_VScroll == m_mousePressStatus
|
|
|| MouseStatus_VScrollSlider == m_mouseMoveStatus || MouseStatus_VScroll == m_mouseMoveStatus
|
|
|| MouseStatus_VScrollTop == m_mouseMoveStatus || MouseStatus_VScrollBottom == m_mouseMoveStatus)
|
|
{
|
|
clrVScrollTop = qRgb(180, 180, 180);
|
|
imgVScrollTop = m_vScrollTopImage[1];
|
|
}
|
|
|
|
// 垂直下键
|
|
QColor clrVScrollBottom = qRgb(220, 220, 220);
|
|
QImage *imgVScrollBottom = m_vScrollBottomImage[0];
|
|
if (MouseStatus_VScrollBottom == m_mousePressStatus)
|
|
{
|
|
clrVScrollBottom = qRgb(140, 140, 140);
|
|
imgVScrollBottom = m_vScrollBottomImage[2];
|
|
}
|
|
else if (MouseStatus_VScrollSlider == m_mousePressStatus || MouseStatus_VScrollTop == m_mousePressStatus
|
|
|| MouseStatus_VScroll == m_mousePressStatus
|
|
|| MouseStatus_VScrollSlider == m_mouseMoveStatus || MouseStatus_VScroll == m_mouseMoveStatus
|
|
|| MouseStatus_VScrollTop == m_mouseMoveStatus || MouseStatus_VScrollBottom == m_mouseMoveStatus)
|
|
{
|
|
clrVScrollBottom = qRgb(180, 180, 180);
|
|
imgVScrollBottom = m_vScrollBottomImage[1];
|
|
}
|
|
|
|
if (m_hScroll)
|
|
{
|
|
if (nullptr == imgHScroll)
|
|
painter.fillRect(getHScrollPos(), clrHScroll);
|
|
else
|
|
DrawImage(painter, getHScrollPos(), imgHScroll, m_hScrollImageStretch);
|
|
|
|
if (nullptr == imgHScrollLeft)
|
|
painter.fillRect(getHScrollLeftPos(), clrHScrollLeft);
|
|
else
|
|
painter.drawImage(getHScrollLeftPos(), *imgHScrollLeft);
|
|
|
|
if (nullptr == imgHScrollRight)
|
|
painter.fillRect(getHScrollRightPos(), clrHScrollRight);
|
|
else
|
|
painter.drawImage(getHScrollRightPos(), *imgHScrollRight);
|
|
|
|
if (nullptr == imgHScrollSlider)
|
|
painter.fillRect(getHScrollSliderPos(), clrHScrollSlider);
|
|
else
|
|
DrawImage(painter, getHScrollSliderPos(), imgHScrollSlider, hScrollSliderStretch);
|
|
}
|
|
|
|
if (m_vScroll)
|
|
{
|
|
if (nullptr == imgVScroll)
|
|
painter.fillRect(getVScrollPos(), clrVScroll);
|
|
else
|
|
DrawImage(painter, getVScrollPos(), imgVScroll, m_vScrollImageStretch);
|
|
|
|
if (nullptr == imgVScrollTop)
|
|
painter.fillRect(getVScrollTopPos(), clrVScrollTop);
|
|
else
|
|
painter.drawImage(getVScrollTopPos(), *imgVScrollTop);
|
|
|
|
if (nullptr == imgVScrollBottom)
|
|
painter.fillRect(getVScrollBottomPos(), clrVScrollBottom);
|
|
else
|
|
painter.drawImage(getVScrollBottomPos(), *imgVScrollBottom);
|
|
|
|
if (nullptr == imgVScrollSlider)
|
|
painter.fillRect(getVScrollSliderPos(), clrVScrollSlider);
|
|
else
|
|
DrawImage(painter, getVScrollSliderPos(), imgVScrollSlider, vScrollSliderStretch);
|
|
}
|
|
|
|
if (m_hScroll && m_vScroll)
|
|
{
|
|
if (nullptr == nullScrollImage)
|
|
painter.fillRect(getNullScrollPos(), clrNullScroll);
|
|
else
|
|
painter.drawImage(getNullScrollPos(), *nullScrollImage);
|
|
}
|
|
}
|
|
|
|
void HGImgView::reset()
|
|
{
|
|
// 复位
|
|
m_draging = false;
|
|
|
|
m_operate = 0;
|
|
m_beginX = -1;
|
|
m_beginY = -1;
|
|
}
|
|
|
|
void HGImgView::updateMoveStatusAndCursor()
|
|
{
|
|
m_mouseMoveStatus = getMouseStatus(mapFromGlobal(QCursor::pos()));
|
|
|
|
if (0 != m_operate)
|
|
{
|
|
setCursor(Qt::ClosedHandCursor);
|
|
}
|
|
else if (MouseStatus_Null != m_mousePressStatus || m_draging)
|
|
{
|
|
setCursor(Qt::ArrowCursor);
|
|
}
|
|
else
|
|
{
|
|
QRect rcWnd(0, 0, this->width(), this->height());
|
|
if (nullptr == m_image || !m_showImage
|
|
|| !m_showColorInfo || MouseStatus_Null != m_mouseMoveStatus
|
|
|| !rcWnd.contains(mapFromGlobal(QCursor::pos())))
|
|
{
|
|
setCursor(Qt::ArrowCursor);
|
|
}
|
|
else
|
|
{
|
|
HGImageInfo info;
|
|
HGBase_GetImageInfo(m_image, &info);
|
|
|
|
int xShow = mapFromGlobal(QCursor::pos()).x() - m_showRect.left;
|
|
int yShow = mapFromGlobal(QCursor::pos()).y() - m_showRect.top;
|
|
int xImg = xShow * (int)info.width / (m_showRect.right - m_showRect.left);
|
|
int yImg = yShow * (int)info.height / (m_showRect.bottom - m_showRect.top);
|
|
|
|
if (xImg >= 0 && xImg < (int)info.width && yImg >= 0 && yImg < (int)info.height)
|
|
{
|
|
setCursor(Qt::CrossCursor);
|
|
}
|
|
else
|
|
{
|
|
setCursor(Qt::ArrowCursor);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
HGImgView::MouseStatus HGImgView::getMouseStatus(const QPoint &pt)
|
|
{
|
|
MouseStatus mouseStatus = MouseStatus_Null;
|
|
if (MouseStatus_Null != m_mousePressStatus || 0 != m_operate || m_draging)
|
|
{
|
|
return mouseStatus;
|
|
}
|
|
|
|
if (!m_mouseOn)
|
|
{
|
|
return mouseStatus;
|
|
}
|
|
|
|
if (m_hScroll && m_vScroll)
|
|
{
|
|
if (getHScrollSliderPos().contains(pt))
|
|
mouseStatus = MouseStatus_HScrollSlider;
|
|
else if (getHScrollLeftPos().contains(pt))
|
|
mouseStatus = MouseStatus_HScrollLeft;
|
|
else if (getHScrollRightPos().contains(pt))
|
|
mouseStatus = MouseStatus_HScrollRight;
|
|
else if (getHScrollPos().contains(pt))
|
|
mouseStatus = MouseStatus_HScroll;
|
|
else if (getVScrollSliderPos().contains(pt))
|
|
mouseStatus = MouseStatus_VScrollSlider;
|
|
else if (getVScrollTopPos().contains(pt))
|
|
mouseStatus = MouseStatus_VScrollTop;
|
|
else if (getVScrollBottomPos().contains(pt))
|
|
mouseStatus = MouseStatus_VScrollBottom;
|
|
else if (getVScrollPos().contains(pt))
|
|
mouseStatus = MouseStatus_VScroll;
|
|
else if (getNullScrollPos().contains(pt))
|
|
mouseStatus = MouseStatus_NullScroll;
|
|
}
|
|
else if (m_hScroll && !m_vScroll)
|
|
{
|
|
if (getHScrollSliderPos().contains(pt))
|
|
mouseStatus = MouseStatus_HScrollSlider;
|
|
else if (getHScrollLeftPos().contains(pt))
|
|
mouseStatus = MouseStatus_HScrollLeft;
|
|
else if (getHScrollRightPos().contains(pt))
|
|
mouseStatus = MouseStatus_HScrollRight;
|
|
else if (getHScrollPos().contains(pt))
|
|
mouseStatus = MouseStatus_HScroll;
|
|
}
|
|
else if (!m_hScroll && m_vScroll)
|
|
{
|
|
if (getVScrollSliderPos().contains(pt))
|
|
mouseStatus = MouseStatus_VScrollSlider;
|
|
else if (getVScrollTopPos().contains(pt))
|
|
mouseStatus = MouseStatus_VScrollTop;
|
|
else if (getVScrollBottomPos().contains(pt))
|
|
mouseStatus = MouseStatus_VScrollBottom;
|
|
else if (getVScrollPos().contains(pt))
|
|
mouseStatus = MouseStatus_VScroll;
|
|
}
|
|
|
|
return mouseStatus;
|
|
}
|
|
|
|
QRect HGImgView::getHScrollLeftPos()
|
|
{
|
|
assert(m_hScroll);
|
|
|
|
return QRect(0, this->height() - m_scrollSize, m_scrollSize, m_scrollSize);
|
|
}
|
|
|
|
QRect HGImgView::getHScrollRightPos()
|
|
{
|
|
assert(m_hScroll);
|
|
|
|
if (!m_vScroll)
|
|
{
|
|
return QRect(this->width() - m_scrollSize, this->height() - m_scrollSize, m_scrollSize, m_scrollSize);
|
|
}
|
|
|
|
return QRect(this->width() - 2 * m_scrollSize, this->height() - m_scrollSize, m_scrollSize, m_scrollSize);
|
|
}
|
|
|
|
QRect HGImgView::getHScrollPos()
|
|
{
|
|
assert(m_hScroll);
|
|
|
|
if (!m_vScroll)
|
|
{
|
|
return QRect(0, this->height() - m_scrollSize, this->width(), m_scrollSize);
|
|
}
|
|
|
|
return QRect(0, this->height() - m_scrollSize, this->width() - m_scrollSize, m_scrollSize);
|
|
}
|
|
|
|
QRect HGImgView::getHScrollSliderPos()
|
|
{
|
|
assert(m_hScroll);
|
|
|
|
QRect rect;
|
|
rect.setY(this->height() - m_scrollSize);
|
|
rect.setHeight(m_scrollSize);
|
|
if (!m_vScroll)
|
|
{
|
|
int rollTotalLen = this->width() - 2 * m_scrollSize;
|
|
int rollLeft = round((double)rollTotalLen * (-m_showRect.left) / (double)(m_showRect.right - m_showRect.left));
|
|
int rollRight = round((double)rollTotalLen * (-m_showRect.left + this->width()) / (double)(m_showRect.right - m_showRect.left));
|
|
int rollLen = rollRight - rollLeft;
|
|
if (rollLen < m_minScrollSliderSize)
|
|
{
|
|
rollLen = m_minScrollSliderSize;
|
|
rollLeft = round((double)(rollTotalLen - m_minScrollSliderSize) * (-m_showRect.left) / (double)(m_showRect.right - m_showRect.left - this->width()));
|
|
}
|
|
|
|
rect.setX(rollLeft + m_scrollSize);
|
|
rect.setWidth(rollLen);
|
|
}
|
|
else
|
|
{
|
|
int rollTotalLen = this->width() - 3 * m_scrollSize;
|
|
int rollLeft = round((double)rollTotalLen * (-m_showRect.left) / (double)(m_showRect.right - m_showRect.left));
|
|
int rollRight = round((double)rollTotalLen * (-m_showRect.left + this->width() - m_scrollSize) / (double)(m_showRect.right - m_showRect.left));
|
|
int rollLen = rollRight - rollLeft;
|
|
if (rollLen < m_minScrollSliderSize)
|
|
{
|
|
rollLen = m_minScrollSliderSize;
|
|
rollLeft = round((double)(rollTotalLen - m_minScrollSliderSize) * (-m_showRect.left) / (double)(m_showRect.right - m_showRect.left - this->width() + m_scrollSize));
|
|
}
|
|
|
|
rect.setX(rollLeft + m_scrollSize);
|
|
rect.setWidth(rollLen);
|
|
}
|
|
|
|
return rect;
|
|
}
|
|
|
|
QRect HGImgView::getVScrollTopPos()
|
|
{
|
|
assert(m_vScroll);
|
|
|
|
return QRect(this->width() - m_scrollSize, 0, m_scrollSize, m_scrollSize);
|
|
}
|
|
|
|
QRect HGImgView::getVScrollBottomPos()
|
|
{
|
|
assert(m_vScroll);
|
|
|
|
if (!m_hScroll)
|
|
{
|
|
return QRect(this->width() - m_scrollSize, this->height() - m_scrollSize, m_scrollSize, m_scrollSize);
|
|
}
|
|
|
|
return QRect(this->width() - m_scrollSize, this->height() - 2 * m_scrollSize, m_scrollSize, m_scrollSize);
|
|
}
|
|
|
|
QRect HGImgView::getVScrollPos()
|
|
{
|
|
assert(m_vScroll);
|
|
|
|
if (!m_hScroll)
|
|
{
|
|
return QRect(this->width() - m_scrollSize, 0, m_scrollSize, this->height());
|
|
}
|
|
|
|
return QRect(this->width() - m_scrollSize, 0, m_scrollSize, this->height() - m_scrollSize);
|
|
}
|
|
|
|
QRect HGImgView::getVScrollSliderPos()
|
|
{
|
|
assert(m_vScroll);
|
|
|
|
QRect rect;
|
|
rect.setX(this->width() - m_scrollSize);
|
|
rect.setWidth(m_scrollSize);
|
|
if (!m_hScroll)
|
|
{
|
|
int rollTotalLen = this->height() - 2 * m_scrollSize;
|
|
int rollTop = round((double)rollTotalLen * (-m_showRect.top) / (double)(m_showRect.bottom - m_showRect.top));
|
|
int rollBottom = round((double)rollTotalLen * (-m_showRect.top + this->height()) / (double)(m_showRect.bottom - m_showRect.top));
|
|
int rollLen = rollBottom - rollTop;
|
|
if (rollLen < m_minScrollSliderSize)
|
|
{
|
|
rollLen = m_minScrollSliderSize;
|
|
rollTop = round((double)(rollTotalLen - m_minScrollSliderSize) * (-m_showRect.top) / (double)(m_showRect.bottom - m_showRect.top - this->height()));
|
|
}
|
|
|
|
rect.setY(rollTop + m_scrollSize);
|
|
rect.setHeight(rollLen);
|
|
}
|
|
else
|
|
{
|
|
int rollTotalLen = this->height() - 3 * m_scrollSize;
|
|
int rollTop = round((double)rollTotalLen * (-m_showRect.top) / (double)(m_showRect.bottom - m_showRect.top));
|
|
int rollBottom = round((double)rollTotalLen * (-m_showRect.top + this->height() - m_scrollSize) / (double)(m_showRect.bottom - m_showRect.top));
|
|
int rollLen = rollBottom - rollTop;
|
|
if (rollLen < m_minScrollSliderSize)
|
|
{
|
|
rollLen = m_minScrollSliderSize;
|
|
rollTop = round((double)(rollTotalLen - m_minScrollSliderSize) * (-m_showRect.top) / (double)(m_showRect.bottom - m_showRect.top - this->height() + m_scrollSize));
|
|
}
|
|
|
|
rect.setY(rollTop + m_scrollSize);
|
|
rect.setHeight(rollLen);
|
|
}
|
|
|
|
return rect;
|
|
}
|
|
|
|
QRect HGImgView::getNullScrollPos()
|
|
{
|
|
assert(m_hScroll && m_vScroll);
|
|
return QRect(this->width() - m_scrollSize, this->height() - m_scrollSize, m_scrollSize, m_scrollSize);
|
|
}
|
|
|
|
void HGImgView::Show()
|
|
{
|
|
repaint();
|
|
}
|