WINGs/wwindow.c

   1
   2 #include <X11/Xmd.h>
   3
   4 #include "WINGsP.h"
   5
   6 #include <X11/Xatom.h>
   7
   8
   9 typedef struct W_Window {
  10     W_Class widgetClass;
  11     W_View *view;
  12
  13     struct W_Window *nextPtr;          /* next in the window list */
  14
  15     struct W_Window *owner;
  16
  17     char *title;
  18
  19     WMPixmap *miniImage;               /* miniwindow */
  20     char *miniTitle;
  21
  22     char *wname;
  23
  24     WMSize resizeIncrement;
  25     WMSize baseSize;
  26     WMSize minSize;
  27     WMSize maxSize;
  28     WMPoint minAspect;
  29     WMPoint maxAspect;
  30
  31     WMPoint upos;
  32     WMPoint ppos;
  33
  34     WMAction *closeAction;
  35     void *closeData;
  36
  37     int level;
  38
  39     struct {
  40         unsigned style:4;
  41         unsigned configured:1;
  42         unsigned documentEdited:1;
  43
  44         unsigned setUPos:1;
  45         unsigned setPPos:1;
  46         unsigned setAspect:1;
  47     } flags;
  48 } _Window;
  49
  50
  51
  52 typedef struct {
  53     CARD32 flags;
  54     CARD32 window_style;
  55     CARD32 window_level;
  56     CARD32 reserved;
  57     Pixmap miniaturize_pixmap;         /* pixmap for miniaturize button */
  58     Pixmap close_pixmap;               /* pixmap for close button */
  59     Pixmap miniaturize_mask;           /* miniaturize pixmap mask */
  60     Pixmap close_mask;                 /* close pixmap mask */
  61     CARD32 extra_flags;
  62 } GNUstepWMAttributes;
  63
  64 #define GSWindowStyleAttr       (1<<0)
  65 #define GSWindowLevelAttr       (1<<1)
  66 #define GSMiniaturizePixmapAttr (1<<3)
  67 #define GSClosePixmapAttr       (1<<4)
  68 #define GSMiniaturizeMaskAttr   (1<<5)
  69 #define GSCloseMaskAttr         (1<<6)
  70 #define GSExtraFlagsAttr        (1<<7)
  71
  72 /* extra flags */
  73 #define GSDocumentEditedFlag    (1<<0)
  74 #define GSNoApplicationIconFlag (1<<5)
  75
  76 #define WMFHideOtherApplications        10
  77 #define WMFHideApplication              12
  78
  79
  80
  81 static void willResizeWindow(W_ViewDelegate *, WMView *, unsigned*, unsigned*);
  82
  83 struct W_ViewDelegate _WindowViewDelegate = {
  84     NULL,
  85     NULL,
  86     NULL,
  87     NULL,
  88     willResizeWindow
  89 };
  90
  91
  92 #define DEFAULT_WIDTH   400
  93 #define DEFAULT_HEIGHT  180
  94 #define DEFAULT_TITLE   ""
  95
  96
  97 static void destroyWindow(_Window *win);
  98
  99 static void handleEvents();
 100
 101 static void realizeWindow();
 102
 103 static void
 104 realizeObserver(void *self, WMNotification *not)
 105 {
 106     realizeWindow(self);
 107 }
 108
 109
 110 WMWindow*
 111 WMCreatePanelWithStyleForWindow(WMWindow *owner, char *name, int style)
 112 {
 113     WMWindow *win;
 114
 115     win = WMCreateWindowWithStyle(owner->view->screen, name, style);
 116     win->owner = owner;
 117
 118     return win;
 119 }
 120
 121
 122
 123 WMWindow*
 124 WMCreatePanelForWindow(WMWindow *owner, char *name)
 125 {
 126     return WMCreatePanelWithStyleForWindow(owner, name,
 127                                            WMTitledWindowMask
 128                                            |WMClosableWindowMask
 129                                            |WMResizableWindowMask);
 130 }
 131
 132
 133 void
 134 WMChangePanelOwner(WMWindow *win, WMWindow *newOwner)
 135 {
 136     win->owner = newOwner;
 137
 138     if (win->view->flags.realized && newOwner) {
 139         XSetTransientForHint(win->view->screen->display, win->view->window,
 140                              newOwner->view->window);
 141     }
 142 }
 143
 144
 145
 146 WMWindow*
 147 WMCreateWindow(WMScreen *screen, char *name)
 148 {
 149     return WMCreateWindowWithStyle(screen, name, WMTitledWindowMask
 150                                    |WMClosableWindowMask
 151                                    |WMMiniaturizableWindowMask
 152                                    |WMResizableWindowMask);
 153 }
 154
 155
 156
 157 WMWindow*
 158 WMCreateWindowWithStyle(WMScreen *screen, char *name, int style)
 159 {
 160     _Window *win;
 161
 162     win = wmalloc(sizeof(_Window));
 163     memset(win, 0, sizeof(_Window));
 164
 165     win->widgetClass = WC_Window;
 166
 167     win->view = W_CreateTopView(screen);
 168     if (!win->view) {
 169         wfree(win);
 170         return NULL;
 171     }
 172     win->view->self = win;
 173
 174     win->view->delegate = &_WindowViewDelegate;
 175
 176     win->wname = wstrdup(name);
 177
 178     /* add to the window list of the screen (application) */
 179     win->nextPtr = screen->windowList;
 180     screen->windowList = win;
 181
 182     WMCreateEventHandler(win->view, ExposureMask|StructureNotifyMask
 183                          |ClientMessageMask|FocusChangeMask,
 184                          handleEvents, win);
 185
 186     W_ResizeView(win->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 187
 188     WMAddNotificationObserver(realizeObserver, win,
 189                               WMViewRealizedNotification, win->view);
 190
 191     win->flags.style = style;
 192
 193     win->level = WMNormalWindowLevel;
 194
 195     /* kluge. Find a better solution */
 196     W_SetFocusOfTopLevel(win->view, win->view);
 197
 198     return win;
 199 }
 200
 201
 202
 203 static void
 204 setWindowTitle(WMWindow *win, const char *title)
 205 {
 206     WMScreen *scr= win->view->screen;
 207     XTextProperty property;
 208     int result;
 209
 210     result = XmbTextListToTextProperty(scr->display,
 211                                        (char**)&title, 1, XStdICCTextStyle,
 212                                        &property);
 213     if (result == XNoMemory || result == XLocaleNotSupported) {
 214         wwarning("window title conversion error... using STRING encoding");
 215         XStoreName(scr->display, win->view->window, title);
 216     } else {
 217         XSetWMName(scr->display, win->view->window, &property);
 218         if (property.value)
 219           XFree(property.value);
 220     }
 221
 222     XChangeProperty(scr->display, win->view->window,
 223                     scr->netwmName, scr->utf8String, 8,
 224                     PropModeReplace, (unsigned char *)title, strlen(title));
 225 }
 226
 227
 228 static void
 229 setMiniwindowTitle(WMWindow *win, const char *title)
 230 {
 231     WMScreen *scr= win->view->screen;
 232     XTextProperty property;
 233     int result;
 234
 235     result = XmbTextListToTextProperty(scr->display,
 236                                        (char**)&title, 1, XStdICCTextStyle,
 237                                        &property);
 238     if (result == XNoMemory || result == XLocaleNotSupported) {
 239         wwarning("icon title conversion error..using STRING encoding");
 240         XSetIconName(scr->display, win->view->window, title);
 241     } else {
 242         XSetWMIconName(scr->display, win->view->window, &property);
 243         if (property.value)
 244           XFree(property.value);
 245     }
 246
 247     XChangeProperty(scr->display, win->view->window,
 248                     scr->netwmIconName, scr->utf8String, 8,
 249                     PropModeReplace, (unsigned char *)title, strlen(title));
 250 }
 251
 252
 253 static void
 254 setMiniwindow(WMWindow *win, RImage *image)
 255 {
 256     WMScreen *scr= win->view->screen;
 257     CARD32 *data;
 258     int x, y;
 259     int o;
 260
 261     if (!image)
 262       return;
 263
 264     data= malloc((image->width * image->height + 2) * sizeof(CARD32));
 265     if (!data)
 266       return;
 267
 268     o= 0;
 269     data[o++] = image->width;
 270     data[o++] = image->height;
 271
 272     for (y= 0; y < image->height; y++) {
 273         for (x= 0; x < image->width; x++) {
 274             CARD32 pixel;
 275             int offs= (x+y*image->width);
 276
 277             if (image->format == RRGBFormat)
 278               pixel= image->data[offs*3]<<16 | image->data[offs*3+1]<<8 | image->data[offs*3+2];
 279             else
 280               pixel= image->data[offs*4]<<16 | image->data[offs*4+1]<<8 | image->data[offs*4+2] | image->data[offs*4+3] << 24;
 281
 282             data[o++]= pixel;
 283         }
 284     }
 285
 286     XChangeProperty(scr->display, win->view->window,
 287                     scr->netwmIcon, XA_CARDINAL, 32,
 288                     PropModeReplace,
 289                     (unsigned char *)data,
 290                     (image->width * image->height + 2) * sizeof(CARD32));
 291
 292     free(data);
 293 }
 294
 295
 296 void
 297 WMSetWindowTitle(WMWindow *win, char *title)
 298 {
 299     if (win->title!=NULL)
 300         wfree(win->title);
 301     if (title!=NULL)
 302         win->title = wstrdup(title);
 303     else
 304         win->title = NULL;
 305
 306     if (win->view->flags.realized) {
 307         setWindowTitle(win, title);
 308     }
 309 }
 310
 311
 312
 313
 314 void
 315 WMSetWindowCloseAction(WMWindow *win, WMAction *action, void *clientData)
 316 {
 317     Atom *atoms = NULL;
 318     Atom *newAtoms;
 319     int count;
 320     WMScreen *scr = win->view->screen;
 321
 322     if (win->view->flags.realized) {
 323         if (action && !win->closeAction) {
 324             if (!XGetWMProtocols(scr->display, win->view->window, &atoms,
 325                                  &count)) {
 326                 count = 0;
 327             }
 328             newAtoms = wmalloc((count+1)*sizeof(Atom));
 329             if (count > 0)
 330                 memcpy(newAtoms, atoms, count*sizeof(Atom));
 331             newAtoms[count++] = scr->deleteWindowAtom;
 332             XSetWMProtocols(scr->display, win->view->window, newAtoms, count);
 333             if (atoms)
 334                 XFree(atoms);
 335             wfree(newAtoms);
 336         } else if (!action && win->closeAction) {
 337             int i, ncount;
 338
 339             if (XGetWMProtocols(scr->display, win->view->window, &atoms,
 340                                 &count) && count>0) {
 341                 newAtoms = wmalloc((count-1)*sizeof(Atom));
 342                 ncount = 0;
 343                 for (i=0; i < count; i++) {
 344                     if (atoms[i]!=scr->deleteWindowAtom) {
 345                         newAtoms[i] = atoms[i];
 346                         ncount++;
 347                     }
 348                 }
 349                 XSetWMProtocols(scr->display, win->view->window, newAtoms,
 350                                 ncount);
 351                 if (atoms)
 352                     XFree(atoms);
 353                 wfree(newAtoms);
 354             }
 355         }
 356     }
 357     win->closeAction = action;
 358     win->closeData = clientData;
 359 }
 360
 361
 362
 363 static void
 364 willResizeWindow(W_ViewDelegate *self, WMView *view,
 365                  unsigned *width, unsigned *height)
 366 {
 367     WMWindow *win = (WMWindow*)view->self;
 368
 369     if (win->minSize.width > 0 && win->minSize.height > 0) {
 370         if (*width < win->minSize.width)
 371             *width = win->minSize.width;
 372         if (*height < win->minSize.height)
 373             *height = win->minSize.height;
 374     }
 375
 376     if (win->maxSize.width > 0 && win->maxSize.height > 0) {
 377         if (*width > win->maxSize.width)
 378             *width = win->maxSize.width;
 379         if (*height > win->maxSize.height)
 380             *height = win->maxSize.height;
 381     }
 382 }
 383
 384
 385 static void
 386 setSizeHints(WMWindow *win)
 387 {
 388     XSizeHints *hints;
 389
 390     hints = XAllocSizeHints();
 391     if (!hints) {
 392         wwarning("could not allocate memory for window size hints");
 393         return;
 394     }
 395
 396     hints->flags = 0;
 397
 398     if (win->flags.setPPos) {
 399         hints->flags |= PPosition;
 400         hints->x = win->ppos.x;
 401         hints->y = win->ppos.y;
 402     }
 403     if (win->flags.setUPos) {
 404         hints->flags |= USPosition;
 405         hints->x = win->upos.x;
 406         hints->y = win->upos.y;
 407     }
 408     if (win->minSize.width>0 && win->minSize.height>0) {
 409         hints->flags |= PMinSize;
 410         hints->min_width = win->minSize.width;
 411         hints->min_height = win->minSize.height;
 412     }
 413     if (win->maxSize.width>0 && win->maxSize.height>0) {
 414         hints->flags |= PMaxSize;
 415         hints->max_width = win->maxSize.width;
 416         hints->max_height = win->maxSize.height;
 417     }
 418     if (win->baseSize.width>0 && win->baseSize.height>0) {
 419         hints->flags |= PBaseSize;
 420         hints->base_width = win->baseSize.width;
 421         hints->base_height = win->baseSize.height;
 422     }
 423     if (win->resizeIncrement.width>0 && win->resizeIncrement.height>0) {
 424         hints->flags |= PResizeInc;
 425         hints->width_inc = win->resizeIncrement.width;
 426         hints->height_inc = win->resizeIncrement.height;
 427     }
 428     if (win->flags.setAspect) {
 429         hints->flags |= PAspect;
 430         hints->min_aspect.x = win->minAspect.x;
 431         hints->min_aspect.y = win->minAspect.y;
 432         hints->max_aspect.x = win->maxAspect.x;
 433         hints->max_aspect.y = win->maxAspect.y;
 434     }
 435
 436
 437     if (hints->flags) {
 438         XSetWMNormalHints(win->view->screen->display, win->view->window, hints);
 439     }
 440     XFree(hints);
 441 }
 442
 443
 444
 445 static void
 446 writeGNUstepWMAttr(WMScreen *scr, Window window, GNUstepWMAttributes *attr)
 447 {
 448     unsigned long data[9];
 449
 450     /* handle idiot compilers where array of CARD32 != struct of CARD32 */
 451     data[0] = attr->flags;
 452     data[1] = attr->window_style;
 453     data[2] = attr->window_level;
 454     data[3] = 0;                       /* reserved */
 455     /* The X protocol says XIDs are 32bit */
 456     data[4] = attr->miniaturize_pixmap;
 457     data[5] = attr->close_pixmap;
 458     data[6] = attr->miniaturize_mask;
 459     data[7] = attr->close_mask;
 460     data[8] = attr->extra_flags;
 461     XChangeProperty(scr->display, window, scr->attribsAtom, scr->attribsAtom,
 462                     32, PropModeReplace,  (unsigned char *)data, 9);
 463 }
 464
 465
 466 static void
 467 setWindowMakerHints(WMWindow *win)
 468 {
 469     GNUstepWMAttributes attribs;
 470     WMScreen *scr = WMWidgetScreen(win);
 471
 472     memset(&attribs, 0, sizeof(GNUstepWMAttributes));
 473     attribs.flags = GSWindowStyleAttr|GSWindowLevelAttr|GSExtraFlagsAttr;
 474     attribs.window_style = win->flags.style;
 475     attribs.window_level = win->level;
 476     if (win->flags.documentEdited)
 477         attribs.extra_flags = GSDocumentEditedFlag;
 478     else
 479         attribs.extra_flags = 0;
 480
 481     writeGNUstepWMAttr(scr, win->view->window, &attribs);
 482 }
 483
 484
 485 static void
 486 realizeWindow(WMWindow *win)
 487 {
 488     XWMHints *hints;
 489     XClassHint *classHint;
 490     WMScreen *scr = win->view->screen;
 491     Atom atoms[4];
 492     int count;
 493
 494     classHint = XAllocClassHint();
 495     classHint->res_name = win->wname;
 496     classHint->res_class = WMGetApplicationName();
 497     XSetClassHint(scr->display, win->view->window, classHint);
 498     XFree(classHint);
 499
 500     hints = XAllocWMHints();
 501     hints->flags = 0;
 502     if (!scr->aflags.simpleApplication) {
 503         hints->flags |= WindowGroupHint;
 504         hints->window_group = scr->groupLeader;
 505     }
 506     if (win->miniImage) {
 507         hints->flags |= IconPixmapHint;
 508         hints->icon_pixmap = WMGetPixmapXID(win->miniImage);
 509         hints->icon_mask = WMGetPixmapMaskXID(win->miniImage);
 510         if (hints->icon_mask != None) {
 511             hints->flags |= IconMaskHint;
 512         }
 513     }
 514     if (hints->flags != 0)
 515         XSetWMHints(scr->display, win->view->window, hints);
 516     XFree(hints);
 517
 518     count = 0;
 519     if (win->closeAction) {
 520         atoms[count++] = scr->deleteWindowAtom;
 521     }
 522
 523     if (count>0)
 524         XSetWMProtocols(scr->display, win->view->window, atoms, count);
 525
 526     if (win->title || win->miniTitle)
 527         XmbSetWMProperties(scr->display, win->view->window, win->title,
 528                            win->miniTitle, NULL, 0, NULL, NULL, NULL);
 529
 530     setWindowMakerHints(win);
 531
 532     setSizeHints(win);
 533
 534     if (win->owner) {
 535         XSetTransientForHint(scr->display, win->view->window,
 536                              win->owner->view->window);
 537     }
 538
 539     if (win->title)
 540       setWindowTitle(win, win->title);
 541 }
 542
 543
 544
 545 void
 546 WMSetWindowAspectRatio(WMWindow *win, int minX, int minY,
 547                        int maxX, int maxY)
 548 {
 549     win->flags.setAspect = 1;
 550     win->minAspect.x = minX;
 551     win->minAspect.y = minY;
 552     win->maxAspect.x = maxX;
 553     win->maxAspect.y = maxY;
 554     if (win->view->flags.realized)
 555         setSizeHints(win);
 556 }
 557
 558
 559
 560 void
 561 WMSetWindowInitialPosition(WMWindow *win, int x, int y)
 562 {
 563     win->flags.setPPos = 1;
 564     win->ppos.x = x;
 565     win->ppos.y = y;
 566     if (win->view->flags.realized)
 567         setSizeHints(win);
 568     WMMoveWidget(win, x, y);
 569 }
 570
 571
 572
 573 void
 574 WMSetWindowUserPosition(WMWindow *win, int x, int y)
 575 {
 576     win->flags.setUPos = 1;
 577     win->upos.x = x;
 578     win->upos.y = y;
 579     if (win->view->flags.realized)
 580         setSizeHints(win);
 581     WMMoveWidget(win, x, y);
 582 }
 583
 584
 585
 586
 587 void
 588 WMSetWindowMinSize(WMWindow *win, unsigned width, unsigned height)
 589 {
 590     win->minSize.width = width;
 591     win->minSize.height = height;
 592     if (win->view->flags.realized)
 593         setSizeHints(win);
 594 }
 595
 596
 597
 598 void
 599 WMSetWindowMaxSize(WMWindow *win, unsigned width, unsigned height)
 600 {
 601     win->maxSize.width = width;
 602     win->maxSize.height = height;
 603     if (win->view->flags.realized)
 604         setSizeHints(win);
 605 }
 606
 607
 608 void
 609 WMSetWindowBaseSize(WMWindow *win, unsigned width, unsigned height)
 610 {
 611     /* TODO: validate sizes */
 612     win->baseSize.width = width;
 613     win->baseSize.height = height;
 614     if (win->view->flags.realized)
 615         setSizeHints(win);
 616 }
 617
 618
 619 void
 620 WMSetWindowResizeIncrements(WMWindow *win, unsigned wIncr, unsigned hIncr)
 621 {
 622     win->resizeIncrement.width = wIncr;
 623     win->resizeIncrement.height = hIncr;
 624     if (win->view->flags.realized)
 625         setSizeHints(win);
 626 }
 627
 628
 629 void
 630 WMSetWindowLevel(WMWindow *win, int level)
 631 {
 632     win->level = level;
 633     if (win->view->flags.realized)
 634         setWindowMakerHints(win);
 635 }
 636
 637
 638 void
 639 WMSetWindowDocumentEdited(WMWindow *win, Bool flag)
 640 {
 641     flag = ((flag==0) ? 0 : 1);
 642     if (win->flags.documentEdited != flag) {
 643         win->flags.documentEdited = flag;
 644         if (win->view->flags.realized)
 645             setWindowMakerHints(win);
 646     }
 647 }
 648
 649
 650 void
 651 WMSetWindowMiniwindowImage(WMWindow *win, RImage *image)
 652 {
 653     if (win->view->flags.realized)
 654         setMiniwindow(win, image);
 655 }
 656
 657
 658 void
 659 WMSetWindowMiniwindowPixmap(WMWindow *win, WMPixmap *pixmap)
 660 {
 661     if ((win->miniImage && !pixmap) || (!win->miniImage && pixmap)) {
 662         if (win->miniImage)
 663             WMReleasePixmap(win->miniImage);
 664
 665         if (pixmap)
 666             win->miniImage = WMRetainPixmap(pixmap);
 667         else
 668             win->miniImage = NULL;
 669
 670         if (win->view->flags.realized) {
 671             XWMHints *hints;
 672
 673             hints = XGetWMHints(win->view->screen->display, win->view->window);
 674             if (!hints) {
 675                 hints = XAllocWMHints();
 676                 if (!hints) {
 677                     wwarning("could not allocate memory for WM hints");
 678                     return;
 679                 }
 680                 hints->flags = 0;
 681             }
 682             if (pixmap) {
 683                 hints->flags |= IconPixmapHint;
 684                 hints->icon_pixmap = WMGetPixmapXID(pixmap);
 685                 hints->icon_mask = WMGetPixmapMaskXID(pixmap);
 686                 if (hints->icon_mask != None) {
 687                     hints->flags |= IconMaskHint;
 688                 }
 689             }
 690             XSetWMHints(win->view->screen->display, win->view->window, hints);
 691             XFree(hints);
 692         }
 693     }
 694 }
 695
 696
 697 void
 698 WMSetWindowMiniwindowTitle(WMWindow *win, char *title)
 699 {
 700     if ((win->miniTitle && !title) || (!win->miniTitle && title)
 701         || (title && win->miniTitle && strcoll(title, win->miniTitle)!=0)) {
 702         if (win->miniTitle)
 703             wfree(win->miniTitle);
 704
 705         if (title)
 706             win->miniTitle = wstrdup(title);
 707         else
 708             win->miniTitle = NULL;
 709
 710         if (win->view->flags.realized) {
 711             setMiniwindowTitle(win, title);
 712         }
 713     }
 714 }
 715
 716
 717 void
 718 WMCloseWindow(WMWindow *win)
 719 {
 720     WMUnmapWidget(win);
 721     /* withdraw the window */
 722     if (win->view->flags.realized)
 723         XWithdrawWindow(win->view->screen->display, win->view->window,
 724                         win->view->screen->screen);
 725 }
 726
 727
 728 static void
 729 handleEvents(XEvent *event, void *clientData)
 730 {
 731     _Window *win = (_Window*)clientData;
 732     W_View *view = win->view;
 733
 734
 735     switch (event->type) {
 736     case ClientMessage:
 737         if (event->xclient.message_type == win->view->screen->protocolsAtom
 738             && event->xclient.format == 32
 739             && event->xclient.data.l[0]==win->view->screen->deleteWindowAtom) {
 740
 741             if (win->closeAction) {
 742                 (*win->closeAction)(win, win->closeData);
 743             }
 744         }
 745         break;
 746         /*
 747          * was causing windows to ignore commands like closeWindow
 748          * after the windows is iconized/restored or a workspace change
 749          * if this is really needed, put the MapNotify portion too and
 750          * fix the restack bug in wmaker
 751          case UnmapNotify:
 752          WMUnmapWidget(win);
 753          break;
 754          *
 755          case MapNotify:
 756          WMMapWidget(win);
 757          break;
 758
 759          */
 760     case DestroyNotify:
 761         destroyWindow(win);
 762         break;
 763
 764     case ConfigureNotify:
 765         if (event->xconfigure.width != view->size.width
 766             || event->xconfigure.height != view->size.height) {
 767
 768             view->size.width = event->xconfigure.width;
 769             view->size.height = event->xconfigure.height;
 770
 771             if (view->flags.notifySizeChanged) {
 772                 WMPostNotificationName(WMViewSizeDidChangeNotification,
 773                                        view, NULL);
 774             }
 775         }
 776         if (event->xconfigure.x != view->pos.x
 777             || event->xconfigure.y != view->pos.y) {
 778
 779             if (event->xconfigure.send_event) {
 780                 view->pos.x = event->xconfigure.x;
 781                 view->pos.y = event->xconfigure.y;
 782             } else {
 783                 Window foo;
 784
 785                 XTranslateCoordinates(view->screen->display,
 786                                       view->window, view->screen->rootWin,
 787                                       event->xconfigure.x, event->xconfigure.y,
 788                                       &view->pos.x, &view->pos.y, &foo);
 789             }
 790         }
 791         break;
 792     }
 793 }
 794
 795
 796
 797
 798 static void
 799 destroyWindow(_Window *win)
 800 {
 801     WMScreen *scr = win->view->screen;
 802
 803     WMRemoveNotificationObserver(win);
 804
 805     if (scr->windowList == win) {
 806         scr->windowList = scr->windowList->nextPtr;
 807     } else {
 808         WMWindow *ptr;
 809         ptr = scr->windowList;
 810
 811         if (ptr) {
 812             while (ptr->nextPtr) {
 813                 if (ptr->nextPtr==win) {
 814                     ptr->nextPtr = ptr->nextPtr->nextPtr;
 815                     break;
 816                 }
 817                 ptr = ptr->nextPtr;
 818             }
 819         }
 820     }
 821
 822     if (win->title) {
 823         wfree(win->title);
 824     }
 825
 826     if (win->miniTitle) {
 827         wfree(win->miniTitle);
 828     }
 829
 830     if (win->miniImage) {
 831         WMReleasePixmap(win->miniImage);
 832     }
 833
 834     if (win->wname)
 835         wfree(win->wname);
 836
 837     wfree(win);
 838 }
 839
 840