wake-up-neo.com

Wie kann man die Schließen-Schaltfläche im WPF-Fenster ausblenden?

Ich schreibe einen modalen Dialog in WPF. Wie kann ich ein WPF-Fenster so einstellen, dass es keine Schaltfläche zum Schließen gibt? Ich möchte immer noch, dass WindowState eine normale Titelleiste hat.

Ich habe ResizeMode, WindowState und WindowStyle gefunden, aber bei keiner dieser Eigenschaften kann ich die Schaltfläche "Schließen" ausblenden, aber die Titelleiste wie in modalen Dialogen anzeigen.

187

WPF verfügt nicht über eine integrierte Eigenschaft, um die Schließen-Schaltfläche der Titelleiste auszublenden. Sie können dies jedoch mit ein paar Zeilen P/Invoke tun.

Fügen Sie diese Deklarationen zunächst Ihrer Window-Klasse hinzu:

private const int GWL_STYLE = -16;
private const int WS_SYSMENU = 0x80000;
[DllImport("user32.dll", SetLastError = true)]
private static extern int GetWindowLong(IntPtr hWnd, int nIndex);
[DllImport("user32.dll")]
private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

Fügen Sie diesen Code dann in das Fenster Loaded-Ereignis ein:

var hwnd = new WindowInteropHelper(this).Handle;
SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_SYSMENU);

Und los geht's: nicht mehr Schließen. Auf der linken Seite der Titelleiste befindet sich auch kein Fenstersymbol. Dies bedeutet, dass kein Systemmenü angezeigt wird, auch wenn Sie mit der rechten Maustaste auf die Titelleiste klicken. Sie alle zusammen.

Beachten Sie, dass Alt + F4 das Fenster weiterhin schließt. Wenn Sie nicht zulassen möchten, dass sich das Fenster schließt, bevor der Hintergrund-Thread fertig ist, können Sie auch OnClosing überschreiben und Cancel auf true setzen, wie Gabe vorgeschlagen hat.

254
Joe White

Ich bin gerade zu einem ähnlichen Problem gekommen und die Lösung von Joe White scheint mir einfach und sauber zu sein. Ich habe es wiederverwendet und als angefügte Eigenschaft von Window definiert

public class WindowBehavior
{
    private static readonly Type OwnerType = typeof (WindowBehavior);

    #region HideCloseButton (attached property)

    public static readonly DependencyProperty HideCloseButtonProperty =
        DependencyProperty.RegisterAttached(
            "HideCloseButton",
            typeof (bool),
            OwnerType,
            new FrameworkPropertyMetadata(false, new PropertyChangedCallback(HideCloseButtonChangedCallback)));

    [AttachedPropertyBrowsableForType(typeof(Window))]
    public static bool GetHideCloseButton(Window obj) {
        return (bool)obj.GetValue(HideCloseButtonProperty);
    }

    [AttachedPropertyBrowsableForType(typeof(Window))]
    public static void SetHideCloseButton(Window obj, bool value) {
        obj.SetValue(HideCloseButtonProperty, value);
    }

    private static void HideCloseButtonChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var window = d as Window;
        if (window == null) return;

