private object DeserializeEntry(IDesignerSerializationManager manager, ObjectEntry objectEntry)
{
object deserialized = null;
if (objectEntry.IsEntireObject)
{
CodeDomSerializer serializer = (CodeDomSerializer)manager.GetSerializer(objectEntry.Type,
typeof(CodeDomSerializer));
if (serializer != null)
{
deserialized = serializer.Deserialize(manager, objectEntry.Serialized);
// check if the name of the object has changed
// (if it e.g clashes with another name)
string newName = manager.GetName(deserialized);
if (newName != objectEntry.Name)
{
objectEntry.Name = newName;
}
}
}
else
{
foreach (MemberEntry memberEntry in objectEntry.Members.Values)
{
CodeDomSerializer serializer = (CodeDomSerializer)manager.GetSerializer(objectEntry.Type,
typeof(CodeDomSerializer));
if (serializer != null)
{
serializer.Deserialize(manager, memberEntry.Serialized);
}
}
}
return(deserialized);
}
/// <summary>
/// Deserializes the specified serialized CodeDOM object into an object.
/// </summary>
/// <param name="manager">
/// A serialization manager interface that is used during the deserialization process.
/// </param>
/// <param name="codeObject">A serialized CodeDOM object to deserialize.</param>
/// <returns>The deserialized CodeDOM object.</returns>
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.GetSerializer(
typeof(UICultureChanger).BaseType, typeof(CodeDomSerializer));
return(baseClassSerializer.Deserialize(manager, codeObject));
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(BvResourceManagerChanger).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
Component component = (Component)value;
IDesignerHost host = component.Site.GetService(typeof(IDesignerHost)) as IDesignerHost;
if (host != null)
{
CodeCommentStatement comment = new CodeCommentStatement("Form Is Localizable: " + IsLocalizable(host));
statements.Insert(0, comment);
if (IsLocalizable(host))
{
CodeTypeDeclaration classTypeDeclaration = (CodeTypeDeclaration)manager.GetService(typeof(CodeTypeDeclaration));
CodeExpression typeofExpression = new CodeTypeOfExpression(classTypeDeclaration.Name);
CodeDirectionExpression outResourceExpression = new CodeDirectionExpression(FieldDirection.Out, new CodeVariableReferenceExpression("resources"));
CodeExpression rightCodeExpression = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("bv.common.Resources.BvResourceManagerChanger"), "GetResourceManager", new CodeExpression[] { typeofExpression, outResourceExpression });
statements.Insert(0, new CodeExpressionStatement(rightCodeExpression));
}
}
}
return(codeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object tempValue)
{
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer
(
typeof(System.Collections.ArrayList),
typeof(CodeDomSerializer)
);
GridColumns columns = (GridColumns)tempValue;
if ((columns.Count > 0) && (columns.HasDefaultColumn()))
{
ArrayList serializeColumns = new ArrayList();
foreach (GridColumn column in columns)
{
if (!(column is Alphora.Dataphor.DAE.Client.Controls.DataColumn))
{
serializeColumns.Add(column);
}
}
return(baseSerializer.Serialize(manager, serializeColumns));
}
else
{
return(baseSerializer.Serialize(manager, tempValue));
}
}
protected override void PerformLoad(IDesignerSerializationManager manager)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
CodeCompileUnit document = this.Parse();
if (document == null)
{
throw new NotSupportedException("The language did not provide a code parser for this file");
}
string namespaceName = null;
CodeTypeDeclaration rootDocument = GetFirstCodeTypeDecl(document, out namespaceName);
if (rootDocument == null)
{
throw new InvalidOperationException("Cannot find a declaration in a namespace to load.");
}
_rootSerializer = manager.GetSerializer(manager.GetType(rootDocument.BaseTypes[0].BaseType),
typeof(RootCodeDomSerializer)) as CodeDomSerializer;
if (_rootSerializer == null)
{
throw new InvalidOperationException("Serialization not supported for this class");
}
_rootSerializer.Deserialize(manager, rootDocument);
base.SetBaseComponentClassName(namespaceName + "." + rootDocument.Name);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(PlotToolBarButton).BaseType, typeof(CodeDomSerializer));
object obj = codeDomSerializer.Serialize(manager, value);
CodeExpression codeExpression = base.SerializeToExpression(manager, value);
if (codeExpression == null)
{
return(obj);
}
if (!(obj is CodeStatementCollection))
{
return(obj);
}
CodeStatementCollection codeStatementCollection = (CodeStatementCollection)obj;
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(codeExpression, "LoadingBegin");
int index = 0;
for (int i = 0; i < codeStatementCollection.Count; i++)
{
if (codeStatementCollection[i] is CodeCommentStatement)
{
index = i + 1;
}
}
codeStatementCollection.Insert(index, new CodeExpressionStatement(expression));
expression = new CodeMethodInvokeExpression(codeExpression, "LoadingEnd");
codeStatementCollection.Add(expression);
return(obj);
}
protected void SerializeEvent(IDesignerSerializationManager manager, CodeStatementCollection statements,
object value, EventDescriptor descriptor)
{
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
if (statements == null)
{
throw new ArgumentNullException("statements");
}
if (manager == null)
{
throw new ArgumentNullException("manager");
}
MemberCodeDomSerializer serializer = manager.GetSerializer(descriptor.GetType(), typeof(MemberCodeDomSerializer)) as MemberCodeDomSerializer;
if (serializer != null && serializer.ShouldSerialize(manager, value, descriptor))
{
serializer.Serialize(manager, value, descriptor, statements);
}
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseSerializer =
(CodeDomSerializer)manager.GetSerializer(typeof(ResourceControl).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
statements.Insert(0, new CodeCommentStatement("MLUResManager is used to set the custom resource file which in the another resource.dll."));
statements.Insert(0, new CodeCommentStatement("Must to set the BaseName property which is use to get the resource file name."));
CodeExpression targetObject =
base.SerializeToExpression(manager, value);
if (targetObject != null)
{
CodeExpression Paramter = new CodeArgumentReferenceExpression("ref resources");
CodeMethodInvokeExpression methodCall =
new CodeMethodInvokeExpression(targetObject, "reInitResManger", Paramter);
statements.Add(methodCall);
}
}
return(codeObject);
}
public override object Deserialize(IDesignerSerializationManager manager, object codeDomObject)
{
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(ResourceControl).BaseType,
typeof(CodeDomSerializer));
return(baseSerializer.Deserialize(manager, codeDomObject));
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer _codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(
typeof(MultiFunctionChartLegend).BaseType, typeof(CodeDomSerializer));
object _object = _codeDomSerializer.Serialize(manager, value);
if (_object is CodeStatementCollection)
{
CodeStatementCollection _codeStatementCollection = (CodeStatementCollection)_object;
CodeExpression _targetObject = base.GetExpression(manager, value);
if (_targetObject != null)
{
CodePropertyReferenceExpression _codePropertyReferenceExpression = new CodePropertyReferenceExpression(_targetObject, "OwnerChart");
CodeAssignStatement _codeAssignStatement = new CodeAssignStatement(_codePropertyReferenceExpression, new CodeThisReferenceExpression());
_codeStatementCollection.Insert(0, _codeAssignStatement);
CodeCommentStatement _codeCommentStatement = new CodeCommentStatement(
new CodeComment("WARNING: This generates an exception in design time, but is ok (select 'Ignore and continue')."));
_codeStatementCollection.Insert(0, _codeCommentStatement);
}
}
return(_object);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
object obj2 = ((CodeDomSerializer) manager.GetSerializer(typeof(ImageList).BaseType, typeof(CodeDomSerializer))).Serialize(manager, value);
ImageList list = value as ImageList;
if (list != null)
{
StringCollection keys = list.Images.Keys;
if (!(obj2 is CodeStatementCollection))
{
return obj2;
}
CodeExpression targetObject = base.GetExpression(manager, value);
if (targetObject == null)
{
return obj2;
}
CodeExpression expression2 = new CodePropertyReferenceExpression(targetObject, "Images");
if (expression2 == null)
{
return obj2;
}
for (int i = 0; i < keys.Count; i++)
{
if ((keys[i] != null) || (keys[i].Length != 0))
{
CodeMethodInvokeExpression expression3 = new CodeMethodInvokeExpression(expression2, "SetKeyName", new CodeExpression[] { new CodePrimitiveExpression(i), new CodePrimitiveExpression(keys[i]) });
((CodeStatementCollection) obj2).Add(expression3);
}
}
}
return obj2;
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseSerializer;
CodeStatementCollection statements;
CodeExpression targetObject;
if (manager == null || value == null)
{
return(null);
}
baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(MyControl).BaseType, typeof(CodeDomSerializer));
statements = baseSerializer.Serialize(manager, value) as CodeStatementCollection;
if (statements == null)
{
statements = new CodeStatementCollection();
}
targetObject = GetExpression(manager, value);
if (targetObject != null)
{
// add 'myControl.Visible = true;' statement.
statements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(targetObject, "Visible"),
new CodePrimitiveExpression(true)));
}
return(statements);
}
// See sample for the Deserialize method
/// <summary>
/// We customize the output from the default serializer here, adding
/// a comment and an extra line of code.
/// </summary>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
// first, locate and invoke the default serializer for
// the ButtonArray's base class (UserControl)
//
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(TaskBarButton).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
// now add some custom code
//
if (codeObject is CodeStatementCollection)
{
// add a custom comment to the code.
//
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
//statements.Insert(0, new CodeCommentStatement("This is a custom comment added by a custom serializer on " + DateTime.Now.ToLongDateString()));
// call a custom method.
//
CodeExpression targetObject = base.SerializeToExpression(manager, value);
if (targetObject != null)
{
CodeExpression args = new CodeSnippetExpression("this.Handle");
CodeMethodInvokeExpression methodCall = new CodeMethodInvokeExpression(targetObject, "AddToWindow");
methodCall.Parameters.Add(args);
statements.Add(methodCall);
}
}
// finally, return the statements that have been created
return(codeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer _codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(
typeof(DXPlayer).BaseType, typeof(CodeDomSerializer));
object _object = _codeDomSerializer.Serialize(manager, value);
if (_object is CodeStatementCollection)
{
CodeStatementCollection _codeStatementCollection = (CodeStatementCollection)_object;
CodeExpression _targetObject = base.GetExpression(manager, value);
if (_targetObject != null)
{
CodePropertyReferenceExpression _codePropertyReferenceExpression =
new CodePropertyReferenceExpression(_targetObject, "Owner");
CodeAssignStatement _codeAssignStatement = new CodeAssignStatement(
_codePropertyReferenceExpression, new CodeThisReferenceExpression());
_codeStatementCollection.Insert(0, _codeAssignStatement);
}
}
return(_object);
}
protected void SerializeProperty(IDesignerSerializationManager manager, CodeStatementCollection statements, object value, PropertyDescriptor propertyToSerialize)
{
if (propertyToSerialize == null)
{
throw new ArgumentNullException("propertyToSerialize");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
if (statements == null)
{
throw new ArgumentNullException("statements");
}
if (manager == null)
{
throw new ArgumentNullException("manager");
}
MemberCodeDomSerializer serializer = manager.GetSerializer(propertyToSerialize.GetType(), typeof(MemberCodeDomSerializer)) as MemberCodeDomSerializer;
if (serializer != null && serializer.ShouldSerialize(manager, value, propertyToSerialize))
{
serializer.Serialize(manager, value, propertyToSerialize, statements);
}
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer serializer1 = (CodeDomSerializer)manager.GetSerializer(this.GetPropType().BaseType, typeof(CodeDomSerializer));
object obj1 = serializer1.Serialize(manager, value);
if (this.ShouldSerialize(value) && (obj1 is CodeStatementCollection))
{
string text1 = manager.GetName(value);
if ((text1 != null) && (text1 != string.Empty))
{
CodeStatementCollection collection1 = (CodeStatementCollection)obj1;
CodeExpression expression1 = base.SerializeToExpression(manager, value);
IDesignerHost host1 = ((Component)value).Container as IDesignerHost;
if (host1.RootComponent != null)
{
string text2 = manager.GetName(host1.RootComponent);
if ((text2 != null) && (text2 != string.Empty))
{
CodePropertyReferenceExpression expression2 = new CodePropertyReferenceExpression(expression1, this.GetPropName());
CodeExpression[] expressionArray1 = new CodeExpression[1] {
new CodeTypeOfExpression(text2)
};
expressionArray1 = new CodeExpression[1] {
new CodePrimitiveExpression(text1 + ".XmlScheme")
};
CodeMethodInvokeExpression expression3 = new CodeMethodInvokeExpression(new CodeObjectCreateExpression(typeof(ResourceManager), expressionArray1), "GetObject", expressionArray1);
CodeCastExpression expression4 = new CodeCastExpression("System.String", expression3);
CodeAssignStatement statement1 = new CodeAssignStatement(expression2, expression4);
collection1.Add(statement1);
}
}
}
}
return(obj1);
}
/// <summary>
/// Deserilizes the given CodeDom object into a real object. This
/// will use the serialization manager to create objects and resolve
/// data types. The root of the object graph is returned.
/// </summary>
public virtual object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
object instance = null;
if (manager is null || codeObject is null)
{
throw new ArgumentNullException(manager is null ? "manager" : "codeObject");
}
using (TraceScope("CodeDomSerializer::Deserialize"))
{
// What is the code object? We support an expression, a statement or a collection of statements
if (codeObject is CodeExpression expression)
{
instance = DeserializeExpression(manager, null, expression);
}
else
{
if (codeObject is CodeStatementCollection statements)
{
foreach (CodeStatement element in statements)
{
// If we do not yet have an instance, we will need to pick through the statements and see if we can find one.
if (instance is null)
{
instance = DeserializeStatementToInstance(manager, element);
if (instance != null)
{
PropertyDescriptorCollection props = TypeDescriptor.GetProperties(instance, new Attribute[] { BrowsableAttribute.Yes });
foreach (PropertyDescriptor prop in props)
{
if (!prop.Attributes.Contains(DesignerSerializationVisibilityAttribute.Hidden) &&
prop.Attributes.Contains(DesignerSerializationVisibilityAttribute.Content) &&
!(manager.GetSerializer(prop.PropertyType, typeof(CodeDomSerializer)) is CollectionCodeDomSerializer))
{
ResetBrowsableProperties(prop.GetValue(instance));
}
}
}
}
else
{
DeserializeStatement(manager, element);
}
}
}
else
{
if (!(codeObject is CodeStatement statement))
{
Debug.Fail("CodeDomSerializer::Deserialize requires a CodeExpression, CodeStatement or CodeStatementCollection to parse");
string supportedTypes = string.Format(CultureInfo.CurrentCulture, "{0}, {1}, {2}", typeof(CodeExpression).Name, typeof(CodeStatement).Name, typeof(CodeStatementCollection).Name);
throw new ArgumentException(string.Format(SR.SerializerBadElementTypes, codeObject.GetType().Name, supportedTypes));
}
}
}
}
return(instance);
}
/// <summary>
/// We customize the output from the default serializer here, adding
/// a comment and an extra line of code.
/// </summary>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
// first, locate and invoke the default serializer for
// the ButtonArray's base class (UserControl)
//
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(WizardStepsControl).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
// now add some custom code
//
if (codeObject is CodeStatementCollection)
{
// add a custom comment to the code.
//
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
statements.Insert(4, new CodeCommentStatement("This is a custom comment added by a custom serializer on " + DateTime.Now.ToLongDateString()));
// call a custom method.
//
CodeExpression targetObject = base.SerializeToExpression(manager, value);
WizardStepsControl wsc = (WizardStepsControl)value;
if (targetObject != null && wsc.Steps != null)
{
CodePropertyReferenceExpression leftNode = new CodePropertyReferenceExpression(targetObject, "Steps");
CodeObjectCreateExpression rightNode = new CodeObjectCreateExpression(typeof(Collection <Step>));
CodeAssignStatement initializeStepsStatement = new CodeAssignStatement(leftNode, rightNode);
statements.Insert(5, initializeStepsStatement);
}
}
// finally, return the statements that have been created
return(codeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object value) {
var baseSerializer = (CodeDomSerializer)manager
.GetSerializer(typeof(ResourceManagerSetter).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
var statements = codeObject as CodeStatementCollection;
if (statements != null) {
CodeExpression leftCodeExpression = new CodeVariableReferenceExpression("resources");
var classTypeDeclaration = (CodeTypeDeclaration)manager.GetService(typeof(CodeTypeDeclaration));
CodeExpression typeofExpression = new CodeTypeOfExpression(classTypeDeclaration.Name);
CodeExpression rightCodeExpression =
new CodeObjectCreateExpression(typeof(XafComponentResourceManager),
new[] { typeofExpression });
//CodeExpression rightCodeExpression =
// new CodeTypeReferenceExpression(
// "new DevExpress.ExpressApp.Win.Templates"),
// "XafComponentResourceManager", new[] { typeofExpression });
statements.Insert(0, new CodeAssignStatement(leftCodeExpression, rightCodeExpression));
}
return codeObject;
}
public override object Serialize(
IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseSerializer = manager.GetSerializer(
typeof(FlowChart).BaseType, typeof(CodeDomSerializer)) as CodeDomSerializer;
object codeObject = baseSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection code =
codeObject as CodeStatementCollection;
FlowChart chart = value as FlowChart;
// Brushes
SerializeBrush(code, "BackBrush", chart, chart.BackBrush);
SerializeBrush(code, "BoxBrush", chart, chart.BoxBrush);
SerializeBrush(code, "TableBrush", chart, chart.TableBrush);
SerializeBrush(code, "ArrowBrush", chart, chart.ArrowBrush);
// Pens
SerializePen(code, "BoxPen", chart, chart.BoxPen);
SerializePen(code, "TablePen", chart, chart.TablePen);
SerializePen(code, "ArrowPen", chart, chart.ArrowPen);
// Text alignment
SerializeTextFormat(code, "TextFormat", chart, chart.TextFormat);
}
return codeObject;
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
var baseSerializer = (CodeDomSerializer)manager
.GetSerializer(typeof(ResourceManagerSetter).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
var statements = codeObject as CodeStatementCollection;
if (statements != null)
{
CodeExpression leftCodeExpression = new CodeVariableReferenceExpression("resources");
var classTypeDeclaration = (CodeTypeDeclaration)manager.GetService(typeof(CodeTypeDeclaration));
CodeExpression typeofExpression = new CodeTypeOfExpression(classTypeDeclaration.Name);
CodeExpression rightCodeExpression =
new CodeObjectCreateExpression(typeof(XafComponentResourceManager),
new[] { typeofExpression });
//CodeExpression rightCodeExpression =
// new CodeTypeReferenceExpression(
// "new DevExpress.ExpressApp.Win.Templates"),
// "XafComponentResourceManager", new[] { typeofExpression });
statements.Insert(0, new CodeAssignStatement(leftCodeExpression, rightCodeExpression));
}
return(codeObject);
}
private bool CanCacheComponent(IDesignerSerializationManager manager, object value, PropertyDescriptorCollection props)
{
IComponent component = value as IComponent;
if (component != null)
{
if (component.Site != null)
{
INestedSite site = component.Site as INestedSite;
if ((site != null) && !string.IsNullOrEmpty(site.FullName))
{
return false;
}
}
if (props == null)
{
props = TypeDescriptor.GetProperties(component);
}
foreach (PropertyDescriptor descriptor in props)
{
if (typeof(IComponent).IsAssignableFrom(descriptor.PropertyType) && !descriptor.Attributes.Contains(DesignerSerializationVisibilityAttribute.Hidden))
{
MemberCodeDomSerializer serializer = (MemberCodeDomSerializer) manager.GetSerializer(descriptor.GetType(), typeof(MemberCodeDomSerializer));
if ((serializer != null) && serializer.ShouldSerialize(manager, value, descriptor))
{
return false;
}
}
}
}
return true;
}
public override object Serialize(
IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseSerializer = manager.GetSerializer(
typeof(FlowChart).BaseType, typeof(CodeDomSerializer)) as CodeDomSerializer;
object codeObject = baseSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection code =
codeObject as CodeStatementCollection;
FlowChart chart = value as FlowChart;
// Brushes
SerializeBrush(code, "BackBrush", chart, chart.BackBrush);
SerializeBrush(code, "BoxBrush", chart, chart.BoxBrush);
SerializeBrush(code, "TableBrush", chart, chart.TableBrush);
SerializeBrush(code, "ArrowBrush", chart, chart.ArrowBrush);
// Pens
SerializePen(code, "BoxPen", chart, chart.BoxPen);
SerializePen(code, "TablePen", chart, chart.TablePen);
SerializePen(code, "ArrowPen", chart, chart.ArrowPen);
// Text alignment
SerializeTextFormat(code, "TextFormat", chart, chart.TextFormat);
}
return(codeObject);
}
/// <summary>
/// Serializes the specified object into a CodeDOM object.
/// </summary>
/// <param name="manager">The serialization manager to use during serialization.</param>
/// <param name="value">The object to serialize.</param>
/// <returns>A CodeDOM object representing the object that has been serialized.</returns>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.GetSerializer(
typeof(UICultureChanger).BaseType, typeof(CodeDomSerializer));
CodeStatementCollection codeStatementCollection = (CodeStatementCollection)baseClassSerializer.Serialize(
manager, value);
string variableName = ((Component)value).Site.Name;
// If the CodeStatementCollection only contains the constructor and/or member variable definition,
// add comment-block with name of the member variable.
if (codeStatementCollection.Count <= 2)
{
codeStatementCollection.Add(new CodeCommentStatement(""));
codeStatementCollection.Add(new CodeCommentStatement(variableName));
codeStatementCollection.Add(new CodeCommentStatement(""));
}
// Add a call to the UICultureChanger.AddForm method.
CodeMethodInvokeExpression codeMethodInvokeExpression = new CodeMethodInvokeExpression(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), variableName),
"AddForm", new CodeExpression[] { new CodeThisReferenceExpression() });
codeStatementCollection.Add(codeMethodInvokeExpression);
return(codeStatementCollection);
}
/// <summary>
///
/// </summary>
/// <param name="manager"></param>
/// <param name="codeObject"></param>
/// <returns></returns>
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
// This is how we associate the component with the serializer.
CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
return(baseClassSerializer.Deserialize(manager, codeObject));
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
object obj2 = ((CodeDomSerializer)manager.GetSerializer(typeof(ImageList).BaseType, typeof(CodeDomSerializer))).Serialize(manager, value);
ImageList list = value as ImageList;
if (list != null)
{
StringCollection keys = list.Images.Keys;
if (!(obj2 is CodeStatementCollection))
{
return(obj2);
}
CodeExpression targetObject = base.GetExpression(manager, value);
if (targetObject == null)
{
return(obj2);
}
CodeExpression expression2 = new CodePropertyReferenceExpression(targetObject, "Images");
if (expression2 == null)
{
return(obj2);
}
for (int i = 0; i < keys.Count; i++)
{
if ((keys[i] != null) || (keys[i].Length != 0))
{
CodeMethodInvokeExpression expression3 = new CodeMethodInvokeExpression(expression2, "SetKeyName", new CodeExpression[] { new CodePrimitiveExpression(i), new CodePrimitiveExpression(keys[i]) });
((CodeStatementCollection)obj2).Add(expression3);
}
}
}
return(obj2);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
try {
CodeDomSerializer serial = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (serial == null)
{
return(null);
}
CodeStatementCollection statements = (CodeStatementCollection)serial.Serialize(manager, value);
IDesignerHost host = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if (host == value)
{
return(statements);
}
InsertCodeCommentHeader(statements);
Calendar cdr = (Calendar)value;
CodeExpression cnref = SerializeToExpression(manager, value);
CodePropertyReferenceExpression propref = null;
//CodeAssignStatement cassign = null;
//cdr.CalendarStyle.CalendarHeader = new HeaderStyle(Font, foreColor, backColor, height);
// CalendarStyle.CalendarHeader
propref = new CodePropertyReferenceExpression(cnref, "CalendarStyle.CalendarHeader");
return(statements);
} catch (Exception ex) {
MessageBox.Show("Error during Serialize : " + ex.ToString());
return(null);
}
}
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
var baseClassSerializer = (CodeDomSerializer)manager.
GetSerializer(
typeof(HorizontalPictureScroller).BaseType,
typeof(CodeDomSerializer));
return(baseClassSerializer.Deserialize(manager, codeObject));
}
/// <summary>
/// Serializes the specified object into a CodeDOM object.
/// </summary>
/// <param name="manager">A serialization manager interface that is used during the deserialization process.</param>
/// <param name="value">The object to serialize.</param>
/// <returns>A CodeDOM object representing the object that has been serialized.</returns>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
// Set serialization flag
bool oldSerializationFlag = false;
SerializationStatus oldSerializationStatus = SerializationStatus.None;
Chart chart = value as Chart;
if (chart != null)
{
oldSerializationFlag = chart.serializing;
oldSerializationStatus = chart.serializationStatus;
chart.serializing = true;
chart.serializationStatus = SerializationStatus.Saving;
}
// Serialize object using the base class serializer
object result = null;
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(Chart).BaseType, typeof(CodeDomSerializer));
if (baseSerializer != null)
{
result = baseSerializer.Serialize(manager, value);
System.CodeDom.CodeStatementCollection statements = result as System.CodeDom.CodeStatementCollection;
// Sustom serialization of the DataSource property
if (statements != null && chart != null)
{
// Check if DataSource property is set
if (chart.DataSource != null && chart.DataSource is String && ((String)chart.DataSource) != "(none)")
{
// Add assignment statement for the DataSource property
System.CodeDom.CodeExpression targetObject =
base.SerializeToExpression(manager, value);
if (targetObject != null)
{
System.CodeDom.CodeAssignStatement assignStatement = new System.CodeDom.CodeAssignStatement(
new System.CodeDom.CodePropertyReferenceExpression(targetObject, "DataSource"),
new System.CodeDom.CodePropertyReferenceExpression(new System.CodeDom.CodeThisReferenceExpression(), (String)chart.DataSource));
statements.Add(assignStatement);
}
}
}
}
// Clear serialization flag
if (chart != null)
{
chart.serializing = oldSerializationFlag;
chart.serializationStatus = oldSerializationStatus;
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="manager"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
object codeObject = baseClassSerializer.Serialize(manager, value);
if (value.GetType().GetInterface("IWSerializer") == null)
{
System.Windows.Forms.MessageBox.Show("Must not never reach here:" + value.GetType().ToString());
return(codeObject);
}
MethodInfo mInf = value.GetType().GetInterface("IWSerializer").GetMethod("ShouldSerialize");
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
//--- loop through all statements
int count = statements.Count;
for (int i = 0; i < count; i++)
{
CodeStatement st = statements[i];
if (st is CodeAssignStatement)
{
CodeAssignStatement cAssign = (CodeAssignStatement)st;
// If left is eg. 'this.BorderColor'
if (cAssign.Left is CodePropertyReferenceExpression)
{
/* if(cAssign.Right is CodeCastExpression){
* CodeCastExpression c = (CodeCastExpression)cAssign.Right;
* if(c.Expression is CodeMethodInvokeExpression){
* CodeMethodInvokeExpression mI = (CodeMethodInvokeExpression)c.Expression;
* if(mI.Method.TargetObject is CodeVariableReferenceExpression){
* CodeVariableReferenceExpression vR = (CodeVariableReferenceExpression)mI.Method.TargetObject;
* System.Windows.Forms.MessageBox.Show(vR.);
* }
* }
* }*/
string propertyName = ((CodePropertyReferenceExpression)cAssign.Left).PropertyName;
//--- Check if we need to serialize property.
if (!(bool)mInf.Invoke(value, new object[] { propertyName }))
{
statements.Remove(st);
count--;
i--;
}
}
}
}
}
return(codeObject);
}
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
try {
CodeDomSerializer serial = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
return(serial.Deserialize(manager, codeObject));
} catch (Exception ex) {
MessageBox.Show("Error during Deserialize : " + ex.ToString());
return(null);
}
}
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
// This is how we associate the component with the serializer.
CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.
GetSerializer(typeof(MyComponent).BaseType, typeof(CodeDomSerializer));
/* This is the simplest case, in which the class just calls the base class
* to do the work. */
return(baseClassSerializer.Deserialize(manager, codeObject));
}
public override object Deserialize(IDesignerSerializationManager manager, object tempValue)
{
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer
(
typeof(Alphora.Dataphor.DAE.Client.Controls.GridColumns).BaseType,
typeof(CodeDomSerializer)
);
return(baseSerializer.Deserialize(manager, tempValue));
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
if (manager == null || value == null)
{
throw new ArgumentNullException((manager == null) ? "manager" : "value");
}
CodeDomSerializer codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (codeDomSerializer == null)
{
return(null);
}
object obj = codeDomSerializer.Serialize(manager, value);
InheritanceAttribute inheritanceAttribute = (InheritanceAttribute)TypeDescriptor.GetAttributes(value)[typeof(InheritanceAttribute)];
InheritanceLevel inheritanceLevel = InheritanceLevel.NotInherited;
if (inheritanceAttribute != null)
{
inheritanceLevel = inheritanceAttribute.InheritanceLevel;
}
if (inheritanceLevel != InheritanceLevel.InheritedReadOnly)
{
IDesignerHost designerHost = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if (designerHost != null)
{
PropertyDescriptor propertyDescriptor = TypeDescriptor.GetProperties(designerHost.RootComponent)["Localizable"];
if (propertyDescriptor != null && propertyDescriptor.PropertyType == typeof(bool) && (bool)propertyDescriptor.GetValue(designerHost.RootComponent))
{
this.SerializeControlHierarchy(manager, designerHost, value);
}
}
CodeStatementCollection codeStatementCollection = obj as CodeStatementCollection;
if (codeStatementCollection != null)
{
Control control = (Control)value;
if ((designerHost != null && control == designerHost.RootComponent) || this.HasSitedNonReadonlyChildren(control))
{
this.SerializeSuspendLayout(manager, codeStatementCollection, value);
this.SerializeResumeLayout(manager, codeStatementCollection, value);
ControlDesigner controlDesigner = designerHost.GetDesigner(control) as ControlDesigner;
var serializePerformLayoutProp = typeof(ControlDesigner).GetProperty("SerializePerformLayout", BindingFlags.NonPublic | BindingFlags.Instance);
if (this.HasAutoSizedChildren(control) || (controlDesigner != null && (bool)serializePerformLayoutProp.GetValue(controlDesigner)))
{
this.SerializePerformLayout(manager, codeStatementCollection, value);
}
}
if (this.HasMixedInheritedChildren(control))
{
this.SerializeZOrder(manager, codeStatementCollection, control);
}
}
}
return(obj);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
ToolStripMenuItem item = value as ToolStripMenuItem;
ToolStrip currentParent = item.GetCurrentParent();
if (((item != null) && !item.IsOnDropDown) && ((currentParent != null) && (currentParent.Site == null)))
{
return null;
}
CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer(typeof(ImageList).BaseType, typeof(CodeDomSerializer));
return serializer.Serialize(manager, value);
}
public override object Deserialize(
IDesignerSerializationManager manager, object codeObject)
{
// Simply invoke the base class' method
CodeDomSerializer baseSerializer = manager.GetSerializer(
typeof(FlowChart).BaseType, typeof(CodeDomSerializer)) as CodeDomSerializer;
object obj = baseSerializer.Deserialize(manager, codeObject);
return obj;
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
if ((manager == null) || (value == null))
{
throw new ArgumentNullException((manager == null) ? "manager" : "value");
}
CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (serializer == null)
{
return null;
}
object obj2 = serializer.Serialize(manager, value);
InheritanceAttribute attribute = (InheritanceAttribute) TypeDescriptor.GetAttributes(value)[typeof(InheritanceAttribute)];
InheritanceLevel notInherited = InheritanceLevel.NotInherited;
if (attribute != null)
{
notInherited = attribute.InheritanceLevel;
}
if (notInherited != InheritanceLevel.InheritedReadOnly)
{
IDesignerHost service = (IDesignerHost) manager.GetService(typeof(IDesignerHost));
if (service != null)
{
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(service.RootComponent)["Localizable"];
if (((descriptor != null) && (descriptor.PropertyType == typeof(bool))) && ((bool) descriptor.GetValue(service.RootComponent)))
{
this.SerializeControlHierarchy(manager, service, value);
}
}
CodeStatementCollection statements = obj2 as CodeStatementCollection;
if (statements == null)
{
return obj2;
}
Control parent = (Control) value;
if (((service != null) && (parent == service.RootComponent)) || this.HasSitedNonReadonlyChildren(parent))
{
this.SerializeSuspendLayout(manager, statements, value);
this.SerializeResumeLayout(manager, statements, value);
ControlDesigner designer = service.GetDesigner(parent) as ControlDesigner;
if (this.HasAutoSizedChildren(parent) || ((designer != null) && designer.SerializePerformLayout))
{
this.SerializePerformLayout(manager, statements, value);
}
}
if (this.HasMixedInheritedChildren(parent))
{
this.SerializeZOrder(manager, statements, parent);
}
}
return obj2;
}
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
if ((manager == null) || (codeObject == null))
{
throw new ArgumentNullException((manager == null) ? "manager" : "codeObject");
}
CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (serializer == null)
{
return null;
}
return serializer.Deserialize(manager, codeObject);
}
public virtual object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
object component = null;
if ((manager == null) || (codeObject == null))
{
throw new ArgumentNullException((manager == null) ? "manager" : "codeObject");
}
using (CodeDomSerializerBase.TraceScope("CodeDomSerializer::Deserialize"))
{
CodeExpression expression = codeObject as CodeExpression;
if (expression != null)
{
return base.DeserializeExpression(manager, null, expression);
}
CodeStatementCollection statements = codeObject as CodeStatementCollection;
if (statements != null)
{
foreach (CodeStatement statement in statements)
{
if (component == null)
{
component = this.DeserializeStatementToInstance(manager, statement);
if (component != null)
{
foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(component, new Attribute[] { BrowsableAttribute.Yes }))
{
if ((!descriptor.Attributes.Contains(DesignerSerializationVisibilityAttribute.Hidden) && descriptor.Attributes.Contains(DesignerSerializationVisibilityAttribute.Content)) && !(manager.GetSerializer(descriptor.PropertyType, typeof(CodeDomSerializer)) is CollectionCodeDomSerializer))
{
this.ResetBrowsableProperties(descriptor.GetValue(component));
}
}
}
}
else
{
base.DeserializeStatement(manager, statement);
}
}
return component;
}
if (!(codeObject is CodeStatement))
{
string str = string.Format(CultureInfo.CurrentCulture, "{0}, {1}, {2}", new object[] { typeof(CodeExpression).Name, typeof(CodeStatement).Name, typeof(CodeStatementCollection).Name });
throw new ArgumentException(System.Design.SR.GetString("SerializerBadElementTypes", new object[] { codeObject.GetType().Name, str }));
}
}
return component;
}
CodeMemberMethod FindInitializeComponentMethod(IDesignerHost host, IDesignerSerializationManager serializationManager)
{
this.serializationManager = serializationManager;
object rootComponent = host.RootComponent;
TypeCodeDomSerializer serializer = serializationManager.GetSerializer(rootComponent.GetType(), typeof(TypeCodeDomSerializer)) as TypeCodeDomSerializer;
CodeTypeDeclaration typeDec = serializer.Serialize(serializationManager, rootComponent, host.Container.Components) as CodeTypeDeclaration;
foreach (CodeTypeMember member in typeDec.Members) {
CodeMemberMethod method = member as CodeMemberMethod;
if (method != null) {
if (method.Name == "InitializeComponent") {
return method;
}
}
}
return null;
}
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
if ((manager == null) || (codeObject == null))
{
throw new ArgumentNullException((manager == null) ? "manager" : "codeObject");
}
IContainer service = (IContainer) manager.GetService(typeof(IContainer));
ArrayList list = null;
if (service != null)
{
list = new ArrayList(service.Components.Count);
foreach (IComponent component in service.Components)
{
Control control = component as Control;
if (control != null)
{
control.SuspendLayout();
list.Add(control);
}
}
}
object obj2 = null;
try
{
CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (serializer == null)
{
return null;
}
obj2 = serializer.Deserialize(manager, codeObject);
}
finally
{
if (list != null)
{
foreach (Control control2 in list)
{
control2.ResumeLayout(false);
}
}
}
return obj2;
}
/// <summary>
/// Serializes the specified object into a CodeDOM object.
/// </summary>
/// <param name="manager">The serialization manager to use during serialization.</param>
/// <param name="value">The object to serialize.</param>
/// <returns>
/// A CodeDOM object representing the object that has been serialized.
/// </returns>
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(ImageListView).BaseType, typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
CodeExpression imageListViewCode = base.SerializeToExpression(manager, value);
if (imageListViewCode != null && value is ImageListView)
{
int index = 0;
foreach (ImageListView.ImageListViewColumnHeader column in ((ImageListView)value).Columns)
{
if (!(column.Text == column.DefaultText &&
column.Width == ImageListView.DefaultColumnWidth &&
column.DisplayIndex == index &&
((index < 4) == column.Visible)))
{
CodeMethodInvokeExpression columnSetCode = new CodeMethodInvokeExpression(imageListViewCode,
"SetColumnHeader",
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(ColumnType)), Enum.GetName(typeof(ColumnType), column.Type)),
new CodePrimitiveExpression(column.Text),
new CodePrimitiveExpression(column.Width),
new CodePrimitiveExpression(column.DisplayIndex),
new CodePrimitiveExpression(column.Visible)
);
if (column.Text == column.DefaultText)
columnSetCode.Parameters.RemoveAt(1);
statements.Add(columnSetCode);
}
index++;
}
}
return codeObject;
}
return base.Serialize(manager, value);
}
protected override void PerformLoad (IDesignerSerializationManager manager)
{
if (manager == null)
throw new ArgumentNullException ("manager");
CodeCompileUnit document = this.Parse ();
if (document == null)
throw new NotSupportedException ("The language did not provide a code parser for this file");
string namespaceName = null;
CodeTypeDeclaration rootDocument = ExtractFirstCodeTypeDecl (document, out namespaceName);
if (rootDocument == null)
throw new InvalidOperationException ("Cannot find a declaration in a namespace to load.");
_rootSerializer = manager.GetSerializer (manager.GetType (rootDocument.Name),
typeof (RootCodeDomSerializer)) as CodeDomSerializer;
if (_rootSerializer == null)
throw new InvalidOperationException ("Serialization not supported for this class");
_rootSerializer.Deserialize (manager, rootDocument);
base.SetBaseComponentClassName (namespaceName + "." + rootDocument.Name);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseClassSerializer = (CodeDomSerializer)manager.
GetSerializer(typeof(BindingManager).BaseType, typeof(CodeDomSerializer));
object codeObject = baseClassSerializer.Serialize(manager, value);
if(codeObject is CodeStatementCollection && value is BindingManager) {
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
BindingManager bindingManager = (BindingManager)value;
foreach(var action in bindingManager.GetValueActions()) {
CodeMethodInvokeExpression methodInvoke = GetSetValueExpression(manager, bindingManager, action);
statements.Add(methodInvoke);
}
foreach(var action in bindingManager.GetBindingActions()) {
CodeMethodInvokeExpression methodInvoke = GetSetBindingExpression(manager, bindingManager, action);
statements.Add(methodInvoke);
}
}
return codeObject;
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeDomSerializer baseSerializer =
(CodeDomSerializer)manager.GetSerializer(
typeof(Component),
typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements =
(CodeStatementCollection)codeObject;
CodeExpression targetObject =
base.SerializeToReferenceExpression(manager, value);
if (targetObject != null)
{
statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(targetObject, "Owner"),
new CodeThisReferenceExpression()));
}
}
return codeObject;
}
/// <summary>
/// Deserializes the specified serialized CodeDOM object into an object.
/// </summary>
/// <param name="manager">A serialization manager interface that is used during the deserialization process.</param>
/// <param name="codeObject">A serialized CodeDOM object to deserialize.</param>
/// <returns>The deserialized CodeDOM object.</returns>
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(ImageListView).BaseType, typeof(CodeDomSerializer));
return baseSerializer.Deserialize(manager, codeObject);
}
private CodeDomSerializer GetBaseSerializer(IDesignerSerializationManager manager)
{
return (CodeDomSerializer) manager.GetSerializer(typeof(TableLayoutPanel).BaseType, typeof(CodeDomSerializer));
}
private void SerializeContentProperty(IDesignerSerializationManager manager, object value, PropertyDescriptor property, bool isExtender, CodeStatementCollection statements)
{
bool flag;
object presetValue = this.GetPropertyValue(manager, property, value, out flag);
CodeDomSerializer serializer = null;
if (presetValue == null)
{
string name = manager.GetName(value);
if (name == null)
{
name = value.GetType().FullName;
}
manager.ReportError(System.Design.SR.GetString("SerializerNullNestedProperty", new object[] { name, property.Name }));
}
else
{
serializer = (CodeDomSerializer) manager.GetSerializer(presetValue.GetType(), typeof(CodeDomSerializer));
if (serializer != null)
{
CodeExpression targetObject = base.SerializeToExpression(manager, value);
if (targetObject != null)
{
CodeExpression expression = null;
if (isExtender)
{
ExtenderProvidedPropertyAttribute attribute = (ExtenderProvidedPropertyAttribute) property.Attributes[typeof(ExtenderProvidedPropertyAttribute)];
CodeExpression expression3 = base.SerializeToExpression(manager, attribute.Provider);
CodeExpression expression4 = base.SerializeToExpression(manager, value);
if ((expression3 != null) && (expression4 != null))
{
CodeMethodReferenceExpression expression5 = new CodeMethodReferenceExpression(expression3, "Get" + property.Name);
CodeMethodInvokeExpression expression6 = new CodeMethodInvokeExpression {
Method = expression5
};
expression6.Parameters.Add(expression4);
expression = expression6;
}
}
else
{
expression = new CodePropertyReferenceExpression(targetObject, property.Name);
}
if (expression != null)
{
ExpressionContext context = new ExpressionContext(expression, property.PropertyType, value, presetValue);
manager.Context.Push(context);
object obj3 = null;
try
{
SerializeAbsoluteContext context2 = (SerializeAbsoluteContext) manager.Context[typeof(SerializeAbsoluteContext)];
if (base.IsSerialized(manager, presetValue, context2 != null))
{
obj3 = base.GetExpression(manager, presetValue);
}
else
{
obj3 = serializer.Serialize(manager, presetValue);
}
}
finally
{
manager.Context.Pop();
}
CodeStatementCollection statements2 = obj3 as CodeStatementCollection;
if (statements2 == null)
{
CodeStatement statement2 = obj3 as CodeStatement;
if (statement2 != null)
{
statements.Add(statement2);
}
}
else
{
foreach (CodeStatement statement in statements2)
{
statements.Add(statement);
}
}
}
}
}
else
{
manager.ReportError(System.Design.SR.GetString("SerializerNoSerializerForComponent", new object[] { property.PropertyType.FullName }));
}
}
}
private void SerializeContentProperty (IDesignerSerializationManager manager, object instance,
PropertyDescriptor descriptor, CodeStatementCollection statements)
{
CodePropertyReferenceExpression propRef = new CodePropertyReferenceExpression ();
propRef.PropertyName = descriptor.Name;
object propertyValue = descriptor.GetValue (instance);
ExpressionContext expressionCtx = manager.Context[typeof (ExpressionContext)] as ExpressionContext;
if (expressionCtx != null && expressionCtx.PresetValue == instance)
propRef.TargetObject = expressionCtx.Expression;
else
propRef.TargetObject = base.SerializeToExpression (manager, instance);
CodeDomSerializer serializer = manager.GetSerializer (propertyValue.GetType (), typeof (CodeDomSerializer)) as CodeDomSerializer;
if (propRef.TargetObject != null && serializer != null) {
manager.Context.Push (new ExpressionContext (propRef, propRef.GetType (), null, propertyValue));
object serialized = serializer.Serialize (manager, propertyValue);
manager.Context.Pop ();
CodeStatementCollection serializedStatements = serialized as CodeStatementCollection;
if (serializedStatements != null)
statements.AddRange (serializedStatements);
CodeStatement serializedStatement = serialized as CodeStatement;
if (serializedStatement != null)
statements.Add (serializedStatement);
CodeExpression serializedExpr = serialized as CodeExpression;
if (serializedExpr != null)
statements.Add (new CodeAssignStatement (propRef, serializedExpr));
}
}
public override object Deserialize(IDesignerSerializationManager manager, object codeDomObject) {
var baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(ResourceManagerSetter).BaseType, typeof(CodeDomSerializer));
return baseSerializer.Deserialize(manager, codeDomObject);
}
private CodeDomSerializer GetBaseSerializer(IDesignerSerializationManager manager)
{
return (CodeDomSerializer) manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
}
private object DeserializeEntry (IDesignerSerializationManager manager, ObjectEntry objectEntry)
{
object deserialized = null;
if (objectEntry.IsEntireObject) {
CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer (objectEntry.Type,
typeof (CodeDomSerializer));
if (serializer != null) {
deserialized = serializer.Deserialize (manager, objectEntry.Serialized);
// check if the name of the object has changed
// (if it e.g clashes with another name)
string newName = manager.GetName (deserialized);
if (newName != objectEntry.Name)
objectEntry.Name = newName;
}
} else {
foreach (MemberEntry memberEntry in objectEntry.Members.Values) {
CodeDomSerializer serializer = (CodeDomSerializer) manager.GetSerializer (objectEntry.Type,
typeof (CodeDomSerializer));
if (serializer != null)
serializer.Deserialize (manager, memberEntry.Serialized);
}
}
return deserialized;
}
object SerializeRow(IDesignerSerializationManager manager, CodeExpression target, Row row)
{
object codeObject = null;
ExpressionContext context = null;
ExpressionContext context2 = manager.Context[typeof(ExpressionContext)] as ExpressionContext;
CodeMethodInvokeExpression codeIndexer = new CodeMethodInvokeExpression(target, "GetAt", new CodePrimitiveExpression(row.Index));
if (context2 != null)
{
//CodeIndexerExpression codeIndexer = new CodeIndexerExpression(target, new CodePrimitiveExpression(row.Index));
context = new ExpressionContext(codeIndexer, typeof(RowCollection), context2.PresetValue, row);
manager.Context.Push(context);
}
try
{
CodeDomSerializer rowSerialzier = (CodeDomSerializer)manager.GetSerializer(row.GetType(), typeof(CodeDomSerializer));
//codeObject = rowSerialzier.Serialize(manager, row);
codeObject = rowSerialzier.SerializeAbsolute(manager, row);
}
finally
{
foreach (Cell item in row.Cells)
{
object cellCodeObject = SerializeCell(manager, codeIndexer, item);
if(cellCodeObject is CodeStatementCollection && codeObject is CodeStatementCollection)
{
(codeObject as CodeStatementCollection).AddRange(cellCodeObject as CodeStatementCollection);
}
}
if (context != null)
{
manager.Context.Pop();
}
}
return codeObject;
}
object SerializeCell(IDesignerSerializationManager manager, CodeExpression target, Cell cell)
{
object codeObject = null;
ExpressionContext context = null;
ExpressionContext context2 = manager.Context[typeof(ExpressionContext)] as ExpressionContext;
if (context2 != null)
{
CodeMethodInvokeExpression codeIndexer = new CodeMethodInvokeExpression(target, "GetAt", new CodePrimitiveExpression(cell.Column.Index));
context = new ExpressionContext(codeIndexer, typeof(RowCollection), context2.PresetValue, cell);
manager.Context.Push(context);
}
try
{
CodeDomSerializer rowSerialzier = (CodeDomSerializer)manager.GetSerializer(cell.GetType(), typeof(CodeDomSerializer));
//codeObject = rowSerialzier.Serialize(manager, row);
codeObject = rowSerialzier.SerializeAbsolute(manager, cell);
}
finally
{
if (context != null)
{
manager.Context.Pop();
}
}
return codeObject;
}
protected CodeDomSerializer GetSerializer (IDesignerSerializationManager manager, Type instanceType)
{
return manager.GetSerializer (instanceType, typeof (CodeDomSerializer)) as CodeDomSerializer;
}
protected void SerializeEvent (IDesignerSerializationManager manager, CodeStatementCollection statements,
object value, EventDescriptor descriptor)
{
if (descriptor == null)
throw new ArgumentNullException ("descriptor");
if (value == null)
throw new ArgumentNullException ("value");
if (statements == null)
throw new ArgumentNullException ("statements");
if (manager == null)
throw new ArgumentNullException ("manager");
MemberCodeDomSerializer serializer = manager.GetSerializer (descriptor.GetType (), typeof (MemberCodeDomSerializer)) as MemberCodeDomSerializer;
if (serializer != null && serializer.ShouldSerialize (manager, value, descriptor))
serializer.Serialize (manager, value, descriptor, statements);
}
protected void SerializeProperty (IDesignerSerializationManager manager, CodeStatementCollection statements,
object value, PropertyDescriptor propertyToSerialize)
{
if (propertyToSerialize == null)
throw new ArgumentNullException ("propertyToSerialize");
if (value == null)
throw new ArgumentNullException ("value");
if (statements == null)
throw new ArgumentNullException ("statements");
if (manager == null)
throw new ArgumentNullException ("manager");
MemberCodeDomSerializer serializer = manager.GetSerializer (propertyToSerialize.GetType (),
typeof (MemberCodeDomSerializer)) as MemberCodeDomSerializer;
if (serializer != null && serializer.ShouldSerialize (manager, value, propertyToSerialize))
serializer.Serialize (manager, value, propertyToSerialize, statements);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
var baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(SharedImageCollection), typeof(CodeDomSerializer));
object codeObject = baseSerializer.Serialize(manager, value);
// remove all generated code except for the member initialization
CodeStatementCollection coll = codeObject as CodeStatementCollection;
if (coll != null)
{
for (int i=coll.Count-1; i>=0; i--)
{
CodeStatement ex = coll[i];
var ass = ex as CodeAssignStatement;
if (ass == null || !(ass.Left is CodeFieldReferenceExpression))
coll.RemoveAt(i);
}
}
return codeObject;
}
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
var baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(SharedImageCollection), typeof(CodeDomSerializer));
return baseSerializer.Deserialize(manager, codeObject);
}
public override object Serialize(IDesignerSerializationManager manager, object obj)
{
if (manager == null)
throw new ArgumentNullException("manager");
if (manager.Context == null)
throw new ArgumentException("manager", SR.GetString(SR.Error_MissingContextProperty));
if (obj == null)
throw new ArgumentNullException("obj");
DependencyObject dependencyObject = obj as DependencyObject;
if (dependencyObject == null)
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(DependencyObject).FullName), "obj");
Activity activity = obj as Activity;
if (activity != null)
manager.Context.Push(activity);
CodeStatementCollection retVal = null;
try
{
if (activity != null)
{
CodeDomSerializer componentSerializer = manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer)) as CodeDomSerializer;
if (componentSerializer == null)
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(CodeDomSerializer).FullName));
retVal = componentSerializer.Serialize(manager, activity) as CodeStatementCollection;
}
else
{
retVal = base.Serialize(manager, obj) as CodeStatementCollection;
}
if (retVal != null)
{
CodeStatementCollection codeStatements = new CodeStatementCollection(retVal);
CodeExpression objectExpression = SerializeToExpression(manager, obj);
if (objectExpression != null)
{
ArrayList propertiesSerialized = new ArrayList();
List<DependencyProperty> dependencyProperties = new List<DependencyProperty>(dependencyObject.MetaDependencyProperties);
foreach (DependencyProperty dp in dependencyObject.DependencyPropertyValues.Keys)
{
if (dp.IsAttached)
{
if ((dp.IsEvent && dp.OwnerType.GetField(dp.Name + "Event", BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly) != null) ||
(!dp.IsEvent && dp.OwnerType.GetField(dp.Name + "Property", BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly) != null))
dependencyProperties.Add(dp);
}
}
foreach (DependencyProperty dependencyProperty in dependencyProperties)
{
object value = null;
if (dependencyObject.IsBindingSet(dependencyProperty))
value = dependencyObject.GetBinding(dependencyProperty);
else if (!dependencyProperty.IsEvent)
value = dependencyObject.GetValue(dependencyProperty);
else
value = dependencyObject.GetHandler(dependencyProperty);
// Attached property should always be set through SetValue, no matter if it's a meta property or if there is a data context.
// Other meta properties will be directly assigned.
// Other instance property will go through SetValue if there is a data context or if it's of type Bind.
if (value != null &&
(dependencyProperty.IsAttached || (!dependencyProperty.DefaultMetadata.IsMetaProperty && value is ActivityBind)))
{
object[] attributes = dependencyProperty.DefaultMetadata.GetAttributes(typeof(DesignerSerializationVisibilityAttribute));
if (attributes.Length > 0)
{
DesignerSerializationVisibilityAttribute serializationVisibilityAttribute = attributes[0] as DesignerSerializationVisibilityAttribute;
if (serializationVisibilityAttribute.Visibility == DesignerSerializationVisibility.Hidden)
continue;
}
// Events of type Bind will go through here. Regular events will go through IEventBindingService.
CodeExpression param1 = null;
string dependencyPropertyName = dependencyProperty.Name + ((dependencyProperty.IsEvent) ? "Event" : "Property");
FieldInfo fieldInfo = dependencyProperty.OwnerType.GetField(dependencyPropertyName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
if (fieldInfo != null && !fieldInfo.IsPublic)
param1 = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(DependencyProperty)), "FromName", new CodePrimitiveExpression(dependencyProperty.Name), new CodeTypeOfExpression(dependencyProperty.OwnerType));
else
param1 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(dependencyProperty.OwnerType), dependencyPropertyName);
CodeExpression param2 = SerializeToExpression(manager, value);
//Fields property fails to serialize to expression due to reference not being created,
//the actual code for fields are generated in datacontext code generator so we do nothing here
if (param1 != null && param2 != null)
{
CodeMethodInvokeExpression codeMethodInvokeExpr = null;
if (value is ActivityBind)
codeMethodInvokeExpr = new CodeMethodInvokeExpression(objectExpression, "SetBinding", new CodeExpression[] { param1, new CodeCastExpression(new CodeTypeReference(typeof(ActivityBind)), param2) });
else
codeMethodInvokeExpr = new CodeMethodInvokeExpression(objectExpression, (dependencyProperty.IsEvent) ? "AddHandler" : "SetValue", new CodeExpression[] { param1, param2 });
retVal.Add(codeMethodInvokeExpr);
// Remove the property set statement for the event which is replaced by the SetValue() expression.
foreach (CodeStatement statement in codeStatements)
{
if (statement is CodeAssignStatement && ((CodeAssignStatement)statement).Left is CodePropertyReferenceExpression)
{
CodePropertyReferenceExpression prop = ((CodeAssignStatement)statement).Left as CodePropertyReferenceExpression;
if (prop.PropertyName == dependencyProperty.Name && prop.TargetObject.Equals(objectExpression))
retVal.Remove(statement);
}
}
}
propertiesSerialized.Add(dependencyProperty);
}
}
IEventBindingService eventBindingService = manager.GetService(typeof(IEventBindingService)) as IEventBindingService;
if (eventBindingService == null)
{
// At compile time, we don't have an event binding service. We need to mannually emit the code to add
// event handlers.
foreach (EventDescriptor eventDesc in TypeDescriptor.GetEvents(dependencyObject))
{
string handler = WorkflowMarkupSerializationHelpers.GetEventHandlerName(dependencyObject, eventDesc.Name);
if (!string.IsNullOrEmpty(handler))
{
CodeEventReferenceExpression eventRef = new CodeEventReferenceExpression(objectExpression, eventDesc.Name);
CodeDelegateCreateExpression listener = new CodeDelegateCreateExpression(new CodeTypeReference(eventDesc.EventType), new CodeThisReferenceExpression(), handler);
retVal.Add(new CodeAttachEventStatement(eventRef, listener));
}
}
}
// We also need to handle properties of type System.Type. If the value is a design time type, xomlserializer
// is not going to be able to deserialize the type. We then store the type name in the user data and
// output a "typeof(xxx)" expression using the type name w/o validating the type.
if (dependencyObject.UserData.Contains(UserDataKeys.DesignTimeTypeNames))
{
Hashtable typeNames = dependencyObject.UserData[UserDataKeys.DesignTimeTypeNames] as Hashtable;
foreach (object key in typeNames.Keys)
{
string propName = null;
string ownerTypeName = null;
string typeName = typeNames[key] as string;
DependencyProperty dependencyProperty = key as DependencyProperty;
if (dependencyProperty != null)
{
if (propertiesSerialized.Contains(dependencyProperty))
continue;
object[] attributes = dependencyProperty.DefaultMetadata.GetAttributes(typeof(DesignerSerializationVisibilityAttribute));
if (attributes.Length > 0)
{
DesignerSerializationVisibilityAttribute serializationVisibilityAttribute = attributes[0] as DesignerSerializationVisibilityAttribute;
if (serializationVisibilityAttribute.Visibility == DesignerSerializationVisibility.Hidden)
continue;
}
propName = dependencyProperty.Name;
ownerTypeName = dependencyProperty.OwnerType.FullName;
}
else if (key is string)
{
int indexOfDot = ((string)key).LastIndexOf('.');
Debug.Assert(indexOfDot != -1, "Wrong property name in DesignTimeTypeNames hashtable.");
if (indexOfDot != -1)
{
ownerTypeName = ((string)key).Substring(0, indexOfDot);
propName = ((string)key).Substring(indexOfDot + 1);
}
}
if (!string.IsNullOrEmpty(typeName) && !string.IsNullOrEmpty(propName) && !string.IsNullOrEmpty(ownerTypeName))
{
if (ownerTypeName == obj.GetType().FullName)
{
// Property is not an attached property. Serialize using regular property set expression.
CodePropertyReferenceExpression propertyRef = new CodePropertyReferenceExpression(objectExpression, propName);
retVal.Add(new CodeAssignStatement(propertyRef, new CodeTypeOfExpression(typeName)));
}
else
{
// This is an attached property. Serialize using SetValue() expression.
CodeExpression param1 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(ownerTypeName), propName + "Property");
CodeExpression param2 = new CodeTypeOfExpression(typeName);
retVal.Add(new CodeMethodInvokeExpression(objectExpression, "SetValue", new CodeExpression[] { param1, param2 }));
}
}
}
}
}
}
}
finally
{
if (activity != null)
{
object pushedActivity = manager.Context.Pop();
System.Diagnostics.Debug.Assert(pushedActivity == activity);
}
}
return retVal;
}
