Merge remote-tracking branch 'upstream/master' into feature/TextRunProperties

.gitmodules

@@ -3,4 +3,4 @@
 	url = https://github.com/kekekeks/Numerge.git
 [submodule "src/Markup/Avalonia.Markup.Xaml/XamlIl/xamlil.github"]
 	path = src/Markup/Avalonia.Markup.Xaml/XamlIl/xamlil.github
-	url = https://github.com/kekekeks/XamlIl.git
+	url = https://github.com/kekekeks/XamlX.git

native/Avalonia.Native/inc/avalonia-native.h

@@ -205,6 +205,15 @@ enum AvnMenuItemToggleType
     Radio
 };
 
+enum AvnExtendClientAreaChromeHints
+{
+    AvnNoChrome = 0,
+    AvnSystemChrome = 0x01,
+    AvnPreferSystemChrome = 0x02,
+    AvnOSXThickTitleBar = 0x08,
+    AvnDefaultChrome = AvnSystemChrome,
+};
+
 AVNCOM(IAvaloniaNativeFactory, 01) : IUnknown
 {
 public:
@@ -279,6 +288,10 @@ AVNCOM(IAvnWindow, 04) : virtual IAvnWindowBase
     virtual HRESULT SetWindowState(AvnWindowState state) = 0;
     virtual HRESULT GetWindowState(AvnWindowState*ret) = 0;
     virtual HRESULT TakeFocusFromChildren() = 0;
+    virtual HRESULT SetExtendClientArea (bool enable) = 0;
+    virtual HRESULT SetExtendClientAreaHints (AvnExtendClientAreaChromeHints hints) = 0;
+    virtual HRESULT GetExtendTitleBarHeight (double*ret) = 0;
+    virtual HRESULT SetExtendTitleBarHeight (double value) = 0;
 };
 
 AVNCOM(IAvnWindowBaseEvents, 05) : IUnknown

native/Avalonia.Native/src/OSX/window.h

@@ -3,9 +3,6 @@
 
 class WindowBaseImpl;
 
-@interface AutoFitContentVisualEffectView : NSVisualEffectView
-@end
-
 @interface AvnView : NSView<NSTextInputClient, NSDraggingDestination>
 -(AvnView* _Nonnull) initWithParent: (WindowBaseImpl* _Nonnull) parent;
 -(NSEvent* _Nonnull) lastMouseDownEvent;
@@ -15,6 +12,14 @@ class WindowBaseImpl;
 -(AvnPixelSize) getPixelSize;
 @end
 
+@interface AutoFitContentView : NSView
+-(AutoFitContentView* _Nonnull) initWithContent: (NSView* _Nonnull) content;
+-(void) ShowTitleBar: (bool) show;
+-(void) SetTitleBarHeightHint: (double) height;
+-(void) SetContent: (NSView* _Nonnull) content;
+-(void) ShowBlur: (bool) show;
+@end
+
 @interface AvnWindow : NSWindow <NSWindowDelegate>
 +(void) closeAll;
 -(AvnWindow* _Nonnull) initWithParent: (WindowBaseImpl* _Nonnull) parent;
@@ -27,6 +32,8 @@ class WindowBaseImpl;
 -(void) showWindowMenuWithAppMenu;
 -(void) applyMenu:(NSMenu* _Nullable)menu;
 -(double) getScaling;
+-(double) getExtendedTitleBarHeight;
+-(void) setIsExtended:(bool)value;
 @end
 
 struct INSWindowHolder

native/Avalonia.Native/src/OSX/window.mm

@@ -6,8 +6,6 @@
 #include <OpenGL/gl.h>
 #include "rendertarget.h"
 
-
-
 class WindowBaseImpl : public virtual ComSingleObject<IAvnWindowBase, &IID_IAvnWindowBase>, public INSWindowHolder
 {
 private:
@@ -20,7 +18,7 @@ public:
         View = NULL;
         Window = NULL;
     }
-    NSVisualEffectView* VisualEffect;
+    AutoFitContentView* StandardContainer;
     AvnView* View;
     AvnWindow* Window;
     ComPtr<IAvnWindowBaseEvents> BaseEvents;
@@ -39,6 +37,7 @@ public:
         _glContext = gl;
         renderTarget = [[IOSurfaceRenderTarget alloc] initWithOpenGlContext: gl];
         View = [[AvnView alloc] initWithParent:this];
+        StandardContainer = [[AutoFitContentView new] initWithContent:View];
 
         Window = [[AvnWindow alloc] initWithParent:this];
         
@@ -49,12 +48,8 @@ public:
         [Window setStyleMask:NSWindowStyleMaskBorderless];
         [Window setBackingType:NSBackingStoreBuffered];
         
-        VisualEffect = [AutoFitContentVisualEffectView new];
+        [Window setOpaque:false];
-        [VisualEffect setBlendingMode:NSVisualEffectBlendingModeBehindWindow];
+        [Window setContentView: StandardContainer];
-        [VisualEffect setMaterial:NSVisualEffectMaterialLight];
-        [VisualEffect setAutoresizesSubviews:true];
-        
-        [Window setContentView: View];
     }
     
     virtual HRESULT ObtainNSWindowHandle(void** ret) override
@@ -410,12 +405,7 @@ public:
     
     virtual HRESULT SetBlurEnabled (bool enable) override
     {
-        [Window setContentView: enable ? VisualEffect : View];
+        [StandardContainer ShowBlur:enable];
-        
-        if(enable)
-        {
-            [VisualEffect addSubview:View];
-        }
         
         return S_OK;
     }
@@ -492,6 +482,8 @@ private:
     bool _inSetWindowState;
     NSRect _preZoomSize;
     bool _transitioningWindowState;
+    bool _isClientAreaExtended;
+    AvnExtendClientAreaChromeHints _extendClientHints;
     
     FORWARD_IUNKNOWN()
     BEGIN_INTERFACE_MAP()
@@ -505,6 +497,8 @@ private:
     ComPtr<IAvnWindowEvents> WindowEvents;
     WindowImpl(IAvnWindowEvents* events, IAvnGlContext* gl) : WindowBaseImpl(events, gl)
     {
+        _isClientAreaExtended = false;
+        _extendClientHints = AvnDefaultChrome;
         _fullScreenActive = false;
         _canResize = true;
         _decorations = SystemDecorationsFull;
@@ -523,8 +517,20 @@ private:
             if ([subview isKindOfClass:NSClassFromString(@"NSTitlebarContainerView")]) {
                 NSView *titlebarView = [subview subviews][0];
                 for (id button in titlebarView.subviews) {
-                    if ([button isKindOfClass:[NSButton class]]) {
+                    if ([button isKindOfClass:[NSButton class]])
-                        [button setHidden: (_decorations != SystemDecorationsFull)];
+                    {
+                        if(_isClientAreaExtended)
+                        {
+                            auto wantsChrome = (_extendClientHints & AvnSystemChrome) || (_extendClientHints & AvnPreferSystemChrome);
+                            
+                            [button setHidden: !wantsChrome];
+                        }
+                        else
+                        {
+                            [button setHidden: (_decorations != SystemDecorationsFull)];
+                        }
+                        
+                        [button setWantsLayer:true];
                     }
                 }
             }
@@ -600,6 +606,35 @@ private:
             
             if(_lastWindowState != state)
             {
+                if(_isClientAreaExtended)
+                {
+                    if(_lastWindowState == FullScreen)
+                    {
+                        // we exited fs.
+                       if(_extendClientHints & AvnOSXThickTitleBar)
+                       {
+                          Window.toolbar = [NSToolbar new];
+                          Window.toolbar.showsBaselineSeparator = false;
+                       }
+
+                       [Window setTitlebarAppearsTransparent:true];
+
+                       [StandardContainer setFrameSize: StandardContainer.frame.size];
+                    }
+                    else if(state == FullScreen)
+                    {
+                        // we entered fs.
+                        if(_extendClientHints & AvnOSXThickTitleBar)
+                        {
+                            Window.toolbar = nullptr;
+                        }
+                       
+                        [Window setTitlebarAppearsTransparent:false];
+                        
+                        [StandardContainer setFrameSize: StandardContainer.frame.size];
+                    }
+                }
+                
                 _lastWindowState = state;
                 WindowEvents->WindowStateChanged(state);
             }
@@ -656,8 +691,6 @@ private:
                 return S_OK;
             }
             
-            auto currentFrame = [Window frame];
-            
             UpdateStyle();
             
             HideOrShowTrafficLights();
@@ -790,6 +823,81 @@ private:
             return S_OK;
         if([Window isKeyWindow])
             [Window makeFirstResponder: View];
+        
+        return S_OK;
+    }
+    
+    virtual HRESULT SetExtendClientArea (bool enable) override
+    {
+        _isClientAreaExtended = enable;
+        
+        if(enable)
+        {
+            Window.titleVisibility = NSWindowTitleHidden;
+            
+            [Window setTitlebarAppearsTransparent:true];
+            
+            auto wantsTitleBar = (_extendClientHints & AvnSystemChrome) || (_extendClientHints & AvnPreferSystemChrome);
+            
+            if (wantsTitleBar)
+            {
+                [StandardContainer ShowTitleBar:true];
+            }
+            else
+            {
+                [StandardContainer ShowTitleBar:false];
+            }
+            
+            if(_extendClientHints & AvnOSXThickTitleBar)
+            {
+                Window.toolbar = [NSToolbar new];
+                Window.toolbar.showsBaselineSeparator = false;
+            }
+            else
+            {
+                Window.toolbar = nullptr;
+            }
+        }
+        else
+        {
+            Window.titleVisibility = NSWindowTitleVisible;
+            Window.toolbar = nullptr;
+            [Window setTitlebarAppearsTransparent:false];
+            View.layer.zPosition = 0;
+        }
+        
+        [Window setIsExtended:enable];
+        
+        HideOrShowTrafficLights();
+        
+        UpdateStyle();
+        
+        return S_OK;
+    }
+    
+    virtual HRESULT SetExtendClientAreaHints (AvnExtendClientAreaChromeHints hints) override
+    {
+        _extendClientHints = hints;
+        
+        SetExtendClientArea(_isClientAreaExtended);
+        return S_OK;
+    }
+    
+    virtual HRESULT GetExtendTitleBarHeight (double*ret) override
+    {
+        if(ret == nullptr)
+        {
+            return E_POINTER;
+        }
+        
+        *ret = [Window getExtendedTitleBarHeight];
+        
+        return S_OK;
+    }
+    
+    virtual HRESULT SetExtendTitleBarHeight (double value) override
+    {
+        [StandardContainer SetTitleBarHeightHint:value];
         return S_OK;
     }
     
@@ -802,8 +910,9 @@ private:
         [Window setTitlebarAppearsTransparent:NO];
         [Window setTitle:_lastTitle];
         
-        [Window setStyleMask:NSWindowStyleMaskTitled | NSWindowStyleMaskResizable];
+        Window.styleMask = Window.styleMask | NSWindowStyleMaskTitled | NSWindowStyleMaskResizable;
-        
+        Window.styleMask = Window.styleMask & ~NSWindowStyleMaskFullSizeContentView;
+    
         [Window toggleFullScreen:nullptr];
     }
     
@@ -951,19 +1060,120 @@ protected:
         {
             s |= NSWindowStyleMaskMiniaturizable;
         }
+        
+        if(_isClientAreaExtended)
+        {
+            s |= NSWindowStyleMaskFullSizeContentView | NSWindowStyleMaskTexturedBackground;
+        }
         return s;
     }
 };
 
 NSArray* AllLoopModes = [NSArray arrayWithObjects: NSDefaultRunLoopMode, NSEventTrackingRunLoopMode, NSModalPanelRunLoopMode, NSRunLoopCommonModes, NSConnectionReplyMode, nil];
 
-@implementation AutoFitContentVisualEffectView
+@implementation AutoFitContentView
+{
+    NSVisualEffectView* _titleBarMaterial;
+    NSBox* _titleBarUnderline;
+    NSView* _content;
+    NSVisualEffectView* _blurBehind;
+    double _titleBarHeightHint;
+    bool _settingSize;
+}
+
+-(AutoFitContentView* _Nonnull) initWithContent:(NSView *)content
+{
+    _titleBarHeightHint = -1;
+    _content = content;
+    _settingSize = false;
+
+    [self setAutoresizesSubviews:true];
+    [self setWantsLayer:true];
+    
+    _titleBarMaterial = [NSVisualEffectView new];
+    [_titleBarMaterial setBlendingMode:NSVisualEffectBlendingModeWithinWindow];
+    [_titleBarMaterial setMaterial:NSVisualEffectMaterialTitlebar];
+    [_titleBarMaterial setWantsLayer:true];
+    _titleBarMaterial.hidden = true;
+    
+    _titleBarUnderline = [NSBox new];
+    _titleBarUnderline.boxType = NSBoxSeparator;
+    _titleBarUnderline.fillColor = [NSColor underPageBackgroundColor];
+    _titleBarUnderline.hidden = true;
+    
+    [self addSubview:_titleBarMaterial];
+    [self addSubview:_titleBarUnderline];
+    
+    _blurBehind = [NSVisualEffectView new];
+    [_blurBehind setBlendingMode:NSVisualEffectBlendingModeBehindWindow];
+    [_blurBehind setMaterial:NSVisualEffectMaterialLight];
+    [_blurBehind setWantsLayer:true];
+    _blurBehind.hidden = true;
+    
+    [self addSubview:_blurBehind];
+    [self addSubview:_content];
+    
+    [self setWantsLayer:true];
+    return self;
+}
+
+-(void) ShowBlur:(bool)show
+{
+    _blurBehind.hidden = !show;
+}
+
+-(void) ShowTitleBar: (bool) show
+{
+    _titleBarMaterial.hidden = !show;
+    _titleBarUnderline.hidden = !show;
+}
+
+-(void) SetTitleBarHeightHint: (double) height
+{
+    _titleBarHeightHint = height;
+    
+    [self setFrameSize:self.frame.size];
+}
+
 -(void)setFrameSize:(NSSize)newSize
 {
-    [super setFrameSize:newSize];
+    if(_settingSize)
-    if([[self subviews] count] == 0)
+    {
         return;
-    [[self subviews][0] setFrameSize: newSize];
+    }
+    
+    _settingSize = true;
+    [super setFrameSize:newSize];
+    
+    [_blurBehind setFrameSize:newSize];
+    [_content setFrameSize:newSize];
+    
+    auto window = objc_cast<AvnWindow>([self window]);
+    
+    // TODO get actual titlebar size
+    
+    double height = _titleBarHeightHint == -1 ? [window getExtendedTitleBarHeight] : _titleBarHeightHint;
+    
+    NSRect tbar;
+    tbar.origin.x = 0;
+    tbar.origin.y = newSize.height - height;
+    tbar.size.width = newSize.width;
+    tbar.size.height = height;
+    
+    [_titleBarMaterial setFrame:tbar];
+    tbar.size.height = height < 1 ? 0 : 1;
+    [_titleBarUnderline setFrame:tbar];
+    _settingSize = false;
+}
+
+-(void) SetContent: (NSView* _Nonnull) content
+{
+    if(content != nullptr)
+    {
+        [content removeFromSuperview];
+        [self addSubview:content];
+        _content = content;
+    }
 }
 @end
 
@@ -1523,15 +1733,43 @@ NSArray* AllLoopModes = [NSArray arrayWithObjects: NSDefaultRunLoopMode, NSEvent
     bool _canBecomeKeyAndMain;
     bool _closed;
     bool _isEnabled;
+    bool _isExtended;
     AvnMenu* _menu;
     double _lastScaling;
 }
 
+-(void) setIsExtended:(bool)value;
+{
+    _isExtended = value;
+}
+
 -(double) getScaling
 {
     return _lastScaling;
 }
 
+-(double) getExtendedTitleBarHeight
+{
+    if(_isExtended)
+    {
+        for (id subview in self.contentView.superview.subviews)
+        {
+            if ([subview isKindOfClass:NSClassFromString(@"NSTitlebarContainerView")])
+            {
+                NSView *titlebarView = [subview subviews][0];
+
+                return (double)titlebarView.frame.size.height;
+            }
+        }
+
+        return -1;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
 +(void)closeAll
 {
     NSArray<NSWindow*>* windows = [NSArray arrayWithArray:[NSApp windows]];
@@ -1650,6 +1888,7 @@ NSArray* AllLoopModes = [NSArray arrayWithObjects: NSDefaultRunLoopMode, NSEvent
     [self setOpaque:NO];
     [self setBackgroundColor: [NSColor clearColor]];
     [self invalidateShadow];
+    _isExtended = false;
     return self;
 }
 

samples/ControlCatalog/MainView.xaml

@@ -66,6 +66,7 @@
       <TabItem Header="ToolTip"><pages:ToolTipPage/></TabItem>
       <TabItem Header="TreeView"><pages:TreeViewPage/></TabItem>
       <TabItem Header="Viewbox"><pages:ViewboxPage/></TabItem>
+      <TabItem Header="Window Customizations"><pages:WindowCustomizationsPage/></TabItem>
       <TabControl.Tag>
         <StackPanel Width="115" Spacing="4" HorizontalAlignment="Right" VerticalAlignment="Bottom" Margin="8">
           <ComboBox x:Name="Decorations" SelectedIndex="0">

samples/ControlCatalog/MainView.xaml.cs

@@ -58,13 +58,6 @@ namespace ControlCatalog
                 if (VisualRoot is Window window)
                     window.SystemDecorations = (SystemDecorations)decorations.SelectedIndex;
             };
-
-            var transparencyLevels = this.Find<ComboBox>("TransparencyLevels");
-            transparencyLevels.SelectionChanged += (sender, e) =>
-            {
-                if (VisualRoot is Window window)
-                    window.TransparencyLevelHint = (WindowTransparencyLevel)transparencyLevels.SelectedIndex;
-            };
         }
 
         protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)

samples/ControlCatalog/MainWindow.xaml

@@ -7,7 +7,13 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:vm="clr-namespace:ControlCatalog.ViewModels"
         xmlns:v="clr-namespace:ControlCatalog.Views"
-        x:Class="ControlCatalog.MainWindow" WindowState="{Binding WindowState, Mode=TwoWay}" Background="{DynamicResource SystemControlPageBackgroundAltHighBrush}">
+        ExtendClientAreaToDecorationsHint="{Binding ExtendClientAreaEnabled}"
+        ExtendClientAreaChromeHints="{Binding ChromeHints}"
+        ExtendClientAreaTitleBarHeightHint="{Binding TitleBarHeight}"
+        TransparencyLevelHint="{Binding TransparencyLevel}"
+        TransparencyBackgroundFallback="Transparent"
+        x:Name="MainWindow"
+        x:Class="ControlCatalog.MainWindow" WindowState="{Binding WindowState, Mode=TwoWay}" Background="{x:Null}">
   <NativeMenu.Menu>
     <NativeMenu>
       <NativeMenuItem Header="File">
@@ -56,20 +62,30 @@
     </NativeMenu>
   </NativeMenu.Menu>
 
- <Window.DataTemplates>
+  <Window.DataTemplates>
     <DataTemplate DataType="vm:NotificationViewModel">
       <v:CustomNotificationView />
     </DataTemplate>
   </Window.DataTemplates>
-  <DockPanel LastChildFill="True">
+  <Panel>
-    <Menu Name="MainMenu" DockPanel.Dock="Top">
+    <Panel Margin="{Binding #MainWindow.OffScreenMargin}">
-      <MenuItem Header="File">
+      <DockPanel Background="{DynamicResource SystemControlBackgroundChromeBlackHighBrush}" LastChildFill="True" Margin="{Binding #MainWindow.WindowDecorationMargin}">
-        <MenuItem Header="Exit" Command="{Binding ExitCommand}" />
+        <Menu Name="MainMenu" DockPanel.Dock="Top">
-      </MenuItem>
+          <MenuItem Header="File">
-      <MenuItem Header="Help">
+            <MenuItem Header="Exit" Command="{Binding ExitCommand}" />
-        <MenuItem Header="About" Command="{Binding AboutCommand}" />
+          </MenuItem>
-      </MenuItem>
+          <MenuItem Header="Help">
-    </Menu>
+            <MenuItem Header="About" Command="{Binding AboutCommand}" />
-    <local:MainView />
+          </MenuItem>
-  </DockPanel>
+        </Menu>
+        <local:MainView />
+      </DockPanel>
+    </Panel>
+    <Border IsVisible="{Binding ExtendClientAreaEnabled}" BorderThickness="1 1 1 0" CornerRadius="4 4 0 0" BorderBrush="#55000000" Height="22" VerticalAlignment="Top" HorizontalAlignment="Left" Margin="250 8 0 0">
+      <Border.Background>
+        <SolidColorBrush Color="White" Opacity="0.7" />
+      </Border.Background>
+      <TextBlock Margin="5 5 5 0" Text="Content In Title Bar" />
+    </Border>
+  </Panel>
 </Window>

samples/ControlCatalog/Pages/WindowCustomizationsPage.xaml

@@ -0,0 +1,19 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             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"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+             x:Class="ControlCatalog.Pages.WindowCustomizationsPage">
+  <StackPanel Spacing="10"  Margin="25">
+    <CheckBox Content="Extend Client Area to Decorations" IsChecked="{Binding ExtendClientAreaEnabled}" />
+    <CheckBox Content="Title Bar" IsChecked="{Binding SystemTitleBarEnabled}" />    
+    <CheckBox Content="Prefer System Chrome" IsChecked="{Binding PreferSystemChromeEnabled}" />
+    <Slider Minimum="-1" Maximum="200" Value="{Binding TitleBarHeight}" />
+    <ComboBox x:Name="TransparencyLevels" SelectedIndex="{Binding TransparencyLevel}">
+      <ComboBoxItem>None</ComboBoxItem>
+      <ComboBoxItem>Transparent</ComboBoxItem>
+      <ComboBoxItem>Blur</ComboBoxItem>
+      <ComboBoxItem>AcrylicBlur</ComboBoxItem>
+    </ComboBox>
+  </StackPanel>
+</UserControl>

samples/ControlCatalog/Pages/WindowCustomizationsPage.xaml.cs

@@ -0,0 +1,19 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace ControlCatalog.Pages
+{
+    public class WindowCustomizationsPage : UserControl
+    {
+        public WindowCustomizationsPage()
+        {
+            this.InitializeComponent();
+        }
+
+        private void InitializeComponent()
+        {
+            AvaloniaXamlLoader.Load(this);
+        }
+    }
+}

samples/ControlCatalog/ViewModels/MainWindowViewModel.cs

@@ -3,6 +3,8 @@ using Avalonia.Controls;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Controls.Notifications;
 using Avalonia.Dialogs;
+using Avalonia.Platform;
+using System;
 using ReactiveUI;
 
 namespace ControlCatalog.ViewModels
@@ -14,6 +16,12 @@ namespace ControlCatalog.ViewModels
         private bool _isMenuItemChecked = true;
         private WindowState _windowState;
         private WindowState[] _windowStates;
+        private int _transparencyLevel;
+        private ExtendClientAreaChromeHints _chromeHints;
+        private bool _extendClientAreaEnabled;
+        private bool _systemTitleBarEnabled;        
+        private bool _preferSystemChromeEnabled;
+        private double _titleBarHeight;
 
         public MainWindowViewModel(IManagedNotificationManager notificationManager)
         {
@@ -62,6 +70,63 @@ namespace ControlCatalog.ViewModels
                 WindowState.Maximized,
                 WindowState.FullScreen,
             };
+
+            this.WhenAnyValue(x => x.SystemTitleBarEnabled, x=>x.PreferSystemChromeEnabled)
+                .Subscribe(x =>
+                {
+                    var hints = ExtendClientAreaChromeHints.NoChrome | ExtendClientAreaChromeHints.OSXThickTitleBar;
+
+                    if(x.Item1)
+                    {
+                        hints |= ExtendClientAreaChromeHints.SystemChrome;
+                    }
+
+                    if(x.Item2)
+                    {
+                        hints |= ExtendClientAreaChromeHints.PreferSystemChrome;
+                    }
+
+                    ChromeHints = hints;
+                });
+
+            SystemTitleBarEnabled = true;            
+            TitleBarHeight = -1;
+        }        
+
+        public int TransparencyLevel
+        {
+            get { return _transparencyLevel; }
+            set { this.RaiseAndSetIfChanged(ref _transparencyLevel, value); }
+        }        
+
+        public ExtendClientAreaChromeHints ChromeHints
+        {
+            get { return _chromeHints; }
+            set { this.RaiseAndSetIfChanged(ref _chromeHints, value); }
+        }        
+
+        public bool ExtendClientAreaEnabled
+        {
+            get { return _extendClientAreaEnabled; }
+            set { this.RaiseAndSetIfChanged(ref _extendClientAreaEnabled, value); }
+        }        
+
+        public bool SystemTitleBarEnabled
+        {
+            get { return _systemTitleBarEnabled; }
+            set { this.RaiseAndSetIfChanged(ref _systemTitleBarEnabled, value); }
+        }        
+
+        public bool PreferSystemChromeEnabled
+        {
+            get { return _preferSystemChromeEnabled; }
+            set { this.RaiseAndSetIfChanged(ref _preferSystemChromeEnabled, value); }
+        }        
+
+        public double TitleBarHeight
+        {
+            get { return _titleBarHeight; }
+            set { this.RaiseAndSetIfChanged(ref _titleBarHeight, value); }
         }
 
         public WindowState WindowState

src/Avalonia.Build.Tasks/Avalonia.Build.Tasks.csproj

@@ -5,7 +5,7 @@
         <OutputType>exe</OutputType>
         <GenerateDocumentationFile>false</GenerateDocumentationFile>
         <BuildOutputTargetFolder>tools</BuildOutputTargetFolder>
-        <DefineConstants>$(DefineConstants);BUILDTASK;XAMLIL_CECIL_INTERNAL;XAMLIL_INTERNAL</DefineConstants>
+        <DefineConstants>$(DefineConstants);BUILDTASK;XAMLX_CECIL_INTERNAL;XAMLX_INTERNAL</DefineConstants>
         <CopyLocalLockFileAssemblies Condition="$(TargetFramework) == 'netstandard2.0'">true</CopyLocalLockFileAssemblies>
         <NoWarn>NU1605</NoWarn>
     </PropertyGroup>
@@ -21,10 +21,10 @@
         <Link>XamlIlExtensions/%(RecursiveDir)%(FileName)%(Extension)</Link>
       </Compile>
       <Compile Remove="external/cecil/**/*.*" />
-      <Compile Include="../Markup/Avalonia.Markup.Xaml/XamlIl\xamlil.github\src\XamlIl\**\*.cs">
+      <Compile Include="../Markup/Avalonia.Markup.Xaml/XamlIl\xamlil.github\src\XamlX\**\*.cs">
         <Link>XamlIl/%(RecursiveDir)%(FileName)%(Extension)</Link>
       </Compile>
-      <Compile Include="../Markup/Avalonia.Markup.Xaml/XamlIl\xamlil.github\src\XamlIl.Cecil\**\*.cs">
+      <Compile Include="../Markup/Avalonia.Markup.Xaml/XamlIl\xamlil.github\src\XamlX.IL.Cecil\**\*.cs">
         <Link>XamlIl.Cecil/%(RecursiveDir)%(FileName)%(Extension)</Link>
       </Compile>
       <Compile Include="../Markup/Avalonia.Markup\Markup\Parsers\SelectorGrammar.cs">
@@ -47,7 +47,7 @@
       </Compile>
 
       <Compile Remove="../Markup/Avalonia.Markup.Xaml/XamlIl\xamlil.github\**\obj\**\*.cs" />
