main.c

系统任务管理器

				0, 0, x_dst, y, w_pix, h_cap);
	else if (mask || frame_mask)
		frame_transparency_warning();

	gkrellm_free_pixmap(&pixmap);
	gkrellm_free_bitmap(&mask);
	}

static void
draw_frame_caps(GkrellmMonitor *mon)
	{
	GkrellmMonprivate	*mp = mon->privat;
	gint				y, h, h_left, h_right;

	if (!mp->main_vbox || mp->cap_images_off)
		return;
	y = mp->main_vbox->allocation.y;
	h = mp->main_vbox->allocation.height;
	if (mon != gkrellm_mon_host())
		y -= _GK.frame_top_height;

	h_left = h_right = 0;
	if (mp->top_spacer.piximage && _GK.frame_left_spacer_overlap)
		h_left = mp->top_spacer.height;
	if (mp->top_spacer.piximage && _GK.frame_right_spacer_overlap)
		h_right = mp->top_spacer.height;

	if (mp->top_type == GKRELLM_SPACER_CHART)
		{
		draw_cap(_GK.cap_top_left_chart_piximage, y, h, h_left, 1, 1);
		draw_cap(_GK.cap_top_right_chart_piximage, y, h, h_right, 1, 0);
		}
	else
		{
		draw_cap(_GK.cap_top_left_meter_piximage, y, h, h_left, 1, 1);
		draw_cap(_GK.cap_top_right_meter_piximage, y, h, h_right, 1, 0);
		}

	h_left = h_right = 0;
	if (mp->bottom_spacer.piximage && _GK.frame_left_spacer_overlap)
		h_left = mp->bottom_spacer.height;
	if (mp->bottom_spacer.piximage && _GK.frame_right_spacer_overlap)
		h_right = mp->bottom_spacer.height;

	if (mp->bottom_type == GKRELLM_SPACER_CHART)
		{
		draw_cap(_GK.cap_bottom_left_chart_piximage, y, h, h_left, 0, 1);
		draw_cap(_GK.cap_bottom_right_chart_piximage, y, h, h_right, 0, 0);
		}
	else
		{
		draw_cap(_GK.cap_bottom_left_meter_piximage, y, h, h_left, 0, 1);
		draw_cap(_GK.cap_bottom_right_meter_piximage, y, h, h_right, 0, 0);
		}
	}

static void
draw_left_frame_overlap(GdkPixbuf *pixbuf, GkrellmBorder *border,
			gint y_frame, gint overlap, gint height)
	{
	GkrellmPiximage		piximage;
	GdkPixmap			*pixmap = NULL;
	GdkBitmap			*mask = NULL;
	gint				w_pixbuf, h_pixbuf;

	if (overlap <= 0)
		return;
	w_pixbuf = gdk_pixbuf_get_width(pixbuf);
	h_pixbuf = gdk_pixbuf_get_height(pixbuf);
	piximage.pixbuf = gdk_pixbuf_new_subpixbuf(pixbuf, 0, 0,
						overlap, h_pixbuf);
	piximage.border = *border;
	gkrellm_scale_piximage_to_pixmap(&piximage, &pixmap, &mask,
						overlap, height);
	g_object_unref(G_OBJECT(piximage.pixbuf));
	gdk_draw_drawable(gtree.frame_left_pixmap, _GK.draw1_GC, pixmap,
					0, 0, _GK.frame_left_width - overlap, y_frame,
					overlap, height);
	if (mask && gtree.frame_left_mask)
		gdk_draw_drawable(gtree.frame_left_mask, _GK.bit1_GC, mask,
					0, 0, _GK.frame_left_width - overlap, y_frame,
					overlap, height);
	else if (mask || gtree.frame_left_mask)
		frame_transparency_warning();

	gkrellm_free_pixmap(&pixmap);
	gkrellm_free_bitmap(&mask);
	}

static void
draw_right_frame_overlap(GdkPixbuf *pixbuf, GkrellmBorder *border,
			gint y_frame, gint overlap, gint height)
	{
	GkrellmPiximage		piximage;
	GdkPixmap			*pixmap = NULL;
	GdkBitmap			*mask = NULL;
	gint				w_pixbuf, h_pixbuf;

	if (overlap <= 0)
		return;
	w_pixbuf = gdk_pixbuf_get_width(pixbuf);
	h_pixbuf = gdk_pixbuf_get_height(pixbuf);
	piximage.pixbuf = gdk_pixbuf_new_subpixbuf(pixbuf,
						w_pixbuf - overlap, 0, overlap, h_pixbuf);
	piximage.border = *border;
	gkrellm_scale_piximage_to_pixmap(&piximage, &pixmap, &mask,
					overlap, height);
	g_object_unref(G_OBJECT(piximage.pixbuf));
	gdk_draw_drawable(gtree.frame_right_pixmap, _GK.draw1_GC, pixmap,
					0, 0, 0, y_frame, overlap, height);
	if (mask && gtree.frame_right_mask)
		gdk_draw_drawable(gtree.frame_right_mask, _GK.bit1_GC, mask,
					0, 0, 0, y_frame, overlap, height);
	else if (mask || gtree.frame_right_mask)
		frame_transparency_warning();

	gkrellm_free_pixmap(&pixmap);
	gkrellm_free_bitmap(&mask);
	}

