/* Copyright (C) 2005 The cairomm Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*/
#include <cairomm/surface.h>
#include <cairomm/script.h>
#include <cairomm/private.h>
namespace Cairo
{
static cairo_user_data_key_t USER_DATA_KEY_WRITE_FUNC = {0};
static cairo_user_data_key_t USER_DATA_KEY_READ_FUNC = {0};
static void
free_slot(void* data)
{
auto slot = static_cast<Surface::SlotWriteFunc*>(data);
delete slot;
}
static Surface::SlotWriteFunc*
get_slot(cairo_surface_t* surface) {
return static_cast<Surface::SlotWriteFunc*>(cairo_surface_get_user_data(surface,
&USER_DATA_KEY_WRITE_FUNC));
}
static void
set_read_slot(cairo_surface_t* surface, Surface::SlotReadFunc* slot) {
// the slot will automatically be freed by free_slot() when the underlying C
// instance is destroyed
cairo_surface_set_user_data(surface, &USER_DATA_KEY_READ_FUNC, slot, &free_slot);
}
static void
set_write_slot(cairo_surface_t* surface, Surface::SlotWriteFunc* slot) {
// the slot will automatically be freed by free_slot() when the underlying C
// instance is destroyed
cairo_surface_set_user_data(surface, &USER_DATA_KEY_WRITE_FUNC, slot, &free_slot);
}
cairo_status_t read_func_wrapper(void* closure, unsigned char* data, unsigned int length)
{
if (!closure)
return CAIRO_STATUS_READ_ERROR;
auto read_func = static_cast<Surface::SlotReadFunc*>(closure);
return static_cast<cairo_status_t>((*read_func)(data, length));
}
cairo_status_t write_func_wrapper(void* closure, const unsigned char* data, unsigned int length)
{
if (!closure)
return CAIRO_STATUS_WRITE_ERROR;
auto write_func = static_cast<Surface::SlotWriteFunc*>(closure);
return static_cast<cairo_status_t>((*write_func)(data, length));
}
Surface::Surface(cairo_surface_t* cobject, bool has_reference)
: m_cobject(nullptr)
{
if(has_reference)
m_cobject = cobject;
else
m_cobject = cairo_surface_reference(cobject);
}
Surface::~Surface()
{
if(m_cobject)
cairo_surface_destroy(m_cobject);
}
void Surface::finish()
{
cairo_surface_finish(cobj());
check_object_status_and_throw_exception(*this);
}
const unsigned char* Surface::get_mime_data(const std::string& mime_type, unsigned long& length)
{
const unsigned char* data = nullptr;
cairo_surface_get_mime_data(const_cast<cobject*>(cobj()), mime_type.c_str(), &data, &length);
check_object_status_and_throw_exception(*this);
return data;
}
static void on_cairo_destroy(void *data)
{
auto slot = static_cast<Surface::SlotDestroy*>(data);
if(!slot)
return;
(*slot)();
delete slot;
}
void Surface::set_mime_data(const std::string& mime_type, unsigned char* data, unsigned long length, const SlotDestroy& slot_destroy)
{
auto copy = new SlotDestroy(slot_destroy); //Deleted when the callback is called once.
cairo_surface_set_mime_data(const_cast<cobject*>(cobj()), mime_type.c_str(), data, length,
&on_cairo_destroy, copy);
check_object_status_and_throw_exception(*this);
}
void Surface::unset_mime_data(const std::string& mime_type)
{
cairo_surface_set_mime_data(const_cast<cobject*>(cobj()), mime_type.c_str(),
0, 0, 0, 0);
check_object_status_and_throw_exception(*this);
}
void Surface::get_font_options(FontOptions& options) const
{
auto cfontoptions = cairo_font_options_create();
cairo_surface_get_font_options(const_cast<cobject*>(cobj()), cfontoptions);
options = FontOptions(cfontoptions);
cairo_font_options_destroy(cfontoptions);
check_object_status_and_throw_exception(*this);
}
void Surface::flush()
{
cairo_surface_flush(cobj());
check_object_status_and_throw_exception(*this);
}
void Surface::mark_dirty()
{
cairo_surface_mark_dirty(cobj());
check_object_status_and_throw_exception(*this);
}
void Surface::mark_dirty(int x, int y, int width, int height)
{
cairo_surface_mark_dirty_rectangle(cobj(), x, y, width, height);
check_object_status_and_throw_exception(*this);
}
void Surface::set_device_offset(double x_offset, double y_offset)
{
cairo_surface_set_device_offset(cobj(), x_offset, y_offset);
check_object_status_and_throw_exception(*this);
}
void Surface::get_device_offset(double& x_offset, double& y_offset) const
{
cairo_surface_get_device_offset(const_cast<cobject*>(cobj()), &x_offset, &y_offset);
}
void Surface::set_fallback_resolution(double x_pixels_per_inch, double y_pixels_per_inch)
{
cairo_surface_set_fallback_resolution(cobj(), x_pixels_per_inch, y_pixels_per_inch);
check_object_status_and_throw_exception(*this);
}
void Surface::get_fallback_resolution(double& x_pixels_per_inch,
double& y_pixels_per_inch) const
{
cairo_surface_get_fallback_resolution(const_cast<cairo_surface_t*>(cobj()),
&x_pixels_per_inch,
&y_pixels_per_inch);
check_object_status_and_throw_exception(*this);
}
SurfaceType Surface::get_type() const
{
auto surface_type =
cairo_surface_get_type(const_cast<cobject*>(cobj()));
check_object_status_and_throw_exception(*this);
return static_cast<SurfaceType>(surface_type);
}
Content Surface::get_content() const
{
auto content = cairo_surface_get_content(const_cast<cairo_surface_t*>(cobj()));
check_object_status_and_throw_exception(*this);
return static_cast<Content>(content);
}
void Surface::copy_page()
{
cairo_surface_copy_page(cobj());
check_object_status_and_throw_exception(*this);
}
void Surface::show_page()
{
cairo_surface_show_page(cobj());
check_object_status_and_throw_exception(*this);
}
bool Surface::has_show_text_glyphs() const
{
bool result = cairo_surface_has_show_text_glyphs(const_cast<cairo_surface_t*>(cobj()));
check_object_status_and_throw_exception(*this);
return result;
}
#ifdef CAIRO_HAS_PNG_FUNCTIONS
void Surface::write_to_png(const std::string& filename)
{
auto status = cairo_surface_write_to_png(cobj(), filename.c_str());
check_status_and_throw_exception(status);
}
void Surface::write_to_png_stream(const SlotWriteFunc& write_func)
{
auto old_slot = get_slot(cobj());
if (old_slot)
delete old_slot;
auto slot_copy = new SlotWriteFunc(write_func);
set_write_slot(cobj(), slot_copy);
auto status = cairo_surface_write_to_png_stream(cobj(),
&write_func_wrapper,
slot_copy /*closure*/);
check_status_and_throw_exception(status);
}
void Surface::write_to_png(cairo_write_func_t write_func, void *closure)
{
auto status = cairo_surface_write_to_png_stream(cobj(), write_func, closure);
check_status_and_throw_exception(status);
}
#endif
RefPtr<Device> Surface::get_device()
{
auto *d = cairo_surface_get_device (m_cobject);
if (!d)
return RefPtr<Device>();
auto surface_type = cairo_surface_get_type(m_cobject);
switch (surface_type)
{
#if CAIRO_HAS_SCRIPT_SURFACE
case CAIRO_SURFACE_TYPE_SCRIPT:
return RefPtr<Script>(new Script(d, true /* has reference */));
break;
#endif
default:
return RefPtr<Device>(new Device(d, true /* has reference */));
}
}
void Surface::reference() const
{
cairo_surface_reference(const_cast<cobject*>(cobj()));
}
void Surface::unreference() const
{
cairo_surface_destroy(const_cast<cobject*>(cobj()));
}
RefPtr<Surface> Surface::create(const RefPtr<Surface> other, Content content, int width, int height)
{
auto cobject = cairo_surface_create_similar(other->cobj(), (cairo_content_t)content, width, height);
check_status_and_throw_exception(cairo_surface_status(cobject));
return RefPtr<Surface>(new Surface(cobject, true /* has reference */));
}
RefPtr<Surface> Surface::create(const RefPtr<Surface>& target, double x, double y, double width, double height)
{
auto cobject = cairo_surface_create_for_rectangle(target->cobj(), x, y, width, height);
check_status_and_throw_exception(cairo_surface_status(cobject));
return RefPtr<Surface>(new Surface(cobject, true /* has reference */));
}
ImageSurface::ImageSurface(cairo_surface_t* cobject, bool has_reference)
: Surface(cobject, has_reference)
{ }
ImageSurface::~ImageSurface()
{
// surface is destroyed in base class
}
RefPtr<ImageSurface> ImageSurface::create(Format format, int width, int height)
{
auto cobject = cairo_image_surface_create((cairo_format_t)format, width, height);
check_status_and_throw_exception(cairo_surface_status(cobject));
return RefPtr<ImageSurface>(new ImageSurface(cobject, true /* has reference */));
}
RefPtr<ImageSurface> ImageSurface::create(unsigned char* data, Format format, int width, int height, int stride)
{
auto cobject = cairo_image_surface_create_for_data(data, (cairo_format_t)format, width, height, stride);
check_status_and_throw_exception(cairo_surface_status(cobject));
return RefPtr<ImageSurface>(new ImageSurface(cobject, true /* has reference */));
}
#ifdef CAIRO_HAS_PNG_FUNCTIONS
RefPtr<ImageSurface> ImageSurface::create_from_png(std::string filename)
{
auto cobject = cairo_image_surface_create_from_png(filename.c_str());
check_status_and_throw_exception(cairo_surface_status(cobject));
return RefPtr<ImageSurface>(new ImageSurface(cobject, true /* has reference */));
}
RefPtr<ImageSurface> ImageSurface::create_from_png_stream(const SlotReadFunc& read_func)
{
auto slot_copy = new SlotReadFunc(read_func);
auto cobject =
cairo_image_surface_create_from_png_stream(&read_func_wrapper, slot_copy);
check_status_and_throw_exception(cairo_surface_status(cobject));
set_read_slot(cobject, slot_copy);
return RefPtr<ImageSurface>(new ImageSurface(cobject, true /* has reference */));
}
RefPtr<ImageSurface> ImageSurface::create_from_png(cairo_read_func_t read_func, void *closure)
{
auto cobject = cairo_image_surface_create_from_png_stream(read_func, closure);
check_status_and_throw_exception(cairo_surface_status(cobject));
return RefPtr<ImageSurface>(new ImageSurface(cobject, true /* has reference */));
}
#endif // CAIRO_HAS_PNG_FUNCTIONS
int ImageSurface::get_width() const
{
const auto result =
cairo_image_surface_get_width(const_cast<cobject*>(cobj()));
check_object_status_and_throw_exception(*this);
return result;
}
int ImageSurface::get_height() const
{
const auto result =
cairo_image_surface_get_height(const_cast<cobject*>(cobj()));
check_object_status_and_throw_exception(*this);
return result;
}
unsigned char* ImageSurface::get_data()
{
return cairo_image_surface_get_data(cobj());
}
const unsigned char* ImageSurface::get_data() const
{
return cairo_image_surface_get_data(const_cast<cobject*>(cobj()));
}
Format ImageSurface::get_format() const
{
return static_cast<Format>(cairo_image_surface_get_format(const_cast<cobject*>(cobj())));
}
int ImageSurface::get_stride() const
{
return cairo_image_surface_get_stride(const_cast<cobject*>(cobj()));
}
int ImageSurface::format_stride_for_width (Cairo::Format format, int width)
{
return cairo_format_stride_for_width(static_cast<cairo_format_t>(format), width);
}
/*******************************************************************************
* THE FOLLOWING SURFACE TYPES ARE EXPERIMENTAL AND NOT FULLY SUPPORTED
******************************************************************************/
#ifdef CAIRO_HAS_PDF_SURFACE
PdfSurface::PdfSurface(cairo_surface_t* cobject, bool has_reference) :
Surface(cobject, has_reference)
{}
PdfSurface::~PdfSurface()
{
// surface is destroyed in base class
}
RefPtr<PdfSurface> PdfSurface::create(std::string filename, double width_in_points, double height_in_points)
{
auto cobject = cairo_pdf_surface_create(filename.c_str(), width_in_points, height_in_points);
check_status_and_throw_exception(cairo_surface_status(cobject));
return RefPtr<PdfSurface>(new PdfSurface(cobject, true /* has reference */));
}
RefPtr<PdfSurface> PdfSurface::create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points)
{
auto cobject = cairo_pdf_surface_create_for_stream(write_func, closure, width_in_points, height_in_points);
check_status_and_throw_exception(cairo_surface_status(cobject));
return RefPtr<PdfSurface>(new PdfSurface(cobject, true /* has reference */));
}
RefPtr<PdfSurface> PdfSurface::create_for_stream(const SlotWriteFunc& write_func, double
width_in_points, double height_in_points)
{
auto slot_copy = new SlotWriteFunc(write_func);
auto cobject =
cairo_pdf_surface_create_for_stream(write_func_wrapper, slot_copy,
width_in_points, height_in_points);
check_status_and_throw_exception(cairo_surface_status(cobject));
set_write_slot(cobject, slot_copy);
return RefPtr<PdfSurface>(new PdfSurface(cobject, true /* has reference */));
}
void PdfSurface::set_size(double width_in_points, double height_in_points)
{
cairo_pdf_surface_set_size(cobj(), width_in_points, height_in_points);
check_object_status_and_throw_exception(*this);
}
void PdfSurface::restrict_to_version(PdfVersion version)
{
cairo_pdf_surface_restrict_to_version(cobj(), static_cast<cairo_pdf_version_t>(version));
check_object_status_and_throw_exception(*this);
}
const std::vector<PdfVersion> PdfSurface::get_versions()
{
cairo_pdf_version_t const *versions;
int num_versions;
cairo_pdf_get_versions(&versions, &num_versions);
// Just copy the version array out into a std::vector.
std::vector<PdfVersion> vec;
for (int i = 0; i < num_versions; ++i)
{
vec.push_back(static_cast<PdfVersion>(versions[i]));
}
return vec;
}
std::string PdfSurface::version_to_string(PdfVersion version)
{
const char *cstring = cairo_pdf_version_to_string(static_cast<cairo_pdf_version_t>(version));
return cstring ? std::string(cstring) : std::string();
}
#endif // CAIRO_HAS_PDF_SURFACE
#ifdef CAIRO_HAS_PS_SURFACE
PsSurface::PsSurface(cairo_surface_t* cobject, bool has_reference) :
Surface(cobject, has_reference)
{}
PsSurface::~PsSurface()
{
// surface is destroyed in base class
}
RefPtr<PsSurface> PsSurface::create(std::string filename, double width_in_points, double height_in_points)
{
auto cobject = cairo_ps_surface_create(filename.c_str(), width_in_points, height_in_points);
check_status_and_throw_exception(cairo_surface_status(cobject));
return RefPtr<PsSurface>(new PsSurface(cobject, true /* has reference */));
}
RefPtr<PsSurface> PsSurface::create_for_stream(const SlotWriteFunc& write_func, double
width_in_points, double height_in_points)
{
auto slot_copy = new SlotWriteFunc(write_func);
auto cobject =
cairo_ps_surface_create_for_stream(write_func_wrapper, slot_copy,
width_in_points, height_in_points);
check_status_and_throw_exception(cairo_surface_status(cobject));
set_write_slot(cobject, slot_copy);
return RefPtr<PsSurface>(new PsSurface(cobject, true /* has reference */));
}
RefPtr<PsSurface> PsSurface::create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points)
{
auto cobject = cairo_ps_surface_create_for_stream(write_func, closure, width_in_points, height_in_points);
check_status_and_throw_exception(cairo_surface_status(cobject));
return RefPtr<PsSurface>(new PsSurface(cobject, true /* has reference */));
}
void PsSurface::set_size(double width_in_points, double height_in_points)
{
cairo_ps_surface_set_size(cobj(), width_in_points, height_in_points);
check_object_status_and_throw_exception(*this);
}
void PsSurface::dsc_comment(std::string comment)
{
cairo_ps_surface_dsc_comment(cobj(), comment.c_str());
check_object_status_and_throw_exception(*this);
}
void PsSurface::dsc_begin_setup()
{
cairo_ps_surface_dsc_begin_setup(cobj());
check_object_status_and_throw_exception(*this);
}
void PsSurface::dsc_begin_page_setup()
{
cairo_ps_surface_dsc_begin_page_setup(cobj());
check_object_status_and_throw_exception(*this);
}
bool PsSurface::get_eps() const
{
auto result = cairo_ps_surface_get_eps(const_cast<cairo_surface_t*>(cobj()));
check_object_status_and_throw_exception(*this);
return result;
}
void PsSurface::set_eps(bool eps)
{
cairo_ps_surface_set_eps(cobj(), eps);
check_object_status_and_throw_exception(*this);
}
void PsSurface::restrict_to_level(PsLevel level)
{
cairo_ps_surface_restrict_to_level(cobj(), static_cast<cairo_ps_level_t>(level));
check_object_status_and_throw_exception(*this);
}
const std::vector<PsLevel> PsSurface::get_levels()
{
cairo_ps_level_t const *levels;
int num_levels;
cairo_ps_get_levels(&levels, &num_levels);
// Just copy the level array out into a std::vector. This is a rarely used
// function and the array of levels is going to be very small, so there's no
// real performance hit.
std::vector<PsLevel> vec;
for (int i = 0; i < num_levels; ++i)
{
vec.push_back(static_cast<PsLevel>(levels[i]));
}
return vec;
}
std::string PsSurface::level_to_string(PsLevel level)
{
return std::string(cairo_ps_level_to_string(static_cast<cairo_ps_level_t>(level)));
}
#endif // CAIRO_HAS_PS_SURFACE
#ifdef CAIRO_HAS_SVG_SURFACE
SvgSurface::SvgSurface(cairo_surface_t* cobject, bool has_reference) :
Surface(cobject, has_reference)
{}
SvgSurface::~SvgSurface()
{
// surface is destroyed in base class
}
RefPtr<SvgSurface> SvgSurface::create(std::string filename, double width_in_points, double height_in_points)
{
auto cobject = cairo_svg_surface_create(filename.c_str(), width_in_points, height_in_points);
check_status_and_throw_exception(cairo_surface_status(cobject));
return RefPtr<SvgSurface>(new SvgSurface(cobject, true /* has reference */));
}
RefPtr<SvgSurface> SvgSurface::create_for_stream(const SlotWriteFunc& write_func,
double width_in_points,
double height_in_points)
{
auto slot_copy = new SlotWriteFunc(write_func);
auto cobject =
cairo_svg_surface_create_for_stream(write_func_wrapper, slot_copy,
width_in_points, height_in_points);
check_status_and_throw_exception(cairo_surface_status(cobject));
set_write_slot(cobject, slot_copy);
return RefPtr<SvgSurface>(new SvgSurface(cobject, true /* has reference */));
}
RefPtr<SvgSurface> SvgSurface::create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points)
{
auto cobject = cairo_svg_surface_create_for_stream(write_func, closure, width_in_points, height_in_points);
check_status_and_throw_exception(cairo_surface_status(cobject));
return RefPtr<SvgSurface>(new SvgSurface(cobject, true /* has reference */));
}
void SvgSurface::restrict_to_version(SvgVersion version)
{
cairo_svg_surface_restrict_to_version(cobj(), static_cast<cairo_svg_version_t>(version));
check_object_status_and_throw_exception(*this);
}
const std::vector<SvgVersion> SvgSurface::get_versions()
{
cairo_svg_version_t const *versions;
int num_versions;
cairo_svg_get_versions(&versions, &num_versions);
// Just copy the version array out into a std::vector. This is a rarely used
// function and the array of versions is going to be very small, so there's no
// real performance hit.
std::vector<SvgVersion> vec;
for (int i = 0; i < num_versions; ++i)
{
vec.push_back(static_cast<SvgVersion>(versions[i]));
}
return vec;
}
std::string SvgSurface::version_to_string(SvgVersion version)
{
return std::string(cairo_svg_version_to_string(static_cast<cairo_svg_version_t>(version)));
}
#endif // CAIRO_HAS_SVG_SURFACE
#ifdef CAIRO_HAS_GLITZ_SURFACE
GlitzSurface::GlitzSurface(cairo_surface_t* cobject, bool has_reference)
: Surface(cobject, has_reference)
{ }
GlitzSurface::~GlitzSurface()
{
// surface is destroyed in base class
}
RefPtr<GlitzSurface> GlitzSurface::create(glitz_surface_t *surface)
{
auto cobject = cairo_glitz_surface_create(surface);
check_status_and_throw_exception(cairo_surface_status(cobject));
return RefPtr<GlitzSurface>(new GlitzSurface(cobject, true /* has reference */));
}
#endif // CAIRO_HAS_GLITZ_SURFACE
} //namespace Cairo
// vim: ts=2 sw=2 et