dwm/dwm-3.6.1-12pba: 85763b447d0f layout.c

view layout.c @ 15:85763b447d0f

add dwindle_m layout

author	paulo
date	Mon, 09 Apr 2018 20:08:44 -0600
parents	162accc5d36d
children

line source

1 /* (C)opyright MMVI-MMVII Anselm R. Garbe <garbeam at gmail dot com>

2 * See LICENSE file for license details.

3 */

4 #include "dwm.h"

6 unsigned int master = MASTER;

7 unsigned int nmaster = NMASTER;

8 unsigned int blw = 0;

9 Layout *lt = NULL;

11 /* static */

13 static unsigned int nlayouts = 0;

15 static void

16 spiral(void) {

17 unsigned int i, n, nx, ny, nw, nh;

18 Client *c;

20 nx = wax;

21 ny = way + wah;

22 nw = waw;

23 nh = wah;

24 for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))

25 n++;

26 for(i = 0, c = clients; c; c = c->next)

27 if(isvisible(c)) {

28 if(c->isbanned)

29 XMoveWindow(dpy, c->win, c->x, c->y);

30 c->isbanned = False;

31 if(c->isversatile)

32 continue;

33 c->ismax = False;

34 if((i % 2 && nh / 2 > 2 * c->border)

35 || (!(i % 2) && nw / 2 > 2 * c->border))

36 {

37 if(i < n - 1) {

38 if(i % 2)

39 nh /= 2;

40 else

41 nw /= 2;

42 if((i % 4) == 2)

43 nx += nw;

44 else if((i % 4) == 3)

45 ny += nh;

46 }

47 if((i % 4) == 0)

48 ny -= nh;

49 else if((i % 4) == 1)

50 nx += nw;

51 else if((i % 4) == 2)

52 ny += nh;

53 else

54 nx -= nw;

55 i++;

56 }

57 resize(c, nx, ny, nw - 2 * c->border, nh - 2 * c->border, False);

58 }

59 else {

60 c->isbanned = True;

61 XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);

62 }

63 if(!sel || !isvisible(sel)) {

64 for(c = stack; c && !isvisible(c); c = c->snext);

65 focus(c);

66 }

67 restack();

68 }

70 static void

71 dwindle_m(void) {

72 unsigned int i, j, n, nx, ny, nw, nh, mn, mr, mx, mw;

73 unsigned int m = 2;

74 //unsigned int m = nmaster;

75 Client *c;

77 nx = wax;

78 //ny = way + wah;

79 ny = 0;

80 nw = waw;

81 nh = wah;

82 mx = nx;

83 mw = nw / m;

84 for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))

85 n++;

86 mn = n / m;

87 mr = n % m;

88 for(i = 0, j = 0, c = clients; c; c = c->next)

89 if(isvisible(c)) {

90 if(c->isbanned)

91 XMoveWindow(dpy, c->win, c->x, c->y);

92 c->isbanned = False;

93 if(c->isversatile)

94 continue;

95 c->ismax = False;

96 if((i % 2 && nh / 2 > 2 * c->border)

97 || (!(i % 2) && nw / 2 > 2 * c->border))

98 {

99 if((j % m) == 0) {

100 if(i < mn - (mr > 0 ? 0 : 1)) {

101 if(i % 2)

102 nh /= 2;

103 else {

104 nw /= 2;

105 mw = nw / m;

106 }

107 }

108 else if(mr)

109 mw = nw / mr;

110 if((i % 4) == 0)

111 //ny -= nh;

112 ny += (i == 0 ? way : nh);

113 else if((i % 4) == 1)

114 nx += nw;

115 else if((i % 4) == 2)

116 ny += nh;

117 else

118 //nx -= nw;

119 nx += nw;

120 i++;

121 }

122 mx = nx + (j % m) * mw;

123 j++;

124 }

125 resize(c, mx, ny, mw - 2 * c->border, nh - 2 * c->border, False);

126 }

127 else {

128 c->isbanned = True;

129 XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);

130 }

131 if(!sel || !isvisible(sel)) {

132 for(c = stack; c && !isvisible(c); c = c->snext);

133 focus(c);

134 }

135 restack();

136 }

137

138 static void

139 spiral_h(void) {

140 unsigned int i, n, nx, ny, nw, nh;

141 Client *c;

142

143 nx = wax + waw;

144 ny = way;

145 nw = waw;

146 nh = wah;

147 for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))

148 n++;

149 for(i = 0, c = clients; c; c = c->next)

150 if(isvisible(c)) {

151 if(c->isbanned)

152 XMoveWindow(dpy, c->win, c->x, c->y);

153 c->isbanned = False;

154 if(c->isversatile)

155 continue;

156 c->ismax = False;

157 if((i % 2 && nw / 2 > 2 * c->border)

158 || (!(i % 2) && nh / 2 > 2 * c->border))

159 {

160 if(i < n - 1) {

161 if(i % 2)

162 nw /= 2;

163 else

164 nh /= 2;

165 if((i % 4) == 2)

166 ny += nh;

167 else if((i % 4) == 3)

168 nx += nw;

169 }

170 if((i % 4) == 0)

171 nx -= nw;

172 else if((i % 4) == 1)

173 ny += nh;

174 else if((i % 4) == 2)

175 nx += nw;

176 else

177 ny -= nh;

178 i++;

179 }

180 resize(c, nx, ny, nw - 2 * c->border, nh - 2 * c->border, False);

181 }

