/*
 * Copyright 2006-2009, Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Ingo Weinhold <bonefish@cs.tu-berlin.de>
 *              Stephan Aßmus <superstippi@gmx.de>
 */

#include "ScrollView.h"

#include <algorithm>
#include <stdio.h>
#include <string.h>

#include <Bitmap.h>
#ifdef __HAIKU__
#  include <LayoutUtils.h>
#endif
#include <Message.h>
#include <ScrollBar.h>
#include <Window.h>

#include "Scrollable.h"
#include "ScrollCornerBitmaps.h"

using namespace std;

// #pragma mark - InternalScrollBar

class InternalScrollBar : public BScrollBar {
 public:
                                                                InternalScrollBar(ScrollView* scrollView,
                                                                                                  BRect frame,
                                                                                                  orientation posture);
        virtual                                         ~InternalScrollBar();

        virtual void                            ValueChanged(float value);

        virtual void                            MouseDown(BPoint where);
        virtual void                            MouseUp(BPoint where);

 private:
        ScrollView*                                     fScrollView;
};

// constructor
InternalScrollBar::InternalScrollBar(ScrollView* scrollView, BRect frame,
                                                                         orientation posture)
        : BScrollBar(frame, NULL, NULL, 0, 0, posture),
          fScrollView(scrollView)
{
}

// destructor
InternalScrollBar::~InternalScrollBar()
{
}

// ValueChanged
void
InternalScrollBar::ValueChanged(float value)
{
        // Notify our parent scroll view. Note: the value already has changed,
        // so that we can't check, if it really has changed.
        if (fScrollView)
                fScrollView->_ScrollValueChanged(this, value);
}

// MouseDown
void
InternalScrollBar::MouseDown(BPoint where)
{
        if (fScrollView)
                fScrollView->_SetScrolling(true);
        BScrollBar::MouseDown(where);
}

// MouseUp
void
InternalScrollBar::MouseUp(BPoint where)
{
        BScrollBar::MouseUp(where);
        if (fScrollView)
                fScrollView->_SetScrolling(false);
}



// #pragma mark -ScrollCorner

class ScrollCorner : public BView {
 public:
                                                                ScrollCorner(ScrollView* scrollView);
        virtual                                         ~ScrollCorner();

        virtual void                            MouseDown(BPoint point);
        virtual void                            MouseUp(BPoint point);
        virtual void                            MouseMoved(BPoint point, uint32 transit,
                                                                                   const BMessage* message);

        virtual void                            Draw(BRect updateRect);
        virtual void                            WindowActivated(bool active);

                        void                            SetActive(bool active);
        inline  bool                            IsActive() const
                                                                        { return fState & STATE_ACTIVE; }

 private:
                        ScrollView*                     fScrollView;
                        uint32                          fState;
                        BPoint                          fStartPoint;
                        BPoint                          fStartScrollOffset;
                        BBitmap*                        fBitmaps[3];

        inline  bool                            IsEnabled() const
                                                                        { return ((fState & STATE_ENABLED) ==
                                                                                          STATE_ENABLED); }

                        void                            SetDragging(bool dragging);
        inline  bool                            IsDragging() const
                                                                        { return (fState & STATE_DRAGGING); }

        enum {
                STATE_DRAGGING                  = 0x01,
                STATE_WINDOW_ACTIVE             = 0x02,
                STATE_ACTIVE                    = 0x04,
                STATE_ENABLED                   = STATE_WINDOW_ACTIVE | STATE_ACTIVE,
        };
};

