Merging trunk up to r39145.
[blender.git] / source / blender / windowmanager / intern / wm_event_system.c
index bce1cc22f7fb9d747e4ab9e19bde7a77668aee8e..258d6bbc025fe95198069f6769a5d0999021de8a 100644 (file)
@@ -1,4 +1,4 @@
-/**
+/*
  * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
  * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file blender/windowmanager/intern/wm_event_system.c
+ *  \ingroup wm
+ */
+
+
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
@@ -41,6 +46,7 @@
 #include "GHOST_C-api.h"
 
 #include "BLI_blenlib.h"
+#include "BLI_utildefines.h"
 
 #include "BKE_blender.h"
 #include "BKE_context.h"
 #include "BKE_report.h"
 #include "BKE_scene.h"
 #include "BKE_screen.h"
-#include "BKE_utildefines.h"
+
 #include "BKE_sound.h"
 
 #include "ED_fileselect.h"
 #include "ED_info.h"
 #include "ED_screen.h"
+#include "ED_view3d.h"
 #include "ED_util.h"
 
 #include "RNA_access.h"
@@ -72,6 +79,8 @@
 #include "wm_event_types.h"
 #include "wm_draw.h"
 
+static int wm_operator_call_internal(bContext *C, wmOperatorType *ot, PointerRNA *properties, ReportList *reports, short context, short poll_only);
+
 /* ************ event management ************** */
 
 void wm_event_add(wmWindow *win, wmEvent *event_to_add)
@@ -99,7 +108,7 @@ void wm_event_free(wmEvent *event)
 void wm_event_free_all(wmWindow *win)
 {
        wmEvent *event;
-
+       
        while((event= win->queue.first)) {
                BLI_remlink(&win->queue, event);
                wm_event_free(event);
@@ -115,7 +124,7 @@ static int wm_test_duplicate_notifier(wmWindowManager *wm, unsigned int type, vo
        for(note=wm->queue.first; note; note=note->next)
                if((note->category|note->data|note->subtype|note->action) == type && note->reference == reference)
                        return 1;
-
+       
        return 0;
 }
 
@@ -123,20 +132,20 @@ static int wm_test_duplicate_notifier(wmWindowManager *wm, unsigned int type, vo
 void WM_event_add_notifier(const bContext *C, unsigned int type, void *reference)
 {
        wmNotifier *note= MEM_callocN(sizeof(wmNotifier), "notifier");
-
+       
        note->wm= CTX_wm_manager(C);
        BLI_addtail(&note->wm->queue, note);
-
+       
        note->window= CTX_wm_window(C);
-
+       
        if(CTX_wm_region(C))
                note->swinid= CTX_wm_region(C)->swinid;
-
+       
        note->category= type & NOTE_CATEGORY;
        note->data= type & NOTE_DATA;
        note->subtype= type & NOTE_SUBTYPE;
        note->action= type & NOTE_ACTION;
-
+       
        note->reference= reference;
 }
 
@@ -147,15 +156,15 @@ void WM_main_add_notifier(unsigned int type, void *reference)
 
        if(wm && !wm_test_duplicate_notifier(wm, type, reference)) {
                wmNotifier *note= MEM_callocN(sizeof(wmNotifier), "notifier");
-
+               
                note->wm= wm;
                BLI_addtail(&note->wm->queue, note);
-
+               
                note->category= type & NOTE_CATEGORY;
                note->data= type & NOTE_DATA;
                note->subtype= type & NOTE_SUBTYPE;
                note->action= type & NOTE_ACTION;
-
+               
                note->reference= reference;
        }
 }
@@ -174,16 +183,17 @@ void wm_event_do_notifiers(bContext *C)
        wmWindowManager *wm= CTX_wm_manager(C);
        wmNotifier *note, *next;
        wmWindow *win;
+       unsigned int win_combine_v3d_datamask= 0;
        
        if(wm==NULL)
                return;
-
+       
        /* cache & catch WM level notifiers, such as frame change, scene/screen set */
        for(win= wm->windows.first; win; win= win->next) {
                int do_anim= 0;
-
+               
                CTX_wm_window_set(C, win);
-
+               
                for(note= wm->queue.first; note; note= next) {
                        next= note->next;
 
@@ -219,12 +229,13 @@ void wm_event_do_notifiers(bContext *C)
                                        }
                                        else if(note->data==ND_FRAME)
                                                do_anim= 1;
-
+                                       
                                        if(note->action == NA_REMOVED) {
                                                ED_screen_delete_scene(C, note->reference);     // XXX hrms, think this over!
                                                if(G.f & G_DEBUG)
                                                        printf("scene delete %p\n", note->reference);
                                        }
+                                               
                                }
                        }
                        if(ELEM5(note->category, NC_SCENE, NC_OBJECT, NC_GEOM, NC_SCENE, NC_WM)) {
@@ -240,17 +251,15 @@ void wm_event_do_notifiers(bContext *C)
                        if(!G.rendering) {
 
                                /* depsgraph gets called, might send more notifiers */
-                               ED_update_for_newframe(C, 1);
+                               ED_update_for_newframe(CTX_data_main(C), win->screen->scene, win->screen, 1);
                        }
                }
        }
-
+       
        /* the notifiers are sent without context, to keep it clean */
        while( (note=wm_notifier_next(wm)) ) {
-               wmWindow *win;
-
                for(win= wm->windows.first; win; win= win->next) {
-
+                       
                        /* filter out notifiers */
                        if(note->category==NC_SCREEN && note->reference && note->reference!=win->screen);
                        else if(note->category==NC_SCENE && note->reference && note->reference!=win->screen->scene);
@@ -262,12 +271,12 @@ void wm_event_do_notifiers(bContext *C)
                                CTX_wm_window_set(C, win);
 
                                /* printf("notifier win %d screen %s cat %x\n", win->winid, win->screen->id.name+2, note->category); */
-                               ED_screen_do_listen(win, note);
+                               ED_screen_do_listen(C, note);
 
                                for(ar=win->screen->regionbase.first; ar; ar= ar->next) {
                                        ED_region_do_listen(ar, note);
                                }
-
+                               
                                for(sa= win->screen->areabase.first; sa; sa= sa->next) {
                                        ED_area_do_listen(sa, note);
                                        for(ar=sa->regionbase.first; ar; ar= ar->next) {
@@ -276,14 +285,19 @@ void wm_event_do_notifiers(bContext *C)
                                }
                        }
                }
-
+               
                MEM_freeN(note);
        }
+       
+       /* combine datamasks so 1 win doesn't disable UV's in another [#26448] */
+       for(win= wm->windows.first; win; win= win->next) {
+               win_combine_v3d_datamask |= ED_viewedit_datamask(win->screen);
+       }
 
        /* cached: editor refresh callbacks now, they get context */
        for(win= wm->windows.first; win; win= win->next) {
                ScrArea *sa;
-
+               
                CTX_wm_window_set(C, win);
                for(sa= win->screen->areabase.first; sa; sa= sa->next) {
                        if(sa->do_refresh) {
@@ -291,16 +305,30 @@ void wm_event_do_notifiers(bContext *C)
                                ED_area_do_refresh(C, sa);
                        }
                }
-
+               
                /* XXX make lock in future, or separated derivedmesh users in scene */
-               if(!G.rendering)
+               if(!G.rendering) {
                        /* depsgraph & animation: update tagged datablocks */
+
+                       /* copied to set's in scene_update_tagged_recursive() */
+                       win->screen->scene->customdata_mask= win_combine_v3d_datamask;
+
+                       /* XXX, hack so operators can enforce datamasks [#26482], gl render */
+                       win->screen->scene->customdata_mask |= win->screen->scene->customdata_mask_modal;
+
                        scene_update_tagged(CTX_data_main(C), win->screen->scene);
+               }
        }
 
        CTX_wm_window_set(C, NULL);
 }
 
+static int wm_event_always_pass(wmEvent *event)
+{
+       /* some events we always pass on, to ensure proper communication */
+       return ISTIMER(event->type) || (event->type == WINDEACTIVATE);
+}
+
 /* ********************* ui handler ******************* */
 
 static int wm_handler_ui_call(bContext *C, wmEventHandler *handler, wmEvent *event, int always_pass)
@@ -308,8 +336,19 @@ static int wm_handler_ui_call(bContext *C, wmEventHandler *handler, wmEvent *eve
        ScrArea *area= CTX_wm_area(C);
        ARegion *region= CTX_wm_region(C);
        ARegion *menu= CTX_wm_menu(C);
+       static int do_wheel_ui= 1;
+       int is_wheel= ELEM(event->type, WHEELUPMOUSE, WHEELDOWNMOUSE);
        int retval;
-
+       
+       /* UI is quite aggressive with swallowing events, like scrollwheel */
+       /* I realize this is not extremely nice code... when UI gets keymaps it can be maybe smarter */
+       if(do_wheel_ui==0) {
+               if(is_wheel)
+                       return WM_HANDLER_CONTINUE;
+               else if(wm_event_always_pass(event)==0)
+                       do_wheel_ui= 1;
+       }
+       
        /* we set context to where ui handler came from */
        if(handler->ui_area) CTX_wm_area_set(C, handler->ui_area);
        if(handler->ui_region) CTX_wm_region_set(C, handler->ui_region);
@@ -329,10 +368,14 @@ static int wm_handler_ui_call(bContext *C, wmEventHandler *handler, wmEvent *eve
                CTX_wm_region_set(C, NULL);
                CTX_wm_menu_set(C, NULL);
        }
-
+       
        if(retval == WM_UI_HANDLER_BREAK)
                return WM_HANDLER_BREAK;
-
+       
+       /* event not handled in UI, if wheel then we temporarily disable it */
+       if(is_wheel)
+               do_wheel_ui= 0;
+       
        return WM_HANDLER_CONTINUE;
 }
 
@@ -361,14 +404,14 @@ static void wm_handler_ui_cancel(bContext *C)
 int WM_operator_poll(bContext *C, wmOperatorType *ot)
 {
        wmOperatorTypeMacro *otmacro;
-
+       
        for(otmacro= ot->macro.first; otmacro; otmacro= otmacro->next) {
-               wmOperatorType *ot= WM_operatortype_find(otmacro->idname, 0);
+               wmOperatorType *ot_macro= WM_operatortype_find(otmacro->idname, 0);
                
-               if(0==WM_operator_poll(C, ot))
+               if(0==WM_operator_poll(C, ot_macro))
                        return 0;
        }
-
+       
        /* python needs operator type, so we added exception for it */
        if(ot->pyop_poll)
                return ot->pyop_poll(C, ot);
@@ -378,52 +421,70 @@ int WM_operator_poll(bContext *C, wmOperatorType *ot)
        return 1;
 }
 
