gemini - kennedy.gemi.dev

0 /*

1 * window.c - window management routines

2 */

4 /*

6 *

7 * Permission is hereby granted, free of charge, to any person obtaining a

8 * copy of this software and associated documentation files (the "Software"),

9 * to deal in the Software without restriction, including without limitation

10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

11 * and/or sell copies of the Software, and to permit persons to whom the

12 * Software is furnished to do so, subject to the following conditions:

13 *

14 * The above copyright notice and this permission notice shall be included

15 * in all copies or substantial portions of the Software.

16 *

17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

23 * DEALINGS IN THE SOFTWARE.

24 */

26 #include <X11/X.h>

27 #include <assert.h>

28 #include <limits.h>

29 #include <stdio.h>

30 #include <stdlib.h>

31 #include <string.h>

32 #include <unistd.h>

34 #include <X11/cursorfont.h>

35 #include <X11/Xatom.h>

36 #include <X11/Xlib.h>

37 #include <X11/Xutil.h>

39 #include "button.h"

40 #include "global.h"

41 #include "hints.h"

42 #include "lib.h"

43 #include "menu.h"

44 #include "resizer.h"

45 #include "title.h"

46 #include "widget.h"

47 #include "window.h"

48 #include "monitor.h"

49 #include "ewmh.h"

51 #define NBTN 3

53 struct window *active = NULL;

55 static Atom WM_STATE;

57 static Window front;

59 static LIST_DEFINE(normallayer);

60 static LIST_DEFINE(toplayer);

61 static int needrestack = 0;

62 static int nwindows = 0;

64 static Cursor movecurs;

65 static Cursor normalcurs;

67 static void client_to_window_geom(XWindowAttributes *, XSizeHints *,

68 int *x, int *y, int *width, int *height, int decoration);

69 static void window_to_client_geom(struct window *,

70 int *x, int *y, int *width, int *height);

71 static void confevent(struct window *, XConfigureRequestEvent *);

72 static void windowevent(struct widget *, XEvent *);

73 static void setgrav(Window, int);

74 static void restack_transient_windows(struct window *);

75 static void put_window_group_below(struct window *);

76 static void selectfrommenu(void *ptr);

77 static struct window *topmost_window(void);

78 static void fitwin(struct window *);

79 static void smartpos(int, int, int *, int *, int);

80 static void make_window_visible(struct window *);

82 // TOCHECK

83 void *getprop(Window w, Atom prop, Atom type, int fmt, unsigned long *rcountp)

84 {

85 void *ptr = NULL;

86 unsigned long count = 32;

87 Atom rtype;

88 int rfmt;

89 unsigned long rafter;

90 for (;;) {

91 if (XGetWindowProperty(display, w, prop, 0L, count,

92 False, type, &rtype, &rfmt, rcountp,

93 &rafter, (unsigned char **)&ptr) != Success) {

94 // Error

95 return NULL;

96 } else if (rtype != type || rfmt != fmt) {

97 // Does not exist (type=None), or wrong type/format

98 return NULL;

99 } else if (rafter > 0) {

100 XFree(ptr);

101 ptr = NULL;

102 count *= 2;

103 } else {

104 return ptr;

105 }

106 }

107 }

108

109 static int ismapped(Window client)

110 {

111 XWindowAttributes attr;

112 int rval = 0;

113

114 clerr();

115 if (XGetWindowAttributes(display, client, &attr))

116 rval = attr.map_state != IsUnmapped;

117 sterr();

118

119 return rval;

120 }

121

122 void window_init(void)

123 {

124 XSetWindowAttributes attr;

125 Window *winlist;

126 Window d1, d2;

127 unsigned int i, n;

128

129 attr.override_redirect = True;

130 front = XCreateWindow(display, root, 0, 0, 1, 1, 0, 0, InputOnly,

131 CopyFromParent, CWOverrideRedirect, &attr);

132 movecurs = XCreateFontCursor(display, XC_fleur);

133 normalcurs = XCreateFontCursor(display, XC_left_ptr);

134 XDefineCursor(display, root, normalcurs);

135

136 if (XQueryTree(display, root, &d1, &d2, &winlist, &n)) {

137 for (i = 0; i < n; i++)

138 if (find_widget(winlist[i], WIDGET_ANY) == NULL

139 && ismapped(winlist[i]))

140 manage_window(winlist[i], 1);

141 if (winlist != NULL)

142 XFree(winlist);

143 }

144 }

145

146 void window_fini(void)

147 {

148 struct window *win;

149 LIST *lp;

150

151 while (!LIST_EMPTY(&normallayer)) {

152 lp = LIST_TAIL(&normallayer);

153 win = LIST_ITEM(lp, struct window, layerlink);

154 unmanage_window(win, 0);

155 }

156 while (!LIST_EMPTY(&toplayer)) {

157 lp = LIST_TAIL(&toplayer);

158 win = LIST_ITEM(lp, struct window, layerlink);

159 unmanage_window(win, 0);

160 }

161

162 XDestroyWindow(display, front);

163 }

164

165 void raise_window(struct window *win)

166 {

167 LIST_REMOVE(&win->layerlink);

168 LIST_INSERT_HEAD(win->layer, &win->layerlink);

169 needrestack = 1;

170 }

171

172 void lower_window(struct window *win)

173 {

174 LIST_REMOVE(&win->layerlink);

175 win->layer = &normallayer;

176 LIST_INSERT_TAIL(win->layer, &win->layerlink);

177 needrestack = 1;

178 repaint_window(win); /* might have changed layer */

179 }

180

181 static void lower_window_within_layer(struct window *win)

182 {

183 LIST_REMOVE(&win->layerlink);

184 LIST_INSERT_TAIL(win->layer, &win->layerlink);

185 needrestack = 1;

186 }

187

188 void put_window_above(struct window *win, struct window *ref)

189 {

190 LIST_REMOVE(&win->layerlink);

191 win->layer = ref->layer;

192 LIST_INSERT_BEFORE(&ref->layerlink, &win->layerlink);

193 needrestack = 1;

194 repaint_window(win); /* might have changed layer */

195 }

196

197 void put_window_below(struct window *win, struct window *ref)

198 {

199 LIST_REMOVE(&win->layerlink);

200 win->layer = ref->layer;

201 LIST_INSERT_AFTER(&ref->layerlink, &win->layerlink);

202 needrestack = 1;

203 repaint_window(win); /* might have changed layer */

204 }

205

206 void toggle_window_ontop(struct window *win)

207 {

208 win->layer = win->layer == &toplayer ? &normallayer : &toplayer;

209 LIST_REMOVE(&win->layerlink);

210 LIST_INSERT_HEAD(win->layer, &win->layerlink);

211 needrestack = 1;

212 restack_transient_windows(win);

213 repaint_window(win); /* changed layer */

214 }

215

216 int window_is_ontop(struct window *win)

217 {

218 return win->layer == &toplayer;

219 }

220

221 void get_window_stack(struct window ***wins_return, int *nwins_return)

222 {

223 LIST *lp;

224 int i;

225

226 *wins_return = MALLOC(nwindows * sizeof (struct window *));

227 *nwins_return = nwindows;

228 i = 0;

229 LIST_FOREACH(lp, &toplayer) {

230 assert(i < nwindows);

231 (*wins_return)[i++] = LIST_ITEM(lp, struct window, layerlink);

232 }

233 LIST_FOREACH(lp, &normallayer) {

234 assert(i < nwindows);

235 (*wins_return)[i++] = LIST_ITEM(lp, struct window, layerlink);

236 }

237 assert(i == nwindows);

238 }

239

240 void get_client_stack(Window **clients_return, int *nclients_return)

241 {

242 LIST *lp;

243 struct window *win;

244 int i;

245

246 *clients_return = MALLOC(nwindows * sizeof (Window));

247 *nclients_return = nwindows;

248 i = 0;

249 LIST_FOREACH(lp, &toplayer) {

250 assert(i < nwindows);

251 win = LIST_ITEM(lp, struct window, layerlink);

252 (*clients_return)[i++] = win->client;

253 }

254 LIST_FOREACH(lp, &normallayer) {

255 assert(i < nwindows);

256 win = LIST_ITEM(lp, struct window, layerlink);

257 (*clients_return)[i++] = win->client;

258 }

259 assert(i == nwindows);

260 }

261

262 void restack_all_windows(void)

