griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup: Comment formatting, grammar

Browse Source
This commit is contained in:
Hans Goudey
2020-10-14 15:04:49 -05:00
parent 11a8a6d0e6
commit a509e79a4c
3 changed files with 249 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
source/blender/windowmanager/intern/wm.c
View File

@@ -20,9 +20,9 @@
/** \file
* \ingroup wm
*
* Internal functions for managing UI registrable types (operator, UI and menu types)
* Internal functions for managing UI registrable types (operator, UI and menu types).
*
* Also Blenders main event loop (WM_main)
* Also Blender's main event loop (WM_main).
*/
#include <stddef.h>
@@ -87,7 +87,7 @@ static void window_manager_foreach_id(ID *id, LibraryForeachIDData *data)
if (win->workspace_hook != NULL) {
ID *workspace = (ID *)BKE_workspace_active_get(win->workspace_hook);
BKE_LIB_FOREACHID_PROCESS_ID(data, workspace, IDWALK_CB_NOP);
/* allow callback to set a different workspace */
/* Allow callback to set a different workspace. */
BKE_workspace_active_set(win->workspace_hook, (WorkSpace *)workspace);
}
if (BKE_lib_query_foreachid_process_flags_get(data) & IDWALK_INCLUDE_UI) {
@@ -129,8 +129,7 @@ void WM_operator_free(wmOperator *op)
#ifdef WITH_PYTHON
if (op->py_instance) {
/* do this first in case there are any __del__ functions or
* similar that use properties */
/* Do this first in case there are any __del__ functions or similar that use properties. */
BPY_DECREF_RNA_INVALIDATE(op->py_instance);
}
#endif
@@ -180,13 +179,13 @@ void WM_operator_free_all_after(wmWindowManager *wm, struct wmOperator *op)
*/
void WM_operator_type_set(wmOperator *op, wmOperatorType *ot)
{
/* not supported for Python */
/* Not supported for Python. */
BLI_assert(op->py_instance == NULL);
op->type = ot;
op->ptr->type = ot->srna;
/* ensure compatible properties */
/* Ensure compatible properties. */
if (op->properties) {
PointerRNA ptr;
@@ -208,8 +207,8 @@ static void wm_reports_free(wmWindowManager *wm)
WM_event_remove_timer(wm, NULL, wm->reports.reporttimer);
}
/* all operations get registered in the windowmanager here */
/* called on event handling by event_system.c */
/* All operations get registered in the windowmanager here. */
/* Called on event handling by event_system.c. */
void wm_operator_register(bContext *C, wmOperator *op)
{
wmWindowManager *wm = CTX_wm_manager(C);
@@ -217,7 +216,7 @@ void wm_operator_register(bContext *C, wmOperator *op)
BLI_addtail(&wm->operators, op);
/* only count registered operators */
/* Only count registered operators. */
while (op) {
wmOperator *op_prev = op->prev;
if (op->type->flag & OPTYPE_REGISTER) {
@@ -230,7 +229,7 @@ void wm_operator_register(bContext *C, wmOperator *op)
op = op_prev;
}
/* so the console is redrawn */
/* So the console is redrawn. */
WM_event_add_notifier(C, NC_SPACE | ND_SPACE_INFO_REPORT, NULL);
WM_event_add_notifier(C, NC_WM | ND_HISTORY, NULL);
}
@@ -287,7 +286,7 @@ void WM_keyconfig_init(bContext *C)
{
wmWindowManager *wm = CTX_wm_manager(C);
/* create standard key configs */
/* Create standard key configs. */
if (wm->defaultconf == NULL) {
/* Keep lowercase to match the preset filename. */
wm->defaultconf = WM_keyconfig_new(wm, WM_KEYCONFIG_STR_DEFAULT, false);
@@ -299,8 +298,7 @@ void WM_keyconfig_init(bContext *C)
wm->userconf = WM_keyconfig_new(wm, WM_KEYCONFIG_STR_DEFAULT " user", false);
}
/* initialize only after python init is done, for keymaps that
* use python operators */
/* Initialize only after python init is done, for keymaps that use python operators. */
if (CTX_py_init_get(C) && (wm->initialized & WM_KEYCONFIG_IS_INIT) == 0) {
/* create default key config, only initialize once,
* it's persistent across sessions */
@@ -325,7 +323,7 @@ void WM_check(bContext *C)
Main *bmain = CTX_data_main(C);
wmWindowManager *wm = CTX_wm_manager(C);
/* wm context */
/* WM context. */
if (wm == NULL) {
wm = bmain->wm.first;
CTX_wm_manager_set(C, wm);
@@ -341,18 +339,18 @@ void WM_check(bContext *C)
}
if (!G.background) {
/* case: fileread */
/* Case: fileread. */
if ((wm->initialized & WM_WINDOW_IS_INIT) == 0) {
WM_keyconfig_init(C);
WM_autosave_init(wm);
}
/* case: no open windows at all, for old file reads */
/* Case: no open windows at all, for old file reads. */
wm_window_ghostwindows_ensure(wm);
}
/* case: fileread */
/* note: this runs in bg mode to set the screen context cb */
/* Case: fileread. */
/* Note: this runs in background mode to set the screen context cb. */
if ((wm->initialized & WM_WINDOW_IS_INIT) == 0) {
ED_screens_init(bmain, wm);
wm->initialized |= WM_WINDOW_IS_INIT;
@@ -364,7 +362,7 @@ void wm_clear_default_size(bContext *C)
wmWindowManager *wm = CTX_wm_manager(C);
wmWindow *win;
/* wm context */
/* WM context. */
if (wm == NULL) {
wm = CTX_data_main(C)->wm.first;
CTX_wm_manager_set(C, wm);
@@ -382,7 +380,7 @@ void wm_clear_default_size(bContext *C)
}
}
/* on startup, it adds all data, for matching */
/* On startup, it adds all data, for matching. */
void wm_add_default(Main *bmain, bContext *C)
{
wmWindowManager *wm = BKE_libblock_alloc(bmain, ID_WM, "WinMan", 0);
@@ -404,7 +402,7 @@ void wm_add_default(Main *bmain, bContext *C)
wm_window_make_drawable(wm, win);
}
/* context is allowed to be NULL, do not free wm itself (lib_id.c) */
/* Context is allowed to be NULL, do not free wm itself (lib_id.c). */
void wm_close_and_free(bContext *C, wmWindowManager *wm)
{
wmWindow *win;
@@ -421,7 +419,7 @@ void wm_close_and_free(bContext *C, wmWindowManager *wm)
#endif
while ((win = BLI_pophead(&wm->windows))) {
/* prevent draw clear to use screen */
/* Prevent draw clear to use screen. */
BKE_workspace_active_set(win->workspace_hook, NULL);
wm_window_free(C, wm, win);
}
@@ -476,16 +474,16 @@ void WM_main(bContext *C)
while (1) {
/* get events from ghost, handle window events, add to window queues */
/* Get events from ghost, handle window events, add to window queues. */
wm_window_process_events(C);
/* per window, all events to the window, screen, area and region handlers */
/* Per window, all events to the window, screen, area and region handlers. */
wm_event_do_handlers(C);
/* events have left notes about changes, we handle and cache it */
/* Wvents have left notes about changes, we handle and cache it. */
wm_event_do_notifiers(C);
/* execute cached changes draw */
/* Wxecute cached changes draw. */
wm_draw_update(C);
}
}

436
source/blender/windowmanager/intern/wm_event_system.c
View File

@@ -157,7 +157,7 @@ void wm_event_free(wmEvent *event)
{
if (event->customdata) {
if (event->customdatafree) {
/* note: pointer to listbase struct elsewhere */
/* Note: pointer to listbase struct elsewhere. */
if (event->custom == EVT_DATA_DRAGDROP) {
ListBase *lb = event->customdata;
WM_drag_free_list(lb);
@@ -268,8 +268,8 @@ void WM_main_remove_notifier_reference(const void *reference)
note_next = note->next;
if (note->reference == reference) {
/* don't remove because this causes problems for #wm_event_do_notifiers
* which may be looping on the data (deleting screens) */
/* Don't remove because this causes problems for #wm_event_do_notifiers
* which may be looping on the data (deleting screens). */
wm_notifier_clear(note);
}
}
@@ -314,7 +314,7 @@ void WM_main_remap_editor_id_reference(ID *old_id, ID *new_id)
static void wm_notifier_clear(wmNotifier *note)
{
/* NULL the entire notifier, only leaving (next, prev) members intact */
/* NULL the entire notifier, only leaving (next, prev) members intact. */
memset(((char *)note) + sizeof(Link), 0, sizeof(*note) - sizeof(Link));
}
@@ -322,13 +322,13 @@ void wm_event_do_depsgraph(bContext *C, bool is_after_open_file)
{
wmWindowManager *wm = CTX_wm_manager(C);
/* The whole idea of locked interface is to prevent viewport and whatever
* thread to modify the same data. Because of this, we can not perform
* thread from modifying the same data. Because of this, we can not perform
* dependency graph update.
*/
if (wm->is_interface_locked) {
return;
}
/* Combine datamasks so 1 win doesn't disable UV's in another T26448. */
/* Combine datamasks so one window doesn't disable UV's in another T26448. */
CustomData_MeshMasks win_combine_v3d_datamask = {0};
LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
const Scene *scene = WM_window_get_active_scene(win);
@@ -369,7 +369,7 @@ void wm_event_do_depsgraph(bContext *C, bool is_after_open_file)
void wm_event_do_refresh_wm_and_depsgraph(bContext *C)
{
wmWindowManager *wm = CTX_wm_manager(C);
/* cached: editor refresh callbacks now, they get context */
/* Cached: editor refresh callbacks now, they get context. */
LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
const bScreen *screen = WM_window_get_active_screen(win);
ScrArea *area;
@@ -403,7 +403,7 @@ static void wm_event_execute_timers(bContext *C)
CTX_wm_window_set(C, NULL);
}
/* called in mainloop */
/* Called in mainloop. */
void wm_event_do_notifiers(bContext *C)
{
wmNotifier *note, *next;
@@ -417,9 +417,9 @@ void wm_event_do_notifiers(bContext *C)
return;
}
/* disable? - keep for now since its used for window level notifiers. */
/* Disable? - Keep for now since its used for window level notifiers. */
#if 1
/* cache & catch WM level notifiers, such as frame change, scene/screen set */
/* Cache & catch WM level notifiers, such as frame change, scene/screen set. */
for (win = wm->windows.first; win; win = win->next) {
Scene *scene = WM_window_get_active_scene(win);
bool do_anim = false;
@@ -502,27 +502,27 @@ void wm_event_do_notifiers(bContext *C)
* collide (happens on slow scenes), BKE_scene_graph_update_for_newframe can be called
* twice which can depgraph update the same object at once */
if (G.is_rendering == false) {
/* depsgraph gets called, might send more notifiers */
/* Depsgraph gets called, might send more notifiers. */
Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C);
ED_update_for_newframe(CTX_data_main(C), depsgraph);
}
}
}
/* the notifiers are sent without context, to keep it clean */
/* The notifiers are sent without context, to keep it clean. */
while ((note = BLI_pophead(&wm->queue))) {
for (win = wm->windows.first; win; win = win->next) {
Scene *scene = WM_window_get_active_scene(win);
bScreen *screen = WM_window_get_active_screen(win);
WorkSpace *workspace = WM_window_get_active_workspace(win);
/* filter out notifiers */
/* Dilter out notifiers. */
if (note->category == NC_SCREEN && note->reference && note->reference != screen &&
note->reference != workspace && note->reference != WM_window_get_active_layout(win)) {
/* pass */
/* Pass. */
}
else if (note->category == NC_SCENE && note->reference && note->reference != scene) {
/* pass */
/* Pass. */
}
else {
ARegion *region;
@@ -580,7 +580,7 @@ void wm_event_do_notifiers(bContext *C)
static int wm_event_always_pass(const wmEvent *event)
{
/* some events we always pass on, to ensure proper communication */
/* Some events we always pass on, to ensure proper communication. */
return ISTIMER(event->type) || (event->type == WINDEACTIVATE);
}
@@ -603,14 +603,14 @@ static int wm_handler_ui_call(bContext *C,
int retval;
/* UI code doesn't handle return values - it just always returns break.
* to make the DBL_CLICK conversion work, we just don't send this to UI, except mouse clicks */
* to make the DBL_CLICK conversion work, we just don't send this to UI, except mouse clicks. */
if (((handler->head.flag & WM_HANDLER_ACCEPT_DBL_CLICK) == 0) && !ISMOUSE_BUTTON(event->type) &&
(event->val == KM_DBL_CLICK)) {
return WM_HANDLER_CONTINUE;
}
/* UI is quite aggressive with swallowing events, like scroll-wheel. */
/* I realize this is not extremely nice code... when UI gets keymaps it can be maybe smarter */
/* I realize this is not extremely nice code... when UI gets keymaps it can be maybe smarter. */
if (do_wheel_ui == false) {
if (is_wheel) {
return WM_HANDLER_CONTINUE;
@@ -646,7 +646,7 @@ static int wm_handler_ui_call(bContext *C,
CTX_wm_menu_set(C, menu);
}
else {
/* this special cases is for areas and regions that get removed */
/* This special cases is for areas and regions that get removed. */
CTX_wm_area_set(C, NULL);
CTX_wm_region_set(C, NULL);
CTX_wm_menu_set(C, NULL);
@@ -739,7 +739,7 @@ void WM_ndof_deadzone_set(float deadzone)
static void wm_add_reports(ReportList *reports)
{
/* if the caller owns them, handle this */
/* If the caller owns them, handle this. */
if (reports->list.first && (reports->flag & RPT_OP_HOLD) == 0) {
wmWindowManager *wm = G_MAIN->wm.first;
@@ -797,7 +797,7 @@ bool WM_operator_poll(bContext *C, wmOperatorType *ot)
}
}
/* python needs operator type, so we added exception for it */
/* Python needs operator type, so we added exception for it. */
if (ot->pyop_poll) {
return ot->pyop_poll(C, ot);
}
@@ -817,7 +817,7 @@ bool WM_operator_poll_context(bContext *C, wmOperatorType *ot, short context)
bool WM_operator_check_ui_empty(wmOperatorType *ot)
{
if (ot->macro.first != NULL) {
/* for macros, check all have exec() we can call */
/* For macros, check all have exec() we can call. */
wmOperatorTypeMacro *otmacro;
for (otmacro = ot->macro.first; otmacro; otmacro = otmacro->next) {
wmOperatorType *otm = WM_operatortype_find(otmacro->idname, 0);
@@ -862,12 +862,12 @@ void WM_operator_region_active_win_set(bContext *C)
}
}
/* (caller_owns_reports == true) when called from python */
/* (caller_owns_reports == true) when called from python. */
static void wm_operator_reports(bContext *C, wmOperator *op, int retval, bool caller_owns_reports)
{
if (G.background == 0 && caller_owns_reports == false) { /* popup */
if (op->reports->list.first) {
/* FIXME, temp setting window, see other call to UI_popup_menu_reports for why */
/* FIXME, temp setting window, see other call to UI_popup_menu_reports for why. */
wmWindow *win_prev = CTX_wm_window(C);
ScrArea *area_prev = CTX_wm_area(C);
ARegion *region_prev = CTX_wm_region(C);
@@ -888,12 +888,12 @@ static void wm_operator_reports(bContext *C, wmOperator *op, int retval, bool ca
CLOG_STR_INFO_N(WM_LOG_OPERATORS, 1, WM_operator_pystring(C, op, false, true));
if (caller_owns_reports == false) {
BKE_reports_print(op->reports, RPT_DEBUG); /* print out reports to console. */
BKE_reports_print(op->reports, RPT_DEBUG); /* Print out reports to console. */
}
if (op->type->flag & OPTYPE_REGISTER) {
if (G.background == 0) { /* ends up printing these in the terminal, gets annoying */
/* Report the python string representation of the operator */
if (G.background == 0) { /* Ends up printing these in the terminal, gets annoying. */
/* Report the python string representation of the operator. */
char *buf = WM_operator_pystring(C, op, false, true);
BKE_report(CTX_wm_reports(C), RPT_OPERATOR, buf);
MEM_freeN(buf);
@@ -905,7 +905,7 @@ static void wm_operator_reports(bContext *C, wmOperator *op, int retval, bool ca
if ((retval & OPERATOR_CANCELLED) && !BLI_listbase_is_empty(&op->reports->list)) {
WM_event_add_notifier(C, NC_SPACE | ND_SPACE_INFO_REPORT, NULL);
}
/* if the caller owns them, handle this */
/* If the caller owns them, handle this. */
wm_add_reports(op->reports);
}
@@ -935,9 +935,9 @@ static void wm_operator_finished(bContext *C, wmOperator *op, const bool repeat,
WM_operator_last_properties_store(op);
}
/* we don't want to do undo pushes for operators that are being
* called from operators that already do an undo push. usually
* this will happen for python operators that call C operators */
/* We don't want to do undo pushes for operators that are being
* called from operators that already do an undo push. Usually
* this will happen for python operators that call C operators. */
if (wm->op_undo_depth == 0) {
if (op->type->flag & OPTYPE_UNDO) {
ED_undo_push_op(C, op);
@@ -993,7 +993,7 @@ static void wm_operator_finished(bContext *C, wmOperator *op, const bool repeat,
}
}
/* if repeat is true, it doesn't register again, nor does it free */
/* If repeat is true, it doesn't register again, nor does it free. */
static int wm_operator_exec(bContext *C, wmOperator *op, const bool repeat, const bool store)
{
wmWindowManager *wm = CTX_wm_manager(C);
@@ -1042,7 +1042,7 @@ static int wm_operator_exec(bContext *C, wmOperator *op, const bool repeat, cons
return retval | OPERATOR_HANDLED;
}
/* simply calls exec with basic checks */
/* Simply calls exec with basic checks. */
static int wm_operator_exec_notest(bContext *C, wmOperator *op)
{
int retval = OPERATOR_CANCELLED;
@@ -1058,7 +1058,7 @@ static int wm_operator_exec_notest(bContext *C, wmOperator *op)
}
/**
* for running operators with frozen context (modal handlers, menus)
* For running operators with frozen context (modal handlers, menus).
*
* \param store: Store settings for re-use.
*
@@ -1104,8 +1104,8 @@ int WM_operator_repeat_last(bContext *C, wmOperator *op)
return ret;
}
/**
* \return true if #WM_operator_repeat can run
* simple check for now but may become more involved.
* \return true if #WM_operator_repeat can run.
* Simple check for now but may become more involved.
* To be sure the operator can run call `WM_operator_poll(C, op->type)` also, since this call
* checks if #WM_operator_repeat() can run at all, not that it WILL run at any time.
*/
@@ -1131,7 +1131,7 @@ bool WM_operator_repeat_check(const bContext *UNUSED(C), wmOperator *op)
bool WM_operator_is_repeat(const bContext *C, const wmOperator *op)
{
/* may be in the operators list or not */
/* May be in the operators list or not. */
wmOperator *op_prev;
if (op->prev == NULL && op->next == NULL) {
wmWindowManager *wm = CTX_wm_manager(C);
@@ -1155,7 +1155,7 @@ static wmOperator *wm_operator_create(wmWindowManager *wm,
op->type = ot;
BLI_strncpy(op->idname, ot->idname, OP_MAX_TYPENAME);
/* initialize properties, either copy or create */
/* Initialize properties, either copy or create. */
op->ptr = MEM_callocN(sizeof(PointerRNA), "wmOperatorPtrRNA");
if (properties && properties->data) {
op->properties = IDP_CopyProperty(properties->data);
@@ -1166,28 +1166,28 @@ static wmOperator *wm_operator_create(wmWindowManager *wm,
}
RNA_pointer_create(&wm->id, ot->srna, op->properties, op->ptr);
/* initialize error reports */
/* Initialize error reports. */
if (reports) {
op->reports = reports; /* must be initialized already */
op->reports = reports; /* Must be initialized already. */
}
else {
op->reports = MEM_mallocN(sizeof(ReportList), "wmOperatorReportList");
BKE_reports_init(op->reports, RPT_STORE | RPT_FREE);
}
/* recursive filling of operator macro list */
/* Recursive filling of operator macro list. */
if (ot->macro.first) {
static wmOperator *motherop = NULL;
wmOperatorTypeMacro *otmacro;
int root = 0;
/* ensure all ops are in execution order in 1 list */
/* Ensure all ops are in execution order in 1 list. */
if (motherop == NULL) {
motherop = op;
root = 1;
}
/* if properties exist, it will contain everything needed */
/* If properties exist, it will contain everything needed. */
if (properties) {
otmacro = ot->macro.first;
@@ -1197,7 +1197,7 @@ static wmOperator *wm_operator_create(wmWindowManager *wm,
break;
}
/* skip invalid properties */
/* Skip invalid properties. */
if (STREQ(RNA_property_identifier(prop), otmacro->idname)) {
wmOperatorType *otm = WM_operatortype_find(otmacro->idname, 0);
PointerRNA someptr = RNA_property_pointer_get(properties, prop);
@@ -1206,7 +1206,7 @@ static wmOperator *wm_operator_create(wmWindowManager *wm,
IDP_ReplaceGroupInGroup(opm->properties, otmacro->properties);
BLI_addtail(&motherop->macro, opm);
opm->opm = motherop; /* pointer to mom, for modal() */
opm->opm = motherop; /* Pointer to mom, for modal(). */
otmacro = otmacro->next;
}
@@ -1219,7 +1219,7 @@ static wmOperator *wm_operator_create(wmWindowManager *wm,
wmOperator *opm = wm_operator_create(wm, otm, otmacro->ptr, NULL);
BLI_addtail(&motherop->macro, opm);
opm->opm = motherop; /* pointer to mom, for modal() */
opm->opm = motherop; /* Pointer to mom, for modal(). */
}
}
@@ -1237,12 +1237,12 @@ static void wm_region_mouse_co(bContext *C, wmEvent *event)
{
ARegion *region = CTX_wm_region(C);
if (region) {
/* compatibility convention */
/* Compatibility convention. */
event->mval[0] = event->x - region->winrct.xmin;
event->mval[1] = event->y - region->winrct.ymin;
}
else {
/* these values are invalid (avoid odd behavior by relying on old mval values) */
/* These values are invalid (avoid odd behavior by relying on old mval values). */
event->mval[0] = -1;
event->mval[1] = -1;
}
@@ -1270,7 +1270,7 @@ static int wm_operator_invoke(bContext *C,
if (WM_operator_poll(C, ot)) {
wmWindowManager *wm = CTX_wm_manager(C);
/* if reports == NULL, they'll be initialized */
/* If reports == NULL, they'll be initialized. */
wmOperator *op = wm_operator_create(wm, ot, properties, reports);
const bool is_nested_call = (wm->op_undo_depth != 0);
@@ -1279,8 +1279,8 @@ static int wm_operator_invoke(bContext *C,
op->flag |= OP_IS_INVOKE;
}
/* initialize setting from previous run */
if (!is_nested_call && use_last_properties) { /* not called by py script */
/* /initialize setting from previous run. */
if (!is_nested_call && use_last_properties) { /* Not called by py script. */
WM_operator_last_properties_init(op);
}
@@ -1320,30 +1320,30 @@ static int wm_operator_invoke(bContext *C,
}
}
else {
/* debug, important to leave a while, should never happen */
/* Debug, important to leave a while, should never happen. */
CLOG_ERROR(WM_LOG_OPERATORS, "invalid operator call '%s'", op->idname);
}
/* Note, if the report is given as an argument then assume the caller will deal with displaying
* them currently Python only uses this. */
if (!(retval & OPERATOR_HANDLED) && (retval & (OPERATOR_FINISHED | OPERATOR_CANCELLED))) {
/* only show the report if the report list was not given in the function */
/* Only show the report if the report list was not given in the function. */
wm_operator_reports(C, op, retval, (reports != NULL));
}
if (retval & OPERATOR_HANDLED) {
/* do nothing, wm_operator_exec() has been called somewhere */
/* Do nothing, wm_operator_exec() has been called somewhere. */
}
else if (retval & OPERATOR_FINISHED) {
const bool store = !is_nested_call && use_last_properties;
wm_operator_finished(C, op, false, store);
}
else if (retval & OPERATOR_RUNNING_MODAL) {
/* take ownership of reports (in case python provided own) */
/* Take ownership of reports (in case python provided own). */
op->reports->flag |= RPT_FREE;
/* grab cursor during blocking modal ops (X11)
* Also check for macro
/* Grab cursor during blocking modal ops (X11)
* Also check for macro.
*/
if (ot->flag & OPTYPE_BLOCKING || (op->opm && op->opm->type->flag & OPTYPE_BLOCKING)) {
int bounds[4] = {-1, -1, -1, -1};
@@ -1393,10 +1393,10 @@ static int wm_operator_invoke(bContext *C,
WM_cursor_grab_enable(CTX_wm_window(C), wrap, false, bounds);
}
/* cancel UI handlers, typically tooltips that can hang around
/* Cancel UI handlers, typically tooltips that can hang around
* while dragging the view or worse, that stay there permanently
* after the modal operator has swallowed all events and passed
* none to the UI handler */
* none to the UI handler. */
wm_event_handler_ui_cancel(C);
}
else {
@@ -1409,9 +1409,8 @@ static int wm_operator_invoke(bContext *C,
/**
* #WM_operator_name_call is the main accessor function
* this is for python to access since its done the operator lookup
*
* invokes operator in context
* This is for python to access since its done the operator lookup
* invokes operator in context.
*/
static int wm_operator_call_internal(bContext *C,
wmOperatorType *ot,
@@ -1425,7 +1424,7 @@ static int wm_operator_call_internal(bContext *C,
CTX_wm_operator_poll_msg_set(C, NULL);
/* dummie test */
/* Dummy test. */
if (ot) {
wmWindow *window = CTX_wm_window(C);
@@ -1437,7 +1436,7 @@ static int wm_operator_call_internal(bContext *C,
case WM_OP_INVOKE_REGION_CHANNELS:
case WM_OP_INVOKE_AREA:
case WM_OP_INVOKE_SCREEN:
/* window is needed for invoke, cancel operator */
/* Window is needed for invoke and cancel operators. */
if (window == NULL) {
if (poll_only) {
CTX_wm_operator_poll_msg_set(C, "Missing 'window' in context");
@@ -1474,8 +1473,8 @@ static int wm_operator_call_internal(bContext *C,
case WM_OP_INVOKE_REGION_CHANNELS:
case WM_OP_EXEC_REGION_PREVIEW:
case WM_OP_INVOKE_REGION_PREVIEW: {
/* forces operator to go to the region window/channels/preview, for header menus
* but we stay in the same region if we are already in one
/* Forces operator to go to the region window/channels/preview, for header menus,
* but we stay in the same region if we are already in one.
*/
ARegion *region = CTX_wm_region(C);
ScrArea *area = CTX_wm_area(C);
@@ -1515,14 +1514,14 @@ static int wm_operator_call_internal(bContext *C,
retval = wm_operator_invoke(C, ot, event, properties, reports, poll_only, true);
/* set region back */
/* Set region back. */
CTX_wm_region_set(C, region);
return retval;
}
case WM_OP_EXEC_AREA:
case WM_OP_INVOKE_AREA: {
/* remove region from context */
/* Remove region from context. */
ARegion *region = CTX_wm_region(C);
CTX_wm_region_set(C, NULL);
@@ -1533,7 +1532,7 @@ static int wm_operator_call_internal(bContext *C,
}
case WM_OP_EXEC_SCREEN:
case WM_OP_INVOKE_SCREEN: {
/* remove region + area from context */
/* Remove region + area from context. */
ARegion *region = CTX_wm_region(C);
ScrArea *area = CTX_wm_area(C);
@@ -1554,7 +1553,7 @@ static int wm_operator_call_internal(bContext *C,
return 0;
}
/* invokes operator in context */
/* Invokes operator in context. */
int WM_operator_name_call_ptr(bContext *C,
wmOperatorType *ot,
short context,
@@ -1637,10 +1636,10 @@ int WM_operator_call_py(bContext *C,
#endif
/* not especially nice using undo depth here, its used so py never
* triggers undo or stores operators last used state.
/* Not especially nice using undo depth here. It's used so Python never
* triggers undo or stores an operator's last used state.
*
* we could have some more obvious way of doing this like passing a flag.
* We could have some more obvious way of doing this like passing a flag.
*/
wmWindowManager *wm = CTX_wm_manager(C);
if (!is_undo && wm) {
@@ -1664,13 +1663,13 @@ int WM_operator_call_py(bContext *C,
* General API for different handler types.
* \{ */
/* future extra customadata free? */
/* Future extra customadata free? */
void wm_event_free_handler(wmEventHandler *handler)
{
MEM_freeN(handler);
}
/* only set context when area/region is part of screen */
/* Only set context when area/region is part of screen. */
static void wm_handler_op_context(bContext *C, wmEventHandler_Op *handler, const wmEvent *event)
{
wmWindow *win = handler->context.win ? handler->context.win : CTX_wm_window(C);
@@ -1694,8 +1693,8 @@ static void wm_handler_op_context(bContext *C, wmEventHandler_Op *handler, const
}
if (area == NULL) {
/* when changing screen layouts with running modal handlers (like render display), this
* is not an error to print */
/* When changing screen layouts with running modal handlers (like render display), this
* is not an error to print. */
if (handler->op == NULL) {
CLOG_ERROR(WM_LOG_HANDLERS,
"internal error: handler (%s) has invalid area",
@@ -1725,7 +1724,7 @@ static void wm_handler_op_context(bContext *C, wmEventHandler_Op *handler, const
}
}
/* XXX no warning print here, after full-area and back regions are remade */
/* XXX no warning print here, after full-area and back regions are remade. */
if (region) {
CTX_wm_region_set(C, region);
}
@@ -1734,7 +1733,7 @@ static void wm_handler_op_context(bContext *C, wmEventHandler_Op *handler, const
}
}
/* called on exit or remove area, only here call cancel callback */
/* Called on exit or remove area, only here call cancel callback. */
void WM_event_remove_handlers(bContext *C, ListBase *handlers)
{
wmEventHandler *handler_base;
@@ -1815,9 +1814,9 @@ static bool wm_eventmatch(const wmEvent *winevent, const wmKeyMapItem *kmi)
const int kmitype = WM_userdef_event_map(kmi->type);
/* the matching rules */
/* The matching rules. */
if (kmitype == KM_TEXTINPUT) {
if (winevent->val == KM_PRESS) { /* prevent double clicks */
if (winevent->val == KM_PRESS) { /* Prevent double clicks. */
/* NOT using ISTEXTINPUT anymore because (at least on Windows) some key codes above 255
* could have printable ascii keys - BUG T30479. */
if (ISKEYBOARD(winevent->type) && (winevent->ascii || winevent->utf8_buf[0])) {
@@ -1831,7 +1830,7 @@ static bool wm_eventmatch(const wmEvent *winevent, const wmKeyMapItem *kmi)
const wmTabletData *wmtab = &winevent->tablet;
if (winevent->type != LEFTMOUSE) {
/* tablet events can occur on hover + keypress */
/* Tablet events can occur on hover + keypress. */
return false;
}
if ((kmitype == TABLET_STYLUS) && (wmtab->active != EVT_TABLET_STYLUS)) {
@@ -1926,7 +1925,7 @@ static void wm_event_modalkeymap_begin(const bContext *C,
{
BLI_assert(event->type != EVT_MODAL_MAP);
/* support for modal keymap in macros */
/* Support for modal keymap in macros. */
if (op->opm) {
op = op->opm;
}
@@ -2005,7 +2004,7 @@ static int wm_handler_operator_call(bContext *C,
{
int retval = OPERATOR_PASS_THROUGH;
/* derived, modal or blocking operator */
/* Derived, modal or blocking operator. */
if ((handler_base->type == WM_HANDLER_TYPE_OP) &&
(((wmEventHandler_Op *)handler_base)->op != NULL)) {
wmEventHandler_Op *handler = (wmEventHandler_Op *)handler_base;
@@ -2018,7 +2017,7 @@ static int wm_handler_operator_call(bContext *C,
*/
}
else if (ot->modal) {
/* we set context to where modal handler came from */
/* We set context to where modal handler came from. */
wmWindowManager *wm = CTX_wm_manager(C);
ScrArea *area = CTX_wm_area(C);
ARegion *region = CTX_wm_region(C);
@@ -2032,11 +2031,11 @@ static int wm_handler_operator_call(bContext *C,
wm->op_undo_depth++;
}
/* warning, after this call all context data and 'event' may be freed. see check below */
/* Warning, after this call all context data and 'event' may be freed. see check below. */
retval = ot->modal(C, op, event);
OPERATOR_RETVAL_CHECK(retval);
/* when this is _not_ the case the modal modifier may have loaded
/* When this is _not_ the case the modal modifier may have loaded
* a new blend file (demo mode does this), so we have to assume
* the event, operator etc have all been freed. - campbell */
if (CTX_wm_manager(C) == wm) {
@@ -2056,13 +2055,13 @@ static int wm_handler_operator_call(bContext *C,
}
}
else {
/* not very common, but modal operators may report before finishing */
/* Not very common, but modal operators may report before finishing. */
if (!BLI_listbase_is_empty(&op->reports->list)) {
wm_add_reports(op->reports);
}
}
/* important to run 'wm_operator_finished' before NULLing the context members */
/* Important to run 'wm_operator_finished' before NULLing the context members. */
if (retval & OPERATOR_FINISHED) {
wm_operator_finished(C, op, false, true);
handler->op = NULL;
@@ -2072,21 +2071,21 @@ static int wm_handler_operator_call(bContext *C,
handler->op = NULL;
}
/* putting back screen context, reval can pass trough after modal failures! */
/* Putting back screen context, reval can pass trough after modal failures! */
if ((retval & OPERATOR_PASS_THROUGH) || wm_event_always_pass(event)) {
CTX_wm_area_set(C, area);
CTX_wm_region_set(C, region);
}
else {
/* this special cases is for areas and regions that get removed */
/* This special cases is for areas and regions that get removed. */
CTX_wm_area_set(C, NULL);
CTX_wm_region_set(C, NULL);
}
/* update gizmos during modal handlers */
/* /update gizmos during modal handlers. */
wm_gizmomaps_handled_modal_update(C, event, handler);
/* remove modal handler, operator itself should have been canceled and freed */
/* Remove modal handler, operator itself should have been canceled and freed. */
if (retval & (OPERATOR_CANCELLED | OPERATOR_FINISHED)) {
WM_cursor_grab_disable(CTX_wm_window(C), NULL);
@@ -2164,14 +2163,14 @@ static int wm_handler_operator_call(bContext *C,
/* Done linking gizmo. */
}
}
/* Finished and pass through flag as handled */
/* Finished and pass through flag as handled. */
/* Finished and pass through flag as handled */
/* Finished and pass through flag as handled. */
if (retval == (OPERATOR_FINISHED | OPERATOR_PASS_THROUGH)) {
return WM_HANDLER_HANDLED;
}
/* Modal unhandled, break */
/* Modal unhandled, break. */
if (retval == (OPERATOR_PASS_THROUGH | OPERATOR_RUNNING_MODAL)) {
return (WM_HANDLER_BREAK | WM_HANDLER_MODAL);
}
@@ -2212,10 +2211,10 @@ static int wm_handler_fileselect_do(bContext *C,
BLI_assert(area->spacetype == SPACE_FILE);
region_header->flag |= RGN_FLAG_HIDDEN;
/* Header on bottom, AZone triangle to toggle header looks misplaced at the top */
/* Header on bottom, AZone triangle to toggle header looks misplaced at the top. */
region_header->alignment = RGN_ALIGN_BOTTOM;
/* settings for filebrowser, sfile is not operator owner but sends events */
/* Settings for filebrowser, #sfile is not operator owner but sends events. */
SpaceFile *sfile = (SpaceFile *)area->spacedata.first;
sfile->op = handler->op;
@@ -2235,7 +2234,7 @@ static int wm_handler_fileselect_do(bContext *C,
case EVT_FILESELECT_EXTERNAL_CANCEL: {
wmWindow *ctx_win = CTX_wm_window(C);
/* remlink now, for load file case before removing*/
/* Remove link now, for load file case before removing. */
BLI_remlink(handlers, handler);
if (val == EVT_FILESELECT_EXTERNAL_CANCEL) {
@@ -2264,10 +2263,10 @@ static int wm_handler_fileselect_do(bContext *C,
wm_window_close(C, wm, temp_win);
CTX_wm_window_set(C, ctx_win); /* #wm_window_close() NULLs. */
/* Some operators expect a drawable context (for EVT_FILESELECT_EXEC) */
/* Some operators expect a drawable context (for EVT_FILESELECT_EXEC). */
wm_window_make_drawable(wm, ctx_win);
/* Ensure correct cursor position, otherwise, popups may close immediately after
* opening (UI_BLOCK_MOVEMOUSE_QUIT) */
* opening (UI_BLOCK_MOVEMOUSE_QUIT). */
wm_get_cursor_position(ctx_win, &ctx_win->eventstate->x, &ctx_win->eventstate->y);
wm->winactive = ctx_win; /* Reports use this... */
if (handler->context.win == temp_win) {
@@ -2293,7 +2292,7 @@ static int wm_handler_fileselect_do(bContext *C,
wm_handler_op_context(C, handler, ctx_win->eventstate);
/* needed for UI_popup_menu_reports */
/* Needed for #UI_popup_menu_reports. */
if (val == EVT_FILESELECT_EXEC) {
int retval;
@@ -2339,7 +2338,7 @@ static int wm_handler_fileselect_do(bContext *C,
/* add reports to the global list, otherwise they are not seen */
BLI_movelisttolist(&CTX_wm_reports(C)->list, &handler->op->reports->list);
/* more hacks, since we meddle with reports, banner display doesn't happen automatic */
/* More hacks, since we meddle with reports, banner display doesn't happen automaticM */
WM_report_banner_show();
CTX_wm_window_set(C, win_prev);
@@ -2347,7 +2346,7 @@ static int wm_handler_fileselect_do(bContext *C,
CTX_wm_region_set(C, region_prev);
}
/* for WM_operator_pystring only, custom report handling is done above */
/* For WM_operator_pystring only, custom report handling is done above. */
wm_operator_reports(C, handler->op, retval, true);
if (retval & OPERATOR_FINISHED) {
@@ -2413,7 +2412,7 @@ static int wm_action_not_handled(int action)
printf
static int wm_handlers_do_keymap_with_keymap_handler(
/* From 'wm_handlers_do_intern' */
/* From 'wm_handlers_do_intern'. */
bContext *C,
wmEvent *event,
ListBase *handlers,
@@ -2445,7 +2444,7 @@ static int wm_handlers_do_keymap_with_keymap_handler(
C, handlers, &handler->head, event, kmi->ptr, kmi->idname);
if (action & WM_HANDLER_BREAK) {
/* not always_pass here, it denotes removed handler_base */
/* Not always_pass here, it denotes removed handler_base. */
CLOG_INFO(WM_LOG_HANDLERS, 2, "handled! '%s'", kmi->idname);
if (keymap_post.post_fn != NULL) {
keymap_post.post_fn(keymap, kmi, keymap_post.user_data);
@@ -2496,7 +2495,7 @@ static int wm_handlers_do_keymap_with_gizmo_handler(
CTX_wm_gizmo_group_set(C, gzgroup);
/* handler->op is called later, we want keymap op to be triggered here */
/* handler->op is called later, we want keymap op to be triggered here. */
action |= wm_handler_operator_call(
C, handlers, &handler->head, event, kmi->ptr, kmi->idname);
@@ -2546,7 +2545,7 @@ static int wm_handlers_do_gizmo_handler(bContext *C,
/* Needed so UI blocks over gizmos don't let events fall through to the gizmos,
* noticeable for the node editor - where dragging on a node should move it, see: T73212.
* note we still allow for starting the gizmo drag outside, then travel 'inside' the node */
* note we still allow for starting the gizmo drag outside, then travel 'inside' the node. */
if (region->type->clip_gizmo_events_by_ui) {
if (UI_region_block_find_mouse_over(region, &event->x, true)) {
if (gz != NULL && event->type != EVT_GIZMO_UPDATE) {
@@ -2572,7 +2571,7 @@ static int wm_handlers_do_gizmo_handler(bContext *C,
bool handle_highlight = false;
bool handle_keymap = false;
/* handle gizmo highlighting */
/* Handle gizmo highlighting. */
if (!wm_gizmomap_modal_get(gzmap) &&
((event->type == MOUSEMOVE) || is_event_modifier || is_event_drag)) {
handle_highlight = true;
@@ -2699,7 +2698,7 @@ static int wm_handlers_do_intern(bContext *C, wmEvent *event, ListBase *handlers
{
const bool do_debug_handler =
(G.debug & G_DEBUG_HANDLERS) &&
/* comment this out to flood the console! (if you really want to test) */
/* Comment this out to flood the console! (if you really want to test). */
!ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE);
wmWindowManager *wm = CTX_wm_manager(C);
@@ -2710,9 +2709,9 @@ static int wm_handlers_do_intern(bContext *C, wmEvent *event, ListBase *handlers
return action;
}
/* modal handlers can get removed in this loop, we keep the loop this way
/* Modal handlers can get removed in this loop, we keep the loop this way.
*
* note: check 'handlers->first' because in rare cases the handlers can be cleared
* Note: check 'handlers->first' because in rare cases the handlers can be cleared
* by the event that's called, for eg:
*
* Calling a python script which changes the area.type, see T32232. */
@@ -2723,13 +2722,13 @@ static int wm_handlers_do_intern(bContext *C, wmEvent *event, ListBase *handlers
/* During this loop, UI handlers for nested menus can tag multiple handlers free. */
if (handler_base->flag & WM_HANDLER_DO_FREE) {
/* pass */
/* Pass. */
}
else if (handler_base->poll == NULL || handler_base->poll(CTX_wm_region(C), event)) {
/* in advance to avoid access to freed event on window close */
/* In advance to avoid access to freed event on window close. */
always_pass = wm_event_always_pass(event);
/* modal+blocking handler_base */
/* Modal+blocking handler_base. */
if (handler_base->flag & WM_HANDLER_BLOCKING) {
action |= WM_HANDLER_BREAK;
}
@@ -2762,7 +2761,7 @@ static int wm_handlers_do_intern(bContext *C, wmEvent *event, ListBase *handlers
if (!wm->is_interface_locked && event->type == EVT_DROP) {
wmDropBox *drop = handler->dropboxes->first;
for (; drop; drop = drop->next) {
/* other drop custom types allowed */
/* Other drop custom types allowed. */
if (event->custom == EVT_DATA_DRAGDROP) {
ListBase *lb = (ListBase *)event->customdata;
wmDrag *drag;
@@ -2784,19 +2783,19 @@ static int wm_handlers_do_intern(bContext *C, wmEvent *event, ListBase *handlers
C, drop->ot, drop->ptr, NULL, drop->opcontext, false, event);
action |= WM_HANDLER_BREAK;
/* free the drags */
/* Free the drags. */
WM_drag_free_list(lb);
WM_drag_free_list(&single_lb);
event->customdata = NULL;
event->custom = 0;
/* XXX fileread case */
/* XXX fileread case. */
if (CTX_wm_window(C) == NULL) {
return action;
}
/* escape from drag loop, got freed */
/* Escape from drag loop, got freed. */
break;
}
}
@@ -2812,7 +2811,7 @@ static int wm_handlers_do_intern(bContext *C, wmEvent *event, ListBase *handlers
wmEventHandler_Op *handler = (wmEventHandler_Op *)handler_base;
if (handler->is_fileselect) {
if (!wm->is_interface_locked) {
/* screen context changes here */
/* Screen context changes here. */
action |= wm_handler_fileselect_call(C, handlers, handler, event);
}
}
@@ -2841,11 +2840,11 @@ static int wm_handlers_do_intern(bContext *C, wmEvent *event, ListBase *handlers
return action;
}
/* XXX code this for all modal ops, and ensure free only happens here */
/* XXX code this for all modal ops, and ensure free only happens here. */
/* Modal UI handler can be tagged to be freed. */
if (BLI_findindex(handlers, handler_base) !=
-1) { /* could be freed already by regular modal ops */
-1) { /* Could be freed already by regular modal ops. */
if (handler_base->flag & WM_HANDLER_DO_FREE) {
BLI_remlink(handlers, handler_base);
wm_event_free_handler(handler_base);
@@ -2862,12 +2861,12 @@ static int wm_handlers_do_intern(bContext *C, wmEvent *event, ListBase *handlers
#undef PRINT
/* this calls handlers twice - to solve (double-)click events */
/* Yhis calls handlers twice - to solve (double-)click events. */
static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
{
int action = wm_handlers_do_intern(C, event, handlers);
/* fileread case */
/* Fileread case. */
if (CTX_wm_window(C) == NULL) {
return action;
}
@@ -3066,8 +3065,8 @@ static void wm_paintcursor_tag(bContext *C, wmPaintCursor *pc, ARegion *region)
}
}
/* called on mousemove, check updates for paintcursors */
/* context was set on active area and region */
/* Called on mousemove, check updates for paintcursors. */
/* Context was set on active area and region. */
static void wm_paintcursor_test(bContext *C, const wmEvent *event)
{
wmWindowManager *wm = CTX_wm_manager(C);
@@ -3079,7 +3078,7 @@ static void wm_paintcursor_test(bContext *C, const wmEvent *event)
wm_paintcursor_tag(C, wm->paintcursors.first, region);
}
/* if previous position was not in current region, we have to set a temp new context */
/* If previous position was not in current region, we have to set a temp new context. */
if (region == NULL || !BLI_rcti_isect_pt_v(&region->winrct, &event->prevx)) {
ScrArea *area = CTX_wm_area(C);
@@ -3113,7 +3112,7 @@ static void wm_event_drag_and_drop_test(wmWindowManager *wm, wmWindow *win, wmEv
else if (event->type == LEFTMOUSE && event->val == KM_RELEASE) {
event->type = EVT_DROP;
/* create customdata, first free existing */
/* Vreate customdata, first free existing. */
if (event->customdata) {
if (event->customdatafree) {
MEM_freeN(event->customdata);
@@ -3124,7 +3123,7 @@ static void wm_event_drag_and_drop_test(wmWindowManager *wm, wmWindow *win, wmEv
event->customdata = &wm->drags;
event->customdatafree = 1;
/* clear drop icon */
/* Vlear drop icon. */
screen->do_draw_drag = true;
/* restore cursor (disabled, see wm_dragdrop.c) */
@@ -3132,7 +3131,7 @@ static void wm_event_drag_and_drop_test(wmWindowManager *wm, wmWindow *win, wmEv
}
}
/* filter out all events of the pie that spawned the last pie unless it's a release event */
/* Filter out all events of the pie that spawned the last pie unless it's a release event. */
static bool wm_event_pie_filter(wmWindow *win, const wmEvent *event)
{
if (win->lock_pie_event && win->lock_pie_event == event->type) {
@@ -3172,14 +3171,14 @@ static void wm_event_free_and_remove_from_queue_if_valid(wmEvent *event)
* Handle events for all windows, run from the #WM_main event loop.
* \{ */
/* called in main loop */
/* goes over entire hierarchy: events -> window -> screen -> area -> region */
/* Called in main loop. */
/* Goes over entire hierarchy: events -> window -> screen -> area -> region. */
void wm_event_do_handlers(bContext *C)
{
wmWindowManager *wm = CTX_wm_manager(C);
wmWindow *win;
/* update key configuration before handling events */
/* Update key configuration before handling events. */
WM_keyconfig_update(wm);
WM_gizmoconfig_update(CTX_data_main(C));
@@ -3187,7 +3186,7 @@ void wm_event_do_handlers(bContext *C)
bScreen *screen = WM_window_get_active_screen(win);
wmEvent *event;
/* some safety checks - these should always be set! */
/* Some safety checks - these should always be set! */
BLI_assert(WM_window_get_active_scene(win));
BLI_assert(WM_window_get_active_screen(win));
BLI_assert(WM_window_get_active_workspace(win));
@@ -3248,7 +3247,7 @@ void wm_event_do_handlers(bContext *C)
while ((event = win->queue.first)) {
int action = WM_HANDLER_CONTINUE;
/* active screen might change during handlers, update pointer */
/* Active screen might change during handlers, update pointer. */
screen = WM_window_get_active_screen(win);
if (G.debug & (G_DEBUG_HANDLERS | G_DEBUG_EVENTS) &&
@@ -3257,7 +3256,7 @@ void wm_event_do_handlers(bContext *C)
WM_event_print(event);
}
/* take care of pie event filter */
/* Take care of pie event filter. */
if (wm_event_pie_filter(win, event)) {
if (!ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE)) {
CLOG_INFO(WM_LOG_HANDLERS, 1, "event filtered due to pie button pressed");
@@ -3278,7 +3277,7 @@ void wm_event_do_handlers(bContext *C)
}
}
/* we let modal handlers get active area/region, also wm_paintcursor_test needs it */
/* We let modal handlers get active area/region, also wm_paintcursor_test needs it. */
CTX_wm_area_set(C, area_event_inside(C, &event->x));
CTX_wm_region_set(C, region_event_inside(C, &event->x));
@@ -3288,16 +3287,16 @@ void wm_event_do_handlers(bContext *C)
wm_region_mouse_co(C, event);
/* first we do priority handlers, modal + some limited keymaps */
/* First we do priority handlers, modal + some limited keymaps. */
action |= wm_handlers_do(C, event, &win->modalhandlers);
/* fileread case */
/* Fileread case. */
if (CTX_wm_window(C) == NULL) {
wm_event_free_and_remove_from_queue_if_valid(event);
return;
}
/* check for a tooltip */
/* Check for a tooltip. */
if (screen == WM_window_get_active_screen(win)) {
if (screen->tool_tip && screen->tool_tip->timer) {
if ((event->type == TIMER) && (event->customdata == screen->tool_tip->timer)) {
@@ -3306,10 +3305,10 @@ void wm_event_do_handlers(bContext *C)
}
}
/* check dragging, creates new event or frees, adds draw tag */
/* Check dragging, creates new event or frees, adds draw tag. */
wm_event_drag_and_drop_test(wm, win, event);
/* builtin tweak, if action is break it removes tweak */
/* Builtin tweak, if action is break it removes tweak. */
wm_tweakevent_test(C, event, action);
if ((action & WM_HANDLER_BREAK) == 0) {
@@ -3320,7 +3319,7 @@ void wm_event_do_handlers(bContext *C)
/* State variables in screen, cursors.
* Also used in wm_draw.c, fails for modal handlers though. */
ED_screen_set_active_region(C, win, &event->x);
/* for regions having custom cursors */
/* For regions having custom cursors. */
wm_paintcursor_test(C, event);
}
#ifdef WITH_INPUT_NDOF
@@ -3330,15 +3329,16 @@ void wm_event_do_handlers(bContext *C)
#endif
ED_screen_areas_iter (win, screen, area) {
/* after restoring a screen from SCREENMAXIMIZED we have to wait
* with the screen handling till the region coordinates are updated */
/* After restoring a screen from SCREENMAXIMIZED we have to wait
* with the screen handling till the region coordinates are updated. */
if (screen->skip_handling == true) {
/* restore for the next iteration of wm_event_do_handlers */
/* Restore for the next iteration of wm_event_do_handlers. */
screen->skip_handling = false;
break;
}
/* update azones if needed - done here because it needs to be independent from redraws */
/* Update azones if needed - done here because it needs to be independent from redraws.
*/
if (area->flag & AREA_FLAG_ACTIONZONES_UPDATE) {
ED_area_azones_update(area, &event->x);
}
@@ -3352,12 +3352,12 @@ void wm_event_do_handlers(bContext *C)
CTX_wm_region_set(C, region);
/* call even on non mouse events, since the */
/* Call even on non mouse events, since the */
wm_region_mouse_co(C, event);
if (!BLI_listbase_is_empty(&wm->drags)) {
/* does polls for drop regions and checks uibuts */
/* need to be here to make sure region context is true */
/* Does polls for drop regions and checks #uiButs. */
/* Need to be here to make sure region context is true. */
if (ELEM(event->type, MOUSEMOVE, EVT_DROP) || ISKEYMODIFIER(event->type)) {
wm_drags_check_ops(C, event);
}
@@ -3365,7 +3365,7 @@ void wm_event_do_handlers(bContext *C)
action |= wm_handlers_do(C, event, &region->handlers);
/* fileread case (python), T29489. */
/* Fileread case (python), T29489. */
if (CTX_wm_window(C) == NULL) {
wm_event_free_and_remove_from_queue_if_valid(event);
return;
@@ -3381,7 +3381,7 @@ void wm_event_do_handlers(bContext *C)
CTX_wm_region_set(C, NULL);
if ((action & WM_HANDLER_BREAK) == 0) {
wm_region_mouse_co(C, event); /* only invalidates event->mval in this case */
wm_region_mouse_co(C, event); /* Only invalidates event->mval in this case. */
action |= wm_handlers_do(C, event, &area->handlers);
}
CTX_wm_area_set(C, NULL);
@@ -3392,7 +3392,7 @@ void wm_event_do_handlers(bContext *C)
}
if ((action & WM_HANDLER_BREAK) == 0) {
/* also some non-modal handlers need active area/region */
/* Also some non-modal handlers need active area/region. */
CTX_wm_area_set(C, area_event_inside(C, &event->x));
CTX_wm_region_set(C, region_event_inside(C, &event->x));
@@ -3400,7 +3400,7 @@ void wm_event_do_handlers(bContext *C)
action |= wm_handlers_do(C, event, &win->handlers);
/* fileread case */
/* Fileread case. */
if (CTX_wm_window(C) == NULL) {
wm_event_free_and_remove_from_queue_if_valid(event);
return;
@@ -3415,16 +3415,16 @@ void wm_event_do_handlers(bContext *C)
win->eventstate->check_click = false;
}
/* update previous mouse position for following events to use */
/* Update previous mouse position for following events to use. */
win->eventstate->prevx = event->x;
win->eventstate->prevy = event->y;
/* unlink and free here, blender-quit then frees all */
/* Unlink and free here, blender-quit then frees all. */
BLI_remlink(&win->queue, event);
wm_event_free(event);
}
/* only add mousemove when queue was read entirely */
/* Only add mousemove when queue was read entirely. */
if (win->addmousemove && win->eventstate) {
wmEvent tevent = *(win->eventstate);
// printf("adding MOUSEMOVE %d %d\n", tevent.x, tevent.y);
@@ -3438,7 +3438,7 @@ void wm_event_do_handlers(bContext *C)
CTX_wm_window_set(C, NULL);
}
/* update key configuration after handling events */
/* Update key configuration after handling events. */
WM_keyconfig_update(wm);
WM_gizmoconfig_update(CTX_data_main(C));
}
@@ -3451,7 +3451,7 @@ void wm_event_do_handlers(bContext *C)
void WM_event_fileselect_event(wmWindowManager *wm, void *ophandle, int eventval)
{
/* add to all windows! */
/* Add to all windows! */
wmWindow *win;
for (win = wm->windows.first; win; win = win->next) {
@@ -3465,14 +3465,14 @@ void WM_event_fileselect_event(wmWindowManager *wm, void *ophandle, int eventval
}
}
/* operator is supposed to have a filled "path" property */
/* optional property: filetype (XXX enum?) */
/* Operator is supposed to have a filled "path" property. */
/* Optional property: filetype (XXX enum?) */
/**
* The idea here is to keep a handler alive on window queue, owning the operator.
* The file window can send event to make it execute, thus ensuring
* executing happens outside of lower level queues, with UI refreshed.
* Should also allow multiwin solutions
* Should also allow multiwin solutions.
*/
void WM_event_add_fileselect(bContext *C, wmOperator *op)
{
@@ -3484,7 +3484,7 @@ void WM_event_add_fileselect(bContext *C, wmOperator *op)
UI_popup_handlers_remove_all(C, &win->modalhandlers);
if (!is_temp_screen) {
/* only allow 1 file selector open per window */
/* Only allow 1 file selector open per window. */
LISTBASE_FOREACH_MUTABLE (wmEventHandler *, handler_base, &win->modalhandlers) {
if (handler_base->type == WM_HANDLER_TYPE_OP) {
wmEventHandler_Op *handler = (wmEventHandler_Op *)handler_base;
@@ -3494,7 +3494,7 @@ void WM_event_add_fileselect(bContext *C, wmOperator *op)
bScreen *screen = CTX_wm_screen(C);
bool cancel_handler = true;
/* find the area with the file selector for this handler */
/* Find the area with the file selector for this handler. */
ED_screen_areas_iter (win, screen, area) {
if (area->spacetype == SPACE_FILE) {
SpaceFile *sfile = area->spacedata.first;
@@ -3508,7 +3508,7 @@ void WM_event_add_fileselect(bContext *C, wmOperator *op)
}
}
/* if not found we stop the handler without changing the screen */
/* If not found we stop the handler without changing the screen. */
if (cancel_handler) {
wm_handler_fileselect_do(
C, &win->modalhandlers, handler, EVT_FILESELECT_EXTERNAL_CANCEL);
@@ -3528,10 +3528,10 @@ void WM_event_add_fileselect(bContext *C, wmOperator *op)
BLI_addhead(&win->modalhandlers, handler);
/* check props once before invoking if check is available
* ensures initial properties are valid */
/* Check props once before invoking if check is available
* ensures initial properties are valid. */
if (op->type->check) {
op->type->check(C, op); /* ignore return value */
op->type->check(C, op); /* Ignore return value. */
}
WM_event_fileselect_event(wm, op, EVT_FILESELECT_FULL_OPEN);
@@ -3557,18 +3557,18 @@ wmEventHandler_Op *WM_event_add_modal_handler(bContext *C, wmOperator *op)
handler->head.type = WM_HANDLER_TYPE_OP;
wmWindow *win = CTX_wm_window(C);
/* operator was part of macro */
/* Operator was part of macro. */
if (op->opm) {
/* give the mother macro to the handler */
/* Give the mother macro to the handler. */
handler->op = op->opm;
/* mother macro opm becomes the macro element */
/* Mother macro opm becomes the macro element. */
handler->op->opm = op;
}
else {
handler->op = op;
}
handler->context.area = CTX_wm_area(C); /* means frozen screen context for modal handlers! */
handler->context.area = CTX_wm_area(C); /* Means frozen screen context for modal handlers! */
handler->context.region = CTX_wm_region(C);
handler->context.region_type = handler->context.region ? handler->context.region->regiontype :
-1;
@@ -3628,7 +3628,7 @@ wmEventHandler_Keymap *WM_event_add_keymap_handler(ListBase *handlers, wmKeyMap
return NULL;
}
/* only allow same keymap once */
/* Only allow same keymap once. */
LISTBASE_FOREACH (wmEventHandler *, handler_base, handlers) {
if (handler_base->type == WM_HANDLER_TYPE_KEYMAP) {
wmEventHandler_Keymap *handler = (wmEventHandler_Keymap *)handler_base;
@@ -3738,7 +3738,7 @@ struct wmEventHandler_Keymap *WM_event_add_keymap_handler_dynamic(
return NULL;
}
/* only allow same keymap once */
/* Only allow same keymap once. */
LISTBASE_FOREACH (wmEventHandler *, handler_base, handlers) {
if (handler_base->type == WM_HANDLER_TYPE_KEYMAP) {
wmEventHandler_Keymap *handler = (wmEventHandler_Keymap *)handler_base;
@@ -3759,7 +3759,7 @@ struct wmEventHandler_Keymap *WM_event_add_keymap_handler_dynamic(
return handler;
}
/* priorities not implemented yet, for time being just insert in begin of list */
/* Priorities not implemented yet, for time being just insert in begin of list. */
wmEventHandler_Keymap *WM_event_add_keymap_handler_priority(ListBase *handlers,
wmKeyMap *keymap,
int UNUSED(priority))
@@ -3866,7 +3866,7 @@ wmEventHandler_UI *WM_event_add_ui_handler(const bContext *C,
return handler;
}
/* set "postpone" for win->modalhandlers, this is in a running for () loop in wm_handlers_do() */
/* Set "postpone" for win->modalhandlers, this is in a running for () loop in wm_handlers_do(). */
void WM_event_remove_ui_handler(ListBase *handlers,
wmUIHandlerFunc handle_fn,
wmUIHandlerRemoveFunc remove_fn,
@@ -3878,7 +3878,7 @@ void WM_event_remove_ui_handler(ListBase *handlers,
wmEventHandler_UI *handler = (wmEventHandler_UI *)handler_base;
if ((handler->handle_fn == handle_fn) && (handler->remove_fn == remove_fn) &&
(handler->user_data == user_data)) {
/* handlers will be freed in wm_handlers_do() */
/* Handlers will be freed in wm_handlers_do(). */
if (postpone) {
handler->head.flag |= WM_HANDLER_DO_FREE;
}
@@ -3911,7 +3911,7 @@ void WM_event_free_ui_handler_all(bContext *C,
wmEventHandler_Dropbox *WM_event_add_dropbox_handler(ListBase *handlers, ListBase *dropboxes)
{
/* only allow same dropbox once */
/* Only allow same dropbox once. */
LISTBASE_FOREACH (wmEventHandler *, handler_base, handlers) {
if (handler_base->type == WM_HANDLER_TYPE_DROPBOX) {
wmEventHandler_Dropbox *handler = (wmEventHandler_Dropbox *)handler_base;
@@ -3924,7 +3924,7 @@ wmEventHandler_Dropbox *WM_event_add_dropbox_handler(ListBase *handlers, ListBas
wmEventHandler_Dropbox *handler = MEM_callocN(sizeof(*handler), __func__);
handler->head.type = WM_HANDLER_TYPE_DROPBOX;
/* dropbox stored static, no free or copy */
/* Dropbox stored static, no free or copy. */
handler->dropboxes = dropboxes;
BLI_addhead(handlers, handler);
@@ -4135,7 +4135,7 @@ static void wm_eventemulation(wmEvent *event, bool test_only)
}
}
else if (event->val == KM_RELEASE) {
/* only send middle-mouse release if emulated */
/* Only send middle-mouse release if emulated. */
if (emulating_event == MIDDLEMOUSE) {
event->type = MIDDLEMOUSE;
*mod = 0;
@@ -4148,7 +4148,7 @@ static void wm_eventemulation(wmEvent *event, bool test_only)
}
}
/* numpad emulation */
/* Numpad emulation. */
if (U.flag & USER_NONUMPAD) {
switch (event->type) {
case EVT_ZEROKEY:
@@ -4225,7 +4225,7 @@ void wm_tablet_data_from_ghost(const GHOST_TabletData *tablet_data, wmTabletData
}
#ifdef WITH_INPUT_NDOF
/* adds customdata to event */
/* Adds customdata to event. */
static void attach_ndof_data(wmEvent *event, const GHOST_TEventNDOFMotionData *ghost)
{
wmNDOFMotionData *data = MEM_mallocN(sizeof(wmNDOFMotionData), "customdata NDOF");
@@ -4253,7 +4253,7 @@ static void attach_ndof_data(wmEvent *event, const GHOST_TEventNDOFMotionData *g
}
#endif /* WITH_INPUT_NDOF */
/* imperfect but probably usable... draw/enable drags to other windows */
/* Imperfect but probably usable... draw/enable drags to other windows. */
static wmWindow *wm_event_cursor_other_windows(wmWindowManager *wm, wmWindow *win, wmEvent *event)
{
int mval[2] = {event->x, event->y};
@@ -4262,7 +4262,7 @@ static wmWindow *wm_event_cursor_other_windows(wmWindowManager *wm, wmWindow *wi
return NULL;
}
/* in order to use window size and mouse position (pixels), we have to use a WM function */
/* In order to use window size and mouse position (pixels), we have to use a WM function. */
/* check if outside, include top window bar... */
if (mval[0] < 0 || mval[1] < 0 || mval[0] > WM_window_pixels_x(win) ||
@@ -4293,7 +4293,7 @@ static bool wm_event_is_double_click(const wmEvent *event, const wmEvent *event_
if ((event->type == event_state->prevtype) && (event_state->prevval == KM_RELEASE) &&
(event->val == KM_PRESS)) {
if (ISMOUSE(event->type) && WM_event_drag_test(event, &event_state->prevclickx)) {
/* pass */
/* Pass. */
}
else {
if ((PIL_check_seconds_timer() - event_state->prevclicktime) * 1000 < U.dbl_click_time) {
@@ -4309,9 +4309,9 @@ static wmEvent *wm_event_add_mousemove(wmWindow *win, const wmEvent *event)
{
wmEvent *event_last = win->queue.last;
/* some painting operators want accurate mouse events, they can
/* Some painting operators want accurate mouse events, they can
* handle in between mouse move moves, others can happily ignore
* them for better performance */
* them for better performance. */
if (event_last && event_last->type == MOUSEMOVE) {
event_last->type = INBETWEEN_MOUSEMOVE;
}
@@ -4325,8 +4325,8 @@ static wmEvent *wm_event_add_mousemove(wmWindow *win, const wmEvent *event)
return event_new;
}
/* windows store own event queues, no bContext here */
/* time is in 1000s of seconds, from ghost */
/* Windows store own event queues, no bContext here. */
/* Time is in 1000s of seconds, from Ghost. */
void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void *customdata)
{
wmWindow *owin;
@@ -4347,12 +4347,12 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
*/
wmEvent event, *evt = win->eventstate;
/* initialize and copy state (only mouse x y and modifiers) */
/* Initialize and copy state (only mouse x y and modifiers). */
event = *evt;
event.is_repeat = false;
switch (type) {
/* mouse move, also to inactive window (X11 does this) */
/* Mouse move, also to inactive window (X11 does this). */
case GHOST_kEventCursorMove: {
GHOST_TEventCursorData *cd = customdata;
@@ -4369,8 +4369,8 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
evt->tablet.is_motion_absolute = event_new->tablet.is_motion_absolute;
}
/* also add to other window if event is there, this makes overdraws disappear nicely */
/* it remaps mousecoord to other window in event */
/* Also add to other window if event is there, this makes overdraws disappear nicely. */
/* It remaps mousecoord to other window in event. */
owin = wm_event_cursor_other_windows(wm, win, &event);
if (owin) {
wmEvent oevent, *oevt = owin->eventstate;
@@ -4414,19 +4414,19 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
event.y = evt->y = pd->y;
event.val = KM_NOTHING;
/* Use prevx/prevy so we can calculate the delta later */
/* Use prevx/prevy so we can calculate the delta later. */
event.prevx = event.x - pd->deltaX;
event.prevy = event.y - (-pd->deltaY);
wm_event_add(win, &event);
break;
}
/* mouse button */
/* ,ouse button, */
case GHOST_kEventButtonDown:
case GHOST_kEventButtonUp: {
GHOST_TEventButtonData *bd = customdata;
/* get value and type from ghost */
/* Get value and type from Ghost. */
event.val = (type == GHOST_kEventButtonDown) ? KM_PRESS : KM_RELEASE;
if (bd->button == GHOST_kButtonMaskLeft) {
@@ -4456,15 +4456,15 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
wm_eventemulation(&event, false);
/* copy previous state to prev event state (two old!) */
/* Copy previous state to prev event state (two old!). */
evt->prevval = evt->val;
evt->prevtype = evt->type;
/* copy to event state */
/* Copy to event state. */
evt->val = event.val;
evt->type = event.type;
/* double click test */
/* Double click test. */
if (wm_event_is_double_click(&event, evt)) {
CLOG_INFO(WM_LOG_HANDLERS, 1, "Send double click");
event.val = KM_DBL_CLICK;
@@ -4475,7 +4475,7 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
evt->prevclicky = event.y;
}
/* add to other window if event is there (not to both!) */
/* Add to other window if event is there (not to both!). */
owin = wm_event_cursor_other_windows(wm, win, &event);
if (owin) {
wmEvent oevent = *(owin->eventstate);
@@ -4494,34 +4494,34 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
break;
}
/* keyboard */
/* Keyboard. */
case GHOST_kEventKeyDown:
case GHOST_kEventKeyUp: {
GHOST_TEventKeyData *kd = customdata;
short keymodifier = KM_NOTHING;
event.type = convert_key(kd->key);
event.ascii = kd->ascii;
memcpy(
event.utf8_buf, kd->utf8_buf, sizeof(event.utf8_buf)); /* might be not null terminated*/
/* Might be not NULL terminated. */
memcpy(event.utf8_buf, kd->utf8_buf, sizeof(event.utf8_buf));
event.is_repeat = kd->is_repeat;
event.val = (type == GHOST_kEventKeyDown) ? KM_PRESS : KM_RELEASE;
wm_eventemulation(&event, false);
/* copy previous state to prev event state (two old!) */
/* Copy previous state to prev event state (two old!). */
evt->prevval = evt->val;
evt->prevtype = evt->type;
/* copy to event state */
/* Copy to event state. */
evt->val = event.val;
evt->type = event.type;
evt->is_repeat = event.is_repeat;
/* exclude arrow keys, esc, etc from text input */
/* Exclude arrow keys, esc, etc from text input. */
if (type == GHOST_kEventKeyUp) {
event.ascii = '\0';
/* ghost should do this already for key up */
/* Ghost should do this already for key up. */
if (event.utf8_buf[0]) {
CLOG_ERROR(WM_LOG_EVENTS,
"ghost on your platform is misbehaving, utf8 events on key up!");
@@ -4546,7 +4546,7 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
}
}
/* assigning both first and second is strange - campbell */
/* Assigning both first and second is strange. - campbell */
switch (event.type) {
case EVT_LEFTSHIFTKEY:
case EVT_RIGHTSHIFTKEY:
@@ -4606,20 +4606,20 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
break;
}
/* double click test */
/* if previous event was same type, and previous was release, and now it presses... */
/* Double click test. */
/* If previous event was same type, and previous was release, and now it presses... */
if (wm_event_is_double_click(&event, evt)) {
CLOG_INFO(WM_LOG_HANDLERS, 1, "Send double click");
event.val = KM_DBL_CLICK;
}
/* this case happens on holding a key pressed, it should not generate
* press events events with the same key as modifier */
/* This case happens on holding a key pressed, it should not generate
* press events events with the same key as modifier. */
if (event.keymodifier == event.type) {
event.keymodifier = 0;
}
/* this case happens with an external numpad, and also when using 'dead keys'
/* This case happens with an external numpad, and also when using 'dead keys'
* (to compose complex latin characters e.g.), it's not really clear why.
* Since it's impossible to map a key modifier to an unknown key,
* it shouldn't harm to clear it. */
@@ -4627,15 +4627,15 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, void
evt->keymodifier = event.keymodifier = 0;
}
/* if test_break set, it catches this. Do not set with modifier presses.
/* If test_break set, it catches this. Do not set with modifier presses.
* XXX Keep global for now? */
if ((event.type == EVT_ESCKEY && event.val == KM_PRESS) &&
/* check other modifiers because ms-windows uses these to bring up the task manager */
/* Check other modifiers because ms-windows uses these to bring up the task manager. */
(event.shift == 0 && event.ctrl == 0 && event.alt == 0)) {
G.is_break = true;
}
/* double click test - only for press */
/* Double click test - only for press. */
if (event.val == KM_PRESS) {
/* Don't reset timer & location when holding the key generates repeat events. */
if ((evt->prevtype != event.type) || (evt->prevval != KM_PRESS)) {
@@ -4838,7 +4838,7 @@ wmKeyMapItem *WM_event_match_keymap_item_from_handlers(bContext *C,
LISTBASE_FOREACH (wmEventHandler *, handler_base, handlers) {
/* During this loop, UI handlers for nested menus can tag multiple handlers free. */
if (handler_base->flag & WM_HANDLER_DO_FREE) {
/* pass */
/* Pass. */
}
else if (handler_base->poll == NULL || handler_base->poll(CTX_wm_region(C), event)) {
if (handler_base->type == WM_HANDLER_TYPE_KEYMAP) {
@@ -5133,7 +5133,7 @@ bool WM_window_modal_keymap_status_draw(bContext *C, wmWindow *win, uiLayout *la
bool show_text = true;
{
/* warning: O(n^2) */
/* Warning: O(n^2). */
wmKeyMapItem *kmi = NULL;
for (kmi = keymap->items.first; kmi; kmi = kmi->next) {
if (kmi->propvalue == items[i].value) {

12
source/creator/creator.c
View File

@@ -47,7 +47,7 @@
#include "BLI_threads.h"
#include "BLI_utildefines.h"
/* mostly init functions */
/* Mostly init functions. */
#include "BKE_appdir.h"
#include "BKE_blender.h"
#include "BKE_brush.h"
@@ -69,7 +69,7 @@
#include "DEG_depsgraph.h"
#include "IMB_imbuf.h" /* for IMB_init */
#include "IMB_imbuf.h" /* For #IMB_init. */
#include "RE_engine.h"
#include "RE_render_ext.h"
@@ -107,7 +107,7 @@
# include "sdlew.h"
#endif
#include "creator_intern.h" /* own include */
#include "creator_intern.h" /* Own include. */
/* Local Function prototypes. */
@@ -244,7 +244,7 @@ int main(int argc,
/* --- end declarations --- */
/* ensure we free data on early-exit */
/* Ensure we free data on early-exit. */
struct CreatorAtExitData app_init_data = {NULL};
BKE_blender_atexit_register(callback_main_atexit, &app_init_data);
@@ -320,7 +320,7 @@ int main(int argc,
sdlewInit();
#endif
/* Initialize logging */
/* Initialize logging. */
CLG_init();
CLG_fatal_fn_set(callback_clg_fatal);
@@ -366,7 +366,7 @@ int main(int argc,
fpsetmask(0);
#endif
/* initialize path to executable */
/* Initialize path to executable. */
BKE_appdir_program_path_init(argv[0]);
BLI_threadapi_init();