Qt界面边框跑马灯（附代码）

最新推荐文章于 2024-07-29 17:20:47 发布
最新推荐文章于 2024-07-29 17:20:47 发布
阅读量1.2k 收藏 5
点赞数 1
分类专栏： 以往文章 文章标签： qt跑马灯
本博客所有文章禁止转载及抄袭，侵权必究。
本文链接：https://blog.csdn.net/qq_39660930/article/details/113267715
版权

1、效果：
在这里插入图片描述
2、思路：
在需要设计边框的界面上下左右各放一个label，每个label对应一副图像，while循环一次则图像变一次，图像变了则重新把图像绘制到label中。
3、源码：
GuiLight.h

#pragma once

#include <QtCore/qthread.h>
#include <QtGui/QMouseEvent>
#include <QtWidgets/QPushButton>
#include <QtCore/QVariant>
#include <QtWidgets/QAction>
#include <QtWidgets/QApplication>
#include <QtWidgets/QButtonGroup>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QMainWindow>
#include <QtWidgets/QMenuBar>
#include <QtWidgets/QStatusBar>
#include <QtWidgets/QWidget>
#include <QtWidgets/QLabel>
#include <QtGui/QImage>
#include <QtWidgets/QtWidgets>
#include <QtWidgets/qfiledialog.h>
#include "ui_GuiLight.h"

typedef struct tagRGBImg
{
	unsigned char*       pucImg[3];
	unsigned int         sImgWidth;
	unsigned int         sImgHeight;
	unsigned int         sImgStride;
}RGB_IMG_S;

typedef struct tagTImgBox
{
	int				  lastState;
	unsigned int      imgNum;
	RGB_IMG_S         img[100];
}T_IMG_BOX_S;

typedef struct tagTTImgBox
{
	unsigned int      TBoxNum;
	T_IMG_BOX_S       TBox[100];
}TT_IMG_BOX_S;

class GuiLight;
class MyThread :public QThread
{
	Q_OBJECT
public:
	MyThread(QObject* parent, GuiLight* gui);
	~MyThread();

	void stop();
	void run();//线程入口函数（工作线程的主函数）

private:
	GuiLight* m_gui;
	RGB_IMG_S m_rgb[4];
	TT_IMG_BOX_S m_TTBox[4];
	QImage* m_showimage[4];
	int     m_stop;
};

class GuiLight : public QMainWindow
{
	Q_OBJECT

public:
	GuiLight(QWidget* parent = Q_NULLPTR);
	~GuiLight();
	
	int getimgNum() { return m_imgNum; };
	int getLabelSize() { return m_labelSize; };

protected:
	//关闭按钮触发
	void closeEvent(QCloseEvent* event);

signals:
    void sigtopLabelShowImg(QImage*);
	void sigbottomLabelShowImg(QImage*);
	void sigleftLabelShowImg(QImage*);
	void sigrightLabelShowImg(QImage*);
    
private slots:
	void topLabelShowImg(QImage* img);
	void bottomLabelShowImg(QImage* img);
	void leftLabelShowImg(QImage* img);
	void rightLabelShowImg(QImage* img);

private:
	int m_imgNum;
	int m_labelSize;
	QLabel* m_topLabel;
	QLabel* m_bottomLabel;
	QLabel* m_leftLabel;
	QLabel* m_rightLabel;
	MyThread* m_task;

	Ui::GuiLightClass ui;
};

GuiLight.cpp

#include "GuiLight.h"

static int g_labelSize = 4;//小图的宽度，g_labelSize：4字节对齐
static int g_imgNum = 8;//颜色条宽度，每个颜色条有几个小图
static int g_TboxNum = 4;//每个label颜色条个数
static int g_sleepms = 1000;//多久动一次

void setImg(RGB_IMG_S* img, int r, int g, int b)
{
	if (img == NULL)
		return;
	for (unsigned int i = 0; i < img->sImgHeight; i++)
	{
		for (unsigned int j = 0; j < img->sImgWidth; j++)
		{
			*(img->pucImg[0] + (i * img->sImgStride + j) * 3) = r;
			*(img->pucImg[1] + (i * img->sImgStride + j) * 3) = g;
			*(img->pucImg[2] + (i * img->sImgStride + j) * 3) = b;
		}
	}
}

