pawstextbox.h

Go to the documentation of this file.

/*
 * pawstextbox.h - Author: Andrew Craig
 *
 * Copyright (C) 2003 Atomic Blue ([email protected], http://www.atomicblue.org)
 *
 *
 * 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 (version 2 of the License)
 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */
// pawstextbox.h: interface for the pawsTextBox class.
//

#ifndef PAWS_TEXT_BOX_HEADER
#define PAWS_TEXT_BOX_HEADER

struct iVirtualClock;

#include "pawswidget.h"
#include <csutil/parray.h>
#include <ivideo/fontserv.h>
#include <iutil/virtclk.h>

#include <ispellchecker.h>

class pawsTextBox : public pawsWidget
{
public:
    enum pawsVertAdjust
    {
        vertTOP,    
        vertBOTTOM, 
        vertCENTRE  
    };

    enum pawsHorizAdjust
    {
        horizLEFT,  
        horizRIGHT, 
        horizCENTRE 
    };

    pawsTextBox();

    virtual ~pawsTextBox();

    pawsTextBox(const pawsTextBox &origin);

    bool Setup(iDocumentNode* node);
    bool SelfPopulate(iDocumentNode* node);

    void Draw();

    void SetText(const char* text);

    void FormatText(const char* fmt, ...);

    const char* GetText() const
    {
        return text;
    }

    void SetVertical(bool vertical);

    void Adjust(pawsHorizAdjust horiz, pawsVertAdjust vert);
    void HorizAdjust(pawsHorizAdjust horiz);
    void VertAdjust(pawsVertAdjust vert);

    void SetSizeByText(int padX,int padY);

    virtual bool OnGainFocus(bool)
    {
        return false;
    }

    virtual int GetBorderStyle()
    {
        return BORDER_SUNKEN;
    }

    inline void Grayed(bool g)
    {
        grayed = g;
    }

    virtual int GetFontColour();

    virtual void OnUpdateData(const char* dataname,PAWSData &data);

    static int CountCodePoints(const char* text, int start = 0, int len = -1);

    static int RewindCodePoints(const char* text, int start, int count);

    static int SkipCodePoints(const char* text, int start, int count);

protected:

    void CalcTextPos();

    void CalcTextSize(int &width, int &height);

    void CalcLetterSizes();

    csString text;

    int colour;

    bool grayed;

    pawsHorizAdjust horizAdjust;

    pawsVertAdjust  vertAdjust;

    bool vertical;

    int textX;

    int textY;

    int textWidth;

    psPoint* letterSizes;

};

//--------------------------------------------------------------------------
CREATE_PAWS_FACTORY(pawsTextBox);



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

#define MESSAGE_TEXTBOX_MOUSE_SCROLL_AMOUNT 3

class pawsMessageTextBox : public pawsWidget
{
public:
    struct MessageSegment
    {
        int x;
        csString text;
        int colour;
        int size;

        MessageSegment() : x(0), text(""), colour(0), size(0) { }
    };
    struct MessageLine
    {
        csString text;
        int colour;
        int size;
        csArray<MessageSegment> segments;

        MessageLine()
        {
            text = "";
            colour = 0;
            size = 0;
        }
        MessageLine(const MessageLine &origin):text(origin.text),colour(origin.colour),size(origin.size)
        {
            for(unsigned int i = 0 ; i < origin.segments.GetSize(); i++)
                segments.Push(origin.segments[i]);
        }
    };

    pawsMessageTextBox();
    pawsMessageTextBox(const pawsMessageTextBox &origin);
    virtual ~pawsMessageTextBox();
    virtual bool Setup(iDocumentNode* node);
    virtual bool Setup(void);
    virtual bool PostSetup();

    bool SelfPopulate(iDocumentNode* node);

    virtual void Draw();

    void AddMessage(const char* data, int colour = -1);

    void AppendLastMessage(const char* data);
    void ReplaceLastMessage(const char* data);

    virtual void OnResize();
    virtual void Resize();
    virtual bool OnScroll(int direction, pawsScrollBar* widget);
    virtual bool OnMouseDown(int button, int modifiers, int x, int y);

    void Clear();

    virtual int GetBorderStyle()
    {
        return BORDER_SUNKEN;
    }

    void ResetScroll();

    void FullScroll();

    virtual void OnUpdateData(const char* dataname,PAWSData &data);

    bool OnKeyDown(utf32_char code, utf32_char key, int modifiers);


protected:
    int RenderMessage(const char* data, int lineStart, int colour);

