no top bar, no tabs, equal sizes

diff --git a/dwm.c b/dwm.c
index 8cc9571..e4237a4 100644 (file)
--- a/dwm.c
+++ b/dwm.c
@@ -283,6 +283,7 @@ static void window_set_opaque(Client *c);
 static void window_set_translucent(Client *c);
 static void window_set_invisible(Client *c);
 static void window_set_opacity(Client *c, int opacity_index);
 static void window_set_translucent(Client *c);
 static void window_set_invisible(Client *c);
 static void window_set_opacity(Client *c, int opacity_index);

+static Client* choose_slave (Client *master, Client *focused);

 static void update_window_opacities(Monitor *m);
 void
 window_set_opacity(Client *c, int opacity_index) {
 static void update_window_opacities(Monitor *m);
 void
 window_set_opacity(Client *c, int opacity_index) {

@@ -310,25 +311,23 @@ window_set_invisible(Client *c) {
 }
 void
 update_window_opacities(Monitor *m) {
 }
 void
 update_window_opacities(Monitor *m) {

-       Client *master, *slave, *c;
-       Bool selection_floating = False;
-       slave = master = nexttiled(m->clients);
-       if (master) slave = nexttiled(master->next);
-       if (m->sel && m->sel != master) {
-               if (nexttiled(m->sel) == m->sel) // if selection is tiled
-                       slave = m->sel;
-               else
-                       selection_floating = True;
-       }
-       for (c = m->clients; c; c = c->next) {
-               if (ISVISIBLE(c)) {
-                       if (c->isfloating || c == m->sel || (selection_floating && (c == master || c == slave))) {
-                               window_set_opaque(c);
-                       } else if (c == master || c == slave) {
-                               window_set_translucent(c);
-                       } else {
-                               window_set_opaque(c);
-                       }
+       Client *master, *slave, *focused, *c;
+       Bool focused_is_floating = False;
+       master = nexttiled(m->clients);
+       focused = (m->sel && ISVISIBLE(m->sel)) ? m->sel : NULL;
+       slave = choose_slave(master, focused);
+       // detect if the focused window is floating (and visible)
+       if (master && focused && focused != slave && focused != master) {
+               if (nexttiled(focused) != focused) {
+                       focused_is_floating = True;
+               }
+       }
+       // set opacity of visible floaters, master and slave
+       for (c = nextvisible(m->clients); c; c = nextvisible(c->next)) {
+               if (c->isfloating || c == focused || (focused_is_floating && (c == master || c == slave))) {
+                       window_set_opaque(c);
+               } else if (c == master || c == slave) {
+                       window_set_translucent(c);

                }
        }
 }
                }
        }
 }

@@ -655,7 +654,7 @@ configurenotify(XEvent *e) {
                        drw_resize(drw, sw, bh);
                        updatebars();
                        for(m = mons; m; m = m->next)
                        drw_resize(drw, sw, bh);
                        updatebars();
                        for(m = mons; m; m = m->next)

-                               XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, m->ww * m->mfact, bh);
+                               XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, m->ww, bh);

                        focus(NULL);
                        arrange(NULL);
                }
                        focus(NULL);
                        arrange(NULL);
                }

@@ -813,10 +812,10 @@ drawbar(Monitor *m) {
        xx = x;
        if(m == selmon) { /* status is only drawn on selected monitor */
                w = TEXTW(stext);
        xx = x;
        if(m == selmon) { /* status is only drawn on selected monitor */
                w = TEXTW(stext);

-               x = m->ww * m->mfact - w;
+               x = m->ww - w;

                if(x < xx) {
                        x = xx;
                if(x < xx) {
                        x = xx;

-                       w = m->ww* m->mfact  - xx;
+                       w = m->ww - xx;

                }
                drw_text(drw, x, 0, w, bh, stext, 0);
        }
                }
                drw_text(drw, x, 0, w, bh, stext, 0);
        }

@@ -828,7 +827,8 @@ drawbar(Monitor *m) {
                        drw_setscheme(drw, m == selmon ? &scheme[SchemeSel] : &scheme[SchemeNorm]);
                        drw_text(drw, x, 0, w, bh, m->sel->name, 0);
                        drw_rect(drw, x, 0, w, bh, m->sel->isfixed, m->sel->isfloating, 0);
                        drw_setscheme(drw, m == selmon ? &scheme[SchemeSel] : &scheme[SchemeNorm]);
                        drw_text(drw, x, 0, w, bh, m->sel->name, 0);
                        drw_rect(drw, x, 0, w, bh, m->sel->isfixed, m->sel->isfloating, 0);

-               } else {
+               }
+               else {

                        drw_setscheme(drw, &scheme[SchemeNorm]);
                        drw_text(drw, x, 0, w, bh, NULL, 0);
                }
                        drw_setscheme(drw, &scheme[SchemeNorm]);
                        drw_text(drw, x, 0, w, bh, NULL, 0);
                }

@@ -1815,77 +1815,98 @@ tile(Monitor *m) {
                }
 }
 
                }
 }
 

-#define GUTTER_PX   4
-#define TAB_HEIGHT (bh / 2 - GUTTER_PX)
-#define TAB_PAD     GUTTER_PX
+// search forward from start, return the last client before end
+Client*
+prev_tiled (Client *start, Client *end) {
+       Client *w, *n;
+       for (w = start; w && (n = nexttiled(w->next)); w = n) {
+               if (n == end) {
+                       return w;
+               }
+       }
+       return NULL;
+}

 
 

