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

#ifndef SCROLL_VIEW_H
#define SCROLL_VIEW_H

#include <View.h>

#include "Scroller.h"

class Scrollable;
class InternalScrollBar;
class ScrollCorner;

enum {
        SCROLL_HORIZONTAL                                               = 0x01,
        SCROLL_VERTICAL                                                 = 0x02,
        SCROLL_HORIZONTAL_MAGIC                                 = 0x04,
        SCROLL_VERTICAL_MAGIC                                   = 0x08,
        SCROLL_VISIBLE_RECT_IS_CHILD_BOUNDS             = 0x10,
        SCROLL_NO_FRAME                                                 = 0x20,
        SCROLL_LIST_FRAME                                               = 0x40,
};

enum {
        BORDER_LEFT             = 0x01,
        BORDER_TOP              = 0x02,
        BORDER_RIGHT    = 0x04,
        BORDER_BOTTOM   = 0x08,
        BORDER_ALL              = BORDER_LEFT | BORDER_TOP | BORDER_RIGHT | BORDER_BOTTOM
};


class ScrollView : public BView, public Scroller {
public:
                                                                ScrollView(BView* child, uint32 scrollingFlags,
                                                                        BRect frame, const char *name,
                                                                        uint32 resizingMode, uint32 viewFlags,
                                                                        uint32 borderStyle = B_FANCY_BORDER,
                                                                        uint32 borderFlags = BORDER_ALL);
#ifdef __HAIKU__
                                                                ScrollView(BView* child, uint32 scrollingFlags,
                                                                        const char *name, uint32 viewFlags,
                                                                        uint32 borderStyle = B_FANCY_BORDER,
                                                                        uint32 borderFlags = BORDER_ALL);
#endif // __HAIKU__
        virtual                                         ~ScrollView();

        virtual void                            AllAttached();
        virtual void                            Draw(BRect updateRect);
        virtual void                            FrameResized(float width, float height);
        virtual void                            WindowActivated(bool activated);

#ifdef __HAIKU__

        virtual BSize                           MinSize();
        virtual BSize                           PreferredSize();

#endif // __HAIKU__

                        uint32                          ScrollingFlags() const;
                        void                            SetVisibleRectIsChildBounds(bool flag);
                        bool                            VisibleRectIsChildBounds() const;

                        BView*                          Child() const;
                        void                            ChildFocusChanged(bool focused);

                        BScrollBar*                     HScrollBar() const;
                        BScrollBar*                     VScrollBar() const;
                        BView*                          HVScrollCorner() const;

                        void                            SetHSmallStep(float hStep);
                        void                            SetVSmallStep(float vStep);
                        void                            SetSmallSteps(float hStep, float vStep);
                        void                            GetSmallSteps(float* hStep,
                                                                                          float* vStep) const;
                        float                           HSmallStep() const;
                        float                           VSmallStep() const;

        virtual bool                            IsScrolling() const;
        virtual void                            SetScrollingEnabled(bool enabled);

 protected:
        virtual void                            DataRectChanged(BRect oldDataRect,
                                                                                                BRect newDataRect);
        virtual void                            ScrollOffsetChanged(BPoint oldOffset,
                                                                                                        BPoint newOffset);
        virtual void                            VisibleSizeChanged(float oldWidth,
                                                                                                   float oldHeight,
                                                                                                   float newWidth,
                                                                                                   float newHeight);
        virtual void                            ScrollTargetChanged(Scrollable* oldTarget,
                                                                                                        Scrollable* newTarget);

 private:
                        BView*                          fChild;                 // child view
                        uint32                          fScrollingFlags;
                        InternalScrollBar*      fHScrollBar;    // horizontal scroll bar
                        InternalScrollBar*      fVScrollBar;    // vertical scroll bar
                        ScrollCorner*           fScrollCorner;  // scroll corner
                        bool                            fHVisible;              // horizontal/vertical scroll
                        bool                            fVVisible;              // bar visible flag
                        bool                            fCornerVisible; // scroll corner visible flag
                        bool                            fWindowActive;
                        bool                            fChildFocused;
                        bool                            fScrolling;
                        float                           fHSmallStep;
                        float                           fVSmallStep;

                        uint32                          fBorderStyle;
                        uint32                          fBorderFlags;

                        void                            _Init(BView* child, uint32 scrollingFlags,
                                                                        uint32 borderStyle, uint32 borderFlags);

                        void                            _ScrollValueChanged(
                                                                                InternalScrollBar* scrollBar,
                                                                                float value);
                        void                            _ScrollCornerValueChanged(BPoint offset);

protected:
        virtual void                            _Layout(uint32 flags);

private:
                        void                            _UpdateScrollBars();
                        uint32                          _UpdateScrollBarVisibility();

                        BRect                           _InnerRect() const;
                        BRect                           _ChildRect() const;
                        BRect                           _ChildRect(bool hbar, bool vbar) const;
                        BRect                           _GuessVisibleRect(bool hbar, bool vbar) const;
                        BRect                           _MaxVisibleRect() const;
#ifdef __HAIKU__
        virtual BSize                           _Size(BSize childSize);
#endif

                        void                            _SetScrolling(bool scrolling);

        friend class InternalScrollBar;
        friend class ScrollCorner;
};



#endif  // SCROLL_VIEW_H