layerutil.c
上传用户:xk288cn
上传日期:2007-05-28
资源大小:4876k
文件大小:6k
源码类别:

GIS编程

开发平台:

Visual C++

  1. /* Copyright (c) Mark J. Kilgard, 1993, 1994. */
  2. /* This program is freely distributable without licensing fees
  3.    and is provided without guarantee or warrantee expressed or
  4.    implied. This program is -not- in the public domain. */
  5. /* Based on XLayerUtil.c: Revision: 1.5 */
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include "layerutil.h"
  9. /* SGI optimization introduced in IRIX 6.3 to avoid X server
  10.    round trips for interning common X atoms. */
  11. #include <X11/Xatom.h>
  12. #if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
  13. #include <X11/SGIFastAtom.h>
  14. #else
  15. #define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
  16. #endif
  17. static Bool layersRead = False;
  18. static OverlayInfo **overlayInfoPerScreen;
  19. static unsigned long *numOverlaysPerScreen;
  20. static void
  21. findServerOverlayVisualsInfo(Display * dpy)
  22. {
  23.   static Atom overlayVisualsAtom;
  24.   Atom actualType;
  25.   Status status;
  26.   unsigned long sizeData, bytesLeft;
  27.   Window root;
  28.   int actualFormat, numScreens, i;
  29.   if (layersRead == False) {
  30.     overlayVisualsAtom = XSGIFastInternAtom(dpy,
  31.       "SERVER_OVERLAY_VISUALS", SGI_XA_SERVER_OVERLAY_VISUALS, True);
  32.     if (overlayVisualsAtom != None) {
  33.       numScreens = ScreenCount(dpy);
  34.       overlayInfoPerScreen = (OverlayInfo **)
  35.         malloc(numScreens * sizeof(OverlayInfo *));
  36.       numOverlaysPerScreen = (unsigned long *)
  37.         malloc(numScreens * sizeof(unsigned long));
  38.       if (overlayInfoPerScreen != NULL &&
  39.         numOverlaysPerScreen != NULL) {
  40.         for (i = 0; i < numScreens; i++) {
  41.           root = RootWindow(dpy, i);
  42.           status = XGetWindowProperty(dpy, root,
  43.             overlayVisualsAtom, 0L, (long) 10000, False,
  44.             overlayVisualsAtom, &actualType, &actualFormat,
  45.             &sizeData, &bytesLeft,
  46.             (unsigned char **) &overlayInfoPerScreen[i]);
  47.           if (status != Success ||
  48.             actualType != overlayVisualsAtom ||
  49.             actualFormat != 32 || sizeData < 4)
  50.             numOverlaysPerScreen[i] = 0;
  51.           else
  52.             /* Four 32-bit quantities per
  53.                SERVER_OVERLAY_VISUALS entry. */
  54.             numOverlaysPerScreen[i] = sizeData / 4;
  55.         }
  56.         layersRead = True;
  57.       } else {
  58.         if (overlayInfoPerScreen != NULL)
  59.           free(overlayInfoPerScreen);
  60.         if (numOverlaysPerScreen != NULL)
  61.           free(numOverlaysPerScreen);
  62.       }
  63.     }
  64.   }
  65. }
  66. int
  67. __glutGetTransparentPixel(Display * dpy, XVisualInfo * vinfo)
  68. {
  69.   int i, screen = vinfo->screen;
  70.   OverlayInfo *overlayInfo;
  71.   findServerOverlayVisualsInfo(dpy);
  72.   if (layersRead) {
  73.     for (i = 0; i < numOverlaysPerScreen[screen]; i++) {
  74.       overlayInfo = &overlayInfoPerScreen[screen][i];
  75.       if (vinfo->visualid == overlayInfo->overlay_visual) {
  76.         if (overlayInfo->transparent_type == TransparentPixel) {
  77.           return (int) overlayInfo->value;
  78.         } else {
  79.           return -1;
  80.         }
  81.       }
  82.     }
  83.   }
  84.   return -1;
  85. }
  86. XLayerVisualInfo *
  87. __glutXGetLayerVisualInfo(Display * dpy, long lvinfo_mask,
  88.   XLayerVisualInfo * lvinfo_template, int *nitems_return)
  89. {
  90.   XVisualInfo *vinfo;
  91.   XLayerVisualInfo *layerInfo;
  92.   int numVisuals, count, i, j;
  93.   vinfo = XGetVisualInfo(dpy, lvinfo_mask & VisualAllMask,
  94.     &lvinfo_template->vinfo, nitems_return);
  95.   if (vinfo == NULL)
  96.     return NULL;
  97.   numVisuals = *nitems_return;
  98.   findServerOverlayVisualsInfo(dpy);
  99.   layerInfo = (XLayerVisualInfo *)
  100.     malloc(numVisuals * sizeof(XLayerVisualInfo));
  101.   if (layerInfo == NULL) {
  102.     XFree(vinfo);
  103.     return NULL;
  104.   }
  105.   count = 0;
  106.   for (i = 0; i < numVisuals; i++) {
  107.     XVisualInfo *pVinfo = &vinfo[i];
  108.     int screen = pVinfo->screen;
  109.     OverlayInfo *overlayInfo = NULL;
  110.     overlayInfo = NULL;
  111.     if (layersRead) {
  112.       for (j = 0; j < numOverlaysPerScreen[screen]; j++)
  113.         if (pVinfo->visualid ==
  114.           overlayInfoPerScreen[screen][j].overlay_visual) {
  115.           overlayInfo = &overlayInfoPerScreen[screen][j];
  116.           break;
  117.         }
  118.     }
  119.     if (lvinfo_mask & VisualLayerMask)
  120.       if (overlayInfo == NULL) {
  121.         if (lvinfo_template->layer != 0)
  122.           continue;
  123.       } else if (lvinfo_template->layer != overlayInfo->layer)
  124.         continue;
  125.     if (lvinfo_mask & VisualTransparentType)
  126.       if (overlayInfo == NULL) {
  127.         if (lvinfo_template->type != None)
  128.           continue;
  129.       } else if (lvinfo_template->type !=
  130.         overlayInfo->transparent_type)
  131.         continue;
  132.     if (lvinfo_mask & VisualTransparentValue)
  133.       if (overlayInfo == NULL)
  134.         /* Non-overlay visuals have no sense of
  135.            TransparentValue. */
  136.         continue;
  137.       else if (lvinfo_template->value != overlayInfo->value)
  138.         continue;
  139.     layerInfo[count].vinfo = *pVinfo;
  140.     if (overlayInfo == NULL) {
  141.       layerInfo[count].layer = 0;
  142.       layerInfo[count].type = None;
  143.       layerInfo[count].value = 0;  /* meaningless */
  144.     } else {
  145.       layerInfo[count].layer = overlayInfo->layer;
  146.       layerInfo[count].type = overlayInfo->transparent_type;
  147.       layerInfo[count].value = overlayInfo->value;
  148.     }
  149.     count++;
  150.   }
  151.   XFree(vinfo);
  152.   *nitems_return = count;
  153.   if (count == 0) {
  154.     XFree(layerInfo);
  155.     return NULL;
  156.   } else
  157.     return layerInfo;
  158. }
  159. #if 0                   /* Unused by GLUT. */
  160. Status
  161. __glutXMatchLayerVisualInfo(Display * dpy, int screen,
  162.   int depth, int visualClass, int layer,
  163.   XLayerVisualInfo * lvinfo_return)
  164. {
  165.   XLayerVisualInfo *lvinfo;
  166.   XLayerVisualInfo lvinfoTemplate;
  167.   int nitems;
  168.   lvinfoTemplate.vinfo.screen = screen;
  169.   lvinfoTemplate.vinfo.depth = depth;
  170. #if defined(__cplusplus) || defined(c_plusplus)
  171.   lvinfoTemplate.vinfo.c_class = visualClass;
  172. #else
  173.   lvinfoTemplate.vinfo.class = visualClass;
  174. #endif
  175.   lvinfoTemplate.layer = layer;
  176.   lvinfo = __glutXGetLayerVisualInfo(dpy,
  177.     VisualScreenMask | VisualDepthMask |
  178.     VisualClassMask | VisualLayerMask,
  179.     &lvinfoTemplate, &nitems);
  180.   if (lvinfo != NULL && nitems > 0) {
  181.     *lvinfo_return = *lvinfo;
  182.     return 1;
  183.   } else
  184.     return 0;
  185. }
  186. #endif