无极缩放滚动条

最新推荐文章于 2023-09-07 10:46:15 发布
最新推荐文章于 2023-09-07 10:46:15 发布
阅读量414 收藏
点赞数
分类专栏： QT 文章标签： QT 无极缩放
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15821883/article/details/114521676
版权

滚动条分析

1、无极缩放滚动条，滚动条包含滑块、左右拉伸按钮，  最左、最右存在两个sigle step按钮

2、value计算

3、缩放计算(滚动条特有)

滑块占整个滚动条的长度比例

4、节目布局

5、代码

#pragma once
#include <QFrame>
#include <QToolButton>
#include <QBoxLayout>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QPushButton>
#include <QMouseEvent>

/*
*	总长度length = maximum() - minimum() + pageStep()
*	修改滑块的长度,相当于改变了滚动的长度,相当于缩放整个滚动条
*
*/

namespace Ui
{
	class ScrollBar;
}

class ScrollBar : public QFrame
{
	Q_OBJECT

	Q_PROPERTY(int minimum READ minimum WRITE setMinimum)
	Q_PROPERTY(int maximum READ maximum WRITE setMaximum)
	Q_PROPERTY(int singleStep READ singleStep WRITE setSingleStep)
	Q_PROPERTY(int pageStep READ pageStep WRITE setPageStep)
	Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged USER true)
	Q_PROPERTY(Qt::Orientation orientation READ orientation WRITE setOrientation)

public:
	enum ScrollBarMouseType
	{
		ScrollBarMouseType_normorl,				// 默认移动
		ScrollBarMouseType_left,				// 拖拽左边缩放按钮
		ScrollBarMouseType_right,				// 拖拽右边缩放按钮
		ScrollBarMouseType_move,				// 移动按钮
	};

public:
	explicit ScrollBar(QWidget *parent = Q_NULLPTR);
	~ScrollBar();

	Qt::Orientation orientation() const;

	void setMinimum(int);
	int minimum() const;

	void setMaximum(int);
	int maximum() const;

	void setSingleStep(int);
	int singleStep() const;

	void setPageStep(int);
	int pageStep() const;

	void setSliderDown(bool);
	bool isSliderDown() const;

	void setScale(double dScale);
	double getScale() const;

	void setScaleButtonVisible(bool visible);
	bool getScaleButtonVisible() const;

	void setSingleButtonVisible(bool visible);
	bool getSingleButtonVisible() const;

	int value() const;

public Q_SLOTS:
	void setValue(int);
	void setOrientation(Qt::Orientation);
	void setRange(int min, int max);
	void doMouseMoveEvent(QMouseEvent *event);

Q_SIGNALS:
	void valueChanged(int value);
	void sliderPressed();
	void sliderMoved(int position);
	void sliderReleased();
	void rangeChanged(int min, int max);
	void scaleChanged(double scale); // 0~1

protected:
	virtual void mouseReleaseEvent(QMouseEvent *) override;
	virtual void mouseMoveEvent(QMouseEvent *) override;
	virtual bool eventFilter(QObject *obj, QEvent *event) override;
	virtual void resizeEvent(QResizeEvent *event) override;

private:
	void calcPosition();
	void caclScale();

	// UI部分
protected:
	void resetUi();

protected:
	Qt::Orientation			mOrientation;						// 格式
	ScrollBarMouseType		mMouseType;
	QPoint					mPointPress;						// 鼠标按下位置

protected:
	Ui::ScrollBar*		mUi;

private:
	int						mMinimum;							// 最大值
	int                     mMaximum;						    // 最小值
	int						mPageStep;							// 
	int						mSingleStep;						// 跳动距离
	int                     mValue;								// 进度值	
	bool					mSliderDown;						// slider 按下
	double					mScale;								// 缩放值，用来处理 实际显示的大小
	bool					mScaleBtnVisible;					// 缩放按钮是否显示
	bool					mSingleBtnVisible;					// 左右移动btn是否显示
};
#include "ScrollBar.h"
#include "ui_ScrollBar.h"
#include <QDebug>

#define MIN_LENTH 50

