* modules/codec/ffmpeg/*: modified the ffmpeg video codec to use direct
[vlc.git] / modules / gui / beos / TransportButton.cpp
1 /*****************************************************************************
2  * TransportButton.cpp
3  *****************************************************************************
4  * Copyright (C) 2001 VideoLAN
5  * $Id: TransportButton.cpp,v 1.3 2002/10/29 17:33:11 titer Exp $
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., 59 Temple Place - Suite 330, Boston, MA  02111, 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