Blender V5.3
grid_view.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cfloat>
10#include <cmath>
11#include <limits>
12#include <optional>
13#include <stdexcept>
14
15#include "BKE_context.hh"
16#include "BKE_icons.hh"
17
18#include "BLI_index_range.hh"
19
20#include "WM_types.hh"
21
22#include "RNA_access.hh"
23
24#include "UI_interface_c.hh"
26#include "UI_view2d.hh"
27#include "interface_intern.hh"
28
29#include "UI_grid_view.hh"
30
31namespace blender::ui {
32
33/* ---------------------------------------------------------------------- */
34
36
37AbstractGridViewItem &AbstractGridView::add_item(std::unique_ptr<AbstractGridViewItem> item)
38{
39 items_.append(std::move(item));
40
41 AbstractGridViewItem &added_item = *items_.last();
42 item_map_.add(added_item.identifier_, &added_item);
43 this->register_item(added_item);
44
45 return added_item;
46}
47
48void AbstractGridView::foreach_view_item(FunctionRef<void(AbstractViewItem &)> iter_fn) const
49{
50 /* Implementation for the base class virtual function. More specialized iterators below. */
51
52 for (const auto &item_ptr : items_) {
53 iter_fn(*item_ptr);
54 }
55}
56
58{
59 for (const auto &item_ptr : items_) {
60 iter_fn(*item_ptr);
61 }
62}
63
65{
66 for (const auto &item_ptr : items_) {
67 if (item_ptr->is_filtered_visible()) {
68 iter_fn(*item_ptr);
69 }
70 }
71}
72
73AbstractGridViewItem *AbstractGridView::find_matching_item(
74 const AbstractGridViewItem &item_to_match, const AbstractGridView &view_to_search_in) const
75{
76 AbstractGridViewItem *const *match = view_to_search_in.item_map_.lookup_ptr(
77 item_to_match.identifier_);
78 BLI_assert(!match || item_to_match.matches(**match));
79
80 return match ? *match : nullptr;
81}
82
83void AbstractGridView::update_children_from_old(const AbstractView &old_view)
84{
85 const AbstractGridView &old_grid_view = dynamic_cast<const AbstractGridView &>(old_view);
86
87 this->foreach_item([this, &old_grid_view](AbstractGridViewItem &new_item) {
88 const AbstractGridViewItem *matching_old_item = find_matching_item(new_item, old_grid_view);
89 if (!matching_old_item) {
90 return;
91 }
92
93 new_item.update_from_old(*matching_old_item);
94 });
95}
96
98{
99 return style_;
100}
101
103{
104 return items_.size();
105}
106
108{
110 return *item_count_filtered_;
111 }
112
113 int i = 0;
114 this->foreach_filtered_item([&i](const auto &) { i++; });
115
116 BLI_assert(i <= this->get_item_count());
118 return i;
119}
120
121void AbstractGridView::set_tile_size(int tile_width, int tile_height)
122{
123 style_.tile_width = tile_width;
124 style_.tile_height = tile_height;
125}
126
127static std::optional<int> find_filtered_item_index(const AbstractGridViewItem &item)
128{
130
131 const AbstractGridView &view = item.get_view();
132 std::optional<int> index;
133
134 int i = 0;
135 view.foreach_filtered_item([&](AbstractGridViewItem &iter_item) {
136 if (&item == &iter_item) {
137 index = i;
138 }
139 i++;
140 });
141
142 return index;
143}
144
146{
147 AbstractViewItem *active_item = nullptr;
148 AbstractViewItem *first_visible_item = nullptr;
149 this->foreach_filtered_item([&](AbstractViewItem &item) {
150 if (item.is_active()) {
151 active_item = &item;
152 }
153 if (!first_visible_item) {
154 first_visible_item = &item;
155 }
156 });
157 return active_item ? active_item : first_visible_item;
158}
159
161{
162 AbstractViewItem *next_item = nullptr;
163 bool found_active = false;
164 this->foreach_filtered_item([&](AbstractViewItem &item) {
165 found_active |= (&item == from);
166 if (!found_active) {
167 next_item = &item;
168 }
169 });
170
171 return found_active ? next_item : from;
172}
173
175{
176 AbstractViewItem *next_item = nullptr;
177 bool found_active = false;
178 this->foreach_filtered_item([&](AbstractViewItem &item) {
179 if (found_active) {
180 /* Store the element next to the active. */
181 next_item = &item;
182 found_active = false;
183 }
184 found_active = (&item == from);
185 });
186
187 return next_item ? next_item : from;
188}
189
191{
192 const std::optional<int> from_index = find_filtered_item_index(
193 dynamic_cast<const AbstractGridViewItem &>(*from));
194
195 const int next_item_index = std::clamp(
196 *from_index - cols_per_row_, 0, get_item_count_filtered() - 1);
197
198 int i = 0;
199 AbstractViewItem *next_item = nullptr;
200 this->foreach_filtered_item([&](AbstractViewItem &item) {
201 if (i == next_item_index) {
202 next_item = &item;
203 }
204 i++;
205 });
206 return next_item ? next_item : from;
207}
208
210{
211 const std::optional<int> from_index = find_filtered_item_index(
212 dynamic_cast<const AbstractGridViewItem &>(*from));
213
214 const int next_item_index = std::clamp(
215 *from_index + cols_per_row_, 0, get_item_count_filtered() - 1);
216
217 int i = 0;
218 AbstractViewItem *next_item = nullptr;
219 this->foreach_filtered_item([&](AbstractViewItem &item) {
220 if (i == next_item_index) {
221 next_item = &item;
222 }
223 i++;
224 });
225
226 return next_item ? next_item : from;
227}
228
230{
231 ARegion *region = CTX_wm_region(C);
232 View2D &v2d = region->v2d;
233
234 const IndexRange &visible_range = this->get_visible_range(v2d, nullptr);
235 const int first_idx_in_view = visible_range.first();
236
237 const int cur_height = BLI_rctf_size_y(&v2d.cur);
238 const int view_height = BLI_rcti_size_y(&v2d.mask);
239 const int tot_height = BLI_rctf_size_y(&v2d.tot);
240 const int count_rows_in_view = std::max(view_height / style_.tile_height, 1);
241 const int tot_rows = std::max(tot_height / style_.tile_height, 1);
242
243 switch (direction) {
245 const int target_row = std::max(0, (first_idx_in_view / cols_per_row_) - count_rows_in_view);
246 v2d.cur.ymax = v2d.tot.ymax - target_row * style_.tile_height;
247 v2d.cur.ymin = v2d.cur.ymax - cur_height;
248 break;
249 }
251 const int target_row = std::min(tot_rows,
252 (first_idx_in_view / cols_per_row_) + count_rows_in_view);
253 v2d.cur.ymax = v2d.tot.ymax - target_row * style_.tile_height;
254 v2d.cur.ymin = v2d.cur.ymax - cur_height;
255 break;
256 }
258 v2d.cur.ymax = v2d.tot.ymax;
259 v2d.cur.ymin = v2d.cur.ymax - cur_height;
260 break;
261 }
263 v2d.cur.ymin = v2d.tot.ymin;
264 v2d.cur.ymax = v2d.cur.ymin + cur_height;
265 break;
266 }
267 }
268}
269
271 const View2D &v2d, const AbstractGridViewItem *force_visible_item) const
272{
274
275 int first_idx_in_view = 0;
276
277 const float scroll_ofs_y = std::abs(v2d.cur.ymax - v2d.tot.ymax);
278 if (!IS_EQF(scroll_ofs_y, 0)) {
279 const int scrolled_away_rows = int(scroll_ofs_y) / style_.tile_height;
280
281 first_idx_in_view = scrolled_away_rows * cols_per_row_;
282 }
283
284 const int view_height = BLI_rcti_size_y(&v2d.mask);
285 const int count_rows_in_view = std::max(view_height / style_.tile_height, 1);
286 const int max_items_in_view = (count_rows_in_view + 1) * cols_per_row_;
287 BLI_assert(max_items_in_view > 0);
288
289 IndexRange visible_items(first_idx_in_view, max_items_in_view);
290
291 /* Ensure #visible_items contains #force_visible_item, adjust if necessary. */
292 if (force_visible_item && force_visible_item->is_filtered_visible()) {
293 if (std::optional<int> item_idx = find_filtered_item_index(*force_visible_item)) {
294 if (!visible_items.contains(*item_idx)) {
295 /* Move range so the first row contains #force_visible_item. */
296 return IndexRange((item_idx == 0) ? 0 : *item_idx % cols_per_row_, max_items_in_view);
297 }
298 }
299 }
300
301 return visible_items;
302}
303
304void AbstractGridView::scroll_active_into_view(bContext *C, bool scroll_active_to_center)
305{
306 int index = 0;
307 this->foreach_filtered_item([&](AbstractViewItem &item) {
308 if (item.is_active()) {
309 Button *but = reinterpret_cast<Button *>(item.view_item_button());
310 ARegion *region = CTX_wm_region(C);
311 rctf rect;
312 View2D &v2d = region->v2d;
313 if (but) {
314 rctf region_rect;
315 block_to_region_rctf(region, but->block, &region_rect, &but->rect);
316
317 view2d_region_to_view_rctf(&v2d, &region_rect, &rect);
318 }
319
320 const IndexRange &visible_range = this->get_visible_range(v2d, nullptr);
321 int first_idx_in_view = visible_range.first();
322 int last_idx_in_view = visible_range.last();
323
324 if (but) {
325 /* When button is slightly outside the view, clamp region to button's height, see: !159566
326 */
327 first_idx_in_view += rect.ymax > v2d.cur.ymax ? cols_per_row_ : 0;
328 last_idx_in_view -= rect.ymin < v2d.cur.ymin ? cols_per_row_ : 0;
329 }
330
331 const int view_height = BLI_rcti_size_y(&v2d.mask);
332 const int count_rows_in_view = std::max(view_height / style_.tile_height, 1);
333
334 if (index < first_idx_in_view) {
335 int target_row = index / cols_per_row_;
336 target_row -= scroll_active_to_center ? count_rows_in_view / 2 : 0;
337 const int cur_height = BLI_rctf_size_y(&v2d.cur);
338 v2d.cur.ymax = v2d.tot.ymax - target_row * style_.tile_height;
339 v2d.cur.ymin = v2d.cur.ymax - cur_height;
340 }
341 else if (index >= last_idx_in_view) {
342 int target_row = (index / cols_per_row_) + 1;
343 target_row += scroll_active_to_center ? count_rows_in_view / 2 : 0;
344 const int cur_height = BLI_rctf_size_y(&v2d.cur);
345 v2d.cur.ymin = v2d.tot.ymax - target_row * style_.tile_height - 2 * U.pixelsize;
346 v2d.cur.ymax = v2d.cur.ymin + cur_height;
347 }
348 }
349 index++;
350 });
351}
352
353GridViewStyle::GridViewStyle(int width, int height) : tile_width(width), tile_height(height) {}
354
355/* ---------------------------------------------------------------------- */
356
358
360{
361 const AbstractGridViewItem &other_grid_item = dynamic_cast<const AbstractGridViewItem &>(other);
362 return identifier_ == other_grid_item.identifier_;
363}
364
365void AbstractGridViewItem::add_grid_tile_button(Block &block)
366{
367 const GridViewStyle &style = this->get_view().get_style();
368 view_item_but_ = static_cast<ButtonViewItem *>(uiDefBut(&block,
370 "",
371 0,
372 0,
373 style.tile_width,
374 style.tile_height,
375 nullptr,
376 0,
377 0,
378 ""));
379
381}
382
383std::optional<std::string> AbstractGridViewItem::debug_name() const
384{
385 return identifier_;
386}
387
389{
390 if (!view_) [[unlikely]] {
391 throw std::runtime_error(
392 "Invalid state, item must be added through AbstractGridView::add_item()");
393 }
394 return dynamic_cast<AbstractGridView &>(*view_);
395}
396
397/* ---------------------------------------------------------------------- */
398
399std::unique_ptr<DropTargetInterface> AbstractGridViewItem::create_item_drop_target()
400{
401 return create_drop_target();
402}
403
404std::unique_ptr<GridViewItemDropTarget> AbstractGridViewItem::create_drop_target()
405{
406 return nullptr;
407}
408
410
411/* ---------------------------------------------------------------------- */
412
430 const AbstractGridView &grid_view_;
431 const GridViewStyle &style_;
432 const int cols_per_row_ = 0;
433 /* Indices of items within the view. Calculated by constructor. If this is unset it means all
434 * items/buttons should be drawn. */
435 std::optional<IndexRange> visible_items_range_;
436
437 public:
439 const AbstractGridView &grid_view,
440 int cols_per_row,
441 const AbstractGridViewItem *force_visible_item);
442
443 bool is_item_visible(int item_idx) const;
444 void fill_layout_before_visible(Block &block) const;
445 void fill_layout_after_visible(Block &block) const;
446
447 private:
448 IndexRange get_visible_range(const View2D &v2d,
449 const AbstractGridViewItem *force_visible_item) const;
450 void add_spacer_button(Block &block, int row_count) const;
451};
452
454 const View2D &v2d,
455 const AbstractGridView &grid_view,
456 const int cols_per_row,
457 const AbstractGridViewItem *force_visible_item)
458 : grid_view_(grid_view), style_(grid_view.get_style()), cols_per_row_(cols_per_row)
459{
460 if (v2d.flag & V2D_IS_INIT && grid_view.get_item_count_filtered()) {
461 visible_items_range_ = this->grid_view_.get_visible_range(v2d, force_visible_item);
462 }
463}
464
466{
467 return !visible_items_range_ || visible_items_range_->contains(item_idx);
468}
469
471{
472 if (!visible_items_range_ || visible_items_range_->is_empty()) {
473 return;
474 }
475 const int first_idx_in_view = visible_items_range_->first();
476 if (first_idx_in_view < 1) {
477 return;
478 }
479 const int tot_tiles_before_visible = first_idx_in_view;
480 const int scrolled_away_rows = tot_tiles_before_visible / cols_per_row_;
481 this->add_spacer_button(block, scrolled_away_rows);
482}
483
485{
486 if (!visible_items_range_ || visible_items_range_->is_empty()) {
487 return;
488 }
489 const int last_item_idx = grid_view_.get_item_count_filtered() - 1;
490 const int last_visible_idx = visible_items_range_->last();
491
492 if (last_item_idx > last_visible_idx) {
493 const int remaining_rows = (cols_per_row_ > 0) ? ceilf((last_item_idx - last_visible_idx) /
494 float(cols_per_row_)) :
495 0;
496 BuildOnlyVisibleButtonsHelper::add_spacer_button(block, remaining_rows);
497 }
498}
499
500void BuildOnlyVisibleButtonsHelper::add_spacer_button(Block &block, const int row_count) const
501{
502 /* UI code only supports button dimensions of `signed short` size, the layout height we want to
503 * fill may be bigger than that. So add multiple labels of the maximum size if necessary. */
504 for (int remaining_rows = row_count; remaining_rows > 0;) {
505 const short row_count_this_iter = std::min(
506 std::numeric_limits<short>::max() / style_.tile_height, remaining_rows);
507
508 uiDefBut(&block,
510 "",
511 0,
512 0,
513 UI_UNIT_X,
514 row_count_this_iter * style_.tile_height,
515 nullptr,
516 0,
517 0,
518 "");
519 remaining_rows -= row_count_this_iter;
520 }
521}
522
523/* ---------------------------------------------------------------------- */
524
526 Block &block_;
527
528 friend class GridViewBuilder;
529
530 public:
532
533 void build_from_view(const bContext &C, AbstractGridView &grid_view, const View2D &v2d) const;
534
535 private:
536 void build_grid_tile(const bContext &C, Layout &grid_layout, AbstractGridViewItem &item) const;
537
538 Layout &current_layout() const;
539};
540
541GridViewLayoutBuilder::GridViewLayoutBuilder(Layout &layout) : block_(*layout.block()) {}
542
543void GridViewLayoutBuilder::build_grid_tile(const bContext &C,
544 Layout &grid_layout,
545 AbstractGridViewItem &item) const
546{
547 Layout &overlap = grid_layout.overlap();
548 overlap.fixed_size_set(true);
549
550 item.add_grid_tile_button(block_);
551 item.build_grid_tile(C, overlap.row(false));
552}
553
555 AbstractGridView &grid_view,
556 const View2D &v2d) const
557{
558 Layout &parent_layout = this->current_layout();
559
560 Layout &layout = parent_layout.column(true);
561 const GridViewStyle &style = grid_view.get_style();
562
563 /* We might not actually know the width available for the grid view. Let's just assume that
564 * either there is a fixed width defined via #uiLayoutSetUnitsX() or that the layout is close to
565 * the root level and inherits its width. Might need a more reliable method. */
566 const int guessed_layout_width = (parent_layout.ui_units_x() > 0) ?
567 parent_layout.ui_units_x() * UI_UNIT_X :
568 parent_layout.width();
569 const int cols_per_row = std::max(guessed_layout_width / style.tile_width, 1);
570 grid_view.cols_per_row_ = cols_per_row;
571
572 const AbstractGridViewItem *search_highlight_item = dynamic_cast<const AbstractGridViewItem *>(
573 grid_view.search_highlight_item());
574
575 BuildOnlyVisibleButtonsHelper build_visible_helper(
576 v2d, grid_view, cols_per_row, search_highlight_item);
577
578 build_visible_helper.fill_layout_before_visible(block_);
579
580 int item_idx = 0;
581 Layout *row = nullptr;
582 grid_view.foreach_filtered_item([&](AbstractGridViewItem &item) {
583 /* Skip if item isn't visible. */
584 if (!build_visible_helper.is_item_visible(item_idx)) {
585 item_idx++;
586 return;
587 }
588
589 /* Start a new row for every first item in the row. */
590 if ((item_idx % cols_per_row) == 0) {
591 row = &layout.row(true);
592 }
593
594 this->build_grid_tile(C, *row, item);
595 item_idx++;
596 });
597
598 block_layout_set_current(&block_, &parent_layout);
599
600 build_visible_helper.fill_layout_after_visible(block_);
601}
602
603Layout &GridViewLayoutBuilder::current_layout() const
604{
605 return *block_.curlayout;
606}
607
608/* ---------------------------------------------------------------------- */
609
611
613 AbstractGridView &grid_view,
614 Layout &layout,
615 std::optional<StringRef> search_string)
616{
617 Block &block = *layout.block();
618
620 block_view_persistent_state_restore(*region, block, grid_view);
621
622 grid_view.build_items();
623 grid_view.update_from_old(block);
624 grid_view.change_state_delayed();
625 grid_view.filter(search_string);
626
627 if (grid_view.get_item_count_filtered() == 0) {
628 return;
629 }
630
631 /* Ensure the given layout is actually active. */
632 block_layout_set_current(&block, &layout);
633
634 GridViewLayoutBuilder builder(layout);
635 builder.build_from_view(C, grid_view, region->v2d);
636}
637
638/* ---------------------------------------------------------------------- */
639
644
646 BIFIconID override_preview_icon_id) const
647{
648 const GridViewStyle &style = this->get_view().get_style();
649 Block *block = layout.block();
650
652 [this](const Button * /*but*/) { return label; });
653
654 Button *but = uiDefBut(block,
656 hide_label_ ? "" : label,
657 0,
658 0,
659 style.tile_width,
660 style.tile_height,
661 nullptr,
662 0,
663 0,
664 "");
665
666 const BIFIconID icon_id = override_preview_icon_id ? override_preview_icon_id : preview_icon_id;
667
668 def_but_icon(but,
669 icon_id,
670 /* NOLINTNEXTLINE: bugprone-suspicious-enum-usage */
672 but->emboss = EmbossType::None;
673}
674
675void PreviewGridItem::build_grid_tile(const bContext & /*C*/, Layout &layout) const
676{
677 this->build_grid_tile_button(layout);
678}
679
684
689
691{
692 hide_label_ = true;
693}
694
695void PreviewGridItem::on_activate(bContext &C)
696{
697 if (activate_fn_) {
698 activate_fn_(C, *this);
699 }
700}
701
702std::optional<bool> PreviewGridItem::should_be_active() const
703{
704 if (is_active_fn_) {
705 return is_active_fn_();
706 }
707 return std::nullopt;
708}
709
710} // namespace blender::ui
#define C
Definition RandGen.cpp:29
#define UI_UNIT_X
#define IS_EQF(a, b)
constexpr int64_t first() const
constexpr int64_t last(const int64_t n=0) const
constexpr IndexRange()=default
constexpr bool contains(int64_t value) const
std::optional< std::string > debug_name() const override
Definition grid_view.cc:383
virtual void build_grid_tile(const bContext &C, Layout &layout) const =0
AbstractGridView & get_view() const
Definition grid_view.cc:388
virtual std::unique_ptr< GridViewItemDropTarget > create_drop_target()
Definition grid_view.cc:404
AbstractGridViewItem(StringRef identifier)
Definition grid_view.cc:357
std::unique_ptr< DropTargetInterface > create_item_drop_target() final
Definition grid_view.cc:399
bool matches(const AbstractViewItem &other) const override
Definition grid_view.cc:359
Map< StringRef, AbstractGridViewItem * > item_map_
ItemT & add_item(Args &&...args)
void set_tile_size(int tile_width, int tile_height)
Definition grid_view.cc:121
AbstractViewItem * navigate_up(AbstractViewItem *from) override
Definition grid_view.cc:190
void scroll_active_into_view(bContext *C, bool scroll_active_to_center=false) override
Definition grid_view.cc:304
AbstractViewItem * navigate_right(AbstractViewItem *from) override
Definition grid_view.cc:174
void foreach_filtered_item(ItemIterFn iter_fn) const
Definition grid_view.cc:64
FunctionRef< void(AbstractGridViewItem &)> ItemIterFn
AbstractViewItem * navigate_left(AbstractViewItem *from) override
Definition grid_view.cc:160
AbstractViewItem * find_active_or_visible_item() const override
Definition grid_view.cc:145
void foreach_item(ItemIterFn iter_fn) const
Definition grid_view.cc:57
IndexRange get_visible_range(const View2D &v2d, const AbstractGridViewItem *force_visible_item) const
Definition grid_view.cc:270
std::optional< int > item_count_filtered_
const GridViewStyle & get_style() const
Definition grid_view.cc:97
void page_scroll(bContext *C, PageScrollDirection direction) override
Definition grid_view.cc:229
AbstractViewItem * navigate_down(AbstractViewItem *from) override
Definition grid_view.cc:209
virtual void build_items()=0
Vector< std::unique_ptr< AbstractGridViewItem > > items_
virtual std::optional< bool > should_be_active() const
ui::ButtonViewItem * view_item_button() const
ui::ButtonViewItem * view_item_but_
const AbstractViewItem * search_highlight_item() const
virtual void change_state_delayed()
void register_item(AbstractViewItem &item)
void update_from_old(Block &new_block)
void filter(std::optional< StringRef > filter_str)
bool is_item_visible(int item_idx) const
Definition grid_view.cc:465
void fill_layout_before_visible(Block &block) const
Definition grid_view.cc:470
void fill_layout_after_visible(Block &block) const
Definition grid_view.cc:484
BuildOnlyVisibleButtonsHelper(const View2D &v2d, const AbstractGridView &grid_view, int cols_per_row, const AbstractGridViewItem *force_visible_item)
Definition grid_view.cc:453
void build_grid_view(const bContext &C, AbstractGridView &grid_view, Layout &layout, std::optional< StringRef > search_string={})
Definition grid_view.cc:612
GridViewItemDropTarget(AbstractGridView &view)
Definition grid_view.cc:409
void build_from_view(const bContext &C, AbstractGridView &grid_view, const View2D &v2d) const
Definition grid_view.cc:554
PreviewGridItem(StringRef identifier, StringRef label, int preview_icon_id)
Definition grid_view.cc:640
void build_grid_tile(const bContext &C, Layout &layout) const override
Definition grid_view.cc:675
void set_is_active_fn(IsActiveFn fn)
Definition grid_view.cc:685
std::function< void(bContext &C, PreviewGridItem &new_active)> ActivateFn
void set_on_activate_fn(ActivateFn fn)
Definition grid_view.cc:680
void build_grid_tile_button(Layout &layout, BIFIconID override_preview_icon_id=ICON_NONE) const
Definition grid_view.cc:645
std::function< bool()> IsActiveFn
void block_to_region_rctf(const ARegion *region, const Block *block, rctf *rct_dst, const rctf *rct_src)
Definition interface.cc:162
void button_func_quick_tooltip_set(Button *but, std::function< std::string(const Button *but)> func)
Button * uiDefBut(Block *block, ButtonTypeWithPointerType but_and_ptr_type, StringRef str, int x, int y, short width, short height, void *poin, float min, float max, std::optional< StringRef > tip)
static std::optional< int > find_filtered_item_index(const AbstractGridViewItem &item)
Definition grid_view.cc:127
void view2d_region_to_view_rctf(const View2D *v2d, const rctf *rect_src, rctf *rect_dst) ATTR_NONNULL()
Definition view2d.cc:1657
void def_but_icon(Button *but, const int icon, const int64_t flag)
int preview_tile_size_y(const int size_px=96)
void block_layout_set_current(Block *block, Layout *layout)
void block_view_persistent_state_restore(const ARegion &region, const Block &block, AbstractView &view)
int preview_tile_size_x(const int size_px=96)
UserDef U
Definition blender.cc:58
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
Definition BLI_rect.hh:207
BLI_INLINE float BLI_rctf_size_y(const struct rctf *rct)
Definition BLI_rect.hh:215
int BIFIconID
Definition ED_asset.hh:30
ARegion * CTX_wm_region_popup(const bContext *C)
ARegion * CTX_wm_region(const bContext *C)
#define ceilf
GridViewStyle(int width, int height)
Definition grid_view.cc:353
void fixed_size_set(bool fixed_size)
Layout & column(bool align)
Layout & row(bool align)