← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/3rdparty/webkit/WebCore/accessibility/AccessibilityMediaControls.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-11-02 18:30:08 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (15.2.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20091102183008-b6a4gcs128mvfb3m
Tags: upstream-4.6.0~beta1
Import upstream version 4.6.0~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/webkit/WebCore/accessibility/AccessibilityMediaControls.cpp
 
1
/*
 
2
 * Copyright (C) 2009 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
 
 
30
#include "config.h"
 
31
 
 
32
#if ENABLE(VIDEO)
 
33
 
 
34
#include "AccessibilityMediaControls.h"
 
35
 
 
36
#include "AXObjectCache.h"
 
37
#include "HTMLInputElement.h"
 
38
#include "HTMLNames.h"
 
39
#include "LocalizedStrings.h"
 
40
#include "MediaControlElements.h"
 
41
#include "RenderObject.h"
 
42
#include "RenderSlider.h"
 
43
 
 
44
namespace WebCore {
 
45
 
 
46
using namespace HTMLNames;
 
47
 
 
48
 
 
49
AccessibilityMediaControl::AccessibilityMediaControl(RenderObject* renderer)
 
50
    : AccessibilityRenderObject(renderer)
 
51
{
 
52
}
 
53
 
 
54
PassRefPtr<AccessibilityObject> AccessibilityMediaControl::create(RenderObject* renderer)
 
55
{
 
56
    ASSERT(renderer->node() && renderer->node()->isMediaControlElement());
 
57
 
 
58
    Node* node = renderer->node();
 
59
    MediaControlElementType controlType;
 
60
 
 
61
    if (node->hasTagName(inputTag))
 
62
        controlType = static_cast<MediaControlInputElement*>(node)->displayType();
 
63
    else
 
64
        controlType = static_cast<MediaControlElement*>(node)->displayType();
 
65
 
 
66
    PassRefPtr<AccessibilityObject> obj;
 
67
    switch (controlType) {
 
68
    case MediaSlider:
 
69
        obj = AccessibilityMediaTimeline::create(renderer);
 
70
        break;
 
71
 
 
72
    case MediaCurrentTimeDisplay:
 
73
    case MediaTimeRemainingDisplay:
 
74
        obj = AccessibilityMediaTimeDisplay::create(renderer);
 
75
        break;
 
76
 
 
77
    case MediaControlsPanel:
 
78
        obj = AccessibilityMediaControlsContainer::create(renderer);
 
79
        break;
 
80
 
 
81
    default:
 
82
        obj = adoptRef(new AccessibilityMediaControl(renderer));
 
83
        break;
 
84
    }
 
85
 
 
86
    return obj;
 
87
}
 
88
 
 
89
MediaControlElementType AccessibilityMediaControl::controlType() const
 
90
{
 
91
    if (!renderer() || !renderer()->node())
 
92
        return MediaTimelineContainer;  // Timeline container is not accessible.
 
93
 
 
94
    Node* node = renderer()->node();
 
95
 
 
96
    if (node->hasTagName(inputTag))
 
97
        return static_cast<MediaControlInputElement*>(node)->displayType();
 
98
 
 
99
    return static_cast<MediaControlElement*>(node)->displayType();
 
100
}
 
101
 
 
102
String AccessibilityMediaControl::controlTypeName() const
 
103
{
 
104
    DEFINE_STATIC_LOCAL(const String, mediaMuteButtonName, ("MuteButton"));
 
105
    DEFINE_STATIC_LOCAL(const String, mediaPlayButtonName, ("PlayButton"));
 
106
    DEFINE_STATIC_LOCAL(const String, mediaSeekBackButtonName, ("SeekBackButton"));
 
107
    DEFINE_STATIC_LOCAL(const String, mediaSeekForwardButtonName, ("SeekForwardButton"));
 
108
    DEFINE_STATIC_LOCAL(const String, mediaRewindButtonName, ("RewindButton"));
 
109
    DEFINE_STATIC_LOCAL(const String, mediaReturnToRealtimeButtonName, ("ReturnToRealtimeButton"));
 
110
    DEFINE_STATIC_LOCAL(const String, mediaUnMuteButtonName, ("UnMuteButton"));
 
111
    DEFINE_STATIC_LOCAL(const String, mediaPauseButtonName, ("PauseButton"));
 
112
    DEFINE_STATIC_LOCAL(const String, mediaStatusDisplayName, ("StatusDisplay"));
 
113
    DEFINE_STATIC_LOCAL(const String, mediaCurrentTimeDisplay, ("CurrentTimeDisplay"));
 
114
    DEFINE_STATIC_LOCAL(const String, mediaTimeRemainingDisplay, ("TimeRemainingDisplay"));
 
115
 
 
116
    switch (controlType()) {
 
117
    case MediaMuteButton:
 
118
        return mediaMuteButtonName;
 
119
    case MediaPlayButton:
 
120
        return mediaPlayButtonName;
 
121
    case MediaSeekBackButton:
 
122
        return mediaSeekBackButtonName;
 
123
    case MediaSeekForwardButton:
 
124
        return mediaSeekForwardButtonName;
 
125
    case MediaRewindButton:
 
126
        return mediaRewindButtonName;
 
127
    case MediaReturnToRealtimeButton:
 
128
        return mediaReturnToRealtimeButtonName;
 
129
    case MediaUnMuteButton:
 
130
        return mediaUnMuteButtonName;
 
131
    case MediaPauseButton:
 
132
        return mediaPauseButtonName;
 
133
    case MediaStatusDisplay:
 
134
        return mediaStatusDisplayName;
 
135
    case MediaCurrentTimeDisplay:
 
136
        return mediaCurrentTimeDisplay;
 
137
    case MediaTimeRemainingDisplay:
 
138
        return mediaTimeRemainingDisplay;
 
139
 
 
140
    default:
 
141
        break;
 
142
    }
 
143
 
 
144
    return String();
 
145
}
 
146
 
 
147
String AccessibilityMediaControl::title() const
 
148
{
 
149
    DEFINE_STATIC_LOCAL(const String, controlsPanel, ("ControlsPanel"));
 
150
 
 
151
    if (controlType() == MediaControlsPanel)
 
152
        return localizedMediaControlElementString(controlsPanel);
 
153
 
 
154
    return AccessibilityRenderObject::title();
 
155
}
 
156
 
 
157
String AccessibilityMediaControl::accessibilityDescription() const
 
158
{
 
159
    return localizedMediaControlElementString(controlTypeName());
 
160
}
 
161
 
 
162
String AccessibilityMediaControl::helpText() const
 
163
{
 
164
    return localizedMediaControlElementHelpText(controlTypeName());
 
165
}
 
166
 
 
167
bool AccessibilityMediaControl::accessibilityIsIgnored() const
 
168
{
 
169
    if (!m_renderer || !m_renderer->style() || m_renderer->style()->visibility() != VISIBLE || controlType() == MediaTimelineContainer)
 
170
        return true;
 
171
 
 
172
    return false;
 
173
}
 
174
 
 
175
AccessibilityRole AccessibilityMediaControl::roleValue() const
 
176
{
 
177
    switch (controlType()) {
 
178
    case MediaFullscreenButton:
 
179
    case MediaMuteButton:
 
180
    case MediaPlayButton:
 
181
    case MediaSeekBackButton:
 
182
    case MediaSeekForwardButton:
 
183
    case MediaRewindButton:
 
184
    case MediaReturnToRealtimeButton:
 
185
    case MediaUnMuteButton:
 
186
    case MediaPauseButton:
 
187
        return ButtonRole;
 
188
 
 
189
    case MediaStatusDisplay:
 
190
        return StaticTextRole;
 
191
 
 
192
    case MediaTimelineContainer:
 
193
        return GroupRole;
 
194
 
 
195
    default:
 
196
        break;
 
197
    }
 
198
 
 
199
    return UnknownRole;
 
200
}
 
201
 
 
202
 
 
203
 
 
204
//
 
205
// AccessibilityMediaControlsContainer
 
206
 
 
207
AccessibilityMediaControlsContainer::AccessibilityMediaControlsContainer(RenderObject* renderer)
 
208
    : AccessibilityMediaControl(renderer)
 
209
{
 
210
}
 
211
 
 
212
PassRefPtr<AccessibilityObject> AccessibilityMediaControlsContainer::create(RenderObject* renderer)
 
213
{
 
214
    return adoptRef(new AccessibilityMediaControlsContainer(renderer));
 
215
}
 
216
 
 
217
String AccessibilityMediaControlsContainer::accessibilityDescription() const
 
218
{
 
219
    return localizedMediaControlElementString(elementTypeName());
 
220
}
 
221
 
 
222
String AccessibilityMediaControlsContainer::helpText() const
 
223
{
 
224
    return localizedMediaControlElementHelpText(elementTypeName());
 
225
}
 
226
 
 
227
bool AccessibilityMediaControlsContainer::controllingVideoElement() const
 
228
{
 
229
    if (!m_renderer->node())
 
230
        return true;
 
231
 
 
232
    MediaControlTimeDisplayElement* element = static_cast<MediaControlTimeDisplayElement*>(m_renderer->node());
 
233
 
 
234
    return element->mediaElement()->isVideo();
 
235
}
 
236
 
 
237
const String AccessibilityMediaControlsContainer::elementTypeName() const
 
238
{
 
239
    DEFINE_STATIC_LOCAL(const String, videoElement, ("VideoElement"));
 
240
    DEFINE_STATIC_LOCAL(const String, audioElement, ("AudioElement"));
 
241
 
 
242
    if (controllingVideoElement())
 
243
        return videoElement;
 
244
    return audioElement;
 
245
}
 
246
 
 
247
 
 
248
//
 
249
// AccessibilityMediaTimeline
 
250
 
 
251
AccessibilityMediaTimeline::AccessibilityMediaTimeline(RenderObject* renderer)
 
252
    : AccessibilitySlider(renderer)
 
253
{
 
254
}
 
255
 
 
256
PassRefPtr<AccessibilityObject> AccessibilityMediaTimeline::create(RenderObject* renderer)
 
257
{
 
258
    return adoptRef(new AccessibilityMediaTimeline(renderer));
 
259
}
 
260
 
 
261
String AccessibilityMediaTimeline::valueDescription() const
 
262
{
 
263
    ASSERT(m_renderer->node()->hasTagName(inputTag));
 
264
 
 
265
    float time = static_cast<HTMLInputElement*>(m_renderer->node())->value().toFloat();
 
266
    return localizedMediaTimeDescription(time);
 
267
}
 
268
 
 
269
String AccessibilityMediaTimeline::helpText() const
 
270
{
 
271
    DEFINE_STATIC_LOCAL(const String, slider, ("Slider"));
 
272
    return localizedMediaControlElementHelpText(slider);
 
273
}
 
274
 
 
275
 
 
276
//
 
277
// AccessibilityMediaTimeDisplay
 
278
 
 
279
AccessibilityMediaTimeDisplay::AccessibilityMediaTimeDisplay(RenderObject* renderer)
 
280
    : AccessibilityMediaControl(renderer)
 
281
{
 
282
}
 
283
 
 
284
PassRefPtr<AccessibilityObject> AccessibilityMediaTimeDisplay::create(RenderObject* renderer)
 
285
{
 
286
    return adoptRef(new AccessibilityMediaTimeDisplay(renderer));
 
287
}
 
288
 
 
289
bool AccessibilityMediaTimeDisplay::accessibilityIsIgnored() const
 
290
{
 
291
    if (!m_renderer || !m_renderer->style() || m_renderer->style()->visibility() != VISIBLE)
 
292
        return true;
 
293
 
 
294
    return !m_renderer->style()->width().value();
 
295
}
 
296
 
 
297
String AccessibilityMediaTimeDisplay::accessibilityDescription() const
 
298
{
 
299
    DEFINE_STATIC_LOCAL(const String, currentTimeDisplay, ("CurrentTimeDisplay"));
 
300
    DEFINE_STATIC_LOCAL(const String, timeRemainingDisplay, ("TimeRemainingDisplay"));
 
301
 
 
302
    if (controlType() == MediaCurrentTimeDisplay)
 
303
        return localizedMediaControlElementString(currentTimeDisplay);
 
304
 
 
305
    return localizedMediaControlElementString(timeRemainingDisplay);
 
306
}
 
307
 
 
308
String AccessibilityMediaTimeDisplay::stringValue() const
 
309
{
 
310
    if (!m_renderer || !m_renderer->node())
 
311
        return String();
 
312
 
 
313
    MediaControlTimeDisplayElement* element = static_cast<MediaControlTimeDisplayElement*>(m_renderer->node());
 
314
    float time = element->currentValue();
 
315
    return localizedMediaTimeDescription(fabsf(time));
 
316
}
 
317
 
 
318
} // namespace WebCore
 
319
 
 
320
#endif // ENABLE(VIDEO)