Revert Sticky Keys (and everything related to that)

Our current keymap doesn't give us enough room to make such changes in
the event system. To fix small issues caused by this, we would need to do
drastic changes in Blender's keymaps and internal handling. It was worth
a try, but it didn't work.

I can write down a more descriptive statement in a few days, but for now
I need a break of this stuff.

4 files changed, 76 insertions, 140 deletions

diff --git a/source/blender/windowmanager/intern/wm_event_system.c b/source/blender/windowmanager/intern/wm_event_system.c
index 8c013eb7cd4..d8ca80a62cb 100644
--- a/source/blender/windowmanager/intern/wm_event_system.c
+++ b/source/blender/windowmanager/intern/wm_event_system.c
@@ -404,7 +404,7 @@ static int wm_handler_ui_call(bContext *C, wmEventHandler *handler, wmEvent *eve
 	 * to make the DBL_CLICK conversion work, we just don't send this to UI, except mouse clicks */
 	if (((handler->flag & WM_HANDLER_ACCEPT_DBL_CLICK) == 0) &&
 	    (event->type != LEFTMOUSE) &&
-	    (event->click_type == KM_DBL_CLICK))
+	    (event->val == KM_DBL_CLICK))
 	{
 		return WM_HANDLER_CONTINUE;
 	}
@@ -1442,7 +1442,6 @@ int WM_userdef_event_map(int kmitype)
 }
 
 
-/* XXX rename to something more descriptive like wm_event_is_keymapitem_matching and use bool */
 static int wm_eventmatch(wmEvent *winevent, wmKeyMapItem *kmi)
 {
 	int kmitype = WM_userdef_event_map(kmi->type);
@@ -1459,13 +1458,10 @@ static int wm_eventmatch(wmEvent *winevent, wmKeyMapItem *kmi)
 
 	if (kmitype != KM_ANY)
 		if (winevent->type != kmitype) return 0;
-
-	/* KM_ANY excludes KM_HOLD since it's time based and not a real input - filter it out */
-	if (kmi->val == KM_ANY && winevent->click_type == KM_HOLD) return 0;
-
+	
 	if (kmi->val != KM_ANY)
-		if (!ELEM(kmi->val, winevent->val, winevent->click_type)) return 0;
-
+		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;
@@ -1512,9 +1508,8 @@ static void wm_event_modalkeymap(const bContext *C, wmOperator *op, wmEvent *eve
 		/* modal keymap checking returns handled events fine, but all hardcoded modal
 		 * handling typically swallows all events (OPERATOR_RUNNING_MODAL).
 		 * This bypass just disables support for double clicks in hardcoded modal handlers */
-		if (event->click_type == KM_DBL_CLICK) {
+		if (event->val == KM_DBL_CLICK) {
 			event->val = KM_PRESS;
-			event->click_type = 0;
 			*dbl_click_disabled = true;
 		}
 	}
@@ -1546,9 +1541,9 @@ static void wm_event_modalmap_end(wmEvent *event, bool dbl_click_disabled)
 		event->val = event->prevval;
 		event->prevval = 0;
 	}
-	else if (dbl_click_disabled) {
-		event->click_type = KM_DBL_CLICK;
-	}
+	else if (dbl_click_disabled)
+		event->val = KM_DBL_CLICK;
+
 }
 
 /* Warning: this function removes a modal handler, when finished */