    csPDelArray<MessageLine> messages;

    //void AdjustMessages();

    void SplitMessage(const char* newText, int colour, int size, MessageLine* &msgLine, int &startPosition);

    void CalcLineHeight();

    pawsScrollBar* GetScrollBar();

    csPDelArray<MessageLine> adjusted;

    int lineHeight;
    size_t maxLines;

    int topLine;

    pawsScrollBar* scrollBar;
    int scrollBarWidth;

private:
    static const int INITOFFSET = 20;
    void WriteMessageLine(MessageLine* &msgLine, csString text, int colour);
    void WriteMessageSegment(MessageLine* &msgLine, csString text, int colour, int startPosition);
    csString FindStringThatFits(csString stringBuffer, int canDrawLength);
};

CREATE_PAWS_FACTORY(pawsMessageTextBox);

#define EDIT_TEXTBOX_MOUSE_SCROLL_AMOUNT 3
#define BLINK_TICKS  1000

class pawsEditTextBox : public pawsWidget
{
public:
    pawsEditTextBox();
    virtual ~pawsEditTextBox();
    pawsEditTextBox(const pawsEditTextBox &origin);

    virtual void Draw();

    bool Setup(iDocumentNode* node);

    bool OnKeyDown(utf32_char code, utf32_char key, int modifiers);

    const char* GetText()
    {
        return text.GetDataSafe();
    }

    void SetMultiline(bool multi);
    void SetPassword(bool pass); //displays astrices instead of text

    void SetText(const char* text, bool publish = true);

    virtual void OnUpdateData(const char* dataname,PAWSData &data);

    void SetSizeByText();

    void Clear();

    virtual bool OnMouseDown(int button, int modifiers, int x, int y);

    virtual bool OnClipboard(const csString &content);

    virtual int GetBorderStyle()
    {
        return BORDER_SUNKEN;
    }

    bool SelfPopulate(iDocumentNode* node);

    unsigned int GetTopLine()
    {
        return topLine;
    }
    void SetTopLine(unsigned int newTopLine)
    {
        topLine = newTopLine;
    }

    void SetCursorPosition(size_t pos)
    {
        cursorPosition = pos;
    }

    virtual bool GetFocusOverridesControls() const
    {
        return true;
    }

    void SetMaxLength(unsigned int maxlen);
    inline unsigned int GetMaxLength() const
    {
        return maxLen;
    }
    inline unsigned int GetRemainingChars() const
    {
        if(maxLen)
            return (unsigned int)(maxLen - text.Length());
        return UINT_MAX;
    }
    inline bool getSpellChecked() const
    {
        return spellChecked;
    };
    inline void setSpellChecked(const bool check)
    {
        spellChecked = check;
    };
    inline void toggleSpellChecked()
    {
        spellChecked = !spellChecked;
    };
    unsigned int getTypoColour()
    {
        return typoColour;
    };
    void setTypoColour(unsigned int col)
    {
        typoColour = col;
    };
protected:
    void checkSpelling();
    struct Word
    {
        bool correct;
        int endPos;
    };

    bool password;
    csRef<iVirtualClock> clock;

    int start;

    size_t cursorPosition;
    unsigned int cursorLine;

    bool blink;

    csTicks blinkTicks;

    csString text;

    bool multiLine;

    int lineHeight;
    size_t maxLines;

    // This value will always be one less than the number of used lines
    size_t usedLines;

    unsigned int topLine;
    unsigned int maxLen;

    pawsScrollBar* vScrollBar;
    csRef<iSpellChecker> spellChecker;
    bool spellChecked;
    unsigned int typoColour;
    csArray<Word> words;
};

CREATE_PAWS_FACTORY(pawsEditTextBox);


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


#define MULTILINE_TEXTBOX_MOUSE_SCROLL_AMOUNT 3
class pawsMultiLineTextBox : public pawsWidget
{
public:
    pawsMultiLineTextBox();
    pawsMultiLineTextBox(const pawsMultiLineTextBox &origin);
    virtual ~pawsMultiLineTextBox();

    bool Setup(iDocumentNode* node);
    bool PostSetup();

    void Draw();

    void SetText(const char* text);
    const char* GetText()
    {
        return text;
    }
    void Resize();
    bool OnScroll(int direction, pawsScrollBar* widget);
    virtual bool OnMouseDown(int button, int modifiers, int x, int y);

    // Normal text boxes should not be focused.
    virtual bool OnGainFocus(bool /*notifyParent*/ = true)
    {
        return false;
    }
    virtual void OnUpdateData(const char* dataname,PAWSData &data);

protected:

    void OrganizeText(const char* text);

    pawsScrollBar* GetScrollBar();

    csString text;
    csArray<csString> lines;

    //where our scrollbar at?
    size_t startLine;
    //Number of lines that we can fit in the box
    size_t canDrawLines;
    bool usingScrollBar;
    int maxWidth;
    int maxHeight;
    pawsScrollBar* scrollBar;
};

//--------------------------------------------------------------------------
CREATE_PAWS_FACTORY(pawsMultiLineTextBox);


class pawsMultiPageTextBox : public pawsWidget
{
public:
    pawsMultiPageTextBox();
    pawsMultiPageTextBox(const pawsMultiPageTextBox &origin);
    virtual ~pawsMultiPageTextBox();

    bool Setup(iDocumentNode* node);
    bool PostSetup();




    void Draw();

    void SetText(const char* text);
    const char* GetText()
    {
        return text;
    }
    void Resize();
    bool OnScroll(int direction, pawsScrollBar* widget);

    virtual bool OnMouseDown(int button, int modifiers, int x, int y);

    // Normal text boxes should not be focused.
    virtual bool OnGainFocus(bool /*notifyParent*/ = true)
    {
        return false;
    }
    virtual void OnUpdateData(const char* dataname,PAWSData &data);

    // Added these member functions for dealing with pages
    int GetNumPages();
    void SetCurrentPageNum(int n);
    int GetCurrentPageNum();
protected:

    // splits the given text in separate lines filling the 'lines' variable
    void OrganizeText(const char* text);

    pawsScrollBar* GetScrollBar();


    csString text;
    csArray<csString> lines;

    //where our scrollbar at?and that d
    size_t startLine;
    //Number of lines that we can fit in the box
    size_t canDrawLines;
    bool usingScrollBar;
    int maxWidth;
    int maxHeight;
    pawsScrollBar* scrollBar;
    int currentPageNum;
    int numPages;
};

//--------------------------------------------------------------------------
CREATE_PAWS_FACTORY(pawsMultiPageTextBox);


/* An edit box widget */
class pawsMultilineEditTextBox : public pawsWidget
{
public:
    pawsMultilineEditTextBox();
    virtual ~pawsMultilineEditTextBox();
    pawsMultilineEditTextBox(const pawsMultilineEditTextBox &origin);
    struct MessageLine
    {
        size_t lineLength; //Stores length of the line.
        size_t breakLine; //Stores real text position of where break occurs.
        int lineExtra; //Stores 1 if line ends with a \n, or 0 if it does not.
    };

    bool Setup(iDocumentNode* node);

    virtual void Draw();
    void DrawWidgetText(const char* text, size_t x, size_t y, int style, int fg, int visLine);

    void SetText(const char* text, bool publish = true);
    const char* GetText();
    void UpdateScrollBar();
    virtual void SetupScrollBar();

    bool OnScroll(int direction, pawsScrollBar* widget);
    virtual void OnResize();
    virtual bool OnMouseUp(int button, int modifiers, int x, int y);
    virtual bool OnMouseDown(int button, int modifiers, int x, int y);
    virtual bool OnClipboard(const csString &content);
    virtual void OnUpdateData(const char* dataname,PAWSData &data);
    virtual bool OnKeyDown(utf32_char code, utf32_char key, int modifiers);
    virtual void CalcMouseClick(int x, int y, size_t &cursorLine, size_t &cursorChar);

    virtual bool GetFocusOverridesControls() const
    {
        return true;
    }

    void PushLineInfo(size_t lineLength, size_t lineBreak, int lineExtra);

    virtual int GetBorderStyle()
    {
        return BORDER_SUNKEN;
    }
    void LayoutText();

    bool SelfPopulate(iDocumentNode* node);

    size_t GetTopLine()
    {
        return topLine;
    }
    void SetTopLine(size_t newTopLine)
    {
        topLine = newTopLine;
    }
    size_t GetCursorPosition();
    size_t GetCursorPosition(size_t destLine, size_t destCursor);
    void SetCursorPosition(size_t pos)
    {
        cursorPosition = pos;
    }
    void Clear()
    {
        SetText("");
    }
    csString GetLine(size_t line);
    int GetLineWidth(int lineNumber);
    void GetLinePos(size_t lineNumber, size_t &start, size_t &end);
    void GetLineRelative(size_t pos, size_t &start, size_t &end);
    bool EndsWithNewLine(int lineNumber);
    void GetCursorLocation(size_t pos, size_t &destLine, size_t &destCursor);
    char GetAt(size_t destLine, size_t destCursor);

