Windows forms на весь экран

Как использовать OAuth2 со Spring Security в Java

Javaican 14.05.2025

Протокол OAuth2 часто путают с механизмами аутентификации, хотя по сути это протокол авторизации. Представьте, что вместо передачи ключей от всего дома вашему другу, который пришёл полить цветы, вы. . .

Анализ текста на Python с NLTK и Spacy

AI_Generated 14.05.2025

NLTK, старожил в мире обработки естественного языка на Python, содержит богатейшую коллекцию алгоритмов и готовых моделей. Эта библиотека отлично подходит для образовательных целей и. . .

Реализация DI в PHP

Jason-Webb 13.05.2025

Когда я начинал писать свой первый крупный PHP-проект, моя архитектура напоминала запутаный клубок спагетти. Классы создавали другие классы внутри себя, зависимости жостко прописывались в коде, а о. . .

Обработка изображений в реальном времени на C# с OpenCV

stackOverflow 13.05.2025

Объединение библиотеки компьютерного зрения OpenCV с современным языком программирования C# создаёт симбиоз, который открывает доступ к впечатляющему набору возможностей. Ключевое преимущество этого. . .

POCO, ACE, Loki и другие продвинутые C++ библиотеки

NullReferenced 13.05.2025

В C++ разработки существует такое обилие библиотек, что порой кажется, будто ты заблудился в дремучем лесу. И среди этого многообразия POCO (Portable Components) – как маяк для тех, кто ищет. . .

Паттерны проектирования GoF на C#

UnmanagedCoder 13.05.2025

Вы наверняка сталкивались с ситуациями, когда код разрастается до неприличных размеров, а его поддержка становится настоящим испытанием. Именно в такие моменты на помощь приходят паттерны Gang of. . .

Создаем CLI приложение на Python с Prompt Toolkit

py-thonny 13.05.2025

Современные командные интерфейсы давно перестали быть черно-белыми текстовыми программами, которые многие помнят по старым операционным системам. CLI сегодня – это мощные, интуитивные и даже. . .

Конвейеры ETL с Apache Airflow и Python

AI_Generated 13.05.2025

ETL-конвейеры – это набор процессов, отвечающих за извлечение данных из различных источников (Extract), их преобразование в нужный формат (Transform) и загрузку в целевое хранилище (Load). . . .

Выполнение асинхронных задач в Python с asyncio

py-thonny 12.05.2025

Современный мир программирования похож на оживлённый мегаполис – тысячи процессов одновременно требуют внимания, ресурсов и времени. В этих джунглях операций возникают ситуации, когда программа. . .

Работа с gRPC сервисами на C#

UnmanagedCoder 12.05.2025

gRPC (Google Remote Procedure Call) — открытый высокопроизводительный RPC-фреймворк, изначально разработанный компанией Google. Он отличается от традиционых REST-сервисов как минимум тем, что. . .

• Download demo project — 13.65 KB

Introduction

One of the sounds-like-simple questions is “how to make your application truly Full Screen”, i.e. not showing Taskbar or anything like that.

The initial approach is obvious…

    targetForm.WindowState = FormWindowState.Maximized;
    targetForm.FormBorderStyle = FormBorderStyle.None;
    targetForm.TopMost = true;

… assuming that the target form is referenced with targetForm.

Does it work? Well, sort of. If your Taskbar has default setting unchecked for “Keep the taskbar on top of other Windows”, this will present your application in all its glory all over the screen estate.

However, if the Taskbar is set to appear on top of all others, this won’t help — your application won’t cover it.

Update For This Approach

In the discussion of the article (below) Azlan David (thanks David!) suggested to try this approach:

targetForm.FormBorderStyle = FormBorderStyle.None;
targetForm.WindowState = FormWindowState.Maximized;

(Just changed the order of property assignments.) It does the work on all Win XP SP2 computers where I had the opportunity to test it; however, on one Win 2003 SP1 computer, this did not help; I’m still investigating why.

