main.c

系统任务管理器

		   )
			{
			t = style->margin.top;
			b = style->margin.bottom;
			}
		else
			{
			t = style->border.top * _GK.theme_scale / 100;
			b = style->border.bottom * _GK.theme_scale / 100;
			}
		}
	if (top)
		*top = t;
	if (bottom)
		*bottom = b;
	}

GkrellmMargin *
gkrellm_get_style_margins(GkrellmStyle *style)
	{
	static GkrellmMargin	m_default = {0,0,0,0};

	if (!style)
		return &m_default;
	gkrellm_get_top_bottom_margins(style,
				&style->margin.top, &style->margin.bottom);		/* XXX */
	return &style->margin;
	}

void
gkrellm_set_style_margins(GkrellmStyle *style, GkrellmMargin *margin)
	{
	if (style && margin)
		style->margin = *margin;
	}

void
gkrellm_draw_string(GdkDrawable *drawable, GkrellmTextstyle *ts,
			gint x, gint y, gchar *s)
	{
	if (!drawable || !ts || !s)
		return;
	if (ts->effect)
		{
		gdk_gc_set_foreground(_GK.text_GC, &ts->shadow_color);
		gkrellm_gdk_draw_string(drawable, ts->font, _GK.text_GC,
					x + 1, y + 1, s);
		}
	gdk_gc_set_foreground(_GK.text_GC, &ts->color);
	gkrellm_gdk_draw_string(drawable, ts->font, _GK.text_GC, x, y, s);
	}

void
gkrellm_draw_text(GdkDrawable *drawable, GkrellmTextstyle *ts, gint x, gint y,
			gchar *s, gint len)
	{
	if (!drawable || !ts || !s)
		return;
	if (ts->effect)
		{
		gdk_gc_set_foreground(_GK.text_GC, &ts->shadow_color);
		gkrellm_gdk_draw_text(drawable, ts->font, _GK.text_GC,
					x + 1, y + 1, s, len);
		}
	gdk_gc_set_foreground(_GK.text_GC, &ts->color);
	gkrellm_gdk_draw_text(drawable, ts->font, _GK.text_GC, x, y, s, len);
	}

gint
gkrellm_label_x_position(gint position, gint w_field, gint w_label,
				gint margin)
	{
	gint	x;

	x = w_field * position / GKRELLM_LABEL_MAX;
	x -= w_label / 2;
	if (x > w_field - w_label - margin)
		x = w_field - w_label - margin;
	if (x < margin)
		x = margin;
	return x;
	}

/* ---------------------------------------------------------------------- */
#define	RESISTANCE_PIXELS	35

static gint		moving_gkrellm	= FALSE;
static gint		x_press_event, y_press_event;
static gint		gkrellm_width, gkrellm_height;

void
gkrellm_motion(GtkWidget *widget, GdkEventMotion *ev, gpointer data)
	{
	gint			x_pointer, y_pointer, x, y, right_zone, bottom_zone;
	GdkModifierType	m;

	if (moving_gkrellm)
		{
		m = ev->state;
		if (!(m & GDK_BUTTON1_MASK))
			{
			moving_gkrellm = FALSE;
			return;
			}
		/* Catch up to the pointer so GKrellM does not lag the pointer motion.
		*/
		gkrellm_winop_flush_motion_events();
		gdk_window_get_pointer(NULL, &x_pointer, &y_pointer, &m);

		/* Subtract press event coordinates to account for pointer offset
		|  into top_window.  Have edge resistance to the move.
		*/
		x = x_pointer - x_press_event;
		y = y_pointer - y_press_event;
		right_zone = _GK.w_display - gkrellm_width;
		bottom_zone = _GK.h_display - gkrellm_height;

		if (_GK.x_position >= 0 && x < 0 && x > -RESISTANCE_PIXELS)
			x = 0;
		if (   _GK.x_position <= right_zone
			&& x > right_zone && x < right_zone + RESISTANCE_PIXELS
		   )
			x = right_zone;
		if (_GK.y_position >= 0 && y < 0 && y > -RESISTANCE_PIXELS)
			y = 0;
		if (   _GK.y_position <= bottom_zone
			&& y > bottom_zone && y < bottom_zone + RESISTANCE_PIXELS
		   )
			y = bottom_zone;

		/* Moves to x,y position relative to root.
		*/
		_GK.y_position = y;
		_GK.x_position = x;
		_GK.position_valid = TRUE;
		gdk_window_move(top_window->window, x, y);
		}
	}

