1 /* 2 * Copyright (c) 1999, 2018, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 /** ------------------------------------------------------------------------ 26 This file contains routines for manipulating generic lists. 27 Lists are implemented with a "harness". In other words, each 28 node in the list consists of two pointers, one to the data item 29 and one to the next node in the list. The head of the list is 30 the same struct as each node, but the "item" ptr is used to point 31 to the current member of the list (used by the first_in_list and 32 next_in_list functions). 33 34 This file is available under and governed by the GNU General Public 35 License version 2 only, as published by the Free Software Foundation. 36 However, the following notice accompanied the original version of this 37 file: 38 39 Copyright 1994 Hewlett-Packard Co. 40 Copyright 1996, 1998 The Open Group 41 42 Permission to use, copy, modify, distribute, and sell this software and its 43 documentation for any purpose is hereby granted without fee, provided that 44 the above copyright notice appear in all copies and that both that 45 copyright notice and this permission notice appear in supporting 46 documentation. 47 48 The above copyright notice and this permission notice shall be included 49 in all copies or substantial portions of the Software. 50 51 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 52 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 53 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 54 IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR 55 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 56 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 57 OTHER DEALINGS IN THE SOFTWARE. 58 59 Except as contained in this notice, the name of The Open Group shall 60 not be used in advertising or otherwise to promote the sale, use or 61 other dealings in this Software without prior written authorization 62 from The Open Group. 63 64 ------------------------------------------------------------------------ **/ 65 66 /****************************************************************************** 67 * 68 * This file contains various typedef's, macros and procedure declarations for 69 * a set of example utility procedures contained in the file "wsutils.c". 70 * 71 ******************************************************************************/ 72 73 typedef unsigned long Pixel; 74 75 /* This is the actual structure returned by the X server describing the 76 * SERVER_OVERLAY_VISUAL property. 77 */ 78 typedef struct 79 { 80 VisualID visualID; /* The VisualID of the overlay visual */ 81 int transparentType; /* Can be None, TransparentPixel or 82 * TransparentMask */ 83 Pixel value; /* Pixel value */ 84 int layer; /* Overlay planes will always be in 85 * layer 1 */ 86 } OverlayVisualPropertyRec; 87 88 89 /* This is structure also describes the SERVER_OVERLAY_VISUAL property, but 90 * should be more useful than the one actually returned by the X server 91 * because it actually points to the visual's XVisualInfo struct rather than 92 * refering to the visual's ID. 93 */ 94 typedef struct 95 { 96 XVisualInfo *pOverlayVisualInfo; /* Pointer to the XVisualInfo struct */ 97 int transparentType; /* Can be None, TransparentPixel or 98 * TransparentMask */ 99 Pixel value; /* Pixel value */ 100 int layer; /* Overlay planes will always be in 101 * layer 1 */ 102 } OverlayInfo; 103 104 105 /* These macros are the values of the "transparentType" above: */ 106 #ifndef None 107 #define None 0 108 #endif 109 #ifndef TransparentPixel 110 #define TransparentPixel 1 111 #endif 112 113 114 /* These macros define how flexible a program is when it requests a window's 115 * creation with either the CreateImagePlanesWindow() or 116 * CreateOverlayPlanesWindow(): 117 */ 118 #ifndef NOT_FLEXIBLE 119 #define NOT_FLEXIBLE 0 120 #define FLEXIBLE 1 121 #endif 122 123 124 /* These macros define the values of the "sbCmapHint" parameter of the 125 * CreateImagePlanesWindow(): 126 */ 127 #ifndef SB_CMAP_TYPE_NORMAL 128 #define SB_CMAP_TYPE_NORMAL 1 129 #endif 130 131 #ifndef SB_CMAP_TYPE_MONOTONIC 132 #define SB_CMAP_TYPE_MONOTONIC 2 133 #endif 134 135 #ifndef SB_CMAP_TYPE_FULL 136 #define SB_CMAP_TYPE_FULL 4 137 #endif 138 139 140 /****************************************************************************** 141 * 142 * GetXVisualInfo() 143 * 144 * This routine takes an X11 Display, screen number, and returns whether the 145 * screen supports transparent overlays and three arrays: 146 * 147 * 1) All of the XVisualInfo struct's for the screen. 148 * 2) All of the OverlayInfo struct's for the screen. 149 * 3) An array of pointers to the screen's image plane XVisualInfo 150 * structs. 151 * 152 * The code below obtains the array of all the screen's visuals, and obtains 153 * the array of all the screen's overlay visual information. It then processes 154 * the array of the screen's visuals, determining whether the visual is an 155 * overlay or image visual. 156 * 157 * If the routine sucessfully obtained the visual information, it returns zero. 158 * If the routine didn't obtain the visual information, it returns non-zero. 159 * 160 ******************************************************************************/ 161 162 extern int GetXVisualInfo( 163 Display *display, /* Which X server (aka "display"). */ 164 int screen, /* Which screen of the "display". */ 165 int *transparentOverlays, /* Non-zero if there's at least one 166 * overlay visual and if at least one 167 * of those supports a transparent 168 * pixel. */ 169 int *numVisuals, /* Number of XVisualInfo struct's 170 * pointed to to by pVisuals. */ 171 XVisualInfo **pVisuals, /* All of the device's visuals. */ 172 int *numOverlayVisuals, /* Number of OverlayInfo's pointed 173 * to by pOverlayVisuals. If this 174 * number is zero, the device does 175 * not have overlay planes. */ 176 OverlayInfo **pOverlayVisuals, /* The device's overlay plane visual 177 * information. */ 178 int *numImageVisuals, /* Number of XVisualInfo's pointed 179 * to by pImageVisuals. */ 180 XVisualInfo ***pImageVisuals /* The device's image visuals. */ 181 ); 182 183 184 /****************************************************************************** 185 * 186 * FreeXVisualInfo() 187 * 188 * This routine frees the data that was allocated by GetXVisualInfo(). 189 * 190 ******************************************************************************/ 191 192 extern void FreeXVisualInfo( 193 XVisualInfo *pVisuals, 194 OverlayInfo *pOverlayVisuals, 195 XVisualInfo **pImageVisuals 196 ); 197 198 199 /****************************************************************************** 200 * 201 * FindImagePlanesVisual() 202 * 203 * This routine attempts to find a visual to use to create an image planes 204 * window based upon the information passed in. 205 * 206 * The "Hint" values give guides to the routine as to what the program wants. 207 * The "depthFlexibility" value tells the routine how much the program wants 208 * the actual "depthHint" specified. If the program can't live with the 209 * screen's image planes visuals, the routine returns non-zero, and the 210 * "depthObtained" and "pImageVisualToUse" return parameters are NOT valid. 211 * Otherwise, the "depthObtained" and "pImageVisualToUse" return parameters 212 * are valid and the routine returns zero. 213 * 214 * NOTE: This is just an example of what can be done. It may or may not be 215 * useful for any specific application. 216 * 217 ******************************************************************************/ 218 219 extern int FindImagePlanesVisual( 220 Display *display, /* Which X server (aka "display"). */ 221 int screen, /* Which screen of the "display". */ 222 int numImageVisuals, /* Number of XVisualInfo's pointed 223 * to by pImageVisuals. */ 224 XVisualInfo **pImageVisuals, /* The device's image visuals. */ 225 int sbCmapHint, /* What Starbase cmap modes will be 226 * used with the visual. NOTE: This 227 * is a mask of the possible values. */ 228 int depthHint, /* Desired depth. */ 229 int depthFlexibility, /* How much the actual value in 230 * "depthHint" is desired. */ 231 Visual **pImageVisualToUse, /* The screen's image visual to use. */ 232 int *depthObtained /* Actual depth of the visual. */ 233 ); 234 235 236 /****************************************************************************** 237 * 238 * FindOverlayPlanesVisual() 239 * 240 * This routine attempts to find a visual to use to create an overlay planes 241 * window based upon the information passed in. 242 * 243 * While the CreateImagePlanesWindow() routine took a sbCmapHint, this 244 * routine doesn't. Starbase's CMAP_FULL shouldn't be used in overlay planes 245 * windows. This is partially because this functionality is better suited in 246 * the image planes where there are generally more planes, and partially 247 * because the overlay planes generally have PseudoColor visuals with one 248 * color being transparent (the transparent normally being the "white" color 249 * for CMAP_FULL). 250 * 251 * The "depthHint" values give guides to the routine as to what depth the 252 * program wants the window to be. The "depthFlexibility" value tells the 253 * routine how much the program wants the actual "depthHint" specified. If 254 * the program can't live with the screen's overlay planes visuals, the 255 * routine returns non-zero, and the "depthObtained" and "pOverlayVisualToUse" 256 * return parameters are NOT valid. Otherwise, the "depthObtained" and 257 * "pOverlayVisualToUse" return parameters are valid and the routine returns 258 * zero. 259 * 260 * NOTE: This is just an example of what can be done. It may or may not be 261 * useful for any specific application. 262 * 263 ******************************************************************************/ 264 265 extern int FindOverlayPlanesVisual( 266 Display *display, /* Which X server (aka "display"). */ 267 int screen, /* Which screen of the "display". */ 268 int numOverlayVisuals, /* Number of OverlayInfo's pointed 269 * to by pOverlayVisuals. */ 270 OverlayInfo *pOverlayVisuals, /* The device's overlay plane visual 271 * information. */ 272 int depthHint, /* Desired depth. */ 273 int depthFlexibility, /* How much the actual value in 274 * "depthHint" is desired. */ 275 int transparentBackground, /* Non-zero if the visual must have 276 * a transparent color. */ 277 Visual **pOverlayVisualToUse, /* The screen's overlay visual to 278 * use. */ 279 int *depthObtained, /* Actual depth of the visual. */ 280 int *transparentColor /* The transparent color the program 281 * can use with the visual. */ 282 ); 283 284 285 /****************************************************************************** 286 * 287 * CreateImagePlanesWindow() 288 * 289 * This routine creates an image planes window, potentially creates a colormap 290 * for the window to use, and sets the window's standard properties, based 291 * upon the information passed in to the routine. While "created," the window 292 * has not been mapped. 293 * 294 * If the routine suceeds, it returns zero and the return parameters 295 * "imageWindow", "imageColormap" and "mustFreeImageColormap" are valid. 296 * Otherwise, the routine returns non-zero and the return parameters are 297 * NOT valid. 298 * 299 * NOTE: This is just an example of what can be done. It may or may not be 300 * useful for any specific application. 301 * 302 ******************************************************************************/ 303 304 extern int CreateImagePlanesWindow( 305 Display *display, /* Which X server (aka "display"). */ 306 int screen, /* Which screen of the "display". */ 307 Window parentWindow, /* Window ID of the parent window for 308 * the created window. */ 309 int windowX, /* Desired X coord. of the window. */ 310 int windowY, /* Desired Y coord of the window. */ 311 int windowWidth, /* Desired width of the window. */ 312 int windowHeight, /* Desired height of the window. */ 313 int windowDepth, /* Desired depth of the window. */ 314 Visual *pImageVisualToUse, /* The window's image planes visual. */ 315 int argc, /* Program's argc parameter. */ 316 char *argv[], /* Program's argv parameter. */ 317 char *windowName, /* Name to put on window's border. */ 318 char *iconName, /* Name to put on window's icon. */ 319 Window *imageWindow, /* Window ID of the created window. */ 320 Colormap *imageColormap, /* The window's colormap. */ 321 int *mustFreeImageColormap /* Non-zero if the program must call 322 * XFreeColormap() for imageColormap. */ 323 ); 324 325 326 /****************************************************************************** 327 * 328 * CreateOverlayPlanesWindow() 329 * 330 * This routine creates an overlay planes window, potentially creates a colormap 331 * for the window to use, and sets the window's standard properties, based 332 * upon the information passed in to the routine. While "created," the window 333 * has not been mapped. 334 * 335 * If the routine suceeds, it returns zero and the return parameters 336 * "overlayWindow", "overlayColormap" and "mustFreeOverlayColormap" are valid. 337 * Otherwise, the routine returns non-zero and the return parameters are 338 * NOT valid. 339 * 340 * NOTE: This is just an example of what can be done. It may or may not be 341 * useful for any specific application. 342 * 343 ******************************************************************************/ 344 345 int CreateOverlayPlanesWindow( 346 Display *display, /* Which X server (aka "display"). */ 347 int screen, /* Which screen of the "display". */ 348 Window parentWindow, /* Window ID of the parent window for 349 * the created window. */ 350 int windowX, /* Desired X coord. of the window. */ 351 int windowY, /* Desired Y coord of the window. */ 352 int windowWidth, /* Desired width of the window. */ 353 int windowHeight, /* Desired height of the window. */ 354 int windowDepth, /* Desired depth of the window. */ 355 Visual *pOverlayVisualToUse, /* The window's overlay planes visual.*/ 356 int argc, /* Program's argc parameter. */ 357 char *argv[], /* Program's argv parameter. */ 358 char *windowName, /* Name to put on window's border. */ 359 char *iconName, /* Name to put on window's icon. */ 360 int transparentBackground, /* Non-zero if the window's background 361 * should be a transparent color. */ 362 int *transparentColor, /* The transparent color to use as the 363 * window's background. */ 364 Window *overlayWindow, /* Window ID of the created window. */ 365 Colormap *overlayColormap, /* The window's colormap. */ 366 int *mustFreeOverlayColormap/* Non-zero if the program must call 367 * XFreeColormap() for 368 * overlayColormap. */ 369 ); 370