Merge pull request #65 from taiyu-len/focus_v2

Focus v2

1 files changed, 245 insertions, 117 deletions

diff --git a/sway/handlers.c b/sway/handlers.c
index e17aefee..0157d466 100644
--- a/sway/handlers.c
+++ b/sway/handlers.c
@@ -3,18 +3,23 @@
 #include <stdbool.h>
 #include <wlc/wlc.h>
 #include <ctype.h>
-#include "layout.h"
+
+#include "handlers.h"
 #include "log.h"
+#include "layout.h"
 #include "config.h"
 #include "commands.h"
-#include "handlers.h"
 #include "stringop.h"
 #include "workspace.h"
 #include "container.h"
+#include "focus.h"
+
+uint32_t keys_pressed[32];
 
 static struct wlc_origin mouse_origin;
-//Keyboard input is being overrided by window (dmenu)
-static bool override_redirect = false;
+
+static bool m1_held = false;
+static bool m2_held = false;
 
 static bool pointer_test(swayc_t *view, void *_origin) {
 	const struct wlc_origin *origin = _origin;
@@ -23,27 +28,60 @@ static bool pointer_test(swayc_t *view, void *_origin) {
 	while (parent->type != C_OUTPUT) {
 		parent = parent->parent;
 	}
-	if (view->type == C_VIEW && origin->x >= view->x && origin->y >= view->y
-			&& origin->x < view->x + view->width && origin->y < view->y + view->height
-			&& view->visible && parent == root_container.focused) {
+	if (origin->x >= view->x && origin->y >= view->y
+		&& origin->x < view->x + view->width && origin->y < view->y + view->height
+		&& view->visible && parent == root_container.focused) {
 		return true;
 	}
 	return false;
 }
 
-swayc_t *focus_pointer(void) {
-	swayc_t *focused = get_focused_container(&root_container);
-	if (!(wlc_view_get_state(focused->handle) & WLC_BIT_FULLSCREEN)) {
-		swayc_t *pointer = find_container(&root_container, pointer_test, &mouse_origin);
-		if (pointer && focused != pointer) {
-			unfocus_all(&root_container);
-			focus_view(pointer);
-		} else if (!focused) {
-			focus_view(active_workspace);
+swayc_t *container_under_pointer(void) {
+	//root.output->workspace
+	if (!root_container.focused || !root_container.focused->focused) {
+		return NULL;
+	}
+	swayc_t *lookup = root_container.focused->focused;
+	//Case of empty workspace
+	if (lookup->children == 0) {
+		return NULL;
+	}
+	while (lookup->type != C_VIEW) {
+		int i;
+		int len;
+		//if tabbed/stacked go directly to focused container, otherwise search
+		//children
+		if (lookup->layout == L_TABBED || lookup->layout == L_STACKED) {
+			lookup = lookup->focused;
+			continue;
+		}
+		//if workspace, search floating
+		if (lookup->type == C_WORKSPACE) {
+			len = lookup->floating->length;
+			for (i = 0; i < len; ++i) {
+				if (pointer_test(lookup->floating->items[i], &mouse_origin)) {
+					lookup = lookup->floating->items[i];
+					break;
+				}
+			}
+			if (i < len) {
+				continue;
+			}
+		}
+		//search children
+		len = lookup->children->length;
+		for (i = 0; i < len; ++i) {
+			if (pointer_test(lookup->children->items[i], &mouse_origin)) {
+				lookup = lookup->children->items[i];
+				break;
+			}
+		}
+		//when border and titles are done, this could happen
+		if (i == len) {
+			break;
 		}
-		focused = pointer;
 	}
-	return focused;
+	return lookup;
 }
 
 static bool handle_output_created(wlc_handle output) {
@@ -81,90 +119,77 @@ static void handle_output_resolution_change(wlc_handle output, const struct wlc_
 
 static void handle_output_focused(wlc_handle output, bool focus) {
 	swayc_t *c = get_swayc_for_handle(output, &root_container);
-	if (!c) return;
+	//if for some reason this output doesnt exist, create it.
+	if (!c) {
+		handle_output_created(output);
+	}
 	if (focus) {
-		unfocus_all(&root_container);
-		focus_view(c);
+		set_focused_container(c);
 	}
 }
 
 static bool handle_view_created(wlc_handle handle) {
 	swayc_t *focused = get_focused_container(&root_container);
-	uint32_t type = wlc_view_get_type(handle);
-	// If override_redirect/unmanaged/popup/modal/splach
-	if (type) {
-		sway_log(L_DEBUG,"Unmanaged window of type %x left alone", type);
-		wlc_view_set_state(handle, WLC_BIT_ACTIVATED, true);
-		if (type & WLC_BIT_UNMANAGED) {
-			return true;
-		}
-		// For things like Dmenu
-		if (type & WLC_BIT_OVERRIDE_REDIRECT) {
-			override_redirect = true;
-			wlc_view_focus(handle);
-		}
-
-		// Float popups
-		if (type & WLC_BIT_POPUP) {
-			swayc_t *view = new_floating_view(handle);
-			wlc_view_set_state(handle, WLC_BIT_MAXIMIZED, false);
-			focus_view(view);
-			arrange_windows(active_workspace, -1, -1);
-		}
-	} else {
-		swayc_t *view = new_view(focused, handle);
-		//Set maximize flag for windows.
-		//TODO: floating windows have this unset
+	swayc_t *newview = NULL;
+	switch (wlc_view_get_type(handle)) {
+	//regular view created regularly
+	case 0:
+		newview = new_view(focused, handle);
 		wlc_view_set_state(handle, WLC_BIT_MAXIMIZED, true);
-		unfocus_all(&root_container);
-		focus_view(view);
-		arrange_windows(view->parent, -1, -1);
+		break;
+	//takes keyboard focus
+	case WLC_BIT_OVERRIDE_REDIRECT:
+		sway_log(L_DEBUG, "view %ld with OVERRIDE_REDIRECT", handle);
+		locked_view_focus = true;
+		wlc_view_focus(handle);
+		wlc_view_set_state(handle, WLC_BIT_ACTIVATED, true);
+		wlc_view_bring_to_front(handle);
+		break;
+	//Takes container focus
+	case WLC_BIT_OVERRIDE_REDIRECT|WLC_BIT_UNMANAGED:
+		sway_log(L_DEBUG, "view %ld with OVERRIDE_REDIRECT|WLC_BIT_MANAGED", handle);
+		wlc_view_bring_to_front(handle);
+		locked_container_focus = true;
+		break;
+	//set modals as floating containers
+	case WLC_BIT_MODAL:
+		wlc_view_bring_to_front(handle);
+		newview = new_floating_view(handle);
+	case WLC_BIT_POPUP:
+		break;
 	}
-	if (wlc_view_get_state(focused->handle) & WLC_BIT_FULLSCREEN) {
-		unfocus_all(&root_container);
-		focus_view(focused);
-		arrange_windows(focused, -1, -1);
+	if (newview) {
+		set_focused_container(newview);
+		arrange_windows(newview->parent, -1, -1);
 	}
 	return true;
 }
 
 static void handle_view_destroyed(wlc_handle handle) {
-	sway_log(L_DEBUG, "Destroying window %u", (unsigned int)handle);
-
-	// Properly handle unmanaged views
-	uint32_t type = wlc_view_get_type(handle);
-	if (type) {
-		wlc_view_set_state(handle, WLC_BIT_ACTIVATED, true);
-		sway_log(L_DEBUG,"Unmanaged window of type %x was destroyed", type);
-		if (type & WLC_BIT_UNMANAGED) {
-			// We need to call focus_view() on focus_pointer because unmanaged windows
-			// do not alter the focus structure of the container tree. This makes focus_pointer()
-			// think that it doesn't need to do anything, so we manually focus the result.
-			focus_view(focus_pointer());
-			return;
-		}
-
-		if (type & WLC_BIT_OVERRIDE_REDIRECT) {
-			override_redirect = false;
-			focus_view(focus_pointer());
-			return;
-		}
-
-		// WLC_BIT_POPUP doesn't need to be dealt with since it's
-		// treated as a floating view.
-	}
-
+	sway_log(L_DEBUG, "Destroying window %lu", handle);
 	swayc_t *view = get_swayc_for_handle(handle, &root_container);
-	swayc_t *parent;
 	swayc_t *focused = get_focused_container(&root_container);
 
-	if (view) {
-		parent = destroy_view(view);
-		arrange_windows(parent, -1, -1);
-	}
-	if (!focused || focused == view) {
-		focus_pointer();
+	switch (wlc_view_get_type(handle)) {
+	//regular view created regularly
+	case 0:
+	case WLC_BIT_MODAL:
+		if (view) {
+			swayc_t *parent = destroy_view(view);
+			arrange_windows(parent, -1, -1);
+		}
+		break;
+	//takes keyboard focus
+	case WLC_BIT_OVERRIDE_REDIRECT:
+		locked_view_focus = false;
+		break;
+	//Takes container focus
+	case WLC_BIT_OVERRIDE_REDIRECT|WLC_BIT_UNMANAGED:
+		locked_container_focus = false;
+	case WLC_BIT_POPUP:
+		break;
 	}
+	set_focused_container(get_focused_view(&root_container));
 }
 
 static void handle_view_focus(wlc_handle view, bool focus) {
@@ -172,6 +197,8 @@ static void handle_view_focus(wlc_handle view, bool focus) {
 }
 
 static void handle_view_geometry_request(wlc_handle handle, const struct wlc_geometry* geometry) {
+	sway_log(L_DEBUG, "geometry request %d x %d : %d x %d",
+			geometry->origin.x, geometry->origin.y, geometry->size.w,geometry->size.h);
 	// If the view is floating, then apply the geometry.
 	// Otherwise save the desired width/height for the view.
 	// This will not do anything for the time being as WLC improperly sends geometry requests
@@ -186,33 +213,32 @@ static void handle_view_geometry_request(wlc_handle handle, const struct wlc_geo
 			view->x = geometry->origin.x;
 			view->y = geometry->origin.y;
 			arrange_windows(view->parent, -1, -1);
-		}	
+		}
 	}
 }
 
 static void handle_view_state_request(wlc_handle view, enum wlc_view_state_bit state, bool toggle) {
+	swayc_t *c = NULL;
 	switch(state) {
 	case WLC_BIT_FULLSCREEN:
-		{
-			//I3 just lets it become fullscreen
-			wlc_view_set_state(view,state,toggle);
-			swayc_t *c = get_swayc_for_handle(view, &root_container);
-			sway_log(L_DEBUG, "setting view %ld %s, fullscreen %d",view,c->name,toggle);
-			if (c) {
-				arrange_windows(c->parent, -1, -1);
-				//Set it as focused window for that workspace if its going
-				//fullscreen
-				if (toggle) {
-					swayc_t *ws = c;
-					while (ws->type != C_WORKSPACE) {
-						ws = ws->parent;
-					}
-					//Set ws focus to c
-					focus_view_for(ws, c);
+		//I3 just lets it become fullscreen
+		wlc_view_set_state(view, state, toggle);
+		c = get_swayc_for_handle(view, &root_container);
+		sway_log(L_DEBUG, "setting view %ld %s, fullscreen %d",view,c->name,toggle);
+		if (c) {
+			arrange_windows(c->parent, -1, -1);
+			//Set it as focused window for that workspace if its going
+			//fullscreen
+			if (toggle) {
+				swayc_t *ws = c;
+				while (ws->type != C_WORKSPACE) {
+					ws = ws->parent;
 				}
+				//Set ws focus to c
+				set_focused_container_for(ws, c);
 			}
-			break;
 		}
+		break;
 	case WLC_BIT_MAXIMIZED:
 	case WLC_BIT_RESIZING:
 	case WLC_BIT_MOVING:
@@ -226,11 +252,10 @@ static void handle_view_state_request(wlc_handle view, enum wlc_view_state_bit s
 static bool handle_key(wlc_handle view, uint32_t time, const struct wlc_modifiers
 		*modifiers, uint32_t key, uint32_t sym, enum wlc_key_state state) {
 	enum { QSIZE = 32 };
-	if (override_redirect) {
+	if (locked_view_focus && state == WLC_KEY_STATE_PRESSED) {
 		return false;
 	}
 	static uint8_t  head = 0;
-	static uint32_t array[QSIZE];
 	bool cmd_success = false;
 
 	struct sway_mode *mode = config->current_mode;
@@ -239,13 +264,13 @@ static bool handle_key(wlc_handle view, uint32_t time, const struct wlc_modifier
 
 	//Find key, if it has been pressed
 	int mid = 0;
-	while (mid < head && array[mid] != sym) {
+	while (mid < head && keys_pressed[mid] != sym) {
 		++mid;
 	}
 	if (state == WLC_KEY_STATE_PRESSED && mid == head && head + 1 < QSIZE) {
-		array[head++] = sym;
+		keys_pressed[head++] = sym;
 	} else if (state == WLC_KEY_STATE_RELEASED && mid < head) {
-		memmove(array + mid, array + mid + 1, sizeof*array * (--head - mid));
+		memmove(keys_pressed + mid, keys_pressed + mid + 1, sizeof*keys_pressed * (--head - mid));
 	}
 	// TODO: reminder to check conflicts with mod+q+a versus mod+q
 	int i;
@@ -260,7 +285,7 @@ static bool handle_key(wlc_handle view, uint32_t time, const struct wlc_modifier
 				xkb_keysym_t *key = binding->keys->items[j];
 				uint8_t k;
 				for (k = 0; k < head; ++k) {
-					if (array[k] == *key) {
+					if (keys_pressed[k] == *key) {
 						match = true;
 						break;
 					}
@@ -271,12 +296,12 @@ static bool handle_key(wlc_handle view, uint32_t time, const struct wlc_modifier
 			}
 
 			if (match) {
-				//Remove matched keys from array
+				//Remove matched keys from keys_pressed
 				int j;
 				for (j = 0; j < binding->keys->length; ++j) {
 					uint8_t k;
 					for (k = 0; k < head; ++k) {
-						memmove(array + k, array + k + 1, sizeof*array * (--head - k));
+						memmove(keys_pressed + k, keys_pressed + k + 1, sizeof*keys_pressed * (--head - k));
 						break;
 					}
 				}
@@ -291,13 +316,100 @@ static bool handle_key(wlc_handle view, uint32_t time, const struct wlc_modifier
 	return cmd_success;
 }
 
-static bool handle_pointer_motion(wlc_handle view, uint32_t time, const struct wlc_origin *origin) {
-	static wlc_handle prev_view = 0;
+static bool handle_pointer_motion(wlc_handle handle, uint32_t time, const struct wlc_origin *origin) {
+	static struct wlc_origin prev_pos;
+	static wlc_handle prev_handle = 0;
 	mouse_origin = *origin;
-	if (config->focus_follows_mouse && prev_view != view) {
-		focus_pointer();
+	bool changed_floating = false;
+	int i = 0;
+	// Do checks to determine if proper keys are being held
+	swayc_t *view = active_workspace->focused;
+	if (m1_held) {
+		if (view->is_floating) {
+			while (keys_pressed[i++]) {
+				if (keys_pressed[i] == config->floating_mod) {
+					int dx = mouse_origin.x - prev_pos.x;
+					int dy = mouse_origin.y - prev_pos.y;
+					sway_log(L_DEBUG, "Moving from px: %d to cx: %d and from py: %d to cy: %d", prev_pos.x, mouse_origin.x, prev_pos.y, mouse_origin.y);
+					sway_log(L_DEBUG, "Moving: dx: %d, dy: %d", dx, dy);
+
+					view->x += dx;
+					view->y += dy;
+					changed_floating = true;
+					break;
+				}
+			}
+		}
+	} else if (m2_held) {
+		if (view->is_floating) {
+			while (keys_pressed[i++]) {
+				if (keys_pressed[i] == config->floating_mod) {
+					int dx = mouse_origin.x - prev_pos.x;
+					int dy = mouse_origin.y - prev_pos.y;
+					sway_log(L_DEBUG, "Moving from px: %d to cx: %d and from py: %d to cy: %d", prev_pos.x, mouse_origin.x, prev_pos.y, mouse_origin.y);
+					sway_log(L_INFO, "Moving: dx: %d, dy: %d", dx, dy);
+
+					// Move and resize the view based on the dx/dy and mouse position
+					int midway_x = view->x + view->width/2;
+					int midway_y = view->y + view->height/2;
+
+					if (dx < 0) {
+						changed_floating = true;
+						if (mouse_origin.x > midway_x) {
+							sway_log(L_INFO, "Downsizing view to the left");
+							view->width += dx;
+						} else {
+							sway_log(L_INFO, "Upsizing view to the left");
+							view->x += dx;
+							view->width -= dx;
+						}
+					} else if (dx > 0){
+						changed_floating = true;
+						if (mouse_origin.x > midway_x) {
+							sway_log(L_INFO, "Upsizing to the right");
+							view->width += dx;
+						} else {
+							sway_log(L_INFO, "Downsizing to the right");
+							view->x += dx;
+							view->width -= dx;
+						}
+					}
+
+					if (dy < 0) {
+						changed_floating = true;
+						if (mouse_origin.y > midway_y) {
+							sway_log(L_INFO, "Downsizing view to the top");
+							view->height += dy;
+						} else {
+							sway_log(L_INFO, "Upsizing the view to the top");
+							view->y += dy;
+							view->height -= dy;
+						}
+					} else if (dy > 0) {
+						changed_floating = true;
+						if (mouse_origin.y > midway_y) {
+							sway_log(L_INFO, "Upsizing to the bottom");
+							view->height += dy;
+						} else {
+							sway_log(L_INFO, "Downsizing to the bottom");
+							view->y += dy;
+							view->height -= dy;
+						}
+					}
+					break;
+				}
+			}
+		}
+	}
+	if (config->focus_follows_mouse && prev_handle != handle) {
+		set_focused_container(container_under_pointer());
+	}
+	prev_handle = handle;
+	prev_pos = mouse_origin;
+	if (changed_floating) {
+		arrange_windows(view, -1, -1);
+		return true;
 	}
-	prev_view = view;
 	return false;
 }
 
@@ -305,8 +417,24 @@ static bool handle_pointer_button(wlc_handle view, uint32_t time, const struct w
 		uint32_t button, enum wlc_button_state state) {
 	swayc_t *focused = get_focused_container(&root_container);
 	if (state == WLC_BUTTON_STATE_PRESSED) {
-		swayc_t *pointer = focus_pointer();
+		sway_log(L_DEBUG, "Mouse button %u pressed", button);
+		if (button == 272) {
+			m1_held = true;
+		}
+		if (button == 273) {
+			m2_held = true;
+		}
+		swayc_t *pointer = container_under_pointer();
+		set_focused_container(pointer);
 		return (pointer && pointer != focused);
+	} else {
+		sway_log(L_DEBUG, "Mouse button %u released", button);
+		if (button == 272) {
+			m1_held = false;
+		}
+		if (button == 273) {
+			m2_held = false;
+		}
 	}
 	return false;
 }