Пример #1
0
 public override void checkHoverWidget(MouseMoveEventArgs e)
 {
     base.checkHoverWidget (e);
     if (child != null)
         if (child.MouseIsIn (e.Position))
             child.checkHoverWidget (e);
 }
Пример #2
0
 public override void onMouseMove(object sender, MouseMoveEventArgs e)
 {
     base.onMouseMove (sender, e);
     if (CurrentInterface.Mouse.LeftButton == ButtonState.Released)
         return;
     updateMouseLocalPos (e.Position);
 }
Пример #3
0
        public override void onMouseMove(object sender, MouseMoveEventArgs e)
        {
            base.onMouseMove(sender, e);

            Interface otkgw = IFace;

            if (!hoverBorder)
            {
                currentDirection  = Direction.None;
                IFace.MouseCursor = XCursor.Default;
                return;
            }

            if (this.HasFocus && movable)
            {
                if (e.Mouse.IsButtonDown(MouseButton.Left))
                {
                    MoveAndResize(e.XDelta, e.YDelta, currentDirection);
                    return;
                }
            }
            if (Resizable)
            {
                Direction lastDir = currentDirection;

                if (Math.Abs(e.Position.Y - this.Slot.Y) < Interface.BorderThreshold)
                {
                    if (Math.Abs(e.Position.X - this.Slot.X) < Interface.BorderThreshold)
                    {
                        currentDirection = Direction.NW;
                    }
                    else if (Math.Abs(e.Position.X - this.Slot.Right) < Interface.BorderThreshold)
                    {
                        currentDirection = Direction.NE;
                    }
                    else
                    {
                        currentDirection = Direction.N;
                    }
                }
                else if (Math.Abs(e.Position.Y - this.Slot.Bottom) < Interface.BorderThreshold)
                {
                    if (Math.Abs(e.Position.X - this.Slot.X) < Interface.BorderThreshold)
                    {
                        currentDirection = Direction.SW;
                    }
                    else if (Math.Abs(e.Position.X - this.Slot.Right) < Interface.BorderThreshold)
                    {
                        currentDirection = Direction.SE;
                    }
                    else
                    {
                        currentDirection = Direction.S;
                    }
                }
                else if (Math.Abs(e.Position.X - this.Slot.X) < Interface.BorderThreshold)
                {
                    currentDirection = Direction.W;
                }
                else if (Math.Abs(e.Position.X - this.Slot.Right) < Interface.BorderThreshold)
                {
                    currentDirection = Direction.E;
                }
                else
                {
                    currentDirection = Direction.None;
                }

                if (currentDirection != lastDir)
                {
                    switch (currentDirection)
                    {
                    case Direction.None:
                        otkgw.MouseCursor = XCursor.Default;
                        break;

                    case Direction.N:
                        otkgw.MouseCursor = XCursor.V;
                        break;

                    case Direction.S:
                        otkgw.MouseCursor = XCursor.V;
                        break;

                    case Direction.E:
                        otkgw.MouseCursor = XCursor.H;
                        break;

                    case Direction.W:
                        otkgw.MouseCursor = XCursor.H;
                        break;

                    case Direction.NW:
                        otkgw.MouseCursor = XCursor.NW;
                        break;

                    case Direction.NE:
                        otkgw.MouseCursor = XCursor.NE;
                        break;

                    case Direction.SW:
                        otkgw.MouseCursor = XCursor.SW;
                        break;

                    case Direction.SE:
                        otkgw.MouseCursor = XCursor.SE;
                        break;
                    }
                }
            }
        }
Пример #4
0
 public override void onMouseEnter(object sender, MouseMoveEventArgs e)
 {
     base.onMouseEnter (sender, e);
     if ((LogicalParent as Menu).AutomaticOpenning && items.Children.Count>0)
         IsOpened = true;
 }
Пример #5
0
        public virtual void checkHoverWidget(MouseMoveEventArgs e)
        {
            if (CurrentInterface.HoverWidget != this) {
                CurrentInterface.HoverWidget = this;
                onMouseEnter (this, e);
            }

            this.onMouseMove (this, e);//without this, window border doesn't work, should be removed
        }
Пример #6
0
 public virtual void onMouseLeave(object sender, MouseMoveEventArgs e)
 {
     #if DEBUG_FOCUS
     Debug.WriteLine("MouseLeave => " + this.ToString());
     #endif
     MouseLeave.Raise (this, e);
 }
