|| || || || || || || ||

---

TextEdit.h

Go to the documentation of this file.

/*
12345678901234567890123456789012345678901234567890123456789012345678901234567890
*/
#ifndef OglGui_TextEdit_h
#define OglGui_TextEdit_h

#include <deque>

#ifndef OglGui_DocDimensions_h
#include "OglGui/DocDimensions.h"
#endif

#ifndef OglGui_WindowScrollBar_h
#include "OglGui/WindowScrollBar.h"
#endif

#ifndef OglGui_TextEditListener_h
#include "OglGui/TextEditListener.h"
#endif


namespace OglGui
{

class TextEdit : public Window, public DocDimensions, ScrollBarListener, RepeatTimer
{
    typedef std::string string;

public:

    TextEdit(int x, int y, int w, int h, strconst text, int sB=3) :
        Window(x, y, w, h)
    {
        Init(text, w, h, sB);
    }

    TextEdit(Window* parent, int w, int h, strconst text, int sB=3) :
        Window(parent, w, h)
    {
        Init(text, w, h, sB);
    }

    TextEdit(Window* parent, int x,int y, int w,int h, strconst text, int sB=3):
        Window(parent, x, y, w, h)
    {
        Init(text, w, h, sB);
    }

// ChangeInfo inner class for infinite undo/redo
    class ChangeInfo
    {
    public:
        ChangeInfo(int ind1, int ind2, std::string* str, int caret, int mark)
        {
            mStart = ind1;
            mEnd   = ind2;
            mCaret = caret;
            mMark  = mark;
            mStr  = *str;
        }

        int Start()       { return mStart; }
        int End()         { return mEnd; }
        int Caret()       { return mCaret; }
        int Mark()        { return mMark; }
        std::string Str() { return mStr; }

    private:
        std::string     mStr;
        int             mStart, mEnd;
        int             mCaret, mMark;
    };

// End of ChangeInfo inner class

// Infinite undo/redo stuff
// NOTE: Should probably be made private
    void EmptyChangeInfoDeque(std::deque<ChangeInfo*>& deQue)
    {
        ChangeInfo *changeInfo;
        while (!deQue.empty())
        {
            changeInfo = deQue.back();
            deQue.pop_back();
            delete changeInfo;
        }
    }

    void UndoAction()
    {
        if (undoDeque.empty())
            return;

        ChangeInfo* undo = undoDeque.back();
        undoDeque.pop_back();

        ChangeInfo* redo = undoDeque.back();
        undoDeque.pop_back();

        mText.replace(undo->Start(), undo->End() - undo->Start(), undo->Str());
        mCaret = undo->Caret();
        mMark  = undo->Mark();

        redoDeque.push_back(redo);
        redoDeque.push_back(undo);

        RecomputeDocument();
        PublishChange();
    }

    void RedoAction()
    {
        if (redoDeque.empty())
            return;

        ChangeInfo* undo = redoDeque.back();
        redoDeque.pop_back();

        ChangeInfo* redo = redoDeque.back();
        redoDeque.pop_back();

        mText.replace(redo->Start(), redo->End() - redo->Start(), redo->Str());
        mCaret = redo->Caret();
        mMark  = redo->Mark();

        undoDeque.push_back(redo);
        undoDeque.push_back(undo);

        RecomputeDocument();
        PublishChange();
    }

    void UndoableInsertKey(int c)
    {
        string  str = "";
        string  redoStr = "";
        char    buf[2];
        int     left, right;

        if (!redoDeque.empty())
            EmptyChangeInfoDeque(redoDeque);

        buf[0] = c; buf[1] = '\0';
        redoStr += buf;

        GetSelectionLeftRight(left, right);

        ChangeInfo* redo = new ChangeInfo(left, right, &redoStr,
                                          left+(c?1:0), left+(c?1:0));
        if (left != right)
            str = mText.substr(left, right-left);
        ChangeInfo* undo = new ChangeInfo(left, left+(c?1:0), &str,
                                          mCaret, mMark);

        undoDeque.push_back(redo);
        undoDeque.push_back(undo);
    }

    void UndoableInsertString(string str)
    {
        string  undoStr = "";
        int     left, right;

        if (!redoDeque.empty())
            EmptyChangeInfoDeque(redoDeque);

        GetSelectionLeftRight(left, right);

        if (left != right)
            undoStr = mText.substr(left, right-left);

        ChangeInfo* redo = new ChangeInfo(left, left+undoStr.length(), &str,
                                          left+str.length(), left+str.length());

        ChangeInfo* undo = new ChangeInfo(left, left + str.length(), &undoStr,
                                          mCaret, mMark);

        undoDeque.push_back(redo);
        undoDeque.push_back(undo);
    }

    void UndoableDeleteKey(int dir)
    {
        string  str = "";
        string  undoStr = "";
        char    buf[2];

        if (!redoDeque.empty())
            EmptyChangeInfoDeque(redoDeque);

        int chInd = mCaret + (dir == -1 ? -1 : 0); 
        buf[0] = mText[chInd];
        buf[1] = '\0';
        undoStr += buf;

        ChangeInfo* redo = new ChangeInfo(mCaret + (dir==-1 ? -1:0),
                                          mCaret + (dir==-1 ?  0:1), &str,
                                          mCaret, mCaret);

        ChangeInfo* undo = new ChangeInfo(mCaret + (dir==-1 ? -1:0),
                                          mCaret + (dir==-1 ? -1:0), &undoStr,
                                          mCaret, mMark);
        undoDeque.push_back(redo);
        undoDeque.push_back(undo);
    }
// End of undo/redo related stuff

// Convenience functions
    bool ReadFile(strconst fileName)
    {
        if (mSingleLine)
            return false;

        int nBytes = -1;
        FILE *fp = fopen(fileName.c_str(), "rb");
        if (fp)
        {
            fseek(fp, 0, SEEK_END);
            nBytes = ftell(fp);
            fseek(fp, 0, SEEK_SET);
            char* buf = (char *) malloc(nBytes+1);
            if (buf)
            {
                nBytes = fread(buf, sizeof(char), nBytes, fp);
                buf[nBytes] = '\0';
                // Get rid of 13 10 newline combinations
                char *tmpBuf = (char*) malloc(nBytes+1);
                if (tmpBuf)
                {
                    int ind=0;
                    for (int i=0; i<=nBytes; i++)
                        if (buf[i] != 13)
                            tmpBuf[ind++] = buf[i];
                    SetText(tmpBuf);
                    free(tmpBuf);
                }
                else
                    SetText(buf);
                free(buf);
            }
            else
                nBytes = -1;
            fclose(fp);
        }
        return nBytes != -1;
    }

    void PublishChange()
    {
        if (mListener)
            mListener->TextEditChangedEvent(this, mListenerData);
    }

// Setters / Getters
    void SetTextEditListener(TextEditListener* listener, void* userData=0)
    {
        mListener = listener;
        mListenerData = userData;
    }

    void SetText(strconst txt)
    {
        EmptyChangeInfoDeque(undoDeque);
        EmptyChangeInfoDeque(redoDeque);

        if (mSingleLine)
        {
            string str;
            int pos = txt.find_first_of("\n", 0);
            if (pos == string::npos)
                pos = txt.length();
            str = txt.substr(0, pos);
            mText = str;
        }
        else
            mText = txt;

        mDocX = mDocY = 0;
        mCaret = mMark = 0;
        RecomputeDocument();
        PublishChange();
        mDocX = 0;
    }

    string GetText() { return mText; }

    ScrollBar* HorizontalScrollBar() { return mHorizontalScrollBar; }
    ScrollBar* VerticalScrollBar() { return mVerticalScrollBar; }

    void  Editable(bool mode) { mEditable = mode; }
    bool  Editable() { return mEditable; }

    void  SingleLine(bool mode) { mSingleLine = mode; }
    bool  SingleLine() { return mSingleLine; }

    void  ClipBackground(bool mode) { mClipBackground = mode; }
    bool  ClipBackground() { return mClipBackground; }

    void  CaretColor(ULONG col) { mCaretColor = col; }
    ULONG CaretColor() { return mCaretColor; }

    void  TextShadowed(bool mode) { mTextShadowed = mode; }
    bool  TextShadowed() { return mTextShadowed; }

    void  TextShadowColor(ULONG shadCol) { mShadowColor = shadCol; };
    ULONG TextShadowColor() { return mShadowColor; };

    void  LineHeight(int h) { mLineH = h; }
    int   LineHeight() { return mLineH; }

    int   Length() { return mText.length(); }

    string GetSelection()
    {
        if (mMark == mCaret)
            return "";

        int left, right;
        GetSelectionLeftRight(left, right);
        return mText.substr(left, right-left);
    }

    void SetCaretMark(int caret, int mark)
    {
        Caret(caret);
        Mark(mark);
    }

    void Caret(int ind)
    {
        if ((mCaret = ind) > mText.length())
            mCaret = mText.length();
        if (mCaret < 0)
            mCaret = 0;
    }

    void  Mark(int ind)
    {
        if ((mMark = ind) > mText.length())
            mMark = mText.length();
        if (mMark < 0)
            mMark = 0;
    }

    int Caret()  { return mCaret; }
    int Mark()   { return mMark; }
    int CaretX() { return mCaretX; }
    int CaretY() { return mCaretY; }
// End of Setter / Getters
    void RecomputeDocument()
    {
        ComputeDocHeight();
        ClampDocY();
        ComputeCaretPosition();
        MoveToCaret();
    }

    int ComputeDocHeight()
    {
        int h = 0;
        int nChar;
        int ind = 0;

        while ((nChar = GetLineAtIndex(0, ind))!=-1)
        {
            ind += nChar+1;
            h += mLineH;
        }
        return mDocH = h;
    }

    int ComputeMaxWidth()
    {
        string  str;
        int     nChar;
        int     lineInd = 0;
        int     x, maxX = 0;

        while ((nChar = GetLineAtIndex(&str, lineInd) + 1))
        {
            x = FindWidthAtIndex(&str, str.length());
            if (x > maxX)
                maxX = x;
            lineInd += nChar;
        }
        return maxX;
    }

    void ComputeCaretPosition()
    {
        int y = mDocH + mDocY - mLineH;
        int lineInd = 0;
        int nChar;

        while ((nChar = GetLineAtIndex(0, lineInd) + 1) &&
               lineInd+nChar <= mCaret)
        {
            lineInd += nChar;
            y -= mLineH;
        }
        mCaretY = y;

        int x = mLeftMargin;
        if (nChar)
        {
            string str;
            GetLineAtIndex(&str, lineInd);
            x = FindWidthAtIndex(&str, mCaret - lineInd) + mDocX;
        }
        mCaretX = x;
    }

    void ClampDocX()
    {
        if (mDocX > 0)
            mDocX = 0;
        if (mDocX + mDocW < W())
            mDocX = W() - mDocW;
    }

    void ClampDocY()
    {
        if (mDocY < H() - mDocH)
            mDocY = H() - mDocH;
        if (mDocY > H() - mLineH)
            mDocY = H() - mLineH;
    }

    void GetSelectionLeftRight(int& left, int& right)
    {
        if (mMark < mCaret)
        {
            left  = mMark;
            right = mCaret;
        }
        else
        {
            left  = mCaret;
            right = mMark;
        }
    }

    int FindIndexAtWidth(string* str, int w)
    {
        int len = str->length();
        int ind = 0, indW;
        while (ind<len && (indW=FindWidthAtIndex(str, ind)) < w)
            ind++;
        return ind;
    }

    int FindInsertionIndexAtWidth(string* str, int w)
    {
        int len = str->length();
        int ind = 0, indW;
        while (ind<len && (indW=FindWidthAtIndex(str, ind)) < w)
            ind++;
 
        // Find closest side for insertion. If clicked on first halve of
        // character insert before, otherwise after
        if (ind && (indW - (indW - FindWidthAtIndex(str, ind-1))/2) > w)
            ind--;
        return ind;
    }

    int FindWidthAtIndex(string* str, int ind)
    {
        char    buf[2048];
        int     w, h;
        void*   font;

        int     tPos, tInd = 0, tCnt = 0, tabW;
        int     totWidth = 0;
        string  tabStr;

        if (ind > str->length())
            ind = str->length();
        if (ind > 2047)
            ind = 2047;

        FindOglFont(mOglWnd, &font, NULL);

        if ((tPos = str->find_first_of("\t")) == string::npos)
        {
            buf[0] = '\0';
            strncpy(buf, str->c_str(), ind);
            buf[ind] = '\0';
            oglSys.AbstFontTextSize(mOglWnd, font, buf, &w, &h);
            return mLeftMargin + w;
        }

        oglSys.AbstFontTextSize(mOglWnd, font, "    ", &w, &h);
        tabW = w;

        bool done = false;
        while (!done && ((tPos = str->find_first_of("\t",tInd)) != string::npos))
        {
            tabStr = str->substr(tInd, tPos-tInd);
            if (ind > tInd + tabStr.length())
            {
                oglSys.AbstFontTextSize(mOglWnd, font, tabStr.c_str(), &w, &h);
                tCnt = (totWidth + w) / tabW + 1;
                totWidth = tCnt * tabW;
            }
            else
            {
                tabStr = tabStr.substr(0, ind - tInd);
                oglSys.AbstFontTextSize(mOglWnd, font, tabStr.c_str(), &w, &h);
                totWidth += w;
                done = true;
            }
            tInd = tPos+1;
        }
        if (!done)
        {
            tabStr = str->substr(tInd, ind - tInd);
            oglSys.AbstFontTextSize(mOglWnd, font, tabStr.c_str(), &w, &h);
            totWidth += w;
        }
        return mLeftMargin + totWidth;
    }

/*
    // No tab support version
    int FindWidthAtIndex(string* str, int ind)
    {
        char    buf[2048];
        int     w, h, font;
        
        FindOglFont(mOglWnd, &font, NULL);

        buf[0] = '\0';
        strncpy(buf, str->c_str(), ind);
        buf[ind] = '\0';
        oglSys.AbstFontTextSize(mOglWnd, font, buf, &w, &h);
        return mLeftMargin + w;
    }
*/

    int FindLineAtY(int wndY, int &lineY)
    {
        int ind = 0, nChar = 0;
        int y = mDocH + mDocY - mLineH;

        while (y > wndY && (nChar = GetLineAtIndex(0, ind))!=-1)
        {
            ind += nChar+1;
            y -= mLineH;
        }
        if (ind > mText.length())
            ind = mText.length();
        lineY = y;
        return ind;
    }

    int FindFirstVisibleLine(int &lineY)
    {
        return FindLineAtY( H(), lineY);
    }

    int GetLineAtIndex(string* str, int ind)
    {
        if (ind >= mText.length())
            return -1;
        int pos = mText.find_first_of("\n", (size_t) ind);
        if (pos == string::npos)
            pos = mText.length();
        if (str!=0)
            *str = (pos-ind) ? mText.substr(ind, pos-ind) : "";
        return pos-ind;
    }

    void InvertBlock(int x1, int y1, int x2, int y2)
    {
        glColor3d(1,1,1);
        glEnable(GL_BLEND);
        glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
        glBegin(GL_QUADS);
        glVertex2d(x1, y1);
        glVertex2d(x1, y2);
        glVertex2d(x2, y2);
        glVertex2d(x2, y1);
        glEnd();
        glDisable(GL_BLEND);
    }

    void HandleInvertLineSelection(string *str, int ind, int indEnd, int y)
    {
        if (mMark == mCaret)
            return;

        int left, right;
        int xEnd, xStart, yEnd = y + mLineH;

        GetSelectionLeftRight(left, right);

        if (ind >= left && indEnd <= right)
        {
            if (*str == "")
                xEnd = mLeftMargin+4;
            else
                xEnd = FindWidthAtIndex(str, indEnd-ind); 
            InvertBlock(mLeftMargin+mDocX, y, xEnd+mDocX, yEnd);
        }
        else
        {
            if (ind >= left && ind <= right)
            {
                xEnd = FindWidthAtIndex(str, right-ind);
                InvertBlock(mLeftMargin+mDocX, y, xEnd+mDocX, yEnd);
            }
            if (indEnd > left && indEnd <= right)
            {
                xStart = FindWidthAtIndex(str, left-ind)+mDocX;
                xEnd = FindWidthAtIndex(str, indEnd-ind)+mDocX; 
                InvertBlock(xStart, y, xEnd, yEnd);
            }
            if (ind < left && indEnd > right)
            {
                xStart = FindWidthAtIndex(str, left-ind)+mDocX;
                xEnd = FindWidthAtIndex(str, right-ind)+mDocX;
                InvertBlock(xStart, y, xEnd, yEnd);
            }
        }
    }

    void PrintBuf(int x, int y, const char* buf)
    {
        int col = GetForeground();
        if (!mTextShadowed)
            oglSys.PosColPrintf(mOglWnd, x, y, col, "%s", buf);
        else
            oglSys.ShadowPrintf(mOglWnd, x, y, mShadowColor, col, "%s", buf);
    }

    void DrawTabbedLine(int x, int y, const char* buf)
    {
        string  str = buf;

        if (str.find_first_of("\t") == string::npos)
            return PrintBuf(x, y, buf);

        string  tabStr;
        int     tabPos, tabInd = 0;
        int     totWidth = 0, tabCnt = 0;
        int     w, h;
        int     tabWidth;
        void*   font;

        FindOglFont(mOglWnd, &font, NULL);
        oglSys.AbstFontTextSize(mOglWnd, font, "    ", &tabWidth, &h);

        while ((tabPos = str.find_first_of("\t", tabInd)) != string::npos)
        {
            tabStr = str.substr(tabInd, tabPos-tabInd);
            PrintBuf(x + totWidth, y, tabStr.c_str());

            oglSys.AbstFontTextSize(mOglWnd, font, tabStr.c_str(), &w, &h);
            tabCnt = (totWidth + w) / tabWidth + 1;
            totWidth = tabCnt * tabWidth;
            tabInd = tabPos+1;
        }
        if (tabInd < str.length())
        {
            tabStr = str.substr(tabInd, str.length()-tabInd);
            PrintBuf(x + totWidth, y, tabStr.c_str());
        }
    }

    void DrawText()
    {
        int    yPos = H();
        int    ind = 0;

        if ((ind = FindFirstVisibleLine(yPos)) > mText.length())
            return;

        string  line;
        char    buf[2048];
        int     nChar;

        while (yPos >= -mLineH && (nChar = GetLineAtIndex(&line, ind))!=-1)
        {
            int  bufInd = 0;
            int  xOff = mLeftMargin + mDocX;
            bool doShow = true;

            strncpy(buf, line.c_str(), 2047);
            buf[2047] ='\0';

            if (mDocX < 0)
            {
                bufInd = FindIndexAtWidth(&line, -mDocX);
                if ((xOff = FindWidthAtIndex(&line, bufInd) + mDocX) < 0)
                    doShow = false;
            }
            if (doShow) // RvB added 2 to allow for smaller single line height
                DrawTabbedLine(xOff, yPos+2, buf + bufInd);

            if (mMark != mCaret) // RvB: changed -4 into -2 for smaller line heights
                HandleInvertLineSelection(&line, ind, ind+nChar+1, yPos-2);
            ind += nChar+1;
            yPos -= mLineH;
        }
        if (GetOGLWND() == oglFocusWnd) {
            SetSolidLineColor(mCaretColor);
        } else {
            SetSolidLineColor(mShadowColor);
        }
        // RvB used to draw -4 changed to -2 to allow for smaller line height
        DrawLine(mCaretX, mCaretY-2, mCaretX, mCaretY-2+mLineH);
    }

    void MoveToCaret()
    {
        int minY = mHorizontalScrollBar ? mHorizontalScrollBar->H() : 0;
        int maxW = W() - (mVerticalScrollBar ? mVerticalScrollBar->W() : 0);

        if (mCaretY < minY)
        {
            mDocY -= (mCaretY-minY)-6;
            mCaretY = minY + 6;
        }
        if (mCaretY > H() - mLineH)
        {
            mDocY -= mCaretY - (H() - mLineH);
            mCaretY = H() - mLineH;
        }
        if (mCaretX < 0)
        {
            mDocX -= mCaretX-mLeftMargin;;
            mCaretX = mLeftMargin;
        }
        if (mCaretX > maxW - 8)
        {
            mDocX -= mCaretX - (maxW-8);
        }
    }

    void HandleMoveKey(int c, int state)
    {
        bool    shift   = (state & oglShift) ? true : false;
        bool    control = (state & oglControl) ? true : false;
        string  str;

        if (c==oglUP || c==oglDOWN || c==oglPAGEUP || c==oglPAGEDOWN)
        {
            int     lineInd = FindLineAtY(mCaretY, mCaretY);
            int     dY;

            if (mUpDownPos == -1)
                mUpDownPos = mCaret - lineInd;

            if (c==oglUP || c==oglDOWN)
                dY = (c==oglUP ? mLineH : -mLineH);
            else
                dY = (c==oglPAGEUP ? H()-2*mLineH : -H()+2*mLineH);

            lineInd = FindLineAtY(mCaretY + dY, mCaretY);
            if (c==oglPAGEUP || c==oglPAGEDOWN)
            {
                int oldCaretY = mCaretY;
                ComputeCaretPosition();
                mDocY += mCaretY - oldCaretY;
                ClampDocY();
            }
            GetLineAtIndex(&str, lineInd);
            int sLen = str.length();
            mCaret = lineInd + ((sLen > mUpDownPos) ? mUpDownPos : sLen);
        }
        else
        {
            mUpDownPos = -1;
            if (c==oglLEFT || c==oglRIGHT)
                if ((mCaret += (c==oglLEFT) ? -1 : 1) < 0)
                    mCaret = 0;

            if (c==oglHOME && control)
                mCaret = 0;
            else if(c == oglHOME)
                mCaret = FindLineAtY(mCaretY, mCaretY);

            if (c==oglEND && control)
                mCaret = mText.size();
            else if (c==oglEND)
            {
                int lineInd = FindLineAtY(mCaretY, mCaretY);
                GetLineAtIndex(&str, lineInd);
                mCaret = lineInd + str.length();
            }
        }

        if (mCaret > mText.length())
            mCaret = mText.length();

        if (!shift)
            mMark = mCaret;

        ComputeCaretPosition();
    }

    void DoDeleteSelection()
    {
        int left,right;
        GetSelectionLeftRight(left, right);
        //mText = mText.erase(left, right - left);
mText.erase(left, right - left);
        mCaret = mMark = left;
    }

    void InsertKey(int c)
    {
        UndoableInsertKey(c);
        if (mCaret != mMark)
            DoDeleteSelection();
        mText.insert(mCaret, 1, c);
        mCaret++;
        mMark = mCaret;
        ComputeCaretPosition();
        PublishChange();
    }

    void InsertString(string str)
    {
        UndoableInsertString(str);
        if (mCaret != mMark)
            DoDeleteSelection();
        mText.insert(mCaret, str);
        mMark = mCaret += str.length();
        ComputeCaretPosition();
        PublishChange();
    }

    void DeleteSelection()
    {
        bool changed = mCaret != mMark;
        UndoableInsertKey(0);
        DoDeleteSelection();
        if (changed)
            PublishChange();
    }

    void BackSpace()
    {
        bool changed = mCaret != mMark;

        if (mCaret != mMark)
            DeleteSelection();
        else if (mCaret > 0)
        {
            changed = true;
            UndoableDeleteKey(-1);
            mMark = --mCaret;
            //mText = mText.erase(mCaret, 1);
mText.erase(mCaret, 1);
        }
        ComputeCaretPosition();
        if (changed)
            PublishChange();
    }

    void DeleteKey()
    {
        bool changed = mCaret != mMark;
        if (mCaret != mMark)
            DeleteSelection();
        else if (mCaret < mText.size())
        {
            changed = true;
            UndoableDeleteKey(1);
            //mText = mText.erase(mCaret, 1);
mText.erase(mCaret, 1);
        }
        ComputeCaretPosition();
        if (changed)
            PublishChange();
    }

    void Paste()
    {
        if (mClipboardString.empty())
            return;
        if (mSingleLine)
        {
            string str;
            int pos = mClipboardString.find_first_of("\n", 0);
            if (pos == string::npos)
                pos = mClipboardString.length();
            str = mClipboardString.substr(0, pos);
            InsertString(str);
        }
        else
            InsertString(mClipboardString);
        PublishChange();
    }

    void Copy()
    {
        if (mCaret == mMark)
            return;

        int left,right;
        GetSelectionLeftRight(left, right);
        mClipboardString = mText.substr(left, right - left);
    }

    void Cut()
    {
        bool changed = mCaret != mMark;
        Copy();
        DeleteSelection();
        if (changed)
            PublishChange();
    }

    void StartScrollClipping()
    {
        int x = 0, y = 0, w = W(), h = H();
        if (mHorizontalScrollBar)
        {
            y = mHorizontalScrollBar->H();
            h -= mHorizontalScrollBar->H();
        }
        if (mVerticalScrollBar)
            w -= mVerticalScrollBar->W();
        oglSys.StartScissor(mOglWnd, x, y, w, h);

    }

    void EndScrollClipping()
    {
        oglSys.EndScissor();
    }

    virtual void OnScroll(ScrollBar *src, int position, void* userData)
    {
        if (src == mHorizontalScrollBar)
            mDocX = -position;
        if (src == mVerticalScrollBar)
            mDocY = -mDocH + H() + position;
        ComputeCaretPosition();
    }

    void HandleScrollBarsOnDisplay()
    {
        if (mVerticalScrollBar)
        {
            int extra = mHorizontalScrollBar ? mHorizontalScrollBar->H() : 0;
            mVerticalScrollBar->SetRange(mDocH+4 + extra, H() - extra - mLineH);
            int nPos = mDocH - H() + mDocY;
            mVerticalScrollBar->SetNewPos(nPos);
        }

        if (mHorizontalScrollBar)
        {
            mHorizontalScrollBar->SetRange(mDocW, W()-20);
            mHorizontalScrollBar->SetNewPos(-mDocX);
        }

        if (mPropagateScrollingY && RepeatTime())
        {
            mDocY += mPropagateScrollingY;
            ClampDocY();
            MouseFunc(oglMouseMove, 0, oglLeftButton, mLastMouseX, mLastMouseY);
        }

        if (mPropagateScrollingX && RepeatTime())
        {
            mDocX += mPropagateScrollingX;
            ClampDocX();
            MouseFunc(oglMouseMove, 0, oglLeftButton, mLastMouseX, mLastMouseY);
        }
    }

    virtual void InitFunc()
    {
        Window::InitFunc();
        mInitialized = true;
    }

    virtual void ExitFunc()
    {
        EmptyChangeInfoDeque(undoDeque);
        EmptyChangeInfoDeque(redoDeque);
        Window::ExitFunc();
    }

    virtual void InitDisplayFunc()
    {
        if (mClipBackground && (mHorizontalScrollBar || mVerticalScrollBar))
            StartScrollClipping();
        Window::InitDisplayFunc();
    }

    virtual void DisplayFunc()
    {
        Window::DisplayFunc();

        HandleScrollBarsOnDisplay();
 
        if (!mClipBackground && (mHorizontalScrollBar || mVerticalScrollBar))
            StartScrollClipping();

        OGC oldOGC;
        OGCSave(&oldOGC);
        DrawText();
        OGCRestore(&oldOGC);
        ComputeCaretPosition();

        if (mHorizontalScrollBar || mVerticalScrollBar)
            EndScrollClipping();
    }

    virtual void MouseFunc(int msg, int btn, int state, int x, int y)
    {
        if (msg == oglMouseDown && btn == oglLeftButton && !(state&oglControl))
        {
            string  str;
            int     lineInd = FindLineAtY(y, mCaretY);

            GetLineAtIndex(&str, lineInd);
            mCaret = lineInd + FindInsertionIndexAtWidth(&str, -mDocX+x);
            if (!(state & oglShift))
                mMark = mCaret;

            StartRepeatTime();
            oglSys.SetAlwaysDraw(mOglWnd, 1);
            mLastMouseX = x;
            mLastMouseY = y;
            mUpDownPos = mCaret - lineInd;
        }
        if (msg == oglMouseMove && (state & oglLeftButton))
        {
            string  str;
            int     lineInd = FindLineAtY(y, mCaretY);

            GetLineAtIndex(&str, lineInd);
            mCaret = lineInd + FindInsertionIndexAtWidth(&str, -mDocX+x);

            mPropagateScrollingX = mPropagateScrollingY = 0;

            int minY = mHorizontalScrollBar ? mHorizontalScrollBar->H() : 0;
            if (y < minY)
                mPropagateScrollingY = 4 - (y-minY)/2;
            else if(y > H())
                mPropagateScrollingY = -4 - (y - H())/2;

            int maxW = W() - (mVerticalScrollBar ? mVerticalScrollBar->W() : 0); 
            if (x < 0)
                mPropagateScrollingX = 4 - x/2;
            else if(x > maxW)
                mPropagateScrollingX = -4 - (x - maxW)/2;

            mLastMouseX = x;
            mLastMouseY = y;
            mUpDownPos = mCaret - lineInd;
        }

        if (msg == oglMouseUp && btn == oglLeftButton)
        {
            mPropagateScrollingY = mPropagateScrollingX = 0;
            oglSys.SetAlwaysDraw(mOglWnd, 0);
        }

        if (msg == oglMouseWheelUp || msg == oglMouseWheelDown)
        {
            mDocY += (msg == oglMouseWheelUp ? -mLineH : mLineH);
            ClampDocY();
        }

        ComputeCaretPosition();
        Window::MouseFunc(msg, btn, state, x, y);
    }

    virtual void KeyboardFunc(int c, int state)
    {
        bool shift = (state & oglShift) ? true : false;
        int  oldDocH = mDocH;

        Window::KeyboardFunc(c, state);

        if (c == oglUP     || c == oglDOWN ||
            c == oglLEFT   || c == oglRIGHT ||
            c == oglPAGEUP || c == oglPAGEDOWN ||
            c == oglHOME   || c == oglEND)
        {
            HandleMoveKey(c, state);
        }
        if (c == oglCTRL('c'))
            Copy();

        if (mEditable)
        {
            if (c == oglCTRL('z'))
                UndoAction();
            if (c == oglCTRL('y'))
                RedoAction();

            if (c == oglCTRL('x'))
                Cut();
            if (c == oglCTRL('v'))
                Paste();

            if( c == '\r' )
                c = '\n';

            if( c == 8 )
                BackSpace();
            if (c == oglDELETE)
                DeleteKey();
            if (c == '\n' || c == '\t' || c == ' ' || isalnum(c) || ispunct(c))
                if (!(mSingleLine && c == '\n'))
                    InsertKey(c);

            mDocY -= ComputeDocHeight() - oldDocH;
        }

        MoveToCaret();
    }


    virtual void ReshapeFunc(int w, int h)
    {
        Window::ReshapeFunc(w,h);

        if (!mInitialized)
            return;

        ComputeDocHeight();

        // Anchor text at upper left corner
        mDocY += (h - mOldH);
        mOldH = h;

        ClampDocY();
        ComputeCaretPosition();
    }

protected:

    void Init(strconst text, int w, int h, int sB)
    {
        SetBorderType( BEV_RIDGE );
        mListener = 0;
        mHorizontalScrollBar = mVerticalScrollBar = 0;

        // Used to be true, but I do not know why
        // mClipBackground = true;
        mClipBackground = false;

        mInitialized = false;
        mEditable = true;
        mSingleLine = false;
 
        //mDocX = 0;
        mDocW = 800;
        mOldH = h;
        mLeftMargin = 8;

        mMark = 0;
        mCaret = 0;
        mCaretY = h - mLineH;
        mCaretX = mLeftMargin;
        mCaretColor = oglLIGHTRED;

        mTextShadowed = false;
        mShadowColor = oglLIGHTGREY;
        mLineH = 16;

        SetText(text);


        if (sB & 1)
        {
            mHorizontalScrollBar = new WindowScrollBar(this, true, 1, 16,
                                                       (sB&2)?16:0);
            mHorizontalScrollBar->SetLineIncrement(mLineH);
            mHorizontalScrollBar->SetScrollBarListener(this);
            mHorizontalScrollBar->MapKeysTo(this);
        }
        if (sB & 2)
        {
            mVerticalScrollBar = new WindowScrollBar(this, false, 1, 16,
                                                     (sB&1)?16:0);
            mVerticalScrollBar->SetLineIncrement(mLineH);
            mVerticalScrollBar->SetScrollBarListener(this);
            mVerticalScrollBar->MapKeysTo(this);
        }

        mUpDownPos = -1;

        mPropagateScrollingY = 0;
        mPropagateScrollingX = 0;
        mLastMouseX = 0;

        SetDisableGlobalKeyListener( true );
        SetDisableOGLViewKeys( true );
        SetDisableOGLViewMouse( true );

        SetBackground(oglWHITE);
    }

    std::deque<ChangeInfo*> undoDeque;
    std::deque<ChangeInfo*> redoDeque;

    WindowScrollBar*    mHorizontalScrollBar;
    WindowScrollBar*    mVerticalScrollBar;
    bool                mClipBackground;

    string      mText;
    int         mLineH;

    bool        mInitialized;
    bool        mEditable;
    bool        mSingleLine;

    int         mMark;
    int         mCaret;
    int         mCaretX;
    int         mCaretY;
    ULONG       mCaretColor;

    int         mLeftMargin;
    
    int         mOldH;
    int         mUpDownPos;

    bool        mTextShadowed;
    ULONG       mShadowColor;

    int         mPropagateScrollingY;
    int         mPropagateScrollingX;

    int         mLastMouseX;
    int         mLastMouseY;


    TextEditListener* mListener;
    void*             mListenerData;
};

} // namespace oglGui
#endif

---