Beépített ablakkezelő: 10 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:39

Ez a projekt bemutatja, hogyan valósítható meg egy ablakkezelő mozgatható, átlapolt ablakokkal egy beágyazott mikrovezérlőn, LCD panellel és érintőképernyővel. Vannak kereskedelmi forgalomban kapható szoftvercsomagok, de ezek pénzbe kerülnek és zárt forráskódúak. Ez a MiniWin nevű ingyenes és nyílt forráskódú. Teljesen kompatibilis C99 nyelven íródott, és C vagy C ++ alkalmazásban is használható. A MiniWin célja, hogy könnyen kezelhető legyen, könnyen módosítható, bővíthető, sokféle hardverre hordozható, és ne legyen túlságosan éhes.

Az ablakok kezeléséhez szükséges kód megadása mellett a MiniWin felhasználói felület -vezérlők gyűjteményét is tartalmazza - gombok, csúszkák, folyamatjelző sávok, fák stb. Az ablakok mozgathatók, átméretezhetők, maximalizálhatók, minimalizálhatók, bezárhatók - mindezek a szokásos dolgok, amelyeket a nagyobb ablakkezelők ablakával végez. A kerning és anti-aliasing (a szöveg simán kinézete) TrueType betűtípusokat is támogatja a vonzó szövegvisszaadás.

Minden ablakban van egy ügyfélterület (a szegélyen belül és a felső sáv alatt). Ezen a ponton hozzáadhat vezérlőket párbeszédablak létrehozásához, vagy a beépített grafikus könyvtár segítségével rajzolhat, amit csak akar. Az összes grafikus könyvtári funkció ablakot ismer. Nem kell aggódnia, hogy hol van az ablaka, mi van átfedésben, vagy ha minimalizálva van.

A saját ablakok készítésén kívül néhány szabványos párbeszédablak is rendelkezésre áll, amelyek nagyon könnyen létrehozhatók - például megerősítő párbeszédablakok (csak egy OK vagy Igen/Nem gombok), idő/dátum beállítások, fájlválasztók, színválasztók stb.

A MiniWin szabványos Windows Manager tervező üzenetsorrendszert használ. A Windows üzenetekkel kommunikálhat egymással és az ablakkezelővel. Nem hívja meg a függvényeket, hogy közvetlenül végezzen dolgokat, üzenetet ad hozzá a sorhoz, és az ablakkezelő végrehajtja azt az Ön számára.

A MiniWin az ST, NXP és Renesas mikrovezérlő-gyártók szabványos fejlesztőlapjaira lett áthelyezve érintőképernyős kijelzővel. Mindezen eszközökhöz vannak hardver illesztőprogramok és példaprojektek. Ezenkívül a MiniWin Windows vagy Linux rendszerre is felépíthető, így a beágyazott hardver beszerzése előtt szimulálhatja a felhasználói felület kódját.

A MiniWin kódgenerátorral rendelkezik. Az ablakokat és a vezérlőket egyszerűen megadhatja, hogy ember által olvasható JSON -fájlt hozzon létre, és a kódgenerátor elemzi a fájlt, és létrehozza az Ön számára a kódot (sok példa követhető). Windows vagy Linux komplett szimulátor alkalmazásokat hoz létre, amelyeket csak meg lehet építeni, és ott van a szimulált LCD kijelzője a MiniWin ablakokkal. Pontosan ugyanazt a generált kódot veheti be, és bedobhatja egy beágyazott projektbe, és ugyanazt a kódot jelenítheti meg ugyanazokkal az ablakokkal és vezérlőkkel később a beágyazott hardveren.

A MiniWin nem igényel működési támogatást a beágyazott eszközön. Mindez egyetlen szálban fut. A MiniWin integrálható a beágyazott processzoron futó RTOS -szal, és vannak példák a MiniWin FreeRTOS integrálására.

Ez az oktatóanyag bemutatja, hogyan lehet elindítani a MiniWin -t STM32 M4 processzoron az olcsó STM32F429 Discovery kártya segítségével, amelyhez már csatlakoztatott QVGA érintőképernyős kijelző tartozik. Ezek könnyen beszerezhetők az elektronikai alkatrészek beszállítójától.

A MiniWin középkategóriás és újabb vezérlőkön fut.