-      <Compile Remove="../Markup/Avalonia.Markup.Xaml/XamlIl\xamlil.github\src\XamlIl\TypeSystem\SreTypeSystem.cs" />
+      <Compile Remove="../Markup/Avalonia.Markup.Xaml/XamlIl\xamlil.github\src\XamlX\IL\SreTypeSystem.cs" />
       <PackageReference Include="Avalonia.Unofficial.Cecil" Version="20190417.2.0" PrivateAssets="All" />
       <PackageReference Condition="$(TargetFramework) == 'netstandard2.0'" Include="ILRepack.MSBuild.Task" Version="2.0.13" PrivateAssets="All" />
       <PackageReference Include="Microsoft.Build.Framework" Version="15.1.548" PrivateAssets="All" />

src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.Helpers.cs

@@ -5,7 +5,7 @@ using Avalonia.Utilities;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using Mono.Collections.Generic;
-using XamlIl.TypeSystem;
+using XamlX.TypeSystem;
 
 namespace Avalonia.Build.Tasks
 {

src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.cs

@@ -7,17 +7,18 @@ using System.Text;
 using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions;
 using Microsoft.Build.Framework;
 using Mono.Cecil;
-using XamlIl.TypeSystem;
 using Avalonia.Utilities;
 using Mono.Cecil.Cil;
 using Mono.Cecil.Rocks;
-using XamlIl;
+using XamlX;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Parsers;
+using XamlX.Parsers;
-using XamlIl.Transform;
+using XamlX.Transform;
+using XamlX.TypeSystem;
 using FieldAttributes = Mono.Cecil.FieldAttributes;
 using MethodAttributes = Mono.Cecil.MethodAttributes;
 using TypeAttributes = Mono.Cecil.TypeAttributes;
+using XamlX.IL;
 
 namespace Avalonia.Build.Tasks
 {
@@ -51,11 +52,11 @@ namespace Avalonia.Build.Tasks
                 // Nothing to do
                 return new CompileResult(true);
             
-            var xamlLanguage = AvaloniaXamlIlLanguage.Configure(typeSystem);
+            var (xamlLanguage , emitConfig) = AvaloniaXamlIlLanguage.Configure(typeSystem);
-            var compilerConfig = new XamlIlTransformerConfiguration(typeSystem,
+            var compilerConfig = new TransformerConfiguration(typeSystem,
                 typeSystem.TargetAssembly,
                 xamlLanguage,
-                XamlIlXmlnsMappings.Resolve(typeSystem, xamlLanguage),
+                XamlXmlnsMappings.Resolve(typeSystem, xamlLanguage),
                 AvaloniaXamlIlLanguage.CustomValueConverter);
 
 
@@ -63,10 +64,10 @@ namespace Avalonia.Build.Tasks
                 TypeAttributes.Class, asm.MainModule.TypeSystem.Object);
             asm.MainModule.Types.Add(contextDef);
 
-            var contextClass = XamlIlContextDefinition.GenerateContextClass(typeSystem.CreateTypeBuilder(contextDef), typeSystem,
+            var contextClass = XamlILContextDefinition.GenerateContextClass(typeSystem.CreateTypeBuilder(contextDef), typeSystem,
-                xamlLanguage);
+                xamlLanguage, emitConfig);
 
-            var compiler = new AvaloniaXamlIlCompiler(compilerConfig, contextClass) { EnableIlVerification = verifyIl };
+            var compiler = new AvaloniaXamlIlCompiler(compilerConfig, emitConfig, contextClass) { EnableIlVerification = verifyIl };
 
             var editorBrowsableAttribute = typeSystem
                 .GetTypeReference(typeSystem.FindType("System.ComponentModel.EditorBrowsableAttribute"))
@@ -126,35 +127,35 @@ namespace Avalonia.Build.Tasks
 
                         // StreamReader is needed here to handle BOM
                         var xaml = new StreamReader(new MemoryStream(res.FileContents)).ReadToEnd();
-                        var parsed = XDocumentXamlIlParser.Parse(xaml);
+                        var parsed = XDocumentXamlParser.Parse(xaml);
 
-                        var initialRoot = (XamlIlAstObjectNode)parsed.Root;
+                        var initialRoot = (XamlAstObjectNode)parsed.Root;
                         
                         
-                        var precompileDirective = initialRoot.Children.OfType<XamlIlAstXmlDirective>()
+                        var precompileDirective = initialRoot.Children.OfType<XamlAstXmlDirective>()
                             .FirstOrDefault(d => d.Namespace == XamlNamespaces.Xaml2006 && d.Name == "Precompile");
                         if (precompileDirective != null)
                         {
-                            var precompileText = (precompileDirective.Values[0] as XamlIlAstTextNode)?.Text.Trim()
+                            var precompileText = (precompileDirective.Values[0] as XamlAstTextNode)?.Text.Trim()
                                 .ToLowerInvariant();
                             if (precompileText == "false")
                                 continue;
                             if (precompileText != "true")
-                                throw new XamlIlParseException("Invalid value for x:Precompile", precompileDirective);
+                                throw new XamlParseException("Invalid value for x:Precompile", precompileDirective);
                         }
                         
-                        var classDirective = initialRoot.Children.OfType<XamlIlAstXmlDirective>()
+                        var classDirective = initialRoot.Children.OfType<XamlAstXmlDirective>()
                             .FirstOrDefault(d => d.Namespace == XamlNamespaces.Xaml2006 && d.Name == "Class");
-                        IXamlIlType classType = null;
+                        IXamlType classType = null;
                         if (classDirective != null)
                         {
-                            if (classDirective.Values.Count != 1 || !(classDirective.Values[0] is XamlIlAstTextNode tn))
+                            if (classDirective.Values.Count != 1 || !(classDirective.Values[0] is XamlAstTextNode tn))
-                                throw new XamlIlParseException("x:Class should have a string value", classDirective);
+                                throw new XamlParseException("x:Class should have a string value", classDirective);
                             classType = typeSystem.TargetAssembly.FindType(tn.Text);
                             if (classType == null)
-                                throw new XamlIlParseException($"Unable to find type `{tn.Text}`", classDirective);
+                                throw new XamlParseException($"Unable to find type `{tn.Text}`", classDirective);
                             compiler.OverrideRootType(parsed,
-                                new XamlIlAstClrTypeReference(classDirective, classType, false));
+                                new XamlAstClrTypeReference(classDirective, classType, false));
                             initialRoot.Children.Remove(classDirective);
                         }
                         
@@ -323,7 +324,7 @@ namespace Avalonia.Build.Tasks
                     catch (Exception e)
                     {
                         int lineNumber = 0, linePosition = 0;
-                        if (e is XamlIlParseException xe)
+                        if (e is XamlParseException xe)
                         {
                             lineNumber = xe.LineNumber;
                             linePosition = xe.LinePosition;

src/Avalonia.Controls/Chrome/CaptionButtons.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Reactive.Disposables;
+using Avalonia.Controls.Primitives;
+
+#nullable enable
+
+namespace Avalonia.Controls.Chrome
+{
+    /// <summary>
+    /// Draws window minimize / maximize / close buttons in a <see cref="TitleBar"/> when managed client decorations are enabled.
+    /// </summary>
+    public class CaptionButtons : TemplatedControl
+    {
+        private CompositeDisposable? _disposables;
+        private Window? _hostWindow;
+
+        public void Attach(Window hostWindow)
+        {
+            if (_disposables == null)
+            {
+                _hostWindow = hostWindow;
+
+                _disposables = new CompositeDisposable
+                {
+                    _hostWindow.GetObservable(Window.WindowStateProperty)
+                    .Subscribe(x =>
+                    {
+                        PseudoClasses.Set(":minimized", x == WindowState.Minimized);
+                        PseudoClasses.Set(":normal", x == WindowState.Normal);
+                        PseudoClasses.Set(":maximized", x == WindowState.Maximized);
+                        PseudoClasses.Set(":fullscreen", x == WindowState.FullScreen);
+                    })
+                };
+            }
+        }
+
+        public void Detach()
+        {
+            if (_disposables != null)
+            {
+                var layer = ChromeOverlayLayer.GetOverlayLayer(_hostWindow);
+
+                layer?.Children.Remove(this);
+
+                _disposables.Dispose();
+                _disposables = null;
+            }
+        }
+
+        protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+        {
+            base.OnApplyTemplate(e);
+
+            var closeButton = e.NameScope.Get<Panel>("PART_CloseButton");
+            var restoreButton = e.NameScope.Get<Panel>("PART_RestoreButton");
+            var minimiseButton = e.NameScope.Get<Panel>("PART_MinimiseButton");
+            var fullScreenButton = e.NameScope.Get<Panel>("PART_FullScreenButton");
+
+            closeButton.PointerReleased += (sender, e) => _hostWindow?.Close();
+
+            restoreButton.PointerReleased += (sender, e) =>
+            {
+                if (_hostWindow != null)
+                {
+                    _hostWindow.WindowState = _hostWindow.WindowState == WindowState.Maximized ? WindowState.Normal : WindowState.Maximized;
+                }
+            };
+
+            minimiseButton.PointerReleased += (sender, e) =>
+            {
+                if (_hostWindow != null)
+                {
+                    _hostWindow.WindowState = WindowState.Minimized;
+                }
+            };
+
+            fullScreenButton.PointerReleased += (sender, e) =>
+            {
+                if (_hostWindow != null)
+                {
+                    _hostWindow.WindowState = _hostWindow.WindowState == WindowState.FullScreen ? WindowState.Normal : WindowState.FullScreen;
+                }
+            };
+        }
+    }
+}

src/Avalonia.Controls/Chrome/TitleBar.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Reactive.Disposables;
+using Avalonia.Controls.Primitives;
+
+#nullable enable
+
+namespace Avalonia.Controls.Chrome
+{
+    /// <summary>
+    /// Draws a titlebar when managed client decorations are enabled.
+    /// </summary>
+    public class TitleBar : TemplatedControl
+    {
+        private CompositeDisposable? _disposables;
+        private readonly Window? _hostWindow;
+        private CaptionButtons? _captionButtons;
+
+        public TitleBar(Window hostWindow)
+        {
+            _hostWindow = hostWindow;
+        }
+
+        public TitleBar()
+        {
+
+        }
+
+        public void Attach()
+        {
+            if (_disposables == null)
+            {
+                var layer = ChromeOverlayLayer.GetOverlayLayer(_hostWindow);
+
+                layer?.Children.Add(this);
+
+                if (_hostWindow != null)
+                {
+                    _disposables = new CompositeDisposable
+                    {
+                        _hostWindow.GetObservable(Window.WindowDecorationMarginProperty)
+                            .Subscribe(x => UpdateSize()),
+
+                        _hostWindow.GetObservable(Window.ExtendClientAreaTitleBarHeightHintProperty)
+                            .Subscribe(x => UpdateSize()),
+
+                        _hostWindow.GetObservable(Window.OffScreenMarginProperty)
+                            .Subscribe(x => UpdateSize()),
+
+                        _hostWindow.GetObservable(Window.WindowStateProperty)
+                            .Subscribe(x =>
+                            {
+                                PseudoClasses.Set(":minimized", x == WindowState.Minimized);
+                                PseudoClasses.Set(":normal", x == WindowState.Normal);
+                                PseudoClasses.Set(":maximized", x == WindowState.Maximized);
+                                PseudoClasses.Set(":fullscreen", x == WindowState.FullScreen);
+                            })
+                    };
+
+                    _captionButtons?.Attach(_hostWindow);
+                }
+
+                UpdateSize();
+            }
+        }
+
+        private void UpdateSize()
+        {
+            if (_hostWindow != null)
+            {
+                Margin = new Thickness(
+                    _hostWindow.OffScreenMargin.Left,
+                    _hostWindow.OffScreenMargin.Top,
+                    _hostWindow.OffScreenMargin.Right,
+                    _hostWindow.OffScreenMargin.Bottom);
+
+                if (_hostWindow.WindowState != WindowState.FullScreen)
+                {
+                    Height = _hostWindow.WindowDecorationMargin.Top;
+
+                    if (_captionButtons != null)
+                    {
+                        _captionButtons.Height = Height;
+                    }
+                }
+            }
+        }
+
+        public void Detach()
+        {
+            if (_disposables != null)
+            {
+                var layer = ChromeOverlayLayer.GetOverlayLayer(_hostWindow);
+
+                layer?.Children.Remove(this);
+
+                _disposables.Dispose();
+                _disposables = null;
+
+                _captionButtons?.Detach();
+            }
+        }
+
+        protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+        {
+            base.OnApplyTemplate(e);
+
+            _captionButtons = e.NameScope.Get<CaptionButtons>("PART_CaptionButtons");
+
+            if (_hostWindow != null)
+            {
+                _captionButtons.Attach(_hostWindow);
+            }
+
+            UpdateSize();
+        }
+    }
+}

src/Avalonia.Controls/Platform/ExtendClientAreaChromeHints.cs

@@ -0,0 +1,38 @@
+using System;
+
+namespace Avalonia.Platform
+{
+    /// <summary>
+    /// Hint for Window Chrome when ClientArea is Extended.
+    /// </summary>
+    [Flags]
+    public enum ExtendClientAreaChromeHints
+    {
+        /// <summary>
+        /// The will be no chrome at all.
+        /// </summary>
+        NoChrome,
+
+        /// <summary>
+        /// The default for the platform.
+        /// </summary>
+        Default = SystemChrome,
+
+        /// <summary>
+        /// Use SystemChrome
+        /// </summary>
+        SystemChrome = 0x01,
+
+        /// <summary>
+        /// Use system chrome where possible. OSX system chrome is used, Windows managed chrome is used.
+        /// This is because Windows Chrome can not be shown ontop of user content.
+        /// </summary>
+        PreferSystemChrome = 0x02,
+
+        /// <summary>
+        /// On OSX the titlebar is the thicker toolbar kind. Causes traffic lights to be positioned
+        /// slightly lower than normal.
+        /// </summary>
+        OSXThickTitleBar = 0x08,               
+    }
+}

src/Avalonia.Controls/Platform/IWindowImpl.cs

@@ -68,6 +68,34 @@ namespace Avalonia.Platform
         /// </summary>
         Func<bool> Closing { get; set; }
 
+        /// <summary>
+        /// Gets a value to indicate if the platform was able to extend client area to non-client area.
+        /// </summary>
+        bool IsClientAreaExtendedToDecorations { get; }
+
+        /// <summary>
+        /// Gets or Sets an action that is called whenever one of the extend client area properties changed.
+        /// </summary>
+        Action<bool> ExtendClientAreaToDecorationsChanged { get; set; }
+
+        /// <summary>
+        /// Gets a flag that indicates if Managed decorations i.e. caption buttons are required.
+        /// This property is used when <see cref="IsClientAreaExtendedToDecorations"/> is set.
+        /// </summary>
+        bool NeedsManagedDecorations { get; }
+
+        /// <summary>
+        /// Gets a thickness that describes the amount each side of the non-client area extends into the client area.
+        /// It includes the titlebar.
+        /// </summary>
+        Thickness ExtendedMargins { get; }
+
+        /// <summary>
+        /// Gets a thickness that describes the margin around the window that is offscreen.
+        /// This may happen when a window is maximized and <see cref="IsClientAreaExtendedToDecorations"/> is set.
+        /// </summary>
+        Thickness OffScreenMargin { get; }
+
         /// <summary>
         /// Starts moving a window with left button being held. Should be called from left mouse button press event handler.
         /// </summary>
@@ -94,5 +122,23 @@ namespace Avalonia.Platform
         /// </summary>
         /// 
         void SetMinMaxSize(Size minSize, Size maxSize);
+
+        /// <summary>
+        /// Sets if the ClientArea is extended into the non-client area.
+        /// </summary>
+        /// <param name="extendIntoClientAreaHint">true to enable, false to disable</param>
+        void SetExtendClientAreaToDecorationsHint(bool extendIntoClientAreaHint);        
+
+        /// <summary>
+        /// Sets hints that configure how the client area extends. 
+        /// </summary>
+        /// <param name="hints"></param>
+        void SetExtendClientAreaChromeHints(ExtendClientAreaChromeHints hints);
+
+        /// <summary>
+        /// Sets how big the non-client titlebar area should be.
+        /// </summary>
+        /// <param name="titleBarHeight">-1 for platform default, otherwise the height in DIPs.</param>
+        void SetExtendClientAreaTitleBarHeightHint(double titleBarHeight);       
     }
 }

src/Avalonia.Controls/Primitives/ChromeOverlayLayer.cs

@@ -0,0 +1,29 @@
+using System.Linq;
+using Avalonia.Rendering;
+using Avalonia.VisualTree;
+
+#nullable enable
+
+namespace Avalonia.Controls.Primitives
+{
+    public class ChromeOverlayLayer : Panel, ICustomSimpleHitTest
+    {
+        public static ChromeOverlayLayer? GetOverlayLayer(IVisual visual)
+        {
+            foreach (var v in visual.GetVisualAncestors())
+                if (v is VisualLayerManager vlm)
+                    if (vlm.OverlayLayer != null)
+                        return vlm.ChromeOverlayLayer;
+
+            if (visual is TopLevel tl)
+            {
+                var layers = tl.GetVisualDescendants().OfType<VisualLayerManager>().FirstOrDefault();
+                return layers?.ChromeOverlayLayer;
+            }
+
+            return null;
+        }
+
+        public bool HitTest(Point point) => Children.HitTestCustom(point);
+    }
+}

src/Avalonia.Controls/Primitives/VisualLayerManager.cs

@@ -6,7 +6,9 @@ namespace Avalonia.Controls.Primitives
     public class VisualLayerManager : Decorator
     {
         private const int AdornerZIndex = int.MaxValue - 100;
-        private const int OverlayZIndex = int.MaxValue - 99;
+        private const int ChromeZIndex = int.MaxValue - 99;
+        private const int OverlayZIndex = int.MaxValue - 98;
+
         private ILogicalRoot _logicalRoot;
         private readonly List<Control> _layers = new List<Control>();
         
@@ -24,6 +26,17 @@ namespace Avalonia.Controls.Primitives
             }
         }
 
+        public ChromeOverlayLayer ChromeOverlayLayer
+        {
+            get
+            {
+                var rv = FindLayer<ChromeOverlayLayer>();
+                if (rv == null)
+                    AddLayer(rv = new ChromeOverlayLayer(), ChromeZIndex);
+                return rv;
+            }
+        }
+
         public OverlayLayer OverlayLayer
         {
             get

src/Avalonia.Controls/Properties/AssemblyInfo.cs

@@ -13,3 +13,4 @@ using Avalonia.Metadata;
 [assembly: XmlnsDefinition("https://github.com/avaloniaui", "Avalonia.Controls.Shapes")]
 [assembly: XmlnsDefinition("https://github.com/avaloniaui", "Avalonia.Controls.Templates")]
 [assembly: XmlnsDefinition("https://github.com/avaloniaui", "Avalonia.Controls.Notifications")]
+[assembly: XmlnsDefinition("https://github.com/avaloniaui", "Avalonia.Controls.Chrome")]

src/Avalonia.Controls/TopLevel.cs

@@ -405,7 +405,7 @@ namespace Avalonia.Controls
                 }
                 else
                 {
-                    _transparencyFallbackBorder.Background = Brushes.Transparent;
+                    _transparencyFallbackBorder.Background = null;
                 }
             }
 

src/Avalonia.Controls/Window.cs

@@ -4,6 +4,7 @@ using System.ComponentModel;
 using System.Linq;
 using System.Reactive.Linq;
 using System.Threading.Tasks;
+using Avalonia.Controls.Chrome;
 using Avalonia.Controls.Platform;
 using Avalonia.Data;
 using Avalonia.Input;
@@ -69,7 +70,11 @@ namespace Avalonia.Controls
     /// </summary>
     public class Window : WindowBase, IStyleable, IFocusScope, ILayoutRoot
     {
-        private readonly List<(Window child, bool isDialog)> _children = new List<(Window, bool)>();
+        private readonly List<(Window child, bool isDialog)> _children = new List<(Window, bool)>();        
+        private TitleBar _managedTitleBar;
+        private bool _isExtendedIntoWindowDecorations;
+        private Thickness _windowDecorationMargin;
+        private Thickness _offScreenMargin;
 
         /// <summary>
         /// Defines the <see cref="SizeToContent"/> property.
@@ -87,6 +92,37 @@ namespace Avalonia.Controls
                 o => o.HasSystemDecorations,
                 (o, v) => o.HasSystemDecorations = v);
 
+        /// <summary>
+        /// Defines the <see cref="ExtendClientAreaToDecorationsHint"/> property.
+        /// </summary>
+        public static readonly StyledProperty<bool> ExtendClientAreaToDecorationsHintProperty =
+            AvaloniaProperty.Register<Window, bool>(nameof(ExtendClientAreaToDecorationsHint), false);
+
+        public static readonly StyledProperty<ExtendClientAreaChromeHints> ExtendClientAreaChromeHintsProperty =
+            AvaloniaProperty.Register<Window, ExtendClientAreaChromeHints>(nameof(ExtendClientAreaChromeHints), ExtendClientAreaChromeHints.Default);
+
+        public static readonly StyledProperty<double> ExtendClientAreaTitleBarHeightHintProperty =
+            AvaloniaProperty.Register<Window, double>(nameof(ExtendClientAreaTitleBarHeightHint), -1);
+
+        /// <summary>
+        /// Defines the <see cref="IsExtendedIntoWindowDecorations"/> property.
+        /// </summary>
+        public static readonly DirectProperty<Window, bool> IsExtendedIntoWindowDecorationsProperty =
+            AvaloniaProperty.RegisterDirect<Window, bool>(nameof(IsExtendedIntoWindowDecorations),
+                o => o.IsExtendedIntoWindowDecorations,
+                unsetValue: false);
+
+        /// <summary>
+        /// Defines the <see cref="WindowDecorationMargin"/> property.
+        /// </summary>
+        public static readonly DirectProperty<Window, Thickness> WindowDecorationMarginProperty =
+            AvaloniaProperty.RegisterDirect<Window, Thickness>(nameof(WindowDecorationMargin),
+                o => o.WindowDecorationMargin);
+
+        public static readonly DirectProperty<Window, Thickness> OffScreenMarginProperty =
+            AvaloniaProperty.RegisterDirect<Window, Thickness>(nameof(OffScreenMargin),
+                o => o.OffScreenMargin);
+
         /// <summary>
         /// Defines the <see cref="SystemDecorations"/> property.
         /// </summary>
@@ -164,6 +200,21 @@ namespace Avalonia.Controls
             WindowStateProperty.Changed.AddClassHandler<Window>(
                 (w, e) => { if (w.PlatformImpl != null) w.PlatformImpl.WindowState = (WindowState)e.NewValue; });
 
+            ExtendClientAreaToDecorationsHintProperty.Changed.AddClassHandler<Window>(
+                (w, e) => { if (w.PlatformImpl != null) w.PlatformImpl.SetExtendClientAreaToDecorationsHint((bool)e.NewValue); });
+
+            ExtendClientAreaChromeHintsProperty.Changed.AddClassHandler<Window>(
+                (w, e) =>
+                {
+                    if (w.PlatformImpl != null)
+                    {
+                        w.PlatformImpl.SetExtendClientAreaChromeHints((ExtendClientAreaChromeHints)e.NewValue);
+                    }
+                });
+
+            ExtendClientAreaTitleBarHeightHintProperty.Changed.AddClassHandler<Window>(
+                (w, e) => { if (w.PlatformImpl != null) w.PlatformImpl.SetExtendClientAreaTitleBarHeightHint((double)e.NewValue); });
+
             MinWidthProperty.Changed.AddClassHandler<Window>((w, e) => w.PlatformImpl?.SetMinMaxSize(new Size((double)e.NewValue, w.MinHeight), new Size(w.MaxWidth, w.MaxHeight)));
             MinHeightProperty.Changed.AddClassHandler<Window>((w, e) => w.PlatformImpl?.SetMinMaxSize(new Size(w.MinWidth, (double)e.NewValue), new Size(w.MaxWidth, w.MaxHeight)));
             MaxWidthProperty.Changed.AddClassHandler<Window>((w, e) => w.PlatformImpl?.SetMinMaxSize(new Size(w.MinWidth, w.MinHeight), new Size((double)e.NewValue, w.MaxHeight)));
@@ -189,6 +240,7 @@ namespace Avalonia.Controls
             impl.GotInputWhenDisabled = OnGotInputWhenDisabled;
             impl.WindowStateChanged = HandleWindowStateChanged;
             _maxPlatformClientSize = PlatformImpl?.MaxAutoSizeHint ?? default(Size);
+            impl.ExtendClientAreaToDecorationsChanged = ExtendClientAreaToDecorationsChanged;            
             this.GetObservable(ClientSizeProperty).Skip(1).Subscribe(x => PlatformImpl?.Resize(x));
 
             PlatformImpl?.ShowTaskbarIcon(ShowInTaskbar);
@@ -237,6 +289,66 @@ namespace Avalonia.Controls
             }
         }
 
+        /// <summary>
+        /// Gets or sets if the ClientArea is Extended into the Window Decorations (chrome or border).
+        /// </summary>
+        public bool ExtendClientAreaToDecorationsHint
+        {
+            get { return GetValue(ExtendClientAreaToDecorationsHintProperty); }
+            set { SetValue(ExtendClientAreaToDecorationsHintProperty, value); }
+        }
+
+        /// <summary>
+        /// Gets or Sets the <see cref="Avalonia.Platform.ExtendClientAreaChromeHints"/> that control
+        /// how the chrome looks when the client area is extended.
+        /// </summary>
+        public ExtendClientAreaChromeHints ExtendClientAreaChromeHints
+        {
+            get => GetValue(ExtendClientAreaChromeHintsProperty);
+            set => SetValue(ExtendClientAreaChromeHintsProperty, value);
+        }
+
+        /// <summary>
+        /// Gets or Sets the TitlebarHeightHint for when the client area is extended.
+        /// A value of -1 will cause the titlebar to be auto sized to the OS default.
+        /// Any other positive value will cause the titlebar to assume that height.
+        /// </summary>
+        public double ExtendClientAreaTitleBarHeightHint
+        {
+            get => GetValue(ExtendClientAreaTitleBarHeightHintProperty);
+            set => SetValue(ExtendClientAreaTitleBarHeightHintProperty, value);
+        }        
+
+        /// <summary>
+        /// Gets if the ClientArea is Extended into the Window Decorations.
+        /// </summary>
+        public bool IsExtendedIntoWindowDecorations
+        {
+            get => _isExtendedIntoWindowDecorations;
+            private set => SetAndRaise(IsExtendedIntoWindowDecorationsProperty, ref _isExtendedIntoWindowDecorations, value);
+        }        
+
+        /// <summary>
+        /// Gets the WindowDecorationMargin.
+        /// This tells you the thickness around the window that is used by borders and the titlebar.
+        /// </summary>
+        public Thickness WindowDecorationMargin
+        {
+            get => _windowDecorationMargin;
+            private set => SetAndRaise(WindowDecorationMarginProperty, ref _windowDecorationMargin, value);
+        }        
+
+        /// <summary>
+        /// Gets the window margin that is hidden off the screen area.
+        /// This is generally only the case on Windows when in Maximized where the window border
+        /// is hidden off the screen. This Margin may be used to ensure user content doesnt overlap this space.
+        /// </summary>
+        public Thickness OffScreenMargin
+        {
+            get => _offScreenMargin;
+            private set => SetAndRaise(OffScreenMarginProperty, ref _offScreenMargin, value);
+        }
+
         /// <summary>
         /// Sets the system decorations (title bar, border, etc)
         /// </summary>