Пример #7
0
//		[XmlAttributeAttribute()][DefaultValue(WindowState.Normal)]
//		public virtual WindowState State {
//			get { return _state; }
//			set {
//				if (_state == value)
//					return;
//				_state = value;
//				NotifyValueChanged ("State", _state);
//				NotifyValueChanged ("IsNormal", IsNormal);
//				NotifyValueChanged ("IsMaximized", IsMaximized);
//				NotifyValueChanged ("IsMinimized", IsMinimized);
//				NotifyValueChanged ("IsNotMinimized", IsNotMinimized);
//			}
//		}
        #endregion

        #region GraphicObject Overrides
        public override void onMouseMove(object sender, MouseMoveEventArgs e)
        {
            base.onMouseMove(sender, e);

            Interface otkgw = CurrentInterface;

            if (!hoverBorder)
            {
                currentDirection             = Direction.None;
                CurrentInterface.MouseCursor = XCursor.Default;
                return;
            }

            if (this.HasFocus && _movable)
            {
                if (e.Mouse.IsButtonDown(MouseButton.Left))
                {
                    int currentLeft = this.Left;
                    int currentTop = this.Top;
                    int currentWidth, currentHeight;

                    if (currentLeft == 0)
                    {
                        currentLeft = this.Slot.Left;
                        this.Left   = currentLeft;
                    }
                    if (currentTop == 0)
                    {
                        currentTop = this.Slot.Top;
                        this.Top   = currentTop;
                    }
                    if (this.Width.IsFixed)
                    {
                        currentWidth = this.Width;
                    }
                    else
                    {
                        currentWidth = this.Slot.Width;
                    }

                    if (this.Height.IsFixed)
                    {
                        currentHeight = this.Height;
                    }
                    else
                    {
                        currentHeight = this.Slot.Height;
                    }

                    switch (currentDirection)
                    {
                    case Direction.None:
                        this.Left = currentLeft + e.XDelta;
                        this.Top  = currentTop + e.YDelta;
                        break;

                    case Direction.N:
                        this.Height = currentHeight - e.YDelta;
                        if (this.Height == currentHeight - e.YDelta)
                        {
                            this.Top = currentTop + e.YDelta;
                        }
                        break;

                    case Direction.S:
                        this.Height = currentHeight + e.YDelta;
                        break;

                    case Direction.W:
                        this.Width = currentWidth - e.XDelta;
                        if (this.Width == currentWidth - e.XDelta)
                        {
                            this.Left = currentLeft + e.XDelta;
                        }
                        break;

                    case Direction.E:
                        this.Width = currentWidth + e.XDelta;
                        break;

                    case Direction.NW:
                        this.Height = currentHeight - e.YDelta;
                        if (this.Height == currentHeight - e.YDelta)
                        {
                            this.Top = currentTop + e.YDelta;
                        }
                        this.Width = currentWidth - e.XDelta;
                        if (this.Width == currentWidth - e.XDelta)
                        {
                            this.Left = currentLeft + e.XDelta;
                        }
                        break;

                    case Direction.NE:
                        this.Height = currentHeight - e.YDelta;
                        if (this.Height == currentHeight - e.YDelta)
                        {
                            this.Top = currentTop + e.YDelta;
                        }
                        this.Width = currentWidth + e.XDelta;
                        break;

                    case Direction.SW:
                        this.Width = currentWidth - e.XDelta;
                        if (this.Width == currentWidth - e.XDelta)
                        {
                            this.Left = currentLeft + e.XDelta;
                        }
                        this.Height = currentHeight + e.YDelta;
                        break;

                    case Direction.SE:
                        this.Height = currentHeight + e.YDelta;
                        this.Width  = currentWidth + e.XDelta;
                        break;
                    }
                    return;
                }
            }
            if (Resizable)
            {
                Direction lastDir = currentDirection;

                if (Math.Abs(e.Position.Y - this.Slot.Y) < Interface.BorderThreshold)
                {
                    if (Math.Abs(e.Position.X - this.Slot.X) < Interface.BorderThreshold)
                    {
                        currentDirection = Direction.NW;
                    }
                    else if (Math.Abs(e.Position.X - this.Slot.Right) < Interface.BorderThreshold)
                    {
                        currentDirection = Direction.NE;
                    }
                    else
                    {
                        currentDirection = Direction.N;
                    }
                }
                else if (Math.Abs(e.Position.Y - this.Slot.Bottom) < Interface.BorderThreshold)
                {
                    if (Math.Abs(e.Position.X - this.Slot.X) < Interface.BorderThreshold)
                    {
                        currentDirection = Direction.SW;
                    }
                    else if (Math.Abs(e.Position.X - this.Slot.Right) < Interface.BorderThreshold)
                    {
                        currentDirection = Direction.SE;
                    }
                    else
                    {
                        currentDirection = Direction.S;
                    }
                }
                else if (Math.Abs(e.Position.X - this.Slot.X) < Interface.BorderThreshold)
                {
                    currentDirection = Direction.W;
                }
                else if (Math.Abs(e.Position.X - this.Slot.Right) < Interface.BorderThreshold)
                {
                    currentDirection = Direction.E;
                }
                else
                {
                    currentDirection = Direction.None;
                }

                if (currentDirection != lastDir)
                {
                    switch (currentDirection)
                    {
                    case Direction.None:
                        otkgw.MouseCursor = XCursor.Default;
                        break;

                    case Direction.N:
                        otkgw.MouseCursor = XCursor.V;
                        break;

                    case Direction.S:
                        otkgw.MouseCursor = XCursor.V;
                        break;

                    case Direction.E:
                        otkgw.MouseCursor = XCursor.H;
                        break;

                    case Direction.W:
                        otkgw.MouseCursor = XCursor.H;
                        break;

                    case Direction.NW:
                        otkgw.MouseCursor = XCursor.NW;
                        break;

                    case Direction.NE:
                        otkgw.MouseCursor = XCursor.NE;
                        break;

                    case Direction.SW:
                        otkgw.MouseCursor = XCursor.SW;
                        break;

                    case Direction.SE:
                        otkgw.MouseCursor = XCursor.SE;
                        break;
                    }
                }
            }
        }
