CWE-ou-minkata/Sources/Plasma/FeatureLib/pfGameGUIMgr/pfGUIMultiLineEditCtrl.h

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, 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, see <http://www.gnu.org/licenses/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////////////
//                                                                          //
//  pfGUIMultiLineEditCtrl Header                                           //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

#ifndef _pfGUIMultiLineEditCtrl_h
#define _pfGUIMultiLineEditCtrl_h

#include "pfGUIControlMod.h"
#include "hsTemplates.h"

#include "plInputCore/plInputDevice.h"

class plMessage;
class hsGMaterial;
class plTextGenerator;
class pfMLScrollProc;
class pfGUIValueCtrl;

struct plUndoAction;

class pfGUIMultiLineEditProc
{
public:
    pfGUIMultiLineEditProc() {}
    virtual ~pfGUIMultiLineEditProc() {}

    // we've hit the end of the control list (by moving the cursor)
    virtual void OnEndOfControlList(Int32 cursorPos) {}

    // we've hit the beginning of the control ist (by moving the cursor)
    virtual void OnBeginningOfControlList(Int32 cursorPos) {}
};

class pfGUIMultiLineEditCtrl : public pfGUIControlMod
{
    public:
        enum Direction
        {
            kLineStart = 1,
            kLineEnd,
            kBufferStart,
            kBufferEnd,
            kOneBack,
            kOneForward,
            kOneWordBack,
            kOneWordForward,
            kOneLineUp,
            kOneLineDown,
            kPageUp,
            kPageDown
        };

    protected:

        mutable hsTArray<wchar_t>   fBuffer;        // Because AcquireArray() isn't const

        hsTArray<Int32> fLineStarts;
        UInt16          fLineHeight, fCurrCursorX, fCurrCursorY;
        Int32           fCursorPos, fLastCursorLine;
        hsBool          fIgnoreNextKey, fReadyToRender;
        hsBounds3Ext    fLastP2PArea;
        Int8            fLockCount;
        UInt8           fCalcedFontSize;    // The font size that we calced our line height at

        UInt8           fLastKeyModifiers;
        wchar_t         fLastKeyPressed;

        static wchar_t  fColorCodeChar, fStyleCodeChar;
        static UInt32   fColorCodeSize, fStyleCodeSize;

        virtual hsBool  IEval( double secs, hsScalar del, UInt32 dirty ); // called only by owner object's Eval()

        virtual void    IPostSetUpDynTextMap( void );
        virtual void    IUpdate( void );
        void            IUpdate( Int32 startLine, Int32 endLine );

        friend class pfMLScrollProc;

        pfGUIValueCtrl  *fScrollControl;
        pfMLScrollProc  *fScrollProc;
        Int32           fScrollPos;
        Int32           fBufferLimit;

        pfGUIMultiLineEditCtrl *fNextCtrl; // used for linking multiple controls together to share a buffer
        pfGUIMultiLineEditCtrl *fPrevCtrl;

        pfGUIMultiLineEditProc *fEventProc; // where we send events to

        std::string fFontFace;
        hsColorRGBA fFontColor;
        UInt8       fFontSize;
        UInt8       fFontStyle;
        enum flagsSet
        {
            kFontFaceSet = 1,
            kFontColorSet = 2,
            kFontSizeSet = 4,
            kFontStyleSet = 8
        };
        UInt8       fFontFlagsSet;

        int     fTopMargin,fLeftMargin,fBottomMargin,fRightMargin;

        void    IMoveCursor( Direction dir );
        void    IMoveCursorTo( Int32 position );    // Updates selection
        void    ISetCursor( Int32 newPosition );    // Doesn't update selection

        Int32   IRecalcLineStarts( Int32 startingLine, hsBool force, hsBool dontUpdate = false );
        void    IRecalcFromCursor( hsBool forceUpdate = false );
        Int32   IFindCursorLine( Int32 cursorPos = -1 ) const;
        hsBool  IStoreLineStart( UInt32 line, Int32 start );
        void    IOffsetLineStarts( UInt32 position, Int32 offset, hsBool offsetSelectionEnd = false );
        Int32   IPointToPosition( Int16 x, Int16 y, hsBool searchOutsideBounds = false );
        Int32   ICalcNumVisibleLines( void ) const;

        void    IReadColorCode( Int32 &pos, hsColorRGBA &color ) const;
        void    IReadStyleCode( Int32 &pos, UInt8 &fontStyle ) const;
        UInt32  IRenderLine( UInt16 x, UInt16 y, Int32 start, Int32 end, hsBool dontRender = false );
        hsBool  IFindLastColorCode( Int32 pos, hsColorRGBA &color, hsBool ignoreFirstCharacter = false ) const;
        hsBool  IFindLastStyleCode( Int32 pos, UInt8 &style, hsBool ignoreFirstCharacter = false ) const;

        inline static bool  IIsCodeChar( const wchar_t c );
        inline static bool  IIsRenderable( const wchar_t c );
        inline static Int32 IOffsetToNextChar( wchar_t stringChar );
        inline Int32        IOffsetToNextCharFromPos( Int32 pos ) const;

