private void suiteTreeView_DragOver(object sender, DragEventArgs e)
        {
            Point formP = this.PointToClient(new Point(e.X, e.Y));

            DragHelper.ImageList_DragMove(formP.X - this.suiteTreeView.Left, formP.Y - this.suiteTreeView.Top);
            TreeNode dropNode = this.suiteTreeView.GetNodeAt(this.suiteTreeView.PointToClient(new Point(e.X, e.Y)));

            if (dropNode == null)
            {
                e.Effect = DragDropEffects.None;
                return;
            }

            e.Effect = DragDropEffects.Move;

            if (this.tempDropNode != dropNode)
            {
                DragHelper.ImageList_DragShowNolock(false);
                this.suiteTreeView.SelectedNode = dropNode;
                DragHelper.ImageList_DragShowNolock(true);
                tempDropNode = dropNode;
            }

            TreeNode tmpNode = dropNode;

            while (tmpNode.Parent != null)
            {
                if (tmpNode.Parent == this.dragNode)
                {
                    e.Effect = DragDropEffects.None;
                }

                tmpNode = tmpNode.Parent;
            }
        }
        private void OnDragStarting(UIElement sender, DragStartingEventArgs args)
        {
            IEnumerable <DbMediaFile> files = null;
            var _vm = DataContext as CommonViewItemModel;

            switch (_vm.Type)
            {
            case CommonItemType.Album:
                files = _vm.InternalDbEntityId.GetAlbumById()
                        .MediaFiles
                        .OrderBy(c => c.DiscNumber)
                        .ThenBy(c => c.TrackNumber);
                break;

            case CommonItemType.Artist:
                files = _vm.InternalDbEntityId.GetArtistById()
                        .MediaFiles
                        .OrderBy(c => c.Album)
                        .ThenBy(c => c.DiscNumber)
                        .ThenBy(c => c.TrackNumber);
                break;
            }
            if (files != null)
            {
                args.DragUI.SetContentFromDataPackage();
                args.Data.RequestedOperation = DataPackageOperation.Copy;
                args.Data.SetText(DragHelper.Add(files));
            }
        }
        private void suiteTreeView_ItemDrag(object sender, ItemDragEventArgs e)
        {
            this.dragNode = (TreeNode)e.Item;
            this.suiteTreeView.SelectedNode = this.dragNode;

            this.imageListDrag.Images.Clear();
            this.imageListDrag.ImageSize = new Size(this.dragNode.Bounds.Size.Width + this.suiteTreeView.Indent, this.dragNode.Bounds.Height);

            Bitmap   bmp = new Bitmap(this.dragNode.Bounds.Width + this.suiteTreeView.Indent, this.dragNode.Bounds.Height);
            Graphics gfx = Graphics.FromImage(bmp);

            gfx.DrawImage(this.treeViewImages.Images[0], 0, 0);
            gfx.DrawString(this.dragNode.Text, this.suiteTreeView.Font, new SolidBrush(this.suiteTreeView.ForeColor), (float)this.suiteTreeView.Indent, 1.0f);

            this.imageListDrag.Images.Add(bmp);

            Point p = this.suiteTreeView.PointToClient(Control.MousePosition);

            int dx = p.X + this.suiteTreeView.Indent - this.dragNode.Bounds.Left;
            int dy = p.Y - this.dragNode.Bounds.Top;

            if (DragHelper.ImageList_BeginDrag(this.imageListDrag.Handle, 0, dx, dy))
            {
                this.suiteTreeView.DoDragDrop(bmp, DragDropEffects.Move);
                DragHelper.ImageList_EndDrag();
            }
        }
Beispiel #4
0
        void TemplateTree_DragOver(object sender, DragEventArgs e)
        {
            Point point = TemplateTree.PointToClient(new Point(e.X, e.Y));

            DragHelper.ImageList_DragMove(point.X, point.Y);
            e.Effect = DragDropEffects.Move;
        }
        private void timer_Tick(object sender, System.EventArgs e)
        {
            Point    pt   = PointToClient(Control.MousePosition);
            TreeNode node = this.suiteTreeView.GetNodeAt(pt);

            if (node == null)
            {
                return;
            }

            if (pt.Y < 30)
            {
                if (node.PrevVisibleNode != null)
                {
                    node = node.PrevVisibleNode;
                    DragHelper.ImageList_DragShowNolock(false);
                    node.EnsureVisible();
                    this.suiteTreeView.Refresh();
                    DragHelper.ImageList_DragShowNolock(true);
                }
            }
            else if (pt.Y > this.suiteTreeView.Size.Height - 30)
            {
                if (node.NextVisibleNode != null)
                {
                    node = node.NextVisibleNode;

                    DragHelper.ImageList_DragShowNolock(false);
                    node.EnsureVisible();
                    this.suiteTreeView.Refresh();
                    DragHelper.ImageList_DragShowNolock(true);
                }
            }
        }
        private void OnDragStarting(UIElement sender, DragStartingEventArgs args)
        {
            var playlist = (sender as FrameworkElement).DataContext as Playlist;

            args.DragUI.SetContentFromDataPackage();
            args.Data.RequestedOperation = DataPackageOperation.Copy;
            args.Data.SetText(DragHelper.Add(playlist));
        }
        private void TxtHeader_OnPreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            var element = (FrameworkElement)sender;

            _field = (SmartFiled)element.DataContext;
            DragHelper.SetClick(new DragElement((IDragElement)_field, WorkSpace.Instance), e);
            e.Handled = false;
        }
Beispiel #8
0
        protected override void OnItemDrag(ItemDragEventArgs e)
        {
            try
            {
                // Get drag node and select it
                this.dragNode = (TreeNode)e.Item;

                this.SelectedNode = this.dragNode;

                // Reset image list used for drag image
                this.imageListDrag.Images.Clear();
                this.imageListDrag.ImageSize = new Size(this.dragNode.Bounds.Size.Width + this.Indent, this.dragNode.Bounds.Height);

                // Create new bitmap
                // This bitmap will contain the tree node image to be dragged
                Bitmap bmp = new Bitmap(this.dragNode.Bounds.Width + this.Indent, this.dragNode.Bounds.Height);

                // Get graphics from bitmap
                Graphics gfx = Graphics.FromImage(bmp);

                // Draw node icon into the bitmap
                if (this.ImageList != null)
                {
                    this.imageListDrag.ColorDepth = this.ImageList.ColorDepth;

                    gfx.DrawImage(this.ImageList.Images[this.dragNode.ImageIndex], 0, 0);

                    // Draw node label into bitmap
                    gfx.DrawString(this.dragNode.Text,
                                   this.Font,
                                   new SolidBrush(this.ForeColor),
                                   (float)this.Indent, 1.0f);
                }
                // Add bitmap to imagelist
                this.imageListDrag.Images.Add(bmp);

                // Get mouse position in client coordinates
                Point p = this.PointToClient(Control.MousePosition);

                // Compute delta between mouse position and node bounds
                int dx = p.X + this.Indent - this.dragNode.Bounds.Left;
                int dy = p.Y - this.dragNode.Bounds.Top;

                // Begin dragging image
                if (DragHelper.ImageList_BeginDrag(this.imageListDrag.Handle, 0, dx, dy))
                {
                    // Begin dragging
                    this.DoDragDrop(bmp, DragDropEffects.Move);
                    // End dragging image
                    DragHelper.ImageList_EndDrag();
                }
            }
            catch (Exception ex)
            {
                ACSLog.InsertLog(MessageBoxIcon.Error, ex);
            }
        }
            /// <summary>
            /// Gets called when the item is dropped.
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void _Drop(object sender, DragEventArgs e)
            {
                var treeView = sender as TreeView;

                if (treeView == null || treeView != this._treeView)
                {
                    return;
                }

                // Unlock updates
                DragHelper.ImageList_DragShowNolock(false);
                treeView.Refresh();

                if (this._draggedNode != null && this.NodeMap != "")
                {
                    var      movingNode       = this._draggedNode;
                    var      NodeIndexes      = this.NodeMap.Split(_NODEMAP_DELIMITER);
                    var      InsertCollection = treeView.Nodes;
                    TreeNode newParent        = null;
                    for (var i = 0; i < NodeIndexes.Length - 1; i++)
                    {
                        var index = Int32.Parse(NodeIndexes[i]);
                        if (index > InsertCollection.Count)
                        {
                            index = InsertCollection.Count;
                        }
                        InsertCollection = (newParent = InsertCollection[index]).Nodes;
                    }

                    var insertIndex = Int32.Parse(NodeIndexes[NodeIndexes.Length - 1]);

                    // special case: we're inserting the node into the same tree again
                    var oldIndex = InsertCollection.IndexOf(movingNode);
                    // we need to decrement the stored index, because after removing the node, all following elements' indexes will be decremented
                    if (oldIndex <= insertIndex && movingNode.Parent == newParent)
                    {
                        --insertIndex;
                    }

                    // prepare move
                    this._OnNodeMove?.Invoke(movingNode, newParent, insertIndex);

                    // move
                    movingNode.Remove();
                    InsertCollection.Insert(insertIndex, movingNode);

                    var index2 = int.Parse(NodeIndexes[NodeIndexes.Length - 1]);
                    if (index2 < InsertCollection.Count)
                    {
                        treeView.SelectedNode = InsertCollection[index2];
                    }

                    this._draggedNode             = null;
                    this._dragScrollTimer.Enabled = false;
                }
            }
        public RecentRepositoriesListBox()
        {
            Columns.Add(new CustomListBoxColumn(0, Resources.StrName, true)
            {
                SizeMode = ColumnSizeMode.Fill
            });

            HeaderStyle = HeaderStyle.Hidden;
            _dragHelper = new DragHelper();
        }
