src/ppapi/cpp/dev/truetype_font_dev.h

   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_