proc3.c

类似如任务管理器的一个东西

/*gcc proc.c -o proc `pkg-config --cflags --libs gtk+-2.0`*/
#include <stdio.h>
#include <gtk/gtk.h>
#include <string.h>
#include <time.h>
#define NUM 100
#define NUM2 50

typedef struct _ProgressData {
  GtkWidget *pbar;
  int timer;
} ProgressData;
typedef struct _mm_used_Data {
  GtkWidget *label;
  int timer;
} mm_used_Data;

static GtkWidget *clocker,*clocker2;

char *readHost();
char *readOs();
void readCpu(char *cput,char *cpum);
gint progress_timeout( gpointer data );
char *read_mm_total();
gint read_mm_timeout( gpointer data );
void clock_begin();
void clock_run();

/*打开hostname文件,读取主机名子*/
char *readHost()
{
	FILE *host;
	char hostName[NUM];
	//打开hostname文件,读取主机名子
	if((host=fopen("/proc/sys/kernel/hostname","r"))==NULL){
		fprintf(stderr,"Can't open %s\n","/proc/sys/kernel/hostname");
		exit(-1);
	}else  fgets(hostName,NUM,host);
	fclose(host);
	static char newHost[NUM] = "hostname:  ";
	strcat(newHost,hostName);
	return newHost;
}
/*打开ostype和osrelease文件,读取系统版本*/
char *readOs()
{
	FILE *os1;
	FILE *os2;
	char osType1[NUM];
	char osType2[NUM2];
	//打开文件,读取系统版本号
	if((os1=fopen("/proc/sys/kernel/ostype","r"))==NULL){
		fprintf(stderr,"Can't open %s\n","/proc/sys/kernel/ostype");
		exit(-1);
	}else  fgets(osType1,6,os1);
	if((os2=fopen("/proc/sys/kernel/osrelease","r"))==NULL){
		fprintf(stderr,"Can't open %s\n","/proc/sys/kernel/release");
		exit(-1);
	}else  fgets(osType2,NUM,os2);
	fclose(os1);
	fclose(os2);
	strcat(osType1,"  ");
	strcat(osType1,osType2);
	static char newOs[NUM] = "system version:  ";
	strcat(newOs,osType1);
	return newOs;
}   
/*打开cpuinfo文件,读取CPU型号和主频*/
void readCpu(char *cput,char *cpum)
{
	FILE *cpu;
	int i;
	//打开cpuinfo文件,读取CPU型号和主频
	if((cpu=fopen("/proc/cpuinfo","r"))==NULL){
		fprintf(stderr,"Can't open %s\n","/proc/cpuinfo");
		exit(-1);
	}else{
		for(i=0;fgets(cput,NUM2,cpu)!=NULL&&i<4;i++);
		for(;fgets(cpum,20,cpu)!=NULL&&i<5;i++);
	}
	char *cpuT = cput;
	char *cpuM = cpum;
	char *cpuTemp1 = strchr(cpuT,':');
	char *cpuTemp2 = strchr(cpuM,':');
        cpuTemp1++;
	cpuTemp2++;
	char newCpu1[NUM] = "";
	char newCpu2[NUM] = "";
	strcat(newCpu1,cpuTemp1);
	strcat(newCpu2,cpuTemp2);
	strcpy(cput,newCpu1);
	strcpy(cpum,newCpu2);
	strcat(cpum,"  MHz");
	fclose(cpu);
}

/* 更新进度条，这样就能够看到进度条的移动 */
gint progress_timeout( gpointer data )
{
 	ProgressData *pdata = (ProgressData *)data;

  	//gtk_progress_bar_pulse(GTK_PROGRESS_BAR(pdata->pbar));
        gdouble new_val;
  
  	/*使用在调整对象中设置的取值范围计算进度条的值*/
        new_val = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (pdata->pbar)) + 0.1;
      
  	if (new_val > 1.0)      new_val = 0.0;
      
  	/*设置进度条的新值*/
  	gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (pdata->pbar), new_val);

	gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pdata->pbar), "progress");
    
  	/*这是一个timeout函数，返回 TRUE，这样它就能够继续被调用*/
  	return TRUE;
} 
/* 清除分配的内存，删除定时器(timer) */
void destroy_progress( GtkWidget *widget, ProgressData *mdata )
{
    gtk_timeout_remove (mdata->timer);
    mdata->timer = 0;
    g_free (mdata);
    gtk_main_quit ();
}

/*读取内存的信息,返回的信息是共有多少内存*/
char *read_mm_total()
{
	FILE *mm;
	int i;
	char mmT[NUM2];
	//打开mminfo文件,读取已用内存信息
	if((mm=fopen("/proc/meminfo","r"))==NULL){
		fprintf(stderr,"Can't open %s\n","/proc/meminfo");
		exit(-1);
	}else{
		for(i=0;fgets(mmT,NUM2,mm)!=NULL&&i<5;i++);	
	}
	static char mm_total[NUM] = "内存总数 :";
        char *mmTemp1 = strchr(mmT,':');
	mmTemp1 += 7;
	strcat(mm_total,mmTemp1);
	fclose(mm);
	return mm_total;
}

