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

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

GIS编程

开发平台：

Visual C++

mui.c：源码内容
  1. /*
  2.  * Copyright (c) 1993-1997, Silicon Graphics, Inc.
  3.  * ALL RIGHTS RESERVED 
  4.  * Permission to use, copy, modify, and distribute this software for 
  5.  * any purpose and without fee is hereby granted, provided that the above
  6.  * copyright notice appear in all copies and that both the copyright notice
  7.  * and this permission notice appear in supporting documentation, and that 
  8.  * the name of Silicon Graphics, Inc. not be used in advertising
  9.  * or publicity pertaining to distribution of the software without specific,
  10.  * written prior permission. 
  11.  *
  12.  * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
  13.  * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
  14.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
  15.  * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
  16.  * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
  17.  * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
  18.  * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
  19.  * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
  20.  * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
  21.  * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
  22.  * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
  23.  * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
  24.  * 
  25.  * US Government Users Restricted Rights 
  26.  * Use, duplication, or disclosure by the Government is subject to
  27.  * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
  28.  * (c)(1)(ii) of the Rights in Technical Data and Computer Software
  29.  * clause at DFARS 252.227-7013 and/or in similar or successor
  30.  * clauses in the FAR or the DOD or NASA FAR Supplement.
  31.  * Unpublished-- rights reserved under the copyright laws of the
  32.  * United States.  Contractor/manufacturer is Silicon Graphics,
  33.  * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
  34.  *
  35.  * OpenGL(R) is a registered trademark of Silicon Graphics, Inc.
  36.  */
  38. #include <mui/gizmo.h>
  39. #include <stdio.h>
  40. #include <GL/glut.h>
  41. #include <stdlib.h>
  43. extern int activemenu;
  44. extern int menuinuse;
  46. static muiObject *newmuiobj(void)
  47. {
  48.     muiObject *newobj = (muiObject *)malloc(sizeof(muiObject));
  49.     newobj->active = 0;
  50.     newobj->enable = 1;
  51.     newobj->select = 0;
  52.     newobj->locate = 0;
  53.     newobj->visible = 1;
  54.     newobj->callback = 0;
  55.     muiSetUIList(newobj, muiGetActiveUIList());
  56.     muiAddToUIList(muiGetActiveUIList(), newobj);
  57.     newobj->id = 0;
  58.     return newobj;
  59. }
  61. muiObject *muiNewPulldown(void)
  62. {
  63.     muiObject *newPD = newmuiobj();
  64.     newPD->type = MUI_PULLDOWN;
  65.     newPD->xmin = 0;
  66.     newPD->ymin = glutGet(GLUT_WINDOW_HEIGHT) - PULLDOWN_HEIGHT;
  67.     newPD->xmax = glutGet(GLUT_WINDOW_WIDTH);
  68.     newPD->ymax = glutGet(GLUT_WINDOW_HEIGHT);
  69.     newPD->object = (void *)newpd();
  70.     newPD->handler = pdhandler;
  71.     return newPD;
  72. }
  74. muiObject *muiNewButton(int xmin, int xmax, int ymin, int ymax)
  75. {
  76.     muiObject *newb = newmuiobj();
  77.     newb->type = MUI_BUTTON;
  78.     newb->xmin = xmin;
  79.     newb->ymin = ymin;
  80.     newb->xmax = xmax;
  81.     newb->ymax = ymax;
  82.     newb->object = (void *)newbut();
  83.     ((Button *)(newb->object))->object = newb;
  84.     newb->handler = buttonhandler;
  85.     return newb;
  86. }
  88. muiObject *muiNewRadioButton(int xmin, int ymin)
  89. {
  90.     muiObject *newb = newmuiobj();
  91.     newb->type = MUI_RADIOBUTTON;
  92.     newb->xmin = xmin;
  93.     newb->ymin = ymin;
  94.     newb->xmax = xmin+ RADIOWIDTH-1;
  95.     newb->ymax = ymin+RADIOHEIGHT-1;
  96.     newb->object = (void *)newradiobut();
  97.     ((Button *)(newb->object))->object = newb;
  98.     newb->handler = buttonhandler;
  99.     return newb;
  100. }
  102. muiObject *muiNewTinyRadioButton(int xmin, int ymin)
  103. {
  104.     muiObject *newb = newmuiobj();
  105.     newb->type = MUI_TINYRADIOBUTTON;
  106.     newb->xmin = xmin;
  107.     newb->ymin = ymin;
  108.     newb->xmax = xmin+ TINYRADIOWIDTH-1;
  109.     newb->ymax = ymin+ TINYRADIOHEIGHT-1;
  110.     newb->object = (void *)newradiobut();
  111.     ((Button *)(newb->object))->object = newb;
  112.     newb->handler = buttonhandler;
  113.     return newb;
  114. }
  116. muiObject *muiNewVSlider(int xmin, int ymin, int ymax, int scenter, int shalf)
  117. {
  118.     muiObject *newvsl = newmuiobj();
  119.     newvsl->type = MUI_VSLIDER;
  120.     newvsl->xmin = xmin;
  121.     newvsl->ymin = ymin;
  122.     newvsl->xmax = xmin+SLIDERWIDTH-1;
  123.     newvsl->ymax = ymax;
  124.     newvsl->object = (void *)newvs(newvsl, ymin, ymax, scenter, shalf);
  125.     newvsl->handler = vshandler;
  126.     return newvsl;
  127. }
  129. muiObject *muiNewHSlider(int xmin, int ymin, int xmax, int scenter, int shalf)
  130. {
  131.     muiObject *newhsl = newmuiobj();
  132.     newhsl->type = MUI_HSLIDER;
  133.     newhsl->xmin = xmin;
  134.     newhsl->ymin = ymin;
  135.     newhsl->xmax = xmax;
  136.     newhsl->ymax = ymin+SLIDERWIDTH-1;
  137.     newhsl->object = (void *)newhs(newhsl, xmin, xmax, scenter, shalf);
  138.     newhsl->handler = hshandler;
  139.     return newhsl;
  140. }
  142. muiObject *muiNewTextList(int xmin, int ymin, int xmax, int listheight)
  143. {
  144.     muiObject *newtlo = newmuiobj();
  145.     newtlo->type = MUI_TEXTLIST;
  146.     newtlo->xmin = xmin;
  147.     newtlo->ymin = ymin;
  148.     newtlo->xmax = xmax;
  149.     newtlo->object = (void *)newtl(newtlo, listheight);
  150.     newtlo->handler = tlhandler;
  151.     return newtlo;
  152. }
  154. muiObject *muiNewLabel(int xmin, int ymin, char *label)
  155. {
  156.     muiObject *newlbl = newmuiobj();
  157.     newlbl->type = MUI_LABEL;
  158.     newlbl->xmin = xmin;
  159.     newlbl->ymin = ymin;
  160.     /* XXX maximums */
  161.     newlbl->object = (void *)newlabel(label);
  162.     newlbl->handler = nullhandler;
  163.     return newlbl;
  164. }
  166. muiObject *muiNewBoldLabel(int xmin, int ymin, char *label)
  167. {
  168.     muiObject *newlbl = newmuiobj();
  169.     newlbl->type = MUI_BOLDLABEL;
  170.     newlbl->xmin = xmin;
  171.     newlbl->ymin = ymin;
  172.     /* XXX maximums */
  173.     newlbl->object = (void *)newlabel(label);
  174.     newlbl->handler = nullhandler;
  175.     return newlbl;
  176. }
  178. muiObject *muiNewTextbox(int xmin, int xmax, int ymin)
  179. {
  180.     muiObject *newtextbox = newmuiobj();
  181.     newtextbox->type = MUI_TEXTBOX;
  182.     newtextbox->xmin = xmin;
  183.     newtextbox->ymin = ymin;
  184.     newtextbox->xmax = xmax;
  185.     newtextbox->ymax = ymin + TEXTBOXHEIGHT - 1;
  186.     newtextbox->object = (void *)newtb(xmin, xmax);
  187.     newtextbox->handler = textboxhandler;
  188.     return newtextbox;
  189. }
  191. void muiGetObjectSize(muiObject *obj, int *xmin, int *ymin, int *xmax, int *ymax)
  192. {
  193.     *xmin = obj->xmin;
  194.     *xmax = obj->xmax;
  195.     *ymin = obj->ymin;
  196.     *ymax = obj->ymax;
  197. }
  199. void muiFreeObject(muiObject *obj)
  200. {
  201.     switch (obj->type) {
  202. case MUI_BUTTON:
  203. case MUI_RADIOBUTTON:
  204. case MUI_TINYRADIOBUTTON:
  205. case MUI_VSLIDER:
  206. case MUI_HSLIDER:
  207. case MUI_TEXTBOX:
  208. case MUI_TEXTLIST:
  209. case MUI_PULLDOWN:
  210.     free(obj->object);
  211.     break;
  212. case MUI_LABEL:
  213. case MUI_BOLDLABEL:
  214.     break;
  215.     }
  216.     free(obj);
  217. }
  219. void     muiSetID(muiObject *obj, int id)
  220. {
  221.     obj->id = id;
  222. }
  224. int muiGetID(muiObject *obj)
  225. {
  226.     return obj->id;
  227. }
  229. void muiSetCallback(muiObject *obj, void (*callback)(muiObject *, enum muiReturnValue))
  230. {
  231.     obj->callback = callback;
  232. }
  234. int muiInObject(muiObject *obj, int x, int y)
  235. {
  236.     if (obj->xmin <= x && x <= obj->xmax && obj->ymin <= y && y <= obj->ymax)
  237. return 1;
  238.     return 0;
  239. }
  241. int muiGetLocate(muiObject *obj)
  242. {
  243.     return obj->locate;
  244. }
  246. void muiSetLocate(muiObject *obj, int state)
  247. {
  248.     obj->locate = (short) state;
  249. }
  251. int muiGetSelect(muiObject *obj)
  252. {
  253.     return obj->select;
  254. }
  256. void muiSetUIList(muiObject *obj, int list)
  257. {
  258.     obj->uilist = list;
  259. }
  261. int muiGetUIList(muiObject *obj)
  262. {
  263.     return obj->uilist;
  264. }
  266. void muiSetSelect(muiObject *obj, int state)
  267. {
  268.     obj->select = (short) state;
  269. }
  271. int muiGetVisible(muiObject *obj)
  272. {
  273.     return obj->visible;
  274. }
  276. void muiSetVisible(muiObject *obj, int state)
  277. {
  278.     obj->visible = (short) state;
  279. }
  281. int muiGetActive(muiObject *obj)
  282. {
  283.     return obj->active;
  284. }
  286. void muiSetActive(muiObject *obj, int state)
  287. {
  288.     obj->active = (short) state;
  289. }
  291. int muiGetEnable(muiObject *obj)
  292. {
  293.     return obj->enable;
  294. }
  296. void muiSetEnable(muiObject *obj, int state)
  297. {
  298.     obj->enable = (short) state;
  299. }
  301. void muiDrawObject(muiObject *obj)
  302. {
  303.     switch (obj->type) {
  304. case MUI_BUTTON:
  305.     drawbut(obj);
  306.     break;
  307. case MUI_RADIOBUTTON:
  308.     drawradiobutton(obj);
  309.     break;
  310. case MUI_TINYRADIOBUTTON:
  311.     drawtinyradio(obj);
  312.     break;
  313. case MUI_LABEL:
  314.     drawlabel(obj);
  315.     break;
  316. case MUI_BOLDLABEL:
  317.     drawboldlabel(obj);
  318.     break;
  319. case MUI_TEXTBOX:
  320.     drawtb(obj);
  321.     break;
  322. case MUI_VSLIDER:
  323.     drawvs(obj);
  324.     break;
  325. case MUI_HSLIDER:
  326.     drawhs(obj);
  327.     break;
  328. case MUI_TEXTLIST:
  329.     drawtl(obj);
  330.     break;
  331. case MUI_PULLDOWN:
  332.     drawpulldown(obj);
  333.     break;
  334.     }
  335. }
  337. void muiError(char *s)
  338. {
  339.     fprintf(stderr, "%sn", s);
  340.     exit(0);
  341. }
  343. #define MAX_UI_LISTS 50
  344. static muiCons *muilist[MAX_UI_LISTS];
  345. static int muilistindex[MAX_UI_LISTS];
  347. void muiNewUIList(int listid)
  348. {
  349.     static int inited = 0;
  350.     int i;
  352.     if (inited == 0) {
  353. inited = 1;
  354. for (i = 1; i < MAX_UI_LISTS; i++)
  355.     muilistindex[i] = -1;
  356. muilistindex[0] = listid;
  357. muiSetActiveUIList(listid);
  358. return;
  359.     }
  360.     for (i = 0; i < MAX_UI_LISTS; i++)
  361. if (muilistindex[i] == -1) {
  362.     muilistindex[i] = listid;
  363.     muiSetActiveUIList(listid);
  364.     return;
  365. }
  366.     muiError("muiNewUIList: No more UI lists available");
  367. }
  369. int muiGetListId(int uilist)
  370. {
  371.     int i;
  372.     
  373.     for (i = 0; i < MAX_UI_LISTS; i++) {
  374. if (muilistindex[i] == uilist) return i;
  375.     }
  376.     muiError("muiAddToUIList: illegal UI list identifier");
  377.     return -1;
  378. }
  380. muiCons *muiGetListCons(int uilist)
  381. {
  382.     int i;
  383.     
  384.     for (i = 0; i < MAX_UI_LISTS; i++) {
  385. if (muilistindex[i] == uilist) return muilist[i];
  386.     }
  387.     muiError("muiGetListCons: illegal UI list identifier");
  388.     return (muiCons *)0;
  389. }
  391. void muiAddToUIList(int uilist, muiObject *obj)
  392. {
  393.     int i;
  394.     muiCons *mcons;
  396.     if (uilist == 0) {
  397. muiError("muiAddToUIList: no active UI list");
  398.     }
  399.     if ((i = muiGetListId(uilist)) == -1) return;
  400.     mcons = (muiCons *)malloc(sizeof(muiCons));
  401.     mcons->next = muilist[i];
  402.     muilist[i] = mcons;
  403.     mcons->object = obj;
  404. }
  406. static muiObject *muiFastHitInList(muiCons *mcons, int x, int y)
  407. {
  408.     while (mcons) {
  409. if (muiInObject(mcons->object, x, y))
  410.     switch (mcons->object->type) {
  411. case MUI_BUTTON:
  412. case MUI_TEXTBOX:
  413. case MUI_VSLIDER:
  414. case MUI_HSLIDER:
  415. case MUI_TEXTLIST:
  416. case MUI_RADIOBUTTON:
  417. case MUI_TINYRADIOBUTTON:
  418. case MUI_PULLDOWN:
  419.     return mcons->object;
  420. case MUI_LABEL:
  421. case MUI_BOLDLABEL:
  422.     return 0;
  423.     }
  424. mcons = mcons->next;
  425.     }
  426.     return (muiObject *)0; /* not found */
  427. }
  429. muiObject *muiHitInList(int uilist, int x, int y)
  430. {
  431.     muiCons *mcons;
  432.     
  433.     if ((mcons = muiGetListCons(uilist)) == (muiCons *)0) return (muiObject *)0;
  434.     return muiFastHitInList(mcons, x, y);
  435. }
  437. void muiDrawUIList(int uilist)
  438. {
  439.     muiCons *mcons;
  441.     if ((mcons = muiGetListCons(uilist)) == (muiCons *)0) return;
  442.     muiBackgroundClear();
  443.     while (mcons) {
  444. muiDrawObject(mcons->object);
  445. mcons = mcons->next;
  446.     }
  447. }
  449. static muiObject *SelectedObj, *LocatedObj;
  450. static muiCons *ActiveCons;
  451. static int ActiveUIList = 0;
  452. static muiObject *ActiveSlider = 0;
  454. void muiSetActiveUIList(int i)
  455. {
  456.     ActiveUIList = i;
  457. }
  459. int muiGetActiveUIList(void)
  460. {
  461.     return ActiveUIList;
  462. }
  464. static void muiInitInteraction(int uilist)
  465. {
  466.     muiCons *mcons;
  467.     muiObject *obj;
  469.     if ((mcons = muiGetListCons(uilist)) == (muiCons *)0) return;
  470.     SelectedObj = LocatedObj = (muiObject *)0;
  471.     ActiveCons = mcons;
  472.     ActiveUIList = uilist;
  473.     while (mcons) {
  474. obj = mcons->object;
  475. muiSetSelect(obj, 0);
  476. muiSetLocate(obj, 0);
  477. mcons = mcons->next;
  478.     }
  479. }
  481. static void (*noncallback)(int, int) = 0;
  483. static void nonmuicallback(int x, int y)
  484. {
  485.     if (noncallback == 0) return;
  486.     noncallback(x, y);
  487. }
  489. void muiSetNonMUIcallback(void (*nc)(int, int))
  490. {
  491.     noncallback = nc;
  492. }
  494. void muiHandleEvent(int event, int value, int x, int y)
  495. {
  496.     muiObject *obj;
  497.     static int lastactive = 0;
  498.     enum muiReturnValue retval;
  500.     if (ActiveUIList == 0) {
  501. muiError("muiHandleEvent: no active UI list");
  502.     }
  503.     if (lastactive != ActiveUIList) {
  504. muiInitInteraction(lastactive = ActiveUIList);
  505.     }
  506.     if ((event == MUI_KEYSTROKE)) {
  507. if (obj = muiGetActiveTB()) {
  508.     retval = (obj->handler)(obj, event, value, x, y);
  509.     if (retval && obj->callback)
  510. (obj->callback)(obj, retval);
  511.     return;
  512. }
  513. /* may have to add text editors, et cetera */
  514. return;
  515.     }
  516.     if (event == MUI_DEVICE_RELEASE && ActiveSlider) {
  517. retval = (ActiveSlider->handler)(ActiveSlider, event, value, x, y);
  518. if (retval && ActiveSlider->callback)
  519.     (ActiveSlider->callback)(ActiveSlider, retval);
  520. ActiveSlider = 0;
  521. return;
  522.     }
  523.     ActiveCons = muiGetListCons(ActiveUIList);
  524.     obj = muiFastHitInList(ActiveCons, x, y);
  525.     if (obj == 0 && event == MUI_DEVICE_PRESS) {
  526. nonmuicallback(x, y);
  527. return;
  528.     }
  529.     if (event == MUI_DEVICE_UP && (!menuinuse) && (activemenu != -1) && (obj == 0 || obj->type != MUI_PULLDOWN)) {
  530. activemenu = -1;
  531. glutDetachMenu(GLUT_LEFT_BUTTON);
  532.     }
  533.     if (obj && (obj->type == MUI_VSLIDER || obj->type == MUI_HSLIDER)
  534.     && event == MUI_DEVICE_PRESS)
  535.     ActiveSlider = obj;
  536.     if (obj == 0) {
  537. if (ActiveSlider) {
  538.     retval = (ActiveSlider->handler)(ActiveSlider, event, value, x, y);
  539.     if (retval && ActiveSlider->callback)
  540. (ActiveSlider->callback)(ActiveSlider, retval);
  541.     return;
  542. }
  543.         if (LocatedObj) {
  544.     muiSetLocate(LocatedObj, 0);
  545.     muiDrawObject(LocatedObj);
  546.     LocatedObj = 0;
  547. }
  548. if ((event == MUI_DEVICE_RELEASE) && SelectedObj) {
  549.     muiSetSelect(SelectedObj, 0);
  550.     muiSetLocate(SelectedObj, 0);
  551.     muiDrawObject(SelectedObj);
  552.     LocatedObj = SelectedObj = 0;
  553. }
  554. return;
  555.     }
  556.     retval = (obj->handler)(obj, event, value, x, y);
  557.     if (retval && obj->callback)
  558. (obj->callback)(obj, retval);
  559.     return;
  560. }
  562. /* ARGSUSED2 */
  563. enum muiReturnValue buttonhandler(muiObject *obj, int event, int value, int x, int y)
  564. {
  565.     if (!muiGetEnable(obj) || !muiGetVisible(obj)) return MUI_NO_ACTION;
  567.     switch (event) {
  568. case MUI_DEVICE_DOWN:
  569.     return MUI_NO_ACTION;
  570. case MUI_DEVICE_UP:
  571.     if (LocatedObj != obj) {
  572.         if (LocatedObj) {
  573.     muiSetLocate(LocatedObj, 0);
  574.     muiDrawObject(LocatedObj);
  575. }
  576. muiSetLocate(obj, 1);
  577. muiDrawObject(obj);
  578. LocatedObj = obj;
  579.     }
  580.     return MUI_NO_ACTION;
  581. case MUI_DEVICE_PRESS:
  582.     muiSetSelect(obj, 1);
  583.     muiSetLocate(obj, 1);
  584.     SelectedObj = LocatedObj = obj;
  585.     muiDrawObject(obj);
  586.     return MUI_NO_ACTION;
  587. case MUI_DEVICE_RELEASE:
  588.     if (SelectedObj != obj) {
  589. muiSetSelect(SelectedObj, 0);
  590. muiSetLocate(SelectedObj, 0);
  591. muiDrawObject(SelectedObj);
  592. muiSetLocate(obj, 1);
  593. LocatedObj = obj;
  594. muiDrawObject(obj);
  595. return MUI_NO_ACTION;
  596.     }
  597.     if (obj->type == MUI_RADIOBUTTON || obj->type == MUI_TINYRADIOBUTTON) {
  598. Button *b = (Button *)obj->object, *b1;
  599. if (b->link) {
  600.     muiSetActive(obj, 1);
  601.     b1 = b->link;
  602.     while (b1 != b) {
  603. muiSetActive(b1->object, 0);
  604. b1 = b1->link;
  605.     }
  606. } else {
  607.       muiSetActive(obj, ( muiGetActive(obj) ? 0 : 1 ) );
  608.    }
  609.     }
  610.     muiSetSelect(obj, 0);
  611.     muiDrawObject(obj);
  612.     return MUI_BUTTON_PRESS;
  613. case MUI_DEVICE_CLICK:
  614.     muiSetSelect(obj, 0);
  615.     muiSetLocate(obj, 1);
  616.     LocatedObj = obj;
  617.     muiDrawObject(obj);
  618.     return MUI_BUTTON_PRESS;
  619. case MUI_DEVICE_DOUBLE_CLICK:
  620.     muiSetSelect(obj, 0);
  621.     muiSetLocate(obj, 1);
  622.     LocatedObj = obj;
  623.     muiDrawObject(obj);
  624.     return MUI_BUTTON_PRESS; /* XXX this may not be right; */
  625. case MUI_KEYSTROKE:
  626.     return MUI_NO_ACTION;
  627. default:
  628.     muiError("buttonhandler: wacko event");
  629.     return MUI_NO_ACTION;
  630.     }
  631. }
  633. /* ARGSUSED */
  634. enum muiReturnValue nullhandler(muiObject *obj, int event, int value, int x, int y)
  635. {
  636.     return MUI_NO_ACTION;
  637. }