Embedded Window Manager: 10 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:25

Dette projekt viser, hvordan man implementerer en vinduesmanager med bevægelige overlappede vinduer på en integreret mikro-controller med et LCD-panel og en berøringsskærm. Der er kommercielt tilgængelige softwarepakker til at gøre dette, men de koster penge og er lukket kilde. Denne, kaldet MiniWin, er gratis og open-source. Den er skrevet i fuldt kompatibel C99 og kan bruges i en C eller C ++ applikation. Målene med MiniWin er at være nemme at bruge, nemme at ændre, udvidelige, bærbare til en bred vifte af hardware og ikke for ressourcessultne.

Udover at give koden til at styre dine vinduer har MiniWin en samling af brugergrænsefladekontroller - knapper, skydere, statuslinjer, træer osv. Du kan have flere vinduer af forskellige typer eller flere forekomster af samme type. Windows kan flyttes rundt, ændres størrelse, maksimeres, minimeres, lukkes - alt det sædvanlige, du gør med vinduer i større vinduesadministratorer. TrueType-skrifttyper med kerning og anti-aliasing (får tekst til at se smooooooth ud) understøttes også for attraktiv tekstgengivelse.

I hvert vindue har du et klientområde (din plads inden for grænsen og under den øverste bjælke). På dette kan du tilføje kontroller til at lave en dialog, eller du kan bruge det indbyggede grafikbibliotek til at tegne, hvad du vil. Alle grafikbibliotekets funktioner er vinduesbevidste. Du behøver ikke bekymre dig om, hvor dit vindue er, hvad der overlapper det, eller om det er minimeret.

Udover at lave dine egne vinduer er der også inkluderet nogle standarddialoger, der er meget lette at instantiere - f.eks. Bekræftelsesdialogbokse (bare en OK eller Ja/Nej -knapper), tids-/datosættere, filvalg, farvevalg osv.

MiniWin bruger et standard Windows Manager -designmeddelelseskøsystem. Windows kan interagere med hinanden og vindueshåndteringen via beskeder. Du kalder ikke funktioner for at gøre tingene direkte, du tilføjer en besked til køen, og vindueshåndteringen vedtager den for dig.

MiniWin er blevet portet til standardudviklingskort med berøringsskærme fra mikro-controller-leverandører ST, NXP og Renesas. Der er hardwaredrivere og eksempelprojekter til alle disse enheder. Derudover kan MiniWin bygges til Windows eller Linux, så du kan simulere din brugergrænsefladekode, før du får din indlejrede hardware.

MiniWin har en kodegenerator. Du kan angive dine vinduer og kontrolelementer i en letoprettelig JSON -fil, der kan læses af mennesker, og kodegeneratoren analyserer filen og opretter koden for dig (der er masser af eksempler at følge). Det skaber komplette Windows- eller Linux -simulatorapplikationer, der bare kan bygges, og der er din simulerede LCD -skærm, hvor dine MiniWin -vinduer fungerer. Du kan tage nøjagtig den samme genererede kode og slippe den ind i et integreret projekt og have den samme kode, der viser de samme vinduer og kontroller øjeblikke senere på din indlejrede hardware.

MiniWin kræver ingen driftsstøtte på den integrerede enhed. Det hele kører i en enkelt tråd. MiniWin kan integreres med en RTOS, der kører på en integreret processor, og der er eksempler på integration af MiniWin med FreeRTOS.

Denne instruktive viser, hvordan du får MiniWin i gang på en STM32 M4 -processor ved hjælp af det billige STM32F429 Discovery -kort, der leveres med et QVGA -berøringsskærm, der allerede er tilsluttet. Disse er let tilgængelige fra din elektronikkomponentleverandør.

MiniWin kører på mellemklasse mikro-controllere og derover.

Forbrugsvarer

STM32F429I-DISC1 udviklingskort og et mikro-USB-kabel

STM32CubeIDE download, som er gratis.

Trin 1: Hent koden

Først og fremmest skal du installere STM32CubeIDE. Det får du fra ST's websted. Du skal registrere, og det tager et stykke tid at downloade og installere det. Det hele er gratis.

Mens det installerer, skal du downloade MiniWin -kilden og pakke den ud. Det er stort, men du vil kun bruge en lille del af det. Klik på den grønne 'Klon eller download' knap her …

github.com/miniwinwm/miniwinwm

