#include "config.h"
#if ENABLE(VIDEO_TRACK)
#include "TextTrackCue.h"
#include "CSSPropertyNames.h"
#include "CSSValueKeywords.h"
#include "DocumentFragment.h"
#include "Event.h"
#include "HTMLDivElement.h"
#include "HTMLSpanElement.h"
#include "Logging.h"
#include "NodeTraversal.h"
#include "RenderTextTrackCue.h"
#include "Text.h"
#include "TextTrack.h"
#include "TextTrackCueList.h"
#include "WebVTTElement.h"
#include "WebVTTParser.h"
#include <wtf/MathExtras.h>
#include <wtf/text/StringBuilder.h>
namespace WebCore {
static const int invalidCueIndex = -1;
static const int undefinedPosition = -1;
static const int autoSize = 0;
static const String& startKeyword()
{
DEFINE_STATIC_LOCAL(const String, start, (ASCIILiteral("start")));
return start;
}
static const String& middleKeyword()
{
DEFINE_STATIC_LOCAL(const String, middle, (ASCIILiteral("middle")));
return middle;
}
static const String& endKeyword()
{
DEFINE_STATIC_LOCAL(const String, end, (ASCIILiteral("end")));
return end;
}
static const String& horizontalKeyword()
{
return emptyString();
}
static const String& verticalGrowingLeftKeyword()
{
DEFINE_STATIC_LOCAL(const String, verticalrl, (ASCIILiteral("rl")));
return verticalrl;
}
static const String& verticalGrowingRightKeyword()
{
DEFINE_STATIC_LOCAL(const String, verticallr, (ASCIILiteral("lr")));
return verticallr;
}
TextTrackCueBox::TextTrackCueBox(Document* document, TextTrackCue* cue)
: HTMLElement(divTag, document)
, m_cue(cue)
{
setPseudo(textTrackCueBoxShadowPseudoId());
}
TextTrackCue* TextTrackCueBox::getCue() const
{
return m_cue;
}
void TextTrackCueBox::applyCSSProperties(const IntSize&)
{
setInlineStyleProperty(CSSPropertyPosition, CSSValueAbsolute);
setInlineStyleProperty(CSSPropertyUnicodeBidi, CSSValueWebkitPlaintext);
setInlineStyleProperty(CSSPropertyDirection, m_cue->getCSSWritingDirection());
setInlineStyleProperty(CSSPropertyWebkitWritingMode, m_cue->getCSSWritingMode(), false);
std::pair<float, float> position = m_cue->getCSSPosition();
setInlineStyleProperty(CSSPropertyTop, static_cast<double>(position.second), CSSPrimitiveValue::CSS_PERCENTAGE);
setInlineStyleProperty(CSSPropertyLeft, static_cast<double>(position.first), CSSPrimitiveValue::CSS_PERCENTAGE);
if (m_cue->vertical() == horizontalKeyword()) {
setInlineStyleProperty(CSSPropertyWidth, static_cast<double>(m_cue->getCSSSize()), CSSPrimitiveValue::CSS_PERCENTAGE);
setInlineStyleProperty(CSSPropertyHeight, CSSValueAuto);
} else {
setInlineStyleProperty(CSSPropertyWidth, CSSValueAuto);
setInlineStyleProperty(CSSPropertyHeight, static_cast<double>(m_cue->getCSSSize()), CSSPrimitiveValue::CSS_PERCENTAGE);
}
if (m_cue->align() == startKeyword())
setInlineStyleProperty(CSSPropertyTextAlign, CSSValueStart);
else if (m_cue->align() == endKeyword())
setInlineStyleProperty(CSSPropertyTextAlign, CSSValueEnd);
else
setInlineStyleProperty(CSSPropertyTextAlign, CSSValueCenter);
if (!m_cue->snapToLines()) {
setInlineStyleProperty(CSSPropertyWebkitTransform,
String::format("translate(-%.2f%%, -%.2f%%)", position.first, position.second));
setInlineStyleProperty(CSSPropertyWhiteSpace, CSSValuePre);
}
}
const AtomicString& TextTrackCueBox::textTrackCueBoxShadowPseudoId()
{
DEFINE_STATIC_LOCAL(const AtomicString, trackDisplayBoxShadowPseudoId, ("-webkit-media-text-track-display", AtomicString::ConstructFromLiteral));
return trackDisplayBoxShadowPseudoId;
}
RenderObject* TextTrackCueBox::createRenderer(RenderArena* arena, RenderStyle*)
{
return new (arena) RenderTextTrackCue(this);
}
TextTrackCue::TextTrackCue(ScriptExecutionContext* context, double start, double end, const String& content)
: m_startTime(start)
, m_endTime(end)
, m_content(content)
, m_linePosition(undefinedPosition)
, m_computedLinePosition(undefinedPosition)
, m_textPosition(50)
, m_cueSize(100)
, m_cueIndex(invalidCueIndex)
, m_processingCueChanges(0)
, m_writingDirection(Horizontal)
, m_cueAlignment(Middle)
, m_webVTTNodeTree(0)
, m_track(0)
, m_scriptExecutionContext(context)
, m_isActive(false)
, m_pauseOnExit(false)
, m_snapToLines(true)
, m_cueBackgroundBox(HTMLSpanElement::create(spanTag, toDocument(context)))
, m_displayTreeShouldChange(true)
, m_displayDirection(CSSValueLtr)
{
ASSERT(m_scriptExecutionContext->isDocument());
m_displayWritingModeMap[Horizontal] = CSSValueHorizontalTb;
m_displayWritingModeMap[VerticalGrowingLeft] = CSSValueVerticalRl;
m_displayWritingModeMap[VerticalGrowingRight] = CSSValueVerticalLr;
}
TextTrackCue::~TextTrackCue()
{
removeDisplayTree();
}
PassRefPtr<TextTrackCueBox> TextTrackCue::createDisplayTree()
{
return TextTrackCueBox::create(ownerDocument(), this);
}
TextTrackCueBox* TextTrackCue::displayTreeInternal()
{
if (!m_displayTree)
m_displayTree = createDisplayTree();
return m_displayTree.get();
}
void TextTrackCue::willChange()
{
if (++m_processingCueChanges > 1)
return;
if (m_track)
m_track->cueWillChange(this);
}
void TextTrackCue::didChange()
{
ASSERT(m_processingCueChanges);
if (--m_processingCueChanges)
return;
if (m_track)
m_track->cueDidChange(this);
m_displayTreeShouldChange = true;
}
TextTrack* TextTrackCue::track() const
{
return m_track;
}
void TextTrackCue::setTrack(TextTrack* track)
{
m_track = track;
}
void TextTrackCue::setId(const String& id)
{
if (m_id == id)
return;
willChange();
m_id = id;
didChange();
}
void TextTrackCue::setStartTime(double value, ExceptionCode& ec)
{
if (std::isinf(value) || std::isnan(value)) {
ec = TypeError;
return;
}
if (m_startTime == value || value < 0)
return;
willChange();
m_startTime = value;
didChange();
}
void TextTrackCue::setEndTime(double value, ExceptionCode& ec)
{
if (std::isinf(value) || std::isnan(value)) {
ec = TypeError;
return;
}
if (m_endTime == value || value < 0)
return;
willChange();
m_endTime = value;
didChange();
}
void TextTrackCue::setPauseOnExit(bool value)
{
if (m_pauseOnExit == value)
return;
m_pauseOnExit = value;
}
const String& TextTrackCue::vertical() const
{
switch (m_writingDirection) {
case Horizontal:
return horizontalKeyword();
case VerticalGrowingLeft:
return verticalGrowingLeftKeyword();
case VerticalGrowingRight:
return verticalGrowingRightKeyword();
default:
ASSERT_NOT_REACHED();
return emptyString();
}
}
void TextTrackCue::setVertical(const String& value, ExceptionCode& ec)
{
WritingDirection direction = m_writingDirection;
if (value == horizontalKeyword())
direction = Horizontal;
else if (value == verticalGrowingLeftKeyword())
direction = VerticalGrowingLeft;
else if (value == verticalGrowingRightKeyword())
direction = VerticalGrowingRight;
else
ec = SYNTAX_ERR;
if (direction == m_writingDirection)
return;
willChange();
m_writingDirection = direction;
didChange();
}
void TextTrackCue::setSnapToLines(bool value)
{
if (m_snapToLines == value)
return;
willChange();
m_snapToLines = value;
didChange();
}
void TextTrackCue::setLine(int position, ExceptionCode& ec)
{
if (!m_snapToLines && (position < 0 || position > 100)) {
ec = INDEX_SIZE_ERR;
return;
}
if (m_linePosition == position)
return;
willChange();
m_linePosition = position;
m_computedLinePosition = calculateComputedLinePosition();
didChange();
}
void TextTrackCue::setPosition(int position, ExceptionCode& ec)
{
if (position < 0 || position > 100) {
ec = INDEX_SIZE_ERR;
return;
}
if (m_textPosition == position)
return;
willChange();
m_textPosition = position;
didChange();
}
void TextTrackCue::setSize(int size, ExceptionCode& ec)
{
if (size < 0 || size > 100) {
ec = INDEX_SIZE_ERR;
return;
}
if (m_cueSize == size)
return;
willChange();
m_cueSize = size;
didChange();
}
const String& TextTrackCue::align() const
{
switch (m_cueAlignment) {
case Start:
return startKeyword();
case Middle:
return middleKeyword();
case End:
return endKeyword();
default:
ASSERT_NOT_REACHED();
return emptyString();
}
}
void TextTrackCue::setAlign(const String& value, ExceptionCode& ec)
{
CueAlignment alignment = m_cueAlignment;
if (value == startKeyword())
alignment = Start;
else if (value == middleKeyword())
alignment = Middle;
else if (value == endKeyword())
alignment = End;
else
ec = SYNTAX_ERR;
if (alignment == m_cueAlignment)
return;
willChange();
m_cueAlignment = alignment;
didChange();
}
void TextTrackCue::setText(const String& text)
{
if (m_content == text)
return;
willChange();
m_webVTTNodeTree = 0;
m_content = text;
didChange();
}
int TextTrackCue::cueIndex()
{
if (m_cueIndex == invalidCueIndex) {
ASSERT(track());
ASSERT(track()->cues());
if (TextTrackCueList* cueList = track()->cues())
m_cueIndex = cueList->getCueIndex(this);
}
return m_cueIndex;
}
void TextTrackCue::invalidateCueIndex()
{
m_cueIndex = invalidCueIndex;
}
void TextTrackCue::createWebVTTNodeTree()
{
if (!m_webVTTNodeTree)
m_webVTTNodeTree = WebVTTParser::create(0, m_scriptExecutionContext)->createDocumentFragmentFromCueText(m_content);
}
void TextTrackCue::copyWebVTTNodeToDOMTree(ContainerNode* webVTTNode, ContainerNode* parent)
{
for (Node* node = webVTTNode->firstChild(); node; node = node->nextSibling()) {
RefPtr<Node> clonedNode;
if (node->isWebVTTElement())
clonedNode = toWebVTTElement(node)->createEquivalentHTMLElement(ownerDocument());
else
clonedNode = node->cloneNode(false);
parent->appendChild(clonedNode, ASSERT_NO_EXCEPTION);
if (node->isContainerNode())
copyWebVTTNodeToDOMTree(toContainerNode(node), toContainerNode(clonedNode.get()));
}
}
PassRefPtr<DocumentFragment> TextTrackCue::getCueAsHTML()
{
createWebVTTNodeTree();
if (!m_webVTTNodeTree)
return 0;
RefPtr<DocumentFragment> clonedFragment = DocumentFragment::create(ownerDocument());
copyWebVTTNodeToDOMTree(m_webVTTNodeTree.get(), clonedFragment.get());
return clonedFragment.release();
}
PassRefPtr<DocumentFragment> TextTrackCue::createCueRenderingTree()
{
RefPtr<DocumentFragment> clonedFragment;
createWebVTTNodeTree();
if (!m_webVTTNodeTree)
return 0;
clonedFragment = DocumentFragment::create(ownerDocument());
m_webVTTNodeTree->cloneChildNodes(clonedFragment.get());
return clonedFragment.release();
}
bool TextTrackCue::dispatchEvent(PassRefPtr<Event> event)
{
if (!track() || track()->mode() == TextTrack::disabledKeyword())
return false;
return EventTarget::dispatchEvent(event);
}
#if ENABLE(WEBVTT_REGIONS)
void TextTrackCue::setRegionId(const String& regionId)
{
if (m_regionId == regionId)
return;
willChange();
m_regionId = regionId;
didChange();
}
#endif
bool TextTrackCue::isActive()
{
return m_isActive && track() && track()->mode() != TextTrack::disabledKeyword();
}
void TextTrackCue::setIsActive(bool active)
{
m_isActive = active;
if (!active) {
displayTreeInternal()->remove(ASSERT_NO_EXCEPTION);
}
}
int TextTrackCue::calculateComputedLinePosition()
{
if (m_linePosition != undefinedPosition)
return m_linePosition;
if (!m_snapToLines)
return 100;
if (!track())
return -1;
int n = track()->trackIndexRelativeToRenderedTracks();
n++;
n = -n;
return n;
}
static bool isCueParagraphSeparator(UChar character)
{
return WTF::Unicode::category(character) & WTF::Unicode::Separator_Paragraph;
}
void TextTrackCue::determineTextDirection()
{
DEFINE_STATIC_LOCAL(const String, rtTag, (ASCIILiteral("rt")));
createWebVTTNodeTree();
if (!m_webVTTNodeTree)
return;
StringBuilder paragraphBuilder;
for (Node* node = m_webVTTNodeTree->firstChild(); node; node = NodeTraversal::next(node, m_webVTTNodeTree.get())) {
if (!node->isTextNode() || node->localName() == rtTag)
continue;
paragraphBuilder.append(node->nodeValue());
}
String paragraph = paragraphBuilder.toString();
if (!paragraph.length())
return;
for (size_t i = 0; i < paragraph.length(); ++i) {
UChar current = paragraph[i];
if (!current || isCueParagraphSeparator(current))
return;
if (UChar current = paragraph[i]) {
WTF::Unicode::Direction charDirection = WTF::Unicode::direction(current);
if (charDirection == WTF::Unicode::LeftToRight) {
m_displayDirection = CSSValueLtr;
return;
}
if (charDirection == WTF::Unicode::RightToLeft
|| charDirection == WTF::Unicode::RightToLeftArabic) {
m_displayDirection = CSSValueRtl;
return;
}
}
}
}
void TextTrackCue::calculateDisplayParameters()
{
determineTextDirection();
m_displayWritingMode = m_displayWritingModeMap[m_writingDirection];
int maximumSize = m_textPosition;
if ((m_writingDirection == Horizontal && m_cueAlignment == Start && m_displayDirection == CSSValueLtr)
|| (m_writingDirection == Horizontal && m_cueAlignment == End && m_displayDirection == CSSValueRtl)
|| (m_writingDirection == VerticalGrowingLeft && m_cueAlignment == Start)
|| (m_writingDirection == VerticalGrowingRight && m_cueAlignment == Start)) {
maximumSize = 100 - m_textPosition;
} else if ((m_writingDirection == Horizontal && m_cueAlignment == End && m_displayDirection == CSSValueLtr)
|| (m_writingDirection == Horizontal && m_cueAlignment == Start && m_displayDirection == CSSValueRtl)
|| (m_writingDirection == VerticalGrowingLeft && m_cueAlignment == End)
|| (m_writingDirection == VerticalGrowingRight && m_cueAlignment == End)) {
maximumSize = m_textPosition;
} else if (m_cueAlignment == Middle) {
maximumSize = m_textPosition <= 50 ? m_textPosition : (100 - m_textPosition);
maximumSize = maximumSize * 2;
}
m_displaySize = std::min(m_cueSize, maximumSize);
if (m_writingDirection == Horizontal) {
if (m_cueAlignment == Start) {
if (m_displayDirection == CSSValueLtr)
m_displayPosition.first = m_textPosition;
else
m_displayPosition.first = 100 - m_textPosition - m_displaySize;
} else if (m_cueAlignment == End) {
if (m_displayDirection == CSSValueRtl)
m_displayPosition.first = 100 - m_textPosition;
else
m_displayPosition.first = m_textPosition - m_displaySize;
}
}
if ((m_writingDirection == VerticalGrowingLeft && m_cueAlignment == Start)
|| (m_writingDirection == VerticalGrowingRight && m_cueAlignment == Start)) {
m_displayPosition.second = m_textPosition;
} else if ((m_writingDirection == VerticalGrowingLeft && m_cueAlignment == End)
|| (m_writingDirection == VerticalGrowingRight && m_cueAlignment == End)) {
m_displayPosition.second = 100 - m_textPosition;
}
if (m_writingDirection == Horizontal && m_cueAlignment == Middle) {
if (m_displayDirection == CSSValueLtr)
m_displayPosition.first = m_textPosition - m_displaySize / 2;
else
m_displayPosition.first = 100 - m_textPosition - m_displaySize / 2;
}
if ((m_writingDirection == VerticalGrowingLeft && m_cueAlignment == Middle)
|| (m_writingDirection == VerticalGrowingRight && m_cueAlignment == Middle))
m_displayPosition.second = m_textPosition - m_displaySize / 2;
if (m_snapToLines && m_displayPosition.second == undefinedPosition && m_writingDirection == Horizontal)
m_displayPosition.second = 0;
if (!m_snapToLines && m_displayPosition.second == undefinedPosition && m_writingDirection == Horizontal)
m_displayPosition.second = m_computedLinePosition;
if (m_snapToLines && m_displayPosition.first == undefinedPosition
&& (m_writingDirection == VerticalGrowingLeft || m_writingDirection == VerticalGrowingRight))
m_displayPosition.first = 0;
if (!m_snapToLines && (m_writingDirection == VerticalGrowingLeft || m_writingDirection == VerticalGrowingRight))
m_displayPosition.first = m_computedLinePosition;
m_computedLinePosition = calculateComputedLinePosition();
}
void TextTrackCue::markFutureAndPastNodes(ContainerNode* root, double previousTimestamp, double movieTime)
{
DEFINE_STATIC_LOCAL(const String, timestampTag, (ASCIILiteral("timestamp")));
bool isPastNode = true;
double currentTimestamp = previousTimestamp;
if (currentTimestamp > movieTime)
isPastNode = false;
for (Node* child = root->firstChild(); child; child = NodeTraversal::next(child, root)) {
if (child->nodeName() == timestampTag) {
unsigned position = 0;
String timestamp = child->nodeValue();
double currentTimestamp = WebVTTParser::create(0, m_scriptExecutionContext)->collectTimeStamp(timestamp, &position);
ASSERT(currentTimestamp != -1);
if (currentTimestamp > movieTime)
isPastNode = false;
}
if (child->isWebVTTElement()) {
toWebVTTElement(child)->setIsPastNode(isPastNode);
if (!m_id.isEmpty())
toElement(child)->setIdAttribute(AtomicString(m_id.characters(), m_id.length()));
}
}
}
void TextTrackCue::updateDisplayTree(double movieTime)
{
if (!track()->isRendered())
return;
m_cueBackgroundBox->removeChildren();
RefPtr<DocumentFragment> referenceTree = createCueRenderingTree();
if (!referenceTree)
return;
markFutureAndPastNodes(referenceTree.get(), startTime(), movieTime);
m_cueBackgroundBox->appendChild(referenceTree);
}
TextTrackCueBox* TextTrackCue::getDisplayTree(const IntSize& videoSize)
{
RefPtr<TextTrackCueBox> displayTree = displayTreeInternal();
if (!m_displayTreeShouldChange || !track()->isRendered())
return displayTree.get();
calculateDisplayParameters();
displayTree->removeChildren();
m_cueBackgroundBox->setPseudo(cueShadowPseudoId());
displayTree->appendChild(m_cueBackgroundBox, ASSERT_NO_EXCEPTION, AttachLazily);
displayTree->applyCSSProperties(videoSize);
m_displayTreeShouldChange = false;
return displayTree.get();
}
void TextTrackCue::removeDisplayTree()
{
displayTreeInternal()->remove(ASSERT_NO_EXCEPTION);
}
std::pair<double, double> TextTrackCue::getPositionCoordinates() const
{
std::pair<double, double> coordinates;
if (m_writingDirection == Horizontal && m_displayDirection == CSSValueLtr) {
coordinates.first = m_textPosition;
coordinates.second = m_computedLinePosition;
return coordinates;
}
if (m_writingDirection == Horizontal && m_displayDirection == CSSValueRtl) {
coordinates.first = 100 - m_textPosition;
coordinates.second = m_computedLinePosition;
return coordinates;
}
if (m_writingDirection == VerticalGrowingLeft) {
coordinates.first = 100 - m_computedLinePosition;
coordinates.second = m_textPosition;
return coordinates;
}
if (m_writingDirection == VerticalGrowingRight) {
coordinates.first = m_computedLinePosition;
coordinates.second = m_textPosition;
return coordinates;
}
ASSERT_NOT_REACHED();
return coordinates;
}
TextTrackCue::CueSetting TextTrackCue::settingName(const String& name)
{
DEFINE_STATIC_LOCAL(const String, verticalKeyword, (ASCIILiteral("vertical")));
DEFINE_STATIC_LOCAL(const String, lineKeyword, (ASCIILiteral("line")));
DEFINE_STATIC_LOCAL(const String, positionKeyword, (ASCIILiteral("position")));
DEFINE_STATIC_LOCAL(const String, sizeKeyword, (ASCIILiteral("size")));
DEFINE_STATIC_LOCAL(const String, alignKeyword, (ASCIILiteral("align")));
#if ENABLE(WEBVTT_REGIONS)
DEFINE_STATIC_LOCAL(const String, regionIdKeyword, (ASCIILiteral("region")));
#endif
if (name == verticalKeyword)
return Vertical;
else if (name == lineKeyword)
return Line;
else if (name == positionKeyword)
return Position;
else if (name == sizeKeyword)
return Size;
else if (name == alignKeyword)
return Align;
#if ENABLE(WEBVTT_REGIONS)
else if (name == regionIdKeyword)
return RegionId;
#endif
return None;
}
void TextTrackCue::setCueSettings(const String& input)
{
m_settings = input;
unsigned position = 0;
while (position < input.length()) {
while (position < input.length() && WebVTTParser::isValidSettingDelimiter(input[position]))
position++;
if (position >= input.length())
break;
unsigned endOfSetting = position;
String setting = WebVTTParser::collectWord(input, &endOfSetting);
CueSetting name;
size_t colonOffset = setting.find(':', 1);
if (colonOffset == notFound || colonOffset == 0 || colonOffset == setting.length() - 1)
goto NextSetting;
name = settingName(setting.substring(0, colonOffset));
position += colonOffset + 1;
if (position >= input.length())
break;
switch (name) {
case Vertical:
{
String writingDirection = WebVTTParser::collectWord(input, &position);
if (writingDirection == verticalGrowingLeftKeyword())
m_writingDirection = VerticalGrowingLeft;
else if (writingDirection == verticalGrowingRightKeyword())
m_writingDirection = VerticalGrowingRight;
}
break;
case Line:
{
StringBuilder linePositionBuilder;
while (position < input.length() && (input[position] == '-' || input[position] == '%' || isASCIIDigit(input[position])))
linePositionBuilder.append(input[position++]);
if (position < input.length() && !WebVTTParser::isValidSettingDelimiter(input[position]))
break;
String linePosition = linePositionBuilder.toString();
if (linePosition.find('-', 1) != notFound || linePosition.reverseFind("%", linePosition.length() - 2) != notFound)
break;
if (linePosition[0] == '-' && linePosition[linePosition.length() - 1] == '%')
break;
bool validNumber;
int number = linePosition.toInt(&validNumber);
if (!validNumber)
break;
if (linePosition[linePosition.length() - 1] == '%') {
if (number < 0 || number > 100)
break;
m_snapToLines = false;
}
m_linePosition = number;
}
break;
case Position:
{
String textPosition = WebVTTParser::collectDigits(input, &position);
if (textPosition.isEmpty())
break;
if (position >= input.length())
break;
if (input[position++] != '%')
break;
if (position < input.length() && !WebVTTParser::isValidSettingDelimiter(input[position]))
break;
bool validNumber;
int number = textPosition.toInt(&validNumber);
if (!validNumber)
break;
if (number < 0 || number > 100)
break;
m_textPosition = number;
}
break;
case Size:
{
String cueSize = WebVTTParser::collectDigits(input, &position);
if (cueSize.isEmpty())
break;
if (position >= input.length())
break;
if (input[position++] != '%')
break;
if (position < input.length() && !WebVTTParser::isValidSettingDelimiter(input[position]))
break;
bool validNumber;
int number = cueSize.toInt(&validNumber);
if (!validNumber)
break;
if (number < 0 || number > 100)
break;
m_cueSize = number;
}
break;
case Align:
{
String cueAlignment = WebVTTParser::collectWord(input, &position);
if (cueAlignment == startKeyword())
m_cueAlignment = Start;
else if (cueAlignment == middleKeyword())
m_cueAlignment = Middle;
else if (cueAlignment == endKeyword())
m_cueAlignment = End;
}
break;
#if ENABLE(WEBVTT_REGIONS)
case RegionId:
m_regionId = WebVTTParser::collectWord(input, &position);
break;
#endif
case None:
break;
}
NextSetting:
position = endOfSetting;
}
#if ENABLE(WEBVTT_REGIONS)
if (m_regionId.isEmpty())
return;
if (m_linePosition != undefinedPosition || m_cueSize != 100 || m_writingDirection != Horizontal)
m_regionId = emptyString();
#endif
}
int TextTrackCue::getCSSWritingDirection() const
{
return m_displayDirection;
}
int TextTrackCue::getCSSWritingMode() const
{
return m_displayWritingMode;
}
int TextTrackCue::getCSSSize() const
{
return m_displaySize;
}
std::pair<double, double> TextTrackCue::getCSSPosition() const
{
if (!m_snapToLines)
return getPositionCoordinates();
return m_displayPosition;
}
const AtomicString& TextTrackCue::interfaceName() const
{
return eventNames().interfaceForTextTrackCue;
}
ScriptExecutionContext* TextTrackCue::scriptExecutionContext() const
{
return m_scriptExecutionContext;
}
EventTargetData* TextTrackCue::eventTargetData()
{
return &m_eventTargetData;
}
EventTargetData* TextTrackCue::ensureEventTargetData()
{
return &m_eventTargetData;
}
bool TextTrackCue::isEqual(const TextTrackCue& cue, CueMatchRules match) const
{
if (cueType() != cue.cueType())
return false;
if (match != IgnoreDuration && m_endTime != cue.endTime())
return false;
if (m_startTime != cue.startTime())
return false;
if (m_content != cue.text())
return false;
if (m_settings != cue.cueSettings())
return false;
if (m_id != cue.id())
return false;
if (m_textPosition != cue.position())
return false;
if (m_linePosition != cue.line())
return false;
if (m_cueSize != cue.size())
return false;
if (align() != cue.align())
return false;
return true;
}
bool TextTrackCue::isOrderedBefore(const TextTrackCue* other) const
{
return startTime() < other->startTime() || (startTime() == other->startTime() && endTime() > other->endTime());
}
void TextTrackCue::setFontSize(int fontSize, const IntSize&, bool important)
{
if (!hasDisplayTree() || !fontSize)
return;
LOG(Media, "TextTrackCue::setFontSize - setting cue font size to %i", fontSize);
displayTreeInternal()->setInlineStyleProperty(CSSPropertyFontSize, String::number(fontSize) + "px", important);
}
}
#endif