ჩაშენებული ფანჯრის მენეჯერი: 10 ნაბიჯი

2025 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2025-01-23 14:50

ეს პროექტი გვიჩვენებს, თუ როგორ განვახორციელოთ ფანჯრის მენეჯერი მოძრავი გადაფარებული ფანჯრებით ჩამონტაჟებულ მიკროკონტროლერზე LCD პანელით და სენსორული ეკრანით. არსებობს კომერციულად ხელმისაწვდომი პროგრამული პაკეტები ამის გასაკეთებლად, მაგრამ მათი ღირებულებაა და დახურული წყაროა. ეს ერთი, სახელწოდებით MiniWin, არის უფასო და ღია. ის დაწერილია სრულად შესაბამის C99 და შეიძლება გამოყენებულ იქნას C ან C ++ პროგრამაში. მიზნები MiniWin უნდა იყოს მარტივი გამოყენება, ადვილად მოდიფიცირებადი, გაფართოებადი, პორტატული ტექნიკის ფართო სპექტრზე და არც ისე რესურსი მშიერი.

MiniWin– ს ასევე აქვს Windows– ის მართვის კოდის მინიჭება ინტერფეისის კონტროლის კოლექცია - ღილაკები, სლაიდერი, პროგრესული ზოლები, ხეები და ა.შ. Windows შეიძლება გადაადგილდეს, შეიცვალოს, გაიზარდოს, შემცირდეს, დაიხუროს - ყველა ის ჩვეულებრივი რამ, რასაც აკეთებთ ფანჯრებით უფრო დიდი ფანჯრების მენეჯერებში. TrueType შრიფტები kerning და anti-aliasing (ხდის ტექსტს smooooooth) ასევე მხარს უჭერს მიმზიდველი ტექსტის გაწევას.

თითოეულ ფანჯარაში თქვენ გაქვთ კლიენტის ტერიტორია (თქვენი სივრცე საზღვრის შიგნით და ზედა ზოლის ქვემოთ). ამაზე შეგიძლიათ დაამატოთ კონტროლი დიალოგის შესაქმნელად, ან გამოიყენოთ ჩაშენებული გრაფიკული ბიბლიოთეკა, რათა დახატოთ რაც გსურთ. ყველა გრაფიკული ბიბლიოთეკის ფუნქცია ფანჯრისთვის ცნობილია. თქვენ არ უნდა ინერვიულოთ იმაზე, თუ სად არის თქვენი ფანჯარა, რა არის მისი გადახურვა ან მინიმუმამდე შემცირებული.

საკუთარი ფანჯრების დამზადების გარდა, ასევე არის სტანდარტული დიალოგები, რომელთა ინსტალაციაც ძალიან ადვილია - მაგალითად, დადასტურების დიალოგები (უბრალოდ OK ან დიახ/არა ღილაკები), დროის/თარიღის განმსაზღვრელი, ფაილის ამომრჩევლები, ფერის ამომრჩევლები და ა.

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 წყარო და გახსენით იგი. ის დიდია, მაგრამ თქვენ გამოიყენებთ მის მცირე ნაწილს. დააწკაპუნეთ მწვანე ღილაკზე "კლონირება ან ჩამოტვირთვა" აქ …

github.com/miniwinwm/miniwinwm

შემდეგ აირჩიეთ ჩამოტვირთეთ Zip. გახსენით შინაარსი.

ნაბიჯი 2: შექმენით მაგალითი პროექტი

პირველი მოდით ავაშენოთ ერთ -ერთი მაგალითი პროექტი. კარგს ქვია MiniWinSimple. გაუშვით STM32CubeIDE შემდეგ გააკეთეთ ეს:

1. აირჩიეთ ფაილი | იმპორტი…
2. გახსენით General და აირჩიეთ არსებული პროექტი სამუშაო სივრცეში. შემდეგი
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. წაშალეთ იქ არსებული ყველა ფაილი.
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": ჭეშმარიტი, "ხილული": ჭეშმარიტი, "შემცირებული": მცდარი}

და ჩასვით იგი კვლავ მძიმით, რომელიც განასხვავებს 2 განმარტებას.

