Mostrando a miniatura da imagem com o cursor do mouse enquanto arrasta

8

Eu tenho um pequeno aplicativo WPF que possui uma janela com um controle de imagem. O controle de imagem mostra uma imagem do sistema de arquivos. Eu quero que o usuário possa arrastar a imagem e soltar na área de trabalho ou em qualquer lugar para salvá-la. Está funcionando bem.

Mas eu quero mostrar uma miniatura pequena da imagem junto com o cursor do mouse quando o usuário a arrastar. Assim como arrastamos uma imagem do Windows File Explorer para outro local. Como conseguir isso?

Comportamento atual de arrastar / soltar

Comportamento atual de arrastar / soltar

Comportamento desejado

Comportamento desejado

Aqui está o meu código XAML

<Grid>
   <Image x:Name="img" Height="100" Width="100" Margin="100,30,0,0"/>
</Grid>

Aqui está o código C #

   public partial class MainWindow : Window
    {
        string imgPath;
        Point start;
        bool dragStart = false;

        public MainWindow()
        {
            InitializeComponent();
            imgPath = "C:\\Pictures\\flower.jpg";

            ImageSource imageSource = new BitmapImage(new Uri(imgPath));
            img.Source = imageSource;
            window.PreviewMouseMove += Window_PreviewMouseMove;
            window.PreviewMouseUp += Window_PreviewMouseUp;
            window.Closing += Window_Closing;
            img.PreviewMouseLeftButtonDown += Img_PreviewMouseLeftButtonDown;
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            window.PreviewMouseMove -= Window_PreviewMouseMove;
            window.PreviewMouseUp -= Window_PreviewMouseUp;
            window.Closing -= Window_Closing;
            img.PreviewMouseLeftButtonDown -= Img_PreviewMouseLeftButtonDown;
        }


        private void Window_PreviewMouseMove(object sender, MouseEventArgs e)
        {
            if (!dragStart) return;
            if (e.LeftButton != MouseButtonState.Pressed)
            {
                dragStart = false; return;
            }

            Point mpos = e.GetPosition(null);
            Vector diff = this.start - mpos;

            if (Math.Abs(diff.X) > SystemParameters.MinimumHorizontalDragDistance &&
                Math.Abs(diff.Y) > SystemParameters.MinimumVerticalDragDistance)
            {
                string[] file = { imgPath };
                DataObject d = new DataObject();
                d.SetData(DataFormats.Text, file[0]);
                d.SetData(DataFormats.FileDrop, file);
                DragDrop.DoDragDrop(this, d, DragDropEffects.Copy);
            }
        }

        private void Img_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            this.start = e.GetPosition(null);
            dragStart = true;
        }

        private void Window_PreviewMouseUp(object sender, MouseButtonEventArgs e)
        {
            dragStart = false;
        }
    }
Riz
fonte
1
talvez você use DragDrop.GiveFeedback. Verifique este stackoverflow.com/questions/4878004/…
Rao Hammas Hussain
@RaoHammasHussain Ele está tentando mudar o cursor do mouse, não é disso que eu preciso.
Riz
apenas uma idéia, talvez você possa fazer algo como criar um contêiner oculto que apareça ao arrastar e tenha uma imagem arrastada atual filho e esse contêiner siga o cursor do mouse.
Rao Hammas Hussain
@RaoHammasHussain O contêiner oculto tem um problema que permanecerá dentro da janela. Não podemos mostrá-lo do lado de fora quando o mouse sai da janela.
Riz
tenho algo que deve funcionar .. tente este homem stackoverflow.com/questions/1175870/…
Rao Hammas Hussain

Respostas:

2

Oficialmente, você deve usar a interface IDragSourceHelper para adicionar um bitmap de visualização a uma operação Drag & Drop.

Infelizmente, essa interface usa o método IDataObject :: SetData que não é implementado no nível COM pela classe .NET DataObject, apenas no nível .NET.

A solução é reutilizar um IDataObject fornecido pelo Shell para qualquer item do Shell (aqui um arquivo), usando a função SHCreateItemFromParsingName e o método IShellItem :: BindToHandler .

Observe que essas funções adicionam automaticamente formatos da área de transferência como o FileDrop, mas ainda precisamos usar o IDragSourceHelper para adicionar a imagem de visualização.

É assim que você pode usá-lo:

...
// get IDataObject from the Shell so it can handle more formats
var dataObject = DataObjectUtilities.GetFileDataObject(imgPath);

// add the thumbnail to the data object
DataObjectUtilities.AddPreviewImage(dataObject, imgPath);

// start d&d
DragDrop.DoDragDrop(this, dataObject, DragDropEffects.All);
...

E aqui está o código:

public static class DataObjectUtilities
{
    public static void AddPreviewImage(System.Runtime.InteropServices.ComTypes.IDataObject dataObject, string imgPath)
    {
        if (dataObject == null)
            throw new ArgumentNullException(nameof(dataObject));

        var ddh = (IDragSourceHelper)new DragDropHelper();
        var dragImage = new SHDRAGIMAGE();

        // note you should use a thumbnail here, not a full-sized image
        var thumbnail = new System.Drawing.Bitmap(imgPath);
        dragImage.sizeDragImage.cx = thumbnail.Width;
        dragImage.sizeDragImage.cy = thumbnail.Height;
        dragImage.hbmpDragImage = thumbnail.GetHbitmap();
        Marshal.ThrowExceptionForHR(ddh.InitializeFromBitmap(ref dragImage, dataObject));
    }

    public static System.Runtime.InteropServices.ComTypes.IDataObject GetFileDataObject(string filePath)
    {
        if (filePath == null)
            throw new ArgumentNullException(nameof(filePath));

        Marshal.ThrowExceptionForHR(SHCreateItemFromParsingName(filePath, null, typeof(IShellItem).GUID, out var item));
        Marshal.ThrowExceptionForHR(item.BindToHandler(null, BHID_DataObject, typeof(System.Runtime.InteropServices.ComTypes.IDataObject).GUID, out var dataObject));
        return (System.Runtime.InteropServices.ComTypes.IDataObject)dataObject;
    }

    private static readonly Guid BHID_DataObject = new Guid("b8c0bd9f-ed24-455c-83e6-d5390c4fe8c4");

    [DllImport("shell32", CharSet = CharSet.Unicode)]
    private static extern int SHCreateItemFromParsingName(string path, System.Runtime.InteropServices.ComTypes.IBindCtx pbc, [MarshalAs(UnmanagedType.LPStruct)] Guid riid, out IShellItem ppv);

    [Guid("43826d1e-e718-42ee-bc55-a1e261c37bfe"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    private interface IShellItem
    {
        [PreserveSig]
        int BindToHandler(System.Runtime.InteropServices.ComTypes.IBindCtx pbc, [MarshalAs(UnmanagedType.LPStruct)] Guid bhid, [MarshalAs(UnmanagedType.LPStruct)] Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppv);

        // other methods are not defined, we don't need them
    }

    [ComImport, Guid("4657278a-411b-11d2-839a-00c04fd918d0")] // CLSID_DragDropHelper
    private class DragDropHelper
    {
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct POINT
    {
        public int x;
        public int y;
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct SIZE
    {
        public int cx;
        public int cy;
    }

    // https://docs.microsoft.com/en-us/windows/win32/api/shobjidl_core/ns-shobjidl_core-shdragimage
    [StructLayout(LayoutKind.Sequential)]
    private struct SHDRAGIMAGE
    {
        public SIZE sizeDragImage;
        public POINT ptOffset;
        public IntPtr hbmpDragImage;
        public int crColorKey;
    }

    // https://docs.microsoft.com/en-us/windows/win32/api/shobjidl_core/nn-shobjidl_core-idragsourcehelper
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("DE5BF786-477A-11D2-839D-00C04FD918D0")]
    private interface IDragSourceHelper
    {
        [PreserveSig]
        int InitializeFromBitmap(ref SHDRAGIMAGE pshdi, System.Runtime.InteropServices.ComTypes.IDataObject pDataObject);

        [PreserveSig]
        int InitializeFromWindow(IntPtr hwnd, ref POINT ppt, System.Runtime.InteropServices.ComTypes.IDataObject pDataObject);
    }
}
Simon Mourier
fonte
@SimmonMourier Isso é o mais próximo do que eu estava procurando. Obrigado pelo seu tempo.
Riz
0

Aqui, tente isso. Ele "pega" um quadrado vermelho transparente ao redor da posição do mouse e o "solta" quando você clica novamente.

Na realidade, você deseja criar o thread fazendo a interoperabilidade ao clicar e pará-lo (não abortar) quando você soltar.

<Window x:Class="WpfApp1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WpfApp1"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800"
        DataContext="{Binding RelativeSource={RelativeSource Self}}">
    <Grid>
        <Button x:Name="Clicker" Click="OnClick">Click Me!</Button>
        <Popup Placement="Absolute" PlacementRectangle="{Binding Placement}" AllowsTransparency="True" IsOpen="{Binding IsOpen}"
               MouseUp="Cancel">
            <Grid Margin="10" Background="#7fff0000">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="400"></ColumnDefinition>
                </Grid.ColumnDefinitions>
                <Grid.RowDefinitions>
                    <RowDefinition Height="400"></RowDefinition>
                </Grid.RowDefinitions>
                <TextBlock>Hello!</TextBlock>
            </Grid>
        </Popup>
    </Grid>
</Window>

E código por trás:

[StructLayout(LayoutKind.Sequential)]
public struct InteropPoint
{
    public int X;
    public int Y;
}

/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window, INotifyPropertyChanged
{
    private bool isOpen;
    private int xPos;
    private int yPos;

    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    static extern bool GetCursorPos(ref InteropPoint lpPoint);

    private Thread t;

    public MainWindow()
    {
        InitializeComponent();

        t = new Thread(() =>
        {
            while (true)
            {
                //Logic
                InteropPoint p = new InteropPoint();
                GetCursorPos(ref p);

                //Update UI
                Dispatcher.BeginInvoke(new Action(() =>
                {
                    XPos = (int) p.X;
                    YPos = (int) p.Y;
                }));

                Thread.Sleep(10);
            }
        });

        t.Start();
    }

    protected override void OnClosing(CancelEventArgs e)
    {
        t.Abort();
    }

    private void OnClick(object sender, RoutedEventArgs e)
    {
        IsOpen = !IsOpen;
    }

    public int XPos
    {
        get => xPos;
        set
        {
            if (value == xPos) return;
            xPos = value;
            OnPropertyChanged();
            OnPropertyChanged(nameof(Placement));
        }
    }

    public int YPos
    {
        get => yPos;
        set
        {
            if (value == yPos) return;
            yPos = value;
            OnPropertyChanged();
            OnPropertyChanged(nameof(Placement));
        }
    }

    public bool IsOpen
    {
        get => isOpen;
        set
        {
            if (value == isOpen) return;
            isOpen = value;
            OnPropertyChanged();
        }
    }

    public Rect Placement => new Rect(XPos - 200, YPos - 200, 400, 400);

    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    private void Cancel(object sender, MouseButtonEventArgs e)
    {
        IsOpen = false;
    }
}
Adam Brown
fonte