读取linux /proc/文件信息，用GTK编程实现简单的系统管理器
源程序附最后（也可直接打包下载http://download.csdn.net/detail/creazyapple/4088149）
要求：
理解和分析/proc文件
内容
了解/proc文件的特点和使用方法。
监控系统状态，显示系统中若干部件的使用情况。用图形界面显示系统监控状态。
相关原理：
用户和应用程序可以通过/proc得到系统的信息，并可以改变内核的某些参数。由于系统的信息是动态改变的，所以用户或应用程序读取proc文件时，proc文件系统是动态从系统内核读出所需信息并提交的。
我们要显示系统信息，只需进行相应的文件操作。首先打开相应的文件，读取所需要的信息，将其写入一个缓冲区中，然后将缓冲区的内容加到Gtk的相应的控件上面去，最后将控件组合显示即可。
/proc/文件结构参考：http://blog.csdn.net/ubuntulover/article/details/4449787
比如我们如果要读取cpu信息，可以在控制台下输入命令：cat /proc/cpuinf
要得到内存信息，可以输入命令：cat /proc/meminfo 
这只是冰山一角，仅此我们已经看到/proc目录下文件内容之丰富。
要想编程读取这些信息，首先我们要了解/proc结构，了解其各种信息的排布，然后就像读普通文件一样将其筛选出来。
比如，查看系统的cpu频率，属于cpu信息：more /proc/cpuinfo （注，命令more 和cat功能相似，都是显示一个文件的内容)
其排布为如下：
我们也就知道，cpuinf文件中，一种信息放一行，因此我们一行一行的遴选信息。
首先需将cpuinf文件读出来，
fp = fopen("/proc/cpuinf", "r");
/* 从fp中读取sizeof(buffer)块数据放入buffer */
buf = fread(buffer, 1, sizeof(buffer), fp);
fclose(fp);
然后进行字符串匹配，找到含有“cpu MHz”这个字符串的一行，读出来即可。
其它如模块信息、内存信息，类似处理，字要你了解了其结构，就可以方便的读出来
所以关键有3点：1、你知道信息在哪里；2、你看到了信息的排列方式；3、设计算法剔除无用信息。
而对于进程信息，稍复杂。
我们先看看进程信息放在哪里的：首先进入 /proc 目录并查看该目录下的文件：
蓝色的是目录（所谓的文件夹），绿色的是文件，文件中有cpuinf、meminfo等，我们之前已经看过。现在看看那些蓝色的以数字为名的文件夹，他们正是保存进程信息的！
目录1存储的是PID为1的进程的信息，目录2存储的是PID为2的进程的信息……
我们试着进入这些目录看看！
里面有一些目录和文件，其中有个status文件，打开看看：
看到了吧，很清晰地罗列出了进程1的信息，名字是init，状态Sleeping ，PID是1……
由此得知，要读取所有进程的信息列表，我们需要循环打开/proc文件夹下所有以数字命名的目录。
大致过程为：
while ((ptr = readdir(dir)) != NULL)
{
if ((ptr->d_name[0] >= '0') && (ptr->d_name[0] <= '9')) //打开以数值命名的目录
{
sprintf(path, "/proc/%s/status", ptr->d_name); //将此文件的全部路径写入name中
//打开这个文件，并且从中读取到有用的信息放在相应的数组中
fd = open(path, O_RDONLY);
read(fd, store, sizeof(store));
……
读取信息
……
close(fd);
}
}
closedir(dir);好了，现在弄清楚了原理，就可以动手实现了。但是需要一个界面呀，这里我们继续用GTK来画界面。
关于GTK这里就不多说了。
最后实现界面截图：
杀死进程：
刷新列表：
最后，附上源程序。共11个文件，将其放入一个文件夹下，编译命令：gcc -o sb *.c `pkg-config --cflags --libs gtk+-2.0`（当然首先得配置好了GTK，
参考上一篇博客 ubuntu GTK+eclipse 配置 http://blog.csdn.net/creazyapple/article/details/7290443）
/*
* MainWin.c
* SystemMonitor
* Created on: 2012-2-24
* Author: zhushengben
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define MAX 1024
#include "searchInfor.h"
#include "cpu.h"
#include "memory.h"
#include "module.h"
#include "process.h"
#include "menuBar.h"
#include "progressBar.h"
#include "showAbout.h"
#include "refresh.h"
#include "showImage.h"
int main(int argc, char ** argv)
{
GtkWidget * window;
GtkWidget * main_vbox;
GtkWidget *tooltip;
gtk_init(&argc, &argv);
/* 主窗口 */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
tooltip = gtk_tooltips_new();
gtk_tooltips_set_tip(tooltip, window, "系统监视器\n此软件归华中科技大学所有\n未经授权不可擅自更改",
NULL);
gtk_window_set_title(GTK_WINDOW(window), "System Moniter");
gtk_window_set_opacity(GTK_WINDOW(window), 0.95); // 设置透明度函数
//update_widget_bg(window, BACK_IMAGE);
/* 默认窗口大小 */
gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
/* 窗口初始位置在屏幕最中央 */
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
/* 显示窗口 */
gtk_widget_show(window);
/* 创建一个纵向盒 */
main_vbox = gtk_vbox_new(FALSE, 10);
/* 设定这个容器和周围的间距 */
gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 5);
/* 将这个布局容器添加到整个视窗的容器中 */
gtk_container_add(GTK_CONTAINER(window), main_vbox);
/* 显示该盒 */
gtk_widget_show(main_vbox);
createMenuBar(main_vbox);
/* 建立多标签页notebook */
GtkWidget *notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos((GtkNotebook *) notebook, GTK_POS_BOTTOM);
gtk_notebook_set_show_border((GtkNotebook *) notebook, FALSE);
/* 在纵向盒顶部添加该笔记本 */
gtk_box_pack_end(GTK_BOX(main_vbox), notebook, TRUE, TRUE, 0);
/* 显示该笔记本 */
gtk_widget_show(notebook);
/* 新建第一个标签页到notebook，用的是frame框架 */
createCPUPage(notebook);
/* 新建第三个标签页到notebook */
createModPage(notebook);
/* 新建第四个标签页到notebook */
createProPage(notebook);
/* 新建第五个标签页到notebook */
/* 原来是mem模块在死循环中 */
createMemPage(notebook);
/* 新建第二个标签页到notebook */
createAboutPage(notebook);
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
/**************************************************/
gtk_timeout_add(400, refresh, pdata);
gtk_main();
return 0;
}
/*
* cpu.h
* helloWorld
* Created on: 2012-2-19
* Author: zhushengben
*/
#ifndef CPU_H_
#define CPU_H_
GtkWidget *window;
GtkWidget *main_vbox;
GtkWidget *clist; //进程时候需要的列表
GtkWidget *clist2; //模块读取时需要的列表
GtkWidget *cpu_draw_area;
GdkPixmap *cpu_graph;
GtkWidget *pbar_cpu;
/* 全局变量 */
static gint cpuPoints[100];
static gfloat cpu_rate = 0.0;
static char PID[20];
static int selectedRow;
float zuser = 0, ztotal = 0;
typedef struct CPUinfo
{
char modeName[50]; //line 5
char cpuMHz[10]; //line 7
char cacheSize[10];//line 8
char cpuCores[10]; //line 12
char addrSize[50]; //line 30
}*cpuInfo;
static gboolean cpu_expose_event(GtkWidget *widget, GdkEventExpose *event,
gpointer data)
{
gdk_draw_drawable(widget->window, widget->style->fg_gc[GTK_WIDGET_STATE(
widget)], cpu_graph, event->area.x, event->area.y, event->area.x,
event->area.y, event->area.width, event->area.height);
return FALSE;
}
static gboolean cpu_configure_event(GtkWidget *widget,
GdkEventConfigure *event, gpointer data)
{
if (cpu_graph)
{
g_object_unref(cpu_graph);
}
cpu_graph = gdk_pixmap_new(widget->window, widget->allocation.width,
widget->allocation.height, -1);
gdk_draw_rectangle(cpu_graph, widget->style->white_gc, TRUE, 0, 0,
widget->allocation.width, widget->allocation.height);
return TRUE;
}
/* 取得cpu利用率 */
float getCpuUseRatio()
{
FILE *fp;
char buffer[1024];
size_t buf;
float useRatio;
/* 分别为用户模式，低优先级用户模式，内核模式，空闲的处理器时间 */
float user = 0, nice = 0, sys = 0, idle = 0, iowait = 0;
fp = fopen("/proc/stat", "r");
/* 从fp中读取sizeof(buffer)块数据放入buffer，每次读一块 */
buf = fread(buffer, 1, sizeof(buffer), fp);
fclose(fp);
if (buf == 0)
return 0;
buffer[buf] == '\0';
sscanf(buffer, "cpu %f %f %f %f %f", &user, &nice, &sys, &idle, &iowait);
if (idle <= 0)
idle = 0;
useRatio = 100 * (user - zuser) / (user + nice + sys + idle - ztotal);
if (useRatio > 100)
useRatio = 100;
ztotal = user + nice + sys + idle;
zuser = user;
cpu_rate = useRatio;
return useRatio;
}
/* cpu标签页，显示cpu信息 */
void createCPUPage(GtkWidget* notebook)
{
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *frame1 = gtk_frame_new("");
gtk_container_set_border_width(GTK_CONTAINER(frame1), 10);
gtk_widget_set_size_request(frame1, 120, 500);
gtk_widget_show(frame1);
/* 将该标签页加入到notebook中 */
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame1, gtk_label_new(
"CPU信息"));
/* 在该页建议个表格，分为上下2行，一列 */
GtkWidget *table1 = gtk_table_new(10, 10, TRUE);
/* 将这个表添加到“cpu使用率“页 */
gtk_container_add(GTK_CONTAINER(frame1), table1);
/* 新建一个frame框架用于显示图表 */
GtkWidget *CPU_frame1 = gtk_frame_new("CPU使用历史曲线");
/* 放到表格第一行 */
/* 这个函数的参数不懂，不好调整 */
gtk_table_attach_defaults(GTK_TABLE(table1), CPU_frame1, 0, 8, 0, 5);
gtk_widget_show(CPU_frame1);
/* 现在,我们开始向屏幕绘图。
* 我们使用的构件是绘图区构件。
*一个绘图区构件本质上是一个 X 窗口,没有其它的东西。
*它是一个空白的画布,我们可以在其上绘制需要的东西。*/
cpu_draw_area = gtk_drawing_area_new();
/* 设置可以画图 */
gtk_widget_set_app_paintable(cpu_draw_area, TRUE);
/* 画图区默认大小 */
gtk_drawing_area_size(GTK_DRAWING_AREA(cpu_draw_area), 40, 80);
/* 画布添加到cpu曲线框架中 */
gtk_container_add(GTK_CONTAINER(CPU_frame1), cpu_draw_area);
gtk_widget_show(cpu_draw_area);
/* 关联回调函数 */
/* 关于各种事件不甚了解 */
g_signal_connect(cpu_draw_area, "expose_event",
G_CALLBACK(cpu_expose_event), NULL);
g_signal_connect(cpu_draw_area, "configure_event", G_CALLBACK(
cpu_configure_event), NULL);
gtk_widget_show(cpu_draw_area);
int i;
for (i = 0; i < 100; i++)
{
/* 要取[a,b)之间的随机整数（包括a，但不包括b)，使用：
* (rand() % (b - a)) + a */
cpuPoints[i] = (rand() % 30 + 180);
}
// 此处出现问题
/* 不断刷新画图 */
// gtk_timeout_add(100, (GtkFunction) drawGraph, NULL);
/* 取得CPU信息 */
char modeName[50], cpuMHz[20], cacheSize[20], cpuCores[20], addrSize[50];
char cpuBuffer[1000];
//getCPUInfo("/proc/cpuinfo", modeName, cacheSize);
//cpuMHz,cacheSize,cpuCores,addrSize);
/* 不能用\t !! */
getInforNotd("/proc/cpuinfo", "model name", modeName);
getInforNotd("/proc/cpuinfo", "cache size", cacheSize);
getInforNotd("/proc/cpuinfo", "cpu MHz", cpuMHz);
getInforNotd("/proc/cpuinfo", "cpu cores", cpuCores);
getInforNotd("/proc/cpuinfo", "address sizes", addrSize);
/* 建一个frame在表一下半部显示cpu信息 */
GtkWidget *frame_down = gtk_frame_new("系统信息 ");
gtk_table_attach_defaults(GTK_TABLE(table1), frame_down, 0, 10, 5, 10);
gtk_widget_show(frame_down);
/* 这里必须要show表，为什么？不知到该在什么时候show什么 */
gtk_widget_show(table1);
/* 在该狂建建一个表格，将下半部分为1行，2列 */
GtkWidget *table_down = gtk_table_new(1, 2, TRUE);
/* 将这个表添加到下面框架 */
gtk_container_add(GTK_CONTAINER(frame_down), table_down);
/* 建一个frame在表二左半部显示硬件信息 */
GtkWidget *frame_left_down = gtk_frame_new("硬件");
gtk_table_attach_defaults(GTK_TABLE(table_down), frame_left_down, 0, 1, 0,
1);
gtk_widget_show(frame_left_down);
/* 这里必须要show表，为什么？不知到该在什么时候show什么 */
gtk_widget_show(table_down);
/* 容器 */
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_container_add(GTK_CONTAINER(frame_left_down), vbox);
gtk_widget_show(vbox);
/* 建一个标签显示cpu型号 */
strcpy(cpuBuffer, "CPU型号和主频:\n");
strcat(cpuBuffer, modeName);
/* 这里不该有？
* gtk_widget_show(label);
* 原来是因为我们有清除cpuBuffer */
/* 建一个标签显示cache大小 */
strcat(cpuBuffer, "\n\nCache 大小:");
strcat(cpuBuffer, cacheSize);
/* 建一个标签显示cpu主频 */
strcat(cpuBuffer, "\n\ncpu 主频:");
strcat(cpuBuffer, cpuMHz);
strcat(cpuBuffer, " MHz");
/* 建一个标签显示cpu核数 */
strcat(cpuBuffer, "\n\ncpu核数:");
strcat(cpuBuffer, cpuCores);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
/* 建一个标签显示addrSize */
strcat(cpuBuffer, "\n\n寻址位数:");
strcat(cpuBuffer, addrSize);
label = gtk_label_new(cpuBuffer);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
gtk_widget_show(label);
/* 建一个frame在表二右半部显示系统版本信号 */
GtkWidget *frame_right_down = gtk_frame_new("Ubuntu");
GdkColor color;
PangoFontDescription *font;
/* 设置颜色 */
gdk_color_parse("blue", &color);
gtk_widget_modify_fg(frame_right_down, GTK_STATE_NORMAL, &color);
/* 设置字体 */
font = pango_font_description_from_string("San");
pango_font_description_set_size(font, 30 * PANGO_SCALE);
gtk_widget_modify_font(frame_right_down, font);
gtk_table_attach_defaults(GTK_TABLE(table_down), frame_right_down, 1, 2, 0,
1);
gtk_widget_show(frame_right_down);
/* 这里必须要show表，为什么？不知到该在什么时候show什么 */
gtk_widget_show(table_down);
/* 容器 */
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_container_add(GTK_CONTAINER(frame_right_down), vbox);
gtk_widget_show(vbox);
/* 建一个标签显示cpu型号 */
memset(cpuBuffer, 0, 1000);
memset(addrSize, 0, 50);
getSysVersion("/proc/version", "version", addrSize);
strcat(cpuBuffer, "\n\n内核版本 : ");
strcat(cpuBuffer, addrSize);
strcat(cpuBuffer, "\n\n系统版本 10.10 (maverick)");
strcat(cpuBuffer, "\n\nGNOME 2.32.0");
GtkWidget *label1 = gtk_label_new(cpuBuffer);
gtk_box_pack_start(GTK_BOX(vbox), label1, FALSE, FALSE, 5);
gtk_widget_show(label1);
/* 新建一个frame框架用于显示进度条*/
GtkWidget *frame_cpu = gtk_frame_new("cpu使用率");
gtk_table_attach_defaults(GTK_TABLE(table1), frame_cpu, 8, 10, 0, 5);
gtk_widget_show(frame_cpu);
/* 创建第一个进度条
* GTK_PROGRESS_BOTTOM_TO_TOP */
pbar_cpu = gtk_progress_bar_new();
gtk_container_add(GTK_CONTAINER(frame_cpu), pbar_cpu);
gtk_progress_bar_set_orientation(pbar_cpu, GTK_PROGRESS_BOTTOM_TO_TOP);
gtk_widget_show(pbar_cpu);
/* 容器 放在右下角 */
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_table_attach_defaults(GTK_TABLE(table1), vbox, 6, 10, 7, 10);
gtk_widget_show(vbox);
gtk_widget_show(table1);
/* 创建一个图像 */
GtkWidget *image = gtk_image_new_from_file("4.png");
gtk_box_pack_start(GTK_BOX(vbox), image, FALSE, FALSE, 3);
gtk_widget_show(image);
/* 容器 放在右下角 */
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_table_attach_defaults(GTK_TABLE(table1), vbox, 0, 5, 7, 10);
gtk_widget_show(vbox);
gtk_widget_show(table1);
/* 创建一个图像 */
image = gtk_image_new_from_file("1.png");
gtk_box_pack_start(GTK_BOX(vbox), image, FALSE, FALSE, 3);
gtk_widget_show(image);
}
#endif /* CPU_H_ *//*
* memory.h
* systemMonitor
* Created on: 2012-2-19
* Author: zhushengben
*/
#ifndef MEMORY_H_
#define MEMORY_H_
typedef struct _ProgressData
{
GtkWidget *frame1;
GtkWidget *pbar;
GtkWidget *pbar1;
GtkWidget *pbar2;
GtkWidget *pbar3;
gboolean activity_mode;
} ProgressData;
ProgressData *pdata_mem;
GtkWidget *label_memSize;
GtkWidget *label_freeSize;
GtkWidget *label_cacheSize;
GtkWidget *label_cacheUse;
gdouble memUseRatio, swapUse;
char totalMem[20], freeMem[20], SwapTotal[20], SwapFree[20];
char Buffers[20], Cached[20], buffer[40];
/* 更新进度条,这样就能够看到进度条的移动 */
gint progress_timeout(gpointer data);
/* MEMERY标签页，显示内存信息 */
void createMemPage(GtkWidget* notebook)
{
GtkWidget *align;
GtkWidget *table;
GtkWidget *vbox;
GtkWidget *image;
GdkColor color;
PangoFontDescription *font;
memUseRatio = 0;
memset(buffer, 0, 40);
/* 为传递到回调函数中的数据分配内存 */
pdata_mem = g_malloc(sizeof(ProgressData));
pdata_mem->frame1 = gtk_frame_new("");
gtk_container_set_border_width(GTK_CONTAINER(pdata_mem->frame1), 0);
gtk_widget_set_size_request(pdata_mem->frame1, 120, 500);
gtk_widget_show(pdata_mem->frame1);
/* 将该标签页加入到notebook中 */
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), pdata_mem->frame1,
gtk_label_new("内存信息"));
/* 建一个表格，将下半部分为10行，10列 */
table = gtk_table_new(10, 10, TRUE);
/* 将这个表添加到框架 */
gtk_container_add(GTK_CONTAINER(pdata_mem->frame1), table);
/* 创建进度条 */
/* 新建一个frame框架用于显示进度条*/
GtkWidget *frame_cpu = gtk_frame_new("内存");
gtk_table_attach_defaults(GTK_TABLE(table), frame_cpu, 0, 5, 0, 3);
gtk_widget_show(frame_cpu);
/* 容器 */
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_container_add(GTK_CONTAINER(frame_cpu), vbox);
gtk_widget_show(vbox);
gtk_widget_show(table);
/* 创建一个居中对齐的对象 */
align = gtk_alignment_new(0.5, 0.5, 0.8, 0);
gtk_box_pack_start(GTK_BOX(vbox), align, FALSE, FALSE, 5);
gtk_widget_show(align);
/* 创建第一个进度条
* GTK_PROGRESS_BOTTOM_TO_TOP */
pdata_mem->pbar = gtk_progress_bar_new();
gtk_container_add(GTK_CONTAINER(align), pdata_mem->pbar);
gtk_progress_bar_set_orientation(pdata_mem->pbar,
GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_widget_show(pdata_mem->pbar);
/* 创建一个居中对齐的对象 */
align = gtk_alignment_new(0.5, 0.5, 0.8, 0);
gtk_box_pack_start(GTK_BOX(vbox), align, FALSE, FALSE, 5);
gtk_widget_show(align);
/* 创建第二个进度条 */
pdata_mem->pbar1 = gtk_progress_bar_new();
gtk_container_add(GTK_CONTAINER(align), pdata_mem->pbar1);
// toggle_show_text("内存使用率", pdata_mem);
toggle_activity_mode(FALSE, pdata_mem);
gtk_widget_show(pdata_mem->pbar1);
/* 新建一个frame框架用于显示进度条*/
frame_cpu = gtk_frame_new("交换区");
gtk_table_attach_defaults(GTK_TABLE(table), frame_cpu, 5, 10, 0, 3);
gtk_widget_show(frame_cpu);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_container_add(GTK_CONTAINER(frame_cpu), vbox);
gtk_widget_show(vbox);
gtk_widget_show(table);
/* 创建一个居中对齐的对象 */
align = gtk_alignment_new(0.5, 0.5, 0.8, 0);
gtk_box_pack_start(GTK_BOX(vbox), align, FALSE, FALSE, 5);
gtk_widget_show(align);
/* 创建第三个进度条 */
pdata_mem->pbar2 = gtk_progress_bar_new();
gtk_container_add(GTK_CONTAINER(align), pdata_mem->pbar2);
toggle_show_text("内存交换区", pdata_mem);
toggle_activity_mode(FALSE, pdata_mem);
gtk_widget_show(pdata_mem->pbar2);
/* 创建一个居中对齐的对象 */
align = gtk_alignment_new(0.5, 0.5, 0.8, 0);
gtk_box_pack_start(GTK_BOX(vbox), align, FALSE, FALSE, 5);
gtk_widget_show(align);
/* 创建第四个进度条 */
pdata_mem->pbar3 = gtk_progress_bar_new();
gtk_container_add(GTK_CONTAINER(align), pdata_mem->pbar3);
toggle_show_text("交换区使用量", pdata_mem);
toggle_activity_mode(FALSE, pdata_mem);
gtk_widget_show(pdata_mem->pbar3);
/* 加上这一行后，出现问题
* faile to NULL to ProgressBar
* 关于timer的使用不明白 */
/* 不断刷新画图 */
//gtk_timeout_add(100, (GtkFunction) progress_timeout, pdata_mem);
progress_timeout(pdata_mem);
/*************************************/
/* 容器 放在左下角 */
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_table_attach_defaults(GTK_TABLE(table), vbox, 0, 6, 4, 10);
gtk_widget_show(vbox);
gtk_widget_show(table);
/* 创建一个居中对齐的对象 */
align = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), align, FALSE, FALSE, 5);
gtk_widget_show(align);
/* 建一个标签显示内存大小 */
label_memSize = gtk_label_new(buffer);
gtk_container_add(GTK_CONTAINER(align), label_memSize);
font = pango_font_description_from_string("San");
pango_font_description_set_size(font, 15 * PANGO_SCALE);
gtk_widget_modify_font(label_memSize, font);
/* 设置控件可容字数从而设置其大小 */
gtk_label_set_width_chars(GTK_LABEL(label_memSize), 20);
/* 设置控件对齐方式
* 第一个参数是lblTest,第二个参数是左右方向的对齐值，第三个参数是上下方向的对齐值;
*对齐值的取值范围为0-1.取0时，为左对齐,取1时,为右对齐,取0.5时，为中间对齐. */
gtk_misc_set_alignment(GTK_MISC(label_memSize), 0, 0.5);
gtk_widget_show(label_memSize);
/****************************************************/
/* 创建一个居中对齐的对象 */
align = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), align, FALSE, FALSE, 5);
gtk_widget_show(align);
/* 建一个标签显示空闲区大小 */
label_freeSize = gtk_label_new(buffer);
gtk_container_add(GTK_CONTAINER(align), label_freeSize);
/* 设置颜色 */
gdk_color_parse("red", &color);
gtk_widget_modify_fg(label_freeSize, GTK_STATE_NORMAL, &color);
/* 设置字体 */
font = pango_font_description_from_string("San");
pango_font_description_set_size(font, 15 * PANGO_SCALE);
gtk_widget_modify_font(label_freeSize, font);
/* 设置控件可容字数从而设置其大小 */
gtk_label_set_width_chars(GTK_LABEL(label_freeSize), 20);
/* 设置控件对齐方式
* 第一个参数是lblTest,第二个参数是左右方向的对齐值，第三个参数是上下方向的对齐值;
*对齐值的取值范围为0-1.取0时，为左对齐,取1时,为右对齐,取0.5时，为中间对齐. */
gtk_misc_set_alignment(GTK_MISC(label_freeSize), 0, 0.5);
gtk_widget_show(label_freeSize);
/****************************************************/
/* 创建一个居中对齐的对象 */
align = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), align, FALSE, FALSE, 5);
gtk_widget_show(align);
/* 建一个标签显示cache大小 */
label_cacheSize = gtk_label_new(buffer);
gtk_container_add(GTK_CONTAINER(align), label_cacheSize);
/* 设置颜色 */
gdk_color_parse("black", &color);
gtk_widget_modify_fg(label_cacheSize, GTK_STATE_NORMAL, &color);
/* 设置字体 */
font = pango_font_description_from_string("San");
pango_font_description_set_size(font, 15 * PANGO_SCALE);
gtk_widget_modify_font(label_cacheSize, font);
/* 设置控件可容字数从而设置其大小 */
gtk_label_set_width_chars(GTK_LABEL(label_cacheSize), 20);
/* 设置控件对齐方式
* 第一个参数是lblTest,第二个参数是左右方向的对齐值，第三个参数是上下方向的对齐值;
*对齐值的取值范围为0-1.取0时，为左对齐,取1时,为右对齐,取0.5时，为中间对齐. */
gtk_misc_set_alignment(GTK_MISC(label_cacheSize), 0, 0.5);
gtk_widget_show(label_cacheSize);
/****************************************************/
/* 创建一个居中对齐的对象 */
align = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), align, FALSE, FALSE, 5);
gtk_widget_show(align);
/* 建一个标签显示空闲区大小 */
label_cacheUse = gtk_label_new(buffer);
gtk_container_add(GTK_CONTAINER(align), label_cacheUse);
/* 设置颜色 */
gdk_color_parse("black", &color);
gtk_widget_modify_fg(label_cacheUse, GTK_STATE_NORMAL, &color);
/* 设置字体 */
font = pango_font_description_from_string("San");
pango_font_description_set_size(font, 15 * PANGO_SCALE);
gtk_widget_modify_font(label_cacheUse, font);
/* 设置控件可容字数从而设置其大小 */
gtk_label_set_width_chars(GTK_LABEL(label_cacheUse), 20);
/* 设置控件对齐方式
* 第一个参数是lblTest,第二个参数是左右方向的对齐值，第三个参数是上下方向的对齐值;
*对齐值的取值范围为0-1.取0时，为左对齐,取1时,为右对齐,取0.5时，为中间对齐. */
gtk_misc_set_alignment(GTK_MISC(label_cacheUse), 0, 0.5);
gtk_widget_show(label_cacheUse);
/**********************************************/
/* 容器 放在中间角角 */
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_table_attach_defaults(GTK_TABLE(table), vbox, 0, 10, 3, 8);
gtk_widget_show(vbox);
gtk_widget_show(table);
/* 新建一个frame框架用于显示进度条*/
frame_cpu = gtk_frame_new("");
gtk_table_attach_defaults(GTK_TABLE(table), frame_cpu, 0, 10, 3, 4);
gtk_widget_show(frame_cpu);
/* 创建一个进度条 */
createProgressBar(frame_cpu);
/* 容器 放在右下角 */
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_table_attach_defaults(GTK_TABLE(table), vbox, 4, 10, 5, 10);
gtk_widget_show(vbox);
gtk_widget_show(table);
/* 创建一个图像 */
image = gtk_image_new_from_file("penguin.gif");
gtk_box_pack_start(GTK_BOX(vbox), image, FALSE, FALSE, 3);
gtk_widget_show(image);
/* 容器 放在右下角 */
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_table_attach_defaults(GTK_TABLE(table), vbox, 3, 7, 8, 10);
gtk_widget_show(vbox);
gtk_widget_show(table);
/* 创建一个图像 */
image = gtk_image_new_from_file("5.png");
gtk_box_pack_start(GTK_BOX(vbox), image, FALSE, FALSE, 3);
gtk_widget_show(image);
/* 容器 放在右下角 */
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_table_attach_defaults(GTK_TABLE(table), vbox, 0, 2, 4, 6);
gtk_widget_show(vbox);
gtk_widget_show(table);
/* 创建一个图像 */
image = gtk_image_new_from_file("a.png");
gtk_box_pack_start(GTK_BOX(vbox), image, FALSE, FALSE, 3);
gtk_widget_show(image);
}
/* 更新进度条,这样就能够看到进度条的移动 */
gint progress_timeout(gpointer data)
{
if (pdata_mem->activity_mode)
gtk_progress_bar_pulse(GTK_PROGRESS_BAR(pdata_mem->pbar));
else
{
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pdata_mem->pbar),
memUseRatio);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pdata_mem->pbar1), 1
- memUseRatio);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pdata_mem->pbar2),
swapUse);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pdata_mem->pbar3), 1
- swapUse);
}
return TRUE;
}
/* 设置进度条的滑槽上的文本显示 */
void toggle_show_text(const gchar *text, ProgressData *pdata_mem)
{
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pdata_mem->pbar), "内存使用率");
}
/* 设置进度条的活动模式 */
void toggle_activity_mode(gboolean activity_mode, ProgressData *pdata_mem)
{
pdata_mem->activity_mode = activity_mode;
}
/* 回调函数,切换进度条的移动方向 */
void toggle_orientation(GtkWidget *widget, ProgressData *pdata_mem)
{
switch (gtk_progress_bar_get_orientation(GTK_PROGRESS_BAR(pdata_mem->pbar)))
{
case GTK_PROGRESS_LEFT_TO_RIGHT:
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(pdata_mem->pbar),
GTK_PROGRESS_RIGHT_TO_LEFT);
break;
case GTK_PROGRESS_RIGHT_TO_LEFT:
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(pdata_mem->pbar),
GTK_PROGRESS_LEFT_TO_RIGHT);
break;
default:
;// 什么也不做
}
}
/* 清除分配的内存,删除定时器(timer) */
void destroy_progress(GtkWidget *widget, ProgressData *pdata_mem)
{
pdata_mem->frame1 = NULL;
pdata_mem->pbar = NULL;
pdata_mem->pbar1 = NULL;
pdata_mem->pbar2 = NULL;
pdata_mem->pbar3 = NULL;
g_free(pdata_mem);
gtk_main_quit();
}
void set_label_mem_text(void)
{
getInfor("/proc/meminfo", "MemTotal", totalMem);
getInfor("/proc/meminfo", "MemFree", freeMem);
getInfor("/proc/meminfo", "SwapTotal", SwapTotal);
getInfor("/proc/meminfo", "SwapFree", SwapFree);
float total_mem = (float) atoi(totalMem);
float free_mem = (float) atoi(freeMem);
memUseRatio = 1 - free_mem / total_mem;
float total_swap = (float) atoi(SwapTotal);
float free_swap = (float) atoi(SwapFree);
swapUse = 1 - free_swap / total_swap;
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pdata_mem->pbar),
memUseRatio);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pdata_mem->pbar1), 1
- memUseRatio);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pdata_mem->pbar2), swapUse);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pdata_mem->pbar3), 1
- swapUse);
char p[20] = "内存使用率(", buf[10];
gcvt(memUseRatio * 100, 4, buf);
strcat(buf, "%)");
strcat(p, buf);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pdata_mem->pbar), p);
char p1[20] = "内存剩余量(", buf1[10];
gcvt(100 - memUseRatio * 100, 4, buf1);
strcat(buf1, "%)");
strcat(p1, buf1);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pdata_mem->pbar1), p1);
char p2[20] = "交换区使用率(", buf2[10];
gcvt(swapUse * 100, 4, buf2);
strcat(buf2, "%)");
strcat(p2, buf2);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pdata_mem->pbar2), p2);
char p3[20] = "交换区剩余量(", buf3[10];
gcvt(100 - swapUse * 100, 4, buf3);
strcat(buf3, "%)");
strcat(p3, buf3);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pdata_mem->pbar3), p3);
char buffer[100] = "";
strcat(buffer, "\n\n内存大小 : ");
strcat(buffer, totalMem);
strcat(buffer, " MB");
gtk_label_set_text((GtkLabel*) label_memSize, buffer);
memset(buffer, 0, 40);
strcat(buffer, "\n空闲区大小 : ");
strcat(buffer, freeMem);
strcat(buffer, " MB");
gtk_label_set_text((GtkLabel*) label_freeSize, buffer);
getInfor("/proc/meminfo", "Buffers", Buffers);
memset(buffer, 0, 40);
strcat(buffer, "\n缓存大小 : ");
strcat(buffer, Buffers);
strcat(buffer, " MB");
gtk_label_set_text((GtkLabel*) label_cacheSize, buffer);
getInfor("/proc/meminfo", "Cached", Cached);
memset(buffer, 0, 40);
strcat(buffer, "\nCached大小 : ");
strcat(buffer, Cached);
strcat(buffer, " MB");
gtk_label_set_text((GtkLabel*) label_cacheUse, buffer);
}
#endif /* MEMORY_H_ *//*
* module.h
* helloWorld
* Created on: 2012-2-19
* Author: zhushengben
*/
#ifndef MODULE_H_
#define MODULE_H_
GtkWidget * clist_modul;
void getModInfo(char store[], int i, char modName[], char memUse[],
char times[]);
void createModPage(GtkWidget* notebook)
{
GtkWidget *frame_up, *frame_down, *table, *align, *button;
GtkWidget *frame = gtk_frame_new("模块信息表");
gtk_container_set_border_width(GTK_CONTAINER(frame), 10);
gtk_widget_set_size_request(frame, 100, 355);
gtk_widget_show(frame);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, gtk_label_new(
"模块信息"));
/* 建一个表格，分为上下两部分 */
table = gtk_table_new(10, 4, TRUE);
/* 将这个表添加到框架 */
gtk_container_add(GTK_CONTAINER(frame), table);
/* 建一个frame在表上边*/
frame_down = gtk_frame_new("*0(^_^)0*");
gtk_table_attach_defaults(GTK_TABLE(table), frame_down, 0, 4, 0, 10);
gtk_widget_show(frame_down);
gtk_widget_show(table);
GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_add(GTK_CONTAINER(frame_down), scrolled_window);
gtk_widget_show(scrolled_window);
/* 老是不能显示，经测试直到这里都可以正确实现 */
gchar *titles[3] =
{ "模块名", "占用内存", "加载次数" }; //由于含有特殊情况，所以只读取通//用格式的范例
clist_modul = gtk_clist_new_with_titles(3, titles);
gtk_clist_set_shadow_type(GTK_CLIST(clist_modul), GTK_SHADOW_IN);
gtk_clist_set_column_width(GTK_CLIST(clist_modul), 0, 270);
gtk_clist_set_column_width(GTK_CLIST(clist_modul), 1, 270);
gtk_clist_set_column_width(GTK_CLIST(clist_modul), 2, 270);
gtk_container_add(GTK_CONTAINER(scrolled_window), clist_modul);
set_modul_info();
gtk_widget_show(clist_modul);
}
void set_modul_info()
{
/* 原来是这个函数中出现某种问题，
* 删除这个函数后可以出现所有控件
* 于是我干脆把那个函数直接整合到这个函数中来
* 结果可以运行来！
* 我认为可能是将控件作为函数参数传递出的问题 */
/* 读取当前进程信息，并显示到列表框中 */
//add_modules_view(clist_modul);
/* 原来用的是5000，出现问题，于是变小，可以 */
char infoBuf[2000]; //暂存读取的modules文件内容
int fd = open("/proc/modules", O_RDONLY);
read(fd, infoBuf, sizeof(infoBuf));
close(fd);
unsigned int lines = 0;
unsigned int i = 0;
gtk_clist_clear(clist_modul);
/* 先取得行数 */
while (i != sizeof(infoBuf) / sizeof(char))
{
if (infoBuf[i] == '\n')
lines++;
i++;
}
i = 0;
for (i = 1; i <= lines; i++)
{
char convert_mem[25];
char modName[25]; //模块名
char memUse[20]; //内存量
char times[5]; //使用次数
int mem_num;
float real_mem;
getModInfo(infoBuf, i, modName, memUse, times);
mem_num = atoi(memUse);
real_mem = (float) mem_num / (1024);
gcvt(real_mem, 3, convert_mem);
gchar *list[1][3] =
{
{ modName, convert_mem, times } };
gtk_clist_append((GtkCList*) clist_modul, list[0]);
gtk_clist_thaw((GtkCList *) clist_modul); //更新list列表显示
}
}
void getModInfo(char store[], int i, char modName[], char memUse[],
char times[])
{
int j = 0;
int cflags = 0; //记录读取的回车键个数以便判断行数
int k = 0;
char name2[25];
char mem2[20];
char times2[5];
while (cflags < i - 1)
{
if (store[j] == '\n')
cflags++; //回车数加1
j++;
}
while (store[j] != ' ')
{ //读取进程名
name2[k++] = store[j];
j++;
}
name2[k] = '\0';
j++; //跳转到下一个不是空格的地方
k = 0;
while (store[j] != ' ')
{
mem2[k++] = store[j];
j++;
}
mem2[k] = '\0'; //封口
j++;
times2[0] = store[j]; //读取模块的使用次数
times2[1] = '\0'; //封口
strcpy(modName, name2);
strcpy(memUse, mem2);
strcpy(times, times2);
}
void add_modul(void)
{
system("insmod ./devDrv.ko");
set_modul_info();
}
void remove_modul(void)
{
system("rmmod devDrv.");
set_modul_info();
}
#endif /* MODULE_H_ */
/*
* process.h
* helloWorld
* Created on: 2012-2-19
* Author: zhushengben
*/
#ifndef PROCESS_H_
#define PROCESS_H_
GtkWidget * clist;
GtkWidget *label_proc;
GtkWidget *label_time;
/* 刷新信息 */
void set_proc_info();
/* 表示读取第i个空格之前的一个字符串(此即获得的数据)) */
void read_info(char store[], int i, char get[]);
/* 用户选中某一行时的回调函数*/
void selection_made(GtkWidget *clist, gint row, gint column,
GdkEventButton *event, gpointer data);
void createProPage(GtkWidget* notebook)
{
char buffer[100];
GtkWidget * table;
GtkWidget *frame_up;
GtkWidget *frame_down;
GtkWidget *vbox;
GtkWidget *font;
GtkWidget *tooltip;
GdkColor color;
GtkWidget *frame = gtk_frame_new("");
gtk_container_set_border_width(GTK_CONTAINER(frame), 10);
gtk_widget_set_size_request(frame, 100, 355);
gtk_widget_show(frame);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, gtk_label_new(
"进程信息"));
/* 建一个表格，分为上下两部分 */
table = gtk_table_new(10, 4, TRUE);
/* 将这个表添加到框架 */
gtk_container_add(GTK_CONTAINER(frame), table);
/* 建一个frame在表左下边显示标签信息 */
frame_up = gtk_frame_new("*0(^_^)0*");
gtk_table_attach_defaults(GTK_TABLE(table), frame_up, 0, 2, 7, 10);
gtk_widget_show(frame_up);
gtk_widget_show(table);
/* 建一个标签显示进程数等(用button代替) */
label_proc = gtk_button_new_with_label("good");
gtk_container_add(GTK_CONTAINER(frame_up), label_proc);
/* 连接刷新 */
g_signal_connect(G_OBJECT(label_proc), "clicked",
G_CALLBACK(set_proc_info), NULL);
tooltip = gtk_tooltips_new();
gtk_tooltips_set_tip(tooltip, label_proc, "点击刷新", NULL);
gtk_widget_show(label_proc);
/* 建一个frame在表右下边显示标签信息 */
frame_up = gtk_frame_new("(*^_^*)");
gtk_table_attach_defaults(GTK_TABLE(table), frame_up, 2, 4, 7, 10);
gtk_widget_show(frame_up);
gtk_widget_show(table);
/* 建一个标签显示系统时间(用button代替) */
label_time = gtk_button_new_with_label("good");
gtk_tooltips_set_tip(tooltip, label_time, "点击刷新", NULL);
g_signal_connect(G_OBJECT(label_time), "clicked",
G_CALLBACK(set_proc_info), NULL);
gtk_container_add(GTK_CONTAINER(frame_up), label_time);
gtk_widget_show(label_time);
/* 建一个frame在表下边显示进程信息 */
frame_down = gtk_frame_new("进程信息表");
gtk_table_attach_defaults(GTK_TABLE(table), frame_down, 0, 4, 0, 7);
gtk_widget_show(frame_down);
gtk_widget_show(table);
/* 创建一个滚动窗口构件，将GtkCList组装到里面。
* 这样使得内容超出列表时，可以用滚动条浏览*/
GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_add(GTK_CONTAINER(frame_down), scrolled_window);
gtk_widget_show(scrolled_window);
gchar *titles[5] =
{ "进程名", "进程PID", "进程状态", "占用内存", "优先级" };
/* 创建GtkCList构件。本例中，我们使用了5列*/
clist = gtk_clist_new_with_titles(5, titles);
gtk_tooltips_set_tip(tooltip, clist, "点击杀死进程", NULL);
/* 当作出选择时，我们要知道选择了哪一个单元格。
* 使用 selection_row回调函数，代码在clist.h可以看见*/
gtk_signal_connect(GTK_OBJECT(clist), "select_row", GTK_SIGNAL_FUNC(
selection_made), NULL);
/* 不一定要设置边框的阴影，但是效果挺不错*/
gtk_clist_set_shadow_type(GTK_CLIST(clist), GTK_SHADOW_OUT);
/* 设置每一列到宽度 */
gtk_clist_set_column_width(GTK_CLIST(clist), 0, 200);
gtk_clist_set_column_width(GTK_CLIST(clist), 1, 120);
gtk_clist_set_column_width(GTK_CLIST(clist), 2, 110);
gtk_clist_set_column_width(GTK_CLIST(clist), 3, 100);
gtk_clist_set_column_width(GTK_CLIST(clist), 4, 100);
gtk_container_add(GTK_CONTAINER(scrolled_window), clist);
gtk_widget_show(clist);
set_proc_info();
}
void set_proc_info()
{
/* 读取当前进程信息，并显示到列表框中 */
DIR *dir;
struct dirent *ptr;
dir = opendir("/proc");
char path[20]; //记录pid的数字文件夹
int fd; //文件描述，用于打开那些数字文件夹的stat文件
char store[1000]; //将读取的stat文件内容暂时存放到store中
char name[20]; //进程名
char pid_num[20]; //pid号
char stat[20]; //状态
char memory[20]; //内存
char priority[20]; //优先级
gtk_clist_clear(GTK_CLIST(clist));
while ((ptr = readdir(dir)) != NULL)
{
if ((ptr->d_name[0] >= '0') && (ptr->d_name[0] <= '9'))
{
sprintf(path, "/proc/%s/stat", ptr->d_name); //将此文件的全部路径写入name中
//打开这个文件，并且从中读取到有用的信息放在相应的数组中
fd = open(path, O_RDONLY);
read(fd, store, sizeof(store));
close(fd);
read_info(store, 1, pid_num); //进去的是字符串和号，出来对应信息修改
read_info(store, 2, name); //读取名称
read_info(store, 3, stat); //进程状态，SDR已经转化为中文
read_info(store, 18, priority); //优先级
read_info(store, 23, memory); //注意是以B为单位，需要换算
int mem_num = atoi(memory); //转换成整数形式B为单位
float real_mem = (float) mem_num / (1024 * 1024); //得到MB为单位的信息
char convert_mem[25];
gcvt(real_mem, 5, convert_mem); //浮点数转换成字符串
gchar *list[1][5] =
{
{ name, pid_num, stat, convert_mem, priority } };
/* 把这一行加入到clist中 */
gtk_clist_append((GtkCList*) clist, list[0]);
gtk_clist_thaw((GtkCList *) clist); //更新list列表显示
}
}
closedir(dir);
}
/* 用户选中某一行时的回调函数*/
void selection_made(GtkWidget *clist, gint row, gint column,
GdkEventButton *event, gpointer data)
{
/* 取得存储在被选中的行和列的单元格上的文本
* 当鼠标点击时，我们用t e x t参数接收一个指针*/
gchar *Pid, *procName, buffer[40] = "Kill the process <";
/* 该函数读取CLIST被选中到PID，
* 它与gtk_clist_set_text函数功能相反。*/
gtk_clist_get_text(GTK_CLIST(clist), row, 1, &Pid);
gtk_clist_get_text(GTK_CLIST(clist), row, 0, &procName);
selectedRow = row;
strcat(buffer, procName);
strcat(buffer, "> !?");
GtkWidget *dialog;
dialog = gtk_message_dialog_new(NULL, //
GTK_DIALOG_DESTROY_WITH_PARENT, //跟随父窗口关闭
GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,//
buffer);
gtk_window_set_title(GTK_WINDOW(dialog), "*0(^_^)0*");
GtkResponseType result = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
if (result == GTK_RESPONSE_YES || result == GTK_RESPONSE_APPLY)
{
killProcess(Pid);
}
return;
}
/* 根据一个pid杀死进程 */
/* 使用全局变量PID */
void killProcess(gchar *Pid)
{
gchar killCmd[50] = "kill ";
strcat(killCmd, Pid);
system(killCmd);
g_printf("%s", killCmd);
/* 用gtk_clist_clear函数清除列表
* void gtk_clist_remove (GtkCList *clist,gint row);
* 该函数用来删除某一索引行。
* 行数确定时，直接对应第二个参数即可。
* 对于行数不确定，而是由鼠标或键盘随机获得焦点行的动态行删除问题，
* 在具体编程实现上，可以通过利用CLIST列表构件头文件
* gtkclist.h内GtkCList结构中的属性变量focus_row来实现，语句如下：
* gtk_clist_remove (GTK_CLIST(clist),GTK_CLIST (clist)->focus_row);*/
gtk_clist_remove(clist, selectedRow);
GtkWidget *dialog;//声明一个对话框
/* 新建一个消息对话框 */
dialog = gtk_message_dialog_new(NULL, //没有父窗口
GTK_DIALOG_DESTROY_WITH_PARENT, //跟随父窗口关闭
GTK_MESSAGE_WARNING, //显示警告图标
GTK_BUTTONS_OK, //显示OK按钮
("人生寂寞啊，被人杀死了！")); //提示信息的内容
gtk_window_set_title(GTK_WINDOW(dialog), ("进程已经被杀死……"));//对话框的标题
gtk_dialog_run(GTK_DIALOG(dialog));//运行对话框
gtk_widget_destroy(dialog);//删除对话框
}
void set_label_proc_text()
{
char buffer[100];
char processes[10];
getInforAftSpace("/proc/stat", "processes", processes);
strcpy(buffer, "当前进程数 : ");
strcat(buffer, processes);
char btime[10];//系统运行时间
char times[30];
int fd = open("/proc/uptime", O_RDONLY);
read(fd, times, sizeof(times));
close(fd);
read_info(times, 0, btime);
float fInfor = (float) atof(btime);
fInfor = fInfor / 60; //将单位化成min
gcvt(fInfor, 5, btime);
strcat(buffer, "\n系统运行时间 : ");
strcat(buffer, btime);
strcat(buffer, " min");
char aveLoad[20];
get_load_avg(aveLoad);
strcat(buffer, "\n平均负载 : ");
strcat(buffer, aveLoad);
gtk_button_set_label((GtkButton*) label_proc, buffer);
strcpy(buffer, "--------------点击刷新------------\n\n当前时间 ：");
time_t rawtime;
struct tm * timeinfo;
time(&rawtime);
timeinfo = localtime(&rawtime);
strcat(buffer, asctime(timeinfo));
gtk_button_set_label((GtkButton*) label_time, buffer);
}
#endif /* PROCESS_H_ *//*
* showAbout.h
* systemMonitor
* Created on: 2012-2-19
* Author: zhushengben
*/
#ifndef SHOWABOUT_H_
#define SHOWABOUT_H_
void showAbout(void)
{
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file("3.png", NULL);
GtkWidget *dialog = gtk_about_dialog_new();
gtk_about_dialog_set_name(GTK_ABOUT_DIALOG(dialog), "Ubuntu 系统监视器");
gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(dialog), "beta0.1");
gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(dialog),
"Copyright © 2012-2114 ZhuShengben");
gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(dialog), "查看当前进程，监视系统状态 .");
gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(dialog),
"http://user.qzone.qq.com/337075552");
gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(dialog), pixbuf);
g_object_unref(pixbuf), pixbuf = NULL;
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
/* 创建一个滚动文本区域,用于显示一个"信息" */
void createAboutPage(GtkWidget* notebook)
{
GtkWidget *label;
GtkWidget *table;
GtkWidget *button;
GtkWidget *align;
GtkWidget *tooltip;
GtkWidget *vbox;
GtkWidget *scrolled_window;
GtkWidget *view;
GtkWidget *vpaned;
GtkTextBuffer * buffer;
GtkWidget *frame = gtk_frame_new("编辑邮件");
gtk_container_set_border_width(GTK_CONTAINER(frame), 10);
gtk_widget_set_size_request(frame, 120, 500);
gtk_widget_show(frame);
/* 将该标签页加入到notebook中 */
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, gtk_label_new(
"错误报告"));
/* 在顶级窗口上添加一个垂直分栏窗口构件 */
vpaned = gtk_vpaned_new();
gtk_container_add(GTK_CONTAINER(frame), vpaned);
gtk_widget_show(vpaned);
/* 在分栏窗口的两部分各添加一些构件 */
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add1(GTK_PANED(vpaned), scrolled_window);
view = gtk_text_view_new();
gtk_container_add(GTK_CONTAINER(scrolled_window), view);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
insert_text(buffer, TRUE);
gtk_widget_show_all(scrolled_window);
gtk_widget_show(scrolled_window);
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add2(GTK_PANED(vpaned), scrolled_window);
view = gtk_text_view_new();
gtk_container_add(GTK_CONTAINER(scrolled_window), view);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
insert_text(buffer, FALSE);
gtk_widget_show_all(scrolled_window);
gtk_widget_show(scrolled_window);
/* 建一个表格，将下半部分为10行，10列 */
// table = gtk_table_new(10, 10, TRUE);
/* 将这个表添加到框架 */
// gtk_container_add(GTK_CONTAINER(frame), table);
/* 创建一个居中对齐的对象 */
align = gtk_alignment_new(0.5, 0.5, 0.8, 0);
gtk_container_add(GTK_CONTAINER(frame), align);
gtk_widget_show(align);
button = gtk_button_new_with_label("Submit");
gtk_container_add(GTK_CONTAINER(align), button);
tooltip = gtk_tooltips_new();
gtk_tooltips_set_tip(tooltip, button, "点击发送", NULL);
gtk_widget_show(button);
}
/* 向文本构件中添加一些文本*/
void insert_text(GtkTextBuffer *buffer, gboolean thanks)
{
GtkTextIter iter;
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
if (TRUE == thanks)
gtk_text_buffer_insert(buffer, &iter,//
"From: @nasa.gov\n"
"To: [email protected]\n"
"Subject: Bugs found !\n"
"There are some bugs just as follows:\n"
//
, -1);
else
gtk_text_buffer_insert(buffer, &iter,//
"介绍\n"
"*\n"
"系统监视器手册 V2.2\n"
" 系统监视器程序使您能够显示系统的基本信息，并能够监视系统进程、系统资源使用情况和文件系统。您也可以用系统监视器来修改系统的行为。\n"
"系统监视器包含四个选项卡部分\n"
"系统\n"
" 显示计算机硬件和软件的不同基本信息。\n"
"发行版\n"
"*\n"
" 发行版版本\n"
"*\n"
" Linux 内核版本\n"
"*\n"
" GNOME 版本\n"
" 硬件\n"
"*\n"
" 安装的内存\n"
"*\n"
" 处理器和速度\n"
" 系统状态\n"
"*\n"
" 当前可用磁盘空间\n"
"处理器\n"
" 显示活动进程和进程之间的相互关系。为每个单独进程提供详细信息，并使您能够控制活动进程。\n"
" 资源\n"
" 显示以下系统资源的当前使用情况。\n"
"*\n"
" CPU(中央处理器)时间\n"
"*\n"
" 内存和交换空间\n"
"*\n"
" 网络使用情况\n"
" 文件系统\n"
"% CPU\n"
" 选中此项以显示进程当前使用的 CPU 时间百分率。\n"
"CPU 时间\n"
" 选中此项以显示进程已作用的 CPU 时间。\n"
"启动\n"
" 选中此项以显示进程开始运行的时间。\n"
"优先级\n"
" 选中此项以显示进程的 nice 值。nice 值设置进程的优先级：nice 值越低，优先极越高。\n"
"ID\n"
" 选中此项以显示进程标识符，也即 pid。pid 是一个唯一标识进程的数字。您可以使用 pid 在命令行操纵进程。\n"
"内存\n"
" 选中此项以显示进程当前占用的系统内存大小。\n"
//
, -1);
}
/* 设置背景图片 */
void update_widget_bg(GtkWidget *widget, gchar *img_file)
{
GtkStyle *style;
GdkPixbuf *pixbuf;
GdkPixmap *pixmap;
gint width, height;
pixbuf = gdk_pixbuf_new_from_file(img_file, NULL);
width = gdk_pixbuf_get_width(pixbuf);
height = gdk_pixbuf_get_height(pixbuf);
pixmap = gdk_pixmap_new(NULL, width, height, 24);
gdk_pixbuf_render_pixmap_and_mask(pixbuf, &pixmap, NULL, 0);
style = gtk_style_copy(GTK_WIDGET(widget)->style);
if (style->bg_pixmap[GTK_STATE_NORMAL])
g_object_unref(style->bg_pixmap[GTK_STATE_NORMAL]);
style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref(pixmap);
style->bg_pixmap[GTK_STATE_ACTIVE] = g_object_ref(pixmap);
style->bg_pixmap[GTK_STATE_PRELIGHT] = g_object_ref(pixmap);
style->bg_pixmap[GTK_STATE_SELECTED] = g_object_ref(pixmap);
style->bg_pixmap[GTK_STATE_INSENSITIVE] = g_object_ref(pixmap);
gtk_widget_set_style(GTK_WIDGET(widget), style);
g_object_unref(style);
}
#endif /* SHOWABOUT_H_ *//*
* showImage.h
* SystemMonitor
* Created on: 2012-2-24
* Author: zhushengben
*/
#ifndef SHOWIMAGE_H_
#define SHOWIMAGE_H_
void showImage(int argc, char *argv[])
{
GtkWidget *window = NULL;
GdkPixbuf *pixbuf = NULL;
GdkBitmap *bitmap = NULL;
GdkPixmap *pixmap = NULL;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_signal_connect(GTK_OBJECT(window), "delete_event", GTK_SIGNAL_FUNC(
gtk_main_quit), NULL);
gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(
gtk_main_quit), NULL);
gtk_window_set_decorated(GTK_WINDOW(window), FALSE); // 设置无边框
gtk_widget_set_app_paintable(window, TRUE);
gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
gtk_widget_realize(window);
pixbuf = gdk_pixbuf_new_from_file("penguin.gif", NULL); // gdk函数读取png文件
gdk_pixbuf_render_pixmap_and_mask(pixbuf, &pixmap, &bitmap, 120); // alpha小于128认为透明
gtk_widget_shape_combine_mask(window, bitmap, 0, 0); // 设置透明蒙板
gdk_window_set_back_pixmap(window->window, pixmap, FALSE); // 设置窗口背景
g_object_unref(pixbuf);
g_object_unref(bitmap);
g_object_unref(pixmap);
gtk_widget_show_all(window);
gtk_main();
}
#endif /* SHOWIMAGE_H_ */
/*
* menuBar.h
* systemMonitor
* Created on: 2012-2-19
* Author: zhushengben
*/
#ifndef MENUBAR_H_
#define MENUBAR_H_
#include
#include
static gint button_press(GtkWidget *, GdkEvent *);
static void menuitem_response(gchar *);
#define BACK_IMAGE ("3.jpg")
int createMenuBar(GtkWidget *vbox)
{
GtkWidget *menu;
GtkWidget *menu_bar;
GtkWidget *monitor_menu;
GtkWidget *edit_menu;
GtkWidget *view_menu;
GtkWidget *help_menu;
GtkWidget *menu_items;
char buf[128];
int i;
/* 初始化菜单构件,记住,永远也不要用
* gtk_show_widget() 来显示菜单构件。
* 这个是包含菜单项的菜单,当你在程序的"Root Menu"上点击时
* 它会弹出来 */
menu = gtk_menu_new();
update_widget_bg(menu,"3.jpg");
/* 创建一个新的菜单项,名称为... */
menu_items = gtk_menu_item_new_with_label("刷新模块");
/* ...并将它加到菜单。 */
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
/* 当菜单项被选中时做点有趣的事 */
g_signal_connect_swapped(G_OBJECT(menu_items), "activate", G_CALLBACK(
set_modul_info), NULL);
/* 显示构件 */
gtk_widget_show(menu_items);
menu_items = gtk_menu_item_new_with_label("装载模块");
/* ...并将它加到菜单。 */
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
/* 当菜单项被选中时做点有趣的事 */
g_signal_connect_swapped(G_OBJECT(menu_items), "activate", G_CALLBACK(
add_modul), NULL);
/* 显示构件 */
gtk_widget_show(menu_items);
menu_items = gtk_menu_item_new_with_label("卸载模块");
/* ...并将它加到菜单。 */
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
/* 当菜单项被选中时做点有趣的事 */
g_signal_connect_swapped(G_OBJECT(menu_items), "activate", G_CALLBACK(
remove_modul), NULL);
/* 显示构件 */
gtk_widget_show(menu_items);
/*
* 接着我们用一个小循环为"test-menu"产生三个菜单条目。
* 注意对 gtk_menu_append 的调用。这里我们将一序列的菜单项
* 加到我们的菜单上。通常,我们也捕获每个菜单项的"clicked"
* 信号并为它设置一个回调,不过在这里这个被省略了以节省空间。 */
for (i = 0; i < 3; i++)
{
/* 将名称复制到 buf. */
sprintf(buf, "版权所有", i);
/* 创建一个新的菜单项,名称为... */
menu_items = gtk_menu_item_new_with_label(buf);
/* ...并将它加到菜单。 */
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
/* 当菜单项被选中时做点有趣的事 */
g_signal_connect_swapped(G_OBJECT(menu_items), "activate", G_CALLBACK(
menuitem_response), g_strdup(buf));
/* 显示构件 */
gtk_widget_show(menu_items);
}
/* 这个是根菜单,将成为显示在菜单栏上的标签。
* 这里不会附上一个信号处理函数,因为它只是在
* 被按下时弹出其余的菜单。 */
monitor_menu = gtk_menu_item_new_with_label("监视器(M)");
edit_menu = gtk_menu_item_new_with_label("编辑(E)");
view_menu = gtk_menu_item_new_with_label("查看(V)");
help_menu = gtk_menu_item_new_with_label("帮助(H)");
gtk_widget_show(monitor_menu);
gtk_widget_show(edit_menu);
gtk_widget_show(view_menu);
gtk_widget_show(help_menu);
/* 现在我们指定我们想要让新创建的"menu"成
* 为"root menu"的菜单 */
gtk_menu_item_set_submenu(GTK_MENU_ITEM(monitor_menu), menu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit_menu), menu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_menu), menu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help_menu), menu);
/* 创建一个菜单栏以包含菜单,并将它加到主窗口
* 一个纵向盒子里: */
menu_bar = gtk_menu_bar_new();
update_widget_bg(menu_bar,"3.jpg");
// update_widget_bg(menu_bar, BACK_IMAGE);
gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 2);
gtk_widget_show(menu_bar);
/* 最后把菜单项添加到菜单栏上 -- 这就是我
* 咆哮了多次的“根”菜单项 =) */
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), monitor_menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), edit_menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view_menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help_menu);
return 0;
}
int createButtonMenu(GtkWidget *vbox)
{
GtkWidget *menu;
GtkWidget *menu_items;
GtkWidget *button;
/* 初始化菜单构件,记住,永远也不要用
* gtk_show_widget() 来显示菜单构件。
* 这个是包含菜单项的菜单,当你在程序的"Root Menu"上点击时
* 它会弹出来 */
menu = gtk_menu_new();
/* 创建一个新的菜单项,名称为... */
menu_items = gtk_menu_item_new_with_label("Sure to kill the process !!??");
/* ...并将它加到菜单。 */
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
/* 当菜单项被选中时做点有趣的事 */
g_signal_connect_swapped(G_OBJECT(menu_items), "activate", G_CALLBACK(
killProcess), NULL);
/* 显示构件 */
gtk_widget_show(menu_items);
/* 创建一个按钮,它带了一个弹出菜单 */
button = gtk_button_new_with_label(
"* * * * * * * * * * * * * * * * * * * * * * *");
/* 连接弹出菜单 */
g_signal_connect_swapped(G_OBJECT(button), "event",
G_CALLBACK(button_press), menu);
gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 2);
gtk_widget_show(button);
return 0;
}
/* 对鼠标按下作出回应,弹出 widget 变量传递进来的菜单。
* 注意"widget"参数是被传递进来的菜单,不是
* 被按下的按钮。
*/
static gint button_press(GtkWidget *widget, GdkEvent *event)
{
if (event->type == GDK_BUTTON_PRESS)
{
GdkEventButton *bevent = (GdkEventButton *) event;
gtk_menu_popup(GTK_MENU(widget), NULL, NULL, NULL, NULL,
bevent->button, bevent->time);
/* 告诉调用代码我们已经处理了这个事件;事件传播(buck)在
* 这里停止。 */
return TRUE;
}
/* 告诉调用代码我们没有处理这个事件;继续传播它。 */
return FALSE;
}
/* 当菜单项被选中时打印一个字符串 */
static void menuitem_response(gchar *string)
{
showAbout();
}
#endif /* MENUBAR_H_ */ /*
* progressBar.h
* systemMonitor
* Created on: 2012-2-19
* Author: zhushengben
*/
#ifndef PROGRESSBAR_H_
#define PROGRESSBAR_H_
typedef struct ProgressData
{
GtkWidget *pbar;
int timer;
gboolean activity_mode;
gboolean showCpuProgress;
} _ProgressData;
_ProgressData *pdata;
int createProgressBar(GtkWidget *vbox, gboolean activity_mode,
gboolean showCpuProgress)
{
GtkWidget *align;
GtkWidget *separator;
GtkWidget *table;
GtkWidget *button;
GtkWidget *check;
/* 为传递到回调函数中的数据分配内存 */
pdata = g_malloc(sizeof(_ProgressData));
pdata->showCpuProgress = showCpuProgress;
/* 创建进度条 */
pdata->pbar = gtk_progress_bar_new();
gtk_container_add(GTK_CONTAINER(vbox), pdata->pbar);
gtk_progress_bar_set_orientation(pbar_cpu, GTK_PROGRESS_BOTTOM_TO_TOP);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pdata->pbar), "running...");
pdata->activity_mode = activity_mode;
gtk_widget_show(pdata->pbar);
separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 0);
gtk_widget_show(separator);
return 0;
}
#endif /* PROGRESSBAR_H_ *//*
* refresh.h
* SystemMonitor
* Created on: 2012-2-21
* Author: zhushengben
*/
#ifndef REFRESH_H_
#define REFRESH_H_
/* 更新进度条,这样就能够看到进度条的移动 */
gint refresh(gpointer data)
{
/* cpu */
/* 建一个矩形绘图区 */
GdkGC *gc_chart = gdk_gc_new(cpu_draw_area->window);
// update_widget_bg(gc_chart, BACK_IMAGE);
/* 背景颜色 */
GdkColor color;
color.red = 0x0000;
color.green = 0x0000;
color.blue = 0x0000;
gdk_gc_set_rgb_fg_color(gc_chart, &color);
int width, height, curPoint, step;
cpu_rate = getCpuUseRatio() / 100;
gdk_draw_rectangle(cpu_graph, gc_chart, TRUE, 0, 0,
cpu_draw_area->allocation.width, cpu_draw_area->allocation.height);
width = cpu_draw_area->allocation.width;
height = cpu_draw_area->allocation.height;
curPoint = (int) (cpu_rate * (double) height);
cpuPoints[99] = height - curPoint;
int i;
for (i = 0; i < 99; i++)
{
/* 后一时刻的为前面取代 */
cpuPoints[i] = cpuPoints[i + 1];
}
step = width / 99;
GdkGC *gc = gdk_gc_new(GDK_DRAWABLE(cpu_graph));
gdk_color_parse("darkred", &color);
if (cpu_rate > 0.1)
gdk_color_parse("red", &color);
gdk_gc_set_foreground(gc, &color);
/* gdk_gc_set_line_attributes(GdkGC *gc,//
line_width,
GdkLineStyle line_style,
GdkCapStyle cap_style,
GdkJoinStyle join_style);
*/
gdk_gc_set_line_attributes(gc, 1, GDK_LINE_SOLID, GDK_CAP_ROUND,
GDK_JOIN_MITER);
for (i = 99; i >= 1; i--)
{
gdk_draw_line(GDK_DRAWABLE(cpu_graph), gc, i * step, cpuPoints[i], /* 第一个点坐标 */
(i - 1) * step, cpuPoints[i - 1]); /* 第二个点坐标 */
}
gtk_widget_queue_draw(cpu_draw_area);
char buffer[50] = "cpu使用率:\n\n";
char cbuf[5];
gcvt(cpu_rate * 100, 5, cbuf);
strcat(cbuf, "%");
strcat(buffer, cbuf);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pbar_cpu), buffer);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pbar_cpu), cpu_rate);
_ProgressData *pdata = (_ProgressData *) data;
gdouble new_val;
if (pdata->activity_mode)
gtk_progress_bar_pulse(GTK_PROGRESS_BAR(pdata->pbar));
else
{
if (!pdata->showCpuProgress)
{
/* 使用在调整对象中设置的取值范围计算进度条的值 */
new_val = gtk_progress_bar_get_fraction(GTK_PROGRESS_BAR(
pdata->pbar)) + 0.01;
if (new_val > 1.0)
new_val = 0.0;
}
else
new_val = cpu_rate;
/* 设置进度条的新值 */
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pdata->pbar), new_val);
}
set_label_mem_text();
set_label_proc_text(label_proc);
/* 这是一个 timeout 函数,返回 TRUE,这样它就能够继续被调用 */
return TRUE;
}
#endif /* REFRESH_H_ *//*
* searchInfor.h
* helloWorld
* Created on: 2012-2-19
* Author: zhushengben
*/
#ifndef SEARCHINFOR_H_
#define SEARCHINFOR_H_
#include
#include
#include
#include
#include
#include
#define MAX 1024
#define STANDARD 0
#define SHORT 1
#define LONG 2
/*
* 在指定的proc文件中查找所需要的内核信息,并将找到的字符串后面的信息输出
* pah:指定的proc文件的路径
* name:所要查找的内核信息
* infor:装载信息，已经转换为MB
* 内存信息
* more /proc/meminfo
* MemTotal: 2058448 kB
* MemFree: 52496 kB
* Buffers: 580832 kB
* Cached: 877024 kB
*/
void getInfor(char *path, char *name, char infor[])
{
int fd = open(path, O_RDONLY);
char store[2000];
int k = 0;
char *p = NULL;
read(fd, store, sizeof(store));
close(fd);
/* 取得所需要信息所在行首尾指针 */
p = strstr(store, name);
/* 跳过标题 */
while ((*p < '0') || (*p > '9'))
{
p++;
}
/* 读取数值 */
while ((*p >= '0') && (*p <= '9'))
{
infor[k] = *p;
k++;
p++;
}
infor[k] = '\0';
float fInfor = (float) atoi(infor);
fInfor = fInfor / 1024; //将单位化成MB
gcvt(fInfor, 5, infor); //换算后的存放在total中
}
/* 直接取空格后数值,没有转换尾MB的 */
void getInforAftSpace(char *path, char *name, char infor[])
{
int fd = open(path, O_RDONLY);
char store[2000];
int k = 0;
char *p = NULL;
read(fd, store, sizeof(store));
close(fd);
/* 取得所需要信息所在行首尾指针 */
p = strstr(store, name);
/* 跳过标题 */
while ((*p < '0') || (*p > '9'))
{
p++;
}
/* 读取数值 */
while ((*p >= '0') && (*p <= '9'))
{
infor[k] = *p;
k++;
p++;
}
infor[k] = '\0';
}
/* 获取cpu信息等 */
/*model name : Pentium(R) Dual-Core CPU T4400 @ 2.20GHz
*stepping : 10
*cpu MHz : 1200.000
*cache size : 1024 KB */
void getInforNotd(char *path, char *name, char infor[])
{
int fd = open(path, O_RDONLY);
char store[2000];
int k = 0;
char *p = NULL;
read(fd, store, sizeof(store));
close(fd);
/* 取得所需要信息所在行首尾指针 */
p = strstr(store, name);
/* 跳过标题 */
do
{
p++;
} while (*p != ':');
p += 2;
/* 读取数值 */
while (*p != '\n')
{
infor[k] = *p;
k++;
p++;
}
infor[k] = '\0';
}
void getSysVersion(char *path, char *name, char infor[])
{
int fd = open(path, O_RDONLY);
char store[2000];
int k = 0;
char *p = NULL;
read(fd, store, sizeof(store));
close(fd);
/* 取得所需要信息所在行首尾指针 */
p = strstr(store, name);
/* 读取数值 */
while (*p != '\n' && *p != ')')
{
infor[k] = *p;
k++;
p++;
}
infor[k++] = ')';
infor[k] = '\0';
}
/* 显示系统的平均负载的内容 */
int get_load_avg(char aveLoad[])
{
int fd;
int n, k = 0;
int res = -1;
char line_buf[50];
/* 打开存储系统平均负载的proc文件 */
if ((fd = open("/proc/loadavg", O_RDONLY)) == -1)
{
perror("fail to loadavg");
exit(-1);
}
/* 读取系统的平均负载的内容 */
if ((n = read(fd, line_buf, MAX)) == -1)
{
perror("fail to read");
goto err;
}
line_buf[n] = '/0';
n = 0;
while (line_buf[n] != '\n' && line_buf[n] != '\0')
{
aveLoad[k++] = line_buf[n++];
}
aveLoad[k] = '\0';
res = 0;
err: close(fd);
return res;
}
void read_info(char store[], int i, char get[])
{
int j = 0; //j表示的就是这个字符串的下标
int k = 0;
int cflags = 0; //用来记录空格的个数
char buf[20]; //用来保存需要的信息
while (cflags < i - 1)
{ //特别注意此处是i-1，否则输出的顺序都是乱的，因为需要在i之前的空格，所以是i-1，这样执行完才是i-1的空格
if (store[j++] == ' ')
cflags++;
}
while (store[j] != ' ')
{ //读取下一个空格之前的
buf[k++] = store[j];
j++;
}
buf[k] = '\0';
if (2 == i)
{//名称，去掉括号
int i, j = 0;
for (i = 1; ')' != buf[i]; i++)
{
get[j++] = buf[i];
}
get[j] = '\0';
}
else if (i == 3)
{//第三个是表示状态
if (!strcmp(buf, "S"))
strcpy(get, "睡眠中");
else if (!strcmp(buf, "R"))
strcpy(get, "运行中");
else if (!strcmp(buf, "T"))
strcpy(get, "已停止");
else if (!strcmp(buf, "D"))
strcpy(get, "不可中断");
else if (!strcmp(buf, "Z"))
strcpy(get, "死锁中");
/* 这里出现一个问题，想不通啊！
* 为什么上面两行不是放在if外面？
* 原来是if中= 和 == 混淆 */
//else strcpy(get,"奇怪！");
}
else
strcpy(get, buf);
}
#endif /* SEARCHINFOR_H_ */