MyThread::MyThread(QObject* parent, GuiLight* gui)
	:QThread(parent)
{
	m_gui = NULL;
	memset(&m_rgb[0], 0, sizeof(RGB_IMG_S)*4);
	memset(&m_TTBox[0], 0, sizeof(TT_IMG_BOX_S)*4);
	m_showimage[0] = NULL;
	m_showimage[1] = NULL;
	m_showimage[2] = NULL;
	m_showimage[3] = NULL;
	m_stop = 1;

	if (gui == NULL)
		return;

	m_gui = gui;

	int boxSize = gui->getLabelSize();
	int imgNum = m_gui->getimgNum();
	int lastStat = 0;

	m_rgb[0].sImgWidth = gui->width();
	m_rgb[0].sImgHeight = boxSize;
	m_rgb[0].sImgStride = gui->width();
	m_rgb[0].pucImg[0] = (unsigned char*)malloc(m_rgb[0].sImgStride * m_rgb[0].sImgHeight * 3);
	memset(m_rgb[0].pucImg[0], 0, m_rgb[0].sImgStride * m_rgb[0].sImgHeight * 3);
	m_rgb[0].pucImg[1] = m_rgb[0].pucImg[0] + 1;
	m_rgb[0].pucImg[2] = m_rgb[0].pucImg[1] + 1;

	m_TTBox[0].TBoxNum = m_rgb[0].sImgWidth / boxSize / imgNum;

    lastStat = 0;
	for (unsigned int i = 0; i < m_TTBox[0].TBoxNum; i++)
	{
		lastStat++;
		m_TTBox[0].TBox[i].imgNum = imgNum;
		for (unsigned int j = 0; j < m_TTBox[0].TBox[i].imgNum; j++)
		{
			if (lastStat % 2)
				m_TTBox[0].TBox[i].lastState = 1;
			else
				m_TTBox[0].TBox[i].lastState = 0;

			m_TTBox[0].TBox[i].img[j].pucImg[0] = m_rgb[0].pucImg[0] + (i * imgNum + j) * boxSize * 3;
			m_TTBox[0].TBox[i].img[j].pucImg[1] = m_TTBox[0].TBox[i].img[j].pucImg[0] + 1;
			m_TTBox[0].TBox[i].img[j].pucImg[2] = m_TTBox[0].TBox[i].img[j].pucImg[1] + 1;
			m_TTBox[0].TBox[i].img[j].sImgWidth = boxSize;
			m_TTBox[0].TBox[i].img[j].sImgHeight = boxSize;
			m_TTBox[0].TBox[i].img[j].sImgStride = m_rgb[0].sImgStride;

			if (m_TTBox[0].TBox[i].lastState)
			{
				setImg(&m_TTBox[0].TBox[i].img[j], 255, 0, 0);
			}
		}
	}

	m_showimage[0] = new QImage((uchar*)m_rgb[0].pucImg[0], gui->width(), boxSize, QImage::Format_RGB888);
	emit m_gui->sigtopLabelShowImg(m_showimage[0]);

	m_rgb[1].sImgWidth = gui->width();
	m_rgb[1].sImgHeight = boxSize;
	m_rgb[1].sImgStride = gui->width();
	m_rgb[1].pucImg[0] = (unsigned char*)malloc(m_rgb[1].sImgStride * m_rgb[1].sImgHeight * 3);
	memset(m_rgb[1].pucImg[0], 0, m_rgb[1].sImgStride * m_rgb[1].sImgHeight * 3);
	m_rgb[1].pucImg[1] = m_rgb[1].pucImg[0] + 1;
	m_rgb[1].pucImg[2] = m_rgb[1].pucImg[1] + 1;

	m_TTBox[1].TBoxNum = m_rgb[1].sImgWidth / boxSize / imgNum;

	lastStat = 1;
	for (unsigned int i = 0; i < m_TTBox[1].TBoxNum; i++)
	{
		lastStat++;
		m_TTBox[1].TBox[i].imgNum = imgNum;
		for (unsigned int j = 0; j < m_TTBox[1].TBox[i].imgNum; j++)
		{
			if (lastStat % 2)
				m_TTBox[1].TBox[i].lastState = 1;
			else
				m_TTBox[1].TBox[i].lastState = 0;

			m_TTBox[1].TBox[i].img[j].pucImg[0] = m_rgb[1].pucImg[0] + (i * imgNum + j) * boxSize * 3;
			m_TTBox[1].TBox[i].img[j].pucImg[1] = m_TTBox[1].TBox[i].img[j].pucImg[0] + 1;
			m_TTBox[1].TBox[i].img[j].pucImg[2] = m_TTBox[1].TBox[i].img[j].pucImg[1] + 1;
			m_TTBox[1].TBox[i].img[j].sImgWidth = boxSize;
			m_TTBox[1].TBox[i].img[j].sImgHeight = boxSize;
			m_TTBox[1].TBox[i].img[j].sImgStride = m_rgb[1].sImgStride;

			if (m_TTBox[1].TBox[i].lastState)
			{
				setImg(&m_TTBox[1].TBox[i].img[j], 255, 0, 0);
			}
		}
	}

	m_showimage[1] = new QImage((uchar*)m_rgb[1].pucImg[0], gui->width(), boxSize, QImage::Format_RGB888);
	emit m_gui->sigbottomLabelShowImg(m_showimage[1]);

	m_rgb[2].sImgWidth = boxSize;
	m_rgb[2].sImgHeight = imgNum * boxSize * g_TboxNum;
	m_rgb[2].sImgStride = boxSize;
	m_rgb[2].pucImg[0] = (unsigned char*)malloc(m_rgb[2].sImgStride * m_rgb[2].sImgHeight * 3);
	memset(m_rgb[2].pucImg[0], 0, m_rgb[2].sImgStride * m_rgb[2].sImgHeight * 3);
	m_rgb[2].pucImg[1] = m_rgb[2].pucImg[0] + 1;
	m_rgb[2].pucImg[2] = m_rgb[2].pucImg[1] + 1;

	m_TTBox[2].TBoxNum = m_rgb[2].sImgHeight / boxSize / imgNum;

	lastStat = 1;
	for (unsigned int i = 0; i < m_TTBox[2].TBoxNum; i++)
	{
		lastStat++;
		m_TTBox[2].TBox[i].imgNum = imgNum;
		for (unsigned int j = 0; j < m_TTBox[2].TBox[i].imgNum; j++)
		{
			if (lastStat % 2)
				m_TTBox[2].TBox[i].lastState = 1;
			else
				m_TTBox[2].TBox[i].lastState = 0;

			m_TTBox[2].TBox[i].img[j].pucImg[0] = m_rgb[2].pucImg[0] + (i * imgNum + j) * boxSize * boxSize * 3;
			m_TTBox[2].TBox[i].img[j].pucImg[1] = m_TTBox[2].TBox[i].img[j].pucImg[0] + 1;
			m_TTBox[2].TBox[i].img[j].pucImg[2] = m_TTBox[2].TBox[i].img[j].pucImg[1] + 1;
			m_TTBox[2].TBox[i].img[j].sImgWidth = boxSize;
			m_TTBox[2].TBox[i].img[j].sImgHeight = boxSize;
			m_TTBox[2].TBox[i].img[j].sImgStride = m_rgb[2].sImgStride;

			if (m_TTBox[2].TBox[i].lastState)
			{
				setImg(&m_TTBox[2].TBox[i].img[j], 255, 0, 0);
			}
		}
	}

	m_showimage[2] = new QImage((uchar*)m_rgb[2].pucImg[0], boxSize, imgNum * boxSize * g_TboxNum, QImage::Format_RGB888);
	emit m_gui->sigleftLabelShowImg(m_showimage[2]);

	m_rgb[3].sImgWidth = boxSize;
	m_rgb[3].sImgHeight = imgNum * boxSize * g_TboxNum;
	m_rgb[3].sImgStride = boxSize;
	m_rgb[3].pucImg[0] = (unsigned char*)malloc(m_rgb[3].sImgStride * m_rgb[3].sImgHeight * 3);
	memset(m_rgb[3].pucImg[0], 0, m_rgb[3].sImgStride * m_rgb[3].sImgHeight * 3);
	m_rgb[3].pucImg[1] = m_rgb[3].pucImg[0] + 1;
	m_rgb[3].pucImg[2] = m_rgb[3].pucImg[1] + 1;

	m_TTBox[3].TBoxNum = m_rgb[3].sImgHeight / boxSize / imgNum;

	lastStat = 0;
	for (unsigned int i = 0; i < m_TTBox[3].TBoxNum; i++)
	{
		lastStat++;
		m_TTBox[3].TBox[i].imgNum = imgNum;
		for (unsigned int j = 0; j < m_TTBox[3].TBox[i].imgNum; j++)
		{
			if (lastStat % 2)
				m_TTBox[3].TBox[i].lastState = 1;
			else
				m_TTBox[3].TBox[i].lastState = 0;

			m_TTBox[3].TBox[i].img[j].pucImg[0] = m_rgb[3].pucImg[0] + (i * imgNum + j) * boxSize * boxSize * 3;
			m_TTBox[3].TBox[i].img[j].pucImg[1] = m_TTBox[3].TBox[i].img[j].pucImg[0] + 1;
			m_TTBox[3].TBox[i].img[j].pucImg[2] = m_TTBox[3].TBox[i].img[j].pucImg[1] + 1;
			m_TTBox[3].TBox[i].img[j].sImgWidth = boxSize;
			m_TTBox[3].TBox[i].img[j].sImgHeight = boxSize;
			m_TTBox[3].TBox[i].img[j].sImgStride = m_rgb[3].sImgStride;

			if (m_TTBox[3].TBox[i].lastState)
			{
				setImg(&m_TTBox[3].TBox[i].img[j], 255, 0, 0);
			}
		}
	}

	m_showimage[3] = new QImage((uchar*)m_rgb[3].pucImg[0], boxSize, imgNum * boxSize * g_TboxNum, QImage::Format_RGB888);
	emit m_gui->sigrightLabelShowImg(m_showimage[3]);

    m_stop = 0;
	start();
}