182 else {

183 c->isbanned = True;

184 XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);

185 }

186 if(!sel || !isvisible(sel)) {

187 for(c = stack; c && !isvisible(c); c = c->snext);

188 focus(c);

189 }

190 restack();

191 }

192

193 static void

194 monocle(void) {

195 Client *c;

196

197 for(c = clients; c; c = c->next)

198 if(isvisible(c) && c->isbanned) {

199 XMoveWindow(dpy, c->win, c->x, c->y);

200 c->isbanned = False;

201 }

202 else if(!isvisible(c)) {

203 c->isbanned = True;

204 XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);

205 }

206

207 for(c = nexttiled(clients); c; c = nexttiled(c->next))

208 resize(c, wax, way, waw - 2*c->border, wah - 2*c->border, False);

209

210 restack();

211 }

212

213 static void

214 bstack(void) {

215 unsigned int i, n, nx, ny, nw, nh, mw, mh, tw, th;

216 Client *c;

217

218 for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))

219 n++;

220 /* window geoms */

221 mh = (n > nmaster) ? (wah * master) / 1000 : wah;

222 mw = (n > nmaster) ? waw / nmaster : waw / (n > 0 ? n : 1);

223 th = wah - mh;

224 tw = (n > nmaster) ? waw / (n - nmaster) : 0;

225

226 for(i = 0, c = clients; c; c = c->next)

227 if(isvisible(c)) {

228 if(c->isbanned)

229 XMoveWindow(dpy, c->win, c->x, c->y);

230 c->isbanned = False;

231 if(c->isversatile)

232 continue;

233 c->ismax = False;

234 nx = wax;

235 ny = way;

236 if(i < nmaster) {

237 nx += i * mw;

238 nw = mw - 2 * BORDERPX;

239 nh = mh - 2 * BORDERPX;

240 }

241 else { /* tile window */

242 ny += mh;

243 nh = th - 2 * BORDERPX;

244 if(tw > 2 * BORDERPX) {

245 nx += (i - nmaster) * tw;

246 nw = tw - 2 * BORDERPX;

247 }

248 else /* fallback if th <= 2 * BORDERPX */

249 nw = waw - 2 * BORDERPX;

250 }

251 resize(c, nx, ny, nw, nh, False);

252 i++;

253 }

254 else {

255 c->isbanned = True;

256 XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);

257 }

258 if(!sel || !isvisible(sel)) {

259 for(c = stack; c && !isvisible(c); c = c->snext);

260 focus(c);

261 }

262 restack();

263 }

264

265 static void

266 grid(void) {

267 unsigned int n, cols, rows, cn, rn, i, cx, cy, cw, ch;

268 Client *c;

269

270 for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))

271 n++;

272 if(n == 0)

273 return;

274

275 /* grid dimensions */

276 for(cols = 0; cols <= n/2; cols++)

277 if(cols*cols >= n)

278 break;

279 if(n == 5) /* set layout against the general calculation: not 1:2:2, but 2:3 */

280 cols = 2;

281 rows = n/cols;

282

283 /* window geometries */

284 cw = cols ? waw / cols : waw;

285 cn = 0; /* current column number */

286 rn = 0; /* current row number */

287 for(i = 0, c = clients; c; c = c->next)

288 if(isvisible(c)) {

289 if(i/rows + 1 > cols - n%cols)

290 rows = n/cols + 1;

291 ch = rows ? wah / rows : wah;

292 cx = cn*cw;

293 cy = (TOPBAR ? dc.h : 0) + rn*ch;

294 resize(c, cx, cy, cw - 2 * BORDERPX, ch - 2 * BORDERPX, False);

295 rn++;

296 if(rn >= rows) {

297 rn = 0;

298 cn++;

299 }

300 i++;

301 }

302 else {

303 c->isbanned = True;

304 XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);

305 }

306

307 if(!sel || !isvisible(sel)) {

308 for(c = stack; c && !isvisible(c); c = c->snext);

309 focus(c);

310 }

311 restack();

312 }

313

314 static void

315 tile(void) {

316 unsigned int i, n, nx, ny, nw, nh, mw, mh, tw, th;

317 Client *c;

318

319 for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))

320 n++;

321 /* window geoms */

322 mh = (n > nmaster) ? wah / nmaster : wah / (n > 0 ? n : 1);

323 mw = (n > nmaster) ? (waw * master) / 1000 : waw;

324 th = (n > nmaster) ? wah / (n - nmaster) : 0;

325 tw = waw - mw;

326

327 for(i = 0, c = clients; c; c = c->next)

