protected virtual void ProcessTargetItem(DragDropManagerBase sourceManager, Point pt)
{
TargetItem = GetVisibleHitTestElement(pt);
if (TargetItem == null)
{
sourceManager.ViewInfo.DropTargetRow = null;
sourceManager.SetDropTargetType(DropTargetType.DataArea);
ShowDropMarker(ListBox, TableDragIndicatorPosition.None);
return;
}
var position = Mouse.GetPosition(TargetItem);
double height = TargetItem.ActualHeight;
if (position.Y < height / 2)
{
sourceManager.SetDropTargetType(DropTargetType.InsertRowsBefore);
ShowDropMarker(TargetItem, TableDragIndicatorPosition.Top);
}
else
{
sourceManager.SetDropTargetType(DropTargetType.InsertRowsAfter);
ShowDropMarker(TargetItem, TableDragIndicatorPosition.Bottom);
}
sourceManager.ViewInfo.DropTargetRow = TargetItem.Content;
}
public LocalDragDropController(DragDropManagerBase dragDropManager, ISClientSocket serverConnection)
{
ddManager = dragDropManager;
server = serverConnection;
ddManager.DataDropped += Local_DataDropped;
ddManager.DragDropCancelled += Local_DragDropCancelled;
ddManager.DragDropSuccess += Local_DragDropSuccess;
server.DragDropDataReceived += Socket_DragDropReceived;
server.CancelAnyDragDrop += Socket_CancelAnyDragDrop;
}
protected override void PerformDropToViewCore(DragDropManagerBase sourceManager)
{
GridViewHitInfoBase hitInfo = GetHitInfo(HitElement);
if (BanDrop(hitInfo.RowHandle, hitInfo, sourceManager, DropTargetType.None))
{
ClearDragInfo(sourceManager);
return;
}
PerformDropToView(sourceManager, hitInfo as TableViewHitInfo, LastPosition, SetReorderDropInfo, (_) => SetMoveToGroupRowDropInfo, SetAddRowsDropInfo);
}
public override void OnDragOver(DragDropManagerBase sourceManager, UIElement source, Point pt)
{
this.dragOverSourceManager = sourceManager;
ListBoxDragOverEventArgs e = RaiseDragOverEvent(sourceManager, pt, DropTargetType.None);
DropEventIsLocked = e.Handled ? !e.AllowDrop : !AllowDrop || sourceManager.DraggingRows == null || sourceManager.DraggingRows.Count < 1;
if (!DropEventIsLocked)
{
ProcessTargetItem(sourceManager, pt);
return;
}
}
public DataControlDragElement(DragDropManagerBase dragDropManager, Point offset, FrameworkElement owner) {
initialOffset = offset;
container.Owner = owner;
container.Content = new ContentPresenter() {
Content = dragDropManager.ViewInfo,
ContentTemplate = dragDropManager.DragElementTemplate
?? (dragDropManager.TemplatesContainer !=null ? dragDropManager.TemplatesContainer.DefaultDragElementTemplate : null),
HorizontalAlignment = HorizontalAlignment.Left,
VerticalAlignment = VerticalAlignment.Top,
};
container.ShowContentOnly = true;
container.FloatSize = new Size(350, 800);
}
protected void PerformDropToView(DragDropManagerBase sourceManager, TableViewHitInfo hitInfo, Point pt, MoveRowsDelegate reorderDelegate, Func <bool, MoveRowsDelegate> groupDelegateExtractor, MoveRowsDelegate addRowsDelegate)
{
int insertRowHandle = hitInfo.RowHandle;
var grid = GetSourceGrid();
if (this.GridControl.IsGroupRowHandle(insertRowHandle))
{
groupDelegateExtractor(true)(sourceManager, insertRowHandle, HitElement);
return;
}
if (IsSortedButNotGrouped(grid) || hitInfo.HitTest == TableViewHitTest.DataArea)
{
if (sourceManager.DraggingRows.Count > 0 && GetDataAreaElement(HitElement) != null /* && !ReferenceEquals(sourceManager, this)*/)
{
addRowsDelegate(sourceManager, insertRowHandle, HitElement);
}
else
{
ClearDragInfo(sourceManager);
}
return;
}
if (insertRowHandle == GridControl.InvalidRowHandle || insertRowHandle == GridControl.AutoFilterRowHandle || insertRowHandle == GridControl.NewItemRowHandle)
{
ClearDragInfo(sourceManager);
return;
}
if (this.GridControl.GroupCount > 0)
{
int groupRowHandle = this.GridControl.GetParentRowHandle(insertRowHandle);
if (ShouldReorderGroup(grid))
{
if (!IsSameGroup(sourceManager, GetGroupInfos(groupRowHandle), HitElement))
{
groupDelegateExtractor(false)(sourceManager, groupRowHandle, HitElement);
}
reorderDelegate(sourceManager, insertRowHandle, HitElement);
}
else
{
groupDelegateExtractor(true)(sourceManager, groupRowHandle, HitElement);
}
}
else
{
reorderDelegate(sourceManager, insertRowHandle, HitElement);
}
}
public CustomDataControlDragElement(DragDropManagerBase dragDropManager, Point offset, FrameworkElement owner)
: base(dragDropManager, offset, owner)
{
ContentPresenter content = container.Content as ContentPresenter;
DragDropViewInfo oldInfo = content.Content as DragDropViewInfo;
ExternalDragDropViewInfo info = new ExternalDragDropViewInfo {
DraggingRows = (dragDropManager as IDragRowVisibilitySupport).DraggingRowsData,
DropTargetRow = oldInfo.DropTargetRow,
DropTargetType = oldInfo.DropTargetType,
FirstDraggingObject = oldInfo.FirstDraggingObject,
GroupInfo = oldInfo.GroupInfo
};
content.Content = info;
}
private void StartModules(StartOptions args, ISServerDependencies dependencies)
{
cbManager = args.HasArg(StartArguments.NoClipboard) ? new NullClipboardManager() : dependencies.ClipboardManager;
dragDropMan = args.HasArg(StartArguments.NoDragDrop) ? new NullDragDropManager() : dependencies.DragDropManager;
inputMan = dependencies.InputManager;
outMan = dependencies.OutputManager;
displayMan = dependencies.DisplayManager;
cbController = new GlobalClipboardController(cbManager, clientMan);
ddController = new GlobalDragDropController(dragDropMan, clientMan);
fileController = new FileAccessController();
inputController = new GlobalInputController(clientMan, inputMan, udpHost);
cbManager.Start();
dragDropMan.Start();
inputMan.Start();
outMan.Start();
displayMan.Start();
}
protected override void OnDrop(DragDropManagerBase sourceManager, UIElement source, Point pt)
{
if (DropEventIsLocked)
{
return;
}
ListBoxDropEventArgs e = RaiseDropEvent(sourceManager);
if (!e.Handled)
{
if (sourceManager.DraggingRows.Count > 0 && AllowDrop)
{
ProcessTargetItem(e.SourceManager, pt);
IList currentSource = ItemsSource;
IList draggedFromSource = e.SourceManager.GetSource(null);
foreach (object obj in e.DraggedRows)
{
if (TargetItem != null && obj == TargetItem.Content)
{
continue;
}
draggedFromSource.Remove(obj);
switch (e.SourceManager.ViewInfo.DropTargetType)
{
case DropTargetType.DataArea:
currentSource.Add(obj);
break;
case DropTargetType.InsertRowsAfter:
currentSource.Insert(currentSource.IndexOf(TargetItem.Content) + 1, obj);
break;
case DropTargetType.InsertRowsBefore:
currentSource.Insert(Math.Max(currentSource.IndexOf(TargetItem.Content), 0), obj);
break;
}
}
RaiseDroppedEvent(sourceManager, e.DraggedRows);
}
}
HideDropMarker();
}
GridDropEventArgs RaiseDropEvent(DragDropManagerBase sourceManager, TableViewHitInfo hitInfo, IList rows, DropTargetType dropTargetType) {
GridDropEventArgs e = new GridDropEventArgs() {
HitInfo = hitInfo,
DraggedRows = rows,
DropTargetType = dropTargetType,
Handled = false,
Manager = this,
SourceManager = sourceManager,
GridControl = GridControl,
};
if(DropEventHandler != null)
DropEventHandler(this, e);
return e;
}
void MoveSelectedRows(DragDropManagerBase sourceManager, int insertRowHandle, DependencyObject hitElement) {
object insertObject = GridControl.GetRow(insertRowHandle);
if(insertObject == null || sourceManager.DraggingRows.Contains(GridControl.GetRow(insertRowHandle)))
return;
FrameworkElement row = GetRowElement(hitElement);
DropTargetType dropTargetType = GetDropTargetType(row);
if(dropTargetType == DropTargetType.None)
return;
int index = ItemsSource.IndexOf(insertObject);
if(dropTargetType == DropTargetType.InsertRowsAfter)
index++;
GridControl.BeginDataUpdate();
foreach(object obj in sourceManager.DraggingRows) {
object sourceObject = sourceManager.GetObject(obj);
if(ReferenceEquals(ItemsSource, sourceManager.GetSource(obj))) {
if(index > ItemsSource.IndexOf(sourceObject))
index--;
}
sourceManager.ItemsSource.Remove(sourceObject);
ItemsSource.Insert(index, sourceObject);
index++;
}
GridControl.EndDataUpdate();
if(RestoreSelection) {
int startRowHandle = GridControl.GetRowHandleByListIndex(ItemsSource.IndexOf(sourceManager.DraggingRows[0]));
int endRowHandle = GridControl.GetRowHandleByListIndex(ItemsSource.IndexOf(sourceManager.DraggingRows[sourceManager.DraggingRows.Count - 1]));
TableView.SelectRange(startRowHandle, endRowHandle);
} else
TableView.ClearSelection();
TableView.FocusedRow = sourceManager.DraggingRows[0];
}
protected override void AddRow(DragDropManagerBase sourceManager, object row, int insertRowHandle) {
sourceManager.ItemsSource.Remove(row);
ItemsSource.Add(row);
}
bool InternalBanDrop(int insertRowHandle, DragDropManagerBase sourceManager) {
return false;
}
void PerformDropToView(DragDropManagerBase sourceManager, Point pt, MoveRowsDelegate reorderDelegate, MoveRowsDelegate moveToGroupDelegate, MoveRowsDelegate addRowsDelegate) {
UIElement element = GetVisibleHitTestElement(pt);
TableViewHitInfo hitInfo = TableView.CalcHitInfo(element);
int insertRowHandle = hitInfo.RowHandle;
if(BanDrop(insertRowHandle, hitInfo, sourceManager)) {
ClearDragInfo(sourceManager);
return;
}
if(GridControl.IsGroupRowHandle(insertRowHandle)) {
moveToGroupDelegate(sourceManager, insertRowHandle, element);
return;
}
if(IsSortedButNotGrouped() || hitInfo.HitTest == TableViewHitTest.DataArea) {
if(sourceManager.DraggingRows.Count > 0 && GetDataAreaElement(element) != null && !ReferenceEquals(sourceManager, this)) {
addRowsDelegate(sourceManager, insertRowHandle, element);
} else {
ClearDragInfo(sourceManager);
}
return;
}
if(insertRowHandle == GridControl.InvalidRowHandle) {
ClearDragInfo(sourceManager);
return;
}
if(GridControl.GroupCount > 0) {
int groupRowHandle = GridControl.GetParentRowHandle(insertRowHandle);
moveToGroupDelegate(sourceManager, groupRowHandle, element);
} else {
reorderDelegate(sourceManager, insertRowHandle, element);
}
}
protected internal override void OnDrop(DragDropManagerBase sourceManager, UIElement source, Point pt) {
GridDropEventArgs e = RaiseDropEvent(sourceManager, pt);
if(!e.Handled)
PerformDropToView(sourceManager, pt, MoveSelectedRows, MoveSelectedRowsToGroup, AddRows);
RaiseDroppedEvent(sourceManager, e);
}
protected virtual void AddRow(DragDropManagerBase sourceManager, object row, int insertRowHandle) { }
protected void SetMoveToGroupRowDropInfo(DragDropManagerBase sourceManager, int insertRowHandle, DependencyObject hitElement)
{
SetReorderDropInfoInfo.Invoke(this, new object[] { sourceManager, insertRowHandle, hitElement });
}
void SetReorderDropInfo(DragDropManagerBase sourceManager, int insertRowHandle, DependencyObject hitElement) {
FrameworkElement rowElement = GetRowElement(hitElement);
TableDragIndicatorPosition dragIndicatorPosition = GetDragIndicatorPositionForRowElement(rowElement);
if(dragIndicatorPosition != TableDragIndicatorPosition.None) {
DropTargetType dropTargetType = dragIndicatorPosition == TableDragIndicatorPosition.Bottom ? DropTargetType.InsertRowsAfter : DropTargetType.InsertRowsBefore;
sourceManager.SetDropTargetType(dropTargetType);
sourceManager.ViewInfo.DropTargetRow = GridControl.GetRow(insertRowHandle);
sourceManager.ShowDropMarker(rowElement, dragIndicatorPosition);
} else {
ClearDragInfo(sourceManager);
}
}
bool CanMoveSelectedRowsToGroup(DragDropManagerBase sourceManager, GroupInfo[] groupInfos, DependencyObject hitElement) {
if(GetRowElement(hitElement) == null)
return false;
foreach(object obj in sourceManager.DraggingRows) {
if(!ItemsSource.Contains(obj))
return true;
foreach(GroupInfo groupInfo in groupInfos) {
object value;
if(groupInfo.FieldName.Contains(".")) {
ComplexPropertyDescriptor complexDescr = new ComplexPropertyDescriptor(obj, groupInfo.FieldName);
value = complexDescr.GetValue(obj);
} else
value = TypeDescriptor.GetProperties(obj)[groupInfo.FieldName].GetValue(obj);
if(!object.Equals(value, groupInfo.Value))
return true;
}
}
return false;
}
TreeListDropEventArgs RaiseDropEvent(DragDropManagerBase sourceManager, TreeListViewHitInfo hitInfo, TreeListNode insertNode, IList rows, DropTargetType dropTargetType) {
TreeListDropEventArgs e = new TreeListDropEventArgs() {
HitInfo = hitInfo,
TargetNode = insertNode,
DraggedRows = rows,
DropTargetType = dropTargetType,
Handled = false,
Manager = this,
SourceManager = sourceManager,
DataControl = DataControl as GridDataControlBase,
};
if(DropEventHandler != null)
DropEventHandler(this, e);
return e;
}
protected void AddRows(DragDropManagerBase sourceManager, int insertRowHandle, DependencyObject hitElement) {
DataControl.BeginDataUpdate();
foreach(object row in sourceManager.DraggingRows)
AddRow(sourceManager, row, insertRowHandle);
DataControl.EndDataUpdate();
}
void RaiseDroppedEvent(DragDropManagerBase sourceManager, TreeListDropEventArgs dropEventArgs) {
if(DroppedEventHandler != null) {
TreeListDroppedEventArgs e = new TreeListDroppedEventArgs() {
DataControl = DataControl as GridDataControlBase,
TargetNode = dropEventArgs.TargetNode,
HitInfo = dropEventArgs.HitInfo,
Manager = this,
DraggedRows = dropEventArgs.DraggedRows,
SourceManager = sourceManager,
DropTargetType = dropEventArgs.DropTargetType,
};
DroppedEventHandler(this, e);
}
}
protected internal override void OnDrop(DragDropManagerBase sourceManager, UIElement source, Point pt) { }
void SetReorderDropInfo(DragDropManagerBase sourceManager, int insertRowHandle, DependencyObject hitElement) {
FrameworkElement rowElement = GetRowElement(hitElement);
TableDragIndicatorPosition dragIndicatorPosition = GetDragIndicatorPositionForRowElement(rowElement);
if(dragIndicatorPosition != TableDragIndicatorPosition.None) {
DropTargetType dropTargetType;
switch(dragIndicatorPosition) {
case TableDragIndicatorPosition.Top:
dropTargetType = DropTargetType.InsertRowsBefore;
break;
case TableDragIndicatorPosition.Bottom:
dropTargetType = DropTargetType.InsertRowsAfter;
break;
case TableDragIndicatorPosition.InRow:
dropTargetType = DropTargetType.InsertRowsIntoNode;
break;
default:
dropTargetType = DropTargetType.None;
break;
}
sourceManager.SetDropTargetType(dropTargetType);
sourceManager.ViewInfo.DropTargetRow = GetObjectByRowHandle(insertRowHandle);
sourceManager.ShowDropMarker(rowElement, dragIndicatorPosition);
} else {
ClearDragInfo(sourceManager);
}
}
protected override void PerformDropToView(DragDropManagerBase sourceManager) {
if((bool)LayoutHelper.GetTopLevelVisual(View).GetValue(DragManager.IsDraggingProperty))
PerformDropToView(sourceManager, LastPosition, SetReorderDropInfo, SetMoveToGroupRowDropInfo, SetAddRowsDropInfo);
}
void MoveSelectedRowsToChildrenCollection(DragDropManagerBase sourceManager, int groupRowHandle, DependencyObject hitElement) {
}
bool BanDrop(int insertRowHandle, TableViewHitInfo hitInfo, DragDropManagerBase sourceManager) {
GridDragOverEventArgs e = RaiseDragOverEvent(hitInfo, sourceManager);
return e.Handled ? !e.AllowDrop : !e.AllowDrop || InternalBanDrop(insertRowHandle, sourceManager);
}
public TreeListDragSource(DragDropManagerBase dragDropManager)
: base(dragDropManager) {
}
GridDragOverEventArgs RaiseDragOverEvent(TableViewHitInfo hitInfo, DragDropManagerBase sourceManager) {
GridDragOverEventArgs e = new GridDragOverEventArgs(hitInfo, sourceManager.DraggingRows) {
Handled = false,
Manager = this,
SourceManager = sourceManager,
};
if(DragOverEventHandler != null)
DragOverEventHandler(this, e);
return e;
}
protected void InvalidateScrollingAndPerformDropToView(DragDropManagerBase sourceManager, Point point) {
InvalidateScrolling(point);
View.UpdateLayout();
DataControl.Dispatcher.BeginInvoke(new Action(() => PerformDropToView(sourceManager)));
}
void SetMoveToGroupRowDropInfo(DragDropManagerBase sourceManager, int insertRowHandle, DependencyObject hitElement) {
GroupInfo[] groupInfo = GetGroupInfos(insertRowHandle);
if(CanMoveSelectedRowsToGroup(sourceManager, groupInfo, hitElement)) {
sourceManager.SetDropTargetType(DropTargetType.InsertRowsIntoGroup);
sourceManager.ViewInfo.GroupInfo = groupInfo;
sourceManager.ShowDropMarker(GetRowElement(hitElement), TableDragIndicatorPosition.None);
} else {
ClearDragInfo(sourceManager);
}
}
protected internal override void OnDragOver(DragDropManagerBase sourceManager, UIElement source, Point pt) {
LastPosition = pt;
scrollTimer.Start();
UpdateHoverRowHandle(source, pt);
if(IsExpandable) {
AutoExpandTimer.Stop();
AutoExpandTimer.Start();
} else
AutoExpandTimer.Stop();
if(AllowScrolling)
InvalidateScrollingAndPerformDropToView(sourceManager, pt);
else
PerformDropToView(sourceManager);
base.OnDragOver(sourceManager, source, pt);
}
GridDropEventArgs RaiseDropEvent(DragDropManagerBase sourceManager, Point pt) {
UIElement hitElement = GetVisibleHitTestElement(pt);
TableViewHitInfo hitInfo = GetHitInfo(hitElement) as TableViewHitInfo;
DropTargetType dropTargetType = GridControl.GroupCount > 0 ? DropTargetType.InsertRowsIntoGroup : GetDropTargetType(GetRowElement(hitElement));
return RaiseDropEvent(sourceManager, hitInfo, sourceManager.DraggingRows,
hitInfo.HitTest == TableViewHitTest.DataArea ? DropTargetType.DataArea : dropTargetType);
}
protected virtual void PerformDropToView(DragDropManagerBase sourceManager) { }
void RaiseDroppedEvent(DragDropManagerBase sourceManager, GridDropEventArgs dropEventArgs){
if(DroppedEventHandler != null) {
GridDroppedEventArgs e = new GridDroppedEventArgs() {
GridControl = GridControl,
TargetRowHandle = dropEventArgs.TargetRowHandle,
HitInfo = dropEventArgs.HitInfo,
Manager = this,
DraggedRows = dropEventArgs.DraggedRows,
SourceManager = sourceManager,
DropTargetType = dropEventArgs.DropTargetType,
};
DroppedEventHandler(this, e);
}
}
public DragDropHitTestResult(DragDropManagerBase manager)
: base(manager) {
}
void MoveSelectedRowsToGroup(DragDropManagerBase sourceManager, int groupRowHandle, DependencyObject hitElement) {
GroupInfo[] groupInfo = GetGroupInfos(groupRowHandle);
if(!CanMoveSelectedRowsToGroup(sourceManager, groupInfo, hitElement))
return;
foreach(object obj in sourceManager.DraggingRows) {
foreach(GroupInfo item in groupInfo) {
SetPropertyValue(sourceManager.GetObject(obj), item.FieldName, item.Value);
}
if(!ItemsSource.Contains(obj)) {
sourceManager.ItemsSource.Remove(sourceManager.GetObject(obj));
ItemsSource.Add(sourceManager.GetObject(obj));
}
}
}
protected void SetAddRowsDropInfo(DragDropManagerBase sourceManager, int insertRowHandle, DependencyObject hitElement) {
sourceManager.SetDropTargetType(DropTargetType.DataArea);
sourceManager.ShowDropMarker(GetDataAreaElement(hitElement), TableDragIndicatorPosition.None);
}
public GridDragSource(DragDropManagerBase dragDropManager)
: base(dragDropManager) {
}
protected bool IsSameGroup(DragDropManagerBase sourceManager, GroupInfo[] groupInfos, DependencyObject hitElement)
{
return((bool)IsSameGroupInfo.Invoke(this, new object[] { sourceManager, groupInfos, hitElement }));
}