void
gkrellm_menu_popup(void)
	{
	gtk_menu_popup(GTK_MENU(item_factory->widget), NULL, NULL, NULL, NULL,
					0, gtk_get_current_event_time());
	}

static void
top_frame_button_release(GtkWidget *widget, GdkEventButton *ev, gpointer data)
	{
	if (!no_transparency)
		gkrellm_winop_apply_rootpixmap_transparency();
	moving_gkrellm = FALSE;
	if (_GK.debug_level & DEBUG_POSITION)
		printf("gkrellm moveto: x_pos=%d y_pos=%d\n",
				_GK.x_position, _GK.y_position);
	}

static gboolean
top_frame_button_press(GtkWidget *widget, GdkEventButton *ev, gpointer data)
	{
	gint			x_pointer, y_pointer;
	GdkModifierType	m;
	time_t			time_check;

	gdk_window_get_pointer(NULL, &x_pointer, &y_pointer, &m);
	gdk_window_get_geometry(NULL, NULL, NULL, &_GK.w_display,
				&_GK.h_display, NULL);
	gkrellm_width = _GK.chart_width
				+ _GK.frame_left_width + _GK.frame_right_width;
	gkrellm_height = _GK.monitor_height + _GK.total_frame_height;

	/* If system time is changed, gtk_timeout_add() setting gets
	|  confused, so put some duct tape here ...
	*/
	time(&time_check);
	if (time_check > _GK.time_now + 2 || time_check < _GK.time_now)
		gkrellm_start_timer(_GK.update_HZ);

	if (ev->button == 3)
		{
		gtk_menu_popup(GTK_MENU(item_factory->widget), NULL, NULL, NULL, NULL,
					ev->button, ev->time);
		return FALSE;
		}
	gtk_window_present(GTK_WINDOW(top_window));

	if (_GK.client_mode && gkrellm_client_server_connect_state() == 0)
		gkrellm_client_mode_connect_thread();

	if (!_GK.withdrawn)		/* Move window unless in the slit */
		{
		/* I need pointer coords relative to top_window.  So, add in offsets
		|  to hostname window if that is where we pressed.
		*/
		x_press_event = ev->x;
		y_press_event = ev->y;
		if (widget == gtree.top1_event_box)
			{
			x_press_event += _GK.frame_left_width;
			y_press_event += _GK.frame_top_height;
			}
		moving_gkrellm = TRUE;
		configure_position_lock = FALSE;
		}
	return FALSE;
	}

#define	CLOSE_LEFT	0
#define	CLOSE_RIGHT	1


  /* If any frame images have transparency (masks != NULL) use the
  |  frame masks to construct a main window sized mask.
  */
