using System;
using System.Collections.Generic;
using System.Drawing;
using DevComponents.DotNetBar.Charts.Style;

namespace DevComponents.DotNetBar.Charts
{
    class FlockAlign
    {
        #region Constants

	    private const long RemovePenalty = 1;
        private const int MovesPerIteration = 500;
	
        #endregion

        #region Private variables

        private List<PointLabelGroup> _LabelGroups;
	
        #endregion

        public FlockAlign(List<PointLabelGroup> labelGroups)
        {
            _LabelGroups = labelGroups;

            foreach (PointLabelGroup lg in _LabelGroups)
            {
                foreach (PointLabel pl in lg.PointLabels)
                    pl.Bounds = Rectangle.Empty;
            }
        }

        #region Iterate

        public bool Iterate(Rectangle bounds, DataLabelOverlapMode ovlMode)
        {
            if (ovlMode == DataLabelOverlapMode.NotSet)
                ovlMode = DataLabelOverlapMode.RotateAroundPoint;

            for (int i = 0; i < _LabelGroups.Count; i++)
            {
                PointLabelGroup lg = _LabelGroups[i];
                List<PointLabel> lps = lg.PointLabels;
                ChartSeries series = lg.ChartSeries;

                Point lp = Point.Empty;

                for (int j = 0; j < lps.Count; j++)
                {
                    PointLabel pl = lps[j];

                    if (pl.Visible == true )
                    {
                        DataLabelVisualStyle dstyle = pl.DataLabelVisualStyle ?? series.EffectiveDataLabelStyle;

                        if (series.IsBarSeries == true)
                        {
                            if (series.IsRotated == true)
                                IterateHBar(series, pl, bounds, ovlMode, dstyle);
                            else
                                IterateVBar(series, pl, bounds, ovlMode, dstyle);
                        }
                        else
                        {
                            IteratePoint(series, pl, bounds, lp, ovlMode, dstyle);
                        }
                    }

                    lp = pl.Point;
                }
            }

            return (true);
        }

        #region IterateHBar

        private void IterateHBar(ChartSeries series, PointLabel pl,
            Rectangle bounds, DataLabelOverlapMode ovlMode, DataLabelVisualStyle dstyle)
        {
            ChartXy chartXy = series.Parent as ChartXy;

            int start = (pl.IsDataLabel == true)
                ? pl.Point.X - 1 : series.GetHBarStart(chartXy, pl.SeriesPoint);

            int end = pl.Point.X;

            BarLabelPosition labelPos = pl.BarLabelPosition;
            
            if (labelPos == BarLabelPosition.NotSet)
                labelPos = series.GetBarLabelPosition(chartXy);

            switch (labelPos)
            {
                case BarLabelPosition.Near:
                    SetHBarLabelNear(series, pl, bounds, ovlMode, dstyle, start, end, false);
                    break;

                case BarLabelPosition.NearInside:
                    SetHBarLabelNear(series, pl, bounds, ovlMode, dstyle, start, end, true);
                    break;

                case BarLabelPosition.Far:
                    SetHBarLabelFar(series, pl, bounds, ovlMode, dstyle, start, end, false);
                    break;

                case BarLabelPosition.FarInside:
                    SetHBarLabelFar(series, pl, bounds, ovlMode, dstyle, start, end, true);
                    break;

                default:
                    SetHBarLabelCenter(series, pl, bounds, ovlMode, dstyle, start, end);
                    break;
            }
        }

        #region SetHBarLabelNear

        private void SetHBarLabelNear(ChartSeries series, PointLabel pl, Rectangle bounds,
            DataLabelOverlapMode ovlMode, DataLabelVisualStyle dstyle, int start, int end, bool inside)
        {
            ConnectorLineVisualStyle cstyle = dstyle.ConnectorLineStyle;

            Point pt = new Point(start, pl.Point.Y + series.BarOffset);

            Size size = GetBoundsSize(series, pl, dstyle);
            Rectangle t = Rectangle.Empty;

            int minLength = Dpi.Width(cstyle.MinLength);

            for (int i = 0; i < 2; i++)
            {
                int clen = (inside == false && minLength > 0) ? minLength + Dpi.Width2 : Dpi.Width4;

                int step = cstyle.LengthStep;
                int offset = (size.Width / 2 + clen);

                if (inside ? end < start : end > start)
                {
                    step *= -1;
                    offset *= -1;
                }

                Point ptc = pt;
                ptc.X += offset;

                t = GetCenteredRectangle(series, ptc, size);

                while (step < 0 ? t.X > bounds.X : t.Right < bounds.Right)
                {
                    if (SetHBarLabelPos(pl, ovlMode, bounds, ptc, t, start, end) == true)
                        return;

                    if (ovlMode != DataLabelOverlapMode.RotateAroundPoint)
                        break;

                    t.X += step;

                    if (cstyle.MaxLength > 0)
                    {
                        if (Math.Abs(t.X - ptc.X) > cstyle.MaxLength)
                            break;
                    }
                }

                inside = !inside;
            }

            SetHBarDefaultLabelPos(series, ref pl, pt, t, ovlMode, start, end);
        }

