git.sesse.net Git - vlc/blob - modules/gui/beos/TransportButton.cpp

   1 /*****************************************************************************
   2  * TransportButton.cpp
   3  *****************************************************************************
   4  * Copyright (C) 2001 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Tony Castley <tcastley@mail.powerup.com.au>
   8  *          Stephan Aßmus <stippi@yellowbites.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #include <Bitmap.h>
  26 #include <Debug.h>
  27 #include <MessageFilter.h>
  28 #include <Screen.h>
  29 #include <Window.h>
  30
  31 #include <map>
  32
  33 #include "TransportButton.h"
  34 #include "DrawingTidbits.h"
  35
  36 class BitmapStash {
  37 // Bitmap stash is a simple class to hold all the lazily-allocated
  38 // bitmaps that the TransportButton needs when rendering itself.
  39 // signature is a combination of the different enabled, pressed, playing, etc.
  40 // flavors of a bitmap. If the stash does not have a particular bitmap,
  41 // it turns around to ask the button to create one and stores it for next time.
  42 public:
  43     BitmapStash(TransportButton *);
  44     ~BitmapStash();
  45     BBitmap *GetBitmap(uint32 signature);
  46
  47 private:
  48     TransportButton *owner;
  49     map<uint32, BBitmap *> stash;
  50 };
  51
  52 BitmapStash::BitmapStash(TransportButton *owner)
  53     :    owner(owner)
  54 {
  55 }
  56
  57 BBitmap *
  58 BitmapStash::GetBitmap(uint32 signature)
  59 {
  60     if (stash.find(signature) == stash.end()) {
  61         BBitmap *newBits = owner->MakeBitmap(signature);
  62         ASSERT(newBits);
  63         stash[signature] = newBits;
  64     }
  65
  66     return stash[signature];
  67 }
  68
  69 BitmapStash::~BitmapStash()
  70 {
  71     // delete all the bitmaps
  72     for (map<uint32, BBitmap *>::iterator i = stash.begin(); i != stash.end(); i++)
  73         delete (*i).second;
  74 }
  75
  76
  77 class PeriodicMessageSender {
  78     // used to send a specified message repeatedly when holding down a button
  79 public:
  80     static PeriodicMessageSender *Launch(BMessenger target,
  81         const BMessage *message, bigtime_t period);
  82     void Quit();
  83
  84 private:
  85     PeriodicMessageSender(BMessenger target, const BMessage *message,
  86         bigtime_t period);
  87     ~PeriodicMessageSender() {}
  88         // use quit
  89
  90     static status_t TrackBinder(void *);
  91     void Run();
  92
  93     BMessenger target;
  94     BMessage message;
  95
  96     bigtime_t period;
  97
  98     bool requestToQuit;
  99 };
 100
 101
 102 PeriodicMessageSender::PeriodicMessageSender(BMessenger target,
 103     const BMessage *message, bigtime_t period)
 104     :    target(target),
 105         message(*message),
 106         period(period),
 107         requestToQuit(false)
 108 {
 109 }
 110
 111 PeriodicMessageSender *
 112 PeriodicMessageSender::Launch(BMessenger target, const BMessage *message,
 113     bigtime_t period)
 114 {
 115     PeriodicMessageSender *result = new PeriodicMessageSender(target, message, period);
 116     thread_id thread = spawn_thread(&PeriodicMessageSender::TrackBinder,
 117         "ButtonRepeatingThread", B_NORMAL_PRIORITY, result);
 118
 119     if (thread <= 0 || resume_thread(thread) != B_OK) {
 120         // didn't start, don't leak self
 121         delete result;
 122         result = 0;
 123     }
 124
 125     return result;
 126 }
 127
 128 void
 129 PeriodicMessageSender::Quit()
 130 {
 131     requestToQuit = true;
 132 }
 133
 134 status_t
 135 PeriodicMessageSender::TrackBinder(void *castToThis)
 136 {
 137     ((PeriodicMessageSender *)castToThis)->Run();
 138     return 0;
 139 }
 140
 141 void
 142 PeriodicMessageSender::Run()
 143 {
 144     for (;;) {
 145         snooze(period);
 146         if (requestToQuit)
 147             break;
 148         target.SendMessage(&message);
 149     }
 150     delete this;
 151 }
 152
 153 class SkipButtonKeypressFilter : public BMessageFilter {
 154 public:
 155     SkipButtonKeypressFilter(uint32 shortcutKey, uint32 shortcutModifier,
 156         TransportButton *target);
 157
 158 protected:
 159     filter_result Filter(BMessage *message, BHandler **handler);
 160
 161 private:
 162     uint32 shortcutKey;
 163     uint32 shortcutModifier;
 164     TransportButton *target;
 165 };
 166
 167 SkipButtonKeypressFilter::SkipButtonKeypressFilter(uint32 shortcutKey,
 168     uint32 shortcutModifier, TransportButton *target)
 169     :    BMessageFilter(B_ANY_DELIVERY, B_ANY_SOURCE),
 170         shortcutKey(shortcutKey),
 171         shortcutModifier(shortcutModifier),
 172         target(target)
 173 {
 174 }
 175
 176 filter_result
 177 SkipButtonKeypressFilter::Filter(BMessage *message, BHandler **handler)
 178 {
 179     if (target->IsEnabled()
 180         && (message->what == B_KEY_DOWN || message->what == B_KEY_UP)) {
 181         uint32 modifiers;
 182         uint32 rawKeyChar = 0;
 183         uint8 byte = 0;
 184         int32 key = 0;
 185
 186         if (message->FindInt32("modifiers", (int32 *)&modifiers) != B_OK
 187             || message->FindInt32("raw_char", (int32 *)&rawKeyChar) != B_OK
 188             || message->FindInt8("byte", (int8 *)&byte) != B_OK
 189             || message->FindInt32("key", &key) != B_OK)
 190             return B_DISPATCH_MESSAGE;
 191
 192         modifiers &= B_SHIFT_KEY | B_COMMAND_KEY | B_CONTROL_KEY
 193             | B_OPTION_KEY | B_MENU_KEY;
 194             // strip caps lock, etc.
 195
 196         if (modifiers == shortcutModifier && rawKeyChar == shortcutKey) {
 197             if (message->what == B_KEY_DOWN)
 198                 target->ShortcutKeyDown();
 199             else
 200                 target->ShortcutKeyUp();
 201
 202             return B_SKIP_MESSAGE;
 203         }
 204     }
 205
 206     // let others deal with this
 207     return B_DISPATCH_MESSAGE;
 208 }
 209
 210 TransportButton::TransportButton(BRect frame, const char *name,
 211     const unsigned char *normalBits,
 212     const unsigned char *pressedBits,
 213     const unsigned char *disabledBits,
 214     BMessage *invokeMessage, BMessage *startPressingMessage,
 215     BMessage *pressingMessage, BMessage *donePressingMessage, bigtime_t period,
 216     uint32 key, uint32 modifiers, uint32 resizeFlags)
 217     :    BControl(frame, name, "", invokeMessage, resizeFlags, B_WILL_DRAW | B_NAVIGABLE),
 218         bitmaps(new BitmapStash(this)),
 219         normalBits(normalBits),
 220         pressedBits(pressedBits),
 221         disabledBits(disabledBits),
 222         startPressingMessage(startPressingMessage),
 223         pressingMessage(pressingMessage),
 224         donePressingMessage(donePressingMessage),
 225         pressingPeriod(period),
 226         mouseDown(false),
 227         keyDown(false),
 228         messageSender(0),
 229         keyPressFilter(0)
 230 {
 231     if (key)
 232         keyPressFilter = new SkipButtonKeypressFilter(key, modifiers, this);
 233 }
 234
 235
 236 void
 237 TransportButton::AttachedToWindow()
 238 {
 239     _inherited::AttachedToWindow();
 240     if (keyPressFilter)
 241         Window()->AddCommonFilter(keyPressFilter);
 242
 243     // transparent to reduce flicker
 244     SetViewColor(B_TRANSPARENT_COLOR);
 245 }
 246
 247 void
 248 TransportButton::DetachedFromWindow()
 249 {
 250     if (keyPressFilter)
 251         Window()->RemoveCommonFilter(keyPressFilter);
 252     _inherited::DetachedFromWindow();
 253 }
 254
 255
 256 TransportButton::~TransportButton()
 257 {
 258     delete startPressingMessage;
 259     delete pressingMessage;
 260     delete donePressingMessage;
 261     delete bitmaps;
 262     delete keyPressFilter;
 263 }
 264
 265 void
 266 TransportButton::WindowActivated(bool state)
 267 {
 268     if (!state)
 269         ShortcutKeyUp();
 270
 271     _inherited::WindowActivated(state);
 272 }
 273
 274 void
 275 TransportButton::SetEnabled(bool on)
 276 {
 277     if (on != IsEnabled()) {
 278         _inherited::SetEnabled(on);
 279         if (!on)
 280             ShortcutKeyUp();
 281     }
 282 }
 283
 284 const unsigned char *
 285 TransportButton::BitsForMask(uint32 mask) const
 286 {
 287     switch (mask) {
 288         case 0:
 289             return normalBits;
 290         case kDisabledMask:
 291             return disabledBits;
 292         case kPressedMask:
 293             return pressedBits;
 294         default:
 295             break;
 296     }
 297     TRESPASS();
 298     return 0;
 299 }
 300
 301
 302 BBitmap *
 303 TransportButton::MakeBitmap(uint32 mask)
 304 {
 305     BRect r(Bounds());
 306     BBitmap *result = new BBitmap(r, B_CMAP8);
 307
 308     uint8* src = (uint8*)BitsForMask(mask);
 309
 310     if (src && result && result->IsValid()) {
 311         // int32 width = r.IntegerWidth() + 1;
 312         int32 height = r.IntegerHeight() + 1;
 313         int32 bpr = result->BytesPerRow();
 314         uint8* dst = (uint8*)result->Bits();
 315         // copy source bits into bitmap line by line,
 316         // taking possible alignment into account
 317         // since the source data has been generated
 318         // by QuickRes, it still contains aligment too
 319         // (hence skipping bpr and not width bytes)
 320         for (int32 y = 0; y < height; y++) {
 321             memcpy(dst, src, bpr);
 322             src += bpr;
 323             dst += bpr;
 324         }
 325         ReplaceTransparentColor(result, Parent()->ViewColor());
 326     } else {
 327         delete result;
 328         result = NULL;
 329     }
 330
 331     return result;
 332 }
 333
 334 uint32
 335 TransportButton::ModeMask() const
 336 {
 337     return (IsEnabled() ? 0 : kDisabledMask)
 338         | (Value() ? kPressedMask : 0);
 339 }
 340
 341 void
 342 TransportButton::Draw(BRect)
 343 {
 344     DrawBitmapAsync(bitmaps->GetBitmap(ModeMask()));
 345 }
 346
 347
 348 void
 349 TransportButton::StartPressing()
 350 {
 351     SetValue(1);
 352     if (startPressingMessage)
 353         Invoke(startPressingMessage);
 354
 355     if (pressingMessage) {
 356         ASSERT(pressingMessage);
 357         messageSender = PeriodicMessageSender::Launch(Messenger(),
 358             pressingMessage, pressingPeriod);
 359     }
 360 }
 361
 362 void
 363 TransportButton::MouseCancelPressing()
 364 {
 365     if (!mouseDown || keyDown)
 366         return;
 367
 368     mouseDown = false;
 369
 370     if (pressingMessage) {
 371         ASSERT(messageSender);
 372         PeriodicMessageSender *sender = messageSender;
 373         messageSender = 0;
 374         sender->Quit();
 375     }
 376
 377     if (donePressingMessage)
 378         Invoke(donePressingMessage);
 379     SetValue(0);
 380 }
 381
 382 void
 383 TransportButton::DonePressing()
 384 {
 385     if (pressingMessage) {
 386         ASSERT(messageSender);
 387         PeriodicMessageSender *sender = messageSender;
 388         messageSender = 0;
 389         sender->Quit();
 390     }
 391
 392     Invoke();
 393     SetValue(0);
 394 }
 395
 396 void
 397 TransportButton::MouseStartPressing()
 398 {
 399     if (mouseDown)
 400         return;
 401
 402     mouseDown = true;
 403     if (!keyDown)
 404         StartPressing();
 405 }
 406
 407 void
 408 TransportButton::MouseDonePressing()
 409 {
 410     if (!mouseDown)
 411         return;
 412
 413     mouseDown = false;
 414     if (!keyDown)
 415         DonePressing();
 416 }
 417
 418 void
 419 TransportButton::ShortcutKeyDown()
 420 {
 421     if (!IsEnabled())
 422         return;
 423
 424     if (keyDown)
 425         return;
 426
 427     keyDown = true;
 428     if (!mouseDown)
 429         StartPressing();
 430 }
 431
 432 void
 433 TransportButton::ShortcutKeyUp()
 434 {
 435     if (!keyDown)
 436         return;
 437
 438     keyDown = false;
 439     if (!mouseDown)
 440         DonePressing();
 441 }
 442
 443
 444 void
 445 TransportButton::MouseDown(BPoint)
 446 {
 447     if (!IsEnabled())
 448         return;
 449
 450     ASSERT(Window()->Flags() & B_ASYNCHRONOUS_CONTROLS);
 451     SetTracking(true);
 452     SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
 453     MouseStartPressing();
 454 }
 455
 456 void
 457 TransportButton::MouseMoved(BPoint point, uint32 code, const BMessage *)
 458 {
 459     if (IsTracking() && Bounds().Contains(point) != Value()) {
 460         if (!Value())
 461             MouseStartPressing();
 462         else
 463             MouseCancelPressing();
 464     }
 465 }
 466
 467 void
 468 TransportButton::MouseUp(BPoint point)
 469 {
 470     if (IsTracking()) {
 471         if (Bounds().Contains(point))
 472             MouseDonePressing();
 473         else
 474             MouseCancelPressing();
 475         SetTracking(false);
 476     }
 477 }
 478
 479 void
 480 TransportButton::SetStartPressingMessage(BMessage *message)
 481 {
 482     delete startPressingMessage;
 483     startPressingMessage = message;
 484 }
 485
 486 void
 487 TransportButton::SetPressingMessage(BMessage *message)
 488 {
 489     delete pressingMessage;
 490     pressingMessage = message;
 491 }
 492
 493 void
 494 TransportButton::SetDonePressingMessage(BMessage *message)
 495 {
 496     delete donePressingMessage;
 497     donePressingMessage = message;
 498 }
 499
 500 void
 501 TransportButton::SetPressingPeriod(bigtime_t newTime)
 502 {
 503     pressingPeriod = newTime;
 504 }
 505
 506
 507 PlayPauseButton::PlayPauseButton(BRect frame, const char *name,
 508     const unsigned char *normalBits, const unsigned char *pressedBits,
 509     const unsigned char *disabledBits, const unsigned char *normalPlayingBits,
 510     const unsigned char *pressedPlayingBits, const unsigned char *normalPausedBits,
 511     const unsigned char *pressedPausedBits,
 512     BMessage *invokeMessage, uint32 key, uint32 modifiers, uint32 resizeFlags)
 513     :    TransportButton(frame, name, normalBits, pressedBits,
 514             disabledBits, invokeMessage, 0,
 515             0, 0, 0, key, modifiers, resizeFlags),
 516         normalPlayingBits(normalPlayingBits),
 517         pressedPlayingBits(pressedPlayingBits),
 518         normalPausedBits(normalPausedBits),
 519         pressedPausedBits(pressedPausedBits),
 520         state(PlayPauseButton::kStopped),
 521         lastPauseBlinkTime(0),
 522         lastModeMask(0)
 523 {
 524 }
 525
 526 void
 527 PlayPauseButton::SetStopped()
 528 {
 529     if (state == kStopped || state == kAboutToPlay)
 530         return;
 531
 532     state = kStopped;
 533     Invalidate();
 534 }
 535
 536 void
 537 PlayPauseButton::SetPlaying()
 538 {
 539     if (state == kPlaying || state == kAboutToPause)
 540         return;
 541
 542     state = kPlaying;
 543     Invalidate();
 544 }
 545
 546 const bigtime_t kPauseBlinkPeriod = 600000;
 547
 548 void
 549 PlayPauseButton::SetPaused()
 550 {
 551     if (state == kAboutToPlay)
 552         return;
 553
 554     // in paused state blink the LED on and off
 555     bigtime_t now = system_time();
 556     if (state == kPausedLedOn || state == kPausedLedOff) {
 557         if (now - lastPauseBlinkTime < kPauseBlinkPeriod)
 558             return;
 559
 560         if (state == kPausedLedOn)
 561             state = kPausedLedOff;
 562         else
 563             state = kPausedLedOn;
 564     } else
 565         state = kPausedLedOn;
 566
 567     lastPauseBlinkTime = now;
 568     Invalidate();
 569 }
 570
 571 uint32
 572 PlayPauseButton::ModeMask() const
 573 {
 574     if (!IsEnabled())
 575         return kDisabledMask;
 576
 577     uint32 result = 0;
 578
 579     if (Value())
 580         result = kPressedMask;
 581
 582     if (state == kPlaying || state == kAboutToPlay)
 583         result |= kPlayingMask;
 584     else if (state == kAboutToPause || state == kPausedLedOn)
 585         result |= kPausedMask;
 586
 587     return result;
 588 }
 589
 590 const unsigned char *
 591 PlayPauseButton::BitsForMask(uint32 mask) const
 592 {
 593     switch (mask) {
 594         case kPlayingMask:
 595             return normalPlayingBits;
 596         case kPlayingMask | kPressedMask:
 597             return pressedPlayingBits;
 598         case kPausedMask:
 599             return normalPausedBits;
 600         case kPausedMask | kPressedMask:
 601             return pressedPausedBits;
 602         default:
 603             return _inherited::BitsForMask(mask);
 604     }
 605     TRESPASS();
 606     return 0;
 607 }
 608
 609
 610 void
 611 PlayPauseButton::StartPressing()
 612 {
 613     if (state == kPlaying)
 614         state = kAboutToPause;
 615     else
 616          state = kAboutToPlay;
 617
 618     _inherited::StartPressing();
 619 }
 620
 621 void
 622 PlayPauseButton::MouseCancelPressing()
 623 {
 624     if (state == kAboutToPause)
 625          state = kPlaying;
 626     else
 627         state = kStopped;
 628
 629     _inherited::MouseCancelPressing();
 630 }
 631
 632 void
 633 PlayPauseButton::DonePressing()
 634 {
 635     if (state == kAboutToPause) {
 636          state = kPausedLedOn;
 637         lastPauseBlinkTime = system_time();
 638     } else if (state == kAboutToPlay)
 639         state = kPlaying;
 640
 641     _inherited::DonePressing();
 642 }
 643
 644