Example #1
0
 public bool ConditionsMet(LayerModel layer, IDataModel dataModel)
 {
     lock (layer.Properties.Conditions)
     {
         return layer.Properties.Conditions.All(cm => cm.ConditionMet(dataModel));
     }
 }
Example #2
0
        public void SetupProperties(LayerModel layerModel)
        {
            if (layerModel.Properties is KeyboardPropertiesModel)
                return;

            layerModel.Properties = new KeyboardPropertiesModel(layerModel.Properties);
        }
Example #3
0
        public void Draw(LayerModel layer, DrawingContext c)
        {
            var props = (KeyboardPropertiesModel) layer.Properties;
            if (string.IsNullOrEmpty(props.GifFile))
                return;
            if (!File.Exists(props.GifFile))
                return;

            // Only reconstruct GifImage if the underlying source has changed
            if (layer.GifImage == null)
                layer.GifImage = new GifImage(props.GifFile);
            if (layer.GifImage.Source != props.GifFile)
                layer.GifImage = new GifImage(props.GifFile);

            var rect = new Rect(layer.AppliedProperties.X*4,
                layer.AppliedProperties.Y*4,
                layer.AppliedProperties.Width*4,
                layer.AppliedProperties.Height*4);

            lock (layer.GifImage)
            {
                var draw = layer.GifImage.GetNextFrame();
                c.DrawImage(ImageUtilities.BitmapToBitmapImage(new Bitmap(draw)), rect);
            }
        }
Example #4
0
        public void Draw(LayerModel layer, DrawingContext c)
        {
            // If an animation is present, let it handle the drawing
            if (layer.LayerAnimation != null && !(layer.LayerAnimation is NoneAnimation))
            {
                layer.LayerAnimation.Draw(layer.Properties, layer.AppliedProperties, c);
                return;
            }

            // Otherwise draw the rectangle with its layer.AppliedProperties dimensions and brush
            var rect = layer.Properties.Contain
                ? new Rect(layer.AppliedProperties.X*4,
                    layer.AppliedProperties.Y*4,
                    layer.AppliedProperties.Width*4,
                    layer.AppliedProperties.Height*4)
                : new Rect(layer.Properties.X*4,
                    layer.Properties.Y*4,
                    layer.Properties.Width*4,
                    layer.Properties.Height*4);

            var clip = new Rect(layer.AppliedProperties.X*4, layer.AppliedProperties.Y*4,
                layer.AppliedProperties.Width*4, layer.AppliedProperties.Height*4);


            c.PushClip(new RectangleGeometry(clip));
            c.DrawRectangle(layer.AppliedProperties.Brush, null, rect);
            c.Pop();
        }
Example #5
0
        public void SetupProperties(LayerModel layerModel)
        {
            if (layerModel.Properties is SimplePropertiesModel)
                return;

            layerModel.Properties = new SimplePropertiesModel(layerModel.Properties);
        }
Example #6
0
        public void Draw(LayerModel layer, DrawingContext c)
        {
            lock (SpectrumData)
            {
                foreach (var audioLayer in _audioLayers)
                {
                    // This is cheating but it ensures that the brush is drawn across the entire main-layer
                    var oldWidth = audioLayer.Properties.Width;
                    var oldHeight = audioLayer.Properties.Height;
                    var oldX = audioLayer.Properties.X;
                    var oldY = audioLayer.Properties.Y;

                    audioLayer.Properties.Width = layer.Properties.Width;
                    audioLayer.Properties.Height = layer.Properties.Height;
                    audioLayer.Properties.X = layer.Properties.X;
                    audioLayer.Properties.Y = layer.Properties.Y;
                    audioLayer.LayerType.Draw(audioLayer, c);

                    audioLayer.Properties.Width = oldWidth;
                    audioLayer.Properties.Height = oldHeight;
                    audioLayer.Properties.X = oldX;
                    audioLayer.Properties.Y = oldY;
                }
            }
        }
Example #7
0
 public void Draw(LayerModel layer, DrawingContext c)
 {
     lock (_keyPressLayers)
     {
         foreach (var keyPressLayer in _keyPressLayers)
             keyPressLayer.LayerType.Draw(keyPressLayer, c);
     }
 }
        public override bool MustStop(LayerModel layer)
        {
            if (ExpirationType != ExpirationType.Animation)
                return base.MustStop(layer);

            if (layer.LayerType is KeyboardGifType)
                return layer.GifImage?.CurrentFrame >= layer.GifImage?.FrameCount - 1;
            return (layer.LayerAnimation == null) || layer.LayerAnimation.MustExpire(layer);
        }
Example #9
0
        public ImageSource DrawThumbnail(LayerModel layer)
        {
            var thumbnailRect = new Rect(0, 0, 18, 18);
            var visual = new DrawingVisual();
            using (var c = visual.RenderOpen())
                c.DrawImage(ImageUtilities.BitmapToBitmapImage(Resources.mousemat), thumbnailRect);

            var image = new DrawingImage(visual.Drawing);
            return image;
        }
        public override void TriggerEvent(LayerModel layer)
        {
            if (CanTrigger && DelayExpired())
            {
                if (layer.GifImage != null)
                    layer.GifImage.CurrentFrame = 0;
            }

            base.TriggerEvent(layer);
        }
Example #11
0
        public void Update(LayerModel layerModel, bool updateAnimations)
        {
            var progress = layerModel.Properties.AnimationProgress;
            if (MustExpire(layerModel))
                progress = 0;
            progress = progress + layerModel.Properties.AnimationSpeed*2;

            // If not previewing, store the animation progress in the actual model for the next frame
            if (updateAnimations)
                layerModel.Properties.AnimationProgress = progress;
        }
Example #12
0
        public void Update(LayerModel layerModel, IDataModel dataModel, bool isPreview = false)
        {
            layerModel.AppliedProperties = new KeyboardPropertiesModel(layerModel.Properties);
            if (isPreview || dataModel == null)
                return;

            // If not previewing, apply dynamic properties according to datamodel
            var keyboardProps = (KeyboardPropertiesModel) layerModel.AppliedProperties;
            foreach (var dynamicProperty in keyboardProps.DynamicProperties)
                dynamicProperty.ApplyProperty(dataModel, layerModel.AppliedProperties);
        }
Example #13
0
        /// <summary>
        ///     Gets whether the event should stop
        /// </summary>
        /// <param name="layer"></param>
        /// <returns></returns>
        public virtual bool MustStop(LayerModel layer)
        {
            if (ExpirationType == ExpirationType.Time)
            {
                if (EventTriggerTime == DateTime.MinValue)
                    return false;
                return DateTime.Now - EventTriggerTime > Length;
            }
            if (ExpirationType == ExpirationType.Animation)
                return (layer.LayerAnimation == null) || layer.LayerAnimation.MustExpire(layer);

            return true;
        }