/*读取内存的使用信息*/
gint read_mm_timeout( gpointer data )
{
	mm_used_Data *mdata = (mm_used_Data *)data;
	FILE *mm;
	int i;
	char mmT[NUM2];
	/*打开mminfo文件,读取已用内存信息*/
	if((mm=fopen("/proc/meminfo","r"))==NULL){
		fprintf(stderr,"Can't open %s\n","/proc/meminfo");
		exit(-1);
	}else{
		for(i=0;fgets(mmT,NUM2,mm)!=NULL&&i<11;i++);	
	}
	char *mmTemp1 = strchr(mmT,':');
	char mm_used[NUM] = "已用内存 :";
	mmTemp1 += 10;
	strcat(mm_used,mmTemp1);
	gtk_label_set_text( GTK_LABEL(mdata->label), mm_used );
	fclose(mm);
	return TRUE;
}

/*更新当前时间*/
void clock_begin()
{   
	time_t now;
 	struct tm *l_time;
 	gchar buf[NUM];
 	now=time((time_t *)NULL);
 	l_time=localtime(&now);
      	sprintf(buf,"system time:%d:%d:%d",l_time->tm_hour,l_time->tm_min,l_time->tm_sec);
 	gtk_label_set_text(GTK_LABEL(clocker),buf);
}

/*更新系统运行时间*/
void clock_run()
{          
	long int runtime;
        int  hour,min,sec;
        FILE *uptime;
	char timeT[NUM2];
	/*打开mminfo文件,读取已用内存信息*/
	if((uptime=fopen("/proc/uptime","r"))==NULL){
		fprintf(stderr,"Can't open %s\n","/proc/uptime");
		exit(-1);
           }
        fgets(timeT,8,uptime);
 	runtime=strtol(timeT,NULL,0);
        hour=runtime/3600;
        min=(runtime-hour*3600)/60;
        sec=runtime-hour*3600-min*60;
 	gchar buf[NUM]; 	 	
      	sprintf(buf,"run time:%d:%d:%d",hour,min,sec);
 	gtk_label_set_text(GTK_LABEL(clocker2),buf);
}


/* 向文本构件中添加一些文本 - 这是当窗口被实例化(realized)时调用的回调函数。
 * 我们也可以用 gtk_widget_realize 强行将窗口实例化，但这必须在它的层次关系
 *  确定后(be part of a hierarchy)才行。 
 */
void insert_text (GtkTextBuffer *buffer)
{
   GtkTextIter iter;
 
   gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);

   gtk_text_buffer_insert (buffer, &iter,   
    "hi,这是一个任务管理器\n"
    "上面显示的是主机名,版本,cpu\n"
    "型号和主频等信息\n"
    "下面显示cpu和内存的一些信息\n" 
    "还有时间显示\n", -1);
}
   
/* 创建一个滚动文本区域，用于显示一个"信息" */
GtkWidget *create_text( void )
{
   GtkWidget *scrolled_window;
   GtkWidget *view;
   GtkTextBuffer *buffer;

   view = gtk_text_view_new ();
   gtk_text_view_set_editable (GTK_TEXT_VIEW (view), FALSE);
   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));

   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_container_add (GTK_CONTAINER (scrolled_window), view);
   insert_text (buffer);

   gtk_widget_show_all (scrolled_window);

   return scrolled_window;
}
   
int main( int   argc, char *argv[] )
{
    GtkWidget *window;
    GtkWidget *vpaned;
    GtkWidget *label;
    GtkWidget *label2;
    GtkWidget *notebook;
    GtkWidget *frame;
    GtkWidget *text;
    GtkWidget *table;
    GtkWidget *table1;
    GtkWidget *table2;
    GtkWidget *cpu_table;
    GtkWidget *mm_table;
    GtkWidget *swap_table;
    GtkWidget *align;
    GtkWidget *separator;
    GtkWidget *vbox;
    ProgressData *pdata;
    mm_used_Data *mdata;
    
    gtk_init (&argc, &argv);

    /* 为传递到回调函数中的数据分配内存 */
    pdata = g_malloc (sizeof (ProgressData));
    mdata = g_malloc (sizeof (mm_used_Data));
   
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title (GTK_WINDOW (window), "任务管理器");
    g_signal_connect (G_OBJECT (window), "destroy",
	              G_CALLBACK (destroy_progress),
                      pdata);
    gtk_container_set_border_width (GTK_CONTAINER (window), 15);
    gtk_widget_set_size_request (GTK_WIDGET (window), 260, 320);

    /* 在顶级窗口上添加一个垂直分栏窗口构件 */
   
    vpaned = gtk_vpaned_new ();
    gtk_container_add (GTK_CONTAINER (window), vpaned);
    gtk_widget_show (vpaned);
   
    /* 在分栏窗口的两部分各添加一些构件 */
   
    table = gtk_table_new(2,1,TRUE);
    gtk_widget_show (table);
    gtk_paned_add2 (GTK_PANED (vpaned), table);
   
    notebook = gtk_notebook_new();
    gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook),GTK_POS_TOP);
    
    gtk_table_attach_defaults(GTK_TABLE(table),notebook,0,1,0,1);
    gtk_widget_show (notebook);

     /*创建一个文本区域用来显示一些信息*/
    text = create_text();
    gtk_paned_add1 (GTK_PANED (vpaned), text);
    gtk_widget_show (text);
  
    char buf[80];
    frame=gtk_frame_new(buf);
    gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
    gtk_widget_show (frame);
 
    char *hostName = readHost();//读取主机名
    label2= gtk_label_new (hostName);
    gtk_container_add (GTK_CONTAINER (frame), label2);
    gtk_widget_show (label2);
    
    label2= gtk_label_new ("主机号");
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook),frame, label2);

    frame=gtk_frame_new(buf);
    gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
    gtk_widget_show (frame);
 
    char *osType = readOs();//读取系统版本
    label2= gtk_label_new (osType);
    gtk_container_add (GTK_CONTAINER (frame), label2);
    gtk_widget_show (label2);
    
    label2= gtk_label_new ("系统版本");
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook),frame, label2);

    frame=gtk_frame_new(buf);
    gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
    gtk_widget_show (frame);
 
    char cpuType[NUM];
    char cpuMH[NUM];
    readCpu(cpuType,cpuMH);//读取CPU版本和型号

    label2= gtk_label_new (cpuType);
    gtk_container_add (GTK_CONTAINER (frame), label2);
    gtk_widget_show (label2);
    
    label2= gtk_label_new ("CPU型号");
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook),frame, label2);

    frame=gtk_frame_new(buf);
    gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
    gtk_widget_show (frame);

    label2= gtk_label_new (cpuMH);
    gtk_container_add (GTK_CONTAINER (frame), label2);
    gtk_widget_show (label2);
    
    label2= gtk_label_new ("CPU主频");
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook),frame, label2);
 
    gtk_notebook_set_page(GTK_NOTEBOOK(notebook),2);

    /*table2用来容纳4个信息,分别是cpu使用情况,内存使用情况,交换使用情况和当前时间*/
    table2 = gtk_table_new(5,1,TRUE);
    gtk_table_attach_defaults(GTK_TABLE(table),table2, 0,1,1,2);    
    gtk_widget_show (table2);

    /*cpu_table用来容纳一个label和一个bar,显示cpu的使用情况*/  
    cpu_table = gtk_table_new(1,2,TRUE);
    gtk_table_attach_defaults(GTK_TABLE(table2),cpu_table, 0,1,1,2);    
    gtk_widget_show (cpu_table);  

    label = gtk_label_new ("CPU使用情况:");
    gtk_widget_show (label);
    gtk_table_attach_defaults(GTK_TABLE(cpu_table),label, 0,1,0,1);     

    /* 创建进度条 */
    pdata->pbar = gtk_progress_bar_new ();
    gtk_table_attach_defaults(GTK_TABLE(cpu_table),pdata->pbar, 1,2,0,1); 
    gtk_widget_show (pdata->pbar);

    /* 加一个定时器(timer)，以更新进度条的值 */
    pdata->timer = gtk_timeout_add (100, progress_timeout, pdata);

    /*mm_table用来容纳两个label,显示内存的使用情况*/  
    mm_table = gtk_vbox_new(FALSE,0);
    gtk_table_attach_defaults(GTK_TABLE(table2),mm_table, 0,1,3,5);    
    gtk_widget_show (mm_table);  

    /*创建一个label,显示总的内存量*/
    char *mmTotal = read_mm_total();
    label = gtk_label_new (mmTotal);
    gtk_widget_show (label);
    gtk_box_pack_start (GTK_BOX(mm_table), label, TRUE, TRUE, 0);

    mdata->label = gtk_label_new ("已用内存: ");
    gtk_widget_show (mdata->label);
    gtk_box_pack_start (GTK_BOX(mm_table), mdata->label, TRUE, TRUE, 0);
    /* 加一个定时器(timer)，以更新内存使用的值 */
    mdata->timer = gtk_timeout_add (500, read_mm_timeout, mdata);

     /*创建一个hbox来显示系统当前时间*/
    clocker = gtk_label_new("");
    gtk_widget_show (clocker); 
    gtk_table_attach_defaults(GTK_TABLE(table2),clocker, 0,1,5,6); 
    gtk_timeout_add(1000,(GtkFunction)clock_begin,NULL);//超时函数

    /*创建一个hbox来显示系统运行时间*/
    clocker2 = gtk_label_new("");
    gtk_widget_show (clocker2); 
    gtk_table_attach_defaults(GTK_TABLE(table2),clocker2, 0,1,6,7); 
    gtk_timeout_add(1000,(GtkFunction)clock_run,NULL);//超时函数

    gtk_widget_show (table);    
    gtk_widget_show (window);

    gtk_main ();

    return 0;
}