/// <override></override> protected override void ProcessExecModelPropertyChange(IModelMapping propertyMapping) { switch (propertyMapping.ShapePropertyId) { case PropertyIdText: Text = propertyMapping.GetString(); break; case PropertyIdCharacterStyle: // assign private stylebecause if the style matches the template's style, it would not be assigned. CharacterStyle = propertyMapping.GetStyle() as ICharacterStyle; Invalidate(); break; case PropertyIdParagraphStyle: // assign private stylebecause if the style matches the template's style, it would not be assigned. ParagraphStyle = propertyMapping.GetStyle() as IParagraphStyle; Invalidate(); break; default: base.ProcessExecModelPropertyChange(propertyMapping); break; } }
/// <ToBeCompleted></ToBeCompleted> public IModelMapping GetPropertyMapping(int modelPropertyId) { IModelMapping result = null; propertyMappings.TryGetValue(modelPropertyId, out result); return(result); }
/// <ToBeCompleted></ToBeCompleted> public void UnmapProperties(IModelMapping propertyMapping) { if (propertyMapping == null) { throw new ArgumentNullException("propertyMapping"); } propertyMappings.Remove(propertyMapping.ModelPropertyId); }
public virtual T BuildMappedModel <T>(T model, IModel modelData, IModelMapping mapping) //where T : class { foreach (var property in mapping.ModelProperties) { SetPropertyValue(model, modelData, property); } return(model); }
/// <override></override> protected override void ProcessExecModelPropertyChange(IModelMapping propertyMapping) { switch (propertyMapping.ShapePropertyId) { case PropertyIdDiameter: DiameterInternal = propertyMapping.GetInteger(); break; default: base.ProcessExecModelPropertyChange(propertyMapping); break; } }
/// <ToBeCompleted></ToBeCompleted> public void MapProperties(IModelMapping propertyMapping) { if (propertyMapping == null) { throw new ArgumentNullException("propertyMapping"); } if (propertyMappings.ContainsKey(propertyMapping.ModelPropertyId)) { propertyMappings[propertyMapping.ModelPropertyId] = propertyMapping; } else { propertyMappings.Add(propertyMapping.ModelPropertyId, propertyMapping); } }
/// <summary> /// Define a new model-to-shape property mapping. /// </summary> public void SetModelMapping(IModelMapping modelMapping) { if (modelMapping == null) { throw new ArgumentNullException("modelMapping"); } _workTemplate.MapProperties(modelMapping); TemplateWasChanged = true; if (TemplateShapePropertyMappingSet != null) { _modelMappingChangedEventArgs.Template = _workTemplate; _modelMappingChangedEventArgs.ModelMapping = modelMapping; TemplateShapePropertyMappingSet(this, _modelMappingChangedEventArgs); } }
/// <summary> /// Deletes a model-to-shape property mapping /// </summary> /// <param name="modelMapping"></param> public void DeleteModelMapping(IModelMapping modelMapping) { if (modelMapping == null) { throw new ArgumentNullException("modelMapping"); } workTemplate.UnmapProperties(modelMapping); TemplateWasChanged = true; if (TemplateShapePropertyMappingDeleted != null) { modelMappingChangedEventArgs.Template = workTemplate; modelMappingChangedEventArgs.ModelMapping = modelMapping; TemplateShapePropertyMappingDeleted(this, modelMappingChangedEventArgs); } }
/// <override></override> protected override void ProcessExecModelPropertyChange(IModelMapping propertyMapping) { switch (propertyMapping.ShapePropertyId) { case PropertyIdBodyHeight: BodyHeight = propertyMapping.GetInteger(); break; case PropertyIdHeadWidth: HeadWidth = propertyMapping.GetInteger(); break; default: base.ProcessExecModelPropertyChange(propertyMapping); break; } }
public static void Compare(Template savedTemplate, Template loadedTemplate, int version) { CompareId(savedTemplate, loadedTemplate); CompareString(savedTemplate.Description, loadedTemplate.Description, false); CompareString(savedTemplate.Name, loadedTemplate.Name, false); CompareString(savedTemplate.Title, loadedTemplate.Title, false); CompareObjectCount(savedTemplate.GetPropertyMappings(), loadedTemplate.GetPropertyMappings()); foreach (IModelMapping savedMapping in savedTemplate.GetPropertyMappings()) { IModelMapping loadedMapping = loadedTemplate.GetPropertyMapping(savedMapping.ModelPropertyId); Compare(savedMapping, loadedMapping, version); } Compare(savedTemplate.Shape, loadedTemplate.Shape, version); foreach (ControlPointId ptId in savedTemplate.Shape.GetControlPointIds(ControlPointCapabilities.All)) { Assert.AreEqual <TerminalId>(savedTemplate.GetMappedTerminalId(ptId), loadedTemplate.GetMappedTerminalId(ptId)); Assert.AreEqual <string>(savedTemplate.GetMappedTerminalName(ptId), loadedTemplate.GetMappedTerminalName(ptId)); } }
/// <override></override> protected override void ProcessExecModelPropertyChange(IModelMapping propertyMapping) { switch (propertyMapping.ShapePropertyId) { case PropertyIdAngle: Angle = propertyMapping.GetInteger(); break; case PropertyIdFillStyle: // assign private stylebecause if the style matches the template's style, it would not be assigned. privateFillStyle = (IFillStyle)propertyMapping.GetStyle(); Invalidate(); break; default: base.ProcessExecModelPropertyChange(propertyMapping); break; } }
public static void Compare(Template templateA, Template templateB, int version) { CompareId(templateA, templateB); CompareString(templateA.Description, templateB.Description, false); CompareString(templateA.Name, templateB.Name, false); CompareString(templateA.Title, templateB.Title, false); CompareObjectCount(templateA.GetPropertyMappings(), templateB.GetPropertyMappings()); foreach (IModelMapping mappingA in templateA.GetPropertyMappings()) { IModelMapping mappingB = templateB.GetPropertyMapping(mappingA.ModelPropertyId); Compare(mappingA, mappingB, version); } Compare(templateA.Shape, templateB.Shape, version); Compare(templateA.Shape.ModelObject, templateB.Shape.ModelObject, version); CompareObjectCount(templateA.Shape.GetControlPointIds(ControlPointCapabilities.All), templateB.Shape.GetControlPointIds(ControlPointCapabilities.All)); foreach (ControlPointId ptId in templateA.Shape.GetControlPointIds(ControlPointCapabilities.Connect)) { Assert.AreEqual <TerminalId>(templateA.GetMappedTerminalId(ptId), templateB.GetMappedTerminalId(ptId)); Assert.AreEqual <string>(templateA.GetMappedTerminalName(ptId), templateB.GetMappedTerminalName(ptId)); } }
public IModelMapping GetMapping(Type type) { if (type == null) { throw new ArgumentNullException("type"); } IModelMapping result = null; var generics = type.GetGenericArguments(); if (generics.Length > 0) { Type genericType = type.GetGenericArguments()[0]; if (genericType != null && typeof(ICollection <>).MakeGenericType(genericType).IsAssignableFrom(type)) { type = genericType; } } if (modelMappings.ContainsKey(type)) { result = modelMappings[type]; } else if (propertyMappingLists.ContainsKey(type)) { var propertyMappings = propertyMappingLists[type]; //IList<IModelProperty> modelProperties = new List<IModelProperty>(); var modelProperties = propertyMappings.Select(mapping => { mapping.GetMapping(mapping.PropertyAttribute, this); //GetMapping is called when the mapping is first requested, assuming all Binding Modules have been loaded up return(resolver.GetModelProperty(mapping.Property, mapping.PropertyAttribute)); }).ToList(); //foreach (var mapping in propertyMappings) //{ // mapping.GetMapping(mapping.PropertyAttribute, this); // modelProperties.Add(resolver.GetModelProperty(mapping.Property, mapping.PropertyAttribute)); //} result = new ModelMapping(type, modelProperties); modelMappings.Add(type, result); //The first time it's asked for, it's loaded into the dictionary permanently and can't change } return(result); }
public static void Compare(IModelMapping savedMapping, IModelMapping loadedMapping, int version) { CompareId(savedMapping, loadedMapping); Assert.AreEqual <int>(savedMapping.ModelPropertyId, loadedMapping.ModelPropertyId); Assert.AreEqual <int>(savedMapping.ShapePropertyId, loadedMapping.ShapePropertyId); if (savedMapping is NumericModelMapping && loadedMapping is NumericModelMapping) { Compare((NumericModelMapping)savedMapping, (NumericModelMapping)loadedMapping, version); } else if (savedMapping is FormatModelMapping && loadedMapping is FormatModelMapping) { Compare((FormatModelMapping)savedMapping, (FormatModelMapping)loadedMapping, version); } else if (savedMapping is StyleModelMapping && loadedMapping is StyleModelMapping) { Compare((StyleModelMapping)savedMapping, (StyleModelMapping)loadedMapping, version); } else { Assert.Fail("saved and loaded model mapping are of different types"); } }
public static void Compare(IModelMapping mappingA, IModelMapping mappingB, int version) { CompareId(mappingA, mappingB); Assert.AreEqual <int>(mappingA.ModelPropertyId, mappingB.ModelPropertyId); Assert.AreEqual <int>(mappingA.ShapePropertyId, mappingB.ShapePropertyId); if (mappingA is NumericModelMapping && mappingB is NumericModelMapping) { Compare((NumericModelMapping)mappingA, (NumericModelMapping)mappingB, version); } else if (mappingA is FormatModelMapping && mappingB is FormatModelMapping) { Compare((FormatModelMapping)mappingA, (FormatModelMapping)mappingB, version); } else if (mappingA is StyleModelMapping && mappingB is StyleModelMapping) { Compare((StyleModelMapping)mappingA, (StyleModelMapping)mappingB, version); } else { Assert.Fail("Model mappings A and B are of different types"); } }
/// <ToBeCompleted></ToBeCompleted> public void MapProperties(IModelMapping propertyMapping) { if (propertyMapping == null) throw new ArgumentNullException("propertyMapping"); if (propertyMappings.ContainsKey(propertyMapping.ModelPropertyId)) propertyMappings[propertyMapping.ModelPropertyId] = propertyMapping; else propertyMappings.Add(propertyMapping.ModelPropertyId, propertyMapping); }
public SetModelAction(object model, IModelMapping modelMapping) { _model = model ?? throw new ArgumentNullException(nameof(model)); _modelMapping = modelMapping ?? throw new ArgumentNullException(nameof(modelMapping)); }
public GetModelAction(IModelMapping modelMapping) { _modelMapping = modelMapping ?? throw new ArgumentNullException(nameof(modelMapping)); }
/// <override></override> protected override void ProcessExecModelPropertyChange(IModelMapping propertyMapping) { switch (propertyMapping.ShapePropertyId) { //case PropertyIdImage: break; case PropertyIdImageLayout: ImageLayout = (ImageLayoutMode)propertyMapping.GetInteger(); break; case PropertyIdImageGrayScale: GrayScale = (propertyMapping.GetInteger() != 0); break; case PropertyIdImageGamma: //GammaCorrection = Math.Max(0.00000001f, Math.Abs(propertyMapping.GetFloat())); GammaCorrection = propertyMapping.GetFloat(); break; case PropertyIdImageTransparency: checked { Transparency = (byte)propertyMapping.GetInteger(); } break; case PropertyIdImageTransparentColor: TransparentColor = Color.FromArgb(propertyMapping.GetInteger()); break; default: base.ProcessExecModelPropertyChange(propertyMapping); break; } }
/// <ToBeCompleted></ToBeCompleted> public TemplateControllerPropertyMappingChangedEventArgs(Template template, IModelMapping modelMapping) : base(template) { this.propertyMapping = modelMapping; }
/// <override></override> protected override void ProcessExecModelPropertyChange(IModelMapping propertyMapping) { switch (propertyMapping.ShapePropertyId) { case PropertyIdColumnBackgroundColorStyle: privateColumnBackgroundColorStyle = (propertyMapping.GetStyle() as IColorStyle); Invalidate(); break; case PropertyIdColumnCharacterStyle: privateColumnCharacterStyle = (propertyMapping.GetStyle() as ICharacterStyle); InvalidateDrawCache(); Invalidate(); break; case PropertyIdColumnParagraphStyle: privateColumnParagraphStyle = (propertyMapping.GetStyle() as IParagraphStyle); InvalidateDrawCache(); Invalidate(); break; default: base.ProcessExecModelPropertyChange(propertyMapping); break; } }
public virtual object BuildMappedModel(IModel modelData, IModelMapping mapping) { var model = resolver.ResolveInstance(mapping.ModelType); return(BuildMappedModel(model, modelData, mapping)); }
/// <override></override> protected override void ProcessExecModelPropertyChange(IModelMapping propertyMapping) { switch (propertyMapping.ShapePropertyId) { case PropertyIdWidth: Width = propertyMapping.GetInteger(); break; case PropertyIdHeight: Height = propertyMapping.GetInteger(); break; default: base.ProcessExecModelPropertyChange(propertyMapping); break; } }
// Value Mapping Grid private void PopulateValueMappingGrid(IModelMapping modelMapping) { valueMappingGridPopulating = true; // Clear value mapping grid valueMappingGrid.Rows.Clear(); valueMappingGrid.Columns.Clear(); // Add columns and rows if (modelMapping is NumericModelMapping) { CreateNumericMappingColumns((NumericModelMapping)modelMapping); CreateNumericMappingRows((NumericModelMapping)modelMapping); } else if (modelMapping is FormatModelMapping) { CreateFormatMappingColumns((FormatModelMapping)modelMapping); CreateFormatMappingRows((FormatModelMapping)modelMapping); } else if (modelMapping is StyleModelMapping) { CreateStyleMappingColumns((StyleModelMapping)modelMapping); CreateStyleMappingRows((StyleModelMapping)modelMapping); } valueMappingGridPopulating = false; }
public GetModel Mapping(IModelMapping mapping) { _mapping = mapping ?? throw new ArgumentNullException(nameof(mapping)); return(this); }
public virtual T BuildMappedModel <T>(IModel modelData, IModelMapping mapping) //where T: class { T model = (T)resolver.ResolveInstance(typeof(T)); return(BuildMappedModel <T>(model, modelData, mapping)); }
/// <summary> /// Deletes a model-to-shape property mapping /// </summary> /// <param name="modelMapping"></param> public void DeleteModelMapping(IModelMapping modelMapping) { if (modelMapping == null) throw new ArgumentNullException("modelMapping"); workTemplate.UnmapProperties(modelMapping); TemplateWasChanged = true; if (TemplateShapePropertyMappingDeleted != null) { modelMappingChangedEventArgs.Template = workTemplate; modelMappingChangedEventArgs.ModelMapping = modelMapping; TemplateShapePropertyMappingDeleted(this, modelMappingChangedEventArgs); } }
private void DoCreatePropertyMappingGridRow(IModelMapping modelMapping) { // Find corresponding PropertyInfos PropertyInfo shapePropertyInfo = FindPropertyInfo(shapePropertyInfos, modelMapping.ShapePropertyId); PropertyInfo modelPropertyInfo = FindPropertyInfo(modelPropertyInfos, modelMapping.ModelPropertyId); // create a new row for the existing ModelMapping int rowIdx = propertyMappingGrid.Rows.Add(); propertyMappingGrid.Rows[rowIdx].Tag = modelMapping; propertyMappingGrid.Rows[rowIdx].Cells[shapeColumnIdx].Value = shapePropertyInfo.Name; propertyMappingGrid.Rows[rowIdx].Cells[modelColumnIdx].Value = modelPropertyInfo.Name; }
/// <ToBeCompleted></ToBeCompleted> public void UnmapProperties(IModelMapping propertyMapping) { if (propertyMapping == null) throw new ArgumentNullException("propertyMapping"); propertyMappings.Remove(propertyMapping.ModelPropertyId); }