@@ -435,6 +547,27 @@ namespace Avalonia.Controls
             }
         }
 
+        protected virtual void ExtendClientAreaToDecorationsChanged(bool isExtended)
+        {
+            IsExtendedIntoWindowDecorations = isExtended;
+            WindowDecorationMargin = PlatformImpl.ExtendedMargins;
+            OffScreenMargin = PlatformImpl.OffScreenMargin;
+
+            if (PlatformImpl.NeedsManagedDecorations)
+            {
+                if (_managedTitleBar == null)
+                {
+                    _managedTitleBar = new TitleBar(this);
+                    _managedTitleBar.Attach();
+                }                
+            }
+            else
+            {
+                _managedTitleBar?.Detach();
+                _managedTitleBar = null;
+            }
+        }
+
         /// <summary>
         /// Hides the window but does not close it.
         /// </summary>

src/Avalonia.DesignerSupport/Remote/PreviewerWindowImpl.cs

@@ -78,7 +78,17 @@ namespace Avalonia.DesignerSupport.Remote
         }
 
         public IScreenImpl Screen { get; } = new ScreenStub();
-        public Action GotInputWhenDisabled { get; set; }
+        public Action GotInputWhenDisabled { get; set; }        
+        
+        public Action<bool> ExtendClientAreaToDecorationsChanged { get; set; }
+
+        public Thickness ExtendedMargins { get; } = new Thickness();
+
+        public bool IsClientAreaExtendedToDecorations { get; }
+
+        public Thickness OffScreenMargin { get; } = new Thickness();
+
+        public bool NeedsManagedDecorations => false;
 
         public void Activate()
         {
@@ -119,5 +129,17 @@ namespace Avalonia.DesignerSupport.Remote
         public void SetEnabled(bool enable)
         {
         }
+
+        public void SetExtendClientAreaToDecorationsHint(bool extendIntoClientAreaHint)
+        {            
+        }
+
+        public void SetExtendClientAreaChromeHints(ExtendClientAreaChromeHints hints)
+        {            
+        }
+
+        public void SetExtendClientAreaTitleBarHeightHint(double titleBarHeight)
+        {            
+        }
     }
 }

src/Avalonia.DesignerSupport/Remote/Stubs.cs

@@ -38,7 +38,13 @@ namespace Avalonia.DesignerSupport.Remote
         public WindowState WindowState { get; set; }
         public Action<WindowState> WindowStateChanged { get; set; }
 
-        public Action<WindowTransparencyLevel> TransparencyLevelChanged { get; set; }
+        public Action<WindowTransparencyLevel> TransparencyLevelChanged { get; set; }        
+
+        public Action<bool> ExtendClientAreaToDecorationsChanged { get; set; }
+
+        public Thickness ExtendedMargins { get; } = new Thickness();
+
+        public Thickness OffScreenMargin { get; } = new Thickness();
 
         public WindowStub(IWindowImpl parent = null)
         {
@@ -141,6 +147,18 @@ namespace Avalonia.DesignerSupport.Remote
         {
         }
 
+        public void SetExtendClientAreaToDecorationsHint(bool extendIntoClientAreaHint)
+        {
+        }
+
+        public void SetExtendClientAreaChromeHints(ExtendClientAreaChromeHints hints)
+        {
+        }
+
+        public void SetExtendClientAreaTitleBarHeightHint(double titleBarHeight)
+        {
+        }
+
         public IPopupPositioner PopupPositioner { get; }
 
         public Action GotInputWhenDisabled { get; set; }
@@ -152,6 +170,10 @@ namespace Avalonia.DesignerSupport.Remote
         }
 
         public WindowTransparencyLevel TransparencyLevel { get; private set; }
+
+        public bool IsClientAreaExtendedToDecorations { get; }
+
+        public bool NeedsManagedDecorations => false;
     }
 
     class ClipboardStub : IClipboard

src/Avalonia.Native/WindowImpl.cs

@@ -1,6 +1,8 @@
 using System;
 using Avalonia.Controls;
 using Avalonia.Controls.Platform;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
 using Avalonia.Native.Interop;
 using Avalonia.OpenGL;
 using Avalonia.Platform;
@@ -14,6 +16,8 @@ namespace Avalonia.Native
         private readonly AvaloniaNativePlatformOptions _opts;
         private readonly GlPlatformFeature _glFeature;
         IAvnWindow _native;
+        private double _extendTitleBarHeight = -1;
+
         internal WindowImpl(IAvaloniaNativeFactory factory, AvaloniaNativePlatformOptions opts,
             GlPlatformFeature glFeature) : base(opts, glFeature)
         {
@@ -50,6 +54,8 @@ namespace Avalonia.Native
 
             void IAvnWindowEvents.WindowStateChanged(AvnWindowState state)
             {
+                _parent.InvalidateExtendedMargins();
+
                 _parent.WindowStateChanged?.Invoke((WindowState)state);
             }
 
@@ -96,7 +102,85 @@ namespace Avalonia.Native
             }
         }
 
-        public Action<WindowState> WindowStateChanged { get; set; }
+        public Action<WindowState> WindowStateChanged { get; set; }        
+
+        public Action<bool> ExtendClientAreaToDecorationsChanged { get; set; }
+
+        public Thickness ExtendedMargins { get; private set; }
+
+        public Thickness OffScreenMargin { get; } = new Thickness();
+
+        private bool _isExtended;
+        public bool IsClientAreaExtendedToDecorations => _isExtended;
+
+        protected override bool ChromeHitTest (RawPointerEventArgs e)
+        {
+            if(_isExtended)
+            {
+                if(e.Type == RawPointerEventType.LeftButtonDown)
+                {
+                    var visual = (_inputRoot as Window).Renderer.HitTestFirst(e.Position, _inputRoot as Window, x =>
+                            {
+                                if (x is IInputElement ie && !ie.IsHitTestVisible)
+                                {
+                                    return false;
+                                }
+                                return true;
+                            });
+
+                    if(visual == null)
+                    {
+                        _native.BeginMoveDrag();
+                    }
+                }
+            }
+
+            return false;
+        }
+        
+        private void InvalidateExtendedMargins()
+        {
+            if (WindowState ==  WindowState.FullScreen)
+            {
+                ExtendedMargins = new Thickness();
+            }
+            else
+            {
+                ExtendedMargins = _isExtended ? new Thickness(0, _extendTitleBarHeight == -1 ? _native.GetExtendTitleBarHeight() : _extendTitleBarHeight, 0, 0) : new Thickness();
+            }
+
+            ExtendClientAreaToDecorationsChanged?.Invoke(_isExtended);
+        }
+
+        /// <inheritdoc/>
+        public void SetExtendClientAreaToDecorationsHint(bool extendIntoClientAreaHint)
+        {
+            _isExtended = extendIntoClientAreaHint;
+
+            _native.SetExtendClientArea(extendIntoClientAreaHint);
+
+            InvalidateExtendedMargins();
+        }
+
+        /// <inheritdoc/>
+        public void SetExtendClientAreaChromeHints(ExtendClientAreaChromeHints hints)
+        {   
+            _native.SetExtendClientAreaHints ((AvnExtendClientAreaChromeHints)hints);
+        }
+
+        /// <inheritdoc/>
+        public void SetExtendClientAreaTitleBarHeightHint(double titleBarHeight)
+        {
+            _extendTitleBarHeight = titleBarHeight;
+            _native.SetExtendTitleBarHeight(titleBarHeight);
+
+            ExtendedMargins = _isExtended ? new Thickness(0, titleBarHeight == -1 ? _native.GetExtendTitleBarHeight() : titleBarHeight, 0, 0) : new Thickness();
+
+            ExtendClientAreaToDecorationsChanged?.Invoke(_isExtended);
+        }
+
+        /// <inheritdoc/>
+        public bool NeedsManagedDecorations => false;
 
         public void ShowTaskbarIcon(bool value)
         {

src/Avalonia.Native/WindowImplBase.cs

@@ -46,7 +46,7 @@ namespace Avalonia.Native
     public abstract class WindowBaseImpl : IWindowBaseImpl,
         IFramebufferPlatformSurface, ITopLevelImplWithNativeControlHost
     {
-        IInputRoot _inputRoot;
+        protected IInputRoot _inputRoot;
         IAvnWindowBase _native;
         private object _syncRoot = new object();
         private bool _deferredRendering = false;
@@ -266,6 +266,11 @@ namespace Avalonia.Native
             return args.Handled;
         }
 
+        protected virtual bool ChromeHitTest(RawPointerEventArgs e)
+        {
+            return false;
+        }
+
         public void RawMouseEvent(AvnRawMouseEventType type, uint timeStamp, AvnInputModifiers modifiers, AvnPoint point, AvnVector delta)
         {
             Dispatcher.UIThread.RunJobs(DispatcherPriority.Input + 1);
@@ -277,7 +282,12 @@ namespace Avalonia.Native
                     break;
 
                 default:
-                    Input?.Invoke(new RawPointerEventArgs(_mouse, timeStamp, _inputRoot, (RawPointerEventType)type, point.ToAvaloniaPoint(), (RawInputModifiers)modifiers));
+                    var e = new RawPointerEventArgs(_mouse, timeStamp, _inputRoot, (RawPointerEventType)type, point.ToAvaloniaPoint(), (RawInputModifiers)modifiers);
+                    
+                    if(!ChromeHitTest(e))
+                    {
+                        Input?.Invoke(e);
+                    }
                     break;
             }
         }

src/Avalonia.Themes.Default/CaptionButtons.xaml

@@ -0,0 +1,69 @@
+<Styles xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <Style Selector="CaptionButtons">
+    <Setter Property="Foreground" Value="{DynamicResource ThemeForegroundBrush}"/>    
+    <Setter Property="MaxHeight" Value="30" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <StackPanel Spacing="2" Margin="0 0 7 0" VerticalAlignment="Stretch" TextBlock.FontSize="10" Orientation="Horizontal">
+          <StackPanel.Styles>
+            <Style Selector="Panel">
+              <Setter Property="Width" Value="45" />
+              <Setter Property="Background" Value="Transparent" />
+            </Style>
+            <Style Selector="Panel:pointerover">
+              <Setter Property="Background" Value="#7F7f7f7f" />
+            </Style>
+            <Style Selector="Panel#PART_CloseButton:pointerover">
+              <Setter Property="Background" Value="#7FFF0000" />
+            </Style>
+            <Style Selector="Viewbox">
+              <Setter Property="Width" Value="11" />
+              <Setter Property="Margin" Value="2" />
+            </Style>
+          </StackPanel.Styles>
+          <Panel x:Name="PART_FullScreenButton">
+            <Viewbox>
+              <Path Stretch="UniformToFill" Fill="{TemplateBinding Foreground}" />
+            </Viewbox>
+          </Panel>
+
+          <Panel x:Name="PART_MinimiseButton">
+            <Viewbox>
+              <Path Stretch="UniformToFill" Fill="{TemplateBinding Foreground}" Data="M2048 1229v-205h-2048v205h2048z" />
+            </Viewbox>
+          </Panel>
+
+          <Panel x:Name="PART_RestoreButton">
+            <Viewbox>
+              <Viewbox.RenderTransform>
+                <RotateTransform Angle="-90" />
+              </Viewbox.RenderTransform>
+              <Path Stretch="UniformToFill" Fill="{TemplateBinding Foreground}"/>
+            </Viewbox>
+          </Panel>
+
+          <Panel x:Name="PART_CloseButton">
+            <Viewbox>
+              <Path Stretch="UniformToFill" Fill="{TemplateBinding Foreground}" Data="M1169 1024l879 -879l-145 -145l-879 879l-879 -879l-145 145l879 879l-879 879l145 145l879 -879l879 879l145 -145z" />
+            </Viewbox>
+          </Panel>
+        </StackPanel>
+      </ControlTemplate>
+    </Setter>
+  </Style>
+  <Style Selector="CaptionButtons Panel#PART_RestoreButton Path">
+    <Setter Property="Data" Value="M2048 2048v-2048h-2048v2048h2048zM1843 1843h-1638v-1638h1638v1638z" />
+  </Style>
+  <Style Selector="CaptionButtons:maximized Panel#PART_RestoreButton Path">
+    <Setter Property="Data" Value="M2048 410h-410v-410h-1638v1638h410v410h1638v-1638zM1434 1434h-1229v-1229h1229v1229zM1843 1843h-1229v-205h1024v-1024h205v1229z" />
+  </Style>
+  <Style Selector="CaptionButtons Panel#PART_FullScreenButton Path">
+    <Setter Property="Data" Value="M2048 2048v-819h-205v469l-1493 -1493h469v-205h-819v819h205v-469l1493 1493h-469v205h819z" />
+  </Style>
+  <Style Selector="CaptionButtons:fullscreen Panel#PART_FullScreenButton Path">
+    <Setter Property="Data" Value="M205 1024h819v-819h-205v469l-674 -674l-145 145l674 674h-469v205zM1374 1229h469v-205h-819v819h205v-469l674 674l145 -145z" />
+  </Style>
+  <Style Selector="CaptionButtons:fullscreen Panel#PART_RestoreButton, CaptionButtons:fullscreen Panel#PART_MinimiseButton">
+    <Setter Property="IsVisible" Value="False" />
+  </Style>
+ </Styles>

src/Avalonia.Themes.Default/DefaultTheme.xaml

@@ -9,6 +9,7 @@
   <StyleInclude Source="resm:Avalonia.Themes.Default.Button.xaml?assembly=Avalonia.Themes.Default"/>
   <StyleInclude Source="resm:Avalonia.Themes.Default.Carousel.xaml?assembly=Avalonia.Themes.Default"/>
   <StyleInclude Source="resm:Avalonia.Themes.Default.CheckBox.xaml?assembly=Avalonia.Themes.Default"/>
+  <StyleInclude Source="resm:Avalonia.Themes.Default.CaptionButtons.xaml?assembly=Avalonia.Themes.Default"/>
   <StyleInclude Source="resm:Avalonia.Themes.Default.ComboBox.xaml?assembly=Avalonia.Themes.Default"/>
   <StyleInclude Source="resm:Avalonia.Themes.Default.ComboBoxItem.xaml?assembly=Avalonia.Themes.Default"/>
   <StyleInclude Source="resm:Avalonia.Themes.Default.ContentControl.xaml?assembly=Avalonia.Themes.Default"/>

src/Avalonia.Themes.Default/TitleBar.xaml

@@ -0,0 +1,53 @@
+<Styles xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <Design.PreviewWith>
+    <Border>
+      <TitleBar Background="SkyBlue" Height="30" Width="300" Foreground="Black" />
+    </Border>
+  </Design.PreviewWith>
+  <Style Selector="TitleBar">
+    <Setter Property="Foreground" Value="{DynamicResource SystemControlForegroundBaseHighBrush}"/>    
+    <Setter Property="VerticalAlignment" Value="Top" />
+    <Setter Property="HorizontalAlignment" Value="Stretch" />
+    <Setter Property="Background" Value="Transparent" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Panel HorizontalAlignment="{TemplateBinding HorizontalAlignment}" VerticalAlignment="Stretch">
+          <Panel x:Name="PART_MouseTracker" Height="1" VerticalAlignment="Top" />
+          <Panel x:Name="PART_Container">
+            <Border x:Name="PART_Background" Background="{TemplateBinding Background}" />
+            <CaptionButtons x:Name="PART_CaptionButtons" VerticalAlignment="Top" HorizontalAlignment="Right" Foreground="{TemplateBinding Foreground}" MaxHeight="30" />
+          </Panel>
+        </Panel>
+      </ControlTemplate>
+    </Setter>
+  </Style>
+
+  <Style Selector="TitleBar:fullscreen">
+    <Setter Property="Background" Value="{DynamicResource SystemAccentColor}" />
+  </Style>
+
+  <Style Selector="TitleBar /template/ Border#PART_Background">
+    <Setter Property="IsHitTestVisible" Value="False" />
+  </Style>
+
+  <Style Selector="TitleBar:fullscreen /template/ Border#PART_Background">
+    <Setter Property="IsHitTestVisible" Value="True" />
+  </Style>
+
+  <Style Selector="TitleBar:fullscreen /template/ Panel#PART_MouseTracker">
+    <Setter Property="Background" Value="Transparent" />
+  </Style>
+
+  <Style Selector="TitleBar:fullscreen /template/ Panel#PART_Container">
+    <Setter Property="RenderTransform" Value="translateY(-30px)" />
+    <Setter Property="Transitions">
+      <Transitions>
+        <TransformOperationsTransition Property="RenderTransform" Duration="0:0:.25" />
+      </Transitions>
+    </Setter>
+  </Style>
+
+  <Style Selector="TitleBar:fullscreen:pointerover /template/ Panel#PART_Container">
+    <Setter Property="RenderTransform" Value="none" />
+  </Style>
+</Styles>

src/Avalonia.Themes.Default/Window.xaml

@@ -5,7 +5,9 @@
   <Setter Property="Template">
     <ControlTemplate>
       <Panel>
-        <Border Name="PART_TransparencyFallback" IsHitTestVisible="False" />
+        <Panel IsHitTestVisible="False" Margin="{TemplateBinding OffScreenMargin}">
+          <Border Name="PART_TransparencyFallback" IsHitTestVisible="False" />
+        </Panel>
         <Border Background="{TemplateBinding Background}">
           <VisualLayerManager>
             <ContentPresenter Name="PART_ContentPresenter"

src/Avalonia.Themes.Fluent/CaptionButtons.xaml

@@ -0,0 +1,68 @@
+<Styles xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <Style Selector="CaptionButtons">    
+    <Setter Property="MaxHeight" Value="30" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <StackPanel Spacing="2" Margin="0 0 7 0" VerticalAlignment="Stretch" TextBlock.FontSize="10" Orientation="Horizontal">
+          <StackPanel.Styles>
+            <Style Selector="Panel">
+              <Setter Property="Width" Value="45" />
+              <Setter Property="Background" Value="Transparent" />
+            </Style>
+            <Style Selector="Panel:pointerover">
+              <Setter Property="Background" Value="#7F7f7f7f" />
+            </Style>
+            <Style Selector="Panel#PART_CloseButton:pointerover">
+              <Setter Property="Background" Value="#7FFF0000" />
+            </Style>
+            <Style Selector="Viewbox">
+              <Setter Property="Width" Value="11" />
+              <Setter Property="Margin" Value="2" />
+            </Style>
+          </StackPanel.Styles>
+          <Panel x:Name="PART_FullScreenButton">
+            <Viewbox>
+              <Path Stretch="UniformToFill" Fill="{TemplateBinding Foreground}" />
+            </Viewbox>
+          </Panel>
+
+          <Panel x:Name="PART_MinimiseButton">
+            <Viewbox>
+              <Path Stretch="UniformToFill" Fill="{TemplateBinding Foreground}" Data="M2048 1229v-205h-2048v205h2048z" />
+            </Viewbox>
+          </Panel>
+
+          <Panel x:Name="PART_RestoreButton">
+            <Viewbox>
+              <Viewbox.RenderTransform>
+                <RotateTransform Angle="-90" />
+              </Viewbox.RenderTransform>
+              <Path Stretch="UniformToFill" Fill="{TemplateBinding Foreground}"/>
+            </Viewbox>
+          </Panel>
+
+          <Panel x:Name="PART_CloseButton">
+            <Viewbox>
+              <Path Stretch="UniformToFill" Fill="{TemplateBinding Foreground}" Data="M1169 1024l879 -879l-145 -145l-879 879l-879 -879l-145 145l879 879l-879 879l145 145l879 -879l879 879l145 -145z" />
+            </Viewbox>
+          </Panel>
+        </StackPanel>
+      </ControlTemplate>
+    </Setter>
+  </Style>
+  <Style Selector="CaptionButtons Panel#PART_RestoreButton Path">
+    <Setter Property="Data" Value="M2048 2048v-2048h-2048v2048h2048zM1843 1843h-1638v-1638h1638v1638z" />
+  </Style>
+  <Style Selector="CaptionButtons:maximized Panel#PART_RestoreButton Path">
+    <Setter Property="Data" Value="M2048 410h-410v-410h-1638v1638h410v410h1638v-1638zM1434 1434h-1229v-1229h1229v1229zM1843 1843h-1229v-205h1024v-1024h205v1229z" />
+  </Style>
+  <Style Selector="CaptionButtons Panel#PART_FullScreenButton Path">
+    <Setter Property="Data" Value="M2048 2048v-819h-205v469l-1493 -1493h469v-205h-819v819h205v-469l1493 1493h-469v205h819z" />
+  </Style>
+  <Style Selector="CaptionButtons:fullscreen Panel#PART_FullScreenButton Path">
+    <Setter Property="Data" Value="M205 1024h819v-819h-205v469l-674 -674l-145 145l674 674h-469v205zM1374 1229h469v-205h-819v819h205v-469l674 674l145 -145z" />
+  </Style>
+  <Style Selector="CaptionButtons:fullscreen Panel#PART_RestoreButton, CaptionButtons:fullscreen Panel#PART_MinimiseButton">
+    <Setter Property="IsVisible" Value="False" />
+  </Style>
+ </Styles>

src/Avalonia.Themes.Fluent/FluentTheme.xaml

@@ -7,7 +7,8 @@
 
   <StyleInclude Source="resm:Avalonia.Themes.Fluent.FocusAdorner.xaml?assembly=Avalonia.Themes.Fluent"/>
   <StyleInclude Source="resm:Avalonia.Themes.Fluent.Button.xaml?assembly=Avalonia.Themes.Fluent"/>
-  <StyleInclude Source="resm:Avalonia.Themes.Fluent.Carousel.xaml?assembly=Avalonia.Themes.Fluent"/>
+  <StyleInclude Source="resm:Avalonia.Themes.Fluent.CaptionButtons.xaml?assembly=Avalonia.Themes.Fluent"/>
+  <StyleInclude Source="resm:Avalonia.Themes.Fluent.Carousel.xaml?assembly=Avalonia.Themes.Fluent"/>  
   <StyleInclude Source="resm:Avalonia.Themes.Fluent.CheckBox.xaml?assembly=Avalonia.Themes.Fluent"/>
   <StyleInclude Source="resm:Avalonia.Themes.Fluent.ComboBox.xaml?assembly=Avalonia.Themes.Fluent"/>
   <StyleInclude Source="resm:Avalonia.Themes.Fluent.ComboBoxItem.xaml?assembly=Avalonia.Themes.Fluent"/>
@@ -36,6 +37,7 @@
   <StyleInclude Source="resm:Avalonia.Themes.Fluent.TextBox.xaml?assembly=Avalonia.Themes.Fluent"/>
   <StyleInclude Source="resm:Avalonia.Themes.Fluent.ToggleButton.xaml?assembly=Avalonia.Themes.Fluent"/>
   <StyleInclude Source="resm:Avalonia.Themes.Fluent.Expander.xaml?assembly=Avalonia.Themes.Fluent"/>
+  <StyleInclude Source="resm:Avalonia.Themes.Fluent.TitleBar.xaml?assembly=Avalonia.Themes.Fluent"/>
   <StyleInclude Source="resm:Avalonia.Themes.Fluent.TreeView.xaml?assembly=Avalonia.Themes.Fluent"/>
   <StyleInclude Source="resm:Avalonia.Themes.Fluent.TreeViewItem.xaml?assembly=Avalonia.Themes.Fluent"/>
   <StyleInclude Source="resm:Avalonia.Themes.Fluent.UserControl.xaml?assembly=Avalonia.Themes.Fluent"/>

src/Avalonia.Themes.Fluent/TitleBar.xaml

@@ -0,0 +1,53 @@
+<Styles xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <Design.PreviewWith>
+    <Border>
+      <TitleBar Background="SkyBlue" Height="30" Width="300" Foreground="Black" />
+    </Border>
+  </Design.PreviewWith>
+  <Style Selector="TitleBar">
+    <Setter Property="Foreground" Value="{DynamicResource SystemControlForegroundBaseHighBrush}"/>    
+    <Setter Property="VerticalAlignment" Value="Top" />
+    <Setter Property="HorizontalAlignment" Value="Stretch" />
+    <Setter Property="Background" Value="Transparent" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Panel HorizontalAlignment="{TemplateBinding HorizontalAlignment}" VerticalAlignment="Stretch">
+          <Panel x:Name="PART_MouseTracker" Height="1" VerticalAlignment="Top" />
+          <Panel x:Name="PART_Container">
+            <Border x:Name="PART_Background" Background="{TemplateBinding Background}" />
+            <CaptionButtons x:Name="PART_CaptionButtons" VerticalAlignment="Top" HorizontalAlignment="Right" Foreground="{TemplateBinding Foreground}" MaxHeight="30" />
+          </Panel>
+        </Panel>
+      </ControlTemplate>
+    </Setter>
+  </Style>
+
+  <Style Selector="TitleBar:fullscreen">
+    <Setter Property="Background" Value="{DynamicResource SystemAccentColor}" />
+  </Style>
+
+  <Style Selector="TitleBar /template/ Border#PART_Background">
+    <Setter Property="IsHitTestVisible" Value="False" />
+  </Style>
+
+  <Style Selector="TitleBar:fullscreen /template/ Border#PART_Background">
+    <Setter Property="IsHitTestVisible" Value="True" />
+  </Style>
+
+  <Style Selector="TitleBar:fullscreen /template/ Panel#PART_MouseTracker">
+    <Setter Property="Background" Value="Transparent" />
+  </Style>
+
+  <Style Selector="TitleBar:fullscreen /template/ Panel#PART_Container">
+    <Setter Property="RenderTransform" Value="translateY(-30px)" />
+    <Setter Property="Transitions">
+      <Transitions>
+        <TransformOperationsTransition Property="RenderTransform" Duration="0:0:.25" />
+      </Transitions>
+    </Setter>
+  </Style>
+
+  <Style Selector="TitleBar:fullscreen:pointerover /template/ Panel#PART_Container">
+    <Setter Property="RenderTransform" Value="none" />
+  </Style>
+</Styles>

src/Avalonia.Themes.Fluent/Window.xaml

@@ -1,5 +1,5 @@
 <Style xmlns="https://github.com/avaloniaui" Selector="Window">
-  <Setter Property="Background" Value="{DynamicResource SystemControlBackgroundChromeMediumBrush}"/>
+  <Setter Property="Background" Value="{DynamicResource SystemControlBackgroundChromeBlackHighBrush}"/>  
   <Setter Property="Foreground" Value="{DynamicResource ThemeForegroundBrush}"/>
   <Setter Property="FontSize" Value="{DynamicResource FontSizeNormal}"/>
   <Setter Property="Template">

src/Avalonia.X11/X11Window.cs

@@ -312,7 +312,15 @@ namespace Avalonia.X11
         {
             get => _transparencyHelper.TransparencyLevelChanged;
             set => _transparencyHelper.TransparencyLevelChanged = value;
-        }
+        }        
+
+        public Action<bool> ExtendClientAreaToDecorationsChanged { get; set; }
+
+        public Thickness ExtendedMargins { get; } = new Thickness();
+
+        public Thickness OffScreenMargin { get; } = new Thickness();
+
+        public bool IsClientAreaExtendedToDecorations { get; }
 
         public Action Closed { get; set; }
         public Action<PixelPoint> PositionChanged { get; set; }
@@ -1039,6 +1047,18 @@ namespace Avalonia.X11
             _disabled = !enable;
         }
 
