Porting to Graphics View

Porting scenes with tiles

QGraphicsScene does not provide an API for tiles. However, you can achieve similar behavior by drawing pixmaps in a reimplementation of QGraphicsScene::drawBackground().

Q3Canvas' tile support is based on providing one pixmap containing tiles of a fixed width and height, and then accessing them (reading and replacing tiles) by index. The tiles in the pixmap are arranged from the left to right, top to bottom.

With Graphics View, this pixmap can be stored as a member of a subclass of QGraphicsScene. The three main functions that make out the public tile API can then be declared as new members of this class. Here is one example of how to implement tile support:

 class TileScene : public QGraphicsScene
 {
 public:
     ...

     void setTiles(const QPixmap &pixmap, int h, int v,
                   int tileHeight, int tileWidth);
     void setTile(int x, int y, int tilenum);

 private:
     QRect tileRect(int x, int y) const;
     QRect tileRect(int tileNum) const;

     QVector<QVector<int> > tiles;
     QPixmap tilePixmap;
     int tileW, tileH;
     int hTiles, vTiles;
 };

Depending on how your scene uses tiles, you may be able to simplify this approach. In this example, we will try to mimic the behavior of the Q3Canvas functions.

We start by creating a subclass of QGraphicsScene ("TileScene"). In this class, we declare two of the tile functions from Q3Canvas, and we then add two helper function that returns the rectangle for a certain tile in our tile pixmap. We will use a two-dimensional vector of ints to keep track of what tiles should be used at what parts of the scene.

 void TileScene::setTiles(const QPixmap &pixmap, int h, int v,
                          int tileHeight, int tileWidth)
 {
     tilePixmap = pixmap;
     tileW = tileWidth;
     tileH = tileHeight;
     hTiles = h;
     vTiles = v;

     tiles.resize(v);
     for (int y = 0; y < v; ++y)
         tiles[y].resize(h);
 }

In setTiles(), we store the pixmap and tile properties as members of the class. Then we resize the tiles vector to match the width and height of our tile grid.

 void TileScene::setTile(int x, int y, int tilenum)
 {
     tiles[y][x] = tilenum;
     update(tileRect(x, y));
 }

The setTile() function updates the tiles index, and then updates the corresponding rect in the scene by calling tileRect().

 QRect TileScene::tileRect(int x, int y) const
 {
     return QRect(x * tileW, y * tileH, tileW, tileH);
 }

The first tileRect() function returns a QRect for the tile at position (x, y).

 QRect TileScene::tileRect(int tileNum) const
 {
     int numHTiles = tilePixmap.width() / tileW;
     int numVTiles = tilePixmap.height() / tileH;
     return tileRect(tileNum % numHTiles, tileNum / numHTiles);
 }

The second tileRect() function returns a QRect for a tile number. With these functions in place, we can implement the drawBackground() function.

 void drawBackground(QPainter *painter, const QRectF &exposed)
 {
     for (int y = 0; y < vTiles; ++y) {
         for (int x = 0; x < hTiles; ++x) {
             QRect destRect = tileRect(x, y);
             if (exposed.intersects(destRect)) {
                 painter->drawPixmap(destRect, tilePixmap,
                                     tileRect(tiles[y][x]));
             }
         }
     }
 }

In drawBackground(), we redraw all tiles that have been exposed by intersecting each tile rect with the exposed background area.

     // Before
     Q3CanvasEllipse ellipse(10, 10);

     // After
     QGraphicsEllipseItem ellipse(-5, -5, 10, 10);

 static QPainterPath fromControlPoints(const Q3PointArray &pa)
 {
     QPainterPath path;
     path.moveTo(pa[0]);
     for (int i = 1; i < pa.size(); i += 3)
         path.cubicTo(pa[i], pa[(i + 1) % pa.size()], pa[(i + 2) % pa.size()]);
     return path;
 }

 wildcardPath.replace("%1", "*");
 QFileInfo fi(wildcardPath);

 QList<QPixmap> frames;
 foreach (QString entry, QDir(fi.path(), fi.fileName()).entryList())
     frames << QPixmap(fi.path() + "/" + entry);