massive reduction of unneeded files

1 files changed, 0 insertions, 403 deletions

diff --git a/nx-X11/programs/Xserver/miext/rootless/README.txt b/nx-X11/programs/Xserver/miext/rootless/README.txt
deleted file mode 100644
index ffd17902f..000000000
--- a/nx-X11/programs/Xserver/miext/rootless/README.txt
+++ /dev/null
@@ -1,403 +0,0 @@
-                            Generic Rootless Layer
-                                 Version 1.0
-                                July 13, 2004
-
-                               Torrey T. Lyons
-                              torrey@xfree86.org
-
-
-Introduction
-
-        The generic rootless layer allows an X server to be implemented 
-on top of another window server in a cooperative manner. This allows the 
-X11 windows and native windows of the underlying window server to 
-coexist on the same screen. The layer is called "rootless" because the root 
-window of the X server is generally not drawn. Instead, each top-level 
-child of the root window is represented as a separate on-screen window by 
-the underlying window server. The layer is referred to as "generic" 
-because it abstracts away the details of the underlying window system and 
-contains code that is useful for any rootless X server. The code for the 
-generic rootless layer is located in xc/programs/Xserver/miext/rootless. To 
-build a complete rootless X server requires a specific rootless 
-implementation, which provides functions that allow the generic rootless 
-layer to interact with the underlying window system.
-
-
-Concepts
-
-        In the context of a rootless X server the term window is used to 
-mean many fundamentally different things. For X11 a window is a DDX 
-resource that describes a visible, or potentially visible, rectangle on the 
-screen. A top-level window is a direct child of the root window. To avoid 
-confusion, an on-screen native window of the underlying window system 
-is referred to as a "frame". The generic rootless layer associates each 
-mapped top-level X11 window with a frame. An X11 window may be said 
-to be "framed" if it or its top-level parent is represented by a frame.
-
-        The generic rootless layer models each frame as being backed at 
-all times by a backing buffer, which is periodically flushed to the screen. 
-If the underlying window system does not provide a backing buffer for 
-frames, this must be done by the rootless implementation. The generic 
-rootless layer model does not assume it always has access to the frames' 
-backing buffers. Any drawing to the buffer will be proceeded by a call to 
-the rootless implementation's StartDrawing() function and StopDrawing() 
-will be called when the drawing is concluded. The address of the frame's 
-backing buffer is returned by the StartDrawing() function and it can 
-change between successive calls.
-
-        Because each frame is assumed to have a backing buffer, the 
-generic rootless layer will stop Expose events being generated when the 
-regions of visibility of a frame change on screen. This is similar to backing 
-store, but backing buffers are different in that they always store a copy of 
-the entire window contents, not just the obscured portions. The price paid 
-in increased memory consumption is made up by the greatly decreased 
-complexity in not having to track and record regions as they are obscured.
-
-
-Rootless Implementation
-
-        The specifics of the underlying window system are provided to the 
-generic rootless layer through rootless implementation functions, compile-
-time options, and runtime parameters. The rootless implementation 
-functions are a list of functions that allow the generic rootless layer to 
-perform operations such as creating, destroying, moving, and resizing 
-frames. Some of the implementation functions are optional. A detailed 
-description of the rootless implementation functions is provided in 
-Appendix A.
-
-        By design, a rootless implementation should only have to include 
-the rootless.h header file. The rootlessCommon.h file contains definitions 
-internal to the generic rootless layer. (If you find you need to use 
-rootlessCommon.h in your implementation, let the generic rootless layer 
-maintainers know. This could be an area where the generic rootless layer 
-should be generalized.) A rootless implementation should also modify 
-rootlessConfig.h to specify compile time options for its platform.
-
-        The following compile-time options are defined in 
-rootlessConfig.h:
-
-      o ROOTLESS_ACCEL: If true, use the optional rootless acceleration
-        functions where possible to a accelerate X11 drawing primitives.
-        If false, all drawing will be done with fb.
-
-      o ROOTLESS_GLOBAL_COORDS: This option controls the way that frame
-        coordinates are passed to the rootless implementation. If false,
-        the coordinates are passed per screen relative to the origin of 
-        the screen the frame is currently on. Some implementations may 
-        prefer to work in a single global coordinate space that spans all 
-        screens. If this option is true, the coordinates are passed after 
-        adding the coordinates of the screen origin and an overall offset of 
-        (rootlessGlobalOffsetX, rootlessGlobalOffsetY).
-
-      o ROOTLESS_PROTECT_ALPHA: By default for a color bit depth of 24 and
-        32 bits per pixel, fb will overwrite the "unused" 8 bits to optimize
-        drawing speed. If this is true, the alpha channel of frames is
-        protected and is not modified when drawing to them. The bits 
-        containing the alpha channel are defined by the macro 
-        RootlessAlphaMask(bpp), which should return a bit mask for 
-        various bits per pixel.
-
-      o ROOTLESS_REDISPLAY_DELAY: Time in milliseconds between updates to
-        the underlying window server. Most operations will be buffered until
-        this time has expired.
-
-      o ROOTLESS_RESIZE_GRAVITY: If the underlying window system supports it,
-        some frame resizes can be optimized by relying on the frame contents
-        maintaining a particular gravity during the resize. In this way less
-        of the frame contents need to be preserved by the generic rootless
-        layer. If true, the generic rootless layer will pass gravity hints
-        during resizing and rely on the frame contents being preserved
-        accordingly.
-
-      o ROOTLESS_TRACK_DAMAGE: The generic rootless layer draws to the
-        frames' backing buffers and periodically flushes the modified
-        regions to the underlying window server. If this option is true,
-        the generic rootless layer will track these damaged regions. 
-        Currently it uses the miRegion code and will not simplify damaged 
-        regions even when updating a bounding region would be more 
-        efficient. Some window systems provide a more efficient way to 
-        track damaged regions. If this option is false, the rootless 
-        implementation function DamageRects() is called whenever a 
-        backing buffer is modified and the rootless implementation is 
-        expected to track the damaged regions itself.
-
-        The following runtime options are defined in rootless.h:
-
-      o rootlessGlobalOffsetX, rootlessGlobalOffsetY: These are only 
-        used if ROOTLESS_GLOBAL_COORDS is true. They specify the global
-        offset that is applied to all screens when converting from
-        screen-local to global coordinates.
-
-      o rootless_CopyBytes_threshold, rootless_FillBytes_threshold, 
-        rootless_CompositePixels_threshold, rootless_CopyWindow_threshold:
-        The minimum number of bytes or pixels for which to use the rootless
-        implementation's respective acceleration function. The rootless
-        acceleration functions are all optional so these will only be used
-        if the respective acceleration function pointer is not NULL.
-
-
-Accelerated Drawing
-
-	The rootless implementation typically does not have direct access 
-to the hardware. Its access to the graphics hardware is generally through 
-the API of the underlying window system. This underlying API may not 
-overlap well with the X11 drawing primitives. The generic rootless layer 
-falls back to using fb for all its 2-D drawing. Providing optional rootless 
-implementation acceleration functions can accelerate some graphics 
-primitives and some window functions. Typically calling through to the 
-underlying window systems API will not speed up these operations for 
-small enough areas. The rootless_*_threshold runtime options allow the 
-rootless implementation to provide hints for when the acceleration 
-functions should be used instead of fb.
-
-
-Alpha Channel Protection
-
-	If the bits per pixel is greater then the color bit depth, the contents 
-of the extra bits are undefined by the X11 protocol. Some window systems 
-will use these extra bits as an alpha channel. The generic rootless layer can 
-be configured to protect these bits and make sure they are not modified by 
-other parts of the X server. To protect the alpha channel 
-ROOTLESS_PROTECT_ALPHA and RootlessAlphaMask(bpp) must be 
-set appropriately as described under the compile time options. This 
-ensures that the X11 graphics primitives do not overwrite the alpha 
-channel in an attempt to optimize drawing. In addition, the window 
-functions PaintWindow() and Composite() must be replaced by alpha 
-channel safe variants. These are provided in rootless/safeAlpha.
-
-
-Credits
-
-	The generic rootless layer was originally conceived and developed 
-by Greg Parker as part of the XDarwin X server on Mac OS X. John 
-Harper made later optimizations to this code but removed its generic 
-independence of the underlying window system. Torrey T. Lyons 
-reintroduced the generic abstractions and made the rootless code suitable 
-for use by other X servers.
-
-
-Appendix A: Rootless Implementation Functions
-
-	The rootless implementation functions are defined in rootless.h. It 
-is intended that rootless.h contains the complete interface that is needed by 
-rootless implementations. The definitions contained in rootlessCommon.h 
-are intended for internal use by the generic rootless layer and are more 
-likely to change.
-
-	Most of these functions take a RootlessFrameID as a parameter. 
-The RootlessFrameID is an opaque object that is returned by the 
-implementation's CreateFrame() function. The generic rootless layer does 
-not use this frame id other than to pass it back to the rootless 
-implementation to indicate the frame to operate on.
-
-/*
- * Create a new frame.
- *  The frame is created unmapped.
- *
- *  pFrame      RootlessWindowPtr for this frame should be completely
- *              initialized before calling except for pFrame->wid, which
- *              is set by this function.
- *  pScreen     Screen on which to place the new frame
- *  newX, newY  Position of the frame. These will be identical to pFrame-x,
- *              pFrame->y unless ROOTLESS_GLOBAL_COORDS is set.
- *  pNewShape   Shape for the frame (in frame-local coordinates). NULL for
- *              unshaped frames.
- */
-typedef Bool (*RootlessCreateFrameProc)
-    (RootlessWindowPtr pFrame, ScreenPtr pScreen, int newX, int newY,
-     RegionPtr pNewShape);
-
-/*
- * Destroy a frame.
- *  Drawing is stopped and all updates are flushed before this is called.
- *
- *  wid         Frame id
- */
-typedef void (*RootlessDestroyFrameProc)
-    (RootlessFrameID wid);
-
-/*
- * Move a frame on screen.
- *  Drawing is stopped and all updates are flushed before this is called.
- *
- *  wid         Frame id
- *  pScreen     Screen to move the new frame to
- *  newX, newY  New position of the frame
- */
-typedef void (*RootlessMoveFrameProc) 
-    (RootlessFrameID wid, ScreenPtr pScreen, int newX, int newY);
-
-/*
- * Resize and move a frame.
- *  Drawing is stopped and all updates are flushed before this is called.
- *
- *  wid         Frame id
- *  pScreen     Screen to move the new frame to
- *  newX, newY  New position of the frame
- *  newW, newH  New size of the frame
- *  gravity     Gravity for window contents (rl_gravity_enum). This is always
- *              RL_GRAVITY_NONE unless ROOTLESS_RESIZE_GRAVITY is set.
- */
-typedef void (*RootlessResizeFrameProc)
-    (RootlessFrameID wid, ScreenPtr pScreen,
-     int newX, int newY, unsigned int newW, unsigned int newH,
-     unsigned int gravity);
-
-/*
- * Change frame ordering (AKA stacking, layering).
- *  Drawing is stopped before this is called. Unmapped frames are mapped by
- *  setting their ordering.
- *
- *  wid         Frame id
- *  nextWid     Frame id of frame that is now above this one or NULL if this
- *              frame is at the top.
- */
-typedef void (*RootlessRestackFrameProc)
-    (RootlessFrameID wid, RootlessFrameID nextWid);
-
-/*
- * Change frame's shape.
- *  Drawing is stopped before this is called.
- *
- *  wid         Frame id
- *  pNewShape   New shape for the frame (in frame-local coordinates)
- *              or NULL if now unshaped.
- */
-typedef void (*RootlessReshapeFrameProc)
-    (RootlessFrameID wid, RegionPtr pNewShape);
-
-/*
- * Unmap a frame.
- *
- *  wid         Frame id
- */
-typedef void (*RootlessUnmapFrameProc)
-    (RootlessFrameID wid);
-
-/*
- * Start drawing to a frame.
- *  Prepare a frame for direct access to its backing buffer.
- *
- *  wid         Frame id
- *  pixelData   Address of the backing buffer (returned)
- *  bytesPerRow Width in bytes of the backing buffer (returned)
- */
-typedef void (*RootlessStartDrawingProc)
-    (RootlessFrameID wid, char **pixelData, int *bytesPerRow);
-
-/*
- * Stop drawing to a frame.
- *  No drawing to the frame's backing buffer will occur until drawing
- *  is started again.
- *
- *  wid         Frame id
- *  flush       Flush drawing updates for this frame to the screen. This
- *              will always be FALSE if ROOTLESS_TRACK_DAMAGE is set.
- */
-typedef void (*RootlessStopDrawingProc)
-    (RootlessFrameID wid, Bool flush);
-
-/*
- * Flush drawing updates to the screen.
- *  Drawing is stopped before this is called.
- *
- *  wid         Frame id
- *  pDamage     Region containing all the changed pixels in frame-local
- *              coordinates. This is clipped to the window's clip. This
- *              will be NULL if ROOTLESS_TRACK_DAMAGE is not set.
- */
-typedef void (*RootlessUpdateRegionProc)
-    (RootlessFrameID wid, RegionPtr pDamage);
-
-/*
- * Mark damaged rectangles as requiring redisplay to screen.
- *  This will only be called if ROOTLESS_TRACK_DAMAGE is not set.
- *
- *  wid         Frame id
- *  nrects      Number of damaged rectangles
- *  rects       Array of damaged rectangles in frame-local coordinates
- *  shift_x,    Vector to shift rectangles by
- *   shift_y
- */
-typedef void (*RootlessDamageRectsProc)
-    (RootlessFrameID wid, int nrects, const BoxRec *rects,
-     int shift_x, int shift_y);
-
-/*
- * Switch the window associated with a frame. (Optional)
- *  When a framed window is reparented, the frame is resized and set to
- *  use the new top-level parent. If defined this function will be called
- *  afterwards for implementation specific bookkeeping.
- *
- *  pFrame      Frame whose window has switched
- *  oldWin      Previous window wrapped by this frame
- */
-typedef void (*RootlessSwitchWindowProc)
-    (RootlessWindowPtr pFrame, WindowPtr oldWin);
-
-/*
- * Copy bytes. (Optional)
- *  Source and destinate may overlap and the right thing should happen.
- *
- *  width       Bytes to copy per row
- *  height      Number of rows
- *  src         Source data
- *  srcRowBytes Width of source in bytes
- *  dst         Destination data
- *  dstRowBytes Width of destination in bytes
- */
-typedef void (*RootlessCopyBytesProc)
-    (unsigned int width, unsigned int height,
-     const void *src, unsigned int srcRowBytes,
-     void *dst, unsigned int dstRowBytes);
-
-/*
- * Fill memory with 32-bit pattern. (Optional)
- *
- *  width       Bytes to fill per row
- *  height      Number of rows
- *  value       32-bit pattern to fill with
- *  dst         Destination data
- *  dstRowBytes Width of destination in bytes
- */
-typedef void (*RootlessFillBytesProc)
-    (unsigned int width, unsigned int height, unsigned int value,
-     void *dst, unsigned int dstRowBytes);
-
-/*
- * Composite pixels from source and mask to destination. (Optional)
- *
- *  width, height   Size of area to composite to in pizels
- *  function        Composite function built with RL_COMPOSITE_FUNCTION
- *  src             Source data
- *  srcRowBytes     Width of source in bytes (Passing NULL means source
- *                  is a single pixel.
- *  mask            Mask data
- *  maskRowBytes    Width of mask in bytes
- *  dst             Destination data
- *  dstRowBytes     Width of destination in bytes
- *
- *  For src and dst, the first element of the array is the color data. If
- *  the second element is non-null it implies there is alpha data (which
- *  may be meshed or planar). Data without alpha is assumed to be opaque.
- *
- *  An X11 error code is returned.
- */
-typedef int (*RootlessCompositePixelsProc)
-    (unsigned int width, unsigned int height, unsigned int function,
-     void *src[2], unsigned int srcRowBytes[2],
-     void *mask, unsigned int maskRowBytes,
-     void *dst[2], unsigned int dstRowBytes[2]);
-
-/*
- * Copy area in frame to another part of frame. (Optional)
- *
- *  wid         Frame id
- *  dstNrects   Number of rectangles to copy
- *  dstRects    Array of rectangles to copy
- *  dx, dy      Number of pixels away to copy area
- */
-typedef void (*RootlessCopyWindowProc)
-    (RootlessFrameID wid, int dstNrects, const BoxRec *dstRects,
-     int dx, int dy);
-