private void mnuUndo_Click(object sender, RoutedEventArgs e)
        {
            Undo();
        }

        private void UndoCanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = _UndoCanExecute;
            e.Handled = true;
        }
        private void Undo()
        {
            LayerOverlay undoLayer = (LayerOverlay)wpfMap.Overlays["undoOverlay"];
            LayerOverlay cLayers = (LayerOverlay)wpfMap.Overlays["basemap"];
            ShapeFileFeatureLayer userLayer;
            Feature undoFeature = new Feature();
            LayerOverlay baseMap = (LayerOverlay)wpfMap.Overlays["basemap"];
            Cursor oldCursor = this.Cursor;
            this.Cursor = Cursors.Wait;
            try
            {
                InMemoryFeatureLayer undo = (InMemoryFeatureLayer)undoLayer.Layers["undo"];
                undoLayer.Lock.EnterWriteLock();
                undo.Open();
                undoFeature = undo.InternalFeatures[undo.InternalFeatures.Count - 1];
                undo.InternalFeatures.RemoveAt(undo.InternalFeatures.Count - 1);
                undo.Close();
                userLayer = (ShapeFileFeatureLayer)cLayers.Layers[undoFeature.ColumnValues["OriginalLayer"]];
                string sLabelLayer = GetLabelLayerName(userLayer);
                userLayer.Close();
                if (undo.InternalFeatures.Count == 0)
                {
                    mnuUndo.IsEnabled = false;
                    btnUndo.IsEnabled = false;
                    btnUndo.Opacity = .25;
                    _UndoCanExecute = false;
                }

            }
            finally
            {
                undoLayer.Lock.ExitWriteLock();
            }
            ShapeFileFeatureLayer street = new ShapeFileFeatureLayer();
            string sLabelName = GetLabelLayerName(userLayer);
            ShapeFileFeatureLayer tempLabelLayer = (ShapeFileFeatureLayer)baseMap.Layers[sLabelName];
            tempLabelLayer.Close();
            userLayer.Close();


            DirectoryInfo dir = new DirectoryInfo(m_renderMapFolder + "USA\\tlka");
            FileInfo[] files = dir.GetFiles("*.shp");
            string sRoadLevel = undoFeature.ColumnValues["OriginalLayer"];
            sRoadLevel = sRoadLevel.Substring(sRoadLevel.Length - 2, 2);
            for (int i = 0; i < files.Length; i++)
            {
                if (files[i].Name.Substring(6, 2) == sRoadLevel)
                {
                    street = new ShapeFileFeatureLayer(m_renderMapFolder + @"USA\TLKA\" + files[i].Name, ShapeFileReadWriteMode.ReadWrite);
                }
            }
            baseMap.Lock.EnterWriteLock();
            try
            {
                if (!street.IsOpen)
                    street.Open();
                Feature newFeature = street.QueryTools.GetFeatureById(undoFeature.Id,ReturningColumnsType.AllColumns);
                street.EditTools.BeginTransaction();
                if (newFeature.Id != null)
                {
                    newFeature = undoFeature;
                    street.EditTools.Update(newFeature);
                }
                else
                {
                    street.EditTools.Add(undoFeature);
                    RedoFeatures.Add(RedoFeatures.Count.ToString(), undoFeature);
                } 
                TransactionResult tr = street.EditTools.CommitTransaction();
                //if(tr.TransactionResultStatus == TransactionResultStatus.Success)
                street.Close();
                ShapeFileFeatureLayer.BuildIndexFile(street.ShapePathFileName);
                tempLabelLayer.Open();
                userLayer.Open();
                if (RedoFeatures.Count == 1)
                {
                    _RedoCanExecute = true;
                    btnRedo.IsEnabled = true;
                    btnRedo.Opacity = 1;
                    mnuRedo.IsEnabled = true;
                }
            }
            finally
            {
                baseMap.Lock.ExitWriteLock();
                wpfMap.Refresh();
                this.Cursor = oldCursor;
            }
        }
        private void UndoExecuted(object sender, ExecutedRoutedEventArgs e)
        {
            Undo();
        }

        private void mnuRedo_Click(object sender, RoutedEventArgs e)
        {
            Redo();
        }

        private void RedoCanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = _RedoCanExecute;
            e.Handled = true;
        }

        private void RedoExecuted(object sender, ExecutedRoutedEventArgs e)
        {
            Redo();
        }

        private void Redo()
        {
            Feature redoFeature = RedoFeatures[(RedoFeatures.Count-1).ToString()];
            LayerOverlay baseMap = (LayerOverlay)wpfMap.Overlays["basemap"];
            LayerOverlay undoLayer = (LayerOverlay)wpfMap.Overlays["undoOverlay"];
            Cursor oldCursor = this.Cursor;
            this.Cursor = Cursors.Wait;
            ShapeFileFeatureLayer roadLayer = (ShapeFileFeatureLayer)baseMap.Layers[redoFeature.ColumnValues["OriginalLayer"]];
            try
            {
                baseMap.Lock.EnterWriteLock();
                string sLabelLayer = GetLabelLayerName(roadLayer);
                roadLayer.Close();
                ShapeFileFeatureLayer tempLabelLayer = (ShapeFileFeatureLayer)baseMap.Layers[sLabelLayer];
                tempLabelLayer.Close();
                ShapeFileFeatureLayer street = new ShapeFileFeatureLayer(roadLayer.ShapePathFileName, ShapeFileReadWriteMode.ReadWrite);
                InMemoryFeatureLayer undo = (InMemoryFeatureLayer)undoLayer.Layers["undo"];
                Feature undoFeature = new Feature(redoFeature.GetWellKnownText(), redoFeature.Id, redoFeature.ColumnValues);
                undoLayer.Lock.EnterWriteLock();
                undo.Open();
                undo.Columns.Add(new FeatureSourceColumn("OriginalLayer"));
                undoFeature.ColumnValues["OriginalLayer"] = roadLayer.Name;
                undo.InternalFeatures.Add(undo.InternalFeatures.Count.ToString(), undoFeature);
                undo.Close();
                mnuUndo.IsEnabled = true;
                btnUndo.IsEnabled = true;
                _UndoCanExecute = true;
                btnUndo.Opacity = 1;

                if (!street.IsOpen)
                    street.Open();
                Collection<Feature> allFeatures = street.QueryTools.GetAllFeatures(ReturningColumnsType.NoColumns);
                Feature deleteFeature = allFeatures[allFeatures.Count - 1];
                street.EditTools.BeginTransaction();
                street.EditTools.Delete(deleteFeature.Id);
                street.EditTools.CommitTransaction();
                street.Close();
                ShapeFileFeatureLayer.BuildIndexFile(roadLayer.ShapePathFileName);
                wpfMap.TrackOverlay.TrackShapeLayer.InternalFeatures.Clear();
                wpfMap.EditOverlay.EditShapesLayer.InternalFeatures.Clear();
                wpfMap.EditOverlay.EditShapesLayer.BuildIndex();
                wpfMap.TrackOverlay.TrackShapeLayer.BuildIndex();
                tempLabelLayer.Open();
                roadLayer.Open();
            }
            finally
            {
                baseMap.Lock.ExitWriteLock();
                wpfMap.Refresh();
                RedoFeatures.Remove((RedoFeatures.Count - 1).ToString());
                if (RedoFeatures.Count == 0)
                {
                    mnuRedo.IsEnabled = false;
                    btnRedo.IsEnabled = false;
                    _RedoCanExecute = false;
                    btnRedo.Opacity = .25;
                }
                this.Cursor = oldCursor;
            }

        } 