2010-07-08 Eric Carlson <eric.carlson@apple.com>
[WebKit-https.git] / WebCore / rendering / MediaControlElements.h
1 /*
2  * Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #ifndef MediaControlElements_h
30 #define MediaControlElements_h
31
32 #if ENABLE(VIDEO)
33
34 #include "HTMLDivElement.h"
35 #include "HTMLInputElement.h"
36 #include "HTMLMediaElement.h"
37 #include "RenderBlock.h"
38
39 // These are the shadow elements used in RenderMedia
40
41 namespace WebCore {
42
43 class Event;
44 class Frame;
45
46 // Must match WebKitSystemInterface.h
47 enum MediaControlElementType {
48     MediaFullscreenButton = 0,
49     MediaMuteButton,
50     MediaPlayButton,
51     MediaSeekBackButton,
52     MediaSeekForwardButton,
53     MediaSlider,
54     MediaSliderThumb,
55     MediaRewindButton,
56     MediaReturnToRealtimeButton,
57     MediaShowClosedCaptionsButton,
58     MediaHideClosedCaptionsButton,
59     MediaUnMuteButton,
60     MediaPauseButton,
61     MediaTimelineContainer,
62     MediaCurrentTimeDisplay,
63     MediaTimeRemainingDisplay,
64     MediaStatusDisplay,
65     MediaControlsPanel,
66     MediaVolumeSliderContainer,
67     MediaVolumeSlider,
68     MediaVolumeSliderThumb,
69     MediaVolumeSliderMuteButton,
70 };
71
72 HTMLMediaElement* toParentMediaElement(RenderObject*);
73
74 class MediaControlShadowRootElement : public HTMLDivElement {
75 public:
76     static PassRefPtr<MediaControlShadowRootElement> create(HTMLMediaElement*);
77
78     void updateStyle();
79     
80 private:
81     MediaControlShadowRootElement(HTMLMediaElement*);
82     
83     virtual bool isShadowNode() const { return true; }
84     virtual Node* shadowParentNode() { return m_mediaElement; }
85
86     HTMLMediaElement* m_mediaElement;    
87 };
88
89 // ----------------------------
90
91 class MediaControlElement : public HTMLDivElement {
92 public:
93     static PassRefPtr<MediaControlElement> create(HTMLMediaElement*, PseudoId);
94
95     virtual void attach();
96     void attachToParent(Element*);
97     void update();
98     void updateStyle();
99
100     MediaControlElementType displayType() const { return m_displayType; }
101
102     HTMLMediaElement* mediaElement() const { return m_mediaElement; }
103
104 protected:
105     MediaControlElement(HTMLMediaElement*, PseudoId);
106
107     virtual bool rendererIsNeeded(RenderStyle*);
108
109     virtual PassRefPtr<RenderStyle> styleForElement();
110
111 private:
112     virtual bool isMediaControlElement() const { return true; }
113
114     HTMLMediaElement* m_mediaElement;   
115     PseudoId m_pseudoStyleId;
116     MediaControlElementType m_displayType;  // some elements can show multiple types (e.g. play/pause)
117 };
118
119 // ----------------------------
120
121 class MediaControlTimelineContainerElement : public MediaControlElement {
122 public:
123     static PassRefPtr<MediaControlTimelineContainerElement> create(HTMLMediaElement*);
124
125 private:
126     MediaControlTimelineContainerElement(HTMLMediaElement*);
127     virtual bool rendererIsNeeded(RenderStyle*);
128 };
129
130 // ----------------------------
131
132 class MediaControlVolumeSliderContainerElement : public MediaControlElement {
133 public:
134     static PassRefPtr<MediaControlVolumeSliderContainerElement> create(HTMLMediaElement*);
135
136     virtual PassRefPtr<RenderStyle> styleForElement();
137     void setVisible(bool);
138     bool isVisible() { return m_isVisible; }
139     void setPosition(int x, int y);
140     bool hitTest(const IntPoint& absPoint);
141
142 private:
143     MediaControlVolumeSliderContainerElement(HTMLMediaElement*);
144
145     bool m_isVisible;
146     int m_x, m_y;
147 };
148
149 // ----------------------------
150
151 class MediaControlStatusDisplayElement : public MediaControlElement {
152 public:
153     static PassRefPtr<MediaControlStatusDisplayElement> create(HTMLMediaElement*);
154
155     void update();
156
157 private:
158     MediaControlStatusDisplayElement(HTMLMediaElement*);
159
160     virtual bool rendererIsNeeded(RenderStyle*);
161
162     enum StateBeingDisplayed { Nothing, Loading, LiveBroadcast };
163     StateBeingDisplayed m_stateBeingDisplayed;
164 };
165
166 // ----------------------------
167
168 class MediaControlInputElement : public HTMLInputElement {
169 public:
170     void attachToParent(Element*);
171     void update();
172     void updateStyle();
173
174     bool hitTest(const IntPoint& absPoint);
175
176     MediaControlElementType displayType() const { return m_displayType; }
177
178     HTMLMediaElement* mediaElement() const { return m_mediaElement; }
179
180 protected:
181     MediaControlInputElement(HTMLMediaElement*, PseudoId, const String& type);
182
183     void setDisplayType(MediaControlElementType);
184
185     PseudoId pseudoStyleId() const { return m_pseudoStyleId; }
186
187 private:
188     virtual void attach();
189     virtual bool rendererIsNeeded(RenderStyle*);
190
191     virtual PassRefPtr<RenderStyle> styleForElement();
192
193     virtual bool isMediaControlElement() const { return true; }
194
195     virtual void updateDisplayType() { }
196
197     HTMLMediaElement* m_mediaElement;   
198     PseudoId m_pseudoStyleId;
199     MediaControlElementType m_displayType;
200 };
201
202 // ----------------------------
203
204 class MediaControlMuteButtonElement : public MediaControlInputElement {
205 public:
206     enum ButtonLocation { Controller, VolumeSlider };
207     static PassRefPtr<MediaControlMuteButtonElement> create(HTMLMediaElement*, ButtonLocation);
208
209     virtual void defaultEventHandler(Event*);
210
211 private:
212     MediaControlMuteButtonElement(HTMLMediaElement*, ButtonLocation);
213
214     virtual void updateDisplayType();
215 };
216
217 // ----------------------------
218
219 class MediaControlPlayButtonElement : public MediaControlInputElement {
220 public:
221     static PassRefPtr<MediaControlPlayButtonElement> create(HTMLMediaElement*);
222
223     virtual void defaultEventHandler(Event*);
224
225 private:
226     MediaControlPlayButtonElement(HTMLMediaElement*);
227
228     virtual void updateDisplayType();
229 };
230
231 // ----------------------------
232
233 class MediaControlSeekButtonElement : public MediaControlInputElement {
234 public:
235     static PassRefPtr<MediaControlSeekButtonElement> create(HTMLMediaElement*, PseudoId);
236
237     virtual void defaultEventHandler(Event*);
238
239 private:
240     MediaControlSeekButtonElement(HTMLMediaElement*, PseudoId);
241
242     bool isForwardButton() const;
243
244     virtual void detach();
245     void seekTimerFired(Timer<MediaControlSeekButtonElement>*);
246
247     bool m_seeking;
248     bool m_capturing;
249     Timer<MediaControlSeekButtonElement> m_seekTimer;
250 };
251     
252 // ----------------------------
253
254 class MediaControlRewindButtonElement : public MediaControlInputElement {
255 public:
256     static PassRefPtr<MediaControlRewindButtonElement> create(HTMLMediaElement*);
257
258     virtual void defaultEventHandler(Event*);
259
260 private:
261     MediaControlRewindButtonElement(HTMLMediaElement*);
262 };
263
264 // ----------------------------
265
266 class MediaControlReturnToRealtimeButtonElement : public MediaControlInputElement {
267 public:
268     static PassRefPtr<MediaControlReturnToRealtimeButtonElement> create(HTMLMediaElement*);
269
270     virtual void defaultEventHandler(Event*);
271
272 private:
273     MediaControlReturnToRealtimeButtonElement(HTMLMediaElement*);
274 };    
275
276 // ----------------------------
277
278 class MediaControlToggleClosedCaptionsButtonElement : public MediaControlInputElement {
279 public:
280     static PassRefPtr<MediaControlToggleClosedCaptionsButtonElement> create(HTMLMediaElement*);
281
282     virtual void defaultEventHandler(Event*);
283
284 private:
285     MediaControlToggleClosedCaptionsButtonElement(HTMLMediaElement*);
286
287     virtual void updateDisplayType();
288 };    
289
290 // ----------------------------
291
292 class MediaControlTimelineElement : public MediaControlInputElement {
293 public:
294     static PassRefPtr<MediaControlTimelineElement> create(HTMLMediaElement*);
295
296     virtual void defaultEventHandler(Event*);
297     void update(bool updateDuration = true);
298
299 private:
300     MediaControlTimelineElement(HTMLMediaElement*);
301 };
302
303 // ----------------------------
304
305 class MediaControlVolumeSliderElement : public MediaControlInputElement {
306 public:
307     static PassRefPtr<MediaControlVolumeSliderElement> create(HTMLMediaElement*);
308
309     virtual void defaultEventHandler(Event*);
310     void update();
311
312 private:
313     MediaControlVolumeSliderElement(HTMLMediaElement*);
314 };
315
316 // ----------------------------
317
318 class MediaControlFullscreenButtonElement : public MediaControlInputElement {
319 public:
320     static PassRefPtr<MediaControlFullscreenButtonElement> create(HTMLMediaElement*);
321
322     virtual void defaultEventHandler(Event*);
323
324 private:
325     MediaControlFullscreenButtonElement(HTMLMediaElement*);
326 };
327
328 // ----------------------------
329
330 class MediaControlTimeDisplayElement : public MediaControlElement {
331 public:
332     static PassRefPtr<MediaControlTimeDisplayElement> create(HTMLMediaElement*, PseudoId);
333
334     void setVisible(bool);
335
336     void setCurrentValue(float);
337     float currentValue() const { return m_currentValue; }
338
339 private:
340     MediaControlTimeDisplayElement(HTMLMediaElement*, PseudoId);
341
342     virtual PassRefPtr<RenderStyle> styleForElement();
343     float m_currentValue;
344     bool m_isVisible;
345 };
346
347 // ----------------------------
348
349 class RenderMediaControlShadowRoot : public RenderBlock {
350 public:
351     RenderMediaControlShadowRoot(Element* e) : RenderBlock(e) { }
352     void setParent(RenderObject* p) { RenderObject::setParent(p); }
353 };
354     
355 // ----------------------------
356
357 } //namespace WebCore
358
359 #endif // ENABLE(VIDEO)
360
361 #endif // MediaControlElements_h