Ներկառուցված պատուհանի կառավարիչ `10 քայլ

2024 Հեղինակ: John Day | [email protected]. Վերջին փոփոխված: 2024-01-30 09:45

Այս նախագիծը ցույց է տալիս, թե ինչպես կարելի է իրականացնել շարժական համընկնող պատուհաններով պատուհանների կառավարիչ `ներկառուցված միկրոկառավարիչի վրա` LCD վահանակով և սենսորային էկրանով: Կան կոմերցիոնորեն հասանելի ծրագրային փաթեթներ դա անելու համար, բայց դրանք գումար են պահանջում և փակ աղբյուր են: Այս մեկը, որը կոչվում է MiniWin, անվճար է և բաց կոդով: Այն գրված է լիովին համապատասխան C99- ով և կարող է օգտագործվել C կամ C ++ ծրագրում: MiniWin- ի նպատակներն են լինել օգտագործման համար դյուրին, փոփոխելի, ընդարձակվող, շարժական սարքավորումների լայն տեսականիով և ոչ շատ ռեսուրսների կարիք ունեցող:

Ինչպես նաև ձեր պատուհանները կառավարելու համար ծածկագիր տրամադրելը, MiniWin- ն ունի օգտվողի միջերեսի կառավարման կոճակներ `կոճակներ, սահիչներ, առաջընթացի ձողեր, ծառեր և այլն: Դուք կարող եք ունենալ տարբեր տեսակի բազմաթիվ պատուհաններ կամ նույն տիպի բազմաթիվ օրինակներ: Windows- ը կարող է տեղաշարժվել, չափափոխվել, առավելագույնի հասցնել, նվազագույնի հասցնել, փակվել `այն բոլոր սովորական գործերը, որոնք դուք անում եք պատուհանների հետ ավելի մեծ պատուհանների կառավարիչներում: TrueType տառատեսակները ՝ միջուկային և հակաալիզացիոն (տեքստը հարթ տեսք է հաղորդում) նույնպես ապահովված են տեքստի գրավիչ մատուցման համար:

Յուրաքանչյուր պատուհանում դուք ունեք հաճախորդի տարածք (ձեր տարածքը սահմանի ներսում և վերին գծից ներքև): Դրա վրա կարող եք երկխոսություն կազմելու համար ավելացնել կառավարման տարրեր կամ ներկառուցված գրաֆիկական գրադարանից նկարել այն, ինչ ցանկանում եք: Գրաֆիկական գրադարանի բոլոր գործառույթները տեղյակ են պատուհանից: Պետք չէ անհանգստանալ, թե որտեղ է ձեր պատուհանը, ինչն է այն համընկնում կամ այն նվազագույնի հասցվում է:

Բացի ձեր սեփական պատուհանների պատրաստումից, կան նաև մի քանի ստանդարտ երկխոսություններ, որոնք շատ հեշտ է ձևակերպել, օրինակ `հաստատման երկխոսություններ (պարզապես OK կամ Yes/No կոճակներ), ժամանակի/ամսաթվի կարգավորիչներ, ֆայլերի ընտրիչներ, գույնի ընտրիչներ և այլն:

MiniWin- ն օգտագործում է պատուհանների կառավարչի նախագծման հաղորդագրությունների հերթի ստանդարտ համակարգ: Windows- ը կարող է փոխազդել միմյանց և պատուհանների մենեջերի հետ հաղորդագրությունների միջոցով: Դուք գործառույթներ չեք կանչում ուղղակիորեն գործեր անելու համար, հաղորդագրություն եք ավելացնում հերթում, և պատուհանների կառավարիչը դա կիրականացնի ձեզ համար:

MiniWin- ը տեղափոխվել է ստանդարտ զարգացման տախտակներ `սենսորային էկրանով ցուցադրվող ST, NXP և Renesas մատակարարներից: Այս բոլոր սարքերի համար կան ապարատային վարորդներ և օրինակելի նախագծեր: Բացի այդ, MiniWin- ը կարող է կառուցվել Windows- ի կամ Linux- ի համար, որպեսզի կարողանաք մոդելավորել ձեր ինտերֆեյսի ծածկագիրը `նախքան ձեր ներդրված ապարատը ձեռք բերելը:

MiniWin- ն ունի կոդի գեներատոր: Դուք կարող եք պարզել ձեր պատուհաններն ու կառավարման տարրերը ՝ պարզ ընթերցվող JSON ֆայլ ստեղծելու համար, իսկ կոդերի գեներատորը վերլուծում է ֆայլը և ստեղծում ձեզ համար կոդը (հետևելու բազմաթիվ օրինակներ կան): Այն ստեղծում է Windows կամ Linux ամբողջական սիմուլյատոր ծրագրեր, որոնք կարող են պարզապես կառուցվել, և այնտեղ է ձեր մոդելավորված LCD էկրանը ՝ ձեր MiniWin պատուհաններով աշխատող: Կարող եք վերցնել ճիշտ նույն գեներացված ծածկագիրը և գցել այն ներդրված նախագծի մեջ և ունենալ նույն ծածկագիրը, որը մի քանի րոպե հետո ցուցադրում է նույն պատուհանները և վերահսկիչները ձեր ներդրված սարքավորման վրա:

Ներկառուցված սարքում MiniWin- ը չի պահանջում գործառնական աջակցություն: Ամեն ինչ անցնում է մեկ թելի մեջ: MiniWin- ը կարող է ինտեգրվել ներկառուցված պրոցեսորով աշխատող RTOS- ի հետ և կան օրինակներ, որոնք MiniWin- ը ինտեգրում են FreeRTOS- ին:

Այս հրահանգը ցույց է տալիս, թե ինչպես կարելի է գործարկել MiniWin- ը STM32 M4 պրոցեսորով ՝ օգտագործելով էժան STM32F429 Discovery տախտակը, որն արդեն իսկ կցված է QVGA սենսորային էկրանով: Դրանք հեշտությամբ հասանելի են ձեր էլեկտրոնիկայի բաղադրիչների մատակարարից:

MiniWin- ն աշխատում է միջին և ավելի բարձր կարգի միկրոհսկիչների վրա:

Պարագաներ

STM32F429I-DISC1 զարգացման տախտակ և միկրո USB մալուխ

STM32CubeIDE ներբեռնում, որն անվճար է:

Քայլ 1: Ստանալ կոդը

Առաջին հերթին անհրաժեշտ է տեղադրել STM32CubeIDE: Դուք դա ստանում եք ST- ի կայքից: Դուք պետք է գրանցվեք, և այն ներբեռնելու և տեղադրելու համար որոշ ժամանակ է պահանջվում: Ամեն ինչ անվճար է:

Տեղադրման ընթացքում ներբեռնեք MiniWin աղբյուրը և բացեք այն: Այն մեծ է, բայց դուք կօգտագործեք դրա միայն մի փոքր մասը: Կտտացրեք կանաչ «Clone or Download» կոճակին այստեղ…

github.com/miniwinwm/miniwinwm

ապա ընտրեք Ներբեռնել Zip. Բացեք բովանդակությունը:

Քայլ 2. Նախագծի օրինակ կառուցելը

Նախ եկեք կառուցենք օրինակելի նախագծերից մեկը: Լավը կոչվում է MiniWinSimple: Գործարկեք STM32CubeIDE- ը, ապա դա արեք.

