Innebygd vindusbehandling: 10 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:21

Dette prosjektet viser hvordan du implementerer en vindusbehandling med bevegelige overlappende vinduer på en innebygd mikrokontroller med LCD-panel og berøringsskjerm. Det er kommersielt tilgjengelige programvarepakker for å gjøre dette, men de koster penger og er lukket kilde. Denne, kalt MiniWin, er gratis og åpen kildekode. Den er skrevet i fullstendig C99 og kan brukes i en C eller C ++ applikasjon. Målene med MiniWin er å være enkle å bruke, enkle å endre, utvidbare, bærbare til et bredt spekter av maskinvare og ikke for ressurssultne.

I tillegg til å gi koden for å administrere Windows har MiniWin en samling brukerkontroller - knapper, glidebrytere, fremdriftslinjer, trær etc. Du kan ha flere vinduer av forskjellige typer eller flere forekomster av samme type. Windows kan flyttes rundt, endres størrelse, maksimeres, minimeres, lukkes - alt det vanlige du gjør med vinduer i større vindusbehandlere. TrueType-fonter med kerning og anti-aliasing (får tekst til å se smooooooth ut) støttes også for attraktiv tekstgengivelse.

I hvert vindu har du et klientområde (plassen din innenfor grensen og under den øverste linjen). På dette kan du legge til kontroller for å lage en dialog, eller du kan bruke det innebygde grafikkbiblioteket til å tegne det du vil. Alle grafikkbibliotekets funksjoner er klar over vinduet. Du trenger ikke å bekymre deg for hvor vinduet ditt er, hva som overlapper det eller om det er minimert.

I tillegg til å lage dine egne vinduer er det også noen standarddialoger inkludert som er veldig enkle å instantiere - for eksempel bekreftelsesdialogbokser (bare en OK- eller Ja/Nei -knapp), tid/dato -innstillere, filvelgere, fargevalg etc.

MiniWin bruker et standard Windows Manager -designmeldingskøsystem. Windows kan samhandle med hverandre og vindusbehandleren via meldinger. Du kaller ikke funksjoner for å gjøre ting direkte, du legger til en melding i køen og vindusbehandleren vil vedta den for deg.

MiniWin er portet til standard utviklingstavler med berøringsskjerm fra mikrokontrollerleverandører ST, NXP og Renesas. Det er maskinvaredrivere og eksempelprosjekter for alle disse enhetene. I tillegg kan MiniWin bygges for Windows eller Linux, slik at du kan simulere brukergrensesnittkoden din før du får den innebygde maskinvaren.

MiniWin har en kodegenerator. Du kan spesifisere vinduene og kontrollene dine i en enkelt å opprette lesbar JSON -fil, og kodegeneratoren analyserer filen og oppretter koden for deg (det er mange eksempler å følge). Den lager komplette Windows- eller Linux -simulatorapplikasjoner som bare kan bygges, og det er din simulerte LCD -skjerm med MiniWin -vinduene dine. Du kan ta nøyaktig den samme genererte koden og slippe den inn i et innebygd prosjekt og ha den samme koden som viser de samme vinduene og kontrollene øyeblikk senere på den innebygde maskinvaren.

MiniWin krever ingen driftsstøtte på den innebygde enheten. Det hele går i en enkelt tråd. MiniWin kan integreres med en RTOS som kjører på en innebygd prosessor, og det er eksempler på integrering av MiniWin med FreeRTOS.

Denne instruksen viser hvordan du får MiniWin i gang på en STM32 M4 -prosessor ved å bruke det billige STM32F429 Discovery -kortet som har en QVGA -berøringsskjerm som allerede er festet. Disse er lett tilgjengelige fra leverandøren av elektronikkomponenter.

MiniWin kjører på mellomstore mikrokontroller og over.

Rekvisita

STM32F429I-DISC1 utviklingskort og en mikro-USB-kabel

STM32CubeIDE nedlasting som er gratis.

Trinn 1: Få koden

Først av alt må du installere STM32CubeIDE. Det får du fra STs nettsted. Du må registrere deg, og det tar en stund å laste ned og installere det. Alt er gratis.

Mens den installerer, last ned MiniWin -kilden og pakk den ut. Det er stort, men du vil bare bruke en liten del av det. Klikk på den grønne knappen "Klon eller nedlasting" her …