vælg derefter Download Zip. Pak indholdet ud.

Trin 2: Opbygning af et eksempelprojekt

Lad os først bygge et af eksempelprojekterne. En god hedder MiniWinSimple. Start STM32CubeIDE, og gør derefter dette:

1. Vælg Fil | Importer …
2. Åbn Generelt, og vælg Eksisterende projekt i arbejdsområde. Næste.
3. Klik på Gennemse, og naviger til det sted, hvor du pakkede MiniWin ud. Gå derefter til mappen STM32CubeIDE / MiniWinSimple / STM32F429. Klik på Vælg mappe.
4. I projekt: afkryds MiniWinSimple_STM32F429, klik derefter på Udfør.
5. MiniWinSimple_STM32F429 -projektet vises i din Project Explorer. Vælg det, og byg det derefter med Project | Build Project.
6. Tilslut nu dit USB -kabel til kortet og din computer, og kør det ved hjælp af Kør | Debug, og når det er downloadet, skal du vælge Kør | Genoptag. Du får en skærmkalibreringsdisplay første gang, så tryk på midten af de 3 kryds på LCD -displayet. Du kan nu interagere med vinduet på displayet.

For at flytte et vindue skal du trække det ved titellinjen. For at ændre størrelsen på et vindue skal du bruge det hvide trekantikon til venstre for titellinjen. MiniWin -vinduer kan ikke ændres ved at trække i grænserne, da skærmene MiniWin bruges på er for små. For at minimere, maksimere eller lukke et vindue skal du bruge ikonerne i højre ende af titellinjen (tæt kan være deaktiveret). Når et vindue er minimeret, kan du ikke flytte de minimerede ikoner rundt. De bygger op fra bunden til venstre til højre.

Trin 3: Kørsel af kodegeneratoren

Nu vil vi ændre eksempelprojektet ved at generere nogle egne vinduer og slippe den nye kode i. For at gøre dette kører vi kodegeneratoren.

1. Åbn en kommandoprompt, og gå til den mappe, hvor du pakkede MiniWin ud, og derefter til mappen Tools / CodeGen.
2. Den eksekverbare til Windows CodeGen.exe er allerede tilgængelig. For Linux skal du bygge det ved at skrive make. (Du kan også bygge den fra kilde til Windows, hvis du er bekymret for at køre en downloadet eksekverbar fil, men du skal installere kompilatoren og udviklingsmiljøet. Se MiniWin -dokumentationen i dokumentmappen for at få flere oplysninger).
3. I denne mappe er der nogle eksempler på JSON -filer. Vi bruger eksempel_empty.json. Du skal først redigere det for at konfigurere det til Windows eller Linux. Åbn den i en editor og øverst, hvor du finder "TargetType", ændrer du værdien "Linux" eller "Windows" til, hvad du kører kodegeneratoren på.
4. Skriv nu codegen example_empty.json i kommandoprompten.
5. Gå til dit projekt i STM32CubeIDE, og åbn mappen MiniWinSimple_Common. Slet alle filerne derinde.
6. Vi forlod "TargetName" i JSON -filen som standard på "MiniWinGen", så det er navnet på vores mappe med genereret kode. Gå til den mappe, hvor du pakkede MiniWin ud og derefter MiniWinGen_Common -mappen. Vælg nu alle disse filer, og træk og slip dem derefter til STM32CubeIDE i dit projekts MiniWinSimple_Common -mappe.
7. Nu genopbyg og genopfør projektet i STM32CubeIDE, og dit nye designvindue vises. Knappen i vinduet er gået, fordi eksempel_empty.json ikke definerer nogen.

Trin 4: Tilføjelse af et vindue

Vi tilføjer nu et andet vindue til JSON -konfigurationsfilen og regenererer koden.

1. Åbn eksempel_empty.json i en teksteditor.

2. Under afsnittet "Windows" er der en vifte af Windows -definitioner, som i øjeblikket kun har ét vindue. Kopier alt dette …

{

"Navn": "W1", "Titel": "Vindue 1", "X": 10, "Y": 15, "Bredde": 200, "Højde": 180, "Border": true, "TitleBar": true, "Synlig": true, "Minimeret": falsk}

og indsæt den igen med et komma, der adskiller de 2 definitioner.

