gls_map_symbology_basic_data_source.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsMapSymbologyBasicDataSource class.

  \par Copyright Information

  Copyright (c) 2017 The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>

  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.

  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.

  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).

  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.

*/
#ifndef INCLUDED_GLS_MAP_SYMBOLOGY_BASIC_DATA_SOURCE_H_
#define INCLUDED_GLS_MAP_SYMBOLOGY_BASIC_DATA_SOURCE_H_

#include "gls_map_symbology.h"
#include "gls_map_symbology_data_source.h"

#include "events.h"
#include "group.h"

namespace disti
{
/* This section defines the standard symbology data source classes.
 * The user may use one of these classes to store the symbology data
 * or define their own MapSymbologyDataSource to provide direct access
 * to another database. */

////////////////////////////////////////////////////////
// GlsMapSymbologyBasicDataSource template
////////////////////////////////////////////////////////

/// Basic icon data storage that may be used with the GlsMapSymbologyBasicDataSource class
class GlsMapSymbologyBasicIcon
{
public:
    /// Set the icon location
    inline void SetLocation( const GeoCoord& value ) { _location = value; }
    /// Get the icon location
    inline const GeoCoord& GetLocation() { return _location; }
    /// Set the icon type (geometry index)
    inline void SetType( int value ) { _type = value; }
    /// Get the icon type (geometry index)
    inline int GetType() { return _type; }

    GlsMapSymbologyBasicIcon()
        : _type( 0 )
    {}

protected:
    GeoCoord _location;
    int      _type;
};

/// Basic path data storage that may be used with the GlsMapSymbologyBasicDataSource class
class GlsMapSymbologyBasicPath
{
public:
    /// Set the number of points in the path.
    /// Point locations will be uninitialized.
    inline void SetPointCount( unsigned int value )
    {
        _points.Count( value );
        InvalidateBoundingRect();
    }

    /// \returns the number of points in the path
    inline unsigned int GetPointCount() { return _points.Count(); }

    /// Set the location of a given point
    /// If the point does not exist, the point count will be increased
    /// to point+1.  Any other new points allocated as a result of the
    /// increased count will be uninitialized.
    inline void SetPointLocation( int point, const GeoCoord& location )
    {
        _points[ point ] = location;
        InvalidateBoundingRect();
    }

    /// \returns the location of the given point
    inline const GeoCoord& GetPointLocation( int point ) { return _points[ point ]; }

    /// Set the path type (geometry index)
    /// Set to -1 to use the default path appearance.
    inline void SetType( int value ) { _type = value; }

    /// Get the path type (geometry index)
    inline int GetType() { return _type; }

    /// return the bounding rectangle for the given path
    inline const GeoRect& GetBoundingRect()
    {
        if( !_boundingRectIsValid )
        {
            CalculateBoundingRect();
        }
        return _boundingRect;
    }

    inline void InvalidateBoundingRect() { _boundingRectIsValid = false; }

    GlsMapSymbologyBasicPath()
        : _type( -1 )
        , _boundingRectIsValid( false )
    {}

protected:
    inline void CalculateBoundingRect()
    {
        _boundingRect.SetToNull();
        for( unsigned int i = 0; i < _points.Count(); i++ )
        {
            _boundingRect.GrowToContainPoint( _points[ i ] );
        }
    }

    DynamicArray<GeoCoord, false> _points;
    int                           _type;
    bool                          _boundingRectIsValid;
    GeoRect                       _boundingRect;
};

// This is a basic implementation of the
// MapSymbologyDataSource that users can derive from.
// Users may also create a data source that derives
// directly from the MapSymbologyDataSource
// interface if they prefer.
// This is a template class to allow the user to use
// their own icon and path storage classes if desired.
// The GlsMapSymbologyBasicIcon and GlsMapSymbologyBasicPath
// classes are provided as a possible starting point
// for the icon and path storage implementation.
template<class IconT, class PathT>
class GlsMapSymbologyBasicDataSource : public GlsMapSymbologyDataSource
{
public:
    ////////////////////////////////////////////////////////
    // MapSymbologyDataSource interface
    ////////////////////////////////////////////////////////

    /// See base class
    virtual void GetSymbolsInRegion( GlsMapSymbology* symbology, const GeoRect& region, IconIDList& icons, PathIDList& paths )
    {
        icons.Count( 0 );
        paths.Count( 0 );

        // Iterate through the icons and return the list of icons that are
        // inside the region.
        {
            const unsigned int iconCount = GetIconCount();
            IconT*             current;
            IconID             iconID;
            for( unsigned int iconIdx = 0; iconIdx < iconCount; iconIdx++ )
            {
                iconID  = _iconIDArray[ iconIdx ];
                current = GetIcon( iconID );
                if( current && IconIsVisible( current ) && region.ContainsPoint( current->GetLocation() ) )
                {
                    icons.PushBack( iconID );
                }
            }
        }

        // Iterate through the paths and return the list of paths that
        // intersect the region.
        {
            const unsigned int pathCount = GetPathCount();
            PathT*             current;
            PathID             pathID;
            for( unsigned int pathIdx = 0; pathIdx < pathCount; pathIdx++ )
            {
                pathID  = _pathIDArray[ pathIdx ];
                current = GetPath( pathID );
                if( current && PathIsVisible( current ) && region.Intersects( current->GetBoundingRect() ) )
                {
                    paths.PushBack( pathID );
                }
            }
        }
    }

    /// See base class
    virtual DisplayObject* GetIconGeometry( IconID iconID, GlsMapSymbology* symbology )
    {
        // Return the DisplayObject in the symbology group
        // that should be used to draw the given icon.
        IconT* icon = GetIcon( iconID );
        if( icon )
        {
            int geomIndex = icon->GetType();
            if( symbology && geomIndex > -1 && ( (unsigned int)geomIndex ) < symbology->Count() )
            {
                return symbology->Item( geomIndex );
            }
        }

        return NULL; // No icon found
    }

    /// See base class
    virtual void GetIconLocation( IconID iconID, GeoCoord& location )
    {
        IconT* icon = GetIcon( iconID );
        if( icon )
        {
            location = icon->GetLocation();
        }
    }

    /// See base class
    virtual DisplayObject* GetPathGeometry( PathID pathID, GlsMapSymbology* symbology )
    {
        // Return the DisplayObject in the symbology group
        // that should be used to draw the given path.
        PathT* path = GetPath( pathID );
        if( path )
        {
            int geomIndex = path->GetType();
            if( geomIndex > -1 && symbology && ( (unsigned int)geomIndex ) < symbology->Count() )
            {
                return symbology->Item( geomIndex );
            }
        }

        return NULL; // Use the default path geometry
    }

    /// See base class
    virtual long GetPathPointCount( PathID pathID )
    {
        PathT* path = GetPath( pathID );
        if( path )
            return path->GetPointCount();
        else
            return 0;
    }

    /// See base class
    virtual void GetPathPointLocation( PathID pathID, long point, GeoCoord& locationOut )
    {
        PathT* path = GetPath( pathID );
        if( path )
        {
            locationOut = path->GetPointLocation( point );
        }
    }

    /// See base class
    virtual void SetupIconForRendering( GlsMapSymbology*, IconID iconID, DisplayObject* iconGeometry )
    {
        // Override this to apply any custom data to the icons when they draw
    }

    /// See base class
    virtual void SetupPathForRendering( GlsMapSymbology*, PathID pathID, DisplayObject* iconGeometry )
    {
        // Override this to apply any custom data to the paths when they draw
    }

    /// See base class
    virtual void PostDraw( disti::GlsMapView* view, disti::GlsMapSymbology* symbology )
    {
        // Override this to perform additional rendering if needed.
    }

    ////////////////////////////////////////////////////////
    // GlsMapSymbologyBasicDataSource functionality...
    ////////////////////////////////////////////////////////

    /// Derived classes can override this method
    /// to disable drawing of certain icon types.
    virtual bool IconIsVisible( IconT* icon )
    {
        return true;
    }

    /// Derived classes can override this method
    /// to disable drawing of certain path types.
    virtual bool PathIsVisible( PathT* path )
    {
        return true;
    }

    /// Add an icon to the data source
    /// \param location The location of the new icon
    /// \param geometryIndex The geometry index to use for drawing. (-1 indicates do not draw)
    /// \returns the IconID for the new icon
    virtual IconID AddIcon( const GeoCoord& location, int geometryIndex )
    {
        IconT icon;

        icon.SetLocation( location );
        icon.SetType( geometryIndex );

        IconID id = GetNextIconID();
        _iconArray.PushBack( icon );
        _iconIDArray.PushBack( id );
        return id;
    }

