chart.c

系统任务管理器

		result = 1;
	else
		result = 0;
	return result;
    }
#endif

static void
insert_in_chartlist(GkrellmChart *cp)
	{
	GList	*list;
	GkrellmChart	*cp_x;
	gint	position = 0;

	for (list = chart_list; list; list = list->next, ++position)
		{
		cp_x = (GkrellmChart *) list->data;
		if (cp_x->style_id > cp->style_id)
			{
			chart_list = g_list_insert(chart_list, cp, position);
			return;
			}
		}
	chart_list = g_list_append(chart_list, cp);
	}

void
gkrellm_chart_hide(GkrellmChart *cp, gboolean hide_panel)
	{
	gint	h_spacers = 0;

	if (!cp || !cp->shown)
		return;

	if (cp->top_spacer.image)
		h_spacers = cp->top_spacer.height;
	if (cp->bottom_spacer.image)
		h_spacers += cp->bottom_spacer.height;

	gtk_widget_hide(cp->box);
	gkrellm_freeze_side_frame_packing();
	if (hide_panel)
		gkrellm_panel_hide(cp->panel);
	gkrellm_monitor_height_adjust(- (cp->h + h_spacers));
	cp->shown = FALSE;
	gkrellm_thaw_side_frame_packing();
	}

void
gkrellm_chart_show(GkrellmChart *cp, gboolean show_panel)
	{
	gint	h_spacers = 0;

	if (!cp || cp->shown)
		return;

	if (cp->top_spacer.image)
		h_spacers = cp->top_spacer.height;
	if (cp->bottom_spacer.image)
		h_spacers += cp->bottom_spacer.height;

	gtk_widget_show(cp->box);
	gkrellm_freeze_side_frame_packing();
	if (show_panel)
		gkrellm_panel_show(cp->panel);
	cp->shown = TRUE;
	gkrellm_monitor_height_adjust(cp->h + h_spacers);
	gkrellm_thaw_side_frame_packing();
	}

gboolean
gkrellm_is_chart_visible(GkrellmChart *cp)
	{
	if (!cp)
		return FALSE;
	return cp->shown;
	}

gboolean
gkrellm_chart_enable_visibility(GkrellmChart *cp, gboolean new_vis,
					gboolean *current_vis)
	{
	gboolean	changed = FALSE;

	if (new_vis  && ! *current_vis)
		{
		gkrellm_chart_show(cp, TRUE);
		*current_vis  = TRUE;
		changed = TRUE;
		}
	if (!new_vis  && *current_vis)
		{
		gkrellm_chart_hide(cp, TRUE);
		*current_vis  = FALSE;
		changed = TRUE;
		}
	return changed;
	}

void
gkrellm_set_chart_height_default(GkrellmChart *cp, gint h)
	{
	if (!cp || (cp->config && cp->config->config_loaded))
		return;

	if (h < MIN_CHARTHEIGHT)
		h = MIN_CHARTHEIGHT;
	if (h > MAX_CHARTHEIGHT)
		h = MAX_CHARTHEIGHT;
	cp->h = h;
	}

static void
render_chart_margin_spacers(GkrellmChart *cp)
	{
	GkrellmMargin	*m;
	GkrellmSpacer	*ts, *bs;

	ts = &cp->top_spacer;
	bs = &cp->bottom_spacer;
	if (ts->image)
		gtk_container_remove(GTK_CONTAINER(ts->vbox), ts->image);
	if (bs->image)
		gtk_container_remove(GTK_CONTAINER(bs->vbox), bs->image);
	ts->image = bs->image = NULL;
	m = gkrellm_get_style_margins(cp->style);
	ts->piximage = cp->bg_piximage;
	ts->height   = m->top;
	bs->piximage = cp->bg_piximage;
	bs->height   = m->bottom;

	if (!gkrellm_render_spacer(ts, 0, m->top,
				_GK.frame_left_chart_overlap, _GK.frame_right_chart_overlap))
		gtk_widget_hide(ts->vbox);

	if (!gkrellm_render_spacer(bs,
				gdk_pixbuf_get_height(cp->bg_piximage->pixbuf) - m->bottom,
				m->bottom,
				_GK.frame_left_chart_overlap, _GK.frame_right_chart_overlap))
		gtk_widget_hide(bs->vbox);
	}