263 {

264 Window *xwins;

265 struct window *win;

266 LIST *lp;

267 int i;

268

269 if (!needrestack)

270 return;

271

272 xwins = MALLOC((nwindows + 1) * sizeof (Window));

273 xwins[0] = front;

274 i = 1;

275 LIST_FOREACH(lp, &toplayer) {

276 assert(i < nwindows + 1);

277 win = LIST_ITEM(lp, struct window, layerlink);

278 xwins[i++] = WIDGET_XWINDOW(win);

279 }

280 LIST_FOREACH(lp, &normallayer) {

281 assert(i < nwindows + 1);

282 win = LIST_ITEM(lp, struct window, layerlink);

283 xwins[i++] = WIDGET_XWINDOW(win);

284 }

285 assert(i == nwindows + 1);

286 XRestackWindows(display, xwins, nwindows + 1);

287 FREE(xwins);

288 needrestack = 0;

289

290 hints_restack();

291 }

292

293 static struct window *topmost_window(void)

294 {

295 struct window *win;

296 LIST *lp;

297 /*

298 LIST_FOREACH(lp, &toplayer) {

299 win = LIST_ITEM(lp, struct window, layerlink);

300 if (WIDGET_MAPPED(win))

301 return win;

302 }*/

303 LIST_FOREACH(lp, &normallayer) {

304 win = LIST_ITEM(lp, struct window, layerlink);

305 if (WIDGET_MAPPED(win))

306 return win;

307 }

308 return NULL;

309 }

310

311 void map_window(struct window *win)

312 {

313 if (WIDGET_MAPPED(win))

314 return;

315

316 clerr();

317 XMapWindow(display, win->client);

318 sterr();

319

320 map_widget((struct widget *)win);

321

322 hints_map(win);

323 }

324

325 void unmap_window(struct window *win)

326 {

327 if (!WIDGET_MAPPED(win))

328 return;

329

330 unmap_widget((struct widget *)win);

331

332 if (win == active)

333 set_active_window(NULL);

334

335 clerr();

336 win->ignoreunmap++;

337 XUnmapWindow(display, win->client);

338 sterr();

339

340 hints_unmap(win);

341

342 lower_window_within_layer(win);

343

344 if (win->menuitem != NULL)

345 put_menuitem_last(win->menuitem);

346 /*

347 if (!LIST_EMPTY(&normallayer)) {

348 struct listnode* lp = LIST_TAIL(&normallayer);

349 win = LIST_ITEM(lp, struct window, layerlink);

350 set_active_window(win);

351 }*/

352 }

353

354 void user_unmap_window(struct window *win)

355 {

356 struct window **wins;

357 int i, n, wasactive;

358

359 wasactive = window_is_active(win);

360

361 unmap_window(win);

362

363 get_window_stack(&wins, &n);

364 for (i = 0; i < n; i++) {

365 if (windows_are_transient_related(wins[i], win)

366 && WIDGET_MAPPED(wins[i]))

367 unmap_window(wins[i]);

368 }

369 FREE(wins);

370

371 if (wasactive)

372 set_active_window(topmost_window());

373 }

374

375 static int getwmstate(Window xwindow, long *statp)

376 {

377 unsigned long nitems, bytes_after;

378 unsigned char *prop;

379 Atom actual_type;

380 int actual_format;

381 int rval = -1;

382

383 if (XGetWindowProperty(display, xwindow,

384 WM_STATE, 0L, 2L, False, WM_STATE, &actual_type, &actual_format,

385 &nitems, &bytes_after, &prop) == Success) {

386 if (nitems > 0) {

387 *statp = ((unsigned long *)prop)[0];

388 rval = 0;

389 }

390 XFree(prop);

391 }

392

393 return rval;

394 }

395

396 static void client_to_window_geom(XWindowAttributes *attr, XSizeHints *sz,

397 int *x, int *y, int *width, int *height, int decoration)

398 {

399

400 int _border_width = border_width;

401 int _button_size = button_size;

402 if (!decoration) {

403 _border_width = 0;

404 _button_size = 0;

405 }

406

407 int north, south, east, west, stat, center;

408

409 north = south = east = west = stat = center = 0;

410

411 if (sz->flags & PWinGravity) {

412 switch (sz->win_gravity) {

413 case SouthGravity:

414 south = 1;

415 break;

416 case SouthWestGravity:

417 south = 1;

418 west = 1;

419 break;

420 case SouthEastGravity:

421 south = 1;

422 east = 1;

423 break;

424 break;

425 case NorthGravity:

426 north = 1;

427 break;

428 case NorthWestGravity:

429 north = 1;

430 west = 1;

431 break;

432 case NorthEastGravity:

433 north = 1;

434 east = 1;

435 break;

436 case CenterGravity:

437 center = 1;

438 break;

439 case StaticGravity:

440 stat = 1;

441 break;

442 default:

443 north = 1;

444 west = 1;

445 break;

446 }

447 } else {

448 north = 1;

449 west = 1;

450 }

451

452 if (north)

453 *y = attr->y;

454 else if (south)

455 *y = attr->y + 2 * attr->border_width

456 - 2 * _border_width - _button_size;

457 else if (center)

458 *y = attr->y + attr->border_width

459 + attr->height / 2

460 - (attr->height + 2 * _border_width + _button_size) / 2;

461 else if (stat)

462 *y = attr->y + attr->border_width - _border_width - _button_size;

463 else

464 *y = attr->y;

465

466 if (west)

467 *x = attr->x;

468 else if (east)

469 *x = attr->x + 2 * attr->border_width

470 - 2 * _border_width;

471 else if (center)

472 *x = attr->x + attr->border_width

473 + attr->width / 2

474 - (attr->width + 2 * _border_width) / 2;

475 else if (stat)

476 *x = attr->x + attr->border_width - _border_width;

477 else

478 *x = attr->x;

479

480 *width = attr->width + 2 * _border_width;

481 *height = attr->height + 2 * _border_width + _button_size;

482 }

483

484 static void window_to_client_geom(struct window *win,

485 int *x, int *y, int *width, int *height)

486 {

487

488 int _border_width = border_width;

489 int _button_size = button_size;

490 if (!win->decoration) {

491 _border_width = 0;

492 _button_size = 0;

493 }

494

495 int north, south, east, west, stat, center;

496

497 north = south = east = west = stat = center = 0;

498

499 if (win->wmnormalhints->flags & PWinGravity) {

500 switch (win->wmnormalhints->win_gravity) {

501 case SouthGravity:

502 south = 1;

503 break;

504 case SouthWestGravity:

505 south = 1;

506 west = 1;

507 break;

508 case SouthEastGravity:

509 south = 1;

510 east = 1;

511 break;

512 break;

513 case NorthGravity:

514 north = 1;

515 break;

516 case NorthWestGravity:

517 north = 1;

518 west = 1;

519 break;

520 case NorthEastGravity:

521 north = 1;

522 east = 1;

523 break;

524 case CenterGravity:

525 center = 1;

526 break;

527 case StaticGravity:

528 stat = 1;

529 break;

530 default:

531 north = 1;

532 west = 1;

533 break;

534 }

535 } else {

536 north = 1;

537 west = 1;

538 }

539

540 if (north)

541 *y = WIDGET_Y(win);

542 else if (south)

543 *y = WIDGET_Y(win) - 2*win->cborder

544 + 2*_border_width + _button_size;

545 else if (center)

546 *y = WIDGET_Y(win) + WIDGET_HEIGHT(win) / 2

547 - (WIDGET_HEIGHT(win) - 2*_border_width - _button_size) / 2

548 - win->cborder;

549 else if (stat)

550 *y = WIDGET_Y(win) - win->cborder + _border_width + _button_size;

551 else

552 *y = WIDGET_Y(win);

553

554 if (west)

555 *x = WIDGET_X(win);

556 else if (east)

557 *x = WIDGET_X(win) - 2*win->cborder + 2*_border_width;

558 else if (center)

559 *x = WIDGET_X(win) + WIDGET_WIDTH(win) / 2

560 - (WIDGET_WIDTH(win) - 2*_border_width) / 2 - win->cborder;

561 else if (stat)

562 *x = WIDGET_X(win) - win->cborder + _border_width;

563 else

564 *x = WIDGET_X(win);

565

566 *width = WIDGET_WIDTH(win) - 2*_border_width;

567 *height = WIDGET_HEIGHT(win) - 2*_border_width - _button_size;

568 }

569

570 void delete_window(struct window *win)

571 {

572 if (!hints_delete(win)) {

573 clerr();

574 XKillClient(display, win->client);

575 sterr();

576 }

577 }

578

579 /*

580 * See ICCCM 4.1.5 and EWMH "Implementation notes".

581 */

582 static void confevent(struct window *win, XConfigureRequestEvent *ep)

