public virtual Size ScrollOffsetForChildVisible(RadElement childElement, Point currentScrollValue)
        {
            int childIndex = this.Children.IndexOf(childElement);

            if (childIndex < 0 || childIndex >= this.Children.Count)
            {
                return(Size.Empty);
            }

            Rectangle clientRect = new Rectangle(Point.Empty, this.Size);
            Rectangle childRect  = childElement.FullRectangle;

            childRect.Offset((int)Math.Round(this.PositionOffset.Width), (int)Math.Round(this.PositionOffset.Height));
            Size childOffset    = RadCanvasViewport.CalcMinOffset(childRect, clientRect);
            Size viewportOffset = new Size(-childOffset.Width, -childOffset.Height);

            if (this.Orientation == System.Windows.Forms.Orientation.Vertical)
            {
                viewportOffset.Height = ConvertPixelOffsetToIndexOffset(currentScrollValue.Y, childIndex, viewportOffset.Height);
            }
            else
            {
                viewportOffset.Width = ConvertPixelOffsetToIndexOffset(currentScrollValue.X, childIndex, viewportOffset.Width);
            }

            return(viewportOffset);
        }
        public void ScrollElementIntoView(RadElement childElement)
        {
            if (childElement == null)
            {
                return;
            }

            if (this.UseNewLayoutSystem)
            {
                this.UpdateLayout();
            }

            if (this.UsePhysicalScrolling)
            {
                Rectangle viewportRect = new Rectangle(Point.Empty, this.viewportSize);
                Rectangle childRect    = childElement.FullBoundingRectangle;
                childRect.Offset((int)Math.Round(this.viewport.PositionOffset.Width),
                                 (int)Math.Round(this.viewport.PositionOffset.Height));
                Size childOffset = RadCanvasViewport.CalcMinOffset(childRect, viewportRect);
                ScrollWith(-childOffset.Width, -childOffset.Height);
            }
            else
            {
                if (this.viewport != null)
                {
                    Size offset = ((IRadScrollViewport)this.viewport).ScrollOffsetForChildVisible(childElement, this.Value);
                    ScrollWith(offset.Width, offset.Height);
                }
            }
        }
 public void ScrollElementIntoView(RadElement childElement)
 {
     if (childElement == null)
     {
         return;
     }
     this.UpdateLayout();
     if (this.UsePhysicalScrolling)
     {
         Rectangle dest = new Rectangle(Point.Empty, this.viewportSize);
         Rectangle src  = new Rectangle(childElement.BoundingRectangle.Location, Size.Add(childElement.BoundingRectangle.Size, childElement.Margin.Size));
         src.Offset((int)Math.Round((double)this.viewport.PositionOffset.Width), (int)Math.Round((double)this.viewport.PositionOffset.Height));
         Size size = RadCanvasViewport.CalcMinOffset(src, dest);
         this.ScrollWith(-size.Width, -size.Height);
     }
     else
     {
         if (this.viewport == null)
         {
             return;
         }
         Size size = ((IRadScrollViewport)this.viewport).ScrollOffsetForChildVisible(childElement, this.Value);
         this.ScrollWith(size.Width, size.Height);
     }
 }
        public virtual Size ScrollOffsetForChildVisible(
            RadElement childElement,
            Point currentScrollValue)
        {
            int indexToOffset = this.Children.IndexOf(childElement);

            if (indexToOffset < 0 || indexToOffset >= this.Children.Count)
            {
                return(Size.Empty);
            }
            Rectangle dest = new Rectangle(Point.Empty, this.Size);
            Rectangle src  = new Rectangle(childElement.BoundingRectangle.Location, Size.Add(childElement.BoundingRectangle.Size, childElement.Margin.Size));

            src.Offset((int)Math.Round((double)this.PositionOffset.Width), (int)Math.Round((double)this.PositionOffset.Height));
            Size size1 = RadCanvasViewport.CalcMinOffset(src, dest);
            Size size2 = new Size(-size1.Width, -size1.Height);

            if (this.Orientation == Orientation.Vertical)
            {
                size2.Height = this.ConvertPixelOffsetToIndexOffset(currentScrollValue.Y, indexToOffset, size2.Height);
            }
            else
            {
                size2.Width = this.ConvertPixelOffsetToIndexOffset(currentScrollValue.X, indexToOffset, size2.Width);
            }
            return(size2);
        }
        public override Size ScrollOffsetForChildVisible(RadElement childElement, Point currentScrollValue)
        {
            Rectangle clientRect = new Rectangle(Point.Empty, this.Size);
            Rectangle childRect  = childElement.Bounds;

            childRect.Offset((int)Math.Round(this.PositionOffset.Width), (int)Math.Round(this.PositionOffset.Height));
            Size childOffset    = RadCanvasViewport.CalcMinOffset(childRect, clientRect);
            Size viewportOffset = new Size(-childOffset.Width, -childOffset.Height);

            return(viewportOffset);
        }
Exemple #6
0
        public virtual Size ScrollOffsetForChildVisible(
            RadElement childElement,
            Point currentScrollValue)
        {
            Rectangle dest = new Rectangle(Point.Empty, this.Size);
            Rectangle src  = new Rectangle(childElement.BoundingRectangle.Location, Size.Add(childElement.BoundingRectangle.Size, childElement.Margin.Size));

            src.Offset((int)Math.Round((double)this.PositionOffset.Width), (int)Math.Round((double)this.PositionOffset.Height));
            Size size = RadCanvasViewport.CalcMinOffset(src, dest);

            return(new Size(-size.Width, -size.Height));
        }