Imprimare (Ctrl+P)

Opțiuni de formular

1. Informații generale

Parametrii formularului (fila Parametri) servesc două scopuri:
● Descrieți setul de date care va afecta deschiderea formularului (parametrizare formular). Pentru a face acest lucru, trebuie să enumerați toți parametrii necesari și să specificați tipurile acestora.
● Definiți parametrii care vor afecta cheia de unicitate a formei. 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ă există un formular cu cheia primită în sistem
unicitate, acest formular este returnat; dacă nu, se creează o nouă formă.
Când este invocat un formular, valorile parametrilor create de dezvoltator pot fi specificate în structura parametrilor, împreună cu parametrii sistemului de formulare (dacă există).
Parametrii formularului pot fi transferați formularului în momentul creării acestuia. Analiza parametrilor trecuți poate fi efectuată în eveniment OnCreateOnServer() (colecția Parameters este o proprietate a obiectului ManagedForm):

// La site-ul apelului.
// Formează parametrul formularului.
Parametri = New Struct();
Opțiuni.Lipire("Importanţă", Valoare predefinită(„Enumerare.Importanță.Important”);
// Deschideți formularul cu parametri.
OpenForm("GeneralForm.ViewForm", Parametri);
…
// În modulul formular.
&Pe server
Procedură OnCreateOnServer (Eșec, Procesare standard)
În cazul în care un Parametri.Importanță = Enums.Importance.Important Oh, atunci
…
EndIf;
EndProcedure

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

2. Opțiuni de formular standard

Pentru a sprijini interacțiunea automată între formulare, sistemul oferă o serie de opțiuni standard care sunt utilizate pentru a controla formularele atunci când sunt deschise. Cu ajutorul acestor parametri, sistemul implementează în câmpurile de formular selecția din formularele 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 1C:Enterprise, transmițându-i atunci când apelează metoda OpenForm().
Lista 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 - Extensie...inline referințe.

3. Un exemplu de lucru cu parametrii formularului

Pentru a demonstra cum funcționează parametrii formularului, să luăm în considerare implementarea selectării unui element în câmpul de intrare. Esența exemplului va fi implementarea mecanismului de selectare a unui element din listă în limbajul încorporat.
Până când începeți să lucrați cu exemplul, trebuie să aveți o configurație care să aibă următoarele proprietăți:
● există un director de Bunuri cu o ierarhie de grupuri și elemente;
● există un director Analogues cu atributul SelectedProduct de tip DirectoryLink.Produse;
● Ambele cărți de referință au formulare de articole.
Acum 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 le utilizează;
● cum le poate folosi un dezvoltator.
Să adăugăm parametru suplimentar Un care va controla închiderea formularului de selectare după ce este selectat un articol. Să numim acest parametru CloseAfterSelection(tip boolean). Să-l adăugăm ca parametru al formularului Formular de selecție al directorului Bunuri.
Pentru a deschide formularul de selecție a elementelor, este necesar să creați un handler de evenimente pentru evenimentul SelectStart la elementul de formular SelectedItem sub forma elementului de director Analogues.

&AtClient
Procedură SelectedItemSelectionStart(Articol, Procesare standard)
Procesare standard= fals ;
Opțiuni de alegere= Structură nouă;
SelectionParameters.Insert(„SelectionMode”, True);
SelectionParameters.Insert(„SelectGroupsAndItems”, FolosindGroupsAndItems.Items);
SelectionParameters.Insert(„AllowRootSelection”, False);
SelectionParameters.Insert(„CurrentLine”, Object.SelectedItem);
SelectionParameters.Insert(„CloseAfterSelection”, False);
OpenForm(„Catalog.Products.ChoiceForm”, Opțiuni de alegere, Articole.Produs Selectat);
EndProcedure
Ar trebui 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 de selecția efectuată. LA 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 handler-ului HandlingChoice 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 StartChoice , atunci sistemul însuși își va efectua acțiunile. Acest lucru este valabil pentru toți manipulatorii suplimentari care sunt utilizați în exemplu.
Acum trebuie să procesăm parametrii trecuți în formularul de selectare. Să o facem în handler OnCreateOnServer() din modulul formular de selectare.

&Pe server
Procedură OnCreateOnServer (Eșec, Procesare standard)
Procesare standard= fals ;
Elements.List.SelectGroupsAndItems = Parameters.SelectGroupsAndItems;
Elements.List.AllowSelectRoot = Parametri.AllowSelectRoot;
Items.List.CurrentRow = Parameters.CurrentRow;
CloseOnSelection = Parameters.CloseAfterSelection;
EndProcedure
Pentru a verifica performanta parametrilor de formular setati de noi, vom seta, folosind configuratorul, proprietatea List a tabelului formular de selectie SelectațiGroupsAndItems la valoarea Grupuri (fără aplicarea parametrului, selecția elementelor de dicționar 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 articolului dorit în formularul de selecție. Pentru a face acest lucru, trebuie să definiți un handler de evenimente pentru evenimentul SelectValues ​​din tabelul de formulare.

&AtClient
Procedură ListSelectionValues(Articol, Procesare standard, Valoare)
Procesare standard= fals ;
NotifySelection(Valoare);
EndProcedure
Ne rămâne să implementăm procesarea selectării unui element în câmpul de intrare în sine. Pentru a face acest lucru, trebuie să vă ocupați de eveniment HandlingChoice câmpul nostru de introducere SelectedProduct.

&AtClient
Procedură SelectedItemProcessingChoice(Element, SelectedValue, StandardProcessing)
Procesare standard= fals ;
Object.SelectedItem = SelectedValue;
EndProcedure
Am implementat independent un mecanism de sistem pentru selectarea unei valori în câmpul de intrare din formular.
ATENŢIE! Acest exemplu nu este complet. Singurul său scop este de a demonstra mecanica lucrului cu parametrii de formă.
Dacă la crearea parametrilor (handler SelectedItemSelectionStart()) înlocuiți linia:

SelectionParameters.Insert(„CloseAfterSelection”, True);
la linia:
SelectionParameters.Insert(„CloseAfterSelection”, False);
apoi formularul de selecție nu se va mai închide după ce selecția este făcută. Aceasta poate fi folosită, de exemplu, pentru a implementa un formular de selecție (selectarea mai multor produse fără a închide formularul de selecție).

Pentru a sprijini interacțiunea automată între formulare, sistemul oferă o serie de opțiuni standard care sunt utilizate pentru a controla formularele atunci când sunt deschise. Cu ajutorul acestor parametri, sistemul implementează în câmpurile de formular selecția din formularele 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 1C:Enterprise, 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 prin extensie formă gestionată lista dinamica.
• CurrentLine– un șir care va fi activat în listă când este deschis. Este transmisă o valoare care identifică șirul. Furnizat de extensia de formular gestionată de listă dinamică.
• SelectațiGroupsAndItems– acest parametru setează proprietatea SelectGroupAndItems a tabelului atributului principal al formularului. Furnizat de extensia de formular gestionată de listă dinamică.
• AllowSelectionRoot– determină dacă rădăcina poate fi selectată în formularul cu o listă dinamică afișată ca arbore. Furnizat de extensia de formular gestionată a unei liste dinamice 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– valoare de identificare a obiectului care se editează în formular. Dacă valoarea lipsește sau este incorectă, se creează un nou obiect folosind parametrii rămași. Furnizat de formulare de obiecte și extensii ale managerului de înregistrare a registrului de informații.
• ValueCopy– o valoare care identifică obiectul care va fi folosit pentru copiere la crearea unui nou obiect. Furnizat de formulare de obiecte și extensii ale managerului de înregistrare a registrului de informații.
• Valori de umplere– valori pentru completarea detaliilor noului obiect. Reprezintă o structură. Numele elementelor corespund numelor atributelor, iar valorile conțin datele care vor fi folosite pentru completarea atributelor specificate. Furnizat de formulare de obiecte și extensii ale managerului 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 noului obiect: grup sau element. Furnizat de extensii de formulare de obiect.

Exemplu de lucru cu parametrii formularului

Pentru a demonstra cum funcționează parametrii formularului, să luăm în considerare implementarea selectării unui element în câmpul de intrare. Esența exemplului va fi implementarea mecanismului de selectare a unui element din listă în limbajul încorporat.

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

• Modul principal de lansare este Aplicația gestionată;
• există un director Bunuri cu o ierarhie de grupuri și elemente;
• există un director Analogues cu atributul SelectedItem de tip DirectoryReference.Goods;
• ambele cărți de referință au formulare de articole gestionate.

Acum 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ă ce este selectat un element. Să numim acest flag CloseAfterSelection (tip boolean). Să-l adăugăm ca parametru de formular al formularului de selecție a directorului de bunuri.

Pentru a deschide formularul de selecție a elementelor, este necesar să creați un handler de evenimente pentru evenimentul SelectStart pentru elementul de formular SelectedItem în formularul de elemente de catalog Analogues:

&AtClient

Procedură SelectedItemSelectionStart(Articol, Procesare standard)

StandardProcessing = Fals;

ChoiceParameters = Structură nouă; 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);

EndProcedure

Ar trebui 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 de 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ă implementați handlerul SelectProcess al modulului de formular și să decideți în el ce atribut de formular să plasați datele selectate.

Deschiderea de formulare în mod programatic într-o aplicație gestionată 1C este semnificativ diferită de deschiderea lor într-o aplicație obișnuită. Să începem cu vechea metodă. Constă în primirea formularului și deschiderea ulterioară a acestuia î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 procesare, codul trebuie să fie ușor modificat:

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

Trebuie avut în vedere că la primirea formularului se va efectua o altă procedură de eveniment OnCreateOnServer.

Luați în considerare alte metode care vă permit să deschideți formulare într-o aplicație gestionată 1C mai rapid și mai convenabil. Pot fi utilizate diferite metode în funcție de situația specifică.

1. Cum se deschide forma unui obiect într-o aplicație gestionată dacă există un link către aceasta.

În acest caz, totul este extrem de simplu.

RefReference= Referințe. Nomenclatură. FindByCode("000000001");
OpenValue(ReferenceReference) ;

2. Cum se deschide un formular 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 se va scrie valoarea selectată;
• Sugestia care va fi afișată în caseta de selecție;
• Descrierea tipurilor de valori selectate. Pot exista mai multe tipuri, apoi, înainte de a alege o anumită valoare, vi se va solicita să selectați un tip.

Ca urmare a execuției funcției, se va deschide formularul de selecție implicit pentru obiectul de tipul specificat.

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

TypeDescription= new TypeDescription(Array) ;

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

Metodele anterioare permiteau deschiderea doar a formularelor setate pentru obiecte în mod implicit (formular obiect sau formular de selecție). Dacă trebuie să deschideți un formular arbitrar, puteți utiliza funcția OpenForm().

Această funcție are destul de mulți parametri. Să luăm în considerare câteva dintre ele:

• Numele formularului- aici puteți selecta oricare dintre formele standard ale obiectului, de exemplu, FormSelect sau FormList. Sau un formular specific creat de dezvoltatori.
• Opțiuni- vă permite să vă transferați la 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ă OnCreateOnServer() pe forma deschisă.
• Modul deschidere formular- are 3 opțiuni: independent, blocați întreaga interfață, blocați formularul de proprietar.

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

3. Cum se deschide forma unui obiect existent

Fiecare formular are un atribut cheie. Este evidențiat cu aldine în lista de atribute de formular și este de obicei numit Un obiect la forme de elemente de directoare, documente. Alte obiecte pot avea un nume diferit. Pentru a deschide forma unui obiect existent, trebuie să treceți parametrul în formularul deschis Cheie cu valoare ca referință la obiect.

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

&Pe server
Funcția FindC();
Returnați manuale. Contrapartide. FindByAttribute ("TIN", "745107734623")
EndFunctions

4. Cum se deschide forma unui obiect nou

Aceasta este doar o funcție OpenForm() fara nici un parametru.

&AtClient
Procedură Comanda 1 (Comandă)
OpenForm( "Carte de referință. Contrapărți. Forma obiect") ;
EndProcedure

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

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

&AtClient
Procedură Comanda 1 (Comandă)
Parametru= structură nouă;
Parametru. Insert(„Motivul” , LinkToAccountToBuyer) ;
OpenForm( "Document. Realizare Bunuri si Servicii. Formular obiect", Parametru) ;
EndProcedure

Acest exemplu va crea un document Vanzare de bunuri si servicii si completata pe baza facturii de plata catre cumparator, link-ul catre care a fost transferat.

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

Selecția pe formularele 1C poate fi simplă și complexă. Selecția simplă implică expresii precum Organizație = Horns and Hooves LLC. Selecția complexă implică alte tipuri de comparație, de exemplu, Listată. În acest articol, vom lua în considerare organizarea unei selecții simple, iar un articol separat va fi dedicat celei complexe.

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

De exemplu, să deschidem formularul pentru lista de căutare Non-GTE iar acolo vom face o selecție de către proprietar - elementul directorului Nomenclatură.

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

Selecție= Structură nouă;
Selecţie. Insert(„Proprietar”, LinkToNomenclature);

Parametru. Insert("Selectie", Selection) ;

OpenForm( „Formular de numere.GTE Director.GTE”, Parametru) ;
EndProcedure

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

Pentru a face acest lucru, aveți nevoie de o cheie de înregistrare a registrului de informații.

Cheie de înregistrare sunt valorile tuturor măsurătorilor și ale perioadei (dacă registrul este periodic). Adică, cheia înregistrării sunt parametrii prin care înregistrarea poate fi identificată în mod unic.

Algoritmul de deschidere este următorul:

1. Introducem în structură datele cheii de înregistrare cu valorile necesare.
2. Am plasat structura rezultată într-o matrice.
3. Din matrice creăm cheia de înregistrare.
4. Transmiterea unui parametru la formularul deschis Cheie cu cheia de înregistrare de la articolul 3 ca valoare.

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

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

ArrayKey = Matrice nouă;
ArrayKey. Add(KeyParameters) ;

RecordKey = Nou( „Informații RegisterRecordKey.NomenclaturePrices”, ArrayKey);

Parametru. Insert(„Cheie”, RecordKey);

OpenForm( "Registrul de informații. Nomenclatură prețuri. Formular de înregistrare", Parametru) ;
EndProcedure

Acest articol descrie cum se transmite o valoare ca parametru 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 normale

În formele normale, au existat 2 posibilități pentru a trece un parametru:
1) o metodă mai puțin obișnuită: sub forma unui obiect în fila „Detalii”, detaliile au fost adăugate, dacă este necesar, accesul a fost determinat prin mijloace vizuale
2) o modalitate mai comună: o variabilă de export a fost declarată în modulul formular și valoarea a fost procesată în handlerul „BeforeOpening”

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

