Discussion :

[jdsetls]

Bonjour,

Qui utilise les API Windows et de quelle façon ?
J'ai l'impression qu'on peut absolument tout faire avec, sauf qu'elles sont un peu décourageantes en terme de convivialité.

Qu'en pensez-vous ?

Merci
Cordialement

[Patrice Terrier]

Principalement les programmeurs système, les programmeurs de jeux, et les fournisseurs de composants qui proposent des "addons" sous forme de DLL Win32, seul format compatible avec tous les langage de programmation Windows, à condition d'utiliser la convention d'appel _stdcall au lieu de _cdecl.

Bien entendu pas question de MFC ni d'ATL et encore moins de DotNET

Quelques avantage qui résultent de l'utilisation directe de l'API Windows bas niveau :
- Il n'y a aucune encapsulation, donc pas de Framework supplémentaire à télécharger.
- Le code est très rapide et très compacte car tout est déjà dans la Flat API de Windows.
- On peut contourner les bugs des langages "évolués".
- On peut créer ses propres composants.
etc.

Pour ceux qui parlent anglais, voir ma profession de foi ici :
http://www.jose.it-berater.org/smffo...p?topic=1129.0

et pour ceux qui veulent en apprendre plus sur la programmation bas niveau (en anglais), voir là :
http://www.jose.it-berater.org/smffo...hp?board=151.0

...

[jurassic pork]

hello Patrice,

Bien entendu pas question de MFC ni d'ATL et encore moins de DotNET

Qu'entends-tu par là ?

[jdsetls]

Principalement les programmeurs système, les programmeurs de jeux, et les fournisseurs de composants qui proposent des "addons" sous forme de DLL Win32, seul format compatible avec tous les langage de programmation Windows, à condition d'utiliser la convention d'appel _stdcall au lieu de _cdecl.

Bien entendu pas question de MFC ni d'ATL et encore moins de DotNET

Quelques avantage qui résultent de l'utilisation directe de l'API Windows bas niveau :
- Il n'y a aucune encapsulation, donc pas de Framework supplémentaire à télécharger.
- Le code est très rapide et très compacte car tout est déjà dans la Flat API de Windows.
- On peut contourner les bugs des langages "évolués".
- On peut créer ses propres composants.
etc.

Pour ceux qui parlent anglais, voir ma profession de foi ici :
http://www.jose.it-berater.org/smffo...p?topic=1129.0

et pour ceux qui veulent en apprendre plus sur la programmation bas niveau (en anglais), voir là :
http://www.jose.it-berater.org/smffo...hp?board=151.0

...

Bonjour Patrice Terrier,
Peux tu nous apprendre à utiliser l'API du GDI qui permet de créer un cube, avec s'il te plait, l'usage des couleurs ?
Donc et merci d'avance, comment puis-je créer un cube dans une zone image, et le paramétrer depuis Windev ?
Merci,
Cordialement

nb : Si tu pouvais me fournir le code de tes programmes graphiques, j'aurai également des codes et programmes à te donner.
Et je te mentionnerai avec ton adresse professionnelle, dans la prochaine révision de mon livre sur Windev 2014.

[jdsetls]

Bonjour,
Si j'ai bien compris, la cinquième édition du livre de Charles Petzold SDK est 'culte'.
Je me souviens avoir acheté un des tout premiers bouquin en américain sur les API.
Un pavé dans les 1300 pages.
Cordialement

[Patrice Terrier]

Qu'entends-tu par là ?

Depuis de nombreuses années, toute la politique de Microsoft a été de détourner les "programmeurs" de la programmation bas niveau.
Sous prétexte que le code "managé" est plus sûr que le code bas niveau qui lui est "unsafe", résultat les jeunes informaticiens ne savent plus programmer en utilisant directement le SDK, et il sont incapable d'écrire le moindre bout de code avec un simple éditeur ASCII et un compilateur en ligne de commande, et je ne parle même pas de la taille du code généré.

Je programme de temps en temps en C#, mais ne l'utilise jamais en production, uniquement pour des démos. Car je ne supporte pas d'attendre 45 secondes avant de pouvoir afficher "Hello world" la première fois qu'il doit charger le Framework DotNET.
En outre comme le code IL n'est pas du véritable code compilé, il est impossible de l'exécuter sans "run-time", dans ces conditions je préfère utiliser WinDev.

