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