Develop Reference

How can I make the window of my MAUI app fixed, so not resizable or set a minimum height/width?

How can I set the size of the window in my MAUI Windows application to be fixed? So the user can not resize the window.
Or how is it possible to set a minimum height or width to the window?

you can set OverlappedPresenter.IsResizable Property to false using handler api:
public App()
{
InitializeComponent();
#if WINDOWS
SetWinNoResizable();
#endif
...
}
public void SetWinNoResizable()
{
Microsoft.Maui.Handlers.WindowHandler.Mapper.AppendToMapping(nameof(IWindow),
(handler, view) =>
{
#if WINDOWS
var nativeWindow = handler.PlatformView;
IntPtr windowHandle = WinRT.Interop.WindowNative.GetWindowHandle(nativeWindow);
WindowId WindowId = Win32Interop.GetWindowIdFromWindow(windowHandle);
AppWindow appWindow = AppWindow.GetFromWindowId(WindowId);
var presenter = appWindow.Presenter as OverlappedPresenter;
presenter.IsResizable = false;
#endif
});
}

WINUI 3.0 - Reunion 0.5 window size///

I just start learning WinUI 3.0 and can't find any information in google or books like Learn WinUI 3.0 how to set default window size of application. I know in UWP it can be like
ApplicationView.PreferredLaunchViewSize = new Size(480, 800);
ApplicationView.PreferredLaunchWindowingMode = ApplicationViewWindowingMode.PreferredLaunchViewSize;
But actually it doesn't work in WinUI

No need to do these interop calls on your own or use third-party packages for this.
Try this trifecta:
// Use 'this' rather than 'window' as variable if this is about the current window.
IntPtr hWnd = WinRT.Interop.WindowNative.GetWindowHandle(window);
var windowId = Microsoft.UI.Win32Interop.GetWindowIdFromWindow(hWnd);
var appWindow = Microsoft.UI.Windowing.AppWindow.GetFromWindowId(windowId);
Then you can finally set the size with:
appWindow.Resize(new Windows.Graphics.SizeInt32 { Width = 480, Height = 800 });
Note that an AppWindow object has several other functions as well, like
MoveAndResize, Show, Hide, and features to modify the title bar.

Take a look at this repository dotMorten/WinUIEx.
It contains a method to set the window size and position
myWindow.SetWindowPositionAndSize(100, 100, 1024, 768);
I also found an example in the WinUI3 Samples
I'm adding the relevant code here for easy reference
private void SetWindowSize(IntPtr hwnd, int width, int height)
{
var dpi = PInvoke.User32.GetDpiForWindow(hwnd);
float scalingFactor = (float)dpi / 96;
width = (int)(width * scalingFactor);
height = (int)(height * scalingFactor);
PInvoke.User32.SetWindowPos(hwnd, PInvoke.User32.SpecialWindowHandles.HWND_TOP,
0, 0, width, height,
PInvoke.User32.SetWindowPosFlags.SWP_NOMOVE);
}

I can't comment on answers yet but to add to Jonas' answer, you can put his answer in the class constructor (where this.InitializeComponent() is) of your main window code-behind or in the OnLaunched method of App.cs. I'm sure that seems obvious to a lot of people but to those coming from other languages/platforms it might not be. Example:
public MainWindow()
{
this.InitializeComponent();
IntPtr hWnd = WinRT.Interop.WindowNative.GetWindowHandle(this); // m_window in App.cs
WindowId windowId = Win32Interop.GetWindowIdFromWindow(hWnd);
AppWindow appWindow = AppWindow.GetFromWindowId(windowId);
var size = new Windows.Graphics.SizeInt32();
size.Width = 480;
size.Height = 800;
appWindow.Resize(size);
// or like Jonas said:
// appWindow.Resize(new Windows.Graphics.SizeInt32 { Width = 480, Height = 800 });
}