ScrollBar::ScrollBar(QWidget *parent)
	: QFrame(parent)
	, mOrientation(Qt::Horizontal)
	, mSliderDown(false)
	, mMinimum(0)
	, mMaximum(100)
	, mPageStep(1)
	, mSingleStep(1)
	, mValue(0)
	, mUi(new Ui::ScrollBar)
	, mMouseType(ScrollBarMouseType_normorl)
	, mScale(1)
	, mScaleBtnVisible(true)
	, mSingleBtnVisible(true)
{	 
	this->setContentsMargins(0, 0, 0, 0);
	mUi->setupUi(this);

	caclScale();

	mUi->mSliderLeftArrow->installEventFilter(this);
	mUi->mSliderToolButton->installEventFilter(this);
	mUi->mSliderRightArrow->installEventFilter(this);

	connect(mUi->mSliderToolButton, &QToolButton::pressed, this, [this]
	{
		mMouseType = ScrollBarMouseType_move;
	});
	connect(mUi->mSliderLeftArrow, &QToolButton::pressed, this, [this]
	{
		mMouseType = ScrollBarMouseType_left;
	});
	connect(mUi->mSliderRightArrow, &QToolButton::pressed, this, [this]
	{
		mMouseType = ScrollBarMouseType_right;
	});

	connect(mUi->mRightArrow, &QToolButton::clicked, this, [this]
	{
		setValue(mValue + mSingleStep);
	});

	connect(mUi->mLeftArrow, &QToolButton::clicked, this, [this]
	{
		setValue(mValue - mSingleStep);
	});
}

ScrollBar::~ScrollBar()
{
}

Qt::Orientation ScrollBar::orientation() const
{
	return mOrientation;
}

void ScrollBar::setMinimum(int min)
{
	setRange(min, mMaximum);
}

int ScrollBar::minimum() const
{
	return mMinimum;
}

void ScrollBar::setMaximum(int max)
{
	setRange(mMinimum, max);
}

int ScrollBar::maximum() const
{
	return mMaximum;
}

void ScrollBar::setSingleStep(int step)
{
	if (mSingleStep != step)
	{
		mSingleStep = step;
	}
}

int ScrollBar::singleStep() const
{
	return mSingleStep;
}

void ScrollBar::setPageStep(int step)
{
	if (mPageStep != step)
	{
		mPageStep = step;
	}
}

int ScrollBar::pageStep() const
{
	return mPageStep;
}

void ScrollBar::setSliderDown(bool bDown)
{
	mSliderDown = bDown;
	this->repaint();
}

bool ScrollBar::isSliderDown() const
{
	return mSliderDown;
}

void ScrollBar::setScale(double dScale)
{
	if (dScale < 0 || dScale > 1)
	{
		return;
	}

	if (mScale != dScale)
	{
		mScale = dScale;
		emit scaleChanged(dScale);

		qDebug() << mScale << endl;

		if (mMouseType == ScrollBarMouseType_normorl)
		{
			caclScale();
		}
	}
}


double ScrollBar::getScale() const
{
	return mScale;
}

void ScrollBar::setScaleButtonVisible(bool visible)
{
	if (mScaleBtnVisible != visible)
	{
		mScaleBtnVisible = visible;

		mUi->mSliderLeftArrow->setVisible(mScaleBtnVisible);
		mUi->mSliderRightArrow->setVisible(mScaleBtnVisible);

		caclScale();
	}
}

bool ScrollBar::getScaleButtonVisible() const
{
	return mScaleBtnVisible;
}

void ScrollBar::setSingleButtonVisible(bool visible)
{
	if (mSingleBtnVisible != visible)
	{
		mSingleBtnVisible = visible;

		mUi->mLeftArrow->setVisible(mScaleBtnVisible);
		mUi->mRightArrow->setVisible(mScaleBtnVisible);

		caclScale();
	}
}

bool ScrollBar::getSingleButtonVisible() const
{
	return mSingleBtnVisible;
}

int ScrollBar::value() const
{
	return mValue;
}

void ScrollBar::setValue(int value)
{
	if (value < mMinimum)
	{
		value = mMinimum;
	}
	else if (value > mMaximum)
	{
		value = mMaximum;
	}

	if (mValue != value)
	{
		mValue = value;
		emit valueChanged(value);

		if (mMouseType == ScrollBarMouseType_normorl)
		{
			calcPosition();
		}
		qDebug() << mValue << endl;
	}
}

