scrnintstr.h (27314B)
1 /*********************************************************** 2 3 Copyright 1987, 1998 The Open Group 4 5 Permission to use, copy, modify, distribute, and sell this software and its 6 documentation for any purpose is hereby granted without fee, provided that 7 the above copyright notice appear in all copies and that both that 8 copyright notice and this permission notice appear in supporting 9 documentation. 10 11 The above copyright notice and this permission notice shall be included in 12 all copies or substantial portions of the Software. 13 14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 18 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 19 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 20 21 Except as contained in this notice, the name of The Open Group shall not be 22 used in advertising or otherwise to promote the sale, use or other dealings 23 in this Software without prior written authorization from The Open Group. 24 25 Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. 26 27 All Rights Reserved 28 29 Permission to use, copy, modify, and distribute this software and its 30 documentation for any purpose and without fee is hereby granted, 31 provided that the above copyright notice appear in all copies and that 32 both that copyright notice and this permission notice appear in 33 supporting documentation, and that the name of Digital not be 34 used in advertising or publicity pertaining to distribution of the 35 software without specific, written prior permission. 36 37 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING 38 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL 39 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR 40 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 41 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, 42 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS 43 SOFTWARE. 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 60 typedef struct _PixmapFormat { 61 unsigned char depth; 62 unsigned char bitsPerPixel; 63 unsigned char scanlinePad; 64 } PixmapFormatRec; 65 66 typedef 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 78 typedef struct _Depth { 79 unsigned char depth; 80 short numVids; 81 VisualID *vids; /* block of visual ids for this depth */ 82 } DepthRec; 83 84 typedef 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 99 typedef Bool (*CloseScreenProcPtr) (ScreenPtr /*pScreen */ ); 100 101 typedef void (*QueryBestSizeProcPtr) (int /*class */ , 102 unsigned short * /*pwidth */ , 103 unsigned short * /*pheight */ , 104 ScreenPtr /*pScreen */ ); 105 106 typedef Bool (*SaveScreenProcPtr) (ScreenPtr /*pScreen */ , 107 int /*on */ ); 108 109 typedef 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 118 typedef void (*GetSpansProcPtr) (DrawablePtr /*pDrawable */ , 119 int /*wMax */ , 120 DDXPointPtr /*ppt */ , 121 int * /*pwidth */ , 122 int /*nspans */ , 123 char * /*pdstStart */ ); 124 125 typedef void (*SourceValidateProcPtr) (DrawablePtr /*pDrawable */ , 126 int /*x */ , 127 int /*y */ , 128 int /*width */ , 129 int /*height */ , 130 unsigned int /*subWindowMode */ ); 131 132 typedef Bool (*CreateWindowProcPtr) (WindowPtr /*pWindow */ ); 133 134 typedef Bool (*DestroyWindowProcPtr) (WindowPtr /*pWindow */ ); 135 136 typedef Bool (*PositionWindowProcPtr) (WindowPtr /*pWindow */ , 137 int /*x */ , 138 int /*y */ ); 139 140 typedef Bool (*ChangeWindowAttributesProcPtr) (WindowPtr /*pWindow */ , 141 unsigned long /*mask */ ); 142 143 typedef Bool (*RealizeWindowProcPtr) (WindowPtr /*pWindow */ ); 144 145 typedef Bool (*UnrealizeWindowProcPtr) (WindowPtr /*pWindow */ ); 146 147 typedef void (*RestackWindowProcPtr) (WindowPtr /*pWindow */ , 148 WindowPtr /*pOldNextSib */ ); 149 150 typedef int (*ValidateTreeProcPtr) (WindowPtr /*pParent */ , 151 WindowPtr /*pChild */ , 152 VTKind /*kind */ ); 153 154 typedef void (*PostValidateTreeProcPtr) (WindowPtr /*pParent */ , 155 WindowPtr /*pChild */ , 156 VTKind /*kind */ ); 157 158 typedef void (*WindowExposuresProcPtr) (WindowPtr /*pWindow */ , 159 RegionPtr /*prgn */); 160 161 typedef void (*PaintWindowProcPtr) (WindowPtr /*pWindow*/, 162 RegionPtr /*pRegion*/, 163 int /*what*/); 164 165 typedef void (*CopyWindowProcPtr) (WindowPtr /*pWindow */ , 166 DDXPointRec /*ptOldOrg */ , 167 RegionPtr /*prgnSrc */ ); 168 169 typedef void (*ClearToBackgroundProcPtr) (WindowPtr /*pWindow */ , 170 int /*x */ , 171 int /*y */ , 172 int /*w */ , 173 int /*h */ , 174 Bool /*generateExposures */ ); 175 176 typedef 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 189 typedef PixmapPtr (*CreatePixmapProcPtr) (ScreenPtr /*pScreen */ , 190 int /*width */ , 191 int /*height */ , 192 int /*depth */ , 193 unsigned /*usage_hint */ ); 194 195 typedef Bool (*DestroyPixmapProcPtr) (PixmapPtr /*pPixmap */ ); 196 197 typedef Bool (*RealizeFontProcPtr) (ScreenPtr /*pScreen */ , 198 FontPtr /*pFont */ ); 199 200 typedef Bool (*UnrealizeFontProcPtr) (ScreenPtr /*pScreen */ , 201 FontPtr /*pFont */ ); 202 203 typedef void (*ConstrainCursorProcPtr) (DeviceIntPtr /*pDev */ , 204 ScreenPtr /*pScreen */ , 205 BoxPtr /*pBox */ ); 206 207 typedef void (*CursorLimitsProcPtr) (DeviceIntPtr /* pDev */ , 208 ScreenPtr /*pScreen */ , 209 CursorPtr /*pCursor */ , 210 BoxPtr /*pHotBox */ , 211 BoxPtr /*pTopLeftBox */ ); 212 213 typedef Bool (*DisplayCursorProcPtr) (DeviceIntPtr /* pDev */ , 214 ScreenPtr /*pScreen */ , 215 CursorPtr /*pCursor */ ); 216 217 typedef Bool (*RealizeCursorProcPtr) (DeviceIntPtr /* pDev */ , 218 ScreenPtr /*pScreen */ , 219 CursorPtr /*pCursor */ ); 220 221 typedef Bool (*UnrealizeCursorProcPtr) (DeviceIntPtr /* pDev */ , 222 ScreenPtr /*pScreen */ , 223 CursorPtr /*pCursor */ ); 224 225 typedef void (*RecolorCursorProcPtr) (DeviceIntPtr /* pDev */ , 226 ScreenPtr /*pScreen */ , 227 CursorPtr /*pCursor */ , 228 Bool /*displayed */ ); 229 230 typedef Bool (*SetCursorPositionProcPtr) (DeviceIntPtr /* pDev */ , 231 ScreenPtr /*pScreen */ , 232 int /*x */ , 233 int /*y */ , 234 Bool /*generateEvent */ ); 235 236 typedef void (*CursorWarpedToProcPtr) (DeviceIntPtr /* pDev */ , 237 ScreenPtr /*pScreen */ , 238 ClientPtr /*pClient */ , 239 WindowPtr /*pWindow */ , 240 SpritePtr /*pSprite */ , 241 int /*x */ , 242 int /*y */ ); 243 244 typedef void (*CurserConfinedToProcPtr) (DeviceIntPtr /* pDev */ , 245 ScreenPtr /*pScreen */ , 246 WindowPtr /*pWindow */ ); 247 248 typedef Bool (*CreateGCProcPtr) (GCPtr /*pGC */ ); 249 250 typedef Bool (*CreateColormapProcPtr) (ColormapPtr /*pColormap */ ); 251 252 typedef void (*DestroyColormapProcPtr) (ColormapPtr /*pColormap */ ); 253 254 typedef void (*InstallColormapProcPtr) (ColormapPtr /*pColormap */ ); 255 256 typedef void (*UninstallColormapProcPtr) (ColormapPtr /*pColormap */ ); 257 258 typedef int (*ListInstalledColormapsProcPtr) (ScreenPtr /*pScreen */ , 259 XID * /*pmaps */ ); 260 261 typedef void (*StoreColorsProcPtr) (ColormapPtr /*pColormap */ , 262 int /*ndef */ , 263 xColorItem * /*pdef */ ); 264 265 typedef void (*ResolveColorProcPtr) (unsigned short * /*pred */ , 266 unsigned short * /*pgreen */ , 267 unsigned short * /*pblue */ , 268 VisualPtr /*pVisual */ ); 269 270 typedef RegionPtr (*BitmapToRegionProcPtr) (PixmapPtr /*pPix */ ); 271 272 typedef void (*ScreenBlockHandlerProcPtr) (ScreenPtr pScreen, 273 void *timeout); 274 275 /* result has three possible values: 276 * < 0 - error 277 * = 0 - timeout 278 * > 0 - activity 279 */ 280 typedef void (*ScreenWakeupHandlerProcPtr) (ScreenPtr pScreen, 281 int result); 282 283 typedef Bool (*CreateScreenResourcesProcPtr) (ScreenPtr /*pScreen */ ); 284 285 typedef Bool (*ModifyPixmapHeaderProcPtr) (PixmapPtr pPixmap, 286 int width, 287 int height, 288 int depth, 289 int bitsPerPixel, 290 int devKind, 291 void *pPixData); 292 293 typedef PixmapPtr (*GetWindowPixmapProcPtr) (WindowPtr /*pWin */ ); 294 295 typedef void (*SetWindowPixmapProcPtr) (WindowPtr /*pWin */ , 296 PixmapPtr /*pPix */ ); 297 298 typedef PixmapPtr (*GetScreenPixmapProcPtr) (ScreenPtr /*pScreen */ ); 299 300 typedef void (*SetScreenPixmapProcPtr) (PixmapPtr /*pPix */ ); 301 302 typedef void (*MarkWindowProcPtr) (WindowPtr /*pWin */ ); 303 304 typedef Bool (*MarkOverlappedWindowsProcPtr) (WindowPtr /*parent */ , 305 WindowPtr /*firstChild */ , 306 WindowPtr * /*pLayerWin */ ); 307 308 typedef int (*ConfigNotifyProcPtr) (WindowPtr /*pWin */ , 309 int /*x */ , 310 int /*y */ , 311 int /*w */ , 312 int /*h */ , 313 int /*bw */ , 314 WindowPtr /*pSib */ ); 315 316 typedef void (*MoveWindowProcPtr) (WindowPtr /*pWin */ , 317 int /*x */ , 318 int /*y */ , 319 WindowPtr /*pSib */ , 320 VTKind /*kind */ ); 321 322 typedef void (*ResizeWindowProcPtr) (WindowPtr /*pWin */ , 323 int /*x */ , 324 int /*y */ , 325 unsigned int /*w */ , 326 unsigned int /*h */ , 327 WindowPtr /*pSib */ 328 ); 329 330 typedef WindowPtr (*GetLayerWindowProcPtr) (WindowPtr /*pWin */ 331 ); 332 333 typedef void (*HandleExposuresProcPtr) (WindowPtr /*pWin */ ); 334 335 typedef void (*ReparentWindowProcPtr) (WindowPtr /*pWin */ , 336 WindowPtr /*pPriorParent */ ); 337 338 typedef void (*SetShapeProcPtr) (WindowPtr /*pWin */ , 339 int /* kind */ ); 340 341 typedef void (*ChangeBorderWidthProcPtr) (WindowPtr /*pWin */ , 342 unsigned int /*width */ ); 343 344 typedef void (*MarkUnrealizedWindowProcPtr) (WindowPtr /*pChild */ , 345 WindowPtr /*pWin */ , 346 Bool /*fromConfigure */ ); 347 348 typedef Bool (*DeviceCursorInitializeProcPtr) (DeviceIntPtr /* pDev */ , 349 ScreenPtr /* pScreen */ ); 350 351 typedef void (*DeviceCursorCleanupProcPtr) (DeviceIntPtr /* pDev */ , 352 ScreenPtr /* pScreen */ ); 353 354 typedef void (*ConstrainCursorHarderProcPtr) (DeviceIntPtr, ScreenPtr, int, 355 int *, int *); 356 357 358 typedef Bool (*SharePixmapBackingProcPtr)(PixmapPtr, ScreenPtr, void **); 359 360 typedef 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 */ 378 typedef void (*SyncSharedPixmapProcPtr)(PixmapDirtyUpdatePtr); 379 380 typedef Bool (*StartPixmapTrackingProcPtr)(DrawablePtr, PixmapPtr, 381 int x, int y, 382 int dst_x, int dst_y, 383 Rotation rotation); 384 385 typedef Bool (*PresentSharedPixmapProcPtr)(PixmapPtr); 386 387 typedef Bool (*RequestSharedPixmapNotifyDamageProcPtr)(PixmapPtr); 388 389 typedef Bool (*StopPixmapTrackingProcPtr)(DrawablePtr, PixmapPtr); 390 391 typedef Bool (*StopFlippingPixmapTrackingProcPtr)(DrawablePtr, 392 PixmapPtr, PixmapPtr); 393 394 typedef Bool (*SharedPixmapNotifyDamageProcPtr)(PixmapPtr); 395 396 typedef Bool (*ReplaceScanoutPixmapProcPtr)(DrawablePtr, PixmapPtr, Bool); 397 398 typedef WindowPtr (*XYToWindowProcPtr)(ScreenPtr pScreen, 399 SpritePtr pSprite, int x, int y); 400 401 typedef int (*NameWindowPixmapProcPtr)(WindowPtr, PixmapPtr, CARD32); 402 403 typedef 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 495 typedef 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 665 static inline RegionPtr 666 BitmapToRegion(ScreenPtr _pScreen, PixmapPtr pPix) 667 { 668 return (*(_pScreen)->BitmapToRegion) (pPix); /* no mi version?! */ 669 } 670 671 typedef 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 688 extern _X_EXPORT ScreenInfo screenInfo; 689 690 extern _X_EXPORT void InitOutput(ScreenInfo * /*pScreenInfo */ , 691 int /*argc */ , 692 char ** /*argv */ ); 693 694 #endif /* SCREENINTSTRUCT_H */