Esempio n. 1
0
        protected override void Select(bool directed, bool forward)
        {
            if (directed && !forward)
            {
                activeGrabber = ActiveGrabberEnum.Max;
                Invalidate(true);
            }
            else
            {
                activeGrabber = ActiveGrabberEnum.Min;
                Invalidate(true);
            }

            base.Select(directed, forward);
        }
Esempio n. 2
0
        /// <summary>
        /// Handles MouseDown-event.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnMouseDown(object sender, MouseEventArgs e)
        {
            if (!Enabled)
            {
                return;
            }

            Rectangle lMarkRect = new Rectangle(Math.Min(lGrabberPoints[0].X, lGrabberPoints[1].X), Math.Min(lGrabberPoints[0].Y, lGrabberPoints[3].Y),
                                                Math.Abs(lGrabberPoints[2].X - lGrabberPoints[0].X), Math.Max(Math.Abs(lGrabberPoints[0].Y - lGrabberPoints[3].Y), Math.Abs(lGrabberPoints[0].Y - lGrabberPoints[1].Y)));

            Rectangle rMarkRect = new Rectangle(Math.Min(rGrabberPoints[0].X, rGrabberPoints[2].X), Math.Min(rGrabberPoints[0].Y, rGrabberPoints[1].Y),
                                                Math.Abs(rGrabberPoints[0].X - rGrabberPoints[2].X), Math.Max(Math.Abs(rGrabberPoints[2].Y - rGrabberPoints[0].Y), Math.Abs(rGrabberPoints[1].Y - rGrabberPoints[0].Y)));

            // save current value, even if not necessary
            oldRangeMin = rangeMin;
            oldRangeMax = rangeMax;

            if (lMarkRect.Contains(e.X, e.Y))
            {
                Capture       = true;
                moveLGrabber  = true;
                activeGrabber = ActiveGrabberEnum.Min;
                Invalidate(true);
            }

            if (rMarkRect.Contains(e.X, e.Y))
            {
                Capture       = true;
                moveRGrabber  = true;
                activeGrabber = ActiveGrabberEnum.Max;
                Invalidate(true);
            }

            if (bGrabberRect.Contains(e.X, e.Y))
            {
                mouseGrabOriginX = e.X;
                mouseGrabOriginY = e.Y;

                oldPosRangeMin = posRangeMin;
                oldPosRangeMax = posRangeMax;

                Capture       = true;
                moveBGrabber  = true;
                activeGrabber = ActiveGrabberEnum.Both;
                Invalidate(true);
            }
        }
Esempio n. 3
0
        protected override bool ProcessTabKey(bool forward)
        {
            if (!this.TabStop)
            {
                return(base.ProcessTabKey(forward));
            }

            if (!forward && activeGrabber == ActiveGrabberEnum.Max)
            {
                activeGrabber = ActiveGrabberEnum.Both;
                Invalidate(true);
                return(true);
            }

            if (!forward && activeGrabber == ActiveGrabberEnum.Both)
            {
                activeGrabber = ActiveGrabberEnum.Min;
                Invalidate(true);
                return(true);
            }

            if (forward && activeGrabber == ActiveGrabberEnum.Min)
            {
                activeGrabber = ActiveGrabberEnum.Both;
                Invalidate(true);
                return(true);
            }

            if (forward && activeGrabber == ActiveGrabberEnum.Both)
            {
                activeGrabber = ActiveGrabberEnum.Max;
                Invalidate(true);
                return(true);
            }

            return(base.ProcessTabKey(forward));
        }
Esempio n. 4
0
		private void OnLeave(object sender, EventArgs e)
		{
			activeGrabber=ActiveGrabberEnum.None;
			Invalidate(true);
		}