This works. You will need to add the nuget package PInvoke.User32.
protected override void OnLaunched(Microsoft.UI.Xaml.LaunchActivatedEventArgs args)
{
m_window = new MainWindow();
m_window.Activate();
//Get the Window's HWND
var windowNative = m_window.As<IWindowNative>();
m_windowHandle = windowNative.WindowHandle;
m_window.Activate();
SetWindowBounds(0,0,100,100);
}
private Window m_window;
private IntPtr m_windowHandle;
public IntPtr WindowHandle { get { return m_windowHandle; } }
[ComImport]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
[Guid("EECDBF0E-BAE9-4CB6-A68E-9598E1CB57BB")]
internal interface IWindowNative
{
IntPtr WindowHandle { get; }
}
public void SetWindowBounds(int x, int y, int width, int height)
{
var dpi = PInvoke.User32.GetDpiForWindow(m_windowHandle);
float scalingFactor = (float)dpi / 96;
width = (int)(width * scalingFactor);
height = (int)(height * scalingFactor);
PInvoke.User32.SetWindowPos(m_windowHandle, PInvoke.User32.SpecialWindowHandles.HWND_TOP,
x, y, width, height,
PInvoke.User32.SetWindowPosFlags.SWP_NOMOVE);
}

Implement lens magnification to magnify the Windows Taskbar

I want to be able to perform lens magnificaiton on top of the windows taskbar. So far I've been unsuccessful in implementing this seeing as the taskbar will always open on top of my window. Windows built-in magnifier is able to do this so I'm hoping it is indeed possible.
I've attached two screenshots showing Windows built-in magnifier and how it is able to magnify the taskbar and how my application will render below the taskbar.
Windows built-in Magnifier:
My application:
Is there any way to have my application render above the taskbar and thus magnify the taskbar?
<Window x:Class="WpfNativeTesting.MagnificationWindow"
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:WpfNativeTesting"
mc:Ignorable="d"
Title="MagnificationWindow"
Height="400"
Width="400"
WindowStyle="None"
ResizeMode="NoResize"
AllowsTransparency="true"
ShowInTaskbar="False"
Topmost="True">
<Grid x:Name="ContainerGrid">
<Grid x:Name="MagnificationGrid" />
</Grid>
</Window>
public partial class MagnificationWindow : Window
{
private IntPtr HWnd;
private IntPtr HWndMag;
private bool MagnificationInitialized = false;
private DispatcherTimer Timer = new DispatcherTimer();
private RECT MagWindowRect = new RECT();
private bool IsColorEffectSet = false;
private float magnification = 1.0f;
public float Magnification
{
get { return magnification; }
set
{
if (value < 1.0f)
{
value = 1.0f;
}
if (HWndMag != null)
{
if (magnification != value)
{
magnification = value;
Transformation matrix = new Transformation(magnification);
NativeMethods.MagSetWindowTransform(HWndMag, ref matrix);
}
}
}
}
public MagnificationWindow()
{
InitializeComponent();
Loaded += MagnificationWindow_Loaded;
Show();
}
private void MagnificationWindow_Loaded(object sender, RoutedEventArgs e)
{
HWnd = new WindowInteropHelper(this).Handle;
var exStyle = NativeMethods.GetWindowLong(HWnd, NativeMethods.GWL_EXSTYLE);
exStyle |= (int)ExtendedWindowStyles.WS_EX_TOPMOST | (int)ExtendedWindowStyles.WS_EX_LAYERED | (int)ExtendedWindowStyles.WS_EX_TRANSPARENT;
NativeMethods.SetWindowLong(HWnd, NativeMethods.GWL_EXSTYLE, exStyle);
var style = NativeMethods.GetWindowLong(HWnd, NativeMethods.GWL_STYLE);
style |= (int)WindowStyles.WS_CAPTION | (int)WindowStyles.WS_SYSMENU;
NativeMethods.SetWindowLong(HWnd, NativeMethods.GWL_STYLE, exStyle);
MagnificationInitialized = NativeMethods.MagInitialize();
if (MagnificationInitialized)
{
SetupMagnifier();
Timer.Interval = TimeSpan.FromMilliseconds(NativeMethods.USER_TIMER_MINIMUM);
Timer.Tick += Timer_Tick;
Timer.Start();
}
}
protected override void OnClosing(CancelEventArgs e)
{
base.OnClosing(e);
RemoveMagnifier();
}
private void Timer_Tick(object sender, EventArgs e)
{
UpdateMaginifier();
}
private void SetupMagnifier()
{
var hInst = NativeMethods.GetModuleHandle(null);
NativeMethods.GetClientRect(HWnd, ref MagWindowRect);
HWndMag = NativeMethods.CreateWindow((int)ExtendedWindowStyles.WS_EX_STATICEDGE, NativeMethods.WC_MAGNIFIER,
"MagnificationWindow", (int)WindowStyles.WS_CHILD | (int)MagnifierStyle.MS_SHOWMAGNIFIEDCURSOR | (int)WindowStyles.WS_VISIBLE,
MagWindowRect.left, MagWindowRect.top, MagWindowRect.right, MagWindowRect.bottom, HWnd, IntPtr.Zero, hInst, IntPtr.Zero);
NativeMethods.MagShowSystemCursor(false);
if (HWndMag == IntPtr.Zero)
{
return;
}
var matrix = new Transformation(Magnification);
NativeMethods.MagSetWindowTransform(HWndMag, ref matrix);
}
private void UpdateMaginifier()
{
if (!MagnificationInitialized || HWndMag == IntPtr.Zero)
{
return;
}
POINT mousePoint = new POINT();
RECT sourceRect = new RECT();
NativeMethods.GetCursorPos(ref mousePoint);
int width = (int)((MagWindowRect.right - MagWindowRect.left) / Magnification);
int height = (int)((MagWindowRect.bottom - MagWindowRect.top) / Magnification);
sourceRect.left = mousePoint.x - width / 2;
sourceRect.top = mousePoint.y - height / 2;
NativeMethods.MagSetWindowSource(HWndMag, sourceRect);
POINT mouse = new POINT();
NativeMethods.GetCursorPos(ref mouse);
NativeMethods.SetWindowPos(HWnd, NativeMethods.HWND_TOPMOST, mouse.x - (int)(magnification * width / 2), mouse.y - (int)(magnification * height / 2), width, height,
(int)SetWindowPosFlags.SWP_NOACTIVATE |
(int)SetWindowPosFlags.SWP_NOSIZE);
NativeMethods.InvalidateRect(HWndMag, IntPtr.Zero, true);
}
public void RemoveMagnifier()
{
if (MagnificationInitialized)
{
NativeMethods.MagUninitialize();
MagnificationInitialized = false;
}
}
// ...
}

