drawable.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 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 PAPYRUSDRAWABLE_H
#define PAPYRUSDRAWABLE_H

#include <map>

#include <papyrus/pointer.h>
#include <papyrus/enums.h>
#include <papyrus/utility.h>
#include <papyrus/renderable.h>
#include <papyrus/region.h>
#include <papyrus/viewbox.h>
#include <papyrus/matrix.h>

namespace Papyrus
{

  class Group;

  class Drawable : public Renderable
  {
    protected:

      Drawable ( const Glib::ustring& id=Glib::ustring(), double tx = 0.0, double ty = 0.0, double sx = 1.0, double sy = 1.0, double r = 0.0 );

    public:
      PAPYRUS_RENDERABLE(Drawable);

      virtual ~Drawable();

      virtual void set( const AttributeValueMap& avmap );

      bool is_visible() const;

      void show();

      void hide();

      double alpha() const;

      void set_alpha( double a );
      
      double x() const;

      void set_x( double x );

      double y() const;

      void set_y( double y );

      void get_xy( double& x, double& y );

      void set_xy( double x, double y );

      void translate ( double tx, double ty );

      void get_scale( double& sx, double& sy );

      double get_scale_x() const;

      double get_scale_y() const;

      void set_scale_x( double sx );

      void set_scale_y( double sy );
      
      void set_scale( double scale_x, double scale_y );

      void set_scale( double s );

      void scale ( double s );

      void scale ( double scale_x, double scale_y );

      double get_rotation(DegRad unit=RADIANS) const;

      void set_rotation( double r, DegRad unit=RADIANS );

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

      void get_skew ( double& skewx, double& skewy, DegRad unit=RADIANS );

      double get_skew_x(DegRad unit=RADIANS) const;

      double get_skew_y(DegRad unit=RADIANS) const;

      void set_skew_x ( double skewx, DegRad unit=RADIANS );

      void set_skew_y ( double skewy, DegRad unit=RADIANS );

      void set_skew ( double skewx, double skewy, DegRad unit=RADIANS );

      void set_skew ( double s, DegRad unit=RADIANS );

      void skew ( double x, double y, DegRad unit=RADIANS );

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

      double centroid_x() const;

      void set_centroid_x ( double centroid_x );

      double centroid_y() const;

      void set_centroid_y ( double centroid_y );

      void get_centroid ( double& centroid_x, double& centroid_y );

      void set_centroid ( double centroid_x, double centroid_y );

      const Matrix& matrix() const;
      
      const Matrix& composed_matrix() const;

      typedef std::list<Matrix::pointer> MatrixList;
      typedef std::map<int,MatrixList> MatrixMap;
      
      struct CountedConnection {
        CountedConnection(): count(0) { }
        sigc::connection connection;
        unsigned int count;
      };
        
      typedef std::map<Matrix::pointer, CountedConnection> MatrixConnMap;
      
      void add_matrix( const Matrix::pointer m, int level=0 );
      
      void remove_matrix( const Matrix::pointer m );
      
      void remove_matrix( const Matrix::pointer m, int level );
      
      const MatrixMap& matrices();
      
      const MatrixConnMap& matrix_connection_map();

      virtual Matrix global_matrix() const;

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

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

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

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

      virtual void render ( Context& cairo ) const;

      virtual void render( Context& cairo, double x, double y, double w, double h ) const;
      
      virtual void draw( Context& cairo ) const = 0;
      
      virtual void freeze();
      
      virtual void thaw(bool force_redraw=false);

      bool is_frozen();
      
      int composite_operator();

      void set_composite_operator ( Cairo::Operator op );

      void clear_composite_operator();

      virtual Region extents(const Matrix& m = Matrix::Identity, ExtentsPerformance ep=EXTENTS_QUICK) const;

      virtual Region pre_viewbox_extents(const Matrix& m = Matrix::Identity, ExtentsPerformance ep=EXTENTS_QUICK) const;

