layerhandler.cs

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using Core.GIS.Geodatabase;
using ESRI.ArcGIS.Carto;
using ESRI.ArcGIS.esriSystem;
using ESRI.ArcGIS.Geodatabase;

namespace Core.GIS.Carto
{
	/// <summary>
	/// Responsável por controlar
	/// as operações realizadas sobre
	/// as camadas de um mapa.
	/// </summary>
	public class MapLayerHandler : IMapLayerHandler
	{
		// equivalente à IFeatureLayer
		private const string LAYER_UID = "{E156D7E5-22AF-11D3-9F99-00C04F6BC78E}";
        private static log4net.ILog _log = log4net.LogManager.GetLogger(typeof(MapLayerHandler));

		private IMap _currentMap;

		public IMap CurrentMap
		{
			get { return _currentMap; }
			private set { _currentMap = value; }
		}

		public int LayerCount
		{
			get { return _currentMap.LayerCount; }
		}

		public MapLayerHandler(IMap currentMap)
		{
			_currentMap = currentMap;
		}

		#region Privado

		/// <summary>
		/// Método auxiliar para testar se o indíce do layer é válido
		/// </summary>
		/// <param name="index"></param>
		/// <returns></returns>
		private bool IsIndexValid(int index)
		{
		    return _currentMap.LayerCount > index;
		}

	    #endregion

		#region Acesso

