trimesh.fl

# data file for the Fltk User Interface Designer (fluid)
version 1.0305
header_name {.h}
code_name {.cc}
decl {\#include "Surfaces.h"} {public local
}

decl {\#include <vector>} {private local
}

decl {\#include<list>} {public global
}

decl {\#include <algorithm>} {private local
}

decl {class TBmeshWin;} {public local
}

decl {\#include "HDF5DataBrowser.h"} {private local
}

decl {class IsoSurface;} {public local
}

decl {class ObjProps;} {public local
}

decl {\#define MaxRecentSz 10} {private local
}

decl {enum DATA_SET_TYPE { ASCII, IGB, AUX, DYN_PTS, HDF5, VECT };} {public global
}

decl {\#define SAVE_WIDGET(f,a) f<<\#a<<" = "<<double(a->value())<<endl;} {private local
}

decl {\#define TEST_VAR(A,B,C) if(!strcmp(\#A,B)){A->value(C);A->do_callback();continue;}} {private local
}

decl {\#define TEST_RADIO(A,B,C,D) if(!strcmp(\#A,B)){if(C){A->setonly();A->do_callback(D);}continue;}} {private local
}

decl {\#define TEST_CHOICE(A,B,C) if(!strcmp(\#A,B)){A->value(C);A->mvalue()->do_callback(A);continue;}} {private local
}

decl {\#define TEST_MENUVAR(A,B,C,D) if(!strcmp(\#A,B)){if(C)A->set();else A->clear();if(A->callback())A->do_callback(D);continue;}} {private local
}

decl {\#define IGNORE_VAR(A,B) if(!strcmp(\#A,B)){continue;}} {private local
}

decl {\#define MAX_INIT_VECS 200000} {private local
}

decl {\#include "Model.h"} {public local
}

decl {\#include <string>} {private local
}

decl {\#include <set>} {private local
}

decl {\#include "colourchoice.h"} {public local
}

decl {\#include "FlyBy.h"} {public global
}