+        public void SetExtendClientAreaToDecorationsHint(bool extendIntoClientAreaHint)
+        {
+        }
+
+        public void SetExtendClientAreaChromeHints(ExtendClientAreaChromeHints hints)
+        {
+        }
+
+        public void SetExtendClientAreaTitleBarHeightHint(double titleBarHeight)
+        {
+        }
+
         public Action GotInputWhenDisabled { get; set; }
 
         public void SetIcon(IWindowIconImpl icon)
@@ -1107,5 +1127,7 @@ namespace Avalonia.X11
         }
 
         public WindowTransparencyLevel TransparencyLevel => _transparencyHelper.CurrentLevel;
+
+        public bool NeedsManagedDecorations => false;
     }
 }

src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <DefineConstants>PCL;NETSTANDARD;NETSTANDARD2_0;HAS_TYPE_CONVERTER;HAS_CUSTOM_ATTRIBUTE_PROVIDER;XAMLIL_INTERNAL</DefineConstants>
+    <DefineConstants>PCL;NETSTANDARD;NETSTANDARD2_0;HAS_TYPE_CONVERTER;HAS_CUSTOM_ATTRIBUTE_PROVIDER;XAMLX_INTERNAL</DefineConstants>
     <UseCecil>false</UseCecil>
     <DefineConstants Condition="$(UseCecil) == true">$(DefineConstants);RUNTIME_XAML_CECIL</DefineConstants>
     <EnableDefaultCompileItems>False</EnableDefaultCompileItems>
@@ -58,8 +58,8 @@
         <Compile Include="XamlIl\Runtime\IAvaloniaXamlIlXmlNamespaceInfoProviderV1.cs" />
         <Compile Include="XamlIl\Runtime\XamlIlRuntimeHelpers.cs" />
         <Compile Include="XamlLoadException.cs" />
-        <Compile Include="XamlIl\xamlil.github\src\XamlIl\**\*.cs" />
+        <Compile Include="XamlIl\xamlil.github\src\XamlX\**\*.cs" />
-        <Compile Condition="$(UseCecil) == true" Include="XamlIl\xamlil.github\src\XamlIl.Cecil\**\*.cs" />
+        <Compile Condition="$(UseCecil) == true" Include="XamlIl\xamlil.github\src\XamlX.Il.Cecil\**\*.cs" />
         <Compile Remove="XamlIl\xamlil.github\**\obj\**\*.cs" />
         <Compile Include="..\Avalonia.Markup\Markup\Parsers\SelectorGrammar.cs" />
         <Compile Include="XamlTypes.cs" />

src/Markup/Avalonia.Markup.Xaml/XamlIl/AvaloniaXamlIlRuntimeCompiler.cs

@@ -10,12 +10,15 @@ using System.Runtime.InteropServices;
 using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions;
 using Avalonia.Markup.Xaml.XamlIl.Runtime;
 using Avalonia.Platform;
-using XamlIl.Transform;
+using XamlX.Transform;
-using XamlIl.TypeSystem;
+using XamlX.TypeSystem;
+using XamlX.IL;
+using XamlX.Emit;
 #if RUNTIME_XAML_CECIL
 using TypeAttributes = Mono.Cecil.TypeAttributes;
 using Mono.Cecil;
-using XamlIl.Ast;
+using XamlX.Ast;
+using XamlX.IL.Cecil;
 #endif
 namespace Avalonia.Markup.Xaml.XamlIl
 {
@@ -24,9 +27,10 @@ namespace Avalonia.Markup.Xaml.XamlIl
 #if !RUNTIME_XAML_CECIL
         private static SreTypeSystem _sreTypeSystem;
         private static ModuleBuilder _sreBuilder;
-        private static IXamlIlType _sreContextType; 
+        private static IXamlType _sreContextType; 
-        private static XamlIlLanguageTypeMappings _sreMappings;
+        private static XamlLanguageTypeMappings _sreMappings;
-        private static XamlIlXmlnsMappings _sreXmlns;
+        private static XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult> _sreEmitMappings;
+        private static XamlXmlnsMappings _sreXmlns;
         private static AssemblyBuilder _sreAsm;
         private static bool _sreCanSave;
 
@@ -82,13 +86,14 @@ namespace Avalonia.Markup.Xaml.XamlIl
             }
 
             if (_sreMappings == null)
-                _sreMappings = AvaloniaXamlIlLanguage.Configure(_sreTypeSystem);
+                (_sreMappings, _sreEmitMappings) = AvaloniaXamlIlLanguage.Configure(_sreTypeSystem);
             if (_sreXmlns == null)
-                _sreXmlns = XamlIlXmlnsMappings.Resolve(_sreTypeSystem, _sreMappings);
+                _sreXmlns = XamlXmlnsMappings.Resolve(_sreTypeSystem, _sreMappings);
             if (_sreContextType == null)
-                _sreContextType = XamlIlContextDefinition.GenerateContextClass(
+                _sreContextType = XamlILContextDefinition.GenerateContextClass(
                     _sreTypeSystem.CreateTypeBuilder(
-                        _sreBuilder.DefineType("XamlIlContext")), _sreTypeSystem, _sreMappings);
+                        _sreBuilder.DefineType("XamlIlContext")), _sreTypeSystem, _sreMappings,
+                        _sreEmitMappings);
         }
 
 
@@ -115,12 +120,13 @@ namespace Avalonia.Markup.Xaml.XamlIl
             InitializeSre();
             var asm = localAssembly == null ? null : _sreTypeSystem.GetAssembly(localAssembly);
 