github.com/miniwinwm/miniwinwm

velg deretter Last ned zip. Pakk ut innholdet.

Trinn 2: Bygg et eksempelprosjekt

La oss først bygge et av eksempelprosjektene. En god heter MiniWinSimple. Start opp STM32CubeIDE og gjør dette:

1. Velg Fil | Importer …
2. Åpne Generelt og velg Eksisterende prosjekt til arbeidsområde. Neste.
3. Klikk på Bla gjennom og naviger til der du pakket ut MiniWin. Gå deretter til mappen STM32CubeIDE / MiniWinSimple / STM32F429. Klikk på Velg mappe.
4. I prosjekt: kryss av for MiniWinSimple_STM32F429 og klikk deretter Fullfør.
5. MiniWinSimple_STM32F429 -prosjektet vises i Project Explorer. Velg det, og bygg det deretter med Project | Build Project.
6. Koble nå USB -kabelen til kortet og datamaskinen og kjør den ved hjelp av Kjør | Debug, og når den er lastet ned, velg Kjør | Fortsett. Du får en skjermkalibreringsdisplay første gang, så berør midten av de tre kryssene på LCD -skjermen. Du kan nå samhandle med vinduet på displayet.

For å flytte et vindu, dra det ved tittellinjen. For å endre størrelsen på et vindu, bruk det hvite trekantikonet til venstre på tittellinjen. MiniWin -vinduer kan ikke endres ved å dra kantene ettersom skjermene MiniWin brukes på er for små. For å minimere, maksimere eller lukke et vindu, bruk ikonene i høyre ende av tittellinjen (lukk kan være deaktivert). Når et vindu er minimert, kan du ikke flytte de minimerte ikonene rundt. De bygger opp fra nedre venstre til høyre.

Trinn 3: Kjøre kodegeneratoren

Nå vil vi endre eksempelprosjektet ved å generere noen egne vinduer og slippe den nye koden. For å gjøre dette kjører vi kodegeneratoren.

1. Åpne en ledetekst og gå til mappen der du pakket ut MiniWin og deretter til Verktøy / CodeGen -mappen.
2. Den kjørbare filen for Windows CodeGen.exe er allerede tilgjengelig. For Linux må du bygge det ved å skrive make. (Du kan også bygge den fra kilde for Windows hvis du er bekymret for å kjøre en nedlastbar kjørbar fil, men du trenger installert kompilator og utviklingsmiljø. Se MiniWin -dokumentasjonen i dokumentmappen for detaljer).
3. I denne mappen er noen eksempler på JSON -filer. Vi bruker eksempel_empty.json. Du må redigere det først for å konfigurere det for Windows eller Linux. Åpne den i en editor, og øverst hvor du finner "TargetType", endre "Linux" eller "Windows" -verdien til det du kjører kodegeneratoren på.
4. Skriv nå codegen example_empty.json i ledeteksten.
5. Gå til prosjektet ditt i STM32CubeIDE og åpne mappen MiniWinSimple_Common. Slett alle filene der.
6. Vi forlot "TargetName" i JSON -filen som standard på "MiniWinGen", så det er navnet på mappen vår med generert kode. Gå til mappen der du pakket ut MiniWin og deretter MiniWinGen_Common -mappen. Velg nå alle disse filene, og dra og slipp dem deretter inn i STM32CubeIDE i prosjektets MiniWinSimple_Common -mappe.
7. Nå gjenoppbygg og kjør prosjektet på nytt i STM32CubeIDE, og det nye designvinduet ditt vises. Knappen i vinduet har gått fordi example_empty.json ikke definerer noen.

Trinn 4: Legge til et vindu

Vi legger nå til et nytt vindu i JSON -konfigurasjonsfilen og regenererer koden.

1. Åpne eksempel_empty.json i et tekstredigeringsprogram.

2. Under "Windows" -delen er det en rekke Windows -definisjoner som for øyeblikket bare har ett vindu. Kopier alt dette …

{

"Name": "W1", "Title": "Window 1", "X": 10, "Y": 15, "Width": 200, "Height": 180, "Border": true, "TitleBar": true, "Visible": true, "Minimized": false}

