client.c
changeset 29 8ad86d0a6a53
parent 28 3dceb132082d
child 30 2e0fb4130bfb
equal deleted inserted replaced
28:3dceb132082d 29:8ad86d0a6a53
    16 {
    16 {
    17 	if(!stack)
    17 	if(!stack)
    18 		return;
    18 		return;
    19 	stack->x = sx;
    19 	stack->x = sx;
    20 	stack->y = bh;
    20 	stack->y = bh;
    21 	stack->w = sw - 2;
    21 	stack->w = sw - 2 * stack->border;
    22 	stack->h = sh - bh - 2;
    22 	stack->h = sh - bh - 2 * stack->border;
    23 	resize(stack);
    23 	resize(stack);
       
    24 	discard_events(EnterWindowMask);
    24 }
    25 }
    25 
    26 
    26 void
    27 void
    27 arrange(void *aux)
    28 arrange(void *aux)
    28 {
    29 {
    41 	if(rows * rows < n)
    42 	if(rows * rows < n)
    42 		cols = rows + 1;
    43 		cols = rows + 1;
    43 	else
    44 	else
    44 		cols = rows;
    45 		cols = rows;
    45 
    46 
    46 	gw = (sw - 1)  / cols;
    47 	gw = (sw - 2 * c->border)  / cols;
    47 	gh = (sh - bh - 1) / rows;
    48 	gh = (sh - bh - 2 * c->border) / rows;
    48 
    49 
    49 	for(i = j = 0, c = clients; c; c = c->next) {
    50 	for(i = j = 0, c = clients; c; c = c->next) {
    50 		c->x = i * gw;
    51 		c->x = i * gw;
    51 		c->y = j * gh + bh;
    52 		c->y = j * gh + bh;
    52 		c->w = gw;
    53 		c->w = gw;
    55 		if(++i == cols) {
    56 		if(++i == cols) {
    56 			j++;
    57 			j++;
    57 			i = 0;
    58 			i = 0;
    58 		}
    59 		}
    59 	}
    60 	}
       
    61 	discard_events(EnterWindowMask);
    60 }
    62 }
    61 
    63 
    62 void
    64 void
    63 sel(void *aux)
    65 sel(void *aux)
    64 {
    66 {
   159 		c->minw = size.min_width;
   161 		c->minw = size.min_width;
   160 		c->minh = size.min_height;
   162 		c->minh = size.min_height;
   161 	}
   163 	}
   162 	else
   164 	else
   163 		c->minw = c->minh = 0;
   165 		c->minw = c->minh = 0;
       
   166 	if(c->flags & PWinGravity)
       
   167 		c->grav = size.win_gravity;
       
   168 	else
       
   169 		c->grav = NorthWestGravity;
   164 }
   170 }
   165 
   171 
   166 void
   172 void
   167 raise(Client *c)
   173 raise(Client *c)
   168 {
   174 {
   211 	if(c->y < bh)
   217 	if(c->y < bh)
   212 		c->ty = c->y += bh;
   218 		c->ty = c->y += bh;
   213 	c->tw = c->w = wa->width;
   219 	c->tw = c->w = wa->width;
   214 	c->h = wa->height;
   220 	c->h = wa->height;
   215 	c->th = bh;
   221 	c->th = bh;
       
   222 	c->border = 1;
   216 	update_size(c);
   223 	update_size(c);
   217 	XSetWindowBorderWidth(dpy, c->win, 1);
   224 	XSetWindowBorderWidth(dpy, c->win, 1);
   218 	XSetWindowBorder(dpy, c->win, brush.border);
   225 	XSetWindowBorder(dpy, c->win, brush.border);
   219 	XSelectInput(dpy, c->win,
   226 	XSelectInput(dpy, c->win,
   220 			StructureNotifyMask | PropertyChangeMask | EnterWindowMask);
   227 			StructureNotifyMask | PropertyChangeMask | EnterWindowMask);
   245 	resize(c);
   252 	resize(c);
   246 	focus(c);
   253 	focus(c);
   247 }
   254 }
   248 
   255 
   249 void
   256 void
       
   257 gravitate(Client *c, Bool invert)
       
   258 {
       
   259 	int dx = 0, dy = 0;
       
   260 
       
   261 	switch(c->grav) {
       
   262 	case StaticGravity:
       
   263 	case NorthWestGravity:
       
   264 	case NorthGravity:
       
   265 	case NorthEastGravity:
       
   266 		dy = c->border;
       
   267 		break;
       
   268 	case EastGravity:
       
   269 	case CenterGravity:
       
   270 	case WestGravity:
       
   271 		dy = -(c->h / 2) + c->border;
       
   272 		break;
       
   273 	case SouthEastGravity:
       
   274 	case SouthGravity:
       
   275 	case SouthWestGravity:
       
   276 		dy = -c->h;
       
   277 		break;
       
   278 	default:
       
   279 		break;
       
   280 	}
       
   281 
       
   282 	switch (c->grav) {
       
   283 	case StaticGravity:
       
   284 	case NorthWestGravity:
       
   285 	case WestGravity:
       
   286 	case SouthWestGravity:
       
   287 		dx = c->border;
       
   288 		break;
       
   289 	case NorthGravity:
       
   290 	case CenterGravity:
       
   291 	case SouthGravity:
       
   292 		dx = -(c->w / 2) + c->border;
       
   293 		break;
       
   294 	case NorthEastGravity:
       
   295 	case EastGravity:
       
   296 	case SouthEastGravity:
       
   297 		dx = -(c->w + c->border);
       
   298 		break;
       
   299 	default:
       
   300 		break;
       
   301 	}
       
   302 
       
   303 	if(invert) {
       
   304 		dx = -dx;
       
   305 		dy = -dy;
       
   306 	}
       
   307 	c->x += dx;
       
   308 	c->y += dy;
       
   309 }
       
   310 
       
   311 void
   250 resize(Client *c)
   312 resize(Client *c)
   251 {
   313 {
   252 	XConfigureEvent e;
   314 	XConfigureEvent e;
   253 
   315 
   254 	resize_title(c);
   316 	resize_title(c);
   258 	e.window = c->win;
   320 	e.window = c->win;
   259 	e.x = c->x;
   321 	e.x = c->x;
   260 	e.y = c->y;
   322 	e.y = c->y;
   261 	e.width = c->w;
   323 	e.width = c->w;
   262 	e.height = c->h;
   324 	e.height = c->h;
   263 	e.border_width = 0;
   325 	e.border_width = c->border;
   264 	e.above = None;
   326 	e.above = None;
   265 	e.override_redirect = False;
   327 	e.override_redirect = False;
   266 	XSendEvent(dpy, c->win, False, StructureNotifyMask, (XEvent *)&e);
   328 	XSendEvent(dpy, c->win, False, StructureNotifyMask, (XEvent *)&e);
   267 	XFlush(dpy);
   329 	XFlush(dpy);
   268 }
   330 }