583 {

584 XWindowAttributes attr;

585 int x;

586 int y;

587 int width;

588 int height;

589

590 if (ep->value_mask & CWBorderWidth)

591 win->cborder = ep->border_width;

592

593 window_to_client_geom(win, &attr.x, &attr.y,

594 &attr.width, &attr.height);

595 attr.border_width = win->cborder;

596

597 if (ep->value_mask & CWX)

598 attr.x = ep->x;

599 if (ep->value_mask & CWY)

600 attr.y = ep->y;

601 if (ep->value_mask & CWWidth)

602 attr.width = ep->width;

603 if (ep->value_mask & CWHeight)

604 attr.height = ep->height;

605

606 /*

607 * FIXME: handle stacking order

608 */

609 // cause vbox resize bug

610 client_to_window_geom(&attr, win->wmnormalhints,

611 &x, &y, &width, &height, win->decoration);

612 moveresize_window(win, x, y, width, height); // resize to 0

613 }

614

615 static void prepare_repaint(struct widget *widget)

616 {

617 struct window *win = (struct window *)widget;

618

619 if (window_family_is_active(win))

620 XSetWindowBackground(display, WIDGET_XWINDOW(win),

621 color_title_active_bg.normal);

622 else

623 XSetWindowBackground(display, WIDGET_XWINDOW(win),

624 color_title_inactive_bg.normal);

625 }

626

627 static void repaint(struct widget *widget)

628 {

629 struct window *win = (struct window *)widget;

630 if(!win->decoration) {

631 return;

632 }

633 GC gc = win->title->gc;

634 struct color *color =

635 window_family_is_active(win) ?

636 &color_title_active_bg : &color_title_inactive_bg;

637 int w = WIDGET_WIDTH(win);

638 int h = WIDGET_HEIGHT(win);

639 int bw = border_width;

640

641 drawraised(WIDGET_XWINDOW(win), gc, color,

642 0, 0, WIDGET_WIDTH(win), WIDGET_HEIGHT(win));

643 drawlowered(WIDGET_XWINDOW(win), gc, color,

644 border_width - 2, border_width - 2,

645 WIDGET_WIDTH(win) - 2 * border_width + 3,

646 WIDGET_HEIGHT(win) - 2 * border_width + 3);

647

648 XSetForeground(display, gc, color->normal);

649

650 XFillRectangle(display, WIDGET_XWINDOW(win), gc,

651 1, 1, w - 3, bw - 3);

652 XFillRectangle(display, WIDGET_XWINDOW(win), gc,

653 1, h - bw + 1, w - 3, bw - 3);

654 XFillRectangle(display, WIDGET_XWINDOW(win), gc,

655 1, bw - 2, bw - 3, h - 2 * bw + 3);

656 XFillRectangle(display, WIDGET_XWINDOW(win), gc,

657 w - bw + 1, bw - 2, bw - 3, h - 2 * bw + 3);

658

659 /* Also paint behind client window in case it is shaped. */

660 XFillRectangle(display, WIDGET_XWINDOW(win), gc,

661 bw, bw + button_size, w - 2 * bw, h - 2 * bw - button_size);

662 }

663

664 static void windowevent(struct widget *widget, XEvent *ep)

665 {

666 struct window *win = (struct window *)widget;

667 long stap;

668 //printf("event %!d(MISSING)\n", ep->type);

669 switch (ep->type) {

670 case ButtonPress:

671 //printf("!step 1\n");

672 if (ep->xbutton.button < 4) {

673 //printf("!step 1.5\n");

674 set_active_window_(win, ep->xbutton.button);

675 } else {

676 //printf("!step 2\n");

677 //struct window *ptr = active;

678 //set_active_window(win);

679 //beginfastmove(WIDGET_XWINDOW(win));

680 set_active_window_(win, ep->xbutton.button);

681 break;

682 }

683 //printf("!step 3\n");

684 if (ep->xbutton.state & Mod1Mask) {

685 win->altmove.xoff = ep->xbutton.x;

686 win->altmove.yoff = ep->xbutton.y;

687 win->altmove.moving = 1;

688 beginfastmove(WIDGET_XWINDOW(win));

689 }

690 //printf("!step 4\n");

691 break;

692 case MotionNotify:

693 if (win->altmove.moving) {

694 if (ep->xmotion.state & ControlMask)

695 move_window_family(win,

696 ep->xmotion.x_root - win->altmove.xoff,

697 ep->xmotion.y_root - win->altmove.yoff);

698 else

699 move_window(win,

700 ep->xmotion.x_root - win->altmove.xoff,

701 ep->xmotion.y_root - win->altmove.yoff);

702 }

703 break;

704 case ButtonRelease:

705 //if (ep->xbutton.button < 4) {

706 win->altmove.moving = 0;

707 endfastmove();

708 //}

709 break;

710 case MapRequest:

711 set_active_window(win);

712 break;

713 case UnmapNotify:

714 /* This can be a real or synthetic unmap event. */

715 if (ep->xunmap.window != win->client)

716 break;

717 if (win->ignoreunmap > 0)

718 win->ignoreunmap--;

719 else if (win->ignoreunmap == 0) {

720 if ((win->title&&fastmovewin_current==WIDGET_XWINDOW(win->title)) || fastmovewin_current==WIDGET_XWINDOW(win))

721 endfastmove();

722 hints_withdraw(win);

723 unmanage_window(win, 1);

724 } else

725 abort();

726 break;

727 case ConfigureRequest:

728 confevent(win, &ep->xconfigurerequest);

729 break;

730 case ClientMessage:

731 hints_clientmessage(win, &ep->xclient);

732 break;

733 case PropertyNotify:

734 hints_propertynotify(win, &ep->xproperty);

735 break;

736 case DestroyNotify:

737 if (ep->xdestroywindow.window == win->client)

738 unmanage_window(win, 1);

739 break;

740 case Expose:

741 if (ep->xexpose.count == 0)

742 repaint(widget);

743 break;

744 case GravityNotify:

745 case CreateNotify:

746 if (ep->xcreatewindow.x == monitors[0].x && ep->xcreatewindow.y == monitors[0].y

747 && ep->xcreatewindow.width == monitors[0].w && ep->xcreatewindow.height == monitors[0].h )//&&

748 // ep->xcreatewindow.override_redirect)

749 printf("createnotify\n");

750 case MapNotify:

751 case ReparentNotify:

752 case ConfigureNotify:

753 /* ignore */

754 break;

755 default:

756 debug("windowevent(): unhandled event -- %!s(MISSING) (%!d(MISSING))",

757 eventname(ep->type), ep->type);

758 break;

759 }

760 }

761

762 void low_limit_size(int *width, int *height, int decoration)

763 {

764 *width = MAX(*width, decoration*(2 * border_width) + 1);

765 *height = MAX(*height, decoration*(2 * border_width + button_size) + 1);

766 }

767

768 void window_calcsize(struct window *win, int width, int height,

769 int *rwidth, int *rheight, int *rxdim, int *rydim)

770 {

771 int decwidth = 2 * border_width;

772 int decheight = 2 * border_width + button_size;

773 if(!win->decoration) {

774 decwidth = decheight = 0;

775 }

776 int havemin = 0;

777 int minwidth = 0;

778 int minheight = 0;

779 int wmminwidth = 0;

780 int wmminheight = 0;

781

782 low_limit_size(&width, &height, win->decoration);

783 low_limit_size(&wmminwidth, &wmminheight, win->decoration);

784

785 width -= decwidth;

786 height -= decheight;

787

788 if (win->wmnormalhints->flags & PMaxSize) {

789 width = MIN(width, win->wmnormalhints->max_width);

790 height = MIN(height, win->wmnormalhints->max_height);

791 }

792

793 havemin = 0;

794 if (win->wmnormalhints->flags & PMinSize) {

795 minwidth = win->wmnormalhints->min_width;

796 minheight = win->wmnormalhints->min_height;

797 havemin = 1;

798 } else if (win->wmnormalhints->flags & PBaseSize) {

799 minwidth = win->wmnormalhints->base_width;

800 minheight = win->wmnormalhints->base_height;

801 havemin = 1;

802 }

803 if (havemin) {

804 width = MAX(width, minwidth);

805 height = MAX(height, minheight);

806 }

807

808 if (win->wmnormalhints->flags & PResizeInc) {

809 if (win->wmnormalhints->width_inc != 0) {

810 int wb;

811 if (win->wmnormalhints->flags & PBaseSize)

812 wb = win->wmnormalhints->base_width;

813 else if (win->wmnormalhints->flags & PMinSize)

814 wb = win->wmnormalhints->min_width;

815 else

816 wb = 0;

817 width -= wb;

818 width -= width %!w(MISSING)in->wmnormalhints->width_inc;

819 if (havemin)

820 width = MAX(width, minwidth - wb);

821 while (wb + width + decwidth < wmminwidth)

822 width += win->wmnormalhints->width_inc;

823 if (rxdim != NULL)

824 *rxdim = width / win->wmnormalhints->width_inc;

825 width += wb;

826 } else if (rxdim != NULL)

827 *rxdim = width;

828 if (win->wmnormalhints->height_inc != 0) {

829 int hb;

830 if (win->wmnormalhints->flags & PBaseSize)

831 hb = win->wmnormalhints->base_height;

832 else if (win->wmnormalhints->flags & PMinSize)

833 hb = win->wmnormalhints->min_height;

834 else

835 hb = 0;

836 height -= hb;

837 height -= height %!w(MISSING)in->wmnormalhints->height_inc;

838 if (havemin)

839 height = MAX(height, minheight - hb);

840 while (hb + height + decheight < wmminheight)

841 height += win->wmnormalhints->height_inc;

842 if (rydim != NULL)

843 *rydim =

844 height / win->wmnormalhints->height_inc;

845 height += hb;

846 } else if (rydim != NULL)

847 *rydim = height;

848 } else {

849 if (rxdim != NULL)

850 *rxdim = width;

851 if (rydim != NULL)

852 *rydim = height;

853 }

854

855 width += 2 * border_width;

856 height += 2 * border_width + button_size;

857

858 if (rwidth != NULL)

859 *rwidth = width;

860 if (rheight != NULL)

861 *rheight = height;

862 }

