Files
mono/mcs/class/System.Design/System.ComponentModel.Design.Serialization/RootCodeDomSerializer.cs
T
Ivan Zlatev 23c5583323 2007-10-24 Ivan N. Zlatev <[email protected]>
* CodeDomSerializerBase.cs: 
         - Implement deserialization of CodeCastExpression.
         - Add error reporting.
        * PropertyCodeDomSerializer.cs: Error reporting.
        * BasicDesignerLoader.cs: 
         - Unload only if loaded.
         - Error reporting.
        * RootCodeDomSerializer.cs: Push the Root context during 
        deserialization.


svn path=/trunk/mcs/; revision=88084
2007-10-24 16:47:29 +00:00

280 lines
8.5 KiB
C#

//
// System.ComponentModel.Design.Serialization.RootCodeDomSerializer
//
// Authors:
// Ivan N. Zlatev (contact i-nZ.net)
//
// (C) 2007 Ivan N. Zlatev
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
#if NET_2_0
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.CodeDom;
namespace System.ComponentModel.Design.Serialization
{
internal class RootCodeDomSerializer : CodeDomSerializer
{
internal class CodeMap
{
private string _className;
private Type _classType;
private List<CodeMemberField> _fields;
private CodeStatementCollection _preInit;
private CodeStatementCollection _init;
private CodeStatementCollection _postInit;
public CodeMap (Type classType, string className)
{
if (classType == null)
throw new ArgumentNullException ("classType");
if (className == null)
throw new ArgumentNullException ("className");
_classType = classType;
_className = className;
_fields = new List<CodeMemberField> ();
_preInit = new CodeStatementCollection ();
_init = new CodeStatementCollection ();
_init = new CodeStatementCollection ();
_postInit = new CodeStatementCollection ();
}
public void AddField (CodeMemberField field)
{
_fields.Add (field);
}
public void AddPreInitStatement (CodeStatement statement)
{
_preInit.Add (statement);
}
public void AddInitStatement (CodeStatement statement)
{
_init.Add (statement);
}
public void AddInitStatements (CodeStatementCollection statements)
{
_init.AddRange (statements);
}
public void AddPostInitStatement (CodeStatement statement)
{
_postInit.Add (statement);
}
/*
class Type : BaseType
{
#region Windows Form Designer generated code
private void InitializeComponent ()
{
preInit;
init;
postInit;
}
private field1;
private field2;
#endregion
}
*/
public CodeTypeDeclaration GenerateClass ()
{
CodeTypeDeclaration clas = new CodeTypeDeclaration (_className);
clas.BaseTypes.Add (_classType);
clas.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Windows Form Designer generated code"));
CodeMemberMethod initialize = new CodeMemberMethod ();
initialize.Name = "InitializeComponent";
initialize.ReturnType = new CodeTypeReference (typeof (void));
initialize.Attributes = MemberAttributes.Private;
initialize.Statements.AddRange (_preInit);
initialize.Statements.AddRange (_init);
initialize.Statements.AddRange (_postInit);
clas.Members.Add (initialize);
foreach (CodeMemberField field in _fields)
clas.Members.Add (field);
clas.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, null));
return clas;
}
public void Clear ()
{
_preInit.Clear ();
_init.Clear ();
_postInit.Clear ();
_fields.Clear ();
}
}
private CodeMap _codeMap;
public RootCodeDomSerializer ()
{
}
public override object Serialize (IDesignerSerializationManager manager, object value)
{
if (manager == null)
throw new ArgumentNullException ("manager");
if (value == null)
throw new ArgumentNullException ("value");
if (_codeMap == null)
_codeMap = new CodeMap (value.GetType (), manager.GetName (value));
_codeMap.Clear ();
RootContext rootContext = new RootContext (new CodeThisReferenceExpression (), value);
manager.Context.Push (rootContext);
this.SerializeComponents (manager, ((IComponent) value).Site.Container.Components, (IComponent) value);
// Serialize root component
//
CodeStatementCollection statements = new CodeStatementCollection ();
statements.Add (new CodeCommentStatement (String.Empty));
statements.Add (new CodeCommentStatement (manager.GetName (value)));
statements.Add (new CodeCommentStatement (String.Empty));
// Note that during the serialization process below ComponentCodeDomSerializer
// will be invoked to serialize the rootcomponent during expression serialization.
// It will check for RootContext and return that.
base.SerializeProperties (manager, statements, value, new Attribute[0]);
base.SerializeEvents (manager, statements, value, new Attribute[0]);
_codeMap.AddInitStatements (statements);
manager.Context.Pop ();
return _codeMap.GenerateClass ();
}
private void SerializeComponents (IDesignerSerializationManager manager, ICollection components, IComponent rootComponent)
{
foreach (IComponent component in components) {
if (!Object.ReferenceEquals (component, rootComponent)) {
manager.Context.Push (new ExpressionContext (null, null, rootComponent, component));
SerializeComponent (manager, component);
manager.Context.Pop ();
}
}
}
private void SerializeComponent (IDesignerSerializationManager manager, IComponent component)
{
CodeDomSerializer serializer = base.GetSerializer (manager, component) as CodeDomSerializer; // ComponentCodeDomSerializer
if (serializer != null) {
this.Code.AddField (new CodeMemberField (component.GetType (), manager.GetName (component)));
CodeStatementCollection statements = (CodeStatementCollection) serializer.Serialize (manager, component);
CodeStatement ctorStatement = ExtractCtorStatement (manager, statements, component);
if (ctorStatement != null)
Code.AddPreInitStatement (ctorStatement);
Code.AddInitStatements (statements);
}
}
internal CodeMap Code {
get { return _codeMap; }
}
// Used to remove the ctor from the statement colletion in order for the ctor statement to be moved.
//
private CodeStatement ExtractCtorStatement (IDesignerSerializationManager manager, CodeStatementCollection statements,
object component)
{
CodeStatement result = null;
CodeAssignStatement assignment = null;
CodeObjectCreateExpression ctor = null;
int toRemove = -1;
for (int i=0; i < statements.Count; i++) {
assignment = statements[i] as CodeAssignStatement;
if (assignment != null) {
ctor = assignment.Right as CodeObjectCreateExpression;
if (ctor != null && manager.GetType (ctor.CreateType.BaseType) == component.GetType ()) {
result = assignment;
toRemove = i;
}
}
}
if (toRemove != -1)
statements.RemoveAt (toRemove);
return result;
}
public override object Deserialize (IDesignerSerializationManager manager, object codeObject)
{
CodeTypeDeclaration declaration = (CodeTypeDeclaration) codeObject;
Type rootType = manager.GetType (declaration.BaseTypes[0].BaseType);
object root = manager.CreateInstance (rootType, null, declaration.Name, true);
RootContext rootContext = new RootContext (new CodeThisReferenceExpression (), root);
manager.Context.Push (rootContext);
CodeMemberMethod initComponentMethod = GetInitializeMethod (declaration);
if (initComponentMethod == null)
throw new InvalidOperationException ("InitializeComponent method is missing in: " + declaration.Name);
foreach (CodeStatement statement in initComponentMethod.Statements)
base.DeserializeStatement (manager, statement);
manager.Context.Pop ();
return root;
}
private CodeMemberMethod GetInitializeMethod (CodeTypeDeclaration declaration)
{
CodeMemberMethod method = null;
foreach (CodeTypeMember member in declaration.Members) {
method = member as CodeMemberMethod;
if (method != null && method.Name == "InitializeComponent")
break;
}
return method;
}
}
}
#endif