Beispiel #11
0
        private void BetterTreeView_DragOver(object sender, DragEventArgs e)
        {
            DragScroll();

            // Compute drag position and move image
            Point formP = PointToClient(new Point(e.X, e.Y));

            DragHelper.ImageList_DragMove(formP.X - Left, formP.Y - Top);

            // Get actual drop node
            TreeNode dropNode = GetNodeAt(PointToClient(new Point(e.X, e.Y)));

            // Make sure we have a node.
            if (dropNode == null)
            {
                e.Effect = DragDropEffects.None;
                return;
            }

            if (tempDropNode != dropNode)
            {
                DragHelper.ImageList_DragShowNolock(false);
                SelectedNode = dropNode;
                DragHelper.ImageList_DragShowNolock(true);
                tempDropNode = dropNode;
            }

            // Make sure that we aren't dropping onto a child node.
            TreeNode tmpNode = dropNode;

            while (tmpNode.Parent != null)
            {
                if (tmpNode.Parent == dragNode)
                {
                    e.Effect = DragDropEffects.None;
                    return;
                }
                tmpNode = tmpNode.Parent;
            }

            // Allow any event handlers a chance to cancel the drag/drop.
            DragOverNodeEventArgs args = new DragOverNodeEventArgs(dragNode, dropNode);

            if (DragOverNode != null)
            {
                DragOverNode(this, args);
            }
            if (args.Cancel)
            {
                e.Effect = DragDropEffects.None;
                return;
            }

            e.Effect = DragDropEffects.All;
        }
        public LocalRepositoriesListBox()
        {
            Columns.Add(new CustomListBoxColumn(1, Resources.StrName, true)
            {
                SizeMode = ColumnSizeMode.Fill
            });

            HeaderStyle = HeaderStyle.Hidden;
            ItemHeight  = SystemInformation.IconSize.Height + 4;
            AllowDrop   = true;
            _dragHelper = new DragHelper();
        }
Beispiel #13
0
        private void CanvTag_PreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            var item = (FrameworkElement)sender;
            var tag  = item.DataContext as Tag;

            if (tag == null)
            {
                return;
            }
            DragHelper.SetClick(new DragElement((IDragElement)tag, TagGrp), e);
            e.Handled = false;
        }
Beispiel #14
0
        private void ImageScroll_PreviewMouseMove(object sender, MouseEventArgs e)
        {
            var position   = e.GetPosition(null);
            var difference = _previousPosition - position;

            if (e.LeftButton == MouseButtonState.Pressed && DragHelper.IsSignificantDrag(difference))
            {
                _previousPosition = position;

                ImageScroll.ScrollToHorizontalOffset(ImageScroll.HorizontalOffset + difference.X);
                ImageScroll.ScrollToVerticalOffset(ImageScroll.VerticalOffset + difference.Y);
            }
        }
