Nagi! Nagi! Šiandien pagaliau vėl atidarome Windows langą. Atsisveikink vargše konsolė!
Iki tol turite būti susipažinę su C++ sintaksė, suprasti, kaip naudoti kilpas ir kilpas bei suprasti, kaip gerai veikia funkcijos. Jei buvote sugautas jūrų mūšyje, galite atkreipti dėmesį į tai, ką užfiksavote.
Ugorsko registracijos forma
Visas WinAPI naudojamas kodas parašytas ukrainietiška forma. Naudinga gerai parašyti kodą.
Kieno burbuolės raidė turėtų būti dedama prieš pakeitimo pavadinimą. Visi žodžiai svarbių funkcijų pavadinimuose prasideda didžiąja raide.
Priešdėlių ašis:
b – keisti tipą bool.
l - pakeisti tipą ilgas sveikasis skaičius.
w – žodis (žodis) – 16 bitų. Nepasirašyto trumpojo tipo pavadinimas.
dw – dvigubas žodis (požodis) – 32 bitai. Zminna tipo nepasirašytas ilgas.
sz - eilutė, kuri baigiasi nuliu (eilutė baigiasi nuliu). Tiesiog paprasta eilutė, kurią nuolat vikorizavome.
p arba lp – rodyklė. lp (kaip ilgoji rodyklė) – šie rodikliai perkelti iš praeities. Tuo pačiu metu lp i p reiškia tą patį.
h – aprašymas (tipo rankena).
Pavyzdžiui, ašis vadinama taip:
negaliojantis * pData;
Šios registracijos formos autorių teisės priklauso „Microsoft“. Yra daug žmonių, kurie kritikuoja šį keičiamųjų įvardijimo būdą. Tačiau panašios kalbos (ypač apie kodavimą) yra gyvybiškai svarbios didelėms įmonėms.
Leiskite jums priminti, kad nuolatiniai identifikatoriai yra pagrįsti didžiosiomis raidėmis: WM_DESTROY. WM_DESTOY – reikšmė 2, konstanta apibrėžiama per define.
Be to, winAPI turi daugybę tipų perskirstymo. Šio puslapio ašis yra http://msdn.microsoft.com/en-us/library/aa383751(VS.85).aspx, galite rasti visų tipų Windows aprašymus (anglų kalba).
Ir dar viena kalba, kurios mes nesupratome. Dušams dažnai suteikiamos NULL reikšmės. Atkreipkite dėmesį, kad tai yra tiesiog 0, o pasirašantieji, kuriems priskirta reikšmė NULL (nulis), nenurodo atminties dalies.
„Windows“ API („WinAPI“)
Visos „Windows“ programos naudoja specialią programavimo sąsają „WinAPI“. „Movi C“ funkcijų ir struktūrų rinkinys leidžia jūsų programai gerai veikti „Windows“.
„Windows“ API turi puikių galimybių dirbti su operacine sistema. Galima sakyti – be sienų.
Negalime žiūrėti tik į šimtą WinAPI galimybių. Šiuo metu noriu paimti daugiau medžiagos, bet tai užtruktų daug valandų, o parsiuntus WinAPI į pelkes, per porą akmenų patektume į DirectX WinAPI aprašymas, mokysime dvi pamokas (įskaitant šią) Jie žiūrės tik į „Windows“ sistemą.
„Windows“ skirta programa, kaip ir DOS skirta programa, turi pagrindinę funkciją. Čia ši funkcija vadinama WinMain.
WinMain funkcija
„Windows“ programą sudaro šios dalys (viskas saugoma „WinMain“):
Klasės lango sukūrimas ir registravimas. Nepainiokite su C++ klasėmis. WinAPI parašyta C kalba, yra daug klasių, kurios mums žinomos kaip įprastas žodis.
Programos lango sukūrimas.
Pagrindinis ciklas, kuriame formuojasi žinios.
Apie apdorojimą pranešama paskutinėje procedūroje. Lango procedūra yra pagrindinė funkcija.
Ašis ir keli taškai yra „Windows“ programų pagrindas. Pratęsdami šią naują pamoką, viską sutvarkysime smulkiai. Jei pasiklydote programų aprašyme, grįžkite prie šių punktų.
Dabar viską sutvarkykime:
WinAPI: WNDCLASS struktūra
Pirmiausia turime sukurti ir išsaugoti struktūrinį pakeitimą WNDCLASS, o tada pagal jį užregistruoti galutinę klasę.
Ašis atrodo taip:
mano c++ kodas typedef struct ( UINT stilius; // lango stilius WNDPROC lpfnWndProc; // lango procedūros indikatorius int cbClsExtra; // papildomi baitai po klasės. Pirmiausia nustatykite į 0 int cbWndExtra; // papildomi baitai po lango egzemplioriaus. Pirmiausia nustatykite į 0 / programos programa: Perėjo peržiūros parametras WinMain HICON hIcon // programos piktograma HCURSOR hbrBackground // fono spalva LPCTSTR lpszMenuName;
WNDCLASS struktūra WinAPI sandėlyje apibrėžia pagrindines kuriamo lango galias: piktogramas, pelės žymeklio rodinį, lango meniu, kuris priedas bus lange...
Išsaugoję šią struktūrą, galite užregistruoti galutinę klasę. Nėra tų pačių klasių kaip C++. Dabar galite prisiminti, kad tai yra šablonas, kurį užregistravote sistemoje, ir dabar pagal šį šabloną galite sukurti naują šabloną. Ir visas šias dienas valdys valdžia, kaip sužinojote iš WNDCLASS struktūrinių pokyčių.
WinAPI: funkcija CreateWindow
Užregistravus naują klasę, jos pagrindu sukuriamos pagrindinės programos (perėjome į kitą tašką). Išbandykite šią papildomą funkciją CreateWindow. Gali būti įžeidžiantis prototipas:
mano c++ kodas HWND CreateWindow(LPCTSTR lpClassName // klasės pavadinimas LPCTSTR lpWindowName // lango pavadinimas (rodomas pavadinime) DWORD dwStyle // lango stilius int x // horizontali koordinatė nuo kairiojo ekrano krašto int y // vertikali koordinatė wow edge screen int nWidth, // lango plotis int nAukštis, // lango aukštis HWND hWndParent, // tėvo langas HMENU hMenu, // meniu aprašymas HINSTANCE hInstance, // programos egzempliorius LPVOID lpParam // parametras pirmą kartą nustatytas į NULL);
Kadangi lango klasei (WNDCLASS struktūrai) suteikiamos pagrindinės lango galios, tai čia yra konkretūs odos lango parametrai: lango dydis, koordinatės...
Ši funkcija pasuka aprašymo langą. Norėdami gauti išsamesnį aprašymą, galite pereiti į langą, kuris yra panašus į identifikatorių.
Atkreipkite dėmesį, kad čia yra daug naujų tipų. Tiesą sakant, visa smarvė sena, tik pervadinta. Pavyzdžiui: HWND nėra perskirstymas į HANDLE tipą, kuris savaip yra perskirstymas į PVOID, kuris taip pat yra perskirstymas į void*. Tiesa palaidota taip giliai! Galų gale, HWND tipas nėra tuštumos ženklas.
Langas sudarytas iš daugelio dalių. Tiesą sakant, kiekvienoje programoje matysite: lango pavadinimą, sistemos meniu (spustelėkite programos piktogramą viršutinėje kairėje lango dalyje), tris sistemos mygtukus, skirtus darbui su langu: užsidega, visas ekranas ir Uždaryti. Be to, praktiškai visada papildomai yra meniu. Likusios ašies tikrai nebus mumyse. Ir, žinoma, didžiąją lango dalį užima vadinamoji. kliento sritis, kurioje klientas dirba.
Tai geriau nei lango režimas. Jei ir toliau treniruosimės su DiectX ilgą laiką, viso ekrano režimo nenaudosime.
Laiškų tvarkymas
Pagrindinis visų pažangių „Windows“ programų pranašumas yra naujinimų apdorojimas.
Pavyzdžiui, kai vartotojas paspaudžia klaviatūros klavišą, sugeneruojamas pranešimas, kad klavišas buvo paspaustas. Tada turėsite eiti į programą, kuri buvo aktyvi, kai paspaudėte klavišą.
Štai turime įvykį – paspaudžiamas klavišas.
Veiksmai gali būti: pelės žymeklio perkėlimas, programų fokusavimo keitimas, klaviatūros klavišų paspaudimas, lango uždarymas. Tai gana turtinga. Duje! Per sekundę operacinėje sistemoje galima sukurti dešimtis pranešimų.
Taigi, jei yra koks nors atsakymas, operacinė sistema generuoja pranešimą: paspaudus klavišą pasikeičia pelės žymeklio koordinatės ir atsidaro naujas langas.
Informaciją gali kurti tiek operacinė sistema, tiek įvairios programos.
Būsimo užsakymo struktūra ir išvaizda:
mano c++ kodas typedef struct tagMSG ( HWND hwnd; // langas, nurodantis UINT pranešimą; // pranešimo kodas WPARAM wParam; // parametras LPARAM lParam; // parametras DWORD laikas; // valanda, kai buvo išsiųstas pranešimas POINT pt; // koordinatės pelės žymeklis) MSG;
Atkreipkite dėmesį į tai, kad struktūros priskiriamos iš naujo naudojant typedefs.
Norėdami sukurti šią struktūrą, galite greitai naudoti šį kodą:
mano c++ kodas msg.messgae == 2; // tai dvi lygiaverčių fragmentų eilutės msg.message == WM_DESTROY; // pastovus WM_DESTROY senas du
Čia yra laukas, kuriame yra pranešimo kodas (pranešimo pavadinimas lygus WM_DESTROY konstantai. WM – Windows Message (Windows posistemyje). WM_DESTROY – tai pranešimas, kuris generuojamas uždarius langą (sunaikinti – išsaugoti). ).
Kodai nurodyti po papildomomis konstantomis ir WM_ priešdėliu: WM_CLOSE, WM_CREATE ir kt.
MSG struktūra turi HWND tipą – Window Handle (lango rankena ir lango aprašymas). Tai toks dalykas, kuris apibūdina pasaulį. Kaina nurodyta už ID simbolį (lango pavadinimą).
Prisiminkite šį žodį - rankena (apibūdinkite, aprašykite). Sistemoje Windows tai labai dažna piktnaudžiavimo tema. Be to, visų tipų Windows, prasidedantys raide H, yra aprašymai: piktogramos aprašymas, šrifto aprašymas, programos egzemplioriaus aprašymas. Jų, kiek pamenu, yra apie trisdešimt.
Visa „Windows“ programų sąveika vyksta naudojant šiuos langų aprašymus (HWND).
Yra dar vienas svarbus deskriptorius – programos deskriptorius (HINSTANCE – pirmasis WinMain parametras) – tai unikalus programos identifikatorius, nes jokia operacinė sistema negali sumaišyti dviejų skirtingų programų. Tai maždaug kaip brūkšninis kodas. Pažiūrėsime vėliau.
Iš karto, kai atliekate bet kokį veiksmą, sukuriamas ir įsimenamas pranešimas: nustatomas aprašymo langas, kuriame galite atšaukti pranešimą, nustatomas pranešimo ID, išsaugomi parametrai, išsaugoma užsakymo valanda (dabartinė) Suraskite koordinates pelės žymeklį (žr. struktūrą).
Po šio pranešimo eikite į kitą operacinės sistemos pranešimą. Kalbant apie mūsų informaciją, ji bus išsiųsta į reikiamą langą („Windows“ žino, kaip siųsti odos informaciją specialistams). Jei žinote apie programas, turėsite būti informuoti apie programas. Sunku patekti į dugną, darosi nuobodu.
Nuostabu, kad šiuo momentu, kai vartotojas atliko kokį nors veiksmą (buvo rodomas pranešimas ir buvo sugeneruotas pranešimas) ir šiuo momentu, kai programa sureagavo į šį veiksmą (pranešimą sugeneravo programa), yra daug informacijos. Net jei naudojate „Windows“, daug informacijos galite gauti ir iš programų. Pirmajame gali būti apie šimtus, kitame gali būti bent keli.
Langų procedūra – WndProc
Tęsiame nuo informacijos išnaudojimo momento iki programos pabaigos. Tiesiog dar daug laiko, ir jis pradeda byrėti. Apdorojant atkreipkite dėmesį, kad odos programa turi specialią funkciją – lango procedūrą. Jis vadinamas WndProc (iš Window Procedure). Išplėtimo procedūros langas vykdomas pagrindinėje programos cikle ir baigiamas kiekvienos ciklo iteracijos metu.
Informacija (struktūrinių pakeitimų MSG pavidalu) šiai funkcijai taikoma parametrų forma: lango aprašymas, pranešimo identifikatorius ir du parametrai. Atkreipkite dėmesį, kad laikas ir pt laukai neperduodami lango procedūrai. Totto, leiskite man pasakyti, tai jau "rozіbran".
Lango procedūros viduryje jungiklis pašalinamas, todėl reikia patikrinti pranešimo ID. Ašis yra paprastos lango procedūros pavyzdys (visiškai veikia):
mano c++ kodas// nešvaistykite laiko HRESULT ir __stdcall. Pažiūrėsime į juos vėliau. ) // kompiliatorius nusprendžia informuoti )
Likau aš – pagrindinis ciklas. Vin yra dar paprastesnis. Kiekvieną ciklo iteraciją patikrina programa. Kai tik turi informacijos, tave ji traukia. Tada ciklas bus paragintas spustelėti lango procedūrą, kad apdorotų informaciją.
Ašis įsibėgėja ir viskas šiai dienai. Jau dabar aišku, kad programa pagal WinAPI yra daug panašesnė į programą pagal DOS. Kaip jau rašiau, ateinančioje pamokoje pažiūrėsime į veikiančios programos kodą.
Turiu teisę kurti naują projektą. Naujo projekto lange pasirinkite šabloną – Win32Project (anksčiau pasirinkome Win32 Console Application). Viename iš būsimų langų nenustatykite Empty Project vėliavėlės ir IDE sugeneruos paruoštą programą.
Jei atidžiai pažvelgsite į kodą faile project_name.cpp, pamatysite viską, ką aptarėme: MSG struktūros pakeitimą, WNDCLASS struktūros užpildymą, lango sukūrimą naudojant funkciją CreateWindow, pagrindinę programos kilpą. . Be to, failui priskiriama WndProc funkcija. Perjungimo laukeliuose turite apdoroti daugybę informacijos: WM_COMMAND, WM_PAINT, WM_DESTROY. Raskite viską faile.
Be to, ką matėme, programoje yra daug papildomo kodo. Kitoje laidoje pažiūrėsime į programos kodą, kad viskas būtų patikrinta. Tai bus daug paprastesnė ir protingesnė nei tai, ką sukuria IDE.
Atsisakymas
Maniau, kad WinAPI pasirodys visai šalia. Jau seniai aišku, kad kelių platformų karkasų yra labai daug, „Windows“ yra ne tik staliniuose kompiuteriuose, o pati „Microsoft“ savo parduotuvėje negaili priedų, kurie išteisintų šį monstrą. Yra tūkstančiai straipsnių apie tai, kaip kurti naudojant WinAPI, ne tik čia, bet ir visame internete, kurių skaičius siekia tūkstančius tiek ikimokyklinio amžiaus, tiek vėliau. Visas skrodimo procesas grindžiamas nebe atomais, o subatominėmis dalelėmis. Kas gali būti paprasčiau ir protingiau? Ir štai aš...
Tačiau ne viskas taip paprasta, kaip atrodo.
Kodėl apie WinAPI dabar?
Vieną dieną, kai mane išsekino tas pats geras dalykas, pagalvojau: kas čia per velnias, o redaktoriuje nėra tokios paprastos kalbos, kaip naršyti klaviatūros mygtukais, kaip bet kuriame įprastame redaktoriuje.Apie ką aš kalbu? Ir ašies kodas:
WM_KEYDOWN atvejis: MessageBox(hwndDlg,"Mirk!","Aš miręs!",MB_YESNO|MB_ICONINFORMATION);
Tokiu būdu autoriai norėjo pridėti klaviatūros palaikymą, tačiau „Windows“ dialogo langų architektūros realybė griežtai nubaudė už tokį savivaliavimą. Ar kas nors naudojo emuliatorių ar valdiklį, ar norėtumėte tai sužinoti?
Kokia problema?
Atsakymas yra toks: tu negali taip dirbti!
Ir grįžtant prie „WinAPI“ burbuolės kanalo: yra per daug populiarių ir ne tiek daug projektų, kad būtų galima tęsti šio projekto vikoravimą šiuo metu, nes Trumpai tariant, jūs negalite daug kalbėti apie gryną API (čia galite be galo piešti analogijas su aukštos kokybės kalbos ir asemblerio išlyginimu, bet visai ne). Kodėl gi ne? Tiesiog vikoristas ir tiek.
Apie problemą
Su dialogo langais dirbti lengviau nei su GUI, tuo pačiu suteikiant mums galimybę viską atlikti patiems. Pavyzdžiui, informacija WM_KEYDOWN/WM_KEYUP, kuri randama lango procedūroje, randama DefDlgProc poskyriuose, įskaitant tokius žodžius kaip: Naršymas skirtuku, Esc apdorojimas, Enter klavišai ir kt. Be to, jums nereikia kurti dialogų rankiniu būdu: tiesiog pridėkite mygtukus, sąrašus, išteklių rengyklę, spustelėkite WinMain CreateDialog/DialogBox ir viskas.Lengva apeiti tokias kitas paslaptis. Ir bent du visiškai legalūs būdai:
- Sukurkite savo klasę naudodami RegisterClassEx ir pridėkite WM_KEYDOWN į klasės apdorojimo procedūrą ir nukreipkite ją į pačią dialogo apdorojimo procedūrą. Taip ir taip! Galite kurti dialogus su savo klase ir naudoti VS redaktorių, leidžiantį nustatyti dialogo klasės pavadinimą. Ar kas nors apie tai žino ir yra savanaudis?
Akivaizdus trūkumas: Būtina registruoti dar vieną klasę, todėl yra dar 1 CALLBACK procedūra, kurios esmė bus prarasta lažybų transliacijoje. Be to, mes nežinome kudi Jie bus peržengti, o policija lauks. - Vikoristovat akceleratoriaus mechanizmo įgyvendinimas. Ir mums niekada nereikės keisti dialogo procedūros kodo! Na, kodėl nepridėjus vienos eilės prie jungiklio/dėklo, bet kaina mažesnė.
Pamokos?
Aš nebijau to pasakyti Ūsai Langų kūrimo per WinAPI vadovėliai prasideda tokiu paprastu kodu, nurodant, kaip pranešama apie apdorojimo ciklą (praleisiu langų klasės paruošimo ir kitų ryšių detales):Nors (GetMessage(&msg, nullptr, 0, 0)) ( TranslateMessage(&msg; DispatchMessage(&msg); )
Čia viskas labai paprasta:
- GetMessage() šaukia velnio žinią ir Pagrindinė mintis: blokuoja srautą, nes jis tuščias
- TranslateMessage() su WM_KEYDOWN/WM_KEYUP suformuoja pranešimą WM_CHAR/WM_SYSCHAR (tai būtina, jei norite sukurti savo teksto rengyklę).
- DispatchMessage() siunčia pranešimą į lango procedūrą (tokia, kokia ji yra).
Todėl grąžinamoji vertė gali būti ne nulis, nulis arba -1, venkite tokio kodo:І Nukreipkite užpakalį žemiau tinkamu ciklu.
while (GetMessage(lpMsg, hWnd, 0, 0)) ...
Varto sakė, kad VS šablonai, skirti Win32, turi tuos pačius rašybos papildymus negerai ciklas. Ir tai tikrai beprotiška. Nors mažai kas gilinasi į tai, ką patys autoriai sudarė, tai a priori teisinga. O neteisingas kodas dauginasi iš klaidų, kurias labai sunku pagauti.
Po šio kodo fragmento, kaip taisyklė, vyksta diskusija apie greitintuvus ir pridedama pora naujų eilučių (atsižvelgiant į MSDN, raginu parašyti teisingą kilpą):
HACCEL hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR)); BOOL bRet = 0; while (bRet = GetMessage(&msg, nullptr, 0, 0)) ( if (-1 == bRet) break; if (!TranslateAccelerator(msg.hwnd, hAccel, &msg)) ( TranslateMessage(&msg); DispatchMes ; ) )
Man dažniausiai patinka šis variantas. aš vin ( ta-dam) Znovu klysta!
Pakalbėsiu apie tuos, kurie pasikeitė (ir tada apie šio kodo problemas):
Pirmoje išteklių eilutėje pasirenkama raktų lentelė, o spustelėjus bet kurį iš formatų, bus rodomas pranešimas WM_COMMAND su atitinkamu komandos ID.
Štai ką „TranslateAccelerator“ daro: kaip nuskaityti WM_KEYDOWN ir šiame sąraše esantį rakto kodą, tada (vėlgi pagrindinis taškas) suformatuoti WM_COMMAND (MAKEWPARAM(id, 1)) pranešimą ir išsiųsti jį tipams One day for the window rankena nurodyta pirmame argumente , apdorojimo procedūros.
Su likusia fraze, manau, paaiškėjo, kokia buvo ankstesnio kodo problema.
Leiskite paaiškinti: GetMessage yra pasirinktas VISIEMS „lango“ tipo objektams (įskaitant antrines: mygtukus, sąrašus ir pan.), o „TranslateAccelerator“ kur išsiųs sugeneruotą WM_COMMAND? Teisingai: grįžkite į mygtuką / sąrašą. Prie procedūros pridedame WM_COMMAND, o tai reiškia, kad turime ją iš jos pašalinti.
Pasirodo, mūsų sukurtam langui reikia naudoti TranslateAccelerator:
HWND hMainWnd = CreateWindow(...); HACCEL hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR)); BOOL bRet = 0; while (bRet = GetMessage(&msg, nullptr, 0, 0)) (if (-1 == bRet) break; if (!TranslateAccelerator(hMainWnd, hAccel, &msg)) ( TranslateMessage(&msg); DispatchMess )
O dabar viskas gerai ir puiku: viską smulkiai sutvarkėme ir viskas veikia puikiai.
Aš vėl žinau. :-) Darykime tai teisingai, kol turėsime tik vieną dalyką – savo. Kai tik atsiranda nemodalinis naujas langas (dialogas), visi klavišai, kurie bus paspausti naujame lange, išverčiami į WM_COMMAND ir kur siunčiami? Ir leiskite pasakyti teisingai: mūsų galvos skausmas yra blogas.
Šiame etape patariu neužblokuoti policijos nuo pačios kurčiausios situacijos, o verčiau pažvelgti į kalbas, kurios jau yra anksčiau (arba gali būti neišaiškintos) pamokose.
IsDialogMessage
Remdamiesi šios funkcijos pavadinimu, galite manyti, kad tai reiškia: žinoti apie bet kokį dialogą. Ale, visų pirma, ką tu žinai? Kitaip tariant, kokia šios informacijos vertė?Tikrai verta mokėti šiek tiek daugiau, tai išsiskiria iš pavadinimo. Ir sau:
- Vaikų valdiklius galite naršyti naudodami mygtukus Tab / Shift + Tab / Aukštyn / Žemyn / Dešinėn / Kairėn. Be to, mums užtenka dar kažko
- Paspaudus ESC, susidaro WM_COMMAND(IDCANCEL)
- Paspaudus Enter, susidaro WM_COMMAND(IDOK) arba paspaudus mygtuką eilutėje
- Keičia mygtukus už jungčių (tokių mygtukų rėmas yra šiek tiek šviesesnis nei kitų)
- Na, ir dar daugiau skirtingų dalykų, kurie korespondento robotui palengvina dialogą
Kitu būdu galime palengvinti gyvenimą už sąraše išvardintų taškų (ir dar kelių) grotų.
Vzagali, jūs vikoristuojate čia, „Windows“ viršuje, siekdami roboto saugumo modaliniai dialogo langai, o programuotojams suteikiama galimybė spustelėti juos nemodaliniams dialogams. Tačiau galime tai panaudoti kaip gerą priemonę:
Be to, funkcijos dialogo funkcija naudojama dialogo langams modeliuoti, ją galite naudoti su bet kokiu langu, kad ženklai būtų nustatyti languose, kad būtų pasirinkta pati klaviatūra, todėl dialogo lange Galimas.Tobto. Dabar suformatuokime kilpą taip:
HWND hMainWnd = CreateWindow(...); HACCEL hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR)); BOOL bRet = 0; while (bRet = GetMessage(&msg, nullptr, 0, 0)) ( if (-1 == bRet) break; if (!TranslateAccelerator(hMainWnd, hAccel, &msg)) ( if (!IsDialogMessage(hMainWnd) TranslateMessage(&msg) ; DispatchMessage(&msg);
Tada pagaliau naudosime navigaciją, kaip ir kituose „Windows“ dialoguose. Tačiau dabar mus atėmė du trūkumai:
- Šis kodas taip pat bus maloniai naudojamas su vienu (nemodaliniu) langu;
- Atėmę visus dialogo naršymo privalumus, prie rodinio turime pridėti WM_KEYDOWN/WM_KEYUP (tik pačiam langui, o ne vaikų valdikliams);
Tai pirmas dalykas, paskelbtas „Google“ arba internete: jų tūkstančiai. Apie siūlomą sprendimą (svarbiausia – sukurti savo dialogų klasę, apie kurią rašiau aukščiau, subclassing ir RegisterHotKey. Čia išmoksiu „trumpiausią“ metodą: vikorize Windows Hooks).
Atėjo laikas kalbėti apie tai, ko trūksta vadovėliuose ir vaizdo įrašuose.
Paprastai (kaip taisyklė! Jei kas nori daugiau, galite užregistruoti savo klasę dialogams ir taip dirbti. O jei nerūpi, galiu pridėti šį straipsnį) WM_KEYDOWN jei norite apdoroti spaudimą, paspauskite klavišą pasirinkti funkciją nepriklausomai nuo valdymo biure – tai yra. Tai yra gyvybiškai svarbi šio dialogo funkcija. Jei taip yra, kodėl gi nepasinaudojus gausiomis galimybėmis, kurias mums suteikia pati WinAPI: TranslateAccelerator.
Per vikoryst lygiai vienas greitintuvų lentelė ir net pagrindinis langas. Na, tiesą sakant: yra tik vienas GetMessage ciklo ciklas ir tik viena lentelė. Kur jie turėtų eiti?
Tiesą sakant, GetMessage kilpos gali būti įnašų. Dar kartą pasigrožėkime „PostQuitMessage“ aprašymu:
Funkcijos PostQuitMessage paskelbia WM_QUIT pranešimą gijos pranešimų eilėje ir iškart grįžta;Gaunu pranešimą:
Jei funkcija yra atnaujinti WM_QUIT pranešimą, grąžinama vertė yra nulis.Taigi įvyksta išėjimas iš GetMessage ciklo, kaip lango procedūroje vadiname PostQuitMessage. Ką tai reiškia?
Mes galime už odos nemodalinis Tai yra langas, skirtas mūsų programai sukurti savo galios ciklą. Jei DialogBoxParam mums tinka, nes Mums neįmanoma susukti savo drėgmės ciklo. Tačiau jei kuriate dialogo langą naudodami CreateDialogBoxParam arba langą naudodami CreateWindow, galite paleisti kitą ciklą. Kai kalbama apie odos Norėdami pradėti tokį dialogą, turime spustelėti PostQuitMessage:
HWND hMainWnd = CreateWindow(...); HACCEL hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR)); BOOL bRet = 0; while (bRet = GetMessage(&msg, nullptr, 0, 0)) ( if (-1 == bRet) break; if (!TranslateAccelerator(hMainWnd, hAccel, &msg)) ( if (!IsDialogMessage(hMainWnd) TranslateMessage(&msg) ; DispatchMessage(&msg); ))) // .... hInstance, MAKEINTRESOURCE(IDD_MYDIALOG), hwnd, MyDialogBoxProc), HACCEL hAccel = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR_FOR_MY_DIALOG)); wnd, FALSE);// išjungti pirminį langą, nes dialogo langas yra modalinis while (bRet = GetMessage(&msg, nullptr, 0, 0)) ( if (-1 == bRet) break; if (!TranslateAccelerator(hDlg, hAccel) , &msg)) ( if (!IsDia , &msg)) ( TranslateMessage(&msg; DispatchMessage(&msg); ) ) ) EnableWindow(hwnd, fSavedEnabledState); // Įgalinti pirminį langą. wparam, LPARAM lparam) (switch(umsg) (atvejis WM_CLOSE: (// EndDialog(hwnd, 0)); - NEDARYK TO! // EndDialog tinka tik modifikuojant dialogus, sukurtus naudojant DialogBox(Param) DestroyWindow(hwnd) ; break ) case WM_DESTROY: ( PostQuitMessage(0); break; ) // .... ) return 0; )
Susigrąžinkite pagarbą: dabar galime pridėti naują odos langą mūsų programoje prieš apdorodami Vlasnu akceleratoriaus stalas. WM_QUIT pašalina GetMessage iš dialogo ciklo, o išorinė ciklas neveikia. Kodėl tu taip susijaudinęs?
Dešinėje yra tai, kad dabartinis ciklas „atsistoja“ ant „DispatchMessage“ paspaudimo, kuris yra spustelėjęs mūsų procedūrą, kaip įjungti jo galią vidinis„GetMessage“ ciklas su pačiu „DispatchMessage“. Klasikiniai wiklik priedai (DispatchMessage). Todėl išorinė kilpa neatšaukia WM_QUIT ir baigiasi šiame etape. Viskas vyksta sklandžiai.
Na, čia yra keletas trūkumų:
Odai toks ciklas išnyksta tik „tavo“ langui. Mes nežinome apie kitus čia. Tai reiškia, kad jei čia pasirodys kitas ciklas, visi jie turės apdoroti savo pranešimus naudodami TranslateAccelerator / IsDialogMessage porą.
Na, atėjo laikas atsiimti visą pagarbą ir parašyti bei nuspręsti, kaip teisingai apdoroti viską, kad informuotume jus apie visus mūsų programos rezultatus. Noriu gerbti, kad atlygis už vieną srautą laikomas mažesniu. Nes Jei odos srautas leidžia suvokti savo struktūrą, tada odos srautas turės sukurti savo struktūras. Bijoti net nereikšmingų kodo pakeitimų.
Robimo yra gražus
Nes Jei teisingai nustatyti užduotį yra pusė sprendimo, pirmiausia turiu teisingai nustatyti užduotį.Visų pirma būtų logiška, kad tik aktyvesnis Dabar gaunu pranešimus. Tobto. Neaktyvaus lango atveju mes neverčiame greitintuvo ir nesiunčiame pranešimų IsDialogMessage.
Kitaip, jei langui akceleratoriaus lentelė nenustatyta, tada nėra ką versti, tik pranešimas IsDialogMessage.
Sukurkime paprastą std:: žemėlapį, kuris lango aprašą susietų su greitintuvo lentelės aprašu. Ašis yra tokia:
Std::žemėlapis
O sukurtų langų pasaulyje mes ir toliau įtrauksime naują langą su deskriptoriumi į jūsų mėgstamą lentelę (arba nulį, nes toks apdorojimas nereikalingas).
BOOL AddAccelerators(HWND hWnd, HACCEL hAccel) ( if (IsWindow(hWnd)) ( l_mAccelTable[ hWnd ] = hAccel; return TRUE; ) return FALSE; ) BOOL AddAccelerators(HWNDhW LoadInstanceCcelerators,BOOLacceler(hWNDcceler),BOOLacceler(hWNDcceler); hWnd, int accel)
O uždarę langą eikite šalin. Ašis yra tokia:
Tuščias DelAccel(HWND hWnd) ( std::map
Dabar, kai sukuriame naują dialogo langą / langą, spustelėkite AddAccelerators (hNewDialog, IDR_MY_ACCEL_TABLE). Kaip uždaryti: DelAccel(hNewDialog).
Turime reikalingų aprašų sąrašą. Štai kaip modifikuojame pagrindinę apdorojimo ciklą:
// ... HWND hMainWnd = CreateWindow(...); AddAccelerators(hMainWnd, IDR_ACCELERATOR); BOOL bRet = 0; while (bRet = GetMessage(&msg, nullptr, 0, 0)) ( if (-1 == bRet) break; if (!HandleAccelArray(GetActiveWindow(), msg)) ( TranslateMessage(&msg; DispatchMessage ) // .. .
Daug geriau! Kas yra su HandleAccelArray ir kas toliau su GetActiveWindow()?
Šiek tiek teorijos:
Yra dvi funkcijos, kurios suka aktyvią lango rankenėlę GetForegroundWindow ir GetActiveWindow. Pirmojo svarba prieš kitą išsamiai aprašyta kito aprašyme:
Grąžinimo reikšmė yra aktyvaus lango, prijungto prie iškviečiančios gijos pranešimų eilės, rankena. Kitu atveju grąžinama vertė yra NULL.Jei pirmiausia pasukate bet kurio sistemos lango aprašą, tada tik kiti kaip vikoristo žodis turi informuoti mūsų srautą. Nes Mes ir toliau gyvensime tik savo sraute (o taip pat ir tie, kurie bus iššvaistyti iki mūsų dienų), tada liksime.
Taigi HandleAccelArray ašis, kurią perduoda deskriptorius aktyviame lange, yra labiausiai matoma mūsų žemėlapyje ir tokia, kokia ji yra, siunčia pranešimą TranslateAccelerator transliacijai, o tada (lyg ir nereikalaujama nogo). ) IsDialogMessage. Jei pranešimas dar neišsiųstas, pasukite FALSE, kad atliktumėte standartinę TranslateMessage/DispatchMessage procedūrą.
Tai atrodo taip:
BOOL HandleAccelWindow(std::map
Dabar kiekvienas vaikas turi teisę pridėti savo mėgstamą akceleratoriaus lentelę ir ramiai gaudyti bei įvesti WM_COMMAND su reikiamu kodu.
Kas dar yra vienoje WM_COMMAND kodo eilutėje?
„TranslateAccelerator“ aprašymas:Kad būtų aišku, kad funkcija siuntimas su pranešimais reiškia meniu arba valdiklius, labai efektyvus žodis su wParam parametru WM_COMMAND arba WM_SYSCOMMAND pranešimas turi reikšmę 1.WM_COMMAND apdorojimo kodas atrodo taip:
Switch(HIWORD(wParam)) ( BN_CLICKED: // Komanda iš mygtukų/meniu ( switch(LOWORD(wParam)))) ( IDC_BUTTON1 atvejis: DoButton1Stuff(); pertrauka; IDC_BUTTON2: DoButton2Stuff ) pertrauka; ) )
Dabar galite parašyti taip:
Switch(HIWORD(wParam)) ( 1 atvejis: // greitintuvo dėklas BN_CLICKED // Komanda iš mygtukų/meniu ( jungiklis(LOWORD(wParam)))) ( atvejis IDC_BUTTON1: DoButton1Stuff(); pertrauka; atvejis IDC_BUT // ... ) pertrauka; ) )
O dabar, atsigręžęs į tą patį fceux, pridūręs tik viena eilutė Mygtukų komandų apdorojimo kode pašaliname šiuos dalykus: naudokite klaviatūros derinimo priemonę. Pakanka pridėti nedidelį apvalkalą prie galvos kilpos ir naują greitintuvų lentelę su pavaldiniais VK_KEY => IDC_DEBUGGER_BUTTON.
PS: Nedaug žmonių žino, ar galima sukurti savo greitintuvo lentelę, o dabar ją užšaldyti tiesiogiai.
P.P.S. Nes DialogBox/DialogBoxParam pasuka maitinimo ciklą, tada per juos iškvietus dialogą greitintuvai neveikia ir mūsų ciklas (ar ciklai) yra „neaktyvus“.
P.P.P.S.: Spustelėjus HandleAccelWindow korteles l_mAccelTable galima pakeisti, nes TranslateAccelerator arba IsDialogMessage spustelėkite DispatchMessage ir čia galėsite prisijungti prie AddAccelerators arba DelAccel mūsų procesoriuose! Todėl geriau neignoruoti šių funkcijų.
Galite įvesti kodą. Jis buvo pagrįstas kodu, sugeneruotu iš standartinio MS VS 2017 šablono.
Žymos: pridėti žymų
C WinAPI yra pagrindinis „Microsoft“ programų sąsajų (API) rinkinys, prieinamas operacinėse sistemose Ankstyvoji versija buvo vadinama „Win32 API“.
Įeikite
WinAPI yra programų programavimo sąsaja, naudojama kuriant Windows programas. Pirmiausia kūrėjas turi naudoti Windows SDK, anksčiau vadintą platformos SDK.
Sujunkite antraštės failus, bibliotekas, vaizdus, dokumentus ir įrankius, naudojamus programoms kurti. API, skirta kalbų programavimui C ir C++. Tai yra tiesiausias būdas sukurti priedus įmonės operacinėje sistemoje.
Naudodami WinAPI galite jį suskirstyti į kelias sritis:
Koristuvalnytsky sąsaja;
multimedija;
„Windows“ apvalkalas;
Merezhevy paslaugos.
pagrindinės paslaugos;
sauga;
Pagrindinės paslaugos užtikrins prieigą prie pagrindinių išteklių. Tai apima WinAPI funkcijas, failų sistemas, įrenginius, procesus, gijas, registrą ir klaidų apdorojimą. Saugos srityje yra sąsajų, objektų ir kitų programavimo elementų, skirtų autentifikavimui, autorizacijai, kriptografijai ir kitoms su sauga susijusioms užduotims atlikti. Grafikos posistemis suteikia grafikos rodymo monitoriuose, spausdintuvuose ir kituose rodymo įrenginiuose funkcijas. Tapytojo sąsaja suteiks langų ir tapytojo elementų kūrimo funkcionalumą.
Daugialypės terpės komponentas suteikia įrankius darbui su vaizdo, garso ir įvesties įrenginiais. Shell sąsajos funkcijos leidžia programoms pasiekti operacinės sistemos apvalkalo teikiamas funkcijas. Tinklo paslaugos suteikia maksimalią prieigą prie „Windows“.
Komponentai
Kai veikia WinAPI, turėsite prieigą prie pagrindinių Windows API galimybių, kurias galima suskirstyti į septynias kategorijas. Pažvelkime į jų pranešimo odą.
Pagrindinės paslaugos suteikia prieigą prie pagrindinių „Windows“ sistemos išteklių. Programos: failų sistema, išoriniai įrenginiai, procesai, prieiga prie sistemos registro ir branduolių sistemos. Šios funkcijos saugomos failuose kernel.exe, krnl286.exe arba krnl386.exe 16 bitų sistemoms ir kernel32.dll bei advapi32.dll 32 bitų sistemoms.
Grafinė sąsaja suteiks prieigą prie išteklių, skirtų rodyti monitoriuose, spausdintuvuose ir kitoje išorinėje įrangoje. Jis saugomas faile gdi.exe 16 bitų sistemose ir gdi32.dll 32 bitų sistemose.
Vartotojo sąsajos sąsaja pasižymi pagrindinių elementų, tokių kaip mygtukai ir slinkimas, išvaizda, informacija apie klaviatūrą ir peles bei su jais susijusias funkcijas. Šios funkcijos saugomos faile user.exe 16 bitų sistemose ir user32.dll comctl32.dll 32 bitų sistemose. Pradedant nuo XP versijos, valdikliai yra sugrupuoti į comctl32.dll.
Slapti dialogai – rodomi duomenys, skirti atidaryti ir išsaugoti failus, pasirinkti spalvas ir šriftus. Failas yra comdlg.dll 16 bitų sistemose ir comdlg32.dll 32 bitų sistemose.
„Windows Shell“ yra „WinAPI“ komponentas, leidžiantis programoms pasiekti operacinės sistemos apvalkalo teikiamas funkcijas.
Tinklo paslaugos suteikia prieigą prie maksimalių operacinės sistemos galimybių. Jos subkomponentai apima NetBIOS, Winsock, RPC. Senesnėse versijose yra NetDDE.
Versijos
Win16, Win32 ir Win32s yra standartiniai komponentų rinkiniai, leidžiantys taikomajai programinei įrangai atlikti įvairių Windows šeimos operacinių sistemų funkcijas.
Win32, Win16 įpėdinis, buvo pristatytas 1993 m. Windows šeimos 32 bitų produktuose, tokiuose kaip Windows NT, 2000, 95. Ši programinės įrangos sąsaja įgyvendina tris programinės įrangos bibliotekas: Kernel32.dll, User32.dll ir GDI32.dll2. Tos pačios „Win32“ funkcijos pasiekiamos visuose „Windows“ produktuose ir, priklausomai nuo produkto, pridėjus šias funkcijas gali kilti paslaugų problemų.
Win32 galimybės apima ryšį tarp programų, procesų valdymą, kompiuterio failus, spausdintuvus, serverius ir ryšio prievadus.
Specifikacija
WinAPI yra abstrakti „Windows“ operacinės sistemos programavimo sąsajos specifikacija. Susideda iš funkcijų, jungčių, struktūrų, duomenų tipų, makrokomandų, konstantų ir kitų programavimo elementų deklaracijų. WinAPI aprašomas antraštėje ir yra Windows C antraštėse. Oficialus WinAPI funkcijos įgyvendinimas yra dinaminėse bibliotekose (DLL): pavyzdžiui, kernel32.dll, user32.dll, gdi32.dll ir shell32.dll sistemoje. katalogas. Yra „Windows API“ įdiegtų trečiųjų šalių: ypač „Wine“ ir „ReactOS“ projektai.
Windows API yra dinaminis objektas. Su kiekviena nauja OS versija ir naujinimų paketais funkcijų skaičius palaipsniui auga. Taip pat yra svarbių skirtumų tarp serverio versijų ir operacinės sistemos darbalaukio versijų. Šios funkcijos nėra oficialiai dokumentuotos.
Pelles C
„Pelles C“ yra be programinės įrangos ir greičiausias C kompiliatorius bei integruotas kūrimo variklis (IDE), skirtas C kalbos programavimui. Palaiko 32 bitų „Windows“ (x86) ir 64 bitų „Windows“ (x64). Įgyvendina C99 ir C11 standartus. „Pelles May“ apima išteklių rengyklę, bitų schemą, piktogramą, žymeklio rengyklę ir šešiolikos iškelties rengyklę. Atskleidė Švedijos mažmenininkas Pelle Orinius. Kompiliatoriaus pavadinime nurodytas jo autoriaus vardas. Kartu su SDK programuotojas gali iš karto atspausdinti sukurtą programą be tolesnio diegimo.
Tikslinga architektūra
Norėdami sukurti „Windows API“ programas, turite įjungti „Microsoft“ plėtinius. Už jos sklinda smarvė, dėl kurios kompiliatorius mato pranešimą apie klaidą, tarsi tai būtų C WinAPI programa su sugedusia struktūra: fatal error #1014: #error: "No target architecture". Norėdami įjungti „Microsoft“ plėtinį, eikite į projekto parametrus ir pasirinkite skirtuką „Compiler“. Šiame skirtuke suaktyvinta parinktis „Išjungti Microsoft plėtinius“.
MSDN
Tai yra centrinis „Windows“ diegimo portalas. Tai puikus rinkinys medžiagos, susijusios su programų kūrimu iš įvairių Microsoft įrankių. Išsami duomenų bazė su darbalaukio programų kūrimo dokumentacija ir Windows API sąrašu.
Zastosuvannya DLL WinAPI C
Išplėstinių elementų biblioteka suteiks prieigą prie išplėstinių operacinės sistemos funkcijų, tokių kaip eilutės, langų indikatoriai, įrankių juostos ir skirtukai. Šios komandos yra bibliotekoje commctrl.dll 16 bitų sistemose ir comctl32.dll ir sugrupuotos su kliento sąsaja.
DLL yra dinaminis bibliotekos failo formatas, naudojamas keletui „Windows“ programų kodų ir procedūrų išsaugoti. DLL failai buvo sukurti taip, kad daugelis programų galėtų akimirksniu pasiekti savo informaciją ir taip taupyti atmintį. Leidžia vartotojams redaguoti kodą keliose programose jų nekeičiant. DLL bibliotekos gali būti konvertuojamos į statinę, vikoristinę MSIL Disassembler arba DLL, skirtą Lib 3.00.
„WinAPI“, kaip „Windows“ taikomųjų programų programavimo sąsaja, siūlo paprastas funkcijas, leidžiančias kurti savo programas – nuo paprasto failų apdorojimo iki grafinės sąsajos žemo lygio įrenginių tvarkyklių programavimui.
Prieš pradėdami programuoti su WinAPI, turite nustatyti vidurinį kodą sistemoje Windows. Nors tai nėra „Linux“ platinimas, jame nėra įmontuoto kompiliatoriaus priedams kurti. Pažvelkime į šias kodo sudarymo parinktis:
Galimas kūrėjų rinkinys, skirtas „Windows“, kuriame pateikiama dokumentacija ir įrankiai, leidžiantys kūrėjams kurti programinę įrangą naudojant „Wikimedia“ API ir susijusias technologijas.
Windows API – operacinės sistemos funkcijų rinkinys
API santrumpa daugeliui pradedančiųjų programuotojų atrodo neaiški ir paini. Tiesą sakant, programų programavimo sąsaja (API) yra tik paruoštas funkcijų rinkinys, kurį gali naudoti priedų pardavėjai. Formaliąja prasme ši sąvoka prilygsta tam, kas anksčiau dažnai buvo vadinama subprogramų biblioteka. Tačiau atkreipkite dėmesį, kad pagal API yra speciali tokių bibliotekų kategorija.
Kūrimo proceso metu galutiniam vartotojui suformuojamas specifinių vidinių funkcijų, reikalingų konkrečiai programai įgyvendinti, rinkinys, kuris vadinamas MyApplication API. Tačiau dažnai atrandama, kad šios funkcijos gali būti efektyviai naudojamos kuriant kitas programas, įskaitant kitas programas. Kaip autoriai, remdamiesi savo produkto pardavimo strategija, renkasi mitybą: kodėl leidžia prieiti prie kokio rinkinio išoriniams klientams? Jei patvirtinama, programinės įrangos paketo, kaip teigiamos charakteristikos, aprašyme yra tokia frazė: „Paketas apima išsamų API funkcijų rinkinį“ (arba už papildomus pinigus).
Taigi dažniausiai API yra funkcijų, kurios yra vienos programos dalis, tačiau kurias galima naudoti kitose programose, rinkinys. Pavyzdžiui, „Excel“, be sąsajos galutiniam vartotojui, turi „Excel“ API funkcijų rinkinį, kurį galima pasiekti, pavyzdžiui, naudojant programas, sukurtas naudojant VB.
Akivaizdu, kad „Windows API“ yra funkcijų rinkinys, kuris yra pačios operacinės sistemos dalis ir tuo pat metu yra prieinamas bet kuriai kitai programai, įskaitant parašytą naudojant VB. Šis planas yra visiškai analogiškas sistemos BIOS / DOS nepaisymo rinkiniui, kuris iš tikrųjų yra DOS API.
„Windows API“ funkcionalumo pranašumas, viena vertus, yra daug platesnis nei DOS, kita vertus, jame nėra daug funkcijų, leidžiančių tiesiogiai valdyti kompiuterio resursus, prieinamus programoms ankstesnėje OS. Be to, prisijungimas prie Windows API yra pagrįstas papildomais procedūriniais parametrais, o DOS funkcija pasiekiama per specialią procesoriaus mašinos komandą, pavadintą Interrupt.
Labiausiai reikalinga Win API VB programuotojams
Nepaisant to, kad VB neturi įvairių funkcijų, rimtesnio tobulėjimo procese paaiškėja, kad jų galimybių dažnai neužtenka būtinoms užduotims atlikti. Tokiu atveju naujokai programuotojai dažnai pradeda taupyti VB trūkumus ir galvoti apie įrankio keitimą, neįtardami, kad jų kompiuteryje yra didelis sąnaudų rinkinys ir juos reikia greitai įvesti.
Susipažinus su Win API, paaiškėja, kad yra daug naudotų VB funkcijų, kurios yra ne kas kita, kaip išplėstos iki konkrečių sistemos procedūrų, o tik įdiegtos ta pačia sintaksė kaip ir duota kalba. Atsižvelgiant į greitos API poreikį, galimos parinktys:
- API funkcijos, kurios iš esmės įgyvendinamos VB funkcijų pavidalu. Tačiau laiko ne mažiau, tokiu atveju gali tekti pereiti prie API sąstingio, kad tai leistų greitai padidinti našumą (išskyrus tuos atvejus, kai nėra nereikalingų perkeliamų parametrų pakeitimų).
- Sukurtos VB funkcijos įgyvendinamos tik išorinių API funkcijų dėka. Štai paprastesnis variantas. Pavyzdžiui, funkcija CreateDirectory API turi didesnes galimybes, palyginti su operatoriumi VB MkDir.
- Yra daug API funkcijų, kurios neturi analogų dabartinėje VB kalbos versijoje. Pavyzdžiui, neįmanoma ištrinti katalogo naudojant VB - tam reikia naudoti funkciją DeleteDirectory.
Taip pat reikėtų pažymėti, kad tam tikros API funkcijos (kai kurios iš jų Win API yra net nereikšmingos) negali būti pasiekiamos iš VB programų per daugybę kalbinių sąsajų, pavyzdžiui, dėl to, kad trūksta galimybės dirbti su atminties adresais. Tačiau daugeliu atvejų gali padėti nebanalūs programavimo būdai (tuo pačiu adresu).
Ypatinga autoriaus idėja yra ta, kad užuot išplėtus versiją į VB naudojamų funkcijų versiją, toliau būtų gerai aprašytos dažniausiai naudojamos API funkcijos. Tuo pačiu norėčiau palinkėti kūrėjams nelaukti naujos funkcijos su išplėstomis funkcijomis versijos pasirodymo, o atsižvelgti į originalios Win API atsargas – visiškai aišku, kad jūsų galimybės poreikis gali būti įdiegtas jau ї VB 1.0 versijoje, 1991 m.
Yak vivchati Win API
Ne taip paprasta prisiminti, kad Win32 API funkcijų skaičius yra apie 10 tūkstančių (tikslaus skaičiaus niekas nežino, kaip Microsoft).
VB sandėlyje (4-6 versijos) yra failas su Win API aprašymu - WIN32API.TXT (jos įgyvendinimo ataskaita bus paskelbta vėliau). Ale, in Persher, su jogu, galima išsižadėti Vidomosti dėl tų pačių parametrų atpažinimo vicoristovani mnemoni izmen, o kita vertus-tsomo failo funkcijų perepas toli gražu nedingo. Šiais laikais (kaip pasisekė) VB 3.0 turėjo specialius koncepcijos įrodymo failus, aprašančius Win16 API funkcijas. 4.0 versijoje ši vertinga informacija jau pasiekiama rankinėje sąsajoje.
Papildomos informacijos apie Win32 API galima rasti ankstesniame platformos programinės įrangos kūrimo rinkinyje, kuris taip pat yra MSDN bibliotekos kompaktiniuose diskuose, įtrauktuose į VB 5.0, 6.0 Enterprise Edition ir Office 2000 Developer Edition. Tačiau ten rasti reikiamą informaciją ir ją pasiekti visai nelengva. Net nepaminint, kad visi aprašymai yra sukurti tik C.
Pasaulyje labiausiai žinomas API programavimo VB aplinkoje įvadas yra žinomo amerikiečių eksperto Danielio Applemano knyga. Ši Dano Applemano „Visual Basic Programer's Guide to Windows API“ serija (skirta „Win16“, „Win32“, šimtams skirtingų VB versijų) nuo 1993 m. nuolat tapo VB programuotojų bestseleriu. 1997 metais išleistą knygą Dan Appleman's VB 5.0 Programmer's Guide to the Win32 API autoriui iš JAV atvežė draugas, kuris žinojo apie pirmąjį mažo provincijos miestelio knygyną.
Šioje daugiau nei 1500 puslapių knygoje pateikiamas pažangių API programavimo VB technikų aprašymas, taip pat daugiau nei 900 funkcijų. Kompaktiniame diske bus visas knygos tekstas ir visos programinės įrangos programos, taip pat keletas papildomų skyrių, kurie nepasiekė antrosios versijos. 1999 m. Danas Applemanas išleido naują knygą „Dan Appleman Win32 API Puzzle Book and Tutorial for Visual Basic Programers“, kurioje yra dar 7600 funkcijų apžvalgos (nors ir ne ataskaitų lentos).
„Win API“ ir „Dynamic Link Library“ (DLL)
Win API diegimų rinkinys kaip dinaminės DLL bibliotekos. Toliau mes iš tikrųjų kalbėsime apie DLL diegimo VB viduryje technologiją taikant bibliotekas, kurios yra įtrauktos į Win API sandėlį. Tačiau kalbant apie DLL, būtina užsitarnauti didelę pagarbą.
Šiuo atveju pagal DLL galime gerbti tradicinę dvigubų dinaminių bibliotekų versiją, kuri užtikrina tiesioginį konvertavimą į reikiamas procedūras – paprogrames ar funkcijas (maždaug tiek, kiek tikimasi iškviečiant procedūras VB projekto viduryje ). Tokias bibliotekas galima kurti naudojant kitus įrankius: VC++, Delphi, Fortran ir VB (kuri yra 7.0 versijoje) – likusios gali veikti tik naudojant ActiveX DLL, kurias galima pasiekti per internetinį OLE Automation veidą.
Dinaminės bibliotekos failuose gali būti plėtinys.DLL, tačiau taip yra nebūtinai (Win16 plėtinys.EXE dažnai įstrigo); Išorinių įrenginių tvarkyklės nurodytos papildomoje DRV.
Kaip jau minėjome, svarbu nustatyti tikslų Windows API funkcijų ir failų skaičių, kad juos būtų galima saugoti sistemos kataloge. Šiame plane būtų geriau matyti bibliotekos sandėlį, kuris eina iki operacinės sistemos branduolio, ir pagrindines bibliotekas su pagrindinėmis papildomomis funkcijomis.
Ir dabar aš laimingas.
Prašome 1. Laikykitės teisingo DL skelbimo formatavimo L-procedūros
Programos hierarchija iki DLL procedūrų atrodo taip pat, kaip ir iki „pirminių“ Visual Basic procedūrų, pavyzdžiui:
Skambinti DllName ([argumentų sąrašas])
Tačiau norint naudoti išorines DLL funkcijas (įskaitant Win API), programa turi jas iškviesti naudodama pareiškimą Declare, kuris atrodo taip:
Paskelbkite papildomos procedūros pavadinimą Lib _ „Bibliotekos pavadinimas“ _ [([Argumentų sąrašas])]
Deklaruoti funkcijos funkcijos pavadinimą _ Lib "Bibliotekos pavadinimas" _ [([Argumentų sąrašas])]
Čia, ties kvadratinėmis svirtimis, nurodomi būtini operatoriaus elementai, kursyvu rodomi besikeičiantys žodžiai, kursyvu – pagrindiniai žodžiai. Išplėstinė sistema buvo sukurta taip, kad būtų pateiktas geras operatoriaus sintaksės aprašymas, todėl tam tikri punktai tampa mažiau reikšmingi.
Dauguma išorinių funkcijų yra modulio skiltyje Bendrosios deklaracijos. Jei įdedate jį į formos modulį, turite nurodyti raktinį žodį Privatus (jis bus pasiekiamas tik modulio viduryje) – tai vienoda visoms formos modulio procedūroms.
Win32 API diegimų rinkinys apsiriboja funkcijomis (Win16 API turėjo daug antrinių programų). Tai ypač pasakytina apie Long tipo funkcijas, kurios dažniausiai grąžina operacijos užbaigimo kodą.
Declare operatorius pasirodė MS Basic jau DOS ir buvo naudojamas perduoti vidines procedūras projektui. „Visual Basic“ to nereikia, nes vidinių procedūrų deklaracijose automatiškai aprašomi jų sub ir funkcijų aprašymai. Pritaikytas iš Basic/DOS, naujame aprašyme turi būti nurodytas bibliotekos failo, kuriame yra procedūra, pavadinimas. „Wip“ API bibliotekos yra „Windows“ sistemos kataloge. Viskas, ko reikia, yra failo pavadinimas. Jei dirbate su DLL, norėdami įsitikinti, turėsite parašyti naują kelią į tą failą.
Operatoriaus Declare aprašymas užima daug vietos ir netelpa į vieną eilutę prie kodo lango. Todėl rekomenduojame rašant programas atkreipti dėmesį į bet kokio tipo eilučių perkėlimo schemą, pavyzdžiui:
Nurodykite funkciją GetTempPath _ Lib "kernel32" slapyvardį "GetTempPathA" _ (ByVal nBufferLength As Long, _ ByVal lpBuffer As String) Kaip Long
Ir čia yra aprašyti visi pagrindiniai skirtingų eilučių aprašymo elementai ir gera perskaityti.
Prašome 2. Būkite ypač pagarbūs dirbdami su DLL funkcijomis
Win API ir įvairių DLL funkcijų naudojimas žymiai išplečia VB funkcines galimybes ir dažniausiai leidžia padidinti programos našumą. Tačiau kaina, kurią reikia mokėti už tokią kainą, yra robotinių programų patikimumo sumažėjimas, ypač kūrimo proceso metu.
Vienas iš svarbiausių VB tarpinės programinės įrangos privalumų yra programos kūrimo proceso patikimumas: veikiant interpretatoriaus karkasui, programos kodu teoriškai neįmanoma sulaužyti Windows ir VB roboto. Programuotojas gali būti nelabai atsargus dėl parametrų perdavimo iškviečiamai funkcijai teisingumo – tokias klaidas nesunkiai aptiks pats vertėjas tiek versdamas kodą, tiek jį vykdydamas. Blogiausiu atveju tiesiog nutrūks apdorojimo režimas, kalbant apie prasmę, kur ir kas atsitiko.
Naudojant tiesiogines Windows API ar kitų DLL bibliotekų funkcijas, galima valdyti duomenų perdavimą ir sujungimo į kodą procesą už VB vidurio ribų. Todėl išorinių funkcijų kompromisas gali sukelti VB ir operacinės sistemos gedimą. Tai ypač svarbu programos kūrimo etape, jei naudos buvimas yra visiškai natūralus. Taigi, dėl plataus bazinės sistemos funkcijų spektro, programuotojas prisiima atsakomybę už jų įgyvendinimo teisingumą.
Problemą dar labiau apsunkina tai, kad skirtingos programos skirtingai perduoda parametrus tarp procedūrų. (Tiksliau diskutuojama apie skirtingus perdavimo būdus, nes daugelis iš mūsų gali palaikyti daugybę metodų.) Win API yra įdiegta C/C++ ir reikia kalbėti apie šioje sistemoje priimtų parametrų perdavimą, nes yra klasifikuojami. kaip pirminis VB variantas.
Ryšium su tuo pažymėtina, kad API funkcijų VB analogų atsiradimas pateisinamas likusių pritaikymu VB sintaksei ir panašaus duomenų mainų valdymo mechanizmo įdiegimu. Taip pat vertiname, kad galutiniame programų kūrimo etape, kuriant sukompiliuotą modulį, geriau pasirinkti kompiliavimo parinktį P-kodas, o ne Native Code (mašinos kodas). Iš pradžių programa veikia valdoma vertėjo – o ne naudojant mašininį kodą, bet geriausia – žiūrint į operacinę sistemą ir užtikrinant rankinį režimą galimoms klaidoms nustatyti.
Porada 3. Dešimt Dano Applemano rekomendacijų dėl patikimo API programavimo VB tarpinėje programinėje įrangoje
Įvairioms API funkcijoms reikia kruopštesnio programavimo, naudojant kai kuriuos ne tokius paprastus procedūrų mastelio padidinimo metodus (palyginti su VB). Mes palaipsniui badaujame nuo šio maisto. O dabar pateiksime Dano Applemano diskusijų šia tema santrauką (pirmoji versija pasirodė dar 1993 m.) su kai kuriais papildomais komentarais.
1. Prisiminkite apie ByVal. Dažniausia problema, kylanti, kai API ir DLL įdiegiami prieš funkcijas, slypi neteisingame ByVal raktinio žodžio žodyne: jie arba pamiršta jį įdėti, arba galiausiai įdeda, kai to nereikia.
Šie pavyzdžiai rodo ByVal operatoriaus įvestį parametrams perduoti
| Parametrų tipas | Z ByVal | Be ByVal |
|---|---|---|
| Sveikasis skaičius | Stacko talpa yra 16 bitų | Į krūvą gali tilpti 32 bitų 16 bitų sveikojo skaičiaus adresai |
| Ilgai | Stackas turi 32 bitų talpą | Į krūvą gali tilpti 32 bitų sveikojo skaičiaus 32 bitų adresai |
| Styga | Seka konvertuojama į formatą, kuris naudojamas C (atsižvelgiant į nulinį baitą). 32 bitų naujos eilutės adresai dedami į krūvą | Kiemelyje yra eilutės VB deskriptorius. (Tokių deskriptorių niekada neatpažįsta pati Windows API ir jie atpažįstami tik DLL, įdiegtuose specialiai VB.) |
Čia verta paminėti, kad parametrų perdavimą bet kurioje programavimo sistemoje, taip pat ir VB, lemia du pagrindiniai žingsniai: siuntimas (ByRef) arba reikšmė (ByVal). Pirmasis variantas gauna biržos adresą (šis variantas naudojamas VB mainams), kitas – jo vertę. Galiojimo principas slypi tame, kad po papildomo pranešimo užtikrinama, kad skambinanti programa bus grąžinta į pakeistą perduodamo parametro reikšmę.
Norėdami pradėti, atlikite eksperimentą naudodami šias programas:
Dim v As Integer v = 2 Iškvieskite MyProc(v) MsgBox “v = “ & v Sub MyProc (v Kaip sveikasis skaičius) v = v + 1 End Sub
Paleidus Viconnya, vikamima užpakalį, ZINSYAM ZMININE, RIVNE 3 vertės. Dešinėje, Danijos vipad, Zmіnino V adresai, fizikiškai seklios projekcijos, Viclikaє, perduodamos į danus. Dabar pakeiskite procedūros aprašymą į
„Sub MyProc“ („ByVal“ prieš sveikąjį skaičių)
Dėl to paleidus testą pašalinama v = 2, o tai reiškia, kad procedūrai perduodama tik kintamojo išvesties reikšmė – su ja susietų operacijų rezultatas negrąžinamas programai, kuri iškviečia. Vertės perdavimo režimą taip pat galima pakeisti skambučio operatoriaus pagalba taip:
Sub MyProc (v As Integer) ... Skambinti MyProc ((v)) '(v) – rankenos nurodo perdavimo režimą _ už verčių.
Tačiau išplečiant vidines VB procedūras, ByVal raktinio žodžio naudojimas Call pareiškime yra slopinamas - vietoj to blokuojamos apvalios rankos. Štai paaiškinimas.
Klasikinėje versijoje (C, Fortran, Pascal) ByRef ir ByVal režimų svarba priklauso nuo to, kas dedama į duomenų mainų krūvą – mainų adresai ar reikšmės. „Basic“ programinės įrangos emuliacijos „ByVal“ versija istoriškai buvo naudojama - krūvoje visada yra adresai, išskyrus atvejus, kai perduodamos reikšmės, kurioms sukuriamas laiko pokytis. Norint atskirti dvi parinktis (Classic ir Basic), „ByVal“ režimą galima apibūdinti įvairiais būdais. Būtina, BYVAL VB režime vb, pamirštant krūvą aukščiau esančių ženklų: užvaldę žvėries formą, lichėjaus programą, vicliką, apsisukti (abo neapsuka) Zmininovo vileniją. . „Klasikinėje“ versijoje tokia painiava gali sukelti mirtiną mirtį per valandą po užbaigimo (pavyzdžiui, jei vietoj vikoristo atminties adreso yra keičiamos reikšmės, lygios, tarkime, nuliui ).
DLL funkcijos yra įgyvendinamos pagal „klasikinius“ principus, todėl reikia aiškiai aprašyti, kaip keičiamasi duomenimis su kiekvienu argumentu. Tai pati gali būti naudojama kaip deklaravimo funkcija per Declare aprašą (tiksliau, perduodamų argumentų sąrašą). Dažniausiai parametrų perdavimas Windows API funkcijai arba DLL nurodomas naudojant ByVal raktinį žodį. Be to, jį galima nurodyti operatoriuje Declare arba tiesiogiai iškviečiant funkciją.
Neteisingo parametrų perdavimo palikimą lengva perkelti. Jei pasirinksite akivaizdžiai neteisingą adresą, pamatysite GPF (bendros apsaugos gedimo) pranešimą. Kadangi funkcija nuskaito vertes, kurios nepalieka galiojančio adreso, API funkcija patenka į svetimą sritį (pavyzdžiui, į „Windows“ branduolį) su visomis katastrofiškomis pasekmėmis.
2. Pakeiskite perduodamų parametrų tipą. Ne mažiau svarbu yra teisingas perduodamų parametrų skaičius ir tipas. Būtina, kad Declare deklaruojami argumentai atitiktų API funkcijos parametrus. Didžiausia problema perduodant parametrus yra susijusi su skirtumu tarp NULL ir nulių eilės – atminties pėdsako, kuris yra vienas ir tas pats.
3. Patikrinkite pasukamos vertės tipą.
VB toleruoja reikšmių, kurias suka funkcija, tipų įvairovę, o kai kurios skaitinės reikšmės pasukamos per registrus, o ne per krūvą. Šios taisyklės padės nustatyti teisingas reikšmes, kurias grąžina API funkcija:
- DLL funkcija, kuri nepasuka reikšmių (analogiškai negaliojančia „C“), gali būti nutildyta kaip VB Sub.
- API funkcija, kuri suka reikšmę (Sveikasis skaičius arba Ilgas), gali būti priskirta arba kaip pogrupis, arba kaip funkcija, sukanti konkretaus tipo reikšmes.
- Ši API funkcija nepasuka slankiojo kablelio skaičių, tačiau DLL gali pasukti tokio tipo duomenis.
4. Labai atsargiai naudokite „As Any“ konstrukciją. Daugelis Windows API funkcijų turi galimybę priimti skirtingų tipų parametrus ir naudoti juos pagal konstrukciją As Any (tipo interpretacija priklauso nuo kitų perduodamų parametrų reikšmės).
Geri sprendimai gali turėti keletą slapyvardžių (Alias) funkcijų kiekvienu atveju, du ar daugiau iš jų turi tas pačias funkcijas, o kiekvienas aprašymas turi parametrą ir dainavimo tipą.
5. Nepamirškite inicijuoti eilučių. Win API turi paprastą funkciją, kuri sukasi informaciją rinkdama duomenis iš eilučių buferių, kurie perduodami kaip parametras. Savo programoje viską galite padaryti teisingai: nepamirškite apie ByVal, teisingai perduokite parametrus funkcijai. Tačiau „Windows“ negali patikėti, koks didelis yra matomos saugyklos vietos. Eilutės dydis turi būti pakankamas, kad tilptų visi joje esantys duomenys. Atsakomybė už reikiamo dydžio buferio rezervavimą tenka VB programuotojui.
Atkreipkite dėmesį, kad 32 bitų „Windows“ su skirtingomis eilutėmis galima konvertuoti iš Unicode (dviejų baitų kodavimo) į ANSI (vieno baito kodavimą) ir atgal, priklausomai nuo nacionalinės sistemos nustatymų. Todėl norint rezervuoti buferius, dažnai saugiau naudoti baitų masyvus, o ne įprastus. (Ataskaita apie tai bus aptarta toliau.)
Dauguma Win API funkcijų leidžia patiems nustatyti maksimalų bloko dydį. Pavyzdžiui, norint nurodyti bloko dydį, reikia iškviesti kitą API funkciją. Pavyzdžiui, „GetWindowTextLength“ leidžia nustatyti eilutės dydį, reikalingą „GetWindowText“ funkcijos lango pavadinimui įdėti. Dėl šios priežasties „Windows“ garantuoja, kad neperžengsite sienos.
6. Vikorize Option Explicit abiem kalbomis.
7. Atidžiai patikrinkite parametrų reikšmes ir vertes, kurios yra pasukamos. VB turi galimybę patikrinti tipus. Tai reiškia, kad jei bandysite perduoti neteisingą parametrą VB funkcijai, blogiausia, kas gali nutikti, yra tai, kad atmesite VB klaidos pranešimą. Deja, šis mechanizmas neveikia atnaujinus į Windows API funkciją.
„Windows 9x“ turi sudėtingą daugumos API funkcijų parametrų tikrinimo sistemą. Todėl malonės buvimas šiuose duomenyse nereiškia mirtinos žalos atlyginimo, tačiau nustatyti, kas tai sukėlė, nėra taip paprasta.
Čia galite rasti keletą būdų, kaip pagerinti šios rūšies pieną:
- Patikrinkite odos koregavimo režimą arba Debug.Print, kad patikrintumėte API funkcijos odos reakciją. Peržiūrėkite šių paspaudimų rezultatus, kad įsitikintumėte, jog viskas yra normaliose ribose ir funkcija tinkamai atlikta;
- „Vikorist“ yra „Windows“ pagrindu sukurtas kūrėjas, pvz., „CodeView“ ir pritaikyta „Windows“ versija (iš „Windows“ SDK). Šios funkcijos gali aptikti parametrų keitimą ir, svarbiausia, nustatyti, kurią API funkciją reikia keisti;
- Patikrinkite papildomas trečiųjų šalių įmonių funkcijas, kad patikrintumėte parametrų tipus ir jų verčių priimtinumą. Tokiais metodais galima ne tik rasti parametrų pakeitimus, bet ir nurodyti VB kodui, kur buvo atliktas pakeitimas.
Be to, būtina atidžiai patikrinti API funkcijos rezultatą.
8. Atminkite, kad VB ir Windows skaičiai nėra vienodi. Pirmiausia prisiminkime, kad terminas „Sveikasis skaičius“ VB reiškia 16 bitų skaičių, o Win 32 dokumentacijoje – 32 bitų skaičių. Kitu būdu sveikieji skaičiai (Sveikasis skaičius ir ilgis) VB nėra reikšmės be ženklo (vienas skaitmuo naudojamas kaip ženklas, kitas kaip skaičiaus mantisa), sistemoje Windows - naudojami net nežinomi skaičiai. Į šią situaciją reikia atsižvelgti, jei parametrą formuojate naudodami papildomas aritmetines operacijas (pavyzdžiui, apskaičiuojant adresą naudojant papildomą bazės ir poslinkio pakeitimą). Kuriems standartinės VB aritmetinės funkcijos netinka. Kodėl bijote šios situacijos, pakalbėkime apie tai.
9. Būkite atsargūs su funkcijų pavadinimais. Win16 visų Win32 API funkcijų pavadinimai yra jautrūs tiksliam mažųjų ir didžiųjų raidžių pokyčiams (Win16 to neturėjo). Jei vietoj puikaus rašiklio dedate mažą rašiklį, reikiama funkcija nebus rasta. Taip pat atkreipkite dėmesį į teisingą priesagą A arba W funkcijose, kad nustatytumėte eilutės parametrus. (Ataskaita apie tai – skirsnis žemiau.)
10. Kuo dažniau išsaugokite savo darbo rezultatus. Gedimai, susiję su neteisingais DLL ir Win API scenarijais, gali sukelti VB tarpinės programinės įrangos ir galbūt visos operacinės sistemos gedimą. Atkreipkite dėmesį, kad jūsų kodas būtų išsaugotas prieš bandomąjį paleidimą. Paprasčiausia prieš pradedant projektą VB aplinkoje nustatyti automatinio modulių rašymo į projektą režimą.
Perskaitę ankstesnį, galite padaryti išvadą, kad Win API funkcija pašalinta iš dešinės. Beje, tai tiesa, bet tik pagal saugų programavimą, kurį teikia pats VB. Tačiau esant nedideliam sąstingiui ir žinomoms galimoms kliūtims ši rizika yra minimali. Be to, dažnai tiesiog neįmanoma susidoroti su „Win API“ sąstingiu – jos vis tiek prireiks rimtos plėtros atveju.
Prieš tai mes galvojome apie „povandeninius“ akmenis, skirtus plačiajai DLL klasei. Su Win API viskas yra daug paprasčiau, nes šių funkcijų įgyvendinimo forma yra aiškiai suvienodinta. Štai pagrindiniai dalykai, į kuriuos reikia atsižvelgti į motinos pagarbą:
- Win32 API funkcijos yra funkcijos arba funkcijos funkcijos tipo procedūros (Win16 API turėjo daug antrinių programų). Visos funkcijos yra ilgio tipo, todėl jų aprašymai rašomi tokia forma: Declare Function name... As Long ‘funkcijos tipas _ nurodytas aiškioje formoje
Deklaruoti funkcijos pavadinimą & 'funkcijos tipą _ nurodo papildoma priesaga
Konvertavimas į API funkciją atrodo taip:
Rezultatas& = ApiName& ([ Argumentų sąrašas]
- Svarbiausia pasukama funkcija yra operacijos užbaigimo kodas. Be to, nulinė vertė reiškia įprastą užbaigimą, o nulinė reikšmė reiškia vykdymą. Dar kartą (arba ne anksčiau) galite paaiškinti pakeitimo pobūdį naudodami funkciją GetLastError. Šios funkcijos aprašymas atrodo taip: Deklaruoti funkciją GetLastError& Lib "kernel32" ()
UVAGA! Vidurinėje pusėje esančiame VB robote, skirtame galiojančių atleidimo kodų ryannatei, vicoristovati galia yra galinga Lastdlleror Op'kta Err, GetlasterRor funkcijos bb іnodi vene MIZh pramonėje į API vicuno viconun, tvorų vikunomų vikunkai.
Kodą, kuris generuoja GelLastError, galite interpretuoti naudodami papildomas konstantas, įrašytas API32.TXT faile, kurių pavadinimai prasideda priesaga ERROR_.
Dažniausiai pasitaikantys atakų tipai yra šie kodai:
- ERROR_INVALID_HANDLE = 6& – neteisinga rankena
- ERROR_CALL_NOT_IMPLEMENTED = 120& – „Windows 9x“ funkcijų iškvietimas pasiekiamas tik „Windows NT“
- ERROR_INVALID_PARAMETER = 87& – neteisinga parametro reikšmė
Tačiau yra daugybė funkcijų, leidžiančių pasukti tam tikro parametro reikšmes (pavyzdžiui, „OpenFile“ pasuka failo aprašymo reikšmes). Šiuo atveju reikšmė priskiriama kitoms specialioms Return& reikšmėms, dažniausiai 0 -1.
- „Win32“ API turi griežtai fiksuotus paprasčiausių tipų duomenų perdavimo būdus. a) ByVal...Tas Long
Mažiausiai 80 % argumentų perduodama naudojant ilgąjį tipą. Patikslinkite argumentą pirmiausia yra kartu su ByVal raktiniu žodžiu, ir tai, be kita ko, reiškia, kad yra susietas vienpusis duomenų perdavimas – iš VB programų į API funkciją.
B) ByVal...As String
Šio tipo perdavimas taip pat dažnai įvyksta su tuo pačiu argumentu pirmiausia ByValas įstringa. Kai iškviečiama API funkcija, į krūvą įrašomi eilučių adresai, leidžiantys keistis duomenimis abipusiai. Dirbant eilėmis, būtina pasirūpinti kai kuriomis problemomis.
Pirma, eilučių atminties rezervavimą atlieka iškviečianti programa, todėl jei API funkcija saugos eilutes, tuomet prieš iškviečiant reikia susikurti reikiamo dydžio eilutę. Pavyzdžiui, funkcija GetWindowsDirectory pasuka kelią į Windows katalogą, kuris neturi užimti daugiau nei 144 simbolius. Akivaizdu, kad šios funkcijos įgyvendinimas gali atrodyti maždaug taip:
WinPath$ = Space$(144) ' rezervuota eilutė _ 144 simbolių Result& = GetWindowsDirectory& (WinTath$, 144) _ ' buferio užpildymas ' Rezultatas& – tikrasis simbolių skaičius pavadinimo _ kataloge WinPath$ = Left$(WinPath, Result&)
Kita problema slypi tame, kad API funkciją pavertus API funkcija, jos vidiniame ekrane atkuriama išvesties eilutė, o išėjus iš funkcijos – taip pat. Kaip pirmosiomis „Win16“ dienomis šiai operacijai reikėjo pridėti tik nulinį baitą, pavyzdžiui, eilutę, tada, atsiradus „Win32“, Unicode dviejų baitų kodavimas buvo pakeistas į ANSI ir pan. . (Apie tai buvo pranešta straipsnyje „Robotų su eilučių keitimu VB ypatybės“, Computer Press 10'99 ir 01'2000). Svarbu tik tai, kad ByVal pagalba... Kaip String konstrukcija galima apsikeisti simbolinių duomenų eilėmis.
B) ... Kaip ir bet kuri
Tai reiškia, kad atminties buferio adreso reikšmė bus dedama į krūvą, o interpretacija, o ne tai, ką, pavyzdžiui, apdoros API funkcija, nepriklauso nuo kitų argumentų reikšmės. Tačiau As Any gali būti naudojamas tik operatoriuje Declare – kai taikoma konkreti funkcija, argumentui gali būti suteikta konkreti reikšmė.
D) ... Kaip UserDefinedType
Tokia struktūra taip pat dažnai užstringa, kai reikia keistis duomenimis (pažeidusios šalies pažadas) dėl kokios nors kitos struktūros. Tiesą sakant, šis dizainas yra paprastas konkretaus perdavimo formos „As Any“ diegimo tipas, tiesiog kiekviena funkcija turi fiksuotą struktūrą.
Duomenų struktūros formą lemia konkreti API funkcija, o teisingai juos aprašyti ir rezervuoti ta pačia programa yra atsakinga programa. Tai yra dizainas pirmiausia vikoristas bežodžiai ByVal, tada į šį laukelį pridedamas pavedimas po išsiuntimo - į steką įrašomas mainų adresas.
Prisijunkite prie API funkcijos
Tai iliustruojama naudojant dvi pagrindines darbo su failais funkcijas – lopen ir lread, kurios aprašomos taip:
Paskelbti funkciją lopen Lib "kernel32" _ Pseudonimas "_lopen" (_ ByVal lpFileName kaip eilutę, _ ByVal wReadWrite As Long) Skelbti funkciją lread Lib "kernel32" _ Alias>"_lread" (_ ByVal hFile As Long lpBuff _ ByVal wBytes As Long) As Long
VB kalboje jų analogai – kartais tiksliau – yra Open ir Get operatoriai (dvejetainiam režimui). Mus labai sužavėjo raktinio žodžio Alias naudojimas tuščioje funkcijoje - tai ta pati problema, jei negalite be jo. Šie funkcijų pavadinimai bibliotekoje prasideda simboliu po kėde (įprastas filmo C stilius), kurio neleidžia VB.
Failo atidarymo operacija gali atrodyti taip:
Const INVALID_HANDLE_VALUE = -1 ' neteisingas _ reikšmės aprašymas lpFileName$ = "D:\calc.bas" ' failo pavadinimas wReadWrite& = 2 ' skaitymo-rašymo režimas hFile& = lopen(lpFailoPavadinimas$, wReadWrite&) _ ' valued = INVALID_HANDLE'_VALUE pataisyti failą ' nurodykite taisymo kodą CodeError& = Err.LastDllError 'CodeError& = GetLastError _ ' ši konstrukcija neveikia Pabaiga, jei
Čia turime pabrėžti du dalykus:
- Kaip funkcijos reikšmę nustatome failo aprašymo reikšmę. Reikšmė patvirtina reikšmę -1;
- Šiuo atveju nebūtina eiti į GetLastError funkciją – norėdami gauti nurodytą klaidos reikšmę, nuėjome į Err objektą (apie tokios situacijos galimybę kalbėjome plačiau).
Tada galite skaityti vietoj failo, bet tai taip pat perteikia, kad programa yra atsakinga už jos struktūros atpažinimą (kaip būna dirbant su keliais dvigubais failais). Šiuo atveju lread funkcijos aprašymas gali atrodyti taip:
Dim MyVar As Single wBytes = lread (hFile&, MyVar, Len(MyVar) ' kalbos numerio skaitymas, 4 baitai ' wBytes - faktiškai nuskaitytų duomenų skaičius, '-1 - lygumas... Įveskite MyStruct x As Single i As Integer Pabaigos tipas Dim MyVar As MyStruct wBytes = lread (hFile&, MyVar, Len(MyVar)) ' skaitymo duomenų struktūra, 6 baitai
Dar kartą parodykite pagarbą: kitas funkcijos argumentas perduodamas siuntėjams ir grąžinimui į reikšmes.
Dim MyVar As String MyVar = Space$(10) ' rezervuoti vietą 10 simbolių wBytes = lread (hFile&, ByVal MyVar, Len(MyVar)) ' skaitymo simbolių eilutė, 10 simbolių
Čia matosi anksčiau įvesto užpakalio svarba – eilutės pakeitimas būtinai lydimas ByVal raktažodžio.
Skaitymas vietoj failo masyve (paprastumo dėlei naudosime vieno baito masyvą) kompiliuojamas taip:
Pritemdyti MyArray (1 iki 10) kaip baitas wBytes = lread (hFile&, MyArray(1), _ Len(MyArray(1))* 10) ‘ nuskaityti 10 elementų iš masyvo
Kaip argumentą nurodydami pirmąjį masyvo elementą, perduodame masyvui rezervuotos atminties srities galvos adresą. Akivaizdu, kad galite išsaugoti bet kurį masyvo fragmentą naudodami šį metodą:
WBytes = lread (hFile&, MyArray(4), _ Len(MyArray(1))* 5) nuskaito masyvo elementus nuo 4 iki 8
Porada 5. Vickory Alias perdavimui Nustatymai kaip bet kokie
Čia, remdamiesi priekiniu užpakaliu, atskleidžiame ketvirtojo esmę dėl Dano Applemano.
Dirbant su funkcija lread, svarbu atsiminti, kad prieš ją paleidžiant įprastą kintamąjį, būtina naudoti ByVal raktinį žodį (kitaip informacija apie nelegalią operaciją nepraras). Kad būtumėte saugūs, galite sukurti papildomą specialų šios funkcijos aprašą, skirtą dirbti tik su įprastais pakeitimais:
Nurodykite funkciją lreadString Lib „kernel32“ _ Pseudonimas „_lread“ (_ ByVal hFile As Long, ByVal lpBuffer As String, _ ByVal wBytes As Long) Kaip Ilgas
Dirbant su šiuo aprašymu, spausdinant nebereikia nurodyti ByVal:
WBytes = lreadString(hFile&, MyVarString, _ Len(MyVarString))
Atrodytų, kad operatoriaus Declare sintaksė leidžia sukurti tokį specialų masyvo aprašymą:
Deklaruoti funkciją lreadString Lib „kernel32“ slapyvardį „_lread“ (_ ByVal hFile As Long, lpBuffer() As Byte, _ ByVal wBytes As Long) Kaip Long
Protetinis gyvūnas
WBytes = lreadArray(hFile&, MyArray(), 10)
neišvengiamai lems mirtiną programos vykdymą.
Tai tęsinys diskusijoms apie eilučių pakeitimų apdorojimo ypatumus Visual Basic: VB naudoja dviejų baitų Unicode kodavimą, Win API – vieno baito ANSI (ir su C priimtinu formatu – su nuliu baitu pabaigoje). Akivaizdu, kad keičiant eilutę kaip argumentą, konvertavimas iš Unicode į ANSI automatiškai atliekamas, kai iškviečiate API funkciją (tiksliau, DLL funkciją), o konvertavimas atliekamas pasukus.
Esmė čia paprasta: galite keistis simboliais duomenimis naudodami kintamąjį Strings, tačiau jais negalima keistis pakankamai dviguba informacija (kaip buvo dirbant su 16 bitų VB versijomis). Geriau naudoti vienmatį baitų masyvą.
Matyt, String tipas gali būti naudojamas apibūdinti struktūros struktūrą. Ryšys su šia atmintimi yra toks:
- Kuriant Win API kategoriškai negalima naudoti šios konstrukcijos: Įveskite MyStruct x As Single s As String
Keitimo tvarka kartu su visais programos išvaizdos palikimais perduodamas eilutės deskriptorius.
- Galimas kaip fiksuoto dvigubinimo eilutės struktūros elementas: Tipas MyStruct x As Single s As String*8 ‘ fiksuoto padvigubinimo eilutė Pabaigos tipas
Tokiu atveju būtinai iš naujo sukurkite kodą.
Ir pagarba išlieka: vienu metu atnaujinus į API funkciją neįmanoma konsoliduoti eilučių pakeitimų masyvo (tiek fiksuotų, tiek keičiamų). Priešingu atveju „neteisėtos operacijos“ atsiradimas bus garantuotas.
Visiškai aišku, kad esate blogoje situacijoje, jei jums reikia įrašyti DLL funkciją į savo biblioteką. Poreikis neišvengiamai atsiras, jei naudosite mišrią programavimo technologiją – dviejų ar daugiau programų derinį vienai programai įgyvendinti.
Svarbu tai, kad mišrus programavimas yra pagrindinis įgyvendinimo tikslas, siekiant išsamios ataskaitos. Išties kalbos kalba (tiksliau kalba paremta programavimo sistema) turi savo stipriąsias ir silpnąsias puses, todėl visiškai logiška pasitelkti įvairių įrankių privalumus įvairioms užduotims pasiekti. Pavyzdžiui, VB – kompiuterio sąsajai sukurti, C – efektyviai prieigai prie sistemos išteklių, Fortran – skaitiniams algoritmams įgyvendinti.
Autoriaus idėja tokia: rimtą įsitraukimą į programavimą kūrėjas pabrėžia naudodamas dvi priemones. Akivaizdu, kad šiuolaikiniame galvoje labai sunku būti nepriklausomu dviejų sistemų ekspertu, todėl „pagrindinės ir papildomos kalbos“ schema tampa logiškesnė. Idėja yra ta, kad „papildomos“ kalbos žinių perkėlimas (parašytas pagal daugybę paprastų procedūrų) gali žymiai padidinti „pagrindinės“ kalbos veiksmingumą. Svarbu, kad VB žinios, kaip papildoma nauda, dabar yra praktinis reikalavimas profesionaliam programuotojui. Prieš kalbant, vos per kelias DOS valandas, bet kuriam programuotojui, pažiūrėkime į Basic, būtų be galo svarbu žinoti Assembler pagrindus.
Taigi yra kitaip, bet grupinių robotų galvoje, kai skinas programuotojas užsiima savo specifiniu darbu, teiginiai apie procedūrinės sąsajos ypatumus skirtingomis kalbomis yra visų projekto dalyvių kaltė. Žinau, kad yra daug programavimo sistemų (įskaitant VB), be sąsajos, kurią reikia paaiškinti, galima nustatyti kitus metodus, išplečiant apdorojimo metodus iki procedūrų, leidžiančių pritaikyti sąsają kitoms kalboms .
Naudodami tarpprocedūrinę sąsają atkreipkite dėmesį į šiuos galimus spąstus:
- Dėl identifikatorių rašymo taisyklių jus gali sudominti skirtingos kalbos. Pavyzdžiui, dažnai naudojamas procedūros pavadinimo slapyvardis, kuris yra paslėptas VB. Šią problemą galima lengvai paaiškinti slapyvardžio raktinio žodžio naudojimu operatoriaus Declare (puikus 2.3 pavyzdys).
- Galite nustatyti į krūvą perduodamų argumentų rašymo seką. Pavyzdžiui, DOS valandomis (tiesą pasakius, nežinau, kaip tai atrodo Windows viduryje), užrašant argumentus iš sąrašo pabaigos, kitomis kalbomis (Fortran, Pascal, Basic) – iš pradžios.
- Aiškinami įvairūs parametrų – nurodymų ar reikšmių – perdavimo principai.
- Griežti eilinių pareigų išsaugojimo principai. Pavyzdžiui, C kalboje (kaip Fortran ir Pascal) paskutinė eilutės eilutė nurodoma nuliu baitu jos gale, o Basic paskutinė minutė yra aiškiai parašyta eilutės apraše. Akivaizdu, kad reikia atsiminti galimybę keisti skirtingus simbolių kodus.
- Perkeldami turtingo pasaulio masyvus, atminkite, kad yra įvairių variantų, kaip transformuoti turtingo pasaulio struktūras viename pasaulyje (pradedant nuo pirmojo indekso arba nuo likusių, šimtas dvimačių masyvų - „eilutėse“ arba „eilutėse“). bitėms“).
Remiantis tuo, galima suformuluoti šias rekomendacijas:
- Patikrinkite paprasčiausius dalykus peržiūrėdami, kaip argumentai perduodami DLL funkcijai. „Win API“ priimti standartai yra visiškai nuoseklūs.
- Kiekvieną kartą neperkelkite masių paprastų kareivių.
- Pagarbiai vikorist perkelkite paprastus paprastus ir turtingus masyvus.
- Būtinai atidžiai patikrinkite mechanizmo, skirto argumentų perdavimo procedūrai, kuri iškviečiama ir atgal, funkcionalumą. Norėdami patikrinti duomenis, parašykite specialų testą. Atidžiai patikrinkite odos argumento perdavimo teisingumą. Pvz., jei turite procedūrą su daugybe argumentų, pirmiausia patikrinkite, ar teisingai perduodamas odos parametras pasirinkčiai su vienu argumentu, o tada visam sąrašui.
Ką daryti, jei DLL funkcija jau parašyta, pavyzdžiui, Fortran, bet įvesties sąsaja nedera su naujuoju VB standartu? Čia galite nurodyti dvi datas. Pirma: parašykite bandomąją DLL funkciją ir jos pagalba pabandykite naudoti bandymų ir klaidų metodą, kad pasirinktumėte reikiamą funkcionalumą VB programoms. Kitas: parašykite Fortran adapterio procedūrą, kuri suteiktų paprastą sąsają tarp VB ir DLL funkcijos su paprastų duomenų struktūrų transformavimu sandėlyje (pavyzdžiui, didelio baitų masyvo transformavimas iš eilučių masyvo).
Otzhe: vykorist DLL funkcijos. Taip pat išsaugokite saldumą.
ComputerPress 9"2000
Šis straipsnis skirtas tiems, kurie programuoja C++ ir buvo priversti naudoti WinAPI.Noriu žengti į priekį žaidime:
Aš neapsimetinėju C++ ar WinAPI guru.
Aš tik pradedu ir noriu čia pristatyti keletą programų, kurios palengvins WinAPI funkcijų ir mechanizmų naudojimą.
Šiame straipsnyje manau, kad jūs jau susipažinote su C++, kad galėtumėte kurti klases ir perkelti joms skirtingus operatorius ir kad jau „pamilote“ savo mechanizmus į klasę.
Konsolės kūrimas ir vikoristas
Norėdamas patobulinti Win32 programas ar tiesiog pasigrožėti, kaip ten viskas atrodo per vidurį, visada nubrauksiu konsolę.Kadangi kuriate GUI programą, o ne konsolę, konsolė neprisijungs. Norėdami spustelėti internete, galite rasti šį kodą
Jei (AllocConsole())
{
std::ios::sync_with_stdio();
}
Kad būtų aiškumo, Raja apvynioja jį funkcija. Pavyzdžiui:
void CreateConsole()
{
jei (AllocConsole())
{
int hCrt = _open_osfhandle((ilgai)GetStdHandle(STD_OUTPUT_HANDLE), 4);
*stdout = *(::_fdopen(hCrt, "w"));
::setvbuf(stdout, NULL, _IONBF, 0);
*stderr = *(::_fdopen(hCrt, "w"));
::setvbuf(stderr, NULL, _IONBF, 0);
std::ios::sync_with_stdio();
}
Konsolė veikia tik ekrano režimu ir veikia taip pat, kaip ir konsolių programose. Įveskite informaciją kaip anksčiau - cout/wcout.
Kad šis kodas būtų veiksmingas, į projektą būtina įtraukti šiuos failus:
#įtraukti
#įtraukti #įtraukti
ir įgalinkite std vardų erdvę visuotinėje vardų erdvėje:
naudojant vardų erdvę std;
Žinoma, jei nenorite nieko daryti, tiesiog pridėkite std:: prie visų jame esančių objektų.
Rodymui skirtų objektų atsiskaitymas ir aritmavimas. operacija
Sukūrę ir įvedę „pagaliau“, pirmiausia turite išvesti visas reikšmes į konsolę.Pavyzdžiui:
Lango kliento srities dydį nustatote naudodami papildomą funkciją GetClientRect, kur parametras perduodamas į RECT struktūros objekto adresą, kad šis objektas būtų užpildytas duomenimis. Jei reikia žinoti užfiksuotos kliento srities dydį, galite tiesiog įvesti jį į jau prijungtą pultą.
Cout< Ale darbas taip greitai (juolab kad dažnai taip tenka dirbti) nėra lengvas. Klasė newrect:public RECT Dabar tiesiog atspausdinkite objektą naudodami cout / wcout: Cout< Ir jūs patys matote, kad viskas yra taip, kaip jums reikia. Apgalvoję ir parašę tokią pamoką, palengvinsite savo gyvenimą ir sugaišite daugiau nei valandą, įsisavindami ir paaštrindami rašymo pradžią vienu metu. Timas labiau, gerbiu tai dar gražiau - tokią klasę susikurti pačiam ir ją papildyti pagal savo poreikius.
Čia mums į pagalbą ateina ramybė.
Sukurkite klasę, kuri atvirai susitraukia iš RECT struktūros, ir pakeiskite išvesties teiginio paskirtį<< так, как вам угодно.
Pavyzdžiui:
{
viešas:
draugas ostream& operatorius<<(ostream &strm,newrect &rect)
{
strm<<"Prtint RECT object:\n";
strm<
}
};
Taip pat galite dirbti su bet kokiais jums reikalingais operatoriais.
Pavyzdžiui, jei reikia modifikuoti arba priskirti struktūras (pvz., RECT arba POINT) – visiškai pakeiskite operatorius==() ir operator=().
Jei norite įdiegti operatorių mažiau< что бы быстро сравнивать размеры окна и т.д. перегрузите operator<().
Taigi, manau, galite dirbti net su bet kokiomis struktūromis ir, svarbiausia, kad visos funkcijos, veikiančios su pirminiu RECT struktūros objektu, puikiai veiks su juo.
Taip pat rekomenduoju visą šį grožį sudėti į atskirą failą, kuris yra prijungtas, ir, jei reikia, jį redaguoti.Jūsų klasė
Nežinau kaip kitiems, bet aš esu visiškai žalia, nusprendžiau sukurti naują projektą odos funkcijai arba odos skyriui / knygos poskyriui, kad viskas būtų tvarkoje ir būtų galima pavartyti aplink ir atnaujink ją bet kurią akimirką ir atmintyje' Tai būtinos akimirkos.
Kadangi WinAPI, norint sukurti paprastą langą, reikia užpildyti klasės struktūrą, ją užregistruoti ir parašyti trivialią langų procedūrą, tai po trečio ar ketvirto projekto supratau, kad vis dar rašau C++.
Dėl to viską griebiau iš paprastos klasės. Lango rankena, lango pavadinimas, klasės pavadinimas, lango procedūrų adresai, langų klasė (WNDCLASS) yra saugomi privačios klasės skyriuje.
Norėdami juos išgauti, turite aprašyti paprastą „Gauti“ metodą, pavyzdžiui:
HWND GetHWND()
LPCTSTR GetClsName() ir kt.
Langų klasės atnaujinimą ir registravimą, paties lango sukūrimą ir jo eksponavimą atlieka dizaineris.
Paprastumo dėlei galite perplanuoti konstruktorių, o langų klasės užbaigimą ir registravimą įvesti į privačią klasės funkciją ir iškviesti ją iš kiekvieno konstruktoriaus. Atbulinės eigos pranašumas slypi tame, kad kartais reikia sukurti visiškai paprastą langą ir aš paspaudžiu konstruktorių su dviem parametrais - lango pavadinimas ir programos trukdis.
Kitu atveju nereikia kurti lango su specialiais dydžiais, o ne pagal numatytąją langų procedūrą ir bet kokį kitą stilių – paspaudžiu konstruktorių su susijusiais parametrais.
Ši klasė turi mažiau reikšmių tiesiogiai įtrauktame faile, kuris yra IDE įtraukimo aplanke.
Šios klasės šablonas:
klasės „BaseWindow“.
{
WNDCLASSEX_wcex;
TCHAR_className;
TCHAR_lango pavadinimas;
HWND_hwnd;
bool_WindowCreation();
viešas:
BaseWindow(LPCTSTR lango pavadinimas,HINSTANCE pavyzdys,DWORD stilius,UINT x,UINT y,UINT aukštis,UINT plotis);
BaseWindow(LPCTSTR lango pavadinimas,HINSTANCE hInstancija);
const HWND GetHWND()const(grįžti HWND;)
LPCTSTR GetWndName()const(grįžta _lango pavadinimas;)
}; P.S.
Viskas, kas aprašyta, tinka:
Platforma – Windows 7 32 bitų
IDE – „Visual Studio 2010“.
Galbūt kas nors norėtų iššaukti juoką ir ironiją, bet juk visi manėme, kad esame naujokai/stažuotojai/jaunesnieji.
Prašau jūsų būti skrupulingiems prieš savo postą. Konstruktyvi kritika, žinoma, nukrenta.
Operacinės sistemos (OS)
