解决 WPF 中Popup弹窗的输入框控件无法定位输入法的问题（包括可拖动的popup）

最新推荐文章于 2023-07-07 23:34:01 发布
最新推荐文章于 2023-07-07 23:34:01 发布
阅读量1k 收藏
点赞数 1
分类专栏： C# 文章标签： wpf c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MengHuanXinZuo/article/details/107984332
版权

为解决popup中输入法无法正常定位的问题，创建自定义popup控件，完整代码如下：

using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices;
using System.Security;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Interop;

namespace MaterialDesignThemes.Wpf
{
    /// <summary>
    /// This custom popup can be used by validation error templates or something else.
    /// It provides some additional nice features:
    ///     - repositioning if host-window size or location changed
    ///     - repositioning if host-window gets maximized and vice versa
    ///     - it's only topmost if the host-window is activated
    /// </summary>
    public class PopupEx : Popup
    {
        public static readonly DependencyProperty CloseOnMouseLeftButtonDownProperty
            = DependencyProperty.Register(nameof(CloseOnMouseLeftButtonDown),
                                          typeof(bool),
                                          typeof(PopupEx),
                                          new PropertyMetadata(false));

        /// <summary>
        /// Gets/sets if the popup can be closed by left mouse button down.
        /// </summary>
        public bool CloseOnMouseLeftButtonDown
        {
            get { return (bool)GetValue(CloseOnMouseLeftButtonDownProperty); }
            set { SetValue(CloseOnMouseLeftButtonDownProperty, value); }
        }

        public static readonly DependencyProperty AllowTopMostProperty
            = DependencyProperty.Register(nameof(AllowTopMost),
                                          typeof(bool),
                                          typeof(PopupEx),
                                          new PropertyMetadata(true));

        public bool AllowTopMost
        {
            get { return (bool)GetValue(AllowTopMostProperty); }
            set { SetValue(AllowTopMostProperty, value); }
        }

        public PopupEx()
        {
            Loaded += PopupEx_Loaded;
            Opened += PopupEx_Opened;

            EventManager.RegisterClassHandler(typeof(PopupEx), Popup.PreviewGotKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnPreviewGotKeyboardFocus),           true);
        }

        private static void OnPreviewGotKeyboardFocus(Object sender, KeyboardFocusChangedEventArgs e)
        {
            var textBox = e.NewFocus as TextBoxBase;
            if (textBox != null)
            {
                var hwndSource = PresentationSource.FromVisual(textBox) as HwndSource;
                if (hwndSource != null)
                {
                    NativeMethods.SetActiveWindow(hwndSource.Handle);
                }
            }
        }

        /// <summary>
        /// Causes the popup to update it's position according to it's current settings.
        /// </summary>
        public void RefreshPosition()
        {
            var offset = HorizontalOffset;
            // "bump" the offset to cause the popup to reposition itself on its own
            SetCurrentValue(HorizontalOffsetProperty, offset + 1);
            SetCurrentValue(HorizontalOffsetProperty, offset);
        }

        private void PopupEx_Loaded(object sender, RoutedEventArgs e)
        {
            var target = PlacementTarget as FrameworkElement;
            if (target == null)
            {
                return;
            }

            hostWindow = Window.GetWindow(target);
            if (hostWindow == null)
            {
                return;
            }

            hostWindow.LocationChanged -= hostWindow_SizeOrLocationChanged;
            hostWindow.LocationChanged += hostWindow_SizeOrLocationChanged;
            hostWindow.SizeChanged -= hostWindow_SizeOrLocationChanged;
            hostWindow.SizeChanged += hostWindow_SizeOrLocationChanged;
            target.SizeChanged -= hostWindow_SizeOrLocationChanged;
            target.SizeChanged += hostWindow_SizeOrLocationChanged;
            hostWindow.StateChanged -= hostWindow_StateChanged;
            hostWindow.StateChanged += hostWindow_StateChanged;
            hostWindow.Activated -= hostWindow_Activated;
            hostWindow.Activated += hostWindow_Activated;
            hostWindow.Deactivated -= hostWindow_Deactivated;
            hostWindow.Deactivated += hostWindow_Deactivated;

            Unloaded -= PopupEx_Unloaded;
            Unloaded += PopupEx_Unloaded;
        }

        private void PopupEx_Opened(object sender, EventArgs e)
        {
            SetTopmostState(hostWindow?.IsActive ?? true);
        }

        private void hostWindow_Activated(object sender, EventArgs e)
        {
            SetTopmostState(true);
        }

        private void hostWindow_Deactivated(object sender, EventArgs e)
        {
            SetTopmostState(false);
        }

        private void PopupEx_Unloaded(object sender, RoutedEventArgs e)
        {
            var target = PlacementTarget as FrameworkElement;
            if (target != null)
            {
                target.SizeChanged -= hostWindow_SizeOrLocationChanged;
            }
            if (hostWindow != null)
            {
                hostWindow.LocationChanged -= hostWindow_SizeOrLocationChanged;
                hostWindow.SizeChanged -= hostWindow_SizeOrLocationChanged;
                hostWindow.StateChanged -= hostWindow_StateChanged;
                hostWindow.Activated -= hostWindow_Activated;
                hostWindow.Deactivated -= hostWindow_Deactivated;
            }
            Unloaded -= PopupEx_Unloaded;
            Opened -= PopupEx_Opened;
            hostWindow = null;
        }

        private void hostWindow_StateChanged(object sender, EventArgs e)
        {
            if (hostWindow != null && hostWindow.WindowState != WindowState.Minimized)
            {
                // special handling for validation popup
                var target = PlacementTarget as FrameworkElement;
                var holder = target != null ? target.DataContext as AdornedElementPlaceholder : null;
                if (holder != null && holder.AdornedElement != null)
                {
                    PopupAnimation = PopupAnimation.None;
                    IsOpen = false;
                    var errorTemplate = holder.AdornedElement.GetValue(Validation.ErrorTemplateProperty);
                    holder.AdornedElement.SetValue(Validation.ErrorTemplateProperty, null);
                    holder.AdornedElement.SetValue(Validation.ErrorTemplateProperty, errorTemplate);
                }
            }
        }

        private void hostWindow_SizeOrLocationChanged(object sender, EventArgs e)
        {
            RefreshPosition();
        }

        private void SetTopmostState(bool isTop)
        {
            isTop &= AllowTopMost;
            // Don抰 apply state if it抯 the same as incoming state
            if (appliedTopMost.HasValue && appliedTopMost == isTop)
            {
                return;
            }

            if (Child == null)
            {
                return;
            }

            var hwndSource = (PresentationSource.FromVisual(Child)) as HwndSource;
            if (hwndSource == null)
            {
                return;
            }
            var hwnd = hwndSource.Handle;

            RECT rect;
            if (!GetWindowRect(hwnd, out rect))
            {
                return;
            }
            //Debug.WriteLine("setting z-order " + isTop);

            var left = rect.Left;
            var top = rect.Top;
            var width = rect.Width;
            var height = rect.Height;
            if (isTop)
            {
                SetWindowPos(hwnd, HWND_TOPMOST, left, top, width, height, SWP.TOPMOST);
            }
            else
            {
                // Z-Order would only get refreshed/reflected if clicking the
                // the titlebar (as opposed to other parts of the external
                // window) unless I first set the popup to HWND_BOTTOM
                // then HWND_TOP before HWND_NOTOPMOST
                SetWindowPos(hwnd, HWND_BOTTOM, left, top, width, height, SWP.TOPMOST);
                SetWindowPos(hwnd, HWND_TOP, left, top, width, height, SWP.TOPMOST);
                SetWindowPos(hwnd, HWND_NOTOPMOST, left, top, width, height, SWP.TOPMOST);
            }

            appliedTopMost = isTop;
        }

        protected override void OnPreviewMouseLeftButtonDown(MouseButtonEventArgs e)
        {
            if (CloseOnMouseLeftButtonDown)
            {
                IsOpen = false;
            }
        }

        private Window hostWindow;
        private bool? appliedTopMost;
        private static readonly IntPtr HWND_TOPMOST = new IntPtr(-1);
        private static readonly IntPtr HWND_NOTOPMOST = new IntPtr(-2);
        private static readonly IntPtr HWND_TOP = new IntPtr(0);
        private static readonly IntPtr HWND_BOTTOM = new IntPtr(1);

        /// <summary>
        /// SetWindowPos options
        /// </summary>
        [Flags]
        internal enum SWP
        {
            ASYNCWINDOWPOS = 0x4000,
            DEFERERASE = 0x2000,
            DRAWFRAME = 0x0020,
            FRAMECHANGED = 0x0020,
            HIDEWINDOW = 0x0080,
            NOACTIVATE = 0x0010,
            NOCOPYBITS = 0x0100,
            NOMOVE = 0x0002,
            NOOWNERZORDER = 0x0200,
            NOREDRAW = 0x0008,
            NOREPOSITION = 0x0200,
            NOSENDCHANGING = 0x0400,
            NOSIZE = 0x0001,
            NOZORDER = 0x0004,
            SHOWWINDOW = 0x0040,
            TOPMOST = SWP.NOACTIVATE | SWP.NOOWNERZORDER | SWP.NOSIZE | SWP.NOMOVE | SWP.NOREDRAW | SWP.NOSENDCHANGING,
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal static int LOWORD(int i)
        {
            return (short)(i & 0xFFFF);
        }

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

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

        [StructLayout(LayoutKind.Sequential)]
        internal struct RECT
        {
            private int _left;
            private int _top;
            private int _right;
            private int _bottom;

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            public void Offset(int dx, int dy)
            {
                _left += dx;
                _top += dy;
                _right += dx;
                _bottom += dy;
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            public int Left
            {
                get { return _left; }
                set { _left = value; }
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            public int Right
            {
                get { return _right; }
                set { _right = value; }
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            public int Top
            {
                get { return _top; }
                set { _top = value; }
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            public int Bottom
            {
                get { return _bottom; }
                set { _bottom = value; }
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            public int Width
            {
                get { return _right - _left; }
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            public int Height
            {
                get { return _bottom - _top; }
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            public POINT Position
            {
                get { return new POINT { x = _left, y = _top }; }
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
            public SIZE Size
            {
                get { return new SIZE { cx = Width, cy = Height }; }
            }

            public static RECT Union(RECT rect1, RECT rect2)
            {
                return new RECT
                {
                    Left = Math.Min(rect1.Left, rect2.Left),
                    Top = Math.Min(rect1.Top, rect2.Top),
                    Right = Math.Max(rect1.Right, rect2.Right),
                    Bottom = Math.Max(rect1.Bottom, rect2.Bottom),
                };
            }

            public override bool Equals(object obj)
            {
                try
                {
                    var rc = (RECT)obj;
                    return rc._bottom == _bottom
                        && rc._left == _left
                        && rc._right == _right
                        && rc._top == _top;
                }
                catch (InvalidCastException)
                {
                    return false;
                }
            }

            public override int GetHashCode()
            {
                return (_left << 16 | LOWORD(_right)) ^ (_top << 16 | LOWORD(_bottom));
            }
        }

        [SecurityCritical]
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        [DllImport("user32.dll", EntryPoint = "GetWindowRect", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);

        [SecurityCritical]
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        [DllImport("user32.dll", EntryPoint = "SetWindowPos", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool _SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int cx, int cy, SWP uFlags);

        [SecurityCritical]
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        private static bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int cx, int cy, SWP uFlags)
        {
            if (!_SetWindowPos(hWnd, hWndInsertAfter, x, y, cx, cy, uFlags))
            {
                // If this fails it's never worth taking down the process.  Let the caller deal with the error if they want.
                return false;
            }

            return true;
        }

        #region P/Invoke imports & definitions
        public static class NativeMethods
        {
            [DllImport("user32.dll")]
            [return: MarshalAs(UnmanagedType.Bool)]
            internal static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
            [DllImport("user32", EntryPoint = "SetWindowPos")]
            internal static extern int SetWindowPos(IntPtr hWnd, int hwndInsertAfter, int x, int y, int cx, int cy, int wFlags);

            [DllImport("user32.dll")]
            internal static extern IntPtr SetActiveWindow(IntPtr hWnd);
        }
        #endregion
    }
}

主要功能点为在构造函数中添加事件：

EventManager.RegisterClassHandler(typeof(PopupEx), Popup.PreviewGotKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnPreviewGotKeyboardFocus), true);
private static void OnPreviewGotKeyboardFocus(Object sender, KeyboardFocusChangedEventArgs e)
{
	var textBox = e.NewFocus as TextBoxBase;
	if (textBox != null)
	{
		var hwndSource = PresentationSource.FromVisual(textBox) as HwndSource;
		if (hwndSource != null)
		{
			NativeMethods.SetActiveWindow(hwndSource.Handle);
		}
	}
}

#region P/Invoke imports & definitions
public static class NativeMethods
{
	[DllImport("user32.dll")]
	[return: MarshalAs(UnmanagedType.Bool)]
	internal static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
	[DllImport("user32", EntryPoint = "SetWindowPos")]
	internal static extern int SetWindowPos(IntPtr hWnd, int hwndInsertAfter, int x, int y, int cx, int cy, int wFlags);

	[DllImport("user32.dll")]
	internal static extern IntPtr SetActiveWindow(IntPtr hWnd);
}
#endregion

实现可拖动的popup，代码如下：

using System;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;

namespace PopupExControl
{
    public class PopupEx : Popup
    {
        /// <summary>
        /// 是否窗口随动，默认为随动（true）
        /// </summary>
        public bool IsPositionUpdate
        {
            get { return (bool)GetValue(IsPositionUpdateProperty); }
            set { SetValue(IsPositionUpdateProperty, value); }
        }

        public static readonly DependencyProperty IsPositionUpdateProperty =
            DependencyProperty.Register("IsPositionUpdate", typeof(bool), typeof(PopupEx), new PropertyMetadata(true, new PropertyChangedCallback(IsPositionUpdateChanged)));

        private static void IsPositionUpdateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            (d as PopupEx).pup_Loaded(d as PopupEx, null);
        }

        /// <summary>
        /// 加载窗口随动事件
        /// </summary>
        public PopupEx()
        {
            //this.Loaded += pup_Loaded;

            EventManager.RegisterClassHandler(typeof(PopupEx), Popup.PreviewGotKeyboardFocusEvent, new KeyboardFocusChangedEventHandler(OnPreviewGotKeyboardFocus),
            true);
        }

        private static void OnPreviewGotKeyboardFocus(Object sender, KeyboardFocusChangedEventArgs e)
        {
            var textBox = e.NewFocus as TextBoxBase;
            if (textBox != null)
            {
                var hwndSource = PresentationSource.FromVisual(textBox) as HwndSource;
                if (hwndSource != null)
                {
                    NativeMethods.SetActiveWindow(hwndSource.Handle);
                }
            }
        }

        /// <summary>
        /// 加载窗口随动事件
        /// </summary>
        private void pup_Loaded(object sender, RoutedEventArgs e)
        {
            Popup pup = sender as Popup;
            var win = VisualTreeHelper.GetParent(pup);
            while (win != null && (win as Window) == null)
            {
                win = VisualTreeHelper.GetParent(win);
            }
            if ((win as Window) != null)
            {
                (win as Window).LocationChanged -= PositionChanged;
                if (IsPositionUpdate)
                {
                    (win as Window).LocationChanged += PositionChanged;
                }
            }
        }

        /// <summary>
        /// 刷新位置
        /// </summary>
        private void PositionChanged(object sender, EventArgs e)
        {
            var method = typeof(Popup).GetMethod("UpdatePosition", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
            if (IsOpen)
            {
                method.Invoke(this, null);
            }
        }

        //是否最前默认为非最前（false）
        public static DependencyProperty TopmostProperty = Window.TopmostProperty.AddOwner(typeof(Popup), new FrameworkPropertyMetadata(false, OnTopmostChanged));
        public bool Topmost
        {
            get { return (bool)GetValue(TopmostProperty); }
            set { SetValue(TopmostProperty, value); }
        }
        private static void OnTopmostChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
        {
            (obj as PopupEx).UpdateWindow();
        }

        /// <summary>
        /// 重写拉开方法，置于非最前
        /// </summary>
        /// <param name="e"></param>
        protected override void OnOpened(EventArgs e)
        {
            UpdateWindow();
        }

        /// <summary>
        /// 刷新Popup层级
        /// </summary>
        private void UpdateWindow()
        {
            var hwnd = ((HwndSource)PresentationSource.FromVisual(Child)).Handle;
            RECT rect;
            if (NativeMethods.GetWindowRect(hwnd, out rect))
            {
                NativeMethods.SetWindowPos(hwnd, Topmost ? -1 : -2, rect.Left, rect.Top, (int)Width, (int)Height, 0);
            }
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct RECT
        {
            public int Left;
            public int Top;
            public int Right;
            public int Bottom;
        }
        #region P/Invoke imports & definitions
        public static class NativeMethods
        {
            [DllImport("user32.dll")]
            [return: MarshalAs(UnmanagedType.Bool)]
            internal static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
            [DllImport("user32", EntryPoint = "SetWindowPos")]
            internal static extern int SetWindowPos(IntPtr hWnd, int hwndInsertAfter, int x, int y, int cx, int cy, int wFlags);

            [DllImport("user32.dll")]
            internal static extern IntPtr SetActiveWindow(IntPtr hWnd);
        }
        #endregion
    }
}

具体调用：

[DllImport("user32.dll")]
public static extern IntPtr WindowFromPoint(POINT Point);

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

[DllImportAttribute("user32.dll")]
public static extern IntPtr SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);

[DllImportAttribute("user32.dll")]
public static extern bool ReleaseCapture();

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

public const int WM_NCLBUTTONDOWN = 0xA1;
public const int HT_CAPTION = 0x2;

private void Border_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
	IntPtr hWndPopup;

	GetCursorPos(out POINT curPos);
	hWndPopup = WindowFromPoint(curPos);

	ReleaseCapture();
	SendMessage(hWndPopup, WM_NCLBUTTONDOWN, new IntPtr(HT_CAPTION), IntPtr.Zero);
}

以此记录笔记。

平凡就是福
关注
专栏目录
使用popup的时候无法用form嵌套textarea导致value值的获取的问题的解决方案；popup中placeholder悬浮的解决方案
qq_43773083的博客
05-09 411
wxml <van-popup show="{{ delateShow }}" custom-style="min-height: 30%;width:90%;border-radius:10rpx;"> <view class="popHeader">单位作废</view> <view class="popContent c00"> <view class="s30" style="line-height:80rpx;">作废说明<
WPF自定义Popup窗口随动非顶层不屏蔽输入法
帮助别人，帮助自己。
11-16 2781
做小项目的时候用到了Popup，但是原生的Popup为最顶层页面，屏蔽输入法不说，还不会自动随窗口移动更新位置。网上方案有很多，这里整理下方便各位码农们使用，废话不多说，直接上干货！ class PopubEx : Popup { /// /// 是否窗口随动，默认为随动（true） /// public bool Is
WPF中Popup上的textbox无法切换到中文输入法
zh1223ch的专栏
04-06 2577
Wpf画面处理时，遇到个问题，popup上怎么都切换不出输入法，只有QQ输入法勉强能切出来打中文，但是也看不到输入框，原来popup上的textbox无法切换出输入法，是微软的一个bug,微软说4.0会修正该bug，项目是3.5的，最新的4.0试了下确实已经修正该问题，可惜用不到。需要自己写个自定义的popup做处理。可能是popup的弹出性质导致的，大概是popup出现时总是处于Active状态
解决popupwindow中弹出输入法被遮挡问题
热门推荐
道哥的技术博客
12-10 1万+
在Popupwindow中有EditText，当点选EditText后输入法在popupwindow后面显示了。最后查找了大量资料后输入法终于在popupwindow在前端显示了，呵呵非常的好。解决思路 我们知道popupwindow中有个输入法配置选项。 。解决思路我们知道popupwindow中有个输入法配置选项。   if (nava_home_popupWindow == null
wpf 键盘可根据输入框变换位置
freshman_kang的博客
04-18 207
触摸屏情况下不遮挡输入框
WPF的弹窗用户控件，添加到工程即可使用
01-27
WPF的弹窗用户控件，添加到工程即可使用；效果见博文：https://blog.csdn.net/leeyunj/article/details/122711930?spm=1001.2014.3001.5502
WPF 解决popup顶置以及跟随窗体移动的问题（自定义控件,并且可解决wpf与winform控件相互嵌套的问题）-附件资源
03-05
WPF 解决popup顶置以及跟随窗体移动的问题（自定义控件,并且可解决wpf与winform控件相互嵌套的问题）-附件资源
wpf控件拖动改变大小并显示定位和大小
09-20
在WPF（Windows Presentation Foundation）开发中，控件的拖动改变大小以及显示其定位和大小是常见的需求，尤其在创建可交互用户界面时。本文将深入探讨如何实现这一功能，包括利用Canvas作为布局容器以及在运行时...
wpf使用Popup封装数据筛选框,wpf使用Popup封装数据筛选框
最新发布
03-21
在封装数据筛选框的过程中，通常我们会创建一个自定义控件，这个控件内部包含`Popup`以及筛选框所需的输入框、下拉列表等元素。这些元素可以通过绑定到视图模型的属性，实现数据驱动的筛选功能。例如，你可以创建两...
WPF：带阴影、带箭头的Popup提示框
03-30
在Windows Presentation Foundation (WPF) 中，Popup是一个非常实用的控件，用于创建浮动的、非模态的用户界面元素，它可以显示在主窗口或其他UI元素之上。在本项目"PopupSamples.7z"中，我们可以期待看到一系列的...
2018-12-21-WPF-弹出-popup-里面的-TextBox-无法输入汉字
lindexi
11-21 916
title author date CreateTime categories WPF 弹出 popup 里面的 TextBox 无法输入汉字 lindexi 2018-12-21 18:10:30 +0800 2018-2-13 17:23:3 +0800 WPF 这是一个 w...
移动端输入框在软键盘弹出后位置矫正
这是我的博客
03-22 4021
在做移动端的时候，经常碰到在触发软键盘的时候导致页面压缩或者是输入框被遮挡了。 以下为解决方式： var clientHeight = document.body.clientHeight; var _focusElem = null; //输入框焦点 //利用捕获事件监听输入框等focus动作 document.body.addEventListener("foc...
WPF Popup 中 IME 不跟随 TextBox
Iron 的博客
09-24 1526
WPF Popup中IME不跟随TextBox 在 WPF 程序中，如果一个 TextBox 被放置在 Popup 中，当在这个 TextBox 中进行输入时，输入法（IME） 的备选框不会显示在该 TextBox 旁边，而是显示在 Windows 右下角，如下动图所示。 如果 TextBox 是直接放置在 Window（或其子控件）之上的，IME 会呈跟随 TextBox 呈现。 此乃 W...
关于弹出窗口的输入法挡住按钮问题
salmanit的专栏
08-26 1793
网上一般提供的两种方法都是
光标无法定位到网页输入框
songwenze的专栏
05-06 8549
现象：打开IE进入到任何网页，当在输入用户名和密码时，你会发现你的光标无法定位到文本框中，文本框中也不会出一闪烁的光标。解决：  第一印象  1。开始认为中毒了，因为朋友说他发现不能用的时候，刚刚杀过毒，（发现了几个木马）     在网上搜了搜那几个被查杀几个毒，发现这几个病毒，还比较单纯，比较好查杀。     搞了半天也没个头绪，后来试着在网上搜了搜，找到一个半法
【愚公系列】2023年10月 WPF控件专题 Popup控件详解
时光隧道
07-07 7979
WPF控件是Windows Presentation Foundation（WPF）中的基本用户界面元素。它们是可视化对象，可以用来创建各种用户界面。WPF控件可以分为两类：原生控件和自定义控件。原生控件是由Microsoft提供的内置控件，如Button、TextBox、Label、ComboBox等。这些控件都是WPF中常见的标准用户界面元素。自定义控件则允许开发人员使用XAML和C#等编程语言来创建个性化的用户界面元素。自定义控件可以根据需求提供更多的功能和自定义化选项，以及更好的用户体验。
WPF中不规则窗体与WindowsFormsHost控件兼容问题的解决方法
09-04
通过以上步骤，我们可以解决WPF不规则窗体与`WindowsFormsHost`控件的兼容问题，使WinForms控件在透明或非矩形的WPF窗体中正常显示。这个方法虽然涉及到Windows API的使用，但能够提供一个通用的解决方案，对于需要...
解决popupwindow中弹出输入法被挤上去 顶起的bug
weixin_33859844的博客
04-03 535
/*** ******************腾讯微博: http://t.qq.com/lixiaodaoaaa **************** ******************新浪微博:http://weibo.com/lixiaodaoaaa **************** ******************by:lixiaodaoaaa **...
WPF弹窗
weixin_42975610的博客
02-10 3297
实现弹窗 弹窗和前面实现的登录跳转的功能类似，都是定义一个窗口类，在其它窗口的函数中实例化使用。区别在于，登录跳转实例化新的窗体后，登录的窗体就丢弃了，保留新建的窗体；而弹窗则是一个临时性窗体，完成当前的工作后就丢弃了，原有窗体保留。 第一步，新建wpf窗口，命名为LabelPopupWindow.xaml [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p6QP0YeJ-1612920616680)(F:\chenggeng\Blog\Image\wpf基础开发img3.pn
windows客户端开发--如何修复输入法提示框位置不正确
一蓑烟雨任平生 也无风雨也无晴
03-05 4815
应该也有人会遇到这样的困扰：就是在edit或是richedit控件中输入时，输入法的提示框位置不正确。何为HIMC ？什么是IME (Input Method Editors)？广义上讲，IME是微软提供的Windows平台的一套输入法编程规范，依照这套规范（框架），你不需要处理太多输入法特性相关的操作（光标跟随，输入捕获，字码转换后输出到应用程序等），你只需要使用IME规范里面提供的工具函数（im
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值