DefineEditTextTag.h

Go to the documentation of this file.

// 
//   Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc.
// 
// 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 3 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, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef GNASH_SWF_DEFINEEDITTEXTTAG_H
#define GNASH_SWF_DEFINEEDITTEXTTAG_H

#include "SWFRect.h"
#include "DefinitionTag.h"
#include "SWF.h" // for TagType definition
#include "RGBA.h"
#include "TextField.h"

#include <boost/intrusive_ptr.hpp>
#include <string>
#include <boost/cstdint.hpp> // for boost::uint16_t and friends
 

// Forward declarations
namespace gnash {
        class SWFStream;
        class movie_definition;
        class RunResources;
    class Font;
}

namespace gnash {
namespace SWF {

//
class DefineEditTextTag : public DefinitionTag
{

public:

    ~DefineEditTextTag() {}

        static void loader(SWFStream& in, TagType tag, movie_definition& m,
            const RunResources& r);

    const SWFRect& bounds() const { return _rect; }

    DisplayObject* createDisplayObject(Global_as& gl,
            DisplayObject* parent) const;

        const std::string& defaultText() const {
                return _defaultText;
        }

        const std::string& variableName() const {
                return _variableName;
        }

        //
        unsigned int maxChars() const {
                return _maxChars;
        }

        boost::uint16_t rightMargin() const {
                return _rightMargin;
        }

        boost::uint16_t leftMargin() const {
                return _leftMargin;
        }

        boost::uint16_t indent() const {
                return _indent;
        }

        // @@ what if has_font is false ??
        boost::uint16_t textHeight() const {
                return _textHeight;
        }

        const rgba& color() const {
                return _color;
        }

        //
        boost::uint16_t leading() const {
                return _leading;
        }

    bool multiline() const {
        return _multiline;
    }

    bool password() const {
        return _password;
    }

    TextField::TextAlignment alignment() const {
                return _alignment;
        }

        bool border() const {
                return _border;
        }

    bool autoSize() const {
        return _autoSize;
    }

        bool wordWrap() const {
                return _wordWrap;
        }

        bool hasText() const {
                return _hasText;
        }

        bool readOnly() const
        {
                return _readOnly;
        }

        bool noSelect() const 
        {
             return _noSelect;
        }
        
        bool html() const { return _html; }

        // 
        bool getUseEmbeddedGlyphs() const 
        {
                return _useOutlines;
        }

    boost::intrusive_ptr<Font> getFont() const
    {
        return _font;
    }

private:

    //
        DefineEditTextTag(SWFStream& in, movie_definition& m, boost::uint16_t id);

    void read(SWFStream& in, movie_definition& m);

        SWFRect _rect;

        std::string _variableName;

    // For an SWF-defined textfield we'll read
    // this from the tag. Dynamic textfields should
    // behave as always having text by default (not tested).
        bool _hasText;
        bool _wordWrap;
        bool _multiline;

        bool _password;
        bool _readOnly;
        bool _autoSize;
        bool _noSelect;

        bool _border;

        //
        bool _html;

    // For an SWF-defined textfield we'll read
    // this from the tag. Dynamic textfields should
        // use device fonts by default (so not use outline ones)
        bool _useOutlines;

        int     _fontID;
        boost::intrusive_ptr<Font> _font;

    // TODO: initialize to a meaningful value (see MovieClip::add_textfield)
    //       and make sure get_font_height is not called for rendering purposes
    //       (instead call a method of TextField) (?)
        boost::uint16_t _textHeight;

        rgba _color;

        //
        unsigned int _maxChars;

    TextField::TextAlignment _alignment;
        
        boost::uint16_t _leftMargin;

        boost::uint16_t _rightMargin;

        boost::uint16_t _indent;

        boost::uint16_t _leading;

        std::string     _defaultText;
};


} // namespace gnash::SWF
} // namespace gnash

#endif