3. Skift "W1" til "W2" og "Vindue 1" til "Vindue 2". Skift "X", "Y", "Bredde" og "Højde" til nogle forskellige værdier, og husk, at skærmopløsningen er 240 bred og 320 høj.

4. Gem filen, og kør kodegeneratoren igen.

5. Kopier filerne som i det foregående trin, genopbyg og kør igen. Du vil nu have 2 vinduer på din skærm.

Trin 5: Tilføjelse af en kontrol

Nu tilføjer vi nogle kontroller til dit nye vindue. Rediger den samme fil som i det foregående trin.

1. I specifikationen for vindue W1 tilføj et komma efter den sidste indstilling ("Minimeret": falsk) og tilføj derefter denne tekst

"MenuBar": sandt, "MenuBarEnabled": true, "MenuItems": ["Fred", "Bert", "Pete", "Alf", "Ian"], "Buttons": [{"Name": "B1", "Label": "Knap1", "X": 10, "Y": 10, "Aktiveret": sand, "Synlig": sand}}

Dette afsnit tilføjer en menulinje med 5 elementer og aktiverer det (menulinjer kan deaktiveres globalt, prøv det). Det tilføjer også en knap, der er aktiveret og synlig (de kan oprettes usynlige og derefter gøres synlige i kode senere).

2. Regenerer koden, kopier den på tværs, genopbyg, kør alt igen som før.

Trin 6: Få kontrolelementerne til at gøre noget

Nu har vi den grundlæggende brugergrænseflade, vi har brug for for at få den til at gøre noget. I dette eksempel dukker vi op en farvevælgerdialog, når der trykkes på knappen i vindue 1.

Gå til dit projekt i STM32CubeIDE, og åbn MiniWinSimple_Common -mappen, og åbn derefter filen W1.c (navnet på denne fil svarer til vinduets "Navn" -felt i JSON -filen, når koden blev genereret).

I denne fil finder du funktionen window_W1_message_function (). Det ser sådan ud:

void window_W1_message_function (const mw_message_t *message) {MW_ASSERT (message! = (void *) 0, "Null pointer parameter"); / * Næste linje stopper kompiler advarsler, da variabel i øjeblikket er ubrugt */ (tomrum) window_W1_data; switch (message-> message_id) {case MW_WINDOW_CREATED_MESSAGE: / * Tilføj enhver vindue-initialiseringskode her * / break; sag MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Tilføj vindue menuhåndteringskode her * / break; sag MW_BUTTON_PRESSED_MESSAGE: if (message-> sender_handle == button_B1_handle) { / * Tilføj din handlerkode for denne kontrol her * /} pause; standard: / * Hold MISRA glad * / pause; }}

Dette kaldes af vinduesmanageren for dette vindue, når vindueshåndteringen skal fortælle vinduet, at der er sket noget. I dette tilfælde er vi interesserede i at vide, at der kun er trykket på vinduets eneste knap. I switch -erklæringen for meddelelsestyper ser du en sag for MW_BUTTON_PRESSED_MESSAGE. Denne kode kører, når der er trykket på knappen. Der er kun en knap i dette vindue, men der kan være flere, så der kontrolleres hvilken knap det er. I dette tilfælde kan det kun være knap B1 (navn svarer til navnet på knappen i JSON -filen igen).

Så efter denne sagsetiket tilføj koden for at pop op en farvevælgerdialog, som er denne:

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

Parametrene er som følger:

• 10, 10 er placeringen på skærmen i dialogboksen
• "Farve" er dialogens titel
• MW_HAL_LCD_RED er standardfarven, dialogen starter med
• falske midler viser ikke stor størrelse (prøv at indstille den til sand og se forskellen)
• besked-> modtagerhåndtag er, hvem der ejer denne dialog, i dette tilfælde er det dette vindue. Et vindues håndtag er i funktionens meddelelsesparameter. Dette er vinduet, som dialogresponset sendes til.

For at finde ud af værdien af den farve, brugeren valgte, vil vindueshåndteringen sende et vindue til vores vindue med den valgte farve, når brugeren trykker på OK -knappen i dialogboksen. Derfor skal vi også opfange denne meddelelse med en anden sag i switch -erklæringen, der ser sådan ud:

sag MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE:

{mw_hal_lcd_colour_t valgt_farve = besked-> meddelelsesdata; (ugyldig) valgt_farve; } pause;

Vi gør ikke noget med den valgte farve endnu, så bare kast den ud for at forhindre en compiler -advarsel. Den endelige kode for denne funktion ser nu sådan ud:

