/*
 * Copyright 2001-2020, Haiku, Inc.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *              DarkWyrm, bpmagic@columbus.rr.com
 *              Adi Oanca, adioanca@gmail.com
 *              Stephan Aßmus, superstippi@gmx.de
 *              Axel Dörfler, axeld@pinc-software.de
 *              Brecht Machiels, brecht@mos6581.org
 *              Clemens Zeidler, haiku@clemens-zeidler.de
 *              Tri-Edge AI
 *              Jacob Secunda, secundja@gmail.com
 */
#ifndef WINDOW_H
#define WINDOW_H


#include "RegionPool.h"
#include "ServerWindow.h"
#include "View.h"
#include "WindowList.h"

#include <AutoDeleter.h>
#include <ObjectList.h>
#include <Referenceable.h>
#include <Region.h>
#include <String.h>


class Window;


typedef BObjectList<Window>     StackWindows;


class WindowStack : public BReferenceable {
public:
                                                                WindowStack(::Decorator* decorator);
                                                                ~WindowStack();

                        void                            SetDecorator(::Decorator* decorator);
                        ::Decorator*            Decorator();

        const   StackWindows&           WindowList() const { return fWindowList; }
        const   StackWindows&           LayerOrder() const { return fWindowLayerOrder; }

                        Window*                         TopLayerWindow() const;

                        int32                           CountWindows();
                        Window*                         WindowAt(int32 index);
                        bool                            AddWindow(Window* window,
                                                                        int32 position = -1);
                        bool                            RemoveWindow(Window* window);

                        bool                            MoveToTopLayer(Window* window);
                        bool                            Move(int32 from, int32 to);
private:
                        ObjectDeleter< ::Decorator>
                                                                fDecorator;

                        StackWindows            fWindowList;
                        StackWindows            fWindowLayerOrder;
};


namespace BPrivate {
        class PortLink;
};

class ClickTarget;
class ClientLooper;
class Decorator;
class Desktop;
class DrawingEngine;
class EventDispatcher;
class Screen;
class WindowBehaviour;
class WorkspacesView;

// TODO: move this into a proper place
#define AS_REDRAW 'rdrw'


class Window {
public:
                                                                Window(const BRect& frame, const char *name,
                                                                        window_look look, window_feel feel,
                                                                        uint32 flags, uint32 workspaces,
                                                                        ::ServerWindow* window,
                                                                        DrawingEngine* drawingEngine);
        virtual                                         ~Window();

                        status_t                        InitCheck() const;

                        BRect                           Frame() const { return fFrame; }
                        const char*                     Title() const { return fTitle.String(); }

                        window_anchor&          Anchor(int32 index);
                        Window*                         NextWindow(int32 index) const;
                        Window*                         PreviousWindow(int32 index) const;

                        ::Desktop*                      Desktop() const { return fDesktop; }
                        ::Decorator*            Decorator() const;
                        ::ServerWindow*         ServerWindow() const { return fWindow; }
                        ::EventTarget&          EventTarget() const
                                                                        { return fWindow->EventTarget(); }

                        bool                            ReloadDecor();

                        void                            SetScreen(const ::Screen* screen);
                        const ::Screen*         Screen() const;

                        // setting and getting the "hard" clipping, you need to have
                        // WriteLock()ed the clipping!
                        void                            SetClipping(BRegion* stillAvailableOnScreen);
                        // you need to have ReadLock()ed the clipping!
        inline  BRegion&                        VisibleRegion() { return fVisibleRegion; }
                        BRegion&                        VisibleContentRegion();

                        // TODO: not protected by a lock, but noone should need this anyways
                        // make private? when used inside Window, it has the ReadLock()
                        void                            GetFullRegion(BRegion* region);
                        void                            GetBorderRegion(BRegion* region);
                        void                            GetContentRegion(BRegion* region);

                        void                            MoveBy(int32 x, int32 y, bool moveStack = true);
                        void                            ResizeBy(int32 x, int32 y,
                                                                        BRegion* dirtyRegion,
                                                                        bool resizeStack = true);
                        void                            SetOutlinesDelta(BPoint delta,
                                                                        BRegion* dirtyRegion);