Let’s go further — the next step is to use P/Invoke and to engage the Win32 API services. There is an easy way to hide a particular window. So, find the Taskbar and hide it:

private const int SW_HIDE = 0;
private const int SW_SHOW = 1;

[DllImport("user32.dll")]
private static extern int FindWindow(string className, string windowText);
[DllImport("user32.dll")]
private static extern int ShowWindow(int hwnd, int command);

int hWnd = FindWindow("Shell_TrayWnd", "");
ShowWindow(hWnd, SW_HIDE);

targetForm.WindowState = FormWindowState.Maximized;
targetForm.FormBorderStyle = FormBorderStyle.None;
targetForm.TopMost = true;

(You need to add using System.Runtime.InteropServices;)

Is this better? In theory, yes — the Taskbar is hidden, but your application still does not occupy the whole screen — the place where the Taskbar was is not used.

The real and proven solution is to make a request to WinAPI that your form take the whole screen estate — Taskbar will hide itself in that case. Full information about that can be found in the KB article Q179363: How To Cover the Task Bar with a Window.

The steps are as follows:

• Find out the dimension of the screen estate by calling GetSystemMetrics
• Set the dimensions of your form to full screen

Here is the actual code:

public class WinApi
{
    [DllImport(”user32.dll”, EntryPoint = “GetSystemMetrics”)]
    public static extern int GetSystemMetrics(int which);

    [DllImport(”user32.dll”)]
    public static extern void
        SetWindowPos(IntPtr hwnd, IntPtr hwndInsertAfter,
                     int X, int Y, int width, int height, uint flags);        

    private const int SM_CXSCREEN = 0;
    private const int SM_CYSCREEN = 1;
    private static IntPtr HWND_TOP = IntPtr.Zero;
    private const int SWP_SHOWWINDOW = 64; 

    public static int ScreenX
    {
        get { return GetSystemMetrics(SM_CXSCREEN);}
    }

    public static int ScreenY
    {
        get { return GetSystemMetrics(SM_CYSCREEN);}
    }

    public static void SetWinFullScreen(IntPtr hwnd)
    {
        SetWindowPos(hwnd, HWND_TOP, 0, 0, ScreenX, ScreenY, SWP_SHOWWINDOW);
    }
}




public class FormState
{
    private FormWindowState winState;
    private FormBorderStyle brdStyle;
    private bool topMost;
    private Rectangle bounds;

    private bool IsMaximized = false;

    public void Maximize(Form targetForm)
    {
        if (!IsMaximized)
        {
            IsMaximized = true;
            Save(targetForm);
            targetForm.WindowState = FormWindowState.Maximized;
            targetForm.FormBorderStyle = FormBorderStyle.None;
            targetForm.TopMost = true;
            WinApi.SetWinFullScreen(targetForm.Handle);
        }
    }

    public void Save(Form targetForm)
    {
        winState = targetForm.WindowState;
        brdStyle = targetForm.FormBorderStyle;
        topMost = targetForm.TopMost;
        bounds = targetForm.Bounds;
    }

    public void Restore(Form targetForm)
    {
        targetForm.WindowState = winState;
        targetForm.FormBorderStyle = brdStyle;
        targetForm.TopMost = topMost;
        targetForm.Bounds = bounds;
        IsMaximized = false;
    }
}

Now you can use the above class in your WinForms application like this:

public partial class MaxForm : Form
{
    FormState formState = new FormState();

    public MaxForm()
    {
        InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e)
    {
        formState.Maximize(this);
    }

    private void button2_Click(object sender, EventArgs e)
    {
        formState.Restore(this);
    }
}

The full code and example application can be downloaded from the link at the top of this article.

History

• 3^rd December, 2006: Initial post

Для изучения данного материала понадобится знать следующее:

1. Инициализация библиотеки Tao OpenGL на языке C# в среде .NET
2. Подробное описание инициализации и визуализации в OpenGL на языке C#