      virtual Region raw_extents() const;

      virtual Region global_extents() const;

      bool exclude_from_extents();

      void set_exclude_from_extents ( bool b=true );

      virtual Region calculate_extents(const Matrix& m = Matrix::Identity, ExtentsPerformance ep = EXTENTS_QUICK) const;

      void apply_external_matrices( Matrix& m ) const;

      virtual bool inside ( double x, double y );

      void set_selectable ( bool selectable = true );

      bool is_selectable();

      virtual bool is_group();

      Viewbox::pointer viewbox();

      void set_viewbox ( Viewbox::pointer viewbox = Viewbox::pointer() );

      void set_viewbox(double x, double y, double w, double h,
                       Viewbox::ALIGN align=Viewbox::ALIGN_XMAX_YMAX,
                       Viewbox::MEET_OR_SLICE meet_or_slice = Viewbox::MEET);

      void set_viewbox(const Region& region,
                       Viewbox::ALIGN align=Viewbox::ALIGN_XMAX_YMAX,
                       Viewbox::MEET_OR_SLICE meet_or_slice = Viewbox::MEET);

      void set_viewbox ( const Viewbox& viewbox );

      sigc::signal<void, double, double, double, double>& signal_redraw();

      sigc::signal<void>& signal_selectable();

      sigc::signal<void>& signal_destroyed();
      
      sigc::signal<void,FrozenThawed>& signal_frozen();

      sigc::signal<void>& signal_composed_matrix_invalidated();

      sigc::signal<void>& signal_extents_changed();
      
      void reset_position();

      void redraw_proxy();

      virtual pointer clone() const = 0;

      operator pointer();

      pointer self();

      virtual Group* parent();

    protected:
      weak_pointer m_self;

      Group* m_parent;

      MatrixMap m_matrices;
      
      MatrixConnMap m_matrix_connections;
      
      void on_matrix_changed();

      virtual Matrix calculate_composed_matrix() const;
      
      int m_composite_operator;

      bool m_visible;

      double m_alpha;
      
      bool m_frozen;
      
      bool m_frozen_by_parent;
      
      bool m_need_redraw;

      bool m_selectable;

      Viewbox::pointer m_viewbox;

      sigc::connection m_viewbox_connection;

      void on_viewbox_changed();

      sigc::signal<void, double, double, double, double> m_signal_redraw;

      sigc::signal<void> m_signal_selectable;

      sigc::signal<void> m_signal_destroyed;
      
      sigc::signal<void,FrozenThawed> m_signal_frozen;
      
      sigc::signal<void> m_signal_composed_matrix_invalidated;

      sigc::signal<void> m_signal_extents_changed;

      friend class Group;

      virtual void redraw( );

      Glib::ustring svg_transform();

      static Cairo::RefPtr<Cairo::ImageSurface> m_sidebuffer_image;

      static Context m_sidebuffer_cairo;

      bool m_exclude_from_extents;

      void invalidate_matrix();

      void invalidate_composed_matrix();
      
      void invalidate_extents();

    private:
      
      // These are private because any access needs
      // to invalidate the matrix through invalidate_matrix()
      // and invalidate_composed_matrix() to ensure everything
      // gets set properly and the signal is emitted

      double m_x;

      double m_y;

      double m_sx;

      double m_sy;

      double m_r;

      double m_skewx;

      double m_skewy;

      double m_centroid_x;

      double m_centroid_y;

       Matrix m_composed_matrix;

      bool m_composed_matrix_invalid;
      
      Matrix m_matrix;

      bool m_matrix_invalid;

      Region m_extents;

      bool m_extents_invalid;

      Region m_redraw_extents;

      Region m_pre_viewbox_extents;

      bool m_pre_viewbox_extents_invalid;

  };

  typedef std::map<Glib::ustring,Drawable::pointer> DrawableDictionary;



#define EXTENTS_CHECKED_CAIRO_OP(x,y) x->y()

}

#endif