Kellékek

STM32F429I-DISC1 fejlesztőkártya és mikro USB kábel

Az STM32CubeIDE letöltése ingyenes.

1. lépés: A kód beszerzése

Először telepítenie kell az STM32CubeIDE -t. Ezt az ST honlapjáról kapja. Regisztrálnia kell, és a letöltése és telepítése eltart egy ideig. Minden ingyenes.

Telepítés közben töltse le a MiniWin forrást, és bontsa ki. Nagy, de csak egy kis részét fogja használni. Kattintson a zöld "Klón vagy letöltés" gombra itt …

github.com/miniwinwm/miniwinwm

majd válassza a Zip letöltése lehetőséget. Csomagolja ki a tartalmat.

2. lépés: Példaprojekt építése

Először építsük fel az egyik példa projektet. Egy jót MiniWinSimple -nek hívnak. Indítsa el az STM32CubeIDE alkalmazást, majd tegye a következőket:

1. Válassza a Fájl | Importálás lehetőséget…
2. Nyissa meg az Általános elemet, és válassza a Meglévő projekt a munkaterületre lehetőséget. Következő.
3. Kattintson a Tallózás gombra, és navigáljon arra a helyre, ahol kicsomagolta a MiniWin -t. Ezután lépjen az STM32CubeIDE / MiniWinSimple / STM32F429 mappába. Kattintson a Mappa kiválasztása elemre.
4. A Projectben: jelölje be a MiniWinSimple_STM32F429 jelölőnégyzetet, majd kattintson a Befejezés gombra.
5. A MiniWinSimple_STM32F429 projekt megjelenik a Project Explorerben. Válassza ki, majd készítse el a Project | Build Project segítségével.
6. Most csatlakoztassa az USB -kábelt az alaplaphoz és a számítógéphez, és futtassa a Futtatás | Hibakeresés paranccsal, és amikor letöltötte, válassza a Futtatás | Folytatás lehetőséget. Az első alkalommal képernyő -kalibrációs kijelzőt kap, ezért érintse meg a három kereszt közepét az LCD -kijelzőn. Most már kezelheti a kijelző ablakát.

Egy ablak mozgatásához húzza a címsorához. Egy ablak átméretezéséhez használja a címsor bal oldalán található fehér háromszög ikont. A MiniWin ablakok átméretezése nem lehetséges a szegélyek húzásával, mivel a MiniWin kijelzői túl kicsik. Az ablak minimalizálásához, maximalizálásához vagy bezárásához használja a címsor jobb oldalán található ikonokat (a bezárás esetleg le van tiltva). Ha egy ablak kicsinyítve van, akkor nem mozgathatja a kicsinyített ikonokat. Balról jobbra felfelé építkeznek.

3. lépés: Futtassa a kódgenerátort

Most megváltoztatjuk a példaprojektet úgy, hogy előállítunk néhány saját ablakot, és bedobjuk az új kódot. Ehhez futtatjuk a kódgenerátort.

1. Nyisson meg egy parancssort, és lépjen abba a mappába, ahol kicsomagolta a MiniWin -t, majd az Eszközök / CodeGen mappába.
2. A Windows CodeGen.exe futtatható fájlja már elérhető. Linux esetén a make beírásával kell felépíteni. (A Windows forrásból is elkészítheti, ha aggódik egy letöltött futtatható fájl futtatása miatt, de telepítenie kell a fordítót és a fejlesztői környezetet. Részletekért tekintse meg a MiniWin dokumentációját a docs mappában.)
3. Ebben a mappában található néhány példa JSON fájl. Az example_empty.json fájlt fogjuk használni. A Windows vagy Linux rendszer beállításához először szerkesztenie kell. Nyissa meg egy szerkesztőben, és a tetején, ahol a "TargetType" elemet találja, módosítsa a "Linux" vagy "Windows" értéket arra, amin a kódgenerátort futtatja.
4. Most írja be a codegen example_empty.json parancsot a parancssorba.
5. Nyissa meg a projektet az STM32CubeIDE -ban, és nyissa meg a MiniWinSimple_Common mappát. Törölje az összes benne lévő fájlt.
6. A "TargetName" -t a JSON fájlban hagytuk alapértelmezettként a "MiniWinGen" -nél, így ez a generált kódot tartalmazó mappánk neve. Nyissa meg azt a mappát, ahol kicsomagolta a MiniWin -t, majd a MiniWinGen_Common mappát. Most válassza ki ezeket a fájlokat, majd húzza át az STM32CubeIDE -ba a projekt MiniWinSimple_Common mappájában.
7. Most építse újra és futtassa újra a projektet az STM32CubeIDE -ban, és megjelenik az új tervezési ablak. Az ablak gombja eltűnt, mert az example_empty.json nem definiál semmit.

