L'ouverture par programme de formulaires dans une application 1C gérée est très différente de leur ouverture dans une application standard. Regardons d'abord l'ancienne méthode. Elle consiste à recevoir un formulaire puis à l'ouvrir en mode normal ou modal (lorsqu'il est ouvert en mode modal, le formulaire bloque le programme).

GetForm() . Ouvrir()

Il s’agit de la méthode d’ouverture de formulaires la plus lente. Cependant, il vous permet de traiter le formulaire par programme avant de l'ouvrir. Pour traiter le code, vous devez modifier un peu :

Formulaire = ObtenirFormulaire( "Document. Réception des biens et services. Formulaire de document") ;
//Ici, nous effectuons des actions avec le formulaire
Formulaire. Ouvrir();

Il faut tenir compte du fait qu'à la réception du formulaire, une autre procédure événementielle sera exécutée QuandCrééSurServeur.

Examinons d'autres méthodes qui vous permettent d'ouvrir des formulaires dans une application 1C gérée plus rapidement et plus facilement. Selon la situation spécifique, différentes méthodes peuvent être utilisées.

1. Comment ouvrir un formulaire objet dans une application gérée s'il existe un lien vers celui-ci.

Dans ce cas, tout est extrêmement simple.

RefLink = Répertoires. Nomenclature. FindByCode("000000001" ) ;
OpenValue(RefLink) ;

2. Comment ouvrir le formulaire de sélection puis obtenir la valeur sélectionnée.

Il y a une fonction pour ça EntrezValeur(). La fonction a 3 paramètres :

• La variable dans laquelle la valeur sélectionnée sera écrite ;
• Un indice qui sera affiché dans la fenêtre de sélection ;
• Description des types de valeurs sélectionnées. Il peut y avoir plusieurs types, auquel cas vous serez invité à sélectionner un type avant de sélectionner une valeur spécifique.

À la suite de l'exécution de la fonction, le formulaire de sélection par défaut pour un objet du type spécifié s'ouvrira.

Valeur variable ;
Tableau= nouveau tableau ;
Tableau. Ajouter(Type( "RépertoireLink.Nomenclature") ) ;
Tableau. Ajouter(Type( "DirectoryLink. Contreparties") ) ;

TypeDescription= nouveau TypeDescription(Array) ;

Res = EnterValue(Valeur, "Indice", TypeDescription) ;

Les méthodes précédentes permettaient uniquement d'ouvrir les formulaires par défaut des objets (formulaire objet ou formulaire de sélection). Si vous devez ouvrir un formulaire personnalisé, vous pouvez utiliser la fonction OuvrirFormulaire().

Cette fonction a pas mal de paramètres. Examinons-en quelques-uns :

• Nom de forme— ici, vous pouvez sélectionner l'une des formes d'objet standard, par exemple, Formulaire de sélection ou Formulaire de liste. Ou un formulaire spécifique créé par les développeurs.
• Possibilités— vous permet de le transférer vers le formulaire dans le formulaire constructions certains paramètres avant de l'ouvrir, déterminant ainsi les données de sortie. Les paramètres peuvent être n'importe quelle donnée pouvant être transmise du client au serveur. Les paramètres passés à l'ouverture du formulaire peuvent être traités dans la procédure QuandCréationSurServeur() au formulaire en cours d'ouverture.
• Mode d'ouverture du formulaire— dispose de 3 options : indépendant, bloquer toute l'interface, bloquer le formulaire propriétaire.

Voyons comment la fonction est utilisée OuvrirFormulaire() dans diverses situations.

3. Comment ouvrir le formulaire d'un objet existant

Chaque formulaire possède un attribut clé. Il est mis en évidence en gras dans la liste des détails du formulaire et est généralement appelé Un objet sous forme d'éléments d'ouvrages et de documents de référence. D'autres objets peuvent avoir un nom différent. Pour ouvrir le formulaire d'un objet existant, vous devez passer un paramètre au formulaire en cours d'ouverture Clé avec la valeur comme référence à un objet.

&SurClient
Procédure Command1 (Commande)
Paramètre = nouvelle structure ;
Paramètre. Insérer("Clé" , FindC() ) ;
OpenForm(, Paramètre) ;
Fin de la procédure

&Sur le serveur
Fonction FindC();
Répertoires de retour. Contreparties. FindByRequisites ("TIN", "745107734623")
FinFonction

4. Comment ouvrir un nouveau formulaire d'objet

Une fonction simple fera l'affaire ici OuvrirFormulaire() sans aucun paramètre.

&SurClient
Procédure Command1 (Commande)
OuvrirFormulaire( "Répertoire. Contreparties. Forme d'objet") ;
Fin de la procédure

5. Comment ouvrir un nouveau formulaire d'objet et le remplir en fonction de quelque chose

Vous devez passer un paramètre Base, dont la valeur sera une référence à l'objet de base de remplissage. Cela lancera la procédure ProcessFill().

&SurClient
Procédure Command1 (Commande)
Paramètre = nouvelle structure ;
Paramètre. Insérer("Base", LinkToBuyerAccount) ;
OuvrirFormulaire( "Document. Ventes de biens et services. Forme d'objet", Paramètre) ;
Fin de la procédure

Cet exemple créera un document Ventes de biens et services et rempli sur la base d'une facture de paiement à l'acheteur dont le lien a été transmis.

6. Comment ouvrir un formulaire et y définir une sélection

La sélection sur les formulaires 1C peut être simple ou complexe. Une sélection simple implique des expressions telles que Organisation = Cornes et sabots LLC. La sélection complexe implique d'autres types de comparaison, par ex. Sur la liste. Dans cet article, nous examinerons l'organisation de la sélection simple, et un article distinct sera consacré à la sélection complexe.

Pour organiser une sélection simple, il faut passer un paramètre avec une clé au formulaire en cours d'ouverture Sélection, la valeur sera une structure dans laquelle la clé est le nom du champ de liste dynamique et la valeur est la donnée recherchée.

Par exemple, ouvrons le formulaire de liste de répertoires Numéros GTD et faites-y une sélection par propriétaire - élément de répertoire Nomenclature.

&SurClient
Procédure Command1 (Commande)
Paramètre = nouvelle structure ;

Sélection= nouvelle Structure ;
Sélection. Insert("Propriétaire", LinkToNomenclature) ;

Paramètre. Insérer("Sélection", Sélection) ;

OuvrirFormulaire( "Répertoire.Numéros GTD.Formulaire de liste", Paramètre) ;
Fin de la procédure

7. Comment ouvrir le formulaire d'inscription au registre d'information

Pour ce faire, vous aurez besoin de la clé d’entrée au registre d’informations.

Clé d'enregistrement— ce sont les valeurs de toutes les mesures et la période (si le registre est périodique). Autrement dit, une clé d'enregistrement correspond aux paramètres par lesquels un enregistrement peut être identifié de manière unique.

L'algorithme d'ouverture est le suivant :

1. Nous entrons les données clés de l'enregistrement avec les valeurs nécessaires dans la structure.
2. Nous plaçons la structure résultante dans un tableau.
3. Nous créons une clé d'enregistrement à partir du tableau.
4. On passe un paramètre au formulaire qui s'ouvre Clé avec la clé d'enregistrement de l'étape 3 comme valeur.

&SurClient
Procédure Command1 (Commande)
Paramètre = nouvelle structure ;

KeyParameters= nouvelle structure ;
Paramètres clés. Insérer("Nomenclature", LinkToNomenclature) ;
Paramètres clés. Insérer("TypePrix", LinkToPriceType) ;
Paramètres clés. Insérer("Période", Date) ;

KeyArray = Nouveau tableau ;
Tableau de clés. Ajouter(KeyParameters) ;

EntryKey = Nouveau ( "Informations RegisterRecord Key.PrixNomenclature", KeyArray) ;

Paramètre. Insérer("Clé", CléEnregistrement) ;

OuvrirFormulaire( "Registre d'informations. Prix de la nomenclature. Formulaire d'enregistrement", Paramètre) ;
Fin de la procédure

Pour ouvrir le formulaire de sélection avec sélection en 1s 8.2(formes régulières), nous devons effectuer certaines actions. Nous l'obtiendrons en premier. Après cela, nous définirons la sélection et l’ouvrirons par programme, voici un exemple de code :

Sélection sur le formulaire dans le champ de saisie 1C 8.2 avec plusieurs valeurs

Dans l'exemple ci-dessus, nous avons regardé comment définir la sélection sur le formulaire de sélection par valeur spécifique. Examinons maintenant une situation dans laquelle vous devez remplacer plusieurs valeurs, cela peut être, par exemple, un tableau ou déchargé à partir d'un résultat de requête. Ceci est une sélection dans le champ de saisie 1c avec de multiples significations.

Tout d'abord, nous obtenons le formulaire de sélection, passons « Élément » (propriétaire) dans les paramètres, définissons l'indicateur du mode de sélection. Ensuite on crée une liste de valeurs et un tableau, on note qu'en sélection lors de la définition du type de comparaison dans la liste, un objet ne peut être présent qu'avec le type ListeValeurs. Nous ajoutons des éléments au tableau, puis chargeons ce tableau dans la liste de valeurs, que nous définissons ensuite dans la sélection. N'oubliez pas non plus d'activer l'indicateur pour utiliser cette sélection et de définir le type de comparaison.

Définition de la sélection dans le champ de saisie du formulaire dans 1C 8.3, événement Début de sélection

Considérons maintenant sélection dans le champ de saisie sur un formulaire géré dans 1C 8.3. Retrouvons sur le formulaire l'élément qui nous intéresse, dans lequel nous allons paramétrer la sélection, dans notre cas il s'agit du champ « Organisation ». On retrouve l'événement « Début de sélection », on clique sur la loupe et on se retrouve dans la procédure. On voit le paramètre Selection Data ; ce paramètre est de type ValueList. Afin de limiter la sélection aux éléments nécessaires, nous devons remplir la liste de valeurs. Nous ne pouvons sélectionner des éléments que sur le serveur, nous créons donc une procédure avec la directive de compilation &OnServer. Dans cette procédure, remplissez les données de sélection.

Comment ouvrir une fiche d'un objet existant ?

Lors de l'ouverture d'un formulaire d'un objet existant, en plus du nom du formulaire, vous devez également indiquer l'objet dont le formulaire doit être ouvert. Pour ce faire, utilisez le paramètre de formulaire Key et un lien vers l'objet qui nous intéresse.

Par exemple, si à partir du formulaire de liste des organisations vous devez ouvrir le formulaire de l'organisation sur laquelle se trouve le curseur, vous pouvez le faire de la manière suivante :

Nous transmettons les paramètres de formulaire sous la forme d'une structure, où le nom de l'élément de structure correspond au nom du paramètre de formulaire et la valeur est la valeur à laquelle nous voulons définir le paramètre de formulaire.

Si vous souhaitez ouvrir non pas la forme principale, mais une forme arbitraire d'un objet créé dans le configurateur, au lieu du nom standard du formulaire principal (ObjectForm), indiquez le mot Formulaire suivi d'un point - le nom du formulaire créé dans le configurateur.

Par exemple:

ReferenceToDirectoryElement = Elements.List.CurrentRow ; FormParameters = Nouvelle Structure("Clé", ReferenceToDirectoryElement); OpenForm("Directory.Organizations.Form.UniversalObjectForm",FormParameters);

A noter que dans le cas où, en plus d'un lien vers un objet, aucun paramètre n'a besoin d'être passé au formulaire en cours d'ouverture et que c'est le formulaire principal de l'objet existant qui est nécessaire, vous pouvez utiliser une méthode plus simple - ouvrir le formulaire en suivant la procédure Valeur Ouverte():

OpenValue(Items.List.CurrentRow);

Cette méthode est moins polyvalente, mais dans certains cas, elle permet d'économiser du temps et des efforts. Par exemple, dans le cas considéré, une de ces lignes peut remplacer toute la procédure à trois lignes que nous avons écrite précédemment.

Il faut cependant être prudent lors de l'utilisation de cette procédure. Dans certains cas, cela peut entraîner des appels supplémentaires au serveur, par exemple lorsque vous devez ouvrir un formulaire d'élément de répertoire hiérarchique. Lors de l'utilisation de cette procédure, la plateforme fera un appel supplémentaire au serveur pour déterminer si un élément est un groupe ou non, puisqu'il faut ouvrir des formulaires différents pour l'élément et pour le groupe.

Dans le même temps, ces informations peuvent être connues à l'avance du développeur au sein de son algorithme et, à l'aide de la fonction OpenForm(), le développeur peut ouvrir le formulaire souhaité sans appels supplémentaires au serveur, en spécifiant immédiatement le nom standard du formulaire principal. formulaire.