chart.c

系统任务管理器

		cf->step0 = 1.0;
		cf->step1 = 1.0;
		cf->digits = 0;
		}
	else
		{
		cf->low = low;
		cf->high = high;
		cf->step0 = step0;
		cf->step1 = step1;
		cf->digits = digits;
		cf->spin_factor = spin_factor;
		}
	if (cf->spin_factor < 1.0)
		cf->spin_factor = 1.0;
	cf->adjustment_is_set = TRUE;
	}

void
gkrellm_chartconfig_grid_resolution_label(GkrellmChartconfig *cf, gchar *label)
	{
	if (!cf)
		return;
	gkrellm_dup_string(&cf->grid_resolution_label, label);
	}

void
gkrellm_set_chartconfig_auto_grid_resolution(GkrellmChartconfig *cf, gboolean ato)
	{
	if (cf)
		cf->auto_grid_resolution = ato;
	}

void
gkrellm_set_chartconfig_auto_resolution_stick(GkrellmChartconfig *cf, gboolean stick)
	{
	if (cf)
		cf->auto_resolution_stick = stick;
	}

void
gkrellm_set_chartconfig_sequence_125(GkrellmChartconfig *cf, gboolean seq)
	{
	if (cf)
		cf->sequence_125 = seq;
	}

void
gkrellm_set_chartconfig_fixed_grids(GkrellmChartconfig *cf, gint fixed_grids)
	{
	if (!cf || fixed_grids < 0 || fixed_grids > 5)
		return;
	cf->fixed_grids = fixed_grids;
	}

gint
gkrellm_get_chartconfig_fixed_grids(GkrellmChartconfig *cf)
	{
	if (!cf)
		return 0;
	return cf->fixed_grids;
	}

void
gkrellm_chartconfig_fixed_grids_connect(GkrellmChartconfig *cf,
			void (*func)(gpointer), gpointer data)
	{
	if (!cf)
		return;
	cf->cb_fixed_grids = func;
	cf->cb_fixed_grids_data = data;
	}

gint
gkrellm_get_chartconfig_height(GkrellmChartconfig *cf)
	{
	if (!cf)
		return 0;
	return cf->h;
	}

void
gkrellm_chartconfig_height_connect(GkrellmChartconfig *cf,
			void (*func)(gpointer), gpointer data)
	{
	if (!cf)
		return;
	cf->cb_height = func;
	cf->cb_height_data = data;
	}

void
gkrellm_set_chart_height(GkrellmChart *cp, gint h)
	{
	GtkWidget			*top_win = gkrellm_get_top_window();
	GtkSpinButton		*spin;
	GList				*list;
	GkrellmChartdata	*cd;
	GkrellmChartconfig	*cf;
	gint				dy;

	if (!cp || cp->h == h)
		return;
	dy = h - cp->h;
	cp->h = h;
	cp->config->h = h;
	render_default_data_pixmaps(cp);
	for (list = cp->cd_list; list; list = list->next)
		{
		cd = (GkrellmChartdata *) list->data;
		g_object_unref(G_OBJECT(cd->data_bitmap));
		g_object_unref(G_OBJECT(cd->layer.pixmap));
		cd->data_bitmap = gdk_pixmap_new(top_win->window, cp->w, cp->h, 1);
		cd->layer.pixmap = gdk_pixmap_new(top_win->window, cp->w, cp->h, -1);
		}
	cp->bg_sequence_id += 1;
	render_chart_pixmaps(cp);

	cf = cp->config;
	if (cf->cb_height && !cf->cb_block)
		(*cf->cb_height)(cf, cf->cb_height_data);
	gtk_widget_set_size_request(cp->drawing_area, cp->w, cp->h);
	set_chartdata_split_heights(cp);
	if (cp->shown)
		{
		gkrellm_monitor_height_adjust(dy);
		gkrellm_pack_side_frames();
		gkrellm_refresh_chart(cp);
		}
	if (cp->config_window)
		{
		spin = GTK_SPIN_BUTTON(cf->height_spin_button);
		if (h != gtk_spin_button_get_value_as_int(spin))
			gtk_spin_button_set_value(spin, (gfloat) h);
		}
	}