void ScrollBar::setOrientation(Qt::Orientation ori)
{
	if (ori != mOrientation)
	{
		mOrientation = ori;

		resetUi();
	}
}

void ScrollBar::setRange(int min, int max)
{
	if (min != mMinimum || max != mMaximum)
	{
		mMinimum = qMin(min, max);
		mMaximum = qMax(min, max);

		emit rangeChanged(mMinimum, mMaximum);
	}
}

// 这个应该计算按下点在mouse的哪个位置
void ScrollBar::doMouseMoveEvent(QMouseEvent *event)
{
	if (mMouseType != ScrollBarMouseType_move)
	{
		return;
	}

	QRect rect = mUi->frame->frameGeometry();
	QRect sliderRect = mUi->mSliderFrame->frameGeometry();

	QPoint point = event->globalPos();

	if (mOrientation == Qt::Horizontal)
	{
		// 鼠标移动了多少个像素
		int dx = point.x() - mPointPress.x() + rect.x();

		if (dx >= 0 && (dx + rect.width()) <= sliderRect.width())
		{
			mUi->frame->setGeometry(QRect(dx, 0, rect.width(), sliderRect.height()));
		}
	}
	else
	{
		// 鼠标移动了多少个像素
		int dy = point.y() - mPointPress.y() + rect.y();
		if (dy >= 0 && (dy + rect.height()) <= sliderRect.height())
		{
			mUi->frame->setGeometry(QRect(0, dy, sliderRect.width(), rect.height()));
		}

	}
	mPointPress = point;
	calcPosition();
}

void ScrollBar::mouseReleaseEvent(QMouseEvent *event)
{
	mMouseType = ScrollBarMouseType_normorl;
	mPointPress = event->globalPos();
}

void ScrollBar::mouseMoveEvent(QMouseEvent *event)
{
	QPoint point = event->globalPos();
	
	// frame在sliderRect上的位置,不能超过sliderRect的宽高
	QRect rect = mUi->frame->frameGeometry();
	// 只有宽高是有用值
	QRect sliderRect = mUi->mSliderFrame->frameGeometry();
		 
	switch (mMouseType)
	{
	case ScrollBar::ScrollBarMouseType_normorl:
	{
		break;
	}
	case ScrollBar::ScrollBarMouseType_left:
	{
		if (mOrientation == Qt::Horizontal)
		{
			int nDx = point.x() - mPointPress.x();
			if (rect.x() < -nDx)
			{
				nDx = -rect.x();
			}

			int x = rect.x() + nDx;

			if (x >= 0 && MIN_LENTH < (rect.width() - nDx))
			{
				mUi->frame->setGeometry(QRect(x, 0, rect.width() - nDx, sliderRect.height()));
			}
		}
		else
		{
			int nDy = point.y() - mPointPress.y();
			if (rect.y() < -nDy)
			{
				nDy = -rect.y();
			}

			int y = rect.y() + nDy;

			if (y >= 0 && MIN_LENTH < (rect.height() - nDy))
			{
				mUi->frame->setGeometry(QRect(0, y, sliderRect.width(), rect.height() - nDy));
			}

		}
		caclScale();
		break;
	}
	case ScrollBar::ScrollBarMouseType_right:
	{
		if (mOrientation == Qt::Horizontal)
		{
			int nDx = point.x() - mPointPress.x();
			if ((rect.topRight().x() + nDx) > sliderRect.width())
			{
				nDx = sliderRect.width() - rect.topRight().x();
			}
			if ((rect.width() + nDx) > (MIN_LENTH))
			{
				mUi->frame->setGeometry(QRect(rect.x(), 0, rect.width() + nDx, sliderRect.height()));
			}
		}
		else
		{
			int nDy = point.y() - mPointPress.y();
			if ((rect.bottomRight().y() + nDy) > sliderRect.height())
			{
				nDy = sliderRect.height() - rect.bottomRight().y();
			}
			if ((rect.height() + nDy) > (MIN_LENTH))
			{
				mUi->frame->setGeometry(QRect(0, rect.y(), sliderRect.width(), rect.height() + nDy));
			}
		}
		caclScale();
		break;
	}
	case ScrollBar::ScrollBarMouseType_move:
	{
		doMouseMoveEvent(event);
		break;
	}
	default:
		break;
	}
	mPointPress = point;
	
}