// constructor
ScrollCorner::ScrollCorner(ScrollView* scrollView)
        : BView(BRect(0.0, 0.0, B_V_SCROLL_BAR_WIDTH - 1.0f, B_H_SCROLL_BAR_HEIGHT - 1.0f), NULL,
                        0, B_WILL_DRAW),
          fScrollView(scrollView),
          fState(0),
          fStartPoint(0, 0),
          fStartScrollOffset(0, 0)
{
        SetViewColor(B_TRANSPARENT_32_BIT);

        fBitmaps[0] = new BBitmap(BRect(0.0f, 0.0f, sBitmapWidth - 1,
                sBitmapHeight - 1), sColorSpace);
        char* bits = (char*)fBitmaps[0]->Bits();
        int32 bpr = fBitmaps[0]->BytesPerRow();
        for (int i = 0; i < sBitmapHeight; i++, bits += bpr) {
                memcpy(bits, &sScrollCornerNormalBits[i * sBitmapHeight * 4],
                        sBitmapWidth * 4);
        }

        fBitmaps[1] = new BBitmap(BRect(0.0f, 0.0f, sBitmapWidth - 1,
                sBitmapHeight - 1), sColorSpace);
        bits = (char*)fBitmaps[1]->Bits();
        bpr = fBitmaps[1]->BytesPerRow();
        for (int i = 0; i < sBitmapHeight; i++, bits += bpr) {
                memcpy(bits, &sScrollCornerPushedBits[i * sBitmapHeight * 4],
                        sBitmapWidth * 4);
        }

        fBitmaps[2] = new BBitmap(BRect(0.0f, 0.0f, sBitmapWidth - 1,
                sBitmapHeight - 1), sColorSpace);
        bits = (char*)fBitmaps[2]->Bits();
        bpr = fBitmaps[2]->BytesPerRow();
        for (int i = 0; i < sBitmapHeight; i++, bits += bpr) {
                memcpy(bits, &sScrollCornerDisabledBits[i * sBitmapHeight * 4],
                        sBitmapWidth * 4);
        }
}

// destructor
ScrollCorner::~ScrollCorner()
{
        for (int i = 0; i < 3; i++)
                delete fBitmaps[i];
}

// MouseDown
void
ScrollCorner::MouseDown(BPoint point)
{
        BView::MouseDown(point);
        uint32 buttons = 0;
        Window()->CurrentMessage()->FindInt32("buttons", (int32 *)&buttons);
        if (buttons & B_PRIMARY_MOUSE_BUTTON) {
                SetMouseEventMask(B_POINTER_EVENTS);
                if (fScrollView && IsEnabled() && Bounds().Contains(point)) {
                        SetDragging(true);
                        fStartPoint = point;
                        fStartScrollOffset = fScrollView->ScrollOffset();
                }
        }
}

// MouseUp
void
ScrollCorner::MouseUp(BPoint point)
{
        BView::MouseUp(point);
        uint32 buttons = 0;
        Window()->CurrentMessage()->FindInt32("buttons", (int32 *)&buttons);
        if (!(buttons & B_PRIMARY_MOUSE_BUTTON))
                SetDragging(false);
}

// MouseMoved
void
ScrollCorner::MouseMoved(BPoint point, uint32 transit, const BMessage* message)
{
        BView::MouseMoved(point, transit, message);
        if (IsDragging()) {
                uint32 buttons = 0;
                Window()->CurrentMessage()->FindInt32("buttons", (int32 *)&buttons);
                // This is a work-around for a BeOS bug: We sometimes don't get a
                // MouseUp(), but fortunately it seems, that within the last
                // MouseMoved() the button is not longer pressed.
                if (buttons & B_PRIMARY_MOUSE_BUTTON) {
                        BPoint diff = point - fStartPoint;
                        if (fScrollView) {
                                fScrollView->_ScrollCornerValueChanged(fStartScrollOffset
                                                                                                           - diff);
//                                                                                                         + diff);
                        }
                } else
                        SetDragging(false);
        }
}

// Draw
void
ScrollCorner::Draw(BRect updateRect)
{
        if (IsEnabled()) {
                if (IsDragging())
                        DrawBitmap(fBitmaps[1], BPoint(0.0f, 0.0f));
                else
                        DrawBitmap(fBitmaps[0], BPoint(0.0f, 0.0f));
        }
        else
                DrawBitmap(fBitmaps[2], BPoint(0.0f, 0.0f));
}

// WindowActivated
void
ScrollCorner::WindowActivated(bool active)
{
        if (active != (fState & STATE_WINDOW_ACTIVE)) {
                bool enabled = IsEnabled();
                if (active)
                        fState |= STATE_WINDOW_ACTIVE;
                else
                        fState &= ~STATE_WINDOW_ACTIVE;
                if (enabled != IsEnabled())
                        Invalidate();
        }
}

