Adressoff et Pointeur sur une fonction

Bonjour,

Si tu définis tes fonctions dans un objet public, tu pourra y faire
appel à l'aide de la fonction CallByName.

Vincent Guichard

Public Function F(X As Single) As Single
F = -X
End Function

Public Sub DrawFunction(Func As String, St As Single, Sp As Single)
Dim i As Single, r As Single
CurrentX = St
CurrentY = CallByName(Form1, Func, VbMethod, St)
For i = St + 1 To Sp Step 1
r = CallByName(Form1, Func, VbMethod, i)
'Faire Quelque chose avec i et r
Next i
End Sub

Private Sub Form_Load()
DrawFunction "F", 0, 10
End Sub

Bonsoir Christophe,

le WE fut-il positif ? apparemment revigorant déjà !

Je crois voir ce qui t'a mené (mais pas en bateau !)
En fait il s'agit juste de manipuler explicitement
(et pas implicitement commenous le faisons en permanence)
l'appel de fonction comme un appel de variable !

Quand on affecte une variable à une autre, on demande
à la seconde de pointer (contenir) la meme chose que la première...
Ce que nous fait parfois le compilateur
en manipulant les adresses de nos objets....

Quan on utilise/appelle une procédure, on demande (par l'intermédiaire
du nom de procédure) d'exécuter le code à l'adresse 'nom_de_procedure'
c'est a dire physiquement à AddressOf nom_de_procedure
comme si on avait étiqueté ce code par:
nom_de_procedure :
Bon, la syntaxe basic préfère nous obliger à un Sub....
mais cela ressemble fort à un GOTO (ou GOSUB...)

Cela serait parfois bien pratique de désigner
le nom de la fonction voulue en variable......

Ce qui permettrait de piloter par variable le code à exécuter....

Cette idée est utilisée en standard en C/C++ depuis très longtemps.
Ainsi, la fonction de tri d'un tableau est-elle codée de façon générale
en algorithme en binaire, (donc sans erreur et rapide),
sauf que pour comparer deux cases du tableau
il faut encore savoir si c'est du texte (cf. Option Compare)
ou de quel nature d'entier ou de réel...
D'ou l'obligation de changer de fonction de comparaison
selon les objets/données à trier !
La manipulation de l'adresse de la fonction
consiste juste à aller "patcher" dans le code binaire
le branchement à la bonne adresse, pour exécuter le bon code....

La seule précaution à prendre, c'est évident
que le "prototype" de la fonction, c-a-dire
ses paramètres d'appel et son argument de retour
soient dans des types corrects !

Imagine simplement que tu passes par une variable
(non pas de type String mais de type Long )
le "nom" de la fonction que tu veux faire utiliser,
sauf que le "nom" est bien sur l'adresse du code binaire de la fonction...

Je t'ai mis les deux articles du MSDN sur le sujet,
mais si j'ai bien compris ce que j'ai lu, en basic, on ne peut
pas directement appeler l'exécution de la fonction voulue
par une simple variable comme en C ;
il faudrait lancer un appel à la fonction
de la façon suivante :
' remplacer la ligne :
Y = TAN(X)
' par
Y = CallByName (<objet>,"TAN",X)

Mais je n'ai pas encore compris exactement ce à quoi
ressort cet obscur <objet> en notre occurrence...

Yann

PS : sinon, on passera par une DLL en C/C++
et tant qu'a faire, si tu as déjà uen classe,
on la ré-écrira en C++ ce qui devrait etre plus facile.





-------------------------------------------------------------
AddressOf, opérateur


Opérateur unaire provoquant la transmission de l'adresse de laprocédure
qu'il précède à une procédure API attendant un pointeur de fonction à cette
position dans la liste d'arguments.

Syntaxe

AddressOf procedurename

L'argument procedurename indique la procédure dont l'adresse va être passée.
Il doit désigner une procédure figurant dans unmodule standard duprojet dans
lequel l'appel est effectué.

Remarques

