mem.c

系统任务管理器

			w_scroll = w;
		}
	if (!mon_in_motion)
		{
		if (w_scroll > mem.decal_label->w)
			x_scroll = (x_scroll + ((gkrellm_update_HZ() < 7) ? 2 : 1))
						% (w_scroll - mem.decal_label->w / 3);
		else
			x_scroll = 0;
		}
	gkrellm_draw_panel_layers(mem.panel);
	gkrellm_draw_panel_layers(swap.panel);
	}

static gint
meminfo_expose_event(GtkWidget *widget, GdkEventExpose *ev)
	{
	GdkPixmap	*pixmap	= NULL;

	if (widget == mem.panel->drawing_area)
		pixmap = mem.panel->pixmap;
	else if (widget == swap.panel->drawing_area)
		pixmap = swap.panel->pixmap;
	else if (swap_chart.chart && widget == swap_chart.chart->drawing_area)
		pixmap = swap_chart.chart->pixmap;
	if (pixmap)
		gdk_draw_drawable(widget->window, gkrellm_draw_GC(1), pixmap,
				ev->area.x, ev->area.y, ev->area.x, ev->area.y,
				ev->area.width, ev->area.height);
	return FALSE;
	}

static gint
cb_panel_enter(GtkWidget *w, GdkEventButton *ev, MeminfoMeter *mm)
	{
	if (mm->label_is_data)
		mm->mouse_entered = TRUE;
	return FALSE;
	}

static gint
cb_panel_leave(GtkWidget *w, GdkEventButton *ev, MeminfoMeter *mm)
	{
	mm->mouse_entered = FALSE;
	return FALSE;
	}

static gint
cb_panel_release(GtkWidget *widget, GdkEventButton *ev)
	{
    if (ev->button == 3)
		return FALSE;
	if (mon_in_motion)
		{
		if (mon_in_motion->restore_label)
			{
			if (mon_in_motion->label_is_data)
				gkrellm_config_modified();
			mon_in_motion->label_is_data = FALSE;
			draw_decal_label(mon_in_motion, 1);
			}
		mon_in_motion->restore_label = TRUE;
		}
	mon_in_motion = NULL;
	x_moved = FALSE;
	return FALSE;
	}

static gint
cb_panel_press(GtkWidget *widget, GdkEventButton *ev, MeminfoMeter *mm)
    {
	if (ev->button == 3)
		{
		gkrellm_open_config_window(mon_mem);
		return FALSE;
		}
	if (   ev->button == 1 && mm->launch.button
		&& gkrellm_in_decal(mm->launch.button->decal, ev)
	   )
		return FALSE;
	if (widget == mem.panel->drawing_area)
		mon_in_motion = &mem;
	else if (widget == swap.panel->drawing_area)
		mon_in_motion = &swap;
	else
		return FALSE;
	if (! mon_in_motion->label_is_data)
		{
		mon_in_motion->label_is_data = TRUE;
		mon_in_motion->restore_label = FALSE;
		mon_in_motion->mouse_entered = TRUE;
		gkrellm_config_modified();
		}
	x_mon_motion = ev->x;
	draw_decal_label(mon_in_motion, 1);
	x_moved = FALSE;
	return FALSE;
	}