3. შეცვალეთ "W1" "W2" და "Window 1" "Window 2". შეცვალეთ "X", "Y", "სიგანე" და "სიმაღლე" სხვადასხვა მნიშვნელობებზე, გაითვალისწინეთ ეკრანის გარჩევადობა 240 სიგანე 320 სიმაღლეზე.

4. შეინახეთ ფაილი და კვლავ გაუშვით კოდის გენერატორი.

5. დააკოპირეთ ფაილები, როგორც წინა საფეხურზე, აღადგინეთ და გაიმეორეთ. ახლა თქვენ გექნებათ 2 ფანჯარა თქვენს ეკრანზე.

ნაბიჯი 5: კონტროლის დამატება

ახლა ჩვენ დავამატებთ რამდენიმე კონტროლს თქვენს ახალ ფანჯარაში. შეცვალეთ იგივე ფაილი, როგორც წინა ეტაპზე.

1. ფანჯარაში W1 სპეციფიკაციაში დაამატეთ მძიმე ბოლო პარამეტრის შემდეგ ("მინიმიზებული": ყალბი) და შემდეგ დაამატეთ ეს ტექსტი

"MenuBar": მართალია, "MenuBarEnabled": true, "MenuItems": ["Fred", "Bert", "Pete", "Alf", "Ian"], "Buttons": [{"Name": "B1", "Label": "ღილაკი 1", "X": 10, "Y": 10, "ჩართულია": true, "ხილული": 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 (შეტყობინება! = (ბათილია *) 0, "მაჩვენებლის ნულოვანი პარამეტრი"); / * შემდეგი ხაზი აჩერებს შემდგენლის გაფრთხილებებს, რადგან ცვლადი ამჟამად გამოუყენებელია */ (void) window_W1_data; გადართვა (შეტყობინება-> შეტყობინების_იდი) {case MW_WINDOW_CREATED_MESSAGE: / * დაამატეთ ნებისმიერი ფანჯრის ინიციალიზაციის კოდი აქ * / შესვენება; საქმე MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * დაამატეთ ფანჯრის მენიუს დამუშავების კოდი აქ * / შესვენება; კეისი MW_BUTTON_PRESSED_MESSAGE: if (შეტყობინება-> გამგზავნის სახელური == ღილაკი_B1_ხელე) { / * დაამატეთ დამმუშავებლის კოდი ამ კონტროლისთვის აქ * /} შესვენება; ნაგულისხმევი: / * შეინახე 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; გადართვა (შეტყობინება-> შეტყობინების_იდი) {case MW_WINDOW_CREATED_MESSAGE: / * დაამატეთ ნებისმიერი ფანჯრის ინიციალიზაციის კოდი აქ * / შესვენება; საქმე MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * დაამატეთ ფანჯრის მენიუს დამუშავების კოდი აქ * / შესვენება; საქმე MW_BUTTON_PRESSED_MESSAGE: თუ (შეტყობინება-> გამგზავნის_მომუშავე == ღილაკი_B1_ხელე) { / * დაამატეთ თქვენი დამმუშავებლის კოდი ამ კონტროლისთვის აქ * / mw_create_window_dialog_colour_chooser (10, 10, "ფერი", MW_HAL_LCD_RED), მცდარი, შეტყობინება-> მიმღები,> } შესვენება; საქმე MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE: {mw_hal_lcd_colour_t selected_colour = message-> message_data; (ბათილია) არჩეული_ფერი; } შესვენება; ნაგულისხმევი: / * შეინახე MISRA ბედნიერი * / შესვენება; }}

კოდის გაშვება ნაჩვენებია ზემოთ მოცემულ სურათზე. თქვენ შეიძლება შეამჩნიოთ, რომ როდესაც დიალოგი ნაჩვენებია, თქვენ უნდა უპასუხოთ მას და გაათავისუფლოთ იგი სანამ რამეს გააკეთებთ. ამას ქვია მოდალური ქცევა. დიალოგები MiniWin– ში და ყოველთვის გლობალურად მოდალური და თქვენ შეგიძლიათ გქონდეთ მხოლოდ ერთი ჩვენება ერთდროულად. აქ მეტი ახსნა არსებობს …

en.wikipedia.org/wiki/Modal_window

ნაბიჯი 7: ხატვა ფანჯარაში

აქამდე ჩვენ მხოლოდ კონტროლს ვიყენებდით და ისინი თვითონ ხატავდნენ. დროა გავაკეთოთ ჩვენი ფანჯრის პერსონალური ნახაზი. ნაწილი, რომელზედაც შეგიძლიათ დახატოთ არის საზღვრების შიგნით (თუკი ასეთია, ისინი არჩევითია), გადახვევის ზოლების შიგნით (თუ განსაზღვრულია, ასევე სურვილისამებრ) და სათაურის ზოლის ქვემოთ (თუ არის ერთი, ესეც სურვილისამებრ). მას უწოდებენ კლიენტის არეალს ფანჯრის ტერმინოლოგიაში.

MiniWin– ში არის გრაფიკული ბრძანებების ბიბლიოთეკა, რომლის გამოყენებაც შეგიძლიათ. ყველამ იცის ფანჯარა. ეს ნიშნავს, რომ თქვენ არ უნდა ინერვიულოთ იმაზე, თუ ფანჯარა ხილულია, ნაწილობრივ დაფარული სხვა ფანჯრებით, ჩართული, ნაწილობრივ გამორთული ან სრულად ეკრანიდან, ან თუ სად ხატავთ კოორდინატი არის კლიენტის არეზე ან მის მიღმა რა ეს ყველაფერი შენზე ზრუნავს. თქვენ არ შეგიძლიათ დახაზოთ თქვენი კლიენტის ზონის გარეთ.

ფანჯრის ტერმინოლოგიაში კლიენტის სფეროების დახატვას ეწოდება ფერწერა და ყველა ფანჯარას აქვს საღებავის ფუნქცია, სადაც თქვენ აკეთებთ თქვენს ნახატს. თქვენ არ დაურეკავთ თქვენი საღებავის ფუნქციას, ფანჯრის მენეჯერი ამას აკეთებს თქვენთვის საჭიროების შემთხვევაში. ეს საჭიროა, როდესაც ფანჯარა გადაადგილდება ან სხვა ფანჯარა თავზე იცვლება მისი პოზიცია ან ხილვადობა. თუ თქვენ გჭირდებათ ფანჯრის შეღებვა იმის გამო, რომ ზოგიერთი მონაცემი, რომელზედაც დამოკიდებულია ფანჯრის შინაარსი, შეიცვალა (ანუ თქვენ იცით, რომ საჭიროა ხელახლა შეღებვა, ვიდრე ფანჯრის მენეჯერმა იცის), მაშინ ფანჯრის მენეჯერს ეუბნებით, რომ საჭიროა ხელახლა შეღებვა და ის იძახებს შენი საღებავის ფუნქცია. შენ თვითონ არ დაუძახებ. (ეს ყველაფერი ნაჩვენებია შემდეგ ნაწილში).

პირველ რიგში, თქვენ უნდა იპოვოთ თქვენი საღებავის ფუნქცია. კოდის გენერატორი ქმნის მას თქვენთვის და ის მაღლაა შეტყობინებების დამმუშავებლის ფუნქციის ზემოთ წინა ნაწილში შეცვლილი. გადადით თქვენს პროექტზე და კვლავ გახსენით ფაილი W1.c.

ამ ფაილში ნახავთ ფუნქციას window_W1_paint_function (). ასე გამოიყურება:

void 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). სიმაღლე); / * დაამატეთ ფანჯრის ხატვის კოდი აქ */}