bool ScrollBar::eventFilter(QObject *obj, QEvent *event)
{
	switch (event->type())
	{
	case QEvent::Enter:
	{
		if (obj == mUi->mSliderLeftArrow || obj == mUi->mSliderRightArrow)
		{
			if (mOrientation == Qt::Horizontal)
			{
				setCursor(Qt::SizeHorCursor);
			}
			else
			{
				setCursor(Qt::SizeVerCursor);
			}
			
		}
		else
		{
			setCursor(Qt::ArrowCursor);
		}
		break;
	}
	case QEvent::Leave:
	{
		setCursor(Qt::ArrowCursor);
		break;
	}
	case QEvent::MouseButtonPress:
	case QEvent::MouseButtonRelease:
	{
		QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
		if (mouseEvent)
		{
			mPointPress = mouseEvent->globalPos();
		}
		break;
	}
	case QEvent::MouseMove:
	{
		if (obj == mUi->mSliderToolButton)
		{
			QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
			if (mouseEvent)
			{
				doMouseMoveEvent(mouseEvent);
			}
		}
		break;
	}
	default:
		break;
	}
	return QFrame::eventFilter(obj, event);
}

void ScrollBar::resizeEvent(QResizeEvent *event)
{
	caclScale();
}

void ScrollBar::calcPosition()
{
	// 计算Value
	if (mMouseType != ScrollBarMouseType_normorl)
	{
		// 计算位置
		QRect framRect = mUi->frame->frameGeometry();
		QRect rect = mUi->mSliderFrame->frameGeometry();
		if (mOrientation == Qt::Horizontal)
		{
			if (framRect.width() == rect.width())
			{
				setValue(mMinimum);
			}
			else
			{
				if ((framRect.width() + framRect.x()) >= rect.width())
				{
					setValue(mMaximum);
				}
				else
				{
					double dValue = double(mMaximum - mMinimum) / double(rect.width() - framRect.width());
					setValue(mMinimum + dValue * framRect.x());
				}
			}
		}
		else
		{
			if (framRect.height() == rect.height())
			{
				setValue(mMinimum);
			}
			else
			{
				if ((framRect.height() + framRect.y()) >= rect.height())
				{
					setValue(mMaximum);
				}
				else
				{
					double dValue = double(mMaximum - mMinimum) / double(rect.height() - framRect.height());
					setValue(mMinimum + dValue * framRect.y());
				}
			}
		}
	}
	else  // 根据value计算滑块的位置
	{
		QRect framRect = mUi->frame->frameGeometry();
		QRect rect = mUi->mSliderFrame->frameGeometry();

		if (mOrientation == Qt::Horizontal)
		{
			if (mValue == mMinimum)
			{
				mUi->frame->setGeometry(0, 0, framRect.width(), rect.height());
			}
			else if (mValue == mMaximum)
			{
				mUi->frame->setGeometry(rect.width() - framRect.width(), 0, framRect.width(), rect.height());
			}
			else if (framRect.width() != rect.width())
			{
				double dValue = double(mMaximum - mMinimum) / double(rect.width() - framRect.width());	// 每一个像素代表的值
				int nPos = (mValue - mMinimum) / dValue;

				if (nPos >= 0 && (nPos + framRect.width()) <= rect.width())
				{
					mUi->frame->setGeometry(nPos, 0, framRect.width(), rect.height());
				}
			}
		}
		else
		{
			if (mValue == mMinimum)
			{
				mUi->frame->setGeometry(0, 0, framRect.width(), framRect.height());
			}
			else if (mValue == mMaximum)
			{
				mUi->frame->setGeometry(0, rect.height() - framRect.height(), rect.width(), framRect.height());
			}
			else if (framRect.height() != rect.height())
			{
				double dValue = double(mMaximum - mMinimum) / double(rect.height() - framRect.height());	// 每一个像素代表的值
				int nPos = (mValue - mMinimum) / dValue;

				if (nPos >= 0 && (nPos + framRect.height()) <= rect.height())
				{
					mUi->frame->setGeometry(0, nPos, rect.width(), framRect.height());
				}
			}
		}
	}
}

