WINGs/wview.c

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