public override ICollection Deserialize(SerializationStore store)
{
if (store == null) throw new ArgumentNullException("store");
WorkflowMarkupSerializationStore xomlStore = store as WorkflowMarkupSerializationStore;
if (xomlStore == null) throw new InvalidOperationException(SR.GetString(SR.Error_UnknownSerializationStore));
return (ICollection)xomlStore.Deserialize(this.serviceProvider);
}
public override void Serialize(SerializationStore store, object value)
{
if (store == null) throw new ArgumentNullException("store");
if (value == null) throw new ArgumentNullException("value");
WorkflowMarkupSerializationStore xomlStore = store as WorkflowMarkupSerializationStore;
if (xomlStore == null) throw new InvalidOperationException(SR.GetString(SR.Error_UnknownSerializationStore));
xomlStore.AddObject(value);
}
public override void SerializeMember(SerializationStore store, object owningObject, MemberDescriptor member)
{
if (store == null) throw new ArgumentNullException("store");
if (owningObject == null) throw new ArgumentNullException("owningObject");
if (member == null) throw new ArgumentNullException("member");
WorkflowMarkupSerializationStore xomlStore = store as WorkflowMarkupSerializationStore;
if (xomlStore == null) throw new InvalidOperationException(SR.GetString(SR.Error_UnknownSerializationStore));
xomlStore.AddMember(owningObject, member);
}
public override ICollection Deserialize(SerializationStore store)
{
if (store == null)
{
throw new ArgumentNullException("store");
}
CodeDomSerializationStore store2 = store as CodeDomSerializationStore;
if (store2 == null)
{
throw new InvalidOperationException(System.Design.SR.GetString("CodeDomComponentSerializationServiceUnknownStore"));
}
return store2.Deserialize(this._provider);
}
public override ICollection Deserialize(SerializationStore store)
{
if (store == null)
{
throw new ArgumentNullException("store");
}
WorkflowMarkupSerializationStore store2 = store as WorkflowMarkupSerializationStore;
if (store2 == null)
{
throw new InvalidOperationException(SR.GetString("Error_UnknownSerializationStore"));
}
return store2.Deserialize(this.serviceProvider);
}
ICollection IDesignerSerializationService.Deserialize(object serializationData)
{
if (serializationData == null)
{
throw new ArgumentNullException("serializationData");
}
ComponentSerializationService service = LoaderHost.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
SerializationStore store = serializationData as SerializationStore;
if (service != null && serializationData != null)
{
return(service.Deserialize(store, this.LoaderHost.Container));
}
return(new object[0]);
}
public override void DeserializeTo(SerializationStore store, IContainer container, bool validateRecycledTypes, bool applyDefaults)
{
if (store == null)
{
throw new ArgumentNullException("store");
}
if (container == null)
{
throw new ArgumentNullException("container");
}
WorkflowMarkupSerializationStore store2 = store as WorkflowMarkupSerializationStore;
if (store2 == null)
{
throw new InvalidOperationException(SR.GetString("Error_UnknownSerializationStore"));
}
store2.DeserializeTo(this.serviceProvider, container);
}
public override void DeserializeTo(SerializationStore store, IContainer container, bool validateRecycledTypes, bool applyDefaults)
{
if (store == null)
{
throw new ArgumentNullException("store");
}
if (container == null)
{
throw new ArgumentNullException("container");
}
CodeDomSerializationStore store2 = store as CodeDomSerializationStore;
if (store2 == null)
{
throw new InvalidOperationException(System.Design.SR.GetString("CodeDomComponentSerializationServiceUnknownStore"));
}
store2.DeserializeTo(this._provider, container, validateRecycledTypes, applyDefaults);
}
private void SerializeCore(SerializationStore store, object value, bool absolute)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (store == null)
{
throw new ArgumentNullException("store");
}
CodeDomSerializationStore codeDomStore = store as CodeDomSerializationStore;
if (store == null)
{
throw new InvalidOperationException("store type unsupported");
}
codeDomStore.AddObject(value, absolute);
}
object IDesignerSerializationService.Serialize(ICollection objects)
{
if (objects == null)
{
throw new ArgumentNullException("objects");
}
ComponentSerializationService service = LoaderHost.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
if (service != null)
{
SerializationStore store = service.CreateStore();
foreach (object o in objects)
{
service.Serialize(store, o);
}
store.Close();
return(store);
}
return(null);
}
private void SerializeMemberCore(SerializationStore store, object owningObject, MemberDescriptor member, bool absolute)
{
if (member == null)
{
throw new ArgumentNullException("member");
}
if (owningObject == null)
{
throw new ArgumentNullException("owningObject");
}
if (store == null)
{
throw new ArgumentNullException("store");
}
CodeDomSerializationStore codeDomStore = store as CodeDomSerializationStore;
if (codeDomStore == null)
{
throw new InvalidOperationException("store type unsupported");
}
codeDomStore.AddMember(owningObject, member, absolute);
}
public void DeserializeTo(SerializationStore store, IContainer container)
{
DeserializeTo(store, container, true, true);
}
/// <summary> /// Normal serialization only serializes values that differ from the component's default state. /// This provides the most compact serialization mechanism but assumes that during deserilalization /// a new, freshly created object will be used. If an existing object is used properties that /// contained default values during serialization would not be reset back to their defaults. /// The SerializeAbsolute method does not require this assumption on the deserializing end. /// Instead, it saves data in the serialization store about default values as well so that /// deserialization can reset non-default properties back to their default values. This is /// especially true for collection objects, where the collections are either cleared and /// items re-added, or individual items are removed and added. /// </summary> public abstract void SerializeAbsolute(SerializationStore store, object value);
public abstract void Serialize(SerializationStore store, Object value);
private void SerializeMemberCore (SerializationStore store, object owningObject, MemberDescriptor member, bool absolute)
{
if (member == null)
throw new ArgumentNullException ("member");
if (owningObject == null)
throw new ArgumentNullException ("owningObject");
if (store == null)
throw new ArgumentNullException ("store");
CodeDomSerializationStore codeDomStore = store as CodeDomSerializationStore;
if (codeDomStore == null)
throw new InvalidOperationException ("store type unsupported");
codeDomStore.AddMember (owningObject, member, absolute);
}
public override void SerializeMemberAbsolute(SerializationStore store, object owningObject, MemberDescriptor member)
{
throw null;
}
public abstract System.Collections.ICollection Deserialize(SerializationStore store, System.ComponentModel.IContainer container);
public abstract System.Collections.ICollection Deserialize(SerializationStore store);
public override void DeserializeTo(SerializationStore store, IContainer container, bool validateRecycledTypes, bool applyDefaults)
{
throw null;
}
public void DeserializeTo(SerializationStore store, System.ComponentModel.IContainer container)
{
}
public abstract void DeserializeTo(SerializationStore store, System.ComponentModel.IContainer container, bool validateRecycledTypes, bool applyDefaults);
private void SaveAfterState(UndoEngine engine)
{
object component = null;
IReferenceService service = engine.GetService(typeof(IReferenceService)) as IReferenceService;
if (service != null)
{
component = service.GetReference(this._componentName);
}
else
{
IDesignerHost host = engine.GetService(typeof(IDesignerHost)) as IDesignerHost;
if (host != null)
{
component = host.Container.Components[this._componentName];
}
}
if (component != null)
{
this._after = this.Serialize(engine, component, this._member);
}
}
public void DeserializeTo(SerializationStore store, IContainer container)
{
DeserializeTo(store, container, validateRecycledTypes: true, applyDefaults: true);
}
public abstract void SerializeMemberAbsolute(SerializationStore store, Object owningObject, System.ComponentModel.MemberDescriptor member);
/// <summary> /// This method deserializes the given store to produce a collection of /// objects contained within it. If a container is provided, objects /// that are created that implement IComponent will be added to the container. /// </summary> public abstract ICollection Deserialize(SerializationStore store);
public override ICollection Deserialize (SerializationStore store)
{
return this.Deserialize (store, null);
}
// error CS0534: 'System.Workflow.ComponentModel.Design.XomlComponentSerializationService' does not implement inherited abstract member 'System.ComponentModel.Design.Serialization.ComponentSerializationService.SerializeAbsolute(System.ComponentModel.Design.Serialization.SerializationStore, object)'
public override void SerializeAbsolute(SerializationStore store, object value)
{
this.Serialize(store, value);
}
public override void DeserializeTo (SerializationStore store, IContainer container, bool validateRecycledTypes, bool applyDefaults)
{
DeserializeCore (store, container, validateRecycledTypes, applyDefaults);
}
public void SetModifiedState (UndoEngine engine, IComponent component, MemberDescriptor member)
{
// Console.WriteLine ("ComponentChangeAction.SetModifiedState (" + (_componentName != null ? (_componentName + ".") : "") +
// member.Name + "): " +
// (((PropertyDescriptor)member).GetValue (component) == null ? "null" :
// ((PropertyDescriptor)member).GetValue (component).ToString ()));
ComponentSerializationService serializationService = engine.GetRequiredService (
typeof (ComponentSerializationService)) as ComponentSerializationService;
_afterChange = serializationService.CreateStore ();
serializationService.SerializeMemberAbsolute (_afterChange, component, member);
_afterChange.Close ();
}
public override void Serialize (SerializationStore store, object value)
{
SerializeCore (store, value, false);
}
public override void SerializeMemberAbsolute(SerializationStore store, object owningObject, MemberDescriptor member)
{
SerializeMemberCore(store, owningObject, member, true);
}
public override void SerializeMemberAbsolute (SerializationStore store, object owningObject, MemberDescriptor member)
{
SerializeMemberCore (store, owningObject, member, true);
}
/// <summary> /// This method deserializes the given store, but rather than produce /// new objects, the data in the store is applied to an existing /// set of objects that are taken from the provided container. This /// allows the caller to pre-create an object however it sees fit. If /// an object has deserialization state and the object is not named in /// the set of existing objects, a new object will be created. If that /// object also implements IComponent, it will be added to the given /// container. Objects in the container must have names that /// match objects in the serialization store in order for an existing /// object to be used. If validateRecycledTypes is true it is guaranteed /// that the deserialization will only work if applied to an object of the /// same type. /// </summary> public abstract void DeserializeTo(SerializationStore store, IContainer container, bool validateRecycledTypes, bool applyDefaults);
public void DeserializeTo(SerializationStore store, System.ComponentModel.IContainer container, bool validateRecycledTypes)
{
}
public void DeserializeTo(SerializationStore store, IContainer container)
{
DeserializeTo(store, container, true, true);
}
public void DeserializeTo(SerializationStore store, IContainer container, bool validateRecycledTypes)
{
DeserializeTo(store, container, validateRecycledTypes, true);
}
public override ICollection Deserialize (SerializationStore store, IContainer container)
{
return DeserializeCore (store, container, true, true);
}
/// <summary> /// Normal serialization only serializes values that differ from the component's default state. /// This provides the most compact serialization mechanism but assumes that during deserilalization /// a new, freshly created object will be used. If an existing object is used properties that /// contained default values during serialization would not be reset back to their defaults. /// The SerializeAbsolute method does not require this assumption on the deserializing end. /// Instead, it saves data in the serialization store about default values as well so that /// deserialization can reset non-default properties back to their default values. This is /// especially true for collection objects, where the collections are either cleared and /// items re-added, or individual items are removed and added. /// </summary> public abstract void SerializeAbsolute(SerializationStore store, object value);
private ICollection DeserializeCore (SerializationStore store, IContainer container, bool validateRecycledTypes,
bool applyDefaults)
{
CodeDomSerializationStore codeDomStore = store as CodeDomSerializationStore;
if (codeDomStore == null)
throw new InvalidOperationException ("store type unsupported");
return codeDomStore.Deserialize (_provider, container, validateRecycledTypes, applyDefaults);
}
/// <summary> /// This method serializes the given member on the given object, /// but also serializes the member if it contains the default value. /// Note that for some members, containing the default value and setting /// the same value back to the member are different concepts. For example, /// if a property inherits its value from a parent object if no local value /// is set, setting the value back to the property can may not be what is desired. /// SerializeMemberAbsolute takes this into account and would clear the state of /// the property in this case. /// </summary> public abstract void SerializeMemberAbsolute(SerializationStore store, object owningObject, MemberDescriptor member);
public override void SerializeAbsolute (SerializationStore store, object value)
{
SerializeCore (store, value, true);
}
/// <summary> /// This method deserializes the given store to produce a collection of /// objects contained within it. If a container is provided, objects /// that are created that implement IComponent will be added to the container. /// </summary> public abstract ICollection Deserialize(SerializationStore store);
private void SerializeCore (SerializationStore store, object value, bool absolute)
{
if (value == null)
throw new ArgumentNullException ("value");
if (store == null)
throw new ArgumentNullException ("store");
CodeDomSerializationStore codeDomStore = store as CodeDomSerializationStore;
if (store == null)
throw new InvalidOperationException ("store type unsupported");
codeDomStore.AddObject (value, absolute);
}
/// <summary> /// This method deserializes the given store to produce a collection of /// objects contained within it. If a container is provided, objects /// that are created that implement IComponent will be added to the container. /// </summary> public abstract ICollection Deserialize(SerializationStore store, IContainer container);
/// <summary> /// This method deserializes the given store, but rather than produce /// new objects, the data in the store is applied to an existing /// set of objects that are taken from the provided container. This /// allows the caller to pre-create an object however it sees fit. If /// an object has deserialization state and the object is not named in /// the set of existing objects, a new object will be created. If that /// object also implements IComponent, it will be added to the given /// container. Objects in the container must have names that /// match objects in the serialization store in order for an existing /// object to be used. If validateRecycledTypes is true it is guaranteed /// that the deserialization will only work if applied to an object of the /// same type. /// </summary> public abstract void DeserializeTo(SerializationStore store, IContainer container, bool validateRecycledTypes, bool applyDefaults);
private void SerializeDropDownItems(ToolStripDropDownItem parent, ref SerializationStore _serializedDataForDropDownItems, ComponentSerializationService _serializationService)
{
foreach (System.Windows.Forms.ToolStripItem item in parent.DropDownItems)
{
if (!(item is DesignerToolStripControlHost))
{
_serializationService.Serialize(_serializedDataForDropDownItems, item);
ToolStripDropDownItem item2 = item as ToolStripDropDownItem;
if (item2 != null)
{
this.SerializeDropDownItems(item2, ref _serializedDataForDropDownItems, _serializationService);
}
}
}
}
public void DeserializeTo(SerializationStore store, IContainer container, bool validateRecycledTypes)
{
DeserializeTo(store, container, validateRecycledTypes, true);
}
public override ICollection Deserialize(SerializationStore store)
{
return(this.Deserialize(store, null));
}
/// <summary> /// This method serializes the given member on the given object, /// but also serializes the member if it contains the default value. /// Note that for some members, containing the default value and setting /// the same value back to the member are different concepts. For example, /// if a property inherits its value from a parent object if no local value /// is set, setting the value back to the property can may not be what is desired. /// SerializeMemberAbsolute takes this into account and would clear the state of /// the property in this case. /// </summary> public abstract void SerializeMemberAbsolute(SerializationStore store, object owningObject, MemberDescriptor member);
//error CS0534: 'System.Workflow.ComponentModel.Design.XomlComponentSerializationService' does not implement inherited abstract member 'System.ComponentModel.Design.Serialization.ComponentSerializationService.SerializeMemberAbsolute(System.ComponentModel.Design.Serialization.SerializationStore, object, System.ComponentModel.MemberDescriptor)'
public override void SerializeMemberAbsolute(SerializationStore store, object owningObject, MemberDescriptor member)
{
this.SerializeMember(store, owningObject, member);
}
/// <summary> /// This method deserializes the given store to produce a collection of /// objects contained within it. If a container is provided, objects /// that are created that implement IComponent will be added to the container. /// </summary> public abstract ICollection Deserialize(SerializationStore store, IContainer container);
public override ICollection Deserialize(SerializationStore store)
{
throw null;
}
public override ICollection Deserialize(SerializationStore store, IContainer container)
{
return(DeserializeCore(store, container, true, true));
}
public override ICollection Deserialize(SerializationStore store, IContainer container)
{
throw null;
}
public override void DeserializeTo(SerializationStore store, IContainer container, bool validateRecycledTypes, bool applyDefaults)
{
DeserializeCore(store, container, validateRecycledTypes, applyDefaults);
}
public override void Serialize(SerializationStore store, object value)
{
SerializeCore(store, value, false);
}
public ComponentAddRemoveAction (UndoEngine engine, IComponent component, bool added)
{
if (component == null)
throw new ArgumentNullException ("component");
// Console.WriteLine ((added ? "Component*Add*RemoveAction" : "ComponentAdd*Remove*Action") +
// " (" + component.Site.Name + ")");
ComponentSerializationService serializationService = engine.GetRequiredService (
typeof (ComponentSerializationService)) as ComponentSerializationService;
_serializedComponent = serializationService.CreateStore ();
serializationService.Serialize (_serializedComponent, component);
_serializedComponent.Close ();
_added = added;
_componentName = component.Site.Name;
}
public override void SerializeAbsolute(SerializationStore store, object value)
{
SerializeCore(store, value, true);
}
// Reminder: _component might no longer be a valid instance
// so one should request a new one.
//
public override void Undo (UndoEngine engine)
{
if (_beforeChange == null) {
// Console.WriteLine ("ComponentChangeAction.Undo: ERROR: UndoUnit is not complete.");
return;
}
// Console.WriteLine ("ComponentChangeAction.Undo (" + _componentName + "." + _member.Name + ")");
IDesignerHost host = (IDesignerHost)engine.GetRequiredService (typeof(IDesignerHost));
_component = host.Container.Components[_componentName];
ComponentSerializationService serializationService = engine.GetRequiredService (
typeof (ComponentSerializationService)) as ComponentSerializationService;
serializationService.DeserializeTo (_beforeChange, host.Container);
SerializationStore tmp = _beforeChange;
_beforeChange = _afterChange;
_afterChange = tmp;
}
public override void SerializeAbsolute(SerializationStore store, object value)
{
throw null;
}
