view_group.h 5.17 KB
Newer Older
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
/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2013 CERN
 * @author Maciej Suminski <maciej.suminski@cern.ch>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 *
 */

/**
 * @file view_group.h
 * @brief VIEW_GROUP extends VIEW_ITEM by possibility of grouping items into a single object.
 * VIEW_GROUP does not take over ownership of the held items. The main purpose of this class is
 * to group items and draw them on a single layer (in particular the overlay).
 */

#ifndef VIEW_GROUP_H_
#define VIEW_GROUP_H_

#include <view/view_item.h>
#include <deque>

39
namespace KIGFX
40 41 42 43
{
class VIEW_GROUP : public VIEW_ITEM
{
public:
44
    VIEW_GROUP( VIEW* aView = NULL );
45 46
    virtual ~VIEW_GROUP();

47 48 49 50
    /// Helper typedefs
    typedef std::set<VIEW_ITEM*>::const_iterator const_iter;
    typedef std::set<VIEW_ITEM*>::iterator iter;

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
    /**
     * Function Add()
     * Adds an item to the group.
     *
     * @param aItem is the item to be added.
     */
    virtual void Add( VIEW_ITEM* aItem );

    /**
     * Function Remove()
     * Removes an item from the group.
     *
     * @param aItem is the item to be removed.
     */
    virtual void Remove( VIEW_ITEM* aItem );

    /**
     * Function Clear()
     * Removes all the stored items from the group.
     */
    virtual void Clear();

    /**
     * Function Begin()
     * Returns iterator to beginning.
     */
77
    inline const_iter Begin() const
78 79 80 81 82 83 84 85
    {
        return m_items.begin();
    }

    /**
     * Function End()
     * Returns iterator to end.
     */
86
    inline const_iter End() const
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
    {
        return m_items.end();
    }

    /**
     * Function GetSize()
     * Returns the number of stored items.
     *
     * @return Number of stored items.
     */
    virtual unsigned int GetSize() const;

    /**
     * Function ViewBBox()
     * Returns the bounding box for all stored items covering all its layers.
     *
     * @return The current bounding box
     */
    virtual const BOX2I ViewBBox() const;

    /**
     * Function ViewDraw()
     * Draws all the stored items in the group on the given layer.
     *
     * @param aLayer is the layer which should be drawn.
     * @param aGal is the GAL that should be used for drawing.
     */
114
    virtual void ViewDraw( int aLayer, GAL* aGal ) const;
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135

    /**
     * Function ViewGetLayers()
     * Returns all the layers used by the stored items.
     *
     * @param aLayers[] is the output layer index array.
     * @param aCount is the number of layer indices in aLayers[].
     */
    virtual void ViewGetLayers( int aLayers[], int& aCount ) const;

    /**
     * Function SetLayer()
     * Sets layer used to draw the group.
     *
     * @param aLayer is the layer used for drawing.
     */
    inline virtual void SetLayer( int aLayer )
    {
        m_layer = aLayer;
    }

Maciej Suminski's avatar
Maciej Suminski committed
136 137 138 139
    /**
     * Function FreeItems()
     * Frees all the items that were added to the group.
     */
140 141
    void FreeItems();

Maciej Suminski's avatar
Maciej Suminski committed
142 143 144 145 146 147
    /**
     * Function GetView()
     * Returns pointer to the VIEW instance used by items.
     *
     * @return Pointer to the VIEW instance.
     */
148
    KIGFX::VIEW* GetView() const
149 150 151 152
    {
        return m_view;
    }

153 154 155 156 157 158 159 160 161 162 163 164 165 166
    /**
     * Function ItemsSetVisibility()
     * Sets visibility of items stored in the VIEW_GROUP.
     *
     * @param aVisible decides if items should be visible or not.
     */
    virtual void ItemsSetVisibility( bool aVisible );

    /**
     * Function ItemsViewUpdate()
     * Updates items stored in the VIEW_GROUP.
     *
     * @param aFlags determines the way in which items will be updated.
     */
Maciej Suminski's avatar
Maciej Suminski committed
167
    virtual void ItemsViewUpdate( VIEW_ITEM::VIEW_UPDATE_FLAGS aFlags );
168

169 170 171 172
protected:
    /// These functions cannot be used with VIEW_GROUP as they are intended only to work with
    /// singular VIEW_ITEMs (there is only one-to-one relation between item/layer combination and
    /// its group).
Maciej Suminski's avatar
Maciej Suminski committed
173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
    int getGroup( int aLayer ) const
    {
        return -1;
    }

    std::vector<int> getAllGroups() const
    {
        return std::vector<int>();
    }

    void setGroup( int aLayer, int aGroup )
    {}

    void deleteGroups()
    {}

    bool storesGroups() const
    {
        return false;
    }
193 194 195 196 197 198 199 200 201 202

    /// Layer on which the group is drawn
    int m_layer;

private:
    void updateBbox();

    /// Container for storing VIEW_ITEMs
    std::set<VIEW_ITEM*> m_items;
};
203
} // namespace KIGFX
204 205

#endif // VIEW_GROUP_H_