gboolean
gkrellm_get_chartdata_hide(GkrellmChartdata *cd)
	{
	if (cd && cd->hide)
		return TRUE;
	return FALSE;
	}


/* =================================================================== */

static void
chart_config_window_close(GtkWidget *widget, GkrellmChart *cp)
	{
	if (cp->config_window)
		gtk_widget_destroy(cp->config_window);
	cp->config_window = NULL;
	}

void
gkrellm_chartconfig_window_destroy(GkrellmChart *cp)
	{
	chart_config_window_close(NULL, cp);
	}

static gint
chart_config_window_delete_event(GtkWidget *widget, GdkEvent *ev,
			gpointer data)
	{
	chart_config_window_close(widget, data);
	return FALSE;
	}

static void
set_resolution_menubar_items_sensitivity(GkrellmChartconfig *cf)
	{
	GtkWidget	*w;

	if (!cf->auto_resolution_item_factory)
		return;

	w = gtk_item_factory_get_widget(cf->auto_resolution_item_factory,
				_("/Control/Auto mode sticks at peak value"));
	GTK_CHECK_MENU_ITEM(w)->active = cf->auto_resolution_stick;

	w = gtk_item_factory_get_widget(cf->auto_resolution_item_factory,
				_("/Control/Auto mode recalibrate"));
	if (cf->auto_grid_resolution)
		gtk_widget_set_sensitive(w, TRUE);
	else
		gtk_widget_set_sensitive(w, FALSE);
	}

static void
cb_chart_height(GtkWidget *adjustment, GkrellmChart *cp)
	{
	GtkSpinButton	*spin;
	gint			h;

	_GK.config_modified = TRUE;
	spin = GTK_SPIN_BUTTON(cp->config->height_spin_button);
	h = gtk_spin_button_get_value_as_int(spin);
	gkrellm_set_chart_height(cp, h);
	}

static void
cb_chart_fixed_grids(GtkWidget *adjustment, GkrellmChart *cp)
	{
	GtkSpinButton		*spin;
	GkrellmChartconfig	*cf = cp->config;

	_GK.config_modified = TRUE;
	spin = GTK_SPIN_BUTTON(cf->fixed_grids_spin_button);
	cf->fixed_grids = gtk_spin_button_get_value_as_int(spin);
	if (cf->auto_grid_resolution)
		set_auto_grid_resolution(cp, cp->maxval_auto);
	if (cf->cb_fixed_grids && !cf->cb_block)
		(*cf->cb_fixed_grids)(cf, cf->cb_fixed_grids_data);

	set_resolution_menubar_items_sensitivity(cf);

	gkrellm_refresh_chart(cp);
	}

static void
cb_line_draw_style(GtkWidget *widget, GkrellmChartdata *cd)
	{
	_GK.config_modified = TRUE;
	cd->draw_style = GTK_TOGGLE_BUTTON(widget)->active;
	gkrellm_rescale_chart(cd->chart);
	}

static void
cb_auto_resolution(GtkWidget *widget, GkrellmChart *cp)
	{
	GtkWidget			*button;
	GkrellmChartconfig	*cf = cp->config;

	_GK.config_modified = TRUE;
	cf->auto_grid_resolution = GTK_TOGGLE_BUTTON(widget)->active;

	set_resolution_menubar_items_sensitivity(cf);
	button = cf->grid_resolution_spin_button;
	if (cf->auto_grid_resolution)
		gtk_widget_set_sensitive(button, FALSE);
	else
		gtk_widget_set_sensitive(button, TRUE);
	gkrellm_rescale_chart(cp);
	}

