/*
 * DropSink.cs - Add drop sink ability to an ObjectListView
 *
 * Author: Phillip Piper
 * Date: 2009-03-17 5:15 PM
 *
 * Change log:
 * 2010-08-24   JPP  - Moved AcceptExternal property up to SimpleDragSource.
 * v2.3
 * 2009-09-01   JPP  - Correctly handle case where RefreshObjects() is called for
 *                     objects that were children but are now roots.
 * 2009-08-27   JPP  - Added ModelDropEventArgs.RefreshObjects() to simplify updating after
 *                     a drag-drop operation
 * 2009-08-19   JPP  - Changed to use OlvHitTest()
 * v2.2.1
 * 2007-07-06   JPP  - Added StandardDropActionFromKeys property to OlvDropEventArgs
 * v2.2
 * 2009-05-17   JPP  - Added a Handled flag to OlvDropEventArgs
 *                   - Tweaked the appearance of the drop-on-background feedback
 * 2009-04-15   JPP  - Separated DragDrop.cs into DropSink.cs
 * 2009-03-17   JPP  - Initial version
 * 
 * Copyright (C) 2009-2010 Phillip Piper
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
 */

using System;
using System.Collections;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;

namespace BrightIdeasSoftware
{
    /// <summary>
    /// Objects that implement this interface can acts as the receiver for drop
    /// operation for an ObjectListView.
    /// </summary>
    public interface IDropSink
    {
        /// <summary>
        /// Gets or sets the ObjectListView that is the drop sink
        /// </summary>
        ObjectListView ListView { get; set; }

        /// <summary>
        /// Draw any feedback that is appropriate to the current drop state.
        /// </summary>
        /// <remarks>
        /// Any drawing is done over the top of the ListView. This operation should disturb
        /// the Graphic as little as possible. Specifically, do not erase the area into which
        /// you draw. 
        /// </remarks>
        /// <param name="g">A Graphic for drawing</param>
        /// <param name="bounds">The contents bounds of the ListView (not including any header)</param>
        void DrawFeedback(Graphics g, Rectangle bounds);

        /// <summary>
        /// The user has released the drop over this control
        /// </summary>
        /// <remarks>
        /// Implementators should set args.Effect to the appropriate DragDropEffects. This value is returned
        /// to the originator of the drag.
        /// </remarks>
        /// <param name="args"></param>
        void Drop(DragEventArgs args);

        /// <summary>
        /// A drag has entered this control.
        /// </summary>
        /// <remarks>Implementators should set args.Effect to the appropriate DragDropEffects.</remarks>
        /// <param name="args"></param>
        void Enter(DragEventArgs args);

        /// <summary>
        /// Change the cursor to reflect the current drag operation.
        /// </summary>
        /// <param name="args"></param>
        void GiveFeedback(GiveFeedbackEventArgs args);

        /// <summary>
        /// The drag has left the bounds of this control
        /// </summary>
        void Leave();

        /// <summary>
        /// The drag is moving over this control.
        /// </summary>
        /// <remarks>This is where any drop target should be calculated.
        /// Implementators should set args.Effect to the appropriate DragDropEffects.
        /// </remarks>
        /// <param name="args"></param>
        void Over(DragEventArgs args);

        /// <summary>
        /// Should the drag be allowed to continue?
        /// </summary>
        /// <param name="args"></param>
        void QueryContinue(QueryContinueDragEventArgs args);
    }

    /// <summary>
    /// This is a do-nothing implementation of IDropSink that is a useful
    /// base class for more sophisticated implementations.
    /// </summary>
    public class AbstractDropSink : IDropSink
    {
        #region IDropSink Members

        /// <summary>
        /// Gets or sets the ObjectListView that is the drop sink
        /// </summary>
        public virtual ObjectListView ListView {
            get { return listView; }
            set { this.listView = value; }
        }
        private ObjectListView listView;

        /// <summary>
        /// Draw any feedback that is appropriate to the current drop state.
        /// </summary>
        /// <remarks>
        /// Any drawing is done over the top of the ListView. This operation should disturb
        /// the Graphic as little as possible. Specifically, do not erase the area into which
        /// you draw. 
        /// </remarks>
        /// <param name="g">A Graphic for drawing</param>
        /// <param name="bounds">The contents bounds of the ListView (not including any header)</param>
        public virtual void DrawFeedback(Graphics g, Rectangle bounds) {
        }

        /// <summary>
        /// The user has released the drop over this control
        /// </summary>
        /// <remarks>
        /// Implementators should set args.Effect to the appropriate DragDropEffects. This value is returned
        /// to the originator of the drag.
        /// </remarks>
        /// <param name="args"></param>
        public virtual void Drop(DragEventArgs args) {
            this.Cleanup();
        }

        /// <summary>
        /// A drag has entered this control.
        /// </summary>
        /// <remarks>Implementators should set args.Effect to the appropriate DragDropEffects.</remarks>
        /// <param name="args"></param>
        public virtual void Enter(DragEventArgs args) {
        }

        /// <summary>
        /// The drag has left the bounds of this control
        /// </summary>
        public virtual void Leave() {
            this.Cleanup();
        }

        /// <summary>
        /// The drag is moving over this control.
        /// </summary>
        /// <remarks>This is where any drop target should be calculated.
        /// Implementators should set args.Effect to the appropriate DragDropEffects.
        /// </remarks>
        /// <param name="args"></param>
        public virtual void Over(DragEventArgs args) {
        }

