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