group.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 PAPYRUSGROUP_H
#define PAPYRUSGROUP_H

#include <list>
#include <map>
#include <vector>

#include <papyrus/drawable.h>
#include <papyrus/fill.h>
#include <papyrus/rgba.h>
#include <papyrus/stroke.h>

namespace Papyrus
{

  typedef std::vector<Drawable::pointer> Selection;

  class Group : public Drawable
  {
    protected:

      Group(const Glib::ustring& id=Glib::ustring());

      Group(const AttributeValueMap& avmap);

    public:
      PAPYRUS_DRAWABLE(Group);

      static pointer create(const Glib::ustring& id=Glib::ustring());

      static pointer create(const AttributeValueMap& avmap);

      typedef std::list<Drawable::pointer> Layer;

      typedef std::map<int,Layer> Layers;

      friend class Canvas;

      virtual ~Group();

      const Glib::ustring& title() const;

      void set_title( const Glib::ustring& t );

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

      const Glib::ustring& description() const;

      void set_description( const Glib::ustring& d );

      sigc::signal<void>& signal_description_changed();
      
      virtual void freeze();
      
      virtual void thaw(bool force_redraw=false);

      virtual bool is_intermediate_drawing_enabled();

      virtual void enable_intermediate_drawing(bool enabled=true);

      virtual void set( const AttributeValueMap& avmap );

      virtual bool add( Drawable::pointer item, int layer=0 );

      virtual bool remove( Drawable::pointer object );

      virtual bool remove( Drawable* object );

      virtual bool clear();

      Drawable::pointer child( const Glib::ustring& id ) const;

      template <class T>
      PapyrusPointer<T> child( const Glib::ustring& id ) const
      {
        Layers::const_iterator ilayer;
        Layer::const_reverse_iterator ichild;
  
        for ( ilayer = m_layers.begin(); ilayer != m_layers.end(); ilayer++ )
        {
          for ( ichild = ilayer->second.rbegin(); ichild != ilayer->second.rend(); ichild++ )
          {
            if ( (*ichild)->id() == id )
            {
              PapyrusPointer<T> ptr;
              try {
                ptr = papyrus_dynamic_pointer_cast<T>(*ichild);
                return ptr;
              }
              catch ( std::bad_cast )
              {
              }
            }
          }
        }

        return PapyrusPointer<T>();
      }

      virtual bool raise( Drawable::pointer item, int steps=1 );

      virtual bool raise_to_top( Drawable::pointer item );

      virtual bool lower( Drawable::pointer item, int steps=1 );
      
      virtual bool lower_to_bottom( Drawable::pointer item );

      virtual bool move_to_layer( int layer, Drawable::pointer item );

      size_t size() const;

      const Layers& layers() const;

      const Layer& layer(int l) const throw (std::out_of_range);

      bool has_layer( int l );

      bool has( Drawable::pointer d ) const;

      virtual bool inside( double x, double y );

      virtual Selection select( double x, double y, unsigned depth = 1 );

      sigc::signal<void, Drawable::pointer>& signal_child_added();

      sigc::signal<void, Drawable::pointer>& signal_child_removed();

      virtual bool is_group();

      Fill::pointer fill();

      void set_fill( Fill::pointer fill );

      void set_fill ( Paint::pointer paint );

      void set_fill( const RGBA& color );

      void set_fill( const Glib::ustring& fill );

      Stroke::pointer stroke();

      void set_stroke( Stroke::pointer stroke );

      void set_stroke ( Paint::pointer paint );

      void set_stroke ( const RGBA& color );

      void set_stroke ( const Glib::ustring& stroke );

      const PaintDictionary& paint_dictionary() const;

      Paint::pointer lookup_paint( const Glib::ustring& name ) const;

      void add_paint_to_dictionary( const Glib::ustring& name, Paint::pointer p );

      void remove_paint_from_dictionary( const Glib::ustring& name );

      void clear_paint_dictionary();

      sigc::signal<void, const Glib::ustring& >& signal_paint_added_to_dictionary();

      sigc::signal<void, const Glib::ustring& >& signal_paint_removed_from_dictionary();

      const DrawableDictionary& drawable_dictionary() const;

      Drawable::pointer lookup_drawable( const Glib::ustring& name ) const;

      void add_drawable_to_dictionary( const Glib::ustring& name, Drawable::pointer p );

      void remove_drawable_from_dictionary( const Glib::ustring& name );

      void clear_drawable_dictionary();

      sigc::signal<void, const Glib::ustring& >& signal_drawable_added_to_dictionary();

      sigc::signal<void, const Glib::ustring& >& signal_drawable_removed_from_dictionary();

      virtual Glib::ustring svg(unsigned depth=0);

    protected:

      // maintaining both items as list for drawing order and connections for quick access
      Layers m_layers;
      size_t m_size;

      typedef std::map<Drawable::pointer, sigc::connection> Connections;
      Connections m_redraw_connections;
      Connections m_changed_connections;

      sigc::signal<void, Drawable::pointer> m_signal_child_added;
      sigc::signal<void, Drawable::pointer> m_signal_child_removed;

      Fill::pointer m_fill;
      Stroke::pointer m_stroke;

      PaintDictionary m_paint_dictionary;
      sigc::signal<void, const Glib::ustring& > m_signal_paint_added_to_dictionary;
      sigc::signal<void, const Glib::ustring& > m_signal_paint_removed_from_dictionary;

      DrawableDictionary m_drawable_dictionary;
      sigc::signal<void, const Glib::ustring& > m_signal_drawable_added_to_dictionary;
      sigc::signal<void, const Glib::ustring& > m_signal_drawable_removed_from_dictionary;

      Glib::ustring m_title;
      sigc::signal<void> m_signal_title_changed;

      Glib::ustring m_description;
      sigc::signal<void> m_signal_description_changed;

      bool m_intermediate_drawing_enabled;



      virtual void on_child_changed( Drawable::pointer child );

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

      void on_child_redraw( double x, double y, double w, double h, Drawable::pointer child );
      
      virtual void draw( Context& cairo ) const;
      
      void freeze_children();
      
      void thaw_children(bool force_redraw=false);

    private:

      void on_child_changed_proxy( Drawable::pointer child );
      
  };

}

#endif