Beispiel #15
0
        private void Tag_OnPreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            var element = (FrameworkElement)sender;
            Tag tag     = element.DataContext as Tag;

            if (tag == null)
            {
                return;
            }
            var dragElement = new DragProcessor.DragElement((DragProcessor.IDragElement)tag, WorkSpace.Instance.ActiveField);

            DragHelper.SetClick(dragElement, e);
        }
Beispiel #16
0
        public MainWindow()
        {
            this.InitializeComponent();

            this.ViewModel.PropertyChanged += (_, e) =>
            {
                if (e.PropertyName == nameof(this.ViewModel.Project))
                {
                    this.Zoom.Center();
                }
            };

            this.drag = new DragHelper(this.ViewModel);
        }
Beispiel #17
0
        private void timer_Tick(object sender, EventArgs e)
        {
            try
            {
                // get node at mouse position
                Point    pt   = PointToClient(Control.MousePosition);
                TreeNode node = this.GetNodeAt(pt);

                if (node == null)
                {
                    return;
                }

                // if mouse is near to the top, scroll up
                if (pt.Y < 30)
                {
                    // set actual node to the upper one
                    if (node.PrevVisibleNode != null)
                    {
                        node = node.PrevVisibleNode;

                        // hide drag image
                        DragHelper.ImageList_DragShowNolock(false);
                        // scroll and refresh
                        node.EnsureVisible();
                        this.Refresh();
                        // show drag image
                        DragHelper.ImageList_DragShowNolock(true);
                    }
                }
                // if mouse is near to the bottom, scroll down
                else if (pt.Y > this.Size.Height - 30)
                {
                    if (node.NextVisibleNode != null)
                    {
                        node = node.NextVisibleNode;

                        DragHelper.ImageList_DragShowNolock(false);
                        node.EnsureVisible();
                        this.Refresh();
                        DragHelper.ImageList_DragShowNolock(true);
                    }
                }
            }
            catch (Exception ex)
            {
                ACSLog.InsertLog(MessageBoxIcon.Error, ex);
            }
        }
Beispiel #18
0
        protected override void OnDragLeave(EventArgs e)
        {
            try
            {
                this.dragging = false;
                DragHelper.ImageList_DragLeave(this.Handle);

                // Disable timer for scrolling dragged item
                this.timer.Enabled = false;
            }
            catch (Exception ex)
            {
                ACSLog.InsertLog(MessageBoxIcon.Error, ex);
            }
        }
            /// <summary>
            /// Gets called when a dragged item leaves the control.
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void _DragLeave(object sender, EventArgs e)
            {
                var treeView = sender as TreeView;

                if (treeView == null || treeView != this._treeView)
                {
                    return;
                }

                // remove drag/drop image
                DragHelper.ImageList_DragLeave(treeView.Handle);

                // Disable timer for scrolling dragged item
                this._dragScrollTimer.Enabled = false;
            }
Beispiel #20
0
        private void treeView1_DragEnter(object sender, System.Windows.Forms.DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.Text))
            {
                e.Effect = DragDropEffects.Move;
            }
            else
            {
                e.Effect = DragDropEffects.None;
            }


            DragHelper.ImageList_DragEnter(this.treeView1.Handle, e.X - this.treeView1.Left,
                                           e.Y - this.treeView1.Top);
        }