ეს არის შიშველი, როგორც გენერირებული კოდი და ყველაფერი რაც მას აკეთებს არის შეავსოს კლიენტის არე მყარი თეთრი. მოდით დავხატოთ ყვითელი შევსებული წრე კლიენტის არეზე. პირველ რიგში, ჩვენ უნდა გვესმოდეს გრაფიკული კონტექსტის კონცეფცია (სხვა Windows რამ). ჩვენ ვადგენთ ხატვის პარამეტრებს გრაფიკულ კონტექსტში და შემდეგ ვუწოდებთ ზოგად წრეს ხატვის რუტინას. ამ მაგალითში ჩვენ უნდა განვსაზღვროთ არის თუ არა წრეს საზღვარი, საზღვრის ხაზის სტილი, საზღვრის ფერი, არის თუ არა წრე შევსებული, შევსების ფერი და შევსების ნიმუში. თქვენ ხედავთ ზემოთ მოცემულ კოდს, რომელიც მსგავსს აკეთებს კლიენტის არეის უსაზღვრო მყარი თეთრი ოთხკუთხედის შევსების მიზნით. გრაფიკული კონტექსტის მნიშვნელობები არ ახსოვს საღებავის ფუნქციის თითოეულ ზარს შორის, ასე რომ თქვენ უნდა დააყენოთ ღირებულებები ყოველ ჯერზე (თუმცა ისინი ახსენდება საღებავის ფუნქციით).

ზემოთ მოყვანილ კოდში ხედავთ, რომ შევსება ჩართულია და შევსების ნიმუში გამორთულია, ამიტომ ჩვენ არ გვჭირდება მათი ხელახლა დაყენება. ჩვენ უნდა დავაყენოთ საზღვარი, საზღვრის ხაზის სტილი მყარად, საზღვრის წინა პლანზე ფერი შავი და შეავსოთ ფერი ყვითლად ასე:

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 რადიუსით 15. აღადგინეთ კოდი და გაიმეორეთ იგი და თქვენ დაინახავთ წრეს ფანჯარაში, როგორც ეს ნაჩვენებია ზემოთ. თქვენ შეამჩნევთ, რომ წრე და ღილაკი ერთმანეთს ემთხვევა, მაგრამ ღილაკი თავზეა. ეს არის დიზაინით. კონტროლი ყოველთვის არის ყველაფრის თავზე, რასაც კლიენტის არეზე ხატავთ.

ნაბიჯი 8: ფანჯრის მონაცემები

აქამდე ჩვენ განვახორციელეთ ჩვენი საკუთარი კოდი Window 1 -ის შეტყობინების ფუნქციაში (შემომავალი შეტყობინებების დამუშავება) და მისი საღებავის ფუნქცია (ფანჯრის კლიენტის არეზე გამოსახვა). ახლა დროა დააკავშიროთ ეს ორი. მოდით შეავსოთ საღებავის ფუნქციაში დახატული წრე იმ ფერით, რომელსაც მომხმარებელი ირჩევს ფერის არჩევისას ღილაკის დაჭერისას. გახსოვდეთ, რომ ჩვენ არ ვიძახებთ საღებავის ფუნქციას, ამას აკეთებს ფანჯრის მენეჯერი, ამიტომ ჩვენი შეტყობინების ფუნქციას (რომელმაც იცის არჩეული ფერი) არ შეუძლია პირდაპირ დარეკოს საღებავის ფუნქცია. ამის ნაცვლად, ჩვენ გვჭირდება მონაცემების ქეშირება და ფანჯრის მენეჯერს შევატყობინოთ, რომ საჭიროა ხელახლა შეღებვა. ფანჯრის მენეჯერი დარეკავს საღებავის ფუნქციას, რომელსაც შეუძლია გამოიყენოს ქეშირებული მონაცემები.

W1.c– ის ზედა ნაწილში ნახავთ მონაცემთა ცარიელ სტრუქტურას და ამ ტიპის ობიექტს კოდის გენერატორის მიერ გამოცხადებულს შემდეგნაირად:

typedef სტრუქტურა

{ / * დაამატეთ თქვენი მონაცემების წევრები აქ * / char dummy; /* ზოგიერთი შემდგენელი უჩივის ცარიელ ნაგებობებს; წაშალეთ ეს როდესაც დაამატებთ თქვენს წევრებს */} window_W1_data_t; სტატიკური window_W1_data_t window_W1_data;

ეს არის ადგილი, სადაც ჩვენ ვინახავთ ჩვენს მონაცემებს ისე, რომ ის დაცულია ზარებში და ცნობილია როგორც ფანჯრის მონაცემები. ჩვენ მხოლოდ უნდა შევინახოთ არჩეული ფერი აქ, ასე:

typedef სტრუქტურა