Example #14
0
        public bool ConditionsMet(LayerModel layer, IDataModel dataModel)
        {
            lock (layer.Properties.Conditions)
            {
                var conditionsMet = layer.Properties.Conditions.All(cm => cm.ConditionMet(dataModel));
                layer.EventProperties.Update(layer, conditionsMet);

                if (conditionsMet && layer.EventProperties.CanTrigger)
                    layer.EventProperties.TriggerEvent(layer);

                return layer.EventProperties.MustDraw;
            }
        }
Example #15
0
        public void SetupProperties(LayerModel layerModel)
        {
            if (layerModel.Properties is SimplePropertiesModel)
                return;

            layerModel.Properties = new SimplePropertiesModel(layerModel.Properties);

            // Remove height and width dynamic properties since they are not applicable
            layerModel.Properties.DynamicProperties.Remove(
                layerModel.Properties.DynamicProperties.FirstOrDefault(d => d.LayerProperty == "Height"));
            layerModel.Properties.DynamicProperties.Remove(
                layerModel.Properties.DynamicProperties.FirstOrDefault(d => d.LayerProperty == "Width"));
        }
Example #16
0
        // Called every frame, if parent conditions met.
        public void Update(LayerModel layerModel, bool conditionsMet)
        {
            if (EventCanTriggerTime > DateTime.MinValue && (DateTime.Now - EventCanTriggerTime > TriggerDelay))
            {
                CanTrigger = true;
                TriggerEvent(layerModel);
                return;
            }

            if (MustDraw && MustStop(layerModel))
                MustDraw = false;

            if (!conditionsMet)
                CanTrigger = true;
        }
Example #17
0
        public ImageSource DrawThumbnail(LayerModel layer)
        {
            var thumbnailRect = new Rect(0, 0, 18, 18);
            var visual = new DrawingVisual();
            using (var c = visual.RenderOpen())
            {
                if (layer.Properties.Brush != null)
                {
                    c.DrawRectangle(layer.Properties.Brush,
                        new Pen(new SolidColorBrush(Colors.White), 1),
                        thumbnailRect);
                }
            }

            var image = new DrawingImage(visual.Drawing);
            return image;
        }
Example #18
0
        public void Update(LayerModel layerModel, bool updateAnimations)
        {
            // TODO: Generic implementation
            // Reset animation progress if layer wasn't drawn for 100ms
            if ((new TimeSpan(0, 0, 0, 0, 100) < DateTime.Now - layerModel.LastRender) && updateAnimations)
                layerModel.Properties.AnimationProgress = 0;

            var progress = layerModel.Properties.AnimationProgress;

            if (MustExpire(layerModel))
                progress = 0;
            progress = progress + layerModel.Properties.AnimationSpeed/2;

            // If not previewing, store the animation progress in the actual model for the next frame
            if (updateAnimations)
                layerModel.Properties.AnimationProgress = progress;
        }
Example #19
0
        public void Update(LayerModel layerModel, IDataModel dataModel, bool isPreview = false)
        {
            // Generic layers are always drawn 10*10 (which is 40*40 when scaled up)
            layerModel.Properties.Width = 10;
            layerModel.Properties.Height = 10;
            layerModel.Properties.X = 0;
            layerModel.Properties.Y = 0;
            layerModel.Properties.Contain = true;

            layerModel.AppliedProperties = new SimplePropertiesModel(layerModel.Properties);

            if (isPreview || dataModel == null)
                return;

            // If not previewing, apply dynamic properties according to datamodel
            var props = (SimplePropertiesModel) layerModel.AppliedProperties;
            foreach (var dynamicProperty in props.DynamicProperties)
                dynamicProperty.ApplyProperty(dataModel, layerModel.AppliedProperties);
        }
Example #20
0
        public void SetupProperties(LayerModel layerModel)
        {
            if (layerModel.Properties is KeyPressPropertiesModel)
                return;

            // Setup brush as a radial
            layerModel.Properties = new KeyPressPropertiesModel(layerModel.Properties)
            {
                Brush = new RadialGradientBrush(new GradientStopCollection
                {
                    new GradientStop(Colors.Red, 0.85),
                    new GradientStop(Color.FromArgb(0, 255, 0, 0), 0.95),
                    new GradientStop(Colors.Red, 0.55),
                    new GradientStop(Color.FromArgb(0, 255, 0, 0), 0.45)
                })
            };
            // Setup defaults
            ((KeyPressPropertiesModel) layerModel.Properties).AnimationSpeed = 2.5;
            ((KeyPressPropertiesModel) layerModel.Properties).Scale = 8;
        }
Example #21
0
        /// <summary>
        ///     Resets the event's properties and triggers it
        /// </summary>
        public virtual void TriggerEvent(LayerModel layer)
        {
            if (!CanTrigger)
                return;

            if (TriggerDelay > TimeSpan.Zero)
            {
                if (EventCanTriggerTime == DateTime.MinValue)
                    EventCanTriggerTime = DateTime.Now;

                if (DateTime.Now - EventCanTriggerTime < TriggerDelay)
                    return;

                EventCanTriggerTime = DateTime.MinValue;
            }

            CanTrigger = false;
            MustDraw = true;
            EventTriggerTime = DateTime.Now;
            layer.Properties.AnimationProgress = 0.0;
        }
Example #22
0
        public void Update(LayerModel layerModel, IDataModel dataModel, bool isPreview = false)
        {
            // Key press is always as large as the entire keyboard it is drawn for
            layerModel.Properties.Width = _mainManager.DeviceManager.ActiveKeyboard.Width;
            layerModel.Properties.Height = _mainManager.DeviceManager.ActiveKeyboard.Height;
            layerModel.Properties.X = 0;
            layerModel.Properties.Y = 0;
            layerModel.Properties.Contain = true;

            _layerModel = layerModel;

            if (isPreview)
                return;

            lock (_keyPressLayers)
            {
                // Remove expired key presses
                _keyPressLayers = _keyPressLayers.Where(k => !k.LayerAnimation.MustExpire(k)).ToList();
                // Update the ones that are still active
                foreach (var keyPressLayer in _keyPressLayers)
                    keyPressLayer.Update(null, false, true);
            }
        }
Example #23
0
        public LayerEditorViewModel(LayerModel layer, IDataModel dataModel, IEnumerable<ILayerType> types,
            List<ILayerAnimation> layerAnimations)
        {
            Layer = layer;
            ProposedLayer = Clone(layer);
            ProposedLayer.Children.Clear();
            DataModel = DataModel;
            LayerTypes = new BindableCollection<ILayerType>(types);
            LayerAnimations = layerAnimations;

            DataModelProps = new BindableCollection<PropertyCollection>(GenerateTypeMap(dataModel));

            if (Layer.Properties == null)
                Layer.SetupProperties();

            // Setup existing conditions           
            var conditions = layer.Properties.Conditions.Select(c => new LayerConditionViewModel(this, c));
            LayerConditionVms = new BindableCollection<LayerConditionViewModel>(conditions);

            PropertyChanged += PropertiesViewModelHandler;

            // Setup existiing properties
            PreSelect();
        }