        /// <summary>
        /// Change the cursor to reflect the current drag operation.
        /// </summary>
        /// <remarks>You only need to override this if you want non-standard cursors.
        /// The standard cursors are supplied automatically.</remarks>
        /// <param name="args"></param>
        public virtual void GiveFeedback(GiveFeedbackEventArgs args) {
            args.UseDefaultCursors = true;
        }

        /// <summary>
        /// Should the drag be allowed to continue?
        /// </summary>
        /// <remarks>
        /// You only need to override this if you want the user to be able
        /// to end the drop in some non-standard way, e.g. dragging to a
        /// certain point even without releasing the mouse, or going outside
        /// the bounds of the application. 
        /// </remarks>
        /// <param name="args"></param>
        public virtual void QueryContinue(QueryContinueDragEventArgs args) {
        }


        #endregion

        #region Commands

        /// <summary>
        /// This is called when the mouse leaves the drop region and after the
        /// drop has completed.
        /// </summary>
        protected virtual void Cleanup() {
        }

        #endregion
    }

    /// <summary>
    /// The enum indicates which target has been found for a drop operation
    /// </summary>
    [Flags]
    public enum DropTargetLocation
    {
        /// <summary>
        /// No applicable target has been found
        /// </summary>
        None = 0,

        /// <summary>
        /// The list itself is the target of the drop
        /// </summary>
        Background = 0x01,

        /// <summary>
        /// An item is the target
        /// </summary>
        Item = 0x02,

        /// <summary>
        /// Between two items (or above the top item or below the bottom item)
        /// can be the target. This is not actually ever a target, only a value indicate
        /// that it is valid to drop between items
        /// </summary>
        BetweenItems = 0x04,

        /// <summary>
        /// Above an item is the target
        /// </summary>
        AboveItem = 0x08,

        /// <summary>
        /// Below an item is the target
        /// </summary>
        BelowItem = 0x10,

        /// <summary>
        /// A subitem is the target of the drop
        /// </summary>
        SubItem = 0x20,

        /// <summary>
        /// On the right of an item is the target (not currently used)
        /// </summary>
        RightOfItem = 0x40,

        /// <summary>
        /// On the left of an item is the target (not currently used)
        /// </summary>
        LeftOfItem = 0x80
    }

    /// <summary>
    /// This class represents a simple implementation of a drop sink.
    /// </summary>
    /// <remarks>
    /// Actually, it's far from simple and can do quite a lot in its own right.
    /// </remarks>
    public class SimpleDropSink : AbstractDropSink
    {
        #region Life and death

        /// <summary>
        /// Make a new drop sink
        /// </summary>
        public SimpleDropSink() {
            this.timer = new Timer();
            this.timer.Interval = 250;
            this.timer.Tick += new EventHandler(this.timer_Tick);

            this.CanDropOnItem = true;
            //this.CanDropOnSubItem = true;
            //this.CanDropOnBackground = true;
            //this.CanDropBetween = true;

            this.FeedbackColor = Color.FromArgb(180, Color.MediumBlue);
            this.billboard = new BillboardOverlay();
        }

        #endregion

        #region Public properties

        /// <summary>
        /// Get or set the locations where a drop is allowed to occur (OR-ed together)
        /// </summary>
        public DropTargetLocation AcceptableLocations {
            get { return this.acceptableLocations; }
            set { this.acceptableLocations = value; }
        }
        private DropTargetLocation acceptableLocations;
        
        /// <summary>
        /// Gets or sets whether this sink allows model objects to be dragged from other lists
        /// </summary>
        public bool AcceptExternal {
            get { return this.acceptExternal; }
            set { this.acceptExternal = value; }
        }
        private bool acceptExternal = true;

        /// <summary>
        /// Gets or sets whether the ObjectListView should scroll when the user drags
        /// something near to the top or bottom rows.
        /// </summary>
        public bool AutoScroll {
            get { return this.autoScroll; }
            set { this.autoScroll = value; }
        }
        private bool autoScroll = true;

        /// <summary>
        /// Gets the billboard overlay that will be used to display feedback
        /// messages during a drag operation. 
        /// </summary>
        /// <remarks>Set this to null to stop the feedback.</remarks>
        public BillboardOverlay Billboard {
            get { return this.billboard; }
            set { this.billboard = value; }
        }
        private BillboardOverlay billboard;

        /// <summary>
        /// Get or set whether a drop can occur between items of the list
        /// </summary>
        public bool CanDropBetween {
            get { return (this.AcceptableLocations & DropTargetLocation.BetweenItems) == DropTargetLocation.BetweenItems; }
            set {
                if (value)
                    this.AcceptableLocations |= DropTargetLocation.BetweenItems;
                else 
                    this.AcceptableLocations &= ~DropTargetLocation.BetweenItems;
            }
        }

        /// <summary>
        /// Get or set whether a drop can occur on the listview itself
        /// </summary>
        public bool CanDropOnBackground {
            get { return (this.AcceptableLocations & DropTargetLocation.Background) == DropTargetLocation.Background; }
            set {
                if (value)
                    this.AcceptableLocations |= DropTargetLocation.Background;
                else
                    this.AcceptableLocations &= ~DropTargetLocation.Background;
            }
        }

        /// <summary>
        /// Get or set whether a drop can occur on items in the list
        /// </summary>
        public bool CanDropOnItem {
            get { return (this.AcceptableLocations & DropTargetLocation.Item) == DropTargetLocation.Item; }
            set {
                if (value)
                    this.AcceptableLocations |= DropTargetLocation.Item;
                else
                    this.AcceptableLocations &= ~DropTargetLocation.Item;
            }
        }