4. lépés: Ablak hozzáadása

Most hozzáadunk egy második ablakot a JSON konfigurációs fájlhoz, és újrageneráljuk a kódot.

1. Nyissa meg az example_empty.json fájlt egy szövegszerkesztőben.

2. A "Windows" rész alatt egy sor Windows definíció található, amelyeknek jelenleg csak egy ablaka van. Másolja mindezt…

{

"Név": "W1", "Cím": "Ablak 1", "X": 10, "Y": 15, "Szélesség": 200, "Magasság": 180, "Szegély": igaz, "Címsor": true, "Visible": true, "Minimized": false}

és illessze be újra a két definíciót elválasztó vesszővel.

3. Változtassa meg a "W1" -t "W2" -re, az "Window 1" -t pedig "Window 2" -ra. Módosítsa az "X", "Y", "Szélesség" és "Magasság" értékeket különböző értékekre, szem előtt tartva, hogy a képernyő felbontása 240 széles és 320 magas.

4. Mentse a fájlt, és futtassa újra a kódgenerátort.

5. Másolja a fájlokat az előző lépéshez hasonlóan, építse újra és futtassa újra. Most 2 ablak jelenik meg a kijelzőn.

5. lépés: Vezérlő hozzáadása

Most hozzáadunk néhány vezérlőt az új ablakhoz. Szerkessze ugyanazt a fájlt, mint az előző lépésben.

1. A W1 ablak specifikációjában adjon hozzá vesszőt az utolsó beállítás után ("Minimizált": hamis), majd adja hozzá ezt a szöveget

"MenuBar": igaz, "MenuBarEnabled": true, "MenuItems": ["Fred", "Bert", "Pete", "Alf", "Ian"], "Buttons": [{"Name": "B1", "Label": "Button1", "X": 10, "Y": 10, "Enabled": true, "Visible": true}]

Ez a szakasz hozzáad egy menüelemet 5 elemmel, és engedélyezi azt (a menüsorok globálisan letilthatók, próbálja ki). Hozzáad egy engedélyezett és látható gombot is (ezeket láthatatlanná lehet tenni, majd később láthatóvá kell tenni a kódban).

2. Regenerálja a kódot, másolja át, építse újra, futtassa újra, mint korábban.

6. lépés: Az irányítás elvégzése

Most megvan az alapvető felhasználói felület, amire szükségünk van ahhoz, hogy valamit tegyen. Ebben a példában megjelenik egy színválasztó párbeszédpanel, amikor megnyomja az 1. ablak gombot.

Nyissa meg a projektet az STM32CubeIDE programban, és nyissa meg a MiniWinSimple_Common mappát, majd nyissa meg a W1.c fájlt (ennek a fájlnak a neve megfelel a JSON fájl ablakának "Név" mezőjének, amikor a kódot generálták).

Ebben a fájlban megtalálja az ablak_W1_üzenet_funkció () függvényt. Ez így néz ki:

void window_W1_message_function (const mw_message_t *message) {MW_ASSERT (message! = (void *) 0, "Null pointer paraméter"); / * A következő sor leállítja a fordító figyelmeztetéseit, mivel a változó jelenleg nincs használatban */ (void) window_W1_data; switch (message-> message_id) {case MW_WINDOW_CREATED_MESSAGE: / * Itt adhat hozzá bármilyen ablak inicializáló kódot * / break; eset MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Itt adja hozzá az ablakmenü kezelési kódját * / break; MW_BUTTON_PRESSED_MESSAGE eset: if (message-> sender_handle == button_B1_handle) { / * Itt adja hozzá a kezelő kódját ehhez a vezérlőhöz * /} break; alapértelmezett: / * Tartsa boldognak a MISRA -t * / break; }}

