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