Пример #8
0
 public override void onMouseLeave(object sender, MouseMoveEventArgs e)
 {
     base.onMouseLeave (sender, e);
     CurrentInterface.MouseCursor = XCursor.Default;
 }
Пример #9
0
 public override void onMouseLeave(object sender, MouseMoveEventArgs e)
 {
     base.onMouseLeave (sender, e);
     AutomaticOpenning = false;
 }
Пример #10
0
 protected void onBorderMouseEnter(object sender, MouseMoveEventArgs e)
 {
     hoverBorder = true;
 }
Пример #11
0
        public override void onMouseMove(object sender, MouseMoveEventArgs e)
        {
            base.onMouseMove (sender, e);

            Interface otkgw = CurrentInterface;

            if (!hoverBorder) {
                currentDirection = Direction.None;
                CurrentInterface.MouseCursor = XCursor.Default;
                return;
            }

            if (this.HasFocus && _movable) {
                if (e.Mouse.IsButtonDown (MouseButton.Left)) {
                    int currentLeft = this.Left;
                    int currentTop = this.Top;
                    int currentWidth, currentHeight;

                    if (currentLeft == 0) {
                        currentLeft = this.Slot.Left;
                        this.Left = currentLeft;
                    }
                    if (currentTop == 0) {
                        currentTop = this.Slot.Top;
                        this.Top = currentTop;
                    }
                    if (this.Width.IsFixed)
                        currentWidth = this.Width;
                    else
                        currentWidth = this.Slot.Width;

                    if (this.Height.IsFixed)
                        currentHeight = this.Height;
                    else
                        currentHeight = this.Slot.Height;

                    switch (currentDirection) {
                    case Direction.None:
                        this.Left = currentLeft + e.XDelta;
                        this.Top = currentTop + e.YDelta;
                        break;
                    case Direction.N:
                        this.Height = currentHeight - e.YDelta;
                        if (this.Height == currentHeight - e.YDelta)
                            this.Top = currentTop + e.YDelta;
                        break;
                    case Direction.S:
                        this.Height = currentHeight + e.YDelta;
                        break;
                    case Direction.W:
                        this.Width = currentWidth - e.XDelta;
                        if (this.Width == currentWidth - e.XDelta)
                            this.Left = currentLeft + e.XDelta;
                        break;
                    case Direction.E:
                        this.Width = currentWidth + e.XDelta;
                        break;
                    case Direction.NW:
                        this.Height = currentHeight - e.YDelta;
                        if (this.Height == currentHeight - e.YDelta)
                            this.Top = currentTop + e.YDelta;
                        this.Width = currentWidth - e.XDelta;
                        if (this.Width == currentWidth - e.XDelta)
                            this.Left = currentLeft + e.XDelta;
                        break;
                    case Direction.NE:
                        this.Height = currentHeight - e.YDelta;
                        if (this.Height == currentHeight - e.YDelta)
                            this.Top = currentTop + e.YDelta;
                        this.Width = currentWidth + e.XDelta;
                        break;
                    case Direction.SW:
                        this.Width = currentWidth - e.XDelta;
                        if (this.Width == currentWidth - e.XDelta)
                            this.Left = currentLeft + e.XDelta;
                        this.Height = currentHeight + e.YDelta;
                        break;
                    case Direction.SE:
                        this.Height = currentHeight + e.YDelta;
                        this.Width = currentWidth + e.XDelta;
                        break;
                    }
                    return;
                }
            }
            //			GraphicObject firstFocusableAncestor = otkgw.hoverWidget;
            //			while (firstFocusableAncestor != this) {
            //				if (firstFocusableAncestor == null)
            //					return;
            //				if (firstFocusableAncestor.Focusable)
            //					return;
            //				firstFocusableAncestor = firstFocusableAncestor.Parent as GraphicObject;
            //			}
            if (Resizable) {
                Direction lastDir = currentDirection;

                if (Math.Abs (e.Position.Y - this.Slot.Y) < Interface.BorderThreshold) {
                    if (Math.Abs (e.Position.X - this.Slot.X) < Interface.BorderThreshold)
                        currentDirection = Direction.NW;
                    else if (Math.Abs (e.Position.X - this.Slot.Right) < Interface.BorderThreshold)
                        currentDirection = Direction.NE;
                    else
                        currentDirection = Direction.N;
                } else if (Math.Abs (e.Position.Y - this.Slot.Bottom) < Interface.BorderThreshold) {
                    if (Math.Abs (e.Position.X - this.Slot.X) < Interface.BorderThreshold)
                        currentDirection = Direction.SW;
                    else if (Math.Abs (e.Position.X - this.Slot.Right) < Interface.BorderThreshold)
                        currentDirection = Direction.SE;
                    else
                        currentDirection = Direction.S;
                } else if (Math.Abs (e.Position.X - this.Slot.X) < Interface.BorderThreshold)
                    currentDirection = Direction.W;
                else if (Math.Abs (e.Position.X - this.Slot.Right) < Interface.BorderThreshold)
                    currentDirection = Direction.E;
                else
                    currentDirection = Direction.None;

                if (currentDirection != lastDir) {
                    switch (currentDirection) {
                    case Direction.None:
                        otkgw.MouseCursor = XCursor.Default;
                        break;
                    case Direction.N:
                        otkgw.MouseCursor = XCursor.V;
                        break;
                    case Direction.S:
                        otkgw.MouseCursor = XCursor.V;
                        break;
                    case Direction.E:
                        otkgw.MouseCursor = XCursor.H;
                        break;
                    case Direction.W:
                        otkgw.MouseCursor = XCursor.H;
                        break;
                    case Direction.NW:
                        otkgw.MouseCursor = XCursor.NW;
                        break;
                    case Direction.NE:
                        otkgw.MouseCursor = XCursor.NE;
                        break;
                    case Direction.SW:
                        otkgw.MouseCursor = XCursor.SW;
                        break;
                    case Direction.SE:
                        otkgw.MouseCursor = XCursor.SE;
                        break;
                    }
                }
            }
        }