Example #24
0
 public void RemoveLayer(LayerModel layer)
 {
     ProfileEditorModel.RemoveLayer(layer, SelectedProfile);
     UpdateLayerList(null);
 }
Example #25
0
 public bool MustExpire(LayerModel layer)
 {
     return layer.Properties.AnimationProgress + layer.Properties.AnimationSpeed*2 >= layer.Properties.Height*4;
 }
        public void Apply(LayerModel layerModel)
        {
            var proposedProperties = _layerEditorViewModel.ProposedLayer.Properties;
            proposedProperties.DynamicProperties = proposedProperties
                .DynamicProperties
                .Where(p => p.LayerProperty != _property).ToList();

            if (!Proposed.GameProperty.IsNullOrEmpty())
                proposedProperties.DynamicProperties.Add(Proposed);
        }
Example #27
0
 public RenameCommand(LayerModel layer, string oldName, string newName)
 {
     _layer   = layer;
     _oldName = oldName;
     _newName = newName;
 }
 private void ViewModel_AppearChanged(LayerModel arg1, bool arg2)
 {
 }
 private void ViewModel_LockChanged(LayerModel arg1, bool arg2)
 {
 }
Example #30
0
 public void Update(LayerModel layerModel, IDataModel dataModel, bool isPreview = false)
 {
 }
Example #31
0
 public bool MustExpire(LayerModel layer) => layer.AnimationProgress <= 0;
Example #32
0
        internal void AutoOpenPointPlanFile(string file, string cityName, DerivedTypeEnum derivedType, List <string> failedFiles)
        {
            Document     acDoc   = Application.DocumentManager.Open(file, false);
            Database     acCurDb = acDoc.Database;
            Editor       ed      = acDoc.Editor;
            DocumentLock docLock = acDoc.LockDocument();

            try
            {
                ModelBase mb = new ModelBase();

                //if (derivedType is DerivedTypeEnum.PointsPlan)
                //{
                //    mb = new PointsPlanModel();
                //}
                //if (derivedType is DerivedTypeEnum.UnitPlan)
                //{
                //    mb = new UnitPlanModel();
                //}
                //if (derivedType is DerivedTypeEnum.None)
                //{
                //    mb = new ModelBase();
                //}

                // 判断是否读取布局空间(papermodel)
                MainForm.isOnlyModel = mb.IsOnlyModel;
                //MainForm.isOnlyModel = false;
                mb.DocName   = Path.GetFileNameWithoutExtension(file);
                mb.projectId = cityName;

                // 获取图例
                ModelBaseMethod <ModelBase> mbm = new ModelBaseMethod <ModelBase>();
                mbm.GetAllLengedGemo(mb);
                mbm.GetExportLayers(mb);

                //// 获取特殊图层
                //LayerSpecialCommand<ModelBase> layerSpecial = new LayerSpecialCommand<ModelBase>();
                //layerSpecial.AddSpecialLayerModel(mb);

                //mb.LayerList = new List<string>{"道路中线"};
                if (mb.LayerList != null)
                {
                    foreach (string layer in mb.LayerList)
                    {
                        ModelBaseMethod <ModelBase> modelMe = new ModelBaseMethod <ModelBase>();
                        LayerModel lyModel = modelMe.GetAllLayerGemo(mb, layer);

                        if (mb.allLines == null)
                        {
                            mb.allLines = new List <LayerModel>();
                        }
                        mb.allLines.Add(lyModel);
                    }
                    //if (derivedType is DerivedTypeEnum.PointsPlan)
                    //{
                    //    PostModel.AutoPostModelBase(mb as ModelBase, failedFiles);
                    //}
                    //if (derivedType is DerivedTypeEnum.UnitPlan)
                    //{
                    //    PostModel.AutoPostModelBase(mb as ModelBase, failedFiles);
                    //}
                    //if (derivedType is DerivedTypeEnum.None)
                    //{
                    //    PostModel.AutoPostModelBase(mb as ModelBase, failedFiles);
                    //}
                    PostModel.AutoPostModelBase(mb as ModelBase, failedFiles);
                }
                docLock.Dispose();
                acCurDb.Dispose();
                acDoc.CloseAndDiscard();
                acDoc.Dispose();
                GC.Collect();
                System.Windows.Forms.Application.DoEvents();
            }
            catch (Exception e)
            {
                //string logFileName = @"C: \Users\Public\Documents\" + DateTime.Now.ToString("yyyy-MM-dd") + ".log";
                //using (TextWriter logFile = TextWriter.Synchronized(File.AppendText(logFileName)))
                //{
                //    logFile.WriteLine(DateTime.Now);
                //    logFile.WriteLine(e.Message);
                //    logFile.WriteLine("\r\n");
                //    logFile.Flush();
                //    logFile.Close();
                //}
                System.Windows.Forms.MessageBox.Show(e.Message);
                docLock.Dispose();
                GC.Collect();
            }
            // 发送类型

            // 发送图层数据
        }
