Пример #1
0
        public virtual void AddChild( Widget _widget, int _iIndex )
        {
            Debug.Assert( _widget.Parent == null );
            //Debug.Assert( _widget.Screen == Screen );

            _widget.Parent = this;
            mlChildren.Insert( _iIndex, _widget );
            UpdateContentSize();
        }
Пример #2
0
        //----------------------------------------------------------------------
        public void AddChild( Widget _widget, int _iIndex, bool _bExpand )
        {
            Debug.Assert( _widget.Parent == null );
            Debug.Assert( _widget.Screen == Screen );

            _widget.Parent = this;
            mlExpandedChildren.Insert( _iIndex, _bExpand );
            mlChildren.Insert( _iIndex, _widget );
            UpdateContentSize();
        }
Пример #3
0
        public void AddChildAt( Widget _child, int _iColumn, int _iRow )
        {
            Debug.Assert( ! maWidgetLocations.ContainsKey( _child ) );
            Debug.Assert( _child.Parent == null );

            //Debug.Assert( _child.Screen == Screen ); wtf??

            _child.Parent = this;

            maTiles[ _iColumn, _iRow ] = _child;
            maWidgetLocations[ _child ] = new Point( _iColumn, _iRow );
            mlChildren.Add( _child );
        }
Пример #4
0
        public virtual void RemoveChild( Widget _widget )
        {
            Debug.Assert( _widget.Parent == this );

            _widget.Parent = null;
            mlChildren.Remove( _widget );
            UpdateContentSize();
        }
Пример #5
0
        //----------------------------------------------------------------------
        public override Widget GetSibling( Direction _direction, Widget _child )
        {
            Widget nearestSibling = null;
            Widget focusableSibling = null;

            Widget fixedChild = (Widget)_child;

            foreach( Widget child in mlChildren )
            {
                if( child == _child ) continue;

                switch( _direction )
                {
                    case Direction.Up:
                        if( child.LayoutRect.Bottom <= fixedChild.LayoutRect.Center.Y && ( nearestSibling == null || child.LayoutRect.Bottom > nearestSibling.LayoutRect.Bottom ) )
                        {
                            Widget childFocusableWidget = child.GetFirstFocusableDescendant( _direction );
                            if( childFocusableWidget != null )
                            {
                                nearestSibling = child;
                                focusableSibling = childFocusableWidget;
                            }
                        }
                        break;
                    case Direction.Down:
                        if( child.LayoutRect.Top >= fixedChild.LayoutRect.Center.Y && ( nearestSibling == null || child.LayoutRect.Top < nearestSibling.LayoutRect.Top ) )
                        {
                            Widget childFocusableWidget = child.GetFirstFocusableDescendant( _direction );
                            if( childFocusableWidget != null )
                            {
                                nearestSibling = child;
                                focusableSibling = childFocusableWidget;
                            }
                        }
                        break;
                    case Direction.Left:
                        if( child.LayoutRect.Right <= fixedChild.LayoutRect.Center.X && ( nearestSibling == null || child.LayoutRect.Right > nearestSibling.LayoutRect.Right ) )
                        {
                            Widget childFocusableWidget = child.GetFirstFocusableDescendant( _direction );
                            if( childFocusableWidget != null )
                            {
                                nearestSibling = child;
                                focusableSibling = childFocusableWidget;
                            }
                        }
                        break;
                    case Direction.Right:
                        if( child.LayoutRect.Left >= fixedChild.LayoutRect.Center.X && ( nearestSibling == null || child.LayoutRect.Left < nearestSibling.LayoutRect.Left ) )
                        {
                            Widget childFocusableWidget = child.GetFirstFocusableDescendant( _direction );
                            if( childFocusableWidget != null )
                            {
                                nearestSibling = child;
                                focusableSibling = childFocusableWidget;
                            }
                        }
                        break;
                }
            }

            if( focusableSibling == null )
            {
                return base.GetSibling( _direction, this );
            }

            return focusableSibling;
        }
