1c deschideți formularul cu parametri. Trecerea parametrilor către formulare gestionate și regulate

Pentru a sprijini interacțiunea automată între formulare, sistemul oferă o serie de parametri standard care sunt utilizați pentru a controla formularele atunci când sunt deschise. Folosind acești parametri, sistemul implementează în câmpurile de formular selecția din formulare de selecție, deschiderea formularelor obiect, operarea comenzilor standard etc. Adică oferă diverse scenarii de operare a interfeței încorporate în sistem. Dar dezvoltatorul poate folosi acești parametri și în limbajul încorporat, transmițându-i atunci când apelează metoda OpenForm().

Enumerăm parametrii furnizați de sistem și scopul lor:

Modul de selecție– formularul se deschide în modul de selecție. Furnizat de extensia de formular gestionată de listă dinamică.
CurrentRow– un șir care va fi activat în listă când este deschis. Se transmite o valoare care identifică rândul. Furnizat de extensia de formular gestionată din lista dinamică.
Selectarea grupurilor și a elementelor– acest parametru setează proprietatea Selection of Groups and Elements din tabelul atributului principal al formularului. Furnizat de extensia de formular gestionată din lista dinamică.
AllowSelectRoot– definește capacitatea de a selecta o rădăcină într-o formă cu o listă dinamică afișată ca arbore. Furnizat de o extensie de formular gestionată pentru o listă dinamică afișată ca arbore.
Selecţie– set de selecție într-o listă dinamică. Reprezintă o structură. Numele elementelor corespund denumirilor câmpurilor prin care se face selecția, iar valorile conțin valorile selecției. Furnizat de extensia de formular gestionată de listă dinamică.
Cheie– o valoare care identifică obiectul care se editează în formular. Dacă valoarea lipsește sau este incorectă, se creează un nou obiect folosind parametrii rămași. Furnizat de extensii de formulare de obiect și manager de înregistrare a registrului de informații.
Copiați valoarea– o valoare care identifică obiectul care va fi folosit pentru copiere la crearea unui nou obiect. Furnizat de extensii de formulare de obiect și manager de înregistrare a registrului de informații.
Valori de umplere– valori pentru completarea detaliilor unui obiect nou. Reprezintă o structură. Numele elementelor corespund denumirilor detaliilor, iar valorile conțin datele care vor fi folosite pentru completarea detaliilor specificate. Furnizat de extensii de formulare de obiect și manager de înregistrare a registrului de informații.
Baza– o valoare care identifică obiectul care va fi folosit ca bază la crearea unui nou obiect prin introducere pe bază. Furnizat de extensii de formulare de obiect.
Acest grup– definește tipul de obiect nou: grup sau element. Furnizat de extensii de formulare de obiect.

Un exemplu de lucru cu parametrii formularului

Până când începeți să lucrați cu exemplul, trebuie să aveți o configurație cu următoarele proprietăți:

Mod de lansare principal – Aplicație gestionată;
există un director Produse cu o ierarhie de grupuri și elemente;
există un director Analogi cu atributul SelectedProduct de tip DirectoryLink.Products;
ambele directoare au forme de elemente gestionate.

Acum să implementăm în această configurație toate mecanismele pe care platforma le folosește pentru a selecta un element din listă în limbajul încorporat. Procedând astfel, vom vedea cum sunt utilizați parametrii de formular standard; modul în care sistemul însuși le folosește; cum le poate folosi un dezvoltator.

Să adăugăm un steag suplimentar care va controla închiderea formularului de selecție după selectarea unui element. Să numim acest flag CloseAfterSelection (de tip boolean). Să-l adăugăm ca parametru de formular Formular pentru selectarea directorului Produse.

Pentru a deschide formularul de selecție a elementelor, trebuie să creați un handler de evenimente pentru evenimentul Începutul selecției pentru elementul de formular Produs selectat sub forma elementului de director Analogues:

&OnClient

Procedură SelectedProductStartSelection(Articol, Procesare standard)

StandardProcessing = Fals;

SelectionParameters = Structură nouă; SelectionParameters.Insert("SelectionMode", True); SelectionParameters.Insert("SelectingGroupsAndElements", UsingGroupsAndElements.Elements); SelectionParameters.Insert("AllowRootSelection", False); SelectionParameters.Insert("CurrentRow", Object.SelectedProduct); SelectionParameters.Insert("CloseAfterSelection", False); OpenForm("Directory.Products.SelectionForm", SelectionParameters, Elements.SelectedProduct);

