← Back to branch summary

~ubuntu-branches/debian/squeeze/gmsh/squeeze

« back to all changes in this revision

Viewing changes to Fltk/visibilityWindow.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Christophe Prud'homme, Christophe Prud'homme
  • Date: 2009-09-02 18:12:15 UTC
  • mfrom: (1.2.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20090902181215-yla8zvcas2ucvkm9
[Christophe Prud'homme]
* New upstream release
  + fixed surface mesh orientation bug introduced in 2.4.0;
  + mesh and graphics code refactoring;
  + small usability enhancements and bug fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Fltk/visibilityWindow.cpp
12
12
#include <FL/Fl_Box.H>
13
13
#include <FL/Fl_Return_Button.H>
14
14
#include "GmshConfig.h"
15
 
#include "GUI.h"
16
 
#include "Draw.h"
 
15
#include "FlGui.h"
 
16
#include "drawContext.h"
17
17
#include "visibilityWindow.h"
18
18
#include "paletteWindow.h"
19
19
#include "contextWindow.h"
195
195
    }
196
196
    else if(type == ElementaryEntities){
197
197
      for(GModel::piter it = m->firstElementaryName(); it != m->lastElementaryName(); ++it)
198
 
        setLabel(it->first, it->second, 1);
 
198
        setLabel(it->first.second, it->second, 1);
199
199
      for(GModel::viter it = m->firstVertex(); it != m->lastVertex(); it++)
200
200
        _entities.push_back(new VisElementary(*it));
201
201
      for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); it++)
207
207
    }
