root/FalconView/trunk/public/Plugins/Overlays/GeodataOverlayServer/DataSourceTree.cs @ 2267

// Copyright (c) 1994-2010 Georgia Tech Research Corporation, Atlanta, GA
// This file is part of FalconView(tm).

// FalconView(tm) is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// FalconView(tm) is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public License
// along with FalconView(tm).  If not, see <http://www.gnu.org/licenses/>.

// FalconView(tm) is a trademark of Georgia Tech Research Corporation.

using FvDataSourcesLib;
using fvw;
using MAPENGINELib;
using MAPSCALEUTILSERVERLib;

using Microsoft.Win32;
using SharedDotNetUtils;

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace GeodataOverlayServer
{
   public partial class DataSourceTree : UserControl
   {
      public delegate void TreeNodeRefreshed(object sender, FvDataTreeNode oldNode, FvDataTreeNode newNode);
      public event TreeNodeRefreshed OnTreeNodeRefreshed;

      private TreeViewEventHandler m_clickHandler;
      private MenuItem[] m_contextMenu;
      private IMapRenderingEngineDataCheck m_datacheck;
      private IMap m_map = new MapClass();
      private IMap3 m_map3 = new Map3Class();
      private IMapRenderingEngine m_renderingEngine = new MapRenderingEngineClass();
      private bool m_bAddingDataSource = false;

      public TreeView Tree
      {
         get { return tree; }
      }

      public DataSourceTree()
      {
         InitializeComponent();
         tree.Parent = this;
         tree.Dock = DockStyle.Fill;
         tree.CheckBoxes = true;

         try
         {

            RegistryKey key = Registry.LocalMachine.OpenSubKey("Software\\PFPS\\FalconView\\Main");
            string dataPath = key.GetValue("HD_DATA").ToString();

            ImageList imageList = new ImageList();
            imageList.Images.Add(Image.FromFile(dataPath + @"\icons\Geodata\Data Source.ico"));
            imageList.Images.Add(Image.FromFile(dataPath + @"\icons\Geodata\Feature Data Set.ico"));
            imageList.Images.Add(Image.FromFile(dataPath + @"\icons\Geodata\Raster Data Set.ico"));
            tree.ImageList = imageList;
         }
         catch (Exception ex)
         {
            LoggingUtils.ReportError(ex);
         }

         m_renderingEngine.Init(null);
         m_datacheck = (IMapRenderingEngineDataCheck)m_renderingEngine;

         m_clickHandler = new TreeViewEventHandler(Tree_AfterCheck);

         Tree.AfterCheck += m_clickHandler;

         m_contextMenu = new MenuItem[3];
         int index = 0;

         m_contextMenu[index] = new MenuItem("Check All Children");
         m_contextMenu[index++].Click += new EventHandler(CheckAllChildren_Click);
         m_contextMenu[index] = new MenuItem("Get Description");
         m_contextMenu[index++].Click += new EventHandler(GetDescription_Click);
         m_contextMenu[index] = new MenuItem("Scale to Extents");
         m_contextMenu[index++].Click += new EventHandler(ScaleToExtents_Click);

         Tree.NodeMouseClick += new System.Windows.Forms.TreeNodeMouseClickEventHandler(Tree_NodeMouseClick);

         // add listener for when nodes are expanded or collapsed
         TreeViewEventHandler handler = new TreeViewEventHandler(UpdateDataSourceExpandedState);
         Tree.AfterCollapse += handler;
         Tree.AfterExpand += handler;
      }

      private void UpdateDataSourceExpandedState(object sender, TreeViewEventArgs e)
      {
         if (!m_bAddingDataSource)
         {
            FvDataTreeNode node = e.Node as FvDataTreeNode;
            if (node != null)
            {
               IUIState uiState = node.Source as IUIState;
               if (uiState != null)
               {
                  switch (e.Action)
                  {
                     case TreeViewAction.Collapse:
                        uiState.Expanded = false;
                        break;
                     case TreeViewAction.Expand:
                        uiState.Expanded = true;
                        break;
                  }
               }
            }
         }
      }

      private void GetDescription_Click(object sender, EventArgs e)
      {
         FvDataTreeNode dataTreeNode = Tree.SelectedNode as FvDataTreeNode;
         if (dataTreeNode != null)
            new DescriptionForm(dataTreeNode).Show(Tree);
      }

      public class DataSourceCallbackHandler : IFvDataSourceCallback
      {
         private FvDataTreeNode m_node;
         private DataSourceTree m_tree;
         private bool m_bRefreshPending = false;

         public DataSourceCallbackHandler(FvDataTreeNode node, DataSourceTree tree)
         {
            LoggingUtils.Assert(node.Source != null, "node must have a data source");
            m_node = node;
            m_tree = tree;
            s_callbackHandlerList.Add(this);
         }

         public void DataSourceChanged()
         {
            try
            {
               // hold refresh until whatever operation has put a hold on refreshing completes

               if (s_bHoldDataSourceCallbacks)
               {
                  m_bRefreshPending = true;
                  return;
               }

               m_bRefreshPending = false;

               // create a new node that contains all the new stuff
               FvDataTreeNode new_node = new FvDataTreeNode(m_node.Source);

               // replace the old node with the new node
               TreeNodeCollection treeNodeCollection = m_tree.Tree.Nodes;
               int index = treeNodeCollection.IndexOf(m_node);
               treeNodeCollection.RemoveAt(index);
               treeNodeCollection.Insert(index, new_node);
               FvDataTreeNode old_node = m_node;
               m_node = new_node;

               // let the world know that we replaced a tree node
               m_tree.FireOnTreeNodeRefreshed(old_node, new_node);
            }
            catch (Exception ex)
            {
               LoggingUtils.ReportError(ex);
            }
         }

         private static bool s_bHoldDataSourceCallbacks = false;
         private static List<DataSourceCallbackHandler> s_callbackHandlerList = new List<DataSourceCallbackHandler>();

         // This is a global hold on refresh callbacks.  Set this if you want to hold refresh callbacks globally until
         // some operation is complete.
         public static bool HoldDataSourceChangedCallbacks
         {
            get { return s_bHoldDataSourceCallbacks; }

            set
            {
               s_bHoldDataSourceCallbacks = value;

               if (!s_bHoldDataSourceCallbacks)
               {
                  // handlers may now fire their refresh events
                  foreach (DataSourceCallbackHandler handler in s_callbackHandlerList)
                  {
                     if (handler.m_bRefreshPending)
                        handler.DataSourceChanged();
                  }
               }
            }
         }

         public void Uninitialize()
         {
            // call when this callback handler is no longer used
            s_callbackHandlerList.Remove(this);
         }
      }

      private Dictionary<IFvDataSource, DataSourceCallbackHandler> m_callbackHandlers = new Dictionary<IFvDataSource, DataSourceCallbackHandler>();

      public FvDataTreeNode AddDataSource(IFvDataSource dataSource)
      {
         try
         {
            m_bAddingDataSource = true;

            // create a tree node and add it to the tree
            FvDataTreeNode node = new FvDataTreeNode(dataSource);
            tree.Nodes.Add(node);

            // create a callback handler and register for callbacks
            m_callbackHandlers[dataSource] = new DataSourceCallbackHandler(node, this);
            try
            {
               dataSource.RegisterForCallbacks(m_callbackHandlers[dataSource]);
            }
            catch (NotImplementedException)
            {
               m_callbackHandlers[dataSource].Uninitialize();
            }

            return node;
         }
         finally
         {
            m_bAddingDataSource = false;
         }
      }

      public void FireOnTreeNodeRefreshed(FvDataTreeNode oldNode, FvDataTreeNode newNode)
      {
         OnTreeNodeRefreshed(this, oldNode, newNode);
      }

      private void BestResolution(double centerLat, double centerLon,
          double rotation, int zoom, int projection,
          string mapSource, IMapScaleUtil scaleUtil,
          double resolution, out Array aScales, out Array aScaleUnits,
          out Array aMapSeries, out int preferredIndex, out double bestResolution)
      {
         object oScales, oScaleUnits, oMapSeries;
         m_datacheck.GetAvailableMapSeries(mapSource, centerLat, centerLon,
             rotation, zoom, (ProjectionEnum)projection, 0,
             out oScales, out oScaleUnits, out oMapSeries);

         aScales = oScales as Array;
         aScaleUnits = oScaleUnits as Array;
         aMapSeries = oMapSeries as Array;

         //scale out until we fail or until we fit the space
         preferredIndex = 0;
         bestResolution = double.MaxValue;

         if (!(aScales is Array && aScaleUnits is Array && aMapSeries is Array))
            return;

         double bestDiff = double.MaxValue;
         for (int i = aScales.GetLowerBound(0);
             i < aScales.GetUpperBound(0);
             i++)
         {
            double indexScale = double.Parse(aScales.GetValue(i).ToString());
            MAPSCALEUTILSERVERLib.MapScaleUnitsEnum indexScaleUnits = (MAPSCALEUTILSERVERLib.MapScaleUnitsEnum)(int.Parse(aScaleUnits.GetValue(i).ToString()));

            double newResolution = indexScale;
            if (!indexScaleUnits.Equals(MAPSCALEUTILSERVERLib.MapScaleUnitsEnum.MAP_SCALE_DENOMINATOR))
            {
               newResolution = scaleUtil.ResolutionToScale(indexScale, indexScaleUnits);
            }

            double diff = Math.Abs(resolution - newResolution);
            if (diff < bestDiff)
            {
               bestDiff = diff;
               bestResolution = newResolution;
               preferredIndex = i;
            }
         }
      }

      void CheckAllChildren_Click(object sender, EventArgs e)
      {
         FvDataTreeNode node = (FvDataTreeNode)Tree.SelectedNode;
         SetCheckNodeAndChildren(node, true);
         SetCheckNodeAndParents(node, true);
      }

      private void CurrentMapSettings(double lonDiff, double latDiff, out double rotation, out int zoom, out int projection, out string mapSource, out IMapScaleUtil scaleUtil, out double resolution)
      {
         //find map pixel bounds
         double scale = 0;
         double currentLat = 0;
         double currentLon = 0;
         rotation = 0;
         int scaleUnits = 0;
         zoom = 0;
         projection = 0;
         int currentHeight = 0;
         int currentWidth = 0;
         mapSource = "";
         string mapSeries = "";
         m_map3.GetMapDisplayEx(
             ref mapSource,
             ref scale,
             ref scaleUnits,
             ref mapSeries,
             ref currentLat,
             ref currentLon,
             ref rotation,
             ref zoom,
             ref projection);

         m_map.GetMapDimensions(ref currentHeight, ref currentWidth);

         //calculate the ratios to use in degrees per pixel
         double widthRatio = lonDiff / currentWidth;
         double heightRatio = latDiff / currentHeight;
         double resolutionDegreesPerPixel = Math.Max(heightRatio, widthRatio);

         //minimal resolution is 1/10 of a second per pixel
         double minResolution = 1.0 / 60.0 / 60.0 / 10.0;
         resolutionDegreesPerPixel = Math.Max(resolutionDegreesPerPixel, minResolution);

         scaleUtil = new MapScaleUtilClass();
         resolution = scaleUtil.ResolutionToScale(resolutionDegreesPerPixel, MAPSCALEUTILSERVERLib.MapScaleUnitsEnum.MAP_SCALE_ARC_DEGREES);
      }

      public void ScaleToExtents()
      {
         try
         {
            double centerLat, centerLon;
            double lonDiff = 0;
            double latDiff = 0;
            if (Tree.SelectedNode is FvDataTreeNode)
            {
               double westLon, eastLon, southLat, northLat;
               FvDataTreeNode node = Tree.SelectedNode as FvDataTreeNode;
               node.Center(out centerLat, out centerLon);
               node.Extent2D(out westLon, out southLat, out eastLon, out northLat);
               lonDiff = Math.Abs(westLon - eastLon);
               latDiff = Math.Abs(northLat - southLat);
            }
            else
            {
               return;
            }

            double rotation;
            int zoom;
            int projection;
            string mapSource;
            IMapScaleUtil scaleUtil;
            double resolution;
            CurrentMapSettings(lonDiff, latDiff, out rotation, out zoom, out projection, out mapSource, out scaleUtil, out resolution);

            string source = "Tiros";
            double scale = 1;
            int scaleUnits = (int)(MAPENGINELib.MapScaleUnitsEnum.MAP_SCALE_WORLD);
            string series = "";

            double bestDiff = double.MaxValue;
            MDSLib.IMapHandlersRowset rowset = new MDSLib.MapHandlersRowsetClass();
            object productsObj = rowset.SelectDistinctProducts();
            Array products = (productsObj as Array);
            foreach (object o in products)
            {
               string product = o as string;

               Array aScales;
               Array aScaleUnits;
               Array aMapSeries;
               int preferredIndex;
               double bestResolution;
               BestResolution(centerLat, centerLon,
                   rotation, zoom, projection, product,
                   scaleUtil, resolution,
                   out aScales, out aScaleUnits, out aMapSeries,
                   out preferredIndex, out bestResolution);
               double diff = Math.Abs(resolution - bestResolution);
               if (diff < bestDiff)
               {
                  bestDiff = diff;
                  source = product;
                  scale = double.Parse(aScales.GetValue(preferredIndex).ToString());
                  scaleUnits = int.Parse(aScaleUnits.GetValue(preferredIndex).ToString());
                  series = aMapSeries.GetValue(preferredIndex).ToString();
               }
            }

            m_map3.SetMapDisplayEx(
                source,
                scale,
                scaleUnits,
                series,
                centerLat,
                centerLon,
                rotation,
                zoom,
                projection);
         }
         catch (Exception ex)
         {
            LoggingUtils.ReportError(ex);
         }
      }

      void ScaleToExtents_Click(object sender, EventArgs e)
      {
         ScaleToExtents();
         //hide the context menu
         SendKeys.SendWait("{ESC}");
      }

      public static void SetCheckNodeAndChildren(FvDataTreeNode parentNode, bool check)
      {
         parentNode.Checked = check;
         IUIState uiState = parentNode.Set as IUIState;
         if (uiState == null) uiState = parentNode.Source as IUIState;
         if (uiState != null) uiState.Visible = check;
         foreach (FvDataTreeNode node in parentNode.Nodes)
            SetCheckNodeAndChildren(node, check);
      }

      public static void SetCheckNodeAndParents(FvDataTreeNode childNode, bool check)
      {
         childNode.Checked = check;
         IUIState uiState = childNode.Set as IUIState;
         if (uiState == null) uiState = childNode.Source as IUIState;
         if (uiState != null) uiState.Visible = check;
         if (childNode.Parent != null)
            SetCheckNodeAndParents((FvDataTreeNode)childNode.Parent, check);
      }

      void Tree_AfterCheck(object sender, TreeViewEventArgs e)
      {
         Tree.AfterCheck -= m_clickHandler;
         if (!e.Node.Checked)
         {
            SetCheckNodeAndChildren((FvDataTreeNode)e.Node, false);
         }
         if (e.Node.Checked)
         {
            SetCheckNodeAndParents((FvDataTreeNode)e.Node, true);
         }
         Tree.AfterCheck += m_clickHandler;
      }

      void Tree_NodeMouseClick(object sender, System.Windows.Forms.TreeNodeMouseClickEventArgs e)
      {
         Tree.SelectedNode = e.Node;
         if (e.Button == MouseButtons.Right)
         {
            ContextMenu menu = new ContextMenu(m_contextMenu);
            menu.Show(Tree, e.Location);
         }
      }

      public void Unload(FvDataTreeNode dataSource)
      {
         Unload(dataSource, Tree.Nodes);
      }

      public bool Unload(FvDataTreeNode dataSource, TreeNodeCollection nodes)
      {
         foreach (TreeNode node in nodes)
         {
            if (node is FvDataTreeNode)
            {
               FvDataTreeNode dsNode = node as FvDataTreeNode;
               if (dsNode.Source == dataSource.Source && m_callbackHandlers.ContainsKey(dataSource.Source))
               {
                  // unregister callback handler
                  try
                  {
                     dataSource.Source.UnregisterForCallbacks(m_callbackHandlers[dataSource.Source]);
                     m_callbackHandlers[dataSource.Source].Uninitialize();
                  }
                  catch (NotImplementedException)
                  {
                     //this means we didn't register it in the first place during adding - any reporting should
                     //be done at that point.  We have nothing to do here.
                  }
                  m_callbackHandlers.Remove(dataSource.Source);
                  if (m_callbackHandlers.ContainsKey(dataSource.Source))
                  {
                     dataSource.Source.UnregisterForCallbacks(m_callbackHandlers[dataSource.Source]);
                     m_callbackHandlers[dataSource.Source].Uninitialize();
                     m_callbackHandlers.Remove(dataSource.Source);
                  }

                  // remove the node from the tree
                  tree.Nodes.Remove(dsNode);

                  return true;
               }
               //check children
               if (node.Nodes != null && Unload(dataSource, node.Nodes))
               {
                  return true;
               }
            }
         }
         return false;
      }
   }

   public class FvDataTreeNode : TreeNode
   {
      private IFvDataSet m_set;
      private IFvDataSource m_source;

      public IFvDataSet Set
      {
         get { return m_set; }
      }

      public IFvDataSource Source
      {
         get { return m_source; }
      }

      public FvDataTreeNode(IFvDataSource dataSource) : base(dataSource.Name)
      {
         m_source = dataSource;
         Checked = true;
         ImageIndex = 0;
         SelectedImageIndex = ImageIndex;

         //set data set after setting ImageIndex & SelectedImageIndex to make sure these are correct
         IFvDataSet dataSet = m_source as IFvDataSet;
         if (dataSet != null) SetDataSet(dataSet);

         // set the check state
         IUIState uiState = m_source as IUIState;
         this.Checked = uiState != null ? uiState.Visible : true;

         // don't add any objects twice (some data sets and data sources are the same object)
         Dictionary<IntPtr, object> objectsAlreadyAdded = new Dictionary<IntPtr, object>();

         //add all data sources
         for (int i = 0; i < dataSource.DataSourceCount; i++)
         {
            IFvDataSource source = dataSource.GetDataSource(i);
            Add(source);
            // "For any one object, a specific query for the IUnknown interface on any of the object's interfaces must
            // always return the same pointer value." from http://msdn.microsoft.com/en-us/library/ms682521(VS.85).aspx
            IntPtr iunk = Marshal.GetIUnknownForObject(source);
            objectsAlreadyAdded[iunk] = null;
            Marshal.Release(iunk); // required after GetIUnknownForObject
         }

         for (int i = 0; i < dataSource.DataSetCount; i++)
         {
            IFvDataSet set = dataSource.GetDataSet(i);
            IntPtr iunk = Marshal.GetIUnknownForObject(set);
            if (!objectsAlreadyAdded.ContainsKey(iunk))
               Add(set);
            Marshal.Release(iunk); // required after GetIUnknownForObject
         }

         // set the expanded state
         if (uiState != null)
            if (uiState.Expanded) Expand(); else Collapse();
         else
            Expand();
      }

      public FvDataTreeNode(IFvDataSet dataSet) : base(dataSet.Name)
      {
         SetDataSet(dataSet);
         IUIState uiState = dataSet as IUIState;
         this.Checked = uiState != null ? uiState.Visible : true;
      }

      public void Add(IFvDataSet dataSet)
      {
         this.Nodes.Add(new FvDataTreeNode(dataSet));
      }

      public void Add(IFvDataSource dataSource)
      {
         FvDataTreeNode node = new FvDataTreeNode(dataSource);
         this.Nodes.Add(node);
      }

      public void Center(out double latitude, out double longitude)
      {
         double northLat;
         double southLat;
         double eastLon;
         double westLon;

         Extent2D(out westLon, out southLat, out eastLon, out northLat);

         double latDiff = northLat - southLat;
         latitude = southLat + (latDiff / 2);

         double lonDiff = eastLon - westLon;
         if (lonDiff < 0)
         {
            lonDiff = (180.0 - westLon) + (eastLon - -180.0);
         }
         longitude = westLon + (lonDiff / 2);
         while (longitude >= 180.0)
         {
            longitude -= 360.0;
         }
      }

      public void Extent2D(out double westLon, out double southLat, out double eastLon, out double northLat)
      {
         if (m_source != null)
         {
            m_source.Extent2D(out westLon, out southLat, out eastLon, out northLat);
            return;
         }
         else if (m_set != null)
         {
            m_set.Extent2D(out westLon, out southLat, out eastLon, out northLat);
            return;
         }

         //since either m_source or m_set must be valid, one of the above will work
         //but we have to assign something because the compiler doesn't realize that
         westLon = 0;
         eastLon = 0;
         northLat = 0;
         southLat = 0;
      }

      private void SetDataSet(IFvDataSet dataSet)
      {
         m_set = dataSet;
         ImageIndex = dataSet is IRasterDataSet ? 2 : 1;
         SelectedImageIndex = ImageIndex;
      }
   }
}