1. Ընտրեք Ֆայլ | Ներմուծել…
2. Բացեք General- ը և ընտրեք Existing Project into Workspace: Հաջորդը
3. Կտտացրեք Փնտրել և նավարկել այնտեղ, որտեղից ազատել եք MiniWin- ը: Այնուհետև անցեք STM32CubeIDE / MiniWinSimple / STM32F429 թղթապանակ: Կտտացրեք Ընտրել թղթապանակը:
4. Նախագծում ՝ նշեք MiniWinSimple_STM32F429, այնուհետև կտտացրեք Ավարտել:
5. MiniWinSimple_STM32F429 նախագիծը կհայտնվի ձեր Project Explorer- ում: Ընտրեք այն, այն կառուցեք Project | Build Project- ի միջոցով:
6. Այժմ միացրեք ձեր USB մալուխը տախտակին և ձեր համակարգչին և գործարկեք այն `օգտագործելով Run | Debug, և երբ այն ներբեռնվի, ընտրեք Run | Resume: Դուք առաջին անգամ կստանաք էկրանի չափման էկրան, այնպես որ դիպչեք LCD էկրանին դրված 3 խաչերի կենտրոնին: Այժմ կարող եք փոխազդել ցուցադրման պատուհանի հետ:

Պատուհան տեղափոխելու համար քաշեք այն իր վերնագրի գծով: Պատուհանը չափափոխելու համար օգտագործեք սպիտակ եռանկյունի պատկերակը վերնագրի տողից ձախ: MiniWin պատուհանները հնարավոր չէ չափափոխել ՝ եզրերը քաշելով, քանի որ MiniWin- ի օգտագործման էկրանները չափազանց փոքր են: Պատուհանը նվազագույնի հասցնելու, առավելագույնի հասցնելու կամ փակելու համար օգտագործեք վերնագրի տողի աջ ծայրում գտնվող պատկերակները (փակումը կարող է անջատված լինել): Երբ պատուհանը նվազագույնի է հասցվում, դուք չեք կարող նվազեցված պատկերակները տեղաշարժել: Նրանք կառուցվում են ներքևից ձախից աջ:

Քայլ 3: Գործարկեք կոդերի գեներատորը

Այժմ մենք կփոխենք նախագծի օրինակը ՝ ստեղծելով մեր սեփական պատուհանները և թողնելով նոր ծածկագիրը: Դա անելու համար մենք գործարկելու ենք կոդի գեներատորը:

1. Բացեք հրամանի տողը և գնացեք այն թղթապանակը, որտեղից բացել եք MiniWin- ը, այնուհետև Tools / CodeGen պանակը:
2. Windows CodeGen.exe- ի կատարելիքն արդեն հասանելի է: Linux- ի համար պետք է այն կառուցել ՝ մուտքագրելով make: (Կարող եք նաև այն կառուցել Windows- ի աղբյուրից, եթե մտահոգված եք ներբեռնված գործարկվող ծրագրի գործարկմամբ, բայց ձեզ հարկավոր է տեղադրել կոմպիլյատորը և զարգացման միջավայրը: Մանրամասների համար տե՛ս փաստաթղթերի թղթապանակի MiniWin փաստաթղթերը):
3. Այս թղթապանակում կան JSON ֆայլերի օրինակներ: Մենք կօգտագործենք example_empty.json- ը: Windows- ի կամ Linux- ի համար այն նախ պետք է խմբագրեք: Բացեք այն խմբագրիչում և վերևում, որտեղ դուք կգտնեք, որ «TargetType» - ը փոխի «Linux» - ի կամ «Windows» - ի արժեքը այն, ինչով աշխատում եք կոդի գեներատորով:
4. Այժմ հրամանի տողում մուտքագրեք codegen example_empty.json:
5. Գնացեք ձեր նախագիծը STM32CubeIDE- ում և բացեք MiniWinSimple_Common թղթապանակը: Deնջել այնտեղ գտնվող բոլոր ֆայլերը:
6. Մենք թողել ենք «TargetName» - ը JSON ֆայլում որպես կանխադրված «MiniWinGen» - ում, այնպես որ դա գեներացված կոդի մեր թղթապանակի անունն է: Գնացեք այն թղթապանակը, որտեղից բացել եք MiniWin, այնուհետև MiniWinGen_Common պանակը: Այժմ ընտրեք այս բոլոր ֆայլերը և քաշեք և թողեք այնուհետև STM32CubeIDE ՝ ձեր նախագծի MiniWinSimple_Common պանակում:
7. Այժմ վերակառուցեք և վերագործարկեք նախագիծը STM32CubeIDE- ում և կհայտնվի ձեր նոր դիզայնի պատուհանը: Պատուհանի կոճակը հեռացել է, քանի որ example_empty.json- ը որևէ մեկը չի սահմանում:

Քայլ 4: Պատուհանի ավելացում

Այժմ մենք երկրորդ պատուհան կավելացնենք JSON կազմաձևման ֆայլին և կվերածնենք ծածկագիրը:

1. Բացեք example_empty.json տեքստային խմբագրիչում:

2. «Windows» բաժնի տակ կա պատուհանների սահմանումների զանգված, որը ներկայումս ունի միայն մեկ պատուհան: Պատճենեք այս ամենը…

{

«Անուն» ՝ «W1», «Վերնագիր» ՝ «Պատուհան 1», «X» ՝ 10, «Y» ՝ 15, «Լայնություն» ՝ 200, «Բարձրություն» ՝ 180, «Սահման» ՝ ճշմարիտ, «TitleBar»: ճշմարիտ, «տեսանելի» ՝ ճշմարիտ, «նվազագույնի հասցված» ՝ կեղծ}

և նորից տեղադրեք այն երկու սահմանումներն առանձնացնող ստորակետով:

3. Փոխեք «W1» - ը «W2» և «Window 1» - ը ՝ «Window 2»: Փոխեք «X», «Y», «Լայնություն» և «Բարձրություն» տարբեր արժեքների ՝ հաշվի առնելով, որ էկրանի լուծաչափը 240 լայնություն է 320 բարձրության վրա:

4. Պահեք ֆայլը և նորից գործարկեք կոդի գեներատորը:

5. Պատճենեք ֆայլերը, ինչպես նախորդ քայլին, վերակառուցեք և կրկնեք: Այժմ ձեր էկրանին կունենաք 2 պատուհան:

Քայլ 5: Կառավարման ավելացում

Այժմ մենք ձեր նոր պատուհանում մի քանի հսկողություն կավելացնենք: Խմբագրեք նույն ֆայլը, ինչպես նախորդ քայլին:

1. W1 պատուհանի բնութագրում վերջին պարամետրից հետո ստորակետ ավելացրեք («Minimized»: false), ապա ավելացրեք այս տեքստը

«MenuBar». Ճշմարիտ, "MenuBarEnabled". Ճշմարիտ, "MenuItems": ["Fred", "Bert", "Pete", "Alf", "Ian"], "Buttons": [{"Name": "B1", "Label": "Button1", "X": 10, "Y": 10, "Enabled": true, "Visible": true}]

Այս բաժինը ավելացնում է ընտրացանկի տող ՝ 5 տարրով և միացնում այն (ցանկի տողերը կարող են գլոբալ անջատված լինել, փորձեք այն): Այն նաև ավելացնում է մի կոճակ, որը միացված և տեսանելի է (դրանք կարող են ստեղծվել անտեսանելի, այնուհետև տեսանելի դառնալ ծածկագրում):

2. Վերականգնել ծածկագիրը, պատճենել այն, վերակառուցել, կրկնել ամեն ինչ, ինչպես նախկինում:

Քայլ 6. Ստիպելով վերահսկիչներին ինչ -որ բան անել

Այժմ մենք ունենք հիմնական ինտերֆեյսը, որն անհրաժեշտ է նրան ինչ -որ բան անելու համար: Այս օրինակի համար մենք կհայտնվենք գույնի ընտրության երկխոսություն, երբ սեղմվի 1 -ին պատուհանում գտնվող կոճակը:

Գնացեք ձեր նախագիծը STM32CubeIDE- ում և բացեք MiniWinSimple_Common թղթապանակը, այնուհետև բացեք ֆայլը W1.c (այս ֆայլի անունը համապատասխանում է պատուհանի «Անուն» դաշտին JSON ֆայլում, երբ ծածկագիրը ստեղծվել է):

Այս ֆայլում դուք կգտնեք գործառույթ window_W1_message_function (): Կարծես այսպիսին է.

void window_W1_message_function (const mw_message_t *message) {MW_ASSERT (message! = (void *) 0, "Null ցուցիչի պարամետր"); / * Հաջորդ տողը դադարեցնում է կազմողի նախազգուշացումները, քանի որ փոփոխականն այս պահին չօգտագործված է */ (void) window_W1_data; switch (message-> message_id) {case MW_WINDOW_CREATED_MESSAGE: / * Ավելացնել ցանկացած պատուհանի սկզբնավորման կոդ այստեղ * / ընդմիջում; գործ MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Ավելացնել պատուհանի ընտրացանկի գործածման կոդ այստեղ * / ընդմիջում; դեպքում MW_BUTTON_PRESSED_MESSAGE. կանխադրված ՝ / * MISRA- ին երջանիկ պահեք * / ընդմիջում; }}

Այս պատուհանի համար սա կոչվում է պատուհանների կառավարիչ, երբ պատուհանի կառավարիչը պետք է պատուհանը տեղյակ պահի, որ ինչ -որ բան տեղի է ունեցել: Այս դեպքում մեզ հետաքրքրում է իմանալ, որ պատուհանի միակ կոճակը սեղմված է: Հաղորդագրությունների տեսակների անջատիչ հայտարարության մեջ դուք կտեսնեք MW_BUTTON_PRESSED_MESSAGE գործ: Այս կոդը գործում է կոճակը սեղմելուց հետո: Այս պատուհանում կա միայն մեկ կոճակ, բայց կարող է լինել ավելի շատ, այնպես որ ստուգվում է, թե որ կոճակն է դա: Այս դեպքում այն կարող է լինել միայն B1 կոճակը (անունը կրկին համապատասխանում է JSON ֆայլի կոճակի անունին):

Այսպիսով, այս գործի պիտակից հետո ավելացրեք ծածկագիրը ՝ գույնի ընտրության երկխոսություն բացելու համար, որն է.

mw_create_window_dialog_colour_chooser (10, 10, «Գույն», MW_HAL_LCD_RED, կեղծ, հաղորդագրություն-> ստացողի_բռնակ);

Պարամետրերը հետևյալն են.

• 10, 10 -ը երկխոսության էկրանին գտնվելու վայրն է
• «Գույնը» երկխոսության վերնագիրն է
• MW_HAL_LCD_RED- ը կանխադրված գույնն է, որով երկխոսությունը կսկսվի
• կեղծ միջոցները մեծ չափեր ցույց չեն տալիս (փորձեք սահմանել այն ճշմարիտ և տեսեք տարբերությունը)
• հաղորդագրություն-> ստացողի բռնակն է, թե ում է պատկանում այս երկխոսությունը, այս դեպքում դա այս պատուհանն է: Ֆունկցիայի հաղորդագրության պարամետրում պատուհանի բռնակ է: Սա այն պատուհանն է, որին կուղարկվի երկխոսության պատասխանը:

Գույնի արժեքը պարզելու համար օգտագործողը ընտրել է պատուհանի կառավարիչը մեր պատուհանին հաղորդագրություն կուղարկի ընտրված գույնով, երբ օգտվողը երկխոսության մեջ կտտացնի OK կոճակը: Հետևաբար, մենք պետք է այս հաղորդագրությունը նույնպես ընդհատենք անջատիչի հայտարարության մեկ այլ դեպքով, որն ունի այս տեսքը.

գործ MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE:

{mw_hal_lcd_colour_t selected_colour = message-> message_data; (դատարկ) ընտրված_գույն; } ընդմիջում;

Մենք դեռ ոչինչ չենք անում ընտրված գույնի հետ, այնպես որ պարզապես այն անվավեր ենք դարձնում ՝ կազմող նախազգուշացումը կանխելու համար: Այս ֆունկցիայի վերջնական կոդը այժմ այսպիսին է.

void window_W1_message_function (const mw_message_t *message)

{MW_ASSERT (հաղորդագրություն! = (Անվավեր*) 0, «ցուցիչի անվավեր պարամետր»); / * Հաջորդ տողը դադարեցնում է կազմողի նախազգուշացումները, քանի որ փոփոխականն այս պահին չօգտագործված է */ (void) window_W1_data; switch (message-> message_id) {case MW_WINDOW_CREATED_MESSAGE: / * Ավելացնել ցանկացած պատուհանի սկզբնավորման կոդ այստեղ * / ընդմիջում; գործ MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Ավելացնել պատուհանի ընտրացանկի գործածման կոդ այստեղ * / ընդմիջում; դեպքում MW_BUTTON_PRESSED_MESSAGE: } ընդմիջում; գործ MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE: {mw_hal_lcd_colour_t selected_colour = message-> message_data; (դատարկ) ընտրված_գույն; } ընդմիջում; կանխադրված ՝ / * Երջանիկ պահեք MISRA- ն / ընդմիջում; }}

Կոդի գործարկումը ցուցադրվում է վերևի նկարում: Դուք կարող եք նկատել, որ երբ երկխոսությունը ցուցադրվում է, դուք պետք է արձագանքեք դրան և հեռացնեք այն, նախքան որևէ այլ բան անելը: Սա կոչվում է մոդալ վարք: Երկխոսություններ MiniWin- ում և բոլորը գլոբալ առումով մոդալ, և դուք կարող եք ունենալ միայն մեկ ցուցադրում միաժամանակ: Այստեղ ավելի շատ բացատրություն կա…

hy.wikipedia.org/wiki/Modal_window

Քայլ 7: Նկարչություն պատուհանում

Մինչ այժմ մենք օգտագործում էինք միայն վերահսկիչներ, և դրանք ինքնուրույն են գծում: It'sամանակն է ինչ -որ կերպ նկարել մեր պատուհանի վրա: Մասը, որի վրա կարող եք նկարել, գտնվում է սահմանների ներսում (եթե դրանք առկա են, դրանք պարտադիր չեն), ոլորման վահանակների ներսում (եթե սահմանված է, նաև ըստ ցանկության) և վերնագրի տողից ներքև (եթե կա մեկը, դա նույնպես պարտադիր չէ): Այն պատուհանի տերմինաբանությամբ կոչվում է հաճախորդի տարածք:

MiniWin- ում կա գրաֆիկական հրամանների գրադարան, որը կարող եք օգտագործել: Նրանք բոլորը պատուհանից տեղյակ են: Դա նշանակում է, որ պետք չէ անհանգստանալ, եթե պատուհանը տեսանելի է, մասամբ ծածկված է այլ պատուհաններով, միացված է, մասամբ անջատված է կամ ամբողջությամբ անջատված էկրանից, կամ եթե ձեր նկարած վայրի կոորդինատը գտնվում է հաճախորդի տարածքում կամ դրանից դուրս:. Այդ ամենը խնամված է ձեզ համար: Դուք չեք կարող նկարել ձեր հաճախորդների տարածքից դուրս:

Պատուհանների տերմինաբանության մեջ հաճախորդների տարածքների վրա նկարելը կոչվում է նկարչություն, և յուրաքանչյուր պատուհան ունի ներկի գործառույթ, որտեղ դուք նկարում եք ձեր նկարը: Դուք չեք զանգահարում ձեր ներկի գործառույթը, պատուհանների կառավարիչը դա անում է ձեզ համար, երբ դա անհրաժեշտ է: Դա անհրաժեշտ է, երբ պատուհանը տեղափոխվի կամ վերևում գտնվող մեկ այլ պատուհան փոխվի իր դիրքով կամ տեսանելիությամբ: Եթե Ձեզ անհրաժեշտ է պատուհանի ներկում, քանի որ որոշ տվյալներ, որոնցից կախված է պատուհանի բովանդակությունը, փոխվել են (այսինքն `գիտեք, որ պահանջվում է վերաներկում, քան պատուհանի կառավարիչը դա իմանա), ապա պատուհանի կառավարչին ասում եք, որ անհրաժեշտ է վերաներկել և այն կանչում է ձեր ներկի գործառույթը: Դուք ինքներդ դա չեք անվանում: (Այս ամենը ցուցադրվում է հաջորդ բաժնում):