Ezt az ablakkezelő hívja erre az ablakra, amikor az ablakkezelőnek értesítenie kell az ablakot, hogy valami történt. Ebben az esetben szeretnénk tudni, hogy az ablak egyetlen gombját megnyomták. Az üzenettípusok kapcsolójában az MW_BUTTON_PRESSED_MESSAGE esetet láthatja. Ez a kód a gomb megnyomásakor fut. Ebben az ablakban csak egy gomb található, de több is lehet, ezért ellenőrzik, hogy melyik gomb. Ebben az esetben csak a B1 gomb lehet (a név ismét megegyezik a JSON fájl gombjának nevével).

Tehát az esetcímke után adja hozzá a kódot egy színválasztó párbeszédablakhoz, amely a következő:

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

A paraméterek a következők:

• 10, 10 a párbeszédablak képernyőjén található hely
• "Szín" a párbeszédablak címe
• A párbeszédpanel alapértelmezett színe az MW_HAL_LCD_RED
• hamis azt jelenti, hogy ne mutasson nagy méretet (próbálja meg igazra állítani, és nézze meg a különbséget)
• az üzenet-> címzett kezelője az, akinek ez a párbeszédpanel a tulajdonosa, ebben az esetben ez az ablak. Egy ablak fogantyúja van a funkció üzenetparaméterében. Ez az az ablak, amelyre a párbeszédpanel válaszát küldi.

A felhasználó által kiválasztott szín értékének kiderítéséhez az ablakkezelő elküldi ablakunknak a választott színű üzenetet, amikor a felhasználó megnyomja az OK gombot a párbeszédpanelen. Ezért ezt az üzenetet is el kell fognunk egy másik esettel a kapcsoló utasításban, amely így néz ki:

MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE eset:

{mw_hal_lcd_colour_t selected_colour = message-> message_data; (void) selected_colour; } szünet;

A választott színnel még nem csinálunk semmit, ezért pusztítsuk el, hogy elkerüljük a fordító figyelmeztetését. Ennek a funkciónak a végső kódja így néz ki:

void window_W1_message_function (const mw_message_t *üzenet)

{MW_ASSERT (message! = (Void*) 0, "Null pointer paraméter"); / * A következő sor leállítja a fordító figyelmeztetéseit, mivel a változó jelenleg nincs használatban */ (void) window_W1_data; switch (message-> message_id) {case MW_WINDOW_CREATED_MESSAGE: / * Itt adhat hozzá bármilyen ablak inicializáló kódot * / break; eset MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Itt adja hozzá az ablakmenü kezelési kódját * / break; eset MW_BUTTON_PRESSED_MESSAGE: if (message-> sender_handle == button_B1_handle) { / * Itt adja hozzá a kezelő kódját ehhez a vezérlőhöz * / mw_create_window_dialog_colour_chooser (10, 10, "Color", MW_HAL_LCD_RED, false, message->) } szünet; eset MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE: {mw_hal_lcd_colour_t selected_colour = message-> message_data; (void) selected_colour; } szünet; alapértelmezett: / * Tartsa boldognak a MISRA -t * / break; }}

A kód futtatása a fenti képen látható. Észreveheti, hogy amikor egy párbeszédpanel jelenik meg, válaszolnia kell rá, és el kell utasítania, mielőtt bármi mást tenne. Ezt modális viselkedésnek nevezik. Párbeszédablakok a MiniWin -ben és mindenhol globálisan modális, és egyszerre csak egy megjelenítés jelenhet meg. Itt több magyarázat is van…

en.wikipedia.org/wiki/Modal_window

7. lépés: Rajz az ablakban

Eddig csak kezelőszerveket használtunk, és azok maguk rajzolnak. Itt az ideje, hogy egyedi rajzokat készítsünk az ablakunkon. A rajzolni kívánt rész a kereteken belül található (ha vannak ilyenek, akkor nem kötelezőek), a görgetősávokon belül (ha definiált, akkor is opcionális) és a címsor alatt (ha van ilyen, akkor ez is opcionális). Az ablak terminológiájában ügyfélterületnek nevezik.