static void
apply_frame_transparency(gboolean force)
	{
	GtkWidget			*win;
	gint				w, h;
	static gint			w_prev, h_prev;

	if (decorated)
		return;

	win = gtree.window;
	w = _GK.chart_width + _GK.frame_left_width + _GK.frame_right_width;
	h = _GK.monitor_height + _GK.total_frame_height;
	if (!gtree.window_transparency_mask || w != w_prev || h != h_prev)
		{
		if (gtree.window_transparency_mask)
			g_object_unref(G_OBJECT(gtree.window_transparency_mask));
		gtree.window_transparency_mask = gdk_pixmap_new(win->window, w, h, 1);
		w_prev = w;
		h_prev = h;
		}
	else if (!force && monitors_visible == mask_monitors_visible)
		return;

	/* Set entire shape mask to 1, then write in the frame masks.
	*/
	gdk_draw_rectangle(gtree.window_transparency_mask, _GK.bit1_GC, TRUE,
				0, 0, w, h);

	if (monitors_visible)
		{
		if (gtree.frame_top_mask)
			gdk_draw_drawable(gtree.window_transparency_mask, _GK.bit1_GC,
				gtree.frame_top_mask, 0, 0,  0, 0,  w, _GK.frame_top_height);
		if (gtree.frame_bottom_mask)
			gdk_draw_drawable(gtree.window_transparency_mask, _GK.bit1_GC,
				gtree.frame_bottom_mask,
				0, 0, 0, h - _GK.frame_bottom_height,
				w, _GK.frame_bottom_height);

		if (gtree.frame_left_mask)
			gdk_draw_drawable(gtree.window_transparency_mask, _GK.bit1_GC,
				gtree.frame_left_mask,
				0, 0,  0, _GK.frame_top_height,
				_GK.frame_left_width, _GK.monitor_height);

		if (gtree.frame_right_mask)
			gdk_draw_drawable(gtree.window_transparency_mask, _GK.bit1_GC,
				gtree.frame_right_mask,
				0, 0,  w - _GK.frame_right_width, _GK.frame_top_height,
				_GK.frame_right_width, _GK.monitor_height);
		}
	else	/* Top and bottom frames are not visible and GKrellM is shut */
		{
		if (gtree.frame_left_mask)
			gdk_draw_drawable(gtree.window_transparency_mask, _GK.bit1_GC,
				gtree.frame_left_mask,
				0, 0,  0, 0,
				_GK.frame_left_width, _GK.monitor_height);

		if (gtree.frame_right_mask)
			gdk_draw_drawable(gtree.window_transparency_mask, _GK.bit1_GC,
				gtree.frame_right_mask,
				0, 0,  _GK.frame_left_width, 0,
				_GK.frame_right_width, _GK.monitor_height);
		}

	gtk_widget_shape_combine_mask(gtree.window,
						gtree.window_transparency_mask, 0, 0);
	mask_monitors_visible = monitors_visible;
	}

static gboolean
side_frame_button_press(GtkWidget *widget, GdkEventButton *ev, gpointer data)
	{
	static gint		direction;
	gint			x_gkrell, y_gkrell;

	if (ev->button == 3)
		{
		gtk_menu_popup(GTK_MENU(item_factory->widget), NULL, NULL, NULL, NULL,
					ev->button, ev->time);
		return FALSE;
		}
	if (decorated || _GK.withdrawn)
		return FALSE;
	gdk_window_get_origin(gtree.window->window, &x_gkrell, &y_gkrell);
	direction = (x_gkrell < _GK.w_display / 2) ? CLOSE_LEFT : CLOSE_RIGHT;

	if (ev->button == 2 || (_GK.m2 && ev->button == 1))
		{
		monitors_visible = !monitors_visible;
		if (monitors_visible)
			{
			gtk_widget_show(gtree.middle_vbox);
			gtk_widget_show(gtree.top0_vbox);
			gtk_widget_show(gtree.bottom_vbox);
			if (direction == CLOSE_RIGHT)
				gdk_window_move(gtree.window->window,
								x_gkrell - _GK.chart_width, y_gkrell);
			}
		else
			{
			gtk_widget_hide(gtree.top0_vbox);
			gtk_widget_hide(gtree.bottom_vbox);
			gtk_widget_hide(gtree.middle_vbox);
			if (direction == CLOSE_RIGHT)
				gdk_window_move(gtree.window->window,
								x_gkrell + _GK.chart_width, y_gkrell);
			}
		gdk_flush();  /* Avoid double click race */
		}
	return FALSE;
	}


static void
create_frame_top(GtkWidget *vbox)
	{
	static GtkWidget	*ft_vbox;
	static GtkWidget	*ft_image;
	GkrellmPiximage		*im;
	gint				w, h;

	if (decorated)
		return;
	im = _GK.frame_top_piximage;

	w = _GK.chart_width + _GK.frame_left_width + _GK.frame_right_width;
	h = (_GK.frame_top_height > 0) ? _GK.frame_top_height
				: gdk_pixbuf_get_height(im->pixbuf);
//	h = h * _GK.theme_scale / 100;

	_GK.frame_top_height = h;

	_GK.total_frame_height += h;
	gkrellm_scale_piximage_to_pixmap(im,
				&gtree.frame_top_pixmap, &gtree.frame_top_mask, w, h);

	if (!ft_vbox)
		{
		ft_vbox = gtk_vbox_new(FALSE, 0);
		gtk_container_add(GTK_CONTAINER(vbox), ft_vbox);
		gtk_widget_show(ft_vbox);

		ft_image = gtk_image_new_from_pixmap(gtree.frame_top_pixmap, NULL);
		gtk_box_pack_start(GTK_BOX(ft_vbox), ft_image, FALSE, FALSE, 0);
		gtk_widget_show(ft_image);
		}
	else
		gtk_image_set_from_pixmap(GTK_IMAGE(ft_image),
				gtree.frame_top_pixmap, NULL);
	}

