Drucken (Strg+P)

Formularoptionen

1. Allgemeine Information

Formularparameter (Tab Parameter) dienen zwei Zwecken:
● Beschreiben Sie den Datensatz, der das Öffnen des Formulars beeinflusst (Formularparametrisierung). Dazu müssen Sie alle notwendigen Parameter auflisten und ihre Typen angeben.
● Definieren Sie die Parameter, die den Eindeutigkeitsschlüssel der Form beeinflussen. Dazu müssen Sie die Eigenschaft festlegen Schlüsselparameter diejenigen Parameter, die an der Bildung des Formulareindeutigkeitsschlüssels teilnehmen sollen. Wenn Sie versuchen, ein Formular zu öffnen, sucht das System mithilfe des generierten Formulareindeutigkeitsschlüssels nach einem vorhandenen Formular. Wenn es ein Formular mit dem erhaltenen Schlüssel im System gibt
Eindeutigkeit, dieses Formular wird zurückgegeben; wenn nicht, wird ein neues Formular erstellt.
Wenn ein Formular aufgerufen wird, können vom Entwickler erstellte Parameterwerte zusammen mit Formularsystemparametern (falls vorhanden) in der Parameterstruktur angegeben werden.
Formularparameter können dem Formular zum Zeitpunkt seiner Erstellung übergeben werden. Die Analyse der übergebenen Parameter kann im Ereignis durchgeführt werden OnCreateOnServer() (Die Parameters-Sammlung ist eine Eigenschaft des Objekts Verwaltetes Formular):

// Auf der Aufrufseite.
// Formularparameter bilden.
Parameter = Neue Struct();
Optionen.Einfügen("Bedeutung", Vordefinierter Wert(„Aufzählung.Wichtigkeit.Wichtig“));
// Öffnen Sie das Formular mit Parametern.
OpenForm("GeneralForm.ViewForm", Parameter);
…
// Im Formularmodul.
&Auf dem Server
Verfahren OnCreateOnServer (Fehler, Standardverarbeitung)
Wenn Parameter.Wichtigkeit = Aufzählungen.Wichtigkeit.Wichtig Oh dann
…
EndIf;
EndProzedur

AUFMERKSAMKEIT! Nach Aufruf des Eventhandlers OnCreateOnServer Alle Nicht-Schlüssel-Formularparameter werden aus der Parameters-Auflistung entfernt.
Beratung. Nicht wesentliche Formularparameter, die für die weitere Arbeit notwendig sind, müssen in den Formulardaten hinterlegt werden.

2. Standardformularoptionen

Um die automatische Interaktion zwischen Formularen zu unterstützen, bietet das System eine Reihe von Standardoptionen, mit denen Formulare beim Öffnen gesteuert werden. Mit Hilfe dieser Parameter implementiert das System in den Formularfeldern die Auswahl aus den Auswahlformularen, das Öffnen von Objektformularen, die Bedienung von Standardbefehlen usw. Das heißt, sie stellen verschiedene in das System eingebettete Sbereit.
Aber der Entwickler kann diese Parameter auch in der 1C:Enterprise-Sprache verwenden, indem er sie beim Aufruf der Methode OpenForm() übergibt.
Die Liste der Standardformularparameter in Abhängigkeit von der Art der Formularerweiterung finden Sie in den Abschnitten Eingebettete Sprache - Schnittstelle
(verwaltet) - Verwaltetes Formular - Erweiterung ... inline Verweise.

3. Ein Beispiel für die Arbeit mit Formularparametern