Beispiel #21
0
        protected override void OnDragEnter(DragEventArgs drgevent)
        {
            try
            {
                DragHelper.ImageList_DragEnter(this.Handle, drgevent.X - this.Left,
                                               drgevent.Y - this.Top);

                // Enable timer for scrolling dragged item
                this.timer.Enabled = true;
            }
            catch (Exception e)
            {
                ACSLog.InsertLog(MessageBoxIcon.Error, e);
            }
        }
            private void _Draw()
            {
                // hide image
                DragHelper.ImageList_DragShowNolock(false);

                // paint treeview
                this._treeView.Refresh();

                // paint placeholder
                var hoveredNode = this._nodeOver;

                if (hoveredNode != null && hoveredNode.TreeView != null)
                {
                    switch (this._placeHolder)
                    {
                    case PlaceHolderType.LeafTop: {
                        this._DrawLeafTopPlaceholders(hoveredNode);
                        break;
                    }

                    case PlaceHolderType.LeafBottom: {
                        this._DrawLeafBottomPlaceholders(hoveredNode, this._parentDragDrop);
                        break;
                    }

                    case PlaceHolderType.AddToFolder: {
                        this._DrawAddToFolderPlaceholder(hoveredNode);
                        break;
                    }

                    case PlaceHolderType.FolderTop: {
                        this._DrawFolderTopPlaceholders(hoveredNode);
                        break;
                    }

                    case PlaceHolderType.None: {
                        break;
                    }

                    default: {
                        throw new NotImplementedException("Unknown place holder type");
                    }
                    }
                }

                // paint image
                DragHelper.ImageList_DragShowNolock(true);
            }
Beispiel #23
0
        private static void OnPreviewMouseMove(object sender, MouseEventArgs e)
        {
            var position   = e.GetPosition(null);
            var difference = _startPosition - position;

            if (e.LeftButton == MouseButtonState.Pressed && DragHelper.IsSignificantDrag(difference))
            {
                var dependencyObject = sender as DependencyObject;

                var command = (ICommand)dependencyObject.GetValue(CommandProperty);
                //var commandParameter = dependencyObject.GetValue(CommandParameterProperty);
                var commandParameter = e.OriginalSource;

                command.Execute(commandParameter);
            }
        }
Beispiel #24
0
        public UCRegionSeatSetting()
        {
            InitializeComponent();

            mListRegionSeats  = new List <RegionSeatInfo>();
            mListToolBtnItems = new List <ImageButtonItem>();
            mListSeatItems    = new ObservableCollection <RegionSeatItem>();
            mListAllSeatInfos = new List <SeatInfo>();

            mDragHelper = new DragHelper();

            Loaded += UCRegionSeatSetting_Loaded;
            TxtSeatLeft.KeyDown         += TxtSeatLeft_KeyDown;
            TxtSeatTop.KeyDown          += TxtSeatTop_KeyDown;
            SliderMapScale.ValueChanged += SliderMapScale_ValueChanged;
        }
Beispiel #25
0
        private void Node_OnPreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            var nodeCtrl = sender as NodeCotrol;

            if (nodeCtrl != null && nodeCtrl.IsDraEnable)
            {
                var nodes = new List <Node>(SelectedNodes);
                var node  = ((FrameworkElement)sender).DataContext as Node;
                if (!nodes.Contains(node))
                {
                    nodes.Add(node);
                }
                var data = new DragProcessor.DragElement(nodes, CurTag);
                DragHelper.SetClick(data, e);
                e.Handled = false;
            }
        }
Beispiel #26
0
        private async void OnPlayItemsListViewDragEnter(object sender, DragEventArgs e)
        {
            var def = e.GetDeferral();

            if (e.DataView.Contains(StandardDataFormats.StorageItems))
            {
                e.AcceptedOperation = DataPackageOperation.Copy;
            }
            else if (e.DataView.Contains(StandardDataFormats.Text))
            {
                if (DragHelper.Contains(await e.DataView.GetTextAsync()))
                {
                    e.AcceptedOperation = DataPackageOperation.Copy;
                }
            }
            def.Complete();
        }
            /// <summary>
            /// Gets called when the timer ticks.
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void _Tick(object sender, EventArgs e)
            {
                var treeView = this._treeView;

                // get node at mouse position
                var pt   = treeView.PointToClient(Control.MousePosition);
                var node = treeView.GetNodeAt(pt);

                if (node == null)
                {
                    return;
                }

                // if mouse is near to the top, scroll up
                if (pt.Y < _SCROLL_PIXEL_RANGE)
                {
                    // set actual node to the upper one
                    if (node.PrevVisibleNode == null)
                    {
                        return;
                    }

                    node = node.PrevVisibleNode;

                    // hide drag image
                    DragHelper.ImageList_DragShowNolock(false);

                    // scroll and refresh
                    node.EnsureVisible();
                    this._Draw();
                }
                // if mouse is near to the bottom, scroll down
                else if (pt.Y > treeView.Size.Height - _SCROLL_PIXEL_RANGE)
                {
                    if (node.NextVisibleNode == null)
                    {
                        return;
                    }

                    node = node.NextVisibleNode;

                    DragHelper.ImageList_DragShowNolock(false);
                    node.EnsureVisible();
                    this._Draw();
                }
            }
