Bonjour à tous.
Je dois actuellement développer une appli qui utilise un assembly qui
gère un système de téléphonie, avec windev 10. Je tiens à
souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
pas trop ^^)
L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
problème. Le souci se situe dans l'autre sens, communication de
l'assembly vers mon appli windev.
Lors de la détection d'un appel entrant, il faut pouvoir récupérer
l'évènement.. En C#, ce ne serait pas trop un problème, il suffit de
créer la procédure qui va être appelée.. mais avec Windev c'est u ne
autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
dans l'aide ou les exemples.
J'ai une procédure qui a été importée avec l'assembly, appelée
add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
passer en paramètre (j'ai essayé de passer un pointeur sur fonction,
mais ça marche pas).
Quelqu'un sait-il comment je dois gérer cela ??
Bonjour à tous.
Je dois actuellement développer une appli qui utilise un assembly qui
gère un système de téléphonie, avec windev 10. Je tiens à
souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
pas trop ^^)
L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
problème. Le souci se situe dans l'autre sens, communication de
l'assembly vers mon appli windev.
Lors de la détection d'un appel entrant, il faut pouvoir récupérer
l'évènement.. En C#, ce ne serait pas trop un problème, il suffit de
créer la procédure qui va être appelée.. mais avec Windev c'est u ne
autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
dans l'aide ou les exemples.
J'ai une procédure qui a été importée avec l'assembly, appelée
add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
passer en paramètre (j'ai essayé de passer un pointeur sur fonction,
mais ça marche pas).
Quelqu'un sait-il comment je dois gérer cela ??
Bonjour à tous.
Je dois actuellement développer une appli qui utilise un assembly qui
gère un système de téléphonie, avec windev 10. Je tiens à
souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
pas trop ^^)
L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
problème. Le souci se situe dans l'autre sens, communication de
l'assembly vers mon appli windev.
Lors de la détection d'un appel entrant, il faut pouvoir récupérer
l'évènement.. En C#, ce ne serait pas trop un problème, il suffit de
créer la procédure qui va être appelée.. mais avec Windev c'est u ne
autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
dans l'aide ou les exemples.
J'ai une procédure qui a été importée avec l'assembly, appelée
add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
passer en paramètre (j'ai essayé de passer un pointeur sur fonction,
mais ça marche pas).
Quelqu'un sait-il comment je dois gérer cela ??
wrote:Bonjour à tous.
Je dois actuellement développer une appli qui utilise un assembly qui
gère un système de téléphonie, avec windev 10. Je tiens à
souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
pas trop ^^)
L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
problème. Le souci se situe dans l'autre sens, communication de
l'assembly vers mon appli windev.
Lors de la détection d'un appel entrant, il faut pouvoir récupérer
l'évènement.. En C#, ce ne serait pas trop un problème, il suffit de
créer la procédure qui va être appelée.. mais avec Windev c'est une
autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
dans l'aide ou les exemples.
J'ai une procédure qui a été importée avec l'assembly, appelée
add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
passer en paramètre (j'ai essayé de passer un pointeur sur fonction,
mais ça marche pas).
Quelqu'un sait-il comment je dois gérer cela ??
Bon, j'ai un peu avancé sur le sujet.
En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
paramètre à passer est en fait un délégué (mot clef delegate en
C#)
En gros on écrit une fonction qui sera exécutée lors de
l'évènement (principe du callback)
Seulement, je ne sais pas du tout comment gérer ça avec windev. J'ai
fait quelques recherches sur le net mais je ne trouve aucune réponse.
Besoin d'aide, merci à vous :)
pierre_jean_soule@yahoo.fr wrote:
Bonjour à tous.
Je dois actuellement développer une appli qui utilise un assembly qui
gère un système de téléphonie, avec windev 10. Je tiens à
souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
pas trop ^^)
L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
problème. Le souci se situe dans l'autre sens, communication de
l'assembly vers mon appli windev.
Lors de la détection d'un appel entrant, il faut pouvoir récupérer
l'évènement.. En C#, ce ne serait pas trop un problème, il suffit de
créer la procédure qui va être appelée.. mais avec Windev c'est une
autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
dans l'aide ou les exemples.
J'ai une procédure qui a été importée avec l'assembly, appelée
add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
passer en paramètre (j'ai essayé de passer un pointeur sur fonction,
mais ça marche pas).
Quelqu'un sait-il comment je dois gérer cela ??
Bon, j'ai un peu avancé sur le sujet.
En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
paramètre à passer est en fait un délégué (mot clef delegate en
C#)
En gros on écrit une fonction qui sera exécutée lors de
l'évènement (principe du callback)
Seulement, je ne sais pas du tout comment gérer ça avec windev. J'ai
fait quelques recherches sur le net mais je ne trouve aucune réponse.
Besoin d'aide, merci à vous :)
wrote:Bonjour à tous.
Je dois actuellement développer une appli qui utilise un assembly qui
gère un système de téléphonie, avec windev 10. Je tiens à
souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
pas trop ^^)
L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
problème. Le souci se situe dans l'autre sens, communication de
l'assembly vers mon appli windev.
Lors de la détection d'un appel entrant, il faut pouvoir récupérer
l'évènement.. En C#, ce ne serait pas trop un problème, il suffit de
créer la procédure qui va être appelée.. mais avec Windev c'est une
autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
dans l'aide ou les exemples.
J'ai une procédure qui a été importée avec l'assembly, appelée
add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
passer en paramètre (j'ai essayé de passer un pointeur sur fonction,
mais ça marche pas).
Quelqu'un sait-il comment je dois gérer cela ??
Bon, j'ai un peu avancé sur le sujet.
En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
paramètre à passer est en fait un délégué (mot clef delegate en
C#)
En gros on écrit une fonction qui sera exécutée lors de
l'évènement (principe du callback)
Seulement, je ne sais pas du tout comment gérer ça avec windev. J'ai
fait quelques recherches sur le net mais je ne trouve aucune réponse.
Besoin d'aide, merci à vous :)
Peij a formulé la demande :
> wrote:
>> Bonjour à tous.
>>
>> Je dois actuellement développer une appli qui utilise un assembly qui
>> gère un système de téléphonie, avec windev 10. Je tiens à
>> souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
>> pas trop ^^)
>>
>> L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
>> problème. Le souci se situe dans l'autre sens, communication de
>> l'assembly vers mon appli windev.
>>
>> Lors de la détection d'un appel entrant, il faut pouvoir récupér er
>> l'évènement.. En C#, ce ne serait pas trop un problème, il suffi t de
>> créer la procédure qui va être appelée.. mais avec Windev c'es t une
>> autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce s oit
>> dans l'aide ou les exemples.
>>
>> J'ai une procédure qui a été importée avec l'assembly, appel ée
>> add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté q ue
>> je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
>> passer en paramètre (j'ai essayé de passer un pointeur sur fonctio n,
>> mais ça marche pas).
>>
>> Quelqu'un sait-il comment je dois gérer cela ??
>
> Bon, j'ai un peu avancé sur le sujet.
>
> En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
> paramètre à passer est en fait un délégué (mot clef delegate en
> C#)
>
> En gros on écrit une fonction qui sera exécutée lors de
> l'évènement (principe du callback)
>
> Seulement, je ne sais pas du tout comment gérer ça avec windev. J'ai
> fait quelques recherches sur le net mais je ne trouve aucune réponse.
>
> Besoin d'aide, merci à vous :)
Il faut savoir que les fonction de Windev sont des pointeurs de
fonction "classique du langage C". C'est d'ailleurs pour ca que l'on
peut utiliser direcement les pointeurs de fonction dans nos chères
méthodes API de Windows du style :
API("MéthodeAPI", "LaDll.dll", ..., &MaFonction, ...)
Windev, ne fait pas automatiquement la conversion entre se pointeur et
l'association à une classe EventHandler.
Il existe une fonction en .NET qui se trouve dans l'assembly de
l'intéropérabilité qui permet de faire cela :
Classe : System.Runtime.Interop.Marshal
Méthode : GetDelegateForFunctionPointer()
Le seul hic, c'est que je n'arrive pas à appeler la méthode
Type.GetType(string) de .NET via Windev.
Ce que j'ai fais alors, c'est ma classe .NET qui fera automatiquement
le branchement vers un pointeur de fonction passé en paramètre.
Voici un exemple d'une classe C# classique avec un événement :
***************************
using System;
using System.IO;
using System.Runtime.InteropServices;
namespace ClassLibrary1
{
public class Class1
{
public Class1()
{
}
public event EventHandler UnEvenement;
public void AppelEvenement()
{
if (this.UnEvenement != null)
this.UnEvenement(this, EventArgs.Empty);
}
public void BrancherEvenement(IntPtr p)
{
Delegate d;
d = Marshal.GetDelegateForFunctionPointer(p,
typeof(EventHandler));
this.UnEvenement += (EventHandler)d;
}
}
}
***************************
Tu remarqueras une méthode BrancherEvenement() qui prend en paramètre
un pointeur.
En W-Langage il suffit de faire alors :
***************************
c est une Class1 dynamique
o est un "Object" dynamique
c = allouer un Class1()
c:AjouteEvenement(&MaProcedure)
c:BrancherEvenement()
***************************
En considérant qu'il existe une fonction de ce style :
***************************
PROCEDURE MaProcedure(sender, e)
Info("CA MAAAAAAAAAARCHE !!!")
***************************
En fait le code de BrancherEvenement() peut être réaliser en W-Langag e,
mais Windev génére (en Windev 9) une erreur si tu fais :
Type::GetType("System.EventHandler")
Si tu ne peux pas modifier le code source des assembly .NET (car
t'utilises des assembly déjà compilé, ou on ne veut pas que tu modi fies
les sources) dans ce cas, passe par un assembly intermédiaire qui
contiendra une classe qui permettra le branchement de tout ce petit
monde...
Autre chose, ne me crie pas dessus si tu ne trouves pas la fonction
GetDelegateForFunctionPointer(), elle est nouvelle dans le Framework
2.0
Cordialement
--
Gilles TOURREAU
Responsable informatique
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Peij a formulé la demande :
> pierre_jean_soule@yahoo.fr wrote:
>> Bonjour à tous.
>>
>> Je dois actuellement développer une appli qui utilise un assembly qui
>> gère un système de téléphonie, avec windev 10. Je tiens à
>> souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
>> pas trop ^^)
>>
>> L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
>> problème. Le souci se situe dans l'autre sens, communication de
>> l'assembly vers mon appli windev.
>>
>> Lors de la détection d'un appel entrant, il faut pouvoir récupér er
>> l'évènement.. En C#, ce ne serait pas trop un problème, il suffi t de
>> créer la procédure qui va être appelée.. mais avec Windev c'es t une
>> autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce s oit
>> dans l'aide ou les exemples.
>>
>> J'ai une procédure qui a été importée avec l'assembly, appel ée
>> add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté q ue
>> je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
>> passer en paramètre (j'ai essayé de passer un pointeur sur fonctio n,
>> mais ça marche pas).
>>
>> Quelqu'un sait-il comment je dois gérer cela ??
>
> Bon, j'ai un peu avancé sur le sujet.
>
> En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
> paramètre à passer est en fait un délégué (mot clef delegate en
> C#)
>
> En gros on écrit une fonction qui sera exécutée lors de
> l'évènement (principe du callback)
>
> Seulement, je ne sais pas du tout comment gérer ça avec windev. J'ai
> fait quelques recherches sur le net mais je ne trouve aucune réponse.
>
> Besoin d'aide, merci à vous :)
Il faut savoir que les fonction de Windev sont des pointeurs de
fonction "classique du langage C". C'est d'ailleurs pour ca que l'on
peut utiliser direcement les pointeurs de fonction dans nos chères
méthodes API de Windows du style :
API("MéthodeAPI", "LaDll.dll", ..., &MaFonction, ...)
Windev, ne fait pas automatiquement la conversion entre se pointeur et
l'association à une classe EventHandler.
Il existe une fonction en .NET qui se trouve dans l'assembly de
l'intéropérabilité qui permet de faire cela :
Classe : System.Runtime.Interop.Marshal
Méthode : GetDelegateForFunctionPointer()
Le seul hic, c'est que je n'arrive pas à appeler la méthode
Type.GetType(string) de .NET via Windev.
Ce que j'ai fais alors, c'est ma classe .NET qui fera automatiquement
le branchement vers un pointeur de fonction passé en paramètre.
Voici un exemple d'une classe C# classique avec un événement :
***************************
using System;
using System.IO;
using System.Runtime.InteropServices;
namespace ClassLibrary1
{
public class Class1
{
public Class1()
{
}
public event EventHandler UnEvenement;
public void AppelEvenement()
{
if (this.UnEvenement != null)
this.UnEvenement(this, EventArgs.Empty);
}
public void BrancherEvenement(IntPtr p)
{
Delegate d;
d = Marshal.GetDelegateForFunctionPointer(p,
typeof(EventHandler));
this.UnEvenement += (EventHandler)d;
}
}
}
***************************
Tu remarqueras une méthode BrancherEvenement() qui prend en paramètre
un pointeur.
En W-Langage il suffit de faire alors :
***************************
c est une Class1 dynamique
o est un "Object" dynamique
c = allouer un Class1()
c:AjouteEvenement(&MaProcedure)
c:BrancherEvenement()
***************************
En considérant qu'il existe une fonction de ce style :
***************************
PROCEDURE MaProcedure(sender, e)
Info("CA MAAAAAAAAAARCHE !!!")
***************************
En fait le code de BrancherEvenement() peut être réaliser en W-Langag e,
mais Windev génére (en Windev 9) une erreur si tu fais :
Type::GetType("System.EventHandler")
Si tu ne peux pas modifier le code source des assembly .NET (car
t'utilises des assembly déjà compilé, ou on ne veut pas que tu modi fies
les sources) dans ce cas, passe par un assembly intermédiaire qui
contiendra une classe qui permettra le branchement de tout ce petit
monde...
Autre chose, ne me crie pas dessus si tu ne trouves pas la fonction
GetDelegateForFunctionPointer(), elle est nouvelle dans le Framework
2.0
Cordialement
--
Gilles TOURREAU
Responsable informatique
gilles.tourreau@pos.fr
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Peij a formulé la demande :
> wrote:
>> Bonjour à tous.
>>
>> Je dois actuellement développer une appli qui utilise un assembly qui
>> gère un système de téléphonie, avec windev 10. Je tiens à
>> souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
>> pas trop ^^)
>>
>> L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
>> problème. Le souci se situe dans l'autre sens, communication de
>> l'assembly vers mon appli windev.
>>
>> Lors de la détection d'un appel entrant, il faut pouvoir récupér er
>> l'évènement.. En C#, ce ne serait pas trop un problème, il suffi t de
>> créer la procédure qui va être appelée.. mais avec Windev c'es t une
>> autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce s oit
>> dans l'aide ou les exemples.
>>
>> J'ai une procédure qui a été importée avec l'assembly, appel ée
>> add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté q ue
>> je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
>> passer en paramètre (j'ai essayé de passer un pointeur sur fonctio n,
>> mais ça marche pas).
>>
>> Quelqu'un sait-il comment je dois gérer cela ??
>
> Bon, j'ai un peu avancé sur le sujet.
>
> En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
> paramètre à passer est en fait un délégué (mot clef delegate en
> C#)
>
> En gros on écrit une fonction qui sera exécutée lors de
> l'évènement (principe du callback)
>
> Seulement, je ne sais pas du tout comment gérer ça avec windev. J'ai
> fait quelques recherches sur le net mais je ne trouve aucune réponse.
>
> Besoin d'aide, merci à vous :)
Il faut savoir que les fonction de Windev sont des pointeurs de
fonction "classique du langage C". C'est d'ailleurs pour ca que l'on
peut utiliser direcement les pointeurs de fonction dans nos chères
méthodes API de Windows du style :
API("MéthodeAPI", "LaDll.dll", ..., &MaFonction, ...)
Windev, ne fait pas automatiquement la conversion entre se pointeur et
l'association à une classe EventHandler.
Il existe une fonction en .NET qui se trouve dans l'assembly de
l'intéropérabilité qui permet de faire cela :
Classe : System.Runtime.Interop.Marshal
Méthode : GetDelegateForFunctionPointer()
Le seul hic, c'est que je n'arrive pas à appeler la méthode
Type.GetType(string) de .NET via Windev.
Ce que j'ai fais alors, c'est ma classe .NET qui fera automatiquement
le branchement vers un pointeur de fonction passé en paramètre.
Voici un exemple d'une classe C# classique avec un événement :
***************************
using System;
using System.IO;
using System.Runtime.InteropServices;
namespace ClassLibrary1
{
public class Class1
{
public Class1()
{
}
public event EventHandler UnEvenement;
public void AppelEvenement()
{
if (this.UnEvenement != null)
this.UnEvenement(this, EventArgs.Empty);
}
public void BrancherEvenement(IntPtr p)
{
Delegate d;
d = Marshal.GetDelegateForFunctionPointer(p,
typeof(EventHandler));
this.UnEvenement += (EventHandler)d;
}
}
}
***************************
Tu remarqueras une méthode BrancherEvenement() qui prend en paramètre
un pointeur.
En W-Langage il suffit de faire alors :
***************************
c est une Class1 dynamique
o est un "Object" dynamique
c = allouer un Class1()
c:AjouteEvenement(&MaProcedure)
c:BrancherEvenement()
***************************
En considérant qu'il existe une fonction de ce style :
***************************
PROCEDURE MaProcedure(sender, e)
Info("CA MAAAAAAAAAARCHE !!!")
***************************
En fait le code de BrancherEvenement() peut être réaliser en W-Langag e,
mais Windev génére (en Windev 9) une erreur si tu fais :
Type::GetType("System.EventHandler")
Si tu ne peux pas modifier le code source des assembly .NET (car
t'utilises des assembly déjà compilé, ou on ne veut pas que tu modi fies
les sources) dans ce cas, passe par un assembly intermédiaire qui
contiendra une classe qui permettra le branchement de tout ce petit
monde...
Autre chose, ne me crie pas dessus si tu ne trouves pas la fonction
GetDelegateForFunctionPointer(), elle est nouvelle dans le Framework
2.0
Cordialement
--
Gilles TOURREAU
Responsable informatique
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Gilles TOURREAU wrote:Peij a formulé la demande :wrote:Bonjour à tous.
Je dois actuellement développer une appli qui utilise un assembly qui
gère un système de téléphonie, avec windev 10. Je tiens à
souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
pas trop ^^)
L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
problème. Le souci se situe dans l'autre sens, communication de
l'assembly vers mon appli windev.
Lors de la détection d'un appel entrant, il faut pouvoir récupérer
l'évènement.. En C#, ce ne serait pas trop un problème, il suffit de
créer la procédure qui va être appelée.. mais avec Windev c'est une
autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
dans l'aide ou les exemples.
J'ai une procédure qui a été importée avec l'assembly, appelée
add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
passer en paramètre (j'ai essayé de passer un pointeur sur fonction,
mais ça marche pas).
Quelqu'un sait-il comment je dois gérer cela ??
Bon, j'ai un peu avancé sur le sujet.
En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
paramètre à passer est en fait un délégué (mot clef delegate en
C#)
En gros on écrit une fonction qui sera exécutée lors de
l'évènement (principe du callback)
Seulement, je ne sais pas du tout comment gérer ça avec windev. J'ai
fait quelques recherches sur le net mais je ne trouve aucune réponse.
Besoin d'aide, merci à vous :)
Il faut savoir que les fonction de Windev sont des pointeurs de
fonction "classique du langage C". C'est d'ailleurs pour ca que l'on
peut utiliser direcement les pointeurs de fonction dans nos chères
méthodes API de Windows du style :
API("MéthodeAPI", "LaDll.dll", ..., &MaFonction, ...)
Windev, ne fait pas automatiquement la conversion entre se pointeur et
l'association à une classe EventHandler.
Il existe une fonction en .NET qui se trouve dans l'assembly de
l'intéropérabilité qui permet de faire cela :
Classe : System.Runtime.Interop.Marshal
Méthode : GetDelegateForFunctionPointer()
Le seul hic, c'est que je n'arrive pas à appeler la méthode
Type.GetType(string) de .NET via Windev.
Ce que j'ai fais alors, c'est ma classe .NET qui fera automatiquement
le branchement vers un pointeur de fonction passé en paramètre.
Voici un exemple d'une classe C# classique avec un événement :
***************************
using System;
using System.IO;
using System.Runtime.InteropServices;
namespace ClassLibrary1
{
public class Class1
{
public Class1()
{
}
public event EventHandler UnEvenement;
public void AppelEvenement()
{
if (this.UnEvenement != null)
this.UnEvenement(this, EventArgs.Empty);
}
public void BrancherEvenement(IntPtr p)
{
Delegate d;
d = Marshal.GetDelegateForFunctionPointer(p,
typeof(EventHandler));
this.UnEvenement += (EventHandler)d;
}
}
}
***************************
Tu remarqueras une méthode BrancherEvenement() qui prend en paramètre
un pointeur.
En W-Langage il suffit de faire alors :
***************************
c est une Class1 dynamique
o est un "Object" dynamique
c = allouer un Class1()
c:AjouteEvenement(&MaProcedure)
c:BrancherEvenement()
***************************
En considérant qu'il existe une fonction de ce style :
***************************
PROCEDURE MaProcedure(sender, e)
Info("CA MAAAAAAAAAARCHE !!!")
***************************
En fait le code de BrancherEvenement() peut être réaliser en W-Langage,
mais Windev génére (en Windev 9) une erreur si tu fais :
Type::GetType("System.EventHandler")
Si tu ne peux pas modifier le code source des assembly .NET (car
t'utilises des assembly déjà compilé, ou on ne veut pas que tu modifies
les sources) dans ce cas, passe par un assembly intermédiaire qui
contiendra une classe qui permettra le branchement de tout ce petit
monde...
Autre chose, ne me crie pas dessus si tu ne trouves pas la fonction
GetDelegateForFunctionPointer(), elle est nouvelle dans le Framework
2.0
Cordialement
--
Gilles TOURREAU
Responsable informatique
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Merci beaucoup pour ces informations Gilles (vous avez l'air très
actif sur ce forum).
En fait, je me demandais, n'est-il pas possible d'appeler la méthode
GetDelegateForFunctionPointer() directement depuis windev, par exemple
********************
gClObjDotNet:add_onConnect(TrucBidule::GetDelegateForFunctionPointer(&MaFonction))
//OnConnect nous dit quand on est connecté, le plus simple à utiliser
dans l'assembly vu que le délégué n'attend pas de paramètre
PROCEDURE MaFonction()
Info("CA MAAAAAAAAAARCHE !!!") //(©Gilles Tourreau)
********************
C'est juste une idée (mais par quoi dois-je remplacer TrucBidule dans
mon exemple ?? xD)
Sinon, pour infos, l'assembly que j'utilise est écrit en .Net 2.0 et
je ne peux pas toucher au code.
merci encore :)
Gilles TOURREAU wrote:
Peij a formulé la demande :
pierre_jean_soule@yahoo.fr wrote:
Bonjour à tous.
Je dois actuellement développer une appli qui utilise un assembly qui
gère un système de téléphonie, avec windev 10. Je tiens à
souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
pas trop ^^)
L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
problème. Le souci se situe dans l'autre sens, communication de
l'assembly vers mon appli windev.
Lors de la détection d'un appel entrant, il faut pouvoir récupérer
l'évènement.. En C#, ce ne serait pas trop un problème, il suffit de
créer la procédure qui va être appelée.. mais avec Windev c'est une
autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
dans l'aide ou les exemples.
J'ai une procédure qui a été importée avec l'assembly, appelée
add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
passer en paramètre (j'ai essayé de passer un pointeur sur fonction,
mais ça marche pas).
Quelqu'un sait-il comment je dois gérer cela ??
Bon, j'ai un peu avancé sur le sujet.
En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
paramètre à passer est en fait un délégué (mot clef delegate en
C#)
En gros on écrit une fonction qui sera exécutée lors de
l'évènement (principe du callback)
Seulement, je ne sais pas du tout comment gérer ça avec windev. J'ai
fait quelques recherches sur le net mais je ne trouve aucune réponse.
Besoin d'aide, merci à vous :)
Il faut savoir que les fonction de Windev sont des pointeurs de
fonction "classique du langage C". C'est d'ailleurs pour ca que l'on
peut utiliser direcement les pointeurs de fonction dans nos chères
méthodes API de Windows du style :
API("MéthodeAPI", "LaDll.dll", ..., &MaFonction, ...)
Windev, ne fait pas automatiquement la conversion entre se pointeur et
l'association à une classe EventHandler.
Il existe une fonction en .NET qui se trouve dans l'assembly de
l'intéropérabilité qui permet de faire cela :
Classe : System.Runtime.Interop.Marshal
Méthode : GetDelegateForFunctionPointer()
Le seul hic, c'est que je n'arrive pas à appeler la méthode
Type.GetType(string) de .NET via Windev.
Ce que j'ai fais alors, c'est ma classe .NET qui fera automatiquement
le branchement vers un pointeur de fonction passé en paramètre.
Voici un exemple d'une classe C# classique avec un événement :
***************************
using System;
using System.IO;
using System.Runtime.InteropServices;
namespace ClassLibrary1
{
public class Class1
{
public Class1()
{
}
public event EventHandler UnEvenement;
public void AppelEvenement()
{
if (this.UnEvenement != null)
this.UnEvenement(this, EventArgs.Empty);
}
public void BrancherEvenement(IntPtr p)
{
Delegate d;
d = Marshal.GetDelegateForFunctionPointer(p,
typeof(EventHandler));
this.UnEvenement += (EventHandler)d;
}
}
}
***************************
Tu remarqueras une méthode BrancherEvenement() qui prend en paramètre
un pointeur.
En W-Langage il suffit de faire alors :
***************************
c est une Class1 dynamique
o est un "Object" dynamique
c = allouer un Class1()
c:AjouteEvenement(&MaProcedure)
c:BrancherEvenement()
***************************
En considérant qu'il existe une fonction de ce style :
***************************
PROCEDURE MaProcedure(sender, e)
Info("CA MAAAAAAAAAARCHE !!!")
***************************
En fait le code de BrancherEvenement() peut être réaliser en W-Langage,
mais Windev génére (en Windev 9) une erreur si tu fais :
Type::GetType("System.EventHandler")
Si tu ne peux pas modifier le code source des assembly .NET (car
t'utilises des assembly déjà compilé, ou on ne veut pas que tu modifies
les sources) dans ce cas, passe par un assembly intermédiaire qui
contiendra une classe qui permettra le branchement de tout ce petit
monde...
Autre chose, ne me crie pas dessus si tu ne trouves pas la fonction
GetDelegateForFunctionPointer(), elle est nouvelle dans le Framework
2.0
Cordialement
--
Gilles TOURREAU
Responsable informatique
gilles.tourreau@pos.fr
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Merci beaucoup pour ces informations Gilles (vous avez l'air très
actif sur ce forum).
En fait, je me demandais, n'est-il pas possible d'appeler la méthode
GetDelegateForFunctionPointer() directement depuis windev, par exemple
********************
gClObjDotNet:add_onConnect(TrucBidule::GetDelegateForFunctionPointer(&MaFonction))
//OnConnect nous dit quand on est connecté, le plus simple à utiliser
dans l'assembly vu que le délégué n'attend pas de paramètre
PROCEDURE MaFonction()
Info("CA MAAAAAAAAAARCHE !!!") //(©Gilles Tourreau)
********************
C'est juste une idée (mais par quoi dois-je remplacer TrucBidule dans
mon exemple ?? xD)
Sinon, pour infos, l'assembly que j'utilise est écrit en .Net 2.0 et
je ne peux pas toucher au code.
merci encore :)
Gilles TOURREAU wrote:Peij a formulé la demande :wrote:Bonjour à tous.
Je dois actuellement développer une appli qui utilise un assembly qui
gère un système de téléphonie, avec windev 10. Je tiens à
souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
pas trop ^^)
L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
problème. Le souci se situe dans l'autre sens, communication de
l'assembly vers mon appli windev.
Lors de la détection d'un appel entrant, il faut pouvoir récupérer
l'évènement.. En C#, ce ne serait pas trop un problème, il suffit de
créer la procédure qui va être appelée.. mais avec Windev c'est une
autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
dans l'aide ou les exemples.
J'ai une procédure qui a été importée avec l'assembly, appelée
add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
passer en paramètre (j'ai essayé de passer un pointeur sur fonction,
mais ça marche pas).
Quelqu'un sait-il comment je dois gérer cela ??
Bon, j'ai un peu avancé sur le sujet.
En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
paramètre à passer est en fait un délégué (mot clef delegate en
C#)
En gros on écrit une fonction qui sera exécutée lors de
l'évènement (principe du callback)
Seulement, je ne sais pas du tout comment gérer ça avec windev. J'ai
fait quelques recherches sur le net mais je ne trouve aucune réponse.
Besoin d'aide, merci à vous :)
Il faut savoir que les fonction de Windev sont des pointeurs de
fonction "classique du langage C". C'est d'ailleurs pour ca que l'on
peut utiliser direcement les pointeurs de fonction dans nos chères
méthodes API de Windows du style :
API("MéthodeAPI", "LaDll.dll", ..., &MaFonction, ...)
Windev, ne fait pas automatiquement la conversion entre se pointeur et
l'association à une classe EventHandler.
Il existe une fonction en .NET qui se trouve dans l'assembly de
l'intéropérabilité qui permet de faire cela :
Classe : System.Runtime.Interop.Marshal
Méthode : GetDelegateForFunctionPointer()
Le seul hic, c'est que je n'arrive pas à appeler la méthode
Type.GetType(string) de .NET via Windev.
Ce que j'ai fais alors, c'est ma classe .NET qui fera automatiquement
le branchement vers un pointeur de fonction passé en paramètre.
Voici un exemple d'une classe C# classique avec un événement :
***************************
using System;
using System.IO;
using System.Runtime.InteropServices;
namespace ClassLibrary1
{
public class Class1
{
public Class1()
{
}
public event EventHandler UnEvenement;
public void AppelEvenement()
{
if (this.UnEvenement != null)
this.UnEvenement(this, EventArgs.Empty);
}
public void BrancherEvenement(IntPtr p)
{
Delegate d;
d = Marshal.GetDelegateForFunctionPointer(p,
typeof(EventHandler));
this.UnEvenement += (EventHandler)d;
}
}
}
***************************
Tu remarqueras une méthode BrancherEvenement() qui prend en paramètre
un pointeur.
En W-Langage il suffit de faire alors :
***************************
c est une Class1 dynamique
o est un "Object" dynamique
c = allouer un Class1()
c:AjouteEvenement(&MaProcedure)
c:BrancherEvenement()
***************************
En considérant qu'il existe une fonction de ce style :
***************************
PROCEDURE MaProcedure(sender, e)
Info("CA MAAAAAAAAAARCHE !!!")
***************************
En fait le code de BrancherEvenement() peut être réaliser en W-Langage,
mais Windev génére (en Windev 9) une erreur si tu fais :
Type::GetType("System.EventHandler")
Si tu ne peux pas modifier le code source des assembly .NET (car
t'utilises des assembly déjà compilé, ou on ne veut pas que tu modifies
les sources) dans ce cas, passe par un assembly intermédiaire qui
contiendra une classe qui permettra le branchement de tout ce petit
monde...
Autre chose, ne me crie pas dessus si tu ne trouves pas la fonction
GetDelegateForFunctionPointer(), elle est nouvelle dans le Framework
2.0
Cordialement
--
Gilles TOURREAU
Responsable informatique
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Merci beaucoup pour ces informations Gilles (vous avez l'air très
actif sur ce forum).
En fait, je me demandais, n'est-il pas possible d'appeler la méthode
GetDelegateForFunctionPointer() directement depuis windev, par exemple
********************
gClObjDotNet:add_onConnect(TrucBidule::GetDelegateForFunctionPointer(&MaFonction))
//OnConnect nous dit quand on est connecté, le plus simple à utiliser
dans l'assembly vu que le délégué n'attend pas de paramètre
PROCEDURE MaFonction()
Info("CA MAAAAAAAAAARCHE !!!") //(©Gilles Tourreau)
********************
C'est juste une idée (mais par quoi dois-je remplacer TrucBidule dans
mon exemple ?? xD)
Sinon, pour infos, l'assembly que j'utilise est écrit en .Net 2.0 et
je ne peux pas toucher au code.
merci encore :)
Peij a exposé le 16/08/2006 :
> Gilles TOURREAU wrote:
>> Peij a formulé la demande :
>>> wrote:
>>>> Bonjour à tous.
>>>>
>>>> Je dois actuellement développer une appli qui utilise un assembly qui
>>>> gère un système de téléphonie, avec windev 10. Je tiens à
>>>> souligner que je débute dans ce domaine (j'ai fait un peu de C#, m ais
>>>> pas trop ^^)
>>>>
>>>> L'import de l'assembly fait, j'arrive à exécuter des fonctions s ans
>>>> problème. Le souci se situe dans l'autre sens, communication de
>>>> l'assembly vers mon appli windev.
>>>>
>>>> Lors de la détection d'un appel entrant, il faut pouvoir récup érer
>>>> l'évènement.. En C#, ce ne serait pas trop un problème, il suf fit de
>>>> créer la procédure qui va être appelée.. mais avec Windev c' est une
>>>> autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
>>>> dans l'aide ou les exemples.
>>>>
>>>> J'ai une procédure qui a été importée avec l'assembly, appel ée
>>>> add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
>>>> je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je d ois
>>>> passer en paramètre (j'ai essayé de passer un pointeur sur fonct ion,
>>>> mais ça marche pas).
>>>>
>>>> Quelqu'un sait-il comment je dois gérer cela ??
>>>
>>> Bon, j'ai un peu avancé sur le sujet.
>>>
>>> En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
>>> paramètre à passer est en fait un délégué (mot clef delegat e en
>>> C#)
>>>
>>> En gros on écrit une fonction qui sera exécutée lors de
>>> l'évènement (principe du callback)
>>>
>>> Seulement, je ne sais pas du tout comment gérer ça avec windev. J 'ai
>>> fait quelques recherches sur le net mais je ne trouve aucune répons e.
>>>
>>> Besoin d'aide, merci à vous :)
>>
>> Il faut savoir que les fonction de Windev sont des pointeurs de
>> fonction "classique du langage C". C'est d'ailleurs pour ca que l'on
>> peut utiliser direcement les pointeurs de fonction dans nos chères
>> méthodes API de Windows du style :
>>
>> API("MéthodeAPI", "LaDll.dll", ..., &MaFonction, ...)
>>
>> Windev, ne fait pas automatiquement la conversion entre se pointeur et
>> l'association à une classe EventHandler.
>>
>> Il existe une fonction en .NET qui se trouve dans l'assembly de
>> l'intéropérabilité qui permet de faire cela :
>>
>> Classe : System.Runtime.Interop.Marshal
>> Méthode : GetDelegateForFunctionPointer()
>>
>> Le seul hic, c'est que je n'arrive pas à appeler la méthode
>> Type.GetType(string) de .NET via Windev.
>>
>> Ce que j'ai fais alors, c'est ma classe .NET qui fera automatiquement
>> le branchement vers un pointeur de fonction passé en paramètre.
>>
>> Voici un exemple d'une classe C# classique avec un événement :
>>
>> ***************************
>> using System;
>> using System.IO;
>> using System.Runtime.InteropServices;
>>
>> namespace ClassLibrary1
>> {
>> public class Class1
>> {
>> public Class1()
>> {
>>
>> }
>>
>> public event EventHandler UnEvenement;
>>
>> public void AppelEvenement()
>> {
>> if (this.UnEvenement != null)
>> this.UnEvenement(this, EventArgs.Empty);
>> }
>>
>> public void BrancherEvenement(IntPtr p)
>> {
>> Delegate d;
>> d = Marshal.GetDelegateForFunctionPointer(p,
>> typeof(EventHandler));
>>
>> this.UnEvenement += (EventHandler)d;
>> }
>> }
>> }
>> ***************************
>>
>> Tu remarqueras une méthode BrancherEvenement() qui prend en paramè tre
>> un pointeur.
>>
>> En W-Langage il suffit de faire alors :
>>
>> ***************************
>> c est une Class1 dynamique
>> o est un "Object" dynamique
>>
>> c = allouer un Class1()
>>
>> c:AjouteEvenement(&MaProcedure)
>> c:BrancherEvenement()
>> ***************************
>>
>> En considérant qu'il existe une fonction de ce style :
>>
>> ***************************
>> PROCEDURE MaProcedure(sender, e)
>>
>> Info("CA MAAAAAAAAAARCHE !!!")
>> ***************************
>>
>>
>> En fait le code de BrancherEvenement() peut être réaliser en W-Lan gage,
>> mais Windev génére (en Windev 9) une erreur si tu fais :
>>
>> Type::GetType("System.EventHandler")
>>
>> Si tu ne peux pas modifier le code source des assembly .NET (car
>> t'utilises des assembly déjà compilé, ou on ne veut pas que tu m odifies
>> les sources) dans ce cas, passe par un assembly intermédiaire qui
>> contiendra une classe qui permettra le branchement de tout ce petit
>> monde...
>>
>> Autre chose, ne me crie pas dessus si tu ne trouves pas la fonction
>> GetDelegateForFunctionPointer(), elle est nouvelle dans le Framework
>> 2.0
>>
>> Cordialement
>>
>> --
>> Gilles TOURREAU
>> Responsable informatique
>>
>>
>> Société P.O.S
>> Spécialiste en motoculture depuis + de 30 ans !
>> http://www.pos.fr
>
> Merci beaucoup pour ces informations Gilles (vous avez l'air très
> actif sur ce forum).
>
> En fait, je me demandais, n'est-il pas possible d'appeler la méthode
> GetDelegateForFunctionPointer() directement depuis windev, par exemple
>>
>
> ********************
> gClObjDotNet:add_onConnect(TrucBidule::GetDelegateForFunctionPointer(&M aFonction))
> //OnConnect nous dit quand on est connecté, le plus simple à utilis er
> dans l'assembly vu que le délégué n'attend pas de paramètre
>
>
> PROCEDURE MaFonction()
>
> Info("CA MAAAAAAAAAARCHE !!!") //(©Gilles Tourreau)
> ********************
>
> C'est juste une idée (mais par quoi dois-je remplacer TrucBidule dans
> mon exemple ?? xD)
>
> Sinon, pour infos, l'assembly que j'utilise est écrit en .Net 2.0 et
> je ne peux pas toucher au code.
>
> merci encore :)
Comme je l'ai dis (et peut-être mal expliqué) :
Il est possible d'appeler GetDelegateForFunctionPointer() depuis
Windev.
La méthode GetDelegateForFunctionPointer() prend 2 paramètres (CF. Le
SDK de Billou sur le .NET Framework) :
Un IntPtr qui représente le pointeur de votre fonction.
Un Type qui doit être le type de votre évenement (hérité de
EventHandler).
Pour le premier : pas de problème
Pour le second : Il faut obtenir le type de votre évenement.
**************************
RAPPEL sur ce qu'est un type d'évenement :
Quand un évenement est défini comme celà en C# :
public event EventHandler UnEvenement;
L'évenement "UnEvenement" est de type "EventHandler".
**************************
La seul manière d'obtenir le type d'une classe dans le .NET est de
faire un "typeof(LaClasse)". Le problème est que "typeof" n'existe pas
en Windev, il existe cependant une fonction .NET qui permettent de
faire cela : Type.GetType("Le.Type.A.Retourner")
Le code W-Langage pour celà serait :
Marshal::GetDelegateForFunctionPointer(&MaFonction,
Type::GetType("System.EventHandler"))
Tu constateras que ce code provoque une erreur de compilation au niveau
de Windev te disant que GetType n'est pas globale alors que chez Billou
elle est définie comme statique...? Pourquoi ? Je n'en sais rien !
Certainement un bug de Windev...
C'est pour cela que pour remedier à ce problème :
- Soit tu modifies un peu ton code .NET pour faire des fonctions de
branchement comme je t'ai montré en exemple.
- Soit, si tu ne peux pas, tu créer un assembly .NET qui permet de
faire ces branchements.
Cordialement
--
Gilles TOURREAU
Responsable informatique
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Peij a exposé le 16/08/2006 :
> Gilles TOURREAU wrote:
>> Peij a formulé la demande :
>>> pierre_jean_soule@yahoo.fr wrote:
>>>> Bonjour à tous.
>>>>
>>>> Je dois actuellement développer une appli qui utilise un assembly qui
>>>> gère un système de téléphonie, avec windev 10. Je tiens à
>>>> souligner que je débute dans ce domaine (j'ai fait un peu de C#, m ais
>>>> pas trop ^^)
>>>>
>>>> L'import de l'assembly fait, j'arrive à exécuter des fonctions s ans
>>>> problème. Le souci se situe dans l'autre sens, communication de
>>>> l'assembly vers mon appli windev.
>>>>
>>>> Lors de la détection d'un appel entrant, il faut pouvoir récup érer
>>>> l'évènement.. En C#, ce ne serait pas trop un problème, il suf fit de
>>>> créer la procédure qui va être appelée.. mais avec Windev c' est une
>>>> autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
>>>> dans l'aide ou les exemples.
>>>>
>>>> J'ai une procédure qui a été importée avec l'assembly, appel ée
>>>> add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
>>>> je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je d ois
>>>> passer en paramètre (j'ai essayé de passer un pointeur sur fonct ion,
>>>> mais ça marche pas).
>>>>
>>>> Quelqu'un sait-il comment je dois gérer cela ??
>>>
>>> Bon, j'ai un peu avancé sur le sujet.
>>>
>>> En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
>>> paramètre à passer est en fait un délégué (mot clef delegat e en
>>> C#)
>>>
>>> En gros on écrit une fonction qui sera exécutée lors de
>>> l'évènement (principe du callback)
>>>
>>> Seulement, je ne sais pas du tout comment gérer ça avec windev. J 'ai
>>> fait quelques recherches sur le net mais je ne trouve aucune répons e.
>>>
>>> Besoin d'aide, merci à vous :)
>>
>> Il faut savoir que les fonction de Windev sont des pointeurs de
>> fonction "classique du langage C". C'est d'ailleurs pour ca que l'on
>> peut utiliser direcement les pointeurs de fonction dans nos chères
>> méthodes API de Windows du style :
>>
>> API("MéthodeAPI", "LaDll.dll", ..., &MaFonction, ...)
>>
>> Windev, ne fait pas automatiquement la conversion entre se pointeur et
>> l'association à une classe EventHandler.
>>
>> Il existe une fonction en .NET qui se trouve dans l'assembly de
>> l'intéropérabilité qui permet de faire cela :
>>
>> Classe : System.Runtime.Interop.Marshal
>> Méthode : GetDelegateForFunctionPointer()
>>
>> Le seul hic, c'est que je n'arrive pas à appeler la méthode
>> Type.GetType(string) de .NET via Windev.
>>
>> Ce que j'ai fais alors, c'est ma classe .NET qui fera automatiquement
>> le branchement vers un pointeur de fonction passé en paramètre.
>>
>> Voici un exemple d'une classe C# classique avec un événement :
>>
>> ***************************
>> using System;
>> using System.IO;
>> using System.Runtime.InteropServices;
>>
>> namespace ClassLibrary1
>> {
>> public class Class1
>> {
>> public Class1()
>> {
>>
>> }
>>
>> public event EventHandler UnEvenement;
>>
>> public void AppelEvenement()
>> {
>> if (this.UnEvenement != null)
>> this.UnEvenement(this, EventArgs.Empty);
>> }
>>
>> public void BrancherEvenement(IntPtr p)
>> {
>> Delegate d;
>> d = Marshal.GetDelegateForFunctionPointer(p,
>> typeof(EventHandler));
>>
>> this.UnEvenement += (EventHandler)d;
>> }
>> }
>> }
>> ***************************
>>
>> Tu remarqueras une méthode BrancherEvenement() qui prend en paramè tre
>> un pointeur.
>>
>> En W-Langage il suffit de faire alors :
>>
>> ***************************
>> c est une Class1 dynamique
>> o est un "Object" dynamique
>>
>> c = allouer un Class1()
>>
>> c:AjouteEvenement(&MaProcedure)
>> c:BrancherEvenement()
>> ***************************
>>
>> En considérant qu'il existe une fonction de ce style :
>>
>> ***************************
>> PROCEDURE MaProcedure(sender, e)
>>
>> Info("CA MAAAAAAAAAARCHE !!!")
>> ***************************
>>
>>
>> En fait le code de BrancherEvenement() peut être réaliser en W-Lan gage,
>> mais Windev génére (en Windev 9) une erreur si tu fais :
>>
>> Type::GetType("System.EventHandler")
>>
>> Si tu ne peux pas modifier le code source des assembly .NET (car
>> t'utilises des assembly déjà compilé, ou on ne veut pas que tu m odifies
>> les sources) dans ce cas, passe par un assembly intermédiaire qui
>> contiendra une classe qui permettra le branchement de tout ce petit
>> monde...
>>
>> Autre chose, ne me crie pas dessus si tu ne trouves pas la fonction
>> GetDelegateForFunctionPointer(), elle est nouvelle dans le Framework
>> 2.0
>>
>> Cordialement
>>
>> --
>> Gilles TOURREAU
>> Responsable informatique
>> gilles.tourreau@pos.fr
>>
>> Société P.O.S
>> Spécialiste en motoculture depuis + de 30 ans !
>> http://www.pos.fr
>
> Merci beaucoup pour ces informations Gilles (vous avez l'air très
> actif sur ce forum).
>
> En fait, je me demandais, n'est-il pas possible d'appeler la méthode
> GetDelegateForFunctionPointer() directement depuis windev, par exemple
>>
>
> ********************
> gClObjDotNet:add_onConnect(TrucBidule::GetDelegateForFunctionPointer(&M aFonction))
> //OnConnect nous dit quand on est connecté, le plus simple à utilis er
> dans l'assembly vu que le délégué n'attend pas de paramètre
>
>
> PROCEDURE MaFonction()
>
> Info("CA MAAAAAAAAAARCHE !!!") //(©Gilles Tourreau)
> ********************
>
> C'est juste une idée (mais par quoi dois-je remplacer TrucBidule dans
> mon exemple ?? xD)
>
> Sinon, pour infos, l'assembly que j'utilise est écrit en .Net 2.0 et
> je ne peux pas toucher au code.
>
> merci encore :)
Comme je l'ai dis (et peut-être mal expliqué) :
Il est possible d'appeler GetDelegateForFunctionPointer() depuis
Windev.
La méthode GetDelegateForFunctionPointer() prend 2 paramètres (CF. Le
SDK de Billou sur le .NET Framework) :
Un IntPtr qui représente le pointeur de votre fonction.
Un Type qui doit être le type de votre évenement (hérité de
EventHandler).
Pour le premier : pas de problème
Pour le second : Il faut obtenir le type de votre évenement.
**************************
RAPPEL sur ce qu'est un type d'évenement :
Quand un évenement est défini comme celà en C# :
public event EventHandler UnEvenement;
L'évenement "UnEvenement" est de type "EventHandler".
**************************
La seul manière d'obtenir le type d'une classe dans le .NET est de
faire un "typeof(LaClasse)". Le problème est que "typeof" n'existe pas
en Windev, il existe cependant une fonction .NET qui permettent de
faire cela : Type.GetType("Le.Type.A.Retourner")
Le code W-Langage pour celà serait :
Marshal::GetDelegateForFunctionPointer(&MaFonction,
Type::GetType("System.EventHandler"))
Tu constateras que ce code provoque une erreur de compilation au niveau
de Windev te disant que GetType n'est pas globale alors que chez Billou
elle est définie comme statique...? Pourquoi ? Je n'en sais rien !
Certainement un bug de Windev...
C'est pour cela que pour remedier à ce problème :
- Soit tu modifies un peu ton code .NET pour faire des fonctions de
branchement comme je t'ai montré en exemple.
- Soit, si tu ne peux pas, tu créer un assembly .NET qui permet de
faire ces branchements.
Cordialement
--
Gilles TOURREAU
Responsable informatique
gilles.tourreau@pos.fr
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Peij a exposé le 16/08/2006 :
> Gilles TOURREAU wrote:
>> Peij a formulé la demande :
>>> wrote:
>>>> Bonjour à tous.
>>>>
>>>> Je dois actuellement développer une appli qui utilise un assembly qui
>>>> gère un système de téléphonie, avec windev 10. Je tiens à
>>>> souligner que je débute dans ce domaine (j'ai fait un peu de C#, m ais
>>>> pas trop ^^)
>>>>
>>>> L'import de l'assembly fait, j'arrive à exécuter des fonctions s ans
>>>> problème. Le souci se situe dans l'autre sens, communication de
>>>> l'assembly vers mon appli windev.
>>>>
>>>> Lors de la détection d'un appel entrant, il faut pouvoir récup érer
>>>> l'évènement.. En C#, ce ne serait pas trop un problème, il suf fit de
>>>> créer la procédure qui va être appelée.. mais avec Windev c' est une
>>>> autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
>>>> dans l'aide ou les exemples.
>>>>
>>>> J'ai une procédure qui a été importée avec l'assembly, appel ée
>>>> add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
>>>> je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je d ois
>>>> passer en paramètre (j'ai essayé de passer un pointeur sur fonct ion,
>>>> mais ça marche pas).
>>>>
>>>> Quelqu'un sait-il comment je dois gérer cela ??
>>>
>>> Bon, j'ai un peu avancé sur le sujet.
>>>
>>> En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
>>> paramètre à passer est en fait un délégué (mot clef delegat e en
>>> C#)
>>>
>>> En gros on écrit une fonction qui sera exécutée lors de
>>> l'évènement (principe du callback)
>>>
>>> Seulement, je ne sais pas du tout comment gérer ça avec windev. J 'ai
>>> fait quelques recherches sur le net mais je ne trouve aucune répons e.
>>>
>>> Besoin d'aide, merci à vous :)
>>
>> Il faut savoir que les fonction de Windev sont des pointeurs de
>> fonction "classique du langage C". C'est d'ailleurs pour ca que l'on
>> peut utiliser direcement les pointeurs de fonction dans nos chères
>> méthodes API de Windows du style :
>>
>> API("MéthodeAPI", "LaDll.dll", ..., &MaFonction, ...)
>>
>> Windev, ne fait pas automatiquement la conversion entre se pointeur et
>> l'association à une classe EventHandler.
>>
>> Il existe une fonction en .NET qui se trouve dans l'assembly de
>> l'intéropérabilité qui permet de faire cela :
>>
>> Classe : System.Runtime.Interop.Marshal
>> Méthode : GetDelegateForFunctionPointer()
>>
>> Le seul hic, c'est que je n'arrive pas à appeler la méthode
>> Type.GetType(string) de .NET via Windev.
>>
>> Ce que j'ai fais alors, c'est ma classe .NET qui fera automatiquement
>> le branchement vers un pointeur de fonction passé en paramètre.
>>
>> Voici un exemple d'une classe C# classique avec un événement :
>>
>> ***************************
>> using System;
>> using System.IO;
>> using System.Runtime.InteropServices;
>>
>> namespace ClassLibrary1
>> {
>> public class Class1
>> {
>> public Class1()
>> {
>>
>> }
>>
>> public event EventHandler UnEvenement;
>>
>> public void AppelEvenement()
>> {
>> if (this.UnEvenement != null)
>> this.UnEvenement(this, EventArgs.Empty);
>> }
>>
>> public void BrancherEvenement(IntPtr p)
>> {
>> Delegate d;
>> d = Marshal.GetDelegateForFunctionPointer(p,
>> typeof(EventHandler));
>>
>> this.UnEvenement += (EventHandler)d;
>> }
>> }
>> }
>> ***************************
>>
>> Tu remarqueras une méthode BrancherEvenement() qui prend en paramè tre
>> un pointeur.
>>
>> En W-Langage il suffit de faire alors :
>>
>> ***************************
>> c est une Class1 dynamique
>> o est un "Object" dynamique
>>
>> c = allouer un Class1()
>>
>> c:AjouteEvenement(&MaProcedure)
>> c:BrancherEvenement()
>> ***************************
>>
>> En considérant qu'il existe une fonction de ce style :
>>
>> ***************************
>> PROCEDURE MaProcedure(sender, e)
>>
>> Info("CA MAAAAAAAAAARCHE !!!")
>> ***************************
>>
>>
>> En fait le code de BrancherEvenement() peut être réaliser en W-Lan gage,
>> mais Windev génére (en Windev 9) une erreur si tu fais :
>>
>> Type::GetType("System.EventHandler")
>>
>> Si tu ne peux pas modifier le code source des assembly .NET (car
>> t'utilises des assembly déjà compilé, ou on ne veut pas que tu m odifies
>> les sources) dans ce cas, passe par un assembly intermédiaire qui
>> contiendra une classe qui permettra le branchement de tout ce petit
>> monde...
>>
>> Autre chose, ne me crie pas dessus si tu ne trouves pas la fonction
>> GetDelegateForFunctionPointer(), elle est nouvelle dans le Framework
>> 2.0
>>
>> Cordialement
>>
>> --
>> Gilles TOURREAU
>> Responsable informatique
>>
>>
>> Société P.O.S
>> Spécialiste en motoculture depuis + de 30 ans !
>> http://www.pos.fr
>
> Merci beaucoup pour ces informations Gilles (vous avez l'air très
> actif sur ce forum).
>
> En fait, je me demandais, n'est-il pas possible d'appeler la méthode
> GetDelegateForFunctionPointer() directement depuis windev, par exemple
>>
>
> ********************
> gClObjDotNet:add_onConnect(TrucBidule::GetDelegateForFunctionPointer(&M aFonction))
> //OnConnect nous dit quand on est connecté, le plus simple à utilis er
> dans l'assembly vu que le délégué n'attend pas de paramètre
>
>
> PROCEDURE MaFonction()
>
> Info("CA MAAAAAAAAAARCHE !!!") //(©Gilles Tourreau)
> ********************
>
> C'est juste une idée (mais par quoi dois-je remplacer TrucBidule dans
> mon exemple ?? xD)
>
> Sinon, pour infos, l'assembly que j'utilise est écrit en .Net 2.0 et
> je ne peux pas toucher au code.
>
> merci encore :)
Comme je l'ai dis (et peut-être mal expliqué) :
Il est possible d'appeler GetDelegateForFunctionPointer() depuis
Windev.
La méthode GetDelegateForFunctionPointer() prend 2 paramètres (CF. Le
SDK de Billou sur le .NET Framework) :
Un IntPtr qui représente le pointeur de votre fonction.
Un Type qui doit être le type de votre évenement (hérité de
EventHandler).
Pour le premier : pas de problème
Pour le second : Il faut obtenir le type de votre évenement.
**************************
RAPPEL sur ce qu'est un type d'évenement :
Quand un évenement est défini comme celà en C# :
public event EventHandler UnEvenement;
L'évenement "UnEvenement" est de type "EventHandler".
**************************
La seul manière d'obtenir le type d'une classe dans le .NET est de
faire un "typeof(LaClasse)". Le problème est que "typeof" n'existe pas
en Windev, il existe cependant une fonction .NET qui permettent de
faire cela : Type.GetType("Le.Type.A.Retourner")
Le code W-Langage pour celà serait :
Marshal::GetDelegateForFunctionPointer(&MaFonction,
Type::GetType("System.EventHandler"))
Tu constateras que ce code provoque une erreur de compilation au niveau
de Windev te disant que GetType n'est pas globale alors que chez Billou
elle est définie comme statique...? Pourquoi ? Je n'en sais rien !
Certainement un bug de Windev...
C'est pour cela que pour remedier à ce problème :
- Soit tu modifies un peu ton code .NET pour faire des fonctions de
branchement comme je t'ai montré en exemple.
- Soit, si tu ne peux pas, tu créer un assembly .NET qui permet de
faire ces branchements.
Cordialement
--
Gilles TOURREAU
Responsable informatique
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Gilles TOURREAU wrote:Peij a exposé le 16/08/2006 :Gilles TOURREAU wrote:Peij a formulé la demande :wrote:Bonjour à tous.
Je dois actuellement développer une appli qui utilise un assembly qui
gère un système de téléphonie, avec windev 10. Je tiens à
souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
pas trop ^^)
L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
problème. Le souci se situe dans l'autre sens, communication de
l'assembly vers mon appli windev.
Lors de la détection d'un appel entrant, il faut pouvoir récupérer
l'évènement.. En C#, ce ne serait pas trop un problème, il suffit de
créer la procédure qui va être appelée.. mais avec Windev c'est une
autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
dans l'aide ou les exemples.
J'ai une procédure qui a été importée avec l'assembly, appelée
add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
passer en paramètre (j'ai essayé de passer un pointeur sur fonction,
mais ça marche pas).
Quelqu'un sait-il comment je dois gérer cela ??
Bon, j'ai un peu avancé sur le sujet.
En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
paramètre à passer est en fait un délégué (mot clef delegate en
C#)
En gros on écrit une fonction qui sera exécutée lors de
l'évènement (principe du callback)
Seulement, je ne sais pas du tout comment gérer ça avec windev. J'ai
fait quelques recherches sur le net mais je ne trouve aucune réponse.
Besoin d'aide, merci à vous :)
Il faut savoir que les fonction de Windev sont des pointeurs de
fonction "classique du langage C". C'est d'ailleurs pour ca que l'on
peut utiliser direcement les pointeurs de fonction dans nos chères
méthodes API de Windows du style :
API("MéthodeAPI", "LaDll.dll", ..., &MaFonction, ...)
Windev, ne fait pas automatiquement la conversion entre se pointeur et
l'association à une classe EventHandler.
Il existe une fonction en .NET qui se trouve dans l'assembly de
l'intéropérabilité qui permet de faire cela :
Classe : System.Runtime.Interop.Marshal
Méthode : GetDelegateForFunctionPointer()
Le seul hic, c'est que je n'arrive pas à appeler la méthode
Type.GetType(string) de .NET via Windev.
Ce que j'ai fais alors, c'est ma classe .NET qui fera automatiquement
le branchement vers un pointeur de fonction passé en paramètre.
Voici un exemple d'une classe C# classique avec un événement :
***************************
using System;
using System.IO;
using System.Runtime.InteropServices;
namespace ClassLibrary1
{
public class Class1
{
public Class1()
{
}
public event EventHandler UnEvenement;
public void AppelEvenement()
{
if (this.UnEvenement != null)
this.UnEvenement(this, EventArgs.Empty);
}
public void BrancherEvenement(IntPtr p)
{
Delegate d;
d = Marshal.GetDelegateForFunctionPointer(p,
typeof(EventHandler));
this.UnEvenement += (EventHandler)d;
}
}
}
***************************
Tu remarqueras une méthode BrancherEvenement() qui prend en paramètre
un pointeur.
En W-Langage il suffit de faire alors :
***************************
c est une Class1 dynamique
o est un "Object" dynamique
c = allouer un Class1()
c:AjouteEvenement(&MaProcedure)
c:BrancherEvenement()
***************************
En considérant qu'il existe une fonction de ce style :
***************************
PROCEDURE MaProcedure(sender, e)
Info("CA MAAAAAAAAAARCHE !!!")
***************************
En fait le code de BrancherEvenement() peut être réaliser en W-Langage,
mais Windev génére (en Windev 9) une erreur si tu fais :
Type::GetType("System.EventHandler")
Si tu ne peux pas modifier le code source des assembly .NET (car
t'utilises des assembly déjà compilé, ou on ne veut pas que tu modifies
les sources) dans ce cas, passe par un assembly intermédiaire qui
contiendra une classe qui permettra le branchement de tout ce petit
monde...
Autre chose, ne me crie pas dessus si tu ne trouves pas la fonction
GetDelegateForFunctionPointer(), elle est nouvelle dans le Framework
2.0
Cordialement
--
Gilles TOURREAU
Responsable informatique
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Merci beaucoup pour ces informations Gilles (vous avez l'air très
actif sur ce forum).
En fait, je me demandais, n'est-il pas possible d'appeler la méthode
GetDelegateForFunctionPointer() directement depuis windev, par exemple
********************
gClObjDotNet:add_onConnect(TrucBidule::GetDelegateForFunctionPointer(&MaFonction))
//OnConnect nous dit quand on est connecté, le plus simple à utiliser
dans l'assembly vu que le délégué n'attend pas de paramètre
PROCEDURE MaFonction()
Info("CA MAAAAAAAAAARCHE !!!") //(©Gilles Tourreau)
********************
C'est juste une idée (mais par quoi dois-je remplacer TrucBidule dans
mon exemple ?? xD)
Sinon, pour infos, l'assembly que j'utilise est écrit en .Net 2.0 et
je ne peux pas toucher au code.
merci encore :)
Comme je l'ai dis (et peut-être mal expliqué) :
Il est possible d'appeler GetDelegateForFunctionPointer() depuis
Windev.
La méthode GetDelegateForFunctionPointer() prend 2 paramètres (CF. Le
SDK de Billou sur le .NET Framework) :
Un IntPtr qui représente le pointeur de votre fonction.
Un Type qui doit être le type de votre évenement (hérité de
EventHandler).
Pour le premier : pas de problème
Pour le second : Il faut obtenir le type de votre évenement.
**************************
RAPPEL sur ce qu'est un type d'évenement :
Quand un évenement est défini comme celà en C# :
public event EventHandler UnEvenement;
L'évenement "UnEvenement" est de type "EventHandler".
**************************
La seul manière d'obtenir le type d'une classe dans le .NET est de
faire un "typeof(LaClasse)". Le problème est que "typeof" n'existe pas
en Windev, il existe cependant une fonction .NET qui permettent de
faire cela : Type.GetType("Le.Type.A.Retourner")
Le code W-Langage pour celà serait :
Marshal::GetDelegateForFunctionPointer(&MaFonction,
Type::GetType("System.EventHandler"))
Tu constateras que ce code provoque une erreur de compilation au niveau
de Windev te disant que GetType n'est pas globale alors que chez Billou
elle est définie comme statique...? Pourquoi ? Je n'en sais rien !
Certainement un bug de Windev...
C'est pour cela que pour remedier à ce problème :
- Soit tu modifies un peu ton code .NET pour faire des fonctions de
branchement comme je t'ai montré en exemple.
- Soit, si tu ne peux pas, tu créer un assembly .NET qui permet de
faire ces branchements.
Cordialement
--
Gilles TOURREAU
Responsable informatique
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Ok, j'en enfin pigé le truc. En fait, j'étais en train d'essayer de
faire ce que tu me disais pendant que tu écrivais la réponse, et j'ai
pu constater le problème de la fonction GetType (et c'est fort
dérangeant, car ça limite pas mal l'intégration d'assemblies dans
Windev).
J'ai essayé d'instancier un objet Type pour voir, mais ça a
lamentablement fait planter Windev. Je pense que PCSoft à encore un
peu de chemin à faire dans ce sens là.
Il va donc être nécessaire que je passe par un assembly perso. Mais,
dans ce cas, je vais donc devoir gérer tous les appels possibles vers
l'assembly, non ? (a moins que l'on puisse appeler des fonctions d'une
même instance d'un assembly depuis 2 sources différentes, si j'ose
m'exprimer ainsi).
En gros, est-ce que je peux avoir mon appli qui fasse des appels
directs vers l'assembly en même temps que mon truc intermédiare fasse
ses branchements, ou faut-il que je crée tous les points d'entrée
nécessaires dans mon assembly intermédiaire (ce qui économiserai pas
mal de temps ^^)
Merci encore pour ces réponses pertinentes :)
Gilles TOURREAU wrote:
Peij a exposé le 16/08/2006 :
Gilles TOURREAU wrote:
Peij a formulé la demande :
pierre_jean_soule@yahoo.fr wrote:
Bonjour à tous.
Je dois actuellement développer une appli qui utilise un assembly qui
gère un système de téléphonie, avec windev 10. Je tiens à
souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
pas trop ^^)
L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
problème. Le souci se situe dans l'autre sens, communication de
l'assembly vers mon appli windev.
Lors de la détection d'un appel entrant, il faut pouvoir récupérer
l'évènement.. En C#, ce ne serait pas trop un problème, il suffit de
créer la procédure qui va être appelée.. mais avec Windev c'est une
autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
dans l'aide ou les exemples.
J'ai une procédure qui a été importée avec l'assembly, appelée
add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
passer en paramètre (j'ai essayé de passer un pointeur sur fonction,
mais ça marche pas).
Quelqu'un sait-il comment je dois gérer cela ??
Bon, j'ai un peu avancé sur le sujet.
En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
paramètre à passer est en fait un délégué (mot clef delegate en
C#)
En gros on écrit une fonction qui sera exécutée lors de
l'évènement (principe du callback)
Seulement, je ne sais pas du tout comment gérer ça avec windev. J'ai
fait quelques recherches sur le net mais je ne trouve aucune réponse.
Besoin d'aide, merci à vous :)
Il faut savoir que les fonction de Windev sont des pointeurs de
fonction "classique du langage C". C'est d'ailleurs pour ca que l'on
peut utiliser direcement les pointeurs de fonction dans nos chères
méthodes API de Windows du style :
API("MéthodeAPI", "LaDll.dll", ..., &MaFonction, ...)
Windev, ne fait pas automatiquement la conversion entre se pointeur et
l'association à une classe EventHandler.
Il existe une fonction en .NET qui se trouve dans l'assembly de
l'intéropérabilité qui permet de faire cela :
Classe : System.Runtime.Interop.Marshal
Méthode : GetDelegateForFunctionPointer()
Le seul hic, c'est que je n'arrive pas à appeler la méthode
Type.GetType(string) de .NET via Windev.
Ce que j'ai fais alors, c'est ma classe .NET qui fera automatiquement
le branchement vers un pointeur de fonction passé en paramètre.
Voici un exemple d'une classe C# classique avec un événement :
***************************
using System;
using System.IO;
using System.Runtime.InteropServices;
namespace ClassLibrary1
{
public class Class1
{
public Class1()
{
}
public event EventHandler UnEvenement;
public void AppelEvenement()
{
if (this.UnEvenement != null)
this.UnEvenement(this, EventArgs.Empty);
}
public void BrancherEvenement(IntPtr p)
{
Delegate d;
d = Marshal.GetDelegateForFunctionPointer(p,
typeof(EventHandler));
this.UnEvenement += (EventHandler)d;
}
}
}
***************************
Tu remarqueras une méthode BrancherEvenement() qui prend en paramètre
un pointeur.
En W-Langage il suffit de faire alors :
***************************
c est une Class1 dynamique
o est un "Object" dynamique
c = allouer un Class1()
c:AjouteEvenement(&MaProcedure)
c:BrancherEvenement()
***************************
En considérant qu'il existe une fonction de ce style :
***************************
PROCEDURE MaProcedure(sender, e)
Info("CA MAAAAAAAAAARCHE !!!")
***************************
En fait le code de BrancherEvenement() peut être réaliser en W-Langage,
mais Windev génére (en Windev 9) une erreur si tu fais :
Type::GetType("System.EventHandler")
Si tu ne peux pas modifier le code source des assembly .NET (car
t'utilises des assembly déjà compilé, ou on ne veut pas que tu modifies
les sources) dans ce cas, passe par un assembly intermédiaire qui
contiendra une classe qui permettra le branchement de tout ce petit
monde...
Autre chose, ne me crie pas dessus si tu ne trouves pas la fonction
GetDelegateForFunctionPointer(), elle est nouvelle dans le Framework
2.0
Cordialement
--
Gilles TOURREAU
Responsable informatique
gilles.tourreau@pos.fr
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Merci beaucoup pour ces informations Gilles (vous avez l'air très
actif sur ce forum).
En fait, je me demandais, n'est-il pas possible d'appeler la méthode
GetDelegateForFunctionPointer() directement depuis windev, par exemple
********************
gClObjDotNet:add_onConnect(TrucBidule::GetDelegateForFunctionPointer(&MaFonction))
//OnConnect nous dit quand on est connecté, le plus simple à utiliser
dans l'assembly vu que le délégué n'attend pas de paramètre
PROCEDURE MaFonction()
Info("CA MAAAAAAAAAARCHE !!!") //(©Gilles Tourreau)
********************
C'est juste une idée (mais par quoi dois-je remplacer TrucBidule dans
mon exemple ?? xD)
Sinon, pour infos, l'assembly que j'utilise est écrit en .Net 2.0 et
je ne peux pas toucher au code.
merci encore :)
Comme je l'ai dis (et peut-être mal expliqué) :
Il est possible d'appeler GetDelegateForFunctionPointer() depuis
Windev.
La méthode GetDelegateForFunctionPointer() prend 2 paramètres (CF. Le
SDK de Billou sur le .NET Framework) :
Un IntPtr qui représente le pointeur de votre fonction.
Un Type qui doit être le type de votre évenement (hérité de
EventHandler).
Pour le premier : pas de problème
Pour le second : Il faut obtenir le type de votre évenement.
**************************
RAPPEL sur ce qu'est un type d'évenement :
Quand un évenement est défini comme celà en C# :
public event EventHandler UnEvenement;
L'évenement "UnEvenement" est de type "EventHandler".
**************************
La seul manière d'obtenir le type d'une classe dans le .NET est de
faire un "typeof(LaClasse)". Le problème est que "typeof" n'existe pas
en Windev, il existe cependant une fonction .NET qui permettent de
faire cela : Type.GetType("Le.Type.A.Retourner")
Le code W-Langage pour celà serait :
Marshal::GetDelegateForFunctionPointer(&MaFonction,
Type::GetType("System.EventHandler"))
Tu constateras que ce code provoque une erreur de compilation au niveau
de Windev te disant que GetType n'est pas globale alors que chez Billou
elle est définie comme statique...? Pourquoi ? Je n'en sais rien !
Certainement un bug de Windev...
C'est pour cela que pour remedier à ce problème :
- Soit tu modifies un peu ton code .NET pour faire des fonctions de
branchement comme je t'ai montré en exemple.
- Soit, si tu ne peux pas, tu créer un assembly .NET qui permet de
faire ces branchements.
Cordialement
--
Gilles TOURREAU
Responsable informatique
gilles.tourreau@pos.fr
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Ok, j'en enfin pigé le truc. En fait, j'étais en train d'essayer de
faire ce que tu me disais pendant que tu écrivais la réponse, et j'ai
pu constater le problème de la fonction GetType (et c'est fort
dérangeant, car ça limite pas mal l'intégration d'assemblies dans
Windev).
J'ai essayé d'instancier un objet Type pour voir, mais ça a
lamentablement fait planter Windev. Je pense que PCSoft à encore un
peu de chemin à faire dans ce sens là.
Il va donc être nécessaire que je passe par un assembly perso. Mais,
dans ce cas, je vais donc devoir gérer tous les appels possibles vers
l'assembly, non ? (a moins que l'on puisse appeler des fonctions d'une
même instance d'un assembly depuis 2 sources différentes, si j'ose
m'exprimer ainsi).
En gros, est-ce que je peux avoir mon appli qui fasse des appels
directs vers l'assembly en même temps que mon truc intermédiare fasse
ses branchements, ou faut-il que je crée tous les points d'entrée
nécessaires dans mon assembly intermédiaire (ce qui économiserai pas
mal de temps ^^)
Merci encore pour ces réponses pertinentes :)
Gilles TOURREAU wrote:Peij a exposé le 16/08/2006 :Gilles TOURREAU wrote:Peij a formulé la demande :wrote:Bonjour à tous.
Je dois actuellement développer une appli qui utilise un assembly qui
gère un système de téléphonie, avec windev 10. Je tiens à
souligner que je débute dans ce domaine (j'ai fait un peu de C#, mais
pas trop ^^)
L'import de l'assembly fait, j'arrive à exécuter des fonctions sans
problème. Le souci se situe dans l'autre sens, communication de
l'assembly vers mon appli windev.
Lors de la détection d'un appel entrant, il faut pouvoir récupérer
l'évènement.. En C#, ce ne serait pas trop un problème, il suffit de
créer la procédure qui va être appelée.. mais avec Windev c'est une
autre histoire, et je n'ai trouvé aucune info à ce sujet, que ce soit
dans l'aide ou les exemples.
J'ai une procédure qui a été importée avec l'assembly, appelée
add_OnCallEvent({callEvent}), et je suppose que c'est de ce côté que
je dois jeter un oeil. Seulement, je ne sais pas du tout ce que je dois
passer en paramètre (j'ai essayé de passer un pointeur sur fonction,
mais ça marche pas).
Quelqu'un sait-il comment je dois gérer cela ??
Bon, j'ai un peu avancé sur le sujet.
En me plongeant un peu plus dans un exemple en c#, j'ai compris que le
paramètre à passer est en fait un délégué (mot clef delegate en
C#)
En gros on écrit une fonction qui sera exécutée lors de
l'évènement (principe du callback)
Seulement, je ne sais pas du tout comment gérer ça avec windev. J'ai
fait quelques recherches sur le net mais je ne trouve aucune réponse.
Besoin d'aide, merci à vous :)
Il faut savoir que les fonction de Windev sont des pointeurs de
fonction "classique du langage C". C'est d'ailleurs pour ca que l'on
peut utiliser direcement les pointeurs de fonction dans nos chères
méthodes API de Windows du style :
API("MéthodeAPI", "LaDll.dll", ..., &MaFonction, ...)
Windev, ne fait pas automatiquement la conversion entre se pointeur et
l'association à une classe EventHandler.
Il existe une fonction en .NET qui se trouve dans l'assembly de
l'intéropérabilité qui permet de faire cela :
Classe : System.Runtime.Interop.Marshal
Méthode : GetDelegateForFunctionPointer()
Le seul hic, c'est que je n'arrive pas à appeler la méthode
Type.GetType(string) de .NET via Windev.
Ce que j'ai fais alors, c'est ma classe .NET qui fera automatiquement
le branchement vers un pointeur de fonction passé en paramètre.
Voici un exemple d'une classe C# classique avec un événement :
***************************
using System;
using System.IO;
using System.Runtime.InteropServices;
namespace ClassLibrary1
{
public class Class1
{
public Class1()
{
}
public event EventHandler UnEvenement;
public void AppelEvenement()
{
if (this.UnEvenement != null)
this.UnEvenement(this, EventArgs.Empty);
}
public void BrancherEvenement(IntPtr p)
{
Delegate d;
d = Marshal.GetDelegateForFunctionPointer(p,
typeof(EventHandler));
this.UnEvenement += (EventHandler)d;
}
}
}
***************************
Tu remarqueras une méthode BrancherEvenement() qui prend en paramètre
un pointeur.
En W-Langage il suffit de faire alors :
***************************
c est une Class1 dynamique
o est un "Object" dynamique
c = allouer un Class1()
c:AjouteEvenement(&MaProcedure)
c:BrancherEvenement()
***************************
En considérant qu'il existe une fonction de ce style :
***************************
PROCEDURE MaProcedure(sender, e)
Info("CA MAAAAAAAAAARCHE !!!")
***************************
En fait le code de BrancherEvenement() peut être réaliser en W-Langage,
mais Windev génére (en Windev 9) une erreur si tu fais :
Type::GetType("System.EventHandler")
Si tu ne peux pas modifier le code source des assembly .NET (car
t'utilises des assembly déjà compilé, ou on ne veut pas que tu modifies
les sources) dans ce cas, passe par un assembly intermédiaire qui
contiendra une classe qui permettra le branchement de tout ce petit
monde...
Autre chose, ne me crie pas dessus si tu ne trouves pas la fonction
GetDelegateForFunctionPointer(), elle est nouvelle dans le Framework
2.0
Cordialement
--
Gilles TOURREAU
Responsable informatique
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Merci beaucoup pour ces informations Gilles (vous avez l'air très
actif sur ce forum).
En fait, je me demandais, n'est-il pas possible d'appeler la méthode
GetDelegateForFunctionPointer() directement depuis windev, par exemple
********************
gClObjDotNet:add_onConnect(TrucBidule::GetDelegateForFunctionPointer(&MaFonction))
//OnConnect nous dit quand on est connecté, le plus simple à utiliser
dans l'assembly vu que le délégué n'attend pas de paramètre
PROCEDURE MaFonction()
Info("CA MAAAAAAAAAARCHE !!!") //(©Gilles Tourreau)
********************
C'est juste une idée (mais par quoi dois-je remplacer TrucBidule dans
mon exemple ?? xD)
Sinon, pour infos, l'assembly que j'utilise est écrit en .Net 2.0 et
je ne peux pas toucher au code.
merci encore :)
Comme je l'ai dis (et peut-être mal expliqué) :
Il est possible d'appeler GetDelegateForFunctionPointer() depuis
Windev.
La méthode GetDelegateForFunctionPointer() prend 2 paramètres (CF. Le
SDK de Billou sur le .NET Framework) :
Un IntPtr qui représente le pointeur de votre fonction.
Un Type qui doit être le type de votre évenement (hérité de
EventHandler).
Pour le premier : pas de problème
Pour le second : Il faut obtenir le type de votre évenement.
**************************
RAPPEL sur ce qu'est un type d'évenement :
Quand un évenement est défini comme celà en C# :
public event EventHandler UnEvenement;
L'évenement "UnEvenement" est de type "EventHandler".
**************************
La seul manière d'obtenir le type d'une classe dans le .NET est de
faire un "typeof(LaClasse)". Le problème est que "typeof" n'existe pas
en Windev, il existe cependant une fonction .NET qui permettent de
faire cela : Type.GetType("Le.Type.A.Retourner")
Le code W-Langage pour celà serait :
Marshal::GetDelegateForFunctionPointer(&MaFonction,
Type::GetType("System.EventHandler"))
Tu constateras que ce code provoque une erreur de compilation au niveau
de Windev te disant que GetType n'est pas globale alors que chez Billou
elle est définie comme statique...? Pourquoi ? Je n'en sais rien !
Certainement un bug de Windev...
C'est pour cela que pour remedier à ce problème :
- Soit tu modifies un peu ton code .NET pour faire des fonctions de
branchement comme je t'ai montré en exemple.
- Soit, si tu ne peux pas, tu créer un assembly .NET qui permet de
faire ces branchements.
Cordialement
--
Gilles TOURREAU
Responsable informatique
Société P.O.S
Spécialiste en motoculture depuis + de 30 ans !
http://www.pos.fr
Ok, j'en enfin pigé le truc. En fait, j'étais en train d'essayer de
faire ce que tu me disais pendant que tu écrivais la réponse, et j'ai
pu constater le problème de la fonction GetType (et c'est fort
dérangeant, car ça limite pas mal l'intégration d'assemblies dans
Windev).
J'ai essayé d'instancier un objet Type pour voir, mais ça a
lamentablement fait planter Windev. Je pense que PCSoft à encore un
peu de chemin à faire dans ce sens là.
Il va donc être nécessaire que je passe par un assembly perso. Mais,
dans ce cas, je vais donc devoir gérer tous les appels possibles vers
l'assembly, non ? (a moins que l'on puisse appeler des fonctions d'une
même instance d'un assembly depuis 2 sources différentes, si j'ose
m'exprimer ainsi).
En gros, est-ce que je peux avoir mon appli qui fasse des appels
directs vers l'assembly en même temps que mon truc intermédiare fasse
ses branchements, ou faut-il que je crée tous les points d'entrée
nécessaires dans mon assembly intermédiaire (ce qui économiserai pas
mal de temps ^^)
Merci encore pour ces réponses pertinentes :)