        /// <summary>
        /// Get or set whether a drop can occur on a subitem in the list
        /// </summary>
        public bool CanDropOnSubItem {
            get { return (this.AcceptableLocations & DropTargetLocation.SubItem) == DropTargetLocation.SubItem; }
            set {
                if (value)
                    this.AcceptableLocations |= DropTargetLocation.SubItem;
                else
                    this.AcceptableLocations &= ~DropTargetLocation.SubItem;
            }
        }

        /// <summary>
        /// Get or set the index of the item that is the target of the drop
        /// </summary>
        public int DropTargetIndex {
            get { return dropTargetIndex; }
            set {
                if (this.dropTargetIndex != value) {
                    this.dropTargetIndex = value;
                    this.ListView.Invalidate();
                }
            }
        }
        private int dropTargetIndex = -1;

        /// <summary>
        /// Get the item that is the target of the drop
        /// </summary>
        public OLVListItem DropTargetItem {
            get {
                return this.ListView.GetItem(this.DropTargetIndex);
            }
        }

        /// <summary>
        /// Get or set the location of the target of the drop
        /// </summary>
        public DropTargetLocation DropTargetLocation {
            get { return dropTargetLocation; }
            set {
                if (this.dropTargetLocation != value) {
                    this.dropTargetLocation = value;
                    this.ListView.Invalidate();
                }
            }
        }
        private DropTargetLocation dropTargetLocation;

        /// <summary>
        /// Get or set the index of the subitem that is the target of the drop
        /// </summary>
        public int DropTargetSubItemIndex {
            get { return dropTargetSubItemIndex; }
            set {
                if (this.dropTargetSubItemIndex != value) {
                    this.dropTargetSubItemIndex = value;
                    this.ListView.Invalidate();
                }
            }
        }
        private int dropTargetSubItemIndex = -1;

        /// <summary>
        /// Get or set the color that will be used to provide drop feedback
        /// </summary>
        public Color FeedbackColor {
            get { return this.feedbackColor; }
            set { this.feedbackColor = value; }
        }
        private Color feedbackColor;

        /// <summary>
        /// Get whether the alt key was down during this drop event
        /// </summary>
        public bool IsAltDown {
            get { return (this.KeyState & 32) == 32; }
        }

        /// <summary>
        /// Get whether any modifier key was down during this drop event
        /// </summary>
        public bool IsAnyModifierDown {
            get { return (this.KeyState & (4 + 8 + 32)) != 0; }
        }

        /// <summary>
        /// Get whether the control key was down during this drop event
        /// </summary>
        public bool IsControlDown {
            get { return (this.KeyState & 8) == 8; }
        }

        /// <summary>
        /// Get whether the left mouse button was down during this drop event
        /// </summary>
        public bool IsLeftMouseButtonDown {
            get { return (this.KeyState & 1) == 1; }
        }

        /// <summary>
        /// Get whether the right mouse button was down during this drop event
        /// </summary>
        public bool IsMiddleMouseButtonDown {
            get { return (this.KeyState & 16) == 16; }
        }

        /// <summary>
        /// Get whether the right mouse button was down during this drop event
        /// </summary>
        public bool IsRightMouseButtonDown {
            get { return (this.KeyState & 2) == 2; }
        }

        /// <summary>
        /// Get whether the shift key was down during this drop event
        /// </summary>
        public bool IsShiftDown {
            get { return (this.KeyState & 4) == 4; }
        }

        /// <summary>
        /// Get or set the state of the keys during this drop event
        /// </summary>
        public int KeyState {
            get { return this.keyState; }
            set { this.keyState = value; }
        }
        private int keyState;

        #endregion

        #region Events

        /// <summary>
        /// Triggered when the sink needs to know if a drop can occur.
        /// </summary>
        /// <remarks>
        /// Handlers should set Effect to indicate what is possible.
        /// Handlers can change any of the DropTarget* setttings to change
        /// the target of the drop.
        /// </remarks>
        public event EventHandler<OlvDropEventArgs> CanDrop;

        /// <summary>
        /// Triggered when the drop is made.
        /// </summary>
        public event EventHandler<OlvDropEventArgs> Dropped;

        /// <summary>
        /// Triggered when the sink needs to know if a drop can occur
        /// AND the source is an ObjectListView
        /// </summary>
        /// <remarks>
        /// Handlers should set Effect to indicate what is possible.
        /// Handlers can change any of the DropTarget* setttings to change
        /// the target of the drop.
        /// </remarks>
        public event EventHandler<ModelDropEventArgs> ModelCanDrop;

        /// <summary>
        /// Triggered when the drop is made.
        /// AND the source is an ObjectListView
        /// </summary>
        public event EventHandler<ModelDropEventArgs> ModelDropped;

        #endregion

        #region DropSink Interface

        /// <summary>
        /// Cleanup the drop sink when the mouse has left the control or 
        /// the drag has finished.
        /// </summary>
        protected override void Cleanup() {
            this.DropTargetLocation = DropTargetLocation.None;
            this.ListView.FullRowSelect = this.originalFullRowSelect;
            this.Billboard.Text = null;
        }