I posted this question in the Microsoft Q/A forum and got a solution that got it working.
https://learn.microsoft.com/en-us/answers/questions/54196/magnifier-control-unable-to-magnify-the-taskbar-st.html
We need to make it a Accessibility app by setting uiAcess=true in the
manifest, sign the executable, and placing it in a secure location
(e.g. Program Files) as described below:
Set uiAccess=true in the manifest Set this option in Visual Studio
by setting Linker | Manifest File | UAC Bypass UI Protection to Yes
Sign the executable See
https://learn.microsoft.com/en-us/previous-versions/bb756995(v=msdn.10)
Place it in a secure location See
https://learn.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations
I placed the application in a secure location before I signed it and used the following commands to create the certificate and sign the application.
makecert /n "CN=Company, O=Company, C=SE" /r /pe /h 0 /eku "1.3.6.1.5.5.7.3.3,1.3.6.1.4.1.311.10.3.13" /e 01/01/2021 /sv Company.pvk Company.cer
Pvk2Pfx /pvk Company.pvk /pi "password" /spc Company.cer /pfx Company.pfx /po "password" /pi "password"
and finally
signtool sign /f "Company.pfx" /p "password" "application".exe
And that's it!

Setting SharpDX.Windows.RenderForm.IsFullscreen before RenderLoop.Run corrupts window