MyThread::~MyThread()
{
    delete m_showimage[0];
    delete m_showimage[1];
    delete m_showimage[2];
    delete m_showimage[3];
}

void MyThread::stop()
{
	m_stop = 1;
}

void MyThread::run()
{
	unsigned int cnt = 0;
    int ix = g_imgNum - 1;
    srand((unsigned)time(NULL));
    int tr = rand() % 255;
    int tg = rand() % 255;
    int tb = rand() % 255;
	while (1)
	{
        if(cnt%(g_imgNum*g_TboxNum*4) == 0)
        {
            tr = rand() % 255;
            tg = rand() % 255;
            tb = rand() % 255;
        }
		for (unsigned int i = 0; i < m_TTBox[0].TBoxNum; i++)
		{
			if ((cnt / g_imgNum != 0) && (cnt % g_imgNum == 0))
				m_TTBox[0].TBox[i].lastState = !m_TTBox[0].TBox[i].lastState;
			if (m_TTBox[0].TBox[i].lastState)
			{
				setImg(&m_TTBox[0].TBox[i].img[ix - cnt % g_imgNum], 0, 0, 0);
			}
			else
			{
				setImg(&m_TTBox[0].TBox[i].img[ix - cnt % g_imgNum], tr, tg, tb);
			}
		}
		for (unsigned int i = 0; i < m_TTBox[1].TBoxNum; i++)
		{
			if ((cnt / g_imgNum != 0) && (cnt % g_imgNum == 0))
				m_TTBox[1].TBox[i].lastState = !m_TTBox[1].TBox[i].lastState;
			if (m_TTBox[1].TBox[i].lastState)
			{
				setImg(&m_TTBox[1].TBox[i].img[cnt % g_imgNum], 0, 0, 0);
			}
			else
			{
				setImg(&m_TTBox[1].TBox[i].img[cnt % g_imgNum], tr, tg, tb);
			}
		}
		for (unsigned int i = 0; i < m_TTBox[2].TBoxNum; i++)
		{
			if ((cnt / g_imgNum != 0) && (cnt % g_imgNum == 0))
				m_TTBox[2].TBox[i].lastState = !m_TTBox[2].TBox[i].lastState;
			if (m_TTBox[2].TBox[i].lastState)
			{
				setImg(&m_TTBox[2].TBox[i].img[cnt % g_imgNum], 0, 0, 0);
			}
			else
			{
				setImg(&m_TTBox[2].TBox[i].img[cnt % g_imgNum], tr, tg, tb);
			}
		}
		for (unsigned int i = 0; i < m_TTBox[3].TBoxNum; i++)
		{
			if ((cnt / g_imgNum != 0) && (cnt % g_imgNum == 0))
				m_TTBox[3].TBox[i].lastState = !m_TTBox[3].TBox[i].lastState;
			if (m_TTBox[3].TBox[i].lastState)
			{
				setImg(&m_TTBox[3].TBox[i].img[ix - cnt % g_imgNum], 0, 0, 0);
			}
			else
			{
				setImg(&m_TTBox[3].TBox[i].img[ix - cnt % g_imgNum], tr, tg, tb);
			}
		}
		QThread::msleep(g_sleepms);
        emit m_gui->sigtopLabelShowImg(m_showimage[0]);
		emit m_gui->sigbottomLabelShowImg(m_showimage[1]);
		emit m_gui->sigleftLabelShowImg(m_showimage[2]);
		emit m_gui->sigrightLabelShowImg(m_showimage[3]);
		cnt++;
		if (m_stop == 1)
		{
			break;
		}
	}
}

