kolf/canvasitem.h

   1 /*
   2     Copyright (C) 2002-2005, Jason Katz-Brown <jasonkb@mit.edu>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17 */
  18
  19 #ifndef KOLF_CANVASITEM_H
  20 #define KOLF_CANVASITEM_H
  21
  22 #include <kdebug.h>
  23
  24 #include <QGraphicsView>
  25 #include <QGraphicsRectItem>
  26
  27 #include "config.h"
  28
  29 class Ball;
  30 class KConfigGroup;
  31 class StateDB;
  32 class KolfGame;
  33
  34 class CanvasItem
  35 {
  36 public:
  37         CanvasItem() { game = 0; }
  38         virtual ~CanvasItem() {}
  39         /**
  40          * load your settings from the KConfigGroup, which represents a course.
  41          */
  42         virtual void load(KConfigGroup *) {}
  43         /**
  44          * load a point if you wish. Rarely necessary.
  45          */
  46         virtual void loadState(StateDB * /*db*/) {}
  47         /**
  48          * returns a bool that is true if your item needs to load after other items
  49          */
  50         virtual bool loadLast() const { return false; }
  51         /**
  52          * called if the item is made by user while editing, with the item that was selected on the hole;
  53          */
  54         virtual void selectedItem(QGraphicsItem * /*item*/) {}
  55         /**
  56          * called after the item is moved the very first time by the game
  57          */
  58         virtual void firstMove(int /*x*/, int /*y*/) {}
  59         /**
  60          * used for resizing, also moves the item appropriately
  61          */
  62         virtual void resize(double /*resize factor*/) { kDebug(12007) << "Warning, empty resize used\n"; }
  63         /**
  64          * save your settings.
  65          */
  66         virtual void save(KConfigGroup *cfg);
  67         /**
  68          * save a point if you wish. Rarely necessary.
  69          */
  70         virtual void saveState(StateDB * /*db*/) {}
  71         /**
  72          * called for information when shot started
  73          */
  74         virtual void shotStarted() {}
  75         /**
  76          * called right before any items are saved.
  77          */
  78         virtual void aboutToSave() {}
  79         /**
  80          * called right after all items are saved.
  81          */
  82         virtual void savingDone() {}
  83         /**
  84          * called when the edit mode has been changed.
  85          */
  86         virtual void editModeChanged(bool /*editing*/) {}
  87         /**
  88          * the item should delete any other objects it's created.
  89          * DO NOT DO THIS KIND OF STUFF IN THE DESTRUCTOR!
  90          */
  91         virtual void aboutToDie() {}
  92         /**
  93          * returns the object to get rid of when the delete button is pressed on this item. Some sub-objects will return something other than this.
  94          */
  95         virtual CanvasItem *itemToDelete() { return this; }
  96         /**
  97          * called when user presses delete key while editing. This is very rarely reimplemented, and generally shouldn't be.
  98          */
  99         virtual void aboutToDelete() {}
 100         /**
 101          * returns whether this item should be able to be deleted by user while editing.
 102          */
 103         virtual bool deleteable() const { return true; }
 104         /**
 105          * returns whether this item should get doAdvance called -- it is called in sync with ball advancing (which is twice as fast as the advance() calling rate)
 106          */
 107         virtual bool fastAdvance() const { return false; }
 108         /**
 109          * called when all items have had their chance at a doAdvance
 110          */
 111         virtual void fastAdvanceDone() {}
 112         /**
 113          * called if fastAdvance is enabled
 114          */
 115         virtual void doAdvance() {}
 116         /**
 117          * if all items of this type of item (based on data()) that are "colliding" (ie, in the same spot) with ball should get collision() called.
 118          */
 119         virtual bool terrainCollisions() const { return false; }
 120         /**
 121          * returns whether or not this item lifts items on top of it.
 122          */
 123         virtual bool vStrut() const { return false; }
 124         /**
 125          * show extra item info
 126          */
 127         virtual void showInfo() {}
 128         /**
 129          * hide extra item info
 130          */
 131         virtual void hideInfo() {}
 132         /**
 133          * update your Z value (this is called by various things when perhaps the value should change) if this is called by a vStrut, it will pass 'this'.
 134          */
 135         virtual void updateZ(QGraphicsRectItem * /*vStrut*/ = 0) {}
 136         /**
 137          * clean up for prettyness
 138          */
 139         virtual void clean() {}
 140         /**
 141          * scale factor changed (game->scaleFactor(), the world matrix is game->worldMatrix())
 142          * NOTE: not used in Kolf 1.1, which comes with KDE 3.1.
 143          */
 144         virtual void scaleChanged() {}
 145         /**
 146          * returns whether this item can be moved by others (if you want to move an item, you should honor this!)
 147          */
 148         virtual bool canBeMovedByOthers() const { return false; }
 149         /**
 150          * returns a Config that can be used to configure this item by the user.
 151          * The default implementation returns one that says 'No configuration options'.
 152          */
 153         virtual Config *config(QWidget *parent) { return new DefaultConfig(parent); }
 154         /**
 155          * returns other items that should be moveable (besides this one of course).
 156          */
 157         virtual QList<QGraphicsItem *> moveableItems() const { return QList<QGraphicsItem *>(); }
 158         /**
 159          * returns whether this can be moved by the user while editing.
 160          */
 161         virtual bool moveable() const { return true; }
 162
 163         void setId(int newId) { id = newId; }
 164         int curId() const { return id; }
 165
 166         /**
 167          * call to play sound (ie, playSound("wall") plays kdedir/share/apps/kolf/sounds/wall.wav).
 168          * optionally, specify vol to be between 0-1, for no sound to full volume, respectively.
 169          */
 170         void playSound(const QString &file, double vol = 1);
 171
 172         /**
 173          * called on ball's collision. Return if terrain collidingItems should be processed.
 174          */
 175         virtual bool collision(Ball * /*ball*/, long int /*id*/) { return false; }
 176
 177         /**
 178          * reimplement if you want extra items to have access to the game object.
 179          * playSound() relies on having this.
 180          */
 181         virtual void setGame(KolfGame *game) { this->game = game; }
 182
 183         /**
 184          * returns whether this is a corner resizer
 185          */
 186         virtual bool cornerResize() const { return false; }
 187
 188         QString name() const { return m_name; }
 189         void setName(const QString &newname) { m_name = newname; }
 190         virtual void setSize(double /*width*/, double /*height*/) {;}
 191
 192         virtual void updateBaseResizeInfo() {}
 193
 194         /**
 195          * custom animation code
 196          */
 197         void setAnimated(bool animated) { this->animated=animated; }
 198         void setVelocity(double xv, double yv) { setXVelocity(xv); setYVelocity(yv); }
 199         void setXVelocity(double xVelocity) { this->xVelocity=xVelocity; }
 200         void setYVelocity(double yVelocity) { this->yVelocity=yVelocity; }
 201         double getXVelocity() { return xVelocity; }
 202         double getYVelocity() { return yVelocity; }
 203         virtual void moveBy(double , double) { kDebug(12007) << "Warning, empty moveBy used";} //needed so that float can call the own custom moveBy()s of everything on it
 204
 205 protected:
 206         /**
 207          * pointer to main KolfGame
 208          */
 209         KolfGame *game;
 210
 211         /**
 212          * returns the highest vertical strut the item is on
 213          */
 214         QGraphicsRectItem *onVStrut();
 215
 216         /**
 217          * custom animation code
 218          */
 219         bool animated;
 220         double xVelocity;
 221         double yVelocity;
 222
 223 private:
 224         QString m_name;
 225         int id;
 226 };
 227
 228 #endif