DNA_windowmanager_types.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2007 Blender Foundation.
 * All rights reserved.
 */
 
#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
extern "C" {
#endif
 
/* defined here: */
struct wmWindow;
struct wmWindowManager;
 
struct wmEvent;
struct wmGesture;
struct wmKeyConfig;
struct wmKeyMap;
struct wmMsgBus;
struct wmOperator;
struct wmOperatorType;
 
/* forwards */
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
 
/* keep in sync with 'rna_enum_wm_report_items' in wm_rna.c */
typedef enum ReportType {
  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),
} ReportType;
 
#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) */
};
 
/* 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;
 
/* saved in the wm, don't remove */
typedef struct ReportList {
  ListBase list;
  int printlevel;
  int storelevel;
  int flag;
  char _pad[4];
  struct wmTimer *reporttimer;
} ReportList;
 
/* timer customdata to control reports display */
/* These two Lines with # tell makesdna this struct can be excluded. */
#
#
typedef struct ReportTimerInfo {
  float col[4];
  float widthfac;
} ReportTimerInfo;
 
//#ifdef WITH_XR_OPENXR
typedef struct wmXrData {
  struct wmXrRuntimeData *runtime;
  XrSessionSettings session_settings;
} wmXrData;
//#endif
 
/* reports need to be before wmWindowManager */
 
/* windowmanager is saved, tag WMAN */
typedef struct wmWindowManager {
  ID id;
 
  struct wmWindow *windrawable, *winactive;
  ListBase windows;
 
  short initialized;
  short file_saved;
  short op_undo_depth;
 
  short outliner_sync_select_dirty;
 
  ListBase operators;
 
  ListBase notifier_queue;
 
  struct ReportList reports;
 
  ListBase jobs;
 
  ListBase paintcursors;
 
  ListBase drags;
 
  ListBase keyconfigs;
  struct wmKeyConfig *defaultconf;
  struct wmKeyConfig *addonconf;
  struct wmKeyConfig *userconf;
 
  ListBase timers;
  struct wmTimer *autosavetimer;
 
  struct UndoStack *undo_stack;
 
  char is_interface_locked;
  char _pad[7];
 
  struct wmMsgBus *message_bus;
 
  //#ifdef WITH_XR_OPENXR
  wmXrData xr;
  //#endif
} wmWindowManager;
 
/* wmWindowManager.initialized */
enum {
  WM_WINDOW_IS_INIT = (1 << 0),
  WM_KEYCONFIG_IS_INIT = (1 << 1),
};
 
/* wmWindowManager.outliner_sync_select_dirty */
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 only! */
#if !defined(WIN32) && !defined(DNA_DEPRECATED)
#  ifdef __GNUC__
#    define ime_data ime_data __attribute__((deprecated))
#  endif
#endif
 
/* the saveable part, rest of data is local in ghostwinlay */
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 WorkSpaceInstanceHook *workspace_hook;
 
  ScrAreaMap global_areas;
 
  struct bScreen *screen DNA_DEPRECATED;
 
  int winid;
  short posx, posy, sizex, sizey;
  char windowstate;
  char active;
  short cursor;
  short lastcursor;
  short modalcursor;
  short grabcursor;
  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 _pad0[1];
 
  short pie_event_type_lock;
  short pie_event_type_last;
 
  struct wmEvent *eventstate;
 
  struct wmGesture *tweak;
 
  /* Input Method Editor data - complex character input (especially for Asian character input)
   * Currently WIN32, runtime-only data. */
  struct wmIMEData *ime_data;
 
  ListBase event_queue;
  ListBase handlers;
  ListBase modalhandlers;
 
  ListBase gesture;
 
  struct Stereo3dFormat *stereo3d_format;
 
  /* custom drawing callbacks */
  ListBase drawcalls;
 
  /* Private runtime info to show text in the status bar. */
  void *cursor_keymap_status;
} 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];
  /* rna pointer to access properties, like keymap */
  struct IDProperty *properties;
  struct PointerRNA *ptr;
} wmOperatorTypeMacro;
 
/* Partial copy of the event, for matching by event handler. */
typedef struct wmKeyMapItem {
  struct wmKeyMapItem *next, *prev;
 
  /* operator */
  char idname[64];
  IDProperty *properties;
 
  /* modal */
  char propvalue_str[64];
  short propvalue;
 
  /* event */
  short type;
  short val;
  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,
  KMI_TYPE_TWEAK = 2,
  KMI_TYPE_TEXTINPUT = 3,
  KMI_TYPE_TIMER = 4,
  KMI_TYPE_NDOF = 5,
};
 
/* stored in WM, the actively used keymaps */
typedef struct wmKeyMap {
  struct wmKeyMap *next, *prev;
 
  ListBase items;
  ListBase diff_items;
 
  char idname[64];
  short spaceid;
  short regionid;
  char owner_id[64];
 
  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), /* modal map, not using operatornames */
  KEYMAP_USER = (1 << 1),  /* user keymap */
  KEYMAP_EXPANDED = (1 << 2),
  KEYMAP_CHILDREN_EXPANDED = (1 << 3),
  KEYMAP_DIFF = (1 << 4),          /* diff keymap for user preferences */
  KEYMAP_USER_MODIFIED = (1 << 5), /* keymap has user modifications */
  KEYMAP_UPDATE = (1 << 6),
  KEYMAP_TOOL = (1 << 7), /* keymap for active tool system */
};
 
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];
  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),
  /* add this flag if the event should pass through */
  OPERATOR_PASS_THROUGH = (1 << 3),
  /* in case operator got executed outside WM code... like via fileselect */
  OPERATOR_HANDLED = (1 << 4),
  /* used for operators that act indirectly (eg. popup menu)
   * note: this isn't great design (using operators to trigger UI) avoid where possible. */
  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 << 1),
 
  OP_IS_MODAL_GRAB_CURSOR = (1 << 2),
 
  OP_IS_MODAL_CURSOR_REGION = (1 << 3),
};
 
#ifdef __cplusplus
}
#endif