Commit 73adbcff: - added Windows 11 goodies

MainWindow_Updating.cs

-1+6

/BExplorer/BetterExplorer/_MainWindow/MainWindow_Updating.cs

View

using System;

using System.ComponentModel;

using System.Linq;

using System.Runtime.InteropServices;

using System.Threading;

using System.Windows;

using System.Windows.Threading;

private void MainWindow_OnClosed(Object sender, EventArgs e) {

}

[return: MarshalAs(UnmanagedType.Bool)]

[DllImport("user32.dll", SetLastError = true)]

private static extern Boolean PostMessage(IntPtr hWnd, UInt32 Msg, IntPtr wParam, IntPtr lParam);

private void ButtonBase_OnClick(Object sender, RoutedEventArgs e) {

var b = PostMessage(this.Handle, 0x0084, IntPtr.Zero, (IntPtr) ((10 << 16) | (10 & 0xFFFF)));

private void ButtonBase_OnClick(Object sender, RoutedEventArgs e) {

new ToastContentBuilder()

.AddArgument("action", "viewConversation")

.AddArgument("conversationId", 9813)

app.manifest

-8+23

/BExplorer/BetterExplorer/app.manifest

View

</application>

</compatibility>

<dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2, PerMonitor, System</dpiAwareness>

</windowsSettings>

</application>

MainWindow.xaml

-3+4

/BExplorer/BetterExplorer/MainWindow.xaml

View

</Ribbon:Ribbon.QuickAccessItems>

<Ribbon:Ribbon.Menu>

<Ribbon:Backstage

x:Name="backstage"

x:Name="backstage" Margin="1,0,0,0"

Ribbon:KeyTip.Keys="F"

Background="DarkOrange"

Header="Menu"

Grid.Row="4"

Grid.ColumnSpan="2"

Background="{DynamicResource WhiteBrush}"

Margin="1,0,1,0">

Margin="0">

<Grid.ColumnDefinitions>

Grid.ColumnSpan="3"

Width="{Binding ActualWidth, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type Grid}}}"

Height="{Binding ActualHeight, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type RowDefinition}}}"

Margin="0" />

Margin="0" Visibility="Collapsed"/>

<GridSplitter

Grid.Row="1"

Grid.ColumnSpan="3"

Background="LightBlue" />

<Grid

x:Name="TreeGrid"

Margin="2,0,2,0"

Grid.Row="2"

Grid.Column="0"

Background="{DynamicResource WhiteBrush}">

RibbonWindow.cs

-105+349

/Fluent.Ribbon-develop/Fluent.Ribbon/Controls/RibbonWindow.cs

View

Displayed content is truncated due to maximum viewable content limit.

// ReSharper disable once CheckNamespace

namespace Fluent

{

using System.Runtime.InteropServices;

using System.Windows.Automation.Peers;

using System.Windows.Controls;

using System.Windows.Interop;

using ControlzEx.Standard;

namespace Fluent {

using System;

using System.Windows;

using System.Windows.Data;

[TemplatePart(Name = PART_ContentPresenter, Type = typeof(UIElement))]

[TemplatePart(Name = PART_RibbonTitleBar, Type = typeof(RibbonTitleBar))]

[TemplatePart(Name = PART_WindowCommands, Type = typeof(WindowCommands))]

public class RibbonWindow : Window, IRibbonWindow

{

public class RibbonWindow : Window, IRibbonWindow {

// ReSharper disable InconsistentNaming

#pragma warning disable SA1310 // Field names must not contain underscore

private const string PART_Icon = "PART_Icon";

private const string PART_WindowCommands = "PART_WindowCommands";

#pragma warning restore SA1310 // Field names must not contain underscore

// ReSharper restore InconsistentNaming

private FrameworkElement iconImage;

#region Properties

/// <summary>

/// Gets ribbon titlebar

/// </summary>

public RibbonTitleBar TitleBar

{

get { return (RibbonTitleBar)this.GetValue(TitleBarProperty); }

private set { this.SetValue(titleBarPropertyKey, value); }

public RibbonTitleBar TitleBar {

get => (RibbonTitleBar)this.GetValue(TitleBarProperty);

private set => this.SetValue(titleBarPropertyKey, value);

}

private static readonly DependencyPropertyKey titleBarPropertyKey = DependencyProperty.RegisterReadOnly(nameof(TitleBar), typeof(RibbonTitleBar), typeof(RibbonWindow), new PropertyMetadata());

/// <summary>

/// Gets or sets the height which is used to render the window title.

/// </summary>

public double TitleBarHeight

{

get { return (double)this.GetValue(TitleBarHeightProperty); }

set { this.SetValue(TitleBarHeightProperty, value); }

public double TitleBarHeight {

get => (double)this.GetValue(TitleBarHeightProperty);

set => this.SetValue(TitleBarHeightProperty, value);

}

/// <summary>

/// Gets or sets the <see cref="Brush"/> which is used to render the window title.

/// </summary>

public Brush TitleForeground

{

get { return (Brush)this.GetValue(TitleForegroundProperty); }

set { this.SetValue(TitleForegroundProperty, value); }

public Brush TitleForeground {

get => (Brush)this.GetValue(TitleForegroundProperty);

set => this.SetValue(TitleForegroundProperty, value);

}

/// <summary>

/// Gets or sets the <see cref="Brush"/> which is used to render the window title background.

/// </summary>

public Brush TitleBackground

{

get { return (Brush)this.GetValue(TitleBackgroundProperty); }

set { this.SetValue(TitleBackgroundProperty, value); }

public Brush TitleBackground {

get => (Brush)this.GetValue(TitleBackgroundProperty);

set => this.SetValue(TitleBackgroundProperty, value);

}

/// <summary>

/// Gets or sets the window commands

/// </summary>

public WindowCommands WindowCommands

{

get { return (WindowCommands)this.GetValue(WindowCommandsProperty); }

set { this.SetValue(WindowCommandsProperty, value); }

public WindowCommands WindowCommands {

get => (WindowCommands)this.GetValue(WindowCommandsProperty);

set => this.SetValue(WindowCommandsProperty, value);

}

/// <summary>

/// Gets or sets resize border thickness

/// </summary>

public Thickness ResizeBorderThickness

{

get { return (Thickness)this.GetValue(ResizeBorderThicknessProperty); }

set { this.SetValue(ResizeBorderThicknessProperty, value); }

public Thickness ResizeBorderThickness {

get => (Thickness)this.GetValue(ResizeBorderThicknessProperty);

set => this.SetValue(ResizeBorderThicknessProperty, value);

}

/// <summary>

/// Gets or sets glass border thickness

/// </summary>

public Thickness GlassFrameThickness

{

get { return (Thickness)this.GetValue(GlassFrameThicknessProperty); }

set { this.SetValue(GlassFrameThicknessProperty, value); }

public Thickness GlassFrameThickness {

get => (Thickness)this.GetValue(GlassFrameThicknessProperty);

set => this.SetValue(GlassFrameThicknessProperty, value);

}

/// <summary>

/// Gets or sets whether icon is visible

/// </summary>

public bool IsIconVisible

{

get { return (bool)this.GetValue(IsIconVisibleProperty); }

set { this.SetValue(IsIconVisibleProperty, value); }

public bool IsIconVisible {

get => (bool)this.GetValue(IsIconVisibleProperty);

set => this.SetValue(IsIconVisibleProperty, value);

}

/// <summary>

/// Gets whether window is collapsed

/// </summary>

public bool IsCollapsed

{

get { return (bool)this.GetValue(IsCollapsedProperty); }

set { this.SetValue(IsCollapsedProperty, value); }

public bool IsCollapsed {

get => (bool)this.GetValue(IsCollapsedProperty);

set => this.SetValue(IsCollapsedProperty, value);

}

/// <summary>

/// Defines if the Ribbon should automatically set <see cref="IsCollapsed"/> when the width or height of the owner window drop under <see cref="Ribbon.MinimalVisibleWidth"/> or <see cref="Ribbon.MinimalVisibleHeight"/>

/// </summary>

public bool IsAutomaticCollapseEnabled

{

get { return (bool)this.GetValue(IsAutomaticCollapseEnabledProperty); }

set { this.SetValue(IsAutomaticCollapseEnabledProperty, value); }

public bool IsAutomaticCollapseEnabled {

get => (bool)this.GetValue(IsAutomaticCollapseEnabledProperty);

set => this.SetValue(IsAutomaticCollapseEnabledProperty, value);

}

/// <summary>

/// Defines if the taskbar should be ignored and hidden while the window is maximized.

/// </summary>

public bool IgnoreTaskbarOnMaximize

{

get { return (bool)this.GetValue(IgnoreTaskbarOnMaximizeProperty); }

set { this.SetValue(IgnoreTaskbarOnMaximizeProperty, value); }

public bool IgnoreTaskbarOnMaximize {

get => (bool)this.GetValue(IgnoreTaskbarOnMaximizeProperty);

set => this.SetValue(IgnoreTaskbarOnMaximizeProperty, value);

}

/// <summary>

/// Static constructor

/// </summary>

static RibbonWindow()

{

static RibbonWindow() {

DefaultStyleKeyProperty.OverrideMetadata(typeof(RibbonWindow), new FrameworkPropertyMetadata(typeof(RibbonWindow)));

BorderThicknessProperty.OverrideMetadata(typeof(RibbonWindow), new FrameworkPropertyMetadata(new Thickness(1)));

/// <summary>

/// Default constructor

/// </summary>

public RibbonWindow()

{

this.SizeChanged += this.OnSizeChanged;

this.Loaded += this.OnLoaded;

// WindowChromeBehavior initialization has to occur in constructor. Otherwise the load event is fired early and performance of the window is degraded.

this.InitializeWindowChromeBehavior();

public RibbonWindow() {

//this.SizeChanged += this.OnSizeChanged;

//this.Loaded += this.OnLoaded;

//this.InitializeWindowChromeBehavior();

//this.GlassFrameThickness = new Thickness(0, 1, 0, 0);

}

#endregion

#region Overrides

/// <summary>

/// Initializes the WindowChromeBehavior which is needed to render the custom WindowChrome.

/// </summary>

private void InitializeWindowChromeBehavior()

{

private void InitializeWindowChromeBehavior() {

var behavior = new WindowChromeBehavior();

BindingOperations.SetBinding(behavior, WindowChromeBehavior.ResizeBorderThicknessProperty, new Binding { Path = new PropertyPath(ResizeBorderThicknessProperty), Source = this });

BindingOperations.SetBinding(behavior, WindowChromeBehavior.GlassFrameThicknessProperty, new Binding { Path = new PropertyPath(GlassFrameThicknessProperty), Source = this });

Interaction.GetBehaviors(this).Add(behavior);

}

#region Overrides

#endregion

// Size change to collapse ribbon

private void OnSizeChanged(object sender, SizeChangedEventArgs e)

{

private void OnSizeChanged(object sender, SizeChangedEventArgs e) {

this.MaintainIsCollapsed();

}

private void OnLoaded(object sender, RoutedEventArgs e)

{

if (this.SizeToContent == SizeToContent.Manual)

{

private void OnLoaded(object sender, RoutedEventArgs e) {

if (this.SizeToContent == SizeToContent.Manual) {

return;

}

this.RunInDispatcherAsync(() =>

{

this.RunInDispatcherAsync(() => {

// Fix for #454 while also keeping #473

var availableSize = new Size(this.TitleBar.ActualWidth, this.TitleBar.ActualHeight);

this.TitleBar.Measure(availableSize);

this.TitleBar.ForceMeasureAndArrange();

}, DispatcherPriority.ApplicationIdle);

}

/// <summary>

/// used to overwrite WndProc

/// </summary>

/// <param name="e"></param>

protected override void OnSourceInitialized(EventArgs e) {

base.OnSourceInitialized(e);

var source = PresentationSource.FromVisual(this) as HwndSource;

source.AddHook(WndProcHooked);

}

public T FindChild<T>(DependencyObject parent, string childName)

where T : DependencyObject {

// Confirm parent and childName are valid.

if (parent == null) return null;

T foundChild = null;

int childrenCount = VisualTreeHelper.GetChildrenCount(parent);

for (int i = 0; i < childrenCount; i++) {

var child = VisualTreeHelper.GetChild(parent, i);

// If the child is not of the request child type child

T childType = child as T;

if (childType == null) {

// recursively drill down the tree

foundChild = FindChild<T>(child, childName);

// If the child is found, break so we do not overwrite the found child.

if (foundChild != null) break;

} else if (!string.IsNullOrEmpty(childName)) {

var frameworkElement = child as FrameworkElement;

// If the child's name is set for search

if (frameworkElement != null && frameworkElement.Name == childName) {

// if the child's name is of the request name

foundChild = FindChild<T>(child, childName);

break;

}

} else {

// child element found.

foundChild = (T)child;

break;

}

return foundChild;

}

[DllImport("user32.dll")]

[return: MarshalAs(UnmanagedType.Bool)]

internal static extern bool GetCursorPos(ref Win32Point pt);

[StructLayout(LayoutKind.Sequential)]

internal struct Win32Point {

public Int32 X;

public Int32 Y;

};

public static Point GetMousePosition() {

var w32Mouse = new Win32Point();

GetCursorPos(ref w32Mouse);

return new Point(w32Mouse.X, w32Mouse.Y);

}

[DllImport("user32.dll", EntryPoint = "GetWindowLongPtr")]

private static extern IntPtr GetWindowLongPtr(IntPtr hWnd, int nIndex);

private IntPtr WndProcHooked(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled) {

var cp = this.GetPart<UIElement>(PART_WindowCommands) as ContentPresenter;

var ct = cp.Content as WindowCommands;

var max = ct.Template.FindName("PART_Max", ct) as System.Windows.Controls.Button;

var restore = ct.Template.FindName("PART_Restore", ct) as System.Windows.Controls.Button;

var mp = GetMousePosition();

AutomationPeer theBtnRestorePeer = UIElementAutomationPeer.CreatePeerForElement(restore);

Rect rectRestore = theBtnRestorePeer.GetBoundingRectangle();

AutomationPeer theBtnMaxPeer = UIElementAutomationPeer.CreatePeerForElement(max);

Rect rectMax = theBtnMaxPeer.GetBoundingRectangle();

if (msg == 0x0084) {

if (rectRestore.Contains(mp.X, mp.Y) || rectMax.Contains(mp.X, mp.Y)) {

max.Background = (Brush)Application.Current.Resources["Fluent.Ribbon.Brushes.WindowCommands.CaptionButton.MouseOver.Background"];

restore.Background = (Brush)Application.Current.Resources["Fluent.Ribbon.Brushes.WindowCommands.CaptionButton.MouseOver.Background"];

handled = true;

return (IntPtr)9;

} else {

max.Background = (Brush)Application.Current.Resources["Fluent.Ribbon.Brushes.WindowCommands.CaptionButton.Background"];

restore.Background = (Brush)Application.Current.Resources["Fluent.Ribbon.Brushes.WindowCommands.CaptionButton.Background"];

}

if (msg == 0x00A1 && wParam == (IntPtr)9) {

handled = true;

}

if (msg == 0x0024) {

WmGetMinMaxInfo(hwnd, lParam, (int)MinWidth, (int)MinHeight);

handled = true;

}

if (msg == 0x00A2 && wParam == (IntPtr)9) {

if (this.WindowState == WindowState.Maximized) {

SystemCommands.RestoreWindow(this);

} else {

SystemCommands.MaximizeWindow(this);

}

return IntPtr.Zero;

}

private void MaintainIsCollapsed()

{

if (this.IsAutomaticCollapseEnabled == false)

{

private void MaintainIsCollapsed() {

if (this.IsAutomaticCollapseEnabled == false) {

return;

}

if (this.ActualWidth < Ribbon.MinimalVisibleWidth

|| this.ActualHeight < Ribbon.MinimalVisibleHeight)

{

|| this.ActualHeight < Ribbon.MinimalVisibleHeight) {

this.IsCollapsed = true;

}

else

{

} else {

this.IsCollapsed = false;

}

/// <inheritdoc />

public override void OnApplyTemplate()

{

public override void OnApplyTemplate() {

base.OnApplyTemplate();

this.TitleBar = this.GetTemplateChild(PART_RibbonTitleBar) as RibbonTitleBar;

if (this.iconImage != null)

{

if (this.iconImage != null) {

this.iconImage.MouseDown -= this.HandleIconMouseDown;

}

if (this.WindowCommands == null)

{

if (this.WindowCommands == null) {

this.WindowCommands = new WindowCommands();

}

this.iconImage = this.GetPart<FrameworkElement>(PART_Icon);

if (this.iconImage != null)

{

if (this.iconImage != null) {

this.iconImage.MouseDown += this.HandleIconMouseDown;

}

/// <inheritdoc />

protected override void OnStateChanged(EventArgs e)

{

protected override void OnStateChanged(EventArgs e) {

base.OnStateChanged(e);

// todo: remove fix if we update to ControlzEx 4.0

if (this.WindowState == WindowState.Maximized

&& this.SizeToContent != SizeToContent.Manual)

{

&& this.SizeToContent != SizeToContent.Manual) {

this.SizeToContent = SizeToContent.Manual;

}

this.RunInDispatcherAsync(() => this.TitleBar?.ForceMeasureAndArrange(), DispatcherPriority.Background);

}

private void HandleIconMouseDown(object sender, MouseButtonEventArgs e)

{

switch (e.ChangedButton)

{

private void HandleIconMouseDown(object sender, MouseButtonEventArgs e) {

switch (e.ChangedButton) {

case MouseButton.Left:

if (e.ClickCount == 1)

{

if (e.ClickCount == 1) {

e.Handled = true;

WindowSteeringHelper.ShowSystemMenu(this, this.PointToScreen(new Point(0, this.TitleBarHeight)));

}

else if (e.ClickCount == 2)

{

} else if (e.ClickCount == 2) {

e.Handled = true;

#pragma warning disable 618

/// <typeparam name="T">The interface type inheirted from DependencyObject.</typeparam>

/// <param name="name">The name of the template child.</param>

internal T GetPart<T>(string name)

where T : DependencyObject

where T : DependencyObject {

return this.GetTemplateChild(name) as T;

}

public const int MONITOR_DEFAULTTONULL = 0x00000000;

public const int MONITOR_DEFAULTTOPRIMARY = 0x00000001;

public const int MONITOR_DEFAULTTONEAREST = 0x00000002;

[DllImport("user32.dll", CharSet = CharSet.Auto)]

public static extern bool GetMonitorInfo(IntPtr hmonitor, [In, Out] MONITORINFOEX info);

[DllImport("user32")]

internal static extern IntPtr MonitorFromWindow(IntPtr handle, int flags);

public static void WmGetMinMaxInfo(IntPtr hwnd, IntPtr lParam, int minWidth, int minHeight)

{

IntPtr monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);

if (monitor != IntPtr.Zero) {

MINMAXINFO mmi = (MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(MINMAXINFO));

MONITORINFOEX monitorInfo = new MONITORINFOEX();

monitorInfo.cbSize = Marshal.SizeOf(typeof(MONITORINFOEX));

GetMonitorInfo(monitor, monitorInfo);

RECT rcWorkArea = monitorInfo.rcWork;

RECT rcMonitorArea = monitorInfo.rcMonitor;

mmi.ptMaxPosition.x = Math.Abs(rcWorkArea.left - rcMonitorArea.left);

mmi.ptMaxPosition.y = Math.Abs(rcWorkArea.top - rcMonitorArea.top);

if (mmi.ptMaxPosition.y == 0)

mmi.ptMaxPosition.y = 1;

mmi.ptMaxSize.x = Math.Abs(rcWorkArea.right - rcWorkArea.left);

mmi.ptMaxSize.y = Math.Abs(rcWorkArea.bottom - rcWorkArea.top);

Marshal.StructureToPtr(mmi, lParam, true);

}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto, Pack = 4)]

public class MONITORINFOEX {

internal int cbSize = Marshal.SizeOf(typeof(MONITORINFOEX));

internal RECT rcMonitor = new RECT();

internal RECT rcWork = new RECT();

internal int dwFlags = 0;

[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]

internal char[] szDevice = new char[32];

}

WindowCommands.cs

-2+2

/Fluent.Ribbon-develop/Fluent.Ribbon/Metro/Controls/WindowCommands.cs

View

}

this.restoreButton = this.Template.FindName("PART_Restore", this) as System.Windows.Controls.Button;

if (this.restoreButton != null)

{

if (this.restoreButton != null) {

var rw = this.GetParentWindow() as RibbonWindow;

this.restoreButton.Click += this.RestoreClick;

}

Amber.xaml

-1+1

/Fluent.Ribbon-develop/Fluent.Ribbon/Themes/Accents/Amber.xaml

View

GeneratorParameters.json

/Fluent.Ribbon-develop/Fluent.Ribbon/Themes/Accents/GeneratorParameters.json

View

WindowCommands.xaml

/Fluent.Ribbon-develop/Fluent.Ribbon/Themes/Controls/WindowCommands.xaml

View

RibbonWindow.xaml

/Fluent.Ribbon-develop/Fluent.Ribbon/Themes/RibbonWindow.xaml

View

Styles.xaml

/Fluent.Ribbon-develop/Fluent.Ribbon/Themes/Styles.xaml

View

Fluent.Ribbon.NET 4.6.csproj

/Fluent.Ribbon-develop/Fluent.Ribbon/Fluent.Ribbon.NET 4.6.csproj

View

User32.cs

/Shell/Interop/User32.cs

View

Extensions.cs

/Shell/Extensions.cs

View

ImageListEx.cs

/Shell/ImageListEx.cs

View

ShellContextMenu.cs

/Shell/ShellContextMenu.cs

View

ShellTreeViewEx.cs

/Shell/ShellTreeViewEx.cs

View

ShellViewEx.cs

/Shell/ShellViewEx.cs

View

.gitignore

/.gitignore

View



	BExplorer/BetterExplorer
	_MainWindow
	MainWindow_Updating.cs
	app.manifest
	MainWindow.xaml
	Fluent.Ribbon-develop/Fluent.Ribbon
	Controls
	RibbonWindow.cs
	Metro/Controls
	WindowCommands.cs
	Themes
	Accents
	Amber.xaml
	GeneratorParameters.json
	Controls
	WindowCommands.xaml
	RibbonWindow.xaml
	Styles.xaml
	Fluent.Ribbon.NET 4.6.csproj
	Shell
	Interop
	User32.cs
	Extensions.cs
	ImageListEx.cs
	ShellContextMenu.cs
	ShellTreeViewEx.cs
	ShellViewEx.cs
	.gitignore