client.c
changeset 127 1480e19f6377
parent 124 75576e44c1d8
child 128 0a407fbb8092
equal deleted inserted replaced
126:1489f6b97714 127:1480e19f6377
    75 
    75 
    76 	if(!(c = getnext(sel->next, tsel)))
    76 	if(!(c = getnext(sel->next, tsel)))
    77 		c = getnext(clients, tsel);
    77 		c = getnext(clients, tsel);
    78 	if(c) {
    78 	if(c) {
    79 		higher(c);
    79 		higher(c);
    80 		c->revert = sel;
       
    81 		focus(c);
    80 		focus(c);
    82 	}
    81 	}
    83 }
    82 }
    84 
    83 
    85 void
    84 void
    91 		return;
    90 		return;
    92 
    91 
    93 	if(sel->ismax)
    92 	if(sel->ismax)
    94 		togglemax(NULL);
    93 		togglemax(NULL);
    95 
    94 
    96 	if((c = sel->revert && sel->revert->tags[tsel] ? sel->revert : NULL)) {
    95 	if(!(c = getprev(sel->prev))) {
       
    96 		for(c = clients; c && c->next; c = c->next);
       
    97 		c = getprev(c);
       
    98 	}
       
    99 	if(c) {
    97 		higher(c);
   100 		higher(c);
    98 		focus(c);
   101 		focus(c);
    99 	}
   102 	}
   100 }
   103 }
   101 
   104 
   125 gravitate(Client *c, Bool invert)
   128 gravitate(Client *c, Bool invert)
   126 {
   129 {
   127 	int dx = 0, dy = 0;
   130 	int dx = 0, dy = 0;
   128 
   131 
   129 	switch(c->grav) {
   132 	switch(c->grav) {
       
   133 	default:
       
   134 		break;
   130 	case StaticGravity:
   135 	case StaticGravity:
   131 	case NorthWestGravity:
   136 	case NorthWestGravity:
   132 	case NorthGravity:
   137 	case NorthGravity:
   133 	case NorthEastGravity:
   138 	case NorthEastGravity:
   134 		dy = c->border;
   139 		dy = c->border;
   141 	case SouthEastGravity:
   146 	case SouthEastGravity:
   142 	case SouthGravity:
   147 	case SouthGravity:
   143 	case SouthWestGravity:
   148 	case SouthWestGravity:
   144 		dy = -(c->h);
   149 		dy = -(c->h);
   145 		break;
   150 		break;
       
   151 	}
       
   152 
       
   153 	switch (c->grav) {
   146 	default:
   154 	default:
   147 		break;
   155 		break;
   148 	}
       
   149 
       
   150 	switch (c->grav) {
       
   151 	case StaticGravity:
   156 	case StaticGravity:
   152 	case NorthWestGravity:
   157 	case NorthWestGravity:
   153 	case WestGravity:
   158 	case WestGravity:
   154 	case SouthWestGravity:
   159 	case SouthWestGravity:
   155 		dx = c->border;
   160 		dx = c->border;
   162 	case NorthEastGravity:
   167 	case NorthEastGravity:
   163 	case EastGravity:
   168 	case EastGravity:
   164 	case SouthEastGravity:
   169 	case SouthEastGravity:
   165 		dx = -(c->w + c->border);
   170 		dx = -(c->w + c->border);
   166 		break;
   171 		break;
   167 	default:
       
   168 		break;
       
   169 	}
   172 	}
   170 
   173 
   171 	if(invert) {
   174 	if(invert) {
   172 		dx = -dx;
   175 		dx = -dx;
   173 		dy = -dy;
   176 		dy = -dy;
   202 }
   205 }
   203 
   206 
   204 void
   207 void
   205 manage(Window w, XWindowAttributes *wa)
   208 manage(Window w, XWindowAttributes *wa)
   206 {
   209 {
   207 	int diff;
       
   208 	Client *c;
   210 	Client *c;
   209 	Window trans;
   211 	Window trans;
   210 	XSetWindowAttributes twa;
   212 	XSetWindowAttributes twa;
   211 
   213 
   212 	c = emallocz(sizeof(Client));
   214 	c = emallocz(sizeof(Client));
   222 
   224 
   223 	c->border = 1;
   225 	c->border = 1;
   224 	c->proto = getproto(c->win);
   226 	c->proto = getproto(c->win);
   225 	setsize(c);
   227 	setsize(c);
   226 	XSelectInput(dpy, c->win,
   228 	XSelectInput(dpy, c->win,
   227 			StructureNotifyMask | PropertyChangeMask | EnterWindowMask);
   229 		StructureNotifyMask | PropertyChangeMask | EnterWindowMask);
   228 	XGetTransientForHint(dpy, c->win, &trans);
   230 	XGetTransientForHint(dpy, c->win, &trans);
   229 	twa.override_redirect = 1;
   231 	twa.override_redirect = 1;
   230 	twa.background_pixmap = ParentRelative;
   232 	twa.background_pixmap = ParentRelative;
   231 	twa.event_mask = ExposureMask;
   233 	twa.event_mask = ExposureMask;
   232 
   234 
   235 			DefaultVisual(dpy, screen),
   237 			DefaultVisual(dpy, screen),
   236 			CWOverrideRedirect | CWBackPixmap | CWEventMask, &twa);
   238 			CWOverrideRedirect | CWBackPixmap | CWEventMask, &twa);
   237 
   239 
   238 	settags(c);
   240 	settags(c);
   239 
   241 
       
   242 	if(clients)
       
   243 		clients->prev = c;
   240 	c->next = clients;
   244 	c->next = clients;
   241 	clients = c;
   245 	clients = c;
   242 
   246 
   243 	XGrabButton(dpy, Button1, MODKEY, c->win, False, ButtonPressMask,
   247 	XGrabButton(dpy, Button1, MODKEY, c->win, False, ButtonPressMask,
   244 			GrabModeAsync, GrabModeSync, None, None);
   248 			GrabModeAsync, GrabModeSync, None, None);
   262 		focus(c);
   266 		focus(c);
   263 	}
   267 	}
   264 	else {
   268 	else {
   265 		XMapRaised(dpy, c->win);
   269 		XMapRaised(dpy, c->win);
   266 		XMapRaised(dpy, c->title);
   270 		XMapRaised(dpy, c->title);
       
   271 
   267 	}
   272 	}
   268 }
   273 }
   269 
   274 
   270 void
   275 void
   271 pop(Client *c)
   276 pop(Client *c)
   272 {
   277 {
   273 	Client **l;
   278 	Client **l;
   274 
   279 
   275 	for(l = &clients; *l && *l != c; l = &(*l)->next);
   280 	for(l = &clients; *l && *l != c; l = &(*l)->next);
       
   281 	if(c->prev)
       
   282 		c->prev->next = c->next;
       
   283 	if(c->next)
       
   284 		c->next->prev = c->prev;
   276 	*l = c->next;
   285 	*l = c->next;
   277 
   286 
   278 	c->next = clients; /* pop */
   287 	if(clients)
       
   288 		clients->prev = c;
       
   289 	c->next = clients;
   279 	clients = c;
   290 	clients = c;
   280 	arrange(NULL);
   291 	arrange(NULL);
   281 }
   292 }
   282 
   293 
   283 void
   294 void
   437 
   448 
   438 	XUngrabButton(dpy, AnyButton, AnyModifier, c->win);
   449 	XUngrabButton(dpy, AnyButton, AnyModifier, c->win);
   439 	XDestroyWindow(dpy, c->title);
   450 	XDestroyWindow(dpy, c->title);
   440 
   451 
   441 	for(l = &clients; *l && *l != c; l = &(*l)->next);
   452 	for(l = &clients; *l && *l != c; l = &(*l)->next);
       
   453 	if(c->prev)
       
   454 		c->prev->next = c->next;
       
   455 	if(c->next)
       
   456 		c->next->prev = c->prev;
   442 	*l = c->next;
   457 	*l = c->next;
   443 	for(l = &clients; *l; l = &(*l)->next)
   458 	if(sel == c) {
   444 		if((*l)->revert == c)
   459 		sel = getnext(c->next, tsel);
   445 			(*l)->revert = NULL;
   460 		if(!sel)
   446 	if(sel == c)
   461 			sel = getprev(c->prev);
   447 		sel = sel->revert ? sel->revert : clients;
   462 		if(!sel)
   448 
   463 			sel = clients;
       
   464 	}
   449 	free(c);
   465 	free(c);
   450 
   466 
   451 	XSync(dpy, False);
   467 	XSync(dpy, False);
   452 	XSetErrorHandler(xerror);
   468 	XSetErrorHandler(xerror);
   453 	XUngrabServer(dpy);
   469 	XUngrabServer(dpy);