Пример #12
0
        //public string update = "";
        #endregion


        #region Mouse Handling
        void Mouse_Move(object sender, MouseMoveEventArgs e)
        {
            if (_activeWidget != null)
            {
                //first, ensure object is still in the graphic tree
                if (_activeWidget.HostContainer == null)
                {
                    activeWidget = null;
                }
                else
                {
                    //send move evt even if mouse move outside bounds
                    _activeWidget.onMouseMove(_activeWidget, e);
                    return;
                }
            }

            if (_hoverWidget != null)
            {
                //first, ensure object is still in the graphic tree
                if (_hoverWidget.HostContainer == null)
                {
                    hoverWidget = null;
                }
                else
                {
                    //check topmost graphicobject first
                    GraphicObject tmp  = _hoverWidget;
                    GraphicObject topc = null;
                    while (tmp is GraphicObject)
                    {
                        topc = tmp;
                        tmp  = tmp.Parent as GraphicObject;
                    }
                    int idxhw = GraphicObjects.IndexOf(topc);
                    if (idxhw != 0)
                    {
                        int i = 0;
                        while (i < idxhw)
                        {
                            if (GraphicObjects [i].MouseIsIn(e.Position))
                            {
                                _hoverWidget.onMouseLeave(this, e);
                                GraphicObjects [i].checkHoverWidget(e);
                                return;
                            }
                            i++;
                        }
                    }


                    if (_hoverWidget.MouseIsIn(e.Position))
                    {
                        _hoverWidget.checkHoverWidget(e);
                        return;
                    }
                    else
                    {
                        _hoverWidget.onMouseLeave(this, e);
                        //seek upward from last focused graph obj's
                        while (_hoverWidget.Parent as GraphicObject != null)
                        {
                            _hoverWidget = _hoverWidget.Parent as GraphicObject;
                            if (_hoverWidget.MouseIsIn(e.Position))
                            {
                                _hoverWidget.checkHoverWidget(e);
                                return;
                            }
                            else
                            {
                                _hoverWidget.onMouseLeave(this, e);
                            }
                        }
                    }
                }
            }

            //top level graphic obj's parsing
            for (int i = 0; i < GraphicObjects.Count; i++)
            {
                GraphicObject g = GraphicObjects[i];
                if (g.MouseIsIn(e.Position))
                {
                    g.checkHoverWidget(e);
                    PutOnTop(g);
                    return;
                }
            }
            _hoverWidget = null;
            MouseMove.Raise(this, e);
        }
Пример #13
0
 public override void onMouseLeave(object sender, MouseMoveEventArgs e)
 {
     base.onMouseLeave(sender, e);
     AutomaticOpenning = false;
 }
Пример #14
0
        public override void onMouseMove(object sender, MouseMoveEventArgs e)
        {
            base.onMouseMove(sender, e);

            if (!IsActive)
            {
                return;
            }

            GenericStack gs = Parent as GenericStack;
            int          newDelta = delta, size1 = init1, size2 = init2;

            if (gs.Orientation == Orientation.Horizontal)
            {
                newDelta -= e.XDelta;
                if (size1 < 0)
                {
                    size1 = go1.Slot.Width + delta;
                }
                if (size2 < 0)
                {
                    size2 = go2.Slot.Width - delta;
                }
            }
            else
            {
                newDelta -= e.YDelta;
                if (size1 < 0)
                {
                    size1 = go1.Slot.Height + delta;
                }
                if (size2 < 0)
                {
                    size2 = go2.Slot.Height - delta;
                }
            }

            if (size1 - newDelta < min1 || (max1 > 0 && size1 - newDelta > max1) ||
                size2 + newDelta < min2 || (max2 > 0 && size2 + newDelta > max2))
            {
                return;
            }

            delta = newDelta;

            if (gs.Orientation == Orientation.Horizontal)
            {
                if (init1 >= 0)
                {
                    go1.Width = init1 - delta;
                }
                if (init2 >= 0)
                {
                    go2.Width = init2 + delta;
                }
            }
            else
            {
                if (init1 >= 0)
                {
                    go1.Height = init1 - delta;
                }
                if (init2 >= 0)
                {
                    go2.Height = init2 + delta;
                }
            }
        }
Пример #15
0
        public override void onMouseMove(object sender, MouseMoveEventArgs e)
        {
            if (IsDropTarget)
            {
                DockWindow dw = IFace.DragAndDropOperation.DragSource as DockWindow;
                if (dw.IsDocked)
                {
                    base.onMouseMove(sender, e);
                    return;
                }

                Alignment curDockPos = dw.DockingPosition;
                dw.DockingPosition = Alignment.Undefined;

                Rectangle cb = ClientRectangle;
                Point     lm = ScreenPointToLocal(e.Position);

                if (Children.Count == 0)
                {
                    Rectangle r = cb;
                    r.Inflate(r.Width / -5, r.Height / -5);
                    if (r.ContainsOrIsEqual(lm))
                    {
                        dw.DockingPosition = Alignment.Center;
                    }
                }
                else
                {
                    rIn = cb;

                    if (Orientation == Orientation.Horizontal || Children.Count == 1)
                    {
                        if (lm.Y > cb.Top + cb.Height / 3 && lm.Y < cb.Bottom - cb.Height / 3)
                        {
                            if (lm.X < cb.Left + cb.Width / 3)
                            {
                                dw.DockingPosition = Alignment.Left;
                            }
                            else if (lm.X > cb.Right - cb.Width / 3)
                            {
                                dw.DockingPosition = Alignment.Right;
                            }
                        }
                        else
                        {
                            getFocusedChild(lm);
                            if (focusedChild != null)
                            {
                                if (lm.Y < rIn.Top + rIn.Height / 3)
                                {
                                    dw.DockingPosition = Alignment.Top;
                                }
                                else if (lm.Y > rIn.Bottom - rIn.Height / 3)
                                {
                                    dw.DockingPosition = Alignment.Bottom;
                                }
                            }
                        }
                    }
                    if (Orientation == Orientation.Vertical || Children.Count == 1)
                    {
                        if (lm.X > cb.Left + cb.Width / 3 && lm.X < cb.Right - cb.Width / 3)
                        {
                            if (lm.Y < cb.Top + cb.Height / 3)
                            {
                                dw.DockingPosition = Alignment.Top;
                            }
                            else if (lm.Y > cb.Bottom - cb.Height / 3)
                            {
                                dw.DockingPosition = Alignment.Bottom;
                            }
                        }
                        else
                        {
                            getFocusedChild(lm);
                            if (focusedChild != null)
                            {
                                if (lm.X < rIn.Left + rIn.Width / 3)
                                {
                                    dw.DockingPosition = Alignment.Left;
                                }
                                else if (lm.X > rIn.Right - rIn.Width / 3)
                                {
                                    dw.DockingPosition = Alignment.Right;
                                }
                            }
                        }
                    }
                }

                if (curDockPos != dw.DockingPosition)
                {
                    RegisterForGraphicUpdate();
                }
            }
            base.onMouseMove(sender, e);
        }