Նախ, դուք պետք է գտնեք ձեր ներկի գործառույթը: Կոդ գեներատորը ստեղծում է այն ձեզ համար, և այն գտնվում է նախորդ բաժնում փոփոխված հաղորդագրությունների մշակողի գործառույթից վերև: Գնացեք ձեր նախագիծ և կրկին բացեք ֆայլը W1.c:

Այս ֆայլում դուք կգտնեք գործառույթը window_W1_paint_function (): Կարծես այսպիսին է.

դատարկ window_W1_paint_function (mw_handle_t window_handle, const mw_gl_draw_info_t *draw_info)

{MW_ASSERT (draw_info! = (Void*) 0, "ցուցիչի անվավեր պարամետր"); / * Լրացրեք պատուհանի հաճախորդի տարածքը ամուր սպիտակ գույնով */ 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). լայնություն, mw_get_window_client_rect (window_handle).բարձրություն); / * Ավելացրեք ձեզ պատուհանի ներկման կոդը այստեղ */}

Սա բաց թողնված ծածկագիր է, և այն ամենը, ինչ անում է, հաճախորդի տարածքը լցնում է ամուր սպիտակով: Եկեք դեղին լցված շրջան նկարենք հաճախորդի տարածքում: Սկզբում մենք պետք է հասկանանք գրաֆիկական համատեքստի հայեցակարգը (պատուհանների մեկ այլ բան): Մենք գծագրման պարամետրեր ենք սահմանում գրաֆիկական համատեքստում, այնուհետև անվանում ենք ընդհանուր շրջանակի գծագրման ռեժիմ: Այս օրինակում մենք պետք է սահմանենք այն, թե արդյոք շրջանն ունի եզրագիծ, եզրագծի ոճ, եզրագծի գույն, արդյոք շրջանակը լցված է, լրացնում է գույնը և լրացնում նախշը: Դուք կարող եք տեսնել վերևի ծածկագիրը, որը նման բան է անում հաճախորդի տարածքը առանց եզրերի ամուր լցված սպիտակ ուղղանկյունով լցնելու համար: Գրաֆիկական համատեքստում արժեքները չեն հիշվում ներկի գործառույթի յուրաքանչյուր կանչի միջև, այնպես որ դուք պետք է ամեն անգամ սահմանեք դրանք (չնայած դրանք հիշվում են ներկի գործառույթով):

Վերևի ծածկագրում կարող եք տեսնել, որ լրացումը միացված է, և լրացման օրինակը անջատված է, այնպես որ մենք կարիք չունենք դրանք նորից սահմանելու: Մենք պետք է սահմանը սահմանենք, սահմանագծի ոճը ՝ պինդ, սահմանի նախնական գույնը ՝ սև, իսկ գույնը ՝ դեղին, այսպես.

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

Ավելացրեք այս ծածկագիրը այս գործառույթի մեկնաբանության մեջ, որտեղ գրված է ՝ ավելացնել ձեր կոդը: Հաջորդը մենք պետք է գծենք մի շրջան, որն արվում է այսպես.

mw_gl_circle (draw_info, 30, 30, 15);

Սա գծում է շրջան 30, 30 շառավղով կոորդինատների վրա: Վերակառուցեք ծածկագիրը և կրկնեք այն, և պատուհանում կտեսնեք շրջան, ինչպես ցույց է տրված վերևում: Դուք կնկատեք, որ շրջանն ու կոճակը համընկնում են, բայց կոճակը վերևում է: Սա նախագծով է: Կառավարիչները միշտ այն ամենի վրա են, ինչ հաճախորդի տարածքում եք գծում:

Քայլ 8: Պատուհանի տվյալները