863

864 static void setgrav(Window xwin, int grav)

865 {

866 XSetWindowAttributes attr;

867

868 attr.win_gravity = grav;

869 XChangeWindowAttributes(display, xwin, CWWinGravity, &attr);

870 }

871

872 void expand_window(struct window* win) {

873 win->odim = win->widget.dim;

874 maximize_window(win, -1, -1);

875 }

876

877 int maximize_window(struct window *win, int posx, int posy)

878 {

879 if(!win->resizable) {

880 return -1;

881 }

882 if(posx == -1) {

883 posx = win->widget.dim.x;

884 }

885 if(posy == -1) {

886 posy = win->widget.dim.y;

887 }

888 int x, y, rwidth, rheight;

889 int id = 0;

890 if (!win->fullscreen&&win->maximized) {

891 set_button_image(win->expandbtn, &expand_image);

892 moveresize_window(win, win->odim.x, win->odim.y, win->odim.width, win->odim.height);

893 win->maximized = 0;

894 for(; id<monitors_len-1; id++) {

895 if(monitors[id].x<=posx&&

896 monitors[id].y<=posy&&

897 monitors[id].x+monitors[id].w>=posx&&

898 monitors[id].y+monitors[id].h>=posy) break;

899 }

900 } else {

901 set_button_image(win->expandbtn, &expanded_image);

902 win->odim = win->widget.dim;

903 for(; id<monitors_len-1; id++) {

904 if(monitors[id].x<=posx&&

905 monitors[id].y<=posy&&

906 monitors[id].x+monitors[id].w>posx&&

907 monitors[id].y+monitors[id].h>posy) break;

908 }

909 //moveresize_window(win, monitors[id].x-(win->fullscreen?border_width:0), monitors[id].y-(win->fullscreen?button_size+border_width:0), monitors[id].w+(win->fullscreen?border_width*2:0), monitors[id].h+(win->fullscreen?button_size/2+border_width*2:0)-(id==0&&!win->fullscreen?panel_height:0));

910 //printf("%!d(MISSING)\n", monitors[id].h-((id==0&&!win->fullscreen)?panel_height:0));

911 XResizeWindow(display, win->client, monitors[id].w, monitors[id].h);

912 //XResizeWindow(display, WIDGET_XWINDOW(win), monitors[id].w, monitors[id].h);

913 moveresize_window(win, monitors[id].x, monitors[id].y, monitors[id].w, monitors[id].h-((id==0&&!win->fullscreen)?panel_height:0));

914 win->maximized = 1;

915 }

916 return id;

917 }

918

919 int window_is_resizable(struct window* win) {

920 if(win&&win->wmnormalhints&&win->wmnormalhints->flags & PMinSize && win->wmnormalhints->flags & PMaxSize && win->wmnormalhints->min_width==win->wmnormalhints->max_width) return 0;

921 return 1;

922 }

923

924 struct window *manage_window(Window client, int wmstart)