static gint
cb_panel_motion(GtkWidget *widget, GdkEventButton *ev)
	{
	GdkModifierType	state;
	GkrellmDecal	*d;
	PangoFontDescription *font_desc;
	gchar			buf[128];
	gint			w, x_delta;

	state = ev->state;
	if (   ! mon_in_motion
		|| ! (state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK))
		|| ! mon_in_motion->label_is_data
	   )
		{
		mon_in_motion = NULL;
		return FALSE;
		}
	d = mon_in_motion->decal_label;
	font_desc = gkrellm_meter_alt_textstyle(mon_in_motion->style_id)->font;

	format_meminfo_data(mon_in_motion, mon_in_motion->data_format_shadow,
				buf, sizeof(buf));
	w = gkrellm_gdk_string_width(font_desc, buf);
	if (w > d->w)
		{
		x_delta = ev->x - x_mon_motion;
		x_mon_motion = ev->x;
		d->x_off += x_delta;
		if (d->x_off < -w)
			d->x_off = -w;
		if (d->x_off > d->w)
			d->x_off = d->w;
		x_scroll = d->w / 3 - d->x_off;
		if (mem.label_is_data)
			draw_decal_label(&mem, 1);
		if (swap.label_is_data)
			draw_decal_label(&swap, 1);
		mon_in_motion->restore_label = FALSE;
		}
	x_moved = TRUE;
	return FALSE;
	}

static void
setup_scaling(GkrellmChartconfig *cf, MeminfoChart *mc)
	{
	GkrellmChart	*cp	  = mc->chart;
	gint	res   = DEFAULT_GRID_RES,
			grids = FULL_SCALE_GRIDS;

	if (cp)
		{
		grids = gkrellm_get_chartconfig_fixed_grids(cp->config);
		res = gkrellm_get_chartconfig_grid_resolution(cp->config);
		}
	if (grids == 0)
		grids = FULL_SCALE_GRIDS;

	if (swap.krell_delta)
		swap.krell_delta->full_scale = res * grids / gkrellm_update_HZ();
	}

static void
destroy_chart(MeminfoChart *mc)
	{
	if (! mc->chart)
		return;
	gkrellm_chart_destroy(mc->chart);
	mc->chart = NULL;
	mc->enabled = FALSE;
	}

static void
create_chart(MeminfoChart *mc, gint first_create)
	{
	GkrellmChart				*cp;
	static GkrellmPiximage		*piximage;

	if (first_create)
		mc->chart = gkrellm_chart_new0();
	cp = mc->chart;

	if (gkrellm_load_piximage("bg_chart", NULL, &piximage, SWAP_STYLE_NAME))
		gkrellm_chart_bg_piximage_override(cp, piximage,
					gkrellm_bg_grid_piximage(swap.style_id));
	gkrellm_set_chart_height_default(cp, DEFAULT_SWAP_CHART_HEIGHT);
	gkrellm_chart_create(mc->vbox, mon_swap, cp, &mc->chart_config);
	mc->out_cd = gkrellm_add_default_chartdata(cp, _("Swap Out"));
	mc->in_cd = gkrellm_add_default_chartdata(cp, _("Swap In"));
	gkrellm_set_draw_chart_function(cp, refresh_chart, mc);
    gkrellm_chartconfig_fixed_grids_connect(cp->config,
                setup_scaling, mc);
    gkrellm_chartconfig_grid_resolution_connect(cp->config,
                setup_scaling, mc);
    gkrellm_chartconfig_grid_resolution_adjustment(cp->config, TRUE,
                0, (gfloat) MIN_GRID_RES, (gfloat) MAX_GRID_RES, 0, 0, 0, 70);
    gkrellm_chartconfig_grid_resolution_label(cp->config,
                _("Swap in/out pages per sec"));
    if (gkrellm_get_chartconfig_grid_resolution(cp->config) < MIN_GRID_RES)
        gkrellm_set_chartconfig_grid_resolution(cp->config, DEFAULT_GRID_RES);

	gkrellm_alloc_chartdata(cp);

	if (first_create)
		{
		g_signal_connect(G_OBJECT(cp->drawing_area), "expose_event",
					G_CALLBACK(meminfo_expose_event), NULL);
		g_signal_connect(G_OBJECT(cp->drawing_area), "button_press_event",
					G_CALLBACK(cb_extra), mc);
		gtk_widget_show(mc->vbox);
		}
	else
		refresh_chart(mc);	/* Avoid second lag at theme/size switches */
	mc->enabled = TRUE;
	ascent = 0;
	}