#if 0
static gboolean
cb_chart_map_event(GtkWidget *widget, GdkEvent *event, GkrellmChart *cp)
    {
    gdk_window_get_position(cp->drawing_area->window, NULL, &cp->y_mapped);
	if (_GK.frame_left_chart_overlap > 0 || _GK.frame_right_chart_overlap > 0)
		_GK.need_frame_packing = TRUE;
    return FALSE;
    }
#endif

static gboolean
cb_chart_size_allocate(GtkWidget *widget, GtkAllocation *size,
				GkrellmChart *cp)
    {
    gdk_window_get_position(cp->drawing_area->window, NULL, &cp->y_mapped);
	if (_GK.frame_left_chart_overlap > 0 || _GK.frame_right_chart_overlap > 0)
		_GK.need_frame_packing = TRUE;
    return FALSE;
    }

static void
render_chart_pixmaps(GkrellmChart *cp)
	{
	GkrellmPiximage	piximage;
	GkrellmMargin	*m;
	gint			h, w;

	m = gkrellm_get_style_margins(cp->style);
	w = gdk_pixbuf_get_width(cp->bg_piximage->pixbuf)
				- _GK.frame_left_chart_overlap - _GK.frame_right_chart_overlap;
	h = gdk_pixbuf_get_height(cp->bg_piximage->pixbuf) - m->top - m->bottom;

	if (   (   m->top > 0 || m->bottom > 0
			|| _GK.frame_left_chart_overlap > 0
			|| _GK.frame_right_chart_overlap > 0
		   )
		&& w > 0 && h > 0
	   )
		{
		piximage.pixbuf = gdk_pixbuf_new_subpixbuf(cp->bg_piximage->pixbuf,
				_GK.frame_left_chart_overlap, m->top, w, h);
		piximage.border = cp->bg_piximage->border;
		gkrellm_border_adjust(&piximage.border,
				-_GK.frame_left_chart_overlap, -_GK.frame_right_chart_overlap,
				-m->top, -m->bottom);
		gkrellm_scale_piximage_to_pixmap(&piximage, &cp->bg_clean_pixmap,
					&cp->bg_mask, cp->w, cp->h);
		g_object_unref(G_OBJECT(piximage.pixbuf));
		}
	else
		gkrellm_scale_piximage_to_pixmap(cp->bg_piximage,
					&cp->bg_clean_pixmap, &cp->bg_mask, cp->w, cp->h);

	gkrellm_clone_pixmap(&cp->pixmap, &cp->bg_clean_pixmap);
	gkrellm_clone_pixmap(&cp->bg_pixmap, &cp->bg_clean_pixmap);
	gkrellm_clone_pixmap(&cp->bg_src_pixmap, &cp->bg_clean_pixmap);
	gkrellm_clone_pixmap(&cp->bg_text_pixmap, &cp->bg_clean_pixmap);
	}

