ImageViewerInteractiveMode Class

Summary

Base class for the rich user experience features of the ImageViewer.

Syntax

C++

public abstract class ImageViewerInteractiveMode

Public MustInherit Class ImageViewerInteractiveMode

public ref class ImageViewerInteractiveMode abstract

Remarks

ImageViewerInteractiveMode works with the InteractiveService object of the ImageViewer to provide rich user interface experiences when the user interacts with the viewer using mouse or touch.

ImageViewerInteractiveMode is a base abstract class: from it you can derive your own class to handle custom interaction with the viewer. For more information and for a list of the out-of-the-box modes provided by LEADTOOLS, refer to Image Viewer Interactive Modes.

ImageViewerInteractiveMode has the following functionality:

Member	Description
WorkingCursor, IdleCursor and HitTestStateCursor	Cursor to use when the interactive mode is in an idle, working or hit-test state (for desktop browsers).
MouseButtons	The mouse button attached to this mode (for desktop browsers)

To use an interactive mode, you create an instance of any of the derived classes and assign it to the viewer using one of the following methods:

ImageViewer.DefaultInteractiveMode: Assigns the interactive mode to the left mouse button on desktop browsers or default touch events on devices that support touch.
ImageViewer.InteractiveModes: Add more than one interactive mode to the viewer.

Within the derived class, attach listeners to the events of InteractiveService to perform actions based on user input. Set InteractiveEventArgs.IsHandled to true to mark the events as handled so that other interactive modes will not also respond to the events, if desired.

You can use multiple interactive modes at the same time. For example, use the following code to support panning/zooming with the left mouse button and magnify glass with the right button:

Example

This example will create a custom ImageViewerInteractiveMode that will rotate the image when the user clicks or touches and drags on the viewer.

using Leadtools; 
using Leadtools.Controls; 
using Leadtools.Codecs; 
using Leadtools.Drawing; 
using LeadtoolsExamples.Common; 
using Leadtools.ImageProcessing; 
using Leadtools.ImageProcessing.Color; 
 
private class TransformInteractiveMode : ImageViewerInteractiveMode 
{ 
   public TransformInteractiveMode() : 
      base() 
   { 
      this.AutoItemMode = ImageViewerAutoItemMode.AutoSet; 
   } 
 
   private Keys _scaleKeyModifier = Keys.Control; 
   public virtual Keys ScaleKeyModifier 
   { 
      get { return _scaleKeyModifier; } 
      set 
      { 
         // Supported is none and any modifiers 
         switch (value) 
         { 
            case Keys.None: 
            case Keys.Alt: 
            case Keys.Shift: 
            case Keys.Control: 
               _scaleKeyModifier = value; 
               break; 
 
            default: 
               throw new ArgumentException("Invalid value", "ScaleKeyModifier"); 
         } 
      } 
   } 
 
   private Keys _rotateKeyModifier = Keys.Alt; 
   public virtual Keys RotateKeyModifier 
   { 
      get { return _rotateKeyModifier; } 
      set 
      { 
         // Supported is none and any modifiers 
         switch (value) 
         { 
            case Keys.None: 
            case Keys.Alt: 
            case Keys.Shift: 
            case Keys.Control: 
               _rotateKeyModifier = value; 
               break; 
 
            default: 
               throw new ArgumentException("Invalid value", "PageKeyModifier"); 
         } 
      } 
   } 
 
   public override string Name 
   { 
      get { return "Transform"; } 
   } 
 
   public override int Id 
   { 
      get { return ImageViewerInteractiveMode.UserModeId + 3; } 
   } 
 
   public override void Start(ImageViewer imageViewer) 
   { 
      base.Start(imageViewer); 
      var service = base.InteractiveService; 
 
      // Pan required events 
      service.DragStarted += new EventHandler<InteractiveDragStartedEventArgs>(service_DragStarted); 
      service.DragDelta += new EventHandler<InteractiveDragDeltaEventArgs>(service_DragDelta); 
      service.DragCompleted += new EventHandler<InteractiveDragCompletedEventArgs>(service_DragCompleted); 
      service.DoubleTap += new EventHandler<InteractiveEventArgs>(service_DoubleTap); 
   } 
 
