| // Copyright (c) 2013 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. |
| |
| #ifndef PPAPI_CPP_TRUETYPE_FONT_H_ |
| #define PPAPI_CPP_TRUETYPE_FONT_H_ |
| |
| #include "ppapi/c/dev/ppb_truetype_font_dev.h" |
| #include "ppapi/c/pp_time.h" |
| #include "ppapi/cpp/completion_callback.h" |
| #include "ppapi/cpp/pass_ref.h" |
| #include "ppapi/cpp/resource.h" |
| |
| /// @file |
| /// This file defines the API to create a TrueType font object. |
| |
| namespace pp { |
| |
| class InstanceHandle; |
| |
| // TrueTypeFontDesc_Dev -------------------------------------------------------- |
| |
| /// The <code>TrueTypeFontDesc_Dev</code> class represents a TrueType font |
| /// descriptor, used to Create and Describe fonts. |
| class TrueTypeFontDesc_Dev { |
| public: |
| /// Default constructor for creating a <code>TrueTypeFontDesc_Dev</code> |
| /// object. |
| TrueTypeFontDesc_Dev(); |
| |
| /// Constructor that takes an existing <code>PP_TrueTypeFontDesc_Dev</code> |
| /// structure. The 'family' PP_Var field in the structure will be managed by |
| /// this instance. |
| TrueTypeFontDesc_Dev(PassRef, const PP_TrueTypeFontDesc_Dev& pp_desc); |
| |
| /// The copy constructor for <code>TrueTypeFontDesc_Dev</code>. |
| /// |
| /// @param[in] other A reference to a <code>TrueTypeFontDesc_Dev</code>. |
| TrueTypeFontDesc_Dev(const TrueTypeFontDesc_Dev& other); |
| |
| ~TrueTypeFontDesc_Dev(); |
| |
| TrueTypeFontDesc_Dev& operator=(const TrueTypeFontDesc_Dev& other); |
| |
| const PP_TrueTypeFontDesc_Dev& pp_desc() const { |
| return desc_; |
| } |
| |
| Var family() const { |
| return family_; |
| } |
| void set_family(const Var& family) { |
| family_ = family; |
| // The assignment above manages the underlying PP_Vars. Copy the new one |
| // into the wrapped desc struct. |
| desc_.family = family_.pp_var(); |
| } |
| |
| PP_TrueTypeFontFamily_Dev generic_family() const { |
| return desc_.generic_family; |
| } |
| void set_generic_family(PP_TrueTypeFontFamily_Dev family) { |
| desc_.generic_family = family; |
| } |
| |
| PP_TrueTypeFontStyle_Dev style() const { return desc_.style; } |
| void set_style(PP_TrueTypeFontStyle_Dev style) { |
| desc_.style = style; |
| } |
| |
| PP_TrueTypeFontWeight_Dev weight() const { return desc_.weight; } |
| void set_weight(PP_TrueTypeFontWeight_Dev weight) { |
| desc_.weight = weight; |
| } |
| |
| PP_TrueTypeFontWidth_Dev width() const { return desc_.width; } |
| void set_width(PP_TrueTypeFontWidth_Dev width) { |
| desc_.width = width; |
| } |
| |
| PP_TrueTypeFontCharset_Dev charset() const { return desc_.charset; } |
| void set_charset(PP_TrueTypeFontCharset_Dev charset) { |
| desc_.charset = charset; |
| } |
| |
| private: |
| pp::Var family_; // This manages the PP_Var embedded in desc_. |
| PP_TrueTypeFontDesc_Dev desc_; |
| }; |
| |
| // TrueTypeFont_Dev ------------------------------------------------------------ |
| |
| /// The <code>TrueTypeFont_Dev</code> class represents a TrueType font resource. |
| class TrueTypeFont_Dev : public Resource { |
| public: |
| /// Default constructor for creating a <code>TrueTypeFont_Dev</code> object. |
| TrueTypeFont_Dev(); |
| |
| /// A constructor used to create a <code>TrueTypeFont_Dev</code> and associate |
| /// it with the provided <code>Instance</code>. |
| /// |
| /// @param[in] instance The instance that owns this resource. |
| TrueTypeFont_Dev(const InstanceHandle& instance, |
| const TrueTypeFontDesc_Dev& desc); |
| |
| /// The copy constructor for <code>TrueTypeFont_Dev</code>. |
| /// |
| /// @param[in] other A reference to a <code>TrueTypeFont_Dev</code>. |
| TrueTypeFont_Dev(const TrueTypeFont_Dev& other); |
| |
| /// A constructor used when you have received a PP_Resource as a return |
| /// value that has had its reference count incremented for you. |
| /// |
| /// @param[in] resource A PP_Resource corresponding to a TrueType font. |
| TrueTypeFont_Dev(PassRef, PP_Resource resource); |
| |
| /// Gets an array of TrueType font family names available on the host. |
| /// These names can be used to create a font from a specific family. |
| /// |
| /// @param[in] instance A <code>InstanceHandle</code> requesting the family |
| /// names. |
| /// @param[in] callback A <code>CompletionCallbackWithOutput</code> to be |
| /// called upon completion of GetFontFamilies. |
| /// |
| /// @return If >= 0, the number of family names returned, otherwise an error |
| /// code from <code>pp_errors.h</code>. |
| static int32_t GetFontFamilies( |
| const InstanceHandle& instance, |
| const CompletionCallbackWithOutput<std::vector<Var> >& callback); |
| |
| /// Gets an array of TrueType font descriptors for a given font family. These |
| /// descriptors can be used to create a font in that family and matching the |
| /// descriptor attributes. |
| /// |
| /// @param[in] instance A <code>PP_Instance</code> requesting the font |
| /// descriptors. |
| /// @param[in] family A <code>Var</code> holding a string specifying the font |
| /// family. |
| /// @param[in] callback A <code>CompletionCallbackWithOutput</code> to be |
| /// called upon completion of GetFontsInFamily. |
| /// |
| /// @return If >= 0, the number of font descriptors returned, otherwise an |
| /// error code from <code>pp_errors.h</code>. |
| static int32_t GetFontsInFamily( |
| const InstanceHandle& instance, |
| const Var& family, |
| const CompletionCallbackWithOutput<std::vector<TrueTypeFontDesc_Dev> >& |
| callback); |
| |
| /// Returns a description of the given font resource. This description may |
| /// differ from the description passed to Create, reflecting the host's font |
| /// matching and fallback algorithm. |
| /// |
| /// @param[in] callback A <code>CompletionCallback</code> to be called upon |
| /// completion of Describe. |
| /// |
| /// @return A return code from <code>pp_errors.h</code>. If an error code is |
| /// returned, the descriptor will be left unchanged. |
| int32_t Describe( |
| const CompletionCallbackWithOutput<TrueTypeFontDesc_Dev>& callback); |
| |
| /// Gets an array of identifying tags for each table in the font. |
| /// These tags can be used to request specific tables using GetTable. |
| /// |
| /// @param[in] callback A <code>CompletionCallbackWithOutput</code> to be |
| /// called upon completion of GetTableTags. |
| /// |
| /// @return If >= 0, the number of table tags returned, otherwise an error |
| /// code from <code>pp_errors.h</code>. |
| int32_t GetTableTags( |
| const CompletionCallbackWithOutput<std::vector<uint32_t> >& callback); |
| |
| /// Copies the given font table into client memory. |
| /// |
| /// @param[in] table A 4 byte value indicating which table to copy. |
| /// For example, 'glyf' will cause the outline table to be copied into the |
| /// output array. A zero tag value will cause the entire font to be copied. |
| /// @param[in] offset The offset into the font table. |
| /// @param[in] max_data_length The maximum number of bytes to transfer from |
| /// <code>offset</code>. |
| /// @param[in] callback A <code>CompletionCallbackWithOutput</code> to be |
| /// called upon completion of GetTable. |
| /// |
| /// @return If >= 0, the table size in bytes, otherwise an error code from |
| /// <code>pp_errors.h</code>. |
| int32_t GetTable( |
| uint32_t table, |
| int32_t offset, |
| int32_t max_data_length, |
| const CompletionCallbackWithOutput<std::vector<char> >& callback); |
| }; |
| |
| namespace internal { |
| |
| // A specialization of CallbackOutputTraits to provide the callback system the |
| // information on how to handle pp::TrueTypeFontDesc_Dev. This converts |
| // PP_TrueTypeFontDesc_Dev to pp::TrueTypeFontDesc_Dev when passing to the |
| // plugin, and specifically manages the PP_Var embedded in the desc_ field. |
| template<> |
| struct CallbackOutputTraits<TrueTypeFontDesc_Dev> { |
| typedef PP_TrueTypeFontDesc_Dev* APIArgType; |
| typedef PP_TrueTypeFontDesc_Dev StorageType; |
| |
| static inline APIArgType StorageToAPIArg(StorageType& t) { |
| return &t; |
| } |
| |
| static inline TrueTypeFontDesc_Dev StorageToPluginArg(StorageType& t) { |
| return TrueTypeFontDesc_Dev(PASS_REF, t); |
| } |
| |
| static inline void Initialize(StorageType* t) { |
| // Use the same defaults as TrueTypeFontDesc_Dev does. |
| TrueTypeFontDesc_Dev dummy; |
| *t = dummy.pp_desc(); |
| } |
| }; |
| |
| class TrueTypeFontDescArrayOutputAdapterWithStorage |
| : public ArrayOutputAdapter<PP_TrueTypeFontDesc_Dev> { |
| public: |
| TrueTypeFontDescArrayOutputAdapterWithStorage() { |
| set_output(&temp_storage_); |
| }; |
| |
| virtual ~TrueTypeFontDescArrayOutputAdapterWithStorage() { |
| if (!temp_storage_.empty()) { |
| // An easy way to release the resource references held by |temp_storage_|. |
| output(); |
| } |
| }; |
| |
| std::vector<TrueTypeFontDesc_Dev>& output() { |
| PP_DCHECK(output_storage_.empty()); |
| typedef std::vector<PP_TrueTypeFontDesc_Dev> Entries; |
| for (Entries::iterator it = temp_storage_.begin(); |
| it != temp_storage_.end(); ++it) |
| output_storage_.push_back(TrueTypeFontDesc_Dev(PASS_REF, *it)); |
| temp_storage_.clear(); |
| return output_storage_; |
| } |
| |
| private: |
| std::vector<PP_TrueTypeFontDesc_Dev> temp_storage_; |
| std::vector<TrueTypeFontDesc_Dev> output_storage_; |
| }; |
| |
| // A specialization of CallbackOutputTraits to provide the callback system the |
| // information on how to handle vectors of TrueTypeFontDesc_Dev. This converts |
| // PP_TrueTypeFontDesc_Dev to TrueTypeFontDesc_Dev when passing to the plugin. |
| template<> |
| struct CallbackOutputTraits< std::vector<TrueTypeFontDesc_Dev> > { |
| typedef PP_ArrayOutput APIArgType; |
| typedef TrueTypeFontDescArrayOutputAdapterWithStorage StorageType; |
| |
| static inline APIArgType StorageToAPIArg(StorageType& t) { |
| return t.pp_array_output(); |
| } |
| |
| static inline std::vector<TrueTypeFontDesc_Dev>& StorageToPluginArg( |
| StorageType& t) { |
| return t.output(); |
| } |
| |
| static inline void Initialize(StorageType* /* t */) {} |
| }; |
| |
| } // namespace internal |
| |
| } // namespace pp |
| |
| #endif // PPAPI_CPP_TRUETYPE_FONT_H_ |