static void
draw_frame_overlaps(void)
	{
	GList				*list;
	GkrellmMonitor		*mon;
	GkrellmMonprivate	*mp;
	GkrellmChart		*cp;
	GkrellmPanel		*p;
	GkrellmMargin		*m;
	gint				y;
	static GkrellmBorder zero_border;

	for (list = gkrellm_get_chart_list(); list; list = list->next)
		{
		cp = (GkrellmChart *) list->data;
		mon = (GkrellmMonitor *) cp->monitor;
		if (!mon->privat->enabled || !cp->shown || cp->y_mapped < 0)
			continue;

		m = gkrellm_get_style_margins(cp->style);
		y = cp->y_mapped - _GK.frame_top_height;

		draw_left_frame_overlap(cp->bg_piximage->pixbuf,
					&_GK.frame_left_chart_border, y - m->top,
					_GK.frame_left_chart_overlap, cp->h + m->top + m->bottom);
		draw_right_frame_overlap(cp->bg_piximage->pixbuf,
					&_GK.frame_right_chart_border, y - m->top,
					_GK.frame_right_chart_overlap, cp->h + m->top + m->bottom);
		}
	for (list = gkrellm_get_panel_list(); list; list = list->next)
		{
		p = (GkrellmPanel *) list->data;
		mon = (GkrellmMonitor *) p->monitor;
		if (!mon->privat->enabled || !p->shown || p->y_mapped < 0)
			continue;
		y = p->y_mapped;

		/* Special case:  hostname is in an event box and its y_mapped is
		|  relative to that event box window, or 0.  All other panels/charts
		|  are relative to the top level window which includes the top frame.
		*/
		if (mon != gkrellm_mon_host())
			y -= _GK.frame_top_height;

		draw_left_frame_overlap(p->bg_piximage->pixbuf,
					&_GK.frame_left_panel_border, y,
					_GK.frame_left_panel_overlap, p->h);
		draw_right_frame_overlap(p->bg_piximage->pixbuf,
					&_GK.frame_right_panel_border, y,
					_GK.frame_right_panel_overlap, p->h);
		}
	for (list = gkrellm_monitor_list; list; list = list->next)
		{
		mon = (GkrellmMonitor *) list->data;
		mp = mon->privat;
		if (!mp->enabled || !mp->spacers_shown)
			continue;
		if (mp->top_spacer.image && !mp->spacer_overlap_off)
			{
			y = mp->top_spacer.image->allocation.y;
			if (mon != gkrellm_mon_host())
				y -= _GK.frame_top_height;
			draw_left_frame_overlap(mp->top_spacer.piximage->pixbuf,
					&zero_border, y,
					_GK.frame_left_spacer_overlap, mp->top_spacer.height);
			draw_right_frame_overlap(mp->top_spacer.piximage->pixbuf,
					&zero_border, y,
					_GK.frame_right_spacer_overlap, mp->top_spacer.height);
			}
		if (mp->bottom_spacer.image && !mp->spacer_overlap_off)
			{
			y = mp->bottom_spacer.image->allocation.y;
			if (mon != gkrellm_mon_host())
				y -= _GK.frame_top_height;
			draw_left_frame_overlap(mp->bottom_spacer.piximage->pixbuf,
					&zero_border, y,
					_GK.frame_left_spacer_overlap, mp->bottom_spacer.height);
			draw_right_frame_overlap(mp->bottom_spacer.piximage->pixbuf,
					&zero_border, y,
					_GK.frame_right_spacer_overlap, mp->bottom_spacer.height);
			}
		draw_frame_caps(mon);
		}
	}

static gint	freeze_packing;

void
gkrellm_freeze_side_frame_packing(void)
	{
	freeze_packing += 1;
	}

void
gkrellm_thaw_side_frame_packing(void)
	{
	if (freeze_packing > 0)
		{
		freeze_packing -= 1;
		if (freeze_packing == 0)
			gkrellm_pack_side_frames();
		}
	}

