aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/programs/Xserver/miext/rootless/README.txt
diff options
context:
space:
mode:
authorReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
committerReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
commitf4092abdf94af6a99aff944d6264bc1284e8bdd4 (patch)
tree2ac1c9cc16ceb93edb2c4382c088dac5aeafdf0f /nx-X11/programs/Xserver/miext/rootless/README.txt
parenta840692edc9c6d19cd7c057f68e39c7d95eb767d (diff)
downloadnx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.gz
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.bz2
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.zip
Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1
Summary: Imported nx-X11-3.1.0-1.tar.gz Keywords: Imported nx-X11-3.1.0-1.tar.gz into Git repository
Diffstat (limited to 'nx-X11/programs/Xserver/miext/rootless/README.txt')
-rw-r--r--nx-X11/programs/Xserver/miext/rootless/README.txt403
1 files changed, 403 insertions, 0 deletions
diff --git a/nx-X11/programs/Xserver/miext/rootless/README.txt b/nx-X11/programs/Xserver/miext/rootless/README.txt
new file mode 100644
index 000000000..ffd17902f
--- /dev/null
+++ b/nx-X11/programs/Xserver/miext/rootless/README.txt
@@ -0,0 +1,403 @@
+ 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);
+