WINGs/wbutton.c

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