winops-x11.c

系统任务管理器

		printf("gkrellm: %s\n",
			_("Exiting because multiple instances option is off.\n"));
		exit(0);
		}
	smc_connect(argc, argv);
	display = GDK_WINDOW_XDISPLAY(gkrellm_get_top_window()->window);
	window  = GDK_WINDOW_XWINDOW(gkrellm_get_top_window()->window);

	/* Set window type or list of states using standard EWMH hints.
	|  See http://www.freedesktop.org/
	|  At least KDE3 and GNOME2 are EWMH compliant.
	*/
	if (_GK.dock_type && !_GK.command_line_decorated)
		{
		atoms[0] = XInternAtom(display, "_NET_WM_WINDOW_TYPE_DOCK", False);
    
		XChangeProperty(display, window,
					XInternAtom(display, "_NET_WM_WINDOW_TYPE", False),
					XA_ATOM, 32, PropModeReplace, (guchar *) atoms, 1);
		_GK.is_dock_type = TRUE;
		_GK.state_skip_taskbar = FALSE;
		_GK.state_skip_pager = FALSE;
		}
	if (_GK.state_skip_taskbar)
		{
		atoms[n] = XInternAtom(display, "_NET_WM_STATE_SKIP_TASKBAR", False);
		++n;
		}
	if (_GK.state_skip_pager)
		{
		atoms[n] = XInternAtom(display, "_NET_WM_STATE_SKIP_PAGER", False);
		++n;
		}
	if (_GK.state_above)
		{
		atoms[n++] = XInternAtom(display, "_NET_WM_STATE_ABOVE", False);
		/* see gkrellm_winop_state_above() */
		atoms[n++] = XInternAtom(display, "_NET_WM_STATE_STAYS_ON_TOP", False);
		_GK.state_below = FALSE;
		}
	if (_GK.state_below)
		{
		atoms[n] = XInternAtom(display, "_NET_WM_STATE_BELOW", False);
		++n;
		}
	if (n > 0)
		XChangeProperty(display, window,
					XInternAtom(display, "_NET_WM_STATE", False),
					XA_ATOM, 32, PropModeReplace, (guchar *) atoms, n);
	} 

void
gkrellm_winop_withdrawn(void)
	{
	Display		*display;
	Window		window;

	if (!_GK.withdrawn)
		return;
	display = GDK_WINDOW_XDISPLAY(gkrellm_get_top_window()->window);
	window  = GDK_WINDOW_XWINDOW(gkrellm_get_top_window()->window);

	if (!_GK.is_dock_type)
		{
		XWMHints mywmhints; 
		mywmhints.initial_state = WithdrawnState; 
		mywmhints.flags=StateHint;

		XSetWMHints(display, window, &mywmhints); 
		}
	else
		gkrellm_message_dialog(NULL,
			_("Warning: -w flag is ignored when the window dock type is set"));
	}

  /* Use XParseGeometry, but width and height are ignored.
  |  If GKrellM is moved, update _GK.y_position.
  */
void
gkrellm_winop_place_gkrellm(gchar *geom)
    {
	gint	place, x, y, w_gkrell, h_gkrell;

	x = y = 0;
	place = XParseGeometry(geom, &x, &y,
				(guint *) &w_gkrell, (guint *) &h_gkrell);

	w_gkrell = _GK.chart_width + _GK.frame_left_width + _GK.frame_right_width;
	h_gkrell = _GK.monitor_height + _GK.total_frame_height;

	if (place & YNegative)
		y = _GK.h_display - h_gkrell + y;
	if (place & XNegative)
		x = _GK.w_display - w_gkrell + x;
	gdk_window_move(gkrellm_get_top_window()->window, x, y);
	_GK.y_position = y;
	_GK.x_position = x;
	_GK.position_valid = TRUE;
	if (_GK.debug_level & DEBUG_POSITION)
		printf("geometry moveto %d %d\n", x, y);
	}

void
gkrellm_winop_flush_motion_events(void)
	{
	XEvent			xevent;

	gdk_flush();
	while (XCheckTypedEvent(GDK_DISPLAY(), MotionNotify, &xevent))
		;
	}

  /* Check if background has changed
  */
gboolean
gkrellm_winop_updated_background(void)
	{
	Pixmap	root_pix = None;
	Atom	prop, ret_type = (Atom) 0;
	guchar	*prop_return = NULL;
	gint	fmt;
	gulong	nitems, bytes_after;
  
	if (!_GK.any_transparency)
		return FALSE;
	prop = XInternAtom(GDK_DISPLAY(), "_XROOTPMAP_ID", True);
	if (prop == None)
		return FALSE;
  
	XGetWindowProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(), prop, 0L, 1L, False,
			AnyPropertyType, &ret_type, &fmt, &nitems, &bytes_after,
			&prop_return);
	if (prop_return && ret_type == XA_PIXMAP)
		{
		root_pix = *((Pixmap *) prop_return);
		XFree(prop_return);
		}
	else
		return FALSE;

	if (root_pix != root_xpixmap)
		{
		root_xpixmap = root_pix;
		return TRUE;
		}
	return FALSE;
	}

