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, const 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 const char *WMGetButtonText(WMButton *bPtr)
 329 {
 330         return bPtr->caption;
 331 }
 332
 333 void WMSetButtonAltText(WMButton * bPtr, const char *text)
 334 {
 335         if (bPtr->altCaption)
 336                 wfree(bPtr->altCaption);
 337
 338         if (text != NULL) {
 339                 bPtr->altCaption = wstrdup(text);
 340         } else {
 341                 bPtr->altCaption = NULL;
 342         }
 343
 344         if (bPtr->view->flags.realized) {
 345                 paintButton(bPtr);
 346         }
 347 }
 348
 349 void WMSetButtonTextColor(WMButton * bPtr, WMColor * color)
 350 {
 351         if (bPtr->textColor)
 352                 WMReleaseColor(bPtr->textColor);
 353
 354         bPtr->textColor = WMRetainColor(color);
 355 }
 356
 357 void WMSetButtonAltTextColor(WMButton * bPtr, WMColor * color)
 358 {
 359         if (bPtr->altTextColor)
 360                 WMReleaseColor(bPtr->altTextColor);
 361
 362         bPtr->altTextColor = WMRetainColor(color);
 363 }
 364
 365 void WMSetButtonDisabledTextColor(WMButton * bPtr, WMColor * color)
 366 {
 367         if (bPtr->disTextColor)
 368                 WMReleaseColor(bPtr->disTextColor);
 369
 370         bPtr->disTextColor = WMRetainColor(color);
 371 }
 372
 373 void WMSetButtonSelected(WMButton * bPtr, int isSelected)
 374 {
 375         bPtr->flags.selected = isSelected ? 1 : 0;
 376
 377         if (bPtr->view->flags.realized) {
 378                 paintButton(bPtr);
 379         }
 380         if (bPtr->groupIndex > 0)
 381                 WMPostNotificationName(WMPushedRadioNotification, bPtr, NULL);
 382 }
 383
 384 int WMGetButtonSelected(WMButton * bPtr)
 385 {
 386         CHECK_CLASS(bPtr, WC_Button);
 387
 388         return bPtr->flags.selected;
 389 }
 390
 391 void WMSetButtonBordered(WMButton * bPtr, int isBordered)
 392 {
 393         bPtr->flags.bordered = isBordered;
 394
 395         if (bPtr->view->flags.realized) {
 396                 paintButton(bPtr);
 397         }
 398 }
 399
 400 void WMSetButtonFont(WMButton * bPtr, WMFont * font)
 401 {
 402         if (bPtr->font)
 403                 WMReleaseFont(bPtr->font);
 404
 405         bPtr->font = WMRetainFont(font);
 406 }
 407
 408 void WMSetButtonEnabled(WMButton * bPtr, Bool flag)
 409 {
 410         bPtr->flags.enabled = ((flag == 0) ? 0 : 1);
 411
 412         if (bPtr->view->flags.mapped) {
 413                 paintButton(bPtr);
 414         }
 415 }
 416
 417 int WMGetButtonEnabled(WMButton * bPtr)
 418 {
 419         CHECK_CLASS(bPtr, WC_Button);
 420
 421         return bPtr->flags.enabled;
 422 }
 423
 424 void WMSetButtonImageDimsWhenDisabled(WMButton * bPtr, Bool flag)
 425 {
 426         bPtr->flags.dimsWhenDisabled = ((flag == 0) ? 0 : 1);
 427
 428         updateDisabledMask(bPtr);
 429 }
 430
 431 void WMSetButtonTag(WMButton * bPtr, int tag)
 432 {
 433         bPtr->tag = tag;
 434 }
 435
 436 void WMPerformButtonClick(WMButton * bPtr)
 437 {
 438         CHECK_CLASS(bPtr, WC_Button);
 439
 440         if (!bPtr->flags.enabled)
 441                 return;
 442
 443         bPtr->flags.pushed = 1;
 444         bPtr->flags.selected = 1;
 445
 446         if (bPtr->view->flags.mapped) {
 447                 paintButton(bPtr);
 448                 XFlush(WMScreenDisplay(WMWidgetScreen(bPtr)));
 449                 wusleep(20000);
 450         }
 451
 452         bPtr->flags.pushed = 0;
 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         if (bPtr->view->flags.mapped)
 462                 paintButton(bPtr);
 463 }
 464
 465 void WMSetButtonAction(WMButton * bPtr, WMAction * action, void *clientData)
 466 {
 467         CHECK_CLASS(bPtr, WC_Button);
 468
 469         bPtr->action = action;
 470
 471         bPtr->clientData = clientData;
 472 }
 473
 474 static void radioPushObserver(void *observerData, WMNotification * notification)
 475 {
 476         WMButton *bPtr = (WMButton *) observerData;
 477         WMButton *pushedButton = (WMButton *) WMGetNotificationObject(notification);
 478
 479         if (bPtr != pushedButton && pushedButton->groupIndex == bPtr->groupIndex && bPtr->groupIndex != 0) {
 480                 if (bPtr->flags.selected) {
 481                         bPtr->flags.selected = 0;
 482                         paintButton(bPtr);
 483                 }
 484         }
 485 }
 486
 487 void WMGroupButtons(WMButton * bPtr, WMButton * newMember)
 488 {
 489         static int tagIndex = 0;
 490
 491         CHECK_CLASS(bPtr, WC_Button);
 492         CHECK_CLASS(newMember, WC_Button);
 493
 494         if (!bPtr->flags.addedObserver) {
 495                 WMAddNotificationObserver(radioPushObserver, bPtr, WMPushedRadioNotification, NULL);
 496                 bPtr->flags.addedObserver = 1;
 497         }
 498         if (!newMember->flags.addedObserver) {
 499                 WMAddNotificationObserver(radioPushObserver, newMember, WMPushedRadioNotification, NULL);
 500                 newMember->flags.addedObserver = 1;
 501         }
 502
 503         if (bPtr->groupIndex == 0) {
 504                 bPtr->groupIndex = ++tagIndex;
 505         }
 506         newMember->groupIndex = bPtr->groupIndex;
 507 }
 508
 509 void WMSetButtonContinuous(WMButton * bPtr, Bool flag)
 510 {
 511         bPtr->flags.continuous = ((flag == 0) ? 0 : 1);
 512         if (bPtr->timer) {
 513                 WMDeleteTimerHandler(bPtr->timer);
 514                 bPtr->timer = NULL;
 515         }
 516 }
 517
 518 void WMSetButtonPeriodicDelay(WMButton * bPtr, float delay, float interval)
 519 {
 520         bPtr->periodicInterval = interval;
 521         bPtr->periodicDelay = delay;
 522 }
 523
 524 static void paintButton(Button * bPtr)
 525 {
 526         W_Screen *scrPtr = bPtr->view->screen;
 527         WMReliefType relief;
 528         int offset;
 529         char *caption;
 530         WMPixmap *image;
 531         WMColor *textColor;
 532         WMColor *backColor;
 533
 534         backColor = NULL;
 535         caption = bPtr->caption;
 536
 537         if (bPtr->flags.enabled) {
 538                 textColor = (bPtr->textColor != NULL ? bPtr->textColor : scrPtr->black);
 539         } else {
 540                 textColor = (bPtr->disTextColor != NULL ? bPtr->disTextColor : scrPtr->darkGray);
 541         }
 542
 543         if (bPtr->flags.enabled || !bPtr->dimage)
 544                 image = bPtr->image;
 545         else
 546                 image = bPtr->dimage;
 547         offset = 0;
 548         if (bPtr->flags.bordered)
 549                 relief = WRRaised;
 550         else
 551                 relief = WRFlat;
 552
 553         if (bPtr->flags.selected) {
 554                 if (bPtr->flags.stateLight) {
 555                         backColor = scrPtr->white;
 556                         textColor = scrPtr->black;
 557                 }
 558
 559                 if (bPtr->flags.stateChange) {
 560                         if (bPtr->altCaption)
 561                                 caption = bPtr->altCaption;
 562                         if (bPtr->altImage)
 563                                 image = bPtr->altImage;
 564                         if (bPtr->altTextColor)
 565                                 textColor = bPtr->altTextColor;
 566                 }
 567
 568                 if (bPtr->flags.statePush && bPtr->flags.bordered) {
 569                         relief = WRSunken;
 570                         offset = 1;
 571                 }
 572         }
 573
 574         if (bPtr->flags.pushed) {
 575                 if (bPtr->flags.pushIn) {
 576                         relief = WRPushed;
 577                         offset = 1;
 578                 }
 579                 if (bPtr->flags.pushLight) {
 580                         backColor = scrPtr->white;
 581                         textColor = scrPtr->black;
 582                 }
 583
 584                 if (bPtr->flags.pushChange) {
 585                         if (bPtr->altCaption)
 586                                 caption = bPtr->altCaption;
 587                         if (bPtr->altImage)
 588                                 image = bPtr->altImage;
 589                         if (bPtr->altTextColor)
 590                                 textColor = bPtr->altTextColor;
 591                 }
 592         }
 593
 594         W_PaintTextAndImage(bPtr->view, True, textColor,
 595                             (bPtr->font != NULL ? bPtr->font : scrPtr->normalFont),
 596                             relief, caption, bPtr->flags.alignment, image,
 597                             bPtr->flags.imagePosition, backColor, offset);
 598 }
 599
 600 static void handleEvents(XEvent * event, void *data)
 601 {
 602         Button *bPtr = (Button *) data;
 603
 604         CHECK_CLASS(data, WC_Button);
 605
 606         switch (event->type) {
 607         case Expose:
 608                 if (event->xexpose.count != 0)
 609                         break;
 610                 paintButton(bPtr);
 611                 break;
 612
 613         case DestroyNotify:
 614                 destroyButton(bPtr);
 615                 break;
 616         }
 617 }
 618
 619 static void autoRepeat(void *data)
 620 {
 621         Button *bPtr = (Button *) data;
 622
 623         if (bPtr->action && bPtr->flags.pushed)
 624                 (*bPtr->action) (bPtr, bPtr->clientData);
 625
 626         bPtr->timer = WMAddTimerHandler((int)(bPtr->periodicInterval * 1000), autoRepeat, bPtr);
 627 }
 628
 629 static void handleActionEvents(XEvent * event, void *data)
 630 {
 631         Button *bPtr = (Button *) data;
 632         int doclick = 0, dopaint = 0;
 633
 634         CHECK_CLASS(data, WC_Button);
 635
 636         if (!bPtr->flags.enabled)
 637                 return;
 638
 639         switch (event->type) {
 640         case EnterNotify:
 641                 if (bPtr->groupIndex == 0) {
 642                         bPtr->flags.pushed = bPtr->flags.wasPushed;
 643                         if (bPtr->flags.pushed) {
 644                                 bPtr->flags.selected = !bPtr->flags.prevSelected;
 645                                 dopaint = 1;
 646                         }
 647                 }
 648                 break;
 649
 650         case LeaveNotify:
 651                 if (bPtr->groupIndex == 0) {
 652                         bPtr->flags.wasPushed = bPtr->flags.pushed;
 653                         if (bPtr->flags.pushed) {
 654                                 bPtr->flags.selected = bPtr->flags.prevSelected;
 655                                 dopaint = 1;
 656                         }
 657                         bPtr->flags.pushed = 0;
 658                 }
 659                 break;
 660
 661         case ButtonPress:
 662                 if (event->xbutton.button == Button1) {
 663                         bPtr->flags.prevSelected = bPtr->flags.selected;
 664                         bPtr->flags.wasPushed = 0;
 665                         bPtr->flags.pushed = 1;
 666                         if (bPtr->groupIndex > 0) {
 667                                 bPtr->flags.selected = 1;
 668                                 dopaint = 1;
 669                                 break;
 670                         }
 671                         bPtr->flags.selected = !bPtr->flags.selected;
 672                         dopaint = 1;
 673
 674                         if (bPtr->flags.continuous && !bPtr->timer) {
 675                                 bPtr->timer = WMAddTimerHandler((int)(bPtr->periodicDelay * 1000),
 676                                                                 autoRepeat, bPtr);
 677                         }
 678                 }
 679                 break;
 680
 681         case ButtonRelease:
 682                 if (event->xbutton.button == Button1) {
 683                         if (bPtr->flags.pushed) {
 684                                 if (bPtr->groupIndex == 0 || (bPtr->flags.selected && bPtr->groupIndex > 0))
 685                                         doclick = 1;
 686                                 dopaint = 1;
 687                                 if (bPtr->flags.springLoaded) {
 688                                         bPtr->flags.selected = bPtr->flags.prevSelected;
 689                                 }
 690                         }
 691                         bPtr->flags.pushed = 0;
 692                 }
 693                 if (bPtr->timer) {
 694                         WMDeleteTimerHandler(bPtr->timer);
 695                         bPtr->timer = NULL;
 696                 }
 697                 break;
 698         }
 699
 700         if (dopaint)
 701                 paintButton(bPtr);
 702
 703         if (doclick) {
 704                 if (bPtr->flags.selected && bPtr->groupIndex > 0) {
 705                         WMPostNotificationName(WMPushedRadioNotification, bPtr, NULL);
 706                 }
 707
 708                 if (bPtr->action)
 709                         (*bPtr->action) (bPtr, bPtr->clientData);
 710         }
 711 }
 712
 713 static void destroyButton(Button * bPtr)
 714 {
 715         if (bPtr->flags.addedObserver) {
 716                 WMRemoveNotificationObserver(bPtr);
 717         }
 718
 719         if (bPtr->timer)
 720                 WMDeleteTimerHandler(bPtr->timer);
 721
 722         if (bPtr->font)
 723                 WMReleaseFont(bPtr->font);
 724
 725         if (bPtr->caption)
 726                 wfree(bPtr->caption);
 727
 728         if (bPtr->altCaption)
 729                 wfree(bPtr->altCaption);
 730
 731         if (bPtr->textColor)
 732                 WMReleaseColor(bPtr->textColor);
 733
 734         if (bPtr->altTextColor)
 735                 WMReleaseColor(bPtr->altTextColor);
 736
 737         if (bPtr->disTextColor)
 738                 WMReleaseColor(bPtr->disTextColor);
 739
 740         if (bPtr->image)
 741                 WMReleasePixmap(bPtr->image);
 742
 743         if (bPtr->dimage) {
 744                 /* yuck.. kluge */
 745                 bPtr->dimage->pixmap = None;
 746
 747                 WMReleasePixmap(bPtr->dimage);
 748         }
 749         if (bPtr->altImage)
 750                 WMReleasePixmap(bPtr->altImage);
 751
 752         wfree(bPtr);
 753 }