1 files changed, 421 insertions, 0 deletions
diff --git a/src/core/frame.c b/src/core/frame.c
new file mode 100644
index 00000000..2d0bbb51
--- /dev/null
+++ b/src/core/frame.c
@@ -0,0 +1,421 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+/* Marco X window decorations */
+
+/* 
+ * Copyright (C) 2001 Havoc Pennington
+ * Copyright (C) 2003, 2004 Red Hat, Inc.
+ * Copyright (C) 2005 Elijah Newren
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <config.h>
+#include "frame-private.h"
+#include "bell.h"
+#include "errors.h"
+#include "keybindings.h"
+
+#ifdef HAVE_RENDER
+#include <X11/extensions/Xrender.h>
+#endif
+
+#define EVENT_MASK (SubstructureRedirectMask | \
+ StructureNotifyMask | SubstructureNotifyMask | \
+ ExposureMask | \
+ ButtonPressMask | ButtonReleaseMask | \
+ PointerMotionMask | PointerMotionHintMask | \
+ EnterWindowMask | LeaveWindowMask | \
+ FocusChangeMask | \
+ ColormapChangeMask)
+
+void
+meta_window_ensure_frame (MetaWindow *window)
+{
+ MetaFrame *frame;
+ XSetWindowAttributes attrs;
+ Visual *visual;
+ 
+ if (window->frame)
+ return;
+ 
+ /* See comment below for why this is required. */
+ meta_display_grab (window->display);
+ 
+ frame = g_new (MetaFrame, 1);
+
+ frame->window = window;
+ frame->xwindow = None;
+
+ frame->rect = window->rect;
+ frame->child_x = 0;
+ frame->child_y = 0;
+ frame->bottom_height = 0;
+ frame->right_width = 0;
+ frame->current_cursor = 0;
+
+ frame->mapped = FALSE;
+ frame->need_reapply_frame_shape = TRUE;
+ frame->is_flashing = FALSE;
+ 
+ meta_verbose ("Framing window %s: visual %s default, depth %d default depth %d\n",
+ window->desc,
+ XVisualIDFromVisual (window->xvisual) ==
+ XVisualIDFromVisual (window->screen->default_xvisual) ?
+ "is" : "is not",
+ window->depth, window->screen->default_depth);
+ meta_verbose ("Frame geometry %d,%d %dx%d\n",
+ frame->rect.x, frame->rect.y,
+ frame->rect.width, frame->rect.height);
+ 
+ /* Default depth/visual handles clients with weird visuals; they can
+ * always be children of the root depth/visual obviously, but
+ * e.g. DRI games can't be children of a parent that has the same
+ * visual as the client. NULL means default visual.
+ *
+ * We look for an ARGB visual if we can find one, otherwise use
+ * the default of NULL.
+ */
+ 
+ /* Special case for depth 32 windows (assumed to be ARGB),
+ * we use the window's visual. Otherwise we just use the system visual.
+ */
+ if (window->depth == 32)
+ visual = window->xvisual;
+ else
+ visual = NULL;
+ 
+ frame->xwindow = meta_ui_create_frame_window (window->screen->ui,
+ window->display->xdisplay,
+ visual,
+ frame->rect.x,
+ frame->rect.y,
+ frame->rect.width,
+ frame->rect.height,
+ frame->window->screen->number);
+
+ meta_verbose ("Frame for %s is 0x%lx\n", frame->window->desc, frame->xwindow);
+ attrs.event_mask = EVENT_MASK;
+ XChangeWindowAttributes (window->display->xdisplay,
+ frame->xwindow, CWEventMask, &attrs);
+ 
+ meta_display_register_x_window (window->display, &frame->xwindow, window);
+
+ /* Now that frame->xwindow is registered with window, we can set its
+ * background.
+ */
+ meta_ui_reset_frame_bg (window->screen->ui, frame->xwindow);
+
+ /* Reparent the client window; it may be destroyed,
+ * thus the error trap. We'll get a destroy notify later
+ * and free everything. Comment in FVWM source code says
+ * we need a server grab or the child can get its MapNotify
+ * before we've finished reparenting and getting the decoration
+ * window onscreen, so ensure_frame must be called with
+ * a grab.
+ */
+ meta_error_trap_push (window->display);
+ if (window->mapped)
+ {
+ window->mapped = FALSE; /* the reparent will unmap the window,
+ * we don't want to take that as a withdraw
+ */
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "Incrementing unmaps_pending on %s for reparent\n", window->desc);
+ window->unmaps_pending += 1;
+ }
+ /* window was reparented to this position */
+ window->rect.x = 0;
+ window->rect.y = 0;
+
+ XReparentWindow (window->display->xdisplay,
+ window->xwindow,
+ frame->xwindow,
+ window->rect.x,
+ window->rect.y);
+ /* FIXME handle this error */
+ meta_error_trap_pop (window->display, FALSE);
+ 
+ /* stick frame to the window */
+ window->frame = frame;
+ 
+ if (window->title)
+ meta_ui_set_frame_title (window->screen->ui,
+ window->frame->xwindow,
+ window->title);
+
+ /* Move keybindings to frame instead of window */
+ meta_window_grab_keys (window);
+
+ /* Shape mask */
+ meta_ui_apply_frame_shape (frame->window->screen->ui,
+ frame->xwindow,
+ frame->rect.width,
+ frame->rect.height,
+ frame->window->has_shape);
+ frame->need_reapply_frame_shape = FALSE;
+ 
+ meta_display_ungrab (window->display);
+}
+
+void
+meta_window_destroy_frame (MetaWindow *window)
+{
+ MetaFrame *frame;
+ 
+ if (window->frame == NULL)
+ return;
+
+ meta_verbose ("Unframing window %s\n", window->desc);
+ 
+ frame = window->frame;
+ 
+ meta_bell_notify_frame_destroy (frame);
+ 
+ /* Unparent the client window; it may be destroyed,
+ * thus the error trap.
+ */
+ meta_error_trap_push (window->display);
+ if (window->mapped)
+ {
+ window->mapped = FALSE; /* Keep track of unmapping it, so we
+ * can identify a withdraw initiated
+ * by the client.
+ */
+ meta_topic (META_DEBUG_WINDOW_STATE,
+ "Incrementing unmaps_pending on %s for reparent back to root\n", window->desc);
+ window->unmaps_pending += 1;
+ }
+ XReparentWindow (window->display->xdisplay,
+ window->xwindow,
+ window->screen->xroot,
+ /* Using anything other than meta_window_get_position()
+ * coordinates here means we'll need to ensure a configure
+ * notify event is sent; see bug 399552.
+ */
+ window->frame->rect.x,
+ window->frame->rect.y);
+ meta_error_trap_pop (window->display, FALSE);
+
+ meta_ui_destroy_frame_window (window->screen->ui, frame->xwindow);
+
+ meta_display_unregister_x_window (window->display,
+ frame->xwindow);
+ 
+ window->frame = NULL;
+
+ /* Move keybindings to window instead of frame */
+ meta_window_grab_keys (window);
+ 
+ g_free (frame);
+ 
+ /* Put our state back where it should be */
+ meta_window_queue (window, META_QUEUE_CALC_SHOWING);
+ meta_window_queue (window, META_QUEUE_MOVE_RESIZE);
+}
+
+
+MetaFrameFlags
+meta_frame_get_flags (MetaFrame *frame)
+{
+ MetaFrameFlags flags;
+
+ flags = 0;
+
+ if (frame->window->border_only)
+ {
+ ; /* FIXME this may disable the _function_ as well as decor
+ * in some cases, which is sort of wrong.
+ */
+ }
+ else
+ {
+ flags |= META_FRAME_ALLOWS_MENU;
+ 
+ if (frame->window->has_close_func)
+ flags |= META_FRAME_ALLOWS_DELETE;
+ 
+ if (frame->window->has_maximize_func)
+ flags |= META_FRAME_ALLOWS_MAXIMIZE;
+ 
+ if (frame->window->has_minimize_func)
+ flags |= META_FRAME_ALLOWS_MINIMIZE;
+ 
+ if (frame->window->has_shade_func)
+ flags |= META_FRAME_ALLOWS_SHADE;
+ } 
+ 
+ if (META_WINDOW_ALLOWS_MOVE (frame->window))
+ flags |= META_FRAME_ALLOWS_MOVE;
+
+ if (META_WINDOW_ALLOWS_HORIZONTAL_RESIZE (frame->window))
+ flags |= META_FRAME_ALLOWS_HORIZONTAL_RESIZE;
+
+ if (META_WINDOW_ALLOWS_VERTICAL_RESIZE (frame->window))
+ flags |= META_FRAME_ALLOWS_VERTICAL_RESIZE;
+ 
+ if (frame->window->has_focus)
+ flags |= META_FRAME_HAS_FOCUS;
+
+ if (frame->window->shaded)
+ flags |= META_FRAME_SHADED;
+
+ if (frame->window->on_all_workspaces)
+ flags |= META_FRAME_STUCK;
+
+ /* FIXME: Should we have some kind of UI for windows that are just vertically
+ * maximized or just horizontally maximized?
+ */
+ if (META_WINDOW_MAXIMIZED (frame->window))
+ flags |= META_FRAME_MAXIMIZED;
+
+ if (frame->window->fullscreen)
+ flags |= META_FRAME_FULLSCREEN;
+
+ if (frame->is_flashing)
+ flags |= META_FRAME_IS_FLASHING;
+
+ if (frame->window->wm_state_above)
+ flags |= META_FRAME_ABOVE;
+ 
+ return flags;
+}
+
+void
+meta_frame_calc_geometry (MetaFrame *frame,
+ MetaFrameGeometry *geomp)
+{
+ MetaFrameGeometry geom;
+ MetaWindow *window;
+
+ window = frame->window;
+
+ meta_ui_get_frame_geometry (window->screen->ui,
+ frame->xwindow,
+ &geom.top_height,
+ &geom.bottom_height,
+ &geom.left_width,
+ &geom.right_width);
+ 
+ *geomp = geom;
+}
+
+static void
+update_shape (MetaFrame *frame)
+{
+ if (frame->need_reapply_frame_shape)
+ {
+ meta_ui_apply_frame_shape (frame->window->screen->ui,
+ frame->xwindow,
+ frame->rect.width,
+ frame->rect.height,
+ frame->window->has_shape);
+ frame->need_reapply_frame_shape = FALSE;
+ }
+}
+
+void
+meta_frame_sync_to_window (MetaFrame *frame,
+ int resize_gravity,
+ gboolean need_move,
+ gboolean need_resize)
+{
+ if (!(need_move || need_resize))
+ {
+ update_shape (frame);
+ return;
+ }
+
+ meta_topic (META_DEBUG_GEOMETRY,
+ "Syncing frame geometry %d,%d %dx%d (SE: %d,%d)\n",
+ frame->rect.x, frame->rect.y,
+ frame->rect.width, frame->rect.height,
+ frame->rect.x + frame->rect.width,
+ frame->rect.y + frame->rect.height);
+
+ /* set bg to none to avoid flicker */
+ if (need_resize)
+ {
+ meta_ui_unflicker_frame_bg (frame->window->screen->ui,
+ frame->xwindow,
+ frame->rect.width,
+ frame->rect.height);
+
+ /* we need new shape if we're resized */
+ frame->need_reapply_frame_shape = TRUE;
+ }
+
+ /* Done before the window resize, because doing it before means
+ * part of the window being resized becomes unshaped, which may
+ * be sort of hard to see with bg = None. If we did it after
+ * window resize, part of the window being resized would become
+ * shaped, which might be more visible.
+ */
+ update_shape (frame);
+ 
+ meta_ui_move_resize_frame (frame->window->screen->ui,
+ frame->xwindow,
+ frame->rect.x,
+ frame->rect.y,
+ frame->rect.width,
+ frame->rect.height);
+
+ if (need_resize)
+ {
+ meta_ui_reset_frame_bg (frame->window->screen->ui,
+ frame->xwindow);
+
+ /* If we're interactively resizing the frame, repaint
+ * it immediately so we don't start to lag.
+ */
+ if (frame->window->display->grab_window ==
+ frame->window)
+ meta_ui_repaint_frame (frame->window->screen->ui,
+ frame->xwindow);
+ }
+}
+
+void
+meta_frame_queue_draw (MetaFrame *frame)
+{
+ meta_ui_queue_frame_draw (frame->window->screen->ui,
+ frame->xwindow);
+}
+
+void
+meta_frame_set_screen_cursor (MetaFrame *frame,
+ MetaCursor cursor)
+{
+ Cursor xcursor;
+ if (cursor == frame->current_cursor)
+ return;
+ frame->current_cursor = cursor;
+ if (cursor == META_CURSOR_DEFAULT)
+ XUndefineCursor (frame->window->display->xdisplay, frame->xwindow);
+ else
+ { 
+ xcursor = meta_display_create_x_cursor (frame->window->display, cursor);
+ XDefineCursor (frame->window->display->xdisplay, frame->xwindow, xcursor);
+ XFlush (frame->window->display->xdisplay);
+ XFreeCursor (frame->window->display->xdisplay, xcursor);
+ }
+}
+
+Window
+meta_frame_get_xwindow (MetaFrame *frame)
+{
+ return frame->xwindow;
+}