Пример #16
0
 protected virtual void onBorderMouseEnter(object sender, MouseMoveEventArgs e)
 {
     hoverBorder = true;
 }
Пример #17
0
 public override void onMouseMove(object sender, MouseMoveEventArgs e)
 {
     savedMousePos.X += e.XDelta;
     savedMousePos.Y += e.YDelta;
     base.onMouseMove (sender, new MouseMoveEventArgs(savedMousePos.X,savedMousePos.Y,e.XDelta,e.YDelta));
 }
Пример #18
0
 protected void onBorderMouseLeave(object sender, MouseMoveEventArgs e)
 {
     hoverBorder = false;
     currentDirection = Direction.None;
     CurrentInterface.MouseCursor = XCursor.Default;
 }
Пример #19
0
 public override void onMouseEnter(object sender, MouseMoveEventArgs e)
 {
     base.onMouseEnter (sender, e);
     if (Selectable)
         CurrentInterface.MouseCursor = XCursor.Text;
 }
Пример #20
0
        public override void onMouseMove(object sender, MouseMoveEventArgs e)
        {
            base.onMouseMove(sender, e);

            if (!IsActive)
            {
                return;
            }

            GenericStack gs       = Parent as GenericStack;
            int          ptrSplit = gs.Children.IndexOf(this);

            if (ptrSplit == 0 || ptrSplit == gs.Children.Count - 1)
            {
                return;
            }

            if (gs.Orientation == Orientation.Horizontal)
            {
                if ((gs.Children [ptrSplit - 1].Width + e.XDelta <
                     gs.Children [ptrSplit - 1].MinimumSize.Width) ||
                    (gs.Children [ptrSplit + 1].Width - e.XDelta <
                     gs.Children [ptrSplit + 1].MinimumSize.Width))
                {
                    return;
                }

                if (!gs.Children [ptrSplit - 1].Width.IsFixed)
                {
                    gs.Children [ptrSplit - 1].Width = gs.Children [ptrSplit - 1].Slot.Width;
                }
                if (!gs.Children [ptrSplit + 1].Width.IsFixed)
                {
                    gs.Children [ptrSplit + 1].Width = gs.Children [ptrSplit + 1].Slot.Width;
                }

                gs.Children [ptrSplit - 1].Width = gs.Children [ptrSplit - 1].Width + e.XDelta;
                gs.Children [ptrSplit + 1].Width = gs.Children [ptrSplit + 1].Width - e.XDelta;
            }
            else
            {
                if ((gs.Children [ptrSplit - 1].Height + e.YDelta <
                     gs.Children [ptrSplit - 1].MinimumSize.Height) ||
                    (gs.Children [ptrSplit + 1].Height - e.YDelta <
                     gs.Children [ptrSplit + 1].MinimumSize.Height))
                {
                    return;
                }

                if (!gs.Children [ptrSplit - 1].Height.IsFixed)
                {
                    gs.Children [ptrSplit - 1].Height = gs.Children [ptrSplit - 1].Slot.Height;
                }
                if (!gs.Children [ptrSplit + 1].Height.IsFixed)
                {
                    gs.Children [ptrSplit + 1].Height = gs.Children [ptrSplit + 1].Slot.Height;
                }

                gs.Children [ptrSplit - 1].Height = gs.Children [ptrSplit - 1].Height + e.YDelta;
                gs.Children [ptrSplit + 1].Height = gs.Children [ptrSplit + 1].Height - e.YDelta;
            }
        }
Пример #21
0
        public override void onMouseMove(object sender, MouseMoveEventArgs e)
        {
            base.onMouseMove (sender, e);

            if (!(SelectionInProgress && HasFocus && _selectable))
                return;

            updatemouseLocalPos (e.Position);

            RegisterForRedraw();
        }