{ / * დაამატეთ თქვენი მონაცემების წევრები აქ * / mw_hal_lcd_colour_t არჩეული_ფერი; } 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" #მოიცავს "miniwin_user.h" #მოიცავს "W1.h" typedef struct { / * დაამატეთ თქვენი მონაცემების წევრები აქ * / mw_hal_lcd_colour_t არჩეული_ფერი; } 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, "მაჩვენებლის ნულოვანი პარამეტრი"); / * შეავსეთ ფანჯრის კლიენტის არე მყარი თეთრი */ 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 (შეტყობინება! = (void *) 0, "მაჩვენებლის ნულოვანი პარამეტრი"); / * შემდეგი ხაზი აჩერებს შემდგენლის გაფრთხილებებს, რადგან ცვლადი ამჟამად გამოუყენებელია */ (void) window_W1_data; გადართვა (შეტყობინება-> შეტყობინების_იდი) {case MW_WINDOW_CREATED_MESSAGE: / * დაამატეთ ნებისმიერი ფანჯრის ინიციალიზაციის კოდი აქ * / შესვენება; საქმე MW_MENU_BAR_ITEM_PRESSED_MESSAGE: / * დაამატეთ ფანჯრის მენიუს დამუშავების კოდი აქ * / შესვენება; საქმე MW_BUTTON_PRESSED_MESSAGE: თუ (შეტყობინება-> გამგზავნის_მომუშავე == ღილაკი_B1_ხელე) { / * დაამატეთ თქვენი დამმუშავებლის კოდი ამ კონტროლისთვის აქ * / mw_create_window_dialog_colour_chooser (10, 10, "ფერი", MW_HAL_LCD_RED), მცდარი, შეტყობინება-> მიმღები,> } შესვენება; საქმე MW_DIALOG_COLOUR_CHOOSER_OK_MESSAGE: {window_W1_data.chosen_colour = შეტყობინება-> შეტყობინების_დანაშაული; 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, "დასაბუთება": "ცენტრი", "BackgroundColour": "MW_HAL_LCD_YELLOW", "ForegroundColour": "MW_HAL_LCD_BLACK", "Font": "mf_rlefont_BLKCHCRY16", "გააქტიურებული": ჭეშმარიტი, "ხილული": ჭეშმარიტი]}}

მოკლე სიტყვა TrueType შრიფტების შესახებ MiniWin– ში. შრიფტები შემოდის.ttf ფაილებში. ფანჯრების მენეჯერებში უფრო დიდ კომპიუტერებზე ეს გადატანილია თქვენს ეკრანზე, როცა საჭიროა. ამას ბევრი დამუშავების ძალა და მეხსიერება სჭირდება და არ არის შესაფერისი პატარა მოწყობილობებისთვის. MiniWin– ში ისინი წინასწარ დამუშავებულია ბიტმაპებად და დაკავშირებულია შედგენის დროს ფიქსირებული შრიფტის ზომით და სტილით (თამამი, დახრილი და ა. ეს გაკეთდა თქვენთვის გადმოწერილი MiniWin zip ფაილის ორი შრიფტისთვის. თუ გსურთ სხვა ზომის და სტილის სხვა შრიფტების გამოყენება იხილეთ დოკუმენტების საქაღალდეში MiniWin დოკუმენტაცია. არსებობს ინსტრუმენტები MiniWin– ში Windows– ისთვის და Linux– ისთვის.ttf ფაილების წინასწარი დამუშავებისათვის კოდის ფაილებში, რომლებიც შეგიძლიათ ჩააგდოთ თქვენს პროექტში.

და მეორე სწრაფი სიტყვა - შრიფტების უმეტესობა საავტორო უფლებაა, მათ შორის ის, რასაც Microsoft Windows– ში ნახავთ. გამოიყენეთ ისინი სურვილისამებრ პირადი სარგებლობისთვის, მაგრამ რასაც თქვენ აქვეყნებთ, დარწმუნებული უნდა იყოთ, რომ შრიფტების გამოქვეყნების ლიცენზია ამის საშუალებას იძლევა, როგორც ეს ხდება MiniWin– ში შემავალი 2 შრიფტის შემთხვევაში, მაგრამ არა Microsoft– ის შრიფტებზე!

დაუბრუნდით კოდს! შექმენით, ჩამოაგდეთ ფაილები, შექმენით და ხელახლა გაუშვით, როგორც ადრე და ნახავთ, რომ ახლა ფანჯარა 2 – ს აქვს ნაგულისხმევი ტექსტი ყვითელ ფონზე უაზრო შრიფტით. მოდით შევცვალოთ ტექსტი ფანჯრის 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, შეტყობინება-> მიმღების_ხელე, text_box_TB1_handle, 0UL, "იყო ბნელი და ქარიშხლიანი ღამე …", 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– თან.