File: oxygentileset.h

package info (click to toggle)
oxygen 4:5.8.4-1
  • links: PTS, VCS
  • area: main
  • in suites: stretch
  • size: 25,856 kB
  • ctags: 2,619
  • sloc: cpp: 21,895; python: 39; makefile: 20; sh: 13
file content (175 lines) | stat: -rw-r--r-- 5,857 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
#ifndef oxygentileset_h
#define oxygentileset_h

/*
 * Copyright 2009-2010 Hugo Pereira Da Costa <hugo.pereira@free.fr>
 * Copyright 2008 Long Huynh Huu <long.upcase@googlemail.com>
 * Copyright 2007 Matthew Woehlke <mw_triad@users.sourceforge.net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License version 2 as published by the Free Software Foundation.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#include "oxygen_export.h"

#include <QPixmap>
#include <QRect>
#include <QVector>

//* handles proper scaling of pixmap to match widget rect.
/**
tilesets are collections of stretchable pixmaps corresponding to a given widget corners, sides, and center.
corner pixmaps are never stretched. center pixmaps are
*/
namespace Oxygen
{
    class OXYGEN_EXPORT TileSet
    {
        public:

        //* default size for tileset tiles
        enum
        {
            DefaultSize = 7
        };

        /**
        Create a TileSet from a pixmap. The size of the bottom/right chunks is
        whatever is left over from the other chunks, whose size is specified
        in the required parameters.

        @param w1 width of the left chunks
        @param h1 height of the top chunks
        @param w2 width of the not-left-or-right chunks
        @param h2 height of the not-top-or-bottom chunks
        */
        TileSet(const QPixmap&, int w1, int h1, int w2, int h2 );

        /**
        Create a TileSet from a pixmap. The size of the top/left and bottom/right
        chunks is specified, with the middle chunks created from the specified
        portion of the pixmap. This allows the middle chunks to overlap the outer
        chunks (or to not use all pixels). The top/left and bottom/right chunks
        are carved out of the corners of the pixmap.

        @param w1 width of the left chunks
        @param h1 height of the top chunks
        @param w3 width of the right chunks
        @param h3 height of bottom chunks
        @param x2 x-coordinate of the top of the not-left-or-right chunks
        @param y2 y-coordinate of the left of the not-top-or-bottom chunks
        @param w2 width of the not-left-or-right chunks
        @param h2 height of the not-top-or-bottom chunks
        */
        TileSet(const QPixmap &pix, int w1, int h1, int w3, int h3, int x2, int y2, int w2, int h2 );

        //* empty constructor
        TileSet();

        //* destructor
        virtual ~TileSet()
        {}

        /**
        Flags specifying what sides to draw in ::render. Corners are drawn when
        the sides forming that corner are drawn, e.g. Top|Left draws the
        top-center, center-left, and top-left chunks. The center-center chunk is
        only drawn when Center is requested.
        */
        enum Tile {
            Top = 0x1,
            Left = 0x2,
            Bottom = 0x4,
            Right = 0x8,
            Center = 0x10,
            TopLeft = Top|Left,
            TopRight = Top|Right,
            BottomLeft = Bottom|Left,
            BottomRight = Bottom|Right,
            Ring = Top|Left|Bottom|Right,
            Horizontal = Left|Right|Center,
            Vertical = Top|Bottom|Center,
            Full = Ring|Center
        };
        Q_DECLARE_FLAGS(Tiles, Tile)

        /**
        Adjust rect to deal with missing tiles
        This will extend the relevant side so that the missing tiles extends beyond the
        rect passed as argument
        */

        QRect adjust( const QRect&, Tiles ) const;

        /**
        Fills the specified rect with tiled chunks. Corners are never tiled,
        edges are tiled in one direction, and the center chunk is tiled in both
        directions. Partial tiles are used as needed so that the entire rect is
        perfectly filled. Filling is performed as if all chunks are being drawn.
        */
        void render(const QRect&, QPainter*, Tiles = Ring) const;

        //* return size associated to this tileset
        QSize size( void ) const
        { return QSize( _w1 + _w3, _h1 + _h3 ); }

        //* is valid
        bool isValid( void ) const
        { return _pixmaps.size() == 9; }

        //* side extend
        /**
        it is used to (pre) tile the side pixmaps, in order to make further tiling faster when rendering, at the cost of
        using more memory for the cache. Changes to this member only affects tilesets that are created afterwards.
        */
        void setSideExtent( int value )
        { _sideExtent = value; }

        //* returns pixmap for given index
        QPixmap pixmap( int index ) const
        { return _pixmaps[index]; }

        protected:

        //* shortcut to pixmap list
        using PixmapList = QVector<QPixmap>;

        //* initialize pixmap
        void initPixmap( PixmapList&, const QPixmap&, int w, int h, const QRect& );

        private:

        //* side extend
        /**
        it is used to (pre) tile the side pixmaps, in order to make further tiling faster when rendering, at the cost of
        using more memory for the cache.
        */
        static int _sideExtent;

        //* pixmap arry
        PixmapList _pixmaps;

        // dimensions
        int _w1;
        int _h1;
        int _w3;
        int _h3;

    };

}

Q_DECLARE_OPERATORS_FOR_FLAGS(Oxygen::TileSet::Tiles)

#endif //TILESET_H