static void
cb_inverted_draw_mode(GtkWidget *widget, GkrellmChartdata *cd)
	{
	_GK.config_modified = TRUE;
	cd->inverted = GTK_TOGGLE_BUTTON(widget)->active;
	gkrellm_rescale_chart(cd->chart);
	}

static void
cb_hide(GtkWidget *widget, GkrellmChartdata *cd)
	{
	_GK.config_modified = TRUE;
	cd->hide = GTK_TOGGLE_BUTTON(widget)->active;
	set_chartdata_split_heights(cd->chart);
	gkrellm_rescale_chart(cd->chart);
	}

static void
cb_split_mode(GtkWidget *widget, GkrellmChartdata *cd)
	{
	_GK.config_modified = TRUE;
	cd->split_chart = GTK_TOGGLE_BUTTON(widget)->active;
	gtk_widget_set_sensitive(cd->split_fraction_spin_button, cd->split_chart);
	set_chartdata_split_heights(cd->chart);
	gkrellm_rescale_chart(cd->chart);
	}

static void
cb_split_fraction(GtkWidget *adjustment, GkrellmChartdata *cd)
	{
	GtkSpinButton	*spin;

	_GK.config_modified = TRUE;
	spin = GTK_SPIN_BUTTON(cd->split_fraction_spin_button);
	cd->split_fraction = gtk_spin_button_get_value(spin);
	set_chartdata_split_heights(cd->chart);
	gkrellm_rescale_chart(cd->chart);
	}


/* =================================================================== */

static void
cb_auto_res_control(GkrellmChart *cp, guint option, GtkWidget* widget)
    {
    GkrellmChartconfig *cf;
	gint			grid_res;
	gboolean		active;

	cf = cp->config;
    switch (option)
        {
        case 0:
			cp->maxval_auto_base = 0;
			cp->maxval_peak = 0;
			break;
        case 1:
            active = GTK_CHECK_MENU_ITEM(widget)->active;
			cf->auto_resolution_stick = active;
			cp->maxval_auto_base = 0;
            break;
        case 2:
            active = GTK_CHECK_MENU_ITEM(widget)->active;
			if (cf->sequence_125 && active)
				return;
			cf->sequence_125 = active;
			break;
        case 3:
            active = GTK_CHECK_MENU_ITEM(widget)->active;
			if (!cf->sequence_125 && active)
				return;
			cf->sequence_125 = !active;

			grid_res = gkrellm_125_sequence(cf->grid_resolution,
						cf->sequence_125, cf->low, cf->high, TRUE, FALSE);
			cf->grid_resolution = grid_res;
			set_grid_resolution_spin_button(cp, grid_res);
            break;
        }
	gkrellm_refresh_chart(cp);
    }


static GtkItemFactoryEntry	auto_res_control_items[] =
    {
{N_("/Control"),	NULL,	NULL,				 0,	"<LastBranch>" },
{N_("/Control/-"),	NULL,	NULL,				 0,	"<Separator>"},
{N_("/Control/Auto mode recalibrate"),
					NULL,	cb_auto_res_control, 0, "<Item>"},
{N_("/Control/Auto mode sticks at peak value"),
					NULL,	cb_auto_res_control, 1,	"<ToggleItem>"},
{N_("/Control/-"),	NULL,    NULL,				 0,	"<Separator>"},
{N_("/Control/Sequence.../1 2 5"),
					NULL,	cb_auto_res_control, 2,	"<RadioItem>"},
{N_("/Control/Sequence.../1 1.5 2 3 5 7"),
					NULL,	cb_auto_res_control, 3,
					N_("/Control/Sequence.../1 2 5")},
{N_("/Control/-"),	 NULL,	NULL,				 0,	"<Separator>"},
    };