        /// <summary>
        /// Draw any feedback that is appropriate to the current drop state.
        /// </summary>
        /// <remarks>
        /// Any drawing is done over the top of the ListView. This operation should disturb
        /// the Graphic as little as possible. Specifically, do not erase the area into which
        /// you draw. 
        /// </remarks>
        /// <param name="g">A Graphic for drawing</param>
        /// <param name="bounds">The contents bounds of the ListView (not including any header)</param>
        public override void DrawFeedback(Graphics g, Rectangle bounds) {
            g.SmoothingMode = ObjectListView.SmoothingMode;

            switch (this.DropTargetLocation) {
                case DropTargetLocation.Background:
                    this.DrawFeedbackBackgroundTarget(g, bounds);
                    break;
                case DropTargetLocation.Item:
                    this.DrawFeedbackItemTarget(g, bounds);
                    break;
                case DropTargetLocation.AboveItem:
                    this.DrawFeedbackAboveItemTarget(g, bounds);
                    break;
                case DropTargetLocation.BelowItem:
                    this.DrawFeedbackBelowItemTarget(g, bounds);
                    break;
            }

            if (this.Billboard != null) {
                this.Billboard.Draw(this.ListView, g, bounds);
            }
        }

        /// <summary>
        /// The user has released the drop over this control
        /// </summary>
        /// <param name="args"></param>
        public override void Drop(DragEventArgs args) {
            this.TriggerDroppedEvent(args);
            this.timer.Stop();
            this.Cleanup();
        }

        /// <summary>
        /// A drag has entered this control.
        /// </summary>
        /// <remarks>Implementators should set args.Effect to the appropriate DragDropEffects.</remarks>
        /// <param name="args"></param>
        public override void Enter(DragEventArgs args) {
            //System.Diagnostics.Debug.WriteLine("Enter");

            /* 
             * When FullRowSelect is true, we have two problems:
             * 1) GetItemRect(ItemOnly) returns the whole row rather than just the icon/text, which messes
             *    up our calculation of the drop rectangle.
             * 2) during the drag, the Timer events will not fire! This is the major problem, since without
             *    those events we can't autoscroll. 
             * 
             * The first problem we can solve through coding, but the second is more difficult. 
             * We avoid both problems by turning off FullRowSelect during the drop operation.
             */    
            this.originalFullRowSelect = this.ListView.FullRowSelect;
            this.ListView.FullRowSelect = false;

            // Setup our drop event args block
            this.dropEventArgs = new ModelDropEventArgs();
            this.dropEventArgs.DropSink = this;
            this.dropEventArgs.ListView = this.ListView;
            this.dropEventArgs.DataObject = args.Data;
            OLVDataObject olvData = args.Data as OLVDataObject;
            if (olvData != null) {
                this.dropEventArgs.SourceListView = olvData.ListView;
                this.dropEventArgs.SourceModels = olvData.ModelObjects;
            }

            this.Over(args);
        }

        /// <summary>
        /// The drag is moving over this control.
        /// </summary>
        /// <param name="args"></param>
        public override void Over(DragEventArgs args) {
            //System.Diagnostics.Debug.WriteLine("Over");
            this.KeyState = args.KeyState;
            Point pt = this.ListView.PointToClient(new Point(args.X, args.Y));
            args.Effect = this.CalculateDropAction(args, pt);
            this.CheckScrolling(pt);
        }

        #endregion
        
        #region Events

        /// <summary>
        /// Trigger the Dropped events
        /// </summary>
        /// <param name="args"></param>
        protected virtual void TriggerDroppedEvent(DragEventArgs args) {
            this.dropEventArgs.Handled = false;

            // If the source is an ObjectListView, trigger the ModelDropped event
            if (this.dropEventArgs.SourceListView != null) 
                this.OnModelDropped(this.dropEventArgs);

            if (!this.dropEventArgs.Handled)
                this.OnDropped(this.dropEventArgs);
        }

        /// <summary>
        /// Trigger CanDrop
        /// </summary>
        /// <param name="args"></param>
        protected virtual void OnCanDrop(OlvDropEventArgs args) {
            if (this.CanDrop != null)
                this.CanDrop(this, args);
        }

        /// <summary>
        /// Trigger Dropped
        /// </summary>
        /// <param name="args"></param>
        protected virtual void OnDropped(OlvDropEventArgs args) {
            if (this.Dropped != null)
                this.Dropped(this, args);
        }

        /// <summary>
        /// Trigger ModelCanDrop
        /// </summary>
        /// <param name="args"></param>
        protected virtual void OnModelCanDrop(ModelDropEventArgs args) {

            // Don't allow drops from other list, if that's what's configured
            if (!this.AcceptExternal && args.SourceListView != null && args.SourceListView != this.ListView) {
                args.Effect = DragDropEffects.None;
                args.DropTargetLocation = DropTargetLocation.None;
                args.InfoMessage = "This list doesn't accept drops from other lists";
                return;
            }

            if (this.ModelCanDrop != null)
                this.ModelCanDrop(this, args);
        }

        /// <summary>
        /// Trigger ModelDropped
        /// </summary>
        /// <param name="args"></param>
        protected virtual void OnModelDropped(ModelDropEventArgs args) {
            if (this.ModelDropped != null)
                this.ModelDropped(this, args);
        }

        #endregion

        #region Implementation

        private void timer_Tick(object sender, EventArgs e) {
            this.HandleTimerTick();
        }

