src/piecegroup.h

   1 /*
   2   Copyright (c) 2006 Paolo Capriotti <p.capriotti@sns.it>
   3             (c) 2006 Maurizio Monge <maurizio.monge@kdemail.net>
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9 */
  10
  11 #ifndef BOARD_H
  12 #define BOARD_H
  13
  14 #include <boost/shared_ptr.hpp>
  15 #include "canvas/group.h"
  16 #include "point.h"
  17 #include "grid.h"
  18 #include "animation.h"
  19 #include "piecesprite.h"
  20 #include "mainanimation.h"
  21 #include "pointconverter.h"
  22 #include "spriteloader.h"
  23 #include "clickablecanvas.h"
  24 #include "element.h"
  25
  26 class MainAnimation;
  27 class PointConverter;
  28 class SpriteLoader;
  29
  30 //BEGIN PieceGroup
  31
  32 /**
  33   * @class PieceGroup <piecegroup.h>
  34   * @brief The abstract base class for all widgets that draw pieces.
  35   *
  36   * PieceGroup is a general abstract widget that can be subclassed to
  37   * implement a rectangular widget with piece m_sprites on it.
  38   * It uses the method template pattern to provide a flexible yet comfortable
  39   * api for subclassing.
  40   */
  41 class PieceGroup : public ClickableCanvas, protected PointConverter {
  42 public:
  43
  44 protected:
  45   /** fading animations enabled */
  46   bool        m_anim_fade;
  47
  48   /** movement animations enabled */
  49   bool        m_anim_movement;
  50
  51   /** true if the board is flipped */
  52   bool        m_flipped;
  53
  54   /** size of a square in points */
  55   int         m_square_size;
  56
  57   /** loader class, to load pieces */
  58   SpriteLoader m_loader;
  59
  60   /** main animation structure */
  61   MainAnimation* m_main_animation;
  62
  63   /** enqueue an animation */
  64   void enqueue(const boost::shared_ptr<Animation>&);
  65
  66   /** stops all animations */
  67   void stopAnimations();
  68
  69   /** finalizes an animaiton group */
  70   void finalizeAnimation(AnimationGroup*);
  71
  72   /** ajdusts the sprite's position */
  73   void adjustSprite(const Point&, bool smooth = false);
  74
  75   /** enqueue a movement animation (convenience function) */
  76   void animatePiece(const boost::shared_ptr<PieceSprite>& piece,
  77                                   const Point& to, double speed);
  78
  79   /** fades in the sprite at a given point */
  80   void fadeIn(const Point&);
  81
  82   /** returns the sprite at p */
  83   virtual boost::shared_ptr<PieceSprite> spriteAt(const Point&) = 0;
  84
  85 public:
  86   PieceGroup(Canvas::Abstract* parent);
  87   virtual ~PieceGroup();
  88
  89   /** returns the point converter class */
  90   PointConverter* converter() { return static_cast<PointConverter*>(this); }
  91
  92   /** returns the point converter class */
  93   const PointConverter* converter() const { return static_cast<const PointConverter*>(this); }
  94
  95   /** returns the sprite loader */
  96   SpriteLoader* loader() { return &m_loader; }
  97
  98   /** returns the sprite loader */
  99   const SpriteLoader* loader() const { return &m_loader; }
 100
 101   /** returns the flipped value */
 102   virtual bool  flipped() const { return m_flipped; }
 103
 104   /** returns the size of a square */
 105   virtual int   squareSize() const { return m_square_size; }
 106
 107   /** returns the size of the grid */
 108   virtual Point gridSize() const = 0;
 109
 110   /** returns the center of a square */
 111   QPoint squareCenter(const QPoint& point) {
 112           return point - QPoint(m_square_size, m_square_size) / 2;
 113   }
 114
 115   /** x size (deprecated, use boardRect instead) */
 116   int    boardSizeX() { return m_square_size*gridSize().x; }
 117
 118   /** y size (deprecated, use boardRect instead) */
 119   int    boardSizeY() { return m_square_size*gridSize().y; }
 120
 121   /** returns the area covered by the piece grid */
 122   virtual QRect boardRect() { return QRect(pos(), QSize(m_square_size*gridSize().x,
 123                                                  m_square_size*gridSize().y)); }
 124
 125   /** returns the group that contains the pieces (override this) */
 126   virtual Canvas::Abstract* piecesGroup() = 0;
 127
 128   /** resize event handler (updates the sprites and the square size) */
 129   virtual void onResize(int new_size, bool force_reload = false);
 130
 131   /** changed settings handler */
 132   virtual void settingsChanged();
 133
 134   /** create a sprite from a pixmap */
 135   virtual boost::shared_ptr<PieceSprite> createSprite(const QPixmap& pix, const Point& pos);
 136 };
 137
 138 //END PieceGroup
 139
 140 #endif