Visually Located | Managing Extents within the ArcGIS WPF/Silverlight/etc. APIs

Managing extents within the ArcGIS .Net client API’s is pretty simple. Esri has an example on the resources page. I implemented one for the ArcFM Silverlight SDK sample. Oddly enough, they are quite similar. I don’t remember copying theirs, but you never know. Like most things we as developers do, after a couple of years you look back and wonder “What was I thinking?” I look back at my original code and wonder why did I implement the Extents class the way that I did. I originally used one List to hold all of the Extents. This made some of the code pretty ugly. I’ve created a different implementation that utilizes two stacks. I have one class that manages all of the extents:

        1: public class Extents

       2: {

       3:     private readonly Stack<Envelope> _backStack = new Stack<Envelope>();

       4:     private readonly Stack<Envelope> _forwardStack = new Stack<Envelope>();

       5:  

       6:     public bool HasPreviousExtent

       7:     {

       8:         get { return _backStack.Count > 0; }

       9:     }

  

    public bool HasNextExtent

    {

        get { return _forwardStack.Count > 0; }

    }

  

    public Envelope CurrentExtent { get; set; }

  

    public Envelope PreviousExtent

    {

        get

        {

            if (HasPreviousExtent)

            {

                _forwardStack.Push(CurrentExtent);

                CurrentExtent = _backStack.Pop();

                return CurrentExtent;

            }

            return null;

        }

    }

  

    public Envelope NextExtent

    {

        get

        {

            if (HasNextExtent)

            {

                _backStack.Push(CurrentExtent);

                CurrentExtent = _forwardStack.Pop();

                return CurrentExtent;

            }

            return null;

        }

    }

  

    public void Add(Envelope extent)

    {

        if (extent == null) return;

  

        if (CurrentExtent != null)

        {

            _backStack.Push(CurrentExtent);

        }

        CurrentExtent = extent;

  

        // If a new extent is added, then anything in our forward stack needs to be removed

        _forwardStack.Clear();

    }

}

I’m a big fan of MVVM, so I’ll use a ViewModel to access the Extents. I’ll also be using the DelegateCommand from Microsoft.

       1: public class ViewModel

       2: {

       3:     public ViewModel()

       4:     {

       5:         Extents = new Extents();

       6:         PreviousExtent = new DelegateCommand(MovePreviousExtent, extent => Extents.HasPreviousExtent);

       7:         NextExtent = new DelegateCommand(MoveNextExtent, extent => Extents.HasNextExtent);

       8:         IsNewExtent = true;

       9:     }

  

    private Map _map;

  

    public Map Map

    {

        get { return _map; }

        set

        {

            UnsubscribeMapEvents(_map);

            SubscribeMapEvents(value);

            _map = value; 

        }

    }

  

    public DelegateCommand PreviousExtent { get; private set; }

    public DelegateCommand NextExtent { get; private set; }

  

    private bool IsNewExtent { get; set; }

    private Extents Extents { get; set; }

  

    private void MovePreviousExtent(object obj)

    {

        // This extent should not be put onto the Extents stack.

        IsNewExtent = false;

        Map.ZoomTo(Extents.PreviousExtent);

    }

    

    private void MoveNextExtent(object obj)

    {

        // This extent should not be put onto the Extents stack.

        IsNewExtent = false;

        Map.ZoomTo(Extents.NextExtent);

    }

  

    private void UnsubscribeMapEvents(Map map)

    {

        if (map == null) return;

        map.ExtentChanged -= Map_ExtentChanged;

    }

  

    private void SubscribeMapEvents(Map map)

    {

        if (map == null) return;

        map.ExtentChanged += Map_ExtentChanged;

    }

  

    private void Map_ExtentChanged(object sender, ExtentEventArgs e)

    {

        // Only add the extent if it is "new" ie: Not a Previous or Next extent

        if (IsNewExtent)

        {

            Extents.Add(e.NewExtent);

        }

        IsNewExtent = true;

        PreviousExtent.RaiseCanExecuteChanged();

        NextExtent.RaiseCanExecuteChanged();

    }

}

The joy of these classes is that they can be used within all of the .Net Client API’s! This can even be used within the new ArcGIS Runtime (currently in Beta). Using these within our application is now a breeze! Here is the xaml for a WPF Window

       1: <Window x:Class="ExtentNavigationApp.MainWindow"

       2:         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

       3:         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 

       4:         xmlns:esri="http://schemas.esri.com/arcgis/client/2009"

       5:         Title="MainWindow" Height="350" Width="525">

       6:     <Grid x:Name="LayoutRoot" Background="White">

       7:         <esri:Map x:Name="Map" >

       8:             <esri:ArcGISTiledMapServiceLayer Url="http://server.arcfmsolution.com/ArcGIS/rest/services/Landbase/MapServer"/>

       9:             <esri:ArcGISTiledMapServiceLayer Url="http://server.arcfmsolution.com/ArcGIS/rest/services/Electric/MapServer"/>

      10:         </esri:Map>

      11:         <StackPanel Orientation="Horizontal" VerticalAlignment="Top">

      12:             <Button Content="Previous Extent" Command="{Binding PreviousExtent}" Height="25" Width="100"/>

      13:             <Button Content="Next Extent" Command="{Binding NextExtent}" Height="25" Width="100"/>

      14:         </StackPanel>

      15:     </Grid>

      16: </Window>

And the code behind:

       1: public partial class MainWindow : Window

       2: {

       3:     public MainWindow()

       4:     {

       5:         InitializeComponent();

       6:         DataContext = new ViewModel() { Map = Map };

       7:     }

       8: }

Related posts