Concernant MFC et ATL, ils ne fonctionnent pas sans le CRT Microsoft, alors bonjour la galère quand la bonne version n'est pas installée sur la machine des clients, ou alors il faut utiliser à chaque fois un installateur, donc pas question d'envoyer simplement un ZIP avec juste l'EXE. Et comme je n'utilise pas la POO je n'ai rien à faire de MFC (Microsoft Foundation Class).

...

[DelphiManiac]

...
En outre comme le code IL n'est pas du véritable code compilé, il est impossible de l'exécuter sans "run-time", dans ces conditions je préfère utiliser WinDev....

Le code Winev n'est pas plus compilé que l'IL et Windev à tout autant besoin d'un runtime.

L'avantage de l'IL par rapport à Windev, c'est que le framework (au moins en version 2) est déployé nativement sur la plupart des versions de Windows.


Concernant les API, pourquoi pas quand on a besoin de performances maximales, sinon le reste du temps, c'est une "bétise" de se passer des framework, ceux ci apportent des fonctionnalités testées et validées. Pourquoi réinventer la roue à chaque fois ?

En allant à l’extrême, tu devrais te mettre à l'assembleur, cela semble bien correspondre à ta forme de pensée, mais ce n'est pas parce que tu penses d'une certaine manière que celle ci est la meilleure :/ La réciproque es tout autant valide.


Juste pour mon information, quand tu codes et que tu as besoin d'afficher une fenêtre, tu codes toi même, à chaque fois, la boucle de gestion des messages ?

[Patrice Terrier]

Le code Winev n'est pas plus compilé que l'IL et Windev à tout autant besoin d'un runtime.

Oui, vous avez tout à fait raison, WinDev est du p-code, mais je préfère utiliser WinDev que DotNET, car je n'ai pas à me prendre la tête pour m'interfacer avec les DLLs bas niveau.

Concernant les API, pourquoi pas quand on a besoin de performances maximales, sinon le reste du temps, c'est une "bétise" de se passer des framework, ceux ci apportent des fonctionnalités testées et validées. Pourquoi réinventer la roue à chaque fois ?

Je ne cherche pas à polémiquer, j'essaie de répondre aux questions qui me sont posées.
Je ne cherche pas non plus à réinventer la roue, puisque déjà tout existe dans l'API bas niveau

En allant à l’extrême, tu devrais te mettre à l'assembleur, cela semble bien correspondre à ta forme de pensée, mais ce n'est pas parce que tu penses d'une certaine manière que celle ci est la meilleure.

Pour ce qui est le cœur de mon métier, à savoir la programmation de composants, je n'ai pas le choix.
Par contre quand je dois écrire des applications complètes, je fais appel à WinDev, c'est pour cela qu'il fait partie de ma boîte à outils.

Concernant l'assembleur, pourquoi pas, lorsque c'est nécessaire...
Voici un exemple de calcul matriciel utilisé dans la version 32-bit de GDImage.dll (écrit en PowerBASIC)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
SUB MatrixMul5x5FPU(BYREF mr() AS SINGLE, BYREF m1() AS SINGLE, BYREF m2() AS SINGLE )
DIM p AS SINGLE PTR
 
p = VARPTR(m1(0))
! mov ecx,eax
p = VARPTR(m2(0))
! mov edx,eax
p = VARPTR(mr(0))
 
block:
! call column
! call column
! call column
! call column
! call column
EXIT SUB
 
column:
! call cell
! call cell
! call cell
! call cell
! call cell
! add edx,20
! sub ecx,20
! ret
 
cell: ' row A * column B
! fld   dword ptr [ecx   ]
! fmul  dword ptr [edx   ]
! fld   dword ptr [ecx+20]
! fmul  dword ptr [edx+04]
! fld   dword ptr [ecx+40]
! fmul  dword ptr [edx+08]
! fld   dword ptr [ecx+60]
! fmul  dword ptr [edx+12]
! fld   dword ptr [ecx+80]
! fmul  dword ptr [edx+16]
! faddp st(1),st(0)
! faddp st(1),st(0)
! faddp st(1),st(0)
! faddp st(1),st(0)
! fstp  dword ptr [eax]
! add   eax,4
! add   ecx,4
! ret
END SUB