Example #33
0
        public override MapModel <LayerModel <TileModel <SpriteInfo> > > Load(IDataManagerArguments arguments)
        {
            MapModel <LayerModel <TileModel <SpriteInfo> > > map = null;

            var mapArguments = (arguments as ContentFileDataLoaderArguments);

            using (var fileStream = new FileStream(this.RootPath + mapArguments.FileName + EngineConstants.MAP_FILE_EXT, FileMode.Open))
            {
                using (var bR = new BinaryReader(fileStream))
                {
                    // Load the tileset information
                    int           tilesetCount = bR.ReadInt32();
                    List <string> tilesetPaths = new List <string>();
                    for (int i = 0; i < tilesetCount; i++)
                    {
                        // We can throw this information away as it is used only in the editor suite.
                        string tilesetPath = bR.ReadString();
                        tilesetPaths.Add(tilesetPath);
                    }

                    string name       = bR.ReadString();
                    var    dimensions = new Vector(bR.ReadInt32(), bR.ReadInt32());

                    map = new MapModel <LayerModel <TileModel <SpriteInfo> > >(dimensions, name)
                    {
                        Dark = bR.ReadBoolean()
                    };
                    map.TilesetPaths.AddRange(tilesetPaths);

                    map.Bounds = new Rect(0, 0, (int)map.Dimensions.X, (int)map.Dimensions.Y);

                    int layerCount = bR.ReadInt32();
                    for (int i = 0; i < layerCount; i++)
                    {
                        string layerName = bR.ReadString();
                        int    lIndex    = bR.ReadInt32();

                        var layer = new LayerModel <TileModel <SpriteInfo> >(map.Dimensions, layerName, lIndex);

                        for (int x = 0; x < layer.Tiles.GetLength(0); x++)
                        {
                            for (int y = 0; y < layer.Tiles.GetLength(1); y++)
                            {
                                if (bR.ReadBoolean())
                                {
                                    layer.Tiles[x, y] = new TileModel <SpriteInfo>(new Vector(x * EngineConstants.TILE_SIZE, y * EngineConstants.TILE_SIZE));

                                    if (bR.ReadBoolean()) // Is there a valid attribute saved for this tile?
                                    {
                                        int    attributeDataLength = bR.ReadInt32();
                                        byte[] attributeData       = bR.ReadBytes(attributeDataLength);
                                        layer.Tiles[x, y].Attribute = TileAttribute.Deserialize(attributeData);
                                    }

                                    if (bR.ReadBoolean())
                                    {
                                        layer.Tiles[x, y].Animated    = bR.ReadBoolean();
                                        layer.Tiles[x, y].LightSource = bR.ReadBoolean();

                                        string spriteName = bR.ReadString();
                                        float  zIndex     = bR.ReadSingle(); // We can throw this away

                                        layer.Tiles[x, y].Sprite = new SpriteInfo(spriteName)
                                        {
                                            Transform =
                                            {
                                                Position   = new Vector(x * EngineConstants.TILE_SIZE, y * EngineConstants.TILE_SIZE),
                                                Color      = new Color(bR.ReadByte(),                  bR.ReadByte(),                 bR.ReadByte(),   bR.ReadByte()),
                                                Rect       = new Rect(bR.ReadInt32(),                  bR.ReadInt32(),                bR.ReadInt32(),  bR.ReadInt32()),
                                                LayerDepth = zIndex
                                            }
                                        };

                                        layer.Tiles[x, y].FrameCount = bR.ReadInt32();
                                    }
                                }
                            }
                        }

                        //int mapObjectCount = bR.ReadInt32();
                        //for (int mI = 0; mI < mapObjectCount; mI++)
                        //{
                        //    var mapObject = new MapObjectDescriptor()
                        //    {
                        //        Position = new Vector(bR.ReadSingle(), bR.ReadSingle())
                        //    };

                        //    if (bR.ReadBoolean())
                        //    {
                        //        string texturePath = bR.ReadString();
                        //        mapObject.Sprite = new SpriteInfo(texturePath)
                        //        {
                        //            Transform =
                        //            {
                        //                Rect = new Rect(bR.ReadInt32(), bR.ReadInt32(), bR.ReadInt32(), bR.ReadInt32())
                        //            }
                        //        };
                        //    }

                        //    mapObject.Animated = bR.ReadBoolean();

                        //    mapObject.FrameTime = bR.ReadInt32();

                        //    string scriptPath = bR.ReadString();

                        //    var lightSource = bR.ReadBoolean();
                        //    var lightRadius = bR.ReadSingle();
                        //    var lightColor = new Color(bR.ReadByte(), bR.ReadByte(), bR.ReadByte(), bR.ReadByte());

                        //    if (lightSource)
                        //    {
                        //        mapObject.LightInformation = new LightInformation()
                        //        {
                        //            Radius = lightRadius,
                        //            Color = lightColor
                        //        };
                        //    }

                        //}

                        map.AddLayer(layerName, layer);
                    }
                }
            }

            return(map);
        }
Example #34
0
 public bool MustExpire(LayerModel layer)
 {
     return(layer.Properties.AnimationProgress + layer.Properties.AnimationSpeed * 2 >= layer.Properties.Width * 4);
 }
Example #35
0
        public void GetAllDimensioning(T model, string layerName)
        {
            if (model != null)
            {
                LayerModel lm  = new LayerModel();
                Document   doc = Application.DocumentManager.MdiActiveDocument;
                Database   db  = doc.Database;

                ObjectIdCollection ids = new ObjectIdCollection();
                lm.Name = layerName;

                PromptSelectionResult ProSset = null;
                TypedValue[]          filList = new TypedValue[1] {
                    new TypedValue((int)DxfCode.LayerName, layerName)
                };
                SelectionFilter sfilter = new SelectionFilter(filList);

                ProSset = doc.Editor.SelectAll(sfilter);
                if (ProSset.Status == PromptStatus.OK)
                {
                    // lyModel.pointFs = new Dictionary<int, List<object>>();
                    using (Transaction tran = db.TransactionManager.StartTransaction())
                    {
                        SelectionSet sst  = ProSset.Value;
                        ObjectId[]   oids = sst.GetObjectIds();

                        LayerTable lt = (LayerTable)db.LayerTableId.GetObject(OpenMode.ForRead);
                        foreach (ObjectId layerId in lt)
                        {
                            LayerTableRecord ltr = (LayerTableRecord)tran.GetObject(layerId, OpenMode.ForRead);
                            if (ltr.Name == layerName)
                            {
                                lm.Color = System.Drawing.ColorTranslator.ToHtml(ltr.Color.ColorValue);
                            }
                        }

                        foreach (ObjectId lengGemo in oids)
                        {
                            DBObject            ob             = tran.GetObject(lengGemo, OpenMode.ForRead);
                            PointsPlanItemModel pointsPlanItem = new PointsPlanItemModel();

                            Entity             ety  = ob as Entity;
                            DBObjectCollection objs = new DBObjectCollection();
                            ety.Explode(objs);

                            foreach (DBObject obj in objs)
                            {
                                if (obj is DBText)
                                {
                                    pointsPlanItem.RoadWidth = (obj as DBText).TextString;
                                }
                                if (obj is MText)
                                {
                                    pointsPlanItem.RoadWidth = (obj as MText).Text;
                                }
                            }

                            //BlockInfoModel plModel = MethodCommand.AnalysisBlcokInfo(ob);
                            //pointsPlanItem.Geom = plModel;

                            if (lm.modelItemList == null)
                            {
                                lm.modelItemList = new List <object>();
                            }

                            lm.modelItemList.Add(pointsPlanItem);
                        }
                    }


                    if (model.allLines == null)
                    {
                        model.allLines = new List <LayerModel>();
                    }
                    model.allLines.Add(lm);
                }
            }
        }