ugyldig window_W1_message_function (const mw_message_t *meddelelse)

{MW_ASSERT (meddelelse! = (Void*) 0, "Null pointer parameter"); / * Næste linje stopper kompiler advarsler, da variabel i øjeblikket er ubrugt */ (tomrum) window_W1_data; switch (message-> message_id) {case MW_WINDOW_CREATED_MESSAGE: / * Tilføj enhver vindue-initialiseringskode her * / break; sag MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Tilføj vindue menuhåndteringskode her * / break; case MW_BUTTON_PRESSED_MESSAGE: if (message-> sender_handle == button_B1_handle) { / * Tilføj din handlerkode til denne kontrol her * / mw_create_window_dialog_colour_chooser (10, 10, "Color", MW_HAL_LCD_RED, false, message-> recipient_) } pause; sag MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE: {mw_hal_lcd_colour_t valgt_farve = besked-> besked_data; (ugyldig) valgt_farve; } pause; standard: / * Hold MISRA glad * / pause; }}

Kørsel af koden vises på billedet ovenfor. Du bemærker måske, at når en dialog vises, skal du svare på den og afvise den, før du gør noget andet. Dette kaldes modal adfærd. Dialoger i MiniWin og alle altid globalt modale, og du kan kun få en visning ad gangen. Der er mere forklaring her …

da.wikipedia.org/wiki/Modal_window

Trin 7: Tegning i vinduet

Indtil videre har vi kun brugt kontrolelementer, og de tegner sig selv. Det er tid til at lave en brugerdefineret tegning på vores vindue. Den del, du kan tegne på, er inden for grænserne (hvis de er nogen, er de valgfri), inde i rullefeltene (hvis defineret, også valgfri) og under titellinjen (hvis der er en, er det også valgfrit). Det kaldes klientområdet i vindueterminologi.

Der er et bibliotek med grafikkommandoer i MiniWin, som du kan bruge. De er alle vinduesbevidste. Det betyder, at du ikke behøver at bekymre dig om vinduet er synligt, delvis skjult af andre vinduer, tændt, delvis slukket eller helt ude af skærmen, eller hvis koordinaten for, hvor du tegner, er på klientområdet eller ud over det. Det hele er taget sig af for dig. Du kan ikke tegne uden for dit klientområde.

Tegning på klientområder i Windows -terminologi kaldes maleri, og hvert vindue har en malerfunktion, hvor du tegner. Du kalder ikke din malingfunktion, vindueshåndtereren gør det for dig, når det er nødvendigt. Det er nødvendigt, når et vindue flyttes, eller et andet vindue på toppen har ændret sin position eller synlighed. Hvis du har brug for dit vindue til at male igen, fordi nogle af de data, vinduets indhold er afhængig af, har ændret sig (dvs. du ved, at en omlakering er påkrævet i stedet for, at vindueshåndtereren ved det), fortæller du vindueshåndteringen, at der er behov for en omlakering, og den kalder din maling funktion. Du kalder det ikke selv. (Alt dette er demonstreret i det næste afsnit).

Først skal du finde din malingsfunktion. Kodegeneratoren opretter det til dig, og det er lige over meddelelsesbehandlingsfunktionen, der blev ændret i det foregående afsnit. Gå til dit projekt, og åbn filen W1.c igen.

I denne fil finder du funktionsvindue_W1_paint_function (). Det ser sådan ud:

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 parameter"); / * Fyld vinduets klientområde med solid hvid */ 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); / * Tilføj din vinduesmalekode her */}

Dette er den bare som-genererede kode, og alt det gør er at fylde klientområdet med fast hvidt. Lad os tegne en gul fyldt cirkel på klientområdet. Først skal vi forstå begrebet en grafisk kontekst (en anden Windows -ting). Vi indstiller tegneparametre i den grafiske kontekst og kalder derefter en generisk cirkeltegningsrutine. Ting, vi skal angive i dette eksempel, er, om cirklen har en kant, kantlinjestil, kantfarve, om cirklen er fyldt, fyldfarve og udfyldningsmønster. Du kan se koden ovenfor, der gør noget lignende for at fylde klientområdet med et kantløst, fyldt hvidt rektangel. Værdierne i den grafiske kontekst huskes ikke mellem hvert opkald i malingsfunktionen, så du skal konfigurere værdierne hver gang (de huskes dog med malingsfunktionen).

