Merging trunk up to r39145.
[blender.git] / source / blender / windowmanager / intern / wm_event_system.c
index 4268f192821e831d1ec561e2c41e49a89280c2f9..258d6bbc025fe95198069f6769a5d0999021de8a 100644 (file)
@@ -183,6 +183,7 @@ 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;
@@ -270,7 +271,7 @@ 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);
@@ -288,6 +289,11 @@ 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;
@@ -305,7 +311,10 @@ void wm_event_do_notifiers(bContext *C)
                        /* depsgraph & animation: update tagged datablocks */
 
                        /* copied to set's in scene_update_tagged_recursive() */
-                       win->screen->scene->customdata_mask= ED_viewedit_datamask(win->screen);
+                       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);
                }
@@ -331,7 +340,7 @@ static int wm_handler_ui_call(bContext *C, wmEventHandler *handler, wmEvent *eve
        int is_wheel= ELEM(event->type, WHEELUPMOUSE, WHEELDOWNMOUSE);
        int retval;
        
-       /* UI is quite agressive with swallowing events, like scrollwheel */
+       /* 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)
@@ -436,15 +445,19 @@ static void wm_operator_reports(bContext *C, wmOperator *op, int retval, int pop
                if(G.f & G_DEBUG)
                        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 */
-                       char *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);
@@ -457,7 +470,7 @@ static void wm_operator_reports(bContext *C, wmOperator *op, int retval, int pop
                WM_event_remove_timer(wm, NULL, wm_reports->reporttimer);
                
                /* Records time since last report was added */
-               wm_reports->reporttimer= WM_event_add_timer(wm, CTX_wm_window(C), TIMER, 0.05);
+               wm_reports->reporttimer= WM_event_add_timer(wm, CTX_wm_window(C), TIMERREPORT, 0.05);
                
                rti = MEM_callocN(sizeof(ReportTimerInfo), "ReportTimerInfo");
                wm_reports->reporttimer->customdata = rti;
@@ -648,6 +661,11 @@ 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;
+       }
 }
 
 static int wm_operator_invoke(bContext *C, wmOperatorType *ot, wmEvent *event, PointerRNA *properties, ReportList *reports, short poll_only)
@@ -693,7 +711,6 @@ static int wm_operator_invoke(bContext *C, wmOperatorType *ot, wmEvent *event, P
                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 */
@@ -714,6 +731,14 @@ static int wm_operator_invoke(bContext *C, wmOperatorType *ot, wmEvent *event, P
                                        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);
@@ -1264,16 +1289,23 @@ static int wm_handler_fileselect_call(bContext *C, ListBase *handlers, wmEventHa
                                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);
-                               else
-                                       ED_screen_full_newspace(C, sa, SPACE_FILE);     /* sets context */
-                               
+                               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 */
+                               }
+
+                               /* 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;
 
@@ -1432,10 +1464,13 @@ 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);
                
@@ -1514,9 +1549,21 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
                        }
                }
                
-               /* XXX 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 */
@@ -1530,7 +1577,7 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
                         *   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 itwill fallback to a single click.
+                        *   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 &&
@@ -1557,6 +1604,9 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
                        }
                }
        }
+       
+       if(action == (WM_HANDLER_BREAK|WM_HANDLER_MODAL))
+               wm_cursor_arrow_move(CTX_wm_window(C), event);
 
        return action;
 }
@@ -1566,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;
@@ -1685,6 +1735,9 @@ 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;
                
@@ -1706,7 +1759,7 @@ void wm_event_do_handlers(bContext *C)
                                        }
                                        
                                        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(CTX_data_main(C), scene, win->screen, 1);
@@ -1735,17 +1788,11 @@ void wm_event_do_handlers(bContext *C)
                        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));
                        