        /// <summary>
        /// Handle the timer tick event, which is sent when the listview should
        /// scroll
        /// </summary>
        protected virtual void HandleTimerTick() {

            // If the mouse has been released, stop scrolling.
            // This is only necessary if the mouse is released outside of the control. 
            // If the mouse is released inside the control, we would receive a Drop event.
            if ((this.IsLeftMouseButtonDown && (Control.MouseButtons & MouseButtons.Left) != MouseButtons.Left) ||
                (this.IsMiddleMouseButtonDown && (Control.MouseButtons & MouseButtons.Middle) != MouseButtons.Middle) ||
                (this.IsRightMouseButtonDown && (Control.MouseButtons & MouseButtons.Right) != MouseButtons.Right)) {
                this.timer.Stop();
                this.Cleanup();
                return;
            }

            // Auto scrolling will continune while the mouse is close to the ListView
            const int GRACE_PERIMETER = 30;

            Point pt = this.ListView.PointToClient(Cursor.Position);
            Rectangle r2 = this.ListView.ClientRectangle;
            r2.Inflate(GRACE_PERIMETER, GRACE_PERIMETER);
            if (r2.Contains(pt)) {
                this.ListView.LowLevelScroll(0, this.scrollAmount);
            }
        }

        /// <summary>
        /// When the mouse is at the given point, what should the target of the drop be?
        /// </summary>
        /// <remarks>This method should update the DropTarget* members of the given arg block</remarks>
        /// <param name="args"></param>
        /// <param name="pt">The mouse point, in client co-ordinates</param>
        protected virtual void CalculateDropTarget(OlvDropEventArgs args, Point pt) {
            const int SMALL_VALUE = 3;
            DropTargetLocation location = DropTargetLocation.None;
            int targetIndex = -1;
            int targetSubIndex = 0;

            if (this.CanDropOnBackground)
                location = DropTargetLocation.Background;

            // Which item is the mouse over?
            // If it is not over any item, it's over the background.
            //ListViewHitTestInfo info = this.ListView.HitTest(pt.X, pt.Y);
            OlvListViewHitTestInfo info = this.ListView.OlvHitTest(pt.X, pt.Y);
            if (info.Item != null && this.CanDropOnItem) {
                location = DropTargetLocation.Item;
                targetIndex = info.Item.Index;
                if (info.SubItem != null && this.CanDropOnSubItem)
                    targetSubIndex = info.Item.SubItems.IndexOf(info.SubItem);
            }

            // Check to see if the mouse is "between" rows.
            // ("between" is somewhat loosely defined)
            if (this.CanDropBetween && this.ListView.GetItemCount() > 0) {

                // If the mouse is over an item, check to see if it is near the top or bottom
                if (location == DropTargetLocation.Item) {
                    if (pt.Y - SMALL_VALUE <= info.Item.Bounds.Top)
                        location = DropTargetLocation.AboveItem;
                    if (pt.Y + SMALL_VALUE >= info.Item.Bounds.Bottom)
                        location = DropTargetLocation.BelowItem;
                } else {
                    // Is there an item a little below the mouse?
                    // If so, we say the drop point is above that row
                    info = this.ListView.OlvHitTest(pt.X, pt.Y + SMALL_VALUE);
                    if (info.Item != null) {
                        targetIndex = info.Item.Index;
                        location = DropTargetLocation.AboveItem;
                    } else {
                        // Is there an item a little above the mouse?
                        info = this.ListView.OlvHitTest(pt.X, pt.Y - SMALL_VALUE);
                        if (info.Item != null) {
                            targetIndex = info.Item.Index;
                            location = DropTargetLocation.BelowItem;
                        }
                    }
                }
            }

            args.DropTargetLocation = location;
            args.DropTargetIndex = targetIndex;
            args.DropTargetSubItemIndex = targetSubIndex;
        }

        /// <summary>
        /// What sort of action is possible when the mouse is at the given point?
        /// </summary>
        /// <remarks>
        /// </remarks>
        /// <param name="args"></param>
        /// <param name="pt"></param>
        /// <returns></returns>
        public virtual DragDropEffects CalculateDropAction(DragEventArgs args, Point pt) {
            this.CalculateDropTarget(this.dropEventArgs, pt);

            this.dropEventArgs.MouseLocation = pt;
            this.dropEventArgs.InfoMessage = null;
            this.dropEventArgs.Handled = false;

            if (this.dropEventArgs.SourceListView != null) {
                this.dropEventArgs.TargetModel = this.ListView.GetModelObject(this.dropEventArgs.DropTargetIndex);
                this.OnModelCanDrop(this.dropEventArgs);
            }

            if (!this.dropEventArgs.Handled)
                this.OnCanDrop(this.dropEventArgs);

            this.UpdateAfterCanDropEvent(this.dropEventArgs);

            return this.dropEventArgs.Effect;
        }

        /// <summary>
        /// Based solely on the state of the modifier keys, what drop operation should
        /// be used?
        /// </summary>
        /// <returns>The drop operation that matches the state of the keys</returns>
        public DragDropEffects CalculateStandardDropActionFromKeys() {
            if (this.IsControlDown) {
                if (this.IsShiftDown)
                    return DragDropEffects.Link;
                else
                    return DragDropEffects.Copy;
            } else {
                return DragDropEffects.Move;
            }
        }

        /// <summary>
        /// Should the listview be made to scroll when the mouse is at the given point?
        /// </summary>
        /// <param name="pt"></param>
        protected virtual void CheckScrolling(Point pt) {
            if (!this.AutoScroll)
                return;

            Rectangle r = this.ListView.ContentRectangle;
            int rowHeight = this.ListView.RowHeightEffective;
            int close = rowHeight;

            // In Tile view, using the whole row height is too much
            if (this.ListView.View == View.Tile)
                close /= 2;

            if (pt.Y <= (r.Top + close)) {
                // Scroll faster if the mouse is closer to the top
                this.timer.Interval = ((pt.Y <= (r.Top + close / 2)) ? 100 : 350);
                this.timer.Start();
                this.scrollAmount = -rowHeight;
            } else {
                if (pt.Y >= (r.Bottom - close)) {
                    this.timer.Interval = ((pt.Y >= (r.Bottom - close / 2)) ? 100 : 350);
                    this.timer.Start();
                    this.scrollAmount = rowHeight;
                } else {
                    this.timer.Stop();
                }
            }
        }