// SetActive
void
ScrollCorner::SetActive(bool active)
{
        if (active != IsActive()) {
                bool enabled = IsEnabled();
                if (active)
                        fState |= STATE_ACTIVE;
                else
                        fState &= ~STATE_ACTIVE;
                if (enabled != IsEnabled())
                        Invalidate();
        }
}

// SetDragging
void
ScrollCorner::SetDragging(bool dragging)
{
        if (dragging != IsDragging()) {
                if (dragging)
                        fState |= STATE_DRAGGING;
                else
                        fState &= ~STATE_DRAGGING;
                Invalidate();
        }
}


// #pragma mark - ScrollView


// constructor
ScrollView::ScrollView(BView* child, uint32 scrollingFlags, BRect frame,
                const char* name, uint32 resizingMode, uint32 viewFlags,
                uint32 borderStyle, uint32 borderFlags)
        : BView(frame, name, resizingMode,
                viewFlags | B_FRAME_EVENTS | B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE),
        Scroller()
{
        _Init(child, scrollingFlags, borderStyle, borderFlags);
}

#ifdef __HAIKU__

// constructor
ScrollView::ScrollView(BView* child, uint32 scrollingFlags, const char* name,
                uint32 viewFlags, uint32 borderStyle, uint32 borderFlags)
        : BView(name, viewFlags | B_FRAME_EVENTS | B_WILL_DRAW
                | B_FULL_UPDATE_ON_RESIZE),
        Scroller()
{
        _Init(child, scrollingFlags, borderStyle, borderFlags);
}

#endif // __HAIKU__

// destructor
ScrollView::~ScrollView()
{
}

// AllAttached
void
ScrollView::AllAttached()
{
        // do a first layout
        _Layout(_UpdateScrollBarVisibility());
}

// Draw
void ScrollView::Draw(BRect updateRect)
{
        if (fBorderStyle == B_NO_BORDER)
                return;

        rgb_color keyboardFocus = keyboard_navigation_color();
        rgb_color light = tint_color(ui_color(B_PANEL_BACKGROUND_COLOR),
                                                                 B_LIGHTEN_MAX_TINT);
        rgb_color shadow = tint_color(ui_color(B_PANEL_BACKGROUND_COLOR),
                                                                  B_DARKEN_1_TINT);
        rgb_color darkShadow = tint_color(ui_color(B_PANEL_BACKGROUND_COLOR),
                                                                  B_DARKEN_2_TINT);

        BRect r = Bounds();

        if (fChildFocused && fWindowActive) {
                SetHighColor(keyboardFocus);
                StrokeRect(r);
        } else {
                if (fBorderStyle == B_PLAIN_BORDER) {
                        SetHighColor(darkShadow);
                        StrokeRect(r);
                } else {
                        BeginLineArray(4);
                        AddLine(BPoint(r.left, r.bottom),
                                        BPoint(r.left, r.top), shadow);
                        AddLine(BPoint(r.left + 1.0, r.top),
                                        BPoint(r.right, r.top), shadow);
                        AddLine(BPoint(r.right, r.top + 1.0),
                                        BPoint(r.right, r.bottom), light);
                        AddLine(BPoint(r.right - 1.0, r.bottom),
                                        BPoint(r.left + 1.0, r.bottom), light);
                        EndLineArray();
                }
        }
        if (fBorderStyle == B_PLAIN_BORDER)
                return;

        // The right and bottom lines will be hidden if the scroll views are
        // visible. But that doesn't harm.
        r.InsetBy(1, 1);
        SetHighColor(darkShadow);
        StrokeRect(r);
}

// FrameResized
void
ScrollView::FrameResized(float width, float height)
{
        _Layout(0);
}

// WindowActivated
void ScrollView::WindowActivated(bool activated)
{
        fWindowActive = activated;
        if (fChildFocused)
                Invalidate();
}

#ifdef __HAIKU__

// MinSize
BSize
ScrollView::MinSize()
{
        BSize size = (fChild ? fChild->MinSize() : BSize(-1, -1));
        return _Size(size);
}

