1/***********************************************************
2
3Copyright 1987, 1998  The Open Group
4
5Permission to use, copy, modify, distribute, and sell this software and its
6documentation for any purpose is hereby granted without fee, provided that
7the above copyright notice appear in all copies and that both that
8copyright notice and this permission notice appear in supporting
9documentation.
10
11The above copyright notice and this permission notice shall be included in
12all copies or substantial portions of the Software.
13
14THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
17OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20
21Except as contained in this notice, the name of The Open Group shall not be
22used in advertising or otherwise to promote the sale, use or other dealings
23in this Software without prior written authorization from The Open Group.
24
25Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
26
27                        All Rights Reserved
28
29Permission to use, copy, modify, and distribute this software and its
30documentation for any purpose and without fee is hereby granted,
31provided that the above copyright notice appear in all copies and that
32both that copyright notice and this permission notice appear in
33supporting documentation, and that the name of Digital not be
34used in advertising or publicity pertaining to distribution of the
35software without specific, written prior permission.
36
37DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
38ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
39DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
40ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
41WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
42ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
43SOFTWARE.
44
45******************************************************************/
46
47#ifndef SCREENINTSTRUCT_H
48#define SCREENINTSTRUCT_H
49
50#include "screenint.h"
51#include "regionstr.h"
52#include "colormap.h"
53#include "cursor.h"
54#include "validate.h"
55#include <X11/Xproto.h>
56#include "dix.h"
57#include "privates.h"
58#include <X11/extensions/randr.h>
59
60typedef struct _PixmapFormat {
61    unsigned char depth;
62    unsigned char bitsPerPixel;
63    unsigned char scanlinePad;
64} PixmapFormatRec;
65
66typedef struct _Visual {
67    VisualID vid;
68    short class;
69    short bitsPerRGBValue;
70    short ColormapEntries;
71    short nplanes;              /* = log2 (ColormapEntries). This does not
72                                 * imply that the screen has this many planes.
73                                 * it may have more or fewer */
74    unsigned long redMask, greenMask, blueMask;
75    int offsetRed, offsetGreen, offsetBlue;
76} VisualRec;
77
78typedef struct _Depth {
79    unsigned char depth;
80    short numVids;
81    VisualID *vids;             /* block of visual ids for this depth */
82} DepthRec;
83
84typedef struct _ScreenSaverStuff {
85    WindowPtr pWindow;
86    XID wid;
87    char blanked;
88    Bool (*ExternalScreenSaver) (ScreenPtr /*pScreen */ ,
89                                 int /*xstate */ ,
90                                 Bool /*force */ );
91} ScreenSaverStuffRec;
92
93/*
94 *  There is a typedef for each screen function pointer so that code that
95 *  needs to declare a screen function pointer (e.g. in a screen private
96 *  or as a local variable) can easily do so and retain full type checking.
97 */
98
99typedef Bool (*CloseScreenProcPtr) (ScreenPtr /*pScreen */ );
100
101typedef void (*QueryBestSizeProcPtr) (int /*class */ ,
102                                      unsigned short * /*pwidth */ ,
103                                      unsigned short * /*pheight */ ,
104                                      ScreenPtr /*pScreen */ );
105
106typedef Bool (*SaveScreenProcPtr) (ScreenPtr /*pScreen */ ,
107                                   int /*on */ );
108
109typedef void (*GetImageProcPtr) (DrawablePtr /*pDrawable */ ,
110                                 int /*sx */ ,
111                                 int /*sy */ ,
112                                 int /*w */ ,
113                                 int /*h */ ,
114                                 unsigned int /*format */ ,
115                                 unsigned long /*planeMask */ ,
116                                 char * /*pdstLine */ );
117
118typedef void (*GetSpansProcPtr) (DrawablePtr /*pDrawable */ ,
119                                 int /*wMax */ ,
120                                 DDXPointPtr /*ppt */ ,
121                                 int * /*pwidth */ ,
122                                 int /*nspans */ ,
123                                 char * /*pdstStart */ );
124
125typedef void (*SourceValidateProcPtr) (DrawablePtr /*pDrawable */ ,
126                                       int /*x */ ,
127                                       int /*y */ ,
128                                       int /*width */ ,
129                                       int /*height */ ,
130                                       unsigned int /*subWindowMode */ );
131
132typedef Bool (*CreateWindowProcPtr) (WindowPtr /*pWindow */ );
133
134typedef Bool (*DestroyWindowProcPtr) (WindowPtr /*pWindow */ );
135
136typedef Bool (*PositionWindowProcPtr) (WindowPtr /*pWindow */ ,
137                                       int /*x */ ,
138                                       int /*y */ );
139
140typedef Bool (*ChangeWindowAttributesProcPtr) (WindowPtr /*pWindow */ ,
141                                               unsigned long /*mask */ );
142
143typedef Bool (*RealizeWindowProcPtr) (WindowPtr /*pWindow */ );
144
145typedef Bool (*UnrealizeWindowProcPtr) (WindowPtr /*pWindow */ );
146
147typedef void (*RestackWindowProcPtr) (WindowPtr /*pWindow */ ,
148                                      WindowPtr /*pOldNextSib */ );
149
150typedef int (*ValidateTreeProcPtr) (WindowPtr /*pParent */ ,
151                                    WindowPtr /*pChild */ ,
152                                    VTKind /*kind */ );
153
154typedef void (*PostValidateTreeProcPtr) (WindowPtr /*pParent */ ,
155                                         WindowPtr /*pChild */ ,
156                                         VTKind /*kind */ );
157
158typedef void (*WindowExposuresProcPtr) (WindowPtr /*pWindow */ ,
159                                        RegionPtr /*prgn */);
160
161typedef void (*PaintWindowProcPtr) (WindowPtr /*pWindow*/,
162                                    RegionPtr /*pRegion*/,
163                                    int /*what*/);
164
165typedef void (*CopyWindowProcPtr) (WindowPtr /*pWindow */ ,
166                                   DDXPointRec /*ptOldOrg */ ,
167                                   RegionPtr /*prgnSrc */ );
168
169typedef void (*ClearToBackgroundProcPtr) (WindowPtr /*pWindow */ ,
170                                          int /*x */ ,
171                                          int /*y */ ,
172                                          int /*w */ ,
173                                          int /*h */ ,
174                                          Bool /*generateExposures */ );
175
176typedef void (*ClipNotifyProcPtr) (WindowPtr /*pWindow */ ,
177                                   int /*dx */ ,
178                                   int /*dy */ );
179
180/* pixmap will exist only for the duration of the current rendering operation */
181#define CREATE_PIXMAP_USAGE_SCRATCH                     1
182/* pixmap will be the backing pixmap for a redirected window */
183#define CREATE_PIXMAP_USAGE_BACKING_PIXMAP              2
184/* pixmap will contain a glyph */
185#define CREATE_PIXMAP_USAGE_GLYPH_PICTURE               3
186/* pixmap will be shared */
187#define CREATE_PIXMAP_USAGE_SHARED                      4
188
189typedef PixmapPtr (*CreatePixmapProcPtr) (ScreenPtr /*pScreen */ ,
190                                          int /*width */ ,
191                                          int /*height */ ,
192                                          int /*depth */ ,
193                                          unsigned /*usage_hint */ );
194
195typedef Bool (*DestroyPixmapProcPtr) (PixmapPtr /*pPixmap */ );
196
197typedef Bool (*RealizeFontProcPtr) (ScreenPtr /*pScreen */ ,
198                                    FontPtr /*pFont */ );
199
200typedef Bool (*UnrealizeFontProcPtr) (ScreenPtr /*pScreen */ ,
201                                      FontPtr /*pFont */ );
202
203typedef void (*ConstrainCursorProcPtr) (DeviceIntPtr /*pDev */ ,
204                                        ScreenPtr /*pScreen */ ,
205                                        BoxPtr /*pBox */ );
206
207typedef void (*CursorLimitsProcPtr) (DeviceIntPtr /* pDev */ ,
208                                     ScreenPtr /*pScreen */ ,
209                                     CursorPtr /*pCursor */ ,
210                                     BoxPtr /*pHotBox */ ,
211                                     BoxPtr /*pTopLeftBox */ );
212
213typedef Bool (*DisplayCursorProcPtr) (DeviceIntPtr /* pDev */ ,
214                                      ScreenPtr /*pScreen */ ,
215                                      CursorPtr /*pCursor */ );
216
217typedef Bool (*RealizeCursorProcPtr) (DeviceIntPtr /* pDev */ ,
218                                      ScreenPtr /*pScreen */ ,
219                                      CursorPtr /*pCursor */ );
220
221typedef Bool (*UnrealizeCursorProcPtr) (DeviceIntPtr /* pDev */ ,
222                                        ScreenPtr /*pScreen */ ,
223                                        CursorPtr /*pCursor */ );
224
225typedef void (*RecolorCursorProcPtr) (DeviceIntPtr /* pDev */ ,
226                                      ScreenPtr /*pScreen */ ,
227                                      CursorPtr /*pCursor */ ,
228                                      Bool /*displayed */ );
229
230typedef Bool (*SetCursorPositionProcPtr) (DeviceIntPtr /* pDev */ ,
231                                          ScreenPtr /*pScreen */ ,
232                                          int /*x */ ,
233                                          int /*y */ ,
234                                          Bool /*generateEvent */ );
235
236typedef void (*CursorWarpedToProcPtr) (DeviceIntPtr /* pDev */ ,
237                                       ScreenPtr /*pScreen */ ,
238                                       ClientPtr /*pClient */ ,
239                                       WindowPtr /*pWindow */ ,
240                                       SpritePtr /*pSprite */ ,
241                                       int /*x */ ,
242                                       int /*y */ );
243
244typedef void (*CurserConfinedToProcPtr) (DeviceIntPtr /* pDev */ ,
245                                         ScreenPtr /*pScreen */ ,
246                                         WindowPtr /*pWindow */ );
247
248typedef Bool (*CreateGCProcPtr) (GCPtr /*pGC */ );
249
250typedef Bool (*CreateColormapProcPtr) (ColormapPtr /*pColormap */ );
251
252typedef void (*DestroyColormapProcPtr) (ColormapPtr /*pColormap */ );
253
254typedef void (*InstallColormapProcPtr) (ColormapPtr /*pColormap */ );
255
256typedef void (*UninstallColormapProcPtr) (ColormapPtr /*pColormap */ );
257
258typedef int (*ListInstalledColormapsProcPtr) (ScreenPtr /*pScreen */ ,
259                                              XID * /*pmaps */ );
260
261typedef void (*StoreColorsProcPtr) (ColormapPtr /*pColormap */ ,
262                                    int /*ndef */ ,
263                                    xColorItem * /*pdef */ );
264
265typedef void (*ResolveColorProcPtr) (unsigned short * /*pred */ ,
266                                     unsigned short * /*pgreen */ ,
267                                     unsigned short * /*pblue */ ,
268                                     VisualPtr /*pVisual */ );
269
270typedef RegionPtr (*BitmapToRegionProcPtr) (PixmapPtr /*pPix */ );
271
272typedef void (*ScreenBlockHandlerProcPtr) (ScreenPtr pScreen,
273                                           void *timeout);
274
275/* result has three possible values:
276 * < 0 - error
277 * = 0 - timeout
278 * > 0 - activity
279 */
280typedef void (*ScreenWakeupHandlerProcPtr) (ScreenPtr pScreen,
281                                            int result);
282
283typedef Bool (*CreateScreenResourcesProcPtr) (ScreenPtr /*pScreen */ );
284
285typedef Bool (*ModifyPixmapHeaderProcPtr) (PixmapPtr pPixmap,
286                                           int width,
287                                           int height,
288                                           int depth,
289                                           int bitsPerPixel,
290                                           int devKind,
291                                           void *pPixData);
292
293typedef PixmapPtr (*GetWindowPixmapProcPtr) (WindowPtr /*pWin */ );
294
295typedef void (*SetWindowPixmapProcPtr) (WindowPtr /*pWin */ ,
296                                        PixmapPtr /*pPix */ );
297
298typedef PixmapPtr (*GetScreenPixmapProcPtr) (ScreenPtr /*pScreen */ );
299
300typedef void (*SetScreenPixmapProcPtr) (PixmapPtr /*pPix */ );
301
302typedef void (*MarkWindowProcPtr) (WindowPtr /*pWin */ );
303
304typedef Bool (*MarkOverlappedWindowsProcPtr) (WindowPtr /*parent */ ,
305                                              WindowPtr /*firstChild */ ,
306                                              WindowPtr * /*pLayerWin */ );
307
308typedef int (*ConfigNotifyProcPtr) (WindowPtr /*pWin */ ,
309                                    int /*x */ ,
310                                    int /*y */ ,
311                                    int /*w */ ,
312                                    int /*h */ ,
313                                    int /*bw */ ,
314                                    WindowPtr /*pSib */ );
315
316typedef void (*MoveWindowProcPtr) (WindowPtr /*pWin */ ,
317                                   int /*x */ ,
318                                   int /*y */ ,
319                                   WindowPtr /*pSib */ ,
320                                   VTKind /*kind */ );
321
322typedef void (*ResizeWindowProcPtr) (WindowPtr /*pWin */ ,
323                                     int /*x */ ,
324                                     int /*y */ ,
325                                     unsigned int /*w */ ,
326                                     unsigned int /*h */ ,
327                                     WindowPtr  /*pSib */
328    );
329
330typedef WindowPtr (*GetLayerWindowProcPtr) (WindowPtr   /*pWin */
331    );
332
333typedef void (*HandleExposuresProcPtr) (WindowPtr /*pWin */ );
334
335typedef void (*ReparentWindowProcPtr) (WindowPtr /*pWin */ ,
336                                       WindowPtr /*pPriorParent */ );
337
338typedef void (*SetShapeProcPtr) (WindowPtr /*pWin */ ,
339                                 int /* kind */ );
340
341typedef void (*ChangeBorderWidthProcPtr) (WindowPtr /*pWin */ ,
342                                          unsigned int /*width */ );
343
344typedef void (*MarkUnrealizedWindowProcPtr) (WindowPtr /*pChild */ ,
345                                             WindowPtr /*pWin */ ,
346                                             Bool /*fromConfigure */ );
347
348typedef Bool (*DeviceCursorInitializeProcPtr) (DeviceIntPtr /* pDev */ ,
349                                               ScreenPtr /* pScreen */ );
350
351typedef void (*DeviceCursorCleanupProcPtr) (DeviceIntPtr /* pDev */ ,
352                                            ScreenPtr /* pScreen */ );
353
354typedef void (*ConstrainCursorHarderProcPtr) (DeviceIntPtr, ScreenPtr, int,
355                                              int *, int *);
356
357
358typedef Bool (*SharePixmapBackingProcPtr)(PixmapPtr, ScreenPtr, void **);
359
360typedef Bool (*SetSharedPixmapBackingProcPtr)(PixmapPtr, void *);
361
362#define HAS_SYNC_SHARED_PIXMAP 1
363/* The SyncSharedPixmap hook has two purposes:
364 *
365 * 1. If the primary driver has it, the secondary driver can use it to
366 * synchronize the shared pixmap contents with the screen pixmap.
367 * 2. If the secondary driver has it, the primary driver can expect the secondary
368 * driver to call the primary screen's SyncSharedPixmap hook, so the primary
369 * driver doesn't have to synchronize the shared pixmap contents itself,
370 * e.g. from the BlockHandler.
371 *
372 * A driver must only set the hook if it handles both cases correctly.
373 *
374 * The argument is the secondary screen's pixmap_dirty_list entry, the hook is
375 * responsible for finding the corresponding entry in the primary screen's
376 * pixmap_dirty_list.
377 */
378typedef void (*SyncSharedPixmapProcPtr)(PixmapDirtyUpdatePtr);
379
380typedef Bool (*StartPixmapTrackingProcPtr)(DrawablePtr, PixmapPtr,
381                                           int x, int y,
382                                           int dst_x, int dst_y,
383                                           Rotation rotation);
384
385typedef Bool (*PresentSharedPixmapProcPtr)(PixmapPtr);
386
387typedef Bool (*RequestSharedPixmapNotifyDamageProcPtr)(PixmapPtr);
388
389typedef Bool (*StopPixmapTrackingProcPtr)(DrawablePtr, PixmapPtr);
390
391typedef Bool (*StopFlippingPixmapTrackingProcPtr)(DrawablePtr,
392                                                  PixmapPtr, PixmapPtr);
393
394typedef Bool (*SharedPixmapNotifyDamageProcPtr)(PixmapPtr);
395
396typedef Bool (*ReplaceScanoutPixmapProcPtr)(DrawablePtr, PixmapPtr, Bool);
397
398typedef WindowPtr (*XYToWindowProcPtr)(ScreenPtr pScreen,
399                                       SpritePtr pSprite, int x, int y);
400
401typedef int (*NameWindowPixmapProcPtr)(WindowPtr, PixmapPtr, CARD32);
402
403typedef void (*DPMSProcPtr)(ScreenPtr pScreen, int level);
404
405/* Wrapping Screen procedures
406
407   There are a few modules in the X server which dynamically add and
408    remove themselves from various screen procedure call chains.
409
410    For example, the BlockHandler is dynamically modified by:
411
412     * xf86Rotate
413     * miSprite
414     * composite
415     * render (for animated cursors)
416
417    Correctly manipulating this chain is complicated by the fact that
418    the chain is constructed through a sequence of screen private
419    structures, each holding the next screen->proc pointer.
420
421    To add a module to a screen->proc chain is fairly simple; just save
422    the current screen->proc value in the module screen private
423    and store the module's function in the screen->proc location.
424
425    Removing a screen proc is a bit trickier. It seems like all you
426    need to do is set the screen->proc pointer back to the value saved
427    in your screen private. However, if some other module has come
428    along and wrapped on top of you, then the right place to store the
429    previous screen->proc value is actually in the wrapping module's
430    screen private structure(!). Of course, you have no idea what
431    other module may have wrapped on top, nor could you poke inside
432    its screen private in any case.
433
434    To make this work, we restrict the unwrapping process to happen
435    during the invocation of the screen proc itself, and then we
436    require the screen proc to take some care when manipulating the
437    screen proc functions pointers.
438
439    The requirements are:
440
441     1) The screen proc must set the screen->proc pointer back to the
442        value saved in its screen private before calling outside its
443        module.
444
445     2a) If the screen proc wants to be remove itself from the chain,
446         it must not manipulate screen->proc pointer again before
447         returning.
448
449     2b) If the screen proc wants to remain in the chain, it must:
450
451       2b.1) Re-fetch the screen->proc pointer and store that in
452             its screen private. This ensures that any changes
453             to the chain will be preserved.
454
455       2b.2) Set screen->proc back to itself
456
457    One key requirement here is that these steps must wrap not just
458    any invocation of the nested screen->proc value, but must nest
459    essentially any calls outside the current module. This ensures
460    that other modules can reliably manipulate screen->proc wrapping
461    using these same rules.
462
463    For example, the animated cursor code in render has two macros,
464    Wrap and Unwrap.
465
466        #define Unwrap(as,s,elt)    ((s)->elt = (as)->elt)
467
468    Unwrap takes the screen private (as), the screen (s) and the
469    member name (elt), and restores screen->proc to that saved in the
470    screen private.
471
472        #define Wrap(as,s,elt,func) (((as)->elt = (s)->elt), (s)->elt = func)
473
474    Wrap takes the screen private (as), the screen (s), the member
475    name (elt) and the wrapping function (func). It saves the
476    current screen->proc value in the screen private, and then sets the
477    screen->proc to the local wrapping function.
478
479    Within each of these functions, there's a pretty simple pattern:
480
481        Unwrap(as, pScreen, UnrealizeCursor);
482
483        // Do local stuff, including possibly calling down through
484        // pScreen->UnrealizeCursor
485
486        Wrap(as, pScreen, UnrealizeCursor, AnimCurUnrealizeCursor);
487
488    The wrapping block handler is a bit different; it does the Unwrap,
489    the local operations, and then only re-Wraps if the hook is still
490    required. Unwrap occurs at the top of each function, just after
491    entry, and Wrap occurs at the bottom of each function, just
492    before returning.
493 */
494
495typedef struct _Screen {
496    int myNum;                  /* index of this instance in Screens[] */
497    ATOM id;
498    short x, y, width, height;
499    short mmWidth, mmHeight;
500    short numDepths;
501    unsigned char rootDepth;
502    DepthPtr allowedDepths;
503    unsigned long rootVisual;
504    unsigned long defColormap;
505    short minInstalledCmaps, maxInstalledCmaps;
506    char backingStoreSupport, saveUnderSupport;
507    unsigned long whitePixel, blackPixel;
508    GCPtr GCperDepth[MAXFORMATS + 1];
509    /* next field is a stipple to use as default in a GC.  we don't build
510     * default tiles of all depths because they are likely to be of a color
511     * different from the default fg pixel, so we don't win anything by
512     * building a standard one.
513     */
514    PixmapPtr defaultStipple;
515    void *devPrivate;
516    short numVisuals;
517    VisualPtr visuals;
518    WindowPtr root;
519    ScreenSaverStuffRec screensaver;
520
521    DevPrivateSetRec    screenSpecificPrivates[PRIVATE_LAST];
522
523    /* Random screen procedures */
524
525    CloseScreenProcPtr CloseScreen;
526    QueryBestSizeProcPtr QueryBestSize;
527    SaveScreenProcPtr SaveScreen;
528    GetImageProcPtr GetImage;
529    GetSpansProcPtr GetSpans;
530    SourceValidateProcPtr SourceValidate;
531
532    /* Window Procedures */
533
534    CreateWindowProcPtr CreateWindow;
535    DestroyWindowProcPtr DestroyWindow;
536    PositionWindowProcPtr PositionWindow;
537    ChangeWindowAttributesProcPtr ChangeWindowAttributes;
538    RealizeWindowProcPtr RealizeWindow;
539    UnrealizeWindowProcPtr UnrealizeWindow;
540    ValidateTreeProcPtr ValidateTree;
541    PostValidateTreeProcPtr PostValidateTree;
542    WindowExposuresProcPtr WindowExposures;
543    CopyWindowProcPtr CopyWindow;
544    ClearToBackgroundProcPtr ClearToBackground;
545    ClipNotifyProcPtr ClipNotify;
546    RestackWindowProcPtr RestackWindow;
547    PaintWindowProcPtr PaintWindow;
548
549    /* Pixmap procedures */
550
551    CreatePixmapProcPtr CreatePixmap;
552    DestroyPixmapProcPtr DestroyPixmap;
553
554    /* Font procedures */
555
556    RealizeFontProcPtr RealizeFont;
557    UnrealizeFontProcPtr UnrealizeFont;
558
559    /* Cursor Procedures */
560
561    ConstrainCursorProcPtr ConstrainCursor;
562    ConstrainCursorHarderProcPtr ConstrainCursorHarder;
563    CursorLimitsProcPtr CursorLimits;
564    DisplayCursorProcPtr DisplayCursor;
565    RealizeCursorProcPtr RealizeCursor;
566    UnrealizeCursorProcPtr UnrealizeCursor;
567    RecolorCursorProcPtr RecolorCursor;
568    SetCursorPositionProcPtr SetCursorPosition;
569    CursorWarpedToProcPtr CursorWarpedTo;
570    CurserConfinedToProcPtr CursorConfinedTo;
571
572    /* GC procedures */
573
574    CreateGCProcPtr CreateGC;
575
576    /* Colormap procedures */
577
578    CreateColormapProcPtr CreateColormap;
579    DestroyColormapProcPtr DestroyColormap;
580    InstallColormapProcPtr InstallColormap;
581    UninstallColormapProcPtr UninstallColormap;
582    ListInstalledColormapsProcPtr ListInstalledColormaps;
583    StoreColorsProcPtr StoreColors;
584    ResolveColorProcPtr ResolveColor;
585
586    /* Region procedures */
587
588    BitmapToRegionProcPtr BitmapToRegion;
589
590    /* os layer procedures */
591
592    ScreenBlockHandlerProcPtr BlockHandler;
593    ScreenWakeupHandlerProcPtr WakeupHandler;
594
595    /* anybody can get a piece of this array */
596    PrivateRec *devPrivates;
597
598    CreateScreenResourcesProcPtr CreateScreenResources;
599    ModifyPixmapHeaderProcPtr ModifyPixmapHeader;
600
601    GetWindowPixmapProcPtr GetWindowPixmap;
602    SetWindowPixmapProcPtr SetWindowPixmap;
603    GetScreenPixmapProcPtr GetScreenPixmap;
604    SetScreenPixmapProcPtr SetScreenPixmap;
605    NameWindowPixmapProcPtr NameWindowPixmap;
606
607    PixmapPtr pScratchPixmap;   /* scratch pixmap "pool" */
608
609    unsigned int totalPixmapSize;
610
611    MarkWindowProcPtr MarkWindow;
612    MarkOverlappedWindowsProcPtr MarkOverlappedWindows;
613    ConfigNotifyProcPtr ConfigNotify;
614    MoveWindowProcPtr MoveWindow;
615    ResizeWindowProcPtr ResizeWindow;
616    GetLayerWindowProcPtr GetLayerWindow;
617    HandleExposuresProcPtr HandleExposures;
618    ReparentWindowProcPtr ReparentWindow;
619
620    SetShapeProcPtr SetShape;
621
622    ChangeBorderWidthProcPtr ChangeBorderWidth;
623    MarkUnrealizedWindowProcPtr MarkUnrealizedWindow;
624
625    /* Device cursor procedures */
626    DeviceCursorInitializeProcPtr DeviceCursorInitialize;
627    DeviceCursorCleanupProcPtr DeviceCursorCleanup;
628
629    /* set it in driver side if X server can copy the framebuffer content.
630     * Meant to be used together with '-background none' option, avoiding
631     * malicious users to steal framebuffer's content if that would be the
632     * default */
633    Bool canDoBGNoneRoot;
634
635    Bool isGPU;
636
637    /* Info on this screen's secondarys (if any) */
638    struct xorg_list secondary_list;
639    struct xorg_list secondary_head;
640    int output_secondarys;
641    /* Info for when this screen is a secondary */
642    ScreenPtr current_primary;
643    Bool is_output_secondary;
644    Bool is_offload_secondary;
645
646    SharePixmapBackingProcPtr SharePixmapBacking;
647    SetSharedPixmapBackingProcPtr SetSharedPixmapBacking;
648
649    StartPixmapTrackingProcPtr StartPixmapTracking;
650    StopPixmapTrackingProcPtr StopPixmapTracking;
651    SyncSharedPixmapProcPtr SyncSharedPixmap;
652
653    SharedPixmapNotifyDamageProcPtr SharedPixmapNotifyDamage;
654    RequestSharedPixmapNotifyDamageProcPtr RequestSharedPixmapNotifyDamage;
655    PresentSharedPixmapProcPtr PresentSharedPixmap;
656    StopFlippingPixmapTrackingProcPtr StopFlippingPixmapTracking;
657
658    struct xorg_list pixmap_dirty_list;
659
660    ReplaceScanoutPixmapProcPtr ReplaceScanoutPixmap;
661    XYToWindowProcPtr XYToWindow;
662    DPMSProcPtr DPMS;
663} ScreenRec;
664
665static inline RegionPtr
666BitmapToRegion(ScreenPtr _pScreen, PixmapPtr pPix)
667{
668    return (*(_pScreen)->BitmapToRegion) (pPix);        /* no mi version?! */
669}
670
671typedef struct _ScreenInfo {
672    int imageByteOrder;
673    int bitmapScanlineUnit;
674    int bitmapScanlinePad;
675    int bitmapBitOrder;
676    int numPixmapFormats;
677     PixmapFormatRec formats[MAXFORMATS];
678    int numScreens;
679    ScreenPtr screens[MAXSCREENS];
680    int numGPUScreens;
681    ScreenPtr gpuscreens[MAXGPUSCREENS];
682    int x;                      /* origin */
683    int y;                      /* origin */
684    int width;                  /* total width of all screens together */
685    int height;                 /* total height of all screens together */
686} ScreenInfo;
687
688extern _X_EXPORT ScreenInfo screenInfo;
689
690extern _X_EXPORT void InitOutput(ScreenInfo * /*pScreenInfo */ ,
691                                 int /*argc */ ,
692                                 char ** /*argv */ );
693
694#endif                          /* SCREENINTSTRUCT_H */
695