C++ Окно, интерфейс.

$ cat hello.c
#include <X11/Xlib.h>
#include <unistd.h>

int main()
{
    Display* MainDisplay = XOpenDisplay(0);
    Window RootWindow = XDefaultRootWindow(MainDisplay);
    
    Window MainWindow = XCreateSimpleWindow(MainDisplay, RootWindow, 0, 0, 800, 600, 0, 0, 0x00aade87);
    XMapWindow(MainDisplay, MainWindow);
    XFlush(MainDisplay);

    for(;;) { sleep(1); }
}
$ gcc hello.c -lX11
$ ./a.out
^C

import QtQuick 2.15
import QtQuick.Window 2.15

Window {
    visible: true
    width: 256
    height: 256

    Canvas {
        id: canvas
        anchors.fill: parent

        onPaint: {
            var ctx = getContext("2d");
            for (var y = 0; y < height; y++) {
                for (var x = 0; x < width; x++) {
                    ctx.fillStyle = Qt.rgba(x / 255, y / 255, (x + y) / 510, 1);
                    ctx.fillRect(x, y, 1, 1);
                }
            }
        }
    }
}

[dependencies]
eframe = "0.31.1" # Фреймворк для создания окон с egui
egui = "0.31.1"   # Сама библиотека egui

use eframe::egui;

fn main() {
    let options = eframe::NativeOptions::default();
    eframe::run_native(
        "Pixel Art House", // Название окна
        options,
        Box::new(|_cc| Ok(Box::new(MyApp {}))), // Оборачиваем MyApp в Ok
    )
    .expect("Failed to start eframe application");
}

struct MyApp {}

impl eframe::App for MyApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        egui::CentralPanel::default().show(ctx, |ui| {
            // Получаем холст для рисования
            let painter = ui.painter();

            // Размеры холста
            let canvas_width = 200.0;
            let canvas_height = 200.0;

            // Очищаем фон (трава)
            painter.rect_filled(
                egui::Rect::from_min_size(egui::pos2(0.0, 0.0), egui::vec2(canvas_width, canvas_height)),
                0.0,
                egui::Color32::from_rgb(34, 139, 34), // Зеленый цвет травы
            );

            // Рисуем домик пикселями
            draw_house(painter);
        });
    }
}

// Функция для рисования домика
fn draw_house(painter: &egui::Painter) {
    // Крыша (треугольник)
    painter.add(egui::Shape::convex_polygon(
        vec![
            egui::pos2(80.0, 40.0),  // Верхняя точка крыши
            egui::pos2(50.0, 80.0),  // Левый угол
            egui::pos2(110.0, 80.0), // Правый угол
        ],
        egui::Color32::from_rgb(255, 69, 0), // Оранжевый цвет крыши
        egui::Stroke::NONE,
    ));

    // Стены дома (прямоугольник)
    painter.rect_filled(
        egui::Rect::from_min_size(egui::pos2(50.0, 80.0), egui::vec2(60.0, 60.0)),
        0.0,
        egui::Color32::from_rgb(139, 69, 19), // Коричневый цвет стен
    );

    // Окно
    painter.rect_filled(
        egui::Rect::from_min_size(egui::pos2(60.0, 100.0), egui::vec2(20.0, 20.0)),
        0.0,
        egui::Color32::from_rgb(173, 216, 230), // Светло-голубой цвет окна
    );

    // Дверь
    painter.rect_filled(
        egui::Rect::from_min_size(egui::pos2(85.0, 120.0), egui::vec2(10.0, 20.0)),
        0.0,
        egui::Color32::from_rgb(139, 0, 0), // Темно-красный цвет двери
    );
}

-- Функция love.load вызывается один раз при запуске программы
function love.load()
    -- Устанавливаем размер окна
    love.window.setMode(400, 400)
end

-- Функция love.draw вызывается каждый кадр для отрисовки
function love.draw()
    -- Очищаем фон травой (зелёный цвет)
    love.graphics.setColor(34 / 255, 139 / 255, 34 / 255) -- RGB цвет травы
    love.graphics.rectangle("fill", 0, 250, 400, 150)

    -- Рисуем стены дома (коричневый прямоугольник)
    love.graphics.setColor(139 / 255, 69 / 255, 19 / 255) -- RGB цвет стен
    love.graphics.rectangle("fill", 100, 150, 100, 100)

    -- Рисуем крышу (треугольник)
    love.graphics.setColor(255 / 255, 69 / 255, 0 / 255) -- RGB цвет крыши
    love.graphics.polygon("fill", 150, 50, 100, 150, 200, 150)

    -- Рисуем окно (светло-голубой прямоугольник)
    love.graphics.setColor(173 / 255, 216 / 255, 230 / 255) -- RGB цвет окна
    love.graphics.rectangle("fill", 120, 170, 30, 30)

    -- Рисуем дверь (темно-красный прямоугольник)
    love.graphics.setColor(139 / 255, 0 / 255, 0 / 255) -- RGB цвет двери
    love.graphics.rectangle("fill", 155, 200, 20, 50)

    -- Рисуем солнце (жёлтый круг)
    love.graphics.setColor(255 / 255, 215 / 255, 0 / 255) -- RGB цвет солнца
    love.graphics.circle("fill", 350, 50, 30)
end

love .

[package]
name = "dancing_strings_demo"
version = "0.1.0"
edition = "2021"

[dependencies]
egui = { version = "0.31", features = ["color-hex"] }
eframe = "0.31"

use eframe::egui;
use egui::{Rect, emath};

fn main() {
    let options = eframe::NativeOptions::default();
    if let Err(error) = run_app(options) {
        eprintln!("Failed to run app: {error}");
    }
}

fn run_app(options: eframe::NativeOptions) -> Result<(), eframe::Error> {
    eframe::run_native(
        "Dancing Strings",
        options,
        Box::new(|_cc| Ok(Box::new(DancingStrings::default()))),
    )
}

#[derive(Default)]
struct DancingStrings {
    colors: bool,
}

impl eframe::App for DancingStrings {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        egui::CentralPanel::default().show(ctx, |ui| {
            ui.vertical_centered(|ui| {
                ui.heading("♫ Dancing Strings");
            });

            ui.checkbox(&mut self.colors, "Colored")
                .on_hover_text("Demonstrates how a path can have varying color across its length.");

            egui::Frame::canvas(ui.style()).show(ui, |ui| {
                ui.ctx().request_repaint();
                let time = ui.input(|i| i.time);

                let desired_size = ui.available_width() * egui::vec2(1.0, 0.35);
                let (_id, rect) = ui.allocate_space(desired_size);

                let to_screen =
                    emath::RectTransform::from_to(Rect::from_x_y_ranges(0.0..=1.0, -1.0..=1.0), rect);

                let mut shapes = vec![];

                for &mode in &[2, 3, 5] {
                    let mode = mode as f64;
                    let n = 120;
                    let speed = 1.5;

                    let points: Vec<egui::Pos2> = (0..=n)
                        .map(|i| {
                            let t = i as f64 / (n as f64);
                            let amp = (time * speed * mode).sin() / mode;
                            let y = amp * (t * std::f64::consts::TAU / 2.0 * mode).sin();
                            to_screen * egui::pos2(t as f32, y as f32)
                        })
                        .collect();

                    let thickness = 10.0 / mode as f32;
                    shapes.push(egui::epaint::Shape::line(
                        points,
                        if self.colors {
                            egui::epaint::PathStroke::new_uv(thickness, move |rect, p| {
                                let t = emath::remap(p.x, rect.x_range(), -1.0..=1.0).abs();
                                let center_color = egui::hex_color!("#5BCEFA");
                                let outer_color = egui::hex_color!("#F5A9B8");

                                egui::Color32::from_rgb(
                                    emath::lerp(center_color.r() as f32..=outer_color.r() as f32, t) as u8,
                                    emath::lerp(center_color.g() as f32..=outer_color.g() as f32, t) as u8,
                                    emath::lerp(center_color.b() as f32..=outer_color.b() as f32, t) as u8,
                                )
                            })
                        } else {
                            egui::epaint::PathStroke::new(
                                thickness,
                                if ui.visuals().dark_mode {
                                    egui::Color32::from_additive_luminance(196)
                                } else {
                                    egui::Color32::from_black_alpha(240)
                                },
                            )
                        },
                    ));
                }

                ui.painter().extend(shapes);
            });
        });
    }
}

function love.load()
    width = love.graphics.getWidth()
    height = love.graphics.getHeight()
    centerY = height / 2
    modes = {2, 3, 5}
    nPoints = 120
    speed = 1.5
    thickness = 4
    useColor = true

    colors = {
        center = {75/255, 206/255, 250/255},   -- #5BCEFA
        outer = {245/255, 169/255, 184/255}    -- #F5A9B8
    }
end

function love.update(dt)
    -- место для вашей рекламы
end

function love.draw()
    love.graphics.setBackgroundColor(0.1, 0.1, 0.1) -- тёмный фон

    local time = love.timer.getTime()

    for _, mode in ipairs(modes) do
        local points = {}

        for i = 0, nPoints do
            local t = i / nPoints
            local amp = math.sin(time * speed * mode) / mode
            local y = amp * math.sin(t * math.pi * mode)

            local x_screen = t * width
            local y_screen = centerY + y * 100

            table.insert(points, x_screen)
            table.insert(points, y_screen)
        end

        if useColor then
            love.graphics.setLineWidth(thickness)
            for i = 1, #points - 3, 2 do
                local x1, y1 = points[i], points[i+1]
                local x2, y2 = points[i+2], points[i+3]

                local t = math.abs((x1 / width) * 2 - 1)
                local r = lerp(colors.center[1], colors.outer[1], t)
                local g = lerp(colors.center[2], colors.outer[2], t)
                local b = lerp(colors.center[3], colors.outer[3], t)

                love.graphics.setColor(r, g, b)
                love.graphics.line(x1, y1, x2, y2)
            end
        else
            love.graphics.setColor(1, 1, 1)
            love.graphics.setLineWidth(thickness)
            love.graphics.line(points)
        end
    end

    -- Переключатель цвета
    love.graphics.setColor(1, 1, 1)
    love.graphics.print("Press C to toggle color", 10, 10)
end

function love.keypressed(key)
    if key == "c" then
        useColor = not useColor
    end
end

-- Вспомогательная функция для интерполяции
function lerp(a, b, t)
    return a + (b - a) * t
end

love .

[package]
name = "dancing_strings_demo"
version = "0.1.0"
edition = "2021"

# Для работы с системными вызовами
[dependencies]
libc = "0.2"

use std::ptr::{null, null_mut};
use std::thread;
use std::time::Duration;
use libc::{c_int, c_ulong};

#[repr(C)]
struct XEvent {
    pub type_: c_int,
    pub xany: [u8; 24],
}

// Константы
const KEY_PRESS_MASK: c_int = 1 << 0;
const CLIENT_MESSAGE: c_int = 21;

const WIDTH: usize = 400;
const HEIGHT: usize = 300;

#[link(name = "X11")]
extern "C" {
    fn XOpenDisplay(display_name: *const i8) -> *mut Display;
    fn XDefaultScreen(dpy: *mut Display) -> c_int;
    fn XRootWindow(dpy: *mut Display, screen: c_int) -> Window;
    fn XCreateSimpleWindow(
        dpy: *mut Display,
        parent: Window,
        x: c_int,
        y: c_int,
        width: u32,
        height: u32,
        border_width: u32,
        border: c_ulong,
        background: c_ulong,
    ) -> Window;
    fn XMapWindow(dpy: *mut Display, w: Window);
    fn XSelectInput(dpy: *mut Display, w: Window, event_mask: c_int);
    fn XNextEvent(dpy: *mut Display, event: *mut XEvent) -> c_int;
    fn XFlush(dpy: *mut Display) -> c_int;
    fn XCloseDisplay(dpy: *mut Display) -> c_int;
    fn XCreateGC(dpy: *mut Display, d: Drawable, valuemask: u64, values: *mut ()) -> GC;
    fn XSetForeground(dpy: *mut Display, gc: GC, foreground: c_ulong);
    fn XFillRectangle(
        dpy: *mut Display,
        d: Drawable,
        gc: GC,
        x: c_int,
        y: c_int,
        width: u32,
        height: u32,
    );
    fn XPending(dpy: *mut Display) -> c_int;
}

type Display = std::ffi::c_void;
type Window = c_ulong;
type Drawable = c_ulong;
type GC = *mut std::ffi::c_void;

fn main() {
    // Открываем дисплей
    let display = unsafe { XOpenDisplay(null()) };
    if display.is_null() {
        panic!("Не удалось подключиться к X серверу");
    }

    // Получаем корневое окно
    let screen = unsafe { XDefaultScreen(display) };
    let root_window = unsafe { XRootWindow(display, screen) };

    // Создаём наше окно
    let window = unsafe {
        XCreateSimpleWindow(
            display,
            root_window,
            0,
            0,
            WIDTH as u32,
            HEIGHT as u32,
            0,
            0,
            0xff000000, // Чёрный фон
        )
    };

    if window == 0 {
        panic!("Не удалось создать окно!");
    }

    // Подписываемся на события
    unsafe {
        XSelectInput(display, window, KEY_PRESS_MASK | CLIENT_MESSAGE);
        XMapWindow(display, window);
        XFlush(display); // Отправляем команду на экран
    }

    // Создаём графический контекст
    let gc = unsafe { XCreateGC(display, window, 0, null_mut()) };
    if gc.is_null() {
        panic!("Не удалось создать GC");
    }

    // Устанавливаем цвет: красный (RGB: FF0000)
    unsafe {
        XSetForeground(display, gc, 0xFF0000); // красный
    }

    println!("Окно создано. Ждём событий...");

    // Цикл обработки событий
    let mut running = true;
    while running {
        if unsafe { XPending(display) } > 0 {
            let mut event: XEvent = unsafe { std::mem::zeroed() };
            unsafe {
                XNextEvent(display, &mut event);
            }

            match event.type_ {
                2 => {
                    // KeyPress
                    running = false;
                }
                _ => {}
            }
        } else {
            // Рисуем красный квадрат 10x10 по центру
            unsafe {
                XFillRectangle(display, window, gc, 195, 145, 10, 10);
                XFlush(display);
            }

            thread::sleep(Duration::from_millis(100));
        }
    }

    unsafe {
        XCloseDisplay(display);
    }

    println!("Программа завершена.");
}