ListBox and Popup do not work together

Question

I am using Caliburn.Micro for a WPF application.

One of the feature I am using wraps a view in the a popup control and let me choose the settings.

But I came to the conclusion that this is a behaviour I cannot solve.

In the code behind when I click the Button a popup appears and when I click elsewhere on the screen it goes away as expected.

When I click on an item in the list, the popup appears but does not disappear if I click elsewhere on the window. (it does though if i click somewhere else, like another application)

Basically I cannot create a PopUp with StaysOpen = false behaviour when handling a selected item event. What can i do to solve this?

<Window x:Class="WpfApplication1.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:WpfApplication1"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <ListBox Name="ListBox" Width="250" HorizontalAlignment="Left" SelectionChanged="ListBox_SelectionChanged">

        </ListBox>

        <Button Name="Button" HorizontalAlignment="Right" Content="ShowPopUp" Click="Button_Click" />
    </Grid>
</Window>

and the code behind

namespace WpfApplication1
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.ListBox.ItemsSource = new System.Collections.ObjectModel.ObservableCollection<MainWindowItem>()
            {
                new MainWindowItem {Name = "Test 001" },
                new MainWindowItem {Name = "Test 002" },
                new MainWindowItem {Name = "Test 003" },

            };
        }

        private void ListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var selection = this.ListBox.SelectedItem as MainWindowItem;
            if (selection == null)
            {
                return;
            }

            var popUp = new System.Windows.Controls.Primitives.Popup();
            popUp.Child = new TextBox { Text = selection.Name , MinWidth = 200 , MinHeight = 32};
            popUp.StaysOpen = false;
            popUp.AllowsTransparency = true;
            popUp.PlacementTarget = sender as FrameworkElement;
            popUp.IsOpen = true;
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {

            var popUp = new System.Windows.Controls.Primitives.Popup();
            popUp.Child = new TextBox { Text = "This is button Clicked" , MinWidth = 200, MinHeight = 32 };
            popUp.StaysOpen = false;
            popUp.AllowsTransparency = true;
            popUp.PlacementTarget = sender as FrameworkElement;
            popUp.IsOpen = true;
        }
    }

    public class MainWindowItem
    {
        public string Name { get; set; }

        public string Value { get; set; }
    }
}

score 1 · Answer 1 · edited May 23 '17 at 12:23

Hi please try the next solution. It based on the mouse down event hooking (from here), each time it happened will collapse the Popup(and reset list item selection).

Code behind

/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow
{
    public static readonly DependencyProperty SelectedProperty = DependencyProperty.Register(
        "Selected", typeof (object), typeof (MainWindow), new PropertyMetadata(default(object)));
    //property to monitor selection
    public object Selected
    {
        get { return (object) GetValue(SelectedProperty); }
        set { SetValue(SelectedProperty, value); }
    }

    private Popup _popUp;

    public MainWindow()
    {
        InitializeComponent();
        _popUp = new Popup {IsOpen = false};

        ListBox.ItemsSource = new System.Collections.ObjectModel.ObservableCollection<MainWindowItem>()
        {
            new MainWindowItem {Name = "Test 001" },
            new MainWindowItem {Name = "Test 002" },
            new MainWindowItem {Name = "Test 003" },
        };

        Loaded += OnLoaded;
        Unloaded += OnUnloaded;
    }

    //will stop hookig here
    private void OnUnloaded(object sender, RoutedEventArgs routedEventArgs)
    {
        Unloaded -= OnUnloaded;
        Loaded -= OnLoaded;
        MouseHook.MouseAction -= MouseHookOnMouseAction;
        MouseHook.Stop();
    }

    //will collapse the popup and reset selection
    private void MouseHookOnMouseAction(object sender, EventArgs eventArgs)
    {
        Selected = null;
        _popUp.IsOpen = false;
    }

    //will start hookig here
    private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
    {
        MouseHook.MouseAction += MouseHookOnMouseAction;
        MouseHook.Start();
    }

    //here is your logic without any changes
    private void ListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        var selection = ListBox.SelectedItem as MainWindowItem;
        if (selection == null)
        {
            return;
        }



        _popUp.Child = new TextBox { Text = selection.Name, MinWidth = 200, MinHeight = 32 };
        _popUp.StaysOpen = false;
        _popUp.AllowsTransparency = true;
        _popUp.PlacementTarget = sender as FrameworkElement;
        _popUp.IsOpen = true;
    }

    //here is your logic without any changes
    private void Button_Click(object sender, RoutedEventArgs e)
    {
        _popUp.IsOpen = false;
        _popUp.Child = new TextBox { Text = "This is button Clicked", MinWidth = 200, MinHeight = 32 };
        _popUp.StaysOpen = false;
        _popUp.AllowsTransparency = true;
        _popUp.PlacementTarget = sender as FrameworkElement;
        _popUp.IsOpen = true;
    }
}

public class MainWindowItem
{
    public string Name { get; set; }

    public string Value { get; set; }
}

/// <summary>
/// Mouse hooking helper
/// </summary>
public static class MouseHook
{
    public static event EventHandler MouseAction = delegate { };

    /// <summary>
    /// Starts hooking
    /// </summary>
    public static void Start()
    {
        _hookID = SetHook(_proc);
    }

    /// <summary>
    /// Stops hooking
    /// </summary>
    public static void Stop()
    {
        UnhookWindowsHookEx(_hookID);
    }

    private static LowLevelMouseProc _proc = HookCallback;
    private static IntPtr _hookID = IntPtr.Zero;

    //actually set a hook
    private static IntPtr SetHook(LowLevelMouseProc proc)
    {
        using (Process curProcess = Process.GetCurrentProcess())
        using (ProcessModule curModule = curProcess.MainModule)
        {
            IntPtr hook = SetWindowsHookEx(WH_MOUSE_LL, proc, GetModuleHandle("user32"), 0);
            if (hook == IntPtr.Zero) throw new System.ComponentModel.Win32Exception();
            return hook;
        }
    }

    private delegate IntPtr LowLevelMouseProc(int nCode, IntPtr wParam, IntPtr lParam);

    //is the mouse hook callback
    private static IntPtr HookCallback(
      int nCode, IntPtr wParam, IntPtr lParam)
    {
        if (nCode >= 0 && MouseMessages.WM_LBUTTONDOWN == (MouseMessages)wParam)
        {
            MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
            MouseAction(null, new EventArgs());
        }
        return CallNextHookEx(_hookID, nCode, wParam, lParam);
    }

    private const int WH_MOUSE_LL = 14;

    private enum MouseMessages
    {
        WM_LBUTTONDOWN = 0x0201,
        WM_LBUTTONUP = 0x0202,
        WM_MOUSEMOVE = 0x0200,
        WM_MOUSEWHEEL = 0x020A,
        WM_RBUTTONDOWN = 0x0204,
        WM_RBUTTONUP = 0x0205
    }

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

    [StructLayout(LayoutKind.Sequential)]
    private struct MSLLHOOKSTRUCT
    {
        public POINT pt;
        public uint mouseData;
        public uint flags;
        public uint time;
        public IntPtr dwExtraInfo;
    }

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern IntPtr SetWindowsHookEx(int idHook,
      LowLevelMouseProc lpfn, IntPtr hMod, uint dwThreadId);

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool UnhookWindowsHookEx(IntPtr hhk);

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode,
      IntPtr wParam, IntPtr lParam);

    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern IntPtr GetModuleHandle(string lpModuleName);
}

XAML code

<Window x:Class="WPFPopupStrangeIssueSOHelpAttempt.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="MainWindow" Height="350" Width="525" x:Name="This">
<Grid>
    <ListBox Name="ListBox" Width="250" HorizontalAlignment="Left" 
             SelectedItem="{Binding ElementName=This, Path=Selected, UpdateSourceTrigger=PropertyChanged}" 
             SelectionChanged="ListBox_SelectionChanged">
    </ListBox>

    <Button Name="Button" HorizontalAlignment="Right" Content="ShowPopUp" Click="Button_Click" />
</Grid></Window>

Let me know if you need any explanations.

Regards.

Thanks, I will let you know if this works for me as soon as I can — mhttk, Mar 16 '16 at 15:53
this seems fine, but I ended adopting a slightly different approach as I may have several popups at the same time interacting. — mhttk, Mar 17 '16 at 11:47

ListBox and Popup do not work together

1 Answers1