proc.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);
}

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

  	//gtk_progress_bar_pulse(GTK_PROGRESS_BAR(pdata->pbar));
  
  	/*使用在调整对象中设置的取值范围计算进度条的值*/
        new_val = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (pdata->pbar)) + 0.05;
  	if (new_val > 0.7)      new_val = 0.4;
      
  	/*设置进度条的新值*/
  	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);
}

void entry_callback( GtkWidget *widget,GtkWidget *entry )
{      
	FILE *state;
	const gchar *entry_text;
	int i;
	char buf[10*NUM];//用来存放该进程的详细信息
	char line_buf[NUM];
	entry_text = gtk_entry_get_text (GTK_ENTRY (entry));//取得用户输入的内容
	char file[NUM2] = "/proc/";//构造该进程的文件目录
	strcat(file,entry_text);
	strcat(file,"/status");
	printf("file:%s\n",file);		/*for debug*/
	if((state=fopen(file,"r"))!=NULL){
                for(i=0;fgets(line_buf,NUM,state)!=NULL&&i<10;i++){
			strcat(buf,line_buf);
			strcat(buf,"\n");                
		}
		//gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)),buf, -1);
                printf("%s",buf);		
	}else{    
		//gtk_text_buffer_set_text(gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)),
			     //  "Can't find the thread!\n", -1);
                printf("Can't find the thread!\n");
	}
	fclose(state);
}

/* 向文本构件中添加一些文本 - 这是当窗口被实例化(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 *table3;  
    GtkWidget *cpu_table;
    GtkWidget *mm_table;
    GtkWidget *swap_table;
    GtkWidget *align;
    GtkWidget *entry;
    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), 280, 400);

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

    table3 = gtk_table_new(5,1,TRUE);
    gtk_widget_show (table3);
    gtk_paned_add1 (GTK_PANED (vpaned), table3);

   /*创建一个文本区域用来显示一些信息*/
    text = create_text();
    gtk_table_attach_defaults(GTK_TABLE(table3),text,0,1,0,3);
    gtk_widget_show (text);
  
    /* 创建一个居中对齐的对象 */
    align = gtk_alignment_new (0.5, 0.5, 0, 0);
    gtk_table_attach_defaults(GTK_TABLE(table3),align,0,1,3,4);
    gtk_widget_show (align);

    table1 = gtk_table_new(1,2,TRUE);
    gtk_container_add (GTK_CONTAINER (align), table1);
    gtk_widget_show (table1);
 
    label = gtk_label_new ("搜索进程:");
    gtk_label_set_justify( GTK_LABEL(label), GTK_JUSTIFY_LEFT );//设置对齐方式
    gtk_widget_show (label);
    gtk_table_attach_defaults(GTK_TABLE(table1),label,0,1,0,1);
    entry = gtk_entry_new();
    gtk_table_attach_defaults(GTK_TABLE(table1),entry,1,2,0,1);
    gtk_widget_show (entry);
    /*文本框在回车键的时候会发出'activate'信号，因此可以捕捉这个信号来显示进程信息*/
                      
      gtk_signal_connect (GTK_OBJECT(entry), "activate",
                               GTK_SIGNAL_FUNC(entry_callback),entry);

    separator = gtk_hseparator_new ();
    gtk_table_attach_defaults(GTK_TABLE(table3),separator,0,1,4,5);
    gtk_widget_show (separator);

    /*建个notebook的构件*/
    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,2);
    gtk_widget_show (notebook);
   
    /*加入第一个页面*/
    frame=gtk_frame_new("HostName");
    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("OSVersion");
    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("CPUType");
    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("CPU MHz");
    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,2,5);    
    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);

     /*创建一个label来显示系统当前时间*/
    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);

    /*创建一个label来显示系统运行时间*/
    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;
}