i3
click.c
Go to the documentation of this file.
1 #undef I3__FILE__
2 #define I3__FILE__ "click.c"
3 /*
4  * vim:ts=4:sw=4:expandtab
5  *
6  * i3 - an improved dynamic tiling window manager
7  * © 2009-2012 Michael Stapelberg and contributors (see also: LICENSE)
8  *
9  * click.c: Button press (mouse click) events.
10  *
11  */
12 #include "all.h"
13 
14 #include <time.h>
15 #include <math.h>
16 
17 #include <xcb/xcb_icccm.h>
18 
19 #include <X11/XKBlib.h>
20 
21 typedef enum { CLICK_BORDER = 0,
24 
25 /*
26  * Finds the correct pair of first/second cons between the resize will take
27  * place according to the passed border position (top, left, right, bottom),
28  * then calls resize_graphical_handler().
29  *
30  */
31 static bool tiling_resize_for_border(Con *con, border_t border, xcb_button_press_event_t *event) {
32  DLOG("border = %d, con = %p\n", border, con);
33  Con *second = NULL;
34  Con *first = con;
35  direction_t search_direction;
36  switch (border) {
37  case BORDER_LEFT:
38  search_direction = D_LEFT;
39  break;
40  case BORDER_RIGHT:
41  search_direction = D_RIGHT;
42  break;
43  case BORDER_TOP:
44  search_direction = D_UP;
45  break;
46  case BORDER_BOTTOM:
47  search_direction = D_DOWN;
48  break;
49  }
50 
51  bool res = resize_find_tiling_participants(&first, &second, search_direction);
52  if (!res) {
53  LOG("No second container in this direction found.\n");
54  return false;
55  }
56 
57  assert(first != second);
58  assert(first->parent == second->parent);
59 
60  /* The first container should always be in front of the second container */
61  if (search_direction == D_UP || search_direction == D_LEFT) {
62  Con *tmp = first;
63  first = second;
64  second = tmp;
65  }
66 
67  const orientation_t orientation = ((border == BORDER_LEFT || border == BORDER_RIGHT) ? HORIZ : VERT);
68 
69  resize_graphical_handler(first, second, orientation, event);
70 
71  DLOG("After resize handler, rendering\n");
72  tree_render();
73  return true;
74 }
75 
76 /*
77  * Called when the user clicks using the floating_modifier, but the client is in
78  * tiling layout.
79  *
80  * Returns false if it does not do anything (that is, the click should be sent
81  * to the client).
82  *
83  */
84 static bool floating_mod_on_tiled_client(Con *con, xcb_button_press_event_t *event) {
85  /* The client is in tiling layout. We can still initiate a resize with the
86  * right mouse button, by chosing the border which is the most near one to
87  * the position of the mouse pointer */
88  int to_right = con->rect.width - event->event_x,
89  to_left = event->event_x,
90  to_top = event->event_y,
91  to_bottom = con->rect.height - event->event_y;
92 
93  DLOG("click was %d px to the right, %d px to the left, %d px to top, %d px to bottom\n",
94  to_right, to_left, to_top, to_bottom);
95 
96  if (to_right < to_left &&
97  to_right < to_top &&
98  to_right < to_bottom)
99  return tiling_resize_for_border(con, BORDER_RIGHT, event);
100 
101  if (to_left < to_right &&
102  to_left < to_top &&
103  to_left < to_bottom)
104  return tiling_resize_for_border(con, BORDER_LEFT, event);
105 
106  if (to_top < to_right &&
107  to_top < to_left &&
108  to_top < to_bottom)
109  return tiling_resize_for_border(con, BORDER_TOP, event);
110 
111  if (to_bottom < to_right &&
112  to_bottom < to_left &&
113  to_bottom < to_top)
114  return tiling_resize_for_border(con, BORDER_BOTTOM, event);
115 
116  return false;
117 }
118 
119 /*
120  * Finds out which border was clicked on and calls tiling_resize_for_border().
121  *
122  */
123 static bool tiling_resize(Con *con, xcb_button_press_event_t *event, const click_destination_t dest) {
124  /* check if this was a click on the window border (and on which one) */
125  Rect bsr = con_border_style_rect(con);
126  DLOG("BORDER x = %d, y = %d for con %p, window 0x%08x\n",
127  event->event_x, event->event_y, con, event->event);
128  DLOG("checks for right >= %d\n", con->window_rect.x + con->window_rect.width);
129  if (dest == CLICK_DECORATION) {
130  /* The user clicked on a window decoration. We ignore the following case:
131  * The container is a h-split, tabbed or stacked container with > 1
132  * window. Decorations will end up next to each other and the user
133  * expects to switch to a window by clicking on its decoration. */
134 
135  /* Since the container might either be the child *or* already a split
136  * container (in the case of a nested split container), we need to make
137  * sure that we are dealing with the split container here. */
138  Con *check_con = con;
139  if (con_is_leaf(check_con) && check_con->parent->type == CT_CON)
140  check_con = check_con->parent;
141 
142  if ((check_con->layout == L_STACKED ||
143  check_con->layout == L_TABBED ||
144  con_orientation(check_con) == HORIZ) &&
145  con_num_children(check_con) > 1) {
146  DLOG("Not handling this resize, this container has > 1 child.\n");
147  return false;
148  }
149  return tiling_resize_for_border(con, BORDER_TOP, event);
150  }
151 
152  if (event->event_x >= 0 && event->event_x <= (int32_t)bsr.x &&
153  event->event_y >= (int32_t)bsr.y && event->event_y <= (int32_t)(con->rect.height + bsr.height))
154  return tiling_resize_for_border(con, BORDER_LEFT, event);
155 
156  if (event->event_x >= (int32_t)(con->window_rect.x + con->window_rect.width) &&
157  event->event_y >= (int32_t)bsr.y && event->event_y <= (int32_t)(con->rect.height + bsr.height))
158  return tiling_resize_for_border(con, BORDER_RIGHT, event);
159 
160  if (event->event_y >= (int32_t)(con->window_rect.y + con->window_rect.height))
161  return tiling_resize_for_border(con, BORDER_BOTTOM, event);
162 
163  return false;
164 }
165 
166 /*
167  * Being called by handle_button_press, this function calls the appropriate
168  * functions for resizing/dragging.
169  *
170  */
171 static int route_click(Con *con, xcb_button_press_event_t *event, const bool mod_pressed, const click_destination_t dest) {
172  DLOG("--> click properties: mod = %d, destination = %d\n", mod_pressed, dest);
173  DLOG("--> OUTCOME = %p\n", con);
174  DLOG("type = %d, name = %s\n", con->type, con->name);
175 
176  /* don’t handle dockarea cons, they must not be focused */
177  if (con->parent->type == CT_DOCKAREA)
178  goto done;
179 
180  /* Any click in a workspace should focus that workspace. If the
181  * workspace is on another output we need to do a workspace_show in
182  * order for i3bar (and others) to notice the change in workspace. */
183  Con *ws = con_get_workspace(con);
184  Con *focused_workspace = con_get_workspace(focused);
185 
186  if (!ws) {
187  ws = TAILQ_FIRST(&(output_get_content(con_get_output(con))->focus_head));
188  if (!ws)
189  goto done;
190  }
191 
192  if (ws != focused_workspace)
193  workspace_show(ws);
194  focused_id = XCB_NONE;
195 
196  /* get the floating con */
197  Con *floatingcon = con_inside_floating(con);
198  const bool proportional = (event->state & BIND_SHIFT);
199  const bool in_stacked = (con->parent->layout == L_STACKED || con->parent->layout == L_TABBED);
200 
201  /* 1: see if the user scrolled on the decoration of a stacked/tabbed con */
202  if (in_stacked &&
203  dest == CLICK_DECORATION &&
204  (event->detail == XCB_BUTTON_INDEX_4 ||
205  event->detail == XCB_BUTTON_INDEX_5)) {
206  DLOG("Scrolling on a window decoration\n");
207  orientation_t orientation = (con->parent->layout == L_STACKED ? VERT : HORIZ);
208  /* Focus the currently focused container on the same level that the
209  * user scrolled on. e.g. the tabbed decoration contains
210  * "urxvt | i3: V[xterm geeqie] | firefox",
211  * focus is on the xterm, but the user scrolled on urxvt.
212  * The splitv container will be focused. */
213  Con *focused = con->parent;
214  focused = TAILQ_FIRST(&(focused->focus_head));
215  con_focus(focused);
216  /* To prevent scrolling from going outside the container (see ticket
217  * #557), we first check if scrolling is possible at all. */
218  bool scroll_prev_possible = (TAILQ_PREV(focused, nodes_head, nodes) != NULL);
219  bool scroll_next_possible = (TAILQ_NEXT(focused, nodes) != NULL);
220  if (event->detail == XCB_BUTTON_INDEX_4 && scroll_prev_possible)
221  tree_next('p', orientation);
222  else if (event->detail == XCB_BUTTON_INDEX_5 && scroll_next_possible)
223  tree_next('n', orientation);
224  goto done;
225  }
226 
227  /* 2: focus this con. */
228  con_focus(con);
229 
230  /* 3: For floating containers, we also want to raise them on click.
231  * We will skip handling events on floating cons in fullscreen mode */
232  Con *fs = (ws ? con_get_fullscreen_con(ws, CF_OUTPUT) : NULL);
233  if (floatingcon != NULL && fs != con) {
234  floating_raise_con(floatingcon);
235 
236  /* 4: floating_modifier plus left mouse button drags */
237  if (mod_pressed && event->detail == XCB_BUTTON_INDEX_1) {
238  floating_drag_window(floatingcon, event);
239  return 1;
240  }
241 
242  /* 5: resize (floating) if this was a (left or right) click on the
243  * left/right/bottom border, or a right click on the decoration.
244  * also try resizing (tiling) if it was a click on the top */
245  if (mod_pressed && event->detail == XCB_BUTTON_INDEX_3) {
246  DLOG("floating resize due to floatingmodifier\n");
247  floating_resize_window(floatingcon, proportional, event);
248  return 1;
249  }
250 
251  if (!in_stacked && dest == CLICK_DECORATION) {
252  /* try tiling resize, but continue if it doesn’t work */
253  DLOG("tiling resize with fallback\n");
254  if (tiling_resize(con, event, dest))
255  goto done;
256  }
257 
258  if (dest == CLICK_DECORATION && event->detail == XCB_BUTTON_INDEX_3) {
259  DLOG("floating resize due to decoration right click\n");
260  floating_resize_window(floatingcon, proportional, event);
261  return 1;
262  }
263 
264  if (dest == CLICK_BORDER) {
265  DLOG("floating resize due to border click\n");
266  floating_resize_window(floatingcon, proportional, event);
267  return 1;
268  }
269 
270  /* 6: dragging, if this was a click on a decoration (which did not lead
271  * to a resize) */
272  if (!in_stacked && dest == CLICK_DECORATION) {
273  floating_drag_window(floatingcon, event);
274  return 1;
275  }
276 
277  goto done;
278  }
279 
280  if (in_stacked) {
281  /* for stacked/tabbed cons, the resizing applies to the parent
282  * container */
283  con = con->parent;
284  }
285 
286  /* 7: floating modifier pressed, initiate a resize */
287  if (dest == CLICK_INSIDE && mod_pressed && event->detail == XCB_BUTTON_INDEX_3) {
288  if (floating_mod_on_tiled_client(con, event))
289  return 1;
290  }
291  /* 8: otherwise, check for border/decoration clicks and resize */
292  else if ((dest == CLICK_BORDER || dest == CLICK_DECORATION) &&
293  (event->detail == XCB_BUTTON_INDEX_1 ||
294  event->detail == XCB_BUTTON_INDEX_3)) {
295  DLOG("Trying to resize (tiling)\n");
296  tiling_resize(con, event, dest);
297  }
298 
299 done:
300  xcb_allow_events(conn, XCB_ALLOW_REPLAY_POINTER, event->time);
301  xcb_flush(conn);
302  tree_render();
303  return 0;
304 }
305 
306 /*
307  * The button press X callback. This function determines whether the floating
308  * modifier is pressed and where the user clicked (decoration, border, inside
309  * the window).
310  *
311  * Then, route_click is called on the appropriate con.
312  *
313  */
314 int handle_button_press(xcb_button_press_event_t *event) {
315  Con *con;
316  DLOG("Button %d pressed on window 0x%08x (child 0x%08x) at (%d, %d) (root %d, %d)\n",
317  event->state, event->event, event->child, event->event_x, event->event_y,
318  event->root_x, event->root_y);
319 
320  last_timestamp = event->time;
321 
322  const uint32_t mod = config.floating_modifier;
323  const bool mod_pressed = (mod != 0 && (event->state & mod) == mod);
324  DLOG("floating_mod = %d, detail = %d\n", mod_pressed, event->detail);
325  if ((con = con_by_window_id(event->event)))
326  return route_click(con, event, mod_pressed, CLICK_INSIDE);
327 
328  if (!(con = con_by_frame_id(event->event))) {
329  /* If the root window is clicked, find the relevant output from the
330  * click coordinates and focus the output's active workspace. */
331  if (event->event == root) {
332  Con *output, *ws;
333  TAILQ_FOREACH (output, &(croot->nodes_head), nodes) {
334  if (con_is_internal(output) ||
335  !rect_contains(output->rect, event->event_x, event->event_y))
336  continue;
337 
338  ws = TAILQ_FIRST(&(output_get_content(output)->focus_head));
339  if (ws != con_get_workspace(focused)) {
340  workspace_show(ws);
341  tree_render();
342  }
343  return 1;
344  }
345  return 0;
346  }
347 
348  ELOG("Clicked into unknown window?!\n");
349  xcb_allow_events(conn, XCB_ALLOW_REPLAY_POINTER, event->time);
350  xcb_flush(conn);
351  return 0;
352  }
353 
354  if (event->child != XCB_NONE) {
355  DLOG("event->child not XCB_NONE, so this is an event which originated from a click into the application, but the application did not handle it.\n");
356  return route_click(con, event, mod_pressed, CLICK_INSIDE);
357  }
358 
359  /* Check if the click was on the decoration of a child */
360  Con *child;
361  TAILQ_FOREACH (child, &(con->nodes_head), nodes) {
362  if (!rect_contains(child->deco_rect, event->event_x, event->event_y))
363  continue;
364 
365  return route_click(child, event, mod_pressed, CLICK_DECORATION);
366  }
367 
368  return route_click(con, event, mod_pressed, CLICK_BORDER);
369 }
Definition: data.h:87
struct Con * parent
Definition: data.h:512
void tree_next(char way, orientation_t orientation)
Changes focus in the given way (next/previous) and given orientation (horizontal/vertical).
Definition: tree.c:677
static bool tiling_resize(Con *con, xcb_button_press_event_t *event, const click_destination_t dest)
Definition: click.c:123
void floating_resize_window(Con *con, const bool proportional, const xcb_button_press_event_t *event)
Called when the user clicked on a floating window while holding the floating_modifier and the right m...
Definition: floating.c:534
void tree_render(void)
Renders the tree, that is rendering all outputs using render_con() and pushing the changes to X11 usi...
Definition: tree.c:507
direction_t
Definition: data.h:54
uint32_t y
Definition: data.h:124
Config config
Definition: config.c:19
xcb_connection_t * conn
Definition: main.c:47
Con * con_get_workspace(Con *con)
Gets the workspace container this node is on.
Definition: con.c:317
int resize_graphical_handler(Con *first, Con *second, orientation_t orientation, const xcb_button_press_event_t *event)
Definition: resize.c:102
Definition: data.h:54
Stores a rectangle, for example the size of a window, the child window etc.
Definition: data.h:122
#define LOG(fmt,...)
Definition: libi3.h:76
int handle_button_press(xcb_button_press_event_t *event)
The button press X callback.
Definition: click.c:314
struct Rect window_rect
Definition: data.h:515
void floating_drag_window(Con *con, const xcb_button_press_event_t *event)
Called when the user clicked on the titlebar of a floating window.
Definition: floating.c:439
void workspace_show(Con *workspace)
Switches to the given workspace.
Definition: workspace.c:447
struct Rect rect
Definition: data.h:514
#define TAILQ_FIRST(head)
Definition: queue.h:323
Definition: data.h:54
click_destination_t
Definition: click.c:21
xcb_timestamp_t last_timestamp
The last timestamp we got from X11 (timestamps are included in some events and are used for some thin...
Definition: main.c:57
#define TAILQ_NEXT(elm, field)
Definition: queue.h:325
bool con_is_internal(Con *con)
Returns true if the container is internal, such as __i3_scratch.
Definition: con.c:411
bool rect_contains(Rect rect, uint32_t x, uint32_t y)
Definition: util.c:37
enum Con::@18 type
Con * con_by_window_id(xcb_window_t window)
Returns the container with the given client window ID or NULL if no such container exists...
Definition: con.c:461
#define DLOG(fmt,...)
Definition: libi3.h:86
border_t
On which border was the dragging initiated?
Definition: floating.h:23
Definition: data.h:86
void floating_raise_con(Con *con)
Raises the given container in the list of floating containers.
Definition: floating.c:379
struct Rect deco_rect
Definition: data.h:516
Con * con_get_fullscreen_con(Con *con, fullscreen_mode_t fullscreen_mode)
Returns the first fullscreen node below this node.
Definition: con.c:365
Rect con_border_style_rect(Con *con)
Returns a &quot;relative&quot; Rect which contains the amount of pixels that need to be added to the original R...
Definition: con.c:1090
bool con_is_leaf(Con *con)
Returns true when this node is a leaf node (has no children)
Definition: con.c:241
uint32_t height
Definition: data.h:126
Definition: data.h:54
Con * focused
Definition: tree.c:15
char * name
Definition: data.h:520
static int route_click(Con *con, xcb_button_press_event_t *event, const bool mod_pressed, const click_destination_t dest)
Definition: click.c:171
void con_focus(Con *con)
Sets input focus to the given container.
Definition: con.c:213
Con * con_by_frame_id(xcb_window_t frame)
Returns the container with the given frame ID or NULL if no such container exists.
Definition: con.c:474
int con_num_children(Con *con)
Returns the number of children of this container.
Definition: con.c:526
Definition: data.h:54
#define TAILQ_PREV(elm, headname, field)
Definition: queue.h:329
#define ELOG(fmt,...)
Definition: libi3.h:81
Definition: data.h:55
layout_t layout
Definition: data.h:578
orientation_t con_orientation(Con *con)
Returns the orientation of the given container (for stacked containers, vertical orientation is used ...
Definition: con.c:843
A &#39;Con&#39; represents everything from the X11 root window down to a single X11 window.
Definition: data.h:479
uint32_t x
Definition: data.h:123
orientation_t
Definition: data.h:55
bool resize_find_tiling_participants(Con **current, Con **other, direction_t direction)
Definition: resize.c:54
struct Con * croot
Definition: tree.c:14
xcb_window_t root
Definition: main.c:60
Con * output_get_content(Con *output)
Returns the output container below the given output container.
Definition: output.c:18
Con * con_get_output(Con *con)
Gets the output container (first container with CT_OUTPUT in hierarchy) this node is on...
Definition: con.c:303
Con * con_inside_floating(Con *con)
Checks if the given container is either floating or inside some floating container.
Definition: con.c:430
uint32_t floating_modifier
The modifier which needs to be pressed in combination with your mouse buttons to do things with float...
Definition: config.h:178
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:334
static bool tiling_resize_for_border(Con *con, border_t border, xcb_button_press_event_t *event)
Definition: click.c:31
Definition: data.h:55
static bool floating_mod_on_tiled_client(Con *con, xcb_button_press_event_t *event)
Definition: click.c:84
xcb_window_t focused_id
Stores the X11 window ID of the currently focused window.
Definition: x.c:16
uint32_t width
Definition: data.h:125