-            var compiler = new AvaloniaXamlIlCompiler(new XamlIlTransformerConfiguration(_sreTypeSystem, asm,
+            var compiler = new AvaloniaXamlIlCompiler(new TransformerConfiguration(_sreTypeSystem, asm,
                     _sreMappings, _sreXmlns, AvaloniaXamlIlLanguage.CustomValueConverter),
+                _sreEmitMappings,
                 _sreContextType) { EnableIlVerification = true };
             var tb = _sreBuilder.DefineType("Builder_" + Guid.NewGuid().ToString("N") + "_" + uri);
 
-            IXamlIlType overrideType = null;
+            IXamlType overrideType = null;
             if (rootInstance != null)
             {
                 overrideType = _sreTypeSystem.GetType(rootInstance.GetType());
@@ -203,6 +209,7 @@ namespace Avalonia.Markup.Xaml.XamlIl
         private static string _cecilEmitDir;
         private static CecilTypeSystem _cecilTypeSystem;
         private static XamlIlLanguageTypeMappings _cecilMappings;
+        private static XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult> _cecilEmitMappings;
         private static XamlIlXmlnsMappings _cecilXmlns;
         private static bool _cecilInitialized;
 
@@ -215,7 +222,7 @@ namespace Avalonia.Markup.Xaml.XamlIl
             Directory.CreateDirectory(_cecilEmitDir);
             var refs = new[] {path}.Concat(File.ReadAllLines(path + ".refs"));
             _cecilTypeSystem = new CecilTypeSystem(refs);
-            _cecilMappings = AvaloniaXamlIlLanguage.Configure(_cecilTypeSystem);
+            (_cecilMappings, _cecilEmitMappings) = AvaloniaXamlIlLanguage.Configure(_cecilTypeSystem);
             _cecilXmlns = XamlIlXmlnsMappings.Resolve(_cecilTypeSystem, _cecilMappings);
             _cecilInitialized = true;
         }
@@ -226,7 +233,7 @@ namespace Avalonia.Markup.Xaml.XamlIl
             if (uri == null)
                 throw new InvalidOperationException("Please, go away");
             InitializeCecil();
-                        IXamlIlType overrideType = null;
+                        IXamlType overrideType = null;
             if (rootInstance != null)
             {
                 overrideType = _cecilTypeSystem.GetType(rootInstance.GetType().FullName);
@@ -261,6 +268,7 @@ namespace Avalonia.Markup.Xaml.XamlIl
                     localAssembly == null ? null : _cecilTypeSystem.FindAssembly(localAssembly.GetName().Name),
                     _cecilMappings, XamlIlXmlnsMappings.Resolve(_cecilTypeSystem, _cecilMappings),
                     AvaloniaXamlIlLanguage.CustomValueConverter),
+                _cecilEmitMappings,
                 _cecilTypeSystem.CreateTypeBuilder(contextDef));
             compiler.ParseAndCompile(xaml, uri.ToString(), tb, overrideType);
             var asmPath = Path.Combine(_cecilEmitDir, safeUri + ".dll");

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlCompiler.cs

@@ -1,29 +1,32 @@
 using System.Collections.Generic;
 using System.Linq;
 using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers;
-using XamlIl;
+using XamlX;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Parsers;
+using XamlX.Emit;
-using XamlIl.Transform;
+using XamlX.IL;
-using XamlIl.Transform.Transformers;
+using XamlX.Parsers;
-using XamlIl.TypeSystem;
+using XamlX.Transform;
+using XamlX.Transform.Transformers;
+using XamlX.TypeSystem;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
 {
-    class AvaloniaXamlIlCompiler : XamlIlCompiler
+    class AvaloniaXamlIlCompiler : XamlILCompiler
     {
-        private readonly XamlIlTransformerConfiguration _configuration;
+        private readonly TransformerConfiguration _configuration;
-        private readonly IXamlIlType _contextType;
+        private readonly IXamlType _contextType;
         private readonly AvaloniaXamlIlDesignPropertiesTransformer _designTransformer;
 
-        private AvaloniaXamlIlCompiler(XamlIlTransformerConfiguration configuration) : base(configuration, true)
+        private AvaloniaXamlIlCompiler(TransformerConfiguration configuration, XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult> emitMappings)
+            : base(configuration, emitMappings, true)
         {
             _configuration = configuration;
 
-            void InsertAfter<T>(params IXamlIlAstTransformer[] t) 
+            void InsertAfter<T>(params IXamlAstTransformer[] t) 
                 => Transformers.InsertRange(Transformers.FindIndex(x => x is T) + 1, t);
 
-            void InsertBefore<T>(params IXamlIlAstTransformer[] t) 
+            void InsertBefore<T>(params IXamlAstTransformer[] t) 
                 => Transformers.InsertRange(Transformers.FindIndex(x => x is T), t);
 
 
@@ -37,12 +40,12 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
             
             // Targeted
 
-            InsertBefore<XamlIlPropertyReferenceResolver>(new AvaloniaXamlIlTransformInstanceAttachedProperties());
+            InsertBefore<PropertyReferenceResolver>(new AvaloniaXamlIlTransformInstanceAttachedProperties());
-            InsertAfter<XamlIlPropertyReferenceResolver>(new AvaloniaXamlIlAvaloniaPropertyResolver());
+            InsertAfter<PropertyReferenceResolver>(new AvaloniaXamlIlAvaloniaPropertyResolver());
             
 
 
-            InsertBefore<XamlIlContentConvertTransformer>(
+            InsertBefore<ContentConvertTransformer>(
                 new AvaloniaXamlIlSelectorTransformer(),
                 new AvaloniaXamlIlSetterTransformer(),
                 new AvaloniaXamlIlControlTemplateTargetTypeMetadataTransformer(),
@@ -55,17 +58,21 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
             Transformers.Add(new AddNameScopeRegistration());
             Transformers.Add(new AvaloniaXamlIlMetadataRemover());
 
+            Emitters.Add(new AvaloniaNameScopeRegistrationXamlIlNodeEmitter());
         }
 
-        public AvaloniaXamlIlCompiler(XamlIlTransformerConfiguration configuration,
+        public AvaloniaXamlIlCompiler(TransformerConfiguration configuration,
-            IXamlIlTypeBuilder contextTypeBuilder) : this(configuration)
+            XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult> emitMappings,
+            IXamlTypeBuilder<IXamlILEmitter> contextTypeBuilder)
+            : this(configuration, emitMappings)
         {
             _contextType = CreateContextType(contextTypeBuilder);
         }
 
         
-        public AvaloniaXamlIlCompiler(XamlIlTransformerConfiguration configuration,
+        public AvaloniaXamlIlCompiler(TransformerConfiguration configuration,
-            IXamlIlType contextType) : this(configuration)
+            XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult> emitMappings,
+            IXamlType contextType) : this(configuration, emitMappings)
         {
             _contextType = contextType;
         }
@@ -79,37 +86,35 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
             set => _designTransformer.IsDesignMode = value;
         }
 
-        public void ParseAndCompile(string xaml, string baseUri, IFileSource fileSource, IXamlIlTypeBuilder tb, IXamlIlType overrideRootType)
+        public void ParseAndCompile(string xaml, string baseUri, IFileSource fileSource, IXamlTypeBuilder<IXamlILEmitter> tb, IXamlType overrideRootType)
         {
-            var parsed = XDocumentXamlIlParser.Parse(xaml, new Dictionary<string, string>
+            var parsed = XDocumentXamlParser.Parse(xaml, new Dictionary<string, string>
             {
                 {XamlNamespaces.Blend2008, XamlNamespaces.Blend2008}
             });
             
-            var rootObject = (XamlIlAstObjectNode)parsed.Root;
+            var rootObject = (XamlAstObjectNode)parsed.Root;
 
             var classDirective = rootObject.Children
-                .OfType<XamlIlAstXmlDirective>().FirstOrDefault(x =>
+                .OfType<XamlAstXmlDirective>().FirstOrDefault(x =>
                     x.Namespace == XamlNamespaces.Xaml2006
                     && x.Name == "Class");
 
             var rootType =
                 classDirective != null ?
-                    new XamlIlAstClrTypeReference(classDirective,
+                    new XamlAstClrTypeReference(classDirective,
-                        _configuration.TypeSystem.GetType(((XamlIlAstTextNode)classDirective.Values[0]).Text),
+                        _configuration.TypeSystem.GetType(((XamlAstTextNode)classDirective.Values[0]).Text),
                         false) :
-                    XamlIlTypeReferenceResolver.ResolveType(CreateTransformationContext(parsed, true),
+                    TypeReferenceResolver.ResolveType(CreateTransformationContext(parsed, true),
-                        (XamlIlAstXmlTypeReference)rootObject.Type, true);
+                        (XamlAstXmlTypeReference)rootObject.Type, true);
             
             
             if (overrideRootType != null)
             {
-                
-
                 if (!rootType.Type.IsAssignableFrom(overrideRootType))
-                    throw new XamlIlLoadException(
+                    throw new XamlX.XamlLoadException(
                         $"Unable to substitute {rootType.Type.GetFqn()} with {overrideRootType.GetFqn()}", rootObject);
-                rootType = new XamlIlAstClrTypeReference(rootObject, overrideRootType, false);
+                rootType = new XamlAstClrTypeReference(rootObject, overrideRootType, false);
             }
 
             OverrideRootType(parsed, rootType);
@@ -119,17 +124,17 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
             
         }
 
-        public void OverrideRootType(XamlIlDocument doc, IXamlIlAstTypeReference newType)
+        public void OverrideRootType(XamlDocument doc, IXamlAstTypeReference newType)
         {
-            var root = (XamlIlAstObjectNode)doc.Root;
+            var root = (XamlAstObjectNode)doc.Root;
             var oldType = root.Type;
             if (oldType.Equals(newType))
                 return;
 
             root.Type = newType;
-            foreach (var child in root.Children.OfType<XamlIlAstXamlPropertyValueNode>())
+            foreach (var child in root.Children.OfType<XamlAstXamlPropertyValueNode>())
             {
-                if (child.Property is XamlIlAstNamePropertyReference prop)
+                if (child.Property is XamlAstNamePropertyReference prop)
                 {
                     if (prop.DeclaringType.Equals(oldType))
                         prop.DeclaringType = newType;

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlLanguage.cs

@@ -2,10 +2,12 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers;
-using XamlIl;
+using XamlX;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Emit;
-using XamlIl.TypeSystem;
+using XamlX.IL;
+using XamlX.Transform;
+using XamlX.TypeSystem;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
 {
@@ -17,12 +19,12 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
     
     class AvaloniaXamlIlLanguage
     {
-        public static XamlIlLanguageTypeMappings Configure(IXamlIlTypeSystem typeSystem)
+        public static (XamlLanguageTypeMappings language, XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult> emit) Configure(IXamlTypeSystem typeSystem)
         {
             var runtimeHelpers = typeSystem.GetType("Avalonia.Markup.Xaml.XamlIl.Runtime.XamlIlRuntimeHelpers");
             var assignBindingAttribute = typeSystem.GetType("Avalonia.Data.AssignBindingAttribute");
             var bindingType = typeSystem.GetType("Avalonia.Data.IBinding");
-            var rv = new XamlIlLanguageTypeMappings(typeSystem)
+            var rv = new XamlLanguageTypeMappings(typeSystem)
             {
                 SupportInitialize = typeSystem.GetType("System.ComponentModel.ISupportInitialize"),
                 XmlnsAttributes =
@@ -51,18 +53,22 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                 },
                 InnerServiceProviderFactoryMethod =
                     runtimeHelpers.FindMethod(m => m.Name == "CreateInnerServiceProviderV1"),
-                ProvideValueTargetPropertyEmitter = XamlIlAvaloniaPropertyHelper.Emit,
             };
             rv.CustomAttributeResolver = new AttributeResolver(typeSystem, rv);
-            rv.ContextTypeBuilderCallback = (b, c) => EmitNameScopeField(rv, typeSystem, b, c);
+
-            return rv;
+            var emit = new XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult>
+            {
+                ProvideValueTargetPropertyEmitter = XamlIlAvaloniaPropertyHelper.Emit,
+                ContextTypeBuilderCallback = (b, c) => EmitNameScopeField(rv, typeSystem, b, c)
+            };
+            return (rv, emit);
         }
 
         public const string ContextNameScopeFieldName = "AvaloniaNameScope";
 
-        private static void EmitNameScopeField(XamlIlLanguageTypeMappings mappings,
+        private static void EmitNameScopeField(XamlLanguageTypeMappings mappings,
-            IXamlIlTypeSystem typeSystem,
+            IXamlTypeSystem typeSystem,
-            IXamlIlTypeBuilder typebuilder, IXamlIlEmitter constructor)
+            IXamlTypeBuilder<IXamlILEmitter> typebuilder, IXamlILEmitter constructor)
         {
 
             var nameScopeType = typeSystem.FindType("Avalonia.Controls.INameScope");
@@ -78,23 +84,23 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
         }
         
 
-        class AttributeResolver : IXamlIlCustomAttributeResolver
+        class AttributeResolver : IXamlCustomAttributeResolver
         {
-            private readonly IXamlIlType _typeConverterAttribute;
+            private readonly IXamlType _typeConverterAttribute;
 
-            private readonly List<KeyValuePair<IXamlIlType, IXamlIlType>> _converters =
+            private readonly List<KeyValuePair<IXamlType, IXamlType>> _converters =
-                new List<KeyValuePair<IXamlIlType, IXamlIlType>>();
+                new List<KeyValuePair<IXamlType, IXamlType>>();
 
-            private readonly IXamlIlType _avaloniaList;
+            private readonly IXamlType _avaloniaList;
-            private readonly IXamlIlType _avaloniaListConverter;
+            private readonly IXamlType _avaloniaListConverter;
 
 
-            public AttributeResolver(IXamlIlTypeSystem typeSystem, XamlIlLanguageTypeMappings mappings)
+            public AttributeResolver(IXamlTypeSystem typeSystem, XamlLanguageTypeMappings mappings)
             {
                 _typeConverterAttribute = mappings.TypeConverterAttributes.First();
 
-                void AddType(IXamlIlType type, IXamlIlType conv) 
+                void AddType(IXamlType type, IXamlType conv) 
-                    => _converters.Add(new KeyValuePair<IXamlIlType, IXamlIlType>(type, conv));
+                    => _converters.Add(new KeyValuePair<IXamlType, IXamlType>(type, conv));
 
                 void Add(string type, string conv)
                     => AddType(typeSystem.GetType(type), typeSystem.GetType(conv));
@@ -113,7 +119,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                 _avaloniaListConverter = typeSystem.GetType("Avalonia.Collections.AvaloniaListConverter`1");
             }
 
-            IXamlIlType LookupConverter(IXamlIlType type)
+            IXamlType LookupConverter(IXamlType type)
             {
                 foreach(var p in _converters)
                     if (p.Key.Equals(type))
@@ -123,15 +129,15 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                 return null;
             }
 
-            class ConstructedAttribute : IXamlIlCustomAttribute
+            class ConstructedAttribute : IXamlCustomAttribute
             {
-                public bool Equals(IXamlIlCustomAttribute other) => false;
+                public bool Equals(IXamlCustomAttribute other) => false;
                 
-                public IXamlIlType Type { get; }
+                public IXamlType Type { get; }
                 public List<object> Parameters { get; }
                 public Dictionary<string, object> Properties { get; }
 
-                public ConstructedAttribute(IXamlIlType type, List<object> parameters, Dictionary<string, object> properties)
+                public ConstructedAttribute(IXamlType type, List<object> parameters, Dictionary<string, object> properties)
                 {
                     Type = type;
                     Parameters = parameters ?? new List<object>();
@@ -139,7 +145,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                 }
             }
             
-            public IXamlIlCustomAttribute GetCustomAttribute(IXamlIlType type, IXamlIlType attributeType)
+            public IXamlCustomAttribute GetCustomAttribute(IXamlType type, IXamlType attributeType)
             {
                 if (attributeType.Equals(_typeConverterAttribute))
                 {
@@ -151,25 +157,25 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                 return null;
             }
 
-            public IXamlIlCustomAttribute GetCustomAttribute(IXamlIlProperty property, IXamlIlType attributeType)
+            public IXamlCustomAttribute GetCustomAttribute(IXamlProperty property, IXamlType attributeType)
             {
                 return null;
             }
         }
 
-        public static bool CustomValueConverter(XamlIlAstTransformationContext context,
+        public static bool CustomValueConverter(AstTransformationContext context,
-            IXamlIlAstValueNode node, IXamlIlType type, out IXamlIlAstValueNode result)
+            IXamlAstValueNode node, IXamlType type, out IXamlAstValueNode result)
         {
             if (type.FullName == "System.TimeSpan" 
-                && node is XamlIlAstTextNode tn
+                && node is XamlAstTextNode tn
                 && !tn.Text.Contains(":"))
             {
                 var seconds = double.Parse(tn.Text, CultureInfo.InvariantCulture);
-                result = new XamlIlStaticOrTargetedReturnMethodCallNode(tn,
+                result = new XamlStaticOrTargetedReturnMethodCallNode(tn,
                     type.FindMethod("FromSeconds", type, false, context.Configuration.WellKnownTypes.Double),
                     new[]
                     {
-                        new XamlIlConstantNode(tn, context.Configuration.WellKnownTypes.Double, seconds)
+                        new XamlConstantNode(tn, context.Configuration.WellKnownTypes.Double, seconds)
                     });
                 return true;
             }
@@ -178,9 +184,9 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
             {
                 var scope = context.ParentNodes().OfType<AvaloniaXamlIlTargetTypeMetadataNode>().FirstOrDefault();
                 if (scope == null)
-                    throw new XamlIlLoadException("Unable to find the parent scope for AvaloniaProperty lookup", node);
+                    throw new XamlX.XamlLoadException("Unable to find the parent scope for AvaloniaProperty lookup", node);
-                if (!(node is XamlIlAstTextNode text))
+                if (!(node is XamlAstTextNode text))
-                    throw new XamlIlLoadException("Property should be a text node", node);
+                    throw new XamlX.XamlLoadException("Property should be a text node", node);
                 result = XamlIlAvaloniaPropertyHelper.CreateNode(context, text.Text, scope.TargetType, text);
                 return true;
             }

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AddNameScopeRegistration.cs

@@ -1,33 +1,35 @@
 using System;
 using System.Linq;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Emit;
-using XamlIl.TypeSystem;
+using XamlX.IL;
+using XamlX.Transform;
+using XamlX.TypeSystem;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
-    class AddNameScopeRegistration : IXamlIlAstTransformer
+    class AddNameScopeRegistration : IXamlAstTransformer
     {
-        public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node)
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
         {
-            if (node is XamlIlPropertyAssignmentNode pa
+            if (node is XamlPropertyAssignmentNode pa
                 && pa.Property.Name == "Name"
                 && pa.Property.DeclaringType.FullName == "Avalonia.StyledElement")
             {
-                if (context.ParentNodes().FirstOrDefault() is XamlIlManipulationGroupNode mg
+                if (context.ParentNodes().FirstOrDefault() is XamlManipulationGroupNode mg
                     && mg.Children.OfType<AvaloniaNameScopeRegistrationXamlIlNode>().Any())
                     return node;
                 
-                IXamlIlAstValueNode value = null;
+                IXamlAstValueNode value = null;
                 for (var c = 0; c < pa.Values.Count; c++)
                     if (pa.Values[c].Type.GetClrType().Equals(context.Configuration.WellKnownTypes.String))
                     {
                         value = pa.Values[c];
-                        if (!(value is XamlIlAstTextNode))
+                        if (!(value is XamlAstTextNode))
                         {
-                            var local = new XamlIlAstCompilerLocalNode(value);
+                            var local = new XamlAstCompilerLocalNode(value);
                             // Wrap original in local initialization
-                            pa.Values[c] = new XamlIlAstLocalInitializationNodeEmitter(value, value, local);
+                            pa.Values[c] = new XamlAstLocalInitializationNodeEmitter(value, value, local);
                             // Use local
                             value = local;
                         }
@@ -36,20 +38,20 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                     }
 
                 if (value != null)
-                    return new XamlIlManipulationGroupNode(pa)
+                    return new XamlManipulationGroupNode(pa)
                     {
                         Children =
                         {
                             pa,
-                            new AvaloniaNameScopeRegistrationXamlIlNode(value, context.GetAvaloniaTypes())
+                            new AvaloniaNameScopeRegistrationXamlIlNode(value)
                         }
                     };
             }
 
             if (!context.ParentNodes().Any()
-                && node is XamlIlValueWithManipulationNode mnode)
+                && node is XamlValueWithManipulationNode mnode)
             {
-                mnode.Manipulation = new XamlIlManipulationGroupNode(mnode,
+                mnode.Manipulation = new XamlManipulationGroupNode(mnode,
                     new[]
                     {
                         mnode.Manipulation,
@@ -59,17 +61,17 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
             return node;
         }
 
-        class HandleRootObjectScopeNode : XamlIlAstNode, IXamlIlAstManipulationNode, IXamlIlAstEmitableNode
+        class HandleRootObjectScopeNode : XamlAstNode, IXamlAstManipulationNode, IXamlAstEmitableNode<IXamlILEmitter, XamlILNodeEmitResult>
         {
             private readonly AvaloniaXamlIlWellKnownTypes _types;
 
-            public HandleRootObjectScopeNode(IXamlIlLineInfo lineInfo,
+            public HandleRootObjectScopeNode(IXamlLineInfo lineInfo,
                 AvaloniaXamlIlWellKnownTypes types) : base(lineInfo)
             {
                 _types = types;
             }
 
-            public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
+            public XamlILNodeEmitResult Emit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
             {
                 var next = codeGen.DefineLabel();
                 var scopeField = context.RuntimeContext.ContextType.Fields.First(f =>
@@ -91,49 +93,55 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                         .EmitCall(_types.INameScopeComplete, true);
                 }
 
-                return XamlIlNodeEmitResult.Void(1);
+                return XamlILNodeEmitResult.Void(1);
 
             }
         }
     }
 
-    class AvaloniaNameScopeRegistrationXamlIlNode : XamlIlAstNode, IXamlIlAstManipulationNode, IXamlIlAstEmitableNode
+    class AvaloniaNameScopeRegistrationXamlIlNode : XamlAstNode, IXamlAstManipulationNode
     {
-        private readonly AvaloniaXamlIlWellKnownTypes _types;
+        public IXamlAstValueNode Name { get; set; }
-        public IXamlIlAstValueNode Name { get; set; }
 
-        public AvaloniaNameScopeRegistrationXamlIlNode(IXamlIlAstValueNode name, AvaloniaXamlIlWellKnownTypes types) : base(name)
+        public AvaloniaNameScopeRegistrationXamlIlNode(IXamlAstValueNode name) : base(name)
         {
-            _types = types;
             Name = name;
         }
 
-        public override void VisitChildren(IXamlIlAstVisitor visitor)
+        public override void VisitChildren(IXamlAstVisitor visitor)
-            => Name = (IXamlIlAstValueNode)Name.Visit(visitor);
+            => Name = (IXamlAstValueNode)Name.Visit(visitor);
+    }
 
-        public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
+    class AvaloniaNameScopeRegistrationXamlIlNodeEmitter : IXamlAstLocalsNodeEmitter<IXamlILEmitter, XamlILNodeEmitResult>
+    {
+        public XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContextWithLocals<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
         {
-            var scopeField = context.RuntimeContext.ContextType.Fields.First(f =>
+            if (node is AvaloniaNameScopeRegistrationXamlIlNode registration)
-                f.Name == AvaloniaXamlIlLanguage.ContextNameScopeFieldName);
-            
-            using (var targetLoc = context.GetLocal(context.Configuration.WellKnownTypes.Object))
             {
 
-                codeGen
+                var scopeField = context.RuntimeContext.ContextType.Fields.First(f =>
-                    // var target = {pop}
+                    f.Name == AvaloniaXamlIlLanguage.ContextNameScopeFieldName);
-                    .Stloc(targetLoc.Local)
+
-                    // _context.NameScope.Register(Name, target)
+                using (var targetLoc = context.GetLocalOfType(context.Configuration.WellKnownTypes.Object))
-                    .Ldloc(context.ContextLocal)
+                {
-                    .Ldfld(scopeField);
-                    
-                context.Emit(Name, codeGen, Name.Type.GetClrType());
-                
-                codeGen
-                    .Ldloc(targetLoc.Local)
-                    .EmitCall(_types.INameScopeRegister, true);
-            }
 
-            return XamlIlNodeEmitResult.Void(1);
+                    codeGen
+                        // var target = {pop}
+                        .Stloc(targetLoc.Local)
+                        // _context.NameScope.Register(Name, target)
+                        .Ldloc(context.ContextLocal)
+                        .Ldfld(scopeField);
+
+                    context.Emit(registration.Name, codeGen, registration.Name.Type.GetClrType());
+
+                    codeGen
+                        .Ldloc(targetLoc.Local)
+                        .EmitCall(context.GetAvaloniaTypes().INameScopeRegister, true);
+                }
+
+                return XamlILNodeEmitResult.Void(1);
+            }
+            return default;
         }
     }
 }

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaBindingExtensionHackTransformer.cs

@@ -1,16 +1,16 @@
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Transform;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
-    class AvaloniaBindingExtensionHackTransformer : IXamlIlAstTransformer
+    class AvaloniaBindingExtensionHackTransformer : IXamlAstTransformer
     {
-        public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node)
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
         {
             // Our code base expects XAML parser to prefer `FooExtension` to `Foo` even with `<Foo>` syntax
             // This is the legacy of Portable.Xaml, so we emulate that behavior here
 
-            if (node is XamlIlAstXmlTypeReference tref
+            if (node is XamlAstXmlTypeReference tref
                 && tref.Name == "Binding"
                 && tref.XmlNamespace == "https://github.com/avaloniaui")
                 tref.IsMarkupExtension = true;

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlAvaloniaPropertyResolver.cs

@@ -1,14 +1,14 @@
 using System.Linq;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Transform;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
-    class AvaloniaXamlIlAvaloniaPropertyResolver : IXamlIlAstTransformer
+    class AvaloniaXamlIlAvaloniaPropertyResolver : IXamlAstTransformer
     {
-        public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node)
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
         {
-            if (node is XamlIlAstClrProperty prop)
+            if (node is XamlAstClrProperty prop)
             {
                 var n = prop.Name + "Property";
                 var field =

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlConstructorServiceProviderTransformer.cs

@@ -1,15 +1,17 @@
 using System.Linq;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Emit;
-using XamlIl.TypeSystem;
+using XamlX.IL;
+using XamlX.Transform;
+using XamlX.TypeSystem;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
-    class AvaloniaXamlIlConstructorServiceProviderTransformer : IXamlIlAstTransformer
+    class AvaloniaXamlIlConstructorServiceProviderTransformer : IXamlAstTransformer
     {
-        public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node)
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
         {
-            if (node is XamlIlAstObjectNode on && on.Arguments.Count == 0)
+            if (node is XamlAstObjectNode on && on.Arguments.Count == 0)
             {
                 var ctors = on.Type.GetClrType().Constructors;
                 if (!ctors.Any(c => c.IsPublic && !c.IsStatic && c.Parameters.Count == 0))
@@ -27,20 +29,20 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
             return node;
         }
 
-        class InjectServiceProviderNode : XamlIlAstNode, IXamlIlAstValueNode,IXamlIlAstNodeNeedsParentStack,
+        class InjectServiceProviderNode : XamlAstNode, IXamlAstValueNode,IXamlAstNodeNeedsParentStack,
-            IXamlIlAstEmitableNode
+            IXamlAstEmitableNode<IXamlILEmitter, XamlILNodeEmitResult>
         {
-            public InjectServiceProviderNode(IXamlIlType type, IXamlIlLineInfo lineInfo) : base(lineInfo)
+            public InjectServiceProviderNode(IXamlType type, IXamlLineInfo lineInfo) : base(lineInfo)
             {
-                Type = new XamlIlAstClrTypeReference(lineInfo, type, false);
+                Type = new XamlAstClrTypeReference(lineInfo, type, false);
             }
 
-            public IXamlIlAstTypeReference Type { get; }
+            public IXamlAstTypeReference Type { get; }
             public bool NeedsParentStack => true;
-            public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
+            public XamlILNodeEmitResult Emit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
             {
                 codeGen.Ldloc(context.ContextLocal);
-                return XamlIlNodeEmitResult.Type(0, Type.GetClrType());
+                return XamlILNodeEmitResult.Type(0, Type.GetClrType());
             }
         }
     }

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlControlTemplateTargetTypeMetadataTransformer.cs

@@ -1,29 +1,29 @@
 using System.Linq;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Transform;
-using XamlIl.TypeSystem;
+using XamlX.TypeSystem;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
-    class AvaloniaXamlIlControlTemplateTargetTypeMetadataTransformer : IXamlIlAstTransformer
+    class AvaloniaXamlIlControlTemplateTargetTypeMetadataTransformer : IXamlAstTransformer
     {
-        public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node)
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
         {
-            if (!(node is XamlIlAstObjectNode on
+            if (!(node is XamlAstObjectNode on
                   && on.Type.GetClrType().FullName == "Avalonia.Markup.Xaml.Templates.ControlTemplate"))
                 return node;
-            var tt = on.Children.OfType<XamlIlAstXamlPropertyValueNode>().FirstOrDefault(ch =>
+            var tt = on.Children.OfType<XamlAstXamlPropertyValueNode>().FirstOrDefault(ch =>
                                               ch.Property.GetClrProperty().Name == "TargetType");
 
             if (context.ParentNodes().FirstOrDefault() is AvaloniaXamlIlTargetTypeMetadataNode)
                 // Deja vu. I've just been in this place before
                 return node;
 
-            IXamlIlAstTypeReference targetType;
+            IXamlAstTypeReference targetType;
 
             var templatableBaseType = context.Configuration.TypeSystem.GetType("Avalonia.Controls.Control");
             
-            if ((tt?.Values.FirstOrDefault() is XamlIlTypeExtensionNode tn))
+            if ((tt?.Values.FirstOrDefault() is XamlTypeExtensionNode tn))
             {
                 targetType = tn.Value;
             }
@@ -33,11 +33,11 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                     .FirstOrDefault();
                 if (parentScope?.ScopeType == AvaloniaXamlIlTargetTypeMetadataNode.ScopeTypes.Style)
                     targetType = parentScope.TargetType;
-                else if (context.ParentNodes().Skip(1).FirstOrDefault() is XamlIlAstObjectNode directParentNode
+                else if (context.ParentNodes().Skip(1).FirstOrDefault() is XamlAstObjectNode directParentNode
                          && templatableBaseType.IsAssignableFrom(directParentNode.Type.GetClrType()))
                     targetType = directParentNode.Type;
                 else
-                    targetType = new XamlIlAstClrTypeReference(node,
+                    targetType = new XamlAstClrTypeReference(node,
                         templatableBaseType, false);
             }
                 
@@ -48,9 +48,9 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
         }
     }
 
-    class AvaloniaXamlIlTargetTypeMetadataNode : XamlIlValueWithSideEffectNodeBase
+    class AvaloniaXamlIlTargetTypeMetadataNode : XamlValueWithSideEffectNodeBase
     {
-        public IXamlIlAstTypeReference TargetType { get; set; }
+        public IXamlAstTypeReference TargetType { get; set; }
         public ScopeTypes ScopeType { get; }
 
         public enum ScopeTypes
@@ -60,7 +60,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
             Transitions
         }
         
-        public AvaloniaXamlIlTargetTypeMetadataNode(IXamlIlAstValueNode value, IXamlIlAstTypeReference targetType,
+        public AvaloniaXamlIlTargetTypeMetadataNode(IXamlAstValueNode value, IXamlAstTypeReference targetType,
             ScopeTypes type)
             : base(value, value)
         {

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlDesignPropertiesTransformer.cs

@@ -1,12 +1,12 @@
 using System.Collections.Generic;
 using System.Linq;
-using XamlIl;
+using XamlX;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Transform;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
-    class AvaloniaXamlIlDesignPropertiesTransformer : IXamlIlAstTransformer
+    class AvaloniaXamlIlDesignPropertiesTransformer : IXamlAstTransformer
     {
         public bool IsDesignMode { get; set; }
 
@@ -17,14 +17,14 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
         };
 
         private const string AvaloniaNs = "https://github.com/avaloniaui";
-        public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node)
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
         {
-            if (node is XamlIlAstObjectNode on)
+            if (node is XamlAstObjectNode on)
             {
                 for (var c=0; c<on.Children.Count;)
                 {
                     var ch = on.Children[c];
-                    if (ch is XamlIlAstXmlDirective directive
+                    if (ch is XamlAstXmlDirective directive
                         && directive.Namespace == XamlNamespaces.Blend2008
                         && DesignDirectives.TryGetValue(directive.Name, out var mapTo))
                     {
@@ -34,9 +34,9 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                         else
                         {
                             // Map to an actual property in `Design` class
-                            on.Children[c] = new XamlIlAstXamlPropertyValueNode(ch,
+                            on.Children[c] = new XamlAstXamlPropertyValueNode(ch,
-                                new XamlIlAstNamePropertyReference(ch,
+                                new XamlAstNamePropertyReference(ch,
-                                    new XamlIlAstXmlTypeReference(ch, AvaloniaNs, "Design"),
+                                    new XamlAstXmlTypeReference(ch, AvaloniaNs, "Design"),
                                     mapTo, on.Type), directive.Values);
                             c++;
                         }
@@ -44,9 +44,9 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                     // Remove all "Design" attached properties in non-design mode
                     else if (
                         !IsDesignMode
-                        && ch is XamlIlAstXamlPropertyValueNode pv
+                        && ch is XamlAstXamlPropertyValueNode pv
-                        && pv.Property is XamlIlAstNamePropertyReference pref
+                        && pv.Property is XamlAstNamePropertyReference pref
-                        && pref.DeclaringType is XamlIlAstXmlTypeReference dref
+                        && pref.DeclaringType is XamlAstXmlTypeReference dref
                         && dref.XmlNamespace == AvaloniaNs && dref.Name == "Design"
                     )
                     {

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlMetadataRemover.cs

@@ -1,12 +1,12 @@
 using System.Linq;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Transform;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
-    class AvaloniaXamlIlMetadataRemover : IXamlIlAstTransformer
+    class AvaloniaXamlIlMetadataRemover : IXamlAstTransformer
     {
-        public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node)
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
         {
             if (node is AvaloniaXamlIlTargetTypeMetadataNode md)
                 return md.Value;

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlSelectorTransformer.cs

@@ -3,41 +3,45 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using Avalonia.Markup.Parsers;
-using XamlIl;
+using XamlX;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Emit;
-using XamlIl.Transform.Transformers;
+using XamlX.IL;
-using XamlIl.TypeSystem;
+using XamlX.Transform;
+using XamlX.Transform.Transformers;
+using XamlX.TypeSystem;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
-    class AvaloniaXamlIlSelectorTransformer : IXamlIlAstTransformer
+    using XamlParseException = XamlX.XamlParseException;
+    using XamlLoadException = XamlX.XamlLoadException;
+    class AvaloniaXamlIlSelectorTransformer : IXamlAstTransformer
     {
-        public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node)
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
         {
-            if (!(node is XamlIlAstObjectNode on && on.Type.GetClrType().FullName == "Avalonia.Styling.Style"))
+            if (!(node is XamlAstObjectNode on && on.Type.GetClrType().FullName == "Avalonia.Styling.Style"))
                 return node;
 
-            var pn = on.Children.OfType<XamlIlAstXamlPropertyValueNode>()
+            var pn = on.Children.OfType<XamlAstXamlPropertyValueNode>()
                 .FirstOrDefault(p => p.Property.GetClrProperty().Name == "Selector");
 
             if (pn == null)
                 return node;
 
             if (pn.Values.Count != 1)
-                throw new XamlIlParseException("Selector property should should have exactly one value", node);
+                throw new XamlParseException("Selector property should should have exactly one value", node);
             
             if (pn.Values[0] is XamlIlSelectorNode)
                 //Deja vu. I've just been in this place before
                 return node;
             
-            if (!(pn.Values[0] is XamlIlAstTextNode tn))
+            if (!(pn.Values[0] is XamlAstTextNode tn))
-                throw new XamlIlParseException("Selector property should be a text node", node);
+                throw new XamlParseException("Selector property should be a text node", node);
 
             var selectorType = pn.Property.GetClrProperty().Getter.ReturnType;
             var initialNode = new XamlIlSelectorInitialNode(node, selectorType);
             XamlIlSelectorNode Create(IEnumerable<SelectorGrammar.ISyntax> syntax,
-                Func<string, string, XamlIlAstClrTypeReference> typeResolver)
+                Func<string, string, XamlAstClrTypeReference> typeResolver)
             {
                 XamlIlSelectorNode result = initialNode;
                 XamlIlOrSelectorNode results = null;
@@ -63,18 +67,18 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                             var type = result?.TargetType;
 
                             if (type == null)
-                                throw new XamlIlParseException("Property selectors must be applied to a type.", node);
+                                throw new XamlParseException("Property selectors must be applied to a type.", node);
 
                             var targetProperty =
                                 type.GetAllProperties().FirstOrDefault(p => p.Name == property.Property);
 
                             if (targetProperty == null)
-                                throw new XamlIlParseException($"Cannot find '{property.Property}' on '{type}", node);
+                                throw new XamlParseException($"Cannot find '{property.Property}' on '{type}", node);
 
-                            if (!XamlIlTransformHelpers.TryGetCorrectlyTypedValue(context,
+                            if (!XamlTransformHelpers.TryGetCorrectlyTypedValue(context,
-                                new XamlIlAstTextNode(node, property.Value, context.Configuration.WellKnownTypes.String),
+                                new XamlAstTextNode(node, property.Value, context.Configuration.WellKnownTypes.String),
                                 targetProperty.PropertyType, out var typedValue))
-                                throw new XamlIlParseException(
+                                throw new XamlParseException(
                                     $"Cannot convert '{property.Value}' to '{targetProperty.PropertyType.GetFqn()}",
                                     node);
 
@@ -100,7 +104,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                             result = initialNode;
                             break;
                         default:
-                            throw new XamlIlParseException($"Unsupported selector grammar '{i.GetType()}'.", node);
+                            throw new XamlParseException($"Unsupported selector grammar '{i.GetType()}'.", node);
                     }
                 }
 
@@ -119,15 +123,15 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
             }
             catch (Exception e)
             {
-                throw new XamlIlParseException("Unable to parse selector: " + e.Message, node);
+                throw new XamlParseException("Unable to parse selector: " + e.Message, node);
             }
 
             var selector = Create(parsed, (p, n) 
-                => XamlIlTypeReferenceResolver.ResolveType(context, $"{p}:{n}", true, node, true));
+                => TypeReferenceResolver.ResolveType(context, $"{p}:{n}", true, node, true));
             pn.Values[0] = selector;
 
             return new AvaloniaXamlIlTargetTypeMetadataNode(on,
-                new XamlIlAstClrTypeReference(selector, selector.TargetType, false),
+                new XamlAstClrTypeReference(selector, selector.TargetType, false),
                 AvaloniaXamlIlTargetTypeMetadataNode.ScopeTypes.Style);
         }
 
@@ -135,32 +139,32 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 
 
     
-    abstract class XamlIlSelectorNode : XamlIlAstNode, IXamlIlAstValueNode, IXamlIlAstEmitableNode
+    abstract class XamlIlSelectorNode : XamlAstNode, IXamlAstValueNode, IXamlAstEmitableNode<IXamlILEmitter, XamlILNodeEmitResult>
     {
         protected XamlIlSelectorNode Previous { get; }
-        public abstract IXamlIlType TargetType { get; }
+        public abstract IXamlType TargetType { get; }
 
         public XamlIlSelectorNode(XamlIlSelectorNode previous,
-            IXamlIlLineInfo info = null,
+            IXamlLineInfo info = null,
-            IXamlIlType selectorType = null) : base(info ?? previous)
+            IXamlType selectorType = null) : base(info ?? previous)
         {
             Previous = previous;
-            Type = selectorType == null ? previous.Type : new XamlIlAstClrTypeReference(this, selectorType, false);
+            Type = selectorType == null ? previous.Type : new XamlAstClrTypeReference(this, selectorType, false);
         }
 
-        public IXamlIlAstTypeReference Type { get; }
+        public IXamlAstTypeReference Type { get; }
 
-        public virtual XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
+        public virtual XamlILNodeEmitResult Emit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
         {
             if (Previous != null)
                 context.Emit(Previous, codeGen, Type.GetClrType());
             DoEmit(context, codeGen);
-            return XamlIlNodeEmitResult.Type(0, Type.GetClrType());
+            return XamlILNodeEmitResult.Type(0, Type.GetClrType());
         }
         
-        protected abstract void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen);
+        protected abstract void DoEmit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen);
 
-        protected void EmitCall(XamlIlEmitContext context, IXamlIlEmitter codeGen, Func<IXamlIlMethod, bool> method)
+        protected void EmitCall(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen, Func<IXamlMethod, bool> method)
         {
             var selectors = context.Configuration.TypeSystem.GetType("Avalonia.Styling.Selectors");
             var found = selectors.FindMethod(m => m.IsStatic && m.Parameters.Count > 0 && method(m));
@@ -170,27 +174,27 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
     
     class XamlIlSelectorInitialNode : XamlIlSelectorNode
     {
-        public XamlIlSelectorInitialNode(IXamlIlLineInfo info,
+        public XamlIlSelectorInitialNode(IXamlLineInfo info,
-            IXamlIlType selectorType) : base(null, info, selectorType)
+            IXamlType selectorType) : base(null, info, selectorType)
         {
         }
 
-        public override IXamlIlType TargetType => null;
+        public override IXamlType TargetType => null;
-        protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen) => codeGen.Ldnull();
+        protected override void DoEmit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen) => codeGen.Ldnull();
     }
 
     class XamlIlTypeSelector : XamlIlSelectorNode
     {
         public bool Concrete { get; }
 
-        public XamlIlTypeSelector(XamlIlSelectorNode previous, IXamlIlType type, bool concrete) : base(previous)
+        public XamlIlTypeSelector(XamlIlSelectorNode previous, IXamlType type, bool concrete) : base(previous)
         {
             TargetType = type;
             Concrete = concrete;
         }
 
-        public override IXamlIlType TargetType { get; }
+        public override IXamlType TargetType { get; }
-        protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
+        protected override void DoEmit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
         {
             var name = Concrete ? "OfType" : "Is";
             codeGen.Ldtype(TargetType);
@@ -217,8 +221,8 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
         }
 
 
-        public override IXamlIlType TargetType => Previous?.TargetType;
+        public override IXamlType TargetType => Previous?.TargetType;
-        protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
+        protected override void DoEmit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
         {
             codeGen.Ldstr(String);
             var name = _type.ToString();
@@ -242,8 +246,8 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
             _type = type;
         }
 
-        public override IXamlIlType TargetType => null;
+        public override IXamlType TargetType => null;
-        protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
+        protected override void DoEmit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
         {
             var name = _type.ToString();
             EmitCall(context, codeGen,
@@ -260,8 +264,8 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
             Argument = argument;
         }
 
-        public override IXamlIlType TargetType => Previous?.TargetType;
+        public override IXamlType TargetType => Previous?.TargetType;
-        protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
+        protected override void DoEmit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
         {
             context.Emit(Argument, codeGen, Type.GetClrType());
             EmitCall(context, codeGen,
@@ -272,22 +276,22 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
     class XamlIlPropertyEqualsSelector : XamlIlSelectorNode
     {
         public XamlIlPropertyEqualsSelector(XamlIlSelectorNode previous,
-            IXamlIlProperty property,
+            IXamlProperty property,
-            IXamlIlAstValueNode value)
+            IXamlAstValueNode value)
             : base(previous)
         {
             Property = property;
             Value = value;
         }
 
-        public IXamlIlProperty Property { get; set; }
+        public IXamlProperty Property { get; set; }
-        public IXamlIlAstValueNode Value { get; set; }
+        public IXamlAstValueNode Value { get; set; }
         
-        public override IXamlIlType TargetType => Previous?.TargetType;
+        public override IXamlType TargetType => Previous?.TargetType;
-        protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
+        protected override void DoEmit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
         {
             if (!XamlIlAvaloniaPropertyHelper.Emit(context, codeGen, Property))
-                throw new XamlIlLoadException(
+                throw new XamlLoadException(
                     $"{Property.Name} of {(Property.Setter ?? Property.Getter).DeclaringType.GetFqn()} doesn't seem to be an AvaloniaProperty",
                     this);
             context.Emit(Value, codeGen, context.Configuration.WellKnownTypes.Object);
@@ -302,7 +306,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
     class XamlIlOrSelectorNode : XamlIlSelectorNode
     {
         List<XamlIlSelectorNode> _selectors = new List<XamlIlSelectorNode>();
-        public XamlIlOrSelectorNode(IXamlIlLineInfo info, IXamlIlType selectorType) : base(null, info, selectorType)
+        public XamlIlOrSelectorNode(IXamlLineInfo info, IXamlType selectorType) : base(null, info, selectorType)
         {
         }
 
@@ -311,11 +315,11 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
             _selectors.Add(node);
         }
         
-        public override IXamlIlType TargetType
+        public override IXamlType TargetType
         {
             get
             {
-                IXamlIlType result = null;
+                IXamlType result = null;
 
                 foreach (var selector in _selectors)
                 {
@@ -340,10 +344,10 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
             }
         }
 
-        protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
+        protected override void DoEmit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
         {
             if (_selectors.Count == 0)
-                throw new XamlIlLoadException("Invalid selector count", this);
+                throw new XamlLoadException("Invalid selector count", this);
             if (_selectors.Count == 1)
             {
                 _selectors[0].Emit(context, codeGen);

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlSetterTransformer.cs

@@ -1,64 +1,68 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using XamlIl;
+using XamlX;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Emit;
-using XamlIl.Transform.Transformers;
+using XamlX.IL;
-using XamlIl.TypeSystem;
+using XamlX.Transform;
+using XamlX.Transform.Transformers;
+using XamlX.TypeSystem;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
-    class AvaloniaXamlIlSetterTransformer : IXamlIlAstTransformer
+    using XamlParseException = XamlX.XamlParseException;
+    using XamlLoadException = XamlX.XamlLoadException;
+    class AvaloniaXamlIlSetterTransformer : IXamlAstTransformer
     {
-        public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node)
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
         {
-            if (!(node is XamlIlAstObjectNode on
+            if (!(node is XamlAstObjectNode on
                   && on.Type.GetClrType().FullName == "Avalonia.Styling.Setter"))
                 return node;
 
-            var parent = context.ParentNodes().OfType<XamlIlAstObjectNode>()
+            var parent = context.ParentNodes().OfType<XamlAstObjectNode>()
                 .FirstOrDefault(p => p.Type.GetClrType().FullName == "Avalonia.Styling.Style");
             
             if (parent == null)
-                throw new XamlIlParseException(
+                throw new XamlParseException(
                     "Avalonia.Styling.Setter is only valid inside Avalonia.Styling.Style", node);
-            var selectorProperty = parent.Children.OfType<XamlIlAstXamlPropertyValueNode>()
+            var selectorProperty = parent.Children.OfType<XamlAstXamlPropertyValueNode>()
                 .FirstOrDefault(p => p.Property.GetClrProperty().Name == "Selector");
             if (selectorProperty == null)
-                throw new XamlIlParseException(
+                throw new XamlParseException(
                     "Can not find parent Style Selector", node);
             var selector = selectorProperty.Values.FirstOrDefault() as XamlIlSelectorNode;
             if (selector?.TargetType == null)
-                throw new XamlIlParseException(
+                throw new XamlParseException(
                     "Can not resolve parent Style Selector type", node);
 
 
-            var property = @on.Children.OfType<XamlIlAstXamlPropertyValueNode>()
+            var property = @on.Children.OfType<XamlAstXamlPropertyValueNode>()
                 .FirstOrDefault(x => x.Property.GetClrProperty().Name == "Property");
             if (property == null)
-                throw new XamlIlParseException("Setter without a property is not valid", node);
+                throw new XamlParseException("Setter without a property is not valid", node);
 
-            var propertyName = property.Values.OfType<XamlIlAstTextNode>().FirstOrDefault()?.Text;
+            var propertyName = property.Values.OfType<XamlAstTextNode>().FirstOrDefault()?.Text;
             if (propertyName == null)
-                throw new XamlIlParseException("Setter.Property must be a string", node);
+                throw new XamlParseException("Setter.Property must be a string", node);
 
 
             var avaloniaPropertyNode = XamlIlAvaloniaPropertyHelper.CreateNode(context, propertyName,
-                new XamlIlAstClrTypeReference(selector, selector.TargetType, false), property.Values[0]);
+                new XamlAstClrTypeReference(selector, selector.TargetType, false), property.Values[0]);
-            property.Values = new List<IXamlIlAstValueNode>
+            property.Values = new List<IXamlAstValueNode>
             {
                 avaloniaPropertyNode
             };
 
             var valueProperty = on.Children
-                .OfType<XamlIlAstXamlPropertyValueNode>().FirstOrDefault(p => p.Property.GetClrProperty().Name == "Value");
+                .OfType<XamlAstXamlPropertyValueNode>().FirstOrDefault(p => p.Property.GetClrProperty().Name == "Value");
-            if (valueProperty?.Values?.Count == 1 && valueProperty.Values[0] is XamlIlAstTextNode)
+            if (valueProperty?.Values?.Count == 1 && valueProperty.Values[0] is XamlAstTextNode)
             {
                 var propType = avaloniaPropertyNode.AvaloniaPropertyType;
-                if (!XamlIlTransformHelpers.TryGetCorrectlyTypedValue(context, valueProperty.Values[0],
+                if (!XamlTransformHelpers.TryGetCorrectlyTypedValue(context, valueProperty.Values[0],
                         propType, out var converted))
-                    throw new XamlIlParseException(
+                    throw new XamlParseException(
                         $"Unable to convert property value to {propType.GetFqn()}",
                         valueProperty.Values[0]);
 
@@ -69,9 +73,9 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
             return node;
         }
 
-        class SetterValueProperty : XamlIlAstClrProperty
+        class SetterValueProperty : XamlAstClrProperty
         {
-            public SetterValueProperty(IXamlIlLineInfo line, IXamlIlType setterType, IXamlIlType targetType,
+            public SetterValueProperty(IXamlLineInfo line, IXamlType setterType, IXamlType targetType,
                 AvaloniaXamlIlWellKnownTypes types)
                 : base(line, "Value", setterType, null)
             {
@@ -82,21 +86,21 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                 Setters.Add(new XamlIlDirectCallPropertySetter(method, targetType));
             }
             
-            class XamlIlDirectCallPropertySetter : IXamlIlPropertySetter
+            class XamlIlDirectCallPropertySetter : IXamlPropertySetter, IXamlEmitablePropertySetter<IXamlILEmitter>
             {
-                private readonly IXamlIlMethod _method;
+                private readonly IXamlMethod _method;
-                private readonly IXamlIlType _type;
+                private readonly IXamlType _type;
-                public IXamlIlType TargetType { get; }
+                public IXamlType TargetType { get; }
                 public PropertySetterBinderParameters BinderParameters { get; } = new PropertySetterBinderParameters();
-                public IReadOnlyList<IXamlIlType> Parameters { get; }
+                public IReadOnlyList<IXamlType> Parameters { get; }
-                public void Emit(IXamlIlEmitter codegen)
+                public void Emit(IXamlILEmitter codegen)
                 {
                     if (_type.IsValueType)
                         codegen.Box(_type);
                     codegen.EmitCall(_method, true);
                 }
 
-                public XamlIlDirectCallPropertySetter(IXamlIlMethod method, IXamlIlType type)
+                public XamlIlDirectCallPropertySetter(IXamlMethod method, IXamlType type)
                 {
                     _method = method;
                     _type = type;

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransformInstanceAttachedProperties.cs

@@ -1,20 +1,22 @@
 using System.Collections.Generic;
 using System.Linq;
-using XamlIl;
+using XamlX;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Emit;
-using XamlIl.TypeSystem;
+using XamlX.IL;
+using XamlX.Transform;
+using XamlX.TypeSystem;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
-    class AvaloniaXamlIlTransformInstanceAttachedProperties : IXamlIlAstTransformer
+    class AvaloniaXamlIlTransformInstanceAttachedProperties : IXamlAstTransformer
     {
 
-        public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node)
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
         {
-            if (node is XamlIlAstNamePropertyReference prop 
+            if (node is XamlAstNamePropertyReference prop 
-                && prop.TargetType is XamlIlAstClrTypeReference targetRef 
+                && prop.TargetType is XamlAstClrTypeReference targetRef 
-                && prop.DeclaringType is XamlIlAstClrTypeReference declaringRef)
+                && prop.DeclaringType is XamlAstClrTypeReference declaringRef)
             {
                 // Target and declared type aren't assignable but both inherit from AvaloniaObject
                 var avaloniaObject = context.Configuration.TypeSystem.FindType("Avalonia.AvaloniaObject");
@@ -70,21 +72,21 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
             return node;
         }
 
-        class AvaloniaAttachedInstanceProperty : XamlIlAstClrProperty, IXamlIlAvaloniaProperty
+        class AvaloniaAttachedInstanceProperty : XamlAstClrProperty, IXamlIlAvaloniaProperty
         {
-            private readonly XamlIlTransformerConfiguration _config;
+            private readonly TransformerConfiguration _config;
-            private readonly IXamlIlType _declaringType;
+            private readonly IXamlType _declaringType;
-            private readonly IXamlIlType _avaloniaPropertyType;
+            private readonly IXamlType _avaloniaPropertyType;
-            private readonly IXamlIlType _avaloniaObject;
+            private readonly IXamlType _avaloniaObject;
-            private readonly IXamlIlField _field;
+            private readonly IXamlField _field;
-
+
-            public AvaloniaAttachedInstanceProperty(XamlIlAstNamePropertyReference prop,
+            public AvaloniaAttachedInstanceProperty(XamlAstNamePropertyReference prop,
-                XamlIlTransformerConfiguration config,
+                TransformerConfiguration config,
-                IXamlIlType declaringType,
+                IXamlType declaringType,
-                IXamlIlType type,
+                IXamlType type,
-                IXamlIlType avaloniaPropertyType,
+                IXamlType avaloniaPropertyType,
-                IXamlIlType avaloniaObject,
+                IXamlType avaloniaObject,
-                IXamlIlField field) : base(prop, prop.Name,
+                IXamlField field) : base(prop, prop.Name,
                 declaringType, null)
             
             
@@ -104,11 +106,11 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                 Getter = new GetterMethod(this);
             }
 
-            public IXamlIlType PropertyType { get;  }
+            public IXamlType PropertyType { get;  }
 
-            public IXamlIlField AvaloniaProperty => _field;
+            public IXamlField AvaloniaProperty => _field;
             
-            class SetterMethod : IXamlIlPropertySetter
+            class SetterMethod : IXamlPropertySetter, IXamlEmitablePropertySetter<IXamlILEmitter>
             {
                 private readonly AvaloniaAttachedInstanceProperty _parent;
 
@@ -118,10 +120,10 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                     Parameters = new[] {_parent._avaloniaObject, _parent.PropertyType};
                 }
 
-                public IXamlIlType TargetType => _parent.DeclaringType;
+                public IXamlType TargetType => _parent.DeclaringType;
                 public PropertySetterBinderParameters BinderParameters { get; } = new PropertySetterBinderParameters();
-                public IReadOnlyList<IXamlIlType> Parameters { get; }
+                public IReadOnlyList<IXamlType> Parameters { get; }
-                public void Emit(IXamlIlEmitter emitter)
+                public void Emit(IXamlILEmitter emitter)
                 {
                     var so = _parent._config.WellKnownTypes.Object;
                     var method = _parent._avaloniaObject
@@ -133,7 +135,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                                          && m.Parameters[2].IsEnum
                         );
                     if (method == null)
-                        throw new XamlIlTypeSystemException(
+                        throw new XamlTypeSystemException(
                             "Unable to find SetValue(AvaloniaProperty, object, BindingPriority) on AvaloniaObject");
                     using (var loc = emitter.LocalsPool.GetLocal(_parent.PropertyType))
                         emitter
@@ -150,7 +152,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                 }
             }
 
-            class GetterMethod :  IXamlIlCustomEmitMethod
+            class GetterMethod :  IXamlCustomEmitMethod<IXamlILEmitter>
             {
                 public GetterMethod(AvaloniaAttachedInstanceProperty parent) 
                 {
@@ -163,16 +165,16 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                 public bool IsPublic => true;
                 public bool IsStatic => true;
                 public string Name { get; protected set; }
-                public IXamlIlType DeclaringType { get; }
+                public IXamlType DeclaringType { get; }
-                public IXamlIlMethod MakeGenericMethod(IReadOnlyList<IXamlIlType> typeArguments) 
+                public IXamlMethod MakeGenericMethod(IReadOnlyList<IXamlType> typeArguments) 
                     => throw new System.NotSupportedException();
 
 
-                public bool Equals(IXamlIlMethod other) =>
+                public bool Equals(IXamlMethod other) =>
                     other is GetterMethod m && m.Name == Name && m.DeclaringType.Equals(DeclaringType);
-                public IXamlIlType ReturnType => Parent.PropertyType;
+                public IXamlType ReturnType => Parent.PropertyType;
-                public IReadOnlyList<IXamlIlType> Parameters { get; }
+                public IReadOnlyList<IXamlType> Parameters { get; }
-                public void EmitCall(IXamlIlEmitter emitter)
+                public void EmitCall(IXamlILEmitter emitter)
                 {
                     var method = Parent._avaloniaObject
                         .FindMethod(m => m.IsPublic && !m.IsStatic && m.Name == "GetValue"
@@ -180,7 +182,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                                          m.Parameters.Count == 1
                                          && m.Parameters[0].Equals(Parent._avaloniaPropertyType));
                     if (method == null)
-                        throw new XamlIlTypeSystemException(
+                        throw new XamlTypeSystemException(
                             "Unable to find T GetValue<T>(AvaloniaProperty<T>) on AvaloniaObject");
                     emitter
                         .Ldsfld(Parent._field)

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransitionsTypeMetadataTransformer.cs

@@ -1,17 +1,17 @@
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Transform;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
-    class AvaloniaXamlIlTransitionsTypeMetadataTransformer : IXamlIlAstTransformer
+    class AvaloniaXamlIlTransitionsTypeMetadataTransformer : IXamlAstTransformer
     {
-        public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node)
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
         {
-            if (node is XamlIlAstObjectNode on)
+            if (node is XamlAstObjectNode on)
             {
                 foreach (var ch in on.Children)
                 {
-                    if (ch is XamlIlAstXamlPropertyValueNode pn
+                    if (ch is XamlAstXamlPropertyValueNode pn
                         && pn.Property.GetClrProperty().Getter?.ReturnType.Equals(context.GetAvaloniaTypes().Transitions) == true)
                     {
                         for (var c = 0; c < pn.Values.Count; c++)

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlWellKnownTypes.cs

@@ -1,52 +1,54 @@
-using XamlIl.Transform;
+using XamlX.Emit;
-using XamlIl.TypeSystem;
+using XamlX.IL;
+using XamlX.Transform;
+using XamlX.TypeSystem;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
     class AvaloniaXamlIlWellKnownTypes
     {
-        public IXamlIlType AvaloniaObject { get; }
+        public IXamlType AvaloniaObject { get; }
-        public IXamlIlType IAvaloniaObject { get; }
+        public IXamlType IAvaloniaObject { get; }
-        public IXamlIlType BindingPriority { get; }
+        public IXamlType BindingPriority { get; }
-        public IXamlIlType AvaloniaObjectExtensions { get; }
+        public IXamlType AvaloniaObjectExtensions { get; }
-        public IXamlIlType AvaloniaProperty { get; }
+        public IXamlType AvaloniaProperty { get; }
-        public IXamlIlType AvaloniaPropertyT { get; }
+        public IXamlType AvaloniaPropertyT { get; }
-        public IXamlIlType IBinding { get; }
+        public IXamlType IBinding { get; }
-        public IXamlIlMethod AvaloniaObjectBindMethod { get; }
+        public IXamlMethod AvaloniaObjectBindMethod { get; }
-        public IXamlIlMethod AvaloniaObjectSetValueMethod { get; }
+        public IXamlMethod AvaloniaObjectSetValueMethod { get; }
-        public IXamlIlType IDisposable { get; }
+        public IXamlType IDisposable { get; }
-        public XamlIlTypeWellKnownTypes XamlIlTypes { get; }
+        public XamlTypeWellKnownTypes XamlIlTypes { get; }
-        public XamlIlLanguageTypeMappings XamlIlMappings { get; }
+        public XamlLanguageTypeMappings XamlIlMappings { get; }
-        public IXamlIlType Transitions { get; }
+        public IXamlType Transitions { get; }
-        public IXamlIlType AssignBindingAttribute { get; }
+        public IXamlType AssignBindingAttribute { get; }
-        public IXamlIlType UnsetValueType { get; }
+        public IXamlType UnsetValueType { get; }
-        public IXamlIlType StyledElement { get; }
+        public IXamlType StyledElement { get; }
-        public IXamlIlType NameScope { get; }
+        public IXamlType NameScope { get; }
-        public IXamlIlMethod NameScopeSetNameScope { get; }
+        public IXamlMethod NameScopeSetNameScope { get; }
-        public IXamlIlType INameScope { get; }
+        public IXamlType INameScope { get; }
-        public IXamlIlMethod INameScopeRegister { get; }
+        public IXamlMethod INameScopeRegister { get; }
-        public IXamlIlMethod INameScopeComplete { get; }
+        public IXamlMethod INameScopeComplete { get; }
         
-        public AvaloniaXamlIlWellKnownTypes(XamlIlAstTransformationContext ctx)
+        public AvaloniaXamlIlWellKnownTypes(TransformerConfiguration config)
         {
-            XamlIlTypes = ctx.Configuration.WellKnownTypes;
+            XamlIlTypes = config.WellKnownTypes;
-            XamlIlMappings = ctx.Configuration.TypeMappings;
+            XamlIlMappings = config.TypeMappings;
-            AvaloniaObject = ctx.Configuration.TypeSystem.GetType("Avalonia.AvaloniaObject");
+            AvaloniaObject = config.TypeSystem.GetType("Avalonia.AvaloniaObject");
-            IAvaloniaObject = ctx.Configuration.TypeSystem.GetType("Avalonia.IAvaloniaObject");
+            IAvaloniaObject = config.TypeSystem.GetType("Avalonia.IAvaloniaObject");
-            AvaloniaObjectExtensions = ctx.Configuration.TypeSystem.GetType("Avalonia.AvaloniaObjectExtensions");
+            AvaloniaObjectExtensions = config.TypeSystem.GetType("Avalonia.AvaloniaObjectExtensions");
-            AvaloniaProperty = ctx.Configuration.TypeSystem.GetType("Avalonia.AvaloniaProperty");
+            AvaloniaProperty = config.TypeSystem.GetType("Avalonia.AvaloniaProperty");
-            AvaloniaPropertyT = ctx.Configuration.TypeSystem.GetType("Avalonia.AvaloniaProperty`1");
+            AvaloniaPropertyT = config.TypeSystem.GetType("Avalonia.AvaloniaProperty`1");
-            BindingPriority = ctx.Configuration.TypeSystem.GetType("Avalonia.Data.BindingPriority");
+            BindingPriority = config.TypeSystem.GetType("Avalonia.Data.BindingPriority");
-            IBinding = ctx.Configuration.TypeSystem.GetType("Avalonia.Data.IBinding");
+            IBinding = config.TypeSystem.GetType("Avalonia.Data.IBinding");
-            IDisposable = ctx.Configuration.TypeSystem.GetType("System.IDisposable");
+            IDisposable = config.TypeSystem.GetType("System.IDisposable");
-            Transitions = ctx.Configuration.TypeSystem.GetType("Avalonia.Animation.Transitions");
+            Transitions = config.TypeSystem.GetType("Avalonia.Animation.Transitions");
-            AssignBindingAttribute = ctx.Configuration.TypeSystem.GetType("Avalonia.Data.AssignBindingAttribute");
+            AssignBindingAttribute = config.TypeSystem.GetType("Avalonia.Data.AssignBindingAttribute");
             AvaloniaObjectBindMethod = AvaloniaObjectExtensions.FindMethod("Bind", IDisposable, false, IAvaloniaObject,
                 AvaloniaProperty,
-                IBinding, ctx.Configuration.WellKnownTypes.Object);
+                IBinding, config.WellKnownTypes.Object);
-            UnsetValueType = ctx.Configuration.TypeSystem.GetType("Avalonia.UnsetValueType");
+            UnsetValueType = config.TypeSystem.GetType("Avalonia.UnsetValueType");
-            StyledElement = ctx.Configuration.TypeSystem.GetType("Avalonia.StyledElement");
+            StyledElement = config.TypeSystem.GetType("Avalonia.StyledElement");
-            INameScope = ctx.Configuration.TypeSystem.GetType("Avalonia.Controls.INameScope");
+            INameScope = config.TypeSystem.GetType("Avalonia.Controls.INameScope");
             INameScopeRegister = INameScope.GetMethod(
                 new FindMethodMethodSignature("Register", XamlIlTypes.Void,
                      XamlIlTypes.String, XamlIlTypes.Object)
@@ -58,7 +60,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
                 {
                     IsStatic = false, DeclaringOnly = true, IsExactMatch = true
                 });
-            NameScope = ctx.Configuration.TypeSystem.GetType("Avalonia.Controls.NameScope");
+            NameScope = config.TypeSystem.GetType("Avalonia.Controls.NameScope");
             NameScopeSetNameScope = NameScope.GetMethod(new FindMethodMethodSignature("SetNameScope",
                 XamlIlTypes.Void, StyledElement, INameScope) {IsStatic = true});
 
@@ -70,11 +72,19 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 
     static class AvaloniaXamlIlWellKnownTypesExtensions
     {
-        public static AvaloniaXamlIlWellKnownTypes GetAvaloniaTypes(this XamlIlAstTransformationContext ctx)
+        public static AvaloniaXamlIlWellKnownTypes GetAvaloniaTypes(this AstTransformationContext ctx)
         {
             if (ctx.TryGetItem<AvaloniaXamlIlWellKnownTypes>(out var rv))
                 return rv;
-            ctx.SetItem(rv = new AvaloniaXamlIlWellKnownTypes(ctx));
+            ctx.SetItem(rv = new AvaloniaXamlIlWellKnownTypes(ctx.Configuration));
+            return rv;
+        }
+
+        public static AvaloniaXamlIlWellKnownTypes GetAvaloniaTypes(this XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> ctx)
+        {
+            if (ctx.TryGetItem<AvaloniaXamlIlWellKnownTypes>(out var rv))
+                return rv;
+            ctx.SetItem(rv = new AvaloniaXamlIlWellKnownTypes(ctx.Configuration));
             return rv;
         }
     }

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/IgnoredDirectivesTransformer.cs

@@ -1,17 +1,17 @@
 using System.Linq;
-using XamlIl;
+using XamlX;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Transform;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
-    class IgnoredDirectivesTransformer : IXamlIlAstTransformer
+    class IgnoredDirectivesTransformer : IXamlAstTransformer
     {
-        public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node)
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
         {
-            if (node is XamlIlAstObjectNode no)
+            if (node is XamlAstObjectNode no)
             {
-                foreach (var d in no.Children.OfType<XamlIlAstXmlDirective>().ToList())
+                foreach (var d in no.Children.OfType<XamlAstXmlDirective>().ToList())
                 {
                     if (d.Namespace == XamlNamespaces.Xaml2006)
                     {

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/XNameTransformer.cs

@@ -1,30 +1,29 @@
-using XamlIl;
+using XamlX;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Transform;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers
 {
-    class XNameTransformer : IXamlIlAstTransformer
+    class XNameTransformer : IXamlAstTransformer
     {
-        
         /// <summary>
         /// Converts x:Name directives to regular Name assignments
         /// </summary>
         /// <returns></returns>
-        public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node)
+        public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
         {
-            if (node is XamlIlAstObjectNode on)
+            if (node is XamlAstObjectNode on)
             {
                 for (var c =0; c< on.Children.Count;c++)
                 {
                     var ch = on.Children[c];
-                    if (ch is XamlIlAstXmlDirective d
+                    if (ch is XamlAstXmlDirective d
                         && d.Namespace == XamlNamespaces.Xaml2006
                         && d.Name == "Name")
 
 
-                        on.Children[c] = new XamlIlAstXamlPropertyValueNode(d,
+                        on.Children[c] = new XamlAstXamlPropertyValueNode(d,
-                            new XamlIlAstNamePropertyReference(d, on.Type, "Name", on.Type),
+                            new XamlAstNamePropertyReference(d, on.Type, "Name", on.Type),
                             d.Values);
                 }
             }

src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlAvaloniaPropertyHelper.cs

@@ -5,17 +5,22 @@ using System.Xml;
 using Avalonia.Markup.Xaml.Parsers;
 using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers;
 using Avalonia.Utilities;
-using XamlIl;
+using XamlX;
-using XamlIl.Ast;
+using XamlX.Ast;
-using XamlIl.Transform;
+using XamlX.Transform;
-using XamlIl.Transform.Transformers;
+using XamlX.Transform.Transformers;
-using XamlIl.TypeSystem;
+using XamlX.TypeSystem;
+using XamlX.Emit;
+using XamlX.IL;
+
+using XamlIlEmitContext = XamlX.Emit.XamlEmitContext<XamlX.IL.IXamlILEmitter, XamlX.IL.XamlILNodeEmitResult>;
+using IXamlIlAstEmitableNode = XamlX.Emit.IXamlAstEmitableNode<XamlX.IL.IXamlILEmitter, XamlX.IL.XamlILNodeEmitResult>;
 
 namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
 {
     class XamlIlAvaloniaPropertyHelper
     {
-        public static bool Emit(XamlIlEmitContext context, IXamlIlEmitter emitter, XamlIlAstClrProperty property)
+        public static bool Emit(XamlIlEmitContext context, IXamlILEmitter emitter, XamlAstClrProperty property)
         {
             if (property is IXamlIlAvaloniaProperty ap)
             {
@@ -32,7 +37,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
             return true;
         }
         
-        public static bool Emit(XamlIlEmitContext context, IXamlIlEmitter emitter, IXamlIlProperty property)
+        public static bool Emit(XamlIlEmitContext context, IXamlILEmitter emitter, IXamlProperty property)
         {
             var type = (property.Getter ?? property.Setter).DeclaringType;
             var name = property.Name + "Property";
@@ -44,16 +49,16 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
             return true;
         }
 
-        public static IXamlIlAvaloniaPropertyNode CreateNode(XamlIlAstTransformationContext context,
+        public static IXamlIlAvaloniaPropertyNode CreateNode(AstTransformationContext context,
-            string propertyName, IXamlIlAstTypeReference selectorTypeReference, IXamlIlLineInfo lineInfo)
+            string propertyName, IXamlAstTypeReference selectorTypeReference, IXamlLineInfo lineInfo)
         {
-            XamlIlAstNamePropertyReference forgedReference;
+            XamlAstNamePropertyReference forgedReference;
             
             var parser = new PropertyParser();
             
             var parsedPropertyName = parser.Parse(new CharacterReader(propertyName.AsSpan()));
             if(parsedPropertyName.owner == null)
-                forgedReference = new XamlIlAstNamePropertyReference(lineInfo, selectorTypeReference,
+                forgedReference = new XamlAstNamePropertyReference(lineInfo, selectorTypeReference,
                     propertyName, selectorTypeReference);
             else
             {
@@ -62,19 +67,19 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                     xmlOwner += ":";
                 xmlOwner += parsedPropertyName.owner;
                 
-                var tref = XamlIlTypeReferenceResolver.ResolveType(context, xmlOwner, false, lineInfo, true);
+                var tref = TypeReferenceResolver.ResolveType(context, xmlOwner, false, lineInfo, true);
 
                 var propertyFieldName = parsedPropertyName.name + "Property";
                 var found = tref.Type.GetAllFields()
                     .FirstOrDefault(f => f.IsStatic && f.IsPublic && f.Name == propertyFieldName);
                 if (found == null)
-                    throw new XamlIlParseException(
+                    throw new XamlX.XamlParseException(
                         $"Unable to find {propertyFieldName} field on type {tref.Type.GetFullName()}", lineInfo);
                 return new XamlIlAvaloniaPropertyFieldNode(context.GetAvaloniaTypes(), lineInfo, found);
             }
 
             var clrProperty =
-                ((XamlIlAstClrProperty)new XamlIlPropertyReferenceResolver().Transform(context,
+                ((XamlAstClrProperty)new PropertyReferenceResolver().Transform(context,
                     forgedReference));
             return new XamlIlAvaloniaPropertyNode(lineInfo,
                 context.Configuration.TypeSystem.GetType("Avalonia.AvaloniaProperty"),
@@ -82,40 +87,40 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
         }
     }
 
-    interface IXamlIlAvaloniaPropertyNode : IXamlIlAstValueNode
+    interface IXamlIlAvaloniaPropertyNode : IXamlAstValueNode
     {
-        IXamlIlType AvaloniaPropertyType { get; }
+        IXamlType AvaloniaPropertyType { get; }
     }
     
-    class XamlIlAvaloniaPropertyNode : XamlIlAstNode, IXamlIlAstValueNode, IXamlIlAstEmitableNode, IXamlIlAvaloniaPropertyNode
+    class XamlIlAvaloniaPropertyNode : XamlAstNode, IXamlAstValueNode, IXamlIlAstEmitableNode, IXamlIlAvaloniaPropertyNode
     {
-        public XamlIlAvaloniaPropertyNode(IXamlIlLineInfo lineInfo, IXamlIlType type, XamlIlAstClrProperty property) : base(lineInfo)
+        public XamlIlAvaloniaPropertyNode(IXamlLineInfo lineInfo, IXamlType type, XamlAstClrProperty property) : base(lineInfo)
         {
-            Type = new XamlIlAstClrTypeReference(this, type, false);
+            Type = new XamlAstClrTypeReference(this, type, false);
             Property = property;
             AvaloniaPropertyType = Property.Getter?.ReturnType
                                    ?? Property.Setters.First().Parameters[0];
         }
 
-        public XamlIlAstClrProperty Property { get; }
+        public XamlAstClrProperty Property { get; }
 
-        public IXamlIlAstTypeReference Type { get; }
+        public IXamlAstTypeReference Type { get; }
-        public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
+        public XamlILNodeEmitResult Emit(XamlIlEmitContext context, IXamlILEmitter codeGen)
         {
             if (!XamlIlAvaloniaPropertyHelper.Emit(context, codeGen, Property))
-                throw new XamlIlLoadException(Property.Name + " is not an AvaloniaProperty", this);
+                throw new XamlX.XamlLoadException(Property.Name + " is not an AvaloniaProperty", this);
-            return XamlIlNodeEmitResult.Type(0, Type.GetClrType());
+            return XamlILNodeEmitResult.Type(0, Type.GetClrType());
         }
 
-        public IXamlIlType AvaloniaPropertyType { get; }
+        public IXamlType AvaloniaPropertyType { get; }
     }
 
-    class XamlIlAvaloniaPropertyFieldNode : XamlIlAstNode, IXamlIlAstValueNode, IXamlIlAstEmitableNode, IXamlIlAvaloniaPropertyNode
+    class XamlIlAvaloniaPropertyFieldNode : XamlAstNode, IXamlAstValueNode, IXamlIlAstEmitableNode, IXamlIlAvaloniaPropertyNode
     {
-        private readonly IXamlIlField _field;
+        private readonly IXamlField _field;
 
         public XamlIlAvaloniaPropertyFieldNode(AvaloniaXamlIlWellKnownTypes types,
-            IXamlIlLineInfo lineInfo, IXamlIlField field) : base(lineInfo)
+            IXamlLineInfo lineInfo, IXamlField field) : base(lineInfo)
         {
             _field = field;
             var avaloniaPropertyType = field.FieldType;
@@ -130,7 +135,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                 avaloniaPropertyType = avaloniaPropertyType.BaseType;
             }
 
-            throw new XamlIlParseException(
+            throw new XamlX.XamlParseException(
                 $"{field.Name}'s type {field.FieldType} doesn't inherit from AvaloniaProperty<T>, make sure to use typed properties",
                 lineInfo);
 
@@ -138,25 +143,25 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
         
         
 
-        public IXamlIlAstTypeReference Type => new XamlIlAstClrTypeReference(this, _field.FieldType, false);
+        public IXamlAstTypeReference Type => new XamlAstClrTypeReference(this, _field.FieldType, false);
-        public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
+        public XamlILNodeEmitResult Emit(XamlIlEmitContext context, IXamlILEmitter codeGen)
         {
             codeGen.Ldsfld(_field);
-            return XamlIlNodeEmitResult.Type(0, _field.FieldType);
+            return XamlILNodeEmitResult.Type(0, _field.FieldType);
         }
 
-        public IXamlIlType AvaloniaPropertyType { get; }
+        public IXamlType AvaloniaPropertyType { get; }
     }
 
     interface IXamlIlAvaloniaProperty
     {
-        IXamlIlField AvaloniaProperty { get; }
+        IXamlField AvaloniaProperty { get; }
     }
     
-    class XamlIlAvaloniaProperty : XamlIlAstClrProperty, IXamlIlAvaloniaProperty
+    class XamlIlAvaloniaProperty : XamlAstClrProperty, IXamlIlAvaloniaProperty
     {
-        public IXamlIlField AvaloniaProperty { get; }
+        public IXamlField AvaloniaProperty { get; }
-        public XamlIlAvaloniaProperty(XamlIlAstClrProperty original, IXamlIlField field,
+        public XamlIlAvaloniaProperty(XamlAstClrProperty original, IXamlField field,
             AvaloniaXamlIlWellKnownTypes types)
             :base(original, original.Name, original.DeclaringType, original.Getter, original.Setters)
         {
@@ -168,41 +173,41 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
             Setters.Insert(0, new UnsetValueSetter(types, original.DeclaringType, field));
         }
 
-        abstract class AvaloniaPropertyCustomSetter : IXamlIlPropertySetter
+        abstract class AvaloniaPropertyCustomSetter : IXamlPropertySetter, IXamlEmitablePropertySetter<IXamlILEmitter>
         {
             protected AvaloniaXamlIlWellKnownTypes Types;
-            protected IXamlIlField AvaloniaProperty;
+            protected IXamlField AvaloniaProperty;
 
             public AvaloniaPropertyCustomSetter(AvaloniaXamlIlWellKnownTypes types,
-                IXamlIlType declaringType,
+                IXamlType declaringType,
-                IXamlIlField avaloniaProperty)
+                IXamlField avaloniaProperty)
             {
                 Types = types;
                 AvaloniaProperty = avaloniaProperty;
                 TargetType = declaringType;
             }
 
-            public IXamlIlType TargetType { get; }
+            public IXamlType TargetType { get; }
 
             public PropertySetterBinderParameters BinderParameters { get; } = new PropertySetterBinderParameters
             {
                 AllowXNull = false
             };
 
-            public IReadOnlyList<IXamlIlType> Parameters { get; set; }
+            public IReadOnlyList<IXamlType> Parameters { get; set; }
-            public abstract void Emit(IXamlIlEmitter codegen);
+            public abstract void Emit(IXamlILEmitter codegen);
         }
 
         class BindingSetter : AvaloniaPropertyCustomSetter
         {
             public BindingSetter(AvaloniaXamlIlWellKnownTypes types,
-                IXamlIlType declaringType,
+                IXamlType declaringType,
-                IXamlIlField avaloniaProperty) : base(types, declaringType, avaloniaProperty)
+                IXamlField avaloniaProperty) : base(types, declaringType, avaloniaProperty)
             {
                 Parameters = new[] {types.IBinding};
             }
 
-            public override void Emit(IXamlIlEmitter emitter)
+            public override void Emit(IXamlILEmitter emitter)
             {
                 using (var bloc = emitter.LocalsPool.GetLocal(Types.IBinding))
                     emitter
@@ -217,13 +222,13 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
 
         class UnsetValueSetter : AvaloniaPropertyCustomSetter
         {
-            public UnsetValueSetter(AvaloniaXamlIlWellKnownTypes types, IXamlIlType declaringType, IXamlIlField avaloniaProperty) 
+            public UnsetValueSetter(AvaloniaXamlIlWellKnownTypes types, IXamlType declaringType, IXamlField avaloniaProperty) 
                 : base(types, declaringType, avaloniaProperty)
             {
                 Parameters = new[] {types.UnsetValueType};
             }
 
-            public override void Emit(IXamlIlEmitter codegen)
+            public override void Emit(IXamlILEmitter codegen)
             {
                 var unsetValue = Types.AvaloniaProperty.Fields.First(f => f.Name == "UnsetValue");
                 codegen

src/Markup/Avalonia.Markup.Xaml/XamlIl/xamlil.github

@@ -1 +1 @@
-Subproject commit 068162245473ec39ee36da12150e928072b96403
+Subproject commit 0028377ce7c7dc21f9fe71b45f62a95991b1ab58

src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs

@@ -989,6 +989,12 @@ namespace Avalonia.Win32.Interop
             }
         }
 
+        [DllImport("user32.dll")]
+        public static extern IntPtr GetSystemMenu(IntPtr hWnd, bool bRevert);
+
+        [DllImport("user32.dll")]
+        public static extern bool EnableMenuItem(IntPtr hMenu, uint uIDEnableItem, uint uEnable);
+
         [DllImport("user32.dll", SetLastError = true)]
         public static extern bool GetWindowPlacement(IntPtr hWnd, ref WINDOWPLACEMENT lpwndpl);
 
@@ -1317,6 +1323,9 @@ namespace Avalonia.Win32.Interop
         [DllImport("dwmapi.dll")]
         public static extern int DwmIsCompositionEnabled(out bool enabled);
 
+        [DllImport("dwmapi.dll")]
+        public static extern bool DwmDefWindowProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam, ref IntPtr plResult);
+        
         [DllImport("dwmapi.dll")]
         public static extern void DwmEnableBlurBehindWindow(IntPtr hwnd, ref DWM_BLURBEHIND blurBehind);
 

src/Windows/Avalonia.Win32/WindowImpl.AppWndProc.cs

@@ -0,0 +1,539 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using Avalonia.Controls;
+using Avalonia.Controls.Platform;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Win32.Input;
+using static Avalonia.Win32.Interop.UnmanagedMethods;
+
+namespace Avalonia.Win32
+{
+    public partial class WindowImpl
+    {
+        [SuppressMessage("Microsoft.StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation",
+            Justification = "Using Win32 naming for consistency.")]
+        protected virtual unsafe IntPtr AppWndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
+        {
+            const double wheelDelta = 120.0;
+            uint timestamp = unchecked((uint)GetMessageTime());
+
+            RawInputEventArgs e = null;
+            var shouldTakeFocus = false;
+
+            switch ((WindowsMessage)msg)
+            {
+                case WindowsMessage.WM_ACTIVATE:
+                    {
+                        var wa = (WindowActivate)(ToInt32(wParam) & 0xffff);
+
+                        switch (wa)
+                        {
+                            case WindowActivate.WA_ACTIVE:
+                            case WindowActivate.WA_CLICKACTIVE:
+                                {
+                                    Activated?.Invoke();
+                                    break;
+                                }
+
+                            case WindowActivate.WA_INACTIVE:
+                                {
+                                    Deactivated?.Invoke();
+                                    break;
+                                }
+                        }
+
+                        return IntPtr.Zero;
+                    }
+
+                case WindowsMessage.WM_NCCALCSIZE:
+                    {
+                        if (ToInt32(wParam) == 1 && !HasFullDecorations || _isClientAreaExtended)
+                        {
+                            return IntPtr.Zero;
+                        }
+
+                        break;
+                    }
+
+                case WindowsMessage.WM_CLOSE:
+                    {
+                        bool? preventClosing = Closing?.Invoke();
+                        if (preventClosing == true)
+                        {
+                            return IntPtr.Zero;
+                        }
+
+                        break;
+                    }
+
+                case WindowsMessage.WM_DESTROY:
+                    {
+                        //Window doesn't exist anymore
+                        _hwnd = IntPtr.Zero;
+                        //Remove root reference to this class, so unmanaged delegate can be collected
+                        s_instances.Remove(this);
+                        Closed?.Invoke();
+
+                        _mouseDevice.Dispose();
+                        _touchDevice?.Dispose();
+                        //Free other resources
+                        Dispose();
+                        return IntPtr.Zero;
+                    }
+
+                case WindowsMessage.WM_DPICHANGED:
+                    {
+                        var dpi = ToInt32(wParam) & 0xffff;
+                        var newDisplayRect = Marshal.PtrToStructure<RECT>(lParam);
+                        _scaling = dpi / 96.0;
+                        ScalingChanged?.Invoke(_scaling);
+                        SetWindowPos(hWnd,
+                            IntPtr.Zero,
+                            newDisplayRect.left,
+                            newDisplayRect.top,
+                            newDisplayRect.right - newDisplayRect.left,
+                            newDisplayRect.bottom - newDisplayRect.top,
+                            SetWindowPosFlags.SWP_NOZORDER |
+                            SetWindowPosFlags.SWP_NOACTIVATE);
+                        return IntPtr.Zero;
+                    }
+
+                case WindowsMessage.WM_KEYDOWN:
+                case WindowsMessage.WM_SYSKEYDOWN:
+                    {
+                        e = new RawKeyEventArgs(
+                            WindowsKeyboardDevice.Instance,
+                            timestamp,
+                            _owner,
+                            RawKeyEventType.KeyDown,
+                            KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)),
+                            WindowsKeyboardDevice.Instance.Modifiers);
+                        break;
+                    }
+
+                case WindowsMessage.WM_MENUCHAR:
+                    {
+                        // mute the system beep
+                        return (IntPtr)((int)MenuCharParam.MNC_CLOSE << 16);
+                    }
+
+                case WindowsMessage.WM_KEYUP:
+                case WindowsMessage.WM_SYSKEYUP:
+                    {
+                        e = new RawKeyEventArgs(
+                            WindowsKeyboardDevice.Instance,
+                            timestamp,
+                            _owner,
+                            RawKeyEventType.KeyUp,
+                            KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)),
+                            WindowsKeyboardDevice.Instance.Modifiers);
+                        break;
+                    }
+                case WindowsMessage.WM_CHAR:
+                    {
+                        // Ignore control chars
+                        if (ToInt32(wParam) >= 32)
+                        {
+                            e = new RawTextInputEventArgs(WindowsKeyboardDevice.Instance, timestamp, _owner,
+                                new string((char)ToInt32(wParam), 1));
+                        }
+
+                        break;
+                    }
+
+                case WindowsMessage.WM_LBUTTONDOWN:
+                case WindowsMessage.WM_RBUTTONDOWN:
+                case WindowsMessage.WM_MBUTTONDOWN:
+                case WindowsMessage.WM_XBUTTONDOWN:
+                    {
+                        shouldTakeFocus = ShouldTakeFocusOnClick;
+                        if (ShouldIgnoreTouchEmulatedMessage())
+                        {
+                            break;
+                        }
+
+                        e = new RawPointerEventArgs(
+                            _mouseDevice,
+                            timestamp,
+                            _owner,
+                            (WindowsMessage)msg switch
+                            {
+                                WindowsMessage.WM_LBUTTONDOWN => RawPointerEventType.LeftButtonDown,
+                                WindowsMessage.WM_RBUTTONDOWN => RawPointerEventType.RightButtonDown,
+                                WindowsMessage.WM_MBUTTONDOWN => RawPointerEventType.MiddleButtonDown,
+                                WindowsMessage.WM_XBUTTONDOWN =>
+                                HighWord(ToInt32(wParam)) == 1 ?
+                                    RawPointerEventType.XButton1Down :
+                                    RawPointerEventType.XButton2Down
+                            },
+                            DipFromLParam(lParam), GetMouseModifiers(wParam));
+                        break;
+                    }
+
+                case WindowsMessage.WM_LBUTTONUP:
+                case WindowsMessage.WM_RBUTTONUP:
+                case WindowsMessage.WM_MBUTTONUP:
+                case WindowsMessage.WM_XBUTTONUP:
+                    {
+                        shouldTakeFocus = ShouldTakeFocusOnClick;
+                        if (ShouldIgnoreTouchEmulatedMessage())
+                        {
+                            break;
+                        }
+
+                        e = new RawPointerEventArgs(
+                            _mouseDevice,
+                            timestamp,
+                            _owner,
+                            (WindowsMessage)msg switch
+                            {
+                                WindowsMessage.WM_LBUTTONUP => RawPointerEventType.LeftButtonUp,
+                                WindowsMessage.WM_RBUTTONUP => RawPointerEventType.RightButtonUp,
+                                WindowsMessage.WM_MBUTTONUP => RawPointerEventType.MiddleButtonUp,
+                                WindowsMessage.WM_XBUTTONUP =>
+                                HighWord(ToInt32(wParam)) == 1 ?
+                                    RawPointerEventType.XButton1Up :
+                                    RawPointerEventType.XButton2Up,
+                            },
+                            DipFromLParam(lParam), GetMouseModifiers(wParam));
+                        break;
+                    }
+
+                case WindowsMessage.WM_MOUSEMOVE:
+                    {
+                        if (ShouldIgnoreTouchEmulatedMessage())
+                        {
+                            break;
+                        }
+
+                        if (!_trackingMouse)
+                        {
+                            var tm = new TRACKMOUSEEVENT
+                            {
+                                cbSize = Marshal.SizeOf<TRACKMOUSEEVENT>(),
+                                dwFlags = 2,
+                                hwndTrack = _hwnd,
+                                dwHoverTime = 0,
+                            };
+
+                            TrackMouseEvent(ref tm);
+                        }
+
+                        e = new RawPointerEventArgs(
+                            _mouseDevice,
+                            timestamp,
+                            _owner,
+                            RawPointerEventType.Move,
+                            DipFromLParam(lParam), GetMouseModifiers(wParam));
+
+                        break;
+                    }
+
+                case WindowsMessage.WM_MOUSEWHEEL:
+                    {
+                        e = new RawMouseWheelEventArgs(
+                            _mouseDevice,
+                            timestamp,
+                            _owner,
+                            PointToClient(PointFromLParam(lParam)),
+                            new Vector(0, (ToInt32(wParam) >> 16) / wheelDelta), GetMouseModifiers(wParam));
+                        break;
+                    }
+
+                case WindowsMessage.WM_MOUSEHWHEEL:
+                    {
+                        e = new RawMouseWheelEventArgs(
+                            _mouseDevice,
+                            timestamp,
+                            _owner,
+                            PointToClient(PointFromLParam(lParam)),
+                            new Vector(-(ToInt32(wParam) >> 16) / wheelDelta, 0), GetMouseModifiers(wParam));
+                        break;
+                    }
+
+                case WindowsMessage.WM_MOUSELEAVE:
+                    {
+                        _trackingMouse = false;
+                        e = new RawPointerEventArgs(
+                            _mouseDevice,
+                            timestamp,
+                            _owner,
+                            RawPointerEventType.LeaveWindow,
+                            new Point(-1, -1), WindowsKeyboardDevice.Instance.Modifiers);
+                        break;
+                    }
+
+                case WindowsMessage.WM_NCLBUTTONDOWN:
+                case WindowsMessage.WM_NCRBUTTONDOWN:
+                case WindowsMessage.WM_NCMBUTTONDOWN:
+                case WindowsMessage.WM_NCXBUTTONDOWN:
+                    {
+                        e = new RawPointerEventArgs(
+                            _mouseDevice,
+                            timestamp,
+                            _owner,
+                            (WindowsMessage)msg switch
+                            {
+                                WindowsMessage.WM_NCLBUTTONDOWN => RawPointerEventType
+                                    .NonClientLeftButtonDown,
+                                WindowsMessage.WM_NCRBUTTONDOWN => RawPointerEventType.RightButtonDown,
+                                WindowsMessage.WM_NCMBUTTONDOWN => RawPointerEventType.MiddleButtonDown,
+                                WindowsMessage.WM_NCXBUTTONDOWN =>
+                                HighWord(ToInt32(wParam)) == 1 ?
+                                    RawPointerEventType.XButton1Down :
+                                    RawPointerEventType.XButton2Down,
+                            },
+                            PointToClient(PointFromLParam(lParam)), GetMouseModifiers(wParam));
+                        break;
+                    }
+                case WindowsMessage.WM_TOUCH:
+                    {
+                        var touchInputCount = wParam.ToInt32();
+
+                        var pTouchInputs = stackalloc TOUCHINPUT[touchInputCount];
+                        var touchInputs = new Span<TOUCHINPUT>(pTouchInputs, touchInputCount);
+
+                        if (GetTouchInputInfo(lParam, (uint)touchInputCount, pTouchInputs, Marshal.SizeOf<TOUCHINPUT>()))
+                        {
+                            foreach (var touchInput in touchInputs)
+                            {
+                                Input?.Invoke(new RawTouchEventArgs(_touchDevice, touchInput.Time,
+                                    _owner,
+                                    touchInput.Flags.HasFlagCustom(TouchInputFlags.TOUCHEVENTF_UP) ?
+                                        RawPointerEventType.TouchEnd :
+                                        touchInput.Flags.HasFlagCustom(TouchInputFlags.TOUCHEVENTF_DOWN) ?
+                                            RawPointerEventType.TouchBegin :
+                                            RawPointerEventType.TouchUpdate,
+                                    PointToClient(new PixelPoint(touchInput.X / 100, touchInput.Y / 100)),
+                                    WindowsKeyboardDevice.Instance.Modifiers,
+                                    touchInput.Id));
+                            }
+
+                            CloseTouchInputHandle(lParam);
+                            return IntPtr.Zero;
+                        }
+
+                        break;
+                    }
+                case WindowsMessage.WM_NCPAINT:
+                    {
+                        if (!HasFullDecorations)
+                        {
+                            return IntPtr.Zero;
+                        }
+
+                        break;
+                    }
+
+                case WindowsMessage.WM_NCACTIVATE:
+                    {
+                        if (!HasFullDecorations)
+                        {
+                            return new IntPtr(1);
+                        }
+
+                        break;
+                    }
+
+                case WindowsMessage.WM_PAINT:
+                    {
+                        using (_rendererLock.Lock())
+                        {
+                            if (BeginPaint(_hwnd, out PAINTSTRUCT ps) != IntPtr.Zero)
+                            {
+                                var f = Scaling;
+                                var r = ps.rcPaint;
+                                Paint?.Invoke(new Rect(r.left / f, r.top / f, (r.right - r.left) / f,
+                                    (r.bottom - r.top) / f));
+                                EndPaint(_hwnd, ref ps);
+                            }
+                        }
+
+                        return IntPtr.Zero;
+                    }
+
+                case WindowsMessage.WM_SIZE:
+                    {
+                        using (_rendererLock.Lock())
+                        {
+                            // Do nothing here, just block until the pending frame render is completed on the render thread
+                        }
+
+                        var size = (SizeCommand)wParam;
+
+                        if (Resized != null &&
+                            (size == SizeCommand.Restored ||
+                             size == SizeCommand.Maximized))
+                        {
+                            var clientSize = new Size(ToInt32(lParam) & 0xffff, ToInt32(lParam) >> 16);
+                            Resized(clientSize / Scaling);
+                        }
+
+                        var windowState = size == SizeCommand.Maximized ?
+                            WindowState.Maximized :
+                            (size == SizeCommand.Minimized ? WindowState.Minimized : WindowState.Normal);
+
+                        if (windowState != _lastWindowState)
+                        {
+                            _lastWindowState = windowState;
+
+                            WindowStateChanged?.Invoke(windowState);
+
+                            if (_isClientAreaExtended)
+                            {
+                                UpdateExtendMargins();
+
+                                ExtendClientAreaToDecorationsChanged?.Invoke(true);
+                            }
+                        }
+
+                        return IntPtr.Zero;
+                    }
+
+                case WindowsMessage.WM_MOVE:
+                    {
+                        PositionChanged?.Invoke(new PixelPoint((short)(ToInt32(lParam) & 0xffff),
+                            (short)(ToInt32(lParam) >> 16)));
+                        return IntPtr.Zero;
+                    }
+
+                case WindowsMessage.WM_GETMINMAXINFO:
+                    {
+                        MINMAXINFO mmi = Marshal.PtrToStructure<MINMAXINFO>(lParam);
+
+                        if (_minSize.Width > 0)
+                        {
+                            mmi.ptMinTrackSize.X =
+                                (int)((_minSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right);
+                        }
+
+                        if (_minSize.Height > 0)
+                        {
+                            mmi.ptMinTrackSize.Y =
+                                (int)((_minSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom);
+                        }
+
+                        if (!double.IsInfinity(_maxSize.Width) && _maxSize.Width > 0)
+                        {
+                            mmi.ptMaxTrackSize.X =
+                                (int)((_maxSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right);
+                        }
+
+                        if (!double.IsInfinity(_maxSize.Height) && _maxSize.Height > 0)
+                        {
+                            mmi.ptMaxTrackSize.Y =
+                                (int)((_maxSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom);
+                        }
+
+                        Marshal.StructureToPtr(mmi, lParam, true);
+                        return IntPtr.Zero;
+                    }
+
+                case WindowsMessage.WM_DISPLAYCHANGE:
+                    {
+                        (Screen as ScreenImpl)?.InvalidateScreensCache();
+                        return IntPtr.Zero;
+                    }
+
+                case WindowsMessage.WM_KILLFOCUS:
+                    LostFocus?.Invoke();
+                    break;
+            }
+
+#if USE_MANAGED_DRAG
+            if (_managedDrag.PreprocessInputEvent(ref e))
+                return UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam);
+#endif
+            
+            if(shouldTakeFocus)
+            {
+                SetFocus(_hwnd);
+            }
+
+            if (e != null && Input != null)
+            {
+                Input(e);
+
+                if (e.Handled)
+                {
+                    return IntPtr.Zero;
+                }
+            }
+
+            using (_rendererLock.Lock())
+            {
+                return DefWindowProc(hWnd, msg, wParam, lParam);
+            }
+        }
+
+        private static int ToInt32(IntPtr ptr)
+        {
+            if (IntPtr.Size == 4)
+                return ptr.ToInt32();
+
+            return (int)(ptr.ToInt64() & 0xffffffff);
+        }
+
+        private static int HighWord(int param) => param >> 16;
+
+        private Point DipFromLParam(IntPtr lParam)
+        {
+            return new Point((short)(ToInt32(lParam) & 0xffff), (short)(ToInt32(lParam) >> 16)) / Scaling;
+        }
+
+        private PixelPoint PointFromLParam(IntPtr lParam)
+        {
+            return new PixelPoint((short)(ToInt32(lParam) & 0xffff), (short)(ToInt32(lParam) >> 16));
+        }
+
+        private bool ShouldIgnoreTouchEmulatedMessage()
+        {
+            if (!_multitouch)
+            {
+                return false;
+            }
+
+            // MI_WP_SIGNATURE
+            // https://docs.microsoft.com/en-us/windows/win32/tablet/system-events-and-mouse-messages
+            const long marker = 0xFF515700L;
+
+            var info = GetMessageExtraInfo().ToInt64();
+            return (info & marker) == marker;
+        }
+
+        private static RawInputModifiers GetMouseModifiers(IntPtr wParam)
+        {
+            var keys = (ModifierKeys)ToInt32(wParam);
+            var modifiers = WindowsKeyboardDevice.Instance.Modifiers;
+
+            if (keys.HasFlagCustom(ModifierKeys.MK_LBUTTON))
+            {
+                modifiers |= RawInputModifiers.LeftMouseButton;
+            }
+
+            if (keys.HasFlagCustom(ModifierKeys.MK_RBUTTON))
+            {
+                modifiers |= RawInputModifiers.RightMouseButton;
+            }
+
+            if (keys.HasFlagCustom(ModifierKeys.MK_MBUTTON))
+            {
+                modifiers |= RawInputModifiers.MiddleMouseButton;
+            }
+
+            if (keys.HasFlagCustom(ModifierKeys.MK_XBUTTON1))
+            {
+                modifiers |= RawInputModifiers.XButton1MouseButton;
+            }
+
+            if (keys.HasFlagCustom(ModifierKeys.MK_XBUTTON2))
+            {
+                modifiers |= RawInputModifiers.XButton2MouseButton;
+            }
+
+            return modifiers;
+        }
+    }
+}

src/Windows/Avalonia.Win32/WindowImpl.CustomCaptionProc.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Diagnostics;
+using Avalonia.Controls;
+using Avalonia.Input;
+using static Avalonia.Win32.Interop.UnmanagedMethods;
+
+#nullable enable
+
+namespace Avalonia.Win32
+{
+    public partial class WindowImpl
+    {
+        // Hit test the frame for resizing and moving.
+        HitTestValues HitTestNCA(IntPtr hWnd, IntPtr wParam, IntPtr lParam)
+        {
+            // Get the point coordinates for the hit test.
+            var ptMouse = PointFromLParam(lParam);
+
+            // Get the window rectangle.            
+            GetWindowRect(hWnd, out var rcWindow);
+
+            // Get the frame rectangle, adjusted for the style without a caption.
+            RECT rcFrame = new RECT();
+            AdjustWindowRectEx(ref rcFrame, (uint)(WindowStyles.WS_OVERLAPPEDWINDOW & ~WindowStyles.WS_CAPTION), false, 0);
+
+            RECT border_thickness = new RECT();
+            if (GetStyle().HasFlag(WindowStyles.WS_THICKFRAME))
+            {
+                AdjustWindowRectEx(ref border_thickness, (uint)(GetStyle()), false, 0);
+                border_thickness.left *= -1;
+                border_thickness.top *= -1;
+            }
+            else if (GetStyle().HasFlag(WindowStyles.WS_BORDER))
+            {
+                border_thickness = new RECT { bottom = 1, left = 1, right = 1, top = 1 };
+            }
+
+            if (_extendTitleBarHint >= 0)
+            {
+                border_thickness.top = (int)(_extendedMargins.Top * Scaling);
+            }
+
+            // Determine if the hit test is for resizing. Default middle (1,1).
+            ushort uRow = 1;
+            ushort uCol = 1;
+            bool fOnResizeBorder = false;
+
+            // Determine if the point is at the top or bottom of the window.
+            if (ptMouse.Y >= rcWindow.top && ptMouse.Y < rcWindow.top + border_thickness.top)
+            {
+                fOnResizeBorder = (ptMouse.Y < (rcWindow.top - rcFrame.top));
+                uRow = 0;
+            }
+            else if (ptMouse.Y < rcWindow.bottom && ptMouse.Y >= rcWindow.bottom - border_thickness.bottom)
+            {
+                uRow = 2;
+            }
+
+            // Determine if the point is at the left or right of the window.
+            if (ptMouse.X >= rcWindow.left && ptMouse.X < rcWindow.left + border_thickness.left)
+            {
+                uCol = 0; // left side
+            }
+            else if (ptMouse.X < rcWindow.right && ptMouse.X >= rcWindow.right - border_thickness.right)
+            {
+                uCol = 2; // right side
+            }
+
+            // Hit test (HTTOPLEFT, ... HTBOTTOMRIGHT)
+            HitTestValues[][] hitTests = new[]
+            {
+                new []{ HitTestValues.HTTOPLEFT,    fOnResizeBorder ? HitTestValues.HTTOP : HitTestValues.HTCAPTION,    HitTestValues.HTTOPRIGHT },
+                new []{ HitTestValues.HTLEFT,      HitTestValues.HTNOWHERE,     HitTestValues.HTRIGHT },
+                new []{ HitTestValues.HTBOTTOMLEFT, HitTestValues.HTBOTTOM, HitTestValues.HTBOTTOMRIGHT },
+            };
+
+            return hitTests[uRow][uCol];
+        }
+
+        protected virtual IntPtr CustomCaptionProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam, ref bool callDwp)
+        {
+            IntPtr lRet = IntPtr.Zero;
+
+            callDwp = !DwmDefWindowProc(hWnd, msg, wParam, lParam, ref lRet);
+
+            switch ((WindowsMessage)msg)
+            {
+                case WindowsMessage.WM_DWMCOMPOSITIONCHANGED:
+                    // TODO handle composition changed.
+                    break;
+
+                case WindowsMessage.WM_NCHITTEST:
+                    if (lRet == IntPtr.Zero)
+                    {
+                        if(WindowState == WindowState.FullScreen)
+                        {
+                            return (IntPtr)HitTestValues.HTCLIENT;
+                        }
+                        var hittestResult = HitTestNCA(hWnd, wParam, lParam);
+
+                        lRet = (IntPtr)hittestResult;
+
+                        uint timestamp = unchecked((uint)GetMessageTime());
+
+                        if (hittestResult == HitTestValues.HTCAPTION)
+                        {
+                            var position = PointToClient(PointFromLParam(lParam));
+
+                            if (_owner is Window window)
+                            {
+                                var visual = window.Renderer.HitTestFirst(position, _owner as Window, x =>
+                                {
+                                    if (x is IInputElement ie && !ie.IsHitTestVisible)
+                                    {
+                                        return false;
+                                    }
+
+                                    return true;
+                                });
+
+                                if (visual != null)
+                                {
+                                    hittestResult = HitTestValues.HTCLIENT;
+                                    lRet = (IntPtr)hittestResult;
+                                }
+                            }
+                        }
+
+                        if (hittestResult != HitTestValues.HTNOWHERE)
+                        {
+                            callDwp = false;
+                        }
+                    }
+                    break;
+            }
+
+            return lRet;
+        }
+    }
+}

src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs

@@ -15,519 +15,22 @@ namespace Avalonia.Win32
 {
     public partial class WindowImpl
     {
-        [SuppressMessage("Microsoft.StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation",
-            Justification = "Using Win32 naming for consistency.")]
         protected virtual unsafe IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
         {
-            const double wheelDelta = 120.0;
+            IntPtr lRet = IntPtr.Zero;
-            uint timestamp = unchecked((uint)GetMessageTime());
+            bool callDwp = true;
 
-            RawInputEventArgs e = null;
+            if (_isClientAreaExtended)
-            var shouldTakeFocus = false;
-            
-            switch ((WindowsMessage)msg)
             {
-                case WindowsMessage.WM_ACTIVATE:
+                lRet = CustomCaptionProc(hWnd, msg, wParam, lParam, ref callDwp);
-                {
-                    var wa = (WindowActivate)(ToInt32(wParam) & 0xffff);
-
-                    switch (wa)
-                    {
-                        case WindowActivate.WA_ACTIVE:
-                        case WindowActivate.WA_CLICKACTIVE:
-                        {
-                            Activated?.Invoke();
-                            break;
-                        }
-
-                        case WindowActivate.WA_INACTIVE:
-                        {
-                            Deactivated?.Invoke();
-                            break;
-                        }
-                    }
-
-                    return IntPtr.Zero;
-                }
-
-                case WindowsMessage.WM_NCCALCSIZE:
-                {
-                    if (ToInt32(wParam) == 1 && !HasFullDecorations)
-                    {
-                        return IntPtr.Zero;
-                    }
-
-                    break;
-                }
-
-                case WindowsMessage.WM_CLOSE:
-                {
-                    bool? preventClosing = Closing?.Invoke();
-                    if (preventClosing == true)
-                    {
-                        return IntPtr.Zero;
-                    }
-
-                    break;
-                }
-
-                case WindowsMessage.WM_DESTROY:
-                {
-                    //Window doesn't exist anymore
-                    _hwnd = IntPtr.Zero;
-                    //Remove root reference to this class, so unmanaged delegate can be collected
-                    s_instances.Remove(this);
-                    Closed?.Invoke();
-
-                    _mouseDevice.Dispose();
-                    _touchDevice?.Dispose();
-                    //Free other resources
-                    Dispose();
-                    return IntPtr.Zero;
-                }
-
-                case WindowsMessage.WM_DPICHANGED:
-                {
-                    var dpi = ToInt32(wParam) & 0xffff;
-                    var newDisplayRect = Marshal.PtrToStructure<RECT>(lParam);
-                    _scaling = dpi / 96.0;
-                    ScalingChanged?.Invoke(_scaling);
-                    SetWindowPos(hWnd,
-                        IntPtr.Zero,
-                        newDisplayRect.left,
-                        newDisplayRect.top,
-                        newDisplayRect.right - newDisplayRect.left,
-                        newDisplayRect.bottom - newDisplayRect.top,
-                        SetWindowPosFlags.SWP_NOZORDER |
-                        SetWindowPosFlags.SWP_NOACTIVATE);
-                    return IntPtr.Zero;
-                }
-
-                case WindowsMessage.WM_KEYDOWN:
-                case WindowsMessage.WM_SYSKEYDOWN:
-                {
-                    e = new RawKeyEventArgs(
-                        WindowsKeyboardDevice.Instance,
-                        timestamp,
-                        _owner,
-                        RawKeyEventType.KeyDown,
-                        KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)),
-                        WindowsKeyboardDevice.Instance.Modifiers);
-                    break;
-                }
-
-                case WindowsMessage.WM_MENUCHAR:
-                {
-                    // mute the system beep
-                    return (IntPtr)((int)MenuCharParam.MNC_CLOSE << 16);
-                }
-
-                case WindowsMessage.WM_KEYUP:
-                case WindowsMessage.WM_SYSKEYUP:
-                {
-                    e = new RawKeyEventArgs(
-                        WindowsKeyboardDevice.Instance,
-                        timestamp,
-                        _owner,
-                        RawKeyEventType.KeyUp,
-                        KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)),
-                        WindowsKeyboardDevice.Instance.Modifiers);
-                    break;
-                }
-                case WindowsMessage.WM_CHAR:
-                {
-                    // Ignore control chars
-                    if (ToInt32(wParam) >= 32)
-                    {
-                        e = new RawTextInputEventArgs(WindowsKeyboardDevice.Instance, timestamp, _owner,
-                            new string((char)ToInt32(wParam), 1));
-                    }
-
-                    break;
-                }
-
-                case WindowsMessage.WM_LBUTTONDOWN:
-                case WindowsMessage.WM_RBUTTONDOWN:
-                case WindowsMessage.WM_MBUTTONDOWN:
-                case WindowsMessage.WM_XBUTTONDOWN:
-                {
-                    shouldTakeFocus = ShouldTakeFocusOnClick;
-                    if (ShouldIgnoreTouchEmulatedMessage())
-                    {
-                        break;
-                    }
-
-                    e = new RawPointerEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        (WindowsMessage)msg switch
-                        {
-                            WindowsMessage.WM_LBUTTONDOWN => RawPointerEventType.LeftButtonDown,
-                            WindowsMessage.WM_RBUTTONDOWN => RawPointerEventType.RightButtonDown,
-                            WindowsMessage.WM_MBUTTONDOWN => RawPointerEventType.MiddleButtonDown,
-                            WindowsMessage.WM_XBUTTONDOWN =>
-                            HighWord(ToInt32(wParam)) == 1 ?
-                                RawPointerEventType.XButton1Down :
-                                RawPointerEventType.XButton2Down
-                        },
-                        DipFromLParam(lParam), GetMouseModifiers(wParam));
-                    break;
-                }
-
-                case WindowsMessage.WM_LBUTTONUP:
-                case WindowsMessage.WM_RBUTTONUP:
-                case WindowsMessage.WM_MBUTTONUP:
-                case WindowsMessage.WM_XBUTTONUP:
-                {
-                    shouldTakeFocus = ShouldTakeFocusOnClick;
-                    if (ShouldIgnoreTouchEmulatedMessage())
-                    {
-                        break;
-                    }
-
-                    e = new RawPointerEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        (WindowsMessage)msg switch
-                        {
-                            WindowsMessage.WM_LBUTTONUP => RawPointerEventType.LeftButtonUp,
-                            WindowsMessage.WM_RBUTTONUP => RawPointerEventType.RightButtonUp,
-                            WindowsMessage.WM_MBUTTONUP => RawPointerEventType.MiddleButtonUp,
-                            WindowsMessage.WM_XBUTTONUP =>
-                            HighWord(ToInt32(wParam)) == 1 ?
-                                RawPointerEventType.XButton1Up :
-                                RawPointerEventType.XButton2Up,
-                        },
-                        DipFromLParam(lParam), GetMouseModifiers(wParam));
-                    break;
-                }
-
-                case WindowsMessage.WM_MOUSEMOVE:
-                {
-                    if (ShouldIgnoreTouchEmulatedMessage())
-                    {
-                        break;
-                    }
-
-                    if (!_trackingMouse)
-                    {
-                        var tm = new TRACKMOUSEEVENT
-                        {
-                            cbSize = Marshal.SizeOf<TRACKMOUSEEVENT>(),
-                            dwFlags = 2,
-                            hwndTrack = _hwnd,
-                            dwHoverTime = 0,
-                        };
-
-                        TrackMouseEvent(ref tm);
-                    }
-
-                    e = new RawPointerEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        RawPointerEventType.Move,
-                        DipFromLParam(lParam), GetMouseModifiers(wParam));
-
-                    break;
-                }
-
-                case WindowsMessage.WM_MOUSEWHEEL:
-                {
-                    e = new RawMouseWheelEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        PointToClient(PointFromLParam(lParam)),
-                        new Vector(0, (ToInt32(wParam) >> 16) / wheelDelta), GetMouseModifiers(wParam));
-                    break;
-                }
-
-                case WindowsMessage.WM_MOUSEHWHEEL:
-                {
-                    e = new RawMouseWheelEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        PointToClient(PointFromLParam(lParam)),
-                        new Vector(-(ToInt32(wParam) >> 16) / wheelDelta, 0), GetMouseModifiers(wParam));
-                    break;
-                }
-
-                case WindowsMessage.WM_MOUSELEAVE:
-                {
-                    _trackingMouse = false;
-                    e = new RawPointerEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        RawPointerEventType.LeaveWindow,
-                        new Point(-1, -1), WindowsKeyboardDevice.Instance.Modifiers);
-                    break;
-                }
-
-                case WindowsMessage.WM_NCLBUTTONDOWN:
-                case WindowsMessage.WM_NCRBUTTONDOWN:
-                case WindowsMessage.WM_NCMBUTTONDOWN:
-                case WindowsMessage.WM_NCXBUTTONDOWN:
-                {
-                    e = new RawPointerEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        (WindowsMessage)msg switch
-                        {
-                            WindowsMessage.WM_NCLBUTTONDOWN => RawPointerEventType
-                                .NonClientLeftButtonDown,
-                            WindowsMessage.WM_NCRBUTTONDOWN => RawPointerEventType.RightButtonDown,
-                            WindowsMessage.WM_NCMBUTTONDOWN => RawPointerEventType.MiddleButtonDown,
-                            WindowsMessage.WM_NCXBUTTONDOWN =>
-                            HighWord(ToInt32(wParam)) == 1 ?
-                                RawPointerEventType.XButton1Down :
-                                RawPointerEventType.XButton2Down,
-                        },
-                        PointToClient(PointFromLParam(lParam)), GetMouseModifiers(wParam));
-                    break;
-                }
-                case WindowsMessage.WM_TOUCH:
-                {
-                    var touchInputCount = wParam.ToInt32();
-
-                    var pTouchInputs = stackalloc TOUCHINPUT[touchInputCount];
-                    var touchInputs = new Span<TOUCHINPUT>(pTouchInputs, touchInputCount);
-
-                    if (GetTouchInputInfo(lParam, (uint)touchInputCount, pTouchInputs, Marshal.SizeOf<TOUCHINPUT>()))
-                    {
-                        foreach (var touchInput in touchInputs)
-                        {
-                            Input?.Invoke(new RawTouchEventArgs(_touchDevice, touchInput.Time,
-                                _owner,
-                                touchInput.Flags.HasFlagCustom(TouchInputFlags.TOUCHEVENTF_UP) ?
-                                    RawPointerEventType.TouchEnd :
-                                    touchInput.Flags.HasFlagCustom(TouchInputFlags.TOUCHEVENTF_DOWN) ?
-                                        RawPointerEventType.TouchBegin :
-                                        RawPointerEventType.TouchUpdate,
-                                PointToClient(new PixelPoint(touchInput.X / 100, touchInput.Y / 100)),
-                                WindowsKeyboardDevice.Instance.Modifiers,
-                                touchInput.Id));
-                        }
-
-                        CloseTouchInputHandle(lParam);
-                        return IntPtr.Zero;
-                    }
-
-                    break;
-                }
-                case WindowsMessage.WM_NCPAINT:
-                {
-                    if (!HasFullDecorations)
-                    {
-                        return IntPtr.Zero;
-                    }
-
-                    break;
-                }
-
-                case WindowsMessage.WM_NCACTIVATE:
-                {
-                    if (!HasFullDecorations)
-                    {
-                        return new IntPtr(1);
-                    }
-
-                    break;
-                }
-
-                case WindowsMessage.WM_PAINT:
-                {
-                    using (_rendererLock.Lock())
-                    {
-                        if (BeginPaint(_hwnd, out PAINTSTRUCT ps) != IntPtr.Zero)
-                        {
-                            var f = Scaling;
-                            var r = ps.rcPaint;
-                            Paint?.Invoke(new Rect(r.left / f, r.top / f, (r.right - r.left) / f,
-                                (r.bottom - r.top) / f));
-                            EndPaint(_hwnd, ref ps);
-                        }
-                    }
-
-                    return IntPtr.Zero;
-                }
-
-                case WindowsMessage.WM_SIZE:
-                {
-                    using (_rendererLock.Lock())
-                    {
-                        // Do nothing here, just block until the pending frame render is completed on the render thread
-                    }
-
-                    var size = (SizeCommand)wParam;
-
-                    if (Resized != null &&
-                        (size == SizeCommand.Restored ||
-                         size == SizeCommand.Maximized))
-                    {
-                        var clientSize = new Size(ToInt32(lParam) & 0xffff, ToInt32(lParam) >> 16);
-                        Resized(clientSize / Scaling);
-                    }
-
-                    var windowState = size == SizeCommand.Maximized ?
-                        WindowState.Maximized :
-                        (size == SizeCommand.Minimized ? WindowState.Minimized : WindowState.Normal);
-
-                    if (windowState != _lastWindowState)
-                    {
-                        _lastWindowState = windowState;
-                        WindowStateChanged?.Invoke(windowState);
-                    }
-
-                    return IntPtr.Zero;
-                }
-
-                case WindowsMessage.WM_MOVE:
-                {
-                    PositionChanged?.Invoke(new PixelPoint((short)(ToInt32(lParam) & 0xffff),
-                        (short)(ToInt32(lParam) >> 16)));
-                    return IntPtr.Zero;
-                }
-
-                case WindowsMessage.WM_GETMINMAXINFO:
-                {
-                    MINMAXINFO mmi = Marshal.PtrToStructure<MINMAXINFO>(lParam);
-                    
-                    _maxTrackSize = mmi.ptMaxTrackSize;
-
-                    if (_minSize.Width > 0)
-                    {
-                        mmi.ptMinTrackSize.X =
-                            (int)((_minSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right);
-                    }
-
-                    if (_minSize.Height > 0)
-                    {
-                        mmi.ptMinTrackSize.Y =
-                            (int)((_minSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom);
-                    }
-
-                    if (!double.IsInfinity(_maxSize.Width) && _maxSize.Width > 0)
-                    {
-                        mmi.ptMaxTrackSize.X =
-                            (int)((_maxSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right);
-                    }
-
-                    if (!double.IsInfinity(_maxSize.Height) && _maxSize.Height > 0)
-                    {
-                        mmi.ptMaxTrackSize.Y =
-                            (int)((_maxSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom);
-                    }
-
-                    Marshal.StructureToPtr(mmi, lParam, true);
-                    return IntPtr.Zero;
-                }
-
-                case WindowsMessage.WM_DISPLAYCHANGE:
-                {
-                    (Screen as ScreenImpl)?.InvalidateScreensCache();
-                    return IntPtr.Zero;
-                }
-                case WindowsMessage.WM_KILLFOCUS:
-                    LostFocus?.Invoke();
-                    break;
-            }
-
-#if USE_MANAGED_DRAG
-            if (_managedDrag.PreprocessInputEvent(ref e))
-                return UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam);
-#endif
-            
-            if (shouldTakeFocus)
-                SetFocus(_hwnd);
-
-            if (e != null && Input != null)
-            {
-                Input(e);
-
-                if (e.Handled)
-                {
-                    return IntPtr.Zero;
-                }
-            }
-
-            using (_rendererLock.Lock())
-            {
-                return DefWindowProc(hWnd, msg, wParam, lParam);
-            }
-        }
-
-        private static int ToInt32(IntPtr ptr)
-        {
-            if (IntPtr.Size == 4)
-                return ptr.ToInt32();
-
-            return (int)(ptr.ToInt64() & 0xffffffff);
-        }
-
-        private static int HighWord(int param) => param >> 16;
-
-        private Point DipFromLParam(IntPtr lParam)
-        {
-            return new Point((short)(ToInt32(lParam) & 0xffff), (short)(ToInt32(lParam) >> 16)) / Scaling;
-        }
-
-        private PixelPoint PointFromLParam(IntPtr lParam)
-        {
-            return new PixelPoint((short)(ToInt32(lParam) & 0xffff), (short)(ToInt32(lParam) >> 16));
-        }
-
-        private bool ShouldIgnoreTouchEmulatedMessage()
-        {
-            if (!_multitouch)
-            {
-                return false;
-            }
-
-            // MI_WP_SIGNATURE
-            // https://docs.microsoft.com/en-us/windows/win32/tablet/system-events-and-mouse-messages
-            const long marker = 0xFF515700L;
-
-            var info = GetMessageExtraInfo().ToInt64();
-            return (info & marker) == marker;
-        }
-
-        private static RawInputModifiers GetMouseModifiers(IntPtr wParam)
-        {
-            var keys = (ModifierKeys)ToInt32(wParam);
-            var modifiers = WindowsKeyboardDevice.Instance.Modifiers;
-
-            if (keys.HasFlagCustom(ModifierKeys.MK_LBUTTON))
-            {
-                modifiers |= RawInputModifiers.LeftMouseButton;
-            }
-
-            if (keys.HasFlagCustom(ModifierKeys.MK_RBUTTON))
-            {
-                modifiers |= RawInputModifiers.RightMouseButton;
-            }
-
-            if (keys.HasFlagCustom(ModifierKeys.MK_MBUTTON))
-            {
-                modifiers |= RawInputModifiers.MiddleMouseButton;
-            }
-
-            if (keys.HasFlagCustom(ModifierKeys.MK_XBUTTON1))
-            {
-                modifiers |= RawInputModifiers.XButton1MouseButton;
             }
 
-            if (keys.HasFlagCustom(ModifierKeys.MK_XBUTTON2))
+            if (callDwp)
             {
-                modifiers |= RawInputModifiers.XButton2MouseButton;
+                lRet = AppWndProc(hWnd, msg, wParam, lParam);
             }
 
-            return modifiers;
+            return lRet;
         }
         
         public INativeControlHostImpl NativeControlHost => _nativeControlHost;

src/Windows/Avalonia.Win32/WindowImpl.cs

@@ -42,6 +42,10 @@ namespace Avalonia.Win32
 
         private SavedWindowInfo _savedWindowInfo;
         private bool _isFullScreenActive;
+        private bool _isClientAreaExtended;
+        private Thickness _extendedMargins;
+        private Thickness _offScreenMargin;
+        private double _extendTitleBarHint = -1;
 
 #if USE_MANAGED_DRAG
         private readonly ManagedWindowResizeDragHelper _managedDrag;
@@ -70,7 +74,8 @@ namespace Avalonia.Win32
         private Size _minSize;
         private Size _maxSize;
         private POINT _maxTrackSize;
-        private WindowImpl _parent;
+        private WindowImpl _parent;        
+        private ExtendClientAreaChromeHints _extendChromeHints = ExtendClientAreaChromeHints.Default;
 
         public WindowImpl()
         {
@@ -183,6 +188,11 @@ namespace Avalonia.Win32
         {
             get
             {
+                if(_isFullScreenActive)
+                {
+                    return WindowState.FullScreen;
+                }
+
                 var placement = default(WINDOWPLACEMENT);
                 GetWindowPlacement(_hwnd, ref placement);
 
@@ -668,6 +678,98 @@ namespace Avalonia.Win32
             }
 
             TaskBarList.MarkFullscreen(_hwnd, fullscreen);
+            
+            ExtendClientArea();
+        }
+
+        private MARGINS UpdateExtendMargins()
+        {
+            RECT borderThickness = new RECT();
+            RECT borderCaptionThickness = new RECT();            
+
+            AdjustWindowRectEx(ref borderCaptionThickness, (uint)(GetStyle()), false, 0);
+            AdjustWindowRectEx(ref borderThickness, (uint)(GetStyle() & ~WindowStyles.WS_CAPTION), false, 0);
+            borderThickness.left *= -1;
+            borderThickness.top *= -1;
+            borderCaptionThickness.left *= -1;
+            borderCaptionThickness.top *= -1;
+
+            bool wantsTitleBar = _extendChromeHints.HasFlag(ExtendClientAreaChromeHints.SystemChrome) || _extendTitleBarHint == -1;
+
+            if (!wantsTitleBar)
+            {
+                borderCaptionThickness.top = 1;
+            }
+
+            MARGINS margins = new MARGINS();
+            margins.cxLeftWidth = 1;
+            margins.cxRightWidth = 1;
+            margins.cyBottomHeight = 1;
+
+            if (_extendTitleBarHint != -1)
+            {
+                borderCaptionThickness.top = (int)(_extendTitleBarHint * Scaling);                
+            }
+
+            margins.cyTopHeight = _extendChromeHints.HasFlag(ExtendClientAreaChromeHints.SystemChrome) && !_extendChromeHints.HasFlag(ExtendClientAreaChromeHints.PreferSystemChrome) ? borderCaptionThickness.top : 1;
+
+            if (WindowState == WindowState.Maximized)
+            {
+                _extendedMargins = new Thickness(0, (borderCaptionThickness.top - borderThickness.top) / Scaling, 0, 0);
+                _offScreenMargin = new Thickness(borderThickness.left / Scaling, borderThickness.top / Scaling, borderThickness.right / Scaling, borderThickness.bottom / Scaling);
+            }
+            else
+            {
+                _extendedMargins = new Thickness(0, (borderCaptionThickness.top) / Scaling, 0, 0);
+                _offScreenMargin = new Thickness();
+            }
+
+            return margins;
+        }
+
+        private void ExtendClientArea()
+        {
+            if (DwmIsCompositionEnabled(out bool compositionEnabled) < 0 || !compositionEnabled)
+            {
+                _isClientAreaExtended = false;
+                return;
+            }
+
+            GetWindowRect(_hwnd, out var rcClient);
+
+            // Inform the application of the frame change.
+            SetWindowPos(_hwnd,
+                         IntPtr.Zero,
+                         rcClient.left, rcClient.top,
+                         rcClient.Width, rcClient.Height,
+                         SetWindowPosFlags.SWP_FRAMECHANGED);
+
+            if (_isClientAreaExtended && WindowState != WindowState.FullScreen)
+            {
+                var margins = UpdateExtendMargins();
+
+                DwmExtendFrameIntoClientArea(_hwnd, ref margins);
+            }
+            else
+            {
+                var margins = new MARGINS();
+                DwmExtendFrameIntoClientArea(_hwnd, ref margins);
+
+                _offScreenMargin = new Thickness();
+                _extendedMargins = new Thickness();
+            }
+
+            if(!_isClientAreaExtended || (_extendChromeHints.HasFlag(ExtendClientAreaChromeHints.SystemChrome) &&
+                !_extendChromeHints.HasFlag(ExtendClientAreaChromeHints.PreferSystemChrome)))
+            {
+                EnableCloseButton(_hwnd);
+            }
+            else
+            {
+                DisableCloseButton(_hwnd);
+            }
+
+            ExtendClientAreaToDecorationsChanged?.Invoke(_isClientAreaExtended);
         }
 
         private void ShowWindow(WindowState state)
@@ -818,9 +920,10 @@ namespace Avalonia.Win32
                 // Otherwise it will still show in the taskbar.
             }
 
+            WindowStyles style;
             if ((oldProperties.IsResizable != newProperties.IsResizable) || forceChanges)
             {
-                var style = GetStyle();
+                style = GetStyle();
 
                 if (newProperties.IsResizable)
                 {
@@ -841,7 +944,7 @@ namespace Avalonia.Win32
 
             if ((oldProperties.Decorations != newProperties.Decorations) || forceChanges)
             {
-                var style = GetStyle();
+                style = GetStyle();
 
                 const WindowStyles fullDecorationFlags = WindowStyles.WS_CAPTION | WindowStyles.WS_SYSMENU;
 
@@ -886,7 +989,26 @@ namespace Avalonia.Win32
                         SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE |
                         SetWindowPosFlags.SWP_FRAMECHANGED);
                 }
-            }
+            }            
+        }
+
+        private const int MF_BYCOMMAND = 0x0;
+        private const int MF_BYPOSITION = 0x400;
+        private const int MF_REMOVE = 0x1000;
+        private const int MF_ENABLED = 0x0;
+        private const int MF_GRAYED = 0x1;
+        private const int MF_DISABLED = 0x2;
+        private const int SC_CLOSE = 0xF060;
+
+        void DisableCloseButton(IntPtr hwnd)
+        {
+            EnableMenuItem(GetSystemMenu(hwnd, false), SC_CLOSE,
+                           MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
+        }
+        void EnableCloseButton(IntPtr hwnd)
+        {
+            EnableMenuItem(GetSystemMenu(hwnd, false), SC_CLOSE,
+                           MF_BYCOMMAND | MF_ENABLED);
         }
 
 #if USE_MANAGED_DRAG
@@ -912,6 +1034,43 @@ namespace Avalonia.Win32
 
         IntPtr EglGlPlatformSurface.IEglWindowGlPlatformSurfaceInfo.Handle => Handle.Handle;
 
+        public void SetExtendClientAreaToDecorationsHint(bool hint)
+        {
+            _isClientAreaExtended = hint;
+            
+            ExtendClientArea();            
+        }        
+
+        public void SetExtendClientAreaChromeHints(ExtendClientAreaChromeHints hints)
+        {
+            _extendChromeHints = hints;
+
+            ExtendClientArea();
+        }
+        
+        /// <inheritdoc/>
+        public void SetExtendClientAreaTitleBarHeightHint(double titleBarHeight)
+        {
+            _extendTitleBarHint = titleBarHeight;
+
+            ExtendClientArea();
+        }
+
+        /// <inheritdoc/>
+        public bool IsClientAreaExtendedToDecorations => _isClientAreaExtended;
+
+        /// <inheritdoc/>
+        public Action<bool> ExtendClientAreaToDecorationsChanged { get; set; }
+        
+        /// <inheritdoc/>
+        public bool NeedsManagedDecorations => _isClientAreaExtended && _extendChromeHints.HasFlag(ExtendClientAreaChromeHints.PreferSystemChrome);
+
+        /// <inheritdoc/>
+        public Thickness ExtendedMargins => _extendedMargins;
+
+        /// <inheritdoc/>
+        public Thickness OffScreenMargin => _offScreenMargin;
+
         private struct SavedWindowInfo
         {
             public WindowStyles Style { get; set; }