用QT实现Windows定时关机功能

最新推荐文章于 2023-04-22 14:51:04 发布

飘云

最新推荐文章于 2023-04-22 14:51:04 发布

阅读量4.7k

点赞数 4

分类专栏： VS2008+QT4 文章标签： qt windows signal token dialog null

本文链接：https://blog.csdn.net/piaoyunqing/article/details/5740612

版权

VS2008+QT4 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

目前网上定时关机的小工具很多，但是按照个人使用经验来说，网上很多小工具都是有毒或者带有恶意代码或者流氓代码的。因为平时经常下载东西，需要使用定时关机，所以干脆自己写了个定时关机的软件，简单易用。

截图基于WIN7系统，顺便说一句，WIN7下的小软件很漂亮。

首先，软件需要最小化托盘运行，并且显示倒计时悬浮窗。这里设置为在右下角显示。代码如下：

SusWidget.h

#ifndef SUSWIDGET_H
#define SUSWIDGET_H

#include <QtGui/QWidget>
#include <QDateTime>
#include <QtGui/QLineEdit>
#include <QtCore/QTextCodec>
#include <QtGui/QApplication>
#include <QDesktopWidget>

#ifndef    REMAIN_TIME
#define   REMAIN_TIME            0
#endif

#ifndef    TO_SHUTDOWN
#define   TO_SHUTDOWN         1
#endif

#ifndef    SHUTDOWN_ERROR
#define   SHUTDOWN_ERROR  2
#endif

class SusWidget : public QWidget
{
	Q_OBJECT

public:
	SusWidget(QWidget *parent = 0, Qt::WFlags flags = 0);
	~SusWidget();

private:
	QLineEdit  *timeEdit;

public slots:
	void SetRemainTime(const QTime &time, int type);
};

#endif // SUSWIDGET_H

SusWidget.cpp

#include "suswidget.h"

SusWidget::SusWidget(QWidget *parent, Qt::WFlags flags)
: QWidget(parent, flags)
{
	setFixedSize(170, 20);
	QTextCodec::setCodecForTr(QTextCodec::codecForName("gb18030"));
	setWindowFlags(Qt::CustomizeWindowHint | Qt::WindowStaysOnTopHint | Qt::Tool);
	QRect   screenSize;
	screenSize = QApplication::desktop()->rect();
	setGeometry(screenSize.width()-180, screenSize.height()-70, 170, 20);
	timeEdit = new QLineEdit(this);
	timeEdit->setGeometry(rect());
	QPalette palette;
	QBrush brush(QColor(255, 255, 0, 255));
	brush.setStyle(Qt::SolidPattern);
	QBrush brush1(QColor(85, 0, 0, 255));
	brush1.setStyle(Qt::SolidPattern);
	palette.setBrush(QPalette::Active, QPalette::Text, brush);
	palette.setBrush(QPalette::Active, QPalette::Base, brush1);
	palette.setBrush(QPalette::Inactive, QPalette::Text, brush);
	palette.setBrush(QPalette::Inactive, QPalette::Base, brush1);
	palette.setBrush(QPalette::Disabled, QPalette::Text, brush);
	palette.setBrush(QPalette::Disabled, QPalette::Base, brush1);
	timeEdit->setPalette(palette);
	QFont font;
	font.setFamily(QString::fromUtf8("\351\273\221\344\275\223"));
	font.setBold(true);
	font.setWeight(75);
	timeEdit->setFont(font);
	timeEdit->setAlignment(Qt::AlignCenter);
	timeEdit->setText(tr("正在统计关机剩余时间..."));
	timeEdit->setReadOnly(true);
}

SusWidget::~SusWidget()
{

}


void SusWidget::SetRemainTime(const QTime &time, int type)
{
	if ( type == REMAIN_TIME )
	{
		timeEdit->setText( tr("离关机还有：") + time.toString(tr("hh时mm分ss秒")) );
	}
	if ( type == TO_SHUTDOWN )
	{
		timeEdit->setText( tr("正在关机...") );
	}
	if ( type == SHUTDOWN_ERROR )
	{
		timeEdit->setText( tr("关机失败...") );
	}
}

定时关机需要一个后台线程来实现计时功能：

TimeThread.h

#ifndef TIMETHREAD_H
#define TIMETHREAD_H

#include <QDateTime>
#include <QThread>
#include <Windows.h>

#define   REMAIN_TIME            0
#define   TO_SHUTDOWN         1
#define   SHUTDOWN_ERROR  2

class TimeThread : public QThread
{
	Q_OBJECT

public:
	QTime m_time;
	bool m_start;

public:
	TimeThread(QObject *parent = 0);
	void SetCountTime(QTime time, bool start);
	bool MySystemShutdown();

signals:
	void RemainTimeChanged(const QTime &time, int type);

protected:
	void run();
};

#endif

TimeThread.cpp

#include "TimeThread.h"

TimeThread::TimeThread(QObject *parent) : QThread(parent)
{
	m_time = QTime(1, 0, 0);
	m_start = false;
}

void TimeThread::SetCountTime(QTime time, bool start)
{
	m_time = time;
	m_start = start;
}

void TimeThread::run()
{
	QTime  oldTime, newTime;
	oldTime.setHMS(QTime::currentTime().hour(), QTime::currentTime().minute(), QTime::currentTime().second(), 0);
	while(m_start)
	{
		msleep(250);
		newTime.setHMS(QTime::currentTime().hour(), QTime::currentTime().minute(), QTime::currentTime().second(), 0);
		if ( oldTime != newTime )
		{
			oldTime = newTime;
			m_time = m_time.addSecs(-1);
		}
		emit  RemainTimeChanged(m_time, REMAIN_TIME);
		if ( m_time == QTime(0, 0, 0) )
		{
			emit  RemainTimeChanged(m_time, TO_SHUTDOWN);
			if ( !MySystemShutdown() )
			{
				emit  RemainTimeChanged(m_time, SHUTDOWN_ERROR);
			}
			break;
		}
	}
}

bool TimeThread::MySystemShutdown()
{
	HANDLE hToken; 
	TOKEN_PRIVILEGES tkp; 

	//获取进程标志
	if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) 
		return false; 

	//获取关机特权的LUID
	LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, 	&tkp.Privileges[0].Luid); 
	tkp.PrivilegeCount = 1; 
	tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; 

	//获取这个进程的关机特权
	AdjustTokenPrivileges(hToken, false, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0); 
	if (GetLastError() != ERROR_SUCCESS) return false; 

	// 强制关闭计算机 
	if (  !ExitWindowsEx(EWX_SHUTDOWN | EWX_FORCE, 
    	 SHTDN_REASON_MAJOR_OPERATINGSYSTEM | SHTDN_REASON_MINOR_UPGRADE |	SHTDN_REASON_FLAG_PLANNED)) 
		 return false; 
	return true;
}

一般的定时关机软件还需要显示当前系统时间：

SystemTimeThread.h

#ifndef SYSTEMTIMETHREAD_H
#define SYSTEMTIMETHREAD_H

#include <QDateTime>
#include <QThread>

class SystemTimeThread : public QThread
{
	Q_OBJECT

public:
	QTime m_time;

public:
	SystemTimeThread(QObject *parent = 0);

signals:
	void CurrentTimeChanged(const QTime &time);

protected:
	void run();
};

#endif

SystemTimeThread.cpp

#include "SystemTimeThread.h"

SystemTimeThread::SystemTimeThread(QObject *parent) :  QThread(parent)
{
	m_time = m_time.currentTime();
}

void SystemTimeThread::run()
{
	while(1)
	{
		msleep(500);
		m_time = m_time.currentTime();
		emit CurrentTimeChanged(m_time);
	}
}

好了，上面的主要部分都已经编写完成，接下来就是主要界面了。定时关机只是一个小软件，所以尽量的简单易用，不要加入过多不必要的功能。代码如下：

shutdown.h

#ifndef SHUTDOWN_H
#define SHUTDOWN_H

#include <QtCore/QVariant>
#include <QtGui/QAction>
#include <QtGui/QApplication>
#include <QtGui/QButtonGroup>
#include <QtGui/QDialog>
#include <QtGui/QGroupBox>
#include <QtGui/QLabel>
#include <QtGui/QLineEdit>
#include <QtGui/QPushButton>
#include <QtGui/QRadioButton>
#include <QtGui/QTimeEdit>
#include <QRegExpValidator>
#include <QString>
#include <QDateTime>
#include <QSystemTrayIcon>

#include "TimeThread.h"
#include "SusWidget.h"
#include "SystemTimeThread.h"

class ShutDown : public QDialog
{
	Q_OBJECT

public:
	ShutDown(QWidget *parent = 0, Qt::WFlags flags = 0);
	~ShutDown();

private:
	QGroupBox *chooseGroup;
	QRadioButton *countDownRadio;
	QRadioButton *timerRadio;
	QTimeEdit *countEdit;
	QTimeEdit *timeEdit;
	QLabel *remainText;
	QLineEdit *remainTimeLine;
	QLineEdit *systemTimeLine;
	QLabel *currentTimeText;
	QPushButton *startButton;
	QPushButton *exitButton;

	QAction *susAction;
	QAction *restoreAction;
	QAction *quitAction;
	QSystemTrayIcon *trayIcon;
	QMenu *trayIconMenu;

	QTime    m_time;
	bool       m_start;
	bool       m_countDown;
	bool       m_mini;
	bool       m_suspend;
	TimeThread  m_timeThread;
	SystemTimeThread  m_systemTimeThread;
	SusWidget *swidget;

//protected:
//	void closeEvent(QCloseEvent *event);

public:
	void createActions();
	void createTrayIcon();
	void SetSusTime(const QTime &time, int type);

signals:
	void RemainTimeChanged(const QTime &time, int type);

private slots:
	void  CountTimeChanged(const QTime &time);
	void  ClickedCountDownRadio();
	void  doTimeChanged(const QTime &time);
	void  ClickedTimerRadio();
	void  ClickedStartButton();
	void  SetRemainTime(const QTime &time, int type);
	void  SetCurrentTime(const QTime &time);
	void  ShowDialog();
	void  ClikedTrayIcon(QSystemTrayIcon::ActivationReason reason);
	void  ShowSusWidget();
	void  HideOrExit();
};

#endif // SHUTDOWN_H

shutdown.cpp

#include "shutdown.h"
#include <QtGui>

ShutDown::ShutDown(QWidget *parent, Qt::WFlags flags)
: QDialog(parent, flags)
{
	if (objectName().isEmpty())  setObjectName(QString::fromUtf8("ShutDown"));
	setFixedSize(264, 261);

	setWindowFlags(Qt::WindowMinimizeButtonHint);

	QIcon icon;
	icon.addPixmap(QPixmap(QString::fromUtf8("Resources/shutdown.png")), QIcon::Normal, QIcon::Off);
	setWindowIcon(icon);

	createActions();
	createTrayIcon();

	chooseGroup = new QGroupBox(this);
	chooseGroup->setGeometry(QRect(20, 10, 221, 191));
	chooseGroup->setAlignment(Qt::AlignCenter);
	countDownRadio = new QRadioButton(chooseGroup);
	countDownRadio->setGeometry(QRect(20, 30, 101, 21));
	timerRadio = new QRadioButton(chooseGroup);
	timerRadio->setGeometry(QRect(20, 70, 101, 21));
	countEdit = new QTimeEdit(chooseGroup);
	countEdit->setGeometry(QRect(120, 30, 81, 22));
	countEdit->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);
	countEdit->setTime(QTime(1, 0, 0));
	timeEdit = new QTimeEdit(chooseGroup);
	timeEdit->setGeometry(QRect(120, 70, 81, 22));
	timeEdit->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);
	remainText = new QLabel(chooseGroup);
	remainText->setGeometry(QRect(20, 110, 81, 21));
	remainTimeLine = new QLineEdit(chooseGroup);
	remainTimeLine->setGeometry(QRect(110, 110, 91, 20));
	remainTimeLine->setAlignment(Qt::AlignCenter);
	remainTimeLine->setReadOnly(true);
	systemTimeLine = new QLineEdit(chooseGroup);
	systemTimeLine->setGeometry(QRect(110, 150, 91, 20));
	systemTimeLine->setAlignment(Qt::AlignCenter);
	systemTimeLine->setReadOnly(true);
	currentTimeText = new QLabel(chooseGroup);
	currentTimeText->setGeometry(QRect(20, 150, 81, 21));
	startButton = new QPushButton(this);
	startButton->setGeometry(QRect(30, 220, 101, 23));
	exitButton = new QPushButton(this);
	exitButton->setGeometry(QRect(140, 220, 91, 23));

	countDownRadio->setChecked(true);
	timerRadio->setChecked(false);
	m_time = countEdit->time();
	remainTimeLine->setText(m_time.toString(tr("hh时mm分ss秒")));
	m_start = false;
	m_countDown = true;
	m_mini = false;
	m_suspend = true;

	connect(&m_timeThread, SIGNAL(RemainTimeChanged(const QTime &, int)), this, SLOT(SetRemainTime(const QTime &, int)));
	connect(&m_systemTimeThread, SIGNAL(CurrentTimeChanged(const QTime &)), this, SLOT(SetCurrentTime(const QTime &)));
	m_systemTimeThread.start();
	swidget = new SusWidget(0);

	connect(exitButton, SIGNAL(clicked()), this, SLOT(HideOrExit()));    //reject()
	connect(countEdit, SIGNAL(timeChanged(const QTime &)), this, SLOT(CountTimeChanged(const QTime &)));
	connect(countDownRadio, SIGNAL(clicked()), this, SLOT(ClickedCountDownRadio()));
	connect(timeEdit, SIGNAL(timeChanged(const QTime &)), this, SLOT(doTimeChanged(const QTime &)));
	connect(timerRadio, SIGNAL(clicked()), this, SLOT(ClickedTimerRadio()));
	connect(startButton, SIGNAL(clicked()), this, SLOT(ClickedStartButton()));
	connect(this, SIGNAL(RemainTimeChanged(const QTime &, int)), swidget, SLOT(SetRemainTime(const QTime &, int)));

	setWindowTitle(QApplication::translate("ShutDown", "\351\243\230\344\272\221\345\256\232\346\227\266\345\205\263\346\234\272\347\250\213\345\272\217", 0, QApplication::UnicodeUTF8));
	chooseGroup->setTitle(QApplication::translate("ShutDown", "\350\256\276\345\256\232\345\205\263\346\234\272\346\226\271\345\274\217", 0, QApplication::UnicodeUTF8));
	countDownRadio->setText(QApplication::translate("ShutDown", "\350\256\276\345\256\232\345\200\222\350\256\241\346\227\266\357\274\232", 0, QApplication::UnicodeUTF8));
	timerRadio->setText(QApplication::translate("ShutDown", "\350\256\276\345\256\232\345\205\263\346\234\272\346\227\266\351\227\264\357\274\232", 0, QApplication::UnicodeUTF8));
	remainText->setText(QApplication::translate("ShutDown", "\345\205\263\346\234\272\345\211\251\344\275\231\346\227\266\351\227\264\357\274\232", 0, QApplication::UnicodeUTF8));
	currentTimeText->setText(QApplication::translate("Dialog", "\345\275\223\345\211\215\347\263\273\347\273\237\346\227\266\351\227\264\357\274\232", 0, QApplication::UnicodeUTF8));
	startButton->setText(QApplication::translate("ShutDown", "\345\274\200\345\247\213\345\256\232\346\227\266\345\205\263\346\234\272", 0, QApplication::UnicodeUTF8));
	exitButton->setText(QApplication::translate("ShutDown", "\351\232\220\350\227\217\346\210\226\351\200\200\345\207\272", 0, QApplication::UnicodeUTF8));
}

ShutDown::~ShutDown()
{
	m_systemTimeThread.terminate();
	m_systemTimeThread.wait();
}

/*
void ShutDown::closeEvent(QCloseEvent *event)
{
	int choose = QMessageBox::question(this, tr("最小化到托盘或退出程序"),	tr("飘云温情提示：\n      是否将程序最小化到托盘？最小化请点击Yes，退出程序请点击No。\n最小化后如需退出程序，请在托盘图标上点击右键，选择退出！") ,
		QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
	if( choose == QMessageBox::Yes )
	{
		hide();
		event->ignore();
		trayIcon->show();
		m_mini = true;
		if(m_start)  trayIcon->setToolTip(tr("定时关机程序正在运行"));
		else trayIcon->setToolTip(tr("定时关机程序已经停止运行"));
		m_suspend = true;
		if(m_start) swidget->show();
	}
	else
	{
		reject();
	}
}*/


void  ShutDown::HideOrExit()
{
	int choose = QMessageBox::question(this, tr("最小化到托盘或退出程序"),	tr("飘云温情提示：\n      是否将程序最小化到托盘？最小化请点击Yes，退出程序请点击No。\n最小化后如需退出程序，请在托盘图标上点击右键，选择退出！") ,
		                                     QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
	if( choose == QMessageBox::Yes )
	{
		hide();
		trayIcon->show();
		m_mini = true;
		if(m_start)  trayIcon->setToolTip(tr("定时关机程序正在运行"));
		else trayIcon->setToolTip(tr("定时关机程序已经停止运行"));
		m_suspend = true;
		if(m_start) swidget->show();
	}
	else
	{
		reject();
	}
}

void ShutDown::createActions()
{
	susAction = new QAction(tr("隐藏悬浮窗"), this);
	connect(susAction, SIGNAL(triggered()), this, SLOT(ShowSusWidget()));
	restoreAction = new QAction(tr("还原窗口"), this);
	connect(restoreAction, SIGNAL(triggered()), this, SLOT(ShowDialog()));
	quitAction = new QAction(tr("退出程序"), this);
	connect(quitAction, SIGNAL(triggered()), qApp, SLOT(quit()));
	QIcon icon;
	icon.addPixmap(QPixmap(QString::fromUtf8("Resources/sus.png")), QIcon::Normal, QIcon::Off);
	susAction->setIcon(icon);
	QIcon icon1;
	icon1.addPixmap(QPixmap(QString::fromUtf8("Resources/restore.png")), QIcon::Normal, QIcon::Off);
	restoreAction->setIcon(icon1);
	QIcon icon2;
	icon2.addPixmap(QPixmap(QString::fromUtf8("Resources/exit.png")), QIcon::Normal, QIcon::Off);
	quitAction->setIcon(icon2);
}

void ShutDown::createTrayIcon()
{
	trayIconMenu = new QMenu(this);
	trayIconMenu->addAction(susAction);
	trayIconMenu->addAction(restoreAction);
	trayIconMenu->addSeparator();
	trayIconMenu->addAction(quitAction);
	trayIcon = new QSystemTrayIcon(this);
	trayIcon->setContextMenu(trayIconMenu);
	QIcon icon;
	icon.addPixmap(QPixmap(QString::fromUtf8("Resources/shutdown.png")), QIcon::Normal, QIcon::Off);
	trayIcon->setIcon(icon);
	connect(trayIcon, SIGNAL(activated (QSystemTrayIcon::ActivationReason)), this, SLOT(ClikedTrayIcon(QSystemTrayIcon::ActivationReason)));
	susAction->setEnabled(false);
}

void  ShutDown::ShowDialog()
{
	showNormal();
	m_mini = false;
	trayIcon->hide();
	swidget->hide();
}

void  ShutDown::ShowSusWidget()
{
	if ( m_suspend )
	{
		swidget->hide();
		susAction->setText(tr("显示悬浮窗"));
		m_suspend = false;
	}
	else
	{
		swidget->show();
		susAction->setText(tr("隐藏悬浮窗"));
		m_suspend = true;
	}
}
void ShutDown::ClikedTrayIcon(QSystemTrayIcon::ActivationReason reason)
{
	if ( reason == QSystemTrayIcon::Trigger )  ShowDialog();
}

void ShutDown::CountTimeChanged(const QTime &time)
{
	countDownRadio->setChecked(true);
	timerRadio->setChecked(false);
	m_time = countEdit->time();
	remainTimeLine->setText( m_time.toString(tr("hh时mm分ss秒")) );
	m_countDown = true;
}

void ShutDown::ClickedCountDownRadio()
{
	QTime  time = countEdit->time();
	CountTimeChanged(time);
}

void ShutDown::doTimeChanged(const QTime &time)
{
	countDownRadio->setChecked(false);
	timerRadio->setChecked(true);
	QTime systemTime;
	systemTime = systemTime.currentTime();
	QTime setTime = timeEdit->time();
	m_time = setTime.addSecs(-systemTime.hour()*60*60-systemTime.minute()*60-systemTime.second());
	remainTimeLine->setText( m_time.toString(tr("hh时mm分ss秒")) );
	m_countDown = false;
}

void ShutDown::ClickedTimerRadio()
{
	QTime  time;
	time = timeEdit->time();
	doTimeChanged(time);
}

void ShutDown::ClickedStartButton()
{
	if ( m_countDown )
	{
		m_time = countEdit->time();
		remainTimeLine->setText( m_time.toString(tr("hh时mm分ss秒")) );
		remainTimeLine->setText( m_time.toString(tr("hh时mm分ss秒")) );
	}
	else
	{
		QTime systemTime;
		systemTime = systemTime.currentTime();
		QTime setTime = timeEdit->time();
		m_time = setTime.addSecs(-systemTime.hour()*60*60-systemTime.minute()*60-systemTime.second());
		remainTimeLine->setText( m_time.toString(tr("hh时mm分ss秒")) );
	}
	if ( m_start )
	{
		//停止计时
		countDownRadio->setEnabled (true);
		timerRadio->setEnabled(true);
		timeEdit->setEnabled(true);
		countEdit->setEnabled(true);
		susAction->setEnabled(false);
		startButton->setText(tr("开始定时关机"));
		m_start = false;
		m_timeThread.SetCountTime(m_time, m_start);
		m_timeThread.terminate();
		m_timeThread.wait();
	}
	else
	{
		//开始计时
		countDownRadio->setEnabled (false);
		timerRadio->setEnabled(false);
		timeEdit->setEnabled(false);
		countEdit->setEnabled(false);
		susAction->setEnabled(true);
		startButton->setText(tr("取消定时关机"));
		m_start = true;
		m_timeThread.SetCountTime(m_time, m_start);
		m_timeThread.start();
	}
}

void  ShutDown::SetSusTime(const QTime &time, int type)
{
	emit RemainTimeChanged(time, type);
	if ( type == SHUTDOWN_ERROR )
	{
		countDownRadio->setEnabled (true);
		timerRadio->setEnabled(true);
		timeEdit->setEnabled(true);
		countEdit->setEnabled(true);
		susAction->setEnabled(false);
		startButton->setText(tr("开始定时关机"));
		m_start = false;
	}
}

void ShutDown::SetRemainTime(const QTime &time, int type)
{
	if ( !m_mini )
	{
		if ( type == REMAIN_TIME )
		{
			remainTimeLine->setText( time.toString(tr("hh时mm分ss秒")) );
		}
		if ( type == TO_SHUTDOWN )
		{
			remainTimeLine->setText( tr("正在关机...") );
		}
		if ( type == SHUTDOWN_ERROR )
		{
			remainTimeLine->setText( tr("关机失败...") );
			countDownRadio->setEnabled (true);
			timerRadio->setEnabled(true);
			timeEdit->setEnabled(true);
			countEdit->setEnabled(true);
			susAction->setEnabled(false);
			startButton->setText(tr("开始定时关机"));
			m_start = false;
		}
	}
	if ( m_mini && m_suspend )
	{
		SetSusTime(time, type);
	}
}

void ShutDown::SetCurrentTime(const QTime &time)
{
	systemTimeLine->setText( time.toString(tr("hh时mm分ss秒")) );
}

对于QT，还有个主函数：

main.cpp

#include <QtGui/QApplication>
#include <QtCore/QTextCodec>
#include "shutdown.h"

int main(int argc, char *argv[])
{
	QApplication a(argc, argv);
	QTextCodec::setCodecForTr(QTextCodec::codecForName("gb2312"));
	ShutDown w;
	w.show();
	return a.exec();
}

至此一个简单的定时关机程序就编写完了。我也是个QT初学者，代码可能有些生涩，只是分享一下初次使用QT编程序的经验而已。