static void
connect_panel_signals(GkrellmPanel *p, MeminfoMeter *mm)
		{
		g_signal_connect(G_OBJECT (p->drawing_area), "expose_event",
					G_CALLBACK(meminfo_expose_event), NULL);
		g_signal_connect(G_OBJECT(p->drawing_area), "button_press_event",
					G_CALLBACK(cb_panel_press), mm);
		g_signal_connect(G_OBJECT(p->drawing_area), "button_release_event",
					G_CALLBACK(cb_panel_release), NULL);
		g_signal_connect(G_OBJECT(p->drawing_area), "motion_notify_event",
					G_CALLBACK(cb_panel_motion), NULL);
		g_signal_connect(G_OBJECT(p->drawing_area), "enter_notify_event",
					G_CALLBACK(cb_panel_enter), mm);
		g_signal_connect(G_OBJECT(p->drawing_area), "leave_notify_event",
					G_CALLBACK(cb_panel_leave), mm);
		}

static void
create_mem_panel(GtkWidget *vbox, gint first_create)
	{
	GkrellmPiximage	*im = NULL;
	MeminfoMeter	*mm;
	GkrellmPanel	*p;
	GkrellmTextstyle *ts;
	GkrellmStyle	*s;
	gchar			*expand, buf[64], *u;
	gint			w_label, label_x_position, label_y_off;

	mm = &mem;
	if (first_create)
		mm->panel = gkrellm_panel_new0();
	if (!mem.all_krells)	/* Krells are not in panel krell list where */
		{					/* they would be automatically destroyed. */
		gkrellm_destroy_krell(mem.krell_buffers);
		gkrellm_destroy_krell(mem.krell_cache);
		}
	p = mm->panel;

	/* I've got two extra krells for buffers and cache.  Use the #included
	|  images unless themer has customized.
	*/
	s = gkrellm_copy_style(gkrellm_meter_style(mm->style_id));

	s->krell_yoff = 0;
	s->krell_depth = 1;
	s->krell_x_hot = -1;
	gkrellm_get_gkrellmrc_integer("mem_krell_cache_depth", &s->krell_depth);
	gkrellm_get_gkrellmrc_integer("mem_krell_cache_x_hot", &s->krell_x_hot);
	gkrellm_get_gkrellmrc_integer("mem_krell_cache_yoff", &s->krell_yoff);
	expand = gkrellm_get_gkrellmrc_string("mem_krell_cache_expand");
	gkrellm_set_krell_expand(s, expand);
	g_free(expand);
	gkrellm_load_piximage("krell_cache", krell_cache_xpm, &im, MEM_STYLE_NAME);
	mm->krell_cache = gkrellm_create_krell(p, im, s);
	gkrellm_monotonic_krell_values(mm->krell_cache, FALSE);

	s->krell_yoff = 0;
	s->krell_depth = 1;
	s->krell_x_hot = -1;
	gkrellm_get_gkrellmrc_integer("mem_krell_buffers_depth", &s->krell_depth);
	gkrellm_get_gkrellmrc_integer("mem_krell_buffers_x_hot", &s->krell_x_hot);
	gkrellm_get_gkrellmrc_integer("mem_krell_buffers_yoff", &s->krell_yoff);
	expand = gkrellm_get_gkrellmrc_string("mem_krell_buffers_expand");
	gkrellm_set_krell_expand(s, expand);
	g_free(expand);
	gkrellm_load_piximage("krell_buffers", krell_buffers_xpm,
						 &im,MEM_STYLE_NAME);
	mm->krell_buffers = gkrellm_create_krell(p, im, s);
	gkrellm_monotonic_krell_values(mm->krell_buffers, FALSE);

	/* Unlike the style pointer passed to gkrellm_panel_configure(), the krells
	|  don't need the style to persist.
	*/
	g_free(s);
	if (im)
		gkrellm_destroy_piximage(im);

	s = gkrellm_meter_style(mm->style_id);
	gkrellm_panel_label_get_position(s, &label_x_position, &label_y_off);

	mm->krell_used = gkrellm_create_krell(p,
						gkrellm_krell_meter_piximage(mm->style_id), s);
	gkrellm_monotonic_krell_values(mm->krell_used, FALSE);

	if (mem.label)
		g_free(mem.label);
	if (label_x_position == GKRELLM_LABEL_NONE)
		mem.label = g_strdup("");
	else
		mem.label = g_strdup(_("Mem"));
	if (!g_utf8_validate(mem.label, -1, NULL))
		{
		u = g_locale_to_utf8(mem.label, -1, NULL, NULL, NULL);
		g_free(mem.label);
		mem.label = u;
		}

	snprintf(buf, sizeof(buf), "%sMemfj8", mem.label);
	mm->decal_label = gkrellm_create_decal_text(p, buf,
				gkrellm_meter_textstyle(mm->style_id), s, -1,
				(label_y_off > 0) ? label_y_off : -1,
				-1);
	gkrellm_panel_configure(p, NULL, s);
	gkrellm_panel_create(vbox, mon_mem, p);

	ts = &mm->decal_label->text_style;
	w_label = gkrellm_gdk_string_width(ts->font, mm->label) + ts->effect;
	mm->x_label = gkrellm_label_x_position(label_x_position,
				mm->decal_label->w,
				w_label, 0);
	draw_decal_label(mm, 0);

	if (first_create)
		connect_panel_signals(p, mm);

	mm->launch.margin.left = - mm->x_label + 2;
	mm->launch.margin.right = -(mm->decal_label->w - mm->x_label - w_label) +2;
	gkrellm_setup_decal_launcher(p, &mm->launch, mm->decal_label);

	if (!mm->enabled)
		gkrellm_panel_hide(p);
	if (!mem.all_krells)
		{
		gkrellm_remove_krell(mem.panel, mem.krell_buffers);
		gkrellm_remove_krell(mem.panel, mem.krell_cache);
		}
	}

