gdkwindow-xynth.c

超强的嵌入式GUI系统

	GdkWindow       *b;
	GdkWindow       *event_win;
	
	ENTER();
	
	/* Do a possible cursor change before checking if we need to
	   generate crossing events so cursor changes due to pointer
	   grabs work correctly. */
	{
		static GdkCursorXYNTH *last_cursor = NULL;
		GdkWindowObject       *private = GDK_WINDOW_OBJECT(dest);
		GdkWindowImplXYNTH    *impl    = GDK_WINDOW_IMPL_XYNTH(private->impl);
		GdkCursorXYNTH        *cursor;
		
		if (_gdk_xynth_pointer_grab_cursor) {
			cursor = (GdkCursorXYNTH *) _gdk_xynth_pointer_grab_cursor;
		} else {
			cursor = (GdkCursorXYNTH *) impl->cursor;
		}
		if (cursor != last_cursor) {
			win     = gdk_xynth_window_find_toplevel(dest);
			private = GDK_WINDOW_OBJECT(win);
			impl    = GDK_WINDOW_IMPL_XYNTH(private->impl);
			
			if (impl->xynth_window) {
				DEBUG("Change cursor here!");
				NIY();
			}
			last_cursor = cursor;
		}
	}
	if (dest == gdk_xynth_window_containing_pointer) {
		LEAVE();
		return;
	}
	if (gdk_xynth_window_containing_pointer == NULL) {
		gdk_xynth_window_containing_pointer = g_object_ref(_gdk_parent_root);
	}
	if (src) {
		a = src;
	} else {
		a = gdk_xynth_window_containing_pointer;
	}
	b = dest;
	if (a == b) {
		LEAVE();
		return;
	}
	/* gdk_xynth_window_containing_pointer might have been destroyed.
	 * The refcount we hold on it should keep it, but it's parents
	 * might have died.
	 */
	if (GDK_WINDOW_DESTROYED(a)) {
		a = _gdk_parent_root;
	}
	gdk_xynth_mouse_get_info(&x, &y, &modifiers);
	c = gdk_xynth_find_common_ancestor(a, b);
	non_linear = (c != a) && (c != b);
	event_win = gdk_xynth_pointer_event_window(a, GDK_LEAVE_NOTIFY);
	if (event_win) {
		event = gdk_xynth_event_make(event_win, GDK_LEAVE_NOTIFY);
		event->crossing.subwindow = NULL;
		gdk_window_get_origin(a, &x_int, &y_int);
		event->crossing.x      = x - x_int;
		event->crossing.y      = y - y_int;
		event->crossing.x_root = x;
		event->crossing.y_root = y;
		event->crossing.mode   = mode;
		if (non_linear) {
			event->crossing.detail = GDK_NOTIFY_NONLINEAR;
		} else if (c == a) {
			event->crossing.detail = GDK_NOTIFY_INFERIOR;
		} else {
			event->crossing.detail = GDK_NOTIFY_ANCESTOR;
		}
		event->crossing.focus = FALSE;
		event->crossing.state = modifiers;
	}
	/* Traverse up from a to (excluding) c */
	if (c != a) {
		last = a;
		win = GDK_WINDOW(GDK_WINDOW_OBJECT(a)->parent);
		while (win != c) {
			event_win = gdk_xynth_pointer_event_window (win, GDK_LEAVE_NOTIFY);
			if (event_win) {
				event = gdk_xynth_event_make(event_win, GDK_LEAVE_NOTIFY);
				event->crossing.subwindow = g_object_ref(last);
				gdk_window_get_origin (win, &x_int, &y_int);
				event->crossing.x      = x - x_int;
				event->crossing.y      = y - y_int;
				event->crossing.x_root = x;
				event->crossing.y_root = y;
				event->crossing.mode   = mode;
				if (non_linear) {
					event->crossing.detail = GDK_NOTIFY_NONLINEAR_VIRTUAL;
				} else {
					event->crossing.detail = GDK_NOTIFY_VIRTUAL;
				}
				event->crossing.focus = FALSE;
				event->crossing.state = modifiers;
			}
			last = win;
			win = GDK_WINDOW(GDK_WINDOW_OBJECT(win)->parent);
		}
	}
	/* Traverse down from c to b */
	if (c != b) {
		path = NULL;
		win = GDK_WINDOW(GDK_WINDOW_OBJECT(b)->parent);
		while (win != c) {
			path = g_slist_prepend(path, win);
			win = GDK_WINDOW(GDK_WINDOW_OBJECT(win)->parent);
		}
		list = path;
		while (list) {
			win = GDK_WINDOW(list->data);
			list = g_slist_next(list);
			if (list) {
				next = GDK_WINDOW (list->data);
			} else {
				next = b;
			}
			event_win = gdk_xynth_pointer_event_window(win, GDK_ENTER_NOTIFY);
			if (event_win) {
				event = gdk_xynth_event_make(event_win, GDK_ENTER_NOTIFY);
				event->crossing.subwindow = g_object_ref(next);
				gdk_window_get_origin(win, &x_int, &y_int);
				event->crossing.x      = x - x_int;
				event->crossing.y      = y - y_int;
				event->crossing.x_root = x;
				event->crossing.y_root = y;
				event->crossing.mode   = mode;
				if (non_linear) {
					event->crossing.detail = GDK_NOTIFY_NONLINEAR_VIRTUAL;
				} else {
					event->crossing.detail = GDK_NOTIFY_VIRTUAL;
				}
				event->crossing.focus = FALSE;
				event->crossing.state = modifiers;
			}
		}
		g_slist_free(path);
	}
	event_win = gdk_xynth_pointer_event_window(b, GDK_ENTER_NOTIFY);
	if (event_win) {
		event = gdk_xynth_event_make(event_win, GDK_ENTER_NOTIFY);
		event->crossing.subwindow = NULL;
		gdk_window_get_origin(b, &x_int, &y_int);
		event->crossing.x      = x - x_int;
		event->crossing.y      = y - y_int;
		event->crossing.x_root = x;
		event->crossing.y_root = y;
		event->crossing.mode   = mode;
		if (non_linear) {
			event->crossing.detail = GDK_NOTIFY_NONLINEAR;
		} else if (c == a) {
			event->crossing.detail = GDK_NOTIFY_ANCESTOR;
		} else {
			event->crossing.detail = GDK_NOTIFY_INFERIOR;
		}
		event->crossing.focus = FALSE;
		event->crossing.state = modifiers;
	}
	if (mode != GDK_CROSSING_GRAB) {
		/* this seems to cause focus to change as the pointer moves yuck
		 * gdk_xynth_change_focus(b);
		 */
		if (b != gdk_xynth_window_containing_pointer) {
			g_object_unref(gdk_xynth_window_containing_pointer);
			gdk_xynth_window_containing_pointer = g_object_ref(b);
		}
	}
	LEAVE();
}