В принципе, переход в полноэкранный режим (далее ПР — задача довольно простая, но требует значительных затрат по времени при написании кода. Однако, один раз написав код, вы можете без труда использовать его во всех OpenGL приложениях.
Нужно сказать сразу, что полная инициализация П� через WinApi здесь рассматриваться не будет, иначе зачем тогда использовать С# и .Net-обвертки типа ТАО? Также нужно отметить, что сам по себе С# дает падение производительности при обработке графики примерно на 15%.

И наконец, по небольшому, но собственному опыту скажу, что работать с графикой в родном С++ все-таки удобней.
Весь процесс создания полноэкранного режима разобьем на две части:

1. Создание оконного масштабируемого приложения
2. «Простая инициализация» полноэкранного режима

Создание оконного масштабируемого приложения

Подготовка оконного масштабируемого приложения

Для начала создаем проект Windows Forms и дадим ему название TAO_Fullscreen_Mode. Точно так же, как и в уроке «Инициализация библиотеки Tao OpenGL на языке C# в среде .NET», добавляем ссылки (Links) на библиотеки Tao.OpenGL.dll, Tao.FreeGlut.dll, Tao.Platform.Windows.dll.

Главное окно программы переименуем из Form1 в FormFS, параметр Name в свойствах окна (рис. 1).

Дадим ему название TAO Fullscreen Form (параметр Text). Наше приложение будет использовать реакции нажатия клавиш. Для того, чтобы включить обработчик событий нажатия клавиш, необходимо в свойствах формы для параметра KeyPreview выставить значение True (рис. 1).

Таким образом, когда наше окно имеет фокус (выделено в настоящий момент) будут обрабатываться события нажатия клавиш клавиатуры.
Рисунок 1. KeyPreview.

Необходимо также поместить на форму элемент управления SimpleOpenGlControl. В свойствах элемента нужно изменить параметр Dock на значение Fill (окно примет вид, как показано на рисунке 2) и переименовать его в TaoWin.

Картинка с сайта: esate.ru

Рисунок 2. Изменения параметра Dock на значение Fill.
Теперь можно отложить мышку в сторону и перейти непосредственно к написанию кода. Для работы с импортированными библиотеками, необходимо включить соответствующие пространства имен:

Листинг 1:

/*http://esate.ru, KinsT*/

using System;
using System.Drawing;
using System.Windows.Forms;
// Библиотеки для работы с графикой;
using Tao.OpenGl;
using Tao.Platform.Windows;
using Tao.FreeGlut;

Используя директивы #region и #endregion, выделите блок кода внутри класса FormFS и дайте этому блоку название «+++ GLOBAL +++». Сейчас Ваш код должен выглядеть, как показано в Листинге 2:

Листинг 2:

/*http://esate.ru, KinsT*/

namespace TAO_Fullscreen_Mode
{
    public partial class FormFS : Form
    {
        #region +++ GLOBAL +++
        
        #endregion

        public FormFS()
        {
            InitializeComponent();
        }
    }
} 

Создадим переменную FS типа bool внутри блока GLOBAL, чтобы она была видна во всех функциях-методах данного класса. Переменная FS является флагом указывающим, какой из режимов полноэкранный или оконный выбран для работы приложения в данный момент.

Необходимо также добавить еще один конструктор класса с параметром (вообще говоря, можно просто изменить стандартный, но этика программирования мне подсказывает, что от стандартных конструкторов без параметров при написании кода лучше не отказываться). В качестве параметра конструктора будем использовать переменную типа bool с названием fullscreen. В каждом конструкторе инициализируем работу элемента TaoWin.

Листинг 3:

/*http://esate.ru, KinsT*/

namespace TAO_Fullscreen_Mode
{
    public partial class FormFS : Form
    {
        #region +++ GLOBAL +++
        // Флаг полноэкранного режима;
        private bool FS;
        #endregion

        public FormFS()
        {
            InitializeComponent();
            // Инициализируем работу TaoWin;
            TaoWin.InitializeContexts();
        }
        public FormFS(bool fullscreen)
        {
            InitializeComponent();
       // Инициализируем работу TaoWin;
            TaoWin.InitializeContexts();
        }
    }
} 

Таким образом, конструктор с параметром будет определять в каком режиме запустить приложение, а стандартный конструктор без параметра по-умолчанию запустит приложение в оконном режиме.

Создайте функцию private void InitGL() в которой будем проводить инициализацию OpenGL. Все настройки, которые касаются OpenGL-сцены, расположены именно в этой функции:

Листинг 4:

/*http://esate.ru, KinsT*/

        // Инициализация OpenGL
        private void InitGL()
        {
            Glut.glutInit();
            Glut.glutInitDisplayMode(Glut.GLUT_RGBA |
                Glut.GLUT_DEPTH |
                Glut.GLUT_DOUBLE);
            // Разрешить плавное цветовое сглаживание;
            Gl.glShadeModel(Gl.GL_SMOOTH);
            // Разрешить тест глубины;
            Gl.glEnable(Gl.GL_DEPTH_TEST);
            // Разрешить очистку буфера глубины;
            Gl.glClearDepth(1.0f);
            // Определение типа теста глубины;
            Gl.glDepthFunc(Gl.GL_LEQUAL);
            // Слегка улучшим вывод перспективы;
            Gl.glHint(Gl.GL_PERSPECTIVE_CORRECTION_HINT, Gl.GL_NICEST);
            // Разрешаем смешивание;
            Gl.glEnable(Gl.GL_BLEND);
            // Устанавливаем тип смешивания;
            Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
        }

В функции glutInitDisplayMode(…) мы инициализировали двойной буфер кадра, буфер глубины и режим отображения цветов GLUT_RGBA — для вывода цвета будет использовано три компоненты цвета + альфа канал прозрачности. Использование такой модели цветов дает возможность в дальнейшем использовать смешивание и использовать по выбору различные режимы сглаживания (точек, линий, полигонов).

Последние три функции кода рассмотрим подробнее:

• Gl.glHint (target, mode) – управляет способом выполнения растеризации примитивов и может принимать различные параметры. Так в качестве target могут выступать следующие:
• GL_FOG_HINT — точность вычислений при наложении тумана;
• GL_LINE_SMOOTH_HINT — управление качеством прямых;
• GL_PERSPECTIVE_CORRECTION_HINT — точность интерполяции координат при вычислении цветов и наложении текстуры;
• GL_POINT_SMOOTH_HINT — управление качеством точек;
• при значении параметра mode равном GL_NICEST точки рисуются как окружности;
• GL_POLYGON_SMOOTH_HINT — управление качеством вывода сторон многоугольника.

В качестве параметра mode выступают такие параметры:

• GL_FASTEST — используется наиболее быстрый алгоритм рисования;
• GL_NICEST — используется алгоритм, обеспечивающий лучшее качество;
• GL_DONT_CARE — выбор алгоритма зависит от реализации;
• Gl.glEnable(Gl.GL_BLEND) – разрешаем смешивание. Эту функцию необходимо вызывать, если в дальнейшем вы планируете, к примеру, наслаивать друг на друга слои с различной степенью прозрачности;
• Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA) – выбираем наиболее подходящие параметры смешивания.