        #endregion

        #region SetHBarLabelFar

        private void SetHBarLabelFar(ChartSeries series, PointLabel pl, Rectangle bounds,
            DataLabelOverlapMode ovlMode, DataLabelVisualStyle dstyle, int start, int end, bool inside)
        {
            ConnectorLineVisualStyle cstyle = dstyle.ConnectorLineStyle;

            Point pt = new Point(end, pl.Point.Y + series.BarOffset);
            Size size = GetBoundsSize(series, pl, dstyle);

            Rectangle t = Rectangle.Empty;

            int minLength = Dpi.Width(cstyle.MinLength);
            
            for (int i = 0; i < 2; i++)
            {
                int clen = (inside == false && minLength >= 0) ? minLength + Dpi.Width2 : Dpi.Width4;

                int step = cstyle.LengthStep;
                int offset = (size.Width / 2 + clen);

                if (inside ? end > start : end < start)
                {
                    step *= -1;
                    offset *= -1;
                }

                Point ptc = pt;
                ptc.X += offset;

                t = GetCenteredRectangle(series, ptc, size);

                while (step < 0 ? t.X > bounds.X : t.Right < bounds.Right)
                {
                    if (SetHBarLabelPos(pl, ovlMode, bounds, ptc, t, start, end) == true)
                        return;

                    if (ovlMode != DataLabelOverlapMode.RotateAroundPoint)
                        break;

                    t.X += step;

                    if (cstyle.MaxLength > 0)
                    {
                        if (Math.Abs(t.X - ptc.X) > cstyle.MaxLength)
                            break;
                    }
                }

                inside = !inside;
            }

            SetHBarDefaultLabelPos(series, ref pl, pt, t, ovlMode, start, end);
        }

        #endregion

        #region SetHBarLabelCenter

        private void SetHBarLabelCenter(ChartSeries series, PointLabel pl,
            Rectangle bounds, DataLabelOverlapMode ovlMode, DataLabelVisualStyle dstyle,
            int start, int end)
        {
            Point pt = new Point((end + start) / 2, pl.Point.Y + series.BarOffset);

            int pass = 0;
            int step = 2;
            int startx = pt.X;

            Size size = GetBoundsSize(series, pl, dstyle);

            Rectangle t = GetCenteredRectangle(series, pt, size);

            int len = (end + start) / 2;

            while (pass <= len)
            {
                if (SetHBarLabelPos(pl, ovlMode, bounds, pt, t, start, end) == true)
                    return;

                if (ovlMode != DataLabelOverlapMode.RotateAroundPoint)
                    break;

                int pval = pass / 2 + 1;

                if (pass % 2 > 0)
                    pval = -pval;

                t.X = (startx + (pval * step));

                pass++;
            }

            SetHBarDefaultLabelPos(series, ref pl, pt, t, ovlMode, start, end);
        }

        #endregion

        #region SetHBarLabelPos

        private bool SetHBarLabelPos(PointLabel pl,
            DataLabelOverlapMode ovlMode, Rectangle bounds, Point pt, Rectangle t, int start, int end)
        {
            if (IsFreeArea(t, bounds, ovlMode, false, true) == true)
            {
                pl.Bounds = t;

                SetHBarEdgePoint(pl, pt, t, start, end);

                return (true);
            }

            if (ovlMode == DataLabelOverlapMode.HideOverlapping)
                return (true);

            return (false);
        }

        #endregion

        #region SetHBarDefaultLabelPos

        private void SetHBarDefaultLabelPos(ChartSeries series, ref PointLabel pl,
            Point pt, Rectangle t, DataLabelOverlapMode ovlMode, int start, int end)
        {
            if (ovlMode == DataLabelOverlapMode.RotateAroundPoint)
            {
                if (t.X < start)
                    t.X = start + Dpi.Width4;
                else
                    t.X = end - (t.Width + Dpi.Width4);

                ChartXy chartXy = series.Parent as ChartXy;

                Rectangle bounds = chartXy.ContentBoundsEx;

                if (t.Right > bounds.Right)
                    t.X -= (t.Right - bounds.Right + Dpi.Width4);

                if (t.X < bounds.X)
                    t.X = bounds.X + Dpi.Width4;

                pl.Bounds = t;

                SetHBarEdgePoint(pl, pt, t, start, end);
            }
            else
            {
                pl.Bounds = Rectangle.Empty;
                pl.EdgePoint = Point.Empty;
            }
        }

        #endregion

        #region SetHBarEdgePoint

        private void SetHBarEdgePoint(PointLabel pl, Point pt, Rectangle t, int start, int end)
        {
            if (t.X > start && t.X > end)
            {
                pt.X = Math.Max(start, end);
                pl.EdgePoint = new Point(t.X, pt.Y);
            }
            else if (t.X < start && t.X < end)
            {
                pt.X = Math.Min(start, end);
                pl.EdgePoint = new Point(t.Right, pt.Y);
            }
            else
            {
                pl.EdgePoint = Point.Empty;
            }

            pl.Point = pt;
        }

        #endregion

        #endregion

        #region IterateVBar

        private void IterateVBar(ChartSeries series, PointLabel pl,
            Rectangle bounds, DataLabelOverlapMode ovlMode, DataLabelVisualStyle dstyle)
        {
            ChartXy chartXy = series.Parent as ChartXy;

            int start = series.GetVBarStart(chartXy, pl.SeriesPoint);
            int end = pl.Point.Y;

            BarLabelPosition labelPos = series.GetBarLabelPosition(chartXy);

            switch (labelPos)
            {
                case BarLabelPosition.Near:
                    SetVBarLabelNear(series, pl, bounds, ovlMode, dstyle, start, end, false);
                    break;

                case BarLabelPosition.NearInside:
                    SetVBarLabelNear(series, pl, bounds, ovlMode, dstyle, start, end, true);
                    break;

                case BarLabelPosition.Far:
                    SetVBarLabelFar(series, pl, bounds, ovlMode, dstyle, start, end, false);
                    break;

                case BarLabelPosition.FarInside:
                    SetVBarLabelFar(series, pl, bounds, ovlMode, dstyle, start, end, true);
                    break;

                default:
                    SetVBarLabelCenter(series, pl, bounds, ovlMode, dstyle, start, end);
                    break;
            }
        }

        #region SetVBarLabelNear

        private void SetVBarLabelNear(ChartSeries series, PointLabel pl, Rectangle bounds,
            DataLabelOverlapMode ovlMode, DataLabelVisualStyle dstyle, int start, int end, bool inside)
        {
            ConnectorLineVisualStyle cstyle = dstyle.ConnectorLineStyle;

            Point pt = new Point(pl.Point.X + series.BarOffset, start);
            Size size = GetBoundsSize(series, pl, dstyle);

            int minLength = Dpi.Width(cstyle.MinLength);

            int clen = (inside == false && minLength >= 0) ? minLength + Dpi.Width2 : Dpi.Width4;

            int step = cstyle.LengthStep;
            int offset = (size.Height / 2 + clen);

            Rectangle t = Rectangle.Empty;

            for (int i = 0; i < 2; i++)
            {
                if (inside ? end < start : end > start)
                {
                    step *= -1;
                    offset *= -1;
                }

                Point ptc = pt;
                ptc.Y += offset;

                t = GetCenteredRectangle(series, ptc, size);

                while (t.Y < bounds.Bottom)
                {
                    if (SetVBarLabelPos(pl, ovlMode, bounds, ptc, t, start, end) == true)
                        return;

                    if (ovlMode != DataLabelOverlapMode.RotateAroundPoint)
                        break;

                    t.Y += step;

                    if (cstyle.MaxLength > 0)
                    {
                        if (Math.Abs(t.Y - ptc.Y) > cstyle.MaxLength)
                            break;
                    }
                }

                inside = !inside;
            }

            SetVBarDefaultLabelPos(series, ref pl, pt, t, ovlMode, start, end);
        }

        #endregion

        #region SetVBarLabelFar

        private void SetVBarLabelFar(ChartSeries series, PointLabel pl, Rectangle bounds,
            DataLabelOverlapMode ovlMode, DataLabelVisualStyle dstyle, int start, int end, bool inside)
        {
            ConnectorLineVisualStyle cstyle = dstyle.ConnectorLineStyle;

            Point pt = new Point(pl.Point.X + series.BarOffset, end);
            Size size = GetBoundsSize(series, pl, dstyle);

            int minLength = Dpi.Width(cstyle.MinLength);

            Rectangle t = Rectangle.Empty;

            for (int i = 0; i < 2; i++)
            {
                int clen = (inside == false && minLength >= 0) ? minLength + Dpi.Width2 : Dpi.Width4;

                int step = cstyle.LengthStep;
                int offset = (size.Height / 2 + clen);

                if (inside ? end > start : end < start)
                {
                    step *= -1;
                    offset *= -1;
                }

                Point ptc = pt;
                ptc.Y += offset;

                t = GetCenteredRectangle(series, ptc, size);

                while (step < 0 ? t.Y > bounds.Y : t.Y < bounds.Bottom)
                {
                    if (SetVBarLabelPos(pl, ovlMode, bounds, ptc, t, start, end) == true)
                        return;

                    if (ovlMode != DataLabelOverlapMode.RotateAroundPoint)
                        break;

                    t.Y += step;

                    if (cstyle.MaxLength > 0)
                    {
                        if (Math.Abs(t.Y - ptc.Y) > cstyle.MaxLength)
                            break;
                    }
                }

                inside = !inside;
            }

            SetVBarDefaultLabelPos(series, ref pl, pt, t, ovlMode, start, end);
        }

        #endregion

        #region SetVBarLabelCenter

        private void SetVBarLabelCenter(ChartSeries series, PointLabel pl,
            Rectangle bounds, DataLabelOverlapMode ovlMode, DataLabelVisualStyle dstyle,
            int origin, int end)
        {
            Point pt = new Point(pl.Point.X + series.BarOffset, (end + origin) / 2);

            int pass = 0;
            int step = 2;
            int starty = pt.Y;

            Size size = GetBoundsSize(series, pl, dstyle);

            Rectangle t = GetCenteredRectangle(series, pt, size);

            int len = (end + origin) / 2;

            while (pass <= len)
            {
                if (SetVBarLabelPos(pl, ovlMode, bounds, pt, t, origin, end) == true)
                    return;

                if (ovlMode != DataLabelOverlapMode.RotateAroundPoint)
                    break;

                int pval = pass / 2 + 1;

                if (pass % 2 > 0)
                    pval = -pval;

                t.Y = (starty + (pval * step));

                pass++;
            }

            SetVBarDefaultLabelPos(series, ref pl, pt, t, ovlMode, origin, end);
        }

        #endregion

        #region SetVBarLabelPos

        private bool SetVBarLabelPos(PointLabel pl,
            DataLabelOverlapMode ovlMode, Rectangle bounds, Point pt, Rectangle t, int start, int end)
        {
            if (IsFreeArea(t, bounds, ovlMode, false, true) == true)
            {
                pl.Bounds = t;

                SetVBarEdgePoint(pl, pt, t, start, end);

                return (true);
            }

            if (ovlMode == DataLabelOverlapMode.HideOverlapping)
                return (true);

            return (false);
        }

        #endregion

        #region SetVBarDefaultLabelPos

        private void SetVBarDefaultLabelPos(ChartSeries series, ref PointLabel pl,
            Point pt, Rectangle t, DataLabelOverlapMode ovlMode, int start, int end)
        {
            if (ovlMode == DataLabelOverlapMode.RotateAroundPoint)
            {
                if (t.Y > start)
                    t.Y = start - (t.Height + Dpi.Height4);
                else
                    t.Y = end + Dpi.Height4;

                ChartXy chartXy = series.Parent as ChartXy;

                Rectangle bounds = chartXy.ContentBoundsEx;

                if (t.Y > bounds.Bottom)
                    t.Y -= (t.Bottom - bounds.Bottom + Dpi.Height4);

                if (t.Y < bounds.Y)
                    t.Y = bounds.Y + Dpi.Height4;

                pl.Bounds = t;

                SetVBarEdgePoint(pl, pt, t, start, end);
            }
            else
            {
                pl.Bounds = Rectangle.Empty;
                pl.EdgePoint = Point.Empty;
            }
        }

        #endregion

        #region SetVBarEdgePoint

        private void SetVBarEdgePoint(PointLabel pl, Point pt, Rectangle t, int start, int end)
        {
            if (t.Y > start && t.Y > end)
            {
                pt.Y = Math.Max(start, end);
                pl.EdgePoint = new Point(pt.X, t.Y);
            }
            else if (t.Y < start && t.Y < end)
            {
                pt.Y = Math.Min(start, end);
                pl.EdgePoint = new Point(pt.X, t.Bottom);
            }
            else
            {
                pl.EdgePoint = Point.Empty;
            }

            pl.Point = pt;
        }

        #endregion

        #endregion

        #region IteratePoint

        private void IteratePoint(ChartSeries series, PointLabel pl,
            Rectangle bounds, Point lp, DataLabelOverlapMode ovlMode, DataLabelVisualStyle dstyle)
        {
            if ((dstyle.CenterLabel != Tbool.True) ||
                SetLabelCenter(series, pl, bounds, ovlMode, dstyle) == false)
            {
                ConnectorLineVisualStyle cstyle = dstyle.ConnectorLineStyle;

                int step;
                int startAngle = GetStartAngle(lp, pl, cstyle, out step);

                int offset = 0;

                if (cstyle.Origin == ConnectorOrigin.Edge)
                {
                    offset = Math.Max(
                        pl.SeriesPoint.PointSize.Width,
                        pl.SeriesPoint.PointSize.Height) / 2;
                }

                SetLabel(series, pl, startAngle, step,
                    cstyle.MinLength + offset, cstyle.MaxLength + offset, ovlMode, bounds, dstyle);
            }
        }

        #endregion

        #region GetBoundsSize

        private Size GetBoundsSize(
            ChartSeries series, PointLabel pl, DataLabelVisualStyle dstyle)
        {
            RotateDegrees rotate = series.GetRotateDegrees(dstyle);

            Size size = (rotate == RotateDegrees.Rotate90 || rotate == RotateDegrees.Rotate270)
                ? new Size(pl.LabelSize.Height, pl.LabelSize.Width) : pl.LabelSize;

            if (dstyle.HasBorder == true)
            {
                size.Width += (dstyle.BorderThickness << 1);
                size.Height += (dstyle.BorderThickness << 1);
            }

            size.Width += dstyle.Padding.Horizontal;
            size.Height += dstyle.Padding.Vertical;

            return (size);
        }

        #endregion

        #region SetLabelCenter

        private bool SetLabelCenter(ChartSeries series, PointLabel pl,
            Rectangle bounds, DataLabelOverlapMode ovlMode, DataLabelVisualStyle dstyle)
        {
            Rectangle t = GetCenteredRectangle(series, pl.Point, pl.LabelSize);

            if (IsFreeArea(t, bounds, ovlMode, true, true) == true)
            {
                pl.Bounds = t;
                pl.EdgePoint = new Point(t.Right, t.Bottom);

                return (true);
            }

            if (ovlMode == DataLabelOverlapMode.HideOverlapping)
                return (true);

            return (false);
        }

        #endregion

        #region SetLabel

        private bool SetLabel(ChartSeries series, PointLabel pl, int startAngle, int step,
            int radius, int maxRadius, DataLabelOverlapMode ovlMode, Rectangle bounds, DataLabelVisualStyle dstyle)
        {
            int angle = startAngle;
            int pass = 0;

            radius = Dpi.Width(radius);
            maxRadius = Dpi.Width(maxRadius);

            while (radius <= maxRadius)
            {
                Point calcPoint;
                Rectangle r = GetAreaRectangle(series, pl, angle, radius, out calcPoint, dstyle);

                if (IsFreeArea(r, bounds, ovlMode, true, true) == true)
                {
                    pl.Angle = angle;
                    pl.Bounds = r;
                    pl.EdgePoint = calcPoint;

                    return (true);
                }

                if (ovlMode != DataLabelOverlapMode.RotateAroundPoint)
                    break;

                int pval = pass / 2 + 1;

                if (pass % 2 > 0)
                    pval = -pval;

                angle = (startAngle + (pval * step)) % 360;

                pass++;

                if (pass * step >= 360)
                {
                    radius += Dpi.Width15;
                    pass = 0;
                }
            }

            pl.Bounds = Rectangle.Empty;
            pl.EdgePoint = Point.Empty;

            return (false);
        }

        #endregion

        #region GetStartAngle

        private int GetStartAngle(Point lp,
            PointLabel pl, ConnectorLineVisualStyle cstyle, out int step)
        {
            step = cstyle.AngleStep;

            if (cstyle.DefaultAngle >= 0)
                return (cstyle.DefaultAngle);

            Point pt = pl.Point;

            int rise = lp.Y - pt.Y;
            int run = lp.X - pt.X;

            double slope = (run == 0) ? 0 : (double)rise / run;

            return ((slope < 1) ? 270 : (slope > 0) ? 315 : 225);
        }

        #endregion

        #region GetCenteredRectangle

        private Rectangle GetCenteredRectangle(
            ChartSeries series, Point pt, Size labelSize)
        {
            Rectangle r = new Rectangle(pt, labelSize);

            r.X -= (r.Width / 2);
            r.Y -= (r.Height / 2);

            return (r);
        }

        #endregion

        #region GetAreaRectangle

        private Rectangle GetAreaRectangle(ChartSeries series, PointLabel pl,
            int angle, int radius, out Point calcPoint, DataLabelVisualStyle dstyle)
        {
            Rectangle r = new Rectangle(pl.Point, pl.LabelSize);

            RotateDegrees rotate = series.GetRotateDegrees(dstyle);

            if (rotate == RotateDegrees.Rotate90 || rotate == RotateDegrees.Rotate270)
            {
                r.Width = pl.LabelSize.Height;
                r.Height = pl.LabelSize.Width;
            }

            if (dstyle.HasBorder == true)
            {
                int n = Dpi.Width(dstyle.BorderThickness) << 1;

                r.Width += n;
                r.Height += n;
            }

            r.Width += Dpi.Width(dstyle.Padding.Horizontal);
            r.Height += Dpi.Height(dstyle.Padding.Vertical);

            r.X += (int)(radius * Math.Cos(MathHelper.ToRadians(angle)));
            r.Y += (int)(radius * Math.Sin(MathHelper.ToRadians(angle)));

            calcPoint = r.Location;

            return (OffsetAreaRectangle(r, angle, ref calcPoint, dstyle));
        }

        #region OffsetAreaRectangle

        private Rectangle OffsetAreaRectangle(Rectangle r,
            int angle, ref Point calcPoint, DataLabelVisualStyle dstyle)
        {
            if (angle == 0)
            {
                r.Y -= (r.Height / 2);
            }
            else if (angle == 90)
            {
                r.X -= (r.Width / 2);
            }
            else if (angle == 180)
            {
                r.X -= r.Width;
                r.Y -= (r.Height / 2);
            }
            else if (angle == 270)
            {
                r.X -= (r.Width / 2);
                r.Y -= r.Height;
            }
            else if (angle < 90)
            {
            }
            else if (angle < 180)
            {
                r.X -= r.Width;
            }
            else if (angle < 270)
            {
                r.X -= r.Width;
                r.Y -= r.Height;
            }
            else
            {
                r.Y -= r.Height;
            }

            return (r);
        }

        #endregion

        #endregion

        #region IsFreeArea

        private bool IsFreeArea(
            Rectangle r, Rectangle bounds, DataLabelOverlapMode ovlMode, bool xos, bool yos)
        {
            if (xos == true)
            {
                if (r.X < bounds.X || r.Right > bounds.Right)
                    return (false);
            }

            if (yos == true)
            {
                if (r.Y < bounds.Y || r.Bottom > bounds.Bottom)
                    return (false);
            }

            if (ovlMode == DataLabelOverlapMode.ShowOverlapping)
                return (true);

            r.Inflate(3, 3);

            for (int i = 0; i < _LabelGroups.Count; i++)
            {
                List<PointLabel> lps = _LabelGroups[i].PointLabels;

                for (int j = 0; j < lps.Count; j++)
                {
                    PointLabel pl = lps[j];

                    if (pl.Bounds.IsEmpty == false)
                    {
                        if (pl.Bounds.IntersectsWith(r) == true)
                            return (false);
                    }
                }
            }

            return (true);
        }

        #endregion

        #endregion
    }
}