        void    IActuallyInsertColor( Int32 pos, hsColorRGBA &color );
        void    IActuallyInsertStyle( Int32 pos, UInt8 style );

        void    IUpdateScrollRange( void );

        wchar_t *ICopyRange( Int32 start, Int32 end ) const;

        Int32   ICharPosToBufferPos( Int32 charPos ) const;

        void    IUpdateBuffer();
        void    IUpdateLineStarts();
        void    ISetGlobalBuffer();
        void    ISetLineStarts(hsTArray<Int32> lineStarts);

        void    IHitEndOfControlList(Int32 cursorPos);
        void    IHitBeginningOfControlList(Int32 cursorPos);

    public:

        enum
        {
            kRefScrollCtrl = kRefDerivedStart
        };

        pfGUIMultiLineEditCtrl();
        virtual ~pfGUIMultiLineEditCtrl();

        CLASSNAME_REGISTER( pfGUIMultiLineEditCtrl );
        GETINTERFACE_ANY( pfGUIMultiLineEditCtrl, pfGUIControlMod );

        virtual hsBool  MsgReceive( plMessage* pMsg );
        
        virtual void Read( hsStream* s, hsResMgr* mgr );
        virtual void Write( hsStream* s, hsResMgr* mgr );

        virtual void    HandleMouseDown( hsPoint3 &mousePt, UInt8 modifiers );
        virtual void    HandleMouseUp( hsPoint3 &mousePt, UInt8 modifiers );
        virtual void    HandleMouseDrag( hsPoint3 &mousePt, UInt8 modifiers );

        virtual hsBool  HandleKeyPress( wchar_t key, UInt8 modifiers );
        virtual hsBool  HandleKeyEvent( pfGameGUIMgr::EventType event, plKeyDef key, UInt8 modifiers );

        virtual void    PurgeDynaTextMapImage();

        // Extended event types
        enum ExtendedEvents
        {
            kValueChanging,
            kScrollPosChanged,
            kKeyPressedEvent
        };

        void    SetScrollPosition( Int32 topLine );
        void    MoveCursor( Direction dir );

        void    InsertChar( char c );
        void    InsertChar( wchar_t c);
        void    InsertString( const char *string );
        void    InsertString( const wchar_t *string );
        void    InsertColor( hsColorRGBA &color );
        void    InsertStyle( UInt8 fontStyle );
        void    DeleteChar( void );
        void    ClearBuffer( void );
        void    SetBuffer( const char *asciiText );
        void    SetBuffer( const wchar_t *asciiText );
        void    SetBuffer( const UInt8 *codedText, UInt32 length );
        void    SetBuffer( const UInt16 *codedText, UInt32 length );
        char    *GetNonCodedBuffer( void ) const;
        wchar_t *GetNonCodedBufferW( void ) const;
        UInt8   *GetCodedBuffer( UInt32 &length ) const;
        UInt16  *GetCodedBufferW( UInt32 &length ) const;
        UInt32  GetBufferSize();

        void    SetBufferLimit(Int32 limit) { fBufferLimit = limit; }
        Int32   GetBufferLimit() { return fBufferLimit; }

        void    GetThisKeyPressed( char &key, UInt8 &modifiers ) const { key = (char)fLastKeyPressed; modifiers = fLastKeyModifiers; }

        void    Lock( void );
        void    Unlock( void );
        hsBool  IsLocked( void ) const { return ( fLockCount > 0 ) ? true : false; }
        
        void    SetScrollEnable( hsBool state );

        void    ForceUpdate() {/*IRecalcLineStarts(0,true);*/IUpdateLineStarts(); IUpdate();}

        void    SetNext( pfGUIMultiLineEditCtrl *newNext );
        void    ClearNext();
        void    SetPrev( pfGUIMultiLineEditCtrl *newPrev );
        void    ClearPrev();
        void    SetEventProc( pfGUIMultiLineEditProc *eventProc );
        void    ClearEventProc();
        Int32   GetFirstVisibleLine();
        Int32   GetLastVisibleLine();
        Int32   GetNumVisibleLines() {return ICalcNumVisibleLines();}
        void    SetGlobalStartLine(Int32 line);

        void    SetCursorToLoc(Int32 loc) {ISetCursor(loc);}

        void    SetMargins(int top, int left, int bottom, int right);

        UInt8   GetFontSize() {return fFontSize;} // because we're too cool to use the color scheme crap

        void    SetFontFace(std::string fontFace);
        void    SetFontColor(hsColorRGBA fontColor) {fFontColor = fontColor; fFontFlagsSet |= kFontColorSet;}
        void    SetFontSize(UInt8 fontSize);
        void    SetFontStyle(UInt8 fontStyle) {fFontStyle = fontStyle; fFontFlagsSet |= kFontStyleSet;}

        hsBool  ShowingBeginningOfBuffer();
        hsBool  ShowingEndOfBuffer();

        void    DeleteLinesFromTop(int numLines); // cursor and scroll position might be off after this call, not valid on connected controls
};

#endif // _pfGUIMultiLineEditCtrl_h