+++ /dev/null
-/*
- * Rootless window management
- */
-/*
- * Copyright (c) 2001 Greg Parker. All Rights Reserved.
- * Copyright (c) 2002 Torrey T. Lyons. All Rights Reserved.
- * Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the name(s) of the above copyright
- * holders shall not be used in advertising or otherwise to promote the sale,
- * use or other dealings in this Software without prior written authorization.
- */
-/* Portions of this file are based on fbwindow.c, which contains the
- * following copyright:
- *
- * Copyright © 1998 Keith Packard
- */
-/* $XFree86: xc/programs/Xserver/hw/darwin/quartz/rootlessWindow.c,v 1.11 2002/09/28 00:43:39 torrey Exp $ */
-
-#include "rootless-common.h"
-#include "rootless-window.h"
-#include "darwin.h"
-#include "Xplugin.h"
-#include "x-hash.h"
-#include "x-list.h"
-#define _APPLEWM_SERVER_
-#include "applewmstr.h"
-
-#include "fb.h"
-#include "propertyst.h"
-
-#ifdef PANORAMIX
-#include "panoramiX.h"
-#include "panoramiXsrv.h"
-#endif
-
-#include <X11/Xatom.h>
-#include <pthread.h>
-
-#define DEFINE_ATOM_HELPER(func,atom_name) \
-static Atom func (void) { \
- static unsigned int generation; \
- static Atom atom; \
- if (generation != serverGeneration) { \
- generation = serverGeneration; \
- atom = MakeAtom (atom_name, strlen (atom_name), TRUE); \
- } \
- return atom; \
-}
-
-DEFINE_ATOM_HELPER (xa_native_screen_origin, "_NATIVE_SCREEN_ORIGIN")
-DEFINE_ATOM_HELPER (xa_native_window_id, "_NATIVE_WINDOW_ID")
-DEFINE_ATOM_HELPER (xa_apple_no_order_in, "_APPLE_NO_ORDER_IN")
-
-/* Maps xp_window_id -> AquaWindowRec */
-static x_hash_table *window_hash;
-static pthread_mutex_t window_hash_mutex;
-
-static Bool no_configure_window;
-static Bool windows_hidden;
-
-static const int normal_window_levels[AppleWMNumWindowLevels+1] = {
- 0, 3, 4, 5, LONG_MIN + 30, LONG_MIN + 29,
-};
-static const int rooted_window_levels[AppleWMNumWindowLevels+1] = {
- 202, 203, 204, 205, 201, 200
-};
-
-static inline xp_error
-configure_window (xp_window_id id, unsigned int mask,
- const xp_window_changes *values)
-{
- if (!no_configure_window)
- return xp_configure_window (id, mask, values);
- else
- return XP_Success;
-}
-
-static inline unsigned long
-current_time_in_seconds (void)
-{
- unsigned long t = 0;
-
- t += currentTime.milliseconds / 1000;
- t += currentTime.months * 4294967;
-
- return t;
-}
-
-static inline Bool
-rootlessHasRoot (ScreenPtr pScreen)
-{
- return WINREC (WindowTable[pScreen->myNum]) != NULL;
-}
-
-void
-RootlessNativeWindowStateChanged (xp_window_id id, unsigned int state)
-{
- WindowPtr pWin;
- RootlessWindowRec *winRec;
-
- pWin = RootlessGetXWindow (id);
- if (pWin == NULL)
- return;
-
- winRec = WINREC (pWin);
- if (winRec == NULL)
- return;
-
- winRec->is_offscreen = (state & XP_WINDOW_STATE_OFFSCREEN) != 0;
- winRec->is_obscured = (state & XP_WINDOW_STATE_OBSCURED) != 0;
-
-#ifdef ROOTLESS
- pWin->rootlessUnhittable = winRec->is_offscreen;
-#endif
-}
-
-void
-RootlessNativeWindowMoved (xp_window_id id)
-{
- WindowPtr pWin;
- xp_box bounds;
- int sx, sy;
- XID vlist[2];
- Mask mask;
- ClientPtr client;
-
- pWin = RootlessGetXWindow (id);
- if (pWin == NULL)
- return;
-
- if (xp_get_window_bounds (id, &bounds) != Success)
- return;
-
- sx = dixScreenOrigins[pWin->drawable.pScreen->myNum].x + darwinMainScreenX;
- sy = dixScreenOrigins[pWin->drawable.pScreen->myNum].y + darwinMainScreenY;
-
- /* Fake up a ConfigureWindow packet to resize the window to the
- current bounds. */
-
- vlist[0] = (INT16) bounds.x1 - sx;
- vlist[1] = (INT16) bounds.y1 - sy;
- mask = CWX | CWY;
-
- /* pretend we're the owner of the window! */
- client = LookupClient (pWin->drawable.id, NullClient);
-
- /* Don't want to do anything to the physical window (avoids
- notification-response feedback loops) */
-
- no_configure_window = TRUE;
- ConfigureWindow (pWin, mask, vlist, client);
- no_configure_window = FALSE;
-}
-
-/* Updates the _NATIVE_SCREEN_ORIGIN property on the given root window. */
-static void
-set_screen_origin (WindowPtr pWin)
-{
- long data[2];
-
- if (!IsRoot (pWin))
- return;
-
- /* FIXME: move this to an extension? */
-
- data[0] = (dixScreenOrigins[pWin->drawable.pScreen->myNum].x
- + darwinMainScreenX);
- data[1] = (dixScreenOrigins[pWin->drawable.pScreen->myNum].y
- + darwinMainScreenY);
-
- ChangeWindowProperty (pWin, xa_native_screen_origin (), XA_INTEGER,
- 32, PropModeReplace, 2, data, TRUE);
-}
-
-/* For now, don't create a physical window until either the window is
- realized, or we really need it (e.g. to attach VRAM surfaces to).
- Do reset the window size so it's not clipped by the root window. */
-Bool
-RootlessCreateWindow (WindowPtr pWin)
-{
- Bool result;
- RegionRec saveRoot;
-
- SCREEN_UNWRAP (pWin->drawable.pScreen, CreateWindow);
-
- if (!IsRoot (pWin))
- {
- /* win/border size set by DIX, not by wrapped CreateWindow, so
- correct it here. Don't HUGE_ROOT when pWin is the root! */
-
- HUGE_ROOT (pWin);
- SetWinSize (pWin);
- SetBorderSize (pWin);
- }
- else
- {
- set_screen_origin (pWin);
- }
-
- result = pWin->drawable.pScreen->CreateWindow (pWin);
-
- if (pWin->parent)
- NORMAL_ROOT (pWin);
-
- SCREEN_WRAP (pWin->drawable.pScreen, CreateWindow);
-
- return result;
-}
-
-/* Destroy the physical window associated with the given window */
-static void
-rootlessDestroyFrame (WindowPtr pWin, RootlessWindowRec *winRec)
-{
- RootlessStopDrawing (pWin, FALSE);
-
- pthread_mutex_lock (&window_hash_mutex);
- x_hash_table_remove (window_hash, (void *) winRec->wid);
- pthread_mutex_unlock (&window_hash_mutex);
-
- xp_destroy_window (winRec->wid);
-
- xfree (winRec);
- WINREC (pWin) = NULL;
-}
-
-Bool
-RootlessDestroyWindow (WindowPtr pWin)
-{
- RootlessWindowRec *winRec = WINREC(pWin);
- Bool result;
-
- if (winRec != NULL)
- rootlessDestroyFrame (pWin, winRec);
-
- /* winRec is gone now */
-
- SCREEN_UNWRAP(pWin->drawable.pScreen, DestroyWindow);
-
- result = pWin->drawable.pScreen->DestroyWindow (pWin);
-
- SCREEN_WRAP(pWin->drawable.pScreen, DestroyWindow);
-
- return result;
-}
-
-#ifdef SHAPE
-static Bool
-RootlessGetShape (WindowPtr pWin, RegionPtr pShape)
-{
- if (wBoundingShape (pWin) == NULL)
- return FALSE;
-
- /* wBoundingShape is relative to *inner* origin of window.
- Translate by borderWidth to get the outside-relative position. */
-
- REGION_INIT (pScreen, pShape, NullBox, 0);
- REGION_COPY (pScreen, pShape, wBoundingShape (pWin));
- REGION_TRANSLATE (pScreen, pShape, pWin->borderWidth, pWin->borderWidth);
-
- return TRUE;
-}
-
-/* boundingShape = outside border (like borderClip)
- clipShape = inside border (like clipList)
- Both are in window-local coordinates
- We only care about boundingShape (FIXME true?)
-
- RootlessReallySetShape is used in several places other than SetShape.
- Most importantly, SetShape is often called on unmapped windows, so we
- have to wait until the window is mapped to reshape the frame. */
-static void
-rootlessSetShape (WindowPtr pWin)
-{
- RootlessWindowRec *winRec = WINREC (pWin);
-
- RegionRec newShape;
- RegionPtr pShape;
- xp_window_changes wc;
-
- if (winRec == NULL)
- return;
-
- RootlessStopDrawing (pWin, FALSE);
-
- pShape = RootlessGetShape (pWin, &newShape) ? &newShape : NULL;
-
- RL_DEBUG_MSG("reshaping...");
- RL_DEBUG_MSG("numrects %d, extents %d %d %d %d\n",
- REGION_NUM_RECTS(&newShape),
- newShape.extents.x1, newShape.extents.y1,
- newShape.extents.x2, newShape.extents.y2);
-
- RootlessDisableUpdate (pWin);
-
- if (pShape != NULL)
- {
- wc.shape_nrects = REGION_NUM_RECTS (pShape);
- wc.shape_rects = REGION_RECTS (pShape);
- }
- else
- {
- wc.shape_nrects = -1;
- wc.shape_rects = NULL;
- }
-
- wc.shape_tx = wc.shape_ty = 0;
-
- configure_window (winRec->wid, XP_SHAPE, &wc);
-
- if (pShape != NULL)
- REGION_UNINIT(pScreen, &newShape);
-}
-
-void
-RootlessSetShape (WindowPtr pWin)
-{
- ScreenPtr pScreen = pWin->drawable.pScreen;
-
- SCREEN_UNWRAP (pScreen, SetShape);
-
- pScreen->SetShape (pWin);
-
- SCREEN_WRAP (pScreen, SetShape);
-
- rootlessSetShape (pWin);
-}
-#endif
-
-/* Disallow ParentRelative background on top-level windows
- because the root window doesn't really have the right background
- and fb will try to draw on the root instead of on the window.
- ParentRelative prevention is also in PaintWindowBackground/Border()
- so it is no longer really needed here. */
-Bool
-RootlessChangeWindowAttributes (WindowPtr pWin, unsigned long vmask)
-{
- Bool result;
- ScreenPtr pScreen = pWin->drawable.pScreen;
-
- RL_DEBUG_MSG("change window attributes start\n");
-
- SCREEN_UNWRAP (pScreen, ChangeWindowAttributes);
-
- result = pScreen->ChangeWindowAttributes (pWin, vmask);
-
- SCREEN_WRAP (pScreen, ChangeWindowAttributes);
-
- if (WINREC (pWin) != NULL)
- {
- /* disallow ParentRelative background state */
-
- if (pWin->backgroundState == ParentRelative)
- {
- XID pixel = 0;
- ChangeWindowAttributes (pWin, CWBackPixel, &pixel, serverClient);
- }
- }
-
- RL_DEBUG_MSG("change window attributes end\n");
- return result;
-}
-
-/* This is a hook for when DIX moves or resizes a window.
- Update the frame position now. (x, y) are *inside* position.
- After this, mi and fb are expecting the pixmap to be at the new location. */
-Bool
-RootlessPositionWindow (WindowPtr pWin, int x, int y)
-{
- ScreenPtr pScreen = pWin->drawable.pScreen;
- RootlessWindowRec *winRec = WINREC (pWin);
- Bool result;
-
- RL_DEBUG_MSG("positionwindow start (win 0x%x)\n", pWin);
-
- if (winRec != NULL)
- {
- if (winRec->is_drawing)
- {
- /* Reset frame's pixmap and move it to the new position. */
- int bw = wBorderWidth (pWin);
-
- winRec->pixmap->devPrivate.ptr = winRec->data;
- TranslatePixmapBase (winRec->pixmap, - (x - bw), - (y - bw));
- }
- }
-
- SCREEN_UNWRAP (pScreen, PositionWindow);
-
- result = pScreen->PositionWindow (pWin, x, y);
-
- SCREEN_WRAP(pScreen, PositionWindow);
-
- RL_DEBUG_MSG("positionwindow end\n");
- return result;
-}
-
-/* Initialize some basic attributes of the frame. Note that winRec
- may already have valid data in it, so don't overwrite anything
- valuable. */
-static void
-rootlessInitializeFrame (WindowPtr pWin, RootlessWindowRec *winRec)
-{
- DrawablePtr d = &pWin->drawable;
- int bw = wBorderWidth (pWin);
-
- winRec->win = pWin;
-
- winRec->x = d->x - bw;
- winRec->y = d->y - bw;
- winRec->width = d->width + 2*bw;
- winRec->height = d->height + 2*bw;
- winRec->borderWidth = bw;
-}
-
-static void
-rootlessSetNativeProperty (RootlessWindowRec *winRec)
-{
- xp_error err;
- unsigned int native_id;
- long data;
-
- err = xp_get_native_window (winRec->wid, &native_id);
- if (err == Success)
- {
- /* FIXME: move this to an extension? */
-
- data = native_id;
- ChangeWindowProperty (winRec->win, xa_native_window_id (),
- XA_INTEGER, 32, PropModeReplace, 1, &data, TRUE);
- }
-}
-
-static xp_error
-rootlessColormapCallback (void *data, int first_color,
- int n_colors, uint32_t *colors)
-{
- return (RootlessResolveColormap (data, first_color, n_colors, colors)
- ? XP_Success : XP_BadMatch);
-}
-
-/* If the given window doesn't have a physical window associated with it,
- attempt to create one. If that's unsuccessful, return null. */
-static RootlessWindowRec *
-rootlessEnsureFrame (WindowPtr pWin)
-{
- ScreenPtr pScreen = pWin->drawable.pScreen;
- RootlessWindowRec *winRec;
- RegionRec shape;
- RegionPtr pShape = NULL;
-
- xp_window_changes wc;
- unsigned int mask;
- xp_error err;
- int sx, sy;
-
- if (WINREC (pWin) != NULL)
- return WINREC (pWin);
-
- if (pWin->drawable.class != InputOutput)
- return NULL;
-
- winRec = xalloc (sizeof(RootlessWindowRec));
-
- if (!winRec)
- return NULL;
-
- rootlessInitializeFrame (pWin, winRec);
-
- winRec->is_drawing = FALSE;
- winRec->pixmap = NULL;
- winRec->wid = 0;
- winRec->is_update_disabled = FALSE;
- winRec->is_reorder_pending = FALSE;
- winRec->level = !IsRoot (pWin) ? 0 : AppleWMNumWindowLevels;
- WINREC(pWin) = winRec;
-
-#ifdef SHAPE
- if (RootlessGetShape (pWin, &shape))
- pShape = &shape;
-#endif
-
- sx = dixScreenOrigins[pScreen->myNum].x + darwinMainScreenX;
- sy = dixScreenOrigins[pScreen->myNum].y + darwinMainScreenY;
-
- mask = 0;
-
- wc.x = sx + winRec->x;
- wc.y = sy + winRec->y;
- wc.width = winRec->width;
- wc.height = winRec->height;
- wc.bit_gravity = XP_GRAVITY_NONE;
- mask |= XP_BOUNDS;
-
- if (pWin->drawable.depth == 8)
- {
- wc.depth = XP_DEPTH_INDEX8;
- wc.colormap = rootlessColormapCallback;
- wc.colormap_data = pScreen;
- mask |= XP_COLORMAP;
- }
- else if (pWin->drawable.depth == 15)
- wc.depth = XP_DEPTH_RGB555;
- else if (pWin->drawable.depth == 24)
- wc.depth = XP_DEPTH_ARGB8888;
- else
- wc.depth = XP_DEPTH_NIL;
- mask |= XP_DEPTH;
-
- if (pShape != NULL)
- {
- wc.shape_nrects = REGION_NUM_RECTS (pShape);
- wc.shape_rects = REGION_RECTS (pShape);
- wc.shape_tx = wc.shape_ty = 0;
- mask |= XP_SHAPE;
- }
-
- if (!rootlessHasRoot (pScreen))
- wc.window_level = normal_window_levels[winRec->level];
- else
- wc.window_level = rooted_window_levels[winRec->level];
- mask |= XP_WINDOW_LEVEL;
-
- err = xp_create_window (mask, &wc, &winRec->wid);
-
- if (err != Success)
- {
- xfree (winRec);
- return NULL;
- }
-
- if (window_hash == NULL)
- {
- window_hash = x_hash_table_new (NULL, NULL, NULL, NULL);
- pthread_mutex_init (&window_hash_mutex, NULL);
- }
-
- pthread_mutex_lock (&window_hash_mutex);
- x_hash_table_insert (window_hash, (void *) winRec->wid, winRec);
- pthread_mutex_unlock (&window_hash_mutex);
-
- rootlessSetNativeProperty (winRec);
-
- if (pShape != NULL)
- REGION_UNINIT (pScreen, &shape);
-
- return winRec;
-}
-
-/* The frame is usually created here and not in CreateWindow so that
- windows do not eat memory until they are realized. */
-Bool
-RootlessRealizeWindow(WindowPtr pWin)
-{
- Bool result = FALSE;
- RegionRec saveRoot;
- ScreenPtr pScreen = pWin->drawable.pScreen;
- XID pixel;
-
- RL_DEBUG_MSG("realizewindow start (win 0x%x)\n", pWin);
-
- if (IsTopLevel (pWin) && pWin->drawable.class == InputOutput)
- {
- RootlessWindowRec *winRec;
-
- winRec = rootlessEnsureFrame (pWin);
- if (winRec == NULL)
- return NULL;
-
- winRec->is_reorder_pending = TRUE;
-
- /* Disallow ParentRelative background state on top-level windows.
- This might have been set before the window was mapped. */
-
- if (pWin->backgroundState == ParentRelative)
- {
- pixel = 0;
- ChangeWindowAttributes (pWin, CWBackPixel, &pixel, serverClient);
- }
- }
-
- if (!IsRoot(pWin)) HUGE_ROOT(pWin);
- SCREEN_UNWRAP (pScreen, RealizeWindow);
-
- result = pScreen->RealizeWindow (pWin);
-
- SCREEN_WRAP (pScreen, RealizeWindow);
- if (!IsRoot(pWin)) NORMAL_ROOT(pWin);
-
- RL_DEBUG_MSG("realizewindow end\n");
- return result;
-}
-
-void
-RootlessEnableRoot (ScreenPtr pScreen)
-{
- WindowPtr pRoot;
- pRoot = WindowTable[pScreen->myNum];
-
- rootlessEnsureFrame (pRoot);
- (*pScreen->ClearToBackground) (pRoot, 0, 0, 0, 0, TRUE);
- RootlessReorderWindow (pRoot);
-}
-
-void
-RootlessDisableRoot (ScreenPtr pScreen)
-{
- WindowPtr pRoot;
- RootlessWindowRec *winRec;
-
- pRoot = WindowTable[pScreen->myNum];
- winRec = WINREC (pRoot);
-
- if (winRec != NULL)
- {
- rootlessDestroyFrame (pRoot, winRec);
- DeleteProperty (pRoot, xa_native_window_id ());
- }
-}
-
-void
-RootlessHideAllWindows (void)
-{
- int i;
- ScreenPtr pScreen;
- WindowPtr pWin;
- RootlessWindowRec *winRec;
- xp_window_changes wc;
-
- if (windows_hidden)
- return;
-
- windows_hidden = TRUE;
-
- for (i = 0; i < screenInfo.numScreens; i++)
- {
- pScreen = screenInfo.screens[i];
- pWin = WindowTable[i];
- if (pScreen == NULL || pWin == NULL)
- continue;
-
- for (pWin = pWin->firstChild; pWin != NULL; pWin = pWin->nextSib)
- {
- if (!pWin->realized)
- continue;
-
- RootlessStopDrawing (pWin, FALSE);
-
- winRec = WINREC (pWin);
- if (winRec != NULL)
- {
- wc.stack_mode = XP_UNMAPPED;
- wc.sibling = 0;
- configure_window (winRec->wid, XP_STACKING, &wc);
- }
- }
- }
-}
-
-void
-RootlessShowAllWindows (void)
-{
- int i;
- ScreenPtr pScreen;
- WindowPtr pWin;
- RootlessWindowRec *winRec;
-
- if (!windows_hidden)
- return;
-
- windows_hidden = FALSE;
-
- for (i = 0; i < screenInfo.numScreens; i++)
- {
- pScreen = screenInfo.screens[i];
- pWin = WindowTable[i];
- if (pScreen == NULL || pWin == NULL)
- continue;
-
- for (pWin = pWin->firstChild; pWin != NULL; pWin = pWin->nextSib)
- {
- if (!pWin->realized)
- continue;
-
- winRec = rootlessEnsureFrame (pWin);
- if (winRec == NULL)
- continue;
-
- RootlessReorderWindow (pWin);
- }
-
- RootlessScreenExpose (pScreen);
- }
-}
-
-void
-RootlessSetWindowLevel (WindowPtr pWin, int level)
-{
- RootlessWindowRec *winRec;
- xp_window_changes wc;
-
- winRec = WINREC (pWin);
- if (!IsTopLevel (pWin) || winRec == NULL || winRec->level == level)
- return;
-
- RootlessStopDrawing (pWin, FALSE);
-
- winRec->level = level;
-
- if (!rootlessHasRoot (pWin->drawable.pScreen))
- wc.window_level = normal_window_levels[level];
- else
- wc.window_level = rooted_window_levels[level];
-
- configure_window (winRec->wid, XP_WINDOW_LEVEL, &wc);
-}
-
-/* Return the id of the physical window displaying the given window. If
- CREATE is true and the window has no frame, attempt to create one. */
-xp_window_id
-RootlessGetPhysicalWindow (WindowPtr pWin, Bool create)
-{
- RootlessWindowRec *winRec;
-
- if (TopLevelParent (pWin) == NULL)
- return 0;
-
- winRec = WINREC (pWin);
-
- if (winRec == NULL && create && !IsRoot (pWin)
- && pWin->drawable.class == InputOutput)
- {
- rootlessEnsureFrame (pWin);
- winRec = WINREC (pWin);
- }
-
- if (winRec == NULL)
- return 0;
-
- return winRec->wid;
-}
-
-/* Given the id of a physical window, try to find the top-level (or root)
- X window that it represents. */
-WindowPtr
-RootlessGetXWindow (xp_window_id wid)
-{
- RootlessWindowRec *winRec;
-
- if (window_hash == NULL)
- return NULL;
-
- winRec = x_hash_table_lookup (window_hash, (void *) wid, NULL);
-
- return winRec != NULL ? winRec->win : NULL;
-}
-
-/* Number is an appkit window number. Returns true if X is displaying
- a window with that number. */
-int
-RootlessKnowsWindowNumber (int number)
-{
- Bool ret;
- xp_window_id wid;
-
- /* need to lock, since this function can be called by any thread */
-
- if (window_hash == NULL)
- return FALSE;
-
- pthread_mutex_lock (&window_hash_mutex);
-
- if (xp_lookup_native_window (number, &wid))
- ret = RootlessGetXWindow (wid) != NULL;
- else
- ret = FALSE;
-
- pthread_mutex_unlock (&window_hash_mutex);
-
- return ret;
-}
-
-Bool
-RootlessUnrealizeWindow (WindowPtr pWin)
-{
- ScreenPtr pScreen = pWin->drawable.pScreen;
- RootlessWindowRec *winRec = WINREC(pWin);
- xp_window_changes wc;
- Bool result;
-
- RL_DEBUG_MSG("unrealizewindow start\n");
-
- if (winRec != NULL)
- {
- RootlessStopDrawing (pWin, FALSE);
-
- wc.stack_mode = XP_UNMAPPED;
- wc.sibling = 0;
-
- configure_window (winRec->wid, XP_STACKING, &wc);
-
- winRec->unrealize_time = current_time_in_seconds ();
- winRec->is_reorder_pending = FALSE;
-
- RootlessReenableUpdate (pWin);
- }
-
- SCREEN_UNWRAP (pScreen, UnrealizeWindow);
-
- result = pScreen->UnrealizeWindow (pWin);
-
- SCREEN_WRAP (pScreen, UnrealizeWindow);
-
- RL_DEBUG_MSG ("unrealizewindow end\n");
- return result;
-}
-
-void
-RootlessReparentWindow (WindowPtr pWin, WindowPtr pPriorParent)
-{
- ScreenPtr pScreen = pWin->drawable.pScreen;
- RootlessWindowRec *winRec = WINREC (pWin);
-
- WindowPtr pTopWin;
-
- if (IsRoot (pWin) || IsRoot (pWin->parent)
- || IsTopLevel (pWin) || winRec == NULL)
- {
- return;
- }
-
- /* If the window is moving upwards towards the root has a frame,
- we want to try to move it onto its new toplevel parent. If we
- can't do that, we'll just have to jettison it.. */
-
- pTopWin = TopLevelParent (pWin);
- assert (pTopWin != pWin);
-
- pWin->rootlessUnhittable = FALSE;
-
- DeleteProperty (pWin, xa_native_window_id ());
-
- if (WINREC (pTopWin) != NULL)
- {
- /* We're screwed. */
- rootlessDestroyFrame (pWin, winRec);
- }
- else
- {
- xp_window_changes wc;
- int sx, sy;
-
- if (!pTopWin->realized && pWin->realized)
- {
- wc.stack_mode = XP_UNMAPPED;
- wc.sibling = 0;
-
- RootlessStopDrawing (pWin, FALSE);
- configure_window (winRec->wid, XP_STACKING, &wc);
- }
-
- /* Switch the frame record from one to the other. */
-
- WINREC (pWin) = NULL;
- WINREC (pTopWin) = winRec;
-
- rootlessInitializeFrame (pTopWin, winRec);
- rootlessSetShape (pTopWin);
-
- sx = dixScreenOrigins[pScreen->myNum].x + darwinMainScreenX;
- sy = dixScreenOrigins[pScreen->myNum].y + darwinMainScreenY;
-
- wc.x = sx + winRec->x;
- wc.y = sy + winRec->y;
- wc.width = winRec->width;
- wc.height = winRec->height;
- wc.bit_gravity = XP_GRAVITY_NONE;
-
- RootlessStopDrawing (pWin, FALSE);
- configure_window (winRec->wid, XP_BOUNDS, &wc);
-
- rootlessSetNativeProperty (winRec);
-
- if (pTopWin->realized && !pWin->realized)
- winRec->is_reorder_pending = TRUE;
- }
-}
-
-/* Reorder the window associated with the given frame so that it's
- physically above the window below it in the X stacking order. */
-void
-RootlessReorderWindow (WindowPtr pWin)
-{
- RootlessWindowRec *winRec = WINREC (pWin);
-
- if (pWin->realized && winRec != NULL
- && !winRec->is_reorder_pending && !windows_hidden)
- {
- WindowPtr newPrevW;
- RootlessWindowRec *newPrev;
- xp_window_changes wc;
- Atom atom;
- PropertyPtr prop;
-
- /* quartz-wm sets the _APPLE_NO_ORDER_IN property on windows
- that are being genie-restored from the Dock. We want them to
- be mapped but remain ordered-out until the animation
- completes (when the Dock will order them in) */
-
- atom = xa_apple_no_order_in ();
- for (prop = wUserProps (pWin); prop != NULL; prop = prop->next)
- {
- if (prop->propertyName == atom && prop->type == atom)
- return;
- }
-
- RootlessStopDrawing (pWin, FALSE);
-
- if (IsRoot (pWin))
- {
- wc.stack_mode = XP_MAPPED_BELOW;
- wc.sibling = 0;
- }
- else
- {
- /* Find the next window above this one that has a mapped frame. */
-
- newPrevW = pWin->prevSib;
- while (newPrevW
- && (WINREC (newPrevW) == NULL || !newPrevW->realized))
- {
- newPrevW = newPrevW->prevSib;
- }
-
- newPrev = newPrevW != NULL ? WINREC (newPrevW) : NULL;
-
- /* Then either stack ourselves below it if it exists, or raise
- ourselves above everything otherwise. */
-
- if (newPrev == NULL)
- {
- wc.stack_mode = XP_MAPPED_ABOVE;
- wc.sibling = 0;
- }
- else
- {
- if (newPrev->is_reorder_pending)
- {
- newPrev->is_reorder_pending = FALSE;
- RootlessReorderWindow (newPrevW);
- }
-
- wc.stack_mode = XP_MAPPED_BELOW;
- wc.sibling = newPrev->wid;
- }
- }
-
- configure_window (winRec->wid, XP_STACKING, &wc);
- }
-}
-
-void
-RootlessRestackWindow (WindowPtr pWin, WindowPtr pOldNextSib)
-{
- RegionRec saveRoot;
- RootlessWindowRec *winRec = WINREC (pWin);
- ScreenPtr pScreen = pWin->drawable.pScreen;
-
- RL_DEBUG_MSG("restackwindow start\n");
- if (winRec != NULL)
- RL_DEBUG_MSG("restack top level \n");
-
- HUGE_ROOT(pWin);
- SCREEN_UNWRAP(pScreen, RestackWindow);
-
- if (pScreen->RestackWindow != NULL)
- pScreen->RestackWindow (pWin, pOldNextSib);
-
- SCREEN_WRAP(pScreen, RestackWindow);
- NORMAL_ROOT(pWin);
-
- if (winRec != NULL && pWin->viewable)
- RootlessReorderWindow (pWin);
-
- RL_DEBUG_MSG("restackwindow end\n");
-}
-
-/*
- * Specialized window copy procedures
- */
-
-/* Globals needed during window resize and move. */
-static pointer gResizeDeathBits = NULL;
-static int gResizeDeathCount;
-static PixmapPtr gResizeDeathPix[2];
-static BoxRec gResizeDeathBounds[2];
-static CopyWindowProcPtr gResizeOldCopyWindowProc = NULL;
-
-/* CopyWindow () that doesn't do anything. For MoveWindow() of
- top-level windows. */
-static void
-RootlessNoCopyWindow (WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
-{
- /* Some code expects the region to be translated */
-
- int dx = ptOldOrg.x - pWin->drawable.x;
- int dy = ptOldOrg.y - pWin->drawable.y;
-
- REGION_TRANSLATE (pWin->drawable.pScreen, prgnSrc, -dx, -dy);
-}
-
-/* CopyWindow used during ResizeWindow for gravity moves. (from fbCopyWindow)
- The original always draws on the root pixmap (which we don't have).
- Instead, draw on the parent window's pixmap.
- Resize version: the old location's pixels are in gResizeCopyWindowSource */
-static void
-RootlessResizeCopyWindow (WindowPtr pWin, DDXPointRec ptOldOrg,
- RegionPtr prgnSrc)
-{
- ScreenPtr pScreen = pWin->drawable.pScreen;
- RegionRec rgnDst;
- int dx, dy;
-
- RL_DEBUG_MSG("resizecopywindowFB start (win 0x%x)\n", pWin);
-
- /* Don't unwrap pScreen->CopyWindow.
- The bogus rewrap with RootlessCopyWindow causes a crash if
- CopyWindow is called again during the same resize. */
-
- if (gResizeDeathCount == 0)
- return;
-
- RootlessStartDrawing (pWin);
-
- dx = ptOldOrg.x - pWin->drawable.x;
- dy = ptOldOrg.y - pWin->drawable.y;
- REGION_TRANSLATE (pScreen, prgnSrc, -dx, -dy);
- REGION_INIT (pScreen, &rgnDst, NullBox, 0);
- REGION_INTERSECT (pScreen, &rgnDst, &pWin->borderClip, prgnSrc);
-
- if (gResizeDeathCount == 1)
- {
- /* Simple case, we only have a single source pixmap. */
-
- fbCopyRegion (&gResizeDeathPix[0]->drawable,
- &pScreen->GetWindowPixmap(pWin)->drawable, 0,
- &rgnDst, dx, dy, fbCopyWindowProc, 0, 0);
- }
- else
- {
- int i;
- RegionRec clip, clipped;
-
- /* More complex case, N source pixmaps (usually two). So we
- intersect the destination with each source and copy those bits. */
-
- for (i = 0; i < gResizeDeathCount; i++)
- {
- REGION_INIT (pScreen, &clip, gResizeDeathBounds + 0, 1);
- REGION_INIT (pScreen, &clipped, NullBox, 0);
- REGION_INTERSECT (pScreen, &rgnDst, &clip, &clipped);
-
- fbCopyRegion (&gResizeDeathPix[i]->drawable,
- &pScreen->GetWindowPixmap(pWin)->drawable, 0,
- &clipped, dx, dy, fbCopyWindowProc, 0, 0);
-
- REGION_UNINIT (pScreen, &clipped);
- REGION_UNINIT (pScreen, &clip);
- }
- }
-
- /* Don't update - resize will update everything */
- REGION_UNINIT (pScreen, &rgnDst);
-
- fbValidateDrawable (&pWin->drawable);
-
- RL_DEBUG_MSG("resizecopywindowFB end\n");
-}
-
-/* Update *new* location of window. Old location is redrawn with
- PaintWindowBackground/Border. Cloned from fbCopyWindow
- The original always draws on the root pixmap (which we don't have).
- Instead, draw on the parent window's pixmap. */
-void
-RootlessCopyWindow (WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
-{
- ScreenPtr pScreen = pWin->drawable.pScreen;
- RootlessWindowRec *winRec;
- WindowPtr top;
-
- RegionRec rgnDst;
- int dx, dy;
- BoxPtr extents;
- unsigned int area;
-
- RL_DEBUG_MSG("copywindowFB start (win 0x%x)\n", pWin);
-
- top = TopLevelParent (pWin);
- if (top == NULL)
- {
- RL_DEBUG_MSG("no parent\n");
- return;
- }
-
- winRec = WINREC(top);
- if (winRec == NULL)
- {
- RL_DEBUG_MSG("not framed\n");
- return;
- }
-
- SCREEN_UNWRAP (pScreen, CopyWindow);
-
- dx = ptOldOrg.x - pWin->drawable.x;
- dy = ptOldOrg.y - pWin->drawable.y;
- REGION_TRANSLATE (pScreen, prgnSrc, -dx, -dy);
-
- REGION_INIT (pScreen, &rgnDst, NullBox, 0);
- REGION_INTERSECT (pScreen, &rgnDst, &pWin->borderClip, prgnSrc);
-
- extents = REGION_EXTENTS (pScreen, &rgnDst);
- area = (extents->x2 - extents->x1) * (extents->y2 - extents->y1);
-
- if (area > xp_scroll_area_threshold)
- {
- /* Move region to window local coords */
- REGION_TRANSLATE (pScreen, &rgnDst, -winRec->x, -winRec->y);
-
- RootlessStopDrawing (pWin, FALSE);
-
- xp_copy_window (winRec->wid, winRec->wid,
- REGION_NUM_RECTS (&rgnDst),
- REGION_RECTS (&rgnDst), dx, dy);
- }
- else
- {
- RootlessStartDrawing (pWin);
-
- fbCopyRegion ((DrawablePtr) pWin, (DrawablePtr) pWin,
- 0, &rgnDst, dx, dy, fbCopyWindowProc, 0, 0);
-
- /* prgnSrc has been translated to dst position */
- RootlessDamageRegion(pWin, prgnSrc);
- }
-
- REGION_UNINIT (pScreen, &rgnDst);
- fbValidateDrawable (&pWin->drawable);
-
- SCREEN_WRAP (pScreen, CopyWindow);
-
- RL_DEBUG_MSG("copywindowFB end\n");
-}
-
-/*
- * Window resize procedures
- */
-
-enum {
- WIDTH_SMALLER = 1,
- HEIGHT_SMALLER = 2,
-};
-
-/* Compute which directions the window is resizing in. */
-static inline unsigned int
-resize_code (int oldX, int oldY, int oldW, int oldH,
- int newX, int newY, int newW, int newH)
-{
- unsigned int code = 0;
-
- /* These comparisons were chosen to avoid setting bits when the sizes
- are the same. (So the fastest case automatically gets taken when
- dimensions are unchanging.) */
-
- if (newW < oldW)
- code |= WIDTH_SMALLER;
-
- if (newH < oldH)
- code |= HEIGHT_SMALLER;
-
- return code;
-}
-
-static inline unsigned int
-resize_weighting (int oldX1, int oldY1, int oldX2, int oldY2, int oldBW,
- int newX1, int newY1, int newX2, int newY2, int newBW)
-{
- /* Choose gravity to avoid local copies. Do that by looking for
- a corner that doesn't move _relative to the screen_ */
-
- if (newBW != oldBW)
- return XP_GRAVITY_NONE;
-
- if (newX1 == oldX1 && newY1 == oldY1)
- return XP_GRAVITY_NORTH_WEST;
- else if (newX1 == oldX1 && newY2 == oldY2)
- return XP_GRAVITY_SOUTH_WEST;
- else if (newX2 == oldX2 && newY2 == oldY2)
- return XP_GRAVITY_SOUTH_EAST;
- else if (newX2 == oldX2 && newY1 == oldY1)
- return XP_GRAVITY_NORTH_EAST;
- else
- return XP_GRAVITY_NONE;
-}
-
-/* Resize the given window to its new position and size. */
-static void
-resize_frame (ScreenPtr pScreen, WindowPtr pWin,
- RootlessWindowRec *winRec, int gravity)
-{
- int sx, sy;
- xp_window_changes wc;
-
- sx = dixScreenOrigins[pScreen->myNum].x + darwinMainScreenX;
- sy = dixScreenOrigins[pScreen->myNum].y + darwinMainScreenY;
-
- wc.x = sx + winRec->x;
- wc.y = sy + winRec->y;
- wc.width = winRec->width;
- wc.height = winRec->height;
- wc.bit_gravity = gravity;
-
- /* It's unlikely that being async will save us anything here.
- But it can't hurt. */
-
- configure_window (winRec->wid, XP_BOUNDS, &wc);
-}
-
-/* Prepare to resize a top-level window. The old window's pixels are
- saved and the implementation is told to change the window size.
- (x,y,w,h) is outer frame of window (outside border) */
-static Bool
-StartFrameResize (WindowPtr pWin, Bool gravity,
- int oldX, int oldY, int oldW, int oldH, int oldBW,
- int newX, int newY, int newW, int newH, int newBW)
-{
- ScreenPtr pScreen = pWin->drawable.pScreen;
- RootlessWindowRec *winRec = WINREC(pWin);
- Bool need_window_source = FALSE, resize_after = FALSE;
-
- BoxRec rect, copy_rect;
- int oldX2, newX2;
- int oldY2, newY2;
- unsigned int weight;
-
- oldX2 = oldX + oldW, newX2 = newX + newW;
- oldY2 = oldY + oldH, newY2 = newY + newH;
-
- /* Decide which resize weighting to use */
- weight = resize_weighting (oldX, oldY, oldW, oldH, oldBW,
- newX, newY, newW, newH, newBW);
-
- /* Compute intersection between old and new rects */
- rect.x1 = max(oldX, newX);
- rect.y1 = max(oldY, newY);
- rect.x2 = min(oldX2, newX2);
- rect.y2 = min(oldY2, newY2);
-
- RL_DEBUG_MSG("RESIZE TOPLEVEL WINDOW with gravity %i ", gravity);
- RL_DEBUG_MSG("%d %d %d %d %d %d %d %d %d %d\n",
- oldX, oldY, oldW, oldH, oldBW,
- newX, newY, newW, newH, newBW);
-
- RootlessDisableUpdate (pWin);
- RootlessRedisplay (pWin);
-
- /* If gravity is true, then we need to have a way of recovering all
- the original bits in the window for when X rearranges the contents
- based on the various gravity settings. The obvious way is to just
- snapshot the entire backing store before resizing it, but that
- it slow on large windows.
-
- So the optimization here is to use CG's resize weighting options
- to allow us to reason about what is left in the backing store
- after the resize. We can then only copy what won't be there after
- the resize, and do a two-stage copy operation.
-
- Most of these optimizations are only applied when the top-left
- corner of the window is fixed, since that's the common case. They
- could probably be extended with some thought. */
-
- gResizeDeathCount = 0;
-
- if (gravity && weight == XP_GRAVITY_NORTH_WEST)
- {
- unsigned int code;
-
- /* Top left corner is anchored. We never need to copy the
- entire window. */
-
- need_window_source = TRUE;
-
- code = resize_code (oldX, oldY, oldW, oldH,
- newX, newY, newW, newH);
-
- if (((code ^ (code >> 1)) & 1) == 0)
- {
- /* Both dimensions are either getting larger, or both
- are getting smaller. No need to copy anything. */
-
- if (code == (WIDTH_SMALLER | HEIGHT_SMALLER))
- {
- /* Since the window is getting smaller, we can do gravity
- repair on it with it's current size, then resize it
- afterwards. */
-
- resize_after = TRUE;
- }
-
- gResizeDeathCount = 1;
- }
- else
- {
- unsigned int copy_rowbytes, Bpp;
-
- /* We can get away with a partial copy. 'rect' is the
- intersection between old and new bounds, so copy
- everything to the right of or below the intersection. */
-
- RootlessStartDrawing (pWin);
-
- if (code == WIDTH_SMALLER)
- {
- copy_rect.x1 = rect.x2;
- copy_rect.y1 = rect.y1;
- copy_rect.x2 = oldX2;
- copy_rect.y2 = oldY2;
- }
- else if (code == HEIGHT_SMALLER)
- {
- copy_rect.x1 = rect.x1;
- copy_rect.y1 = rect.y2;
- copy_rect.x2 = oldX2;
- copy_rect.y2 = oldY2;
- }
- else
- abort ();
-
- Bpp = winRec->win->drawable.bitsPerPixel / 8;
- copy_rowbytes = (((copy_rect.x2 - copy_rect.x1) * Bpp) + 31) & ~31;
- gResizeDeathBits = xalloc (copy_rowbytes
- * (copy_rect.y2 - copy_rect.y1));
-
- xp_copy_bytes ((copy_rect.x2 - copy_rect.x1) * Bpp,
- copy_rect.y2 - copy_rect.y1, ((char *) winRec->data)
- + ((copy_rect.y1 - oldY) * winRec->rowbytes)
- + (copy_rect.x1 - oldX) * Bpp, winRec->rowbytes,
- gResizeDeathBits, copy_rowbytes);
-
- gResizeDeathBounds[1] = copy_rect;
- gResizeDeathPix[1]
- = GetScratchPixmapHeader(pScreen, copy_rect.x2 - copy_rect.x1,
- copy_rect.y2 - copy_rect.y1,
- winRec->win->drawable.depth,
- winRec->win->drawable.bitsPerPixel,
- winRec->rowbytes,
- (void *) gResizeDeathBits);
-
- TranslatePixmapBase (gResizeDeathPix[1],
- -copy_rect.x1, -copy_rect.y1);
-
- gResizeDeathCount = 2;
- }
- }
- else if (gravity)
- {
- /* The general case. Just copy everything. */
-
- RootlessStartDrawing (pWin);
-
- gResizeDeathBits = xalloc(winRec->rowbytes * winRec->height);
-
- memcpy(gResizeDeathBits, winRec->data,
- winRec->rowbytes * winRec->height);
-
- gResizeDeathBounds[0] = (BoxRec) {oldX, oldY, oldX2, oldY2};
- gResizeDeathPix[0]
- = GetScratchPixmapHeader(pScreen, winRec->width,
- winRec->height,
- winRec->win->drawable.depth,
- winRec->win->drawable.bitsPerPixel,
- winRec->rowbytes,
- (void *) gResizeDeathBits);
-
- TranslatePixmapBase (gResizeDeathPix[0], -oldX, -oldY);
- gResizeDeathCount = 1;
- }
-
- RootlessStopDrawing (pWin, FALSE);
-
- winRec->x = newX;
- winRec->y = newY;
- winRec->width = newW;
- winRec->height = newH;
- winRec->borderWidth = newBW;
-
- /* Unless both dimensions are getting smaller, Resize the frame
- before doing gravity repair */
-
- if (!resize_after)
- resize_frame (pScreen, pWin, winRec, weight);
-
- RootlessStartDrawing(pWin);
-
- /* If necessary, create a source pixmap pointing at the current
- window bits. */
-
- if (need_window_source)
- {
- gResizeDeathBounds[0] = (BoxRec) {oldX, oldY, oldX2, oldY2};
- gResizeDeathPix[0]
- = GetScratchPixmapHeader (pScreen, oldW, oldH,
- winRec->win->drawable.depth,
- winRec->win->drawable.bitsPerPixel,
- winRec->rowbytes, winRec->data);
-
- TranslatePixmapBase (gResizeDeathPix[0], -oldX, -oldY);
- }
-
- /* Use custom CopyWindow when moving gravity bits around
- ResizeWindow assumes the old window contents are in the same
- pixmap, but here they're in deathPix instead. */
-
- if (gravity)
- {
- gResizeOldCopyWindowProc = pScreen->CopyWindow;
- pScreen->CopyWindow = RootlessResizeCopyWindow;
- }
-
- /* If we can't rely on the window server preserving the bits we
- need in the position we need, copy the pixels in the
- intersection from src to dst. ResizeWindow assumes these pixels
- are already present when making gravity adjustments. pWin
- currently has new-sized pixmap but is in old position.
-
- FIXME: border width change! (?) */
-
- if (gravity && weight == XP_GRAVITY_NONE)
- {
- PixmapPtr src, dst;
-
- assert (gResizeDeathCount == 1);
-
- src = gResizeDeathPix[0];
- dst = pScreen->GetWindowPixmap(pWin);
-
- RL_DEBUG_MSG("Resize copy rect %d %d %d %d\n",
- rect.x1, rect.y1, rect.x2, rect.y2);
-
- /* rect is the intersection of the old location and new location */
- if (BOX_NOT_EMPTY(rect) && src != NULL && dst != NULL)
- {
- int dx, dy;
-
- /* The window drawable still has the old frame position, which
- means that DST doesn't actually point at the origin of our
- physical backing store when adjusted by the drawable.x,y
- position. So sneakily adjust it temporarily while copying.. */
-
- dx = newX - oldX;
- dy = newY - oldY;
- TranslatePixmapBase (dst, -dx, -dy);
-
- fbCopyWindowProc(&src->drawable, &dst->drawable, NULL,
- &rect, 1, 0, 0, FALSE, FALSE, 0, 0);
-
- TranslatePixmapBase (dst, dx, dy);
- }
- }
-
- return resize_after;
-}
-
-static void
-FinishFrameResize (WindowPtr pWin, Bool gravity, int oldX, int oldY,
- unsigned int oldW, unsigned int oldH, unsigned int oldBW,
- int newX, int newY, unsigned int newW, unsigned int newH,
- unsigned int newBW, Bool resize_now)
-{
- ScreenPtr pScreen = pWin->drawable.pScreen;
- RootlessWindowRec *winRec = WINREC(pWin);
- BoxRec box;
- int i;
-
- RootlessStopDrawing (pWin, FALSE);
-
- if (resize_now)
- {
- unsigned int weight;
-
- /* We didn't resize anything earlier, so do it now, now that
- we've finished gravitating the bits. */
-
- weight = resize_weighting (oldX, oldY, oldW, oldH, oldBW,
- newX, newY, newW, newH, newBW);
-
- resize_frame (pScreen, pWin, winRec, weight);
- }
-
- /* Redraw everything. FIXME: there must be times when we don't need
- to do this. Perhaps when top-left weighting and no gravity? */
-
- box.x1 = 0;
- box.y1 = 0;
- box.x2 = winRec->width;
- box.y2 = winRec->height;
-
- xp_mark_window (winRec->wid, 1, &box, 0, 0);
-
- for (i = 0; i < 2; i++)
- {
- if (gResizeDeathPix[i] != NULL)
- {
- FreeScratchPixmapHeader (gResizeDeathPix[i]);
- gResizeDeathPix[i] = NULL;
- }
- }
-
- if (gResizeDeathBits != NULL)
- {
- xfree (gResizeDeathBits);
- gResizeDeathBits = NULL;
- }
-
- if (gravity)
- pScreen->CopyWindow = gResizeOldCopyWindowProc;
-}
-
-/* If kind==VTOther, window border is resizing (and borderWidth is
- already changed!!@#$) This case works like window resize, not move. */
-void
-RootlessMoveWindow (WindowPtr pWin, int x, int y, WindowPtr pSib, VTKind kind)
-{
- RootlessWindowRec *winRec = WINREC(pWin);
- ScreenPtr pScreen = pWin->drawable.pScreen;
- CopyWindowProcPtr oldCopyWindowProc = NULL;
-
- int oldX = 0, oldY = 0;
- unsigned int oldW = 0, oldH = 0, oldBW = 0;
- int newX = 0, newY = 0;
- unsigned int newW = 0, newH = 0, newBW = 0;
-
- Bool resize_after = FALSE;
- RegionRec saveRoot;
-
- RL_DEBUG_MSG("movewindow start \n");
-
- if (winRec != NULL)
- {
- if (kind == VTMove)
- {
- oldX = winRec->x;
- oldY = winRec->y;
- RootlessRedisplay (pWin);
- RootlessStartDrawing (pWin);
- }
- else
- {
- RL_DEBUG_MSG("movewindow border resizing ");
-
- oldBW = winRec->borderWidth;
- oldX = winRec->x;
- oldY = winRec->y;
- oldW = winRec->width;
- oldH = winRec->height;
-
- newBW = wBorderWidth (pWin);
- newX = x;
- newY = y;
- newW = pWin->drawable.width + 2*newBW;
- newH = pWin->drawable.height + 2*newBW;
-
- resize_after = StartFrameResize (pWin, FALSE,
- oldX, oldY, oldW, oldH, oldBW,
- newX, newY, newW, newH, newBW);
- }
- }
-
- HUGE_ROOT (pWin);
- SCREEN_UNWRAP (pScreen, MoveWindow);
-
- oldCopyWindowProc = pScreen->CopyWindow;
-
- if (winRec != NULL)
- pScreen->CopyWindow = RootlessNoCopyWindow;
-
- pScreen->MoveWindow (pWin, x, y, pSib, kind);
-
- if (winRec != NULL)
- pScreen->CopyWindow = oldCopyWindowProc;
-
- NORMAL_ROOT (pWin);
- SCREEN_WRAP (pScreen, MoveWindow);
-
- if (winRec != NULL)
- {
- if (kind == VTMove)
- {
- xp_window_changes wc;
- int sx, sy;
-
- RootlessStopDrawing (pWin, FALSE);
-
- winRec->x = x;
- winRec->y = y;
-
- sx = dixScreenOrigins[pScreen->myNum].x + darwinMainScreenX;
- sy = dixScreenOrigins[pScreen->myNum].y + darwinMainScreenY;
-
- wc.x = sx + winRec->x;
- wc.y = sy + winRec->y;
-
- configure_window (winRec->wid, XP_ORIGIN, &wc);
- }
- else
- {
- FinishFrameResize (pWin, FALSE, oldX, oldY, oldW, oldH, oldBW,
- newX, newY, newW, newH, newBW, resize_after);
- }
- }
-
- RL_DEBUG_MSG("movewindow end\n");
-}
-
-
-/* Note: (x, y, w, h) as passed to this procedure don't match the frame
- definition. (x,y) is corner of very outer edge, *outside* border
- w,h is width and height *inside* border, *ignoring* border width
- The rect (x, y, w, h) doesn't mean anything. (x, y, w+2*bw, h+2*bw)
- is total rect (x+bw, y+bw, w, h) is inner rect */
-void
-RootlessResizeWindow (WindowPtr pWin, int x, int y,
- unsigned int w, unsigned int h, WindowPtr pSib)
-{
- RootlessWindowRec *winRec = WINREC(pWin);
- ScreenPtr pScreen = pWin->drawable.pScreen;
- RegionRec saveRoot;
-
- int oldX = 0, oldY = 0;
- unsigned int oldW = 0, oldH = 0, oldBW = 0;
- int newX = 0, newY = 0;
- unsigned int newW = 0, newH = 0, newBW = 0;
-
- Bool resize_after = FALSE;
-
- RL_DEBUG_MSG("resizewindow start (win 0x%x)\n", pWin);
-
- if (winRec != NULL)
- {
- oldBW = winRec->borderWidth;
- oldX = winRec->x;
- oldY = winRec->y;
- oldW = winRec->width;
- oldH = winRec->height;
-
- newBW = oldBW;
- newX = x;
- newY = y;
- newW = w + 2*newBW;
- newH = h + 2*newBW;
-
- resize_after = StartFrameResize (pWin, TRUE,
- oldX, oldY, oldW, oldH, oldBW,
- newX, newY, newW, newH, newBW);
- }
-
- HUGE_ROOT (pWin);
- SCREEN_UNWRAP (pScreen, ResizeWindow);
-
- if (!IsRoot (pWin))
- {
- pScreen->ResizeWindow (pWin, x, y, w, h, pSib);
- }
- else
- {
- BoxRec box;
-
- /* mi won't resize the root. So do it ourselves... */
-
- pWin->drawable.x = x;
- pWin->drawable.y = y;
- pWin->drawable.width = w;
- pWin->drawable.height = h;
-
- box.x1 = x; box.y1 = y;
- box.x2 = x + w; box.y2 = y + h;
- REGION_UNINIT (pScreen, &pWin->winSize);
- REGION_INIT (pScreen, &pWin->winSize, &box, 1);
- REGION_COPY (pScreen, &pWin->borderSize, &pWin->winSize);
- REGION_COPY (pScreen, &pWin->clipList, &pWin->winSize);
- REGION_COPY (pScreen, &pWin->borderClip, &pWin->winSize);
-
- miSendExposures (pWin, &pWin->borderClip,
- pWin->drawable.x, pWin->drawable.y);
- }
-
- SCREEN_WRAP (pScreen, ResizeWindow);
- NORMAL_ROOT (pWin);
-
- if (winRec != NULL)
- {
- FinishFrameResize (pWin, TRUE, oldX, oldY, oldW, oldH, oldBW,
- newX, newY, newW, newH, newBW, resize_after);
- }
-
- RL_DEBUG_MSG("resizewindow end\n");
-}
-
-void
-RootlessRepositionWindow (WindowPtr pWin)
-{
- RootlessWindowRec *winRec = WINREC (pWin);
- ScreenPtr pScreen = pWin->drawable.pScreen;
- xp_window_changes wc;
- int sx, sy;
-
- if (IsRoot (pWin))
- set_screen_origin (pWin);
-
- if (winRec == NULL)
- return;
-
- RootlessStopDrawing (pWin, FALSE);
-
- sx = dixScreenOrigins[pScreen->myNum].x + darwinMainScreenX;
- sy = dixScreenOrigins[pScreen->myNum].y + darwinMainScreenY;
-
- wc.x = sx + winRec->x;
- wc.y = sy + winRec->y;
-
- if (!rootlessHasRoot (pScreen))
- wc.window_level = normal_window_levels[winRec->level];
- else
- wc.window_level = rooted_window_levels[winRec->level];
-
- configure_window (winRec->wid, XP_ORIGIN | XP_WINDOW_LEVEL, &wc);
-
- RootlessReorderWindow (pWin);
-}
-
-void
-RootlessFlushWindowColormap (WindowPtr pWin)
-{
- RootlessWindowRec *winRec = WINREC (pWin);
- xp_window_changes wc;
-
- if (winRec == NULL)
- return;
-
- RootlessStopDrawing (pWin, FALSE);
-
- /* This is how we tell xp that the colormap may have changed. */
-
- wc.colormap = rootlessColormapCallback;
- wc.colormap_data = pWin->drawable.pScreen;
-
- configure_window (winRec->wid, XP_COLORMAP, &wc);
-}
-
-/* Set the Pixmaps on all ParentRelative windows up the ancestor chain. */
-static void
-SetPixmapOfAncestors (WindowPtr pWin)
-{
- ScreenPtr pScreen = pWin->drawable.pScreen;
- WindowPtr topWin = TopLevelParent (pWin);
- RootlessWindowRec *topWinRec = WINREC (topWin);
- XID pixel;
-
- while (pWin->backgroundState == ParentRelative)
- {
- if (pWin == topWin)
- {
- /* disallow ParentRelative background state on top level */
-
- pixel = 0;
- ChangeWindowAttributes(pWin, CWBackPixel, &pixel, serverClient);
-
- RL_DEBUG_MSG("Cleared ParentRelative on 0x%x.\n", pWin);
- break;
- }
-
- pWin = pWin->parent;
- pScreen->SetWindowPixmap (pWin, topWinRec->pixmap);
- }
-}
-
-/* RootlessPaintWindowBackground
- Paint the window background while filling in the alpha channel
- with all on. */
-void
-RootlessPaintWindowBackground (WindowPtr pWin, RegionPtr pRegion, int what)
-{
- ScreenPtr pScreen = pWin->drawable.pScreen;
-
- SCREEN_UNWRAP (pScreen, PaintWindowBackground);
-
- RL_DEBUG_MSG("paintwindowbackground start (win 0x%x, framed %i)\n",
- pWin, IsFramedWindow(pWin));
-
- if (IsFramedWindow (pWin))
- {
- /* Don't bother trying to paint the surface background.. */
- rootlessNoDRIDrawing++;
-
- RootlessStartDrawing (pWin);
- RootlessDamageRegion (pWin, pRegion);
-
- /* For ParentRelative windows, we have to make sure the window
- pixmap is set correctly all the way up the ancestor chain. */
-
- if (pWin->backgroundState == ParentRelative)
- SetPixmapOfAncestors (pWin);
-
- pScreen->PaintWindowBackground (pWin, pRegion, what);
-
- rootlessNoDRIDrawing--;
- }
-
- SCREEN_WRAP (pScreen, PaintWindowBackground);
-
- RL_DEBUG_MSG("paintwindowbackground end\n");
-}
-
-
-/* RootlessPaintWindowBorder
- Paint the window border while filling in the alpha channel with all on. */
-void
-RootlessPaintWindowBorder (WindowPtr pWin, RegionPtr pRegion, int what)
-{
- SCREEN_UNWRAP (pWin->drawable.pScreen, PaintWindowBorder);
-
- RL_DEBUG_MSG("paintwindowborder start (win 0x%x)\n", pWin);
-
- if (IsFramedWindow (pWin))
- {
- RootlessStartDrawing (pWin);
- RootlessDamageRegion (pWin, pRegion);
-
- /* For ParentRelative windows with tiled borders, we have to make
- sure the window pixmap is set correctly all the way up the
- ancestor chain. */
-
- if (!pWin->borderIsPixel && pWin->backgroundState == ParentRelative)
- SetPixmapOfAncestors (pWin);
- }
-
- pWin->drawable.pScreen->PaintWindowBorder (pWin, pRegion, what);
-
- SCREEN_WRAP (pWin->drawable.pScreen, PaintWindowBorder);
-
- RL_DEBUG_MSG("paintwindowborder end\n");
-}
-
-
-/* FIXME: untested!
- pWin inside corner stays the same; pWin->drawable.[xy] stays the same
- frame moves and resizes */
-void
-RootlessChangeBorderWidth (WindowPtr pWin, unsigned int width)
-{
- RegionRec saveRoot;
- Bool resize_after = FALSE;
-
- RL_DEBUG_MSG("change border width\n");
-
- if ((int) width != wBorderWidth (pWin))
- {
- RootlessWindowRec *winRec = WINREC(pWin);
-
- int oldX = 0, oldY = 0, newX = 0, newY = 0;
- unsigned int oldW = 0, oldH = 0, oldBW = 0;
- unsigned int newW = 0, newH = 0, newBW = 0;
-
- if (winRec != NULL)
- {
- oldBW = winRec->borderWidth;
- oldX = winRec->x;
- oldY = winRec->y;
- oldW = winRec->width;
- oldH = winRec->height;
-
- newBW = width;
- newX = pWin->drawable.x - newBW;
- newY = pWin->drawable.y - newBW;
- newW = pWin->drawable.width + 2*newBW;
- newH = pWin->drawable.height + 2*newBW;
-
- resize_after = StartFrameResize (pWin, FALSE,
- oldX, oldY, oldW, oldH, oldBW,
- newX, newY, newW, newH, newBW);
- }
-
- HUGE_ROOT (pWin);
- SCREEN_UNWRAP (pWin->drawable.pScreen, ChangeBorderWidth);
-
- pWin->drawable.pScreen->ChangeBorderWidth (pWin, width);
-
- SCREEN_WRAP (pWin->drawable.pScreen, ChangeBorderWidth);
- NORMAL_ROOT (pWin);
-
- if (winRec != NULL)
- {
- FinishFrameResize (pWin, FALSE, oldX, oldY, oldW, oldH, oldBW,
- newX, newY, newW, newH, newBW, resize_after);
- }
- }
-
- RL_DEBUG_MSG("change border width end\n");
-}
-
-/*
- * RootlessFillRegionTiled
- * Fill using a tile while leaving the alpha channel untouched.
- * Based on fbfillRegionTiled.
- */
-static void
-RootlessFillRegionTiled(
- DrawablePtr pDrawable,
- RegionPtr pRegion,
- PixmapPtr pTile)
-{
- FbBits *dst;
- FbStride dstStride;
- int dstBpp;
- int dstXoff, dstYoff;
- FbBits *tile;
- FbStride tileStride;
- int tileBpp;
- int tileXoff, tileYoff; /* XXX assumed to be zero */
- int tileWidth, tileHeight;
- int n = REGION_NUM_RECTS(pRegion);
- BoxPtr pbox = REGION_RECTS(pRegion);
- int xRot = pDrawable->x;
- int yRot = pDrawable->y;
- FbBits planeMask;
-
-#ifdef PANORAMIX
- if(!noPanoramiXExtension)
- {
- int index = pDrawable->pScreen->myNum;
- if(&WindowTable[index]->drawable == pDrawable)
- {
- xRot -= panoramiXdataPtr[index].x;
- yRot -= panoramiXdataPtr[index].y;
- }
- }
-#endif
- fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff);
- fbGetDrawable (&pTile->drawable, tile, tileStride, tileBpp,
- tileXoff, tileYoff);
- tileWidth = pTile->drawable.width;
- tileHeight = pTile->drawable.height;
- xRot += dstXoff;
- yRot += dstYoff;
- planeMask = FB_ALLONES & ~RootlessAlphaMask(dstBpp);
-
- while (n--)
- {
- fbTile (dst + (pbox->y1 + dstYoff) * dstStride,
- dstStride,
- (pbox->x1 + dstXoff) * dstBpp,
- (pbox->x2 - pbox->x1) * dstBpp,
- pbox->y2 - pbox->y1,
- tile,
- tileStride,
- tileWidth * dstBpp,
- tileHeight,
- GXcopy,
- planeMask,
- dstBpp,
- xRot * dstBpp,
- yRot - pbox->y1);
- pbox++;
- }
-}
-
-/*
- * RootlessPaintWindow
- * Paint the window while filling in the alpha channel with all on.
- * We can't use fbPaintWindow because it zeros the alpha channel.
- */
-void
-RootlessPaintWindow(
- WindowPtr pWin,
- RegionPtr pRegion,
- int what)
-{
- switch (what) {
- case PW_BACKGROUND:
-
- switch (pWin->backgroundState) {
- case None:
- break;
- case ParentRelative:
- do {
- pWin = pWin->parent;
- } while (pWin->backgroundState == ParentRelative);
- (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion,
- what);
- break;
- case BackgroundPixmap:
- RootlessFillRegionTiled (&pWin->drawable,
- pRegion,
- pWin->background.pixmap);
- break;
- case BackgroundPixel:
- {
- Pixel pixel = pWin->background.pixel |
- RootlessAlphaMask(pWin->drawable.bitsPerPixel);
- fbFillRegionSolid (&pWin->drawable, pRegion, 0,
- fbReplicatePixel (pixel,
- pWin->drawable.bitsPerPixel));
- break;
- }
- }
- break;
- case PW_BORDER:
- if (pWin->borderIsPixel)
- {
- Pixel pixel = pWin->border.pixel |
- RootlessAlphaMask(pWin->drawable.bitsPerPixel);
- fbFillRegionSolid (&pWin->drawable, pRegion, 0,
- fbReplicatePixel (pixel,
- pWin->drawable.bitsPerPixel));
- }
- else
- {
- WindowPtr pBgWin;
- for (pBgWin = pWin; pBgWin->backgroundState == ParentRelative;
- pBgWin = pBgWin->parent);
-
- RootlessFillRegionTiled (&pBgWin->drawable,
- pRegion,
- pWin->border.pixmap);
- }
- break;
- }
- fbValidateDrawable (&pWin->drawable);
-}
projects / synfig.git / blobdiff