DNA_windowmanager_types.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2007 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "DNA_listBase.h"
#include "DNA_screen_types.h" /* for #ScrAreaMap */
#include "DNA_xr_types.h"     /* for #XrSessionSettings */
 
#include "DNA_ID.h"
 
#ifdef __cplusplus
#  include <mutex>
using std_mutex_type = std::mutex;
#else
#  define std_mutex_type void
#endif

#ifdef __cplusplus
namespace blender::bke {
class WindowManagerRuntime;
}
using WindowManagerRuntimeHandle = blender::bke::WindowManagerRuntime;
#else   // __cplusplus
typedef struct WindowManagerRuntimeHandle WindowManagerRuntimeHandle;
#endif  // __cplusplus
 
/* Defined here: */
 
struct wmNotifier;
struct wmWindow;
struct wmWindowManager;
 
struct wmEvent_ConsecutiveData;
struct wmEvent;
struct wmKeyConfig;
struct wmKeyMap;
struct wmMsgBus;
struct wmOperator;
struct wmOperatorType;
 
/* Forward declarations: */
 
struct PointerRNA;
struct Report;
struct ReportList;
struct Stereo3dFormat;
struct bContext;
struct bScreen;
struct uiLayout;
struct wmTimer;
 
#define OP_MAX_TYPENAME 64
#define KMAP_MAX_NAME 64

typedef enum eReportType {
  RPT_DEBUG = (1 << 0),
  RPT_INFO = (1 << 1),
  RPT_OPERATOR = (1 << 2),
  RPT_PROPERTY = (1 << 3),
  RPT_WARNING = (1 << 4),
  RPT_ERROR = (1 << 5),
  RPT_ERROR_INVALID_INPUT = (1 << 6),
  RPT_ERROR_INVALID_CONTEXT = (1 << 7),
  RPT_ERROR_OUT_OF_MEMORY = (1 << 8),
} eReportType;
ENUM_OPERATORS(eReportType, RPT_ERROR_OUT_OF_MEMORY)
 
#define RPT_DEBUG_ALL (RPT_DEBUG)
#define RPT_INFO_ALL (RPT_INFO)
#define RPT_OPERATOR_ALL (RPT_OPERATOR)
#define RPT_PROPERTY_ALL (RPT_PROPERTY)
#define RPT_WARNING_ALL (RPT_WARNING)
#define RPT_ERROR_ALL \
  (RPT_ERROR | RPT_ERROR_INVALID_INPUT | RPT_ERROR_INVALID_CONTEXT | RPT_ERROR_OUT_OF_MEMORY)
 
enum ReportListFlags {
  RPT_PRINT = (1 << 0),
  RPT_STORE = (1 << 1),
  RPT_FREE = (1 << 2),
  RPT_OP_HOLD = (1 << 3), /* don't move them into the operator global list (caller will use) */
  RPT_PRINT_HANDLED_BY_OWNER = (1 << 4),
};
 
/* These two lines with # tell `makesdna` this struct can be excluded. */
#
#
typedef struct Report {
  struct Report *next, *prev;
  short type;
  short flag;
  int len;
  const char *typestr;
  const char *message;
} Report;

typedef struct ReportList {
  ListBase list;
  int printlevel;
  int storelevel;
  int flag;
  char _pad[4];
  struct wmTimer *reporttimer;

  std_mutex_type *lock;
} ReportList;
 
/* Timer custom-data to control reports display. */
/* These two lines with # tell `makesdna` this struct can be excluded. */
#
#
typedef struct ReportTimerInfo {
  float widthfac;
  float flash_progress;
} ReportTimerInfo;
 
// #ifdef WITH_XR_OPENXR
typedef struct wmXrData {
  struct wmXrRuntimeData *runtime;
  XrSessionSettings session_settings;
} wmXrData;
// #endif
 
/* reports need to be before wmWindowManager */

typedef struct wmWindowManager {
  ID id;

  struct wmWindow *windrawable;
  struct wmWindow *winactive;
  ListBase windows;

  uint8_t init_flag;
  char _pad0[1];
  short file_saved;
  short op_undo_depth;

  short outliner_sync_select_dirty;

  ListBase operators;

  ListBase notifier_queue;
  struct GSet *notifier_queue_set;

  const struct wmNotifier *notifier_current;

  int extensions_updates;
  int extensions_blocked;

  ListBase jobs;

  ListBase paintcursors;

  ListBase drags;

  ListBase keyconfigs;

  struct wmKeyConfig *defaultconf;
  struct wmKeyConfig *addonconf;
  struct wmKeyConfig *userconf;

  ListBase timers;
  struct wmTimer *autosavetimer;
  char autosave_scheduled;
  char _pad2[7];

  struct UndoStack *undo_stack;
 
  struct wmMsgBus *message_bus;
 
  // #ifdef WITH_XR_OPENXR
  wmXrData xr;
  // #endif
 
  WindowManagerRuntimeHandle *runtime;
} wmWindowManager;
 