GuiLight::GuiLight(QWidget* parent)
	: QMainWindow(parent)
{
	ui.setupUi(this);

	//去掉最大化、最小化按钮，保留关闭按钮
    this->setWindowFlags(Qt::WindowCloseButtonHint);

	m_imgNum = g_imgNum;
	m_labelSize = g_labelSize;
	int TboxNum = g_TboxNum;
	this->resize(m_imgNum * m_labelSize * TboxNum, m_imgNum * m_labelSize * TboxNum + 2 * m_labelSize);
	
	//窗体位置
	this->move(((QApplication::desktop()->width() - this->width()) / 2), (QApplication::desktop()->height() - this->height()) / 2);

	m_topLabel = new QLabel(ui.centralWidget);
	m_topLabel->setObjectName(QString::fromUtf8("label"));
	m_topLabel->setGeometry(QRect(0, 0, this->width(), m_labelSize));

    m_bottomLabel = new QLabel(ui.centralWidget);
	m_bottomLabel->setObjectName(QString::fromUtf8("label"));
	m_bottomLabel->setGeometry(QRect(0, m_imgNum * m_labelSize * TboxNum + m_labelSize, this->width(), m_labelSize));

    m_leftLabel = new QLabel(ui.centralWidget);
	m_leftLabel->setObjectName(QString::fromUtf8("label"));
	m_leftLabel->setGeometry(QRect(0, m_labelSize, m_labelSize, m_imgNum * m_labelSize * TboxNum));

    m_rightLabel = new QLabel(ui.centralWidget);
	m_rightLabel->setObjectName(QString::fromUtf8("label"));
	m_rightLabel->setGeometry(QRect(this->width() - m_labelSize, m_labelSize, m_labelSize, m_imgNum * m_labelSize * TboxNum));

    connect(this, SIGNAL(sigtopLabelShowImg(QImage*)), this, SLOT(topLabelShowImg(QImage*)));
    connect(this, SIGNAL(sigbottomLabelShowImg(QImage*)), this, SLOT(bottomLabelShowImg(QImage*)));
    connect(this, SIGNAL(sigleftLabelShowImg(QImage*)), this, SLOT(leftLabelShowImg(QImage*)));
    connect(this, SIGNAL(sigrightLabelShowImg(QImage*)), this, SLOT(rightLabelShowImg(QImage*)));

	m_task = new MyThread(NULL, this);
}

