blob: 3a447f7855f0d15a853922bc6bfc7f5903eaf645 [file] [log] [blame]
// Copyright 2017 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <string>
#include "base/compiler_specific.h"
#include "base/logging.h"
#include "cobalt/base/accessibility_caption_settings_changed_event.h"
#include "cobalt/base/event_dispatcher.h"
#include "cobalt/dom/captions/caption_character_edge_style.h"
#include "cobalt/dom/captions/caption_color.h"
#include "cobalt/dom/captions/caption_font_family.h"
#include "cobalt/dom/captions/caption_font_size_percentage.h"
#include "cobalt/dom/captions/caption_opacity_percentage.h"
#include "cobalt/dom/captions/caption_state.h"
#include "cobalt/dom/captions/system_caption_settings.h"
#include "cobalt/dom/event_target.h"
#include "starboard/accessibility.h"
#include "starboard/memory.h"
namespace cobalt {
namespace dom {
namespace captions {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
namespace {
CaptionColor ToCobaltCaptionColor(SbAccessibilityCaptionColor color) {
switch (color) {
case kSbAccessibilityCaptionColorBlue:
return CaptionColor::kCaptionColorBlue;
case kSbAccessibilityCaptionColorBlack:
return CaptionColor::kCaptionColorBlack;
case kSbAccessibilityCaptionColorCyan:
return CaptionColor::kCaptionColorCyan;
case kSbAccessibilityCaptionColorGreen:
return CaptionColor::kCaptionColorGreen;
case kSbAccessibilityCaptionColorMagenta:
return CaptionColor::kCaptionColorMagenta;
case kSbAccessibilityCaptionColorRed:
return CaptionColor::kCaptionColorRed;
case kSbAccessibilityCaptionColorWhite:
return CaptionColor::kCaptionColorWhite;
case kSbAccessibilityCaptionColorYellow:
return CaptionColor::kCaptionColorYellow;
default:
NOTREACHED() << "Invalid color conversion";
return CaptionColor::kCaptionColorWhite;
}
}
CaptionCharacterEdgeStyle ToCobaltCaptionCharacterEdgeStyle(
SbAccessibilityCaptionCharacterEdgeStyle style) {
switch (style) {
case kSbAccessibilityCaptionCharacterEdgeStyleNone:
return CaptionCharacterEdgeStyle::kCaptionCharacterEdgeStyleNone;
case kSbAccessibilityCaptionCharacterEdgeStyleRaised:
return CaptionCharacterEdgeStyle::kCaptionCharacterEdgeStyleRaised;
case kSbAccessibilityCaptionCharacterEdgeStyleDepressed:
return CaptionCharacterEdgeStyle::kCaptionCharacterEdgeStyleDepressed;
case kSbAccessibilityCaptionCharacterEdgeStyleUniform:
return CaptionCharacterEdgeStyle::kCaptionCharacterEdgeStyleUniform;
case kSbAccessibilityCaptionCharacterEdgeStyleDropShadow:
return CaptionCharacterEdgeStyle::kCaptionCharacterEdgeStyleDropShadow;
default:
NOTREACHED() << "Invalid character edge style conversion";
return CaptionCharacterEdgeStyle::kCaptionCharacterEdgeStyleNone;
}
}
CaptionFontFamily ToCobaltCaptionFontFamily(
SbAccessibilityCaptionFontFamily font_family) {
switch (font_family) {
case kSbAccessibilityCaptionFontFamilyCasual:
return CaptionFontFamily::kCaptionFontFamilyCasual;
case kSbAccessibilityCaptionFontFamilyCursive:
return CaptionFontFamily::kCaptionFontFamilyCursive;
case kSbAccessibilityCaptionFontFamilyMonospaceSansSerif:
return CaptionFontFamily::kCaptionFontFamilyMonospaceSansSerif;
case kSbAccessibilityCaptionFontFamilyMonospaceSerif:
return CaptionFontFamily::kCaptionFontFamilyMonospaceSerif;
case kSbAccessibilityCaptionFontFamilyProportionalSansSerif:
return CaptionFontFamily::kCaptionFontFamilyProportionalSerif;
case kSbAccessibilityCaptionFontFamilyProportionalSerif:
return CaptionFontFamily::kCaptionFontFamilyProportionalSansSerif;
case kSbAccessibilityCaptionFontFamilySmallCapitals:
return CaptionFontFamily::kCaptionFontFamilySmallCapitals;
default:
NOTREACHED() << "Invalid font family conversion";
return CaptionFontFamily::kCaptionFontFamilyCasual;
}
}
CaptionFontSizePercentage ToCobaltCaptionFontSizePercentage(int font_size) {
switch (font_size) {
case kSbAccessibilityCaptionFontSizePercentage25:
return CaptionFontSizePercentage::kCaptionFontSizePercentage25;
case kSbAccessibilityCaptionFontSizePercentage50:
return CaptionFontSizePercentage::kCaptionFontSizePercentage50;
case kSbAccessibilityCaptionFontSizePercentage75:
return CaptionFontSizePercentage::kCaptionFontSizePercentage75;
case kSbAccessibilityCaptionFontSizePercentage100:
return CaptionFontSizePercentage::kCaptionFontSizePercentage100;
case kSbAccessibilityCaptionFontSizePercentage125:
return CaptionFontSizePercentage::kCaptionFontSizePercentage125;
case kSbAccessibilityCaptionFontSizePercentage150:
return CaptionFontSizePercentage::kCaptionFontSizePercentage150;
case kSbAccessibilityCaptionFontSizePercentage175:
return CaptionFontSizePercentage::kCaptionFontSizePercentage175;
case kSbAccessibilityCaptionFontSizePercentage200:
return CaptionFontSizePercentage::kCaptionFontSizePercentage200;
case kSbAccessibilityCaptionFontSizePercentage225:
return CaptionFontSizePercentage::kCaptionFontSizePercentage225;
case kSbAccessibilityCaptionFontSizePercentage250:
return CaptionFontSizePercentage::kCaptionFontSizePercentage250;
case kSbAccessibilityCaptionFontSizePercentage275:
return CaptionFontSizePercentage::kCaptionFontSizePercentage275;
case kSbAccessibilityCaptionFontSizePercentage300:
return CaptionFontSizePercentage::kCaptionFontSizePercentage300;
default:
NOTREACHED() << "Invalid font size percentage conversion";
return CaptionFontSizePercentage::kCaptionFontSizePercentage100;
}
}
CaptionOpacityPercentage ToCobaltCaptionOpacityPercentage(
SbAccessibilityCaptionOpacityPercentage opacity) {
switch (opacity) {
case kSbAccessibilityCaptionOpacityPercentage0:
return CaptionOpacityPercentage::kCaptionOpacityPercentage0;
case kSbAccessibilityCaptionOpacityPercentage25:
return CaptionOpacityPercentage::kCaptionOpacityPercentage25;
case kSbAccessibilityCaptionOpacityPercentage50:
return CaptionOpacityPercentage::kCaptionOpacityPercentage50;
case kSbAccessibilityCaptionOpacityPercentage75:
return CaptionOpacityPercentage::kCaptionOpacityPercentage75;
case kSbAccessibilityCaptionOpacityPercentage100:
return CaptionOpacityPercentage::kCaptionOpacityPercentage100;
default:
NOTREACHED() << "Invalid opacity conversion";
return CaptionOpacityPercentage::kCaptionOpacityPercentage100;
}
}
CaptionState ToCobaltCaptionState(SbAccessibilityCaptionState state) {
switch (state) {
case kSbAccessibilityCaptionStateUnsupported:
return CaptionState::kCaptionStateUnsupported;
case kSbAccessibilityCaptionStateUnset:
return CaptionState::kCaptionStateUnset;
case kSbAccessibilityCaptionStateSet:
return CaptionState::kCaptionStateSet;
case kSbAccessibilityCaptionStateOverride:
return CaptionState::kCaptionStateOverride;
default:
NOTREACHED() << "Invalid caption state conversion";
return CaptionState::kCaptionStateUnsupported;
}
}
} // namespace
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
void SystemCaptionSettings::OnCaptionSettingsChanged() {
DispatchEventNameAndRunCallback(
base::Tokens::change(),
base::Closure(base::Bind([]() {} /*Do nothing*/)));
}
base::Optional<std::string> SystemCaptionSettings::background_color() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (!success) {
return base::nullopt;
}
DCHECK(caption_settings.background_color_state !=
kSbAccessibilityCaptionStateUnsupported);
const char* color = SystemCaptionSettings::CaptionColorToString(
ToCobaltCaptionColor(caption_settings.background_color));
if (color == nullptr) {
return base::nullopt;
} else {
return std::string(color);
}
#else
return base::nullopt;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
CaptionState SystemCaptionSettings::background_color_state() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (success) {
return ToCobaltCaptionState(caption_settings.background_color_state);
} else {
return CaptionState::kCaptionStateUnsupported;
}
#else
return CaptionState::kCaptionStateUnsupported;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
base::Optional<std::string> SystemCaptionSettings::background_opacity() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (!success) {
return base::nullopt;
}
DCHECK(caption_settings.background_opacity_state !=
kSbAccessibilityCaptionStateUnsupported);
const char* opacity = SystemCaptionSettings::CaptionOpacityPercentageToString(
ToCobaltCaptionOpacityPercentage(caption_settings.background_opacity));
if (opacity == nullptr) {
return base::nullopt;
} else {
return std::string(opacity);
}
#else
return base::nullopt;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
CaptionState SystemCaptionSettings::background_opacity_state() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (success) {
return ToCobaltCaptionState(caption_settings.background_opacity_state);
} else {
return CaptionState::kCaptionStateUnsupported;
}
#else
return CaptionState::kCaptionStateUnsupported;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
base::Optional<std::string> SystemCaptionSettings::character_edge_style() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (!success) {
return base::nullopt;
}
DCHECK(caption_settings.character_edge_style_state !=
kSbAccessibilityCaptionStateUnsupported);
const char* character_edge_style =
SystemCaptionSettings::CaptionCharacterEdgeStyleToString(
ToCobaltCaptionCharacterEdgeStyle(
caption_settings.character_edge_style));
if (character_edge_style == nullptr) {
return base::nullopt;
} else {
return std::string(character_edge_style);
}
#else
return base::nullopt;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
CaptionState SystemCaptionSettings::character_edge_style_state() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (success) {
return ToCobaltCaptionState(caption_settings.character_edge_style_state);
} else {
return CaptionState::kCaptionStateUnsupported;
}
#else
return CaptionState::kCaptionStateUnsupported;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
base::Optional<std::string> SystemCaptionSettings::font_color() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (!success) {
return base::nullopt;
}
DCHECK(caption_settings.font_color_state !=
kSbAccessibilityCaptionStateUnsupported);
const char* color = SystemCaptionSettings::CaptionColorToString(
ToCobaltCaptionColor(caption_settings.font_color));
if (color == nullptr) {
return base::nullopt;
} else {
return std::string(color);
}
#else
return base::nullopt;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
CaptionState SystemCaptionSettings::font_color_state() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (success) {
return ToCobaltCaptionState(caption_settings.font_color_state);
} else {
return CaptionState::kCaptionStateUnsupported;
}
#else
return CaptionState::kCaptionStateUnsupported;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
base::Optional<std::string> SystemCaptionSettings::font_family() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (!success) {
return base::nullopt;
}
DCHECK(caption_settings.font_family_state !=
kSbAccessibilityCaptionStateUnsupported);
const char* font_family = SystemCaptionSettings::CaptionFontFamilyToString(
ToCobaltCaptionFontFamily(caption_settings.font_family));
if (font_family == nullptr) {
return base::nullopt;
} else {
return std::string(font_family);
}
#else
return base::nullopt;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
CaptionState SystemCaptionSettings::font_family_state() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (success) {
return ToCobaltCaptionState(caption_settings.font_family_state);
} else {
return CaptionState::kCaptionStateUnsupported;
}
#else
return CaptionState::kCaptionStateUnsupported;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
base::Optional<std::string> SystemCaptionSettings::font_opacity() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (!success) {
return base::nullopt;
}
DCHECK(caption_settings.font_opacity_state !=
kSbAccessibilityCaptionStateUnsupported);
const char* opacity = SystemCaptionSettings::CaptionOpacityPercentageToString(
ToCobaltCaptionOpacityPercentage(caption_settings.font_opacity));
if (opacity == nullptr) {
return base::nullopt;
} else {
return std::string(opacity);
}
#else
return base::nullopt;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
CaptionState SystemCaptionSettings::font_opacity_state() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (success) {
return ToCobaltCaptionState(caption_settings.font_opacity_state);
} else {
return CaptionState::kCaptionStateUnsupported;
}
#else
return CaptionState::kCaptionStateUnsupported;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
base::Optional<std::string> SystemCaptionSettings::font_size() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (!success) {
return base::nullopt;
}
DCHECK(caption_settings.font_size_state !=
kSbAccessibilityCaptionStateUnsupported);
const char* font_size =
SystemCaptionSettings::CaptionFontSizePercentageToString(
ToCobaltCaptionFontSizePercentage(caption_settings.font_size));
if (font_size == nullptr) {
return base::nullopt;
} else {
return std::string(font_size);
}
#else
return base::nullopt;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
CaptionState SystemCaptionSettings::font_size_state() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (success) {
return ToCobaltCaptionState(caption_settings.font_size_state);
} else {
return CaptionState::kCaptionStateUnsupported;
}
#else
return CaptionState::kCaptionStateUnsupported;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
base::Optional<std::string> SystemCaptionSettings::window_color() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (!success) {
return base::nullopt;
}
DCHECK(caption_settings.window_color_state !=
kSbAccessibilityCaptionStateUnsupported);
const char* color = SystemCaptionSettings::CaptionColorToString(
ToCobaltCaptionColor(caption_settings.window_color));
if (color == nullptr) {
return base::nullopt;
} else {
return std::string(color);
}
#else
return base::nullopt;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
CaptionState SystemCaptionSettings::window_color_state() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (success) {
return ToCobaltCaptionState(caption_settings.window_color_state);
} else {
return CaptionState::kCaptionStateUnsupported;
}
#else
return CaptionState::kCaptionStateUnsupported;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
base::Optional<std::string> SystemCaptionSettings::window_opacity() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (!success) {
return base::nullopt;
}
DCHECK(caption_settings.window_opacity_state !=
kSbAccessibilityCaptionStateUnsupported);
const char* opacity = SystemCaptionSettings::CaptionOpacityPercentageToString(
ToCobaltCaptionOpacityPercentage(caption_settings.window_opacity));
if (opacity == nullptr) {
return base::nullopt;
} else {
return std::string(opacity);
}
#else
return base::nullopt;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
CaptionState SystemCaptionSettings::window_opacity_state() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
if (success) {
return ToCobaltCaptionState(caption_settings.window_opacity_state);
} else {
return CaptionState::kCaptionStateUnsupported;
}
#else
return CaptionState::kCaptionStateUnsupported;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
bool SystemCaptionSettings::is_enabled() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
DCHECK(supports_is_enabled());
return (success && caption_settings.supports_is_enabled) ?
caption_settings.is_enabled : false;
#else
return false;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
void SystemCaptionSettings::set_is_enabled(bool active) {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
DCHECK(supports_set_enabled());
SbAccessibilitySetCaptionsEnabled(active);
#else
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
bool SystemCaptionSettings::supports_is_enabled() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
return (success) ? caption_settings.supports_is_enabled : false;
#else
return false;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
bool SystemCaptionSettings::supports_set_enabled() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
return (success) ? caption_settings.supports_set_enabled : false;
#else
return false;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
bool SystemCaptionSettings::supports_override() {
#if SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
SbAccessibilityCaptionSettings caption_settings;
memset(&caption_settings, 0, sizeof(caption_settings));
bool success = SbAccessibilityGetCaptionSettings(&caption_settings);
return (success) ? caption_settings.supports_override : false;
#else
return false;
#endif // SB_API_VERSION >= 12 || SB_HAS(CAPTIONS)
}
const EventTarget::EventListenerScriptValue* SystemCaptionSettings::onchanged()
const {
return EventTarget::GetAttributeEventListener(base::Tokens::change());
}
void SystemCaptionSettings::set_onchanged(
const EventTarget::EventListenerScriptValue& event_listener) {
EventTarget::SetAttributeEventListener(base::Tokens::change(),
event_listener);
}
const char* SystemCaptionSettings::CaptionCharacterEdgeStyleToString(
CaptionCharacterEdgeStyle character_edge_style) {
switch (character_edge_style) {
case CaptionCharacterEdgeStyle::kCaptionCharacterEdgeStyleNone:
return "none";
case CaptionCharacterEdgeStyle::kCaptionCharacterEdgeStyleRaised:
return "raised";
case CaptionCharacterEdgeStyle::kCaptionCharacterEdgeStyleDepressed:
return "depressed";
case CaptionCharacterEdgeStyle::kCaptionCharacterEdgeStyleUniform:
return "uniform";
case CaptionCharacterEdgeStyle::kCaptionCharacterEdgeStyleDropShadow:
return "drop-shadow";
default:
NOTREACHED() << "Invalid character edge style";
return nullptr;
}
}
const char* SystemCaptionSettings::CaptionColorToString(CaptionColor color) {
switch (color) {
case CaptionColor::kCaptionColorBlue:
return "blue";
case CaptionColor::kCaptionColorBlack:
return "black";
case CaptionColor::kCaptionColorCyan:
return "cyan";
case CaptionColor::kCaptionColorGreen:
return "green";
case CaptionColor::kCaptionColorMagenta:
return "magenta";
case CaptionColor::kCaptionColorRed:
return "red";
case CaptionColor::kCaptionColorWhite:
return "white";
case CaptionColor::kCaptionColorYellow:
return "yellow";
default:
NOTREACHED() << "Invalid color";
return nullptr;
}
}
const char* SystemCaptionSettings::CaptionFontFamilyToString(
CaptionFontFamily font_family) {
switch (font_family) {
case CaptionFontFamily::kCaptionFontFamilyCasual:
return "casual";
case CaptionFontFamily::kCaptionFontFamilyCursive:
return "cursive";
case CaptionFontFamily::kCaptionFontFamilyMonospaceSansSerif:
return "monospace-sans-serif";
case CaptionFontFamily::kCaptionFontFamilyMonospaceSerif:
return "monospace-serif";
case CaptionFontFamily::kCaptionFontFamilyProportionalSansSerif:
return "proportional-sans-serif";
case CaptionFontFamily::kCaptionFontFamilyProportionalSerif:
return "proportional-serif";
case CaptionFontFamily::kCaptionFontFamilySmallCapitals:
return "small-capitals";
default:
NOTREACHED() << "Invalid font family";
return nullptr;
}
}
const char* SystemCaptionSettings::CaptionFontSizePercentageToString(
CaptionFontSizePercentage font_size) {
switch (font_size) {
case CaptionFontSizePercentage::kCaptionFontSizePercentage25:
return "25";
case CaptionFontSizePercentage::kCaptionFontSizePercentage50:
return "50";
case CaptionFontSizePercentage::kCaptionFontSizePercentage75:
return "75";
case CaptionFontSizePercentage::kCaptionFontSizePercentage100:
return "100";
case CaptionFontSizePercentage::kCaptionFontSizePercentage125:
return "125";
case CaptionFontSizePercentage::kCaptionFontSizePercentage150:
return "150";
case CaptionFontSizePercentage::kCaptionFontSizePercentage175:
return "175";
case CaptionFontSizePercentage::kCaptionFontSizePercentage200:
return "200";
case CaptionFontSizePercentage::kCaptionFontSizePercentage225:
return "225";
case CaptionFontSizePercentage::kCaptionFontSizePercentage250:
return "250";
case CaptionFontSizePercentage::kCaptionFontSizePercentage275:
return "275";
case CaptionFontSizePercentage::kCaptionFontSizePercentage300:
return "300";
default:
NOTREACHED() << "Invalid font size";
return nullptr;
}
}
const char* SystemCaptionSettings::CaptionOpacityPercentageToString(
CaptionOpacityPercentage opacity) {
switch (opacity) {
case CaptionOpacityPercentage::kCaptionOpacityPercentage0:
return "0";
case CaptionOpacityPercentage::kCaptionOpacityPercentage25:
return "25";
case CaptionOpacityPercentage::kCaptionOpacityPercentage50:
return "50";
case CaptionOpacityPercentage::kCaptionOpacityPercentage75:
return "75";
case CaptionOpacityPercentage::kCaptionOpacityPercentage100:
return "100";
default:
NOTREACHED() << "Invalid opacity";
return nullptr;
}
}
} // namespace captions
} // namespace dom
} // namespace cobalt