/*
 * Copyright 2001-2020 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus, superstippi@gmx.de
 *              Stefano Ceccherini, stefano.ceccherini@gmail.com
 *              Marc Flerackers, mflerackers@androme.be
 *              Hiroshi Lockheimer (BTextView is based on his STEEngine)
 *              John Scipione, jscipione@gmail.com
 *              Oliver Tappe, zooey@hirschkaefer.de
 */


// TODOs:
// - Consider using BObjectList instead of BList
//       for disallowed characters (it would remove a lot of reinterpret_casts)
// - Check for correctness and possible optimizations the calls to _Refresh(),
//       to refresh only changed parts of text (currently we often redraw the whole
//   text)

// Known Bugs:
// - Double buffering doesn't work well (disabled by default)


#include <TextView.h>

#include <algorithm>
#include <new>

#include <stdio.h>
#include <stdlib.h>

#include <Alignment.h>
#include <Application.h>
#include <Beep.h>
#include <Bitmap.h>
#include <Clipboard.h>
#include <ControlLook.h>
#include <Debug.h>
#include <Entry.h>
#include <Input.h>
#include <LayoutBuilder.h>
#include <LayoutUtils.h>
#include <MessageRunner.h>
#include <Path.h>
#include <PopUpMenu.h>
#include <PropertyInfo.h>
#include <Region.h>
#include <ScrollBar.h>
#include <SystemCatalog.h>
#include <Window.h>

#include <binary_compatibility/Interface.h>

#include "InlineInput.h"
#include "LineBuffer.h"
#include "StyleBuffer.h"
#include "TextGapBuffer.h"
#include "UndoBuffer.h"
#include "WidthBuffer.h"


using namespace std;
using BPrivate::gSystemCatalog;


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "TextView"


#define TRANSLATE(str) \
        gSystemCatalog.GetString(B_TRANSLATE_MARK(str), "TextView")

#undef TRACE
#undef CALLED
//#define TRACE_TEXT_VIEW
#ifdef TRACE_TEXT_VIEW
#       include <FunctionTracer.h>
        static int32 sFunctionDepth = -1;
#       define CALLED(x...)     FunctionTracer _ft(printf, NULL, __PRETTY_FUNCTION__, sFunctionDepth)
#       define TRACE(x...)      { BString _to; \
                                                        _to.Append(' ', (sFunctionDepth + 1) * 2); \
                                                        printf("%s", _to.String()); printf(x); }
#else
#       define CALLED(x...)
#       define TRACE(x...)
#endif


#define USE_WIDTHBUFFER 1
#define USE_DOUBLEBUFFERING 0


struct flattened_text_run {
        int32   offset;
        font_family     family;
        font_style style;
        float   size;
        float   shear;          // typically 90.0
        uint16  face;           // typically 0
        uint8   red;
        uint8   green;
        uint8   blue;
        uint8   alpha;          // 255 == opaque
        uint16  _reserved_;     // 0
};

struct flattened_text_run_array {
        uint32  magic;
        uint32  version;
        int32   count;
        flattened_text_run styles[1];
};

static const uint32 kFlattenedTextRunArrayMagic = 'Ali!';
static const uint32 kFlattenedTextRunArrayVersion = 0;


enum {
        CHAR_CLASS_DEFAULT,
        CHAR_CLASS_WHITESPACE,
        CHAR_CLASS_GRAPHICAL,
        CHAR_CLASS_QUOTE,
        CHAR_CLASS_PUNCTUATION,
        CHAR_CLASS_PARENS_OPEN,
        CHAR_CLASS_PARENS_CLOSE,
        CHAR_CLASS_END_OF_TEXT
};


class BTextView::TextTrackState {
public:
        TextTrackState(BMessenger messenger);
        ~TextTrackState();

        void SimulateMouseMovement(BTextView* view);

public:
        int32                           clickOffset;
        bool                            shiftDown;
        BRect                           selectionRect;
        BPoint                          where;

        int32                           anchor;
        int32                           selStart;
        int32                           selEnd;

private:
        BMessageRunner*         fRunner;
};


struct BTextView::LayoutData {
        LayoutData()
                : leftInset(0),
                  topInset(0),
                  rightInset(0),
                  bottomInset(0),
                  valid(false),
                  overridden(false)
        {
        }

        float                           leftInset;
        float                           topInset;
        float                           rightInset;
        float                           bottomInset;

        BSize                           min;
        BSize                           preferred;
        bool                            valid : 1;
        bool                            overridden : 1;
};


static const rgb_color kBlueInputColor = { 152, 203, 255, 255 };
static const rgb_color kRedInputColor = { 255, 152, 152, 255 };

static const float kHorizontalScrollBarStep = 10.0;
static const float kVerticalScrollBarStep = 12.0;

static const int32 kMsgNavigateArrow = '_NvA';
static const int32 kMsgNavigatePage  = '_NvP';
static const int32 kMsgRemoveWord    = '_RmW';


static property_info sPropertyList[] = {
        {
                "selection",
                { B_GET_PROPERTY, 0 },
                { B_DIRECT_SPECIFIER, 0 },
                "Returns the current selection.", 0,
                { B_INT32_TYPE, 0 }
        },
        {
                "selection",
                { B_SET_PROPERTY, 0 },
                { B_DIRECT_SPECIFIER, 0 },
                "Sets the current selection.", 0,
                { B_INT32_TYPE, 0 }
        },
        {
                "Text",
                { B_COUNT_PROPERTIES, 0 },
                { B_DIRECT_SPECIFIER, 0 },
                "Returns the length of the text in bytes.", 0,
                { B_INT32_TYPE, 0 }
        },
        {
                "Text",
                { B_GET_PROPERTY, 0 },
                { B_RANGE_SPECIFIER, B_REVERSE_RANGE_SPECIFIER, 0 },
                "Returns the text in the specified range in the BTextView.", 0,
                { B_STRING_TYPE, 0 }
        },
        {
                "Text",
                { B_SET_PROPERTY, 0 },
                { B_RANGE_SPECIFIER, B_REVERSE_RANGE_SPECIFIER, 0 },
                "Removes or inserts text into the specified range in the BTextView.", 0,
                { B_STRING_TYPE, 0 }
        },
        {
                "text_run_array",
                { B_GET_PROPERTY, 0 },
                { B_RANGE_SPECIFIER, B_REVERSE_RANGE_SPECIFIER, 0 },
                "Returns the style information for the text in the specified range in "
                        "the BTextView.", 0,
                { B_RAW_TYPE, 0 },
        },
        {
                "text_run_array",
                { B_SET_PROPERTY, 0 },
                { B_RANGE_SPECIFIER, B_REVERSE_RANGE_SPECIFIER, 0 },
                "Sets the style information for the text in the specified range in the "
                        "BTextView.", 0,
                { B_RAW_TYPE, 0 },
        },

        { 0 }
};


BTextView::BTextView(BRect frame, const char* name, BRect textRect,
        uint32 resizeMask, uint32 flags)
        :
        BView(frame, name, resizeMask,
                flags | B_FRAME_EVENTS | B_PULSE_NEEDED | B_INPUT_METHOD_AWARE),
        fText(NULL),
        fLines(NULL),
        fStyles(NULL),
        fDisallowedChars(NULL),
        fUndo(NULL),
        fDragRunner(NULL),
        fClickRunner(NULL),
        fLayoutData(NULL)
{
        _InitObject(textRect, NULL, NULL);
        SetViewUIColor(B_DOCUMENT_BACKGROUND_COLOR);
}


BTextView::BTextView(BRect frame, const char* name, BRect textRect,
        const BFont* initialFont, const rgb_color* initialColor,
        uint32 resizeMask, uint32 flags)
        :
        BView(frame, name, resizeMask,
                flags | B_FRAME_EVENTS | B_PULSE_NEEDED | B_INPUT_METHOD_AWARE),
        fText(NULL),
        fLines(NULL),
        fStyles(NULL),
        fDisallowedChars(NULL),
        fUndo(NULL),
        fDragRunner(NULL),
        fClickRunner(NULL),
        fLayoutData(NULL)
{
        _InitObject(textRect, initialFont, initialColor);
        SetViewUIColor(B_DOCUMENT_BACKGROUND_COLOR);
}


BTextView::BTextView(const char* name, uint32 flags)
        :
        BView(name,
                flags | B_FRAME_EVENTS | B_PULSE_NEEDED | B_INPUT_METHOD_AWARE),
        fText(NULL),
        fLines(NULL),
        fStyles(NULL),
        fDisallowedChars(NULL),
        fUndo(NULL),
        fDragRunner(NULL),
        fClickRunner(NULL),
        fLayoutData(NULL)
{
        _InitObject(Bounds(), NULL, NULL);
        SetViewUIColor(B_DOCUMENT_BACKGROUND_COLOR);
}


BTextView::BTextView(const char* name, const BFont* initialFont,
        const rgb_color* initialColor, uint32 flags)
        :
        BView(name,
                flags | B_FRAME_EVENTS | B_PULSE_NEEDED | B_INPUT_METHOD_AWARE),
        fText(NULL),
        fLines(NULL),
        fStyles(NULL),
        fDisallowedChars(NULL),
        fUndo(NULL),
        fDragRunner(NULL),
        fClickRunner(NULL),
        fLayoutData(NULL)
{
        _InitObject(Bounds(), initialFont, initialColor);
        SetViewUIColor(B_DOCUMENT_BACKGROUND_COLOR);
}


BTextView::BTextView(BMessage* archive)
        :
        BView(archive),
        fText(NULL),
        fLines(NULL),
        fStyles(NULL),
        fDisallowedChars(NULL),
        fUndo(NULL),
        fDragRunner(NULL),
        fClickRunner(NULL),
        fLayoutData(NULL)
{
        CALLED();
        BRect rect;

        if (archive->FindRect("_trect", &rect) != B_OK)
                rect.Set(0, 0, 0, 0);

        _InitObject(rect, NULL, NULL);

        bool toggle;

        if (archive->FindBool("_password", &toggle) == B_OK)
                HideTyping(toggle);

        const char* text = NULL;
        if (archive->FindString("_text", &text) == B_OK)
                SetText(text);

        int32 flag, flag2;
        if (archive->FindInt32("_align", &flag) == B_OK)
                SetAlignment((alignment)flag);

        float value;

        if (archive->FindFloat("_tab", &value) == B_OK)
                SetTabWidth(value);

        if (archive->FindInt32("_col_sp", &flag) == B_OK)
                SetColorSpace((color_space)flag);

        if (archive->FindInt32("_max", &flag) == B_OK)
                SetMaxBytes(flag);

        if (archive->FindInt32("_sel", &flag) == B_OK &&
                archive->FindInt32("_sel", &flag2) == B_OK)
                Select(flag, flag2);

        if (archive->FindBool("_stylable", &toggle) == B_OK)
                SetStylable(toggle);

        if (archive->FindBool("_auto_in", &toggle) == B_OK)
                SetAutoindent(toggle);

        if (archive->FindBool("_wrap", &toggle) == B_OK)
                SetWordWrap(toggle);

        if (archive->FindBool("_nsel", &toggle) == B_OK)
                MakeSelectable(!toggle);

        if (archive->FindBool("_nedit", &toggle) == B_OK)
                MakeEditable(!toggle);

        ssize_t disallowedCount = 0;
        const int32* disallowedChars = NULL;
        if (archive->FindData("_dis_ch", B_RAW_TYPE,
                (const void**)&disallowedChars, &disallowedCount) == B_OK) {

                fDisallowedChars = new BList;
                disallowedCount /= sizeof(int32);
                for (int32 x = 0; x < disallowedCount; x++) {
                        fDisallowedChars->AddItem(
                                reinterpret_cast<void*>(disallowedChars[x]));
                }
        }

        ssize_t runSize = 0;
        const void* flattenedRun = NULL;

        if (archive->FindData("_runs", B_RAW_TYPE, &flattenedRun, &runSize)
                        == B_OK) {
                text_run_array* runArray = UnflattenRunArray(flattenedRun,
                        (int32*)&runSize);
                if (runArray) {
                        SetRunArray(0, fText->Length(), runArray);
                        FreeRunArray(runArray);
                }
        }
}


BTextView::~BTextView()
{
        _CancelInputMethod();
        _StopMouseTracking();
        _DeleteOffscreen();

        delete fText;
        delete fLines;
        delete fStyles;
        delete fDisallowedChars;
        delete fUndo;
        delete fDragRunner;
        delete fClickRunner;
        delete fLayoutData;
}


BArchivable*
BTextView::Instantiate(BMessage* archive)
{
        CALLED();
        if (validate_instantiation(archive, "BTextView"))
                return new BTextView(archive);
        return NULL;
}


status_t
BTextView::Archive(BMessage* data, bool deep) const
{
        CALLED();
        status_t err = BView::Archive(data, deep);
        if (err == B_OK)
                err = data->AddString("_text", Text());
        if (err == B_OK)
                err = data->AddInt32("_align", fAlignment);
        if (err == B_OK)
                err = data->AddFloat("_tab", fTabWidth);
        if (err == B_OK)
                err = data->AddInt32("_col_sp", fColorSpace);
        if (err == B_OK)
                err = data->AddRect("_trect", fTextRect);
        if (err == B_OK)
                err = data->AddInt32("_max", fMaxBytes);
        if (err == B_OK)
                err = data->AddInt32("_sel", fSelStart);
        if (err == B_OK)
                err = data->AddInt32("_sel", fSelEnd);
        if (err == B_OK)
                err = data->AddBool("_stylable", fStylable);
        if (err == B_OK)
                err = data->AddBool("_auto_in", fAutoindent);
        if (err == B_OK)
                err = data->AddBool("_wrap", fWrap);
        if (err == B_OK)
                err = data->AddBool("_nsel", !fSelectable);
        if (err == B_OK)
                err = data->AddBool("_nedit", !fEditable);
        if (err == B_OK)
                err = data->AddBool("_password", IsTypingHidden());

        if (err == B_OK && fDisallowedChars != NULL && fDisallowedChars->CountItems() > 0) {
                err = data->AddData("_dis_ch", B_RAW_TYPE, fDisallowedChars->Items(),
                        fDisallowedChars->CountItems() * sizeof(int32));
        }

        if (err == B_OK) {
                int32 runSize = 0;
                text_run_array* runArray = RunArray(0, fText->Length());

                void* flattened = FlattenRunArray(runArray, &runSize);
                if (flattened != NULL) {
                        data->AddData("_runs", B_RAW_TYPE, flattened, runSize);
                        free(flattened);
                } else
                        err = B_NO_MEMORY;

                FreeRunArray(runArray);
        }

        return err;
}


void
BTextView::AttachedToWindow()
{
        BView::AttachedToWindow();

        SetDrawingMode(B_OP_COPY);

        Window()->SetPulseRate(500000);

        fCaretVisible = false;
        fCaretTime = 0;
        fClickCount = 0;
        fClickTime = 0;
        fDragOffset = -1;
        fActive = false;

        _ValidateTextRect();

        _AutoResize(true);

        _UpdateScrollbars();

        SetViewCursor(B_CURSOR_SYSTEM_DEFAULT);
}


void
BTextView::DetachedFromWindow()
{
        BView::DetachedFromWindow();
}


void
BTextView::Draw(BRect updateRect)
{
        // what lines need to be drawn?
        int32 startLine = _LineAt(BPoint(0.0, updateRect.top));
        int32 endLine = _LineAt(BPoint(0.0, updateRect.bottom));

        _DrawLines(startLine, endLine, -1, true);
}


void
BTextView::MouseDown(BPoint where)
{
        // should we even bother?
        if (!fEditable && !fSelectable)
                return;

        _CancelInputMethod();

        if (!IsFocus())
                MakeFocus();

        _HideCaret();

        _StopMouseTracking();

        int32 modifiers = 0;
        uint32 buttons = 0;
        BMessage* currentMessage = Window()->CurrentMessage();
        if (currentMessage != NULL) {
                currentMessage->FindInt32("modifiers", &modifiers);
                currentMessage->FindInt32("buttons", (int32*)&buttons);
        }

        if (buttons == B_SECONDARY_MOUSE_BUTTON) {
                _ShowContextMenu(where);
                return;
        }

        BMessenger messenger(this);
        fTrackingMouse = new (nothrow) TextTrackState(messenger);
        if (fTrackingMouse == NULL)
                return;

        fTrackingMouse->clickOffset = OffsetAt(where);
        fTrackingMouse->shiftDown = modifiers & B_SHIFT_KEY;
        fTrackingMouse->where = where;

        bigtime_t clickTime = system_time();
        bigtime_t clickSpeed = 0;
        get_click_speed(&clickSpeed);
        bool multipleClick
                = clickTime - fClickTime < clickSpeed
                        && fLastClickOffset == fTrackingMouse->clickOffset;

        fWhere = where;

        SetMouseEventMask(B_POINTER_EVENTS | B_KEYBOARD_EVENTS,
                B_LOCK_WINDOW_FOCUS | B_NO_POINTER_HISTORY);

        if (fSelStart != fSelEnd && !fTrackingMouse->shiftDown && !multipleClick) {
                BRegion region;
                GetTextRegion(fSelStart, fSelEnd, &region);
                if (region.Contains(where)) {
                        // Setup things for dragging
                        fTrackingMouse->selectionRect = region.Frame();
                        fClickCount = 1;
                        fClickTime = clickTime;
                        fLastClickOffset = OffsetAt(where);
                        return;
                }
        }

        if (multipleClick) {
                if (fClickCount > 3) {
                        fClickCount = 0;
                        fClickTime = 0;
                } else {
                        fClickCount++;
                        fClickTime = clickTime;
                }
        } else if (!fTrackingMouse->shiftDown) {
                // If no multiple click yet and shift is not pressed, this is an
                // independent first click somewhere into the textview - we initialize
                // the corresponding members for handling potential multiple clicks:
                fLastClickOffset = fCaretOffset = fTrackingMouse->clickOffset;
                fClickCount = 1;
                fClickTime = clickTime;

                // Deselect any previously selected text
                Select(fTrackingMouse->clickOffset, fTrackingMouse->clickOffset);
        }

        if (fClickTime == clickTime) {
                BMessage message(_PING_);
                message.AddInt64("clickTime", clickTime);
                delete fClickRunner;

                BMessenger messenger(this);
                fClickRunner = new (nothrow) BMessageRunner(messenger, &message,
                        clickSpeed, 1);
        }

        if (!fSelectable) {
                _StopMouseTracking();
                return;
        }

        int32 offset = fSelStart;
        if (fTrackingMouse->clickOffset > fSelStart)
                offset = fSelEnd;

        fTrackingMouse->anchor = offset;

        MouseMoved(where, B_INSIDE_VIEW, NULL);
}


void
BTextView::MouseUp(BPoint where)
{
        BView::MouseUp(where);
        _PerformMouseUp(where);

        delete fDragRunner;
        fDragRunner = NULL;
}


void
BTextView::MouseMoved(BPoint where, uint32 code, const BMessage* dragMessage)
{
        // check if it's a "click'n'move"
        if (_PerformMouseMoved(where, code))
                return;

        switch (code) {
                case B_ENTERED_VIEW:
                case B_INSIDE_VIEW:
                        _TrackMouse(where, dragMessage, true);
                        break;

                case B_EXITED_VIEW:
                        _DragCaret(-1);
                        if (Window()->IsActive() && dragMessage == NULL)
                                SetViewCursor(B_CURSOR_SYSTEM_DEFAULT);
                        break;

                default:
                        BView::MouseMoved(where, code, dragMessage);
        }
}


void
BTextView::WindowActivated(bool active)
{
        BView::WindowActivated(active);

        if (active && IsFocus()) {
                if (!fActive)
                        _Activate();
        } else {
                if (fActive)
                        _Deactivate();
        }

        BPoint where;
        uint32 buttons;
        GetMouse(&where, &buttons, false);

        if (Bounds().Contains(where))
                _TrackMouse(where, NULL);
}


void
BTextView::KeyDown(const char* bytes, int32 numBytes)
{
        const char keyPressed = bytes[0];

        if (!fEditable) {
                // only arrow and page keys are allowed
                // (no need to hide the cursor)
                switch (keyPressed) {
                        case B_LEFT_ARROW:
                        case B_RIGHT_ARROW:
                        case B_UP_ARROW:
                        case B_DOWN_ARROW:
                                _HandleArrowKey(keyPressed);
                                break;

                        case B_HOME:
                        case B_END:
                        case B_PAGE_UP:
                        case B_PAGE_DOWN:
                                _HandlePageKey(keyPressed);
                                break;

                        default:
                                BView::KeyDown(bytes, numBytes);
                                break;
                }

                return;
        }

        // hide the cursor and caret
        if (IsFocus())
                be_app->ObscureCursor();
        _HideCaret();

        switch (keyPressed) {
                case B_BACKSPACE:
                        _HandleBackspace();
                        break;

                case B_LEFT_ARROW:
                case B_RIGHT_ARROW:
                case B_UP_ARROW:
                case B_DOWN_ARROW:
                        _HandleArrowKey(keyPressed);
                        break;

                case B_DELETE:
                        _HandleDelete();
                        break;

                case B_HOME:
                case B_END:
                case B_PAGE_UP:
                case B_PAGE_DOWN:
                        _HandlePageKey(keyPressed);
                        break;

                case B_ESCAPE:
                case B_INSERT:
                case B_FUNCTION_KEY:
                        // ignore, pass it up to superclass
                        BView::KeyDown(bytes, numBytes);
                        break;

                default:
                        // bail out if the character is not allowed
                        if (fDisallowedChars
                                && fDisallowedChars->HasItem(
                                        reinterpret_cast<void*>((uint32)keyPressed))) {
                                beep();
                                return;
                        }

                        _HandleAlphaKey(bytes, numBytes);
                        break;
        }

        // draw the caret
        if (fSelStart == fSelEnd)
                _ShowCaret();
}


void
BTextView::Pulse()
{
        if (fActive && (fEditable || fSelectable) && fSelStart == fSelEnd) {
                if (system_time() > (fCaretTime + 500000.0))
                        _InvertCaret();
        }
}