void gdk_window_set_cursor (GdkWindow *window, GdkCursor *cursor)
{
	GdkWindowImplXYNTH *impl;
	GdkCursor          *old_cursor;
	ENTER();
	if (GDK_IS_WINDOW(window) == 0) {
		LEAVE();
	}
	impl = GDK_WINDOW_IMPL_XYNTH(GDK_WINDOW_OBJECT(window)->impl);
	old_cursor = impl->cursor;
	impl->cursor = (cursor ? gdk_cursor_ref(cursor) : gdk_cursor_new(GDK_LEFT_PTR));
	if (gdk_window_at_pointer(NULL, NULL) == window) {
		/* This is a bit evil but we want to keep all cursor changes in
		 * one place, so let gdk_xynth_window_send_crossing_events
		 * do the work for us. */
		gdk_xynth_window_send_crossing_events(window, window, GDK_CROSSING_NORMAL);
	} else if (impl->xynth_window) {
		GdkCursorXYNTH *xynth_cursor = (GdkCursorXYNTH *) impl->cursor;
		/* this branch takes care of setting the cursor for unmapped windows */
		NIY();
	}
	if (old_cursor) {
		gdk_cursor_unref(old_cursor);
	}
	LEAVE();

}

void gdk_window_set_decorations (GdkWindow *window, GdkWMDecoration decorations)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

void gdk_window_set_events (GdkWindow *window, GdkEventMask event_mask)
{
	ENTER();
	if (GDK_IS_WINDOW(window) == 0) {
		LEAVE();
		return;
	}
	if (event_mask & GDK_BUTTON_MOTION_MASK) {
		event_mask |= (GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK | GDK_BUTTON3_MOTION_MASK);
	}
	GDK_WINDOW_OBJECT(window)->event_mask = event_mask;
	LEAVE();
}

void gdk_window_set_functions (GdkWindow *window, GdkWMFunction functions)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

void gdk_window_set_geometry_hints (GdkWindow *window, GdkGeometry *geometry, GdkWindowHints geom_mask)
{
	g_return_if_fail(GDK_IS_WINDOW(window));
	ENTER();
	if (GDK_WINDOW_DESTROYED(window)) {
		return;
	}
	NIY();
	LEAVE();
}

void gdk_window_set_icon (GdkWindow *window, GdkWindow *icon_window, GdkPixmap *pixmap, GdkBitmap *mask)
{
	g_return_if_fail(GDK_IS_WINDOW(window));
	ENTER();
	if (GDK_WINDOW_DESTROYED(window)) {
		return;
	}
	NIY();
	LEAVE();
}

void gdk_window_set_icon_list (GdkWindow *window, GList *pixbufs)
{
	g_return_if_fail(GDK_IS_WINDOW(window));
	ENTER();
	if (GDK_WINDOW_DESTROYED(window)) {
		return;
	}
	NIY();
	LEAVE();
}