        var hideCloseButton = (bool)e.NewValue;
        if (hideCloseButton && !GetIsHiddenCloseButton(window)) {
            if (!window.IsLoaded) {
                window.Loaded += HideWhenLoadedDelegate;
            }
            else {
                HideCloseButton(window);
            }
            SetIsHiddenCloseButton(window, true);
        }
        else if (!hideCloseButton && GetIsHiddenCloseButton(window)) {
            if (!window.IsLoaded) {
                window.Loaded -= ShowWhenLoadedDelegate;
            }
            else {
                ShowCloseButton(window);
            }
            SetIsHiddenCloseButton(window, false);
        }
    }

    #region Win32 imports

    private const int GWL_STYLE = -16;
    private const int WS_SYSMENU = 0x80000;
    [DllImport("user32.dll", SetLastError = true)]
    private static extern int GetWindowLong(IntPtr hWnd, int nIndex);
    [DllImport("user32.dll")]
    private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

    #endregion

    private static readonly RoutedEventHandler HideWhenLoadedDelegate = (sender, args) => {
        if (sender is Window == false) return;
        var w = (Window)sender;
        HideCloseButton(w);
        w.Loaded -= HideWhenLoadedDelegate;
    };

    private static readonly RoutedEventHandler ShowWhenLoadedDelegate = (sender, args) => {
        if (sender is Window == false) return;
        var w = (Window)sender;
        ShowCloseButton(w);
        w.Loaded -= ShowWhenLoadedDelegate;
    };

    private static void HideCloseButton(Window w) {
        var hwnd = new WindowInteropHelper(w).Handle;
        SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_SYSMENU);
    }

    private static void ShowCloseButton(Window w) {
        var hwnd = new WindowInteropHelper(w).Handle;
        SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) | WS_SYSMENU);
    }

    #endregion

    #region IsHiddenCloseButton (readonly attached property)

    private static readonly DependencyPropertyKey IsHiddenCloseButtonKey =
        DependencyProperty.RegisterAttachedReadOnly(
            "IsHiddenCloseButton",
            typeof (bool),
            OwnerType,
            new FrameworkPropertyMetadata(false));

    public static readonly DependencyProperty IsHiddenCloseButtonProperty =
        IsHiddenCloseButtonKey.DependencyProperty;

    [AttachedPropertyBrowsableForType(typeof(Window))]
    public static bool GetIsHiddenCloseButton(Window obj) {
        return (bool)obj.GetValue(IsHiddenCloseButtonProperty);
    }

    private static void SetIsHiddenCloseButton(Window obj, bool value) {
        obj.SetValue(IsHiddenCloseButtonKey, value);
    }

    #endregion

}

Dann in XAML setzen Sie es einfach so:

<Window 
    x:Class="WafClient.Presentation.Views.SampleWindow"
    xmlns="http://schemas.Microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.Microsoft.com/winfx/2006/xaml"
    xmlns:u="clr-namespace:WafClient.Presentation.Behaviors"
    ResizeMode="NoResize"
    u:WindowBehavior.HideCloseButton="True">
    ...
</Window>
85
SpudCZ

Setzen Sie die WindowStyle-Eigenschaft auf None, um das Kontrollkästchen zusammen mit der Titelleiste auszublenden. Keine Notwendigkeit für kernal Anrufe. 

56

Die Schaltfläche "Schließen" wird nicht gelöscht, aber es wird verhindert, dass jemand das Fenster schließt.

Fügen Sie dies in Ihren Code hinter der Datei ein:

protected override void OnClosing(CancelEventArgs e)
{
   base.OnClosing(e);
   e.Cancel = true;
}
48
flurbius

Um die Schließen-Schaltfläche zu deaktivieren, fügen Sie der Window-Klasse den folgenden Code hinzu (der Code wurde aus hier übernommen, bearbeitet und ein wenig formatiert):

protected override void OnSourceInitialized(EventArgs e)
{
    base.OnSourceInitialized(e);

    HwndSource hwndSource = PresentationSource.FromVisual(this) as HwndSource;

    if (hwndSource != null)
    {
        hwndSource.AddHook(HwndSourceHook);
    }

}

private bool allowClosing = false;

[DllImport("user32.dll")]
private static extern IntPtr GetSystemMenu(IntPtr hWnd, bool bRevert);
[DllImport("user32.dll")]
private static extern bool EnableMenuItem(IntPtr hMenu, uint uIDEnableItem, uint uEnable);

private const uint MF_BYCOMMAND = 0x00000000;
private const uint MF_GRAYED = 0x00000001;

private const uint SC_CLOSE = 0xF060;

private const int WM_SHOWWINDOW = 0x00000018;
private const int WM_CLOSE = 0x10;

