API windows en C/C++ [ pas finie 10% ]

API windows

Pour apprendre à ce servir de l' API windows, il faut savoir maîtriser le C.
API signifie Application Programming Interface

Les bases de l' api windows:

Pour faire une API dans un code en C
#include <windows.h>//directive de préprocesseur

/* vous pouvez rajouter entre int et WinMain WINAPI ou APIENTRY
si le code quand vous compilez a des éreurs. */

int WinMain (//Fonction principale de l' api en C
//ci dessous se trouvent les paramètres qu' elle doit prendre

HINSTANCE cetteInstance,/*Le premier argument est l'instance actuelle de votre programme. C'est en quelque sorte une "boîte" représentant votre programme et imbriquant tout ce qu'il contient (pour ne pas vous encombrer la tête) :*/

HINSTANCE precedenteInstance,/*Le deuxième argument désigne l'instance précédente. En fait ce paramètre date de Windows 16bits et est donc obsolète. Il vaut donc toujours NULL :*/

LPSTR lignesDeCommande,/*# Le troisième argument remplace justement argv que vous connaissez déjà dans le prototype du main console ou SDL. Cependant il est dans sa forme brute et vous ne pourrez donc pas l'utiliser de suite*/

int modeDAffichage/*il s'agit du mode d'affichage (visible, invisible, minimisé etc...) de la fenêtre principale*/
)
{
// les variables pour afficher une fenêtre:
HWND fenetrePrincipale;/*fenetrePrincipale est de type HWND, qui veut dire handle de fenêtre. Si vous connaissez un minimum l'anglais, vous remarquerez que l'on pourrait le traduire par poignée (la variable fenetrePrincipale est une sorte de "poignée" nous permettant d'agir sur la fenêtre principale. Cette structure possède en outre toutes les informations sur la fenêtre nécessaires à son affichage. Bien sûr, ce handle ayant un nom, cela nous permet d'identifier par le nom d'une variable la fenêtre créée.)*/

MSG message;/*la variable message, quant à elle, est comme son nom l'indique un message système, utilisé pour communiquer entre l'utilisateur et les fenêtres : il s'agit en fait du descriptif d'un événement. (exemple d' événements: touche appuyée(s), relachée(s), bouton x; z; sourie; joystick; etc... appuyé(s) ou relaché(s) )*/

WNDCLASS classeFenetre;/*classeFenetre est la classe de fenêtre nécessaire à la construction de la fenêtre principale. C'est en fait une liste d'informations permettant par la suite de créer la fenêtre selon notre bon vouloir. En C++, lorsque que l' on créé une classe, la définition est différente.*/
//pour remplir une fenêtre:
classeFenetre.style=0; //style de la fenêtre

classeFenetre.lpfnWndProc = procedureFenetrePrincipale;/* Le champ 2 définit la fonction callback à utiliser pour cette fenêtre
Fonction callback : fonction chargée de traiter les messages envoyés à une fenêtre, ou à un contrôle. Aussi dénommée procédure. Exemple :
LRESULT CALLBACK MainWndProc(HWND, UINT, WPARAM, LPARAM);*/

classeFenetre.cbClsExtra = 0;/*Le champ 3 définit combien de bytes en plus seront alloués à la suite de la structure*/

classeFenetre.cbWndExtra = 0;/*Le champ 4 définit la même chose, mais suite à l'instance.*/

classeFenetre.hInstance = cetteInstance;/*Le champ 5 définit l'instance à laquelle appartient la fenêtre :*/

classeFenetre.hIcon = LoadIcon(NULL, IDI_APPLICATION);/*Le champ 6 définit l'icône à utiliser pour la fenêtre (en haut à gauche). Elle doit être chargée soit en passant par les ressources, soit comme suit, avec une icône inclue à Windows possédant un ID spécifique*/

classeFenetre.hCursor = LoadCursor(NULL, IDC_ARROW);/*Le champ 7 définit le curseur par défaut à utiliser pour cette fenêtre */

classeFenetre.hbrBackground = (HBRUSH)(1 + COLOR_BTNFACE);/*Le champ 8 définit la couleur à utiliser pour le fond de la fenêtre. Son type est HBRUSH, (traduit brosse) et peut être changé grâce à une fonction de conversion RGB->HBRUSH*/

classeFenetre.lpszMenuName = NULL;/*Le champ 9 définit le menu associé à cette fenêtre*/

classeFenetre.lpszClassName = "classeF";/*Et enfin le le champ 10 qui sera le nom de la classe en question*/

RegisterClass(&classeFenetre)//Pour enregistrer la fenêtre

HWND CreateWindow(
LPCTSTR lpClassName, /*L'argument 1 désigne la classe de fenêtre à partir de laquelle la fenêtre va être créée*/

LPCTSTR lpWindowName,/*L'argument 2 désigne le nom de la fenêtre, c'est à dire, dans le cas d'une fenêtre, la string qui va être affichée en guise de titre*/

DWORD dwStyle,
/*L'argument 3 désigne les styles à donner à la fenêtre */
// Le type DWORD correspond unsigned long
/* tout ce que je mets en "commentaire" C dans les fonctions, à l' endroit
des paramètre n' est surtout pas à refaire dans vos codes... Sinon, vos codes
ne marcheront pas.
C'est juste pour séparer les explications du code.*/

//Désignent respectivement:
int x, //les coordonnées du coin supérieur gauche
int y, //les coordonnées du coin supérieur gauche
int nWidth, //la largeur
int nHeight, //la hauteur de la fenêtre

HWND hWndParent,//L'argument 8 désigne le handle de la fenêtre parent

HMENU hMenu, /*L'argument 9 désigne, dans le cas d'une fenêtre, le menu associé à celle-ci, et dans le cas d'un contrôle, son ID. (pour pouvoir le manipuler)*/

HANDLE hInstance,//L'argument 10 désigne l'instance du programme

LPVOID lpParam /*L'argument 11 Désigne les éventuels paramètres à envoyer à la fenêtre à sa création
LPVOID = équivalent de void*/

/* un exemple d' un code trouvé sur le net:

Code:: fenetePrincipale = CreateWindow("classeF",
"Première fenêtre en winAPI !",
WS_OVERLAPPEDWINDOW, /*Style qui permet d'avoir une fenêtre tout ce qu'il y a de plus normal : barre de titre, menu système (réduire, maximiser, fermer), bordure etc...*/
CW_USEDEFAULT, // Permet à l'OS de déterminer dynamiquement la position de la fenêtre
CW_USEDEFAULT, //Idem
400,
300,
NULL, // Pas de fenêtre parent, puisque c'est la principale
NULL, //Aucun menu ne lui est associé
cetteInstance,
NULL); // Aucun paramètre à lui envoyer en plus

*/

);/*Cette fonction permet de créer une fenêtre. Bien sûr, il faudra la stocker dans une variable.
Attention: CreateWindow ne crée pas vraiment que des fenêtres au sens connu, mais toutes les sortes de contrôles, que cela soit : fenêtre, bouton, listbox, progressbar etc...*/
// On aurait pu la rendre visible avec WS_VISIBLE à l' OS
//Mais pour l' afficher correctement, on utilise:
ShowWindow(fenetrePrincipale,SW_SHOW); /* A la place de SW_SHOW, vous pouvez utiliser utiliser le paramètre de WinMain modeDAffichage, soit utiliser la valeur qu'il prend d'habitude donc SW_SHOW*/
/*Pour la flipper on va mettre la fonction UpdateWindow(paramètre), prenant comme seul paramètre le handle de la fenêtre. Vous l'utiliserez sûrement beaucoup après avoir créé des contrôles enfants d'une fenêtre afin de rafraîchir l'écran juste après leur création. */

