TextField.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 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_TEXTFIELD_H
#define GNASH_TEXTFIELD_H

#include <boost/intrusive_ptr.hpp>
#include <map>
#include <string>
#include <vector>

#include "InteractiveObject.h" // for inheritance
#include "LineStyle.h" // for LineStyle
#include "snappingrange.h"
#include "SWFRect.h" // for inlines
#include "GnashKey.h"

// Forward declarations
namespace gnash {
    namespace SWF {
        class DefineEditTextTag;
        class TextRecord;
    }
    class TextFormat_as;
    class Font;
}

namespace gnash {

class TextField : public InteractiveObject
{

public:
    
    typedef std::vector<size_t> LineStarts;

        enum TextAlignment
        {
                ALIGN_LEFT = 0,
                ALIGN_RIGHT,
                ALIGN_CENTER,
                ALIGN_JUSTIFY
        };

        enum TextFormatDisplay
        {
                TEXTFORMAT_BLOCK = 0,
                TEXTFORMAT_INLINE = 1
        };
        
        enum AutoSize {

                AUTOSIZE_NONE,

                AUTOSIZE_LEFT,

                AUTOSIZE_CENTER,

                AUTOSIZE_RIGHT
        };

        enum TypeValue {

                typeInvalid,

                typeDynamic,

                typeInput
        };

        TextField(as_object* object, DisplayObject* parent,
            const SWF::DefineEditTextTag& def);

    //
    TextField(as_object* object, DisplayObject* parent, const SWFRect& bounds);


        ~TextField();

        // TODO: should this return isSelectable() ?
        bool mouseEnabled() const { return true; }

        //
        InteractiveObject* topmostMouseEntity(boost::int32_t x, boost::int32_t y);

    //
    virtual int getDefinitionVersion() const;

        void mouseEvent(const event_id& id);    

    void keyInput(key::code k);

        const std::string& getVariableName() const
        {
                return _variable_name;
        }

        //
        void set_variable_name(const std::string& newname);
        
        //
        void updateText(const std::string& s);

        std::string get_text_value() const;

        std::string get_htmltext_value() const;

        bool getTextDefined() const { return _textDefined; }

    size_t getCaretIndex() const {
        return m_cursor;
    }

    //
    const std::pair<size_t, size_t>& getSelection() const {
        return _selection;
    }

        //
    void replaceSelection(const std::string& replace);

    //
    //
    void setSelection(int start, int end);

    //
    virtual void setWidth(double width);
    
    //
    virtual void setHeight(double height);

        virtual void display(Renderer& renderer, const Transform& xform);

        void add_invalidated_bounds(InvalidatedRanges& ranges, bool force);

        virtual SWFRect getBounds() const
        {
                return _bounds;
        }

        // See dox in DisplayObject.h
        bool pointInShape(boost::int32_t x, boost::int32_t y) const;

        bool getDrawBackground() const;

        //
        void setDrawBackground(bool draw);

        rgba getBackgroundColor() const;

        //
        void setBackgroundColor(const rgba& col);

        bool getDrawBorder() const;

        //
        void setDrawBorder(bool draw);

        rgba getBorderColor() const;

        //
        void setBorderColor(const rgba& col);

        const rgba& getTextColor() const 
        {
                return _textColor;
        }

        //
        void setTextColor(const rgba& col);

        bool getEmbedFonts() const {
                return _embedFonts;
        }

    boost::int32_t maxChars() const {
        return _maxChars;
    }

        //
    void maxChars(boost::int32_t max) {
        _maxChars = max;
    }

    bool multiline() const {
        return _multiline;
    }

        //
    void multiline(bool b) {
        _multiline = b;
    }
        
    bool password() const {
        return _password;
    }

        //
    void password(bool b) {
        _password = b;
    }
        //
        void setEmbedFonts(bool use);

        AutoSize getAutoSize() const
        {
                return _autoSize;
        }

    TextAlignment getTextAlignment();

        //
        void setAutoSize(AutoSize val);

        //
        void setType(TypeValue val) { if (val != typeInvalid) _type=val; }

        TypeValue getType() const
        {
                return _type;
        }

        bool isReadOnly() const { return _type != typeInput; }

        //
        static TypeValue parseTypeValue(const std::string& val);

        //
        static const char* typeValueName(TypeValue val);

        bool doWordWrap() const {
                return _wordWrap;
        }

        //
        void setWordWrap(bool on);

        bool doHtml() const {
                return _html;
        }

        //
        void setHtml(bool on) {
                _html = on;
        }

        bool isSelectable() const
        {
                return _selectable;
        }

        //
        void setSelectable(bool v) 
        {
                _selectable = v;
        }

        // See DisplayObject::isActiveTextField
        virtual bool isSelectableTextField() const
        {
                return isSelectable();
        }

        //
        void removeTextField();

        //
        boost::intrusive_ptr<const Font> setFont(
            boost::intrusive_ptr<const Font> newfont);

        const Font* getFont() { return _font.get(); }

        
        boost::uint16_t getFontHeight() const
        {
                return _fontHeight;
        }

        void setFontHeight(boost::uint16_t h);

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

        void setLeftMargin(boost::uint16_t h);

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

        void setRightMargin(boost::uint16_t h);

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

        void setIndent(boost::uint16_t h);

        boost::uint16_t getBlockIndent() const
        {
                return _blockIndent;
        }

        void setBlockIndent(boost::uint16_t h);

        TextAlignment getAlignment() const
        {
                return _alignment;
        }

