protected virtual void ShowDialogCore()
        {
            string title     = isEditable ? GisEditor.LanguageManager.GetStringResource("ViewDataEditDataTitle") : GisEditor.LanguageManager.GetStringResource("ViewDataViewDataTitle");
            Window dbfViewer = new Window {
                Style = Application.Current.FindResource("WindowStyle") as System.Windows.Style, Title = title
            };

            dbfViewer.Content = this;
            if (viewerSize != null)
            {
                dbfViewer.Width  = viewerSize.Item1;
                dbfViewer.Height = viewerSize.Item2;
            }
            dbfViewer.Closing += (s, e) =>
            {
                this.IsClosing = true;
                viewerSize     = new Tuple <double, double>(dbfViewer.ActualWidth, dbfViewer.ActualHeight);
            };
            dbfViewer.ShowDialog();
            GisEditor.DockWindowManager.DockWindows.Select(d => d.Content).OfType <DataViewerUserControl>().ForEach(d =>
            {
                DataViewerViewModel viewModel = d.DataContext as DataViewerViewModel;
                if (viewModel != null)
                {
                    viewModel.SelectedLayerAdapter = viewModel.SelectedLayerAdapter;
                }
            });

            this.isHighlightFeatureOnly = (this.DataContext as DataViewerViewModel).ShowSelectedFeatures;
        }
        private void UserControl_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
            featureLayers = new Collection <FeatureLayer>(featureLayers.Where(l =>
            {
                var plugin = GisEditor.LayerManager.GetLayerPlugins(l.GetType()).FirstOrDefault() as FeatureLayerPlugin;
                return(plugin != null);
            }).ToList());
            if (isEditable)
            {
                string helpUri = GisEditor.LanguageManager.GetStringResource("EditDataHelp");
                HelpContainer.Content = HelpButtonHelper.GetHelpButton(helpUri, HelpButtonMode.IconOnly);
            }
            else
            {
                string helpUri = GisEditor.LanguageManager.GetStringResource("ViewDataHelp");
                HelpContainer.Content = HelpButtonHelper.GetHelpButton(helpUri, HelpButtonMode.IconOnly);
            }

            LoadingUriColumnsDataViewerUserControlEventArgs args = new LoadingUriColumnsDataViewerUserControlEventArgs();

            foreach (var item in linkColumnNames)
            {
                args.UriColumnNames.Add(item.Key, item.Value);
            }
            OnLoadingUriColumns(args);
            if (args.UriColumnNames.Count > 0)
            {
                foreach (var item in args.UriColumnNames)
                {
                    linkColumnNames[item.Key] = item.Value;
                }
            }

            viewModel = new DataViewerViewModel(map, featureLayers, selectedFeatureLayer, isHighlightFeatureOnly, isEditable, linkColumnNames);
            this.deleteColumn.Visibility = viewModel.EditVisible;
            this.DataContext             = viewModel;
            viewModel.EditDataChanges.CollectionChanged += EditDataChanges_CollectionChanged;

            scrollBar = GetVisualChild <ScrollBar>(dg);
            scrollBar.LostMouseCapture += new MouseEventHandler(scrollBar_LostMouseCapture);
            Window parentWindow = Parent as Window;

            ContextMenu contextMenu = new ContextMenu();

            MenuItem exportItem = new MenuItem();

            exportItem.Header = GisEditor.LanguageManager.GetStringResource("ViewDataExportButton");

            exportItem.Icon = new Image {
                Source = new BitmapImage(new Uri("/GisEditorInfrastructure;component/Images/exporttoexcel.png", UriKind.RelativeOrAbsolute)), Width = 16, Height = 16
            };
            exportItem.Click += new RoutedEventHandler(ExportItem_Click);

            MenuItem menuItem = new MenuItem()
            {
                Header = GisEditor.LanguageManager.GetStringResource("DataViewerUserControlExportSelectedData")
            };

            menuItem.Icon = new Image {
                Source = new BitmapImage(new Uri("/GisEditorInfrastructure;component/Images/exporttoexcel.png", UriKind.RelativeOrAbsolute)), Width = 16, Height = 16
            };
            menuItem.Click += new RoutedEventHandler(MenuItem_Click);

            MenuItem copyRowMenuItem = new MenuItem()
            {
                Header = GisEditor.LanguageManager.GetStringResource("DataViewerUserControlCopySelectedRowLabel")
            };

            copyRowMenuItem.Icon = new Image {
                Source = new BitmapImage(new Uri("/GisEditorInfrastructure;component/Images/copytoexcel.png", UriKind.RelativeOrAbsolute)), Width = 16, Height = 16
            };
            copyRowMenuItem.Click += new RoutedEventHandler(CopyRowMenuItem_Click);

            MenuItem copyCellMenuItem = new MenuItem()
            {
                Header = GisEditor.LanguageManager.GetStringResource("DataViewerUserControlCopySelectedCellLabel")
            };

            copyCellMenuItem.Icon = new Image {
                Source = new BitmapImage(new Uri("/GisEditorInfrastructure;component/Images/copytoexcel.png", UriKind.RelativeOrAbsolute)), Width = 16, Height = 16
            };
            copyCellMenuItem.Click += new RoutedEventHandler(CopyCellMenuItem_Click);

            contextMenu.Items.Add(exportItem);
            contextMenu.Items.Add(menuItem);
            contextMenu.Items.Add(copyRowMenuItem);
            contextMenu.Items.Add(copyCellMenuItem);
            dg.ContextMenu = contextMenu;

            if (parentWindow != null)
            {
                parentWindow.Closing += ParentWindow_Closing;
            }
        }
        private void SaveChangesClick(object sender, RoutedEventArgs e)
        {
            if (viewModel.EditDataChanges.Count > 0)
            {
                string[] ids = viewModel.EditDataChanges.Select(edc => edc.FeatureID).Distinct().ToArray();
                try
                {
                    TransactionResult result = null;
                    lock (viewModel.SelectedLayerAdapter)
                    {
                        var overlays = DataViewerViewModel.FindLayerOverlayContaining((Tag as GisEditorWpfMap), viewModel.SelectedLayer);
                        foreach (var overlay in overlays)
                        {
                            overlay.Close();
                        }
                        viewModel.ChangeCurrentLayerReadWriteMode(GeoFileReadWriteMode.ReadWrite);
                        viewModel.OpenFeatureLayer();
                        Collection <Feature> features = viewModel.SelectedLayer.QueryTools.GetFeaturesByIds(ids, viewModel.SelectedLayer.GetDistinctColumnNames());
                        var columns = viewModel.SelectedLayer.QueryTools.GetColumns();
                        foreach (var group in viewModel.EditDataChanges.GroupBy(edc => edc.FeatureID))
                        {
                            Feature resultFeature = features.FirstOrDefault(f => f.Id.Equals(group.Key));
                            if (resultFeature != null)
                            {
                                foreach (var item in group)
                                {
                                    resultFeature.ColumnValues[item.ColumnName] = item.NewValue;
                                }
                                var isColumnValueValid = CheckColumnValuesAreValid(resultFeature, columns);
                                if (!isColumnValueValid)
                                {
                                    var failureReasons = new Dictionary <string, string>();
                                    failureReasons.Add("InvalidValue", "Invalid value, please input a valid value.");
                                    result = new TransactionResult(0, 1, failureReasons, TransactionResultStatus.Failure);
                                    features.Remove(resultFeature);
                                    foreach (var item in group)
                                    {
                                        item.Undo();
                                    }
                                }
                            }
                        }

                        if (features.Count > 0)
                        {
                            viewModel.SelectedLayer.EditTools.BeginTransaction();
                            foreach (var feature in features)
                            {
                                viewModel.SelectedLayer.EditTools.Update(feature);
                            }
                            result = viewModel.SelectedLayer.EditTools.CommitTransaction();
                        }
                    }

                    if (result != null && result.TotalFailureCount != 0)
                    {
                        StringBuilder sb = new StringBuilder();
                        foreach (var keyValue in result.FailureReasons)
                        {
                            sb.AppendLine(keyValue.Value);
                            foreach (var item in viewModel.EditDataChanges.Where(edc => edc.FeatureID.Equals(keyValue.Key)))
                            {
                                item.Undo();
                            }
                        }

                        if (!isClosing)
                        {
                            if (result.TotalFailureCount > 1)
                            {
                                string message = "Many errors occur.";
                                GisEditorMessageBox messageBox = new GisEditorMessageBox(MessageBoxButton.OK);
                                messageBox.Message      = message;
                                messageBox.ErrorMessage = sb.ToString();
                                messageBox.Title        = GisEditor.LanguageManager.GetStringResource("FeatureAttibuteWindowUpdateFailedCaption");
                                messageBox.ShowDialog();
                            }
                            else
                            {
                                string message = sb.ToString();
                                if (message.Contains("The Value you input is too long"))
                                {
                                    message = "Value entered exceeds field length.";
                                }
                                GisEditorMessageBox messageBox = new GisEditorMessageBox(MessageBoxButton.OK);
                                messageBox.Message      = message;
                                messageBox.ErrorMessage = sb.ToString();
                                messageBox.Title        = GisEditor.LanguageManager.GetStringResource("FeatureAttibuteWindowUpdateFailedCaption");
                                messageBox.ShowDialog();
                            }
                        }
                    }
                    else
                    {
                        if (!viewModel.ChangedLayers.Contains(viewModel.SelectedLayer))
                        {
                            viewModel.ChangedLayers.Add(viewModel.SelectedLayer);
                        }
                    }
                }
                catch (UnauthorizedAccessException accessEx)
                {
                    System.Windows.Forms.MessageBox.Show(accessEx.Message, "Access Denied");
                    GisEditor.LoggerManager.Log(LoggerLevel.Debug, accessEx.Message, new ExceptionInfo(accessEx));
                }
                finally
                {
                    viewModel.CloseFeatureLayer();
                    viewModel.ChangeCurrentLayerReadWriteMode(GeoFileReadWriteMode.Read);
                }
                viewModel.EditDataChanges.Clear();
            }
        }