Пример #6
0
        //----------------------------------------------------------------------
        public override Widget GetSibling( Direction _direction, Widget _child )
        {
            int iIndex = mlButtons.IndexOf( (Button)_child );

            switch( _direction )
            {
                case Direction.Left:
                    if( iIndex > 0 )
                    {
                        return mlButtons[iIndex - 1];
                    }
                    break;
                case Direction.Right:
                    if( iIndex < mlButtons.Count - 1 )
                    {
                        return mlButtons[iIndex + 1];
                    }
                    break;
            }

            return base.GetSibling( _direction, this );
        }
Пример #7
0
        public virtual Widget GetSibling( UI.Direction _direction, Widget _child )
        {
            if( Parent != null )
            {
                return Parent.GetSibling( _direction, this );
            }

            return null;
        }
Пример #8
0
 public override void AddChild( Widget _widget, int _iIndex )
 {
     throw new NotSupportedException();
 }
Пример #9
0
        public override Widget GetSibling( Direction _direction, Widget _child )
        {
            Widget tileChild = null;
            Point childLocation = maWidgetLocations[ _child ];
            int iOffset = 0;

            do
            {
                iOffset++;

                switch( _direction )
                {
                    case Direction.Left:
                        if( childLocation.X - iOffset < 0 ) return base.GetSibling( _direction, _child );
                        tileChild = maTiles[ childLocation.X - iOffset, childLocation.Y ];
                        break;
                    case Direction.Right:
                        if( childLocation.X + iOffset >= maTiles.GetLength(0) ) return base.GetSibling( _direction, _child );
                        tileChild = maTiles[ childLocation.X + iOffset, childLocation.Y ];
                        break;
                    case Direction.Up:
                        if( childLocation.Y - iOffset < 0 ) return base.GetSibling( _direction, _child );
                        tileChild = maTiles[ childLocation.X, childLocation.Y - iOffset ];
                        break;
                    case Direction.Down:
                        if( childLocation.Y + iOffset >= maTiles.GetLength(1) ) return base.GetSibling( _direction, _child );
                        tileChild = maTiles[ childLocation.X, childLocation.Y + iOffset ];
                        break;
                }
            }
            while( tileChild == null );

            if( tileChild != null )
            {
                return tileChild;
            }
            else
            {
                return base.GetSibling( _direction, this );
            }
        }