   public override void Stop(ImageViewer imageViewer) 
   { 
      if (IsStarted) 
      { 
         var service = base.InteractiveService; 
 
         service.DragStarted -= new EventHandler<InteractiveDragStartedEventArgs>(service_DragStarted); 
         service.DragDelta -= new EventHandler<InteractiveDragDeltaEventArgs>(service_DragDelta); 
         service.DragCompleted -= new EventHandler<InteractiveDragCompletedEventArgs>(service_DragCompleted); 
         service.DoubleTap -= new EventHandler<InteractiveEventArgs>(service_DoubleTap); 
 
         base.Stop(imageViewer); 
      } 
   } 
 
   private void service_DragStarted(object sender, InteractiveDragStartedEventArgs e) 
   { 
      // Make sure pinch is not working, otherwise, ignore pan 
      if (!this.CanStartWork(e)) 
         return; 
 
      // Make sure we are on an item 
      if (this.Item == null) 
         return; 
 
      e.IsHandled = true; 
      this.OnWorkStarted(EventArgs.Empty); 
   } 
 
   private void service_DragDelta(object sender, InteractiveDragDeltaEventArgs e) 
   { 
      if (!this.IsWorking) 
         return; 
 
      var item = this.Item; 
      if (item == null) 
         return; 
 
      // Find out what to do 
      var dx = e.Change.X; 
      var dy = e.Change.Y; 
 
      if (dx == 0 && dy == 0) 
         return; 
 
      var scaleKeyModifier = this.ScaleKeyModifier; 
      var rotateKeyModifier = this.RotateKeyModifier; 
      var scale = (Control.ModifierKeys & scaleKeyModifier) == scaleKeyModifier; 
      var rotate = (Control.ModifierKeys & rotateKeyModifier) == rotateKeyModifier; 
 
      var imageViewer = this.ImageViewer; 
 
      if (scale) 
      { 
         Scale(imageViewer, item, dy, e.Origin); 
      } 
      else if (rotate) 
      { 
         Rotate(imageViewer, item, dx, e.Origin); 
      } 
      else 
      { 
         Translate(imageViewer, item, dx, dy); 
      } 
 
      e.IsHandled = true; 
   } 
 
   private void service_DragCompleted(object sender, InteractiveDragCompletedEventArgs e) 
   { 
      if (!this.IsWorking) 
         return; 
 
      e.IsHandled = true; 
      OnWorkCompleted(EventArgs.Empty); 
   } 
 
   private void service_DoubleTap(object sender, InteractiveEventArgs e) 
   { 
      // Make sure we not working already 
      if (this.IsWorking || !this.CanStartWork(e)) 
         return; 
 
      // Make sure we have an item 
      var item = this.Item; 
      if (item == null) 
         return; 
 
      e.IsHandled = true; 
 
      this.OnWorkStarted(EventArgs.Empty); 
      Identity(this.ImageViewer, item); 
      this.OnWorkCompleted(EventArgs.Empty); 
   } 
 
   private void Identity(ImageViewer imageViewer, ImageViewerItem item) 
   { 
      item.Transform = LeadMatrix.Identity; 
   } 
 
   private void Scale(ImageViewer imageViewer, ImageViewerItem item, int dy, LeadPoint position) 
   { 
      // ... 
      // set scale code 
      // ... 
   } 
 
   private void Rotate(ImageViewer imageViewer, ImageViewerItem item, int dx, LeadPoint position) 
   { 
      // ... 
      // set rotate code 
      // ... 
   } 
 
   private void Translate(ImageViewer imageViewer, ImageViewerItem item, int dx, int dy) 
   { 
      // ... 
      // set translate code 
      // ... 
   } 
} 
 