925 {

926 struct window *win;

927 XWindowAttributes attr;

928 XSizeHints *sz;

929 XWMHints *wmhints;

930 long state;

931 long dummy;

932 int x, y, width, height;

933

934 clerr();

935 if (!XGetWindowAttributes(display, client, &attr)) {

936 sterr();

937 return NULL;

938 }

939 sterr();

940

941 if (attr.override_redirect)

942 return NULL;

943

944 if (find_widget(client, WIDGET_ANY) != NULL) {

945 debug("XXX: Trying to remanage a window!");

946 return NULL;

947 }

948

949 clerr();

950 if (getwmstate(client, &state) == -1 || state == WithdrawnState) {

951 wmhints = XGetWMHints(display, client);

952 if (wmhints == NULL)

953 state = NormalState;

954 else {

955 if (wmhints->flags & StateHint)

956 state = wmhints->initial_state;

957 else

958 state = NormalState;

959 XFree(wmhints);

960 }

961 }

962 sterr();

963

964 if (state == WithdrawnState) {

965 debug("skipping withdrawn window");

966 return NULL;

967 }

968

969 while ((sz = XAllocSizeHints()) == NULL)

970 sleep(1);

971 clerr();

972 XGetWMNormalHints(display, client, sz, &dummy);

973 sterr();

974 client_to_window_geom(&attr, sz, &x, &y, &width, &height, 1);

975 low_limit_size(&width, &height, 1);

976 if (!wmstart && ~sz->flags & USPosition && ~sz->flags & PPosition)

977 smartpos(width, height, &x, &y, get_monitor_cursor());

978 XFree(sz);

979

980 win = MALLOC(sizeof (struct window));

981

982 create_widget(&win->widget, WIDGET_WINDOW,

983 root, InputOutput, x, y, width, height);

984

985

986 /*

987 * Initialize struct members

988 */

989

990 win->name[0] = '\0';

991 win->decoration = 1;

992 win->fullscreen = 0;

993 win->iconname = NULL;

994 win->title = NULL;

995 win->deletebtn = NULL;

996 win->unmapbtn = NULL;

997 win->expandbtn = NULL;

998 win->rsz_northwest = NULL;

999 win->rsz_north = NULL;

1000 win->rsz_northeast = NULL;

1001 win->rsz_west = NULL;

1002 win->rsz_east = NULL;

1003 win->rsz_southwest = NULL;

1004 win->rsz_south = NULL;

1005 win->rsz_southeast = NULL;

1006 win->menuitem = NULL;

1007 win->color = &color_title_active_bg;

1008 win->client = client;

1009 win->colormap = attr.colormap;

1010 win->wmnormalhints = NULL;

1011 win->wmhints = NULL;

1012 win->wmtransientfor = None;

1013 win->cborder = attr.border_width;

1014 win->altmove.moving = 0;

1015 win->altmove.xoff = 0;

1016 win->altmove.yoff = 0;

1017 win->ignoreunmap = 0;

1018 win->maximized = 0;

1019 win->odim.x = attr.x;

1020 win->odim.y = attr.y;

1021 win->odim.width = attr.width;

1022 win->odim.height = attr.height;

1023 win->layer = &normallayer;

1024 LIST_INIT(&win->layerlink);

1025

1026 /*

1027 * Everything initialized. Time to get some work done.

1028 */

1029

1030 LIST_INSERT_HEAD(win->layer, &win->layerlink);

1031 nwindows++;

1032 needrestack = 1;

1033 save_widget_context(&win->widget, client);

1034

1035 grabbutton(display, Button1, Mod1Mask,

1036 WIDGET_XWINDOW(win), False,

1037 ButtonPressMask | ButtonReleaseMask | ButtonMotionMask,

1038 GrabModeAsync, GrabModeAsync, None, movecurs);

1039 grabbutton(display, Button1, Mod1Mask | ControlMask,

1040 WIDGET_XWINDOW(win), False,

1041 ButtonPressMask | ButtonReleaseMask | ButtonMotionMask,

1042 GrabModeAsync, GrabModeAsync, None, movecurs);

1043

1044 /*XSelectInput(display, WIDGET_XWINDOW(win),

1045 //EnterWindowMask|FocusChangeMask|PropertyChangeMask|StructureNotifyMask);

1046 SubstructureRedirectMask|SubstructureNotifyMask

1047 |ButtonPressMask|PointerMotionMask|EnterWindowMask

1048 |LeaveWindowMask|StructureNotifyMask|PropertyChangeMask);

1049 //ExposureMask | SubstructureRedirectMask | SubstructureNotifyMask);*/

1050 XSelectInput(display, WIDGET_XWINDOW(win),

1051 ExposureMask | SubstructureRedirectMask | SubstructureNotifyMask);

1052

1053 win->widget.event = windowevent;

1054 win->widget.prepare_repaint = prepare_repaint;

1055 win->widget.repaint = repaint;

1056

1057 win->deletebtn = create_button(win,

1058 width - border_width - button_size,

1059 border_width, button_size, button_size);

1060 setgrav(WIDGET_XWINDOW(win->deletebtn), NorthEastGravity);

1061 set_button_image(win->deletebtn, &delete_image);

1062 set_button_handler(win->deletebtn, delete_window);

1063

1064 win->expandbtn = create_button(win,

1065 width - border_width - 2 * button_size,

1066 border_width, button_size, button_size);

1067 setgrav(WIDGET_XWINDOW(win->expandbtn), NorthEastGravity);

1068 set_button_image(win->expandbtn, &expand_image);

1069 set_button_handler(win->expandbtn, expand_window);

1070

1071 win->unmapbtn = create_button(win,

1072 width - border_width - 3 * button_size,

1073 border_width, button_size, button_size);

1074 setgrav(WIDGET_XWINDOW(win->unmapbtn), NorthEastGravity);

1075 set_button_image(win->unmapbtn, &unmap_image);

1076 set_button_handler(win->unmapbtn, user_unmap_window);

1077

1078 win->title = create_title(win,

1079 border_width, border_width,

1080 width - 2 * border_width - NBTN * button_size, button_size);

1081

1082 update_window_type(win);

1083 fetch_wm_hints(win);

1084 fetch_wm_normal_hints(win);

1085 clerr();

1086 XAddToSaveSet(display, client);

1087

1088 XSetWindowBorderWidth(display, client, 0);

1089 XReparentWindow(display, client, WIDGET_XWINDOW(win),

1090 win->decoration?border_width:0, win->decoration?(border_width + button_size):0);

1091 if (win->decoration==0)

1092 XResizeWindow(display, win->client, win->widget.dim.width+border_width*2, win->widget.dim.height+button_size+border_width*2);

1093 XLowerWindow(display, client);

1094 XSelectInput(display, client, PropertyChangeMask);

1095 setgrav(client, NorthWestGravity);

1096 grabbutton(display, AnyButton, 0, client, True,

1097 ButtonPressMask, GrabModeSync, GrabModeSync, None, None);

1098 sterr();

1099

1100 win->resizable = window_is_resizable(win);

1101 if(win->decoration&&win->resizable) {

1102 win->rsz_northwest = create_resizer(win, NORTHWEST);

1103 win->rsz_north = create_resizer(win, NORTH);

1104 win->rsz_northeast = create_resizer(win, NORTHEAST);

1105 win->rsz_west = create_resizer(win, WEST);

1106 win->rsz_east = create_resizer(win, EAST);

1107 win->rsz_southwest = create_resizer(win, SOUTHWEST);

1108 win->rsz_south = create_resizer(win, SOUTH);

1109 win->rsz_southeast = create_resizer(win, SOUTHEAST);

1110 }

1111

1112 fetch_window_name(win);

1113 //printf("window name : %!s(MISSING) %!d(MISSING) %!d(MISSING)\n", win->name, win->widget.dim.x, win->widget.dim.y);

1114 if (win->widget.dim.x==0 && win->widget.dim.y==0) {

1115 smartpos(width, height, &x, &y, get_monitor_cursor());

1116 move_window(win, x, y);

1117 }

1118 fetch_icon_name(win);

1119

1120 fetch_wm_transient_for_hint(win);

1121

1122 repaint_window(win);

1123

1124 #if 1

1125 if (win->wmtransientfor != None) {

1126 struct window *w;

1127 w = (struct window *)find_widget(win->wmtransientfor,

1128 WIDGET_WINDOW);

1129 if (w != NULL) {

1130 raise_window(w);

1131 restack_transient_windows(w);

1132 }

1133 }

1134 #endif

1135

1136 hints_manage(win);

1137

1138 map_window(win);

1139

1140 if (state == IconicState)

1141 unmap_window(win);

1142 else

1143 set_active_window(win);

1144

1145 XSync(display, False);

1146

1147 debug("manage \"%!s(MISSING)\" (Window=0x%!x(MISSING))", win->name, (int)win->client);

1148

1149 clerr();

1150 if (!XGetWindowAttributes(display, client, &attr)) {

1151 sterr();

1152 debug("Oops, client window disappeared in manage_window()");

1153 unmanage_window(win, 1);

1154 return NULL;

1155 }

1156 sterr();

1157

1158 //if (!win->decoration)

1159 // resize_window(win, width, height);

1160

1161 return win;

1162 }

1163

1164 static void ranpos(int width, int height, int *rx, int *ry, int monitor)

1165 {

1166 int dx, dy;

1167

1168 dx = monitors[monitor].w - width;

1169 dy = monitors[monitor].h - height;

1170 *rx = dx > 0 ? rand() %!d(MISSING)x + monitors[monitor].x : 0;

1171 *ry = dy > 0 ? rand() %!d(MISSING)y + monitors[monitor].y : 0;

1172 }

1173

1174 static long badness(int x, int y, int width, int height,

1175 struct window **wins, int n)

1176 {

1177 long x1, x2, y1, y2;

1178 long w, h;

1179 long area;

1180 int nwin;

1181 int i;

1182

1183 nwin = 0;

1184 area = 0;

1185 for (i = 0; i < n; i++)

1186 if (WIDGET_MAPPED(wins[i])) {

1187 x1 = WIDGET_X(wins[i]);

1188 x2 = x1 + WIDGET_WIDTH(wins[i]);

1189 y1 = WIDGET_Y(wins[i]);

1190 y2 = y1 + WIDGET_HEIGHT(wins[i]);

1191 if (x + width > x1 && x < x2 &&

1192 y + height > y1 && y < y2) {

1193 w = MIN(x + width, x2) - MAX(x, x1);

1194 h = MIN(y + height, y2) - MAX(y, y1);

1195 if (LONG_MAX - area < w * h)

1196 area = LONG_MAX;

1197 else

1198 area += w * h;

1199 nwin++;

1200 }

1201 }

1202 if (nwin != 0 && LONG_MAX / nwin < area) {

1203 nwin = 1;

1204 area = LONG_MAX;

1205 }

1206 return area * nwin;

1207 }

1208

1209 // add multi monitors support

1210 static void smartpos(int width, int height, int *rx, int *ry, int monitor)

1211 {

1212 struct window **wins;

1213 int n;

1214 int x, y;

1215 long best = -1;

1216 long score;

1217 int i;

1218

1219 get_window_stack(&wins, &n);

1220 for (i = 0; best != 0 && i < 100; i++) {

1221 ranpos(width, height, &x, &y, monitor);

1222 score = badness(x, y, width, height, wins, n);

1223 if (best == -1 || score < best) {

1224 best = score;

1225 *rx = x;

1226 *ry = y;

1227 }

1228 }

1229 FREE(wins);

1230 }

1231

1232 void fetch_wm_normal_hints(struct window *win)

1233 {

1234 long dummy;

1235

1236 if (win->wmnormalhints != NULL)

1237 XFree(win->wmnormalhints);

1238 while ((win->wmnormalhints = XAllocSizeHints()) == NULL)

1239 sleep(1);

1240 clerr();

1241 XGetWMNormalHints(display, win->client, win->wmnormalhints, &dummy);

1242 if(win->wmnormalhints->min_height>2000) {

1243 win->wmnormalhints->min_height = win->wmnormalhints->min_width/3*4;

1244 }

1245 sterr();

1246 }

1247

1248 void fetch_wm_hints(struct window *win)

1249 {

1250 if (win->wmhints != NULL)

1251 XFree(win->wmhints);

1252 clerr();

1253 win->wmhints = XGetWMHints(display, win->client);

1254 sterr();

1255 }

1256

1257 char* window_getname(Window win) {

1258 Atom prop = XInternAtom(display,"_NET_WM_NAME",False), type;

1259 int form;

1260 unsigned long remain, len;

1261 unsigned char *list;

1262

1263 if (XGetWindowProperty(display,win,prop,0,1024,False,XA_STRING,

1264 &type,&form,&len,&remain,&list) != Success) {

1265 return NULL;

1266 }

1267

1268 return (char*)list;

1269 }