Example #36
0
        private void ParsingLayers(XmlNodeList layerNodes)
        {
            foreach (XmlNode node in layerNodes)
            {
                XmlElement element   = (XmlElement)node;
                string     layerName = element.GetAttribute("name");
                string     eye       = element.GetAttribute("Eye");
                LayerModel layer     = new LayerModel(layerName);
                layer.Eye = bool.Parse(eye);

                layer.TriggerAction = element.GetAttribute("trigger");

                // parsing effects
                XmlNode effectsNode = element.SelectSingleNode("effects");
                foreach (XmlNode effectNode in effectsNode.ChildNodes)
                {
                    XmlElement element2 = (XmlElement)effectNode;
                    int        type     = Int32.Parse(element2.SelectSingleNode("type").InnerText);

                    List <ColorPointModel> colorPoints = new List <ColorPointModel>();
                    XmlNode colorPointListNode         = element2.SelectSingleNode("colorPointList");
                    foreach (XmlNode colorpoint in colorPointListNode.ChildNodes)
                    {
                        ColorPointModel cp       = new ColorPointModel();
                        XmlElement      element3 = (XmlElement)colorpoint;
                        cp.Color = new Color
                        {
                            A = Byte.Parse(element3.SelectSingleNode("a").InnerText),
                            R = Byte.Parse(element3.SelectSingleNode("r").InnerText),
                            G = Byte.Parse(element3.SelectSingleNode("g").InnerText),
                            B = Byte.Parse(element3.SelectSingleNode("b").InnerText),
                        };
                        cp.Offset = double.Parse(element3.SelectSingleNode("offset").InnerText);
                        colorPoints.Add(cp);
                    }

                    EffectInfoModel info = new EffectInfoModel(type)
                    {
                        InitColor = new Color
                        {
                            A = Byte.Parse(element2.SelectSingleNode("a").InnerText),
                            R = Byte.Parse(element2.SelectSingleNode("r").InnerText),
                            G = Byte.Parse(element2.SelectSingleNode("g").InnerText),
                            B = Byte.Parse(element2.SelectSingleNode("b").InnerText),
                        },
                        DoubleColor1 = new Color
                        {
                            A = Byte.Parse(element2.SelectSingleNode("d1a").InnerText),
                            R = Byte.Parse(element2.SelectSingleNode("d1r").InnerText),
                            G = Byte.Parse(element2.SelectSingleNode("d1g").InnerText),
                            B = Byte.Parse(element2.SelectSingleNode("d1b").InnerText),
                        },
                        DoubleColor2 = new Color
                        {
                            A = Byte.Parse(element2.SelectSingleNode("d2a").InnerText),
                            R = Byte.Parse(element2.SelectSingleNode("d2r").InnerText),
                            G = Byte.Parse(element2.SelectSingleNode("d2g").InnerText),
                            B = Byte.Parse(element2.SelectSingleNode("d2b").InnerText),
                        },
                        Type               = type,
                        Speed              = Int32.Parse(element2.SelectSingleNode("speed").InnerText),
                        Angle              = Int32.Parse(element2.SelectSingleNode("angle").InnerText),
                        RandomRangeMax     = Int32.Parse(element2.SelectSingleNode("randomRangeMax").InnerText),
                        RandomRangeMin     = Int32.Parse(element2.SelectSingleNode("randomRangeMin").InnerText),
                        ColorModeSelection = Int32.Parse(element2.SelectSingleNode("colormodeselection").InnerText),
                        High               = Int32.Parse(element2.SelectSingleNode("high").InnerText),
                        Low                   = Int32.Parse(element2.SelectSingleNode("low").InnerText),
                        PatternSelect         = Int32.Parse(element2.SelectSingleNode("patternSelect").InnerText),
                        CustomizedPattern     = new List <ColorPointModel>(colorPoints),
                        ColorSegmentation     = bool.Parse(element2.SelectSingleNode("colorSegmentation").InnerText),
                        RainbowSpecialEffects = bool.Parse(element2.SelectSingleNode("rainbowRotation").InnerText),
                        RainbowSpecialMode    = Int32.Parse(element2.SelectSingleNode("rotationMode").InnerText),
                    };

                    if (!IsTriggerEffect(type))
                    {
                        TimelineEffect eff = new TimelineEffect(type);
                        eff.StartTime    = Int32.Parse(element2.SelectSingleNode("start").InnerText);
                        eff.DurationTime = Int32.Parse(element2.SelectSingleNode("duration").InnerText);
                        eff.Info         = info;
                        layer.AddTimelineEffect(new EffectLineViewModel(eff));
                    }
                    else
                    {
                        TriggerEffect eff = new TriggerEffect(type);
                        eff.StartTime    = Int32.Parse(element2.SelectSingleNode("start").InnerText);
                        eff.DurationTime = Int32.Parse(element2.SelectSingleNode("duration").InnerText);
                        eff.Info         = info;
                        layer.AddTriggerEffect(eff);
                        layer.IsTriggering = true;
                    }
                }

                // parsing zones
                XmlNode devicesNode = element.SelectSingleNode("devices");
                foreach (XmlNode deviceNode in devicesNode.ChildNodes)
                {
                    Dictionary <int, int[]> zoneDictionary = new Dictionary <int, int[]>();
                    List <int> zones    = new List <int>();
                    XmlElement element2 = (XmlElement)deviceNode;
                    string     typeName = element2.GetAttribute("type");
                    int        type     = GetTypeByTypeName(typeName);

                    XmlNodeList indexNodes = element2.ChildNodes;
                    foreach (XmlNode index in indexNodes)
                    {
                        zones.Add(Int32.Parse(index.InnerText));
                    }

                    zoneDictionary.Add(type, zones.ToArray());
                    layer.AddDeviceZones(zoneDictionary);
                }

                LayerPage.AddLayer(layer);
            }
        }
Example #37
0
        public void Update(LayerModel layerModel, IDataModel dataModel, bool isPreview = false)
        {
            if ((_device == null) || isPreview)
                return;

            lock (SpectrumData)
            {
                UpdateLayers(layerModel);

                if (!SpectrumData.Any())
                    return;

                var settings = (AudioPropertiesModel) layerModel.Properties;
                if (settings.Direction == Direction.TopToBottom || settings.Direction == Direction.BottomToTop)
                    ApplyVertical(settings);
                else if (settings.Direction == Direction.LeftToRight || settings.Direction == Direction.RightToLeft)
                    ApplyHorizontal(settings);
            }
        }
Example #38
0
 public void Draw(LayerModel layer, DrawingContext c)
 {
 }
