Mercurial Mercurial > dwm / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
dwm.c
changeset 1500 48c3f87c335d
parent 1497 20de01c5ff82
child 1502 15761ac5e2f1
equal deleted inserted replaced
1499:e41abf7aa633 1500:48c3f87c335d 
   150 } Rule;
 
   150 } Rule;
 
   151 
   151 
   152 /* function declarations */
 
   152 /* function declarations */
 
   153 static void applyrules(Client *c);
 
   153 static void applyrules(Client *c);
 
   154 static Bool applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact);
 
   154 static Bool applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact);
 
   155 static void arrange(void);
 
   155 static void arrange(Monitor *m);
 
       
   156 static void arrangemon(Monitor *m);
 
   156 static void attach(Client *c);
 
   157 static void attach(Client *c);
 
   157 static void attachstack(Client *c);
 
   158 static void attachstack(Client *c);
 
   158 static void buttonpress(XEvent *e);
 
   159 static void buttonpress(XEvent *e);
 
   159 static void checkotherwm(void);
 
   160 static void checkotherwm(void);
 
   160 static void cleanup(void);
 
   161 static void cleanup(void);
 
   377 	}
 
   378 	}
 
   378 	return *x != c->x || *y != c->y || *w != c->w || *h != c->h;
 
   379 	return *x != c->x || *y != c->y || *w != c->w || *h != c->h;
 
   379 }
 
   380 }
 
   380 
   381 
   381 void
 
   382 void
 
   382 arrange(void) {
 
   383 arrange(Monitor *m) {
 
   383 	Monitor *m;
 
   384 	if(m)
 
   384 
   385 		showhide(m->stack);
 
   385 	for(m = mons; m; m = m->next)
 
   386 	else for(m = mons; m; m = m->next)
 
   386 		showhide(m->stack);
 
   387 		showhide(m->stack);
 
   387 	focus(NULL);
 
   388 	focus(NULL);
 
   388 	for(m = mons; m; m = m->next) {
 
   389 	if(m)
 
   389 		strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, sizeof m->ltsymbol);
 
   390 		arrangemon(m);
 
   390 		if(m->lt[m->sellt]->arrange)
 
   391 	else for(m = mons; m; m = m->next)
 
   391 			m->lt[m->sellt]->arrange(m);
 
   392 		arrangemon(m);
 
   392 		restack(m);
 
   393 }
 
   393 	}
 
   394 
       
   395 void
 
       
   396 arrangemon(Monitor *m) {
 
       
   397 	strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, sizeof m->ltsymbol);
 
       
   398 	if(m->lt[m->sellt]->arrange)
 
       
   399 		m->lt[m->sellt]->arrange(m);
 
       
   400 	restack(m);
 
   394 }
 
   401 }
 
   395 
   402 
   396 void
 
   403 void
 
   397 attach(Client *c) {
 
   404 attach(Client *c) {
 
   398 	c->next = c->mon->clients;
 
   405 	c->next = c->mon->clients;
 
   544 				XFreePixmap(dpy, dc.drawable);
 
   551 				XFreePixmap(dpy, dc.drawable);
 
   545 			dc.drawable = XCreatePixmap(dpy, root, sw, bh, DefaultDepth(dpy, screen));
 
   552 			dc.drawable = XCreatePixmap(dpy, root, sw, bh, DefaultDepth(dpy, screen));
 
   546 			updatebars();
 
   553 			updatebars();
 
   547 			for(m = mons; m; m = m->next)
 
   554 			for(m = mons; m; m = m->next)
 
   548 				XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, m->ww, bh);
 
   555 				XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, m->ww, bh);
 
   549 			arrange();
 
   556 			arrange(NULL);
 
   550 		}
 
   557 		}
 
   551 	}
 
   558 	}
 
   552 }
 
   559 }
 
   553 
   560 
   554 void
 
   561 void
 
  1137 	attach(c);
 
  1144 	attach(c);
 
  1138 	attachstack(c);
 
  1145 	attachstack(c);
 
  1139 	XMoveResizeWindow(dpy, c->win, c->x + 2 * sw, c->y, c->w, c->h); /* some windows require this */
 
  1146 	XMoveResizeWindow(dpy, c->win, c->x + 2 * sw, c->y, c->w, c->h); /* some windows require this */
 
  1140 	XMapWindow(dpy, c->win);
 
  1147 	XMapWindow(dpy, c->win);
 
  1141 	setclientstate(c, NormalState);
 
  1148 	setclientstate(c, NormalState);
 
  1142 	arrange();
 
  1149 	arrange(c->mon);
 
  1143 }
 
  1150 }
 
  1144 
  1151 
  1145 void
 
  1152 void
 
  1146 mappingnotify(XEvent *e) {
 
  1153 mappingnotify(XEvent *e) {
 
  1147 	XMappingEvent *ev = &e->xmapping;
 
  1154 	XMappingEvent *ev = &e->xmapping;
 
  1263 		switch (ev->atom) {
 
  1270 		switch (ev->atom) {
 
  1264 		default: break;
 
  1271 		default: break;
 
  1265 		case XA_WM_TRANSIENT_FOR:
 
  1272 		case XA_WM_TRANSIENT_FOR:
 
  1266 			XGetTransientForHint(dpy, c->win, &trans);
 
  1273 			XGetTransientForHint(dpy, c->win, &trans);
 
  1267 			if(!c->isfloating && (c->isfloating = (wintoclient(trans) != NULL)))
 
  1274 			if(!c->isfloating && (c->isfloating = (wintoclient(trans) != NULL)))
 
  1268 				arrange();
 
  1275 				arrange(c->mon);
 
  1269 			break;
 
  1276 			break;
 
  1270 		case XA_WM_NORMAL_HINTS:
 
  1277 		case XA_WM_NORMAL_HINTS:
 
  1271 			updatesizehints(c);
 
  1278 			updatesizehints(c);
 
  1272 			break;
 
  1279 			break;
 
  1273 		case XA_WM_HINTS:
 
  1280 		case XA_WM_HINTS:
 
  1358 restack(Monitor *m) {
 
  1365 restack(Monitor *m) {
 
  1359 	Client *c;
 
  1366 	Client *c;
 
  1360 	XEvent ev;
 
  1367 	XEvent ev;
 
  1361 	XWindowChanges wc;
 
  1368 	XWindowChanges wc;
 
  1362 
  1369 
  1363 	drawbars();
 
  1370 	drawbar(m);
 
  1364 	if(!m->sel)
 
  1371 	if(!m->sel)
 
  1365 		return;
 
  1372 		return;
 
  1366 	if(m->sel->isfloating || !m->lt[m->sellt]->arrange)
 
  1373 	if(m->sel->isfloating || !m->lt[m->sellt]->arrange)
 
  1367 		XRaiseWindow(dpy, m->sel->win);
 
  1374 		XRaiseWindow(dpy, m->sel->win);
 
  1368 	if(m->lt[m->sellt]->arrange) {
 
  1375 	if(m->lt[m->sellt]->arrange) {
 
  1425 	c->mon = m;
 
  1432 	c->mon = m;
 
  1426 	c->tags = m->tagset[m->seltags]; /* assign tags of target monitor */
 
  1433 	c->tags = m->tagset[m->seltags]; /* assign tags of target monitor */
 
  1427 	attach(c);
 
  1434 	attach(c);
 
  1428 	attachstack(c);
 
  1435 	attachstack(c);
 
  1429 	focus(NULL);
 
  1436 	focus(NULL);
 
  1430 	arrange();
 
  1437 	arrange(NULL);
 
  1431 }
 
  1438 }
 
  1432 
  1439 
  1433 void
 
  1440 void
 
  1434 setclientstate(Client *c, long state) {
 
  1441 setclientstate(Client *c, long state) {
 
  1435 	long data[] = { state, None };
 
  1442 	long data[] = { state, None };
 
  1440 
  1447 
  1441 void
 
  1448 void
 
  1442 setlayout(const Arg *arg) {
 
  1449 setlayout(const Arg *arg) {
 
  1443 	if(!arg || !arg->v || arg->v != selmon->lt[selmon->sellt])
 
  1450 	if(!arg || !arg->v || arg->v != selmon->lt[selmon->sellt])
 
  1444 		selmon->sellt ^= 1;
 
  1451 		selmon->sellt ^= 1;
 
  1445 	if(arg && arg->v)
 
  1452 	if(arg && arg->v) {
 
  1446 		selmon->lt[selmon->sellt] = (Layout *)arg->v;
 
  1453 		selmon->lt[selmon->sellt] = (Layout *)arg->v;
 
       
  1454 		strncpy(selmon->ltsymbol, selmon->lt[selmon->sellt]->symbol, sizeof selmon->ltsymbol);
 
       
  1455 	}
 
  1447 	if(selmon->sel)
 
  1456 	if(selmon->sel)
 
  1448 		arrange();
 
  1457 		arrange(selmon);
 
  1449 	else
 
  1458 	else
 
  1450 		drawbars();
 
  1459 		drawbar(selmon);
 
  1451 }
 
  1460 }
 
  1452 
  1461 
  1453 /* arg > 1.0 will set mfact absolutly */
 
  1462 /* arg > 1.0 will set mfact absolutly */
 
  1454 void
 
  1463 void
 
  1455 setmfact(const Arg *arg) {
 
  1464 setmfact(const Arg *arg) {
 
  1459 		return;
 
  1468 		return;
 
  1460 	f = arg->f < 1.0 ? arg->f + selmon->mfact : arg->f - 1.0;
 
  1469 	f = arg->f < 1.0 ? arg->f + selmon->mfact : arg->f - 1.0;
 
  1461 	if(f < 0.1 || f > 0.9)
 
  1470 	if(f < 0.1 || f > 0.9)
 
  1462 		return;
 
  1471 		return;
 
  1463 	selmon->mfact = f;
 
  1472 	selmon->mfact = f;
 
  1464 	arrange();
 
  1473 	arrange(selmon);
 
  1465 }
 
  1474 }
 
  1466 
  1475 
  1467 void
 
  1476 void
 
  1468 setup(void) {
 
  1477 setup(void) {
 
  1469 	XSetWindowAttributes wa;
 
  1478 	XSetWindowAttributes wa;
 
  1556 
  1565 
  1557 void
 
  1566 void
 
  1558 tag(const Arg *arg) {
 
  1567 tag(const Arg *arg) {
 
  1559 	if(selmon->sel && arg->ui & TAGMASK) {
 
  1568 	if(selmon->sel && arg->ui & TAGMASK) {
 
  1560 		selmon->sel->tags = arg->ui & TAGMASK;
 
  1569 		selmon->sel->tags = arg->ui & TAGMASK;
 
  1561 		arrange();
 
  1570 		arrange(selmon);
 
  1562 	}
 
  1571 	}
 
  1563 }
 
  1572 }
 
  1564 
  1573 
  1565 void
 
  1574 void
 
  1566 tagmon(const Arg *arg) {
 
  1575 tagmon(const Arg *arg) {
 
  1613 void
 
  1622 void
 
  1614 togglebar(const Arg *arg) {
 
  1623 togglebar(const Arg *arg) {
 
  1615 	selmon->showbar = !selmon->showbar;
 
  1624 	selmon->showbar = !selmon->showbar;
 
  1616 	updatebarpos(selmon);
 
  1625 	updatebarpos(selmon);
 
  1617 	XMoveResizeWindow(dpy, selmon->barwin, selmon->wx, selmon->by, selmon->ww, bh);
 
  1626 	XMoveResizeWindow(dpy, selmon->barwin, selmon->wx, selmon->by, selmon->ww, bh);
 
  1618 	arrange();
 
  1627 	arrange(selmon);
 
  1619 }
 
  1628 }
 
  1620 
  1629 
  1621 void
 
  1630 void
 
  1622 togglefloating(const Arg *arg) {
 
  1631 togglefloating(const Arg *arg) {
 
  1623 	if(!selmon->sel)
 
  1632 	if(!selmon->sel)
 
  1624 		return;
 
  1633 		return;
 
  1625 	selmon->sel->isfloating = !selmon->sel->isfloating || selmon->sel->isfixed;
 
  1634 	selmon->sel->isfloating = !selmon->sel->isfloating || selmon->sel->isfixed;
 
  1626 	if(selmon->sel->isfloating)
 
  1635 	if(selmon->sel->isfloating)
 
  1627 		resize(selmon->sel, selmon->sel->x, selmon->sel->y,
 
  1636 		resize(selmon->sel, selmon->sel->x, selmon->sel->y,
 
  1628 		       selmon->sel->w, selmon->sel->h, False);
 
  1637 		       selmon->sel->w, selmon->sel->h, False);
 
  1629 	arrange();
 
  1638 	arrange(selmon);
 
  1630 }
 
  1639 }
 
  1631 
  1640 
  1632 void
 
  1641 void
 
  1633 toggletag(const Arg *arg) {
 
  1642 toggletag(const Arg *arg) {
 
  1634 	unsigned int newtags;
 
  1643 	unsigned int newtags;
 
  1636 	if(!selmon->sel)
 
  1645 	if(!selmon->sel)
 
  1637 		return;
 
  1646 		return;
 
  1638 	newtags = selmon->sel->tags ^ (arg->ui & TAGMASK);
 
  1647 	newtags = selmon->sel->tags ^ (arg->ui & TAGMASK);
 
  1639 	if(newtags) {
 
  1648 	if(newtags) {
 
  1640 		selmon->sel->tags = newtags;
 
  1649 		selmon->sel->tags = newtags;
 
  1641 		arrange();
 
  1650 		arrange(selmon);
 
  1642 	}
 
  1651 	}
 
  1643 }
 
  1652 }
 
  1644 
  1653 
  1645 void
 
  1654 void
 
  1646 toggleview(const Arg *arg) {
 
  1655 toggleview(const Arg *arg) {
 
  1647 	unsigned int newtagset = selmon->tagset[selmon->seltags] ^ (arg->ui & TAGMASK);
 
  1656 	unsigned int newtagset = selmon->tagset[selmon->seltags] ^ (arg->ui & TAGMASK);
 
  1648 
  1657 
  1649 	if(newtagset) {
 
  1658 	if(newtagset) {
 
  1650 		selmon->tagset[selmon->seltags] = newtagset;
 
  1659 		selmon->tagset[selmon->seltags] = newtagset;
 
  1651 		arrange();
 
  1660 		arrange(selmon);
 
  1652 	}
 
  1661 	}
 
  1653 }
 
  1662 }
 
  1654 
  1663 
  1655 void
 
  1664 void
 
  1656 unfocus(Client *c) {
 
  1665 unfocus(Client *c) {
 
  1661 	XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
 
  1670 	XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
 
  1662 }
 
  1671 }
 
  1663 
  1672 
  1664 void
 
  1673 void
 
  1665 unmanage(Client *c, Bool destroyed) {
 
  1674 unmanage(Client *c, Bool destroyed) {
 
       
  1675 	Monitor *m = c->mon;
 
  1666 	XWindowChanges wc;
 
  1676 	XWindowChanges wc;
 
  1667 
  1677 
  1668 	/* The server grab construct avoids race conditions. */
 
  1678 	/* The server grab construct avoids race conditions. */
 
  1669 	detach(c);
 
  1679 	detach(c);
 
  1670 	detachstack(c);
 
  1680 	detachstack(c);
 
  1679 		XSetErrorHandler(xerror);
 
  1689 		XSetErrorHandler(xerror);
 
  1680 		XUngrabServer(dpy);
 
  1690 		XUngrabServer(dpy);
 
  1681 	}
 
  1691 	}
 
  1682 	free(c);
 
  1692 	free(c);
 
  1683 	focus(NULL);
 
  1693 	focus(NULL);
 
  1684 	arrange();
 
  1694 	arrange(m);
 
  1685 }
 
  1695 }
 
  1686 
  1696 
  1687 void
 
  1697 void
 
  1688 unmapnotify(XEvent *e) {
 
  1698 unmapnotify(XEvent *e) {
 
  1689 	Client *c;
 
  1699 	Client *c;
 
  1906 	if((arg->ui & TAGMASK) == selmon->tagset[selmon->seltags])
 
  1916 	if((arg->ui & TAGMASK) == selmon->tagset[selmon->seltags])
 
  1907 		return;
 
  1917 		return;
 
  1908 	selmon->seltags ^= 1; /* toggle sel tagset */
 
  1918 	selmon->seltags ^= 1; /* toggle sel tagset */
 
  1909 	if(arg->ui & TAGMASK)
 
  1919 	if(arg->ui & TAGMASK)
 
  1910 		selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
 
  1920 		selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
 
  1911 	arrange();
 
  1921 	arrange(selmon);
 
  1912 }
 
  1922 }
 
  1913 
  1923 
  1914 Client *
 
  1924 Client *
 
  1915 wintoclient(Window w) {
 
  1925 wintoclient(Window w) {
 
  1916 	Client *c;
 
  1926 	Client *c;
 
  1984 		if(!c || !(c = nexttiled(c->next)))
 
  1994 		if(!c || !(c = nexttiled(c->next)))
 
  1985 			return;
 
  1995 			return;
 
  1986 	detach(c);
 
  1996 	detach(c);
 
  1987 	attach(c);
 
  1997 	attach(c);
 
  1988 	focus(c);
 
  1998 	focus(c);
 
  1989 	arrange();
 
  1999 	arrange(c->mon);
 
  1990 }
 
  2000 }
 
  1991 
  2001 
  1992 int
 
  2002 int
 
  1993 main(int argc, char *argv[]) {
 
  2003 main(int argc, char *argv[]) {
 
  1994 	if(argc == 2 && !strcmp("-v", argv[1]))
 
  2004 	if(argc == 2 && !strcmp("-v", argv[1]))
dwm