Далее необходимо создать функцию изменения размеров окна OpenGL (сцены) private void ResizeGlScene(). Эта функция должна быть вызвана всякий раз, когда мы хотим изменить размеры сцены. Например, при растягивании окна мышью, когда мы находимся в оконном режиме. Также эта функция должна быть вызвана хотя бы один раз при инициализации ПР, чтобы установить размеры области вывода и настроить нашу сцену перед отрисовкой.

Размер сцены устанавливается в зависимости от текущих размеров элемента TaoWin, это как раз одно из свойств, благодаря которому можно упростить себе работу при инициализации ПР.

Листинг 5:

/*http://esate.ru, KinsT*/

        // Изменение размеров окна OpenGL
        void ResizeGlScene()
        {
            // Предупредим деление на нуль;
            if (TaoWin.Height == 0)
            {
                TaoWin.Height = 1;
            }
            // Сбрасываем текущую область просмотра;
            Gl.glViewport(0, 0, TaoWin.Width, TaoWin.Height);
            // Выбираем матрицу проекций;
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            // Сбрасываем выбранную матрицу;
            Gl.glLoadIdentity();
            // Вычисляем новые геометрические размеры сцены;
            Glu.gluPerspective(45.0f, 
                (float)TaoWin.Width / (float)TaoWin.Height, 
                0.1f, 100.0f);
            // Выбираем матрицу вида модели;
            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            // Сбрасываем ее;
            Gl.glLoadIdentity();
        } 