private IntPtr HwndSourceHook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
{
    switch (msg)
    {
        case WM_SHOWWINDOW:
            {
                IntPtr hMenu = GetSystemMenu(hwnd, false);
                if (hMenu != IntPtr.Zero)
                {
                    EnableMenuItem(hMenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
                }
            }
            break;
        case WM_CLOSE:
            if (!allowClosing)
            {
                handled = true;
            }
            break;
    }
    return IntPtr.Zero;
}

Dieser Code deaktiviert auch das Schließen-Element im System-Menü und das Schließen des Dialogs mit Alt + F4.

Sie möchten das Fenster wahrscheinlich programmgesteuert schließen. Nur den Aufruf von Close() wird nicht funktionieren. Tun Sie so etwas:

allowClosing = true;
Close();
15

Ich habe die Antwort von Viachaslau ausprobiert, da ich die Idee mag, den Button nicht zu entfernen, sondern zu deaktivieren, aber aus irgendeinem Grund hat es nicht immer funktioniert: Der Close-Button war immer noch aktiviert, aber es gab keinerlei Fehler. 

Dies funktionierte dagegen immer (Fehlerprüfung ausgelassen):

[DllImport( "user32.dll" )]
private static extern IntPtr GetSystemMenu( IntPtr hWnd, bool bRevert );
[DllImport( "user32.dll" )]
private static extern bool EnableMenuItem( IntPtr hMenu, uint uIDEnableItem, uint uEnable );

private const uint MF_BYCOMMAND = 0x00000000;
private const uint MF_GRAYED = 0x00000001;
private const uint SC_CLOSE = 0xF060;
private const int WM_SHOWWINDOW = 0x00000018;

protected override void OnSourceInitialized( EventArgs e )
{
  base.OnSourceInitialized( e );
  var hWnd = new WindowInteropHelper( this );
  var sysMenu = GetSystemMenu( hWnd.Handle, false );
  EnableMenuItem( sysMenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED );
}
9
stijn

Ich füge einfach meine Implementierung von Joe Whites Antwort mit Interaktivitätsverhalten hinzu (Sie müssen auf System.Windows.Interactivity verweisen).

code:

public class HideCloseButtonOnWindow : Behavior<Window>
{
    #region bunch of native methods

    private const int GWL_STYLE = -16;
    private const int WS_SYSMENU = 0x80000;

    [DllImport("user32.dll", SetLastError = true)]
    private static extern int GetWindowLong(IntPtr hWnd, int nIndex);

    [DllImport("user32.dll")]
    private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

    #endregion

    protected override void OnAttached()
    {
        base.OnAttached();
        AssociatedObject.Loaded += OnLoaded;
    }

    protected override void OnDetaching()
    {
        AssociatedObject.Loaded -= OnLoaded;
        base.OnDetaching();
    }

    private void OnLoaded(object sender, RoutedEventArgs e)
    {
        var hwnd = new WindowInteropHelper(AssociatedObject).Handle;
        SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_SYSMENU);
    }
}

verwendungszweck:

<Window x:Class="WpfApplication2.MainWindow"
        xmlns="http://schemas.Microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.Microsoft.com/winfx/2006/xaml"
        xmlns:i="http://schemas.Microsoft.com/expression/2010/interactivity"
        xmlns:w="clr-namespace:WpfApplication2">

    <i:Interaction.Behaviors>
        <w:HideCloseButtonOnWindow />
    </i:Interaction.Behaviors>

</Window>
8
tom.maruska

Die zu setzende Eigenschaft ist => WindowStyle="None"

<Window x:Class="mdaframework.MainWindow"
            xmlns="http://schemas.Microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.Microsoft.com/winfx/2006/xaml"
            Title="Start" Height="350" Width="525" ResizeMode="NoResize"  WindowStartupLocation="CenterScreen" WindowStyle="None">
7
daniele3004

Lassen Sie den Benutzer das Fenster "schließen", aber verstecken Sie es wirklich.

Blenden Sie im OnClosing-Ereignis des Fensters das Fenster aus, falls es bereits sichtbar ist:

    If Me.Visibility = Windows.Visibility.Visible Then
        Me.Visibility = Windows.Visibility.Hidden
        e.Cancel = True
    End If

Jedes Mal, wenn der Hintergrund-Thread ausgeführt werden soll, zeigen Sie das Hintergrund-UI-Fenster erneut an:

    w.Visibility = Windows.Visibility.Visible
    w.Show()