og lim den inn igjen med et komma som skiller de to definisjonene.

3. Endre "W1" til "W2" og "Vindu 1" til "Vindu 2". Endre "X", "Y", "Width" og "Height" til noen forskjellige verdier. Husk at skjermoppløsningen er 240 bred og 320 høy.

4. Lagre filen og kjør kodegeneratoren igjen.

5. Kopier filene som i forrige trinn, bygg om og kjør på nytt. Du vil nå ha to vinduer på skjermen.

Trinn 5: Legge til en kontroll

Nå legger vi til noen kontroller i det nye vinduet. Rediger den samme filen som i forrige trinn.

1. I spesifikasjonen for vindu W1 legg til et komma etter den siste innstillingen ("Minimert": usann) og legg deretter til denne teksten

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

Denne delen legger til en menylinje med 5 elementer og aktiverer den (menylinjer kan deaktiveres globalt, prøv det). Den legger også til en knapp som er aktivert og synlig (de kan opprettes usynlige og deretter gjøres synlige i koden senere).

2. Regenerer koden, kopier den på tvers, gjenoppbyg, kjør alt på nytt som før.

Trinn 6: Få kontrollene til å gjøre noe

Nå har vi det grunnleggende brukergrensesnittet vi trenger for å få det til å gjøre noe. For dette eksemplet vil vi vise en fargevelger -dialog når knappen i vindu 1 trykkes.

Gå til prosjektet ditt i STM32CubeIDE og åpne MiniWinSimple_Common -mappen og åpne deretter filen W1.c (navnet på denne filen tilsvarer vinduets "Navn" -felt i JSON -filen når koden ble generert).

I denne filen finner du funksjonsvindu_W1_meldingsfunksjon (). Det ser slik ut:

void window_W1_message_function (const mw_message_t *melding) {MW_ASSERT (melding! = (void *) 0, "Nullpeker parameter"); / * Neste linje stopper kompilatoradvarsler ettersom variabelen for øyeblikket er ubrukt */ (ugyldig) window_W1_data; switch (melding-> melding_id) {sak MW_WINDOW_CREATED_MESSAGE: / * Legg til hvilken som helst vinduets initialiseringskode her * / break; sak MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Legg til vindu menyhåndteringskode her * / break; sak MW_BUTTON_PRESSED_MESSAGE: if (melding-> sender_handle == button_B1_handle) { / * Legg til din behandlerkode for denne kontrollen her * /} pause; standard: / * Hold MISRA glad * / pause; }}

Dette kalles av vindusbehandleren for dette vinduet når vindusbehandleren trenger å la vinduet få vite at noe har skjedd. I dette tilfellet er vi interessert i å vite at vinduets eneste knapp har blitt trykket. I bytteerklæringen for meldingstyper ser du en sak for MW_BUTTON_PRESSED_MESSAGE. Denne koden kjøres når du har trykket på knappen. Det er bare en knapp i dette vinduet, men det kan være flere, så det sjekkes hvilken knapp det er. I dette tilfellet kan det bare være knapp B1 (navnet tilsvarer navnet på knappen i JSON -filen igjen).

Så etter denne etiketten, legg til koden for å dukke opp en fargevelger -dialog, 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 plasseringen på skjermen i dialogboksen
• "Farge" er tittel i dialogboksen
• MW_HAL_LCD_RED er standardfargen som dialogen starter med
• falske midler viser ikke stor størrelse (prøv å sette den til true og se forskjellen)
• melding-> mottakerhåndtak er hvem som eier denne dialogboksen, i dette tilfellet er det dette vinduet. Et vindus håndtak er i funksjonens meldingsparameter. Dette er vinduet dialogen vil bli sendt til.

For å finne ut verdien av fargen brukeren valgte, vil vindusbehandleren sende et vindu til vinduet med den valgte fargen når brukeren trykker på OK -knappen i dialogboksen. Derfor må vi fange opp denne meldingen også med en annen sak i switch -setningen som ser slik ut:

sak MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE:

{mw_hal_lcd_colour_t valgt_farge = melding-> melding_data; (ugyldig) valgt_farge; } gå i stykker;

Vi gjør ikke noe med den valgte fargen ennå, så bare kast den ut for å forhindre en kompilatorvarsel. Den endelige koden for denne funksjonen ser nå slik ut:

void window_W1_message_function (const mw_message_t *melding)

{MW_ASSERT (melding! = (Void*) 0, "Nullpeker -parameter"); / * Neste linje stopper kompilatoradvarsler ettersom variabelen for øyeblikket er ubrukt */ (ugyldig) window_W1_data; switch (melding-> melding_id) {sak MW_WINDOW_CREATED_MESSAGE: / * Legg til hvilken som helst vinduets initialiseringskode her * / break; sak MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Legg til kode for håndtering av vindu her * / break; case MW_BUTTON_PRESSED_MESSAGE: if (message-> sender_handle == button_B1_handle) { / * Legg til din behandlerkode for denne kontrollen her * / mw_create_window_dialog_colour_chooser (10, 10, "Color", MW_HAL_LCD_RED, false, message-> recipient_) } gå i stykker; sak MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE: {mw_hal_lcd_colour_t valgt_farge = melding-> melding_data; (ugyldig) valgt_farge; } gå i stykker; standard: / * Hold MISRA glad * / pause; }}

Kjøring av koden vises på bildet ovenfor. Du vil kanskje legge merke til at når en dialog vises, må du svare på den og avvise den før du gjør noe annet. Dette kalles modal oppførsel. Dialoger i MiniWin og alle alltid globalt modale, og du kan bare ha én visning om gangen. Det er mer forklaring her …

en.wikipedia.org/wiki/Modal_window

Trinn 7: Tegning i vinduet

Så langt har vi bare brukt kontroller, og de tegner seg selv. Det er på tide å lage en tilpasset tegning på vinduet vårt. Delen du kan tegne på er innenfor grensene (hvis de er noen, er de valgfrie), inne i rullefeltene (hvis de er definert, også valgfrie) og under tittellinjen (hvis det er en, er det også valgfritt). Det kalles klientområdet i vindueterminologi.

Det er et bibliotek med grafikkommandoer i MiniWin som du kan bruke. De er alle klar over vinduet. Det betyr at du ikke trenger å bekymre deg for om vinduet er synlig, delvis skjult av andre vinduer, på, delvis av eller helt av skjermen, eller hvis koordinaten for hvor du tegner er på klientområdet eller utenfor det. Alt er tatt vare på for deg. Du kan ikke tegne utenfor ditt klientområde.

Tegning på klientområder i Windows -terminologi kalles maleri, og hvert vindu har en malingsfunksjon der du tegner. Du kaller ikke malingsfunksjonen din, vindusbehandleren gjør det for deg når det trengs. Det er nødvendig når et vindu flyttes eller et annet vindu på toppen har endret posisjon eller sikt. Hvis du trenger å male vinduet på nytt fordi noen av dataene som vinduets innhold er avhengige av har endret seg (dvs. du vet at det er nødvendig med en ny maling i stedet for at vindusbehandleren vet det), forteller du vindusbehandleren at det er nødvendig med en ny maling, og det ringer malingsfunksjonen din. Du kaller det ikke selv. (Alt dette er demonstrert i neste avsnitt).

Først må du finne malingsfunksjonen din. Kodegeneratoren lager den for deg, og den er like over meldingshåndteringsfunksjonen som ble endret i forrige seksjon. Gå til prosjektet ditt og åpne filen W1.c igjen.

I denne filen finner du funksjonsvindu_W1_paint_function (). Det ser slik ut:

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 peker parameter"); / * Fyll vinduets klientområde med helt hvitt */ 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); / * Legg til vindusmalingskoden her */}

Dette er den bare som genererte koden, og alt den gjør er å fylle klientområdet med helt hvitt. La oss tegne en gul fylt sirkel på klientområdet. Først må vi forstå konseptet med en grafisk kontekst (en annen Windows -ting). Vi setter tegningsparametere i grafisk kontekst og kaller deretter en generisk sirkeltegningsrutine. Ting vi må angi i dette eksemplet er om sirkelen har en kantlinje, kantlinjestil, kantfarge, om sirkelen er fylt, fyllfarge og fyllmønster. Du kan se koden ovenfor som gjør noe lignende for å fylle klientområdet med et kantløst, fullt fylt hvitt rektangel. Verdiene i den grafiske konteksten huskes ikke mellom hver samtale i malingsfunksjonen, så du må sette opp verdiene hver gang (de huskes imidlertid med malingsfunksjonen).