// PreferredSize
BSize
ScrollView::PreferredSize()
{
        BSize size = (fChild ? fChild->PreferredSize() : BSize(-1, -1));
        return _Size(size);
}

#endif // __HAIKU__

// #pragma mark -

// ScrollingFlags
uint32
ScrollView::ScrollingFlags() const
{
        return fScrollingFlags;
}

// SetVisibleRectIsChildBounds
void
ScrollView::SetVisibleRectIsChildBounds(bool flag)
{
        if (flag != VisibleRectIsChildBounds()) {
                if (flag)
                        fScrollingFlags |= SCROLL_VISIBLE_RECT_IS_CHILD_BOUNDS;
                else
                        fScrollingFlags &= ~SCROLL_VISIBLE_RECT_IS_CHILD_BOUNDS;
                if (fChild && _UpdateScrollBarVisibility())
                        _Layout(0);
        }
}

// VisibleRectIsChildBounds
bool
ScrollView::VisibleRectIsChildBounds() const
{
        return (fScrollingFlags & SCROLL_VISIBLE_RECT_IS_CHILD_BOUNDS);
}

// Child
BView*
ScrollView::Child() const
{
        return fChild;
}

// ChildFocusChanged
//
// To be called by the scroll child, when its has got or lost the focus.
// We need this to know, when to draw the blue focus frame.
void
ScrollView::ChildFocusChanged(bool focused)
{
        if (fChildFocused != focused) {
                fChildFocused = focused;
                Invalidate();
        }
}

// HScrollBar
BScrollBar*
ScrollView::HScrollBar() const
{
        return fHScrollBar;
}

// VScrollBar
BScrollBar*
ScrollView::VScrollBar() const
{
        return fVScrollBar;
}

// HVScrollCorner
BView*
ScrollView::HVScrollCorner() const
{
        return fScrollCorner;
}

// #pragma mark -

// SetHSmallStep
void
ScrollView::SetHSmallStep(float hStep)
{
        SetSmallSteps(hStep, fVSmallStep);
}

// SetVSmallStep
void
ScrollView::SetVSmallStep(float vStep)
{
        SetSmallSteps(fHSmallStep, vStep);
}

// SetSmallSteps
void
ScrollView::SetSmallSteps(float hStep, float vStep)
{
        if (fHSmallStep != hStep || fVSmallStep != vStep) {
                fHSmallStep = hStep;
                fVSmallStep = vStep;
                _UpdateScrollBars();
        }
}

// GetSmallSteps
void
ScrollView::GetSmallSteps(float* hStep, float* vStep) const
{
        *hStep = fHSmallStep;
        *vStep = fVSmallStep;
}

// HSmallStep
float
ScrollView::HSmallStep() const
{
        return fHSmallStep;
}

// VSmallStep
float
ScrollView::VSmallStep() const
{
        return fVSmallStep;
}

// IsScrolling
bool
ScrollView::IsScrolling() const
{
        return fScrolling;
}

void
ScrollView::SetScrollingEnabled(bool enabled)
{
        Scroller::SetScrollingEnabled(enabled);
        if (IsScrollingEnabled())
                SetScrollOffset(ScrollOffset());
}

// #pragma mark -

// DataRectChanged
void
ScrollView::DataRectChanged(BRect /*oldDataRect*/, BRect /*newDataRect*/)
{
        if (ScrollTarget()) {
                if (_UpdateScrollBarVisibility())
                        _Layout(0);
                else
                        _UpdateScrollBars();
        }
}

// ScrollOffsetChanged
void
ScrollView::ScrollOffsetChanged(BPoint /*oldOffset*/, BPoint newOffset)
{
        if (fHScrollBar && fHScrollBar->Value() != newOffset.x)
                fHScrollBar->SetValue(newOffset.x);
        if (fVScrollBar && fVScrollBar->Value() != newOffset.y)
                fVScrollBar->SetValue(newOffset.y);
}

// VisibleSizeChanged
void
ScrollView::VisibleSizeChanged(float /*oldWidth*/, float /*oldHeight*/,
                                                           float /*newWidth*/, float /*newHeight*/)
{
        if (ScrollTarget()) {
                if (_UpdateScrollBarVisibility())
                        _Layout(0);
                else
                        _UpdateScrollBars();
        }
}

