Interaction entre les composants et les bases hôtes

Lorsqu’un composant a été installé dans une base hôte, son nom apparaît dans la Table du formulaire courant de l’Explorateur de la base hôte, dans le thème "Méthodes composant". Les méthodes partagées des composants sont listées sous forme hiérarchique et, si le composant est interprété, leur contenu s’affiche dans la zone de prévisualisation.

Pour plus d’informations sur la définition des méthodes partagées, reportez-vous au paragraphe Partage des méthodes projet.

Certains types d’objets définis par un composant évoluent dans un espace d’exécution qui leur est propre, ce qui élimine les possibilités de conflit avec les objets existants de la base hôte et ceux des autres composants. Ces objets sont appelés “non partagés” ou “cloisonnés”. Par exemple, les variables sont cloisonnées, ce qui signifie qu’une variable <>Mavar de type Entier long créée et manipulée par un composant peut coexister avec une variable <>Mavar de type Texte créée et manipulée par la base hôte (ou un autre composant). 

D’autres objets partagent le même espace d’exécution entre la base hôte et les composants. L’emploi de ces objets nécessite davantage de précautions mais permet à la base hôte et aux composants de communiquer. Ces objets sont appelés “partagés” ou “non cloisonnés”. 

Par exemple, les ensembles sont partagés, ce qui signifie que si un composant crée l’ensemble monEnsemble, il sera supprimé si la base hôte exécute l’instruction :

Les objets non partagés (cloisonnés) entre les composants et les bases hôtes sont les suivants :

• Feuilles de style
• Info-bulles
• Enumérations
• Images de la bibliothèque
• Menus et barres de menus créés via l’éditeur de menus
• Méthodes projet sans la propriété “Partager la méthode”
• Sémaphores
• Process
• Variables (locales, process et interprocess)
• Variables système (OK, Document, etc.)
• Formulaires table
• Formulaires projet sans la propriété “Publier comme sous-formulaire”
• Ressources et références aux fichiers de ressources ouverts

Les objets partagés (non cloisonnés) entre les composants et les bases hôtes sont les suivants :

• Ensembles
• Sélections temporaires
• Listes hiérarchiques utilisant une référence (créées via les commandes Nouvelle liste, Charger liste, Copier liste ou BLOB vers liste)
• Menus et barres de menus utilisant la référence retournée par la commande Creer menu.
• Méthodes projet ayant la propriété “Partager la méthode”
• Formulaires projet ayant la propriété “Publié comme sous-formulaire dans la base hôte”
• Références de structure XML
• Références de fichiers ouverts (hormis fichiers de ressources)
• Pointeurs

Note : Bien entendu, les objets non utilisables présents dans une base matrice sont ignorés par la base hôte (cf. paragraphe Objets utilisables et non utilisables).

Toutes les méthodes projet d’une base matrice sont par définition incluses dans le composant (la base est le composant), ce qui signifie qu’elles peuvent être appelées et exécutées par le composant. 

En revanche, par défaut ces méthodes projet ne seront ni visibles ni appelables par la base hôte. Vous devez explicitement désigner dans la base matrice les méthodes que vous souhaitez partager avec la base hôte. Ces méthodes projet seront visibles dans la Table du formulaire courant de l’Explorateur et pourront être appelées dans le code la base hôte (mais elles ne pourront pas être modifiées dans l’éditeur de méthodes de la base hôte). Ces méthodes constituent les points d’entrée dans le composant. 

A l’inverse, pour des raisons de sécurité, par défaut un composant ne peut pas exécuter de méthode projet appartenant à la base hôte. Dans certains cas, vous pourrez avoir besoin d’autoriser un composant à accéder à des méthodes projet de votre base hôte. Pour cela, vous devez explicitement désigner les méthodes projet de la base hôte que vous souhaitez rendre accessibles aux composants. 

Ce paramétrage est effectué via la propriété Partager entre composants et base hôte dans la boîte de dialogue des propriétés des méthodes :

Il est également possible d’appliquer cette propriété à plusieurs méthodes à la fois via la boîte de dialogue d’attributs globaux, accessible depuis le menu contextuel de l’Explorateur (cf. paragraphe Modifier attributs globalement).

L’effet de cette option est défini par le contexte d’utilisation de la base : si la base est utilisée comme composant, la méthode sera accessible dans la base hôte et visible dans l’Explorateur. Si la base est une base hôte, la méthode sera utilisable par les composants.

Vous pouvez partager des formulaires de la base matrice et les utiliser comme sous-formulaires dans la base hôte.

Côté composant (base matrice), seuls les sous-formulaires projet peuvent être désignés comme sous-formulaires publiés. 

Pour qu’un formulaire de composant puisse être sélectionné comme sous-formulaire dans une base hôte, il doit avoir été explicitement désigné comme "formulaire publié" dans la boîte de dialogue des propriétés du formulaire via l'option Publié comme sous-formulaire dans la base hôte :

Note : Cette boîte de dialogue est accessible via la commande Propriétés du formulaire du menu contextuel ou du menu d’action de l’Explorateur (cf. Propriétés du formulaire (Explorateur)). 

Vous devez gérer les interactions entre le sous-formulaire et les formulaires parents de la base hôte à l’aide des mécanismes et outils décrits dans la section Sous-formulaires en page.

Côté base hôte, les sous-formulaires provenant de composants doivent impérativement être utilisés en mode page : dans l’éditeur de formulaires, lorsque l’objet sous-formulaire est sélectionné dans le formulaire parent, désélectionnez l’option Sous-formulaire liste dans le thème "Sous-formulaire" de la Liste des propriétés. 

Ensuite, choisissez <Aucun> dans le menu "Table". Les formulaires publiés par les composants sont alors listés dans le menu "Formulaire détaillé". Leur nom est suivi de celui du composant entre parenthèses. Il vous suffit alors de choisir dans cette liste le formulaire à utiliser dans la liste "Formulaire détaillé".

Une nouvelle instance de l’objet sélectionné est alors immédiatement créée dans le formulaire.

Les composants et les bases hôtes ne partagent pas de variables locales, process ou interprocess. Le seul moyen d’accéder aux variables du composant depuis la base hôte et inversement est d’utiliser des pointeurs. 

Exemple utilisant un tableau :

• Dans la base hôte :
  
   TABLEAU ENTIER(MonTab;10)
 UneMéthode(->MonTab)
• Dans le composant, la méthode projet UneMéthode contient :
  
   AJOUTER A TABLEAU($1->;2)

Exemples utilisant des variables :

L’utilisation de pointeurs pour faire communiquer les composants et la base hôte nécessite de prendre en compte les spécificités suivantes :

• La commande Pointeur vers ne retournera pas un pointeur vers une variable de la base hôte si elle est appelée depuis un composant et inversement.

• L’architecture des composants autorise la coexistence, au sein d’une même base interprétée, de composants interprétés et compilés (à l’inverse, seuls des composants compilés peuvent être utilisés dans une base compilée). L’usage de pointeurs dans ce cas doit respecter le principe suivant : l’interpréteur peut dépointer un pointeur construit en mode compilé mais à l’inverse, en mode compilé, il n’est pas possible de dépointer un pointeur construit en mode interprété.
  Illustrons ce principe par l’exemple suivant : soient deux composants, C (compilé) et I (interprété) installés dans la même base hôte.
  
  • si le composant C définit la variable mavarC, le composant I peut accéder à la valeur de cette variable en utilisant le pointeur ->mavarC.
  • si le composant I définit la variable mavarI, le composant C ne peut pas accéder à cette variable en utilisant le pointeur ->mavarI. Cette syntaxe provoque une erreur d’exécution.

• La comparaison de pointeurs via la commande RESOUDRE POINTEUR est déconseillée avec les composants car le principe de cloisonnement des variables autorise la coexistence de variables de même nom mais au contenu radicalement différente dans un composant et la base hôte (ou un autre composant). Le type de la variable peut même être différent dans les deux contextes.
  Si les pointeurs monptr1 et monptr2 pointent chacun sur une variable, la comparaison suivante produira un résultat erroné :
  
   RESOUDRE POINTEUR(monptr1;vNomVar1;vnumtable1;vnumchamp1)
 RESOUDRE POINTEUR(monptr2;vNomVar2;vnumtable2;vnumchamp2)
 Si(vNomVar1=vNomVar2)
  //Ce test retourne Vrai alors que les variables sont différentes
  
  Dans ce cas, il est nécessaire d’utiliser la comparaison de pointeurs :
  
   Si(monptr1=monptr2) //Ce test retourne Faux

Bien que les composants ne puissent pas utiliser de tables, les commandes suivantes peuvent être appelées dans le contexte d’un composant :

TABLE PAR DEFAUT
PAS DE TABLE PAR DEFAUT
Table par defaut courante

En effet, ces commandes sont utiles lorsqu’un composant doit exploiter les tables de la base hôte. Les pointeurs permettent à la base hôte et au composant de communiquer dans ce cas. Par exemple, voici une méthode pouvant être appelée depuis un composant :

Hormis les Commandes non utilisables, un composant peut utiliser toute commande du langage 4D. 

Lorsqu’elles sont appelées depuis un composant, les commandes s’exécutent dans le contexte du composant, à l’exception de la commande EXECUTER METHODE qui utilise le contexte de la méthode désignée par la commande. A noter également que les commandes de lecture du thème “Utilisateurs et groupes” sont utilisables depuis un composant mais lisent les utilisateurs et les groupes de la base hôte (un composant n’a pas d’utilisateurs et groupes propres). 

Les commandes FIXER PARAMETRE BASE et Lire parametre base constituent aussi une exception à ce principe : leur portée est globale à la base. Lorsque ces commandes sont appelées depuis un composant, elles s’appliquent à la base hôte. 

Par ailleurs, des dispositions spécifiques sont définies pour les commandes Fichier structure et Dossier 4D lorsqu’elles sont utilisées dans le cadre des composants (cf. manuel Langage).

La commande LISTE COMPOSANTS permet de connaître la liste des composants chargés par la base hôte.

Lorsque vous utilisez des composants non compilés, leur code apparaît dans le débogueur standard de la base hôte. 

Le débogueur respecte les espaces d’exécution des objets cloisonnés. Si vous affichez la valeur de la variable var1 de la base hôte dans la fenêtre d’évaluation puis exécutez du code appartenant au composant contenant également une variable var1, la valeur affichée ne sera pas mise à jour. Vous devez afficher une autre instance de la variable dans la fenêtre d’évaluation pour obtenir sa valeur dans le contexte courant.