public KmlConfigureWindow()
        {
            InitializeComponent();

            OkButton.IsEnabled       = false;
            ZHeightNumeric.Value     = GetAltitudeValue();
            ZHeightNumeric.IsEnabled = false;
            KmlParameter             = new KmlParameter();
        }
        public static KmlParameter GetKmlParameter()
        {
            KmlParameter       parameter = null;
            KmlConfigureWindow window    = new KmlConfigureWindow();

            window.Owner = Application.Current.MainWindow;
            window.WindowStartupLocation = WindowStartupLocation.CenterOwner;
            if (window.ShowDialog().GetValueOrDefault())
            {
                parameter = window.KmlParameter;
            }
            return(parameter);
        }
        public static void SaveKmlData(IEnumerable <FeatureLayer> featureLayers, KmlParameter parameter)
        {
            StringBuilder builder   = new StringBuilder();
            GeoCanvas     kmlCanvas = new KmlGeoCanvas();

            if (parameter.Is3DKml)
            {
                kmlCanvas = new Kml3DGeoCanvas();
                ((Kml3DGeoCanvas)kmlCanvas).ZHeight = parameter.ZHeight;
            }
            Proj4Projection proj = new Proj4Projection();

            proj.InternalProjectionParametersString = GisEditor.ActiveMap.DisplayProjectionParameters;
            proj.ExternalProjectionParametersString = Proj4Projection.GetDecimalDegreesParametersString();
            proj.Open();

            kmlCanvas.BeginDrawing(builder, proj.ConvertToExternalProjection(GisEditor.ActiveMap.CurrentExtent), GeographyUnit.DecimalDegree);
            featureLayers.ForEach(l =>
            {
                Proj4ProjectionInfo projectionInfo = l.GetProj4ProjectionInfo();
                if (projectionInfo != null)
                {
                    projectionInfo.ExternalProjectionParametersString = Proj4Projection.GetWgs84ParametersString();
                    projectionInfo.SyncProjectionParametersString();
                }

                l.Open();
                l.Draw(kmlCanvas, new Collection <SimpleCandidate>());
            });
            kmlCanvas.EndDrawing();
            using (StreamWriter sw = new StreamWriter(parameter.PathFileName))
            {
                sw.Write(builder.ToString());
                sw.Close();
            }
        }
        public static void SaveToKmlMenuitemClick(object sender, RoutedEventArgs e)
        {
            Collection <Feature> features = GisEditor.SelectionManager.GetSelectedFeatures();

            if (features.All(i => !GisEditor.ActiveMap.CurrentExtent.Intersects(i)))
            {
                ShowOptionsIfNoSelectedFeatureInCurrentExtent(features);
                return;
            }

            Collection <FeatureLayer> featureLayers = new Collection <FeatureLayer>();
            var             featuresGroup           = GisEditor.SelectionManager.GetSelectionOverlay().GetSelectedFeaturesGroup();
            Proj4Projection tempProjection          = new Proj4Projection();

            tempProjection.InternalProjectionParametersString = GisEditor.ActiveMap.DisplayProjectionParameters;
            tempProjection.ExternalProjectionParametersString = Proj4Projection.GetWgs84ParametersString();
            tempProjection.SyncProjectionParametersString();

            try
            {
                tempProjection.Open();
                foreach (var item in featuresGroup)
                {
                    if (item.Value.Count > 0)
                    {
                        InMemoryFeatureLayer layer = new InMemoryFeatureLayer();
                        ZoomLevelSet         sourceZoomLevelSet = item.Key.ZoomLevelSet;
                        try
                        {
                            string       tempXml            = GisEditor.Serializer.Serialize(sourceZoomLevelSet);
                            ZoomLevelSet targetZoomLevelSet = (ZoomLevelSet)GisEditor.Serializer.Deserialize(tempXml);
                            layer.ZoomLevelSet = targetZoomLevelSet;

                            layer.Open();
                            layer.EditTools.BeginTransaction();
                            foreach (var feature in item.Value)
                            {
                                Feature newFeature = tempProjection.ConvertToExternalProjection(feature);
                                layer.EditTools.Add(newFeature);
                            }
                            layer.EditTools.CommitTransaction();

                            if (!item.Key.IsOpen)
                            {
                                item.Key.Open();
                            }
                            foreach (var column in item.Key.QueryTools.GetColumns())
                            {
                                layer.Columns.Add(column);
                            }

                            featureLayers.Add(layer);
                        }
                        catch (Exception ex)
                        {
                            GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                GisEditor.LoggerManager.Log(LoggerLevel.Debug, ex.Message, new ExceptionInfo(ex));
            }
            finally
            {
                tempProjection.Close();
            }

            KmlParameter parameter = GetKmlParameter();

            //System.Windows.Forms.SaveFileDialog sf = new System.Windows.Forms.SaveFileDialog();
            //sf.Filter = "(*.kml)|*.kml|(*.kmz)|*.kmz";
            //sf.FileName = string.Format("{0}-{1}", "KmlExportFile", DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss"));
            if (parameter != null)
            {
                if (Path.GetExtension(parameter.PathFileName).ToUpper() == ".KML")
                {
                    SaveKmlData(featureLayers, parameter);
                }
                else if (Path.GetExtension(parameter.PathFileName).ToUpper() == ".KMZ")
                {
                    StringBuilder         builder       = GetKmlDataBuilder(featureLayers);
                    PlatformGeoCanvas     canvas        = new PlatformGeoCanvas();
                    System.Drawing.Bitmap bitmap        = new System.Drawing.Bitmap((int)GisEditor.ActiveMap.ActualWidth, (int)GisEditor.ActiveMap.ActualHeight);
                    RectangleShape        drawingExtent = GetDrawingExtentInWgs84();
                    canvas.BeginDrawing(bitmap, drawingExtent, GeographyUnit.DecimalDegree);
                    featureLayers.ForEach(l =>
                    {
                        Proj4ProjectionInfo projectionInfo = l.GetProj4ProjectionInfo();
                        if (projectionInfo != null)
                        {
                            projectionInfo.ExternalProjectionParametersString = Proj4Projection.GetWgs84ParametersString();
                            projectionInfo.SyncProjectionParametersString();
                        }

                        l.Open();
                        l.Draw(canvas, new Collection <SimpleCandidate>());
                    });
                    canvas.EndDrawing();
                    string kmlPath = Path.ChangeExtension(parameter.PathFileName, ".kml");
                    string pngPath = Path.ChangeExtension(parameter.PathFileName, ".png");

                    if (File.Exists(kmlPath))
                    {
                        File.Delete(kmlPath);
                    }
                    if (File.Exists(pngPath))
                    {
                        File.Delete(pngPath);
                    }

                    MemoryStream stream = new MemoryStream();
                    bitmap.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
                    byte[] bitmapArray = stream.GetBuffer();

                    File.WriteAllText(kmlPath, builder.ToString());
                    File.WriteAllBytes(pngPath, bitmapArray);

                    var zipFileAdapter = ZipFileAdapterManager.CreateInstance();
                    zipFileAdapter.AddFileToZipFile(kmlPath, "");
                    zipFileAdapter.AddFileToZipFile(pngPath, "");
                    zipFileAdapter.Save(Path.ChangeExtension(parameter.PathFileName, ".kmz"));
                    File.Delete(kmlPath);
                    File.Delete(pngPath);
                }

                string mentionedString = GisEditor.LanguageManager.GetStringResource("KMLFileHasSavedSuccessText");
                if (MessageBox.Show(mentionedString, "Open in Google Earth", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                {
                    string proInstalledPath = GetGoogleEarthProInstalledPath();
                    OpenKmlFileWithGoogleEarth(string.IsNullOrEmpty(proInstalledPath) ? GetGoogleEarthInstalledPath() : proInstalledPath
                                               , parameter.PathFileName);
                }
            }
        }