        /// <summary>
        /// Update the state of our sink to reflect the information that 
        /// may have been written into the drop event args.
        /// </summary>
        /// <param name="args"></param>
        protected virtual void UpdateAfterCanDropEvent(OlvDropEventArgs args) {
            this.DropTargetIndex = args.DropTargetIndex;
            this.DropTargetLocation = args.DropTargetLocation;
            this.DropTargetSubItemIndex = args.DropTargetSubItemIndex;

            if (this.Billboard != null) {
                Point pt = args.MouseLocation;
                pt.Offset(5, 5);
                if (this.Billboard.Text != this.dropEventArgs.InfoMessage || this.Billboard.Location != pt) {
                    this.Billboard.Text = this.dropEventArgs.InfoMessage;
                    this.Billboard.Location = pt;
                    this.ListView.Invalidate();
                }
            }
        }

        #endregion

        #region Rendering

        /// <summary>
        /// Draw the feedback that shows that the background is the target
        /// </summary>
        /// <param name="g"></param>
        /// <param name="bounds"></param>
        protected virtual void DrawFeedbackBackgroundTarget(Graphics g, Rectangle bounds) {
            float penWidth = 12.0f;
            Rectangle r = bounds;
            r.Inflate((int)-penWidth / 2, (int)-penWidth / 2);
            using (Pen p = new Pen(Color.FromArgb(128, this.FeedbackColor), penWidth)) {
                using (GraphicsPath path = this.GetRoundedRect(r, 30.0f)) {
                    g.DrawPath(p, path);
                }
            }
        }

        /// <summary>
        /// Draw the feedback that shows that an item (or a subitem) is the target
        /// </summary>
        /// <param name="g"></param>
        /// <param name="bounds"></param>
        /// <remarks>
        /// DropTargetItem and DropTargetSubItemIndex tells what is the target
        /// </remarks>
        protected virtual void DrawFeedbackItemTarget(Graphics g, Rectangle bounds) {
            if (this.DropTargetItem == null)
                return;
            Rectangle r = this.CalculateDropTargetRectangle(this.DropTargetItem, this.DropTargetSubItemIndex);
            r.Inflate(1, 1);
            float diameter = r.Height / 3;
            using (GraphicsPath path = this.GetRoundedRect(r, diameter)) {
                using (SolidBrush b = new SolidBrush(Color.FromArgb(48, this.FeedbackColor))) {
                    g.FillPath(b, path);
                }
                using (Pen p = new Pen(this.FeedbackColor, 3.0f)) {
                    g.DrawPath(p, path);
                }
            }
        }

        /// <summary>
        /// Draw the feedback that shows the drop will occur before target
        /// </summary>
        /// <param name="g"></param>
        /// <param name="bounds"></param>
        protected virtual void DrawFeedbackAboveItemTarget(Graphics g, Rectangle bounds) {
            if (this.DropTargetItem == null)
                return;

            Rectangle r = this.CalculateDropTargetRectangle(this.DropTargetItem, this.DropTargetSubItemIndex);
            this.DrawBetweenLine(g, r.Left, r.Top, r.Right, r.Top);
        }

        /// <summary>
        /// Draw the feedback that shows the drop will occur after target
        /// </summary>
        /// <param name="g"></param>
        /// <param name="bounds"></param>
        protected virtual void DrawFeedbackBelowItemTarget(Graphics g, Rectangle bounds) {
            if (this.DropTargetItem == null)
                return;

            Rectangle r = this.CalculateDropTargetRectangle(this.DropTargetItem, this.DropTargetSubItemIndex);
            this.DrawBetweenLine(g, r.Left, r.Bottom, r.Right, r.Bottom);
        }

        /// <summary>
        /// Return a GraphicPath that is round corner rectangle.
        /// </summary>
        /// <param name="rect"></param>
        /// <param name="diameter"></param>
        /// <returns></returns>
        protected GraphicsPath GetRoundedRect(Rectangle rect, float diameter) {
            GraphicsPath path = new GraphicsPath();

            RectangleF arc = new RectangleF(rect.X, rect.Y, diameter, diameter);
            path.AddArc(arc, 180, 90);
            arc.X = rect.Right - diameter;
            path.AddArc(arc, 270, 90);
            arc.Y = rect.Bottom - diameter;
            path.AddArc(arc, 0, 90);
            arc.X = rect.Left;
            path.AddArc(arc, 90, 90);
            path.CloseFigure();

            return path;
        }

        /// <summary>
        /// Calculate the target rectangle when the given item (and possible subitem)
        /// is the target of the drop.
        /// </summary>
        /// <param name="item"></param>
        /// <param name="subItem"></param>
        /// <returns></returns>
        protected virtual Rectangle CalculateDropTargetRectangle(OLVListItem item, int subItem) {
            if (subItem > 0)
                return item.SubItems[subItem].Bounds;
            
            Rectangle r = this.ListView.CalculateCellTextBounds(item, subItem);

            // Allow for indent
            if (item.IndentCount > 0) {
                int indentWidth = this.ListView.SmallImageSize.Width;
                r.X += (indentWidth * item.IndentCount);
                r.Width -= (indentWidth * item.IndentCount);
            }

            return r;
        }

