monitor.c

Linux下利用GTK编写的仿windows任务管理器的源代码

{
  vbox = gtk_vbox_new (FALSE, 0);//添加纵向盒子
  gtk_widget_show (vbox);
  gtk_container_add (GTK_CONTAINER(notebook), vbox);//加到笔记本容器中
  
  frame = gtk_frame_new ("CPU Information:");//显示CPU信息边框
  gtk_widget_show (frame);
  gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 10);//加到纵向盒子里

  info = g_string_new ("");
  get_cpu_info (info);//用 info变量存储获得的cpu信息
  
  info_label = gtk_label_new (info->str);//用标签info_label显示info变量的字符串内容
  gtk_widget_show (info_label);
  gtk_container_add (GTK_CONTAINER(frame), info_label);//将该标签加到边框中
  
  frame = gtk_frame_new ("OS Information:");//显示操作系统信息边框
  gtk_widget_show (frame);
  gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 30);//加到纵向盒子里
  
  info = g_string_new ("");
  get_os_info (info);//用 info变量存储获得的操作系统信息
  
  info_label = gtk_label_new (info->str);//用标签info_label显示info变量的字符串内容
  gtk_widget_show (info_label);
  gtk_container_add (GTK_CONTAINER(frame), info_label);//将该标签加到新边框中
  
  label = gtk_label_new ("SysInfo");//系统信息的页标签
  gtk_widget_show (label);
  gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook),
  		gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook),2), label);
//增加到笔记本为该页标签
}

void get_process_info (GtkListStore *store)//获得进程相关信息的函数
{
  DIR *dir;
  struct dirent *entry;
  int fd, i,num = 0;
  gchar dir_buf[256];	
  gchar buffer[128];
  gchar *info[26];
  gchar *delim = " ";
  GtkTreeIter iter;
  gdouble pcuser[PMAX];
  gdouble srate;
  gchar rate_buffer[16];
  gdouble mem;
  gchar mem_buffer[16];
  
  dir = opendir ("/proc");//打开/proc目录，dir为返回的指针
  while ((entry = readdir (dir)) != NULL ) {
	if ((entry->d_name[0] >= '0') && (entry->d_name[0] <= '9')) {
		sprintf (dir_buf, "/proc/%s/stat", entry->d_name);//读取文件到dir_buf中
		fd = open (dir_buf, O_RDONLY);
		read (fd, buffer, sizeof (buffer));
		close (fd);	
        
		info[0] =  strtok (buffer, delim);//以delim分隔符切割buffer的一部分到info［0］
		for (i = 1; i < 26 ; i++) {
			info[i] = strtok (NULL, delim);//查找整个buffer字符串
		}
		pcuser[num] = atoi (info[13]);//转换字符串为长整数
		srate = (pcuser[num]-pfuser[num]) / (2 * total);//cpu利用占总cpu使用的百分比
                if(srate<0||srate>1){srate=0;}
		sprintf (rate_buffer, "%.2f%%",100 * srate);
		
		mem = atoi (info[22]);//该进程的内存使用量
		mem = mem / (1024 * 1024);
		sprintf (mem_buffer, "%-.2f MB",mem);
		
		gtk_list_store_append (store, &iter);//增加到列表
		gtk_list_store_set (store, &iter,
					NAME_COLUMN,info[1],
					PID_COLUMN,info[0],
					STATUS_COLUMN,info[2],
					CPU_COLUMN,rate_buffer,
					MEMORY_COLUMN,mem_buffer,
					-1);
		pfuser[num] = pcuser[num];
  		num = (num + 1 ) % PMAX;
		}
	}
  closedir (dir);
}	


	

void get_cpu_info(GString *string)//获得cpu信息
{
  int fd,i;
  gchar buffer[1024];								
  gchar *delim = "\n";
  gchar *cpu_info[17];
  gchar *tmp;
	
  fd = open ("/proc/cpuinfo", O_RDONLY);//读取cpu相关信息的文件
  read (fd, buffer, sizeof (buffer));
  close (fd);

  cpu_info[0] = strtok (buffer, delim);
  for (i=1; i < 17 ; i++) {
		cpu_info[i] = strtok (NULL,delim);//分割字符串
  }	  
  for (i=0; i < 17; i++) {
  	  	tmp = strstr (cpu_info[i], ":");//忽略冒号:
		tmp += 2; 
        cpu_info[i] = tmp;	  
 }
  
  g_string_append (string, "CPUs          :");//显示相关信息
  g_string_append (string, cpu_info[0]);
  g_string_append_c (string, '\n');
  g_string_append (string, "Model name    :");
  g_string_append (string, cpu_info[4]);
  g_string_append_c (string, '\n');
  g_string_append (string, "CPU MHz       :");
  g_string_append (string, cpu_info[6]);
  g_string_append_c (string, '\n');
  g_string_append (string, "Cache size    :");
  g_string_append (string, cpu_info[7]);
  g_string_append_c (string, '\n');
}