GuiLight::~GuiLight()
{
	if (m_task != NULL)
	{
		delete m_task;
	}
	if(m_topLabel != NULL)
		delete m_topLabel;
	if(m_bottomLabel != NULL)
		delete m_bottomLabel;
	if(m_leftLabel != NULL)
		delete m_leftLabel;
	if(m_rightLabel != NULL)
		delete m_rightLabel;
}

void GuiLight::topLabelShowImg(QImage* img)
{ 
	if(m_topLabel != NULL)
		m_topLabel->setPixmap(QPixmap::fromImage(*img));
}

void GuiLight::bottomLabelShowImg(QImage* img)
{ 
	if(m_bottomLabel != NULL)
		m_bottomLabel->setPixmap(QPixmap::fromImage(*img));
}

void GuiLight::leftLabelShowImg(QImage* img)
{ 
	if(m_leftLabel != NULL)
		m_leftLabel->setPixmap(QPixmap::fromImage(*img));
}

void GuiLight::rightLabelShowImg(QImage* img)
{ 
	if(m_rightLabel != NULL)
		m_rightLabel->setPixmap(QPixmap::fromImage(*img));
}

void GuiLight::closeEvent(QCloseEvent* event)
{
	if (1)
	{
		m_task->stop();
		QThread::msleep(g_sleepms*1.2);

		event->accept();
	}
	else
	{
		event->ignore();
	}
}