I observed a weird and buggy behavior in SharpDX when implementing fullscreen and resolution switching code. Whenever I set RenderForm.IsFullscreen to true before I call RenderLoop.Run(), and return to windowed mode later on, the window is corrupted:
Notice how it's missing an icon, and my desktop background and the console shine through. Also, I can't click on it, any click is redirected to the underlying windows. Even while the RenderLoop is still run clearing the background color to dark blue, just a grayish and too small area is filled. (I can workaround this as a user by maximizing the corrupted window via the taskbar button. Simply resizing doesn't help.)
Here's my complete test code:
using System;
using System.Drawing;
using System.Windows.Forms;
using SharpDX;
using SharpDX.Direct3D;
using SharpDX.Direct3D11;
using SharpDX.DXGI;
using SharpDX.Windows;
internal class Program
{
private static RenderForm _window;
private static SharpDX.Direct3D11.Device _device;
private static DeviceContext _deviceContext;
private static SwapChain _swapChain;
private static RenderTargetView _renderTargetView;
private static bool Fullscreen
{
get
{
return _window.IsFullscreen;
}
set
{
// Do not resize multiple times by preventing the resized event.
_window.UserResized -= _window_UserResized;
_window.IsFullscreen = value;
_swapChain.SetFullscreenState(_window.IsFullscreen, null);
// Resize the window when returning to windowed mode to fit the most recent resolution.
if (!_window.IsFullscreen)
{
_window.ClientSize = _resolution;
}
// Allow new resize events.
_window.UserResized += _window_UserResized;
}
}
private static Size _resolution;
private static Size Resolution
{
get
{
return _resolution;
}
set
{
_resolution = value;
Debug.WriteLine("Setting resolution: " + _resolution.ToString());
// Do not resize multiple times by preventing the resized event.
_window.UserResized -= _window_UserResized;
// Resize the window in windowed mode.
if (!_window.IsFullscreen)
{
_window.ClientSize = _resolution;
}
// Dispose existing objects.
Utilities.Dispose(ref _renderTargetView);
// Resize the back buffer.
_swapChain.ResizeBuffers(0, _resolution.Width, _resolution.Height, Format.R8G8B8A8_UNorm, SwapChainFlags.AllowModeSwitch);
// Create the new and resized render target and set it.
using (Texture2D backBuffer = _swapChain.GetBackBuffer<Texture2D>(0))
{
_renderTargetView = new RenderTargetView(_device, backBuffer);
}
_deviceContext.OutputMerger.SetRenderTargets(_renderTargetView);
// Resize the swap chain buffers to set the fullscreen resolution.
ModeDescription bufferDescription = new ModeDescription()
{
Width = _resolution.Width,
Height = _resolution.Height,
RefreshRate = new Rational(60, 1),
Format = Format.R8G8B8A8_UNorm
};
_swapChain.ResizeTarget(ref bufferDescription);
// Allow new resize events.
_window.UserResized += _window_UserResized;
}
}
private static void Main(string[] args)
{
_window = new RenderForm();
_window.KeyDown += _window_KeyDown;
_window.IsFullscreen = true;
// Set default resolution.
_resolution = new Size(800, 600);
// Describe the swap chain buffer mode.
ModeDescription bufferDescription = new ModeDescription()
{
Width = _resolution.Width,
Height = _resolution.Height,
RefreshRate = new Rational(60, 1),
Format = Format.R8G8B8A8_UNorm
};
// Describe the swap chain.
SwapChainDescription swapChainDescription = new SwapChainDescription()
{
ModeDescription = bufferDescription,
SampleDescription = new SampleDescription(1, 0),
Usage = Usage.RenderTargetOutput,
BufferCount = 1,
OutputHandle = _window.Handle,
IsWindowed = !_window.IsFullscreen,
Flags = SwapChainFlags.AllowModeSwitch // Allows other fullscreen resolutions than native one.
};
// Create the device with the swap chain.
SharpDX.Direct3D11.Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, swapChainDescription, out _device, out _swapChain);
_deviceContext = _device.ImmediateContext;
// Set the resolution to run the code which resizes the internal buffers.
Resolution = _resolution;
_window.UserResized += _window_UserResized;
RenderLoop.Run(_window, Loop);
}
private static void Loop()
{
_deviceContext.ClearRenderTargetView(_renderTargetView, new Color4(0.4f, 0.5f, 0.6f, 1f));
_swapChain.Present(1, 0);
}
private static void _window_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.F)
{
Fullscreen = !Fullscreen;
}
}
private static void _window_UserResized(object sender, EventArgs e)
{
Resolution = _window.ClientSize;
}
}
I can rewrite the code to remember the fullscreen setting as a boolean and not use _window.IsFullscreen directly, then check if I'm in the first iteration of the rendering loop and set the fullscreen state in there by checking the boolean, but that's just awkward.
When I do so, the window animates onto the desktop as if it was newly created. It looks like SharpDX messes up window styles here.
Is this a SharpDX bug or am I doing something wrong? I did not find information that I should not set IsFullscreen to true before calling RenderLoop.Run().

