Blender V5.3
interface_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
19
20#include <memory>
21
22#include "DNA_screen_types.h"
23
24#include "BKE_screen.hh"
25
26#include "BLI_bounds.hh"
27#include "BLI_listbase.hh"
28#include "BLI_map.hh"
29#include "BLI_rect.hh"
30
31#include "ED_screen.hh"
32
33#include "interface_intern.hh"
34
35#include "UI_abstract_view.hh"
36#include "UI_grid_view.hh"
37#include "UI_tree_view.hh"
38#include "WM_api.hh"
39
40namespace blender::ui {
41#define TREE_VIEW_DRAG_SCROLL_SPEED 0.1
42
46struct ViewLink : public Link {
47 std::string idname;
48 std::unique_ptr<AbstractView> view;
49
50 static void views_bounds_calc(const Block &block);
51};
52
53template<class T>
54static T *block_add_view_impl(Block &block, StringRef idname, std::unique_ptr<AbstractView> view)
55{
57
58 ViewLink *view_link = MEM_new<ViewLink>(__func__);
59 BLI_addtail(&block.views, view_link);
60
61 view_link->view = std::move(view);
62 view_link->idname = idname;
63
64 return dynamic_cast<T *>(view_link->view.get());
65}
66
68 StringRef idname,
69 std::unique_ptr<AbstractGridView> grid_view)
70{
71 return block_add_view_impl<AbstractGridView>(block, idname, std::move(grid_view));
72}
73
75 StringRef idname,
76 std::unique_ptr<AbstractTreeView> tree_view)
77{
78 return block_add_view_impl<AbstractTreeView>(block, idname, std::move(tree_view));
79}
80
82{
83 for (ViewLink &link : block->views.items_mutable()) {
84 MEM_delete(&link);
85 }
86}
87
89{
90 Map<AbstractView *, rcti> views_bounds;
91
92 rcti minmax;
93 BLI_rcti_init_minmax(&minmax);
94 for (ViewLink &link : block.views) {
95 views_bounds.add(link.view.get(), minmax);
96 }
97
98 for (Button &but : block.buttons()) {
99 if (but.type != ButtonType::ViewItem) {
100 continue;
101 }
102 auto *view_item_but = static_cast<ButtonViewItem *>(&but);
103 if (!view_item_but->view_item) {
104 continue;
105 }
106
107 /* Get the view from the button. */
108 AbstractViewItem &view_item = *view_item_but->view_item;
109 AbstractView &view = view_item.get_view();
110
111 rcti &bounds = views_bounds.lookup(&view);
112 rcti but_rcti{};
113 BLI_rcti_rctf_copy_round(&but_rcti, &view_item_but->rect);
114 BLI_rcti_do_minmax_rcti(&bounds, &but_rcti);
115 }
116
117 for (const auto item : views_bounds.items()) {
118 const rcti &bounds = item.value;
120 continue;
121 }
122
123 AbstractView &view = *item.key;
124 view.bounds_ = bounds;
125 }
126}
127
129 const Block &block,
130 AbstractView &view)
131{
132 StringRef idname = [&]() -> StringRef {
133 for (ViewLink &link : block.views) {
134 if (link.view.get() == &view) {
135 return link.idname;
136 }
137 }
138 return "";
139 }();
140
141 if (idname.is_empty()) {
143 return;
144 }
145
146 for (uiViewStateLink &stored_state : region.view_states) {
147 if (stored_state.idname == idname) {
148 view.persistent_state_apply(stored_state.state);
149 }
150 }
151}
152
154{
155 for (uiViewStateLink &stored_state : region.view_states) {
156 if (link.idname == stored_state.idname) {
157 return &stored_state;
158 }
159 }
160
161 uiViewStateLink *new_state = MEM_new<uiViewStateLink>(__func__);
162 link.idname.copy(new_state->idname, sizeof(new_state->idname));
163 BLI_addhead(&region.view_states, new_state);
164 return new_state;
165}
166
167void block_views_end(ARegion *region, const Block *block)
168{
170
171 if (region && region->regiontype != RGN_TYPE_TEMPORARY) {
172 for (const ViewLink &link : block->views) {
173 /* Ensure persistent view state storage for writing to files if needed. */
174 if (std::optional<uiViewState> temp_state = link.view->persistent_state()) {
175 uiViewStateLink *state_link = ensure_view_state(*region, link);
176 state_link->state = *temp_state;
177 }
178 }
179 }
180}
181
182void block_views_listen(const Block *block, const wmRegionListenerParams *listener_params)
183{
184 ARegion *region = listener_params->region;
185
186 for (ViewLink &view_link : block->views) {
187 if (view_link.view->listen(*listener_params->notifier)) {
188 ED_region_tag_redraw(region);
189 }
190 }
191}
192
193void block_views_draw_overlays(const ARegion *region, const Block *block)
194{
195 for (ViewLink &view_link : block->views) {
196 view_link.view->draw_overlays(*region, *block);
197 }
198}
199
201 const int xy[2],
202 const int pad,
203 Block **r_block)
204{
205 /* NOTE: Similar to #but_find_mouse_over_ex(). */
206
207 if (!region_contains_point_px(region, xy)) {
208 return nullptr;
209 }
210 for (Block &block : region->runtime->uiblocks) {
211 float mx = xy[0], my = xy[1];
212 window_to_block_fl(region, &block, &mx, &my);
213
214 for (ViewLink &view_link : block.views) {
215 std::optional<rcti> bounds = view_link.view->get_bounds();
216 if (!bounds) {
217 continue;
218 }
219
220 rcti padded_bounds = *bounds;
221 if (pad) {
222 BLI_rcti_pad(&padded_bounds, pad, pad);
223 }
224 if (BLI_rcti_isect_pt(&padded_bounds, mx, my)) {
225 if (r_block != nullptr) {
226 *r_block = &block;
227 }
228 return view_link.view.get();
229 }
230 }
231 }
232
233 return nullptr;
234}
235
237{
238 Block *block = nullptr;
239 ARegion *region = CTX_wm_region(C);
240 wmWindow *window = CTX_wm_window(C);
242 if (!ELEM(event->type, MOUSEMOVE, TIMER)) {
243 return;
244 }
245 AbstractView *view = region_view_find_at(region, event->xy, UI_UNIT_Y, &block);
246 if (view == nullptr) {
247 WM_event_timer_remove(wm, window, dropbox.timer);
248 dropbox.timer = nullptr;
249 return;
250 }
251
252 float x = event->xy[0], y = event->xy[1];
253 window_to_block_fl(region, block, &x, &y);
254
255 const std::optional<rcti> bounds = view->get_bounds();
256 if (!bounds.has_value()) {
257 WM_event_timer_remove(wm, window, dropbox.timer);
258 dropbox.timer = nullptr;
259 return;
260 }
261
262 const float margin = UI_UNIT_Y * 1 / 3;
263 const std::optional<ViewScrollDirection> scroll_dir =
264 [&]() -> std::optional<ViewScrollDirection> {
265 if (y > bounds->ymax - margin) {
267 }
268 if (y < bounds->ymin + margin) {
270 }
271 return std::nullopt;
272 }();
273
274 if (!scroll_dir.has_value()) {
275 WM_event_timer_remove(wm, window, dropbox.timer);
276 dropbox.timer = nullptr;
277 return;
278 }
279
280 if (dropbox.timer) {
281 if (event->type == TIMER) {
282 view->scroll(scroll_dir.value());
283 ED_region_tag_redraw(region);
284 }
285 }
286 else {
288 }
289}
290
291AbstractViewItem *region_views_find_item_at(const ARegion &region, const int xy[2])
292{
293 auto *item_but = static_cast<ButtonViewItem *>(view_item_find_mouse_over(&region, xy));
294 if (!item_but) {
295 return nullptr;
296 }
297
298 return item_but->view_item;
299}
300
302{
303 auto *item_but = static_cast<ButtonViewItem *>(view_item_find_active(region, view));
304 if (!item_but) {
305 return nullptr;
306 }
307
308 return item_but->view_item;
309}
310
312{
313 return view_item_find_active(region);
314}
315
317{
318 for (Block &block : region->runtime->uiblocks) {
319 for (ViewLink &view_link : block.views) {
320 view_link.view->clear_search_highlight();
321 }
322 }
323}
324
325std::unique_ptr<DropTargetInterface> region_views_find_drop_target_at(const ARegion *region,
326 const int xy[2])
327{
328 if (AbstractViewItem *item = region_views_find_item_at(*region, xy)) {
329 if (std::unique_ptr<DropTargetInterface> target = item->create_item_drop_target()) {
330 return target;
331 }
332 }
333
334 /* Get style for some sensible padding around the view items. */
335 const uiStyle *style = style_get_dpi();
336 if (AbstractView *view = region_view_find_at(region, xy, style->buttonspacex)) {
337 if (std::unique_ptr<DropTargetInterface> target = view->create_drop_target()) {
338 return target;
339 }
340 }
341
342 /* To continue scroll during drag when mouse is slightly outside the view, find the view with
343 * extra padding (UI_UNIT_Y). */
344 if (AbstractView *view = region_view_find_at(region, xy, UI_UNIT_Y)) {
345 /* If we are above a tree, but not hovering any specific element, dropping something should
346 * insert it before first or after last visible item depends on the mouse position. */
347 if (AbstractTreeView *tree_view = dynamic_cast<AbstractTreeView *>(view)) {
348 /* Find the first or last item which we want to drop below. */
349 AbstractTreeViewItem *first_or_last_visible = nullptr;
350 tree_view->foreach_root_item([&](AbstractTreeViewItem &item) {
351 if (!item.is_interactive()) {
352 return;
353 }
354 std::optional<rctf> rct = item.get_win_rect(*region);
355 if (rct.has_value()) {
356 if ((!first_or_last_visible && (xy[1] > rct->ymax)) || (xy[1] < rct->ymin)) {
357 first_or_last_visible = &item;
358 }
359 }
360 });
361 if (first_or_last_visible) {
362 return first_or_last_visible->create_item_drop_target();
363 }
364 }
365 }
366
367 return nullptr;
368}
369
370static StringRef block_view_find_idname(const Block &block, const AbstractView &view)
371{
372 /* First get the `idname` of the view we're looking for. */
373 for (ViewLink &view_link : block.views) {
374 if (view_link.view.get() == &view) {
375 return view_link.idname;
376 }
377 }
378
379 return {};
380}
381
382template<class T>
383static T *block_view_find_matching_in_old_block_impl(const Block &new_block, const T &new_view)
384{
385 Block *old_block = new_block.oldblock;
386 if (!old_block) {
387 return nullptr;
388 }
389
390 StringRef idname = block_view_find_idname(new_block, new_view);
391 if (idname.is_empty()) {
392 return nullptr;
393 }
394
395 for (ViewLink &old_view_link : old_block->views) {
396 if (old_view_link.idname == idname) {
397 return dynamic_cast<T *>(old_view_link.view.get());
398 }
399 }
400
401 return nullptr;
402}
403
405 const AbstractView &new_view)
406{
407 return block_view_find_matching_in_old_block_impl(new_block, new_view);
408}
409
411 const Block &new_block, const AbstractViewItem &new_item)
412{
413 Block *old_block = new_block.oldblock;
414 if (!old_block) {
415 return nullptr;
416 }
417
419 new_item.get_view());
420 if (!old_view) {
421 return nullptr;
422 }
423
424 for (Button &old_but : old_block->buttons()) {
425 if (old_but.type != ButtonType::ViewItem) {
426 continue;
427 }
428 ButtonViewItem *old_item_but = static_cast<ButtonViewItem *>(&old_but);
429 if (!old_item_but->view_item) {
430 continue;
431 }
432 AbstractViewItem &old_item = *old_item_but->view_item;
433 /* Check if the item is from the expected view. */
434 if (&old_item.get_view() != old_view) {
435 continue;
436 }
437
438 if (view_item_matches(new_item, old_item)) {
439 return old_item_but;
440 }
441 }
442
443 return nullptr;
444}
445
446} // namespace blender::ui
#define C
Definition RandGen.cpp:29
#define UI_UNIT_Y
int pad[32 - sizeof(int)]
#define BLI_assert_unreachable()
#define ELEM(...)
bool add(const Key &key, const Value &value)
Definition BLI_map.hh:295
const Value & lookup(const Key &key) const
Definition BLI_map.hh:545
ItemIterator items() const &
Definition BLI_map.hh:902
constexpr bool is_empty() const
constexpr int64_t size() const
Abstract base class for defining a customizable tree-view item.
std::optional< rctf > get_win_rect(const ARegion &region) const
Definition tree_view.cc:780
std::unique_ptr< DropTargetInterface > create_item_drop_target() final
Definition tree_view.cc:760
virtual void persistent_state_apply(const uiViewState &state)
std::optional< rcti > get_bounds() const
virtual void scroll(ViewScrollDirection direction)
#define TREE_VIEW_DRAG_SCROLL_SPEED
#define T
AbstractGridView * block_add_view(Block &block, StringRef idname, std::unique_ptr< AbstractGridView > grid_view)
void region_views_clear_search_highlight(const ARegion *region)
AbstractViewItem * region_views_find_item_at(const ARegion &region, const int xy[2])
Button * view_item_find_mouse_over(const ARegion *region, const int xy[2]) ATTR_NONNULL(1
void block_views_listen(const Block *block, const wmRegionListenerParams *listener_params)
bool region_contains_point_px(const ARegion *region, const int xy[2]) ATTR_NONNULL(1
void block_views_draw_overlays(const ARegion *region, const Block *block)
void block_views_end(ARegion *region, const Block *block)
const uiStyle * style_get_dpi()
bool view_item_matches(const AbstractViewItem &a, const AbstractViewItem &b)
void region_view_scroll_at_borders(bContext *C, wmDropBox &dropbox, const wmEvent *event)
AbstractViewItem * region_views_find_active_item(const ARegion *region, const AbstractView *view)
static uiViewStateLink * ensure_view_state(ARegion &region, const ViewLink &link)
Button Button * view_item_find_active(const ARegion *region, const AbstractView *view=nullptr)
Button * region_views_find_active_item_but(const ARegion *region)
std::unique_ptr< DropTargetInterface > region_views_find_drop_target_at(const ARegion *region, const int xy[2])
static T * block_add_view_impl(Block &block, StringRef idname, std::unique_ptr< AbstractView > view)
void window_to_block_fl(const ARegion *region, const Block *block, float *x, float *y)
Definition interface.cc:193
static T * block_view_find_matching_in_old_block_impl(const Block &new_block, const T &new_view)
AbstractView * block_view_find_matching_in_old_block(const Block &new_block, const AbstractView &new_view)
void block_view_persistent_state_restore(const ARegion &region, const Block &block, AbstractView &view)
void block_free_views(Block *block)
static StringRef block_view_find_idname(const Block &block, const AbstractView &view)
AbstractView * region_view_find_at(const ARegion *region, const int xy[2], int pad, Block **r_block=nullptr)
ButtonViewItem * block_view_find_matching_view_item_but_in_old_block(const Block &new_block, const AbstractViewItem &new_item)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
__int64 int64_t
Definition BKE_text.h:90
void BLI_addhead(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:98
void BLI_rcti_init_minmax(struct rcti *rect)
Definition rct.cc:488
wmWindow * CTX_wm_window(const bContext *C)
void BLI_rcti_rctf_copy_round(struct rcti *dst, const struct rctf *src)
void ED_region_tag_redraw(ARegion *region)
Definition area.cc:681
wmWindowManager * CTX_wm_manager(const bContext *C)
bool BLI_rcti_is_empty(const struct rcti *rect)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
void WM_event_timer_remove(wmWindowManager *wm, wmWindow *, wmTimer *timer)
bool BLI_rcti_isect_pt(const struct rcti *rect, int x, int y)
wmTimer * WM_event_timer_add(wmWindowManager *wm, wmWindow *win, const wmEventType event_type, const double time_step)
void BLI_rcti_pad(struct rcti *rect, int pad_x, int pad_y)
Definition rct.cc:643
ARegion * CTX_wm_region(const bContext *C)
void BLI_rcti_do_minmax_rcti(struct rcti *rect, const struct rcti *other)
bke::ARegionRuntime * runtime
ListBaseT< uiViewStateLink > view_states
eRegion_Type regiontype
ListBaseT< ui::Block > uiblocks
ListBaseT< ViewLink > views
std::ranges::transform_view< std::ranges::ref_view< const Vector< std::unique_ptr< Button > > >, Button &(*)(const std::unique_ptr< Button > &)> buttons() const
wmEventType type
Definition WM_types.hh:817
short buttonspacex