void
gkrellm_pack_side_frames(void)
	{
	static GtkWidget	*lf_image, *rf_image;
	gint				x_gkrell, y_gkrell, y_bottom;
	gint				w, h;
	gboolean			was_on_bottom;

	if (   ! _GK.initialized
		|| (   monitor_previous_height == _GK.monitor_height
			&& !_GK.need_frame_packing
		   )
		|| freeze_packing
	   )
		return;
	_GK.need_frame_packing = FALSE;
	if (decorated)
		{
		_GK.frame_left_width = 0;
		_GK.frame_right_width = 0;
		return;
		}

	gdk_window_get_origin(gtree.window->window, &x_gkrell, &y_gkrell);
	gdk_drawable_get_size(gtree.window->window, &w, &h);
	was_on_bottom = (y_gkrell + h >= _GK.h_display) ? TRUE : FALSE;

	gkrellm_scale_piximage_to_pixmap(_GK.frame_left_piximage,
				&gtree.frame_left_pixmap, &gtree.frame_left_mask,
				_GK.frame_left_width, _GK.monitor_height);
	gkrellm_scale_piximage_to_pixmap(_GK.frame_right_piximage,
				&gtree.frame_right_pixmap, &gtree.frame_right_mask,
				_GK.frame_right_width, _GK.monitor_height);
	draw_frame_overlaps();

	if (!lf_image)
		{
		lf_image = gtk_image_new_from_pixmap(gtree.frame_left_pixmap, NULL);
		gtk_box_pack_start(GTK_BOX(gtree.left_vbox), lf_image,
					FALSE, FALSE, 0);
		gtk_widget_show(lf_image);
		}
	else
		gtk_image_set_from_pixmap(GTK_IMAGE(lf_image),
					gtree.frame_left_pixmap, NULL);

	if (!rf_image)
		{
		rf_image = gtk_image_new_from_pixmap(gtree.frame_right_pixmap, NULL);
		gtk_box_pack_start(GTK_BOX(gtree.right_vbox), rf_image,
					FALSE, FALSE, 0);	
		gtk_widget_show(rf_image);
		}
	else
		gtk_image_set_from_pixmap(GTK_IMAGE(rf_image),
					gtree.frame_right_pixmap, NULL);

	/* If height changed so that all of GKrellM would be visible if at last
	|  user set _GK.y_position, then make sure we are really at the user set
	|  _GK.y_position.   This is a y memory effect in case a previous
	|  side frame packing caused a y move.
	*/
	h = _GK.monitor_height + _GK.total_frame_height;
	y_bottom = _GK.h_display - (_GK.y_position + h);
	if (y_bottom >= 0)
		{
		if (_GK.y_position != y_gkrell && _GK.position_valid)
			{
			gdk_window_move(gtree.window->window,
							_GK.x_position, _GK.y_position);
			if (_GK.debug_level & DEBUG_POSITION)
				printf("pack moveto %d %d=y_position (y_gkrell=%d y_bot=%d)\n",
						_GK.x_position, _GK.y_position, y_gkrell, y_bottom);
			}
		y_pack = -1;
		}
	else	/* Otherwise, do a y move to maximize visibility */
		{
		/* If GKrellM grows in height and bottom is moved off screen, move so
		|  that all of GKrellM is visible.
		*/
		y_bottom = _GK.h_display - (y_gkrell + h);
		if (y_bottom < 0)
			{
			if ((y_pack = y_gkrell + y_bottom) < 0)
				y_pack = 0;
			if (_GK.position_valid)
				{
				gdk_window_move(gtree.window->window, _GK.x_position, y_pack);
				if (_GK.debug_level & DEBUG_POSITION)
					printf("pack moveto %d %d=y_pack (y_gkrell=%d y_bot=%d)\n",
							_GK.x_position, y_pack, y_gkrell, y_bottom);
				}
			}
		/* If GKrellM bottom edge was <= screen bottom, then move to make
		|  resized GKrellM still on bottom whether window has shrunk or grown.
		*/
		else if (was_on_bottom)
			{
			if ((y_pack = _GK.h_display - h) < 0)
				y_pack = 0;
			if (_GK.position_valid)
				{
				gdk_window_move(gtree.window->window, _GK.x_position, y_pack);
				if (_GK.debug_level & DEBUG_POSITION)
					printf("pack moveto %d %d=y_pack (y_gkrell=%d on_bottom)\n",
							_GK.x_position, y_pack, y_gkrell);
				}
			}
		}
	monitor_previous_height = _GK.monitor_height;
	check_rootpixmap_transparency = 3;
	}

static gint	on_edge[4];		/* left, right, top, bottom */

