| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "ppapi/cpp/trusted/browser_font_trusted.h" |
| |
| #include <algorithm> |
| |
| #include "ppapi/c/dev/ppb_font_dev.h" |
| #include "ppapi/cpp/image_data.h" |
| #include "ppapi/cpp/instance_handle.h" |
| #include "ppapi/cpp/point.h" |
| #include "ppapi/cpp/rect.h" |
| #include "ppapi/cpp/module_impl.h" |
| |
| namespace pp { |
| |
| namespace { |
| |
| template <> const char* interface_name<PPB_BrowserFont_Trusted_1_0>() { |
| return PPB_BROWSERFONT_TRUSTED_INTERFACE_1_0; |
| } |
| template <> const char* interface_name<PPB_Font_Dev_0_6>() { |
| return PPB_FONT_DEV_INTERFACE_0_6; |
| } |
| |
| // This class provides backwards compat for PPB_Font, which is binary |
| // compatible with the BrowserFont interface. |
| // TODO(brettw) remove PPB_Font altogether when Flash is updated. |
| const PP_FontDescription_Dev* BrowserFontDescToFontDesc( |
| const PP_BrowserFont_Trusted_Description* desc) { |
| return reinterpret_cast<const PP_FontDescription_Dev*>(desc); |
| } |
| PP_FontDescription_Dev* BrowserFontDescToFontDesc( |
| PP_BrowserFont_Trusted_Description* desc) { |
| return reinterpret_cast<PP_FontDescription_Dev*>(desc); |
| } |
| PP_FontMetrics_Dev* BrowserFontMetricsToFontMetrics( |
| PP_BrowserFont_Trusted_Metrics* metrics) { |
| return reinterpret_cast<PP_FontMetrics_Dev*>(metrics); |
| } |
| const PP_TextRun_Dev* BrowserFontTextRunToFontTextRun( |
| const PP_BrowserFont_Trusted_TextRun* run) { |
| return reinterpret_cast<const PP_TextRun_Dev*>(run); |
| } |
| |
| } // namespace |
| |
| // BrowserFontDescription ------------------------------------------------------ |
| |
| BrowserFontDescription::BrowserFontDescription() { |
| pp_font_description_.face = face_.pp_var(); |
| set_family(PP_BROWSERFONT_TRUSTED_FAMILY_DEFAULT); |
| set_size(0); |
| set_weight(PP_BROWSERFONT_TRUSTED_WEIGHT_NORMAL); |
| set_italic(false); |
| set_small_caps(false); |
| set_letter_spacing(0); |
| set_word_spacing(0); |
| } |
| |
| BrowserFontDescription::BrowserFontDescription( |
| const BrowserFontDescription& other) { |
| set_face(other.face()); |
| set_family(other.family()); |
| set_size(other.size()); |
| set_weight(other.weight()); |
| set_italic(other.italic()); |
| set_small_caps(other.small_caps()); |
| set_letter_spacing(other.letter_spacing()); |
| set_word_spacing(other.word_spacing()); |
| } |
| |
| BrowserFontDescription::~BrowserFontDescription() { |
| } |
| |
| BrowserFontDescription& BrowserFontDescription::operator=( |
| const BrowserFontDescription& other) { |
| pp_font_description_ = other.pp_font_description_; |
| |
| // Be careful about the refcount of the string, the copy that operator= made |
| // above didn't copy a ref. |
| pp_font_description_.face = PP_MakeUndefined(); |
| set_face(other.face()); |
| |
| return *this; |
| } |
| |
| // BrowserFontTextRun ---------------------------------------------------------- |
| |
| BrowserFontTextRun::BrowserFontTextRun() { |
| pp_text_run_.text = text_.pp_var(); |
| pp_text_run_.rtl = PP_FALSE; |
| pp_text_run_.override_direction = PP_FALSE; |
| } |
| |
| BrowserFontTextRun::BrowserFontTextRun(const std::string& text, |
| bool rtl, |
| bool override_direction) |
| : text_(text) { |
| pp_text_run_.text = text_.pp_var(); |
| pp_text_run_.rtl = PP_FromBool(rtl); |
| pp_text_run_.override_direction = PP_FromBool(override_direction); |
| } |
| |
| BrowserFontTextRun::BrowserFontTextRun(const BrowserFontTextRun& other) |
| : text_(other.text_) { |
| pp_text_run_.text = text_.pp_var(); |
| pp_text_run_.rtl = other.pp_text_run_.rtl; |
| pp_text_run_.override_direction = other.pp_text_run_.override_direction; |
| } |
| |
| BrowserFontTextRun::~BrowserFontTextRun() { |
| } |
| |
| BrowserFontTextRun& BrowserFontTextRun::operator=( |
| const BrowserFontTextRun& other) { |
| pp_text_run_ = other.pp_text_run_; |
| text_ = other.text_; |
| pp_text_run_.text = text_.pp_var(); |
| return *this; |
| } |
| |
| // BrowserFont_Trusted --------------------------------------------------------- |
| |
| BrowserFont_Trusted::BrowserFont_Trusted() : Resource() { |
| } |
| |
| BrowserFont_Trusted::BrowserFont_Trusted(PP_Resource resource) |
| : Resource(resource) { |
| } |
| |
| BrowserFont_Trusted::BrowserFont_Trusted( |
| const InstanceHandle& instance, |
| const BrowserFontDescription& description) { |
| if (has_interface<PPB_BrowserFont_Trusted_1_0>()) { |
| PassRefFromConstructor(get_interface<PPB_BrowserFont_Trusted_1_0>()->Create( |
| instance.pp_instance(), |
| &description.pp_font_description())); |
| } else if (!has_interface<PPB_Font_Dev_0_6>()) { |
| PassRefFromConstructor(get_interface<PPB_Font_Dev_0_6>()->Create( |
| instance.pp_instance(), |
| BrowserFontDescToFontDesc(&description.pp_font_description()))); |
| } |
| } |
| |
| BrowserFont_Trusted::BrowserFont_Trusted(const BrowserFont_Trusted& other) |
| : Resource(other) { |
| } |
| |
| BrowserFont_Trusted& BrowserFont_Trusted::operator=( |
| const BrowserFont_Trusted& other) { |
| Resource::operator=(other); |
| return *this; |
| } |
| |
| // static |
| Var BrowserFont_Trusted::GetFontFamilies(const InstanceHandle& instance) { |
| if (!has_interface<PPB_Font_Dev_0_6>()) |
| return Var(); |
| return Var(PASS_REF, |
| get_interface<PPB_Font_Dev_0_6>()->GetFontFamilies( |
| instance.pp_instance())); |
| } |
| |
| bool BrowserFont_Trusted::Describe( |
| BrowserFontDescription* description, |
| PP_BrowserFont_Trusted_Metrics* metrics) const { |
| // Be careful with ownership of the |face| string. It will come back with |
| // a ref of 1, which we want to assign to the |face_| member of the C++ class. |
| if (has_interface<PPB_BrowserFont_Trusted_1_0>()) { |
| if (!get_interface<PPB_BrowserFont_Trusted_1_0>()->Describe( |
| pp_resource(), &description->pp_font_description_, metrics)) |
| return false; |
| } else if (!has_interface<PPB_Font_Dev_0_6>()) { |
| if (!get_interface<PPB_Font_Dev_0_6>()->Describe( |
| pp_resource(), |
| BrowserFontDescToFontDesc(&description->pp_font_description_), |
| BrowserFontMetricsToFontMetrics(metrics))) |
| return false; |
| } |
| description->face_ = Var(PASS_REF, |
| description->pp_font_description_.face); |
| return true; |
| } |
| |
| bool BrowserFont_Trusted::DrawTextAt(ImageData* dest, |
| const BrowserFontTextRun& text, |
| const Point& position, |
| uint32_t color, |
| const Rect& clip, |
| bool image_data_is_opaque) const { |
| if (has_interface<PPB_BrowserFont_Trusted_1_0>()) { |
| return PP_ToBool(get_interface<PPB_BrowserFont_Trusted_1_0>()->DrawTextAt( |
| pp_resource(), |
| dest->pp_resource(), |
| &text.pp_text_run(), |
| &position.pp_point(), |
| color, |
| &clip.pp_rect(), |
| PP_FromBool(image_data_is_opaque))); |
| } else if (!has_interface<PPB_Font_Dev_0_6>()) { |
| return PP_ToBool(get_interface<PPB_Font_Dev_0_6>()->DrawTextAt( |
| pp_resource(), |
| dest->pp_resource(), |
| BrowserFontTextRunToFontTextRun(&text.pp_text_run()), |
| &position.pp_point(), |
| color, |
| &clip.pp_rect(), |
| PP_FromBool(image_data_is_opaque))); |
| } |
| return false; |
| } |
| |
| int32_t BrowserFont_Trusted::MeasureText(const BrowserFontTextRun& text) const { |
| if (has_interface<PPB_BrowserFont_Trusted_1_0>()) { |
| return get_interface<PPB_BrowserFont_Trusted_1_0>()->MeasureText( |
| pp_resource(), |
| &text.pp_text_run()); |
| } else if (!has_interface<PPB_Font_Dev_0_6>()) { |
| return get_interface<PPB_Font_Dev_0_6>()->MeasureText( |
| pp_resource(), |
| BrowserFontTextRunToFontTextRun(&text.pp_text_run())); |
| } |
| return -1; |
| } |
| |
| uint32_t BrowserFont_Trusted::CharacterOffsetForPixel( |
| const BrowserFontTextRun& text, |
| int32_t pixel_position) const { |
| if (has_interface<PPB_BrowserFont_Trusted_1_0>()) { |
| return get_interface<PPB_BrowserFont_Trusted_1_0>()-> |
| CharacterOffsetForPixel( |
| pp_resource(), |
| &text.pp_text_run(), |
| pixel_position); |
| } else if (!has_interface<PPB_Font_Dev_0_6>()) { |
| return get_interface<PPB_Font_Dev_0_6>()->CharacterOffsetForPixel( |
| pp_resource(), |
| BrowserFontTextRunToFontTextRun(&text.pp_text_run()), |
| pixel_position); |
| } |
| return 0; |
| } |
| |
| int32_t BrowserFont_Trusted::PixelOffsetForCharacter( |
| const BrowserFontTextRun& text, |
| uint32_t char_offset) const { |
| if (has_interface<PPB_BrowserFont_Trusted_1_0>()) { |
| return get_interface<PPB_BrowserFont_Trusted_1_0>()-> |
| PixelOffsetForCharacter( |
| pp_resource(), |
| &text.pp_text_run(), |
| char_offset); |
| } else if (!has_interface<PPB_Font_Dev_0_6>()) { |
| return get_interface<PPB_Font_Dev_0_6>()->PixelOffsetForCharacter( |
| pp_resource(), |
| BrowserFontTextRunToFontTextRun(&text.pp_text_run()), |
| char_offset); |
| } |
| return 0; |
| } |
| |
| bool BrowserFont_Trusted::DrawSimpleText( |
| ImageData* dest, |
| const std::string& text, |
| const Point& position, |
| uint32_t color, |
| bool image_data_is_opaque) const { |
| return DrawTextAt(dest, BrowserFontTextRun(text), position, color, |
| Rect(dest->size()), image_data_is_opaque); |
| } |
| |
| int32_t BrowserFont_Trusted::MeasureSimpleText(const std::string& text) const { |
| return MeasureText(BrowserFontTextRun(text)); |
| } |
| |
| } // namespace pp |