1270

1271 int

1272 gettextprop(Window w, Atom atom, char *text, unsigned int size)

1273 {

1274 char **list = NULL;

1275 int n;

1276 XTextProperty name;

1277

1278 if (!text || size == 0)

1279 return 0;

1280 text[0] = '\0';

1281 if (!XGetTextProperty(display, w, &name, atom) || !name.nitems)

1282 return 0;

1283 if (name.encoding == XA_STRING)

1284 strncpy(text, (char *)name.value, size - 1);

1285 else {

1286 if (XmbTextPropertyToTextList(display, &name, &list, &n) >= Success && n > 0 && *list) {

1287 strncpy(text, *list, size - 1);

1288 XFreeStringList(list);

1289 }

1290 }

1291 text[size - 1] = '\0';

1292 XFree(name.value);

1293 return 1;

1294 }

1295

1296 void updatetitle(struct window *win)

1297 {

1298 if (!gettextprop(win->client, XInternAtom(display, "_NET_WM_NAME", False), win->name, 1024))

1299 gettextprop(win->client, XA_WM_NAME, win->name, sizeof win->name);

1300 if (win->name[0] == '\0')

1301 strcpy(win->name, "broken name");

1302 }

1303

1304 void fetch_window_name(struct window *win)

1305 {

1306 //XGetWindowProperty(Display *, Window, Atom, long, long, int, Atom, Atom *, int *, unsigned long *, unsigned long *, unsigned char **)

1307 updatetitle(win);

1308 char *name;

1309 if (strlen(win->name) == 0)

1310 name = "<< Anonymous >>";

1311 else

1312 name = win->name;

1313

1314 if (win->menuitem == NULL)

1315 win->menuitem = create_menuitem(winmenu, name,

1316 selectfrommenu, win);

1317 else

1318 rename_menuitem(win->menuitem, name);

1319

1320 REPAINT(win->title);

1321 }

1322

1323 void fetch_icon_name(struct window *win)

1324 {

1325 if (win->iconname != NULL) {

1326 XFree(win->iconname);

1327 win->iconname = NULL;

1328 }

1329

1330 clerr();

1331 XGetIconName(display, win->client, &win->iconname);

1332 if (win->iconname == NULL || strlen(win->iconname) == 0) {

1333 if (win->iconname != NULL) {

1334 XFree(win->iconname);

1335 win->iconname = NULL;

1336 }

1337 XFetchName(display, win->client, &win->iconname);

1338 }

1339 sterr();

1340 }

1341

1342 static void selectfrommenu(void *ptr)

1343 {

1344 set_active_window(ptr);

1345 }

1346

1347 void fetch_wm_transient_for_hint(struct window *win)

1348 {

1349 win->wmtransientfor = None;

1350 clerr();

1351 XGetTransientForHint(display, win->client, &win->wmtransientfor);

1352 sterr();

1353

1354 fitwin(win);

1355 }

1356

1357 static void fitwin(struct window *win)

1358 {

1359 int nbtn = 0;

1360

1361 int resizable = 0;

1362 if (win->resizable &&

1363 WIDGET_WIDTH(win) >= 2 * border_width + 2 * button_size + 1) {

1364 map_widget((struct widget *)win->expandbtn);

1365 resizable = 1;

1366 } else {

1367 unmap_widget((struct widget *)win->expandbtn);

1368 move_widget(&win->unmapbtn->widget, win->odim.width - border_width - 2 * button_size + button_size/2, border_width);

1369 }

1370

1371 if (

1372 WIDGET_WIDTH(win) >= 2 * border_width + (2+resizable) * button_size + 1) {

1373 map_widget((struct widget *)win->unmapbtn);

1374 } else

1375 unmap_widget((struct widget *)win->unmapbtn);

1376

1377 if (WIDGET_WIDTH(win) >= 2 * border_width + button_size + 1)

1378 map_widget((struct widget *)win->deletebtn);

1379 else

1380 unmap_widget((struct widget *)win->deletebtn);

1381

1382 if (!win->decoration) return;

1383

1384 if (win->deletebtn && WIDGET_MAPPED(win->deletebtn))

1385 nbtn++;

1386 if (win->expandbtn && WIDGET_MAPPED(win->expandbtn))

1387 nbtn++;

1388 if (win->unmapbtn && WIDGET_MAPPED(win->unmapbtn))

1389 nbtn++;

1390

1391 resize_title(win->title, MAX(1, WIDGET_WIDTH(win) - 2 * border_width - nbtn * button_size), button_size);

1392 }

1393

1394 void moveresize_window(struct window *win, int x, int y, int width, int height)

1395 {

1396 int move;

1397 int resize;

1398

1399 low_limit_size(&width, &height, win->decoration);

1400

1401 move = x != WIDGET_X(win) || y != WIDGET_Y(win);

1402 if(win->resizable)

1403 resize = width != WIDGET_WIDTH(win) || height != WIDGET_HEIGHT(win);

1404 else

1405 resize = 0;

1406

1407 if (resize) {

1408 clerr();

1409 XResizeWindow(display, win->client,

1410 width - 2 * border_width * win->decoration,

1411 height - (2 * border_width + button_size) * win->decoration);

1412 sterr();

1413 if (win->maximized) {

1414 set_button_image(win->expandbtn, &expand_image);

1415 }

1416 }

1417

1418 moveresize_widget((struct widget *)win, x, y, width, height);

1419 win->maximized = 0;

1420

1421 if (resize && win->decoration) {

1422 fitwin(win);

1423 fit_resizer(win->rsz_northwest);

1424 fit_resizer(win->rsz_north);

1425 fit_resizer(win->rsz_northeast);

1426 fit_resizer(win->rsz_west);

1427 fit_resizer(win->rsz_east);

1428 fit_resizer(win->rsz_southwest);

1429 fit_resizer(win->rsz_south);

1430 fit_resizer(win->rsz_southeast);

1431 }

1432

1433 if (move && !resize)

1434 hints_move(win);

1435 else if (!move && resize)

1436 hints_resize(win);

1437 else if (move && resize)

1438 hints_moveresize(win);

1439 }

1440

1441 void move_window(struct window *win, int x, int y)

1442 {

1443 if(win->maximized&&win->title->moving) {

1444 int m = maximize_window(win, x+1, y+1);

1445 //moveresize_window(win, win->title->xoff+((float)win->title->xoff)/monitors[m].w*WIDGET_WIDTH(win), win->title->yoff, WIDGET_WIDTH(win), WIDGET_HEIGHT(win));

1446 win->title->xoff = ((float)win->title->xoff)/monitors[m].w*(0.9f*WIDGET_WIDTH(win));

1447 } else

1448 moveresize_window(win, x, y, WIDGET_WIDTH(win), WIDGET_HEIGHT(win));

1449 }

1450

1451 void move_window_family(struct window *win, int x, int y)

1452 {

1453 struct window *wp;

1454 LIST *lp;

1455 int dx, dy;

1456

1457 dx = x - WIDGET_X(win);

1458 dy = y - WIDGET_Y(win);

1459

1460 LIST_FOREACH(lp, &toplayer) {

1461 wp = LIST_ITEM(lp, struct window, layerlink);

1462 if (WIDGET_MAPPED(wp) && windows_are_related(wp, win))

1463 move_window(wp, WIDGET_X(wp) + dx, WIDGET_Y(wp) + dy);

1464 }

1465 LIST_FOREACH(lp, &normallayer) {

1466 wp = LIST_ITEM(lp, struct window, layerlink);

1467 if (WIDGET_MAPPED(wp) && windows_are_related(wp, win))

1468 move_window(wp, WIDGET_X(wp) + dx, WIDGET_Y(wp) + dy);

1469 }

1470 }

1471

1472 void resize_window(struct window *win, int width, int height)

1473 {

1474 moveresize_window(win, WIDGET_X(win), WIDGET_Y(win), width, height);

1475 }

1476

1477 void unmanage_window(struct window *win, int clientquit)

1478 {

1479 int x, y, width, height;

1480 int wasactive;

1481

1482 debug("unmanage \"%!s(MISSING)\" (Window=0x%!x(MISSING))",win->name, (int)win->client);

1483

1484 wasactive = win == active;

1485

1486 if (wasactive)

1487 set_active_window(NULL);

1488

1489 if (WIDGET_MAPPED(win))

1490 unmap_widget(&win->widget);

1491

1492 hints_unmanage(win);

1493

1494 /*

1495 * Begin teardown.

1496 * Not safe to call WM related functions from now on.

1497 */

1498

1499 if (win->menuitem != NULL)

1500 destroy_menuitem(win->menuitem);

1501 LIST_REMOVE(&win->layerlink);

1502 nwindows--;

1503

1504 window_to_client_geom(win, &x, &y, &width, &height);

1505 delete_widget_context(win->client);

1506

1507 clerr();

1508 XReparentWindow(display, win->client, root, x, y);

1509 if (!clientquit)

1510 XMapWindow(display, win->client);

1511 ungrabbutton(display, AnyButton, AnyModifier, win->client);

1512 XSelectInput(display, win->client, 0);

1513 XSetWindowBorderWidth(display, win->client, win->cborder);

1514 if (win->wmnormalhints->flags & PWinGravity)

1515 setgrav(win->client, win->wmnormalhints->win_gravity);

1516 XRemoveFromSaveSet(display, win->client);

1517 sterr();

1518

1519 if(win->decoration) {

1520 if(win->title)

1521 destroy_title(win->title);

1522 if(win->deletebtn)

1523 destroy_button(win->deletebtn);

1524 if(win->unmapbtn)

1525 destroy_button(win->unmapbtn);

1526 if(win->expandbtn)

1527 destroy_button(win->expandbtn);

1528

1529 if(win->resizable) {

1530 destroy_resizer(win->rsz_northwest);

1531 destroy_resizer(win->rsz_north);

1532 destroy_resizer(win->rsz_northeast);

1533 destroy_resizer(win->rsz_west);

1534 destroy_resizer(win->rsz_east);

1535 destroy_resizer(win->rsz_southwest);

1536 destroy_resizer(win->rsz_south);

1537 destroy_resizer(win->rsz_southeast);

1538 }

1539 }

1540

1541 if (win->wmhints != NULL)

1542 XFree(win->wmhints);

1543 assert(win->wmnormalhints != NULL);

1544 XFree(win->wmnormalhints);

1545

1546 destroy_widget(&win->widget);

1547 //if (win->name != NULL)

1548 // XFree(win->name);

1549 if (win->iconname != NULL)

1550 XFree(win->iconname);

1551 FREE(win);

1552

1553 XSync(display, False);

1554

1555 /*

1556 * Teardown finished

1557 */

1558

1559 if (wasactive)

1560 set_active_window(topmost_window());

1561

1562 }

1563

1564 void remove_decoration(struct window *win) {

1565 win->decoration = 0;

1566 XMoveWindow(display, win->client, 0, 0);

1567 }

1568

1569 void create_decoration(struct window *win) {

1570

1571 win->decoration = 1;

1572

1573 XMoveWindow(display, win->client, border_width, border_width+button_size);

1574 XResizeWindow(display, win->client, win->widget.dim.width-border_width*2, win->widget.dim.height-button_size-border_width*2);

1575

1576 if (!win->deletebtn) {

1577 win->deletebtn = create_button(win,

1578 win->widget.dim.width - border_width - button_size,

1579 border_width, button_size, button_size);

1580 setgrav(WIDGET_XWINDOW(win->deletebtn), NorthEastGravity);

1581 set_button_image(win->deletebtn, &delete_image);

1582 set_button_handler(win->deletebtn, delete_window);

1583 }

1584

1585 if (!win->expandbtn) {

1586 win->expandbtn = create_button(win,

1587 win->widget.dim.width - border_width - 2 * button_size,

1588 border_width, button_size, button_size);

1589 setgrav(WIDGET_XWINDOW(win->expandbtn), NorthEastGravity);

1590 set_button_image(win->expandbtn, &expand_image);

1591 set_button_handler(win->expandbtn, expand_window);

1592 }

1593

1594 if (!win->unmapbtn) {

1595 win->unmapbtn = create_button(win,

1596 win->widget.dim.width - border_width - 3 * button_size,

1597 border_width, button_size, button_size);

1598 setgrav(WIDGET_XWINDOW(win->unmapbtn), NorthEastGravity);

1599 set_button_image(win->unmapbtn, &unmap_image);

1600 set_button_handler(win->unmapbtn, user_unmap_window);

1601 }

1602

1603 if (!win->title) {

1604 win->title = create_title(win,

1605 border_width, border_width,

1606 win->widget.dim.width - 2 * border_width - NBTN * button_size, button_size);

1607 }

1608

1609 }

1610

1611 void repaint_window(struct window *win)

1612 {

1613 if(!win->decoration) {

1614 if(win->title)

1615 destroy_title(win->title);

1616 if(win->deletebtn)

1617 destroy_button(win->deletebtn);

1618 if(win->unmapbtn)

1619 destroy_button(win->unmapbtn);

1620 if(win->expandbtn)

1621 destroy_button(win->expandbtn);

1622 win->deletebtn = win->unmapbtn = win->expandbtn = NULL;

1623 win->title = NULL;

1624 return;

1625 }

1626 REPAINT(win->title);

1627 REPAINT(win->deletebtn);

1628 REPAINT(win->unmapbtn);

1629 REPAINT(win->expandbtn);

1630 REPAINT(win);

1631 }

1632

1633 void repaint_window_family(struct window *win)

1634 {

1635 struct window *wp;

1636 LIST *lp;

1637

1638 LIST_FOREACH(lp, &toplayer) {

1639 wp = LIST_ITEM(lp, struct window, layerlink);

1640 if (windows_are_related(wp, win))

1641 repaint_window(wp);

1642 }

1643 LIST_FOREACH(lp, &normallayer) {

1644 wp = LIST_ITEM(lp, struct window, layerlink);

1645 if (windows_are_related(wp, win))

1646 repaint_window(wp);

1647 }

1648 }

1649

1650 /*

1651 * This function assumes that 'win' already has the desired stacking.

1652 */

1653 static void restack_transient_windows(struct window *win)

1654 {

1655 struct window *leader;

1656 struct window **wins;

1657 int i, n;

1658

1659 leader = NULL;

1660 if (win->wmtransientfor != None)

1661 leader = (struct window *)find_widget(win->wmtransientfor,

1662 WIDGET_WINDOW);

1663 if (leader == NULL)

1664 leader = win;

1665

1666 if (win != leader)

1667 put_window_below(leader, win);

1668

1669 get_window_stack(&wins, &n);

1670 for (i = 0; i < n; i++) {

1671 if (wins[i]->wmtransientfor == leader->client)

1672 put_window_above(wins[i], leader);

1673 }

1674 FREE(wins);

1675 }

1676

1677 static void map_transient_windows(struct window *win)

1678 {

1679 struct window *leader;

1680 struct window **wins;

1681 int i, n;

1682

1683 leader = NULL;

1684 if (win->wmtransientfor != None)

1685 leader = (struct window *)find_widget(win->wmtransientfor,

1686 WIDGET_WINDOW);

1687 if (leader == NULL)

1688 leader = win;

1689

1690 get_window_stack(&wins, &n);

1691 for (i = 0; i < n; i++)

1692 if (wins[i]->wmtransientfor == leader->client)

1693 make_window_visible(wins[i]);

1694 FREE(wins);

1695 make_window_visible(leader);

1696 }

1697

1698 static void put_window_group_below(struct window *win)

1699 {

1700 struct window **wins, *wp;

1701 int n;

1702

1703 if (win->wmhints == NULL

1704 || ~win->wmhints->flags & WindowGroupHint

1705 || win->wmhints->window_group == None

1706 || win->wmhints->window_group == root)

1707 return;

1708

1709 get_window_stack(&wins, &n);

1710 while (n > 1 && wins[--n] != win) {

1711 wp = wins[n];

1712 if (wp->wmhints != NULL

1713 && wp->wmhints->flags & WindowGroupHint

1714 && wp->wmhints->window_group == win->wmhints->window_group)

1715 put_window_below(wp, win);

1716 }

1717 FREE(wins);

1718 }

1719

1720 int window_is_active(struct window *win)

1721 {

1722 return win == active;

1723 }

1724

1725 int window_is_transient_active(struct window *win)

1726 {

1727 return window_is_active(win)

1728 || (active != NULL && windows_are_transient_related(win, active));

1729 }

1730

1731 int window_group_is_active(struct window *win)

1732 {

1733 return window_is_active(win)

1734 || (active != NULL && windows_are_group_related(win, active));

1735 }

1736

1737 int window_family_is_active(struct window *win)

1738 {

1739 return window_is_active(win)

1740 || window_is_transient_active(win) || window_group_is_active(win);

1741 }

1742

1743 int windows_are_related(struct window *win1, struct window *win2)