En général, lorsqu'un nom de procédure apparaît dans une liste d'arguments,
la procédure est évaluée et l'adresse de la valeur renvoyée par la procédure
est transmise. L'opérateur AddressOf permet de passer l'adresse de la
procédure à une fonction API de Windows dans unebibliothèque de liaisons
dynamiques (DLL), et non la valeur renvoyée par la procédure. La fonction
API peut alors utiliser l'adresse pour appeler la procédure Basic. Ce
processus est connu sous le nom de « rappel ». L'opérateur AddressOf
apparaît uniquement dans l'appel à la procédure API.

S'il est vrai que vous pouvez utiliser l'opérateur AddressOf pour passer des
pointeurs de procédure aux procédures Basic, vous ne pouvez appeler une
fonction avec un pointeur de ce type en Basic. Cela signifie, par exemple,
qu'uneclasse écrite en Basic ne peut faire de rappel à son contrôleur à
l'aide d'un pointeur de ce type. Lorsque l'opérateur AddressOf est utilisé
pour passer un pointeur de procédure aux procédures Basic, leparamètre de la
procédure appelée doit être de type As Long.

Avertissement L'utilisation de l'opérateur AddressOf peut provoquer des
résultats imprévisibles si vous ne maîtrisez pas totalement le concept de
rappels de fonctions. Il est indispensable que vous compreniez le mode de
fonctionnement de la partie Basic du rappel, de même que le code de la DLL
dans laquelle vous passez l'adresse de la fonction. Le débogage de ces
interactions est difficile car le programme s'exécute dans le même processus
que celui de l'environnement de développement. Dans certains cas, le
débogage systématique peut même s'avérer impossible.

Note Vous pouvez créer vos propres prototypes de fonctions de rappel dans
les DLL compilées à l'aide de Microsoft Visual C++ (ou d'outils similaires).
Pour travailler avec l'opérateur AddressOf, votre prototype doit utiliser la
convention d'appel __stdcall. La convention d'appel par défaut (__cdecl) ne
fonctionne pas avec l'opérateur AddressOf.

-------------------------------------------------------------

CallByName, fonction


Exécute une méthode d'un objet, ou définit ou renvoie une propriété
d'unobjet.

Syntaxe

CallByName(object, procedurename, calltype,[arguments()])

La syntaxe de la fonction CallByName comprend les éléments suivants :

Élément Description
object Variant (Object). Nom de l'objet sur lequel sera exécutée la
fonction.
procedurename Variant (String). Expression de chaîne contenant le nom
de la propriété ou méthode de l'objet.
calltype Constant. Constante de type vbCallType représentant le type
de procédure appelée.
arguments() Facultatif : Variant (Array).



Remarques

La fonction CallByName permet d'obtenir ou de définir une propriété, ou
d'invoquer une méthode lors de l'exécution à l'aide d'un nom de chaîne.

Dans l'exemple suivant, la première ligne utilise CallByName pour définir la
propriété MousePointer d'une zone de texte, la deuxième ligne obtient la
valeur de la propriété MousePointer et la troisième invoque la méthode Move
pour déplacer la zone de texte :

CallByName Text1, "MousePointer", vbLet, vbCrosshair
Result = CallByName (Text1, "MousePointer", vbGet)
CallByName Text1, "Move", vbMethod, 100,
100----------------------------------------------------------CallByName,
fonction, exempleCet exemple utilise la fonction CallByName pour appeler la
méthode Move d'un bouton Command.L'exemple utilise aussi une feuille (Form1)
comportant un bouton (Command1) et une étiquette (Label1). Lorsque la
feuille est chargée, la propriété Caption de l'étiquette a pour valeur
"Move", nom de la méthode à appeler. Lorsque vous cliquez sur le bouton, la
fonction CallByName appelle la méthode pour modifier l'emplacement du
bouton.Option Explicit

Private Sub Form_Load()
Label1.Caption = "Move" ' Nom de la méthode Move.
End Sub

Private Sub Command1_Click()
If Command1.Left <> 0 Then
CallByName Command1, Label1.Caption, vbMethod, 0, 0
Else
CallByName Command1, Label1.Caption, vbMethod, 500, 500
End If---------------------------------------------------------AddressOf,
opérateur, exempleL'exemple suivant crée une feuille qui comprend une zone
de liste comportant une liste des polices installées sur votre système,
triée alphabétiquement.Pour exécuter cet exemple, créez une zone de liste
dans une nouvelle feuille. Le code de cette feuille est le suivant :Option
Explicit

Private Sub Form_Load()
Module1.FillListWithFonts List1
End Sub
Placez le code suivant dans un module. Le troisième argument de la
définition de la fonction EnumFontFamilies est un argument de type Long
représentant une procédure. Cet argument doit contenir l'adresse de la
procédure, plutôt que la valeur renvoyée par la procédure. Dans l'appel à la
fonction EnumFontFamilies, le troisième argument demande à l'opérateur
AddressOf de renvoyer l'adresse de la procédure EnumFontFamProc, qui
correspond au nom de la procédure de rappel que vous fournissez lors de
l'appel de la fonction API de Windows, EnumFontFamilies. Lorsque vous passez
l'argument EnumFontFamProc à EnumFontFamilies à l'aide de l'opérateur
AddressOf, Windows appelle la procédure EnumFontFamProc une fois pour
chacune des familles de polices installées sur le système. Le dernier
argument passé à EnumFontFamilies indique la zone de liste dans laquelle
l'information est affichée.' Types d'énumération des polices
Public Const LF_FACESIZE = 32
Public Const LF_FULLFACESIZE = 64

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(LF_FACESIZE) As Byte
End Type

Type NEWTEXTMETRIC
tmHeight As Long
tmAscent As Long
tmDescent As Long
tmInternalLeading As Long
tmExternalLeading As Long
tmAveCharWidth As Long
tmMaxCharWidth As Long
tmWeight As Long
tmOverhang As Long
tmDigitizedAspectX As Long
tmDigitizedAspectY As Long
tmFirstChar As Byte
tmLastChar As Byte
tmDefaultChar As Byte
tmBreakChar As Byte
tmItalic As Byte
tmUnderlined As Byte
tmStruckOut As Byte
tmPitchAndFamily As Byte
tmCharSet As Byte
ntmFlags As Long
ntmSizeEM As Long
ntmCellHeight As Long
ntmAveWidth As Long
End Type

' Indicateurs de champ ntmFlags
Public Const NTM_REGULAR = &H40&
Public Const NTM_BOLD = &H20&
Public Const NTM_ITALIC = &H1&

' Indicateurs tmPitchAndFamily
Public Const TMPF_FIXED_PITCH = &H1
Public Const TMPF_VECTOR = &H2
Public Const TMPF_DEVICE = &H8
Public Const TMPF_TRUETYPE = &H4

Public Const ELF_VERSION = 0
Public Const ELF_CULTURE_LATIN = 0

' Masques EnumFonts
Public Const RASTER_FONTTYPE = &H1
Public Const DEVICE_FONTTYPE = &H2
Public Const TRUETYPE_FONTTYPE = &H4

Declare Function EnumFontFamilies Lib "gdi32" Alias _
"EnumFontFamiliesA" _
(ByVal hDC As Long, ByVal lpszFamily As String, _
ByVal lpEnumFontFamProc As Long, LParam As Any) As Long
Declare Function GetDC Lib "user32" (ByVal hWnd As Long) As Long
Declare Function ReleaseDC Lib "user32" (ByVal hWnd As Long, _
ByVal hDC As Long) As Long

Function EnumFontFamProc(lpNLF As LOGFONT, lpNTM As NEWTEXTMETRIC, _
ByVal FontType As Long, LParam As ListBox) As Long
Dim FaceName As String
Dim FullName As String
FaceName = StrConv(lpNLF.lfFaceName, vbUnicode)
LParam.AddItem Left$(FaceName, InStr(FaceName, vbNullChar) - 1)
EnumFontFamProc = 1
End Function

Sub FillListWithFonts(LB As ListBox)
Dim hDC As Long
LB.Clear
hDC = GetDC(LB.hWnd)
EnumFontFamilies hDC, vbNullString, AddressOf EnumFontFamProc, LB
ReleaseDC LB.hWnd, hDC
End Sub

-------------------------------------------------------------"christophe-pas
de<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le message de
news:41b70ca6$0$8100$8fcfb975@news.wanadoo.fr...

Bonjour,

J'ai écrit une classe permettant d'afficher un point P(x,y) où Y= f(x) f
étant une fonction quelconque.

Pour l'instant ça s'utilise comme suit:
'ici f(x) = tan(x)'
dans un module de feuille ou publique:
mdc étant mon objet définit dans un module de classe:

'valeur de l'incrément réel (double)
dx = mdc.DefiniPasReal
'Valeur d'arrêt
Count& = mdc.DefiniCompteur
'Xo valeur départ
X = mdc.Espacereelleft

For i& = 0 To Count&
Y = Tan(X)
mdc.DessinePointFonction X, Y, RGB(255, 0, 0)
X = X + dx
Next i&

Je voudrais encapsulé ceci encore plus et écrire tout simplement:

mdc.dessinefonction( adresse ou nom de la fonction)
Quel que soit la fonction.(pour définir les valeur de départ et de stop
ainsi que l'incrément pas de soucis)

Aiguillé sur adressoff j'ai googler un peu sur le forum, j'ai vu qu'il
fallait définir la fonction dans un module publique mais après je
comprend pas bien.

Si quelqu'un a des lumières sur le sujet, merci de les partager.
De même des infos sur le callback qui si j'ai bien compris correspond à
ce genre de problématique.
J'avoue que j'ai du mal a comprendre le mécanisme.

Christophe



Christophe

Je vais explorer cette voie (Merci), mais si qqlqu'un peut m'expliquer
une methode avec adressoff ...

Christophe



Vincent Guichard a écrit :

Bonjour,

Si tu définis tes fonctions dans un objet public, tu pourra y faire
appel à l'aide de la fonction CallByName.

Vincent Guichard

Public Function F(X As Single) As Single
F = -X
End Function

Public Sub DrawFunction(Func As String, St As Single, Sp As Single)
Dim i As Single, r As Single
CurrentX = St
CurrentY = CallByName(Form1, Func, VbMethod, St)
For i = St + 1 To Sp Step 1
r = CallByName(Form1, Func, VbMethod, i)
'Faire Quelque chose avec i et r
Next i
End Sub

Private Sub Form_Load()
DrawFunction "F", 0, 10
End Sub

Salut,

Sinon si ton objectif est de faire un traceur de fonction qui sont définies
par l'utilisateur, tu pourras utiliser le moteur de script (ms script
control) pour évaluer ta fonction.

--
Nicolas G.
FAQ VB : http://faq.vb.free.fr
API Guide : http://www.allapi.net
Google Groups : http://groups.google.fr/
MZ-Tools : http://www.mztools.com/

christophe-pasde<> @wanadoo.fr>" < wrote:

Bonjour,

J'ai écrit une classe permettant d'afficher un point P(x,y) où Y > f(x) f étant une fonction quelconque.

Pour l'instant ça s'utilise comme suit:
'ici f(x) = tan(x)'
dans un module de feuille ou publique:
mdc étant mon objet définit dans un module de classe:

'valeur de l'incrément réel (double)
dx = mdc.DefiniPasReal
'Valeur d'arrêt
Count& = mdc.DefiniCompteur
'Xo valeur départ
X = mdc.Espacereelleft

For i& = 0 To Count&
Y = Tan(X)
mdc.DessinePointFonction X, Y, RGB(255, 0, 0)
X = X + dx
Next i&

Je voudrais encapsulé ceci encore plus et écrire tout simplement:

mdc.dessinefonction( adresse ou nom de la fonction)
Quel que soit la fonction.(pour définir les valeur de départ et de
stop ainsi que l'incrément pas de soucis)

Aiguillé sur adressoff j'ai googler un peu sur le forum, j'ai vu qu'il
fallait définir la fonction dans un module publique mais après je
comprend pas bien.

Si quelqu'un a des lumières sur le sujet, merci de les partager.
De même des infos sur le callback qui si j'ai bien compris correspond
à ce genre de problématique.
J'avoue que j'ai du mal a comprendre le mécanisme.

Christophe



Christophe

RE,

> Mais je n'ai pas encore compris exactement ce à quoi
> ressort cet obscur <objet> en notre occurrence...

Sic MSDN CallByName:
<<Exécute une méthode d'un objet, ou définit ou renvoie une propriété
d'un objet.<<

Donc comme le disait Vincent,
Soit l'utilisateur définit une classe Fonction
dans la quelle il met toutes les méthodes publiques qu'il veut,
décrivant Y=f(x)

Soit il ecrit sa fonction dans une form, en la déclarant publique.
Pour l'utilisateur de mdc:
L'appel doit se faire comme suit
call mdc.dessinefonction( object,nomfonction)

Ensuite de manière interne a l'objet mdc on fixe la valeur de X et on
boucle avec un YÊllbyname(object, nomfonction,vbMethod, X)

Object prenant la valeur de FormN ou ClasseMachin.

Je suis d'accord avec toi pour l'aspect Typage unique de la donnée,
contrairement à C++, mais compte tenu de l'objectif du modele objet qui
est de fournir une interface entre les espaces métriques continu 2D et
les espaces discrets périphérique et logique, la valeur supposée de X,Y
est par définition Double.

Si respect de cette condition :
Methode d'un objet publique acceptant en paramètre obligatoire X as
double et renvoyant une valeur Y AS Double
Alors
l'objet mdc est capable de s'interfacer

Merci à Vincent pour le CallByName
Merci à Yann pour les infos.

Christophe

Bnjr Nicolas,

Je ne comprends pas tres bien ta suggestion :
est-ce pour interpréter "on-line" uen fonciton introduite
au clavier par l'utilisateur ? J'aimerais voir un exemple,
car je pige pas trop l'interfaçage.....
Sur le problème actuel, pouvoir passer à une fonction
d'une classe graphique "grapheuse de courbes"
l'adresse d'une fonction à utiliser, il est implicite
que la fonction (éventuellement par un index)
a été programmée en VB à l'extérieur de la classe :
d'où nos interrogations pour passer l'AddressOf...
Mais je ne sais si christophe a résolu le truc...
@+

YannX
"ng" <ng@ngsoft-fr.com> a écrit dans le message de
news:On8SOuW3EHA.2196@TK2MSFTNGP14.phx.gbl...

Salut,

Sinon si ton objectif est de faire un traceur de fonction qui sont

définies

par l'utilisateur, tu pourras utiliser le moteur de script (ms script
control) pour évaluer ta fonction.

--
Nicolas G.
FAQ VB : http://faq.vb.free.fr
API Guide : http://www.allapi.net
Google Groups : http://groups.google.fr/
MZ-Tools : http://www.mztools.com/

christophe-pasde<> @wanadoo.fr>" < wrote:
> Bonjour,
>
> J'ai écrit une classe permettant d'afficher un point P(x,y) où Y > > f(x) f étant une fonction quelconque.
>
> Pour l'instant ça s'utilise comme suit:
> 'ici f(x) = tan(x)'
> dans un module de feuille ou publique:
> mdc étant mon objet définit dans un module de classe:
>
> 'valeur de l'incrément réel (double)
> dx = mdc.DefiniPasReal
> 'Valeur d'arrêt
> Count& = mdc.DefiniCompteur
> 'Xo valeur départ
> X = mdc.Espacereelleft
>
> For i& = 0 To Count&
> Y = Tan(X)
> mdc.DessinePointFonction X, Y, RGB(255, 0, 0)
> X = X + dx
> Next i&
>
> Je voudrais encapsulé ceci encore plus et écrire tout simplement:
>
> mdc.dessinefonction( adresse ou nom de la fonction)
> Quel que soit la fonction.(pour définir les valeur de départ et de
> stop ainsi que l'incrément pas de soucis)
>
> Aiguillé sur adressoff j'ai googler un peu sur le forum, j'ai vu qu'il
> fallait définir la fonction dans un module publique mais après je
> comprend pas bien.
>
> Si quelqu'un a des lumières sur le sujet, merci de les partager.
> De même des infos sur le callback qui si j'ai bien compris correspond
> à ce genre de problématique.
> J'avoue que j'ai du mal a comprendre le mécanisme.
>
> Christophe
>
>
>
> Christophe

"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
message de news:41b770f5$0$3409$8fcfb975@news.wanadoo.fr...

RE,

> Mais je n'ai pas encore compris exactement ce à quoi
> ressort cet obscur <objet> en notre occurrence...

Sic MSDN CallByName:
<<Exécute une méthode d'un objet, ou définit ou renvoie une propriété
d'un objet.<<

Soit l'utilisateur définit une classe Fonction
dans la quelle il met toutes les méthodes publiques qu'il veut,
décrivant Y=f(x)

Pour l'utilisateur de mdc:
L'appel doit se faire comme suit
call mdc.dessinefonction( object,nomfonction)

Ensuite de manière interne a l'objet mdc on fixe la valeur de X et on
boucle avec un YÊllbyname(object, nomfonction,vbMethod, X)

Object prenant la valeur de FormN ou ClasseMachin.

Je suis d'accord avec toi pour l'aspect Typage unique de la donnée,
contrairement à C++, mais compte tenu de l'objectif du modele objet qui
est de fournir une interface entre les espaces métriques continu 2D et
les espaces discrets périphérique et logique, la valeur supposée de X,Y
est par définition Double.

Si respect de cette condition :
Methode d'un objet publique acceptant en paramètre obligatoire X as
double et renvoyant une valeur Y AS Double
Alors
l'objet mdc est capable de s'interfacer

Christophe

Bon, au niveau théorique no problem (c'est du C).
Et en VB6 cela marche comment ? bien ?
Je suis d'accord avec ta conception d'une classe utilisateur
de nom prédéterminé : cela me parait le plus simple,
sauf à rajouter une méthode
mdc.FixFunction( o as Object , f as Long) as boolean
qui passerait l'appel a n'importe quelle méthode publique
à la classe grapheuse....
@+
YannX

Bonjour,

Pas trop le temps en ce moment, mais le truc pourrait être comme ça:

Une MetaClasse MyFonction
avec une methode unique

Public function GraphFonction( X as double) as double
' rien
end function

Une collection de MyFonction
dont la clef assure l'unicité du nom de fonction.

L'utilisateur ensuite n'a qu'a créer des classes fonctions dérivée
Exemple
classe Sinus
Implements GraphFonction

Private Myfonction_Graphfonction(X) as double
Myfonction_Graphfonction=sin(x)
end if

Ensuite le mdc lui ne gere que les fonctions appartenant à la collection
des fonctions.

NB je poursuis la discussion sur le NG, c'est pas pour polluer, mais ce
projet doit être publique à terme, donc si quelqu'un veut donner son
avis qu'il ne se gène pas.


Christophe

YannX a écrit :

"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
message de news:41b770f5$0$3409$8fcfb975@news.wanadoo.fr...

RE,

> Mais je n'ai pas encore compris exactement ce à quoi
> ressort cet obscur <objet> en notre occurrence...

Sic MSDN CallByName:
<<Exécute une méthode d'un objet, ou définit ou renvoie une propriété
d'un objet.<<

Soit l'utilisateur définit une classe Fonction
dans la quelle il met toutes les méthodes publiques qu'il veut,
décrivant Y=f(x)

Pour l'utilisateur de mdc:
L'appel doit se faire comme suit
call mdc.dessinefonction( object,nomfonction)

Ensuite de manière interne a l'objet mdc on fixe la valeur de X et on
boucle avec un YÊllbyname(object, nomfonction,vbMethod, X)

Object prenant la valeur de FormN ou ClasseMachin.

Je suis d'accord avec toi pour l'aspect Typage unique de la donnée,
contrairement à C++, mais compte tenu de l'objectif du modele objet qui
est de fournir une interface entre les espaces métriques continu 2D et
les espaces discrets périphérique et logique, la valeur supposée de X,Y
est par définition Double.

Si respect de cette condition :
Methode d'un objet publique acceptant en paramètre obligatoire X as
double et renvoyant une valeur Y AS Double
Alors
l'objet mdc est capable de s'interfacer

Christophe

Bon, au niveau théorique no problem (c'est du C).
Et en VB6 cela marche comment ? bien ?
Je suis d'accord avec ta conception d'une classe utilisateur
de nom prédéterminé : cela me parait le plus simple,
sauf à rajouter une méthode
mdc.FixFunction( o as Object , f as Long) as boolean
qui passerait l'appel a n'importe quelle méthode publique
à la classe grapheuse....
@+
YannX

Salut,

Je t'envoie les suorces d'un traceur 3d tout simple ds ta BAL.

--
Nicolas G.
FAQ VB : http://faq.vb.free.fr
API Guide : http://www.allapi.net
Google Groups : http://groups.google.fr/
MZ-Tools : http://www.mztools.com/

YannX wrote:

Bnjr Nicolas,

Je ne comprends pas tres bien ta suggestion :
est-ce pour interpréter "on-line" uen fonciton introduite
au clavier par l'utilisateur ? J'aimerais voir un exemple,
car je pige pas trop l'interfaçage.....
Sur le problème actuel, pouvoir passer à une fonction
d'une classe graphique "grapheuse de courbes"
l'adresse d'une fonction à utiliser, il est implicite
que la fonction (éventuellement par un index)
a été programmée en VB à l'extérieur de la classe :
d'où nos interrogations pour passer l'AddressOf...
Mais je ne sais si christophe a résolu le truc...
@+

YannX
"ng" <ng@ngsoft-fr.com> a écrit dans le message de
news:On8SOuW3EHA.2196@TK2MSFTNGP14.phx.gbl...

Salut,

Sinon si ton objectif est de faire un traceur de fonction qui sont
définies par l'utilisateur, tu pourras utiliser le moteur de script
(ms script control) pour évaluer ta fonction.

--
Nicolas G.
FAQ VB : http://faq.vb.free.fr
API Guide : http://www.allapi.net
Google Groups : http://groups.google.fr/
MZ-Tools : http://www.mztools.com/

christophe-pasde<> @wanadoo.fr>" < wrote:

Bonjour,

J'ai écrit une classe permettant d'afficher un point P(x,y) où Y >>> f(x) f étant une fonction quelconque.

Pour l'instant ça s'utilise comme suit:
'ici f(x) = tan(x)'
dans un module de feuille ou publique:
mdc étant mon objet définit dans un module de classe:

'valeur de l'incrément réel (double)
dx = mdc.DefiniPasReal
'Valeur d'arrêt
Count& = mdc.DefiniCompteur
'Xo valeur départ
X = mdc.Espacereelleft

For i& = 0 To Count&
Y = Tan(X)
mdc.DessinePointFonction X, Y, RGB(255, 0, 0)
X = X + dx
Next i&

Je voudrais encapsulé ceci encore plus et écrire tout simplement:

mdc.dessinefonction( adresse ou nom de la fonction)
Quel que soit la fonction.(pour définir les valeur de départ et de
stop ainsi que l'incrément pas de soucis)

Aiguillé sur adressoff j'ai googler un peu sur le forum, j'ai vu
qu'il fallait définir la fonction dans un module publique mais
après je comprend pas bien.

Si quelqu'un a des lumières sur le sujet, merci de les partager.
De même des infos sur le callback qui si j'ai bien compris
correspond à ce genre de problématique.
J'avoue que j'ai du mal a comprendre le mécanisme.

Christophe



Christophe