Stellen Sie beim Beenden der Programmausführung sicher, dass alle Fenster geschlossen sind/können:

Private Sub CloseAll()
    If w IsNot Nothing Then
        w.Visibility = Windows.Visibility.Collapsed ' Tell OnClosing to really close
        w.Close()
    End If
End Sub
2
BSalita

Im Folgenden geht es um das Deaktivieren der Schaltflächen Schließen und Maximieren/Minimieren. Dabei werden nicht die Schaltflächen tatsächlich entfernt (es werden jedoch die Menüelemente entfernt!). Die Schaltflächen in der Titelleiste sind deaktiviert/grau dargestellt. (Ich bin nicht ganz bereit, die gesamte Funktionalität selbst zu übernehmen ^^)

Dies unterscheidet sich geringfügig von der Virgoss-Lösung darin, dass die Menüelemente (und ggf. das nachfolgende Trennzeichen) entfernt werden, anstatt nur deaktiviert zu werden. Es unterscheidet sich von der Joe Whites-Lösung, da nicht das gesamte Systemmenü deaktiviert wird und ich in meinem Fall die Schaltfläche und das Symbol zum Minimieren beibehalten kann.

Der folgende Code unterstützt auch das Deaktivieren der Maximieren/Minimieren-Schaltflächen, da das Entfernen der Einträge aus dem Menü im Gegensatz zur Schließen-Schaltfläche nicht dazu führt, dass die Schaltflächen "deaktiviert" werden, obwohl die Menüeinträge entfernt werden does Deaktivieren Sie die Funktionalität der Schaltflächen.