        void setAlignment(TextAlignment h);

        boost::int16_t getLeading() const
        {
                return _leading;
        }

        void setLeading(boost::int16_t h);

        bool getUnderlined() const
        {
                return _underlined;
        }
        
        TextFormatDisplay getDisplay() const
        { 
                return _display;
        }
        
        bool getBullet() const
        {
                return _bullet;
        }
        
        const std::vector<int>& getTabStops() const
        {
                return _tabStops;
        }

        bool isRestrict() const
        {
                return _restrictDefined;
        }
        
        const std::string& getRestrict() const
        {
                return _restrict;
        }

        size_t getScroll() const
        {
                return _scroll;
        }

        size_t getMaxScroll() const
        {
                return _maxScroll;
        }

        size_t getHScroll() const
        {
                return _hScroll;
        }

        size_t getMaxHScroll() const
        {
                return _maxHScroll;
        }

        size_t getBottomScroll() const
        {
                return _bottomScroll;
        }

        void setUnderlined(bool v);
        void setTabStops(const std::vector<int>& tabStops);
        void setBullet(bool b);
        void setURL(std::string url);
        void setTarget(std::string target);
        void setRestrict(const std::string& restrict);
        void setDisplay(TextFormatDisplay display);
        void setScroll(size_t scroll) {
                _scroll = scroll;
                format_text();
        }
        void setMaxScroll(size_t maxScroll) {
                _maxScroll = maxScroll;
                format_text();
        }
        void setHScroll(size_t hScroll) {
                _hScroll = hScroll;
                format_text();
        }
        void setMaxHScroll(size_t maxHScroll) {
                _maxHScroll = maxHScroll;
                format_text();
        }
        void setbottomScroll(size_t bottomScroll) {
                _bottomScroll = bottomScroll;
                format_text();
        }

        //
        size_t cursorRecord();

        void setTextFormat(TextFormat_as& tf);

        const SWFRect& getTextBoundingBox() const {
                return m_text_bounding_box;
        }

        //
        void setTextValue(const std::wstring& wstr);

private:

    void init();

        //
        void updateText(const std::wstring& s);

        void updateHtmlText(const std::wstring& s);

    void insertTab(SWF::TextRecord& rec, boost::int32_t& x, float scale);

    //
        virtual bool handleFocus();

        virtual void killFocus();

        void onChanged();

        void reset_bounding_box(boost::int32_t x, boost::int32_t y)
        {
                m_text_bounding_box.set_to_point(x, y);
        }

        void format_text();
        
        void scrollLines();
        
        void newLine(boost::int32_t& x, boost::int32_t& y, 
                                 SWF::TextRecord& rec, int& last_space_glyph,
                                 LineStarts::value_type& last_line_start_record, float div);
                                        
        void handleChar(std::wstring::const_iterator& it,
            const std::wstring::const_iterator& e, boost::int32_t& x,
            boost::int32_t& y, SWF::TextRecord& rec, int& last_code,
                    int& last_space_glyph,
            LineStarts::value_type& last_line_start_record);
        
        bool parseHTML(std::wstring& tag,
            std::map<std::string, std::string>& attributes,
            std::wstring::const_iterator& it,
            const std::wstring::const_iterator& e,
                        bool& selfclosing) const;

        float align_line(TextAlignment align, int last_line_start_record, float x);

        //
        void registerTextVariable();

        typedef std::pair<as_object*, ObjectURI> VariableRef;

        VariableRef parseTextVariableRef(const std::string& variableName) const;

        //
        void show_cursor(Renderer& renderer, const SWFMatrix& mat);

    //
    boost::intrusive_ptr<const SWF::DefineEditTextTag> _tag;

    //
        std::wstring _text;

        //
        std::wstring _htmlText;

        SWFRect m_text_bounding_box;

        typedef std::vector<SWF::TextRecord> TextRecords;
        TextRecords _textRecords;

        std::vector<size_t> _recordStarts;

        TextRecords _displayRecords;

        std::string _url;
        std::string _target;
        std::string _restrict;
        std::set<wchar_t> _restrictedchars;
        TextFormatDisplay _display;
        std::vector<int> _tabStops;
        LineStarts _line_starts;

        //
        std::string _variable_name;

        rgba _backgroundColor;

        rgba _borderColor;

        rgba _textColor;
        
        TextAlignment _alignment;

        boost::intrusive_ptr<const Font> _font;
        size_t m_cursor;
        size_t _glyphcount;
        size_t _scroll;
        size_t _maxScroll;
        size_t _hScroll;
        size_t _maxHScroll;
        size_t _bottomScroll;
        size_t _linesindisplay;

    size_t _maxChars;
        
    AutoSize _autoSize;

        TypeValue _type;

        //
        SWFRect _bounds;

    std::pair<size_t, size_t> _selection;

    boost::int16_t _leading;
        boost::uint16_t _indent;

        boost::uint16_t _blockIndent;

        boost::uint16_t _leftMargin;

        boost::uint16_t _rightMargin;

        boost::uint16_t _fontHeight;

        bool _textDefined;

        bool _restrictDefined;
        bool _underlined;
        bool _bullet;

        bool m_has_focus;
        

    bool _multiline;

    bool _password;
        
        //
        bool _text_variable_registered;

        bool _drawBackground;

        bool _drawBorder;

        bool _embedFonts;

        bool _wordWrap;

        bool _html;

        bool _selectable;
        
};

} // namespace gnash

#endif