#define WM_KEYCONFIG_ARRAY_P(wm) &(wm)->defaultconf, &(wm)->addonconf, &(wm)->userconf

enum {
  WM_EXTENSIONS_UPDATE_UNSET = -2,
  WM_EXTENSIONS_UPDATE_CHECKING = -1,
};

enum {
  WM_INIT_FLAG_WINDOW = (1 << 0),
  WM_INIT_FLAG_KEYCONFIG = (1 << 1),
};

enum {
  WM_OUTLINER_SYNC_SELECT_FROM_OBJECT = (1 << 0),
  WM_OUTLINER_SYNC_SELECT_FROM_EDIT_BONE = (1 << 1),
  WM_OUTLINER_SYNC_SELECT_FROM_POSE_BONE = (1 << 2),
  WM_OUTLINER_SYNC_SELECT_FROM_SEQUENCE = (1 << 3),
};
 
#define WM_OUTLINER_SYNC_SELECT_FROM_ALL \
  (WM_OUTLINER_SYNC_SELECT_FROM_OBJECT | WM_OUTLINER_SYNC_SELECT_FROM_EDIT_BONE | \
   WM_OUTLINER_SYNC_SELECT_FROM_POSE_BONE | WM_OUTLINER_SYNC_SELECT_FROM_SEQUENCE)
 
#define WM_KEYCONFIG_STR_DEFAULT "Blender"
 
/* IME is win32 and apple only! */
#if !(defined(WIN32) || defined(__APPLE__)) && !defined(DNA_DEPRECATED)
#  ifdef __GNUC__
#    define ime_data ime_data __attribute__((deprecated))
#  endif
#endif

typedef struct wmWindow {
  struct wmWindow *next, *prev;

  void *ghostwin;
  void *gpuctx;

  struct wmWindow *parent;

  struct Scene *scene;
  struct Scene *new_scene;
  char view_layer_name[64];
  struct Scene *unpinned_scene;
 
  struct WorkSpaceInstanceHook *workspace_hook;

  ScrAreaMap global_areas;
 
  struct bScreen *screen DNA_DEPRECATED;

  int winid;
  short posx, posy;
  short sizex, sizey;
  char windowstate;
  char active;
  short cursor;
  short lastcursor;
  short modalcursor;
  short grabcursor;

  short pie_event_type_lock;
  short pie_event_type_last;
 
  char addmousemove;
  char tag_cursor_refresh;
 
  /* Track the state of the event queue,
   * these store the state that needs to be kept between handling events in the queue. */
  char event_queue_check_click;
  char event_queue_check_drag;
  char event_queue_check_drag_handled;

  char event_queue_consecutive_gesture_type;
  int event_queue_consecutive_gesture_xy[2];
  struct wmEvent_ConsecutiveData *event_queue_consecutive_gesture_data;

  struct wmEvent *eventstate;
  struct wmEvent *event_last_handled;

  const struct wmIMEData *ime_data;
  char ime_data_is_composing;
  char _pad1[7];

  ListBase event_queue;
  ListBase handlers;
  ListBase modalhandlers;

  ListBase gesture;

  struct Stereo3dFormat *stereo3d_format;

  ListBase drawcalls;

  void *cursor_keymap_status;

  uint64_t eventstate_prev_press_time_ms;
 
} wmWindow;
 
#ifdef ime_data
#  undef ime_data
#endif
 
/* These two lines with # tell `makesdna` this struct can be excluded. */
/* should be something like DNA_EXCLUDE
 * but the preprocessor first removes all comments, spaces etc */
#
#
typedef struct wmOperatorTypeMacro {
  struct wmOperatorTypeMacro *next, *prev;
 
  /* operator id */
  char idname[64]; /* OP_MAX_TYPENAME */
  /* rna pointer to access properties, like keymap */
  struct IDProperty *properties;
  struct PointerRNA *ptr;
} wmOperatorTypeMacro;