                        void                            ScrollViewBy(View* view, int32 dx, int32 dy);

                        void                            SetTopView(View* topView);
                        View*                           TopView() const { return fTopView.Get(); }
                        View*                           ViewAt(const BPoint& where);

        virtual bool                            IsOffscreenWindow() const { return false; }

                        void                            GetEffectiveDrawingRegion(View* view,
                                                                        BRegion& region);
                        bool                            DrawingRegionChanged(View* view) const;

                        // generic version, used by the Desktop
                        void                            ProcessDirtyRegion(const BRegion& dirtyRegion,
                                                                        const BRegion& exposeRegion);
                        void                            ProcessDirtyRegion(const BRegion& exposeRegion)
                                                                        { ProcessDirtyRegion(exposeRegion, exposeRegion); }
                        void                            RedrawDirtyRegion();

                        // can be used from inside classes that don't
                        // need to know about Desktop (first version uses Desktop)
                        void                            MarkDirty(BRegion& regionOnScreen);
                        // these versions do not use the Desktop
                        void                            MarkContentDirty(BRegion& dirtyRegion,
                                                                        BRegion& exposeRegion);
                        void                            MarkContentDirtyAsync(BRegion& dirtyRegion);
                        // shortcut for invalidating just one view
                        void                            InvalidateView(View* view, BRegion& viewRegion);

                        void                            DisableUpdateRequests();
                        void                            EnableUpdateRequests();

                        void                            BeginUpdate(BPrivate::PortLink& link);
                        void                            EndUpdate();
                        bool                            InUpdate() const
                                                                        { return fInUpdate; }

                        bool                            NeedsUpdate() const
                                                                        { return fUpdateRequested; }

                        DrawingEngine*          GetDrawingEngine() const
                                                                        { return fDrawingEngine.Get(); }

                        // managing a region pool
                        ::RegionPool*           RegionPool()
                                                                        { return &fRegionPool; }
        inline  BRegion*                        GetRegion()
                                                                        { return fRegionPool.GetRegion(); }
        inline  BRegion*                        GetRegion(const BRegion& copy)
                                                                        { return fRegionPool.GetRegion(copy); }
        inline  void                            RecycleRegion(BRegion* region)
                                                                        { fRegionPool.Recycle(region); }

                        void                            CopyContents(BRegion* region,
                                                                        int32 xOffset, int32 yOffset);

                        void                            MouseDown(BMessage* message, BPoint where,
                                                                        const ClickTarget& lastClickTarget,
                                                                        int32& clickCount,
                                                                        ClickTarget& _clickTarget);
                        void                            MouseUp(BMessage* message, BPoint where,
                                                                        int32* _viewToken);
                        void                            MouseMoved(BMessage* message, BPoint where,
                                                                        int32* _viewToken, bool isLatestMouseMoved,
                                                                        bool isFake);

                        void                            ModifiersChanged(int32 modifiers);

                        // some hooks to inform the client window
                        // TODO: move this to ServerWindow maybe?
                        void                            WorkspaceActivated(int32 index, bool active);
                        void                            WorkspacesChanged(uint32 oldWorkspaces,
                                                                        uint32 newWorkspaces);
                        void                            Activated(bool active);

                        // changing some properties
                        void                            SetTitle(const char* name, BRegion& dirty);

                        void                            SetFocus(bool focus);
                        bool                            IsFocus() const { return fIsFocus; }

                        void                            SetHidden(bool hidden);
        inline  bool                            IsHidden() const { return fHidden; }

                        void                            SetShowLevel(int32 showLevel);
        inline  int32                           ShowLevel() const { return fShowLevel; }

                        void                            SetMinimized(bool minimized);
        inline  bool                            IsMinimized() const { return fMinimized; }

                        void                            SetCurrentWorkspace(int32 index)
                                                                        { fCurrentWorkspace = index; fPriorWorkspace = index; }
                        int32                           CurrentWorkspace() const
                                                                        { return fCurrentWorkspace; }
                        bool                            IsVisible() const;

