104 * SSMMM SSSSS MMMSS |
102 * SSMMM SSSSS MMMSS |
105 */ |
103 */ |
106 void |
104 void |
107 dotile(Arg *arg) { |
105 dotile(Arg *arg) { |
108 int i, n, stackw, stackh, tw, th; |
106 int i, n, stackw, stackh, tw, th; |
|
107 unsigned int md = ((stackpos == StackBottom ? sh - bh : sw) * master) / 100; |
109 Client *c; |
108 Client *c; |
110 |
109 |
111 for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next)) |
110 for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next)) |
112 n++; |
111 n++; |
113 |
112 |
114 if(stackpos == StackBottom) { |
113 if(stackpos == StackBottom) { |
115 stackw = sw; |
114 stackw = sw; |
116 stackh = sh - bh - master; |
115 stackh = sh - bh - md; |
117 } |
116 } |
118 else { |
117 else { |
119 stackw = sw - master; |
118 stackw = sw - md; |
120 stackh = sh - bh; |
119 stackh = sh - bh; |
121 } |
120 } |
122 |
121 |
123 tw = stackw; |
122 tw = stackw; |
124 if(n > 1) |
123 if(n > 1) |
143 if(stackpos == StackLeft) |
142 if(stackpos == StackLeft) |
144 c->x += stackw; |
143 c->x += stackw; |
145 switch(stackpos) { |
144 switch(stackpos) { |
146 case StackLeft: |
145 case StackLeft: |
147 case StackRight: |
146 case StackRight: |
148 c->w = master - 2 * BORDERPX; |
147 c->w = md - 2 * BORDERPX; |
149 c->h = sh - bh - 2 * BORDERPX; |
148 c->h = sh - bh - 2 * BORDERPX; |
150 break; |
149 break; |
151 case StackBottom: |
150 case StackBottom: |
152 c->w = sw - 2 * BORDERPX; |
151 c->w = sw - 2 * BORDERPX; |
153 c->h = master - 2 * BORDERPX; |
152 c->h = md - 2 * BORDERPX; |
154 break; |
153 break; |
155 } |
154 } |
156 } |
155 } |
157 else { /* tile window */ |
156 else { /* tile window */ |
158 if(stackpos == StackRight) |
157 if(stackpos == StackRight) |
159 c->x += master; |
158 c->x += md; |
160 if(th > bh) { |
159 if(th > bh) { |
161 switch(stackpos) { |
160 switch(stackpos) { |
162 case StackLeft: |
161 case StackLeft: |
163 case StackRight: |
162 case StackRight: |
164 c->y = sy + (i - 1) * th + bh; |
163 c->y = sy + (i - 1) * th + bh; |
165 if(i + 1 == n) |
164 if(i + 1 == n) |
166 c->h = sh - c->y - 2 * BORDERPX; |
165 c->h = sh - c->y - 2 * BORDERPX; |
167 break; |
166 break; |
168 case StackBottom: |
167 case StackBottom: |
169 c->y = sy + master + (i - 1) * th + bh; |
168 c->y = sy + md + (i - 1) * th + bh; |
170 if(i + 1 == n) |
169 if(i + 1 == n) |
171 c->h = sh - c->y - 2 * BORDERPX; |
170 c->h = sh - c->y - 2 * BORDERPX; |
172 break; |
171 break; |
173 } |
172 } |
174 c->w = tw - 2 * BORDERPX; |
173 c->w = tw - 2 * BORDERPX; |
175 c->h = th - 2 * BORDERPX; |
174 c->h = th - 2 * BORDERPX; |
176 } |
175 } |
177 else { /* fallback if th < bh */ |
176 else { /* fallback if th < bh */ |
178 if(stackpos == StackBottom) |
177 if(stackpos == StackBottom) |
179 c->y += master; |
178 c->y += md; |
180 c->w = stackw - 2 * BORDERPX; |
179 c->w = stackw - 2 * BORDERPX; |
181 c->h = stackh - 2 * BORDERPX; |
180 c->h = stackh - 2 * BORDERPX; |
182 } |
181 } |
183 } |
182 } |
184 resize(c, False, TopLeft); |
183 resize(c, False, TopLeft); |
236 return False; |
235 return False; |
237 } |
236 } |
238 |
237 |
239 void |
238 void |
240 resizecol(Arg *arg) { |
239 resizecol(Arg *arg) { |
241 int s; |
|
242 unsigned int n; |
240 unsigned int n; |
243 Client *c; |
241 Client *c; |
244 |
242 |
245 for(n = 0, c = clients; c; c = c->next) |
243 for(n = 0, c = clients; c; c = c->next) |
246 if(isvisible(c) && !c->isfloat) |
244 if(isvisible(c) && !c->isfloat) |
247 n++; |
245 n++; |
248 if(!sel || sel->isfloat || n < 2 || (arrange == dofloat)) |
246 if(!sel || sel->isfloat || n < 2 || (arrange == dofloat)) |
249 return; |
247 return; |
250 |
248 |
251 s = stackpos == StackBottom ? sh - bh : sw; |
|
252 if(sel == getnext(clients)) { |
249 if(sel == getnext(clients)) { |
253 if(master + arg->i > s - MINDIM || master + arg->i < MINDIM) |
250 if(master + arg->i > 95 || master + arg->i < 5) |
254 return; |
251 return; |
255 master += arg->i; |
252 master += arg->i; |
256 } |
253 } |
257 else { |
254 else { |
258 if(master - arg->i > s - MINDIM || master - arg->i < MINDIM) |
255 if(master - arg->i > 95 || master - arg->i < 5) |
259 return; |
256 return; |
260 master -= arg->i; |
257 master -= arg->i; |
261 } |
258 } |
262 arrange(NULL); |
259 arrange(NULL); |
263 } |
260 } |