/* -*-c++-*- */
/* osgEarth - Dynamic map generation toolkit for OpenSceneGraph
 * Copyright 2008-2013 Pelican Mapping
 * http://osgearth.org
 *
 * osgEarth is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>
 */

#ifndef OSGEARTHSYMBOLOGY_TEXT_SYMBOL_H
#define OSGEARTHSYMBOLOGY_TEXT_SYMBOL_H 1

#include <osgEarthSymbology/Symbol>
#include <osgEarthSymbology/Expression>
#include <osgEarthSymbology/Fill>
#include <osgEarthSymbology/Stroke>

namespace osgEarth { namespace Symbology
{
    /**
     * Symbol that describes how to render text labels.
     */
    class OSGEARTHSYMBOLOGY_EXPORT TextSymbol : public Symbol
    {
    public:
        enum Encoding {
            ENCODING_ASCII,
            ENCODING_UTF8,
            ENCODING_UTF16,
            ENCODING_UTF32
        };

        // note: these are identical to the values in osgText::Text::AlignmentType
        enum Alignment {
            ALIGN_LEFT_TOP,
            ALIGN_LEFT_CENTER,
            ALIGN_LEFT_BOTTOM,

            ALIGN_CENTER_TOP,
            ALIGN_CENTER_CENTER,
            ALIGN_CENTER_BOTTOM,

            ALIGN_RIGHT_TOP,
            ALIGN_RIGHT_CENTER,
            ALIGN_RIGHT_BOTTOM,
            
            ALIGN_LEFT_BASE_LINE,
            ALIGN_CENTER_BASE_LINE,
            ALIGN_RIGHT_BASE_LINE,
        
            ALIGN_LEFT_BOTTOM_BASE_LINE,
            ALIGN_CENTER_BOTTOM_BASE_LINE,
            ALIGN_RIGHT_BOTTOM_BASE_LINE,
        
            ALIGN_BASE_LINE = ALIGN_LEFT_BASE_LINE /// default.        
        };

        META_Symbol(TextSymbol);

        TextSymbol( const Config& conf =Config() );

        /** dtor */
        virtual ~TextSymbol() { }

        /** Text fill color. */
        optional<Fill>& fill() { return _fill; }
        const optional<Fill>& fill() const { return _fill; }

        /** Text outline color. */
        optional<Stroke>& halo() { return _halo; }
        const optional<Stroke>& halo() const { return _halo; }

        /** Text outline offset */
        optional<float>& haloOffset() { return _haloOffset; }
        const optional<float>& haloOffset() const { return _haloOffset; }

        /** Name of text font. */
        optional<std::string>& font() { return _font; }
        const optional<std::string>& font() const { return _font; }

        /** Actual text to render (if applicable) */
        optional<StringExpression>& content() { return _content; }
        const optional<StringExpression>& content() const { return _content; }

        /** Priority of the label (applicable when the renderer sorts labels) */
        optional<NumericExpression>& priority() { return _priority; }
        const optional<NumericExpression>& priority() const { return _priority; }

        /** Font size. */
        optional<float>& size() { return _size; }
        const optional<float>& size() const { return _size; }

        /** Pixel offset from the center point. */
        optional<osg::Vec2s>& pixelOffset() { return _pixelOffset; }
        const optional<osg::Vec2s>& pixelOffset() const { return _pixelOffset; }

        /** Alignment of the label relative to (0,0) pixels */
        optional<Alignment>& alignment() { return _alignment; }
        const optional<Alignment>& alignment() const { return _alignment; }

        /** Whether to remove duplicates when drawing multiple labels. */
        optional<bool>& removeDuplicateLabels() { return _removeDuplicateLabels; }
        const optional<bool>& removeDuplicateLabels() const { return _removeDuplicateLabels; }

        /** Whether to enable decluttering on the text, if applicable */
        optional<bool>& declutter() { return _declutter; }
        const optional<bool>& declutter() const { return _declutter; }

        /** Label generation provider to use */
        optional<std::string>& provider() { return _provider; }
        const optional<std::string>& provider() const { return _provider; }

        /** text encoding */
        optional<Encoding>& encoding() { return _encoding; }
        const optional<Encoding>& encoding() const { return _encoding; }

    public:
        virtual Config getConfig() const;
        virtual void mergeConfig( const Config& conf );
        static void parseSLD(const Config& c, class Style& style);

    protected:
        optional<Fill>              _fill;
        optional<Stroke>            _halo;
        optional<float>             _haloOffset;
        optional<std::string>       _font;
        optional<float>             _size;
        optional<StringExpression>  _content;
        optional<NumericExpression> _priority;
        optional<bool>              _removeDuplicateLabels;
        optional<osg::Vec2s>        _pixelOffset;
        optional<std::string>       _provider;
        optional<Encoding>          _encoding;
        optional<Alignment>         _alignment;
        optional<bool>              _declutter;
    };

} } // namespace osgEarth::Symbology

#endif // OSGEARTHSYMBOLOGY_TEXT_SYMBOL_H