EndProcedure

Este necesar să ne oprim separat asupra celui de-al treilea parametru al metodei OpenForm(). Acest parametru determină cine va fi proprietarul formularului de selecție și cine va fi anunțat despre selecția efectuată. În acest caz, am specificat elementul formular în sine ca proprietar al formularului de selecție, dar putem specifica și formularul în sine cu acest parametru. În acest caz, va fi necesar să se implementeze handlerul de procesare a selecției modulului de formular și să se decidă în ce atribut de formular să plaseze datele selectate.

Acest articol descrie cum să folosiți mijloace standard pentru a trece o valoare ca parametru la deschiderea unui formular gestionat 8.2, în comparație cu modul în care o operație similară ar putea fi implementată în forme obișnuite.

Cum se transmit parametrii în forme obișnuite

În formele obișnuite, existau 2 posibilități pentru a trece un parametru:
1) o metodă mai puțin obișnuită: în forma obiectului din fila „Detalii”, au fost adăugate atribute și, dacă este necesar, accesul a fost determinat prin mijloace vizuale
2) o metodă mai comună: o variabilă de export a fost declarată în modulul formular și valoarea a fost procesată în handlerul „Înainte de deschidere”

în ambele cazuri, apelul de formular arăta cam așa:

Form = Object.GetForm("SelectionForm",FormOwner, UniquenessKey);
Form.Parameter = ParameterValue;
Form.Open();

Cum sunt transferați parametrii în formularele gestionate

Formularele gestionate au acum capacitatea de a transmite imediat parametri atunci când formularul este primit. Parametrii sunt transmiși ca o structură:

Parametri = New Structure("CurrentValue", LastElement);
SelectionForm = GetForm("Director. Nomenclatura.SelectionForm", Parametri);
FoundItem = SelectionForm.OpenModal();

De asemenea, formularul gestionat are acum „extensii de formular” (obiect, carte de referință, document, raport). În funcție de tipul de obiect, se determină compoziția parametrilor disponibili. De exemplu, dacă în formularul de selecție a directorului trebuie să vă poziționați pe un anumit element, atunci este utilizat parametrul „CurrentValue”. Marele avantaj este că formularul în sine nu necesită handlere de scriere pentru parametri predefiniți, ceea ce reduce cantitatea de cod.

Dezvoltatorul are, de asemenea, posibilitatea de a-și defini propriii parametri (în designerul de formulare gestionate, fila „Parametri”). Durata de viață a parametrilor este limitată de handlerul OnCreationOnServer, ceea ce este logic deoarece parametrii sunt necesari numai la crearea unui formular, dar dacă acest parametru determină unicitatea formularului (steagul „parametru cheie” este setat în proprietățile parametrilor), acesta va fi disponibil în alți handlere.

Pentru a trece un anumit parametru de manipulare, trebuie să faceți puțin mai mult:

1) Definiți parametrul într-o formă controlată.
În handlerul OnCreationOnServer, definiți procesarea acestui parametru (acces la parametrii trecuți prin proprietatea „Parameters”, care are tipul FormDataStructure)
2) Descrieți primirea formularului și transmiteți valoarea noului parametru în parametrii funcției GetForm.
Astfel, codul va arăta astfel:
- La locul unde primiți formularul

Parametri = New Structure("NewParameter", LastElement);
SelectionForm = GetForm("Director. Nomenclature.SelectionForm", Parametri);

Într-un modul de formular gestionat

&Pe server
Procedură când este creat pe server (Eșec, procesare standard)
Dacă Parameters.Property("NewParameter") Atunci
// aici este codul de procesare a parametrilor
endIf;
EndProcedure

Concluzie

Poate că acest articol va fi util cuiva, va economisi timp și vă va scuti de codurile inutile. Pentru informații mai detaliate despre lista completă a parametrilor de formular gestionați, se recomandă să consultați ajutorul „Interfață gestionată\Formular gestionat”.

[trebuie să vă înregistrați pentru a vedea linkul]

Deschiderea programatică a formularelor într-o aplicație gestionată 1C este semnificativ diferită de deschiderea lor într-o aplicație obișnuită. Să ne uităm mai întâi la vechea metodă. Constă în primirea unui formular și apoi deschiderea lui în mod normal sau modal (când este deschis în mod modal, formularul blochează programul).