Analyzing the window styles set, the corrupted window was missing WS_VISIBLE.
So, I simply forgot to Show() the render form. It turned out I have to do this even before analyzing any D3D stuff, or the window would become corrupted again.
Here's the fixed Main() method:
private static void Main(string[] args)
{
_window = new RenderForm();
_window.KeyDown += _window_KeyDown;
_window.IsFullscreen = true;
_window.Show(); // Do not forget this or window styles may break
// Set default resolution.
_resolution = new Size(800, 600);
// Describe the swap chain buffer mode.
ModeDescription bufferDescription = new ModeDescription()
{
Width = _resolution.Width,
Height = _resolution.Height,
RefreshRate = new Rational(60, 1),
Format = Format.R8G8B8A8_UNorm
};
// Describe the swap chain.
SwapChainDescription swapChainDescription = new SwapChainDescription()
{
ModeDescription = bufferDescription,
SampleDescription = new SampleDescription(1, 0),
Usage = Usage.RenderTargetOutput,
BufferCount = 1,
OutputHandle = _window.Handle,
IsWindowed = !_fullscreen,
Flags = SwapChainFlags.AllowModeSwitch // Allows other fullscreen resolutions than native one.
};
// Create the device with the swap chain.
SharpDX.Direct3D11.Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None,
swapChainDescription, out _device, out _swapChain);
_deviceContext = _device.ImmediateContext;
// Set the resolution to run the code which resizes the internal buffers.
Resolution = _resolution;
RenderLoop.Run(_window, Loop);
}

Display a Form in grayscale

Is it possible to Draw any Form (without overridding the Paint method) in grayscale.
If I show a Form in a Modal() Dialog, I wan't do show its parent as grayscale.
I noticed this in the Visual Studio Extension Manager. If a progressbar is downloading a package, the underlying window is grayed out.
I am thinking of this:
private void Button1_Click(object sender, EventArgs e)
{
using (var dialog = new Form2())
{
SetGrayscale(this, true);
dialog.ShowDialog();
SetGrayscale(this, false);
}
}
Update
Just setting Form.Enabled = false; is not what I intended. That does not look as good as a grayscale representation of my form.
I think the compiz window decorator for Linux did this with apps that are unresponsive.

