Example #1
0
        private void Panel1_MouseMove(object sender, MouseEventArgs e)
        {
            if (MouseIsDown)
            {
                ResizeToRectangle(sender, e.Location);
            }

            foreach (Control button in ((Panel)sender).Controls)
            {
                if (MouseRect.IntersectsWith(button.Bounds)) //相交( MouseRect.Contains  完全包含)
                {
                    button.BackColor = Color.Blue;
                }
            }
            Point p = e.Location;

            if (p.X < intWidth)
            {
                CommonCalculated(p, 0);
            }
            if (p.Y < intHeight && p.X > intWidth)
            {
                CommonCalculated(p, 1);
            }
        }
Example #2
0
        private bool HandleMouseDown()
        {
            bool left  = Event.current.button == 0;
            bool right = Event.current.button == 1;

            if (!left && !right)
            {
                return(false);
            }

            if (MouseRect.Contains(Event.current.mousePosition))
            {
                var mousePos = Event.current.mousePosition - new Vector2(0, 16);
                var newNodes = new List <GraphNode>();
                newNodes.AddRange(AllNodes
                                  .Where(node => node.PhysicalRect.Contains(mousePos))
                                  .OrderByDescending(node => node.Id));

                if (!newNodes.Any())
                {
                    DeselectNodes(SelectedNodes);
                    GUI.FocusControl(string.Empty);
                }
                else if (!(CurrentMouseMode is ConnectMode))
                {
                    if (!SelectedNodes.Contains(newNodes.First()))
                    {
                        if (!CtrlPressed)
                        {
                            DeselectNodes(SelectedNodes);
                        }

                        SelectNodes(newNodes.First());
                    }

                    if (left)
                    {
                        NextMouseMode = new DragMode(this);
                    }
                    if (right)
                    {
                        newNodes.First().HandleRightClick();
                    }

                    Event.current.Use();
                    return(true);
                }

                if (CurrentMouseMode is NormalMode && left)
                {
                    NextMouseMode = new SelectMode(this);

                    Event.current.Use();
                    return(true);
                }
            }

            return(false);
        }
Example #3
0
        protected override void Update(float deltaTime)
        {
            if (!Visible)
            {
                return;
            }

            if (flashTimer > 0.0f)
            {
                flashTimer -= deltaTime;
            }
            if (!Enabled)
            {
                return;
            }

            if (skipUpdate)
            {
                skipUpdate = false;
                return;
            }

            if (MouseRect.Contains(PlayerInput.MousePosition) && (GUI.MouseOn == null || (!(GUI.MouseOn is GUIButton) && GUI.IsMouseOn(this))))
            {
                State = ComponentState.Hover;
                if (PlayerInput.PrimaryMouseButtonDown())
                {
                    mouseHeldInside = true;
                    Select();
                }
                else
                {
                    isSelecting = PlayerInput.PrimaryMouseButtonHeld();
                }
                if (PlayerInput.DoubleClicked())
                {
                    SelectAll();
                }
                if (isSelecting)
                {
                    if (!MathUtils.NearlyEqual(PlayerInput.MouseSpeed.X, 0))
                    {
                        CaretIndex = textBlock.GetCaretIndexFromScreenPos(PlayerInput.MousePosition);
                        CalculateCaretPos();
                        CalculateSelection();
                    }
                }
            }
            else
            {
                if ((PlayerInput.LeftButtonClicked() || PlayerInput.RightButtonClicked()) && selected)
                {
                    if (!mouseHeldInside)
                    {
                        Deselect();
                    }
                    mouseHeldInside = false;
                }
                isSelecting = false;
                State       = ComponentState.None;
            }
            if (!isSelecting)
            {
                isSelecting = PlayerInput.KeyDown(Keys.LeftShift) || PlayerInput.KeyDown(Keys.RightShift);
            }

            if (CaretEnabled)
            {
                if (textBlock.OverflowClipActive)
                {
                    if (CaretScreenPos.X < textBlock.Rect.X + textBlock.Padding.X)
                    {
                        textBlock.TextPos = new Vector2(textBlock.TextPos.X + ((textBlock.Rect.X + textBlock.Padding.X) - CaretScreenPos.X), textBlock.TextPos.Y);
                        CalculateCaretPos();
                    }
                    else if (CaretScreenPos.X > textBlock.Rect.Right - textBlock.Padding.Z)
                    {
                        textBlock.TextPos = new Vector2(textBlock.TextPos.X - (CaretScreenPos.X - (textBlock.Rect.Right - textBlock.Padding.Z)), textBlock.TextPos.Y);
                        CalculateCaretPos();
                    }
                }
                caretTimer  += deltaTime;
                caretVisible = ((caretTimer * 1000.0f) % 1000) < 500;
                if (caretVisible && caretPosDirty)
                {
                    CalculateCaretPos();
                }
            }

            if (GUI.KeyboardDispatcher.Subscriber == this)
            {
                State = ComponentState.Selected;
                Character.DisableControls = true;
                if (OnEnterPressed != null && PlayerInput.KeyHit(Keys.Enter))
                {
                    OnEnterPressed(this, Text);
                }
            }
            else if (Selected)
            {
                Deselect();
            }

            textBlock.State = State;
        }
Example #4
0
        protected override void Update(float deltaTime)
        {
            if (!Visible)
            {
                return;
            }

            if (flashTimer > 0.0f)
            {
                flashTimer -= deltaTime;
            }
            if (!Enabled)
            {
                return;
            }
            if (MouseRect.Contains(PlayerInput.MousePosition) && (GUI.MouseOn == null || GUI.IsMouseOn(this)))
            {
                state = ComponentState.Hover;
                if (PlayerInput.LeftButtonDown())
                {
                    Select();
                }
                else
                {
                    isSelecting = PlayerInput.LeftButtonHeld();
                }
                if (PlayerInput.DoubleClicked())
                {
                    SelectAll();
                }
                if (isSelecting)
                {
                    if (!MathUtils.NearlyEqual(PlayerInput.MouseSpeed.X, 0))
                    {
                        CaretIndex = GetCaretIndexFromScreenPos(PlayerInput.MousePosition);
                        CalculateCaretPos();
                        CalculateSelection();
                    }
                }
            }
            else
            {
                if (PlayerInput.LeftButtonClicked() && selected)
                {
                    Deselect();
                }
                isSelecting = false;
                state       = ComponentState.None;
            }
            if (!isSelecting)
            {
                isSelecting = PlayerInput.KeyDown(Keys.LeftShift) || PlayerInput.KeyDown(Keys.RightShift);
            }

            if (CaretEnabled)
            {
                caretTimer  += deltaTime;
                caretVisible = ((caretTimer * 1000.0f) % 1000) < 500;
                if (caretVisible && caretPosDirty)
                {
                    CalculateCaretPos();
                }
            }

            if (GUI.KeyboardDispatcher.Subscriber == this)
            {
                state = ComponentState.Selected;
                Character.DisableControls = true;
                if (OnEnterPressed != null && PlayerInput.KeyHit(Keys.Enter))
                {
                    OnEnterPressed(this, Text);
                }
            }
            else if (Selected)
            {
                Deselect();
            }

            textBlock.State = state;
        }
Example #5
0
		public void MouseMove(object sender, System.Windows.Forms.MouseEventArgs e)
		{
			if(!glcontrol.Focused)
				return;

			#if USE_ARG_IDX
			if(argIndex.Visible && argIndex.MouseMove(Size, e) || mouseDownInsideArgIndex)
				return;
			#endif

			#if USE_PARAM_IDX
			if(paramIndex.Visible && paramIndex.MouseMove(Size, e) || mouseDownInsideParamIndex)
				return;
			#endif

			#if USE_CUSTOM_CONTROLS
			if(ccContainer.Visible && ccContainer.MouseMove(Size, e) || mouseDownInsideCcContainer)
				return;
			#endif

			if(!mouseDownInsideImageCloud)
			{
				if(ContextMenu.MouseMove(sender, e, backbuffersize))
					return;

				if(colorTableMgr.Visible && colorTableMgr.MouseMove(e))
					return;

				return;
			}

			Viewer.RequestInputProcessing();

			if(images == null)
				return;

			Vector2 mousePos = new Vector2(2.0f * e.X / backbuffersize.Width - 1.0f, 1.0f - 2.0f * e.Y / backbuffersize.Height);

			if(mouseDownImage != null)
			{
				Matrix4 invvieworient = freeview.viewmatrix;
				invvieworient.M41 = invvieworient.M42 = invvieworient.M43 = 0.0f;
				invvieworient.Transpose();

				Vector3 vnear = new Vector3(mousePos.X, mousePos.Y, 0.0f);
				Vector3 vfar = new Vector3(vnear.X, vnear.Y, 1.0f);
				Matrix4 invviewprojmatrix = freeview.viewprojmatrix.Inverted();
				vnear = Vector3.TransformPerspective(vnear, invviewprojmatrix);
				vfar = Vector3.TransformPerspective(vfar, invviewprojmatrix);
				Vector3 vdir = (vfar - vnear).Normalized();

				Vector2 uv = mouseDownImage.GetIntersectionUV(vnear, vdir, invvieworient);
				foreach(ImageTransform transform in mouseDownImage.transforms)
					transform.OnImageMouseMove((ImageTransform.MouseButtons)e.Button, mouseDownImage, uv);
			}

			if(dragImage != null)
			{
				Vector3 vnear = new Vector3(mousePos.X, mousePos.Y, 0.0f);
				Vector3 vfar = new Vector3(vnear.X, vnear.Y, 1.0f);
				Matrix4 invviewprojmatrix = freeview.viewprojmatrix.Inverted();
				vnear = Vector3.TransformPerspective(vnear, invviewprojmatrix);
				vfar = Vector3.TransformPerspective(vfar, invviewprojmatrix);
				Vector3 vdir = (vfar - vnear).Normalized();

				// Set newpos to intersection of mouse ray and dragImagePlane
				Vector3 newpos;
				dragImagePlane.IntersectLine(vnear, vdir, out newpos);
				Viewer.browser.OnImageDrag(dragImage, newpos - dragImage.Position + dragImageOffset);
				//ActionManager.Do(MoveAction, newpos - dragImage.pos + dragImageOffset, selection);

				InvalidateOverallBounds();
			}
			else if(Math.Abs(mouseDownLocation.X - e.Location.X) + Math.Abs(mouseDownLocation.Y - e.Location.Y) > 2)
			{
				mouseDownLocation = new Point(-100, -100); // Make sure mouse rect movement stays enabled

				if(enableMouseRect && e.Button == MouseButtons.Left)
				{
					// Update mouse rect
					if(mouseRect == null)
						mouseRect = new MouseRect();
					mouseRect.min.X = Math.Min(mouseDownPos.X, mousePos.X);
					mouseRect.min.Y = Math.Min(mouseDownPos.Y, mousePos.Y);
					mouseRect.max.X = Math.Max(mouseDownPos.X, mousePos.X);
					mouseRect.max.Y = Math.Max(mouseDownPos.Y, mousePos.Y);

					// Ensure mouse rect is at least 1 pixel wide/high (for correct frustum computation)
					float pixelSizeX = 2.0f / (float)backbuffersize.Width;
					float pixelSizeY = 2.0f / (float)backbuffersize.Height;
					if(mouseRect.max.X - mouseRect.min.X < pixelSizeX)
					{
						mouseRect.min.X = (mouseRect.min.X + mouseRect.max.X + pixelSizeX) / 2.0f;
						mouseRect.max.X = mouseRect.min.X + pixelSizeX;
					}
					if(mouseRect.max.Y - mouseRect.min.Y < pixelSizeY)
					{
						mouseRect.min.Y = (mouseRect.min.Y + mouseRect.max.Y + pixelSizeY) / 2.0f;
						mouseRect.max.Y = mouseRect.min.Y + pixelSizeY;
					}

					// >>> Perform frustum intersection with all images

					Frustum mouseRectFrustum;
					//Vector3 pmin = new Vector3(mouseRect.min.X, mouseRect.min.Y, 0.0f); // A point on the bottom left edge of the mouse rect frustum
					//Vector3 pmax = new Vector3(mouseRect.max.X, mouseRect.max.Y, 0.0f); // A point on the top right edge of the mouse rect frustum
					Matrix4 invviewprojmatrix = freeview.viewprojmatrix.Inverted();
					Vector3 ptl = Vector3.TransformPerspective(new Vector3(mouseRect.min.X, mouseRect.max.Y, 0.0f), invviewprojmatrix);
					Vector3 ptl_far = Vector3.TransformPerspective(new Vector3(mouseRect.min.X, mouseRect.max.Y, 1.0f), invviewprojmatrix);
					Vector3 ptr = Vector3.TransformPerspective(new Vector3(mouseRect.max.X, mouseRect.max.Y, 0.0f), invviewprojmatrix);
					Vector3 ptr_far = Vector3.TransformPerspective(new Vector3(mouseRect.max.X, mouseRect.max.Y, 1.0f), invviewprojmatrix);
					Vector3 pbl = Vector3.TransformPerspective(new Vector3(mouseRect.min.X, mouseRect.min.Y, 0.0f), invviewprojmatrix);
					Vector3 pbl_far = Vector3.TransformPerspective(new Vector3(mouseRect.min.X, mouseRect.min.Y, 1.0f), invviewprojmatrix);
					Vector3 pbr = Vector3.TransformPerspective(new Vector3(mouseRect.max.X, mouseRect.min.Y, 0.0f), invviewprojmatrix);

					// Left plane
					mouseRectFrustum.pleft = new Plane(ptl, ptl_far, pbl);

					// Right plane
					mouseRectFrustum.pright = new Plane(ptr, pbr, ptr_far);

					// Top plane
					mouseRectFrustum.ptop = new Plane(ptl, ptr, ptl_far);

					// Bottom plane
					mouseRectFrustum.pbottom = new Plane(pbl, pbl_far, pbr);

					// Near plane
					mouseRectFrustum.pnear.a = freeview.viewprojmatrix.M13;
					mouseRectFrustum.pnear.b = freeview.viewprojmatrix.M23;
					mouseRectFrustum.pnear.c = freeview.viewprojmatrix.M33;
					mouseRectFrustum.pnear.d = freeview.viewprojmatrix.M43;
					mouseRectFrustum.pnear.Normalize();

					// Far plane
					mouseRectFrustum.pfar.a = freeview.viewprojmatrix.M14 - freeview.viewprojmatrix.M13;
					mouseRectFrustum.pfar.b = freeview.viewprojmatrix.M24 - freeview.viewprojmatrix.M23;
					mouseRectFrustum.pfar.c = freeview.viewprojmatrix.M34 - freeview.viewprojmatrix.M33;
					mouseRectFrustum.pfar.d = freeview.viewprojmatrix.M44 - freeview.viewprojmatrix.M43;
					mouseRectFrustum.pfar.Normalize();

					Matrix4 invvieworient = freeview.viewmatrix;
					invvieworient.M41 = invvieworient.M42 = invvieworient.M43 = 0.0f;
					invvieworient.Transpose();
					selection.Clear();
					foreach(TransformedImage image in images.Values)
						if(image.IsVisible() && mouseRectFrustum.DoFrustumCulling(image.GetWorldMatrix(invvieworient), Matrix4.Identity, Matrix4.Identity, new Vector3(0.0f, 0.0f, 0.0f), new Vector3(0.5f, 0.5f, 0.5f)))
							selection.Add(image);
					SelectionChanged();
				}
			}
		}
