본문으로 바로가기

Xtragrid Row를 끌어서 이동시키기(행 바꾸기)

category 프로그래밍/DEVEXPRESS 2016. 4. 12. 10:43

 

 

Xtragrid Row를 드래그 드롭으로 옮기게 하는 클래스이다.

사용법은 GridControlDragNDropClass 인스턴스를 생성하고 SetGridControlDrag 메서드를 이용하면 됨.

   #region GridControlDragNDropClass


        /// <summary>
        /// GridControl Drag에 적용할 Type
        /// </summary>
        public enum enumSetGridControlDrag
        {
            /// <summary>
            /// Drag에 적용하는 이미지를 BitMap으로 사용하여, 크기제한이 없음.
            /// </summary>
            UsingBitmap,
            /// <summary>
            /// Drag에 적용하는 이미지를 ImageList를 사용하여 255, 255 크기 제한이 있음.
            /// </summary>
            UsingImageList,
        }

        /// <summary>
        /// 해당 GridControl에 Drag N Drop를진행할때 적용 모드
        /// </summary>
        public enum enumSetGridControlDragNDropMode
        {
            /// <summary>
            /// 해당 Grid에는 끌기 작업만 진행할 수 있음. Drop작업을 할 수 없음.
            /// </summary>
            UsingDrag,
            /// <summary>
            /// 해당 Grid는 끌기작업을 할수 없으며, Drop작업만 할 수 있음.
            /// </summary>
            UsingDrop,
            /// <summary>
            /// 해당 Grid는 끌기작업 및 Drop작업 모두 가능함.
            /// </summary>
            UsingBoth
        }

        /// <summary>
        /// GridControl에 Drag시 선택한 Row를 마우스 커서 표시
        /// </summary>
        public class GridControlDragNDropClass
        {
            /// <summary>
            /// 생성자
            /// </summary>
            public GridControlDragNDropClass()
            {

            }

            /// <summary>
            /// GridControl에 Drag시 선택한 Row를 마우스 커서에 표시할 수 있도록 세팅 METHOD
            /// </summary>
            /// <param name="enumDragType">Drag를 적용할 Type</param>
            /// <param name="gridcontrol">적용할 GridControl</param>
            /// <param name="enumDragMode">GridControl에 적용할 Drag N Drop MODE</param>
            /// <param name="iTranspValue">BitMap에서만 적용할 투명도(Max. 255)</param>
            public void SetGridControlDrag(enumSetGridControlDrag enumDragType, GridControl gridcontrol, enumSetGridControlDragNDropMode enumDragMode, int iTranspValue = 200)
            {
                switch (enumDragType)
                {
                    case enumSetGridControlDrag.UsingBitmap:
                        GridControlDragHelperUsingBitmap gridBitmap = new GridControlDragHelperUsingBitmap();
                        gridBitmap.SetGridControlDrag(gridcontrol, enumDragMode, iTranspValue);
                        break;
                    case enumSetGridControlDrag.UsingImageList:
                        GridControlDragHelperUsingImageList gridImageList = new GridControlDragHelperUsingImageList();
                        gridImageList.SetGridControlDrag(gridcontrol, enumDragMode);
                        break;
                }
            }
        }

 

        class GridControlDragHelperUsingBitmap
        {
            int iTransValue = 200;
            GridHitInfo downHitInfo = null;
            gCursor gCurPic = null;
            readonly Cursor curNo = new Cursor(new MemoryStream(global::HRCS_ADDIN_REVIEW.Properties.Resources.no));
            readonly Cursor curMove = new Cursor(new MemoryStream(global::HRCS_ADDIN_REVIEW.Properties.Resources.move));
            readonly Cursor curCopy = new Cursor(new MemoryStream(global::HRCS_ADDIN_REVIEW.Properties.Resources.copy));
            enumSetGridControlDragNDropMode enumDragMode = enumSetGridControlDragNDropMode.UsingBoth;

// 요고는 커서모양을 리소스에 넣어둠.

            public GridControlDragHelperUsingBitmap()
            {

            }


            internal void SetGridControlDrag(GridControl gridcontrol, enumSetGridControlDragNDropMode enumDragMode, int iTransValue = 200)
            {
                gridcontrol.AllowDrop = true;
                this.enumDragMode = enumDragMode;
                this.iTransValue = iTransValue;
                if (enumDragMode != enumSetGridControlDragNDropMode.UsingDrop)
                {
                    GridView gv = gridcontrol.MainView as GridView;
                    gv.MouseDown += GridView_MouseDown;
                    gv.MouseMove += GridView_MouseMove;
                }

                gridcontrol.GiveFeedback += GridControl_GiveFeedback;
                gridcontrol.DragOver += GridControl_DragOver;
            }


            void GridView_MouseDown(object sender, MouseEventArgs e)
            {
                GridView gv = sender as GridView;
                downHitInfo = null;
                GridHitInfo ghi = gv.CalcHitInfo(e.Location);
                if (!ghi.InRow) return;
                if (Control.ModifierKeys != Keys.None) return;
                if (e.Button == System.Windows.Forms.MouseButtons.Left && ghi.RowHandle > -1) downHitInfo = ghi;
            }


            void GridView_MouseMove(object sender, MouseEventArgs e)
            {
                GridView gv = sender as GridView;
                if (e.Button == System.Windows.Forms.MouseButtons.Left && downHitInfo != null)
                {
                    Size dragSize = SystemInformation.DragSize;
                    Rectangle dragRect = new Rectangle(new Point(downHitInfo.HitPoint.X - dragSize.Width / 2,
                        downHitInfo.HitPoint.Y - dragSize.Height / 2), dragSize);
                    if (!dragRect.Contains(new Point(e.X, e.Y)))
                    {
                        GridViewInfo gvi = gv.GetViewInfo() as GridViewInfo;
                        GridRowInfo gri = gvi.GetGridRowInfo(downHitInfo.RowHandle);
                        Rectangle retTempGri = gri.DataBounds;
                        int intWid = gri.DataBounds.Width;
                        if (gv.GridControl.Width < intWid)
                        {
                            intWid = gv.GridControl.Width - gvi.ViewRects.ColumnPanelLeft;
                            retTempGri.X += retTempGri.Width - gv.GridControl.Width + gvi.ViewRects.ColumnPanelLeft;
                        }
                        Bitmap bmp = new Bitmap(intWid, gri.DataBounds.Height);
                        Graphics gfx = Graphics.FromImage(bmp);

                        Rectangle retTemp = gv.GridControl.RectangleToScreen(retTempGri);
                        gfx.CopyFromScreen(retTemp.Location, new Point(0, 0), retTemp.Size);
                        gCurPic = new gCursor(bmp, this.iTransValue);
                        DataRow row = gv.GetDataRow(downHitInfo.RowHandle);

                        gv.GridControl.DoDragDrop(row, DragDropEffects.All);
                        downHitInfo = null;
                    }
                }
            }


            void GridControl_DragOver(object sender, DragEventArgs e)
            {
                if (!e.Data.GetDataPresent(typeof(DataRow))) return;
                GridControl gridcontrol = sender as GridControl;
                GridView gv = gridcontrol.MainView as GridView;
                Point formP = gridcontrol.PointToClient(new Point(e.X, e.Y));
                GridHitInfo ghi = gv.CalcHitInfo(formP);
                if (ghi.InRow)
                {
                    gv.FocusedRowHandle = ghi.RowHandle;
                }
                DataRow row = e.Data.GetData(typeof(DataRow)) as DataRow;
                DataRow drSel = gv.GetFocusedDataRow();
                bool isSame = false;

                if (drSel != null && drSel.Table == row.Table) isSame = true;
                switch (ghi.HitTest)
                {
                    case GridHitTest.Row:
                    case GridHitTest.RowCell:
                    case GridHitTest.EmptyRow:
                    case GridHitTest.RowEdge:
                        e.Effect = isSame ? DragDropEffects.Move : DragDropEffects.Copy;
                        if (isSame && enumDragMode == enumSetGridControlDragNDropMode.UsingDrag) e.Effect = DragDropEffects.None;
                        break;
                    default:
                        e.Effect = DragDropEffects.None;
                        break;
                }

            }


            void GridControl_GiveFeedback(object sender, GiveFeedbackEventArgs e)
            {
                e.UseDefaultCursors = false;
                switch (e.Effect)
                {
                    case DragDropEffects.Copy:
                        gCurPic.EffectCursor = curCopy;
                        break;
                    case DragDropEffects.Move:
                        gCurPic.EffectCursor = curMove;
                        break;
                    default:
                        gCurPic.EffectCursor = curNo;
                        break;
                }
                gCurPic.MakeCursor();
                Cursor.Current = gCurPic.cCursor;
            }
        }


        class gCursor
        {
            [StructLayout(LayoutKind.Sequential)]
            private struct ICONINFO
            {
                public bool IsIcon;
                public int xHotspot;
                public int yHotspot;
                public IntPtr MaskBitmap;
                public IntPtr ColorBitmap;
            };

            [DllImport("user32.dll")]
            static extern IntPtr CreateIconIndirect([In] ref ICONINFO iconinfo);

            [DllImport("user32.dll", EntryPoint = "DestroyIcon", SetLastError = true)]
            static extern bool DestroyIcon(IntPtr hIcon);

            [DllImport("gdi32.dll")]
            static extern bool DeleteObject(IntPtr hObject);


            public Bitmap _gImage { get; set; }
            public int gITransp { get; set; }
            public Cursor cCursor { get; set; }

            private Bitmap _gCursorImage;
            public Bitmap gCursorImage
            {
                get { return _gCursorImage; }
                set { _gCursorImage = value; }
            }

            Cursor _EffectCursor = Cursors.Default;
            public Cursor EffectCursor
            {
                get { return _EffectCursor; }
                set { _EffectCursor = value; }
            }

            private Point _gHotSpotPt = new Point(0, 0);


            public gCursor(Bitmap bmp, int iTranRate)
            {
                _gImage = bmp;
                if (iTranRate < 255)
                {
                    Bitmap bm = new Bitmap(_gImage.Width, _gImage.Height);
                    using (ImageAttributes imageAtt = new ImageAttributes())
                    {
                        imageAtt.SetColorMatrix(new ColorMatrix() { Matrix33 = (float)iTranRate / (float)255 });
                        using (Graphics g = Graphics.FromImage(bm))
                        {
                            g.DrawImage(_gImage, new Rectangle(0, 0, _gImage.Width, _gImage.Height), 0, 0, _gImage.Width, _gImage.Height, GraphicsUnit.Pixel, imageAtt);
                        }
                    }
                    _gImage = bm;
                }
            }

            internal void MakeCursor()
            {
                _gHotSpotPt = new Point(_gImage.Width / 2, _gImage.Height / 2);
                Bitmap bm = new Bitmap(_gImage.Width + 32, _gImage.Height + 32);
                using (Graphics g = Graphics.FromImage(bm))
                {
                    g.DrawImage(_gImage, 0, 0);
                    _EffectCursor.Draw(g, new Rectangle(_gHotSpotPt.X, _gHotSpotPt.Y, EffectCursor.Size.Width, EffectCursor.Size.Height));
                    cCursor = CreateCursor(bm);
                }
                bm.Dispose();
            }

            IntPtr curPtr;
            private Cursor CreateCursor(Bitmap bm)
            {
                if (_gCursorImage != null) _gCursorImage.Dispose();
                if (curPtr != IntPtr.Zero) DestroyIcon(curPtr);

                ICONINFO tmp = new ICONINFO();
                tmp.xHotspot = _gHotSpotPt.X;
                tmp.yHotspot = _gHotSpotPt.Y;
                tmp.IsIcon = false;
                tmp.MaskBitmap = bm.GetHbitmap();
                tmp.ColorBitmap = bm.GetHbitmap();

                curPtr = CreateIconIndirect(ref tmp);

                _gCursorImage = Icon.FromHandle(curPtr).ToBitmap();
                if (tmp.MaskBitmap != IntPtr.Zero) DeleteObject(tmp.MaskBitmap);
                if (tmp.ColorBitmap != IntPtr.Zero) DeleteObject(tmp.ColorBitmap);

                return new Cursor(curPtr);
            }
        }

 

 


        class GridControlDragHelperUsingImageList
        {
            GridHitInfo downHitInfo = null;
            int dropTargetRowHandle = -1;
            int DropTargetRowHandle
            {
                get { return dropTargetRowHandle; }
                set
                {
                    dropTargetRowHandle = value;
                }
            }
            enumSetGridControlDragNDropMode enumDragMode = enumSetGridControlDragNDropMode.UsingBoth;

            public GridControlDragHelperUsingImageList()
            {
            }


            internal void SetGridControlDrag(GridControl gridcontrol, enumSetGridControlDragNDropMode enumDragMode)
            {
                this.enumDragMode = enumDragMode;
                if (enumDragMode != enumSetGridControlDragNDropMode.UsingDrop)
                {
                    GridView gv = gridcontrol.MainView as GridView;
                    gv.MouseDown += GridView_MouseDown;
                    gv.MouseMove += GridView_MouseMove;
                }

                gridcontrol.DragOver += GridControl_DragOver;
                gridcontrol.DragEnter += GridControl_DragEnter;
                gridcontrol.DragLeave += GridControl_DragLeave;
            }


            void GridView_MouseDown(object sender, MouseEventArgs e)
            {
                GridView gv = sender as GridView;
                downHitInfo = null;
                GridHitInfo ghi = gv.CalcHitInfo(e.Location);
                if (!ghi.InRow) return;
                if (Control.ModifierKeys != Keys.None) return;
                if (e.Button == System.Windows.Forms.MouseButtons.Left && ghi.RowHandle > -1) downHitInfo = ghi;
            }

 

            void GridView_MouseMove(object sender, MouseEventArgs e)
            {
                GridView gv = sender as GridView;
                if (e.Button == System.Windows.Forms.MouseButtons.Left && downHitInfo != null)
                {
                    Size dragSize = SystemInformation.DragSize;
                    Rectangle dragRect = new Rectangle(new Point(downHitInfo.HitPoint.X - dragSize.Width / 2,
                        downHitInfo.HitPoint.Y - dragSize.Height / 2), dragSize);
                    if (!dragRect.Contains(new Point(e.X, e.Y)))
                    {
                        GridViewInfo gvi = gv.GetViewInfo() as GridViewInfo;
                        GridRowInfo gri = gvi.GetGridRowInfo(downHitInfo.RowHandle);

                        Bitmap bmp = new Bitmap(gri.DataBounds.Width > 256 ? 256 : gri.DataBounds.Width, gri.DataBounds.Height > 256 ? 256 : gri.DataBounds.Height);
                        Graphics gfx = Graphics.FromImage(bmp);
                        Rectangle retTemp = gv.GridControl.RectangleToScreen(gri.DataBounds);
                        gfx.CopyFromScreen(retTemp.Location, new Point(0, 0), retTemp.Size);

                        ImageList imageListDrag = new ImageList();
                        imageListDrag.ImageSize = bmp.Size;
                        imageListDrag.Images.Add(bmp);
                        // Compute delta between mouse position and node bounds

                        DataRow row = gv.GetDataRow(downHitInfo.RowHandle);

                        if (DragHelper.ImageList_BeginDrag(imageListDrag.Handle, 0, 0, 0))
                        {
                            // Begin dragging
                            gv.GridControl.DoDragDrop(row, DragDropEffects.Move);
                            downHitInfo = null;
                            // End dragging image
                            DragHelper.ImageList_EndDrag();
                        }
                    }
                }
            }


            void GridControl_DragLeave(object sender, EventArgs e)
            {
                GridControl gridcontrol = sender as GridControl;
                DragHelper.ImageList_DragLeave(gridcontrol.Handle);
            }


            void GridControl_DragEnter(object sender, DragEventArgs e)
            {
                GridControl gridcontrol = sender as GridControl;
                DragHelper.ImageList_DragEnter(gridcontrol.Handle, e.X - gridcontrol.Left,
                    e.Y - gridcontrol.Top);
            }


            void GridControl_DragOver(object sender, DragEventArgs e)
            {
                GridControl gridcontrol = sender as GridControl;
                Point formP = gridcontrol.PointToClient(new Point(e.X, e.Y));

                GridView gv = gridcontrol.MainView as GridView;
                GridHitInfo ghi = gv.CalcHitInfo(formP);

                DragHelper.ImageList_DragMove(formP.X - gridcontrol.Left, formP.Y - gridcontrol.Top);
                if (e.Data.GetDataPresent(typeof(DataRow)))
                    e.Effect = DragDropEffects.Move;
                else
                    e.Effect = DragDropEffects.None;

            }


        }


        class DragHelper
        {
            internal static Control controls = null;

            [DllImport("comctl32.dll")]
            static extern bool InitCommonControls();

            [DllImport("comctl32.dll", CharSet = CharSet.Auto)]
            internal static extern bool ImageList_BeginDrag(IntPtr himlTrack, int
                iTrack, int dxHotspot, int dyHotspot);

            [DllImport("comctl32.dll", CharSet = CharSet.Auto)]
            internal static extern bool ImageList_DragMove(int x, int y);

            [DllImport("comctl32.dll", CharSet = CharSet.Auto)]
            internal static extern void ImageList_EndDrag();

            [DllImport("comctl32.dll", CharSet = CharSet.Auto)]
            internal static extern bool ImageList_DragEnter(IntPtr hwndLock, int x, int y);

            [DllImport("comctl32.dll", CharSet = CharSet.Auto)]
            internal static extern bool ImageList_DragLeave(IntPtr hwndLock);

            [DllImport("comctl32.dll", CharSet = CharSet.Auto)]
            internal static extern bool ImageList_DragShowNolock(bool fShow);

            static DragHelper()
            {
                InitCommonControls();
            }
        }


        #endregion

 

 

'프로그래밍 > DEVEXPRESS' 카테고리의 다른 글

Xtragrid Column CheckEdit으로 만들기  (0) 2016.04.12
Dev의 모든 글꼴 바꾸기  (1) 2016.04.12