typedef struct wmKeyMapItem {
  struct wmKeyMapItem *next, *prev;
 
  /* operator */
  char idname[64];
  IDProperty *properties;
 
  /* modal */
  char propvalue_str[64];
  short propvalue;
 
  /* event */
  short type;
  int8_t val;
  int8_t direction;
  short shift, ctrl, alt, oskey;
  short keymodifier;
 
  /* flag: inactive, expanded */
  short flag;
 
  /* runtime */
  short maptype;
  short id;
  char _pad[2];
  struct PointerRNA *ptr;
} wmKeyMapItem;

typedef struct wmKeyMapDiffItem {
  struct wmKeyMapDiffItem *next, *prev;
 
  wmKeyMapItem *remove_item;
  wmKeyMapItem *add_item;
} wmKeyMapDiffItem;

enum {
  KMI_INACTIVE = (1 << 0),
  KMI_EXPANDED = (1 << 1),
  KMI_USER_MODIFIED = (1 << 2),
  KMI_UPDATE = (1 << 3),
  KMI_REPEAT_IGNORE = (1 << 4),
};

enum {
  KMI_TYPE_KEYBOARD = 0,
  KMI_TYPE_MOUSE = 1,
  /* 2 is deprecated, was tweak. */
  KMI_TYPE_TEXTINPUT = 3,
  KMI_TYPE_TIMER = 4,
  KMI_TYPE_NDOF = 5,
};

typedef struct wmKeyMap {
  struct wmKeyMap *next, *prev;
 
  ListBase items;
  ListBase diff_items;

  char idname[64];
  short spaceid;
  short regionid;
  char owner_id[128];

  short flag;
  short kmi_id;
 
  /* runtime */
  bool (*poll)(struct bContext *);
  bool (*poll_modal_item)(const struct wmOperator *op, int value);

  const void *modal_items;
} wmKeyMap;

enum {
  KEYMAP_MODAL = (1 << 0),
  KEYMAP_USER = (1 << 1),
  KEYMAP_EXPANDED = (1 << 2),
  KEYMAP_CHILDREN_EXPANDED = (1 << 3),
  KEYMAP_DIFF = (1 << 4),
  KEYMAP_USER_MODIFIED = (1 << 5),
  KEYMAP_UPDATE = (1 << 6),
  KEYMAP_TOOL = (1 << 7),
};

typedef struct wmKeyConfigPref {
  struct wmKeyConfigPref *next, *prev;
  char idname[64];
  IDProperty *prop;
} wmKeyConfigPref;
 
typedef struct wmKeyConfig {
  struct wmKeyConfig *next, *prev;

  char idname[64];
  char basename[64];
 
  ListBase keymaps;
  int actkeymap;
  short flag;
  char _pad0[2];
} wmKeyConfig;

enum {
  KEYCONF_USER = (1 << 1),         /* And what about (1 << 0)? */
  KEYCONF_INIT_DEFAULT = (1 << 2), /* Has default keymap been initialized? */
};

typedef struct wmOperator {
  struct wmOperator *next, *prev;
 
  /* saved */
  char idname[64]; /* OP_MAX_TYPENAME */
  IDProperty *properties;
 
  /* runtime */
  struct wmOperatorType *type;
  void *customdata;
  void *py_instance;

  struct PointerRNA *ptr;
  struct ReportList *reports;

  ListBase macro;
  struct wmOperator *opm;
  struct uiLayout *layout;
  short flag;
  char _pad[6];
} wmOperator;

enum {
  OPERATOR_RUNNING_MODAL = (1 << 0),
  OPERATOR_CANCELLED = (1 << 1),
  OPERATOR_FINISHED = (1 << 2),
  OPERATOR_PASS_THROUGH = (1 << 3),
  OPERATOR_HANDLED = (1 << 4),
  OPERATOR_INTERFACE = (1 << 5),
};
#define OPERATOR_FLAGS_ALL \
  (OPERATOR_RUNNING_MODAL | OPERATOR_CANCELLED | OPERATOR_FINISHED | OPERATOR_PASS_THROUGH | \
   OPERATOR_HANDLED | OPERATOR_INTERFACE | 0)
 
/* sanity checks for debug mode only */
#define OPERATOR_RETVAL_CHECK(ret) \
  (void)ret, BLI_assert(ret != 0 && (ret & OPERATOR_FLAGS_ALL) == ret)

enum {
  OP_IS_INVOKE = (1 << 0),
  OP_IS_REPEAT = (1 << 1),
  OP_IS_REPEAT_LAST = (1 << 2),

  OP_IS_MODAL_GRAB_CURSOR = (1 << 3),

  OP_IS_MODAL_CURSOR_REGION = (1 << 4),
};