Մինչ այժմ մենք ներդրել ենք մեր սեփական ծածկագիրը Window 1- ի հաղորդագրությունների գործառույթում (մուտքային հաղորդագրությունները կարգավորելու համար) և դրա ներկման գործառույթը (նկարել պատուհանի հաճախորդների տարածքում): Հիմա ժամանակն է կապել երկուսը: Թույլ տվեք ներկի գործառույթում գծված շրջանակը լրացնել այն գույնով, որը օգտվողն ընտրում է գույնի ընտրողի կողմից, երբ կոճակը սեղմվում էր: Հիշեք, որ մենք չենք կանչում ներկի գործառույթը, դա անում է պատուհանի կառավարիչը, ուստի մեր հաղորդագրության գործառույթը (որը գիտի ընտրված գույնը) չի կարող ուղղակիորեն զանգել ներկի գործառույթը: Փոխարենը մենք պետք է պահենք տվյալները և պատուհանի կառավարչին տեղեկացնենք, որ պահանջվում է վերաներկում: Պատուհանի կառավարիչը այնուհետև կանչում է ներկի գործառույթը, որը կարող է օգտագործել պահված տվյալները:

W1.c- ի վերևում կտեսնեք տվյալների դատարկ կառուցվածք և այս տիպի օբյեկտ, որը հայտարարված է կոդի գեներատորի կողմից այսպես.

typedef strukt

{ / * Ավելացրեք ձեր տվյալների անդամներին այստեղ * / char dummy; /* Որոշ կազմողներ դժգոհում են դատարկ կառույցներից; հեռացրեք սա, երբ ավելացնեք ձեր անդամներին */} window_W1_data_t; ստատիկ window_W1_data_t window_W1_data;

Սա այն վայրն է, որտեղ մենք պահում ենք մեր տվյալները այնպես, որ դրանք պահպանվեն զանգերի ընթացքում և հայտնի են որպես պատուհանի տվյալներ: Մենք միայն պետք է ընտրված գույնը պահենք այստեղ ՝ այսպես.

typedef strukt

{ / * Ավելացրեք ձեր տվյալների անդամներին այստեղ * / mw_hal_lcd_colour_t selected_colour; } window_W1_data_t; ստատիկ window_W1_data_t window_W1_data = {MW_HAL_LCD_YELLOW};

Մենք նրան կտանք դեղին մեկնարկային գույն: Այժմ հաղորդագրության գործառույթում մենք մի փոքր կփոխենք ծածկագիրը ՝ այստեղ ընտրված գույնը պահպանելու համար.

գործ MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE:

{window_W1_data.chosen_colour = message-> message_data; } ընդմիջում;

Այնուհետև մենք կփոխենք ներկի գործառույթը `այս արժեքն օգտագործելու համար, երբ այն գծում է շրջանակը այսպես.

mw_gl_set_solid_fill_colour (window_W1_data.chosen_colour);

Այժմ մենք փոխել ենք այն տվյալները, որոնցից կախված է պատուհանի բովանդակությունը, ուստի մենք պետք է պատուհանի կառավարչին տեղյակ պահենք, որ պատուհանը ներկման կարիք ունի: Մենք դա անում ենք հաղորդագրության գործառույթում, երբ OK հաղորդագրությունը ստացվում է, այսպես.

mw_paint_window_client (հաղորդագրություն-> ստացողի_բռնակ);

Սա չի հանգեցնում պատուհանի ուղղակի ներկմանը: Դա օգտակար գործառույթ է, որը հաղորդագրություն է ուղարկում պատուհանի կառավարչին, որ պատուհանը պետք է վերաներկվի (եթե դրան ներս մտնես, կարող ես տեսնել, թե ինչպես է դա տեղի ունենում): Այս դեպքում պատուհանը, որը պետք է վերաներկվի, ինքն է, իսկ պատուհանի բռնիչը գտնվում է հաղորդագրությունների պարամետրում `հաղորդագրությունների մշակման գործառույթին:

Ամբողջ ֆայլն այժմ այս տեսքն ունի, եթե վստահ չեք, թե որտեղ են գնում վերևի կոդի որոշ հատվածներ.

#ներառում

#ներառել "miniwin.h" #include "miniwin_user.h" #include "W1.h" typedef struct { / * Ավելացրեք ձեր տվյալների անդամներին այստեղ * / mw_hal_lcd_colour_t selected_colour; } window_W1_data_t; ստատիկ 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 ցուցիչի պարամետր"); / * Լրացրեք պատուհանի հաճախորդի տարածքը ամուր սպիտակ գույնով */ 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). լայնություն, mw_get_window_client_rect (window_handle).բարձրություն); / * Ավելացրեք ձեզ պատուհանի ներկման կոդը այստեղ */ 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 ցուցիչի պարամետր"); / * Հաջորդ տողը դադարեցնում է կազմողի նախազգուշացումները, քանի որ փոփոխականն այս պահին չօգտագործված է */ (void) window_W1_data; switch (message-> message_id) {case MW_WINDOW_CREATED_MESSAGE: / * Ավելացնել ցանկացած պատուհանի սկզբնավորման կոդ այստեղ * / ընդմիջում; գործ MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * Ավելացնել պատուհանի ընտրացանկի գործածման կոդ այստեղ * / ընդմիջում; դեպքում MW_BUTTON_PRESSED_MESSAGE: } ընդմիջում; գործ MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE: {window_W1_data.chosen_colour = message-> message_data; mw_paint_window_client (հաղորդագրություն-> ստացողի_բռնակ); } ընդմիջում; կանխադրված ՝ / * Երջանիկ պահեք MISRA- ն / ընդմիջում; }}

Կառուցեք և նորից աշխատեք, և դուք պետք է կարողանաք սահմանել շրջանագծի լրացման գույնը:

Պատուհանի տվյալների այս օրինակը օգտագործում է տվյալներ, որոնք պահվում են սկզբնական աղբյուրի վերևում գտնվող ստատիկ տվյալների կառուցվածքում: Սա լավ է, եթե դուք ունեք պատուհանի միայն մեկ օրինակ, ինչպես մենք ունենք այս օրինակում, բայց եթե ունեք մեկից ավելի օրինակ, ապա դրանք բոլորը կկիսեն նույն տվյալների կառուցվածքը: Հնարավոր է ունենալ մեկ օրինակի տվյալներ, որպեսզի նույն պատուհանի տիպի բազմաթիվ օրինակներ ունենան իրենց տվյալները: Սա բացատրվում է փաստաթղթերի գրացուցակում հայտնաբերված MiniWin փաստաթղթերում: Ֆայլի օրինակը այն օգտագործում է մի քանի պատուհանների նույն տեսակի պատկերներ ցուցադրելու համար (ինչպես երևում է հիմնական պատկերում ՝ այս հրահանգի վերևում):

Քայլ 9. Որոշ տառատեսակի վերջին զվարճանք

MiniWin- ն աջակցում է TrueType տառատեսակի մատուցմանը: Եթե կա մի բան, որը ձեր ինտերֆեյսը լավ տեսք ունի, դա գրավիչ տառատեսակներ են: Այս վերջին քայլը ցույց է տալիս, թե ինչպես կարելի է TrueType տառատեսակը մատուցել MiniWin պատուհանում:

TrueType տառատեսակները մատուցելու երկու եղանակ կա: Մեկն այն է, որ դրանք ուղղակիորեն նկարեք ձեր հաճախորդի տարածքում, ինչպես դա արվել էր ավելի վաղ շրջանի համար, մյուսը `ձեր պատուհանում ավելացնել տեքստային տուփի հսկողություն: Մենք անում ենք վերջինը, քանի որ դա ավելի հեշտ է:

Այժմ մենք JSON կազմաձևման ֆայլում կավելացնենք տեքստային տուփի հսկողություն: Ավելացրեք այն Պատուհան 2 -ի սահմանման մեջ, որպեսզի այն ունենա հետևյալ տեսքը.

սրա նման:

{

«Անուն» ՝ «W2», «Վերնագիր» ՝ «Պատուհան 2», «X» ՝ 50, «Y» ՝ 65, «Լայնություն» ՝ 100, «Բարձրություն» ՝ 80, «Սահման» ՝ ճշմարիտ, «TitleBar» ՝ ճշմարիտ, «տեսանելի» ՝ ճշմարիտ, «նվազագույնի հասցված» ՝ սխալ, «տեքստային տուփեր» ՝ [{«Անուն» ՝ «TB1», «X» ՝ 0, «Y» ՝ 0, «լայնություն» ՝ 115, «բարձրություն» ՝ 50, «Հիմնավորում» ՝ «Կենտրոն», «Ֆոնային գույն» ՝ «MW_HAL_LCD_YELLOW», «Նախնական գույն» ՝ «MW_HAL_LCD_BLACK», «Տառատեսակ».

Արագ խոսք TrueType տառատեսակների մասին MiniWin- ում: Տառատեսակները գալիս են.ttf ֆայլերում: Ավելի մեծ համակարգիչների պատուհանների կառավարիչներում դրանք անհրաժեշտության դեպքում ցուցադրվում են ձեր էկրանին: Սա շատ պրոցեսորային հզորություն և հիշողություն է պահանջում և հարմար չէ փոքր սարքերի համար: MiniWin- ում դրանք նախապես մշակվում են bitmap- երի մեջ և միացվում են կազմման ժամանակ `ֆիքսված տառատեսակի չափով և ոճով (համարձակ, շեղագիր և այլն), այսինքն` դուք պետք է որոշեք, թե որ տառատեսակներով ինչ չափի և ոճի եք պատրաստվում օգտագործել կազմման ժամանակ: Սա արվել է ձեզ համար ՝ ձեր ներբեռնած MiniWin zip ֆայլի երկու օրինակ տառատեսակների դեպքում: Եթե ցանկանում եք այլ չափսերի և ոճերի այլ տառատեսակներ օգտագործել, տեսեք փաստաթղթերի թղթապանակում գտնվող MiniWin փաստաթղթերը: Կան գործիքներ MiniWin- ում Windows- ի և Linux- ի համար.ttf ֆայլերը նախնական մշակման աղբյուրի կոդի ֆայլերի մեջ, որոնք կարող եք թողնել ձեր նախագծում:

Եվ երկրորդ արագ խոսք. Տառատեսակների մեծ մասը հեղինակային իրավունք է, ներառյալ այն, ինչ կգտնեք Microsoft Windows- ում: Օգտագործեք դրանք ըստ ցանկության ՝ անձնական օգտագործման համար, բայց այն, ինչ հրապարակում եք, պետք է ապահովեք, որ տառատեսակները հրապարակվեն լիցենզիայով, ինչը թույլ է տալիս, ինչպես դա MiniWin- ում ներառված 2 տառատեսակների դեպքում է, բայց ոչ Microsoft- ի տառատեսակների դեպքում:

Վերադառնալ ծածկագրին: Ստեղծեք, թողեք ֆայլեր, ստեղծեք և կրկնեք նախկինի պես, և կտեսնեք, որ «Պատուհան 2» -ն այժմ ունի որոշ կանխադրված տեքստ դեղին ֆոնի վրա ՝ տարօրինակ տառատեսակով: Թույլ տվեք փոխել տեքստը `խմբագրելով Window 2 -ի սկզբնական ֆայլը W2.c.

Մենք պետք է շփվենք մեր ստեղծած տեքստային տուփի հետ, և ինչպես դուք դա անում եք, ինչպես ցանկացած հաղորդակցություն MiniWin- ում, դա հաղորդագրություն ուղարկելը: Մենք ցանկանում ենք տեքստը սահմանել կառավարման վահանակում, երբ պատուհանը ստեղծվում է, բայց նախքան այն ցուցադրվելը, ուստի մենք հաղորդագրություն մշակողի մեջ ավելացնում ենք կոդը MW_WINDOW_CREATED_MESSAGE դեպքում: Սա ստացվում է պատուհանի կոդով պատուհանը ցուցադրվելուց անմիջապես առաջ և նախատեսված է այսպիսի նախաստորագրումների համար: Կոդ գեներատորը ստեղծեց մի տեղ, որը նման է հաղորդագրությունների մշակման գործառույթին.

գործ MW_WINDOW_CREATED_MESSAGE:

/ * Ավելացնել ցանկացած պատուհանի սկզբնավորման կոդ այստեղ */ ընդմիջում;

Այստեղ մենք մտադիր ենք հաղորդագրություն տեղադրել տեքստային տուփի կառավարման վահանակին ՝ ասելով, թե ինչ տեքստ ենք ուզում ցուցադրել ՝ օգտագործելով mw_post_message ֆունկցիան այսպես.

գործ MW_WINDOW_CREATED_MESSAGE:

/ * Ավելացնել ցանկացած պատուհանի սկզբնավորման կոդ այստեղ */ mw_post_message (MW_TEXT_BOX_SET_TEXT_MESSAGE, message-> receip_handle, text_box_TB1_handle, 0UL, "Twas a dark and stormy night …", MW_CONTROL_MESSAGE); ընդմիջում;

Սրանք են պարամետրերը.

• MW_TEXT_BOX_SET_TEXT_MESSAGE - Սա այն հաղորդագրության տեսակն է, որը մենք ուղարկում ենք կառավարմանը: Դրանք թվարկված են miniwin.h- ում և փաստաթղթավորված փաստաթղթերում:
• հաղորդագրություն -> ստացողի_հասցե - Ահա թե ումից է հաղորդագրությունը - այս պատուհանը, որի բռնակը գտնվում է հաղորդագրության պարամետրում փոխանցված հաղորդագրությունների մշակողի գործառույթին:
• text_box_TB1_handle - Ում ենք ուղարկում հաղորդագրություն - տեքստային տուփի կառավարման բռնակ: Դրանք թվարկված են գեներացված ֆայլում miniwin_user.h:
• 0UL - Տվյալների արժեքը, այս դեպքում ոչինչ:
• «Մութ ու բուռն գիշեր էր …» - ցուցիչի արժեք - նոր տեքստ:
• MW_CONTROL_MESSAGE - Ստացողի տեսակը, որը հսկողություն է:

Վերջ: Վերականգնել և կրկնել սովորականի պես և կստանաք տեքստային տուփ, որը ցուցադրվում է ինչպես վերևի նկարում:

Հաղորդագրությունների տեղադրումը հիմնարար նշանակություն ունի MiniWin- ի համար (ինչպես և պատուհանների բոլոր կառավարիչների համար): Լրացուցիչ օրինակների համար նայեք zip ֆայլի նախագծերի օրինակներին և համապարփակ բացատրության համար կարդացեք փաստաթղթերում առկա MiniWin հաղորդագրությունների բաժինը:

Քայլ 10: Առաջ գնալ

Ահա և վերջ MiniWin- ի այս հիմնական ներդրման համար: MiniWin- ը կարող է շատ ավելին անել, քան ցուցադրվել է այստեղ: Օրինակ, այս հրահանգի մեջ օգտագործվող տախտակի էկրանը փոքր է, իսկ կառավարման վահանակները փոքր են և պետք է օգտագործվեն երկկողմանի բիբերի հետ: Այնուամենայնիվ, այլ օրինակներ և սարքավորումներ օգտագործում են ավելի մեծ հսկիչներ (կան 2 չափսեր) ավելի մեծ էկրանների վրա, և դրանք կարող են մատներով աշխատել:

Կան բազմաթիվ այլ տեսակներ, քան այստեղ ցուցադրվածները: Հետագա վերահսկողության համար նայեք կոդի գեներատորների թղթապանակի JSON ֆայլերի օրինակին: Վերահսկողության բոլոր տեսակները ընդգրկված են այս օրինակներում:

Windows- ը շատ տարբերակներ ունի: Եզրագիծը, վերնագրի գիծը և պատկերակները բոլորը կարգավորելի են: Կարող եք ունենալ ոլորման սանդղակներ և ոլորվող պատուհանների հաճախորդների տարածքներ, նույն պատուհանի և պատուհանների բազմաթիվ օրինակներ կարող են մերկ լինել (միայն հաճախորդի տարածք, առանց եզրագիծ կամ վերնագրի գոտի), ինչը նշանակում է, որ դրանք ամրագրված են էկրանին տեղում տեղադրման ժամանակ (տե՛ս այս հատվածի պատկերը չափի մեծ սրբապատկերներով. դրանք իրականում 6 մերկ պատուհաններ են):

MiniWin- ը չի օգտագործում դինամիկ հիշողություն: Սա այն հարմար է դարձնում փոքր սահմանափակ սարքերի համար և պահանջ է որոշ ներդրված նախագծերի համար: MiniWin- ը և դրա ստեղծած ծածկագիրը նույնպես լիովին համապատասխանում են MISRA 2012 -ին «պահանջվող» մակարդակին:

Լրացուցիչ տեղեկությունների համար նայեք փաստաթղթերի թղթապանակին փաստաթղթերի համար, ինչպես նաև zip ֆայլի մյուս օրինակելի ծրագրերը: Այստեղ կան օրինակներ, որոնք ցույց են տալիս, թե ինչպես օգտագործել MiniWin- ի բոլոր հնարավորությունները և ինչպես MiniWin- ը ինտեգրվել FatFS- ի և FreeRTOS- ի հետ: