GetViewBounds Method

Summary

Current bounds of the view in physical (in control pixel) coordinates.

Syntax

C++/CLI

public virtual LeadRectD GetViewBounds( 
   bool withPadding, 
   bool clipped 
)

public:  
   virtual LeadRectD^ GetViewBounds( 
      bool withPadding, 
      bool clipped 
   )

Parameters

withPadding

true to include the value of ViewPadding when calculating the value, otherwise; false.

clipped

true to intersect the returned value with the current viewer control rectangle, otherwise; false.

Return Value

The view bounds in pixels or LeadRectD.Empty if the viewer does not have any items or if the view does not intersect with the control rectangle.

Remarks

The view consists of all current the items in the viewer plus any padding (set in ViewPadding). This is the area that the viewer use to determine whether horizontal and vertical scrollbars are needed and to calculate their size and position.

The view area is calculated during UpdateTransform. The current ViewLayout determines where each item is placed and calculates their sizes. The total of these sizes is calculated and multiplied by any scale factor (XScaleFactor and YScaleFactor) set by the Zoom method. The final size is the view area.

During the calculations, the viewer will calculate the transformation matrix used when rendering the view. This matrix contains the current padding, scroll offset and scale factors and stored in ViewTransform. For example, to render the view border, the viewer simply draws the value of GetViewBounds transformed with ViewTransform.

For more information, refer to Image Viewer Appearance, Image Viewer Transformation, and Image Viewer Bounds and Transform.

Example

using Leadtools; 
using Leadtools.Controls; 
using Leadtools.Codecs; 
using Leadtools.Drawing; 
using Leadtools.ImageProcessing; 
using Leadtools.ImageProcessing.Color; 
 
 
public void TestRedirectRender() 
{ 
   PictureBox control = new PictureBox(); 
   control.Width = 400; 
   control.Dock = DockStyle.Right; 
   control.BringToFront(); 
   _imageViewer.BringToFront(); 
 
   bool renderView = false; 
 
   control.DoubleClick += (sender, e) => 
   { 
      renderView = !renderView; 
      control.Invalidate(); 
   }; 
 
   control.Paint += (sender, e) => 
   { 
      Graphics graphics = e.Graphics; 
 
      int delta = 20; 
      LeadRect destRect = LeadRect.Create(delta, delta, control.ClientSize.Width - delta * 2, control.ClientSize.Height - delta * 2); 
      LeadRect clipRect = destRect; 
 
      ImageViewerRenderRedirectOptions options = new ImageViewerRenderRedirectOptions(); 
 
      ImageViewerItem item = null; 
      if (!renderView) 
         item = _imageViewer.Items[0]; 
 
      LeadRectD sourceRect; 
 
      if (item == null) 
         sourceRect = _imageViewer.GetViewBounds(true, false); 
      else 
      { 
         sourceRect = _imageViewer.GetItemViewBounds(item, ImageViewerItemPart.Image, false); 
         options.RenderBackgrounds = false; 
         options.RenderBorders = false; 
         options.RenderItemStates = false; 
         options.RenderShadows = false; 
         options.RenderText = false; 
      } 
 
      options.CreateTransform(_imageViewer, destRect, sourceRect, ControlSizeMode.FitAlways, ControlAlignment.Center, ControlAlignment.Center); 
      clipRect = options.Transform.TransformRect(sourceRect).ToLeadRect(); 
 
      _imageViewer.RenderRedirect(graphics, options, clipRect); 
 
      graphics.DrawRectangle(Pens.Black, destRect.X, destRect.Y, destRect.Width + 1, destRect.Height + 1); 
 
      // Now lets find out how much of the view is visible (something pan window would do) 
      LeadRectD rect; 
      if (item == null) 
         rect = _imageViewer.GetViewBounds(true, true); 
      else 
         rect = _imageViewer.GetItemViewBounds(item, ImageViewerItemPart.Image, true); 
 
      LeadPointD[] points = 
      { 
         LeadPointD.Create(rect.Left, rect.Top), 
         LeadPointD.Create(rect.Right, rect.Bottom) 
      }; 
 
      options.Transform.TransformPoints(points); 
 
      double xmin = points[0].X; 
      double ymin = points[0].Y; 
      double xmax = xmin; 
      double ymax = ymin; 
 
      for (int i = 1; i < points.Length; i++) 
      { 
         if (points[i].X < xmin) xmin = points[i].X; 
         if (points[i].X > xmax) xmax = points[i].X; 
         if (points[i].Y < ymin) ymin = points[i].Y; 
         if (points[i].Y > ymax) ymax = points[i].Y; 
      } 
 
      LeadRectD bounds = LeadRectD.FromLTRB(xmin, ymin, xmax, ymax); 
      RectangleF rc = new RectangleF((float)bounds.X, (float)bounds.Y, (float)bounds.Width, (float)bounds.Height); 
      graphics.DrawRectangle(Pens.Yellow, rc.X, rc.Y, rc.Width - 1, rc.Height - 1); 
   }; 
 
   _imageViewer.RedirectRender += (sender, e) => 
   { 
      control.Invalidate(); 
   }; 
}

Requirements

Target Platforms

Reference

ImageViewer Class

ImageViewer Members

Leadtools.Controls Namespace

Download our FREE evaluation

Help Version 22.0.2023.1.24

Leadtools.Controls Assembly

Introduction

Getting Started

Namespaces

Leadtools.Controls Namespace

Assemblies