public ImageCaptureWindow(System.Drawing.Rectangle rect, AreaSelection areaSelection)
{
InitializeComponent();
MouseUp += OnMouseUp;
MouseDown += OnMouseDown;
MouseMove += OnMouseMove;
Loaded += OnMainWindowLoaded;
_scalor = DpiUtilities.GetVirtualPixelScale(this);
_areaSelection = areaSelection;
_screenShotImage = new ScreenshotImage();
_screenScalor = DpiUtilities.GetScreenScalingFactor();
_screenShotImage.SnapShot(rect, _screenScalor);
WindowStartupLocation = WindowStartupLocation.Manual;
SourceInitialized += (sender, e) =>
{
IntPtr hWnd = new WindowInteropHelper(this).Handle;
NativeMethods.SetWindowPos(hWnd, (IntPtr)NativeMethods.SetWindowPosInsertAfter.HWND_TOP, rect.Left, rect.Top, rect.Width, rect.Height, 0);
};
var bmDesktopSource = ScreenCapture.GetBitmapSource(_screenShotImage.ScreenSnapshotImage);
BackgroundImage.Fill = new ImageBrush(bmDesktopSource);
MagnifierBackgroundImage.Source = bmDesktopSource;
}
private BitmapSource GetCapturedImage()
{
var rect = _areaSelection.GetSelectedArea();
// decide which monitor the selected area belongs to by checking the mid point of the selected area
var x = (rect.left + rect.width / 2);
var y = (rect.top + rect.height / 2);
var hMonitor = NativeMethods.MonitorFromPoint(new NativeMethods.POINT()
{
x = x, y = y
}, 0);
var curMon = _areaSelection.ScreenProps.GetMonitorInformation(hMonitor);
var monitorScalingX = curMon.dpiX / 96 / _screenScalor;
var monitorScalingY = curMon.dpiY / 96 / _screenScalor;
var dpiScaler = new DpiScale(monitorScalingX, monitorScalingY);
var capturedImage = _screenShotImage.GetCaptureImage(rect, dpiScaler);
// Copies to clipboard based on user setting
if (UserSettings.CopyToClipboardAfterSnip)
{
System.Windows.Clipboard.SetImage(capturedImage);
}
return(capturedImage);
}
public Screen(ConsoleBuffer.Buffer buffer)
{
this.dpiInfo = VisualTreeHelper.GetDpi(this);
this.cells = new VisualCollection(this);
this.Buffer = buffer;
this.cursorBlinkWatch.Start();
CompositionTarget.Rendering += this.RenderFrame;
this.MouseEnter += (sender, args) =>
{
args.MouseDevice.OverrideCursor = Cursors.IBeam;
};
this.MouseLeave += (sender, args) =>
{
args.MouseDevice.OverrideCursor = Cursors.Arrow;
};
this.MouseWheel += (sender, args) =>
{
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
{
var factor = args.Delta > 0 ? 2 : -2;
this.SetFontSize(this.fontSizeEm + factor);
args.Handled = true;
}
};
this.SetFontSize(14);
this.Resize();
}
private IntPtr _HandleNCCalcSize(WM uMsg, IntPtr wParam, IntPtr lParam, out bool handled)
{
if (this._chromeInfo.NonClientFrameEdges != NonClientFrameEdges.None)
{
DpiScale dpi = this._window.GetDpi();
Thickness thickness = DpiHelper.LogicalThicknessToDevice(SystemParameters.WindowResizeBorderThickness, dpi.DpiScaleX, dpi.DpiScaleY);
RECT rect = (RECT)Marshal.PtrToStructure(lParam, typeof(RECT));
if (Utility.IsFlagSet((int)this._chromeInfo.NonClientFrameEdges, 2))
{
rect.Top += (int)thickness.Top;
}
if (Utility.IsFlagSet((int)this._chromeInfo.NonClientFrameEdges, 1))
{
rect.Left += (int)thickness.Left;
}
if (Utility.IsFlagSet((int)this._chromeInfo.NonClientFrameEdges, 8))
{
rect.Bottom -= (int)thickness.Bottom;
}
if (Utility.IsFlagSet((int)this._chromeInfo.NonClientFrameEdges, 4))
{
rect.Right -= (int)thickness.Right;
}
Marshal.StructureToPtr(rect, lParam, false);
}
handled = true;
IntPtr zero = IntPtr.Zero;
if (wParam.ToInt32() != 0)
{
zero = new IntPtr(768);
}
return(zero);
}
/// <summary>
/// 指定スクリーンにおけるDPIを取得する
/// </summary>
/// <param name="screen">スクリーン</param>
/// <param name="dpiX">X値</param>
/// <param name="dpiY">Y値</param>
public static void GetDpi(System.Windows.Forms.Screen screen, out float dpiX, out float dpiY)
{
DpiScale dpi = GetDpi(screen);
dpiX = (float)dpi.PixelsPerInchX;
dpiY = (float)dpi.PixelsPerInchY;
}
// Token: 0x06006D68 RID: 28008 RVA: 0x001F6988 File Offset: 0x001F4B88
protected override Cursor GetCurrentCursor()
{
if (InkCanvasEditingMode.EraseByPoint == this._cachedEraseMode)
{
if (this._cachedPointEraserCursor == null)
{
this._cachedStylusShape = base.InkCanvas.EraserShape;
Matrix tranform = base.GetElementTransformMatrix();
if (!tranform.IsIdentity)
{
if (tranform.HasInverse)
{
tranform.OffsetX = 0.0;
tranform.OffsetY = 0.0;
}
else
{
tranform = Matrix.Identity;
}
}
DpiScale dpi = base.InkCanvas.GetDpi();
this._cachedPointEraserCursor = PenCursorManager.GetPointEraserCursor(this._cachedStylusShape, tranform, dpi.DpiScaleX, dpi.DpiScaleY);
}
return(this._cachedPointEraserCursor);
}
return(PenCursorManager.GetStrokeEraserCursor());
}
public bool Equals(BitmapLoadProperties other)
{
if (other is null)
{
return(false);
}
if (DpiScale?.Equals(other.DpiScale) == false)
{
return(false);
}
if (MaxDecodePixelWidth != other.MaxDecodePixelWidth)
{
return(false);
}
if (MaxDecodePixelHeight != other.MaxDecodePixelHeight)
{
return(false);
}
if (!string.Equals(Source, other.Source, StringComparison.Ordinal))
{
return(false);
}
return(true);
}
// adjust zoom when DPI changes.
protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi)
{
var ratio = newDpi.DpiScaleX / oldDpi.DpiScaleX;
Zoom = (int)(Zoom * ratio);
base.OnDpiChanged(oldDpi, newDpi);
}
private void MainWin_Loaded(object sender, RoutedEventArgs e)
{
if (App.ContextMenuWin == null)
{
App.ContextMenuWin = new ContextMenuWindow();
}
virWrapPanel = GetVisualChild <VirtualizingWrapPanel>(TV1);
DpiScale = VisualTreeHelper.GetDpi(this);
Setting.ThumbnailSize.PropertyChanged += ThumbnailSizeChanged;
var view = (ListCollectionView)((CollectionViewSource)FindResource("ObjectListViewSource")).View;
view.CustomSort = new Helpers.ObjectInfoSorter();
//load last path or open dialog
if (InitialPath?.Length > 0)
{
Task.Run(() => LoadPath(InitialPath));
}
else if (Setting.LastPath?.Length > 0)
{
Task.Run(() => LoadPath(Setting.LastPath));
}
else
{
openFolderPrompt();
}
}
private void DrawFormattedText(DpiScale dpiInfo)
{
FormattedText formattedText = new FormattedText(
"FABLE",
new System.Globalization.CultureInfo("en-US"),
FlowDirection.LeftToRight,
new Typeface(
new System.Windows.Media.FontFamily("Segoe UI"),
FontStyles.Normal,
FontWeights.Bold,
FontStretches.Normal),
120,
System.Windows.Media.Brushes.Red,
dpiInfo.PixelsPerDip);
// Build a geometry out of the text.
Geometry geometry = new PathGeometry();
geometry = formattedText.BuildGeometry(new System.Windows.Point(0, 0));
// Adjust the geometry to fit the aspect ration of the video by scaling it.
ScaleTransform myScaleTransform = new ScaleTransform();
myScaleTransform.ScaleX = .85;
myScaleTransform.ScaleY = 2.0;
geometry.Transform = myScaleTransform;
// Flatten the geometry and create a PathGeometry out of it.
PathGeometry pathGeometry = new PathGeometry();
pathGeometry = geometry.GetFlattenedPathGeometry();
// Use the PathGeometry for the empty placeholder Path element in XAML.
path.Data = pathGeometry;
// Use the PathGeometry for the animated ball that follows the path of the text outline.
matrixAnimation.PathGeometry = pathGeometry;
}
protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi)
{
base.OnDpiChanged(oldDpi, newDpi);
eventAggregator.SendMessage(new DpiChangedMessage {
DpiScale = newDpi
});
}
public static Rect ScaleRectDownFromDPI(Rect _sourceRect, DpiScale dpiScale)
{
double dpiX = dpiScale.DpiScaleX;
double dpiY = dpiScale.DpiScaleY;
return(new Rect(new Point(_sourceRect.X / dpiX, _sourceRect.Y / dpiY), new System.Windows.Size(_sourceRect.Width / dpiX, _sourceRect.Height / dpiY)));
}
public static Rect ScaleRectUpToDPI(Rect _toScaleUp, DpiScale dpiScale)
{
double dpiX = dpiScale.DpiScaleX;
double dpiY = dpiScale.DpiScaleY;
return(new Rect(new Point(_toScaleUp.X * dpiX, _toScaleUp.Y * dpiY), new System.Windows.Size(_toScaleUp.Width * dpiX, _toScaleUp.Height * dpiY)));
}
private void CompositionHostControl_Loaded(object sender, RoutedEventArgs e)
{
_currentDpi = WindowsMedia.VisualTreeHelper.GetDpi(this);
_rectWidth = CompositionHostElement.ActualWidth / 2;
_rectHeight = CompositionHostElement.ActualHeight / 2;
// Get graphics device.
_compositionGraphicsDevice = CanvasComposition.CreateCompositionGraphicsDevice(_compositor, _canvasDevice);
// Create surface.
var noiseDrawingSurface = _compositionGraphicsDevice.CreateDrawingSurface(
new Windows.Foundation.Size(_rectWidth, _rectHeight),
DirectXPixelFormat.B8G8R8A8UIntNormalized,
DirectXAlphaMode.Premultiplied);
// Draw to surface and create surface brush.
var noiseFilePath = AppDomain.CurrentDomain.BaseDirectory + "Assets\\NoiseAsset_256X256.png";
LoadSurface(noiseDrawingSurface, noiseFilePath);
_noiseSurfaceBrush = _compositor.CreateSurfaceBrush(noiseDrawingSurface);
// Add composition content to tree.
_compositionHost.SetChild(_containerVisual);
AddCompositionContent();
ToggleAcrylic();
}
/// <summary>
/// Returns a string containing a list of numbers separated with newlines.
/// </summary>
private FormattedText GetFormattedLineNumbers(int firstIndex, int lastIndex, DpiScale dpi)
{
string text = "";
for (int i = firstIndex + 1; i <= lastIndex + 1; i++)
{
text += i.ToString() + "\n";
}
text = text.Trim();
FormattedText ft = new FormattedText(
text,
System.Globalization.CultureInfo.InvariantCulture,
FlowDirection.LeftToRight,
new Typeface(FontFamily, FontStyle, FontWeight, FontStretch),
FontSize,
new SolidColorBrush(Color.FromRgb(0x21, 0xA1, 0xD8)), dpi.PixelsPerDip)
{
Trimming = TextTrimming.None,
LineHeight = lineHeight,
TextAlignment = TextAlignment.Right
};
return(ft);
}
public BitmapSource RenderToImage(UIElement element)
{
element.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
element.Arrange(new Rect(new Point(), element.DesiredSize));
// call to UpdateLayout is required to force children to be rendered too
element.UpdateLayout();
DpiScale dpiInfo = VisualTreeHelper.GetDpi(App.Current.MainWindow);
var renderTarget = new RenderTargetBitmap(
(int)(element.DesiredSize.Width * dpiInfo.DpiScaleX),
(int)(element.DesiredSize.Height * dpiInfo.DpiScaleY),
96.0, 96.0, PixelFormats.Pbgra32
);
var drawingVisual = new DrawingVisual();
using (DrawingContext drawingContext = drawingVisual.RenderOpen())
{
var rect = new Rect(new Point(0, 0), new Point(renderTarget.Width, renderTarget.Height));
drawingContext.DrawRectangle(Brushes.White, null, rect);
drawingContext.DrawRectangle(new VisualBrush(element), null, rect);
}
renderTarget.Render(drawingVisual);
return(renderTarget);
}
private void WmGetMinMaxInfo(System.IntPtr hwnd, System.IntPtr lParam)
{
NativeMethods.MINMAXINFO mmi = (NativeMethods.MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(NativeMethods.MINMAXINFO));
// Adjust the maximized size and position to fit the work area of the correct monitor
System.IntPtr monitor = NativeMethods.GetMonitorFromWindow(hwnd);
// MinHeight and MinWidth need to be scaled from Virtual Pixels back to Logical Pixels
DpiScale dpiScale = VirtualPixelScale;
if (monitor != System.IntPtr.Zero)
{
NativeMethods.MONITORINFO monitorInfo = new NativeMethods.MONITORINFO();
NativeMethods.GetMonitorInfo(monitor, monitorInfo);
NativeMethods.RECT rcWorkArea = monitorInfo.rcWork;
NativeMethods.RECT rcMonitorArea = monitorInfo.rcMonitor;
mmi.ptMaxPosition.x = Math.Abs(rcWorkArea.left - rcMonitorArea.left);
mmi.ptMaxPosition.y = Math.Abs(rcWorkArea.top - rcMonitorArea.top);
mmi.ptMaxSize.x = DoubleToInt32(Math.Abs(rcWorkArea.right - rcWorkArea.left));
mmi.ptMaxSize.y = DoubleToInt32(Math.Abs(rcWorkArea.bottom - rcWorkArea.top));
// After much research, it appears that the MaxTrackSize is used for secondary monitors
// while MaxSize is used for the primary monitor.
mmi.ptMaxTrackSize.x = DoubleToInt32(Math.Abs(rcWorkArea.right - rcWorkArea.left));
mmi.ptMaxTrackSize.y = DoubleToInt32(Math.Abs(rcWorkArea.bottom - rcWorkArea.top));
mmi.ptMinTrackSize.x = GetMinWidthInScreenPixels(dpiScale);
mmi.ptMinTrackSize.y = GetMinHeightInScreenPixels(dpiScale);
}
Marshal.StructureToPtr(mmi, lParam, true);
}
/// <summary>
/// Called when DPI of the monitor to which NotifyIcon belongs changed.
/// </summary>
/// <param name="oldDpi">Old DPI information</param>
/// <param name="newDpi">New DPI information</param>
protected virtual void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi)
{
if (_icon != null)
{
NotifyIcon.Icon = GetIcon(_icon, newDpi);
}
}
private static T LogicalToDeviceUnits <T>(this IntPtr hwnd, T value) where T : IConvertible
{
var windowDpi = hwnd.GetWindowDpi();
var windowDpiScale = new DpiScale(windowDpi.X / 96.0, windowDpi.Y / 96.0);
return((T)Convert.ChangeType((value.ToDouble(null) * windowDpiScale.DpiScaleX), typeof(T)));
}
protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi)
{
if (this.ActualWidth > 0 && currentGraph != null)
{
currentGraph.UpdateSize(newDpi, CompositionHostElement.ActualWidth, CompositionHostElement.ActualHeight);
}
}
/// <summary>
/// When implemented in a derived class, positions child elements and determines a
/// size for a FrameworkElement-derived class.
/// </summary>
/// <param name="finalSize"></param>
/// <returns></returns>
protected override Size ArrangeOverride(Size finalSize)
{
if (this.Visibility == Visibility.Collapsed || Child == null)
{
//Child takes up no space
return(new Size(0, 0));
}
Vector originalScale = _currentScale;
ScaleChild();
DpiScale dpi = GetDpi();
bool scaled = (_currentScale != originalScale);
SD.Size targetSize = Convert.ConstraintToSystemDrawingSize(finalSize, _currentScale, dpi.DpiScaleX, dpi.DpiScaleY);
if ((Child.Size != targetSize) && ((finalSize != _priorConstraint) || scaled))
{
_priorConstraint = finalSize;
Child.Size = targetSize;
}
Size returnSize = Convert.ToSystemWindowsSize(Child.Size, _currentScale, dpi.DpiScaleX, dpi.DpiScaleY);
returnSize.Width = Math.Min(returnSize.Width, finalSize.Width);
returnSize.Height = Math.Min(returnSize.Height, finalSize.Height);
if (HostContainerInternal.BackgroundImage != null)
{
_propertyMap.OnPropertyChanged(this, "Background", this.Background);
}
return(returnSize);
}
private static void SetWindowDpiImpl(Window window, double dpiScaleX, double dpiScaleY)
{
// Get window current dpi.
DpiScale dpi = VisualTreeHelper.GetDpi(window);
// Prepare new window position.
double left = window.Left * dpi.DpiScaleX;
double top = window.Top * dpi.DpiScaleY;
double width = window.ActualWidth * dpi.DpiScaleX;
double height = window.ActualHeight * dpi.DpiScaleY;
// Prepare an instance of HwndDpiChangedEventArgs.
Type[] paramTypes = new Type[] { typeof(DpiScale), typeof(DpiScale), typeof(Rect) };
object[] paramValues = new object[]
{
/* old dpi */ dpi,
/* new dpi */ new DpiScale(dpiScaleX, dpiScaleY),
/* position */ new Rect(left, top, width, height)
};
HwndDpiChangedEventArgs args = CreateInstance <HwndDpiChangedEventArgs>(paramTypes, paramValues);
// Get window hosting HwndSource.
PresentationSource source = PresentationSource.FromVisual(window);
// Change DPI on the specified window.
_onDpiChangedMethod.Invoke(source, new object[] { args });
// Update Left and Top properties according to new DPI.
_wmMoveChangedMethod.Invoke(window, null);
}
protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi)
{
base.OnDpiChanged(oldDpi, newDpi);
dpi = VisualTreeHelper.GetDpi(this).DpiScaleX;
log.Info($"Current screen dpi {dpi * 100}%");
}
/// <summary>Measures the child elements of a <see cref="T:System.Windows.Controls.Border" /> before they are arranged during the <see cref="M:System.Windows.Controls.Border.ArrangeOverride(System.Windows.Size)" /> pass.</summary>
/// <param name="constraint">An upper <see cref="T:System.Windows.Size" /> limit that cannot be exceeded.</param>
/// <returns>The <see cref="T:System.Windows.Size" /> that represents the upper size limit of the element.</returns>
// Token: 0x06004264 RID: 16996 RVA: 0x0012F824 File Offset: 0x0012DA24
protected override Size MeasureOverride(Size constraint)
{
UIElement child = this.Child;
Size result = default(Size);
Thickness borderThickness = this.BorderThickness;
if (base.UseLayoutRounding && !FrameworkAppContextSwitches.DoNotApplyLayoutRoundingToMarginsAndBorderThickness)
{
DpiScale dpi = base.GetDpi();
borderThickness = new Thickness(UIElement.RoundLayoutValue(borderThickness.Left, dpi.DpiScaleX), UIElement.RoundLayoutValue(borderThickness.Top, dpi.DpiScaleY), UIElement.RoundLayoutValue(borderThickness.Right, dpi.DpiScaleX), UIElement.RoundLayoutValue(borderThickness.Bottom, dpi.DpiScaleY));
}
Size size = Border.HelperCollapseThickness(borderThickness);
Size size2 = Border.HelperCollapseThickness(this.Padding);
if (child != null)
{
Size size3 = new Size(size.Width + size2.Width, size.Height + size2.Height);
Size availableSize = new Size(Math.Max(0.0, constraint.Width - size3.Width), Math.Max(0.0, constraint.Height - size3.Height));
child.Measure(availableSize);
Size desiredSize = child.DesiredSize;
result.Width = desiredSize.Width + size3.Width;
result.Height = desiredSize.Height + size3.Height;
}
else
{
result = new Size(size.Width + size2.Width, size.Height + size2.Height);
}
return(result);
}
/// <overloads>
/// Initializes a new instance of the <see cref="WpfDrawingSettings"/> class.
/// </overloads>
/// <summary>
/// Initializes a new instance of the <see cref="WpfDrawingSettings"/> class
/// with the default parameters and settings.
/// </summary>
public WpfDrawingSettings()
{
_defaultFontName = "Arial";
_textAsGeometry = false;
_optimizePath = true;
_includeRuntime = true;
_neutralCulture = CultureInfo.GetCultureInfo("en-us");
_culture = CultureInfo.GetCultureInfo("en-us");
_pixelWidth = -1;
_pixelHeight = -1;
_ensureViewboxSize = false;
_ensureViewboxPosition = true;
_ignoreRootViewbox = false;
_wpfVisitors = new WpfVisitors();
_properties = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
_fontSynch = new object();
_fontLocations = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_fontFamilyNames = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
_fontFamilyMap = new Dictionary <string, IList <FontFamily> >(StringComparer.OrdinalIgnoreCase);
_cssVariables = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
_dpiScale = DpiUtilities.GetSystemScale();
}
private void ScaleRightImage(DpiScale newDpi)
{
// update bestScale
bestScale = ImageDpiHelper.GetBestScale(newDpi.PixelsPerDip);
string imageUrl = ImageDpiHelper.GetDesiredImageUrlForDpi(this);
UpdateImageSource(this, imageUrl);
}
/// <summary>
/// Rescaling the AppBar when Display DPI changes
/// </summary>
/// <param name="oldDpi">Old Display DPI</param>
/// <param name="newDpi">New Display DPI</param>
protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi)
{
base.OnDpiChanged(oldDpi, newDpi);
if (IsAppBarRegistered)
{
OnDockLocationChanged();
}
}
protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi)
{
base.OnDpiChanged(oldDpi, newDpi);
Debug.WriteLine($"Image DpiChanged: {newDpi.PixelsPerDip}");
SetSource(newDpi.PixelsPerDip);
}
internal static Pixel Pixel(this MouseEventArgs e, WpfPlot plot)
{
DpiScale dpiScale = VisualTreeHelper.GetDpi(plot);
double x = e.GetPosition(plot).X *dpiScale.DpiScaleX;
double y = e.GetPosition(plot).Y *dpiScale.DpiScaleY;
return(new Pixel((float)x, (float)y));
}
public static Thickness RoundLayoutValue(Thickness value, DpiScale dpi)
{
return(new(
RoundLayoutValue(value.Left, dpi.DpiScaleX),
RoundLayoutValue(value.Top, dpi.DpiScaleY),
RoundLayoutValue(value.Right, dpi.DpiScaleX),
RoundLayoutValue(value.Bottom, dpi.DpiScaleY)));
}
protected override void OnDpiChanged(DpiScale oldDpiScaleInfo, DpiScale newDpiScaleInfo)
{
_dpiInfo = newDpiScaleInfo;
if (_mouseAnimator != null)
{
_mouseAnimator.DpiInfo = newDpiScaleInfo;
}
}
///<summary>DPI改变时</summary>
protected override void OnDpiChanged(DpiScale oldValueDpi, DpiScale newDpi)
{
base.OnDpiChanged(oldValueDpi, newDpi);
if (Oscilloscopes != IntPtr.Zero)
{
Dll.RefreshDPI(Oscilloscopes);
}
}
protected override void OnDpiChanged(DpiScale oldDpiScale, DpiScale newDpiScale)
{
_pixelsPerDip = newDpiScale.PixelsPerDip;
UpdateFormattedText(_pixelsPerDip);
}
private void Attach()
{
if (attached)
return;
var hwndSource = GetHwndSource();
if (hwndSource == null)
return;
var hwndParent = hwndSource.Handle;
if (hwndParent == IntPtr.Zero)
return;
// Get current DPI
dpiScale = VisualTreeHelper.GetDpi(this);
var style = NativeHelper.GetWindowLong(Handle, NativeHelper.GWL_STYLE);
// Removes Caption bar and the sizing border
// Must be a child window to be hosted
style |= NativeHelper.WS_CHILD;
NativeHelper.SetWindowLong(Handle, NativeHelper.GWL_STYLE, style);
NativeHelper.ShowWindow(Handle, NativeHelper.SW_HIDE);
// Update the parent to be the parent of the host
NativeHelper.SetParent(Handle, hwndParent);
// Register keyboard sink to make shortcuts work
((IKeyboardInputSink)this).KeyboardInputSite = ((IKeyboardInputSink)hwndSource).RegisterKeyboardInputSink(this);
attached = true;
}
/// <inheritdoc />
protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi)
{
dpiScale = newDpi;
UpdateWindowPosition();
}
protected override void OnDpiChanged(DpiScale oldDpiScaleInfo, DpiScale newDpiScaleInfo)
{
DrawFormattedText(newDpiScaleInfo);
}
// when DPI changes, ensure we are using the right scaled image, based on the DPI.
protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi)
{
ScaleRightImage(newDpi);
}