void
BTextView::FrameResized(float newWidth, float newHeight)
{
        BView::FrameResized(newWidth, newHeight);

        // frame resized in _AutoResize() instead
        if (fResizable)
                return;

        if (fWrap) {
                // recalculate line breaks
                // will update scroll bars if text rect changes
                _ResetTextRect();
        } else {
                // don't recalculate line breaks,
                // move text rect into position and redraw.

                float dataWidth = _TextWidth();
                newWidth = std::max(dataWidth, newWidth);

                // align rect
                BRect rect(fLayoutData->leftInset, fLayoutData->topInset,
                        newWidth - fLayoutData->rightInset,
                        newHeight - fLayoutData->bottomInset);

                rect = BLayoutUtils::AlignOnRect(rect,
                        BSize(fTextRect.Width(), fTextRect.Height()),
                        BAlignment(fAlignment, B_ALIGN_TOP));
                fTextRect.OffsetTo(rect.left, rect.top);

                // must invalidate whole thing because of highlighting
                Invalidate();
                _UpdateScrollbars();
        }
}


void
BTextView::MakeFocus(bool focus)
{
        BView::MakeFocus(focus);

        if (focus && Window() != NULL && Window()->IsActive()) {
                if (!fActive)
                        _Activate();
        } else {
                if (fActive)
                        _Deactivate();
        }
}


void
BTextView::MessageReceived(BMessage* message)
{
        // ToDo: block input if not editable (Andrew)

        // was this message dropped?
        if (message->WasDropped()) {
                BPoint dropOffset;
                BPoint dropPoint = message->DropPoint(&dropOffset);
                ConvertFromScreen(&dropPoint);
                ConvertFromScreen(&dropOffset);
                if (!_MessageDropped(message, dropPoint, dropOffset))
                        BView::MessageReceived(message);

                return;
        }

        switch (message->what) {
                case B_CUT:
                        if (!IsTypingHidden())
                                Cut(be_clipboard);
                        else
                                beep();
                        break;

                case B_COPY:
                        if (!IsTypingHidden())
                                Copy(be_clipboard);
                        else
                                beep();
                        break;

                case B_PASTE:
                        Paste(be_clipboard);
                        break;

                case B_UNDO:
                        Undo(be_clipboard);
                        break;

                case B_SELECT_ALL:
                        SelectAll();
                        break;

                case B_INPUT_METHOD_EVENT:
                {
                        int32 opcode;
                        if (message->FindInt32("be:opcode", &opcode) == B_OK) {
                                switch (opcode) {
                                        case B_INPUT_METHOD_STARTED:
                                        {
                                                BMessenger messenger;
                                                if (message->FindMessenger("be:reply_to", &messenger)
                                                                == B_OK) {
                                                        ASSERT(fInline == NULL);
                                                        fInline = new InlineInput(messenger);
                                                }
                                                break;
                                        }

                                        case B_INPUT_METHOD_STOPPED:
                                                delete fInline;
                                                fInline = NULL;
                                                break;

                                        case B_INPUT_METHOD_CHANGED:
                                                if (fInline != NULL)
                                                        _HandleInputMethodChanged(message);
                                                break;

                                        case B_INPUT_METHOD_LOCATION_REQUEST:
                                                if (fInline != NULL)
                                                        _HandleInputMethodLocationRequest();
                                                break;

                                        default:
                                                break;
                                }
                        }
                        break;
                }

                case B_SET_PROPERTY:
                case B_GET_PROPERTY:
                case B_COUNT_PROPERTIES:
                {
                        BPropertyInfo propInfo(sPropertyList);
                        BMessage specifier;
                        const char* property;

                        if (message->GetCurrentSpecifier(NULL, &specifier) < B_OK
                                || specifier.FindString("property", &property) < B_OK) {
                                BView::MessageReceived(message);
                                return;
                        }

                        if (propInfo.FindMatch(message, 0, &specifier, specifier.what,
                                        property) < B_OK) {
                                BView::MessageReceived(message);
                                break;
                        }

                        BMessage reply;
                        bool handled = false;
                        switch(message->what) {
                                case B_GET_PROPERTY:
                                        handled = _GetProperty(message, &specifier, property,
                                                &reply);
                                        break;

                                case B_SET_PROPERTY:
                                        handled = _SetProperty(message, &specifier, property,
                                                &reply);
                                        break;

                                case B_COUNT_PROPERTIES:
                                        handled = _CountProperties(message, &specifier,
                                                property, &reply);
                                        break;

                                default:
                                        break;
                        }
                        if (handled)
                                message->SendReply(&reply);
                        else
                                BView::MessageReceived(message);
                        break;
                }

                case _PING_:
                {
                        if (message->HasInt64("clickTime")) {
                                bigtime_t clickTime;
                                message->FindInt64("clickTime", &clickTime);
                                if (clickTime == fClickTime) {
                                        if (fSelStart != fSelEnd && fSelectable) {
                                                BRegion region;
                                                GetTextRegion(fSelStart, fSelEnd, &region);
                                                if (region.Contains(fWhere))
                                                        _TrackMouse(fWhere, NULL);
                                        }
                                        delete fClickRunner;
                                        fClickRunner = NULL;
                                }
                        } else if (fTrackingMouse) {
                                fTrackingMouse->SimulateMouseMovement(this);
                                _PerformAutoScrolling();
                        }
                        break;
                }

                case _DISPOSE_DRAG_:
                        if (fEditable)
                                _TrackDrag(fWhere);
                        break;

                case kMsgNavigateArrow:
                {
                        int32 key = message->GetInt32("key", 0);
                        int32 modifiers = message->GetInt32("modifiers", 0);
                        _HandleArrowKey(key, modifiers);
                        break;
                }

                case kMsgNavigatePage:
                {
                        int32 key = message->GetInt32("key", 0);
                        int32 modifiers = message->GetInt32("modifiers", 0);
                        _HandlePageKey(key, modifiers);
                        break;
                }

                case kMsgRemoveWord:
                {
                        int32 key = message->GetInt32("key", 0);
                        int32 modifiers = message->GetInt32("modifiers", 0);
                        if (key == B_DELETE)
                                _HandleDelete(modifiers);
                        else if (key == B_BACKSPACE)
                                _HandleBackspace(modifiers);
                        break;
                }

                default:
                        BView::MessageReceived(message);
                        break;
        }
}


BHandler*
BTextView::ResolveSpecifier(BMessage* message, int32 index, BMessage* specifier,
        int32 what, const char* property)
{
        BPropertyInfo propInfo(sPropertyList);
        BHandler* target = this;

        if (propInfo.FindMatch(message, index, specifier, what, property) < B_OK) {
                target = BView::ResolveSpecifier(message, index, specifier, what,
                        property);
        }

        return target;
}


status_t
BTextView::GetSupportedSuites(BMessage* data)
{
        if (data == NULL)
                return B_BAD_VALUE;

        status_t err = data->AddString("suites", "suite/vnd.Be-text-view");
        if (err != B_OK)
                return err;

        BPropertyInfo prop_info(sPropertyList);
        err = data->AddFlat("messages", &prop_info);

        if (err != B_OK)
                return err;
        return BView::GetSupportedSuites(data);
}


status_t
BTextView::Perform(perform_code code, void* _data)
{
        switch (code) {
                case PERFORM_CODE_MIN_SIZE:
                        ((perform_data_min_size*)_data)->return_value
                                = BTextView::MinSize();
                        return B_OK;
                case PERFORM_CODE_MAX_SIZE:
                        ((perform_data_max_size*)_data)->return_value
                                = BTextView::MaxSize();
                        return B_OK;
                case PERFORM_CODE_PREFERRED_SIZE:
                        ((perform_data_preferred_size*)_data)->return_value
                                = BTextView::PreferredSize();
                        return B_OK;
                case PERFORM_CODE_LAYOUT_ALIGNMENT:
                        ((perform_data_layout_alignment*)_data)->return_value
                                = BTextView::LayoutAlignment();
                        return B_OK;
                case PERFORM_CODE_HAS_HEIGHT_FOR_WIDTH:
                        ((perform_data_has_height_for_width*)_data)->return_value
                                = BTextView::HasHeightForWidth();
                        return B_OK;
                case PERFORM_CODE_GET_HEIGHT_FOR_WIDTH:
                {
                        perform_data_get_height_for_width* data
                                = (perform_data_get_height_for_width*)_data;
                        BTextView::GetHeightForWidth(data->width, &data->min, &data->max,
                                &data->preferred);
                        return B_OK;
                }
                case PERFORM_CODE_SET_LAYOUT:
                {
                        perform_data_set_layout* data = (perform_data_set_layout*)_data;
                        BTextView::SetLayout(data->layout);
                        return B_OK;
                }
                case PERFORM_CODE_LAYOUT_INVALIDATED:
                {
                        perform_data_layout_invalidated* data
                                = (perform_data_layout_invalidated*)_data;
                        BTextView::LayoutInvalidated(data->descendants);
                        return B_OK;
                }
                case PERFORM_CODE_DO_LAYOUT:
                {
                        BTextView::DoLayout();
                        return B_OK;
                }
        }

        return BView::Perform(code, _data);
}


void
BTextView::SetText(const char* text, const text_run_array* runs)
{
        SetText(text, text ? strlen(text) : 0, runs);
}


void
BTextView::SetText(const char* text, int32 length, const text_run_array* runs)
{
        _CancelInputMethod();

        // hide the caret/unhighlight the selection
        if (fActive) {
                if (fSelStart != fSelEnd) {
                        if (fSelectable)
                                Highlight(fSelStart, fSelEnd);
                } else
                        _HideCaret();
        }

        // remove data from buffer
        if (fText->Length() > 0)
                DeleteText(0, fText->Length());

        if (text != NULL && length > 0)
                InsertText(text, length, 0, runs);

        // bounds are invalid, set them based on text
        if (!Bounds().IsValid()) {
                ResizeTo(LineWidth(0) - 1, LineHeight(0));
                fTextRect = Bounds();
                _ValidateTextRect();
                _UpdateInsets(fTextRect);
        }

        // recalculate line breaks and draw the text
        _Refresh(0, length);
        fCaretOffset = fSelStart = fSelEnd = 0;

        // draw the caret
        _ShowCaret();
}


void
BTextView::SetText(BFile* file, int32 offset, int32 length,
        const text_run_array* runs)
{
        CALLED();

        _CancelInputMethod();

        if (file == NULL)
                return;

        if (fText->Length() > 0)
                DeleteText(0, fText->Length());

        if (!fText->InsertText(file, offset, length, 0))
                return;

        // update the start offsets of each line below offset
        fLines->BumpOffset(length, _LineAt(offset) + 1);

        // update the style runs
        fStyles->BumpOffset(length, fStyles->OffsetToRun(offset - 1) + 1);

        if (fStylable && runs != NULL)
                SetRunArray(offset, offset + length, runs);
        else {
                // apply null-style to inserted text
                _ApplyStyleRange(offset, offset + length);
        }

        // recalculate line breaks and draw the text
        _Refresh(0, length);
        fCaretOffset = fSelStart = fSelEnd = 0;
        ScrollToOffset(fSelStart);

        // draw the caret
        _ShowCaret();
}


void
BTextView::Insert(const char* text, const text_run_array* runs)
{
        if (text != NULL)
                _DoInsertText(text, strlen(text), fSelStart, runs);
}


void
BTextView::Insert(const char* text, int32 length, const text_run_array* runs)
{
        if (text != NULL && length > 0)
                _DoInsertText(text, strnlen(text, length), fSelStart, runs);
}


void
BTextView::Insert(int32 offset, const char* text, int32 length,
        const text_run_array* runs)
{
        // pin offset at reasonable values
        if (offset < 0)
                offset = 0;
        else if (offset > fText->Length())
                offset = fText->Length();

        if (text != NULL && length > 0)
                _DoInsertText(text, strnlen(text, length), offset, runs);
}


void
BTextView::Delete()
{
        Delete(fSelStart, fSelEnd);
}


void
BTextView::Delete(int32 startOffset, int32 endOffset)
{
        CALLED();

        // pin offsets at reasonable values
        if (startOffset < 0)
                startOffset = 0;
        else if (startOffset > fText->Length())
                startOffset = fText->Length();

        if (endOffset < 0)
                endOffset = 0;
        else if (endOffset > fText->Length())
                endOffset = fText->Length();

        // anything to delete?
        if (startOffset == endOffset)
                return;

        // hide the caret/unhighlight the selection
        if (fActive) {
                if (fSelStart != fSelEnd) {
                        if (fSelectable)
                                Highlight(fSelStart, fSelEnd);
                } else
                        _HideCaret();
        }
        // remove data from buffer
        DeleteText(startOffset, endOffset);

        // check if the caret needs to be moved
        if (fCaretOffset >= endOffset)
                fCaretOffset -= (endOffset - startOffset);
        else if (fCaretOffset >= startOffset && fCaretOffset < endOffset)
                fCaretOffset = startOffset;

        fSelEnd = fSelStart = fCaretOffset;

        // recalculate line breaks and draw what's left
        _Refresh(startOffset, endOffset, fCaretOffset);

        // draw the caret
        _ShowCaret();
}


const char*
BTextView::Text() const
{
        return fText->RealText();
}


int32
BTextView::TextLength() const
{
        return fText->Length();
}


void
BTextView::GetText(int32 offset, int32 length, char* buffer) const
{
        if (buffer != NULL)
                fText->GetString(offset, length, buffer);
}


uchar
BTextView::ByteAt(int32 offset) const
{
        if (offset < 0 || offset >= fText->Length())
                return '\0';

        return fText->RealCharAt(offset);
}


int32
BTextView::CountLines() const
{
        return fLines->NumLines();
}


int32
BTextView::CurrentLine() const
{
        return LineAt(fSelStart);
}


void
BTextView::GoToLine(int32 index)
{
        _CancelInputMethod();
        _HideCaret();
        fSelStart = fSelEnd = fCaretOffset = OffsetAt(index);
        _ShowCaret();
}


void
BTextView::Cut(BClipboard* clipboard)
{
        _CancelInputMethod();
        if (!fEditable)
                return;
        if (fUndo) {
                delete fUndo;
                fUndo = new CutUndoBuffer(this);
        }
        Copy(clipboard);
        Delete();
}


void
BTextView::Copy(BClipboard* clipboard)
{
        _CancelInputMethod();

        if (clipboard->Lock()) {
                clipboard->Clear();

                BMessage* clip = clipboard->Data();
                if (clip != NULL) {
                        int32 numBytes = fSelEnd - fSelStart;
                        const char* text = fText->GetString(fSelStart, &numBytes);
                        clip->AddData("text/plain", B_MIME_TYPE, text, numBytes);

                        int32 size;
                        if (fStylable) {
                                text_run_array* runArray = RunArray(fSelStart, fSelEnd, &size);
                                clip->AddData("application/x-vnd.Be-text_run_array",
                                        B_MIME_TYPE, runArray, size);
                                FreeRunArray(runArray);
                        }
                        clipboard->Commit();
                }
                clipboard->Unlock();
        }
}


void
BTextView::Paste(BClipboard* clipboard)
{
        CALLED();
        _CancelInputMethod();

        if (!fEditable || !clipboard->Lock())
                return;

        BMessage* clip = clipboard->Data();
        if (clip != NULL) {
                const char* text = NULL;
                ssize_t length = 0;

                if (clip->FindData("text/plain", B_MIME_TYPE,
                                (const void**)&text, &length) == B_OK) {
                        text_run_array* runArray = NULL;
                        ssize_t runLength = 0;

                        if (fStylable) {
                                clip->FindData("application/x-vnd.Be-text_run_array",
                                        B_MIME_TYPE, (const void**)&runArray, &runLength);
                        }

                        _FilterDisallowedChars((char*)text, length, runArray);

                        if (length < 1) {
                                beep();
                                clipboard->Unlock();
                                return;
                        }

                        if (fUndo) {
                                delete fUndo;
                                fUndo = new PasteUndoBuffer(this, text, length, runArray,
                                        runLength);
                        }

                        if (fSelStart != fSelEnd)
                                Delete();

                        Insert(text, length, runArray);
                        ScrollToOffset(fSelEnd);
                }
        }

        clipboard->Unlock();
}


void
BTextView::Clear()
{
        // We always check for fUndo != NULL (not only here),
        // because when fUndo is NULL, undo is deactivated.
        if (fUndo) {
                delete fUndo;
                fUndo = new ClearUndoBuffer(this);
        }

        Delete();
}


bool
BTextView::AcceptsPaste(BClipboard* clipboard)
{
        bool result = false;

        if (fEditable && clipboard && clipboard->Lock()) {
                BMessage* data = clipboard->Data();
                result = data && data->HasData("text/plain", B_MIME_TYPE);
                clipboard->Unlock();
        }

        return result;
}


bool
BTextView::AcceptsDrop(const BMessage* message)
{
        return fEditable && message
                && message->HasData("text/plain", B_MIME_TYPE);
}


void
BTextView::Select(int32 startOffset, int32 endOffset)
{
        CALLED();
        if (!fSelectable)
                return;

        _CancelInputMethod();

        // pin offsets at reasonable values
        if (startOffset < 0)
                startOffset = 0;
        else if (startOffset > fText->Length())
                startOffset = fText->Length();
        if (endOffset < 0)
                endOffset = 0;
        else if (endOffset > fText->Length())
                endOffset = fText->Length();

        // a negative selection?
        if (startOffset > endOffset)
                return;

        // is the new selection any different from the current selection?
        if (startOffset == fSelStart && endOffset == fSelEnd)
                return;

        fStyles->InvalidateNullStyle();

        _HideCaret();

        if (startOffset == endOffset) {
                if (fSelStart != fSelEnd) {
                        // unhilite the selection
                        if (fActive)
                                Highlight(fSelStart, fSelEnd);
                }
                fSelStart = fSelEnd = fCaretOffset = startOffset;
                _ShowCaret();
        } else {
                if (fActive) {
                        // draw only those ranges that are different
                        long start, end;
                        if (startOffset != fSelStart) {
                                // start of selection has changed
                                if (startOffset > fSelStart) {
                                        start = fSelStart;
                                        end = startOffset;
                                } else {
                                        start = startOffset;
                                        end = fSelStart;
                                }
                                Highlight(start, end);
                        }

                        if (endOffset != fSelEnd) {
                                // end of selection has changed
                                if (endOffset > fSelEnd) {
                                        start = fSelEnd;
                                        end = endOffset;
                                } else {
                                        start = endOffset;
                                        end = fSelEnd;
                                }
                                Highlight(start, end);
                        }
                }
                fSelStart = startOffset;
                fSelEnd = endOffset;
        }
}


void
BTextView::SelectAll()
{
        // Place the cursor at the end of the selection.
        fCaretOffset = fText->Length();
        Select(0, fCaretOffset);
}


void
BTextView::GetSelection(int32* _start, int32* _end) const
{
        int32 start = 0;
        int32 end = 0;

        if (fSelectable) {
                start = fSelStart;
                end = fSelEnd;
        }

        if (_start)
                *_start = start;

        if (_end)
                *_end = end;
}


void
BTextView::AdoptSystemColors()
{
        if (IsEditable())
                SetViewUIColor(B_DOCUMENT_BACKGROUND_COLOR);
        else
                SetViewUIColor(B_DOCUMENT_BACKGROUND_COLOR, _UneditableTint());

        SetLowUIColor(ViewUIColor());
        SetHighUIColor(B_DOCUMENT_TEXT_COLOR);
}


bool
BTextView::HasSystemColors() const
{
        float tint = B_NO_TINT;
        float uneditableTint = _UneditableTint();

        return ViewUIColor(&tint) == B_DOCUMENT_BACKGROUND_COLOR
                && (tint == B_NO_TINT || tint == uneditableTint)
                && LowUIColor(&tint) == B_DOCUMENT_BACKGROUND_COLOR
                && (tint == B_NO_TINT || tint == uneditableTint)
                && HighUIColor(&tint) == B_DOCUMENT_TEXT_COLOR && tint == B_NO_TINT;
}


void
BTextView::SetFontAndColor(const BFont* font, uint32 mode, const rgb_color* color)
{
        SetFontAndColor(fSelStart, fSelEnd, font, mode, color);
}


void
BTextView::SetFontAndColor(int32 startOffset, int32 endOffset,
        const BFont* font, uint32 mode, const rgb_color* color)
{
        CALLED();

        _HideCaret();

        const int32 textLength = fText->Length();

        if (!fStylable) {
                // When the text view is not stylable, we always set the whole text's
                // style and ignore the offsets
                startOffset = 0;
                endOffset = textLength;
        } else {
                // pin offsets at reasonable values
                if (startOffset < 0)
                        startOffset = 0;
                else if (startOffset > textLength)
                        startOffset = textLength;

                if (endOffset < 0)
                        endOffset = 0;
                else if (endOffset > textLength)
                        endOffset = textLength;
        }

        // apply the style to the style buffer
        fStyles->InvalidateNullStyle();
        _ApplyStyleRange(startOffset, endOffset, mode, font, color);

        if ((mode & (B_FONT_FAMILY_AND_STYLE | B_FONT_SIZE)) != 0) {
                // ToDo: maybe only invalidate the layout (depending on
                // B_SUPPORTS_LAYOUT) and have it _Refresh() automatically?
                InvalidateLayout();
                // recalc the line breaks and redraw with new style
                _Refresh(startOffset, endOffset);
        } else {
                // the line breaks wont change, simply redraw
                _RequestDrawLines(_LineAt(startOffset), _LineAt(endOffset));
        }

        _ShowCaret();
}


void
BTextView::GetFontAndColor(int32 offset, BFont* _font,
        rgb_color* _color) const
{
        fStyles->GetStyle(offset, _font, _color);
}


void
BTextView::GetFontAndColor(BFont* _font, uint32* _mode,
        rgb_color* _color, bool* _sameColor) const
{
        fStyles->ContinuousGetStyle(_font, _mode, _color, _sameColor,
                fSelStart, fSelEnd);
}


