758f3f7456
Issue was that the `on_activate()` callback of tree-items were continuously called, because the active-state was queried before we fully reconstructed the tree and its state from the previous redraw. Such issues could happen in more places, so I've refactored the API a bit to reflect the requirements for state queries, and include some sanity checks. The actual fix for the issue is to delay the state change until the tree is fully reconstructed, by letting the tree-items pass a callback to check if they should be active.
439 lines
12 KiB
C++
439 lines
12 KiB
C++
/*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
/** \file
|
|
* \ingroup edinterface
|
|
*/
|
|
|
|
#include "DNA_userdef_types.h"
|
|
|
|
#include "BLT_translation.h"
|
|
|
|
#include "interface_intern.h"
|
|
|
|
#include "UI_interface.h"
|
|
|
|
#include "UI_tree_view.hh"
|
|
|
|
namespace blender::ui {
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* Add a tree-item to the container. This is the only place where items should be added, it handles
|
|
* important invariants!
|
|
*/
|
|
AbstractTreeViewItem &TreeViewItemContainer::add_tree_item(
|
|
std::unique_ptr<AbstractTreeViewItem> item)
|
|
{
|
|
children_.append(std::move(item));
|
|
|
|
/* The first item that will be added to the root sets this. */
|
|
if (root_ == nullptr) {
|
|
root_ = this;
|
|
}
|
|
|
|
AbstractTreeViewItem &added_item = *children_.last();
|
|
added_item.root_ = root_;
|
|
if (root_ != this) {
|
|
/* Any item that isn't the root can be assumed to the a #AbstractTreeViewItem. Not entirely
|
|
* nice to static_cast this, but well... */
|
|
added_item.parent_ = static_cast<AbstractTreeViewItem *>(this);
|
|
}
|
|
|
|
return added_item;
|
|
}
|
|
|
|
void TreeViewItemContainer::foreach_item_recursive(ItemIterFn iter_fn, IterOptions options) const
|
|
{
|
|
for (const auto &child : children_) {
|
|
iter_fn(*child);
|
|
if (bool(options & IterOptions::SkipCollapsed) && child->is_collapsed()) {
|
|
continue;
|
|
}
|
|
|
|
child->foreach_item_recursive(iter_fn, options);
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
void AbstractTreeView::foreach_item(ItemIterFn iter_fn, IterOptions options) const
|
|
{
|
|
foreach_item_recursive(iter_fn, options);
|
|
}
|
|
|
|
void AbstractTreeView::build_layout_from_tree(const TreeViewLayoutBuilder &builder)
|
|
{
|
|
uiLayout *prev_layout = builder.current_layout();
|
|
|
|
uiLayoutColumn(prev_layout, true);
|
|
|
|
foreach_item([&builder](AbstractTreeViewItem &item) { builder.build_row(item); },
|
|
IterOptions::SkipCollapsed);
|
|
|
|
UI_block_layout_set_current(&builder.block(), prev_layout);
|
|
}
|
|
|
|
void AbstractTreeView::update_from_old(uiBlock &new_block)
|
|
{
|
|
uiBlock *old_block = new_block.oldblock;
|
|
if (!old_block) {
|
|
/* Initial construction, nothing to update. */
|
|
is_reconstructed_ = true;
|
|
return;
|
|
}
|
|
|
|
uiTreeViewHandle *old_view_handle = ui_block_view_find_matching_in_old_block(
|
|
&new_block, reinterpret_cast<uiTreeViewHandle *>(this));
|
|
BLI_assert(old_view_handle);
|
|
|
|
AbstractTreeView &old_view = reinterpret_cast<AbstractTreeView &>(*old_view_handle);
|
|
update_children_from_old_recursive(*this, old_view);
|
|
|
|
/* Finished (re-)constructing the tree. */
|
|
is_reconstructed_ = true;
|
|
}
|
|
|
|
void AbstractTreeView::update_children_from_old_recursive(const TreeViewItemContainer &new_items,
|
|
const TreeViewItemContainer &old_items)
|
|
{
|
|
for (const auto &new_item : new_items.children_) {
|
|
AbstractTreeViewItem *matching_old_item = find_matching_child(*new_item, old_items);
|
|
if (!matching_old_item) {
|
|
continue;
|
|
}
|
|
|
|
new_item->update_from_old(*matching_old_item);
|
|
|
|
/* Recurse into children of the matched item. */
|
|
update_children_from_old_recursive(*new_item, *matching_old_item);
|
|
}
|
|
}
|
|
|
|
AbstractTreeViewItem *AbstractTreeView::find_matching_child(
|
|
const AbstractTreeViewItem &lookup_item, const TreeViewItemContainer &items)
|
|
{
|
|
for (const auto &iter_item : items.children_) {
|
|
if (lookup_item.matches(*iter_item)) {
|
|
/* We have a matching item! */
|
|
return iter_item.get();
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
bool AbstractTreeView::is_reconstructed() const
|
|
{
|
|
return is_reconstructed_;
|
|
}
|
|
|
|
void AbstractTreeView::change_state_delayed()
|
|
{
|
|
BLI_assert_msg(
|
|
is_reconstructed(),
|
|
"These state changes are supposed to be delayed until reconstruction is completed");
|
|
foreach_item([](AbstractTreeViewItem &item) { item.change_state_delayed(); });
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
void AbstractTreeViewItem::on_activate()
|
|
{
|
|
/* Do nothing by default. */
|
|
}
|
|
|
|
void AbstractTreeViewItem::is_active(IsActiveFn is_active_fn)
|
|
{
|
|
is_active_fn_ = is_active_fn;
|
|
}
|
|
|
|
bool AbstractTreeViewItem::on_drop(const wmDrag & /*drag*/)
|
|
{
|
|
/* Do nothing by default. */
|
|
return false;
|
|
}
|
|
|
|
bool AbstractTreeViewItem::can_drop(const wmDrag & /*drag*/) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
std::string AbstractTreeViewItem::drop_tooltip(const bContext & /*C*/,
|
|
const wmDrag & /*drag*/,
|
|
const wmEvent & /*event*/) const
|
|
{
|
|
return TIP_("Drop into/onto tree item");
|
|
}
|
|
|
|
void AbstractTreeViewItem::update_from_old(const AbstractTreeViewItem &old)
|
|
{
|
|
is_open_ = old.is_open_;
|
|
is_active_ = old.is_active_;
|
|
}
|
|
|
|
bool AbstractTreeViewItem::matches(const AbstractTreeViewItem &other) const
|
|
{
|
|
return label_ == other.label_;
|
|
}
|
|
|
|
const AbstractTreeView &AbstractTreeViewItem::get_tree_view() const
|
|
{
|
|
return static_cast<AbstractTreeView &>(*root_);
|
|
}
|
|
|
|
int AbstractTreeViewItem::count_parents() const
|
|
{
|
|
int i = 0;
|
|
for (TreeViewItemContainer *parent = parent_; parent; parent = parent->parent_) {
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
void AbstractTreeViewItem::activate()
|
|
{
|
|
BLI_assert_msg(get_tree_view().is_reconstructed(),
|
|
"Item activation can't be done until reconstruction is completed");
|
|
|
|
if (is_active()) {
|
|
return;
|
|
}
|
|
|
|
/* Deactivate other items in the tree. */
|
|
get_tree_view().foreach_item([](auto &item) { item.deactivate(); });
|
|
|
|
on_activate();
|
|
/* Make sure the active item is always visible. */
|
|
ensure_parents_uncollapsed();
|
|
|
|
is_active_ = true;
|
|
}
|
|
|
|
void AbstractTreeViewItem::deactivate()
|
|
{
|
|
is_active_ = false;
|
|
}
|
|
|
|
bool AbstractTreeViewItem::is_active() const
|
|
{
|
|
BLI_assert_msg(get_tree_view().is_reconstructed(),
|
|
"State can't be queried until reconstruction is completed");
|
|
return is_active_;
|
|
}
|
|
|
|
bool AbstractTreeViewItem::is_collapsed() const
|
|
{
|
|
BLI_assert_msg(get_tree_view().is_reconstructed(),
|
|
"State can't be queried until reconstruction is completed");
|
|
return is_collapsible() && !is_open_;
|
|
}
|
|
|
|
void AbstractTreeViewItem::toggle_collapsed()
|
|
{
|
|
is_open_ = !is_open_;
|
|
}
|
|
|
|
void AbstractTreeViewItem::set_collapsed(bool collapsed)
|
|
{
|
|
is_open_ = !collapsed;
|
|
}
|
|
|
|
bool AbstractTreeViewItem::is_collapsible() const
|
|
{
|
|
return !children_.is_empty();
|
|
}
|
|
|
|
void AbstractTreeViewItem::ensure_parents_uncollapsed()
|
|
{
|
|
for (AbstractTreeViewItem *parent = parent_; parent; parent = parent->parent_) {
|
|
parent->set_collapsed(false);
|
|
}
|
|
}
|
|
|
|
void AbstractTreeViewItem::change_state_delayed()
|
|
{
|
|
if (is_active_fn_()) {
|
|
activate();
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
TreeViewBuilder::TreeViewBuilder(uiBlock &block) : block_(block)
|
|
{
|
|
}
|
|
|
|
void TreeViewBuilder::build_tree_view(AbstractTreeView &tree_view)
|
|
{
|
|
tree_view.build_tree();
|
|
tree_view.update_from_old(block_);
|
|
tree_view.change_state_delayed();
|
|
tree_view.build_layout_from_tree(TreeViewLayoutBuilder(block_));
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
TreeViewLayoutBuilder::TreeViewLayoutBuilder(uiBlock &block) : block_(block)
|
|
{
|
|
}
|
|
|
|
void TreeViewLayoutBuilder::build_row(AbstractTreeViewItem &item) const
|
|
{
|
|
uiLayout *prev_layout = current_layout();
|
|
uiLayout *row = uiLayoutRow(prev_layout, false);
|
|
|
|
item.build_row(*row);
|
|
|
|
UI_block_layout_set_current(&block(), prev_layout);
|
|
}
|
|
|
|
uiBlock &TreeViewLayoutBuilder::block() const
|
|
{
|
|
return block_;
|
|
}
|
|
|
|
uiLayout *TreeViewLayoutBuilder::current_layout() const
|
|
{
|
|
return block().curlayout;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
BasicTreeViewItem::BasicTreeViewItem(StringRef label, BIFIconID icon_) : icon(icon_)
|
|
{
|
|
label_ = label;
|
|
}
|
|
|
|
void BasicTreeViewItem::tree_row_click_fn(struct bContext * /*C*/, void *but_arg1, void * /*arg2*/)
|
|
{
|
|
uiButTreeRow *tree_row_but = (uiButTreeRow *)but_arg1;
|
|
BasicTreeViewItem &tree_item = reinterpret_cast<BasicTreeViewItem &>(*tree_row_but->tree_item);
|
|
|
|
/* Let a click on an opened item activate it, a second click will close it then.
|
|
* TODO Should this be for asset catalogs only? */
|
|
if (tree_item.is_collapsed() || tree_item.is_active()) {
|
|
tree_item.toggle_collapsed();
|
|
}
|
|
tree_item.activate();
|
|
}
|
|
|
|
void BasicTreeViewItem::build_row(uiLayout &row)
|
|
{
|
|
uiBlock *block = uiLayoutGetBlock(&row);
|
|
tree_row_but_ = (uiButTreeRow *)uiDefIconTextBut(block,
|
|
UI_BTYPE_TREEROW,
|
|
0,
|
|
/* TODO allow icon besides the chevron icon? */
|
|
get_draw_icon(),
|
|
label_.data(),
|
|
0,
|
|
0,
|
|
UI_UNIT_X,
|
|
UI_UNIT_Y,
|
|
nullptr,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
nullptr);
|
|
|
|
tree_row_but_->tree_item = reinterpret_cast<uiTreeViewItemHandle *>(this);
|
|
UI_but_func_set(&tree_row_but_->but, tree_row_click_fn, tree_row_but_, nullptr);
|
|
UI_but_treerow_indentation_set(&tree_row_but_->but, count_parents());
|
|
}
|
|
|
|
void BasicTreeViewItem::on_activate()
|
|
{
|
|
if (activate_fn_) {
|
|
activate_fn_(*this);
|
|
}
|
|
}
|
|
|
|
void BasicTreeViewItem::on_activate(ActivateFn fn)
|
|
{
|
|
activate_fn_ = fn;
|
|
}
|
|
|
|
BIFIconID BasicTreeViewItem::get_draw_icon() const
|
|
{
|
|
if (icon) {
|
|
return icon;
|
|
}
|
|
|
|
if (is_collapsible()) {
|
|
return is_collapsed() ? ICON_TRIA_RIGHT : ICON_TRIA_DOWN;
|
|
}
|
|
|
|
return ICON_NONE;
|
|
}
|
|
|
|
uiBut *BasicTreeViewItem::button()
|
|
{
|
|
return &tree_row_but_->but;
|
|
}
|
|
|
|
} // namespace blender::ui
|
|
|
|
using namespace blender::ui;
|
|
|
|
bool UI_tree_view_item_is_active(const uiTreeViewItemHandle *item_handle)
|
|
{
|
|
const AbstractTreeViewItem &item = reinterpret_cast<const AbstractTreeViewItem &>(*item_handle);
|
|
return item.is_active();
|
|
}
|
|
|
|
bool UI_tree_view_item_matches(const uiTreeViewItemHandle *a_handle,
|
|
const uiTreeViewItemHandle *b_handle)
|
|
{
|
|
const AbstractTreeViewItem &a = reinterpret_cast<const AbstractTreeViewItem &>(*a_handle);
|
|
const AbstractTreeViewItem &b = reinterpret_cast<const AbstractTreeViewItem &>(*b_handle);
|
|
return a.matches(b);
|
|
}
|
|
|
|
bool UI_tree_view_item_can_drop(const uiTreeViewItemHandle *item_, const wmDrag *drag)
|
|
{
|
|
const AbstractTreeViewItem &item = reinterpret_cast<const AbstractTreeViewItem &>(*item_);
|
|
return item.can_drop(*drag);
|
|
}
|
|
|
|
char *UI_tree_view_item_drop_tooltip(const uiTreeViewItemHandle *item_,
|
|
const bContext *C,
|
|
const wmDrag *drag,
|
|
const wmEvent *event)
|
|
{
|
|
const AbstractTreeViewItem &item = reinterpret_cast<const AbstractTreeViewItem &>(*item_);
|
|
return BLI_strdup(item.drop_tooltip(*C, *drag, *event).c_str());
|
|
}
|
|
|
|
/**
|
|
* Let a tree-view item handle a drop event.
|
|
* \return True if the drop was handled by the tree-view item.
|
|
*/
|
|
bool UI_tree_view_item_drop_handle(uiTreeViewItemHandle *item_, const ListBase *drags)
|
|
{
|
|
AbstractTreeViewItem &item = reinterpret_cast<AbstractTreeViewItem &>(*item_);
|
|
|
|
LISTBASE_FOREACH (const wmDrag *, drag, drags) {
|
|
if (item.can_drop(*drag)) {
|
|
return item.on_drop(*drag);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|