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， 未完成， 只实现了部分功能。

 

运行界面如下图。