Exemple #1
0
        protected IEventComponent ShowFeatureEditorByGuid(string guid)
        {
            bool exist = false;

            foreach (DockContent item in DockPanel.Contents)
            {
                if (item.GetType() == typeof(FeatureEditor))
                {
                    FeatureEditor editor = (FeatureEditor)item;
                    if (editor.Feature.Guid == guid)
                    {
                        editor.Show();
                        exist = true;
                    }
                }
            }

            if (!exist)
            {
                FeatureWrapper feat = PK.Wrapper.FindFeature(guid);
                if (feat != null)
                {
                    FE = new FeatureEditor();
                    FE.OpenContainingFolderEvent += new EventHandler <Forms.BaseForms.PathEventArgs>(OpenContainingFolderEvent);
                    FE.SetFeat(feat);
                    FE.Show(DockPanel, DockState.Document);
                    return(FE);
                }
            }
            return(null);
        }
Exemple #2
0
        private IFeature AddNewFeatureFromGeometryDelegate(IFeatureProvider featureProvider, IGeometry geometry)
        {
            if (FeatureEditor != null)
            {
                return(FeatureEditor.AddNewFeatureByGeometry(this, geometry));
            }

            throw new NotImplementedException();
        }
        public void CanDeleteAndMoveDoesNotCrashWithEmptyLayer()
        {
            var editor = new FeatureEditor(null, null, null, null, null)
            {
            };

            Assert.IsFalse(editor.AllowDeletion());
            Assert.IsFalse(editor.AllowMove());
        }
        /// <summary>
        /// Initializes a new layer
        /// </summary>
        /// <param name="layername">Name of layer</param>
        public VectorLayer(string layername)
        {
            SimplifyGeometryDuringRendering  = true;
            SkipRenderingOfVerySmallFeatures = true;

            name = layername;
            // smoothingMode = SmoothingMode.AntiAlias;
            smoothingMode = SmoothingMode.HighSpeed;
            FeatureEditor = new FeatureEditor();
        }
        public DiscreteGridPointCoverageLayer()
        {
            showLines = true;

            Name    = "Grid Points";
            Visible = true;

            pen = Pens.LightGreen;

            FeatureEditor = new FeatureEditor(); // default feature editor
        }
        /// <summary>
        /// Creates a clone of the vectorlayer given as parameter to the constructor
        /// </summary>
        /// <param name="layer"></param>
        public VectorLayer(VectorLayer layer)
        {
            if (layer != null)
            {
                if (layer.Style != null)
                {
                    style        = (VectorStyle)layer.Style.Clone();
                    isStyleDirty = true;
                }

                name = layer.Name;
            }

            smoothingMode = SmoothingMode.HighSpeed;
            FeatureEditor = new FeatureEditor();
            SimplifyGeometryDuringRendering  = layer.SimplifyGeometryDuringRendering;
            SkipRenderingOfVerySmallFeatures = layer.SkipRenderingOfVerySmallFeatures;
            CoordinateSystem         = layer.CoordinateSystem;
            CoordinateTransformation = layer.CoordinateTransformation;
        }
        /// <summary>
        /// initialize a Gdal based raster layer
        /// </summary>
        /// <param name="name">Name of layer</param>
        /// <param name="path">location of image</param>
        public GdalRasterLayer(string name, string path)
        {
            base.Name = name;

            CustomRenderers.Clear();
            CustomRenderers.Add(new GdalRenderer(this)); // add optimized custom gdal renderer

            if (path == null)
            {
                return;
            }

            var rasterFeatureProvider = new GdalFeatureProvider();

            rasterFeatureProvider.Open(path);

            DataSource = rasterFeatureProvider;

            FeatureEditor = new FeatureEditor();
        }
 public RegularGridCoverageLayer()
 {
     FeatureEditor = new FeatureEditor();
 }