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->refCount = 1;
 117
 118     view->screen = screen;
 119
 120     if (parent!=NULL) {
 121         /* attributes are not valid for root window */
 122         view->attribFlags = CWEventMask|CWBitGravity;
 123         view->attribs = defAtts;
 124
 125         view->attribFlags |= CWBackPixel|CWColormap|CWBorderPixel;
 126         view->attribs.background_pixel = W_PIXEL(screen->gray);
 127         view->attribs.border_pixel = W_PIXEL(screen->black);
 128         view->attribs.colormap = screen->colormap;
 129
 130         view->backColor = WMRetainColor(screen->gray);
 131
 132         adoptChildView(parent, view);
 133     }
 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
 186 void
 187 W_RealizeView(W_View *view)
 188 {
 189     Window parentWID;
 190     Display *dpy = view->screen->display;
 191     W_View *ptr;
 192
 193     assert(view->size.width > 0);
 194     assert(view->size.height > 0);
 195
 196
 197     if (view->parent && !view->parent->flags.realized) {
 198         wwarning("trying to realize widget of unrealized parent");
 199         return;
 200     }
 201
 202     if (!view->flags.realized) {
 203         parentWID = view->parent->window;
 204         view->window = XCreateWindow(dpy, parentWID, view->pos.x, view->pos.y,
 205                                      view->size.width, view->size.height, 0,
 206                                      view->screen->depth, InputOutput,
 207                                      view->screen->visual, view->attribFlags,
 208                                      &view->attribs);
 209
 210         XSaveContext(dpy, view->window, ViewContext, (XPointer)view);
 211
 212         view->flags.realized = 1;
 213
 214         if (view->flags.mapWhenRealized) {
 215             W_MapView(view);
 216             view->flags.mapWhenRealized = 0;
 217         }
 218
 219         WMPostNotificationName(WMViewRealizedNotification, view, NULL);
 220     }
 221
 222     /* realize children */
 223     ptr = view->childrenList;
 224     while (ptr!=NULL) {
 225         W_RealizeView(ptr);
 226
 227         ptr = ptr->nextSister;
 228     }
 229 }
 230
 231
 232 void
 233 W_ReparentView(W_View *view, W_View *newParent, int x, int y)
 234 {
 235     Display *dpy = view->screen->display;
 236
 237     assert(!view->flags.topLevel);
 238
 239     unparentView(view);
 240     adoptChildView(newParent, view);
 241
 242     if (view->flags.realized) {
 243         if (newParent->flags.realized) {
 244             XReparentWindow(dpy, view->window, newParent->window, x, y);
 245         } else {
 246             wwarning("trying to reparent realized view to unrealized parent");
 247             return;
 248         }
 249     }
 250
 251     view->pos.x = x;
 252     view->pos.y = y;
 253 }
 254
 255
 256
 257 void
 258 W_MapView(W_View *view)
 259 {
 260     if (!view->flags.mapped) {
 261         if (view->flags.realized) {
 262             XMapRaised(view->screen->display, view->window);
 263             XFlush(view->screen->display);
 264             view->flags.mapped = 1;
 265         } else {
 266             view->flags.mapWhenRealized = 1;
 267         }
 268     }
 269 }
 270
 271
 272 /*
 273  * W_MapSubviews-
 274  *     maps all children of the current view that where already realized.
 275  */
 276 void
 277 W_MapSubviews(W_View *view)
 278 {
 279     XMapSubwindows(view->screen->display, view->window);
 280     XFlush(view->screen->display);
 281
 282     view = view->childrenList;
 283     while (view) {
 284         view->flags.mapped = 1;
 285         view->flags.mapWhenRealized = 0;
 286         view = view->nextSister;
 287     }
 288 }
 289
 290
 291
 292 void
 293 W_UnmapSubviews(W_View *view)
 294 {
 295     XUnmapSubwindows(view->screen->display, view->window);
 296     XFlush(view->screen->display);
 297
 298     view = view->childrenList;
 299     while (view) {
 300         view->flags.mapped = 0;
 301         view->flags.mapWhenRealized = 0;
 302         view = view->nextSister;
 303     }
 304 }
 305
 306
 307
 308 void
 309 W_UnmapView(W_View *view)
 310 {
 311     view->flags.mapWhenRealized = 0;
 312     if (!view->flags.mapped)
 313         return;
 314
 315     XUnmapWindow(view->screen->display, view->window);
 316     XFlush(view->screen->display);
 317
 318     view->flags.mapped = 0;
 319 }
 320
 321
 322 W_View*
 323 W_TopLevelOfView(W_View *view)
 324 {
 325     W_View *toplevel;
 326
 327     for (toplevel=view; !toplevel->flags.topLevel; toplevel=toplevel->parent);
 328
 329     return toplevel;
 330 }
 331
 332
 333 static void
 334 destroyView(W_View *view)
 335 {
 336     W_View *ptr;
 337
 338     if (view->flags.alreadyDead)
 339         return;
 340     view->flags.alreadyDead = 1;
 341
 342     /* delete the balloon text for the view, if there's any */
 343     WMSetBalloonTextForView(NULL, view);
 344
 345     if (view->nextFocusChain)
 346         view->nextFocusChain->prevFocusChain = view->prevFocusChain;
 347     if (view->prevFocusChain)
 348         view->prevFocusChain->nextFocusChain = view->nextFocusChain;
 349
 350     /* Do not leave focus in a inexisting control */
 351     if (W_FocusedViewOfToplevel(W_TopLevelOfView(view))==view)
 352         W_SetFocusOfTopLevel(W_TopLevelOfView(view), NULL);
 353
 354     if (view->flags.topLevel) {
 355         W_FocusInfo *info = view->screen->focusInfo;
 356         /* remove focus information associated to this toplevel */
 357
 358         if (info) {
 359             if (info->toplevel==view) {
 360                 view->screen->focusInfo = info->next;
 361                 wfree(info);
 362             } else {
 363                 while (info->next) {
 364                     if (info->next->toplevel == view)
 365                         break;
 366                     info = info->next;
 367                 }
 368                 if (info->next) {
 369                     W_FocusInfo *next = info->next->next;
 370                     wfree(info->next);
 371                     info->next = next;
 372                 }
 373                 /* else the toplevel did not have any focused subview */
 374             }
 375         }
 376     }
 377
 378     /* destroy children recursively */
 379     while (view->childrenList!=NULL) {
 380         ptr = view->childrenList;
 381         ptr->flags.parentDying = 1;
 382
 383         W_DestroyView(ptr);
 384
 385         if (ptr == view->childrenList) {
 386             view->childrenList = ptr->nextSister;
 387             ptr->parent = NULL;
 388         }
 389     }
 390
 391     W_CallDestroyHandlers(view);
 392
 393     if (view->flags.realized) {
 394         XDeleteContext(view->screen->display, view->window, ViewContext);
 395
 396         /* if parent is being destroyed, it will die naturaly */
 397         if (!view->flags.parentDying || view->flags.topLevel)
 398             XDestroyWindow(view->screen->display, view->window);
 399     }
 400
 401     /* remove self from parent's children list */
 402     unparentView(view);
 403
 404     W_CleanUpEvents(view);
 405
 406  //   WMUnregisterViewDraggedTypes(view);
 407
 408 #if 0
 409     if (view->dragSourceProcs)
 410         wfree(view->dragSourceProcs);
 411
 412     if (view->dragDestinationProcs)
 413         wfree(view->dragDestinationProcs);
 414 #endif
 415     wfree(view);
 416 }
 417
 418
 419
 420 void
 421 W_DestroyView(W_View *view)
 422 {
 423     W_ReleaseView(view);
 424 }
 425
 426
 427
 428 void
 429 W_MoveView(W_View *view, int x, int y)
 430 {
 431     assert(view->flags.root==0);
 432
 433     if (view->delegate && view->delegate->willMove) {
 434         (*view->delegate->willMove)(view->delegate, view, &x, &y);
 435     }
 436
 437     if (view->pos.x == x && view->pos.y == y)
 438         return;
 439
 440     if (view->flags.realized) {
 441         XMoveWindow(view->screen->display, view->window, x, y);
 442     }
 443     view->pos.x = x;
 444     view->pos.y = y;
 445
 446     if (view->delegate && view->delegate->didMove) {
 447         (*view->delegate->didMove)(view->delegate, view);
 448     }
 449 }
 450
 451
 452 void
 453 W_ResizeView(W_View *view, unsigned int width, unsigned int height)
 454 {
 455     int shrinked;
 456
 457     if (view->delegate && view->delegate->willResize) {
 458         (*view->delegate->willResize)(view->delegate, view, &width, &height);
 459     }
 460
 461     assert(width > 0);
 462     assert(height > 0);
 463
 464     if (view->size.width == width && view->size.height == height)
 465         return;
 466
 467     shrinked = width < view->size.width || height < view->size.height;
 468
 469     if (view->flags.realized) {
 470         XResizeWindow(view->screen->display, view->window, width, height);
 471     }
 472     view->size.width = width;
 473     view->size.height = height;
 474
 475     if (view->delegate && view->delegate->didResize) {
 476         (*view->delegate->didResize)(view->delegate, view);
 477     }
 478
 479     if (view->flags.notifySizeChanged)
 480         WMPostNotificationName(WMViewSizeDidChangeNotification, view, NULL);
 481 }
 482
 483
 484 void
 485 W_RedisplayView(W_View *view)
 486 {
 487     XEvent ev;
 488
 489     if (!view->flags.mapped)
 490         return;
 491
 492     ev.xexpose.type = Expose;
 493     ev.xexpose.display = view->screen->display;
 494     ev.xexpose.window = view->window;
 495     ev.xexpose.count = 0;
 496
 497     WMHandleEvent(&ev);
 498 }
 499
 500
 501 void
 502 W_SetViewBackgroundColor(W_View *view, WMColor *color)
 503 {
 504     if (view->backColor)
 505         WMReleaseColor(view->backColor);
 506     view->backColor = WMRetainColor(color);
 507
 508     view->attribFlags |= CWBackPixel;
 509     view->attribs.background_pixel = color->color.pixel;
 510     if (view->flags.realized) {
 511         XSetWindowBackground(view->screen->display, view->window,
 512                              color->color.pixel);
 513         XClearWindow(view->screen->display, view->window);
 514     }
 515 }
 516
 517
 518
 519 W_View*
 520 W_FocusedViewOfToplevel(W_View *view)
 521 {
 522     WMScreen *scr = view->screen;
 523     W_FocusInfo *info;
 524
 525     for (info = scr->focusInfo; info!=NULL; info = info->next)
 526         if (view == info->toplevel)
 527             break;
 528
 529     if (!info)
 530         return NULL;
 531
 532     return info->focused;
 533 }
 534
 535
 536 void
 537 W_SetFocusOfTopLevel(W_View *toplevel, W_View *view)
 538 {
 539     WMScreen *scr = toplevel->screen;
 540     XEvent event;
 541     W_FocusInfo *info;
 542
 543     for (info = scr->focusInfo; info!=NULL; info = info->next)
 544         if (toplevel == info->toplevel)
 545             break;
 546
 547     if (!info) {
 548         info = wmalloc(sizeof(W_FocusInfo));
 549         info->toplevel = toplevel;
 550         info->focused = view;
 551         info->next = scr->focusInfo;
 552         scr->focusInfo = info;
 553     } else {
 554         event.xfocus.mode = NotifyNormal;
 555         event.xfocus.detail = NotifyDetailNone;
 556         if (info->focused) {
 557             /* simulate FocusOut event */
 558             event.xfocus.type = FocusOut;
 559             W_DispatchMessage(info->focused, &event);
 560         }
 561         info->focused = view;
 562     }
 563     if (view) {
 564         /* simulate FocusIn event */
 565         event.xfocus.type = FocusIn;
 566         W_DispatchMessage(view, &event);
 567     }
 568 }
 569
 570
 571 void
 572 W_BroadcastMessage(W_View *targetParent, XEvent *event)
 573 {
 574     W_View *target;
 575
 576     target = targetParent->childrenList;
 577     while (target!=NULL) {
 578         W_DispatchMessage(target, event);
 579
 580         target = target->nextSister;
 581     }
 582 }
 583
 584
 585 void
 586 W_DispatchMessage(W_View *target, XEvent *event)
 587 {
 588     if (target->window==None)
 589         return;
 590     event->xclient.window = target->window;
 591     event->xclient.display = target->screen->display;
 592
 593     WMHandleEvent(event);
 594     /*
 595     XSendEvent(target->screen->display, target->window, False,
 596                SubstructureNotifyMask, event);
 597      */
 598 }
 599
 600
 601
 602 WMView*
 603 W_RetainView(WMView *view)
 604 {
 605     view->refCount++;
 606     return view;
 607 }
 608
 609
 610
 611 void
 612 W_ReleaseView(WMView *view)
 613 {
 614     view->refCount--;
 615     if (view->refCount < 1) {
 616         destroyView(view);
 617     }
 618 }
 619
 620
 621 WMWidget*
 622 WMWidgetOfView(WMView *view)
 623 {
 624     return view->self;
 625 }
 626
 627
 628 WMSize
 629 WMGetViewSize(WMView *view)
 630 {
 631     return view->size;
 632 }
 633
 634 WMPoint
 635 WMGetViewPosition(WMView *view)
 636 {
 637     return view->pos;
 638 }
 639
 640
 641 void
 642 WMSetViewNotifySizeChanges(WMView *view, Bool flag)
 643 {
 644     view->flags.notifySizeChanged = flag;
 645 }
 646
 647 Window
 648 WMViewXID(WMView *view)
 649 {
 650     return view->window;
 651 }
 652
 653
 654 WMPoint
 655 WMGetViewScreenPosition(WMView *view)
 656 {
 657     WMScreen *scr = W_VIEW_SCREEN(view);
 658     Window foo;
 659     int x, y;
 660
 661     XTranslateCoordinates(scr->display, W_VIEW_DRAWABLE(view),
 662                           scr->rootWin, 0, 0, &x, &y, &foo);
 663
 664     return wmkpoint(x, y);
 665 }
 666
 667
 668