Пример #22
0
 public override void onMouseEnter(object sender, MouseMoveEventArgs e)
 {
     base.onMouseEnter (sender, e);
     if ((Parent as GenericStack).Orientation == Orientation.Horizontal)
         CurrentInterface.MouseCursor = XCursor.H;
     else
         CurrentInterface.MouseCursor = XCursor.V;
 }
Пример #23
0
        public override void onMouseMove(object sender, MouseMoveEventArgs e)
        {
            base.onMouseMove (sender, e);

            if (!IsActive)
                return;

            GenericStack gs = Parent as GenericStack;
            int newDelta = delta, size1 = init1 , size2 = init2;
            if (gs.Orientation == Orientation.Horizontal) {
                newDelta -= e.XDelta;
                if (size1 < 0)
                    size1 = go1.Slot.Width + delta;
                if (size2 < 0)
                    size2 = go2.Slot.Width - delta;
            } else {
                newDelta -= e.YDelta;
                if (size1 < 0)
                    size1 = go1.Slot.Height + delta;
                if (size2 < 0)
                    size2 = go2.Slot.Height - delta;
            }

            if (size1 - newDelta < min1 || (max1 > 0 && size1 - newDelta > max1) ||
                size2 + newDelta < min2 || (max2 > 0 && size2 + newDelta > max2))
                return;

            delta = newDelta;

            if (gs.Orientation == Orientation.Horizontal) {
                if (init1 >= 0)
                    go1.Width = init1 - delta;
                if (init2 >= 0)
                    go2.Width = init2 + delta;
            } else {
                if (init1 >= 0)
                    go1.Height = init1 - delta;
                if (init2 >= 0)
                    go2.Height = init2 + delta;
            }
        }
Пример #24
0
        public override void onMouseMove(object sender, MouseMoveEventArgs e)
        {
            if (holdCursor) {
                if (_orientation == Orientation.Horizontal)
                    Value += (double)e.XDelta / unity;
                else
                    Value += (double)e.YDelta / unity;
            }

            base.onMouseMove (sender, e);
        }
Пример #25
0
        public virtual void onMouseMove(object sender, MouseMoveEventArgs e)
        {
            //bubble event to the top
            GraphicObject p = Parent as GraphicObject;
            if (p != null)
                p.onMouseMove(sender,e);

            MouseMove.Raise (sender, e);
        }
Пример #26
0
 public override void onMouseMove(object sender, MouseMoveEventArgs e)
 {
     savedMousePos.X += e.XDelta;
     savedMousePos.Y += e.YDelta;
     base.onMouseMove(sender, new MouseMoveEventArgs(savedMousePos.X, savedMousePos.Y, e.XDelta, e.YDelta));
 }
Пример #27
0
 /// <summary>
 /// Constructs a new <see cref="MouseMoveEventArgs"/> instance.
 /// </summary>
 /// <param name="args">The <see cref="MouseMoveEventArgs"/> instance to clone.</param>
 public MouseMoveEventArgs(MouseMoveEventArgs args)
     : this(args.X, args.Y, args.XDelta, args.YDelta)
 {
 }
Пример #28
0
 public override void onMouseLeave(object sender, MouseMoveEventArgs e)
 {
     base.onMouseLeave(sender, e);
     CurrentInterface.MouseCursor = XCursor.Default;
 }
Пример #29
0
 public override void onMouseLeave(object sender, MouseMoveEventArgs e)
 {
     if (IsOpened)
         IsOpened = false;
     base.onMouseLeave (this, e);
 }
Пример #30
0
 public override void onMouseLeave(object sender, MouseMoveEventArgs e)
 {
     base.onMouseLeave(sender, e);
     IsPopped = false;
 }
Пример #31
0
 protected virtual void onBorderMouseLeave(object sender, MouseMoveEventArgs e)
 {
     hoverBorder       = false;
     currentDirection  = Direction.None;
     IFace.MouseCursor = XCursor.Default;
 }
Пример #32
0
        public override void checkHoverWidget(MouseMoveEventArgs e)
        {
            if (CurrentInterface.HoverWidget != this) {
                CurrentInterface.HoverWidget = this;
                onMouseEnter (this, e);
            }

            if (SelectedTab > Children.Count - 1)
                return;

            if (((Children[SelectedTab] as TabItem).Content.Parent as GraphicObject).MouseIsIn(e.Position))
            {
                Children[SelectedTab].checkHoverWidget (e);
                return;
            }
            for (int i = Children.Count - 1; i >= 0; i--) {
                TabItem ti = Children [i] as TabItem;
                if (ti.TabTitle.MouseIsIn(e.Position))
                {
                    Children[i].checkHoverWidget (e);
                    return;
                }
            }
        }
