Exemplo n.º 1
0
        private void listView1_ItemChecked(object sender, ItemCheckedEventArgs e)
        {
            myListNode item = (myListNode)e.Item;

            if (e.Item.Checked)
            {
                item.layer.VisibleMask = gviViewportMask.gviViewAllNormalView;
            }
            else
            {
                item.layer.VisibleMask = gviViewportMask.gviViewNone;
            }
        }
Exemplo n.º 2
0
        private void listView1_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            if (this.listView1.SelectedItems.Count == 0)
            {
                return;
            }
            myListNode item = (myListNode)this.listView1.SelectedItems[0];

            item.Checked = true;
            IEnvelope env = (IEnvelope)layerEnvelopeMap[item.layer];

            if (env == null || (env.MaxX == 0.0 && env.MaxY == 0.0 && env.MaxZ == 0.0 &&
                                env.MinX == 0.0 && env.MinY == 0.0 && env.MinZ == 0.0))
            {
                return;
            }
            this.axRenderControl1.Camera.LookAt(env.Center, 1000, angle);
        }
Exemplo n.º 3
0
        private void listView1_MouseDown(object sender, MouseEventArgs e)
        {
            myListNode item = (myListNode)this.listView1.GetItemAt(e.X, e.Y);

            if (item == null)
            {
                return;
            }

            cbCOMProperties.Items.Clear();
            selectedLayer = item.layer;
            IGeometryRender render = selectedLayer.GetGeometryRender();

            if (render != null)
            {
                if (render.RenderType == gviRenderType.gviRenderSimple)
                {
                    IGeometrySymbol geoSymbol = (render as ISimpleGeometryRender).Symbol;
                    txtScript.Text = geoSymbol.Script;

                    switch (geoSymbol.SymbolType)
                    {
                    case gviGeometrySymbolType.gviGeoSymbolPoint:
                    {
                        cbCOMProperties.Items.Add("Size");
                        cbCOMProperties.Items.Add("FillColor");
                    }
                    break;

                    case gviGeometrySymbolType.gviGeoSymbolModelPoint:
                    {
                        cbCOMProperties.Items.Add("Color");
                    }
                    break;

                    case gviGeometrySymbolType.gviGeoSymbolImagePoint:
                    {
                        cbCOMProperties.Items.Add("Size");
                        cbCOMProperties.Items.Add("ImageName");
                    }
                    break;

                    case gviGeometrySymbolType.gviGeoSymbolCurve:
                    {
                        cbCOMProperties.Items.Add("Color");
                        cbCOMProperties.Items.Add("ImageName");
                        cbCOMProperties.Items.Add("RepeatLength");
                        cbCOMProperties.Items.Add("Width");
                    }
                    break;

                    case gviGeometrySymbolType.gviGeoSymbolSurface:
                    {
                        cbCOMProperties.Items.Add("Color");
                    }
                    break;

                    case gviGeometrySymbolType.gviGeoSymbol3DPolygon:
                    {
                        cbCOMProperties.Items.Add("Color");
                        cbCOMProperties.Items.Add("Height");
                    }
                    break;
                    }
                }
            }
            else
            {
                switch (item.type)
                {
                case LayerType.ModelPoint:
                {
                    cbCOMProperties.Items.Add("Color");
                }
                break;

                case LayerType.Polyline:
                {
                    cbCOMProperties.Items.Add("Color");
                    cbCOMProperties.Items.Add("ImageName");
                    cbCOMProperties.Items.Add("RepeatLength");
                    cbCOMProperties.Items.Add("Width");
                }
                break;

                case LayerType.Point:
                {
                    cbCOMProperties.Items.Add("Size");
                    cbCOMProperties.Items.Add("FillColor");
                    cbCOMProperties.Items.Add("ImageName");
                }
                break;

                case LayerType.Polygon:
                {
                    cbCOMProperties.Items.Add("Color");
                    cbCOMProperties.Items.Add("Height");
                }
                break;
                }
            }

            cbFields.Items.Clear();
            IFeatureClass fc = null;

            try
            {
                foreach (System.Guid guid in fcGuidMap.Keys)
                {
                    if (guid.Equals(selectedLayer.FeatureClassId))
                    {
                        fc = fcGuidMap[guid] as IFeatureClass;
                    }
                }

                IFieldInfoCollection fields = fc.GetFields();
                for (int i = 0; i < fields.Count; i++)
                {
                    IFieldInfo field = fields.Get(i);
                    if (field.FieldType == gviFieldType.gviFieldGeometry || field.FieldType == gviFieldType.gviFieldBlob)
                    {
                        continue;
                    }
                    cbFields.Items.Add(field.Name);
                }
            }
            catch (System.Exception ex)
            {
            }

            type = item.type;
        }