-void
-jason_layout(Monitor *m) {
-       unsigned int i, tiled_count, mw, right_width, tab_counts[2] = {0,0}, cur_tab = 0, *tab_count;
-       int tab_top;
-       Client *c, *vis_slave = 0, *base = 0;
-
-       tab_count = &(tab_counts[0]);
-
-       for(tiled_count = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), tiled_count++) {
-               if (tiled_count == 0) { // master
-                       if (c->next) {
-                               if (m->sel && (m->sel == c || m->sel->isfloating || !ISVISIBLE(m->sel))) {
-                                       vis_slave = nexttiled(c->next);
-                               } else {
-                                       vis_slave = m->sel;
-                               }
+// return the window to show on the right side
+Client*
+choose_slave (Client *master, Client *focused) {
+       if (!master) {
+               return NULL;
+       }
+       if (focused) {
+               // FIXME put this same algorithm in update_window_opacities
+               if (focused->isfloating) {
+                       // show the window just "under" it
+                       Client *prev = prev_tiled(master, focused);
+                       // fall back to the first slave
+                       if (prev && prev != master) {
+                               return prev;
+                       } else {
+                               return nexttiled(master->next);

                        }
                } else {
                        }
                } else {

-                       if (c == vis_slave) {
-                               tab_count = &(tab_counts[1]);
+                       // focused window is tiled
+                       if (focused == master) {
+                               // master is focused, show first slave
+                               return nexttiled(master->next);

                        } else {
                        } else {

-                               (*tab_count) += 1;
+                               // focused window is a slave, so show that one
+                               return focused;

                        }
                }
        }
                        }
                }
        }

-       if(tiled_count == 0) {
+       // maybe we get called when there's no focused?
+       return nexttiled(master->next);
+}
+
+#define GUTTER_PX   4
+
+void
+jason_layout(Monitor *m) {
+       Client *c, *master, *slave, *focused, *base = 0;
+       unsigned int master_width, slave_width, slave_left;
+
+       // find master
+       master = nexttiled(m->clients);
+
+       // no master? nothing to do
+       if (!master) {

                return;
        }
 
                return;
        }
 

-       if(tiled_count > 1 || (tiled_count == 1 && !nexttiled(m->clients)->screen_hog)) {
-               mw = m->ww * m->mfact;
+       // find focused and slave
+       focused = (m->sel && ISVISIBLE(m->sel)) ? m->sel : NULL;
+       slave = choose_slave(master, focused);
+
+       // calculate window widths
+       if (!slave && master->screen_hog) {
+               master_width = m->ww;

        } else {
        } else {

-               mw = m->ww;
-       }
-       right_width = m->ww - mw - GUTTER_PX;
-       tab_count = &(tab_counts[0]);
-       tab_top = m->my - m->wh + TAB_HEIGHT;
-       for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++) {
-               if (i == 0) {
-                       resize(c, m->wx, m->wy, mw, m->wh, False, 0);
-               } else {
-                       if (c == vis_slave) {
-                               resize(c,
-                                       m->wx + mw + GUTTER_PX,
-                                       m->my + TAB_HEIGHT + TAB_PAD,
-                                       right_width,
-                                       m->wh,
-                                       False,
-                                       base
-                               );
-                               tab_count = &(tab_counts[1]);
-                               tab_top = m->my + m->mh - TAB_HEIGHT;
-                               cur_tab = 0;
-                       } else {
-                               // this function does not get called when focus changes
-                               // resize(c, m->wx + m->ww, m->wy, m->ww - mw, m->wh, False);
-                               resize(c,
-                                       m->wx + mw + GUTTER_PX + right_width * cur_tab / (*tab_count),
-                                       tab_top,
-                                       right_width,
-                                       m->wh,
-                                       False,
-                                       base
-                               );
-                               cur_tab += 1;
-                       }
-               }
+               master_width = m->ww * m->mfact - GUTTER_PX / 2;
+       }
+       slave_left = m->ww * m->mfact + GUTTER_PX / 2;
+       slave_width = m->ww * (1 - m->mfact) - GUTTER_PX / 2;
+
+       // resize/reposition master
+       resize(master,
+               m->wx,
+               m->wy,
+               master_width,
+               m->wh,
+               False,
+               0
+       );
+       // resize/reposition slaves
+       base = master; // window to be above in the stacking order
+       for (c = nexttiled(master->next); c; c = nexttiled(c->next)) {
+               resize(c,
+                       slave_left,
+                       c == slave ? m->wy : m->wy - m->wh,
+                       slave_width,
+                       m->wh,
+                       False,
+                       base
+               );

                base = c;
        }
 }
                base = c;
        }
 }

@@ -1997,7 +2018,7 @@ updatebars(void) {
        for(m = mons; m; m = m->next) {
                if (m->barwin)
                        continue;
        for(m = mons; m; m = m->next) {
                if (m->barwin)
                        continue;

-               m->barwin = XCreateWindow(dpy, root, m->wx, m->by, m->ww * m->mfact, bh, 0, DefaultDepth(dpy, screen),
+               m->barwin = XCreateWindow(dpy, root, m->wx, m->by, m->ww, bh, 0, DefaultDepth(dpy, screen),

                                          CopyFromParent, DefaultVisual(dpy, screen),
                                          CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa);
                XChangeProperty(dpy, root, netatom[NetSupportingWMCheck], XA_WINDOW, 32,
                                          CopyFromParent, DefaultVisual(dpy, screen),
                                          CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa);
                XChangeProperty(dpy, root, netatom[NetSupportingWMCheck], XA_WINDOW, 32,