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