Example #39
0
        private void RunDemo()
        {
            // Add Top Horizon
            var topHorizonX = new IntervalReaderSettings
            {
                Interval    = _converterService.Convert(200, LengthUnits.Foot, LengthUnits.Meter),
                PointsCount = 16,
                StartPoint  = 0
            };
            var topHorizonY = new IntervalReaderSettings
            {
                Interval    = _converterService.Convert(200, LengthUnits.Foot, LengthUnits.Meter),
                PointsCount = 26,
                StartPoint  = 0
            };
            var topHorizonZ = new FileReaderSettings
            {
                FilePath = AppDomain.CurrentDomain.BaseDirectory + ConfigurationManager.AppSettings.Get("demoDepthsFile")
            };

            var topHorizon = new LayerModel
            {
                Name  = "Top Horizon",
                Color = new SolidColorBrush(Color.FromArgb(180, 33, 175, 17)),
                X     = _intervalReaderService.ReadPoints(topHorizonX),
                Y     = _intervalReaderService.ReadPoints(topHorizonY),
                Z     = _fileReaderService.ReadPoints(topHorizonZ).Select(p =>
                {
                    return(_converterService.Convert(p * -1, LengthUnits.Foot, LengthUnits.Meter));
                }).ToArray()
            };

            AddLayer(topHorizon, UpperLayers, nameof(UpperLayers));

            // Add Base Horizon
            var baseHorizon = new LayerModel
            {
                Name  = "Base Horizon",
                Color = new SolidColorBrush(Color.FromRgb(235, 179, 25)),
                X     = topHorizon.X,
                Y     = topHorizon.Y,
                Z     = topHorizon.Z.Select(p => p - 100).ToArray()
            };

            AddLayer(baseHorizon, LowerLayers, nameof(LowerLayers));

            // Add Fluid Body
            var fluidBody = new LayerModel
            {
                Name  = "Fluid Body",
                Color = new SolidColorBrush(Color.FromRgb(148, 192, 230)),
                X     = topHorizon.X,
                Y     = topHorizon.Y,
                Z     = _intervalReaderService.ReadPoints(new IntervalReaderSettings
                {
                    Interval    = 0,
                    PointsCount = topHorizon.Z.Length,
                    StartPoint  = -3000
                })
            };

            AddLayer(fluidBody, LowerLayers, nameof(LowerLayers));
        }
Example #40
0
 public void Draw(LayerModel layerModel, DrawingContext c)
 {
 }
        private void ProcessLayers(ApplicationValidationResultIQ validationResult, DictionaryQuery <CompositeModel, PublicCompositeTypeGenerationResult> loadingResults, DictionaryProxy <LayerModel, LayerImpl> layers, LayerModel layerModel)
        {
            if (!layers.CQ.ContainsKey(layerModel))
            {
                layers.Add(layerModel, new LayerImpl(validationResult, loadingResults, this, layerModel));
            }

            foreach (LayerModel used in layerModel.UsedLayerModels)
            {
                this.ProcessLayers(validationResult, loadingResults, layers, used);
            }
        }
 private void ViewModel_RectangleSelecting(LayerModel obj)
 {
 }
Example #43
0
 public bool MustExpire(LayerModel layer)
 {
     return(layer.AnimationProgress + layer.Properties.AnimationSpeed * 2 >=
            layer.Properties.Width * layer.LayerType.DrawScale);
 }
Example #44
0
        public override void GetAllAttributeInfo(T model)
        {
            foreach (AttributeModel am in model.attributes)
            {
                foreach (string layerName in GetRealLayer(am.LayerName))
                {
                    LayerModel lyModel = new LayerModel();
                    lyModel.IsHaveAttribute = true;
                    List <BlockInfoModel> list = new List <BlockInfoModel>();
                    lyModel.Name = layerName;
                    Document           doc = Application.DocumentManager.MdiActiveDocument;
                    ObjectIdCollection ids = new ObjectIdCollection();

                    PromptSelectionResult ProSset = null;
                    TypedValue[]          filList = new TypedValue[1] {
                        new TypedValue((int)DxfCode.LayerName, layerName)
                    };
                    SelectionFilter sfilter   = new SelectionFilter(filList);
                    LayoutManager   layoutMgr = LayoutManager.Current;

                    string ss = layoutMgr.CurrentLayout;
                    ProSset = doc.Editor.SelectAll(sfilter);
                    //  List<ObjectId> idss=  GetEntitiesInModelSpace();
                    Database db = doc.Database;
                    List <BlockReference> blockTableRecords = new List <BlockReference>();
                    if (ProSset.Status == PromptStatus.OK)
                    {
                        lyModel.pointFs = new Dictionary <int, List <object> >();
                        using (Transaction tran = db.TransactionManager.StartTransaction())
                        {
                            SelectionSet sst = ProSset.Value;

                            ObjectId[] oids = sst.GetObjectIds();

                            int           ad = 0;
                            List <string> aa = new List <string>();

                            LayerTable lt = (LayerTable)db.LayerTableId.GetObject(OpenMode.ForRead);
                            foreach (ObjectId layerId in lt)
                            {
                                LayerTableRecord ltr = (LayerTableRecord)tran.GetObject(layerId, OpenMode.ForRead);
                                if (ltr.Name == layerName)
                                {
                                    lyModel.Color = System.Drawing.ColorTranslator.ToHtml(ltr.Color.ColorValue);
                                }
                            }

                            int i = 0;


                            foreach (ObjectId lengGemo in oids)
                            {
                                AttributeModel am2 = new AttributeModel();

                                foreach (AttributeItemModel att in am.attributeItems)
                                {
                                    AttributeItemModel aim2 = new AttributeItemModel();
                                    aim2.TargetName  = att.TargetName;
                                    aim2.AtItemType  = att.AtItemType;
                                    aim2.AtGroupType = att.AtGroupType;
                                    am2.attributeItems.Add(aim2);
                                }

                                DBObject       ob      = tran.GetObject(lengGemo, OpenMode.ForRead);
                                BlockInfoModel plModel = MethodCommand.AnalysisBlcokInfo(ob, am2);

                                if (plModel != null)
                                {
                                    List <object> obj = new List <object>()
                                    {
                                        plModel
                                    };
                                    lyModel.pointFs.Add(i, obj);
                                    i++;
                                }
                            }
                        }
                        if (model.allLines == null)
                        {
                            model.allLines = new List <LayerModel>();
                        }
                        model.allLines.Add(lyModel);
                    }
                }
            }
        }
Example #45
0
 public bool MustExpire(LayerModel layer) => layer.Properties.AnimationProgress > 2;
Example #46
0
 public bool MustExpire(LayerModel layer) => layer.Properties.AnimationProgress > 2;
Example #47
0
        /// <summary>
        ///     Updates the inner layers when the settings have changed
        /// </summary>
        /// <param name="layerModel"></param>
        private void UpdateLayers(LayerModel layerModel)
        {
            var settings = (AudioPropertiesModel) layerModel.Properties;
            if (JsonConvert.SerializeObject(settings).Equals(JsonConvert.SerializeObject(_previousSettings)))
                return;

            _previousSettings = GeneralHelpers.Clone((AudioPropertiesModel) layerModel.Properties);

            _audioLayers.Clear();
            if (settings.Direction == Direction.TopToBottom || settings.Direction == Direction.BottomToTop)
                SetupVertical(settings);
            else if (settings.Direction == Direction.LeftToRight || settings.Direction == Direction.RightToLeft)
                SetupHorizontal(settings);
        }