gboolean
gkrellm_winop_draw_rootpixmap_onto_transparent_chart(GkrellmChart *cp)
	{
	Window			child;
	GkrellmMargin	*m;
	gint			x, y;

	if (   root_xpixmap == None || !cp->transparency
		|| !cp->drawing_area || !cp->drawing_area->window
	   )
		return FALSE;
	XTranslateCoordinates(GDK_DISPLAY(),
			GDK_WINDOW_XWINDOW(cp->drawing_area->window),
			GDK_ROOT_WINDOW(),
			0, 0, &x, &y, &child);
	XSetTSOrigin(GDK_DISPLAY(), GDK_GC_XGC(trans_gc), -x, -y);

	/* First make the chart totally transparent
	*/
	gdk_draw_rectangle(cp->bg_src_pixmap, trans_gc,
					TRUE, 0, 0, cp->w, cp->h);

	/* If mode permits, stencil on non transparent parts of bg_clean_pixmap.
	*/
	if (cp->transparency == 2 && cp->bg_mask)
		{
		gdk_gc_set_clip_mask(_GK.text_GC, cp->bg_mask);
		gdk_draw_drawable(cp->bg_src_pixmap, _GK.text_GC,
				cp->bg_clean_pixmap, 0, 0, 0, 0, cp->w, cp->h);
		}
	m = &cp->style->margin;
	if (cp->top_spacer.pixmap)
		{
		XSetTSOrigin(GDK_DISPLAY(), GDK_GC_XGC(trans_gc), -x, -(y - m->top));
		gdk_draw_rectangle(cp->top_spacer.pixmap, trans_gc,
					TRUE, 0, 0, cp->w, cp->style->margin.top);
		if (cp->transparency == 2 && cp->top_spacer.mask)
			{
			gdk_gc_set_clip_mask(_GK.text_GC, cp->top_spacer.mask);
			gdk_draw_drawable(cp->top_spacer.pixmap, _GK.text_GC,
						cp->top_spacer.clean_pixmap, 0, 0, 0, 0,
						cp->w, cp->style->margin.top);
			}
		gtk_image_set_from_pixmap(GTK_IMAGE(cp->top_spacer.image),
					cp->top_spacer.pixmap, NULL);
		}

	if (cp->bottom_spacer.pixmap)
		{
		XSetTSOrigin(GDK_DISPLAY(), GDK_GC_XGC(trans_gc),
					-x, -(y + cp->h - m->bottom));
		gdk_draw_rectangle(cp->bottom_spacer.pixmap, trans_gc,
					TRUE, 0, 0, cp->w, cp->style->margin.bottom);
		if (cp->transparency == 2 && cp->bottom_spacer.mask)
			{
			gdk_gc_set_clip_mask(_GK.text_GC, cp->bottom_spacer.mask);
			gdk_draw_drawable(cp->bottom_spacer.pixmap, _GK.text_GC,
						cp->bottom_spacer.clean_pixmap, 0, 0, 0, 0,
						cp->w, cp->style->margin.bottom);
			}
		gtk_image_set_from_pixmap(GTK_IMAGE(cp->bottom_spacer.image),
					cp->bottom_spacer.pixmap, NULL);
		}
	gdk_gc_set_clip_mask(_GK.text_GC, NULL);
	cp->bg_sequence_id += 1;
	return TRUE;
	}	

gboolean
gkrellm_winop_draw_rootpixmap_onto_transparent_panel(GkrellmPanel *p)
	{
	Window	child;
	gint	x, y;

	if (   root_xpixmap == None || !p->transparency
		|| !p->drawing_area || !p->drawing_area->window
	   )
		return FALSE;
	XTranslateCoordinates(GDK_DISPLAY(),
			GDK_WINDOW_XWINDOW(p->drawing_area->window),
			GDK_ROOT_WINDOW(),
			0, 0, &x, &y, &child);
	XSetTSOrigin(GDK_DISPLAY(), GDK_GC_XGC(trans_gc), -x, -y);

	/* First make the panel totally transparent
	*/
	gdk_draw_rectangle(p->bg_pixmap, trans_gc, TRUE, 0, 0, p->w, p->h);

	/* If mode permits, stencil on non transparent parts of bg_clean_pixmap.
	*/
	if (p->transparency == 2 && p->bg_mask)
		{
        gdk_gc_set_clip_mask(_GK.text_GC, p->bg_mask);
        gdk_draw_drawable(p->bg_pixmap, _GK.text_GC, p->bg_clean_pixmap,
                    0, 0, 0, 0, p->w, p->h);
        gdk_gc_set_clip_mask(_GK.text_GC, NULL);
		}
	return TRUE;
	}	