GetForm() . Deschis()

Aceasta este cea mai lentă metodă de deschidere a formularelor. Cu toate acestea, vă permite să procesați în mod programatic formularul înainte de a-l deschide. Pentru a procesa codul, trebuie să schimbați puțin:

Formular = GetForm( "Document. Primirea bunurilor și serviciilor. Formular document") ;
//Aici efectuăm acțiuni cu formularul
Formă. Deschis();

Trebuie avut în vedere că la primirea formularului se va executa o altă procedură eveniment WhenCreatedOnServer.

Să ne uităm la alte metode care vă permit să deschideți formulare într-o aplicație gestionată 1C mai rapid și mai convenabil. În funcție de situația specifică, pot fi utilizate diferite metode.

1. Cum se deschide un formular de obiect într-o aplicație gestionată dacă există un link către acesta.

În acest caz, totul este extrem de simplu.

RefLink = Directoare. Nomenclatură. FindByCode("000000001");
OpenValue(RefLink) ;

2. Cum se deschide formularul de selecție și apoi se obține valoarea selectată.

Există o funcție pentru asta EnterValue(). Funcția are 3 parametri:

Variabila în care va fi scrisă valoarea selectată;
Un indiciu care va fi afișat în fereastra de selecție;
Descrierea tipurilor de valori selectate. Pot exista mai multe tipuri, caz în care vi se va solicita să selectați un tip înainte de a selecta o anumită valoare.

Ca rezultat al executării funcției, se va deschide formularul de selecție implicit pentru un obiect de tipul specificat.

Valoare variabilă;
Array= nou Array;
Matrice. Adăugați(Tip( „DirectoryLink.Nomenclatură”) ) ;
Matrice. Adăugați(Tip( „DirectoryLink. Contrapărți”) ) ;

TypeDescription= new TypeDescription(Array) ;

Res = EnterValue(Valoare, „Hint” , TypeDescription) ;

Metodele anterioare vă permiteau doar să deschideți formularele implicite pentru obiecte (formular obiect sau formular de selecție). Dacă trebuie să deschideți un formular personalizat, puteți utiliza funcția OpenForm().

Această funcție are destul de mulți parametri. Să ne uităm la unele dintre ele:

Numele formularului— aici puteți selecta oricare dintre formele standard de obiect, de exemplu, Formular de selecție sau Formular de listă. Sau un formular specific creat de dezvoltatori.
Opțiuni— vă permite să îl transferați în formularul din formular structurilor anumiți parametri înainte de a-l deschide, determinând astfel datele de ieșire. Parametrii pot fi orice date care pot fi transmise de la client la server. Parametrii trecuți la deschiderea formularului pot fi procesați în procedură WhenCreatingOnServer() la formularul care se deschide.
Modul deschidere formular— are 3 opțiuni: independent, blocați întreaga interfață, blocați formularul de proprietar.

Să vedem cum este utilizată funcția OpenForm() in diverse situatii.

3. Cum se deschide forma unui obiect existent

Fiecare formular are un atribut cheie. Este evidențiată cu caractere aldine în lista detaliilor formularului și este de obicei numită Un obiect sub forme de elemente de cărţi de referinţă şi documente. Alte obiecte pot avea un nume diferit. Pentru a deschide o formă a unui obiect existent, trebuie să treceți un parametru formularului care se deschide Cheie cu valoarea ca referință la un obiect.

&OnClient
Procedură Comanda 1 (Comandă)
Parametru= structură nouă;
Parametru. Insert("Cheie", FindC());
OpenForm(, Parametru);
EndProcedure

&Pe server
Funcția FindC();
Retur Directoare. Contrapartide. FindByRequisites ("TIN", "745107734623")
EndFunction

4. Cum se deschide un nou formular de obiect

O funcție simplă va face aici OpenForm() fara nici un parametru.

&OnClient
Procedură Comanda 1 (Comandă)
OpenForm( „Director. Contrapărți. Formă obiect”) ;
EndProcedure

5. Cum să deschideți un formular de obiect nou și să îl completați în funcție de ceva

Trebuie să treceți un parametru Baza, a cărui valoare va fi o referință la obiectul de bază de umplere. Aceasta va începe procedura ProcessFill().

