FindWindow
GetWindow
GetWindowText
SetWindowText
IsWindow
MoveWindow
IsWindowVisible
EnableWindow
IsWindowEnabled
WindowFromPoint
ShowWindow
Chiudi la finestra
SetWindowPos
GetClassLong
SetClassLong
GetWindowLong
SetWindowLong
GetDesktopWindow
GetParent
Funzione FindWindow
funzione FindWindow (className, WindowName: PChar): HWND;
La funzione restituisce un handle di finestra che soddisfa la richiesta (0 se tale finestra non è stata trovata).
Uno dei parametri può essere nullo, nel qual caso la ricerca viene eseguita utilizzando l'altro parametro.
Esempio:
Funzione GetWindow
funzione GetWindow (Wnd: HWND; Param): HWND
La funzione restituisce un handle di finestra che soddisfa la richiesta.
Esempio:
Funzione GetWindowText
funzione GetWindowText (hWnd: HWND; lpString: PChar; nMaxCount: Integer): Integer;
La funzione restituisce il testo della finestra. Per il modulo, questo sarà il titolo, per il pulsante: l'etichetta sul pulsante.
La lunghezza massima del testo, se il testo è più lungo, viene tagliato.
Esempio:
Funzione IsWindow
funzione IsWindow (hWnd: HWND): BOOL; Restituisce True se esiste una finestra con l'handle specificato, False altrimenti.
hwnd La maniglia della finestra desiderataFunzione MoveWindow
MoveWindow (hWnd: HWND; X, Y, nWidth, nHeight: Integer; bRepaint: BOOL): BOOL; Sposta la finestra in una nuova posizione.
hWnd Una maniglia per spostare la finestra. X, Y, nLarghezza, nAltezza Di conseguenza: nuove coordinate X, Y; nuova larghezza, altezza. bRepaint Un valore booleano che indica se la finestra verrà ridisegnata.Funzione IsWindowVisible
funzione IsWindowVisible (hWnd: HWND): BOOL;
Restituisce True se la finestra indicata è visibile.
Funzione EnableWindow
funzione EnableWindow (hWnd: HWND; bEnable: BOOL): BOOL;
Imposta l'accessibilità della finestra (la finestra è inaccessibile se non risponde agli eventi del mouse, agli eventi della tastiera, ecc.). L'analogo Delphi è la proprietà Enabled dei componenti. EnableWindow restituisce True se tutto è andato bene e False in caso contrario.
Esempio:
Funzione IsWindowEnabled
funzione IsWindowEnabled (hWnd: HWND): BOOL;
Restituisce per la finestra specificata: True se la finestra è disponibile e False in caso contrario.
Funzione WindowFromPoint
WindowFromPoint (Point: TPoint): HWND;
Restituisce una maniglia alla finestra a questo punto sullo schermo.
Funzione
| genere TPoint \u003d Disco x: Longint; y: Longint; fine; |
Funzione ShowWindow
funzione ShowWindow (hWnd: HWND; nCmdShow: Integer): BOOL; Mostra o nasconde la finestra.
hWnd La maniglia della finestra desiderata nCmdShow Una costante che determina cosa verrà fatto con la finestra: SW_HIDE SW_SHOWNORMALSW_NORMAL SW_SHOWMINIMIZED SW_SHOWMAXIMIZED SW_MAXIMIZE SW_SHOWNOACTIVATE SW_SHOW SW_MINIMIZE SW_SHOWMINNOACTIVE SW_SHOWNA SW_RESTORE SW_SHOWDEFAULT SW_MAX
Esempio:
Funzione CloseWindow
funzione CloseWindow (hWnd: HWND): BOOL; stdcall;
Chiude la finestra
SetWindowPos
funzione SetWindowPos (hWnd: HWND; hWndInsertAfter: HWND; X, Y, cx, cy: Integer; uFlags: UINT): BOOL; stdcall;
Imposta la finestra in una nuova posizione
Di conseguenza, un nuovo orizzonte. , vert. posizione della finestra ( X, Y), nonché la nuova larghezza
e altezza ( cx, cy)
Funzione GetClassLong
funzione GetClassLong (hWnd: HWND; nIndex: Integer): Integer;
Questa funzione restituisce un numero intero a 32 bit prelevato da un campo record specifico TWndClassEx la finestra specificata.
Nota: nel caso in cui la funzione restituisca un puntatore, è necessaria la conversione del tipo (Intero -\u003e
Funzione SetClassLong
funzione SetClassLong (hWnd: HWND; nIndex: Integer; dwNewLong: Longint): Integer; Funzione funzione accoppiata. Imposta il campo richiesto sul valore corrispondente.
La funzione restituisce il vecchio valore del campo in modo che possa essere corretto in seguito, oppure viene restituito zero se qualcosa è andato storto.
Nota pointer digitare Numero intero.
Funzione GetWindowLong
funzione GetWindowLong (hWnd: HWND; nIndex: Integer): Longint; Restituisce informazioni su una determinata finestra come numero intero a 32 bit.
hWnd Maniglia per finestra nIndex Una costante che determina cosa verrà restituito. Ci deve essere uno dei seguenti:GWL_WNDPROC Restituisce l'indirizzo della procedura finestra associata a questa finestra. L'indirizzo ricevuto (dopo le conversioni del tipo corrispondente) può essere utilizzato nella funzione CallWindowProc... Questo valore viene di solito utilizzato se vogliono sostituire la procedura esistente con la propria finestra, mentre, per non perdere la funzionalità della finestra, di solito usano CallWindowProc. GWL_HINSTANCE Restituisce il descrittore dell'applicazione specificato quando la finestra è stata creata dalla funzione CreateWindowEx. GWL_HWNDPARENT Restituisce l'handle (HWND) della finestra principale GWL_STYLE Restituisce lo stile della finestra. Valori di stile specifici vengono riconosciuti mediante un'operazione bit a bit E e costanti WS_XXX GWL_EXSTYLE Restituisce lo stile esteso della finestra. Valori di stile specifici vengono riconosciuti mediante un'operazione bit a bit E e costanti WS_EX_XXX GWL_USERDATA Restituisce il numero intero a 32 bit associato alla finestra (questo è l'ultimo parametro nella chiamata a CreateWindow o CreateWindowEx) GWL_ID Restituisce l'identificatore della finestra (non ha nulla a che fare con l'handle della finestra!) Impostato dal parametro hMenu per le finestre figlio quando si chiama CreateWindow o CreateWindowEx
Nota: nel caso in cui la funzione restituisca un puntatore, è richiesta la conversione del tipo (Intero -\u003e Puntatore). Puoi farlo in questo modo:
Funzione SetWindowLong
funzione SetWindowLong (hWnd: HWND; nIndex: Integer; dwNewLong: Longint): Longint;
Associato per funzionare. Modifica gli attributi di una finestra specifica.
La funzione restituisce il vecchio valore della proprietà se la chiamata ha avuto esito positivo, oppure null in caso contrario.
Nota: quando si impostano i campi del puntatore, è necessario digitare casting pointer digitare Numero intero.
Funzione GetDesktopWindow
funzione GetDesktopWindow: HWND
La funzione restituisce un handle alla finestra Desktop. Nessun parametro
GetParent
funzione GetParent (hWnd: HWND): HWND;
Restituisce l'handle della finestra principale per una finestra hWnd.
Con WinAPI è possibile creare varie procedure di finestre, finestre di dialogo, programmi e persino giochi. Diciamo che questa libreria è fondamentale nello sviluppo della programmazione, MFC, perché queste interfacce sono componenti aggiuntivi di questa libreria. Dopo averlo imparato, creerai facilmente forme e capirai come questo accade.
Non saremo introdotti in teoria. Cominciamo da come creare questo progetto in MVS e alla fine dell'articolo verrà discusso un semplice esempio.
Così. Per prima cosa apriamo Visual Studio, quindi, fai clic sulla scheda "File", quindi su "Crea progetto":
Quindi, nell'elenco a discesa Visual C ++, selezionare l'elemento Win32 e ci sarà "Progetto Win32". Ci clicchiamo sopra: 
Immettere il nome del progetto, indicare il percorso e fare clic su "OK". Successivamente, dice "Benvenuti alla procedura guidata per l'applicazione Win32". Fai clic su Avanti. Per impostazione predefinita, l'etichetta "Progetto vuoto" non ha un segno di spunta. Dobbiamo installarlo e assicurarci che il nostro "Tipo di applicazione" sia Applicazione Windows. Se tutto è corretto, fai clic su "Fine".
Dovremmo avere un progetto vuoto come questo:
Bene, ora iniziamo a scrivere programma semplice, che tradizionalmente mostrerà la scritta: "Ciao, mondo !!!".
Naturalmente, è necessario aggiungere un file .cpp "nome" al progetto. Facciamo clic su "File di codice sorgente" con il tasto destro del mouse, nell'elenco a discesa, selezionare la scheda - "Aggiungi", quindi "Crea elemento ...". Di conseguenza, dovremmo avere una finestra come questa:
Seleziona "File C ++", inserisci un nome, fai clic su "Aggiungi". Quindi apriamo questo file e incolliamo il seguente codice (dettagli sotto):
#includere
Il risultato dovrebbe essere così:
Ora diamo un'occhiata più da vicino al codice del programma.
Nella prima riga includiamo il file di intestazione windows.h. Contiene tutte le funzioni "apish" necessarie. Qui è tutto chiaro.
NEL 4-7 righe abbiamo una descrizione della funzione int WINAPI WinMain ().
Qualificatore WINAPI, sempre necessario per la funzione WinMain. Ricordalo e basta. WinMain è il nome della funzione. Ha quattro parametri. Il primo è HINSTANCE hInstance ( linea 4). hInstance è un handle per un'istanza di finestra (questo è un certo codice di una procedura di finestra, un identificatore con cui il sistema operativo lo distinguerà dalle altre finestre). Attraverso di esso, è possibile accedere alla finestra mentre si lavora in altre funzioni (ne parleremo più avanti), modificare qualsiasi cosa nei parametri della finestra. HINSTANCE è uno dei molti tipi di dati definiti in WinAPI come int, ad esempio. E il record hINstance di HINSTANCE ci dice che stiamo creando una nuova variabile del tipo HINSTANCE chiamata hInstance.
Parleremo dei tipi di dati in seguito, quindi passiamo al parametro successivo: HINSTANCE hPrevInstance ( linea 5). Come è scritto nei commenti, in Win32 non viene utilizzato, poiché è stato creato per un sistema a 3.x bit, dal precedente è chiaro che si tratta di un handle per un'istanza di finestra. Successivamente, abbiamo una variabile di tipo LPSTR ( linea 6) denominato lpCmdLine. Viene utilizzato nel caso in cui apriamo una finestra riga di comando con parametri scritti in parole. Questo è un modo molto esotico, quindi non ci soffermeremo su di esso.
E l'ultimo parametro: intero, determina come viene visualizzata la finestra. È necessario per la funzione ShowWindow, che verrà descritta in seguito. Ad esempio, con l'aiuto di esso possiamo espandere la finestra a schermo intero, renderla di una certa altezza, trasparente o sopra il resto.
Vai alla funzione MessageBox () ( linea 10). Ha quattro parametri ed è necessario per visualizzare messaggi di errore, ad esempio. In questo caso, l'abbiamo usato per visualizzare il messaggio. In generale, la descrizione della funzione è simile alla seguente:
Int MessageBox (HWND hWnd, // handle alla finestra principale LPCTSTR lpText, // puntatore alla riga con il messaggio LPCTSTR lpCaption, // puntatore alla riga con il testo dell'intestazione UINT uType); // flag per visualizzare pulsanti, stile icona e così via
Nel nostro caso, il primo parametro è impostato su zero. Questo perché non abbiamo finestre padre (non è avviato da nessun programma).
Successivamente abbiamo due variabili di tipo LPCTSTR: lpText e lpCaption. Il primo riporta le informazioni che verranno visualizzate nella finestra in forma di testo. Il secondo dice cosa verrà scritto nel testo del titolo per la finestra. Questo è analogo a char * str, ma ancora no. Affinché il testo sia visualizzato correttamente, è necessario inserire la lettera L ( UNICODE linea).
Bene, l'ultimo tipo di dati è UINT - un numero intero senza segno a 32 bit. Cioè, un analogo di int. A questo parametro possono essere passati alcuni valori (più avanti su di essi), grazie ai quali è possibile modificare l'aspetto del pulsante. Nel nostro caso - questo è MB_OK - significa che la finestra crea un pulsante con la scritta "OK" e l'azione corrispondente quando viene premuto (chiusura dell'applicazione).
NEL linea 11restituiamo il valore della funzione, poiché non è di tipo vuoto.
Pertanto, ora abbiamo una comprensione generale di WinAPI. Continua nelle sezioni seguenti.
Alla fine! Alla fine! Oggi inizieremo a creare una finestra di Windows completa. Addio console miserabile !!!
A questo punto, dovresti già avere una buona conoscenza della sintassi C ++, essere in grado di lavorare con rami e loop e capire bene come funzionano le funzioni. Se hai imparato una battaglia navale, puoi presumere di aver imparato tutto questo.
Notazione ungherese
Tutto il codice che troviamo in WinAPI è scritto in ungherese. Questa è una convenzione di codifica.
In questo caso, la lettera iniziale del tipo viene posizionata davanti al nome della variabile. Tutte le parole nei nomi delle variabili e delle funzioni iniziano con una lettera maiuscola.
Ecco alcuni prefissi:
b è una variabile di tipo bool.
l è una variabile intera lunga.
w - dalla parola (parola) - 16 bit. Tipo variabile corto firmato.
dw - dalla doppia parola (doppia parola) - 32 bit. Variabile di tipo unsigned long.
sz - stringa terminata con zero. Solo una stringa normale che abbiamo usato tutto il tempo.
p o lp è un puntatore (dal puntatore). lp (dal puntatore lungo) - questi puntatori sono passati dal passato. Ora lp e p significano la stessa cosa.
h - maniglia (dalla maniglia).
Ad esempio, un puntatore verrebbe chiamato in questo modo:
void * pData;
Questa forma di record è utilizzata da Microsoft. Molte persone criticano questo modo di nominare le variabili. Ma questo tipo di cose (convenzioni di codifica) sono vitali nelle grandi aziende.
Lascia che ti ricordi che gli identificatori costanti di solito sono composti solo da lettere maiuscole: WM_DESTROY. WM_DESTOY è 2, la costante viene definita tramite define.
Inoltre, winAPI utilizza molti tipi sovrascritti. Qui in questa pagina - http://msdn.microsoft.com/en-us/library/aa383751(VS.85).aspx, puoi trovare le descrizioni di tutti i tipi di Windows (in inglese).
E un'altra cosa che non abbiamo analizzato. Ai puntatori vengono spesso assegnati valori NULL. Pensalo come solo 0 e i puntatori assegnati al valore NULL (zero) non puntano a nessun pezzo di memoria.
API di Windows (WinAPI)
Tutti i programmi Windows utilizzano una speciale interfaccia di programmazione WinAPI. È un insieme di funzioni e strutture C che rendono il programma compatibile con Windows.
L'API di Windows ha enormi possibilità di lavorare con il sistema operativo. Si potrebbe anche dire: illimitato.
Non copriremo nemmeno l'uno percento di tutte le funzionalità di WinAPI. Inizialmente volevo prendere più materiale, ma ci sarebbe voluto troppo tempo e impantanarsi nella palude di WinAPI, DirectX "e arriveremmo tra un paio d'anni. La descrizione di WinAPI prenderà due lezioni (compresa questa). In esse tratteremo solo il framework applicativo per Finestre.
Un programma Windows, proprio come un programma DOS, ha una funzione principale. Questa funzione si chiama WinMain qui.
Funzione WinMain
Il programma Windows è composto dalle seguenti parti (tutto ciò accade all'interno di WinMain):
Crea e registra una classe di finestre. Non essere confuso con le classi C ++. WinAPI è scritto in C, non ci sono classi nel nostro solito senso della parola.
Creazione di una finestra del programma.
Il ciclo principale in cui vengono elaborati i messaggi.
Elaborazione dei messaggi del programma in una finestra. La procedura della finestra è una funzione normale.
Questi quattro punti sono alla base del programma Windows. Durante questa e la prossima lezione, approfondiremo tutto questo in dettaglio. Se ti confondi nella descrizione del programma, torna a questi punti.
Ora diamo un'occhiata a tutto questo in dettaglio:
WinAPI: Struttura WNDCLASS
Prima di tutto, devi creare e compilare la variabile di struttura WNDCLASS, quindi registrare una classe di finestra basata su di essa.
Ecco come appare questa struttura:
codice c ++ typedef struct (stile UINT; // stile finestra WNDPROC lpfnWndProc; // puntatore alla procedura finestra int cbClsExtra; // byte aggiuntivi dopo la classe. Inserisci sempre 0 int cbWndExtra; // byte aggiuntivi dopo l'istanza della finestra. Inserisci sempre 0 HINSTANCE hInstance; / / istanza dell'applicazione Passato come parametro in WinMain HICON hIcon; // icona dell'applicazione HCURSOR hCursor; // cursore applicazione HBRUSH hbrBackground; // colore di sfondo LPCTSTR lpszMenuName; // nome menu LPCTSTR lpszClassName; // nome classe) WNDCLASS, * PWNDCLASS ;
La struttura WNDCLASS come parte di WinAPI definisce le proprietà di base della finestra che viene creata: icone, il tipo di cursore del mouse, se la finestra ha un menu, quale applicazione sarà proprietaria della finestra ...
Dopo aver compilato questa struttura, è possibile registrare una classe di finestra da essa. Non stiamo parlando di classi come in C ++. Piuttosto, puoi presumere che la classe della finestra sia un tale modello, che tu l'abbia registrata con il sistema e ora puoi creare diverse finestre basate su questo modello. E tutte queste finestre avranno le proprietà definite nella variabile di struttura WNDCLASS.
WinAPI: Funzione CreateWindow
Dopo aver registrato la classe della finestra, la finestra principale dell'applicazione viene creata sulla base (ora abbiamo iniziato il secondo punto). Questo viene fatto usando la funzione CreateWindow. Ha il seguente prototipo:
codice c ++ HWND CreateWindow (LPCTSTR lpClassName, // nome classe LPCTSTR lpWindowName, // nome finestra (visualizzato nel titolo) DWORD dwStyle, // stile finestra int x, // coordinata orizzontale dal bordo sinistro dello schermo, // coordinata verticale da bordo superiore dello schermo int nLarghezza, // larghezza finestra int nAltezza, // altezza finestra HWND hWndParent, // finestra principale HMENU hMenu, // menu HINSTANCE gestisci hInstance, // istanza applicazione LPVOID parametro lpParam //; sempre impostato su NULL);
Se le proprietà della finestra di base sono impostate nella classe della finestra (struttura WNDCLASS), qui sono più specifiche per ciascuna finestra: dimensioni della finestra, coordinate ...
Questa funzione restituisce un handle alla finestra. Usando la maniglia, puoi fare riferimento alla finestra, è come un identificatore.
Nota che ci sono molti nuovi tipi qui. In realtà sono tutti vecchi, appena ridefiniti. Ad esempio: HWND è una sostituzione del tipo HANDLE, che a sua volta è una sostituzione del PVOID, che a sua volta è una sostituzione del vuoto *. Quanto profondamente seppellita la verità! Tuttavia, il tipo HWND è un puntatore a vuoto.
La finestra è composta da più parti. In quasi tutti i programmi vedrai: il titolo della finestra, il menu di sistema (se fai clic sull'icona dell'applicazione nella parte in alto a sinistra della finestra), tre pulsanti di sistema per lavorare con la finestra: minimizza, espandi a schermo intero e chiudi. Inoltre, c'è quasi sempre un menu nell'applicazione. Non avremo quest'ultimo. E, naturalmente, la maggior parte della finestra è occupata dal cosiddetto. l'area client in cui l'utente lavora abitualmente.
Questo è per la modalità finestra. Per molto tempo ci eserciteremo con DiectX nella finestra - non useremo la modalità a schermo intero.
Gestione dei messaggi
La principale differenza tra tutti i nostri programmi precedenti e i programmi Windows è la gestione dei messaggi.
Ad esempio, quando l'utente preme un tasto sulla tastiera, viene generato un messaggio in cui è stato premuto un tasto. Questo messaggio viene quindi inviato all'applicazione attiva quando l'utente ha premuto il tasto.
Qui abbiamo un evento (evento) - è stato premuto un tasto.
Un evento può essere: spostare il cursore del mouse, cambiare lo stato attivo di un'applicazione, premere un tasto della tastiera, chiudere una finestra. Ci sono molti eventi Molto! Dozzine di eventi possono verificarsi nel sistema operativo al secondo.
Quindi, quando si verifica un evento, il sistema operativo crea un messaggio: tale e tale tasto è stato premuto, le coordinate del cursore del mouse sono cambiate, è stata aperta una nuova finestra.
I messaggi possono essere generati sia dal sistema operativo che da varie applicazioni.
Il messaggio è una struttura e assomiglia a questo:
codice c ++ typedef struct tagMSG (HWND hwnd; // finestra che riceverà questo messaggio Messaggio UINT; // Codice messaggio WPARAM wParam; // Parametro LPARAM lParam; // Tempo parametro DWORD; // ora in cui il messaggio si è verificato POINT pt; // coordinate cursore del mouse) MSG;
Nota come le strutture vengono ridefinite con typedef.
Per creare questa struttura, è possibile utilizzare il seguente codice:
codice c ++ msg.messgae \u003d\u003d 2; // queste due righe sono equivalenti poiché msg.message \u003d\u003d WM_DESTROY; // costante WM_DESTROY è uguale a due
Qui, il campo che contiene il codice del messaggio (nome del messaggio, viene confrontato con la costante WM_DESTROY. WM - dal messaggio di Windows (messaggio di Windows). WM_DESTROY è un messaggio che viene generato quando la finestra viene chiusa (distruggi).
I codici dei messaggi sono definiti usando costanti e sono preceduti da WM_: WM_CLOSE, WM_CREATE, ecc.
La struttura MSG contiene il tipo HWND - dalla maniglia della finestra (maniglia della finestra o maniglia della finestra). Questo è il tipo di cosa che "descrive" la finestra. Questo è qualcosa come un identificatore (nome della finestra).
Ricorda questa parola - handle (descrittore, descrittore). Questo termine è usato molto spesso in Windows. Quasi tutti i tipi di Windows che iniziano con H sono descrittori: descrittore di icone, descrittore di caratteri, descrittore di istanza dell'applicazione. Ce ne sono trenta per quanto mi ricordo.
Tutte le interazioni tra le applicazioni in Windows vengono eseguite utilizzando questi stessi descrittori di finestre (HWND).
Esiste un altro descrittore importante - il descrittore dell'applicazione (HINSTANCE è il primo parametro di WinMain) - questo è un identificatore univoco dell'applicazione, grazie al quale il sistema operativo non sarà in grado di confondere due diversi programmi. È come un codice a barre. Lo vedremo più tardi.
Ogni volta che l'utente esegue un'azione, viene creato e riempito un messaggio: viene impostato l'handle della finestra che dovrebbe ricevere questo messaggio, viene impostato l'identificatore del messaggio, i parametri vengono riempiti, il tempo (corrente) viene riempito e vengono indicate le coordinate del cursore del mouse (vedere la struttura).
Questo messaggio viene quindi inserito nella coda dei messaggi del sistema operativo. Quando la coda raggiunge il nostro messaggio, viene inviata alla finestra desiderata (windows sa a quale finestra inviare ciascun messaggio grazie ai descrittori). Quando un messaggio arriva all'applicazione, viene inserito nella coda dei messaggi dell'applicazione. Non appena arriva il suo turno, viene elaborato.
Guarda, tra il momento in cui l'utente ha eseguito un'azione (si è verificato un evento e un messaggio è stato generato) e il momento in cui il programma ha reagito a questa azione (il messaggio è stato elaborato dal programma), si verificano molti eventi. Dopotutto, sia la coda dei messaggi di Windows che la coda dei messaggi dell'applicazione possono contenere molti messaggi. Nel primo caso, possiamo parlarne a centinaia, nel secondo caso, almeno alcuni.
Procedura finestra (WndProc)
Continuiamo dal momento in cui il messaggio è entrato nella coda dei messaggi dell'applicazione. Non appena il turno lo ha raggiunto, viene elaborato. Per elaborare i messaggi, ogni programma deve avere una funzione speciale: una finestra. Di solito si chiama WndProc (per la procedura di Windows). La chiamata della procedura finestra si trova nel ciclo principale del programma e viene eseguita ad ogni iterazione del ciclo.
I messaggi (sotto forma di variabili di struttura MSG) rientrano in questa funzione come parametri: handle di finestra, ID messaggio e due parametri. Si noti che i campi time e pt non vengono passati alla procedura della finestra. Cioè, il messaggio è già stato "analizzato".
All'interno della procedura della finestra è presente un ramo switch, in cui viene verificato l'identificatore del messaggio. Ecco un esempio di una semplice procedura di finestra (è completamente funzionale):
codice c ++ // ignora HRESULT e __stdcall per ora. Li vedremo in seguito HRESULT __stdcall WndProc (HWND hWnd, messaggio UINT, WPARAM wParam, LPARAM lParam) (switch (messaggio) (case WM_PAINT: // codice di gestione messaggi WM_PAINT return 0; case WM_DESTROY: // codice gestione messaggi WM_DESTROY return 0; ) // gestore per tutti gli altri messaggi)
E l'ultimo è il ciclo principale. È molto semplice. Ogni iterazione del ciclo controlla la coda dei messaggi dell'applicazione. Se è presente un messaggio nella coda dei messaggi, questo viene estratto dalla coda. Quindi viene richiamata una procedura di finestra nel corpo del ciclo per elaborare il messaggio preso dalla coda.
Questo, in generale, è tutto per oggi. È già chiaro che un programma WinAPI è molto più complesso di un programma DOS. Come ho scritto sopra, nella prossima lezione analizzeremo il codice di un programma di lavoro.
Crea un nuovo progetto come esercizio. Nella finestra Nuovo progetto selezionare il modello - Win32Project (finora abbiamo scelto l'applicazione console Win32). In una delle seguenti finestre, lasciare deselezionata la casella di controllo Progetto vuoto e l'IDE genererà uno stub di programma.
Se dai un'occhiata da vicino al codice per il file project_name.cpp, troverai tutto ciò di cui abbiamo discusso: la variabile della struttura MSG, riempiendo la struttura WNDCLASS, creando una finestra con la funzione CreateWindow, il ciclo principale del programma. Inoltre, il file definisce la funzione WndProc. Elabora diversi messaggi nei rami switch: WM_COMMAND, WM_PAINT, WM_DESTROY. Trova tutto nel file.
Oltre a ciò che abbiamo visto, il programma contiene molto codice aggiuntivo. Nel prossimo numero, esamineremo il codice del programma in cui verrà tagliato tutto ciò che non è necessario. Sarà molto più semplice e chiaro di quello che genera l'IDE.
C WinAPI è il set principale di interfacce di programmazione (API) Microsoft disponibili sui sistemi operativi Prima versione è stata chiamata API Win32.
introduzione
C WinAPI è un'interfaccia di programmazione dell'applicazione che viene utilizzata per creare applicazioni Windows. Per iniziare, un utente inesperto deve scaricare Windows SDK, precedentemente noto come Platform SDK.
Contiene file di intestazione, librerie, esempi, documentazione e strumenti utilizzati per sviluppare applicazioni. API per i linguaggi di programmazione C e C ++. Questo è il modo più diretto dall'azienda per creare applicazioni sul sistema operativo.
C WinAPI può essere suddiviso in diverse aree:
interfaccia utente;
multimedia;
shell di Windows;
servizi di rete.
servizi di base;
sicurezza;
I servizi di base forniscono accesso alle risorse di base. Questi includono funzioni C WinAPI, file system, dispositivi, processi, thread, registro e gestione degli errori. Il regno della sicurezza fornisce interfacce, oggetti e altri elementi di programmazione per autenticazione, autorizzazione, crittografia e altre attività relative alla sicurezza. Il sottosistema grafico offre funzionalità per la trasmissione di contenuti grafici a monitor, stampanti e altri dispositivi di output. L'interfaccia utente fornisce funzionalità per la creazione di finestre e controlli.
Il componente multimediale fornisce strumenti per lavorare con dispositivi video, audio e di input. Le funzioni dell'interfaccia Shell consentono alle applicazioni di accedere alle funzioni fornite dalla shell del sistema operativo. I servizi di rete forniscono accesso alle funzionalità di rete di Windows.
componenti
Quando si crea WinAPI C, considerare le funzionalità sottostanti fornite dall'API di Windows, che possono essere organizzate in sette categorie. Consideriamo ciascuno di essi in modo più dettagliato.
I servizi essenziali forniscono l'accesso alle risorse di sistema di base disponibili in Windows. Esempi: file system, periferiche, processi, accesso al registro e un sistema di gestione delle eccezioni. Queste funzioni sono archiviate in kernel.exe, krnl286.exe o krnl386.exe per sistemi a 16 bit e kernel32.dll e advapi32.dll per sistemi a 32 bit.
L'interfaccia grafica fornisce l'accesso alle risorse per la visualizzazione su monitor, stampanti e altre apparecchiature periferiche. Memorizzato in gdi.exe su sistemi a 16 bit e gdi32.dll su sistemi a 32 bit.
L'interfaccia utente è responsabile della visualizzazione e della manipolazione di elementi di base come pulsanti e barre di scorrimento, recupero di informazioni su tastiera e mouse e funzioni correlate. Queste funzioni sono memorizzate nel file user.exe su sistemi a 16 bit e user32.dll comctl32.dll su sistemi a 32 bit. A partire da XP, i controlli sono stati raggruppati in comctl32.dll.
Finestre di dialogo generali: visualizza i dati per l'apertura e il salvataggio dei file, la scelta di colori e caratteri. Si trovano in comdlg.dll su sistemi a 16 bit e comdlg32.dll su sistemi a 32 bit.
Windows Shell è un componente WinAPI che consente alle applicazioni di accedere alle funzionalità fornite dalla shell del sistema operativo.
I servizi di rete forniscono l'accesso a varie funzionalità di rete del sistema operativo. I suoi sottocomponenti includono NetBIOS, Winsock, RPC. Nelle versioni precedenti - NetDDE.
versioni
Win16, Win32 e Win32s sono insiemi standard di componenti che consentono al software applicativo di utilizzare la funzionalità di vari sistemi operativi Windows.
Win32, il successore di Win16, è stato introdotto nel 1993 in prodotti Windows a 32 bit come Windows NT, 2000, 95. Questo interfaccia software implementato da tre librerie software: Kernel32.dll, User32.dll e GDI32.dll2. Le stesse funzionalità di Win32 sono disponibili in tutti i prodotti Windows e, a seconda del prodotto, l'utilizzo di determinate funzionalità può causare un errore di servizio.
Le funzionalità di Win32 includono l'interoperabilità tra programmi, controllo di processi, reti di computer, file, stampanti, server e porte di comunicazione.
specificazione
C WinAPI è una specifica astratta di un'interfaccia di programmazione per un funzionamento sistemi Windows... È costituito da dichiarazioni di funzioni, unioni, strutture, tipi di dati, macro, costanti e altri elementi di programmazione. WinAPI è descritto principalmente e si trova nelle intestazioni di Windows C. L'implementazione ufficiale delle funzioni WinAPI è nelle librerie a collegamento dinamico (DLL): ad esempio kernel32.dll, user32.dll, gdi32.dll o shell32.dll nella directory di sistema. Esistono implementazioni di terze parti dell'API di Windows: principalmente il progetto Wine e il progetto ReactOS.
L'API di Windows è un oggetto dinamico. Il numero di funzioni è in costante aumento con ciascuna nuova versione Sistema operativo e nuovi service pack. Esistono inoltre importanti differenze tra le versioni dei server e le versioni desktop del sistema operativo. Alcune funzionalità non sono documentate ufficialmente.
Pelles C
Pelles C è un programma gratuito e il miglior compilatore C e ambiente di sviluppo integrato (IDE) per il linguaggio di programmazione C. Supporta Windows a 32 bit (x86) e Windows a 64 bit (x64). Implementa gli standard C99 e C11. Pelles C ha un editor di risorse incorporato, bitmap, editor di icone e cursori ed editor di dump esadecimali. È stato sviluppato dallo sviluppatore svedese Pelle Orinius. Il nome del compilatore prende il nome dal suo autore. Viene fornito con un SDK, quindi il programmatore può iniziare immediatamente a creare applicazioni senza ulteriore installazione.
Errore dell'architettura di destinazione
Per creare programmi API Windows, è necessario abilitare le estensioni Microsoft. Sono disabilitati per impostazione predefinita, il che fa sì che il compilatore emetta il seguente messaggio di errore, che è un esempio di errore WinAPI C: errore irreversibile # 1014: #error: "Nessuna architettura di destinazione". Per abilitare le estensioni Microsoft, vai alle opzioni del progetto e seleziona la scheda Compilatore. In questa scheda, attiva la casella di controllo "Abilita estensioni Microsoft".
MSDN
È il portale centrale per lo sviluppo di Windows. Questa è una vasta raccolta di materiali relativi allo sviluppo di applicazioni che utilizzano strumenti Microsoft. Questo è il database più completo insieme alla documentazione per lo sviluppo di applicazioni desktop e un elenco di API di Windows.
Utilizzo di DLL in WinAPI C
La libreria dei controlli comuni fornisce l'accesso a funzionalità avanzate del sistema operativo come barre di stato, barre di avanzamento, barre degli strumenti e schede. Questi comandi si trovano in commctrl.dll su sistemi a 16 bit e comctl32.dll e sono raggruppati insieme all'interfaccia utente.
DLL è un formato di file di libreria a collegamento dinamico utilizzato per memorizzare più codici e procedure per programmi Windows... I file DLL sono stati creati in modo tale che diversi programmi possano utilizzare le loro informazioni contemporaneamente, contribuendo a risparmiare memoria. Consente all'utente di modificare la codifica di più applicazioni contemporaneamente senza modificarle. Le DLL possono essere convertite in statiche usando MSIL Disassembler o DLL per Lib 3.00.
Come API di Windows, WinAPI offre molte potenti funzionalità che ti consentono di creare i tuoi programmi, dalla semplice elaborazione di file alla creazione di un'interfaccia grafica per la programmazione di driver di dispositivo di basso livello.
Prima di iniziare a programmare in WinAPI, è necessario configurare l'ambiente per il codice in Windows. Dal momento che non lo è distribuzione Linux, non ha un compilatore integrato per la creazione di applicazioni. Considera le seguenti opzioni per compilare il tuo codice:
Per Windows, è disponibile un kit di sviluppo che fornisce documentazione e strumenti per consentire agli sviluppatori di creare software utilizzando le API e le tecnologie correlate.
L'API di Windows (interfaccia di programmazione dell'applicazione) è un'interfaccia di programmazione del sistema in modalità utente per la famiglia di sistemi operativi Windows. Prima del rilascio delle versioni a 64 bit di Windows, l'API per le versioni a 32 bit dei sistemi operativi Windows era chiamata API Win32 per distinguerla dall'originale a 16 bit versioni di Windows API (che fungeva da interfaccia di programmazione per le versioni iniziali di Windows a 16 bit).
L'API di Windows è composta da diverse migliaia di funzioni richiamabili, che sono suddivise nelle seguenti categorie principali:
- Servizi di base.
- Servizi componenti
- Servizi di interfaccia utente.
- Servizi grafici e multimediali.
- Messaggistica e collaborazione.
- Networking.
- Servizi web.
Per una descrizione dell'API di Windows, consultare la documentazione per WindowsSoftwareDevelopmentKit (SDK). Questa documentazione è disponibile su www.msdn.microsoft.com. È inoltre incluso con tutti i livelli di abbonamento in Microsoft DeveloperNetwork (MSDN) per gli sviluppatori.
Microsoft .NET Framework è costituito da una libreria di classi denominata Framework Class Library (FCL) e Common Language Runtime (CLR). Il CLR ha funzionalità per la compilazione tempestiva, il controllo del tipo, la garbage collection e la sicurezza dell'accesso al codice. Offrendo queste funzionalità, il CLR fornisce un ambiente di sviluppo che migliora la produttività del programmatore e riduce gli errori di programmazione più comuni.
Il CLR è implementato come un classico server COM, il cui codice risiede in una DLL Windows standard per la modalità utente. Praticamente tutti i componenti di .NET Framework sono implementati come windows standard DLL in modalità utente sovrapposte a funzioni API Windows non gestite. (Nessuno dei componenti di .NET Framework viene eseguito in modalità kernel.) La figura mostra la relazione tra questi componenti.
Servizi, funzioni e programmi standard.
Alcuni termini nella documentazione di utenti e programmi di Windows hanno significati diversi in contesti diversi. Ad esempio, il servizio di parole può fare riferimento a un richiamo di routine nel sistema operativo, un driver di dispositivo o un processo di servizio. Cosa significano esattamente questi termini è mostrato nel seguente elenco:
- Funzioni dell'API di Windows... Routine richiamabili documentate nell'API Windows. Ad esempio CreateProcess, CreateFile e GetMessage.
- Servizi di sistema nativi (o chiamate di sistema)... Servizi sottostanti non documentati nel sistema operativo che vengono richiamati durante l'esecuzione in modalità utente. Ad esempio, NtCreateUserProcess è un servizio interno che la funzione CreateProcess di Windows chiama per creare un nuovo processo.
- Funzioni di supporto del kernel (o subroutine)... Routine all'interno del sistema operativo Windows che possono essere chiamate solo dalla modalità kernel. Ad esempio, ExAllocatePoolWithTag è una routine chiamata dai driver di dispositivo per allocare memoria dagli heap di sistema di Windows (chiamati pool).
- Servizi di Windows. Processi avviati da Gestione controllo servizi (Windowsservicecontrolmanager). Ad esempio, il servizio Task Manager si avvia come un processo in modalità utente che supporta il comando at (simile ai comandi UNIX at o cron).
- DLL (librerie a collegamento dinamico)... Una raccolta di routine richiamabili collegate tra loro come file binario che possono essere caricate dinamicamente dalle applicazioni che utilizzano tali routine. Gli esempi includono Msvcrt.dll (una libreria di runtime per applicazioni C) e Kernel32.dll (una delle librerie del sottosistema API di Windows). Le DLL sono ampiamente utilizzate dai componenti e applicazioni Windowseseguito in modalità utente. Il vantaggio delle DLL rispetto alle librerie statiche è che possono essere utilizzate da più applicazioni contemporaneamente e Windows garantisce che sia presente una sola copia del codice DLL per le applicazioni che fanno riferimento alla DLL. Si noti che gli assembly .NET non eseguibili vengono compilati come DLL, ma senza routine esportate. Il CLR analizza i metadati compilati per accedere ai tipi e ai membri della classe appropriati.
Storia dell'API Win32.
È interessante notare che Win32 non doveva essere l'interfaccia di programmazione originale per quella che allora veniva chiamata Windows NT. Da quando il progetto di Windows NT è iniziato come sostituto di OS / 2 versione 2, l'interfaccia di programmazione originale era l'OS / 2 PresentationManagerAPI a 32 bit. Ma un anno dopo il lancio del progetto, il Microsoft Windows 3.0. Di conseguenza, Microsoft ha cambiato direzione e ha reso Windows NT un futuro sostituto per la famiglia di prodotti Windows, non un sostituto per OS / 2. A questo proposito, è diventato necessario sviluppare una specifica per l'API di Windows - prima che, in Windows 3.0, l'API esistesse solo come interfaccia a 16 bit.
Sebbene l'API di Windows sia stata programmata per introdurre molte nuove funzionalità che non erano disponibili in Windows 3.1, Microsoft ha deciso di rendere la nuova API il più compatibile possibile in nomi, semantica e tipi di dati con l'API di Windows a 16 bit per facilitare l'onere del porting di Windows a 16 bit esistente -applicazioni in Windows NT. Questo, infatti, spiega il fatto che molti dei nomi di funzioni e interfacce possono sembrare incoerenti: questo era necessario per garantire la compatibilità nuove finestre API con la vecchia API di Windows a 16 bit.
