/// <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));
}
/// <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 Deserialize(IDesignerSerializationManager manager, object codeDomObject)
{
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(ResourceControl).BaseType,
typeof(CodeDomSerializer));
return(baseSerializer.Deserialize(manager, codeDomObject));
}
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 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 tempValue)
{
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer
(
typeof(Alphora.Dataphor.DAE.Client.Controls.GridColumns).BaseType,
typeof(CodeDomSerializer)
);
return(baseSerializer.Deserialize(manager, tempValue));
}
/// <summary>
/// Deserializes a PaletteGroupView object from the code DOM.
/// </summary>
/// <param name="manager"></param>
/// <param name="codeObject"></param>
/// <returns></returns>
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
object retVal = null;
// Get base class serializer
CodeDomSerializer baseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(GroupView), typeof(CodeDomSerializer));
if (baseSerializer != null)
{
// Deserialize palette group view using base class serializer
retVal = baseSerializer.Deserialize(manager, codeObject);
if (retVal != null)
{
// Downcast to PaletteGroupView
PaletteGroupView palGrpVw = retVal as PaletteGroupView;
if (palGrpVw != null)
{
// Load symbol palette from the resource file and attach
// to the palette group view
string resName = palGrpVw.Name + "." + "Palette";
System.ComponentModel.Design.IResourceService resSvc = manager.GetService(typeof(System.ComponentModel.Design.IResourceService)) as System.ComponentModel.Design.IResourceService;
if (resSvc != null)
{
System.Resources.IResourceReader resReader = resSvc.GetResourceReader(System.Globalization.CultureInfo.InvariantCulture);
if (resReader != null)
{
// Iterate through the resource file using the resource
// reader and find the byte stream for the palette
byte[] strmData = null;
bool resFound = false;
IDictionaryEnumerator resEnum = resReader.GetEnumerator();
while (resEnum.MoveNext() && !resFound)
{
if ((string)resEnum.Key == resName)
{
strmData = (byte[])resEnum.Value;
resFound = true;
}
}
if (resFound && strmData != null)
{
palGrpVw.LoadPalette(strmData);
}
}
}
}
}
}
return(retVal);
}
/// <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(Chart).BaseType, typeof(CodeDomSerializer));
if (baseSerializer != null)
{
return(baseSerializer.Deserialize(manager, codeObject));
}
return(null);
}
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 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 override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
CodeDomSerializer serializer = GetSerializer(manager);
if (serializer == null)
{
return(null);
}
var obj1 = serializer.Deserialize(manager, codeObject);
return(obj1);
}
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
CodeDomSerializer LbaseSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(System.ComponentModel.Component), typeof(CodeDomSerializer));
if (codeObject is CodeStatementCollection)
{
CodeStatementCollection statements = (CodeStatementCollection)codeObject;
CodeStatement assignPropertyStatement = GetPropertyAssignStatement(statements, PropertyName);
if (assignPropertyStatement != null)
{
statements.Remove(assignPropertyStatement);
statements.Insert(statements.Count, assignPropertyStatement);
}
}
return(LbaseSerializer.Deserialize(manager, codeObject));
}
public override object Deserialize(IDesignerSerializationManager AManager, object ACodeObject)
{
CodeDomSerializer LbaseSerializer = (CodeDomSerializer)AManager.GetSerializer(typeof(Alphora.Dataphor.DAE.Client.DataSession).BaseType, typeof(CodeDomSerializer));
if (ACodeObject is CodeStatementCollection)
{
CodeStatementCollection LStatements = (CodeStatementCollection)ACodeObject;
CodeStatement LSetActivePropertyStatement = GetPropertyAssignStatement(LStatements, CPropertyName);
if (LSetActivePropertyStatement != null)
{
LStatements.Remove(LSetActivePropertyStatement);
LStatements.Insert(LStatements.Count, LSetActivePropertyStatement);
}
}
return(LbaseSerializer.Deserialize(AManager, ACodeObject));
}
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
if (manager == null || codeObject == null)
{
throw new ArgumentNullException((manager == null) ? "manager" : "codeObject");
}
IContainer container = (IContainer)manager.GetService(typeof(IContainer));
ArrayList arrayList = null;
if (container != null)
{
arrayList = new ArrayList(container.Components.Count);
foreach (IComponent component in container.Components)
{
Control control = component as Control;
if (control != null)
{
control.SuspendLayout();
arrayList.Add(control);
}
}
}
object result = null;
try
{
CodeDomSerializer codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (codeDomSerializer == null)
{
return(null);
}
result = codeDomSerializer.Deserialize(manager, codeObject);
}
finally
{
if (arrayList != null)
{
foreach (Control control2 in arrayList)
{
control2.ResumeLayout(true);
}
}
}
return(result);
}
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>
/// This method takes a CodeDomObject and deserializes into a real object.
/// We don't do anything here.
/// </summary>
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
// REVIEW: Please look at this carefully - This is just copied from ControlCodeDomSerializer
ArgumentNullException.ThrowIfNull(manager);
ArgumentNullException.ThrowIfNull(codeObject);
// Find our base class's serializer.
CodeDomSerializer serializer = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (serializer is null)
{
Debug.Fail("Unable to find a CodeDom serializer for 'Component'. Has someone tampered with the serialization providers?");
return(null);
}
return(serializer.Deserialize(manager, codeObject));
}
/// <include file='doc\ControlCodeDomSerializer.uex' path='docs/doc[@for="ControlCodeDomSerializer.Deserialize"]/*' />
/// <devdoc>
/// 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.
/// </devdoc>
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
if (manager == null || codeObject == null)
{
throw new ArgumentNullException(manager == null ? "manager" : "codeObject");
}
// Find our base class's serializer.
//
CodeDomSerializer serializer = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (serializer == null)
{
Debug.Fail("Unable to find a CodeDom serializer for 'Component'. Has someone tampered with the serialization providers?");
return(null);
}
return(serializer.Deserialize(manager, codeObject));
}
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
object instance = null;
// look for the creation statement.
//
foreach (CodeStatement element in (CodeStatementCollection)codeObject)
{
if (element is CodeVariableDeclarationStatement)
{
CodeVariableDeclarationStatement statement = (CodeVariableDeclarationStatement)element;
// We create the resource manager ouselves here because it's not just a straight
// parse of the code.
//
instance = owner.resourceManager;
manager.SetName(instance, statement.Name);
codeObject = new CodeStatementCollection((CodeStatementCollection)codeObject);
((CodeStatementCollection)codeObject).Remove(element);
}
}
innerSerializer.Deserialize(manager, codeObject);
return(instance);
}
/// <summary>
/// Deserializes 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 override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
ArgumentNullException.ThrowIfNull(manager);
ArgumentNullException.ThrowIfNull(codeObject);
//Attempt to suspend all components within the icontainer
IContainer container = (IContainer)manager.GetService(typeof(IContainer));
ArrayList suspendedComponents = null;
if (container != null)
{
suspendedComponents = new ArrayList(container.Components.Count);
foreach (IComponent comp in container.Components)
{
Control control = comp as Control;
if (control != null)
{
control.SuspendLayout();
//Add this control to our suspended components list so we can resume later
suspendedComponents.Add(control);
}
}
}
object objectGraphData = null;
try
{
// Find our base class's serializer.
CodeDomSerializer serializer = (CodeDomSerializer)manager.GetSerializer(typeof(Component), typeof(CodeDomSerializer));
if (serializer is null)
{
Debug.Fail("Unable to find a CodeDom serializer for 'Component'. Has someone tampered with the serialization providers?");
return(null);
}
objectGraphData = serializer.Deserialize(manager, codeObject);
}
finally
{
//resume all suspended comps we found earlier
if (suspendedComponents != null)
{
foreach (Control c in suspendedComponents)
{
// .NET Framework 4.0 (Dev10 #462211): Controls in design time may change their size due to incorrectly
// calculated anchor info.
// UNDONE: c.ResumeLayout(false) because it regressed layouts with Dock property
// see Dev11 bug 117530 DTS Winforms: Upgraded project -Control location and size are changed in the designer gen'd code
c.ResumeLayout(performLayout: true);
}
}
}
return(objectGraphData);
}
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);
}
/// <include file='doc\DesignerSerializationObject.uex' path='docs/doc[@for="DesignerSerializationObject.Deserialize"]/*' />
/// <devdoc>
/// Returns the original collection of objects, deserializing
/// them from saved state if necessary.
/// </devdoc>
public ICollection Deserialize(IDesignerSerializationManager manager, CodeDomSerializer rootSerializer)
{
// If we have a set of objects, and we don't have
// any code that needs to be deserialized, then
// we're done.
//
if (objects != null && code == null)
{
return(objects);
}
// If we need to deserialize, we just ask the real serialization manager for
// the root serializer, and we let it party on the code. The result is
// going to be a (hopefully) non-null containerComponents object whose
// values contain all the components we were interested in.
//
this.manager = manager;
ArrayList components = null;
try {
#if DEBUG
if (traceDSO.TraceVerbose)
{
Debug.WriteLine("Deserializing:");
Debug.Indent();
GenerateCodeFromSerializedData(code);
Debug.Unindent();
}
#endif
rootSerializer.Deserialize(this, code);
}
finally {
if (serializationCompleteEventHandler != null)
{
try {
serializationCompleteEventHandler(this, EventArgs.Empty);
}
catch {}
}
this.manager = null;
resolveNameEventHandler = null;
serializationCompleteEventHandler = null;
designerSerializationProviders = null;
instancesByName = null;
namesByInstance = null;
contextStack = null;
components = containerComponents;
containerComponents = null;
}
// If we got some compnents into our container, get 'em out!
//
if (components != null)
{
// The designer host's root object will be sitting in this
// container, because the root serializer believes that it
// created an instance of it. Remove this object here because
// it is not actually a part of the serialization work.
//
IDesignerHost host = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if (host != null && components.Contains(host.RootComponent))
{
components.Remove(host.RootComponent);
}
object[] finalObjects = new object[objects.Length + components.Count];
objects.CopyTo(finalObjects, 0);
components.CopyTo(finalObjects, objects.Length);
objects = finalObjects;
if (host != null)
{
this.componentChangeSvc = (IComponentChangeService)host.GetService(typeof(IComponentChangeService));
if (this.componentChangeSvc != null)
{
this.componentChangeSvc.ComponentAdded += new ComponentEventHandler(this.OnComponentAdded);
addedComps = new Hashtable();
foreach (IComponent ic in components)
{
addedComps[ic.Site.Name] = ic;
}
}
}
}
return(objects);
}
/// <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));
}
public override object Deserialize(IDesignerSerializationManager manager, object codeDomObject)
{
CodeDomSerializer codeDomSerializer = (CodeDomSerializer)manager.GetSerializer(typeof(PlotToolBarButton).BaseType, typeof(CodeDomSerializer));
return(codeDomSerializer.Deserialize(manager, codeDomObject));
}
public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
{
CodeDomSerializer serializer1 = (CodeDomSerializer)manager.GetSerializer(this.GetPropType().BaseType, typeof(CodeDomSerializer));
return(serializer1.Deserialize(manager, codeObject));
}