void
BTextView::SetRunArray(int32 startOffset, int32 endOffset,
        const text_run_array* runs)
{
        CALLED();

        _CancelInputMethod();

        text_run_array oneRun;

        if (!fStylable) {
                // when the text view is not stylable, we always set the whole text's
                // style with the first run and ignore the offsets
                if (runs->count == 0)
                        return;

                startOffset = 0;
                endOffset = fText->Length();
                oneRun.count = 1;
                oneRun.runs[0] = runs->runs[0];
                oneRun.runs[0].offset = 0;
                runs = &oneRun;
        } else {
                // pin offsets at reasonable values
                if (startOffset < 0)
                        startOffset = 0;
                else if (startOffset > fText->Length())
                        startOffset = fText->Length();

                if (endOffset < 0)
                        endOffset = 0;
                else if (endOffset > fText->Length())
                        endOffset = fText->Length();
        }

        _SetRunArray(startOffset, endOffset, runs);

        _Refresh(startOffset, endOffset);
}


text_run_array*
BTextView::RunArray(int32 startOffset, int32 endOffset, int32* _size) const
{
        // pin offsets at reasonable values
        if (startOffset < 0)
                startOffset = 0;
        else if (startOffset > fText->Length())
                startOffset = fText->Length();

        if (endOffset < 0)
                endOffset = 0;
        else if (endOffset > fText->Length())
                endOffset = fText->Length();

        STEStyleRange* styleRange
                = fStyles->GetStyleRange(startOffset, endOffset - 1);
        if (styleRange == NULL)
                return NULL;

        text_run_array* runArray = AllocRunArray(styleRange->count, _size);
        if (runArray != NULL) {
                for (int32 i = 0; i < runArray->count; i++) {
                        runArray->runs[i].offset = styleRange->runs[i].offset;
                        runArray->runs[i].font = styleRange->runs[i].style.font;
                        runArray->runs[i].color = styleRange->runs[i].style.color;
                }
        }

        free(styleRange);

        return runArray;
}


int32
BTextView::LineAt(int32 offset) const
{
        // pin offset at reasonable values
        if (offset < 0)
                offset = 0;
        else if (offset > fText->Length())
                offset = fText->Length();

        int32 lineNum = _LineAt(offset);
        if (_IsOnEmptyLastLine(offset))
                lineNum++;
        return lineNum;
}


int32
BTextView::LineAt(BPoint point) const
{
        int32 lineNum = _LineAt(point);
        if ((*fLines)[lineNum + 1]->origin <= point.y - fTextRect.top)
                lineNum++;

        return lineNum;
}


BPoint
BTextView::PointAt(int32 offset, float* _height) const
{
        // pin offset at reasonable values
        if (offset < 0)
                offset = 0;
        else if (offset > fText->Length())
                offset = fText->Length();

        // ToDo: Cleanup.
        int32 lineNum = _LineAt(offset);
        STELine* line = (*fLines)[lineNum];
        float height = 0;

        BPoint result;
        result.x = 0.0;
        result.y = line->origin + fTextRect.top;

        bool onEmptyLastLine = _IsOnEmptyLastLine(offset);

        if (fStyles->NumRuns() == 0) {
                // Handle the case where there is only one line (no text inserted)
                fStyles->SyncNullStyle(0);
                height = _NullStyleHeight();
        } else {
                height = (line + 1)->origin - line->origin;

                if (onEmptyLastLine) {
                        // special case: go down one line if offset is at the newline
                        // at the end of the buffer ...
                        result.y += height;
                        // ... and return the height of that (empty) line
                        fStyles->SyncNullStyle(offset);
                        height = _NullStyleHeight();
                } else {
                        int32 length = offset - line->offset;
                        result.x += _TabExpandedStyledWidth(line->offset, length);
                }
        }

        if (fAlignment != B_ALIGN_LEFT) {
                float lineWidth = onEmptyLastLine ? 0.0 : LineWidth(lineNum);
                float alignmentOffset = fTextRect.Width() + 1 - lineWidth;
                if (fAlignment == B_ALIGN_CENTER)
                        alignmentOffset = floorf(alignmentOffset / 2);
                result.x += alignmentOffset;
        }

        // convert from text rect coordinates
        result.x += fTextRect.left;

        // round up
        result.x = lroundf(result.x);
        result.y = lroundf(result.y);
        if (_height != NULL)
                *_height = height;

        return result;
}


int32
BTextView::OffsetAt(BPoint point) const
{
        const int32 textLength = fText->Length();

        // should we even bother?
        if (point.y >= fTextRect.bottom)
                return textLength;
        else if (point.y < fTextRect.top)
                return 0;

        int32 lineNum = _LineAt(point);
        STELine* line = (*fLines)[lineNum];

#define COMPILE_PROBABLY_BAD_CODE 1

#if COMPILE_PROBABLY_BAD_CODE
        // special case: if point is within the text rect and PixelToLine()
        // tells us that it's on the last line, but if point is actually
        // lower than the bottom of the last line, return the last offset
        // (can happen for newlines)
        if (lineNum == (fLines->NumLines() - 1)) {
                if (point.y >= ((line + 1)->origin + fTextRect.top))
                        return textLength;
        }
#endif

        // convert to text rect coordinates
        if (fAlignment != B_ALIGN_LEFT) {
                float alignmentOffset = fTextRect.Width() + 1 - LineWidth(lineNum);
                if (fAlignment == B_ALIGN_CENTER)
                        alignmentOffset = floorf(alignmentOffset / 2);
                point.x -= alignmentOffset;
        }

        point.x -= fTextRect.left;
        point.x = std::max(point.x, 0.0f);

        // ToDo: The following code isn't very efficient, because it always starts
        // from the left end, so when the point is near the right end it's very
        // slow.
        int32 offset = line->offset;
        const int32 limit = (line + 1)->offset;
        float location = 0;
        do {
                const int32 nextInitial = _NextInitialByte(offset);
                const int32 saveOffset = offset;
                float width = 0;
                if (ByteAt(offset) == B_TAB)
                        width = _ActualTabWidth(location);
                else
                        width = _StyledWidth(saveOffset, nextInitial - saveOffset);
                if (location + width > point.x) {
                        if (fabs(location + width - point.x) < fabs(location - point.x))
                                offset = nextInitial;
                        break;
                }

                location += width;
                offset = nextInitial;
        } while (offset < limit);

        if (offset == (line + 1)->offset) {
                // special case: newlines aren't visible
                // return the offset of the character preceding the newline
                if (ByteAt(offset - 1) == B_ENTER)
                        return --offset;

                // special case: return the offset preceding any spaces that
                // aren't at the end of the buffer
                if (offset != textLength && ByteAt(offset - 1) == B_SPACE)
                        return --offset;
        }

        return offset;
}


int32
BTextView::OffsetAt(int32 line) const
{
        if (line < 0)
                return 0;

        if (line > fLines->NumLines())
                return fText->Length();

        return (*fLines)[line]->offset;
}


void
BTextView::FindWord(int32 offset, int32* _fromOffset, int32* _toOffset)
{
        if (offset < 0) {
                if (_fromOffset)
                        *_fromOffset = 0;

                if (_toOffset)
                        *_toOffset = 0;

                return;
        }

        if (offset > fText->Length()) {
                if (_fromOffset)
                        *_fromOffset = fText->Length();

                if (_toOffset)
                        *_toOffset = fText->Length();

                return;
        }

        if (_fromOffset)
                *_fromOffset = _PreviousWordBoundary(offset);

        if (_toOffset)
                *_toOffset = _NextWordBoundary(offset);
}


bool
BTextView::CanEndLine(int32 offset)
{
        if (offset < 0 || offset > fText->Length())
                return false;

        // TODO: This should be improved using the LocaleKit.
        uint32 classification = _CharClassification(offset);

        // wrapping is always allowed at end of text and at newlines
        if (classification == CHAR_CLASS_END_OF_TEXT || ByteAt(offset) == B_ENTER)
                return true;

        uint32 nextClassification = _CharClassification(offset + 1);
        if (nextClassification == CHAR_CLASS_END_OF_TEXT)
                return true;

        // never separate a punctuation char from its preceeding word
        if (classification == CHAR_CLASS_DEFAULT
                && nextClassification == CHAR_CLASS_PUNCTUATION) {
                return false;
        }

        if ((classification == CHAR_CLASS_WHITESPACE
                        && nextClassification != CHAR_CLASS_WHITESPACE)
                || (classification != CHAR_CLASS_WHITESPACE
                        && nextClassification == CHAR_CLASS_WHITESPACE)) {
                return true;
        }

        // allow wrapping after whitespace, unless more whitespace (except for
        // newline) follows
        if (classification == CHAR_CLASS_WHITESPACE
                && (nextClassification != CHAR_CLASS_WHITESPACE
                        || ByteAt(offset + 1) == B_ENTER)) {
                return true;
        }

        // allow wrapping after punctuation chars, unless more punctuation, closing
        // parens or quotes follow
        if (classification == CHAR_CLASS_PUNCTUATION
                && nextClassification != CHAR_CLASS_PUNCTUATION
                && nextClassification != CHAR_CLASS_PARENS_CLOSE
                && nextClassification != CHAR_CLASS_QUOTE) {
                return true;
        }

        // allow wrapping after quotes, graphical chars and closing parens only if
        // whitespace follows (not perfect, but seems to do the right thing most
        // of the time)
        if ((classification == CHAR_CLASS_QUOTE
                        || classification == CHAR_CLASS_GRAPHICAL
                        || classification == CHAR_CLASS_PARENS_CLOSE)
                && nextClassification == CHAR_CLASS_WHITESPACE) {
                return true;
        }

        return false;
}


float
BTextView::LineWidth(int32 lineNumber) const
{
        if (lineNumber < 0 || lineNumber >= fLines->NumLines())
                return 0;

        STELine* line = (*fLines)[lineNumber];
        int32 length = (line + 1)->offset - line->offset;

        // skip newline at the end of the line, if any, as it does no contribute
        // to the width
        if (ByteAt((line + 1)->offset - 1) == B_ENTER)
                length--;

        return _TabExpandedStyledWidth(line->offset, length);
}


float
BTextView::LineHeight(int32 lineNumber) const
{
        float lineHeight = TextHeight(lineNumber, lineNumber);
        if (lineHeight == 0.0) {
                // We probably don't have text content yet. Take the initial
                // style's font height or fall back to the plain font.
                const BFont* font;
                fStyles->GetNullStyle(&font, NULL);
                if (font == NULL)
                        font = be_plain_font;

                font_height fontHeight;
                font->GetHeight(&fontHeight);
                // This is how the height is calculated in _RecalculateLineBreaks().
                lineHeight = ceilf(fontHeight.ascent + fontHeight.descent) + 1;
        }

        return lineHeight;
}


float
BTextView::TextHeight(int32 startLine, int32 endLine) const
{
        const int32 numLines = fLines->NumLines();
        if (startLine < 0)
                startLine = 0;
        else if (startLine > numLines - 1)
                startLine = numLines - 1;

        if (endLine < 0)
                endLine = 0;
        else if (endLine > numLines - 1)
                endLine = numLines - 1;

        float height = (*fLines)[endLine + 1]->origin
                - (*fLines)[startLine]->origin;

        if (startLine != endLine && endLine == numLines - 1
                && fText->RealCharAt(fText->Length() - 1) == B_ENTER) {
                height += (*fLines)[endLine + 1]->origin - (*fLines)[endLine]->origin;
        }

        return ceilf(height);
}


void
BTextView::GetTextRegion(int32 startOffset, int32 endOffset,
        BRegion* outRegion) const
{
        if (!outRegion)
                return;

        outRegion->MakeEmpty();

        // pin offsets at reasonable values
        if (startOffset < 0)
                startOffset = 0;
        else if (startOffset > fText->Length())
                startOffset = fText->Length();
        if (endOffset < 0)
                endOffset = 0;
        else if (endOffset > fText->Length())
                endOffset = fText->Length();

        // return an empty region if the range is invalid
        if (startOffset >= endOffset)
                return;

        float startLineHeight = 0.0;
        float endLineHeight = 0.0;
        BPoint startPt = PointAt(startOffset, &startLineHeight);
        BPoint endPt = PointAt(endOffset, &endLineHeight);

        startLineHeight = ceilf(startLineHeight);
        endLineHeight = ceilf(endLineHeight);

        BRect selRect;
        const BRect bounds(Bounds());

        if (startPt.y == endPt.y) {
                // this is a one-line region
                selRect.left = startPt.x;
                selRect.top = startPt.y;
                selRect.right = endPt.x - 1;
                selRect.bottom = endPt.y + endLineHeight - 1;
                outRegion->Include(selRect);
        } else {
                // more than one line in the specified offset range

                // include first line from start of selection to end of window
                selRect.left = startPt.x;
                selRect.top = startPt.y;
                selRect.right = std::max(fTextRect.right,
                        bounds.right - fLayoutData->rightInset);
                selRect.bottom = startPt.y + startLineHeight - 1;
                outRegion->Include(selRect);

                if (startPt.y + startLineHeight < endPt.y) {
                        // more than two lines in the range
                        // include middle lines from start to end of window
                        selRect.left = std::min(fTextRect.left,
                                bounds.left + fLayoutData->leftInset);
                        selRect.top = startPt.y + startLineHeight;
                        selRect.right = std::max(fTextRect.right,
                                bounds.right - fLayoutData->rightInset);
                        selRect.bottom = endPt.y - 1;
                        outRegion->Include(selRect);
                }

                // include last line start of window to end of selection
                selRect.left = std::min(fTextRect.left,
                        bounds.left + fLayoutData->leftInset);
                selRect.top = endPt.y;
                selRect.right = endPt.x - 1;
                selRect.bottom = endPt.y + endLineHeight - 1;
                outRegion->Include(selRect);
        }
}


void
BTextView::ScrollToOffset(int32 offset)
{
        BRect bounds = Bounds();
        float lineHeight = 0.0;
        BPoint point = PointAt(offset, &lineHeight);
        BPoint scrollBy(B_ORIGIN);

        // horizontal
        if (point.x < bounds.left)
                scrollBy.x = point.x - bounds.right;
        else if (point.x > bounds.right)
                scrollBy.x = point.x - bounds.left;

        // prevent from scrolling out of view
        if (scrollBy.x != 0.0) {
                float rightMax = fTextRect.right + fLayoutData->rightInset;
                if (bounds.right + scrollBy.x > rightMax)
                        scrollBy.x = rightMax - bounds.right;
                float leftMin = fTextRect.left - fLayoutData->leftInset;
                if (bounds.left + scrollBy.x < leftMin)
                        scrollBy.x = leftMin - bounds.left;
        }

        // vertical
        if (CountLines() > 1) {
                // scroll in Y only if multiple lines!
                if (point.y < bounds.top - fLayoutData->topInset)
                        scrollBy.y = point.y - bounds.top - fLayoutData->topInset;
                else if (point.y + lineHeight > bounds.bottom
                                + fLayoutData->bottomInset) {
                        scrollBy.y = point.y + lineHeight - bounds.bottom
                                + fLayoutData->bottomInset;
                }
        }

        ScrollBy(scrollBy.x, scrollBy.y);

        // Update text rect position and scroll bars
        if (CountLines() > 1 && !fWrap)
                FrameResized(Bounds().Width(), Bounds().Height());
}


void
BTextView::ScrollToSelection()
{
        ScrollToOffset(fSelStart);
}


void
BTextView::Highlight(int32 startOffset, int32 endOffset)
{
        // pin offsets at reasonable values
        if (startOffset < 0)
                startOffset = 0;
        else if (startOffset > fText->Length())
                startOffset = fText->Length();
        if (endOffset < 0)
                endOffset = 0;
        else if (endOffset > fText->Length())
                endOffset = fText->Length();

        if (startOffset >= endOffset)
                return;

        BRegion selRegion;
        GetTextRegion(startOffset, endOffset, &selRegion);

        SetDrawingMode(B_OP_INVERT);
        FillRegion(&selRegion, B_SOLID_HIGH);
        SetDrawingMode(B_OP_COPY);
}


// #pragma mark - Configuration methods


void
BTextView::SetTextRect(BRect rect)
{
        if (rect == fTextRect)
                return;

        if (!fWrap) {
                rect.right = Bounds().right;
                rect.bottom = Bounds().bottom;
        }

        _UpdateInsets(rect);

        fTextRect = rect;

        _ResetTextRect();
}


BRect
BTextView::TextRect() const
{
        return fTextRect;
}


void
BTextView::_ResetTextRect()
{
        BRect oldTextRect(fTextRect);
        // reset text rect to bounds minus insets ...
        fTextRect = Bounds().OffsetToCopy(B_ORIGIN);
        fTextRect.left += fLayoutData->leftInset;
        fTextRect.top += fLayoutData->topInset;
        fTextRect.right -= fLayoutData->rightInset;
        fTextRect.bottom -= fLayoutData->bottomInset;

        // and rewrap (potentially adjusting the right and the bottom of the text
        // rect)
        _Refresh(0, fText->Length());

        // Make sure that the dirty area outside the text is redrawn too.
        BRegion invalid(oldTextRect | fTextRect);
        invalid.Exclude(fTextRect);
        Invalidate(&invalid);
}


void
BTextView::SetInsets(float left, float top, float right, float bottom)
{
        if (fLayoutData->leftInset == left
                && fLayoutData->topInset == top
                && fLayoutData->rightInset == right
                && fLayoutData->bottomInset == bottom)
                return;

        fLayoutData->leftInset = left;
        fLayoutData->topInset = top;
        fLayoutData->rightInset = right;
        fLayoutData->bottomInset = bottom;

        fLayoutData->overridden = true;

        InvalidateLayout();
        Invalidate();
}


void
BTextView::GetInsets(float* _left, float* _top, float* _right,
        float* _bottom) const
{
        if (_left)
                *_left = fLayoutData->leftInset;
        if (_top)
                *_top = fLayoutData->topInset;
        if (_right)
                *_right = fLayoutData->rightInset;
        if (_bottom)
                *_bottom = fLayoutData->bottomInset;
}


void
BTextView::SetStylable(bool stylable)
{
        fStylable = stylable;
}


bool
BTextView::IsStylable() const
{
        return fStylable;
}


void
BTextView::SetTabWidth(float width)
{
        if (width == fTabWidth)
                return;

        fTabWidth = width;

        if (Window() != NULL)
                _Refresh(0, fText->Length());
}


float
BTextView::TabWidth() const
{
        return fTabWidth;
}


void
BTextView::MakeSelectable(bool selectable)
{
        if (selectable == fSelectable)
                return;

        fSelectable = selectable;

        if (fActive && fSelStart != fSelEnd && Window() != NULL)
                Highlight(fSelStart, fSelEnd);
}


bool
BTextView::IsSelectable() const
{
        return fSelectable;
}


void
BTextView::MakeEditable(bool editable)
{
        if (editable == fEditable)
                return;

        fEditable = editable;

        // apply uneditable colors or unapply them
        if (HasSystemColors())
                AdoptSystemColors();

        // TextControls change the color of the text when
        // they are made editable, so we need to invalidate
        // the NULL style here
        // TODO: it works well, but it could be caused by a bug somewhere else
        if (fEditable)
                fStyles->InvalidateNullStyle();
        if (Window() != NULL && fActive) {
                if (!fEditable) {
                        if (!fSelectable)
                                _HideCaret();
                        _CancelInputMethod();
                }
        }
}


bool
BTextView::IsEditable() const
{
        return fEditable;
}


void
BTextView::SetWordWrap(bool wrap)
{
        if (wrap == fWrap)
                return;

        bool updateOnScreen = fActive && Window() != NULL;
        if (updateOnScreen) {
                // hide the caret, unhilite the selection
                if (fSelStart != fSelEnd) {
                        if (fSelectable)
                                Highlight(fSelStart, fSelEnd);
                } else
                        _HideCaret();
        }

        BRect savedBounds = Bounds();

        fWrap = wrap;
        if (wrap)
                _ResetTextRect(); // calls _Refresh
        else
                _Refresh(0, fText->Length());

        if (fEditable || fSelectable)
                ScrollToOffset(fCaretOffset);

        // redraw text rect and update scroll bars if bounds have changed
        if (Bounds() != savedBounds)
                FrameResized(Bounds().Width(), Bounds().Height());

        if (updateOnScreen) {
                // show the caret, hilite the selection
                if (fSelStart != fSelEnd) {
                        if (fSelectable)
                                Highlight(fSelStart, fSelEnd);
                } else
                        _ShowCaret();
        }
}


bool
BTextView::DoesWordWrap() const
{
        return fWrap;
}


void
BTextView::SetMaxBytes(int32 max)
{
        const int32 textLength = fText->Length();
        fMaxBytes = max;

        if (fMaxBytes < textLength) {
                int32 offset = fMaxBytes;
                // Delete the text after fMaxBytes, but
                // respect multibyte characters boundaries.
                const int32 previousInitial = _PreviousInitialByte(offset);
                if (_NextInitialByte(previousInitial) != offset)
                        offset = previousInitial;

                Delete(offset, textLength);
        }
}


int32
BTextView::MaxBytes() const
{
        return fMaxBytes;
}


void
BTextView::DisallowChar(uint32 character)
{
        if (fDisallowedChars == NULL)
                fDisallowedChars = new BList;
        if (!fDisallowedChars->HasItem(reinterpret_cast<void*>(character)))
                fDisallowedChars->AddItem(reinterpret_cast<void*>(character));
}


void
BTextView::AllowChar(uint32 character)
{
        if (fDisallowedChars != NULL)
                fDisallowedChars->RemoveItem(reinterpret_cast<void*>(character));
}


void
BTextView::SetAlignment(alignment align)
{
        // Do a reality check
        if (fAlignment != align &&
                        (align == B_ALIGN_LEFT ||
                         align == B_ALIGN_RIGHT ||
                         align == B_ALIGN_CENTER)) {
                fAlignment = align;

                // After setting new alignment, update the view/window
                if (Window() != NULL) {
                        FrameResized(Bounds().Width(), Bounds().Height());
                                // text rect position and scroll bars may change
                        Invalidate();
                }
        }
}


alignment
BTextView::Alignment() const
{
        return fAlignment;
}


void
BTextView::SetAutoindent(bool state)
{
        fAutoindent = state;
}


bool
BTextView::DoesAutoindent() const
{
        return fAutoindent;
}