A MiniWin -ben van egy grafikus parancskönyvtár, amelyet használhat. Mindannyian ablakérzékenyek. Ez azt jelenti, hogy nem kell aggódnia attól, hogy az ablak látható -e, részben eltakarja -e más ablakok, be, részben ki vagy teljesen le a képernyőn, vagy ha a rajz koordinátája az ügyfélterületen vagy azon túl van. Az egész gondoskodik helyetted. Nem rajzolhat az ügyfélterületén kívül.

A Windows terminológiában az ügyfélterületekre történő rajzolást festésnek nevezik, és minden ablaknak van festési funkciója, ahol Ön rajzolja. Nem hívja a festési funkciót, az ablakkezelő elvégzi helyetted, ha szükséges. Erre akkor van szükség, ha egy ablakot elmozdítanak, vagy egy másik ablak tetején megváltozik a helyzete vagy a láthatósága. Ha szüksége van az ablak újrafestésére, mert az ablak tartalmától függő néhány adat megváltozott (azaz tudja, hogy újrafestésre van szükség, nem pedig az ablakkezelőnek), akkor mondja meg az ablakkezelőnek, hogy újrafestésre van szükség, és felhívja a festési funkcióját. Te magad nem hívod. (Mindezt a következő részben mutatjuk be).

Először is meg kell találnia a festési funkciót. A kódgenerátor létrehozza az Ön számára, és közvetlenül az előző részben módosított üzenetkezelő funkció felett van. Nyissa meg a projektet, és nyissa meg újra a W1.c fájlt.

Ebben a fájlban megtalálja a window_W1_paint_function () függvényt. Ez így néz ki:

void 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 paraméter"); / * Töltse fel az ablak ügyfélterületét egyszínű fehérrel */ 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).hight); / * Itt adhat hozzá ablakfestési kódot */}

Ez a puszta generált kód, és csak annyit tesz, hogy kitölti az ügyfélterületet egyszínű fehérrel. Rajzoljunk egy sárga kört az ügyfél területére. Először is meg kell értenünk a grafikus kontextus fogalmát (egy másik Windows dolog). Rajzparamétereket állítunk be a grafikus kontextusban, majd hívunk egy általános kör rajzolási rutint. Ebben a példában meg kell határoznunk, hogy a körnek van -e szegélye, szegélyvonala, szegélyszíne, hogy a kör kitöltött -e, kitöltési szín és kitöltési minta. Láthatja a fenti kódot, amely valami hasonlót tesz az ügyfélterület szegély nélküli, tömött fehér téglalappal való kitöltéséhez. A grafikus kontextusban szereplő értékek nem emlékeznek a festési funkció minden egyes hívása között, ezért minden alkalommal be kell állítania az értékeket (azonban a festési funkcióval emlékeznek rájuk).

A fenti kódban láthatja, hogy a kitöltés be van kapcsolva, és a kitöltési minta ki van kapcsolva, így ezeket nem kell újra beállítani. Be kell állítanunk a szegélyt, a szegély vonal stílusát egyszínűre, a szegély előtér színét feketére, a színt pedig sárgára kell tölteni, mint ez:

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);

Adja hozzá ezt a kódot a funkció megjegyzéséhez, ahol azt írja, hogy adja hozzá a kódot. Ezután rajzoljunk egy kört, amely így történik:

mw_gl_circle (draw_info, 30, 30, 15);

Ez egy kört rajzol a 30, 30 koordinátákon, 15 sugarú körben. Újratelepítse a kódot, és futtassa újra, és egy kört fog látni az ablakban a fent látható módon. Észre fogja venni, hogy a kör és a gomb átfedésben vannak, de a gomb felül van. Ez a tervezés szerint történik. A vezérlők mindig az ügyfélterületen rajzolt elemek tetején vannak.

8. lépés: Ablakadatok

Eddig saját kódunkat valósítottuk meg az ablak 1 üzenetfunkciójában (a bejövő üzenetek kezelésére) és festési funkciójában (az ablak ügyfélterületére történő rajzoláshoz). Most itt az ideje összekapcsolni a kettőt. Töltse ki a festési funkcióban rajzolt kört azzal a színnel, amelyet a felhasználó választott a színválasztó által a gomb megnyomásakor. Ne feledje, hogy mi nem a festési függvényt hívjuk, hanem az ablakkezelő, így az üzenetfunkciónk (amely ismeri a kiválasztott színt) nem hívhatja közvetlenül magát a festési függvényt. Ehelyett gyorsítótárazni kell az adatokat, és értesítenünk kell az ablakkezelőt, hogy újrafestésre van szükség. Az ablakkezelő ezután meghívja a festési funkciót, amely felhasználhatja a gyorsítótárazott adatokat.