// ScrollTargetChanged
void
ScrollView::ScrollTargetChanged(Scrollable* /*oldTarget*/,
                                                                Scrollable* newTarget)
{
/*      // remove the old child
        if (fChild)
                RemoveChild(fChild);
        // add the new child
        BView* view = dynamic_cast<BView*>(newTarget);
        fChild = view;
        if (view)
                AddChild(view);
        else if (newTarget)     // set the scroll target to NULL, if it isn't a BView
                SetScrollTarget(NULL);
*/
}

// _Init
void
ScrollView::_Init(BView* child, uint32 scrollingFlags, uint32 borderStyle,
        uint32 borderFlags)
{
        fChild = NULL;
        fScrollingFlags = scrollingFlags;

        fHScrollBar = NULL;
        fVScrollBar = NULL;
        fScrollCorner = NULL;

        fHVisible = true;
        fVVisible = true;
        fCornerVisible = true;

        fWindowActive = false;
        fChildFocused = false;

        fScrolling = false;

        fHSmallStep = 1;
        fVSmallStep = 1;

        fBorderStyle = borderStyle;
        fBorderFlags = borderFlags;

        // Set transparent view color -- our area is completely covered by
        // our children.
        SetViewColor(B_TRANSPARENT_32_BIT);
        // create scroll bars
        if (fScrollingFlags & (SCROLL_HORIZONTAL | SCROLL_HORIZONTAL_MAGIC)) {
                fHScrollBar = new InternalScrollBar(this,
                                BRect(0.0, 0.0, 100.0, B_H_SCROLL_BAR_HEIGHT), B_HORIZONTAL);
                AddChild(fHScrollBar);
        }
        if (fScrollingFlags & (SCROLL_VERTICAL | SCROLL_VERTICAL_MAGIC)) {
                fVScrollBar = new InternalScrollBar(this,
                                BRect(0.0, 0.0, B_V_SCROLL_BAR_WIDTH, 100.0), B_VERTICAL);
                AddChild(fVScrollBar);
        }
        // Create a scroll corner, if we can scroll into both direction.
        if (fHScrollBar && fVScrollBar) {
                fScrollCorner = new ScrollCorner(this);
                AddChild(fScrollCorner);
        }
        // add child
        if (child) {
                fChild = child;
                AddChild(child);
                if (Scrollable* scrollable = dynamic_cast<Scrollable*>(child))
                        SetScrollTarget(scrollable);
        }
}


// _ScrollValueChanged
void
ScrollView::_ScrollValueChanged(InternalScrollBar* scrollBar, float value)
{
        if (!IsScrollingEnabled())
                return;

        switch (scrollBar->Orientation()) {
                case B_HORIZONTAL:
                        if (fHScrollBar)
                                SetScrollOffset(BPoint(value, ScrollOffset().y));
                        break;
                case B_VERTICAL:
                        if (fVScrollBar)
                                SetScrollOffset(BPoint(ScrollOffset().x, value));
                        break;
                default:
                        break;
        }
}

// _ScrollCornerValueChanged
void
ScrollView::_ScrollCornerValueChanged(BPoint offset)
{
        // The logic in Scrollable::SetScrollOffset() handles offsets, that
        // are out of range.
        SetScrollOffset(offset);
}

// #pragma mark -