Um zu demonstrieren, wie die Formularparameter funktionieren, betrachten wir die Implementierung der Auswahl eines Elements im Eingabefeld. Die Essenz des Beispiels wird die Implementierung des Mechanismus zum Auswählen eines Elements aus der Liste in der eingebauten Sprache sein.
Wenn Sie beginnen, mit dem Beispiel zu arbeiten, benötigen Sie eine Konfiguration mit den folgenden Eigenschaften:
● es gibt ein Warenverzeichnis mit einer Hierarchie von Gruppen und Elementen;
● Es gibt ein Verzeichnis Analogues mit dem Attribut SelectedProduct vom Typ DirectoryLink.Produkte;
● Beide Nachschlagewerke haben Item-Formulare.
Jetzt implementieren wir in dieser Konfiguration alle Mechanismen, die die Plattform verwendet, um ein Element aus der Liste auszuwählen, in der integrierten Sprache. Dabei werden wir sehen:
● wie Standardformularparameter verwendet werden;
● wie das System sie verwendet;
● wie ein Entwickler sie verwenden kann.
Lassen Sie uns hinzufügen zusätzlicher Parameter Ein , das das Schließen des Auswahlformulars steuert, nachdem ein Element ausgewählt wurde. Nennen wir diesen Parameter SchließenNachAuswahl(boolescher Typ). Fügen wir es als Parameter des Formulars Auswahlformular des Warenverzeichnisses hinzu.
Um das Elementauswahlformular zu öffnen, ist es notwendig, einen Event-Handler für das SelectStart-Event am SelectedItem-Formularelement in Form des Analogues-Verzeichniselements anzulegen.

&BeiKunde
Verfahren SelectedItemSelectionStart(Item, StandardProcessing)
Standardverarbeitung= falsch ;
Wahlmöglichkeiten= Neue Struktur ;
SelectionParameters.Insert(„Auswahlmodus“, True);
SelectionParameters.Insert(„SelectGroupsAndItems“, UsingGroupsAndItems.Items);
SelectionParameters.Insert(„AllowRootSelection“, False);
SelectionParameters.Insert(„Aktuelle Linie“, Objekt.SelectedItem);
SelectionParameters.Insert(„CloseAfterSelection“, Falsch);
OpenForm("Katalog.Produkte.Auswahlformular", Wahlmöglichkeiten, Items.SelectedProduct);
EndProzedur
Auf den dritten Parameter der OpenForm()-Methode sollten wir gesondert eingehen. Dieser Parameter bestimmt, wer Eigentümer des Auswahlformulars ist und wer über die getroffene Auswahl benachrichtigt wird. IN dieser Fall Wir haben das Formularelement selbst als Eigentümer des Auswahlformulars angegeben, aber wir können mit diesem Parameter auch das Formular selbst angeben. In diesem Fall muss der Handler implementiert werden HandlingChoice Formularmodul und entscheiden Sie darin, in welches Formularattribut die ausgewählten Daten platziert werden sollen.
HINWEIS. Wenn wir den Ereignishandler StartChoice nicht implementieren, führt das System seine Aktionen selbst aus. Dies gilt für alle weiteren Handler, die im Beispiel verwendet werden.
Jetzt müssen wir die übergebenen Parameter im Auswahlformular verarbeiten. Lassen Sie es uns im Handler tun OnCreateOnServer() des ausgewählten Formularmoduls.

&Auf dem Server
Verfahren OnCreateOnServer (Fehler, Standardverarbeitung)
Standardverarbeitung= falsch ;
Elements.List.SelectGroupsAndItems = Parameters.SelectGroupsAndItems;
Elements.List.AllowSelectRoot = Parameter.AllowSelectRoot;
Items.List.CurrentRow = Parameters.CurrentRow;
CloseOnSelection = Parameters.CloseAfterSelection;
EndProzedur
Um die Performance der von uns eingestellten Formularparameter zu überprüfen, setzen wir mit Hilfe des Konfigurators die List-Eigenschaft der Auswahlformulartabelle Wählen Sie GroupsAndItems aus auf den Wert Gruppen (ohne Anwendung des Parameters ist die Auswahl der Wörterbuchelemente nicht verfügbar).
HINWEIS. Wenn in der List-Tabelle, die eine Liste von Produkten anzeigt, die SelectionMode-Eigenschaft nicht auf True festgelegt ist, ist die Produktauswahl nicht verfügbar.
Nun müssen wir die Auswahl des gewünschten Artikels im Auswahlformular vornehmen. Dazu müssen Sie einen Eventhandler für das SelectValues-Ereignis der Formulartabelle definieren.

&BeiKunde
Verfahren ListSelectionValues(Item, StandardProcessing, Value)
Standardverarbeitung= falsch ;
NotifySelection(Wert);
EndProzedur
Es bleibt uns überlassen, die Verarbeitung der Auswahl eines Elements im Eingabefeld selbst zu implementieren. Dazu müssen Sie das Ereignis behandeln HandlingChoice unser Eingabefeld SelectedProduct.

&BeiKunde
Verfahren SelectedItemProcessingChoice(Item, SelectedValue, StandardProcessing)
Standardverarbeitung= falsch ;
Object.SelectedItem = AusgewählterWert;
EndProzedur
Wir haben unabhängig einen Systemmechanismus zur Auswahl eines Werts im Eingabefeld des Formulars implementiert.
AUFMERKSAMKEIT! Dieses Beispiel ist nicht vollständig. Sein einziger Zweck ist es, die Mechanik der Arbeit mit Formularparametern zu demonstrieren.
Wenn beim Erstellen von Parametern (handler SelectedItemSelectionStart()) ersetzen Sie die Zeile:

SelectionParameters.Insert(„CloseAfterSelection“, True );
zur Zeile:
SelectionParameters.Insert(„CloseAfterSelection“, False) ;
dann wird das Auswahlformular nicht mehr geschlossen, nachdem die Auswahl getroffen wurde. Dies kann zum Beispiel verwendet werden, um ein Auswahlformular zu implementieren (Auswahl mehrerer Produkte, ohne das Auswahlformular zu schließen).

Um die automatische Interaktion zwischen Formularen zu unterstützen, bietet das System eine Reihe von Standardoptionen, mit denen Formulare beim Öffnen gesteuert werden. Mit Hilfe dieser Parameter implementiert das System in den Formularfeldern die Auswahl aus den Auswahlformularen, das Öffnen von Objektformularen, die Bedienung von Standardbefehlen usw. Das heißt, sie stellen verschiedene in das System eingebettete Sbereit. Aber der Entwickler kann diese Parameter auch in der 1C:Enterprise-Sprache verwenden, indem er sie beim Aufruf der Methode OpenForm() übergibt.

Wir listen die vom System bereitgestellten Parameter und deren Zweck auf:

• Auswahlmodus– das Formular öffnet sich im Auswahlmodus. Durch Erweiterung bereitgestellt verwaltetes Formular dynamische Liste.
• AktuelleLinie– eine Zeichenfolge, die beim Öffnen in der Liste aktiviert wird. Es wird ein Wert übergeben, der die Zeichenfolge identifiziert. Wird von der Erweiterung für verwaltete Formulare mit dynamischer Liste bereitgestellt.
• Wählen Sie GroupsAndItems aus– Dieser Parameter legt die Eigenschaft SelectGroupAndItems der Tabelle des Hauptattributs des Formulars fest. Wird von der Erweiterung für verwaltete Formulare mit dynamischer Liste bereitgestellt.
• AllowSelectionRoot– bestimmt, ob die Wurzel im Formular mit einer als Baum dargestellten dynamischen Liste ausgewählt werden kann. Bereitgestellt von der verwalteten Formularerweiterung einer dynamischen Liste, die als Baum angezeigt wird.
• Auswahl– Auswahlsatz in einer dynamischen Liste. Stellt eine Struktur dar. Die Namen der Elemente entsprechen den Namen der Felder, nach denen die Auswahl getroffen wird, und die Werte enthalten die Werte der Auswahl. Wird von der Erweiterung für verwaltete Formulare mit dynamischer Liste bereitgestellt.
• Taste– Wert, der das bearbeitete Objekt im Formular identifiziert. Wenn der Wert fehlt oder falsch ist, wird ein neues Objekt mit den verbleibenden Parametern erstellt. Wird von Objektformularen und Erweiterungen des Datensatzmanagers für Informationsregister bereitgestellt.
• WertKopie– ein Wert, der das Objekt identifiziert, das beim Erstellen eines neuen Objekts zum Kopieren verwendet wird. Wird von Objektformularen und Erweiterungen des Datensatzmanagers für Informationsregister bereitgestellt.
• Werte ausfüllen– Werte zum Ausfüllen der Details des neuen Objekts. Stellt eine Struktur dar. Die Namen der Elemente entsprechen den Namen der Attribute, und die Werte enthalten die Daten, die zum Ausfüllen der angegebenen Attribute verwendet werden. Wird von Objektformularen und Erweiterungen des Datensatzmanagers für Informationsregister bereitgestellt.
• Base– ein Wert, der das Objekt identifiziert, das als Basis verwendet wird, wenn ein neues Objekt durch Eingabe auf der Basis erstellt wird. Wird von Objektformularerweiterungen bereitgestellt.
• Diese Gruppe– definiert den Typ des neuen Objekts: Gruppe oder Element. Wird von Objektformularerweiterungen bereitgestellt.