A W1.c tetején egy üres adatstruktúrát és egy ilyen típusú objektumot láthat, amelyet a kódgenerátor deklarált:

typedef szerkezet

{ / * Adja hozzá adattagjait ide * / char dummy; /* Egyes fordítók panaszkodnak az üres struktúrákra; távolítsa el ezt, amikor hozzáadja tagjait */} window_W1_data_t; static window_W1_data_t window_W1_data;

Itt tároljuk gyorsítótárban adatainkat, hogy azok megőrződjenek a hívások során, és ablakadatok néven ismertek. Csak a kiválasztott színt kell itt tárolnunk, például:

typedef szerkezet

{ / * Adja hozzá adattagjait ide * / mw_hal_lcd_colour_t selected_colour; } window_W1_data_t; static window_W1_data_t window_W1_data = {MW_HAL_LCD_YELLOW};

A kezdő színt sárgának adjuk. Most az üzenet funkcióban kissé módosítjuk a kódot, hogy a kiválasztott színt itt mentsük:

MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE eset:

{window_W1_data.chosen_colour = message-> message_data; } szünet;

Ezután megváltoztatjuk a festési függvényt, hogy ezt az értéket használja, amikor a kört így rajzolja:

mw_gl_set_solid_fill_colour (window_W1_data.chosen_colour);

Most megváltoztattuk azokat az adatokat, amelyeken az ablak tartalma függ, ezért tájékoztatnunk kell az ablakkezelőt, hogy az ablak újrafestésre szorul. Ezt az üzenet funkcióban tesszük, amikor a párbeszédpanel OK üzenete érkezik, például:

mw_paint_window_client (üzenet-> címzett_kezelő);

Ez nem eredményezi az ablak közvetlen festését. Ez egy segédprogram, amely üzenetet küld az ablakkezelőnek arról, hogy az ablakot újra kell festeni (ha belép, láthatja, hogyan történik ez). Az ablak, amelyet ebben az esetben újra kell festeni, maga, és az ablak fogantyúja az üzenetkezelő funkció üzenetparaméterében található.

Az egész fájl most így néz ki, ha nem biztos abban, hogy a fenti kódrészletek egy része hova kerül:

#befoglalni

#include "miniwin.h" #include "miniwin_user.h" #include "W1.h" typedef structure { / * Adja hozzá az adattagokat ide * / mw_hal_lcd_colour_t selected_colour; } window_W1_data_t; static window_W1_data_t window_W1_data = {MW_HAL_LCD_YELLOW}; void 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 paraméter"); / * Töltse fel az ablak ügyfélterületét egyszínű fehérrel */ 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).hight); / * Itt adhat hozzá ablakfestési kódot */ 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); } void window_W1_message_function (const mw_message_t *message) {MW_ASSERT (message! = (void *) 0, "Null pointer paraméter"); / * A következő sor leállítja a fordító figyelmeztetéseit, mivel a változó jelenleg nincs használatban */ (void) window_W1_data; switch (message-> message_id) {case MW_WINDOW_CREATED_MESSAGE: / * Itt adhat hozzá bármilyen ablak inicializáló kódot * / break; eset MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Itt adja hozzá az ablakmenü kezelési kódját * / break; eset MW_BUTTON_PRESSED_MESSAGE: if (message-> sender_handle == button_B1_handle) { / * Itt adja hozzá a kezelő kódját ehhez a vezérlőhöz * / mw_create_window_dialog_colour_chooser (10, 10, "Color", MW_HAL_LCD_RED, false, message->) } szünet; eset MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE: {window_W1_data.chosen_colour = message-> message_data; mw_paint_window_client (üzenet-> címzett_kezelő); } szünet; alapértelmezett: / * Tartsa boldognak a MISRA -t * / break; }}

Építsen és futtasson újra, és képesnek kell lennie a kör kitöltési színének beállítására.

Az ablakadatok ezen példája a forrásfájl tetején lévő statikus adatszerkezetben tárolt adatokat használja. Ez rendben van, ha csak egy példánya van az ablaknak, mint mi ebben a példában, de ha több példánya van, akkor mindegyik ugyanazt az adatszerkezetet használja. Lehetőség van példányonkénti adatokra, így több, azonos típusú ablaknak saját példánya van. Ezt a docs könyvtárban található MiniWin dokumentáció ismerteti. A fájlpélda azt használja, hogy több képet jelenítsen meg ugyanabban az ablaktípusban (amint ez az utasítás legfelül található fő képén látható).

9. lépés: Néhány utolsó betűtípus

A MiniWin támogatja a TrueType betűtípus -megjelenítést. Ha van valami, ami miatt a felhasználói felület jól néz ki, akkor vonzó betűtípusok. Ez az utolsó lépés bemutatja, hogyan lehet a TrueType betűtípust megjeleníteni a MiniWin ablakban.

A TrueType betűtípusok kétféleképpen jeleníthetők meg. Az egyik az, hogy közvetlenül az ügyfélterületre rajzolja őket, mint korábban a körre, a másik az, hogy hozzáad egy szövegdoboz vezérlőt az ablakhoz. Mi az utóbbit csináljuk, mert könnyebb.

Most hozzáadunk egy szövegdoboz vezérlőt a JSON konfigurációs fájlunkhoz. Adja hozzá az Window 2 definíciójához, így néz ki:

mint ez:

{

"Név": "W2", "Cím": "Ablak 2", "X": 50, "Y": 65, "Szélesség": 100, "Magasság": 80, "Szegély": igaz, "Címsor": true, "Visible": true, "Minimized": false, "TextBoxes": [{"Name": "TB1", "X": 0, "Y": 0, "Width": 115, "Height": 50, "Indokolás": "Center", "BackgroundColour": "MW_HAL_LCD_YELLOW", "ForegroundColour": "MW_HAL_LCD_BLACK", "Font": "mf_rlefont_BLKCHCRY16", "Enabled": true, "Visible": true}]}

Egy rövid szó a TrueType betűtípusokról a MiniWin -ben. A betűtípusok.ttf fájlokban jelennek meg. A nagyobb számítógépek ablakkezelőiben szükség esetén megjelennek a kijelzőn. Ez sok feldolgozási energiát és memóriát igényel, és nem alkalmas kis eszközökhöz. A MiniWin programban bitképekké dolgozzák fel őket, és fordítási időben rögzített betűmérettel és -stílussal (félkövér, dőlt, stb.) Kapcsolják össze, azaz el kell döntenie, hogy milyen betűtípusokat milyen stílusban és méretben fog használni a fordításkor. Ezt megtettük Önnek a letöltött MiniWin zip fájl két betűtípusához. Ha más méretű és stílusú más betűtípusokat szeretne használni, tekintse meg a MiniWin dokumentációját a docs mappában. Vannak eszközök a MiniWin for Windows és Linux rendszerben a.ttf fájlok forráskód fájlokká történő előzetes feldolgozásához, amelyeket bedobhat a projektbe.

És egy második gyors szó - a legtöbb betűtípus szerzői jogi, beleértve azokat is, amelyeket a Microsoft Windows rendszerben talál. Használja őket tetszés szerint személyes használatra, de bármit, amit közzétesz, gondoskodnia kell arról, hogy a betűtípusok közzétételéhez szükséges licenc ezt lehetővé tegye, mint például a MiniWinben található 2 betűtípus esetében, de nem a Microsoft betűtípusait!

Vissza a kódhoz! Generáljon, dobjon el fájlokat, építsen és futtasson, mint korábban, és látni fogja, hogy a Window 2 most alapértelmezett szöveget tartalmaz sárga alapon, furcsa betűtípussal. Változtassuk meg a szöveget a Windows 2 forrásfájljának W2.c szerkesztésével.

Kommunikálnunk kell az imént létrehozott szövegdobozzal, és ezt úgy kell tennie, mint a MiniWin minden kommunikációjában, hogy üzenetet küldünk neki. Be akarjuk állítani a szöveget a vezérlőben az ablak létrehozásakor, de még mielőtt megjelenne, ezért az üzenetkezelőben adunk hozzá kódot az MW_WINDOW_CREATED_MESSAGE esetben. Ezt az ablak kódja közvetlenül az ablak megjelenítése előtt kapja meg, és az ilyen inicializálásra szolgál. A kódgenerátor létrehozott egy helytartót, amely így néz ki az üzenetkezelő funkcióban:

MW_WINDOW_CREATED_MESSAGE eset:

/ * Itt adhat hozzá bármilyen ablak inicializáló kódot */ break;

Itt egy üzenetet fogunk közzétenni a szövegmező vezérlőjében, amely megmondja, hogy milyen szöveget szeretnénk megjeleníteni az mw_post_message függvény használatával:

MW_WINDOW_CREATED_MESSAGE eset:

/ * Itt adhat hozzá bármilyen ablak inicializáló kódot */ mw_post_message (MW_TEXT_BOX_SET_TEXT_MESSAGE, message-> recipient_handle, text_box_TB1_handle, 0UL, "Sötét és viharos éjszaka volt …", MW_CONTROL_MESSAGE); szünet;

Ezek a paraméterek:

• MW_TEXT_BOX_SET_TEXT_MESSAGE - Ezt az üzenettípust küldjük a vezérlőnek. A miniwin.h -ban szerepelnek, és dokumentálva vannak.
• message-> recipient_handle - Ettől származik az üzenet - ez az ablak - amelynek fogantyúja az üzenetkezelő funkciónak átadott üzenetparaméterben található.
• text_box_TB1_handle - Kinek küldjük az üzenetet - a szövegdoboz vezérlőjének fogantyúja. Ezeket a miniwin_user.h létrehozott fájl tartalmazza.
• 0UL - Adatérték, ebben az esetben semmi.
• "Sötét és viharos éjszaka volt …" - Mutatóérték - az új szöveg.
• MW_CONTROL_MESSAGE - Címzett típusa, amely egy vezérlőelem.

Ez az. Építse újra és futtassa a szokásos módon, és megkapja a szövegdobozt, mint a fenti képen.

Az üzenetküldés alapvető fontosságú a MiniWin számára (mint minden ablakkezelő számára). További példákért tekintse meg a zip fájlban található példaprojekteket, és átfogó magyarázatért olvassa el a dokumentáció MiniWin üzenetek című szakaszát.

10. lépés: Továbblépés

Ennyi a MiniWin alapvető bevezetéséhez. A MiniWin sokkal többet tud, mint amit itt bemutattak. Például az ebben az utasításban használt képernyő a képernyőn kicsi, a kezelőszervek kicsik, és kétüteművel kell használni. Más példák és hardverek azonban nagyobb kezelőszerveket (2 méretet) használnak a nagyobb kijelzőn, és ezek ujjal is kezelhetők.

Az itt bemutatottakon kívül sok más típusú ellenőrzés is létezik. További vezérlőkért tekintse meg a kódgenerátor mappában található különféle JSON -fájlokat. Ezekben a példákban minden vezérléstípus szerepel.

A Windowsnak sok lehetősége van. A szegély, a címsor és az ikonok konfigurálhatók. Létezhetnek görgetősávok és görgethető ablakkliensterületek, több azonos típusú ablak és ablak is meztelen (csak egy ügyfélterület, szegély vagy címsor nélkül), ami azt jelenti, hogy a fordítási időben rögzítve vannak a kijelzőn (lásd a képet ebben a részben nagy méretű ikonokkal - ezek valójában 6 csupasz ablakok).

A MiniWin nem használ dinamikus memóriát. Ez alkalmassá teszi kis kényszerített eszközökhöz, és egyes beágyazott projektek esetében követelmény. A MiniWin és az általa generált kód is teljes mértékben megfelel a MISRA 2012 követelményeinek.

További információkért nézze meg a dokumentáció mappáját a dokumentumok mappában, valamint a zip fájlban található többi példaprogramot. Itt vannak példák, amelyek bemutatják, hogyan kell használni a MiniWin összes funkcióját, és hogyan integrálható a MiniWin a FatFS és a FreeRTOS rendszerbe.