Exemplo n.º 4
0
        // 公共方法
        void FeatureLayerVisualize(IConnectionInfo ci, bool needfly, string sourceName,
                                   ITextRender textRender, IGeometryRender geoRender, LayerType type)
        {
            try
            {
                IDataSourceFactory dsFactory = new DataSourceFactory();
                IDataSource        ds        = dsFactory.OpenDataSource(ci);
                string[]           setnames  = (string[])ds.GetFeatureDatasetNames();
                if (setnames.Length == 0)
                {
                    return;
                }
                IFeatureDataSet dataset = ds.OpenFeatureDataset(setnames[0]);
                string[]        fcnames = (string[])dataset.GetNamesByType(gviDataSetType.gviDataSetFeatureClassTable);
                if (fcnames.Length == 0)
                {
                    return;
                }
                fcGeoMap = new Hashtable(fcnames.Length);
                foreach (string name in fcnames)
                {
                    IFeatureClass fc = dataset.OpenFeatureClass(name);
                    fcGuidMap.Add(fc.Guid, fc);
                    // 找到空间列字段
                    List <string>        geoNames   = new List <string>();
                    IFieldInfoCollection fieldinfos = fc.GetFields();
                    for (int i = 0; i < fieldinfos.Count; i++)
                    {
                        IFieldInfo fieldinfo = fieldinfos.Get(i);
                        if (null == fieldinfo)
                        {
                            continue;
                        }
                        IGeometryDef geometryDef = fieldinfo.GeometryDef;
                        if (null == geometryDef)
                        {
                            continue;
                        }
                        geoNames.Add(fieldinfo.Name);
                    }
                    fcGeoMap.Add(fc, geoNames);
                }
            }
            catch (COMException ex)
            {
                System.Diagnostics.Trace.WriteLine(ex.Message);
                return;
            }

            // CreateFeautureLayer
            bool hasfly = !needfly;

            foreach (IFeatureClass fc in fcGeoMap.Keys)
            {
                List <string> geoNames = (List <string>)fcGeoMap[fc];
                foreach (string geoName in geoNames)
                {
                    if (!geoName.Equals("Geometry"))
                    {
                        continue;
                    }

                    IFeatureLayer featureLayer = this.axRenderControl1.ObjectManager.CreateFeatureLayer(
                        fc, geoName, textRender, geoRender, rootId);

                    // 添加节点到界面控件上
                    myListNode item = new myListNode(string.Format("{0}_{1}_{2}", sourceName, fc.Name, featureLayer.MaxVisibleDistance.ToString()), featureLayer, type);
                    item.Checked = true;
                    listView1.Items.Add(item);

                    IFieldInfoCollection fieldinfos  = fc.GetFields();
                    IFieldInfo           fieldinfo   = fieldinfos.Get(fieldinfos.IndexOf(geoName));
                    IGeometryDef         geometryDef = fieldinfo.GeometryDef;
                    IEnvelope            env         = geometryDef.Envelope;
                    layerEnvelopeMap.Add(featureLayer, env);
                    if (env == null || (env.MaxX == 0.0 && env.MaxY == 0.0 && env.MaxZ == 0.0 &&
                                        env.MinX == 0.0 && env.MinY == 0.0 && env.MinZ == 0.0))
                    {
                        continue;
                    }

                    // 相机飞入
                    if (!hasfly)
                    {
                        angle.Set(0, -20, 0);
                        this.axRenderControl1.Camera.LookAt(env.Center, 1000, angle);
                    }
                    hasfly = true;
                }
            }
        }