I koden ovenfor kan du se at fyll er på og fyllmønster er av, så vi trenger ikke å sette dem på nytt. Vi må sette grensen på, kantlinjestilen til solid, kantgrunnsfargen til svart og fyllfargen til gul slik:

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

Legg til denne koden ved kommentaren i denne funksjonen der det står å legge til koden din. Deretter må vi tegne en sirkel som gjøres slik:

mw_gl_circle (draw_info, 30, 30, 15);

Dette tegner en sirkel ved koordinatene 30, 30 med radius 15. Ombyg koden og kjør den på nytt, og du vil se en sirkel i vinduet som vist ovenfor. Du vil legge merke til at sirkelen og knappen overlapper hverandre, men knappen er på toppen. Dette er etter design. Kontroller er alltid på toppen av alt du tegner på klientområdet.

Trinn 8: Vindusdata

Så langt har vi implementert vår egen kode i vindu 1s meldingsfunksjon (for å håndtere innkommende meldinger) og dens malingsfunksjon (for å tegne på vinduets klientområde). Nå er det på tide å koble de to. La oss fylle sirkelen som er tegnet i malingsfunksjonen med fargen brukeren velger av fargevelgeren når du trykker på knappen. Husk at vi ikke kaller malingsfunksjonen, vindusbehandleren gjør det, så vår meldingsfunksjon (som kjenner fargen som er valgt) kan ikke kalle malingsfunksjonen direkte selv. I stedet må vi cache dataene og la vindusbehandleren vite at det er nødvendig med en ny maling. Vindusbehandleren vil deretter ringe paint -funksjonen som kan bruke bufrede data.

På toppen av W1.c ser du en tom datastruktur og et objekt av denne typen som er deklarert av kodegeneratoren slik:

typedef struct

{ / * Legg til datamedlemmene dine her * / char dummy; /* Noen kompilatorer klager på tomme strukturer; fjern dette når du legger til dine medlemmer */} window_W1_data_t; statisk window_W1_data_t window_W1_data;

Det er her vi lagrer dataene våre slik at de blir bevart på tvers av samtaler og er kjent som vindusdata. Vi trenger bare å lagre den valgte fargen her, slik:

typedef struct

{ / * Legg til datamedlemmene dine her * / mw_hal_lcd_colour_t valgt_farge; } vindu_W1_data_t; statisk window_W1_data_t window_W1_data = {MW_HAL_LCD_YELLOW};

Vi gir den en startfarge på gul. Nå i meldingsfunksjonen endrer vi koden litt for å lagre den valgte fargen her slik:

sak MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE:

{window_W1_data.chosen_colour = melding-> melding_data; } gå i stykker;

Deretter endrer vi malingsfunksjonen for å bruke denne verdien når den tegner sirkelen slik:

mw_gl_set_solid_fill_colour (vindu_W1_data.valgt_farge);

Nå har vi endret dataene som vinduets innhold er avhengig av, så vi må la vindusbehandleren vite at vinduet må males om. Vi gjør det i meldingsfunksjonen når dialogboksen OK -melding mottas, slik:

mw_paint_window_client (melding-> mottaker_håndtak);

Dette medfører ikke at vinduet males direkte. Det er en verktøyfunksjon som sender en melding til vindusbehandleren om at et vindu må males om (hvis du går inn i det kan du se hvordan dette skjer). Vinduet som må males i dette tilfellet er seg selv, og håndtaket til vinduet er i meldingsparameteren til meldingshåndteringsfunksjonen.

Hele filen ser nå slik ut hvis du er usikker på hvor noen av kodebitene ovenfor går:

#inkludere

