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