Juste pour mon information, quand tu codes et que tu as besoin d'afficher une fenêtre, tu codes toi même, à chaque fois, la boucle de gestion des messages ?

Tout dépend du langage que j'utilise, mais les exemples que j'ai posté ici, sont issus du C++, alors j'utilise la seule syntaxe qui me permet de faire du copier coller de l'un à l'autre. Au passage çà permet de voir ce qu'il y a sous le capot, car n'oubliez pas que WinDev lui-même est programmé principalement en C++.

...

[jurassic pork]

hello,
je suis tout à fait d'accord avec DephiManiac concernant dotnet. Il est vrai que depuis windows 7 le framework dotnet est intégré à toutes les versions de windows. Sachant que c'est microsoft qui le produit autant dire que son intégration à windows est optimale. Patrice tu dis que tu attends 45 secondes pour que dotnet se lance la première fois, cela m'étonne fortement tu dois avoir un processeur un peu lent . L'avantage a l'utiliser dans windev par rapport aux api c'est que les objets dotnets sont vus comme des classes avec leurs methodes et leurs propriétés. Beaucoup plus facile à interfacer qu'avec les apis. Bien sur tout n'est pas parfait et il y a des assemblages dotnet que l'on arrive pas à utiliser dans windev mais la plupart du temps cela fonctionne.

Ami calmant, J.P

[jdsetls]