Example #48
0
        public void TestAccessOrm()
        {
            //ORM数据映射
            DbConfig.UseDefaultConfig(new TModelDbConfig(GetDbPath()));
            Console.WriteLine("Start loadding...");
            Console.WriteLine(new cms_category().Query(m => m.name == "城市").ToCount());
            var cat = new cms_category().Query(m => m.name == "城市").SortAsc(m => m.name).ToModel();

            Console.WriteLine(cat.name);

            //设置只更新部分
            //cat.SetPartHandled();
            //cat.description = "test";
            //cat.Update(m=>m.id == 1);

            Console.WriteLine(cat.ToValue(m => m.name));
            Console.WriteLine(new cms_category().Query(m => m.name == "城市").ToList()[0].name);
            Console.WriteLine(new cms_category().Query(m => m.name == "城市" && m.id > 0 && m.name == "" || (m.id == 0 || m.name == "")).ToCount());
            //指定条件规则查询
            Console.WriteLine(new cms_category().Query(m => (m.name == "城市" && (m.id > 0 || m.name == "")) || (m.id == 0 || m.name == "")).ToCount());

            var cityList = new List <string> {
                "城市", "b", "c"
            };
            var layer = new LayerModel {
                List = cityList
            };

            Console.WriteLine(new cms_category().Query(m => m.name == "城市" || cityList.Contains(m.name) || m.parent_id == Status.Success).ToCount());
            Console.WriteLine(new cms_category().Query(m => m.name == "城市" || layer.List.Contains(m.name)).ToCount());


            //获取全部
            var datsList = new cms_category().Query().ToList();

            Console.WriteLine(datsList.Count);
            //获取N条
            datsList = new cms_category().Query().ToList(6);
            Console.WriteLine(datsList.Count);
            //获取部分
            var partList = new cms_category().Query().ToPartList(6, "id", "name").Select(m => new cms_category
            {
                id   = int.Parse(m[0]),
                name = m[1]
            }).ToList();

            Console.WriteLine(partList.Count);
            //分页查询
            var mapper    = new cms_category().Query();
            var dataCount = mapper.ToCount();

            datsList = mapper.ToList(20, 1, dataCount);
            Console.WriteLine(datsList.Count);
            //条件拼接查询
            mapper.And(m => m.name == "test")
            .And(m => m.id > 0)
            .Or(m => m.parent_id > 0);
            mapper.Or(m => m.parent_id > 0);



            var channels = new cms_channel().Query().ToList();

            Console.WriteLine(channels.Count);
            var grade = new ucl_grade {
                id = 5
            };

            grade.grade_name = "新手1";
            var dal = new UclGradeDataAccess(grade);

            //保持数据库连接
            using (var db = new DbBuilder(new TModelDbConfig(GetDbPath())).KeepConnect())
            {
                //使用数据库db操作并跟踪实体修改状态
                dal.UseDatabase(db).SetPartHandled();
                grade.grade      = 8;
                grade.grade_name = "新手";
                dal.Update();
            }
            //db销毁后重连数据库
            Console.WriteLine(dal.ToValue(m => m.grade_name));


            //使用事务(在事务中处理)
            using (var db = new DbBuilder(new TModelDbConfig(GetDbPath())).KeepConnect())
            {
                try
                {
                    db.BeginTransaction();
                    //TODO:something
                    //使用数据库db操作并跟踪实体修改状态
                    dal.UseDatabase(db).SetPartHandled();
                    grade.grade      = 8;
                    grade.grade_name = "新手";
                    dal.Update();
                    db.CommitTransaction();
                }
                catch (Exception ex)
                {
                    db.RollbackTransaction();
                }
            }

            //使用事务(批处理事务)
            var parList = new List <DbParamInfo>();

            //添加到批处理事务中,如果执行失败则回滚事务
            parList.Add(dal.GetUpdateDbParamInfo().UseVerifyExecResult());
            //TODO:添加其他操作到parList
            var execCount = new DbBuilder(new TModelDbConfig(GetDbPath())).ExecuteSqlTran(parList);

            Console.WriteLine(execCount);
        }
Example #49
0
 public void Update(LayerModel layerModel, ModuleDataModel dataModel, bool isPreview = false)
 {
 }
Example #50
0
        public void GetAllYDBMGemo(T model, string layerName)
        {
            if (model != null)
            {
                LayerModel lm  = new LayerModel();
                Document   doc = Application.DocumentManager.MdiActiveDocument;
                Database   db  = doc.Database;

                ObjectIdCollection ids = new ObjectIdCollection();
                lm.Name = layerName;

                PromptSelectionResult ProSset = null;
                TypedValue[]          filList = new TypedValue[1] {
                    new TypedValue((int)DxfCode.LayerName, layerName)
                };
                SelectionFilter sfilter = new SelectionFilter(filList);

                ProSset = doc.Editor.SelectAll(sfilter);
                if (ProSset.Status == PromptStatus.OK)
                {
                    using (Transaction tran = db.TransactionManager.StartTransaction())
                    {
                        SelectionSet sst  = ProSset.Value;
                        ObjectId[]   oids = sst.GetObjectIds();

                        LayerTable lt = (LayerTable)db.LayerTableId.GetObject(OpenMode.ForRead);
                        foreach (ObjectId layerId in lt)
                        {
                            LayerTableRecord ltr = (LayerTableRecord)tran.GetObject(layerId, OpenMode.ForRead);
                            if (ltr.Name == layerName)
                            {
                                lm.Color = System.Drawing.ColorTranslator.ToHtml(ltr.Color.ColorValue);
                            }
                        }

                        foreach (ObjectId lengGemo in oids)
                        {
                            DBObject            ob             = tran.GetObject(lengGemo, OpenMode.ForRead);
                            PointsPlanItemModel pointsPlanItem = new PointsPlanItemModel();
                            if (ob is Polyline)
                            {
                                Polyline aPl = ob as Polyline;
                                // 读取分图则闭合多段线内的用地代码
                                List <PointF> pfs = new List <PointF>();
                                if (aPl.Closed is true)
                                {
                                    int vn2 = aPl.NumberOfVertices;  //lwp已知的多段线
                                    for (int J = 0; J < vn2; J++)
                                    {
                                        Point2d pt = aPl.GetPoint2dAt(J);
                                        PointF  pf = new PointF((float)pt.X, (float)pt.Y);
                                        pfs.Add(pf);
                                    }
                                }
                                pointsPlanItem.Num = MethodCommand.GetAttrIndex(pfs);
                            }

                            BlockInfoModel plModel = MethodCommand.AnalysisBlcokInfo(ob);
                            pointsPlanItem.Geom = plModel;

                            if (lm.modelItemList == null)
                            {
                                lm.modelItemList = new List <object>();
                            }

                            lm.modelItemList.Add(pointsPlanItem);
                        }
                    }

                    if (model.allLines == null)
                    {
                        model.allLines = new List <LayerModel>();
                    }
                    model.allLines.Add(lm);
                }
            }
        }
