/* | |
* Copyright (C) 2009 Apple Inc. All rights reserved. | |
* | |
* Redistribution and use in source and binary forms, with or without | |
* modification, are permitted provided that the following conditions | |
* are met: | |
* | |
* 1. Redistributions of source code must retain the above copyright | |
* notice, this list of conditions and the following disclaimer. | |
* 2. Redistributions in binary form must reproduce the above copyright | |
* notice, this list of conditions and the following disclaimer in the | |
* documentation and/or other materials provided with the distribution. | |
* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of | |
* its contributors may be used to endorse or promote products derived | |
* from this software without specific prior written permission. | |
* | |
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY | |
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY | |
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | |
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | |
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
*/ | |
#include "config.h" | |
#if ENABLE(VIDEO) | |
#include "AccessibilityMediaControls.h" | |
#include "AXObjectCache.h" | |
#include "HTMLInputElement.h" | |
#include "HTMLNames.h" | |
#include "LocalizedStrings.h" | |
#include "MediaControlElements.h" | |
#include "RenderObject.h" | |
#include "RenderSlider.h" | |
namespace WebCore { | |
using namespace HTMLNames; | |
AccessibilityMediaControl::AccessibilityMediaControl(RenderObject* renderer) | |
: AccessibilityRenderObject(renderer) | |
{ | |
} | |
PassRefPtr<AccessibilityObject> AccessibilityMediaControl::create(RenderObject* renderer) | |
{ | |
ASSERT(renderer->node() && renderer->node()->isMediaControlElement()); | |
Node* node = renderer->node(); | |
MediaControlElementType controlType; | |
if (node->hasTagName(inputTag)) | |
controlType = static_cast<MediaControlInputElement*>(node)->displayType(); | |
else | |
controlType = static_cast<MediaControlElement*>(node)->displayType(); | |
PassRefPtr<AccessibilityObject> obj; | |
switch (controlType) { | |
case MediaSlider: | |
obj = AccessibilityMediaTimeline::create(renderer); | |
break; | |
case MediaCurrentTimeDisplay: | |
case MediaTimeRemainingDisplay: | |
obj = AccessibilityMediaTimeDisplay::create(renderer); | |
break; | |
case MediaControlsPanel: | |
obj = AccessibilityMediaControlsContainer::create(renderer); | |
break; | |
default: | |
obj = adoptRef(new AccessibilityMediaControl(renderer)); | |
break; | |
} | |
return obj; | |
} | |
MediaControlElementType AccessibilityMediaControl::controlType() const | |
{ | |
if (!renderer() || !renderer()->node()) | |
return MediaTimelineContainer; // Timeline container is not accessible. | |
Node* node = renderer()->node(); | |
if (node->hasTagName(inputTag)) | |
return static_cast<MediaControlInputElement*>(node)->displayType(); | |
return static_cast<MediaControlElement*>(node)->displayType(); | |
} | |
String AccessibilityMediaControl::controlTypeName() const | |
{ | |
DEFINE_STATIC_LOCAL(const String, mediaFullscreenButtonName, ("FullscreenButton")); | |
DEFINE_STATIC_LOCAL(const String, mediaMuteButtonName, ("MuteButton")); | |
DEFINE_STATIC_LOCAL(const String, mediaPlayButtonName, ("PlayButton")); | |
DEFINE_STATIC_LOCAL(const String, mediaSeekBackButtonName, ("SeekBackButton")); | |
DEFINE_STATIC_LOCAL(const String, mediaSeekForwardButtonName, ("SeekForwardButton")); | |
DEFINE_STATIC_LOCAL(const String, mediaRewindButtonName, ("RewindButton")); | |
DEFINE_STATIC_LOCAL(const String, mediaReturnToRealtimeButtonName, ("ReturnToRealtimeButton")); | |
DEFINE_STATIC_LOCAL(const String, mediaUnMuteButtonName, ("UnMuteButton")); | |
DEFINE_STATIC_LOCAL(const String, mediaPauseButtonName, ("PauseButton")); | |
DEFINE_STATIC_LOCAL(const String, mediaStatusDisplayName, ("StatusDisplay")); | |
DEFINE_STATIC_LOCAL(const String, mediaCurrentTimeDisplay, ("CurrentTimeDisplay")); | |
DEFINE_STATIC_LOCAL(const String, mediaTimeRemainingDisplay, ("TimeRemainingDisplay")); | |
DEFINE_STATIC_LOCAL(const String, mediaShowClosedCaptionsButtonName, ("ShowClosedCaptionsButton")); | |
DEFINE_STATIC_LOCAL(const String, mediaHideClosedCaptionsButtonName, ("HideClosedCaptionsButton")); | |
switch (controlType()) { | |
case MediaFullscreenButton: | |
return mediaFullscreenButtonName; | |
case MediaMuteButton: | |
return mediaMuteButtonName; | |
case MediaPlayButton: | |
return mediaPlayButtonName; | |
case MediaSeekBackButton: | |
return mediaSeekBackButtonName; | |
case MediaSeekForwardButton: | |
return mediaSeekForwardButtonName; | |
case MediaRewindButton: | |
return mediaRewindButtonName; | |
case MediaReturnToRealtimeButton: | |
return mediaReturnToRealtimeButtonName; | |
case MediaUnMuteButton: | |
return mediaUnMuteButtonName; | |
case MediaPauseButton: | |
return mediaPauseButtonName; | |
case MediaStatusDisplay: | |
return mediaStatusDisplayName; | |
case MediaCurrentTimeDisplay: | |
return mediaCurrentTimeDisplay; | |
case MediaTimeRemainingDisplay: | |
return mediaTimeRemainingDisplay; | |
case MediaShowClosedCaptionsButton: | |
return mediaShowClosedCaptionsButtonName; | |
case MediaHideClosedCaptionsButton: | |
return mediaHideClosedCaptionsButtonName; | |
default: | |
break; | |
} | |
return String(); | |
} | |
String AccessibilityMediaControl::title() const | |
{ | |
DEFINE_STATIC_LOCAL(const String, controlsPanel, ("ControlsPanel")); | |
if (controlType() == MediaControlsPanel) | |
return localizedMediaControlElementString(controlsPanel); | |
return AccessibilityRenderObject::title(); | |
} | |
String AccessibilityMediaControl::accessibilityDescription() const | |
{ | |
return localizedMediaControlElementString(controlTypeName()); | |
} | |
String AccessibilityMediaControl::helpText() const | |
{ | |
return localizedMediaControlElementHelpText(controlTypeName()); | |
} | |
bool AccessibilityMediaControl::accessibilityIsIgnored() const | |
{ | |
if (!m_renderer || !m_renderer->style() || m_renderer->style()->visibility() != VISIBLE || controlType() == MediaTimelineContainer) | |
return true; | |
return false; | |
} | |
AccessibilityRole AccessibilityMediaControl::roleValue() const | |
{ | |
switch (controlType()) { | |
case MediaFullscreenButton: | |
case MediaMuteButton: | |
case MediaPlayButton: | |
case MediaSeekBackButton: | |
case MediaSeekForwardButton: | |
case MediaRewindButton: | |
case MediaReturnToRealtimeButton: | |
case MediaUnMuteButton: | |
case MediaPauseButton: | |
case MediaShowClosedCaptionsButton: | |
case MediaHideClosedCaptionsButton: | |
return ButtonRole; | |
case MediaStatusDisplay: | |
return StaticTextRole; | |
case MediaTimelineContainer: | |
return GroupRole; | |
default: | |
break; | |
} | |
return UnknownRole; | |
} | |
// | |
// AccessibilityMediaControlsContainer | |
AccessibilityMediaControlsContainer::AccessibilityMediaControlsContainer(RenderObject* renderer) | |
: AccessibilityMediaControl(renderer) | |
{ | |
} | |
PassRefPtr<AccessibilityObject> AccessibilityMediaControlsContainer::create(RenderObject* renderer) | |
{ | |
return adoptRef(new AccessibilityMediaControlsContainer(renderer)); | |
} | |
String AccessibilityMediaControlsContainer::accessibilityDescription() const | |
{ | |
return localizedMediaControlElementString(elementTypeName()); | |
} | |
String AccessibilityMediaControlsContainer::helpText() const | |
{ | |
return localizedMediaControlElementHelpText(elementTypeName()); | |
} | |
bool AccessibilityMediaControlsContainer::controllingVideoElement() const | |
{ | |
if (!m_renderer->node()) | |
return true; | |
MediaControlTimeDisplayElement* element = static_cast<MediaControlTimeDisplayElement*>(m_renderer->node()); | |
return element->mediaElement()->isVideo(); | |
} | |
const String AccessibilityMediaControlsContainer::elementTypeName() const | |
{ | |
DEFINE_STATIC_LOCAL(const String, videoElement, ("VideoElement")); | |
DEFINE_STATIC_LOCAL(const String, audioElement, ("AudioElement")); | |
if (controllingVideoElement()) | |
return videoElement; | |
return audioElement; | |
} | |
// | |
// AccessibilityMediaTimeline | |
AccessibilityMediaTimeline::AccessibilityMediaTimeline(RenderObject* renderer) | |
: AccessibilitySlider(renderer) | |
{ | |
} | |
PassRefPtr<AccessibilityObject> AccessibilityMediaTimeline::create(RenderObject* renderer) | |
{ | |
return adoptRef(new AccessibilityMediaTimeline(renderer)); | |
} | |
String AccessibilityMediaTimeline::valueDescription() const | |
{ | |
ASSERT(m_renderer->node()->hasTagName(inputTag)); | |
float time = static_cast<HTMLInputElement*>(m_renderer->node())->value().toFloat(); | |
return localizedMediaTimeDescription(time); | |
} | |
String AccessibilityMediaTimeline::helpText() const | |
{ | |
DEFINE_STATIC_LOCAL(const String, slider, ("Slider")); | |
return localizedMediaControlElementHelpText(slider); | |
} | |
// | |
// AccessibilityMediaTimeDisplay | |
AccessibilityMediaTimeDisplay::AccessibilityMediaTimeDisplay(RenderObject* renderer) | |
: AccessibilityMediaControl(renderer) | |
{ | |
} | |
PassRefPtr<AccessibilityObject> AccessibilityMediaTimeDisplay::create(RenderObject* renderer) | |
{ | |
return adoptRef(new AccessibilityMediaTimeDisplay(renderer)); | |
} | |
bool AccessibilityMediaTimeDisplay::accessibilityIsIgnored() const | |
{ | |
if (!m_renderer || !m_renderer->style() || m_renderer->style()->visibility() != VISIBLE) | |
return true; | |
return !m_renderer->style()->width().value(); | |
} | |
String AccessibilityMediaTimeDisplay::accessibilityDescription() const | |
{ | |
DEFINE_STATIC_LOCAL(const String, currentTimeDisplay, ("CurrentTimeDisplay")); | |
DEFINE_STATIC_LOCAL(const String, timeRemainingDisplay, ("TimeRemainingDisplay")); | |
if (controlType() == MediaCurrentTimeDisplay) | |
return localizedMediaControlElementString(currentTimeDisplay); | |
return localizedMediaControlElementString(timeRemainingDisplay); | |
} | |
String AccessibilityMediaTimeDisplay::stringValue() const | |
{ | |
if (!m_renderer || !m_renderer->node()) | |
return String(); | |
MediaControlTimeDisplayElement* element = static_cast<MediaControlTimeDisplayElement*>(m_renderer->node()); | |
float time = element->currentValue(); | |
return localizedMediaTimeDescription(fabsf(time)); | |
} | |
} // namespace WebCore | |
#endif // ENABLE(VIDEO) |