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