static void
auto_resolution_control_menubar(GtkWidget **menubar, GkrellmChart *cp)
	{
	GtkItemFactory	*item_factory;
	GkrellmChartconfig		*cf = cp->config;
	gint			i, n;
	static gboolean	translated;

	n = sizeof(auto_res_control_items) / sizeof(GtkItemFactoryEntry);
	item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", NULL);
	if (!translated)
		{
		for(i = 0; i < n; i++)
			auto_res_control_items[i].path = _(auto_res_control_items[i].path);
		auto_res_control_items[6].item_type =
				_(auto_res_control_items[6].item_type);
		translated = TRUE;
		}
	gtk_item_factory_create_items(item_factory, n, auto_res_control_items, cp);
	cf->auto_resolution_item_factory = item_factory;
	set_resolution_menubar_items_sensitivity(cf);

	GTK_CHECK_MENU_ITEM(gtk_item_factory_get_widget(item_factory,
		_("/Control/Sequence.../1 2 5")))->active = cf->sequence_125;
	GTK_CHECK_MENU_ITEM(gtk_item_factory_get_widget(item_factory,
		_("/Control/Sequence.../1 1.5 2 3 5 7")))->active = !cf->sequence_125;

	if (menubar)
		*menubar = gtk_item_factory_get_widget(item_factory, "<main>");
	}

