/// <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 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;
}
}
/// <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 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;
}
}
/// <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;
}
}
/// <ToBeCompleted></ToBeCompleted>
public TemplateControllerPropertyMappingChangedEventArgs(Template template, IModelMapping modelMapping)
: base(template)
{
this.propertyMapping = modelMapping;
}
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;
}
/// <override></override>
protected override void ProcessExecModelPropertyChange(IModelMapping propertyMapping) {
switch (propertyMapping.ShapePropertyId) {
case PropertyIdDiameter:
DiameterInternal = propertyMapping.GetInteger();
break;
default:
base.ProcessExecModelPropertyChange(propertyMapping);
break;
}
}
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);
}
