home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / System / Mesa-3.1 / Mesa-glut / test / glut / test18.c < prev    next >
C/C++ Source or Header  |  1998-10-23  |  4KB  |  206 lines
  1.  
  2. /* Copyright (c) Mark J. Kilgard, 1996. */
  3.  
  4. /* This program is freely distributable without licensing fees 
  5.    and is provided without guarantee or warrantee expressed or 
  6.    implied. This program is -not- in the public domain. */
  7.  
  8. /* Test display callbacks are not called for non-viewable
  9.    windows and overlays. */
  10.  
  11. #include <stdlib.h>
  12. #include <stdio.h>
  13. #include <GL/glut.h>
  14.  
  15. int transP, opaqueP;
  16. int main_win, sub_win;
  17. int overlaySupported;
  18. int subHidden, overlayHidden;
  19. int warnIfNormalDisplay = 0;
  20. int firstTime = 1;
  21.  
  22. void
  23. time5_cb(int value)
  24. {
  25.   if (value != -3) {
  26.     printf("ERROR: test18\n");
  27.     exit(1);
  28.   }
  29.   printf("PASS: test18\n");
  30.   exit(0);
  31. }
  32.  
  33. void
  34. time4_cb(int value)
  35. {
  36.   if (value != -6) {
  37.     printf("ERROR: test18\n");
  38.     exit(1);
  39.   }
  40.   warnIfNormalDisplay = 0;
  41.   glutTimerFunc(750, time5_cb, -3);
  42.   glutSetWindow(sub_win);
  43.   glutPostRedisplay();
  44.   glutSetWindow(main_win);
  45.   if (overlaySupported) {
  46.     glutPostOverlayRedisplay();
  47.   }
  48. }
  49.  
  50. void
  51. time3_cb(int value)
  52. {
  53.   if (value != 6) {
  54.     printf("ERROR: test18\n");
  55.     exit(1);
  56.   }
  57.   glutSetWindow(main_win);
  58.   glutHideOverlay();
  59.   overlayHidden = 1;
  60.   warnIfNormalDisplay = 1;
  61.   glutTimerFunc(500, time4_cb, -6);
  62. }
  63.  
  64. void
  65. time2_cb(int value)
  66. {
  67.   if (value != 56) {
  68.     printf("ERROR: test18\n");
  69.     exit(1);
  70.   }
  71.   glutSetWindow(main_win);
  72.   if (overlaySupported) {
  73.     glutShowOverlay();
  74.     overlayHidden = 0;
  75.   }
  76.   glutSetWindow(sub_win);
  77.   glutHideWindow();
  78.   subHidden = 1;
  79.   glutTimerFunc(500, time3_cb, 6);
  80. }
  81.  
  82. void
  83. time_cb(int value)
  84. {
  85.   if (value != 456) {
  86.     printf("ERROR: test18\n");
  87.     exit(1);
  88.   }
  89.   glutSetWindow(sub_win);
  90.   subHidden = 0;
  91.   glutShowWindow();
  92.   glutTimerFunc(500, time2_cb, 56);
  93. }
  94.  
  95. void
  96. display(void)
  97. {
  98.   if (warnIfNormalDisplay) {
  99.     printf("WARNING: hiding overlay should not generate normal plane expose!\n");
  100.     printf("does overlay operation work correctly?\n");
  101.   }
  102.   if (glutLayerGet(GLUT_LAYER_IN_USE) != GLUT_NORMAL) {
  103.     printf("ERROR: test18\n");
  104.     exit(1);
  105.   }
  106.   glClear(GL_COLOR_BUFFER_BIT);
  107.   glFlush();
  108.   if (firstTime) {
  109.     glutTimerFunc(500, time_cb, 456);
  110.     firstTime = 0;
  111.   }
  112. }
  113.  
  114. void
  115. subDisplay(void)
  116. {
  117.   if (glutLayerGet(GLUT_LAYER_IN_USE) != GLUT_NORMAL) {
  118.     printf("ERROR: test18\n");
  119.     exit(1);
  120.   }
  121.   if (subHidden) {
  122.     printf("display callback generated when subwindow was hidden!\n");
  123.     printf("ERROR: test18\n");
  124.     exit(1);
  125.   }
  126.   glClear(GL_COLOR_BUFFER_BIT);
  127.   glFlush();
  128. }
  129.  
  130. void
  131. overDisplay(void)
  132. {
  133.   if (glutLayerGet(GLUT_LAYER_IN_USE) != GLUT_OVERLAY) {
  134.     printf("ERROR: test18\n");
  135.     exit(1);
  136.   }
  137.   if (overlayHidden) {
  138.     printf("display callback generated when overlay was hidden!\n");
  139.     printf("ERROR: test18\n");
  140.     exit(1);
  141.   }
  142.   glClear(GL_COLOR_BUFFER_BIT);
  143.   glFlush();
  144. }
  145.  
  146. void
  147. subVis(int state)
  148. {
  149.   if (glutLayerGet(GLUT_LAYER_IN_USE) != GLUT_NORMAL) {
  150.     printf("ERROR: test18\n");
  151.     exit(1);
  152.   }
  153.   if (subHidden && state == GLUT_VISIBLE) {
  154.     printf("visible callback generated when overlay was hidden!\n");
  155.     printf("ERROR: test18\n");
  156.     exit(1);
  157.   }
  158.   if (!subHidden && state == GLUT_NOT_VISIBLE) {
  159.     printf("non-visible callback generated when overlay was shown!\n");
  160.     printf("ERROR: test18\n");
  161.     exit(1);
  162.   }
  163. }
  164.  
  165. int
  166. main(int argc, char **argv)
  167. {
  168.   glutInit(&argc, argv);
  169.   glutInitWindowSize(300, 300);
  170.   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
  171.  
  172.   main_win = glutCreateWindow("test18");
  173.  
  174.   if (glutGet(GLUT_WINDOW_COLORMAP_SIZE) != 0) {
  175.     printf("RGBA color model windows should report zero colormap entries.\n");
  176.     printf("ERROR: test18\n");
  177.     exit(1);
  178.   }
  179.  
  180.   glutInitDisplayMode(GLUT_SINGLE | GLUT_INDEX);
  181.   glutDisplayFunc(display);
  182.  
  183.   overlaySupported = glutLayerGet(GLUT_OVERLAY_POSSIBLE);
  184.   if (overlaySupported) {
  185.     glutEstablishOverlay();
  186.     glutHideOverlay();
  187.     overlayHidden = 1;
  188.     glutOverlayDisplayFunc(overDisplay);
  189.     transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
  190.     glClearIndex(glutLayerGet(GLUT_TRANSPARENT_INDEX));
  191.     opaqueP = (transP + 1) % glutGet(GLUT_WINDOW_COLORMAP_SIZE);
  192.     glutSetColor(opaqueP, 1.0, 0.0, 1.0);
  193.     glClearIndex(opaqueP);
  194.   }
  195.   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
  196.   sub_win = glutCreateSubWindow(main_win, 10, 10, 20, 20);
  197.   glClearColor(0.0, 1.0, 0.0, 0.0);
  198.   glutDisplayFunc(subDisplay);
  199.   glutVisibilityFunc(subVis);
  200.   glutHideWindow();
  201.   subHidden = 1;
  202.  
  203.   glutMainLoop();
  204.   return 0;             /* ANSI C requires main to return int. */
  205. }
  206.