void
gkrellm_chartconfig_window_create(GkrellmChart *cp)
	{
	GtkWidget			*main_vbox, *vbox, *vbox1, *vbox2, *hbox;
	GtkWidget			*button;
	GList				*list;
	GkrellmChartconfig	*cf;
	GkrellmChartdata	*cd;
	GkrellmPanel		*p;
	gchar				*s;

	if (!cp || _GK.no_config)
		return;
	if (cp->config_window)
		{
		gtk_window_present(GTK_WINDOW(cp->config_window));
		return;
		}
	cp->config_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	g_signal_connect(G_OBJECT(cp->config_window), "delete_event",
			G_CALLBACK(chart_config_window_delete_event), cp);

	p = cp->panel;
	cf = cp->config;
	if (p && p->label)
		s = p->label->string;
	else
		s = NULL;
	gtk_window_set_title(GTK_WINDOW(cp->config_window),
				_("GKrellM Chart Config"));
	gtk_window_set_wmclass(GTK_WINDOW(cp->config_window),
				"Gkrellm_conf", "Gkrellm");

	main_vbox = gtk_vbox_new(FALSE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(cp->config_window), 4);
	gtk_container_add(GTK_CONTAINER(cp->config_window), main_vbox);
	vbox = gkrellm_gtk_framed_vbox(main_vbox, s, 4, FALSE, 4, 3);

	hbox = gtk_hbox_new(TRUE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
	for (list = cp->cd_list; list; list = list->next)
		{
		cd = (GkrellmChartdata *) list->data;
		if ((cd->flags & CHARTDATA_NO_CONFIG) == CHARTDATA_NO_CONFIG)
			continue;
		vbox1 = gkrellm_gtk_framed_vbox(hbox, cd->label, 2, TRUE, 2, 2);

		if (!(cd->flags & CHARTDATA_NO_CONFIG_DRAW_STYLE))
			{
			gkrellm_gtk_check_button(vbox1, &button, cd->draw_style, FALSE, 0,
					_("Line style"));
			g_signal_connect(G_OBJECT(button), "toggled",
					G_CALLBACK(cb_line_draw_style), cd);
			}
		if (!(cd->flags & CHARTDATA_NO_CONFIG_INVERTED))
			{
			gkrellm_gtk_check_button(vbox1, &button, cd->inverted, FALSE, 0,
					_("Inverted"));
			g_signal_connect(G_OBJECT(button), "toggled",
					G_CALLBACK(cb_inverted_draw_mode), cd);
			}
		if (list != cp->cd_list && !(cd->flags & CHARTDATA_NO_CONFIG_SPLIT))
			{
			vbox2 = gkrellm_gtk_framed_vbox(vbox1, NULL, 2, FALSE, 2, 2);
			gkrellm_gtk_check_button(vbox2, &button, cd->split_chart, FALSE, 0,
					_("Split view"));
			g_signal_connect(G_OBJECT(button), "toggled",
					G_CALLBACK(cb_split_mode), cd);
			gkrellm_gtk_spin_button(vbox2, &button, cd->split_fraction,
					0.05, 0.95, 0.01, 0.05, 2, 55,
					cb_split_fraction, cd, FALSE, "");
			gtk_widget_set_sensitive(button, cd->split_chart);
			cd->split_fraction_spin_button = button;
			}
		if (cd->flags & CHARTDATA_ALLOW_HIDE)
			{
			gkrellm_gtk_check_button(vbox1, &button, cd->hide, FALSE, 0,
					_("Hide"));
			g_signal_connect(G_OBJECT(button), "toggled",
					G_CALLBACK(cb_hide), cd);
			}
		}

	cf->auto_resolution_control_menubar = NULL;
	cf->auto_resolution_item_factory = NULL;
	cf->grid_resolution_spin_button = NULL;
	cf->fixed_grids_spin_button = NULL;

	if (cf->adjustment_is_set)
		{
		gfloat	value;

		vbox1 = gkrellm_gtk_framed_vbox(vbox, _("Resolution per Grid"),
					2, FALSE, 2, 2);
		if (cf->map_sequence)
			value = (gfloat) cf->grid_resolution;
		else
			value = cf->grid_resolution / cf->spin_factor;
		gkrellm_gtk_spin_button(vbox1, &button, value,
			cf->low, cf->high, cf->step0, cf->step1, cf->digits, cf->width,
			cb_chart_grid_resolution, cp, FALSE, cf->grid_resolution_label);
		cf->grid_resolution_spin_button = button;
		if (cp->config->auto_grid_resolution)
			gtk_widget_set_sensitive(button, FALSE);

		if (!(cp->config->flags & NO_CONFIG_AUTO_GRID_RESOLUTION))
			{
			hbox = gtk_hbox_new (FALSE, 0);
			gtk_container_set_border_width(GTK_CONTAINER(hbox), 2);
			gtk_container_add(GTK_CONTAINER(vbox1), hbox);
			gkrellm_gtk_check_button(hbox, &button,
					cp->config->auto_grid_resolution, TRUE, 0,
					_("Auto"));
			g_signal_connect(G_OBJECT(button), "toggled",
					G_CALLBACK(cb_auto_resolution), cp);

			auto_resolution_control_menubar(
					&cf->auto_resolution_control_menubar, cp);
			gtk_box_pack_start(GTK_BOX(hbox),
				cf->auto_resolution_control_menubar, FALSE, TRUE, 10);
			}
		}
	if (!(cp->config->flags & NO_CONFIG_FIXED_GRIDS))
		{
		vbox1 = gkrellm_gtk_framed_vbox(vbox, _("Number of Grids"), 2, FALSE,
				2, 2);
		gkrellm_gtk_spin_button(vbox1, &button, (gfloat) cf->fixed_grids,
				0, 5, 1.0, 1.0, 0, 50,
				cb_chart_fixed_grids, cp, FALSE,
				_("0: Auto    1-5: Constant"));
		cf->fixed_grids_spin_button = button;
		}

	vbox1 = gkrellm_gtk_framed_vbox(vbox, NULL, 2, FALSE, 2, 2);
	gkrellm_gtk_spin_button(vbox1, &button, (gfloat) cp->h,
			(gfloat) _GK.chart_height_min, (gfloat) _GK.chart_height_max,
			5.0, 10.0, 0, 50,
			cb_chart_height, cp, FALSE,
			_("Chart height"));
	cf->height_spin_button = button;

	hbox = gtk_hbutton_box_new();
	gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
	gtk_box_set_spacing(GTK_BOX(hbox), 5);
	gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 0);

	button = gtk_button_new_from_stock(GTK_STOCK_OK);