Beispiel #28
0
        protected override void OnDragOver(DragEventArgs drgevent)
        {
            try
            {
                // Compute drag position and move image
                Point formP = this.PointToClient(new Point(drgevent.X, drgevent.Y));
                //DragHelper.ImageList_DragMove(formP.X - this.Left, formP.Y - this.Top);
                DragHelper.ImageList_DragMove(formP.X, formP.Y);

                // Get actual drop node
                TreeNode dropNode = this.GetNodeAt(this.PointToClient(new Point(drgevent.X, drgevent.Y)));
                if (dropNode == null)
                {
                    //Verificar
                    //drgevent.Effect = DragDropEffects.None;
                    return;
                }

                drgevent.Effect = DragDropEffects.Move;

                // if mouse is on a new node select it
                if (this.tempDropNode != dropNode)
                {
                    DragHelper.ImageList_DragShowNolock(false);
                    this.SelectedNode = dropNode;
                    DragHelper.ImageList_DragShowNolock(true);
                    tempDropNode = dropNode;
                }

                // Avoid that drop node is child of drag node
                TreeNode tmpNode = dropNode;
                while (tmpNode.Parent != null)
                {
                    if (tmpNode.Parent == this.dragNode)
                    {
                        drgevent.Effect = DragDropEffects.None;
                    }
                    tmpNode = tmpNode.Parent;
                }
            }
            catch (Exception e)
            {
                ACSLog.InsertLog(MessageBoxIcon.Error, e);
            }
        }
Beispiel #29
0
        private void treeView1_ItemDrag(object sender, System.Windows.Forms.ItemDragEventArgs e)
        {
            dragNode = (TreeNode)e.Item;
            string strItem = dragNode.Name;

            this.imageListDrag.Images.Clear();
            this.imageListDrag.ImageSize = new Size(this.dragNode.Bounds.Size.Width + this.treeView1.Indent, this.dragNode.Bounds.Height);

            Bitmap bmp = new Bitmap(this.dragNode.Bounds.Width + this.treeView1.Indent, this.dragNode.Bounds.Height);



            // Get graphics from bitmap
            Graphics gfx = Graphics.FromImage(bmp);


            gfx.DrawImage(this.imageList1.Images[0], 0, 0);

            // Draw node label into bitmap
            gfx.DrawString(this.dragNode.Text,
                           this.treeView1.Font,
                           new SolidBrush(this.treeView1.ForeColor),
                           (float)this.treeView1.Indent, 1.0f);

            // Add bitmap to imagelist
            this.imageListDrag.Images.Add(bmp);


            Point p = this.treeView1.PointToClient(Control.MousePosition);

            // Compute delta between mouse position and node bounds
            int dx = p.X + this.treeView1.Indent - this.dragNode.Bounds.Left;
            int dy = p.Y - this.dragNode.Bounds.Top;

            // Begin dragging image
            if (DragHelper.ImageList_BeginDrag(this.imageListDrag.Handle, 0, dx, dy))
            {
                // Begin dragging
                // this.treeView1.DoDragDrop(bmp, DragDropEffects.Move);

                DoDragDrop(strItem, DragDropEffects.Move);
                // End dragging image
                DragHelper.ImageList_EndDrag();
            }
        }
    public void OnDrag(Puzzle puzzle)
    {
        if (overlappedSlots.Count == 0)
        {
            if (lastSlot != null)
            {
                SetAlpha(0f);
                lastSlot = null;
            }
            return;
        }

        var slot = DragHelper.GetClosestSlot(puzzle, overlappedSlots);

        MoveHighlightTo(slot);

        lastSlot = slot;
    }