mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-16 17:10:20 -10:00
* ParentControlDesigner.cs: implemented.
* IUISelectionService.cs: implemented.
* WndProcRouter.cs: implemented.
* SelectionFrame.cs: implemented.
* ControlDesigner.cs: implemented.
* ControlDataObject.cs: implemented.
* ComponentTray.cs: implemented.
* ScrollableControlDesigner.cs: implemented.
* UISelectionService.cs: implemented.
* SplitContainerDesigner.cs: implemented.
* IMessageReceiver.cs: implemented.
* Native.cs: implemented.
* DocumentDesigner.cs: implemented.
* DefaultSerializationProviderAttribute.cs: implemented.
* ComponentSerializationService.cs: implemented.
* MemberRelationship.cs: implemented.
* SerializationStore.cs: implemented.
* DesignSurfaceManager.cs: implemented.
* DesignerEventService.cs: implemented.
* ComponentDesigner.cs: implemented.
* ActiveDesignSurfaceChangedEventHandler.cs: implemented.
* LoadedEventHandler.cs: implemented.
* DesignSurfaceCollection.cs: implemented.
* DesignerHost.cs: implemented.
* ExtenderService.cs: implemented.
* DesignModeSite.cs: implemented.
* SelectionService.cs: implemented.
* DesignSurfaceServiceContainer.cs: implemented.
* DesignerActionListCollection.cs: implemented.
* ActiveDesignSurfaceChangedEventArgs.cs: implemented.
* LoadedEventArgs.cs: implemented.
* TypeDescriptorFilterService.cs: implemented.
* ReferenceService.cs: implemented.
* DesignSurface.cs: implemented.
* DesignSurfaceEventHandler.cs: implemented.
* DesignModeNestedContainer.cs: implemented.
* EventBindingService.cs: implemented.
* DesignSurfaceEventArgs.cs: implemented.
* DesignerOptionService.cs: implemented.
* ITreeDesigner.cs: implemented.
* CodeDomComponentSerializationService.cs: implemented.
* CollectionCodeDomSerializer.cs: implemented.
* CodeDomDesignerLoader.cs: implemented.
* CodeDomSerializationProvider.cs: implemented.
* ComponentCodeDomSerializer.cs: implemented.
* RootContext.cs: implemented.
* BasicDesignerLoader.cs: implemented.
* DesignerSerializationManager.cs: implemented.
* EnumCodeDomSerializer.cs: implemented.
* SerializeAbsoluteContext.cs: implemented.
* MemberCodeDomSerializer.cs: implemented.
* PrimitiveCodeDomSerializer.cs: implemented.
* CodeDomSerializerBase.cs: implemented.
* CodeDomSerializer.cs: implemented.
* ExpressionContext.cs: implemented.
* EventCodeDomSerializer.cs: implemented.
* TypeCodeDomSerializer.cs: implemented.
* ObjectStatementCollection.cs: implemented.
* RootCodeDomSerializer.cs: implemented.
* PropertyCodeDomSerializer.cs: implemented.
* StatementContext.cs: implemented.
svn path=/trunk/mcs/; revision=85023
162 lines
5.3 KiB
C#
162 lines
5.3 KiB
C#
//
|
|
// System.ComponentModel.Design.Serialization.CollectionCodeDomSerializer
|
|
//
|
|
// 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.Reflection;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design;
|
|
|
|
using System.CodeDom;
|
|
|
|
namespace System.ComponentModel.Design.Serialization
|
|
{
|
|
public class CollectionCodeDomSerializer : CodeDomSerializer
|
|
{
|
|
|
|
public CollectionCodeDomSerializer ()
|
|
{
|
|
}
|
|
|
|
// FIXME: What is this supposed to do?
|
|
protected bool MethodSupportsSerialization (MethodInfo method)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public override object Serialize (IDesignerSerializationManager manager, object value)
|
|
{
|
|
if (value == null)
|
|
throw new ArgumentNullException ("value");
|
|
if (manager == null)
|
|
throw new ArgumentNullException ("manager");
|
|
|
|
ICollection originalCollection = value as ICollection;
|
|
if (originalCollection == null)
|
|
throw new ArgumentException ("originalCollection is not an ICollection");
|
|
|
|
CodeExpression targetExpression = null;
|
|
|
|
ExpressionContext exprContext = manager.Context[typeof (ExpressionContext)] as ExpressionContext;
|
|
RootContext root = manager.Context[typeof (RootContext)] as RootContext;
|
|
|
|
if (exprContext != null && exprContext.PresetValue == value)
|
|
targetExpression = exprContext.Expression;
|
|
else if (root != null)
|
|
targetExpression = root.Expression;
|
|
|
|
ArrayList valuesToSerialize = new ArrayList ();
|
|
foreach (object o in originalCollection)
|
|
valuesToSerialize.Add (o);
|
|
|
|
return this.SerializeCollection (manager, targetExpression, value.GetType (), originalCollection, valuesToSerialize);
|
|
}
|
|
|
|
protected virtual object SerializeCollection (IDesignerSerializationManager manager, CodeExpression targetExpression,
|
|
Type targetType, ICollection originalCollection, ICollection valuesToSerialize)
|
|
{
|
|
if (valuesToSerialize == null)
|
|
throw new ArgumentNullException ("valuesToSerialize");
|
|
if (originalCollection == null)
|
|
throw new ArgumentNullException ("originalCollection");
|
|
if (targetType == null)
|
|
throw new ArgumentNullException ("targetType");
|
|
if (manager == null)
|
|
throw new ArgumentNullException ("manager");
|
|
|
|
if (valuesToSerialize.Count == 0)
|
|
return null;
|
|
|
|
MethodInfo method = null;
|
|
try {
|
|
object sampleParam = null;
|
|
IEnumerator e = valuesToSerialize.GetEnumerator ();
|
|
e.MoveNext ();
|
|
sampleParam = e.Current;
|
|
// try to find a method matching the type of the sample parameter.
|
|
// Assuming objects in the collection are from the same base type
|
|
method = GetExactMethod (targetType, "Add", new object [] { sampleParam });
|
|
} catch {
|
|
Console.WriteLine ("SerializeCollection: No compatible Add method found in " + targetType);
|
|
}
|
|
|
|
if (method == null)
|
|
return null;
|
|
|
|
CodeStatementCollection statements = new CodeStatementCollection ();
|
|
|
|
foreach (object value in valuesToSerialize) {
|
|
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression ();
|
|
methodInvoke.Method = new CodeMethodReferenceExpression (targetExpression, "Add");
|
|
|
|
manager.Context.Push (new ExpressionContext (methodInvoke, methodInvoke.GetType (), null, originalCollection));
|
|
CodeExpression expression = base.SerializeToExpression (manager, value);
|
|
if (expression == null) {
|
|
Console.WriteLine ("SerializeCollection: Unable to serialize " + value);
|
|
methodInvoke = null;
|
|
} else {
|
|
methodInvoke.Parameters.AddRange (new CodeExpression[] { expression });
|
|
}
|
|
manager.Context.Pop ();
|
|
|
|
if (methodInvoke != null)
|
|
statements.Add (methodInvoke);
|
|
}
|
|
|
|
return statements;
|
|
}
|
|
|
|
// Searches for a method on type that matches argument types
|
|
//
|
|
private MethodInfo GetExactMethod (Type type, string methodName, ICollection argsCollection)
|
|
{
|
|
object[] arguments = null;
|
|
Type[] types = new Type[0];
|
|
|
|
if (argsCollection != null) {
|
|
arguments = new object[argsCollection.Count];
|
|
types = new Type[argsCollection.Count];
|
|
argsCollection.CopyTo (arguments, 0);
|
|
|
|
for (int i=0; i < arguments.Length; i++) {
|
|
if (arguments[i] == null)
|
|
types[i] = null;
|
|
else
|
|
types[i] = arguments[i].GetType ();
|
|
}
|
|
}
|
|
|
|
return type.GetMethod (methodName, types);
|
|
}
|
|
}
|
|
}
|
|
#endif
|