Хотелось бы отметить следующее, что при вызове функции gluPerspective и задании ее параметров нужно быть внимательным, хотя в определении функции и написано, что параметры имеют тип double, но лучше приводить все параметры к типу float. Ниже приведу описание каждого параметра функции:

Функция gluPerspective — устанавливает матрицу перспективной проекции.

void gluPerspective (GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar); fovy — область угла просмотра по вертикали в градусах;

aspect — (ширина области просмотра)/(высота области просмотра). Очень важный параметр, если не привести его к типу float, то вместо шарика Вы обязательно получите яйцо.

zNear — расстояние до ближней плоскости отсечения (всё что ближе — не рисуется);

zFar — расстояние до дальней плоскости отсечения (всё что дальше — не рисуется).

Теперь, когда Вы имеете все функции необходимые для инициализации сцены, нужно создать функцию, которая будет подготавливать все, что Вы захотите нарисовать. Назовем ее private void DrawGlScene(), код данной функции приведен в Листинге 6:

Листинг 6:

/*http://esate.ru, KinsT*/

//РИСОВАНИЕ СЦЕНЫ
        private void DrawGlScene()
        {
            // Выбираем цвет очистки экрана;
            Gl.glClearColor(0.0f, 0.8f, 0.0f, 1.0f);
            // Очищаем экран выбранным цветом;
            Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
            // Сбрасываем текущую матрицу проекций;
            Gl.glLoadIdentity();
            // Обязательно нужно сместиться по оси Z,
            // иначе ни чего не будет видно;
            Gl.glTranslatef(0, 0, -3.0f);

            Gl.glPushMatrix();
            // Здесь можно рисовать что угодно :)
            Gl.glPopMatrix();

            Gl.glFlush();
            TaoWin.Invalidate();
        }

Для запуска приложения необходимо, во-первых, провести инициализацию OpenGL-сцены с помощью подготовленных ранее функций, а во-вторых, добавить обработчик события происходящего при изменении размеров окна. Не будем останавливаться и проведем инициализацию OpenGL, для этого добавим вызов функций InitGL(), ResizeGlScene() и DrawGlScene() в конструкторы класса FormFS. Причем последовательность вызова функций в этом случае имеет большое значение!

Листинг 7:

/*http://esate.ru, KinsT*/

#region CONSTRUCTORS
        public FormFS()
        {
            InitializeComponent();
            // Инициализируем работу TaoWin;
            TaoWin.InitializeContexts();
            // Инициализация OpenGL
            // !!!Последовательность строк имеет значение!!!
            InitGL();
            ResizeGlScene();
            DrawGlScene();
        }

        public FormFS(bool fullscreen)
        {
            InitializeComponent();
            // Инициализируем работу TaoWin;
            TaoWin.InitializeContexts();
            // Инициализация OpenGL
            // !!!Последовательность строк имеет значение!!!
            InitGL();
            ResizeGlScene();
            DrawGlScene();
        }
