matrix.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Rick L. Vinyard, Jr.                            *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This file is part of the papyrus library.                             *
 *                                                                         *
 *   papyrus is free software; you can redistribute it and/or modify       *
 *   it under the terms of the GNU Lesser General Public License           *
 *   version 3.0 as published by the Free Software Foundation.             *
 *                                                                         *
 *   papyrus 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 Lesser General Public License version 3.0 for more details.       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with the papyrus library. If not, see                   *
 *   <http://www.gnu.org/licenses/>.                                       *
 ***************************************************************************/
#ifndef PAPYRUSMATRIX_H
#define PAPYRUSMATRIX_H

#include <sigc++/sigc++.h>
#include <glibmm.h>
#include <cairomm/cairomm.h>

#include <papyrus/pointer.h>
#include <papyrus/enums.h>

namespace Papyrus
{

  class Matrix : public sigc::trackable
  {
    public:

      typedef PapyrusPointer<Matrix> pointer;

      Matrix();

      Matrix ( double tx, double ty, double sx = 1.0, double sy = 1.0, double r = 0.0 );

      Matrix ( double xx, double yx, double xy, double yy, double x0, double y0 );

      Matrix ( const Cairo::Matrix& matrix );

      Matrix ( const Matrix& other );

      Matrix ( const char* svg_transform );

      Matrix ( const Glib::ustring& svg_transform );

      static pointer create();

      static pointer create ( double tx, double ty = 0.0, double sx = 1.0, double sy = 1.0, double r = 0.0 );

      static pointer create ( double xx, double yx, double xy, double yy, double x0, double y0 );

      static pointer create ( const Cairo::Matrix& matrix );

      static pointer create ( const Matrix& other );

      static pointer create ( const char* svg_string );

      static pointer create ( const Glib::ustring& svg_string );

      static Matrix Identity;

      ~Matrix();

      void translate ( double tx, double ty );

      void scale ( double s );

      void scale ( double scale_x, double scale_y );

      void rotate ( double r, DegRad degrad = RADIANS );

      void rotate( double r, double cx, double cy, DegRad degrad = RADIANS );

      void skew ( double s, DegRad degrad = RADIANS );

      void skew ( double skewx, double skewy, DegRad degrad = RADIANS );

      void skew_x( double s, DegRad degrad = RADIANS );

      void skew_y( double s, DegRad degrad = RADIANS );

      void invert();
      
      Matrix inverse() const;

      void transform_distance ( double& dx, double& dy ) const;

      void transform_distance_inverse ( double& dx, double& dy ) const;

      void transform_point ( double& x, double& y ) const;

      void transform_point_inverse ( double& x, double& y ) const;

      Matrix& operator= ( const Cairo::Matrix& other );

      Matrix& operator= ( const Matrix& other );

      Matrix& operator= ( const Matrix::pointer other );

      Matrix& operator= ( const char* svg_transform );

      Matrix& operator= ( const Glib::ustring& svg_transform );

      Matrix operator* ( const Matrix& other ) const;

      Matrix operator* ( const Matrix::pointer other ) const;

      Matrix operator* ( const char* svg_transform ) const;

      Matrix operator* ( const Glib::ustring& svg_transform ) const;

      Matrix& operator*= ( const Matrix& other );
      
      Matrix& operator*= ( const Matrix::pointer other );

      Matrix& operator*= ( const char* svg_transform );

      Matrix& operator*= ( const Glib::ustring& svg_transform );

      bool operator==( const Matrix& other ) const;

      bool operator!=( const Matrix& other ) const;
      
      bool operator==( const pointer other ) const;

      bool operator!=( const pointer other ) const;

      operator const Cairo::Matrix&() const;

      bool set(const Glib::ustring& s);

      void set_identity();

      Glib::ustring svg() const;

      sigc::signal<void> signal_changed();

    protected:
      Cairo::Matrix m_matrix;

      sigc::signal<void> m_signal_changed;

  };

}

  bool operator==( const Papyrus::Matrix::pointer m1, const Papyrus::Matrix& m2);

  bool operator!=( const Papyrus::Matrix::pointer m1, const Papyrus::Matrix& m2);


#endif