// _Layout
//
// Relayouts all children (fChild, scroll bars).
// flags indicates which scrollbars' visibility has changed.
// May be overridden to do a custom layout -- the SCROLL_*_MAGIC must
// be disabled in this case, or strange things happen.
void
ScrollView::_Layout(uint32 flags)
{
        bool hbar = (fHScrollBar && fHVisible);
        bool vbar = (fVScrollBar && fVVisible);
        bool corner = (fScrollCorner && fCornerVisible);
        BRect childRect(_ChildRect());
        float innerWidth = childRect.Width();
        float innerHeight = childRect.Height();
        BPoint scrollLT(_InnerRect().LeftTop());
        scrollLT.x--;
        scrollLT.y--;

        BPoint scrollRB(childRect.RightBottom() + BPoint(1.0f, 1.0f));

        // layout scroll bars and scroll corner
        if (corner) {
                // In this case the scrollbars overlap one pixel.
                fHScrollBar->MoveTo(scrollLT.x, scrollRB.y);
                fHScrollBar->ResizeTo(innerWidth + 2.0, B_H_SCROLL_BAR_HEIGHT);
                fVScrollBar->MoveTo(scrollRB.x, scrollLT.y);
                fVScrollBar->ResizeTo(B_V_SCROLL_BAR_WIDTH, innerHeight + 2.0);
                fScrollCorner->MoveTo(childRect.right + 2.0, childRect.bottom + 2.0);
        } else if (hbar) {
                fHScrollBar->MoveTo(scrollLT.x, scrollRB.y);
                fHScrollBar->ResizeTo(innerWidth + 2.0, B_H_SCROLL_BAR_HEIGHT);
        } else if (vbar) {
                fVScrollBar->MoveTo(scrollRB.x, scrollLT.y);
                fVScrollBar->ResizeTo(B_V_SCROLL_BAR_WIDTH, innerHeight + 2.0);
        }
        // layout child
        if (fChild) {
                fChild->MoveTo(childRect.LeftTop());
                fChild->ResizeTo(innerWidth, innerHeight);
                if (VisibleRectIsChildBounds())
                        SetVisibleSize(innerWidth, innerHeight);
                // Due to a BeOS bug sometimes the area under a recently hidden
                // scroll bar isn't updated correctly.
                // We force this manually: The position of hidden scroll bar isn't
                // updated any longer, so we can't just invalidate it.
                if (fChild->Window()) {
                        if (flags & SCROLL_HORIZONTAL && !fHVisible)
                                fChild->Invalidate(fHScrollBar->Frame());
                        if (flags & SCROLL_VERTICAL && !fVVisible)
                                fChild->Invalidate(fVScrollBar->Frame());
                }
        }
}

// _UpdateScrollBars
//
// Probably somewhat misnamed. This function updates the scroll bars'
// proportion, range attributes and step widths according to the scroll
// target's DataRect() and VisibleBounds(). May also be called, if there's
// no scroll target -- then the scroll bars are disabled.
void
ScrollView::_UpdateScrollBars()
{
        BRect dataRect = DataRect();
        BRect visibleBounds = VisibleBounds();
        if (!fScrollTarget) {
                dataRect.Set(0.0, 0.0, 0.0, 0.0);
                visibleBounds.Set(0.0, 0.0, 0.0, 0.0);
        }
        float hProportion = min_c(1.0f, (visibleBounds.Width() + 1.0f)
                / (dataRect.Width() + 1.0f));
        float hMaxValue = max_c(dataRect.left,
                dataRect.right - visibleBounds.Width());
        float vProportion = min_c(1.0f, (visibleBounds.Height() + 1.0f)
                / (dataRect.Height() + 1.0f));
        float vMaxValue = max_c(dataRect.top,
                dataRect.bottom - visibleBounds.Height());
        // update horizontal scroll bar
        if (fHScrollBar) {
                fHScrollBar->SetProportion(hProportion);
                fHScrollBar->SetRange(dataRect.left, hMaxValue);
                // This obviously ineffective line works around a BScrollBar bug:
                // As documented the scrollbar's value is adjusted, if the range
                // has been changed and it therefore falls out of the range. But if,
                // after resetting the range to what it has been before, the user
                // moves the scrollbar to the original value via one click
                // it is failed to invoke BScrollBar::ValueChanged().
                fHScrollBar->SetValue(fHScrollBar->Value());
                fHScrollBar->SetSteps(fHSmallStep, visibleBounds.Width());
        }
        // update vertical scroll bar
        if (fVScrollBar) {
                fVScrollBar->SetProportion(vProportion);
                fVScrollBar->SetRange(dataRect.top, vMaxValue);
                // This obviously ineffective line works around a BScrollBar bug.
                fVScrollBar->SetValue(fVScrollBar->Value());
                fVScrollBar->SetSteps(fVSmallStep, visibleBounds.Height());
        }
        // update scroll corner
        if (fScrollCorner) {
                fScrollCorner->SetActive(hProportion < 1.0f || vProportion < 1.0f);
        }
}