void
gkrellm_chart_create(GtkWidget *vbox, GkrellmMonitor *mon, GkrellmChart *cp,
			GkrellmChartconfig **config)
	{
	GkrellmMargin	*m;
	GkrellmChartconfig *cf;
	gint			h, style_id;

	if (!vbox || !mon || !cp || !config)
		return;
	if (mon->privat->style_type == CHART_PANEL_TYPE)
		style_id = mon->privat->style_id;
	else
		style_id = DEFAULT_STYLE_ID;
	cp->style = gkrellm_chart_style(style_id);
	m = gkrellm_get_style_margins(cp->style);
	cp->monitor = (gpointer) mon;
	if (!cp->bg_piximage_override)
		{
		cp->bg_piximage = gkrellm_bg_chart_piximage(style_id);
		cp->bg_grid_piximage = gkrellm_bg_grid_piximage(style_id);
		}
	cp->bg_piximage_override = FALSE;
	cp->x = 0;
/*	cp->y = 0; */
	cp->w = _GK.chart_width;
	if (!*config)
		{
		*config = gkrellm_chartconfig_new0();
		(*config)->auto_grid_resolution = TRUE;		/* the default */
		(*config)->h = cp->h;					/* In case default */
		}
	cf = cp->config = *config;
	if (cf->h < 5)
		cf->h = 40;
	cp->h = cf->h;
	if (cf->grid_resolution < 1)
		cf->grid_resolution = 1;
	cp->cd_list = cp->config->cd_list;
	cp->config->chart_cd_list = &cp->cd_list;

	if (!cp->box)
		{		
		cp->box = gtk_vbox_new(FALSE, 0);	/* not a hbox anymore !! */
		gtk_box_pack_start(GTK_BOX(vbox), cp->box, FALSE, FALSE, 0);

		cp->top_spacer.vbox = gtk_vbox_new(FALSE, 0);
		gtk_box_pack_start(GTK_BOX(cp->box), cp->top_spacer.vbox,
				FALSE, FALSE, 0);
		cp->drawing_area = gtk_drawing_area_new();
		gtk_widget_set_events(cp->drawing_area, GDK_EXPOSURE_MASK
				| GDK_LEAVE_NOTIFY_MASK | GDK_ENTER_NOTIFY_MASK
				| GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK
				| GDK_POINTER_MOTION_MASK);
		gtk_box_pack_start(GTK_BOX(cp->box), cp->drawing_area,
				FALSE, FALSE, 0);
		cp->bottom_spacer.vbox = gtk_vbox_new(FALSE, 0);
		gtk_box_pack_start(GTK_BOX(cp->box), cp->bottom_spacer.vbox,
				FALSE, FALSE, 0);

		gtk_widget_show(cp->drawing_area);
		gtk_widget_show(cp->box);
		cp->shown = TRUE;
		gtk_widget_realize(cp->box);
		gtk_widget_realize(cp->drawing_area);
		cp->style_id = style_id;
		insert_in_chartlist(cp);
		cp->y_mapped = -1;
//		g_signal_connect(G_OBJECT (cp->drawing_area), "map_event",
//					G_CALLBACK(cb_chart_map_event), cp);
		g_signal_connect(G_OBJECT (cp->drawing_area), "size_allocate",
					G_CALLBACK(cb_chart_size_allocate), cp);
		}
	else
		free_chart_pixmaps(cp);

	gtk_widget_set_size_request(cp->drawing_area, cp->w, cp->h);

	cp->bg_sequence_id += 1;

	render_chart_pixmaps(cp);
	render_chart_margin_spacers(cp);

	h = gdk_pixbuf_get_height(cp->bg_grid_piximage->pixbuf);
	if (h > 2)
		h = 2;
	gkrellm_scale_piximage_to_pixmap(cp->bg_grid_piximage,
				&cp->bg_grid_pixmap, NULL, cp->w, h);

	cp->transparency = cp->style->transparency;
	_GK.any_transparency |= cp->transparency;

	gkrellm_set_draw_chart_function(cp, default_draw_chart_function, cp);
	cp->redraw_all = TRUE;
	render_default_data_pixmaps(cp);
	if (cp->shown)
		{
		gkrellm_monitor_height_adjust(cp->h + m->top + m->bottom);
		gkrellm_pack_side_frames();
		}
	}

void
gkrellm_refresh_chart(GkrellmChart *cp)
	{
	if (!cp)
		return;
	cp->redraw_all = TRUE;
	cp->maxval_auto = -1;
	if (cp->draw_chart)
		(*(cp->draw_chart))(cp->draw_chart_data);
	}

void
gkrellm_rescale_chart(GkrellmChart *cp)
	{
	if (!cp)
		return;
	scan_for_maxval(cp);
	gkrellm_refresh_chart(cp);
	}

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


static gint		map_125_table[] =
	{
	1, 2, 5,
	10, 20, 50,
	100, 200, 500,
	1000, 2000, 5000,
	10000, 20000, 50000,
	100000, 200000, 500000,
	1000000, 2000000, 5000000,
	10000000, 20000000, 50000000,
	100000000, 200000000, 500000000
	};

static gint		map_12357_table[] =
	{
	1, 2, 3, 5, 7,
	10, 15, 20, 30, 50, 70,
	100, 150, 200, 300, 500, 700,
	1000, 1500, 2000, 3000, 5000, 7000,
	10000, 15000, 20000, 30000, 50000, 70000,
	100000, 150000, 200000, 300000, 500000, 700000,
	1000000, 1500000, 2000000, 3000000, 5000000, 7000000,
	10000000, 15000000, 20000000, 30000000, 50000000, 70000000,
	100000000, 150000000, 200000000, 300000000, 500000000, 700000000
	};