328 if(isvisible(c)) {

329 if(c->isbanned)

330 XMoveWindow(dpy, c->win, c->x, c->y);

331 c->isbanned = False;

332 if(c->isversatile)

333 continue;

334 c->ismax = False;

335 nx = wax;

336 ny = way;

337 if(i < nmaster) {

338 ny += i * mh;

339 nw = mw - 2 * BORDERPX;

340 nh = mh - 2 * BORDERPX;

341 }

342 else { /* tile window */

343 nx += mw;

344 nw = tw - 2 * BORDERPX;

345 if(th > 2 * BORDERPX) {

346 ny += (i - nmaster) * th;

347 nh = th - 2 * BORDERPX;

348 }

349 else /* fallback if th <= 2 * BORDERPX */

350 nh = wah - 2 * BORDERPX;

351 }

352 resize(c, nx, ny, nw, nh, False);

353 i++;

354 }

355 else {

356 c->isbanned = True;

357 XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);

358 }

359 if(!sel || !isvisible(sel)) {

360 for(c = stack; c && !isvisible(c); c = c->snext);

361 focus(c);

362 }

363 restack();

364 }

365

366 LAYOUTS

367

368 /* extern */

369

370 void

371 focusnext(Arg *arg) {

372 Client *c;

373

374 if(!sel)

375 return;

376 for(c = sel->next; c && !isvisible(c); c = c->next);

377 if(!c)

378 for(c = clients; c && !isvisible(c); c = c->next);

379 if(c) {

380 focus(c);

381 restack();

382 }

383 }

384

385 void

386 focusprev(Arg *arg) {

387 Client *c;

388

389 if(!sel)

390 return;

391 for(c = sel->prev; c && !isvisible(c); c = c->prev);

392 if(!c) {

393 for(c = clients; c && c->next; c = c->next);

394 for(; c && !isvisible(c); c = c->prev);

395 }

396 if(c) {

397 focus(c);

398 restack();

399 }

400 }

401

402 void

403 incnmaster(Arg *arg) {

404 //if((lt->arrange != tile) || (nmaster + arg->i < 1)

405 //|| (wah / (nmaster + arg->i) <= 2 * BORDERPX))

406 // return;

407 if(nmaster + arg->i < 1 && nmaster + arg->i <= MAX_TASKS)

408 return;

409 nmaster += arg->i;

410 if(sel)

411 lt->arrange();

412 else

413 drawstatus();

414 }

415

416 void

417 initlayouts(void) {

418 unsigned int i, w;

419

420 lt = &layout[0];

421 nlayouts = sizeof layout / sizeof layout[0];

422 for(blw = i = 0; i < nlayouts; i++) {

423 w = textw(layout[i].symbol);

424 if(w > blw)

425 blw = w;

426 }

427 }

428

429 Client *

430 nexttiled(Client *c) {

431 for(; c && (c->isversatile || !isvisible(c)); c = c->next);

432 return c;

433 }

434

435 void

436 resizemaster(Arg *arg) {

437 //if(lt->arrange != tile)

438 // return;

439 if(arg->i == 0)

440 master = MASTER;

441 else {

442 //if(waw * (master + arg->i) / 1000 >= waw - 2 * BORDERPX

443 //|| waw * (master + arg->i) / 1000 <= 2 * BORDERPX)

444 // return;

445 master += arg->i;

446 }

447 lt->arrange();

448 }

449

450 void

451 restack(void) {

452 Client *c;

453 XEvent ev;

454

455 drawstatus();

456 if(!sel)

457 return;

458 if(sel->isversatile || lt->arrange == versatile)

459 XRaiseWindow(dpy, sel->win);

460 if(lt->arrange != versatile) {

461 if(!sel->isversatile)

462 XLowerWindow(dpy, sel->win);

463 for(c = nexttiled(clients); c; c = nexttiled(c->next)) {

464 if(c == sel)

465 continue;

466 XLowerWindow(dpy, c->win);

467 }

468 }

469 XSync(dpy, False);

470 while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));

471 }

472

473 void

474 setlayout(Arg *arg) {

475 int i;

476

477 if(arg->i < 0) {

478 for(i = 0; i < nlayouts && lt != &layout[i]; i++);

479 if(arg->i == -1)

480 lt = &layout[(i + 1) % nlayouts];

481 else if(arg->i == -2)

482 lt = &layout[(i - 1) >= 0 ? i - 1 : nlayouts - 1];

483 }

484 else {

485 if(arg->i < 0 || arg->i >= nlayouts)

486 return;

487 lt = &layout[arg->i];

488 }

489 if(sel)

490 lt->arrange();

491 else

492 drawstatus();

493 }

494

495 void

496 versatile(void) {

497 Client *c;

498

499 for(c = clients; c; c = c->next) {

500 if(isvisible(c)) {

501 if(c->isbanned)

502 XMoveWindow(dpy, c->win, c->x, c->y);

503 c->isbanned = False;

504 resize(c, c->x, c->y, c->w, c->h, True);

505 }

506 else {

507 c->isbanned = True;

508 XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);

509 }

510 }

511 if(!sel || !isvisible(sel)) {

512 for(c = stack; c && !isvisible(c); c = c->snext);

513 focus(c);

514 }

515 restack();

516 }

Mercurial > hg > index.fcgi > dwm > dwm-3.6.1-12pba

view layout.c @ 15:85763b447d0f