        /// <summary>
        /// Draw a "between items" line at the given co-ordinates
        /// </summary>
        /// <param name="g"></param>
        /// <param name="x1"></param>
        /// <param name="y1"></param>
        /// <param name="x2"></param>
        /// <param name="y2"></param>
        protected virtual void DrawBetweenLine(Graphics g, int x1, int y1, int x2, int y2) {
            using (Brush b = new SolidBrush(this.FeedbackColor)) {
                int x = x1;
                int y = y1;
                using (GraphicsPath gp = new GraphicsPath()) {
                    gp.AddLine(
                        x, y + 5,
                        x, y - 5);
                    gp.AddBezier(
                        x, y - 6,
                        x + 3, y - 2,
                        x + 6, y - 1,
                        x + 11, y);
                    gp.AddBezier(
                        x + 11, y,
                        x + 6, y + 1,
                        x + 3, y + 2,
                        x, y + 6);
                    gp.CloseFigure();
                    g.FillPath(b, gp);
                }
                x = x2;
                y = y2;
                using (GraphicsPath gp = new GraphicsPath()) {
                    gp.AddLine(
                        x, y + 6,
                        x, y - 6);
                    gp.AddBezier(
                        x, y - 7,
                        x - 3, y - 2,
                        x - 6, y - 1,
                        x - 11, y);
                    gp.AddBezier(
                        x - 11, y,
                        x - 6, y + 1,
                        x - 3, y + 2,
                        x, y + 7);
                    gp.CloseFigure();
                    g.FillPath(b, gp);
                }
            }
            using (Pen p = new Pen(this.FeedbackColor, 3.0f)) {
                g.DrawLine(p, x1, y1, x2, y2);
            }
        }

        #endregion

        private Timer timer;
        private int scrollAmount;
        private bool originalFullRowSelect;
        private ModelDropEventArgs dropEventArgs;
    }

    /// <summary>
    /// This drop sink allows items within the same list to be rearranged,
    /// as well as allowing items to be dropped from other lists.
    /// </summary>
    /// <remarks>
    /// <para>
    /// This class can only be used on plain ObjectListViews and FastObjectListViews.
    /// The other flavours have no way to implement the insert operation that is required.
    /// </para>
    /// <para>
    /// This class does not work with grouping.
    /// </para>
    /// <para>
    /// This class works when the OLV is sorted, but it is up to the programmer
    /// to decide what rearranging such lists "means". Example: if the control is sorting
    /// students by academic grade, and the user drags a "Fail" grade student up amonst the "A+"
    /// students, it is the responsibility of the programmer to makes the appropriate changes
    /// to the model and redraw/rebuild the control so that the users action makes sense.
    /// </para>
    /// <para>
    /// Users of this class should listen for the CanDrop event to decide
    /// if models from another OLV can be moved to OLV under this sink.
    /// </para>
    /// </remarks>
    public class RearrangingDropSink : SimpleDropSink
    {
        /// <summary>
        /// Create a RearrangingDropSink
        /// </summary>
        public RearrangingDropSink() {
            this.CanDropBetween = true;
            this.CanDropOnBackground = true;
            this.CanDropOnItem = false;
        }

        /// <summary>
        /// Create a RearrangingDropSink
        /// </summary>
        /// <param name="acceptDropsFromOtherLists"></param>
        public RearrangingDropSink(bool acceptDropsFromOtherLists)
            : this() {
            this.AcceptExternal = acceptDropsFromOtherLists;
        }

        /// <summary>
        /// Trigger OnModelCanDrop
        /// </summary>
        /// <param name="args"></param>
        protected override void OnModelCanDrop(ModelDropEventArgs args) {
            base.OnModelCanDrop(args);

            if (args.Handled)
                return;

            args.Effect = DragDropEffects.Move;

            // Don't allow drops from other list, if that's what's configured
            if (!this.AcceptExternal && args.SourceListView != this.ListView) {
                args.Effect = DragDropEffects.None;
                args.DropTargetLocation = DropTargetLocation.None;
                args.InfoMessage = "This list doesn't accept drops from other lists";
            }

            // If we are rearranging a list, don't allow drops on the background
            if (args.DropTargetLocation == DropTargetLocation.Background && args.SourceListView == this.ListView) {
                args.Effect = DragDropEffects.None;
                args.DropTargetLocation = DropTargetLocation.None;
            }
        }

        /// <summary>
        /// Trigger OnModelDropped
        /// </summary>
        /// <param name="args"></param>
        protected override void OnModelDropped(ModelDropEventArgs args) {
            base.OnModelDropped(args);

            if (!args.Handled)
                this.RearrangeModels(args);
        }

        /// <summary>
        /// Do the work of processing the dropped items
        /// </summary>
        /// <param name="args"></param>
        public virtual void RearrangeModels(ModelDropEventArgs args) {
            switch (args.DropTargetLocation) {
                case DropTargetLocation.AboveItem:
                    this.ListView.MoveObjects(args.DropTargetIndex, args.SourceModels);
                    break;
                case DropTargetLocation.BelowItem:
                    this.ListView.MoveObjects(args.DropTargetIndex + 1, args.SourceModels);
                    break;
                case DropTargetLocation.Background:
                    this.ListView.AddObjects(args.SourceModels);
                    break;
                default:
                    return;
            }

            if (args.SourceListView != this.ListView) {
                args.SourceListView.RemoveObjects(args.SourceModels);
            }
        }
    }

    /// <summary>
    /// When a drop sink needs to know if something can be dropped, or
    /// to notify that a drop has occured, it uses an instance of this class.
    /// </summary>
    public class OlvDropEventArgs : EventArgs
    {
        /// <summary>
        /// Create a OlvDropEventArgs
        /// </summary>
        public OlvDropEventArgs() {
        }

