    //------------------------------------------------------------------------------
    // emView.h
    //
    // Copyright (C) 2004-2010 Oliver Hamann.
    //
    // Homepage: http://eaglemode.sourceforge.net/
    //
    // This program is free software: you can redistribute it and/or modify it under
    // the terms of the GNU General Public License version 3 as published by the
    // Free Software Foundation.
    //
    // This program is distributed in the hope that it will be useful, but WITHOUT
    // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    // FOR A PARTICULAR PURPOSE. See the GNU General Public License version 3 for
    // more details.
    //
    // You should have received a copy of the GNU General Public License version 3
    // along with this program. If not, see <http://www.gnu.org/licenses/>.
    //------------------------------------------------------------------------------

    #ifndef emView_h
    #define emView_h

    #ifndef emCursor_h
    #include <emCore/emCursor.h>
    #endif

    #ifndef emInput_h
    #include <emCore/emInput.h>
    #endif

    #ifndef emPainter_h
    #include <emCore/emPainter.h>
    #endif

    #ifndef emCoreConfig_h
    #include <emCore/emCoreConfig.h>
    #endif

    class emPanel;
    class emViewPort;
    class emWindow;
    class emScreen;

    //==============================================================================
    //=================================== emView ===================================
    //==============================================================================

    class emView : public emContext {

    public:

            // An emView is a rectangle on the screen in which the user can see a
            // tree of panels (see class emPanel). If not disabled by a feature
            // flag, the user can navigate through the panels by zooming, scrolling
            // and moving the focus.
            //
            // After constructing an emView, an appropriate emViewPort should be
            // created on it. Otherwise the view is not connected to any screen or
            // input device (it uses an internal dummy emViewPort then). See the
            // derived class emWindow - it solves the problem of connecting the
            // view. Another solution is the class emSubViewPanel.
            //
            // Even, emView does not create any panels. This should also be done by
            // the caller.
            //
            // emView has been derived from emContext so that it is easy to define
            // custom view settings as models of that context.

            typedef int ViewFlags;
                    // Data type for the feature flags of a view. Possible flags
                    // are:
            enum {
                    VF_POPUP_ZOOM         =(1<<0),
                            // The view pops up whenever the view is zoomed. For
                            // this feature to work, an emScreen must be in the path
                            // of contexts, so that the view is able to create a
                            // private emWindow as the popup.
                    VF_ROOT_SAME_TALLNESS =(1<<1),
                            // The root panel always has the same tallness as the
                            // view. This is highly recommended when using
                            // VF_POPUP_ZOOM.
                    VF_NO_ZOOM            =(1<<2),
                            // The view is always zoomed out. This implies having
                            // VF_NO_USER_NAVIGATION and not having VF_POPUP_ZOOM
                            // and not having VF_EGO_MODE.
                    VF_NO_USER_NAVIGATION =(1<<3),
                            // The user cannot navigate in the view.
                    VF_NO_FOCUS_HIGHLIGHT =(1<<4),
                            // The view does not show any focus highlight.
                    VF_NO_ACTIVE_HIGHLIGHT=(1<<5),
                            // The view does not show any active highlight.
                    VF_EGO_MODE           =(1<<6),
                            // This is a special mode of user interaction. The mouse
                            // pointer is degenerated to a cross-hair in the center
                            // of the view, and each mouse movement scrolls the
                            // view. This mode should not be used when there are
                            // multiple windows or views on the screen, because the
                            // mouse pointer cannot be moved. The name "ego mode"
                            // has been chosen because it is somehow similar to the
                            // mouse control in ego shooter games.
                    VF_STRESS_TEST        =(1<<7)
                            // This repaints the view on every time slice and shows
                            // the frame rate in the upper-left corner. This feature
                            // exists for use by developers.
            };

            emView(emContext & parentContext, ViewFlags viewFlags=0);
                    // Constructor.
                    // Arguments:
                    //   parentContext - Parent context for this new context.
                    //   viewFlags     - Initial feature flags.

            virtual ~emView();
                    // Destructor. If a real view port has been created for this
                    // view, it must be deleted before destructing the view. In
                    // addition, it is always a good idea to delete the root panel
                    // by destructors of derived classes, just because a panel could
                    // depend on the properties of the derivative. For example,
                    // emPanel::GetWindow() must not be used after destructing the
                    // emWindow, and therefore the destructor of emWindow deletes
                    // the panels itself.

            void LinkCrossPtr(emCrossPtrPrivate & crossPtr);
                    // This means emCrossPtr<emView> is possible.

            ViewFlags GetViewFlags() const;
            void SetViewFlags(ViewFlags viewFlags);
                    // Get or set the features of this view.

            const emSignal & GetViewFlagsSignal() const;
                    // This signal is signaled when the features of this view have
                    // changed.

            emColor GetBackgroundColor() const;
            void SetBackgroundColor(emColor c);
                    // Get or set the background color of this view. This color is
                    // used for areas which are not covered by the panels, or where
                    // the panels are transparent. The default is some grey.

            virtual emString GetTitle();
                    // Get the title to be shown for this view. The default
                    // implementation returns the title of the active panel (not
                    // directly, but updated through an engine). See also:
                    // InvalidateTitle()

            const emSignal & GetTitleSignal() const;
                    // This signal is signaled when the title has changed.

            emPanel * CreateControlPanel(emPanel & parent, const emString & name);
                    // If this is a content view, this method may be called to
                    // create a control panel in a control view. The call is
                    // forwarded to the active panel. The result can be NULL which
                    // means to have no control panel. The caller should delete the
                    // control panel before calling CreateControlPanel again, and
                    // before destructing this view.

            const emSignal & GetControlPanelSignal() const;
                    // This signal is signaled when the control panel should be
                    // recreated.

            bool IsFocused() const;
                    // Whether this view has the focus.

            const emSignal & GetFocusSignal();
                    // This signal is signaled when the focus of this view has
                    // changed.

            void Focus();
                    // Make that this view has the focus, if possible by the
                    // emViewPort implementation. Hint: If this is an emWindow, you
                    // may want to call Raise() before.

            emWindow * GetWindow();
                    // Get the window of this view. It returns the nearest window
                    // within the path of contexts to this view. If this view itself
                    // is a window, that window is returned. If no window can be
                    // found, NULL is returned. The result is cached internally.

            emScreen * GetScreen();
                    // Get the screen of this view. If GetWindow() returns non-NULL,
                    // the screen of that window is returned. Otherwise the call is
                    // forwarded to emScreen::LookupInherited(*this). The result is
                    // cached internally.

            double GetHomeX() const;
            double GetHomeY() const;
            double GetHomeWidth() const;
            double GetHomeHeight() const;
            double GetHomePixelTallness() const;
            double GetHomeTallness() const;
                    // Get the home geometry of this view on the screen. "Home"
                    // means the state where the view is not popped up by the
                    // popup-zoom feature. X, Y, Width and Height are the
                    // coordinates of the view rectangle, measured in pixels on the
                    // screen. PixelTallness is the height/width ratio of the pixels
                    // on the monitor (as far as known by the implementation of
                    // emViewPort). And Tallness is the height/width ration of the
                    // view on the monitor. It is equal to
                    // Height/Width*PixelTallness.

            double GetCurrentX() const;
            double GetCurrentY() const;
            double GetCurrentWidth() const;
            double GetCurrentHeight() const;
            double GetCurrentPixelTallness() const;
            double GetCurrentTallness() const;
                    // Get the current geometry of this view on the screen. This is
                    // like GetHomeX(), GetHomeY() and so on, but if the view is
                    // currently popped up by the popup-zoom feature, the geometry
                    // of the popup is returned (should not make any difference for
                    // PixelTallness).

            const emSignal & GetGeometrySignal() const;
                    // This signal is signaled when the home geometry or the current
                    // geometry of this view has changed.

            emPanel * GetRootPanel();
                    // Get the root panel of this view. Returns NULL when this view
                    // has no panels.

            emPanel * GetSupremeViewedPanel();
                    // Get the supreme viewed panel. It is the upper-most panel in
                    // the panel tree which has IsViewed()==true. Returns NULL when
                    // this view has no panels. The supreme viewed panel is always
                    // chosen automatically by the view, depending on the visit
                    // state.

            emPanel * GetActivePanel();
                    // Get the active panel. The active panel is the panel which is
                    // focused when the view is focused. Returns NULL when this view
                    // has no panels.

            emPanel * GetPanelByIdentity(const char * identity);
                    // Search for a panel by identity (see emPanel::GetIdentity()).
                    // Returns NULL if not found.

            emPanel * GetPanelAt(double x, double y);
                    // Get the uppermost panel at the given point.

            emPanel * GetFocusablePanelAt(double x, double y);
                    // Get the uppermost focusable panel at the given point.

            emPanel * GetVisitedPanel(double * pRelX=NULL, double * pRelY=NULL,
                                      double * pRelA=NULL, bool * pAdherent=NULL);
                    // Get the visited panel and optionally relative coordinates and
                    // the visit type. The visited panel is the one on which the
                    // view is currently anchored. That means, if any panel layout
                    // is changed, the visited panel keeps its position within the
                    // view.
                    // Arguments:
                    //   pRelX, pRelY - Pointers for returning the distance vector
                    //                  between the center of the view and the
                    //                  center of the panel, measured in view widths
                    //                  and heights.
                    //   pRelA        - Pointer for returning the area size of view
                    //                  relative to the area size of the panel.
                    //   pAdherent    - Pointer for returning IsVisitAdherent().
                    // Returns:
                    //   The visited panel, or NULL if this view has no panels.

            bool IsVisitAdherent() const;
                    // Whether the visit is adherent. It usually means that the
                    // visit has been set by the user.

            void Visit(emPanel * panel, bool adherent);
                    // Visit a panel. This makes sure that the given panel is
                    // visible and that is is shown not too large and not too small,
                    // and it makes the panel the visited panel.
                    // Arguments:
                    //   panel    - The panel to be visited.
                    //   adherent - Whether the visit shall be adherent.

            void Visit(emPanel * panel, double relX, double relY, double relA,
                       bool adherent);
                    // Visit a panel and position the view relative to it. The
                    // arguments are exactly the things which you can get with
                    // GetVisitedPanel(...) (read there). But if relA is less or
                    // equal 0.0, VisitFullsized(panel,adherent) is performed.

            void VisitBy(emPanel * panel, double relX, double relY, double relA);
                    // Position the view relative to a panel and give the visit to
                    // any panel which is somehow shown centered and well-sized by
                    // the new position. The arguments are like with the Visit
                    // method above.

            void VisitLazy(emPanel * panel, bool adherent);
                    // Visit a panel while being lazy in positioning the view.

            void VisitFullsized(emPanel * panel, bool adherent);
                    // Visit a panel and position the view so that the panel is
                    // shown full-sized.

            void VisitByFullsized(emPanel * panel);
                    // Position the view so that the given panel is shown full-sized
                    // and give the visit to any panel which is somehow shown
                    // centered and well-sized by the new position.

            void VisitNext();
            void VisitPrev();
            void VisitFirst();
            void VisitLast();
            void VisitLeft();
            void VisitRight();
            void VisitUp();
            void VisitDown();
            void VisitNeighbour(int direction);
            void VisitIn();
            void VisitOut();
                    // Visit a sister, parent or child of the currently visited
                    // panel. This walks the tree of focusable panels only.
                    // VisitNeighbour(0) is like VisitRight(), 1 like Down, 2 like
                    // Left and 3 like Up.

            void Seek(const char * identity, bool adherent,
                      const char * subject=NULL);
            void Seek(const char * identity, double relX, double relY, double relA,
                      bool adherent, const char * subject=NULL);
            void SeekBy(const char * identity, double relX, double relY,
                        double relA, const char * subject=NULL);
            void SeekLazy(const char * identity, bool adherent,
                          const char * subject=NULL);
            void SeekFullsized(const char * identity, bool adherent,
                               const char * subject=NULL);
            void SeekByFullsized(const char * identity, const char * subject=NULL);
                    // These methods are like Visit, VisitBy, VisitLazy and so on,
                    // but: The panel is referred by its identity instead of a
                    // pointer. And, if the panel cannot be found immediately, a
                    // seek algorithm is started which runs in a private engine
                    // possibly for long time. The algorithm visits panels on the
                    // path to the desired panel step by step, in the hope they are
                    // expanding the path accordingly. For the whole time, the view
                    // shows an info box and allows the user to abort the seeking by
                    // any input. The additional argument 'subject' can be set to
                    // give a nice name for the sought panel in the info box.

            bool IsSeeking() const;
                    // Whether the view is currently seeking for a panel.

            void AbortSeeking();
                    // Abort any seeking.

            void Zoom(double fixX, double fixY, double factor);
                    // Zoom the view.
                    // Arguments:
                    //   fixX, fixY - Fix point for the zooming.
                    //   factor     - Zoom factor. A value less than 1.0 means to
                    //                zoom out, and a value greater than 1.0 means
                    //                to zoom in.

            void Scroll(double deltaX, double deltaY);
                    // Scroll the view.
                    // Arguments:
                    //   deltaX - How much to scroll in X direction (positive value
                    //            means to scroll right).
                    //   deltaY - How much to scroll in Y direction (positive value
                    //            means to scroll down).

            void ZoomOut();
                    // Zoom out the view completely.

            bool IsZoomedOut();
                    // Whether the view is currently zoomed out completely.

            bool IsPoppedUp() const;
                    // Whether the view is in popped up state.

            void SignalEOIDelayed();
                    // After calling this, the End-Of-Interaction signal will be
                    // signaled, but with a delay of some time slices.

            const emSignal & GetEOISignal() const;
                    // Get the End-Of-Interaction signal. This signal indicates an
                    // end of a temporary user interaction. It has been invented for
                    // emTkButton (see emTkButton::IsNoEOI()). If the view has
                    // VF_POPUP_ZOOM set, the application should call ZoomOut() when
                    // an EOI has been signaled.

    protected:

            virtual void Input(emInputEvent & event, const emInputState & state);
                    // Process input form keyboard and mouse. The default
                    // implementation performs user navigation, and it forward to
                    // the panels.
                    // Arguments:
                    //   event  - An input event. It may be eaten by calling
                    //            event.Eat(). The event reference in non-const only
                    //            for that.
                    //   state  - The current input state.

            virtual emCursor GetCursor();
                    // Get the mouse cursor to be shown for this view. The default
                    // implementation returns the cursor of the panel where the
                    // mouse is. See also: InvalidateCursor()

            virtual void Paint(const emPainter & painter, emColor canvasColor);
                    // Paint this view. The default implementation paints the
                    // panels, the focus and an info box when seeking.
                    // Arguments:
                    //   painter     - A painter for painting the view to the
                    //                 screen. Origin and scaling of this painter
                    //                 are prepared for having the coordinate system
                    //                 of the screen.
                    //   canvasColor - Color of the canvas.
                    // See also: InvalidatePainting()

            virtual void InvalidateTitle();
                    // Indicate a change in the results of GetTitle(). The default
                    // implementation simply signals the title signal (see
                    // GetTitleSignal()).

            void InvalidateCursor();
                    // Indicate a change in the results of GetCursor(). After
                    // calling this, showings of the cursor will be updated.

            void InvalidatePainting();
            void InvalidatePainting(double x, double y, double w, double h);
                    // Indicate a change in the results of Paint(). After calling
                    // this, the view will be re-painted. The second version of the
                    // method allows to invalidate just a rectangular area instead
                    // of the whole view.
                    // Arguments:
                    //   x,y,w,h - Upper-left corner and size of the rectangle.

            virtual void DoCustomCheat(const char * func);
                    // This method could be overloaded for implementing custom cheat
                    // codes. For example, if the user enters "chEat:abc!", this
                    // method is called with func="abc". The default implementation
                    // calls the ancestor view, if there. For the cheat codes
                    // implemented by emView itself, see the implementation of
                    // emView::DoCheats.

    private:
            friend class emViewPort;
            friend class emPanel;
            friend class emSubViewPanel;

            struct PanelRingNode {
                    PanelRingNode * Prev;
                    PanelRingNode * Next;
            };

            void SetFocused(bool focused);
            void SetGeometry(double x, double y, double width, double height,
                             double pixelTallness);

            void AddToNoticeList(PanelRingNode * node);

            void Update();

            void CalcVisitFullsizedCoords(emPanel * panel, double * pRelX,
                                          double * pRelY, double * pRelA);

            void VisitRelBy(emPanel * panel, double relX, double relY, double relA,
                            bool forceViewingUpdate);
            void VisitRel(emPanel * panel, double relX, double relY, double relA,
                          bool adherent, bool forceViewingUpdate);
            void VisitAbs(emPanel * panel, double vx, double vy, double vw,
                          bool adherent, bool forceViewingUpdate);
            void VisitImmobile(emPanel * panel, bool adherent);

            void FindBestSVP(emPanel * * pPanel, double * pVx, double * pVy,
                             double * pVw);
            bool FindBestSVPInTree(emPanel * * pPanel, double * pVx, double * pVy,
                                   double * pVw, bool covering);

            void SwapViewPorts(bool swapFocus);

            void NavigateByUser(emInputEvent & event, emInputState & state);
            void NavigateByProgram(emInputEvent & event, emInputState & state);

            void EmulateMiddleButton(emInputEvent & event, emInputState & state);

            void DoCheats(emInputEvent & event, emInputState & state);

            void RecurseInput(emInputEvent & event,
                              const emInputState & state);
            void RecurseChildrenInput(emPanel * parent, double mx, double my,
                                      emInputEvent & event,
                                      const emInputState & state);

            bool MoveMousePointerBackIntoView(double * pmx, double * pmy);
            void MoveMousePointer(double dx, double dy);

            void InvalidateHighlight();
            void PaintHighlight(const emPainter & painter);

            double GetMouseZoomSpeed(bool fine) const;
            double GetMouseScrollSpeed(bool fine) const;
            double GetWheelZoomSpeed(bool fine) const;
            double GetKeyboardZoomSpeed(bool fine) const;
            double GetKeyboardScrollSpeed(bool fine) const;

            void SetSeekPos(emPanel * panel, const char * childName);
            bool IsHopeForSeeking();

            void SetActivationCandidate(emPanel * panel);

            class UpdateEngineClass : public emEngine {
            public:
                    UpdateEngineClass(emView & view);
            protected:
                    virtual bool Cycle();
            private:
                    emView & View;
            };
            friend class UpdateEngineClass;

            class ActivationEngineClass : public emEngine {
            public:
                    ActivationEngineClass(emView & view);
            protected:
                    virtual bool Cycle();
            private:
                    emView & View;
            };
            friend class ActivationEngineClass;

            class EOIEngineClass : public emEngine {
            public:
                    EOIEngineClass(emView & view);
            protected:
                    virtual bool Cycle();
            private:
                    emView & View;
                    int CountDown;
            };
            friend class EOIEngineClass;

            class SmoothKBNaviEngineClass : public emEngine {
            public:
                    SmoothKBNaviEngineClass(emView & view);
                    void Input(emInputEvent & event, const emInputState & state);
            protected:
                    virtual bool Cycle();
            private:
                    emView & View;
                    enum {
                            DIR_LEFT=1<<0, DIR_RIGHT=1<<1, DIR_UP=1<<2,
                            DIR_DOWN=1<<3, DIR_IN=1<<4, DIR_OUT=1<<5
                    };
                    int Dir;
                    bool Fine;
                    emUInt64 LastClock;
            };
            friend class SmoothKBNaviEngineClass;

            class SeekEngineClass : public emEngine {
            public:
                    SeekEngineClass(
                            emView & view, int seekType, const emString & identity,
                            double relX, double relY, double relA, bool adherent,
                            const emString & subject
                    );
                    virtual ~SeekEngineClass();
                    void Input(emInputEvent & event, const emInputState & state);
                    void Paint(const emPainter & painter);
            protected:
                    virtual bool Cycle();
            private:
                    emView & View;
                    int SeekType;
                    emString Identity;
                    double RelX,RelY,RelA;
                    bool Adherent;
                    emString Subject;
                    emArray<emString> Names;
                    int TimeSlicesWithoutHope;
                    bool GiveUp;
                    emUInt64 GiveUpClock;
            };
            friend class SeekEngineClass;

            class StressTestClass : public emEngine {
            public:
                    StressTestClass(emView & view);
                    virtual ~StressTestClass();
                    void PaintInfo(const emPainter & painter);
            protected:
                    virtual bool Cycle();
            private:
                    emView & View;
                    int TCnt,TPos,TValid;
                    emUInt64 * T;
                    double FrameRate;
                    emUInt64 FRUpdate;
            };
            friend class StressTestClass;

            emCrossPtrList CrossPtrList;
            emRef<emCoreConfig> CoreConfig;
            emViewPort * DummyViewPort;
            emViewPort * HomeViewPort;
            emViewPort * CurrentViewPort;
            emWindow * WindowPtrCache;
            emRef<emModel> ScreenRefCache;
            bool WindowPtrValid;
            bool ScreenRefValid;
            emWindow * PopupWindow;
            emPanel * RootPanel;
            emPanel * SupremeViewedPanel;
            emPanel * MinSVP, * MaxSVP;
            emPanel * ActivePanel;
            emPanel * ActivationCandidate;
            emPanel * VisitedPanel;
            emSignal ViewFlagsSignal;
            emSignal TitleSignal;
            emSignal ControlPanelSignal;
            emSignal FocusSignal;
            emSignal GeometrySignal;
            emSignal EOISignal;
            emUInt64 PanelCreationNumber;
            double HomeX,HomeY,HomeWidth,HomeHeight,HomePixelTallness;
            double CurrentX,CurrentY,CurrentWidth,CurrentHeight,
                   CurrentPixelTallness;
            double LastMouseX,LastMouseY,ZoomFixX,ZoomFixY;
            emString Title;
            emCursor Cursor;
            emColor BackgroundColor;
            ViewFlags VFlags;
            bool Focused;
            bool VisitAdherent;
            bool ZoomScrollInAction;
            bool TitleInvalid;
            bool CursorInvalid;
            bool SVPChoiceInvalid;
            bool SVPChoiceByOpacityInvalid;
            bool GotPopupWindowCloseSignal;
            bool RestartInputRecursion;
            bool ZoomedOutBeforeSG;
            int SettingGeometry;
            int SVPUpdCount;
            emUInt64 SVPUpdSlice;
            emInputEvent NoEvent;
            PanelRingNode NoticeList;
            UpdateEngineClass * UpdateEngine;
            ActivationEngineClass * ActivationEngine;
            EOIEngineClass * EOIEngine;
            SmoothKBNaviEngineClass * SmoothKBNaviEngine;
            SeekEngineClass * SeekEngine;
            int ProtectSeeking;
            emPanel * SeekPosPanel;
            emString SeekPosChildName;
            StressTestClass * StressTest;
            int NavByProgState;
            emUInt64 EmuMidButtonTime;
            int EmuMidButtonRepeat;
            char CheatBuffer[64];

            static const double MaxSVPSize;
            static const double MaxSVPSearchSize;
    };

    //==============================================================================
    //================================= emViewPort =================================
    //==============================================================================

    class emViewPort : public emUncopyable {

    public:

            // Base class for the connection between an emView and the operating
            // system or the hardware or whatever. The default implementation
            // connects the view to nothing. When a view is constructed, it creates
            // such a dummy view port just to have a view port at all. A real view
            // port should be created on the view afterwards. For example, this is
            // solved in emWindow by creating an emWindowPort, which is a derivative
            // of emViewPort.
            //
            // Note that emView implements some tricks for solving the popup-zoom
            // feature. When popping up, the view creates a private emWindow and
            // exchanges the view port of that window for its own view port
            // temporarily. A view port derivative must come clear with such an
            // exchange (do not store any references to the view in it).
            //
            // The title is not interfaced through emViewPort (but through
            // emWindowPort) because it must not be exchanged when the view pops up.
            //
            // The popup-zoom feature is even the reason why all views must share
            // the same coordinate system. It should be the coordinate system of
            // screen.

            emViewPort(emView & homeView);

            virtual ~emViewPort();

    protected:

            void SetViewGeometry(double x, double y, double w, double h,
                                 double pixelTallness);

            double GetViewX() const;
            double GetViewY() const;
            double GetViewWidth() const;
            double GetViewHeight() const;

            void SetViewFocused(bool focused);
            virtual void RequestFocus();

            void InputToView(emInputEvent & event, const emInputState & state);

            emCursor GetViewCursor();

            void PaintView(const emPainter & painter, emColor canvasColor);

            virtual void InvalidateCursor();

            virtual void InvalidatePainting(double x, double y, double w, double h);

    private:
            friend class emView;
            emViewPort();
            emView * HomeView;
            emView * CurrentView;
    };

    //==============================================================================
    //============================== Implementations ===============================
    //==============================================================================

    //----------------------------------- emView -----------------------------------

    inline void emView::LinkCrossPtr(emCrossPtrPrivate & crossPtr)
    {
            CrossPtrList.LinkCrossPtr(crossPtr);
    }

    inline emView::ViewFlags emView::GetViewFlags() const
    {
            return VFlags;
    }

    inline const emSignal & emView::GetViewFlagsSignal() const
    {
            return ViewFlagsSignal;
    }

    inline emColor emView::GetBackgroundColor() const
    {
            return BackgroundColor;
    }

    inline const emSignal & emView::GetTitleSignal() const
    {
            return TitleSignal;
    }

    inline const emSignal & emView::GetControlPanelSignal() const
    {
            return ControlPanelSignal;
    }

    inline bool emView::IsFocused() const
    {
            return Focused;
    }

    inline const emSignal & emView::GetFocusSignal()
    {
            return FocusSignal;
    }

    inline double emView::GetHomeX() const
    {
            return HomeX;
    }

    inline double emView::GetHomeY() const
    {
            return HomeY;
    }

    inline double emView::GetHomeWidth() const
    {
            return HomeWidth;
    }

    inline double emView::GetHomeHeight() const
    {
            return HomeHeight;
    }

    inline double emView::GetHomePixelTallness() const
    {
            return HomePixelTallness;
    }

    inline double emView::GetHomeTallness() const
    {
            return HomeHeight/HomeWidth*HomePixelTallness;
    }

    inline double emView::GetCurrentX() const
    {
            return CurrentX;
    }

    inline double emView::GetCurrentY() const
    {
            return CurrentY;
    }

    inline double emView::GetCurrentWidth() const
    {
            return CurrentWidth;
    }

    inline double emView::GetCurrentHeight() const
    {
            return CurrentHeight;
    }

    inline double emView::GetCurrentPixelTallness() const
    {
            return CurrentPixelTallness;
    }

    inline double emView::GetCurrentTallness() const
    {
            return CurrentHeight/CurrentWidth*CurrentPixelTallness;
    }

    inline const emSignal & emView::GetGeometrySignal() const
    {
            return GeometrySignal;
    }

    inline emPanel * emView::GetRootPanel()
    {
            return RootPanel;
    }

    inline emPanel * emView::GetSupremeViewedPanel()
    {
            return SupremeViewedPanel;
    }

    inline emPanel * emView::GetActivePanel()
    {
            return ActivePanel;
    }

    inline bool emView::IsVisitAdherent() const
    {
            return VisitAdherent;
    }

    inline bool emView::IsSeeking() const
    {
            return SeekEngine!=NULL;
    }

    inline bool emView::IsPoppedUp() const
    {
            return PopupWindow!=NULL;
    }

    inline const emSignal & emView::GetEOISignal() const
    {
            return EOISignal;
    }

    inline void emView::InvalidateCursor()
    {
            CurrentViewPort->InvalidateCursor();
    }

    inline void emView::InvalidatePainting()
    {
            CurrentViewPort->InvalidatePainting(
                    CurrentX,CurrentY,CurrentWidth,CurrentHeight
            );
    }

    inline void emView::InvalidatePainting(double x, double y, double w, double h)
    {
            CurrentViewPort->InvalidatePainting(x,y,w,h);
    }

    //--------------------------------- emViewPort ---------------------------------

    inline void emViewPort::SetViewGeometry(
            double x, double y, double w, double h, double pixelTallness
    )
    {
            CurrentView->SetGeometry(x,y,w,h,pixelTallness);
    }

    inline double emViewPort::GetViewX() const
    {
            return CurrentView->GetCurrentX();
    }

    inline double emViewPort::GetViewY() const
    {
            return CurrentView->GetCurrentY();
    }

    inline double emViewPort::GetViewWidth() const
    {
            return CurrentView->GetCurrentWidth();
    }

    inline double emViewPort::GetViewHeight() const
    {
            return CurrentView->GetCurrentHeight();
    }

    inline void emViewPort::SetViewFocused(bool focused)
    {
            CurrentView->SetFocused(focused);
    }

    inline void emViewPort::InputToView(
            emInputEvent & event, const emInputState & state
    )
    {
            CurrentView->Input(event,state);
    }

    inline emCursor emViewPort::GetViewCursor()
    {
            return CurrentView->GetCursor();
    }

    inline void emViewPort::PaintView(
            const emPainter & painter, emColor canvasColor
    )
    {
            CurrentView->Paint(painter,canvasColor);
    }

    #endif