Пример #10
0
        //----------------------------------------------------------------------
        public void HandleInput()
        {
            //------------------------------------------------------------------
            // Make sure we don't hold references to orphaned widgets
            if( FocusedWidget != null && FocusedWidget.IsOrphan ) FocusedWidget = null;
            if( HoveredWidget != null && HoveredWidget.IsOrphan )
            {
            #if !MONOGAME
                Game.Form.Cursor = System.Windows.Forms.Cursors.Default;
            #endif
                HoveredWidget = null;
            }

            if( mClickedWidget != null && mClickedWidget.IsOrphan ) mClickedWidget = null;

            //------------------------------------------------------------------
            Point mouseHitPoint = new Point(
                (int)( Game.InputMgr.MouseState.X / Resolution.ScaleFactor ),
                (int)( ( Game.InputMgr.MouseState.Y - Game.GraphicsDevice.Viewport.Y ) / Resolution.ScaleFactor )
            );

            if( ! IsActive )
            {
                if( HoveredWidget != null )
                {
                    HoveredWidget.OnMouseOut( mouseHitPoint );
                    HoveredWidget = null;
                }

                if( mClickedWidget != null )
                {
                    mClickedWidget.OnMouseUp( mouseHitPoint, miClickedWidgetMouseButton );
                    mClickedWidget = null;
                }

                return;
            }

            foreach( Buttons button in Enum.GetValues(typeof(Buttons)) )
            {
                PlayerIndex playerIndex;

                bool bPressed;

                if( Game.InputMgr.WasButtonJustPressed( button, Game.PlayerInCharge, out playerIndex, true ) )
                {
                    bPressed = true;
                }
                else
                if( Game.InputMgr.WasButtonJustReleased( button, Game.PlayerInCharge, out playerIndex ) )
                {
                    bPressed = false;
                }
                else
                {
                    continue;
                }

                switch( button )
                {
                    case Buttons.A:
                        if( FocusedWidget != null )
                        {
                            if( bPressed )
                            {
                                FocusedWidget.OnActivateDown();
                                mbHasActivatedFocusedWidget = true;
                            }
                            else
                            if( mbHasActivatedFocusedWidget )
                            {
                                FocusedWidget.OnActivateUp();
                                mbHasActivatedFocusedWidget = false;
                            }
                        }
                        break;
                    case Buttons.B:
                        if( FocusedWidget == null || ! FocusedWidget.OnCancel( bPressed ) )
                        {
                            Root.OnPadButton( button, bPressed );
                        }
                        break;
                    case Buttons.LeftThumbstickLeft:
                    case Buttons.DPadLeft:
                        if( bPressed && FocusedWidget != null ) FocusedWidget.OnPadMove( UI.Direction.Left );
                        break;
                    case Buttons.LeftThumbstickRight:
                    case Buttons.DPadRight:
                        if( bPressed && FocusedWidget != null ) FocusedWidget.OnPadMove( UI.Direction.Right );
                        break;
                    case Buttons.LeftThumbstickUp:
                    case Buttons.DPadUp:
                        if( bPressed && FocusedWidget != null ) FocusedWidget.OnPadMove( UI.Direction.Up );
                        break;
                    case Buttons.LeftThumbstickDown:
                    case Buttons.DPadDown:
                        if( bPressed && FocusedWidget != null ) FocusedWidget.OnPadMove( UI.Direction.Down );
                        break;
                    default:
                        Root.OnPadButton( button, bPressed );
                        break;
                }

            }

            #if WINDOWS || LINUX || MACOSX
            //------------------------------------------------------------------
            // Mouse buttons
            bool bHasMouseEvent = false;

            if( miIgnoreClickFrames == 0 )
            {
                for( int iButton = 0; iButton < 3; iButton++ )
                {
                    if( Game.InputMgr.WasMouseButtonJustPressed( iButton ) )
                    {
                        bHasMouseEvent = true;

                        if( mClickedWidget == null )
                        {
                            miClickedWidgetMouseButton = iButton;

                            Widget hitWidget = null;

                            if( FocusedWidget != null )
                            {
                                hitWidget = FocusedWidget.HitTest( mouseHitPoint );
                            }

                            if( hitWidget == null )
                            {
                                hitWidget = Root.HitTest( mouseHitPoint );
                            }

                            while( hitWidget != null && ! hitWidget.OnMouseDown( mouseHitPoint, iButton ) )
                            {
                                hitWidget = hitWidget.Parent;
                            }

                            mClickedWidget = hitWidget;
                        }
                    }
                }

                if( Game.InputMgr.WasMouseJustDoubleClicked() )
                {
                    bHasMouseEvent = true;

                    Widget widget  = FocusedWidget == null ? null : FocusedWidget.HitTest( mouseHitPoint );
                    if( widget != null )
                    {
                        bool bPressed;

                        switch( Game.InputMgr.PrimaryMouseButton )
                        {
                            case 0:
                                bPressed = Game.InputMgr.MouseState.LeftButton == ButtonState.Pressed;
                                break;
                            case 2:
                                bPressed = Game.InputMgr.MouseState.RightButton == ButtonState.Pressed;
                                break;
                            default:
                                throw new NotSupportedException();
                        }

                        if( bPressed )
                        {
                            mClickedWidget = widget;
                            miClickedWidgetMouseButton = Game.InputMgr.PrimaryMouseButton;
                        }

                        if( widget.OnMouseDoubleClick( mouseHitPoint ) )
                        {
                            miIgnoreClickFrames = 3;
                        }
                    }
                }
            }
            else
            {
                miIgnoreClickFrames--;
            }

            for( int iButton = 0; iButton < 3; iButton++ )
            {
                if( Game.InputMgr.WasMouseButtonJustReleased( iButton ) )
                {
                    bHasMouseEvent = true;

                    if( mClickedWidget != null && iButton == miClickedWidgetMouseButton )
                    {
                        mClickedWidget.OnMouseUp( mouseHitPoint, iButton );
                        mClickedWidget = null;
                    }
                }
            }

            if( ! bHasMouseEvent )
            {
                Widget hoveredWidget = ( FocusedWidget == null ? null : FocusedWidget.HitTest( mouseHitPoint ) ) ?? Root.HitTest( mouseHitPoint );

                if( mouseHitPoint != mPreviousMouseHitPoint )
                {
                    if( mClickedWidget == null )
                    {
                        if( hoveredWidget != null && hoveredWidget == HoveredWidget )
                        {
                            HoveredWidget.OnMouseMove( mouseHitPoint );
                        }
                        else
                        {
                            if( HoveredWidget != null )
                            {
                                HoveredWidget.OnMouseOut( mouseHitPoint );
                            }

                            HoveredWidget = hoveredWidget;
                            if( HoveredWidget != null )
                            {
                                HoveredWidget.OnMouseEnter( mouseHitPoint );
                            }
                        }
                    }
                    else
                    {
                        mClickedWidget.OnMouseMove( mouseHitPoint );
                    }
                }
            }

            // Mouse wheel
            int iWheelDelta = Game.InputMgr.GetMouseWheelDelta();
            if( iWheelDelta != 0 )
            {
                Widget hoveredWidget = ( FocusedWidget == null ? null : FocusedWidget.HitTest( mouseHitPoint ) ) ?? Root.HitTest( mouseHitPoint );

                if( hoveredWidget != null )
                {
                    hoveredWidget.OnMouseWheel( mouseHitPoint, iWheelDelta );
                }
            }

            mPreviousMouseHitPoint = mouseHitPoint;

            //------------------------------------------------------------------
            // Keyboard
            if( FocusedWidget != null )
            {
                foreach( char character in Game.InputMgr.EnteredText )
                {
                    FocusedWidget.OnTextEntered( character );
                }

                foreach( Keys key in Game.InputMgr.JustPressedKeys )
                {
                    FocusedWidget.OnKeyPress( key );
                }

                foreach( var key in Game.InputMgr.JustPressedOSKeys )
                {
                    FocusedWidget.OnOSKeyPress( key );
                }

            }
            #endif
        }
