cppconsui/TreeView.cpp

   1 // Copyright (C) 2007 Mark Pustjens <pustjens@dds.nl>
   2 // Copyright (C) 2010-2015 Petr Pavlu <setup@dagobah.cz>
   3 //
   4 // This file is part of CenterIM.
   5 //
   6 // CenterIM is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 2 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // CenterIM is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with CenterIM.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 #include "TreeView.h"
  20
  21 #include "ColorScheme.h"
  22
  23 #include <cassert>
  24
  25 namespace CppConsUI {
  26
  27 TreeView::ToggleCollapseButton::ToggleCollapseButton(
  28   int w, int h, const char *text)
  29   : Button(w, h, text)
  30 {
  31 }
  32
  33 TreeView::ToggleCollapseButton::ToggleCollapseButton(const char *text)
  34   : Button(text)
  35 {
  36 }
  37
  38 void TreeView::ToggleCollapseButton::setParent(Container &parent)
  39 {
  40   TreeView *tree = dynamic_cast<TreeView *>(&parent);
  41   assert(tree != nullptr);
  42
  43   Button::setParent(parent);
  44   signal_activate.connect(
  45     sigc::hide(sigc::mem_fun(tree, &TreeView::actionToggleCollapsed)));
  46 }
  47
  48 TreeView::TreeView(int w, int h) : Container(w, h)
  49 {
  50   // Allow fast focus changing (paging) using PageUp/PageDown keys.
  51   page_focus_ = true;
  52
  53   // Initialise the tree.
  54   TreeNode root;
  55   root.treeview = this;
  56   root.collapsed = false;
  57   root.style = STYLE_NORMAL;
  58   root.widget = nullptr;
  59   thetree_.set_head(root);
  60   focus_node_ = thetree_.begin();
  61
  62   declareBindables();
  63 }
  64
  65 TreeView::~TreeView()
  66 {
  67   clear();
  68 }
  69
  70 int TreeView::draw(Curses::ViewPort area, Error &error)
  71 {
  72   area.scroll(scroll_xpos_, scroll_ypos_);
  73
  74   int attrs;
  75   DRAW(
  76     getAttributes(ColorScheme::PROPERTY_CONTAINER_BACKGROUND, &attrs, error));
  77   DRAW(area.fill(attrs, error));
  78
  79   int height;
  80   DRAW(drawNode(thetree_.begin(), &height, area, error));
  81
  82   return 0;
  83 }
  84
  85 void TreeView::cleanFocus()
  86 {
  87   Container::cleanFocus();
  88   focus_node_ = thetree_.begin();
  89 }
  90
  91 bool TreeView::grabFocus()
  92 {
  93   for (TheTree::pre_order_iterator i = ++thetree_.begin(); i != thetree_.end();
  94        ++i)
  95     if (i->widget->grabFocus())
  96       return true;
  97   return false;
  98 }
  99
 100 void TreeView::clear()
 101 {
 102   TheTree::pre_order_iterator root = thetree_.begin();
 103   while (root.number_of_children() != 0)
 104     deleteNode(++thetree_.begin(), false);
 105
 106   // Stay sane.
 107   assert(children_.empty());
 108 }
 109
 110 bool TreeView::isWidgetVisible(const Widget &child) const
 111 {
 112   if (parent_ == nullptr || !visible_)
 113     return false;
 114
 115   NodeReference node = findNode(child);
 116   if (!isNodeVisible(node))
 117     return false;
 118
 119   return parent_->isWidgetVisible(*this);
 120 }
 121
 122 bool TreeView::setFocusChild(Widget &child)
 123 {
 124   NodeReference node = findNode(child);
 125   if (!isNodeVisible(node))
 126     return false;
 127
 128   bool res = Container::setFocusChild(child);
 129   focus_node_ = node;
 130   return res;
 131 }
 132
 133 void TreeView::getFocusChain(
 134   FocusChain &focus_chain, FocusChain::iterator parent)
 135 {
 136   // It is possible that the predecessor of focused node was just made invisible
 137   // and moveFocus() is called so other widget can take the focus. In this case
 138   // we find top invisible predecessor of focused node and later the focused
 139   // node is placed into the focus chain when this predecessor is reached.
 140   NodeReference act = focus_node_;
 141   NodeReference top = thetree_.begin();
 142   while (act != thetree_.begin()) {
 143     if (!act->widget->isVisible())
 144       top = act;
 145     act = thetree_.parent(act);
 146   }
 147
 148   // The preorder iterator starts with the root so we must skip it.
 149   for (TheTree::pre_order_iterator i = ++thetree_.begin(); i != thetree_.end();
 150        ++i) {
 151     Widget *widget = i->widget;
 152     Container *container = dynamic_cast<Container *>(widget);
 153
 154     if (container != nullptr && container->isVisible()) {
 155       // The widget is a container so add its widgets as well.
 156       FocusChain::pre_order_iterator iter =
 157         focus_chain.append_child(parent, container);
 158       container->getFocusChain(focus_chain, iter);
 159
 160       // If this is not a focusable widget and it has no focusable children,
 161       // remove it from the chain.
 162       if (focus_chain.number_of_children(iter) == 0)
 163         focus_chain.erase(iter);
 164     }
 165     else if (widget->canFocus() && widget->isVisible()) {
 166       // Widget can be focused.
 167       focus_chain.append_child(parent, widget);
 168     }
 169     else if (i == top) {
 170       // This node is the focused node or the focused node is in a subtree of
 171       // this node.
 172
 173       Container *focus_cont = dynamic_cast<Container *>(focus_child_);
 174       if (focus_cont != nullptr) {
 175         // The focused node is actually a Container. First add the Container,
 176         // then the focused widget.
 177         FocusChain::pre_order_iterator iter =
 178           focus_chain.append_child(parent, focus_cont);
 179         focus_chain.append_child(iter, focus_cont->getFocusWidget());
 180       }
 181       else
 182         focus_chain.append_child(parent, focus_child_);
 183     }
 184
 185     if (i->collapsed || !widget->isVisible())
 186       i.skip_children();
 187   }
 188 }
 189
 190 void TreeView::onChildMoveResize(
 191   Widget &activator, const Rect &oldsize, const Rect &newsize)
 192 {
 193   // Sanity check.
 194   assert(newsize.getLeft() == UNSETPOS && newsize.getTop() == UNSETPOS);
 195
 196   assert(activator.getParent() == this);
 197
 198   // Only interested in external height changes.
 199   if (oldsize.getHeight() == newsize.getHeight())
 200     return;
 201
 202   updateArea();
 203 }
 204
 205 void TreeView::onChildWishSizeChange(
 206   Widget &activator, const Size &oldsize, const Size &newsize)
 207 {
 208   assert(activator.getParent() == this);
 209
 210   if (activator.getHeight() != AUTOSIZE)
 211     return;
 212
 213   if (oldsize.getHeight() == newsize.getHeight())
 214     return;
 215
 216   updateArea();
 217 }
 218
 219 void TreeView::onChildVisible(Widget &activator, bool /*visible*/)
 220 {
 221   assert(activator.getParent() == this);
 222
 223   // TreeView children should get rarely hidden.
 224   updateArea();
 225 }
 226
 227 void TreeView::setCollapsed(NodeReference node, bool collapsed)
 228 {
 229   assert(node->treeview == this);
 230
 231   if (node->collapsed == collapsed)
 232     return;
 233
 234   node->collapsed = collapsed;
 235   fixFocus();
 236   updateArea();
 237   redraw();
 238 }
 239
 240 void TreeView::toggleCollapsed(NodeReference node)
 241 {
 242   assert(node->treeview == this);
 243
 244   node->collapsed = !node->collapsed;
 245   fixFocus();
 246   updateArea();
 247   redraw();
 248 }
 249
 250 void TreeView::actionToggleCollapsed()
 251 {
 252   toggleCollapsed(focus_node_);
 253 }
 254
 255 TreeView::NodeReference TreeView::insertNode(
 256   NodeReference position, Widget &widget)
 257 {
 258   assert(position->treeview == this);
 259
 260   TreeNode node = addNode(widget);
 261   NodeReference iter = thetree_.insert(position, node);
 262   addWidget(widget, UNSETPOS, UNSETPOS);
 263   updateArea();
 264   return iter;
 265 }
 266
 267 TreeView::NodeReference TreeView::insertNodeAfter(
 268   NodeReference position, Widget &widget)
 269 {
 270   assert(position->treeview == this);
 271
 272   TreeNode node = addNode(widget);
 273   NodeReference iter = thetree_.insert_after(position, node);
 274   addWidget(widget, UNSETPOS, UNSETPOS);
 275   updateArea();
 276   return iter;
 277 }
 278
 279 TreeView::NodeReference TreeView::prependNode(
 280   NodeReference parent, Widget &widget)
 281 {
 282   assert(parent->treeview == this);
 283
 284   TreeNode node = addNode(widget);
 285   NodeReference iter = thetree_.prepend_child(parent, node);
 286   addWidget(widget, UNSETPOS, UNSETPOS);
 287   updateArea();
 288   return iter;
 289 }
 290
 291 TreeView::NodeReference TreeView::appendNode(
 292   NodeReference parent, Widget &widget)
 293 {
 294   assert(parent->treeview == this);
 295
 296   TreeNode node = addNode(widget);
 297   NodeReference iter = thetree_.append_child(parent, node);
 298   addWidget(widget, UNSETPOS, UNSETPOS);
 299   updateArea();
 300   return iter;
 301 }
 302
 303 void TreeView::deleteNode(NodeReference node, bool keepchildren)
 304 {
 305   assert(node->treeview == this);
 306
 307   // If we want to keep child nodes we should flatten the tree.
 308   if (keepchildren)
 309     thetree_.flatten(node);
 310
 311   int shrink = 0;
 312   if (node->widget) {
 313     int h = node->widget->getHeight();
 314     if (h == AUTOSIZE) {
 315       h = node->widget->getWishHeight();
 316       if (h == AUTOSIZE)
 317         h = 1;
 318     }
 319     shrink += h;
 320   }
 321
 322   while (thetree_.number_of_children(node) != 0) {
 323     TheTree::pre_order_iterator i = thetree_.begin_leaf(node);
 324     int h = i->widget->getHeight();
 325     if (h == AUTOSIZE) {
 326       h = i->widget->getWishHeight();
 327       if (h == AUTOSIZE)
 328         h = 1;
 329     }
 330     shrink += h;
 331
 332     // Remove the widget and instantly remove it from the tree.
 333     removeWidget(*i->widget);
 334     thetree_.erase(i);
 335   }
 336
 337   if (node->widget != nullptr)
 338     removeWidget(*node->widget);
 339
 340   thetree_.erase(node);
 341   updateArea();
 342   redraw();
 343 }
 344
 345 void TreeView::deleteNodeChildren(NodeReference node, bool keepchildren)
 346 {
 347   assert(node->treeview == this);
 348
 349   SiblingIterator i;
 350   while ((i = node.begin()) != node.end())
 351     deleteNode(i, keepchildren);
 352 }
 353
 354 TreeView::NodeReference TreeView::getSelectedNode() const
 355 {
 356   return focus_node_;
 357 }
 358
 359 int TreeView::getNodeDepth(NodeReference node) const
 360 {
 361   assert(node->treeview == this);
 362
 363   return thetree_.depth(node);
 364 }
 365
 366 void TreeView::moveNodeBefore(NodeReference node, NodeReference position)
 367 {
 368   assert(node->treeview == this);
 369   assert(position->treeview == this);
 370
 371   if (thetree_.previous_sibling(position) == node)
 372     return;
 373
 374   thetree_.move_before(position, node);
 375   fixFocus();
 376   updateArea();
 377   redraw();
 378 }
 379
 380 void TreeView::moveNodeAfter(NodeReference node, NodeReference position)
 381 {
 382   assert(node->treeview == this);
 383   assert(position->treeview == this);
 384
 385   if (thetree_.next_sibling(position) == node)
 386     return;
 387
 388   thetree_.move_after(position, node);
 389   fixFocus();
 390   updateArea();
 391   redraw();
 392 }
 393
 394 void TreeView::setNodeParent(NodeReference node, NodeReference newparent)
 395 {
 396   assert(node->treeview == this);
 397   assert(newparent->treeview == this);
 398
 399   if (thetree_.parent(node) == newparent)
 400     return;
 401
 402   thetree_.move_ontop(thetree_.append_child(newparent), node);
 403   fixFocus();
 404   updateArea();
 405   redraw();
 406 }
 407
 408 void TreeView::setNodeStyle(NodeReference node, Style s)
 409 {
 410   assert(node->treeview == this);
 411
 412   if (node->style == s)
 413     return;
 414
 415   node->style = s;
 416   updateArea();
 417   redraw();
 418 }
 419
 420 TreeView::Style TreeView::getNodeStyle(NodeReference node) const
 421 {
 422   assert(node->treeview == this);
 423
 424   return node->style;
 425 }
 426
 427 void TreeView::updateArea()
 428 {
 429   repositionChildren(thetree_.begin(), 0, true);
 430
 431   // Make sure that the currently focused widget is visible.
 432   updateScroll();
 433 }
 434
 435 int TreeView::drawNode(
 436   SiblingIterator node, int *out_height, Curses::ViewPort &area, Error &error)
 437 {
 438   assert(out_height != nullptr);
 439
 440   int top = 0;
 441   *out_height = 0;
 442
 443   // Draw the node Widget first.
 444   if (node->widget) {
 445     if (!node->widget->isVisible())
 446       return 0;
 447
 448     DRAW(drawChild(*node->widget, area, error));
 449
 450     top = node->widget->getRealTop();
 451     int h = node->widget->getRealHeight();
 452     assert(h != AUTOSIZE);
 453     *out_height += h;
 454   }
 455
 456   // If the node is collapsed or not openable then everything is done.
 457   if (node->collapsed || !isNodeOpenable(node))
 458     return 0;
 459
 460   int depthoffset = thetree_.depth(node) * 2;
 461   SiblingIterator i;
 462   int j;
 463
 464   int attrs;
 465   DRAW(getAttributes(ColorScheme::PROPERTY_TREEVIEW_LINE, &attrs, error));
 466   DRAW(area.attrOn(attrs, error));
 467
 468   for (j = 1; j < *out_height; ++j)
 469     DRAW(area.addLineChar(depthoffset, top + j, Curses::LINE_VLINE, error));
 470
 471   // Note: It would be better to start from the end towards the beginning but
 472   // for some reason it does not seem to work.
 473   SiblingIterator last = node.begin();
 474   for (i = node.begin(); i != node.end(); ++i) {
 475     if (i->widget == nullptr)
 476       continue;
 477
 478     if (!i->widget->isVisible())
 479       continue;
 480
 481     int h = i->widget->getRealHeight();
 482     assert(h != AUTOSIZE);
 483     if (h > 0)
 484       last = i;
 485   }
 486   SiblingIterator end = last;
 487   ++end;
 488   for (i = node.begin(); i != end; ++i) {
 489     if (i != last)
 490       DRAW(area.addLineChar(
 491         depthoffset, top + *out_height, Curses::LINE_LTEE, error));
 492     else
 493       DRAW(area.addLineChar(
 494         depthoffset, top + *out_height, Curses::LINE_LLCORNER, error));
 495
 496     if (i->style == STYLE_NORMAL && isNodeOpenable(i)) {
 497       const char *c = i->collapsed ? "[+]" : "[-]";
 498       DRAW(area.addString(depthoffset + 1, top + *out_height, c, error));
 499     }
 500     else
 501       DRAW(area.addLineChar(
 502         depthoffset + 1, top + *out_height, Curses::LINE_HLINE, error));
 503
 504     DRAW(area.attrOff(attrs, error));
 505     int oldh = *out_height;
 506     int child_height;
 507     DRAW(drawNode(i, &child_height, area, error));
 508     *out_height += child_height;
 509     DRAW(area.attrOn(attrs, error));
 510
 511     if (i != last)
 512       for (j = oldh + 1; j < *out_height; ++j)
 513         DRAW(area.addLineChar(depthoffset, top + j, Curses::LINE_VLINE, error));
 514   }
 515   DRAW(area.attrOff(attrs, error));
 516
 517   return 0;
 518 }
 519
 520 TreeView::TreeNode TreeView::addNode(Widget &widget)
 521 {
 522   // Make room for this widget.
 523   int h = widget.getHeight();
 524   if (h == AUTOSIZE) {
 525     h = widget.getWishHeight();
 526     if (h == AUTOSIZE)
 527       h = 1;
 528   }
 529
 530   // Construct the new node.
 531   TreeNode node;
 532   node.treeview = this;
 533   node.collapsed = false;
 534   node.style = STYLE_NORMAL;
 535   node.widget = &widget;
 536
 537   return node;
 538 }
 539
 540 void TreeView::fixFocus()
 541 {
 542   // This function is called when a widget tree is reorganized (a node was moved
 543   // in another position in the tree). In this case, it is possible that there
 544   // can be revealed a widget that could grab the focus (if there is no focused
 545   // widget yet) or it is also possible that the currently focused widget was
 546   // hidden by this reorganization (then the focus has to be handled to another
 547   // widget).
 548
 549   updateFocusChain();
 550
 551   Container *t = getTopContainer();
 552   Widget *focus = t->getFocusWidget();
 553   if (focus == nullptr) {
 554     // Try to grab the focus.
 555     t->moveFocus(FOCUS_DOWN);
 556   }
 557   else if (!focus->isVisibleRecursive()) {
 558     // Move focus.
 559     t->moveFocus(FOCUS_DOWN);
 560   }
 561 }
 562
 563 TreeView::NodeReference TreeView::findNode(const Widget &child) const
 564 {
 565   /// @todo Speed up this algorithm.
 566   TheTree::pre_order_iterator i;
 567   for (i = thetree_.begin(); i != thetree_.end(); ++i)
 568     if (i->widget == &child)
 569       break;
 570   assert(i != thetree_.end());
 571   return i;
 572 }
 573
 574 bool TreeView::isNodeOpenable(SiblingIterator &node) const
 575 {
 576   for (SiblingIterator i = node.begin(); i != node.end(); ++i) {
 577     if (!i->widget)
 578       continue;
 579     int h = i->widget->getHeight();
 580     if (h == AUTOSIZE) {
 581       h = i->widget->getWishHeight();
 582       if (h == AUTOSIZE)
 583         h = 1;
 584     }
 585     if (h > 0 && i->widget->isVisible())
 586       return true;
 587   }
 588   return false;
 589 }
 590
 591 bool TreeView::isNodeVisible(NodeReference &node) const
 592 {
 593   // Node is visible if all predecessors are visible and open.
 594   NodeReference act = node;
 595   bool first = true;
 596   while (act != thetree_.begin()) {
 597     if (!act->widget->isVisible() || (!first && act->collapsed))
 598       return false;
 599     first = false;
 600     act = thetree_.parent(act);
 601   }
 602   return true;
 603 }
 604
 605 int TreeView::repositionChildren(SiblingIterator node, int top, bool in_visible)
 606 {
 607   int height = 0;
 608
 609   // Position the node Widget first.
 610   Widget *widget = node->widget;
 611   if (widget != nullptr) {
 612     int l = thetree_.depth(node) * 2;
 613     l += (node->style == STYLE_NORMAL && isNodeOpenable(node)) ? 3 : 1;
 614     widget->setRealPosition(l, top);
 615
 616     // Calculate the real width.
 617     int w = widget->getWidth();
 618     if (w == AUTOSIZE) {
 619       w = widget->getWishWidth();
 620       if (w == AUTOSIZE)
 621         w = real_width_ - l;
 622     }
 623     if (w > real_width_)
 624       w = real_width_;
 625
 626     // Calculate the real height.
 627     int h = widget->getHeight();
 628     if (h == AUTOSIZE) {
 629       h = widget->getWishHeight();
 630       if (h == AUTOSIZE)
 631         h = 1;
 632     }
 633
 634     widget->setRealSize(w, h);
 635
 636     if (in_visible && widget->isVisible())
 637       height += h;
 638   }
 639
 640   in_visible = in_visible && !node->collapsed && isNodeOpenable(node);
 641
 642   // Position child nodes.
 643   int children_height = height;
 644   for (SiblingIterator i = node.begin(); i != node.end(); ++i)
 645     children_height += repositionChildren(i, top + children_height, in_visible);
 646
 647   if (!in_visible)
 648     assert(children_height == height);
 649
 650   return children_height;
 651 }
 652
 653 void TreeView::actionCollapse()
 654 {
 655   setCollapsed(focus_node_, true);
 656 }
 657
 658 void TreeView::actionExpand()
 659 {
 660   setCollapsed(focus_node_, false);
 661 }
 662
 663 void TreeView::declareBindables()
 664 {
 665   declareBindable("treeview", "fold-subtree",
 666     sigc::mem_fun(this, &TreeView::actionCollapse),
 667     InputProcessor::BINDABLE_NORMAL);
 668   declareBindable("treeview", "unfold-subtree",
 669     sigc::mem_fun(this, &TreeView::actionExpand),
 670     InputProcessor::BINDABLE_NORMAL);
 671 }
 672
 673 } // namespace CppConsUI
 674
 675 // vim: set tabstop=2 shiftwidth=2 textwidth=80 expandtab: