CerfaDoc - Introduction

Introduction - Edito

CerfaDoc permet d'éditer des formulaires, de les enregistrer dans HelloDOC et de les imprimer. CerfaDoc est en fait un ensemble de plusieurs outils souples et configurables permettant de réaliser des formulaires de saisie (au moyen de pages HTML), de remplir des fichiers PDF(*) avec des données externes, de faire des calculs, etc

Ce kit sert de référence et permet d'intégrer librement CerfaDoc dans n'importe quel logiciel. Le logiciel CerfaDoc a été développé à l'origine en tant que plugin pour HelloDOC et un certain nombre d'exemples sont donnés par rapport à cette intégration avec HelloDOC

CerfaDoc © Emmanuel RAVON (Bat) 2003-2009 Tous droits réservés

HelloDOC © est un produit d'Imagine Editions


CerfaDoc - Installation

Structure de CerfaDoc

s
Structure du système CerfaDoc

L'application qui intègre CerfaDoc effectue un appel soit à l'exécutable CerfaDoc, via une ligne de commande qui permet de paramétrer les différents appels. Il est également possible d'inclure directement cdi_core.dll et afficher 'in place' les fenetres de CerfaDoc (cette option est partiellement développée et le sera à la demande). CerfaDoc dialogue avec l'application (lecture/ecriture) par le biais de la DLL cdi....dll fournie par l'application. Concrêtement cette DLL doit implémenter un certain nombre de fonction telles que l'ouverture de la base, la lecture d'un enregistrement, l'écriture, la recherche, l'accès aux données liée au dossier patient.

Structure dans le cas d'HelloDOC

Exemple du cas d'HelloDOC

Dans le cas d'HelloDOC l'appel de CerfaDoc est fait via les accessoires ou l'ActiveX présent dans chaque enregistrement. L'accès aux données d'HelloDOC est fait via une DLL commune, documentée : HDAPI


CerfaDoc Kit - Intégrer CerfaDoc

Intégrer CerfaDoc

Cette section détaille pas à pas 2 exemples d'intégration.

  • Intégration la plus simple possible
  • Intégration dans un logiciel fictif de gestion de cabinet fait autour de CerfaDoc démontrant toutes les possibilités de CerfaDoc


CerfaDoc Kit - Intégrer CerfaDoc

Exemple basique

Dans cet exemple, on execute simplement CerfaDoc en autonome en prenant les données dans un fichier INI (le nom est celui passé dans le champ "user" sur la ligne de commande) et en sauvegardant les données dans un fichier binaire (.dat) et un fichier HTML (.htm) (également du nom passé dans "user").

