Map Alt + Tweaks to expected behaviours (rotate, zoom, move - LMB, RMB, MMB)

This way speed modifiers (shift/alt) works and overall speed is more constant

intern/ghost/GHOST_Types.h

@@ -412,7 +412,8 @@ typedef enum {
 	GHOST_kTrackpadEventScroll,
 	GHOST_kTrackpadEventRotate,
 	GHOST_kTrackpadEventSwipe, /* Reserved, not used for now */
-	GHOST_kTrackpadEventMagnify
+	GHOST_kTrackpadEventMagnify,
+	GHOST_kTrackpadEventUntouch,
 } GHOST_TTrackpadEventSubTypes;
 	
 

intern/ghost/intern/GHOST_SystemCocoa.mm

@@ -1396,6 +1396,8 @@ GHOST_TSuccess GHOST_SystemCocoa::handleMouseEvent(void *eventPtr)
 			break;
 		case NSEventTypeEndGesture:
 			m_hasMultiTouchTrackpad = 0;
+			pushEvent(new GHOST_EventTrackpad([event timestamp] * 1000, window, GHOST_kTrackpadEventUntouch, 0, 0,
+			                                  0, 0));
 			break;
 			
 		case NSScrollWheel:

release/scripts/presets/interaction/unreal_engine.py

@@ -0,0 +1,5 @@
+# Configuration Unreal Engine
+import bpy
+
+bpy.context.user_preferences.inputs.select_mouse = 'LEFT'
+bpy.context.user_preferences.inputs.walk_navigation.walk_speed = 20.0

release/scripts/presets/keyconfig/unreal_engine.py