#endregion

Теперь настало время вспомнить о мышке! Перейдите к конструктору формы и выделите мышью форму FormFS. Далее зайдите в «Свойства», далее в «События» (Events;), кнопка с желтой молнией (рис.3). Выберите свойство Resize и нажмите двойным кликом на белом поле. После этого студия сгенерирует обработчик этого события, внутри него поместите вызов функций ResizeGlScene() и DrawGlScene(), порядок следования тоже имеет значение. Потому что вначале должно произойти изменений размеров сцены, а потом уже отрисовка.
Рисунок 3. Выбор обработчика для события Resize.

Листинг 8:

/*http://esate.ru, KinsT*/

// Обработчик события изменения размеров формы;
        private void FormFS_Resize(object sender, EventArgs e)
        {
            // Вначале изменим размеры сцены;
            ResizeGlScene();
            // А потом перерисуем;
            DrawGlScene();
        }

Теперь оконное масштабируемое приложение готово к работе, смело запускайте! Ну что, ни каких ошибок не обнаружено? Тогда будем двигаться дальше и перейдем непосредственно к инициализации полноэкранного режима.

«Простая инициализация» полноэкранного режима

Добавьте следующий код рисования диска в функцию DrawGlScene(), между Gl.glPushMatrix() и Gl.glPopMatrix(). Этот код нужен только для нас, чтобы мы могли видеть правильность отображения на экране (масштабируемость изображения, отсутствие эффекта «яйца» и т.д.):

Листинг 9:

/*http://esate.ru, KinsT*/

//
            Gl.glPushMatrix();
            // Здесь можно рисовать что угодно :)
            Glu.GLUquadric disk = Glu.gluNewQuadric();
            Glu.gluQuadricDrawStyle(disk, Glu.GLU_FILL);
            Gl.glColor3ub(255, 0, 150);
            Glu.gluDisk(disk, 0.5, 1.0, 30, 1);

            Gl.glPopMatrix();

Наконец, создадим функцию private void ScreenMode(bool fullscreen), которая отвечает за изменение режима отображения окна – либо в ПР, либо в оконном режиме:

Листинг 10:

/*http://esate.ru, KinsT*/

// Смена режима (Fullscreen/Window)
        private void ScreenMode(bool fullscreen)
        {
            // Присваиваем значение "глобальной" переменной;
            FS = fullscreen;

            if (FS)
            {   // *** ПОЛНОЭКРАННЫЙ РЕЖИМ ***
                // Скрываем рамку окна;
                this.FormBorderStyle = FormBorderStyle.None;
                // Разворачиваем окно;
                this.WindowState = FormWindowState.Maximized;
                // --- Не обязательный пункт --- 
                // Делаем курсор в форме руки;
                // TaoWin.Cursor = Cursors.Hand;
            }
            else
            {   // *** ОКОННЫЙ РЕЖИМ ***
                // Возвращаем состояние окна;
                this.WindowState = FormWindowState.Normal;
                // Показываем масштабируемую рамку окна;
                this.FormBorderStyle = FormBorderStyle.Sizable;
                // --- Не обязательный пункт ---
                // Возвращаем курсор по-умолчанию;
                // TaoWin.Cursor = Cursors.Default;
                // Задаем размеры окна;
                this.Width = 400;   // Ширина;
                this.Height = 300;  // Высота;
            }
            ResizeGlScene();
        }

Если Вы уже успели заметить, то в приведенном выше коде, нет ни каких особенных трудностей или секретов. Используются только стандартные оконные преобразования путем вызова нужных функций.

Сейчас кто-то может сказать: «То, что здесь написано, не имеет ни какого отношения к игровому режиму!», но если посудить логически и посмотреть, скажем, на исходный код П� написанный на С с применением WinApi функций, то Вы увидите, что там ни чего отличного от нашего кода не происходит (кроме задания вручную формата пикселей для всего экрана). Тем более, что Джель не умеет создавать «свой» собственный ПР, как скажем Managet DirectX.