Bonjour,
La syntaxe se trouvant moins tchernobylesque lorsque les valeurs sont données en décimal plutôt qu'en hexadécimal, en voici la liste :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
SPI_GETBEEP = 1
SPI_SETBEEP = 2
SPI_GETMOUSE = 3
SPI_SETMOUSE = 4
SPI_GETBORDER = 5
SPI_SETBORDER = 6
SPI_GETKEYBOARDSPEED = 10
SPI_SETKEYBOARDSPEED = 11
SPI_LANGDRIVER = 12
SPI_ICONHORIZONTALSPACING = 13
SPI_GETSCREENSAVETIMEOUT = 14
SPI_SETSCREENSAVETIMEOUT = 15
SPI_GETSCREENSAVEACTIVE = 16
SPI_SETSCREENSAVEACTIVE = 17
SPI_GETGRIDGRANULARITY = 18
SPI_SETGRIDGRANULARITY = 19
SPI_SETDESKWALLPAPER = 20
SPI_SETDESKPATTERN = 21
SPI_GETKEYBOARDDELAY = 22
SPI_SETKEYBOARDDELAY = 23
SPI_ICONVERTICALSPACING = 24
SPI_GETICONTITLEWRAP = 25
SPI_SETICONTITLEWRAP = 26
SPI_GETMENUDROPALIGNMENT = 27
SPI_SETMENUDROPALIGNMENT = 28
SPI_SETDOUBLECLKWIDTH = 29
SPI_SETDOUBLECLKHEIGHT = 30
SPI_GETICONTITLELOGFONT = 31
SPI_SETDOUBLECLICKTIME = 32
SPI_SETMOUSEBUTTONSWAP = 33
SPI_SETICONTITLELOGFONT = 34
SPI_GETFASTTASKSWITCH = 35
SPI_SETFASTTASKSWITCH = 36
SPI_SETDRAGFULLWINDOWS = 37
SPI_GETDRAGFULLWINDOWS = 38
SPI_GETNONCLIENTMETRICS = 41
SPI_SETNONCLIENTMETRICS = 42
SPI_GETMINIMIZEDMETRICS = 43
SPI_SETMINIMIZEDMETRICS = 44
SPI_GETICONMETRICS = 45
SPI_SETICONMETRICS = 46
SPI_SETWORKAREA = 47
SPI_GETWORKAREA = 48
SPI_SETPENWINDOWS = 49
SPI_GETHIGHCONTRAST = 66
SPI_SETHIGHCONTRAST = 67
SPI_GETKEYBOARDPREF = 68
SPI_SETKEYBOARDPREF = 69
SPI_GETSCREENREADER = 70
SPI_SETSCREENREADER = 71
SPI_GETANIMATION = 72
SPI_SETANIMATION = 73
SPI_GETFONTSMOOTHING = 74
SPI_SETFONTSMOOTHING = 75
SPI_SETDRAGWIDTH = 76
SPI_SETDRAGHEIGHT = 77
SPI_SETHANDHELD = 78
SPI_GETLOWPOWERTIMEOUT = 79
SPI_GETPOWEROFFTIMEOUT = 80
SPI_SETLOWPOWERTIMEOUT = 81
SPI_SETPOWEROFFTIMEOUT = 82
SPI_GETLOWPOWERACTIVE = 83
SPI_GETPOWEROFFACTIVE = 84
SPI_SETLOWPOWERACTIVE = 85
SPI_SETPOWEROFFACTIVE = 86
SPI_SETCURSORS = 87
SPI_SETICONS = 88
SPI_GETDEFAULTINPUTLANG = 89
SPI_SETDEFAULTINPUTLANG = 90
SPI_SETLANGTOGGLE = 91
SPI_GETWINDOWSEXTENSION = 92
SPI_SETMOUSETRAILS = 93
SPI_GETMOUSETRAILS = 94
SPI_SETSCREENSAVERRUNNING = 97
SPI_SCREENSAVERRUNNING = SPI_SETSCREENSAVERRUNNING
SPI_GETFILTERKEYS = 50
SPI_SETFILTERKEYS = 51
SPI_GETTOGGLEKEYS = 52
SPI_SETTOGGLEKEYS = 53
SPI_GETMOUSEKEYS = 54
SPI_SETMOUSEKEYS = 55
SPI_GETSHOWSOUNDS = 56
SPI_SETSHOWSOUNDS = 57
SPI_GETSTICKYKEYS = 58
SPI_SETSTICKYKEYS = 59
SPI_GETACCESSTIMEOUT = 60
SPI_SETACCESSTIMEOUT = 61
SPI_GETSERIALKEYS = 62
SPI_SETSERIALKEYS = 63
SPI_GETSOUNDSENTRY = 64
SPI_SETSOUNDSENTRY = 65
SPI_GETSNAPTODEFBUTTON = 95
SPI_SETSNAPTODEFBUTTON = 96
SPI_GETMOUSEHOVERWIDTH = 98
SPI_SETMOUSEHOVERWIDTH = 99
SPI_GETMOUSEHOVERHEIGHT = 100
SPI_SETMOUSEHOVERHEIGHT = 101
SPI_GETMOUSEHOVERTIME = 102
SPI_SETMOUSEHOVERTIME = 103
SPI_GETWHEELSCROLLLINES = 104
SPI_SETWHEELSCROLLLINES = 105
SPI_GETMENUSHOWDELAY = 106
SPI_SETMENUSHOWDELAY = 107
SPI_GETSHOWIMEUI = 110
SPI_SETSHOWIMEUI = 111
SPI_GETMOUSESPEED = 112
SPI_SETMOUSESPEED = 113
SPI_GETSCREENSAVERRUNNING = 114
SPI_GETDESKWALLPAPER = 115
SPI_GETACTIVEWINDOWTRACKING = &H1000
SPI_SETACTIVEWINDOWTRACKING = &H1001
SPI_GETMENUANIMATION = &H1002
SPI_SETMENUANIMATION = &H1003
SPI_GETCOMBOBOXANIMATION = &H1004
SPI_SETCOMBOBOXANIMATION = &H1005
SPI_GETLISTBOXSMOOTHSCROLLING = &H1006
SPI_SETLISTBOXSMOOTHSCROLLING = &H1007
SPI_GETGRADIENTCAPTIONS = &H1008
SPI_SETGRADIENTCAPTIONS = &H1009
SPI_GETKEYBOARDCUES = &H100A
SPI_SETKEYBOARDCUES = &H100B
SPI_GETMENUUNDERLINES = SPI_GETKEYBOARDCUES
SPI_SETMENUUNDERLINES = SPI_SETKEYBOARDCUES
SPI_GETACTIVEWNDTRKZORDER = &H100C
SPI_SETACTIVEWNDTRKZORDER = &H100D
SPI_GETHOTTRACKING = &H100E
SPI_SETHOTTRACKING = &H100F
SPI_GETMENUFADE = &H1012
SPI_SETMENUFADE = &H1013
SPI_GETSELECTIONFADE = &H1014
SPI_SETSELECTIONFADE = &H1015
SPI_GETTOOLTIPANIMATION = &H1016
SPI_SETTOOLTIPANIMATION = &H1017
SPI_GETTOOLTIPFADE = &H1018
SPI_SETTOOLTIPFADE = &H1019
SPI_GETCURSORSHADOW = &H101A
SPI_SETCURSORSHADOW = &H101B
SPI_GETUIEFFECTS = &H103E
SPI_SETUIEFFECTS = &H103F
SPI_GETFOREGROUNDLOCKTIMEOUT = &H2000
SPI_SETFOREGROUNDLOCKTIMEOUT = &H2001
SPI_GETACTIVEWNDTRKTIMEOUT = &H2002
SPI_SETACTIVEWNDTRKTIMEOUT = &H2003
SPI_GETFOREGROUNDFLASHCOUNT = &H2004
SPI_SETFOREGROUNDFLASHCOUNT = &H2005
SPI_GETCARETWIDTH = &H2006
SPI_SETCARETWIDTH = &H2007

Cordialement,

[Patrice Terrier]

La liste que vous affichez, n'énumère pas des API disponibles, mais les propriétés qui peuvent être listées ou modifiées grâce à l'utilisation de la function SystemParametersInfo qui est le nom de l'API qui permet de lire ou modifier ces propriétés.

[jdsetls]

Dans mon enfance, c'était le titre d'une série pour enfant : Le club des cinq.
Ici, lorsque je poste un message même neutre ou seulement informatif, je me retrouve avec sept mauvais points faisant tomber mon score.
Donc je confirme ma position :
Je me sentirai réellement utile lorsque j'aurai obtenu un score négatif.
A vos clics...
Cordialement

[jdsetls]

Bonjour,
Les APIs commencent désormais à être simple, puisqu'il existe à partir d'une seule syntaxe, jusqu'à des centaines de déclinaisons possibles. Des centaines d'API différentes, sont soudain disponibles.
Nous avons vu au post précédent des exemples de fonctions Get qui fournissent une information.
Voici un exemple de fonction SET qui attribue une valeur.

Bonne surprise, lorsque dans le panneau de configuration je mets le curseur à droite, au maximum, l'API de vérification me donne une valeur de 7 traces.
Au contraire, avec la fonction SET je peux monter à seize traces de souris, ce dont j'avais précisément besoin.

Le code devient alors :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Zone_de_résultats = ""
RetourFonction est un booléen // Type C :BOOL
uiAction est un entier sans signe // Type C :UINT
uiParam est un entier sans signe // Type C :UINT
pvParam est un entier système // Type C :PVOID
fWinIni est un entier sans signe // Type C :UINT
nRésultat est un entier
 
uiParam = 16
uiAction = 0x005D // Action demandée ici 12 traces de souris
fWinIni = 1 //autorise la modification : indispensable
 
RetourFonction=API("USER32","SystemParametersInfoA",  uiaction, uiParam,pvParam,fWinIni)
Zone_de_résultats = "UIParam = " + uiparam + cr + "UIAction (correspond à une constante définissant une action) = " + uiaction + cr + pvparam  + cr + fwinini + cr + "Mon_résultat = "  + UIParam

Comme on le voit le code a été simplifié et c'est cette fois la valeur UIParam qui a été établie à 16.

Le changement de code est suggéré en ces termes :

SPI_SETMOUSETRAILS
0x005D
Enables or disables the Mouse Trails feature, which improves the visibility of mouse cursor movements by briefly showing a trail of cursors and quickly erasing them.
To disable the feature, set the uiParam parameter to zero or 1. To enable the feature, set uiParam to a value greater than 1 to indicate the number of cursors drawn in the trail.

Ceci d'une façon que chacun pourra consulter facilement à l'adresse :
http://msdn.microsoft.com/en-us/libr...=vs.85%29.aspx
La suite au prochain post où nous présenterons différentes connaissances de base concernant les API, leur syntaxe et leur structure.
Cordialement

NB : Le domaine étant très riche, à votre tour de m'aider à explorer et à mettre à la disposition de tous, comme prévu, une vaste bibliothèque d'APIs.

[jdsetls]

Bonjour,
J'ai pioché selon la méthode inductive et je suis content.
Il n'est pas si difficile d'analyser les API, de comprendre leurs variables et leur structure et d'en tirer énormément d'informations.
Dans l'exemple qui suit, nous avons simplement compris la signification des variables et changé une constante ou adresse dans une API simple.

Nous partons du court exemple précédent permettant de lire la vitesse de la souris.

Le plus difficile a été de trouver un endroit où soient données les valeurs des paramètres de type SPI_xxxx qui constituent le coeur même des informations nécessaires.
Dès lors, partant de la valeur d'origine UIAction = 0x00070, il nous suffit de décliner les possibles, mieux on constate assez vite qu'il n'est pas nécessaire d'utiliser une valeur hexadécimale.
Par conséquent, plutôt que d'écrire uiaction = 0x0070
on écrira, plus simple : uiaction = 112
Selon ces principes, voici quelques valeurs de constantes à retenir, en décimal :

10 donne la vitesse du clavier
16 répond 1 si l'économiseur d'écran est paramétré pour être actif
112 exemple d'origine, donne une valeur de 1 à 20 correspondant à la vitesse de la souris

Les constantes correspondantes possèdent l'attribue GET pour récupérer une information et SET pour attribuer une valeur à un paramètre.

Par exemple et si on préfère on pourra continuer à utiliser l'hexadécimal pour déterminer que la souris est ou non ombrée, avec
SPI_SETDROPSHADOW
0x1025

ou encore :
SPI_GETMOUSETRAILS
0x005E
... donne le nombre de trace laissées par la souris (dans mon cas 7)

Rappel du code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Zone_de_résultats = ""
RetourFonction est un booléen // Type C :BOOL
uiAction est un entier sans signe // Type C :UINT
uiParam est un entier sans signe // Type C :UINT
pvParam est un entier système // Type C :PVOID
fWinIni est un entier sans signe // Type C :UINT
nRésultat est un entier
spi_getmouse est un entier 
 
uiParam = 0
uiAction = 0x005E // 0x000A  //Action demandée par exemple  0x0070 ou n'importe laquelle des valeurs 
                                           //disponibles, nous avons désormais des centaines d'API disponibles
                                           //pour le prix d'une
nRésultat = 0
pvParam =  &nRésultat 
fWinIni = 0
 
RetourFonction=API("USER32","SystemParametersInfoA",  uiaction, uiParam,pvParam,fWinIni)
Zone_de_résultats = "UIParam = " + uiparam + cr + "UIAction (correspond à une constante définissant une action) = " + uiaction + cr + pvparam  + cr + fwinini + cr + "Mon_résultat = "  + nrésultat

avec pour résultat :
UIParam = 0
UIAction (correspond à une constante définissant une action) = 94
40252860
0
Mon_résultat = 7

Donc sept traces laissées par la souris. UI action est donné à 94; soit le décimal pour 0x005E

A mon avis nous avons avancé à grand pas, puisque ce n'est pas une API que nous connaissons, mais toute une série.
Plus dans un prochain post.
Cordialement

[jdsetls]

Bonjour,
Autant je suis persuadé de l'utilité et de la puissance des API, fonctions Windows de base permettant de gérer le système, autant je suis perplexe.
Leur syntaxe, comme disent les américains, est 'arcane', c'est à dire réservée aux initiés.
Et tchernobylesque en ce sens qu'elles utilisent des codes issus du C ou C++ qui déconcertent l'innocent utilisateur de Windev.
Si le C et ses avatars sont des Dieux majeurs, je dois être un Dieu mineur qui se cache sous les pierres.
Pourtant je me souviens que, lors des cours PCSoft Windev expert 1 et expert 2, on nous a appris à utiliser les API.

Ce que je voudrais ici, et par exemple je crois l'excellent Hibernatus en être capable, c'est de savoir comment passer les paramètres de façon simple, presque en aveugle et sans comprendre le code.
Prenons un exemple. La liste exhaustive des API Windows se trouve dans leur index à :
http://msdn.microsoft.com/en-us/libr...=vs.85%29.aspx

On peut y lire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
BOOL WINAPI SystemParametersInfo(
  _In_     UINT uiAction,
  _In_     UINT uiParam,
  _Inout_  PVOID pvParam,
  _In_     UINT fWinIni
);
 
Parameters
 
uiAction [in]
 
    Type: UINT

Cette API est courte. Je l'ai choisie pour cela.
Pour autant, en l'absence d'exemples je ne comprends pas ce qu'elle fait :

Retrieves or sets the value of one of the system-wide parameters. This function can also update the user profile while setting a parameter.

C'est beau !!!
Je me souviens que le péché mortel en pédagogie est le présupposé. On suppose que le lecteur connait déjà.

Donc merci de lister ici des exemples clairs d'API, afin de stimuler les rares neurones qui me restent.
Cordialement

[Hibernatus34]

Pour répondre au sondage :
- Beaucoup de GDI+ (version native C++)
- DirectSound
- Manipulation de fenêtres, champs (notamment layered windows pour des effets sympas)

Et hors SDK Windows, on a des projets utilisant des SDK de matériel (e.g. ED-SDK Canon), libs de traitement d'image (e.g. ArcSoft), nos propres DLL C++ (soit du traitement, soit un pont vers d'autres API, car c'est plus pratique en C++ qu'en WD), libs comme libvlc, LAME...

[WDKyle]

Pour répondre au sondage :
- Beaucoup de GDI+ (version native C++)
- DirectSound
- Manipulation de fenêtres, champs (notamment layered windows pour des effets sympas)

Et hors SDK Windows, on a des projets utilisant des SDK de matériel (e.g. ED-SDK Canon), libs de traitement d'image (e.g. ArcSoft), nos propres DLL C++ (soit du traitement, soit un pont vers d'autres API, car c'est plus pratique en C++ qu'en WD), libs comme libvlc, LAME...

Bonsoir,

Je serais interressé de savoir comment tu utilise l'api directsound ? Je cherche a faire de la lecture et de l'enregistrement de fichier audio sur sortie/entree specifique de carte son.

Je connais un peu bass.dll mais elle n'est pas gratuite pour un projet commercial et c'est pas donne cote tarif

Merci

[jurassic pork]

hello,
je ne voudrais pas relancer la polémique , mais l'utilisation généralisée d'API windows s'adresse plutôt à l'élite qu'au programmeur lambda. Dès qu'il faut commencer à programmer sa propre dll en c++ pour intégrer des procédures utilisant des API windows il y a déjà beaucoup moins de candidats. Par contre s'il s'agit d'utiliser quelques api windows dans son programme windev cela reste à la portée de tout le monde. A mon humble avis il ne faut pas réinventer la roue. Si il y a des bibliothèques ( que se soit des dll c++ ou des assemblages dotnet etc...) qui possèdent la ou les fonctions désirées autant les utiliser. Bien sûr vous me direz, il faut voir leurs licences, les contraintes que cela entraîne (par exemple pour dotnet, qu'il soit présent avec l'O.S). Il y a aussi les performances et le rajout de fichiers. Mais si cela n'est pas trop pénalisant , il faut voir le temps gagné !
Prenons l'exemple de WDKyle qui veut utiliser l'API windows DirectSoundCaptureEnumerate. Il n'est pas spécialiste du c++ (du moins je pense), il va plutôt galérer pour pouvoir l'utiliser. Comme il veut faire en plus du traitement audio, il va pouvoir utiliser une bibliothèque audio toute faite. Prenons par exemple l'assemblage dotnet Naudio (licence Microsoft public license). Avec cet assemblage il va pouvoir faire l'équivalent du DirectSoundCaptureEnumerate facilement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
// Enumérer les périphériques d'entrée Audio avec Naudio
WaveInDevices est un entier = WaveIn.DeviceCount
POUR I=0 _A_ WaveInDevices - 1	
deviceInfo est un WaveInCapabilities dynamique
deviceInfo = WaveIn.GetCapabilities(I)
Trace("Périphérique","  ",I, " :  Nom : ",deviceInfo:ProductName," - Canaux : ", deviceInfo:Channels)	
FIN

et bien d'autres choses. Par exemple pour lire un fichier mp3 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
// Lire un fichier mp3 avec NAudio
myWaveOutDevice est un WaveOut
myAudioFileReader est un  AudioFileReader("F:\test.mp3")
myWaveOutDevice.Init(myAudioFileReader)
myWaveOutDevice.PLay()

Ami calmant, J.P

PS : N'hésitez pas à forcer sur les pouces vers le bas, je suis vacciné (contre la grippe porcine) et je ne suis pas auto-stoppeur

[WDKyle]

hello,
je ne voudrais pas relancer la polémique , mais l'utilisation généralisée d'API windows s'adresse plutôt à l'élite qu'au programmeur lambda. Dès qu'il faut commencer à programmer sa propre dll en c++ pour intégrer des procédures utilisant des API windows il y a déjà beaucoup moins de candidats. Par contre s'il s'agit d'utiliser quelques api windows dans son programme windev cela reste à la portée de tout le monde. A mon humble avis il ne faut pas réinventer la roue. Si il y a des bibliothèques ( que se soit des dll c++ ou des assemblages dotnet etc...) qui possèdent la ou les fonctions désirées autant les utiliser. Bien sûr vous me direz, il faut voir leurs licences, les contraintes que cela entraîne (par exemple pour dotnet, qu'il soit présent avec l'O.S). Il y a aussi les performances et le rajout de fichiers. Mais si cela n'est pas trop pénalisant , il faut voir le temps gagné !
Prenons l'exemple de WDKyle qui veut utiliser l'API windows DirectSoundCaptureEnumerate. Il n'est pas spécialiste du c++ (du moins je pense), il va plutôt galérer pour pouvoir l'utiliser. Comme il veut faire en plus du traitement audio, il va pouvoir utiliser une bibliothèque audio toute faite. Prenons par exemple l'assemblage dotnet Naudio (licence Microsoft public license). Avec cet assemblage il va pouvoir faire l'équivalent du DirectSoundCaptureEnumerate facilement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
// Enumérer les périphériques d'entrée Audio avec Naudio
WaveInDevices est un entier = WaveIn.DeviceCount
POUR I=0 _A_ WaveInDevices - 1	
deviceInfo est un WaveInCapabilities dynamique
deviceInfo = WaveIn.GetCapabilities(I)
Trace("Périphérique","  ",I, " :  Nom : ",deviceInfo:ProductName," - Canaux : ", deviceInfo:Channels)	
FIN

et bien d'autres choses. Par exemple pour lire un fichier mp3 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
// Lire un fichier mp3 avec NAudio
myWaveOutDevice est un WaveOut
myAudioFileReader est un  AudioFileReader("F:\test.mp3")
myWaveOutDevice.Init(myAudioFileReader)
myWaveOutDevice.PLay()

Ami calmant, J.P

PS : N'hésitez pas à forcer sur les pouces vers le bas, je suis vacciné (contre la grippe porcine) et je ne suis pas auto-stoppeur

Bonjour,

Merci jurassic pork pour ton aide ! Je vais regarder NAudio mais peut-on choisir les entrées/sorties de carte son ?

Je voulais passer en API directement car je n'aime pas trop les assemblages .Net sous Windev, je trouve cela pas très stable (j'ai faux ?).

Avec les fonctions API de Windev, je ne charge que les fonctions dont j'ai besoin, je ne charge pas tout et pas de grosse dépendances à un assemblage. (encore faux ?)

[jdsetls]

Bonjour,
Voici qui est intéressant.
De mon côté avec le code Windev :
Si j'entre une valeur supérieure à 16, je peux vérifier par un nouvel appel à l'API 112 et j'obtiens.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
Zone_de_résultats = ""
RetourFonction est un booléen // Type C :BOOL
uiAction est un entier sans signe // Type C :UINT
uiParam est un entier sans signe // Type C :UINT
pvParam est un entier système // Type C :PVOID
fWinIni est un entier sans signe // Type C :UINT
nRésultat est un entier
 
uiParam = 8
uiAction = 113 // Action demandée ici mettre la vitesse de la souris à 8
fWinIni = 1

J'écris une vitesse de 8. Je la relis et j'obtiens 8.
Si maintenant j'écris au delà de 16, alors je relis toujours à 16.



Une simple hypothèse :
20 en hexadécimal = 32 en décimal.
Sinon pourquoi écrire un byte (un mot) dont la valeur maxi ne soit ni 16 ni 32 ?

Je m'interroge.
N'oublions pas que la doc Microsoft a parfois été mal traduite ou insuffisamment documentée.
Je suis donc curieux du pourquoi ?
Peut-être doit-on afficher un paramètre donnant la longueur de la chaîne à récupérer ?
Cordialement