void ScrollBar::caclScale()
{
	QRect framRect = mUi->frame->frameGeometry();
	QRect rect = mUi->mSliderFrame->frameGeometry();

	if (mMouseType == ScrollBarMouseType_normorl)
	{
		if (mOrientation == Qt::Horizontal)
		{
			double nWidth = rect.width() * mScale;
			if (nWidth >= MIN_LENTH)
			{
				mUi->frame->setGeometry(framRect.x(), 0, nWidth, rect.height());
			}
		}
		else
		{
			double nHeight = rect.height() * mScale;
			if (nHeight >= MIN_LENTH)
			{
				mUi->frame->setGeometry(0, framRect.y(), rect.width(), nHeight);
			}
		}
	}
	else
	{
		if (mOrientation == Qt::Horizontal)
		{
			setScale((double)framRect.width() / (double)rect.width());
		}
		else
		{
			setScale((double)framRect.height() / (double)rect.height());
		}
		
	}
	calcPosition();
}

void ScrollBar::resetUi()
{
	{
		QLayout* oldLayout = this->layout();
		if (oldLayout)
		{
			delete oldLayout;
			oldLayout = nullptr;
		}

		oldLayout = mUi->frame->layout();
		if(oldLayout)
		{
			delete oldLayout;
		}
	}

	switch (mOrientation)
	{
	case Qt::Horizontal:
	{
		QHBoxLayout *horizontalLayout = new QHBoxLayout(this);
		horizontalLayout->setSpacing(0);
		horizontalLayout->setObjectName(QStringLiteral("horizontalLayout"));
		horizontalLayout->setContentsMargins(0, 1, 0, 1);

		horizontalLayout->addWidget(mUi->mLeftArrow);
		horizontalLayout->addWidget(mUi->mSliderFrame, 1);
		horizontalLayout->addWidget(mUi->mRightArrow);

		{
			QHBoxLayout* horizontalLayout_2 = new QHBoxLayout(mUi->frame);
			horizontalLayout_2->setSpacing(0);
			horizontalLayout_2->setObjectName(QStringLiteral("horizontalLayout_2"));
			horizontalLayout_2->setContentsMargins(0, 0, 0, 0);
			horizontalLayout_2->setMargin(0);

			horizontalLayout_2->addWidget(mUi->mSliderLeftArrow);
			horizontalLayout_2->addWidget(mUi->mSliderToolButton,1);
			horizontalLayout_2->addWidget(mUi->mSliderRightArrow);

			mUi->frame->setLayout(horizontalLayout_2);
			mUi->frame->setContentsMargins(0, 0, 0, 0);
		}

		{
			this->setMaximumHeight(20);
			this->setMaximumWidth(16777215);

			mUi->mSliderLeftArrow->setMinimumSize(QSize(10, 0));
			mUi->mSliderLeftArrow->setMaximumSize(QSize(10, 16777215));

			mUi->mSliderRightArrow->setMinimumSize(QSize(10, 0));
			mUi->mSliderRightArrow->setMaximumSize(QSize(10, 16777215));
		}
		break;
	}
	case Qt::Vertical:
	{
		QVBoxLayout *vLayout = new QVBoxLayout(this);
		vLayout->setSpacing(0);
		vLayout->setObjectName(QStringLiteral("vLayout"));
		vLayout->setContentsMargins(1, 0, 1, 0);

		vLayout->addWidget(mUi->mLeftArrow);
		vLayout->addWidget(mUi->mSliderFrame, 1);
		vLayout->addWidget(mUi->mRightArrow);

		{
			QVBoxLayout* vLayout_2 = new QVBoxLayout(mUi->frame);
			vLayout_2->setSpacing(0);
			vLayout_2->setObjectName(QStringLiteral("vLayout_2"));
			vLayout_2->setMargin(0);
			vLayout_2->setContentsMargins(0, 0, 0, 0);

			vLayout_2->addWidget(mUi->mSliderLeftArrow);
			vLayout_2->addWidget(mUi->mSliderToolButton, 1);
			vLayout_2->addWidget(mUi->mSliderRightArrow);

			mUi->frame->setLayout(vLayout_2);
			mUi->frame->setContentsMargins(0,0,0,0);
		}

		{
			this->setMaximumHeight(16777215);
			this->setMaximumWidth(20);

			mUi->mSliderLeftArrow->setMinimumSize(QSize(0, 0));
			mUi->mSliderLeftArrow->setMaximumSize(QSize(16777215, 10));

			mUi->mSliderToolButton->setMinimumSize(QSize(0, 0));
			mUi->mSliderToolButton->setMaximumSize(QSize(16777215, 16777215));

			mUi->mSliderRightArrow->setMinimumSize(QSize(0, 0));
			mUi->mSliderRightArrow->setMaximumSize(QSize(16777215, 10));
		}
		break;
	}
	default:
		break;
	}
	caclScale();
}

 

 