Für mich geht das. YMMV.

    using System;
    using System.Collections.Generic;
    using System.Text;

    using System.Runtime.InteropServices;
    using Window = System.Windows.Window;
    using WindowInteropHelper = System.Windows.Interop.WindowInteropHelper;
    using Win32Exception = System.ComponentModel.Win32Exception;

    namespace Channelmatter.Guppy
    {

        public class WindowUtil
        {
            const int MF_BYCOMMAND = 0x0000;
            const int MF_BYPOSITION = 0x0400;

            const uint MFT_SEPARATOR = 0x0800;

            const uint MIIM_FTYPE = 0x0100;

            [DllImport("user32", SetLastError=true)]
            private static extern uint RemoveMenu(IntPtr hMenu, uint nPosition, uint wFlags);

            [DllImport("user32", SetLastError=true)]
            private static extern IntPtr GetSystemMenu(IntPtr hWnd, bool bRevert);

            [DllImport("user32", SetLastError=true)]
            private static extern int GetMenuItemCount(IntPtr hWnd);

            [StructLayout(LayoutKind.Sequential)]
            public struct MenuItemInfo {
                public uint   cbSize;
                public uint   fMask;
                public uint   fType;
                public uint   fState;
                public uint   wID;
                public IntPtr hSubMenu;
                public IntPtr hbmpChecked;
                public IntPtr hbmpUnchecked;
                public IntPtr dwItemData; // ULONG_PTR
                public IntPtr dwTypeData;
                public uint   cch;
                public IntPtr hbmpItem;
            };

            [DllImport("user32", SetLastError=true)]
            private static extern int GetMenuItemInfo(
                IntPtr hMenu, uint uItem,
                bool fByPosition, ref MenuItemInfo itemInfo);

            public enum MenuCommand : uint
            {
                SC_CLOSE = 0xF060,
                SC_MAXIMIZE = 0xF030,
            }

            public static void WithSystemMenu (Window win, Action<IntPtr> action) {
                var interop = new WindowInteropHelper(win);
                IntPtr hMenu = GetSystemMenu(interop.Handle, false);
                if (hMenu == IntPtr.Zero) {
                    throw new Win32Exception(Marshal.GetLastWin32Error(),
                        "Failed to get system menu");
                } else {
                    action(hMenu);
                }
            }

            // Removes the menu item for the specific command.
            // This will disable and gray the Close button and disable the
            // functionality behind the Maximize/Minimuze buttons, but it won't
            // gray out the Maximize/Minimize buttons. It will also not stop
            // the default Alt+F4 behavior.
            public static void RemoveMenuItem (Window win, MenuCommand command) {
                WithSystemMenu(win, (hMenu) => {
                    if (RemoveMenu(hMenu, (uint)command, MF_BYCOMMAND) == 0) {
                        throw new Win32Exception(Marshal.GetLastWin32Error(),
                            "Failed to remove menu item");
                    }
                });
            }

            public static bool RemoveTrailingSeparator (Window win) {
                bool result = false; // Func<...> not in .NET3 :-/
                WithSystemMenu(win, (hMenu) => {
                    result = RemoveTrailingSeparator(hMenu);
                });
                return result;
            }

            // Removes the final trailing separator of a menu if it exists.
            // Returns true if a separator is removed.
            public static bool RemoveTrailingSeparator (IntPtr hMenu) {
                int menuItemCount = GetMenuItemCount(hMenu);
                if (menuItemCount < 0) {
                    throw new Win32Exception(Marshal.GetLastWin32Error(),
                        "Failed to get menu item count");
                }
                if (menuItemCount == 0) {
                    return false;
                } else {
                    uint index = (uint)(menuItemCount - 1);
                    MenuItemInfo itemInfo = new MenuItemInfo {
                        cbSize = (uint)Marshal.SizeOf(typeof(MenuItemInfo)),
                        fMask = MIIM_FTYPE,
                    };

                    if (GetMenuItemInfo(hMenu, index, true, ref itemInfo) == 0) {
                        throw new Win32Exception(Marshal.GetLastWin32Error(),
                            "Failed to get menu item info");
                    }

                    if (itemInfo.fType == MFT_SEPARATOR) {
                        if (RemoveMenu(hMenu, index, MF_BYPOSITION) == 0) {
                            throw new Win32Exception(Marshal.GetLastWin32Error(),
                                "Failed to remove menu item");
                        }
                        return true;
                    } else {
                        return false;
                    }
                }
            }

            private const int GWL_STYLE = -16;

            [Flags]
            public enum WindowStyle : int
            {
                WS_MINIMIZEBOX = 0x00020000,
                WS_MAXIMIZEBOX = 0x00010000,
            }

            // Don't use this version for dealing with pointers
            [DllImport("user32", SetLastError=true)]
            private static extern int SetWindowLong (IntPtr hWnd, int nIndex, int dwNewLong);

            // Don't use this version for dealing with pointers
            [DllImport("user32", SetLastError=true)]
            private static extern int GetWindowLong (IntPtr hWnd, int nIndex);

            public static int AlterWindowStyle (Window win,
                WindowStyle orFlags, WindowStyle andNotFlags) 
            {
                var interop = new WindowInteropHelper(win);

                int prevStyle = GetWindowLong(interop.Handle, GWL_STYLE);
                if (prevStyle == 0) {
                    throw new Win32Exception(Marshal.GetLastWin32Error(),
                        "Failed to get window style");
                }

                int newStyle = (prevStyle | (int)orFlags) & ~((int)andNotFlags);
                if (SetWindowLong(interop.Handle, GWL_STYLE, newStyle) == 0) {
                    throw new Win32Exception(Marshal.GetLastWin32Error(),
                        "Failed to set window style");
                }
                return prevStyle;
            }

            public static int DisableMaximizeButton (Window win) {
                return AlterWindowStyle(win, 0, WindowStyle.WS_MAXIMIZEBOX);
            }
        }
    }

Verwendung: Dies muss erfolgen, nachdem die Quelle initialisiert wurde. Ein guter Ort ist die Verwendung des SourceInitialized-Ereignisses des Fensters:

Window win = ...; /* the Window :-) */
WindowUtil.DisableMaximizeButton(win);
WindowUtil.RemoveMenuItem(win, WindowUtil.MenuCommand.SC_MAXIMIZE);
WindowUtil.RemoveMenuItem(win, WindowUtil.MenuCommand.SC_CLOSE);
while (WindowUtil.RemoveTrailingSeparator(win)) 
{
   //do it here
}

