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_windowmanager_enums.h" /* Own enums. */
 
#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 {
struct WindowManagerRuntime;
struct WindowRuntime;
}  // namespace blender::bke
using WindowManagerRuntimeHandle = blender::bke::WindowManagerRuntime;
using WindowRuntimeHandle = blender::bke::WindowRuntime;
#else   // __cplusplus
typedef struct WindowManagerRuntimeHandle WindowManagerRuntimeHandle;
typedef struct WindowRuntimeHandle WindowRuntimeHandle;
#endif  // __cplusplus
 
#ifdef hyper /* MSVC defines. */
#  undef hyper
#endif
 
/* 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 {
#ifdef __cplusplus
  static constexpr ID_Type id_type = ID_WM;
#endif
 
  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;

  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[/*MAX_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 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;

  short 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;

  char addmousemove;
  char _pad1[7];

  ListBase handlers;
  ListBase modalhandlers;

  ListBase gesture;

  struct Stereo3dFormat *stereo3d_format;

  ListBase drawcalls;

  void *cursor_keymap_status;

  void *_pad2;
  uint64_t eventstate_prev_press_time_ms;
 
  WindowRuntimeHandle *runtime;
  void *_pad3;
} 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[/*OP_MAX_TYPENAME*/ 64];
  /* 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;
 
  /* Modifier keys:
   * Valid values:
   * - #KM_ANY
   * - #KM_NOTHING
   * - #KM_MOD_HELD (not #KM_PRESS even though the values match).
   */
 
  int8_t shift;
  int8_t ctrl;
  int8_t alt;
  int8_t oskey;
  int8_t hyper;
 
  char _pad0[7];

  short keymodifier;
 
  /* flag: inactive, expanded */
  uint8_t flag;
 
  /* runtime */
  uint8_t maptype;
  short id;
  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[/*OP_MAX_TYPENAME*/ 64];
  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;