    void SetMaxLength(unsigned int maxlen);
    inline unsigned int GetMaxLength() const
    {
        return maxLen;
    }
    inline unsigned int GetRemainingChars() const
    {
        if(maxLen)
            return (unsigned int)(maxLen - text.Length());
        return UINT_MAX;
    }
    inline bool getSpellChecked() const
    {
        return spellChecked;
    };
    inline void setSpellChecked(const bool check)
    {
        spellChecked = check;
    };
    inline void toggleSpellChecked()
    {
        spellChecked = !spellChecked;
    };
    unsigned int getTypoColour()
    {
        return typoColour;
    };
    void setTypoColour(unsigned int col)
    {
        typoColour = col;
    };

    int GetLinesPerPage()
    {
        return canDrawLines;
    }
protected:
    void checkSpelling();
    void drawTextSpellChecked(iFont* font, int x, int y, int fg, csString str, int visLine);


    struct Word
    {
        bool correct;
        int endPos;
    };

    csRef<iVirtualClock> clock;

    // The position of the cursor blink
    size_t cursorPosition;

    // The position of the cursor in an array (Used by draw method).
    size_t cursorLine;
    size_t cursorLoc;

    bool blink;

    csTicks blinkTicks;

    csString text;
    csPDelArray<MessageLine> lineInfo;
    int lineHeight;

    // Width of the vertical scroll bar
    int vScrollBarWidth;
    size_t canDrawLines;

    size_t topLine;
    pawsScrollBar* vScrollBar;

    bool usingScrollBar;

    int maxWidth;
    int maxHeight;

    int yPos;
    csString tmp;

    unsigned int maxLen;
    /* PS spellChecker plugin
     */
    csRef<iSpellChecker> spellChecker;
    /* Should the text be checked by the spellchecker plugin (if available)
     */
    bool spellChecked;
    unsigned int typoColour;

    csArray<csArray<Word> > lineTypos;
};

CREATE_PAWS_FACTORY(pawsMultilineEditTextBox);



#define FADE_TIME              1000 // Time for the onscreen message to fade away
#define MESG_TIME              3000 // Time for the onscreen message to be shown ( not including fading)

class pawsFadingTextBox : public pawsWidget
{
public:
    pawsFadingTextBox();
    virtual ~pawsFadingTextBox() {};
    pawsFadingTextBox(const pawsFadingTextBox &origin);
    bool Setup(iDocumentNode* /*node*/)
    {
        return true;   // Shouldn't be created in XML, only by code
    }

    void Draw();

    void Fade(); // Force fading
    void SetText(const char* newtext, iFont* font1,iFont* font2, int color,int time=MESG_TIME,int fadetime=FADE_TIME);

    void GetSize(int &w, int &h);
private:
    void DrawBorderText(const char* text, iFont* font,int x);

    csString text;
    csString first;

    csRef<iFont> firstFont; // used for the first letter
    csRef<iFont> font;      // used for the rest

    int org_color;
    int color;
    int scolor;
    csTicks start;

    int ymod;

    int time,fadetime;
};

CREATE_PAWS_FACTORY(pawsFadingTextBox);
struct PictureInfo
{
    unsigned int width; 
    unsigned int height;
    csString srcString;
    unsigned int align;
    unsigned int padding[4];
};
class pawsDocumentView: public pawsMultiLineTextBox
{
public:
    pawsDocumentView();
    pawsDocumentView(const pawsDocumentView &origin);
    virtual ~pawsDocumentView();
    void SetText(const char* text);
    void Draw();
    void Resize();
protected:
    void OrganizeContent(const char* text);

    unsigned int ProcessPictureInfo(iDocumentNode* node);

    csArray<PictureInfo> picsInfo;
};
CREATE_PAWS_FACTORY(pawsDocumentView);


class pawsMultiPageDocumentView: public pawsMultiPageTextBox
{
public:
    pawsMultiPageDocumentView();
    pawsMultiPageDocumentView(const pawsMultiPageDocumentView &origin);
    virtual ~pawsMultiPageDocumentView();
    void SetText(const char* text);

    void Draw();

    void Resize();
protected:
    void OrganizeContent(const char* text);

    unsigned int ProcessPictureInfo(iDocumentNode* node);
    csArray<PictureInfo> picsInfo;
};
CREATE_PAWS_FACTORY(pawsMultiPageDocumentView);

#endif