Integrovaný správce oken: 10 kroků

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:19

Tento projekt ukazuje, jak implementovat správce oken s pohyblivými překrývajícími se okny na integrovaném mikrořadiči s LCD panelem a dotykovou obrazovkou. Existují komerčně dostupné softwarové balíčky, které to dělají, ale stojí peníze a jsou uzavřeným zdrojem. Ten, nazvaný MiniWin, je bezplatný a open-source. Je napsán v plně kompatibilním C99 a lze jej použít v aplikaci C nebo C ++. Cílem MiniWin je být snadno použitelný, snadno upravitelný, rozšiřitelný, přenosný na širokou škálu hardwaru a ne příliš náročný na zdroje.

Kromě poskytování kódu pro správu oken má MiniWin také sadu ovládacích prvků uživatelského rozhraní - tlačítka, posuvníky, ukazatele průběhu, stromy atd. Můžete mít více oken různých typů nebo více instancí stejného typu. Okna lze přesouvat, měnit jejich velikost, maximalizovat, minimalizovat, zavírat - všechny obvyklé věci, které děláte s okny ve větších správcích oken. Pro atraktivní vykreslování textu jsou podporována také písma TrueType s vyrovnání párů a vyhlazení (díky čemuž text vypadá hladce).

V každém okně máte klientskou oblast (váš prostor uvnitř okraje a pod horní lištou). Na toto můžete přidat ovládací prvky k vytvoření dialogu nebo můžete použít vestavěnou grafickou knihovnu k kreslení, co chcete. Všechny funkce grafické knihovny znají okno. Nemusíte se starat o to, kde je vaše okno, co se překrývá nebo zda je minimalizováno.

Kromě vytváření vlastních oken je k dispozici také několik standardních dialogů, jejichž vytváření je velmi snadné - například potvrzovací dialogy (pouze tlačítka OK nebo Ano/Ne), nastavovače času/data, výběr souborů, výběr barev atd.

MiniWin používá standardní systém front zpráv návrhu správce oken. Windows mohou komunikovat mezi sebou navzájem a se správcem oken prostřednictvím zpráv. Nezvoláváte funkce, abyste dělali věci přímo, přidáte zprávu do fronty a správce oken ji za vás uzákoní.

MiniWin byl přenesen na standardní vývojové desky s dotykovými displeji od výrobců mikrořadičů ST, NXP a Renesas. Pro všechna tato zařízení existují ovladače hardwaru a příklady projektů. MiniWin lze navíc vytvořit pro Windows nebo Linux, takže můžete simulovat kód uživatelského rozhraní, než získáte integrovaný hardware.

MiniWin má generátor kódu. Můžete zadat svá okna a ovládací prvky jednoduchým vytvořením souboru JSON čitelného člověkem a generátor kódu soubor analyzuje a vytvoří kód za vás (existuje mnoho příkladů, které je třeba sledovat). Vytváří kompletní simulační aplikace pro Windows nebo Linux, které lze jen stavět, a je zde váš simulovaný LCD displej s fungujícími okny MiniWin. Můžete vzít přesně stejný generovaný kód a vložit jej do vloženého projektu a mít stejný kód zobrazující stejná okna a ovládací prvky o chvíli později na vašem integrovaném hardwaru.

MiniWin nevyžaduje na integrovaném zařízení žádnou provozní podporu. Vše běží v jednom vlákně. MiniWin lze integrovat s RTOS běžícím na integrovaném procesoru a existují příklady integrace MiniWin s FreeRTOS.

Tento návod ukazuje, jak zprovoznit MiniWin na procesoru STM32 M4 pomocí levné desky STM32F429 Discovery, která je dodávána s již připojeným dotykovým displejem QVGA. Ty jsou snadno dostupné u vašeho dodavatele elektronických součástek.

MiniWin běží na mikrořadičích střední třídy a výše.

Zásoby

Vývojová deska STM32F429I-DISC1 a kabel micro USB

Stažení STM32CubeIDE, které je zdarma.

Krok 1: Získání kódu

