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; }