public void ImageViewerInteractiveMode_Example() 
{ 
   _imageViewer.InteractiveModes.BeginUpdate(); 
   _imageViewer.InteractiveModes.Add(new TransformInteractiveMode { IsEnabled = false }); 
   //... 
   //... 
   //... 
   _imageViewer.InteractiveModes.EndUpdate(); 
}

Imports Leadtools 
Imports Leadtools.Controls 
Imports Leadtools.Codecs 
Imports Leadtools.Drawing 
Imports Leadtools.ImageProcessing 
Imports Leadtools.ImageProcessing.Color 
 
Private Class TransformInteractiveMode : Inherits ImageViewerInteractiveMode 
   Public Sub New() 
      MyBase.New() 
      Me.AutoItemMode = ImageViewerAutoItemMode.AutoSet 
   End Sub 
 
   Private _scaleKeyModifier As Keys = Keys.Control 
   Public Overridable Property ScaleKeyModifier() As Keys 
      Get 
         Return _scaleKeyModifier 
      End Get 
      Set(value As Keys) 
         ' Supported is none and any modifiers 
         Select Case value 
            Case Keys.None, Keys.Alt, Keys.Shift, Keys.Control 
               _scaleKeyModifier = value 
 
            Case Else 
               Throw New ArgumentException("Invalid value", "ScaleKeyModifier") 
         End Select 
      End Set 
   End Property 
 
   Private _rotateKeyModifier As Keys = Keys.Alt 
   Public Overridable Property RotateKeyModifier() As Keys 
      Get 
         Return _rotateKeyModifier 
      End Get 
      Set(value As Keys) 
         ' Supported is none and any modifiers 
         Select Case value 
            Case Keys.None, Keys.Alt, Keys.Shift, Keys.Control 
               _rotateKeyModifier = value 
 
            Case Else 
               Throw New ArgumentException("Invalid value", "PageKeyModifier") 
         End Select 
      End Set 
   End Property 
 
   Public Overrides ReadOnly Property Name() As String 
      Get 
         Return "Transform" 
      End Get 
   End Property 
 
   Public Overrides ReadOnly Property Id() As Integer 
      Get 
         Return ImageViewerInteractiveMode.UserModeId + 3 
      End Get 
   End Property 
 
   Public Overrides Sub Start(ByVal imageViewer As ImageViewer) 
      MyBase.Start(imageViewer) 
      Dim service As InteractiveService = MyBase.InteractiveService 
 
      ' Pan required events 
      AddHandler service.DragStarted, AddressOf service_DragStarted 
      AddHandler service.DragDelta, AddressOf service_DragDelta 
      AddHandler service.DragCompleted, AddressOf service_DragCompleted 
      AddHandler service.DoubleTap, AddressOf service_DoubleTap 
   End Sub 
 
   Public Overrides Sub [Stop](ByVal imageViewer As ImageViewer) 
      If IsStarted Then 
         Dim service As InteractiveService = MyBase.InteractiveService 
 
         RemoveHandler service.DragStarted, AddressOf service_DragStarted 
         RemoveHandler service.DragDelta, AddressOf service_DragDelta 
         RemoveHandler service.DragCompleted, AddressOf service_DragCompleted 
         RemoveHandler service.DoubleTap, AddressOf service_DoubleTap 
 
         MyBase.Stop(imageViewer) 
      End If 
   End Sub 
 
   Private Sub service_DragStarted(ByVal sender As Object, ByVal e As InteractiveDragStartedEventArgs) 
      ' Make sure pinch is not working, otherwise, ignore pan 
      If (Not Me.CanStartWork(e)) Then 
         Return 
      End If 
 
      ' Make sure we are on an item 
      If Me.Item Is Nothing Then 
         Return 
      End If 
 
      e.IsHandled = True 
      Me.OnWorkStarted(EventArgs.Empty) 
   End Sub 
 
   Private Sub service_DragDelta(ByVal sender As Object, ByVal e As InteractiveDragDeltaEventArgs) 
      If (Not Me.IsWorking) Then 
         Return 
      End If 
 
      Dim item As ImageViewerItem = Me.Item 
      If item Is Nothing Then 
         Return 
      End If 
 
      ' Find out what to do 
      Dim dx As Integer = e.Change.X 
      Dim dy As Integer = e.Change.Y 
 
      If dx = 0 AndAlso dy = 0 Then 
         Return 
      End If 
 
      Dim scaleKey As Keys = Me.ScaleKeyModifier 
      Dim rotateKey As Keys = Me.RotateKeyModifier 
      Dim doScale As Boolean = (Control.ModifierKeys And scaleKey) = scaleKey 
      Dim doRotate As Boolean = (Control.ModifierKeys And rotateKey) = rotateKey 
 
      Dim imageViewer As ImageViewer = Me.ImageViewer 
 
      If doScale Then 
         Scale(imageViewer, item, dy, e.Origin) 
      ElseIf doRotate Then 
         Rotate(imageViewer, item, dx, e.Origin) 
      Else 
         Translate(imageViewer, item, dx, dy) 
      End If 
 
      e.IsHandled = True 
   End Sub 
 
   Private Sub service_DragCompleted(ByVal sender As Object, ByVal e As InteractiveDragCompletedEventArgs) 
      If (Not Me.IsWorking) Then 
         Return 
      End If 
 
      e.IsHandled = True 
      OnWorkCompleted(EventArgs.Empty) 
   End Sub 
 
   Private Sub service_DoubleTap(ByVal sender As Object, ByVal e As InteractiveEventArgs) 
      ' Make sure we not working already 
      If Me.IsWorking OrElse (Not Me.CanStartWork(e)) Then 
         Return 
      End If 
 
      ' Make sure we have an item 
      Dim item As ImageViewerItem = Me.Item 
      If item Is Nothing Then 
         Return 
      End If 
 
      e.IsHandled = True 
 
      Me.OnWorkStarted(EventArgs.Empty) 
      Identity(Me.ImageViewer, item) 
      Me.OnWorkCompleted(EventArgs.Empty) 
   End Sub 
 
   Private Sub Identity(ByVal imageViewer As ImageViewer, ByVal item As ImageViewerItem) 
      item.Transform = LeadMatrix.Identity 
   End Sub 
 
   Private Sub Scale(ByVal imageViewer As ImageViewer, ByVal item As ImageViewerItem, ByVal dy As Integer, ByVal position As LeadPoint) 
      ' ... 
      ' set scale code 
      ' ... 
   End Sub 
 
   Private Sub Rotate(ByVal imageViewer As ImageViewer, ByVal item As ImageViewerItem, ByVal dx As Integer, ByVal position As LeadPoint) 
      ' ... 
      ' set rotate code 
      ' ... 
   End Sub 
 
   Private Sub Translate(ByVal imageViewer As ImageViewer, ByVal item As ImageViewerItem, ByVal dx As Integer, ByVal dy As Integer) 
      ' ... 
      ' set translate code 
      ' ... 
   End Sub 
End Class 
 
Public Sub ImageViewerInteractiveMode_Example() 
   _imageViewer.InteractiveModes.BeginUpdate() 
   Dim mode As New TransformInteractiveMode 
   mode.IsEnabled = False 
   _imageViewer.InteractiveModes.Add(mode) 
   '... 
   '... 
   '... 
   _imageViewer.InteractiveModes.EndUpdate() 
End Sub

Requirements

Target Platforms

Reference

ImageViewerInteractiveMode Members

Leadtools.Controls Namespace

Download our FREE evaluation

Help Version 20.0.2020.4.3

Leadtools.Controls Assembly

Introduction

Getting Started

Namespaces

Leadtools.Controls Namespace

Assemblies