1744 {

1745 return win1 == win2

1746 || windows_are_group_related(win1, win2)

1747 || windows_are_transient_related(win1, win2);

1748 }

1749

1750 int windows_are_transient_related(struct window *win1, struct window *win2)

1751 {

1752 return win1 == win2

1753 || win1->wmtransientfor == win2->client

1754 || win2->wmtransientfor == win1->client

1755 || (win1->wmtransientfor != None

1756 && win1->wmtransientfor == win2->wmtransientfor);

1757 }

1758

1759 int windows_are_group_related(struct window *win1, struct window *win2)

1760 {

1761 return win1 == win2

1762 || (win1->wmhints != NULL && win2->wmhints != NULL

1763 && win1->wmhints->flags & WindowGroupHint

1764 && win2->wmhints->flags & WindowGroupHint

1765 && win1->wmhints->window_group == win2->wmhints->window_group);

1766 }

1767

1768 /*

1769 * Activate window.

1770 */

1771 void set_active_window_(struct window *win, int button)

1772 {

1773 struct window *old;

1774

1775 if (win != NULL&&button<4) {

1776 raise_window(win); // ???

1777 //if (!window_group_is_active(win))

1778 // put_window_group_below(win);

1779 restack_transient_windows(win);

1780 }

1781

1782 if (win == active)

1783 return;

1784

1785 old = active;

1786 active = win;

1787

1788 if (old != NULL) {

1789 clerr();

1790 grabbutton(display, AnyButton, 0, old->client, True,

1791 ButtonPressMask, GrabModeSync, GrabModeSync, None, None);

1792 sterr();

1793 if(button<4) {

1794 repaint_window_family(old);

1795 hints_deactivate(old);

1796 }

1797 }

1798

1799 if (win != NULL) {

1800 if(button<4)

1801 repaint_window_family(win);

1802 map_transient_windows(win);

1803 make_window_visible(win);

1804

1805 clerr();

1806 XSetInputFocus(display, win->client, RevertToPointerRoot,

1807 CurrentTime);

1808 ungrabbutton(display, AnyButton, 0, win->client);

1809 XAllowEvents(display, ReplayPointer, CurrentTime);

1810 sterr();

1811

1812 if (win->menuitem != NULL)

1813 put_menuitem_first(win->menuitem);

1814 } else {

1815 XSetInputFocus(display, PointerRoot, RevertToPointerRoot,

1816 CurrentTime);

1817 }

1818

1819 if(button<4)

1820 hints_activate(win);

1821 else {

1822 //hints_activate(old);

1823 //active = old;

1824 }

1825 /*if(button>3) {

1826 set_active_window(old);

1827 }*/

1828 }

1829

1830 void set_active_window(struct window *win) {

1831 set_active_window_(win, -1);

1832 }

1833

1834 int get_monitor_cursor() {

1835 Bool result;

1836 Window window_returned;

1837 int root_x, root_y;

1838 int win_x, win_y;

1839 unsigned int mask_return;

1840 result = XQueryPointer(display, root, &window_returned,

1841 &window_returned, &root_x, &root_y, &win_x, &win_y,

1842 &mask_return);

1843 if (result != True) {

1844 fprintf(stderr, "No mouse found.\n");

1845 return -1;

1846 }

1847 for(int i=0; i<monitors_len; i++)

1848 if(root_x>monitors[i].x&&root_x<monitors[i].x+monitors[i].w&&root_y>monitors[i].y&&root_y<monitors[i].y+monitors[i].h)

1849 return i;

1850 return 0;

1851 }

1852

1853 static void make_window_visible(struct window *win)

1854 {

1855 int x, y;

1856

1857 if (WIDGET_X(win) >= DisplayWidth(display, screen) - border_width ||

1858 WIDGET_Y(win) >= DisplayHeight(display, screen) - border_width ||

1859 WIDGET_X(win) + WIDGET_WIDTH(win) < border_width ||

1860 WIDGET_Y(win) + WIDGET_HEIGHT(win) < border_width) {

1861 smartpos(WIDGET_WIDTH(win), WIDGET_HEIGHT(win), &x, &y, get_monitor_cursor());

1862 move_window(win, x, y);

1863 }

1864

1865 if (!WIDGET_MAPPED(win))

1866 map_window(win);

1867 }

1868

1869 Atom getatomprop(struct window *win, Atom prop)

1870 {

1871 int di;

1872 unsigned long dl;

1873 unsigned char *p = NULL;

1874 Atom da, atom = None;

1875

1876 if (XGetWindowProperty(display, win->client, prop, 0L, sizeof atom, False, XA_ATOM,

1877 &da, &di, &dl, &dl, &p) == Success && p) {

1878 atom = *(Atom *)p;

1879 XFree(p);

1880 }

1881 return atom;

1882 }

1883

1884 /*

1885 typedef struct {

1886 long flags;

1887 long functions;

1888 long decorations;

1889 long inputmode;

1890 long status;

1891 } mwmhints;

1892

1893 static Atom MOTIF_WM_HINTS = None;

1894 static mwmhints *getmwmhints(Window w)

1895 {

1896 if (MOTIF_WM_HINTS == None) {

1897 MOTIF_WM_HINTS = XInternAtom(display, "_MOTIF_WM_HINTS", False);

1898 }

1899 unsigned long n = 0;

1900 mwmhints *h = getprop(w, MOTIF_WM_HINTS,

1901 MOTIF_WM_HINTS, 32, &n);

1902 if (h != NULL && n != 5) {

1903 XFree(h);

1904 h = NULL;

1905 }

1906 return h;

1907 }

1908 */

1909 static Atom MOTIF_WM_HINTS = None;

1910 void fetch_wm_motif(struct window *win) {

1911 if (MOTIF_WM_HINTS == None) {

1912 MOTIF_WM_HINTS = XInternAtom(display, "_MOTIF_WM_HINTS", False);

1913 }

1914 long* hints;

1915 Atom ret;

1916 int format;

1917 unsigned long nitems;

1918 unsigned long toberead;

1919 int success = XGetWindowProperty(display, win->client, MOTIF_WM_HINTS, 0, sizeof(long[5]), False, MOTIF_WM_HINTS, &ret, &format, &nitems, &toberead, (unsigned char**)&hints)==Success;

1920 if (success && nitems*format >= sizeof(long[5]))

1921 win->decoration = hints[2]?1:0;

1922 else win->decoration = 1;

1923 }

1924

1925 void window_set_fullscreen(struct window* win, int fullscreen) {

1926 if (fullscreen && !win->fullscreen) {

1927 XChangeProperty(display, win->client, atom[NET_WM_STATE], XA_ATOM, 32,

1928 PropModeReplace, (unsigned char*)&atom[NET_WM_STATE_FULLSCREEN], 1);

1929 win->fullscreen = 1;

1930 remove_decoration(win);

1931 toggle_window_ontop(win);

1932 maximize_window(win, -1, -1);

1933 set_active_window(win);

1934 } else if (!fullscreen && win->fullscreen){

1935 XChangeProperty(display, win->client, atom[NET_WM_STATE], XA_ATOM, 32,

1936 PropModeReplace, (unsigned char*)0, 0);

1937 win->fullscreen = 0;

1938 win->decoration = 1;

1939 toggle_window_ontop(win);

1940 maximize_window(win, -1, -1);

1941 create_decoration(win);

1942 }

1943 }

1944

1945 void update_window_type(struct window *win) {

1946 Atom state = getatomprop(win, atom[NET_WM_STATE]);

1947 Atom wtype = getatomprop(win, atom[NET_WM_WINDOW_TYPE]);

1948 //printf("state %!l(MISSING)d %!l(MISSING)d %!l(MISSING)d\n", state, wtype, atom[NET_WM_WINDOW_TYPE_NORMAL]);

1949 if (state == atom[NET_WM_STATE_FULLSCREEN])

1950 printf("FULL SCREEN!!!\n");

1951

1952 if (wtype == atom[NET_WM_WINDOW_TYPE_TOOLBAR] || wtype == atom[NET_WM_WINDOW_TYPE_DOCK])

1953 toggle_window_ontop(win);

1954 if (wtype == atom[NET_WM_WINDOW_TYPE_SPLASH] || wtype == atom[NET_WM_WINDOW_TYPE_TOOLBAR] || wtype == atom[NET_WM_WINDOW_TYPE_DOCK] || wtype == atom[NET_WM_WINDOW_TYPE_DESKTOP] || wtype == atom[NET_WM_WINDOW_TYPE_MENU])

1955 remove_decoration(win);

1956 else

1957 fetch_wm_motif(win);

1958

1959 }

1960