                        void                            SetPriorWorkspace(int32 index)
                                                                        { fPriorWorkspace = index; }
                        int32                           PriorWorkspace() const
                                                                        { return fPriorWorkspace; }

                        bool                            IsDragging() const;
                        bool                            IsResizing() const;

                        void                            SetSizeLimits(int32 minWidth, int32 maxWidth,
                                                                        int32 minHeight, int32 maxHeight);

                        void                            GetSizeLimits(int32* minWidth, int32* maxWidth,
                                                                        int32* minHeight, int32* maxHeight) const;

                                                                // 0.0 -> left .... 1.0 -> right
                        bool                            SetTabLocation(float location, bool isShifting,
                                                                        BRegion& dirty);
                        float                           TabLocation() const;

                        bool                            SetDecoratorSettings(const BMessage& settings,
                                                                                                         BRegion& dirty);
                        bool                            GetDecoratorSettings(BMessage* settings);

                        void                            HighlightDecorator(bool active);

                        void                            FontsChanged(BRegion* updateRegion);
                        void                            ColorsChanged(BRegion* updateRegion);

                        void                            SetLook(window_look look,
                                                                        BRegion* updateRegion);
                        void                            SetFeel(window_feel feel);
                        void                            SetFlags(uint32 flags, BRegion* updateRegion);

                        window_look                     Look() const { return fLook; }
                        window_feel                     Feel() const { return fFeel; }
                        uint32                          Flags() const { return fFlags; }

                        // window manager stuff
                        uint32                          Workspaces() const { return fWorkspaces; }
                        void                            SetWorkspaces(uint32 workspaces)
                                                                        { fWorkspaces = workspaces; }
                        bool                            InWorkspace(int32 index) const;

                        bool                            SupportsFront();

                        bool                            IsModal() const;
                        bool                            IsFloating() const;
                        bool                            IsNormal() const;

                        bool                            HasModal() const;

                        Window*                         Frontmost(Window* first = NULL,
                                                                        int32 workspace = -1);
                        Window*                         Backmost(Window* first = NULL,
                                                                        int32 workspace = -1);

                        bool                            AddToSubset(Window* window);
                        void                            RemoveFromSubset(Window* window);
                        bool                            HasInSubset(const Window* window) const;
                        bool                            SameSubset(Window* window);
                        uint32                          SubsetWorkspaces() const;
                        bool                            InSubsetWorkspace(int32 index) const;

                        bool                            HasWorkspacesViews() const
                                                                        { return fWorkspacesViewCount != 0; }
                        void                            AddWorkspacesView()
                                                                        { fWorkspacesViewCount++; }
                        void                            RemoveWorkspacesView()
                                                                        { fWorkspacesViewCount--; }
                        void                            FindWorkspacesViews(
                                                                        BObjectList<WorkspacesView>& list) const;

        static  bool                            IsValidLook(window_look look);
        static  bool                            IsValidFeel(window_feel feel);
        static  bool                            IsModalFeel(window_feel feel);
        static  bool                            IsFloatingFeel(window_feel feel);

        static  uint32                          ValidWindowFlags();
        static  uint32                          ValidWindowFlags(window_feel feel);

                        // Window stack methods.
                        WindowStack*            GetWindowStack();

                        bool                            DetachFromWindowStack(
                                                                        bool ownStackNeeded = true);
                        bool                            AddWindowToStack(Window* window);
                        Window*                         StackedWindowAt(const BPoint& where);
                        Window*                         TopLayerStackWindow();

                        int32                           PositionInStack() const;
                        bool                            MoveToTopStackLayer();
                        bool                            MoveToStackPosition(int32 index,
                                                                        bool isMoving);
protected:
                        void                            _ShiftPartOfRegion(BRegion* region,
                                                                        BRegion* regionToShift, int32 xOffset,
                                                                        int32 yOffset);

                        // different types of drawing
                        void                            _TriggerContentRedraw(BRegion& dirty,
                                                                        const BRegion& expose = BRegion());
                        void                            _DrawBorder();

