// This is the code that is executed when you drop a tool from the Toolbox in the designer.
//
protected static void InvokeCreateTool(ParentControlDesigner toInvoke, ToolboxItem tool)
{
if (toInvoke != null)
{
toInvoke.CreateTool(tool);
}
}
protected override IComponent[] CreateToolCore(ToolboxItem tool, int x, int y, int width, int height, bool hasLocation, bool hasSize)
{
if (tool != null)
{
System.Type c = tool.GetType(this.designerHost);
if (!typeof(ToolStrip).IsAssignableFrom(c))
{
ToolStripContainer parent = this.panel.Parent as ToolStripContainer;
if (parent != null)
{
ToolStripContentPanel contentPanel = parent.ContentPanel;
if (contentPanel != null)
{
PanelDesigner toInvoke = this.designerHost.GetDesigner(contentPanel) as PanelDesigner;
if (toInvoke != null)
{
ParentControlDesigner.InvokeCreateTool(toInvoke, tool);
}
}
}
}
else
{
base.CreateToolCore(tool, x, y, width, height, hasLocation, hasSize);
}
}
return(null);
}
// ToolPicked is called when the user double-clicks on a toolbox item.
// The document designer should create a component for the specified tool.
// Only tools that are enabled in the toolbox will be passed to this method.
//
// I create the component in the parent container of the primary selection.
// If not available I create it in the rootcomponent (this essentially :-) )
//
protected virtual void ToolPicked(ToolboxItem tool)
{
ISelectionService selectionSvc = GetService(typeof(ISelectionService)) as ISelectionService;
IDesignerHost host = GetService(typeof(IDesignerHost)) as IDesignerHost;
if (selectionSvc != null && host != null)
{
IDesigner designer = host.GetDesigner((IComponent)selectionSvc.PrimarySelection);
if (designer is ParentControlDesigner)
{
ParentControlDesigner.InvokeCreateTool((ParentControlDesigner)designer, tool);
}
else
{
this.CreateTool(tool);
}
}
else
{
this.CreateTool(tool);
}
IToolboxService tbServ = this.GetService(typeof(IToolboxService)) as IToolboxService;
tbServ.SelectedToolboxItemUsed();
}
protected override IComponent[] CreateToolCore(ToolboxItem tool, int x, int y, int width, int height, bool hasLocation, bool hasSize)
{
if (this.Selected == null)
{
this.Selected = this.splitterPanel1;
}
SplitterPanelDesigner toInvoke = (SplitterPanelDesigner)this.designerHost.GetDesigner(this.Selected);
ParentControlDesigner.InvokeCreateTool(toInvoke, tool);
return(null);
}
// Called by the parent ParentControlDesigner when it is populating the grid-related
// design-time properties changes
//
private void OnParentGridPropertiesChanged(ParentControlDesigner parentDesigner)
{
SetValue(this.Component, "DrawGrid", (bool)GetValue(parentDesigner.Component, "DrawGrid"));
SetValue(this.Component, "SnapToGrid", (bool)GetValue(parentDesigner.Component, "SnapToGrid"));
SetValue(this.Component, "GridSize", (Size)GetValue(parentDesigner.Component, "GridSize"));
// Set also the default values to be those, because we should
// match the parent ParentControlDesigner values.
// called recursivly, so I will rather go for slower, but no stack-overflowable code
//
_defaultDrawGrid = (bool)GetValue(parentDesigner.Component, "DrawGrid");
_defaultSnapToGrid = (bool)GetValue(parentDesigner.Component, "SnapToGrid");
_defaultGridSize = (Size)GetValue(parentDesigner.Component, "GridSize");
this.PopulateGridProperties();
}
protected override IComponent[] CreateToolCore(ToolboxItem tool, int x, int y, int width, int height, bool hasLocation, bool hasSize)
{
TabControl control = (TabControl)this.Control;
if (control.SelectedTab == null)
{
throw new ArgumentException(System.Design.SR.GetString("TabControlInvalidTabPageType", new object[] { tool.DisplayName }));
}
IDesignerHost service = (IDesignerHost)this.GetService(typeof(IDesignerHost));
if (service != null)
{
TabPageDesigner toInvoke = (TabPageDesigner)service.GetDesigner(control.SelectedTab);
ParentControlDesigner.InvokeCreateTool(toInvoke, tool);
}
return(null);
}
// Retrieves the ParentControlDesigner of the specified control if available,
// else returns null.
//
private ParentControlDesigner GetParentControlDesignerOf(Control control)
{
if (control != null)
{
IDesignerHost designerHost = GetService(typeof(IDesignerHost)) as IDesignerHost;
if (designerHost != null)
{
ParentControlDesigner designer = null;
designer = designerHost.GetDesigner(this.Control.Parent) as ParentControlDesigner;
if (designer != null)
{
return(designer);
}
}
}
return(null);
}
protected override IComponent[] CreateToolCore(ToolboxItem tool, int x, int y, int width, int height, bool hasLocation, bool hasSize)
{
if (tool != null)
{
System.Type c = tool.GetType(this.designerHost);
if (typeof(StatusStrip).IsAssignableFrom(c))
{
ParentControlDesigner.InvokeCreateTool(this.GetDesigner(this.bottomToolStripPanel), tool);
}
else if (typeof(ToolStrip).IsAssignableFrom(c))
{
ParentControlDesigner.InvokeCreateTool(this.GetDesigner(this.topToolStripPanel), tool);
}
else
{
ParentControlDesigner.InvokeCreateTool(this.GetDesigner(this.contentToolStripPanel), tool);
}
}
return(null);
}
// Informs all children controls' ParentControlDesigners that the grid properties
// have changed and passes them
//
private void PopulateGridProperties()
{
// Control.Invalidate (true) will redraw the control and it's children
// this will cause a WM_PAINT message to be send and the ControlDesigenr will raise
// the OnPaintAdornments, where the grid drawing takes place.
//
// Note that this should be called *after* the grid properties have changed :-)
//
this.Control.Invalidate(false);
if (this.Control != null)
{
ParentControlDesigner designer = null;
foreach (Control control in this.Control.Controls)
{
designer = this.GetParentControlDesignerOf(control);
if (designer != null)
{
designer.OnParentGridPropertiesChanged(this);
}
}
}
}
protected override IComponent[] CreateComponentsCore(IDesignerHost host, IDictionary defaultValues)
{
IDesignerSerializationService ds = (IDesignerSerializationService)host.GetService(typeof(IDesignerSerializationService));
if (ds == null)
{
return(null);
}
// Deserialize to components collection
//
ICollection objects = ds.Deserialize(_serializationData);
ArrayList components = new ArrayList();
foreach (object obj in objects)
{
if (obj != null && obj is IComponent)
{
components.Add(obj);
}
}
IComponent[] componentsArray = new IComponent[components.Count];
components.CopyTo(componentsArray, 0);
ArrayList trayComponents = null;
// Parent and locate each Control
//
if (defaultValues == null)
{
defaultValues = new Hashtable();
}
Control parentControl = defaultValues["Parent"] as Control;
if (parentControl != null)
{
ParentControlDesigner parentControlDesigner = host.GetDesigner(parentControl) as ParentControlDesigner;
if (parentControlDesigner != null)
{
// Determine bounds of all controls
//
Rectangle bounds = Rectangle.Empty;
foreach (IComponent component in componentsArray)
{
Control childControl = component as Control;
if (childControl != null && childControl != parentControl && childControl.Parent == null)
{
if (bounds.IsEmpty)
{
bounds = childControl.Bounds;
}
else
{
bounds = Rectangle.Union(bounds, childControl.Bounds);
}
}
}
defaultValues.Remove("Size"); // don't care about the drag size
foreach (IComponent component in componentsArray)
{
Control childControl = component as Control;
Form form = childControl as Form;
if (childControl != null &&
!(form != null && form.TopLevel) && // Don't add top-level forms
childControl.Parent == null)
{
defaultValues["Offset"] = new Size(childControl.Bounds.X - bounds.X, childControl.Bounds.Y - bounds.Y);
parentControlDesigner.AddControl(childControl, defaultValues);
}
}
}
}
// VSWhidbey 516338 - When creating an item for the tray, template items will have
// an old location stored in them, so they may show up on top of other items.
// So we need to call UpdatePastePositions for each one to get the tray to
// arrange them properly.
//
ComponentTray tray = (ComponentTray)host.GetService(typeof(ComponentTray));
if (tray != null)
{
foreach (IComponent component in componentsArray)
{
ComponentTray.TrayControl c = tray.GetTrayControlFromComponent(component);
if (c != null)
{
if (trayComponents == null)
{
trayComponents = new ArrayList();
}
trayComponents.Add(c);
}
}
if (trayComponents != null)
{
tray.UpdatePastePositions(trayComponents);
}
}
return(componentsArray);
}
// Settings paths taken from the example at:
// http://msdn2.microsoft.com/en-us/library/system.componentmodel.design.idesigneroptionservice.aspx
//
public override void Initialize(IComponent component)
{
base.Initialize(component);
this.Control.AllowDrop = true;
// Initialize the default values of the Design-Time properties.
//
_defaultDrawGrid = true;
_defaultSnapToGrid = true;
_defaultGridSize = new Size(8, 8);
// If the parent Control of the designed one has a ParentDesigner then inherit the values
// from it's designer.
//
if (this.Control.Parent != null)
{
ParentControlDesigner parentDesigner = GetParentControlDesignerOf(Control.Parent);
if (parentDesigner != null)
{
_defaultDrawGrid = (bool)GetValue(parentDesigner.Component, "DrawGrid");
_defaultSnapToGrid = (bool)GetValue(parentDesigner.Component, "SnapToGrid");
_defaultGridSize = (Size)GetValue(parentDesigner.Component, "GridSize");
}
}
else
{
// Else retrieve them through the IDesignerOptionService (if available)
//
IDesignerOptionService options = GetService(typeof(IDesignerOptionService)) as
IDesignerOptionService;
if (options != null)
{
object value = null;
value = options.GetOptionValue(@"WindowsFormsDesigner\General", "DrawGrid");
if (value is bool)
{
_defaultDrawGrid = (bool)value;
}
value = options.GetOptionValue(@"WindowsFormsDesigner\General", "SnapToGrid");
if (value is bool)
{
_defaultSnapToGrid = (bool)value;
}
value = options.GetOptionValue(@"WindowsFormsDesigner\General", "GridSize");
if (value is Size)
{
_defaultGridSize = (Size)value;
}
}
}
IComponentChangeService componentChangeSvc = GetService(typeof(IComponentChangeService)) as IComponentChangeService;
if (componentChangeSvc != null)
{
componentChangeSvc.ComponentRemoving += new ComponentEventHandler(OnComponentRemoving);
componentChangeSvc.ComponentRemoved += new ComponentEventHandler(OnComponentRemoved);
}
// At the end set whatever we've managed to get
//
_drawGrid = _defaultDrawGrid;
_snapToGrid = _defaultSnapToGrid;
_gridSize = _defaultGridSize;
}
/// <summary>
/// Creates a new escape handler.
/// </summary>
public EscapeHandler(ParentControlDesigner designer)
{
this.designer = designer;
}
protected static void InvokeCreateTool(ParentControlDesigner toInvoke, ToolboxItem tool)
{
toInvoke.CreateTool(tool);
}
public EscapeHandler(ParentControlDesigner designer)
{
this.designer = designer;
}
protected static void InvokeCreateTool(ParentControlDesigner toInvoke, ToolboxItem tool)
{
// TODO
}
public void ChangeParent()
{
Cursor current = Cursor.Current;
DesignerTransaction transaction = this._host.CreateTransaction("Add ToolStripContainer Transaction");
try
{
Cursor.Current = Cursors.WaitCursor;
Control rootComponent = this._host.RootComponent as Control;
ParentControlDesigner designer = this._host.GetDesigner(rootComponent) as ParentControlDesigner;
if (designer != null)
{
ToolStrip component = this._designer.Component as ToolStrip;
if (((component != null) && (this._designer != null)) && ((this._designer.Component != null) && (this._provider != null)))
{
(this._provider.GetService(typeof(DesignerActionUIService)) as DesignerActionUIService).HideUI(component);
}
ToolboxItem tool = new ToolboxItem(typeof(ToolStripContainer));
OleDragDropHandler oleDragHandler = designer.GetOleDragHandler();
if (oleDragHandler != null)
{
ToolStripContainer container = oleDragHandler.CreateTool(tool, rootComponent, 0, 0, 0, 0, false, false)[0] as ToolStripContainer;
if ((container != null) && (component != null))
{
IComponentChangeService service = this._provider.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
Control parent = this.GetParent(container, component);
PropertyDescriptor member = TypeDescriptor.GetProperties(parent)["Controls"];
Control control3 = component.Parent;
if (control3 != null)
{
service.OnComponentChanging(control3, member);
control3.Controls.Remove(component);
}
if (parent != null)
{
service.OnComponentChanging(parent, member);
parent.Controls.Add(component);
}
if (((service != null) && (control3 != null)) && (parent != null))
{
service.OnComponentChanged(control3, member, null, null);
service.OnComponentChanged(parent, member, null, null);
}
ISelectionService service3 = this._provider.GetService(typeof(ISelectionService)) as ISelectionService;
if (service3 != null)
{
service3.SetSelectedComponents(new IComponent[] { container });
}
}
}
}
}
catch (Exception exception)
{
if (exception is InvalidOperationException)
{
((IUIService)this._provider.GetService(typeof(IUIService))).ShowError(exception.Message);
}
if (transaction != null)
{
transaction.Cancel();
transaction = null;
}
}
finally
{
if (transaction != null)
{
transaction.Commit();
transaction = null;
}
Cursor.Current = current;
}
}
// Reminder: We set control.Parent so that it gets serialized for Undo/Redo
//
private void Paste(object sender, EventArgs args)
{
IDesignerSerializationService stateSerializer = GetService(typeof(IDesignerSerializationService)) as IDesignerSerializationService;
ISelectionService selection = GetService(typeof(ISelectionService)) as ISelectionService;
IDesignerHost host = GetService(typeof(IDesignerHost)) as IDesignerHost;
IComponentChangeService changeService = GetService(typeof(IComponentChangeService)) as IComponentChangeService;
if (host == null || stateSerializer == null)
{
return;
}
//
// TODO: MWF X11 doesn't seem to support custom clipboard formats - bug #357642
//
// IDataObject dataObject = Clipboard.GetDataObject ();
// byte[] data = dataObject == null ? null : dataObject.GetData (DT_DATA_FORMAT) as byte[];
// if (data != null) {
// MemoryStream stream = new MemoryStream (data);
// stateSerializer.Deserialize (new BinaryFormatter().Deserialize (stream));
// .....
// }
//
if (_clipboard == null)
{
return;
}
DesignerTransaction transaction = host.CreateTransaction("Paste");
ICollection components = stateSerializer.Deserialize(_clipboard);
// Console.WriteLine ("Pasted components: ");
// foreach (object c in components)
// Console.WriteLine (((IComponent)c).Site.Name);
foreach (object component in components)
{
Control control = component as Control;
if (control == null)
{
continue; // pure Components are added to the ComponentTray by the DocumentDesigner
}
PropertyDescriptor parentProperty = TypeDescriptor.GetProperties(control)["Parent"];
if (control.Parent != null)
{
// Already parented during deserialization?
// In that case explicitly raise component changing/ed for the Parent property,
// so it get's cought by the UndoEngine
if (changeService != null)
{
changeService.OnComponentChanging(control, parentProperty);
changeService.OnComponentChanged(control, parentProperty, null, control.Parent);
}
}
else
{
ParentControlDesigner parentDesigner = null;
if (selection != null && selection.PrimarySelection != null)
{
parentDesigner = host.GetDesigner((IComponent)selection.PrimarySelection) as ParentControlDesigner;
}
if (parentDesigner == null)
{
parentDesigner = host.GetDesigner(host.RootComponent) as DocumentDesigner;
}
if (parentDesigner != null && parentDesigner.CanParent(control))
{
parentProperty.SetValue(control, parentDesigner.Control);
}
}
}
_clipboard = null;
transaction.Commit();
((IDisposable)transaction).Dispose();
}
internal DesignerHost(BrowserTree objTree, Panel imagePanel)
{
_imagePanel = imagePanel;
if (_host == null) {
_host = this;
_serviceContainer = new ServiceContainer();
_serviceContainer.AddService(typeof(IDesignerHost), _host);
_serviceContainer.AddService(typeof(IUIService), _host);
_serviceContainer.AddService(typeof(ISelectionService), _host);
_serviceContainer.AddService(typeof(IToolboxService), new ToolboxService());
}
_container = new DesignerContainer(this);
_defaultSite = new DesignerSite(this, null, _container, "Default site");
_designSurfaceSite = (DesignerSite)_container.CreateSite(_imagePanel, "Design Surface");
// Hook the design surface to the ParentControlDesigner
_parentControlDesigner = new DummyDesigner();
_imagePanel.Site = _designSurfaceSite;
_designSurfaceSite.Designer = _parentControlDesigner;
_parentControlDesigner.Initialize(_imagePanel);
// Used to make sure we don't give a designer for anything higher
// than the design surface (GetDesigner is called on the
// surface's parent)
_designSurfaceParent = ((Control)_imagePanel).Parent;
// Get the type for the UI selection service, since its private
// the compiler will not let us see it
_typeISelectionUIService = ReflectionHelper.GetType("System.Windows.Forms.Design.ISelectionUIService");
// This is required to get an instance of the selection
// UI service installed, we don't actually use this
// designer for anything
_fakePanel = new Panel();
IDesigner compDes = new ComponentDocumentDesigner();
_fakePanel.Site = _container.CreateSite(_fakePanel, "Fake Design Surface");
compDes.Initialize(_fakePanel);
// Make the size of the selection service cover the design
// surface panel so that it will see all of the events
_selUIService = (Control)GetService(_typeISelectionUIService);
ObjectBrowser.ImagePanel.ResetSize(_selUIService);
_imagePanel.Controls.Add(_selUIService);
_imagePanel.SizeChanged += new EventHandler(ImagePanelSizeChange);
DesignMode = true;
// So we change the object selected when a control is selected
SelectionChanged += new EventHandler(objTree.ControlSelectionChanged);
}
public void DoOleDragDrop(DragEventArgs de)
{
// ASURT 43757: By the time we come here, it means that the user completed the drag-drop and
// we compute the new location/size of the controls if needed and set the property values.
// We have to stop freezePainting right here, so that controls can get a chance to validate
// their new rects.
//
freezePainting = false;
if (selectionHandler == null)
{
Debug.Fail("selectionHandler should not be null");
de.Effect = DragDropEffects.None;
return;
}
// make sure we've actually moved
if ((localDrag && de.X == dragBase.X && de.Y == dragBase.Y) ||
de.AllowedEffect == DragDropEffects.None ||
(!localDrag && !dragOk))
{
de.Effect = DragDropEffects.None;
return;
}
bool localMoveOnly = ((int)de.AllowedEffect & AllowLocalMoveOnly) != 0 && localDragInside;
// if we are dragging inside the local dropsource/target, and and AllowLocalMoveOnly flag is set,
// we just consider this a normal move.
//
bool moveAllowed = (de.AllowedEffect & DragDropEffects.Move) != DragDropEffects.None || localMoveOnly;
bool copyAllowed = (de.AllowedEffect & DragDropEffects.Copy) != DragDropEffects.None;
if ((de.Effect & DragDropEffects.Move) != 0 && !moveAllowed)
{
// Try copy instead?
de.Effect = DragDropEffects.Copy;
}
// make sure the copy is allowed
if ((de.Effect & DragDropEffects.Copy) != 0 && !copyAllowed)
{
// if copy isn't allowed, don't do anything
de.Effect = DragDropEffects.None;
return;
}
if (localMoveOnly && (de.Effect & DragDropEffects.Move) != 0)
{
de.Effect |= (DragDropEffects)AllowLocalMoveOnly | DragDropEffects.Move;
}
else if ((de.Effect & DragDropEffects.Copy) != 0)
{
de.Effect = DragDropEffects.Copy;
}
if (forceDrawFrames || localDragInside)
{
// undraw the drag rect
localDragOffset = DrawDragFrames(dragComps, localDragOffset, localDragEffect,
Point.Empty, DragDropEffects.None, forceDrawFrames);
forceDrawFrames = false;
}
Cursor oldCursor = Cursor.Current;
try
{
Cursor.Current = Cursors.WaitCursor;
if (dragOk || (localDragInside && de.Effect == DragDropEffects.Copy))
{
// add em to this parent.
IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
IContainer container = host.RootComponent.Site.Container;
object[] components;
IDataObject dataObj = de.Data;
bool updateLocation = false;
if (dataObj is ComponentDataObjectWrapper)
{
dataObj = ((ComponentDataObjectWrapper)dataObj).InnerData;
ComponentDataObject cdo = (ComponentDataObject)dataObj;
// if we're moving ot a different container, do a full serialization
// to make sure we pick up design time props, etc.
//
IComponent dragOwner = GetDragOwnerComponent(de.Data);
bool newContainer = dragOwner == null || client.Component == null || dragOwner.Site.Container != client.Component.Site.Container;
bool collapseChildren = false;
if (de.Effect == DragDropEffects.Copy || newContainer)
{
// this causes new elements to be created
//
cdo.Deserialize(serviceProvider, (de.Effect & DragDropEffects.Copy) == 0);
}
else
{
collapseChildren = true;
}
updateLocation = true;
components = cdo.Components;
if (collapseChildren)
{
components = GetTopLevelComponents(components);
}
}
else
{
object serializationData = dataObj.GetData(DataFormat, true);
if (serializationData == null)
{
Debug.Fail("data object didn't return any data, so how did we allow the drop?");
components = Array.Empty <IComponent>();
}
else
{
dataObj = new ComponentDataObject(client, serviceProvider, serializationData);
components = ((ComponentDataObject)dataObj).Components;
updateLocation = true;
}
}
// now we need to offset the components locations from the drop mouse
// point to the parent, since their current locations are relative
// the the mouse pointer
if (components != null && components.Length > 0)
{
Debug.Assert(container != null, "Didn't get a container from the site!");
string name;
IComponent comp = null;
DesignerTransaction trans = null;
try
{
trans = host.CreateTransaction(SR.DragDropDropComponents);
if (!localDrag)
{
host.Activate();
}
ArrayList selectComps = new ArrayList();
for (int i = 0; i < components.Length; i++)
{
comp = components[i] as IComponent;
if (comp == null)
{
comp = null;
continue;
}
try
{
name = null;
if (comp.Site != null)
{
name = comp.Site.Name;
}
Control oldDesignerControl = null;
if (updateLocation)
{
oldDesignerControl = client.GetDesignerControl();
User32.SendMessageW(oldDesignerControl.Handle, User32.WM.SETREDRAW);
}
Point dropPt = client.GetDesignerControl().PointToClient(new Point(de.X, de.Y));
// First check if the component we are dropping have a TrayLocation, and if so, use it
PropertyDescriptor loc = TypeDescriptor.GetProperties(comp)["TrayLocation"];
if (loc == null)
{
// it didn't, so let's check for the regular Location
loc = TypeDescriptor.GetProperties(comp)["Location"];
}
if (loc != null && !loc.IsReadOnly)
{
Rectangle bounds = new Rectangle();
Point pt = (Point)loc.GetValue(comp);
bounds.X = dropPt.X + pt.X;
bounds.Y = dropPt.Y + pt.Y;
bounds = selectionHandler.GetUpdatedRect(Rectangle.Empty, bounds, false);
}
if (!client.AddComponent(comp, name, false))
{
// this means that we just moved the control
// around in the same designer.
de.Effect = DragDropEffects.None;
}
else
{
// make sure the component was added to this client
if (client.GetControlForComponent(comp) == null)
{
updateLocation = false;
}
}
if (updateLocation)
{
ParentControlDesigner parentDesigner = client as ParentControlDesigner;
if (parentDesigner != null)
{
Control c = client.GetControlForComponent(comp);
dropPt = parentDesigner.GetSnappedPoint(c.Location);
c.Location = dropPt;
}
}
if (oldDesignerControl != null)
{
//((ComponentDataObject)dataObj).ShowControls();
User32.SendMessageW(oldDesignerControl.Handle, User32.WM.SETREDRAW, (IntPtr)1);
oldDesignerControl.Invalidate(true);
}
if (TypeDescriptor.GetAttributes(comp).Contains(DesignTimeVisibleAttribute.Yes))
{
selectComps.Add(comp);
}
}
catch (CheckoutException ceex)
{
if (ceex == CheckoutException.Canceled)
{
break;
}
throw;
}
}
if (host != null)
{
host.Activate();
}
// select the newly added components
ISelectionService selService = (ISelectionService)GetService(typeof(ISelectionService));
selService.SetSelectedComponents((object[])selectComps.ToArray(typeof(IComponent)), SelectionTypes.Replace);
localDragInside = false;
}
finally
{
if (trans != null)
{
trans.Commit();
}
}
}
}
if (localDragInside)
{
ISelectionUIService selectionUISvc = (ISelectionUIService)GetService(typeof(ISelectionUIService));
Debug.Assert(selectionUISvc != null, "Unable to get selection ui service when adding child control");
if (selectionUISvc != null)
{
// We must check to ensure that UI service is still in drag mode. It is
// possible that the user hit escape, which will cancel drag mode.
//
if (selectionUISvc.Dragging && moveAllowed)
{
Rectangle offset = new Rectangle(de.X - dragBase.X, de.Y - dragBase.Y, 0, 0);
selectionUISvc.DragMoved(offset);
}
}
}
dragOk = false;
}
finally
{
Cursor.Current = oldCursor;
}
}
// Called by the parent ParentControlDesigner when it is populating the grid-related
// design-time properties changes
//
private void OnParentGridPropertiesChanged (ParentControlDesigner parentDesigner)
{
SetValue (this.Component, "DrawGrid", (bool) GetValue (parentDesigner.Component, "DrawGrid"));
SetValue (this.Component, "SnapToGrid", (bool) GetValue (parentDesigner.Component, "SnapToGrid"));
SetValue (this.Component, "GridSize", (Size) GetValue (parentDesigner.Component, "GridSize"));
// Set also the default values to be those, because we should
// match the parent ParentControlDesigner values.
// called recursivly, so I will rather go for slower, but no stack-overflowable code
//
_defaultDrawGrid = (bool) GetValue (parentDesigner.Component, "DrawGrid");
_defaultSnapToGrid = (bool) GetValue (parentDesigner.Component, "SnapToGrid");
_defaultGridSize = (Size) GetValue (parentDesigner.Component, "GridSize");
this.PopulateGridProperties ();
}