Form = Object.GetForm("ChoiceForm",FormOwner,UniqueKey);
Form.Parameter = ParameterValue;
Form.Open();

Cum se transmit 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",LastItem);
ChoiceForm = GetForm("Catalog.Nomenclature.ChoiceForm",Parametri);
FoundItem = ChoiceForm.OpenModal();

De asemenea, formularul gestionat are „extensii de formular” (obiect, director, document, raport). În funcție de tipul obiectului, se stabilește lista parametrilor disponibili. De exemplu, dacă trebuie să vă poziționați pe un anumit element în formularul de selecție a dicționarului, atunci este utilizat parametrul „CurrentValue”. Marele plus este că în forma în sine nu este necesar să scrieți handlere pentru parametrii predefiniți, ceea ce reduce cantitatea de cod.

De asemenea, dezvoltatorul are posibilitatea de a-și defini proprii parametri (în designerul formularului gestionat, fila „Parametri”). Durata de viață a parametrilor este limitată de handlerul OnCreateOnServer, ceea ce este logic deoarece parametrii sunt necesari numai la crearea formularului, 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 ceva mai mult:

1) Definiți un parametru într-o formă gestionată.
În handlerul OnCreateAtServer, definiți procesarea acestui parametru (accesând parametrii trecuți prin proprietatea „Parameters” de tip FormDataStructure)
2) Descrieți primirea formularului și transmiteți valoarea noului parametru în parametrii funcției GetForm.
Deci codul va arăta astfel:
- La locul de primire a formularului

Parametri = New Structure("NewParameter",LastElement);
ChoiceForm = GetForm("Catalog.Nomenclature.ChoiceForm",Parametri);

Într-un modul de formular gestionat

&Pe server
Procedură pe CreationOnServer (Eșec, Procesare standard)
Dacă Parameters.Property("NewParameter") Atunci
// codul de procesare a parametrilor aici
EndIf;
EndProcedure

Concluzie

Poate că acest articol va fi util cuiva, economisește timp și te scutește de codurile inutile. Pentru informații mai detaliate despre lista completa parametrii unui formular gestionat, se recomandă să consultați ajutorul „Interfață gestionată \ Formular gestionat”.

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