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