Blender V5.3
wm.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2007 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
12
13/* Allow using deprecated functionality for .blend file I/O. */
14#define DNA_DEPRECATED_ALLOW
15
16#include <cstring>
17
18#include "DNA_ID_enums.h"
19#include "DNA_layer_types.h"
21
22#include "MEM_guardedalloc.h"
23
24#include "BLI_ghash.hh"
25#include "BLI_listbase.hh"
26#include "BLI_string_utf8.hh"
27#include "BLI_utildefines.hh"
28
29#include "BLT_translation.hh"
30
31#include "BKE_context.hh"
32#include "BKE_global.hh"
33#include "BKE_idprop.hh"
34#include "BKE_idtype.hh"
35#include "BKE_lib_id.hh"
36#include "BKE_lib_query.hh"
37#include "BKE_main.hh"
38#include "BKE_report.hh"
39#include "BKE_screen.hh"
40#include "BKE_workspace.hh"
41
42#include "PRF_profile.hh"
43
44#include "WM_api.hh"
45#include "WM_keymap.hh"
46#include "WM_message.hh"
47#include "WM_types.hh"
48#include "wm.hh"
49#include "wm_draw.hh"
50#include "wm_event_system.hh"
51#include "wm_window.hh"
52#ifdef WITH_XR_OPENXR
53# include "wm_xr.hh"
54#endif
55
56#include "BKE_undo_system.hh"
57#include "ED_screen.hh"
58
59#ifdef WITH_PYTHON
60# include "BPY_extern.hh"
61# include "BPY_extern_run.hh"
62#endif
63
64#include "BLO_read_write.hh"
65
66namespace blender {
67
68/* ****************************************************** */
69
71{
72 wm_close_and_free(nullptr, id_cast<wmWindowManager *>(id));
73}
74
76{
77 wmWindowManager *wm = reinterpret_cast<wmWindowManager *>(id);
79
80 for (wmWindow &win : wm->windows) {
82
83 /* This pointer can be nullptr during old files reading. */
84 if (win.workspace_hook != nullptr) {
85 ID *workspace = id_cast<ID *>(BKE_workspace_active_get(win.workspace_hook));
87 /* Allow callback to set a different workspace. */
88 BKE_workspace_active_set(win.workspace_hook, id_cast<WorkSpace *>(workspace));
90 return;
91 }
92 }
93
95
96 if (flag & IDWALK_INCLUDE_UI) {
97 for (ScrArea &area : win.global_areas.areabase) {
100 }
101 }
102
105 }
106 }
107
109 data, wm->xr.session_settings.base_pose_object, IDWALK_CB_USER_ONE);
110}
111
112static void write_wm_xr_data(BlendWriter *writer, wmXrData *xr_data)
113{
115}
116
117static void window_manager_blend_write(BlendWriter *writer, ID *id, const void *id_address)
118{
119 wmWindowManager *wm = id_cast<wmWindowManager *>(id);
120
121 wm->runtime = nullptr;
122
123 writer->write_id_struct(id_address, wm, [](BlendStructWriter<wmWindowManager> &struct_writer) {
124 wmWindowManager &shallow_wm = struct_writer.shallow_data;
125 shallow_wm.init_flag = {};
126 shallow_wm.op_undo_depth = 0;
127 shallow_wm.outliner_sync_select_dirty = {};
128 shallow_wm.extensions_updates = {};
129 shallow_wm.extensions_blocked = 0;
130 shallow_wm.autosave_scheduled = 0;
131 });
132 BKE_id_blend_write(writer, &wm->id);
133 write_wm_xr_data(writer, &wm->xr);
134
135 for (wmWindow &win : wm->windows) {
136 /* Update deprecated screen member (for so loading in 2.7x uses the correct screen). */
138
139 writer->write_struct(&win, [](BlendStructWriter<wmWindow> &struct_writer) {
140 wmWindow &shallow_win = struct_writer.shallow_data;
141 shallow_win.active = 0;
142 shallow_win.grabcursor = 0;
143 shallow_win.addmousemove = 0;
144 shallow_win.event_queue_check_click = 0;
145 shallow_win.event_queue_check_drag = 0;
146 shallow_win.event_queue_check_drag_handled = 0;
148 shallow_win.event_queue_consecutive_gesture_xy[0] = 0;
149 shallow_win.event_queue_consecutive_gesture_xy[1] = 0;
150 shallow_win.event_queue_consecutive_gesture_data = nullptr;
151 });
152 writer->write_struct(win.workspace_hook);
153 writer->write_struct(win.stereo3d_format);
154
156
157 /* Data is written, clear deprecated data again. */
158 win.screen = nullptr;
159 }
160}
161
166
168{
169 wmWindowManager *wm = id_cast<wmWindowManager *>(id);
170
171 id_us_ensure_real(&wm->id);
172 BLO_read_struct_list(reader, wmWindow, &wm->windows);
173
174 for (wmWindow &win : wm->windows) {
175 BLO_read_struct(reader, wmWindow, &win.parent);
176
179
180 /* This will be nullptr for any pre-2.80 blend file. */
181 if (win.workspace_hook != nullptr) {
182 /* We need to restore a pointer to this later when reading workspaces,
183 * so store in global oldnew-map.
184 * Note that this is only needed for versioning of older .blend files now. */
185 BLO_read_data_globmap_add(reader, hook, win.workspace_hook);
186 /* Cleanup pointers to data outside of this data-block scope. */
187 win.workspace_hook->act_layout = nullptr;
189 win.workspace_hook->temp_layout_store = nullptr;
190 }
191
193 BLO_read_data_invalidate(reader, "Corrupt .blend file, failed to read window areas.");
194 }
195
196 win.active = 0;
197
198 win.cursor = 0;
199 win.lastcursor = 0;
200 win.modalcursor = 0;
201 win.grabcursor = 0;
202 win.addmousemove = true;
209
210 /* Multi-view always falls back to anaglyph at file opening
211 * otherwise quad-buffer saved files can break Blender. */
214 }
215 win.runtime = MEM_new<bke::WindowRuntime>(__func__);
216 }
217
218 direct_link_wm_xr_data(reader, &wm->xr);
219
220 wm->xr.runtime = nullptr;
221
222 wm->init_flag = eWM_InitFlag{};
223 wm->op_undo_depth = 0;
224 wm->extensions_updates = WM_EXTENSIONS_UPDATE_UNSET;
225 wm->extensions_blocked = 0;
226
227 BLI_assert(wm->runtime == nullptr);
228 wm->runtime = MEM_new<bke::WindowManagerRuntime>(__func__);
229}
230
232{
233 wmWindowManager *wm = reinterpret_cast<wmWindowManager *>(id);
234
235 for (wmWindow &win : wm->windows) {
236 for (ScrArea &area : win.global_areas.areabase) {
238 }
239 }
240}
241
243 .id_code = wmWindowManager::id_type,
244 .id_filter = FILTER_ID_WM,
245 .dependencies_id_types = FILTER_ID_SCE | FILTER_ID_WS,
246 .main_listbase_index = INDEX_ID_WM,
247 .struct_size = sizeof(wmWindowManager),
248 .name = "WindowManager",
249 .name_plural = N_("window_managers"),
250 .translation_context = BLT_I18NCONTEXT_ID_WINDOWMANAGER,
253 .asset_type_info = nullptr,
254
255 .init_data = nullptr,
256 .copy_data = nullptr,
257 .free_data = window_manager_free_data,
258 .make_local = nullptr,
259 .foreach_id = window_manager_foreach_id,
260 .foreach_cache = nullptr,
261 .foreach_path = nullptr,
262 .foreach_working_space_color = nullptr,
263 .foreach_asset_weak_reference = nullptr,
264 .owner_pointer_get = nullptr,
265
266 .blend_write = window_manager_blend_write,
267 .blend_read_data = window_manager_blend_read_data,
268 .blend_read_after_liblink = window_manager_blend_read_after_liblink,
269
270 .blend_read_undo_preserve = nullptr,
271
272 .lib_override_apply_post = nullptr,
273};
274
275#define MAX_OP_REGISTERED 32
276
278{
279
280#ifdef WITH_PYTHON
281 if (op->py_instance) {
282 /* Do this first in case there are any __del__ functions or similar that use properties. */
284 }
285#endif
286
287 if (op->ptr) {
288 op->properties = static_cast<IDProperty *>(op->ptr->data);
289 MEM_delete(op->ptr);
290 }
291
292 if (op->properties) {
294 }
295
296 if (op->reports && (op->reports->flag & RPT_FREE)) {
298 MEM_delete(op->reports);
299 }
300
301 if (op->macro.first()) {
302 wmOperator *opm, *opmnext;
303 for (opm = op->macro.first(); opm; opm = opmnext) {
304 opmnext = opm->next;
305 WM_operator_free(opm);
306 }
307 }
308
309 MEM_delete(op);
310}
311
313{
314 op = op->next;
315 while (op != nullptr) {
316 wmOperator *op_next = op->next;
317 BLI_remlink(&wm->runtime->operators, op);
319 op = op_next;
320 }
321}
322
324{
325 /* Not supported for Python. */
326 BLI_assert(op->py_instance == nullptr);
327
328 op->type = ot;
329 op->ptr->type = ot->srna;
330
331 /* Ensure compatible properties. */
332 if (op->properties) {
334
336
337 if (ptr) {
338 IDP_SyncGroupTypes(op->properties, static_cast<const IDProperty *>(ptr.data), true);
339 }
340
342 }
343}
344
346{
347 WM_event_timer_remove(wm, nullptr, wm->runtime->reports.reporttimer);
348}
349
351{
353 int tot = 0;
354
355 BLI_addtail(&wm->runtime->operators, op);
356
357 /* Only count registered operators. */
358 while (op) {
359 wmOperator *op_prev = op->prev;
360 if (op->type->flag & OPTYPE_REGISTER) {
361 tot += 1;
362 }
363 if (tot > MAX_OP_REGISTERED) {
364 BLI_remlink(&wm->runtime->operators, op);
366 }
367 op = op_prev;
368 }
369
370 /* So the console is redrawn. */
373}
374
376{
377 while (wmOperator *op = static_cast<wmOperator *>(BLI_pophead(&wm->runtime->operators))) {
379 }
380
382}
383
385{
386 bool any_removed = false;
387 for (wmOperator &op : wm->runtime->operators.items_mutable()) {
388 if (types.contains(op.type)) {
389 BLI_remlink(&wm->runtime->operators, &op);
390 WM_operator_free(&op);
391 any_removed = true;
392 }
393 }
394
395 if (any_removed) {
397 }
398}
399
401{
402 for (wmWindow &win : wm->windows) {
403 bScreen *screen = WM_window_get_active_screen(&win);
404 for (ScrArea &area : screen->areabase) {
405 switch (area.spacetype) {
406 case SPACE_FILE: {
407 SpaceFile *sfile = area.spacedata.first_as<SpaceFile>();
408 if (sfile->op && types.contains(sfile->op->type)) {
409 /* Freed as part of the handler. */
410 sfile->op = nullptr;
411 }
412 break;
413 }
414 }
415 }
416 }
417
418 for (wmWindow &win : wm->windows) {
419 ListBaseT<wmEventHandler> *lb[2] = {&win.runtime->handlers, &win.runtime->modalhandlers};
420 for (int i = 0; i < ARRAY_SIZE(lb); i++) {
421 for (wmEventHandler &handler_base : *lb[i]) {
422 if (handler_base.type == WM_HANDLER_TYPE_OP) {
423 wmEventHandler_Op *handler = reinterpret_cast<wmEventHandler_Op *>(&handler_base);
424 if (handler->op && types.contains(handler->op->type)) {
425 /* Don't run op->cancel because it needs the context,
426 * assume whoever unregisters the operator will cleanup. */
427 handler->head.flag |= WM_HANDLER_DO_FREE;
428 WM_operator_free(handler->op);
429 handler->op = nullptr;
430 }
431 }
432 }
433 }
434 }
435}
436
441
442/* ****************************************** */
443
445{
446 if (CTX_py_init_get(C) && !G.background) {
447#ifdef WITH_PYTHON
448 const char *imports[] = {"bpy", nullptr};
449 BPY_run_string_eval(C, imports, "bpy.utils.keyconfig_init()");
450#endif
451 }
452}
453
455{
457
458 /* Create standard key configuration. */
459 if (wm->runtime->defaultconf == nullptr) {
460 /* Keep lowercase to match the preset filename. */
461 wm->runtime->defaultconf = WM_keyconfig_new(wm, WM_KEYCONFIG_STR_DEFAULT, false);
462 }
463 if (wm->runtime->addonconf == nullptr) {
464 wm->runtime->addonconf = WM_keyconfig_new(wm, WM_KEYCONFIG_STR_DEFAULT " addon", false);
465 }
466 if (wm->runtime->userconf == nullptr) {
467 wm->runtime->userconf = WM_keyconfig_new(wm, WM_KEYCONFIG_STR_DEFAULT " user", false);
468 }
469
470 /* Initialize only after python init is done, for keymaps that use python operators. */
471 if (CTX_py_init_get(C) && (wm->init_flag & WM_INIT_FLAG_KEYCONFIG) == 0) {
472 /* Create default key config, only initialize once,
473 * it's persistent across sessions. */
474 if (!(wm->runtime->defaultconf->flag & KEYCONF_INIT_DEFAULT)) {
475 wm_window_keymap(wm->runtime->defaultconf);
476 ED_spacetypes_keymap(wm->runtime->defaultconf);
477
479
480 wm->runtime->defaultconf->flag |= KEYCONF_INIT_DEFAULT;
481 }
482
483 /* Harmless, but no need to update in background mode. */
484 if (!G.background) {
485 WM_keyconfig_update_tag(nullptr, nullptr);
486 }
487 /* Don't call #WM_keyconfig_update here because add-ons have not yet been registered yet. */
488
489 wm->init_flag |= WM_INIT_FLAG_KEYCONFIG;
490 }
491}
492
494{
495 Main *bmain = CTX_data_main(C);
497
498 /* WM context. */
499 if (wm == nullptr) {
500 wm = bmain->wm.first();
502 }
503
504 if (wm == nullptr || wm->windows.is_empty()) {
505 return;
506 }
507
508 /* Run before loading the keyconfig. */
509 if (wm->runtime->message_bus == nullptr) {
510 wm->runtime->message_bus = WM_msgbus_create();
511 }
512
513 if (!G.background) {
514 /* Case: file-read. */
515 if ((wm->init_flag & WM_INIT_FLAG_WINDOW) == 0) {
518 }
519
520 /* Initialize GPU backend for GHOST before opening windows. */
522
523 /* Case: no open windows at all, for old file reads. */
525 }
526
527 /* Case: file-read. */
528 /* NOTE: this runs in background mode to set the screen context cb. */
529 if ((wm->init_flag & WM_INIT_FLAG_WINDOW) == 0) {
530 ED_screens_init(C, bmain, wm);
531 wm->init_flag |= WM_INIT_FLAG_WINDOW;
532 }
533}
534
536{
538
539 /* WM context. */
540 if (wm == nullptr) {
541 wm = CTX_data_main(C)->wm.first();
543 }
544
545 if (wm == nullptr || wm->windows.is_empty()) {
546 return;
547 }
548
549 for (wmWindow &win : wm->windows) {
550 win.sizex = 0;
551 win.sizey = 0;
552 win.posx = 0;
553 win.posy = 0;
554 }
555}
556
558{
559 wmWindowManager *wm = static_cast<wmWindowManager *>(
560 BKE_libblock_alloc(bmain, ID_WM, "WinMan", 0));
561 wmWindow *win;
562 bScreen *screen = CTX_wm_screen(C); /* XXX: from file read hrmf. */
563 WorkSpace *workspace;
564 WorkSpaceLayout *layout = BKE_workspace_layout_find_global(bmain, screen, &workspace);
565
567 win = wm_window_new(bmain, wm, nullptr, false);
568 win->scene = CTX_data_scene(C);
571 BKE_workspace_active_layout_set(win->workspace_hook, win->winid, workspace, layout);
572 screen->winid = win->winid;
573
574 wm->runtime = MEM_new<bke::WindowManagerRuntime>(__func__);
575 wm->runtime->winactive = win;
576 wm->file_saved = 1;
578}
579
581{
582 /* NOTE: this also runs when built without `WITH_XR_OPENXR`.
583 * It's necessary to prevent leaks when XR data is created or loaded into non XR builds.
584 * This can occur when Python reads all properties (see the `bl_rna_paths` test). */
585
586 /* Note that non-runtime data in `wm->xr` is freed as part of freeing the window manager. */
587 if (wm->xr.session_settings.shading.prop) {
588 IDP_FreeProperty(wm->xr.session_settings.shading.prop);
589 wm->xr.session_settings.shading.prop = nullptr;
590 }
591}
592
594{
595 if (wm->autosavetimer) {
597 }
598
599#ifdef WITH_XR_OPENXR
600 /* May send notifier, so do before freeing notifier queue. */
601 wm_xr_exit(wm);
602#endif
604
605 while (wmWindow *win = static_cast<wmWindow *>(BLI_pophead(&wm->windows))) {
606 /* Prevent draw clear to use screen. `workspace_hook` may be null for a window that was not
607 * completely read from an invalid file. */
608 if (win->workspace_hook != nullptr) {
609 BKE_workspace_active_set(win->workspace_hook, nullptr);
610 }
611 wm_window_free(C, wm, win);
612 }
613
614#ifdef WITH_PYTHON
616#endif
617
619
620 if (C && CTX_wm_manager(C) == wm) {
621 CTX_wm_manager_set(C, nullptr);
622 }
623
624 MEM_delete(wm->runtime);
625}
626
628{
630 /* Single refresh before handling events.
631 * This ensures we don't run operators before the depsgraph has been evaluated. */
633
634 while (true) {
635
636 /* Get events from ghost, handle window events, add to window queues. */
638
639 /* Per window, all events to the window, screen, area and region handlers. */
641
642 /* Events have left notes about changes, we handle and cache it. */
644
645 /* Execute cached changes draw. */
647
649 }
650}
651
652} // namespace blender
#define BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(data_, func_call_)
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(data_, id_super_, cb_flag_)
#define STRNCPY_UTF8(dst, src)
#define BLO_read_struct_list(reader, struct_name, list)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BLT_I18NCONTEXT_ID_WINDOWMANAGER
#define FILTER_ID_WM
Definition DNA_ID.h:1236
#define FILTER_ID_WS
Definition DNA_ID.h:1228
#define FILTER_ID_SCE
Definition DNA_ID.h:1219
Enumerations for DNA_ID.h.
#define WM_KEYCONFIG_STR_DEFAULT
Read Blender memory allocation and freeing.
#define PRF_scope(category)
#define PRF_frame_mark
#define C
Definition RandGen.cpp:29
#define NC_WM
Definition WM_types.hh:387
#define ND_SPACE_INFO_REPORT
Definition WM_types.hh:563
#define ND_HISTORY
Definition WM_types.hh:431
#define NC_SPACE
Definition WM_types.hh:405
bool contains(const Key &key) const
Definition BLI_set.hh:310
BMesh Iterators.
void WM_main_add_notifier(uint type, void *reference)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BPY_DECREF_RNA_INVALIDATE(void *pyob_ptr)
static void window_manager_blend_read_after_liblink(BlendLibReader *reader, ID *id)
Definition wm.cc:231
wmWindow * wm_window_new(const Main *bmain, wmWindowManager *wm, wmWindow *parent, bool dialog)
Definition wm_window.cc:348
void BKE_workspace_active_set(WorkSpaceInstanceHook *hook, WorkSpace *workspace) SETTER_ATTRS
Definition workspace.cc:637
void WM_operator_free(wmOperator *op)
Definition wm.cc:277
bool CTX_py_init_get(const bContext *C)
void wm_window_events_process(const bContext *C)
void BLO_read_data_globmap_add(BlendDataReader *reader, void *oldaddr, void *newaddr)
Definition readfile.cc:6824
void BKE_reports_free(ReportList *reports)
Definition report.cc:106
void WM_main(bContext *C)
Definition wm.cc:627
void WM_operator_properties_free(PointerRNA *ptr)
static void direct_link_wm_xr_data(BlendDataReader *reader, wmXrData *xr_data)
Definition wm.cc:162
void WM_operator_type_set(wmOperator *op, wmOperatorType *ot)
Definition wm.cc:323
@ IDWALK_DO_DEPRECATED_POINTERS
wmMsgBus * WM_msgbus_create()
PointerRNA WM_operator_properties_create_ptr(wmOperatorType *ot)
static void wm_xr_data_free(wmWindowManager *wm)
Definition wm.cc:580
static void wm_reports_free(wmWindowManager *wm)
Definition wm.cc:345
void BKE_screen_area_map_blend_write(BlendWriter *writer, ScrAreaMap *area_map)
Definition screen.cc:1513
void WM_file_autosave_init(wmWindowManager *wm)
Definition wm_files.cc:2472
void BKE_screen_view3d_shading_blend_read_data(BlendDataReader *reader, View3DShading *shading)
Definition screen.cc:1352
void BLO_read_data_invalidate(BlendDataReader *reader, const char *message)
Definition readfile.cc:6839
bScreen * BKE_workspace_active_screen_get(const WorkSpaceInstanceHook *hook) GETTER_ATTRS
Definition workspace.cc:684
void wm_event_do_notifiers(bContext *C)
void WM_keyconfig_init(bContext *C)
Definition wm.cc:454
LibraryForeachIDFlag BKE_lib_query_foreachid_process_flags_get(const LibraryForeachIDData *data)
Definition lib_query.cc:133
void BKE_id_blend_write(BlendWriter *writer, ID *id)
Definition lib_id.cc:2890
ViewLayer * CTX_data_view_layer(const bContext *C)
WorkSpace * BKE_workspace_active_get(WorkSpaceInstanceHook *hook) GETTER_ATTRS
Definition workspace.cc:633
void * BLI_pophead(ListBase *listbase) ATTR_NONNULL(1)
Definition listbase.cc:259
void wm_window_make_drawable(wmWindowManager *wm, wmWindow *win)
Global G
Definition blender.cc:57
IDTypeInfo IDType_ID_WM
Definition wm.cc:242
void BKE_lib_query_foreachid_process(LibraryForeachIDData *data, ID **id_pp, LibraryForeachIDCallbackFlag cb_flag)
Definition lib_query.cc:82
static void window_manager_blend_read_data(BlendDataReader *reader, ID *id)
Definition wm.cc:167
void wm_close_and_free(bContext *C, wmWindowManager *wm)
Definition wm.cc:593
static void window_manager_foreach_id(ID *id, LibraryForeachIDData *data)
Definition wm.cc:75
void wm_window_ghostwindows_ensure(wmWindowManager *wm)
static void write_wm_xr_data(BlendWriter *writer, wmXrData *xr_data)
Definition wm.cc:112
void WM_keyconfig_reload(bContext *C)
Definition wm.cc:444
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
@ WM_HANDLER_DO_FREE
Definition WM_api.hh:715
BMesh const char void * data
void ED_screens_init(bContext *C, Main *bmain, wmWindowManager *wm)
void BKE_workspace_active_layout_set(WorkSpaceInstanceHook *hook, int winid, WorkSpace *workspace, WorkSpaceLayout *layout) SETTER_ATTRS
Activate a layout.
Definition workspace.cc:675
wmWindowManager * CTX_wm_manager(const bContext *C)
void BKE_screen_area_blend_read_after_liblink(BlendLibReader *reader, ID *parent_id, ScrArea *area)
Definition screen.cc:1812
void wm_window_keymap(wmKeyConfig *keyconf)
WorkSpaceLayout * BKE_workspace_layout_find_global(const Main *bmain, const bScreen *screen, WorkSpace **r_workspace) ATTR_NONNULL(1
Definition workspace.cc:516
void WM_operator_free_all_after(wmWindowManager *wm, wmOperator *op)
Definition wm.cc:312
constexpr size_t ARRAY_SIZE(const T(&arg)[N]) noexcept
bool BPY_run_string_eval(bContext *C, const char *imports[], const char *expr)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
bool BKE_lib_query_foreachid_iter_stop(const LibraryForeachIDData *data)
Definition lib_query.cc:77
void IDP_SyncGroupTypes(IDProperty *dest, const IDProperty *src, bool do_arraylen) ATTR_NONNULL()
Definition idprop.cc:682
void id_us_ensure_real(ID *id)
Definition lib_id.cc:388
void wm_add_default(Main *bmain, bContext *C)
Definition wm.cc:557
void WM_operator_handlers_clear(wmWindowManager *wm, const Set< wmOperatorType * > &types)
Definition wm.cc:400
void BKE_screen_foreach_id_screen_area(LibraryForeachIDData *data, ScrArea *area)
Definition screen.cc:179
void BPY_callback_wm_free(wmWindowManager *wm)
void WM_operator_stack_clear(wmWindowManager *wm)
Definition wm.cc:375
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
Main * CTX_data_main(const bContext *C)
void ED_spacetypes_keymap(wmKeyConfig *keyconf)
@ INDEX_ID_WM
Definition DNA_ID.h:1356
void IDP_FreeProperty(IDProperty *prop)
Definition idprop.cc:1403
void wm_xr_exit(wmWindowManager *wm)
Definition wm_xr.cc:154
void wm_window_free(bContext *C, wmWindowManager *wm, wmWindow *win)
Definition wm_window.cc:276
void wm_operator_register(bContext *C, wmOperator *op)
Definition wm.cc:350
void CTX_wm_manager_set(bContext *C, wmWindowManager *wm)
bool WM_operator_properties_default(PointerRNA *ptr, const bool do_update)
Scene * CTX_data_scene(const bContext *C)
bScreen * CTX_wm_screen(const bContext *C)
void WM_event_timer_remove(wmWindowManager *wm, wmWindow *, wmTimer *timer)
void wm_clear_default_size(bContext *C)
Definition wm.cc:535
void BKE_screen_view3d_shading_blend_write(BlendWriter *writer, View3DShading *shading)
Definition screen.cc:1345
@ OPTYPE_REGISTER
Definition WM_types.hh:188
void wm_event_do_refresh_wm_and_depsgraph(bContext *C)
void wm_draw_update(bContext *C)
Definition wm_draw.cc:1706
void WM_check(bContext *C)
Definition wm.cc:493
void WM_keyconfig_update_tag(wmKeyMap *keymap, wmKeyMapItem *kmi)
wmKeyConfig * WM_keyconfig_new(wmWindowManager *wm, const char *idname, bool user_defined)
Definition wm_keymap.cc:295
bScreen * WM_window_get_active_screen(const wmWindow *win)
bool BKE_screen_area_map_blend_read_data(BlendDataReader *reader, ScrAreaMap *area_map)
Definition screen.cc:1766
void wm_autosave_timer_end(wmWindowManager *wm)
Definition wm_files.cc:2464
void * BKE_libblock_alloc(Main *bmain, short type, const char *name, int flag) ATTR_WARN_UNUSED_RESULT
Definition lib_id.cc:1545
void wm_event_do_handlers(bContext *C)
void WM_init_gpu_backend()
static void window_manager_blend_write(BlendWriter *writer, ID *id, const void *id_address)
Definition wm.cc:117
static void window_manager_free_data(ID *id)
Definition wm.cc:70
@ IDTYPE_FLAGS_NO_MEMFILE_UNDO
Definition BKE_idtype.hh:59
@ IDTYPE_FLAGS_NO_COPY
Definition BKE_idtype.hh:36
@ IDTYPE_FLAGS_NO_ANIMDATA
Definition BKE_idtype.hh:52
@ IDTYPE_FLAGS_NO_LIBLINKING
Definition BKE_idtype.hh:38
@ IDTYPE_FLAGS_NEVER_UNUSED
Definition BKE_idtype.hh:73
void write_id_struct(const void *id_address, const T *id, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
ListBaseT< wmWindowManager > wm
Definition BKE_main.hh:415
StructRNA * type
Definition RNA_types.hh:63
ListBaseT< ScrArea > areabase
ListBaseT< SpaceLink > spacedata
struct wmOperator * op
eStereoDisplayMode display_mode
struct WorkSpaceLayout * temp_layout_store
struct WorkSpaceLayout * act_layout
struct View3DShading shading
ListBaseT< struct ScrArea > areabase
ListBaseT< wmEventHandler > handlers
ListBaseT< wmEventHandler > modalhandlers
eWM_EventHandlerFlag flag
ListBaseT< wmOperator > macro
struct ReportList * reports
struct wmOperatorType * type
eWM_ExtensionsUpdates extensions_updates
eWM_OutlinerSyncSelectDirty outliner_sync_select_dirty
bke::WindowRuntime * runtime
struct wmEvent_ConsecutiveData * event_queue_consecutive_gesture_data
DNA_DEPRECATED struct bScreen * screen
struct WorkSpaceInstanceHook * workspace_hook
struct Stereo3dFormat * stereo3d_format
XrSessionSettings session_settings
#define N_(msgid)
#define MAX_OP_REGISTERED
Definition wm.cc:275