Blender V5.3
workspace_layout_edit.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 <cstdlib>
10
11#include "BLI_listbase.hh"
12#include "BLI_utildefines.hh"
13
14#include "DNA_screen_types.h"
15#include "DNA_workspace_types.h"
16
17#include "BKE_context.hh"
18#include "BKE_lib_id.hh"
19#include "BKE_main.hh"
20#include "BKE_screen.hh"
21#include "BKE_workspace.hh"
22
23#include "WM_api.hh"
24
25#include "ED_screen.hh"
26
27#include "screen_intern.hh"
28
29namespace blender {
30
32 WorkSpace *workspace,
33 wmWindow *win,
34 const char *name)
35{
36 bScreen *screen;
37 rcti screen_rect;
38
39 WM_window_screen_rect_calc(win, &screen_rect);
40 screen = screen_add(bmain, name, &screen_rect);
41
42 return BKE_workspace_layout_add(bmain, *workspace, *screen, name);
43}
44
46 WorkSpace *workspace,
47 const WorkSpaceLayout *layout_old,
48 wmWindow * /*win*/)
49{
50 return BKE_workspace_layout_add_from_layout(bmain, *workspace, *layout_old, LIB_ID_COPY_DEFAULT);
51}
52
54 WorkSpaceLayout *layout_old,
55 WorkSpaceLayout *layout_new,
56 bContext *C)
57{
58 Main *bmain = CTX_data_main(C);
59 wmWindow *win = CTX_wm_window(C);
60 bScreen *screen_new = BKE_workspace_layout_screen_get(layout_new);
61
62 ED_screen_change(C, screen_new);
63
64 if (BKE_workspace_active_layout_get(win->workspace_hook) != layout_old) {
65 BKE_workspace_layout_remove(bmain, workspace, layout_old);
66 return true;
67 }
68
69 return false;
70}
71
73{
74 const bScreen *screen = BKE_workspace_layout_screen_get(layout);
75
76 return ((BKE_screen_is_used(screen) == false) &&
77 /* in typical usage temp screens should have a nonzero winid
78 * (all temp screens should be used, or closed & freed). */
79 (screen->temp == false) && (BKE_screen_is_fullscreen_area(screen) == false) &&
80 (screen->id.name[2] != '.' || !(U.uiflag & USER_HIDE_DOT)));
81}
82
84{
85 for (WorkSpaceLayout *layout_new = layout_old->prev; layout_new; layout_new = layout_new->next) {
86 if (workspace_layout_set_poll(layout_new)) {
87 return layout_new;
88 }
89 }
90
91 for (WorkSpaceLayout *layout_new = layout_old->next; layout_new; layout_new = layout_new->next) {
92 if (workspace_layout_set_poll(layout_new)) {
93 return layout_new;
94 }
95 }
96
97 return nullptr;
98}
99
101{
102 const bScreen *screen_old = BKE_workspace_layout_screen_get(layout_old);
103 WorkSpaceLayout *layout_new;
104
105 BLI_assert(BLI_findindex(&workspace->layouts, layout_old) != -1);
106
107 /* Don't allow deleting temp full-screens for now. */
108 if (BKE_screen_is_fullscreen_area(screen_old)) {
109 return false;
110 }
111
112 /* A layout/screen can only be in use by one window at a time, so as
113 * long as we are able to find a layout/screen that is unused, we
114 * can safely assume ours is not in use anywhere an delete it. */
115
116 layout_new = workspace_layout_delete_find_new(layout_old);
117
118 if (layout_new) {
119 return workspace_layout_delete_doit(workspace, layout_old, layout_new, C);
120 }
121
122 return false;
123}
124
125static bool workspace_change_find_new_layout_cb(const WorkSpaceLayout *layout, void * /*arg*/)
126{
127 /* return false to stop the iterator if we've found a layout that can be activated */
128 return workspace_layout_set_poll(layout) ? false : true;
129}
130
132{
133 for (bScreen &screen_iter : bmain->screens) {
134 if ((&screen_iter != screen) && ELEM(screen_iter.state, SCREENMAXIMIZED, SCREENFULL)) {
135 ScrArea *area = screen_iter.areabase.first();
136 if (area && area->full == screen) {
137 return &screen_iter;
138 }
139 }
140 }
141
142 return screen;
143}
144
145static bool screen_is_used_by_other_window(const wmWindow *win, const bScreen *screen)
146{
147 return BKE_screen_is_used(screen) && (screen->winid != win->winid);
148}
149
151 Main *bmain,
152 WorkSpace *workspace,
153 WorkSpaceLayout *layout_new,
154 const WorkSpaceLayout *layout_fallback_base,
155 wmWindow *win)
156{
157 WorkSpaceLayout *layout_temp = layout_new;
158 bScreen *screen_temp = BKE_workspace_layout_screen_get(layout_new);
159
160 screen_temp = screen_fullscreen_find_associated_normal_screen(bmain, screen_temp);
161 layout_temp = BKE_workspace_layout_find(workspace, screen_temp);
162
163 if (screen_is_used_by_other_window(win, screen_temp)) {
164 /* Screen is already used, try to find a free one. */
166 workspace, layout_new, workspace_change_find_new_layout_cb, nullptr, false);
167 screen_temp = layout_temp ? BKE_workspace_layout_screen_get(layout_temp) : nullptr;
168
169 if (!layout_temp || screen_is_used_by_other_window(win, screen_temp)) {
170 /* Fallback solution: duplicate layout. */
171 layout_temp = ED_workspace_layout_duplicate(bmain, workspace, layout_fallback_base, win);
172 }
173 }
174
175 return layout_temp;
176}
177
178static bool workspace_layout_cycle_iter_cb(const WorkSpaceLayout *layout, void * /*arg*/)
179{
180 /* return false to stop iterator when we have found a layout to activate */
181 return !workspace_layout_set_poll(layout);
182}
183
184bool ED_workspace_layout_cycle(WorkSpace *workspace, const short direction, bContext *C)
185{
186 wmWindow *win = CTX_wm_window(C);
188 const bScreen *old_screen = BKE_workspace_layout_screen_get(old_layout);
189 ScrArea *area = CTX_wm_area(C);
190
191 if (old_screen->temp || (area && area->full && area->full->temp)) {
192 return false;
193 }
194
195 BLI_assert(ELEM(direction, 1, -1));
197 old_layout,
199 nullptr,
200 (direction == -1) ? true :
201 false);
202
203 if (new_layout && (old_layout != new_layout)) {
204 bScreen *new_screen = BKE_workspace_layout_screen_get(new_layout);
205
206 if (area && area->full) {
207 /* return to previous state before switching screens */
208 ED_screen_full_restore(C, area); /* may free screen of old_layout */
209 }
210
211 ED_screen_change(C, new_screen);
212
213 return true;
214 }
215
216 return false;
217}
218
219} // namespace blender
#define C
Definition RandGen.cpp:29
#define ELEM(...)
BMesh Iterators.
UserDef U
Definition blender.cc:58
WorkSpaceLayout * ED_workspace_layout_duplicate(Main *bmain, WorkSpace *workspace, const WorkSpaceLayout *layout_old, wmWindow *win) ATTR_NONNULL()
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
ScrArea * CTX_wm_area(const bContext *C)
bool BKE_screen_is_used(const bScreen *screen) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition screen.cc:1298
WorkSpaceLayout * BKE_workspace_layout_add(Main *bmain, WorkSpace &workspace, bScreen &screen, const char *name)
Definition workspace.cc:426
bool workspace_layout_set_poll(const WorkSpaceLayout *layout)
wmWindow * CTX_wm_window(const bContext *C)
static WorkSpaceLayout * workspace_layout_delete_find_new(const WorkSpaceLayout *layout_old)
void ED_screen_full_restore(bContext *C, ScrArea *area)
@ LIB_ID_COPY_DEFAULT
static bool screen_is_used_by_other_window(const wmWindow *win, const bScreen *screen)
WorkSpaceLayout * BKE_workspace_layout_add_from_layout(Main *bmain, WorkSpace &workspace_dst, const WorkSpaceLayout &layout_src, const int id_copy_flags)
Definition workspace.cc:445
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
WorkSpaceLayout * ED_workspace_screen_change_ensure_unused_layout(Main *bmain, WorkSpace *workspace, WorkSpaceLayout *layout_new, const WorkSpaceLayout *layout_fallback_base, wmWindow *win) ATTR_NONNULL()
WorkSpaceLayout * ED_workspace_layout_add(Main *bmain, WorkSpace *workspace, wmWindow *win, const char *name) ATTR_NONNULL()
WorkSpaceLayout WorkSpaceLayout * BKE_workspace_layout_iter_circular(const WorkSpace *workspace, WorkSpaceLayout *start, bool(*callback)(const WorkSpaceLayout *layout, void *arg), void *arg, bool iter_backward)
Definition workspace.cc:540
static bool workspace_layout_cycle_iter_cb(const WorkSpaceLayout *layout, void *)
bool ED_workspace_layout_cycle(WorkSpace *workspace, short direction, bContext *C) ATTR_NONNULL()
static bool workspace_layout_delete_doit(WorkSpace *workspace, WorkSpaceLayout *layout_old, WorkSpaceLayout *layout_new, bContext *C)
static bool workspace_change_find_new_layout_cb(const WorkSpaceLayout *layout, void *)
static bScreen * screen_fullscreen_find_associated_normal_screen(const Main *bmain, bScreen *screen)
Main * CTX_data_main(const bContext *C)
bScreen * BKE_workspace_layout_screen_get(const WorkSpaceLayout *layout) GETTER_ATTRS
Definition workspace.cc:709
void BKE_workspace_layout_remove(Main *bmain, WorkSpace *workspace, WorkSpaceLayout *layout) ATTR_NONNULL()
Definition workspace.cc:472
bool BKE_screen_is_fullscreen_area(const bScreen *screen) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition screen.cc:1293
WorkSpaceLayout * BKE_workspace_active_layout_get(const WorkSpaceInstanceHook *hook) GETTER_ATTRS
Definition workspace.cc:657
bool ED_screen_change(bContext *C, bScreen *screen)
Change the active screen.
bScreen * screen_add(Main *bmain, const char *name, const rcti *rect)
void WM_window_screen_rect_calc(const wmWindow *win, rcti *r_rect)
WorkSpaceLayout * BKE_workspace_layout_find(const WorkSpace *workspace, const bScreen *screen) ATTR_NONNULL() ATTR_WARN_UNUSED_RESULT
Definition workspace.cc:499
bool ED_workspace_layout_delete(WorkSpace *workspace, WorkSpaceLayout *layout_old, bContext *C) ATTR_NONNULL()
char name[258]
Definition DNA_ID.h:433
ListBaseT< bScreen > screens
Definition BKE_main.hh:400
struct WorkSpaceLayout * next
struct WorkSpaceLayout * prev
ListBaseT< WorkSpaceLayout > layouts
eScreen_State state
ListBaseT< struct ScrArea > areabase
struct WorkSpaceInstanceHook * workspace_hook