WINGs/wview.c

   1
   2
   3 #include "WINGsP.h"
   4
   5 #include <X11/Xresource.h>
   6
   7
   8
   9 /* the notifications about views */
  10
  11 char *WMViewSizeDidChangeNotification = "WMViewSizeDidChangeNotification";
  12 char *WMViewFocusDidChangeNotification = "WMViewFocusDidChangeNotification";
  13 char *WMViewRealizedNotification = "WMViewRealizedNotification";
  14
  15
  16 #define EVENT_MASK  \
  17     KeyPressMask|KeyReleaseMask|ButtonPressMask|ButtonReleaseMask| \
  18     EnterWindowMask|LeaveWindowMask|PointerMotionMask|ExposureMask| \
  19     VisibilityChangeMask|FocusChangeMask|PropertyChangeMask|\
  20     SubstructureNotifyMask|SubstructureRedirectMask
  21
  22
  23 static XSetWindowAttributes defAtts= {
  24     None,                       /* background_pixmap */
  25     0,                          /* background_pixel */
  26     CopyFromParent,             /* border_pixmap */
  27     0,                          /* border_pixel */
  28     ForgetGravity,              /* bit_gravity */
  29     ForgetGravity,              /* win_gravity */
  30     NotUseful,                  /* backing_store */
  31     (unsigned) ~0,              /* backing_planes */
  32     0,                          /* backing_pixel */
  33     False,                      /* save_under */
  34     EVENT_MASK,                 /* event_mask */
  35     0,                          /* do_not_propagate_mask */
  36     False,                      /* override_redirect */
  37     None,                       /* colormap */
  38     None                        /* cursor */
  39 };
  40
  41
  42
  43 static XContext ViewContext=0;  /* context for views */
  44
  45
  46
  47
  48 W_View*
  49 W_GetViewForXWindow(Display *display, Window window)
  50 {
  51     W_View *view;
  52
  53     if (XFindContext(display, window, ViewContext, (XPointer*)&view)==0) {
  54         return view;
  55     }
  56     return NULL;
  57 }
  58
  59
  60
  61 static void
  62 unparentView(W_View *view)
  63 {
  64     /* remove from parent's children list */
  65     if (view->parent!=NULL) {
  66         W_View *ptr;
  67
  68         ptr = view->parent->childrenList;
  69         if (ptr == view) {
  70             view->parent->childrenList = view->nextSister;
  71         } else {
  72             while (ptr!=NULL) {
  73                 if (ptr->nextSister == view) {
  74                     ptr->nextSister = view->nextSister;
  75                     break;
  76                 }
  77                 ptr = ptr->nextSister;
  78             }
  79         }
  80     }
  81     view->parent = NULL;
  82 }
  83
  84
  85 static void
  86 adoptChildView(W_View *view, W_View *child)
  87 {
  88     child->nextSister = NULL;
  89
  90     /* add to end of children list of parent */
  91     if (view->childrenList == NULL) {
  92         view->childrenList = child;
  93     } else {
  94         W_View *ptr;
  95
  96         ptr = view->childrenList;
  97         while (ptr->nextSister!=NULL)
  98             ptr = ptr->nextSister;
  99         ptr->nextSister = child;
 100     }
 101     child->parent = view;
 102 }
 103
 104
 105 static W_View*
 106 createView(W_Screen *screen, W_View *parent)
 107 {
 108     W_View *view;
 109
 110     if (ViewContext==0)
 111         ViewContext = XUniqueContext();
 112
 113     view = wmalloc(sizeof(W_View));
 114     memset(view, 0, sizeof(W_View));
 115
 116     view->screen = screen;
 117
 118     if (parent!=NULL) {
 119         /* attributes are not valid for root window */
 120         view->attribFlags = CWEventMask|CWBitGravity;
 121         view->attribs = defAtts;
 122
 123         view->attribFlags |= CWBackPixel|CWColormap|CWBorderPixel;
 124         view->attribs.background_pixel = W_PIXEL(screen->gray);
 125         view->attribs.border_pixel = W_PIXEL(screen->black);
 126         view->attribs.colormap = screen->colormap;
 127
 128         view->backColor = WMRetainColor(screen->gray);
 129
 130         adoptChildView(parent, view);
 131     }
 132
 133     view->xic = 0;
 134
 135     view->refCount = 1;
 136
 137     view->eventHandlers = WMCreateArrayWithDestructor(4, wfree);
 138
 139     return view;
 140 }
 141
 142
 143
 144 W_View*
 145 W_CreateView(W_View *parent)
 146 {
 147     return createView(parent->screen, parent);
 148 }
 149
 150
 151 W_View*
 152 W_CreateRootView(W_Screen *screen)
 153 {
 154     W_View *view;
 155
 156     view = createView(screen, NULL);
 157
 158     view->window = screen->rootWin;
 159
 160     view->flags.realized = 1;
 161     view->flags.mapped = 1;
 162     view->flags.root = 1;
 163
 164     view->size.width =
 165         WidthOfScreen(ScreenOfDisplay(screen->display, screen->screen));
 166     view->size.height =
 167         HeightOfScreen(ScreenOfDisplay(screen->display, screen->screen));
 168
 169     return view;
 170 }
 171
 172
 173 W_View*
 174 W_CreateTopView(W_Screen *screen)
 175 {
 176     W_View *view;
 177
 178     view = createView(screen, screen->rootView);
 179     if (!view)
 180         return NULL;
 181
 182     view->flags.topLevel = 1;
 183     view->attribs.event_mask |= StructureNotifyMask;
 184
 185     return view;
 186 }
 187
 188
 189 W_View*
 190 W_CreateUnmanagedTopView(W_Screen *screen)
 191 {
 192     W_View *view;
 193
 194     view = createView(screen, screen->rootView);
 195     if (!view)
 196         return NULL;
 197
 198     view->flags.topLevel = 1;
 199     view->attribs.event_mask |= StructureNotifyMask;
 200
 201     view->attribFlags |= CWOverrideRedirect;
 202     view->attribs.override_redirect = True;
 203
 204     return view;
 205 }
 206
 207
 208 void
 209 W_RealizeView(W_View *view)
 210 {
 211     Window parentWID;
 212     Display *dpy = view->screen->display;
 213     W_View *ptr;
 214
 215     assert(view->size.width > 0);
 216     assert(view->size.height > 0);
 217
 218     if (view->parent && !view->parent->flags.realized) {
 219         wwarning("trying to realize widget of unrealized parent");
 220         return;
 221     }
 222
 223     if (!view->flags.realized) {
 224         parentWID = view->parent->window;
 225         view->window = XCreateWindow(dpy, parentWID, view->pos.x, view->pos.y,
 226                                      view->size.width, view->size.height, 0,
 227                                      view->screen->depth, InputOutput,
 228                                      view->screen->visual, view->attribFlags,
 229                                      &view->attribs);
 230
 231         XSaveContext(dpy, view->window, ViewContext, (XPointer)view);
 232
 233         view->flags.realized = 1;
 234
 235         if (view->flags.mapWhenRealized) {
 236             W_MapView(view);
 237             view->flags.mapWhenRealized = 0;
 238         }
 239
 240         WMPostNotificationName(WMViewRealizedNotification, view, NULL);
 241     }
 242
 243     /* realize children */
 244     ptr = view->childrenList;
 245     while (ptr!=NULL) {
 246         W_RealizeView(ptr);
 247
 248         ptr = ptr->nextSister;
 249     }
 250 }
 251
 252
 253 void
 254 W_ReparentView(W_View *view, W_View *newParent, int x, int y)
 255 {
 256     Display *dpy = view->screen->display;
 257
 258     assert(!view->flags.topLevel);
 259
 260     unparentView(view);
 261     adoptChildView(newParent, view);
 262
 263     if (view->flags.realized) {
 264         if (newParent->flags.realized) {
 265             XReparentWindow(dpy, view->window, newParent->window, x, y);
 266         } else {
 267             wwarning("trying to reparent realized view to unrealized parent");
 268             return;
 269         }
 270     }
 271
 272     view->pos.x = x;
 273     view->pos.y = y;
 274 }
 275
 276
 277 void
 278 W_RaiseView(W_View *view)
 279 {
 280     if (W_VIEW_REALIZED(view))
 281         XRaiseWindow(W_VIEW_DISPLAY(view), W_VIEW_DRAWABLE(view));
 282 }
 283
 284
 285
 286 void
 287 W_LowerView(W_View *view)
 288 {
 289     if (W_VIEW_REALIZED(view))
 290         XLowerWindow(W_VIEW_DISPLAY(view), W_VIEW_DRAWABLE(view));
 291 }
 292
 293
 294
 295 void
 296 W_MapView(W_View *view)
 297 {
 298     if (!view->flags.mapped) {
 299         if (view->flags.realized) {
 300             XMapRaised(view->screen->display, view->window);
 301             XFlush(view->screen->display);
 302             view->flags.mapped = 1;
 303         } else {
 304             view->flags.mapWhenRealized = 1;
 305         }
 306     }
 307 }
 308
 309
 310 /*
 311  * W_MapSubviews-
 312  *     maps all children of the current view that where already realized.
 313  */
 314 void
 315 W_MapSubviews(W_View *view)
 316 {
 317     XMapSubwindows(view->screen->display, view->window);
 318     XFlush(view->screen->display);
 319
 320     view = view->childrenList;
 321     while (view) {
 322         view->flags.mapped = 1;
 323         view->flags.mapWhenRealized = 0;
 324         view = view->nextSister;
 325     }
 326 }
 327
 328
 329
 330 void
 331 W_UnmapSubviews(W_View *view)
 332 {
 333     XUnmapSubwindows(view->screen->display, view->window);
 334     XFlush(view->screen->display);
 335
 336     view = view->childrenList;
 337     while (view) {
 338         view->flags.mapped = 0;
 339         view->flags.mapWhenRealized = 0;
 340         view = view->nextSister;
 341     }
 342 }
 343
 344
 345
 346 void
 347 W_UnmapView(W_View *view)
 348 {
 349     view->flags.mapWhenRealized = 0;
 350     if (!view->flags.mapped)
 351         return;
 352
 353     XUnmapWindow(view->screen->display, view->window);
 354     XFlush(view->screen->display);
 355
 356     view->flags.mapped = 0;
 357 }
 358
 359
 360 W_View*
 361 W_TopLevelOfView(W_View *view)
 362 {
 363     W_View *toplevel;
 364
 365     for (toplevel=view;
 366          toplevel && !toplevel->flags.topLevel;
 367          toplevel=toplevel->parent);
 368
 369     return toplevel;
 370 }
 371
 372
 373 static void
 374 destroyView(W_View *view)
 375 {
 376     W_View *ptr;
 377
 378     if (view->flags.alreadyDead)
 379         return;
 380     view->flags.alreadyDead = 1;
 381
 382     /* delete the balloon text for the view, if there's any */
 383     WMSetBalloonTextForView(NULL, view);
 384
 385     if (view->nextFocusChain)
 386         view->nextFocusChain->prevFocusChain = view->prevFocusChain;
 387     if (view->prevFocusChain)
 388         view->prevFocusChain->nextFocusChain = view->nextFocusChain;
 389
 390     /* Do not leave focus in a inexisting control */
 391     if (W_FocusedViewOfToplevel(W_TopLevelOfView(view))==view)
 392         W_SetFocusOfTopLevel(W_TopLevelOfView(view), NULL);
 393
 394     if (view->flags.topLevel) {
 395         W_FocusInfo *info = view->screen->focusInfo;
 396         /* remove focus information associated to this toplevel */
 397
 398         if (info) {
 399             if (info->toplevel==view) {
 400                 view->screen->focusInfo = info->next;
 401                 wfree(info);
 402             } else {
 403                 while (info->next) {
 404                     if (info->next->toplevel == view)
 405                         break;
 406                     info = info->next;
 407                 }
 408                 if (info->next) {
 409                     W_FocusInfo *next = info->next->next;
 410                     wfree(info->next);
 411                     info->next = next;
 412                 }
 413                 /* else the toplevel did not have any focused subview */
 414             }
 415         }
 416     }
 417
 418     /* destroy children recursively */
 419     while (view->childrenList!=NULL) {
 420         ptr = view->childrenList;
 421         ptr->flags.parentDying = 1;
 422
 423         W_DestroyView(ptr);
 424
 425         if (ptr == view->childrenList) {
 426             view->childrenList = ptr->nextSister;
 427             ptr->parent = NULL;
 428         }
 429     }
 430
 431     W_CallDestroyHandlers(view);
 432
 433     if (view->flags.realized) {
 434         XDeleteContext(view->screen->display,
 435                        view->window, ViewContext);
 436
 437         /* if parent is being destroyed, it will die naturaly */
 438         if (!view->flags.parentDying || view->flags.topLevel)
 439             XDestroyWindow(view->screen->display, view->window);
 440     }
 441
 442     /* remove self from parent's children list */
 443     unparentView(view);
 444
 445     /* the array has a wfree() destructor that will be called automatically */
 446     WMFreeArray(view->eventHandlers);
 447     view->eventHandlers = NULL;
 448
 449     WMRemoveNotificationObserver(view);
 450
 451     W_FreeViewXdndPart(view);
 452
 453     if (view->backColor)
 454         WMReleaseColor(view->backColor);
 455
 456     wfree(view);
 457 }
 458
 459
 460
 461 void
 462 W_DestroyView(W_View *view)
 463 {
 464     view->refCount--;
 465
 466     if (view->refCount < 1) {
 467         destroyView(view);
 468     }
 469 }
 470
 471
 472
 473 void
 474 W_MoveView(W_View *view, int x, int y)
 475 {
 476     assert(view->flags.root==0);
 477
 478     if (view->delegate && view->delegate->willMove) {
 479         (*view->delegate->willMove)(view->delegate, view, &x, &y);
 480     }
 481
 482     if (view->pos.x == x && view->pos.y == y)
 483         return;
 484
 485     if (view->flags.realized) {
 486         XMoveWindow(view->screen->display, view->window, x, y);
 487     }
 488     view->pos.x = x;
 489     view->pos.y = y;
 490
 491     if (view->delegate && view->delegate->didMove) {
 492         (*view->delegate->didMove)(view->delegate, view);
 493     }
 494 }
 495
 496
 497 void
 498 W_ResizeView(W_View *view, unsigned int width, unsigned int height)
 499 {
 500     /*int shrinked;*/
 501
 502     if (view->delegate && view->delegate->willResize) {
 503         (*view->delegate->willResize)(view->delegate, view, &width, &height);
 504     }
 505
 506     assert(width > 0);
 507     assert(height > 0);
 508
 509     if (view->size.width == width && view->size.height == height)
 510         return;
 511
 512     /*shrinked = width < view->size.width || height < view->size.height;*/
 513
 514     if (view->flags.realized) {
 515         XResizeWindow(view->screen->display, view->window, width, height);
 516     }
 517     view->size.width = width;
 518     view->size.height = height;
 519
 520     if (view->delegate && view->delegate->didResize) {
 521         (*view->delegate->didResize)(view->delegate, view);
 522     }
 523
 524     /* // TODO. replace in WINGs code, with the didResize delegate */
 525     if (view->flags.notifySizeChanged)
 526         WMPostNotificationName(WMViewSizeDidChangeNotification, view, NULL);
 527 }
 528
 529
 530 void
 531 W_RedisplayView(W_View *view)
 532 {
 533     XEvent ev;
 534
 535     if (!view->flags.mapped)
 536         return;
 537
 538     ev.xexpose.type = Expose;
 539     ev.xexpose.display = view->screen->display;
 540     ev.xexpose.window = view->window;
 541     ev.xexpose.count = 0;
 542
 543     ev.xexpose.serial = 0;
 544
 545     WMHandleEvent(&ev);
 546 }
 547
 548
 549 void
 550 W_SetViewBackgroundColor(W_View *view, WMColor *color)
 551 {
 552     if (view->backColor)
 553         WMReleaseColor(view->backColor);
 554     view->backColor = WMRetainColor(color);
 555
 556     view->attribFlags |= CWBackPixel;
 557     view->attribs.background_pixel = W_PIXEL(color);
 558     if (view->flags.realized) {
 559         XSetWindowBackground(view->screen->display, view->window,
 560                              W_PIXEL(color));
 561         XClearWindow(view->screen->display, view->window);
 562     }
 563 }
 564
 565
 566 void
 567 W_SetViewCursor(W_View *view, Cursor cursor)
 568 {
 569     view->cursor = cursor;
 570     if (W_VIEW_REALIZED(view)) {
 571         XDefineCursor(W_VIEW_DISPLAY(view), W_VIEW_DRAWABLE(view), cursor);
 572     } else {
 573         view->attribFlags |= CWCursor;
 574         view->attribs.cursor = cursor;
 575     }
 576 }
 577
 578
 579 W_View*
 580 W_FocusedViewOfToplevel(W_View *view)
 581 {
 582     WMScreen *scr = view->screen;
 583     W_FocusInfo *info;
 584
 585     for (info = scr->focusInfo; info!=NULL; info = info->next)
 586         if (view == info->toplevel)
 587             break;
 588
 589     if (!info)
 590         return NULL;
 591
 592     return info->focused;
 593 }
 594
 595
 596 void
 597 W_SetFocusOfTopLevel(W_View *toplevel, W_View *view)
 598 {
 599     WMScreen *scr = toplevel->screen;
 600     XEvent event;
 601     W_FocusInfo *info;
 602
 603     for (info = scr->focusInfo; info!=NULL; info = info->next)
 604         if (toplevel == info->toplevel)
 605             break;
 606
 607     if (!info) {
 608         info = wmalloc(sizeof(W_FocusInfo));
 609         info->toplevel = toplevel;
 610         info->focused = view;
 611         info->next = scr->focusInfo;
 612         scr->focusInfo = info;
 613     } else {
 614         event.xfocus.mode = NotifyNormal;
 615         event.xfocus.detail = NotifyDetailNone;
 616         if (info->focused) {
 617             /* simulate FocusOut event */
 618             event.xfocus.type = FocusOut;
 619             W_DispatchMessage(info->focused, &event);
 620         }
 621         info->focused = view;
 622     }
 623     if (view) {
 624         /* simulate FocusIn event */
 625         event.xfocus.type = FocusIn;
 626         W_DispatchMessage(view, &event);
 627     }
 628 }
 629
 630
 631 void
 632 W_BroadcastMessage(W_View *targetParent, XEvent *event)
 633 {
 634     W_View *target;
 635
 636     target = targetParent->childrenList;
 637     while (target!=NULL) {
 638         W_DispatchMessage(target, event);
 639
 640         target = target->nextSister;
 641     }
 642 }
 643
 644
 645 void
 646 W_DispatchMessage(W_View *target, XEvent *event)
 647 {
 648     if (target->window==None)
 649         return;
 650     event->xclient.window = target->window;
 651     event->xclient.display = target->screen->display;
 652
 653     WMHandleEvent(event);
 654     /*
 655      XSendEvent(target->screen->display, target->window, False,
 656      SubstructureNotifyMask, event);
 657      */
 658 }
 659
 660
 661
 662 WMView*
 663 W_RetainView(WMView *view)
 664 {
 665     view->refCount++;
 666
 667     return view;
 668 }
 669
 670
 671 void
 672 W_ReleaseView(WMView *view)
 673 {
 674     view->refCount--;
 675
 676     if (view->refCount < 1) {
 677         destroyView(view);
 678     }
 679 }
 680
 681
 682 WMWidget*
 683 WMWidgetOfView(WMView *view)
 684 {
 685     return view->self;
 686 }
 687
 688
 689 WMSize
 690 WMGetViewSize(WMView *view)
 691 {
 692     return view->size;
 693 }
 694
 695 WMPoint
 696 WMGetViewPosition(WMView *view)
 697 {
 698     return view->pos;
 699 }
 700
 701
 702 void
 703 WMSetViewNotifySizeChanges(WMView *view, Bool flag)
 704 {
 705     view->flags.notifySizeChanged = ((flag==0) ? 0 : 1);
 706 }
 707
 708
 709 Window
 710 WMViewXID(WMView *view)
 711 {
 712     return view->window;
 713 }
 714
 715
 716 WMPoint
 717 WMGetViewScreenPosition(WMView *view)
 718 {
 719     WMScreen *scr = W_VIEW_SCREEN(view);
 720     Window foo;
 721     int x, y, topX, topY;
 722     unsigned int bar;
 723     WMView *topView;
 724
 725     topView = view;
 726     while (topView->parent && topView->parent!=scr->rootView)
 727         topView = topView->parent;
 728
 729     if (!XGetGeometry(scr->display, W_VIEW_DRAWABLE(topView), &foo, &topX,
 730                       &topY, &bar, &bar, &bar, &bar)) {
 731         topX = topY = 0;
 732     }
 733
 734     XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(view),
 735                           scr->rootWin, 0, 0, &x, &y, &foo);
 736
 737     return wmkpoint(x-topX, y-topY);
 738 }
 739
 740
 741 static void
 742 resizedParent(void *self, WMNotification *notif)
 743 {
 744     WMSize size = WMGetViewSize((WMView*)WMGetNotificationObject(notif));
 745     WMView *view = (WMView*)self;
 746
 747     W_MoveView(view, view->leftOffs, view->topOffs);
 748     W_ResizeView(view, size.width - (view->leftOffs + view->rightOffs),
 749                  size.height - (view->topOffs + view->bottomOffs));
 750 }
 751
 752
 753 void
 754 WMSetViewExpandsToParent(WMView *view, int leftOffs, int topOffs,
 755                          int rightOffs, int bottomOffs)
 756 {
 757     WMSize size = view->parent->size;
 758
 759     view->topOffs = topOffs;
 760     view->bottomOffs = bottomOffs;
 761     view->leftOffs = leftOffs;
 762     view->rightOffs = rightOffs;
 763
 764     WMAddNotificationObserver(resizedParent, view,
 765                               WMViewSizeDidChangeNotification,
 766                               view->parent);
 767     WMSetViewNotifySizeChanges(view->parent, True);
 768
 769     W_MoveView(view, leftOffs, topOffs);
 770     W_ResizeView(view, size.width - (leftOffs + rightOffs),
 771                  size.height - (topOffs + bottomOffs));
 772 }
 773
 774