static void
create_swap_panel(GtkWidget *vbox, gint first_create)
	{
	MeminfoMeter	*mm;
	GkrellmPanel	*p;
	GkrellmStyle	*style, *panel_style;
	GkrellmTextstyle *ts;
	gchar			buf[64], *u;
	gint			w_label, label_x_position, label_y_off;

	mm = &swap;
	if (first_create)
		mm->panel = gkrellm_panel_new0();
	p = mm->panel;

	style = gkrellm_meter_style(mm->style_id);
	gkrellm_panel_label_get_position(style, &label_x_position, &label_y_off);

	/* Need a chart styled krell on the swap meter panel, but want it to track
	|  the meter krell margins.
	*/
	panel_style = gkrellm_copy_style(gkrellm_panel_style(DEFAULT_STYLE_ID));
	panel_style->krell_left_margin = style->krell_left_margin;
	panel_style->krell_right_margin = style->krell_right_margin;
	mm->krell_delta = gkrellm_create_krell(p,
			gkrellm_krell_panel_piximage(DEFAULT_STYLE_ID), panel_style);
	g_free(panel_style);	/* unlike panels, krell styles need not persist */

	mm->krell_used = gkrellm_create_krell(p,
				gkrellm_krell_meter_piximage(mm->style_id), style);
	gkrellm_monotonic_krell_values(mm->krell_used, FALSE);

	if (swap.label)
		g_free(swap.label);
	if (label_x_position == GKRELLM_LABEL_NONE)
		swap.label = g_strdup("");
	else
		swap.label = g_strdup(_("Swap"));
	if (!g_utf8_validate(swap.label, -1, NULL))
		{
		u = g_locale_to_utf8(swap.label, -1, NULL, NULL, NULL);
		g_free(swap.label);
		swap.label = u;
		}

	snprintf(buf, sizeof(buf), "%sMemfj8", swap.label);
	mm->decal_label = gkrellm_create_decal_text(p, buf,
				gkrellm_meter_textstyle(mm->style_id), style, -1,
				(label_y_off > 0) ? label_y_off : -1,
				-1);

	gkrellm_panel_configure(p, NULL, style);
	gkrellm_panel_create(vbox, mon_swap, p);

	ts = &mm->decal_label->text_style;
	w_label = gkrellm_gdk_string_width(ts->font, mm->label) + ts->effect;
	mm->x_label = gkrellm_label_x_position(label_x_position,
				mm->decal_label->w,
				w_label, 0);
	draw_decal_label(mm, 0);

	if (first_create)
		connect_panel_signals(p, mm);

	mm->launch.margin.left = - mm->x_label + 1;
	mm->launch.margin.right = -(mm->decal_label->w - mm->x_label - w_label) +1;
	gkrellm_setup_decal_launcher(p, &mm->launch, mm->decal_label);

	if (!mm->enabled)
		gkrellm_panel_hide(p);
	}

