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