		/// <summary>
		/// Retorna todos layers da TOC
		/// </summary>
		/// <returns>IEnumerable[ILayer]</returns>
		public IList<ILayer> GetLayers()
		{
			IEnumLayer layerEnum = null;
			var layers = new List<ILayer>();
            try
            {
                UID uid = new UIDClass {Value = LAYER_UID};
                layerEnum = _currentMap.get_Layers(uid, true);
                ILayer tempLayer;

                while ((tempLayer = layerEnum.Next()) != null)
                {
                    layers.Add(tempLayer);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
			finally
			{
				// release the bad com boys
			    if (layerEnum != null)
                    Marshal.FinalReleaseComObject(layerEnum);
			}

			return layers;
		}

        /// <summary>
        /// Retorna uma lista de camadas pelo nome da feature class
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public IList<ILayer> GetLayersByDatasetName(string name)
        {
            List<ILayer> result = new List<ILayer>();
            IDataset ds;

            if (String.IsNullOrEmpty(name))
                throw new ArgumentException("Não é possível pesquisar por um layer de nome vazio ou nulo.");


            foreach (ILayer l in GetLayers())
            {
                try
                {
                    // se l não é um featureLayer, continue na próxima iteração
                    if (!(l is IFeatureLayer))
                        continue;

                    ds = ((IFeatureLayer)l).FeatureClass as IDataset;
                    System.Diagnostics.Debug.WriteLine(ds.BrowseName);
                    // dataset é nulo, estoure exception, anrã.

                    if (ds.BrowseName.ToLower().Contains(name.ToLower()))
                    {
                        result.Add(l);
                    }
                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Ocorreu um problema ao buscar a camada pelo nome do dataset {0}.", l.Name);
                    continue;
                }
            }

            return result;
        }

	    /// <summary>
		/// Retorna uma camada pelo nome da FEATURE CLASS.
		/// </summary>
		/// <param name="name">string</param>
		/// <returns>ILayer</returns>
		public ILayer GetLayerByDatasetName(string name)
		{
			ILayer result = null;
            IDataset ds;

			if (String.IsNullOrEmpty(name))
				throw new ArgumentException("Não é possível pesquisar por um layer de nome vazio ou nulo.");


            foreach (ILayer l in GetLayers())
            {            
                try
                {
                    // se l não é um featureLayer, continue na próxima iteração
                    if (!(l is IFeatureLayer))
                        continue;

                    ds = ((IFeatureLayer)l).FeatureClass as IDataset;
                    System.Diagnostics.Debug.WriteLine(ds.BrowseName);
                    // dataset é nulo, estoure exception, anrã.

                    if (ds.BrowseName.ToLower().Contains(name.ToLower()))
                    {
                        result = l;
                        break;
                    }
                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Ocorreu um problema ao buscar a camada pelo nome do dataset {0}.", l.Name);
                    continue;
                }
            }

			return result;
		}

		/// <summary>
		/// Retorna um layer pelo indíce
		/// </summary>
		/// <param name="index">int</param>
		/// <returns>ILayer</returns>
		public ILayer GetLayer(int index)
		{
			ILayer layer = null;
			if (IsIndexValid(index))
				layer = _currentMap.get_Layer(index);

			return layer;
		}

		#endregion

		#region Visibilidade

		/// <summary>
		/// Liga todas as camadas da TOC
		/// </summary>
		public void TurnOnAll()
		{
			for (int i = 0; i <= _currentMap.LayerCount - 1; i++)
			{
				TurnLayerOn(i);
			}
		}

		/// <summary>
		/// Desliga todas as camadas da TOC
		/// </summary>
		public void TurnOffAll()
		{
			for (int i = 0; i <= _currentMap.LayerCount - 1; i++)
			{
				TurnLayerOff(i);
			}
		}

		/// <summary>
		/// Alterna a visibilidade de uma camada
		/// </summary>
		/// <param name="index">int</param>
		public void SwitchVisibility(int index)
		{
			if (_currentMap.LayerCount <= index)
				throw new ArgumentException("Não é possível solicitar um layer que não está presente.");

			ILayer layer = _currentMap.get_Layer(index);

            // alterna a visibilidade da camada.
			layer.Visible = !layer.Visible;
		}

		/// <summary>
		/// Desliga uma camada qualquer
		/// </summary>
		/// <remarks>
		/// O cliente é responsável por chamar Refresh.
		/// </remarks>
		/// <param name="index">int</param>
		public void TurnLayerOff(int index)
		{
			if (IsIndexValid(index))
				_currentMap.get_Layer(index).Visible = false;
		}

		public void TurnLayerOff(ILayer l)
		{
			l.Visible = false;
		}

		/// <summary>
		/// Liga uma camada qualquer
		/// </summary>
		/// <remarks>
		/// O cliente é responsável por chamar Refresh().
		/// </remarks>
		/// <param name="index">int</param>
		public void TurnLayerOn(int index)
		{
			if (IsIndexValid(index))
				_currentMap.get_Layer(index).Visible = true;
		}

        /// <summary>
        /// Liga uma cmada qualquer
        /// </summary>
        /// <remarks>
        /// O cliente é responsável por chamar Refresh().
        /// </remarks>
        /// <param name="l">ILayer</param>
		public void TurnLayerOn(ILayer l)
		{
			l.Visible = true;
		}

		#endregion

		#region Outros

		/// <summary>
		/// Aplica uma query à definition query de determinada Layer
		/// </summary>
		/// <param name="index">int</param>
		/// <param name="query">string</param>
		public void ApplyDefinitionQuery(int index, string query)
		{
			ILayer tempLayer = null;
			try
			{
				tempLayer = GetLayer(index);
				ApplyDefinitionQuery(tempLayer, query);
			}
			catch (Exception ex)
			{
                _log.Error(String.Format("Ocorreu um problema ao aplicar uma query à layer {0}.", tempLayer.Name), ex);
			}
			finally
			{
			    if (tempLayer != null)
                    Marshal.ReleaseComObject(tempLayer);
			}
		}

	    public void AddLayer(IFeatureWorkspace workspace, string datasetName)
	    {
	        try
	        {
                IFeatureLayer layer = new FeatureLayerClass();
                layer.FeatureClass = workspace.OpenFeatureClass(datasetName);
                _currentMap.AddLayer(layer);
	        }
	        catch (Exception ex)
	        {
                throw new DatasetNotFoundException("Não foi possível encontrar o dataset solicitado.", ex);
	        }
	    }

	    public void ApplyDefinitionQuery(ILayer l, string query)
		{
	        if (!(l is IFeatureLayer))
                return;

	        var definiton = (IFeatureLayerDefinition)l;
	        definiton.DefinitionExpression = query;
		}

		#endregion
	}
}