Emplacement dans le Kit

  • "Lancement Exemple" est l'équivalent du fichier cerfadoc_ini.bat
  • "Formulaire HTM" est la visualisation du fichier demo.htm avec Internet Explorer (ce fichier est rempli une fois qu'un formulaire a été enregistré)
  • "Source xxx" ouvre le repertoire des sources associées

Création de la DLL

On choisit de nommer cette DLL : CDI_INI.DLL.
Cet exemple a été réalisé avec différents compilateurs :

  • LCC-Win32
  • Microsoft VisualC++ 6
  1. On crée un nouveau projet de DLL. On édite le nom de la DLL, le fait de ne pas générer de underscore (_) dans les noms de fonctions exportés et toutes les autres infos utiles
  2. On y ajoute un fichier main.c vide (ou un template de DLL), on le complète avec une séquence classique de point d'entrée de DLL
    #include <windows.h>
    #define CDI_INTERNAL
    #include "cdi_imp.h"
    HINSTANCE hInst;

    /*******************************************************************************************/
__declspec(dllexport) HRESULT WINAPI LibMain(HINSTANCE hInstance,DWORD
            reason, void *z){
/*******************************************************************************************/
switch (reason){
case DLL_PROCESS_ATTACH:
if (hInst!=NULL){
MessageBox(NULL,"Already
            attached !","",MB_ICONERROR);
return FALSE;
}
hInst=hInstance;
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
case DLL_PROCESS_DETACH:
hInst=NULL;
break;
}
return TRUE;
}

    On importe le fichier cdi_imp.h, avant cette inclusion on déclare CDI_INTERNAL, afin de définir toutes les fonctions avec __declspec(...)
  3. Pour commencer l'implémentation on peut partir du graphe d'architecture global
  4. On implémente la fonction CDI_GetOption(), elle retourne les noms choisis, on choisit d'utiliser la barre permettant d'appeler directement CerfaDoc dans les enregistrements, pas de résumé texte séparé, le flag global d'erreur n'est pas géré
    /*******************************************************************************************/
    int CDI_IMP(CDI_GetOption) (unsigned int opt,int *ret,char *txt,int max){
    /*******************************************************************************************/
    switch (opt){ // En fonction de l'option demandée
    case CDI_OPT_VERSION: // NUM : N° de version d'interface (doit être retourné)
    *ret=CDI_VERSION;
    break;
    case CDI_OPT_NAME: // CHAINE : Retourne le nom résumé de la DLL (ex "HD") (par défaut : nom de la DLL)
    snprintf(txt,max,"INI");
    break;
    case CDI_OPT_NAME_DETAIL: // CHAINE : Retourne le nom détaillé de la DLL ("interface HelloDOC, version 5.60") (par défaut : nom de la DLL)
    snprintf(txt,max,"Exemple basique CerfaDoc - fichiers INI");
    break;
    case CDI_OPT_ENREG_BAR: // NUM : A 1, inclus une barre sous forme d'active X dans l'enregistrement HTML, cette barre permet de réouvir,
    *ret=1;
    break;
    case CDI_OPT_ENREG_TXT: // NUM : A 1, fournit un enregistrement texte séparé, à 0 : laisse la possibilité de l'inclure dans le HTML
    *ret=0;
    break;
    case CDI_OPT_GLOBAL_ERROR: // NUM : A 1, indique qu'une erreur s'est produit lors de l'accès aux données. La lecture de ce flag le remet à 0 (aprèslecture)
    *ret=0;
    break;
    case CDI_OPT_GET_N_PAT_FROM_NAME:// NUM : A 1, indique que le N° du patient peut être récupéré à partir du nom
    *ret=0;
    break;
    default:
    return FALSE;
    }
    return TRUE;
    }
  5. On implémente les fonctions CDI_CabinetOpen() et CDI_CabinetClose(), elles mémorisent simplement ce qui est passé dans le champ "user" sous la forme des 3 fichiers .ini, .dat et .htm, elles indiquent également le répertoire en cours comme répertoire servant à stocker la configuration
    /*******************************************************************************************/
    int CDI_IMP(CDI_CabinetOpen)(char *path,char *cabinet,char *user,int version, int s_version, int build,char *user_path,int embed){
    /*******************************************************************************************/
    char dir[MAX_PATH];
    GetModuleFileName(hInst,dir,MAX_PATH);
    char *s;
    s=dir+strlen(dir);
    while (s>dir && *s!='\\') s--;
    if (s>dir) s++;
    *s=0;
    wsprintf(fic_ini,"%s\\%s.ini",dir,user);
    wsprintf(fic_dat,"%s\\%s.dat",dir,user);
    wsprintf(fic_htm,"%s\\%s.htm",dir,user);
    strcpy(user_path,dir);
    return CDI_OPEN_CABINET_OK;
    }

    /*******************************************************************************************/
    void CDI_IMP(CDI_CabinetClose)(void){
    /*******************************************************************************************/
    }
  6. On implémente la fonctions CDI_Record_Open(). Cette fonction débute une session de recherche, on alloue une structure que l'on appelle RECORD_DATA.
    typedef struct{
    }RECORD_DATA;
    Cette structure contient des champs qui nous seront utile pour l'énumération et la gestion des buffers des données retournées. Pour le moment on y place aucun champ. Le code de la fonction d'ouverture est donc :
    /******************************************************************************************/
    CDI_HDLE_RECORD CDI_IMP(CDI_RecordOpen)(CDI_REF no_pat,SYSTEMTIME *datetime,int opt){
    /*******************************************************************************************/
    RECORD_DATA *data;
    data=LocalAlloc(LMEM_FIXED,sizeof(RECORD_DATA));
    memset(data,0,sizeof(RECORD_DATA));
    return (CDI_HDLE_RECORD)data;
    }
  7. On implémente la fonction CDI_Record_Close() qui pour l'instant ne fait que libérer la structure de type RECORD_DATA que l'on avait allouée à l'ouverture

    /*******************************************************************************************/
    int CDI_IMP(CDI_RecordClose)(CDI_HDLE_RECORD hdle){
    /*******************************************************************************************/
    LocalFree(hdle);
    return TRUE;
    }
  8. On implémente la fonction CDI_RecordCount(), qui retourne 1 si le fichier "user" est présent, 0 sinon
    /*******************************************************************************************/
    unsigned int CDI_IMP(CDI_RecordCount)(CDI_HDLE_RECORD hdle,unsigned int *cur){
    /*******************************************************************************************/
    HANDLE hdle_fic=CreateFile(fic_dat,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
    if (hdle_fic==INVALID_HANDLE_VALUE) return 0;
    CloseHandle(hdle_fic);
    return 1;
    }
  9. On implémente CDI_RecordJump() et CDI_RecordDelete() qui ne font rien
  10. On implémente CDI_RecordsList() qui retourne "1 enregistrement" si le fichier est présent. On doit retourner un tableau contenant toutes les références, on retourne ici un tableau statique contenant une entrée fixe
    /*******************************************************************************************/
    CDI_REF* CDI_IMP(CDI_RecordsList)(unsigned int *nb_enreg,int class){
    /*******************************************************************************************/
    static CDI_REF ret=1;
    HANDLE hdle=CreateFile(fic_dat,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
    *nb_enreg=0;
    if (hdle==INVALID_HANDLE_VALUE) return NULL;
    CloseHandle(hdle);
    *nb_enreg=1;
    return &ret;
    }
  11. On implémente CDI_RecordNew() qui stocke un enregistrement dans les fichiers .dat et .htm
    /*******************************************************************************************/
    int CDI_IMP(CDI_RecordNew)(CDI_ENREG *enreg){
    /*******************************************************************************************/
    unsigned long ec;
    FILETIME ft,ft1;
    HANDLE hdle=CreateFile(fic_dat,GENERIC_WRITE,FILE_SHARE_READ,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
    WriteFile(hdle,enreg->data_raw,enreg->data_raw_len,&ec,NULL);
    SystemTimeToFileTime(&enreg->ext.datetime,&ft);
    LocalFileTimeToFileTime(&ft,&ft1);
    SetFileTime(hdle,&ft1,&ft1,&ft1);
    CloseHandle(hdle);
    hdle=CreateFile(fic_htm,GENERIC_WRITE,FILE_SHARE_READ,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
    WriteFile(hdle,enreg->data_html,enreg->data_html_len,&ec,NULL);
    SetFileTime(hdle,&ft1,&ft1,&ft1);
    CloseHandle(hdle);
    return TRUE;
    }
  12. On implémente CDI_RecordReadNext() qui lit un enregistrement depuis les fichiers .dat et .htm. Cette fonction retourne les données CerfaDoc brutes et les données demandées dans CDI_RECORD_EXT selon les options envoyées dans opt (seul le contenu HTML est retourné dans notre cas). On est amené à allouer un buffer qui retourne les données CerfaDoc brutes. L'adresse de ce buffer est mémorisée dans la structure liée au handle
    typedef struct{
    char *data; // buffer sur l'enregistrement lu
    int index; // index de l'élément à lire (0 non lu, 1 lu)
    }RECORD_DATA;
    Celà pemettra de désalouer ce buffer à l'appel suivant de CDI_RecordReadNext ou à l'appel de CDI_RecordClose. Le buffer alloué pour les données HTML sera explicitement désalloué par CDI_RecordExtFree()
    /*******************************************************************************************/
    int CDI_IMP(CDI_RecordReadNext)(CDI_HDLE_RECORD hdle,char **data,CDI_RECORD_EXT *ext,int opt){
    /*******************************************************************************************/
    unsigned long rd,sz;
    FILETIME ft,ft1;
    RECORD_DATA *data_hdle=(RECORD_DATA *)hdle;
    // Si un buffer est déjà alloué, libère ce buffer
    if (data_hdle->data) LocalFree(data_hdle->data);
    // Si on est plus sur le premier index
    if (data_hdle->index) return FALSE;
    data_hdle->data=NULL;
    // Lit le fichier de données CerfaDoc
    HANDLE hdle_fic=CreateFile(fic_dat,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
    if (hdle_fic==INVALID_HANDLE_VALUE) return FALSE; //Si le fichier de données CerfaDoc brute n'existe pas, erreur
    sz=GetFileSize(hdle_fic,NULL);
    *data=LocalAlloc(LMEM_FIXED,sz); // Alloue le buffer
    if (!*data){ // En cas d'erreur d'allocation mémoire on retourne une erreur
    MessageBox(NULL,"Erreur d'allocation mémoire","CDI-INI",MB_ICONERROR);
    CloseHandle(hdle_fic);
    return FALSE;
    }
    data_hdle->data=*data; // On mémorise ce buffer dans nos structure internes
    ReadFile(hdle_fic,*data,sz,&rd,NULL); // lecture effective.
    GetFileTime(hdle_fic,NULL,NULL,&ft); // On profite d'avoir le fichier ouvert pour lire également la date de l'enregistrement
    CloseHandle(hdle_fic);
    data_hdle->index++;

       if (!ext) return TRUE; // si on n'a pas
            de structure étendue, retourne directement, sinon traite selon
            les options

memset(ext,0,sizeof(CDI_RECORD_EXT));
FileTimeToLocalFileTime(&ft,&ft1);
FileTimeToSystemTime(&ft1,&ext->datetime);
ext->no_pat=1; // par défaut patient
            1
if (opt&CDI_RECORD_EXT_HTML){
// Lit l'enregistrement HTML
hdle_fic=CreateFile(fic_htm,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
if (hdle_fic==INVALID_HANDLE_VALUE) return
            FALSE;
sz=GetFileSize(hdle_fic,NULL);
ext->data_html=LocalAlloc(LMEM_FIXED,sz);
if (!ext->data_html){
MessageBox(NULL,"Erreur d'allocation
            mémoire","CDI-INI",MB_ICONERROR);
CloseHandle(hdle_fic);
return FALSE;
}
ReadFile(hdle_fic,ext->data_html,sz,&rd,NULL);
CloseHandle(hdle_fic);
}
if (opt&CDI_RECORD_EXT_DOSSIER){ // non utilisé
}
if (opt&CDI_RECORD_EXT_OTHER){ // non utilisé
}
return TRUE;
}
    On modifie le code de CDI_RecordClose pour gérer la désallocation
    /*******************************************************************************************/
    int CDI_IMP(CDI_RecordClose)(CDI_HDLE_RECORD hdle){
    /*******************************************************************************************/
    RECORD_DATA *data=(RECORD_DATA *)hdle;
    if (data->data) LocalFree(data->data); // Si on a encore un buffer d'alloué libère le
    LocalFree(hdle);
    return TRUE;
    }
  13. On implémente CDI_RecordExtCreate() qui crée un enregistrement CDI_RECORD_EXT, dans notre cas qui consiste simplement à mettre la structure à 0
    /*******************************************************************************************/
    void CDI_IMP(CDI_RecordExtCreate)(CDI_RECORD_EXT *ext){
    /*******************************************************************************************/
    memset(ext,0,sizeof(CDI_RECORD_EXT));
    }
  14. On implémente CDI_RecordExtFree(), qui libère un enregistrement, on libère simplement le buffer ext->data_html s'il est non nul
    /*******************************************************************************************/
    void CDI_IMP(CDI_RecordExtFree)(CDI_RECORD_EXT *ext){
    /*******************************************************************************************/
    if (ext->data_html) LocalFree(ext->data_html);
    ext->data_html=NULL;
    }
  15. On implémente CDI_SetRecordInfo(), qui n'effectue aucune opération, et indique qu'elle n'a rien retourné
    /*******************************************************************************************/
    int CDI_IMP(CDI_GetRecordInfo)(CDI_RECORD_EXT *data,unsigned int opt,int *ret,char *txt,int max){
    /*******************************************************************************************/
    return FALSE;
    }
  16. On implémente CDI_DataExtSet() qui enregistre les données additionnelles au dossier patient dans un fichier "data_ext.txt"
    /*******************************************************************************************/
    void CDI_IMP(CDI_DataExtSet)(CDI_REF ref,char *data){
    /*******************************************************************************************/
    unsigned long ec;
    HANDLE hdle=CreateFile(FIC_DATA_PATIENT_EXT,GENERIC_WRITE,FILE_SHARE_READ,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
    WriteFile(hdle,data,strlen(data),&ec,NULL);
    CloseHandle(hdle);
    }
  17. On implémente CDI_DataExtGet() qui relit ces données depuis le même fichier
    /*******************************************************************************************/
    void CDI_IMP(CDI_DataExtGet)(CDI_REF ref,char **data){
    /*******************************************************************************************/
    unsigned long sz,rd;
    HANDLE hdle_fic=CreateFile(FIC_DATA_PATIENT_EXT,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
    if (hdle_fic==INVALID_HANDLE_VALUE) return; // Si le fichier de données CerfaDoc brute n'existe pas, erreur
    sz=GetFileSize(hdle_fic,NULL);
    *data=LocalAlloc(LMEM_FIXED,sz+1); // Alloue le buffer, laisse la place pour le 0 de fin de chaine
    if (!*data){ // En cas d'erreur d'allocation mémoire on retourne une erreur
    MessageBox(NULL,"Erreur d'allocation mémoire","CDI-INI",MB_ICONERROR);
    CloseHandle(hdle_fic);
    return;
    }
    ReadFile(hdle_fic,*data,sz,&rd,NULL); // lecture effective.
    *data[sz]=0; // met le 0 de fin de chaine
    CloseHandle(hdle_fic);
    }
  18. On implémente CDI_DataGet() qui est la fonction principale d'acquisition des données pour cet exemple, on ne fait que piocher quelques champs dans le fichier INI

    /*******************************************************************************************/
int CDI_IMP(CDI_DataGet)(unsigned long item,int index,CDI_REF ref,char
            **data,long *nb){
/*******************************************************************************************/
static char buf[MAX_PATH];
static SYSTEMTIME st;
switch (item){
case CDD_PATIENT_NOM:
GetPrivateProfileString(DATA_NAME,"PatientNom","",buf,MAX_PATH,fic_ini);
*data=buf;
break;
case CDD_PATIENT_PRENOM:
GetPrivateProfileString(DATA_NAME,"PatientPrenom","",buf,MAX_PATH,fic_ini);
*data=buf;
break;
...
case CDD_PATIENT_RANG_GEM:
*nb=GetPrivateProfileInt(DATA_NAME,"PatientRangGemellaire",0,fic_ini);
break;
case CDD_PATIENT_TAILLE:
*nb=GetPrivateProfileInt(DATA_NAME,"PatientTaille",0,fic_ini);
break;
case CDD_PATIENT_POIDS:
*nb=GetPrivateProfileInt(DATA_NAME,"PatientPoids",0,fic_ini);
break;
case CDD_PATIENT_SEXE:
*nb=GetPrivateProfileInt(DATA_NAME,"PatientSexe",0,fic_ini);
break;
...
default:
return FALSE;
break;
}
return TRUE;
}
  19. On implémente CDI_DataGet2() vide, cette fonction permet de lire des champs avancés et n'est pas utilisée dans notre cas
    /********************************************************************************************/
    int CDI_IMP(CDI_DataGet2)(unsigned long item,CDI_DATA_EXT *ext,char **data,long *nb){
    /********************************************************************************************/
    return FALSE;
    }

  20. On implémente CDI_Free() qui dans notre cas libérera les buffers toujours de la même façon (s'ils sont non nuls)
    /********************************************************************************************/
    void CDI_IMP(CDI_Free)(void *data,int type,int len){
    /********************************************************************************************/
    if (data) LocalFree(data);
    }
  21. On implémente CDI_PatientsList() qui dans notre cas retourne une liste fixe d'une entrée (1 seul patient) ayant pour ref : 1

    /********************************************************************************************/
    CDI_REF* CDI_IMP(CDI_PatientsList)(unsigned int *nb_enreg,int class){
    /********************************************************************************************/
    CDI_REF *ref;
    *nb_enreg=1;
    ref=LocalAlloc(LMEM_FIXED,sizeof(CDI_REF));
    ref[0]=1;
    return ref;
    }
  22. On implémente CDI_PatientFind() qui dans notre cas retourne toujours une référence 1
    /********************************************************************************************/
    CDI_REF CDI_IMP(CDI_PatientFind)(char *nom,char *prenom,int browse){
    /********************************************************************************************/
    return 1;
    }
  23. On implémente CDI_PatientRef() qui dans notre cas retourne la même information que celle passée en entrée (on a qu'un seul patient, donc pas directement d'indexs sur les patients)
    /********************************************************************************************/
    CDI_REF CDI_IMP(CDI_PatientRef)(CDI_REF index){
    /********************************************************************************************/
    return index;
    }
  24. On doit retirer manuellement les exports que l'on n'utilise pas du fichier cdi_imp.h, à savoir :
    • CDI_DepensesList
    • CDI_RecettesList
    • CDI_Install
    • CDI_Refresh
    • CDI_SVRegimeGet
  25. On peut maintenant compiler la DLL : cdi_ini.dll

Essai de la DLL

  1. On regroupe maintenant dans un même répertoire :
    • cd_core.dll (la dll principale de cerfadoc)
    • cerfadoc.exe (l'exécutable permettant de l'appeler)
    • cdi_ini.dll (notre DLL)
  2. On crée un fichier .BAT permettant d'appeller CerfaDoc avec la ligne de commande :
    cerfadoc.exe +cdi_ini.dll//demo/demo/Patient demo/1///
  3. Toutes les opérations sont terminées, le raccourci peut être utilisé pour créer de nouveaux formulaires, les rééditer. Les enregistrements, qui contiennent la barre CerfaDoc, permettent un renouvellement, une impression, une modification directement depuis n'importe quel affichage HTML/IE (affichage de l'ActiveX)


CerfaDoc Kit - Intégrer CerfaDoc

Exemple complet

Intégration complète

.


CerfaDoc Kit - Structure

Référence

Cette section est la documentation de référence pour l'implémentation de la DLL d'accès CDI_xxx.DLL et l'accès à CerfaDoc.


CerfaDoc Kit - Intégrer CerfaDoc

Ligne de commande

L'appel à CerfaDoc.exe commande la ou les actions effectuées par CerfaDoc. Cette ligne de commande est constituée par :

[+motor]/[:OPTION]CHEMIN/CABINET/UTILISATEUR/PATIENT/FICHE/DOSSIER/HWDPARENT/DATE/TIME

Formalisme :

  • [] est un paramètre optionnel
  • / est un caracètre séparateur, aucun des paramètre ne doit le contenir
Valeur | Type | Détail
+motor | chaine précédée de '+' | Cet élément est optionnel, il permet de selectionner le nom de la DLL d'accès à utiliser. Par défaut : cdi_hellodoc.dll
:OPTION | caractère précédé de ':' | Caractère donnant l'action à effectuer, voir liste après ce tableau
CHEMIN | chaine | Chemin d'accès aux données passé à CDI_CabinetOpen, paramètre path
CABINET | chaine | Cabinet passé à CDI_CabinetOpen, paramètre cabinet
UTILISATEUR | chaine | Utilisateur passé à CDI_CabinetOpen, paramètre user
PATIENT | chaine | Nom du patient pour affichage en divers endroits de CerfaDoc
FICHE | chaine contenant un nombre décimal | N° du patient pour lequel CerfaDoc est appelé. Ce N° sera envoyé par ex à CDI_DataGet.Cet élément peut être omise si l'option CDI_OPT_GET_N_PAT_FROM_NAME est active
DOSSIER | chaine | Référence de dossier, utilisé en interne pour les liens entre formulaire (tag_bcd_reponse|Hash source|tag_bcd_source|tag_lien_source) question et réponse, doit être vide
HWDPARENT | chaine contentant un nombre décimal | Handle de la fenetre parente, est envoyé à la fonction CDI_Refresh. Peut être omis si la fonction CDI_Refresh n'est pas utilisée
DATE | chaine contenant un nombre hexadecimal sans 0x devant OU chaine contenant une date texte | Date de l'élément référencé, utilisé en interne, doit être vide ou omis Une date texte est entrées sous la forme dd-mm-aaaa
TIME | chaine contenant un nombre hexadecimal sans 0x devant OU chaine contenant une heure texte | Heure de l'élément référencé, utilisé en interne, doit être vide ou omis Une heure texte est entrées sous la forme hh-mm-ss

Ex :

appel basique | d:\database/hd560/hd560/André DUPONT/7//34256
appel de la boite "à propos" | :M/hd560/hd560//4868///

Options possibles :

Valeur | Détail
A
a 		Affiche une boite 'A propos' de CerfaDoc
('a') utilise la handle de fenêtre fourni comme parent
B
c | Démarre la boite de configuration
C | Réservé [Console]
D | Lance une boite de renouvellement de l'enregistrement sélectionné
E | Utilisation spéciale par appel direct de cdi_core.dll
F | Affiche la liste des champs de l'enregistrement
G | Réservé
H | Affiche une boite contenant des informations sur le masque de formulaire utilisé
i | Import Apicrypt
I | Lance une impression de l'enregistrement selectionné
J | Demande de réponse à un formulaire (utilisé en interne)
K | Affiche un enregistrement source (demande)
L | Affiche un enregistrement lié (réponse)
M | Lance une boite de modification de l'enregistrement sélectionné
N ou absent | Lance une boite de choix puis de création de formulaire
O | Lance un import du fichier XML sélectionné
P | Effectue une prévisualisation de l'enregistrement sélectionné (affichage du PDF)
Q | Quitte l'application directement
R | Affiche les données brutes de l'enregistrement
S | Lance un import
U | Affiche la boite de mise à jour de CerfaDoc
W | Lance une boite de modification des données du patient sélectionné
X | Effectue un export XML de l'enregistrement
Z | Récupère l'enregistrement


CerfaDoc Kit - DLL

CDI_xxx.DLL

Cette section décrit la DLL CDI_xxxx.DLL à créer


CerfaDoc Kit - DLL

CDI_xxx.DLL nommage

Nom

La DLL créée peut se nommer n'importe comment (son nom est passé dans les paramètres), cependant il est conseillé de garder le formalisme cdi_nom_de_produit.dll. Pour HelloDOC celà donne cdi_hellodoc.dll

Emplacement

Par défaut CerfaDoc recherche la DLL dans le répertoire où est situé son executable (ou sa DLL cd_core.dll lorsqu'elle a été chargée). S'il ne trouve pas la DLL indiquée à cet endroit il la recherche sur tout le système :LoadLibrary(nom_de_la_dll)
La DLL doit alors se situer dans un répertoire acessible par la fonction Win32 LoadLibrary. Une autre option est le répertoire windows/system32

  1. The directory from which the application loaded.
  2. The current directory.
  3. Windows 95: The Windows system directory. Use the GetSystemDirectory function to get the path of this directory.
    Windows NT: The 32-bit Windows system directory. Use the GetSystemDirectory function to get the path of this directory. The name of this directory is SYSTEM32.
  4. Windows NT: The 16-bit Windows system directory. There is no Win32 function that obtains the path of this directory, but it is searched. The name of this directory is SYSTEM.
  5. The Windows directory. Use the GetWindowsDirectory function to get the path of this directory.
  6. The directories that are listed in the PATH environment variable.

Extrait de l'aide Win32 sur les emplacements possibles

Protoypes

Le fichier principal de protoype est le fichier cdi_imp.h disponible avec le kit

Paramètres

L'ensemble des données échangées entre CerfaDoc et la DLL est en alignement sur 1 octet (#pragma pack(1) au niveau de cdi_imp.h)
Les noms de fonctions exportés n'ont pas de '_' d'ajoutés


CerfaDoc Kit - DLL groupe de fonction

CDI_xxx.DLL groupes de fonctions

Options

int CDI_IMP(CDI_GetOption) (unsigned int opt,int *ret,char *txt,int max);
// Récupère une option d'identification ou effactant le comportemant de CerfaDoc
void CDI_IMP(CDI_install) (HWND hwnd,int verbose);
// Installation de la DLL, appelée à tous les démarrages

Cabinet

int CDI_IMP(CDI_CabinetOpen) (char *path,char
  *cabinet,char *user,int version, int s_version, int build,char *user_path,int
  embed);
// Ouvre un cabinet, une base, etc
void CDI_IMP(CDI_CabinetClose) (void);
// Ferme le cabinet
void CDI_IMP(CDI_Refresh) (int hwnd, CDI_REF pat);
// Demande de raffraichissement de l'hôte (après ajout d'une entrée)

Helper

void CDI_IMP(CDI_SVRegimeGet) (char *data,int len,int regime,int abrev);
// Retourne une indication texte sur le nom ou abbréviation d'une caisse (ex : 1 Régime Général et GENERAL)

Accès aux données de la base interfacée

int CDI_IMP(CDI_DataGet) (unsigned long item,int
  index,CDI_REF ref,char **data,long *nb);
// Routine principale d'acquisition de données
int CDI_IMP(CDI_DataGet2) (unsigned long item,CDI_DATA_EXT
  *ext,char **data,long *nb);
// Routine principale d'acquisition de données
void CDI_IMP(CDI_DataExtGet) (CDI_REF ref,char **data);
// Routine d'acquisition des données non structurée (champs
  additionnels)
void CDI_IMP(CDI_DataExtSet) (CDI_REF ref,char *data);
// Routine de stockage des données non structurée (champs
  additionnels)

Accès aux données annexe de la base interfacée

CDI_REF* CDI_IMP(CDI_PatientsList) (unsigned
  int *nb_enreg,int class);
// Retourne une liste de patients
CDI_REF CDI_IMP(CDI_PatientRef) (CDI_REF index);
// Retourne une référence sur un patient
CDI_REF CDI_IMP(CDI_PatientFind) (char *nom,char *prenom,int
  browse);
// Retourne une référence sur un patient recherché
CDI_REF* CDI_IMP(CDI_DepensesList) (unsigned int *nb_enreg,int
  class);
// Retourne une liste de dépenses
CDI_REF* CDI_IMP(CDI_RecettesList) (unsigned int *nb_enreg,int
  class);
// Retourne une liste de recettes

Accès aux enregistrements de CerfaDoc dans la base interfacée

int CDI_IMP(CDI_GetRecordInfo) (CDI_RECORD_EXT
  *data,unsigned int opt,int *ret,char *txt,int max);
// Récupère une information à partir de la structure
  de donnée opaque d'un enregistrement
void CDI_IMP(CDI_SetRecordInfo) (CDI_RECORD_EXT *data,unsigned
  int opt,int val,char *txt);
// Stocke une information dans la structure de donnée opaque d'un
  enregistrement
void CDI_IMP(CDI_RecordExtCreate) (CDI_RECORD_EXT *ext);
// Crée/Alloue un ensemble de données CDI_RECORD_EXT vide
void CDI_IMP(CDI_RecordExtFree) (CDI_RECORD_EXT *ext);
// Libère les données CDI_RECORD_EXT

CDI_REF* CDI_IMP(CDI_RecordsList) (unsigned int *nb_enreg,int class);
// Retourne une liste de tous les éléments de tous les dossiers
unsigned int CDI_IMP(CDI_RecordCount) (CDI_HDLE_RECORD hdle,unsigned int *cur);
// retourne le nombre total d'enregistrements pour le dossier en cours, ce nombre peut contenir d'autres enregistrements que les

CDI_HDLE_RECORD CDI_IMP(CDI_RecordOpen) (CDI_REF
  no_pat,SYSTEMTIME *datetime,int opt);
// ouvre une session de recherche élément CerfaDoc
int CDI_IMP(CDI_RecordClose) (CDI_HDLE_RECORD hdle);
// termine une session de recherche, doit libérer toutes les données
void CDI_IMP(CDI_RecordJump) (CDI_HDLE_RECORD hdle,CDI_REF
  ref);
// se déplace dans la liste des enregistrements à l'index
  donné par ref, cet index peut être tiré de CDI_RecordsList
int CDI_IMP(CDI_RecordReadNext) (CDI_HDLE_RECORD hdle,char
  **data,CDI_RECORD_EXT *ext,int opt);
// cherche un enregistrement CerfaDoc

int CDI_IMP(CDI_RecordNew) (CDI_ENREG *enreg);
// Ajoute un enregistrement CerfaDoc
void CDI_IMP(CDI_RecordDelete) (CDI_RECORD_EXT *ext);
// efface un enregistrement

void CDI_IMP(CDI_Free) (void *data,int type,int len);
// data : donnée à libérer


CerfaDoc Kit - DLL

Principe de fonctionnement

Cette page donne un aperçu des différentes interactions entre CerfaDoc et la DLL CDI_xxx.DLL


CerfaDoc - Liste des fonctions

Liste des fonctions

Nom | Prototype
Options
CDI_GetImage | int CDI_IMP(CDI_GetImage) (int type,HBITMAP *bmp);
Récupère une image correspondant à un élément particulier
type : option parmi CDI_IMG_xxx, indique le type d'image à retourner
bmp : un bitmap (non utilisé pour le moment
retour : N° de la ressource contenant l'image à charger,-1 si image non disponible
CDI_GetOption | int CDI_IMP(CDI_GetOption) (unsigned int opt,int *ret,char *txt,int max);
Récupère une option d'identification ou affectant le comportemant de CerfaDoc
opt : option parmi CDI_OPT_xxx, une option non gérée doit retourner FALSE et ne pas modifier les buffers
*ret : valeur de retour si l'option est NUMERIQUE
txt : chaine à remplir si l'option est une CHAINE, on ne doit pas remplir plus de max octets, 0 terminal compris
max : taille du buffer dispo pour la chaine de retour
retour : TRUE si ok, FALSE si propriété non traitée
CDI_Install | int CDI_IMP(CDI_Install) (HWND hwnd,int verbose);
Installation de la DLL, appelée à tous les démarrages
hwnd : fenetre parente, peut être NULL
verbose : indique si l'action doit être silencieuse ou non
retour : 0:Si erreur, 1:si ok, 2:Si demande d'essai avec un compte administrateur
CDI_RegenFlag | void CDI_IMP(CDI_RegenFlag) (int regen);
Indique si l'on est en cours de regénération (par défaut non)
regen : à 1 en cours de regénération
CDI_Init | int CDI_IMP(CDI_Init) (HWND hwnd,int verbose);
Initialisation de la DLL, cette fonction est apellée (si elle est présente), après le chargement de la DLL elle permet d'afficher des messages d'erreur en cas de chargement incorrect
hwnd : handle de la fenêtre parente pour l'affichage des messages
verbose : à TRUE indique que la DLL peut afficher des messages, sinon, elle doit échouer silencieusement
retour : TRUE en cas de succes, FALSE en cas d'erreur
CDI_EmbedInfo | int CDI_IMP(CDI_EmbedInfo) (char *cabinet,char *user,char *path,HWND *hwnd);
Retourne des informations utilisées par le controle ActiveX
cabinet : nom du cabinet actuellement ouvert (taille max : MAX_PATH)
user : nom de l'utilisateur actuellement en cours (taille max : MAX_PATH)
path : chemin du cabinet (taille max : MAX_PATH)
hwnd : handle fenetre à raffraichir
retour : TRUE en cas de succes, FALSE en cas d'erreur
Cabinet
CDI_CabinetOpen | int CDI_IMP(CDI_CabinetOpen) (char *path,char *cabinet,char *user,int version, int s_version, int build,char *user_path,int embed);
Ouvre un cabinet, une base, etc
path : chemin de la base passé dans la ligne de commande
cabinet : nom du cabinet passé dans la ligne de commande
user : nom de l'utilisateur passé dans la ligne de commande
version : N° de version de CerfaDoc
s_version: N° de sous version de CerfaDoc
build : N° de build de CerfaDoc
user_path: chaine de taille MAX_PATH à remplir avec un chemin où CerfaDoc stockera et lira ses fichiers de configuration pour ce cabinet et cet utilisateur
embed : à 1 indique que CerfaDoc(cd_core.dll) est démarré en DLL cliente
retour : une des constantes CDI_OPEN_CABINET_xx indiquant si l'ouverture s'est bien passée ou non
CDI_RegisterThread | int CDI_IMP(CDI_RegisterThread) (void);
Enregistre un thread, pour lui permettre d'utiliser le cabinet ouvert
CDI_UnRegisterThread | int CDI_IMP(CDI_UnRegisterThread) (void);
Retire un thread (et retire l'accès au cabinet ouver)
CDI_CabinetClose | void CDI_IMP(CDI_CabinetClose) (void);
Ferme le cabinet
CDI_UserList | USERS_DESC *CDI_IMP(CDI_UserList) (void);
Retourne une liste d'utilisateur. Le buffer retourné est à libérer par CDI_Free()
CDI_ImpersonateUser | void CDI_IMP(CDI_ImpersonateUser) (char *user);
Utilise les données d'un autre utilisateur
CDI_Refresh | void CDI_IMP(CDI_Refresh) (int hwnd, CDI_REF pat);
Demande de raffraichissement de l'hôte (après ajout d'une entrée)
hwnd : handle de fenetre passé en ligne de commande
pat : N° de patient dont le dossier est à raffraichir
CDI_Show | int CDI_IMP(CDI_Show) (int hwnd, CDI_REF pat,SYSTEMTIME *st);
Demande l'affichage de l'enregistrement défini par pat et systemtime. Si la fonction n'existe pas ou retourne FALSE, un affichage interne est réalisé
hwnd : handle de fenetre passé en ligne de commande
pat : N° de patient dont le dossier est à raffraichir
st : Date/Heure de l'enregistrement
Helper
CDI_SVRegimeGet | void CDI_IMP(CDI_SVRegimeGet) (char *data,int len,int regime,int abrev);
Retourne une indication texte sur le nom ou abbréviation d'une caisse (ex : 1 Régime Général et GENERAL)
data : buffer de destination
len : taille du buffer de destination
regime : N° de régime à convertir
abrev : à 1 : retourner l'abréviation, à 0 : retourner le nom complet
Accès aux données de la base interfacée
CDI_DataGet | int CDI_IMP(CDI_DataGet) (unsigned long item,int index,CDI_REF ref,char **data,long *nb);
Routine principale d'acquisition de données
Demande un élément désigné par :
item : Détail de l'élément à interroger désigné par une constante CDD_xxxx
index : Index dans le cas d'un élément indexé
ref : Référence sur l'élément à interroger (patient, recette, dépense)
*data : Pointeur vers les données retournées. Ce buffer qui doit être alloué par la DLL pourra être libéré ou réutilisé au prochain appel
*nb : Donnée numérique retournée, peut être de type long, ou double
CDI_DataGet2 | int CDI_IMP(CDI_DataGet2) (unsigned long item,CDI_DATA_EXT *ext,char **data,long *nb);
Routine principale d'acquisition de données
Demande un élément désigné par :
item : Détail de l'élément à interroger désigné par une constante CDD_xxxx
ext : Référence étendue sur l'élément à interroger (formulaire, etc), cette structure contient les informations supplémentaires
*data : Pointeur vers les données retournées. Ce buffer qui doit être alloué par la DLL pourra être libéré ou réutilisé au prochain appel
*nb : Donnée numérique retournée, peut être de type long, ou double
CDI_DataExtGet | void CDI_IMP(CDI_DataExtGet) (CDI_REF ref,char **data);
Routine d'acquisition des données non structurées (champs additionnels de CerfaDoc).
La DLL doit retourner ces données "opaques" stockée dans la dossier patient par CDI_DataExtSet
ref : Référence sur l'élément à interroger (patient, recette, dépense)
*data : Pointeur vers les données retournées. Peut être NULL si non disponible Ce buffer sera libéré par CDI_Free
CDI_DataExtSet | void CDI_IMP(CDI_DataExtSet) (CDI_REF ref,char *data);
Routine de stockage des données non structurée (champs additionnels de CerfaDoc)
La DLL doit stocker ces données "opaques" dans la dossier patient et devra les retourner lors d'un appel à CDI_DataExtSet
ref : Référence sur l'élément à interroger (patient, recette, dépense)
*data : Données à stocker, sous forme de chaine texte terminée par un \0
Accès aux données annexe de la base interfacée
CDI_PatientsList | LPCDI_REF CDI_IMP(CDI_PatientsList) (unsigned int *nb_enreg,int class);
Retourne une liste de tous les patients du cabinet
nb_enreg : à remplir avec le nombre de patients
class : classement à effectuer de la liste
0 : liste dans l'ordre alphabetique de nom+prenom
1 : liste dans l'ordre des N° de dossier
2 : liste dans l'ordre des références de dossiers
retour : pointeur sur un buffer de CDI_REF, chaque entrée correspond à une référence à un patient.
Chaque référence sera convertie par CDI_PatientRef avant d'être envoyée à une fonction type CDI_DataGet
Le buffer sera libéré par CDI_Free
CDI_PatientRef | CDI_REF CDI_IMP(CDI_PatientRef) (CDI_REF index);
Convertit une référence retournée par CDI_PatientList en une référence utilisable par CDI_DataGet
index : index retourné dans une liste de patient
retour : entrée correspondant à un patient
CDI_PatientFind | CDI_REF CDI_IMP(CDI_PatientFind) (char *nom,char *prenom,int browse);
Retourne une référence sur un patient recherché suivant le nom et prénom du patient
nom : nom du patient
prenom : prenom du patient
browse : à 1 indique que l'on doit donner l'entrée suivant la référence donnée par nom et prénom en suivant l'ordre alphabétique. A 0 retourne la ref exacte ou 0 si non existant
retour : entrée correspondant à un patient, devra être convertie par CDI_PatientRef
CDI_PatientCreate | int CDI_IMP(CDI_PatientCreate) (char *nom,char *prenom,CDI_REF *ref);
Crée un patient dans la base s'il n'existe pas. Retourne son identifiant dans *ref
name : nom du patient
prenom : prenom du patient
ref : référence à renseigner avec le N° du dossier créé ou trouvé
retour : TRUE si le patient a été crée ou trouvé. FALSE en cas d'erreur
CDI_DepensesList | CDI_REF* CDI_IMP(CDI_DepensesList) (unsigned int *nb_enreg,int class);
Retourne une liste de dépenses
nb_enreg : à remplir avec le nombre de dépenses
class : classement à effectuer de la liste
0 : classement naturel
retour : pointeur sur un buffer de CDI_REF, chaque entrée correspond à une référence à une dépense
le buffer sera libéré par CDI_Free
CDI_RecettesList | CDI_REF* CDI_IMP(CDI_RecettesList) (unsigned int *nb_enreg,int class);
Retourne une liste de recettes
nb_enreg : à remplir avec le nombre de recettes
class : classement à effectuer de la liste
0 : classement naturel
retour : pointeur sur un buffer de CDI_REF, chaque entrée correspond à une référence à une recette
le buffer sera libéré par CDI_Free
CDI_CourrierNew | int CDI_IMP(CDI_CourrierNew) (char *dest,char *exp,CDI_REF no_pat,int recu,SYSTEMTIME *datetime,char *txt);
Ajoute un courrier
dest : nomdu destinataire du courrier
datetime : date/heure de réalisation du courrier
txt : texte du courrier en HTML
retoru : TRUE en cas de succès, FALSE en cas d'erreur
Accès aux enregistrements de CerfaDoc dans la base interfacée
CDI_GetRecordInfo | int CDI_IMP(CDI_GetRecordInfo) (CDI_RECORD_EXT *data,unsigned int opt,int *ret,char *txt,int max);
Récupère une information à partir de la structure de donnée opaque CDI_RECORD_EXT d'un enregistrement CerfaDoc
data : entrée extension obtenue ou crée
opt : option parmi CDI_RECORD_xxx, une option non gérée doit retourner FALSE et ne pas modifier les buffers
*ret : valeur de retour si l'option est NUMERIQUE
txt : chaine à remplir si l'option est une CHAINE, on ne doit pas remplir plus de max octets, 0 terminal compris
max : taille du buffer dispo pour la chaine de retour
retour : TRUE en cas de succès, FALSE si l'option n'a pas été traitée
CDI_SetRecordInfo | void CDI_IMP(CDI_SetRecordInfo) (CDI_RECORD_EXT *data,unsigned int opt,int val,char *txt);
Stocke une information dans la structure de donnée opaque CDI_RECORD_EXT d'un enregistrement CerfaDoc
data : entrée extension obtenue ou crée
opt : option parmi CDI_RECORD_xxx, une option non gérée doit retourner FALSE et ne pas modifier les buffers
*ret : valeur de retour si l'option est NUMERIQUE
txt : chaine à remplir si l'option est une CHAINE, on ne doit pas remplir plus de max octets, 0 terminal compris
CDI_RecordExtCreate | void CDI_IMP(CDI_RecordExtCreate) (CDI_RECORD_EXT *ext);
Crée/Alloue un ensemble de données CDI_RECORD_EXT vide
ext : strcture à initialiser
CDI_RecordExtFree | void CDI_IMP(CDI_RecordExtFree) (CDI_RECORD_EXT *ext);
Libère les données CDI_RECORD_EXT
ext : donnée à libérer
CDI_RecordsList | LPCDI_REF CDI_IMP(CDI_RecordsList) (unsigned int *nb_enreg,int class);
Retourne une liste de tous les enregistrements CerfaDoc de tous les dossiers. Il peut y avoir parmi cette liste des enregistrements non CerfaDoc
nb_enreg : à remplir avec le nombre d'enregistrements CerfaDoc
class : classement à effectuer de la liste
0 : classement naturel
retour : pointeur sur un buffer de CDI_REF, chaque entrée correspond à une référence à un enregistrement CerfaDoc
le buffer sera libéré par CDI_Free
CDI_RecordOpen | CDI_HDLE_RECORD CDI_IMP(CDI_RecordOpen) (CDI_REF no_pat,SYSTEMTIME *datetime,int opt);
ouvre une session de recherche d'éléments CerfaDoc
no_pat : référence sur le patient (retournée par CDI_PatientRef par ex)
datetime : date et heure de l'enregistrement à chercher (seuls année, mois, jour, heure, minute, seconde sont utilisés)
si NULL, cherche séquentiellement les éléments dans le dossier patient (l'ordre n'est pas défini)
opt : une ou plusieurs option CDI_REC_OPEN_xxx
CDI_RecordClose | int CDI_IMP(CDI_RecordClose) (CDI_HDLE_RECORD hdle);
termine une session de recherche, doit libérer toutes les données
hdle : handle sur la session
CDI_RecordCount | unsigned int CDI_IMP(CDI_RecordCount) (CDI_HDLE_RECORD hdle,unsigned int *cur);
retourne le nombre total d'enregistrements CerfaDoc pour le dossier en cours, ce nombre peut contenir d'autres enregistrements que les
enregistrements CerfaDoc.
hdle : handle sur la session
*cur : si non NULL doit être rempli avec le N° du prochain enregistrement à lire dans la séquence, cet enregistrement n'est pas obligé d'être un
enregistrement CerfaDoc
CDI_RecordJump | void CDI_IMP(CDI_RecordJump) (CDI_HDLE_RECORD hdle,CDI_REF ref);
se déplace dans la liste des enregistrements à l'index donné par ref, cet index peut être tiré de CDI_RecordsList
hdle : handle sur la session
ref : index vers lequel aller
CDI_RecordReadNext | int CDI_IMP(CDI_RecordReadNext) (CDI_HDLE_RECORD hdle,char **data,CDI_RECORD_EXT *ext,int opt);
cherche un enregistrement CerfaDoc
Si la session a été ouverte en browse, retourne le prochain élément dans *data et TRUE en valeur de retour, retourne FALSE en fin de liste
Si la session n'a pas été ouverte en browse, retourne l'élément selectionné et TRUE ou FALSE, s'il est ou non trouvé
hdle : handle sur la session
*data : doit recevoir un buffer alloué avec les données de l'enregistrement (données de data_raw) (si pas d'erreur, NULL sinon)
*ext : doit être complété avec les données extérieures (données opaques CerfaDoc concernant l'enregistrement et données autres de l'enregistrement)
ces données seront désallouée par CDI_RecordExtFree. ext peut être NULL
opt : options de récupération CDI_RECORD_EXT_xx, au moins ces éléments doivent être récupérés. Il peuvent être systématiquement tous récupérés
Les buffers alloués peuvent être libérés lors d'un nouvel appel à CDI_RecordReadNext ou CDI_RecordClose
Les buffers alloués pour CDI_RECORD_EXT doivent être désalloué manuellement par CDI_RecordFreeExt
CDI_RecordNew | int CDI_IMP(CDI_RecordNew) (CDI_ENREG *enreg);
Ajoute un enregistrement CerfaDoc
enreg : contient toutes les données pour créer l'enregistrement
retour : TRUE en cas de succès, FALSE sinon
CDI_RecordDelete | void CDI_IMP(CDI_RecordDelete) (CDI_RECORD_EXT *ext);
Efface un enregistrement référencé par son CDI_RECORD_EXT (on peut stocker une référence dans ext->user_param lors d'un accès CDI_RecordReadNext)
*ext : données étendue de l'enregistrement, seule la partie commune est forcément présente
CDI_Free | void CDI_IMP(CDI_Free) (void *data,int type,int len);
data : donnée à libérer
type : type de données à libérer parmi CDI_DATA_xxx
len : longueur du tableau dans le cas de liste retournée par CDI_PatientList par ex
CDI_GetAllocInfo | int CDI_IMP(CDI_GetAllocInfo) (char *fic,DWORD *page);
Retourne le nom du fichier source ayant effectué la dernière allocation et le numero de ligne
fic : nom du fichier ("" si aucun)
retour : N° de lgine
x | fine CDI_IMP(x) __declspec(dllexport) x
x | fine CDI_IMP(x) (*x)


CerfaDoc Kit - CDI_GetImage

CDI_GetImage

int CDI_IMP(CDI_GetImage) (int type,HBITMAP *bmp);
Récupère une image correspondant à un élément particulier
type : option parmi CDI_IMG_xxx, indique le type d'image à retourner
bmp : un bitmap (non utilisé pour le moment
retour : N° de la ressource contenant l'image à charger,-1 si image non disponible


CerfaDoc Kit - CDI_GetOption

CDI_GetOption

int CDI_IMP(CDI_GetOption) (unsigned int opt,int *ret,char *txt,int max);
Récupère une option d'identification ou affectant le comportemant de CerfaDoc
opt : option parmi CDI_OPT_xxx, une option non gérée doit retourner FALSE et ne pas modifier les buffers
*ret : valeur de retour si l'option est NUMERIQUE
txt : chaine à remplir si l'option est une CHAINE, on ne doit pas remplir plus de max octets, 0 terminal compris
max : taille du buffer dispo pour la chaine de retour
retour : TRUE si ok, FALSE si propriété non traitée

Cette fonction est appelée par CerfaDoc pour récupérer des paramètres de la DLL. Ces paramètres modifient le fonctionnement de CerfaDoc.

Selon le type de la donnée retournée (voir les constantes CDI_OPT_xxx), il faut utiliser :

Type | Elément à utiliser | Exemple en C
CHAINE *data

*data=(char*)malloc(10);
strcpy(*data,"Ma chaine");
ou
static char buffer[1000];
*data=buffer;
strcpy(*data,"Ma chaine");
NUM | *nb | *nb=1234


CerfaDoc Kit - CDI_Install

CDI_Install

int CDI_IMP(CDI_Install) (HWND hwnd,int verbose);
Installation de la DLL, appelée à tous les démarrages
hwnd : fenetre parente, peut être NULL
verbose : indique si l'action doit être silencieuse ou non
retour : 0:Si erreur, 1:si ok, 2:Si demande d'essai avec un compte administrateur

Cette fonction est appelée systématique à tous les démarrages de CerfaDoc. Elle doit vérifier et le cas échant réinstaller les liens nécessaires pour l'utilisation de CerfaDoc dans l'application cliente. Si aucun lien n'est nécessaire cette fonction peut simplement retourner.
hwnd : handle de la fenetre parente, permet à la DLL d'afficher une fenetre bloquante en cas d'erreur
verbose : à 1 autorise la DLL à afficher une fenetre en cas d'erreur (ou pour toute autre raison jugée nécessaire). à 0 interdit tout affichage de fenêtre

Cette fonction est facultative, par défaut aucune action n'est effectuée


CerfaDoc Kit - CDI_RegenFlag

CDI_RegenFlag

void CDI_IMP(CDI_RegenFlag) (int regen);
Indique si l'on est en cours de regénération (par défaut non)
regen : à 1 en cours de regénération


CerfaDoc Kit - CDI_Init

CDI_Init

int CDI_IMP(CDI_Init) (HWND hwnd,int verbose);
Initialisation de la DLL, cette fonction est apellée (si elle est présente), après le chargement de la DLL elle permet d'afficher des messages d'erreur en cas de chargement incorrect
hwnd : handle de la fenêtre parente pour l'affichage des messages
verbose : à TRUE indique que la DLL peut afficher des messages, sinon, elle doit échouer silencieusement
retour : TRUE en cas de succes, FALSE en cas d'erreur


CerfaDoc Kit - CDI_EmbedInfo

CDI_EmbedInfo

int CDI_IMP(CDI_EmbedInfo) (char *cabinet,char *user,char *path,HWND *hwnd);
Retourne des informations utilisées par le controle ActiveX
cabinet : nom du cabinet actuellement ouvert (taille max : MAX_PATH)
user : nom de l'utilisateur actuellement en cours (taille max : MAX_PATH)
path : chemin du cabinet (taille max : MAX_PATH)
hwnd : handle fenetre à raffraichir
retour : TRUE en cas de succes, FALSE en cas d'erreur


CerfaDoc Kit - CDI_CabinetOpen

CDI_CabinetOpen

int CDI_IMP(CDI_CabinetOpen) (char *path,char *cabinet,char *user,int version, int s_version, int build,char *user_path,int embed);
Ouvre un cabinet, une base, etc
path : chemin de la base passé dans la ligne de commande
cabinet : nom du cabinet passé dans la ligne de commande
user : nom de l'utilisateur passé dans la ligne de commande
version : N° de version de CerfaDoc
s_version: N° de sous version de CerfaDoc
build : N° de build de CerfaDoc
user_path: chaine de taille MAX_PATH à remplir avec un chemin où CerfaDoc stockera et lira ses fichiers de configuration pour ce cabinet et cet utilisateur
embed : à 1 indique que CerfaDoc(cd_core.dll) est démarré en DLL cliente
retour : une des constantes CDI_OPEN_CABINET_xx indiquant si l'ouverture s'est bien passée ou non

Cette fonction est appelée au démarrage de CerfaDoc et ouvre le cabinet ou la base de données associée. La DLL peut utiliser "path" "cabinet" "user" pour trouver la base. Ces paramètres sont ceux envoyés dans la ligne de commande de CerfaDoc. Le N° de version, sous version et build de CerfaDoc peut être utilisé pour effectuer des affichage de message d'erreur.
La fonction doit remplir la chaine user_path de longueur MAX_PATH (compter 255 octets si cette constante n'est pas disponible dans l'environnement utilisé) avec un chemin dans lequel CerfaDoc peut venir stocker ses paramètres c'est à dire 2 fichiers (CerfaDoc.ini et CerfaDoc.dat). Ces fichiers sont propre à chaque utilisateur et chaque cabinet.
Le flag "embed" indique que CerfaDoc a été démarré à partir de l'application cliente directement par appel de cdi_core.dll et non à partir de CerfaDoc.exe. Dans ce cas cette fonction est l'endroit pour établir une communication entre l'application parente et cette DLL permettant d'accéder à la base.

La fonction doit retourner une des constantes CDI_OPEN_CABINET_xxx (voir la documentation de ces constantes pour plus de détails)


CerfaDoc Kit - CDI_RegisterThread

CDI_RegisterThread

int CDI_IMP(CDI_RegisterThread) (void);
Enregistre un thread, pour lui permettre d'utiliser le cabinet ouvert


CerfaDoc Kit - CDI_UnRegisterThread

CDI_UnRegisterThread

int CDI_IMP(CDI_UnRegisterThread) (void);
Retire un thread (et retire l'accès au cabinet ouver)


CerfaDoc Kit - CDI_CabinetClose

CDI_CabinetClose

void CDI_IMP(CDI_CabinetClose) (void);
Ferme le cabinet

Cette commande est appelée par CerfaDoc lorsqu'il quitte sa session. La DLL peut effectuer les taches nécessaires lors de la fermeture du cabinet


CerfaDoc Kit - CDI_UserList

CDI_UserList

USERS_DESC *CDI_IMP(CDI_UserList) (void);
Retourne une liste d'utilisateur. Le buffer retourné est à libérer par CDI_Free()


CerfaDoc Kit - CDI_ImpersonateUser

CDI_ImpersonateUser

void CDI_IMP(CDI_ImpersonateUser) (char *user);
Utilise les données d'un autre utilisateur


CerfaDoc Kit - CDI_Refresh

CDI_Refresh

void CDI_IMP(CDI_Refresh) (int hwnd, CDI_REF pat);
Demande de raffraichissement de l'hôte (après ajout d'une entrée)
hwnd : handle de fenetre passé en ligne de commande
pat : N° de patient dont le dossier est à raffraichir

Cette fonction permet de demander à l'application appelante de raffraichir une fenetre ou une liste. Si cette fonction n'est pas nécessaire elle peut être ignorée

Cette fonction est facultative, par défaut aucune action n'est effectuée


CerfaDoc Kit - CDI_Show

CDI_Show

int CDI_IMP(CDI_Show) (int hwnd, CDI_REF pat,SYSTEMTIME *st);
Demande l'affichage de l'enregistrement défini par pat et systemtime. Si la fonction n'existe pas ou retourne FALSE, un affichage interne est réalisé
hwnd : handle de fenetre passé en ligne de commande
pat : N° de patient dont le dossier est à raffraichir
st : Date/Heure de l'enregistrement


CerfaDoc Kit - CDI_SVRegimeGet

CDI_SVRegimeGet

void CDI_IMP(CDI_SVRegimeGet) (char *data,int len,int regime,int abrev);
Retourne une indication texte sur le nom ou abbréviation d'une caisse (ex : 1 Régime Général et GENERAL)
data : buffer de destination
len : taille du buffer de destination
regime : N° de régime à convertir
abrev : à 1 : retourner l'abréviation, à 0 : retourner le nom complet

Cette fonction est utilisée par CerfaDoc pour récupérer des informations sur un N° de régime utilisé par Sesam Vitale. La DLL doit renvoyer dans data un maximum de len caractères (suivi d'un 0 terminal), contenant le nom complet du régime ou l'abréviation correspondante. Cette fonction existe pour car les logiciels médicaux disposent pour la pluspart de ces tables.

Voici un exemple de cette correspondance, cet exemple n'est pas forcément ni à jour ni exhaustif :

N° de régime | Nom complet | Abréviation
1 | Régime Général | GENERAL
2 | Régime Agricole | AGRICOLE
3 | Assurance maladie des Professions Indépendantes | AMPI
4 | Caisses de Prévoyance et de Retraite de la SNCF | SNCF
5 | Régime spécial de la RATP | RATP
6 | Etablissement National des Invalides de la Marine | ENIM
7 | Régime minier de Sécurité Sociale | RMSS
8 | Caisse Nationale Militaire de Securité Sociale | CNMSS
9 | Caisse de prévoyance maladie de la Banque de France | CPMBF
10 | Caisse de Retraite et de Prévoyance des Clercs et Employés de notaires | CRPCEN
11 | Chambre de Commerce et d'Industrie de Paris | CCIP
... | ... | ...
96 | Mutuelle Nationale Aviation Marine | MNAM
99 | Autres mutuelles | AUTRES

Cette fonction est facultative, par défaut elle renvoie les données d'une table de conversion connue comme à jour en 01/2009


CerfaDoc Kit - CDI_DataGet

CDI_DataGet

int CDI_IMP(CDI_DataGet) (unsigned long item,int index,CDI_REF ref,char **data,long *nb);
Routine principale d'acquisition de données
Demande un élément désigné par :
item : Détail de l'élément à interroger désigné par une constante CDD_xxxx
index : Index dans le cas d'un élément indexé
ref : Référence sur l'élément à interroger (patient, recette, dépense)
*data : Pointeur vers les données retournées. Ce buffer qui doit être alloué par la DLL pourra être libéré ou réutilisé au prochain appel
*nb : Donnée numérique retournée, peut être de type long, ou double

Cette fonction est appelée pour CerfaDoc dans le but d'obtenir une donnée précise de la base de donnée. La donnée à retourner est celle indiquée par la constante passée dans "item" CDD_xxx. Seul les éléments n'ayant pas le marquage "E" peuvent être demandés. (ex : CDD_FORM_DATE ne peut pas être demandé via cette fonction mais le sera via CDI_DataGet2)
Dans le cas d'une indexation simple (tableau de donnée), "index" donne l'index dans le tableau. (voir par ex les données plus avancées telles que les notes CDD_NOTE_DATA.Dans tous les autres cas ce paramètre peut être ignoré
Dans le cas de données plus complexes (tableaux de plusieurs dimensions, structure, c'est la fonction CDI_DataGet2 qui est utilisée)
"Ref" donne la référence de l'élément à interroger, ce peut être :

  • Une valeur retournée par CDI_PatientRef
  • Une valeur retournée par CDI_DepensesList
  • Une valeur retournée par CDI_RecettesList

Selon le type de la donnée retournée (voir les constantes CDD_xxx), il faut utiliser :

Type | Elément à utiliser | Exemple en C
CHAINE *data

*data=(char*)malloc(10);
strcpy(*data,"Ma chaine");
ou
static char buffer[1000];
*data=buffer;
strcpy(*data,"Ma chaine");
NUM | *nb | *nb=1234
SYSTEMTIME (SYSTEMTIME*)*data

SYSTEMTIME *st;
st=(SYSTEMTIME*)malloc(sizeof(SYSTEMTIME));
memset(st,0,sizeof(SYSTEMTIME));
st->wHour=12;
st->wMinute=10;
*data=(char*)st;
ou
static SYSTEMTIME st={0};
st.wHour=12;
st.wMinute=10;
*data=(char*)&st;

DOUBLE | (double*)nb | *(double*)nb=9.876


CerfaDoc Kit - CDI_DataGet2

CDI_DataGet2

int CDI_IMP(CDI_DataGet2) (unsigned long item,CDI_DATA_EXT *ext,char **data,long *nb);
Routine principale d'acquisition de données
Demande un élément désigné par :
item : Détail de l'élément à interroger désigné par une constante CDD_xxxx
ext : Référence étendue sur l'élément à interroger (formulaire, etc), cette structure contient les informations supplémentaires
*data : Pointeur vers les données retournées. Ce buffer qui doit être alloué par la DLL pourra être libéré ou réutilisé au prochain appel
*nb : Donnée numérique retournée, peut être de type long, ou double

Cette fonction est appelée pour CerfaDoc dans le but d'obtenir une donnée précise de la base de donnée. La donnée à retourner est celle indiquée par la constante passée dans "item" CDD_xxx. Seul les entrées ayant le marquage "E" peuvent être demandées (par ex CDD_FORM_DATE)
"ext" donne toutes les informations sur l'élément à interroger.

typedef struct{
CDI_REF ref; // référence sur l'élément principal
CDI_REF n_entry; // N° entrée
CDI_REF n_col; // N° de colonne
CDI_REF n_lig; // N° de ligne
char *str1; // Chaine de référence
char *str2; // Chaine de référence
}CDI_DATA_EXT;

Type de données | Signification
CDD_FORM_xxx | ref : référence sur le N° de patient (retourné par CDI_PatientRef) n_entry : N° de formulaire de 0 à CDD_FORM_COUNT-1 n_col : N° de colonne dans le formulaire n_lig : N° de ligne dans le formulaire
CDD_FORM_LIGNE_FORM_STR | str1 : Nom de ligne à rechercher

Pour les types de données retournées voir CDI_DataGet


CerfaDoc Kit - CDI_DataExtGet

CDI_DataExtGet

void CDI_IMP(CDI_DataExtGet) (CDI_REF ref,char **data);
Routine d'acquisition des données non structurées (champs additionnels de CerfaDoc).
La DLL doit retourner ces données "opaques" stockée dans la dossier patient par CDI_DataExtSet
ref : Référence sur l'élément à interroger (patient, recette, dépense)
*data : Pointeur vers les données retournées. Peut être NULL si non disponible Ce buffer sera libéré par CDI_Free

Cette fonction doit retourner un buffer contenant les données ajoutées au dossier patient par CerfaDoc lors d'un appel à CDI_DataExtSet


CerfaDoc Kit - CDI_DataExtSet

CDI_DataExtSet

void CDI_IMP(CDI_DataExtSet) (CDI_REF ref,char *data);
Routine de stockage des données non structurée (champs additionnels de CerfaDoc)
La DLL doit stocker ces données "opaques" dans la dossier patient et devra les retourner lors d'un appel à CDI_DataExtSet
ref : Référence sur l'élément à interroger (patient, recette, dépense)
*data : Données à stocker, sous forme de chaine texte terminée par un \0


CerfaDoc Kit - CDI_PatientsList

CDI_PatientsList

LPCDI_REF CDI_IMP(CDI_PatientsList) (unsigned int *nb_enreg,int class);
Retourne une liste de tous les patients du cabinet
nb_enreg : à remplir avec le nombre de patients
class : classement à effectuer de la liste
0 : liste dans l'ordre alphabetique de nom+prenom
1 : liste dans l'ordre des N° de dossier
2 : liste dans l'ordre des références de dossiers
retour : pointeur sur un buffer de CDI_REF, chaque entrée correspond à une référence à un patient.
Chaque référence sera convertie par CDI_PatientRef avant d'être envoyée à une fonction type CDI_DataGet
Le buffer sera libéré par CDI_Free


CerfaDoc Kit - CDI_PatientRef

CDI_PatientRef

CDI_REF CDI_IMP(CDI_PatientRef) (CDI_REF index);
Convertit une référence retournée par CDI_PatientList en une référence utilisable par CDI_DataGet
index : index retourné dans une liste de patient
retour : entrée correspondant à un patient

Cette fonction convertit une référence de patient obtenue par CDI_PatientFind ou CDI_PatientList en une référence utilisable par les fonctions CDI_DataGet ou CDI_DataGet2
La référence passée en entrée peut être temporaire et différente pour un même patient à chaque appel de CDI_PatientFind ou CDI_PatientList (par ex un offset dans un fichier de données), car CerfaDoc appellera systématiquement CDI_PatientRef avant d'utiliser les données. La référence retournée par CDI_PatientRef doit par contre être fixe et sera utilisée lors de modification ou de recherche pour identifier le patient. Si cette référence est ammenée à changer (par ex lors du transfert d'un dossier d'un cabinet à un autre), il est nécessaire de raffraichir l'enregistrement CerfaDoc.
Une des possibilités est d'utiliser le nom du patient comme référence (celà est possible par l'option CDI_OPT_GET_N_PAT_FROM_NAME).

Quelque soit le type de référence utilisé, il doit être unique pour un même patient et parmi tous les patients.

En résumé :

  • Dans le cas où l'on utilise des N° de dossiers, il faut traiter le cas où l'on change ce numéro pour passer d'un cabinet à un autre par exemple
  • Dans le cas où l'on utilise le nom du patient, il faut traiter le cas des homonymes


CerfaDoc Kit - CDI_PatientFind

CDI_PatientFind

CDI_REF CDI_IMP(CDI_PatientFind) (char *nom,char *prenom,int browse);
Retourne une référence sur un patient recherché suivant le nom et prénom du patient
nom : nom du patient
prenom : prenom du patient
browse : à 1 indique que l'on doit donner l'entrée suivant la référence donnée par nom et prénom en suivant l'ordre alphabétique. A 0 retourne la ref exacte ou 0 si non existant
retour : entrée correspondant à un patient, devra être convertie par CDI_PatientRef

Cette fonction permet d'obtenir une référence sur un patient en donnant son nom et son prénom. Il s'agit d'une recherche sur une clé de recherche. Cette fonction est tuilisée par CerfaDoc entre autre pour la boite de saisie de nom de patient. La valeur retournée sera convertie par CDI_PatientRef par CerfaDoc avant d'être utilisée


CerfaDoc Kit - CDI_PatientCreate

CDI_PatientCreate

int CDI_IMP(CDI_PatientCreate) (char *nom,char *prenom,CDI_REF *ref);
Crée un patient dans la base s'il n'existe pas. Retourne son identifiant dans *ref
name : nom du patient
prenom : prenom du patient
ref : référence à renseigner avec le N° du dossier créé ou trouvé
retour : TRUE si le patient a été crée ou trouvé. FALSE en cas d'erreur


CerfaDoc Kit - CDI_DepensesList

CDI_DepensesList

CDI_REF* CDI_IMP(CDI_DepensesList) (unsigned int *nb_enreg,int class);
Retourne une liste de dépenses
nb_enreg : à remplir avec le nombre de dépenses
class : classement à effectuer de la liste
0 : classement naturel
retour : pointeur sur un buffer de CDI_REF, chaque entrée correspond à une référence à une dépense
le buffer sera libéré par CDI_Free

CerfaDoc appelle cette fonction pour obtenir une liste de toutes les dépenses de l'utilisateur en cours


CerfaDoc Kit - CDI_RecettesList

CDI_RecettesList

CDI_REF* CDI_IMP(CDI_RecettesList) (unsigned int *nb_enreg,int class);
Retourne une liste de recettes
nb_enreg : à remplir avec le nombre de recettes
class : classement à effectuer de la liste
0 : classement naturel
retour : pointeur sur un buffer de CDI_REF, chaque entrée correspond à une référence à une recette
le buffer sera libéré par CDI_Free


CerfaDoc Kit - CDI_CourrierNew

CDI_CourrierNew

int CDI_IMP(CDI_CourrierNew) (char *dest,char *exp,CDI_REF no_pat,int recu,SYSTEMTIME *datetime,char *txt);
Ajoute un courrier
dest : nomdu destinataire du courrier
datetime : date/heure de réalisation du courrier
txt : texte du courrier en HTML
retoru : TRUE en cas de succès, FALSE en cas d'erreur


CerfaDoc Kit - CDI_GetRecordInfo

CDI_GetRecordInfo

int CDI_IMP(CDI_GetRecordInfo) (CDI_RECORD_EXT *data,unsigned int opt,int *ret,char *txt,int max);
Récupère une information à partir de la structure de donnée opaque CDI_RECORD_EXT d'un enregistrement CerfaDoc
data : entrée extension obtenue ou crée
opt : option parmi CDI_RECORD_xxx, une option non gérée doit retourner FALSE et ne pas modifier les buffers
*ret : valeur de retour si l'option est NUMERIQUE
txt : chaine à remplir si l'option est une CHAINE, on ne doit pas remplir plus de max octets, 0 terminal compris
max : taille du buffer dispo pour la chaine de retour
retour : TRUE en cas de succès, FALSE si l'option n'a pas été traitée

CerfaDoc appelle cette fonction pour obtenir une donnée depuis les données "data_orig" et "data_orig_len" de la structure CDI_RECORD_EXT
La DLL a stocké ces données lors d'un appel à CDI_RecordReadNext et doit lors de l'appel à CDI_GetRecordInfo extraire la donnée demandée

Selon le type de la donnée retournée (voir les constantes CDI_RECORD_xxx), il faut utiliser :

Type | Elément à utiliser | Exemple en C
CHAINE *data

*data=(char*)malloc(10);
strcpy(*data,"Ma chaine");
ou
static char buffer[1000];
*data=buffer;
strcpy(*data,"Ma chaine");
NUM | *nb | *nb=1234
SYSTEMTIME (SYSTEMTIME*)*data

SYSTEMTIME *st;
st=(SYSTEMTIME*)malloc(sizeof(SYSTEMTIME));
memset(st,0,sizeof(SYSTEMTIME));
st->wHour=12;
st->wMinute=10;
*data=(char*)st;
ou
static SYSTEMTIME st={0};
st.wHour=12;
st.wMinute=10;
*data=(char*)&st;


CerfaDoc Kit - CDI_SetRecordInfo

CDI_SetRecordInfo

void CDI_IMP(CDI_SetRecordInfo) (CDI_RECORD_EXT *data,unsigned int opt,int val,char *txt);
Stocke une information dans la structure de donnée opaque CDI_RECORD_EXT d'un enregistrement CerfaDoc
data : entrée extension obtenue ou crée
opt : option parmi CDI_RECORD_xxx, une option non gérée doit retourner FALSE et ne pas modifier les buffers
*ret : valeur de retour si l'option est NUMERIQUE
txt : chaine à remplir si l'option est une CHAINE, on ne doit pas remplir plus de max octets, 0 terminal compris

CerfaDoc appelle cette fonction pour modifier une donnée contenue dans"data_orig" et "data_orig_len" de la structure CDI_RECORD_EXT
La DLL a stocké ces données lors d'un appel à CDI_RecordReadNext et doit lors de l'appel à CDI_SetRecordInfo modifier la donnée demandée

Selon le type de la donnée envoyée (voir les constantes CDI_RECORD_xxx), il faut utiliser :

Type Elément à utiliser Exemple en C
CHAINE txt

char donnee_interne[1000];
strcpy(donnee_interne,txt);
NUM val int nb_interne;
nb_interne=nb
SYSTEMTIME (SYSTEMTIME*)txt

SYSTEMTIME st;
memcpy((char*)&st,txt,sizeof(SYSTEMTIME));


CerfaDoc Kit - CDI_RecordExtCreate

CDI_RecordExtCreate

void CDI_IMP(CDI_RecordExtCreate) (CDI_RECORD_EXT *ext);
Crée/Alloue un ensemble de données CDI_RECORD_EXT vide
ext : strcture à initialiser

Cette fonction est appelée par CerfaDoc lorsqu'il crée un nouvel enregistrement. Elle doit initialiser une structure CDI_RECORD_EXT avec des données vides valides. Celà peut consister à allouer des données, ou bien ne rien effectuer si rien n'est nécessaire


CerfaDoc Kit - CDI_RecordExtFree

CDI_RecordExtFree

void CDI_IMP(CDI_RecordExtFree) (CDI_RECORD_EXT *ext);
Libère les données CDI_RECORD_EXT
ext : donnée à libérer

Cette fonction est appelée par CerfaDoc lorsqu'il n'utilise plus les données CDI_RECORD_EXT d'un enregistrement. Cette fonction doit donc désallouer toutes les données présentes dans cette structure (si nécessaire)


CerfaDoc Kit - CDI_RecordsList

CDI_RecordsList

LPCDI_REF CDI_IMP(CDI_RecordsList) (unsigned int *nb_enreg,int class);
Retourne une liste de tous les enregistrements CerfaDoc de tous les dossiers. Il peut y avoir parmi cette liste des enregistrements non CerfaDoc
nb_enreg : à remplir avec le nombre d'enregistrements CerfaDoc
class : classement à effectuer de la liste
0 : classement naturel
retour : pointeur sur un buffer de CDI_REF, chaque entrée correspond à une référence à un enregistrement CerfaDoc
le buffer sera libéré par CDI_Free

Cette fonction est appelée par CerfaDoc pour obtenir une liste de tous les enregistrements CerfaDoc du cabinet. Elle est principalement utilisée pour la regénération de CerfaDoc et pour les formulaires effectuant une recherche sur tous les enregistrements


CerfaDoc Kit - CDI_RecordOpen

CDI_RecordOpen

CDI_HDLE_RECORD CDI_IMP(CDI_RecordOpen) (CDI_REF no_pat,SYSTEMTIME *datetime,int opt);
ouvre une session de recherche d'éléments CerfaDoc
no_pat : référence sur le patient (retournée par CDI_PatientRef par ex)
datetime : date et heure de l'enregistrement à chercher (seuls année, mois, jour, heure, minute, seconde sont utilisés)
si NULL, cherche séquentiellement les éléments dans le dossier patient (l'ordre n'est pas défini)
opt : une ou plusieurs option CDI_REC_OPEN_xxx

Permet à CerfaDoc de débuter une session de recherche d'un enregistrement CerfaDoc. opt indique une option parmi CDI_REC_OPEN_xxx.
La recherche sera terminée par un appel à CDI_RecordClose


CerfaDoc Kit - CDI_RecordClose

CDI_RecordClose

int CDI_IMP(CDI_RecordClose) (CDI_HDLE_RECORD hdle);
termine une session de recherche, doit libérer toutes les données
hdle : handle sur la session


CerfaDoc Kit - CDI_RecordCount

CDI_RecordCount

unsigned int CDI_IMP(CDI_RecordCount) (CDI_HDLE_RECORD hdle,unsigned int *cur);
retourne le nombre total d'enregistrements CerfaDoc pour le dossier en cours, ce nombre peut contenir d'autres enregistrements que les
enregistrements CerfaDoc.
hdle : handle sur la session
*cur : si non NULL doit être rempli avec le N° du prochain enregistrement à lire dans la séquence, cet enregistrement n'est pas obligé d'être un
enregistrement CerfaDoc

Cette fonction doit effectuer un comptage explicite de toutes les clé de recherche pour tous les enregistrements CerfaDoc pour le dossier en cours. Cette opération est séparée au cas où elle prendrait plus de temps


CerfaDoc Kit - CDI_RecordJump

CDI_RecordJump

void CDI_IMP(CDI_RecordJump) (CDI_HDLE_RECORD hdle,CDI_REF ref);
se déplace dans la liste des enregistrements à l'index donné par ref, cet index peut être tiré de CDI_RecordsList
hdle : handle sur la session
ref : index vers lequel aller

Cette fonction est appelée par CerfaDoc dans une session de recherche ouverte avec l'option CDI_REC_OPEN_EMPTY pour se positionner sur l'enregistrement à lire


CerfaDoc Kit - CDI_RecordReadNext

CDI_RecordReadNext

int CDI_IMP(CDI_RecordReadNext) (CDI_HDLE_RECORD hdle,char **data,CDI_RECORD_EXT *ext,int opt);
cherche un enregistrement CerfaDoc
Si la session a été ouverte en browse, retourne le prochain élément dans *data et TRUE en valeur de retour, retourne FALSE en fin de liste
Si la session n'a pas été ouverte en browse, retourne l'élément selectionné et TRUE ou FALSE, s'il est ou non trouvé
hdle : handle sur la session
*data : doit recevoir un buffer alloué avec les données de l'enregistrement (données de data_raw) (si pas d'erreur, NULL sinon)
*ext : doit être complété avec les données extérieures (données opaques CerfaDoc concernant l'enregistrement et données autres de l'enregistrement)
ces données seront désallouée par CDI_RecordExtFree. ext peut être NULL
opt : options de récupération CDI_RECORD_EXT_xx, au moins ces éléments doivent être récupérés. Il peuvent être systématiquement tous récupérés
Les buffers alloués peuvent être libérés lors d'un nouvel appel à CDI_RecordReadNext ou CDI_RecordClose
Les buffers alloués pour CDI_RECORD_EXT doivent être désalloué manuellement par CDI_RecordFreeExt

Cette fonction permet à CerfaDoc de lire l'enregistrement suivant dans une session de recherche. Selon les options passées dans opt (de type CDI_RECORD_EXT_xxx), un ou plusieurs champs de ext doivent être remplis.
Les données à retourner sont les suivantes :

Nom | Description
*data | Données brutes de CerfaDoc. Ces données écrites et lues par CerfaDoc sont les données internes du formulaire. La DLL doit normalement les stocker et les retourner telles quelle sans modification. Le contenu de ces données est documenté dans l'aide de CerfaDoc (rubrique Annexe A-Stockage dans HD). Ce buffer doit être terminé par un caractère NULL (0)
"ext.data_html" | Doivent être lu si opt contient CDI_RECORD_EXT_HTML. Données du résumé HTML du formulaire. Ces données doivent obligatoirement être stockées, elle peuvent servir d'aperçu du formulaire. Il est également possible d'avoir un aperçu du PDF résultant via l'utilisation directe de cdi_core.dll. Ces données servent également d'identifiant unique du formulaire. Enfin ces données assurent une trace du formulaire que l'accès à CerfaDoc soit opérationnel ou non. Ce buffer doit être terminé par un caractère NULL (0)
"ext.data_txt" | Doivent être lu si opt contient CDI_RECORD_EXT_TXT. Dans le cas où l'on choisit d'avoir le résumé texte séparé (option CDI_OPT_ENREG_TXT), données du résumé texte. . Ce buffer doit être terminé par un caractère NULL (0)
"ext.data_orig" et "ext.data_orig_len" | Doivent être lu si opt contient CDI_RECORD_EXT_DOSSIER. Ce sont les données opaques de l'enregistrement fournies par CDI_RecordReadNext qui seront stockées par CDI_RecordNew. Ces données peuvent être interrogées entre temps par CDI_GetRecordInfo et modifiées par CDI_SetRecordInfo.
"ext.data_orig2" | Doivent être lu si opt contient CDI_RECORD_EXT_OTHER. Ce sont des données fournies par CDI_RecordReadNext et qui seront représentées à CDI_RecordNew. . Ce buffer doit être terminé par un caractère NULL (0)
"ext.datetime" | Date et heure de l'enregistrement
"ext.no_pat" | N° de patient de l'enregistrement


CerfaDoc Kit - CDI_RecordNew

CDI_RecordNew

int CDI_IMP(CDI_RecordNew) (CDI_ENREG *enreg);
Ajoute un enregistrement CerfaDoc
enreg : contient toutes les données pour créer l'enregistrement
retour : TRUE en cas de succès, FALSE sinon

Cette fonction est appelée par CerfaDoc pour ajouter un enregistrement CerfaDoc dans la base de donnée associée. La structure CDI_ENREG contient toutes les données à conserver :

typedef struct{
char *form_nom; // Nom du formulaire (chaine texte)
char *form_type; // Type de formulaire (chaine texte)
// Données
int form_boutons; // Indique que ce formulaire a les commandes classiques de la inplace bar
char *data_raw; // Données brutes CerfaDoc
int data_raw_len; // Longueur des données brutes CerfaDoc
char *data_html; // Données résumé HTML
int data_html_len; // Longueur des données résumé HTML
char *data_txt; // Données résumé texte (si option texte activée : CDI_OPT_ENREG_TXT)
int data_txt_len; // Longueur des données résumé texte
char *data_recover; // Données recover HTML
int data_recover_len; // Longueur des données recover HTML
// Données Dossier
CDI_REF n_dos; // N° de dossier
CDI_RECORD_EXT ext; // Données du dossier
}CDI_ENREG;

Les champs "form_name" et "form_type" indique le nom et le type de formulaire stocké. Ce nom peut être utilisé comme "titre" de l'enregistrement par ex sous la forme form_nom(form_type).
"form_bouttons" : à 1 indique que le formulaire contient le lien vers la barre de controle ActiveX permettant de modifier, imprimer, renouveler l'enregistrement
Les données à stocker sont les suivantes

Nom | Description
"data_raw" et "data_raw_len" | Données brutes de CerfaDoc. Ces données écrites et lues par CerfaDoc sont les données internes du formulaire. La DLL doit normalement les stocker et les retourner telles quelle sans modification. Le contenu de ces données est documenté dans l'aide de CerfaDoc (rubrique Annexe A-Stockage dans HD)
"data_html" et "data_html_len" | Données du résumé HTML du formulaire. Ces données doivent obligatoirement être stockées, elle peuvent servir d'aperçu du formulaire. Il est également possible d'avoir un aperçu du PDF résultant via l'utilisation directe de cdi_core.dll. Ces données servent également d'identifiant unique du formulaire. Enfin ces données assurent une trace du formulaire que l'accès à CerfaDoc soit opérationnel ou non
"data_txt" et "data_txt_len" | Dans le cas où l'on choisit d'avoir le résumé texte séparé (option CDI_OPT_ENREG_TXT), données du résumé texte.
"data_recover" et "data_recover_len" | Ces données peuvent être ou non utilisées, elles permettent d'afficher en HTML via le controle ActiveX, un message invitant à cliquer pour "récupérer" un enregistrement endommagées. La récupération consiste à effectuer un réenregistrement du formulaire
n_dos | N° de dossier dans lequel sotcker les données
ext | Structure donnant les données étendues à stocker (voir description dans Options pour CDI_RecordReadNext) "data_orig" et "data_orig_len" sont les données opaque de l'enregistrement fournies par CDI_RecordReadNext qui doivent être stockées par CDI_RecordNew. Ces données ont été interrogées entre temps par CDI_GetRecordInfo et modifiées par CDI_SetRecordInfo. "data_orig2" sont des données fournies par CDI_RecordReadNext et qui doivent être restockées si nécessaire "data_html" et "data_txt" ne sont pas remplies et ne doivent pas être utilisées. "datetime" indique à quelle date doit être effectuée l'enregistrement "no_pat" indique pour quel patient effectuer l'enregistrement


CerfaDoc Kit - CDI_RecordDelete

CDI_RecordDelete

void CDI_IMP(CDI_RecordDelete) (CDI_RECORD_EXT *ext);
Efface un enregistrement référencé par son CDI_RECORD_EXT (on peut stocker une référence dans ext->user_param lors d'un accès CDI_RecordReadNext)
*ext : données étendue de l'enregistrement, seule la partie commune est forcément présente

Cette fonction doit effacer un enregistrement CerfaDoc. Elle est utilisée lorsque l'enregistrement est indiqué comme étant ancien par "old" (ext->old==1). Ce mécanisme permet d'assurer une migration des enregistrements au fur et à mesure de leur modification ou lors d'une regénération. Le champ "user_param" peut être utilisé pour stocker une information (index, offset etc) lors de l'appel à CDI_RecordReadNext qui sera utilisée ensuite lors d'un appel à CDI_RecordDelete


CerfaDoc Kit - CDI_Free

CDI_Free

void CDI_IMP(CDI_Free) (void *data,int type,int len);
data : donnée à libérer
type : type de données à libérer parmi CDI_DATA_xxx
len : longueur du tableau dans le cas de liste retournée par CDI_PatientList par ex

CerfaDoc appelle cette fonction lorsqu'il n'a plus besoin des données de l'élément en question. Il fournit également la taille de cet élément lorsqu'il s'agit d'un tableau et le type de ponnée par une constante de type CDI_DATA_xxx


CerfaDoc Kit - CDI_GetAllocInfo

CDI_GetAllocInfo

int CDI_IMP(CDI_GetAllocInfo) (char *fic,DWORD *page);
Retourne le nom du fichier source ayant effectué la dernière allocation et le numero de ligne
fic : nom du fichier ("" si aucun)
retour : N° de lgine


CerfaDoc Kit - x

x

fine CDI_IMP(x) (*x)


CerfaDoc - Liste des constantes

Liste des constantes

Constante | Valeur | Commentaire
CDI_IMP_INCLUDED |  |
CDI_IMP(x) | x | //__declspec(dllexport) x
CDI_IMP(x) | (*x) |
En tête
CDI_VERSION | 1 | // Version en cours de l'interface
Options pour CDI_CabinetOpen
CDI_OPEN_CABINET_OK | 0 |
CDI_OPEN_CABINET_NEED_UPDATE | 1 |
CDI_OPEN_CABINET_ERROR | 2 |
Format d'enregistrement
CDI_FORMAT_PROPRIETAIRE | 0 | // Format d'enregistrement propriétaire, compact. Doc disponible
CDI_FORMAT_XML | 1 | // Format d'enregistrement XML
Options pour CDI_GetOption
CDI_OPT_VERSION | 0 | // NUM : N° de version d'interface (doit être retourné)
CDI_OPT_NAME | 1 | // CHAINE : Retourne le nom résumé de la DLL (ex "HD") (par défaut : nom de la DLL)
CDI_OPT_NAME_DETAIL | 2 | // CHAINE : Retourne le nom détaillé de la DLL ("interface HelloDOC, version 5.60") (par défaut : nom de la DLL)
CDI_OPT_ENREG_BAR | 3 | // NUM : A 1, inclus une barre sous forme d'active X dans l'enregistrement HTML, cette barre permet de réouvir,
CDI_OPT_ENREG_TXT | 4 | // NUM : A 1, fournit un enregistrement texte séparé, à 0 : laisse la possibilité de l'inclure dans le HTML
CDI_OPT_GLOBAL_ERROR | 5 | // NUM : A 1, indique qu'une erreur s'est produit lors de l'accès aux données. La lecture de ce flag le remet à 0 (après lecture)
CDI_OPT_GET_N_PAT_FROM_NAME | 6 | // NUM : A 1, indique que le N° du patient peut être récupéré à partir du nom
CDI_OPT_CERTIFICATION | 7 | // NUM : Doit indiquer le N° associé à la certification pour être considérée comme certifiée
CDI_OPT_CMD_STRING | 8 | // CHAINE : Permet de modifier la chaine passée en ligne de commande.
CDI_OPT_BOUCLE | 9 | // NUM : A 1, redémarre CerfaDoc
CDI_OPT_PARENT_WIN | 10 | // NUM : Indique que CerfaDoc doit prendre la valeur retournée comme HWND parent
CDI_OPT_CREATE_DOSSIER | 11 | // NUM : A 1, demande à CerfaDoc de créer le dossier s'il n'existe pas
CDI_OPT_ENREG_FORMAT | 12 | // NUM : Format des enregistrements CerfaDoc CDI_FORMAT_xxx
CDI_OPT_ENREG_EXT_FORMAT | 13 | // NUM : Format des données patients CDI_FORMAT_xxx
CDI_OPT_CMD_REQ_STRING | 14 | // CHAINE(in) NUM(out) : Indique qu'une nouvelle instance de CerfaDoc est demandée avec cette chaine d'option
CDI_OPT_ALLOW_PAT_EMPTY | 15 | // NUM : Par défaut : 0 A 1, autorise à avoir un nom de patient vide (utilisé avec CREATE_DOSSIER), par défaut 0
CDI_OPT_IS_SAME_PROCESS | 16 | // NUM : Par défaut : 0 A 1, indique que la prévisualisation est effectuée dans le même process (donc en sortie de la prévisu, on ne ferme pas tout ...)
CDI_OPT_EMBED_WINDOW | 17 | // NUM : Par défaut : 0 A 1, indique que la fenêtre principale de choix de formulaire est 'réduite' (pas de menu, etc)
CDI_OPT_UPDATE_PROG_ADD | 18 | // CHAINE : Retourne le répertoire pour l'update programme
CDI_OPT_CONFIG_RAC | 19 | // NUM : Est-il possible de créer un raccourci ?
CDI_OPT_HKEY_USER | 20 | // NUM : Force une clé spécifique pour HKEY_CURRENT_USER (installation en mode administrateur)
CDI_OPT_STORE_PDF | 21 | // CHAINE : Retourne le répertoire dans lequel stocker le PDF (si demandé)
CDI_OPT_SET_TEXT | 22 | // CHAINE : Indique la description de ce que l'on stocke
CDI_OPT_CERTIFICATION_TRACE | 23 | // CHAINE : Retourne les traces de la certification
Options pour CDI_GetRecordInfo/CDI_SetRecordInfo
CDI_RECORD_RECU | 1 | // NUM : Indique si le document a été reçu (1) ou envoyé (0)
CDI_RECORD_WARNING | 2 | // NUM : Indique un niveau d'alerte (0 à 10)
CDI_RECORD_DATE_DOCUMENT | 3 | // SYSTEMTIME : Retourne la date du document (sous forme d'une structure SYSTEMTIME), seule jour, mois, année est utilisé
CDI_RECORD_DESTINATAIRE | 4 | // CHAINE : Destinataire de l'enregistrement
CDI_RECORD_EXPEDITEUR | 5 | // CHAINE : Expediteur de l'enregistrement
CDI_RECORD_INFORMATION | 6 | // CHAINE : Information sur l'enregistrement
CDI_RECORD_DATE_ENREG | 7 | // SYSTEMTIME : Retourne la date de l'enregistrement, sert de clé d'identification, jour,mois,année,heure, minute,seconde
CDI_RECORD_USER | 8 | // CHAINE : Utilisateur
CDI_RECORD_DATE_ENREG_REMOVE | 9 | // SYSTEMTIME : Date de l'enregistrement à remplacer (si modification et date différente), sert de clé d'identification, jour,mois,année,heure, minute,seconde
Options pour CDI_RecordReadNext
CDI_RECORD_EXT_DOSSIER | 1 | // Récupérer les données dossier
CDI_RECORD_EXT_OTHER | 2 | // Récupérer les autres données
CDI_RECORD_EXT_HTML | 4 | // Récupérer les données du résumé HTML
CDI_RECORD_EXT_TXT | 8 | // Récupérer les données du résumé texte
Options pour CDI_RecordOpen
CDI_REC_OPEN_NO_SEARCH | 1 | // indique que l'on ne doit pas faire une recherche avancée (archive, enreg perdu, etc)
CDI_REC_OPEN_BROWSE | 2 | // indique que l'on doit rechercher tous les éléments du dossier (pas uniquement celui référencé)
CDI_REC_OPEN_EMPTY | 4 | // indique qu'aucun élément n'est selectionné par défaut pour la session de recherche
CDI_REC_OPEN_NO_NAG | 8 | // indique qu'aucun message ne doit être affiché dans ce mode, la DLL doit prendre elle même les décisions
Options pour CDI_DataGet
CDD_PATIENT_NOM | 0 | // CHAINE : Patient : Nom
CDD_PATIENT_PRENOM | 1 | // CHAINE : Patient : Prénom
CDD_PATIENT_ADRESSE | 2 | // CHAINE : Patient : Adresse (N° de rue, rue, etc, hors code postal et ville)
CDD_PATIENT_CODE_POSTAL | 3 | // CHAINE : Patient : Code postal
CDD_PATIENT_VILLE | 4 | // CHAINE : Patient : Ville
CDD_PATIENT_LIEU_NAISSANCE | 5 | // CHAINE : Patient : Lieu de naissance
CDD_PATIENT_TELF_PERSO | 6 | // CHAINE : Patient : Téléphone fixe personnel
CDD_PATIENT_TELF_PRO | 7 | // CHAINE : Patient : Téléphone fixe professionnel
CDD_PATIENT_NUM_SS | 8 | // CHAINE : Patient : N° de sécurité sociale (les espaces seront ignorés et remis en forme)
CDD_PATIENT_DATE_NAI | 9 | // SYSTEMTIME : Patient : Date de naissance patient (jour, mois, année utilisés)
CDD_PATIENT_RANG_GEM | 10 | // NUM : Patient : Rang gémellaire
CDD_PATIENT_TAILLE | 12 | // NUM : Patient : Taille (en cm)
CDD_PATIENT_POIDS | 13 | // NUM : Patient : Poids (en g)
CDD_PATIENT_SEXE | 14 | // NUM : Patient : 0:Homme, 1:Femme
CDD_PATIENT_SIT_FAM | 15 | // NUM : Patient : 0:Celibataire, 1:Marié, 2:Divorcé(e), 3:Veuf(ve), 4:Cocubin(e), 5:Parent célibataire)
CDD_PATIENT_CAISSE_PRIMAIRE_NOM | 16 | // CHAINE : Patient : Nom de la caisse primaire d'assurance maladie
CDD_PATIENT_CAISSE_COMPLEMENTAIRE_NOM | 17 | // CHAINE : Patient : Nom de la caisse complémentaire d'assurance maladie
CDD_PATIENT_NOM_JF | 18 | // CHAINE : Patient : Nom de jeune fille
CDD_PATIENT_EXT_LIBELLE | 19 | // CHAINE : Patient : Libellé des champs d'extension
CDD_PATIENT_EXT_DONNEE | 20 | // CHAINE : Patient : Donnée des champs d'extension
CDD_PATIENT_DOSSIER_REF | 21 | // CHAINE : Patient : Référence de dossier papier
CDD_PATIENT_SV_REGIME_CODE | 22 | // NUM : Patient : N° de Code du régime
CDD_PATIENT_SV_CAISSE_GESTION | 23 | // NUM : Patient : N° Caisse du régime
CDD_PATIENT_SV_CENTRE_GESTION | 24 | // NUM : Patient : N° Centre du régime
CDD_MEDECIN_NOM | 25 | // CHAINE : Médecin : Nom et prénom du médecin SANS le titre !
CDD_MEDECIN_IDNAT | 26 | // CHAINE : Médecin : Identifiant national du médecin SANS la clé
CDD_PATIENT_GROSSESSE_NB_FOETUS | 27 | // NUM : Patient : Grossesse : Nombre de foetus
CDD_PATIENT_GROSSESSE_DATE_REGLE | 28 | // SYSTEMTIME : Patient : Grossesse : Date des dernières règles
CDD_PATIENT_GROSSESSE_DATE_CONCEPTION | 29 | // SYSTEMTIME : Patient : Grossesse : Date de conception
CDD_PATIENT_GROSSESSE_FLAG_ECHO | 30 | // NUM : Patient : Grossesse : Flag echographie, à 1 si une echographie a été faite
CDD_PATIENT_GROSSESSE_DATE_ECHO | 31 | // SYSTEMTIME : Patient : Grossesse : Date d'échographie
CDD_PATIENT_TEL_MOBILE_PERSO | 32 | // CHAINE : Patient : N° de téléphone mobile personnel
CDD_PATIENT_TEL_MOBILE_PRO | 33 | // CHAINE : Patient : N° de téléphone mobile professionnel
CDD_PATIENT_EMAIL_PERSO | 34 | // CHAINE : Patient : Email personnel
CDD_PATIENT_EMAIL_PRO | 35 | // CHAINE : Patient : Email professionnel
CDD_PATIENT_RAW | 36 | // CHAINE : Patient : Données brutes texte, [DEBUG only]. A des fins de debug retourne le maximum de données texte concernant le dossier patient
CDD_PATIENT_ATCD_CHIRURGIE | 37 | // CHAINE : Patient : Antécédants chirugicaux format RTF
CDD_PATIENT_ATCD_MEDICAL | 38 | // CHAINE : Patient : Antécédants médicaux format RTF
CDD_PATIENT_ATCD_FAMILLE | 39 | // CHAINE : Patient : Antécédants familliaux format RTF
CDD_PATIENT_ATCD_ALLERGIE | 40 | // CHAINE : Patient : Antécédants allergiques format RTF
CDD_PATIENT_ATCD_INTOLERANCE | 41 | // CHAINE : Patient : Antécédants intolérances format RTF
CDD_PATIENT_ATCD_GYNECOLOGIE | 42 | // CHAINE : Patient : Antécédants gynécologiques format RTF
CDD_PATIENT_ATCD_OBSTETRIE | 43 | // CHAINE : Patient : Antécédants obstétricaux format RTF
CDD_PATIENT_ATCD_CIPATHOLOGIES | 44 | // CHAINE : Patient : Antécédants contre indication pathologiques format RTF
CDD_PATIENT_ATCD_CIALLERGIES | 45 | // CHAINE : Patient : Antécédants contre indication allergiques format RTF
CDD_PATIENT_ATCD_CIPRECAUTIONS | 46 | // CHAINE : Patient : Antécédants contre indication précautions format RTF
CDD_PATIENT_ATCD_CIPRECAUTIONSLIBRE | 47 | // CHAINE : Patient : Antécédants contre indication précautions (texte libre) format RTF
CDD_PATIENT_ATCD_ALARME_CHIRURGIE | 48 | // NUM : Patient : Antécédants chirurgicaux (alarme)
CDD_PATIENT_ATCD_ALARME_MEDICAL | 49 | // NUM : Patient : Antécédants médicaux (alarme)
CDD_PATIENT_ATCD_ALARME_FAMILLIAL | 50 | // NUM : Patient : Antécédants familliaux (alarme)
CDD_PATIENT_ATCD_ALARME_ALLERGIE | 51 | // NUM : Patient : Antécédants allergiques (alarme)
CDD_PATIENT_ATCD_ALARME_INTOLERANCE | 52 | // NUM : Patient : Antécédants intolérances (alarme)
CDD_PATIENT_ATCD_ALARME_GYNECOLOGIE | 53 | // NUM : Patient : Antécédants gynécologiques (alarme)
CDD_PATIENT_ATCD_ALARME_OBSTETRIE | 54 | // NUM : Patient : Antécédants obstétricaux (alarme)
CDD_PATIENT_ATCD_ALARME_CIPATHOLOGIES | 55 | // NUM : Patient : Antécédants contre indication pathologiques (alarme)
CDD_PATIENT_ATCD_ALARME_CIALLERGIES | 56 | // NUM : Patient : Antécédants contre indication allergiques (alarme)
CDD_PATIENT_ATCD_ALARME_CIPRECAUTIONS | 57 | // NUM : Patient : Antécédants contre indication précautions (alarme)
CDD_DEPENSE_DATE | 58 | // SYSTEMTIME : Depenses : Date de la dépense
CDD_DEPENSE_CODE | 59 | // CHAINE : Depenses : Code de la dépense
CDD_DEPENSE_COMPTE | 60 | // CHAINE : Depenses : Compte auquel est affecté la dépense
CDD_DEPENSE_LIBELLE | 61 | // CHAINE : Depenses : Libelle attaché à la dépense
CDD_DEPENSE_MODE | 62 | // CHAINE : Depenses : Mode de paiement de la dépense
CDD_DEPENSE_TOTAL | 63 | // DOUBLE : Depenses : Valeur de la dépense en euros
CDD_RECETTE_DATE | 64 | // SYSTEMTIME : Recettes : Date de la recette
CDD_RECETTE_DATE_PAIE | 65 | // SYSTEMTIME : Recettes : Date de paiement de la recette
CDD_RECETTE_MODE | 66 | // CHAINE : Recettes : Mode de paiement de la recette
CDD_RECETTE_TOTAL | 67 | // DOUBLE : Recettes : Valeur totale de la recette en euros
CDD_RECETTE_VALUE | 68 | // DOUBLE : Recettes : Valeur d'un élément de la recette en euros
CDD_FORM_DATE | 69 | //E // SYSTEMTIME : Formulaire : Date du formulaire
CDD_FORM_NB_LIGNES | 70 | //E // NUM : Formulaire : Nombre de lignes du formulaire
CDD_FORM_LIGNE_FROM_STR | 71 | //E // NUM : Formulaire : Retourne un N° de ligne à partir de str1 (ligne nommée str1)
CDD_FORM_DATA | 72 | //E // CHAINE : Formulaire : Retourne la donnée située sur nlig et ncol
CDD_FORM_COUNT | 73 | // NUM : Formulaire : Nombre d'enregistrements de formulaires pour ce patient
CDD_PEDIA_NB | 74 | // NUM : Pediatrie : Nombre d'enregistrements
CDD_PEDIA_TAILLE | 75 | // DOUBLE : Pediatrie : Enregistrement : Taille en cm
CDD_PEDIA_POIDS | 76 | // DOUBLE : Pediatrie : Poids en kg
CDD_PEDIA_PC | 77 | // DOUBLE : Pediatrie : Perimètre cranien en cm
CDD_PEDIA_DATE | 78 | // SYSTEMTIME : Pediatrie : Date
CDD_NOTE_DATA | 79 | // CHAINE : Notes : Contenu en RTF (HGLOBAL)
CDD_NOTE_DATE | 80 | // SYSTEMTIME : Notes : Date de la note
CDD_NOTE_TITRE | 81 | // CHAINE : Notes : Titre de la note (HGLOBAL)
CDD_LIEN_FAMILLE_REF | 82 | // NUM : Lien famillial : CDI_REF sur le dossier lié
CDD_LIEN_FAMILLE_TYPE | 83 | // CHAINE : Lien famillial : type de lien (texte, ex : fils, fille, père, mère)
CDD_PATIENT_PROFESSION | 84 | // CHAINE : Patient : Profession
CDD_PATIENT_PAYS_NAISSANCE | 85 | // CHAINE : Patient : Pays de naissance
CDD_PATIENT_CODE_POSTAL_NAISSANCE | 86 | // CHAINE : Patient : Code postal de naissance
CDD_RECETTE_USER | 87 | // CHAINE : Recettes : Nom de l'utilisateur
CDD_RECETTE_FSE | 88 | // NUM : Recettes : Est-elle liée à une FSE ?
CDD_RECETTE_REF | 89 | // NUM : Recettes : N° de la fiche
CDD_RECETTE_ACTE | 90 | // CHAINE : Recettes : Code de l'acte
CDD_PATIENT_PHOTO | 91 | // IMAGEBMP : Patient : Photographie (en format BMP)
CDD_MEDECIN_RPPS | 92 | // CHAINE : Médecin : Identifiant national du médecin RPPS
Type de données à libérer
CDI_DATA_RECORD_LIST | 1 | // Donnée fournie par CDI_RecordsList
CDI_DATA_PATIENT_LIST | 2 | // Donnée fournie par CDI_PatientsList
CDI_DATA_DATA_EXT | 3 | // Donnée fournie par CDI_DataExtGet/CDI_DataGet2 (LocalAlloc)
CDI_DATA_RECETTE_LIST | 4 | // Donnée fournie par CDI_RecettesList
CDI_DATA_DEPENSE_LIST | 5 | // Donnée fournie par CDI_DepensesList
CDI_DATA_DATA_EXTG | 6 | // Donnée fournie par CDI_DataExtGet/CDI_DataExtGet/CDI_DataGet2 (GlobalAlloc)
CDI_DATA_USER_LIST | 7 | // Donnée fournie par CDI_UserList
Type d'image
CDI_IMG_INFO_UPDATE | 1 | // Image à afficher dans la boite de mise à jour extérieure (doit expliquer comment lancer CerfaDoc) Taille conseillée : 250x110


CerfaDoc Kit - En tête

En tête

CDI_VERSION 1 // Version en cours de l'interface

Cette constante définit la version d'interface en cours d'utilisation. Ce N° de version doit être retourné dans l'appel à CDI_GetOption avec comme paramètre CDI_OPT_VERSION


CerfaDoc Kit - Options pour CDI_CabinetOpen

Options pour CDI_CabinetOpen

CDI_OPEN_CABINET_OK | 0
CDI_OPEN_CABINET_NEED_UPDATE | 1
CDI_OPEN_CABINET_ERROR | 2

Constante à retourner lors de l'appel à CDI_CabinetOpen.

En cas de problème retourner CDI_OPEN_CABINET_ERROR, dans ce cas CerfaDoc quitte immédiatement. Il est également possible de lancer automatiquement une mise à jour de CerfaDoc (si on detecte par ex que les données sont d'une version plus récente et qu'une mise à jour de CerfaDoc et où de la DLL d''interface est nécessaire)


CerfaDoc Kit - Format d'enregistrement

Format d'enregistrement

CDI_FORMAT_PROPRIETAIRE | 0 | // Format d'enregistrement propriétaire, compact. Doc disponible
CDI_FORMAT_XML | 1 | // Format d'enregistrement XML


CerfaDoc Kit - Options pour CDI_GetOption

Options pour CDI_GetOption

CDI_OPT_VERSION | 0 | // NUM : N° de version d'interface (doit être retourné)
CDI_OPT_NAME | 1 | // CHAINE : Retourne le nom résumé de la DLL (ex "HD") (par défaut : nom de la DLL)
CDI_OPT_NAME_DETAIL | 2 | // CHAINE : Retourne le nom détaillé de la DLL ("interface HelloDOC, version 5.60") (par défaut : nom de la DLL)
CDI_OPT_ENREG_BAR | 3 | // NUM : A 1, inclus une barre sous forme d'active X dans l'enregistrement HTML, cette barre permet de réouvir,
CDI_OPT_ENREG_TXT | 4 | // NUM : A 1, fournit un enregistrement texte séparé, à 0 : laisse la possibilité de l'inclure dans le HTML
CDI_OPT_GLOBAL_ERROR | 5 | // NUM : A 1, indique qu'une erreur s'est produit lors de l'accès aux données. La lecture de ce flag le remet à 0 (après lecture)
CDI_OPT_GET_N_PAT_FROM_NAME | 6 | // NUM : A 1, indique que le N° du patient peut être récupéré à partir du nom
CDI_OPT_CERTIFICATION | 7 | // NUM : Doit indiquer le N° associé à la certification pour être considérée comme certifiée
CDI_OPT_CMD_STRING | 8 | // CHAINE : Permet de modifier la chaine passée en ligne de commande.
CDI_OPT_BOUCLE | 9 | // NUM : A 1, redémarre CerfaDoc
CDI_OPT_PARENT_WIN | 10 | // NUM : Indique que CerfaDoc doit prendre la valeur retournée comme HWND parent
CDI_OPT_CREATE_DOSSIER | 11 | // NUM : A 1, demande à CerfaDoc de créer le dossier s'il n'existe pas
CDI_OPT_ENREG_FORMAT | 12 | // NUM : Format des enregistrements CerfaDoc CDI_FORMAT_xxx
CDI_OPT_ENREG_EXT_FORMAT | 13 | // NUM : Format des données patients CDI_FORMAT_xxx
CDI_OPT_CMD_REQ_STRING | 14 | // CHAINE(in) NUM(out) : Indique qu'une nouvelle instance de CerfaDoc est demandée avec cette chaine d'option
CDI_OPT_ALLOW_PAT_EMPTY | 15 | // NUM : Par défaut : 0 A 1, autorise à avoir un nom de patient vide (utilisé avec CREATE_DOSSIER), par défaut 0
CDI_OPT_IS_SAME_PROCESS | 16 | // NUM : Par défaut : 0 A 1, indique que la prévisualisation est effectuée dans le même process (donc en sortie de la prévisu, on ne ferme pas tout ...)
CDI_OPT_EMBED_WINDOW | 17 | // NUM : Par défaut : 0 A 1, indique que la fenêtre principale de choix de formulaire est 'réduite' (pas de menu, etc)
CDI_OPT_UPDATE_PROG_ADD | 18 | // CHAINE : Retourne le répertoire pour l'update programme
CDI_OPT_CONFIG_RAC | 19 | // NUM : Est-il possible de créer un raccourci ?
CDI_OPT_HKEY_USER | 20 | // NUM : Force une clé spécifique pour HKEY_CURRENT_USER (installation en mode administrateur)
CDI_OPT_STORE_PDF | 21 | // CHAINE : Retourne le répertoire dans lequel stocker le PDF (si demandé)
CDI_OPT_SET_TEXT | 22 | // CHAINE : Indique la description de ce que l'on stocke
CDI_OPT_CERTIFICATION_TRACE | 23 | // CHAINE : Retourne les traces de la certification


CerfaDoc Kit - Options pour CDI_GetRecordInfo/CDI_SetRecordInfo

Options pour CDI_GetRecordInfo/CDI_SetRecordInfo

CDI_RECORD_RECU | 1 | // NUM : Indique si le document a été reçu (1) ou envoyé (0)
CDI_RECORD_WARNING | 2 | // NUM : Indique un niveau d'alerte (0 à 10)
CDI_RECORD_DATE_DOCUMENT | 3 | // SYSTEMTIME : Retourne la date du document (sous forme d'une structure SYSTEMTIME), seule jour, mois, année est utilisé
CDI_RECORD_DESTINATAIRE | 4 | // CHAINE : Destinataire de l'enregistrement
CDI_RECORD_EXPEDITEUR | 5 | // CHAINE : Expediteur de l'enregistrement
CDI_RECORD_INFORMATION | 6 | // CHAINE : Information sur l'enregistrement
CDI_RECORD_DATE_ENREG | 7 | // SYSTEMTIME : Retourne la date de l'enregistrement, sert de clé d'identification, jour,mois,année,heure, minute,seconde
CDI_RECORD_USER | 8 | // CHAINE : Utilisateur
CDI_RECORD_DATE_ENREG_REMOVE | 9 | // SYSTEMTIME : Date de l'enregistrement à remplacer (si modification et date différente), sert de clé d'identification, jour,mois,année,heure, minute,seconde

Ces constantes désignent les données que CerfaDoc peut demander ou modifier pour les données opaques d'un enregistrement lors d'un appel à CDI_GetRecordInfo ou CDI_SetRecordInfo


CerfaDoc Kit - Options pour CDI_RecordReadNext

Options pour CDI_RecordReadNext

CDI_RECORD_EXT_DOSSIER | 1 | // Récupérer les données dossier
CDI_RECORD_EXT_OTHER | 2 | // Récupérer les autres données
CDI_RECORD_EXT_HTML | 4 | // Récupérer les données du résumé HTML
CDI_RECORD_EXT_TXT | 8 | // Récupérer les données du résumé texte


CerfaDoc Kit - Options pour CDI_RecordOpen

Options pour CDI_RecordOpen

CDI_REC_OPEN_NO_SEARCH | 1 | // indique que l'on ne doit pas faire une recherche avancée (archive, enreg perdu, etc)
CDI_REC_OPEN_BROWSE | 2 | // indique que l'on doit rechercher tous les éléments du dossier (pas uniquement celui référencé)
CDI_REC_OPEN_EMPTY | 4 | // indique qu'aucun élément n'est selectionné par défaut pour la session de recherche
CDI_REC_OPEN_NO_NAG | 8 | // indique qu'aucun message ne doit être affiché dans ce mode, la DLL doit prendre elle même les décisions


CerfaDoc Kit - Options pour CDI_DataGet

Options pour CDI_DataGet

CDD_PATIENT_NOM | 0 | // CHAINE : Patient : Nom
CDD_PATIENT_PRENOM | 1 | // CHAINE : Patient : Prénom
CDD_PATIENT_ADRESSE | 2 | // CHAINE : Patient : Adresse (N° de rue, rue, etc, hors code postal et ville)
CDD_PATIENT_CODE_POSTAL | 3 | // CHAINE : Patient : Code postal
CDD_PATIENT_VILLE | 4 | // CHAINE : Patient : Ville
CDD_PATIENT_LIEU_NAISSANCE | 5 | // CHAINE : Patient : Lieu de naissance
CDD_PATIENT_TELF_PERSO | 6 | // CHAINE : Patient : Téléphone fixe personnel
CDD_PATIENT_TELF_PRO | 7 | // CHAINE : Patient : Téléphone fixe professionnel
CDD_PATIENT_NUM_SS | 8 | // CHAINE : Patient : N° de sécurité sociale (les espaces seront ignorés et remis en forme)
CDD_PATIENT_DATE_NAI | 9 | // SYSTEMTIME : Patient : Date de naissance patient (jour, mois, année utilisés)
CDD_PATIENT_RANG_GEM | 10 | // NUM : Patient : Rang gémellaire
CDD_PATIENT_TAILLE | 12 | // NUM : Patient : Taille (en cm)
CDD_PATIENT_POIDS | 13 | // NUM : Patient : Poids (en g)
CDD_PATIENT_SEXE | 14 | // NUM : Patient : 0:Homme, 1:Femme
CDD_PATIENT_SIT_FAM | 15 | // NUM : Patient : 0:Celibataire, 1:Marié, 2:Divorcé(e), 3:Veuf(ve), 4:Cocubin(e), 5:Parent célibataire)
CDD_PATIENT_CAISSE_PRIMAIRE_NOM | 16 | // CHAINE : Patient : Nom de la caisse primaire d'assurance maladie
CDD_PATIENT_CAISSE_COMPLEMENTAIRE_NOM | 17 | // CHAINE : Patient : Nom de la caisse complémentaire d'assurance maladie
CDD_PATIENT_NOM_JF | 18 | // CHAINE : Patient : Nom de jeune fille
CDD_PATIENT_EXT_LIBELLE | 19 | // CHAINE : Patient : Libellé des champs d'extension
CDD_PATIENT_EXT_DONNEE | 20 | // CHAINE : Patient : Donnée des champs d'extension
CDD_PATIENT_DOSSIER_REF | 21 | // CHAINE : Patient : Référence de dossier papier
CDD_PATIENT_SV_REGIME_CODE | 22 | // NUM : Patient : N° de Code du régime
CDD_PATIENT_SV_CAISSE_GESTION | 23 | // NUM : Patient : N° Caisse du régime
CDD_PATIENT_SV_CENTRE_GESTION | 24 | // NUM : Patient : N° Centre du régime
CDD_MEDECIN_NOM | 25 | // CHAINE : Médecin : Nom et prénom du médecin SANS le titre !
CDD_MEDECIN_IDNAT | 26 | // CHAINE : Médecin : Identifiant national du médecin SANS la clé
CDD_PATIENT_GROSSESSE_NB_FOETUS | 27 | // NUM : Patient : Grossesse : Nombre de foetus
CDD_PATIENT_GROSSESSE_DATE_REGLE | 28 | // SYSTEMTIME : Patient : Grossesse : Date des dernières règles
CDD_PATIENT_GROSSESSE_DATE_CONCEPTION | 29 | // SYSTEMTIME : Patient : Grossesse : Date de conception
CDD_PATIENT_GROSSESSE_FLAG_ECHO | 30 | // NUM : Patient : Grossesse : Flag echographie, à 1 si une echographie a été faite
CDD_PATIENT_GROSSESSE_DATE_ECHO | 31 | // SYSTEMTIME : Patient : Grossesse : Date d'échographie
CDD_PATIENT_TEL_MOBILE_PERSO | 32 | // CHAINE : Patient : N° de téléphone mobile personnel
CDD_PATIENT_TEL_MOBILE_PRO | 33 | // CHAINE : Patient : N° de téléphone mobile professionnel
CDD_PATIENT_EMAIL_PERSO | 34 | // CHAINE : Patient : Email personnel
CDD_PATIENT_EMAIL_PRO | 35 | // CHAINE : Patient : Email professionnel
CDD_PATIENT_RAW | 36 | // CHAINE : Patient : Données brutes texte, [DEBUG only]. A des fins de debug retourne le maximum de données texte concernant le dossier patient
CDD_PATIENT_ATCD_CHIRURGIE | 37 | // CHAINE : Patient : Antécédants chirugicaux format RTF
CDD_PATIENT_ATCD_MEDICAL | 38 | // CHAINE : Patient : Antécédants médicaux format RTF
CDD_PATIENT_ATCD_FAMILLE | 39 | // CHAINE : Patient : Antécédants familliaux format RTF
CDD_PATIENT_ATCD_ALLERGIE | 40 | // CHAINE : Patient : Antécédants allergiques format RTF
CDD_PATIENT_ATCD_INTOLERANCE | 41 | // CHAINE : Patient : Antécédants intolérances format RTF
CDD_PATIENT_ATCD_GYNECOLOGIE | 42 | // CHAINE : Patient : Antécédants gynécologiques format RTF
CDD_PATIENT_ATCD_OBSTETRIE | 43 | // CHAINE : Patient : Antécédants obstétricaux format RTF
CDD_PATIENT_ATCD_CIPATHOLOGIES | 44 | // CHAINE : Patient : Antécédants contre indication pathologiques format RTF
CDD_PATIENT_ATCD_CIALLERGIES | 45 | // CHAINE : Patient : Antécédants contre indication allergiques format RTF
CDD_PATIENT_ATCD_CIPRECAUTIONS | 46 | // CHAINE : Patient : Antécédants contre indication précautions format RTF
CDD_PATIENT_ATCD_CIPRECAUTIONSLIBRE | 47 | // CHAINE : Patient : Antécédants contre indication précautions (texte libre) format RTF
CDD_PATIENT_ATCD_ALARME_CHIRURGIE | 48 | // NUM : Patient : Antécédants chirurgicaux (alarme)
CDD_PATIENT_ATCD_ALARME_MEDICAL | 49 | // NUM : Patient : Antécédants médicaux (alarme)
CDD_PATIENT_ATCD_ALARME_FAMILLIAL | 50 | // NUM : Patient : Antécédants familliaux (alarme)
CDD_PATIENT_ATCD_ALARME_ALLERGIE | 51 | // NUM : Patient : Antécédants allergiques (alarme)
CDD_PATIENT_ATCD_ALARME_INTOLERANCE | 52 | // NUM : Patient : Antécédants intolérances (alarme)
CDD_PATIENT_ATCD_ALARME_GYNECOLOGIE | 53 | // NUM : Patient : Antécédants gynécologiques (alarme)
CDD_PATIENT_ATCD_ALARME_OBSTETRIE | 54 | // NUM : Patient : Antécédants obstétricaux (alarme)
CDD_PATIENT_ATCD_ALARME_CIPATHOLOGIES | 55 | // NUM : Patient : Antécédants contre indication pathologiques (alarme)
CDD_PATIENT_ATCD_ALARME_CIALLERGIES | 56 | // NUM : Patient : Antécédants contre indication allergiques (alarme)
CDD_PATIENT_ATCD_ALARME_CIPRECAUTIONS | 57 | // NUM : Patient : Antécédants contre indication précautions (alarme)
CDD_DEPENSE_DATE | 58 | // SYSTEMTIME : Depenses : Date de la dépense
CDD_DEPENSE_CODE | 59 | // CHAINE : Depenses : Code de la dépense
CDD_DEPENSE_COMPTE | 60 | // CHAINE : Depenses : Compte auquel est affecté la dépense
CDD_DEPENSE_LIBELLE | 61 | // CHAINE : Depenses : Libelle attaché à la dépense
CDD_DEPENSE_MODE | 62 | // CHAINE : Depenses : Mode de paiement de la dépense
CDD_DEPENSE_TOTAL | 63 | // DOUBLE : Depenses : Valeur de la dépense en euros
CDD_RECETTE_DATE | 64 | // SYSTEMTIME : Recettes : Date de la recette
CDD_RECETTE_DATE_PAIE | 65 | // SYSTEMTIME : Recettes : Date de paiement de la recette
CDD_RECETTE_MODE | 66 | // CHAINE : Recettes : Mode de paiement de la recette
CDD_RECETTE_TOTAL | 67 | // DOUBLE : Recettes : Valeur totale de la recette en euros
CDD_RECETTE_VALUE | 68 | // DOUBLE : Recettes : Valeur d'un élément de la recette en euros
CDD_FORM_DATE | 69 | //E // SYSTEMTIME : Formulaire : Date du formulaire
CDD_FORM_NB_LIGNES | 70 | //E // NUM : Formulaire : Nombre de lignes du formulaire
CDD_FORM_LIGNE_FROM_STR | 71 | //E // NUM : Formulaire : Retourne un N° de ligne à partir de str1 (ligne nommée str1)
CDD_FORM_DATA | 72 | //E // CHAINE : Formulaire : Retourne la donnée située sur nlig et ncol
CDD_FORM_COUNT | 73 | // NUM : Formulaire : Nombre d'enregistrements de formulaires pour ce patient
CDD_PEDIA_NB | 74 | // NUM : Pediatrie : Nombre d'enregistrements
CDD_PEDIA_TAILLE | 75 | // DOUBLE : Pediatrie : Enregistrement : Taille en cm
CDD_PEDIA_POIDS | 76 | // DOUBLE : Pediatrie : Poids en kg
CDD_PEDIA_PC | 77 | // DOUBLE : Pediatrie : Perimètre cranien en cm
CDD_PEDIA_DATE | 78 | // SYSTEMTIME : Pediatrie : Date
CDD_NOTE_DATA | 79 | // CHAINE : Notes : Contenu en RTF (HGLOBAL)
CDD_NOTE_DATE | 80 | // SYSTEMTIME : Notes : Date de la note
CDD_NOTE_TITRE | 81 | // CHAINE : Notes : Titre de la note (HGLOBAL)
CDD_LIEN_FAMILLE_REF | 82 | // NUM : Lien famillial : CDI_REF sur le dossier lié
CDD_LIEN_FAMILLE_TYPE | 83 | // CHAINE : Lien famillial : type de lien (texte, ex : fils, fille, père, mère)
CDD_PATIENT_PROFESSION | 84 | // CHAINE : Patient : Profession
CDD_PATIENT_PAYS_NAISSANCE | 85 | // CHAINE : Patient : Pays de naissance
CDD_PATIENT_CODE_POSTAL_NAISSANCE | 86 | // CHAINE : Patient : Code postal de naissance
CDD_RECETTE_USER | 87 | // CHAINE : Recettes : Nom de l'utilisateur
CDD_RECETTE_FSE | 88 | // NUM : Recettes : Est-elle liée à une FSE ?
CDD_RECETTE_REF | 89 | // NUM : Recettes : N° de la fiche
CDD_RECETTE_ACTE | 90 | // CHAINE : Recettes : Code de l'acte
CDD_PATIENT_PHOTO | 91 | // IMAGEBMP : Patient : Photographie (en format BMP)
CDD_MEDECIN_RPPS | 92 | // CHAINE : Médecin : Identifiant national du médecin RPPS


CerfaDoc Kit - Type de données à libérer

Type de données à libérer

CDI_DATA_RECORD_LIST | 1 | // Donnée fournie par CDI_RecordsList
CDI_DATA_PATIENT_LIST | 2 | // Donnée fournie par CDI_PatientsList
CDI_DATA_DATA_EXT | 3 | // Donnée fournie par CDI_DataExtGet/CDI_DataGet2 (LocalAlloc)
CDI_DATA_RECETTE_LIST | 4 | // Donnée fournie par CDI_RecettesList
CDI_DATA_DEPENSE_LIST | 5 | // Donnée fournie par CDI_DepensesList
CDI_DATA_DATA_EXTG | 6 | // Donnée fournie par CDI_DataExtGet/CDI_DataExtGet/CDI_DataGet2 (GlobalAlloc)
CDI_DATA_USER_LIST | 7 | // Donnée fournie par CDI_UserList


CerfaDoc Kit - Type d'image

Type d'image

CDI_IMG_INFO_UPDATE 1 // Image à afficher dans la boite de mise à jour extérieure (doit expliquer comment lancer CerfaDoc) Taille conseillée : 250x110


CerfaDoc Kit - Options pour CDI_DataGet

Options pour CDI_DataGet

CDD_PATIENT_NOM | 0 | // CHAINE : Patient : Nom
CDD_PATIENT_PRENOM | 1 | // CHAINE : Patient : Prénom
CDD_PATIENT_ADRESSE | 2 | // CHAINE : Patient : Adresse (N° de rue, rue, etc, hors code postal et ville)
CDD_PATIENT_CODE_POSTAL | 3 | // CHAINE : Patient : Code postal
CDD_PATIENT_VILLE | 4 | // CHAINE : Patient : Ville
CDD_PATIENT_LIEU_NAISSANCE | 5 | // CHAINE : Patient : Lieu de naissance
CDD_PATIENT_TELF_PERSO | 6 | // CHAINE : Patient : Téléphone fixe personnel
CDD_PATIENT_TELF_PRO | 7 | // CHAINE : Patient : Téléphone fixe professionnel
CDD_PATIENT_NUM_SS | 8 | // CHAINE : Patient : N° de sécurité sociale (les espaces seront ignorés et remis en forme)
CDD_PATIENT_DATE_NAI | 9 | // SYSTEMTIME : Patient : Date de naissance patient (jour, mois, année utilisés)
CDD_PATIENT_RANG_GEM | 10 | // NUM : Patient : Rang gémellaire
CDD_PATIENT_TAILLE | 12 | // NUM : Patient : Taille (en cm)
CDD_PATIENT_POIDS | 13 | // NUM : Patient : Poids (en g)
CDD_PATIENT_SEXE | 14 | // NUM : Patient : 0:Homme, 1:Femme
CDD_PATIENT_SIT_FAM | 15 | // NUM : Patient : 0:Celibataire, 1:Marié, 2:Divorcé(e), 3:Veuf(ve), 4:Cocubin(e), 5:Parent célibataire)
CDD_PATIENT_CAISSE_PRIMAIRE_NOM | 16 | // CHAINE : Patient : Nom de la caisse primaire d'assurance maladie
CDD_PATIENT_CAISSE_COMPLEMENTAIRE_NOM | 17 | // CHAINE : Patient : Nom de la caisse complémentaire d'assurance maladie
CDD_PATIENT_NOM_JF | 18 | // CHAINE : Patient : Nom de jeune fille
CDD_PATIENT_EXT_LIBELLE | 19 | // CHAINE : Patient : Libellé des champs d'extension
CDD_PATIENT_EXT_DONNEE | 20 | // CHAINE : Patient : Donnée des champs d'extension
CDD_PATIENT_DOSSIER_REF | 21 | // CHAINE : Patient : Référence de dossier papier
CDD_PATIENT_SV_REGIME_CODE | 22 | // NUM : Patient : N° de Code du régime
CDD_PATIENT_SV_CAISSE_GESTION | 23 | // NUM : Patient : N° Caisse du régime
CDD_PATIENT_SV_CENTRE_GESTION | 24 | // NUM : Patient : N° Centre du régime
CDD_MEDECIN_NOM | 25 | // CHAINE : Médecin : Nom et prénom du médecin SANS le titre !
CDD_MEDECIN_IDNAT | 26 | // CHAINE : Médecin : Identifiant national du médecin SANS la clé
CDD_PATIENT_GROSSESSE_NB_FOETUS | 27 | // NUM : Patient : Grossesse : Nombre de foetus
CDD_PATIENT_GROSSESSE_DATE_REGLE | 28 | // SYSTEMTIME : Patient : Grossesse : Date des dernières règles
CDD_PATIENT_GROSSESSE_DATE_CONCEPTION | 29 | // SYSTEMTIME : Patient : Grossesse : Date de conception
CDD_PATIENT_GROSSESSE_FLAG_ECHO | 30 | // NUM : Patient : Grossesse : Flag echographie, à 1 si une echographie a été faite
CDD_PATIENT_GROSSESSE_DATE_ECHO | 31 | // SYSTEMTIME : Patient : Grossesse : Date d'échographie
CDD_PATIENT_TEL_MOBILE_PERSO | 32 | // CHAINE : Patient : N° de téléphone mobile personnel
CDD_PATIENT_TEL_MOBILE_PRO | 33 | // CHAINE : Patient : N° de téléphone mobile professionnel
CDD_PATIENT_EMAIL_PERSO | 34 | // CHAINE : Patient : Email personnel
CDD_PATIENT_EMAIL_PRO | 35 | // CHAINE : Patient : Email professionnel
CDD_PATIENT_RAW | 36 | // CHAINE : Patient : Données brutes texte, [DEBUG only]. A des fins de debug retourne le maximum de données texte concernant le dossier patient
CDD_PATIENT_ATCD_CHIRURGIE | 37 | // CHAINE : Patient : Antécédants chirugicaux format RTF
CDD_PATIENT_ATCD_MEDICAL | 38 | // CHAINE : Patient : Antécédants médicaux format RTF
CDD_PATIENT_ATCD_FAMILLE | 39 | // CHAINE : Patient : Antécédants familliaux format RTF
CDD_PATIENT_ATCD_ALLERGIE | 40 | // CHAINE : Patient : Antécédants allergiques format RTF
CDD_PATIENT_ATCD_INTOLERANCE | 41 | // CHAINE : Patient : Antécédants intolérances format RTF
CDD_PATIENT_ATCD_GYNECOLOGIE | 42 | // CHAINE : Patient : Antécédants gynécologiques format RTF
CDD_PATIENT_ATCD_OBSTETRIE | 43 | // CHAINE : Patient : Antécédants obstétricaux format RTF
CDD_PATIENT_ATCD_CIPATHOLOGIES | 44 | // CHAINE : Patient : Antécédants contre indication pathologiques format RTF
CDD_PATIENT_ATCD_CIALLERGIES | 45 | // CHAINE : Patient : Antécédants contre indication allergiques format RTF
CDD_PATIENT_ATCD_CIPRECAUTIONS | 46 | // CHAINE : Patient : Antécédants contre indication précautions format RTF
CDD_PATIENT_ATCD_CIPRECAUTIONSLIBRE | 47 | // CHAINE : Patient : Antécédants contre indication précautions (texte libre) format RTF
CDD_PATIENT_ATCD_ALARME_CHIRURGIE | 48 | // NUM : Patient : Antécédants chirurgicaux (alarme)
CDD_PATIENT_ATCD_ALARME_MEDICAL | 49 | // NUM : Patient : Antécédants médicaux (alarme)
CDD_PATIENT_ATCD_ALARME_FAMILLIAL | 50 | // NUM : Patient : Antécédants familliaux (alarme)
CDD_PATIENT_ATCD_ALARME_ALLERGIE | 51 | // NUM : Patient : Antécédants allergiques (alarme)
CDD_PATIENT_ATCD_ALARME_INTOLERANCE | 52 | // NUM : Patient : Antécédants intolérances (alarme)
CDD_PATIENT_ATCD_ALARME_GYNECOLOGIE | 53 | // NUM : Patient : Antécédants gynécologiques (alarme)
CDD_PATIENT_ATCD_ALARME_OBSTETRIE | 54 | // NUM : Patient : Antécédants obstétricaux (alarme)
CDD_PATIENT_ATCD_ALARME_CIPATHOLOGIES | 55 | // NUM : Patient : Antécédants contre indication pathologiques (alarme)
CDD_PATIENT_ATCD_ALARME_CIALLERGIES | 56 | // NUM : Patient : Antécédants contre indication allergiques (alarme)
CDD_PATIENT_ATCD_ALARME_CIPRECAUTIONS | 57 | // NUM : Patient : Antécédants contre indication précautions (alarme)
CDD_DEPENSE_DATE | 58 | // SYSTEMTIME : Depenses : Date de la dépense
CDD_DEPENSE_CODE | 59 | // CHAINE : Depenses : Code de la dépense
CDD_DEPENSE_COMPTE | 60 | // CHAINE : Depenses : Compte auquel est affecté la dépense
CDD_DEPENSE_LIBELLE | 61 | // CHAINE : Depenses : Libelle attaché à la dépense
CDD_DEPENSE_MODE | 62 | // CHAINE : Depenses : Mode de paiement de la dépense
CDD_DEPENSE_TOTAL | 63 | // DOUBLE : Depenses : Valeur de la dépense en euros
CDD_RECETTE_DATE | 64 | // SYSTEMTIME : Recettes : Date de la recette
CDD_RECETTE_DATE_PAIE | 65 | // SYSTEMTIME : Recettes : Date de paiement de la recette
CDD_RECETTE_MODE | 66 | // CHAINE : Recettes : Mode de paiement de la recette
CDD_RECETTE_TOTAL | 67 | // DOUBLE : Recettes : Valeur totale de la recette en euros
CDD_RECETTE_VALUE | 68 | // DOUBLE : Recettes : Valeur d'un élément de la recette en euros
CDD_FORM_DATE | 69 | //E // SYSTEMTIME : Formulaire : Date du formulaire
CDD_FORM_NB_LIGNES | 70 | //E // NUM : Formulaire : Nombre de lignes du formulaire
CDD_FORM_LIGNE_FROM_STR | 71 | //E // NUM : Formulaire : Retourne un N° de ligne à partir de str1 (ligne nommée str1)
CDD_FORM_DATA | 72 | //E // CHAINE : Formulaire : Retourne la donnée située sur nlig et ncol
CDD_FORM_COUNT | 73 | // NUM : Formulaire : Nombre d'enregistrements de formulaires pour ce patient
CDD_PEDIA_NB | 74 | // NUM : Pediatrie : Nombre d'enregistrements
CDD_PEDIA_TAILLE | 75 | // DOUBLE : Pediatrie : Enregistrement : Taille en cm
CDD_PEDIA_POIDS | 76 | // DOUBLE : Pediatrie : Poids en kg
CDD_PEDIA_PC | 77 | // DOUBLE : Pediatrie : Perimètre cranien en cm
CDD_PEDIA_DATE | 78 | // SYSTEMTIME : Pediatrie : Date
CDD_NOTE_DATA | 79 | // CHAINE : Notes : Contenu en RTF
CDD_NOTE_DATE | 80 | // SYSTEMTIME : Notes : Date de la note
CDD_NOTE_TITRE | 81 | // CHAINE : Notes : Titre de la note
CDD_LIEN_FAMILLE_REF | 82 | // NUM : Lien famillial : CDI_REF sur le dossier lié
CDD_LIEN_FAMILLE_TYPE | 83 | // CHAINE : Lien famillial : type de lien (texte, ex : fils, fille, père, mère)

Ces constantes désignent chacune une donnée que CerfaDoc peut demander lors d'un appel à CDI_DataGet ou CDI_DataGet2


CerfaDoc Kit - Options pour CDI_GetOption

Options pour CDI_GetOption

CDI_OPT_VERSION | 0 | // NUM : N° de version d'interface (doit être retourné)
CDI_OPT_NAME | 1 | // CHAINE : Retourne le nom résumé de la DLL (ex "HD") (par défaut : nom de la DLL)
CDI_OPT_NAME_DETAIL | 2 | // CHAINE : Retourne le nom détaillé de la DLL ("interface HelloDOC, version 5.60") (par défaut : nom de la DLL)
CDI_OPT_ENREG_BAR | 3 | // NUM : A 1, inclus une barre sous forme d'active X dans l'enregistrement HTML, cette barre permet de réouvir,
CDI_OPT_ENREG_TXT | 4 | // NUM : A 1, fournit un enregistrement texte séparé, à 0 : laisse la possibilité de l'inclure dans le HTML
CDI_OPT_GLOBAL_ERROR | 5 | // NUM : A 1, indique qu'une erreur s'est produit lors de l'accès aux données. La lecture de ce flag le remet à 0 (après lecture)
CDI_OPT_GET_N_PAT_FROM_NAME | 6 | // NUM : A 1, indique que le N° du patient peut être récupéré à partir du nom

Ces constantes désignent chacune une option de la DLL d'interface que CerfaDoc peut interroger à tout moment par CDI_GetOption


CerfaDoc Kit - Options pour CDI_RecordOpen

Options pour CDI_RecordOpen

CDI_REC_OPEN_NO_SEARCH | 1 | // indique que l'on ne doit pas faire une recherche avancée (archive, enreg perdu, etc)
CDI_REC_OPEN_BROWSE | 2 | // indique que l'on doit rechercher tous les éléments du dossier (pas uniquement celui référencé)
CDI_REC_OPEN_EMPTY | 4 | // indique qu'aucun élément n'est selectionné par défaut pour la session de recherche
CDI_REC_OPEN_NO_NAG | 8 | // indique qu'aucun message ne doit être affiché dans ce mode, la DLL doit prendre elle même les décisions

Constantes utilisées lors d'un appel CDI_RecordOpen lorsque CerfaDoc démarre une session de recherche. Les différentes constantes peuvent être concaténées par un OU logique (|).
L'option "NO_SEARCH" indique que l'on recherche un enregistrement précis désigné par le N° de patient, la date et l'heure de l'enregistrement. Si l'enregistement n'est pas trouvé, on doit retourner une erreur directement sans tenter de recherche avancée (par ex dans les archives ou autre). Si cette option n'est pas présente on peut tenter une recherche dans les archives ou dans des enregistrements perdus.
L'option "BROWSE" indique explicitement que l'on doit faire une recherche dans tous les éléments CerfaDoc du dossier, il seront énumérés par des appels répétés à CDI_RecordReadNext.
L'option "EMPTY" indique que l'on ne lie pas la session de recherche à un patient particulier mais que l'on viendra selectionner l'enregistrement à lire par CDI_RecordJump
L'option "NO_NAG" indique que l'on ne doit afficher aucun message d'erreur. (utilisé par les modes automatiques de CerfaDoc, par ex regénération). La DLL doit choisir elle même l'option, elle peut choisir par défaut de retourner une erreur au moindre problème.


CerfaDoc Kit - Options pour CDI_RecordReadNext

Options pour CDI_RecordReadNext

CDI_RECORD_EXT_DOSSIER | 1 | // Récupérer les données dossier
CDI_RECORD_EXT_OTHER | 2 | // Récupérer les autres données
CDI_RECORD_EXT_HTML | 4 | // Récupérer les données du résumé HTML
CDI_RECORD_EXT_TXT | 8 | // Récupérer les données du résumé texte

Utilisé lors de l'appel à CDI_RecordReadNext. Indique quelles données doivent obligatoirment être rapatriées dans la structure CDI_RECORD_EXT. Les options peuvent être concaténées par un OU logique (|).

typedef struct{
  void *data_orig;       // Données originale (structure opaque, dans laquelle on peut venir demander des informations par CDI_GetRecordInfo)
  int data_orig_len;     // Longueur données originale
  void *data_orig2;      // [optionnel] Données originale (données opaques, texte ) simplement renvoyées lors d'un appel à CDI_RecordNew.
  void *data_html;       // [optionnel] Résumé HTML
  void *data_txt;        // [optionnel] Résumé Texte
  SYSTEMTIME datetime;   // Date/Heure de l'enregistrement
  CDI_REF no_pat;        // N° de patient
  int old;               // Indique que cet enregistrement est sous un format ancien (doit être supprimé lors d'une regénération)
  CDI_REF user_param;    // Parametre utilisateur pour repérer l'enregistrement
}CDI_RECORD_EXT;

"EXT_DOSSIER" : La DLL doit remplir les champs "data_orig" et "data_orig_len" avec des données ou une référence quelconque dans lesquels CerfaDoc pourra venir demander ou modifier des données par des appels à CDI_GetRecordInfo ou CDI_SetRecordInfo. Les données qui doivent être accessibles via ces données sont celles désignées par les constantes CDI_RECORD_xxx. Le champs "data_orig_len" n'est pas obligatoire et constitue simplement une aide en cas de besoin. CerfaDoc n'accède pas directement à ces données

" EXT_OTHER" : La DLL peut remplir le champ "data_orig2" avec d'autres données de l'enregistrement ou une quelconque référence. Ces données ne seront jamais interrogées ni utilisées directement par CerfaDoc la référence sera simplement renvoyée lors de la modification d'un enregistrement par un appel à CDI_RecordNew

"EXT_HTML" : La DLL doit remplir le champ "data_html" avec les données du résumé HTML de l'enregistrement. Ce buffer doit être terminé par un "\0". Ce résumé HTML sert à identifier l'enregistrement

"EXT_TXT" : La DLL doit remplir le champ "data_txt" avec les données du résumé Texte de l'enregistrement

Les autres champs de la DLL (datetime, no_pat, old, user_param) doivent systématiquement être remplis


CerfaDoc Kit - Type de données à libérer

Type de données à libérer

CDI_DATA_RECORD_LIST | 1 | // Donnée fournie par CDI_RecordsList
CDI_DATA_PATIENT_LIST | 2 | // Donnée fournie par CDI_PatientsList
CDI_DATA_DATA_EXT | 3 | // Donnée fournie par CDI_DataExtGet
CDI_DATA_RECETTE_LIST | 4 | // Donnée fournie par CDI_RecettesList
CDI_DATA_DEPENSE_LIST | 5 | // Donnée fournie par CDI_DepensesList

Constantes utilisées lors d'un appel à CDI_Free
Indique quel est le type de la donnée à libérer, en indiquant la fonction qui a créé ce buffer