С Вами Артур Валиев V.
Когда-то давно я начинал писать музыку на пятнадцатидюймовом ЭЛТ-мониторе. Кажется, это был какой-то старенький 550S — огромная тяжёлая коробка с выпуклым стеклом, занимавшая приличную часть стола.
А ещё у меня был диск.
Один из тех дисков из далёкого и уже почти забытого компьютерного прошлого: сборник программ, который мой брат когда-то купил на Горбушке. Я не знаю, зачем он его купил. Диск несколько лет лежал среди игр, драйверов и прочего компьютерного хлама, пока однажды после игр, учёбы и обычной подростковой суеты мне просто не стало скучно.
Я достал его и начал устанавливать всё подряд. Среди программ оказалась FL Studio, кажется, третья версия. Поставил совершенно случайно, открыл, ничего особенно не понял и начал стучать по барабанам.
Не писать музыку. Не заниматься продакшеном. Не строить планы на будущее. Просто нажимать на квадратики и слушать, что получается.
Зачем я вообще начинаю статью про системное приложение для Windows с какого-то старого диска и ЭЛТ-монитора?
Потому что эта статья на самом деле не столько про мониторы.
Она про пространство.
Где заканчивается компьютер?
С тех времён изменилось почти всё. Компьютеры стали несравнимо мощнее, ЭЛТ исчезли со столов, программы научились делать вещи, которые тогда выглядели фантастикой. У меня давно уже не один пятнадцатидюймовый экран — я работаю с двумя мониторами и считаю это одной из лучших вещей, которые вообще произошли с персональным компьютером.
К нескольким мониторам очень быстро привыкаешь. IDE можно оставить на одном, документацию или браузер — на другом. Не нужно постоянно сворачивать окна, перекладывать их друг на друга и вспоминать, где что лежит. Информация не меняется, но меняется пространство, в котором она существует.
И вот однажды мне стало интересно: почему мы вообще воспринимаем монитор как границу?
Курсор движется вправо. Доходит до края матрицы. Если справа стоит второй монитор — продолжает движение. Если не стоит — всё. Мир закончился.
Мы настолько привыкли к этому, что почти не замечаем странности происходящего.
Перед человеком стоит прямоугольный кусок стекла. Операционная система рисует внутри него окна, текст, кнопки, изображения, видео. И спустя какое-то время наш мозг перестаёт воспринимать этот прямоугольник как физическое устройство. Для нас это уже пространство.
Слева у меня код. Справа браузер. Где-то там терминал. Тут Telegram. Там музыка.
Мы даже говорим: «перетащи окно на другой экран», хотя на самом деле никакое окно никуда физически не перемещается.
Меняются координаты.
И в какой-то момент я задал себе довольно глупый вопрос:
почему наше цифровое рабочее пространство должно заканчиваться одновременно с куском пластика и стекла на столе?
Компьютеру ведь всё равно.
А что, если за краем что-то есть?
Мне снова стало скучно.
Скука вообще довольно интересная вещь. Когда-то из неё случайно появилась FL Studio на моём компьютере. Спустя много лет она привела уже к совсем другому эксперименту.
Я захотел создать экран, которого рядом со мной физически не существует.
Не второй рабочий стол Windows. Не окно, внутри которого нарисован ещё один desktop. Не удалённый компьютер. Не красивую визуальную имитацию.
Настоящий монитор с точки зрения самой Windows.
Такой, которому операционная система даст собственные координаты, разрешение и частоту обновления. Такой, на который приложение сможет перейти в полноэкранный режим. Такой, куда можно унести браузер, терминал, IDE, 1С, Диадок, микшер, OBS или панель видеонаблюдения.
И самое главное — такой, к которому можно привыкнуть.
Так появился EvertyDisplay.
Первый работающий прототип произвёл на меня гораздо более странное впечатление, чем я ожидал.
У меня два физических монитора. Я добавил ещё один виртуальный и расположил его слева. Windows увидела три дисплея. Я взял окно мышью, потащил его к краю физического экрана и перенёс дальше.
Окно исчезло.
Не свернулось. Не закрылось. Не переехало на второй физический монитор.
Оно просто оказалось там.
На экране, которого нет.
Windows была совершенно довольна происходящим. Приложение было довольно. Координаты существовали. Рабочий стол продолжался. Окно продолжало жить.
Единственным участником этой системы, который знал, что никакого монитора слева на самом деле нет, был я.
И именно тогда мне стало по-настоящему интересно.
Монитор, который существует только потому, что все согласились считать его монитором
Если задуматься, физический монитор вообще не является рабочим пространством. Это устройство отображения рабочего пространства.
Звучит как незначительная разница, пока не попробуешь эти две сущности разделить.
В EvertyDisplay виртуальный дисплей определяется Windows как настоящий монитор. У него есть разрешение, частота обновления и место в общей топологии дисплеев. Windows может размещать на нём окна, приложения могут открываться там в fullscreen, курсор может перемещаться между физическими и виртуальными областями.
То есть с точки зрения программного мира экран есть.
А с точки зрения физического мира его нет.
Где в таком случае он находится?
Наверное, самый точный ответ — нигде.
И одновременно там, куда вы его поставили.
Если виртуальный монитор расположен справа от основного, спустя некоторое время правая граница настоящего экрана начинает ощущаться не как конец, а как дверь. Если слева — дверь появляется слева. Если сверху — сверху.
Мозгу удивительно мало нужно, чтобы принять новую геометрию пространства.
Мы привыкли думать, что для ощущения большого рабочего стола необходимо окружить себя панелями. Но оказалось, что значительная часть этого ощущения возникает не из-за самих панелей, а из-за устойчивой пространственной модели.
Я знаю, что справа находится браузер.
Знаю, что слева лежит терминал.
Мне необязательно постоянно видеть их одновременно, если я понимаю, где они находятся.
Возможно, мы вообще воспринимаем компьютер не глазами.
Мы воспринимаем его памятью о расположении вещей.
EvertyDisplay — не ещё один Virtual Desktop
Здесь важно разделить две идеи, потому что внешне они могут показаться похожими.
В Windows давно существуют виртуальные рабочие столы. Они прекрасны, но работают иначе. Когда вы переключаете desktop, пространство фактически сменяется другим пространством.
EvertyDisplay исходит из другой модели.
Пространство не переключается. Оно продолжается.
Окно справа действительно находится справа. Окно сверху находится сверху. Между ними существует геометрия. Курсор движется внутри этой геометрии так же, как если бы соответствующие физические панели стояли вокруг вас.
Внутри программы есть двухмерная схема дисплеев. Физические и виртуальные экраны можно расставлять относительно друг друга: слева, справа, сверху, снизу, вертикально, горизонтально, сеткой. Windows умеет работать и с отрицательными координатами, поэтому монитор слева от основного совершенно нормально может находиться условно в области (-2560, 0).
EvertyDisplay строит из этой топологии граф соседей и понимает, какой экран действительно находится за конкретной границей.
На словах всё это звучит почти банально.
Подвинул курсор вправо — перешёл вправо.
Ровно до того момента, пока не начинаешь это программировать.
Курсор оказался сложнее монитора
У Windows есть замечательное свойство: почти любая вещь, которая кажется очевидной пользователю, становится значительно менее очевидной, когда пытаешься реализовать её на системном уровне.
Возьмём простейший сценарий.
Пользователь пересекает границу экрана. EvertyDisplay должен понять направление движения, определить соседний дисплей, сопоставить координаты и перенести курсор.
После этого Windows сообщает программе новое событие движения мыши.
Проблема в том, что мышь двигал уже не пользователь.
Её двигал EvertyDisplay.
Если отнестись ко второму событию как к обычному пользовательскому вводу, программа может решить, что курсор снова пересёк границу, и отправить его назад.
Получается прекрасный вечный двигатель из двух мониторов.
Пользователь идёт вправо, программа переносит его, Windows сообщает о новом движении, программа трактует его как очередной переход, курсор возвращается, снова возникает событие — и дальше начинается дискотека.
Поэтому пришлось разделять реальные и синтетические события, вводить защиту от повторной активации, учитывать направление, конкретную границу, текущий дисплей и небольшие временные окна подавления.
И тут особенно интересно наблюдать, как философская идея «а давайте продолжим пространство за границей экрана» довольно быстро превращается в HWND, HMONITOR, callbacks, хуки мыши и разбор того, кто именно секунду назад передвинул указатель на три пикселя.
Так обычно и выглядит романтика системного программирования.
Перетащить окно туда, где ничего нет
После перехода курсора мне захотелось следующего естественного поведения.
Если я держу окно мышью и ухожу на виртуальный монитор, окно должно отправиться вместе со мной.
Так появился Drag-to-Teleport.
Название немного громкое, но ощущается это действительно почти как телепортация. Вы хватаете обычное окно, ведёте его к границе физического дисплея, пересекаете её — и окно уходит в виртуальное пространство.
При этом недостаточно просто вызвать функцию Windows и переместить прямоугольник куда-нибудь в соседние координаты. Мониторы могут иметь разное разрешение, разный DPI, разную высоту и даже лишь частично пересекаться друг с другом. Один может находиться в положительных координатах, другой — в отрицательных. Нужно сохранить относительное положение курсора внутри окна и не отправить половину интерфейса куда-то за доступную область.
Это один из тех моментов, когда за очень простой пользовательской механикой постепенно вырастает довольно серьёзная геометрическая модель.
Но пользователь всего этого знать не должен.
Он просто берёт окно и уносит его.
Для меня это вообще один из главных критериев нормальной системной программы: чем сложнее код внутри, тем естественнее должно становиться действие снаружи.
Хорошо. Я унёс окно. Как теперь его увидеть?
И вот здесь возникает главный вопрос ко всей идее.
Если монитор виртуальный и физически его нет, зачем туда вообще что-то отправлять?
Ответ зависит от сценария.
Иногда содержимое экрана не требуется видеть постоянно. Например, там может жить мониторинг, консоль, мессенджер, окно удалённой машины или инструмент, к которому я периодически возвращаюсь.
Но иногда видеть происходящее всё-таки нужно.
Поэтому в EvertyDisplay появились две сущности, которые я воспринимаю почти как порталы.
Первая — Live PiP (Это маленькое окошко где может быть Ваш любимый сериал на Main мониторе). Можно взять виртуальный дисплей и вывести его содержимое маленьким живым окном на физический монитор. Само приложение при этом остаётся на своём отдельном экране Windows, а вы лишь наблюдаете за ним через небольшое представление.
Вторая — Viewport. Он позволяет открыть виртуальный дисплей на физическом экране полноценно.
Захват строится через Direct3D 11, DXGI и Desktop Duplication API. Получается довольно забавная конструкция: Windows рендерит отдельный дисплей, которого физически нет, после чего EvertyDisplay может показать этот дисплей на экране, который физически есть.
Казалось бы: зачем тогда вообще было создавать виртуальный?
Потому что состояние приложения остаётся привязанным именно к отдельному дисплею.
Например, браузер с YouTube может находиться на виртуальном мониторе в настоящем полноэкранном режиме. Я могу уйти обратно на Main, а видео не перестанет быть fullscreen и не превратится обратно в обычное окно. Если мне понадобится посмотреть на него, я открою Viewport или PiP.
Мы не таскаем приложение туда-сюда.
Мы меняем точку, из которой на него смотрим.
И вот это мне кажется уже гораздо интереснее обычного управления окнами.
Пространство как состояние
В какой-то момент я понял, что EvertyDisplay постепенно перестаёт быть программой про «добавить виртуальный монитор».
Сам по себе виртуальный видеовыход создать недостаточно.
Настоящая задача начинается после его появления.
Где он расположен? Кто находится слева от него? Что произойдёт, если физический монитор отключить? Куда должен попасть курсор? Как вернуть окно? Как вести себя, если пользователь нажал значок программы на панели задач, а её окно находится на невидимом сейчас виртуальном экране? Что делать, если Windows решила открыть системный диалог на другом дисплее? Что произойдёт после сна, обновления драйвера или изменения разрешения?
Оказывается, пространство — это не прямоугольники.
Это отношения между ними.
EvertyDisplay хранит топологию, пересчитывает соседей, восстанавливает расположение и старается сделать так, чтобы после перезапуска экран находился там же, где пользователь привык его ощущать.
Потому что если сегодня терминал был слева, завтра он тоже должен быть слева.
Иначе рушится самое главное — пространственная память.
Windows не обещала, что мир останется таким же
Одна из самых неприятных особенностей этой задачи в том, что Windows прекрасно работает с несколькими дисплеями, но вовсе не обещает сохранять вашу красивую внутреннюю картину мира.
DISPLAY1, DISPLAY2, DISPLAY4 не являются вечными идентификаторами.
Удалили монитор — нумерация может измениться. Перезапустили драйвер — снова измениться. Вышли из сна, переподключили DisplayPort, обновили видеодрайвер — система имеет полное право сообщить уже немного другую топологию.
Поэтому довольно быстро пришлось отказаться от идеи «этот монитор был номером три, значит он навсегда номер три».
EvertyDisplay постоянно сверяет сохранённое состояние с реальным: смотрит системные имена устройств, принадлежность к виртуальному адаптеру, существующие выходы и уже после этого восстанавливает пользовательскую модель.
То есть программа не говорит Windows: «я помню мир именно таким, поэтому ты обязана со мной согласиться».
Она спрашивает:
«Что существует сейчас? Хорошо. А теперь попробуем понять, что из этого соответствует тому миру, который пользователь оставил вчера».
Мне вообще нравится этот подход.
Пожалуй, он применим не только к мониторам.
Даже создание экрана не происходит в один момент
Есть ещё одна занятная деталь.
Мы привыкли мыслить программами как последовательностью действий.
Создал монитор — монитор появился.
Но в Windows между этими двумя фразами может существовать довольно большой промежуток времени.
Драйвер уже сообщил, что новый выход создан. DisplayConfig ещё показывает старое состояние. GDI уже что-то видит. DXGI пока не способен открыть новый output. Графическая подсистема перестраивается. UI живёт ещё с предыдущей картиной мира.
Каждая система права.
Просто каждая находится в своём моменте времени.
Поэтому добавление виртуального дисплея в EvertyDisplay пришлось сделать чем-то похожим на прикладную транзакцию: запросить изменение, дождаться переинициализации, заново получить реальную топологию, найти новый выход, проверить его и только потом считать операцию завершённой. Если что-то пошло не так, состояние нужно откатить.
Настоящей транзакции здесь, разумеется, нет. Windows, сторонний драйвер, DXGI и моя программа не собирались однажды вместе и не договаривались соблюдать ACID.
Приходится строить эту предсказуемость сверху.
Возможно, значительная часть системного программирования вообще состоит именно из этого: создавать локальный порядок поверх мира, который не обещал быть синхронным.
Драйвер, Rust и немного честности
Здесь я сразу хочу провести важную границу.
Сам виртуальный видеоадаптер MttVDD не написан мной на Rust. Это отдельный подписанный компонент на базе Windows IddCx.
На Rust в EvertyDisplay написана окружающая система: оркестрация дисплеев, управление состоянием, топология, переходы курсора, работа с окнами и фокусом, IPC, интерфейс, захват, восстановление и связанная с этим логика.
Я специально это проговариваю, потому что не люблю статьи в стиле «я написал всё с нуля», когда внизу лежит несколько десятилетий чужой инженерии.
Мы все строим поверх чего-то. Все.
Windows строит поверх драйверов. Rust-программа строит поверх Win32. EvertyDisplay строит пользовательское пространство поверх виртуального видеовыхода.
Для меня авторство программы определяется не количеством собственноручно написанных транзисторов, а тем, какую новую систему ты смог собрать из существующих примитивов.
Почему снова Rust
Да, опять Rust.
Кажется, в какой-то момент мои статьи без него уже сложно представить.
Но в EvertyDisplay он появился не потому, что мне хотелось написать очередной проект на модном языке. Эта программа довольно неприятна с точки зрения владения состоянием.
Внутри одновременно существуют event loop интерфейса на Iced, асинхронный runtime, IPC, mouse hook, foreground hooks Windows, системный tray, D3D11-захват, операции с драйвером и периодическое обновление топологии. В целом это экосистема EvertyDesk, есть еще проект EvertyCloud где вы можете подключать сетевые диски устройств у кого установлен EvertyDesk next, но об это чуде я расскажу в другой раз.
И всё это должно уметь жить вместе.
Windows callback может прийти тогда, когда Windows считает нужным. D3D-ресурс может потеряться. UI может закрыться, но фоновая служба должна продолжить работу. Pipe может оборваться. Монитор может исчезнуть. Система может выйти из сна уже с другой конфигурацией экранов.
На границе с Win32 никакой сказки про полностью безопасный Rust, конечно, нет.
Там unsafe, сырые указатели, HANDLE, HWND, HMONITOR, COM, UTF-16, callback-функции с extern "system" и необходимость помнить, что дескриптор иногда нужно действительно закрыть, а не просто перестать на него смотреть.
Но именно здесь Rust оказался полезен.
Не тем, что убрал сложность.
Он заставил эту сложность очертить.
Кто владеет ресурсом? Кто имеет право менять конфигурацию? В какой момент объект перестаёт существовать? Можно ли передать это состояние в другой поток? Что произойдёт, если операция завершится ошибкой?
Rust не делает Win32 красивым.
Он не позволяет мне слишком легко делать вид, что Win32 красивый.
И это, пожалуй, даже полезнее.
Мониторы разных размеров живут в странной геометрии
Основной дисплей Windows обычно начинается в (0, 0).
Монитор слева может начинаться в (-2560, 0). Верхний — где-нибудь в (0, -1440).
Дальше начинается веселье.
Один дисплей 1920×1080. Второй 2560×1440. На одном масштабирование 100%, на другом 125%. Они могут быть смещены относительно друг друга, пересекаться лишь частью границы или вообще образовывать довольно экзотическую фигуру.
Поэтому формула «дошёл до правого края — прибавил ширину» довольно быстро перестаёт работать.
Нужно понимать реальное пересечение, преобразовывать координаты и решать, куда именно на соседнем дисплее должен попасть курсор.
То есть даже привычный всем рабочий стол Windows в действительности является маленькой двухмерной вселенной с собственной системой координат.
Большинство людей просто никогда не сталкиваются с необходимостью писать для неё физику.
А ещё есть игры
Довольно быстро выяснилось, что идея «курсор всегда может уйти за границу» прекрасна ровно до первого запуска полноэкранной игры.
Там свободное путешествие мыши между мирами иногда заканчивается сворачиванием приложения, потерей ввода или внезапным вращением камеры.
Поэтому появился Auto-Gaming Guard.
EvertyDisplay определяет такой сценарий и временно блокирует пространственные переходы.
Это маленькая функция, но она хорошо показывает общий принцип проекта.
Если ты пытаешься изменить привычную модель взаимодействия с компьютером, недостаточно придумать красивую новую модель.
Нужно ещё понять, в какие моменты старая модель была правильнее.
Для кого вообще всё это?
Самое интересное, что я не могу назвать одного типичного пользователя EvertyDisplay.
Слишком разные задачи выигрывают от дополнительного пространства.
Представьте обычного сотрудника, который целый день работает на небольшом мониторе с 1С, Диадоком, браузером и ещё несколькими окнами. Ему не нужна футуристическая рабочая станция из шести панелей. Ему нужно просто куда-то убрать то, что необходимо держать открытым, но не требуется видеть каждую секунду.
Представьте видеонаблюдение или мониторинг. Несколько окон могут жить на отдельном виртуальном экране и появляться перед глазами только тогда, когда нужны.
Продюсер может вынести туда микшер или дополнительную панель.
Разработчик — терминалы, документацию, логи, удалённые машины или devtools.
Для OBS виртуальный дисплей вообще может стать самостоятельной сценой.
На ноутбуке идея становится ещё интереснее. Физическая площадь экрана там особенно ограничена, а пространство операционной системы ограничивать ничто не обязано.
Поэтому я всё меньше воспринимаю EvertyDisplay как «замену ещё одному монитору».
Физический монитор прекрасен. Если у вас есть возможность поставить четыре огромных панели — программа не докажет, что они вам больше не нужны.
Но EvertyDisplay позволяет отделить две вещи, которые мы привыкли считать одним целым:
размер рабочего пространства и количество устройств отображения.
Вот это уже намного интереснее.
Программа не должна заставлять помнить, что она существует
Одним из наиболее важных направлений разработки для меня стало даже не добавление новых функций, а устранение моментов, когда виртуальность внезапно напоминает о себе.
Например, окно уже находится на виртуальном дисплее. Пользователь вернулся на физический и через некоторое время нажал значок приложения на панели задач.
Windows совершенно логично активирует существующее окно.
Но пользователь его не видит.
С его точки зрения он нажал кнопку, а ничего не произошло.
Поэтому EvertyDisplay может либо перейти к тому дисплею, где находится окно, либо вернуть само окно обратно.
То же самое происходит с новыми окнами. Вы работаете в виртуальном пространстве, а Windows открывает проводник или браузер на физическом мониторе. Программа должна понимать, что произошло, и при необходимости провести вас вслед за активированным окном.
Такие вещи кажутся мелочами.
На самом деле именно из них складывается ощущение, что система естественная.
Интерфейс начинает работать нормально не тогда, когда пользователь научился его понимать, а тогда, когда ему больше не требуется о нём думать.
Видимое и существующее — не одно и то же
Работая над EvertyDisplay, я поймал себя на ещё одной мысли.
Мы очень часто считаем существующим только то, что сейчас видим.
Окно свернули — как будто его нет.
Вкладку закрыли — исчезла.
Монитор выключили — пространство закончилось.
Но компьютер давно устроен иначе.
Большая часть его состояния всё время находится вне нашего поля зрения. Процессы выполняются в фоне. Данные лежат в памяти. Сетевые соединения живут без всякой визуализации. GPU рендерит текстуры, которые мы можем никогда не увидеть.
Виртуальный монитор просто делает эту мысль очень наглядной.
Вот браузер.
Он существует.
Вот окно.
Оно существует.
Вот рабочий стол.
Он существует.
Но прямо сейчас ни один фотон с этого рабочего стола не летит вам в глаза.
И ничего страшного не происходит.
Может быть, экран никогда и не был пространством.
Он всегда был лишь способом посмотреть внутрь пространства.
Самая сложная часть — не создать виртуальный монитор
На раннем этапе мне казалось, что главным техническим достижением проекта станет сам факт появления виртуального дисплея.
Оказалось, это только начало.
Настоящая сложность EvertyDisplay находится между подсистемами.
Драйвер знает одно. DisplayConfig другое. GDI третье. DXGI может находиться ещё в предыдущем состоянии. Пользователь уже ждёт результат. Курсор генерирует события. Окна пытаются получить фокус. D3D может вернуть ACCESS_LOST, после чего захват приходится создавать заново.
На компьютере может быть Intel, NVIDIA, AMD, виртуальный адаптер и ещё какой-нибудь Microsoft Basic Display Adapter. Нельзя просто взять первый GPU и решить, что он правильный.
После сна устройство может выглядеть уже немного иначе.
При изменении разрешения могут исчезнуть старые DXGI-ресурсы.
Windows может отказать SetForegroundWindow, потому что право забирать фокус у пользователя ограничено специально.
Даже сохранение конфигурации приходится делать аккуратно: временный файл, синхронизация, backup, атомарная замена. Иначе один аварийный выход в неправильный момент способен оставить вместо конфигурации половину JSON.
И вот в этой точке я понял, что EvertyDisplay на самом деле является не программой виртуальных мониторов.
Это программа согласования состояний.
Она пытается заставить несколько независимых подсистем договориться о единой картине пространства.
И когда им это удаётся, пользователь просто двигает мышь вправо.
Мне нравится такой контраст.
Пять дисплеев и другие ограничения реальности
В текущей версии можно создать до пяти активных виртуальных дисплеев. Это ограничение используемого драйвера, а не придуманная мной лицензионная стенка.
Новый виртуальный экран по умолчанию создаётся на безопасных 60 Гц. Я специально не хочу бездумно копировать частоту основного дисплея, потому что если у человека Main работает на 180, 240 или 244 Гц, совершенно не обязательно заставлять виртуальное пространство рендериться с такой же частотой и создавать лишнюю нагрузку.
Есть и другие шероховатости.
Это Windows. Это графическая подсистема. Это драйвер. Это Win32.
Я не хочу делать вид, будто написал магию, способную отменить все особенности операционной системы.
EvertyDisplay интересен мне как раз обратным: программа принимает существующую реальность Windows, со всей её историей, API, ограничениями и странностями, а затем пытается построить поверх неё новый способ взаимодействия.
Всё локально
Ещё одна вещь, которую для меня важно сохранить: основная логика EvertyDisplay не требует облака.
Не нужно отправлять изображение виртуального экрана на какой-то внешний сервер, чтобы потом получить его обратно.
Топология, управление, захват — всё происходит локально.
Для домашнего пользователя это просто приятно.
Для организаций это уже может быть принципиально.
EvertyDisplay Lite при этом распространяется по GPLv3. Код можно изучать, собирать, проверять IPC, смотреть, как устроена логика работы с дисплеями, и дорабатывать под себя.
Мне нравится идея, что системная программа, которая буквально вмешивается в то, как человек воспринимает рабочее пространство Windows, не должна требовать слепой веры.
Возвращаясь к тому пятнадцатидюймовому монитору
Я иногда думаю о том старом ЭЛТ.
На нём помещалось смешное по современным меркам количество информации. Потом появились большие ЖК-дисплеи. Потом второй монитор. Высокие разрешения. Масштабирование. Огромные ультраширокие панели.
Мы всё время решали одну и ту же задачу физически.
Нам становилось тесно — мы покупали больше стекла.
И это совершенно нормальный путь.
Но мне захотелось проверить другой.
Что если расширять не устройство отображения, а само цифровое пространство?
Когда я впервые перенёс окно влево за границу своего настоящего монитора, рационально ничего особенного не произошло.
Изменились координаты прямоугольника.
Windows продолжила рендерить приложение.
Где-то в памяти обновилось состояние.
Несколько API сообщили новые значения.
Но субъективно произошло кое-что очень странное.
На моём столе появилось место, которого на моём столе нет.
И через некоторое время мозг начал принимать его как настоящее.
Мне не требовалось видеть виртуальный экран постоянно, чтобы помнить, что он находится слева. Я просто знал это.
Почти так же мы знаем, что за нашей спиной находится комната, даже если прямо сейчас её не видим.
Наверное, поэтому меня так зацепил этот проект.
Мы вообще видим не экран
Человеку кажется, что он смотрит на монитор.
Но монитор показывает точки света.
Из этих точек мозг собирает буквы.
Из букв — код.
Из прямоугольников — окна.
Из окон — рабочее пространство.
Никакого «рабочего стола» внутри компьютера физически не существует. Нет папок. Нет окон. Нет кнопки «Пуск». Это метафоры, которые оказались настолько удачными, что спустя десятилетия мы перестали замечать их условность.
И монитор в каком-то смысле тоже является частью этой метафоры.
Мы привыкли считать: сколько передо мной физических экранов — столько у меня пространства.
Но это правило появилось не потому, что оно фундаментально.
Просто долгое время иначе было неудобно.
EvertyDisplay для меня — маленький эксперимент над этим правилом.
Не попытка объявить физические мониторы устаревшими.
Не революция интерфейсов.
И уж точно не доказательство того, что теперь всем срочно понадобится пять невидимых дисплеев.
Мне интересен сам вопрос:
обязательно ли цифровому пространству иметь физическую форму, чтобы человек начал воспринимать его как пространство?
Я попробовал.
Оказалось — не обязательно.
Что находится за краем монитора?
В детстве за краем моего пятнадцатидюймового ЭЛТ находился стол.
Потом второй монитор.
Теперь там иногда находится ещё один рабочий стол Windows, которого физически нет.
На нём может быть открыт браузер. Терминал. Видео. Панель мониторинга. Микшер. Документация.
Я могу уйти туда курсором.
Могу перетащить окно.
Могу посмотреть на это пространство через PiP.
Могу открыть его через Viewport.
Могу вернуться обратно.
И всё это постепенно перестаёт ощущаться каким-то технологическим трюком.
Оно просто становится ещё одним местом.
Меня зовут Артур Валиев.
Я написал EvertyDisplay потому, что однажды мне стало скучно и я задал слишком простой вопрос:
«А что, если край монитора — это не конец?»
Когда-то такая же скука заставила меня достать старый диск, случайно установить FL Studio и начать нажимать на квадратики.
Наверное, спустя столько лет мало что изменилось.
Я всё ещё открываю неизвестную программу, технологию или идею и начинаю нажимать на квадратики, чтобы посмотреть, что получится.
Только теперь иногда в результате появляется монитор, которого не существует.
https://github.com/vaalimusic/EvertyDisplayLite
V