Example #6
0
		public void MouseUp(object sender, System.Windows.Forms.MouseEventArgs e)
		{
			if(!glcontrol.Focused)
				return;

			#if USE_ARG_IDX
			mouseDownInsideArgIndex = false;
			if(argIndex.Visible && argIndex.MouseUp(Size, e))
				return;
			#endif

			#if USE_PARAM_IDX
			mouseDownInsideParamIndex = false;
			if(paramIndex.Visible && paramIndex.MouseUp(Size, e))
				return;
			#endif

			#if USE_CUSTOM_CONTROLS
			mouseDownInsideCcContainer = false;
			if(ccContainer.Visible && ccContainer.MouseUp(Size, e))
				return;
			#endif

			Viewer.RequestInputProcessing();

			if(Math.Abs(mouseDownLocation.X - e.Location.X) + Math.Abs(mouseDownLocation.Y - e.Location.Y) < 2)
			{
				if(e.Button == MouseButtons.Left)
					Viewer.browser.OnImageClick(mouseDownImage);
				else if(e.Button == MouseButtons.Right)
					Viewer.browser.OnImageRightClick(mouseDownImage);
			}
			else if(!ContextMenu.MouseUp(sender, e, backbuffersize) && colorTableMgr.Visible)
				colorTableMgr.MouseUp(e);

			dragImage = mouseDownImage = null;
			mouseRect = null;
		}
Example #7
0
        public override void Update(float deltaTime)
        {
            if (!Visible)
            {
                return;
            }

            if (flashTimer > 0.0f)
            {
                flashTimer -= deltaTime;
            }
            if (!Enabled)
            {
                return;
            }

            if (MouseRect.Contains(PlayerInput.MousePosition) && Enabled &&
                (MouseOn == null || MouseOn == this || IsParentOf(MouseOn) || MouseOn.IsParentOf(this)))
            {
                state = ComponentState.Hover;
                if (PlayerInput.LeftButtonClicked())
                {
                    Select();
                    OnSelected?.Invoke(this, Keys.None);
                }
            }
            else
            {
                state = ComponentState.None;
            }

            if (CaretEnabled)
            {
                caretTimer  += deltaTime;
                caretVisible = ((caretTimer * 1000.0f) % 1000) < 500;
            }

            if (keyboardDispatcher.Subscriber == this)
            {
                state = ComponentState.Selected;
                Character.DisableControls = true;
                if (OnEnterPressed != null && PlayerInput.KeyHit(Keys.Enter))
                {
                    string input = Text;
                    Text = "";
                    OnEnterPressed(this, input);
                }
#if LINUX
                else if (PlayerInput.KeyHit(Keys.Back) && Text.Length > 0)
                {
                    Text = Text.Substring(0, Text.Length - 1);
                }
#endif
            }
            else if (Selected)
            {
                Deselect();
            }

            textBlock.State = state;
            textBlock.Update(deltaTime);
        }
Example #8
0
 private void Awake()
 {
     instance = this;
 }