@@ -2026,21 +2021,47 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
 		/* test for CLICK events */
 		if (wm_action_not_handled(action)) {
 			wmWindow *win = CTX_wm_window(C);
-
-			/* XXX check if those double click hacks can be removed/improved since click_type was introduced */
+			
+			/* eventstate stores if previous event was a KM_PRESS, in case that 
+			 * wasn't handled, the KM_RELEASE will become a KM_CLICK */
+			
+			if (win && event->val == KM_PRESS) {
+				win->eventstate->check_click = true;
+			}
+			
 			if (win && win->eventstate->prevtype == event->type) {
-				if (event->click_type == KM_DBL_CLICK) {
+				
+				if ((event->val == KM_RELEASE) &&
+				    (win->eventstate->prevval == KM_PRESS) &&
+				    (win->eventstate->check_click == true))
+				{
+					event->val = KM_CLICK;
+					
+					if (G.debug & (G_DEBUG_HANDLERS)) {
+						printf("%s: handling CLICK\n", __func__);
+					}
+
+					action |= wm_handlers_do_intern(C, event, handlers);
+
+					event->val = KM_RELEASE;
+				}
+				else if (event->val == KM_DBL_CLICK) {
 					event->val = KM_PRESS;
-					event->click_type = 0;
 					action |= wm_handlers_do_intern(C, event, handlers);
 					
 					/* revert value if not handled */
 					if (wm_action_not_handled(action)) {
-						event->click_type = KM_DBL_CLICK;
+						event->val = KM_DBL_CLICK;
 					}
 				}
 			}
 		}
+		else {
+			wmWindow *win = CTX_wm_window(C);
+
+			if (win)
+				win->eventstate->check_click = 0;
+		}
 	}
 	
 	return action;
@@ -2984,50 +3005,22 @@ static wmWindow *wm_event_cursor_other_windows(wmWindowManager *wm, wmWindow *wi
 	return NULL;
 }
 
