Графика в WPF

window.WindowStyle = WindowStyle.None;
window.ResizeMode = ResizeMode.NoResize;

<Window x:Class="FullScreen.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300"
    Background="Green"
    Loaded="Window_Loaded"
    KeyDown="Window_KeyDown"
    KeyUp="Window_KeyDown"
        >
    <Window.ContextMenu>
        <ContextMenu>
            <MenuItem Name="changeScreen" Click="MenuItem_Click" />
        </ContextMenu>
    </Window.ContextMenu>
    <DockPanel>
        <Menu Name="menu" DockPanel.Dock="Top">
            <MenuItem Header="File">
                <MenuItem Header="Open" />
                <MenuItem Header="Save" />
                <MenuItem Header="SaveAs" />
                <MenuItem Header="Exit" />
            </MenuItem>
            <MenuItem Header="Edit">
                <MenuItem Header="Cut" />
                <MenuItem Header="Copy" />
                <MenuItem Header="Paste" />
            </MenuItem>
        </Menu>
        <Image Source="Images/flower2.jpg" Stretch="Uniform" /> 
    </DockPanel>
</Window>

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
    
namespace FullScreen
{
    public partial class Window1 : Window
    {
        // Объявляем как поля для видимости в функциях
        bool fullScreen = false;// Состояние экрана
        WindowStyle windowStyle;
        WindowState windowState;
        ResizeMode resizeMode;
    
        public Window1()
        {
            InitializeComponent();
        }
    
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            // Запоминаем начальные параметры окна
            windowState = this.WindowState;
            windowStyle = this.WindowStyle;
            resizeMode = System.Windows.ResizeMode.CanResizeWithGrip;
            this.ResizeMode = resizeMode;
            changeScreen.Header = "FullScreen";
        }
    
        private void MenuItem_Click(object sender, RoutedEventArgs e)
        {
            FullScreen();
        }
    
        private void FullScreen()
        {
            if (!fullScreen)// Переходим в полноэкранный режим 
            {
                if (this.WindowState == WindowState.Maximized)
                {
                    // Чтобы скрыть панель задач и не было мерцания
                    this.Hide();
                    this.WindowState = WindowState.Normal;
                }
    
                App.Current.MainWindow.WindowStyle = WindowStyle.None;// Без заголовка
                App.Current.MainWindow.Topmost = true;      // На передний план
                App.Current.MainWindow.WindowState = WindowState.Maximized;// Развернуть
                App.Current.MainWindow.ResizeMode = ResizeMode.NoResize;// Неизменяемое
    
                menu.Visibility = Visibility.Collapsed;// Скрываем меню
                HookSystemKeys.FunHook();// Запрещаем системные клавиши
                this.Visibility = Visibility.Visible;
    
                fullScreen = true;
                changeScreen.Header = "WindowScreen";
            }
            else // Восстанавливаем оконный режим
            {
                this.WindowStyle = windowStyle;
                this.Topmost = false;
                this.WindowState = windowState;
                this.ResizeMode = resizeMode;
    
                menu.Visibility = Visibility.Visible;// Показываем меню
                HookSystemKeys.FunUnHook();// Освобождаем системные клавиши
    
                fullScreen = false;
                changeScreen.Header = "FullScreen";
            }
        }
    
        private void Window_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Escape)
                this.Close();
        }
    }
}

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
    
// Для перечисления Keys 
using System.Windows.Forms; 
    
namespace FullScreen
{
    // Отключение системной клавиши
    // http://www.sql.ru/Forum/actualthread.aspx?tid=632552
    class HookSystemKeys
    {
        private const int WH_KEYBOARD_LL = 13;
        private const int WM_KEYUP = 257;// Отпускание любой клавиши
    
        private static LowLevelKeyboardProc _proc = HookCallback;
        private static IntPtr _hookID = IntPtr.Zero;
    
        // Поддержка флагов состояния системных клавиш 
        static bool CtrlKey, AltKey, WinKey;
        private static void StateKey(int vkCode, IntPtr wParam)
        {
            switch ((Keys)vkCode)
            {
                case Keys.LControlKey:
                case Keys.RControlKey:
                    if (wParam == (IntPtr)WM_KEYUP)
                        CtrlKey = false;
                    else
                        CtrlKey = true;
                    break;
                case Keys.LMenu:
                case Keys.RMenu:
                    if (wParam == (IntPtr)WM_KEYUP)
                        AltKey = false;
                    else
                        AltKey = true;
                    break;
                case Keys.LWin:
                case Keys.RWin:
                    if (wParam == (IntPtr)WM_KEYUP)
                        WinKey = false;
                    else
                        WinKey = true;
                    break;
            }
        }
    
        // Общедоступная упаковка оригинала
        public static void FunHook()
        {
            _hookID = SetHook(_proc);
        }
        public static void FunUnHook()
        {
            UnhookWindowsHookEx(_hookID);
        }
    
        private static IntPtr SetHook(LowLevelKeyboardProc proc)
        {
            using (Process curProcess = Process.GetCurrentProcess())
            using (ProcessModule curModule = curProcess.MainModule)
            {
                return SetWindowsHookEx(WH_KEYBOARD_LL, proc, 
                    GetModuleHandle(curModule.ModuleName), 0);
            }
        }
    
        private delegate IntPtr LowLevelKeyboardProc(int nCode, 
            IntPtr wParam, IntPtr lParam);
    
        private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
        {
            int vkCode = Marshal.ReadInt32(lParam);
            StateKey(vkCode, wParam);
            if (WinKey                                      // Системная
                || CtrlKey && (Keys)vkCode == Keys.Escape   // Ctrl+Esc
                || AltKey && (Keys)vkCode == Keys.Escape    // Alt+Esc
                || AltKey && (Keys)vkCode == Keys.Tab)      // Alt+Tab
            {
                return (IntPtr)1;
            }
            else
                return CallNextHookEx(_hookID, nCode, wParam, lParam);
        }
    
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr SetWindowsHookEx(int idHook,
            LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);
    
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern bool UnhookWindowsHookEx(IntPtr hhk);
    
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, 
            IntPtr wParam, IntPtr lParam);
    
        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr GetModuleHandle(string lpModuleName);
    }
}