void get_os_info (GString *string)//获得操作系统相关信息
{
	int fd,i;
      gchar buffer[128];		
      gchar *tmp,*start,*stop;					
	gchar *os_info[8];
	gchar *delim = " ";
	
	fd = open ("/proc/version", O_RDONLY);//读取操作系统相关信息的文件
	read(fd, buffer, sizeof (buffer));
	
	start = buffer;
	stop = strstr (buffer, "#");
	stop--;
	stop--;
	os_info[0] = strtok (buffer, delim);
	for (i = 1; i < 8; i++) {
		os_info[i] = strtok (NULL, delim);//分割字符串
		
	}
	
	g_string_append (string, "Os          :");//显示相关信息
	g_string_append (string, os_info[0]);
	g_string_append_c (string, '\n');
	g_string_append (string, "Rrelease   :");
      g_string_append (string, os_info[2]);
      g_string_append_c (string, '\n');
      g_string_append (string, "Domain      :");
      g_string_append (string, os_info[3]);
  	g_string_append_c (string, '\n');
      g_string_append (string, "Gcc version :");
  	g_string_append (string, os_info[6]);
	g_string_append_c (string, ' ');
      g_string_append (string, os_info[7]);
      g_string_append_c (string, '\n'); 	
}


void draw_cpu_load_graph (void)//画cpu使用的动态图
{
   int fd,i;
   gchar buffer[64];
   gint width,height,current,step;
   guint context_id;
   
   sprintf (buffer, "CPU using rate:%.2f%%\0",100 * rate);//CPU总利用率
   context_id = gtk_statusbar_get_context_id (GTK_STATUSBAR (status_bar),"cpu");
   //获得新的上下文标识符


   gtk_statusbar_push (GTK_STATUSBAR (status_bar), context_id, buffer);//将信消息加到状态栏
   

    //清除原先的图像
   gdk_draw_rectangle (GDK_DRAWABLE (cgraph), window->style->white_gc, 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;

   current = (int)(rate*(double)height);//根据当前cpu利用率决定显示高度
   cpu_graph[DENSITY-1] = height - current;  //从右向左移动
   for ( i = 0 ; i < DENSITY - 1 ; i ++) {
	  	cpu_graph[i] = cpu_graph[i+1];
   }

   step = width/DENSITY;//画图步宽
   
   for (i = DENSITY - 1; i >= 1 ; i -- ) {//循环进行画图工作
 		gdk_draw_line (cgraph, window->style->black_gc,//用很短的直线代替点
  	  							i * step,
  	  							cpu_graph[i],
  	  							(i - 1) * step,
  	  							cpu_graph[i-1]);
   }

   gtk_widget_queue_draw (cpu_draw_area);	//窗口立即强制重绘
}




void draw_mem_load_graph (void)//画内存使用率的的动态图
{
  int fd,i;
  gint mem_total,mem_free,swap_total,swap_free;
  gchar buffer[512];	
  gchar mem_tmp[19][16];
  gchar *start,*stop,*tmp;
  gint width,height,current,step;
  GString *string;
	
  fd = open ("/proc/meminfo", O_RDONLY);//读取内存信息
  read (fd, buffer, sizeof (buffer));
  stop = buffer;
  for (i = 0; i < 19; i++) {
  	start = strstr (stop, ":");//从开始到以冒号为结束符的stop的一部分字符到start
  	start++;
  	stop = strstr (start, "kB");//从开始到以"KB"为结束符的start的一部分字符到stop
  	stop--;
  	tmp = mem_tmp[i];
  	while (start != stop) {
		  	*tmp++ = *start++;  
  	}
  	*tmp = '\0';
  }
  mem_total = atoi (mem_tmp[0]);//内存总量
  mem_free = atoi (mem_tmp[1]);//剩余内存
  

  string = g_string_new ("");//刷新数字形式的内存相关信息
  g_string_append (string, "Total Memory :");
  g_string_append (string, mem_tmp[0]);
  g_string_append (string, " kB");
  g_string_append (string, "   ");
  g_string_append (string, "Free Memory  :");
  g_string_append (string, mem_tmp[1]);
  g_string_append (string, " kB");
  g_string_append_c (string, '\n');
  gtk_label_set_text (GTK_LABEL (mem_label), string->str);//显示到标签上
  g_string_free (string, TRUE);


  string = g_string_new ("");//用于存储页面文件信息
  g_string_append (string, "Total Swap   :");
  g_string_append (string, mem_tmp[11]);
  g_string_append (string, " kB");
  g_string_append (string, "   ");
  g_string_append (string, "Free Swap    :");
  g_string_append (string, mem_tmp[12]);
  g_string_append (string, " kB");
  g_string_append_c (string, '\n');
  gtk_label_set_text (GTK_LABEL (swap_label), string->str);//显示到标签上
  g_string_free (string, TRUE);
  

   //清除先前的图像
  gdk_draw_rectangle (mgraph, window->style->white_gc, TRUE, 0, 0,
  									mem_draw_area->allocation.width,
  									mem_draw_area->allocation.height);

  width = mem_draw_area->allocation.width;//获得原区域的宽度和高度
  height = mem_draw_area->allocation.height;
  current = ((float)(mem_total-mem_free)/(float)mem_total) * height;//根据当前内存利用率决定显示高度
  mem_graph[DENSITY-1] = height - current; //从右向左移动
  for ( i = 0 ; i < DENSITY - 1 ; i ++) {
	  	mem_graph[i] = mem_graph[i+1];
  }
  step = width / DENSITY;//画图步宽

  for (i = DENSITY - 1; i >= 1 ; i -- ) {//循环进行画图工作
  		gdk_draw_line (mgraph, window->style->black_gc,//用很短的直线代替点
  	  							i * step,
  	  							mem_graph[i],
  	  							(i - 1) * step,
  	  							mem_graph[i-1]);
  }
  gtk_widget_queue_draw ( mem_draw_area);	//窗口立即强制重绘
}




void prefresh_button_clicked (gpointer data)//刷新按钮被点击，刷新进程相关信息
{
  gtk_list_store_clear (process_store);
  get_process_info (process_store);	
}




void pdelete_button_clicked (gpointer data)//kill按钮被点击，停止一个进程的运行
{
  GtkTreeSelection *selection;
  GtkTreeModel *model;
  GtkTreeIter iter;
  gchar *pid;
  pid_t pid_num;

  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ptree_view));//获得当前选择的项
  if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
		gtk_tree_model_get (model, &iter, PID_COLUMN, &pid, -1);//在树的相应列中获得该进程的PID
  		pid_num = atoi (pid);//字符串转换成长整数
	    
	    if(kill (pid_num, SIGTERM) == -1 ) {//根据PID结束该进程
			gchar *title = "ERROR";
			gchar *content = "Termination Failed,Check UID";
			show_dialog (title, content);//结束进程失败信息输出
		}
	    gtk_list_store_clear (process_store);//刷新进程信息
	    get_process_info (process_store);	
  }
}


//用于窗口大小改变后的cpu使用率动态图的更新
gboolean cpu_configure_event (GtkWidget *widget, GdkEventConfigure *event, gpointer data)
{
  if (cgraph) {
  		g_object_unref (cgraph);
  }

   //根据原画图区数据创建一个pixmap构件
  cgraph = gdk_pixmap_new (widget->window,
  					widget->allocation.width, widget->allocation.height,-1);

  //在该pixmap构件中重新绘制图形
  gdk_draw_rectangle (cgraph, widget->style->white_gc, TRUE, 0, 0,
					widget->allocation.width, widget->allocation.height);
  return TRUE;
}



//用于暴光事件，开始绘制图形
gboolean cpu_expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
  gdk_draw_drawable (widget->window,
				widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
		     	cgraph,
		     	event->area.x, event->area.y,
		     	event->area.x, event->area.y,
		      event->area.width, event->area.height);
  return TRUE;
}


//用于窗口大小改变后的内存使用率动态图的更新
gboolean mem_configure_event (GtkWidget *widget, GdkEventConfigure *event, gpointer data)
{
  if (mgraph) {
  		g_object_unref (mgraph);
  }

   //根据原画图区数据创建一个pixmap构件
  mgraph = gdk_pixmap_new (widget->window,
  					widget->allocation.width, widget->allocation.height,-1);

  //在该pixmap构件中重新绘制图形
  gdk_draw_rectangle (mgraph, widget->style->white_gc, TRUE, 0, 0,
					widget->allocation.width, widget->allocation.height);
  return TRUE;
}


//用于暴光事件，开始绘制图形
gboolean mem_expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
  gdk_draw_drawable (widget->window,
			widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
		     	mgraph,
		     	event->area.x, event->area.y,
		     	event->area.x, event->area.y,
		      event->area.width, event->area.height);
  return TRUE;
}



void show_dialog (gchar *title, gchar *content)//显示一个对话框，标题title，内容为content
{
	GtkWidget *dialog;
	GtkWidget *label;
    dialog = gtk_dialog_new_with_buttons (title,
                                         GTK_WINDOW (window),
                                         GTK_DIALOG_DESTROY_WITH_PARENT,
                                         GTK_STOCK_CLOSE,
                                         GTK_RESPONSE_NONE,
                                         NULL);//创建一个对话框构件
	gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);//不可改变大小
	g_signal_connect_swapped (dialog,
                             "response", 
                             G_CALLBACK (gtk_widget_destroy),
                             dialog);//事件回调函数为退出	
	
	label = gtk_label_new (content);//创建一个标签，显示content的内容
	gtk_widget_show (label);
	gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
                      label);			  
	gtk_widget_show (dialog);
}