IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

WinDev Discussion :

Problème appel API sur une dll


Sujet :

WinDev

  1. #21
    Expert confirmé
    Avatar de Voroltinquo
    Homme Profil pro
    Chef de projet en SSII
    Inscrit en
    Juin 2017
    Messages
    2 808
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Chef de projet en SSII

    Informations forums :
    Inscription : Juin 2017
    Messages : 2 808
    Points : 5 267
    Points
    5 267
    Billets dans le blog
    1
    Par défaut
    Reprenons la doc :
    signRegisterDataCallBack attend un pointeur sur une fonction de type PACKDATAPROC définit comme suit :
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    typedef int (CALLBACK * PACKDATAPROC)(PDATAPACKET pktObj)
    La procédure de Callback (de type PACKDATAPROC) attend donc un pointeur sur un DATAPACKET (un PDATAPACKET) pour un passage de paramètre par adresse (i.e. une modification dans la procédure de la variable passée en paramètre se répercutera dans la fonction appelante.) C'est le mode de fonctionnement par défaut du WL. On peut donc s'abstraire du passage du pointeur, (dans le pire des cas, on pourra toujours utiliser Transfert)
    Exemple :
    Passage par adresse
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    PROCEDURE TestAdresse(nValeur est entier)
    nValeur++
    Passage par valeur
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    PROCEDURE TestValeur(LOCAL nValeur est entier)
    nValeur++
    C'est le même code (sauf pour le prototype,) pourtant :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    nTest est entier
     
    nTest=4
    TestAdresse(nTest)
    Trace(nTest) //Affiche 5
     
    nTest=4
    TestLocal(nTest)
    Trace(nTest) //Affiche 4
    En résumé, ta fonction de CallBack (celle dont le pointeur sera appelé dans signRegisterDataCallBack pour être éxécutée, un paramètre de type STTagDATAPACK, défini dans le post #2)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    PROCÉDURE CallBack(stMonDATAPACKET est STTagDATAPACKET)
     
    //Traitement sur stMonDATATPACKET
    Utilisation théorique
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    stUnDATAPACKET est STTagDATAPACKET
     
    CallBack(stUnDATAPACKET) //Les modifications dans la fonction seront répercutées dans la variable
    L'utilisation est théorique dans la mesure où nous somme en face d'une fonction appelée via la fonction WL API.
    Il va donc falloir se débrouiller pour passer stUnDATAPACKET en paramètre.

    J'ai des doutes quant à la syntaxe
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    API(MadllPad,"signRegisterDataCallBack",&lpPackDataProc,stUnDATAPACKET)
    Une solution doit être une compilation dynamique de la fonction CallBack

    Un truc du style:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
     
    stUnDATAPACKET est STTagDATAPACKET
    saCode est chaine
    procCallBack est procédure
    ptrCallBack est entier système
    nResAPI est entier
     
    ptrCallBack=&procCallBack //On récupère la valeur du pointeur qui sera passé à la fonction API)
    saCode=[
    PROCÉDURE CallBack(stMonDATAPACKET est STTagDATAPACKET)
     
    //Traitement sur stMonDATATPACKET
    ]
    procCallBack=Compile(saCode)
    procCallBack(stUnDATAPACKET)
     
    nResAPI=API(MadllPad,"signRegisterDataCallBack",ptrCallBack)
    Je te renvoie vers une explication concernant les pointeurs de fonction pour effiner le code ci dessus
    Il y a peut-être plus simple, mais ça tourne.
    Quand tout a échoué utilisez l'option RTFM

  2. #22
    Membre du Club
    Inscrit en
    Septembre 2007
    Messages
    86
    Détails du profil
    Informations forums :
    Inscription : Septembre 2007
    Messages : 86
    Points : 45
    Points
    45
    Par défaut
    merci de toute ces explications et le temps passé Voroltinquo

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    saCode=[
    PROCÉDURE CallBack(stMonDATAPACKET est STTagDATAPACKET)
     
    //Traitement sur stMonDATATPACKET
    ]
    procCallBack=Compile(saCode)
    çà fait une erreur de compilation :
    Erreur de compilation
    Le type 'STTagDATAPACKET' est inconnu. (1,40)

    le type existe bien sûr , j'ai fait une procédure normal pour essayer
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    PROCÉDURE CallBack(stMonDATAPACKET est STTagDATAPACKET)
     
    //Traitement sur stMonDATATPACKET
    çà plante toujours juste quant tu pose le stylo sur le pad ....
    çà fait aucune erreur , juste un arrêt complet du debug comme une fermeture normal ....

  3. #23
    Expert confirmé
    Avatar de Voroltinquo
    Homme Profil pro
    Chef de projet en SSII
    Inscrit en
    Juin 2017
    Messages
    2 808
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Chef de projet en SSII

    Informations forums :
    Inscription : Juin 2017
    Messages : 2 808
    Points : 5 267
    Points
    5 267
    Billets dans le blog
    1
    Par défaut
    Dans ce cas, il faut déjà tenter de ne pas typer le paramètre. Le WL est très permissif donc ça passe.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     
    ...
    saCode=[
    PROCÉDURE CallBack(stMonDATAPACKET)
     
    //Traitement sur stMonDATATPACKET
    ]
    ....
    Après, il nous reste une possibilité bien bovine.
    Déclarer une variable globale et la traiter dans CallBack comme si l'on traitait le paramètre
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
     
    GLOBAL
         gstUnDATAPACKET est STTagDATAPACKET
    FIN
    saCode est chaine
    procCallBack est procédure
    ptrCallBack est entier système
    nResAPI est entier
     
    procCallBack=CallBack
    ptrCallBack=&procCallBack //On récupère la valeur du pointeur qui sera passé à la fonction API)
     
     
     
    nResAPI=API(MadllPad,"signRegisterDataCallBack",ptrCallBack)
    Avec
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    PROCEDURE CallBack(prtDummy est entier système=1) //On doit avoir un paramètre, comme on ne peut pas l'affecter et qu'il ne sera pas utilisé, on lui donne une valeur par défaut
     
    //Traitement de gstUnDataPacket
    Il y a peut-être plus simple, mais ça tourne.
    Quand tout a échoué utilisez l'option RTFM

  4. #24
    Membre du Club
    Inscrit en
    Septembre 2007
    Messages
    86
    Détails du profil
    Informations forums :
    Inscription : Septembre 2007
    Messages : 86
    Points : 45
    Points
    45
    Par défaut
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
     
    stUnDATAPACKET est STTagDATAPACKET
    saCode			est chaîne
    procCallBack	est procédure
    ptrCallBack		est entier système
    nResAPI			est entier
     
    MadllPad		est une chaîne			= "libSign.dll"
    SI ChargeDLL(fRepExe()+"\"+MadllPad)=0 ALORS Erreur("Fichier dll pour le pad non présent");RETOUR
    API(MadllPad,"signOpenDevice") 
     
    ptrCallBack	= &procCallBack //On récupère la valeur du pointeur qui sera passé à la fonction API)
    saCode		= [
    PROCÉDURE CallBack(stMonDATAPACKET)
     
    //Traitement sur stMonDATATPACKET
    ]
    procCallBack=Compile(saCode)
    procCallBack(stUnDATAPACKET)
     
    nResAPI=API(MadllPad,"signRegisterDataCallBack",ptrCallBack)
    çà plante direct dès que tu pose le stylo sur le pad .... un bon crash , aucune fenêtre d'erreur ...

  5. #25
    Membre confirmé

    Homme Profil pro
    Inscrit en
    Juillet 2011
    Messages
    371
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Juillet 2011
    Messages : 371
    Points : 627
    Points
    627
    Billets dans le blog
    1
    Par défaut
    Salut
    Petites questions bête :
    C'est quoi comme processeur sur la tablette ?
    Arm, x86?
    C'est quoi comme système d'exploitation ?
    J'ai vu qu'elles sont compatibles avec beaucoup de système.
    Et enfin tu travailles avec windev ou windev mobile ?

  6. #26
    Expert confirmé
    Avatar de Voroltinquo
    Homme Profil pro
    Chef de projet en SSII
    Inscrit en
    Juin 2017
    Messages
    2 808
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Chef de projet en SSII

    Informations forums :
    Inscription : Juin 2017
    Messages : 2 808
    Points : 5 267
    Points
    5 267
    Billets dans le blog
    1
    Par défaut
    Dans un premier temps, s'il n'y a aucune fenêtre d'erreur, c'est qu'à priori, tu ne gères pas tes erreurs.
    Dans un deuxième temps, pour en revenir à STTagDataPacket qui n'est pas reconnu dans la procédure dynamique, après mûres réflexions c'est logique.
    La procédure dynamique ne "voit" pas ce qui ce passe à l'extérieur (dans le code classique), il va donc falloir redéclarer une structure similaire à STTagDataPacket (ainsi que les énumérations) à l'intérieur du code.
    Comment dans ce cas récupérer le contenu de notre STTagDatapacket utilisé dans la procédure dynamique, au niveau de la procédure principale ?
    Une solution serait peut être de transférer les données de l'une vers l'autre via leur adresse (entier système est un type "classique", il sera donc reconnu dans la procédure dynamique) On commence à faire dans le tordu.
    En gras les modifications apportées
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
     
    stUnDATAPACKET est STTagDATAPACKET dynamique //La mémoire est allouée
    ptrDataPacket est entier système //Pointeur sur stUnDATAPACKET
    saCode est chaine
    procCallBack est procédure
    ptrCallBack est entier système
    nResAPI est entier
    
    ptrDATAPACKET=&stUnDATAPACKET
    ptrCallBack=&procCallBack //On récupère la valeur du pointeur qui sera passé à la fonction API)
    saCode=[
    PROCÉDURE CallBack(ptrMonPointeur est entier système)
    //Déclaration de la struture et des enum
    
    stDATAPACKETInterne est STTagDATAPACKET dynamique
    //Traitement sur stDATAPACKETInterne
    
    Transfert(ptrMonPointeur,&stDATAPACKETInterne,Taille(stDATAPACKETInterne))
    ]
    procCallBack=Compile(saCode)
    procCallBack(ptrDataPacket)
     
    nResAPI=API(MadllPad,"signRegisterDataCallBack",ptrCallBack)
    Il y a peut-être plus simple, mais ça tourne.
    Quand tout a échoué utilisez l'option RTFM

  7. #27
    Membre du Club
    Inscrit en
    Septembre 2007
    Messages
    86
    Détails du profil
    Informations forums :
    Inscription : Septembre 2007
    Messages : 86
    Points : 45
    Points
    45
    Par défaut
    Bonjour,
    Pour la gestion des erreurs , j'ai tous essayé , aucun moyen de la faire apparaître pour le crash , on dirait qu'il écrit dans une adresse mémoire qui le fait planter
    la compilation de code à des erreurs un peu partout , j'ai évité les énumérations qu'il ne comprends pas et 'taille(...)' dans 'compile' mais l'adressage aussi ne fonctionne pas

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
     
    stUnDATAPACKET	est STTagDATAPACKET dynamique	//La mémoire est allouée
    ptrDataPacket	est entier système				//Pointeur sur stUnDATAPACKET
    saCode			est chaîne
    procCallBack	est procédure
    ptrCallBack		est entier système
    nResAPI			est entier
     
    ptrDataPacket	= &stUnDATAPACKET
    ptrCallBack		= &procCallBack //On récupère la valeur du pointeur qui sera passé à la fonction API)
    saCode			= [
    PROCÉDURE CallBack(ptrMonPointeur est entier système)
     
    STTagDATAPACKET est une Structure
    	EventType			est un entier sur 4 octet																		
    	physical_key		est un entier sans signe sur 2 octet										
    	virtual_key			est un entier sans signe sur 2 octet									
    	KeyStatus			est un entier sur 4 octet																	
    	PenStatus			est un entier sur 4 octet																	
    	x					est un entier sans signe sur 2 octet									
    	y					est un entier sans signe sur 2 octet									
    	pressure			est un entier sans signe sur 2 octet								
    	wheel_direction		est un entier sur 2 octet											
    	button				est un entier sans signe sur 2 octet							
    FIN
     
    stDATAPACKETInterne est un STTagDATAPACKET dynamique
    //Traitement sur stDATAPACKETInterne
     
    Transfert(ptrMonPointeur,&stDATAPACKETInterne,26)
    ]
     
    procCallBack=Compile(saCode)
    procCallBack(ptrDataPacket)
     
    nResAPI=API(MadllPad,"signRegisterDataCallBack",ptrCallBack)
    une belle erreur
    Vous avez appelé la fonction 'Transfert'.
    L'adresse source fournie (0x00000000 sur 26 octets) est invalide. Elle ne représente pas une adresse mémoire valide en lecture.

  8. #28
    Membre du Club
    Inscrit en
    Septembre 2007
    Messages
    86
    Détails du profil
    Informations forums :
    Inscription : Septembre 2007
    Messages : 86
    Points : 45
    Points
    45
    Par défaut
    Bonjour,
    Ce qui est étrange , c'est qu'il plante sans crier gare ...
    avec un pointeur sur une chaine de 500 octets , il ne devrait pas planter c'est ce que cela fait sur les autres fonction sans callback , il devrait écrire dessus , ou alors il est sensible est il faut avoir exactement ce qu'il veux , j'ai vérifié en VC :

    Les énumérations , c'est bien 4 octets et les autres variable c'est 2 octets
    quand on fait appelle à la fonction callback de la dll , çà plante pas , c'est quand on touche au pad , c'est à ce moment la que la dll doit écrire sur le pointeur et paf , windev crash ....
    faudrait écrire un code simple en C# et l'importer sur windev , mais il faut maîtriser les dll en c# dans une seul procédure , çà va être la même galere ...

  9. #29
    Expert confirmé
    Avatar de Voroltinquo
    Homme Profil pro
    Chef de projet en SSII
    Inscrit en
    Juin 2017
    Messages
    2 808
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Chef de projet en SSII

    Informations forums :
    Inscription : Juin 2017
    Messages : 2 808
    Points : 5 267
    Points
    5 267
    Billets dans le blog
    1
    Par défaut
    Il n'aime pas trop le transfert pour la bonne et simple raison que j'ai oublié d'allouer mes STTagDataPack dynamique.
    Par ailleurs, j'ai aussi oublié le transfert initial de stMonDataPacket (via son pointeur) vers stDataPacketInterne (il faut bien qu'elle récupère les données de l'extérieur)

    Ce qui nous donne la procédure de CallBack suivante :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
     
    PROCÉDURE CallBack(ptrMonPointeur est entier système)
    //Déclaration de la structure de travail
    STTagDATAPACKETInterne est une Structure
    	m_eVenttype			est entier	//Pour la place mémoire
    	m_nPhysical_key		est entier sur 2
    	m_nVirtual_key		est entier sur 2
    	m_eKeystatus		est entier	//Pour la place mémoire
    	m_ePenstatus		est entier	//Pour la place mémoire
    	x					est entier sur 2
    	y					est entier sur 2
    	m_nPressure			est entier sur 2
    	m_nWheel_direction	est entier sur 2
    	m_nButton			est entier sur 2
    FIN
     
     
     
    pstDataPacketInterne est STTagDATAPACKETInterne dynamique
    pstDataPacketInterne=allouer un STTagDATAPACKETinterne
     
    Transfert(&pstDataPacketInterne,ptrMonPointeur,26)
    pstDataPacketInterne:x++
    pstDataPacketInterne:y++
    Transfert(ptrMonPointeur,&pstDataPacketInterne,26)
     
    libérer pstDataPacketInterne //26 octets, c'est 26 octets. Après on se plaint des fuites mémoire
    appelée via
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    ...
    stUnDataPacket=allouer un STTagDATAPACKET
    nRes=API(MadllPad,"signRegisterDataCallBack",ptrCallBack)
    Il y a peut-être plus simple, mais ça tourne.
    Quand tout a échoué utilisez l'option RTFM

  10. #30
    Membre du Club
    Inscrit en
    Septembre 2007
    Messages
    86
    Détails du profil
    Informations forums :
    Inscription : Septembre 2007
    Messages : 86
    Points : 45
    Points
    45
    Par défaut
    pstDataPacketInterne=allouer un STTagDATAPACKETInterne fait une erreur de compilation on dirait , c'est curieux puisque l'instruction d'avant ne le fait pas
    Erreur de compilation
    Le type 'STTagDATAPACKETinterne' est inconnu. (19,22)

    si on l'enlève , on a toujours ceci comme erreur
    Vous avez appelé la fonction 'Transfert'.
    L'adresse source fournie (0x00000000 sur 26 octets) est invalide. Elle ne représente pas une adresse mémoire valide en lecture.
    c'est le problème des variables 'dynamique' ... elles n'ont pas de pointeur à la création

    si on enlève la compilation , et les 'dynamique' cela fonctionne mais crash comme dab

    la compilation dynamique c'est pas top ... lol

  11. #31
    Expert confirmé
    Avatar de Voroltinquo
    Homme Profil pro
    Chef de projet en SSII
    Inscrit en
    Juin 2017
    Messages
    2 808
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Chef de projet en SSII

    Informations forums :
    Inscription : Juin 2017
    Messages : 2 808
    Points : 5 267
    Points
    5 267
    Billets dans le blog
    1
    Par défaut
    Sortons la tête du guidon, signRegisterDataCallBack (et ses 2 sœurs) est faite pour référencer une fonction de Callback, pas pour l'exécuter.
    Par ailleurs, en cas de réussite elle renvoie le Handle de la fonction (qui est aussi l'adresse de cette fonction) qui servira de paramètre aux fonction signUnregisterXXX.
    Pour une meilleure réutilisation des fonction de la DLL, il est intéressant de créer un collection de procédure ou une classe qui va regrouper tout les appels à la DLL
    Après l'étude du .h on en arrive au résultat suivant (à placer dans le code d'initialisation de la collection ou avant la déclaration de la classe (CXPen est classe))
    Déclarations
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
     
    //Les déclarations suivantes sont la traduction en WL du fichier LibSign.h
    //Les commentaires précédent un déclaration représentent le code C
     
    												/****************/
    												/* ENUMERATIONS */
    												/****************/
     
    //enum EventType
    //{
    //EventType_Pen		= 1,
    //EventType_Key		= 2,
    //EventType_Eraser	= 3,
    //EventType_Wheel		= 4,
    //EventType_ALL		= 0xfe
    //};
    EEventType est une Enumération
    {
    	EventType_Pen		= 1
    	EventType_Key		= 2
    	EventType_Eraser	= 3
    	EventType_Wheel		= 4
    	EventType_ALL		= 0xfe
    }
     
    //enum  PenStatus
    //{
    //PenStatus_Hover,				//悬浮
    //PenStatus_Down,					//按下
    //PenStatus_Move,					//移动
    //PenStatus_Up,					//抬起
    //PenStatus_Leave					//离开
    //};
    EPenStatus est Enumération
    {
    	PenStatus_Hover
    	PenStatus_Down
    	PenStatus_Move
    	PenStatus_Up
    	PenStatus_Leave
    };
     
    //enum KeyStatus
    //{
    //KeyStatus_Up,					//按键抬起
    //KeyStatus_Down					//按键按下
    //};
    EKeyStatus est une Enumération
    {
    	KeyStatus_Up
    	KeyStatus_Down
    }
     
    //enum ButtonStatus
    //{
    //ButtonStatus_Up,				//笔上按键抬起
    //ButtonStatus_Down				//笔上按键按下
    //};
    EButtonStatus est Enumération
    {
    	ButtonStatus_Up
    	ButtonStatus_Down
    }
     
    //enum  TouchStatus
    //{
    //TouchStatus_Up,
    //TouchStatus_Down,
    //TouchStatus_Move
    //};
    ETouchStatus est Enumération
    {
    	TouchStatus_Up
    	TouchStatus_Down
    	TouchStatus_Move
    }
     
    //enum  DeviceStatus
    //{
    //DeviceStatus_Disconnected=0,
    //DeviceStatus_Connected,
    //DeviceStatus_Sleep,
    //DeviceStatus_Awake
    //};
    EDeviceStatus est Enumération
    {
    	DeviceStatus_Disconnected=0
    	DeviceStatus_Connected
    	DeviceStatus_Sleep
    	DeviceStatus_Awake
    }
     
    //enum DeviceRunMode
    //{
    //DeviceRunMode_Mouse		= 1,						//系统鼠标
    //DeviceRunMode_Pen		= 2,							//笔数据
    //DeviceRunMode_MousePen	= 3,						//系统鼠标+笔数据
    //DeviceRunMode_StdPen	= 4						//标准数位笔
    //};
    EDeviceRunMode est Enumération
    {
    	DeviceRunMode_Mouse		= 1
    	DeviceRunMode_Pen		= 2
    	DeviceRunMode_MousePen	= 3
    	DeviceRunMode_StdPen	= 4
    }
     
    													/**************/
    													/* CONSTANTES */
    													/**************/
    //Constantes d'erreur
    CONSTANTE
    	ERR_OK					= 0
    	ERR_DEVICE_NOTFOUND		=-1
    	ERR_DEVICE_OPENFAIL		=-2
    	ERR_DEVICE_NOTCONNECTED	=-3
    	ERR_INVALIDPARAM		=-101
    	ERR_NOSUPPORTED			=-102
    FIN
     
    												/***********************/
    												/* STRUCTURES ET ALIAS */
    												/***********************/
    //Convention de préfixage :
    //Le préfixage rend le code plus lisible lors du débogage, ou pour un lecteur qui n'est pas dans le contexte.
    //La plupart des préfixes utilisés correspondent aux préfixes de la charte standard du WL.
    //J'ai toutefois modifié cette charte afin d'avoir des préfixes correspondant à mes besoins.
    //En voici un extrait :
    //
    // ST définition de structure
    // st structure
    // pst structure dynamique
    // 
    // oc entier sans signe sur 1
    // M entier sans signe sur 2 (Mot)
    // n2 entier sur 2
    // DM entier sans signe sur 4 (Double mot)
    // n entier (sur 4)
    // QM entier sans signe sur 8 (Quadruple mot)
    // pk entier sur 8
    // ptr entier système
    // 
    // sa chaîne ANSI
    // su chaîne UNICODE
    //
    // e énumération
    //
    // proc Procédure
    //
    //Note : les variables globales sont préfixées par les préfixes ci dessous précédées par g (e.g. gn est entier et globale)
     
    //typedef		struct  tagAXIS
    //{
    //unsigned long	min;
    //unsigned long	max;
    //}AXIS, *PAXIS;
    STTagAXIS est Structure
    {
    //Alias : AXIS
    //Alias de pointeur sur un AXIS: PAXIS
    	m_DMMin est entier sans signe sur 4 octets
    	m_DMMax est entier sans signe sur 4 octets
    }
     
    //typedef struct tagTABLET_DEVICEINFO
    //{
    //AXIS				axisX;					//X轴范围
    //AXIS				axisY;					//Y轴范围
    //unsigned long		pressure;				//压感级别
    //char				vendor[32];				//厂商名称
    //char				product[32];			//产品名称
    //unsigned long		version;				//驱动接口版本
    //char				serialnum[32];			//设备序列号
    //}TABLET_DEVICEINFO, *PTABLET_DEVICEINFO;
    STTagTABLET_DEVICEINFO est Structure
    {
    //Alias : TABLET_DEVICEINFO
    //Alias de pointeur sur un TABLET_DEVICEINFO : PTABLET_DEVICEINFO
    	m_stAxisX est STTagAXIS
    	m_stAxisY est STTagAXIS
    	m_DMPressure est entier sans signe sur 4 octets
    	m_saVendor est chaîne sur 32
    	m_saProduct est chaîne sur 32
    	m_DMVersion est entier sans signe sur 4
    	m_saSerialNum est chaîne sur 32
    }
     
    //typedef struct  tagDATAPACKET
    //{
    //EventType			eventtype;				//事件类型	4
    //unsigned short		physical_key;			//物理按键	2
    //unsigned short		virtual_key;			//虚拟按键	2
    //KeyStatus			keystatus;				//按键状态	4
    //PenStatus			penstatus;				//笔尖状态	4
    //unsigned short		x;						//x坐标		2
    //unsigned short		y;						//y坐标		2
    //unsigned short		pressure;				//压感		2
    //short				wheel_direction;		//转盘旋转方向标识	2
    //unsigned short		button;					//笔身按键序列		2
    //}DATAPACKET, *PDATAPACKET;
    STTagDATAPACKET est Structure
    {
    //Alias : DATAPACKET
    //Alias de pointeur sur un DATAPACKET : PDATAPACKET
    	m_eEVenttype est EEventType
    	m_MPhysical_key est entier sans signe sur 2
    	m_MVirtual_key est entier sans signe sur 2
    	m_eKeystatus est EKeyStatus
    	m_ePenstatus est EPenStatus
    	m_Mx est entier sans signe sur 2
    	m_MMy est entier sans signe sur 2
    	m_MPressure est un entier sans signe sur 2
    	m_n2Wheel_direction est entier sur 2
    	m_MButton est entier sans signe sur 2
    }
     
    //typedef struct tagTOUCHDATA
    //{
    //TouchStatus			status[10];
    //unsigned int		x[10];
    //unsigned int		y[10];
    //
    //}TOUCHDATA, *PTOUCHDATA;
    STTagTOUCHDATA est Structure
    {
    //Alias : TOUCHDATA
    //Alias de pointeur sur un TOUCHDATA : PTOUCHDATA
    m_eStatus est ETouchStatus
    m_DMx est entier sans signe sur 4
    m_DMDMy est entier sans signe sur 4
    }
     
    //typedef struct  tagSTATUSPACKET
    //{
    //int			penAlive;
    //int			penBattery;
    //int			status;						//0  DISCONNECTED  1 CONNECTED  2 SLEEP  3 AWAKE
    //}STATUSPACKET, *PSTATUSPACKET;
    STTagSTATUSPACKET est Structure
    {
    	m_nPenAlive est entier
    	m_nPenBattery est entier
    	m_nStatus est entier						//0  DISCONNECTED  1 CONNECTED  2 SLEEP  3 AWAKE
    }
     
    							/******************************************************/
    							/* POINTEURS ET ALIASES SUR LES FONCTIONS DE CALLBACK */
    							/******************************************************/
     
    //PACKDATAPROC
    //typedef		int (_stdcall * PACKDATAPROC)(DATAPACKET pktObj);
    //On définit un pointeur sur une fonction utilisant un DATAPACKET
    //Déclaration de la fonction de type PACKDATAPROC
    //FONCTION CallBackDataPacket(stMonDataPacket est STTagDATAPACKET) :entier
     
    //DEVNOTIFYPROC
    //typedef		int (_stdcall * DEVNOTIFYPROC)(STATUSPACKET pktObj);
    //On définit un pointeur sur une fonction utilisant un STATUSPACKET
    //Déclaration de la fonction de type DEVNOTIFYPROC
    //FONCTION CallBackStatusPacket(stMonStatusPacket est STTagSTATUSPACKET) :entier
     
    //TOUCHPROC
    //typedef		int (_stdcall * TOUCHPROC)(TOUCHDATA td);
    //On définit un pointeur sur une fonction utilisant un TOUCHDATA
    //Déclaration de la fonction de type TOUCHPROC
    //FONCTION CallBackTouchData(stMonTouchData est STTagTOUCHDATA) : entier
     
    									/*********************************************************/
    									/* VARIABLES  ET STRUCTURES UTILISEES DANS LA COLLECTION */
    									/*********************************************************/
     
    //Afin de faciliter l'accès à la dll, on va l'inclure dans l'installation dans un répertoire dll du répertoire de l'appli								
    gsaCheminDll est chaîne	//Chemin de LibSign.dll
    gsaCheminDll=ChaîneConstruit("%1dll\LibSign.dll",ComplèteRep(fRepExe))
     
    gtaListeHandle est tableau associatif d'entiers système //Référence des Callbacks et de leur Handle
    Gestion des erreurs :
    Ce bloc a fait ces preuves depuis de nombreuses années. Il doit être placé à la fin de chaque fonction.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
     
    CAS ERREUR:
    TitreSuivant("Erreur. Ctrl+C pour copier")
    SELON ErreurInfo(errCode)
    	//Erreurs connues		
    	AUTRE CAS :
    		saErrMsg=ChaîneConstruit("%5%2Erreur n° %1%2%3%2Consultez votre fournisseur",...
    		ErreurInfo(errCode),CRLF,ErreurInfo(errMessage),dbgInfo(dbgElément))
    FIN
    SI PAS EnModeTestAutomatique ALORS
    	Erreur(saErrMsg)
    SINON
    	dbgErreur(saErrMsg)
    FIN
    RENVOYER Faux
     
    CAS EXCEPTION:
    TitreSuivant("Exception. Ctrl+C pour copier")
    SELON ExceptionInfo(errCode)
    	//Exceptions connues par leur N°
    	AUTRE CAS
    		saErrMsg=ChaîneConstruit("%5%2Exception n° %1%2%3%2Consultez votre fournisseur",...
    		ExceptionInfo(errCode),CRLF,ExceptionInfo(errMessage),dbgInfo(dbgElément))
    FIN
    SI PAS EnModeTestAutomatique ALORS
    	Erreur(saErrMsg)
    SINON
    	dbgErreur(saErrMsg)
    FIN
    RENVOYER Faux
    En cas d'utilisation de sous fonction, on lui préférera
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    CAS ERREUR:
    	ErreurPropage(dbgInfo(dbgElément))
    	RENVOYER Faux
    CAS EXCEPTION:
    	ExceptionPropage(dbgInfo(dbgElément))
    	RENVOYER Faux
    On obtient donc le résultat suivant :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
     
    // Résumé : Référence une procédure de Callback utilisant un DATAPACKET
    // Description des paramètres d'entrée/sortie de 'SignRegisterDataCallBack' :
    //
    // Syntaxe :
    //[ <Résultat> = ] SignRegisterDataCallBack (<saNomProcédure> est chaîne)
    //
    // Paramètres :
    //	saNomProcédure (chaîne ANSI) : Nom de la procédure à référencer
    // Valeur de retour :
    // 	entier système : Résultat de l'appel de la DLL. En cas de succès, l'appel renvoie le pointeur de la procédure.
    //
    //Exemple d'utilisation
    //
    //ptrRes est entier système
    //
    //ptrRes=SignRegisterDataCallBack("CB_DataPacket")
     
     
    FONCTION SignRegisterDataCallBack( saNomProcédure est chaîne ) : entier système
    ptrRes est entier système	//Résultat de l'appel à la DLL
    saErrMsg est chaîne	//Message renvoyé en cas d'erreur ou d'exception
    ptrPackDataProc est entier système //Pointeur sur la fonction passée en paramètre
    nHandleDLL est entier //Handle de la DLL utilisée
    procPackDataProc est procédure //Procédure que l'on cherche à référencer
     
    //Récupération du pointeur de la procédure
    procPackDataProc=saNomProcédure
    ptrPackDataProc=&procPackDataProc
     
    //Appel de la DLL
    nHandleDLL=ChargeDLL(gsaCheminDll)
    ptrRes=API(gsaCheminDll,"signRegisterDataCallBack",ptrPackDataProc)
    DéchargeDLL(nHandleDLL)
     
    //Interprétation du résultat
    GérerResultatDLL(ptrRes)
     
    gtaListeHandle[saNomProcédure]=ptrRes //On mémorise le résultat
     
    RENVOYER ptrRes
     
    CAS ERREUR:
    TitreSuivant("Erreur. Ctrl+C pour copier")
    SELON ErreurInfo(errCode)
    	//Erreurs connues		
    	AUTRE CAS :
    		saErrMsg=ChaîneConstruit("%5%2Erreur n° %1%2%3%2Consultez votre fournisseur",...
    		ErreurInfo(errCode),CRLF,ErreurInfo(errMessage),dbgInfo(dbgElément))
    FIN
    SI PAS EnModeTestAutomatique ALORS
    	Erreur(saErrMsg)
    SINON
    	dbgErreur(saErrMsg)
    FIN
    RENVOYER Faux
     
    CAS EXCEPTION:
    TitreSuivant("Exception. Ctrl+C pour copier")
    SELON ExceptionInfo(errCode)
    	//Exceptions connues par leur N°
    	AUTRE CAS
    		saErrMsg=ChaîneConstruit("%5%2Exception n° %1%2%3%2Consultez votre fournisseur",...
    		ExceptionInfo(errCode),CRLF,ExceptionInfo(errMessage),dbgInfo(dbgElément))
    FIN
    SI PAS EnModeTestAutomatique ALORS
    	Erreur(saErrMsg)
    SINON
    	dbgErreur(saErrMsg)
    FIN
    RENVOYER Faux
    Avec :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    // Résumé : Cette procédure permet d'éviter la perte de main du CAS ERREUR dans le cas où le code serait dans le code
    //			de ce CAS ERREUR (cf Gestion automatique des erreurs)
    // Description des paramètres d'entrée/sortie de 'GérerResultatDLL' :
    //
    // Syntaxe :
    //GérerResultatDLL (<ptrRes> est entier système)
    //
    // Paramètres :
    //	ptrRes (entier système) : Résultat de l'appel de la DLL via la fonction API
    // Valeur de retour :
    // 	Aucune
    //
    PROCÉDURE PRIVÉE GérerResultatDLL(ptrRes est entier système)
    SI ptrRes<0 ALORS
    	SELON ptrRes
    		CAS ERR_INVALIDPARAM
    			ErreurDéclenche(Abs(ptrRes),"Paramètre invalide")
    		CAS ERR_DEVICE_NOTCONNECTED
    			ErreurDéclenche(Abs(ptrRes),"Périphérique non connecté")
    		CAS ERR_DEVICE_NOTFOUND
    			ErreurDéclenche(Abs(ptrRes),"Périphérique non trouvé")
    		CAS ERR_DEVICE_OPENFAIL
    			ErreurDéclenche(Abs(ptrRes),"Echec de l'ouverture du périphérique")
    		CAS ERR_NOSUPPORTED
    			ErreurDéclenche(Abs(ptrRes),"Périphérique non supporté")
    		AUTRE CAS
    			ErreurDéclenche(11,ChaîneConstruit("Erreur inconnue : %1",ptrRes))
    	FIN
    	RETOUR
    FIN
    Afin de faciliter la récupération de handle, on peut même se créer la fonction suivante:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    // Résumé : Récupère le handle d'une fonction de callback
    // Description des paramètres d'entrée/sortie de 'GetCallBackHandle' :
    //
    // Syntaxe :
    //[ <Résultat> = ] GetCallBackHandle (<saNomCallBack> est chaîne)
    //
    // Paramètres :
    //	saNomCallBack (chaîne ANSI) : Nom de la fonction
    // Valeur de retour :
    // 	entier système : Handle de la fonction
     
    FONCTION GetCallBackHandle(saNomCallBack est chaîne) : entier système
    RENVOYER gtaListeHandle[saNomCallBack]
    En ce qui concerne le crash, le bloc de gestion des erreurs nous donnera certainement plus d'informations. Quoiqu'il en soit, le problème ne vient pas de l'appel à cette fonction qui ne se soucis pas de la présence ou pas du périphérique (elle ne renvoie pas d'rreur du type ERR_DEVICE_XXX)
    Il y a peut-être plus simple, mais ça tourne.
    Quand tout a échoué utilisez l'option RTFM

  12. #32
    Membre du Club
    Inscrit en
    Septembre 2007
    Messages
    86
    Détails du profil
    Informations forums :
    Inscription : Septembre 2007
    Messages : 86
    Points : 45
    Points
    45
    Par défaut
    Bonjour Voroltinquo ,
    Merci pour le temp que tu passe sur mon problème
    j'ai rajouté l'ouverture du pad dans le code

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    nHandleDLL		= ChargeDLL(gsaCheminDll)
    API(gsaCheminDll,"signOpenDevice")
    ptrRes			= API(gsaCheminDll,"signRegisterDataCallBack",ptrPackDataProc)
    DéchargeDLL(nHandleDLL)
    je lance en faisant
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    SignRegisterDataCallBack("CallBack")
    cela fait comme d'habitude , sa crach sans prévenir , le code d'erreur et d'exception ne sert à rien , il ne rentre pas dedans

    vu que çà crach le programme dès que je touche au Pad , même avec winhex , je ne peux pas voir ou la DLL écrit

    un windevien m'a dit que cela provenait du fait d'un bug windev avec les processeurs ARM du PAD !!???....

    j'ai la .net impression qu'il faudrait faire un 'connecteur' pour la fonction callback qui prends un type que windev ne gère pas ...

  13. #33
    Expert confirmé
    Avatar de Voroltinquo
    Homme Profil pro
    Chef de projet en SSII
    Inscrit en
    Juin 2017
    Messages
    2 808
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Chef de projet en SSII

    Informations forums :
    Inscription : Juin 2017
    Messages : 2 808
    Points : 5 267
    Points
    5 267
    Billets dans le blog
    1
    Par défaut
    1 Pour utiliser au mieux un librairie, il est préférable de créer une fonction différente par fonction de la DLL (même si cette fonction ne fait qu'une seule ligne)
    2 Qu'est ce que ça donne en pas à pas
    3 Popoy n'est pas sur que le processeur soit un ARM. Quand bien même, si on était en ARM, le programme planterait à l'appel de la fonction (pb d'adresse), or, chez moi, je n'ai pas de plantage.
    4 A priori ce sont des fonctions de déclaration de callback qui te posent problème. Le périphérique attend certainement que tu les utilises
    Il y a peut-être plus simple, mais ça tourne.
    Quand tout a échoué utilisez l'option RTFM

  14. #34
    Membre du Club
    Inscrit en
    Septembre 2007
    Messages
    86
    Détails du profil
    Informations forums :
    Inscription : Septembre 2007
    Messages : 86
    Points : 45
    Points
    45
    Par défaut
    Bonjour,
    pas à pas , cela fonctionne , cela attends tranquillement que tu utilise le pad en fait .
    Dès que tu pose le stylet sur le PAD , paf , le logiciel se ferme sans d'autre explication .
    on dirait qu'il écrit dans une mauvaise zone mémoire , en clair comme tu dis cela vient de la fonction de déclaration du callback , il prends une mauvaise adresse certainement .
    j'ai lu ceci qui date de 2006 : https://www.generation-nt.com/repons...e-2700041.html avec un problème different mais quasi similaire

  15. #35
    Expert confirmé
    Avatar de Voroltinquo
    Homme Profil pro
    Chef de projet en SSII
    Inscrit en
    Juin 2017
    Messages
    2 808
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Chef de projet en SSII

    Informations forums :
    Inscription : Juin 2017
    Messages : 2 808
    Points : 5 267
    Points
    5 267
    Billets dans le blog
    1
    Par défaut
    J'ai l'impression que les fonctions signRegisterXXX lancent un thread. Si la fonction de callback plante, l'appli plante.
    Il y a peut-être plus simple, mais ça tourne.
    Quand tout a échoué utilisez l'option RTFM

  16. #36
    Membre du Club
    Inscrit en
    Septembre 2007
    Messages
    86
    Détails du profil
    Informations forums :
    Inscription : Septembre 2007
    Messages : 86
    Points : 45
    Points
    45
    Par défaut
    bonjour,
    voila le code en VC

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    typedef		int (_stdcall * PACKDATAPROC)(DATAPACKET pktObj);
    DLL_EXPORT	long	_stdcall	signRegisterDataCallBack(PACKDATAPROC lpPackDataProc);
    le callback
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    m_HandleDataProc = signRegisterDataCallBack(data_proc);
    puis

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    int _stdcall CPadSignatureDlg::data_proc(DATAPACKET data)
    {
    	traitement des données reçu.....
    }
    je maitrise pas assez la logique du premier code pour comprendre le plantage

  17. #37
    Expert confirmé
    Avatar de Voroltinquo
    Homme Profil pro
    Chef de projet en SSII
    Inscrit en
    Juin 2017
    Messages
    2 808
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Chef de projet en SSII

    Informations forums :
    Inscription : Juin 2017
    Messages : 2 808
    Points : 5 267
    Points
    5 267
    Billets dans le blog
    1
    Par défaut
    J'ai commenté ce type de déclaration à la fin de mon (long) code d'initialisation de la collection.
    typedef crée un alias sur un type de variable ... ou sur un alias définit par typedef (cette notion n'existe pas en WL)
    e.g.
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    typedef unsigned char octet
    redéfinit le type "unsigned char" (que l'on pourra toujours utiliser) en type "octet".
    Ainsi le code suivant
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    typedef unsigned char octet;
     
    unsigned char MaVar;
    octet MaVar2;
    va déclarer 2 variables du type unsigned char.

    On peut utiliser typedef pour déclarer un alias sur un pointeur de fonction
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    typedef TypeRetour (*NomFonction)(Liste des paramètres);

    _stdcall(propre à MS) est utilisé pour déclarer une fonction qui a accès à une dll.

    On met le tout dans la moulinette à C
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    typedef		int (_stdcall * PACKDATAPROC)(DATAPACKET pktObj)
    definit un pointeur sur une fonction (PACKDATAPROC) qui retourne un int (entier sur 4), qui va acccéder à une dll et qui prend un DATAPACKET en paramètre.
    NOTE
    DATAPACKET est lui même un alias sur une structure tagDATAPACKET cf
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     
    typedef struct  tagDATAPACKET
    {
    EventType			eventtype;				//事件类型	4
    unsigned short		physical_key;			//物理按键	2
    unsigned short		virtual_key;			//虚拟按键	2
    KeyStatus			keystatus;				//按键状态	4
    PenStatus			penstatus;				//笔尖状态	4
    unsigned short		x;						//x坐标		2
    unsigned short		y;						//y坐标		2
    unsigned short		pressure;				//压感		2
    short				wheel_direction;		//转盘旋转方向标识	2
    unsigned short		button;					//笔身按键序列		2
    }DATAPACKET, *PDATAPACKET;
    Il y a peut-être plus simple, mais ça tourne.
    Quand tout a échoué utilisez l'option RTFM

  18. #38
    Membre du Club
    Inscrit en
    Septembre 2007
    Messages
    86
    Détails du profil
    Informations forums :
    Inscription : Septembre 2007
    Messages : 86
    Points : 45
    Points
    45
    Par défaut
    Bonjour,
    il y a pourtant bien un problème quelque part mais comment y mettre des pièges afin de comprendre ce qu'il fait ( on ne fait pas , ou fait mal ... )

  19. #39
    Expert confirmé
    Avatar de Voroltinquo
    Homme Profil pro
    Chef de projet en SSII
    Inscrit en
    Juin 2017
    Messages
    2 808
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Chef de projet en SSII

    Informations forums :
    Inscription : Juin 2017
    Messages : 2 808
    Points : 5 267
    Points
    5 267
    Billets dans le blog
    1
    Par défaut
    1-Dans :
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    int _stdcall CPadSignatureDlg::data_proc(DATAPACKET data)
    tu as "Traitement des données reçues"
    As tu ce code ?
    2-Dans
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    m_HandleDataProc = signRegisterDataCallBack(data_proc)
    On passe une fonction or, d'après la doc, signRegisterDataCallBack attend un pointeur sur une fonction.
    Il est fort possible que le testicule dans le consommé provienne de là
    Il y a peut-être plus simple, mais ça tourne.
    Quand tout a échoué utilisez l'option RTFM

  20. #40
    Membre du Club
    Inscrit en
    Septembre 2007
    Messages
    86
    Détails du profil
    Informations forums :
    Inscription : Septembre 2007
    Messages : 86
    Points : 45
    Points
    45
    Par défaut
    bonjour
    j'ai raccourci le code , j'ai mis "Traitement des données reçues" pour faire clair , d'origine il arrive ici quand tu touche au pad avec le stylo en VC :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    int _stdcall CPadSignatureDlg::data_proc(DATAPACKET data)
    {
    	WaitForSingleObject(g_eventData, INFINITE);
    	ResetEvent(g_eventData);
    	g_listData.emplace_back(data);
    	SetEvent(g_eventData);
    	g_lpPadSignatureDlg->PostMessage(WM_SIGN_DATA,NULL, NULL);
    	return 0;
    }
    il y a ceci dans le .H
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    static	int _stdcall data_proc(DATAPACKET data);

Discussions similaires

  1. Réponses: 0
    Dernier message: 27/02/2017, 11h19
  2. Réponses: 1
    Dernier message: 17/02/2016, 16h29
  3. Problème appel fonction d'une DLL
    Par xEndLe dans le forum Interfaçage autre langage
    Réponses: 1
    Dernier message: 04/05/2012, 17h08
  4. appel en boucle sur une DLL
    Par kaygee dans le forum ASP
    Réponses: 9
    Dernier message: 29/05/2007, 14h51
  5. Problème appel JNI d'une dll via COM
    Par mfabien dans le forum C
    Réponses: 3
    Dernier message: 13/04/2007, 14h38

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo