| // 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 |
