public bool DoBeginDrag(object[] components, SelectionRules rules, int initialX, int initialY)
{
// if we're in a sizing operation, or the mouse isn't down, don't do this!
if ((rules & SelectionRules.AllSizeable) != SelectionRules.None || Control.MouseButtons == MouseButtons.None)
{
return(true);
}
Control c = client.GetDesignerControl();
localDrag = true;
localDragInside = false;
dragComps = components;
dragBase = new Point(initialX, initialY);
localDragOffset = Point.Empty;
c.PointToClient(new Point(initialX, initialY));
DragDropEffects allowedEffects = DragDropEffects.Copy | DragDropEffects.None | DragDropEffects.Move;
// check to see if any of the components are inherhited. if so, don't allow them to be moved.
// We replace DragDropEffects.Move with a local bit called AllowLocalMoveOnly which means it
// can be moved around on the current dropsource/target, but not to another target. Since only
// we understand this bit, other drop targets will not allow the move to occur
//
for (int i = 0; i < components.Length; i++)
{
InheritanceAttribute attr = (InheritanceAttribute)TypeDescriptor.GetAttributes(components[i])[typeof(InheritanceAttribute)];
if (!attr.Equals(InheritanceAttribute.NotInherited) && !attr.Equals(InheritanceAttribute.InheritedReadOnly))
{
allowedEffects &= ~DragDropEffects.Move;
allowedEffects |= (DragDropEffects)AllowLocalMoveOnly;
}
}
DataObject data = new ComponentDataObjectWrapper(new ComponentDataObject(client, serviceProvider, components, initialX, initialY));
// We make sure we're painted before we start the drag. Then, we disable window painting to
// ensure that the drag can proceed without leaving artifacts lying around. We should be caling LockWindowUpdate,
// but that causes a horrible flashing because GDI+ uses direct draw.
//
User32.MSG msg = default;
while (User32.PeekMessageW(ref msg, IntPtr.Zero, User32.WM.PAINT, User32.WM.PAINT, User32.PM.REMOVE).IsTrue())
{
User32.TranslateMessage(ref msg);
User32.DispatchMessageW(ref msg);
}
// don't do any new painting...
bool oldFreezePainting = freezePainting;
// asurt 90345 -- this causes some subtle bugs, so i'm turning it off to see if we really need it, and if we do
// if we can find a better way.
//
//freezePainting = true;
AddCurrentDrag(data, client.Component);
// Walk through all the children recursively and disable drag-drop
// for each of them. This way, we will not accidentally try to drop
// ourselves into our own children.
//
ArrayList allowDropChanged = new ArrayList();
foreach (object comp in components)
{
Control ctl = comp as Control;
if (ctl != null && ctl.HasChildren)
{
DisableDragDropChildren(ctl.Controls, allowDropChanged);
}
}
DragDropEffects effect = DragDropEffects.None;
IDesignerHost host = GetService(typeof(IDesignerHost)) as IDesignerHost;
DesignerTransaction trans = null;
if (host != null)
{
trans = host.CreateTransaction(string.Format(SR.DragDropDragComponents, components.Length));
}
try
{
effect = c.DoDragDrop(data, allowedEffects);
if (trans != null)
{
trans.Commit();
}
}
finally
{
RemoveCurrentDrag(data);
// Reset the AllowDrop for the components being dragged.
//
foreach (Control ctl in allowDropChanged)
{
ctl.AllowDrop = true;
}
freezePainting = oldFreezePainting;
if (trans != null)
{
((IDisposable)trans).Dispose();
}
}
bool isMove = (effect & DragDropEffects.Move) != 0 || ((int)effect & AllowLocalMoveOnly) != 0;
// since the EndDrag will clear this
bool isLocalMove = isMove && 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)
{
// cancel the drag if we aren't doing a local move
selectionUISvc.EndDrag(!isLocalMove);
}
}
if (!localDragOffset.IsEmpty && effect != DragDropEffects.None)
{
DrawDragFrames(dragComps, localDragOffset, localDragEffect,
Point.Empty, DragDropEffects.None, false);
}
localDragOffset = Point.Empty;
dragComps = null;
localDrag = localDragInside = false;
dragBase = Point.Empty;
/*if (!isLocalMove && isMove){
* IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
* IUndoService undoService = (IUndoService)GetService(typeof(IUndoService));
* IActionUnit unit = null;
*
* if (host != null) {
* DesignerTransaction trans = host.CreateTransaction("Drag/drop");
* try{
* // delete the components
* try{
* for (int i = 0; i < components.Length; i++){
* if (components[i] is IComponent){
* if (undoService != null){
* unit = new CreateControlActionUnit(host, (IComponent)components[i], true);
* }
* host.DestroyComponent((IComponent)components[i]);
* if (undoService != null){
* undoService.AddAction(unit, false);
* }
* }
* }
* }catch(CheckoutException ex){
* if (ex != CheckoutException.Canceled){
* throw ex;
* }
* }
* }
* finally{
* trans.Commit();
* }
* }
* }*/
return(false);
}
/// <include file='doc\ControlCommandSet.uex' path='docs/doc[@for="ControlCommandSet.OnKeySize"]/*' />
/// <devdoc>
/// Called for the various sizing commands we support.
/// </devdoc>
protected void OnKeySize(object sender, EventArgs e)
{
// Arrow keys. Begin a drag if the selection isn't locked.
//
ISelectionService selSvc = SelectionService;
ISelectionUIService uiSvc = SelectionUIService;
if (uiSvc != null && selSvc != null)
{
//added to remove the selection rectangle: bug(54692)
//
uiSvc.Visible = false;
object comp = selSvc.PrimarySelection;
if (comp != null && comp is IComponent)
{
PropertyDescriptor lockedProp = TypeDescriptor.GetProperties(comp)["Locked"];
if (lockedProp == null || (lockedProp.PropertyType == typeof(bool) && ((bool)lockedProp.GetValue(comp))) == false)
{
SelectionRules rules = SelectionRules.Visible;
CommandID cmd = ((MenuCommand)sender).CommandID;
bool invertSnap = false;
int moveOffsetX = 0;
int moveOffsetY = 0;
if (cmd.Equals(MenuCommands.KeySizeHeightDecrease))
{
moveOffsetY = -1;
rules |= SelectionRules.BottomSizeable;
}
else if (cmd.Equals(MenuCommands.KeySizeHeightIncrease))
{
moveOffsetY = 1;
rules |= SelectionRules.BottomSizeable;
}
else if (cmd.Equals(MenuCommands.KeySizeWidthDecrease))
{
moveOffsetX = -1;
rules |= SelectionRules.RightSizeable;
}
else if (cmd.Equals(MenuCommands.KeySizeWidthIncrease))
{
moveOffsetX = 1;
rules |= SelectionRules.RightSizeable;
}
else if (cmd.Equals(MenuCommands.KeyNudgeHeightDecrease))
{
moveOffsetY = -1;
invertSnap = true;
rules |= SelectionRules.BottomSizeable;
}
else if (cmd.Equals(MenuCommands.KeyNudgeHeightIncrease))
{
moveOffsetY = 1;
invertSnap = true;
rules |= SelectionRules.BottomSizeable;
}
else if (cmd.Equals(MenuCommands.KeyNudgeWidthDecrease))
{
moveOffsetX = -1;
invertSnap = true;
rules |= SelectionRules.RightSizeable;
}
else if (cmd.Equals(MenuCommands.KeyNudgeWidthIncrease))
{
moveOffsetX = 1;
invertSnap = true;
rules |= SelectionRules.RightSizeable;
}
else
{
Debug.Fail("Unknown command mapped to OnKeySize: " + cmd.ToString());
}
if (uiSvc.BeginDrag(rules, 0, 0))
{
bool snapOn = false;
Size snapSize = Size.Empty;
IComponent snapComponent = null;
PropertyDescriptor snapProperty = null;
// Gets the needed snap information
//
IDesignerHost host = (IDesignerHost)GetService(typeof(IDesignerHost));
DesignerTransaction trans = null;
try {
if (host != null)
{
GetSnapInformation(host, (IComponent)comp, out snapSize, out snapComponent, out snapProperty);
if (selSvc.SelectionCount > 1)
{
trans = host.CreateTransaction(SR.GetString(SR.DragDropSizeComponents, selSvc.SelectionCount));
}
else
{
trans = host.CreateTransaction(SR.GetString(SR.DragDropSizeComponent, ((IComponent)comp).Site.Name));
}
if (snapProperty != null)
{
snapOn = (bool)snapProperty.GetValue(snapComponent);
if (invertSnap)
{
snapOn = !snapOn;
snapProperty.SetValue(snapComponent, snapOn);
}
}
}
if (snapOn && !snapSize.IsEmpty)
{
moveOffsetX *= snapSize.Width;
moveOffsetY *= snapSize.Height;
}
// Now move the controls the correct # of pixels.
//
uiSvc.DragMoved(new Rectangle(0, 0, moveOffsetX, moveOffsetY));
uiSvc.EndDrag(false);
if (host != null)
{
if (invertSnap && snapProperty != null)
{
snapOn = !snapOn;
snapProperty.SetValue(snapComponent, snapOn);
}
}
}
finally {
if (trans != null)
{
trans.Commit();
uiSvc.Visible = true;
}
}
}
}
}
uiSvc.Visible = true;
}
}