会头痛的可达鸭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DCMTK：缩放DICOM图像
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-15 504
DCMTK：缩放DICOM图像缩放DICOM图像 缩放DICOM图像 #include "dcmtk/config/osconfig.h" #include "dcmtk/dcmdata/dctk.h" #include "dcmtk/dcmdata/cmdlnarg.h" #include "dcmtk/dcmdata/dcuid.h" #include "dcmtk/ofstd/ofconapp.h" #include "dcmtk/ofstd/o
原生js实现拖拽移动与缩放效果
10-14
主要为大家详细介绍了原生js实现拖拽移动与缩放效果，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
FPGA图像无极缩放.Demo2
weixin_42087978的博客
09-07 291
整个的demo涉及到缩放仿真、mipi接收监控，bayer转rgb，DDR读写逻辑，流控，rgb转灰度，缩放算法、hdmi显示等知识，对缩放感兴趣的小伙伴这是一个完整的学习demo。
图片的无极缩放与固定大小
weixin_33801856的博客
06-21 664
今天遇到关于图片页图片大小控制的问题，在论坛里搜索了一下相关帖子，得到了解决的方法，在此整合一下相关的帖子，希望能对初学者起到帮助： 一、固定图片大小而不随鼠标滑动而改变图片大小代码！ 把以下代码加到<head></head>里面： <SCRIPT language="JavaScript" type="text/JavaScript"&g...
图片的无级缩放和无级截取(js+.net)
weixin_33737134的博客
11-28 181
无级截取前端代码用的这里的：http://www.cnblogs.com/cloudgamer/archive/2008/07/21/1247267.html感谢：cloudgamer！ 两个代码均在IE    FF下调试通过给几个图片看下   暂时没有演示地址，如果有好心人提供空间，那我就放上去  .net2.0就可以 无级缩放：按钮前面这个大图是可以通过鼠标拖动  改变大小的   ...
用Qt实现一个动态缩放的滚动条
eiilpux17的博客
03-29 3631
用Qt实现一个动态缩放的滚动条1. QScrollArea与QScrollBar的关系2. 理解QWidget::sizeHint()3. 布局变化通知部分代码: 用Qt实现一个动态缩放的滚动条 很早的时候做一个Qt项目，需求是实现一个滚动条动态变粗变细的效果。当时由于对Qt了解不多，就拒绝了。 最近忙完工作，突然想起这个需求，花点时间实现了一下，确实不难。以下是实际效果图（使用style sh...
无级缩放图片和文字大小
weixin_44546402的博客
06-10 424
无级缩放图片和文字大小 111111111
no_polar_zoom_图像缩放_无极放大_zoom_
10-01
"no_polar_zoom_图像缩放_无极放大_zoom_"这一标题揭示了我们今天要探讨的核心技术——无极放大的图像缩放方法，特别是通过双线性插值算法实现的这一过程。下面，我们将深入讲解这一技术及其应用。 首先，图像缩放...
76.（leaflet篇）leaflet地图无级别缩放（移动端）.zip
03-09
在移动设备上，Leaflet地图的无级别缩放功能对于提供流畅的用户体验至关重要。本文将深入探讨Leaflet地图在移动端实现无级别缩放的技术细节及其优势。 首先，Leaflet地图的核心特性之一就是其优秀的性能和对各种...
no_polar_zoom_图像缩放_无极放大_zoom_源码.zip
10-25
标题中的“no_polar_zoom_图像缩放_无极放大_zoom_源码”指的是一个关于图像处理技术的项目，特别是关于图像无极缩放（无极放大）的算法实现。这个项目的重点在于提供了一种能够平滑、连续且无限放大图像的算法，这...
图像实时缩放的FPGA实现，二次线性插值的Verilog实现。
02-27
在本文中，我们将深入探讨如何使用FPGA（Field-Programmable Gate Array）实现图像实时缩放，并专注于其中的关键技术——二次线性插值。这一技术在数字图像处理领域广泛应用，尤其是在需要高质量图像缩放的场合。...
JavaScript 图片切割效果
cloudgamer
07-21 370
序一（08/07/21） 很久之前就在一个网站的截取相片的功能中看到这个效果，也叫图片裁剪、图片剪切（设置一下也可以做出放大镜等类似的效果）。当时觉得很神奇，碍于水平有限，没做出来。前些日子突然想做一个透镜效果，就突然想到了这个效果，于是找出当年“珍藏”的代码决定一尝所愿。 序二（08/12/06） 自上一个版本的图片切割效果出来后，虽然也经常看到“框架开发这个如何如何容易”之类的评论，但也受到很...
QAbstractSlider、QSlider、QDial、QScrollBar
友善啊，朋友的博客
01-13 1127
QAbstractSlider 一、描述 此类为 QScrollBar、QSlider 和 QDial 等小部件的通用超类。 二、属性成员 1、invertedAppearance : bool 是否倒置外观。 如果为 false（默认值），则最小值和最大值将显示在继承小部件的经典位置。 如果为true，则最小值和最大值出现在它们相反的位置。 2、invertedControls : bool 是否反转其滚轮和按键事件。 如果为 false，则向上滚动鼠标滚轮或使用向上翻页等键
QSrcollBar样式表设置
weixin_43742643的博客
09-03 823
好看的QScrollBar样式表、介绍QScrollBar构造。含效果图。
MINIGUI源码分析(1) ------ 滚动条管理分析
s_k_yliu的专栏
08-29 1747
http://xuyacao.bokee.com/3753615.html http://blog.chinaunix.net/space.php?uid=9563036&do=blog&id=352405
Qt之QSlider相关
qq_38144985的博客
10-12 607
1、minimum、maximum：输入范围的最小值和最大值； 2、singleStep：单步长，拖动滑块时的最小变化数值； 3、pageStep：按PgUp或PgDn时变化的值； 4、value：组件的当前值，拖动时自动改变此值； 5、orientetion：Slider的方向，包括水平Vertical和垂直Horizontal； 6、setInvertedApperance：显示方向是否反向，默认（false）小到大为从左往右、从下往上，反向（true）为从右往左、从上往下； ...
FPGA HLS图像缩放，双线性插值任意比例缩放，提供4套工程源码和技术支持
qq_41667729的博客
09-26 2886
FPGA实现双线性插值任意比例的图像缩放，HLS封装IP，提供2套工程源码和技术支持
ScrollBar(滚动条)的实现尝试
梦起丶的博客
01-30 2523
【写在前面】 【正文开始】 首先，我们思考一下，滚动条负责什么工作： 在一个页面中，当某个元素不足以显示内容时，可以滚动的，用于显示剩下内容的条。 因此，对于一个滚动条，我认为它应该有这些属性： target: any：目标 ( 目标元素，用于滚动其内容 )。 targetWidth & targetHeight: number：目标元素宽高 ( 用于计算滑块宽度以及和后续滚动时的位置计算)。 pressed: bool：是否被按下 ( 用...
Qt基础学习（3）-----滑动条之QSlider
系统运维
10-23 440
//mydialog.h #ifndef MYDIALOG_H #define MYDIALOG_H #include &lt;QDialog&gt; class QLineEdit; class QSlider; class MyDialog : public QDialog { Q_OBJECT public: explicit MyDialog(QWidget *...
nero快乐无极精简版
最新发布
11-29
nero快乐无极精简版是一款专为快节奏生活而设计的软件，它集合了音乐、视频和社交功能，让用户可以在其中尽情享受娱乐乐趣。 首先，这款软件集成了丰富多样的音乐资源，用户可以随时随地通过nero快乐无极精简版欣赏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值