return 0;
}
BOOL GetMessage(LPMSG msg, HWND hwnd, UINT wMsgFilterMin, UINT wMsgFilterMax);//renvoye les messages de l' utilisateur

/* LPMSG msg, L'argument 1 désigne le message récupérateur des événements

HWND hwnd, L'argument 2 désigne le handle de fenêtre dont GetMessage va récupérer les événements */
while (GetMessage(&message, NULL, 0, 0)) /*Récupération des évènements de toutes les fenêtres de l'instance dans message*/
{
TranslateMessage(&message); // Traduction de l'événement
DispatchMessage(&message); // Envoi du message correspondant à la fenêtre conçernée
}

LRESULT CALLBACK procedureFenetrePrincipale(HWND fenetrePrincipale, UINT message, WPARAM wParam, LPARAM lParam);
/*Fonction callback : fonction chargée de traiter les messages envoyés à une fenêtre, ou à un contrôle. Aussi dénommée procédure.

HWND fenetrePrincipale, Le paramètre 1 désigne le handle de la fenêtre concernée

UINT message, Le paramètre 2 désigne le message envoyé par la boucle événementielle traité

WPARAM wParam, LPARAM lParam
Les paramètres 3 et 4 désignent des pointeurs d'int chargés d'apporter des précisions sur l'origine du message

On traite en général les messages de la manière suivante:

Code:: LRESULT CALLBACK procedureFenetrePrincipale(HWND fenetrePrincipale, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_CREATE:
return 0;

case WM_DESTROY:
PostQuitMessage(0);
return 0;

default:
return DefWindowProc(fenetrePrincipale, message, wParam, lParam);
}
}

*WM_CREATE est envoyé à la création de la fenêtre. (Vous pourrez par ailleurs récupérer l'argument optionnel n°11 de CreateWindow à cet endroit)
*WM_DESTROY est envoyé lors du clic sur la croix en haut à droite que vous connaissez si bien Wink

Ici, il est traité et PostQuitMessage est exécuté : il s'agit d'une fonction permettant de quitter simplement et proprement le programme. Elle prend comme unique argument 0.
*Si aucun message déclaré explicitement n'est perçu, on retourne la procédure par défaut fournie par DefWindowProc.

*/