    /// Access an icon in the data source
    /// \param iconID IconID of the desired icon
    /// \returns Pointer to the given icon, or NULL if not found
    virtual IconT* GetIcon( IconID iconID )
    {
        int idx = FindIconByID( iconID );
        if( idx == -1 )
            return NULL;

        return &( _iconArray[ idx ] );
    }

    /// \returns The number of icons in the data source
    virtual unsigned int GetIconCount()
    {
        return _iconArray.Count();
    }

    /// Updates the given icon if it exists
    /// \param iconID The identifier of the icon to update
    /// \param location The new location of the icon
    virtual void UpdateIcon( IconID iconID, GeoCoord& location )
    {
        IconT* icon = GetIcon( iconID );
        if( icon )
        {
            icon->SetLocation( location );
        }
    }

    /// Updates the given icon if it exists
    /// \param iconID The identifier of the icon to update
    /// \param location The new location of the icon
    /// \param geometryIndex The geometry index to use for drawing.
    virtual void UpdateIcon( IconID iconID, GeoCoord& location, int geometryIndex )
    {
        IconT* icon = GetIcon( iconID );
        if( icon )
        {
            icon->SetLocation( location );
            icon->SetType( geometryIndex );
        }
    }

    /// Add a path to the data source
    /// Call GetPath() with the returned PathID to
    /// access the new path and add/modify points in the path.
    /// \sa GetPath
    /// \returns the PathID of the new path
    virtual PathID AddPath()
    {
        PathT path;

        PathID id = GetNextPathID();
        _pathArray.PushBack( path );
        _pathIDArray.PushBack( id );
        return id;
    }

    /// Access a path in the data source
    /// \param pathID PathID of the desired path
    /// \returns Pointer to the given path, or NULL if not found
    virtual PathT* GetPath( PathID pathID )
    {
        int idx = FindPathByID( pathID );
        if( idx == -1 )
            return NULL;

        return &( _pathArray[ idx ] );
    }

    /// \returns The number of paths in the data source
    virtual unsigned int GetPathCount()
    {
        return _pathArray.Count();
    }

    /// Remove a icon from the data source
    virtual void RemoveIcon( IconID iconID )
    {
        int idx = FindIconByID( iconID );
        if( idx > -1 )
        {
            _iconArray.EraseAt( idx );
            _iconIDArray.EraseAt( idx );
        }
    }

    /// Remove a path from the data source
    virtual void RemovePath( PathID pathID )
    {
        int idx = FindPathByID( pathID );
        if( idx > -1 )
        {
            _pathArray.EraseAt( idx );
            _pathIDArray.EraseAt( idx );
        }
    }

    /// Remove all icons from the data source
    virtual void RemoveAllIcons()
    {
        _iconArray.Count( 0 );
        _iconIDArray.Count( 0 );
    }

    /// Remove all paths from the data source
    virtual void RemoveAllPaths()
    {
        _pathArray.Count( 0 );
        _pathIDArray.Count( 0 );
    }

    GlsMapSymbologyBasicDataSource()
    {
        _nextIconID = 1;
        _nextPathID = 1;
    }

    virtual ~GlsMapSymbologyBasicDataSource()
    {
        RemoveAllIcons();
        RemoveAllPaths();
    }

protected:
    DynamicArray<IconT, false> _iconArray;
    DynamicArray<IconID>       _iconIDArray; // Parallel array contains Icon IDs for Icon entries
    IconID                     _nextIconID;
    IconID                     GetNextIconID() { return _nextIconID++; }

    int FindIconByID( IconID id )
    {
        for( unsigned int i = 0; i < _iconIDArray.Count(); i++ )
            if( _iconIDArray[ i ] == id )
                return (int)i;

        return -1;
    }

    DynamicArray<PathT, false> _pathArray;
    DynamicArray<PathID>       _pathIDArray; // Parallel array contains Path IDs for Path entries
    PathID                     _nextPathID;
    PathID                     GetNextPathID() { return _nextPathID++; }

    int FindPathByID( PathID id )
    {
        for( unsigned int i = 0; i < _pathIDArray.Count(); i++ )
            if( _pathIDArray[ i ] == id )
                return (int)i;

        return -1;
    }
};

} // namespace disti
#endif