Пример #33
0
 public override void checkHoverWidget(MouseMoveEventArgs e)
 {
     savedMousePos = e.Position;
     Point m = e.Position - new Point ((int)ScrollX, (int)ScrollY);
     base.checkHoverWidget (new MouseMoveEventArgs(m.X,m.Y,e.XDelta,e.YDelta));
 }
Пример #34
0
 /// <summary>
 /// Constructs a new <see cref="MouseMoveEventArgs"/> instance.
 /// </summary>
 /// <param name="args">The <see cref="MouseMoveEventArgs"/> instance to clone.</param>
 public MouseMoveEventArgs(MouseMoveEventArgs args)
     : this(args.X, args.Y, args.XDelta, args.YDelta)
 {
 }
Пример #35
0
        public override void onMouseMove(object sender, MouseMoveEventArgs e)
        {
            base.onMouseMove (sender, e);

            if (!(HasFocus&&holdCursor))
                return;
            TabView tv = Parent as TabView;
            TabItem previous = null, next = null;
            int tmp = TabOffset + e.XDelta;
            if (tmp < tv.Spacing)
                TabOffset = tv.Spacing;
            else if (tmp > Parent.getSlot ().Width - TabTitle.Slot.Width - tv.Spacing)
                TabOffset = Parent.getSlot ().Width - TabTitle.Slot.Width - tv.Spacing;
            else{
                int idx = tv.Children.IndexOf (this);
                if (idx > 0 && e.XDelta < 0) {
                    previous = tv.Children [idx - 1] as TabItem;

                    if (tmp < previous.TabOffset + previous.TabTitle.Slot.Width / 2) {
                        tv.Children.RemoveAt (idx);
                        tv.Children.Insert (idx - 1, this);
                        tv.SelectedTab = idx - 1;
                        tv.UpdateLayout (LayoutingType.ArrangeChildren);
                    }

                }else if (idx < tv.Children.Count - 1 && e.XDelta > 0) {
                    next = tv.Children [idx + 1] as TabItem;
                    if (tmp > next.TabOffset - next.TabTitle.Slot.Width / 2){
                        tv.Children.RemoveAt (idx);
                        tv.Children.Insert (idx + 1, this);
                        tv.SelectedTab = idx + 1;
                        tv.UpdateLayout (LayoutingType.ArrangeChildren);
                    }
                }
                TabOffset = tmp;
            }
        }
Пример #36
0
        public override void onMouseMove(object sender, MouseMoveEventArgs e)
        {
            base.onMouseMove(sender, e);

            if (Parent == null)
            {
                return;
            }

            if (!IsDragged)
            {
                return;
            }

            TabView tv = Parent as TabView;

            if (Math.Abs(e.Position.Y - dragStartPoint.Y) > dragThreshold ||
                Math.Abs(e.Position.X - dragStartPoint.X) > dragThreshold)
            {
                makeFloating(tv);
                return;
            }

            Rectangle cb = ClientRectangle;

            int tmp = TabOffset + e.XDelta;

            if (tmp < tview.LeftSlope)
            {
                TabOffset = tview.LeftSlope;
            }
            else if (tmp > cb.Width - tv.RightSlope - tv.TabWidth)
            {
                TabOffset = cb.Width - tv.RightSlope - tv.TabWidth;
            }
            else
            {
                dragStartPoint.X = e.Position.X;
                TabItem[] tabItms = tv.Children.Cast <TabItem>().OrderBy(t => t.ViewIndex).ToArray();
                if (ViewIndex > 0 && e.XDelta < 0)
                {
                    TabItem previous = tabItms [ViewIndex - 1];
                    if (tmp < previous.TabOffset + tview.TabWidth / 2)
                    {
                        previous.ViewIndex = ViewIndex;
                        ViewIndex--;
                        tv.UpdateLayout(LayoutingType.ArrangeChildren);
                    }
                }
                else if (ViewIndex < tabItms.Length - 1 && e.XDelta > 0)
                {
                    TabItem next = tabItms [ViewIndex + 1];
                    if (tmp > next.TabOffset - tview.TabWidth / 2)
                    {
                        next.ViewIndex = ViewIndex;
                        ViewIndex++;
                        tv.UpdateLayout(LayoutingType.ArrangeChildren);
                    }
                }
                TabOffset = tmp;
            }
        }