I koden ovenfor kan du se, at udfyldning er slået til, og udfyldningsmønster er deaktiveret, så vi behøver ikke at indstille dem igen. Vi skal indstille grænsen til, kantlinjestilen til solid, kantens forgrundsfarve til sort og udfylde farven til gul sådan:

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

Tilføj denne kode ved kommentaren i denne funktion, hvor der står at tilføje din kode. Dernæst skal vi tegne en cirkel, der gøres sådan:

mw_gl_circle (draw_info, 30, 30, 15);

Dette tegner en cirkel ved koordinaterne 30, 30 med radius 15. Genopbyg koden, og kør den igen, og du vil se en cirkel i vinduet som vist ovenfor. Du vil bemærke, at cirklen og knappen overlapper hinanden, men knappen er øverst. Dette er designet. Kontrol er altid oven på alt, hvad du tegner på klientområdet.

Trin 8: Vinduesdata

Hidtil har vi implementeret vores egen kode i vindue 1's meddelelsesfunktion (til håndtering af indgående meddelelser) og dens malingsfunktion (for at trække på vinduets klientområde). Nu er det tid til at forbinde de to. Lad os udfylde cirklen, der er tegnet i malingsfunktionen, med den farve, brugeren vælger af farvevælgeren, når der blev trykket på knappen. Husk, at vi ikke kalder malefunktionen, vindueshåndteringen gør det, så vores meddelelsesfunktion (som kender den valgte farve) kan ikke kalde malefunktionen direkte selv. I stedet skal vi cache dataene og lade vinduesmanageren vide, at en omlakering er påkrævet. Vinduesmanageren kalder derefter paint -funktionen, som kan bruge de cachelagrede data.

Øverst på W1.c vil du se en tom datastruktur og et objekt af denne type erklæret af kodegeneratoren sådan:

typedef struct

{ / * Tilføj dine datamedlemmer her * / char dummy; /* Nogle kompilatorer klager over tomme strukturer; fjern dette, når du tilføjer dine medlemmer */} window_W1_data_t; statisk window_W1_data_t window_W1_data;

Det er her, vi cacher vores data, så de bevares på tværs af opkald og er kendt som vinduesdata. Vi behøver kun at gemme den valgte farve her, sådan her:

typedef struct

{ / * Tilføj dine datamedlemmer her * / mw_hal_lcd_colour_t valgt_farve; } vindue_W1_data_t; statisk window_W1_data_t window_W1_data = {MW_HAL_LCD_YELLOW};

Vi giver den en startfarve på gul. Nu i meddelelsesfunktionen ændrer vi koden lidt for at gemme den valgte farve her sådan:

sag MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE:

{window_W1_data.chosen_colour = message-> message_data; } pause;

Derefter ændrer vi malingsfunktionen til at bruge denne værdi, når den tegner cirklen sådan:

mw_gl_set_solid_fill_colour (vindue_W1_data.valgt_farve);

Nu har vi ændret de data, som vinduets indhold afhænger af, så vi skal lade vindueshåndtereren vide, at vinduet skal males om. Vi gør det i meddelelsesfunktionen, når OK -meddelelsen i dialogboksen modtages, sådan her:

mw_paint_window_client (besked-> modtager_håndtag);

Dette bevirker ikke, at vinduet males direkte. Det er en hjælpefunktion, der sender en besked til vindueshåndteringen om, at et vindue skal males om (hvis du træder ind i det, kan du se, hvordan dette sker). Vinduet, der skal males i dette tilfælde, er sig selv, og håndtaget til vinduet er i meddelelsesparameteren til meddelelsesbehandlingsfunktionen.

Hele filen ser nu sådan ud, hvis du er usikker på, hvor nogle af kodestykkerne ovenfor går:

#omfatte

#include "miniwin.h" #include "miniwin_user.h" #include "W1.h" typedef struct { / * Tilføj dine datamedlemmer her * / mw_hal_lcd_colour_t valgt_farve; } vindue_W1_data_t; statisk 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 parameter"); / * Fyld vinduets klientområde med solid hvid */ 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); / * Tilføj dig vinduesmalingskode her */ mw_gl_set_fg_colour (MW_HAL_LCD_BLACK); mw_gl_set_solid_fill_colour (vindue_W1_data.valgt_farve); 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 *meddelelse) {MW_ASSERT (meddelelse! = (void *) 0, "Null pointer parameter"); / * Næste linje stopper kompiler advarsler, da variabel i øjeblikket er ubrugt */ (tomrum) window_W1_data; switch (message-> message_id) {case MW_WINDOW_CREATED_MESSAGE: / * Tilføj enhver vindue-initialiseringskode her * / break; sag MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Tilføj vindue menuhåndteringskode her * / break; case MW_BUTTON_PRESSED_MESSAGE: if (message-> sender_handle == button_B1_handle) { / * Tilføj din handlerkode til denne kontrol her * / mw_create_window_dialog_colour_chooser (10, 10, "Color", MW_HAL_LCD_RED, false, message-> recipient_) } pause; sag MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE: {window_W1_data.chosen_colour = message-> message_data; mw_paint_window_client (besked-> modtager_håndtag); } pause; standard: / * Hold MISRA glad * / pause; }}

Byg og kør igen, og du bør være i stand til at indstille cirkelens fyldfarve.

Dette eksempel på vinduesdata bruger data, der er gemt i en statisk datastruktur øverst i kildefilen. Dette er fint, hvis du kun har en forekomst af vinduet, som vi gør i dette eksempel, men hvis du har mere end én forekomst, vil de alle dele den samme datastruktur. Det er muligt at have data pr. Forekomst, så flere forekomster af samme vindustype har deres egne data. Dette forklares i MiniWin -dokumentationen, der findes i dokumentmappen. Fileksemplet bruger det til at vise flere billeder i den samme vindustype (som det ses i hovedbilledet øverst i denne instruks).

Trin 9: Nogle Final Font Fun

MiniWin understøtter TrueType skrifttypegengivelse. Hvis der er en ting, der får din brugergrænseflade til at se godt ud, er det attraktive skrifttyper. Dette sidste trin viser, hvordan man gengiver en TrueType -skrifttype i et MiniWin -vindue.

Der er to måder at gengive TrueType -skrifttyper på. Den ene er at tegne dem direkte på dit klientområde, som det blev gjort for cirklen tidligere, den anden er at tilføje en tekstboksstyring til dit vindue. Vi gør det sidste, da det er lettere.

Nu tilføjer vi en tekstboksstyring til vores JSON -konfigurationsfil. Føj det til Window 2's definition, så det ser sådan ud:

sådan her:

{

"Navn": "W2", "Titel": "Vindue 2", "X": 50, "Y": 65, "Bredde": 100, "Højde": 80, "Border": true, "TitleBar": true, "Visible": true, "Minimized": false, "TextBoxes": [{"Name": "TB1", "X": 0, "Y": 0, "Width": 115, "Height": 50, "Begrundelse": "Center", "BackgroundColour": "MW_HAL_LCD_YELLOW", "ForegroundColour": "MW_HAL_LCD_BLACK", "Font": "mf_rlefont_BLKCHCRY16", "Enabled": true, "Visible": true}]}}

Et hurtigt ord om TrueType -skrifttyper i MiniWin. Skrifttyper findes i.ttf -filer. I vinduesadministratorer på større computere gengives disse på din skærm, når de er nødvendige. Dette kræver masser af processorkraft og hukommelse og er ikke egnet til små enheder. I MiniWin forarbejdes de til bitmaps og forbindes på kompileringstidspunktet med en fast skriftstørrelse og stil (fed, kursiv osv.), Dvs. du skal beslutte, hvilke skrifttyper i hvilken størrelse og stil du vil bruge på kompileringstidspunktet. Dette er blevet gjort for dig for to eksempler på skrifttyper i MiniWin zip -filen, du downloadede. Hvis du vil bruge andre skrifttyper i andre størrelser og stilarter, skal du se MiniWin -dokumentationen i dokumentmappen. Der er værktøjer i MiniWin til Windows og Linux til forbehandling af.ttf-filer til kildekodefiler, som du kan slippe ind i dit projekt.

Og et andet hurtigt ord - de fleste skrifttyper er ophavsretlige, herunder dem, du finder i Microsoft Windows. Brug dem efter eget ønske til personlig brug, men alt hvad du udgiver, skal du sikre, at licensen, skrifttyperne udgives med, tillader det, som det er tilfældet for de 2 skrifttyper, der er inkluderet i MiniWin, men ikke Microsofts skrifttyper!

Tilbage til koden! Generer, slip filer, byg og genopfør som før, og du vil se, at Vindue 2 nu har nogle standardtekster på en gul baggrund i en skør skrifttype. Lad os ændre teksten ved at redigere Window 2's kildefil W2.c.

Vi skal kommunikere med den tekstboks, vi lige har oprettet, og måden du gør det på, ligesom enhver kommunikation i MiniWin er at sende den en besked. Vi vil indstille teksten i kontrolelementet, når vinduet oprettes, men før det vises, så vi tilføjer kode i meddelelsesbehandleren i MW_WINDOW_CREATED_MESSAGE -sagen. Dette modtages af vindueskoden lige før vinduet vises og er beregnet til initialiseringer som denne. Kodegeneratoren oprettede en pladsholder, der ser sådan ud i meddelelseshåndteringsfunktionen:

sag MW_WINDOW_CREATED_MESSAGE:

/ * Tilføj enhver vindue -initialiseringskode her */ break;

Her skal vi sende en besked til tekstbokskontrollen, der fortæller den, hvilken tekst vi vil have den til at vise ved hjælp af mw_post_message -funktionen sådan:

sag MW_WINDOW_CREATED_MESSAGE:

/ * Tilføj enhver vindue-initialiseringskode her */ mw_post_message (MW_TEXT_BOX_SET_TEXT_MESSAGE, meddelelse-> modtager_håndtag, text_box_TB1_handle, 0UL, "Det var en mørk og stormfuld nat …", MW_CONTROL_MESSAGE); pause;

Disse er parametrene:

• MW_TEXT_BOX_SET_TEXT_MESSAGE - Dette er den meddelelsestype, vi sender til kontrolenheden. De er angivet i miniwin.h og dokumenteret i dokumentationen.
• message-> recipient_handle - Det er hvem meddelelsen er fra - dette vindue - hvis håndtag er i meddelelsesparameteren videregivet til meddelelsesbehandlingsfunktionen.
• text_box_TB1_handle - Hvem vi sender beskeden til - håndtaget på tekstbokskontrollen. Disse er angivet i den genererede fil miniwin_user.h.
• 0UL - Dataværdi, intet i dette tilfælde.
• "Var en mørk og stormfuld nat …" - Markørværdi - den nye tekst.
• MW_CONTROL_MESSAGE - Modtager type, som er en kontrol.

Det er det. Genopbyg og genstart som normalt, og du får tekstboksen vist som på billedet ovenfor.

Beskedudstationering er grundlæggende for MiniWin (som det er for alle vinduesadministratorer). For flere eksempler, se eksempler på projekter i zip -filen og for en omfattende forklaring, læs afsnittet om MiniWin -meddelelser i dokumentationen.

Trin 10: Gå videre

Det er det for denne grundlæggende introduktion til MiniWin. MiniWin kan meget mere, end det er vist her. For eksempel er skærmen på tavlen, der bruges i denne instruks, lille, og betjeningselementerne er små og skal bruges med en dibber. Andre eksempler og hardware bruger imidlertid større betjeningselementer (der er 2 størrelser) på større skærme, og disse kan betjenes med fingre.

Der er mange andre former for kontrol end dem, der er vist her. For yderligere kontrol kan du se på de forskellige eksempler på JSON -filer i kodegeneratormappen. Alle kontroltyper er dækket af disse eksempler.

Windows har mange muligheder. Grænsen, titellinjen og ikoner kan alle konfigureres. Du kan have rullepaneler og rullende vinduesklientområder, flere forekomster af samme vindustype og vinduer kan være nøgne (kun et klientområde, ingen kant eller titellinje), hvilket betyder, at de er rettet på kompileringstidspunktet på displayet (se billedet i dette afsnit med store ikoner - det er faktisk 6 nøgne vinduer).

MiniWin bruger ingen dynamisk hukommelse. Dette gør den velegnet til små begrænsede enheder og er et krav for nogle integrerede projekter. MiniWin og den kode, den genererer, er også fuldt ud MISRA 2012 -kompatible til det 'krævede' niveau.

For yderligere information, se i dokumentmappen for dokumentationen og også de andre eksempler på apps i zip -filen. Der er eksempler her, der viser, hvordan man bruger alle funktionerne i MiniWin, og hvordan man integrerer MiniWin med FatFS og FreeRTOS.