static void
spacer_visibility(void)
	{
	gint	top, bot;

	top = swap_chart.enabled ? GKRELLM_SPACER_CHART : GKRELLM_SPACER_METER;
	bot = (swap_chart.enabled && !(mem.enabled || swap.enabled)) ?
				GKRELLM_SPACER_CHART : GKRELLM_SPACER_METER;
	gkrellm_spacers_set_types(mon_mem, top, bot);

	if (mem.enabled || swap.enabled || swap_chart.enabled)
		gkrellm_spacers_show(mon_mem);
	else
		gkrellm_spacers_hide(mon_mem);
	}

  /* No separate swap monitor create function.  Use create_mem() to create
  |  swap chart, mem meter, and swap meter so they will all be a unit in
  |  the same vbox.
  */
static void
create_mem(GtkWidget *vbox, gint first_create)
	{
	if (first_create)
		{
		swap_chart.vbox = gtk_vbox_new(FALSE, 0);
		gtk_box_pack_start(GTK_BOX(vbox), swap_chart.vbox, FALSE, FALSE, 0);

		(*read_mem_data)();
		(*read_swap_data)();
		}
	if (swap_chart.enabled)
		create_chart(&swap_chart, first_create);
	create_mem_panel(vbox, first_create);
	create_swap_panel(vbox, first_create);
	setup_scaling(NULL, &swap_chart);
	spacer_visibility();
	}


#define	MEM_CONFIG_KEYWORD	"meminfo"

static void
cb_alert_trigger(GkrellmAlert *alert, MeminfoMeter *m)
	{
	/* Full panel alert, default decal.
	*/
	alert->panel = m->panel;
	}

static void
create_alert(MeminfoMeter *m)
	{
	gchar	*label;

	if (m == &mem)
		label = _("Memory");
	else
		label = _("Swap");
	m->alert = gkrellm_alert_create(NULL, label,
			_("Percent Usage"),
			TRUE, FALSE, TRUE,
			100, 10, 1, 10, 0);
	gkrellm_alert_trigger_connect(m->alert, cb_alert_trigger, m);
	gkrellm_alert_command_process_connect(m->alert, cb_command_process, m);
	}

static void
save_meminfo_config(FILE *f)
	{
	fprintf(f, "%s mem_meter %d %d %d\n", MEM_CONFIG_KEYWORD,
				mem.enabled, mem.label_is_data, mem.all_krells);
	fprintf(f, "%s swap_meter %d %d\n", MEM_CONFIG_KEYWORD,
				swap.enabled, swap.label_is_data);
	fprintf(f, "%s swap_chart %d %d\n", MEM_CONFIG_KEYWORD,
				swap_chart.enabled, swap_chart.extra_info);
	gkrellm_save_chartconfig(f, swap_chart.chart_config,
				MEM_CONFIG_KEYWORD, NULL);

	fprintf(f, "%s mem_launch %s\n", MEM_CONFIG_KEYWORD,