gint
gkrellm_125_sequence(gint value, gboolean use125,
			gint low, gint high,
			gboolean snap_to_table, gboolean roundup)
	{
	gint    i, table_size;
	gint	*table;

	if (use125)
		{
		table = map_125_table;
		table_size = sizeof(map_125_table) / sizeof(gint);
		}
	else
		{
		table = map_12357_table;
		table_size = sizeof(map_12357_table) / sizeof(gint);
		}
	if (value < low)
		value = low;
	if (value > high)
		value = high;
	if (value < table[0])
		return table[0];
	if (value > table[table_size - 1])
		return table[table_size - 1];
	if (!snap_to_table && !roundup)
		{
		for (i = 0; i < table_size; ++i)
			{
/*printf("  mapping[%d] value=%d table=%d\n", i, value, table[i]); */
			if (value == table[i])
				return table[i];
			else if (value == table[i] - 1)
				return table[i - 1];
			else if (value == table[i] + 1)
				return table[i + 1];
			}
		}
	else if (snap_to_table && !roundup)
		{
		for (i = table_size - 1; i >= 0; --i)
			{
			if (value >= table[i])
				{
				value = table[i];
				break;
				}
			}
		}
	else if (snap_to_table && roundup)
		{
		for (i = 0; i < table_size; ++i)
			{
			if (value <= table[i])
				{
				value = table[i];
				break;
				}
			}
		}
	return value;
	}

static void
set_grid_resolution_spin_button(GkrellmChart *cp, gint res)
	{
	GtkSpinButton	*spin;

	if (!cp || !cp->config_window || !cp->config->grid_resolution_spin_button)
		return;
	spin = GTK_SPIN_BUTTON(cp->config->grid_resolution_spin_button);
	gtk_spin_button_set_value(spin, (gfloat) res);	
	}

static void
cb_chart_grid_resolution(GtkWidget *adjustment, GkrellmChart *cp)
	{
	GtkSpinButton	*spin;
	GkrellmChartconfig		*cf;
	gint			res;
	gfloat			fres;

	cf = cp->config;
	spin = GTK_SPIN_BUTTON(cf->grid_resolution_spin_button);
	if (cf->map_sequence)
		{
		res = gtk_spin_button_get_value_as_int(spin);
		if (res != cf->grid_resolution)
			{
			res = gkrellm_125_sequence(res, cf->sequence_125,
						cf->low, cf->high, FALSE, FALSE);
			cf->grid_resolution = res;
			gtk_spin_button_set_value(spin, (gfloat) res);
			if (cf->cb_grid_resolution && !cf->cb_block)
				(*cf->cb_grid_resolution)(cf, cf->cb_grid_resolution_data);
			gkrellm_refresh_chart(cp);
			}
		}
	else
		{
		fres = gtk_spin_button_get_value(spin);
		if (cf->spin_factor > 0.0)
			fres *= cf->spin_factor;
		cf->grid_resolution = (gint) fres;
		if (cf->grid_resolution < 1)
			cf->grid_resolution = 1;
		if (cf->cb_grid_resolution && !cf->cb_block)
			(*cf->cb_grid_resolution)(cf, cf->cb_grid_resolution_data);
		gkrellm_refresh_chart(cp);
		}
	}


/* ---- GkrellmChartconfig functions ---- */
void
gkrellm_chartconfig_callback_block(GkrellmChartconfig *cf, gboolean block)
	{
	if (!cf)
		return;
	cf->cb_block = block;
	}

void
gkrellm_set_chartconfig_grid_resolution(GkrellmChartconfig *cf, gint res)
	{
	if (!cf || res <= 0)
		return;
	cf->grid_resolution = res;
	}

gint
gkrellm_get_chartconfig_grid_resolution(GkrellmChartconfig *cf)
	{
	if (!cf)
		return 0;
	return cf->grid_resolution;
	}

void
gkrellm_chartconfig_grid_resolution_connect(GkrellmChartconfig *cf,
			void (*func)(gpointer), gpointer data)
	{
	if (!cf)
		return;
	cf->cb_grid_resolution = func;
	cf->cb_grid_resolution_data = data;
	}

void
gkrellm_set_chartconfig_flags(GkrellmChartconfig *cf, gint flags)
	{
	if (!cf)
		return;
	cf->flags = flags;
	}

void
gkrellm_chartconfig_grid_resolution_adjustment(GkrellmChartconfig *cf,
			gboolean map_sequence, gfloat spin_factor,
			gfloat low, gfloat high, gfloat step0, gfloat step1, gint digits,
			gint width)
	{
	if (!cf)
		return;
	cf->map_sequence = map_sequence;
	if ((cf->width = width) == 0)
		cf->width = 70 + log(high / 100000) * 5;
	if (map_sequence)
		{
		cf->low = 1;
		cf->low = (gfloat) gkrellm_125_sequence((gint) low, cf->sequence_125,
							low, high, TRUE, FALSE);
		cf->high = (gfloat) gkrellm_125_sequence((gint) high,
							cf->sequence_125, low, high, TRUE, TRUE);