Example #51
0
        /// <summary>
        ///     Handles dragging the given layer
        /// </summary>
        /// <param name="e"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="hoverLayer"></param>
        private void HandleDragging(MouseEventArgs e, double x, double y, LayerModel hoverLayer)
        {
            // Reset the dragging state on mouse release
            if (e.LeftButton == MouseButtonState.Released ||
                _draggingLayer != null && SelectedLayer != _draggingLayer)
            {
                _draggingLayerOffset = null;
                _draggingLayer       = null;
                return;
            }

            if (SelectedLayer == null || SelectedLayer.LayerType != null && !SelectedLayer.LayerType.ShowInEdtor)
            {
                return;
            }

            // Setup the dragging state on mouse press
            if (_draggingLayerOffset == null && hoverLayer != null && e.LeftButton == MouseButtonState.Pressed)
            {
                var layerRect = hoverLayer.Properties.PropertiesRect(1);

                _draggingLayerOffset = new Point(x - SelectedLayer.Properties.X, y - SelectedLayer.Properties.Y);
                _draggingLayer       = hoverLayer;
                // Detect dragging if cursor is in the bottom right
                _resizing = Math.Sqrt(Math.Pow(x - layerRect.BottomRight.X, 2) +
                                      Math.Pow(y - layerRect.BottomRight.Y, 2)) < 0.6;
            }

            if (_draggingLayerOffset == null || _draggingLayer == null || _draggingLayer != SelectedLayer)
            {
                return;
            }

            var draggingProps = _draggingLayer.Properties;

            // If no setup or reset was done, handle the actual dragging action
            if (_resizing)
            {
                var newWidth  = Math.Round(x - draggingProps.X);
                var newHeight = Math.Round(y - draggingProps.Y);

                // Ensure the layer doesn't leave the canvas
                if (newWidth < 1 || draggingProps.X + newWidth <= 0)
                {
                    newWidth = draggingProps.Width;
                }
                if (newHeight < 1 || draggingProps.Y + newHeight <= 0)
                {
                    newHeight = draggingProps.Height;
                }

                draggingProps.Width  = newWidth;
                draggingProps.Height = newHeight;
            }
            else
            {
                var newX = Math.Round(x - _draggingLayerOffset.Value.X);
                var newY = Math.Round(y - _draggingLayerOffset.Value.Y);

                // Ensure the layer doesn't leave the canvas
                if (newX >= SelectedProfile.Width || newX + draggingProps.Width <= 0)
                {
                    newX = draggingProps.X;
                }
                if (newY >= SelectedProfile.Height || newY + draggingProps.Height <= 0)
                {
                    newY = draggingProps.Y;
                }

                draggingProps.X = newX;
                draggingProps.Y = newY;
            }
        }
Example #52
0
 public LuaLayerProperties(LayerModel layerModel)
 {
     _layerModel = layerModel;
 }
Example #53
0
        private void AutoInitData()
        {
            ModelBase mb = new ModelBase();

            try
            {
                mb          = ChangeToModel(mb);
                isOnlyModel = mb.IsOnlyModel;
                mb.DocName  = System.IO.Path.GetFileNameWithoutExtension(CadHelper.fileName);
                ModelBaseMethod <ModelBase> mbm = new ModelBaseMethod <ModelBase>();
                // mbm.GetLengedPoints(mb);
                mbm.GetAllLengedGemo(mb);
                mbm.GetExportLayers(mb);
                LayerSpecialCommand <ModelBase> layerSpecial = new LayerSpecialCommand <ModelBase>();
                layerSpecial.AddSpecialLayerModel(mb);
                //  mb.AddSpecialLayerModel();
                DataTable tb = new DataTable();
                tb.Columns.Add("所在图层");

                //tb.Columns.Add("图例文本");
                //tb.Columns.Add("图例线段");

                if (mb.LegendList != null)
                {
                    tb.Columns.Add("数据图层");
                    tb.Columns.Add("图例框顶点");
                    for (int i = 0; i < mb.LegendList.Count; i++)
                    {
                        DataRow dr = tb.NewRow();
                        dr[0] = MethodCommand.LegendLayer;

                        dr["数据图层"] = mb.LegendList[i].LayerName;
                        string peakPoint = "";

                        foreach (PointF PT in mb.LegendList[i].BoxPointList)
                        {
                            peakPoint += "Point:" + PT.X + "," + PT.Y + ";";
                        }
                        dr["图例框顶点"] = peakPoint;
                        AnalyBlockList(tb, dr, mb.LegendList[i].GemoModels, "图例");
                        //for (int j = 0; j < mb.LegendList.Count; j++)
                        //{
                        //    if (colNum <= j + 1)
                        //    {
                        //        colNum++;
                        //        DataColumn dc = new DataColumn("Point" + (j + 1));
                        //        tb.Columns.Add(dc);
                        //    }
                        //    dr[j + 1] = "X:" + mb.LegendList[i][j].X + ",Y:" + mb.LegendList[i][j].Y;
                        //}
                        tb.Rows.Add(dr);
                    }
                }
                if (mb.LayerList != null)
                {
                    TreeNode rotNode = new TreeNode("图层筛选");
                    this.treeView1.Nodes.Add(rotNode);
                    foreach (string layer in mb.LayerList)
                    {
                        TreeNode node = new TreeNode(layer);
                        rotNode.Nodes.Add(node);
                    }
                    this.treeView1.ExpandAll();
                }
                if (mb is RoadModel)
                {
                    if (mb is RoadSectionModel)
                    {
                        LayerModel spModel = (mb as RoadSectionModel).allLines[(mb as RoadSectionModel).allLines.Count - 1];
                        GetSpecialDataRowInfo(spModel.modelItemList, tb, spModel.Name);
                    }
                    if (mb is RoadNoSectionModel)
                    {
                        LayerModel spModel = (mb as RoadNoSectionModel).allLines[(mb as RoadNoSectionModel).allLines.Count - 1];
                        GetSpecialDataRowInfo(spModel.modelItemList, tb, spModel.Name);
                    }
                }
                else if (mb is PipeModel)
                {
                    LayerModel spModel = (mb as PipeModel).allLines[(mb as PipeModel).allLines.Count - 1];
                    GetSpecialDataRowInfo(spModel.modelItemList, tb, spModel.Name);
                }


                this.dataGridView1.DataSource = tb;
                model = mb;
                if (treeView1.Nodes.Count > 0)
                {
                    treeView1.Nodes[0].Checked = true;
                }
            }
            catch
            {
                System.IO.FileStream   fs = new System.IO.FileStream(@"C:\Users\Administrator\Desktop\测试结果.txt", System.IO.FileMode.Create);
                System.IO.StreamWriter sw = new System.IO.StreamWriter(fs);
                //开始写入
                sw.WriteLine(mb.DocName);
                //清空缓冲区
                sw.Flush();
                //关闭流
                sw.Close();
                fs.Close();
            }
        }