Итак, что же мы делаем:

Шаг 1. Проверяем флаг ПР. Если мы находимся в ПР, то нужно убрать рамку (Border окна. Далее, присваивая свойству WindowState (отвечает за состояние окна: свернуто, развернуто или восстановлено) параметр FormWindowState.Maximized, разворачиваем наше окно на весь экран.

Шаг 2. Если мы оказались в оконном режиме, то присваиваем свойству WindowState параметр FormWindowState.Normal – восстанавливаем наше окно. Через свойство FormBorderStyle зададим окну границу с изменяемыми размерами (FormBorderStyle.Sizable;).

Шаг 3. В самом конце через свойства Width и Height зададим начальный размер окна, когда его размеры изменены, нужно вызвать функцию изменения размеров OpenGL сцены ResizeGlScene().

Теперь осталось заполнить обработчик событий нажатия клавиатуры. Перейдите к конструктору формы и выделите мышью форму FormFS. Далее зайдите в «Свойства» -> «События» (Events; ), кнопка с желтой молнией (рис. 3).

Выберите свойство KeyUp и нажмите двойным кликом на белом поле. Студия генерирует обработчик события. Нам нужно создать три различных реакции:

1. Выход из приложения: для выхода из приложения будем использовать клавишу ЕSCAPE. Пишем для нее обработчик, дословно: «Если код НАЖАТОЙ кнопки совпадает с кодом клавиши ЕSCAPE, то завершим наше приложение». Точно такое же правило будет использовано для других кнопок, только вместо «завершим наше приложение» будет прописан вызов соответствующих функций.
2. Переход в полноэкранный режим: переход в П� будем производить по нажатию на кнопку F2. Когда кнопка нажата вызываем функцию ScreenMode(… ) с параметром true. И прячем наш курсор мыши Cursor.Hide().
3. Переход в оконный режим: возвращаться в оконный режим будем по нажатию клавиши F1. Когда кнопка нажата вызываем функцию ScreenMode(… ) с параметром false. Показываем курсор Cursor.Show().

Листинг 11:

/*http://esate.ru, KinsT*/

// События нажатий клавиш клавиатуры; 
        private void FormFS_KeyUp(object sender, KeyEventArgs e)
        {
            #region EXIT
            // Нажата клавиша ЕSCAPE;
            if (e.KeyCode == Keys.Escape)
            {
                // Завершим приложение;
                this.Close();
            }
            #endregion

            #region Полноэкранный или оконный режим
            // Нажата клавиша F2;
            if (e.KeyCode == Keys.F2)
            {
                // Изменяем режим на ПОЛНОЭКРАННЫЙ;
                ScreenMode(true);
                // Прячем курсор;
                Cursor.Hide();
            }
            // Нажата клавиша F1;
            if (e.KeyCode == Keys.F1)
            {
                // Изменяем режим на оконный;
                ScreenMode(false);
                // Показываем курсор;
                Cursor.Show();
            }
            #endregion
        }

Вот, пожалуй, и все!

Компилируем, запускаем и жмем по очереди на кнопки F2, F1, пробуем растягивать наше окно и жмем в конце ЕSCAPE.�

На этом первая часть урока закончилась! В следующей части урока «Полноэкранный режим C# + TAO Framework», мы обогатим наше приложение: добавим возможность выбора разрешения экрана, глубины цвета и частоты обновления экрана.

Жду Ваших комментариев!

ИСТОЧНИКИ:

Михаил Фленов:

http://www.flenov.info/favorite.php?artid=292
http://pmg.org.ru/nehe/nehe01.htm3
http://www.opengl.org.ru/books/open_gl/chapter4.15.html

ФАЙЛЫ ПРОЕКТА

Скачать исходный код проекта (VS 2008)