GuiLight.ui

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>GuiLightClass</class>
 <widget class="QMainWindow" name="GuiLightClass">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>500</width>
    <height>400</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>GuiLight</string>
  </property>
  <widget class="QWidget" name="centralWidget"/>
 </widget>
 <layoutdefault spacing="6" margin="11"/>
 <resources/>
 <connections/>
</ui>

4、直接下载exe看效果：
链接：https://pan.baidu.com/s/1VzYYUNQhpAFSR7u0UN7gzA
提取码：uc38
5、编译代码：
参考：vs2019开发qt项目环境搭建

程序员阿周
关注
专栏目录
Qt 实现的跑马灯效果
06-18
基于Qt的跑马灯效果，支持配置文件读取。tcp 设置字体、颜色，大小，内容功能
Qt 实现跑马灯效果
qthello
06-18 3970
参考某大神博客，针对自己的需求，实现了跑马灯效果。 效果如下： 思路： 1，启动定时器 进行刷新 my_timer_id_ = startTimer(10, Qt::PreciseTimer); 2，每触发一次定时器，偏移量增加固定大小。void Ticker::leftScrollTimerEvent(QTimerEvent *ev) offset_ ++； ...
Qt编写自定义控件：跑马灯文本控件
最新发布
友善啊，朋友的博客
07-29 256
【代码】Qt编写自定义控件：跑马灯文本控件。
qt QPainter 绘制跑马灯
08-13
使用qtcreator 绘制类似跑马灯的效果 换行圈，可以设置每个小车的颜色
QT 实现跑马灯
u012342051的专栏
05-06 2610
背景 应项目需求，需要实现一个体现系统运行状态的类似跑马灯效果一样的控件，跑马灯还是本科电子工艺实习期间焊接电路板的时候接触过，初听要用qt实现这个效果，还觉得挺有意思的。开始是调研，理解了一篇博客分享的点阵LED，开始着手实现，最终实现了一个动态的显示状态的小控件。现分享一个实现该控件的一个简要思路。单个LED的设计完全是借鉴过来的，实现跑马灯的效果，主要的工作体现在灯的放置上，也算是存在一个小小的算法设计，虽然这是一个小功能，但是实现之后还是挺有成就感的，特分享出来，供他人做自定义控件...
QT QWidget - 跑马灯
听我一言的博客
12-17 276
关于前面画了个圆，怎么样也得跑个灯, 只是基于布局创建LED Widget而非 QTableView/QTableWidget;
CSS 之 跑马灯边框
weixin_45092437的博客
01-15 2123
尝试实现一下跑马灯样式的边框，虽然这种样式并不常见（基本没卵用），其使用场景我至今没想到，但是它足够花里胡哨，玩的就是花活。经过一番实践，我实现了两种形态的跑马灯样式边框，其效果如下图所示。其主要使用的CSS属性有：`overflow`、`position`、`transform`、` animation`、`@keyframes`以及`::after`和`::before`等等。
QT- label实现滚动字幕 (跑马灯)效果 -像素级
corefunction的博客
07-09 7375
网上资料比较多，但是csdn没有，而且也缺乏比较清晰的教程，于是打算写下这篇博客，和大家一起学习QT
QT 实现LED跑马灯效果
12-17
本篇文章将深入探讨如何在QT中实现LED跑马灯效果，这是一种常见的LED显示动态效果，通常在电子显示屏、信息指示器等设备上看到。我们将主要关注如何使用QWidget类来创建LED效果的圆，并实现跑马灯效果。 首先，理解...
qml实现的背景透明的跑马灯
08-07
在计算机编程领域，特别是在图形用户界面（GUI）设计中，跑马灯效果是一种常见的动态展示信息的方式。在Qt框架下，使用QML（Qt Meta Language）可以轻松实现这一效果。QML是Qt提供的一种声明式语言，用于构建富图形...
Qt 之 自定义窗口标题栏
热门推荐
前行之路还需前行
12-06 7万+
首先自定义标题栏解决了我们程序在不同平台乃至同一平台不同的版本中样式不同的问题，使用自定义标题栏，能够保证外观的一致性，这也是为什么像QQ、有道词典、360等软件都没有使用系统标题栏，都是自定义标题栏了。正是因为自定义标题栏，我们可以自定义不再受约束，想怎么设计就怎么设计。自定义标题栏可以使用自己设计的图标，当然比系统的图标要美观了，颜值当然更高了。下面就讲一讲如何用Qt实现自定义窗口标题栏。
Qt跑马灯源程序
03-25
Qt跑马灯源程序
QT滚动文本demo
09-30
QT滚动文本Demo是一款基于Qt库开发的应用程序，它展示了如何在界面上实现文本的无缝滚动效果，类似于电视屏幕下方常见的跑马灯字幕。Qt是一个跨平台的C++图形用户界面应用程序开发框架，广泛用于桌面、移动和嵌入式...
Qt实现歌词播放流光跑马灯特效
qq_36651243的博客
03-25 1299
Qt实现歌词播放流光跑马灯特效
Qt工作笔记-跑马灯效果
IT1995的博客
07-25 5586
逻辑： 使用静态变量确定位置； 利用QString中mid这函数的性质： 程序运行截图如下：   代码如下： widget.h #ifndef WIDGET_H #define WIDGET_H #include &lt;QWidget&gt; class QTimer; namespace Ui { class Widget; } class Widget : publ...
Qt 中文跑马灯
ACodeLife的博客
11-07 1706
直接上代码： textticker.h #ifndef TEXTTICKER_H #define TEXTTICKER_H #include &lt;QWidget&gt; #include &lt;QLabel&gt; #include &lt;QString&gt; #include &lt;QTimer&gt; #include &lt;QPen&gt; #include &lt;QFon...
css实现边框跑马灯效果（彩虹，渐变，叠加）
天心天地生的博客
12-18 2134
css实现边框跑马灯效果（彩虹，渐变，叠加）
css实现边框跑马灯效果
TarkuNi的博客
07-03 3753
先上效果图 1.先整个div边框 <div class="box horse_run">小马跑起来~</div> 2.书写css样式 .box { height: 300px; width: 400px; box-shadow: 0 0 3px orange; text-align: center; line-height: 280px; } .horse_run { background-image: linear-gradient(90de
qml 发光_Qt编写自定义控件37-发光按钮（会呼吸的痛）
weixin_39864101的博客
12-07 738
一、前言这个控件是好早以前写的，已经授权过好几个人开源过此控件代码，比如红磨坊小胖，此控件并不是来源于真实需求，而仅仅是突发奇想，类似于星星的闪烁，越到边缘越来越淡，定时器动态改变边缘发光的亮度，产生呼吸的效果，别名叫会呼吸的痛，看到这个歌名，又让我想起了前女友，哎！久久不能忘怀！大致的原理就是使用了锥形渐变QRadialGradient，然后定时器改变该渐变画刷的颜色的透明度值，产生呼吸效果。...
如何美化用代码美化qt界面边框
07-05
以上就是使用代码美化Qt界面边框的方法。通过定义样式表或重写绘图方法，可以实现个性化的边框样式，提升界面的美观性和用户体验。 ### 回答2： 在Qt中，我们可以使用代码来美化界面边框。下面是一些方法和技巧： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员阿周

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值