Beispiel für die Arbeit mit Formularparametern

Um zu demonstrieren, wie die Formularparameter funktionieren, betrachten wir die Implementierung der Auswahl eines Elements im Eingabefeld. Die Essenz des Beispiels wird die Implementierung des Mechanismus zum Auswählen eines Elements aus der Liste in der eingebauten Sprache sein.

Wenn Sie beginnen, mit dem Beispiel zu arbeiten, benötigen Sie eine Konfiguration mit den folgenden Eigenschaften:

• Der Hauptstartmodus ist Managed Application;
• es gibt ein Warenverzeichnis mit einer Hierarchie von Gruppen und Elementen;
• es gibt ein Verzeichnis Analogues mit dem Attribut SelectedItem vom Typ DirectoryReference.Goods;
• Beide Nachschlagewerke verfügen über verwaltete Elementformulare.

Jetzt implementieren wir in dieser Konfiguration alle Mechanismen, die die Plattform verwendet, um ein Element aus der Liste auszuwählen, in der integrierten Sprache. Dabei werden wir sehen, wie die Standard-Formularparameter verwendet werden; wie das System selbst sie verwendet; wie ein Entwickler sie verwenden kann.

Lassen Sie uns ein zusätzliches Flag hinzufügen, das das Schließen des Auswahlformulars steuert, nachdem ein Element ausgewählt wurde. Nennen wir dieses Flag CloseAfterSelection (boolescher Typ). Fügen wir es als Formularparameter des Warenverzeichnis-Auswahlformulars hinzu.

Um das Elementauswahlformular zu öffnen, muss ein Ereignishandler für das SelectStart-Ereignis für das SelectedItem-Formularelement im Analogues-Katalogelementformular erstellt werden:

&BeiKunde

Prozedur SelectedItemSelectionStart(Item, StandardProcessing)

Standardverarbeitung = Falsch;

Wahlparameter = Neue Struktur; SelectionParameters.Insert("SelectionMode", True); SelectionParameters.Insert("SelectGroupsAndItems", UseGroupsAndItems.Elements); SelectionParameters.Insert("AllowRootSelection", False); ChoiceParameters.Insert("CurrentRow", Object.SelectedItem); SelectionParameters.Insert("CloseAfterSelection", False); OpenForm("Catalog.Products.ChoiceForm", ChoiceParameters, Elements.SelectedProduct);

EndProzedur

Auf den dritten Parameter der OpenForm()-Methode sollten wir gesondert eingehen. Dieser Parameter bestimmt, wer Eigentümer des Auswahlformulars ist und wer über die getroffene Auswahl benachrichtigt wird. In diesem Fall haben wir das Formularelement selbst als Besitzer des Auswahlformulars angegeben, aber wir können mit diesem Parameter auch das Formular selbst angeben. In diesem Fall muss der SelectProcess-Handler des Formularmoduls implementiert und darin entschieden werden, in welches Formularattribut die ausgewählten Daten platziert werden sollen.

Das programmgesteuerte Öffnen von Formularen in einer verwalteten 1C-Anwendung unterscheidet sich erheblich vom Öffnen in einer regulären Anwendung. Beginnen wir mit der alten Methode. Es besteht darin, das Formular zu erhalten und es anschließend im normalen oder modalen Modus zu öffnen (wenn es im modalen Modus geöffnet wird, blockiert das Formular das Programm).

GetForm() . Offen()

