public object Serialize(System.Collections.ICollection objects)
{
ComponentSerializationService componentSerializationService = _serviceProvider.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
SerializationStore returnObject = null;
using (SerializationStore serializationStore = componentSerializationService.CreateStore())
{
foreach (object obj in objects)
{
if (obj is Control control)
{
//if (control is SMGroup group)
//{
// foreach (object obj2 in control.Controls)
// {
// componentSerializationService.Serialize(serializationStore, obj2);
// }
//}
//if(control is SplitContainerControl split)
//{
// componentSerializationService.SerializeAbsolute(serializationStore, split.Panel1.Controls[0]);
// componentSerializationService.SerializeAbsolute(serializationStore, split.Panel2.Controls[0]);
//}
componentSerializationService.SerializeAbsolute(serializationStore, obj);
}
returnObject = serializationStore;
}
}
return(returnObject);
}
public static IDataObject SerializeActivitiesToDataObject(IServiceProvider serviceProvider, ICollection activities)
{
// get component serialization service
ComponentSerializationService css = (ComponentSerializationService)serviceProvider.GetService(typeof(ComponentSerializationService));
if (css == null)
{
throw new InvalidOperationException("Component Serialization Service is missing.");
}
// serialize all activities to the store
SerializationStore store = css.CreateStore();
using (store)
{
foreach (Activity activity in activities)
{
css.Serialize(store, activity);
}
}
// wrap it with clipboard style object
Stream stream = new MemoryStream();
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, store);
stream.Seek(0, SeekOrigin.Begin);
return(new DataObject(CF_DESIGNER, stream));
}
public System.Collections.ICollection Deserialize(object obj)
{
// string data = File.ReadAllText("save.txt");
MemoryStream fs = obj as MemoryStream;
if (fs != null)
{
ComponentSerializationService componentSerializationService = _serviceProvider.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
SerializationStore serializationStore = componentSerializationService.LoadStore(fs);
ICollection collection = componentSerializationService.Deserialize(serializationStore);
fs.Close();
return(collection);
}
else
{
SerializationStore serializationStore = obj as SerializationStore;
if (serializationStore != null)
{
ComponentSerializationService componentSerializationService = _serviceProvider.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
ICollection collection = componentSerializationService.Deserialize(serializationStore);
return(collection);
}
}
return(new object[] { });
}
public System.Collections.ICollection Deserialize ( object serializationData ) {
SerializationStore serializationStore = serializationData as SerializationStore;
if ( serializationStore != null ) {
ComponentSerializationService componentSerializationService = _serviceProvider.GetService ( typeof ( ComponentSerializationService ) ) as ComponentSerializationService;
ICollection collection = componentSerializationService.Deserialize ( serializationStore );
return collection;
}
return new object[] {};
}
/// <summary>
/// Deserializes the serialization data object and returns a
/// collection of objects represented by that data.
/// </summary>
public ICollection Deserialize(object serializationData)
{
IDesignerHost host = (IDesignerHost)this.serviceProvider.GetService(typeof(IDesignerHost));
if (host != null)
{
ComponentSerializationService serializationService = (ComponentSerializationService)serviceProvider.GetService(typeof(ComponentSerializationService));
return(serializationService.Deserialize((SerializationStore)serializationData, host.Container));
}
return(null);
}
public ICollection Deserialize(object serializationData)
{
SerializationStore serializationStore = serializationData as SerializationStore;
if (serializationStore != null)
{
ComponentSerializationService componentSerializationService = this.serviceProvider.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
return(componentSerializationService.Deserialize(serializationStore));
}
return(new object[0]);
}
private void serializeSubControls(ComponentSerializationService componentSerializationService, SerializationStore serializationStore, Control c)
{
if (c.Controls.Count > 0)
{
foreach (Control c0 in c.Controls)
{
componentSerializationService.Serialize(serializationStore, c0);
serializeSubControls(componentSerializationService, serializationStore, c0);
}
}
}
/// <summary>
/// Serializes a collection of objects and stores them in a
/// serialization data object.
/// </summary>
public object Serialize(ICollection objects)
{
ComponentSerializationService serializationService = (ComponentSerializationService)serviceProvider.GetService(typeof(ComponentSerializationService));
SerializationStore store = serializationService.CreateStore();
foreach (object value in objects)
{
serializationService.Serialize(store, value);
}
store.Close();
return(store);
}
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 object Serialize ( System.Collections.ICollection objects ) {
ComponentSerializationService componentSerializationService = _serviceProvider.GetService ( typeof ( ComponentSerializationService ) ) as ComponentSerializationService;
SerializationStore returnObject = null;
using ( SerializationStore serializationStore = componentSerializationService.CreateStore() ) {
foreach ( object obj in objects ) {
if ( obj is Control )
componentSerializationService.Serialize ( serializationStore, obj );
}
returnObject = serializationStore;
}
return returnObject;
}
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;
}
/// <summary>
/// Serializes a collection of objects and stores them in a
/// serialization data object.
/// </summary>
public object Serialize(ICollection objects)
{
if (objects == null)
{
throw new ArgumentNullException("objects");
}
ComponentSerializationService serializationService = (ComponentSerializationService)serviceProvider.GetService(typeof(ComponentSerializationService));
SerializationStore store = serializationService.CreateStore();
foreach (object value in objects)
{
serializationService.Serialize(store, value);
}
store.Close();
return(store);
}
public static ICollection CopyDragObjects(ICollection objects, IServiceProvider svcProvider)
{
if ((objects != null) && (svcProvider != null))
{
Cursor current = Cursor.Current;
try
{
Cursor.Current = Cursors.WaitCursor;
ComponentSerializationService service = svcProvider.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
IDesignerHost host = svcProvider.GetService(typeof(IDesignerHost)) as IDesignerHost;
if ((service != null) && (host != null))
{
SerializationStore store = null;
store = service.CreateStore();
foreach (IComponent component in GetCopySelection(objects, host))
{
service.Serialize(store, component);
}
store.Close();
ICollection is2 = service.Deserialize(store);
ArrayList list = new ArrayList(objects.Count);
foreach (IComponent component2 in is2)
{
Control control = component2 as Control;
if ((control != null) && (control.Parent == null))
{
list.Add(component2);
}
else if (control == null)
{
ToolStripItem item = component2 as ToolStripItem;
if ((item != null) && (item.GetCurrentParent() == null))
{
list.Add(component2);
}
}
}
return(list);
}
}
finally
{
Cursor.Current = current;
}
}
return(null);
}
public override void Undo (UndoEngine engine)
{
IDesignerHost host = engine.GetRequiredService (typeof (IDesignerHost)) as IDesignerHost;
if (_added) {
// Console.WriteLine ("Component*Add*RemoveAction.Undo (" + _componentName + ")");
IComponent component = host.Container.Components[_componentName];
if (component != null) // the component might have been destroyed already
host.DestroyComponent (component);
_added = false;
} else {
// Console.WriteLine ("ComponentAdd*Remove*Action.Undo (" + _componentName + ")");
ComponentSerializationService serializationService = engine.GetRequiredService (
typeof (ComponentSerializationService)) as ComponentSerializationService;
serializationService.DeserializeTo (_serializedComponent, host.Container);
_added = true;
}
}
public object Serialize(ICollection objects)
{
ComponentSerializationService componentSerializationService = this.serviceProvider.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
SerializationStore result = null;
using (SerializationStore serializationStore = componentSerializationService.CreateStore())
{
foreach (object obj in objects)
{
if (obj is Control)
{
componentSerializationService.Serialize(serializationStore, obj);
}
}
result = serializationStore;
}
return(result);
}
// 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 object Serialize(ICollection objects)
{
ComponentSerializationService componentSerializationService = this.serviceProvider.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
using (SerializationStore serializationStore = componentSerializationService.CreateStore())
{
foreach (object obj in objects)
{
if (obj is Control)
{
((Control)obj).Name = null;
((Control)obj).Name = null;
((Control)obj).Name = "";
((Control)obj).Name = "fdhgh";
componentSerializationService.Serialize(serializationStore, obj);
}
}
return(serializationStore);
}
}
public object Serialize(ICollection objects)
{
ComponentSerializationService componentSerializationService = serviceProvider.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
SerializationStore returnObject = null;
using (SerializationStore serializationStore = componentSerializationService.CreateStore())
{
foreach (object obj in objects)
{
Control c = obj as Control;
if (c != null)
{
componentSerializationService.Serialize(serializationStore, obj);
serializeSubControls(componentSerializationService, serializationStore, c);
}
}
returnObject = serializationStore;
}
return(returnObject);
}
protected UndoEngine(IServiceProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
this._provider = provider;
this._unitStack = new Stack();
this._enabled = true;
this._host = this.GetRequiredService(typeof(IDesignerHost)) as IDesignerHost;
this._componentChangeService = this.GetRequiredService(typeof(IComponentChangeService)) as IComponentChangeService;
this._serializationService = this.GetRequiredService(typeof(ComponentSerializationService)) as ComponentSerializationService;
this._host.TransactionOpening += new EventHandler(this.OnTransactionOpening);
this._host.TransactionClosed += new DesignerTransactionCloseEventHandler(this.OnTransactionClosed);
this._componentChangeService.ComponentAdding += new ComponentEventHandler(this.OnComponentAdding);
this._componentChangeService.ComponentChanging += new ComponentChangingEventHandler(this.OnComponentChanging);
this._componentChangeService.ComponentRemoving += new ComponentEventHandler(this.OnComponentRemoving);
this._componentChangeService.ComponentAdded += new ComponentEventHandler(this.OnComponentAdded);
this._componentChangeService.ComponentChanged += new ComponentChangedEventHandler(this.OnComponentChanged);
this._componentChangeService.ComponentRemoved += new ComponentEventHandler(this.OnComponentRemoved);
this._componentChangeService.ComponentRename += new ComponentRenameEventHandler(this.OnComponentRename);
}
public static Activity[] DeserializeActivitiesFromDataObject(IServiceProvider serviceProvider, IDataObject dataObj, bool addReference)
{
IDesignerHost designerHost = (IDesignerHost)serviceProvider.GetService(typeof(IDesignerHost));
if (designerHost == null)
{
throw new InvalidOperationException("IDesignerHost is missing.");
}
if (dataObj == null)
{
return new Activity[] { }
}
;
object data = dataObj.GetData(CF_DESIGNER);
ICollection activities = null;
if (data is Stream)
{
BinaryFormatter formatter = new BinaryFormatter();
((Stream)data).Seek(0, SeekOrigin.Begin);
object serializationData = formatter.Deserialize((Stream)data);
if (serializationData is SerializationStore)
{
// get component serialization service
ComponentSerializationService css = serviceProvider.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
if (css == null)
{
throw new Exception("ComponentSerializationService is missing.");
}
// deserialize data
activities = css.Deserialize((SerializationStore)serializationData);
}
}
else
{
// Now check for a toolbox item.
IToolboxService ts = (IToolboxService)serviceProvider.GetService(typeof(IToolboxService));
if (ts != null && ts.IsSupported(dataObj, designerHost))
{
ToolboxItem toolBoxItem = ts.DeserializeToolboxItem(dataObj, designerHost);
if (toolBoxItem != null)
{
// this will make sure that we add the assembly reference to project
if (addReference && toolBoxItem.AssemblyName != null)
{
ITypeResolutionService trs = serviceProvider.GetService(typeof(ITypeResolutionService)) as ITypeResolutionService;
if (trs != null)
{
trs.ReferenceAssembly(toolBoxItem.AssemblyName);
}
}
ActivityToolboxItem ActivityToolboxItem = toolBoxItem as ActivityToolboxItem;
if (addReference && ActivityToolboxItem != null)
{
activities = ActivityToolboxItem.CreateComponentsWithUI(designerHost);
}
else
{
activities = toolBoxItem.CreateComponents(designerHost);
}
}
}
}
return((activities != null) ? (Activity[])(new ArrayList(activities).ToArray(typeof(Activity))) : new Activity[] { });
}
internal virtual System.Windows.Forms.ToolStripItem MorphCurrentItem(System.Type t)
{
System.Windows.Forms.ToolStripItem component = null;
IDesignerHost host = (IDesignerHost)this.GetService(typeof(IDesignerHost));
if (host != null)
{
DesignerTransaction transaction = host.CreateTransaction(System.Design.SR.GetString("ToolStripMorphingItemTransaction"));
ToolStrip immediateParent = (ToolStrip)this.ImmediateParent;
if (immediateParent is ToolStripOverflow)
{
immediateParent = this.ToolStripItem.Owner;
}
ToolStripMenuItemDesigner designer = null;
int index = immediateParent.Items.IndexOf(this.ToolStripItem);
string name = this.ToolStripItem.Name;
System.Windows.Forms.ToolStripItem ownerItem = null;
if (this.ToolStripItem.IsOnDropDown)
{
ToolStripDropDown down = this.ImmediateParent as ToolStripDropDown;
if (down != null)
{
ownerItem = down.OwnerItem;
if (ownerItem != null)
{
designer = (ToolStripMenuItemDesigner)host.GetDesigner(ownerItem);
}
}
}
try
{
ToolStripDesigner._autoAddNewItems = false;
ComponentSerializationService service = this.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
SerializationStore store = null;
if (service != null)
{
store = service.CreateStore();
service.Serialize(store, base.Component);
SerializationStore store2 = null;
ToolStripDropDownItem toolStripItem = this.ToolStripItem as ToolStripDropDownItem;
if ((toolStripItem != null) && typeof(ToolStripDropDownItem).IsAssignableFrom(t))
{
toolStripItem.HideDropDown();
store2 = service.CreateStore();
this.SerializeDropDownItems(toolStripItem, ref store2, service);
store2.Close();
}
store.Close();
IComponentChangeService service2 = (IComponentChangeService)this.GetService(typeof(IComponentChangeService));
if (service2 != null)
{
if (immediateParent.Site != null)
{
service2.OnComponentChanging(immediateParent, TypeDescriptor.GetProperties(immediateParent)["Items"]);
}
else if (ownerItem != null)
{
service2.OnComponentChanging(ownerItem, TypeDescriptor.GetProperties(ownerItem)["DropDownItems"]);
service2.OnComponentChanged(ownerItem, TypeDescriptor.GetProperties(ownerItem)["DropDownItems"], null, null);
}
}
this.FireComponentChanging(toolStripItem);
immediateParent.Items.Remove(this.ToolStripItem);
host.DestroyComponent(this.ToolStripItem);
System.Windows.Forms.ToolStripItem item4 = (System.Windows.Forms.ToolStripItem)host.CreateComponent(t, name);
if ((item4 is ToolStripDropDownItem) && (store2 != null))
{
service.Deserialize(store2);
}
service.DeserializeTo(store, host.Container, false, true);
component = (System.Windows.Forms.ToolStripItem)host.Container.Components[name];
if ((component.Image == null) && (component is ToolStripButton))
{
Image image = null;
try
{
image = new Bitmap(typeof(ToolStripButton), "blank.bmp");
}
catch (Exception exception)
{
if (System.Windows.Forms.ClientUtils.IsCriticalException(exception))
{
throw;
}
}
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(component)["Image"];
if ((descriptor != null) && (image != null))
{
descriptor.SetValue(component, image);
}
PropertyDescriptor descriptor2 = TypeDescriptor.GetProperties(component)["DisplayStyle"];
if (descriptor2 != null)
{
descriptor2.SetValue(component, ToolStripItemDisplayStyle.Image);
}
PropertyDescriptor descriptor3 = TypeDescriptor.GetProperties(component)["ImageTransparentColor"];
if (descriptor3 != null)
{
descriptor3.SetValue(component, Color.Magenta);
}
}
immediateParent.Items.Insert(index, component);
if (service2 != null)
{
if (immediateParent.Site != null)
{
service2.OnComponentChanged(immediateParent, TypeDescriptor.GetProperties(immediateParent)["Items"], null, null);
}
else if (ownerItem != null)
{
service2.OnComponentChanging(ownerItem, TypeDescriptor.GetProperties(ownerItem)["DropDownItems"]);
service2.OnComponentChanged(ownerItem, TypeDescriptor.GetProperties(ownerItem)["DropDownItems"], null, null);
}
}
this.FireComponentChanged(toolStripItem);
if (component.IsOnDropDown && (designer != null))
{
designer.RemoveItemBodyGlyph(component);
designer.AddItemBodyGlyph(component);
}
ToolStripDesigner._autoAddNewItems = true;
if (component != null)
{
if (component is ToolStripSeparator)
{
immediateParent.PerformLayout();
}
BehaviorService service3 = (BehaviorService)component.Site.GetService(typeof(BehaviorService));
if (service3 != null)
{
service3.Invalidate();
}
ISelectionService service4 = (ISelectionService)component.Site.GetService(typeof(ISelectionService));
if (service4 != null)
{
service4.SetSelectedComponents(new object[] { component }, SelectionTypes.Replace);
}
}
}
return(component);
}
catch
{
host.Container.Add(this.ToolStripItem);
immediateParent.Items.Insert(index, this.ToolStripItem);
if (transaction != null)
{
transaction.Cancel();
transaction = null;
}
}
finally
{
if (transaction != null)
{
transaction.Commit();
transaction = null;
}
}
}
return(component);
}
public void ComponentSerializationServiceCreated()
{
ComponentSerializationService serializationService = (ComponentSerializationService)loaderHost.GetService(typeof(ComponentSerializationService));
Assert.IsTrue(serializationService is ComponentSerializationService);
}
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);
}
}
}
}
/// <summary>
/// Used to create copies of the objects that we are dragging in a drag operation
/// </summary>
public static ICollection CopyDragObjects(ICollection objects, IServiceProvider svcProvider)
{
if (objects == null || svcProvider == null)
{
Debug.Fail("Invalid parameter passed to DesignerUtils.CopyObjects.");
return(null);
}
Cursor oldCursor = Cursor.Current;
try
{
Cursor.Current = Cursors.WaitCursor;
ComponentSerializationService css = svcProvider.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
IDesignerHost host = svcProvider.GetService(typeof(IDesignerHost)) as IDesignerHost;
Debug.Assert(css != null, "No component serialization service -- we cannot copy the objects");
Debug.Assert(host != null, "No host -- we cannot copy the objects");
if (css != null && host != null)
{
SerializationStore store = null;
store = css.CreateStore();
// Get all the objects, meaning we want the children too
ICollection copyObjects = GetCopySelection(objects, host);
// The serialization service does not (yet) handle serializing collections
foreach (IComponent comp in copyObjects)
{
css.Serialize(store, comp);
}
store.Close();
copyObjects = css.Deserialize(store);
// Now, copyObjects contains a flattened list of all the controls contained in the original drag objects, that's not what we want to return.
// We only want to return the root drag objects, so that the caller gets an identical copy - identical in terms of objects.Count
ArrayList newObjects = new ArrayList(objects.Count);
foreach (IComponent comp in copyObjects)
{
Control c = comp as Control;
if (c != null && c.Parent == null)
{
newObjects.Add(comp);
}
else if (c == null)
{ // this happens when we are dragging a toolstripitem
// TODO: Can we remove the ToolStrip specific code?
if (comp is ToolStripItem item && item.GetCurrentParent() == null)
{
newObjects.Add(comp);
}
}
}
Debug.Assert(newObjects.Count == objects.Count, "Why is the count of the copied objects not the same?");
return(newObjects);
}
}
finally
{
Cursor.Current = oldCursor;
}
return(null);
}
/// <summary>
/// Deserializes the serialization data object and returns a
/// collection of objects represented by that data.
/// </summary>
public ICollection Deserialize(object serializationData)
{
ComponentSerializationService serializationService = (ComponentSerializationService)serviceProvider.GetService(typeof(ComponentSerializationService));
return(serializationService.Deserialize((SerializationStore)serializationData));
}
