Home | History | Annotate | Download | only in dev 
      1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef PPAPI_CPP_TRUETYPE_FONT_H_
      6 #define PPAPI_CPP_TRUETYPE_FONT_H_
      7 
      8 #include "ppapi/c/dev/ppb_truetype_font_dev.h"
      9 #include "ppapi/c/pp_time.h"
     10 #include "ppapi/cpp/completion_callback.h"
     11 #include "ppapi/cpp/pass_ref.h"
     12 #include "ppapi/cpp/resource.h"
     13 
     14 /// @file
     15 /// This file defines the API to create a TrueType font object.
     16 
     17 namespace pp {
     18 
     19 class InstanceHandle;
     20 
     21 // TrueTypeFontDesc_Dev --------------------------------------------------------
     22 
     23 /// The <code>TrueTypeFontDesc_Dev</code> class represents a TrueType font
     24 /// descriptor, used to Create and Describe fonts.
     25 class TrueTypeFontDesc_Dev {
     26  public:
     27   /// Default constructor for creating a <code>TrueTypeFontDesc_Dev</code>
     28   /// object.
     29   TrueTypeFontDesc_Dev();
     30 
     31   /// Constructor that takes an existing <code>PP_TrueTypeFontDesc_Dev</code>
     32   /// structure. The 'family' PP_Var field in the structure will be managed by
     33   /// this instance.
     34   TrueTypeFontDesc_Dev(PassRef, const PP_TrueTypeFontDesc_Dev& pp_desc);
     35 
     36   /// The copy constructor for <code>TrueTypeFontDesc_Dev</code>.
     37   ///
     38   /// @param[in] other A reference to a <code>TrueTypeFontDesc_Dev</code>.
     39   TrueTypeFontDesc_Dev(const TrueTypeFontDesc_Dev& other);
     40 
     41   ~TrueTypeFontDesc_Dev();
     42 
     43   TrueTypeFontDesc_Dev& operator=(const TrueTypeFontDesc_Dev& other);
     44 
     45   const PP_TrueTypeFontDesc_Dev& pp_desc() const {
     46     return desc_;
     47   }
     48 
     49   Var family() const {
     50     return family_;
     51   }
     52   void set_family(const Var& family) {
     53     family_ = family;
     54     // The assignment above manages the underlying PP_Vars. Copy the new one
     55     // into the wrapped desc struct.
     56     desc_.family = family_.pp_var();
     57   }
     58 
     59   PP_TrueTypeFontFamily_Dev generic_family() const {
     60     return desc_.generic_family;
     61   }
     62   void set_generic_family(PP_TrueTypeFontFamily_Dev family) {
     63     desc_.generic_family = family;
     64   }
     65 
     66   PP_TrueTypeFontStyle_Dev style() const { return desc_.style; }
     67   void set_style(PP_TrueTypeFontStyle_Dev style) {
     68     desc_.style = style;
     69   }
     70 
     71   PP_TrueTypeFontWeight_Dev weight() const { return desc_.weight; }
     72   void set_weight(PP_TrueTypeFontWeight_Dev weight) {
     73     desc_.weight = weight;
     74   }
     75 
     76   PP_TrueTypeFontWidth_Dev width() const { return desc_.width; }
     77   void set_width(PP_TrueTypeFontWidth_Dev width) {
     78     desc_.width = width;
     79   }
     80 
     81   PP_TrueTypeFontCharset_Dev charset() const { return desc_.charset; }
     82   void set_charset(PP_TrueTypeFontCharset_Dev charset) {
     83     desc_.charset = charset;
     84   }
     85 
     86  private:
     87   pp::Var family_;  // This manages the PP_Var embedded in desc_.
     88   PP_TrueTypeFontDesc_Dev desc_;
     89 };
     90 
     91 // TrueTypeFont_Dev ------------------------------------------------------------
     92 
     93 /// The <code>TrueTypeFont_Dev</code> class represents a TrueType font resource.
     94 class TrueTypeFont_Dev : public Resource {
     95  public:
     96   /// Default constructor for creating a <code>TrueTypeFont_Dev</code> object.
     97   TrueTypeFont_Dev();
     98 
     99   /// A constructor used to create a <code>TrueTypeFont_Dev</code> and associate
    100   /// it with the provided <code>Instance</code>.
    101   ///
    102   /// @param[in] instance The instance that owns this resource.
    103   TrueTypeFont_Dev(const InstanceHandle& instance,
    104                    const TrueTypeFontDesc_Dev& desc);
    105 
    106   /// The copy constructor for <code>TrueTypeFont_Dev</code>.
    107   ///
    108   /// @param[in] other A reference to a <code>TrueTypeFont_Dev</code>.
    109   TrueTypeFont_Dev(const TrueTypeFont_Dev& other);
    110 
    111   /// A constructor used when you have received a PP_Resource as a return
    112   /// value that has had its reference count incremented for you.
    113   ///
    114   /// @param[in] resource A PP_Resource corresponding to a TrueType font.
    115   TrueTypeFont_Dev(PassRef, PP_Resource resource);
    116 
    117   /// Gets an array of TrueType font family names available on the host.
    118   /// These names can be used to create a font from a specific family.
    119   ///
    120   /// @param[in] instance A <code>InstanceHandle</code> requesting the family
    121   /// names.
    122   /// @param[in] callback A <code>CompletionCallbackWithOutput</code> to be
    123   /// called upon completion of GetFontFamilies.
    124   ///
    125   /// @return If >= 0, the number of family names returned, otherwise an error
    126   /// code from <code>pp_errors.h</code>.
    127   static int32_t GetFontFamilies(
    128       const InstanceHandle& instance,
    129       const CompletionCallbackWithOutput<std::vector<Var> >& callback);
    130 
    131   /// Gets an array of TrueType font descriptors for a given font family. These
    132   /// descriptors can be used to create a font in that family and matching the
    133   /// descriptor attributes.
    134   ///
    135   /// @param[in] instance A <code>PP_Instance</code> requesting the font
    136   /// descriptors.
    137   /// @param[in] family A <code>Var</code> holding a string specifying the font
    138   /// family.
    139   /// @param[in] callback A <code>CompletionCallbackWithOutput</code> to be
    140   /// called upon completion of GetFontsInFamily.
    141   ///
    142   /// @return If >= 0, the number of font descriptors returned, otherwise an
    143   /// error code from <code>pp_errors.h</code>.
    144   static int32_t GetFontsInFamily(
    145       const InstanceHandle& instance,
    146       const Var& family,
    147       const CompletionCallbackWithOutput<std::vector<TrueTypeFontDesc_Dev> >&
    148           callback);
    149 
    150   /// Returns a description of the given font resource. This description may
    151   /// differ from the description passed to Create, reflecting the host's font
    152   /// matching and fallback algorithm.
    153   ///
    154   /// @param[in] callback A <code>CompletionCallback</code> to be called upon
    155   /// completion of Describe.
    156   ///
    157   /// @return A return code from <code>pp_errors.h</code>. If an error code is
    158   /// returned, the descriptor will be left unchanged.
    159   int32_t Describe(
    160       const CompletionCallbackWithOutput<TrueTypeFontDesc_Dev>& callback);
    161 
    162   /// Gets an array of identifying tags for each table in the font.
    163   /// These tags can be used to request specific tables using GetTable.
    164   ///
    165   /// @param[in] callback A <code>CompletionCallbackWithOutput</code> to be
    166   /// called upon completion of GetTableTags.
    167   ///
    168   /// @return If >= 0, the number of table tags returned, otherwise an error
    169   /// code from <code>pp_errors.h</code>.
    170   int32_t GetTableTags(
    171       const CompletionCallbackWithOutput<std::vector<uint32_t> >& callback);
    172 
    173   /// Copies the given font table into client memory.
    174   ///
    175   /// @param[in] table A 4 byte value indicating which table to copy.
    176   /// For example, 'glyf' will cause the outline table to be copied into the
    177   /// output array. A zero tag value will cause the entire font to be copied.
    178   /// @param[in] offset The offset into the font table.
    179   /// @param[in] max_data_length The maximum number of bytes to transfer from
    180   /// <code>offset</code>.
    181   /// @param[in] callback A <code>CompletionCallbackWithOutput</code> to be
    182   /// called upon completion of GetTable.
    183   ///
    184   /// @return If >= 0, the table size in bytes, otherwise an error code from
    185   /// <code>pp_errors.h</code>.
    186   int32_t GetTable(
    187       uint32_t table,
    188       int32_t offset,
    189       int32_t max_data_length,
    190       const CompletionCallbackWithOutput<std::vector<char> >& callback);
    191 };
    192 
    193 namespace internal {
    194 
    195 // A specialization of CallbackOutputTraits to provide the callback system the
    196  // information on how to handle pp::TrueTypeFontDesc_Dev. This converts
    197 // PP_TrueTypeFontDesc_Dev to pp::TrueTypeFontDesc_Dev when passing to the
    198 // plugin, and specifically manages the PP_Var embedded in the desc_ field.
    199 template<>
    200 struct CallbackOutputTraits<TrueTypeFontDesc_Dev> {
    201   typedef PP_TrueTypeFontDesc_Dev* APIArgType;
    202   typedef PP_TrueTypeFontDesc_Dev StorageType;
    203 
    204   static inline APIArgType StorageToAPIArg(StorageType& t) {
    205     return &t;
    206   }
    207 
    208   static inline TrueTypeFontDesc_Dev StorageToPluginArg(StorageType& t) {
    209     return TrueTypeFontDesc_Dev(PASS_REF, t);
    210   }
    211 
    212   static inline void Initialize(StorageType* t) {
    213     // Use the same defaults as TrueTypeFontDesc_Dev does.
    214     TrueTypeFontDesc_Dev dummy;
    215     *t = dummy.pp_desc();
    216   }
    217 };
    218 
    219 class TrueTypeFontDescArrayOutputAdapterWithStorage
    220     : public ArrayOutputAdapter<PP_TrueTypeFontDesc_Dev> {
    221  public:
    222   TrueTypeFontDescArrayOutputAdapterWithStorage() {
    223     set_output(&temp_storage_);
    224   };
    225 
    226   virtual ~TrueTypeFontDescArrayOutputAdapterWithStorage() {
    227     if (!temp_storage_.empty()) {
    228       // An easy way to release the resource references held by |temp_storage_|.
    229       output();
    230     }
    231   };
    232 
    233   std::vector<TrueTypeFontDesc_Dev>& output() {
    234     PP_DCHECK(output_storage_.empty());
    235     typedef std::vector<PP_TrueTypeFontDesc_Dev> Entries;
    236     for (Entries::iterator it = temp_storage_.begin();
    237          it != temp_storage_.end(); ++it)
    238       output_storage_.push_back(TrueTypeFontDesc_Dev(PASS_REF, *it));
    239     temp_storage_.clear();
    240     return output_storage_;
    241   }
    242 
    243  private:
    244   std::vector<PP_TrueTypeFontDesc_Dev> temp_storage_;
    245   std::vector<TrueTypeFontDesc_Dev> output_storage_;
    246 };
    247 
    248 // A specialization of CallbackOutputTraits to provide the callback system the
    249 // information on how to handle vectors of TrueTypeFontDesc_Dev. This converts
    250 // PP_TrueTypeFontDesc_Dev to TrueTypeFontDesc_Dev when passing to the plugin.
    251 template<>
    252 struct CallbackOutputTraits< std::vector<TrueTypeFontDesc_Dev> > {
    253   typedef PP_ArrayOutput APIArgType;
    254   typedef TrueTypeFontDescArrayOutputAdapterWithStorage StorageType;
    255 
    256   static inline APIArgType StorageToAPIArg(StorageType& t) {
    257     return t.pp_array_output();
    258   }
    259 
    260   static inline std::vector<TrueTypeFontDesc_Dev>& StorageToPluginArg(
    261       StorageType& t) {
    262     return t.output();
    263   }
    264 
    265   static inline void Initialize(StorageType* /* t */) {}
    266 };
    267 
    268 }  // namespace internal
    269 
    270 }  // namespace pp
    271 
    272 #endif  // PPAPI_CPP_TRUETYPE_FONT_H_
    273