|

CairoContext.hpp

Go to the documentation of this file.

#ifndef IONFLUX_TOOLS_CAIRO_CAIROCONTEXT
#define IONFLUX_TOOLS_CAIRO_CAIROCONTEXT
/* ==========================================================================
 * Ionflux Tools
 * Copyright (c) 2005 Joern P. Meier
 * mail@ionflux.org
 * --------------------------------------------------------------------------
 * CairoContext.hpp                  Cairo context.
 * ==========================================================================
 * 
 * This file is part of Ionflux Tools.
 * 
 * Ionflux Tools is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the 
 * Free Software Foundation; either version 2 of the License, or (at your 
 * option) any later version.
 * 
 * Ionflux Tools 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 
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License along 
 * with Ionflux Tools; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 * 
 * ========================================================================== */

#include <string>
#include "cairo.h"
#include "ionflux/color.hpp"
#include "ionflux/ManagedObject.hpp"
#include "ionflux/CairoMatrix.hpp"
#include "ionflux/CairoPattern.hpp"
#include "ionflux/CairoSurface.hpp"
#include "ionflux/CairoPath.hpp"

namespace Ionflux
{

namespace Tools
{

namespace Cairo
{

class CairoContext
: public ManagedObject
{
    private:
        
    protected:
        cairo_t* cairoContext;
        
    public:
        
        CairoContext();
        
        CairoContext(const CairoContext& initCairoContext);
        
        CairoContext(cairo_t* initCairoContext);
        
        CairoContext(cairo_surface_t* initSurface);
        
        CairoContext(Surface& initSurface);
        
        virtual ~CairoContext();
        
        virtual void reference();
        
        virtual void destroy();
        
        virtual void save();
        
        virtual void restore();
        
        virtual void setOperator(cairo_operator_t op);
        
        virtual void setSource(cairo_pattern_t* source);
        
        virtual void setSource(const Pattern& source);
        
        virtual void setSourceRgb(double red, double green, double blue);
        
        virtual void setSourceRgba(double red, double green, double blue, double 
        alpha);
        
        virtual void setSourceColor(const Ionflux::Tools::Color& color);
        
        virtual void setSourceSurface(cairo_surface_t* surface, double x, double 
        y);
        
        virtual void setSourceSurface(Surface& surface, double x, double y);
        
        virtual void setTolerance(double tolerance);
        
        virtual void setFillRule(cairo_fill_rule_t fill_rule);
        
        virtual void setLineWidth(double width);
        
        virtual void setLineCap(cairo_line_cap_t line_cap);
        
        virtual void setLineJoin(cairo_line_join_t line_join);
        
        virtual void setDash(double* dashes, int ndash, double offset);
        
        virtual void setMiterLimit(double limit);
        
        virtual void translate(double tx, double ty);
        
        virtual void scale(double sx, double sy);
        
        virtual void rotate(double angle);
        
        virtual void transform(const cairo_matrix_t* matrix);
        
        virtual void transform(const Matrix& matrix);
        
        virtual void setMatrix(const cairo_matrix_t* matrix);
        
        virtual void setMatrix(const Matrix& matrix);
        
        virtual void identityMatrix();
        
        virtual void userToDevice(double* x, double* y);
        
        virtual void userToDeviceDistance(double* dx, double* dy);
        
        virtual void deviceToUser(double* x, double* y);
        
        virtual void deviceToUserDistance(double* dx, double* dy);
        
        virtual void newPath();
        
        virtual void moveTo(double x, double y);
        
        virtual void lineTo(double x, double y);
        
        virtual void curveTo(double x1, double y1, double x2, double y2, double 
        x3, double y3);
        
        virtual void arc(double xc, double yc, double radius, double angle1, 
        double angle2);
        
        virtual void arcNegative(double xc, double yc, double radius, double 
        angle1, double angle2);
        
        virtual void relMoveTo(double dx, double dy);
        
        virtual void relLineTo(double dx, double dy);
        
        virtual void relCurveTo(double dx1, double dy1, double dx2, double dy2, 
        double dx3, double dy3);
        
        virtual void rectangle(double x, double y, double width, double height);
        
        virtual void closePath();
        
        virtual void paint();
        
        virtual void paintWithAlpha(double alpha);
        
        virtual void mask(cairo_pattern_t* pattern);
        
        virtual void mask(const Pattern& pattern);
        
        virtual void maskSurface(cairo_surface_t* surface, double surface_x, 
        double surface_y);
        
        virtual void maskSurface(Surface& surface, double surface_x, double 
        surface_y);
        
        virtual void stroke();
        
        virtual void strokePreserve();
        
        virtual void fill();
        
        virtual void fillPreserve();
        
        virtual void copyPage();
        
        virtual void showPage();
        
        virtual cairo_bool_t inStroke(double x, double y);
        
        virtual cairo_bool_t inFill(double x, double y);
        
        virtual void strokeExtents(double* x1, double* y1, double* x2, double* 
        y2);
        
        virtual void fillExtents(double* x1, double* y1, double* x2, double* y2);
        
        virtual void resetClip();
        
        virtual void clip();
        
        virtual void clipPreserve();
        
        virtual void selectFontFace(const std::string& family, cairo_font_slant_t
        slant, cairo_font_weight_t weight);
        
        virtual void setFontSize(double size);
        
        virtual void setFontMatrix(const cairo_matrix_t* matrix);
        
        virtual void setFontMatrix(const Matrix& matrix);
        
        virtual void getFontMatrix(cairo_matrix_t* matrix);
        
        virtual void getFontMatrix(Matrix& matrix);
        
        virtual void showText(const std::string& utf8);
        
        virtual void showGlyphs(cairo_glyph_t* glyphs, int num_glyphs);
        
        virtual cairo_font_face_t* getFontFace();
        
        virtual void fontExtents(cairo_font_extents_t* extents);
        
        virtual void setFontFace(cairo_font_face_t* font_face);
        
        virtual void textExtents(const std::string& utf8, cairo_text_extents_t* 
        extents);
        
        virtual void glyphExtents(cairo_glyph_t* glyphs, int num_glyphs, 
        cairo_text_extents_t* extents);
        
        virtual void textPath(const std::string& utf8);
        
        virtual void glyphPath(cairo_glyph_t* glyphs, int num_glyphs);
        
        virtual cairo_operator_t getOperator();
        
        virtual cairo_pattern_t* getSource();
        
        virtual double getTolerance();
        
        virtual void getCurrentPoint(double* x, double* y);
        
        virtual cairo_fill_rule_t getFillRule();
        
        virtual double getLineWidth();
        
        virtual cairo_line_cap_t getLineCap();
        
        virtual cairo_line_join_t getLineJoin();
        
        virtual double getMiterLimit();
        
        virtual void getMatrix(cairo_matrix_t* matrix);
        
        virtual void getMatrix(Matrix& matrix);
        
        virtual cairo_surface_t* getTarget();
        
        virtual void getTarget(Surface& surface);
        
        virtual cairo_path_t* copyPath();
        
        virtual void copyPath(Path& target);
        
        virtual cairo_path_t* copyPathFlat();
        
        virtual void copyPathFlat(Path& target);
        
        virtual void appendPath(cairo_path_t* path);
        
        virtual void appendPath(Path& path);
        
        virtual cairo_status_t status();
        
        virtual std::string statusToString(cairo_status_t status);
        
        virtual CairoContext& operator=(const CairoContext& newCairoContext);
        
        virtual CairoContext& operator=(cairo_t* newCairoContext);
        
        virtual void setCairoContext(cairo_t* newCairoContext);
        
        virtual cairo_t* getCairoContext() const;
};


}

}

}

#endif

---