Dies ist die langsamste Methode zum Öffnen von Formularen. Es ermöglicht Ihnen jedoch, das Formular programmgesteuert zu verarbeiten, bevor Sie es öffnen. Für die Verarbeitung muss der Code leicht modifiziert werden:

Formular= GetForm( "Dokument. Erhalt von Waren und Dienstleistungen. Dokumentform") ;
//Hier führen wir Aktionen mit dem Formular aus
Die Form. Offen() ;

Es ist zu beachten, dass nach Eingang des Formulars ein weiteres Ereignisverfahren durchgeführt wird OnCreateOnServer.

Ziehen Sie andere Methoden in Betracht, mit denen Sie Formulare in einer verwalteten 1C-Anwendung schneller und bequemer öffnen können. Je nach Situation können unterschiedliche Methoden zum Einsatz kommen.

1. So öffnen Sie das Formular eines Objekts in einer verwalteten Anwendung, wenn ein Link darauf vorhanden ist.

In diesem Fall ist alles sehr einfach.

RefReference= Referenzen. Nomenklatur. FindByCode("000000001" );
OpenValue(ReferenzReferenz) ;

2. Wie man ein Auswahlformular öffnet und dann den ausgewählten Wert erhält.

Dafür gibt es eine Funktion EnterValue(). Die Funktion hat 3 Parameter:

• Die Variable, in die der ausgewählte Wert geschrieben wird;
• Der Hinweis, der im Auswahlfeld angezeigt wird;
• Beschreibung der Typen ausgewählter Werte. Es kann mehrere Typen geben. Bevor Sie einen bestimmten Wert auswählen, werden Sie aufgefordert, einen Typ auszuwählen.

Als Ergebnis der Funktionsausführung öffnet sich das Standardauswahlformular für das Objekt des angegebenen Typs.

Variablenwert;
Array= neues Array;
Array. Hinzufügen(Typ( "DirectoryLink.Nomenklatur") ) ;
Array. Hinzufügen(Typ( "DirectoryLink. Gegenparteien") ) ;

TypeDescription= neue TypeDescription(Array) ;

Res= EnterValue(Value, "Hint" , TypeDescription) ;

Die vorherigen Methoden erlaubten nur das Öffnen der standardmäßig für Objekte eingestellten Formulare (Objektformular oder Auswahlformular). Wenn Sie ein beliebiges Formular öffnen müssen, können Sie die Funktion verwenden OpenForm().

Diese Funktion hat einige Parameter. Betrachten wir einige davon:

• Formularname- Hier können Sie eine der Standardformen des Objekts auswählen, zum Beispiel Formularauswahl oder Formularliste. Oder ein bestimmtes Formular, das von den Entwicklern erstellt wurde.
• Parameter- ermöglicht Ihnen, zum Formular im Formular zu wechseln Strukturen einige Parameter vor dem Öffnen und bestimmen damit die Ausgabedaten. Parameter können beliebige Daten sein, die vom Client an den Server übergeben werden können. Die beim Öffnen des Formulars übergebenen Parameter können in der Prozedur verarbeitet werden OnCreateOnServer() auf dem geöffneten Formular.
• Modus zum Öffnen des Formulars- hat 3 Optionen: unabhängig, die gesamte Schnittstelle blockieren, das Eigentümerformular blockieren.

Mal sehen, wie die Funktion verwendet wird OpenForm() in verschiedenen Situationen.

3. Wie man das Formular eines bestehenden Objekts öffnet

Jedes Formular hat ein Schlüsselattribut. Es ist in der Liste der Formularattribute fett hervorgehoben und wird normalerweise aufgerufen Ein Objekt bei den formen der elemente der verzeichnisse, der dokumente. Andere Objekte können einen anderen Namen haben. Um das Formular eines vorhandenen Objekts zu öffnen, müssen Sie den Parameter an das geöffnete Formular übergeben Taste mit Wert als Objektreferenz.

&BeiKunde
Prozedur Befehl1 (Befehl)
Parameter= neue Struktur;
Parameter. Insert("Schlüssel" , FindC() ) ;
OpenForm(, Parameter) ;
EndProzedur

