WINGs/wbutton.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6
   7 typedef struct W_Button {
   8     W_Class widgetClass;
   9     WMView *view;
  10
  11     char *caption;
  12
  13     char *altCaption;
  14
  15     WMFont *font;
  16
  17     W_Pixmap *image;
  18     W_Pixmap *altImage;
  19
  20     W_Pixmap *dimage;
  21
  22     void *clientData;
  23     WMAction *action;
  24
  25     int tag;
  26
  27     int groupIndex;
  28
  29     float periodicDelay;
  30     float periodicInterval;
  31
  32     WMHandlerID *timer;                /* for continuous mode */
  33
  34     struct {
  35         WMButtonType type:4;
  36         WMImagePosition imagePosition:4;
  37         WMAlignment alignment:2;
  38
  39         unsigned int selected:1;
  40
  41         unsigned int enabled:1;
  42
  43         unsigned int bordered:1;
  44
  45         unsigned int springLoaded:1;
  46
  47         unsigned int pushIn:1;         /* change relief while pushed */
  48
  49         unsigned int pushLight:1;      /* highlight while pushed */
  50
  51         unsigned int pushChange:1;     /* change caption while pushed */
  52
  53         unsigned int stateLight:1;     /* state indicated by highlight */
  54
  55         unsigned int stateChange:1;    /* state indicated by caption change */
  56
  57         unsigned int statePush:1;      /* state indicated by relief */
  58
  59         unsigned int continuous:1;     /* continually perform action */
  60         /* */
  61         unsigned int prevSelected:1;
  62
  63         unsigned int pushed:1;
  64
  65         unsigned int wasPushed:1;
  66
  67         unsigned int redrawPending:1;
  68
  69         unsigned int addedObserver:1;
  70     } flags;
  71 } Button;
  72
  73
  74
  75 #define DEFAULT_BUTTON_WIDTH    60
  76 #define DEFAULT_BUTTON_HEIGHT   24
  77 #define DEFAULT_BUTTON_ALIGNMENT        WACenter
  78 #define DEFAULT_BUTTON_IS_BORDERED      True
  79
  80
  81 #define DEFAULT_RADIO_WIDTH     100
  82 #define DEFAULT_RADIO_HEIGHT    20
  83 #define DEFAULT_RADIO_ALIGNMENT WALeft
  84 #define DEFAULT_RADIO_IMAGE_POSITION    WIPLeft
  85 #define DEFAULT_RADIO_TEXT      "Radio"
  86
  87
  88 #define DEFAULT_SWITCH_WIDTH    100
  89 #define DEFAULT_SWITCH_HEIGHT   20
  90 #define DEFAULT_SWITCH_ALIGNMENT        WALeft
  91 #define DEFAULT_SWITCH_IMAGE_POSITION   WIPLeft
  92 #define DEFAULT_SWITCH_TEXT     "Switch"
  93
  94
  95 static void destroyButton(Button *bPtr);
  96 static void paintButton(Button *bPtr);
  97
  98 static void handleEvents(XEvent *event, void *data);
  99 static void handleActionEvents(XEvent *event, void *data);
 100
 101
 102 static char *WMPushedRadioNotification="WMPushedRadioNotification";
 103
 104
 105 #define NFONT(b) (b)->view->screen->normalFont
 106
 107
 108 WMButton*
 109 WMCreateCustomButton(WMWidget *parent, int behaviourMask)
 110 {
 111     Button *bPtr;
 112
 113     bPtr = wmalloc(sizeof(Button));
 114     memset(bPtr, 0, sizeof(Button));
 115
 116     bPtr->widgetClass = WC_Button;
 117
 118     bPtr->view = W_CreateView(W_VIEW(parent));
 119     if (!bPtr->view) {
 120         wfree(bPtr);
 121         return NULL;
 122     }
 123     bPtr->view->self = bPtr;
 124
 125     bPtr->flags.type = 0;
 126
 127     bPtr->flags.springLoaded = (behaviourMask & WBBSpringLoadedMask)!=0;
 128     bPtr->flags.pushIn = (behaviourMask & WBBPushInMask)!=0;
 129     bPtr->flags.pushChange = (behaviourMask & WBBPushChangeMask)!=0;
 130     bPtr->flags.pushLight = (behaviourMask & WBBPushLightMask)!=0;
 131     bPtr->flags.stateLight = (behaviourMask & WBBStateLightMask)!=0;
 132     bPtr->flags.stateChange = (behaviourMask & WBBStateChangeMask)!=0;
 133     bPtr->flags.statePush = (behaviourMask & WBBStatePushMask)!=0;
 134
 135     W_ResizeView(bPtr->view, DEFAULT_BUTTON_WIDTH, DEFAULT_BUTTON_HEIGHT);
 136     bPtr->flags.alignment = DEFAULT_BUTTON_ALIGNMENT;
 137     bPtr->flags.bordered = DEFAULT_BUTTON_IS_BORDERED;
 138
 139     bPtr->flags.enabled = 1;
 140
 141
 142     WMCreateEventHandler(bPtr->view, ExposureMask|StructureNotifyMask,
 143                          handleEvents, bPtr);
 144
 145     WMCreateEventHandler(bPtr->view, ButtonPressMask|ButtonReleaseMask
 146                          |EnterWindowMask|LeaveWindowMask,
 147                          handleActionEvents, bPtr);
 148
 149     W_ResizeView(bPtr->view, DEFAULT_BUTTON_WIDTH, DEFAULT_BUTTON_HEIGHT);
 150     bPtr->flags.alignment = DEFAULT_BUTTON_ALIGNMENT;
 151     bPtr->flags.bordered = DEFAULT_BUTTON_IS_BORDERED;
 152
 153     return bPtr;
 154 }
 155
 156
 157
 158 WMButton*
 159 WMCreateButton(WMWidget *parent, WMButtonType type)
 160 {
 161     W_Screen *scrPtr = W_VIEW(parent)->screen;
 162     Button *bPtr;
 163
 164     switch (type) {
 165      case WBTMomentaryPush:
 166         bPtr = WMCreateCustomButton(parent, WBBSpringLoadedMask
 167                                     |WBBPushInMask|WBBPushLightMask);
 168         break;
 169
 170      case WBTMomentaryChange:
 171         bPtr = WMCreateCustomButton(parent, WBBSpringLoadedMask
 172                                     |WBBPushChangeMask);
 173         break;
 174
 175      case WBTPushOnPushOff:
 176         bPtr = WMCreateCustomButton(parent, WBBPushInMask|WBBStatePushMask
 177                                     |WBBStateLightMask);
 178         break;
 179
 180      case WBTToggle:
 181         bPtr = WMCreateCustomButton(parent, WBBPushInMask|WBBStateChangeMask
 182                                     |WBBStatePushMask);
 183         break;
 184
 185      case WBTOnOff:
 186         bPtr = WMCreateCustomButton(parent, WBBStateLightMask);
 187         break;
 188
 189      case WBTSwitch:
 190         bPtr = WMCreateCustomButton(parent, WBBStateChangeMask);
 191         bPtr->flags.bordered = 0;
 192         bPtr->image = WMRetainPixmap(scrPtr->checkButtonImageOff);
 193         bPtr->altImage = WMRetainPixmap(scrPtr->checkButtonImageOn);
 194         break;
 195
 196      case WBTRadio:
 197         bPtr = WMCreateCustomButton(parent, WBBStateChangeMask);
 198         bPtr->flags.bordered = 0;
 199         bPtr->image = WMRetainPixmap(scrPtr->radioButtonImageOff);
 200         bPtr->altImage = WMRetainPixmap(scrPtr->radioButtonImageOn);
 201         break;
 202
 203      default:
 204      case WBTMomentaryLight:
 205         bPtr = WMCreateCustomButton(parent, WBBSpringLoadedMask
 206                                     |WBBPushLightMask);
 207         bPtr->flags.bordered = 1;
 208         break;
 209     }
 210
 211     bPtr->flags.type = type;
 212
 213     if (type==WBTRadio) {
 214         W_ResizeView(bPtr->view, DEFAULT_RADIO_WIDTH, DEFAULT_RADIO_HEIGHT);
 215         WMSetButtonText(bPtr, DEFAULT_RADIO_TEXT);
 216         bPtr->flags.alignment = DEFAULT_RADIO_ALIGNMENT;
 217         bPtr->flags.imagePosition = DEFAULT_RADIO_IMAGE_POSITION;
 218     } else if (type==WBTSwitch) {
 219         W_ResizeView(bPtr->view, DEFAULT_SWITCH_WIDTH, DEFAULT_SWITCH_HEIGHT);
 220         WMSetButtonText(bPtr, DEFAULT_SWITCH_TEXT);
 221         bPtr->flags.alignment = DEFAULT_SWITCH_ALIGNMENT;
 222         bPtr->flags.imagePosition = DEFAULT_SWITCH_IMAGE_POSITION;
 223     }
 224
 225     return bPtr;
 226 }
 227
 228
 229 static void
 230 updateDisabledMask(WMButton *bPtr)
 231 {
 232     WMScreen *scr = WMWidgetScreen(bPtr);
 233     Display *dpy = scr->display;
 234
 235     if (bPtr->image) {
 236         XGCValues gcv;
 237
 238         bPtr->dimage->mask = XCreatePixmap(dpy, scr->stipple,
 239                                            bPtr->dimage->width,
 240                                            bPtr->dimage->height, 1);
 241
 242         XSetForeground(dpy, scr->monoGC, 0);
 243         XFillRectangle(dpy, bPtr->dimage->mask, scr->monoGC, 0, 0,
 244                        bPtr->dimage->width, bPtr->dimage->height);
 245
 246         gcv.foreground = 1;
 247         gcv.background = 0;
 248         gcv.stipple = scr->stipple;
 249         gcv.fill_style = FillStippled;
 250         gcv.clip_mask = bPtr->image->mask;
 251         gcv.clip_x_origin = 0;
 252         gcv.clip_y_origin = 0;
 253
 254         XChangeGC(dpy, scr->monoGC, GCForeground|GCBackground|GCStipple
 255                   |GCFillStyle|GCClipMask|GCClipXOrigin|GCClipYOrigin, &gcv);
 256
 257         XFillRectangle(dpy, bPtr->dimage->mask, scr->monoGC, 0, 0,
 258                        bPtr->dimage->width, bPtr->dimage->height);
 259
 260         gcv.fill_style = FillSolid;
 261         gcv.clip_mask = None;
 262         XChangeGC(dpy, scr->monoGC, GCFillStyle|GCClipMask, &gcv);
 263     }
 264 }
 265
 266 void
 267 WMSetButtonImageDefault(WMButton *bPtr)
 268 {
 269     WMSetButtonImage (bPtr, WMWidgetScreen(bPtr)->buttonArrow);
 270     WMSetButtonAltImage (bPtr, WMWidgetScreen(bPtr)->pushedButtonArrow);
 271 }
 272
 273 void
 274 WMSetButtonImage(WMButton *bPtr, WMPixmap *image)
 275 {
 276     if (bPtr->image!=NULL)
 277         WMReleasePixmap(bPtr->image);
 278     bPtr->image = WMRetainPixmap(image);
 279
 280     if (bPtr->dimage) {
 281         bPtr->dimage->pixmap = None;
 282         WMReleasePixmap(bPtr->dimage);
 283         bPtr->dimage = NULL;
 284     }
 285
 286     if (image) {
 287         bPtr->dimage = WMCreatePixmapFromXPixmaps(WMWidgetScreen(bPtr),
 288                                                   image->pixmap, None,
 289                                                   image->width, image->height,
 290                                                   image->depth);
 291         updateDisabledMask(bPtr);
 292     }
 293
 294     if (bPtr->view->flags.realized) {
 295         paintButton(bPtr);
 296     }
 297 }
 298
 299
 300 void
 301 WMSetButtonAltImage(WMButton *bPtr, WMPixmap *image)
 302 {
 303     if (bPtr->altImage!=NULL)
 304         WMReleasePixmap(bPtr->altImage);
 305     bPtr->altImage = WMRetainPixmap(image);
 306
 307
 308     if (bPtr->view->flags.realized) {
 309         paintButton(bPtr);
 310     }
 311 }
 312
 313
 314 void
 315 WMSetButtonImagePosition(WMButton *bPtr, WMImagePosition position)
 316 {
 317     bPtr->flags.imagePosition = position;
 318
 319
 320     if (bPtr->view->flags.realized) {
 321         paintButton(bPtr);
 322     }
 323 }
 324
 325
 326
 327
 328 void
 329 WMSetButtonTextAlignment(WMButton *bPtr, WMAlignment alignment)
 330 {
 331     bPtr->flags.alignment = alignment;
 332
 333
 334     if (bPtr->view->flags.realized) {
 335         paintButton(bPtr);
 336     }
 337 }
 338
 339 void
 340 WMSetButtonText(WMButton *bPtr, char *text)
 341 {
 342     if (bPtr->caption)
 343         wfree(bPtr->caption);
 344
 345     if (text!=NULL) {
 346         bPtr->caption = wstrdup(text);
 347     } else {
 348         bPtr->caption = NULL;
 349     }
 350
 351
 352     if (bPtr->view->flags.realized) {
 353         paintButton(bPtr);
 354     }
 355 }
 356
 357
 358 void
 359 WMSetButtonAltText(WMButton *bPtr, char *text)
 360 {
 361     if (bPtr->altCaption)
 362         wfree(bPtr->altCaption);
 363
 364     if (text!=NULL) {
 365         bPtr->altCaption = wstrdup(text);
 366     } else {
 367         bPtr->altCaption = NULL;
 368     }
 369
 370     if (bPtr->view->flags.realized) {
 371         paintButton(bPtr);
 372     }
 373 }
 374
 375
 376 void
 377 WMSetButtonSelected(WMButton *bPtr, int isSelected)
 378 {
 379     bPtr->flags.selected = isSelected;
 380
 381     if (bPtr->view->flags.realized) {
 382         paintButton(bPtr);
 383     }
 384 }
 385
 386
 387 int
 388 WMGetButtonSelected(WMButton *bPtr)
 389 {
 390     CHECK_CLASS(bPtr, WC_Button);
 391
 392     return bPtr->flags.selected;
 393 }
 394
 395
 396 void
 397 WMSetButtonBordered(WMButton *bPtr, int isBordered)
 398 {
 399     bPtr->flags.bordered = isBordered;
 400
 401     if (bPtr->view->flags.realized) {
 402         paintButton(bPtr);
 403     }
 404 }
 405
 406
 407 void
 408 WMSetButtonFont(WMButton *bPtr, WMFont *font)
 409 {
 410     if (bPtr->font)
 411         WMReleaseFont(bPtr->font);
 412
 413     bPtr->font = WMRetainFont(font);
 414 }
 415
 416
 417 void
 418 WMSetButtonEnabled(WMButton *bPtr, Bool flag)
 419 {
 420     bPtr->flags.enabled = flag;
 421
 422     if (bPtr->view->flags.mapped) {
 423         paintButton(bPtr);
 424     }
 425 }
 426
 427
 428 void
 429 WMSetButtonTag(WMButton *bPtr, int tag)
 430 {
 431     bPtr->tag = tag;
 432 }
 433
 434
 435
 436 void
 437 WMPerformButtonClick(WMButton *bPtr)
 438 {
 439     CHECK_CLASS(bPtr, WC_Button);
 440
 441     if (!bPtr->flags.enabled)
 442         return;
 443
 444     bPtr->flags.pushed = 1;
 445     bPtr->flags.selected = 1;
 446
 447     if (bPtr->view->flags.mapped) {
 448         paintButton(bPtr);
 449         XFlush(WMScreenDisplay(WMWidgetScreen(bPtr)));
 450         wusleep(20000);
 451     }
 452
 453     if (bPtr->groupIndex>0) {
 454         WMPostNotificationName(WMPushedRadioNotification, bPtr, NULL);
 455     }
 456
 457     if (bPtr->action)
 458         (*bPtr->action)(bPtr, bPtr->clientData);
 459
 460     bPtr->flags.pushed = 0;
 461
 462     if (bPtr->view->flags.mapped)
 463         paintButton(bPtr);
 464 }
 465
 466
 467
 468 void
 469 WMSetButtonAction(WMButton *bPtr, WMAction *action, void *clientData)
 470 {
 471     CHECK_CLASS(bPtr, WC_Button);
 472
 473     bPtr->action = action;
 474
 475     bPtr->clientData = clientData;
 476 }
 477
 478
 479
 480
 481 static void
 482 radioPushObserver(void *observerData, WMNotification *notification)
 483 {
 484     WMButton *bPtr = (WMButton*)observerData;
 485     WMButton *pushedButton = (WMButton*)WMGetNotificationObject(notification);
 486
 487     if (bPtr!=pushedButton && pushedButton->groupIndex == bPtr->groupIndex
 488         && bPtr->groupIndex!=0) {
 489         if (bPtr->flags.selected) {
 490             bPtr->flags.selected = 0;
 491             paintButton(bPtr);
 492         }
 493     }
 494 }
 495
 496
 497
 498 void
 499 WMGroupButtons(WMButton *bPtr, WMButton *newMember)
 500 {
 501     static int tagIndex = 0;
 502
 503     CHECK_CLASS(bPtr, WC_Button);
 504     CHECK_CLASS(newMember, WC_Button);
 505
 506     if (!bPtr->flags.addedObserver) {
 507         WMAddNotificationObserver(radioPushObserver, bPtr,
 508                                   WMPushedRadioNotification, NULL);
 509         bPtr->flags.addedObserver = 1;
 510     }
 511     if (!newMember->flags.addedObserver) {
 512         WMAddNotificationObserver(radioPushObserver, newMember,
 513                                   WMPushedRadioNotification, NULL);
 514         newMember->flags.addedObserver = 1;
 515     }
 516
 517     if (bPtr->groupIndex==0) {
 518         bPtr->groupIndex = ++tagIndex;
 519     }
 520     newMember->groupIndex = bPtr->groupIndex;
 521 }
 522
 523
 524 void
 525 WMSetButtonContinuous(WMButton *bPtr, Bool flag)
 526 {
 527     bPtr->flags.continuous = flag;
 528     if (bPtr->timer) {
 529         WMDeleteTimerHandler(bPtr->timer);
 530         bPtr->timer = NULL;
 531     }
 532 }
 533
 534
 535 void
 536 WMSetButtonPeriodicDelay(WMButton *bPtr, float delay, float interval)
 537 {
 538     bPtr->periodicInterval = interval;
 539     bPtr->periodicDelay = delay;
 540 }
 541
 542
 543
 544 static void
 545 paintButton(Button *bPtr)
 546 {
 547     W_Screen *scrPtr = bPtr->view->screen;
 548     GC gc;
 549     WMReliefType relief;
 550     int offset;
 551     char *caption;
 552     WMPixmap *image;
 553     GC textGC;
 554
 555     gc = NULL;
 556     caption = bPtr->caption;
 557     if (bPtr->flags.enabled || !bPtr->dimage)
 558         image = bPtr->image;
 559     else
 560         image = bPtr->dimage;
 561     offset = 0;
 562     if (bPtr->flags.bordered)
 563         relief = WRRaised;
 564     else
 565         relief = WRFlat;
 566
 567     if (bPtr->flags.selected) {
 568         if (bPtr->flags.stateLight)
 569             gc = WMColorGC(scrPtr->white);
 570
 571         if (bPtr->flags.stateChange) {
 572             if (bPtr->altCaption) {
 573                 caption = bPtr->altCaption;
 574             }
 575             if (bPtr->altImage)
 576                 image = bPtr->altImage;
 577         }
 578
 579         if (bPtr->flags.statePush && bPtr->flags.bordered) {
 580             relief = WRSunken;
 581             offset = 1;
 582         }
 583     }
 584
 585     if (bPtr->flags.pushed) {
 586         if (bPtr->flags.pushIn) {
 587             relief = WRPushed;
 588             offset = 1;
 589         }
 590         if (bPtr->flags.pushLight)
 591             gc = WMColorGC(scrPtr->white);
 592
 593         if (bPtr->flags.pushChange) {
 594             if (bPtr->altCaption) {
 595                 caption = bPtr->altCaption;
 596             }
 597             if (bPtr->altImage)
 598                 image = bPtr->altImage;
 599         }
 600     }
 601
 602
 603     if (bPtr->flags.enabled)
 604         textGC = WMColorGC(scrPtr->black);
 605     else
 606         textGC = WMColorGC(scrPtr->darkGray);
 607
 608     W_PaintTextAndImage(bPtr->view, True, textGC,
 609                         (bPtr->font!=NULL ? bPtr->font : scrPtr->normalFont),
 610                         relief, caption, bPtr->flags.alignment, image,
 611                         bPtr->flags.imagePosition, gc, offset);
 612 }
 613
 614
 615
 616 static void
 617 handleEvents(XEvent *event, void *data)
 618 {
 619     Button *bPtr = (Button*)data;
 620
 621     CHECK_CLASS(data, WC_Button);
 622
 623
 624     switch (event->type) {
 625      case Expose:
 626         if (event->xexpose.count!=0)
 627             break;
 628         paintButton(bPtr);
 629         break;
 630
 631      case DestroyNotify:
 632         destroyButton(bPtr);
 633         break;
 634     }
 635 }
 636
 637
 638 static void
 639 autoRepeat(void *data)
 640 {
 641     Button *bPtr = (Button*)data;
 642
 643     if (bPtr->action && bPtr->flags.pushed)
 644         (*bPtr->action)(bPtr, bPtr->clientData);
 645
 646     bPtr->timer = WMAddTimerHandler((int)(bPtr->periodicInterval*1000),
 647                                     autoRepeat, bPtr);
 648 }
 649
 650
 651 static void
 652 handleActionEvents(XEvent *event, void *data)
 653 {
 654     Button *bPtr = (Button*)data;
 655     int doclick = 0, dopaint=0;
 656
 657     CHECK_CLASS(data, WC_Button);
 658
 659     if (!bPtr->flags.enabled)
 660         return;
 661
 662     switch (event->type) {
 663      case EnterNotify:
 664         if (bPtr->groupIndex == 0) {
 665             bPtr->flags.pushed = bPtr->flags.wasPushed;
 666             if (bPtr->flags.pushed) {
 667                 bPtr->flags.selected = !bPtr->flags.prevSelected;
 668                 dopaint = 1;
 669             }
 670         }
 671         break;
 672
 673      case LeaveNotify:
 674         if (bPtr->groupIndex == 0) {
 675             bPtr->flags.wasPushed = bPtr->flags.pushed;
 676             if (bPtr->flags.pushed) {
 677                 bPtr->flags.selected = bPtr->flags.prevSelected;
 678                 dopaint = 1;
 679             }
 680             bPtr->flags.pushed = 0;
 681         }
 682         break;
 683
 684      case ButtonPress:
 685         if (event->xbutton.button == Button1) {
 686             if (bPtr->groupIndex>0) {
 687                 if (!bPtr->flags.selected)
 688                     doclick = 1;
 689                 bPtr->flags.pushed = 1;
 690                 bPtr->flags.selected = 1;
 691                 dopaint = 1;
 692                 break;
 693             }
 694             bPtr->flags.wasPushed = 0;
 695             bPtr->flags.pushed = 1;
 696             bPtr->flags.prevSelected = bPtr->flags.selected;
 697             bPtr->flags.selected = !bPtr->flags.selected;
 698             dopaint = 1;
 699
 700             if (bPtr->flags.continuous && !bPtr->timer) {
 701                 bPtr->timer = WMAddTimerHandler((int)(bPtr->periodicDelay*1000),
 702                                                 autoRepeat, bPtr);
 703             }
 704         }
 705         break;
 706
 707      case ButtonRelease:
 708         if (event->xbutton.button == Button1) {
 709             if (bPtr->flags.pushed) {
 710                 if (bPtr->groupIndex==0)
 711                     doclick = 1;
 712                 dopaint = 1;
 713                 if (bPtr->flags.springLoaded) {
 714                     bPtr->flags.selected = bPtr->flags.prevSelected;
 715                 }
 716             }
 717             bPtr->flags.pushed = 0;
 718         }
 719         if (bPtr->timer) {
 720             WMDeleteTimerHandler(bPtr->timer);
 721             bPtr->timer = NULL;
 722         }
 723         break;
 724     }
 725
 726     if (dopaint)
 727         paintButton(bPtr);
 728
 729     if (doclick) {
 730         if (bPtr->flags.selected && bPtr->groupIndex>0) {
 731             WMPostNotificationName(WMPushedRadioNotification, bPtr, NULL);
 732         }
 733
 734         if (bPtr->action)
 735             (*bPtr->action)(bPtr, bPtr->clientData);
 736     }
 737 }
 738
 739
 740
 741 static void
 742 destroyButton(Button *bPtr)
 743 {
 744     if (bPtr->flags.addedObserver) {
 745         WMRemoveNotificationObserver(bPtr);
 746     }
 747
 748     if (bPtr->timer)
 749         WMDeleteTimerHandler(bPtr->timer);
 750
 751     if (bPtr->font)
 752         WMReleaseFont(bPtr->font);
 753
 754     if (bPtr->caption)
 755         wfree(bPtr->caption);
 756
 757     if (bPtr->altCaption)
 758         wfree(bPtr->altCaption);
 759
 760     if (bPtr->image)
 761         WMReleasePixmap(bPtr->image);
 762
 763     if (bPtr->dimage) {
 764         /* yuck.. kluge */
 765         bPtr->dimage->pixmap = None;
 766
 767         WMReleasePixmap(bPtr->dimage);
 768     }
 769     if (bPtr->altImage)
 770         WMReleasePixmap(bPtr->altImage);
 771
 772     wfree(bPtr);
 773 }
 774
 775