// set_visible_state
//
// Convenience function: Sets a view's visibility state to /visible/.
// Returns true, if the state was actually changed, false otherwise.
// This function never calls Hide() on a hidden or Show() on a visible
// view. /view/ must be valid.
static inline
bool
set_visible_state(BView* view, bool visible, bool* currentlyVisible)
{
        bool changed = false;
        if (*currentlyVisible != visible) {
                if (visible)
                        view->Show();
                else
                        view->Hide();
                *currentlyVisible = visible;
                changed = true;
        }
        return changed;
}

// _UpdateScrollBarVisibility
//
// Checks which of scroll bars need to be visible according to
// SCROLL_*_MAGIG and shows/hides them, if necessary.
// Returns a bitwise combination of SCROLL_HORIZONTAL and SCROLL_VERTICAL
// according to which scroll bar's visibility state has changed, 0 if none.
// A return value != 0 usually means that the layout isn't valid any longer.
uint32
ScrollView::_UpdateScrollBarVisibility()
{
        uint32 changed = 0;
        BRect childRect(_MaxVisibleRect());
        float width = childRect.Width();
        float height = childRect.Height();
        BRect dataRect = DataRect();                    // Invalid if !ScrollTarget(),
        float dataWidth = dataRect.Width();             // but that doesn't harm.
        float dataHeight = dataRect.Height();   //
        bool hbar = (fScrollingFlags & SCROLL_HORIZONTAL_MAGIC);
        bool vbar = (fScrollingFlags & SCROLL_VERTICAL_MAGIC);
        if (!ScrollTarget()) {
                if (hbar) {
                        if (set_visible_state(fHScrollBar, false, &fHVisible))
                                changed |= SCROLL_HORIZONTAL;
                }
                if (vbar) {
                        if (set_visible_state(fVScrollBar, false, &fVVisible))
                                changed |= SCROLL_VERTICAL;
                }
        } else if (hbar && width >= dataWidth && vbar && height >= dataHeight) {
                // none
                if (set_visible_state(fHScrollBar, false, &fHVisible))
                        changed |= SCROLL_HORIZONTAL;
                if (set_visible_state(fVScrollBar, false, &fVVisible))
                        changed |= SCROLL_VERTICAL;
        } else {
                // The case, that both scroll bars are magic and invisible is catched,
                // so that while checking one bar we can suppose, that the other one
                // is visible (if it does exist at all).
                BRect innerRect(_GuessVisibleRect(fHScrollBar, fVScrollBar));
                float innerWidth = innerRect.Width();
                float innerHeight = innerRect.Height();
                // the horizontal one?
                if (hbar) {
                        if (innerWidth >= dataWidth) {
                                if (set_visible_state(fHScrollBar, false, &fHVisible))
                                        changed |= SCROLL_HORIZONTAL;
                        } else {
                                if (set_visible_state(fHScrollBar, true, &fHVisible))
                                        changed |= SCROLL_HORIZONTAL;
                        }
                }
                // the vertical one?
                if (vbar) {
                        if (innerHeight >= dataHeight) {
                                if (set_visible_state(fVScrollBar, false, &fVVisible))
                                        changed |= SCROLL_VERTICAL;
                        } else {
                                if (set_visible_state(fVScrollBar, true, &fVVisible))
                                        changed |= SCROLL_VERTICAL;
                        }
                }
        }
        // If anything has changed, update the scroll corner as well.
        if (changed && fScrollCorner)
                set_visible_state(fScrollCorner, fHVisible && fVVisible, &fCornerVisible);
        return changed;
}

