private static void Popup_Opened(object sender, EventArgs e)
{
var popup = (Popup)sender;
if (popup.TemplatedParent is MenuItem menuItem)
{
var topLine = GetTopLine(menuItem);
if (topLine == null)
{
return;
}
topLine.HorizontalAlignment = HorizontalAlignment.Left;
topLine.Width = menuItem.ActualWidth;
topLine.Margin = new Thickness();
var positionLeftTop = menuItem.PointToScreen(new Point());
var positionRightBottom = menuItem.PointToScreen(new Point(menuItem.ActualWidth, menuItem.ActualHeight));
ScreenHelper.FindMonitorRectsFromPoint(InteropMethods.GetCursorPos(), out _, out var workAreaRect);
var panel = VisualHelper.GetParent <Panel>(topLine);
if (positionLeftTop.X < 0)
{
topLine.Margin = new Thickness(positionLeftTop.X - panel.Margin.Left, 0, 0, 0);
}
else if (positionLeftTop.X + panel.ActualWidth > workAreaRect.Right)
{
var overflowWidth = positionRightBottom.X - workAreaRect.Right;
if (overflowWidth > 0)
{
topLine.Width -= overflowWidth + panel.Margin.Right;
}
topLine.HorizontalAlignment = HorizontalAlignment.Left;
topLine.Margin = new Thickness(positionLeftTop.X + panel.ActualWidth - workAreaRect.Right + panel.Margin.Right, 0, 0, 0);
}
if (positionRightBottom.Y > workAreaRect.Bottom)
{
topLine.Width = 0;
topLine.HorizontalAlignment = HorizontalAlignment.Stretch;
topLine.Margin = new Thickness();
}
}
}
internal GlowBitmap(IntPtr hdcScreen, int width, int height)
{
_bitmapInfo.biSize = Marshal.SizeOf(typeof(InteropValues.BITMAPINFOHEADER));
_bitmapInfo.biPlanes = 1;
_bitmapInfo.biBitCount = 32;
_bitmapInfo.biCompression = 0;
_bitmapInfo.biXPelsPerMeter = 0;
_bitmapInfo.biYPelsPerMeter = 0;
_bitmapInfo.biWidth = width;
_bitmapInfo.biHeight = -height;
Handle = InteropMethods.CreateDIBSection(
hdcScreen,
ref _bitmapInfo,
0u,
out _pbits,
IntPtr.Zero,
0u);
}
internal static void FindMonitorRectsFromPoint(Point point, out Rect monitorRect, out Rect workAreaRect)
{
var intPtr = InteropMethods.MonitorFromPoint(new InteropValues.POINT
{
X = (int)point.X,
Y = (int)point.Y
}, 2);
monitorRect = new Rect(0.0, 0.0, 0.0, 0.0);
workAreaRect = new Rect(0.0, 0.0, 0.0, 0.0);
if (intPtr != IntPtr.Zero)
{
InteropValues.MONITORINFO monitorInfo = default;
monitorInfo.cbSize = (uint)Marshal.SizeOf(typeof(InteropValues.MONITORINFO));
InteropMethods.GetMonitorInfo(intPtr, ref monitorInfo);
monitorRect = new Rect(monitorInfo.rcMonitor.Position, monitorInfo.rcMonitor.Size);
workAreaRect = new Rect(monitorInfo.rcWork.Position, monitorInfo.rcWork.Size);
}
}
/// <summary>
///
/// </summary>
protected void LoadTracks()
{
_Tracks.Clear();
lock (Player.player_lock)
{
bool done;
IntPtr p_head = GetTrackDescInternal();
Player.p_ex.CheckException();
IntPtr p_track = p_head;
do
{
libvlc_track_description_t track = (libvlc_track_description_t)Marshal.PtrToStructure(p_track, typeof(libvlc_track_description_t));
_Tracks.Add(track.i_id, new VlcTrack(track.i_id, Marshal.PtrToStringAnsi(track.psz_name)));
p_track = track.p_next;
done = (p_track == IntPtr.Zero);
} while (!done);
InteropMethods.libvlc_track_description_release(p_head);
}
_ReloadTracks = false;
}
public static ImageCodecInfo[] ConvertFromMemory(IntPtr memoryStart, int numCodecs)
{
var codecs = new ImageCodecInfo[numCodecs];
int index;
for (index = 0; index < numCodecs; index++)
{
var curcodec = (IntPtr)((long)memoryStart + Marshal.SizeOf(typeof(InteropValues.ImageCodecInfoPrivate)) * index);
var codecp = new InteropValues.ImageCodecInfoPrivate();
InteropMethods.PtrToStructure(curcodec, codecp);
codecs[index] = new ImageCodecInfo
{
Clsid = codecp.Clsid,
FormatID = codecp.FormatID,
CodecName = Marshal.PtrToStringUni(codecp.CodecName),
DllName = Marshal.PtrToStringUni(codecp.DllName),
FormatDescription = Marshal.PtrToStringUni(codecp.FormatDescription),
FilenameExtension = Marshal.PtrToStringUni(codecp.FilenameExtension),
MimeType = Marshal.PtrToStringUni(codecp.MimeType),
Flags = (ImageCodecFlags)codecp.Flags,
Version = codecp.Version,
SignaturePatterns = new byte[codecp.SigCount][],
SignatureMasks = new byte[codecp.SigCount][]
};
for (var j = 0; j < codecp.SigCount; j++)
{
codecs[index].SignaturePatterns[j] = new byte[codecp.SigSize];
codecs[index].SignatureMasks[j] = new byte[codecp.SigSize];
Marshal.Copy((IntPtr)((long)codecp.SigMask + j * codecp.SigSize), codecs[index].SignatureMasks[j], 0, codecp.SigSize);
Marshal.Copy((IntPtr)((long)codecp.SigPattern + j * codecp.SigSize), codecs[index].SignaturePatterns[j], 0, codecp.SigSize);
}
}
return(codecs);
}
public void ShowBalloonTip(string title, string content, NotifyIconInfoType infoType)
{
if (!_added || DesignerHelper.IsInDesignMode)
{
return;
}
var data = new InteropValues.NOTIFYICONDATA
{
uFlags = InteropValues.NIF_INFO,
hWnd = _messageWindowHandle,
uID = _id,
szInfoTitle = title ?? string.Empty,
szInfo = content ?? string.Empty
};
switch (infoType)
{
case NotifyIconInfoType.Info:
data.dwInfoFlags = InteropValues.NIIF_INFO;
break;
case NotifyIconInfoType.Warning:
data.dwInfoFlags = InteropValues.NIIF_WARNING;
break;
case NotifyIconInfoType.Error:
data.dwInfoFlags = InteropValues.NIIF_ERROR;
break;
case NotifyIconInfoType.None:
data.dwInfoFlags = InteropValues.NIIF_NONE;
break;
}
InteropMethods.Shell_NotifyIcon(InteropValues.NIM_MODIFY, data);
}
private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
if (wParam == KeyDownIntPtr)
{
var virtualKey = Marshal.ReadInt32(lParam);
if (VirtualKey != virtualKey)
{
VirtualKey = virtualKey;
KeyDown?.Invoke(null, new KeyboardHookEventArgs(virtualKey, false));
}
}
else if (wParam == SyskeyDownIntPtr)
{
var virtualKey = Marshal.ReadInt32(lParam);
if (VirtualKey != virtualKey)
{
VirtualKey = virtualKey;
KeyDown?.Invoke(null, new KeyboardHookEventArgs(virtualKey, true));
}
}
else if (wParam == KeyUpIntPtr)
{
var virtualKey = Marshal.ReadInt32(lParam);
VirtualKey = -1;
KeyUp?.Invoke(null, new KeyboardHookEventArgs(virtualKey, false));
}
else if (wParam == SyskeyUpIntPtr)
{
var virtualKey = Marshal.ReadInt32(lParam);
VirtualKey = -1;
KeyUp?.Invoke(null, new KeyboardHookEventArgs(virtualKey, true));
}
}
return(InteropMethods.CallNextHookEx(HookId, nCode, wParam, lParam));
}
internal GlowDrawingContext(int width, int height)
{
ScreenDC = InteropMethods.GetDC(IntPtr.Zero);
if (ScreenDC == IntPtr.Zero)
{
return;
}
WindowDC = InteropMethods.CreateCompatibleDC(ScreenDC);
if (WindowDC == IntPtr.Zero)
{
return;
}
BackgroundDC = InteropMethods.CreateCompatibleDC(ScreenDC);
if (BackgroundDC == IntPtr.Zero)
{
return;
}
Blend.BlendOp = 0;
Blend.BlendFlags = 0;
Blend.SourceConstantAlpha = 255;
Blend.AlphaFormat = 1;
_windowBitmap = new GlowBitmap(ScreenDC, width, height);
InteropMethods.SelectObject(WindowDC, _windowBitmap.Handle);
}
protected override void OnSourceInitialized(EventArgs e) => InteropMethods.IntDestroyMenu(this.GetHwndSource().CreateHandleRef());
/// <summary>
///
/// </summary>
/// <returns></returns>
protected override IntPtr GetTrackDescInternal()
{
return(InteropMethods.libvlc_video_get_title_description(Player.p_media_player, ref Player.p_ex));
}
public void RemoveAt(int index)
{
InteropMethods.libvlc_media_list_remove_index(p_mlist, index, ref p_exception);
p_exception.CheckException();
}
public void Add(VlcMedia item)
{
InteropMethods.libvlc_media_list_add_media(p_mlist, item.p_media, ref p_exception);
p_exception.CheckException();
}
/// <summary>
///
/// </summary>
/// <returns></returns>
protected override int GetTrackCountInternal()
{
return(InteropMethods.libvlc_audio_get_track_count(Player.p_media_player, ref Player.p_ex));
}
public static void Stop() => InteropMethods.UnhookWindowsHookEx(HookId);
private void AdonisWindow_Activated(object sender, EventArgs e)
{
InteropMethods.EmptyWorkingSet(System.Diagnostics.Process.GetCurrentProcess().Handle);
}
/// <summary>
/// 退出全屏模式
/// 窗口会回到进入全屏模式时保存的状态
/// 退出全屏模式后会重新启用 DWM 过渡动画
/// </summary>
public static void EndFullScreen(System.Windows.Window window)
{
if (window == null)
{
throw new ArgumentNullException(nameof(window), $"{nameof(window)} 不能为 null");
}
//确保在全屏模式并获取之前保存的状态
if (window.GetValue(BeforeFullScreenWindowPlacementProperty) is InteropValues.WINDOWPLACEMENT placement
&& window.GetValue(BeforeFullScreenWindowStyleProperty) is InteropValues.WindowStyles style)
{
var hwnd = new WindowInteropHelper(window).Handle;
if (hwnd == IntPtr.Zero)
{
// 句柄为 0 只有两种情况：
// 1. 虽然窗口已进入全屏，但窗口已被关闭；
// 2. 窗口初始化前，在还没有调用 StartFullScreen 的前提下就调用了此方法。
// 所以，直接 return 就好。
return;
}
var hwndSource = HwndSource.FromHwnd(hwnd);
//去除hook
hwndSource.RemoveHook(KeepFullScreenHook);
//恢复保存的状态
//不要改变Style里的WS_MAXIMIZE，否则会使窗口变成最大化状态，但是尺寸不对
//也不要设置回Style里的WS_MINIMIZE,否则会导致窗口最小化按钮显示成还原按钮
InteropMethods.SetWindowLong(hwnd, InteropValues.GWL_STYLE,
(IntPtr) (style & ~(InteropValues.WindowStyles.WS_MAXIMIZE | InteropValues.WindowStyles.WS_MINIMIZE)));
if ((style & InteropValues.WindowStyles.WS_MINIMIZE) != 0)
{
//如果窗口进入全屏前是最小化的，这里不让窗口恢复到之前的最小化状态，而是到还原的状态。
//大多数情况下，都不期望在退出全屏的时候，恢复到最小化。
placement.showCmd = InteropValues.SW.RESTORE;
}
if ((style & InteropValues.WindowStyles.WS_MAXIMIZE) != 0)
{
//提前调用 ShowWindow 使窗口恢复最大化，若通过 SetWindowPlacement 最大化会导致闪烁，只靠其恢复 RestoreBounds.
InteropMethods.ShowWindow(hwnd, InteropValues.SW.MAXIMIZE);
}
InteropMethods.SetWindowPlacement(hwnd, ref placement);
if ((style & InteropValues.WindowStyles.WS_MAXIMIZE) ==
0) //如果窗口是最大化就不要修改WPF属性，否则会破坏RestoreBounds，且WPF窗口自身在最大化时，不会修改 Left Top Width Height 属性
{
if (InteropMethods.GetWindowRect(hwnd, out var rect))
{
//不能用 placement 的坐标，placement是工作区坐标，不是屏幕坐标。
//确保窗口的 WPF 属性与 Win32 位置一致
var logicalPos =
hwndSource.CompositionTarget.TransformFromDevice.Transform(
new Point(rect.Left, rect.Top));
var logicalSize =
hwndSource.CompositionTarget.TransformFromDevice.Transform(
new Point(rect.Width, rect.Height));
window.Left = logicalPos.X;
window.Top = logicalPos.Y;
window.Width = logicalSize.X;
window.Height = logicalSize.Y;
}
}
//重新启用 DWM 过渡动画 忽略返回值，若DWM关闭不做处理
InteropMethods.DwmSetWindowAttribute(hwnd, InteropValues.DwmWindowAttribute.DWMWA_TRANSITIONS_FORCEDISABLED, 0,
sizeof(int));
//删除保存的状态
window.ClearValue(BeforeFullScreenWindowPlacementProperty);
window.ClearValue(BeforeFullScreenWindowStyleProperty);
}
}
private static IntPtr KeepFullScreenHook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
{
//处理WM_WINDOWPOSCHANGING消息
const int WINDOWPOSCHANGING = 0x0046;
if (msg == WINDOWPOSCHANGING)
{
try
{
//得到WINDOWPOS结构体
var pos = (InteropValues.WindowPosition) Marshal.PtrToStructure(lParam, typeof(InteropValues.WindowPosition));
if ((pos.Flags & InteropValues.WindowPositionFlags.SWP_NOMOVE) != 0 &&
(pos.Flags & InteropValues.WindowPositionFlags.SWP_NOSIZE) != 0)
{
//既然你既不改变位置，也不改变尺寸，我就不管了...
return IntPtr.Zero;
}
if (InteropMethods.IsIconic(hwnd))
{
// 如果在全屏期间最小化了窗口，那么忽略后续的位置调整。
// 否则按后续逻辑，会根据窗口在 -32000 的位置，计算出错误的目标位置，然后就跳到主屏了。
return IntPtr.Zero;
}
//获取窗口现在的矩形，下面用来参考计算目标矩形
if (InteropMethods.GetWindowRect(hwnd, out var rect))
{
var targetRect = rect; //窗口想要变化的目标矩形
if ((pos.Flags & InteropValues.WindowPositionFlags.SWP_NOMOVE) == 0)
{
//需要移动
targetRect.Left = pos.X;
targetRect.Top = pos.Y;
}
if ((pos.Flags & InteropValues.WindowPositionFlags.SWP_NOSIZE) == 0)
{
//要改变尺寸
targetRect.Right = targetRect.Left + pos.Width;
targetRect.Bottom = targetRect.Top + pos.Height;
}
else
{
//不改变尺寸
targetRect.Right = targetRect.Left + rect.Width;
targetRect.Bottom = targetRect.Top + rect.Height;
}
//使用目标矩形获取显示器信息
var monitor = InteropMethods.MonitorFromRect(ref targetRect, InteropValues.MONITOR_DEFAULTTOPRIMARY);
var info = new InteropValues.MONITORINFO();
info.cbSize = (uint) Marshal.SizeOf(info);
if (InteropMethods.GetMonitorInfo(monitor, ref info))
{
//基于显示器信息设置窗口尺寸位置
pos.X = info.rcMonitor.Left;
pos.Y = info.rcMonitor.Top;
pos.Width = info.rcMonitor.Right - info.rcMonitor.Left;
pos.Height = info.rcMonitor.Bottom - info.rcMonitor.Top;
pos.Flags &= ~(InteropValues.WindowPositionFlags.SWP_NOSIZE | InteropValues.WindowPositionFlags.SWP_NOMOVE |
InteropValues.WindowPositionFlags.SWP_NOREDRAW);
pos.Flags |= InteropValues.WindowPositionFlags.SWP_NOCOPYBITS;
if (rect == info.rcMonitor)
{
var hwndSource = HwndSource.FromHwnd(hwnd);
if (hwndSource?.RootVisual is Window window)
{
//确保窗口的 WPF 属性与 Win32 位置一致，防止有逗比全屏后改 WPF 的属性，发生一些诡异的行为
//下面这样做其实不太好，会再次触发 WM_WINDOWPOSCHANGING 来着.....但是又没有其他时机了
// WM_WINDOWPOSCHANGED 不能用
//（例如：在进入全屏后，修改 Left 属性，会进入 WM_WINDOWPOSCHANGING，然后在这里将消息里的结构体中的 Left 改回，
// 使对 Left 的修改无效，那么将不会进入 WM_WINDOWPOSCHANGED，窗口尺寸正常，但窗口的 Left 属性值错误。）
var logicalPos =
hwndSource.CompositionTarget.TransformFromDevice.Transform(
new Point(pos.X, pos.Y));
var logicalSize =
hwndSource.CompositionTarget.TransformFromDevice.Transform(
new Point(pos.Width, pos.Height));
window.Left = logicalPos.X;
window.Top = logicalPos.Y;
window.Width = logicalSize.X;
window.Height = logicalSize.Y;
}
}
//将修改后的结构体拷贝回去
Marshal.StructureToPtr(pos, lParam, false);
}
}
}
catch
{
// 这里也不需要日志啥的，只是为了防止上面有逗比逻辑，在消息循环里面炸了
}
}
return IntPtr.Zero;
}
protected virtual IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam) => InteropMethods.DefWindowProc(hwnd, msg, wParam, lParam);
private void SubclassWndProc()
{
_wndProc = new InteropValues.WndProc(WndProc);
InteropMethods.SetWindowLong(_handle, -4, Marshal.GetFunctionPointerForDelegate(_wndProc));
}
public virtual void Stop()
{
SyncEvents();
InteropMethods.libvlc_media_player_stop(p_media_player, ref p_ex);
p_ex.CheckException();
}
public virtual void Load(VlcMedia Media)
{
SyncEvents();
InteropMethods.libvlc_media_player_set_media(p_media_player, Media.p_media, ref p_ex);
p_ex.CheckException();
}
public void Stop()
{
InteropMethods.libvlc_vlm_stop_media(Vlm.Vlc.p_instance, Name, ref p_exception);
p_exception.CheckException();
}
protected override void DisposeNativeResources() => InteropMethods.DeleteObject(Handle);
public void SeekTo(float position)
{
InteropMethods.libvlc_vlm_seek_media(Vlm.Vlc.p_instance, Name, position, ref p_exception);
p_exception.CheckException();
}
public void Insert(int index, VlcMedia item)
{
InteropMethods.libvlc_media_list_insert_media(p_mlist, item.p_media, index, ref p_exception);
p_exception.CheckException();
}
/// <summary>
///
/// </summary>
/// <returns></returns>
protected override int GetTrackCurrentInternal()
{
return(InteropMethods.libvlc_media_player_get_title(Player.p_media_player, ref Player.p_ex));
}
public void Unlock()
{
InteropMethods.libvlc_media_list_unlock(p_mlist);
}
/// <summary>
///
/// </summary>
/// <param name="ID"></param>
protected override void SetTrackCurrentInternal(int ID)
{
InteropMethods.libvlc_media_player_set_title(Player.p_media_player, ID, ref Player.p_ex);
}
public static void Stop()
{
HWndSource.RemoveHook(WinProc);
InteropMethods.RemoveClipboardFormatListener(HookId);
}
public void SetControlToMediaPlayer(IntPtr p_media_player, IntPtr parent)
{
//InteropMethods.libvlc_media_player_set_nsobject(p_media_player, parent, ref p_exception);
InteropMethods.libvlc_media_player_set_hwnd(p_media_player, parent, ref p_exception);
p_exception.CheckException();
}
