map_shapes.cpp

Go to the documentation of this file.

//                                                       //
//                         SAGA                          //
//                                                       //
//      System for Automated Geoscientific Analyses      //
//                                                       //
//           Application Programming Interface           //
//                                                       //
//                  Library: SAGA_API                    //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//                    map_shapes.cpp                     //
//                                                       //
//                 Copyright (C) 2026 by                 //
//                      Olaf Conrad                      //
//                                                       //
//-------------------------------------------------------//
//                                                       //
// This file is part of 'SAGA - System for Automated     //
// Geoscientific Analyses'. SAGA 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.       //
//                                                       //
// SAGA 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, see   //
// <http://www.gnu.org/licenses/>.                       //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//    e-mail:     oconrad@saga-gis.org                   //
//                                                       //
//    contact:    Olaf Conrad                            //
//                Institute of Geography                 //
//                University of Hamburg                  //
//                Germany                                //
//                                                       //
 
//---------------------------------------------------------
#include "../dc_helper.h"
 
#include "map_symbology.h"
 
#include "map_layer.h"
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CSG_Map_Shapes::CSG_Map_Shapes(void)
        : CSG_Map_Layer(SG_DATAOBJECT_TYPE_Shapes)
{
        m_bNoData   = true;
        m_bVertices = 0;
        m_DrawOrder = 0;
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Shapes::Add_Parameters(CSG_Parameters &Parameters)
{
        CSG_Map_Layer::Add_Parameters(Parameters);
 
        //-----------------------------------------------------
        // Display...
 
        Parameters.Add_Choice("NODE_DISPLAY"      , "DRAWING_ORDER"           , _TL("Drawing Order"      ), _TL(""), CSG_String::Format("%s|%s",
                _TL("data set"),
                _TL("attribute sorting"))
        );
 
        //-----------------------------------------------------
        // Classification...
 
        Parameters.Add_Bool  ("NODE_COLORS"       , "NODATA_SHOW"             , _TL("Show No-Data"       ), _TL(""), true);
        Parameters.Add_Color ("NODATA_SHOW"       , "NODATA_COLOR"            , _TL("Color"              ), _TL(""), SG_COLOR_GREY_LIGHT);
 
        //-----------------------------------------------------
        // Label...
 
        Parameters.Add_Choice("NODE_LABEL"        , "LABEL_FIELD"             , _TL("Field"              ), _TL(""), CSG_String::Format("<%s>", _TL("default")));
        Parameters.Add_Font  ("LABEL_FIELD"       , "LABEL_FIELD_FONT"        , _TL("Font"               ), _TL(""));
 
        #ifndef _SAGA_MSW
        Parameters.Add_Color ("LABEL_FIELD_FONT"  , "LABEL_COLOR"                    , _TL("Color"              ), _TL(""), SG_Get_Color(SG_System_Get_Color_Foreground()));
        #endif
 
        Parameters.Add_Choice("LABEL_FIELD"       , "LABEL_FIELD_EFFECT"      , _TL("Boundary Effect"    ), _TL(""), CSG_String::Format("%s|%s|%s|%s|%s|%s|%s|%s|%s|%s",
                _TL("none"),
                _TL("full frame"),
                _TL("top"),
                _TL("top left"),
                _TL("left"),
                _TL("bottom left"),
                _TL("bottom"),
                _TL("bottom right"),
                _TL("right"),
                _TL("top right")), 1
        );
 
        Parameters.Add_Color ("LABEL_FIELD_EFFECT", "LABEL_FIELD_EFFECT_COLOR", _TL("Color"              ), _TL(""), SG_Get_Color(SG_System_Get_Color_Background()));
        Parameters.Add_Int   ("LABEL_FIELD_EFFECT", "LABEL_FIELD_EFFECT_SIZE" , _TL("Size"               ), _TL(""), 1, 1, true);
        Parameters.Add_Choice("LABEL_FIELD"       , "LABEL_FIELD_PREC"        , _TL("Numerical Precision"), _TL(""), CSG_String::Format("%s|%s|%s",
                _TL("fit to value"),
                _TL("standard"),
                SG_T("0|0.1|0.12|0.123|0.1234|0.12345|0.1234567|0.12345678|0.123456789|0.1234567890|0.12345678901|0.123456789012|0.1234567890123|0.12345678901234|0.123456789012345|0.1234567890123456|0.12345678901234567|0.123456789012345678|0.1234567890123456789|0.12345678901234567890")), 0
        );
 
        Parameters.Add_Choice("LABEL_FIELD"       , "LABEL_FIELD_SIZE_TYPE"   , _TL("Size relates to..." ), _TL(""), CSG_String::Format("%s|%s|",
                _TL("Screen"),
                _TL("Map Units")), 0
        );
 
        Parameters.Add_Choice("LABEL_FIELD"       , "LABEL_FIELD_SIZEBY"      , _TL("Size by Attribute"  ), _TL(""), CSG_String::Format("<%s>", _TL("<default>")));
 
        Parameters.Add_Double("LABEL_FIELD_SIZEBY", "LABEL_FIELD_SIZE"        , _TL("Default Size"       ), _TL(""), 100., 0., true);
 
        //-----------------------------------------------------
        // Charts...
 
        Parameters.Add_Bool      ("NODE_CHART", "CHART_SHOW"    , _TL("Show"    ), _TL(""), false);
        Parameters.Add_Parameters("CHART_SHOW", "CHART_SETTINGS", _TL("Settings"), _TL(""));
 
        //-----------------------------------------------------
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Shapes::Parameter_Changed(CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags)
{
        //-----------------------------------------------------
        if( Flags & PARAMETER_CHECK_VALUES )
        {
                // ...
        }
 
        //-----------------------------------------------------
        if( Flags & PARAMETER_CHECK_ENABLE )
        {
                if(     Parameters.Cmp_Identifier("CHART_SETTINGS") )
                {
                        if( Parameter.Cmp_Identifier("SIZE_FIELD") )
                        {
                                int Field = Get_Fields_Choice(Parameter);
 
                                Parameters.Set_Enabled("SIZE_RANGE"  , Field >= 0);
                                Parameters.Set_Enabled("SIZE_DEFAULT", Field <  0);
                        }
                        else
                        {
                                CSG_String ID(Parameter.Get_Identifier());
 
                                if( ID.Find("FIELD_") == 0 )
                                {
                                        ID.Replace("FIELD_", "COLOR_");
 
                                        Parameters.Set_Enabled(ID, Parameter.asBool());
                                }
                        }
 
                        return( 1 );
                }
 
                //-------------------------------------------------
                if(     Parameter.Cmp_Identifier("COLOR_SYMBOLS") )
                {
                        Parameters.Set_Enabled("NODATA_SHOW"  , Parameter.asInt() > 0); // not 'single symbol'
                }
 
                if(     Parameter.Cmp_Identifier("NODATA_SHOW") )
                {
                        Parameters.Set_Enabled("NODATA_COLOR" , Parameter.asBool());
                }
 
                if(     Parameter.Cmp_Identifier("OUTLINE") )
                {
                        Parameters.Set_Enabled("OUTLINE_COLOR", Parameter.asBool());
                        Parameters.Set_Enabled("OUTLINE_SIZE" , Parameter.asBool());
                }
 
                if(     Parameter.Cmp_Identifier("LABEL_FIELD") )
                {
                        Parameter.Set_Children_Enabled(Get_Fields_Choice(Parameter) >= 0);
                }
 
                if( Parameter.Cmp_Identifier("LABEL_FIELD_SIZE_TYPE")
                ||  Parameter.Cmp_Identifier("LABEL_FIELD_SIZEBY"   ) )
                {
                        bool Value = Parameters["LABEL_FIELD_SIZE_TYPE"].asInt() != 0 || Get_Fields_Choice(Parameters["LABEL_FIELD_SIZEBY"]) >= 0;
 
                        Parameters.Set_Enabled("LABEL_FIELD_SIZE", Value);
                }
 
                if(     Parameter.Cmp_Identifier("LABEL_FIELD_EFFECT") )
                {
                        Parameter.Set_Children_Enabled(Parameter.asInt() != 0);
                }
 
                if(     Parameter.Cmp_Identifier("CHART_SHOW") )
                {
                        Parameters.Set_Enabled("CHART_SETTINGS", Parameter.asBool());
                }
        }
 
        //-----------------------------------------------------
        return( CSG_Map_Layer::Parameter_Changed(Parameters, Parameter, Flags) );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Shapes::DataObject_Changed(void)
{
        CSG_Map_Layer::DataObject_Changed();
 
        //-----------------------------------------------------
        Set_Fields_Choice(m_Parameters["CLASSIFIED_FIELD"    ], false, false, false);
        Set_Fields_Choice(m_Parameters["CLASSIFIED_NORMALIZE"],  true,  true,  true);
        Set_Fields_Choice(m_Parameters["STRETCH_FIELD"       ],  true, false, false);
        Set_Fields_Choice(m_Parameters["STRETCH_NORMALIZE"   ],  true,  true,  true);
        Set_Fields_Choice(m_Parameters["LABEL_FIELD"         ], false,  true,  true);
        Set_Fields_Choice(m_Parameters["LABEL_FIELD_SIZEBY"  ],  true,  true,  true);
 
        m_Chart.Set_Options(m_pObject->asShapes(), *m_Parameters["CHART_SETTINGS"].asParameters());
 
        //-----------------------------------------------------
        return( true );
}
 
//---------------------------------------------------------
bool CSG_Map_Shapes::Parameters_Changed(void)
{
        CSG_Map_Layer::Parameters_Changed();
 
        //-----------------------------------------------------
        switch( m_Parameters["COLOR_SYMBOLS"].asInt() )
        {
        default: // CSG_Map_Symbology::SINGLE
                m_Stretch.Value  = -1;
                m_Stretch.Normal = -1;
                break;
 
        case  1: // CSG_Map_Symbology::CLASSIFIED
                m_Stretch.Value  = Get_Fields_Choice(m_Parameters["CLASSIFIED_FIELD"    ]);
                m_Stretch.Normal = Get_Fields_Choice(m_Parameters["CLASSIFIED_NORMALIZE"]);
                m_Stretch.Scale  = 1.;
                break;
 
        case  2: // CSG_Map_Symbology::DISCRETE
        case  3: // CSG_Map_Symbology::GRADUATED
                m_Stretch.Value  = Get_Fields_Choice(m_Parameters["STRETCH_FIELD"       ]);
                m_Stretch.Normal = Get_Fields_Choice(m_Parameters["STRETCH_NORMALIZE"   ]);
                m_Stretch.Scale  = m_Parameters["STRETCH_NORMALIZE_FORMAT"].asInt() == 0 ? 1. : 100.;
                break;
        }
 
        if( m_Stretch.Value < 0 )
        {
                m_pSymbology->Set_Mode(CSG_Map_Symbology::SINGLE);
        }
        else if( m_Parameters["COLOR_SYMBOLS"].asInt() == 2 || m_Parameters["COLOR_SYMBOLS"].asInt() == 3 ) // discrete/graduated
        {
                Set_Stretch(m_Parameters);
 
                m_pSymbology->Set_Stretch(
                        m_Parameters["STRETCH_RANGE.MIN"     ].asDouble(),
                        m_Parameters["STRETCH_RANGE.MAX"     ].asDouble(),
                        m_Parameters["STRETCH_INTERVALS"     ].asInt   (),
                        m_Parameters["STRETCH_INTERVALS_LOG" ].asDouble()
                );
 
                m_pSymbology->Update();
        }
 
        //-----------------------------------------------------
        m_bNoData = m_Parameters["NODATA_SHOW"].asBool();
 
        //-----------------------------------------------------
        m_Label.Field = Get_Fields_Choice(m_Parameters["LABEL_FIELD"]);
 
        m_Label.Effect_Color = m_Parameters["LABEL_FIELD_EFFECT_COLOR"].asColor();
        m_Label.Effect_Size  = m_Parameters["LABEL_FIELD_EFFECT_SIZE" ].asInt  ();
        m_Label.Precision    = m_Parameters["LABEL_FIELD_PREC"        ].asInt  ();
 
        switch( m_Label.Precision )
        {
        case  0: m_Label.Precision  = -m_Parameters["TABLE_FLT_DECIMALS"].asInt(); break;
        case  1: m_Label.Precision  = -99; break;
        default: m_Label.Precision -=   2; break;
        }
 
        switch( m_Parameters["LABEL_FIELD_EFFECT"].asInt() )
        {
        default: m_Label.Effect = SG_DC_TEXTEFFECT_NONE       ; break;
        case  1: m_Label.Effect = SG_DC_TEXTEFFECT_FRAME      ; break;
        case  2: m_Label.Effect = SG_DC_TEXTEFFECT_TOP        ; break;
        case  3: m_Label.Effect = SG_DC_TEXTEFFECT_TOPLEFT    ; break;
        case  4: m_Label.Effect = SG_DC_TEXTEFFECT_LEFT       ; break;
        case  5: m_Label.Effect = SG_DC_TEXTEFFECT_BOTTOMLEFT ; break;
        case  6: m_Label.Effect = SG_DC_TEXTEFFECT_BOTTOM     ; break;
        case  7: m_Label.Effect = SG_DC_TEXTEFFECT_BOTTOMRIGHT; break;
        case  8: m_Label.Effect = SG_DC_TEXTEFFECT_RIGHT      ; break;
        case  9: m_Label.Effect = SG_DC_TEXTEFFECT_TOPRIGHT   ; break;
        }
 
        //-----------------------------------------------------
        m_Chart.Get_Options(m_pObject->asShapes(), *m_Parameters["CHART_SETTINGS"].asParameters());
 
        //-----------------------------------------------------
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
CSG_Shape * CSG_Map_Shapes::Get_Shape(sLong i)
{
        return( !m_DrawOrder ? m_pObject->asShapes()->Get_Shape(i) : m_pObject->asShapes()->Get_Shape_byIndex(i) );
}
 

//                                                       //
 
//---------------------------------------------------------
void CSG_Map_Shapes::On_Draw(CSG_Map_DC &dc_Map, int Flags)
{
        if( Get_Extent().Intersects(dc_Map.rWorld()) == INTERSECTION_None )
        {
                return;
        }
 
        //-----------------------------------------------------
        if( (Flags & LAYER_DRAW_FLAG_THUMBNAIL) != 0 )
        {
                Draw_Initialize(dc_Map, LAYER_DRAW_FLAG_THUMBNAIL);
 
                Draw_Thumbnails(dc_Map, 0);
 
                return;
        }
 
        //-----------------------------------------------------
        if( m_Parameters["TRANSPARENCY"].asDouble() > 0. )
        {
                dc_Map.Draw_Layer_Begin();
        }
 
        m_DrawOrder = m_Parameters["DRAWING_ORDER"].asInt();
 
        Draw_Initialize(dc_Map, Flags);
 
        //-----------------------------------------------------
        for(sLong i=0; i<m_pObject->asShapes()->Get_Count(); i++)
        {
                if( (Flags & LAYER_DRAW_FLAG_NOEDITS) != 0 || !Get_Shape(i)->is_Selected() )
                {
                        _Draw_Shape(dc_Map, Get_Shape(i));
                }
        }
 
        if( m_Parameters["CHART_SHOW"].asBool() && m_Chart.is_Valid() )
        {
                for(sLong i=0; i<m_pObject->asShapes()->Get_Count(); i++)
                {
                        if( (Flags & LAYER_DRAW_FLAG_NOEDITS) != 0 || !Get_Shape(i)->is_Selected() )
                        {
                                m_Chart.Draw(dc_Map, Get_Shape(i));
                        }
                }
        }
 
        //-----------------------------------------------------
        if( (Flags & LAYER_DRAW_FLAG_NOLABELS) == 0 && m_Label.Field >= 0 )      // Labels
        {
                int    iSize = Get_Fields_Choice(m_Parameters["LABEL_FIELD_SIZEBY"]);
                double dSize = m_Parameters["LABEL_FIELD_SIZE_TYPE"].asInt() == 1
                        ? dc_Map.World2DC() * m_Parameters["LABEL_FIELD_SIZE"].asDouble() : 1.;
 
                dc_Map.SetFont(SG_Get_wxFont(m_Parameters("LABEL_FIELD_FONT")));
                dc_Map.Get_DC().SetTextForeground(m_Parameters[m_Parameters("LABEL_COLOR") ? "LABEL_COLOR" : "LABEL_FIELD_FONT"].asColor());
 
                if( iSize >= 0 && iSize < m_pObject->asShapes()->Get_Field_Count() )    // size by attribute
                {
                        for(sLong i=0; i<m_pObject->asShapes()->Get_Count(); i++)
                        {
                                int Size = (int)(0.5 + dSize * Get_Shape(i)->asDouble(iSize));
 
                                if( Size > 0 )
                                {
                                        _Draw_Label(dc_Map, Get_Shape(i), Size);
                                }
                        }
                }
                else    // one size fits all
                {
                        int Size = m_Parameters["LABEL_FIELD_SIZE_TYPE"].asInt() == 1 ? (int)(0.5 + dSize) : dc_Map.Get_DC().GetFont().GetPointSize();
 
                        if( Size > 0 )
                        {
                                for(sLong i=0; i<m_pObject->asShapes()->Get_Count(); i++)
                                {
                                        _Draw_Label(dc_Map, Get_Shape(i), Size);
                                }
                        }
                }
        }
 
        //-----------------------------------------------------
        if( m_Parameters["TRANSPARENCY"].asDouble() > 0. ) // Transparency ?
        {
                dc_Map.Draw_Layer_End(m_Parameters["TRANSPARENCY"].asDouble() / 100.);
        }
}
 
//---------------------------------------------------------
void CSG_Map_Shapes::Draw_Thumbnails(CSG_Map_DC &dc_Map, int Limit)
{
        Draw_Initialize(dc_Map, LAYER_DRAW_FLAG_THUMBNAIL);
 
        if( Limit < 1 || m_pObject->asShapes()->Get_Count() <= Limit )
        {
                for(sLong i=0; i<m_pObject->asShapes()->Get_Count(); i++)
                {
                        Draw_Shape(dc_Map, Get_Shape(i), LAYER_DRAW_FLAG_THUMBNAIL);
                }
        }
        else
        {
                double d = m_pObject->asShapes()->Get_Count() / (double)Limit;
 
                for(double i=0; (sLong)i<m_pObject->asShapes()->Get_Count(); i+=d)
                {
                        Draw_Shape(dc_Map, Get_Shape((sLong)i), LAYER_DRAW_FLAG_THUMBNAIL);
                }
        }
}
 
//---------------------------------------------------------
void CSG_Map_Shapes::_Draw_Shape(CSG_Map_DC &dc_Map, CSG_Shape *pShape, int Flags)
{
        if( pShape && dc_Map.rWorld().Intersects(pShape->Get_Extent()) != INTERSECTION_None )
        {
                Draw_Shape(dc_Map, pShape, Flags);
 
                if( m_bVertices > 0 )
                {
                        wxPen   oldPen  (dc_Map.Get_DC().GetPen  ()); dc_Map.SetPen  (*wxBLACK_PEN  );
                        wxBrush oldBrush(dc_Map.Get_DC().GetBrush()); dc_Map.SetBrush(*wxWHITE_BRUSH);
 
                        bool bLabel = m_bVertices == 2 && ((Flags & LAYER_DRAW_FLAG_SELECTION) || m_pObject->asShapes()->Get_Selection_Count() == 0);
 
                        for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
                        {
                                for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
                                {
                                        TSG_Point_Int A = dc_Map.World2DC(pShape->Get_Point(iPoint, iPart));
 
                                        dc_Map.DrawCircle(A.x, A.y, 2);
 
                                        if( bLabel )
                                        {
                                                dc_Map.DrawText(SG_DC_TEXTALIGN_TOPLEFT, A.x, A.y, wxString::Format("%d", iPoint + 1));
                                        }
                                }
                        }
 
                        dc_Map.SetPen  (oldPen  );
                        dc_Map.SetBrush(oldBrush);
                }
        }
}
 
//---------------------------------------------------------
void CSG_Map_Shapes::_Draw_Label(CSG_Map_DC &dc_Map, CSG_Shape *pShape, int PointSize)
{
        if( pShape && dc_Map.rWorld().Intersects(pShape->Get_Extent()) != INTERSECTION_None )
        {
                wxString Label(pShape->asString(m_Label.Field, m_Label.Precision)); Label.Trim(true).Trim(false);
 
                if( !Label.IsEmpty() )
                {
                        if( PointSize > 0 && PointSize != dc_Map.Get_DC().GetFont().GetPointSize() )
                        {
                                wxFont Font(dc_Map.Get_DC().GetFont());
 
                                Font.SetPointSize(PointSize);
 
                                dc_Map.SetFont(Font);
                        }
 
                        Draw_Label(dc_Map, pShape, Label);
                }
        }
}
 

//                                                       //
 
//---------------------------------------------------------
CSG_Parameter * CSG_Map_Shapes::BrushList_Add(CSG_Parameters &Parameters, const CSG_String &ParentID, const CSG_String &Identifier, const CSG_String &Name, const CSG_String &Description) const
{
        return( Parameters.Add_Choice(ParentID, Identifier, Name, Description,
                CSG_String::Format("%s|%s|%s|%s|%s|%s|%s|%s|",
                        _TL("Opaque"           ),
                        _TL("Transparent"      ),
                        _TL("Backward Diagonal"),
                        _TL("Cross Diagonal"   ),
                        _TL("Forward Diagonal" ),
                        _TL("Cross"            ),
                        _TL("Horizontal"       ),
                        _TL("Vertical"         )
                ), 0)
        );
}
 
//---------------------------------------------------------
wxBrushStyle CSG_Map_Shapes::BrushList_Get_Style(const CSG_String &Identifier)
{
        switch( m_Parameters[Identifier].asInt() )
        {
        default: return( wxBRUSHSTYLE_SOLID           );
        case  1: return( wxBRUSHSTYLE_TRANSPARENT     );
        case  2: return( wxBRUSHSTYLE_BDIAGONAL_HATCH );
        case  3: return( wxBRUSHSTYLE_CROSSDIAG_HATCH );
        case  4: return( wxBRUSHSTYLE_FDIAGONAL_HATCH );
        case  5: return( wxBRUSHSTYLE_CROSS_HATCH     );
        case  6: return( wxBRUSHSTYLE_HORIZONTAL_HATCH);
        case  7: return( wxBRUSHSTYLE_VERTICAL_HATCH  );
        }
}
 
//---------------------------------------------------------
CSG_Parameter * CSG_Map_Shapes::PenList_Add(CSG_Parameters &Parameters, const CSG_String &ParentID, const CSG_String &Identifier, const CSG_String &Name, const CSG_String &Description) const
{
        return( Parameters.Add_Choice(ParentID, Identifier, Name, Description,
                CSG_String::Format("%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|",
                        _TL("Solid style"),
                        _TL("Dotted style"),
                        _TL("Long dashed style"),
                        _TL("Short dashed style"), 
                        _TL("Dot and dash style"),
                        _TL("Backward diagonal hatch"),
                        _TL("Cross-diagonal hatch"),
                        _TL("Forward diagonal hatch"),
                        _TL("Cross hatch"),
                        _TL("Horizontal hatch"),
                        _TL("Vertical hatch")
                //      _TL("Use the stipple bitmap")
                //      _TL("Use the user dashes")
                //      _TL("No pen is used")
                ), 0)
        );
}
 
//---------------------------------------------------------
int CSG_Map_Shapes::PenList_Get_Style(const CSG_String &Identifier)
{
        switch( m_Parameters[Identifier].asInt() )
        {
        default: return( wxPENSTYLE_SOLID            ); // Solid style.
        case  1: return( wxPENSTYLE_DOT              ); // Dotted style.
        case  2: return( wxPENSTYLE_LONG_DASH        ); // Long dashed style.
        case  3: return( wxPENSTYLE_SHORT_DASH       ); // Short dashed style.
        case  4: return( wxPENSTYLE_DOT_DASH         ); // Dot and dash style.
        case  5: return( wxPENSTYLE_BDIAGONAL_HATCH  ); // Backward diagonal hatch.
        case  6: return( wxPENSTYLE_CROSSDIAG_HATCH  ); // Cross-diagonal hatch.
        case  7: return( wxPENSTYLE_FDIAGONAL_HATCH  ); // Forward diagonal hatch.
        case  8: return( wxPENSTYLE_CROSS_HATCH      ); // Cross hatch.
        case  9: return( wxPENSTYLE_HORIZONTAL_HATCH ); // Horizontal hatch.
        case 10: return( wxPENSTYLE_VERTICAL_HATCH   ); // Vertical hatch.
//      case 11: return( wxPENSTYLE_STIPPLE          ); // Use the stipple bitmap. 
//      case 12: return( wxPENSTYLE_USER_DASH        ); // Use the user dashes: see wxPen::SetDashes.
//      case 13: return( wxPENSTYLE_TRANSPARENT      ); // No pen is used.
        }
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Shapes::Get_Class_Color(CSG_Shape *pShape, int &Color)
{
        if( m_pSymbology->Get_Mode() == CSG_Map_Symbology::SINGLE )
        {
                Color = m_pSymbology->Get_Single_Color();
 
                return( true );
        }
 
        //-----------------------------------------------------
        if( m_Stretch.Value >= 0 )
        {
                if( m_pSymbology->Get_Mode() == CSG_Map_Symbology::CLASSIFIED && SG_Data_Type_is_Numeric(m_pObject->asShapes()->Get_Field_Type(m_Stretch.Value)) == false )
                {
                        if( m_pSymbology->Get_Class_Color_byValue(pShape->asString(m_Stretch.Value), Color) )
                        {
                                return( true );
                        }
                }
                else
                {
                        double Value;
 
                        if( CSG_Map_Layer::Get_Field_Value(pShape->Get_Index(), m_Stretch.Value, m_Stretch.Normal, m_Stretch.Scale, Value)
                        &&  m_pSymbology->Get_Class_Color_byValue(Value, Color) )
                        {
                                return( true );
                        }
                }
        }
 
        //-----------------------------------------------------
        Color = m_pSymbology->Get_NoData_Color();
 
        return( false );
}
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Shapes::CChart::Set_Options(const CSG_Shapes *pShapes, CSG_Parameters &Parameters)
{
        Parameters.Del_Parameters(); m_Fields.Clear();
 
        CSG_Array_Int Fields;
 
        for(int i=0; i<pShapes->Get_Field_Count(); i++)
        {
                if( SG_Data_Type_is_Numeric(pShapes->Get_Field_Type(i)) )
                {
                        Fields += i;
                }
        }
 
        if( Fields.Get_Size() < 1 )
        {
                return( false );
        }
 
        //-----------------------------------------------------
        Parameters.Set_Callback(false);
 
        Parameters.Add_Choice(""          , "TYPE"        , _TL("Chart Type"        ), _TL(""), CSG_String::Format("%s|%s", _TL("bar"), _TL("pie")), 0);
        Parameters.Add_Bool  ("TYPE"      , "OUTLINE"     , _TL("Outline"           ), _TL(""), false );
 
        Parameters.Add_Choice(""          , "SIZE_FIELD"  , _TL("Size Field"        ), _TL(""), CSG_String::Format("%s|", _TL("<not set>")), 0);
        Parameters.Add_Range ("SIZE_FIELD", "SIZE_RANGE"  , _TL("Size Range"        ), _TL(""), 5., 25., 0., true);
        Parameters.Add_Double("SIZE_FIELD", "SIZE_DEFAULT", _TL("Default Size"      ), _TL(""), 15., 0., true);
        Parameters.Add_Choice("SIZE_FIELD", "SIZE_TYPE"   , _TL("Size relates to..."), _TL(""), CSG_String::Format("%s|%s|", _TL("Screen"), _TL("Map Units")), 0);
 
        Parameters.Add_Node  ("", "FIELDS", _TL("Fields"), _TL(""));
 
        CSG_String Choices; CSG_Colors Colors((int)Fields.Get_Size());
 
        for(int i=0; i<(int)Fields.Get_Size(); i++)
        {
                Choices += CSG_String::Format("{%d}%s|", Fields[i], pShapes->Get_Field_Name(Fields[i]));
 
                CSG_String ID; ID.Printf("FIELD_%d", Fields[i]);
 
                Parameters.Add_Bool("FIELDS", ID, pShapes->Get_Field_Name(Fields[i]), "", false);
                Parameters.Add_Color(ID, CSG_String::Format("COLOR_%d", Fields[i]), "", "", Colors.Get_Color(i));
        }
 
        Choices += CSG_String::Format("{%d}%s|", -1, _TL("<none>"));
 
        Parameters["SIZE_FIELD"].asChoice()->Set_Items(Choices);
        Parameters["SIZE_FIELD"].Set_Value((int)Fields.Get_Size());
 
        Parameters.Set_Callback(true);
 
        return( true );
}
 
//---------------------------------------------------------
bool CSG_Map_Shapes::CChart::Get_Options(const CSG_Shapes *pShapes, const CSG_Parameters &Parameters)
{
        m_Fields.Clear(); m_Size.Field = -1;
 
        if( Parameters("FIELDS") )
        {
                for(int i=0; i<pShapes->Get_Field_Count(); i++)
                {
                        CSG_Parameter *pParameter = Parameters(CSG_String::Format("FIELD_%d", i));
 
                        if(     pParameter )
                        {
                                if( pParameter->asBool() && (pParameter = Parameters(CSG_String::Format("COLOR_%d", i))) != NULL )
                                {
                                        m_Fields.Add(i, pParameter->asColor());
                                }
                        }
                }
 
                switch( Parameters["TYPE"].asInt() )
                {
                default: m_Type = Parameters["OUTLINE"].asBool() ? 0 : 1; break; // bar
                case  1: m_Type = Parameters["OUTLINE"].asBool() ? 2 : 3; break; // pie
                }
 
                m_Size.Field = Get_Fields_Choice(Parameters["SIZE_FIELD"]);
                m_Size.Size  = m_Size.Field < 0
                             ? Parameters["SIZE_DEFAULT"  ].asDouble()
                             : Parameters["SIZE_RANGE.MIN"].asDouble();
                m_Size.Range = Parameters["SIZE_RANGE.MAX"].asDouble() - m_Size.Size;
                m_Size.Type  = Parameters["SIZE_TYPE"     ].asInt   ();
 
                return( true );
        }
 
        return( false );
}
 
//---------------------------------------------------------
void CSG_Map_Shapes::CChart::Draw(CSG_Map_DC &dc_Map, CSG_Shape *pShape)
{
        if( dc_Map.rWorld().Intersects(pShape->Get_Extent()) != INTERSECTION_None )
        {
                TSG_Point_Int point; double scale = m_Size.Size;
 
                if( m_Size.Field >= 0 )
                {
                        double range = pShape->Get_Table()->Get_Range(m_Size.Field);
 
                        if( range > 0. )
                        {
                                scale += m_Size.Range * ((pShape->asDouble(m_Size.Field) - pShape->Get_Table()->Get_Minimum(m_Size.Field)) / range);
                        }
                }
 
                int size = (int)(scale * (m_Size.Type == 1 ? dc_Map.World2DC() : dc_Map.Scale()));
 
                switch( pShape->Get_Type() )
                {
                default                : point = dc_Map.World2DC(pShape->Get_Extent().Get_Center()            ); break;
                case SHAPE_TYPE_Polygon: point = dc_Map.World2DC(((CSG_Shape_Polygon *)pShape)->Get_Centroid()); break;
                }
 
                dc_Map.SetPen(*wxBLACK_PEN);
 
                switch( m_Type )
                {
                default: _Draw_Bar(dc_Map, pShape,  true, point.x, point.y, (int)(0.8 * size), size); break; // bar outlined
                case  1: _Draw_Bar(dc_Map, pShape, false, point.x, point.y, (int)(0.8 * size), size); break; // bar
                case  2: _Draw_Pie(dc_Map, pShape,  true, point.x, point.y, (int)(1.0 * size)      ); break; // pie outlined
                case  3: _Draw_Pie(dc_Map, pShape, false, point.x, point.y, (int)(1.0 * size)      ); break; // pie
                }
        }
}
 
//---------------------------------------------------------
void CSG_Map_Shapes::CChart::_Draw_Pie(CSG_Map_DC &dc_Map, CSG_Table_Record *pRecord, bool bOutline, int x, int y, int size)
{
        double sum = 0.;
 
        for(int i=0; i<m_Fields.Get_Count(); i++)
        {
                sum     += fabs(pRecord->asDouble(m_Fields[i].x));
        }
 
        if( sum > 0. )
        {
                sum = M_PI_360 / sum; double d = 0.;
 
                for(int i=0, jx=x, jy=y-size; i<m_Fields.Get_Count(); i++)
                {
                        if( !bOutline )
                        {
                                dc_Map.SetPen(wxPen(SG_Get_wxColor(m_Fields[i].y)));
                        }
 
                        dc_Map.SetBrush(wxBrush(SG_Get_wxColor(m_Fields[i].y)));
 
                        d += sum * fabs(pRecord->asDouble(m_Fields[i].x));
 
                        int ix = jx; jx = x - (int)(size * sin(-d));
                        int iy = jy; jy = y - (int)(size * cos(-d));
 
                        dc_Map.DrawArc(jx, jy, ix, iy, x, y);
                }
        }
}
 
//---------------------------------------------------------
void CSG_Map_Shapes::CChart::_Draw_Bar(CSG_Map_DC &dc_Map, CSG_Table_Record *pRecord, bool bOutline, int x, int y, int sx, int sy)
{
        double max = fabs(pRecord->asDouble(m_Fields[0].x));
 
        for(int i=1; i<m_Fields.Get_Count(); i++)
        {
                double d = fabs(pRecord->asDouble(m_Fields[i].x));
 
                if( max < d )
                {
                        max = d;
                }
        }
 
        if( max != 0. )
        {
                y += sy / 2; max = sy / max; double dx = sx / (double)m_Fields.Get_Count(), ix = x - sx / 2.;
 
                for(int i=0; i<m_Fields.Get_Count(); i++, ix+=dx)
                {
                        if( !bOutline )
                        {
                                dc_Map.SetPen(wxPen(SG_Get_wxColor(m_Fields[i].y)));
                        }
 
                        dc_Map.SetBrush(wxBrush(SG_Get_wxColor(m_Fields[i].y)));
 
                        double dy = -pRecord->asDouble(m_Fields[i].x) * max;
 
                        dc_Map.DrawRectangle((int)ix, y, (int)dx, (int)dy);
                }
 
                if( !bOutline )
                {
                        dc_Map.SetPen(*wxBLACK_PEN); dc_Map.DrawLine(x - sx / 2, y, x + sx / 2, y);
                }
        }
}
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------