@@ -0,0 +1,462 @@
+# Configuration Unreal Engine
+import bpy
+import os
+
+def kmi_props_setattr(kmi_props, attr, value):
+    try:
+        setattr(kmi_props, attr, value)
+    except AttributeError:
+        print("Warning: property '%s' not found in keymap item '%s'" %
+              (attr, kmi_props.__class__.__name__))
+    except Exception as e:
+        print("Warning: %r" % e)
+
+wm = bpy.context.window_manager
+kc = wm.keyconfigs.new(os.path.splitext(os.path.basename(__file__))[0])
+
+# Map View3D Walk Modal
+km = kc.keymaps.new('View3D Walk Modal', space_type='EMPTY', region_type='WINDOW', modal=True)
+
+kmi = km.keymap_items.new_modal('CANCEL', 'ESC', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('CANCEL', 'RIGHTMOUSE', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('CONFIRM', 'LEFTMOUSE', 'ANY', any=True)
+kmi = km.keymap_items.new_modal('CONFIRM', 'RET', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('CONFIRM', 'NUMPAD_ENTER', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('FAST_ENABLE', 'LEFT_SHIFT', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('FAST_DISABLE', 'LEFT_SHIFT', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('SLOW_ENABLE', 'LEFT_ALT', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('SLOW_DISABLE', 'LEFT_ALT', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('FORWARD', 'W', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('BACKWARD', 'S', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('LEFT', 'A', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('RIGHT', 'D', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('UP', 'E', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('DOWN', 'Q', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('FORWARD_STOP', 'W', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('BACKWARD_STOP', 'S', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('LEFT_STOP', 'A', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('RIGHT_STOP', 'D', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('UP_STOP', 'E', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('DOWN_STOP', 'Q', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('FORWARD', 'UP_ARROW', 'PRESS')
+kmi = km.keymap_items.new_modal('BACKWARD', 'DOWN_ARROW', 'PRESS')
+kmi = km.keymap_items.new_modal('LEFT', 'LEFT_ARROW', 'PRESS')
+kmi = km.keymap_items.new_modal('RIGHT', 'RIGHT_ARROW', 'PRESS')
+kmi = km.keymap_items.new_modal('FORWARD_STOP', 'UP_ARROW', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('BACKWARD_STOP', 'DOWN_ARROW', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('LEFT_STOP', 'LEFT_ARROW', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('RIGHT_STOP', 'RIGHT_ARROW', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('UP', 'NUMPAD_PLUS', 'PRESS')
+kmi = km.keymap_items.new_modal('DOWN', 'NUMPAD_MINUS', 'PRESS')
+kmi = km.keymap_items.new_modal('UP_STOP', 'NUMPAD_PLUS', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('DOWN_STOP', 'NUMPAD_MINUS', 'RELEASE', any=True)
+
+kmi = km.keymap_items.new_modal('GRAVITY_TOGGLE', 'TAB', 'PRESS')
+kmi = km.keymap_items.new_modal('GRAVITY_TOGGLE', 'G', 'PRESS')
+kmi = km.keymap_items.new_modal('JUMP', 'V', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('JUMP_STOP', 'V', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('TELEPORT', 'SPACE', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('TELEPORT', 'MIDDLEMOUSE', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('ACCELERATE', 'WHEELUPMOUSE', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('DECELERATE', 'WHEELDOWNMOUSE', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('CONFIRM', 'TRACKPADUNTOUCH', 'ANY', any=True)
+kmi = km.keymap_items.new_modal('CONFIRM', 'LEFTMOUSE', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('CONFIRM', 'RIGHTMOUSE', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('CONFIRM', 'MIDDLEMOUSE', 'RELEASE', any=True)
+
+
+# Map View3D Rotate Modal
+km = kc.keymaps.new('View3D Rotate Modal', space_type='EMPTY', region_type='WINDOW', modal=True)
+
+kmi = km.keymap_items.new_modal('CONFIRM', 'ESC', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('AXIS_SNAP_ENABLE', 'LEFT_ALT', 'PRESS', any=True)
+kmi = km.keymap_items.new_modal('AXIS_SNAP_DISABLE', 'LEFT_ALT', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('CONFIRM', 'LEFTMOUSE', 'RELEASE', any=True)
+
+
+# Map View3D Zoom Modal
+km = kc.keymaps.new('View3D Zoom Modal', space_type='EMPTY', region_type='WINDOW', modal=True)
+
+kmi = km.keymap_items.new_modal('CONFIRM', 'RIGHTMOUSE', 'RELEASE', any=True)
+kmi = km.keymap_items.new_modal('CONFIRM', 'ESC', 'PRESS', any=True)
+
+
+# Map 3D View
+km = kc.keymaps.new('3D View', space_type='VIEW_3D', region_type='WINDOW', modal=False)
+
+kmi = km.keymap_items.new('view3d.manipulator', 'LEFTMOUSE', 'PRESS', any=True)
+kmi_props_setattr(kmi.properties, 'release_confirm', True)
+kmi = km.keymap_items.new('view3d.cursor3d', 'ACTIONMOUSE', 'PRESS')
+kmi = km.keymap_items.new('view3d.rotate', 'EVT_TWEAK_L', 'ANY', alt=True)
+kmi = km.keymap_items.new('view3d.zoom', 'EVT_TWEAK_R', 'ANY', alt=True)
+kmi = km.keymap_items.new('view3d.move', 'EVT_TWEAK_M', 'ANY', alt=True)
+kmi = km.keymap_items.new('view3d.move', 'MIDDLEMOUSE', 'PRESS', shift=True)
+kmi = km.keymap_items.new('view3d.zoom', 'MIDDLEMOUSE', 'PRESS', ctrl=True)
+kmi = km.keymap_items.new('view3d.dolly', 'MIDDLEMOUSE', 'PRESS', shift=True, ctrl=True)
+kmi = km.keymap_items.new('view3d.view_selected', 'NUMPAD_PERIOD', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'use_all_regions', True)
+kmi = km.keymap_items.new('view3d.view_selected', 'F', 'PRESS')
+kmi_props_setattr(kmi.properties, 'use_all_regions', True)
+kmi = km.keymap_items.new('view3d.view_selected', 'NUMPAD_PERIOD', 'PRESS')
+kmi_props_setattr(kmi.properties, 'use_all_regions', False)
+kmi = km.keymap_items.new('view3d.view_lock_to_active', 'NUMPAD_PERIOD', 'PRESS', shift=True)
+kmi = km.keymap_items.new('view3d.view_lock_clear', 'NUMPAD_PERIOD', 'PRESS', alt=True)
+kmi = km.keymap_items.new('view3d.navigate', 'F', 'PRESS', shift=True)
+kmi = km.keymap_items.new('view3d.smoothview', 'TIMER1', 'ANY', any=True)
+kmi = km.keymap_items.new('view3d.walk', 'TRACKPADPAN', 'ANY')
+kmi = km.keymap_items.new('view3d.walk', 'EVT_TWEAK_R', 'ANY')
+kmi_props_setattr(kmi.properties, 'mouse_mode', 'LOOK_AROUND')
+kmi = km.keymap_items.new('view3d.walk', 'EVT_TWEAK_L', 'ANY')
+kmi_props_setattr(kmi.properties, 'mouse_mode', 'MOVE_HORIZONTAL')
+kmi = km.keymap_items.new('view3d.walk', 'EVT_TWEAK_M', 'ANY')
+kmi_props_setattr(kmi.properties, 'mouse_mode', 'MOVE_VERTICAL')
+
+# simple arrows
+kmi = km.keymap_items.new('view3d.walk', 'UP_ARROW', 'PRESS')
+kmi_props_setattr(kmi.properties, 'initial_direction', 'MOVE_FORWARD')
+kmi_props_setattr(kmi.properties, 'mouse_mode', 'NONE')
+kmi = km.keymap_items.new('view3d.walk', 'DOWN_ARROW', 'PRESS')
+kmi_props_setattr(kmi.properties, 'initial_direction', 'MOVE_BACKWARD')
+kmi_props_setattr(kmi.properties, 'mouse_mode', 'NONE')
+kmi = km.keymap_items.new('view3d.walk', 'LEFT_ARROW', 'PRESS')
+kmi_props_setattr(kmi.properties, 'initial_direction', 'MOVE_LEFT')
+kmi_props_setattr(kmi.properties, 'mouse_mode', 'NONE')
+kmi = km.keymap_items.new('view3d.walk', 'RIGHT_ARROW', 'PRESS')
+kmi_props_setattr(kmi.properties, 'initial_direction', 'MOVE_RIGHT')
+kmi_props_setattr(kmi.properties, 'mouse_mode', 'NONE')
+kmi = km.keymap_items.new('view3d.walk', 'NUMPAD_PLUS', 'PRESS')
+kmi_props_setattr(kmi.properties, 'initial_direction', 'MOVE_UP')
+kmi_props_setattr(kmi.properties, 'mouse_mode', 'NONE')
+kmi = km.keymap_items.new('view3d.walk', 'NUMPAD_MINUS', 'PRESS')
+kmi_props_setattr(kmi.properties, 'initial_direction', 'MOVE_DOWN')
+kmi_props_setattr(kmi.properties, 'mouse_mode', 'NONE')
+
+kmi = km.keymap_items.new('view3d.rotate', 'MOUSEROTATE', 'ANY')
+kmi = km.keymap_items.new('view3d.move', 'TRACKPADPAN', 'ANY', shift=True)
+kmi = km.keymap_items.new('view3d.zoom', 'TRACKPADZOOM', 'ANY')
+kmi = km.keymap_items.new('view3d.zoom', 'TRACKPADPAN', 'ANY', ctrl=True)
+#kmi = km.keymap_items.new('view3d.zoom', 'NUMPAD_PLUS', 'PRESS')
+#kmi_props_setattr(kmi.properties, 'delta', 1)
+#kmi = km.keymap_items.new('view3d.zoom', 'NUMPAD_MINUS', 'PRESS')
+#kmi_props_setattr(kmi.properties, 'delta', -1)
+kmi = km.keymap_items.new('view3d.zoom', 'EQUAL', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'delta', 1)
+kmi = km.keymap_items.new('view3d.zoom', 'MINUS', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'delta', -1)
+kmi = km.keymap_items.new('view3d.zoom', 'WHEELINMOUSE', 'PRESS')
+kmi_props_setattr(kmi.properties, 'delta', 1)
+kmi = km.keymap_items.new('view3d.zoom', 'WHEELOUTMOUSE', 'PRESS')
+kmi_props_setattr(kmi.properties, 'delta', -1)
+kmi = km.keymap_items.new('view3d.dolly', 'NUMPAD_PLUS', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'delta', 1)
+kmi = km.keymap_items.new('view3d.dolly', 'NUMPAD_MINUS', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'delta', -1)
+kmi = km.keymap_items.new('view3d.dolly', 'EQUAL', 'PRESS', shift=True, ctrl=True)
+kmi_props_setattr(kmi.properties, 'delta', 1)
+kmi = km.keymap_items.new('view3d.dolly', 'MINUS', 'PRESS', shift=True, ctrl=True)
+kmi_props_setattr(kmi.properties, 'delta', -1)
+kmi = km.keymap_items.new('view3d.zoom_camera_1_to_1', 'NUMPAD_ENTER', 'PRESS', shift=True)
+kmi = km.keymap_items.new('view3d.view_center_camera', 'HOME', 'PRESS')
+kmi = km.keymap_items.new('view3d.view_center_lock', 'HOME', 'PRESS')
+kmi = km.keymap_items.new('view3d.view_center_cursor', 'HOME', 'PRESS', alt=True)
+kmi = km.keymap_items.new('view3d.view_center_pick', 'F', 'PRESS', alt=True)
+kmi = km.keymap_items.new('view3d.view_all', 'HOME', 'PRESS')
+kmi_props_setattr(kmi.properties, 'center', False)
+kmi = km.keymap_items.new('view3d.view_all', 'HOME', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'use_all_regions', True)
+kmi_props_setattr(kmi.properties, 'center', False)
+kmi = km.keymap_items.new('view3d.view_all', 'C', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'center', True)
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NUMPAD_0', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'CAMERA')
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NUMPAD_1', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'FRONT')
+kmi = km.keymap_items.new('view3d.view_orbit', 'NUMPAD_2', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'ORBITDOWN')
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NUMPAD_3', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'RIGHT')
+kmi = km.keymap_items.new('view3d.view_orbit', 'NUMPAD_4', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'ORBITLEFT')
+kmi = km.keymap_items.new('view3d.view_persportho', 'NUMPAD_5', 'PRESS')
+kmi = km.keymap_items.new('view3d.view_orbit', 'NUMPAD_6', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'ORBITRIGHT')
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NUMPAD_7', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'TOP')
+kmi = km.keymap_items.new('view3d.view_orbit', 'NUMPAD_8', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'ORBITUP')
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NUMPAD_1', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'type', 'BACK')
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NUMPAD_3', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'type', 'LEFT')
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NUMPAD_7', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'type', 'BOTTOM')
+kmi = km.keymap_items.new('view3d.view_pan', 'NUMPAD_2', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'type', 'PANDOWN')
+kmi = km.keymap_items.new('view3d.view_pan', 'NUMPAD_4', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'type', 'PANLEFT')
+kmi = km.keymap_items.new('view3d.view_pan', 'NUMPAD_6', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'type', 'PANRIGHT')
+kmi = km.keymap_items.new('view3d.view_pan', 'NUMPAD_8', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'type', 'PANUP')
+kmi = km.keymap_items.new('view3d.view_roll', 'NUMPAD_4', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'angle', -0.2617993950843811)
+kmi = km.keymap_items.new('view3d.view_roll', 'NUMPAD_6', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'angle', 0.2617993950843811)
+kmi = km.keymap_items.new('view3d.view_pan', 'WHEELUPMOUSE', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'type', 'PANRIGHT')
+kmi = km.keymap_items.new('view3d.view_pan', 'WHEELDOWNMOUSE', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'type', 'PANLEFT')
+kmi = km.keymap_items.new('view3d.view_pan', 'WHEELUPMOUSE', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'type', 'PANUP')
+kmi = km.keymap_items.new('view3d.view_pan', 'WHEELDOWNMOUSE', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'type', 'PANDOWN')
+kmi = km.keymap_items.new('view3d.view_orbit', 'WHEELUPMOUSE', 'PRESS', ctrl=True, alt=True)
+kmi_props_setattr(kmi.properties, 'type', 'ORBITLEFT')
+kmi = km.keymap_items.new('view3d.view_orbit', 'WHEELDOWNMOUSE', 'PRESS', ctrl=True, alt=True)
+kmi_props_setattr(kmi.properties, 'type', 'ORBITRIGHT')
+kmi = km.keymap_items.new('view3d.view_orbit', 'WHEELUPMOUSE', 'PRESS', shift=True, alt=True)
+kmi_props_setattr(kmi.properties, 'type', 'ORBITUP')
+kmi = km.keymap_items.new('view3d.view_orbit', 'WHEELDOWNMOUSE', 'PRESS', shift=True, alt=True)
+kmi_props_setattr(kmi.properties, 'type', 'ORBITDOWN')
+kmi = km.keymap_items.new('view3d.view_roll', 'WHEELUPMOUSE', 'PRESS', shift=True, ctrl=True)
+kmi_props_setattr(kmi.properties, 'angle', -0.2617993950843811)
+kmi = km.keymap_items.new('view3d.view_roll', 'WHEELDOWNMOUSE', 'PRESS', shift=True, ctrl=True)
+kmi_props_setattr(kmi.properties, 'angle', 0.2617993950843811)
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NUMPAD_1', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'type', 'FRONT')
+kmi_props_setattr(kmi.properties, 'align_active', True)
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NUMPAD_3', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'type', 'RIGHT')
+kmi_props_setattr(kmi.properties, 'align_active', True)
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NUMPAD_7', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'type', 'TOP')
+kmi_props_setattr(kmi.properties, 'align_active', True)
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NUMPAD_1', 'PRESS', shift=True, ctrl=True)
+kmi_props_setattr(kmi.properties, 'type', 'BACK')
+kmi_props_setattr(kmi.properties, 'align_active', True)
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NUMPAD_3', 'PRESS', shift=True, ctrl=True)
+kmi_props_setattr(kmi.properties, 'type', 'LEFT')
+kmi_props_setattr(kmi.properties, 'align_active', True)
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NUMPAD_7', 'PRESS', shift=True, ctrl=True)
+kmi_props_setattr(kmi.properties, 'type', 'BOTTOM')
+kmi_props_setattr(kmi.properties, 'align_active', True)
+kmi = km.keymap_items.new('view3d.localview', 'NUMPAD_SLASH', 'PRESS')
+kmi = km.keymap_items.new('view3d.ndof_orbit_zoom', 'NDOF_MOTION', 'ANY')
+kmi = km.keymap_items.new('view3d.ndof_orbit', 'NDOF_MOTION', 'ANY', ctrl=True)
+kmi = km.keymap_items.new('view3d.ndof_pan', 'NDOF_MOTION', 'ANY', shift=True)
+kmi = km.keymap_items.new('view3d.ndof_all', 'NDOF_MOTION', 'ANY', shift=True, ctrl=True)
+kmi = km.keymap_items.new('view3d.view_selected', 'NDOF_BUTTON_FIT', 'PRESS')
+kmi_props_setattr(kmi.properties, 'use_all_regions', False)
+kmi = km.keymap_items.new('view3d.view_roll', 'NDOF_BUTTON_ROLL_CCW', 'PRESS')
+kmi_props_setattr(kmi.properties, 'angle', -1.5707963705062866)
+kmi = km.keymap_items.new('view3d.view_roll', 'NDOF_BUTTON_ROLL_CW', 'PRESS')
+kmi_props_setattr(kmi.properties, 'angle', 1.5707963705062866)
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NDOF_BUTTON_FRONT', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'FRONT')
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NDOF_BUTTON_BACK', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'BACK')
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NDOF_BUTTON_LEFT', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'LEFT')
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NDOF_BUTTON_RIGHT', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'RIGHT')
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NDOF_BUTTON_TOP', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'TOP')
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NDOF_BUTTON_BOTTOM', 'PRESS')
+kmi_props_setattr(kmi.properties, 'type', 'BOTTOM')
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NDOF_BUTTON_FRONT', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'type', 'FRONT')
+kmi_props_setattr(kmi.properties, 'align_active', True)
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NDOF_BUTTON_RIGHT', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'type', 'RIGHT')
+kmi_props_setattr(kmi.properties, 'align_active', True)
+kmi = km.keymap_items.new('view3d.viewnumpad', 'NDOF_BUTTON_TOP', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'type', 'TOP')
+kmi_props_setattr(kmi.properties, 'align_active', True)
+kmi = km.keymap_items.new('view3d.layers', 'ACCENT_GRAVE', 'PRESS')
+kmi_props_setattr(kmi.properties, 'nr', 0)
+kmi = km.keymap_items.new('view3d.layers', 'ONE', 'PRESS', any=True)
+kmi_props_setattr(kmi.properties, 'nr', 1)
+kmi = km.keymap_items.new('view3d.layers', 'TWO', 'PRESS', any=True)
+kmi_props_setattr(kmi.properties, 'nr', 2)
+kmi = km.keymap_items.new('view3d.layers', 'THREE', 'PRESS', any=True)
+kmi_props_setattr(kmi.properties, 'nr', 3)
+kmi = km.keymap_items.new('view3d.layers', 'FOUR', 'PRESS', any=True)
+kmi_props_setattr(kmi.properties, 'nr', 4)
+kmi = km.keymap_items.new('view3d.layers', 'FIVE', 'PRESS', any=True)
+kmi_props_setattr(kmi.properties, 'nr', 5)
+kmi = km.keymap_items.new('view3d.layers', 'SIX', 'PRESS', any=True)
+kmi_props_setattr(kmi.properties, 'nr', 6)
+kmi = km.keymap_items.new('view3d.layers', 'SEVEN', 'PRESS', any=True)
+kmi_props_setattr(kmi.properties, 'nr', 7)
+kmi = km.keymap_items.new('view3d.layers', 'EIGHT', 'PRESS', any=True)
+kmi_props_setattr(kmi.properties, 'nr', 8)
+kmi = km.keymap_items.new('view3d.layers', 'NINE', 'PRESS', any=True)
+kmi_props_setattr(kmi.properties, 'nr', 9)
+kmi = km.keymap_items.new('view3d.layers', 'ZERO', 'PRESS', any=True)
+kmi_props_setattr(kmi.properties, 'nr', 10)
+kmi = km.keymap_items.new('wm.context_toggle_enum', 'Z', 'PRESS')
+kmi_props_setattr(kmi.properties, 'data_path', 'space_data.viewport_shade')
+kmi_props_setattr(kmi.properties, 'value_1', 'SOLID')
+kmi_props_setattr(kmi.properties, 'value_2', 'WIREFRAME')
+kmi = km.keymap_items.new('wm.context_toggle_enum', 'Z', 'PRESS', alt=True)
+kmi_props_setattr(kmi.properties, 'data_path', 'space_data.viewport_shade')
+kmi_props_setattr(kmi.properties, 'value_1', 'SOLID')
+kmi_props_setattr(kmi.properties, 'value_2', 'TEXTURED')
+kmi = km.keymap_items.new('wm.context_toggle_enum', 'Z', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'data_path', 'space_data.viewport_shade')
+kmi_props_setattr(kmi.properties, 'value_1', 'SOLID')
+kmi_props_setattr(kmi.properties, 'value_2', 'RENDERED')
+kmi = km.keymap_items.new('view3d.select', 'SELECTMOUSE', 'PRESS')
+kmi_props_setattr(kmi.properties, 'extend', False)
+kmi_props_setattr(kmi.properties, 'deselect', False)
+kmi_props_setattr(kmi.properties, 'toggle', False)
+kmi_props_setattr(kmi.properties, 'center', False)
+kmi_props_setattr(kmi.properties, 'enumerate', False)
+kmi_props_setattr(kmi.properties, 'object', False)
+kmi = km.keymap_items.new('view3d.select', 'SELECTMOUSE', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'extend', False)
+kmi_props_setattr(kmi.properties, 'deselect', False)
+kmi_props_setattr(kmi.properties, 'toggle', True)
+kmi_props_setattr(kmi.properties, 'center', False)
+kmi_props_setattr(kmi.properties, 'enumerate', False)
+kmi_props_setattr(kmi.properties, 'object', False)
+kmi = km.keymap_items.new('view3d.select', 'SELECTMOUSE', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'extend', False)
+kmi_props_setattr(kmi.properties, 'deselect', False)
+kmi_props_setattr(kmi.properties, 'toggle', False)
+kmi_props_setattr(kmi.properties, 'center', True)
+kmi_props_setattr(kmi.properties, 'enumerate', False)
+kmi_props_setattr(kmi.properties, 'object', True)
+kmi = km.keymap_items.new('view3d.select', 'SELECTMOUSE', 'PRESS', alt=True)
+kmi_props_setattr(kmi.properties, 'extend', False)
+kmi_props_setattr(kmi.properties, 'deselect', False)
+kmi_props_setattr(kmi.properties, 'toggle', False)
+kmi_props_setattr(kmi.properties, 'center', False)
+kmi_props_setattr(kmi.properties, 'enumerate', True)
+kmi_props_setattr(kmi.properties, 'object', False)
+kmi = km.keymap_items.new('view3d.select', 'SELECTMOUSE', 'PRESS', shift=True, ctrl=True)
+kmi_props_setattr(kmi.properties, 'extend', True)
+kmi_props_setattr(kmi.properties, 'deselect', False)
+kmi_props_setattr(kmi.properties, 'toggle', True)
+kmi_props_setattr(kmi.properties, 'center', True)
+kmi_props_setattr(kmi.properties, 'enumerate', False)
+kmi_props_setattr(kmi.properties, 'object', False)
+kmi = km.keymap_items.new('view3d.select', 'SELECTMOUSE', 'PRESS', ctrl=True, alt=True)
+kmi_props_setattr(kmi.properties, 'extend', False)
+kmi_props_setattr(kmi.properties, 'deselect', False)
+kmi_props_setattr(kmi.properties, 'toggle', False)
+kmi_props_setattr(kmi.properties, 'center', True)
+kmi_props_setattr(kmi.properties, 'enumerate', True)
+kmi_props_setattr(kmi.properties, 'object', False)
+kmi = km.keymap_items.new('view3d.select', 'SELECTMOUSE', 'PRESS', shift=True, alt=True)
+kmi_props_setattr(kmi.properties, 'extend', False)
+kmi_props_setattr(kmi.properties, 'deselect', False)
+kmi_props_setattr(kmi.properties, 'toggle', True)
+kmi_props_setattr(kmi.properties, 'center', False)
+kmi_props_setattr(kmi.properties, 'enumerate', True)
+kmi_props_setattr(kmi.properties, 'object', False)
+kmi = km.keymap_items.new('view3d.select', 'SELECTMOUSE', 'PRESS', shift=True, ctrl=True, alt=True)
+kmi_props_setattr(kmi.properties, 'extend', False)
+kmi_props_setattr(kmi.properties, 'deselect', False)
+kmi_props_setattr(kmi.properties, 'toggle', True)
+kmi_props_setattr(kmi.properties, 'center', True)
+kmi_props_setattr(kmi.properties, 'enumerate', True)
+kmi_props_setattr(kmi.properties, 'object', False)
+kmi = km.keymap_items.new('view3d.select_border', 'B', 'PRESS')
+kmi = km.keymap_items.new('view3d.select_lasso', 'EVT_TWEAK_A', 'ANY', ctrl=True)
+kmi_props_setattr(kmi.properties, 'deselect', False)
+kmi = km.keymap_items.new('view3d.select_lasso', 'EVT_TWEAK_A', 'ANY', shift=True, ctrl=True)
+kmi_props_setattr(kmi.properties, 'deselect', True)
+kmi = km.keymap_items.new('view3d.select_circle', 'C', 'PRESS')
+kmi = km.keymap_items.new('view3d.clip_border', 'B', 'PRESS', alt=True)
+kmi = km.keymap_items.new('view3d.zoom_border', 'B', 'PRESS', shift=True)
+kmi = km.keymap_items.new('view3d.render_border', 'B', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'camera_only', True)
+kmi = km.keymap_items.new('view3d.render_border', 'B', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'camera_only', False)
+kmi = km.keymap_items.new('view3d.clear_render_border', 'B', 'PRESS', ctrl=True, alt=True)
+kmi = km.keymap_items.new('view3d.camera_to_view', 'NUMPAD_0', 'PRESS', ctrl=True, alt=True)
+kmi = km.keymap_items.new('view3d.object_as_camera', 'NUMPAD_0', 'PRESS', ctrl=True)
+kmi = km.keymap_items.new('wm.call_menu', 'S', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'name', 'VIEW3D_MT_snap')
+kmi = km.keymap_items.new('view3d.copybuffer', 'C', 'PRESS', oskey=True)
+kmi = km.keymap_items.new('view3d.pastebuffer', 'V', 'PRESS', oskey=True)
+kmi = km.keymap_items.new('view3d.copybuffer', 'C', 'PRESS', ctrl=True)
+kmi = km.keymap_items.new('view3d.pastebuffer', 'V', 'PRESS', ctrl=True)
+kmi = km.keymap_items.new('wm.context_set_enum', 'COMMA', 'PRESS')
+kmi_props_setattr(kmi.properties, 'data_path', 'space_data.pivot_point')
+kmi_props_setattr(kmi.properties, 'value', 'BOUNDING_BOX_CENTER')
+kmi = km.keymap_items.new('wm.context_set_enum', 'COMMA', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'data_path', 'space_data.pivot_point')
+kmi_props_setattr(kmi.properties, 'value', 'MEDIAN_POINT')
+kmi = km.keymap_items.new('wm.context_toggle', 'COMMA', 'PRESS', alt=True)
+kmi_props_setattr(kmi.properties, 'data_path', 'space_data.use_pivot_point_align')
+kmi = km.keymap_items.new('wm.context_toggle', 'SPACE', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'data_path', 'space_data.show_manipulator')
+kmi = km.keymap_items.new('wm.context_set_enum', 'PERIOD', 'PRESS')
+kmi_props_setattr(kmi.properties, 'data_path', 'space_data.pivot_point')
+kmi_props_setattr(kmi.properties, 'value', 'CURSOR')
+kmi = km.keymap_items.new('wm.context_set_enum', 'PERIOD', 'PRESS', ctrl=True)
+kmi_props_setattr(kmi.properties, 'data_path', 'space_data.pivot_point')
+kmi_props_setattr(kmi.properties, 'value', 'INDIVIDUAL_ORIGINS')
+kmi = km.keymap_items.new('wm.context_set_enum', 'PERIOD', 'PRESS', alt=True)
+kmi_props_setattr(kmi.properties, 'data_path', 'space_data.pivot_point')
+kmi_props_setattr(kmi.properties, 'value', 'ACTIVE_ELEMENT')
+kmi = km.keymap_items.new('transform.translate', 'G', 'PRESS')
+kmi = km.keymap_items.new('transform.translate', 'EVT_TWEAK_S', 'ANY')
+kmi = km.keymap_items.new('transform.rotate', 'R', 'PRESS')
+kmi = km.keymap_items.new('transform.resize', 'S', 'PRESS')
+kmi = km.keymap_items.new('transform.bend', 'W', 'PRESS', shift=True)
+kmi = km.keymap_items.new('transform.tosphere', 'S', 'PRESS', shift=True, alt=True)
+kmi = km.keymap_items.new('transform.shear', 'S', 'PRESS', shift=True, ctrl=True, alt=True)
+kmi = km.keymap_items.new('transform.select_orientation', 'SPACE', 'PRESS', alt=True)
+kmi = km.keymap_items.new('transform.create_orientation', 'SPACE', 'PRESS', ctrl=True, alt=True)
+kmi_props_setattr(kmi.properties, 'use', True)
+kmi = km.keymap_items.new('transform.mirror', 'M', 'PRESS', ctrl=True)
+kmi = km.keymap_items.new('wm.context_toggle', 'TAB', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'data_path', 'tool_settings.use_snap')
+kmi = km.keymap_items.new('wm.context_menu_enum', 'TAB', 'PRESS', shift=True, ctrl=True)
+kmi_props_setattr(kmi.properties, 'data_path', 'tool_settings.snap_element')
+kmi = km.keymap_items.new('transform.translate', 'T', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'texture_space', True)
+kmi = km.keymap_items.new('transform.resize', 'T', 'PRESS', shift=True, alt=True)
+kmi_props_setattr(kmi.properties, 'texture_space', True)
+kmi = km.keymap_items.new('transform.skin_resize', 'A', 'PRESS', ctrl=True)
+
+# Map Frames
+km = kc.keymaps.new('Frames', space_type='EMPTY', region_type='WINDOW', modal=False)
+
+kmi = km.keymap_items.new('screen.frame_offset', 'UP_ARROW', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'delta', 10)
+kmi = km.keymap_items.new('screen.frame_offset', 'DOWN_ARROW', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'delta', -10)
+kmi = km.keymap_items.new('screen.frame_offset', 'LEFT_ARROW', 'PRESS', alt=True)
+kmi_props_setattr(kmi.properties, 'delta', -1)
+kmi = km.keymap_items.new('screen.frame_offset', 'RIGHT_ARROW', 'PRESS', alt=True)
+kmi_props_setattr(kmi.properties, 'delta', 1)
+kmi = km.keymap_items.new('screen.frame_offset', 'WHEELDOWNMOUSE', 'PRESS', alt=True)
+kmi_props_setattr(kmi.properties, 'delta', 1)
+kmi = km.keymap_items.new('screen.frame_offset', 'WHEELUPMOUSE', 'PRESS', alt=True)
+kmi_props_setattr(kmi.properties, 'delta', -1)
+kmi = km.keymap_items.new('screen.frame_jump', 'UP_ARROW', 'PRESS', shift=True, ctrl=True)
+kmi_props_setattr(kmi.properties, 'end', True)
+kmi = km.keymap_items.new('screen.frame_jump', 'DOWN_ARROW', 'PRESS', shift=True, ctrl=True)
+kmi_props_setattr(kmi.properties, 'end', False)
+kmi = km.keymap_items.new('screen.frame_jump', 'RIGHT_ARROW', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'end', True)
+kmi = km.keymap_items.new('screen.frame_jump', 'LEFT_ARROW', 'PRESS', shift=True)
+kmi_props_setattr(kmi.properties, 'end', False)
+kmi = km.keymap_items.new('screen.keyframe_jump', 'UP_ARROW', 'PRESS', alt=True)
+kmi_props_setattr(kmi.properties, 'next', True)
+kmi = km.keymap_items.new('screen.keyframe_jump', 'DOWN_ARROW', 'PRESS', alt=True)
+kmi_props_setattr(kmi.properties, 'next', False)
+kmi = km.keymap_items.new('screen.keyframe_jump', 'MEDIA_LAST', 'PRESS')
+kmi_props_setattr(kmi.properties, 'next', True)
+kmi = km.keymap_items.new('screen.keyframe_jump', 'MEDIA_FIRST', 'PRESS')
+kmi_props_setattr(kmi.properties, 'next', False)
+kmi = km.keymap_items.new('screen.animation_play', 'A', 'PRESS', alt=True)
+kmi = km.keymap_items.new('screen.animation_play', 'A', 'PRESS', shift=True, alt=True)
+kmi_props_setattr(kmi.properties, 'reverse', True)
+kmi = km.keymap_items.new('screen.animation_cancel', 'ESC', 'PRESS')
+kmi = km.keymap_items.new('screen.animation_play', 'MEDIA_PLAY', 'PRESS')
+kmi = km.keymap_items.new('screen.animation_cancel', 'MEDIA_STOP', 'PRESS')

source/blender/blenlib/BLI_math_vector.h

@@ -146,6 +146,8 @@ MINLINE void negate_v4_v4(float r[4], const float a[3]);
 
 MINLINE void negate_v3_short(short r[3]);
 
+MINLINE void negate_v2_int(int r[2]);
+
 MINLINE void abs_v2(float r[2]);
 MINLINE void abs_v2_v2(float r[2], const float a[2]);
 MINLINE void abs_v3(float r[3]);

source/blender/blenlib/intern/math_vector_inline.c

@@ -611,6 +611,12 @@ MINLINE void negate_v3_short(short r[3])
 	r[2] = (short)-r[2];
 }
 
+MINLINE void negate_v2_int(int r[2])
+{
+	r[0] = -r[0];
+	r[1] = -r[1];
+}
+
 MINLINE void abs_v2(float r[2])
 {
 	r[0] = fabsf(r[0]);

source/blender/editors/space_view3d/view3d_walk.c

@@ -40,6 +40,9 @@
 
 #include "BLT_translation.h"
 
+#include "RNA_access.h"
+#include "RNA_define.h"
+#include "RNA_types.h"
 
 #include "BIF_gl.h"
 
@@ -93,14 +96,14 @@ enum {
 	WALK_MODAL_DECELERATE,
 };
 
-enum {
+typedef enum {
 	WALK_BIT_FORWARD  = 1 << 0,
 	WALK_BIT_BACKWARD = 1 << 1,
 	WALK_BIT_LEFT     = 1 << 2,
 	WALK_BIT_RIGHT    = 1 << 3,
 	WALK_BIT_UP       = 1 << 4,
 	WALK_BIT_DOWN     = 1 << 5,
-};
+} eWalkDirectionFlag;
 
 typedef enum eWalkTeleportState {
 	WALK_TELEPORT_STATE_OFF = 0,
@@ -119,6 +122,13 @@ typedef enum eWalkGravityState {
 	WALK_GRAVITY_STATE_ON,
 } eWalkGravityState;
 
+typedef enum eWalkMouseMode {
+	WALK_MOUSE_LOOKAROUND = 0,
+	WALK_MOUSE_MOVEHORIZONTAL,
+	WALK_MOUSE_MOVEVERTICAL,
+	WALK_MOUSE_NULL,
+} eWalkMouseMode;
+
 /* called in transform_ops.c, on each regeneration of keymaps  */
 void walk_modal_keymap(wmKeyConfig *keyconf)
 {
@@ -246,6 +256,7 @@ typedef struct WalkInfo {
 	short state;
 	bool redraw;
 
+	int init_mval[2]; /* initial 2D mouse values */
 	int prev_mval[2]; /* previous 2D mouse values */
 	int center_mval[2]; /* center mouse values */
 	int moffset[2];
@@ -267,6 +278,10 @@ typedef struct WalkInfo {
 	/* walk/fly */
 	eWalkMethod navigation_mode;
 
+	eWalkMouseMode mouse_mode;
+
+	bool use_mouse;
+
 	/* teleport */
 	WalkTeleport teleport;
 
@@ -392,7 +407,9 @@ static void walk_navigation_mode_set(bContext *C, wmOperator *op, WalkInfo *walk
 		walk->gravity_state = WALK_GRAVITY_STATE_START;
 	}
 
-	walk_update_header(C, op, walk);
+	if (walk->use_mouse) {
+		walk_update_header(C, op, walk);
+	}
 }
 
 /**
@@ -476,7 +493,7 @@ enum {
 static float base_speed = -1.f;
 static float userdef_speed = -1.f;
 
-static bool initWalkInfo(bContext *C, WalkInfo *walk, wmOperator *op)
+static bool initWalkInfo(bContext *C, WalkInfo *walk, wmOperator *op, const wmEvent *event)
 {
 	wmWindow *win = CTX_wm_window(C);
 
@@ -521,6 +538,9 @@ static bool initWalkInfo(bContext *C, WalkInfo *walk, wmOperator *op)
 	walk->is_slow = false;
 	walk->grid = 1.f / walk->scene->unit.scale_length;
 
+	walk->mouse_mode = RNA_enum_get(op->ptr, "mouse_mode");
+	walk->use_mouse = walk->mouse_mode != WALK_MOUSE_NULL;
+
 	/* user preference settings */
 	walk->teleport.duration = U.walk_navigation.teleport_time;
 	walk->mouse_speed = U.walk_navigation.mouse_speed;
@@ -565,7 +585,7 @@ static bool initWalkInfo(bContext *C, WalkInfo *walk, wmOperator *op)
 
 	walk->time_lastdraw = PIL_check_seconds_timer();
 
-	walk->draw_handle_pixel = ED_region_draw_cb_activate(walk->ar->type, drawWalkPixel, walk, REGION_DRAW_POST_PIXEL);
+	walk->draw_handle_pixel = NULL;
 
 	walk->rv3d->rflag |= RV3D_NAVIGATING;
 
@@ -580,14 +600,22 @@ static bool initWalkInfo(bContext *C, WalkInfo *walk, wmOperator *op)
 
 	copy_v2_v2_int(walk->prev_mval, walk->center_mval);
 
-	WM_cursor_warp(win,
-	               walk->ar->winrct.xmin + walk->center_mval[0],
-	               walk->ar->winrct.ymin + walk->center_mval[1]);
+	/* store the initial mouse positions */
+	walk->init_mval[0] = event->x;
+	walk->init_mval[1] = event->y;
 
-	/* remove the mouse cursor temporarily */
-	WM_cursor_modal_set(win, CURSOR_NONE);
+	if (walk->use_mouse) {
+		walk->draw_handle_pixel = ED_region_draw_cb_activate(walk->ar->type, drawWalkPixel, walk, REGION_DRAW_POST_PIXEL);
 
-	return 1;
+		WM_cursor_warp(win,
+		               walk->ar->winrct.xmin + walk->center_mval[0],
+		               walk->ar->winrct.ymin + walk->center_mval[1]);
+
+		/* remove the mouse cursor temporarily */
+		WM_cursor_modal_set(win, CURSOR_NONE);
+	}
+
+	return true;
 }
 
 static int walkEnd(bContext *C, WalkInfo *walk)
@@ -595,8 +623,12 @@ static int walkEnd(bContext *C, WalkInfo *walk)
 	wmWindow *win;
 	RegionView3D *rv3d;
 
-	if (walk->state == WALK_RUNNING)
+	if ((walk->use_mouse == false) && (walk->active_directions == 0)) {
+		walk->state = WALK_CONFIRM;
+	}
+	else if (walk->state == WALK_RUNNING) {
 		return OPERATOR_RUNNING_MODAL;
+	}
 
 #ifdef NDOF_WALK_DEBUG
 	puts("\n-- walk end --");
@@ -605,10 +637,6 @@ static int walkEnd(bContext *C, WalkInfo *walk)
 	win = CTX_wm_window(C);
 	rv3d = walk->rv3d;
 
-	WM_event_remove_timer(CTX_wm_manager(C), win, walk->timer);
-
-	ED_region_draw_cb_exit(walk->ar->type, walk->draw_handle_pixel);
-
 	ED_view3d_cameracontrol_release(walk->v3d_camera_control, walk->state == WALK_CANCEL);
 
 	rv3d->rflag &= ~RV3D_NAVIGATING;
@@ -616,18 +644,20 @@ static int walkEnd(bContext *C, WalkInfo *walk)
 	if (walk->ndof)
 		MEM_freeN(walk->ndof);
 
-	/* restore the cursor */
-	WM_cursor_modal_restore(win);
+	WM_event_remove_timer(CTX_wm_manager(C), win, walk->timer);
 
 #ifdef USE_TABLET_SUPPORT
-	if (walk->is_cursor_absolute == false)
+	if ((walk->is_cursor_absolute == false) &&
+	    (walk->use_mouse))
 #endif
 	{
-		/* center the mouse */
-		WM_cursor_warp(
-		        win,
-		        walk->ar->winrct.xmin + walk->center_mval[0],
-		        walk->ar->winrct.ymin + walk->center_mval[1]);
+		ED_region_draw_cb_exit(walk->ar->type, walk->draw_handle_pixel);
+
+		/* restore the cursor */
+		WM_cursor_modal_restore(win);
+
+		/* restore the mouse position */
+		WM_cursor_warp(win, walk->init_mval[0], walk->init_mval[1]);
 	}
 
 	if (walk->state == WALK_CONFIRM) {
@@ -642,7 +672,7 @@ static int walkEnd(bContext *C, WalkInfo *walk)
 static bool wm_event_is_last_mousemove(const wmEvent *event)
 {
 	while ((event = event->next)) {
-		if (ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE)) {
+		if (ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE, MOUSEPAN)) {
 			return false;
 		}
 	}
@@ -654,115 +684,6 @@ static void walkEvent(bContext *C, wmOperator *op, WalkInfo *walk, const wmEvent
 	if (event->type == TIMER && event->customdata == walk->timer) {
 		walk->redraw = true;
 	}
-	else if (ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE)) {
-
-#ifdef USE_TABLET_SUPPORT
-		if (walk->is_cursor_first) {
-			/* wait until we get the 'warp' event */
-			if ((walk->center_mval[0] == event->mval[0]) &&
-			    (walk->center_mval[1] == event->mval[1]))
-			{
-				walk->is_cursor_first = false;
-			}
-			else {
-				/* note, its possible the system isn't giving us the warp event
-				 * ideally we shouldn't have to worry about this, see: T45361 */
-				wmWindow *win = CTX_wm_window(C);
-				WM_cursor_warp(win,
-				               walk->ar->winrct.xmin + walk->center_mval[0],
-				               walk->ar->winrct.ymin + walk->center_mval[1]);
-			}
-			return;
-		}
-
-		if ((walk->is_cursor_absolute == false) && WM_event_is_absolute(event)) {
-			walk->is_cursor_absolute = true;
-			copy_v2_v2_int(walk->prev_mval, event->mval);
-			copy_v2_v2_int(walk->center_mval, event->mval);
-			/* without this we can't turn 180d */
-			CLAMP_MIN(walk->mouse_speed, 4.0f);
-		}
-#endif  /* USE_TABLET_SUPPORT */
-
-
-		walk->moffset[0] += event->mval[0] - walk->prev_mval[0];
-		walk->moffset[1] += event->mval[1] - walk->prev_mval[1];
-
-		copy_v2_v2_int(walk->prev_mval, event->mval);
-
-		if ((walk->center_mval[0] != event->mval[0]) ||
-		    (walk->center_mval[1] != event->mval[1]))
-		{
-			walk->redraw = true;
-
-#ifdef USE_TABLET_SUPPORT
-			if (walk->is_cursor_absolute) {
-				/* pass */
-			}
-			else
-#endif
-			if (wm_event_is_last_mousemove(event)) {
-				wmWindow *win = CTX_wm_window(C);
-
-#ifdef __APPLE__
-				if ((abs(walk->prev_mval[0] - walk->center_mval[0]) > walk->center_mval[0] / 2) ||
-				    (abs(walk->prev_mval[1] - walk->center_mval[1]) > walk->center_mval[1] / 2))
-#endif
-				{
-					WM_cursor_warp(win,
-					               walk->ar->winrct.xmin + walk->center_mval[0],
-					               walk->ar->winrct.ymin + walk->center_mval[1]);
-					copy_v2_v2_int(walk->prev_mval, walk->center_mval);
-				}
-			}
-		}
-	}
-	else if (event->type == NDOF_MOTION) {
-		/* do these automagically get delivered? yes. */
-		// puts("ndof motion detected in walk mode!");
-		// static const char *tag_name = "3D mouse position";
-
-		const wmNDOFMotionData *incoming_ndof = event->customdata;
-		switch (incoming_ndof->progress) {
-			case P_STARTING:
-				/* start keeping track of 3D mouse position */
-#ifdef NDOF_WALK_DEBUG
-				puts("start keeping track of 3D mouse position");
-#endif
-				/* fall-through */
-			case P_IN_PROGRESS:
-				/* update 3D mouse position */
-#ifdef NDOF_WALK_DEBUG
-				putchar('.'); fflush(stdout);
-#endif
-				if (walk->ndof == NULL) {
-					// walk->ndof = MEM_mallocN(sizeof(wmNDOFMotionData), tag_name);
-					walk->ndof = MEM_dupallocN(incoming_ndof);
-					// walk->ndof = malloc(sizeof(wmNDOFMotionData));
-				}
-				else {
-					memcpy(walk->ndof, incoming_ndof, sizeof(wmNDOFMotionData));
-				}
-				break;
-			case P_FINISHING:
-				/* stop keeping track of 3D mouse position */
-#ifdef NDOF_WALK_DEBUG
-				puts("stop keeping track of 3D mouse position");
-#endif
-				if (walk->ndof) {
-					MEM_freeN(walk->ndof);
-					// free(walk->ndof);
-					walk->ndof = NULL;
-				}
-
-				/* update the time else the view will jump when 2D mouse/timer resume */
-				walk->time_lastdraw = PIL_check_seconds_timer();
-
-				break;
-			default:
-				break; /* should always be one of the above 3 */
-		}
-	}
 	/* handle modal keymap first */
 	else if (event->type == EVT_MODAL_MAP) {
 		switch (event->val) {
@@ -924,6 +845,126 @@ static void walkEvent(bContext *C, wmOperator *op, WalkInfo *walk, const wmEvent
 				break;
 		}
 	}
+	else if (ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE, MOUSEPAN)) {
+		int xy[2], prevxy[2];
+
+#ifdef USE_TABLET_SUPPORT
+		if (walk->is_cursor_first) {
+			/* wait until we get the 'warp' event */
+			if ((walk->center_mval[0] == event->mval[0]) &&
+			    (walk->center_mval[1] == event->mval[1]))
+			{
+				walk->is_cursor_first = false;
+			}
+			else {
+				/* note, its possible the system isn't giving us the warp event
+				 * ideally we shouldn't have to worry about this, see: T45361 */
+				wmWindow *win = CTX_wm_window(C);
+				WM_cursor_warp(win,
+				               walk->ar->winrct.xmin + walk->center_mval[0],
+				               walk->ar->winrct.ymin + walk->center_mval[1]);
+			}
+			return;
+		}
+
+		if ((walk->is_cursor_absolute == false) && WM_event_is_absolute(event)) {
+			walk->is_cursor_absolute = true;
+			copy_v2_v2_int(walk->prev_mval, event->mval);
+			copy_v2_v2_int(walk->center_mval, event->mval);
+			/* without this we can't turn 180d */
+			CLAMP_MIN(walk->mouse_speed, 4.0f);
+		}
+#endif  /* USE_TABLET_SUPPORT */
+
+		xy[0] = event->x;
+		xy[1] = event->y;
+		prevxy[0] = event->prevx;
+		prevxy[1] = event->prevy;
+
+		if ((event->type == MOUSEPAN) && U.uiflag2 & USER_TRACKPAD_NATURAL) {
+			negate_v2_int(xy);
+			negate_v2_int(prevxy);
+		}
+
+		walk->moffset[0] += xy[0] - prevxy[0];
+		walk->moffset[1] += xy[1] - prevxy[1];
+
+		copy_v2_v2_int(walk->prev_mval, xy);
+
+		if ((walk->center_mval[0] != event->mval[0]) ||
+		    (walk->center_mval[1] != event->mval[1]))
+		{
+			walk->redraw = true;
+
+#ifdef USE_TABLET_SUPPORT
+			if (walk->is_cursor_absolute) {
+				/* pass */
+			}
+			else
+#endif
+
+			if (wm_event_is_last_mousemove(event) && walk->use_mouse) {
+				wmWindow *win = CTX_wm_window(C);
+
+#ifdef __APPLE__
+				if ((abs(walk->prev_mval[0] - walk->center_mval[0]) > walk->center_mval[0] / 2) ||
+				    (abs(walk->prev_mval[1] - walk->center_mval[1]) > walk->center_mval[1] / 2))
+#endif
+				{
+					WM_cursor_warp(win,
+					               walk->ar->winrct.xmin + walk->center_mval[0],
+					               walk->ar->winrct.ymin + walk->center_mval[1]);
+					copy_v2_v2_int(walk->prev_mval, walk->center_mval);
+				}
+			}
+		}
+	}
+	else if (event->type == NDOF_MOTION) {
+		/* do these automagically get delivered? yes. */
+		// puts("ndof motion detected in walk mode!");
+		// static const char *tag_name = "3D mouse position";
+
+		const wmNDOFMotionData *incoming_ndof = event->customdata;
+		switch (incoming_ndof->progress) {
+			case P_STARTING:
+				/* start keeping track of 3D mouse position */
+#ifdef NDOF_WALK_DEBUG
+				puts("start keeping track of 3D mouse position");
+#endif
+				/* fall-through */
+			case P_IN_PROGRESS:
+				/* update 3D mouse position */
+#ifdef NDOF_WALK_DEBUG
+				putchar('.'); fflush(stdout);
+#endif
+				if (walk->ndof == NULL) {
+					// walk->ndof = MEM_mallocN(sizeof(wmNDOFMotionData), tag_name);
+					walk->ndof = MEM_dupallocN(incoming_ndof);
+					// walk->ndof = malloc(sizeof(wmNDOFMotionData));
+				}
+				else {
+					memcpy(walk->ndof, incoming_ndof, sizeof(wmNDOFMotionData));
+				}
+				break;
+			case P_FINISHING:
+				/* stop keeping track of 3D mouse position */
+#ifdef NDOF_WALK_DEBUG
+				puts("stop keeping track of 3D mouse position");
+#endif
+				if (walk->ndof) {
+					MEM_freeN(walk->ndof);
+					// free(walk->ndof);
+					walk->ndof = NULL;
+				}
+
+				/* update the time else the view will jump when 2D mouse/timer resume */
+				walk->time_lastdraw = PIL_check_seconds_timer();
+
+				break;
+			default:
+				break; /* should always be one of the above 3 */
+		}
+	}
 }
 
 static void walkMoveCamera(bContext *C, WalkInfo *walk,
@@ -942,14 +983,134 @@ static float getVelocityZeroTime(const float gravity, const float velocity)
 	return velocity / gravity;
 }
 
-static int walkApply(bContext *C, wmOperator *op, WalkInfo *walk)
-{
 #define WALK_ROTATE_FAC 2.2f /* more is faster */
 #define WALK_TOP_LIMIT DEG2RADF(85.0f)
 #define WALK_BOTTOM_LIMIT DEG2RADF(-80.0f)
 #define WALK_MOVE_SPEED base_speed
 #define WALK_BOOST_FACTOR ((void)0, walk->speed_factor)
 
+/* rotate about the Y axis- look left/right */
+static void walk_mouse_rotate_horizontal(ARegion *ar, RegionView3D *rv3d, const float mouse_speed, int moffset[2], float r_mat[3][3], float r_upvec[3])
+{
+	float x;
+	float tmp_quat[4];
+
+	/* if we're upside down invert the moffset */
+	copy_v3_fl3(r_upvec, 0.0f, 1.0f, 0.0f);
+	mul_m3_v3(r_mat, r_upvec);
+
+	if (r_upvec[2] < 0.0f)
+		moffset[0] = -moffset[0];
+
+	/* relative offset */
+	x = (float) moffset[0] / ar->winx;
+
+	/* speed factor */
+	x *= WALK_ROTATE_FAC;
+
+	/* user adjustement factor */
+	x *= mouse_speed;
+
+	copy_v3_fl3(r_upvec, 0.0f, 0.0f, 1.0f);
+
+	/* Rotate about the relative up vec */
+	axis_angle_normalized_to_quat(tmp_quat, r_upvec, x);
+	mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
+}
+
+/* rotate about the X axis- look up/down */
+static void walk_mouse_rotate_vertical(ARegion *ar, RegionView3D *rv3d, const float mouse_speed, int moffset[2], float r_mat[3][3], float r_upvec[3])
+{
+	float angle, y;
+	float tmp_quat[4];
+
+	/* relative offset */
+	y = (float) moffset[1] / ar->winy;
+
+	/* speed factor */
+	y *= WALK_ROTATE_FAC;
+
+	/* user adjustement factor */
+	y *= mouse_speed;
+
+	/* clamp the angle limits */
+	/* it ranges from 90.0f to -90.0f */
+	angle = -asinf(rv3d->viewmat[2][2]);
+
+	if (angle > WALK_TOP_LIMIT && y > 0.0f)
+		y = 0.0f;
+
+	else if (angle < WALK_BOTTOM_LIMIT && y < 0.0f)
+		y = 0.0f;
+
+	copy_v3_fl3(r_upvec, 1.0f, 0.0f, 0.0f);
+	mul_m3_v3(r_mat, r_upvec);
+	/* Rotate about the relative up vec */
+	axis_angle_to_quat(tmp_quat, r_upvec, -y);
+	mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
+}
+
+static void walk_forward(float mat[3][3], const float speed,
+                        const bool is_world_forward, float r_dvec[3])
+{
+	float dvec_tmp[3] = {0.0f, 0.0f, speed};
+
+	mul_m3_v3(mat, dvec_tmp);
+
+	if (is_world_forward)
+		dvec_tmp[2] = 0.0f;
+
+	normalize_v3(dvec_tmp);
+	mul_v3_fl(dvec_tmp, fabsf(speed));
+	add_v3_v3(r_dvec, dvec_tmp);
+}
+
+static void walk_sideways(const float viewinvmat[4][4], const float speed, float r_dvec[3])
+{
+	float dvec_tmp[3] = {viewinvmat[0][0],
+	                     viewinvmat[0][1],
+	                     0.0f};
+
+	normalize_v3(dvec_tmp);
+	mul_v3_fl(dvec_tmp, speed);
+	add_v3_v3(r_dvec, dvec_tmp);
+}
+
+static void walk_updown(const float speed, float r_dvec[3])
+{
+	float dvec_tmp[3] = {0.0f, 0.0f, speed};
+	add_v3_v3(r_dvec, dvec_tmp);
+}
+
+static void walk_mouse_move(WalkInfo *walk, float mat[3][3], const eWalkDirectionFlag direction, const float time_redraw, float r_dvec[3])
+{
+	const float speed = walk->speed * time_redraw;
+	switch (direction) {
+		case WALK_BIT_UP:
+			walk_updown(-speed, r_dvec);
+			break;
+		case WALK_BIT_DOWN:
+			walk_updown(speed, r_dvec);
+			break;
+		case WALK_BIT_LEFT:
+			walk_sideways(walk->rv3d->viewinv, speed, r_dvec);
+			break;
+		case WALK_BIT_RIGHT:
+			walk_sideways(walk->rv3d->viewinv, -speed, r_dvec);
+			break;
+		case WALK_BIT_FORWARD:
+			walk_forward(mat, speed, true, r_dvec);
+			break;
+		case WALK_BIT_BACKWARD:
+			walk_forward(mat, -speed, true, r_dvec);
+			break;
+		default:
+			break;
+	}
+}
+
+static int walkApply(bContext *C, wmOperator *op, WalkInfo *walk)
+{
 	/* walk mode - Ctrl+Shift+F
 	 * a walk loop where the user can move move the view as if they are in a walk game
 	 */
@@ -963,7 +1124,6 @@ static int walkApply(bContext *C, wmOperator *op, WalkInfo *walk)
 	float upvec[3] = {0.0f, 0.0f, 0.0f}; /* stores the view's up vector */
 
 	int moffset[2]; /* mouse offset from the views center */
-	float tmp_quat[4]; /* used for rotating the view */
 
 #ifdef NDOF_WALK_DEBUG
 	{
@@ -1017,63 +1177,54 @@ static int walkApply(bContext *C, wmOperator *op, WalkInfo *walk)
 
 			copy_m3_m4(mat, rv3d->viewinv);
 
-			{
-				/* rotate about the X axis- look up/down */
-				if (moffset[1]) {
-					float angle;
-					float y;
-
-					/* relative offset */
-					y = (float) moffset[1] / ar->winy;
-
-					/* speed factor */
-					y *= WALK_ROTATE_FAC;
-
-					/* user adjustement factor */
-					y *= walk->mouse_speed;
-
-					/* clamp the angle limits */
-					/* it ranges from 90.0f to -90.0f */
-					angle = -asinf(rv3d->viewmat[2][2]);
-
-					if (angle > WALK_TOP_LIMIT && y > 0.0f)
-						y = 0.0f;
-
-					else if (angle < WALK_BOTTOM_LIMIT && y < 0.0f)
-						y = 0.0f;
-
-					copy_v3_fl3(upvec, 1.0f, 0.0f, 0.0f);
-					mul_m3_v3(mat, upvec);
-					/* Rotate about the relative up vec */
-					axis_angle_to_quat(tmp_quat, upvec, -y);
-					mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
+			switch (walk->mouse_mode) {
+				case WALK_MOUSE_NULL:
+				{
+					/* used when we enter the operator with an arrow key directly */
+					break;
 				}
+				case WALK_MOUSE_MOVEHORIZONTAL:
+				{
+					if (moffset[0])
+						walk_mouse_rotate_horizontal(ar, rv3d, walk->mouse_speed, moffset, mat, upvec);
 
-				/* rotate about the Y axis- look left/right */
-				if (moffset[0]) {
-					float x;
+					if (moffset[1] > 0)
+						walk_mouse_move(walk, mat, WALK_BIT_FORWARD, time_redraw, dvec);
+					else if (moffset[1] < 0)
+						walk_mouse_move(walk, mat, WALK_BIT_BACKWARD, time_redraw, dvec);
 
-					/* if we're upside down invert the moffset */
-					copy_v3_fl3(upvec, 0.0f, 1.0f, 0.0f);
-					mul_m3_v3(mat, upvec);
+					break;
+				}
+				case WALK_MOUSE_MOVEVERTICAL:
+				{
+					/* if we both movements at the same time the effect is too unstable */
+					const bool is_vertical = (abs(moffset[1]) - abs(moffset[0])) > 0;
 
-					if (upvec[2] < 0.0f)
-						moffset[0] = -moffset[0];
+					if (is_vertical) {
+						if (moffset[1] > 0)
+							walk_mouse_move(walk, mat, WALK_BIT_UP, time_redraw, dvec);
+						else if (moffset[1] < 0)
+							walk_mouse_move(walk, mat, WALK_BIT_DOWN, time_redraw, dvec);
+					}
+					else {
+						if (moffset[0] > 0)
+							walk_mouse_move(walk, mat, WALK_BIT_RIGHT, time_redraw, dvec);
+						else if (moffset[0] < 0)
+							walk_mouse_move(walk, mat, WALK_BIT_LEFT, time_redraw, dvec);
+					}
 
-					/* relative offset */
-					x = (float) moffset[0] / ar->winx;
+					break;
+				}
+				case WALK_MOUSE_LOOKAROUND:
+				default:
+				{
+					if (moffset[1])
+						walk_mouse_rotate_vertical(ar, rv3d, walk->mouse_speed, moffset, mat, upvec);
 
-					/* speed factor */
-					x *= WALK_ROTATE_FAC;
+					if (moffset[0])
+						walk_mouse_rotate_horizontal(ar, rv3d, walk->mouse_speed, moffset, mat, upvec);
 
-					/* user adjustement factor */
-					x *= walk->mouse_speed;
-
-					copy_v3_fl3(upvec, 0.0f, 0.0f, 1.0f);
-
-					/* Rotate about the relative up vec */
-					axis_angle_normalized_to_quat(tmp_quat, upvec, x);
-					mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
+					break;
 				}
 			}
 
@@ -1081,71 +1232,55 @@ static int walkApply(bContext *C, wmOperator *op, WalkInfo *walk)
 			if ((walk->active_directions) &&
 			    (walk->gravity_state == WALK_GRAVITY_STATE_OFF))
 			{
-
-				short direction;
 				zero_v3(dvec);
 
+				/* XOR */
 				if ((walk->active_directions & WALK_BIT_FORWARD) ||
 				    (walk->active_directions & WALK_BIT_BACKWARD))
 				{
-
-					direction = 0;
-
-					if ((walk->active_directions & WALK_BIT_FORWARD))
-						direction += 1;
-
-					if ((walk->active_directions & WALK_BIT_BACKWARD))
-						direction -= 1;
-
-					copy_v3_fl3(dvec_tmp, 0.0f, 0.0f, direction);
-					mul_m3_v3(mat, dvec_tmp);
-
-					if (walk->navigation_mode == WALK_MODE_GRAVITY) {
-						dvec_tmp[2] = 0.0f;
+					if ((walk->active_directions & WALK_BIT_FORWARD) &&
+					    (walk->active_directions & WALK_BIT_BACKWARD))
+					{
+					}
+					else if ((walk->active_directions & WALK_BIT_FORWARD)) {
+						walk_forward(mat, 1.0f, (walk->navigation_mode == WALK_MODE_GRAVITY), dvec);
+					}
+					else { /* WALK_BIT_BACKWARD */
+						walk_forward(mat, -1.0f, (walk->navigation_mode == WALK_MODE_GRAVITY), dvec);
 					}
-
-					normalize_v3(dvec_tmp);
-					add_v3_v3(dvec, dvec_tmp);
-
 				}
 
+				/* XOR */
 				if ((walk->active_directions & WALK_BIT_LEFT) ||
 				    (walk->active_directions & WALK_BIT_RIGHT))
 				{
-
-					direction = 0;
-
-					if ((walk->active_directions & WALK_BIT_LEFT))
-						direction += 1;
-
-					if ((walk->active_directions & WALK_BIT_RIGHT))
-						direction -= 1;
-
-					dvec_tmp[0] = direction * rv3d->viewinv[0][0];
-					dvec_tmp[1] = direction * rv3d->viewinv[0][1];
-					dvec_tmp[2] = 0.0f;
-
-					normalize_v3(dvec_tmp);
-					add_v3_v3(dvec, dvec_tmp);
-
+					if ((walk->active_directions & WALK_BIT_LEFT) &&
+					    (walk->active_directions & WALK_BIT_RIGHT))
+					{
+					}
+					else if ((walk->active_directions & WALK_BIT_LEFT)) {
+						walk_sideways(rv3d->viewinv, 1.0f, dvec);
+					}
+					else { /* WALK_BIT_RIGHT */
+						walk_sideways(rv3d->viewinv, -1.0f, dvec);
+					}
 				}
 
+				/* XOR */
 				if ((walk->active_directions & WALK_BIT_UP) ||
 				    (walk->active_directions & WALK_BIT_DOWN))
 				{
-
-					if (walk->navigation_mode == WALK_MODE_FREE) {
-
-						direction = 0;
-
-						if ((walk->active_directions & WALK_BIT_UP))
-							direction -= 1;
-
-						if ((walk->active_directions & WALK_BIT_DOWN))
-							direction = 1;
-
-						copy_v3_fl3(dvec_tmp, 0.0f, 0.0f, direction);
-						add_v3_v3(dvec, dvec_tmp);
+					if ((walk->active_directions & WALK_BIT_UP) &&
+					    (walk->active_directions & WALK_BIT_DOWN))
+					{
+					}
+					else if (walk->navigation_mode == WALK_MODE_FREE) {
+						if ((walk->active_directions & WALK_BIT_UP)) {
+							walk_updown(-1.0f, dvec);
+						}
+						else { /* WALK_BIT_DOWN */
+							walk_updown(1.0f, dvec);
+						}
 					}
 				}
 
@@ -1291,15 +1426,16 @@ static int walkApply(bContext *C, wmOperator *op, WalkInfo *walk)
 	}
 
 	return OPERATOR_FINISHED;
-#undef WALK_ROTATE_FAC
 #undef WALK_ZUP_CORRECT_FAC
 #undef WALK_ZUP_CORRECT_ACCEL
 #undef WALK_SMOOTH_FAC
+}
+
+#undef WALK_ROTATE_FAC
 #undef WALK_TOP_LIMIT
 #undef WALK_BOTTOM_LIMIT
 #undef WALK_MOVE_SPEED
 #undef WALK_BOOST_FACTOR
-}
 
 static void walkApply_ndof(bContext *C, WalkInfo *walk)
 {
@@ -1333,13 +1469,16 @@ static int walk_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 
 	op->customdata = walk;
 
-	if (initWalkInfo(C, walk, op) == false) {
+	if (initWalkInfo(C, walk, op, event) == false) {
 		MEM_freeN(op->customdata);
 		return OPERATOR_CANCELLED;
 	}
 
 	walkEvent(C, op, walk, event);
 
+	if (walk->use_mouse == false)
+		walk->active_directions = RNA_enum_get(op->ptr, "initial_direction");
+
 	WM_event_add_modal_handler(C, op);
 
 	return OPERATOR_RUNNING_MODAL;
@@ -1397,9 +1536,30 @@ static int walk_modal(bContext *C, wmOperator *op, const wmEvent *event)
 	return exit_code;
 }
 
+static EnumPropertyItem walk_navigation_mouse_mode_items[] = {
+	{WALK_MOUSE_LOOKAROUND, "LOOK_AROUND", 0, "Look Around", "Rotates the viewport camera"},
+	{WALK_MOUSE_MOVEHORIZONTAL, "MOVE_HORIZONTAL", 0, "Move Horizontally", "Moves the camera forward and backward and rotates left and right"},
+	{WALK_MOUSE_MOVEVERTICAL, "MOVE_VERTICAL", 0, "Move Vertically", "Moves the camera up and down or left and right"},
+	{WALK_MOUSE_NULL, "NONE", 0, "None", "Mouse movement is not considered"},
+	{0, NULL, 0, NULL, NULL}
+};
+
+static EnumPropertyItem walk_navigation_initial_direction_items[] = {
+	{0, "NONE", 0, "None", ""},
+	{WALK_BIT_FORWARD, "MOVE_FORWARD", 0, "Move Forward", ""},
+	{WALK_BIT_BACKWARD, "MOVE_BACKWARD", 0, "Move Backward", ""},
+	{WALK_BIT_LEFT, "MOVE_LEFT", 0, "Move Left", ""},
+	{WALK_BIT_RIGHT, "MOVE_RIGHT", 0, "Move Right", ""},
+	{WALK_BIT_UP, "MOVE_UP", 0, "Move Up", ""},
+	{WALK_BIT_DOWN, "MOVE_DOWN", 0, "Move Down", ""},
+	{0, NULL, 0, NULL, NULL}
+};
+
 void VIEW3D_OT_walk(wmOperatorType *ot)
 {
-	/* identifiers */
+	PropertyRNA *prop;
+
+/* identifiers */
 	ot->name = "Walk Navigation";
 	ot->description = "Interactively walk around the scene";
 	ot->idname = "VIEW3D_OT_walk";
@@ -1412,4 +1572,9 @@ void VIEW3D_OT_walk(wmOperatorType *ot)
 
 	/* flags */
 	ot->flag = OPTYPE_BLOCKING;
+
+	prop = RNA_def_enum(ot->srna, "mouse_mode", walk_navigation_mouse_mode_items, WALK_MOUSE_LOOKAROUND, "Mouse Mode", "");
+	RNA_def_property_flag(prop, PROP_SKIP_SAVE);
+	prop = RNA_def_enum(ot->srna, "initial_direction", walk_navigation_initial_direction_items, 0, "Initial Direction", "");
+	RNA_def_property_flag(prop, PROP_SKIP_SAVE);
 }

source/blender/makesrna/intern/rna_wm.c

@@ -90,6 +90,7 @@ static EnumPropertyItem event_mouse_type_items[] = {
 	{MOUSEPAN, "TRACKPADPAN", 0, "Mouse/Trackpad Pan", ""},
 	{MOUSEZOOM, "TRACKPADZOOM", 0, "Mouse/Trackpad Zoom", ""},
 	{MOUSEROTATE, "MOUSEROTATE", 0, "Mouse/Trackpad Rotate", ""},
+	{MOUSEUNTOUCH, "TRACKPADUNTOUCH", 0, "Mouse/Trackpad Untouch", ""},
 	{0, "", 0, NULL, NULL},
 	{WHEELUPMOUSE, "WHEELUPMOUSE", 0, "Wheel Up", ""},
 	{WHEELDOWNMOUSE, "WHEELDOWNMOUSE", 0, "Wheel Down", ""},
@@ -185,6 +186,7 @@ EnumPropertyItem event_type_items[] = {
 	{MOUSEPAN, "TRACKPADPAN", 0, "Mouse/Trackpad Pan", "MsPan"},
 	{MOUSEZOOM, "TRACKPADZOOM", 0, "Mouse/Trackpad Zoom", "MsZoom"},
 	{MOUSEROTATE, "MOUSEROTATE", 0, "Mouse/Trackpad Rotate", "MsRot"},
+	{MOUSEUNTOUCH, "TRACKPADUNTOUCH", 0, "Mouse/Trackpad Untouch", "MsUnt"},
 	{0, "", 0, NULL, NULL},
 	{WHEELUPMOUSE, "WHEELUPMOUSE", 0, "Wheel Up", "WhUp"},
 	{WHEELDOWNMOUSE, "WHEELDOWNMOUSE", 0, "Wheel Down", "WhDown"},

source/blender/windowmanager/intern/wm_event_system.c

@@ -3183,6 +3183,9 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int U
 				case GHOST_kTrackpadEventRotate:
 					event.type = MOUSEROTATE;
 					break;
+				case GHOST_kTrackpadEventUntouch:
+					event.type = MOUSEUNTOUCH;
+					break;
 				case GHOST_kTrackpadEventScroll:
 				default:
 					event.type = MOUSEPAN;

source/blender/windowmanager/wm_event_types.h

@@ -75,6 +75,7 @@ enum {
 	MOUSEPAN            = 0x000e,
 	MOUSEZOOM           = 0x000f,
 	MOUSEROTATE         = 0x0010,
+	MOUSEUNTOUCH        = 0x0014,
 	/* defaults from ghost */
 	WHEELUPMOUSE        = 0x000a,
 	WHEELDOWNMOUSE      = 0x000b,
@@ -355,7 +356,7 @@ enum {
 #define ISKEYMODIFIER(event_type)  ((event_type >= LEFTCTRLKEY && event_type <= LEFTSHIFTKEY) || event_type == OSKEY)
 
 /* test whether the event is a mouse button */
-#define ISMOUSE(event_type)  (event_type >= LEFTMOUSE && event_type <= BUTTON7MOUSE)
+#define ISMOUSE(event_type)  (event_type >= LEFTMOUSE && event_type <= MOUSEUNTOUCH)
 
 /* test whether the event is tweak event */
 #define ISTWEAK(event_type)  (event_type >= EVT_TWEAK_L && event_type <= EVT_GESTURE)