git.sur5r.net Git - i3/i3/blob - src/output.c

   1 /*
   2  * vim:ts=4:sw=4:expandtab
   3  *
   4  * i3 - an improved dynamic tiling window manager
   5  * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
   6  *
   7  * output.c: Output (monitor) related functions.
   8  *
   9  */
  10 #include "all.h"
  11
  12 /*
  13  * Returns the content container below the given output container.
  14  *
  15  */
  16 Con *output_get_content(Con *output) {
  17     Con *child;
  18
  19     TAILQ_FOREACH(child, &(output->nodes_head), nodes)
  20     if (child->type == CT_CON)
  21         return child;
  22
  23     return NULL;
  24 }
  25
  26 /*
  27  * Returns an 'output' corresponding to one of left/right/down/up or a specific
  28  * output name.
  29  *
  30  */
  31 Output *get_output_from_string(Output *current_output, const char *output_str) {
  32     if (strcasecmp(output_str, "current") == 0) {
  33         return get_output_for_con(focused);
  34     } else if (strcasecmp(output_str, "left") == 0) {
  35         return get_output_next_wrap(D_LEFT, current_output);
  36     } else if (strcasecmp(output_str, "right") == 0) {
  37         return get_output_next_wrap(D_RIGHT, current_output);
  38     } else if (strcasecmp(output_str, "up") == 0) {
  39         return get_output_next_wrap(D_UP, current_output);
  40     } else if (strcasecmp(output_str, "down") == 0) {
  41         return get_output_next_wrap(D_DOWN, current_output);
  42     }
  43
  44     return get_output_by_name(output_str, true);
  45 }
  46
  47 /*
  48  * Retrieves the primary name of an output.
  49  *
  50  */
  51 char *output_primary_name(Output *output) {
  52     return SLIST_FIRST(&output->names_head)->name;
  53 }
  54
  55 Output *get_output_for_con(Con *con) {
  56     Con *output_con = con_get_output(con);
  57     if (output_con == NULL) {
  58         ELOG("Could not get the output container for con = %p.\n", con);
  59         return NULL;
  60     }
  61
  62     Output *output = get_output_by_name(output_con->name, true);
  63     if (output == NULL) {
  64         ELOG("Could not get output from name \"%s\".\n", output_con->name);
  65         return NULL;
  66     }
  67
  68     return output;
  69 }
  70
  71 /*
  72  * Iterates over all outputs and pushes sticky windows to the currently visible
  73  * workspace on that output.
  74  *
  75  * old_focus is used to determine if a sticky window is going to be focused.
  76  * old_focus might be different than the currently focused container because the
  77  * caller might need to temporarily change the focus and then call
  78  * output_push_sticky_windows. For example, workspace_show needs to set focus to
  79  * one of its descendants first, then call output_push_sticky_windows that
  80  * should focus a sticky window if it was the focused in the previous workspace.
  81  *
  82  */
  83 void output_push_sticky_windows(Con *old_focus) {
  84     Con *output;
  85     TAILQ_FOREACH(output, &(croot->focus_head), focused) {
  86         Con *workspace, *visible_ws = NULL;
  87         GREP_FIRST(visible_ws, output_get_content(output), workspace_is_visible(child));
  88
  89         /* We use this loop instead of TAILQ_FOREACH to avoid problems if the
  90          * sticky window was the last window on that workspace as moving it in
  91          * this case will close the workspace. */
  92         for (workspace = TAILQ_FIRST(&(output_get_content(output)->focus_head));
  93              workspace != TAILQ_END(&(output_get_content(output)->focus_head));) {
  94             Con *current_ws = workspace;
  95             workspace = TAILQ_NEXT(workspace, focused);
  96
  97             /* Since moving the windows actually removes them from the list of
  98              * floating windows on this workspace, here too we need to use
  99              * another loop than TAILQ_FOREACH. */
 100             Con *child;
 101             for (child = TAILQ_FIRST(&(current_ws->focus_head));
 102                  child != TAILQ_END(&(current_ws->focus_head));) {
 103                 Con *current = child;
 104                 child = TAILQ_NEXT(child, focused);
 105                 if (current->type != CT_FLOATING_CON || !con_is_sticky(current)) {
 106                     continue;
 107                 }
 108
 109                 bool ignore_focus = (old_focus == NULL) || (current != old_focus->parent);
 110                 con_move_to_workspace(current, visible_ws, true, false, ignore_focus);
 111                 if (!ignore_focus) {
 112                     Con *current_ws = con_get_workspace(focused);
 113                     con_activate(con_descend_focused(current));
 114                     /* Pushing sticky windows shouldn't change the focused workspace. */
 115                     con_activate(con_descend_focused(current_ws));
 116                 }
 117             }
 118         }
 119     }
 120 }