void
BTextView::SetColorSpace(color_space colors)
{
        if (colors != fColorSpace && fOffscreen) {
                fColorSpace = colors;
                _DeleteOffscreen();
                _NewOffscreen();
        }
}


color_space
BTextView::ColorSpace() const
{
        return fColorSpace;
}


void
BTextView::MakeResizable(bool resize, BView* resizeView)
{
        if (resize) {
                fResizable = true;
                fContainerView = resizeView;

                // Wrapping mode and resizable mode can't live together
                if (fWrap) {
                        fWrap = false;

                        if (fActive && Window() != NULL) {
                                if (fSelStart != fSelEnd) {
                                        if (fSelectable)
                                                Highlight(fSelStart, fSelEnd);
                                } else
                                        _HideCaret();
                        }
                }
                // We need to reset the right inset, as otherwise the auto-resize would
                // get confused about just how wide the textview needs to be.
                // This seems to be an artifact of how Tracker creates the textview
                // during a rename action.
                fLayoutData->rightInset = fLayoutData->leftInset;
        } else {
                fResizable = false;
                fContainerView = NULL;
                if (fOffscreen)
                        _DeleteOffscreen();
                _NewOffscreen();
        }

        _Refresh(0, fText->Length());
}


bool
BTextView::IsResizable() const
{
        return fResizable;
}


void
BTextView::SetDoesUndo(bool undo)
{
        if (undo && fUndo == NULL)
                fUndo = new UndoBuffer(this, B_UNDO_UNAVAILABLE);
        else if (!undo && fUndo != NULL) {
                delete fUndo;
                fUndo = NULL;
        }
}


bool
BTextView::DoesUndo() const
{
        return fUndo != NULL;
}


void
BTextView::HideTyping(bool enabled)
{
        if (enabled)
                Delete(0, fText->Length());

        fText->SetPasswordMode(enabled);
}


bool
BTextView::IsTypingHidden() const
{
        return fText->PasswordMode();
}


// #pragma mark - Size methods


void
BTextView::ResizeToPreferred()
{
        BView::ResizeToPreferred();
}


void
BTextView::GetPreferredSize(float* _width, float* _height)
{
        CALLED();

        _ValidateLayoutData();

        if (_width) {
                float width = Bounds().Width();
                if (width < fLayoutData->min.width
                        || (Flags() & B_SUPPORTS_LAYOUT) != 0) {
                        width = fLayoutData->min.width;
                }
                *_width = width;
        }

        if (_height) {
                float height = Bounds().Height();
                if (height < fLayoutData->min.height
                        || (Flags() & B_SUPPORTS_LAYOUT) != 0) {
                        height = fLayoutData->min.height;
                }
                *_height = height;
        }
}


BSize
BTextView::MinSize()
{
        CALLED();

        _ValidateLayoutData();
        return BLayoutUtils::ComposeSize(ExplicitMinSize(), fLayoutData->min);
}


BSize
BTextView::MaxSize()
{
        CALLED();

        return BLayoutUtils::ComposeSize(ExplicitMaxSize(),
                BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED));
}


BSize
BTextView::PreferredSize()
{
        CALLED();

        _ValidateLayoutData();
        return BLayoutUtils::ComposeSize(ExplicitPreferredSize(),
                fLayoutData->preferred);
}


bool
BTextView::HasHeightForWidth()
{
        if (IsEditable())
                return BView::HasHeightForWidth();

        // When not editable, we assume that all text is supposed to be visible.
        return true;
}


void
BTextView::GetHeightForWidth(float width, float* min, float* max,
        float* preferred)
{
        if (IsEditable()) {
                BView::GetHeightForWidth(width, min, max, preferred);
                return;
        }

        BRect saveTextRect = fTextRect;

        fTextRect.right = fTextRect.left + width;

        // If specific insets were set, reduce the width accordingly (this may result in more
        // linebreaks being inserted)
        if (fLayoutData->overridden) {
                fTextRect.left += fLayoutData->leftInset;
                fTextRect.right -= fLayoutData->rightInset;
        }

        int32 fromLine = _LineAt(0);
        int32 toLine = _LineAt(fText->Length());
        _RecalculateLineBreaks(&fromLine, &toLine);

        // If specific insets were set, add the top and bottom margins to the returned preferred height
        if (fLayoutData->overridden) {
                fTextRect.top -= fLayoutData->topInset;
                fTextRect.bottom += fLayoutData->bottomInset;
        }

        if (min != NULL)
                *min = fTextRect.Height();
        if (max != NULL)
                *max = B_SIZE_UNLIMITED;
        if (preferred != NULL)
                *preferred = fTextRect.Height();

        // Restore the text rect since we were not supposed to change it in this method.
        // Unfortunately, we did change a few other things by calling _RecalculateLineBreaks, that are
        // not so easily undone. However, we are likely to soon get resized to the new width and height
        // computed here, and that will recompute the linebreaks and do a full _Refresh if needed.
        fTextRect = saveTextRect;
}


//      #pragma mark - Layout methods


void
BTextView::LayoutInvalidated(bool descendants)
{
        CALLED();

        fLayoutData->valid = false;
}


void
BTextView::DoLayout()
{
        // Bail out, if we shan't do layout.
        if (!(Flags() & B_SUPPORTS_LAYOUT))
                return;

        CALLED();

        // If the user set a layout, we let the base class version call its
        // hook.
        if (GetLayout()) {
                BView::DoLayout();
                return;
        }

        _ValidateLayoutData();

        // validate current size
        BSize size(Bounds().Size());
        if (size.width < fLayoutData->min.width)
                size.width = fLayoutData->min.width;
        if (size.height < fLayoutData->min.height)
                size.height = fLayoutData->min.height;

        _ResetTextRect();
}


void
BTextView::_ValidateLayoutData()
{
        if (fLayoutData->valid)
                return;

        CALLED();

        float lineHeight = ceilf(LineHeight(0));
        TRACE("line height: %.2f\n", lineHeight);

        // compute our minimal size
        BSize min(lineHeight * 3, lineHeight);
        min.width += fLayoutData->leftInset + fLayoutData->rightInset;
        min.height += fLayoutData->topInset + fLayoutData->bottomInset;

        fLayoutData->min = min;

        // compute our preferred size
        fLayoutData->preferred.height = _TextHeight();

        if (fWrap)
                fLayoutData->preferred.width = min.width + 5 * lineHeight;
        else {
                float maxWidth = fLines->MaxWidth() + fLayoutData->leftInset + fLayoutData->rightInset;
                if (maxWidth < min.width)
                        maxWidth = min.width;

                fLayoutData->preferred.width = maxWidth;
                fLayoutData->min = fLayoutData->preferred;
        }

        fLayoutData->valid = true;
        ResetLayoutInvalidation();

        TRACE("width: %.2f, height: %.2f\n", min.width, min.height);
}


//      #pragma mark -


void
BTextView::AllAttached()
{
        BView::AllAttached();
}


void
BTextView::AllDetached()
{
        BView::AllDetached();
}


/* static */
text_run_array*
BTextView::AllocRunArray(int32 entryCount, int32* outSize)
{
        int32 size = sizeof(text_run_array) + (entryCount - 1) * sizeof(text_run);

        text_run_array* runArray = (text_run_array*)calloc(size, 1);
        if (runArray == NULL) {
                if (outSize != NULL)
                        *outSize = 0;
                return NULL;
        }

        runArray->count = entryCount;

        // Call constructors explicitly as the text_run_array
        // was allocated with malloc (and has to, for backwards
        // compatibility)
        for (int32 i = 0; i < runArray->count; i++)
                new (&runArray->runs[i].font) BFont;

        if (outSize != NULL)
                *outSize = size;

        return runArray;
}


/* static */
text_run_array*
BTextView::CopyRunArray(const text_run_array* orig, int32 countDelta)
{
        text_run_array* copy = AllocRunArray(countDelta, NULL);
        if (copy != NULL) {
                for (int32 i = 0; i < countDelta; i++) {
                        copy->runs[i].offset = orig->runs[i].offset;
                        copy->runs[i].font = orig->runs[i].font;
                        copy->runs[i].color = orig->runs[i].color;
                }
        }
        return copy;
}


/* static */
void
BTextView::FreeRunArray(text_run_array* array)
{
        if (array == NULL)
                return;

        // Call destructors explicitly
        for (int32 i = 0; i < array->count; i++)
                array->runs[i].font.~BFont();

        free(array);
}


/* static */
void*
BTextView::FlattenRunArray(const text_run_array* runArray, int32* _size)
{
        CALLED();
        int32 size = sizeof(flattened_text_run_array) + (runArray->count - 1)
                * sizeof(flattened_text_run);

        flattened_text_run_array* array = (flattened_text_run_array*)malloc(size);
        if (array == NULL) {
                if (_size)
                        *_size = 0;
                return NULL;
        }

        array->magic = B_HOST_TO_BENDIAN_INT32(kFlattenedTextRunArrayMagic);
        array->version = B_HOST_TO_BENDIAN_INT32(kFlattenedTextRunArrayVersion);
        array->count = B_HOST_TO_BENDIAN_INT32(runArray->count);

        for (int32 i = 0; i < runArray->count; i++) {
                array->styles[i].offset = B_HOST_TO_BENDIAN_INT32(
                        runArray->runs[i].offset);
                runArray->runs[i].font.GetFamilyAndStyle(&array->styles[i].family,
                        &array->styles[i].style);
                array->styles[i].size = B_HOST_TO_BENDIAN_FLOAT(
                        runArray->runs[i].font.Size());
                array->styles[i].shear = B_HOST_TO_BENDIAN_FLOAT(
                        runArray->runs[i].font.Shear());
                array->styles[i].face = B_HOST_TO_BENDIAN_INT16(
                        runArray->runs[i].font.Face());
                array->styles[i].red = runArray->runs[i].color.red;
                array->styles[i].green = runArray->runs[i].color.green;
                array->styles[i].blue = runArray->runs[i].color.blue;
                array->styles[i].alpha = 255;
                array->styles[i]._reserved_ = 0;
        }

        if (_size)
                *_size = size;

        return array;
}


/* static */
text_run_array*
BTextView::UnflattenRunArray(const void* data, int32* _size)
{
        CALLED();
        flattened_text_run_array* array = (flattened_text_run_array*)data;

        if (B_BENDIAN_TO_HOST_INT32(array->magic) != kFlattenedTextRunArrayMagic
                || B_BENDIAN_TO_HOST_INT32(array->version)
                        != kFlattenedTextRunArrayVersion) {
                if (_size)
                        *_size = 0;

                return NULL;
        }

        int32 count = B_BENDIAN_TO_HOST_INT32(array->count);

        text_run_array* runArray = AllocRunArray(count, _size);
        if (runArray == NULL)
                return NULL;

        for (int32 i = 0; i < count; i++) {
                runArray->runs[i].offset = B_BENDIAN_TO_HOST_INT32(
                        array->styles[i].offset);

                // Set family and style independently from each other, so that
                // even if the family doesn't exist, we try to preserve the style
                runArray->runs[i].font.SetFamilyAndStyle(array->styles[i].family, NULL);
                runArray->runs[i].font.SetFamilyAndStyle(NULL, array->styles[i].style);

                runArray->runs[i].font.SetSize(B_BENDIAN_TO_HOST_FLOAT(
                        array->styles[i].size));
                runArray->runs[i].font.SetShear(B_BENDIAN_TO_HOST_FLOAT(
                        array->styles[i].shear));

                uint16 face = B_BENDIAN_TO_HOST_INT16(array->styles[i].face);
                if (face != B_REGULAR_FACE) {
                        // Be's version doesn't seem to set this correctly
                        runArray->runs[i].font.SetFace(face);
                }

                runArray->runs[i].color.red = array->styles[i].red;
                runArray->runs[i].color.green = array->styles[i].green;
                runArray->runs[i].color.blue = array->styles[i].blue;
                runArray->runs[i].color.alpha = array->styles[i].alpha;
        }

        return runArray;
}


void
BTextView::InsertText(const char* text, int32 length, int32 offset,
        const text_run_array* runs)
{
        CALLED();

        if (length < 0)
                length = 0;

        if (offset < 0)
                offset = 0;
        else if (offset > fText->Length())
                offset = fText->Length();

        if (length > 0) {
                // add the text to the buffer
                fText->InsertText(text, length, offset);

                // update the start offsets of each line below offset
                fLines->BumpOffset(length, _LineAt(offset) + 1);

                // update the style runs
                fStyles->BumpOffset(length, fStyles->OffsetToRun(offset - 1) + 1);

                // offset the caret/selection, if the text was inserted before it
                if (offset <= fSelEnd) {
                        fSelStart += length;
                        fCaretOffset = fSelEnd = fSelStart;
                }
        }

        if (fStylable && runs != NULL)
                _SetRunArray(offset, offset + length, runs);
        else {
                // apply null-style to inserted text
                _ApplyStyleRange(offset, offset + length);
        }
}


void
BTextView::DeleteText(int32 fromOffset, int32 toOffset)
{
        CALLED();

        if (fromOffset < 0)
                fromOffset = 0;
        else if (fromOffset > fText->Length())
                fromOffset = fText->Length();

        if (toOffset < 0)
                toOffset = 0;
        else if (toOffset > fText->Length())
                toOffset = fText->Length();

        if (fromOffset >= toOffset)
                return;

        // set nullStyle to style at beginning of range
        fStyles->InvalidateNullStyle();
        fStyles->SyncNullStyle(fromOffset);

        // remove from the text buffer
        fText->RemoveRange(fromOffset, toOffset);

        // remove any lines that have been obliterated
        fLines->RemoveLineRange(fromOffset, toOffset);

        // remove any style runs that have been obliterated
        fStyles->RemoveStyleRange(fromOffset, toOffset);

        // adjust the selection accordingly, assumes fSelEnd >= fSelStart!
        int32 range = toOffset - fromOffset;
        if (fSelStart >= toOffset) {
                // selection is behind the range that was removed
                fSelStart -= range;
                fSelEnd -= range;
        } else if (fSelStart >= fromOffset && fSelEnd <= toOffset) {
                // the selection is within the range that was removed
                fSelStart = fSelEnd = fromOffset;
        } else if (fSelStart >= fromOffset && fSelEnd > toOffset) {
                // the selection starts within and ends after the range
                // the remaining part is the part that was after the range
                fSelStart = fromOffset;
                fSelEnd = fromOffset + fSelEnd - toOffset;
        } else if (fSelStart < fromOffset && fSelEnd < toOffset) {
                // the selection starts before, but ends within the range
                fSelEnd = fromOffset;
        } else if (fSelStart < fromOffset && fSelEnd >= toOffset) {
                // the selection starts before and ends after the range
                fSelEnd -= range;
        }
}


/*!     Undoes the last changes.

        \param clipboard A \a clipboard to use for the undo operation.
*/
void
BTextView::Undo(BClipboard* clipboard)
{
        if (fUndo)
                fUndo->Undo(clipboard);
}


undo_state
BTextView::UndoState(bool* isRedo) const
{
        return fUndo == NULL ? B_UNDO_UNAVAILABLE : fUndo->State(isRedo);
}


//      #pragma mark - GetDragParameters() is protected


void
BTextView::GetDragParameters(BMessage* drag, BBitmap** bitmap, BPoint* point,
        BHandler** handler)
{
        CALLED();
        if (drag == NULL)
                return;

        // Add originator and action
        drag->AddPointer("be:originator", this);
        drag->AddInt32("be_actions", B_TRASH_TARGET);

        // add the text
        int32 numBytes = fSelEnd - fSelStart;
        const char* text = fText->GetString(fSelStart, &numBytes);
        drag->AddData("text/plain", B_MIME_TYPE, text, numBytes);

        // add the corresponding styles
        int32 size = 0;
        text_run_array* styles = RunArray(fSelStart, fSelEnd, &size);

        if (styles != NULL) {
                drag->AddData("application/x-vnd.Be-text_run_array", B_MIME_TYPE,
                        styles, size);

                FreeRunArray(styles);
        }

        if (bitmap != NULL)
                *bitmap = NULL;

        if (handler != NULL)
                *handler = NULL;
}


//      #pragma mark - FBC padding and forbidden methods


void BTextView::_ReservedTextView3() {}
void BTextView::_ReservedTextView4() {}
void BTextView::_ReservedTextView5() {}
void BTextView::_ReservedTextView6() {}
void BTextView::_ReservedTextView7() {}
void BTextView::_ReservedTextView8() {}
void BTextView::_ReservedTextView9() {}
void BTextView::_ReservedTextView10() {}
void BTextView::_ReservedTextView11() {}
void BTextView::_ReservedTextView12() {}


// #pragma mark - Private methods


/*!     Inits the BTextView object.

        \param textRect The BTextView's text rect.
        \param initialFont The font which the BTextView will use.
        \param initialColor The initial color of the text.
*/
void
BTextView::_InitObject(BRect textRect, const BFont* initialFont,
        const rgb_color* initialColor)
{
        BFont font;
        if (initialFont == NULL)
                GetFont(&font);
        else
                font = *initialFont;

        _NormalizeFont(&font);

        rgb_color documentTextColor = ui_color(B_DOCUMENT_TEXT_COLOR);

        if (initialColor == NULL)
                initialColor = &documentTextColor;

        fText = new BPrivate::TextGapBuffer;
        fLines = new LineBuffer;
        fStyles = new StyleBuffer(&font, initialColor);

        fInstalledNavigateCommandWordwiseShortcuts = false;
        fInstalledNavigateOptionWordwiseShortcuts = false;
        fInstalledNavigateOptionLinewiseShortcuts = false;
        fInstalledNavigateHomeEndDocwiseShortcuts = false;

        fInstalledSelectCommandWordwiseShortcuts = false;
        fInstalledSelectOptionWordwiseShortcuts = false;
        fInstalledSelectOptionLinewiseShortcuts = false;
        fInstalledSelectHomeEndDocwiseShortcuts = false;

        fInstalledRemoveCommandWordwiseShortcuts = false;
        fInstalledRemoveOptionWordwiseShortcuts = false;

        // We put these here instead of in the constructor initializer list
        // to have less code duplication, and a single place where to do changes
        // if needed.
        fTextRect = textRect;
                // NOTE: The only places where text rect is changed:
                // * width and height are adjusted in _RecalculateLineBreaks(),
                // text rect maintains constant insets, use SetInsets() to change.
        fMinTextRectWidth = fTextRect.Width();
                // see SetTextRect()
        fSelStart = fSelEnd = 0;
        fCaretVisible = false;
        fCaretTime = 0;
        fCaretOffset = 0;
        fClickCount = 0;
        fClickTime = 0;
        fDragOffset = -1;
        fCursor = 0;
        fActive = false;
        fStylable = false;
        fTabWidth = 28.0;
        fSelectable = true;
        fEditable = true;
        fWrap = true;
        fMaxBytes = INT32_MAX;
        fDisallowedChars = NULL;
        fAlignment = B_ALIGN_LEFT;
        fAutoindent = false;
        fOffscreen = NULL;
        fColorSpace = B_CMAP8;
        fResizable = false;
        fContainerView = NULL;
        fUndo = NULL;
        fInline = NULL;
        fDragRunner = NULL;
        fClickRunner = NULL;
        fTrackingMouse = NULL;

        fLayoutData = new LayoutData;
        _UpdateInsets(textRect);

        fLastClickOffset = -1;

        SetDoesUndo(true);
}


//!     Handles when Backspace key is pressed.
void
BTextView::_HandleBackspace(int32 modifiers)
{
        if (!fEditable)
                return;

        if (modifiers < 0) {
                BMessage* currentMessage = Window()->CurrentMessage();
                if (currentMessage == NULL
                        || currentMessage->FindInt32("modifiers", &modifiers) != B_OK) {
                        modifiers = 0;
                }
        }

        bool controlKeyDown = (modifiers & B_CONTROL_KEY) != 0;
        bool optionKeyDown  = (modifiers & B_OPTION_KEY)  != 0;
        bool commandKeyDown = (modifiers & B_COMMAND_KEY) != 0;

        if ((commandKeyDown || optionKeyDown) && !controlKeyDown) {
                fSelStart = _PreviousWordStart(fCaretOffset - 1);
                fSelEnd = fCaretOffset;
        }

        if (fUndo) {
                TypingUndoBuffer* undoBuffer = dynamic_cast<TypingUndoBuffer*>(fUndo);
                if (!undoBuffer) {
                        delete fUndo;
                        fUndo = undoBuffer = new TypingUndoBuffer(this);
                }
                undoBuffer->BackwardErase();
        }

        // we may draw twice, so turn updates off for now
        if (Window() != NULL)
                Window()->DisableUpdates();

        if (fSelStart == fSelEnd) {
                if (fSelStart != 0)
                        fSelStart = _PreviousInitialByte(fSelStart);
        } else
                Highlight(fSelStart, fSelEnd);

        DeleteText(fSelStart, fSelEnd);
        fCaretOffset = fSelEnd = fSelStart;

        _Refresh(fSelStart, fSelEnd, fCaretOffset);

        // turn updates back on
        if (Window() != NULL)
                Window()->EnableUpdates();
}


