home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / diverses / leda / src / graphics / _panel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-15  |  17.0 KB  |  704 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  2.1.1                                                 11-15-1991
  4. +
  5. +
  6. +  _panel.c
  7. +
  8. +
  9. +  Copyright (c) 1991  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. #include <math.h>
  17. #include <string.h>
  18. #include <stdio.h>
  19. #include <values.h>
  20.  
  21. #ifdef XVIEW
  22.  
  23. #include <X11/X.h>
  24. #include <X11/Xlib.h>
  25.  
  26. #include <xview/xview.h>
  27. #include <xview/xv_xrect.h>
  28. #include <xview/panel.h>
  29. #include <xview/font.h>
  30. #include <xview/openmenu.h>
  31. #include <xview/icon.h>
  32.  
  33.  
  34. #else
  35.  
  36. #include <suntool/sunview.h>
  37. #include <suntool/canvas.h>
  38. #include <suntool/panel.h>
  39.  
  40. #endif
  41.  
  42. #define MAX_BUT  64
  43. #define MAX_ITEM 16
  44.  
  45. static short icon_image[] = {
  46.  
  47. #include "leda.icon"
  48.  
  49. };
  50.  
  51. mpr_static(panel_icon_pixrect,64,64,1,icon_image);
  52.  
  53.  
  54. typedef struct {
  55.  
  56. Frame   panel_frame;
  57. Panel   panel;
  58.  
  59. Panel_item choice_item[MAX_ITEM];
  60. int*       choice_ref[MAX_ITEM];
  61. int        choice_step[MAX_ITEM];
  62. int        choice_offset[MAX_ITEM];
  63. int        choice_count;
  64.  
  65. Panel_item slider_item[MAX_ITEM];
  66. int*       slider_ref[MAX_ITEM];
  67. int        slider_count;
  68.  
  69. Panel_item string_item[MAX_ITEM];
  70. Menu       string_menu[MAX_ITEM];
  71. char*      string_ref[MAX_ITEM];
  72. int        string_count;
  73.  
  74. Panel_item int_item[MAX_ITEM];
  75. int*       int_ref[MAX_ITEM];
  76. int        int_count;
  77.  
  78. Panel_item float_item[MAX_ITEM];
  79. double*    float_ref[MAX_ITEM];
  80. int        float_count;
  81.  
  82. Panel_item but_item[MAX_BUT]; 
  83. int        but_centered[MAX_BUT];
  84. int        but_count;
  85. int        but_line_count;
  86. int        button_width;
  87.  
  88. int panel_row;
  89.  
  90. } LEDA_PANEL;
  91.  
  92. typedef LEDA_PANEL *leda_panel;
  93.  
  94. static leda_panel current_panel;
  95. static int        panel_button_answer;
  96.  
  97.  
  98. void  x_draw_panel_init(p)
  99. leda_panel p;
  100. {
  101.   p->choice_count = 0;
  102.   p->slider_count = 0;
  103.   p->string_count = 0;
  104.   p->int_count    = 0;
  105.   p->float_count  = 0;
  106.   p->but_count    = 0;
  107.   p->but_line_count = 0;
  108.   p->button_width = 0;
  109.   p->panel_row    = 0;
  110.  
  111. }
  112.  
  113.  
  114. leda_panel x_draw_panel_create()
  115. { 
  116.  
  117. #ifdef XVIEW
  118.   Xv_Font panel_font;
  119. #endif
  120.  
  121.   Icon icon = icon_create(ICON_IMAGE, &panel_icon_pixrect, 0);
  122.  
  123.   leda_panel p = (leda_panel) malloc(sizeof(LEDA_PANEL));
  124.  
  125.  
  126.   p->panel_frame = window_create(0, FRAME,
  127.                               FRAME_ICON, icon,
  128.                               FRAME_NO_CONFIRM, TRUE, 
  129.                               WIN_WIDTH, 1000,
  130.                               WIN_X,      100, 
  131.                               WIN_Y,      100, 
  132.                               0);
  133.  
  134. #ifdef XVIEW
  135.  
  136.   panel_font = (Xv_Font)xv_find(p->panel_frame, FONT,
  137.                          FONT_FAMILY, FONT_FAMILY_DEFAULT_FIXEDWIDTH,
  138.                          FONT_STYLE,  FONT_STYLE_NORMAL,
  139.                          FONT_SIZE,   14,
  140.                          0);
  141.  
  142.   p->panel = window_create(p->panel_frame, PANEL, WIN_FONT, panel_font, 0);
  143.  
  144. #else
  145.  
  146.   p->panel = window_create(p->panel_frame, PANEL,0);
  147.  
  148. #endif
  149.  
  150.  
  151.  x_draw_panel_init(p);
  152.  
  153.  return p;
  154.  
  155. }
  156.  
  157. void x_draw_panel_destroy(p) 
  158. leda_panel p;
  159. { window_destroy(p->panel_frame);
  160.   free(p); 
  161.  }
  162.  
  163.  
  164. static void panel_button_notify(item, event)
  165. Panel_item    item;
  166. Event        *event;
  167. {
  168.   int i,n;
  169.   char buf[256];
  170.   float f;
  171.  
  172.   panel_button_answer = (int)panel_get(item,PANEL_CLIENT_DATA);
  173.  
  174.   for (i=0; i<current_panel->slider_count; i++)
  175.     *(current_panel->slider_ref[i]) = 
  176.                         (int)panel_get_value(current_panel->slider_item[i]);
  177.  
  178.   for (i=0; i<current_panel->choice_count; i++)
  179.    { n = (int)panel_get_value(current_panel->choice_item[i]);
  180.     *(current_panel->choice_ref[i]) = 
  181.         current_panel->choice_offset[i] + n * current_panel->choice_step[i];
  182.     }
  183.  
  184.   for (i=0; i<current_panel->string_count; i++)
  185.    strcpy(current_panel->string_ref[i],
  186.           (char*)panel_get_value(current_panel->string_item[i]));
  187.  
  188.   for (i=0; i<current_panel->int_count; i++)
  189.   { strcpy(buf,(char*)panel_get_value(current_panel->int_item[i]));
  190.     sscanf(buf,"%d",current_panel->int_ref[i]);
  191.    }
  192.  
  193.   for (i=0; i<current_panel->float_count; i++)
  194.   { strcpy(buf,(char*)panel_get_value(current_panel->float_item[i]));
  195.     sscanf(buf,"%f",&f);
  196.     *(current_panel->float_ref[i]) = (double)f;
  197.    }
  198.  
  199.   notify_stop();
  200.  
  201.  }
  202.  
  203.  
  204. #ifdef XVIEW
  205.  
  206. static void menu_proc(menu, menu_item)  /* selecting menu */
  207. Menu menu;
  208. Menu_item menu_item;
  209. {
  210.    Panel_item text_item = window_get(menu,MENU_CLIENT_DATA);
  211.    window_set(text_item,PANEL_VALUE,window_get(menu_item, MENU_STRING),0);
  212.  }
  213.  
  214. #else
  215.  
  216. static char** menu_strings;
  217.  
  218. static void panel_menu_proc(item, event)
  219. Panel_item item;
  220. Event *event;
  221. { int i;
  222.   Menu_item menu_item;
  223.   int j = (int)panel_get(item,PANEL_CLIENT_DATA);
  224.  
  225.   if (event_id(event) == MS_RIGHT && event_is_down(event))
  226.   { menu_item = menu_show(current_panel->string_menu[j], current_panel->panel, event,0);
  227.     panel_set(current_panel->string_item[j],PANEL_VALUE, menu_get(menu_item, MENU_STRING),0);
  228.    }
  229.   else panel_default_handle_event(item,event);
  230. }
  231.  
  232. #endif
  233.  
  234.  
  235. void x_draw_panel_choice_item(p,text,address,argc,argv,step,offset)
  236. leda_panel p;
  237. char* text;
  238. int* address;
  239. int argc;
  240. char** argv;
  241. int step;
  242. int offset;
  243. {
  244.   int i;
  245.   char* choices[16];
  246.  
  247.   if (p->choice_count == MAX_ITEM) return;
  248.  
  249.   for(i=0;i<16;i++) 
  250.      choices[i] = (i<argc) ? argv[i] : 0;
  251.  
  252.   p->panel_row+=40;
  253.  
  254.   p->choice_ref[p->choice_count] = address;
  255.  
  256.   p->choice_step[p->choice_count] = step;
  257.   p->choice_offset[p->choice_count] = offset;
  258.  
  259.   p->choice_item[p->choice_count] = panel_create_item(p->panel, PANEL_CHOICE, 
  260.                           PANEL_LABEL_STRING, text,       
  261.                           PANEL_LABEL_X, 20,
  262.                           PANEL_VALUE_X, 180,
  263.                           PANEL_ITEM_Y, p->panel_row,
  264.                           PANEL_DISPLAY_LEVEL,    PANEL_ALL,
  265.                           PANEL_VALUE, (*address-offset)/step,
  266.                           PANEL_CHOICE_STRINGS, 
  267.                              choices[0],  choices[1],  choices[2],  choices[3], 
  268.                              choices[4],  choices[5],  choices[6],  choices[7], 
  269.                              choices[8],  choices[9],  choices[10], choices[11],
  270.                              choices[12], choices[13], choices[14], choices[15],
  271.                              0,0);
  272.  p->choice_count++;
  273.  
  274. }
  275.  
  276.  
  277. void x_draw_panel_slider_item(p,text,address,Min,Max)
  278. leda_panel p;
  279. char* text;
  280. int* address;
  281. int Min;
  282. int Max;
  283. {
  284.   int i;
  285.   char label[18];
  286.  
  287.   if (p->slider_count == MAX_ITEM) return;
  288.  
  289.   for (i=0; i<17; i++)  
  290.     label[i] = (i<strlen(text)) ? text[i] : ' ';
  291.  
  292.   label[17] = 0;
  293.  
  294.   p->panel_row+=40;
  295.  
  296.   p->slider_ref[p->slider_count] = address;
  297.  
  298.   p->slider_item[p->slider_count] = panel_create_item(p->panel, PANEL_SLIDER, 
  299.                           PANEL_LABEL_STRING, label,       
  300.                           PANEL_LABEL_X,      20,
  301.                           PANEL_VALUE_X,      180,
  302.                           PANEL_ITEM_Y,       p->panel_row,
  303.                           PANEL_VALUE,        *address,
  304.                           PANEL_MIN_VALUE,    Min,
  305.                           PANEL_MAX_VALUE,    Max,
  306.                           PANEL_SLIDER_WIDTH, 180,
  307.                           PANEL_SHOW_RANGE,   FALSE,
  308.                       /*  PANEL_VALUE_DISPLAY_LENGTH, 20, */
  309.                           0);
  310.  p->slider_count++;
  311.  
  312. }
  313.  
  314.  
  315.  
  316. void x_draw_panel_text_item(p,text)
  317. leda_panel p;
  318. char* text;
  319. {
  320.   p->panel_row+=20;
  321.  
  322.   panel_create_item(p->panel, PANEL_MESSAGE, 
  323.                            PANEL_LABEL_BOLD, TRUE,
  324.                            PANEL_LABEL_STRING, text,
  325.                            PANEL_ITEM_X, 20,
  326.                            PANEL_ITEM_Y, p->panel_row,
  327.                        0);
  328.  
  329. }
  330.  
  331.  
  332. void x_draw_panel_string_menu_item(p,text,s,menu_label,n,items)
  333. leda_panel p;
  334. char* text;
  335. char* s;
  336. char    *menu_label;
  337. int      n;
  338. char  **items;
  339. {
  340.     Menu menu;
  341.     char menu_l[32];
  342.     int i;
  343.     int cols = 1 +n/15;
  344.  
  345.     if (p->string_count == MAX_ITEM) return;
  346.  
  347.     p->panel_row+=40;
  348.  
  349.     p->string_ref[p->string_count] = s;
  350.  
  351.     p->string_item[p->string_count] = panel_create_item(p->panel, PANEL_TEXT, 
  352.                                 PANEL_ITEM_X, 20,
  353.                                 PANEL_ITEM_Y, p->panel_row,
  354.                                 PANEL_LABEL_STRING, text,
  355.                                 PANEL_VALUE,s,
  356.                                 PANEL_VALUE_X,180,
  357.                                 PANEL_LABEL_X,20,
  358.                                 PANEL_VALUE_DISPLAY_LENGTH, 20,
  359.                                 PANEL_VALUE_STORED_LENGTH, 256, 
  360.                                 0);
  361.     
  362. #ifdef XVIEW
  363.  
  364.     if (n>0)
  365.     {
  366.       menu = (Menu)window_create(NULL, MENU,
  367.                              MENU_NCOLS, cols,
  368.                              MENU_CLIENT_DATA, p->string_item[p->string_count],
  369.                              MENU_NOTIFY_PROC, menu_proc,
  370.                              0);
  371.  
  372.       for(i=0;i<n;i++) menu_set(menu,MENU_STRING_ITEM,items[i],i,0);
  373.  
  374.       (void) window_create(p->panel, PANEL_BUTTON,
  375.                               PANEL_LABEL_STRING, menu_label,
  376.                               PANEL_ITEM_MENU,    menu, 
  377.                               0);
  378.      }
  379.  
  380. #else
  381.  
  382.  
  383.     if (n > 0)
  384.     { 
  385.      sprintf(menu_l,"%s -> ",menu_label);
  386.      menu_label = menu_l;
  387.  
  388.       menu = menu_create(MENU_NCOLS, cols,
  389.                          MENU_NOTIFY_PROC, menu_return_item,
  390.                         0);
  391.  
  392.       for(i=0;i<n;i++) menu_set(menu,MENU_STRING_ITEM,items[i],i,0);
  393.  
  394.       panel_create_item(p->panel, PANEL_BUTTON,
  395.               PANEL_LABEL_IMAGE,panel_button_image(p->panel,menu_label,0,0), 
  396.               PANEL_EVENT_PROC, panel_menu_proc,
  397.               PANEL_CLIENT_DATA,p->string_count,
  398.                         0);
  399.      }
  400.  
  401.     p->string_menu[p->string_count] = menu;
  402.  
  403. #endif
  404.  
  405.     p->string_count++;
  406.  
  407.  }
  408.  
  409. void x_draw_panel_string_item(p,text,s)
  410. leda_panel p;
  411. char* text;
  412. char* s;
  413. { x_draw_panel_string_menu_item(p,text,s,"",0,0); }
  414.  
  415.  
  416. void x_draw_panel_int_item(p,text,i)
  417. leda_panel p;
  418. char* text;
  419. int* i;
  420. {
  421.     char s[32];
  422.  
  423.     if (p->int_count == MAX_ITEM) return;
  424.  
  425.     sprintf(s,"%d",*i);
  426.  
  427.     p->panel_row+=40;
  428.  
  429.    
  430.     p->int_ref[p->int_count] = i;
  431.  
  432.     p->int_item[p->int_count] = panel_create_item(p->panel, PANEL_TEXT, 
  433.                                 PANEL_ITEM_X, 20,
  434.                                 PANEL_ITEM_Y, p->panel_row,
  435.                                 PANEL_LABEL_STRING, text,
  436.                                 PANEL_VALUE,s,
  437.                                 PANEL_VALUE_X,180,
  438.                                 PANEL_LABEL_X,20,
  439.                                 PANEL_VALUE_DISPLAY_LENGTH, 10,
  440.                                 PANEL_VALUE_STORED_LENGTH, 32, 
  441.                                 0);
  442.     
  443.  
  444. /*
  445.    p->int_item[p->int_count] = panel_create_item(p->panel, PANEL_NUMERIC_TEXT,
  446.                                             PANEL_ITEM_X, 20,
  447.                                             PANEL_ITEM_Y, p->panel_row,
  448.                                             PANEL_LABEL_STRING,    text,
  449.                                             PANEL_VALUE, *i,
  450.                                             PANEL_MIN_VALUE, -MAXINT,
  451.                                             PANEL_MAX_VALUE, MAXINT,
  452.                                             PANEL_VALUE_X,180,
  453.                                             PANEL_LABEL_X,20,
  454.                                             PANEL_VALUE_DISPLAY_LENGTH, 10,
  455.                                             NULL);
  456. */
  457.  
  458.     p->int_count++;
  459.     
  460.  }
  461.  
  462. void x_draw_panel_float_item(p,text,f)
  463. leda_panel p;
  464. char* text;
  465. double* f;
  466. {
  467.     char s[256];
  468.     sprintf(s,"%f",*f); 
  469.  
  470.     if (p->float_count == MAX_ITEM) return;
  471.  
  472.     p->panel_row+=40;
  473.     p->float_item[p->float_count] = panel_create_item(p->panel, PANEL_TEXT, 
  474.                                 PANEL_ITEM_X, 20,
  475.                                 PANEL_ITEM_Y, p->panel_row,
  476.                                 PANEL_LABEL_STRING, text,
  477.                                 PANEL_VALUE, s,
  478.                                 PANEL_VALUE_X,180,
  479.                                 PANEL_LABEL_X,20,
  480.                                 PANEL_VALUE_DISPLAY_LENGTH, 10,
  481.                                 PANEL_VALUE_STORED_LENGTH, 256, 
  482.                                 0);
  483.     p->float_ref[p->float_count] = f;
  484.  
  485.     p->float_count++;
  486.     
  487.  }
  488.  
  489.  
  490. int x_draw_panel_button(p,button)
  491. leda_panel p;
  492. char* button;
  493. { 
  494.   Rect    *r;
  495.  
  496.   int i;
  497.  
  498.   if (p->but_count == MAX_BUT) return;
  499.  
  500.   p->but_centered[p->but_count] = 0;
  501.  
  502.   if (p->but_line_count==0)
  503.   {  
  504.     if (p->panel_row==0) 
  505.        p->panel_row = 20;
  506.     else 
  507.        if (p->but_count==0) 
  508.           p->panel_row+=50;
  509.        else
  510.           p->panel_row+=35;
  511.  
  512.  p->but_item[p->but_count] =  panel_create_item(p->panel, PANEL_BUTTON, 
  513.  
  514. #ifdef XVIEW
  515.              PANEL_LABEL_STRING, button,       
  516. #else
  517.              PANEL_LABEL_IMAGE,panel_button_image(p->panel,button,0,0),
  518. #endif
  519.                            PANEL_NOTIFY_PROC, panel_button_notify,
  520.                            PANEL_CLIENT_DATA,p->but_count,
  521.                            PANEL_ITEM_Y, p->panel_row,
  522.                            PANEL_ITEM_X,20,
  523.                            0);
  524.    }
  525.     else
  526.    {
  527.      p->but_item[p->but_count] =  panel_create_item(p->panel, PANEL_BUTTON, 
  528.  
  529. #ifdef XVIEW
  530.              PANEL_LABEL_STRING, button,       
  531. #else
  532.              PANEL_LABEL_IMAGE,panel_button_image(p->panel,button,0,0),
  533. #endif
  534.                            PANEL_NOTIFY_PROC, panel_button_notify,
  535.                            PANEL_CLIENT_DATA,p->but_count,
  536.                            PANEL_ITEM_Y, p->panel_row,
  537.                            0);
  538.  
  539.    if ( panel_get(p->but_item[p->but_count],PANEL_ITEM_X)
  540.                            < panel_get(p->but_item[p->but_count-1],PANEL_ITEM_X) )
  541.    { /* new line */
  542.      p->panel_row += 35;
  543.      p->but_line_count = 0;
  544.      panel_set(p->but_item[p->but_count],PANEL_ITEM_Y,p->panel_row,0);
  545.      p->button_width = (int) window_get(p->panel,WIN_WIDTH) - 10;
  546.     }
  547.  
  548.   }
  549.  
  550.     p->but_line_count++;
  551.     p->but_count++;
  552.  
  553.  
  554. }
  555.  
  556.  
  557.  
  558. int x_draw_panel_button_line(p,n,buttons)
  559. leda_panel p;
  560. int n;
  561. char** buttons;
  562. { int i;
  563.   int w;
  564.   Panel_item dummy;
  565.  
  566.  
  567.  
  568.   for(i=0; i<n; i++)  x_draw_panel_button(p,buttons[i]);
  569.  
  570.   dummy =  panel_create_item(p->panel, PANEL_BUTTON, PANEL_ITEM_Y, p->panel_row, 0);
  571.  
  572.   w = (int)panel_get(dummy,PANEL_ITEM_X);
  573.  
  574.   panel_destroy_item(dummy);
  575.  
  576.   if (w < (int)panel_get(p->but_item[p->but_count-1],PANEL_ITEM_X)) 
  577.      p->button_width = (int)window_get(p->panel,WIN_WIDTH) - 10;
  578.   else
  579.      if (w > p->button_width) p->button_width = w;
  580.  
  581.   p->but_line_count = 0;
  582. }
  583.  
  584.  
  585. void x_draw_panel_label(p,label)
  586. leda_panel p;
  587. char* label;
  588. { window_set(p->panel_frame,FRAME_LABEL, label,0); }
  589.  
  590.  
  591. int x_draw_panel_open(p)
  592. leda_panel p;
  593. { Panel_item cont_but, quit_but;
  594.   Rect    *r;
  595.  
  596.   int width,height,left,top,delta;
  597.   int i;
  598.  
  599.   current_panel = p;
  600.  
  601.   if (p->but_count == 0)   /* default buttons: continue /quit */
  602.   {
  603.    p->panel_row+=50;
  604.    
  605.    cont_but = panel_create_item(p->panel, PANEL_BUTTON, 
  606.  
  607. #ifdef XVIEW
  608.              PANEL_LABEL_STRING, "continue",       
  609. #else
  610.              PANEL_LABEL_IMAGE,panel_button_image(p->panel,"continue",0,0),
  611. #endif
  612.                            PANEL_NOTIFY_PROC, panel_button_notify,
  613.                            PANEL_CLIENT_DATA,-1,
  614.                            PANEL_ITEM_Y, p->panel_row,
  615.                            PANEL_ITEM_X, 180,
  616.                   0);
  617.  
  618.    quit_but = panel_create_item(p->panel, PANEL_BUTTON, 
  619.  
  620. #ifdef XVIEW
  621.              PANEL_LABEL_STRING, "quit",       
  622. #else
  623.              PANEL_LABEL_IMAGE,panel_button_image(p->panel,"quit",0,0),
  624. #endif
  625.                            PANEL_NOTIFY_PROC, panel_button_notify,
  626.                            PANEL_CLIENT_DATA,-2,
  627.                            PANEL_ITEM_Y, p->panel_row,
  628.                     0);
  629.  
  630.    }
  631.  
  632.    else 
  633.      if (p->but_line_count > 0) x_draw_panel_button_line(p,0,0);
  634.  
  635.  
  636.  
  637. #ifndef XVIEW
  638.   panel_create_item(p->panel, PANEL_MESSAGE, 
  639.                            PANEL_LABEL_BOLD, TRUE,
  640.                            PANEL_LABEL_STRING, " ",
  641.                            PANEL_ITEM_X, 20,
  642.                            PANEL_ITEM_Y, p->panel_row+25,
  643.                        0);
  644. #endif
  645.  
  646. /*
  647.   if (grid_mode) x_draw_cursor(mouse_xreal,mouse_yreal);
  648. */
  649.  
  650.   window_fit(p->panel);
  651.   window_fit(p->panel_frame);
  652.  
  653.  
  654. /* center buttons */
  655.  
  656.    delta = ((int) window_get(p->panel,WIN_WIDTH) - p->button_width - 10)/2;
  657.  
  658.    for (i=0;i<p->but_count;i++)
  659.      if (p->but_centered[i] == 0)
  660.      { panel_set(p->but_item[i],PANEL_ITEM_X, 
  661.                  panel_get(p->but_item[i],PANEL_ITEM_X) + delta, 0);
  662.        p->but_centered[i] = 1;
  663.       }
  664.  
  665.  
  666.  
  667.   /* center the panel_frame frame on the screen */
  668.  
  669.   r = (Rect *) window_get(p->panel_frame, WIN_SCREEN_RECT);
  670.  
  671.   width = (int) window_get(p->panel_frame, WIN_WIDTH);
  672.   height = (int) window_get(p->panel_frame, WIN_HEIGHT);
  673.  
  674.   left = (r->r_width - width) / 2;
  675.   top = (r->r_height - height) / 2;
  676.  
  677.   if (left < 0) left = 0;
  678.   if (top < 0) top = 0;
  679.  
  680.   window_set(p->panel_frame, WIN_X, left, WIN_Y, top, 0);
  681.  
  682.  
  683.   window_main_loop(p->panel_frame);
  684.  
  685.   window_set(p->panel_frame,WIN_SHOW,FALSE,0);
  686.  
  687.  
  688.   if (p->but_count == 0)
  689.   { panel_destroy_item(cont_but);
  690.     panel_destroy_item(quit_but);
  691.     p->panel_row -= 50;
  692.    }
  693.  
  694. /*
  695.   if (grid_mode) x_draw_cursor(mouse_xreal,mouse_yreal);
  696. */
  697.  
  698.   if (panel_button_answer == -2) exit(0);
  699.  
  700.   return panel_button_answer;
  701.  
  702. }
  703.  
  704.