Nejprve musíte nainstalovat STM32CubeIDE. Získáte to z webových stránek ST. Musíte se zaregistrovat a jeho stažení a instalace chvíli trvá. Vše je zdarma.

Během instalace si stáhněte zdroj MiniWin a rozbalte jej. Je velký, ale použijete jen jeho malou část. Zde klikněte na zelené tlačítko „Klonovat nebo stáhnout“…

github.com/miniwinwm/miniwinwm

poté zvolte Stáhnout zip. Rozbalte obsah.

Krok 2: Vytvoření příkladného projektu

Nejprve si vytvoříme jeden z ukázkových projektů. Dobrý se jmenuje MiniWinSimple. Spusťte STM32CubeIDE a proveďte toto:

1. Zvolte Soubor | Importovat…
2. Otevřete Obecné a vyberte Existující projekt do pracovního prostoru. Další.
3. Klikněte na Procházet a přejděte na místo, kde jste rozbalili MiniWin. Poté přejděte do složky STM32CubeIDE / MiniWinSimple / STM32F429. Klikněte na Vybrat složku.
4. V projektu: zaškrtněte MiniWinSimple_STM32F429 a poté klikněte na Dokončit.
5. Projekt MiniWinSimple_STM32F429 se objeví v Průzkumníku projektů. Vyberte jej a poté jej vytvořte pomocí Project | Build Project.
6. Nyní zapojte USB kabel do desky a počítače a spusťte jej pomocí Run | Debug a po jeho stažení zvolte Run | Resume. Kalibrační displej se zobrazí poprvé, takže se dotkněte středu tří křížků na LCD displeji. Nyní můžete komunikovat s oknem na displeji.

Chcete -li okno přesunout, přetáhněte jej za jeho záhlaví. Chcete -li změnit velikost okna, použijte ikonu bílého trojúhelníku v levé části záhlaví. U oken MiniWin nelze měnit velikost přetažením okrajů, protože displeje, na nichž se MiniWin používá, jsou příliš malé. Chcete -li okno minimalizovat, maximalizovat nebo zavřít, použijte ikony na pravém konci záhlaví (zavírání může být zakázáno). Když je okno minimalizováno, nemůžete minimalizované ikony přesouvat. Budují se zespodu zleva doprava.

Krok 3: Spuštění generátoru kódu

Nyní změníme ukázkový projekt vygenerováním některých vlastních oken a vložením nového kódu dovnitř. K tomu spustíme generátor kódu.

1. Otevřete příkazový řádek a přejděte do složky, kde jste rozbalili MiniWin, a poté do složky Tools / CodeGen.
2. Spustitelný soubor pro Windows CodeGen.exe je již k dispozici. Pro Linux jej musíte vytvořit zadáním make. (Můžete si jej také vytvořit ze zdroje pro Windows, pokud vám dělá starosti spouštění staženého spustitelného souboru, ale potřebujete nainstalovaný kompilátor a vývojové prostředí. Podrobnosti najdete v dokumentaci MiniWin ve složce docs).
3. V této složce je několik příkladů souborů JSON. Použijeme example_empty.json. Chcete -li jej nastavit pro Windows nebo Linux, musíte jej nejprve upravit. Otevřete jej v editoru a nahoře, kde najdete „TargetType“, změňte hodnotu „Linux“nebo „Windows“na to, na čem spouštíte generátor kódu.
4. Nyní do příkazového řádku zadejte codegen example_empty.json.
5. Přejděte na svůj projekt v STM32CubeIDE a otevřete složku MiniWinSimple_Common. Odstranit všechny soubory tam.
6. Nechali jsme „TargetName“v souboru JSON jako výchozí u „MiniWinGen“, takže to je název naší složky generovaného kódu. Přejděte do složky, kde jste rozbalili MiniWin a poté do složky MiniWinGen_Common. Nyní vyberte všechny tyto soubory a přetáhněte je do STM32CubeIDE ve složce MiniWinSimple_Common vašeho projektu.
7. Nyní znovu vytvořte a znovu spusťte projekt v STM32CubeIDE a objeví se vaše nové návrhové okno. Tlačítko v okně zmizelo, protože example_empty.json nedefinuje žádné.