void gdk_window_set_keep_above (GdkWindow *window, gboolean setting)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

void gdk_window_set_keep_below (GdkWindow *window, gboolean setting)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

void gdk_window_set_modal_hint (GdkWindow *window, gboolean modal)
{
	GdkWindowImplXYNTH *impl;
	g_return_if_fail(GDK_IS_WINDOW(window));
	ENTER();
	if (GDK_WINDOW_DESTROYED(window)) {
		return;
	}
	impl = GDK_WINDOW_IMPL_XYNTH(GDK_WINDOW_OBJECT(window)->impl);
	if (impl->xynth_window) {
		NIY();
	}
	LEAVE();
}

void gdk_window_set_role (GdkWindow *window, const gchar *role)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

void gdk_window_set_skip_pager_hint (GdkWindow *window, gboolean skips_pager)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

void gdk_window_set_skip_taskbar_hint (GdkWindow *window, gboolean skips_taskbar)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

void gdk_window_set_title (GdkWindow *window, const gchar *title)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

void gdk_window_set_transient_for (GdkWindow *window, GdkWindow *parent)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

void gdk_window_set_type_hint (GdkWindow *window, GdkWindowTypeHint hint)
{
	ENTER();
	if (GDK_IS_WINDOW(window) == 0) {
		LEAVE();
		return;
	}
	if (GDK_WINDOW_DESTROYED(window)) {
		LEAVE();
		return;
	}
	DEBUG("gdk_window_set_type_hint: %d", hint);
	((GdkWindowImplXYNTH *) ((GdkWindowObject *) window)->impl)->type_hint = hint;
	LEAVE();
}

void gdk_window_set_urgency_hint (GdkWindow *window, gboolean urgent)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

void gdk_window_shape_combine_mask (GdkWindow *window, GdkBitmap *mask, gint x, gint y)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

void gdk_window_show_unraised (GdkWindow *window)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

static gboolean all_parents_shown (GdkWindowObject *private)
{
	ENTER();
	while (GDK_WINDOW_IS_MAPPED(private)) {
		if (private->parent) {
			private = GDK_WINDOW_OBJECT (private)->parent;
		} else {
			LEAVE();
			return TRUE;
		}
	}
	LEAVE();
	return FALSE;
}

static void send_map_events (GdkWindowObject *private)
{
	GList *list;
	GdkWindow *event_win;
	ENTER();
	if (!GDK_WINDOW_IS_MAPPED(private)) {
		LEAVE();
		return;
	}
	event_win = gdk_xynth_other_event_window((GdkWindow *) private, GDK_MAP);
	if (event_win) {
		gdk_xynth_event_make(event_win, GDK_MAP);
	}
	for (list = private->children; list; list = list->next) {
		send_map_events (list->data);
	}
	LEAVE();
}

static void show_window_internal (GdkWindow *window, gboolean raise)
{
	GdkWindowObject *private;
	GdkWindowImplXYNTH *impl;
	GdkWindow *mousewin;
	ENTER();
	private = GDK_WINDOW_OBJECT(window);
	impl = GDK_WINDOW_IMPL_XYNTH(private->impl);
	if (!private->destroyed && !GDK_WINDOW_IS_MAPPED(private)) {
		private->state &= ~GDK_WINDOW_STATE_WITHDRAWN;
		if (raise) {
			gdk_window_raise(window);
		}
		if (all_parents_shown(GDK_WINDOW_OBJECT(private)->parent)) {
			send_map_events(private);
			mousewin = gdk_window_at_pointer(NULL, NULL);
			gdk_xynth_window_send_crossing_events(NULL, mousewin, GDK_CROSSING_NORMAL);
			if (private->input_only) {
				return;
			}
			gdk_window_invalidate_rect(window, NULL, TRUE);
		}
	}
	LEAVE();
}

void gdk_window_show (GdkWindow *window)
{
	g_return_if_fail(GDK_IS_WINDOW(window));
	ENTER();
	show_window_internal(window, FALSE);
	LEAVE();
}

void gdk_window_stick (GdkWindow *window)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

void gdk_window_unfullscreen (GdkWindow *window)
{
	ENTER();
	NIY();
	ASSERT();
	LEAVE();
}

void gdk_window_unmaximize (GdkWindow *window)
{
	g_return_if_fail(GDK_IS_WINDOW(window));
	ENTER();
	if (GDK_WINDOW_DESTROYED(window)) {
		LEAVE();
		return;
	}
	NIY();
	LEAVE();
}

void gdk_window_unstick (GdkWindow *window)
{
	g_return_if_fail(GDK_IS_WINDOW(window));
	ENTER();
	if (GDK_WINDOW_DESTROYED(window)) {