-/**
- * Clicktype test
- *
- * We have 3 different click_types: #KM_CLICK, #KM_HOLD# and #KM_DBL_CLICK.
- *
- * Time is used to determine, what to send. It works as follows:
- * - #KM_RELEASE && time since first #KM_PRESS < U.click_timeout --> send #KM_CLICK
- * - #KM_PRESS && time since first #KM_PRESS > U.click_timeout --> send #KM_HOLD
- * - #KM_PRESS after a #KM_RELEASE && time since previous #KM_PRESS < U.dbl_click_time --> send #KM_DBL_CLICK
- *
- * \note: only #KM_DBL_CLICK is handled here, rest in #wm_window_event_clicktype_init (wm_window.c)
- */
-static void wm_event_clicktype_init(wmWindow *win, wmEvent *event, wmEvent *event_state)
+static bool wm_event_is_double_click(wmEvent *event, wmEvent *event_state)
 {
-	short click_type = 0;
-
-	if ((event->val == KM_PRESS) &&
-	    (event_state->prevval != KM_PRESS || event->prevtype != win->eventstate->prevtype))
-	{
-		event_state->prevclick_time = event->click_time;
-		event_state->prevclickx = event->x;
-		event_state->prevclicky = event->y;
-	}
-
-	/* double click */
-	if (event->type == event_state->prevtype &&
-	    event_state->prevval == KM_RELEASE &&
-	    event->val == KM_PRESS)
+	if ((event->type == event_state->prevtype) &&
+	    (event_state->prevval == KM_RELEASE) &&
+	    (event->val == KM_PRESS))
 	{
 		if ((ISMOUSE(event->type) == false) || ((ABS(event->x - event_state->prevclickx)) <= 2 &&
 		                                        (ABS(event->y - event_state->prevclicky)) <= 2))
 		{
-			if ((PIL_check_seconds_timer() - event_state->prevclick_time) * 1000 < U.dbl_click_time) {
-				click_type = KM_DBL_CLICK;
-				if (G.debug & (G_DEBUG_HANDLERS | G_DEBUG_EVENTS)) {
-					printf("%s Send double click event\n", __func__);
-				}
+			if ((PIL_check_seconds_timer() - event_state->prevclicktime) * 1000 < U.dbl_click_time) {
+				return true;
 			}
 		}
 	}
 
-	if (click_type != event->click_type) {
-		event_state->click_type = event->click_type = click_type;
-	}
+	return false;
 }
 
 static void wm_event_add_mousemove(wmWindow *win, const wmEvent *event)
@@ -3159,9 +3152,6 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int U
 			evt->val = event.val;
 			evt->type = event.type;
 
-			/* click_type */
-			wm_event_clicktype_init(win, &event, evt);
-
 			if (win->active == 0) {
 				int cx, cy;
 				
@@ -3172,6 +3162,18 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int U
 				event.y = evt->y = cy;
 			}
 			
+			/* double click test */
+			if (wm_event_is_double_click(&event, evt)) {
+				if (G.debug & (G_DEBUG_HANDLERS | G_DEBUG_EVENTS))
+					printf("%s Send double click\n", __func__);
+				event.val = KM_DBL_CLICK;
+			}
+			if (event.val == KM_PRESS) {
+				evt->prevclicktime = PIL_check_seconds_timer();
+				evt->prevclickx = event.x;
+				evt->prevclicky = event.y;
+			}
+			
 			/* add to other window if event is there (not to both!) */
 			owin = wm_event_cursor_other_windows(wm, win, &event);
 			if (owin) {
@@ -3210,10 +3212,7 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int U
 			/* copy to event state */
 			evt->val = event.val;
 			evt->type = event.type;
-
-			/* clicktype */
-			wm_event_clicktype_init(win, &event, evt);
-
+			
 			/* exclude arrow keys, esc, etc from text input */
 			if (type == GHOST_kEventKeyUp) {
 				event.ascii = '\0';
@@ -3279,6 +3278,14 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int U
 						event.keymodifier = evt->keymodifier = 0;
 					break;
 			}
+
+			/* double click test */
+			/* if previous event was same type, and previous was release, and now it presses... */
+			if (wm_event_is_double_click(&event, evt)) {
+				if (G.debug & (G_DEBUG_HANDLERS | G_DEBUG_EVENTS))
+					printf("%s Send double click\n", __func__);
+				evt->val = event.val = KM_DBL_CLICK;
+			}
 			
 			/* this case happens on holding a key pressed, it should not generate
 			 * press events events with the same key as modifier */
@@ -3299,6 +3306,13 @@ void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, int type, int U
 				G.is_break = true;
 			}
 			
+			/* double click test - only for press */
+			if (event.val == KM_PRESS) {
+				evt->prevclicktime = PIL_check_seconds_timer();
+				evt->prevclickx = event.x;
+				evt->prevclicky = event.y;
+			}
+			
 			wm_event_add(win, &event);
 			
 			break;
diff --git a/source/blender/windowmanager/intern/wm_keymap.c b/source/blender/windowmanager/intern/wm_keymap.c
index 0a89ca113c4..82e46c1b333 100644
--- a/source/blender/windowmanager/intern/wm_keymap.c
+++ b/source/blender/windowmanager/intern/wm_keymap.c
@@ -1192,15 +1192,11 @@ int WM_keymap_item_compare(wmKeyMapItem *k1, wmKeyMapItem *k2)
 		return 0;
 
 	if (k1->val != KM_ANY && k2->val != KM_ANY) {
-
-#if 0	/* thanks to clicktype those shouldn't be needed anymore */
 		/* take click, press, release conflict into account */
 		if (k1->val == KM_CLICK && ELEM(k2->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0)
 			return 0;
 		if (k2->val == KM_CLICK && ELEM(k1->val, KM_PRESS, KM_RELEASE, KM_CLICK) == 0)
 			return 0;
-#endif
-
 		if (k1->val != k2->val)
 			return 0;
 	}
diff --git a/source/blender/windowmanager/intern/wm_operators.c b/source/blender/windowmanager/intern/wm_operators.c
index 499adf5704d..2e48c840c2c 100644
--- a/source/blender/windowmanager/intern/wm_operators.c
+++ b/source/blender/windowmanager/intern/wm_operators.c
@@ -5149,7 +5149,7 @@ void wm_window_keymap(wmKeyConfig *keyconf)
 	WM_keymap_verify_item(keymap, "WM_OT_debug_menu", DKEY, KM_PRESS, KM_ALT | KM_CTRL, 0);
 
 	/* menus that can be accessed anywhere in blender */
-	WM_keymap_verify_item(keymap, "WM_OT_search_menu", SPACEKEY, KM_CLICK, 0, 0);
+	WM_keymap_verify_item(keymap, "WM_OT_search_menu", SPACEKEY, KM_PRESS, 0, 0);
 	WM_keymap_add_menu(keymap, "USERPREF_MT_ndof_settings", NDOF_BUTTON_MENU, KM_PRESS, 0, 0);
 
 	/* Space switching */
diff --git a/source/blender/windowmanager/intern/wm_window.c b/source/blender/windowmanager/intern/wm_window.c
index 61bddb144ae..d69cf3326b7 100644
--- a/source/blender/windowmanager/intern/wm_window.c
+++ b/source/blender/windowmanager/intern/wm_window.c
@@ -1106,76 +1106,6 @@ static int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr C_void_ptr
 	return 1;
 }
 
-/**
- * #KM_DBL_CLICK is set in wm_event_clicktype_init (wm_event_system.c)
- * Normally, this should be there too, but for #KM_CLICK/#KM_HOLD, we need a
- * time precision of a few milliseconds, which we can't get from there
- */
-static void wm_window_event_clicktype_init(const bContext *C)
-{
-	wmWindowManager *wm = CTX_wm_manager(C);
-
-	if (wm->winactive) {
-		wmWindow *win = wm->winactive;
-		wmEvent *event = win->eventstate;
-		short click_type = event->click_type;
-
-		BLI_assert(event != NULL);
-
-		if ((event->type == EVENT_NONE) ||
-		    ((event->val == KM_NOTHING) && (event->is_key_pressed == false)))
-		{
-			/* nothing needs to be done here */
-			return;
-		}
-
-		/* we always want click_type of last clicked button (to enable
-		 * use with modifier keys) - unnecessary for mouse though */
-		if (!ISMOUSE(event->type) &&
-		    event->val == KM_PRESS &&
-		    event->type != event->keymodifier)
-		{
-			event->is_key_pressed = false;
-		}
-		else if (event->val == KM_PRESS && !event->is_key_pressed) {
-			event->is_key_pressed = true;
-			event->click_time = PIL_check_seconds_timer();
-		}
-		else if (event->val == KM_RELEASE && event->is_key_pressed) {
-			event->is_key_pressed = false;
-		}
-		else if (event->is_key_pressed == false) {
-			return;
-		}
-
-		/* the actual test */
-		if ((PIL_check_seconds_timer() - event->click_time) * 1000 <= U.click_timeout) {
-			/* for any reason some X11 systems send two release events triggering two KM_CLICK
-			 * events - making the rules more strict by checking for prevval resolves this */
-			if (event->val == KM_RELEASE && event->prevval != KM_RELEASE) {
-				click_type = KM_CLICK;
-				if (G.debug & (G_DEBUG_HANDLERS | G_DEBUG_EVENTS)) {
-					printf("%s Send click event\n", __func__);
-				}
-			}
-		}
-		else if (event->is_key_pressed) {
-			click_type = KM_HOLD;
-			if (G.debug & (G_DEBUG_HANDLERS | G_DEBUG_EVENTS)) {
-				printf("%s Send hold event\n", __func__);
-			}
-
-			/* the event we send in this case is a "dummy" event - don't send value */
-			event->val = KM_NOTHING;
-		}
-
-		/* send event with new click_type */
-		if (event->click_type != click_type) {
-			event->click_type = click_type;
-			wm_event_add(win, event);
-		}
-	}
-}
 
 /* This timer system only gives maximum 1 timer event per redraw cycle,
  * to prevent queues to get overloaded.
@@ -1235,11 +1165,7 @@ void wm_window_process_events(const bContext *C)
 
 	if (hasevent)
 		GHOST_DispatchEvents(g_system);
-
-	/* not nice to have this here, but it's the only place
-	 * that can call it with the needed time precision */
-	wm_window_event_clicktype_init(C);
-
+	
 	hasevent |= wm_window_timer(C);
 
 	/* no event, we sleep 5 milliseconds */