static void
create_frame_bottom(GtkWidget *vbox)
	{
	static GtkWidget	*fb_vbox;
	static GtkWidget	*fb_image;
	GkrellmPiximage		*im;
	gint				w, h;

	if (decorated)
		return;
	im = _GK.frame_bottom_piximage;

	w = _GK.chart_width + _GK.frame_left_width + _GK.frame_right_width;
	h = (_GK.frame_bottom_height > 0) ? _GK.frame_bottom_height
				: gdk_pixbuf_get_height(im->pixbuf);
//	h = h * _GK.theme_scale / 100;

	_GK.frame_bottom_height = h;

	_GK.total_frame_height += h;
	gkrellm_scale_piximage_to_pixmap(im,
				&gtree.frame_bottom_pixmap, &gtree.frame_bottom_mask, w, h);
	if (fb_vbox == NULL)
		{
		fb_vbox = gtk_vbox_new(FALSE, 0);
		gtk_container_add(GTK_CONTAINER(vbox), fb_vbox);
		gtk_widget_show(fb_vbox);

		fb_image = gtk_image_new_from_pixmap(gtree.frame_bottom_pixmap, NULL);
		gtk_box_pack_start(GTK_BOX(fb_vbox), fb_image, FALSE, FALSE, 0);
		gtk_widget_show(fb_image);
		}
	else
		gtk_image_set_from_pixmap(GTK_IMAGE(fb_image),
				gtree.frame_bottom_pixmap, NULL);
	}

static void
frame_transparency_warning(void)
    {
    static gint warned = -1;

	if (warned != _GK.theme_reload_count && _GK.command_line_theme)
		fprintf(stderr,
"Warning: frame overlap transparency may not work.  If any of the frame,\n"
"         chart, panel, spacer, or cap images have transparency, then all\n"
"         may need transparency.\n");
	warned = _GK.theme_reload_count;
	}

static void
draw_cap(GkrellmPiximage *piximage, gint y_mon, gint h_mon, gint h_spacer,
		gboolean top, gboolean left)
	{
	GdkPixmap	*pixmap = NULL;
	GdkBitmap	*mask = NULL;
	GdkBitmap	*frame_mask;
	gint		y, x_dst, h_pix, w_pix, h_cap;

	if (!piximage || !piximage->pixbuf)
		return;
	h_pix = gdk_pixbuf_get_height(piximage->pixbuf);
	w_pix = gdk_pixbuf_get_width(piximage->pixbuf);
//	h_pix = h_pix * _GK.theme_scale / 100;
//	w_pix = w_pix * _GK.theme_scale / 100;

	y = top ? y_mon + h_spacer : y_mon + h_mon - h_pix - h_spacer;
	if (y < y_mon)
		y = y_mon;

	h_cap = (y + h_pix <= y_mon + h_mon) ? h_pix : y_mon + h_mon - y;
	if (h_cap <= 0)
		return;

	x_dst = left ? 0 : _GK.frame_right_width - w_pix;
	gkrellm_scale_piximage_to_pixmap(piximage, &pixmap, &mask, w_pix, h_pix);
	gdk_draw_drawable(
				left ? gtree.frame_left_pixmap : gtree.frame_right_pixmap,
				_GK.draw1_GC, pixmap, 0, 0, x_dst, y, w_pix, h_cap);

	frame_mask = left ? gtree.frame_left_mask : gtree.frame_right_mask;
	if (mask && frame_mask)
		gdk_draw_drawable(frame_mask, _GK.bit1_GC, mask,