-                       /* XXX to solve, here screen handlers? */
-                       if(event->type==MOUSEMOVE) {
-                               /* state variables in screen, cursors, also used in wm_draw.c */
-                               ED_screen_set_subwinactive(win, event); 
-                               /* for regions having custom cursors */
-                               wm_paintcursor_test(C, event);
-                       }
-                       
                        /* 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);
                        
@@ -1764,6 +1811,17 @@ void wm_event_do_handlers(bContext *C)
                                ARegion *ar;
                                int doit= 0;
        
+                               /* Note: setting subwin active should be done here, after modal handlers have been done */
+                               if(event->type==MOUSEMOVE) {
+                                       /* 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)) {
                                                CTX_wm_area_set(C, sa);
@@ -1773,10 +1831,12 @@ void wm_event_do_handlers(bContext *C)
                                                                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);
                                                                        }
                                                                        
@@ -1796,9 +1856,10 @@ 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 */
@@ -1810,6 +1871,8 @@ void wm_event_do_handlers(bContext *C)
                                        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 */
@@ -1822,7 +1885,10 @@ 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 */
@@ -1865,6 +1931,7 @@ void wm_event_do_handlers(bContext *C)
                /* only add mousemove when queue was read entirely */
                if(win->addmousemove && win->eventstate) {
                        wmEvent tevent= *(win->eventstate);
+                       //printf("adding MOUSEMOVE %d %d\n", tevent.x, tevent.y);
                        tevent.type= MOUSEMOVE;
                        tevent.prevx= tevent.x;
                        tevent.prevy= tevent.y;
@@ -1874,6 +1941,9 @@ void wm_event_do_handlers(bContext *C)
                
                CTX_wm_window_set(C, NULL);
        }
+
+       /* update key configuration after handling events */
+       WM_keyconfig_update(wm);
 }
 
 /* ********** filesector handling ************ */
@@ -1939,11 +2009,13 @@ void WM_event_add_fileselect(bContext *C, wmOperator *op)
        WM_event_fileselect_event(C, op, full?EVT_FILESELECT_FULL_OPEN:EVT_FILESELECT_OPEN);
 }
 
+#if 0
 /* lets not expose struct outside wm? */
 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)
 {
@@ -2042,14 +2114,21 @@ wmEventHandler *WM_event_add_ui_handler(const bContext *C, ListBase *handlers, w
        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;
                }
        }
@@ -2089,11 +2168,13 @@ void WM_event_remove_area_handler(ListBase *handlers, void *area)
        }
 }
 
+#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)
 {
@@ -2118,6 +2199,13 @@ int WM_modal_tweak_exit(wmEvent *evt, int tweak_event)
                                        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
@@ -2234,10 +2322,51 @@ static void update_tablet_data(wmWindow *win, wmEvent *event)
        } 
 }
 
+/* adds customdata to event */
+static void attach_ndof_data(wmEvent* event, const GHOST_TEventNDOFMotionData* ghost)
+{
+       wmNDOFMotionData* data = MEM_mallocN(sizeof(wmNDOFMotionData), "customdata NDOF");
+
+       const float s = U.ndof_sensitivity;
+
+       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;
+}
+
 /* 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;
@@ -2254,8 +2383,8 @@ static wmWindow *wm_event_cursor_other_windows(wmWindowManager *wm, wmWindow *wi
                                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) {
@@ -2263,8 +2392,8 @@ static wmWindow *wm_event_cursor_other_windows(wmWindowManager *wm, wmWindow *wi
                        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;
                                }
@@ -2280,7 +2409,7 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int U
 {
        wmWindow *owin;
        wmEvent event, *evt= win->eventstate;
-       
+
        /* initialize and copy state (only mouse x y and modifiers) */
        event= *evt;
        
@@ -2290,18 +2419,11 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int U
                        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;
@@ -2316,6 +2438,8 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int U
 
                                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 */
@@ -2348,21 +2472,17 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int U
                                        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;
+                       event.prevy= event.y - (-pd->deltaY);
                        
                        update_tablet_data(win, &event);
                        wm_event_add(win, &event);
@@ -2385,6 +2505,16 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int U
                        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) {
@@ -2483,6 +2613,38 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int U
                        break;
                }
 
+               case GHOST_kEventNDOFMotion: {
+                       event.type = NDOF_MOTION;
+                       attach_ndof_data(&event, customdata);
+                       wm_event_add(win, &event);
+
+                       //printf("sending NDOF_MOTION, prev = %d %d\n", event.x, event.y);
+
+                       break;
+               }
+
+               case GHOST_kEventNDOFButton: {
+                       GHOST_TEventNDOFButtonData* e = customdata;
+
+                       event.type = NDOF_BUTTON_NONE + e->button;
+
+                       switch (e->action) {
+                               case GHOST_kPress:
+                                       event.val = KM_PRESS;
+                                       break;
+                               case GHOST_kRelease:
+                                       event.val = KM_RELEASE;
+                                       break;
+                               }
+
+                       event.custom = 0;
+                       event.customdata = NULL;
+
+                       wm_event_add(win, &event);
+
+                       break;
+               }
+
                case GHOST_kEventUnknown:
                case GHOST_kNumEventTypes:
                        break;