Voici le composant que Borland n'est pas arrivé à faire correctement depuis Delphi 2.0 et C++ Builder 1.0, et qui est enfin disponible aujourd'hui: un composant DDE qui permet de se connecter à une source de données comme Excel ou Reuter afin de récupérer en temps réel des informations.

L'unité DDECP implémente dans 2 composants (TDDEManager et TDDEClient) le protocole d'échange dynamique de données (Dynamic Data Exchange) pour la partie client. Elle peut s'utiliser avec toutes les versions de C++ Builder en 16 et 32 bits.

En effet lorsque 2 applications communiquent entre elles en utilisant le protocole DDE, celle qui fournit les données est appelée serveur, et celle qui reçoit les données est appelée client. Le processus d'échange entre les 2 applications s'appelle une conversation. C'est l'application cliente qui engage la conversation.

Les données sont répérées par des adresses (comme les personnes). Une adresse est structurée en 3 catégories (Service, Topic, Item): Service désigne la source de données, en général le nom du programme; Topic désigne un groupe de données qui ont les mêmes propriétés; Item désigne une donnée parmi ce groupe. Ainsi quand une application cliente désire recevoir des données d'une application serveur, elle envoie une requête <Service, Topic> au serveur qui accepte ou refuse la conversation. Puis le client demande une donnée particulière avec une requête <Item>. Le client peut aussi demander au serveur de l'avertir lorsqu'une donnée change de valeur.

Une application cliente peut avoir plusieurs conversations simultanées avec plusieurs serveurs.
 

• Ces composants sont utilisables complètement lorsque C++ Builder est ouvert. En payant la somme de 100 Francs ou l'équivalent en devise étrangère, vous recevrez la version totale ainsi que toutes les mises à jours. Aucune garantie n'est liée à ces composants. Les remarques sont les bienvenues.

TDDEManager

class PACKAGE TDDEManager : public TComponent
{
private:
  int
    CFLink;
protected:
public:
  DWORD
    IdInstance;
    TList
      *Clients;

  __fastcall TDDEManager(TComponent* Owner);
  virtual __fastcall ~TDDEManager(void);

  int __fastcall PasteLink(char *Service, char *Topic, char *Item);
  int __fastcall PasteLinkEx(int cfFormat, char *Service, char *Topic, char *Item);
__published:
};


class TClient
{
public:
        TDDEClient
                *DDEClient;

        __fastcall TClient(TDDEClient *DDEC);
};

• Le gestionnaire DDE repère toutes les conversations avec le champ Clients, liste de TClient. Ce champ ne doit normalement pas servir.

• La fonction PasteLink sert à récupérer des informations sur la conversation. Une conversation entre 2 application est définie par 2 chaînes de caractères, Service et Topic. Service est en général le nom du programme qui joue le rôle de serveur. Topic est le nom d'une plage de données qui ont les mêmes caractéristiques. Item désigne la donnée qui est susceptible d'être récupérée. Utilise le format cfLink.

• La fonction PasteLinkEx a la même fonction que PasteLink mais utilise le format cfFormat.

• Le destructeur Destroy s'occupe de libérer tous les conversations si elles n'ont pas été terminées normalement.

TDDEClient

class PACKAGE TDDEClient : public TComponent
{
private:
  AnsiString
    FService,
  FTopic;

  HSZ
    HSZService,
    HSZTopic;

  int
    FFormat,
    FTimeOut;

  void __fastcall SetService(const AnsiString Value);
  void __fastcall SetTopic(const AnsiString Value);
  void __fastcall SetFormat(int Value);
  void __fastcall SetTimeOut(int Value);
protected:
public:
  HCONV
    HConv;
  TOnDataChange
    FOnDataChange;

  __fastcall TDDEClient(TComponent* Owner);
  virtual __fastcall ~TDDEClient(void);

  int __fastcall OpenConversation(void);
  int __fastcall CloseConversation(void);
  int __fastcall IsOpen(void);

  char * __fastcall RequestData(char *Item, int *DataSize);
  int __fastcall AdviseData(char *Item);
  int __fastcall UnadviseData(char *Item);
  int __fastcall Execute(char *Item, char *Command);
  int __fastcall Poke(char *Item, void *pData, int DataLength);
  int __fastcall PokeEx(int cfFormat, char *Item, void *pData, int DataLength);
__published:
  __property AnsiString Service = {read = FService, write = SetService};
  __property AnsiString Topic = {read = FTopic, write = SetTopic};
  __property int Format = {read = FFormat, write = SetFormat, default = CF_TEXT};
  __property int TimeOut = {read = FTimeOut, write = SetTimeOut, default = 1000};
  __property TOnDataChange OnDataChange = {read = FOnDataChange, write = FOnDataChange};
};


typedef void __fastcall (__closure *TOnDataChange)(TDDEClient *DDEClient, char *Item, const char *Value, int ValueSize);

Le composant TDDEClient représente la conversation entre l'application cliente et le serveur.

• Pour établir une conversation, il faut préciser les champs Service et Topic, puis appeler la fonction OpenConversation qui répond True si la conversation est ouverte. La conversation est alors ajoutée à la liste du gestionnaire DDE.

• CloseConversation ferme la conversation, c'est à dire interrompt toutes les communications avec le serveur, et la retire de la liste du gestionnaire DDE.

• IsOpen indique si la conversation est établie.

• Format indique au serveur dans quel format il doit envoyer les données (voir dans l'aide les constantes CF_xxx, par défaut égal à CF_TEXT ou 1).

• TimeOut limite le temps de réponse d'une requête. Après TimeOut millisecondes, la fonction rend la main. Toutes les fonctions sont synchrones: la fonction rend la main après avoir terminé son devoir.

• Une donnée peut être demandée de manière discrète au serveur avec la fonction RequestData en précisant Item, qui désigne cette donnée. Le résultat de RequestData est un pointeur sur la donnée dont la taille en octets est donnée par DataSize. Il faut désallouer le résultat avec StrDispose.

• Il est aussi possible de demander au serveur d'avertir le client quand une donnée change de valeur, et de recevoir cette donnée, avec la fonction AdviseData, en précisant Item. Si le serveur accepte, la fonction renvoie True. Si le champ OnDataChange est défini, alors la méthode associée est appelée chaque fois que la valeur d'une donnée change. Une même méthode OnDataChange peut servir à récupérer plusieurs données différentes: il suffit d'appeler AdviseData en précisant Item autant de fois qu'il y a de données à récupérer.

• La fonction UnadviseData stoppe cette notification pour un Item donné, et retourne True en cas de succès.

• La fonction Execute envoie une commande sous la forme d’une chaîne de caractères au serveur, et retourne True en cas de succès.

• La fonction Poke envoie une donnée à l'item Item du serveur avec le format Format, et retourne True en cas de succès. La donnée est définie le pointeur pData qui pointe sur elle, et sa longueur en octets DataLength.

• La fonction PokeEx a la même fonction que Poke mais utilise le format cfFormat.