QT图形界面实现系统监控状态(未完成)

linux操作系统 QT4版本

转：http://wcrane.bokee.com/viewdiary.15932441.html

非常感谢这位仁兄，应为我们用到你的一部分。

 

/*主程序main.cpp*/
#include <QApplication>

#include "mainwindow.h"

int main(int argc, char *argv[])
{
QApplication app(argc, argv);

 MainWindow mainWindow;        //创建主窗口类实例
 mainWindow.resize(200, 100);      //设置主窗口位置
 mainWindow.show();             //显示主窗口
 
 return app.exec();
}

/*主窗口程序mainwindow.cpp*/
#include "mainwindow.h"
/*主窗口类的实现*/
MainWindow::MainWindow(QWidget *parent, Qt::WindowFlags flags)  //构造函数
 : QMainWindow(parent, flags)
{
 setFixedSize(350, 450);                                        //固定窗口大小

//添加菜单选项并给每个菜单利用信号机制添加处理函数
 QMenu *menuFile = menuBar()->addMenu("&File");                //添加菜单
 QAction *action = menuFile->addAction("&Open");                 //创建进程
 connect(action, SIGNAL(triggered()), this, SLOT(createProcess()));
 action = menuFile->addAction("&Exit");                          //退出程序
 connect(action, SIGNAL(triggered()), this, SLOT(close()));
 
 QMenu *menuEdit = menuBar()->addMenu("Edit");
 menuEdit->addAction("&Stop process");                          //停止进程
 connect(action, SIGNAL(triggered()), this, SLOT(stopProcess()));
 menuEdit->addAction("&Continue process");                      //继续进程
 connect(action, SIGNAL(triggered()), this, SLOT(continueProcess()));
 menuEdit->addSeparator();                                     //添加分隔符

 menuEdit->addAction("&Kill process");                          //杀死进程
 connect(action, SIGNAL(triggered()), this, SLOT(killProcess()));
 menuEdit->addAction("&Preference");                           //
 connect(action, SIGNAL(triggered()), this, SLOT(preference()));

 QMenu *menuView = menuBar()->addMenu("&View");
 menuView->addAction("&Active Process");                       //显示活动进程
 connect(action, SIGNAL(triggered()), this, SLOT(activeProcess()));
 menuView->addAction("&My Process");                        //显示当前用户进程
 connect(action, SIGNAL(triggered()), this, SLOT(myProcess()));
 menuView->addAction("All Process");                           //显示所有进程
 connect(action, SIGNAL(triggered()), this, SLOT(allProcess()));
 menuView->addSeparator();
 menuView->addAction("&Dependency");
 connect(action, SIGNAL(triggered()), this, SLOT(dependency()));
 menuView->addAction("Hide Process");                    //隐藏进程进程
 connect(action, SIGNAL(triggered()), this, SLOT(hideProcess()));
 menuView->addAction("Hided Process");                   //显示隐藏进程
 connect(action, SIGNAL(triggered()), this, SLOT(hidedProcess()));
 menuView->addSeparator();
 menuView->addAction("Memory Image");                  //
 connect(action, SIGNAL(triggered()), this, SLOT(memoryImage()));
 menuView->addAction("Opened File");                    //打开文件
 connect(action, SIGNAL(triggered()), this, SLOT(openedFile()));

 QMenu *menuHelp = menuBar()->addMenu("&Help");
 menuHelp->addAction("Help");                          //帮助
 connect(action, SIGNAL(triggered()), this, SLOT(showHelp()));
 menuHelp->addAction("About");                         //关于
connect(action, SIGNAL(triggered()), this, SLOT(showAboutBox()));

tabWidget = new QTabWidget;                    //用tab分页显示各种信息
tabWidget->addTab(new ProcessTab, "Process");      //进程信息显示面板
 tabWidget->addTab(new ResourceTab, "Resource");   //资源信息显示面板
 tabWidget->addTab(new FileSystemTab, "Partition");  //分区信息显示面板

 setCentralWidget(tabWidget);
 setWindowTitle("Linux Resource Manager");
}
/*进程创建消息槽的实现*/
void MainWindow::createProcess()
{
 bool ok;
 QString text = QInputDialog::getText(this, tr("Input file name:"),
                                          tr("Open File:"), QLineEdit::Normal, "File Name", &ok);
    if(ok)
     QProcess::startDetached(text);
    else
        return;
}
/*由于时间关系，其他消息槽均未实现*/
void MainWindow::stopProcess()
{
}
void MainWindow::continueProcess()
{
}
void MainWindow::killProcess(){}
void MainWindow::endProcess(){}
void MainWindow::changePriority(){}
void MainWindow::preference(){}
void MainWindow::activeProcess(){}
void MainWindow::myProcess(){}
void MainWindow::allProcess(){}
void MainWindow::dependency(){}
void MainWindow::hideProcess(){}
void MainWindow::hidedProcess(){}
void MainWindow::memoryImage(){}
void MainWindow::openedFile(){}
void MainWindow::showAboutBox(){}
void MainWindow::showHelp(){}

 

/*主窗口头文件mainwindow.h*/
/*主窗口类的定义，包括所有的消息和消息槽的定义以及成员变量的定义*/
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QMenu>
#include <QWidget>
#include <QTableWidget>
#include <QTabWidget>
#include <QListWidget>
#include <QMenuBar>
#include <QVBoxLayout>
#include <QInputDialog>
#include <QProcess>

#include "tab.h"

class MainWindow : public QMainWindow
{
 Q_OBJECT
public:
 MainWindow(QWidget *parent = 0, Qt::WindowFlags flags = 0);   //构造函数

 void newProcess(const QString &fileName);

 QString *fileName;

 

/*消息槽的定义*/
public slots:
 void createProcess();
 void stopProcess();
 void continueProcess();
 void killProcess();
 void endProcess();
 void changePriority();
 void preference();  //首选项
 void activeProcess();
 void myProcess();
 void allProcess();
 void dependency();
 void hideProcess();
 void hidedProcess();
 void memoryImage();
 void openedFile();
 void showAboutBox();
 void showHelp();

 

private:
 QTabWidget *tabWidget;
 QTableWidget *tableWidget;
 QListWidget *listWidget;
};

#endif

 

/*表格tab.cpp*/
#include "tab.h"

double cpu;             //全局变量，用来保存上一次cpu使用时间
/*进程信息表格的实现*/
ProcessTab::ProcessTab(QWidget *parent)
 : QWidget(parent)
{
 QStringList tableHeaders;          //用list分别显示各条进程信息
 tableHeaders << "Name" << "PID" << "User" << "Status" << "VM" << "Resident MM" << "CPU%" << "nice" << "Memory";       //各项进程信息
 tableProcess = new QTableWidget(0, 9, this);

//设置表格标题栏
 tableProcess->setHorizontalHeaderLabels(tableHeaders);

 QPushButton *pushButton = new QPushButton("Kill Process");
 QLabel *titleLabel = new QLabel("<h3><font color=green>Current System CPU Usage: </font></h3>");
 
 for(int i = 0; i < 3; i++)
  cpuDataStart[i] =  0;
 

cpuUsageLabel = new QLabel;
    /*每秒钟定时更新cpu使用率*/
 QTimer *timer = new QTimer(this);
 connect(timer, SIGNAL(timeout()), this, SLOT(updateCpu())); 
 timer->start(1000);
 updateCpu();
    /*没10秒更新进程信息*/
 QTimer *timer2 = new QTimer(this);
 connect(timer2, SIGNAL(timeout()), this, SLOT(updateProcess()));
 timer2->start(10000);
 updateProcess();

 QVBoxLayout *processLayout = new QVBoxLayout;
 processLayout->addWidget(titleLabel);         //在主面板上添加组件
 processLayout->addWidget(cpuUsageLabel);
 processLayout->addWidget(tableProcess);
 processLayout->addWidget(pushButton);
 setLayout(processLayout);
}

/*cpu使用率更新函数，第一次取前3项之和除以4项之和，以后每次用前一次的各项分别相减然后再用结果的前3项的和除以4项之和，结果以百分数和进度条动态显示*/
void ProcessTab::updateCpu()
{
 QFile file("/proc/stat");      //从/proc/stat中读取cpu信息
 if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
  return;
 QString line = file.readLine();

  QStringList list;
  int current[4], used = 0, total = 0;
 bool ok;

list = line.split(" ");

 for(int i = 2; i < 6; i++)
 {
  cpuDataEnd[i-2] = list[i].toInt(&ok, 10);
  current[i-2] = cpuDataEnd[i-2] - cpuDataStart[i-2];
  cpuDataStart[i-2] = cpuDataEnd[i-2];
  total += current[i-2];          //4项总和
 }
 used = total - current[3];           //计算前3项之和
 cpu = 100.0 * used / total;          //计算cpu使用率
 cpuUsageLabel->setText(QString::number(cpu, 'f', 2).append("%"));   //显示小数点后2位
}
/*更新进程的函数，每隔10秒从/proc下的各个进程的stat文件中读取进程信息，并用表格形式动态显示*/
void ProcessTab::updateProcess()
{
 bool ok;
 DIR *dir;
 FILE *fd;
 struct dirent *dirName;            //目录结构
 char stat[2], nice[3];              //分别保存进程当前状态和nice数
 char vmsize[20], rmsize[20];      //进程所用虚拟内存大小以及所占实际物理内存大小
 char processName[50];          //进程名
 char fileName[50];

 tableProcess->setRowCount(0);       //每次更新进程信息时，先将表格清零
 if((dir = opendir("/proc")) == NULL)  //从/proc目录中读取进程号
  return;
 while((dirName = readdir(dir)) != NULL)
 {
  if(atoi(dirName->d_name))  //根据进程号为非零整数，判断文件夹名是否为进程号
  {
   tableProcess->insertRow(0);  //将进程信息添加到表格
   sprintf(processName, "/proc/%s/stat", dirName->d_name);   //

   if((fd = fopen(processName, "r")) == NULL)
   {
    printf("open error/n");
    return;
   }
           

//从进程的stat文件中读取进程名，状态，nice值，以及内存的使用情况        fscanf(fd,"%*s%s%s%*s%*s%*s%*s%*s%*s%*s%*s%*s%*s%*s%*s%*s%*s%*s%s%*s%*s %*s%s%s", fileName, stat, nice, vmsize, rmsize);
   fclose(fd);
   tableProcess->setItem(0, 0, new QTableWidgetItem(fileName));
   tableProcess->setItem(0, 1, new QTableWidgetItem(dirName->d_name));
   switch(stat[0])             //根据进程的状态，将其转换为更友好的形式显示
   {
    case 'S' :
     tableProcess->setItem(0, 3, new QTableWidgetItem(tr("Sleep")));
     break;
    case 'R' :
     tableProcess->setItem(0, 3, new QTableWidgetItem("Running"));
     break;
    case 'Z' :
     tableProcess->setItem(0, 3, new QTableWidgetItem("Zombie"));
     break;
    case 'D' :
     tableProcess->setItem(0, 3, new QTableWidgetItem(tr("Disk Sleep")));
     break;
    case 'T' :
     tableProcess->setItem(0, 3, new QTableWidgetItem("Stop"));
     break;
    case 'X' :
     tableProcess->setItem(0, 3, new QTableWidgetItem("Dead"));
     break;
    default: 
     break;
   }
   tableProcess->setItem(0, 7, new QTableWidgetItem(nice));
   tableProcess->setItem(0, 4, new QTableWidgetItem(QString("%1M").arg((atof(vmsize) / (1024 * 1024)))));
   tableProcess->setItem(0, 5, new QTableWidgetItem(QString("%1M").arg((atof(rmsize) *4 / 1024))));
  }
 }
}
/*资源面板的实现*/
ResourceTab::ResourceTab(QWidget *parent )
 : QWidget(parent)
{
 QLabel *cpuLabel = new QLabel("<h3><font color=green>CPU:</font></h3>");
 cpuBar = new QProgressBar;      //用进度条动态显示cpu使用率
 QLabel *memLabel = new QLabel;
 memoryLabel = new QLabel;     //内存使用率
 memoryBar = new QProgressBar;  //内存使用率进度条表示
 swapLabel = new QLabel;       //交换分区使用率
 swapBar = new QProgressBar;    //交换分区使用率进度条表示
 netReceiveLabel = new QLabel;   //当前接受到的网络信息量
 netTransmitLabel = new QLabel;  //已发送的网络流量
 
 memoryBar->setRange(0, 100);
 memoryBar->setTextVisible(true);
 swapBar->setRange(0, 100);
 swapBar->setTextVisible(true);
 cpuBar->setRange(0, 100); 
 cpuBar->setTextVisible(true);
    //用Timer类实现每隔1秒钟更新数据
 QTimer *timer = new QTimer(this);
 connect(timer, SIGNAL(timeout()), this, SLOT(updateCpuBar()));
 timer->start(1000);
 updateCpuBar();

 QGridLayout *resourceTabLayout = new QGridLayout;
 resourceTabLayout->addWidget(memoryLabel);
 resourceTabLayout->addWidget(memoryBar);
 resourceTabLayout->addWidget(swapLabel);
 resourceTabLayout->addWidget(swapBar);
 resourceTabLayout->addWidget(cpuLabel);
 resourceTabLayout->addWidget(cpuBar);
 resourceTabLayout->addWidget(netReceiveLabel);
 resourceTabLayout->addWidget(netTransmitLabel);
 setLayout(resourceTabLayout);
}
//更新cpu使用率的进度条，同时更新内存与网络的使用情况
void ResourceTab::updateCpuBar()
{
 cpuBar->setValue((int)cpu);    //设置进度条的位置
 updateMemory();            
 updateNet();
}
//更新内存与交换分区的使用情况
void ResourceTab::updateMemory()
{
 FILE *fd;
 QString str = "K";
 QString strName = "<h3><font color=green>Total memory:  </font></h3>";
 QString swapName = "<h3><font color=green>Swap Total:  </font></h3>";
 char memoryTotal[10];        //物理内存大小
 char memoryFree[10];        //空闲内存大小
 char memoryBuffered[10];    //内存缓冲区大小
 char memoryCached[10];     //
 char swapTotal[10];         //交换分区大小
 char swapFree[10];          //空闲交换分区大小
 char buf[80];

 /*读取内存使用情况*/
    fd = fopen("/proc/meminfo", "r");
 fscanf(fd, "%*s%s%*s", memoryTotal);
 fscanf(fd, "%*s%s%*s", memoryFree); 
 fscanf(fd, "%*s%s%*s", memoryBuffered);
 fscanf(fd, "%*s%s%*s", memoryCached); 

 for(int i =0; i < 8; i++)
 fgets(buf, 80, fd);
    /*读取交换分区使用情况*/
 fscanf(fd, "%*s%s%*s", swapTotal);
 fscanf(fd, "%*s%s%*s", swapFree);

 memoryBar->setValue(100 * (atoi(memoryTotal) - atoi(memoryFree) - atoi(memoryBuffered) - atoi(memoryCached)) / atoi(memoryTotal));
 memoryLabel->setText(strName + memoryTotal + str); 
 swapBar->setValue(100 * (atoi(swapTotal) - atoi(swapFree))/atoi(swapTotal)); 
 swapLabel->setText(swapName + swapTotal + str);
}
/*更新网络使用情况*/
void ResourceTab::updateNet()
{
 QString strReceive = "<h3><font color=green>Total Received: </font></h3>";
 QString strTransmit = "<h3><font color=green>Total Transmitted: </font></h3>";
 FILE *fd;
 char temp[80];
 char receive[20], transmit[20];
 int receiveSpeed;
 char toInt[12];

 if((fd = fopen("/proc/net/dev", "r")) == NULL)
  return;
 for(int i = 0; i < 5; i++)
  fgets(temp, 80, fd);
 fscanf(fd, "%s%*s%*s%*s%*s%*s%*s%*s%s", receive, transmit);
 fclose(fd);
 strcpy(toInt, &receive[5]);
 netReceiveLabel->setText(strReceive + QString(" %1 M").arg(atof(toInt)/(1024*1024)));
 netTransmitLabel->setText(strTransmit + QString(" %1 M").arg(atof(transmit)/(1024*1024)));
}
/*硬盘分区情况表格的实现*/
FileSystemTab::FileSystemTab(QWidget *parent )
 : QWidget(parent)
{
 QStringList tableHeaders;
 tableHeaders << "Device" << "Dirctory" << "Type" << "Sum" << "Free" << "Capacity" << "Used";
 tableFileSystem = new QTableWidget(0, 7, this);
 tableFileSystem->setHorizontalHeaderLabels(tableHeaders);

 QTimer *timer = new QTimer(this);
 connect(timer, SIGNAL(timeout()), this, SLOT(fsList())); 
 timer->start(10000);
 fsList();

 QVBoxLayout *fileSystemLayout = new QVBoxLayout;
 fileSystemLayout->addWidget(tableFileSystem);
 setLayout(fileSystemLayout);
}

void FileSystemTab::updateFileSystem()
{
}
/*获取分区信息并显示*/
void FileSystemTab::fsList()
{
 FILE *fd;
 QString str = "/dev/";
 int i = 0;
 char buf[80];
 char items[4][10];

 tableFileSystem->setRowCount(0);

 fd = fopen("/proc/partitions", "r");
 fgets(buf, 80, fd);
 fgets(buf, 80, fd);
 while(fgets(buf, 80, fd))
 {
  sscanf(buf, "%s%s%s%s", items[0], items[1], items[2], items[3]);
  tableFileSystem->insertRow(0);
  tableFileSystem->setItem(0, 0, new QTableWidgetItem(str + items[3]));
  tableFileSystem->setItem(0, 3, new QTableWidgetItem(items[2])); 
 }
}

 

/*表格头文件tab.h*/
#ifndef TAB_H
#define TAB_H

#include <QLabel>
#include <QWidget>
#include <QTableWidget>
#include <QPushButton>
#include <QVBoxLayout>
#include <QGridLayout>
#include <QTimer>
#include <QFile>
#include <QTextStream>
#include <QList>
#include <QDir>
#include <QProgressBar>
#include <QLocale>

#include <stdlib.h>
#include <stdio.h>
#include <dirent.h>
#include <string.h>

class ProcessTab : public QWidget
{
 Q_OBJECT
public:
 ProcessTab(QWidget *parent = 0);

 

private:
 QLabel *cpuUsageLabel;
 QTableWidget *tableProcess;

 int cpuDataStart[4];
 int cpuDataEnd[4];

 

private slots:
 void updateCpu();
 void updateProcess();
};

 

class ResourceTab : public QWidget
{
 Q_OBJECT
public:
 ResourceTab(QWidget *parent = 0);

 

private:
 QProgressBar *cpuBar;
 QProgressBar *memoryBar;
 QProgressBar *swapBar;
 QLabel *memoryLabel;
 QLabel *swapLabel;
 QLabel *netReceiveLabel;
 QLabel *netTransmitLabel;

/*消息槽*/
private slots:
 void updateCpuBar();
 void updateMemory();
 void updateNet();
};

 

class FileSystemTab : public QWidget
{
 Q_OBJECT
private:
 QTableWidget *tableFileSystem;

 

public:
 FileSystemTab(QWidget *parent = 0);

 

/*消息槽*/
private slots:
 void updateFileSystem();
 void fsList();
};

 

#endif
============================

全部手写， 未用QT designer， 未完成， 只实现了部分功能。

 

运行界面如下图。