&Auf dem Server
FindC()-Funktion;
Rückgabehandbücher. Gegenparteien. FindByAttribute ("TIN", "745107734623")
Endfunktionen

4. So öffnen Sie das Formular eines neuen Objekts

Dies ist nur eine Funktion OpenForm() ohne Parameter.

&BeiKunde
Prozedur Befehl1 (Befehl)
OpenForm( "Nachschlagewerk. Kontrahenten. Objektform") ;
EndProzedur

5. Wie man ein neues Objektformular öffnet und es basierend auf etwas ausfüllt

Muss einen Parameter übergeben Base, dessen Wert ein Verweis auf das Füllbasisobjekt ist. Dadurch wird der Vorgang gestartet HandleFill().

&BeiKunde
Prozedur Befehl1 (Befehl)
Parameter= neue Struktur;
Parameter. Insert("Grund" , LinkToAccountToBuyer) ;
OpenForm( "Dokument. Realisierung von Waren und Dienstleistungen. Gegenstandsform", Parameter) ;
EndProzedur

In diesem Beispiel wird ein Dokument erstellt Verkauf von Waren und Dienstleistungen und anhand der Rechnung zur Zahlung an den Käufer ausgefüllt, auf die der Link übertragen wurde.

6. Wie man ein Formular öffnet und eine Auswahl darauf setzt

Die Auswahl auf 1C-Formularen kann einfach und komplex sein. Einfache Auswahl beinhaltet Ausdrücke wie Organisation = Horns and Hooves LLC. Komplexe Auswahl umfasst andere Arten von Vergleichen, z. B. Gelistet. In diesem Artikel werden wir die Organisation einer einfachen Auswahl betrachten, und der komplexen wird ein separater Artikel gewidmet.

Um eine einfache Auswahl zu organisieren, müssen Sie einen Parameter mit dem Schlüssel an das geöffnete Formular übergeben Auswahl, ist der Wert eine Struktur, in der der Schlüssel der Name des dynamischen Listenfelds und der Wert die zu durchsuchenden Daten sind.

Lassen Sie uns beispielsweise das Nachschlagelistenformular öffnen Nicht-GTE und wir werden dort vom Eigentümer eine Auswahl treffen - das Element des Verzeichnisses Nomenklatur.

&BeiKunde
Prozedur Befehl1 (Befehl)
Parameter= neue Struktur;

Auswahl= neue Struktur;
Auswahl. Insert("Eigentümer", LinkToNomenclature) ;

Parameter. Einfügen("Auswahl", Auswahl) ;

OpenForm( "Verzeichnis.GTE-Nummern.Listenformular", Parameter) ;
EndProzedur

7. So öffnen Sie das Informationsregister-Eintragsformular

Dazu benötigen Sie einen Datensatzschlüssel des Auskunftsregisters.

Aufnahmeschlüssel sind die Werte aller Messungen und die Periode (wenn das Register periodisch ist). Das heißt, der Schlüssel des Datensatzes sind die Parameter, durch die der Datensatz eindeutig identifiziert werden kann.

Der Öffnungsalgorithmus ist wie folgt:

1. Wir tragen die Datensatz-Schlüsseldaten mit den notwendigen Werten in die Struktur ein.
2. Wir platzieren die resultierende Struktur in einem Array.
3. Aus dem Array erstellen wir den Datensatzschlüssel.
4. Übergabe eines Parameters an das geöffnete Formular Taste mit dem Satzschlüssel aus Punkt 3 als Wert.

&BeiKunde
Prozedur Befehl1 (Befehl)
Parameter= neue Struktur;

Schlüsselparameter = neue Struktur;
Schlüsselparameter. Insert("Nomenklatur", LinkToNomenklatur) ;
Schlüsselparameter. Insert("PriceType" , LinkToPriceType) ;
Schlüsselparameter. Insert("Periode", Datum) ;

ArrayKey = Neues Array;
ArrayKey. Hinzufügen (Schlüsselparameter) ;

Datensatzschlüssel = Neu ( "Information RegisterRecordKey.NomenclaturePrices", ArrayKey) ;

Parameter. Insert("Schlüssel", RecordKey) ;

OpenForm( "Informationsregister. Nomenklaturpreise. Aufzeichnungsformular", Parameter) ;
EndProzedur

In diesem Artikel wird beschrieben, wie beim Öffnen eines verwalteten Formulars 8.2 ein Wert als Parameter übergeben wird, im Vergleich dazu, wie ein ähnlicher Vorgang in regulären Formularen implementiert werden könnte.

Wie Parameter in normalen Formen übergeben werden

In normalen Formen gab es 2 Möglichkeiten einen Parameter zu übergeben:
1) eine weniger verbreitete Methode: in Form eines Objekts auf der Registerkarte "Details", die Details wurden hinzugefügt, falls erforderlich, wurde der Zugriff mit visuellen Mitteln bestimmt
2) ein gängigerer Weg: Im Formularmodul wurde eine Exportvariable deklariert und der Wert im „BeforeOpening“-Handler verarbeitet

In beiden Fällen sah der Formularaufruf etwa so aus:

Form = Object.GetForm("ChoiceForm",FormOwner,UniqueKey);
Form.Parameter = ParameterWert;
Formular.Öffnen();

Wie Parameter in verwalteten Formularen übergeben werden

Verwaltete Formulare haben jetzt die Möglichkeit, Parameter sofort zu übergeben, wenn das Formular empfangen wird. Parameter werden als Struktur übergeben:

Parameter = Neue Struktur ("CurrentValue", LastItem);
ChoiceForm = GetForm("Catalog.Nomenclature.ChoiceForm",Parameters);
FoundItem = ChoiceForm.OpenModal();

Außerdem hat das verwaltete Formular "Formularerweiterungen" (Objekt, Verzeichnis, Dokument, Bericht). Abhängig vom Objekttyp wird die Liste der verfügbaren Parameter bestimmt. Wenn Sie beispielsweise im Wörterbuchauswahlformular auf ein bestimmtes Element positionieren müssen, wird der Parameter „CurrentValue“ verwendet. Das große Plus ist, dass im Formular selbst keine Handler für vordefinierte Parameter geschrieben werden müssen, was die Codemenge reduziert.

Außerdem hat der Entwickler die Möglichkeit, eigene Parameter zu definieren (im Designer des verwalteten Formulars, Registerkarte „Parameter“). Die Lebensdauer der Parameter wird durch den OnCreateOnServer-Handler begrenzt, was logisch ist, weil Parameter sind nur beim Erstellen des Formulars erforderlich, aber wenn dieser Parameter die Eindeutigkeit des Formulars bestimmt (das Flag "Schlüsselparameter" ist in den Parametereigenschaften gesetzt), ist er in anderen Handlern verfügbar.

Um einen bestimmten Manipulationsparameter zu übergeben, müssen Sie etwas mehr tun:

1) Definieren Sie einen Parameter in einem verwalteten Formular.
Definieren Sie im Handler OnCreateAtServer die Verarbeitung dieses Parameters (Zugriff auf die übergebenen Parameter über die Eigenschaft „Parameters“ des Typs FormDataStructure)
2) Beschreiben Sie den Empfang des Formulars und übergeben Sie den Wert des neuen Parameters in den Parametern der Funktion GetForm.
Der Code sieht also so aus:
- Am Ort des Eingangs des Formulars

Parameter = Neue Struktur ("NeuerParameter", LetztesElement);
ChoiceForm = GetForm("Catalog.Nomenclature.ChoiceForm",Parameters);

In einem verwalteten Formularmodul

&Auf dem Server
Verfahren auf CreationOnServer (Ausfall, Standardverarbeitung)
If Parameters.Property("NewParameter") Then
// Parameterverarbeitungscode hier
EndIf;
EndProzedur

Fazit

Vielleicht ist dieser Artikel für jemanden nützlich, er spart Zeit und erspart Ihnen unnötigen Code. Nähere Informationen zu vollständige Liste Parameter eines verwalteten Formulars, wird empfohlen, in der Hilfe "Verwaltete Schnittstelle \ Verwaltetes Formular" nachzusehen.

[Sie müssen sich registrieren, um den Link anzuzeigen]