Um die Alt + F4-Funktion zu deaktivieren, müssen Sie nur das Cancelling-Ereignis verbinden und ein Flag setzen, wenn Sie das Fenster wirklich schließen möchten.

1
user166390

So ziemlich genau hier ist dein Problem. Die Schließen-Schaltfläche in der oberen rechten Ecke eines Fensterrahmens ist nicht Teil des WPF-Fensters, sondern gehört zu dem Teil des Fensterrahmens, der von Ihrem Betriebssystem gesteuert wird. Das bedeutet, dass Sie dazu Win32-Interop verwenden müssen.

alternativ können Sie den Noframe verwenden und entweder Ihren eigenen "Frame" bereitstellen oder gar keinen Frame haben.

1
Muad'Dib

Verwenden Sie dieses, geändert von https://stephenhaunts.com/2014/09/25/remove-the-close-button-from-a-wpf-window :

using System;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;

namespace Whatever
{
    public partial class MainMenu : Window
    {
        private const int GWL_STYLE = -16;
        private const int WS_SYSMENU = 0x00080000;

        [DllImport("user32.dll", SetLastError = true)]
        private static extern int GetWindowLongPtr(IntPtr hWnd, int nIndex);

        [DllImport("user32.dll")]
        private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

        public MainMenu()
        {
             InitializeComponent();
             this.Loaded += new RoutedEventHandler(Window_Loaded);
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            var hwnd = new WindowInteropHelper(this).Handle;
            SetWindowLongPtr(hwnd, GWL_STYLE, GetWindowLongPtr(hwnd, GWL_STYLE) & ~WS_SYSMENU);
        }  

    }
}
0
vapcguy

Fügen Sie dem Fenster ein Abschlussereignis hinzu. Fügen Sie diesen Code zum Ereignishandler hinzu.

e.Cancel = true;

Dadurch wird verhindert, dass sich das Fenster schließt. Dies hat den gleichen Effekt wie das Schließen der Schaltfläche "Schließen".

0
Dennis R

goto Fenstereigenschaften gesetzt 

window style = none;

sie werden keine nahen Knöpfe bekommen ...

0

Dadurch wird die Schaltfläche nicht ausgeblendet, der Benutzer kann jedoch nicht vorwärts bewegt werden, indem er das Fenster herunterfährt. 

protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
{            
    if (e.Cancel == false)
    {
        Application.Current.Shutdown();
    }
}
0
A. Lartey

Nach langem Suchen nach der Antwort darauf habe ich diese einfache Lösung erarbeitet, die ich hier in der Hoffnung teile, dass sie anderen hilft.

Ich habe WindowStyle=0x10000000 eingestellt.

Dadurch werden die Werte für WS_VISIBLE (0x10000000) und WS_OVERLAPPED (0x0) für den Fensterstil festgelegt. "Überlappend" ist der notwendige Wert, um die Titelleiste und den Fensterrand anzuzeigen. Durch das Entfernen der Werte WS_MINIMIZEBOX (0x20000), WS_MAXIMIZEBOX (0x10000) und WS_SYSMENU (0x80000) aus meinem Stilwert wurden alle Schaltflächen aus der Titelleiste entfernt, einschließlich der Schaltfläche Schließen.

0
Joe Horr

XAML-Code

<Button Command="Open" Content="_Open">
    <Button.Style>
        <Style TargetType="Button">
            <Style.Triggers>
                <Trigger Property="IsEnabled" Value="False">
                    <Setter Property="Visibility" Value="Collapsed" />
                </Trigger>
            </Style.Triggers>
        </Style>
     </Button.Style>
</Button>

sollte arbeiten

Edit - für diesen Moment - Thread zeigt, wie das gemacht werden kann, aber ich glaube nicht, dass Window eine Eigenschaft hat, um zu bekommen, was Sie wollen, ohne die normale Titelleiste zu verlieren. 

Edit 2 Dieser Thread zeigt eine Möglichkeit, dies zu tun, aber Sie müssen Ihren eigenen Stil auf das Systemmenü anwenden und zeigen, wie Sie dies tun können.

0
TStamper