                        // handling update sessions
                        void                            _TransferToUpdateSession(
                                                                        BRegion* contentDirtyRegion);
                        void                            _SendUpdateMessage();

                        void                            _UpdateContentRegion();

                        void                            _ObeySizeLimits();
                        void                            _PropagatePosition();

                        BString                         fTitle;
                        // TODO: no fp rects anywhere
                        BRect                           fFrame;
                        const ::Screen*         fScreen;

                        window_anchor           fAnchor[kListCount];

                        // the visible region is only recalculated from the
                        // Desktop thread, when using it, Desktop::ReadLockClipping()
                        // has to be called

                        BRegion                         fVisibleRegion;
                        BRegion                         fVisibleContentRegion;

                        // Our part of the "global" dirty region (what needs to be redrawn).
                        // It is calculated from the desktop thread, but we can write to it when we read locked
                        // the clipping, since it is local and the desktop thread is blocked.
                        BRegion                         fDirtyRegion;

                        // Subset of the dirty region that is newly exposed. While the dirty region is merely
                        // showing out of date data on screen, this subset of it is showing remains of other
                        // windows. To avoid glitches, it must be set to a reasonable state as fast as possible,
                        // without waiting for a roundtrip to the window's Draw() methods. So it will be filled
                        // using background color and view bitmap, which can all be done without leaving
                        // app_server.
                        BRegion                         fExposeRegion;

                        // caching local regions
                        BRegion                         fContentRegion;
                        BRegion                         fEffectiveDrawingRegion;

                        bool                            fVisibleContentRegionValid : 1;
                        bool                            fContentRegionValid : 1;
                        bool                            fEffectiveDrawingRegionValid : 1;

                        ::RegionPool            fRegionPool;

                        BObjectList<Window> fSubsets;

                        ObjectDeleter<WindowBehaviour>
                                                                fWindowBehaviour;
                        ObjectDeleter<View>     fTopView;
                        ::ServerWindow*         fWindow;
                        ObjectDeleter<DrawingEngine>
                                                                fDrawingEngine;
                        ::Desktop*                      fDesktop;

                        // The synchronization, which client drawing commands
                        // belong to the redraw of which dirty region is handled
                        // through an UpdateSession. When the client has
                        // been informed that it should redraw stuff, then
                        // this is the current update session. All new
                        // redraw requests from the Desktop will go
                        // into the pending update session.
        class UpdateSession {
        public:
                                                                        UpdateSession();

                                void                            Include(BRegion* additionalDirty);
                                void                            Exclude(BRegion* dirtyInNextSession);

                inline  BRegion&                        DirtyRegion()
                                                                                { return fDirtyRegion; }

                                void                            MoveBy(int32 x, int32 y);

                                void                            SetUsed(bool used);
                inline  bool                            IsUsed() const
                                                                                { return fInUse; }

        private:
                                BRegion                         fDirtyRegion;
                                bool                            fInUse;
        };

                        UpdateSession           fUpdateSessions[2];
                        UpdateSession*          fCurrentUpdateSession;
                        UpdateSession*          fPendingUpdateSession;
                        // these two flags are supposed to ensure a sane
                        // and consistent update session
                        bool                            fUpdateRequested : 1;
                        bool                            fInUpdate : 1;
                        bool                            fUpdatesEnabled : 1;

                        bool                            fHidden : 1;
                        int32                           fShowLevel;
                        bool                            fMinimized : 1;
                        bool                            fIsFocus : 1;

                        window_look                     fLook;
                        window_feel                     fFeel;
                        uint32                          fOriginalFlags;
                        uint32                          fFlags;
                        uint32                          fWorkspaces;
                        int32                           fCurrentWorkspace;
                        int32                           fPriorWorkspace;

                        int32                           fMinWidth;
                        int32                           fMaxWidth;
                        int32                           fMinHeight;
                        int32                           fMaxHeight;

                        int32                           fWorkspacesViewCount;

                friend class DecorManager;

private:
                        WindowStack*            _InitWindowStack();

                        BReference<WindowStack>         fCurrentStack;
};


#endif // WINDOW_H