static void
edge_record()
	{
	gint	x, y, w, h;

	gdk_window_get_origin(gtree.window->window, &x, &y);
	gdk_drawable_get_size(gtree.window->window, &w, &h);
	on_edge[0] = (x <= 0) ? TRUE : FALSE;
	on_edge[1] = (x + w >= _GK.w_display) ? TRUE : FALSE;
	on_edge[2] = (y <= 0) ? TRUE : FALSE;
	on_edge[3] = (y + h >= _GK.h_display) ? TRUE : FALSE;
	}

static void
fix_edges()
	{
	gint	x, y, w, h, x0, y0, y_bottom;

	if (!_GK.position_valid)
		return;
	gdk_window_get_origin(gtree.window->window, &x, &y);
	w = _GK.chart_width + _GK.frame_left_width + _GK.frame_right_width;
	h = _GK.monitor_height + _GK.total_frame_height;

	x0 = x;
	y0 = y;
	if (x < 0 || on_edge[0])
		x = 0;
	if (x > _GK.w_display - w || on_edge[1])
		x = _GK.w_display - w;
	if (y < 0 || on_edge[2])
		y = 0;
	if (y > _GK.h_display - h || on_edge[3])
		y = _GK.h_display - h;

	/* Make sure we bias to last user set _GK.y_position
	*/
	y_bottom = _GK.h_display - (_GK.y_position + h);
	if (y_bottom >= 0)
		y = _GK.y_position;
	if (x != x0 || y != y0)
		{
		/* A theme change move adjustment to keep all visible, but treat this
		|  as a packing move so can bias to the last user set _GK.y_position.
		*/
		gdk_window_move(gtree.window->window, x, y);
		if (y != _GK.y_position)
			y_pack = y;
		if (_GK.debug_level & DEBUG_POSITION)
			printf("fix_edges: %d %d (y_pos=%d)\n", x, y, _GK.y_position);
		}
	}

  /* Put an image in the spacer and chart top/bottom margin boxes accounting
  |  for regions excluded by frame overlaps.
  */
gboolean
gkrellm_render_spacer(GkrellmSpacer *spacer, gint y_src, gint h_src,
			gint l_overlap, gint r_overlap)
	{
	GkrellmPiximage	piximage;
	GdkPixbuf		*pixbuf;
	gint			w_pixbuf, h_pixbuf, w_overlap;

	pixbuf = spacer->piximage->pixbuf;
	w_pixbuf = gdk_pixbuf_get_width(pixbuf);
	h_pixbuf = gdk_pixbuf_get_height(pixbuf);
	w_overlap = l_overlap + r_overlap;

	if (   spacer->height <= 0
		|| h_src > h_pixbuf || y_src < 0 || w_overlap >= w_pixbuf
	   )
		{
		if (spacer->height > 0)
			fprintf(stderr, "Bad image size for spacer or bg_chart.\n");
		return FALSE;
		}
	piximage.border = spacer->piximage->border;
	gkrellm_border_adjust(&piximage.border, -l_overlap, -r_overlap,
				-piximage.border.top, -piximage.border.bottom);

	piximage.pixbuf = gdk_pixbuf_new_subpixbuf(pixbuf, l_overlap, y_src,
				w_pixbuf - w_overlap, (h_src == 0) ? h_pixbuf : h_src);
	gkrellm_scale_piximage_to_pixmap(&piximage, &spacer->clean_pixmap,
				&spacer->mask, _GK.chart_width, spacer->height);
	g_object_unref(G_OBJECT(piximage.pixbuf));
	gkrellm_clone_pixmap(&spacer->pixmap, &spacer->clean_pixmap);
	spacer->image = gtk_image_new_from_pixmap(spacer->pixmap, spacer->mask);
	gtk_container_add(GTK_CONTAINER(spacer->vbox), spacer->image);
	gtk_widget_show_all(spacer->vbox);
	return TRUE;
	}

static void
render_monitor_spacers(GkrellmMonitor *mon)
	{
	GkrellmMonprivate	*mp = mon->privat;
	GkrellmSpacer		*top_spacer, *bottom_spacer;

	top_spacer = &mp->top_spacer;
	bottom_spacer = &mp->bottom_spacer;
	if (top_spacer->image)
		gtk_widget_destroy(top_spacer->image);
	if (bottom_spacer->image)
		gtk_widget_destroy(bottom_spacer->image);
	top_spacer->image = bottom_spacer->image = NULL;

	if (top_spacer->piximage)
		{
		if (top_spacer->height < 0)
			top_spacer->height = (mp->style_type == CHART_PANEL_TYPE) ?