Esempio n. 5
0
		/// <summary>
		/// Handles MouseMove-event.
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void OnMouseMove(object sender, MouseEventArgs e)
		{
			if(!Enabled) return;

			Rectangle lMarkRect=new Rectangle(Math.Min(lGrabberPoints[0].X, lGrabberPoints[1].X), Math.Min(lGrabberPoints[0].Y, lGrabberPoints[3].Y),
				Math.Abs(lGrabberPoints[2].X-lGrabberPoints[0].X), Math.Max(Math.Abs(lGrabberPoints[0].Y-lGrabberPoints[3].Y), Math.Abs(lGrabberPoints[0].Y-lGrabberPoints[1].Y)));

			Rectangle rMarkRect=new Rectangle(Math.Min(rGrabberPoints[0].X, rGrabberPoints[2].X), Math.Min(rGrabberPoints[0].Y, rGrabberPoints[1].Y),
				Math.Abs(rGrabberPoints[0].X-rGrabberPoints[2].X), Math.Max(Math.Abs(rGrabberPoints[2].Y-rGrabberPoints[0].Y), Math.Abs(rGrabberPoints[1].Y-rGrabberPoints[0].Y)));

			if(lMarkRect.Contains(e.X, e.Y)||rMarkRect.Contains(e.X, e.Y)||bGrabberRect.Contains(e.X, e.Y))
			{
				if(orientationBar==RangeBarOrientation.LeftRight) Cursor=Cursors.SizeWE;
				else Cursor=Cursors.SizeNS;
			}
			else Cursor=Cursors.Arrow;

			if(moveLGrabber)
			{
				if(orientationBar==RangeBarOrientation.LeftRight)
				{
					posRangeMin=e.X;
					Cursor=Cursors.SizeWE;
				}
				else
				{
					posRangeMin=e.Y;
					Cursor=Cursors.SizeNS;
				}

				if(posRangeMin<posLimitMin) posRangeMin=posLimitMin;
				if(posRangeMin>posLimitMax) posRangeMin=posLimitMax;
				if(posRangeMax<posRangeMin) posRangeMax=posRangeMin;
				Pos2Range();
				activeGrabber=ActiveGrabberEnum.Min;
				Invalidate(true);

				OnRangeChanging(new RangeChangingEventArgs(rangeMin, rangeMax, oldRangeMin, oldRangeMax));
			}
			else if(moveRGrabber)
			{
				if(orientationBar==RangeBarOrientation.LeftRight)
				{
					posRangeMax=e.X;
					Cursor=Cursors.SizeWE;
				}
				else
				{
					posRangeMax=e.Y;
					Cursor=Cursors.SizeNS;
				}

				if(posRangeMax>posLimitMax) posRangeMax=posLimitMax;
				if(posRangeMax<posLimitMin) posRangeMax=posLimitMin;
				if(posRangeMin>posRangeMax) posRangeMin=posRangeMax;
				Pos2Range();
				activeGrabber=ActiveGrabberEnum.Max;
				Invalidate(true);

				OnRangeChanging(new RangeChangingEventArgs(rangeMin, rangeMax, oldRangeMin, oldRangeMax));
			}
			else if(moveBGrabber)
			{
				int delta=0;
				if(orientationBar==RangeBarOrientation.LeftRight)
				{
					delta=e.X-mouseGrabOriginX;
					Cursor=Cursors.SizeWE;
				}
				else
				{
					delta=e.Y-mouseGrabOriginY;
					Cursor=Cursors.SizeNS;
				}

				if(oldPosRangeMin+delta<posLimitMin) delta=posLimitMin-oldPosRangeMin;
				else if(oldPosRangeMax+delta>posLimitMax) delta=posLimitMax-oldPosRangeMax;

				posRangeMin=oldPosRangeMin+delta;
				posRangeMax=oldPosRangeMax+delta;

				Pos2Range();
				activeGrabber=ActiveGrabberEnum.Both;
				Invalidate(true);

				OnRangeChanging(new RangeChangingEventArgs(rangeMin, rangeMax, oldRangeMin, oldRangeMax));
			}
		}