#include "miniwin.h" #include "miniwin_user.h" #include "W1.h" typedef struct { / * Legg til datamedlemmene dine her * / mw_hal_lcd_colour_t valgt_farge; } vindu_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 peker parameter"); / * Fyll vinduets klientområde med helt hvitt */ 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); / * Legg til vindusmalingskoden her */ mw_gl_set_fg_colour (MW_HAL_LCD_BLACK); mw_gl_set_solid_fill_colour (vindu_W1_data.valgt_farge); 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 *melding) {MW_ASSERT (melding! = (void *) 0, "Nullpeker parameter"); / * Neste linje stopper kompilatoradvarsler ettersom variabelen for øyeblikket er ubrukt */ (ugyldig) window_W1_data; switch (melding-> melding_id) {sak MW_WINDOW_CREATED_MESSAGE: / * Legg til hvilken som helst vinduets initialiseringskode her * / break; sak MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Legg til kode for håndtering av vindu her * / break; case MW_BUTTON_PRESSED_MESSAGE: if (message-> sender_handle == button_B1_handle) { / * Legg til din behandlerkode for denne kontrollen her * / mw_create_window_dialog_colour_chooser (10, 10, "Color", MW_HAL_LCD_RED, false, message-> recipient_) } gå i stykker; sak MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE: {window_W1_data.chosen_colour = melding-> melding_data; mw_paint_window_client (melding-> mottaker_håndtak); } gå i stykker; standard: / * Hold MISRA glad * / pause; }}

Bygg og kjør igjen, og du bør kunne angi fyllfargen til sirkelen.

Dette eksemplet på vindusdata bruker data som er lagret i en statisk datastruktur øverst i kildefilen. Dette er greit hvis du bare har en forekomst av vinduet, som vi gjør i dette eksemplet, men hvis du har mer enn én forekomst, vil de alle dele den samme datastrukturen. Det er mulig å ha data per forekomst, slik at flere forekomster av samme vindustype har egne data. Dette forklares i MiniWin -dokumentasjonen som finnes i dokumentmappen. Fileksemplet bruker den til å vise flere bilder i samme vindustype (som sett i hovedbildet helt øverst i denne instruksjonsboken).

Trinn 9: Noen Final Font Fun

MiniWin støtter TrueType -gjengivelse. Hvis det er en ting som får brukergrensesnittet til å se bra ut, er det attraktive fonter. Dette siste trinnet viser hvordan du gjengir en TrueType -skrift i et MiniWin -vindu.

Det er to måter å gjengi TrueType -fonter på. Den ene er å tegne dem direkte på klientområdet ditt som det ble gjort for sirkelen tidligere, den andre er å legge til en tekstbokskontroll i vinduet ditt. Vi gjør det siste siden det er lettere.

Nå legger vi til en tekstbokskontroll i vår JSON -konfigurasjonsfil. Legg det inn i definisjonen av Window 2 slik at det ser slik ut:

som dette:

{

"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, "Justification": "Center", "BackgroundColour": "MW_HAL_LCD_YELLOW", "ForegroundColour": "MW_HAL_LCD_BLACK", "Font": "mf_rlefont_BLKCHCRY16", "Enabled": true, "Visible": true}]}}

Et raskt ord om TrueType -skrifter i MiniWin. Fontene kommer i.ttf -filer. I vindusbehandlere på større datamaskiner gjengis disse på skjermen når de trengs. Dette krever mye prosessorkraft og minne og er ikke egnet for små enheter. I MiniWin blir de forhåndsbehandlet til bitmaps og knyttet til kompileringstidspunktet med en fast skriftstørrelse og stil (fet skrift, kursiv osv.), Dvs. du må bestemme hvilke fonter med hvilken størrelse og stil du skal bruke på kompileringstidspunktet. Dette er gjort for deg for to eksempler på fonter i MiniWin zip -filen du lastet ned. Hvis du vil bruke andre fonter i andre størrelser og stiler, kan du se MiniWin -dokumentasjonen i dokumentmappen. Det er verktøy i MiniWin for Windows og Linux for forhåndsbehandling av.ttf-filer til kildekodefiler du kan slippe inn i prosjektet.

Og et andre raske ord - de fleste fonter er opphavsrett, inkludert de du finner i Microsoft Windows. Bruk dem etter eget ønske for personlig bruk, men alt du publiserer må du sørge for at lisensen skriftene publiseres med tillater det, slik det er tilfellet for de to skriftene som er inkludert i MiniWin, men ikke Microsofts fonter!

Tilbake til koden! Generer, slipp filer, bygg og kjør på nytt som før, og du vil se at Vindu 2 nå har noen standardtekster på en gul bakgrunn i en sprø skrift. Lar oss endre teksten ved å redigere vindu 2s kildefil W2.c.

Vi må kommunisere med tekstboksen vi nettopp har opprettet, og måten du gjør det på, som enhver kommunikasjon i MiniWin, er å sende den en melding. Vi ønsker å sette teksten i kontrollen når vinduet opprettes, men før det vises, så vi legger til kode i meldingsbehandleren i saken MW_WINDOW_CREATED_MESSAGE. Dette mottas av vinduskoden like før vinduet vises og er beregnet på initialiseringer som dette. Kodegeneratoren opprettet en plassholder som ser slik ut i meldingshåndteringsfunksjonen:

sak MW_WINDOW_CREATED_MESSAGE:

/ * Legg til hvilken som helst vinduets initialiseringskode her */ break;

Her skal vi legge ut en melding til tekstbokskontrollen som forteller hvilken tekst vi vil at den skal vise ved å bruke mw_post_message -funksjonen slik:

sak MW_WINDOW_CREATED_MESSAGE:

/ * Legg til hvilken som helst vinduets initialiseringskode her */ mw_post_message (MW_TEXT_BOX_SET_TEXT_MESSAGE, melding-> mottaker_håndtak, text_box_TB1_handle, 0UL, "Var en mørk og stormfull natt …", MW_CONTROL_MESSAGE); gå i stykker;

Dette er parametrene:

• MW_TEXT_BOX_SET_TEXT_MESSAGE - Dette er meldingstypen vi sender til kontrollen. De er oppført i miniwin.h og dokumentert i dokumentasjonen.
• melding-> mottaker_håndtak - Dette er hvem meldingen kommer fra - dette vinduet - håndtaket som er i meldingsparameteren sendt til meldingshåndteringsfunksjonen.
• text_box_TB1_handle - Hvem vi sender meldingen til - håndtaket på tekstbokskontrollen. Disse er oppført i den genererte filen miniwin_user.h.
• 0UL - Dataværdi, ingenting i dette tilfellet.
• "Var en mørk og stormfull natt …" - Pekerverdi - den nye teksten.
• MW_CONTROL_MESSAGE - Mottakertype som er en kontroll.

Det er det. Bygg om og kjør på nytt som vanlig, og du får tekstboksen som vist på bildet ovenfor.

Meldingsoppføring er grunnleggende for MiniWin (som det er for alle vindusbehandlere). For flere eksempler, se på eksempelprosjektene i zip -filen og for en omfattende forklaring, les avsnittet om MiniWin -meldinger i dokumentasjonen.

Trinn 10: Gå videre

Det er det for denne grunnleggende introduksjonen til MiniWin. MiniWin kan mye mer enn det som er vist her. For eksempel er skjermen på tavlen som brukes i denne instruksjonsboken liten, og kontrollene er små og må brukes med en dibber. Andre eksempler og maskinvare bruker imidlertid større kontroller (det er 2 størrelser) på større skjermer, og disse kan betjenes med fingrene.

Det er mange andre typer kontroll enn de som er vist her. For ytterligere kontroller, ta en titt på de forskjellige JSON -filene i kodegeneratormappen. Alle kontrolltyper er dekket i disse eksemplene.

Windows har mange alternativer. Grensen, tittellinjen og ikonene er alle konfigurerbare. Du kan ha rullefelt og rullevinduklientområder, flere forekomster av samme vindustype og vinduer kan være nakne (bare et klientområde, ingen kantlinje eller tittellinje), noe som betyr at de blir løst på kompileringstidspunktet på skjermen (se bildet i denne delen med store ikoner - dette er faktisk 6 nakne vinduer).

MiniWin bruker ikke noe dynamisk minne. Dette gjør den egnet for små begrensede enheter og er et krav for noen innebygde prosjekter. MiniWin og koden den genererer er også fullt MISRA 2012 -kompatible til det "nødvendige" nivået.

For mer informasjon, ta en titt i dokumentmappen for dokumentasjonen og også de andre eksempelappene i zip -filen. Det er eksempler her som viser hvordan du bruker alle funksjonene i MiniWin og hvordan du integrerer MiniWin med FatFS og FreeRTOS.