        #region Data Properties

        /// <summary>
        /// Get the data object that is being dragged
        /// </summary>
        public object DataObject {
            get { return this.dataObject; }
            internal set { this.dataObject = value; }
        }
        private object dataObject;

        /// <summary>
        /// Get the drop sink that originated this event
        /// </summary>
        public SimpleDropSink DropSink {
            get { return this.dropSink; }
            internal set { this.dropSink = value; }
        }
        private SimpleDropSink dropSink;

        /// <summary>
        /// Get or set the index of the item that is the target of the drop
        /// </summary>
        public int DropTargetIndex {
            get { return dropTargetIndex; }
            set { this.dropTargetIndex = value; }
        }
        private int dropTargetIndex = -1;

        /// <summary>
        /// Get or set the location of the target of the drop
        /// </summary>
        public DropTargetLocation DropTargetLocation {
            get { return dropTargetLocation; }
            set { this.dropTargetLocation = value; }
        }
        private DropTargetLocation dropTargetLocation;

        /// <summary>
        /// Get or set the index of the subitem that is the target of the drop
        /// </summary>
        public int DropTargetSubItemIndex {
            get { return dropTargetSubItemIndex; }
            set { this.dropTargetSubItemIndex = value; }
        }
        private int dropTargetSubItemIndex = -1;

        /// <summary>
        /// Get the item that is the target of the drop
        /// </summary>
        public OLVListItem DropTargetItem {
            get {
                return this.ListView.GetItem(this.DropTargetIndex);
            }
            set {
                if (value == null)
                    this.DropTargetIndex = -1;
                else
                    this.DropTargetIndex = value.Index;
            }
        }

        /// <summary>
        /// Get or set the drag effect that should be used for this operation
        /// </summary>
        public DragDropEffects Effect {
            get { return this.effect; }
            set { this.effect = value; }
        }
        private DragDropEffects effect;

        /// <summary>
        /// Get or set if this event was handled. No further processing will be done for a handled event.
        /// </summary>
        public bool Handled {
            get { return this.handled; }
            set { this.handled = value; }
        }
        private bool handled;

        /// <summary>
        /// Get or set the feedback message for this operation
        /// </summary>
        /// <remarks>
        /// If this is not null, it will be displayed as a feedback message
        /// during the drag.
        /// </remarks>
        public string InfoMessage {
            get { return this.infoMessage; }
            set { this.infoMessage = value; }
        }
        private string infoMessage;

        /// <summary>
        /// Get the ObjectListView that is being dropped on
        /// </summary>
        public ObjectListView ListView {
            get { return this.listView; }
            internal set { this.listView = value; }
        }
        private ObjectListView listView;

        /// <summary>
        /// Get the location of the mouse (in target ListView co-ords)
        /// </summary>
        public Point MouseLocation {
            get { return this.mouseLocation; }
            internal set { this.mouseLocation = value; }
        }
        private Point mouseLocation;

        /// <summary>
        /// Get the drop action indicated solely by the state of the modifier keys
        /// </summary>
        public DragDropEffects StandardDropActionFromKeys {
            get {
                return this.DropSink.CalculateStandardDropActionFromKeys();
            }
        }

        #endregion
    }

    /// <summary>
    /// These events are triggered when the drag source is an ObjectListView.
    /// </summary>
    public class ModelDropEventArgs : OlvDropEventArgs
    {
        /// <summary>
        /// Create a ModelDropEventArgs
        /// </summary>
        public ModelDropEventArgs()
        {
        }

        /// <summary>
        /// Gets the model objects that are being dragged.
        /// </summary>
        public IList SourceModels {
            get { return this.dragModels; }
            internal set { 
                this.dragModels = value;
                TreeListView tlv = this.SourceListView as TreeListView;
                if (tlv != null) {
                    foreach (object model in this.SourceModels) {
                        object parent = tlv.GetParent(model);
                        if (!toBeRefreshed.Contains(parent))
                            toBeRefreshed.Add(parent);
                    }
                }
            }
        }
        private IList dragModels;
        private ArrayList toBeRefreshed = new ArrayList();

        /// <summary>
        /// Gets the ObjectListView that is the source of the dragged objects.
        /// </summary>
        public ObjectListView SourceListView {
            get { return this.sourceListView; }
            internal set { this.sourceListView = value; }
        }
        private ObjectListView sourceListView;

        /// <summary>
        /// Get the model object that is being dropped upon.
        /// </summary>
        /// <remarks>This is only value for TargetLocation == Item</remarks>
        public object TargetModel {
            get { return this.targetModel; }
            internal set { this.targetModel = value; }
        }
        private object targetModel;

        /// <summary>
        /// Refresh all the objects involved in the operation
        /// </summary>
        public void RefreshObjects() {
            TreeListView tlv = this.SourceListView as TreeListView;
            if (tlv != null) {
                foreach (object model in this.SourceModels) {
                    object parent = tlv.GetParent(model);
                    if (!toBeRefreshed.Contains(parent))
                        toBeRefreshed.Add(parent);
                }
            }
            toBeRefreshed.AddRange(this.SourceModels);
            if (this.ListView == this.SourceListView) {
                toBeRefreshed.Add(this.TargetModel);
                this.ListView.RefreshObjects(toBeRefreshed);
            } else {
                this.SourceListView.RefreshObjects(toBeRefreshed);
                this.ListView.RefreshObject(this.TargetModel);
            }
        }
    }
}