// _InnerRect
//
// Returns the rectangle that actually can be used for the child and the
// scroll bars, i.e. the view's Bounds() subtracted the space for the
// decorative frame.
BRect
ScrollView::_InnerRect() const
{
        BRect r = Bounds();
        float borderWidth = 0;
        switch (fBorderStyle) {
                case B_NO_BORDER:
                        break;
                case B_PLAIN_BORDER:
                        borderWidth = 1;
                        break;
                case B_FANCY_BORDER:
                default:
                        borderWidth = 2;
                        break;
        }
        if (fBorderFlags & BORDER_LEFT)
                r.left += borderWidth;
        if (fBorderFlags & BORDER_TOP)
                r.top += borderWidth;
        if (fBorderFlags & BORDER_RIGHT)
                r.right -= borderWidth;
        if (fBorderFlags & BORDER_BOTTOM)
                r.bottom -= borderWidth;
        return r;
}

// _ChildRect
//
// Returns the rectangle, that should be the current child frame.
// `should' because 1. we might not have a child at all or 2. a
// relayout is pending.
BRect
ScrollView::_ChildRect() const
{
        return _ChildRect(fHScrollBar && fHVisible, fVScrollBar && fVVisible);
}

// _ChildRect
//
// The same as _ChildRect() with the exception that not the current
// scroll bar visibility, but a fictitious one given by /hbar/ and /vbar/
// is considered.
BRect
ScrollView::_ChildRect(bool hbar, bool vbar) const
{
        BRect rect(_InnerRect());
        if (vbar)
                rect.right -= B_V_SCROLL_BAR_WIDTH;
        if (hbar)
                rect.bottom -= B_H_SCROLL_BAR_HEIGHT;

        return rect;
}

// _GuessVisibleRect
//
// Returns an approximation of the visible rect for the
// fictitious scroll bar visibility given by /hbar/ and /vbar/.
// In the case !VisibleRectIsChildBounds() it is simply the current
// visible rect.
BRect
ScrollView::_GuessVisibleRect(bool hbar, bool vbar) const
{
        if (VisibleRectIsChildBounds())
                return _ChildRect(hbar, vbar).OffsetToCopy(ScrollOffset());
        return VisibleRect();
}

// _MaxVisibleRect
//
// Returns the maximal possible visible rect in the current situation, that
// is depending on if the visible rect is the child's bounds either the
// rectangle the child covers when both scroll bars are hidden (offset to
// the scroll offset) or the current visible rect.
BRect
ScrollView::_MaxVisibleRect() const
{
        return _GuessVisibleRect(true, true);
}

#ifdef __HAIKU__

BSize
ScrollView::_Size(BSize size)
{
        if (fVVisible)
                size.width += B_V_SCROLL_BAR_WIDTH;
        if (fHVisible)
                size.height += B_H_SCROLL_BAR_HEIGHT;

        switch (fBorderStyle) {
                case B_NO_BORDER:
                        // one line of pixels from scrollbar possibly hidden
                        if (fBorderFlags & BORDER_RIGHT)
                                size.width += fVVisible ? -1 : 0;
                        if (fBorderFlags & BORDER_BOTTOM)
                                size.height += fHVisible ? -1 : 0;
                        break;

                case B_PLAIN_BORDER:
                        if (fBorderFlags & BORDER_LEFT)
                                size.width += 1;
                        if (fBorderFlags & BORDER_TOP)
                                size.height += 1;
                        // one line of pixels in frame possibly from scrollbar
                        if (fBorderFlags & BORDER_RIGHT)
                                size.width += fVVisible ? 0 : 1;
                        if (fBorderFlags & BORDER_BOTTOM)
                                size.height += fHVisible ? 0 : 1;
                        break;

                case B_FANCY_BORDER:
                default:
                        if (fBorderFlags & BORDER_LEFT)
                                size.width += 2;
                        if (fBorderFlags & BORDER_TOP)
                                size.height += 2;
                        // one line of pixels in frame possibly from scrollbar
                        if (fBorderFlags & BORDER_RIGHT)
                                size.width += fVVisible ? 1 : 2;
                        if (fBorderFlags & BORDER_BOTTOM)
                                size.height += fHVisible ? 1 : 2;
                        break;
        }

        return BLayoutUtils::ComposeSize(ExplicitMinSize(), size);
}

#endif // __HAIKU__

// _SetScrolling
void
ScrollView::_SetScrolling(bool scrolling)
{
        fScrolling = scrolling;
}