-static void wm_operator_print(wmOperator *op)
+/* sets up the new context and calls 'wm_operator_invoke()' with poll_only */
+int WM_operator_poll_context(bContext *C, wmOperatorType *ot, int context)
 {
-       char *buf = WM_operator_pystring(NULL, op->type, op->ptr, 1);
+       return wm_operator_call_internal(C, ot, NULL, NULL, context, TRUE);
+}
+
+static void wm_operator_print(bContext *C, wmOperator *op)
+{
+       /* context is needed for enum function */
+       char *buf = WM_operator_pystring(C, op->type, op->ptr, 1);
        printf("%s\n", buf);
        MEM_freeN(buf);
 }
 
 static void wm_operator_reports(bContext *C, wmOperator *op, int retval, int popup)
 {
-       wmWindowManager *wm = CTX_wm_manager(C);
-       ReportList *reports = CTX_wm_reports(C);
-       char *buf;
-
        if(popup)
                if(op->reports->list.first)
                        uiPupMenuReports(C, op->reports);
        
        if(retval & OPERATOR_FINISHED) {
                if(G.f & G_DEBUG)
-                       wm_operator_print(op); /* todo - this print may double up, might want to check more flags then the FINISHED */
-
+                       wm_operator_print(C, op); /* todo - this print may double up, might want to check more flags then the FINISHED */
+               
+               BKE_reports_print(op->reports, RPT_DEBUG); /* print out reports to console. */
                if (op->type->flag & OPTYPE_REGISTER) {
-                       /* Report the python string representation of the operator */
-                       buf = WM_operator_pystring(C, op->type, op->ptr, 1);
-                       BKE_report(CTX_wm_reports(C), RPT_OPERATOR, buf);
-                       MEM_freeN(buf);
+                       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->type, op->ptr, 1);
+                               BKE_report(CTX_wm_reports(C), RPT_OPERATOR, buf);
+                               MEM_freeN(buf);
+                       }
                }
        }
 
-       if (op->reports->list.first) {
+       /* if the caller owns them them handle this */
+       if (op->reports->list.first && (op->reports->flag & RPT_OP_HOLD) == 0) {
+
+               wmWindowManager *wm = CTX_wm_manager(C);
+               ReportList *wm_reports= CTX_wm_reports(C);
                ReportTimerInfo *rti;
 
                /* add reports to the global list, otherwise they are not seen */
-               addlisttolist(&CTX_wm_reports(C)->list, &op->reports->list);
-
+               BLI_movelisttolist(&wm_reports->list, &op->reports->list);
+               
                /* After adding reports to the global list, reset the report timer. */
-               WM_event_remove_timer(wm, NULL, reports->reporttimer);
-
+               WM_event_remove_timer(wm, NULL, wm_reports->reporttimer);
+               
                /* Records time since last report was added */
-               reports->reporttimer= WM_event_add_timer(wm, CTX_wm_window(C), TIMER, 0.02);
-
+               wm_reports->reporttimer= WM_event_add_timer(wm, CTX_wm_window(C), TIMERREPORT, 0.05);
+               
                rti = MEM_callocN(sizeof(ReportTimerInfo), "ReportTimerInfo");
-               reports->reporttimer->customdata = rti;
+               wm_reports->reporttimer->customdata = rti;
        }
 }
 
+/* this function is mainly to check that the rules for freeing
+ * an operator are kept in sync.
+ */
+static int wm_operator_register_check(wmWindowManager *wm, wmOperatorType *ot)
+{
+       return wm && (wm->op_undo_depth == 0) && (ot->flag & OPTYPE_REGISTER);
+}
+
 static void wm_operator_finished(bContext *C, wmOperator *op, int repeat)
 {
        wmWindowManager *wm= CTX_wm_manager(C);
@@ -444,7 +505,7 @@ static void wm_operator_finished(bContext *C, wmOperator *op, int repeat)
                        MEM_freeN(buf);
                }
 
-               if((wm->op_undo_depth == 0) && (op->type->flag & OPTYPE_REGISTER))
+               if(wm_operator_register_check(wm, op->type))
                        wm_operator_register(C, op);
                else
                        WM_operator_free(op);
@@ -456,13 +517,15 @@ static int wm_operator_exec(bContext *C, wmOperator *op, int repeat)
 {
        wmWindowManager *wm= CTX_wm_manager(C);
        int retval= OPERATOR_CANCELLED;
-
+       
+       CTX_wm_operator_poll_msg_set(C, NULL);
+       
        if(op==NULL || op->type==NULL)
                return retval;
-
+       
        if(0==WM_operator_poll(C, op->type))
                return retval;
-
+       
        if(op->type->exec) {
                if(op->type->flag & OPTYPE_UNDO)
                        wm->op_undo_depth++;
@@ -472,16 +535,17 @@ static int wm_operator_exec(bContext *C, wmOperator *op, int repeat)
                if(op->type->flag & OPTYPE_UNDO && CTX_wm_manager(C) == wm)
                        wm->op_undo_depth--;
        }
-
+       
        if (retval & (OPERATOR_FINISHED|OPERATOR_CANCELLED) && repeat == 0)
                wm_operator_reports(C, op, retval, 0);
-
+       
        if(retval & OPERATOR_FINISHED)
                wm_operator_finished(C, op, repeat);
        else if(repeat==0)
                WM_operator_free(op);
-
+       
        return retval | OPERATOR_HANDLED;
+       
 }
 
 /* for running operators with frozen context (modal handlers, menus) */
@@ -495,15 +559,23 @@ int WM_operator_repeat(bContext *C, wmOperator *op)
 {
        return wm_operator_exec(C, op, 1);
 }
+/* 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. */
+int WM_operator_repeat_check(const bContext *UNUSED(C), wmOperator *op)
+{
+       return op->type->exec != NULL;
+}
 
 static wmOperator *wm_operator_create(wmWindowManager *wm, wmOperatorType *ot, PointerRNA *properties, ReportList *reports)
 {
        wmOperator *op= MEM_callocN(sizeof(wmOperator), ot->idname);    /* XXX operatortype names are static still. for debug */
-
+       
        /* XXX adding new operator could be function, only happens here now */
        op->type= ot;
        BLI_strncpy(op->idname, ot->idname, OP_MAX_TYPENAME);
-
+       
        /* initialize properties, either copy or create */
        op->ptr= MEM_callocN(sizeof(PointerRNA), "wmOperatorPtrRNA");
        if(properties && properties->data) {
@@ -523,19 +595,20 @@ static wmOperator *wm_operator_create(wmWindowManager *wm, wmOperatorType *ot, P
                op->reports= MEM_mallocN(sizeof(ReportList), "wmOperatorReportList");
                BKE_reports_init(op->reports, RPT_STORE|RPT_FREE);
        }
-
+       
        /* 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 */
                if(motherop==NULL) {
                        motherop = op;
                        root = 1;
                }
 
+               
                /* if properties exist, it will contain everything needed */
                if (properties) {
                        otmacro= ot->macro.first;
@@ -570,11 +643,11 @@ static wmOperator *wm_operator_create(wmWindowManager *wm, wmOperatorType *ot, P
                                opm->opm= motherop; /* pointer to mom, for modal() */
                        }
                }
-
+               
                if (root)
                        motherop= NULL;
        }
-
+       
        WM_operator_properties_sanitize(op->ptr, 0);
 
        return op;
@@ -588,19 +661,28 @@ static void wm_region_mouse_co(bContext *C, wmEvent *event)
                event->mval[0]= event->x - ar->winrct.xmin;
                event->mval[1]= event->y - ar->winrct.ymin;
        }
+       else {
+               /* these values are invalid (avoid odd behavior by relying on old mval values) */
+               event->mval[0]= -1;
+               event->mval[1]= -1;
+       }
 }
 