Esempio n. 6
0
		/// <summary>
		/// Handles MouseDown-event.
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void OnMouseDown(object sender, MouseEventArgs e)
		{
			if(!Enabled) return;

			Rectangle lMarkRect=new Rectangle(Math.Min(lGrabberPoints[0].X, lGrabberPoints[1].X), Math.Min(lGrabberPoints[0].Y, lGrabberPoints[3].Y),
				Math.Abs(lGrabberPoints[2].X-lGrabberPoints[0].X), Math.Max(Math.Abs(lGrabberPoints[0].Y-lGrabberPoints[3].Y), Math.Abs(lGrabberPoints[0].Y-lGrabberPoints[1].Y)));

			Rectangle rMarkRect=new Rectangle(Math.Min(rGrabberPoints[0].X, rGrabberPoints[2].X), Math.Min(rGrabberPoints[0].Y, rGrabberPoints[1].Y),
				Math.Abs(rGrabberPoints[0].X-rGrabberPoints[2].X), Math.Max(Math.Abs(rGrabberPoints[2].Y-rGrabberPoints[0].Y), Math.Abs(rGrabberPoints[1].Y-rGrabberPoints[0].Y)));

			// save current value, even if not necessary
			oldRangeMin=rangeMin;
			oldRangeMax=rangeMax;

			if(lMarkRect.Contains(e.X, e.Y))
			{
				Capture=true;
				moveLGrabber=true;
				activeGrabber=ActiveGrabberEnum.Min;
				Invalidate(true);
			}

			if(rMarkRect.Contains(e.X, e.Y))
			{
				Capture=true;
				moveRGrabber=true;
				activeGrabber=ActiveGrabberEnum.Max;
				Invalidate(true);
			}

			if(bGrabberRect.Contains(e.X, e.Y))
			{
				mouseGrabOriginX=e.X;
				mouseGrabOriginY=e.Y;

				oldPosRangeMin=posRangeMin;
				oldPosRangeMax=posRangeMax;

				Capture=true;
				moveBGrabber=true;
				activeGrabber=ActiveGrabberEnum.Both;
				Invalidate(true);
			}
		}
Esempio n. 7
0
		protected override void Select(bool directed, bool forward)
		{
			if(directed&&!forward)
			{
				activeGrabber=ActiveGrabberEnum.Max;
				Invalidate(true);
			}
			else
			{
				activeGrabber=ActiveGrabberEnum.Min;
				Invalidate(true);
			}

			base.Select(directed, forward);
		}
Esempio n. 8
0
		protected override bool ProcessTabKey(bool forward)
		{
			if(!this.TabStop) return base.ProcessTabKey(forward);

			if(!forward&&activeGrabber==ActiveGrabberEnum.Max)
			{
				activeGrabber=ActiveGrabberEnum.Both;
				Invalidate(true);
				return true;
			}

			if(!forward&&activeGrabber==ActiveGrabberEnum.Both)
			{
				activeGrabber=ActiveGrabberEnum.Min;
				Invalidate(true);
				return true;
			}

			if(forward&&activeGrabber==ActiveGrabberEnum.Min)
			{
				activeGrabber=ActiveGrabberEnum.Both;
				Invalidate(true);
				return true;
			}

			if(forward&&activeGrabber==ActiveGrabberEnum.Both)
			{
				activeGrabber=ActiveGrabberEnum.Max;
				Invalidate(true);
				return true;
			}

			return base.ProcessTabKey(forward);
		}
Esempio n. 9
0
        /// <summary>
        /// Handles MouseMove-event.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnMouseMove(object sender, MouseEventArgs e)
        {
            if (!Enabled)
            {
                return;
            }

            Rectangle lMarkRect = new Rectangle(Math.Min(lGrabberPoints[0].X, lGrabberPoints[1].X), Math.Min(lGrabberPoints[0].Y, lGrabberPoints[3].Y),
                                                Math.Abs(lGrabberPoints[2].X - lGrabberPoints[0].X), Math.Max(Math.Abs(lGrabberPoints[0].Y - lGrabberPoints[3].Y), Math.Abs(lGrabberPoints[0].Y - lGrabberPoints[1].Y)));

            Rectangle rMarkRect = new Rectangle(Math.Min(rGrabberPoints[0].X, rGrabberPoints[2].X), Math.Min(rGrabberPoints[0].Y, rGrabberPoints[1].Y),
                                                Math.Abs(rGrabberPoints[0].X - rGrabberPoints[2].X), Math.Max(Math.Abs(rGrabberPoints[2].Y - rGrabberPoints[0].Y), Math.Abs(rGrabberPoints[1].Y - rGrabberPoints[0].Y)));

            if (lMarkRect.Contains(e.X, e.Y) || rMarkRect.Contains(e.X, e.Y) || bGrabberRect.Contains(e.X, e.Y))
            {
                if (orientationBar == RangeBarOrientation.LeftRight)
                {
                    Cursor = Cursors.SizeWE;
                }
                else
                {
                    Cursor = Cursors.SizeNS;
                }
            }
            else
            {
                Cursor = Cursors.Arrow;
            }

            if (moveLGrabber)
            {
                if (orientationBar == RangeBarOrientation.LeftRight)
                {
                    posRangeMin = e.X;
                    Cursor      = Cursors.SizeWE;
                }
                else
                {
                    posRangeMin = e.Y;
                    Cursor      = Cursors.SizeNS;
                }

                if (posRangeMin < posLimitMin)
                {
                    posRangeMin = posLimitMin;
                }
                if (posRangeMin > posLimitMax)
                {
                    posRangeMin = posLimitMax;
                }
                if (posRangeMax < posRangeMin)
                {
                    posRangeMax = posRangeMin;
                }
                Pos2Range();
                activeGrabber = ActiveGrabberEnum.Min;
                Invalidate(true);

                OnRangeChanging(new RangeChangingEventArgs(rangeMin, rangeMax, oldRangeMin, oldRangeMax));
            }
            else if (moveRGrabber)
            {
                if (orientationBar == RangeBarOrientation.LeftRight)
                {
                    posRangeMax = e.X;
                    Cursor      = Cursors.SizeWE;
                }
                else
                {
                    posRangeMax = e.Y;
                    Cursor      = Cursors.SizeNS;
                }

                if (posRangeMax > posLimitMax)
                {
                    posRangeMax = posLimitMax;
                }
                if (posRangeMax < posLimitMin)
                {
                    posRangeMax = posLimitMin;
                }
                if (posRangeMin > posRangeMax)
                {
                    posRangeMin = posRangeMax;
                }
                Pos2Range();
                activeGrabber = ActiveGrabberEnum.Max;
                Invalidate(true);

                OnRangeChanging(new RangeChangingEventArgs(rangeMin, rangeMax, oldRangeMin, oldRangeMax));
            }
            else if (moveBGrabber)
            {
                int delta = 0;
                if (orientationBar == RangeBarOrientation.LeftRight)
                {
                    delta  = e.X - mouseGrabOriginX;
                    Cursor = Cursors.SizeWE;
                }
                else
                {
                    delta  = e.Y - mouseGrabOriginY;
                    Cursor = Cursors.SizeNS;
                }

                if (oldPosRangeMin + delta < posLimitMin)
                {
                    delta = posLimitMin - oldPosRangeMin;
                }
                else if (oldPosRangeMax + delta > posLimitMax)
                {
                    delta = posLimitMax - oldPosRangeMax;
                }

                posRangeMin = oldPosRangeMin + delta;
                posRangeMax = oldPosRangeMax + delta;

                Pos2Range();
                activeGrabber = ActiveGrabberEnum.Both;
                Invalidate(true);

                OnRangeChanging(new RangeChangingEventArgs(rangeMin, rangeMax, oldRangeMin, oldRangeMax));
            }
        }