/*Les classes pour créer:
BUTTON : Permettant de créer un bouton.
LISTBOX : Permettant de créer une liste de choix
STATIC : Permettant toutes sortes de choses, comme des images, des groupbox etc...
exemple:*/
LRESULT CALLBACK procedureFenetrePrincipale(HWND fenetrePrincipale, UINT message, WPARAM wParam, LPARAM lParam)
{
static HWND boutons[2] = {NULL};
//Suite:
case WM_CREATE:
boutons[0] = CreateWindow("BUTTON", "Parler", WS_CHILD | WS_VISIBLE,
5, 5, 383, 30, fenetrePrincipale, ID_B_PARLER, instance, NULL);
boutons[1] = CreateWindow("BUTTON", "Quitter", WS_CHILD | WS_VISIBLE,
5, 45, 383, 30, fenetrePrincipale, ID_B_QUITTER, instance, NULL);
return 0;
/* WS_CHILD solidarise le contrôle à la fenêtre parent. Sans lui, le contrôle flotterait "en l'air", en dehors de la fenêtre.
WS_VISIBLE affiche le contrôle. (donc pas besoin de ShowWindow)*/

LOWORD()
HIWORD()/*Ces deux fonctions permettent de trouver des mots haut ou bas niveaux. */

WM_COMMAND: // a mettre dans une condtion avec switch...
//détermine l'ID du bouton qui a été cliqué

LRESULT SendMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
/* Préparer le message pour le bouton..*/

SendMessage(fenetrePrincipale, WM_DESTROY, 0, 0);/*Envoye le message WM_DESTROY, celui qui permet de quitter le programme... */

int MessageBox(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType);/*déclaration de la fonction qui enverra un texte à l' écran */
MessageBox(fenetrePrincipale, "Clic !", "Bonjour.", MB_ICONINFORMATION);/*
envoye une message qui dit "Bonjour."
MB_ICONINFORMATION est une constante permettant d'ajouter un bouton 'OK' à la messagebox et une icône en forme de bulle.
Vous n'avez plus qu'à placer ce code dans le 'case ID_B_PARLER' du callback. */

HMENU menu, sousMenu;
HMENU CreateMenu(VOID);/* créé un menu.*/
BOOL AppendMenu(HMENU hMenu, UINT uFlags, UINT_PTR uIDNewItem, LPCSTR lpNewItem);/* créée une entrée pour ce menu les arguements de cette fonction sont:

HMENU hMenu Le menu avec lequel elle est assotiée.

UINT uFlags L'argument 2 désigne le type de l'entrée, mais aussi par association de flags, des options facultatives (désactivé, coché, illustré etc...)

UINT_PTR uIDNewItem L'argument 3 désigne, dans le cas d'une commande, son ID (ayant le même effet que ceux des boutons), ou dans le cas d'une entrée popup, le handle du sous menu associé

LPCSTR lpNewItem L'argument 4 désigne le nom affiché par l'entrée

Si vous voulez créer une entrée popup (donc un sous menu), le uFlags doit correspondre à la valeur MF_POPUP. Dans le cas d'une commande, il doit être égal à MF_STRING.
Les séparateurs peuvent, eux, être créés avec MF_SEPARATOR. (les deux derniers paramètres seront alors ignorés)

Bien sûr, les sous menus doivent être définis avant d'être associés à un menu, ou dans le cas contraire celui ci n'aurait rien à intégrer.

Les mots cléfs BEGIN et END : sont une autre notation utilisée en ressources pour les accolades ouvrantes et fermantes.

Comme vous pouvez le voir, ID_MENU n'est pas visible : il s'agit de l'identificateur du menu. (d'ailleurs, bien qu'il soit un ID, il n'a pas besoin d'être défini) Seules les entrées entre ses BEGIN et END sont visibles : POPUP désigne les menus déroulants, et MENUITEM une commande (je suppose que vous savez ce que signifie SEPARATOR désormais Wink

). Les ID de chaque commande doivent être spécifiés après le nom affiché et une virgule.

Après avoir créé le menu, encore faut-il le récupérer en vue de l'associer à la fenêtre. Pour cela, on utilise LoadMenu. Cette fonction, prenant comme premier paramètre l'instance actuelle, et en deuxième l'ID du menu, se charge de renvoyer un handle de menu. En utilisant ce handle de menu, vous pourrez l'utiliser lors de CreateWindow ou SetMenu (voir méthodes d'associations ci-après) */

fenetrePrincipale = CreateWindow("classeF", "Ma premiere fenetre winAPI !", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 400, 130, NULL, <gras>menu</gras>, cetteInstance, NULL);/*Créé un menu qui aura pour mère fenetrePrincipale*/
classeFenetre.lpszMenuName = "MENU";//Nom du menu...
SetMenu(fenetrePrincipale, LoadMenu(instance, "ID_MENU"));//charge le menu...

/*Dès la création d' un menu : Spécifier le flag MF_DISABLED pour désactiver l'entrée (MF_ENABLED, permettant de l'activer étant par défaut), ou MF_GRAYED pour le griser.*/
MENUITEM "Parler", ID_B_PARLER, MF_GRAYED

/* Pendant le reste du code : Utiliser la fonction EnableMenuItem prenant comme premier paramètre le handle de menu, comme deuxième soit l'emplacement (basé sur 0) de l'entrée, soit sa commande (choix étant spécifié par la valeur du troisième paramètre), et comme troisième son mode, par combinaison de son mode de détermination (MF_BYCOMMAND implique d'utiliser la commande pour le deuxième paramètre, et MF_BYPOSITION l'inverse) et le mode d'affichage, étant les mêmes valeurs possibles que pour les flags des entrées décrits-ci dessous*/

EnableMenuItem(menu, ID_B_PARLER, MF_BYCOMMAND | MF_GRAYED);

/*Dès la création du menu, on peut spécifier le flag MF_CHECKED (pour coché) ou MF_UNCHECKED (valeur par défaut, non coché).*/
MENUITEM "Parler", ID_B_PARLER, MF_CHECKED

/*Pendant le reste du code : Utiliser la fonction CheckMenuItem, prenant comme premier paramètre le handle de menu concerné, et pour les deuxième et troisième paramètres le même système que pour EnableMenuItem, excepté le fait que les états possibles sont ceux spécifiés ci dessous.*/
CheckMenuItem(menu, ID_B_PARLER, MF_BYCOMMAND | MF_CHECKED);

/*Rajouter un menu popup, au même niveau que "Actions", mais ayant pour nom "Aide". Dans celui ci, une entrée-commande sera ajoutée, portant "A propos" comme nom, et ID_B_APROPOS comme ID. */
POPUP "Aide"
BEGIN
MENUITEM "A propos", ID_B_APROPOS
END

/*Lle mot clé MENU est remplacé par DIALOG (ou DIALOGEX, si vous utilisez des styles étendus), et des informations supplémentaires comme sa position/largeur/hauteur, ses styles et son titre sont rajoutés juste avant la définition. Un schéma basique de boîte de dialogue peut alors être le suivant */

ID_DIALOGUE DIALOG
CW_USEDEFAULT, CW_USEDEFAULT, 200, 120
STYLE WS_OVERLAPPEDWINDOW
CAPTION "Titre"
BEGIN
END

/*WS_OVERLAPPEDWINDOW rend la boîte de dialogue modale, parfaitement banale : barre de titre, menu système (réduire, fermer etc.)... tous les styles applicables aux fenêtres principales (contenus donc dans le champ uStyle de la WNDCLASS) le sont ici. Quant à CAPTION, (dont la traduction française donne "Titre") il indique la chaîne de caractères à afficher dans la barre de titre. (d'où son nom) */

/*Chaque ajout de contrôle s'exécute par l'intermédiaire de mots clés. Sauf exception les lignes de "déclaration" de contrôles en utilisant ces mots clés possède une organisation comme celle-ci */
MOTCLE TEXTE_ASSOCIE, ID, x, y, w, h, STYLES

//Où x et y sont les coordonnées du coin supérieur gauche du contrôle, et w et h les //dimensions du contrôle.

/*Par exemple, un bouton possède comme mot clé PUSHBUTTON. S'il est le bouton par défaut, il est alors DEFPUSHBUTTON.
Une icône possède le même mot clé que pendant une intégration à l'exécutable de celle ci, en passant par les ressources, à savoir ICON.
Enfin, du texte peut être affiché avec le mot clé LTEXT (justifié à gauche) ou RTEXT (justifié à droite).*/
icone1 ICON "chemin/icone.ico"// Choisit une incone..
BOOL APIENTRY// La fonction calback doit renvoyer cette valeur!

ChapII

» HTML [Pas encore finie]
» Base Hexadécimale, binaire, etc... [Pas encore finie. ]