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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 查看源码
_leda_panel.c
资源名称：leda.tar.gz　[点击查看]
上传用户：gzelex
上传日期：2007-01-07
资源大小：707k
文件大小：26k
源码类别：

数值算法/人工智能

开发平台：

MultiPlatform

_leda_panel.c：源码内容
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  _leda_panel.c
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  14. // defines the LEDA_PANEL operations declared in <LEDA/leda_panel.h>
  15. // using the basic graphics routines from <LEDA/impl/x_basic.h>
  17. #include <LEDA/leda_panel.h>
  18. #include <LEDA/impl/x_basic.h>
  20. #include <stdio.h>
  21. #include <string.h>
  22. #include <ctype.h>
  23. #include <stdlib.h>
  25. enum { Text_Item, 
  26.        String_Item, 
  27.        String_Menu_Item, 
  28.        Int_Item, 
  29.        Slider_Item, 
  30.        Float_Item, 
  31.        Button_Item, 
  32.        Choice_Item,
  33.        Bool_Item,
  34.        Color_Item };
  37. static char* duplicate_string(const char* p)
  38. { char* q = new char[strlen(p)+1];
  39.   if (q==0) 
  40.   { fprintf(stderr,"duplicate_string: out of memory");
  41.     abort();
  42.    }
  43.   strcpy(q,p);
  44.   return q;
  45. }
  47. static char* make_string(int x)
  48. { char str[256];
  49.   sprintf(str,"%d",x);
  50.   return duplicate_string(str);
  51.  }
  53. static char* make_string(double x)
  54. { char str[256];
  55.   sprintf(str,"%f",x);
  56.   return duplicate_string(str);
  57.  }
  60. void LEDA_PANEL::panel_redraw_func() 
  61. { if (active_window)
  62.   { LEDA_PANEL* p = (LEDA_PANEL*)active_window; 
  63.     p->open(p->XPOS, p->YPOS, 0, 0, 0, 0, 0); 
  64.    }
  65.  }
  68. void LEDA_PANEL::init(const char* s)
  69. { open_display();
  70.   header = duplicate_string(s);
  71.   XPOS = -1;
  72.   YPOS = -1;
  73.   but_layout = 0;
  74.   item_count = 0;
  75.   but_count = 0;
  76.   win = 0;
  78.   item_bg_color  = white;
  79.   bg_color       = grey1;
  80.   press_color    = grey2;
  81.   shadow_color   = grey3;
  84.   tw = text_width("H");
  85.   th = text_height("H");
  86.   ytskip   = th + 2;
  87.   yskip    = th + 11;
  88.   bskip    = th;
  89.   yoff     = th / 2;
  90.   xoff     = tw + 2;
  91.   last_ycoord = yoff;
  93.   slider_h = th - 1;
  94.   string_h = th + 2;
  95.   button_h = th + 4;
  96.   choice_h = th + 5;
  98.   slider_w  = 200; // minimal slider length
  99.   string_w  = 200; // minimal string/int/float item length
  100.   choice_w  = 35;  // minimal choice field width
  101.   button_w  = 40;  // minimal button width
  103.   but_per_line = 0;  
  104.  }
  107. LEDA_PANEL::LEDA_PANEL(const char* s, int bl)
  108. { WIDTH  = -1;
  109.   HEIGHT = -1;
  110.   init(s);
  111.   but_per_line = (bl == 1) ? 1 : 0;
  112. }
  114. LEDA_PANEL::LEDA_PANEL(const char* s, int width, int height)
  115. { WIDTH  = width;
  116.   HEIGHT = height;
  117.   init(s);
  118.  }
  120. LEDA_PANEL::LEDA_PANEL(int width, int height)
  121. { WIDTH  = width;
  122.   HEIGHT = height;
  123.   init("");
  124.  }
  126. void LEDA_PANEL::item_error()
  127. { fprintf(stderr,"Sorry, too many items."); 
  128.   exit(1);
  129.  }
  131. void LEDA_PANEL::text_item(const char* s)
  132. { if (item_count >= MAX_ITEM_NUM) item_error();
  133.   kind[item_count] = Text_Item;
  134.   label_str[item_count] = duplicate_string(s);
  135.   data_str[item_count] = 0;
  136.   ycoord[item_count] = last_ycoord;
  137.   last_ycoord += ytskip;
  138.   item_count++;
  139. }
  142. void LEDA_PANEL::string_item(const char* s, char** x)
  143. { if (item_count >= MAX_ITEM_NUM) item_error();
  144.   label_str[item_count] = duplicate_string(s);
  145.   data_str[item_count] = duplicate_string(*x);
  146.   ref[item_count] = x;
  147.   kind[item_count] = String_Item;
  148.   ycoord[item_count] = last_ycoord;
  149.   last_ycoord += yskip;
  150.   item_count++;
  151.  }
  154. void LEDA_PANEL::string_menu_item(const char* s, char** x, const char* ,
  155.                                   int argc,const char** argv)
  156. { 
  157.   if (item_count >= MAX_ITEM_NUM) item_error();
  158.   label_str[item_count] = duplicate_string(s);
  159.   data_str[item_count] = duplicate_string(*x);
  160.   ref[item_count] = x;
  161.   kind[item_count] = String_Menu_Item;
  162.   dat1[item_count] = argc;
  163.   choices[item_count] = new char*[argc];
  164.   for(int i = 0; i < argc; i++) 
  165.      choices[item_count][i] = duplicate_string(argv[i]);
  166.   ycoord[item_count] = last_ycoord;
  167.   last_ycoord += yskip;
  168.   item_count++;
  169.  }
  172. void LEDA_PANEL::int_item(const char* s, int* x)
  173. { if (item_count >= MAX_ITEM_NUM) item_error();
  174.   label_str[item_count] = duplicate_string(s);
  175.   data_str[item_count] = make_string(*x);
  176.   ref[item_count] = x;
  177.   kind[item_count] = Int_Item;
  178.   ycoord[item_count] = last_ycoord;
  179.   last_ycoord += yskip;
  180.   item_count++;
  181.  }
  183. void LEDA_PANEL::float_item(const char* s, double* x)
  184. { if (item_count >= MAX_ITEM_NUM) item_error();
  185.   label_str[item_count] = duplicate_string(s);
  186.   data_str[item_count] = make_string(*x);
  187.   ref[item_count] = x;
  188.   kind[item_count] = Float_Item;
  189.   ycoord[item_count] = last_ycoord;
  190.   last_ycoord += yskip;
  191.   item_count++;
  192.  }
  194. void  LEDA_PANEL::slider_item(const char* s, int* x, int min, int max, action_func F)
  195. { if (item_count >= MAX_ITEM_NUM) item_error();
  196.   label_str[item_count] = duplicate_string(s);
  197.   data_str[item_count] = make_string(*x);
  198.   ref[item_count] = x;
  199.   dat1[item_count] = min;
  200.   dat2[item_count] = max;
  201.   kind[item_count] = Slider_Item;
  202.   ycoord[item_count] = last_ycoord;
  203.   action[item_count] = F;
  204.   last_ycoord += yskip;
  205.   item_count++;
  206.  }
  208. void LEDA_PANEL::choice_item(const char* s, int* address, int argc,
  209.                              const char** argv, int step, int off)
  210. { 
  211.   if (item_count >= MAX_ITEM_NUM) item_error();
  212.   label_str[item_count] = duplicate_string(s);
  213.   data_str[item_count] = 0;
  214.   kind[item_count] = Choice_Item;
  215.   ref[item_count] = address;
  216.   dat1[item_count] = argc;
  217.   dat2[item_count] = step;
  218.   offset[item_count] = off;
  219.   choices[item_count] = new char*[argc];
  220.   for(int i=0; i<argc; i++) choices[item_count][i] = duplicate_string(argv[i]);
  221.   ycoord[item_count] = last_ycoord;
  222.   last_ycoord += yskip;
  223.   item_count++;
  224.  }
  227. void LEDA_PANEL::bool_item(const char* s, char* address)
  228. { if (item_count >= MAX_ITEM_NUM) item_error();
  229.   label_str[item_count] = duplicate_string(s);
  230.   data_str[item_count] = 0;
  231.   kind[item_count] = Bool_Item;
  232.   ref[item_count] = address;
  233.   dat1[item_count] = 2;
  234.   dat2[item_count] = 1;
  235.   offset[item_count] = 0;
  236.   choices[item_count] = new char*[2];
  237.   choices[item_count][0] = duplicate_string("off");
  238.   choices[item_count][1] = duplicate_string("on");
  239.   ycoord[item_count] = last_ycoord;
  240.   last_ycoord += yskip;
  241.   item_count++;
  242.  }
  245. void LEDA_PANEL::color_item(const char* s, int* x)
  246. { if (item_count >= MAX_ITEM_NUM) item_error();
  247.   label_str[item_count] = duplicate_string(s);
  248.   data_str[item_count] = 0;
  249.   ref[item_count] = x;
  250.   if (display_depth() > 1)
  251.      kind[item_count] = Color_Item;
  252.   else 
  253.    { // choice item [white][black]
  254.      kind[item_count] = Choice_Item;
  255.      dat1[item_count] = 2;
  256.      dat2[item_count] = 1;
  257.      offset[item_count] = 0;
  258.      choices[item_count] = new char*[2];
  259.      choices[item_count][0] = duplicate_string("white");
  260.      choices[item_count][1] = duplicate_string("black");
  261.     }
  262.   ycoord[item_count] = last_ycoord;
  263.   last_ycoord += yskip;
  264.   item_count++;
  265.  }
  269. int LEDA_PANEL::button(const char* s)
  270. { if (but_count == MAX_BUT_NUM) return -1;
  271.   // space before first line of buttons
  272.   if (but_count==0 && item_count>0)  text_item(""); 
  273.   button_str[but_count] = duplicate_string(s);
  274.   return but_count++;
  275.  }
  278. void  LEDA_PANEL::button_line(int n, const char** b) 
  279. { for(int i=0; i<n; i++) button(b[i]); }
  282. void LEDA_PANEL::draw_box_with_shadow(int x1,int y1,int x2,int y2,int c,int w)
  283. { // below and right of box(x1,y1,x2,y2)
  284.   ::set_color(shadow_color);
  285.   box(win,x1+3,y1+3,x2+w,y2+w);
  286.   ::set_color(c);
  287.   box(win,x1,y1,x2,y2);
  288.   ::set_color(black);
  289.   rectangle(win,x1,y1,x2,y2);
  290.  }
  293. void LEDA_PANEL::draw_d3_box(int x1,int y1,int x2,int y2, int pressed)
  294. {
  295.   ::set_color(bg_color);
  296.   box(win,x1,y1,x2,y2);
  298.    //if (pressed) { x1++; y1++; x2++; y2++; }
  299.    if (pressed) { x1++; y1++; }
  301.    int c1 = (pressed) ? shadow_color : white;
  302.    int c2 = (pressed) ? white        : shadow_color;
  303.    int c3 = (pressed) ? press_color  : bg_color;
  306.    ::set_color(c3);
  307.    box(win,x1,y1,x2,y2);
  309.    ::set_color(c1);
  310.    line(win,x1,y1,x2,y1);
  311.    line(win,x1,y1,x1,y2);
  313.    ::set_color(c2);
  314.    line(win,x1+1,y2,x2,y2);
  315.    line(win,x2,y1+1,x2,y2);
  317.   ::set_color(black);
  318. }
  322. void LEDA_PANEL::draw_string_item(int i,int active, const char* s)
  323. { 
  324.   int  yt = ycoord[i] + (yskip-th)/2;
  325.   put_text(win,xoff,yt,label_str[i],0);
  327.   int x1 = xoff1;
  328.   int x2 = x1 + string_w;
  329.   int y1 = yt - (string_h-th)/2 - 1;
  330.   int y2 = yt + string_h + (string_h-th)/2;
  331.   
  332.   if (s == 0)  s = data_str[i];
  334.   int max_c = string_w/tw - 1;
  335.   int d = strlen(s) - max_c;
  337.   if (active && d > 0) s += d;
  339.   if (bg_color == white)
  340.     { ::set_color(bg_color);
  341.       box(win,x1,y1,x2,y2);
  342.       ::set_color(black);
  343.       rectangle(win,x1,y1,x2,y2);
  344.      }
  345.   else
  346.     draw_d3_box(x1,y1,x2,y2,active);
  348.   // write text into box
  349.   ::set_color(black);
  350.   put_text(win,x1+4,yt,s,max_c,0);
  352.   if (active) put_text(win,x1+4+strlen(s)*tw,yt,"|",0);
  353. }
  358. void LEDA_PANEL::activate_string_item(int n)
  359. { if (n == act_str_item) return;
  360.   if (act_str_item > -1) 
  361.     draw_string_item(act_str_item);
  362.   draw_string_item(n,1);
  363.   act_str_item = n;
  364.  }
  365.    
  367. void LEDA_PANEL::panel_text_edit(int n)
  368. { 
  369.   int h  = yskip-8;
  370.   int y  = ycoord[n] + 4;
  371.   int yt = y + (h - th)/2 + 1;
  372.   int max_c = string_w/tw - 1;
  374.   char  str[128];
  375.   strcpy(str,data_str[n]);
  376.   int j = strlen(str);
  378.   for(;;)
  379.   { int  k,val;
  380.     char c = 13;
  382.     ::set_read_gc();
  384.     while(1)
  385.     { Window w;
  386.       int xc,yc;
  387.       unsigned long t;
  388.       k = get_next_event(&w,&val,&xc,&yc,&t);
  389.       if (w != win) continue;
  390.       if (k == key_press_event || k == button_press_event) break;
  391.      }
  393.      reset_gc();
  395.      if (k == key_press_event) c = val;
  396.      if (c == 13) 
  397.      { put_back_event();
  398.        break;
  399.       }
  401.      if (isprint(c))
  402.      { str[j++]=c;
  403.        str[j] = '';
  404.       }
  406.      if(c==8 && j>0) str[--j] = '';
  408.      draw_string_item(n,1,str);
  409.    }
  411.   delete data_str[n];
  412.   data_str[n] = duplicate_string(str);
  413. }
  416. void LEDA_PANEL::draw_choice_bool_item(int i, int x, int y, int c, int n)
  417. {
  418.   ::set_color(bg_color);
  419.   box(win,x,y,x+n*choice_w,y+choice_h);
  421.   int j;
  423.   if (bg_color != white)
  424.      for(j=0; j<n; j++)
  425.      { draw_d3_box(x,y,x+choice_w-1,y+choice_h,j==c);
  426.        ::set_color(black);
  427.        put_ctext(win,x+choice_w/2,y+choice_h/2,choices[i][j],0);
  428.        x += choice_w;
  429.       }
  430.   else
  431.     for(j=0; j<n; j++)
  432.     { ::set_color(item_bg_color);
  433.       box(win,x+1,y+1,x+choice_w-1,y+choice_h-1);
  434.       ::set_color(black);
  435.       put_ctext(win,x+choice_w/2,y+choice_h/2,choices[i][j],0);
  436.       if (bg_color == item_bg_color) rectangle(win,x,y,x+choice_w,y+choice_h);
  437.       if(j == c) 
  438.       { rectangle(win,x,y,x+choice_w,y+choice_h);
  439.         rectangle(win,x+1,y+1,x+choice_w-1,y+choice_h-1);
  440.        }
  441.       x += choice_w;
  442.      }
  444. }
  448. void LEDA_PANEL::draw_choice_item(int i)
  449. { 
  450.   int yt = ycoord[i] + (yskip-th)/2;
  451.   put_text(win,xoff,yt,label_str[i],0);
  453.   int y = yt - (choice_h-th)/2 - 1;
  454.   int c = (*(int*)ref[i]-offset[i])/dat2[i];
  456.   draw_choice_bool_item(i,xoff1,y,c,dat1[i]);
  457. }
  460. #if !(defined(__GNUC__) && __GNUC_MINOR__ > 5)
  461. typedef char bool;
  462. #endif
  465. void LEDA_PANEL::draw_bool_item(int i)
  466. { 
  467.   int yt = ycoord[i] + (yskip-th)/2 + 1;
  468.   put_text(win,xoff,yt,label_str[i],0);
  470.   int y = yt - (choice_h-th)/2;
  471.   int c = (*(bool*)ref[i]-offset[i])/dat2[i];
  473.   draw_choice_bool_item(i,xoff1,y,c,dat1[i]);
  474. }
  477. void LEDA_PANEL::change_color_item(int i, int j)
  478. { int yt = ycoord[i] + (yskip-th)/2 + 1;
  479.   int y = yt - (choice_h-th)/2 - 1;
  480.   int old = *(int*)ref[i];
  482.   *(int*)ref[i] = j;
  484.   char col_str[8];
  486.   int x = xoff1 + j*choice_h;
  487.   sprintf(col_str,"%d",j);
  488.   press_color = j;
  489.   draw_d3_box(x,y,x+choice_h-1,y+choice_h-1,1);
  490.   ::set_color((j==black) ? white : black);
  491.   put_ctext(win,x+choice_h/2,y+choice_h/2,col_str,0);
  493.   j = old;
  494.   x = xoff1 + j*choice_h;
  495.   sprintf(col_str,"%d",j);
  496.   press_color = grey2;
  497.   draw_d3_box(x,y,x+choice_h-1,y+choice_h-1,0);
  498.   ::set_color((j==bg_color) ? black : j);
  499.   put_ctext(win,x+choice_h/2,y+choice_h/2,col_str,0);
  501.   ::set_color(black);
  502. }
  505. void LEDA_PANEL::draw_color_item(int i)
  506. { 
  507.   int yt = ycoord[i] + (yskip-th)/2 + 1;
  508.   int x = xoff1;
  509.   int y = yt - (choice_h-th)/2 - 1;
  511.   put_text(win,xoff,yt,label_str[i],0);
  513.   char c = *(int*)ref[i];
  516.   ::set_color(bg_color);
  517.   box(win,x,y,x+16*choice_h,y+choice_h);
  519.   for(int j=0; j < 16; j++)
  520.   { char col_str[8];
  521.     sprintf(col_str,"%d",j);
  522.     press_color = j;
  523.     draw_d3_box(x,y,x+choice_h-1,y+choice_h-1,j==c);
  524.     if (j != c)
  525.       ::set_color((j==bg_color) ? black : j);
  526.     else
  527.       ::set_color((j==black) ? white : black);
  528.     put_ctext(win,x+choice_h/2,y+choice_h/2,col_str,0);
  529.     x += choice_h;
  530.    }
  531.   press_color = grey2;
  532.   ::set_color(black);
  534.   //end_group(win);
  535. }
  539. void LEDA_PANEL::draw_slider_item(int i, float x)
  540. { 
  541.   int x0 = xoff1;
  542.   int x1 = x0 + slider_w;
  543.   int y0 = ycoord[i] + (yskip-slider_h)/2 + 1;
  544.   int y1 = y0 + slider_h;
  545.   int yt = ycoord[i] + (yskip-th)/2 + 1;
  547.   if (x == 0) // first time
  548.   { float d = float(slider_w)/(dat2[i]-dat1[i]);
  549.     x = xoff1 + d * (*(int*)ref[i]-dat1[i]);
  550.     put_text(win,xoff,yt,label_str[i],0);
  551.    }
  553.   float mi = dat1[i];
  554.   float ma = dat2[i];
  556.   if (x < x0) x = x0;
  557.   if (x > x1) x = x1;
  559.   int val = int(mi + (ma-mi)*(x-x0)/slider_w + 0.5);
  561.   if (action[i]) action[i](val);
  563.   *(int*)ref[i] = val;
  565.   // text
  566.   char text[16];
  567.   sprintf(text,"%4d",val);
  568.   int t_w = text_width(text) + 3;
  569.   int t_h = text_height(text);
  570.   ::set_color(bg_color);
  571.   box(win,x0-t_w,y0,x0,y0+t_h);
  572.   ::set_color(black);
  573.   put_text(win,x0-t_w,yt,text,0);
  575.   // slider
  576.   if (bg_color == white)
  577.     { ::set_color(black);
  578.       box(win,x0,y0,int(x+0.5),y1);
  579.       ::set_color(white);
  580.       box(win,int(x+0.5),y0,x1,y1);
  581.       ::set_color(black);
  582.       rectangle(win,x0,y0,x1,y1);
  583.      }
  584.   else
  585.     { draw_d3_box(int(x+0.5),y0,x1,y1,1);
  586.       draw_d3_box(x0,y0,int(x+0.5)+1,y1);
  587.      }
  588.   ::set_color(black);
  590. }
  593. void LEDA_PANEL::draw_button(const char* s, int x, int y, int pressed)
  594. { 
  595.    int x1 = x+1;
  596.    int y1 = y+4;
  597.    int x2 = x1 + button_w;
  598.    int y2 = y1 + button_h + 1;
  599.    int yt = y1 + button_h/2;
  600.    int xt = x1 + button_w/2;
  602.    if (bg_color == white)
  603.      { draw_box_with_shadow(x1,y1,x2,y2,white,3);
  604.        if (pressed)
  605.        { box(win,x1+1,y1+1,x2-1,y2-1);
  606.          ::set_color(white);
  607.         }
  608.        put_ctext(win,xt,yt,s,0);
  609.       }
  610.    else
  611.      { draw_d3_box(x1,y1,x2,y2,pressed);
  612.        ::set_color(black);
  613.        put_ctext(win,xt,yt,s,0);
  614.       }
  615.    ::set_color(black);
  616.    flush_display();
  617. }
  623. void LEDA_PANEL::draw_menu_button(int x, int y, int pressed)
  624. { 
  625.   int x1 = x;
  626.   int y1 = y+4;
  627.   int x2 = x1+string_h;
  628.   int y2 = y1+string_h;
  630.   ::set_color(bg_color);
  631.   box(win,x1,y1,x2,y2);
  633.   if (bg_color == item_bg_color)
  634.   { ::set_color(black);
  635.     rectangle(win,x1,y1,x2,y2);
  636.   }
  638.   if (pressed) 
  639.   { ::set_color(black);
  640.     box(win,x1+1,y1+1,x2-1,y2-1);
  641.    }
  643.   y1 += 3;
  644.   y2 -= 3;
  645.   x1 += 4;
  647.   ::set_color(shadow_color);
  648.   line(win,x1,y1,x1,y2-1);
  649.   x1++;
  650.   y1++;
  651.   y2--;
  653.   ::set_color(item_bg_color);
  654.   while (y1 <= y2)
  655.   { ::set_color(item_bg_color);
  656.     line(win,x1,y1,x1,y2);
  657.     x1++;
  658.     line(win,x1,y1,x1,y2);
  659.     ::set_color(shadow_color);
  660.     pixel(win,x1-1,y1);
  661.     pixel(win,x1,  y1);
  662.     ::set_color(white);
  663.     pixel(win,x1-1,y2);
  664.     pixel(win,x1,  y1);
  665.     x1++;
  666.     y1++;
  667.     y2--;
  668.    }
  670.   flush_display();
  671. }
  674. static int read_panel_at(const char* header, int n, char** but,int x, int y)
  675. { LEDA_PANEL p(header);
  676.   for(int i=0; i<n; i++) p.button(but[i]);
  677.   return p.open(x,y,0,0,0,0,3);
  678.  }
  681. int  LEDA_PANEL::open(int xpos, int ypos, int win_x, int win_y, 
  682.                       int win_width, int win_height, int mode)
  683. {
  686.   // mode = 0:  just display panel window  on screen
  687.   // mode = 1:  display, read (blocking), and close 
  688.   // mode = 2:  read
  689.   // mode = 3:  display, read (non-blocking) , and close
  691.   if (display_depth() == 1)
  692.   { bg_color = white;   
  693.     shadow_color = black;   
  694.     item_bg_color = white;   
  695.    }
  697. repaint:
  699.   slider_w  = 200; // minimal slider length
  700.   string_w  = 200; // minimal string/int/float item length
  701.   choice_w  = 30;  // minimal choice field width
  702.   button_w  = 40;  // minimal button width
  703.   xoff1 = 0;       // start of items
  704.   bxoff = 0;       // left and right button boundary space
  706.   int width = (win) ? ::window_width(win) : 100;
  707.   int height; 
  709.   int   bw1;              /* button_w + bskip   */
  710.   int   but_lines;
  711.   int   but,w,i,j;
  713.   unsigned long t;
  715.   int user_buttons = but_count;
  716.   int save_lw = ::set_line_width(1);
  717.   int save_ls = ::set_line_style(0);
  718.   int save_mo = ::set_mode(0);
  720.   if (but_count==0)
  721.   { button("CONTINUE");
  722.     button("QUIT");
  723.    }
  726.   height = 2*yoff;
  728.   for(i=0;i<item_count; i++)
  729.     if (kind[i] != Text_Item)
  730.        { height += yskip;
  731.          if ((w = text_width(label_str[i])+50) > xoff1) xoff1 = w;
  732.  
  733.          if (kind[i] == Choice_Item || kind[i] == Bool_Item)
  734.          { int j;
  735.            for(j=0; j<dat1[i];j++)
  736.            if ((w = text_width(choices[i][j])+10) > choice_w) choice_w = w;
  737.           }
  738.        }
  739.     else
  740.        height += ytskip;
  743.   // adjust width of buttons
  745.   for(i=0; i < but_count; i++)
  746.      if ((w = text_width(button_str[i])+10) > button_w) button_w = w;
  748.   bw1 = button_w + bskip;
  753.   // adjust panel width
  755.   if ((w = text_width(header)) > width) width = w;
  757.   if ((w = but_per_line*bw1+2*xoff) > width) width = w;
  759.   for(i=0; i<item_count; i++)
  760.     switch (kind[i])
  761.     {
  762.       case  Text_Item:
  763.                   if ((w = 2*xoff + text_width(label_str[i])) > width) width=w;
  764.                   break;
  766.       case Choice_Item:
  767.                  if ((w = xoff1+choice_w*dat1[i]+yskip+xoff) > width) width = w;
  768.                  break;
  770.       case Color_Item:
  771.                  if ((w = xoff1+16*choice_h+yskip+xoff) > width) width = w;
  772.                  break;
  774.       case Slider_Item:
  775.                  if ((w = xoff1+slider_w+yskip+xoff) > width) width = w;
  776.                  break;
  778.       case String_Menu_Item:
  779.                  if ((w = xoff1+string_w+2*yskip+xoff) > width) width = w;
  780.                  break;
  783.       default:   if ((w = xoff1+string_w+yskip+xoff) > width) width = w;
  784.                  break;
  785.      }
  787.   // adjust width of slider & string boxes
  789.   w = width-xoff1-2*yskip;
  790.   if (w > slider_w) slider_w = w;
  791.   if (w > string_w) string_w = w;
  794.   // center buttons
  796.   if (but_per_line == 0)
  797.   { but_per_line = (width-2*xoff+bskip)/bw1;
  798.     if (but_per_line == 0)
  799.     { but_per_line = 1;
  800.       width = button_w + 2*xoff;
  801.      }
  802.    }
  803.     
  805.   but_lines = but_count/but_per_line;
  807.   if (but_count % but_per_line) but_lines++;
  809.   if (but_lines == 1)
  810.      bxoff = (width - but_count * bw1 + bskip)/2;
  811.   else
  812.      bxoff = (width - but_per_line * bw1 + bskip)/2;
  815.   height += but_lines * yskip;
  816.   height += yoff;
  818.   for (i=0; i< but_lines; i++)
  819.      kind[item_count+i] = Button_Item;
  822.   if (WIDTH  == -1)  WIDTH  = width;
  823.   if (HEIGHT == -1)  HEIGHT = height;
  826.   if(XPOS == -1)
  827.     if (xpos == -1)
  828.       if (win_width == 0)
  829.          { /* center panel window on the screen */
  830.            XPOS = (display_width() - WIDTH)/2;
  831.            YPOS = (display_height() - HEIGHT)/2;
  832.           }
  833.       else
  834.          { /* center panel window on draw window */
  835.            XPOS = win_x + (win_width - WIDTH)/2;
  836.            YPOS = win_y + (win_height- HEIGHT)/2;
  837.           }
  838.     else /* use supplied coordinates */
  839.       { XPOS = xpos;
  840.         YPOS = ypos;
  841.        }
  844.   if (win==0) 
  845.   { LEDA_WINDOW::open(WIDTH,HEIGHT,XPOS,YPOS,header,bg_color);
  846.     set_show_coordinates(0);
  847.     set_redraw(panel_redraw_func);
  848.     win = draw_win;
  849.    }
  851.   //clear_window(win);
  853.   act_str_item = -1;
  855.   ::set_color(1);
  857.   int y = yoff;
  859.   for(i=0;i<item_count; i++)
  860.   {
  861.     switch (kind[i]) {
  863.     case Text_Item:
  864.         { put_text(win,xoff,ycoord[i],label_str[i],0);
  865.           break;
  866.          }
  868.     case Choice_Item:
  869.         { draw_choice_item(i);
  870.           break;
  871.          }
  873.     case Bool_Item:
  874.         { draw_bool_item(i);
  875.           break;
  876.          }
  878.     case Color_Item:
  879.         { draw_color_item(i);
  880.           break;
  881.          }
  883.     case Slider_Item:
  884.         { draw_slider_item(i,0);
  885.           break;
  886.          }
  888.     case Int_Item:
  889.         { draw_string_item(i);
  890.           if (act_str_item == -1) activate_string_item(i);
  891.           break;
  892.          }
  893.  
  894.     case Float_Item:
  895.         { draw_string_item(i);
  896.           if (act_str_item == -1) activate_string_item(i);
  897.           break;
  898.          }
  899.   
  900.     case String_Item:
  901.         { draw_string_item(i);
  902.           if (act_str_item == -1) activate_string_item(i);
  903.           break;
  904.          }
  906.     case String_Menu_Item:
  907.         { draw_string_item(i);
  908.           draw_menu_button(xoff1+string_w+6,ycoord[i],0);
  909.           if (act_str_item == -1) activate_string_item(i);
  910.           break;
  911.          }
  912.    }
  914.    y += ((kind[i] == Text_Item) ?  ytskip : yskip);
  916.   }
  919.   // place buttons
  921.   //int y = ycoord[item_count-1];
  922.   y -= yskip;
  923.   int x = bxoff;
  925.   for(i=0; i < but_count; i++)
  926.   { if (i % but_per_line == 0)
  927.     { y += yskip;
  928.       x = bxoff;
  929.      }
  930.     draw_button(button_str[i],x,y,0);
  931.     x += bw1;
  932.   }
  934.   but = -1;
  936.   if (mode == 0) goto end;
  939.   while(but == -1)
  940.   { int b;
  941.     i = -1;
  943.     while (i < 0 || i >= item_count+but_lines)
  944.     { int k;
  945.       ::set_read_gc();
  946.       while (1)
  947.       { Window w;
  948.         k = get_next_event(&w,&b,&x,&y,&t);
  949.         if (w == win)
  950.         { if (k == button_press_event || k == key_press_event) break;
  951.           if (k == configure_event) 
  952.           { reset_gc();
  953.             goto repaint;
  954.            }
  955.          }
  956.         else
  957.           if (mode == 3 && k==button_press_event) 
  958.           { put_back_event();
  959.             reset_gc();
  960.             goto end;
  961.            }
  962.        }
  963.       reset_gc();
  965.       if (k==button_press_event)
  966.         { for(i=0,j=yoff;i<item_count+but_lines && j<y; i++)
  967.             if (kind[i] == Text_Item)
  968.                j += ytskip;
  969.             else
  970.                j += yskip;
  971.   
  972.            if (j >=y) i--;
  973.          }
  974.        else  /* key pressed */
  975.        if (act_str_item > -1)
  976.        { if (b == 13) // return key pressed
  977.          { j = act_str_item;
  978.            for(;;)
  979.            { j = (j + 1) % item_count;
  980.              k =  kind[j]; 
  981.              if (k==String_Item || k==String_Menu_Item || 
  982.                  k==Int_Item || k == Float_Item) break;
  983.              }
  984.            activate_string_item(j);
  985.          }
  986.          else
  987.          { x = xoff1;
  988.            i = act_str_item;
  989.            for(k=0,j=yoff; k <= i; k++)
  990.             if (kind[k] == Text_Item)
  991.                j += ytskip;
  992.             else
  993.                j += yskip;
  994.            put_back_event();
  995.           }
  996.        }
  997.      }
  999.     y  = j-yskip;
  1001.     switch (kind[i]) {
  1003.     case Text_Item: break;
  1005.     case Slider_Item:
  1006.     { Window w = win;
  1007.       int xx = 0;
  1008.       if (x < xoff1 || x > xoff1+slider_w) break;
  1009.       ::set_read_gc();
  1010.       while(w == win)
  1011.       { if (xx != x)
  1012.         { xx = x;
  1013.           reset_gc();
  1014.           draw_slider_item(i,xx);
  1015.           ::set_read_gc();
  1016.          }
  1017.         if (get_next_event(&w,&b,&x,&j,&t) == button_release_event) break;
  1018.        }
  1019.       reset_gc();
  1020.       break;
  1021.      }
  1023.     case Int_Item:
  1024.     { activate_string_item(i);
  1025.       panel_text_edit(i);
  1026.       int x = atoi(data_str[i]);
  1027.       delete data_str[i];
  1028.       data_str[i] = make_string(x);
  1029.       *(int*)ref[i] = x;
  1030.       break;
  1031.      }
  1033.     case Float_Item:
  1034.     { activate_string_item(i);
  1035.       panel_text_edit(i);
  1036.       double x = (double)atof(data_str[i]);
  1037.       delete data_str[i];
  1038.       data_str[i] = make_string(x);
  1039.       *(double*)ref[i] = x;
  1040.       break;
  1041.      }
  1043.     case String_Item:
  1044.     { activate_string_item(i);
  1045.       panel_text_edit(i);
  1046.       delete *(char**)ref[i];
  1047.       *(char**)ref[i] = duplicate_string(data_str[i]);
  1048.       break;
  1049.      }
  1051.     case String_Menu_Item:
  1052.     { activate_string_item(i);
  1053.       if (x < xoff1+string_w+10)
  1054.          { panel_text_edit(i);
  1055.            delete *(char**)ref[i];
  1056.            *(char**)ref[i] = duplicate_string(data_str[i]);
  1057.           }
  1058.       else
  1059.          { Window w;
  1060.            draw_menu_button(xoff1+string_w+6,y,1);
  1061.            while (get_next_event(&w,&b,&x,&j,&t) != button_release_event);
  1062.            draw_menu_button(xoff1+string_w+6,y,0);
  1063.            int sel = read_panel_at(label_str[i],dat1[i],choices[i],
  1064.                                    XPOS+xoff1+string_w+16, YPOS+y+24);
  1065.            if (sel > -1)
  1066.            { delete *(char**)ref[i];
  1067.              *(char**)ref[i] = duplicate_string((choices[i])[sel]);
  1068.              data_str[i] = duplicate_string((choices[i])[sel]);
  1069.              draw_string_item(i,1);
  1070.             }
  1071.           }
  1072.       break;
  1073.     }
  1076.    case Choice_Item:
  1077.    { j = (x-xoff1)/choice_w;
  1078.      if (j >= 0 && j<dat1[i])
  1079.      { *(int*)ref[i] = offset[i] + j * dat2[i];
  1080.        draw_choice_item(i);
  1081.       }
  1082.      break;
  1083.     }
  1085.    case Bool_Item:
  1086.    { j = (x-xoff1)/choice_w;
  1087.      if (j >= 0 && j<dat1[i])
  1088.      { *(char*)ref[i] = offset[i] + j * dat2[i];
  1089.        draw_bool_item(i);
  1090.       }
  1091.      break;
  1092.     }
  1094.    case Color_Item:
  1095.    { j = (x-xoff1)/choice_h;
  1096.      if (0 <= j && j <= 15) change_color_item(i,j);
  1097.      break;
  1098.     }
  1100.    case Button_Item:
  1101.    { j = (x-bxoff)/bw1;
  1102.      i = (i-item_count)*but_per_line +j;
  1103.      if (x > bxoff && j < but_per_line && i < but_count)
  1104.      { Window w;
  1105.        draw_button(button_str[i],bxoff+j*bw1,y,1);
  1106.        while (get_next_event(&w,&b,&b,&b,&t) != button_release_event);
  1107.        but = i;
  1108.        //if (mode == 2) draw_button(button_str[i],bxoff+j*bw1,y,1);
  1109.       }
  1110.      break;
  1111.     }
  1113.    }
  1115.    if (mode == 2) break; // no button click neccessary
  1117.  } // while but == -1
  1120.  if (mode == 2) // redisplay  (mode = 0)
  1121.      open(XPOS,YPOS,0,0,0,0,0);
  1123. end:
  1124. /*
  1125.   window_position(win,&(XPOS),&(YPOS));
  1126. */
  1128.   ::set_line_width(save_lw);
  1129.   ::set_line_style(save_ls);
  1130.   ::set_mode(save_mo);
  1132.   if (user_buttons == 0)
  1133.   { but_count = 0;
  1134.     item_count--;
  1135.     if (but == 1)   /* quit button pressed */
  1136.     { close_display();
  1137.       exit(0);
  1138.      }
  1139.    }
  1141.   if (mode == 1 || mode == 3) close();
  1143.   return but;
  1144. }
  1147. void LEDA_PANEL::display(int xpos, int ypos, int win_x, int win_y, int win_width, int win_height)
  1148. { open(xpos, ypos, win_x, win_y, win_width, win_height, 0); }
  1150. /*
  1151. int  LEDA_PANEL::read(int xpos, int ypos, int win_x, int win_y, int win_width, int win_height)
  1152. { return open(xpos, ypos, win_x, win_y, win_width, win_height, 2); }
  1153. */
  1155. int  LEDA_PANEL::read() { return open(XPOS,YPOS,0,0,0,0,2); }
  1159. void  LEDA_PANEL::close() 
  1160. { LEDA_WINDOW::close();
  1161.   win = 0;
  1162.  }
  1166. LEDA_PANEL::~LEDA_PANEL() 
  1167. { delete header; 
  1168.   for(int i = 0; i<item_count; i++)
  1169.   { if (label_str[i]) delete label_str[i];
  1170.     if (data_str[i]) delete data_str[i];
  1171.     if (kind[i] == String_Menu_Item || 
  1172.         kind[i] == Choice_Item || 
  1173.         kind[i] == Bool_Item    )
  1174.       { for(int j = 0; j < dat1[i]; j++) delete choices[i][j];
  1175.         delete choices[i];
  1176.        }
  1177.    }
  1178.   for(int j = 0; j<but_count; j++) delete button_str[j];
  1179. }