Remove HTTPD object type
[vlc.git] / 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