As has already been said the way to do this is to overlay another control / form on top of your existing form and have it render a grayscale version of this on top, you could either do this using an additional form placed exactly over the original form, or using something like a Panel positioned on top of all other controls.
Here is a working example of how you might do this when placing another form exactly over the client area of the first. How to use it
using (Grayscale(this))
{
MessageBox.Show("Test");
}
Implementation
public static Form Grayscale(Form tocover)
{
var frm = new Form
{
FormBorderStyle = FormBorderStyle.None,
ControlBox = false,
ShowInTaskbar = false,
StartPosition = FormStartPosition.Manual,
AutoScaleMode = AutoScaleMode.None,
Location = tocover.PointToScreen(tocover.ClientRectangle.Location),
Size = tocover.ClientSize
};
frm.Paint += (sender, args) =>
{
var bmp = GetFormImageWithoutBorders(tocover);
bmp = ConvertToGrayscale(bmp);
args.Graphics.DrawImage(bmp, args.ClipRectangle.Location);
};
frm.Show(tocover);
return frm;
}
private static Bitmap ConvertToGrayscale(Bitmap source)
{
var bm = new Bitmap(source.Width, source.Height);
for (int y = 0; y < bm.Height; y++)
{
for (int x = 0; x < bm.Width; x++)
{
Color c = source.GetPixel(x, y);
var luma = (int)(c.R * 0.3 + c.G * 0.59 + c.B * 0.11);
bm.SetPixel(x, y, Color.FromArgb(luma, luma, luma));
}
}
return bm;
}
private static Bitmap GetControlImage(Control ctl)
{
var bm = new Bitmap(ctl.Width, ctl.Height);
ctl.DrawToBitmap(bm, new Rectangle(0, 0, ctl.Width, ctl.Height));
return bm;
}
private static Bitmap GetFormImageWithoutBorders(Form frm)
{
// Get the form's whole image.
using (Bitmap wholeForm = GetControlImage(frm))
{
// See how far the form's upper left corner is
// from the upper left corner of its client area.
Point origin = frm.PointToScreen(new Point(0, 0));
int dx = origin.X - frm.Left;
int dy = origin.Y - frm.Top;
// Copy the client area into a new Bitmap.
int wid = frm.ClientSize.Width;
int hgt = frm.ClientSize.Height;
var bm = new Bitmap(wid, hgt);
using (Graphics gr = Graphics.FromImage(bm))
{
gr.DrawImage(wholeForm, 0, 0,
new Rectangle(dx, dy, wid, hgt),
GraphicsUnit.Pixel);
}
return bm;
}
}
Note that:
The implementation of Paint is fairly poor - really it should use double buffering so that the grayscale image is pre-rendered to a buffered graphics context so the Paint method just needs to paint the pre-drawn buffer contents. See Custom Drawing Controls in C# – Manual Double Buffering
ConvertToGrayscale is a tad on the slow side, but can probably be sped up
Things will go wrong if someone manages to move the original form for any reason
The image is static, if the base control gets redrawn then ideally the top form should redraw too. I'm not sure how best to detect when a portion of another form has been invalidated.
If I find the time I'll try and fix some of those problems, but the above at least gives you the general idea.
Note that in WPF this would be a lot easier.
Sources:
How to convert a colour image to grayscale
Get the image of a control or form, or a form's client area in C#

I don't think there is a way to do it directly - I think all forms are rendered with sRGB.
A hacky way could be to overlay the form with a copy of it as an image (this is simple to do with Control.DrawToBitMap) and then pass it through a simple GDI matrix to desaturate https://web.archive.org/web/20141230145627/http://bobpowell.net/grayscale.aspx.

Try something like this which would work for most simple controls (you would need to recurse into containers to switch all controls correctly).
private void button1_Click(object sender, EventArgs e)
{
using (var dialog = new Form())
{
Dictionary<Control, Tuple<Color, Color>> oldcolors = new Dictionary<Control, Tuple<Color, Color>>();
foreach (Control ctl in this.Controls)
{
oldcolors.Add(ctl, Tuple.Create(ctl.BackColor, ctl.ForeColor));
// get rough avg intensity of color
int bg = (ctl.BackColor.R + ctl.BackColor.G + ctl.BackColor.B) / 3;
int fg = (ctl.ForeColor.R + ctl.ForeColor.G + ctl.ForeColor.B) / 3;
ctl.BackColor = Color.FromArgb(bg, bg, bg);
ctl.ForeColor = Color.FromArgb(fg, fg, fg);
}
dialog.ShowDialog();
foreach (Control ctl in this.Controls)
{
ctl.BackColor = oldcolors[ctl].Item1;
ctl.ForeColor = oldcolors[ctl].Item2;
}
}
}