Krok 4: Přidání okna

Nyní přidáme druhé okno do konfiguračního souboru JSON a znovu vygenerujeme kód.

1. Otevřete example_empty.json v textovém editoru.

2. V části „Windows“je pole definic oken, které má aktuálně pouze jedno okno. Zkopírujte to všechno…

{

"Název": "W1", "Název": "Okno 1", "X": 10, "Y": 15, "Šířka": 200, "Výška": 180, "Hranice": true, "TitleBar": true, "Visible": true, "Minimized": false}

a vložte jej znovu čárkou oddělující 2 definice.

3. Změňte „W1“na „W2“a „Okno 1“na „Okno 2“. Změňte „X“, „Y“, „Šířka“a „Výška“na různé hodnoty. Mějte na paměti, že rozlišení obrazovky je 240 na šířku a na 320 na výšku.

4. Uložte soubor a znovu spusťte generátor kódu.

5. Zkopírujte soubory jako v předchozím kroku, znovu vytvořte a spusťte znovu. Nyní budete mít na displeji 2 okna.

Krok 5: Přidání ovládacího prvku

Nyní do vašeho nového okna přidáme některé ovládací prvky. Upravte stejný soubor jako v předchozím kroku.

1. Do specifikace pro okno W1 přidejte po posledním nastavení čárku („Minimalizováno“: false) a poté přidejte tento text

"MenuBar": pravda, „MenuBarEnabled“: true, „MenuItems“: [„Fred“, „Bert“, „Pete“, „Alf“, „Ian“], „Tlačítka“: [{„Název“: „B1“, „Štítek“: "Button1", "X": 10, "Y": 10, "Enabled": true, "Visible": true}]

Tato část přidává panel nabídek s 5 položkami a povoluje jej (pruhy nabídek lze globálně deaktivovat, zkuste to). Přidá také tlačítko, které je povoleno a viditelné (lze je vytvořit neviditelné a později je v kódu zviditelnit).

2. Znovu vytvořte kód, zkopírujte jej, znovu sestavte a znovu spusťte jako dříve.

Krok 6: Přinutí ovládací prvky k něčemu

Nyní máme základní uživatelské rozhraní, které k něčemu potřebujeme. V tomto případě vyskočíme dialog pro výběr barvy po stisknutí tlačítka v okně 1.

Přejděte na svůj projekt v STM32CubeIDE a otevřete složku MiniWinSimple_Common a poté otevřete soubor W1.c (název tohoto souboru odpovídá poli „Název“okna v souboru JSON při generování kódu).

V tomto souboru najdete funkci window_W1_message_function (). Vypadá to takto:

neplatné window_W1_message_function (const mw_message_t *zpráva) {MW_ASSERT (message! = (void *) 0, "Null pointer parameter"); / * Další řádek zastaví varování kompilátoru, protože proměnná je aktuálně nevyužita */ (neplatné) window_W1_data; switch (message-> message_id) {case MW_WINDOW_CREATED_MESSAGE: / * Přidejte sem jakýkoli inicializační kód okna * / break; případ MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Sem přidejte obslužný kód nabídky okna * / break; případ MW_BUTTON_PRESSED_MESSAGE: if (message-> sender_handle == button_B1_handle) { / * Zde přidejte kód obsluhy pro tento ovládací prvek * /} break; výchozí: / * Udělejte MISRU šťastnou * / přestávka; }}

Tomu říká správce oken pro toto okno vždy, když správce oken potřebuje dát oknu vědět, že se něco stalo. V tomto případě nás zajímá, že bylo stisknuto jediné tlačítko okna. V příkazu switch pro typy zpráv uvidíte případ pro MW_BUTTON_PRESSED_MESSAGE. Tento kód se spustí po stisknutí tlačítka. V tomto okně je pouze jedno tlačítko, ale může jich být více, proto se kontroluje, o které tlačítko se jedná. V tomto případě to mohlo být pouze tlačítko B1 (název odpovídá opět názvu tlačítka v souboru JSON).

Takže po tomto štítku případu přidejte kód, aby se otevřelo dialogové okno pro výběr barvy, což je toto:

mw_create_window_dialog_colour_chooser (10, 10, "Color", MW_HAL_LCD_RED, false, message-> recipient_handle);

Parametry jsou následující:

• 10, 10 je umístění na obrazovce dialogu
• „Barva“je název dialogu
• Výchozí barvou, kterou dialog začne, je MW_HAL_LCD_RED
• false znamená, že se nezobrazuje velká velikost (zkuste ji nastavit na true a uvidíte rozdíl)
• message-> handle handle is who own this dialog, in this case it's this window. Popisovač okna je v parametru zprávy funkce. Toto je okno, do kterého bude odeslána odpověď v dialogu.

Chcete -li zjistit hodnotu barvy, kterou si uživatel vybral, správce oken pošle našemu oknu zprávu se zvolenou barvou, když uživatel stiskne tlačítko OK v dialogu. Proto musíme tuto zprávu zachytit také s jiným případem v příkazu switch, který vypadá takto:

případ MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE:

{mw_hal_lcd_colour_t selected_colour = message-> message_data; (neplatné) selected_colour; } přestávka;

S vybranou barvou zatím nic neděláme, takže ji pouze odléváme, abychom zabránili varování kompilátoru. Konečný kód této funkce nyní vypadá takto:

neplatné window_W1_message_function (const mw_message_t *zpráva)

{MW_ASSERT (zpráva! = (Void*) 0, "Parametr nulového ukazatele"); / * Další řádek zastaví varování kompilátoru, protože proměnná je aktuálně nevyužita */ (neplatné) window_W1_data; switch (message-> message_id) {case MW_WINDOW_CREATED_MESSAGE: / * Přidejte sem jakýkoli inicializační kód okna * / break; případ MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Sem přidejte obslužný kód nabídky okna * / break; případ MW_BUTTON_PRESSED_MESSAGE: if (message-> sender_handle == button_B1_handle) { / * Zde přidejte kód obsluhy pro tento ovládací prvek * / mw_create_window_dialog_colour_chooser (10, 10, "Color", MW_HAL_LCD_RED, false, message-> recipient_hand } přestávka; případ MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE: {mw_hal_lcd_colour_t selected_colour = message-> message_data; (neplatné) selected_colour; } přestávka; výchozí: / * Udělejte MISRU šťastnou * / přestávka; }}

Spuštění kódu je zobrazeno na obrázku výše. Můžete si všimnout, že když se dialog zobrazuje, musíte na něj odpovědět a zavřít jej, než uděláte něco jiného. Tomu se říká modální chování. Dialogy v MiniWinu a vždy vždy globálně modální a můžete mít vždy jen jeden. Zde je více vysvětlení…

en.wikipedia.org/wiki/Modal_window

Krok 7: Kreslení v okně

Doposud jsme používali pouze ovládací prvky a kreslí se samy. Je na čase udělat nějaké vlastní kreslení na našem okně. Část, na kterou můžete kreslit, je uvnitř ohraničení (pokud jsou nějaká, jsou volitelná), uvnitř posuvníků (je -li definována, také volitelná) a pod záhlavím (pokud existuje, je také volitelné). V terminologii oken se tomu říká klientská oblast.

V MiniWin je knihovna grafických příkazů, které můžete použít. Všichni jsou si vědomi okna. To znamená, že si nemusíte dělat starosti, pokud je okno viditelné, částečně zakryté jinými okny, zapnuto, částečně vypnuto nebo zcela mimo obrazovku, nebo pokud je souřadnice místa, kde kreslíte, v klientské oblasti nebo mimo ni. Všechno je o vás postaráno. Mimo svoji klientskou oblast nemůžete kreslit.

Kreslení na klientské oblasti v terminologii oken se nazývá malování a každé okno má funkci malování, kde kreslíte. Nevoláte funkci malování, správce oken to v případě potřeby provede za vás. Je to nutné při přesunutí okna nebo změně polohy nebo viditelnosti jiného okna nahoře. Pokud potřebujete překreslit své okno, protože se změnila některá data, na kterých závisí obsah okna (tj. Víte, že je nutné přelakování, než aby to správce oken věděl), pak sdělíte správci oken, že je potřeba překreslit a zavolá vaše funkce lakování. Sám tomu neříkáš. (To vše je ukázáno v následující části).

Nejprve musíte najít funkci malování. Generátor kódu jej vytvoří za vás a je těsně nad funkcí obsluhy zpráv upravenou v předchozí části. Přejděte ke svému projektu a znovu otevřete soubor W1.c.

V tomto souboru najdete funkci window_W1_paint_function (). Vypadá to takto:

neplatné window_W1_paint_function (mw_handle_t window_handle, const mw_gl_draw_info_t *draw_info)

{MW_ASSERT (draw_info! = (Void*) 0, "Parametr nulového ukazatele"); / * Vyplňte klientskou oblast okna plnou bílou */ mw_gl_set_fill (MW_GL_FILL); mw_gl_set_solid_fill_colour (MW_HAL_LCD_WHITE); mw_gl_set_border (MW_GL_BORDER_OFF); mw_gl_clear_pattern (); mw_gl_rectangle (draw_info, 0, 0, mw_get_window_client_rect (window_handle).width, mw_get_window_client_rect (window_handle).height); / * Zde přidejte kód pro malování oken */}

Toto je holý generovaný kód a vše, co dělá, je vyplnit klientskou oblast plnou bílou. Nakreslíme žlutý vyplněný kruh v oblasti klienta. Nejprve musíme porozumět konceptu grafického kontextu (další věc pro Windows). Nastavíme parametry kresby v grafickém kontextu a poté zavoláme obecnou rutinu kreslení kruhu. V tomto příkladu musíme nastavit, zda má kruh ohraničení, styl hraniční čáry, barvu ohraničení, zda je kruh vyplněn, barvu výplně a vzor výplně. Můžete vidět výše uvedený kód, který dělá něco podobného pro vyplnění oblasti klienta bílým obdélníkem bez okrajů. Hodnoty v grafickém kontextu se nepamatují mezi každým voláním funkce malování, takže hodnoty musíte nastavit pokaždé (jsou však zapamatovány pomocí funkce malování).

V kódu výše vidíte, že výplň je zapnutá a vzor výplně je vypnutý, takže je nemusíme znovu nastavovat. Potřebujeme nastavit ohraničení, styl ohraničení na plný, barvu popředí na černou a barvu výplně na žlutou takto:

mw_gl_set_fg_colour (MW_HAL_LCD_BLACK);

mw_gl_set_solid_fill_colour (MW_HAL_LCD_YELLOW); mw_gl_set_line (MW_GL_SOLID_LINE); mw_gl_set_border (MW_GL_BORDER_ON); mw_gl_circle (draw_info, window_simple_data.circle_x, window_simple_data.circle_y, 25);

Přidejte tento kód do komentáře v této funkci, kde je uvedeno přidání kódu. Dále musíme nakreslit kruh, který se provádí takto:

mw_gl_circle (draw_info, 30, 30, 15);

Tím se nakreslí kruh na souřadnicích 30, 30 s poloměrem 15. Znovu vytvořte kód a spusťte jej znovu a v okně uvidíte kruh, jak je uvedeno výše. Všimnete si, že se kruh a tlačítko překrývají, ale tlačítko je nahoře. To je záměrné. Ovládací prvky jsou vždy nad vším, co nakreslíte v klientské oblasti.

Krok 8: Data okna

Doposud jsme implementovali vlastní kód ve funkci zpráv okna 1 (pro zpracování příchozích zpráv) a jeho funkci malování (pro kreslení v klientské oblasti okna). Nyní je čas tyto dva propojit. Umožňuje vyplnit kruh nakreslený ve funkci malování barvou, kterou si uživatel zvolí v nástroji pro výběr barvy při stisknutí tlačítka. Pamatujte, že nenazýváme funkci malování, dělá to správce oken, takže naše funkce zpráv (která zná zvolenou barvu) nemůže volat funkci malování přímo sama. Místo toho musíme data uložit do mezipaměti a dát správci oken vědět, že je vyžadováno překreslení. Správce oken poté zavolá funkci malování, která může používat data uložená v mezipaměti.

V horní části W1.c uvidíte prázdnou datovou strukturu a objekt tohoto typu deklarovaný generátorem kódu takto:

typedef struct

{ / * Přidejte sem své datové členy * / char dummy; /* Někteří překladatelé si stěžují na prázdné struktury; odstraňte to, když přidáte své členy */} window_W1_data_t; statické okno_W1_data_t okno_W1_data;

Zde ukládáme data do mezipaměti, aby byla zachována napříč hovory a je známá jako data okna. Zde musíme uložit pouze zvolenou barvu, například takto:

typedef struct

{ / * Přidejte sem své datové členy * / mw_hal_lcd_colour_t selected_colour; } window_W1_data_t; statické okno_W1_data_t okno_W1_data = {MW_HAL_LCD_YELLOW};

Dáme mu počáteční barvu žluté. Nyní ve funkci zprávy mírně změníme kód, abychom vybranou barvu uložili zde:

případ MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE:

{window_W1_data.chosen_colour = message-> message_data; } přestávka;

Potom změníme funkci malování tak, aby používala tuto hodnotu, když nakreslí kruh takto:

mw_gl_set_solid_fill_colour (window_W1_data.chosen_colour);

Nyní jsme změnili data, na kterých závisí obsah okna, takže musíme dát správci oken vědět, že okno potřebuje přemalovat. Uděláme to ve funkci zprávy, když je přijata dialogová zpráva OK, takto:

mw_paint_window_client (message-> recipient_handle);

Nezpůsobí to přímé natření okna. Jedná se o pomocnou funkci, která odesílá správci oken zprávu, že je potřeba okno překreslit (pokud do něj vstoupíte, uvidíte, jak se to stane). Okno, které je třeba v tomto případě překreslit, je samo o sobě a popisovač okna je v parametru zprávy pro funkci obsluhy zpráv.

Celý soubor nyní vypadá takto, pokud si nejste jisti, kam směřují některé výše uvedené fragmenty kódu:

#zahrnout

#include "miniwin.h" #include "miniwin_user.h" #include "W1.h" typedef struct { / * Sem přidejte své datové členy * / mw_hal_lcd_colour_t selected_colour; } window_W1_data_t; statické okno_W1_data_t okno_W1_data = {MW_HAL_LCD_YELLOW}; neplatné window_W1_paint_function (mw_handle_t window_handle, const mw_gl_draw_info_t *draw_info) {MW_ASSERT (draw_info! = (void *) 0, "Null pointer parameter"); / * Vyplňte klientskou oblast okna plnou bílou */ mw_gl_set_fill (MW_GL_FILL); mw_gl_set_solid_fill_colour (MW_HAL_LCD_WHITE); mw_gl_set_border (MW_GL_BORDER_OFF); mw_gl_clear_pattern (); mw_gl_rectangle (draw_info, 0, 0, mw_get_window_client_rect (window_handle).width, mw_get_window_client_rect (window_handle).height); / * Zde přidejte kód pro malování oken */ mw_gl_set_fg_colour (MW_HAL_LCD_BLACK); mw_gl_set_solid_fill_colour (window_W1_data.chosen_colour); mw_gl_set_line (MW_GL_SOLID_LINE); mw_gl_set_border (MW_GL_BORDER_ON); mw_gl_circle (draw_info, 30, 30, 15); } neplatné window_W1_message_function (const mw_message_t *zpráva) {MW_ASSERT (zpráva! = (void *) 0, "Parametr nulového ukazatele"); / * Další řádek zastaví varování kompilátoru, protože proměnná je aktuálně nevyužita */ (neplatné) window_W1_data; switch (message-> message_id) {case MW_WINDOW_CREATED_MESSAGE: / * Přidejte sem jakýkoli inicializační kód okna * / break; případ MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Sem přidejte obslužný kód nabídky okna * / break; případ MW_BUTTON_PRESSED_MESSAGE: if (message-> sender_handle == button_B1_handle) { / * Zde přidejte kód obsluhy pro tento ovládací prvek * / mw_create_window_dialog_colour_chooser (10, 10, "Color", MW_HAL_LCD_RED, false, message-> recipient_hand } přestávka; případ MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE: {window_W1_data.chosen_colour = message-> message_data; mw_paint_window_client (message-> recipient_handle); } přestávka; výchozí: / * Udělejte MISRU šťastnou * / přestávka; }}

Postavte a spusťte znovu a měli byste být schopni nastavit barvu výplně kruhu.

Tento příklad okenních dat používá data, která jsou uložena ve statické datové struktuře v horní části zdrojového souboru. To je v pořádku, pokud máte pouze jednu instanci okna, jako my v tomto příkladu, ale pokud máte více než jednu instanci, pak budou všichni sdílet stejnou datovou strukturu. Je možné mít data na instanci, takže více instancí stejného typu okna má svá vlastní data. To je vysvětleno v dokumentaci MiniWin v adresáři docs. Příklad souboru jej používá k zobrazení více obrázků ve stejném typu okna (jak je vidět na hlavním obrázku v horní části tohoto pokynu).

Krok 9: Nějaká finální zábava s písmem

MiniWin podporuje vykreslování písem TrueType. Pokud existuje něco, kvůli čemu vypadá vaše uživatelské rozhraní dobře, jsou to atraktivní písma. Tento poslední krok ukazuje, jak vykreslit písmo TrueType v okně MiniWin.

Existují dva způsoby vykreslování písem TrueType. Jedním z nich je nakreslit je přímo do vaší klientské oblasti, jak bylo provedeno pro kruh dříve, druhým je přidání ovládacího prvku textového pole do vašeho okna. Děláme to druhé, protože je to jednodušší.

Nyní přidáme ovládací prvek textového pole do našeho konfiguračního souboru JSON. Přidejte to do definice okna 2, aby to vypadalo takto:

takhle:

{

"Name": "W2", "Title": "Window 2", "X": 50, "Y": 65, "Width": 100, "Height": 80, "Border": true, "TitleBar": true, "Visible": true, "Minimized": false, "TextBoxes": [{"Name": "TB1", "X": 0, "Y": 0, "Width": 115, "Height": 50, "Odůvodnění": "Střed", "BackgroundColour": "MW_HAL_LCD_YELLOW", "ForegroundColour": "MW_HAL_LCD_BLACK", "Písmo": "mf_rlefont_BLKCHCRY16", "Povoleno": true, "Viditelné": true}]}}

Krátké slovo o fontech TrueType v MiniWin. Písma se dodávají v souborech.ttf. Ve správcích oken na větších počítačích jsou tyto vykresleny na váš displej, když jsou potřeba. To vyžaduje spoustu výpočetního výkonu a paměti a není vhodné pro malá zařízení. V MiniWin jsou předem zpracovány do bitmap a propojeny v době kompilace s pevnou velikostí a stylem písma (tučné písmo, kurzíva atd.), Tj. Musíte se rozhodnout, jaká písma v jaké velikosti a stylu budete při kompilaci používat. To bylo pro vás provedeno u dvou příkladů písem v staženém souboru MiniWin zip. Pokud chcete použít jiná písma jiných velikostí a stylů, podívejte se do dokumentace MiniWin ve složce docs. V MiniWin pro Windows a Linux existují nástroje pro předběžné zpracování souborů.ttf na soubory zdrojového kódu, které můžete vložit do svého projektu.

A druhé rychlé slovo - většina písem je chráněna autorskými právy, včetně těch, která najdete v systému Microsoft Windows. Používejte je libovolně pro osobní použití, ale cokoli publikujete, musíte zajistit, aby to licence, s níž jsou písma publikována, umožňovala, jako je tomu u 2 písem obsažených v MiniWin, ale ne u písem Microsoftu!

Zpět ke kódu! Generujte, přetahujte soubory, vytvářejte a znovu spusťte jako dříve a uvidíte, že Okno 2 nyní obsahuje výchozí text na žlutém pozadí v šíleném písmu. Umožňuje změnit text úpravou zdrojového souboru W2.c. okna 2.

Potřebujeme komunikovat s textovým polem, které jsme právě vytvořili, a způsob, jakým to děláte, jako každá komunikace v MiniWin, je poslat mu zprávu. Chceme nastavit text v ovládacím prvku při vytvoření okna, ale před jeho zobrazením, takže přidáme kód do obslužné rutiny zprávy v případě MW_WINDOW_CREATED_MESSAGE. Toto je přijímáno kódem okna těsně před zobrazením okna a je určeno pro inicializaci, jako je tato. Generátor kódu vytvořil držák místa, který ve funkci obsluhy zpráv vypadá takto:

případ MW_WINDOW_CREATED_MESSAGE:

/ * Přidejte sem jakýkoli inicializační kód okna */ break;

Zde pošleme zprávu do ovládacího prvku textového pole, která mu řekne, jaký text chceme, aby zobrazoval pomocí funkce mw_post_message, jako je tato:

případ MW_WINDOW_CREATED_MESSAGE:

/ * Sem přidejte libovolný inicializační kód okna */ mw_post_message (MW_TEXT_BOX_SET_TEXT_MESSAGE, message-> recipient_handle, text_box_TB1_handle, 0UL, „Twas a dark and stormy night…“, MW_CONTROL_MESSAGE); přestávka;

Toto jsou parametry:

• MW_TEXT_BOX_SET_TEXT_MESSAGE - Toto je typ zprávy, kterou posíláme do ovládacího prvku. Jsou uvedeny v souboru miniwin.h a zdokumentovány v dokumentaci.
• message-> recipient_handle - Od koho je zpráva - toto okno - jehož popisovač je v parametru zprávy předán funkci obsluhy zpráv.
• text_box_TB1_handle - Komu posíláme zprávu - popisovač ovládacího prvku textového pole. Ty jsou uvedeny ve vygenerovaném souboru miniwin_user.h.
• 0UL - hodnota dat, v tomto případě nic.
• „Byla to temná a bouřlivá noc …“- Hodnota ukazatele - nový text.
• MW_CONTROL_MESSAGE - typ příjemce, který je ovládacím prvkem.

A je to. Znovu sestavte a spusťte znovu jako obvykle a textové pole se zobrazí jako na obrázku výše.

Zveřejňování zpráv je pro MiniWin zásadní (stejně jako pro všechny správce oken). Další příklady najdete v ukázkových projektech v souboru zip a komplexní vysvětlení si přečtěte v sekci o zprávách MiniWin v dokumentaci.

Krok 10: Jít dále

To je pro tento základní úvod do MiniWin vše. MiniWin dokáže mnohem více, než se zde ukázalo. Například obrazovka na desce použitá v tomto pokynu je malá a ovládací prvky jsou malé a je třeba je používat s dibberem. Jiné příklady a hardware však používají větší ovládací prvky (existují 2 velikosti) na větších displejích, které lze ovládat prstem.

Existuje mnoho dalších typů ovládání, než jaké jsou zde ukázány. Další ovládací prvky najdete v různých příkladech souborů JSON ve složce generátoru kódu. V těchto příkladech jsou zahrnuty všechny typy ovládacích prvků.

Windows mají spoustu možností. Okraj, záhlaví a ikony lze konfigurovat. Můžete mít klientské oblasti posuvníků a rolovacího okna, více instancí stejného typu okna a oken může být nahých (pouze klientská oblast, bez ohraničení nebo záhlaví), což znamená, že jsou v době kompilace opraveny na místě na displeji (viz obrázek v této sekci s velkými ikonami - ve skutečnosti je to 6 nahých oken).

MiniWin nepoužívá žádnou dynamickou paměť. Díky tomu je vhodný pro malá omezená zařízení a je požadavkem pro některé vložené projekty. MiniWin a kód, který generuje, je také plně kompatibilní s MISRA 2012 na „požadované“úrovni.

Další informace najdete ve složce docs pro dokumentaci a také další ukázkové aplikace v souboru zip. Zde jsou příklady, které ukazují, jak používat všechny funkce MiniWin a jak integrovat MiniWin s FatFS a FreeRTOS.