208
208
    else if(type == PhysicalEntities){
209
209
      for(GModel::piter it = m->firstPhysicalName(); it != m->lastPhysicalName(); ++it)
210
 
        setLabel(it->first, it->second, 1);
 
210
        setLabel(it->first.second, it->second, 1);
211
211
      std::map<int, std::vector<GEntity*> > groups[4];
212
212
      m->getPhysicalGroups(groups);
213
213
      for(int i = 0; i < 4; i++){
288
288
 
289
289
static void _rebuild_list_browser()
290
290
{
291
 
  GUI::instance()->visibility->browser->clear();
 
291
  FlGui::instance()->visibility->browser->clear();
292
292
 
293
293
  VisibilityList::VisibilityType type;
294
 
  switch(GUI::instance()->visibility->browser_type->value()){
 
294
  switch(FlGui::instance()->visibility->browser_type->value()){
295
295
  case 0: type = VisibilityList::Models; break;
296
296
  case 2: type = VisibilityList::PhysicalEntities; break;
297
297
  case 3: type = VisibilityList::MeshPartitions; break;
300
300
 
301
301
  VisibilityList::instance()->update(type);
302
302
  for(int i = 0; i < VisibilityList::instance()->getNumEntities(); i++){
303
 
    GUI::instance()->visibility->browser->add
 
303
    FlGui::instance()->visibility->browser->add
304
304
      (VisibilityList::instance()->getBrowserLine(i).c_str());
305
305
    if(VisibilityList::instance()->getVisibility(i))
306
 
      GUI::instance()->visibility->browser->select(i + 1);
 
306
      FlGui::instance()->visibility->browser->select(i + 1);
307
307
  }
308
308
  
309
309
  // activate/deactivate delete button
310
310
  if(type == VisibilityList::PhysicalEntities)
311
 
    GUI::instance()->visibility->push[0]->activate();
 
311
    FlGui::instance()->visibility->push[0]->activate();
312
312
  else
313
 
    GUI::instance()->visibility->push[0]->deactivate();
 
313
    FlGui::instance()->visibility->push[0]->deactivate();
314
314
}
315
315
 
316
316
static void visibility_browser_apply_cb(Fl_Widget *w, void *data)
319
319
  // browser and apply them into the model
320
320
  if(VisibilityList::instance()->getNumEntities()){
321
321
    CTX::instance()->mesh.changed |= (ENT_LINE | ENT_SURFACE | ENT_VOLUME);
322
 
    bool recursive = GUI::instance()->visibility->butt[0]->value() ? true : false;
 
322
    bool recursive = FlGui::instance()->visibility->butt[0]->value() ? true : false;
323
323
    VisibilityList::VisibilityType type;
324
 
    switch(GUI::instance()->visibility->browser_type->value()){
 
324
    switch(FlGui::instance()->visibility->browser_type->value()){
325
325
    case 0: type = VisibilityList::Models; break;
326
326
    case 2: type = VisibilityList::PhysicalEntities; break;
327
327
    case 3: type = VisibilityList::MeshPartitions; break;
329
329
    }
330
330
    VisibilityList::instance()->setAllInvisible(type);
331
331
    for(int i = 0; i < VisibilityList::instance()->getNumEntities(); i++)
332
 
      if(GUI::instance()->visibility->browser->selected(i + 1))
 
332
      if(FlGui::instance()->visibility->browser->selected(i + 1))
333
333
        VisibilityList::instance()->setVisibility(i, 1, recursive);
334
334
    // then refresh the browser to account for recursive selections
335
335
    for(int i = 0; i < VisibilityList::instance()->getNumEntities(); i++)
336
336
      if(VisibilityList::instance()->getVisibility(i))
337
 
        GUI::instance()->visibility->browser->select(i + 1);
338
 
    Draw();
 
337
        FlGui::instance()->visibility->browser->select(i + 1);
 
338
    drawContext::global()->draw();
339
339
  }
340
340
}
341
341
 
343
343
{
344
344
  bool all = true;
345
345
  for(int i = 0; i < VisibilityList::instance()->getNumEntities(); i++){
346
 
    if(!GUI::instance()->visibility->browser->selected(i + 1)){
 
346
    if(!FlGui::instance()->visibility->browser->selected(i + 1)){
347
347
      all = false;
348
348
      break;
349
349
    }
353
353
  }
354
354
  else{
355
355
    for(int i = 0; i < VisibilityList::instance()->getNumEntities(); i++){
356
 
      if(GUI::instance()->visibility->browser->selected(i + 1)){
 
356
      if(FlGui::instance()->visibility->browser->selected(i + 1)){
357
357
        Vis *v = VisibilityList::instance()->getEntity(i);
358
358
        GModel::current()->deletePhysicalGroup(v->getDim(), v->getTag());
359
359
      }
381
381
 
382
382
  if(val == 0) { // select or deselect everything
383
383
    int selectall = 0;
384
 
    for(int i = 0; i < GUI::instance()->visibility->browser->size(); i++)
385
 
      if(!GUI::instance()->visibility->browser->selected(i + 1)) {
 
384
    for(int i = 0; i < FlGui::instance()->visibility->browser->size(); i++)
 
385
      if(!FlGui::instance()->visibility->browser->selected(i + 1)) {
386
386
        selectall = 1;
387
387
        break;
388
388
      }
389
389
    if(selectall)
390
 
      for(int i = 0; i < GUI::instance()->visibility->browser->size(); i++)
391
 
        GUI::instance()->visibility->browser->select(i + 1);
 
390
      for(int i = 0; i < FlGui::instance()->visibility->browser->size(); i++)
 
391
        FlGui::instance()->visibility->browser->select(i + 1);
392
392
    else
393
 
      GUI::instance()->visibility->browser->deselect();
 
393
      FlGui::instance()->visibility->browser->deselect();
394
394
  }
395
395
  else if(val == -1){ // invert the selection
396
 
    int *state = new int[GUI::instance()->visibility->browser->size()];
397
 
    for(int i = 0; i < GUI::instance()->visibility->browser->size(); i++)
398
 
      state[i] = GUI::instance()->visibility->browser->selected(i + 1);
399
 
    GUI::instance()->visibility->browser->deselect();
400
 
    for(int i = 0; i < GUI::instance()->visibility->browser->size(); i++)
401
 
      if(!state[i]) GUI::instance()->visibility->browser->select(i + 1);
 
396
    int *state = new int[FlGui::instance()->visibility->browser->size()];
 
397
    for(int i = 0; i < FlGui::instance()->visibility->browser->size(); i++)
 
398
      state[i] = FlGui::instance()->visibility->browser->selected(i + 1);
 
399
    FlGui::instance()->visibility->browser->deselect();
 
400
    for(int i = 0; i < FlGui::instance()->visibility->browser->size(); i++)
 
401
      if(!state[i]) FlGui::instance()->visibility->browser->select(i + 1);
402
402
    delete [] state;
403
403
  }
404
404
  else if(val == -2){ // create new parameter name for selection
405
 
    for(int i = 0; i < GUI::instance()->visibility->browser->size(); i++){
406
 
      if(GUI::instance()->visibility->browser->selected(i + 1)){
 
405
    for(int i = 0; i < FlGui::instance()->visibility->browser->size(); i++){
 
406
      if(FlGui::instance()->visibility->browser->selected(i + 1)){
407
407
        static char tmpstr[256];
408
408
        sprintf(tmpstr, "%d", VisibilityList::instance()->getTag(i));
409
 
        GUI::instance()->geoContext->input[1]->value(tmpstr);
 
409
        FlGui::instance()->geoContext->input[1]->value(tmpstr);
410
410
        break;
411
411
      }
412
412
    }
413
 
    GUI::instance()->geoContext->input[0]->value("NewName");
414
 
    GUI::instance()->geoContext->show(0);
 
413
    FlGui::instance()->geoContext->input[0]->value("NewName");
 
414
    FlGui::instance()->geoContext->show(0);
415
415
  }
416
416
  else { // set new sorting mode
417
417
    VisibilityList::instance()->setSortMode(val);
443
443
    : Fl_Browser(x, y, w, h, c){}
444
444
};
445
445
 
446
 
#if defined(HAVE_TREE_BROWSER)
 
446
#if defined(HAVE_FL_TREE)
447
447
 
448
 
static void _add_vertex(GVertex *gv, Flu_Tree_Browser::Node *n)
 
448
static void _add_vertex(GVertex *gv, Fl_Tree *tree, std::string path)
449
449
{
450
 
  char str[128];
451
 
  sprintf(str, "Point %d", gv->tag());
452
 
  Flu_Tree_Browser::Node *n2 = n->add(str);
453
 
  if(gv->getVisibility()) n2->select(true);
454
 
  n2->user_data((void*)gv);
 
450
  std::ostringstream vertex;
 
451
  vertex << path << "Point " << gv->tag() << "/";
 
452
  Fl_Tree_Item *n = tree->add(vertex.str().c_str());
 
453
  if(gv->getVisibility()) n->select(1);
 
454
  n->userdata((void*)gv);
 
455
  n->close();
455
456
}
456
457
 
457
 
static void _add_edge(GEdge *ge, Flu_Tree_Browser::Node *n)
 
458
static void _add_edge(GEdge *ge, Fl_Tree *tree, std::string path)
458
459
{
459
 
  char str[128];
460
 
  sprintf(str, "Line %d/", ge->tag());
461
 
  Flu_Tree_Browser::Node *n2 = n->add(str);
462
 
  if(ge->getVisibility()) n2->select(true);
463
 
  n2->user_data((void*)ge);
 
460
  std::ostringstream edge;
 
461
  edge << path << "Line " << ge->tag() << "/";
 
462
  Fl_Tree_Item *n = tree->add(edge.str().c_str());
 
463
  if(ge->getVisibility()) n->select(1);
 
464
  n->userdata((void*)ge);
 
465
  n->close();
464
466
  if(ge->getBeginVertex())
465
 
    _add_vertex(ge->getBeginVertex(), n2);
 
467
    _add_vertex(ge->getBeginVertex(), tree, edge.str());
466
468
  if(ge->getEndVertex())
467
 
    _add_vertex(ge->getEndVertex(), n2);
 
469
    _add_vertex(ge->getEndVertex(), tree, edge.str());
468
470
}
469
471
 
470
 
static void _add_face(GFace *gf, Flu_Tree_Browser::Node *n)
 
472
static void _add_face(GFace *gf, Fl_Tree *tree, std::string path)
471
473
{
472
 
  char str[128];
473
 
  sprintf(str, "Surface %d/", gf->tag());
474
 
  Flu_Tree_Browser::Node *n2 = n->add(str);
475
 
  if(gf->getVisibility()) n2->select(true);
476
 
  n2->user_data((void*)gf);
 
474
  std::ostringstream face;
 
475
  face << path << "Surface " << gf->tag() << "/";
 
476
  Fl_Tree_Item *n = tree->add(face.str().c_str());
 
477
  if(gf->getVisibility()) n->select(1);
 
478
  n->userdata((void*)gf);
 
479
  n->close();
477
480
  std::list<GEdge*> edges = gf->edges();
478
481
  for(std::list<GEdge*>::iterator it = edges.begin(); it != edges.end(); it++)
479
 
    _add_edge(*it, n2);
 
482
    _add_edge(*it, tree, face.str());
480
483
}
481
484
 
482
 
static void _add_region(GRegion *gr, Flu_Tree_Browser::Node *n)
 
485
static void _add_region(GRegion *gr, Fl_Tree *tree, std::string path)
483
486
{
484
 
  char str[128];
485
 
  sprintf(str, "Volume %d/", gr->tag());
486
 
  Flu_Tree_Browser::Node *n2 = n->add(str);
487
 
  if(gr->getVisibility()) n2->select(true);
488
 
  n2->user_data((void*)gr);
 
487
  std::ostringstream region;
 
488
  region << path << "Volume " << gr->tag() << "/";
 
489
  Fl_Tree_Item *n = tree->add(region.str().c_str());
 
490
  if(gr->getVisibility()) n->select(1);
 
491
  n->userdata((void*)gr);
 
492
  n->close();
489
493
  std::list<GFace*> faces = gr->faces();
490
494
  for(std::list<GFace*>::iterator it = faces.begin(); it != faces.end(); it++)
491
 
    _add_face(*it, n2);
 
495
    _add_face(*it, tree, region.str());
492
496
}
493
497
 
494
498
static void _add_physical_group(int dim, int num, std::vector<GEntity*> &ge,
495
 
                                Flu_Tree_Browser::Node *n)
 
499
                                std::map<int, std::string> &oldLabels, 
 
500
                                Fl_Tree *tree, std::string path)
496
501
{
497
502
  if(ge.empty()) return;
498
 
  char str[256];
499
 
  Flu_Tree_Browser::Node *n2 = 0;
500
 
  std::string name;
501
 
  if(ge[0]->model()->getPhysicalName(num).size())
502
 
    name += std::string(" <<") + ge[0]->model()->getPhysicalName(num) + ">>";
 
503
  std::string name = ge[0]->model()->getPhysicalName(dim, num);
 
504
  if(name.empty() && oldLabels.count(num)) name = oldLabels[num];
 
505
  if(name.size()) name = std::string(" <<") + name + ">>";
 
506
 
 
507
  Fl_Tree_Item *n;
 
508
  std::ostringstream group;
 
509
  group << path;
503
510
  switch(dim){
504
511
  case 3:
505
 
    sprintf(str, "Physical Volume %d%s/", num, name.c_str());
506
 
    n2 = n->add(str);
 
512
    group << "Physical Volume " << num << name << "/";
 
513
    n = tree->add(group.str().c_str());
 
514
    n->close();
507
515
    for(unsigned int i = 0; i < ge.size(); i++)
508
 
      _add_region((GRegion*)ge[i], n2);
 
516
      _add_region((GRegion*)ge[i], tree, group.str());
509
517
    break;
510
518
  case 2:
511
 
    sprintf(str, "Physical Surface %d%s/", num, name.c_str());
512
 
    n2 = n->add(str);
 
519
    group << "Physical Surface " << num << name << "/";
 
520
    n = tree->add(group.str().c_str());
 
521
    n->close();
513
522
    for(unsigned int i = 0; i < ge.size(); i++)
514
 
      _add_face((GFace*)ge[i], n2);
 
523
      _add_face((GFace*)ge[i], tree, group.str());
515
524
    break;
516
525
  case 1:
517
 
    sprintf(str, "Physical Line %d%s/", num, name.c_str());
518
 
    n2 = n->add(str);
 
526
    group << "Physical Line " << num << name << "/";
 
527
    n = tree->add(group.str().c_str());
 
528
    n->close();
519
529
    for(unsigned int i = 0; i < ge.size(); i++)
520
 
      _add_edge((GEdge*)ge[i], n2);
 
530
      _add_edge((GEdge*)ge[i], tree, group.str());
521
531
    break;
522
532
  case 0:
523
 
    sprintf(str, "Physical Point %d%s/", num, name.c_str());
524
 
    n2 = n->add(str);
 
533
    group << "Physical Point " << num << name << "/";
 
534
    n = tree->add(group.str().c_str());
 
535
    n->close();
525
536
    for(unsigned int i = 0; i < ge.size(); i++)
526
 
      _add_vertex((GVertex*)ge[i], n2);
 
537
      _add_vertex((GVertex*)ge[i], tree, group.str());
527
538
    break;
528
539
  default:
529
540
    break;
541
552
        GModel::list[i]->getNumVertices();
542
553
    }
543
554
    if(numEnt > 10000){
544
 
      GUI::instance()->visibility->tree->hide();
545
 
      GUI::instance()->visibility->tree_create->show();
 
555
      FlGui::instance()->visibility->tree->hide();
 
556
      FlGui::instance()->visibility->tree_create->show();
546
557
      return;
547
558
    }
548
559
  }
549
560
 
550
 
  GUI::instance()->visibility->tree_create->hide();
551
 
  GUI::instance()->visibility->tree->show();
552
 
  GUI::instance()->visibility->tree->clear();
 
561
  FlGui::instance()->visibility->tree_create->hide();
 
562
  FlGui::instance()->visibility->tree->show();
 
563
  FlGui::instance()->visibility->tree->clear();
553
564
 
554
 
  char str[128];
555
565
  for(unsigned int i = 0; i < GModel::list.size(); i++){
556
566
    GModel *m = GModel::list[i];
557
 
    std::string s(" <<");
558
 
    s += m->getName() + ">>";
559
 
    if(m == GModel::current()) s += " (Active)";
560
 
    sprintf(str, "Model [%d] %s/", i, s.c_str());
561
 
    Flu_Tree_Browser::Node *n = GUI::instance()->visibility->tree->add(str);
562
 
    if(m->getVisibility()) n->select(true);
563
 
    Flu_Tree_Browser::Node *e = n->add("Elementary entities/");
564
 
    e->select(true);
 
567
    std::ostringstream model;
 
568
    model << "Model [" << i << "] <<" << m->getName() << ">>";
 
569
    if(m == GModel::current()) model << " (Active)";
 
570
    model << "/";
 
571
 
 
572
    Fl_Tree_Item *n;
 
573
    n = FlGui::instance()->visibility->tree->add(model.str().c_str());
 
574
    if(m->getVisibility()) n->select(1);
 
575
    n->close();
 
576
 
 
577
    std::string elementary = model.str() + "Elementary entities/";
 
578
    n = FlGui::instance()->visibility->tree->add(elementary.c_str());
 
579
    n->close();
 
580
 
565
581
    for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); it++)
566
 
      _add_region(*it, e);
 
582
      _add_region(*it, FlGui::instance()->visibility->tree, elementary);
567
583
    for(GModel::fiter it = m->firstFace(); it != m->lastFace(); it++)
568
 
      _add_face(*it, e);
 
584
      _add_face(*it, FlGui::instance()->visibility->tree, elementary);
569
585
    for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); it++)
570
 
      _add_edge(*it, e);
 
586
      _add_edge(*it, FlGui::instance()->visibility->tree, elementary);
571
587
    for(GModel::viter it = m->firstVertex(); it != m->lastVertex(); it++)
572
 
      _add_vertex(*it, e);
573
 
    Flu_Tree_Browser::Node *g = n->add("Physical groups/");
574
 
    g->select(true);
 
588
      _add_vertex(*it, FlGui::instance()->visibility->tree, elementary);
 
589
 
 
590
    std::string physical = model.str() + "Physical groups/";
 
591
    n = FlGui::instance()->visibility->tree->add(physical.c_str());
 
592
    n->close();
 
593
 
575
594
    std::map<int, std::vector<GEntity*> > groups[4];
576
595
    m->getPhysicalGroups(groups);
 
596
    std::map<int, std::string> oldLabels;
 
597
#if !defined(HAVE_NO_PARSER)
 
598
    for(std::map<std::string, std::vector<double> >::iterator it = gmsh_yysymbols.begin();
 
599
        it != gmsh_yysymbols.end(); ++it)
 
600
      for(unsigned int i = 0; i < it->second.size(); i++)
 
601
        oldLabels[(int)it->second[i]] = it->first;
 
602
#endif
577
603
    for(int i = 3; i >= 0; i--)
578
604
      for(std::map<int, std::vector<GEntity*> >::iterator it = groups[i].begin();
579
605
          it != groups[i].end(); it++)
580
 
        _add_physical_group(i, it->first, it->second, g);
 
606
        _add_physical_group(i, it->first, it->second, oldLabels,
 
607
                            FlGui::instance()->visibility->tree, physical);
581
608
  }
 
609
 
 
610
  FlGui::instance()->visibility->tree->root_label("Gmsh");
 
611
  FlGui::instance()->visibility->tree->redraw();
582
612
}
583
613
 
584
614
static void build_tree_cb(Fl_Widget *w, void *data)
586
616
  _rebuild_tree_browser(true);
587
617
}
588
618
 
589
 
static void _recur_select(Flu_Tree_Browser::Node *n)
 
619
static void _recur_select(Fl_Tree_Item *n)
590
620
{
591
 
  n->select(true);
 
621
  n->select(1);
592
622
  for(int i = 0; i < n->children(); i++)
593
623
    _recur_select(n->child(i));
594
624
}
595
625
 
596
 
static void _recur_set_visible(Flu_Tree_Browser::Node *n)
 
626
static void _recur_set_visible(Fl_Tree_Item *n)
597
627
{
598
 
  if(n->user_data() && n->selected()){
599
 
    GEntity *ge = (GEntity*)n->user_data();
600
 
    bool recursive = GUI::instance()->visibility->butt[0]->value() ? true : false;
 
628
  if(n->userdata() && n->is_selected()){
 
629
    GEntity *ge = (GEntity*)n->userdata();
 
630
    bool recursive = FlGui::instance()->visibility->butt[0]->value() ? true : false;
601
631
    ge->setVisibility(1, recursive);
602
632
    // force this: if we ask to see an entity, let's assume that we
603
633
    // don't want the whole model to be invisible
607
637
    _recur_set_visible(n->child(i));
608
638
}
609
639
 
610
 
static void _recur_update_selected(Flu_Tree_Browser::Node *n)
 
640
static void _recur_update_selected(Fl_Tree_Item *n)
611
641
{
612
 
  if(n->user_data()){
613
 
    GEntity *ge = (GEntity*)n->user_data();
614
 
    n->select(ge->getVisibility() ? true : false);
 
642
  if(n->userdata()){
 
643
    GEntity *ge = (GEntity*)n->userdata();
 
644
    n->select(ge->getVisibility() ? 1 : 0);
615
645
  }
616
646
  for(int i = 0; i < n->children(); i++)
617
647
    _recur_update_selected(n->child(i));
619
649
 
620
650
static void visibility_tree_apply_cb(Fl_Widget *w, void *data)
621
651
{
622
 
  bool recursive = GUI::instance()->visibility->butt[0]->value() ? true : false;
623
 
  Flu_Tree_Browser::Node *root = GUI::instance()->visibility->tree->first();
 
652
  CTX::instance()->mesh.changed |= (ENT_LINE | ENT_SURFACE | ENT_VOLUME);
 
653
  bool recursive = FlGui::instance()->visibility->butt[0]->value() ? true : false;
 
654
 
 
655
  Fl_Tree_Item *root = FlGui::instance()->visibility->tree->root();
624
656
  for(int i = 0; i < root->children(); i++){
625
657
    GModel *m = GModel::list[i];
626
 
    Flu_Tree_Browser::Node *n = root->child(i);
 
658
    Fl_Tree_Item *n = root->child(i);
627
659
    // treat special levels separately
628
660
    if(recursive){
629
 
      if(n->selected()){ // if model is selected
 
661
      if(root->is_selected() || n->is_selected()){ // if root or model is selected
630
662
        _recur_select(n);
631
663
      }
632
664
      else{
633
665
        for(int j = 0; j < n->children(); j++){
634
 
          if(n->child(j)->selected()) // if elementary/physical is selected
 
666
          if(n->child(j)->is_selected()) // if elementary/physical is selected
635
667
            _recur_select(n->child(j));
636
668
          else if(j == 1){
637
669
            for(int k = 0; k < n->child(j)->children(); k++){
638
 
              if(n->child(j)->child(k)->selected()) // if physical ent is selected
 
670
              if(n->child(j)->child(k)->is_selected()) // if physical ent is selected
639
671
                _recur_select(n->child(j)->child(k));
640
672
            }
641
673
          }
652
684
    // update tree selection
653
685
    _recur_update_selected(n);
654
686
  }
655
 
  Draw();
 
687
  FlGui::instance()->visibility->tree->redraw();
 
688
  drawContext::global()->draw();
656
689
}
657
690
 
658
 
class treeBrowser : public Flu_Tree_Browser{
 
691
class treeBrowser : public Fl_Tree{
659
692
  int handle(int event)
660
693
  {
661
694
    switch(event){
662
695
    case FL_SHORTCUT:
663
696
    case FL_KEYBOARD:
664
 
      if(Fl::test_shortcut(FL_Enter) || 
665
 
         Fl::test_shortcut(FL_KP_Enter)){
 
697
      if(Fl::test_shortcut(FL_Enter) || Fl::test_shortcut(FL_KP_Enter)){
666
698
        visibility_tree_apply_cb(NULL, NULL);
667
699
        return 1;
668
700
      }
669
701
    }
670
 
    return Flu_Tree_Browser::handle(event);
 
702
    return Fl_Tree::handle(event);
671
703
  }
672
704
 public:
673
705
  treeBrowser(int x, int y, int w , int h, const char* c = 0)
674
 
    : Flu_Tree_Browser(x, y, w, h, c){}
 
706
    : Fl_Tree(x, y, w, h, c){}
675
707
};
676
708
 
677
709
#endif
682
714
  // accordingly
683
715
  const char *str = (const char*)data;
684
716
  if(str && !strcmp(str, "redraw_only"))
685
 
    GUI::instance()->visibility->show(true);
 
717
    FlGui::instance()->visibility->show(true);
686
718
  else
687
 
    GUI::instance()->visibility->show(false);
 
719
    FlGui::instance()->visibility->show(false);
688
720
 
689
721
  _rebuild_list_browser();
690
 
#if defined(HAVE_TREE_BROWSER)
 
722
#if defined(HAVE_FL_TREE)
691
723
  _rebuild_tree_browser(false);
692
724
#endif
693
 
  GUI::instance()->visibility->updatePerWindow(true);
 
725
  FlGui::instance()->visibility->updatePerWindow(true);
694
726
}
695
727
 
696
728
static void visibility_save_cb(Fl_Widget *w, void *data)
752
784
  bool all = (num < 0) ? true : false;
753
785
 
754
786
  GModel *m = GModel::current();
 
787
  std::vector<GEntity*> entities;
 
788
  m->getEntities(entities);
755
789
 
756
790
  switch(what){
757
791
  case 0: // nodes
758
 
    for(GModel::viter it = m->firstVertex(); it != m->lastVertex(); it++)
759
 
      for(unsigned int i = 0; i < (*it)->mesh_vertices.size(); i++)
760
 
        if(all || (*it)->mesh_vertices[i]->getNum() == num) 
761
 
          (*it)->mesh_vertices[i]->setVisibility(val);
762
 
    for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); it++)
763
 
      for(unsigned int i = 0; i < (*it)->mesh_vertices.size(); i++)
764
 
        if(all || (*it)->mesh_vertices[i]->getNum() == num) 
765
 
          (*it)->mesh_vertices[i]->setVisibility(val);
766
 
    for(GModel::fiter it = m->firstFace(); it != m->lastFace(); it++)
767
 
      for(unsigned int i = 0; i < (*it)->mesh_vertices.size(); i++)
768
 
        if(all || (*it)->mesh_vertices[i]->getNum() == num) 
769
 
          (*it)->mesh_vertices[i]->setVisibility(val);
770
 
    for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); it++)
771
 
      for(unsigned int i = 0; i < (*it)->mesh_vertices.size(); i++)
772
 
        if(all || (*it)->mesh_vertices[i]->getNum() == num) 
773
 
          (*it)->mesh_vertices[i]->setVisibility(val);
 
792
    for(unsigned int i = 0; i < entities.size(); i++){
 
793
      for(unsigned int j = 0; j < entities[i]->mesh_vertices.size(); j++){
 
794
        MVertex *v = entities[i]->mesh_vertices[j];
 
795
        if(all || v->getNum() == num) v->setVisibility(val);
 
796
      }
 
797
    }
774
798
    break;
775
799
  case 1: // elements
776
 
    for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); it++){
777
 
      for(unsigned int i = 0; i < (*it)->lines.size(); i++)
778
 
        if(all || (*it)->lines[i]->getNum() == num) 
779
 
          (*it)->lines[i]->setVisibility(val);
780
 
    }
781
 
    for(GModel::fiter it = m->firstFace(); it != m->lastFace(); it++){
782
 
      for(unsigned int i = 0; i < (*it)->triangles.size(); i++)
783
 
        if(all || (*it)->triangles[i]->getNum() == num) 
784
 
          (*it)->triangles[i]->setVisibility(val);
785
 
      for(unsigned int i = 0; i < (*it)->quadrangles.size(); i++)
786
 
        if(all || (*it)->quadrangles[i]->getNum() == num) 
787
 
          (*it)->quadrangles[i]->setVisibility(val);
788
 
    }
789
 
    for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); it++){
790
 
      for(unsigned int i = 0; i < (*it)->tetrahedra.size(); i++)
791
 
        if(all || (*it)->tetrahedra[i]->getNum() == num) 
792
 
          (*it)->tetrahedra[i]->setVisibility(val);
793
 
      for(unsigned int i = 0; i < (*it)->hexahedra.size(); i++)
794
 
        if(all || (*it)->hexahedra[i]->getNum() == num) 
795
 
          (*it)->hexahedra[i]->setVisibility(val);
796
 
      for(unsigned int i = 0; i < (*it)->prisms.size(); i++)
797
 
        if(all || (*it)->prisms[i]->getNum() == num) 
798
 
          (*it)->prisms[i]->setVisibility(val);
799
 
      for(unsigned int i = 0; i < (*it)->pyramids.size(); i++)
800
 
        if(all || (*it)->pyramids[i]->getNum() == num) 
801
 
          (*it)->pyramids[i]->setVisibility(val);
 
800
    for(unsigned int i = 0; i < entities.size(); i++){
 
801
      for(unsigned int j = 0; j < entities[i]->getNumMeshElements(); j++){
 
802
        MElement *e = entities[i]->getMeshElement(j);
 
803
        if(all || e->getNum() == num) e->setVisibility(val);
 
804
      }
802
805
    }
803
806
    break;
804
807
  case 2: // point
820
823
  case 6: // physical point
821
824
    for(GModel::viter it = m->firstVertex(); it != m->lastVertex(); it++)
822
825
      for(unsigned int i = 0; i < (*it)->physicals.size(); i++)
823
 
        if (all || std::abs((*it)->physicals[i]) == num) (*it)->setVisibility(val, recursive);
 
826
        if (all || std::abs((*it)->physicals[i]) == num)
 
827
          (*it)->setVisibility(val, recursive);
824
828
    break;
825
829
  case 7: // physical line
826
830
    for(GModel::eiter it = m->firstEdge(); it != m->lastEdge(); it++)
827
831
      for(unsigned int i = 0; i < (*it)->physicals.size(); i++)
828
 
        if (all || std::abs((*it)->physicals[i]) == num) (*it)->setVisibility(val, recursive);
 
832
        if (all || std::abs((*it)->physicals[i]) == num) 
 
833
          (*it)->setVisibility(val, recursive);
829
834
    break;
830
835
  case 8: // physical surface
831
836
    for(GModel::fiter it = m->firstFace(); it != m->lastFace(); it++)
832
837
      for(unsigned int i = 0; i < (*it)->physicals.size(); i++)
833
 
        if (all || std::abs((*it)->physicals[i]) == num) (*it)->setVisibility(val, recursive);
 
838
        if (all || std::abs((*it)->physicals[i]) == num) 
 
839
          (*it)->setVisibility(val, recursive);
834
840
    break;
835
841
  case 9: // physical volume
836
842
    for(GModel::riter it = m->firstRegion(); it != m->lastRegion(); it++)
837
843
      for(unsigned int i = 0; i < (*it)->physicals.size(); i++)
838
 
        if (all || std::abs((*it)->physicals[i]) == num) (*it)->setVisibility(val, recursive);
 
844
        if (all || std::abs((*it)->physicals[i]) == num) 
 
845
          (*it)->setVisibility(val, recursive);
839
846
    break;
840
847
  }
841
848
}
847
854
                              std::vector<GRegion*> &regions,
848
855
                              std::vector<MElement*> &elements)
849
856
{
850
 
  bool recursive = GUI::instance()->visibility->butt[0]->value() ? true : false;
 
857
  bool recursive = FlGui::instance()->visibility->butt[0]->value() ? true : false;
851
858
 
852
859
  if(mode == 1){ // when showing a single entity, first hide everything
853
860
    if(CTX::instance()->pickElements)
893
900
          _set_visibility_by_number(9, regions[i]->physicals[j], mode, recursive);
894
901
    }
895
902
  }
896
 
  int pos = GUI::instance()->visibility->browser->position();
 
903
  int pos = FlGui::instance()->visibility->browser->position();
897
904
  visibility_cb(NULL, (void*)"redraw_only");
898
 
  GUI::instance()->visibility->browser->position(pos);
 
905
  FlGui::instance()->visibility->browser->position(pos);
899
906
}
900
907
 
901
908
static void visibility_number_cb(Fl_Widget *w, void *data)
915
922
  else{ // hide
916
923
    val = 0;
917
924
  }
918
 
  const char *str = GUI::instance()->visibility->input[what]->value();
 
925
  const char *str = FlGui::instance()->visibility->input[what]->value();
919
926
 
920
927
  int num = (!strcmp(str, "all") || !strcmp(str, "*")) ? -1 : atoi(str);
921
 
  bool recursive = GUI::instance()->visibility->butt[0]->value() ? true : false;
 
928
  bool recursive = FlGui::instance()->visibility->butt[0]->value() ? true : false;
922
929
  
923
930
  _set_visibility_by_number(what, num, val, recursive);
924
931
 
925
 
  int pos = GUI::instance()->visibility->browser->position();
 
932
  int pos = FlGui::instance()->visibility->browser->position();
926
933
  visibility_cb(NULL, (void*)"redraw_only");
927
 
  GUI::instance()->visibility->browser->position(pos);
928
 
  Draw();
 
934
  FlGui::instance()->visibility->browser->position(pos);
 
935
  drawContext::global()->draw();
929
936
}
930
937
 
931
938
static void visibility_interactive_cb(Fl_Widget *w, void *data)
1001
1008
    for(int i = 1; i <= 5; i++) // elements, points, lines, surfaces, volumes
1002
1009
      _set_visibility_by_number(i, -1, 1, false);
1003
1010
    CTX::instance()->mesh.changed = ENT_ALL;
1004
 
    Draw();  
 
1011
    drawContext::global()->draw();  
1005
1012
    return;
1006
1013
  }
1007
1014
  else
1016
1023
  while(1) {
1017
1024
    if(what == ENT_ALL) 
1018
1025
      CTX::instance()->mesh.changed = ENT_ALL;
1019
 
    Draw();
 
1026
    drawContext::global()->draw();
1020
1027
    Msg::StatusBar(3, false, "Select %s\n[Press %s'q' to abort]", 
1021
1028
                   str.c_str(), mode ? "" : "'u' to undo or ");
1022
1029
 
1023
 
    char ib = GUI::instance()->selectEntity(what);
 
1030
    char ib = FlGui::instance()->selectEntity(what);
1024
1031
    if(ib == 'l') {
1025
1032
      // store for possible undo later
1026
 
      vertices = GUI::instance()->selectedVertices;
1027
 
      edges = GUI::instance()->selectedEdges;
1028
 
      faces = GUI::instance()->selectedFaces;
1029
 
      regions = GUI::instance()->selectedRegions;
1030
 
      elements = GUI::instance()->selectedElements;
 
1033
      vertices = FlGui::instance()->selectedVertices;
 
1034
      edges = FlGui::instance()->selectedEdges;
 
1035
      faces = FlGui::instance()->selectedFaces;
 
1036
      regions = FlGui::instance()->selectedRegions;
 
1037
      elements = FlGui::instance()->selectedElements;
1031
1038
      _apply_visibility(mode, physical, vertices, edges, faces, regions, elements);
1032
1039
    }
1033
1040
    if(ib == 'u' && !mode){ // undo only in hide mode
1040
1047
 
1041
1048
  CTX::instance()->mesh.changed = ENT_ALL;
1042
1049
  CTX::instance()->pickElements = 0;
1043
 
  Draw();  
 
1050
  drawContext::global()->draw();  
1044
1051
  Msg::StatusBar(3, false, "");
1045
1052
}
1046
1053
 
1048
1055
{
1049
1056
  std::string what = (const char*)data;
1050
1057
  if(what == "item"){
1051
 
    drawContext *ctx = GUI::instance()->getCurrentOpenglWindow()->getDrawContext();
1052
 
    for(int i = 0; i < GUI::instance()->visibility->per_window->size(); i++){
 
1058
    drawContext *ctx = FlGui::instance()->getCurrentOpenglWindow()->getDrawContext();
 
1059
    for(unsigned int i = 0; 
 
1060
        i < (unsigned int)FlGui::instance()->visibility->per_window->size(); i++){
1053
1061
      if(i < GModel::list.size()){
1054
1062
        GModel *m = GModel::list[i];
1055
 
        if(GUI::instance()->visibility->per_window->selected(i + 1)) ctx->show(m);
 
1063
        if(FlGui::instance()->visibility->per_window->selected(i + 1)) ctx->show(m);
1056
1064
        else ctx->hide(m);
1057
1065
      }
1058
1066
      else if(i < GModel::list.size() + PView::list.size()){
1059
1067
        PView *v = PView::list[i - GModel::list.size()];
1060
 
        if(GUI::instance()->visibility->per_window->selected(i + 1)) ctx->show(v);
 
1068
        if(FlGui::instance()->visibility->per_window->selected(i + 1)) ctx->show(v);
1061
1069
        else ctx->hide(v);
1062
1070
      }
1063
1071
    }
1064
1072
  }
1065
1073
  else if(what == "reset_all"){
1066
 
    for(unsigned int i = 0; i < GUI::instance()->graph.size(); i++){
1067
 
      for(unsigned int j = 0; j < GUI::instance()->graph[i]->gl.size(); j++){
1068
 
        drawContext *ctx = GUI::instance()->graph[i]->gl[j]->getDrawContext();
 
1074
    for(unsigned int i = 0; i < FlGui::instance()->graph.size(); i++){
 
1075
      for(unsigned int j = 0; j < FlGui::instance()->graph[i]->gl.size(); j++){
 
1076
        drawContext *ctx = FlGui::instance()->graph[i]->gl[j]->getDrawContext();
1069
1077
        ctx->showAll();
1070
1078
      }
1071
1079
    }
1072
 
    for(int i = 0; i < GUI::instance()->visibility->per_window->size(); i++)
1073
 
      GUI::instance()->visibility->per_window->select(i + 1);
 
1080
    for(int i = 0; i < FlGui::instance()->visibility->per_window->size(); i++)
 
1081
      FlGui::instance()->visibility->per_window->select(i + 1);
1074
1082
  }
1075
 
  Draw();
 
1083
  drawContext::global()->draw();
1076
1084
}
1077
1085
 
1078
1086
visibilityWindow::visibilityWindow(int deltaFontSize)
1135
1143
      browser = new listBrowser
1136
1144
        (2 * WB, 2 * WB + 2 * BH, brw, height - 6 * WB - 4 * BH);
1137
1145
      browser->type(FL_MULTI_BROWSER);
 
1146
      browser->textsize(FL_NORMAL_SIZE - 1);
1138
1147
      browser->column_widths(cols);
1139
1148
      
1140
1149
      gg->end();
1164
1173
    g->end();
1165
1174
    Fl_Group::current()->resizable(g);
1166
1175
  }
1167
 
#if defined(HAVE_TREE_BROWSER)
 
1176
#if defined(HAVE_FL_TREE)
1168
1177
  {
1169
1178
    Fl_Group *g = new Fl_Group
1170
1179
      (WB, WB + BH, width - 2 * WB, height - 3 * WB - 2 * BH, "Tree browser");
1171
1180
 
1172
 
    tree = new treeBrowser
1173
 
      (2 * WB, 2 * WB + BH, brw, height - 6 * WB - 3 * BH);
1174
 
    tree->show_root(false);
1175
 
    tree->box(FL_DOWN_BOX);
1176
 
    tree->insertion_mode(FLU_INSERT_BACK);
1177
 
    tree->branch_icons(0, 0);
1178
 
    tree->branch_text(FL_BLACK, FL_HELVETICA_BOLD, FL_NORMAL_SIZE - 1);
1179
 
    tree->leaf_text(FL_BLACK, FL_HELVETICA, FL_NORMAL_SIZE - 1);
 
1181
    tree = new treeBrowser(2 * WB, 2 * WB + BH, brw, height - 6 * WB - 3 * BH);
 
1182
    tree->labelsize(FL_NORMAL_SIZE - 1);
 
1183
    tree->selectmode(FL_TREE_SELECT_MULTI);
 
1184
    tree->connectorstyle(FL_TREE_CONNECTOR_SOLID);
1180
1185
    tree->hide();
1181
1186
 
1182
1187
    tree_create = new Fl_Button
1388
1393
void visibilityWindow::updatePerWindow(bool force)
1389
1394
{
1390
1395
  static openglWindow *gl = 0;
1391
 
  if(!force && gl == GUI::instance()->getCurrentOpenglWindow()) return;
 
1396
  if(!force && gl == FlGui::instance()->getCurrentOpenglWindow()) return;
1392
1397
 
1393
 
  gl = GUI::instance()->getCurrentOpenglWindow();
 
1398
  gl = FlGui::instance()->getCurrentOpenglWindow();
1394
1399
  drawContext *ctx = gl->getDrawContext();
1395
1400
 
1396
1401
  per_window->clear();