&OnClient
Procedură Comanda 1 (Comandă)
Parametru= structură nouă;
Parametru. Insert("Baza", LinkToBuyerAccount) ;
OpenForm( "Document. Vânzări de bunuri și servicii. Formular obiect", Parametru) ;
EndProcedure

Acest exemplu va crea un document Vânzări de bunuri și serviciiși completat pe baza unei facturi de plată către cumpărător, link-ul către care a fost transmis.

6. Cum să deschideți un formular și să setați o selecție pe el

Selecția pe formularele 1C poate fi simplă sau complexă. Selecția simplă implică expresii precum Organizație = Horns and Hooves LLC. Selecția complexă implică alte tipuri de comparație, de ex. Pe listă. În acest articol vom lua în considerare organizarea selecției simple, iar un articol separat va fi dedicat selecției complexe.

Pentru a organiza o selecție simplă, trebuie să treceți un parametru cu o cheie la formularul care se deschide Selecţie, valoarea va fi o structură în care cheia este numele câmpului de listă dinamică, iar valoarea este datele căutate.

De exemplu, să deschidem formularul de listă de directoare numere GTDși faceți o selecție acolo de proprietar - element de director Nomenclatură.

&OnClient
Procedură Comanda 1 (Comandă)
Parametru= structură nouă;

selectie= Structura noua;
Selecţie. Insert(„Proprietar”, LinkToNomenclature);

Parametru. Insert("Selectie", Selectie);

OpenForm( „Directory.GTD Numbers.List Form”, Parametru) ;
EndProcedure

7. Cum se deschide formularul de intrare în registrul de informații

Pentru a face acest lucru, veți avea nevoie de cheia de introducere a registrului de informații.

Cheie de înregistrare— acestea sunt valorile tuturor măsurătorilor și ale perioadei (dacă registrul este periodic). Adică, o cheie de înregistrare reprezintă parametrii prin care o înregistrare poate fi identificată în mod unic.

Algoritmul de deschidere este următorul:

Introducem în structură datele cheii de înregistrare cu valorile necesare.
Am plasat structura rezultată într-o matrice.
Creăm o cheie de înregistrare din matrice.
Trecem un parametru formularului care se deschide Cheie cu cheia de înregistrare de la pasul 3 ca valoare.

&OnClient
Procedură Comanda 1 (Comandă)
Parametru= structură nouă;

KeyParameters= Structură nouă;
Parametri cheie. Insert("Nomenclatură", LinkToNomenclature);
Parametri cheie. Insert(„PriceType”, LinkToPriceType);
Parametri cheie. Insert(„Perioada”, Data) ;

KeyArray = matrice nouă;
KeyArray. Add(KeyParameters) ;

EntryKey = Nou( „Registrul de informații cheie de înregistrare.Nomenclatură prețuri”, KeyArray) ;

Parametru. Insert(„Cheie”, RecordKey);

OpenForm( „Registrul informațiilor. Prețurile nomenclaturii. Formular de înregistrare”, Parametru) ;
EndProcedure

Imprimare (Ctrl+P)

Opțiuni de formular

1. Informații generale

Parametrii formularului (fila Opțiuni) au două scopuri:
● Descrieți setul de date care vor influența deschiderea formularului (parametrizare formular). Pentru a face acest lucru, trebuie să enumerați toți parametrii necesari și să indicați tipurile acestora.
● Determinați parametrii care vor influența cheia de unicitate a formularului. Pentru a face acest lucru, trebuie să setați proprietatea Parametru cheie acei parametri care ar trebui să participe la formarea cheii de unicitate a formei. Când încercați să deschideți un formular, sistemul caută un formular existent utilizând cheia de unicitate a formularului generată. Dacă în sistem există un formular cu cheia primită
unicitatea, această formă este cea care revine; dacă nu, se creează o nouă formă.
La apelarea unui formular, valorile parametrilor creați de dezvoltator pot fi specificate în structura parametrilor împreună cu parametrii de sistem ai formularelor (dacă există).
Parametrii formularului pot fi transferați formularului în momentul creării acestuia. Analiza parametrilor trecuți poate fi efectuată în cadrul evenimentului WhenCreatingOnServer() (colecția Parameters este o proprietate a obiectului ManagedForm):

