开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
glui.c
资源名称：glut23-src.zip　[点击查看]
上传用户：xk288cn
上传日期：2007-05-28
资源大小：4876k
文件大小：14k
源码类别：

GIS编程

开发平台：

Visual C++

glui.c：源码内容
  2. /*
  3.   glui.c
  4.   Nate Robins, 1997.
  6.   OpenGL based user interface.
  8.  */
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <GL/glut.h>
  14. #define GLUI_BORDER  3
  15. #define GLUI_KNOB   40
  17. #define GLUI_RAISED  1
  18. #define GLUI_SUNKEN  0
  20. #define GLUI_HORIZONTAL 0
  21. #define GLUI_VERTICAL   1
  23. #define GLUI_LESS -1
  24. #define GLUI_HIT   0
  25. #define GLUI_MORE  1
  27. #define GLUI_HILITE 0.15
  29. typedef struct _GLUIslider {
  30.     int type; /* vertical/horizontal */
  31.     int parent; /* parent of this slider */
  32.     int window; /* this sliders window */
  33.     int win_x; /* slider window x (parent relative) */
  34.     int win_y; /* slider window y (parent relative) */
  35.     int win_w; /* slider window width */
  36.     int win_h; /* slider window height */
  37.     int length; /* length of the slider in pixels */
  38.     int knob; /* position of the knob in pixels */
  39.     int lit; /* currently lit? */
  40.     void (*update)(float); /* callback for updating (returns %) */
  41.     struct _GLUIslider* next;
  42. } GLUIslider;
  44. static GLUIslider* _gluiSliders = NULL;
  45. static GLUIslider* _gluiHit = NULL;
  47. static GLUIslider*
  48. _gluiCurrentSlider(void)
  49. {
  50.     GLUIslider* slider = _gluiSliders;
  51.     int window = glutGetWindow();
  53.     while(slider) {
  54. if (slider->window == window)
  55.     break;
  56. slider = slider->next;
  57.     }
  59.     if (!slider)
  60. printf("glui: _gluiCurrentSlider() failed!n");
  62.     return slider;
  63. }
  65. static void
  66. _gluiEmboss(int raised, int lit, int x, int y, int width, int height)
  67. {
  68.     int i;
  69.     float c;
  71.     for (i = 0; i < GLUI_BORDER; i++) {
  72. c = (float)i / (GLUI_BORDER * 5) + (lit ? GLUI_HILITE : 0.0);
  73. if (raised)
  74.     glColor3f(0.275+c, 0.2+c, 0.2+c);
  75. else
  76.     glColor3f(0.875-c, 0.8-c, 0.8-c);
  77. glBegin(GL_LINE_STRIP);
  78. glVertex2f(x+i+1, y+i);
  79. glVertex2f(x+width-i-1, y+i);
  80. glVertex2f(x+width-i-1, y+height-i);
  81. glEnd();
  82.     }
  84.     for (i = 0; i < GLUI_BORDER; i++) {
  85. c = (float)i / (GLUI_BORDER * 5);
  86. if (raised)
  87.     glColor3f(0.875-c, 0.8-c, 0.8-c);
  88. else
  89.     glColor3f(0.275+c, 0.2+c, 0.2+c);
  90. glBegin(GL_LINE_STRIP);
  91. glVertex2f(x+i, y+i);
  92. glVertex2f(x+i, y+height-i-1);
  93. glVertex2f(x+width-i-1, y+height-i-1);
  94. glEnd();
  95.     }
  97.     c = lit ? GLUI_HILITE : 0.0;
  99.     if (raised)
  100. glColor3f(0.575+c, 0.5+c, 0.5+c);
  101.     else
  102. glColor3f(0.475+c, 0.3+c, 0.3+c);
  103.     glRectf(x+i, y+i, x+width-i, y+height-i);
  104. }
  106. static void
  107. _gluiDisplay(void)
  108. {
  109.     int lit;
  110.     GLUIslider* slider = _gluiCurrentSlider();
  112.     lit = slider->lit ? GLUI_HILITE : 0.0;
  114.     glClear(GL_COLOR_BUFFER_BIT);
  115.     if (slider->type == GLUI_HORIZONTAL) {
  116. _gluiEmboss(GLUI_SUNKEN, 0, /* never lit */
  117.     0, 0, slider->length, slider->win_h);
  118. _gluiEmboss(GLUI_RAISED, slider->lit, 
  119.     slider->knob - GLUI_KNOB/2, GLUI_BORDER,
  120.     GLUI_KNOB + GLUI_BORDER, slider->win_h - GLUI_BORDER*2);
  121. /* XXX why is it GLUI_KNOB+GLUI_BORDER ? */
  122. glColor3f(0.975+lit, 0.9+lit, 0.9+lit);
  123. glBegin(GL_LINES);
  124. glVertex2f(slider->knob-2, GLUI_BORDER*2-1);
  125. glVertex2f(slider->knob-2, slider->win_h-GLUI_BORDER*2+1);
  126. glVertex2f(slider->knob+1, GLUI_BORDER*2-1);
  127. glVertex2f(slider->knob+1, slider->win_h-GLUI_BORDER*2+1);
  128. glVertex2f(slider->knob+4, GLUI_BORDER*2-1);
  129. glVertex2f(slider->knob+4, slider->win_h-GLUI_BORDER*2+1);
  130. glEnd();
  131. glColor3f(0.175+lit, 0.1+lit, 0.1+lit);
  132. glBegin(GL_LINES);
  133. glVertex2f(slider->knob-3, GLUI_BORDER*2-1);
  134. glVertex2f(slider->knob-3, slider->win_h-GLUI_BORDER*2+1);
  135. glVertex2f(slider->knob+0, GLUI_BORDER*2-1);
  136. glVertex2f(slider->knob+0, slider->win_h-GLUI_BORDER*2+1);
  137. glVertex2f(slider->knob+3, GLUI_BORDER*2-1);
  138. glVertex2f(slider->knob+3, slider->win_h-GLUI_BORDER*2+1);
  139. glEnd();
  140.     } else {
  141. _gluiEmboss(GLUI_SUNKEN, 0, /* never lit */
  142.     0, 0, slider->win_w, slider->length);
  143. _gluiEmboss(GLUI_RAISED, slider->lit, 
  144.     GLUI_BORDER, slider->knob - GLUI_KNOB/2,
  145.     slider->win_w - GLUI_BORDER*2, GLUI_KNOB + GLUI_BORDER);
  146. /* XXX why is it GLUI_KNOB+GLUI_BORDER ? */
  147. glColor3f(0.175+lit, 0.1+lit, 0.1+lit);
  148. glBegin(GL_LINES);
  149. glVertex2f(GLUI_BORDER*2-1, slider->knob-2);
  150. glVertex2f(slider->win_w-GLUI_BORDER*2+1, slider->knob-2);
  151. glVertex2f(GLUI_BORDER*2-1, slider->knob+1);
  152. glVertex2f(slider->win_w-GLUI_BORDER*2+1, slider->knob+1);
  153. glVertex2f(GLUI_BORDER*2-1, slider->knob+4);
  154. glVertex2f(slider->win_w-GLUI_BORDER*2+1, slider->knob+4);
  155. glEnd();
  156. glColor3f(0.975+lit, 0.9+lit, 0.9+lit);
  157. glBegin(GL_LINES);
  158. glVertex2f(GLUI_BORDER*2-1, slider->knob-3);
  159. glVertex2f(slider->win_w-GLUI_BORDER*2+1, slider->knob-3);
  160. glVertex2f(GLUI_BORDER*2-1, slider->knob+0);
  161. glVertex2f(slider->win_w-GLUI_BORDER*2+1, slider->knob+0);
  162. glVertex2f(GLUI_BORDER*2-1, slider->knob+3);
  163. glVertex2f(slider->win_w-GLUI_BORDER*2+1, slider->knob+3);
  164. glEnd();
  165.     }
  167.     glutSwapBuffers();
  168. }
  170. static int
  171. _gluiHitKnob(GLUIslider* slider, int x, int y)
  172. {
  173.     if (slider->type == GLUI_HORIZONTAL) {
  174. /* we know that we don't have to test the y coordinate because
  175.    the mouse came down in the window (this means that they can
  176.    hit the borders and still move the knob, but that's okay).
  177.  */
  178. if (x > slider->knob - GLUI_KNOB/2 && x < slider->knob + GLUI_KNOB/2)
  179.     return GLUI_HIT;
  180. else if (x < slider->knob)
  181.     return GLUI_LESS;
  182. else
  183.     return GLUI_MORE;
  184.     } else {
  185. /* we know that we don't have to test the x coordinate because
  186.    the mouse came down in the window (this means that they can
  187.    hit the borders and still move the knob, but that's okay).
  188.  */
  189. if (y > slider->knob - GLUI_KNOB/2 && y < slider->knob + GLUI_KNOB/2)
  190.     return GLUI_HIT;
  191. else if (y < slider->knob)
  192.     return GLUI_LESS;
  193. else
  194.     return GLUI_MORE;
  195.     }
  196. }
  198. static void
  199. _gluiConstrainKnob(GLUIslider* slider)
  200. {
  201.     if (slider->knob > slider->length - GLUI_BORDER*2 - GLUI_KNOB/2)
  202. slider->knob = slider->length - GLUI_BORDER*2 - GLUI_KNOB/2;
  203.     else if (slider->knob < GLUI_BORDER + GLUI_KNOB/2)
  204. slider->knob = GLUI_BORDER + GLUI_KNOB/2;
  205. }
  208. static float
  209. _gluiKnobPercent(GLUIslider* slider)
  210. {
  211.     return (float)(slider->knob - GLUI_KNOB/2 - GLUI_BORDER) /
  212. (slider->length - GLUI_BORDER*3 - GLUI_KNOB);
  213. }
  215. static int
  216. _gluiKnobPosition(GLUIslider* slider, float percent)
  217. {
  218.     return GLUI_BORDER + GLUI_KNOB/2 + percent * 
  219. (slider->length - GLUI_BORDER*3 - GLUI_KNOB);
  220. }
  222. static int _gluiX;
  223. static int _gluiY;
  224. static int _gluiMouseDown;
  226. static void
  227. _gluiTimer(int value)
  228. {
  229.     GLUIslider* slider = (GLUIslider*)value;
  230.     float percent;
  232.     percent = _gluiKnobPercent(slider); 
  234.     if (_gluiMouseDown != 0 && percent > 0.0 && percent < 1.0) {
  235. if (_gluiMouseDown == GLUI_LESS) {
  236.     slider->knob -= slider->length / 25.0;
  237.     _gluiConstrainKnob(slider);
  238. } else {
  239.     slider->knob += slider->length / 25.0;
  240.     _gluiConstrainKnob(slider);
  241. }
  242. glutSetWindow(slider->window);
  243.   glutPostRedisplay();
  244. slider->update(_gluiKnobPercent(slider));
  245. glutTimerFunc(20, _gluiTimer, (int)slider);
  246.     }
  247. }
  249. static void
  250. _gluiConvertY(GLUIslider* slider, int* y)
  251. {
  252.     if (slider->win_h < 0) {
  253. glutSetWindow(slider->parent);
  254. *y = glutGet(GLUT_WINDOW_HEIGHT) + slider->win_h - slider->win_y - *y;
  255. glutSetWindow(slider->window);
  256.     } else {
  257. *y = slider->win_h - *y;
  258.     }
  259. }
  261. /* ARGSUSED */
  262. static void
  263. _gluiMouse(int button, int state, int x, int y)
  264. {
  265.     GLUIslider* slider = _gluiCurrentSlider();
  266.     int side;
  268.     _gluiConvertY(slider, &y);
  270.     _gluiX = x;
  271.     _gluiY = y;
  272.     _gluiHit = NULL;
  273.     _gluiMouseDown = GL_FALSE;
  275.     if (state == GLUT_DOWN) {
  276. side = _gluiHitKnob(slider, x, y);
  277. if (side == GLUI_HIT) {
  278.     _gluiHit = slider;
  279. } else if (side == GLUI_LESS) {
  280.     slider->knob -= slider->length / 25.0;
  281.     _gluiConstrainKnob(slider);
  282. } else {
  283.     slider->knob += slider->length / 25.0;
  284.     _gluiConstrainKnob(slider);
  285. }
  286. glutPostRedisplay();
  287. slider->update(_gluiKnobPercent(slider));
  288. _gluiMouseDown = side;
  289. if (side != 0) {
  290.     glutTimerFunc(500, _gluiTimer, (int)slider);
  291. }
  292.     } else {
  293. slider->lit = GL_FALSE;
  294.     }
  295. }
  297. static void
  298. _gluiMotion(int x, int y)
  299. {
  300.     GLUIslider* slider = _gluiHit;
  302.     if (slider) {
  303. _gluiConvertY(slider, &y);
  305. if (slider->type == GLUI_HORIZONTAL) {
  306.     /* clamp the incoming old position, or else the knob will
  307.                possibly "jump" due to the false delta. */
  308.     if (_gluiX < GLUI_BORDER+1)
  309. _gluiX = GLUI_BORDER+1;
  310.     if (_gluiX > slider->length - GLUI_BORDER*2)
  311. _gluiX = slider->length - GLUI_BORDER*2;
  312.     /* we don't want to take any action if the mouse pointer
  313.                has moved passed the extents of the slider. */
  314.     if (x > GLUI_BORDER && x < slider->length - GLUI_BORDER*2) {
  315. slider->knob -= _gluiX - x;
  316. _gluiX = x;
  317.     }
  318. } else {
  319.     /* clamp the incoming old position, or else the knob will
  320.                possibly "jump" due to the false delta. */
  321.     if (_gluiY < GLUI_BORDER+1)
  322. _gluiY = GLUI_BORDER+1;
  323.     if (_gluiY > slider->length - GLUI_BORDER*2)
  324. _gluiY = slider->length - GLUI_BORDER*2;
  325.     /* we don't want to take any action if the mouse pointer
  326.                has moved passed the extents of the slider. */
  327.     if (y > GLUI_BORDER && y < slider->length - GLUI_BORDER*2) {
  328. slider->knob -= _gluiY - y;
  329. _gluiY = y;
  330.     }
  331. }
  332. _gluiConstrainKnob(slider);
  334. /* post a display _before_ updating the user, so that the knob
  335.            won't lag behind. */
  336. glutPostRedisplay();
  338. /* make sure to set the parent window current, otherwise if
  339.            there is OpenGL state being changed in the update callback,
  340.            it will be done to the sliders context! */
  341. glutSetWindow(slider->parent);
  342. slider->update(_gluiKnobPercent(slider));
  343.     }
  344. }
  346. static void
  347. _gluiPassive(int x, int y)
  348. {
  349.     GLUIslider* slider = _gluiCurrentSlider();
  351.     _gluiConvertY(slider, &y);
  353.     if (_gluiHitKnob(slider, x, y) == 0)
  354. slider->lit = GL_TRUE;
  355.     else
  356. slider->lit = GL_FALSE;
  358.     glutPostRedisplay();
  359. }
  361. /* ARGSUSED */
  362. static void
  363. _gluiEntry(int state)
  364. {
  365.     GLUIslider* slider = _gluiCurrentSlider();
  367.     /* set the lit flag to false whether we are coming or going
  368.        because if we are doing either, we can't be on top of the knob!  */
  369.     slider->lit = GL_FALSE;
  370.     glutPostRedisplay();
  371. }
  373. void
  374. gluiReshape(int width, int height)
  375. {
  376.     float percent;
  377.     int x, y, w, h;
  378.     GLUIslider* slider = _gluiSliders;
  380.     while (slider) {
  381. /* we need to get the width and height of the parent, so set
  382.            it current. */
  383. glutSetWindow(slider->parent);
  385. /* all this mumbo jumbo takes care of the negative arguments
  386.            to attach the slider to different sides of the window. */
  387. x = slider->win_x;
  388. if (x < 0)
  389.     x = width - slider->win_w + x + 1;
  390. y = slider->win_y;
  391. if (y < 0)
  392.     y = height - slider->win_h + y + 1;
  393. w = slider->win_w;
  394. if (w < 0)
  395.     w = glutGet(GLUT_WINDOW_WIDTH) + slider->win_w - slider->win_x;
  396. h = slider->win_h;
  397. if (h < 0)
  398.     h = glutGet(GLUT_WINDOW_HEIGHT) + slider->win_h - slider->win_y;
  400. glutSetWindow(slider->window);
  401. glutPositionWindow(x, y);
  402. glutReshapeWindow(w, h);
  404.   percent = _gluiKnobPercent(slider);
  406. if (slider->type == GLUI_HORIZONTAL)
  407.     slider->length = w;
  408. else
  409.     slider->length = h;
  411. slider->knob = _gluiKnobPosition(slider, percent);
  413. _gluiConstrainKnob(slider);
  415. glViewport(0, 0, w, h);
  416. glMatrixMode(GL_PROJECTION);
  417. glLoadIdentity();
  418. gluOrtho2D(0, w, 0, h);
  419. glMatrixMode(GL_MODELVIEW);
  420. glLoadIdentity();
  422. slider = slider->next;
  423.     }
  424. }
  428. int
  429. gluiVerticalSlider(int parent, int x, int y, int width, int height,
  430.    float percent, void (*update)(float))
  431. {
  432.     GLUIslider* slider = (GLUIslider*)malloc(sizeof(GLUIslider));
  433.     slider->next = _gluiSliders;
  434.     _gluiSliders = slider;
  436.     slider->type = GLUI_VERTICAL;
  437.     slider->parent = parent;
  438.     slider->window = glutCreateSubWindow(parent, x, y, width, height);
  439.     slider->win_x = x;
  440.     slider->win_y = y;
  441.     slider->win_w = width;
  442.     slider->win_h = height;
  443.     slider->update = update;
  444.     slider->lit = GL_FALSE;
  446. /*     glutSetCursor(GLUT_CURSOR_LEFT_RIGHT); */
  447.     glutDisplayFunc(_gluiDisplay);
  448.     glutEntryFunc(_gluiEntry);
  449.     glutMouseFunc(_gluiMouse);
  450.     glutMotionFunc(_gluiMotion);
  451.     glutPassiveMotionFunc(_gluiPassive);
  453.     glDisable(GL_LIGHTING);
  454.     glDisable(GL_DEPTH_TEST);
  456.     slider->length = height;
  457.     if (height < 0) {
  458. glutSetWindow(parent);
  459. slider->length = glutGet(GLUT_WINDOW_HEIGHT) + height - slider->win_y;
  460.     }
  462.     slider->knob = _gluiKnobPosition(slider, percent);
  463.     _gluiConstrainKnob(slider);
  465.     return slider->window;
  466. }
  469. /* On a horizontal slider, the height must be non-negative. */
  471. int
  472. gluiHorizontalSlider(int parent, int x, int y, int width, int height,
  473.      float percent, void (*update)(float))
  474. {
  475.     GLUIslider* slider = (GLUIslider*)malloc(sizeof(GLUIslider));
  476.     slider->next = _gluiSliders;
  477.     _gluiSliders = slider;
  479.     slider->type = GLUI_HORIZONTAL;
  480.     slider->parent = parent;
  481.     slider->window = glutCreateSubWindow(parent, x, y, width, height);
  482.     slider->win_x = x;
  483.     slider->win_y = y;
  484.     slider->win_w = width;
  485.     slider->win_h = height;
  486.     slider->update = update;
  487.     slider->lit = GL_FALSE;
  489. /*     glutSetCursor(GLUT_CURSOR_LEFT_RIGHT); */
  490.     glutDisplayFunc(_gluiDisplay);
  491.     glutEntryFunc(_gluiEntry);
  492.     glutMouseFunc(_gluiMouse);
  493.     glutMotionFunc(_gluiMotion);
  494.     glutPassiveMotionFunc(_gluiPassive);
  496.     glDisable(GL_LIGHTING);
  497.     glDisable(GL_DEPTH_TEST);
  499.     slider->length = width;
  500.     if (width < 0) {
  501. glutSetWindow(parent);
  502. slider->length = glutGet(GLUT_WINDOW_WIDTH) + width - slider->win_x;
  503.     }
  505.     slider->knob = _gluiKnobPosition(slider, percent);
  506.     _gluiConstrainKnob(slider);
  508.     return slider->window;
  509. }