-int wm_operator_invoke(bContext *C, wmOperatorType *ot, wmEvent *event, PointerRNA *properties, ReportList *reports)
+static int wm_operator_invoke(bContext *C, wmOperatorType *ot, wmEvent *event, PointerRNA *properties, ReportList *reports, short poll_only)
 {
        wmWindowManager *wm= CTX_wm_manager(C);
        int retval= OPERATOR_PASS_THROUGH;
 
+       /* this is done because complicated setup is done to call this function that is better not duplicated */
+       if(poll_only)
+               return WM_operator_poll(C, ot);
+
        if(WM_operator_poll(C, ot)) {
                wmOperator *op= wm_operator_create(wm, ot, properties, reports); /* if reports==NULL, theyll be initialized */
-
+               
                if((G.f & G_DEBUG) && event && event->type!=MOUSEMOVE)
                        printf("handle evt %d win %d op %s\n", event?event->type:0, CTX_wm_screen(C)->subwinactive, ot->idname); 
-
+               
                if(op->type->invoke && event) {
                        wm_region_mouse_co(C, event);
 
@@ -623,13 +705,13 @@ int wm_operator_invoke(bContext *C, wmOperatorType *ot, wmEvent *event, PointerR
                }
                else
                        printf("invalid operator call %s\n", ot->idname); /* debug, important to leave a while, should never happen */
-
+               
                /* 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 */
                        wm_operator_reports(C, op, retval, (reports==NULL));
-
+               
                if(retval & OPERATOR_HANDLED)
                        ; /* do nothing, wm_operator_exec() has been called somewhere */
                else if(retval & OPERATOR_FINISHED) {
@@ -649,13 +731,31 @@ int wm_operator_invoke(bContext *C, wmOperatorType *ot, wmEvent *event, PointerR
                                        wrap = (U.uiflag & USER_CONTINUOUS_MOUSE) && ((op->flag & OP_GRAB_POINTER) || (ot->flag & OPTYPE_GRAB_POINTER));
                                }
 
+                               /* exception, cont. grab in header is annoying */
+                               if(wrap) {
+                                       ARegion *ar= CTX_wm_region(C);
+                                       if(ar && ar->regiontype == RGN_TYPE_HEADER) {
+                                               wrap= FALSE;
+                                       }
+                               }
+
                                if(wrap) {
+                                       rcti *winrect= NULL;
                                        ARegion *ar= CTX_wm_region(C);
-                                       if(ar) {
-                                               bounds[0]= ar->winrct.xmin;
-                                               bounds[1]= ar->winrct.ymax;
-                                               bounds[2]= ar->winrct.xmax;
-                                               bounds[3]= ar->winrct.ymin;
+                                       ScrArea *sa= CTX_wm_area(C);
+
+                                       if(ar && ar->regiontype == RGN_TYPE_WINDOW && event && BLI_in_rcti(&ar->winrct, event->x, event->y)) {
+                                               winrect= &ar->winrct;
+                                       }
+                                       else if(sa) {
+                                               winrect= &sa->totrct;
+                                       }
+
+                                       if(winrect) {
+                                               bounds[0]= winrect->xmin;
+                                               bounds[1]= winrect->ymax;
+                                               bounds[2]= winrect->xmax;
+                                               bounds[3]= winrect->ymin;
                                        }
                                }
 
@@ -679,13 +779,15 @@ int wm_operator_invoke(bContext *C, wmOperatorType *ot, wmEvent *event, PointerR
  * 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, int context, PointerRNA *properties, ReportList *reports)
+static int wm_operator_call_internal(bContext *C, wmOperatorType *ot, PointerRNA *properties, ReportList *reports, short context, short poll_only)
 {
        wmWindow *window= CTX_wm_window(C);
        wmEvent *event;
        
        int retval;
 
+       CTX_wm_operator_poll_msg_set(C, NULL);
+
        /* dummie test */
        if(ot && C) {
                switch(context) {
@@ -704,7 +806,7 @@ static int wm_operator_call_internal(bContext *C, wmOperatorType *ot, int contex
                }
 
                switch(context) {
-
+                       
                        case WM_OP_EXEC_REGION_WIN:
                        case WM_OP_INVOKE_REGION_WIN: 
                        case WM_OP_EXEC_REGION_CHANNELS:
@@ -723,40 +825,41 @@ static int wm_operator_call_internal(bContext *C, wmOperatorType *ot, int contex
                                        case WM_OP_EXEC_REGION_CHANNELS:
                                        case WM_OP_INVOKE_REGION_CHANNELS:
                                                type = RGN_TYPE_CHANNELS;
-
+                                               break;
+                                       
                                        case WM_OP_EXEC_REGION_PREVIEW:
                                        case WM_OP_INVOKE_REGION_PREVIEW:
                                                type = RGN_TYPE_PREVIEW;
                                                break;
-
+                                       
                                        case WM_OP_EXEC_REGION_WIN:
                                        case WM_OP_INVOKE_REGION_WIN: 
                                        default:
                                                type = RGN_TYPE_WINDOW;
                                                break;
                                }
-
+                               
                                if(!(ar && ar->regiontype == type) && area) {
                                        ARegion *ar1= BKE_area_find_region_type(area, type);
                                        if(ar1)
                                                CTX_wm_region_set(C, ar1);
                                }
-
-                               retval= wm_operator_invoke(C, ot, event, properties, reports);
-
+                               
+                               retval= wm_operator_invoke(C, ot, event, properties, reports, poll_only);
+                               
                                /* set region back */
                                CTX_wm_region_set(C, ar);
-
+                               
                                return retval;
                        }
                        case WM_OP_EXEC_AREA:
                        case WM_OP_INVOKE_AREA:
                        {
-                               /* remove region from context */
+                                       /* remove region from context */
                                ARegion *ar= CTX_wm_region(C);
 
                                CTX_wm_region_set(C, NULL);
-                               retval= wm_operator_invoke(C, ot, event, properties, reports);
+                               retval= wm_operator_invoke(C, ot, event, properties, reports, poll_only);
                                CTX_wm_region_set(C, ar);
 
                                return retval;
@@ -770,7 +873,7 @@ static int wm_operator_call_internal(bContext *C, wmOperatorType *ot, int contex
 
                                CTX_wm_region_set(C, NULL);
                                CTX_wm_area_set(C, NULL);
-                               retval= wm_operator_invoke(C, ot, event, properties, reports);
+                               retval= wm_operator_invoke(C, ot, event, properties, reports, poll_only);
                                CTX_wm_region_set(C, ar);
                                CTX_wm_area_set(C, area);
 
@@ -778,10 +881,10 @@ static int wm_operator_call_internal(bContext *C, wmOperatorType *ot, int contex
                        }
                        case WM_OP_EXEC_DEFAULT:
                        case WM_OP_INVOKE_DEFAULT:
-                               return wm_operator_invoke(C, ot, event, properties, reports);
+                               return wm_operator_invoke(C, ot, event, properties, reports, poll_only);
                }
        }
-
+       
        return 0;
 }
 
@@ -791,7 +894,7 @@ int WM_operator_name_call(bContext *C, const char *opstring, int context, Pointe
 {
        wmOperatorType *ot= WM_operatortype_find(opstring, 0);
        if(ot)
-               return wm_operator_call_internal(C, ot, context, properties, NULL);
+               return wm_operator_call_internal(C, ot, properties, NULL, context, FALSE);
 
        return 0;
 }
@@ -807,7 +910,6 @@ int WM_operator_call_py(bContext *C, wmOperatorType *ot, int context, PointerRNA
 
 #if 0
        wmOperator *op;
-       wmWindowManager *wm=    CTX_wm_manager(C);
        op= wm_operator_create(wm, ot, properties, reports);
 
        if (op->type->exec) {
@@ -823,14 +925,15 @@ int WM_operator_call_py(bContext *C, wmOperatorType *ot, int context, PointerRNA
                printf("error \"%s\" operator has no exec function, python cannot call it\n", op->type->name);
 #endif
 
-       retval= wm_operator_call_internal(C, ot, context, properties, reports);
-
+       retval= wm_operator_call_internal(C, ot, properties, reports, context, FALSE);
+       
        /* keep the reports around if needed later */
-       if (retval & OPERATOR_RUNNING_MODAL || ot->flag & OPTYPE_REGISTER)
-       {
-               reports->flag |= RPT_FREE;
+       if (    (retval & OPERATOR_RUNNING_MODAL) ||
+                       ((retval & OPERATOR_FINISHED) && wm_operator_register_check(CTX_wm_manager(C), ot))
+       ) {
+               reports->flag |= RPT_FREE; /* let blender manage freeing */
        }
-
+       
        return retval;
 }
 
@@ -847,13 +950,13 @@ void wm_event_free_handler(wmEventHandler *handler)
 static void wm_handler_op_context(bContext *C, wmEventHandler *handler)
 {
        bScreen *screen= CTX_wm_screen(C);
-
+       
        if(screen && handler->op) {
                if(handler->op_area==NULL)
                        CTX_wm_area_set(C, NULL);
                else {
                        ScrArea *sa;
-
+                       
                        for(sa= screen->areabase.first; sa; sa= sa->next)
                                if(sa==handler->op_area)
                                        break;
@@ -882,16 +985,16 @@ void WM_event_remove_handlers(bContext *C, ListBase *handlers)
 {
        wmEventHandler *handler;
        wmWindowManager *wm= CTX_wm_manager(C);
-
+       
        /* C is zero on freeing database, modal handlers then already were freed */
        while((handler=handlers->first)) {
                BLI_remlink(handlers, handler);
-
+               
                if(handler->op) {
                        if(handler->op->type->cancel) {
                                ScrArea *area= CTX_wm_area(C);
                                ARegion *region= CTX_wm_region(C);
-
+                               
                                wm_handler_op_context(C, handler);
 
                                if(handler->op->type->flag & OPTYPE_UNDO)
@@ -913,7 +1016,7 @@ void WM_event_remove_handlers(bContext *C, ListBase *handlers)
                        ScrArea *area= CTX_wm_area(C);
                        ARegion *region= CTX_wm_region(C);
                        ARegion *menu= CTX_wm_menu(C);
-
+                       
                        if(handler->ui_area) CTX_wm_area_set(C, handler->ui_area);
                        if(handler->ui_region) CTX_wm_region_set(C, handler->ui_region);
                        if(handler->ui_menu) CTX_wm_menu_set(C, handler->ui_menu);
@@ -938,45 +1041,45 @@ int WM_userdef_event_map(int kmitype)
                                return LEFTMOUSE;
                        else
                                return RIGHTMOUSE;
-
+                       
                case ACTIONMOUSE:
                        if(U.flag & USER_LMOUSESELECT)
                                return RIGHTMOUSE;
                        else
                                return LEFTMOUSE;
-
+                       
                case WHEELOUTMOUSE:
                        if(U.uiflag & USER_WHEELZOOMDIR)
                                return WHEELUPMOUSE;
                        else
                                return WHEELDOWNMOUSE;
-
+                       
                case WHEELINMOUSE:
                        if(U.uiflag & USER_WHEELZOOMDIR)
                                return WHEELDOWNMOUSE;
                        else
                                return WHEELUPMOUSE;
-
+                       
                case EVT_TWEAK_A:
                        if(U.flag & USER_LMOUSESELECT)
                                return EVT_TWEAK_R;
                        else
                                return EVT_TWEAK_L;
-
+                       
                case EVT_TWEAK_S:
                        if(U.flag & USER_LMOUSESELECT)
                                return EVT_TWEAK_L;
                        else
                                return EVT_TWEAK_R;
        }
-
+       
        return kmitype;
 }
 
 static void wm_eventemulation(wmEvent *event)
 {
        static int mmb_emulated = 0; /* this should be in a data structure somwhere */
-
+       
        /* middlemouse emulation */
        if(U.flag & USER_TWOBUTTONMOUSE) {
                if(event->type == LEFTMOUSE && (event->alt || mmb_emulated == KM_PRESS)) {
@@ -1028,10 +1131,10 @@ static int wm_eventmatch(wmEvent *winevent, wmKeyMapItem *kmi)
                if(ISTEXTINPUT(winevent->type) && winevent->ascii) return 1;
        if(kmitype!=KM_ANY)
                if(winevent->type!=kmitype) return 0;
-
+       
        if(kmi->val!=KM_ANY)
                if(winevent->val!=kmi->val) return 0;
-
+       
        /* modifiers also check bits, so it allows modifier order */
        if(kmi->shift!=KM_ANY)
                if(winevent->shift != kmi->shift && !(winevent->shift & kmi->shift)) return 0;
@@ -1041,24 +1144,19 @@ static int wm_eventmatch(wmEvent *winevent, wmKeyMapItem *kmi)
                if(winevent->alt != kmi->alt && !(winevent->alt & kmi->alt)) return 0;
        if(kmi->oskey!=KM_ANY)
                if(winevent->oskey != kmi->oskey && !(winevent->oskey & kmi->oskey)) return 0;
-
+       
        if(kmi->keymodifier)
                if(winevent->keymodifier!=kmi->keymodifier) return 0;
-
+               
        /* key modifiers always check when event has it */
        /* otherwise regular keypresses with keymodifier still work */
        if(winevent->keymodifier)
                if(ISTEXTINPUT(winevent->type)) 
                        if(winevent->keymodifier!=kmi->keymodifier) return 0;
-
+       
        return 1;
 }
 
-static int wm_event_always_pass(wmEvent *event)
-{
-       /* some events we always pass on, to ensure proper communication */
-       return ISTIMER(event->type) || (event->type == WINDEACTIVATE);
-}
 
 /* operator exists */
 static void wm_event_modalkeymap(const bContext *C, wmOperator *op, wmEvent *event)
@@ -1073,6 +1171,7 @@ static void wm_event_modalkeymap(const bContext *C, wmOperator *op, wmEvent *eve
 
                for(kmi= keymap->items.first; kmi; kmi= kmi->next) {
                        if(wm_eventmatch(event, kmi)) {
+                                       
                                event->type= EVT_MODAL_MAP;
                                event->val= kmi->propvalue;
                        }
@@ -1084,7 +1183,7 @@ static void wm_event_modalkeymap(const bContext *C, wmOperator *op, wmEvent *eve
 static int wm_handler_operator_call(bContext *C, ListBase *handlers, wmEventHandler *handler, wmEvent *event, PointerRNA *properties)
 {
        int retval= OPERATOR_PASS_THROUGH;
-
+       
        /* derived, modal or blocking operator */
        if(handler->op) {
                wmOperator *op= handler->op;
@@ -1095,11 +1194,11 @@ static int wm_handler_operator_call(bContext *C, ListBase *handlers, wmEventHand
                        wmWindowManager *wm= CTX_wm_manager(C);
                        ScrArea *area= CTX_wm_area(C);
                        ARegion *region= CTX_wm_region(C);
-
+                       
                        wm_handler_op_context(C, handler);
                        wm_region_mouse_co(C, event);
                        wm_event_modalkeymap(C, op, event);
-
+                       
                        if(ot->flag & OPTYPE_UNDO)
                                wm->op_undo_depth++;
 
@@ -1117,11 +1216,11 @@ static int wm_handler_operator_call(bContext *C, ListBase *handlers, wmEventHand
                                /* this special cases is for areas and regions that get removed */
                                CTX_wm_area_set(C, NULL);
                                CTX_wm_region_set(C, NULL);
-                       }
+                       }               
 
                        if(retval & (OPERATOR_CANCELLED|OPERATOR_FINISHED))
                                wm_operator_reports(C, op, retval, 0);
-
+                       
                        if(retval & OPERATOR_FINISHED) {
                                wm_operator_finished(C, op, 0);
                                handler->op= NULL;
@@ -1130,17 +1229,18 @@ static int wm_handler_operator_call(bContext *C, ListBase *handlers, wmEventHand
                                WM_operator_free(op);
                                handler->op= NULL;
                        }
-
+                       
                        /* remove modal handler, operator itself should have been cancelled and freed */
                        if(retval & (OPERATOR_CANCELLED|OPERATOR_FINISHED)) {
                                WM_cursor_ungrab(CTX_wm_window(C));
 
                                BLI_remlink(handlers, handler);
                                wm_event_free_handler(handler);
-
+                               
                                /* prevent silly errors from operator users */
                                //retval &= ~OPERATOR_PASS_THROUGH;
                        }
+                       
                }
                else
                        printf("wm_handler_operator_call error\n");
@@ -1149,7 +1249,7 @@ static int wm_handler_operator_call(bContext *C, ListBase *handlers, wmEventHand
                wmOperatorType *ot= WM_operatortype_find(event->keymap_idname, 0);
 
                if(ot)
-                       retval= wm_operator_invoke(C, ot, event, properties, NULL);
+                       retval= wm_operator_invoke(C, ot, event, properties, NULL, FALSE);
        }
 
        /* Finished and pass through flag as handled */
@@ -1172,61 +1272,75 @@ static int wm_handler_fileselect_call(bContext *C, ListBase *handlers, wmEventHa
        wmWindowManager *wm= CTX_wm_manager(C);
        SpaceFile *sfile;
        int action= WM_HANDLER_CONTINUE;
-
+       
        if(event->type != EVT_FILESELECT)
                return action;
        if(handler->op != (wmOperator *)event->customdata)
                return action;
-
+       
        switch(event->val) {
                case EVT_FILESELECT_OPEN: 
                case EVT_FILESELECT_FULL_OPEN: 
-                       {
+                       {       
                                ScrArea *sa;
-
+                               
                                /* sa can be null when window A is active, but mouse is over window B */
                                /* in this case, open file select in original window A */
                                if (handler->op_area == NULL) {
                                        bScreen *screen = CTX_wm_screen(C);
                                        sa = (ScrArea *)screen->areabase.first;
-                               } else
+                               }
+                               else {
                                        sa = handler->op_area;
+                               }
+                                       
+                               if(event->val==EVT_FILESELECT_OPEN) {
+                                       ED_area_newspace(C, sa, SPACE_FILE); /* 'sa' is modified in-place */
+                               }
+                               else {
+                                       sa= ED_screen_full_newspace(C, sa, SPACE_FILE); /* sets context */
+                               }
 
-                               if(event->val==EVT_FILESELECT_OPEN)
-                                       ED_area_newspace(C, sa, SPACE_FILE);
-                               else
-                                       ED_screen_full_newspace(C, sa, SPACE_FILE);     /* sets context */
+                               /* note, getting the 'sa' back from the context causes a nasty bug where the newly created
+                                * 'sa' != CTX_wm_area(C). removed the line below and set 'sa' in the 'if' above */
+                               /* sa = CTX_wm_area(C); */
 
                                /* settings for filebrowser, sfile is not operator owner but sends events */
-                               sa = CTX_wm_area(C);
                                sfile= (SpaceFile*)sa->spacedata.first;
                                sfile->op= handler->op;
 
                                ED_fileselect_set_params(sfile);
-
+                               
                                action= WM_HANDLER_BREAK;
                        }
                        break;
-
+                       
                case EVT_FILESELECT_EXEC:
                case EVT_FILESELECT_CANCEL:
+               case EVT_FILESELECT_EXTERNAL_CANCEL:
                        {
                                /* XXX validate area and region? */
                                bScreen *screen= CTX_wm_screen(C);
 
-                               if(screen != handler->filescreen)
-                                       ED_screen_full_prevspace(C, CTX_wm_area(C));
-                               else
-                                       ED_area_prevspace(C, CTX_wm_area(C));
-
-                               /* remlink now, for load file case */
+                               /* remlink now, for load file case before removing*/
                                BLI_remlink(handlers, handler);
-
+                               
+                               if(event->val!=EVT_FILESELECT_EXTERNAL_CANCEL) {
+                                       if(screen != handler->filescreen) {
+                                               ED_screen_full_prevspace(C, CTX_wm_area(C));
+                                       }
+                                       else {
+                                               ED_area_prevspace(C, CTX_wm_area(C));
+                                       }
+                               }
+                               
                                wm_handler_op_context(C, handler);
 
                                /* needed for uiPupMenuReports */
 
                                if(event->val==EVT_FILESELECT_EXEC) {
+#if 0                          // use REDALERT now
+
                                        /* a bit weak, might become arg for WM_event_fileselect? */
                                        /* XXX also extension code in image-save doesnt work for this yet */
                                        if (RNA_struct_find_property(handler->op->ptr, "check_existing") && 
@@ -1237,7 +1351,9 @@ static int wm_handler_fileselect_call(bContext *C, ListBase *handlers, wmEventHa
                                                if(path)
                                                        MEM_freeN(path);
                                        }
-                                       else {
+                                       else
+#endif
+                                       {
                                                int retval;
                                                
                                                if(handler->op->type->flag & OPTYPE_UNDO)
@@ -1245,14 +1361,16 @@ static int wm_handler_fileselect_call(bContext *C, ListBase *handlers, wmEventHa
 
                                                retval= handler->op->type->exec(C, handler->op);
 
+                                               /* XXX check this carefully, CTX_wm_manager(C) == wm is a bit hackish */
                                                if(handler->op->type->flag & OPTYPE_UNDO && CTX_wm_manager(C) == wm)
                                                        wm->op_undo_depth--;
-
+                                               
                                                if (retval & OPERATOR_FINISHED)
                                                        if(G.f & G_DEBUG)
-                                                               wm_operator_print(handler->op);
-
-                                               if(wm->op_undo_depth == 0)
+                                                               wm_operator_print(C, handler->op);
+                                               
+                                               /* XXX check this carefully, CTX_wm_manager(C) == wm is a bit hackish */
+                                               if(CTX_wm_manager(C) == wm && wm->op_undo_depth == 0)
                                                        if(handler->op->type->flag & OPTYPE_UNDO)
                                                                ED_undo_push_op(C, handler->op);
 
@@ -1270,7 +1388,7 @@ static int wm_handler_fileselect_call(bContext *C, ListBase *handlers, wmEventHa
 
                                                        /* XXX - copied from 'wm_operator_finished()' */
                                                        /* add reports to the global list, otherwise they are not seen */
-                                                       addlisttolist(&CTX_wm_reports(C)->list, &handler->op->reports->list);
+                                                       BLI_movelisttolist(&CTX_wm_reports(C)->list, &handler->op->reports->list);
 
                                                        CTX_wm_window_set(C, win_prev);
                                                }
@@ -1293,14 +1411,14 @@ static int wm_handler_fileselect_call(bContext *C, ListBase *handlers, wmEventHa
                                }
 
                                CTX_wm_area_set(C, NULL);
-
+                               
                                wm_event_free_handler(handler);
-
+                               
                                action= WM_HANDLER_BREAK;
                        }
                        break;
        }
-
+       
        return action;
 }
 
@@ -1346,13 +1464,16 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
 
        /* modal handlers can get removed in this loop, we keep the loop this way */
        for(handler= handlers->first; handler; handler= nexthandler) {
+               
                nexthandler= handler->next;
-
-               /* optional boundbox */
-               if(handler_boundbox_test(handler, event)) {
+               
+               /* during this loop, ui handlers for nested menus can tag multiple handlers free */
+               if(handler->flag & WM_HANDLER_DO_FREE);
+                       /* optional boundbox */
+               else if(handler_boundbox_test(handler, event)) {
                        /* in advance to avoid access to freed event on window close */
                        always_pass= wm_event_always_pass(event);
-
+               
                        /* modal+blocking handler */
                        if(handler->flag & WM_HANDLER_BLOCKING)
                                action |= WM_HANDLER_BREAK;
@@ -1360,13 +1481,13 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
                        if(handler->keymap) {
                                wmKeyMap *keymap= WM_keymap_active(wm, handler->keymap);
                                wmKeyMapItem *kmi;
-
+                               
                                if(!keymap->poll || keymap->poll(C)) {
                                        for(kmi= keymap->items.first; kmi; kmi= kmi->next) {
                                                if(wm_eventmatch(event, kmi)) {
-
+                                                       
                                                        event->keymap_idname= kmi->idname;      /* weak, but allows interactive callback to not use rawkey */
-
+                                                       
                                                        action |= wm_handler_operator_call(C, handlers, handler, event, kmi->ptr);
                                                        if(action & WM_HANDLER_BREAK)  /* not always_pass here, it denotes removed handler */
                                                                break;
@@ -1389,12 +1510,26 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
                                                if(event->custom==EVT_DATA_LISTBASE) {
                                                        ListBase *lb= (ListBase *)event->customdata;
                                                        wmDrag *drag;
+                                                       
                                                        for(drag= lb->first; drag; drag= drag->next) {
                                                                if(drop->poll(C, drag, event)) {
+                                                                       
                                                                        drop->copy(drag, drop);
-
-                                                                       wm_operator_invoke(C, drop->ot, event, drop->ptr, NULL);
+                                                                       
+                                                                       /* free the drags before calling operator */
+                                                                       BLI_freelistN(event->customdata);
+                                                                       event->customdata= NULL;
+                                                                       event->custom= 0;
+                                                                       
+                                                                       WM_operator_name_call(C, drop->ot->idname, drop->opcontext, drop->ptr);
                                                                        action |= WM_HANDLER_BREAK;
+                                                                       
+                                                                       /* XXX fileread case */
+                                                                       if(CTX_wm_window(C)==NULL)
+                                                                               return action;
+                                                                       
+                                                                       /* escape from drag loop, got freed */
+                                                                       break;
                                                                }
                                                        }
                                                }
@@ -1413,10 +1548,22 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
                                        break;
                        }
                }
-
-               /* fileread case */
-               if(CTX_wm_window(C)==NULL)
+               
+               /* XXX fileread case, if the wm is freed then the handler's
+                * will have been too so the code below need not run. */
+               if(CTX_wm_window(C)==NULL) {
                        return action;
+               }
+
+               /* 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) != -1) { /* could be free'd already by regular modal ops */
+                       if(handler->flag & WM_HANDLER_DO_FREE) {
+                               BLI_remlink(handlers, handler);
+                               wm_event_free_handler(handler);
+                       }
+               }
        }
 
        /* test for CLICK event */
@@ -1424,11 +1571,24 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
                wmWindow *win = CTX_wm_window(C);
 
                if (win && win->eventstate->prevtype == event->type && win->eventstate->prevval == KM_PRESS) {
-                       /* test for double click first */
-                       if ((PIL_check_seconds_timer() - win->eventstate->prevclicktime) * 1000 < U.dbl_click_time) {
+                       /* test for double click first,
+                        * note1: this can be problematic because single click operators can get the
+                        *   double click event but then with old mouse coords which is highly confusing,
+                        *   so check for mouse moves too.
+                        * note2: the first click event will be handled but still used to create a
+                        *   double click event if clicking again quickly.
+                        *   If no double click events are found it will fallback to a single click.
+                        *   So a double click event can result in 2 successive single click calls
+                        *   if its not handled by the keymap - campbell */
+                       if (    (ABS(event->x - win->eventstate->prevclickx)) <= 2 &&
+                                       (ABS(event->y - win->eventstate->prevclicky)) <= 2 &&
+                                       ((PIL_check_seconds_timer() - win->eventstate->prevclicktime) * 1000 < U.dbl_click_time)
+                       ) {
                                event->val = KM_DBL_CLICK;
-                               event->x = win->eventstate->prevclickx;
-                               event->y = win->eventstate->prevclicky;
+                               /* removed this because in cases where we're this is used as a single click
+                                * event, this will give old coords, since the distance is checked above, using new coords should be ok. */
+                               //   event->x = win->eventstate->prevclickx;
+                               //   event->y = win->eventstate->prevclicky;
                                action |= wm_handlers_do(C, event, handlers);
                        }
 
@@ -1437,12 +1597,16 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
                                action |= wm_handlers_do(C, event, handlers);
                        }
 
+
                        /* revert value if not handled */
                        if (wm_action_not_handled(action)) {
                                event->val = KM_RELEASE;
                        }
                }
        }
+       
+       if(action == (WM_HANDLER_BREAK|WM_HANDLER_MODAL))
+               wm_cursor_arrow_move(CTX_wm_window(C), event);
 
        return action;
 }
@@ -1452,7 +1616,7 @@ static int wm_event_inside_i(wmEvent *event, rcti *rect)
        if(wm_event_always_pass(event))
                return 1;
        if(BLI_in_rcti(rect, event->x, event->y))
-          return 1;
+               return 1;
        if(event->type==MOUSEMOVE) {
                if( BLI_in_rcti(rect, event->prevx, event->prevy)) {
                        return 1;
@@ -1466,7 +1630,7 @@ static ScrArea *area_event_inside(bContext *C, int x, int y)
 {
        bScreen *screen= CTX_wm_screen(C);
        ScrArea *sa;
-
+       
        if(screen)
                for(sa= screen->areabase.first; sa; sa= sa->next)
                        if(BLI_in_rcti(&sa->totrct, x, y))
@@ -1479,7 +1643,7 @@ static ARegion *region_event_inside(bContext *C, int x, int y)
        bScreen *screen= CTX_wm_screen(C);
        ScrArea *area= CTX_wm_area(C);
        ARegion *ar;
-
+       
        if(screen && area)
                for(ar= area->regionbase.first; ar; ar= ar->next)
                        if(BLI_in_rcti(&ar->winrct, x, y))
@@ -1505,21 +1669,22 @@ static void wm_paintcursor_tag(bContext *C, wmPaintCursor *pc, ARegion *ar)
 static void wm_paintcursor_test(bContext *C, wmEvent *event)
 {
        wmWindowManager *wm= CTX_wm_manager(C);
-
+       
        if(wm->paintcursors.first) {
                ARegion *ar= CTX_wm_region(C);
+               
                if(ar)
                        wm_paintcursor_tag(C, wm->paintcursors.first, ar);
-
+               
                /* if previous position was not in current region, we have to set a temp new context */
                if(ar==NULL || !BLI_in_rcti(&ar->winrct, event->prevx, event->prevy)) {
                        ScrArea *sa= CTX_wm_area(C);
-
+                       
                        CTX_wm_area_set(C, area_event_inside(C, event->prevx, event->prevy));
                        CTX_wm_region_set(C, region_event_inside(C, event->prevx, event->prevy));
 
                        wm_paintcursor_tag(C, wm->paintcursors.first, CTX_wm_region(C));
-
+                       
                        CTX_wm_area_set(C, sa);
                        CTX_wm_region_set(C, ar);
                }
@@ -1529,7 +1694,7 @@ static void wm_paintcursor_test(bContext *C, wmEvent *event)
 static void wm_event_drag_test(wmWindowManager *wm, wmWindow *win, wmEvent *event)
 {
        if(wm->drags.first==NULL) return;
-
+       
        if(event->type==MOUSEMOVE)
                win->screen->do_draw_drag= 1;
        else if(event->type==ESCKEY) {
@@ -1538,24 +1703,24 @@ static void wm_event_drag_test(wmWindowManager *wm, wmWindow *win, wmEvent *even
        }
        else if(event->type==LEFTMOUSE && event->val==KM_RELEASE) {
                event->type= EVT_DROP;
-
+               
                /* create customdata, first free existing */
                if(event->customdata) {
                        if(event->customdatafree)
                                MEM_freeN(event->customdata);
                }
-
+               
                event->custom= EVT_DATA_LISTBASE;
                event->customdata= &wm->drags;
                event->customdatafree= 1;
-
+               
                /* clear drop icon */
                win->screen->do_draw_drag= 1;
-
+               
                /* restore cursor (disabled, see wm_dragdrop.c) */
                // WM_cursor_restore(win);
        }
-
+       
        /* overlap fails otherwise */
        if(win->screen->do_draw_drag)
                if(win->drawmethod == USER_DRAW_OVERLAP)
@@ -1570,69 +1735,74 @@ void wm_event_do_handlers(bContext *C)
        wmWindowManager *wm= CTX_wm_manager(C);
        wmWindow *win;
 
+       /* update key configuration before handling events */
+       WM_keyconfig_update(wm);
+
        for(win= wm->windows.first; win; win= win->next) {
                wmEvent *event;
-
+               
                if( win->screen==NULL )
                        wm_event_free_all(win);
                else {
                        Scene* scene = win->screen->scene;
-
+                       
                        if(scene) {
                                int playing = sound_scene_playing(win->screen->scene);
-
+                               
                                if(playing != -1) {
                                        CTX_wm_window_set(C, win);
                                        CTX_wm_screen_set(C, win->screen);
                                        CTX_data_scene_set(C, scene);
-
+                                       
                                        if(((playing == 1) && (!win->screen->animtimer)) || ((playing == 0) && (win->screen->animtimer))){
                                                ED_screen_animation_play(C, -1, 1);
                                        }
-
+                                       
                                        if(playing == 0) {
-                                               int ncfra = sound_sync_scene(scene) * FPS + 0.5;
+                                               int ncfra = sound_sync_scene(scene) * (float)FPS + 0.5f;
                                                if(ncfra != scene->r.cfra)      {
                                                        scene->r.cfra = ncfra;
-                                                       ED_update_for_newframe(C, 1);
+                                                       ED_update_for_newframe(CTX_data_main(C), scene, win->screen, 1);
                                                        WM_event_add_notifier(C, NC_WINDOW, NULL);
                                                }
                                        }
-
+                                       
                                        CTX_data_scene_set(C, NULL);
                                        CTX_wm_screen_set(C, NULL);
                                        CTX_wm_window_set(C, NULL);
                                }
                        }
                }
-
+               
                while( (event= win->queue.first) ) {
                        int action = WM_HANDLER_CONTINUE;
 
                        if((G.f & G_DEBUG) && event && !ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE))
                                printf("pass on evt %d val %d\n", event->type, event->val); 
-
+                       
                        wm_eventemulation(event);
 
                        CTX_wm_window_set(C, win);
-
+                       
                        /* 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, event->y));
                        CTX_wm_region_set(C, region_event_inside(C, event->x, event->y));
-
+                       
                        /* MVC demands to not draw in event handlers... but we need to leave it for ogl selecting etc */
                        wm_window_make_drawable(C, win);
+                       
+                       wm_region_mouse_co(C, event);
 
                        /* first we do priority handlers, modal + some limited keymaps */
                        action |= wm_handlers_do(C, event, &win->modalhandlers);
-
+                       
                        /* fileread case */
                        if(CTX_wm_window(C)==NULL)
                                return;
-
+                       
                        /* check dragging, creates new event or frees, adds draw tag */
                        wm_event_drag_test(wm, win, event);
-
+                       
                        /* builtin tweak, if action is break it removes tweak */
                        wm_tweakevent_test(C, event, action);
 
@@ -1640,14 +1810,17 @@ void wm_event_do_handlers(bContext *C)
                                ScrArea *sa;
                                ARegion *ar;
                                int doit= 0;
-
-                               /* XXX to solve, here screen handlers? */
+       
+                               /* Note: setting subwin active should be done here, after modal handlers have been done */
                                if(event->type==MOUSEMOVE) {
-                                       /* state variables in screen, cursors */
-                                       ED_screen_set_subwinactive(win, event); 
+                                       /* state variables in screen, cursors. Also used in wm_draw.c, fails for modal handlers though */
+                                       ED_screen_set_subwinactive(C, event);   
                                        /* for regions having custom cursors */
                                        wm_paintcursor_test(C, event);
                                }
+                               else if (event->type==NDOF_MOTION) {
+                                       win->addmousemove = TRUE;
+                               }
 
                                for(sa= win->screen->areabase.first; sa; sa= sa->next) {
                                        if(wm_event_inside_i(event, &sa->totrct)) {
@@ -1657,18 +1830,24 @@ void wm_event_do_handlers(bContext *C)
                                                        for(ar=sa->regionbase.first; ar; ar= ar->next) {
                                                                if(wm_event_inside_i(event, &ar->winrct)) {
                                                                        CTX_wm_region_set(C, ar);
+                                                                       
+                                                                       /* call even on non mouse events, since the */
+                                                                       wm_region_mouse_co(C, event);
 
                                                                        /* 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)) {
-                                                                               wm_region_mouse_co(C, event);
                                                                                wm_drags_check_ops(C, event);
                                                                        }
-
+                                                                       
                                                                        action |= wm_handlers_do(C, event, &ar->handlers);
 
-                                                                       doit |= (BLI_in_rcti(&ar->winrct, event->x, event->y));
+                                                                       /* fileread case (python), [#29489] */
+                                                                       if(CTX_wm_window(C)==NULL)
+                                                                               return;
 
+                                                                       doit |= (BLI_in_rcti(&ar->winrct, event->x, event->y));
+                                                                       
                                                                        if(action & WM_HANDLER_BREAK)
                                                                                break;
                                                                }
@@ -1677,20 +1856,23 @@ void wm_event_do_handlers(bContext *C)
 
                                                CTX_wm_region_set(C, NULL);
 
-                                               if((action & WM_HANDLER_BREAK) == 0)
+                                               if((action & WM_HANDLER_BREAK) == 0) {
+                                                       wm_region_mouse_co(C, event); /* only invalidates event->mval in this case */
                                                        action |= wm_handlers_do(C, event, &sa->handlers);
-
+                                               }
                                                CTX_wm_area_set(C, NULL);
 
                                                /* NOTE: do not escape on WM_HANDLER_BREAK, mousemove needs handled for previous area */
                                        }
                                }
-
+                               
                                if((action & WM_HANDLER_BREAK) == 0) {
                                        /* also some non-modal handlers need active area/region */
                                        CTX_wm_area_set(C, area_event_inside(C, event->x, event->y));
                                        CTX_wm_region_set(C, region_event_inside(C, event->x, event->y));
 
+                                       wm_region_mouse_co(C, event);
+
                                        action |= wm_handlers_do(C, event, &win->handlers);
 
                                        /* fileread case */
@@ -1703,9 +1885,12 @@ void wm_event_do_handlers(bContext *C)
                                if(doit && win->screen && win->screen->subwinactive != win->screen->mainwin) {
                                        win->eventstate->prevx= event->x;
                                        win->eventstate->prevy= event->y;
+                                       //printf("win->eventstate->prev = %d %d\n", event->x, event->y);
                                }
+                               else
+                                       ;//printf("not setting prev to %d %d\n", event->x, event->y);
                        }
-
+                       
                        /* store last event for this window */
                        /* mousemove and timer events don't overwrite last type */
                        if (event->type != MOUSEMOVE && !ISTIMER(event->type)) {
@@ -1740,21 +1925,25 @@ void wm_event_do_handlers(bContext *C)
                        /* 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 */
                if(win->addmousemove && win->eventstate) {
-                       wmEvent event= *(win->eventstate);
-                       event.type= MOUSEMOVE;
-                       event.prevx= event.x;
-                       event.prevy= event.y;
-                       wm_event_add(win, &event);
+                       wmEvent tevent= *(win->eventstate);
+                       //printf("adding MOUSEMOVE %d %d\n", tevent.x, tevent.y);
+                       tevent.type= MOUSEMOVE;
+                       tevent.prevx= tevent.x;
+                       tevent.prevy= tevent.y;
+                       wm_event_add(win, &tevent);
                        win->addmousemove= 0;
                }
-
+               
                CTX_wm_window_set(C, NULL);
        }
+
+       /* update key configuration after handling events */
+       WM_keyconfig_update(wm);
 }
 
 /* ********** filesector handling ************ */
@@ -1763,10 +1952,10 @@ void WM_event_fileselect_event(bContext *C, void *ophandle, int eventval)
 {
        /* add to all windows! */
        wmWindow *win;
-
+       
        for(win= CTX_wm_manager(C)->windows.first; win; win= win->next) {
                wmEvent event= *win->eventstate;
-
+               
                event.type= EVT_FILESELECT;
                event.val= eventval;
                event.customdata= ophandle;             // only as void pointer type check
@@ -1785,32 +1974,54 @@ void WM_event_fileselect_event(bContext *C, void *ophandle, int eventval)
 
 void WM_event_add_fileselect(bContext *C, wmOperator *op)
 {
-       wmEventHandler *handler= MEM_callocN(sizeof(wmEventHandler), "fileselect handler");
+       wmEventHandler *handler, *handlernext;
        wmWindow *win= CTX_wm_window(C);
        int full= 1;    // XXX preset?
 
+       /* only allow 1 file selector open per window */
+       for(handler= win->modalhandlers.first; handler; handler=handlernext) {
+               handlernext= handler->next;
+               
+               if(handler->type == WM_HANDLER_FILESELECT) {
+                       if(handler->op)
+                               WM_operator_free(handler->op);
+                       BLI_remlink(&win->modalhandlers, handler);
+                       wm_event_free_handler(handler);
+               }
+       }
+       
+       handler = MEM_callocN(sizeof(wmEventHandler), "fileselect handler");
+       
        handler->type= WM_HANDLER_FILESELECT;
        handler->op= op;
        handler->op_area= CTX_wm_area(C);
        handler->op_region= CTX_wm_region(C);
        handler->filescreen= CTX_wm_screen(C);
-
+       
        BLI_addhead(&win->modalhandlers, handler);
+       
+       /* 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 */
+       }
 
        WM_event_fileselect_event(C, op, full?EVT_FILESELECT_FULL_OPEN:EVT_FILESELECT_OPEN);
 }
 
+#if 0
 /* lets not expose struct outside wm? */
-void WM_event_set_handler_flag(wmEventHandler *handler, int flag)
+static void WM_event_set_handler_flag(wmEventHandler *handler, int flag)
 {
        handler->flag= flag;
 }
+#endif
 
 wmEventHandler *WM_event_add_modal_handler(bContext *C, wmOperator *op)
 {
        wmEventHandler *handler= MEM_callocN(sizeof(wmEventHandler), "event modal handler");
        wmWindow *win= CTX_wm_window(C);
-
+       
        /* operator was part of macro */
        if(op->opm) {
                /* give the mother macro to the handler */
@@ -1820,10 +2031,10 @@ wmEventHandler *WM_event_add_modal_handler(bContext *C, wmOperator *op)
        }
        else
                handler->op= op;
-
+       
        handler->op_area= CTX_wm_area(C);               /* means frozen screen context for modal handlers! */
        handler->op_region= CTX_wm_region(C);
-
+       
        BLI_addhead(&win->modalhandlers, handler);
 
        return handler;
@@ -1842,7 +2053,7 @@ wmEventHandler *WM_event_add_keymap_handler(ListBase *handlers, wmKeyMap *keymap
        for(handler= handlers->first; handler; handler= handler->next)
                if(handler->keymap==keymap)
                        return handler;
-
+       
        handler= MEM_callocN(sizeof(wmEventHandler), "event keymap handler");
        BLI_addtail(handlers, handler);
        handler->keymap= keymap;
@@ -1851,23 +2062,23 @@ wmEventHandler *WM_event_add_keymap_handler(ListBase *handlers, wmKeyMap *keymap
 }
 
 /* priorities not implemented yet, for time being just insert in begin of list */
-wmEventHandler *WM_event_add_keymap_handler_priority(ListBase *handlers, wmKeyMap *keymap, int priority)
+wmEventHandler *WM_event_add_keymap_handler_priority(ListBase *handlers, wmKeyMap *keymap, int UNUSED(priority))
 {
        wmEventHandler *handler;
-
+       
        WM_event_remove_keymap_handler(handlers, keymap);
-
+       
        handler= MEM_callocN(sizeof(wmEventHandler), "event keymap handler");
        BLI_addhead(handlers, handler);
        handler->keymap= keymap;
-
+       
        return handler;
 }
 
 wmEventHandler *WM_event_add_keymap_handler_bb(ListBase *handlers, wmKeyMap *keymap, rcti *bblocal, rcti *bbwin)
 {
        wmEventHandler *handler= WM_event_add_keymap_handler(handlers, keymap);
-
+       
        if(handler) {
                handler->bblocal= bblocal;
                handler->bbwin= bbwin;
@@ -1878,7 +2089,7 @@ wmEventHandler *WM_event_add_keymap_handler_bb(ListBase *handlers, wmKeyMap *key
 void WM_event_remove_keymap_handler(ListBase *handlers, wmKeyMap *keymap)
 {
        wmEventHandler *handler;
-
+       
        for(handler= handlers->first; handler; handler= handler->next) {
                if(handler->keymap==keymap) {
                        BLI_remlink(handlers, handler);
@@ -1897,20 +2108,27 @@ wmEventHandler *WM_event_add_ui_handler(const bContext *C, ListBase *handlers, w
        handler->ui_area= (C)? CTX_wm_area(C): NULL;
        handler->ui_region= (C)? CTX_wm_region(C): NULL;
        handler->ui_menu= (C)? CTX_wm_menu(C): NULL;
-
+       
        BLI_addhead(handlers, handler);
-
+       
        return handler;
 }
 
-void WM_event_remove_ui_handler(ListBase *handlers, wmUIHandlerFunc func, wmUIHandlerRemoveFunc remove, void *userdata)
+/* 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 func, wmUIHandlerRemoveFunc remove, void *userdata, int postpone)
 {
        wmEventHandler *handler;
-
+       
        for(handler= handlers->first; handler; handler= handler->next) {
                if(handler->ui_handle == func && handler->ui_remove == remove && handler->ui_userdata == userdata) {
-                       BLI_remlink(handlers, handler);
-                       wm_event_free_handler(handler);
+                       /* handlers will be freed in wm_handlers_do() */
+                       if(postpone) {
+                               handler->flag |= WM_HANDLER_DO_FREE;
+                       }
+                       else {
+                               BLI_remlink(handlers, handler);
+                               wm_event_free_handler(handler);
+                       }
                        break;
                }
        }
@@ -1924,13 +2142,13 @@ wmEventHandler *WM_event_add_dropbox_handler(ListBase *handlers, ListBase *dropb
        for(handler= handlers->first; handler; handler= handler->next)
                if(handler->dropboxes==dropboxes)
                        return handler;
-
+       
        handler= MEM_callocN(sizeof(wmEventHandler), "dropbox handler");
-
+       
        /* dropbox stored static, no free or copy */
        handler->dropboxes= dropboxes;
        BLI_addhead(handlers, handler);
-
+       
        return handler;
 }
 
@@ -1950,37 +2168,54 @@ void WM_event_remove_area_handler(ListBase *handlers, void *area)
        }
 }
 
-void WM_event_remove_handler(ListBase *handlers, wmEventHandler *handler)
+#if 0
+static void WM_event_remove_handler(ListBase *handlers, wmEventHandler *handler)
 {
        BLI_remlink(handlers, handler);
        wm_event_free_handler(handler);
 }
+#endif
 
 void WM_event_add_mousemove(bContext *C)
 {
        wmWindow *window= CTX_wm_window(C);
-
+       
        window->addmousemove= 1;
 }
 
 /* for modal callbacks, check configuration for how to interpret exit with tweaks  */
 int WM_modal_tweak_exit(wmEvent *evt, int tweak_event)
 {
-       /* user preset or keymap? dunno... */
-       // XXX WTH is this?
-       int tweak_modal= (U.flag & USER_RELEASECONFIRM)==0;
-
-       switch(tweak_event) {
-               case EVT_TWEAK_L:
-               case EVT_TWEAK_M:
-               case EVT_TWEAK_R:
-                       if(evt->val==tweak_modal)
-                               return 1;
-               default:
-                       /* this case is when modal callcback didnt get started with a tweak */
-                       if(evt->val)
+       /* if the release-confirm userpref setting is enabled, 
+        * tweak events can be cancelled when mouse is released
+        */
+       if (U.flag & USER_RELEASECONFIRM) {
+               /* option on, so can exit with km-release */
+               if (evt->val == KM_RELEASE) {
+                       switch (tweak_event) {
+                               case EVT_TWEAK_L:
+                               case EVT_TWEAK_M:
+                               case EVT_TWEAK_R:
+                                       return 1;
+                       }
+               }
+               else {
+                       /* if the initial event wasn't a tweak event then
+                        * ignore USER_RELEASECONFIRM setting: see [#26756] */
+                       if(ELEM3(tweak_event, EVT_TWEAK_L, EVT_TWEAK_M, EVT_TWEAK_R) == 0) {
                                return 1;
+                       }
+               }
        }
+       else {
+               /* this is fine as long as not doing km-release, otherwise
+                * some items (i.e. markers) being tweaked may end up getting
+                * dropped all over
+                */
+               if (evt->val != KM_RELEASE)
+                       return 1;
+       }
+       
        return 0;
 }
 
@@ -2003,7 +2238,7 @@ static int convert_key(GHOST_TKey key)
                        case GHOST_kKeyLinefeed:                return LINEFEEDKEY;
                        case GHOST_kKeyClear:                   return 0;
                        case GHOST_kKeyEnter:                   return RETKEY;
-
+                               
                        case GHOST_kKeyEsc:                             return ESCKEY;
                        case GHOST_kKeySpace:                   return SPACEKEY;
                        case GHOST_kKeyQuote:                   return QUOTEKEY;
@@ -2011,114 +2246,118 @@ static int convert_key(GHOST_TKey key)
                        case GHOST_kKeyMinus:                   return MINUSKEY;
                        case GHOST_kKeyPeriod:                  return PERIODKEY;
                        case GHOST_kKeySlash:                   return SLASHKEY;
-
+                               
                        case GHOST_kKeySemicolon:               return SEMICOLONKEY;
                        case GHOST_kKeyEqual:                   return EQUALKEY;
-
+                               
                        case GHOST_kKeyLeftBracket:             return LEFTBRACKETKEY;
                        case GHOST_kKeyRightBracket:    return RIGHTBRACKETKEY;
                        case GHOST_kKeyBackslash:               return BACKSLASHKEY;
                        case GHOST_kKeyAccentGrave:             return ACCENTGRAVEKEY;
-
+                               
                        case GHOST_kKeyLeftShift:               return LEFTSHIFTKEY;
                        case GHOST_kKeyRightShift:              return RIGHTSHIFTKEY;
                        case GHOST_kKeyLeftControl:             return LEFTCTRLKEY;
                        case GHOST_kKeyRightControl:    return RIGHTCTRLKEY;
-                       case GHOST_kKeyCommand:                 return COMMANDKEY;
+                       case GHOST_kKeyOS:                              return OSKEY;
                        case GHOST_kKeyLeftAlt:                 return LEFTALTKEY;
                        case GHOST_kKeyRightAlt:                return RIGHTALTKEY;
-
+                               
                        case GHOST_kKeyCapsLock:                return CAPSLOCKKEY;
                        case GHOST_kKeyNumLock:                 return 0;
                        case GHOST_kKeyScrollLock:              return 0;
-
+                               
                        case GHOST_kKeyLeftArrow:               return LEFTARROWKEY;
                        case GHOST_kKeyRightArrow:              return RIGHTARROWKEY;
                        case GHOST_kKeyUpArrow:                 return UPARROWKEY;
                        case GHOST_kKeyDownArrow:               return DOWNARROWKEY;
-
+                               
                        case GHOST_kKeyPrintScreen:             return 0;
                        case GHOST_kKeyPause:                   return PAUSEKEY;
-
+                               
                        case GHOST_kKeyInsert:                  return INSERTKEY;
                        case GHOST_kKeyDelete:                  return DELKEY;
                        case GHOST_kKeyHome:                    return HOMEKEY;
                        case GHOST_kKeyEnd:                             return ENDKEY;
                        case GHOST_kKeyUpPage:                  return PAGEUPKEY;
                        case GHOST_kKeyDownPage:                return PAGEDOWNKEY;
-
+                               
                        case GHOST_kKeyNumpadPeriod:    return PADPERIOD;
                        case GHOST_kKeyNumpadEnter:             return PADENTER;
                        case GHOST_kKeyNumpadPlus:              return PADPLUSKEY;
                        case GHOST_kKeyNumpadMinus:             return PADMINUS;
                        case GHOST_kKeyNumpadAsterisk:  return PADASTERKEY;
                        case GHOST_kKeyNumpadSlash:             return PADSLASHKEY;
-
+                               
                        case GHOST_kKeyGrLess:              return GRLESSKEY; 
-
+                       
+                       case GHOST_kKeyMediaPlay:               return MEDIAPLAY;
+                       case GHOST_kKeyMediaStop:               return MEDIASTOP;
+                       case GHOST_kKeyMediaFirst:              return MEDIAFIRST;
+                       case GHOST_kKeyMediaLast:               return MEDIALAST;
+                       
                        default:
                                return UNKNOWNKEY;      /* GHOST_kKeyUnknown */
                }
        }
 }
 
-#if 0
 /* adds customdata to event */
 static void update_tablet_data(wmWindow *win, wmEvent *event)
 {
        const GHOST_TabletData *td= GHOST_GetTabletData(win->ghostwin);
-
+       
        /* if there's tablet data from an active tablet device then add it */
        if ((td != NULL) && td->Active != GHOST_kTabletModeNone) {
                struct wmTabletData *wmtab= MEM_mallocN(sizeof(wmTabletData), "customdata tablet");
-
+               
                wmtab->Active = (int)td->Active;
                wmtab->Pressure = td->Pressure;
                wmtab->Xtilt = td->Xtilt;
                wmtab->Ytilt = td->Ytilt;
-
+               
                event->custom= EVT_DATA_TABLET;
                event->customdata= wmtab;
                event->customdatafree= 1;
        } 
 }
-#endif
-
-/* adds customdata to event */
-static void attach_tablet_data(wmEvent* event, const GHOST_TabletData* ghost)
-{
-       if (ghost->Active != GHOST_kTabletModeNone)
-               {
-               wmTabletData* data = MEM_mallocN(sizeof(wmTabletData), "customdata tablet");
-       
-               data->Active = ghost->Active;
-               data->Pressure = ghost->Pressure;
-               data->Xtilt = ghost->Xtilt;
-               data->Ytilt = ghost->Ytilt;
-       
-               event->custom = EVT_DATA_TABLET;
-               event->customdata = data;
-               event->customdatafree = 1;
-
-               printf("+ pressure = %.2f   tilt = %.2f %2f\n", data->Pressure, data->Xtilt, data->Ytilt);
-               }
-}
 
 /* adds customdata to event */
 static void attach_ndof_data(wmEvent* event, const GHOST_TEventNDOFMotionData* ghost)
 {
        wmNDOFMotionData* data = MEM_mallocN(sizeof(wmNDOFMotionData), "customdata NDOF");
 
-       data->tx = ghost->tx;
-       data->ty = ghost->ty;
-       data->tz = ghost->tz;
+       const float s = U.ndof_sensitivity;
 
-       data->rx = ghost->rx;
-       data->ry = ghost->ry;
-       data->rz = ghost->rz;
+       data->tvec[0]= s * ghost->tx;
+
+       data->rvec[0]= s * ghost->rx;
+       data->rvec[1]= s * ghost->ry;
+       data->rvec[2]= s * ghost->rz;
+
+       if (U.ndof_flag & NDOF_ZOOM_UPDOWN)
+               {
+               // rotate so Y is where Z was (maintain handed-ness)
+               data->tvec[1]= s * ghost->tz;
+               data->tvec[2]= s * -ghost->ty;
+
+               // should this affect rotation also?
+               // initial guess is 'yes', but get user feedback immediately!
+#if 0  // after turning this on, my guess becomes 'no'
+               data->rvec[1]= s * ghost->rz;
+               data->rvec[2]= s * ghost->ry;
+#endif
+               }
+       else
+               {
+               data->tvec[1]= s * ghost->ty;
+               data->tvec[2]= s * ghost->tz;
+               }
 
        data->dt = ghost->dt;
 
+       data->progress = (wmProgress) ghost->progress;
+
        event->custom = EVT_DATA_NDOF_MOTION;
        event->customdata = data;
        event->customdatafree = 1;
@@ -2127,35 +2366,35 @@ static void attach_ndof_data(wmEvent* event, const GHOST_TEventNDOFMotionData* g
 /* imperfect but probably usable... draw/enable drags to other windows */
 static wmWindow *wm_event_cursor_other_windows(wmWindowManager *wm, wmWindow *win, wmEvent *evt)
 {
-       short mx= evt->x, my= evt->y;
-
+       int mx= evt->x, my= evt->y;
+       
        if(wm->windows.first== wm->windows.last)
                return NULL;
-
+       
        /* top window bar... */
        if(mx<0 || my<0 || mx>win->sizex || my>win->sizey+30) { 
                wmWindow *owin;
                wmEventHandler *handler;
-
+               
                /* let's skip windows having modal handlers now */
                /* potential XXX ugly... I wouldn't have added a modalhandlers list (introduced in rev 23331, ton) */
                for(handler= win->modalhandlers.first; handler; handler= handler->next)
                        if(handler->ui_handle || handler->op)
                                return NULL;
-
+               
                /* to desktop space */
-               mx+= win->posx;
-               my+= win->posy;
-
+               mx += (int)win->posx;
+               my += (int)win->posy;
+               
                /* check other windows to see if it has mouse inside */
                for(owin= wm->windows.first; owin; owin= owin->next) {
-
+                       
                        if(owin!=win) {
                                if(mx-owin->posx >= 0 && my-owin->posy >= 0 &&
                                   mx-owin->posx <= owin->sizex && my-owin->posy <= owin->sizey) {
-                                       evt->x= mx-owin->posx;
-                                       evt->y= my-owin->posy;
-
+                                       evt->x= mx - (int)owin->posx;
+                                       evt->y= my - (int)owin->posy;
+                                       
                                        return owin;
                                }
                        }
@@ -2165,62 +2404,57 @@ static wmWindow *wm_event_cursor_other_windows(wmWindowManager *wm, wmWindow *wi
 }
 
 /* windows store own event queues, no bContext here */
-/* time is in 1000s of seconds (or milliseconds?), from ghost */
-void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int time, void *customdata)
+/* time is in 1000s of seconds, from ghost */
+void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int UNUSED(time), void *customdata)
 {
        wmWindow *owin;
        wmEvent event, *evt= win->eventstate;
 
        /* initialize and copy state (only mouse x y and modifiers) */
        event= *evt;
-
+       
        switch (type) {
                /* mouse move */
                case GHOST_kEventCursorMove: {
                        if(win->active) {
                                GHOST_TEventCursorData *cd= customdata;
                                wmEvent *lastevent= win->queue.last;
-
-#if defined(__APPLE__) && defined(GHOST_COCOA)
-                               //Cocoa already uses coordinates with y=0 at bottom, and returns inwindow coordinates on mouse moved event
-                               evt->x= cd->x;
-                               evt->y= cd->y;
-#else
                                int cx, cy;
-
+                               
                                GHOST_ScreenToClient(win->ghostwin, cd->x, cd->y, &cx, &cy);
                                evt->x= cx;
                                evt->y= (win->sizey-1) - cy;
-#endif
-
+                               
                                event.x= evt->x;
                                event.y= evt->y;
 
                                event.type= MOUSEMOVE;
 
                                /* some painting operators want accurate mouse events, they can
-                                  handle inbetween mouse move moves, others can happily ignore
+                                  handle in between mouse move moves, others can happily ignore
                                   them for better performance */
                                if(lastevent && lastevent->type == MOUSEMOVE)
                                        lastevent->type = INBETWEEN_MOUSEMOVE;
 
-                               attach_tablet_data(&event, &(cd->tablet));
-                               // update_tablet_data(win, &event);
+                               update_tablet_data(win, &event);
                                wm_event_add(win, &event);
 
+                               //printf("sending MOUSEMOVE %d %d\n", event.x, event.y);
+                               
                                /* 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= *(owin->eventstate);
-
+                                       
                                        oevent.x=owin->eventstate->x= event.x;
                                        oevent.y=owin->eventstate->y= event.y;
                                        oevent.type= MOUSEMOVE;
-
-                                       // update_tablet_data(owin, &oevent);
+                                       
+                                       update_tablet_data(owin, &oevent);
                                        wm_event_add(owin, &oevent);
                                }
+                               
                        }
                        break;
                }
@@ -2238,24 +2472,19 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int t
                                        event.type= MOUSEPAN;
                                        break;
                        }
-#if defined(__APPLE__) && defined(GHOST_COCOA)
-                       //Cocoa already uses coordinates with y=0 at bottom, and returns inwindow coordinates on mouse moved event
-                       event.x= evt->x = pd->x;
-                       event.y = evt->y = pd->y;
-#else
+
                        {
-                       int cx, cy;
-                       GHOST_ScreenToClient(win->ghostwin, pd->x, pd->y, &cx, &cy);
-                       event.x= evt->x= cx;
-                       event.y= evt->y= (win->sizey-1) - cy;
+                               int cx, cy;
+                               GHOST_ScreenToClient(win->ghostwin, pd->x, pd->y, &cx, &cy);
+                               event.x= evt->x= cx;
+                               event.y= evt->y= (win->sizey-1) - cy;
                        }
-#endif
+
                        // Use prevx/prevy so we can calculate the delta later
                        event.prevx= event.x - pd->deltaX;
-                       event.prevy= event.y - pd->deltaY;
-
-                       // [mce] tablet never sends trackpad events.
-                       // update_tablet_data(win, &event);
+                       event.prevy= event.y - (-pd->deltaY);
+                       
+                       update_tablet_data(win, &event);
                        wm_event_add(win, &event);
                        break;
                }
@@ -2275,27 +2504,35 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int t
                                event.type= BUTTON5MOUSE;
                        else
                                event.type= MIDDLEMOUSE;
+                       
+                       if(win->active==0) {
+                               int cx, cy;
+                               
+                               /* entering window, update mouse pos. (ghost sends win-activate *after* the mouseclick in window!) */
+                               wm_get_cursor_position(win, &cx, &cy);
 
+                               event.x= evt->x= cx;
+                               event.y= evt->y= cy;
+                       }
+                       
                        /* 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);
-
+                               
                                oevent.x= event.x;
                                oevent.y= event.y;
                                oevent.type= event.type;
                                oevent.val= event.val;
-
-                               attach_tablet_data(&oevent, &(bd->tablet));
-                               // update_tablet_data(owin, &oevent);
+                               
+                               update_tablet_data(owin, &oevent);
                                wm_event_add(owin, &oevent);
                        }
                        else {
-                               attach_tablet_data(&event, &(bd->tablet));
-                               // update_tablet_data(win, &event);
+                               update_tablet_data(win, &event);
                                wm_event_add(win, &event);
                        }
-
+                       
                        break;
                }
                /* keyboard */
@@ -2305,11 +2542,11 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int t
                        event.type= convert_key(kd->key);
                        event.ascii= kd->ascii;
                        event.val= (type==GHOST_kEventKeyDown)?KM_PRESS:KM_RELEASE;
-
+                       
                        /* exclude arrow keys, esc, etc from text input */
                        if(type==GHOST_kEventKeyUp || (event.ascii<32 && event.ascii>0))
                                event.ascii= '\0';
-
+                       
                        /* modifiers */
                        if (event.type==LEFTSHIFTKEY || event.type==RIGHTSHIFTKEY) {
                                event.shift= evt->shift= (event.val==KM_PRESS);
@@ -2326,7 +2563,7 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int t
                                if(event.val==KM_PRESS && (evt->ctrl || evt->shift || evt->oskey))
                                   event.alt= evt->alt = 3;             // define?
                        } 
-                       else if (event.type==COMMANDKEY) {
+                       else if (event.type==OSKEY) {
                                event.oskey= evt->oskey= (event.val==KM_PRESS);
                                if(event.val==KM_PRESS && (evt->ctrl || evt->alt || evt->shift))
                                   event.oskey= evt->oskey = 3;         // define?
@@ -2344,30 +2581,29 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int t
                           key we don't want the key modifier */
                        if(event.keymodifier == event.type)
                                event.keymodifier= 0;
-
+                       
                        /* if test_break set, it catches this. XXX Keep global for now? */
                        if(event.type==ESCKEY)
                                G.afbreek= 1;
-
+                       
                        wm_event_add(win, &event);
-
+                       
                        break;
                }
-
+                       
                case GHOST_kEventWheel: {
                        GHOST_TEventWheelData* wheelData = customdata;
-
+                       
                        if (wheelData->z > 0)
                                event.type= WHEELUPMOUSE;
                        else
                                event.type= WHEELDOWNMOUSE;
-
+                       
                        event.val= KM_PRESS;
                        wm_event_add(win, &event);
-
+                       
                        break;
                }
-
                case GHOST_kEventTimer: {
                        event.type= TIMER;
                        event.custom= EVT_DATA_TIMER;
@@ -2382,6 +2618,8 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int t
                        attach_ndof_data(&event, customdata);
                        wm_event_add(win, &event);
 
+                       //printf("sending NDOF_MOTION, prev = %d %d\n", event.x, event.y);
+
                        break;
                }
 
@@ -2416,6 +2654,8 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int t
                        wm_event_add(win, &event);
 
                        break;
+                       
                }
+
        }
 }