Source/WebCore/html/shadow/MediaControlElements.h

   1 /*
   2  * Copyright (C) 2008, 2009, 2010, 2011 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 class MediaControls;
  46
  47 // Must match WebKitSystemInterface.h
  48 enum MediaControlElementType {
  49     MediaFullscreenButton = 0,
  50     MediaMuteButton,
  51     MediaPlayButton,
  52     MediaSeekBackButton,
  53     MediaSeekForwardButton,
  54     MediaSlider,
  55     MediaSliderThumb,
  56     MediaRewindButton,
  57     MediaReturnToRealtimeButton,
  58     MediaShowClosedCaptionsButton,
  59     MediaHideClosedCaptionsButton,
  60     MediaUnMuteButton,
  61     MediaPauseButton,
  62     MediaTimelineContainer,
  63     MediaCurrentTimeDisplay,
  64     MediaTimeRemainingDisplay,
  65     MediaStatusDisplay,
  66     MediaControlsPanel,
  67     MediaVolumeSliderContainer,
  68     MediaVolumeSlider,
  69     MediaVolumeSliderThumb,
  70     MediaVolumeSliderMuteButton,
  71 };
  72
  73 HTMLMediaElement* toParentMediaElement(Node*);
  74 inline HTMLMediaElement* toParentMediaElement(RenderObject* renderer) { return toParentMediaElement(renderer->node()); }
  75
  76 MediaControlElementType mediaControlElementType(Node*);
  77
  78 // ----------------------------
  79
  80 class MediaControlElement : public HTMLDivElement {
  81 public:
  82     void hide();
  83     void show();
  84
  85     virtual MediaControlElementType displayType() const = 0;
  86
  87     HTMLMediaElement* mediaElement() const { return m_mediaElement; }
  88
  89 protected:
  90     MediaControlElement(HTMLMediaElement*);
  91
  92 private:
  93     virtual bool isMediaControlElement() const { return true; }
  94
  95     HTMLMediaElement* m_mediaElement;
  96 };
  97
  98 // ----------------------------
  99
 100 class MediaControlPanelElement : public MediaControlElement {
 101 public:
 102     static PassRefPtr<MediaControlPanelElement> create(HTMLMediaElement*);
 103
 104     void setCanBeDragged(bool);
 105     void resetPosition();
 106     void makeOpaque();
 107     void makeTransparent();
 108
 109 private:
 110     MediaControlPanelElement(HTMLMediaElement*);
 111     virtual MediaControlElementType displayType() const;
 112     virtual const AtomicString& shadowPseudoId() const;
 113     virtual void defaultEventHandler(Event*);
 114
 115     void startDrag(const LayoutPoint& eventLocation);
 116     void continueDrag(const LayoutPoint& eventLocation);
 117     void endDrag();
 118
 119     void setPosition(const LayoutPoint&);
 120
 121     bool m_canBeDragged;
 122     bool m_isBeingDragged;
 123     bool m_opaque;
 124     LayoutPoint m_dragStartPosition;
 125     LayoutPoint m_dragStartEventLocation;
 126 };
 127
 128 // ----------------------------
 129
 130 class MediaControlTimelineContainerElement : public MediaControlElement {
 131 public:
 132     static PassRefPtr<MediaControlTimelineContainerElement> create(HTMLMediaElement*);
 133
 134 private:
 135     MediaControlTimelineContainerElement(HTMLMediaElement*);
 136     virtual const AtomicString& shadowPseudoId() const;
 137
 138     virtual MediaControlElementType displayType() const;
 139 };
 140
 141 // ----------------------------
 142
 143 class MediaControlVolumeSliderContainerElement : public MediaControlElement {
 144 public:
 145     static PassRefPtr<MediaControlVolumeSliderContainerElement> create(HTMLMediaElement*);
 146
 147 private:
 148     MediaControlVolumeSliderContainerElement(HTMLMediaElement*);
 149     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
 150     virtual void defaultEventHandler(Event*);
 151     virtual MediaControlElementType displayType() const;
 152     virtual const AtomicString& shadowPseudoId() const;
 153 };
 154
 155 // ----------------------------
 156
 157 class MediaControlStatusDisplayElement : public MediaControlElement {
 158 public:
 159     static PassRefPtr<MediaControlStatusDisplayElement> create(HTMLMediaElement*);
 160
 161     void update();
 162
 163 private:
 164     MediaControlStatusDisplayElement(HTMLMediaElement*);
 165
 166     virtual MediaControlElementType displayType() const;
 167     virtual const AtomicString& shadowPseudoId() const;
 168
 169     enum StateBeingDisplayed { Nothing, Loading, LiveBroadcast };
 170     StateBeingDisplayed m_stateBeingDisplayed;
 171 };
 172
 173 // ----------------------------
 174
 175 class MediaControlInputElement : public HTMLInputElement {
 176 public:
 177     void hide();
 178     void show();
 179
 180     MediaControlElementType displayType() const { return m_displayType; }
 181
 182     HTMLMediaElement* mediaElement() const { return m_mediaElement; }
 183
 184 protected:
 185     MediaControlInputElement(HTMLMediaElement*, MediaControlElementType);
 186
 187     void setDisplayType(MediaControlElementType);
 188
 189 private:
 190     virtual bool isMediaControlElement() const { return true; }
 191
 192     virtual void updateDisplayType() { }
 193
 194     HTMLMediaElement* m_mediaElement;
 195     MediaControlElementType m_displayType;
 196 };
 197
 198 // ----------------------------
 199
 200 class MediaControlMuteButtonElement : public MediaControlInputElement {
 201 public:
 202     void changedMute();
 203
 204 protected:
 205     MediaControlMuteButtonElement(HTMLMediaElement*, MediaControlElementType);
 206     virtual void defaultEventHandler(Event*);
 207
 208
 209 private:
 210     virtual void updateDisplayType();
 211 };
 212
 213 // ----------------------------
 214
 215 class MediaControlPanelMuteButtonElement : public MediaControlMuteButtonElement {
 216 public:
 217     static PassRefPtr<MediaControlPanelMuteButtonElement> create(HTMLMediaElement*, MediaControls*);
 218
 219 private:
 220     MediaControlPanelMuteButtonElement(HTMLMediaElement*, MediaControls*);
 221
 222     virtual void defaultEventHandler(Event*);
 223     virtual const AtomicString& shadowPseudoId() const;
 224
 225     MediaControls* m_controls;
 226 };
 227
 228 // ----------------------------
 229
 230 class MediaControlVolumeSliderMuteButtonElement : public MediaControlMuteButtonElement {
 231 public:
 232     static PassRefPtr<MediaControlVolumeSliderMuteButtonElement> create(HTMLMediaElement*);
 233
 234 private:
 235     MediaControlVolumeSliderMuteButtonElement(HTMLMediaElement*);
 236
 237     virtual const AtomicString& shadowPseudoId() const;
 238 };
 239
 240
 241 // ----------------------------
 242
 243 class MediaControlPlayButtonElement : public MediaControlInputElement {
 244 public:
 245     static PassRefPtr<MediaControlPlayButtonElement> create(HTMLMediaElement*);
 246
 247     virtual void defaultEventHandler(Event*);
 248     virtual void updateDisplayType();
 249
 250 private:
 251     MediaControlPlayButtonElement(HTMLMediaElement*);
 252
 253     virtual const AtomicString& shadowPseudoId() const;
 254 };
 255
 256 // ----------------------------
 257
 258 class MediaControlSeekButtonElement : public MediaControlInputElement {
 259 public:
 260     virtual void defaultEventHandler(Event*);
 261
 262 protected:
 263     MediaControlSeekButtonElement(HTMLMediaElement*, MediaControlElementType);
 264
 265 private:
 266     virtual bool isForwardButton() const = 0;
 267     virtual void setActive(bool /*flag*/ = true, bool /*pause*/ = false);
 268
 269     void startTimer();
 270     void stopTimer();
 271     float nextRate() const;
 272     void seekTimerFired(Timer<MediaControlSeekButtonElement>*);
 273
 274     enum ActionType { Nothing, Play, Pause };
 275     ActionType m_actionOnStop;
 276     enum SeekType { Skip, Scan };
 277     SeekType m_seekType;
 278     Timer<MediaControlSeekButtonElement> m_seekTimer;
 279 };
 280
 281 // ----------------------------
 282
 283 class MediaControlSeekForwardButtonElement : public MediaControlSeekButtonElement {
 284 public:
 285     static PassRefPtr<MediaControlSeekForwardButtonElement> create(HTMLMediaElement*);
 286
 287 private:
 288     MediaControlSeekForwardButtonElement(HTMLMediaElement*);
 289
 290     virtual bool isForwardButton() const { return true; }
 291     virtual const AtomicString& shadowPseudoId() const;
 292 };
 293
 294 // ----------------------------
 295
 296 class MediaControlSeekBackButtonElement : public MediaControlSeekButtonElement {
 297 public:
 298     static PassRefPtr<MediaControlSeekBackButtonElement> create(HTMLMediaElement*);
 299
 300 private:
 301     MediaControlSeekBackButtonElement(HTMLMediaElement*);
 302
 303     virtual bool isForwardButton() const { return false; }
 304     virtual const AtomicString& shadowPseudoId() const;
 305 };
 306
 307 // ----------------------------
 308
 309 class MediaControlRewindButtonElement : public MediaControlInputElement {
 310 public:
 311     static PassRefPtr<MediaControlRewindButtonElement> create(HTMLMediaElement*);
 312
 313     virtual void defaultEventHandler(Event*);
 314
 315 private:
 316     MediaControlRewindButtonElement(HTMLMediaElement*);
 317
 318     virtual const AtomicString& shadowPseudoId() const;
 319 };
 320
 321 // ----------------------------
 322
 323 class MediaControlReturnToRealtimeButtonElement : public MediaControlInputElement {
 324 public:
 325     static PassRefPtr<MediaControlReturnToRealtimeButtonElement> create(HTMLMediaElement*);
 326
 327     virtual void defaultEventHandler(Event*);
 328
 329 private:
 330     MediaControlReturnToRealtimeButtonElement(HTMLMediaElement*);
 331
 332     virtual const AtomicString& shadowPseudoId() const;
 333 };
 334
 335 // ----------------------------
 336
 337 class MediaControlToggleClosedCaptionsButtonElement : public MediaControlInputElement {
 338 public:
 339     static PassRefPtr<MediaControlToggleClosedCaptionsButtonElement> create(HTMLMediaElement*);
 340
 341     virtual void defaultEventHandler(Event*);
 342     virtual void updateDisplayType();
 343
 344 private:
 345     MediaControlToggleClosedCaptionsButtonElement(HTMLMediaElement*);
 346
 347     virtual const AtomicString& shadowPseudoId() const;
 348 };
 349
 350 // ----------------------------
 351
 352 class MediaControlTimelineElement : public MediaControlInputElement {
 353 public:
 354     static PassRefPtr<MediaControlTimelineElement> create(HTMLMediaElement*, MediaControls*);
 355
 356     virtual void defaultEventHandler(Event*);
 357     void setPosition(float);
 358     void setDuration(float);
 359
 360 private:
 361     MediaControlTimelineElement(HTMLMediaElement*, MediaControls*);
 362
 363     virtual const AtomicString& shadowPseudoId() const;
 364
 365     MediaControls* m_controls;
 366 };
 367
 368 // ----------------------------
 369
 370 class MediaControlVolumeSliderElement : public MediaControlInputElement {
 371 public:
 372     static PassRefPtr<MediaControlVolumeSliderElement> create(HTMLMediaElement*);
 373
 374     virtual void defaultEventHandler(Event*);
 375     void setVolume(float);
 376
 377 protected:
 378     MediaControlVolumeSliderElement(HTMLMediaElement*);
 379
 380 private:
 381     virtual const AtomicString& shadowPseudoId() const;
 382 };
 383
 384 // ----------------------------
 385
 386 class MediaControlFullscreenButtonElement : public MediaControlInputElement {
 387 public:
 388     static PassRefPtr<MediaControlFullscreenButtonElement> create(HTMLMediaElement*, MediaControls*);
 389
 390     virtual void defaultEventHandler(Event*);
 391
 392 private:
 393     MediaControlFullscreenButtonElement(HTMLMediaElement*, MediaControls*);
 394
 395     virtual const AtomicString& shadowPseudoId() const;
 396
 397     MediaControls* m_controls;
 398 };
 399
 400 // ----------------------------
 401
 402 class MediaControlFullscreenVolumeSliderElement : public MediaControlVolumeSliderElement {
 403 public:
 404     static PassRefPtr<MediaControlFullscreenVolumeSliderElement> create(HTMLMediaElement*);
 405
 406 private:
 407     MediaControlFullscreenVolumeSliderElement(HTMLMediaElement*);
 408
 409     virtual const AtomicString& shadowPseudoId() const;
 410 };
 411
 412 // ----------------------------
 413
 414 class MediaControlFullscreenVolumeMinButtonElement : public MediaControlInputElement {
 415 public:
 416     static PassRefPtr<MediaControlFullscreenVolumeMinButtonElement> create(HTMLMediaElement*);
 417
 418     virtual void defaultEventHandler(Event*);
 419
 420 private:
 421     MediaControlFullscreenVolumeMinButtonElement(HTMLMediaElement*);
 422
 423     virtual const AtomicString& shadowPseudoId() const;
 424 };
 425
 426 // ----------------------------
 427
 428 class MediaControlFullscreenVolumeMaxButtonElement : public MediaControlInputElement {
 429 public:
 430     static PassRefPtr<MediaControlFullscreenVolumeMaxButtonElement> create(HTMLMediaElement*);
 431
 432     virtual void defaultEventHandler(Event*);
 433
 434 private:
 435     MediaControlFullscreenVolumeMaxButtonElement(HTMLMediaElement*);
 436
 437     virtual const AtomicString& shadowPseudoId() const;
 438 };
 439
 440 // ----------------------------
 441
 442 class MediaControlTimeDisplayElement : public MediaControlElement {
 443 public:
 444     void setCurrentValue(float);
 445     float currentValue() const { return m_currentValue; }
 446
 447 protected:
 448     MediaControlTimeDisplayElement(HTMLMediaElement*);
 449
 450 private:
 451     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
 452
 453     float m_currentValue;
 454 };
 455
 456 // ----------------------------
 457
 458 class MediaControlTimeRemainingDisplayElement : public MediaControlTimeDisplayElement {
 459 public:
 460     static PassRefPtr<MediaControlTimeRemainingDisplayElement> create(HTMLMediaElement*);
 461
 462 private:
 463     MediaControlTimeRemainingDisplayElement(HTMLMediaElement*);
 464
 465     virtual MediaControlElementType displayType() const;
 466     virtual const AtomicString& shadowPseudoId() const;
 467 };
 468
 469 // ----------------------------
 470
 471 class MediaControlCurrentTimeDisplayElement : public MediaControlTimeDisplayElement {
 472 public:
 473     static PassRefPtr<MediaControlCurrentTimeDisplayElement> create(HTMLMediaElement*);
 474
 475 private:
 476     MediaControlCurrentTimeDisplayElement(HTMLMediaElement*);
 477
 478     virtual MediaControlElementType displayType() const;
 479     virtual const AtomicString& shadowPseudoId() const;
 480 };
 481
 482 // ----------------------------
 483
 484 } // namespace WebCore
 485
 486 #endif // ENABLE(VIDEO)
 487
 488 #endif // MediaControlElements_h