Discussion :

[Al__22]

Bonjour le forum,

Je me permet d'ouvrir ce thread dans le but de créer un nouveau type de code pour une fonction qui a été demandé récemment sur le forum et auquel j'avais répondu totalement à côtés

En m'y penchant d'un peu plus prés et en faisant des recherches sur ce type de fonction je suis toujours tombé sur des codes de 3 m de long et/ou peu pratiques à comprendre et/ou à mettre en marche.
Ma question est donc :
"A-t-on un moyen (comme dans access avec TextWidth) de mesurer facilement la taille (pixel ou cm je suis pas chiant non plus ) d'un texte" (C'est à dire dans un code de moins de 50 lignes et compréhensible)

Voici mes bases (oui j'en ai deux) :
- 1er chemin : utiliser le autosize d'une colonne ou d'un Label (mais dans les deux cas il y a des espaces en plus et cela va dépendre de la résolution du moniteur de chacun )
- 2e chemin : utiliser des API (fastidieux je trouve mais surement plus juste)

Pour ce qui est des API je pensais à :
- GetMapMode32
- SetMapMode32
- CreateFont32
- GetDC32

Donc si quelqu'un à d'autres pistes à présenter ou même une microscopique idée je suis preneur

[Jean-Philippe André]

Salut,
Est-ce que la litterature suivante te donne des infos :

http://fring.developpez.com/vba/excel/zonetxt/
http://claudeleloup.developpez.com/t...ter-taille-sf/

[Al__22]

Bonjour jpcheck

En effet c'est plutôt intéressant mais ça ne m'aide pas vraiment.
Dans le premier lien je ne vois pas ou on mesure un texte (autre que le moment ou tu es obligé de mettre manuellement dans le code de quel type de police/taille/etc. il s'agit)
Dans le deuxième on ne parle que de hauteur de forme. De plus il s'agit d'access donc pas forcément transposable dans excel.

Malgré tout je vais approfondir un peu et voir ce que je peux faire avec ces infos merci

[pijaku]

Bonjour,

Ces fonctions ont été créées par UcFoutu
Tout ce dont tu as besoin y est, mais tu utiliseras surement les fonctions vba_TextWidth et vba_TextHeight...

[Al__22]

Merci pijaku

Je connaissais pas du tout et en effet ça marche du tonnerre

Par contre c'est pour moi beaucoup trop long même en enlevant ce qui ne sert à rien (juste pour ce cas ci soyons d'accord). Et en plus tu est obligé de déclarer ta police en dehors de la fonction elle même :

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
Option Explicit
Private Type LOGFONT
  lfHeight As Long '
  lfWidth As Long
  lfEscapement As Long
  lfOrientation As Long
  lfWeight As Long '
  lfItalic As Byte '
  lfUnderline As Byte '
  lfStrikeOut As Byte '
  lfCharSet As Byte
  lfOutPrecision As Byte
  lfClipPrecision As Byte
  lfQuality As Byte
  lfPitchAndFamily As Byte
  lfFaceName As String * 32 '
End Type
Public Type hv
   X As Long
   Y As Long
End Type
Private Declare Function CreateDC Lib "gdi32.dll" Alias "CreateDCA" (ByVal lpDriverName As String, ByVal lpDeviceName As String, ByVal lpOutput As String, lpInitData As Long) As Long
Private Declare Function CreateCompatibleBitmap Lib "gdi32.dll" (ByVal hdc As Long, ByVal nWidth As Long, ByVal nHeight As Long) As Long
Private Declare Function CreateFontIndirect Lib "gdi32.dll" Alias "CreateFontIndirectA" (lpLogFont As LOGFONT) As Long
Private Declare Function SelectObject Lib "gdi32.dll" (ByVal hdc As Long, ByVal hObject As Long) As Long
Private Declare Function DeleteObject Lib "gdi32.dll" (ByVal hObject As Long) As Long
Private Declare Function MulDiv Lib "kernel32.dll" (ByVal nNumber As Long, ByVal nNumerator As Long, ByVal nDenominator As Long) As Long
Private Declare Function GetDC Lib "user32.dll" (ByVal hwnd As Long) As Long
Private Declare Function GetDeviceCaps Lib "gdi32.dll" (ByVal hdc As Long, ByVal nIndex As Long) As Long
Private Declare Function DeleteDC Lib "gdi32.dll" (ByVal hdc As Long) As Long
Private Declare Function GetTextExtentPoint32 Lib "gdi32" Alias "GetTextExtentPoint32A" (ByVal hdc As Long, _
  ByVal lpsz As String, ByVal cbString As Long, lpSize As hv) As Long
Private Declare Function ReleaseDC Lib "user32" (ByVal hwnd As Long, ByVal hdc As Long) As Long
Private Declare Function GetSystemMetrics Lib "user32" (ByVal nIndex As Long) As Long
 ' code libre d'utilisation et/ou diffusion. Seule obligation : y ajouter la mention suivante :
 ' ******code provenant du forum VBFrance de Codes-Sources - Auteur : ucfoutu*************
Public vba_font As New StdFont
Public Function vba_TextWidth(texte As String, la_font As StdFont) As Single
    vba_TextWidth = dimt(texte, la_font).X
End Function
Public Function vba_TextHeight(texte As String, la_font As StdFont) As Single
    vba_TextHeight = dimt(texte, la_font).Y
End Function
Private Function dimt(ch As String, ByVal pol As StdFont) As hv
    Dim cdc As Long, ccb As Long, cfi As Long, lgf As LOGFONT, tch As hv
    cdc = CreateDC("DISPLAY", "", "", ByVal 0)
    ccb = CreateCompatibleBitmap(cdc, 1, 1)
    DeleteObject SelectObject(cdc, ccb)
    lgf.lfFaceName = pol.Name & Chr$(0): lgf.lfHeight = -MulDiv(pol.Size, GetDeviceCaps(GetDC(0), 90), 72)
    lgf.lfItalic = pol.Italic: lgf.lfStrikeOut = pol.Strikethrough: lgf.lfUnderline = pol.Underline
    lgf.lfWeight = 400
    If pol.Bold = True Then lgf.lfWeight = lgf.lfWeight * 2
    cfi = CreateFontIndirect(lgf)
    DeleteObject SelectObject(cdc, cfi)
    GetTextExtentPoint32 cdc, ch, Len(ch), tch
    DeleteObject cfi: DeleteObject ccb: DeleteDC cdc
    dimt = tch
End Function
 
Sub W_texte()
Dim retx As String
vba_font.Size = Range("B4").Font.Size: vba_font.Name = Range("B4").Font.Name
vba_font.Bold = Range("B4").Font.Bold: vba_font.Italic = Range("B4").Font.Italic 
retx = vba_TextWidth(Range("B4").Value, vba_font)
End Sub

Alors à moins que je soit bêtes (surement le cas) il y a surement un moyen de se dépatouiller pour faire moins long et surtout ne plus être obligé de déclarer sa police en dehors de la fonction (à la rigueur en tant que option de la fonction : T_width( ByVal Texte, NomP as String, TailleP As String, etc.) )

Je vais me pencher dessus et voir ce que je peux faire !

[pijaku]

Voici par exemple.
Difficile tout de même de faire plus court...

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
Option Explicit
'---Cette partie ne peux pas être raccourcie---
'   par contre elle peut être placée dans un module à part
'en changeant les Private par Public
Private Type LOGFONT
  lfHeight As Long '
  lfWidth As Long
  lfEscapement As Long
  lfOrientation As Long
  lfWeight As Long '
  lfItalic As Byte '
  lfUnderline As Byte '
  lfStrikeOut As Byte '
  lfCharSet As Byte
  lfOutPrecision As Byte
  lfClipPrecision As Byte
  lfQuality As Byte
  lfPitchAndFamily As Byte
  lfFaceName As String * 32 '
End Type
Public Type hv
   X As Long
   Y As Long
End Type
Private Declare Function CreateDC Lib "gdi32.dll" Alias "CreateDCA" (ByVal lpDriverName As String, ByVal lpDeviceName As String, ByVal lpOutput As String, lpInitData As Long) As Long
Private Declare Function CreateCompatibleBitmap Lib "gdi32.dll" (ByVal hdc As Long, ByVal nWidth As Long, ByVal nHeight As Long) As Long
Private Declare Function CreateFontIndirect Lib "gdi32.dll" Alias "CreateFontIndirectA" (lpLogFont As LOGFONT) As Long
Private Declare Function SelectObject Lib "gdi32.dll" (ByVal hdc As Long, ByVal hObject As Long) As Long
Private Declare Function DeleteObject Lib "gdi32.dll" (ByVal hObject As Long) As Long
Private Declare Function MulDiv Lib "kernel32.dll" (ByVal nNumber As Long, ByVal nNumerator As Long, ByVal nDenominator As Long) As Long
Private Declare Function GetDC Lib "user32.dll" (ByVal hwnd As Long) As Long
Private Declare Function GetDeviceCaps Lib "gdi32.dll" (ByVal hdc As Long, ByVal nIndex As Long) As Long
Private Declare Function DeleteDC Lib "gdi32.dll" (ByVal hdc As Long) As Long
Private Declare Function GetTextExtentPoint32 Lib "gdi32" Alias "GetTextExtentPoint32A" (ByVal hdc As Long, _
  ByVal lpsz As String, ByVal cbString As Long, lpSize As hv) As Long
Private Declare Function ReleaseDC Lib "user32" (ByVal hwnd As Long, ByVal hdc As Long) As Long
Private Declare Function GetSystemMetrics Lib "user32" (ByVal nIndex As Long) As Long
 ' code libre d'utilisation et/ou diffusion. Seule obligation : y ajouter la mention suivante :
 ' ******code provenant du forum VBFrance de Codes-Sources - Auteur : ucfoutu*************
 'la fonction :
Private Function dimt(ch As String, pol_Name As String, pol_Size As Long, pol_Bold As Boolean, Optional pol_Italic As Byte, Optional pol_Strikethrough As Byte, Optional pol_Underline As Byte) As hv
    Dim cdc As Long, ccb As Long, cfi As Long, lgf As LOGFONT, tch As hv
    cdc = CreateDC("DISPLAY", "", "", ByVal 0)
    ccb = CreateCompatibleBitmap(cdc, 1, 1)
    DeleteObject SelectObject(cdc, ccb)
    lgf.lfFaceName = pol_Name & Chr$(0): lgf.lfHeight = -MulDiv(pol_Size, GetDeviceCaps(GetDC(0), 90), 72)
    lgf.lfItalic = pol_Italic: lgf.lfStrikeOut = pol_Strikethrough: lgf.lfUnderline = pol_Underline
    lgf.lfWeight = 400
    If pol_Bold = True Then lgf.lfWeight = lgf.lfWeight * 2
    cfi = CreateFontIndirect(lgf)
    DeleteObject SelectObject(cdc, cfi)
    GetTextExtentPoint32 cdc, ch, Len(ch), tch
    DeleteObject cfi: DeleteObject ccb: DeleteDC cdc
    dimt = tch
End Function
'l'appel de la fonction :
Sub W_texte()
Dim retx As Long
With Range("B4")
    retx = dimt(.Value, .Font.Name, .Font.Size, .Font.Bold, .Font.Italic).X
End With
MsgBox retx
End Sub

[Al__22]

Quand on veut on peut :

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
Option Explicit
 
Type Taille_32
    cx As Long
    cy As Long
End Type
 
Declare Function FindWindow32 Lib "user32" Alias "FindWindowA" (ByVal Classe As String, ByVal F_Windows As String) As Long
Declare Function GetDC32 Lib "user32" Alias "GetDC" (ByVal G_DC As Long) As Long
Declare Function DeleteObject32 Lib "gdi32" Alias "DeleteObject" (ByVal H_Objet As Long) As Long
Declare Function ReleaseDC32 Lib "user32" Alias "ReleaseDC" (ByVal G_DC As Long, ByVal S_Objet As Long) As Long
Declare Function SelectObject32 Lib "gdi32" Alias "SelectObject" (ByVal S_Objet As Long, ByVal H_Objet As Long) As Long
Declare Function GetTextExtentPoint32 Lib "gdi32" Alias "GetTextExtentPointA" _
(ByVal S_Objet As Long, ByVal S_lpz As String, ByVal S_cb As Long, Taillelp_32 As Taille_32) As Long
Declare Function CreateFont32 Lib "gdi32" Alias "CreateFontA" _
(ByVal H As Long, ByVal W As Long, ByVal E As Long, ByVal O As Long, ByVal WP As Long, ByVal I As Long, _
ByVal u As Long, ByVal s As Long, ByVal C As Long, ByVal OP As Long, ByVal CP As Long, ByVal Q As Long, _
ByVal PAF As Long, ByVal F As String) As Long
 
Dim T_a_trouver As String
 
Function Taille_Texte(ByVal S_Text, S_P_Nom As String, iT_Texte As Long, S_P_Weight As Long)
S_P_Weight = IIf(Range("A1").Font.Bold, 800, 400)
    Dim O_Police As Long
    Dim G_DC As Long
    Dim S_Objet As Long
    Dim N_Police As Long
    Dim P_long As Long
    Dim T_Texte As Taille_32
 
    G_DC = FindWindow32("A_XL", Application.Caption)
    S_Objet = GetDC32(G_DC)
    N_Police = CreateFont32(iT_Texte * -20, 0, 0, 0, S_P_Weight, 0, 0, 0, 0, 0, 0, 0, 0, S_P_Nom)
    O_Police = SelectObject32(S_Objet, N_Police)
    P_long = GetTextExtentPoint32(S_Objet, S_Text, Len(S_Text), T_Texte)
    N_Police = SelectObject32(S_Objet, O_Police)
    P_long = DeleteObject32(N_Police)
    P_long = ReleaseDC32(G_DC, S_Objet)
    Taille_Texte = T_Texte.cx / 20
 
End Function
Sub Test()
 
T_a_trouver = InputBox("Tapez votre texte"): Range("A1") = T_a_trouver
MsgBox ("La taille du texte est " & Taille_Texte(Range("A1"), Range("A1").Font.Name, Range("A1").Font.Size, Range("A1").Font.Bold))
 
End Sub

Malheureusement ça ne marche pas bien
Faut que je continue

En tout cas merci de ta participation pijaku
Si je trouve pas autre chose je prendrai soin de noter ta solution

[Al__22]

Je pense que j'avance sur la bonne voie.
Le code ci dessous permet d'obtenir la taille d'un texte en pixel mais seulement pour une police de 11

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
Private Declare Function GetTextExtentPoint32 Lib "gdi32" Alias "GetTextExtentPoint32A" (ByVal GTEP32 As Long, ByVal S_texte As String, ByVal S_T_long As Long, S_Size As Size) As Long
 
Private Type Size
        cx As Long
        cy As Long
End Type
 
Private Declare Function GetForegroundWindow Lib "user32" () As Long
Private Declare Function GetDC Lib "user32" (ByVal GDC As Long) As Long
 
Private Function GetTheDC() As Long
    Dim S_rep As Long
    S_rep = GetForegroundWindow()
    S_rep = GetDC(S_rep)
    GetTheDC = S_rep
End Function
 
Private Sub Essai()
    Dim ts As Size
    Debug.Print GetTextExtentPoint32(GetTheDC, Range("A1"), Len(Range("A1")), ts)
    MsgBox ts.cx '& vbLf & ts.cy
End Sub

Maintenant en fouillant dans le labyrinthe des API j'en ai trouvé une pas trop mal : GetTextMetrics
Et normalement si je me débrouille bien elle devrait suffire à afficher les bonnes valeurs même quand on change la police.

En fait j'ai peut être mieux : GetCharABCWidthsFloat
Qui une fois utilisé correctement est censé renvoyé la taille de n'importe qu'elle police. Le soucis ? J'ai pas encore trouvé comment la faire fonctionner

[unparia]

Bonjour
Je ne voulais pas intervenir dans cette discussion. Je m'y résous car je vois que tu vas "tourner en rond".
La fonction que tu cites n'est utilisable qu'une fois dessiné le texte dans un hdc (et donc après en avoir défini la police et ses propriétés). Elle ne t'affranchit donc pas de ce que j'appellerais l'essentiel.
Cette fonction n'est par ailleurs pas portable sur tous les OS
Tu devrais, crois-moi, suivre les sages conseils et le lien que pijaku t'a montrés. Tu gagneras ainsi beaucoup de temps.

[Al__22]

Bonjour unparia,

Même si je tourne en rond cela m'aura permit de me creuser les méninges et de découvrir le système API plus en profondeur

Pour ce qui est de la portabilité microsoft indique NT2000 au plus bas donc je pense que je suis large, même si je sais que certains de nos ermites sont resté dans leur 98.

Enfin je n'ai pas rejeté les remarques de pikaju bien au contraire et je suis bien content qu'il m'est montré ce lien.
Mais quand je vois qu'en VB il est possible d'obtenir les mêmes choses avec moins de 40 lignes et "seulement" 6 API je me permet de continuer à faire chauffer ma cervelle. Et ce même si c'est juste pour la beauté du sport

[Docmarti]

Bonjour.

On peut utiliser les propriétés WrapText et RowHeight de VBA Excel pour savoir si le nombre de mots modifie la hauteur de la ligne.

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
 
Sub SurSurplusieurslignes()
 
 
    Set r = ActiveCell
    Set fTemp = Worksheets("temp")
    Set Dest = ActiveSheet
 
    Dest.Columns("D").Cells.Clear
    fTemp.Cells.Clear
 
    If r.Value = "" Then
        MsgBox "Cellule vide??"
        Exit Sub
    End If
 
    Set r1 = fTemp.Cells(1, 1)
    r.Copy r1
 
    With fTemp.Rows(r1.Row)
        .WrapText = False
    End With
 
    Set r2 = fTemp.Cells(4, 3)
    r1.Copy r2
 
    memh = r2.RowHeight
 
    r2.ColumnWidth = r.ColumnWidth
 
    With r2
        .WrapText = True
    End With
 
    t = Split(r2.Value, " ")
    dernier = UBound(t)
    debut = LBound(t)
    ReDim lignes(1)
 
    a = t(0)
 
    While a <> ""
 
        ok = False
        h = r2.RowHeight
        dernier = UBound(t)
 
        While h > memh
            dernier = dernier - 1
 
            a = ""
            sep = " "
            For i = debut To dernier
                If i = dernier Then sep = ""
                a = a & t(i) & sep
            Next
 
            If a = "" Then
                'Le premier mot est trop long pour la largeur de la colonne. Donc on l'accepte quand meme
                a = t(debut)
                ok = True
            End If
 
            r2.Value = a
 
            If ok = True Then
                dernier = dernier + 1
                h = memh
            Else
                h = r2.RowHeight
            End If
 
        Wend
 
        lignes(UBound(lignes)) = a
        ReDim Preserve lignes(UBound(lignes) + 1)
        a = ""
        If dernier < UBound(t) Then
 
            debut = dernier + 1
            sep = " "
            a = ""
            For i = debut To UBound(t)
                If i = UBound(t) Then sep = ""
                a = a & t(i) & sep
            Next
 
            r2.Value = a
 
        End If
    Wend
 
    For i = 1 To UBound(lignes)
         Dest.Cells(i, "D").NumberFormat = "@"
         Dest.Cells(i, "D").FormulaLocal = lignes(i)
    Next
 
End Sub

[unparia]

quand je vois qu'en VB il est possible d'obtenir les mêmes choses avec moins de 40 lignes

Quel "VB" ?
- VB6 dispose des méthodes natives TextWidth et TextHeight, qui ne nécessitent l'utilisation d'aucune fonction de l'Api de Windows
- VB.Net ne dispose pas à ma connaissance de ces méthodes mais le résultat recherché peut s'obtenir facilement par utilisation d'un objet graphique (ce que font d'ailleurs en arrière plan les méthodes TextHeight et TextWidth de VB6)
Tant sous VB6 que sous VB.Net, il y a utilisation en arrière plan d'un contexte de dispositif (dc) et définition de la police de caractères et de ses propriétés.


Ce que pijaku t'a montré fait ce que font VB6 et VB.Net en arrière plan, VBA/Excel ne disposant ni des méthodes de VB6, ni des classes graphiques.
Voilà. Je pense t'avoir maintenant tout dit.

EDIT : pour y parvenir depuis VBA/Excel, VBA n'intervient que pour déclarer les fonctions à utiliser de l'Api de Windows. Les résultats obtenus ne sont pas le fait de "VB", mais des fonctions sollicitées.

[Al__22]

Bonsoir Docmarti,

Je te remercie de ta contribution, je vais voir si ça peut m'aider.
Car rien ne m'empêche de le combiner avec d'autre choses pour voir ou cela me mène, je regarderai ça lundi ou mardi.

@ unparia
Je trouve que tu pars souvent du principe que si ça existe déjà pas la peine de chercher quelque chose de nouveau.
Je me trompe peut être mais moi je fonctionne pas du tout comme ça, pour moi si quelque chose existe c'est qu'on peut l'améliorer, le modifier, se l'approprier.
Bref j'aime bien ta remarque mais je la trouve pas très constructive par rapport à ce que je cherche (encore une fois je ne détiens pas la vérité absolue et peux me tromper lourdement).
Pour ce qui est du VB il s'agit du VB5 si mes souvenirs sont bons et donc c'est compatible VB6 normalement. Je l'avais développé avec un collègue bien mieux calé que moi en codage donc je pourrais pas tout t'expliquer.

Sur ce bon week-end à tous et à lundi
Si jamais vous avez des idées n'hésitez pas mais je ne répondrai que lundi ou mardi (je suis en déplacement jusque là)

[unparia]

Bon ...
1) VB5 (que je connais très bien car je l'utilise) est doté, comme VB6, des méthodes natives TextWidth et TextHeight (et ce que tu veux faire s'obtient donc sous VB5 également en 4 lignes et sans la moindre fonction de l'Api de Windows.
2) pour le reste : je ne ferai pas le reproche de chercher à faire mieux que le code que t'a montré pikaku.
Bonne continuation, donc.

[unparia]

EDIT : je reviens quand même ce matin pour appeler ton attention sur le point suivant :
Si l'important est pour toi la légèreté apparente d'un code (le "poids" de ses lignes "visibles") et non son poids réel en arrière plan (mémoire, etc ...) :
Rien ne t'empêche d'utiliser à cette fin un Label invisible, mais un peu plus finement que ce que l'on voit ici et/ou là, avec le même degré de précision que celui que l'on obtient avec le code que t'a montré pijaku.
La largeur obtenue sera bien évidemment exprimée en unités logiques du conteneur hébergeant le Label. Une conversion sera à faire également si l'on veut cette largeur dans une autre échelle.
- "avantage" ? te donner l'impression de code léger
- inconvénient ? lourdeur (certes non "visible", mais bel et bien réelle) ajoutée

[clementmarcotte]

Bonjour,

En tout cas, ce qui ressort de tout cela c'est l'évidence que VB-quelque chose, n'est pas la garantie que tous les VB sont pareils, même avec des ancêtres communs. En partant de son BASIC d'origine, Microsoft a développé trois "enfants" aux rôles et aux possibilités bien différents :

VBScript : Un VB, si on peut dire, très sommaire et très léger qui sert essentiellement à des scripts, soit pour le web, soit pour des tâches légères, presque essentiellement pour la gestion du système. À vrai dire VBScript est maintenant pratiquement abandonné. Microsoft a décidé de miser sur JavaScript au lieu de JScript et VBScript.

VB 6 (et les précédents) Ce sont des langages compilés, conçus pour permettre des développements rapides d'applications professionnelles et autonomes. et qui cachent les appels à l'API dans un paquet d'instructions spécifiques qui mâchent le tout de façon transparente pour le programmeur. Le programmeur n'a pas à se perdre dans la recherche de la "bonne" fonction de l'API. C'est VB et le compilateurs qui exécutent les choix de Microsoft sur la façon de réaliser les appels aux fonctions de bas niveau.

VBA est là pour permettre d'automatiser une application-hôte avec un jeu d'instructions spécifiques à l'application et spécialisés dans un domaine spécifique lié à l'application. Pour les activités exotiques, il faut soit utiliser la technologie COM et ses "dérivés" comme OLE et les Activex, soit utiliser l'API Windows.

VB.net c'est un tout autre monde. Il n'est pas issu de la technologie COM, comme les autres VB, mais sur la technologie .net. Ce qui lui fait porter le nom de VB, ce sont plus un certain nombre de mots-clefs et d'instructions qui ont le même nom qu'en VB.

Ceci dit, ont peut toujours se faire un contrôle Activex, autant avec VB qu'avec VB.net, qui va inclure les appels transparents à l'API qu'ils permettent et les utiliser en VBA. Mais là, il ne faut pas oublier que VB6 aime bien les twips, mais que VBA et VB.net font de l'urticaire quand ils en rencontrent. Mais le détour par un contrôle Activex, est moins performant qu'un appel direct à l'API. On ne peut pas avoir les fraises et la confiture en même temp.

[unparia]

Bonjour cmarcotte
Tu viens de tout résumer avec assez de clarté et d'esprit. Ton exposé devrait faire prendre conscience de ce que, lors de l'exécution, ce n'est très souvent pas le nombre de lignes de code "visibles", qui fait le "poids" réel et la performance d'une application, mais ce qui en résulte finalement en compilé. Les "conforts" apparents sont bien souvent des tremplins qui finissent par alourdir dans les faits (des faux amis, finalement).
Amitiés à toi.

EDIT : pour ce qui est du reste (les échelles d'unités graphiques et leur utilisation) : ce n'est probablement pas pour rien que le lien donné par pijaku traite également toutes ces "petites choses" dans le même "ensemble".

[Al__22]

Bonjour a tous,

A la lecture de vos commentaires je comprends mieux maintenant pourquoi je pouvais toujours chercher sans trouver de réponse logique.
Tout ceci m'aura permis tout de même de comprendre les API (du moins en partie).

En vous remerciant tous, je vais garder les liens de pijaku sous le coude

Bonne continuation a tous