//!     Handles when an arrow key is pressed.
void
BTextView::_HandleArrowKey(uint32 arrowKey, int32 modifiers)
{
        // return if there's nowhere to go
        if (fText->Length() == 0)
                return;

        int32 selStart = fSelStart;
        int32 selEnd = fSelEnd;

        if (modifiers < 0) {
                BMessage* currentMessage = Window()->CurrentMessage();
                if (currentMessage == NULL
                        || currentMessage->FindInt32("modifiers", &modifiers) != B_OK) {
                        modifiers = 0;
                }
        }

        bool shiftKeyDown   = (modifiers & B_SHIFT_KEY)   != 0;
        bool controlKeyDown = (modifiers & B_CONTROL_KEY) != 0;
        bool optionKeyDown  = (modifiers & B_OPTION_KEY)  != 0;
        bool commandKeyDown = (modifiers & B_COMMAND_KEY) != 0;

        int32 lastClickOffset = fCaretOffset;

        switch (arrowKey) {
                case B_LEFT_ARROW:
                        if (!fEditable && !fSelectable)
                                _ScrollBy(-kHorizontalScrollBarStep, 0);
                        else if (fSelStart != fSelEnd && !shiftKeyDown)
                                fCaretOffset = fSelStart;
                        else {
                                if ((commandKeyDown || optionKeyDown) && !controlKeyDown)
                                        fCaretOffset = _PreviousWordStart(fCaretOffset - 1);
                                else
                                        fCaretOffset = _PreviousInitialByte(fCaretOffset);

                                if (shiftKeyDown && fCaretOffset != lastClickOffset) {
                                        if (fCaretOffset < fSelStart) {
                                                // extend selection to the left
                                                selStart = fCaretOffset;
                                                if (lastClickOffset > fSelStart) {
                                                        // caret has jumped across "anchor"
                                                        selEnd = fSelStart;
                                                }
                                        } else {
                                                // shrink selection from the right
                                                selEnd = fCaretOffset;
                                        }
                                }
                        }
                        break;

                case B_RIGHT_ARROW:
                        if (!fEditable && !fSelectable)
                                _ScrollBy(kHorizontalScrollBarStep, 0);
                        else if (fSelStart != fSelEnd && !shiftKeyDown)
                                fCaretOffset = fSelEnd;
                        else {
                                if ((commandKeyDown || optionKeyDown) && !controlKeyDown)
                                        fCaretOffset = _NextWordEnd(fCaretOffset);
                                else
                                        fCaretOffset = _NextInitialByte(fCaretOffset);

                                if (shiftKeyDown && fCaretOffset != lastClickOffset) {
                                        if (fCaretOffset > fSelEnd) {
                                                // extend selection to the right
                                                selEnd = fCaretOffset;
                                                if (lastClickOffset < fSelEnd) {
                                                        // caret has jumped across "anchor"
                                                        selStart = fSelEnd;
                                                }
                                        } else {
                                                // shrink selection from the left
                                                selStart = fCaretOffset;
                                        }
                                }
                        }
                        break;

                case B_UP_ARROW:
                {
                        if (!fEditable && !fSelectable)
                                _ScrollBy(0, -kVerticalScrollBarStep);
                        else if (fSelStart != fSelEnd && !shiftKeyDown)
                                fCaretOffset = fSelStart;
                        else {
                                if (optionKeyDown && !commandKeyDown && !controlKeyDown)
                                        fCaretOffset = _PreviousLineStart(fCaretOffset);
                                else if (commandKeyDown && !optionKeyDown && !controlKeyDown) {
                                        _ScrollTo(0, 0);
                                        fCaretOffset = 0;
                                } else {
                                        float height;
                                        BPoint point = PointAt(fCaretOffset, &height);
                                        // find the caret position on the previous
                                        // line by gently stepping onto this line
                                        for (int i = 1; i <= height; i++) {
                                                point.y--;
                                                int32 offset = OffsetAt(point);
                                                if (offset < fCaretOffset || i == height) {
                                                        fCaretOffset = offset;
                                                        break;
                                                }
                                        }
                                }

                                if (shiftKeyDown && fCaretOffset != lastClickOffset) {
                                        if (fCaretOffset < fSelStart) {
                                                // extend selection to the top
                                                selStart = fCaretOffset;
                                                if (lastClickOffset > fSelStart) {
                                                        // caret has jumped across "anchor"
                                                        selEnd = fSelStart;
                                                }
                                        } else {
                                                // shrink selection from the bottom
                                                selEnd = fCaretOffset;
                                        }
                                }
                        }
                        break;
                }

                case B_DOWN_ARROW:
                {
                        if (!fEditable && !fSelectable)
                                _ScrollBy(0, kVerticalScrollBarStep);
                        else if (fSelStart != fSelEnd && !shiftKeyDown)
                                fCaretOffset = fSelEnd;
                        else {
                                if (optionKeyDown && !commandKeyDown && !controlKeyDown)
                                        fCaretOffset = _NextLineEnd(fCaretOffset);
                                else if (commandKeyDown && !optionKeyDown && !controlKeyDown) {
                                        _ScrollTo(0, fTextRect.bottom + fLayoutData->bottomInset);
                                        fCaretOffset = fText->Length();
                                } else {
                                        float height;
                                        BPoint point = PointAt(fCaretOffset, &height);
                                        point.y += height;
                                        fCaretOffset = OffsetAt(point);
                                }

                                if (shiftKeyDown && fCaretOffset != lastClickOffset) {
                                        if (fCaretOffset > fSelEnd) {
                                                // extend selection to the bottom
                                                selEnd = fCaretOffset;
                                                if (lastClickOffset < fSelEnd) {
                                                        // caret has jumped across "anchor"
                                                        selStart = fSelEnd;
                                                }
                                        } else {
                                                // shrink selection from the top
                                                selStart = fCaretOffset;
                                        }
                                }
                        }
                        break;
                }
        }

        fStyles->InvalidateNullStyle();

        if (fEditable || fSelectable) {
                if (shiftKeyDown)
                        Select(selStart, selEnd);
                else
                        Select(fCaretOffset, fCaretOffset);

                // scroll if needed
                ScrollToOffset(fCaretOffset);
        }
}


//!     Handles when the Delete key is pressed.
void
BTextView::_HandleDelete(int32 modifiers)
{
        if (!fEditable)
                return;

        if (modifiers < 0) {
                BMessage* currentMessage = Window()->CurrentMessage();
                if (currentMessage == NULL
                        || currentMessage->FindInt32("modifiers", &modifiers) != B_OK) {
                        modifiers = 0;
                }
        }

        bool controlKeyDown = (modifiers & B_CONTROL_KEY) != 0;
        bool optionKeyDown  = (modifiers & B_OPTION_KEY)  != 0;
        bool commandKeyDown = (modifiers & B_COMMAND_KEY) != 0;

        if ((commandKeyDown || optionKeyDown) && !controlKeyDown) {
                fSelStart = fCaretOffset;
                fSelEnd = _NextWordEnd(fCaretOffset) + 1;
        }

        if (fUndo) {
                TypingUndoBuffer* undoBuffer = dynamic_cast<TypingUndoBuffer*>(fUndo);
                if (!undoBuffer) {
                        delete fUndo;
                        fUndo = undoBuffer = new TypingUndoBuffer(this);
                }
                undoBuffer->ForwardErase();
        }

        // we may draw twice, so turn updates off for now
        if (Window() != NULL)
                Window()->DisableUpdates();

        if (fSelStart == fSelEnd) {
                if (fSelEnd != fText->Length())
                        fSelEnd = _NextInitialByte(fSelEnd);
        } else
                Highlight(fSelStart, fSelEnd);

        DeleteText(fSelStart, fSelEnd);
        fCaretOffset = fSelEnd = fSelStart;

        _Refresh(fSelStart, fSelEnd, fCaretOffset);

        // turn updates back on
        if (Window() != NULL)
                Window()->EnableUpdates();
}


//!     Handles when the Page Up, Page Down, Home, or End key is pressed.
void
BTextView::_HandlePageKey(uint32 pageKey, int32 modifiers)
{
        if (modifiers < 0) {
                BMessage* currentMessage = Window()->CurrentMessage();
                if (currentMessage == NULL
                        || currentMessage->FindInt32("modifiers", &modifiers) != B_OK) {
                        modifiers = 0;
                }
        }

        bool shiftKeyDown   = (modifiers & B_SHIFT_KEY)   != 0;
        bool controlKeyDown = (modifiers & B_CONTROL_KEY) != 0;
        bool optionKeyDown  = (modifiers & B_OPTION_KEY)  != 0;
        bool commandKeyDown = (modifiers & B_COMMAND_KEY) != 0;

        STELine* line = NULL;
        int32 selStart = fSelStart;
        int32 selEnd = fSelEnd;

        int32 lastClickOffset = fCaretOffset;
        switch (pageKey) {
                case B_HOME:
                        if (!fEditable && !fSelectable) {
                                fCaretOffset = 0;
                                _ScrollTo(0, 0);
                                break;
                        } else {
                                if (commandKeyDown && !optionKeyDown && !controlKeyDown) {
                                        _ScrollTo(0, 0);
                                        fCaretOffset = 0;
                                } else {
                                        // get the start of the last line if caret is on it
                                        line = (*fLines)[_LineAt(lastClickOffset)];
                                        fCaretOffset = line->offset;
                                }

                                if (!shiftKeyDown)
                                        selStart = selEnd = fCaretOffset;
                                else if (fCaretOffset != lastClickOffset) {
                                        if (fCaretOffset < fSelStart) {
                                                // extend selection to the left
                                                selStart = fCaretOffset;
                                                if (lastClickOffset > fSelStart) {
                                                        // caret has jumped across "anchor"
                                                        selEnd = fSelStart;
                                                }
                                        } else {
                                                // shrink selection from the right
                                                selEnd = fCaretOffset;
                                        }
                                }
                        }
                        break;

                case B_END:
                        if (!fEditable && !fSelectable) {
                                fCaretOffset = fText->Length();
                                _ScrollTo(0, fTextRect.bottom + fLayoutData->bottomInset);
                                break;
                        } else {
                                if (commandKeyDown && !optionKeyDown && !controlKeyDown) {
                                        _ScrollTo(0, fTextRect.bottom + fLayoutData->bottomInset);
                                        fCaretOffset = fText->Length();
                                } else {
                                        // If we are on the last line, just go to the last
                                        // character in the buffer, otherwise get the starting
                                        // offset of the next line, and go to the previous character
                                        int32 currentLine = _LineAt(lastClickOffset);
                                        if (currentLine + 1 < fLines->NumLines()) {
                                                line = (*fLines)[currentLine + 1];
                                                fCaretOffset = _PreviousInitialByte(line->offset);
                                        } else {
                                                // This check is needed to avoid moving the cursor
                                                // when the cursor is on the last line, and that line
                                                // is empty
                                                if (fCaretOffset != fText->Length()) {
                                                        fCaretOffset = fText->Length();
                                                        if (ByteAt(fCaretOffset - 1) == B_ENTER)
                                                                fCaretOffset--;
                                                }
                                        }
                                }

                                if (!shiftKeyDown)
                                        selStart = selEnd = fCaretOffset;
                                else if (fCaretOffset != lastClickOffset) {
                                        if (fCaretOffset > fSelEnd) {
                                                // extend selection to the right
                                                selEnd = fCaretOffset;
                                                if (lastClickOffset < fSelEnd) {
                                                        // caret has jumped across "anchor"
                                                        selStart = fSelEnd;
                                                }
                                        } else {
                                                // shrink selection from the left
                                                selStart = fCaretOffset;
                                        }
                                }
                        }
                        break;

                case B_PAGE_UP:
                {
                        float lineHeight;
                        BPoint currentPos = PointAt(fCaretOffset, &lineHeight);
                        BPoint nextPos(currentPos.x,
                                currentPos.y + lineHeight - Bounds().Height());
                        fCaretOffset = OffsetAt(nextPos);
                        nextPos = PointAt(fCaretOffset);
                        _ScrollBy(0, nextPos.y - currentPos.y);

                        if (!fEditable && !fSelectable)
                                break;

                        if (!shiftKeyDown)
                                selStart = selEnd = fCaretOffset;
                        else if (fCaretOffset != lastClickOffset) {
                                if (fCaretOffset < fSelStart) {
                                        // extend selection to the top
                                        selStart = fCaretOffset;
                                        if (lastClickOffset > fSelStart) {
                                                // caret has jumped across "anchor"
                                                selEnd = fSelStart;
                                        }
                                } else {
                                        // shrink selection from the bottom
                                        selEnd = fCaretOffset;
                                }
                        }

                        break;
                }

                case B_PAGE_DOWN:
                {
                        BPoint currentPos = PointAt(fCaretOffset);
                        BPoint nextPos(currentPos.x, currentPos.y + Bounds().Height());
                        fCaretOffset = OffsetAt(nextPos);
                        nextPos = PointAt(fCaretOffset);
                        _ScrollBy(0, nextPos.y - currentPos.y);

                        if (!fEditable && !fSelectable)
                                break;

                        if (!shiftKeyDown)
                                selStart = selEnd = fCaretOffset;
                        else if (fCaretOffset != lastClickOffset) {
                                if (fCaretOffset > fSelEnd) {
                                        // extend selection to the bottom
                                        selEnd = fCaretOffset;
                                        if (lastClickOffset < fSelEnd) {
                                                // caret has jumped across "anchor"
                                                selStart = fSelEnd;
                                        }
                                } else {
                                        // shrink selection from the top
                                        selStart = fCaretOffset;
                                }
                        }

                        break;
                }
        }

        if (fEditable || fSelectable) {
                if (shiftKeyDown)
                        Select(selStart, selEnd);
                else
                        Select(fCaretOffset, fCaretOffset);

                ScrollToOffset(fCaretOffset);
        }
}


/*!     Handles when an alpha-numeric key is pressed.

        \param bytes The string or character associated with the key.
        \param numBytes The amount of bytes containes in "bytes".
*/
void
BTextView::_HandleAlphaKey(const char* bytes, int32 numBytes)
{
        if (!fEditable)
                return;

        if (fUndo) {
                TypingUndoBuffer* undoBuffer = dynamic_cast<TypingUndoBuffer*>(fUndo);
                if (!undoBuffer) {
                        delete fUndo;
                        fUndo = undoBuffer = new TypingUndoBuffer(this);
                }
                undoBuffer->InputCharacter(numBytes);
        }

        if (fSelStart != fSelEnd) {
                Highlight(fSelStart, fSelEnd);
                DeleteText(fSelStart, fSelEnd);
        }

        // we may draw twice, so turn updates off for now
        if (Window() != NULL)
                Window()->DisableUpdates();

        if (fAutoindent && numBytes == 1 && *bytes == B_ENTER) {
                int32 start, offset;
                start = offset = OffsetAt(_LineAt(fSelStart));

                while (ByteAt(offset) != '\0' &&
                                (ByteAt(offset) == B_TAB || ByteAt(offset) == B_SPACE)
                                && offset < fSelStart)
                        offset++;

                _DoInsertText(bytes, numBytes, fSelStart, NULL);
                if (start != offset)
                        _DoInsertText(Text() + start, offset - start, fSelStart, NULL);
        } else
                _DoInsertText(bytes, numBytes, fSelStart, NULL);

        fCaretOffset = fSelEnd;
        ScrollToOffset(fCaretOffset);

        // turn updates back on
        if (Window() != NULL)
                Window()->EnableUpdates();
}


/*!     Redraw the text between the two given offsets, recalculating line-breaks
        if needed.

        \param fromOffset The offset from where to refresh.
        \param toOffset The offset where to refresh to.
        \param scrollTo Scroll the view to \a scrollTo offset if not \c INT32_MIN.
*/
void
BTextView::_Refresh(int32 fromOffset, int32 toOffset, int32 scrollTo)
{
        // TODO: Cleanup
        float saveHeight = fTextRect.Height();
        float saveWidth = fTextRect.Width();
        int32 fromLine = _LineAt(fromOffset);
        int32 toLine = _LineAt(toOffset);
        int32 saveFromLine = fromLine;
        int32 saveToLine = toLine;

        _RecalculateLineBreaks(&fromLine, &toLine);

        // TODO: Maybe there is still something we can do without a window...
        if (!Window())
                return;

        BRect bounds = Bounds();
        float newHeight = fTextRect.Height();

        // if the line breaks have changed, force an erase
        if (fromLine != saveFromLine || toLine != saveToLine
                        || newHeight != saveHeight) {
                fromOffset = -1;
        }

        if (newHeight != saveHeight) {
                // the text area has changed
                if (newHeight < saveHeight)
                        toLine = _LineAt(BPoint(0.0f, saveHeight + fTextRect.top));
                else
                        toLine = _LineAt(BPoint(0.0f, newHeight + fTextRect.top));
        }

        // draw only those lines that are visible
        int32 fromVisible = _LineAt(BPoint(0.0f, bounds.top));
        int32 toVisible = _LineAt(BPoint(0.0f, bounds.bottom));
        fromLine = std::max(fromVisible, fromLine);
        toLine = std::min(toLine, toVisible);

        _AutoResize(false);

        _RequestDrawLines(fromLine, toLine);

        // erase the area below the text
        BRect eraseRect = bounds;
        eraseRect.top = fTextRect.top + (*fLines)[fLines->NumLines()]->origin;
        eraseRect.bottom = fTextRect.top + saveHeight;
        if (eraseRect.bottom > eraseRect.top && eraseRect.Intersects(bounds)) {
                SetLowColor(ViewColor());
                FillRect(eraseRect, B_SOLID_LOW);
        }

        // update the scroll bars if the text area has changed
        if (newHeight != saveHeight || fMinTextRectWidth != saveWidth)
                _UpdateScrollbars();

        if (scrollTo != INT32_MIN)
                ScrollToOffset(scrollTo);

        Flush();
}


/*!     Recalculate line breaks between two lines.

        \param startLine The line number to start recalculating line breaks.
        \param endLine The line number to stop recalculating line breaks.
*/
void
BTextView::_RecalculateLineBreaks(int32* startLine, int32* endLine)
{
        CALLED();

        float width = fTextRect.Width();

        // don't try to compute anything with word wrapping if the text rect is not set
        if (fWrap && (!fTextRect.IsValid() || width == 0))
                return;

        // sanity check
        *startLine = (*startLine < 0) ? 0 : *startLine;
        *endLine = (*endLine > fLines->NumLines() - 1) ? fLines->NumLines() - 1
                : *endLine;

        int32 textLength = fText->Length();
        int32 lineIndex = (*startLine > 0) ? *startLine - 1 : 0;
        int32 recalThreshold = (*fLines)[*endLine + 1]->offset;
        STELine* curLine = (*fLines)[lineIndex];
        STELine* nextLine = curLine + 1;

        do {
                float ascent, descent;
                int32 fromOffset = curLine->offset;
                int32 toOffset = _FindLineBreak(fromOffset, &ascent, &descent, &width);

                curLine->ascent = ascent;
                curLine->width = width;

                // we want to advance at least by one character
                int32 nextOffset = _NextInitialByte(fromOffset);
                if (toOffset < nextOffset && fromOffset < textLength)
                        toOffset = nextOffset;

                lineIndex++;
                STELine saveLine = *nextLine;
                if (lineIndex > fLines->NumLines() || toOffset < nextLine->offset) {
                        // the new line comes before the old line start, add a line
                        STELine newLine;
                        newLine.offset = toOffset;
                        newLine.origin = ceilf(curLine->origin + ascent + descent) + 1;
                        newLine.ascent = 0;
                        fLines->InsertLine(&newLine, lineIndex);
                } else {
                        // update the existing line
                        nextLine->offset = toOffset;
                        nextLine->origin = ceilf(curLine->origin + ascent + descent) + 1;

                        // remove any lines that start before the current line
                        while (lineIndex < fLines->NumLines()
                                && toOffset >= ((*fLines)[lineIndex] + 1)->offset) {
                                fLines->RemoveLines(lineIndex + 1);
                        }

                        nextLine = (*fLines)[lineIndex];
                        if (nextLine->offset == saveLine.offset) {
                                if (nextLine->offset >= recalThreshold) {
                                        if (nextLine->origin != saveLine.origin)
                                                fLines->BumpOrigin(nextLine->origin - saveLine.origin,
                                                        lineIndex + 1);
                                        break;
                                }
                        } else {
                                if (lineIndex > 0 && lineIndex == *startLine)
                                        *startLine = lineIndex - 1;
                        }
                }

                curLine = (*fLines)[lineIndex];
                nextLine = curLine + 1;
        } while (curLine->offset < textLength);

        // make sure that the sentinel line (which starts at the end of the buffer)
        // has always a width of 0
        (*fLines)[fLines->NumLines()]->width = 0;

        // update text rect
        fTextRect.left = Bounds().left + fLayoutData->leftInset;
        fTextRect.right = Bounds().right - fLayoutData->rightInset;

        // always set text rect bottom
        float newHeight = TextHeight(0, fLines->NumLines() - 1);
        fTextRect.bottom = fTextRect.top + newHeight;

        if (!fWrap) {
                fMinTextRectWidth = fLines->MaxWidth() - 1;

                // expand width if needed
                switch (fAlignment) {
                        default:
                        case B_ALIGN_LEFT:
                                // move right edge
                                fTextRect.right = fTextRect.left + fMinTextRectWidth;
                                break;

                        case B_ALIGN_RIGHT:
                                // move left edge
                                fTextRect.left = fTextRect.right - fMinTextRectWidth;
                                break;

                        case B_ALIGN_CENTER:
                                // move both edges
                                fTextRect.InsetBy(roundf((fTextRect.Width()
                                        - fMinTextRectWidth) / 2), 0);
                                break;
                }

                _ValidateTextRect();
        }

        *endLine = lineIndex - 1;
        *startLine = std::min(*startLine, *endLine);
}


void
BTextView::_ValidateTextRect()
{
        // text rect right must be greater than left
        if (fTextRect.right <= fTextRect.left)
                fTextRect.right = fTextRect.left + 1;
        // text rect bottom must be greater than top
        if (fTextRect.bottom <= fTextRect.top)
                fTextRect.bottom = fTextRect.top + 1;
}


int32
BTextView::_FindLineBreak(int32 fromOffset, float* _ascent, float* _descent,
        float* inOutWidth)
{
        *_ascent = 0.0;
        *_descent = 0.0;

        const int32 limit = fText->Length();

        // is fromOffset at the end?
        if (fromOffset >= limit) {
                // try to return valid height info anyway
                if (fStyles->NumRuns() > 0) {
                        fStyles->Iterate(fromOffset, 1, fInline, NULL, NULL, _ascent,
                                _descent);
                } else {
                        if (fStyles->IsValidNullStyle()) {
                                const BFont* font = NULL;
                                fStyles->GetNullStyle(&font, NULL);

                                font_height fh;
                                font->GetHeight(&fh);
                                *_ascent = fh.ascent;
                                *_descent = fh.descent + fh.leading;
                        }
                }
                *inOutWidth = 0;

                return limit;
        }

        int32 offset = fromOffset;

        if (!fWrap) {
                // Text wrapping is turned off.
                // Just find the offset of the first \n character
                offset = limit - fromOffset;
                fText->FindChar(B_ENTER, fromOffset, &offset);
                offset += fromOffset;
                int32 toOffset = (offset < limit) ? offset : limit;

                *inOutWidth = _TabExpandedStyledWidth(fromOffset, toOffset - fromOffset,
                        _ascent, _descent);

                return offset < limit ? offset + 1 : limit;
        }

        bool done = false;
        float ascent = 0.0;
        float descent = 0.0;
        int32 delta = 0;
        float deltaWidth = 0.0;
        float strWidth = 0.0;
        uchar theChar;

        // wrap the text
        while (offset < limit && !done) {
                // find the next line break candidate
                for (; (offset + delta) < limit; delta++) {
                        if (CanEndLine(offset + delta)) {
                                theChar = fText->RealCharAt(offset + delta);
                                if (theChar != B_SPACE && theChar != B_TAB
                                        && theChar != B_ENTER) {
                                        // we are scanning for trailing whitespace below, so we
                                        // have to skip non-whitespace characters, that can end
                                        // the line, here
                                        delta++;
                                }
                                break;
                        }
                }

                int32 deltaBeforeWhitespace = delta;
                // now skip over trailing whitespace, if any
                for (; (offset + delta) < limit; delta++) {
                        theChar = fText->RealCharAt(offset + delta);
                        if (theChar == B_ENTER) {
                                // found a newline, we're done!
                                done = true;
                                delta++;
                                break;
                        } else if (theChar != B_SPACE && theChar != B_TAB) {
                                // stop at anything else than trailing whitespace
                                break;
                        }
                }

                delta = std::max(delta, (int32)1);

                // do not include B_ENTER-terminator into width & height calculations
                deltaWidth = _TabExpandedStyledWidth(offset,
                                                                done ? delta - 1 : delta, &ascent, &descent);
                strWidth += deltaWidth;

                if (strWidth >= *inOutWidth) {
                        // we've found where the line will wrap
                        done = true;

                        // we have included trailing whitespace in the width computation
                        // above, but that is not being shown anyway, so we try again
                        // without the trailing whitespace
                        if (delta == deltaBeforeWhitespace) {
                                // there is no trailing whitespace, no point in trying
                                break;
                        }

                        // reset string width to start of current run ...
                        strWidth -= deltaWidth;

                        // ... and compute the resulting width (of visible characters)
                        strWidth += _StyledWidth(offset, deltaBeforeWhitespace, NULL, NULL);
                        if (strWidth >= *inOutWidth) {
                                // width of visible characters exceeds line, we need to wrap
                                // before the current "word"
                                break;
                        }
                }

                *_ascent = std::max(ascent, *_ascent);
                *_descent = std::max(descent, *_descent);

                offset += delta;
                delta = 0;
        }

        if (offset - fromOffset < 1) {
                // there weren't any words that fit entirely in this line
                // force a break in the middle of a word
                *_ascent = 0.0;
                *_descent = 0.0;
                strWidth = 0.0;

                int32 current = fromOffset;
                for (offset = _NextInitialByte(current); current < limit;
                                current = offset, offset = _NextInitialByte(offset)) {
                        strWidth += _StyledWidth(current, offset - current, &ascent,
                                &descent);
                        if (strWidth >= *inOutWidth) {
                                offset = _PreviousInitialByte(offset);
                                break;
                        }

                        *_ascent = std::max(ascent, *_ascent);
                        *_descent = std::max(descent, *_descent);
                }
        }

        return std::min(offset, limit);
}


int32
BTextView::_PreviousLineStart(int32 offset)
{
        if (offset <= 0)
                return 0;

        while (offset > 0) {
                offset = _PreviousInitialByte(offset);
                if (_CharClassification(offset) == CHAR_CLASS_WHITESPACE
                        && ByteAt(offset) == B_ENTER) {
                        return offset + 1;
                }
        }

        return offset;
}


int32
BTextView::_NextLineEnd(int32 offset)
{
        int32 textLen = fText->Length();
        if (offset >= textLen)
                return textLen;

        while (offset < textLen) {
                if (_CharClassification(offset) == CHAR_CLASS_WHITESPACE
                        && ByteAt(offset) == B_ENTER) {
                        break;
                }
                offset = _NextInitialByte(offset);
        }

        return offset;
}


int32
BTextView::_PreviousWordBoundary(int32 offset)
{
        uint32 charType = _CharClassification(offset);
        int32 previous;
        while (offset > 0) {
                previous = _PreviousInitialByte(offset);
                if (_CharClassification(previous) != charType)
                        break;
                offset = previous;
        }

        return offset;
}


int32
BTextView::_NextWordBoundary(int32 offset)
{
        int32 textLen = fText->Length();
        uint32 charType = _CharClassification(offset);
        while (offset < textLen) {
                offset = _NextInitialByte(offset);
                if (_CharClassification(offset) != charType)
                        break;
        }

        return offset;
}


int32
BTextView::_PreviousWordStart(int32 offset)
{
        if (offset <= 1)
                return 0;

        --offset;
                // need to look at previous char
        if (_CharClassification(offset) != CHAR_CLASS_DEFAULT) {
                // skip non-word characters
                while (offset > 0) {
                        offset = _PreviousInitialByte(offset);
                        if (_CharClassification(offset) == CHAR_CLASS_DEFAULT)
                                break;
                }
        }
        while (offset > 0) {
                // skip to start of word
                int32 previous = _PreviousInitialByte(offset);
                if (_CharClassification(previous) != CHAR_CLASS_DEFAULT)
                        break;
                offset = previous;
        }

        return offset;
}


int32
BTextView::_NextWordEnd(int32 offset)
{
        int32 textLen = fText->Length();
        if (_CharClassification(offset) != CHAR_CLASS_DEFAULT) {
                // skip non-word characters
                while (offset < textLen) {
                        offset = _NextInitialByte(offset);
                        if (_CharClassification(offset) == CHAR_CLASS_DEFAULT)
                                break;
                }
        }
        while (offset < textLen) {
                // skip to end of word
                offset = _NextInitialByte(offset);
                if (_CharClassification(offset) != CHAR_CLASS_DEFAULT)
                        break;
        }

        return offset;
}


/*!     Returns the width used by the characters starting at the given
        offset with the given length, expanding all tab characters as needed.
*/
float
BTextView::_TabExpandedStyledWidth(int32 offset, int32 length, float* _ascent,
        float* _descent) const
{
        float ascent = 0.0;
        float descent = 0.0;
        float maxAscent = 0.0;
        float maxDescent = 0.0;

        float width = 0.0;
        int32 numBytes = length;
        bool foundTab = false;
        do {
                foundTab = fText->FindChar(B_TAB, offset, &numBytes);
                width += _StyledWidth(offset, numBytes, &ascent, &descent);

                if (maxAscent < ascent)
                        maxAscent = ascent;
                if (maxDescent < descent)
                        maxDescent = descent;

                if (foundTab) {
                        width += _ActualTabWidth(width);
                        numBytes++;
                }

                offset += numBytes;
                length -= numBytes;
                numBytes = length;
        } while (foundTab && length > 0);

        if (_ascent != NULL)
                *_ascent = maxAscent;
        if (_descent != NULL)
                *_descent = maxDescent;

        return width;
}


/*!     Calculate the width of the text within the given limits.

        \param fromOffset The offset where to start.
        \param length The length of the text to examine.
        \param _ascent A pointer to a float which will contain the maximum ascent.
        \param _descent A pointer to a float which will contain the maximum descent.

        \return The width for the text within the given limits.
*/
float
BTextView::_StyledWidth(int32 fromOffset, int32 length, float* _ascent,
        float* _descent) const
{
        if (length == 0) {
                // determine height of char at given offset, but return empty width
                fStyles->Iterate(fromOffset, 1, fInline, NULL, NULL, _ascent,
                        _descent);
                return 0.0;
        }

        float result = 0.0;
        float ascent = 0.0;
        float descent = 0.0;
        float maxAscent = 0.0;
        float maxDescent = 0.0;

        // iterate through the style runs
        const BFont* font = NULL;
        int32 numBytes;
        while ((numBytes = fStyles->Iterate(fromOffset, length, fInline, &font,
                        NULL, &ascent, &descent)) != 0) {
                maxAscent = std::max(ascent, maxAscent);
                maxDescent = std::max(descent, maxDescent);

#if USE_WIDTHBUFFER
                // Use _BWidthBuffer_ if possible
                if (BPrivate::gWidthBuffer != NULL) {
                        result += BPrivate::gWidthBuffer->StringWidth(*fText, fromOffset,
                                numBytes, font);
                } else {
#endif
                        const char* text = fText->GetString(fromOffset, &numBytes);
                        result += font->StringWidth(text, numBytes);

#if USE_WIDTHBUFFER
                }
#endif

                fromOffset += numBytes;
                length -= numBytes;
        }

        if (_ascent != NULL)
                *_ascent = maxAscent;
        if (_descent != NULL)
                *_descent = maxDescent;

        return result;
}


//!     Calculate the actual tab width for the given location.
float
BTextView::_ActualTabWidth(float location) const
{
        float tabWidth = fTabWidth - fmod(location, fTabWidth);
        if (round(tabWidth) == 0)
                tabWidth = fTabWidth;

        return tabWidth;
}


void
BTextView::_DoInsertText(const char* text, int32 length, int32 offset,
        const text_run_array* runs)
{
        _CancelInputMethod();

        if (fText->Length() + length > MaxBytes())
                return;

        if (fSelStart != fSelEnd)
                Select(fSelStart, fSelStart);

        const int32 textLength = fText->Length();
        if (offset > textLength)
                offset = textLength;

        // copy data into buffer
        InsertText(text, length, offset, runs);

        // recalc line breaks and draw the text
        _Refresh(offset, offset + length);
}


void
BTextView::_DoDeleteText(int32 fromOffset, int32 toOffset)
{
        CALLED();
}


void
BTextView::_DrawLine(BView* view, const int32 &lineNum,
        const int32 &startOffset, const bool &erase, BRect &eraseRect,
        BRegion &inputRegion)
{
        STELine* line = (*fLines)[lineNum];
        float startLeft = fTextRect.left;
        if (startOffset != -1) {
                if (ByteAt(startOffset) == B_ENTER) {
                        // StartOffset is a newline
                        startLeft = PointAt(line->offset).x;
                } else
                        startLeft = PointAt(startOffset).x;
        } else if (fAlignment != B_ALIGN_LEFT) {
                float alignmentOffset = fTextRect.Width() + 1 - LineWidth(lineNum);
                if (fAlignment == B_ALIGN_CENTER)
                        alignmentOffset = floorf(alignmentOffset / 2);
                startLeft += alignmentOffset;
        }

        int32 length = (line + 1)->offset;
        if (startOffset != -1)
                length -= startOffset;
        else
                length -= line->offset;

        // DrawString() chokes if you draw a newline
        if (ByteAt((line + 1)->offset - 1) == B_ENTER)
                length--;

        view->MovePenTo(startLeft,
                line->origin + line->ascent + fTextRect.top + 1);

        if (erase) {
                eraseRect.top = line->origin + fTextRect.top;
                eraseRect.bottom = (line + 1)->origin + fTextRect.top;
                view->FillRect(eraseRect, B_SOLID_LOW);
        }

        // do we have any text to draw?
        if (length <= 0)
                return;

        bool foundTab = false;
        int32 tabChars = 0;
        int32 numTabs = 0;
        int32 offset = startOffset != -1 ? startOffset : line->offset;
        const BFont* font = NULL;
        const rgb_color* color = NULL;
        int32 numBytes;
        drawing_mode defaultTextRenderingMode = DrawingMode();
        // iterate through each style on this line
        while ((numBytes = fStyles->Iterate(offset, length, fInline, &font,
                        &color)) != 0) {
                view->SetFont(font);
                view->SetHighColor(*color);

                tabChars = std::min(numBytes, length);
                do {
                        foundTab = fText->FindChar(B_TAB, offset, &tabChars);
                        if (foundTab) {
                                do {
                                        numTabs++;
                                        if (ByteAt(offset + tabChars + numTabs) != B_TAB)
                                                break;
                                } while ((tabChars + numTabs) < numBytes);
                        }

                        drawing_mode textRenderingMode = defaultTextRenderingMode;

                        if (inputRegion.CountRects() > 0
                                && ((offset <= fInline->Offset()
                                        && fInline->Offset() < offset + tabChars)
                                || (fInline->Offset() <= offset
                                        && offset < fInline->Offset() + fInline->Length()))) {

                                textRenderingMode = B_OP_OVER;

                                BRegion textRegion;
                                GetTextRegion(offset, offset + length, &textRegion);

                                textRegion.IntersectWith(&inputRegion);
                                view->PushState();

                                // Highlight in blue the inputted text
                                view->SetHighColor(kBlueInputColor);
                                view->FillRect(textRegion.Frame());

                                // Highlight in red the selected part
                                if (fInline->SelectionLength() > 0) {
                                        BRegion selectedRegion;
                                        GetTextRegion(fInline->Offset()
                                                + fInline->SelectionOffset(), fInline->Offset()
                                                + fInline->SelectionOffset()
                                                + fInline->SelectionLength(), &selectedRegion);

                                        textRegion.IntersectWith(&selectedRegion);

                                        view->SetHighColor(kRedInputColor);
                                        view->FillRect(textRegion.Frame());
                                }

                                view->PopState();
                        }

                        int32 size = tabChars;
                        const char* stringToDraw = fText->GetString(offset, &size);
                        view->SetDrawingMode(textRenderingMode);
                        view->DrawString(stringToDraw, size);

                        if (foundTab) {
                                float penPos = PenLocation().x - fTextRect.left;
                                switch (fAlignment) {
                                        default:
                                        case B_ALIGN_LEFT:
                                                // nothing more to do
                                                break;

                                        case B_ALIGN_RIGHT:
                                                // subtract distance from left to line
                                                penPos -= fTextRect.Width() - LineWidth(lineNum);
                                                break;

                                        case B_ALIGN_CENTER:
                                                // subtract half distance from left to line
                                                penPos -= floorf((fTextRect.Width() + 1
                                                        - LineWidth(lineNum)) / 2);
                                                break;
                                }
                                float tabWidth = _ActualTabWidth(penPos);

                                // add in the rest of the tabs (if there are any)
                                tabWidth += ((numTabs - 1) * fTabWidth);

                                // move pen by tab(s) width
                                view->MovePenBy(tabWidth, 0.0);
                                tabChars += numTabs;
                        }

                        offset += tabChars;
                        length -= tabChars;
                        numBytes -= tabChars;
                        tabChars = std::min(numBytes, length);
                        numTabs = 0;
                } while (foundTab && tabChars > 0);
        }
}


void
BTextView::_DrawLines(int32 startLine, int32 endLine, int32 startOffset,
        bool erase)
{
        if (!Window())
                return;

        const BRect bounds(Bounds());

        // clip the text extending to end of selection
        BRect clipRect(fTextRect);
        clipRect.left = std::min(fTextRect.left,
                bounds.left + fLayoutData->leftInset);
        clipRect.right = std::max(fTextRect.right,
                bounds.right - fLayoutData->rightInset);
        clipRect = bounds & clipRect;

        BRegion newClip;
        newClip.Set(clipRect);
        ConstrainClippingRegion(&newClip);

        // set the low color to the view color so that
        // drawing to a non-white background will work
        SetLowColor(ViewColor());

        BView* view = NULL;
        if (fOffscreen == NULL)
                view = this;
        else {
                fOffscreen->Lock();
                view = fOffscreen->ChildAt(0);
                view->SetLowColor(ViewColor());
                view->FillRect(view->Bounds(), B_SOLID_LOW);
        }

        long maxLine = fLines->NumLines() - 1;
        if (startLine < 0)
                startLine = 0;
        if (endLine > maxLine)
                endLine = maxLine;

        // TODO: See if we can avoid this
        if (fAlignment != B_ALIGN_LEFT)
                erase = true;

        BRect eraseRect = clipRect;
        int32 startEraseLine = startLine;
        STELine* line = (*fLines)[startLine];

        if (erase && startOffset != -1 && fAlignment == B_ALIGN_LEFT) {
                // erase only to the right of startOffset
                startEraseLine++;
                int32 startErase = startOffset;

                BPoint erasePoint = PointAt(startErase);
                eraseRect.left = erasePoint.x;
                eraseRect.top = erasePoint.y;
                eraseRect.bottom = (line + 1)->origin + fTextRect.top;

                view->FillRect(eraseRect, B_SOLID_LOW);

                eraseRect = clipRect;
        }

        BRegion inputRegion;
        if (fInline != NULL && fInline->IsActive()) {
                GetTextRegion(fInline->Offset(), fInline->Offset() + fInline->Length(),
                        &inputRegion);
        }

        //BPoint leftTop(startLeft, line->origin);
        for (int32 lineNum = startLine; lineNum <= endLine; lineNum++) {
                const bool eraseThisLine = erase && lineNum >= startEraseLine;
                _DrawLine(view, lineNum, startOffset, eraseThisLine, eraseRect,
                        inputRegion);
                startOffset = -1;
                        // Set this to -1 so the next iteration will use the line offset
        }

        // draw the caret/hilite the selection
        if (fActive) {
                if (fSelStart != fSelEnd) {
                        if (fSelectable)
                                Highlight(fSelStart, fSelEnd);
                } else {
                        if (fCaretVisible)
                                _DrawCaret(fSelStart, true);
                }
        }

        if (fOffscreen != NULL) {
                view->Sync();
                /*BPoint penLocation = view->PenLocation();
                BRect drawRect(leftTop.x, leftTop.y, penLocation.x, penLocation.y);
                DrawBitmap(fOffscreen, drawRect, drawRect);*/
                fOffscreen->Unlock();
        }

        ConstrainClippingRegion(NULL);
}


void
BTextView::_RequestDrawLines(int32 startLine, int32 endLine)
{
        if (!Window())
                return;

        long maxLine = fLines->NumLines() - 1;

        STELine* from = (*fLines)[startLine];
        STELine* to = endLine == maxLine ? NULL : (*fLines)[endLine + 1];
        BRect invalidRect(Bounds().left, from->origin + fTextRect.top,
                Bounds().right,
                to != NULL ? to->origin + fTextRect.top : fTextRect.bottom);
        Invalidate(invalidRect);
}


void
BTextView::_DrawCaret(int32 offset, bool visible)
{
        float lineHeight;
        BPoint caretPoint = PointAt(offset, &lineHeight);
        caretPoint.x = std::min(caretPoint.x, fTextRect.right);

        BRect caretRect;
        caretRect.left = caretRect.right = caretPoint.x;
        caretRect.top = caretPoint.y;
        caretRect.bottom = caretPoint.y + lineHeight - 1;

        if (visible)
                InvertRect(caretRect);
        else
                Invalidate(caretRect);
}


inline void
BTextView::_ShowCaret()
{
        if (fActive && !fCaretVisible && fEditable && fSelStart == fSelEnd)
                _InvertCaret();
}


inline void
BTextView::_HideCaret()
{
        if (fCaretVisible && fSelStart == fSelEnd)
                _InvertCaret();
}


//!     Hides the caret if it is being shown, and if it's hidden, shows it.
void
BTextView::_InvertCaret()
{
        fCaretVisible = !fCaretVisible;
        _DrawCaret(fSelStart, fCaretVisible);
        fCaretTime = system_time();
}


/*!     Place the dragging caret at the given offset.

        \param offset The offset (zero based within the object's text) where to
               place the dragging caret. If it's -1, hide the caret.
*/
void
BTextView::_DragCaret(int32 offset)
{
        // does the caret need to move?
        if (offset == fDragOffset)
                return;

        // hide the previous drag caret
        if (fDragOffset != -1)
                _DrawCaret(fDragOffset, false);

        // do we have a new location?
        if (offset != -1) {
                if (fActive) {
                        // ignore if offset is within active selection
                        if (offset >= fSelStart && offset <= fSelEnd) {
                                fDragOffset = -1;
                                return;
                        }
                }

                _DrawCaret(offset, true);
        }

        fDragOffset = offset;
}


void
BTextView::_StopMouseTracking()
{
        delete fTrackingMouse;
        fTrackingMouse = NULL;
}


bool
BTextView::_PerformMouseUp(BPoint where)
{
        if (fTrackingMouse == NULL)
                return false;

        if (fTrackingMouse->selectionRect.IsValid())
                Select(fTrackingMouse->clickOffset, fTrackingMouse->clickOffset);

        _StopMouseTracking();
        // adjust cursor if necessary
        _TrackMouse(where, NULL, true);

        return true;
}


bool
BTextView::_PerformMouseMoved(BPoint where, uint32 code)
{
        fWhere = where;

        if (fTrackingMouse == NULL)
                return false;

        int32 currentOffset = OffsetAt(where);
        if (fTrackingMouse->selectionRect.IsValid()) {
                // we are tracking the mouse for drag action, if the mouse has moved
                // to another index or more than three pixels from where it was clicked,
                // we initiate a drag now:
                if (currentOffset != fTrackingMouse->clickOffset
                        || fabs(fTrackingMouse->where.x - where.x) > 3
                        || fabs(fTrackingMouse->where.y - where.y) > 3) {
                        _StopMouseTracking();
                        _InitiateDrag();
                        return true;
                }
                return false;
        }

        switch (fClickCount) {
                case 3:
                        // triple click, extend selection linewise
                        if (currentOffset <= fTrackingMouse->anchor) {
                                fTrackingMouse->selStart
                                        = (*fLines)[_LineAt(currentOffset)]->offset;
                                fTrackingMouse->selEnd = fTrackingMouse->shiftDown
                                        ? fSelEnd
                                        : (*fLines)[_LineAt(fTrackingMouse->anchor) + 1]->offset;
                        } else {
                                fTrackingMouse->selStart
                                        = fTrackingMouse->shiftDown
                                                ? fSelStart
                                                : (*fLines)[_LineAt(fTrackingMouse->anchor)]->offset;
                                fTrackingMouse->selEnd
                                        = (*fLines)[_LineAt(currentOffset) + 1]->offset;
                        }
                        break;

                case 2:
                        // double click, extend selection wordwise
                        if (currentOffset <= fTrackingMouse->anchor) {
                                fTrackingMouse->selStart = _PreviousWordBoundary(currentOffset);
                                fTrackingMouse->selEnd
                                        = fTrackingMouse->shiftDown
                                                ? fSelEnd
                                                : _NextWordBoundary(fTrackingMouse->anchor);
                        } else {
                                fTrackingMouse->selStart
                                        = fTrackingMouse->shiftDown
                                                ? fSelStart
                                                : _PreviousWordBoundary(fTrackingMouse->anchor);
                                fTrackingMouse->selEnd = _NextWordBoundary(currentOffset);
                        }
                        break;

                default:
                        // new click, extend selection char by char
                        if (currentOffset <= fTrackingMouse->anchor) {
                                fTrackingMouse->selStart = currentOffset;
                                fTrackingMouse->selEnd
                                        = fTrackingMouse->shiftDown
                                                ? fSelEnd : fTrackingMouse->anchor;
                        } else {
                                fTrackingMouse->selStart
                                        = fTrackingMouse->shiftDown
                                                ? fSelStart : fTrackingMouse->anchor;
                                fTrackingMouse->selEnd = currentOffset;
                        }
                        break;
        }

        // position caret to follow the direction of the selection
        if (fTrackingMouse->selEnd != fSelEnd)
                fCaretOffset = fTrackingMouse->selEnd;
        else if (fTrackingMouse->selStart != fSelStart)
                fCaretOffset = fTrackingMouse->selStart;

        Select(fTrackingMouse->selStart, fTrackingMouse->selEnd);
        _TrackMouse(where, NULL);

        return true;
}


/*!     Tracks the mouse position, doing special actions like changing the
        view cursor.

        \param where The point where the mouse has moved.
        \param message The dragging message, if there is any.
        \param force Passed as second parameter of SetViewCursor()
*/
void
BTextView::_TrackMouse(BPoint where, const BMessage* message, bool force)
{
        BRegion textRegion;
        GetTextRegion(fSelStart, fSelEnd, &textRegion);

        if (message && AcceptsDrop(message))
                _TrackDrag(where);
        else if ((fSelectable || fEditable)
                && (fTrackingMouse != NULL || !textRegion.Contains(where))) {
                SetViewCursor(B_CURSOR_I_BEAM, force);
        } else
                SetViewCursor(B_CURSOR_SYSTEM_DEFAULT, force);
}


//!     Tracks the mouse position when the user is dragging some data.
void
BTextView::_TrackDrag(BPoint where)
{
        CALLED();
        if (Bounds().Contains(where))
                _DragCaret(OffsetAt(where));
}


//!     Initiates a drag operation.
void
BTextView::_InitiateDrag()
{
        BMessage dragMessage(B_MIME_DATA);
        BBitmap* dragBitmap = NULL;
        BPoint bitmapPoint;
        BHandler* dragHandler = NULL;

        GetDragParameters(&dragMessage, &dragBitmap, &bitmapPoint, &dragHandler);
        SetViewCursor(B_CURSOR_SYSTEM_DEFAULT);

        if (dragBitmap != NULL)
                DragMessage(&dragMessage, dragBitmap, bitmapPoint, dragHandler);
        else {
                BRegion region;
                GetTextRegion(fSelStart, fSelEnd, &region);
                BRect bounds = Bounds();
                BRect dragRect = region.Frame();
                if (!bounds.Contains(dragRect))
                        dragRect = bounds & dragRect;

                DragMessage(&dragMessage, dragRect, dragHandler);
        }

        BMessenger messenger(this);
        BMessage message(_DISPOSE_DRAG_);
        fDragRunner = new (nothrow) BMessageRunner(messenger, &message, 100000);
}


//!     Handles when some data is dropped on the view.
bool
BTextView::_MessageDropped(BMessage* message, BPoint where, BPoint offset)
{
        ASSERT(message);

        void* from = NULL;
        bool internalDrop = false;
        if (message->FindPointer("be:originator", &from) == B_OK
                        && from == this && fSelEnd != fSelStart)
                internalDrop = true;

        _DragCaret(-1);

        delete fDragRunner;
        fDragRunner = NULL;

        _TrackMouse(where, NULL);

        // are we sure we like this message?
        if (!AcceptsDrop(message))
                return false;

        int32 dropOffset = OffsetAt(where);
        if (dropOffset > fText->Length())
                dropOffset = fText->Length();

        // if this view initiated the drag, move instead of copy
        if (internalDrop) {
                // dropping onto itself?
                if (dropOffset >= fSelStart && dropOffset <= fSelEnd)
                        return true;
        }

        ssize_t dataLength = 0;
        const char* text = NULL;
        entry_ref ref;
        if (message->FindData("text/plain", B_MIME_TYPE, (const void**)&text,
                        &dataLength) == B_OK) {
                text_run_array* runArray = NULL;
                ssize_t runLength = 0;
                if (fStylable) {
                        message->FindData("application/x-vnd.Be-text_run_array",
                                B_MIME_TYPE, (const void**)&runArray, &runLength);
                }

                _FilterDisallowedChars((char*)text, dataLength, runArray);

                if (dataLength < 1) {
                        beep();
                        return true;
                }

                if (fUndo) {
                        delete fUndo;
                        fUndo = new DropUndoBuffer(this, text, dataLength, runArray,
                                runLength, dropOffset, internalDrop);
                }

                if (internalDrop) {
                        if (dropOffset > fSelEnd)
                                dropOffset -= dataLength;
                        Delete();
                }

                Insert(dropOffset, text, dataLength, runArray);
                if (IsFocus())
                        Select(dropOffset, dropOffset + dataLength);
        }

        return true;
}


void
BTextView::_PerformAutoScrolling()
{
        // Scroll the view a bit if mouse is outside the view bounds
        BRect bounds = Bounds();
        BPoint scrollBy(B_ORIGIN);

        // R5 does a pretty soft auto-scroll, we try to do the same by
        // simply scrolling the distance between cursor and border
        if (fWhere.x > bounds.right)
                scrollBy.x = fWhere.x - bounds.right;
        else if (fWhere.x < bounds.left)
                scrollBy.x = fWhere.x - bounds.left; // negative value

        // prevent horizontal scrolling if text rect is inside view rect
        if (fTextRect.left > bounds.left && fTextRect.right < bounds.right)
                scrollBy.x = 0;

        if (CountLines() > 1) {
                // scroll in Y only if multiple lines!
                if (fWhere.y > bounds.bottom)
                        scrollBy.y = fWhere.y - bounds.bottom;
                else if (fWhere.y < bounds.top)
                        scrollBy.y = fWhere.y - bounds.top; // negative value
        }

        // prevent vertical scrolling if text rect is inside view rect
        if (fTextRect.top > bounds.top && fTextRect.bottom < bounds.bottom)
                scrollBy.y = 0;

        if (scrollBy != B_ORIGIN)
                _ScrollBy(scrollBy.x, scrollBy.y);
}


//!     Updates the scrollbars associated with the object (if any).
void
BTextView::_UpdateScrollbars()
{
        BRect bounds(Bounds());
        BScrollBar* horizontalScrollBar = ScrollBar(B_HORIZONTAL);
        BScrollBar* verticalScrollBar = ScrollBar(B_VERTICAL);

        // do we have a horizontal scroll bar?
        if (horizontalScrollBar != NULL) {
                long viewWidth = bounds.IntegerWidth();
                long dataWidth = (long)ceilf(_TextWidth());

                long maxRange = dataWidth - viewWidth;
                maxRange = std::max(maxRange, 0l);

                horizontalScrollBar->SetRange(0, (float)maxRange);
                horizontalScrollBar->SetProportion((float)viewWidth
                        / (float)dataWidth);
                horizontalScrollBar->SetSteps(kHorizontalScrollBarStep,
                        dataWidth / 10);
        }

        // how about a vertical scroll bar?
        if (verticalScrollBar != NULL) {
                long viewHeight = bounds.IntegerHeight();
                long dataHeight = (long)ceilf(_TextHeight());

                long maxRange = dataHeight - viewHeight;
                maxRange = std::max(maxRange, 0l);

                verticalScrollBar->SetRange(0, maxRange);
                verticalScrollBar->SetProportion((float)viewHeight
                        / (float)dataHeight);
                verticalScrollBar->SetSteps(kVerticalScrollBarStep,
                        viewHeight);
        }
}


//!     Scrolls by the given offsets
void
BTextView::_ScrollBy(float horizontal, float vertical)
{
        BRect bounds = Bounds();
        _ScrollTo(bounds.left + horizontal, bounds.top + vertical);
}


//!     Scrolls to the given position, making sure not to scroll out of bounds.
void
BTextView::_ScrollTo(float x, float y)
{
        BRect bounds = Bounds();
        long viewWidth = bounds.IntegerWidth();
        long viewHeight = bounds.IntegerHeight();

        float minWidth = fTextRect.left - fLayoutData->leftInset;
        float maxWidth = fTextRect.right + fLayoutData->rightInset - viewWidth;
        float minHeight = fTextRect.top - fLayoutData->topInset;
        float maxHeight = fTextRect.bottom + fLayoutData->bottomInset - viewHeight;

        // set horizontal scroll limits
        if (x > maxWidth)
                x = maxWidth;
        if (x < minWidth)
                x = minWidth;

        // set vertical scroll limits
        if (y > maxHeight)
                y = maxHeight;
        if (y < minHeight)
                y = minHeight;

        ScrollTo(x, y);
}


//!     Autoresizes the view to fit the contained text.
void
BTextView::_AutoResize(bool redraw)
{
        if (!fResizable || fContainerView == NULL)
                return;

        // NOTE: This container view thing is only used by Tracker.
        // move container view if not left aligned
        float oldWidth = Bounds().Width();
        float newWidth = _TextWidth();
        float right = oldWidth - newWidth;

        if (fAlignment == B_ALIGN_CENTER)
                fContainerView->MoveBy(roundf(right / 2), 0);
        else if (fAlignment == B_ALIGN_RIGHT)
                fContainerView->MoveBy(right, 0);

        // resize container view
        float grow = newWidth - oldWidth;
        fContainerView->ResizeBy(grow, 0);

        // reposition text view
        fTextRect.OffsetTo(fLayoutData->leftInset, fLayoutData->topInset);

        // scroll rect to start, there is room for full text
        ScrollToOffset(0);

        if (redraw)
                _RequestDrawLines(0, 0);
}


//!     Creates a new offscreen BBitmap with an associated BView.
void
BTextView::_NewOffscreen(float padding)
{
        if (fOffscreen != NULL)
                _DeleteOffscreen();

#if USE_DOUBLEBUFFERING
        BRect bitmapRect(0, 0, fTextRect.Width() + padding, fTextRect.Height());
        fOffscreen = new BBitmap(bitmapRect, fColorSpace, true, false);
        if (fOffscreen != NULL && fOffscreen->Lock()) {
                BView* bufferView = new BView(bitmapRect, "drawing view", 0, 0);
                fOffscreen->AddChild(bufferView);
                fOffscreen->Unlock();
        }
#endif
}


//!     Deletes the textview's offscreen bitmap, if any.
void
BTextView::_DeleteOffscreen()
{
        if (fOffscreen != NULL && fOffscreen->Lock()) {
                delete fOffscreen;
                fOffscreen = NULL;
        }
}


/*!     Creates a new offscreen bitmap, highlight the selection, and set the
        cursor to \c B_CURSOR_I_BEAM.
*/
void
BTextView::_Activate()
{
        fActive = true;

        // Create a new offscreen BBitmap
        _NewOffscreen();

        if (fSelStart != fSelEnd) {
                if (fSelectable)
                        Highlight(fSelStart, fSelEnd);
        } else
                _ShowCaret();

        BPoint where;
        uint32 buttons;
        GetMouse(&where, &buttons, false);
        if (Bounds().Contains(where))
                _TrackMouse(where, NULL);

        if (Window() != NULL) {
                BMessage* message;

                if (!Window()->HasShortcut(B_LEFT_ARROW, B_COMMAND_KEY)
                        && !Window()->HasShortcut(B_RIGHT_ARROW, B_COMMAND_KEY)) {
                        message = new BMessage(kMsgNavigateArrow);
                        message->AddInt32("key", B_LEFT_ARROW);
                        message->AddInt32("modifiers", B_COMMAND_KEY);
                        Window()->AddShortcut(B_LEFT_ARROW, B_COMMAND_KEY, message, this);

                        message = new BMessage(kMsgNavigateArrow);
                        message->AddInt32("key", B_RIGHT_ARROW);
                        message->AddInt32("modifiers", B_COMMAND_KEY);
                        Window()->AddShortcut(B_RIGHT_ARROW, B_COMMAND_KEY, message, this);

                        fInstalledNavigateCommandWordwiseShortcuts = true;
                }
                if (!Window()->HasShortcut(B_LEFT_ARROW, B_COMMAND_KEY | B_SHIFT_KEY)
                        && !Window()->HasShortcut(B_RIGHT_ARROW,
                                B_COMMAND_KEY | B_SHIFT_KEY)) {
                        message = new BMessage(kMsgNavigateArrow);
                        message->AddInt32("key", B_LEFT_ARROW);
                        message->AddInt32("modifiers", B_COMMAND_KEY | B_SHIFT_KEY);
                        Window()->AddShortcut(B_LEFT_ARROW, B_COMMAND_KEY | B_SHIFT_KEY,
                                message, this);

                        message = new BMessage(kMsgNavigateArrow);
                        message->AddInt32("key", B_RIGHT_ARROW);
                        message->AddInt32("modifiers", B_COMMAND_KEY | B_SHIFT_KEY);
                        Window()->AddShortcut(B_RIGHT_ARROW, B_COMMAND_KEY | B_SHIFT_KEY,
                                message, this);

                        fInstalledSelectCommandWordwiseShortcuts = true;
                }
                if (!Window()->HasShortcut(B_DELETE, B_COMMAND_KEY)
                        && !Window()->HasShortcut(B_BACKSPACE, B_COMMAND_KEY)) {
                        message = new BMessage(kMsgRemoveWord);
                        message->AddInt32("key", B_DELETE);
                        message->AddInt32("modifiers", B_COMMAND_KEY);
                        Window()->AddShortcut(B_DELETE, B_COMMAND_KEY, message, this);

                        message = new BMessage(kMsgRemoveWord);
                        message->AddInt32("key", B_BACKSPACE);
                        message->AddInt32("modifiers", B_COMMAND_KEY);
                        Window()->AddShortcut(B_BACKSPACE, B_COMMAND_KEY, message, this);

                        fInstalledRemoveCommandWordwiseShortcuts = true;
                }

                if (!Window()->HasShortcut(B_LEFT_ARROW, B_OPTION_KEY)
                        && !Window()->HasShortcut(B_RIGHT_ARROW, B_OPTION_KEY)) {
                        message = new BMessage(kMsgNavigateArrow);
                        message->AddInt32("key", B_LEFT_ARROW);
                        message->AddInt32("modifiers", B_OPTION_KEY);
                        Window()->AddShortcut(B_LEFT_ARROW, B_OPTION_KEY, message, this);

                        message = new BMessage(kMsgNavigateArrow);
                        message->AddInt32("key", B_RIGHT_ARROW);
                        message->AddInt32("modifiers", B_OPTION_KEY);
                        Window()->AddShortcut(B_RIGHT_ARROW, B_OPTION_KEY, message, this);

                        fInstalledNavigateOptionWordwiseShortcuts = true;
                }
                if (!Window()->HasShortcut(B_LEFT_ARROW, B_OPTION_KEY | B_SHIFT_KEY)
                        && !Window()->HasShortcut(B_RIGHT_ARROW,
                                B_OPTION_KEY | B_SHIFT_KEY)) {
                        message = new BMessage(kMsgNavigateArrow);
                        message->AddInt32("key", B_LEFT_ARROW);
                        message->AddInt32("modifiers", B_OPTION_KEY | B_SHIFT_KEY);
                        Window()->AddShortcut(B_LEFT_ARROW, B_OPTION_KEY | B_SHIFT_KEY,
                                message, this);

                        message = new BMessage(kMsgNavigateArrow);
                        message->AddInt32("key", B_RIGHT_ARROW);
                        message->AddInt32("modifiers", B_OPTION_KEY | B_SHIFT_KEY);
                        Window()->AddShortcut(B_RIGHT_ARROW, B_OPTION_KEY | B_SHIFT_KEY,
                                message, this);

                        fInstalledSelectOptionWordwiseShortcuts = true;
                }
                if (!Window()->HasShortcut(B_DELETE, B_OPTION_KEY)
                        && !Window()->HasShortcut(B_BACKSPACE, B_OPTION_KEY)) {
                        message = new BMessage(kMsgRemoveWord);
                        message->AddInt32("key", B_DELETE);
                        message->AddInt32("modifiers", B_OPTION_KEY);
                        Window()->AddShortcut(B_DELETE, B_OPTION_KEY, message, this);

                        message = new BMessage(kMsgRemoveWord);
                        message->AddInt32("key", B_BACKSPACE);
                        message->AddInt32("modifiers", B_OPTION_KEY);
                        Window()->AddShortcut(B_BACKSPACE, B_OPTION_KEY, message, this);

                        fInstalledRemoveOptionWordwiseShortcuts = true;
                }

                if (!Window()->HasShortcut(B_UP_ARROW, B_OPTION_KEY)
                        && !Window()->HasShortcut(B_DOWN_ARROW, B_OPTION_KEY)) {
                        message = new BMessage(kMsgNavigateArrow);
                        message->AddInt32("key", B_UP_ARROW);
                        message->AddInt32("modifiers", B_OPTION_KEY);
                        Window()->AddShortcut(B_UP_ARROW, B_OPTION_KEY, message, this);

                        message = new BMessage(kMsgNavigateArrow);
                        message->AddInt32("key", B_DOWN_ARROW);
                        message->AddInt32("modifiers", B_OPTION_KEY);
                        Window()->AddShortcut(B_DOWN_ARROW, B_OPTION_KEY, message, this);

                        fInstalledNavigateOptionLinewiseShortcuts = true;
                }
                if (!Window()->HasShortcut(B_UP_ARROW, B_OPTION_KEY | B_SHIFT_KEY)
                        && !Window()->HasShortcut(B_DOWN_ARROW,
                                B_OPTION_KEY | B_SHIFT_KEY)) {
                        message = new BMessage(kMsgNavigateArrow);
                        message->AddInt32("key", B_UP_ARROW);
                        message->AddInt32("modifiers", B_OPTION_KEY | B_SHIFT_KEY);
                        Window()->AddShortcut(B_UP_ARROW, B_OPTION_KEY | B_SHIFT_KEY,
                                message, this);

                        message = new BMessage(kMsgNavigateArrow);
                        message->AddInt32("key", B_DOWN_ARROW);
                        message->AddInt32("modifiers", B_OPTION_KEY | B_SHIFT_KEY);
                        Window()->AddShortcut(B_DOWN_ARROW, B_OPTION_KEY | B_SHIFT_KEY,
                                message, this);

                        fInstalledSelectOptionLinewiseShortcuts = true;
                }

                if (!Window()->HasShortcut(B_HOME, B_COMMAND_KEY)
                        && !Window()->HasShortcut(B_END, B_COMMAND_KEY)) {
                        message = new BMessage(kMsgNavigatePage);
                        message->AddInt32("key", B_HOME);
                        message->AddInt32("modifiers", B_COMMAND_KEY);
                        Window()->AddShortcut(B_HOME, B_COMMAND_KEY, message, this);

                        message = new BMessage(kMsgNavigatePage);
                        message->AddInt32("key", B_END);
                        message->AddInt32("modifiers", B_COMMAND_KEY);
                        Window()->AddShortcut(B_END, B_COMMAND_KEY, message, this);

                        fInstalledNavigateHomeEndDocwiseShortcuts = true;
                }
                if (!Window()->HasShortcut(B_HOME, B_COMMAND_KEY | B_SHIFT_KEY)
                        && !Window()->HasShortcut(B_END, B_COMMAND_KEY | B_SHIFT_KEY)) {
                        message = new BMessage(kMsgNavigatePage);
                        message->AddInt32("key", B_HOME);
                        message->AddInt32("modifiers", B_COMMAND_KEY | B_SHIFT_KEY);
                        Window()->AddShortcut(B_HOME, B_COMMAND_KEY | B_SHIFT_KEY,
                                message, this);

                        message = new BMessage(kMsgNavigatePage);
                        message->AddInt32("key", B_END);
                        message->AddInt32("modifiers", B_COMMAND_KEY | B_SHIFT_KEY);
                        Window()->AddShortcut(B_END, B_COMMAND_KEY | B_SHIFT_KEY,
                                message, this);

                        fInstalledSelectHomeEndDocwiseShortcuts = true;
                }
        }
}


//!     Unhilights the selection, set the cursor to \c B_CURSOR_SYSTEM_DEFAULT.
void
BTextView::_Deactivate()
{
        fActive = false;

        _CancelInputMethod();
        _DeleteOffscreen();

        if (fSelStart != fSelEnd) {
                if (fSelectable)
                        Highlight(fSelStart, fSelEnd);
        } else
                _HideCaret();

        if (Window() != NULL) {
                if (fInstalledNavigateCommandWordwiseShortcuts) {
                        Window()->RemoveShortcut(B_LEFT_ARROW, B_COMMAND_KEY);
                        Window()->RemoveShortcut(B_RIGHT_ARROW, B_COMMAND_KEY);
                        fInstalledNavigateCommandWordwiseShortcuts = false;
                }
                if (fInstalledSelectCommandWordwiseShortcuts) {
                        Window()->RemoveShortcut(B_LEFT_ARROW, B_COMMAND_KEY | B_SHIFT_KEY);
                        Window()->RemoveShortcut(B_RIGHT_ARROW,
                                B_COMMAND_KEY | B_SHIFT_KEY);
                        fInstalledSelectCommandWordwiseShortcuts = false;
                }
                if (fInstalledRemoveCommandWordwiseShortcuts) {
                        Window()->RemoveShortcut(B_DELETE, B_COMMAND_KEY);
                        Window()->RemoveShortcut(B_BACKSPACE, B_COMMAND_KEY);
                        fInstalledRemoveCommandWordwiseShortcuts = false;
                }

                if (fInstalledNavigateOptionWordwiseShortcuts) {
                        Window()->RemoveShortcut(B_LEFT_ARROW, B_OPTION_KEY);
                        Window()->RemoveShortcut(B_RIGHT_ARROW, B_OPTION_KEY);
                        fInstalledNavigateOptionWordwiseShortcuts = false;
                }
                if (fInstalledSelectOptionWordwiseShortcuts) {
                        Window()->RemoveShortcut(B_LEFT_ARROW, B_OPTION_KEY | B_SHIFT_KEY);
                        Window()->RemoveShortcut(B_RIGHT_ARROW, B_OPTION_KEY | B_SHIFT_KEY);
                        fInstalledSelectOptionWordwiseShortcuts = false;
                }
                if (fInstalledRemoveOptionWordwiseShortcuts) {
                        Window()->RemoveShortcut(B_DELETE, B_OPTION_KEY);
                        Window()->RemoveShortcut(B_BACKSPACE, B_OPTION_KEY);
                        fInstalledRemoveOptionWordwiseShortcuts = false;
                }

                if (fInstalledNavigateOptionLinewiseShortcuts) {
                        Window()->RemoveShortcut(B_UP_ARROW, B_OPTION_KEY);
                        Window()->RemoveShortcut(B_DOWN_ARROW, B_OPTION_KEY);
                        fInstalledNavigateOptionLinewiseShortcuts = false;
                }
                if (fInstalledSelectOptionLinewiseShortcuts) {
                        Window()->RemoveShortcut(B_UP_ARROW, B_OPTION_KEY | B_SHIFT_KEY);
                        Window()->RemoveShortcut(B_DOWN_ARROW, B_OPTION_KEY | B_SHIFT_KEY);
                        fInstalledSelectOptionLinewiseShortcuts = false;
                }

                if (fInstalledNavigateHomeEndDocwiseShortcuts) {
                        Window()->RemoveShortcut(B_HOME, B_COMMAND_KEY);
                        Window()->RemoveShortcut(B_END, B_COMMAND_KEY);
                        fInstalledNavigateHomeEndDocwiseShortcuts = false;
                }
                if (fInstalledSelectHomeEndDocwiseShortcuts) {
                        Window()->RemoveShortcut(B_HOME, B_COMMAND_KEY | B_SHIFT_KEY);
                        Window()->RemoveShortcut(B_END, B_COMMAND_KEY | B_SHIFT_KEY);
                        fInstalledSelectHomeEndDocwiseShortcuts = false;
                }
        }
}


/*!     Changes the passed in font to be displayable by the object.

        Set font rotation to 0, removes any font flag, set font spacing
        to \c B_BITMAP_SPACING and font encoding to \c B_UNICODE_UTF8.
*/
void
BTextView::_NormalizeFont(BFont* font)
{
        if (font) {
                font->SetRotation(0.0f);
                font->SetFlags(0);
                font->SetSpacing(B_BITMAP_SPACING);
                font->SetEncoding(B_UNICODE_UTF8);
        }
}


void
BTextView::_SetRunArray(int32 startOffset, int32 endOffset,
        const text_run_array* runs)
{
        const int32 numStyles = runs->count;
        if (numStyles > 0) {
                const text_run* theRun = &runs->runs[0];
                for (int32 index = 0; index < numStyles; index++) {
                        int32 fromOffset = theRun->offset + startOffset;
                        int32 toOffset = endOffset;
                        if (index + 1 < numStyles) {
                                toOffset = (theRun + 1)->offset + startOffset;
                                toOffset = (toOffset > endOffset) ? endOffset : toOffset;
                        }

                        _ApplyStyleRange(fromOffset, toOffset, B_FONT_ALL, &theRun->font,
                                &theRun->color, false);

                        theRun++;
                }
                fStyles->InvalidateNullStyle();
        }
}


/*!     Returns the character class of the character at the given offset.

        \param offset The offset where the wanted character can be found.

        \return A value which represents the character's classification.
*/
uint32
BTextView::_CharClassification(int32 offset) const
{
        // TODO: Should check against a list of characters containing also
        // japanese word breakers.
        // And what about other languages ? Isn't there a better way to check
        // for separator characters ?
        // Andrew suggested to have a look at UnicodeBlockObject.h
        switch (fText->RealCharAt(offset)) {
                case '\0':
                        return CHAR_CLASS_END_OF_TEXT;

                case B_SPACE:
                case B_TAB:
                case B_ENTER:
                        return CHAR_CLASS_WHITESPACE;

                case '=':
                case '+':
                case '@':
                case '#':
                case '$':
                case '%':
                case '^':
                case '&':
                case '*':
                case '\\':
                case '|':
                case '<':
                case '>':
                case '/':
                case '~':
                        return CHAR_CLASS_GRAPHICAL;

                case '\'':
                case '"':
                        return CHAR_CLASS_QUOTE;

                case ',':
                case '.':
                case '?':
                case '!':
                case ';':
                case ':':
                case '-':
                        return CHAR_CLASS_PUNCTUATION;

                case '(':
                case '[':
                case '{':
                        return CHAR_CLASS_PARENS_OPEN;

                case ')':
                case ']':
                case '}':
                        return CHAR_CLASS_PARENS_CLOSE;

                default:
                        return CHAR_CLASS_DEFAULT;
        }
}


/*!     Returns the offset of the next UTF-8 character.

        \param offset The offset where to start looking.

        \return The offset of the next UTF-8 character.
*/
int32
BTextView::_NextInitialByte(int32 offset) const
{
        if (offset >= fText->Length())
                return offset;

        for (++offset; (ByteAt(offset) & 0xC0) == 0x80; ++offset)
                ;

        return offset;
}


/*!     Returns the offset of the previous UTF-8 character.

        \param offset The offset where to start looking.

        \return The offset of the previous UTF-8 character.
*/
int32
BTextView::_PreviousInitialByte(int32 offset) const
{
        if (offset <= 0)
                return 0;

        int32 count = 6;

        for (--offset; offset > 0 && count; --offset, --count) {
                if ((ByteAt(offset) & 0xC0) != 0x80)
                        break;
        }

        return count ? offset : 0;
}


bool
BTextView::_GetProperty(BMessage* message, BMessage* specifier,
        const char* property, BMessage* reply)
{
        CALLED();
        if (strcmp(property, "selection") == 0) {
                reply->what = B_REPLY;
                reply->AddInt32("result", fSelStart);
                reply->AddInt32("result", fSelEnd);
                reply->AddInt32("error", B_OK);

                return true;
        } else if (strcmp(property, "Text") == 0) {
                if (IsTypingHidden()) {
                        // Do not allow stealing passwords via scripting
                        beep();
                        return false;
                }

                int32 index, range;
                specifier->FindInt32("index", &index);
                specifier->FindInt32("range", &range);

                char* buffer = new char[range + 1];
                GetText(index, range, buffer);

                reply->what = B_REPLY;
                reply->AddString("result", buffer);
                reply->AddInt32("error", B_OK);

                delete[] buffer;

                return true;
        } else if (strcmp(property, "text_run_array") == 0)
                return false;

        return false;
}


bool
BTextView::_SetProperty(BMessage* message, BMessage* specifier,
        const char* property, BMessage* reply)
{
        CALLED();
        if (strcmp(property, "selection") == 0) {
                int32 index, range;

                specifier->FindInt32("index", &index);
                specifier->FindInt32("range", &range);

                Select(index, index + range);

                reply->what = B_REPLY;
                reply->AddInt32("error", B_OK);

                return true;
        } else if (strcmp(property, "Text") == 0) {
                int32 index, range;
                specifier->FindInt32("index", &index);
                specifier->FindInt32("range", &range);

                const char* buffer = NULL;
                if (message->FindString("data", &buffer) == B_OK) {
                        InsertText(buffer, range, index, NULL);
                        _Refresh(index, index + range);
                } else {
                        DeleteText(index, index + range);
                        _Refresh(index, index);
                }

                reply->what = B_REPLY;
                reply->AddInt32("error", B_OK);

                return true;
        } else if (strcmp(property, "text_run_array") == 0)
                return false;

        return false;
}


bool
BTextView::_CountProperties(BMessage* message, BMessage* specifier,
        const char* property, BMessage* reply)
{
        CALLED();
        if (strcmp(property, "Text") == 0) {
                reply->what = B_REPLY;
                reply->AddInt32("result", fText->Length());
                reply->AddInt32("error", B_OK);
                return true;
        }

        return false;
}


//!     Called when the object receives a \c B_INPUT_METHOD_CHANGED message.
void
BTextView::_HandleInputMethodChanged(BMessage* message)
{
        // TODO: block input if not editable (Andrew)
        ASSERT(fInline != NULL);

        const char* string = NULL;
        if (message->FindString("be:string", &string) < B_OK || string == NULL)
                return;

        _HideCaret();

        if (IsFocus())
                be_app->ObscureCursor();

        // If we find the "be:confirmed" boolean (and the boolean is true),
        // it means it's over for now, so the current InlineInput object
        // should become inactive. We will probably receive a
        // B_INPUT_METHOD_STOPPED message after this one.
        bool confirmed;
        if (message->FindBool("be:confirmed", &confirmed) != B_OK)
                confirmed = false;

        // Delete the previously inserted text (if any)
        if (fInline->IsActive()) {
                const int32 oldOffset = fInline->Offset();
                DeleteText(oldOffset, oldOffset + fInline->Length());
                if (confirmed)
                        fInline->SetActive(false);
                fCaretOffset = fSelStart = fSelEnd = oldOffset;
        }

        const int32 stringLen = strlen(string);

        fInline->SetOffset(fSelStart);
        fInline->SetLength(stringLen);
        fInline->ResetClauses();

        if (!confirmed && !fInline->IsActive())
                fInline->SetActive(true);

        // Get the clauses, and pass them to the InlineInput object
        // TODO: Find out if what we did it's ok, currently we don't consider
        // clauses at all, while the bebook says we should; though the visual
        // effect we obtained seems correct. Weird.
        int32 clauseCount = 0;
        int32 clauseStart;
        int32 clauseEnd;
        while (message->FindInt32("be:clause_start", clauseCount, &clauseStart)
                        == B_OK
                && message->FindInt32("be:clause_end", clauseCount, &clauseEnd)
                        == B_OK) {
                if (!fInline->AddClause(clauseStart, clauseEnd))
                        break;
                clauseCount++;
        }

        if (confirmed) {
                _Refresh(fSelStart, fSelEnd, fSelEnd);
                _ShowCaret();

                // now we need to feed ourselves the individual characters as if the
                // user would have pressed them now - this lets KeyDown() pick out all
                // the special characters like B_BACKSPACE, cursor keys and the like:
                const char* currPos = string;
                const char* prevPos = currPos;
                while (*currPos != '\0') {
                        if ((*currPos & 0xC0) == 0xC0) {
                                // found the start of an UTF-8 char, we collect while it lasts
                                ++currPos;
                                while ((*currPos & 0xC0) == 0x80)
                                        ++currPos;
                        } else if ((*currPos & 0xC0) == 0x80) {
                                // illegal: character starts with utf-8 intermediate byte,
                                // skip it
                                prevPos = ++currPos;
                        } else {
                                // single byte character/code, just feed that
                                ++currPos;
                        }
                        KeyDown(prevPos, currPos - prevPos);
                        prevPos = currPos;
                }

                _Refresh(fSelStart, fSelEnd, fSelEnd);
        } else {
                // temporarily show transient state of inline input
                int32 selectionStart = 0;
                int32 selectionEnd = 0;
                message->FindInt32("be:selection", 0, &selectionStart);
                message->FindInt32("be:selection", 1, &selectionEnd);

                fInline->SetSelectionOffset(selectionStart);
                fInline->SetSelectionLength(selectionEnd - selectionStart);

                const int32 inlineOffset = fInline->Offset();
                InsertText(string, stringLen, fSelStart, NULL);

                _Refresh(inlineOffset, fSelEnd, fSelEnd);
                _ShowCaret();
        }
}


/*!     Called when the object receives a \c B_INPUT_METHOD_LOCATION_REQUEST
        message.
*/
void
BTextView::_HandleInputMethodLocationRequest()
{
        ASSERT(fInline != NULL);

        int32 offset = fInline->Offset();
        const int32 limit = offset + fInline->Length();

        BMessage message(B_INPUT_METHOD_EVENT);
        message.AddInt32("be:opcode", B_INPUT_METHOD_LOCATION_REQUEST);

        // Add the location of the UTF8 characters
        while (offset < limit) {
                float height;
                BPoint where = PointAt(offset, &height);
                ConvertToScreen(&where);

                message.AddPoint("be:location_reply", where);
                message.AddFloat("be:height_reply", height);

                offset = _NextInitialByte(offset);
        }

        fInline->Method()->SendMessage(&message);
}


//!     Tells the Input Server method add-on to stop the current transaction.
void
BTextView::_CancelInputMethod()
{
        if (!fInline)
                return;

        InlineInput* inlineInput = fInline;
        fInline = NULL;

        if (inlineInput->IsActive() && Window()) {
                _Refresh(inlineInput->Offset(), fText->Length()
                        - inlineInput->Offset());

                BMessage message(B_INPUT_METHOD_EVENT);
                message.AddInt32("be:opcode", B_INPUT_METHOD_STOPPED);
                inlineInput->Method()->SendMessage(&message);
        }

        delete inlineInput;
}


/*!     Returns the line number of the character at the given \a offset.

        \note This will never return the last line (use LineAt() if you
              need to be correct about that.) N.B.

        \param offset The offset of the wanted character.

        \return The line number of the character at the given \a offset as an int32.
*/
int32
BTextView::_LineAt(int32 offset) const
{
        return fLines->OffsetToLine(offset);
}


/*!     Returns the line number that the given \a point is on.

        \note This will never return the last line (use LineAt() if you
              need to be correct about that.) N.B.

        \param point The \a point the get the line number of.

        \return The line number of the given \a point as an int32.
*/
int32
BTextView::_LineAt(const BPoint& point) const
{
        return fLines->PixelToLine(point.y - fTextRect.top);
}


/*!     Returns whether or not the given \a offset is on the empty line at the end
        of the buffer.
*/
bool
BTextView::_IsOnEmptyLastLine(int32 offset) const
{
        return (offset == fText->Length() && offset > 0
                && fText->RealCharAt(offset - 1) == B_ENTER);
}


void
BTextView::_ApplyStyleRange(int32 fromOffset, int32 toOffset, uint32 mode,
        const BFont* font, const rgb_color* color, bool syncNullStyle)
{
        BFont normalized;
                // Declared before the if so it stays allocated until the call to
                // SetStyleRange
        if (font != NULL) {
                // if a font has been given, normalize it
                normalized = *font;
                _NormalizeFont(&normalized);
                font = &normalized;
        }

        if (!fStylable) {
                // always apply font and color to full range for non-stylable textviews
                fromOffset = 0;
                toOffset = fText->Length();
        }

        if (syncNullStyle)
                fStyles->SyncNullStyle(fromOffset);

        fStyles->SetStyleRange(fromOffset, toOffset, fText->Length(), mode,
                font, color);
}


float
BTextView::_NullStyleHeight() const
{
        const BFont* font = NULL;
        fStyles->GetNullStyle(&font, NULL);

        font_height fontHeight;
        font->GetHeight(&fontHeight);
        return ceilf(fontHeight.ascent + fontHeight.descent + 1);
}


void
BTextView::_ShowContextMenu(BPoint where)
{
        bool isRedo;
        undo_state state = UndoState(&isRedo);
        bool isUndo = state != B_UNDO_UNAVAILABLE && !isRedo;

        int32 start;
        int32 finish;
        GetSelection(&start, &finish);

        bool canEdit = IsEditable();
        int32 length = fText->Length();

        BPopUpMenu* menu = new BPopUpMenu(B_EMPTY_STRING, false, false);

        BLayoutBuilder::Menu<>(menu)
                .AddItem(TRANSLATE("Undo"), B_UNDO/*, 'Z'*/)
                        .SetEnabled(canEdit && isUndo)
                .AddItem(TRANSLATE("Redo"), B_UNDO/*, 'Z', B_SHIFT_KEY*/)
                        .SetEnabled(canEdit && isRedo)
                .AddSeparator()
                .AddItem(TRANSLATE("Cut"), B_CUT, 'X')
                        .SetEnabled(canEdit && start != finish)
                .AddItem(TRANSLATE("Copy"), B_COPY, 'C')
                        .SetEnabled(start != finish)
                .AddItem(TRANSLATE("Paste"), B_PASTE, 'V')
                        .SetEnabled(canEdit && be_clipboard->SystemCount() > 0)
                .AddSeparator()
                .AddItem(TRANSLATE("Select all"), B_SELECT_ALL, 'A')
                        .SetEnabled(!(start == 0 && finish == length))
        ;

        menu->SetTargetForItems(this);
        ConvertToScreen(&where);
        menu->Go(where, true, true,     true);
}


void
BTextView::_FilterDisallowedChars(char* text, ssize_t& length,
        text_run_array* runArray)
{
        if (!fDisallowedChars)
                return;

        if (fDisallowedChars->IsEmpty() || !text)
                return;

        ssize_t stringIndex = 0;
        if (runArray) {
                ssize_t remNext = 0;

                for (int i = 0; i < runArray->count; i++) {
                        runArray->runs[i].offset -= remNext;
                        while (stringIndex < runArray->runs[i].offset
                                && stringIndex < length) {
                                if (fDisallowedChars->HasItem(
                                        reinterpret_cast<void*>(text[stringIndex]))) {
                                        memmove(text + stringIndex, text + stringIndex + 1,
                                                length - stringIndex - 1);
                                        length--;
                                        runArray->runs[i].offset--;
                                        remNext++;
                                } else
                                        stringIndex++;
                        }
                }
        }

        while (stringIndex < length) {
                if (fDisallowedChars->HasItem(
                        reinterpret_cast<void*>(text[stringIndex]))) {
                        memmove(text + stringIndex, text + stringIndex + 1,
                                length - stringIndex - 1);
                        length--;
                } else
                        stringIndex++;
        }
}


void
BTextView::_UpdateInsets(const BRect& rect)
{
        // do not update insets if SetInsets() was called
        if (fLayoutData->overridden)
                return;

        const BRect& bounds = Bounds();

        // we disallow negative insets, as they would cause parts of the
        // text to be hidden
        fLayoutData->leftInset = rect.left >= bounds.left
                ? rect.left - bounds.left : 0;
        fLayoutData->topInset = rect.top >= bounds.top
                ? rect.top - bounds.top : 0;
        fLayoutData->rightInset = bounds.right >= rect.right
                ? bounds.right - rect.right : 0;
        fLayoutData->bottomInset = bounds.bottom >= rect.bottom
                ? bounds.bottom - rect.bottom : 0;

        // only add default insets if text rect is set to bounds
        if (rect == bounds && (fEditable || fSelectable)) {
                float hPadding = be_control_look->DefaultLabelSpacing();
                float hInset = floorf(hPadding / 2.0f);
                float vInset = 1;
                fLayoutData->leftInset += hInset;
                fLayoutData->topInset += vInset;
                fLayoutData->rightInset += hInset;
                fLayoutData->bottomInset += vInset;
        }
}


float
BTextView::_ViewWidth()
{
        return Bounds().Width()
                - fLayoutData->leftInset
                - fLayoutData->rightInset;
}


float
BTextView::_ViewHeight()
{
        return Bounds().Height()
                - fLayoutData->topInset
                - fLayoutData->bottomInset;
}


BRect
BTextView::_ViewRect()
{
        BRect rect(Bounds());
        rect.left += fLayoutData->leftInset;
        rect.top += fLayoutData->topInset;
        rect.right -= fLayoutData->rightInset;
        rect.bottom -= fLayoutData->bottomInset;

        return rect;
}


float
BTextView::_TextWidth()
{
        return fTextRect.Width()
                + fLayoutData->leftInset
                + fLayoutData->rightInset;
}


float
BTextView::_TextHeight()
{
        return fTextRect.Height()
                + fLayoutData->topInset
                + fLayoutData->bottomInset;
}


BRect
BTextView::_TextRect()
{
        BRect rect(fTextRect);
        rect.left -= fLayoutData->leftInset;
        rect.top -= fLayoutData->topInset;
        rect.right += fLayoutData->rightInset;
        rect.bottom += fLayoutData->bottomInset;

        return rect;
}


float
BTextView::_UneditableTint() const
{
        return ui_color(B_DOCUMENT_BACKGROUND_COLOR).IsLight() ? B_DARKEN_1_TINT : 0.853;
}


// #pragma mark - BTextView::TextTrackState


BTextView::TextTrackState::TextTrackState(BMessenger messenger)
        :
        clickOffset(0),
        shiftDown(false),
        anchor(0),
        selStart(0),
        selEnd(0),
        fRunner(NULL)
{
        BMessage message(_PING_);
        const bigtime_t scrollSpeed = 25 * 1000;        // 40 scroll steps per second
        fRunner = new (nothrow) BMessageRunner(messenger, &message, scrollSpeed);
}


BTextView::TextTrackState::~TextTrackState()
{
        delete fRunner;
}


void
BTextView::TextTrackState::SimulateMouseMovement(BTextView* textView)
{
        BPoint where;
        uint32 buttons;
        // When the mouse cursor is still and outside the textview,
        // no B_MOUSE_MOVED message are sent, obviously. But scrolling
        // has to work neverthless, so we "fake" a MouseMoved() call here.
        textView->GetMouse(&where, &buttons);
        textView->_PerformMouseMoved(where, B_INSIDE_VIEW);
}


// #pragma mark - Binary ABI compat


extern "C" void
B_IF_GCC_2(InvalidateLayout__9BTextViewb,  _ZN9BTextView16InvalidateLayoutEb)(
        BTextView* view, bool descendants)
{
        perform_data_layout_invalidated data;
        data.descendants = descendants;

        view->Perform(PERFORM_CODE_LAYOUT_INVALIDATED, &data);
}