// La locația apelului.
// Creați un parametru de formular.
Parametri = new Structure();
Opțiuni.Inserare("Importanţă", Valoare predefinită(„Enumerare.Importanță.Important”);
// Deschideți formularul cu parametri.
OpenForm („GeneralForm.ViewForm”, Parametri);
…
// În modulul formular.
&Pe server
Procedură WhenCreatingOnServer (Eșec, Procesare standard)
Dacă Parametri.Importanță = Enumerări.Importanță.Important o Atunci
…
endIf;
EndProcedure

ATENŢIE! După ce a apelat handlerul de evenimente Când CreatedOnServer toți parametrii formularului care nu sunt cheie sunt eliminați din colecția Parameters.
Sfat. Parametrii formularului non-cheie necesari pentru lucrări ulterioare trebuie stocați în datele formularului.

2. Parametrii formularului standard

Pentru a sprijini interacțiunea automată între formulare, sistemul oferă o serie de parametri standard care sunt utilizați pentru a controla formularele atunci când sunt deschise. Folosind acești parametri, sistemul implementează în câmpurile de formular selecția din formulare de selecție, deschiderea formularelor obiect, operarea comenzilor standard etc. Adică oferă diverse scenarii de operare a interfeței încorporate în sistem.
Dar dezvoltatorul poate folosi acești parametri și în limbajul încorporat, transmițându-i atunci când apelează metoda OpenForm().
O listă a parametrilor de formular standard în funcție de tipul de extensie de formular poate fi găsită în secțiuni Limbaj încorporat - Interfață
(gestionat) – Formular gestionat – Extindere... încorporat certificate

3. Exemplu de lucru cu parametri de formular

Pentru a demonstra cum funcționează parametrii de formular, luați în considerare implementarea selectării unui element într-un câmp de intrare. Esența exemplului va fi implementarea mecanismului de selectare a unui element dintr-o listă în limbajul încorporat.
Până când începeți să lucrați cu exemplul, trebuie să aveți o configurație cu următoarele proprietăți:
● există un director Produse cu o ierarhie de grupuri și elemente;
● există un director Analogs cu detaliile SelectedProduct type DirectoryLink.Produse;
● ambele directoare au forme de elemente.
Acum să implementăm în această configurație toate mecanismele pe care platforma le folosește pentru a selecta un element din listă în limbajul încorporat. În acest caz vom vedea:
● cum sunt utilizați parametrii de formular standard;
● modul în care sistemul însuși le folosește;
● cum le poate folosi un dezvoltator.
Să adăugăm un parametru suplimentar care va controla închiderea formularului de selecție după selectarea unui element. Să numim acest parametru CloseAfterSelection(tip boolean). Să-l adăugăm ca parametru de formular Formular pentru selectarea directorului Produse.
Pentru a deschide formularul de selecție a elementelor, trebuie să creați un handler de evenimente pentru evenimentul Start of Selection pentru elementul de formular SelectedProduct sub forma elementului de director Analogues.

&OnClient
Procedură SelectedProductStartSelection(Articol, Procesare standard)
Procesare standard= fals;
Opțiuni de selecție= Structură nouă;
Opțiuni de selecție.Insert(„SelectionMode”, True);
Opțiuni de selecție.Insert(„Selectarea grupurilor și elementelor”, Utilizarea GroupsAndElements.Elements);
Opțiuni de selecție.Insert(„AllowRootSelection”, False);
Opțiuni de selecție.Insert(„CurrentLine”, Object.SelectedProduct);
Opțiuni de selecție.Insert(„CloseAfterSelection”, False);
OpenForm(„Directory.Products.SelectionForm”, Opțiuni de selecție, Articole.Produs Selectat);
EndProcedure
Este necesar să ne oprim separat asupra celui de-al treilea parametru al metodei OpenForm(). Acest parametru determină cine va fi proprietarul formularului de selecție și cine va fi anunțat despre selecția efectuată. În acest caz, am specificat elementul formular în sine ca proprietar al formularului de selecție, dar putem specifica și formularul în sine cu acest parametru. În acest caz, va fi necesară implementarea unui handler Procesarea selecției modul de formular și decideți în el ce atribut de formular să plasați datele selectate.
NOTĂ. Dacă nu implementăm handlerul de evenimente StartSelection, atunci acțiunile acestuia vor fi efectuate de sistemul însuși. Acest lucru este valabil pentru toți manipulatorii suplimentari care sunt utilizați în exemplu.
Acum trebuie să procesați parametrii trecuți în formularul de selecție. Să facem asta în handler Când CreatedOnServer() din modulul formular de selecție.

&Pe server
Procedură WhenCreatingOnServer(Eșec, StandardProcessing)
Procesare standard= fals;
Elements.List.SelectingGroupsAndElements = Parameters.SelectingGroupsAndElements;
Elements.List.AllowRootSelection = Parametri.AllowRootSelection;
Elements.List.CurrentRow = Parameters.CurrentRow;
CloseOnSelection = Options.CloseAfterSelection;
EndProcedure
Pentru a verifica funcționalitatea parametrilor de formular pe care i-am setat, folosind configuratorul, vom seta proprietatea List pentru tabelul formularului de selecție Selectarea grupurilor și a elementelor la valoarea Grupuri (fără a utiliza parametrul, selecția elementelor de director nu va fi disponibilă).
NOTĂ. Dacă tabelul Listă care afișează o listă de produse nu are proprietatea SelectionMode setată la True, atunci selecția de produse nu va fi disponibilă.
Acum trebuie să ne ocupăm de selecția elementului dorit în formularul de selecție. Pentru a face acest lucru, trebuie să definiți un handler pentru evenimentul SelectValue din tabelul formular.

&OnClient
Procedură ListSelectionValues(Element, StandardProcessing, Value)
Procesare standard= fals;
NotifyOfSelection(Valoare);
EndProcedure
Tot ce trebuie să facem este să implementăm procesarea de selecție a elementelor în câmpul de intrare în sine. Pentru a face acest lucru, trebuie să vă ocupați de eveniment Procesarea selecției câmpul nostru de introducere SelectedProduct.

&OnClient
Procedură SelectedItemSelectionProcessing(Articol, SelectedValue, StandardProcessing)
Procesare standard= fals;
Object.SelectedProduct = SelectedValue;
EndProcedure
Am implementat independent un mecanism de sistem pentru selectarea unei valori într-un câmp de intrare dintr-un formular.
ATENŢIE! Acest exemplu nu este complet. Singurul său scop este de a demonstra mecanismele de lucru cu parametrii formularului.
Dacă la crearea parametrilor (handler SelectedProductStartSelection()) înlocuiți linia:

Opțiuni de selecție.Insert(„CloseAfterSelection”, True);
pe linie:
Opțiuni de selecție.Insert(„CloseAfterSelection”, False);
atunci formularul de selecție nu se va mai închide după ce se face selecția. Aceasta poate fi folosită, de exemplu, pentru a implementa un formular de selecție (selectând mai multe produse fără a închide formularul de selecție).

Avem procesare cu acest formular de bază:

Din acest formular trebuie să deschidem un formular suplimentar, iar textul din câmpul formularului trebuie să fie transferat în formularul deschis. Formularul suplimentar este următorul:

Astfel, când dai clic pe butonul „Run”, se deschide un formular suplimentar cu textul deja introdus în câmp:

Să luăm în considerare o modalitate de a rezolva o astfel de problemă.

Soluţie

Pentru a transfera parametri între formulare obișnuite, puteți fie să utilizați variabila globală de export a modulului de formular, fie să creați un atribut de formular. Să luăm în considerare ambele metode pentru sarcina noastră.

1. Folosind variabila globală de export a modulului formular.

Adăugați următorul cod în formularul principal pentru procedura de gestionare a butonului „Run”:

Procedură ButtonExecutePress(Button)Form = GetForm(" Formular suplimentar" ) ; // „Text” este o variabilă globală de export a modulului formular deschis Formă. Text = FormElements. Text. Sens; Formă. Deschis(); EndProcedure

Variabila text a fost adăugată la modulul formularului care se deschide împreună cu handlerul de evenimente „BeforeOpen”:

Export de text variabil; // Variabilă căreia i se transmite valoarea dintr-o altă formă Procedure BeforeOpen(Eșec, StandardProcessing)FormElements. Text transmis. Valoare = Text; EndProcedure

Problema este rezolvată, și pur și simplu!

2. Utilizarea detaliilor formularului.

Pentru a doua metodă, nici măcar nu trebuie să rescriem manevrele de butoane „Run” și „BeforeOpen”. Tot ceea ce este necesar este să adăugați atributul „Text” cu tipul șirului la formularul deschis.

concluzii

În formularele gestionate, transmiterea parametrilor este mult mai ușoară. În formele convenționale, abordarea descrisă este utilizată în majoritatea cazurilor.

Puteți procesa exemplul din articol descărcați de pe link.