Esempio n. 10
0
        protected override bool ProcessDialogKey(Keys keyData)
        {
            if (!Enabled)
            {
                return(base.ProcessDialogKey(keyData));
            }

            if ((keyData & (Keys.Alt | Keys.Control)) == Keys.None)
            {
                Keys keys = keyData & Keys.KeyCode;
                ActiveGrabberEnum grabber = activeGrabber;

                if (orientationBar == RangeBarOrientation.BottomUp)
                {
                    if (grabber == ActiveGrabberEnum.Min)
                    {
                        grabber = ActiveGrabberEnum.Max;
                    }
                    else if (grabber == ActiveGrabberEnum.Max)
                    {
                        grabber = ActiveGrabberEnum.Min;
                    }

                    switch (keys)
                    {
                    case Keys.Left:
                    case Keys.Up: keys = Keys.Down; break;

                    case Keys.Right:
                    case Keys.Down: keys = Keys.Up; break;
                    }
                }

                int steps = (keyData & Keys.Shift) == Keys.Shift?giantStepSize:1;

                switch (keys)
                {
                case Keys.Left:
                case Keys.Up:
                    if (grabber == ActiveGrabberEnum.Min)
                    {
                        rangeMin -= steps;
                        if (rangeMin < limitMin)
                        {
                            rangeMin = limitMin;
                        }
                        OnRangeChanged(new RangeChangedEventArgs(rangeMin, rangeMax));
                        Invalidate(true);
                    }
                    else if (grabber == ActiveGrabberEnum.Max)
                    {
                        rangeMax -= steps;
                        if (rangeMax < limitMin)
                        {
                            rangeMax = limitMin;
                        }
                        if (rangeMax < rangeMin)
                        {
                            rangeMin = rangeMax;
                        }
                        OnRangeChanged(new RangeChangedEventArgs(rangeMin, rangeMax));
                        Invalidate(true);
                    }
                    else if (grabber == ActiveGrabberEnum.Both)
                    {
                        if (rangeMin - steps < limitMin)
                        {
                            steps = rangeMin - limitMin;
                        }
                        rangeMin -= steps;
                        rangeMax -= steps;
                        OnRangeChanged(new RangeChangedEventArgs(rangeMin, rangeMax));
                        Invalidate(true);
                    }
                    return(true);

                case Keys.Right:
                case Keys.Down:
                    if (grabber == ActiveGrabberEnum.Max)
                    {
                        rangeMax += steps;
                        if (rangeMax > limitMax)
                        {
                            rangeMax = limitMax;
                        }
                        OnRangeChanged(new RangeChangedEventArgs(rangeMin, rangeMax));
                        Invalidate(true);
                    }
                    else if (grabber == ActiveGrabberEnum.Min)
                    {
                        rangeMin += steps;
                        if (rangeMin > limitMax)
                        {
                            rangeMin = limitMax;
                        }
                        if (rangeMax < rangeMin)
                        {
                            rangeMax = rangeMin;
                        }
                        OnRangeChanged(new RangeChangedEventArgs(rangeMin, rangeMax));
                        Invalidate(true);
                    }
                    else if (grabber == ActiveGrabberEnum.Both)
                    {
                        if (rangeMax + steps > limitMax)
                        {
                            steps = limitMax - rangeMax;
                        }
                        rangeMin += steps;
                        rangeMax += steps;
                        OnRangeChanged(new RangeChangedEventArgs(rangeMin, rangeMax));
                        Invalidate(true);
                    }
                    return(true);

                case Keys.Tab:
                    if (this.ProcessTabKey((keyData & Keys.Shift) == Keys.None))
                    {
                        return(true);
                    }
                    break;
                }
            }

            return(base.ProcessDialogKey(keyData));
        }
Esempio n. 11
0
 private void OnLeave(object sender, EventArgs e)
 {
     activeGrabber = ActiveGrabberEnum.None;
     Invalidate(true);
 }