class Meshwin {open
} {
  Function {Meshwin()} {open
  } {
    Fl_Window winny {
      label meshalyzer
      callback {if( fl_choice("Really quit?","No","Yes",0) ){
delete trackballwin;
exit(0);
}} open
      xywh {160 153 455 455} type Double hide resizable hotspot
    } {
      Fl_Box trackballwin {
        callback {if( fl_choice("Really quit?","No","Yes",0 ) ) 
{
Fl_Window *pw = Fl::first_window();
  while (pw){
    pw->hide();
    pw = Fl::first_window();
  }
}}
        xywh {0 0 455 455}
        code0 {\#include "TBmeshWin.h"}
        class TBmeshWin
      }
    }
    code {winny->resizable(trackballwin);
winny->size_range(50,50,1600,1600,5,5,1);
trackballwin->mode(FL_RGB|FL_DOUBLE|FL_DEPTH|FL_ALPHA|FL_OPENGL3|FL_MULTISAMPLE);} {}
  }
  Function {~Meshwin()} {open return_type virtual
  } {
    code {if(trackballwin) {
  delete trackballwin;
}} {}
  }
}

class Controls {open
} {
  decl {std::list<pair <string,Fl_Callback*>>recentLst;} {private local
  }
  decl {friend class ObjProps;} {private local
  }
  Function {Controls()} {open
  } {
    Fl_Window window {
      label {Meshalyzer Controls} open
      xywh {234 64 350 705} type Double box UP_BOX
      code0 {\#include <FL/Fl_Color_Chooser.H>}
      code1 {\#include "VecData.h"} visible
    } {
      Fl_Menu_Bar mainbar {
        xywh {0 0 350 30} labelcolor 1
      } {
        Submenu {} {
          label File
          xywh {0 0 100 20}
        } {
          MenuItem {} {
            label {Add surface}
            callback {char *fn=fl_file_chooser("Surface", "*.{tris,surf,tri}",NULL);
int sn;
if( fn != NULL ) {
  if( (sn=mwtb->add_surface(fn))>0 ) {
    for( int s=0; s<sn; s++ ) {
      surflist->add(mwtb->model->surface(surflist->nitems())->label().c_str(),1);
    }
    elehi->activate();
    elehi->maximum(mwtb->model->number(SurfEle)-1);
    mwtb->redraw(VBO_Visible);
    surflist->redraw();
  }
}}
            xywh {0 0 100 20}
          }
          MenuItem {} {
            label {Compute surfaces}
            callback {fl_cursor( FL_CURSOR_WAIT ); 
Fl::check();
int nsa=mwtb->model->add_region_surfaces();
int ns = mwtb->model->numSurf();
for( int i=ns-nsa; i<ns; i++ )  
  surflist->add( mwtb->model->surface(i)->label().c_str(),1);
surflist->redraw();
fl_cursor( FL_CURSOR_DEFAULT );
Fl::check();
write_surfaces(ns-nsa);
if( nsa) mwtb->redraw(VBO_Visible);}
            xywh {0 0 30 20}
          }
          MenuItem readASCIIbut {
            label {Read ASCII data}
            user_data NULL
            callback {char *fn;
if( !v ) 
  fn = fl_file_chooser("Data file","*{out,dat}*",NULL);
else
  fn = (char *)v;   
if(fn && !mwtb->get_data(fn,tmslider) ) 
    add_recent(fn, ASCII );
mincolval->value(mwtb->cs->min());
maxcolval->value(mwtb->cs->max());}
            xywh {0 0 100 20}
            code0 {\#include <FL/Fl_File_Chooser.H>}
          }
          MenuItem readIGBbut {
            label {Read IGB data}
            callback {char *fn;
if( !v ) 
  fn = fl_file_chooser("Data file","*igb*",NULL);
else
  fn = (char *)v;
if(fn != NULL) {
  fl_cursor(FL_CURSOR_WAIT);
  Fl::check();
  int ret = mwtb->get_data(fn,tmslider);
  fl_cursor(FL_CURSOR_DEFAULT);
  Fl::check();
  if( !ret ) add_recent( fn, IGB );
}
mincolval->value(mwtb->cs->min());
maxcolval->value(mwtb->cs->max());}
            xywh {20 20 100 20}
            code0 {\#include <FL/Fl_File_Chooser.H>}
          }
          MenuItem readVECbut {
            label {Read Vector Data}
            callback {if( !mwtb->getVecData(tmslider) ) {
  vectorgrp->activate();
  tabwidget->value(vectorgrp);
}}
            xywh {0 0 100 20}
          }
          MenuItem readAUXbut {
            label {Read Aux Grid}
            callback {char *fn;
if( v ) 
  fn = (char *)v;
else
  fn = fl_file_chooser( "Auxiliary Grid", "*.pts_t", NULL );
if( fn && !mwtb->readAuxGrid(tmslider,fn) ) {
  auxgridgrp->activate();
  tabwidget->value(auxgridgrp);
  float val;
  if( mwtb->auxGrid->highlight_vertex(0,val)) {
     auxvertval->value(val);
     auxDataGrp->activate();
     mwtb->auxGrid->optimize_cs(0);
     auxmincolval->value(mwtb->auxGrid->cs.min());
     auxmaxcolval->value(mwtb->auxGrid->cs.max());
     mwtb->auxGrid->autocolor(auxautocalibratebut->value());
   } else { 
     auxvertval->value(0); 
     auxDataGrp->deactivate();auxvertval->value(0); 
   } 
   auxhivert->value(0);
   add_recent( fn, AUX );
}}
            xywh {0 0 100 20}
          }
          MenuItem readDYNPTSbut {
            label {Read Dyn Pts}
            callback {char *fn;
if( v )
  fn = (char*)v;
else
  fn = fl_file_chooser("Dynamic Points", "*.dynpt", NULL );
if( fn ){
  mwtb->read_dynamic_pts( fn, tmslider );
  add_recent( fn, DYN_PTS );
}}
            xywh {0 0 30 20}
          }
          MenuItem hdfreadbut {
            label {Read  HDF5 Data}
            callback {\#ifdef USE_HDF5
char *fn;
if( v ) 
  fn = (char *)v;
else
  fn =  fl_file_chooser("Choose HDF5 data file", "*.datH5", NULL );
HDF5DataBrowser *brow =  new HDF5DataBrowser( fn, mwtb );
add_recent( HDF5 );
\#endif}
            xywh {0 0 30 20}
          }
          MenuItem {} {
            label {Recent...}
            xywh {0 0 33 21}
            code0 {o->flags|=FL_SUBMENU_POINTER;}
            code1 {o->user_data(new Fl_Menu_Item[MaxRecentSz+1]);}
            code2 {memset( o->user_data(),0,sizeof(Fl_Menu_Item));}
          }
          MenuItem read_recalibrate {
            label {Recalibrate on read}
            tooltip {Recalibrate colour scale when reading a new data file} xywh {0 0 100 20} type Toggle value 1
          }
          MenuItem read_threaded {
            label {Force threaded read}
            callback {mwtb->forceThreadData(o->value());}
            tooltip {do not attempt to read whole data file into memroy} xywh {0 0 100 20} type Toggle value 1
          }
          MenuItem {} {
            label {Save transform}
            callback {char*fn;
fn=fl_file_chooser("Save Xfrm","*.xfrm",NULL);
if( fn != NULL )
 mwtb->trackball.save(fn);}
            xywh {0 0 100 20}
          }
          MenuItem {} {
            label {Read transform}
            callback {char *fn = fl_file_chooser("Xfrm file","*.xfrm",NULL);
if( fn != NULL ){
  mwtb->trackball.read(fn);
  mwtb->redraw(VBO_View);
}}
            xywh {0 0 100 20}
          }
          MenuItem {} {
            label {Save state}
            callback {save_state();}
            xywh {0 0 100 20}
          }
          MenuItem {} {
            label {Restore state}
            callback {restore_state();}
            xywh {10 10 100 20}
          }
          MenuItem {} {
            label Link
            callback {mwtb->mk_tmlink();
mwtb->tmLink->list_mesh_pids();
mwtb->tmLink->window->show();
mwtb->tmLink->pid->value(std::to_string(getpid()).c_str());}
            xywh {0 0 30 20}
            code0 {\#include <sys/types.h>}
            code1 {\#include <unistd.h>}
          }
          MenuItem {} {
            label Quit
            callback {Fl_Window *pw = Fl::first_window();
while (pw){
  pw->hide();
  pw = Fl::first_window();
}}
            xywh {0 0 100 20}
          }
        }
        Submenu imgmenu {
          label Image open
          xywh {0 0 100 20}
        } {
          MenuItem {} {
            label {Reset transform}
            callback {mwtb->trackball.Reset();
float md = mwtb->get_maxdim();
mwtb->trackball.mouse.SetOglPosAndSize(-md, md, 2*md, 2*md );
mwtb->trackball.size = md;
const GLfloat* po=mwtb->model->pt_offset();
mwtb->trackball.SetOrigin(-po[0],-po[1],-po[2]);
mwtb->redraw(VBO_View);}
            xywh {0 0 100 20}
          }
          MenuItem {} {
            label {Raise window}
            callback {mwtb->parent()->show();}
            xywh {0 0 33 23}
          }
          Submenu {} {
            label View
            xywh {0 0 100 20}
          } {
            Submenu {} {
              label {+X}
              xywh {0 0 100 20}
            } {
              MenuItem {} {
                callback {set_rot('X',0,0);}
                image {images/ppaxis.png} xywh {0 0 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('X',0,1);}
                image {images/npaxis.png} xywh {10 10 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('X',0,2);}
                image {images/nnaxis.png} xywh {20 20 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('X',0,3);}
                image {images/pnaxis.png} xywh {30 30 100 20}
              }
            }
            Submenu {} {
              label {+Y}
              xywh {5 5 100 20}
            } {
              MenuItem {} {
                callback {set_rot('Y',0,0);}
                image {images/ppaxis.png} xywh {10 10 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('Y',0,1);}
                image {images/npaxis.png} xywh {20 20 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('Y',0,2);}
                image {images/nnaxis.png} xywh {30 30 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('Y',0,3);}
                image {images/pnaxis.png} xywh {40 40 100 20}
              }
            }
            Submenu {} {
              label {+Z}
              xywh {20 20 100 20}
            } {
              MenuItem {} {
                callback {set_rot('Z',0,0);}
                image {images/ppaxis.png} xywh {20 20 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('Z',0,1);}
                image {images/npaxis.png} xywh {30 30 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('Z',0,2);}
                image {images/nnaxis.png} xywh {40 40 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('Z',0,3);}
                image {images/pnaxis.png} xywh {50 50 100 20}
              }
            }
            Submenu {} {
              label {-X}
              xywh {25 25 100 20}
            } {
              MenuItem {} {
                callback {set_rot('X',1,0);}
                image {images/ppaxis.png} xywh {10 10 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('X',1,1);}
                image {images/npaxis.png} xywh {20 20 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('X',1,2);}
                image {images/nnaxis.png} xywh {30 30 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('X',1,3);}
                image {images/pnaxis.png} xywh {40 40 100 20}
              }
            }
            Submenu {} {
              label {-Y}
              xywh {35 35 100 20}
            } {
              MenuItem {} {
                callback {set_rot('Y',1,0);}
                image {images/ppaxis.png} xywh {20 20 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('Y',1,1);}
                image {images/npaxis.png} xywh {30 30 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('Y',1,2);}
                image {images/nnaxis.png} xywh {40 40 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('Y',1,3);}
                image {images/pnaxis.png} xywh {50 50 100 20}
              }
            }
            Submenu {} {
              label {-Z}
              xywh {45 45 100 20}
            } {
              MenuItem {} {
                callback {set_rot('Z',1,0);}
                image {images/ppaxis.png} xywh {30 30 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('Z',1,1);}
                image {images/npaxis.png} xywh {40 40 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('Z',1,2);}
                image {images/nnaxis.png} xywh {50 50 100 20}
              }
              MenuItem {} {
                label item
                callback {set_rot('Z',1,3);}
                image {images/pnaxis.png} xywh {60 60 100 20}
              }
            }
          }
          Submenu {} {
            label {Randomly colour} open
            xywh {0 0 100 20}
          } {
            MenuItem {} {
              label vertices
              callback {mwtb->randomize_color(Vertex);}
              xywh {15 15 100 20}
            }
            MenuItem {} {
              label cnnx
              callback {mwtb->randomize_color(Cnnx);}
              xywh {15 15 100 20}
            }
            MenuItem {} {
              label cables
              callback {mwtb->randomize_color(Cable);}
              xywh {0 0 33 21}
            }
            MenuItem {} {
              label {surface eles}
              callback {mwtb->randomize_color(SurfEle);}
              xywh {0 0 100 20}
            }
            MenuItem {} {
              label surfaces
              callback {mwtb->randomize_color(Surface);}
              xywh {5 5 100 20}
            }
            MenuItem {} {
              label voxele
              callback {mwtb->randomize_color(VolEle);}
              xywh {0 0 30 20}
            }
          }
          Submenu {} {
            label {Background colour}
            xywh {0 0 100 20}
          } {
            MenuItem {} {
              label White
              callback {mwtb->bgd(1);}
              xywh {0 0 100 20}
            }
            MenuItem {} {
              label Gray
              callback {mwtb->bgd(0.6);}
              xywh {10 10 100 20}
            }
            MenuItem {} {
              label Black
              callback {mwtb->bgd(0);}
              xywh {20 20 100 20}
            }
          }
          MenuItem norot {
            label {No rotation}
            user_data norot
            callback {mwtb->norot(((Fl_Menu_Item*)v)->checked());}
            xywh {0 0 30 20} type Toggle
          }
          MenuItem revdraworder {
            label {Reverse draw order}
            user_data revdraworder
            callback {mwtb->revdraworder(((Fl_Menu_Item*)v)->checked());}
            xywh {0 0 100 20} type Toggle
          }
          Submenu {} {
            label Sync
            xywh {0 0 70 20}
          } {
            MenuItem {} {
              label Viewport
              callback {mwtb->SendViewportSyncMessage();}
              xywh {5 5 30 20}
            }
            MenuItem {} {
              label {Colour Scale}
              callback {mwtb->SendColourSyncMessage();}
              xywh {5 5 30 20}
            }
            MenuItem {} {
              label Time
              callback {mwtb->SendTimeSyncMessage();}
              xywh {0 0 33 23}
            }
            MenuItem {} {
              label Clipping
              callback {mwtb->SendClipSyncMessage();}
              xywh {0 0 33 23}
            }
            MenuItem {} {
              label {Reference view}
              callback {mwtb->trackball.qRot=mwtb->model->syncRefRot();
mwtb->redraw(VBO_View);}
              xywh {0 0 33 23}
            }
            MenuItem {} {
              label {Set reference view}
              callback {mwtb->model->syncRefRot(mwtb->trackball.GetRotation());}
              xywh {0 0 33 23}
            }
          }
        }
        Submenu {} {
          label Data
          xywh {0 0 100 20}
        } {
          MenuItem {} {
            label Opacity
            callback {mwtb->dataopac->window->show();}
            tooltip {Set opacity based on data values} xywh {0 0 100 20}
          }
          MenuItem {} {
            label Clipping
            callback {mwtb->cplane->window->show();}
            tooltip {manage clipping planes} xywh {10 10 100 20}
          }
          MenuItem {} {
            label Isosurf
            callback {mwtb->isosurfwin->isowin->show();}
            tooltip {isoline and isosurface display} xywh {0 0 31 20}
          }
          MenuItem {} {
            label {Dead range}
            callback {mwtb->deadData->window->show();}
            tooltip {Ignore ranges of data} xywh {0 0 34 20}
          }
          Submenu brcut {
            label {Branch cut} open
            tooltip {Do not interpolate over a branch cut} xywh {0 0 70 20}
          } {
            MenuItem brcutNone {
              label None
              callback {mwtb->branch_cut(0,0,0);}
              xywh {0 0 34 20} type Radio value 1
            }
            MenuItem brcutPM1 {
              label {[-1,1)}
              callback {mwtb->branch_cut(-1,1,0.2);}
              xywh {0 0 34 20} type Radio
            }
            MenuItem brcut01 {
              label {[0,1)}
              callback {mwtb->branch_cut(0,1,0.2);}
              xywh {0 0 34 20} type Radio
            }
            MenuItem brcutPMpi {
              label {[-pi,pi)}
              callback {mwtb->branch_cut(-M_PI,M_PI,.2);}
              xywh {0 0 34 20} type Radio
            }
            MenuItem brcut02pi {
              label {[0,2pi)}
              callback {mwtb->branch_cut(0,2*M_PI,.2);}
              xywh {0 0 34 20} type Radio
            }
          }
        }
        Submenu outmenu {
          label Output
          xywh {0 0 100 20}
        } {
          Submenu {} {
            label PNG
            xywh {5 5 100 20}
          } {
            MenuItem {} {
              label Image
              callback {char *fn = fl_file_chooser("PNG image", "*.png", "image.png" );
if( fn!=NULL)
mwtb->output_png(fn);}
              xywh {10 10 100 20}
            }
            MenuItem {} {
              label Sequence
              callback {Sequence *s=new Sequence( mwtb );
s->window->show();}
              xywh {20 20 100 20}
              code0 {\#include "Sequence.h"}
            }
            MenuItem transBgd {
              label {Transparent Bgd}
              user_data transBgd
              callback {mwtb->transBgd( transBgd->value() );}
              xywh {0 0 30 20} type Toggle
            }
          }
          MenuItem {} {
            label EPS
            callback {char* fn = fl_file_chooser("EPS file name", "*.eps", "image.eps");
if( fn==NULL) return;
mwtb->output_pdf( fn, false );}
            xywh {5 5 100 20}
          }
          MenuItem {} {
            label {Colour Bar}
            callback {char *fn = fl_file_chooser("colour bar image", "*.png", "colour_bar.png" );
if( fn!=NULL)
mwtb->cs->output_png(fn);}
            tooltip {output the colour bar as an image file} xywh {0 0 34 20}
          }
          MenuItem {} {
            label {Fly By}
            callback {flyby->fb_win->show();}
            xywh {0 0 31 20}
          }
          MenuItem {} {
            label {Visible vertices}
            callback {mwtb->dump_vertices();}
            tooltip {output the indices of the visible vertices} xywh {0 0 100 20}
          }
          Submenu recordmenu {
            label Record
            tooltip {take an image snapshot each time something changes} xywh {0 0 100 20}
          } {
            MenuItem {} {
              label start
              callback {if( !mwtb->recording ) {
  char* fn=fl_file_chooser( "Pick base name", "*.png", "frame.png" );
  if( fn != NULL ) {
    outmenu->labelcolor(FL_GREEN);
    redrawbut->show();
    mwtb->recording=true;
    mwtb->record_events( fn );
  }
}}
              xywh {0 0 100 20}
            }
            MenuItem {} {
              label stop
              callback {mwtb->recording = false;
outmenu->labelcolor(FL_BLACK);
redrawbut->hide();
mainbar->redraw();}
              xywh {0 0 100 20}
            }
          }
        }
        MenuItem redrawbut {
          label Redraw
          callback {mwtb->redraw(VBO_All);}
          xywh {0 0 100 20} labelcolor 180 hide
        }
        MenuItem {} {
          label item
          xywh {0 0 30 20} labeltype NO_LABEL
        }
        MenuItem {} {
          label item
          xywh {0 0 30 20} labeltype NO_LABEL
        }
        MenuItem {} {
          label About
          callback {proginfo->show();}
          xywh {0 0 30 20}
        }
      }
      Fl_Menu_Button datadest {
        label {Data on:} open
        tooltip {Object types to datigy} xywh {10 50 170 30} color 26
      } {
        MenuItem vertdisp {
          label Vertices
          user_data vertdisp
          callback {if(((Fl_Menu_Item*)v)->checked()) mwtb->datify(Vertex);
else mwtb->undatify(Vertex);}
          xywh {0 0 30 20} type Toggle
        }
        MenuItem cnnxdisp {
          label Cnnx
          user_data cnnxdisp
          callback {if(((Fl_Menu_Item*)v)->checked()) mwtb->datify(Cnnx);
else mwtb->undatify(Cnnx);}
          xywh {0 0 30 20} type Toggle
        }
        MenuItem surfedgedisp {
          label {Surface edges}
          user_data surfedgedisp
          callback {if(((Fl_Menu_Item*)v)->checked() ) mwtb->datify(SurfEle);
else mwtb->undatify(SurfEle);}
          xywh {0 0 30 20} type Toggle
        }
        MenuItem surfdisp {
          label {Surface Elements}
          user_data surfdisp
          callback {if(((Fl_Menu_Item*)v)->checked() ) mwtb->datify(Surface);
else mwtb->undatify(Surface);}
          xywh {0 0 30 20} type Toggle value 1
        }
        MenuItem voldisp {
          label {Volume Elements}
          user_data voldisp
          callback {if(((Fl_Menu_Item*)v)->checked() ) mwtb->datify(VolEle);
else mwtb->undatify(VolEle);}
          xywh {0 0 30 20} type Toggle
        }
        MenuItem {} {
          label ALL
          callback {mwtb->datify(All);
vertdisp->check();
cnnxdisp->check();
surfedgedisp->check();
surfdisp->check();
voldisp->check();}
          xywh {0 0 30 20}
        }
        MenuItem {} {
          label NONE
          callback {mwtb->undatify(All);
vertdisp->uncheck();
cnnxdisp->uncheck();
surfedgedisp->uncheck();
surfdisp->uncheck();
voldisp->uncheck();}
          xywh {0 0 30 20}
        }
      }
      Fl_Light_Button draw_axes {
        label Axes
        callback {mwtb->axes(o->value());}
        tooltip {toggle axs display} xywh {10 85 65 25}
      }
      Fl_Button voxeleColor {
        label {Voxele  colour}
        callback {static colourChoice* cc=NULL;
cc=pickcolor(VolEle, "Voxele colour",cc);}
        xywh {80 85 100 25} labelsize 13
      }
      Fl_Group dispAs {
        label {Display as:}
        xywh {190 50 150 60} box ENGRAVED_BOX
      } {
        Fl_Check_Button dispAsSurf {
          label Surfaces
          callback {mwtb->dispmode(asSurface);}
          xywh {195 55 90 25} type Radio down_box DIAMOND_DOWN_BOX value 1
        }
        Fl_Check_Button dispAsVol {
          label {Volume Mesh}
          callback {mwtb->dispmode(asTetMesh);}
          xywh {195 80 140 25} type Radio down_box DIAMOND_DOWN_BOX
        }
      }
      Fl_Group regiondisp {
        label Region open
        xywh {10 120 330 145} box ENGRAVED_BOX align 17
      } {
        Fl_Light_Button vertbut {
          label Vertices
          callback {bool *selreg = regselected();
mwtb->showobj(Vertex,selreg,static_cast<bool>(o->value()));
if(o->value())
  pickvert->activate();
else
  pickvert->deactivate();
free(selreg);}
          xywh {160 145 75 25} when 1
        }
        Fl_Light_Button cnnxbut {
          label Connections
          callback {bool* selreg=regselected();
mwtb->showobj(Cnnx,selreg,static_cast<bool>(o->value()));
free(selreg);}
          xywh {160 170 100 25}
        }
        Fl_Button vertprop {
          label props
          callback {if( !objprops[Vertex] )
  objprops[Vertex] = new ObjProps( mwtb, Vertex );
else {
 objprops[Vertex]->update();
}
objprops[Vertex]->win->show();}
          tooltip {vertex properties} xywh {260 145 70 25} labelsize 12
        }
        Fl_Button connprop {
          label props
          callback {if( !objprops[Cnnx] )
  objprops[Cnnx] = new ObjProps( mwtb, Cnnx );
else {
 objprops[Cnnx]->update();
} 
objprops[Cnnx]->win->show();}
          tooltip {connection properties} xywh {260 170 70 25} labelsize 12
        }
        Fl_Light_Button visbut {
          label visible
          callback {bool *selreg=regselected();
mwtb->visibility(selreg, o->value());
free(selreg);}
          xywh {160 195 100 20} value 1
        }
        Fl_Button {} {
          label {select all}
          callback {reglist->check_all();
reglist->do_callback();}
          xywh {160 230 90 20}
        }
        Fl_Check_Browser reglist {
          callback {if( objprops[Vertex] ) objprops[Vertex]->update();
if( objprops[Cnnx] )   objprops[Cnnx]->update();
if( objprops[Cable] )  objprops[Cable]->update();
mwtb->redraw(VBO_Visible);}
          xywh {25 130 120 125} when 1
        }
        Fl_Button {} {
          label invert
          callback {for( int i=0; i<=reglist->nitems(); i++ )
  reglist->checked( i, !reglist->checked(i) );
reglist->do_callback();}
          xywh {250 230 80 20} color 0 labelcolor 49
        }
        Fl_Check_Button vertDispAll {
          label All
          callback {mwtb->draw_all_pts(o->value());}
          tooltip {draw all points; otherwise only those part of displayed objects} xywh {235 145 25 25} box UP_BOX down_box DOWN_BOX align 33
        }
      }
      Fl_Tabs tabwidget {open
        xywh {10 270 330 260} align 0
      } {
        Fl_Group hilightgrp {
          label Highlight selected
          xywh {10 305 330 225} color 11 labelfont 1 labelsize 12 labelcolor 121 align 4
        } {
          Fl_Value_Input tethi {