1 files changed, 128 insertions, 107 deletions

diff --git a/sway/handlers.c b/sway/handlers.c
index e17aefee..99f597af 100644
--- a/sway/handlers.c
+++ b/sway/handlers.c
@@ -3,18 +3,18 @@
 #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"
 
 static struct wlc_origin mouse_origin;
-//Keyboard input is being overrided by window (dmenu)
-static bool override_redirect = false;
 
 static bool pointer_test(swayc_t *view, void *_origin) {
         const struct wlc_origin *origin = _origin;
@@ -23,27 +23,57 @@ 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
+        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 +111,79 @@ 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_POPUP:
+        case WLC_BIT_MODAL:
+                wlc_view_bring_to_front(handle);
+                newview = new_floating_view(handle);
+                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:
+        case WLC_BIT_POPUP:
+                if (view) {
+                        arrange_windows(destroy_view(view), -1, -1);
+                        if (!focused || focused == view) {
+                                set_focused_container(container_under_pointer());
+                        }
+                }
+                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;
+                break;
         }
+        set_focused_container(get_focused_view(&root_container));
 }
 
 static void handle_view_focus(wlc_handle view, bool focus) {
@@ -172,6 +191,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 +207,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) {
-        switch(state) {
+        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,7 +246,7 @@ 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) {
                 return false;
         }
         static uint8_t  head = 0;
@@ -295,7 +315,7 @@ static bool handle_pointer_motion(wlc_handle view, uint32_t time, const struct w
         static wlc_handle prev_view = 0;
         mouse_origin = *origin;
         if (config->focus_follows_mouse && prev_view != view) {
-                focus_pointer();
+                set_focused_container(container_under_pointer());
         }
         prev_view = view;
         return false;
@@ -305,7 +325,8 @@ 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();
+                swayc_t *pointer = container_under_pointer();
+                set_focused_container(pointer);
                 return (pointer && pointer != focused);
         }
         return false;