static void
draw_rootpixmap_onto_transparent_spacers(GkrellmMonitor *mon, gint xr, gint yr)
	{
	GkrellmMonprivate	*mp = mon->privat;
	gint				x, y;

	if (mp->top_spacer.image)
		{
		x = xr + mp->top_spacer.image->allocation.x;
		y = yr + mp->top_spacer.image->allocation.y;
		XSetTSOrigin(GDK_DISPLAY(), GDK_GC_XGC(trans_gc), -x, -y);
		gdk_draw_rectangle(mp->top_spacer.pixmap, trans_gc,
				TRUE, 0, 0, _GK.chart_width, mp->top_spacer.height);
		if (mp->top_spacer.mask)
			{
			gdk_gc_set_clip_mask(_GK.text_GC, mp->top_spacer.mask);
			gdk_draw_drawable(mp->top_spacer.pixmap, _GK.text_GC,
						mp->top_spacer.clean_pixmap, 0, 0, 0, 0,
						_GK.chart_width, mp->top_spacer.height);
			}
		gtk_image_set_from_pixmap(GTK_IMAGE(mp->top_spacer.image),
				mp->top_spacer.pixmap, NULL);
		}
	if (mp->bottom_spacer.image)
		{
		x = xr + mp->bottom_spacer.image->allocation.x;
		y = yr + mp->bottom_spacer.image->allocation.y;
		XSetTSOrigin(GDK_DISPLAY(), GDK_GC_XGC(trans_gc), -x, -y);
		gdk_draw_rectangle(mp->bottom_spacer.pixmap, trans_gc,
				TRUE, 0, 0, _GK.chart_width, mp->bottom_spacer.height);
		if (mp->bottom_spacer.mask)
			{
			gdk_gc_set_clip_mask(_GK.text_GC, mp->bottom_spacer.mask);
			gdk_draw_drawable(mp->bottom_spacer.pixmap, _GK.text_GC,
						mp->bottom_spacer.clean_pixmap, 0, 0, 0, 0,
						_GK.chart_width, mp->bottom_spacer.height);
			}
		gtk_image_set_from_pixmap(GTK_IMAGE(mp->bottom_spacer.image),
				mp->bottom_spacer.pixmap, NULL);
		}
	}

void
gkrellm_winop_apply_rootpixmap_transparency(void)
	{
	Window			child;
	GtkWidget		*top_window = gkrellm_get_top_window();
	Atom			prop,
					ret_type	= (Atom) 0;
	GList			*list;
	GkrellmMonitor	*mon;
	GkrellmChart	*cp;
	GkrellmPanel	*p;
	guchar			*prop_return = NULL;
	gint			fmt;
	gulong			nitems, bytes_after;
	gint			depth_visual;
	Window			root_return;
	guint			w_ret, h_ret, bw_ret, depth_ret;
	gint			x_ret, y_ret, x_root, y_root;

	if (!_GK.any_transparency)
		return;
	prop = XInternAtom(GDK_DISPLAY(), "_XROOTPMAP_ID", True);
	if (prop == None)
		return;
	XGetWindowProperty(GDK_DISPLAY(), GDK_ROOT_WINDOW(), prop, 0L, 1L, False,
			AnyPropertyType, &ret_type, &fmt, &nitems, &bytes_after,
			&prop_return);
	if (prop_return && ret_type == XA_PIXMAP)
		{
		root_xpixmap = *((Pixmap *) prop_return);
		XFree(prop_return);
		}
	if (root_xpixmap == None)
		return;
	if (trans_gc == NULL)
		{
		trans_gc = gdk_gc_new(top_window->window);
		gdk_gc_copy(trans_gc, _GK.draw1_GC);
		}

	depth_ret = 0;
	depth_visual = gdk_drawable_get_visual(top_window->window)->depth;
	if (   !XGetGeometry(GDK_DISPLAY(), root_xpixmap, &root_return,
				&x_ret, &y_ret, &w_ret, &h_ret, &bw_ret, &depth_ret)
		|| depth_ret != depth_visual
	   )
		{
		root_xpixmap = None;
		return;
		}

	/* I could use gdk_pixmap_foreign_new() and stay in the gdk domain,
	|  but it fails (in XGetGeometry()) if I change backgrounds.
	*/
	XSetTile(GDK_DISPLAY(), GDK_GC_XGC(trans_gc), root_xpixmap);
	XSetFillStyle(GDK_DISPLAY(), GDK_GC_XGC(trans_gc), FillTiled);
	for (list = gkrellm_get_chart_list(); list; list = list->next)
		{
		cp = (GkrellmChart *) list->data;
		if (!cp->transparency || !cp->shown)
			continue;
		gkrellm_winop_draw_rootpixmap_onto_transparent_chart(cp);
		gkrellm_refresh_chart(cp);
		}
	for (list = gkrellm_get_panel_list(); list; list = list->next)
		{
		p = (GkrellmPanel *) list->data;
		if (!p->transparency || !p->shown)
			continue;
		gkrellm_draw_panel_label(p);
		}
	XTranslateCoordinates(GDK_DISPLAY(),
			GDK_WINDOW_XWINDOW(top_window->window),
			GDK_ROOT_WINDOW(),
			0, 0, &x_root, &y_root, &child);
	for (list = gkrellm_monitor_list; list; list = list->next)
		{
		mon = (GkrellmMonitor *) list->data;
		draw_rootpixmap_onto_transparent_spacers(mon, x_root, y_root);
		}
	gdk_gc_set_clip_mask(_GK.text_GC, NULL);
	}