Пример #11
0
        //----------------------------------------------------------------------
        public void Focus( Widget _widget )
        {
            Debug.Assert( _widget.Screen == this );

            mbHasActivatedFocusedWidget = false;
            if( FocusedWidget != null && FocusedWidget != _widget )
            {
                FocusedWidget.OnBlur();
            }

            if( FocusedWidget != _widget )
            {
                FocusedWidget = _widget;
                FocusedWidget.OnFocus();
            }
        }
Пример #12
0
        //----------------------------------------------------------------------
        public override Widget GetSibling( Direction _direction, Widget _child )
        {
            int iIndex = mlChildren.IndexOf( _child );

            if( mOrientation == Orientation.Horizontal )
            {
                if( _direction == Direction.Right )
                {
                    if( iIndex < mlChildren.Count - 1 )
                    {
                        return mlChildren[iIndex + 1];
                    }
                }
                else
                if( _direction == Direction.Left )
                {
                    if( iIndex > 0 )
                    {
                        return mlChildren[iIndex - 1];
                    }
                }
            }
            else
            {
                if( _direction == Direction.Down )
                {
                    if( iIndex < mlChildren.Count - 1 )
                    {
                        return mlChildren[iIndex + 1];
                    }
                }
                else
                if( _direction == Direction.Up )
                {
                    if( iIndex > 0 )
                    {
                        return mlChildren[iIndex - 1];
                    }
                }
            }

            return base.GetSibling( _direction, this );
        }
Пример #13
0
 public void AddChild( Widget _widget, bool _bExpand )
 {
     AddChild( _widget, mlChildren.Count, _bExpand );
 }
Пример #14
0
 public override void AddChild( Widget _widget, int _iIndex )
 {
     AddChild( _widget, _iIndex, false );
 }
Пример #15
0
 public void AddChild( Widget _widget )
 {
     AddChild( _widget, mlChildren.Count );
 }
Пример #16
0
        public override void RemoveChild( Widget _widget )
        {
            Debug.Assert( _widget.Parent == this );

            _widget.Parent = null;

            Point widgetLocation = maWidgetLocations[ _widget ];
            maWidgetLocations.Remove( _widget );

            maTiles[ widgetLocation.X, widgetLocation.Y ] = null;
            mlChildren.Remove( _widget );
        }
Пример #17
0
        public override void RemoveChild( Widget _widget )
        {
            Debug.Assert( _widget.Parent == this );

            _widget.Parent = null;

            mlExpandedChildren.RemoveAt( mlChildren.IndexOf( _widget ) );

            mlChildren.Remove( _widget );
            UpdateContentSize();
        }