W tym artykule opisano, jak używać standardowych środków do przekazywania wartości jako parametru podczas otwierania zarządzanego formularza 8.2, w porównaniu ze sposobem, w jaki można zaimplementować podobną operację w zwykłych formularzach.

Jak parametry są przekazywane w zwykłych formularzach

W zwykłych formularzach istniały 2 możliwości przekazania parametru:
1) mniej powszechna metoda: w formularzu obiektu w zakładce „Szczegóły” dodano atrybuty, a w razie potrzeby określono dostęp za pomocą środków wizualnych
2) bardziej powszechny sposób: w module formularza zadeklarowano zmienną eksportu, a wartość została przetworzona w procedurze obsługi „Before Opening”

w obu przypadkach wywołanie formularza wyglądało mniej więcej tak:

Formularz = Obiekt.GetForm("SelectionForm",FormOwner, UniquenessKey);
Form.Parameter = Wartość parametru;
Formularz.Open();

Sposób przekazywania parametrów w formularzach zarządzanych

Formularze zarządzane mają teraz możliwość natychmiastowego przekazywania parametrów po otrzymaniu formularza. Parametry przekazywane są jako struktura:

Parametry = Nowa struktura("CurrentValue", LastElement);
SelectionForm = GetForm("Katalog. Nomenklatura.SelectionForm", Parametry);
FoundItem = SelectionForm.OpenModal();

Ponadto zarządzany formularz ma teraz „rozszerzenia formularza” (obiekt, podręcznik, dokument, raport). W zależności od rodzaju obiektu określany jest skład dostępnych parametrów. Przykładowo, jeśli w formularzu wyboru katalogu trzeba pozycjonować na konkretnym elemencie, wówczas używany jest parametr „CurrentValue”. Dużą zaletą jest to, że sam formularz nie wymaga pisania procedur obsługi predefiniowanych parametrów, co zmniejsza ilość kodu.

Deweloper ma także możliwość zdefiniowania własnych parametrów (w kreatorze zarządzanych formularzy, zakładka „Parametry”). Czas życia parametrów jest ograniczony przez procedurę obsługi OnCreationOnServer, co jest logiczne, ponieważ parametry wymagane są tylko przy tworzeniu formularza, jednak jeśli parametr ten decyduje o niepowtarzalności formularza (we właściwościach parametru ustawiana jest flaga „parametr klucza”), będzie on dostępny w innych handlerach.

Aby przekazać konkretny parametr manipulacji, musisz zrobić trochę więcej:

1) Zdefiniuj parametr w formie kontrolowanej.
W procedurze obsługi OnCreationOnServer zdefiniuj przetwarzanie tego parametru (dostęp do przekazanych parametrów poprzez właściwość „Parametry”, która ma typ FormDataStructure)
2) Opisz otrzymanie formularza i przekaż wartość nowego parametru w parametrach funkcji GetForm.
Zatem kod będzie wyglądał następująco:
- W miejscu, w którym otrzymasz formularz

Parametry = Nowa Struktura("NowyParametr", LastElement);
SelectionForm = GetForm("Katalog. Nomenklatura.SelectionForm", Parametry);

W zarządzanym module formularza

&Na serwerze
Procedura w przypadku utworzenia na serwerze (awaria, przetwarzanie standardowe)
If Parametry.Property("NowyParametr") Następnie
// tutaj jest kod przetwarzania parametrów
koniecJeśli;
Koniec procedury

Wniosek

Być może ten artykuł komuś się przyda, zaoszczędzi czas i oszczędzi niepotrzebnego kodu. Aby uzyskać bardziej szczegółowe informacje na temat pełnej listy parametrów zarządzanych formularzy, zaleca się zapoznanie z pomocą „Zarządzany interfejs\Zarządzany formularz”.

[musisz się zarejestrować, żeby zobaczyć link]

Programowe otwieranie formularzy w zarządzanej aplikacji 1C znacznie różni się od otwierania ich w zwykłej aplikacji. Przyjrzyjmy się najpierw starej metodzie. Polega na otrzymaniu formularza, a następnie otwarciu go w trybie normalnym lub modalnym (po otwarciu w trybie modalnym formularz blokuje program).

PobierzFormularz(). Otwarty()

Jest to najwolniejsza metoda otwierania formularzy. Pozwala jednak na programowe przetworzenie formularza przed jego otwarciem. Aby przetworzyć kod, musisz trochę zmienić:

Formularz = GetForm( „Dokument. Odbiór towarów i usług. Formularz dokumentu”) ;
//Tutaj wykonujemy akcje z formularzem
Formularz. Otwarty();

Należy wziąć pod uwagę, że po otrzymaniu formularza zostanie wykonana kolejna procedura zdarzenia Kiedy utworzono na serwerze.

Przyjrzyjmy się innym metodom, które pozwalają szybciej i wygodniej otwierać formularze w zarządzanej aplikacji 1C. W zależności od konkretnej sytuacji można zastosować różne metody.

1. Jak otworzyć formularz obiektowy w zarządzanej aplikacji, jeżeli istnieje do niego odnośnik.

W tym przypadku wszystko jest niezwykle proste.

RefLink = Katalogi. Nomenklatura. FindByCode("000000001");
OpenValue(RefLink) ;

2. Jak otworzyć formularz wyboru i następnie uzyskać wybraną wartość.

Jest do tego funkcja WprowadźWartość(). Funkcja ma 3 parametry:

• Zmienna, do której zostanie zapisana wybrana wartość;
• Podpowiedź, która wyświetli się w oknie wyboru;
• Opis typów wybranych wartości. Może być kilka typów i w takim przypadku zostaniesz poproszony o wybranie typu przed wybraniem określonej wartości.

W wyniku wykonania funkcji otworzy się domyślny formularz wyboru obiektu określonego typu.

Zmienna wartość;
Tablica= nowa tablica;
Szyk. Dodaj(Typ( „DirectoryLink.Nomenklatura”) ) ;
Szyk. Dodaj(Typ( „DirectoryLink. Kontrahenci”) ) ;

TypeDescription= nowy TypeDescription(Array) ;

Res = EnterValue(Wartość, "Wskazówka" , TypOpis) ;

Poprzednie metody umożliwiały jedynie otwieranie domyślnych formularzy dla obiektów (formularz obiektowy lub formularz selekcji). Jeśli chcesz otworzyć niestandardowy formularz, możesz skorzystać z tej funkcji Otwórz formularz().

Ta funkcja ma sporo parametrów. Przyjrzyjmy się niektórym z nich:

• Nazwa formularza— tutaj możesz wybrać jeden ze standardowych kształtów obiektów, np. Formularz wyboru Lub Formularz listy. Lub konkretny formularz stworzony przez programistów.
• Opcje— umożliwia przeniesienie go do formularza w formularzu Struktury niektóre parametry przed jego otwarciem, określając w ten sposób dane wyjściowe. Parametrami mogą być dowolne dane, które mogą być przekazywane od klienta do serwera. Parametry przekazane podczas otwierania formularza mogą zostać przetworzone w procedurze Kiedy tworzysz na serwerze() przy otwieranym formularzu.
• Tryb otwierania formularza— ma 3 opcje: niezależna, blokuje cały interfejs, blokuje formularz właściciela.

Przyjrzyjmy się, jak używana jest ta funkcja Otwórz formularz() w różnych sytuacjach.

3. Jak otworzyć formę istniejącego obiektu

Każdy formularz ma jeden kluczowy atrybut. Jest on wyróżniony pogrubioną czcionką na liście szczegółów formularza i zwykle nosi nazwę Obiekt w postaci elementów podręczników i dokumentów. Inne obiekty mogą mieć inną nazwę. Aby otworzyć formularz istniejącego obiektu należy przekazać parametr do otwieranego formularza Klucz z wartością jako odniesieniem do obiektu.

&Na kliencie
Procedura Polecenie 1 (Polecenie)
Parametr= nowa struktura;
Parametr. Wstaw("Klucz", ZnajdźC() ) ;
OpenForm(, parametr) ;
Koniec procedury

&Na serwerze
Funkcja ZnajdźC();
Zwróć katalogi. Kontrahenci. FindByRequisites („NIP”, „745107734623”)
Funkcja końcowa

4. Jak otworzyć nowy formularz obiektowy

Tutaj wystarczy prosta funkcja Otwórz formularz() bez żadnych parametrów.

&Na kliencie
Procedura Polecenie 1 (Polecenie)
Otwórz formularz( „Katalog. Kontrahenci. Formularz obiektu”) ;
Koniec procedury

5. Jak otworzyć nowy formularz obiektowy i wypełnić go na podstawie czegoś

Musisz przekazać parametr Baza, którego wartość będzie referencją do obiektu bazowego wypełnienia. To rozpocznie procedurę Wypełnienie procesu().

&Na kliencie
Procedura Polecenie 1 (Polecenie)
Parametr= nowa struktura;
Parametr. Wstaw("Baza", LinkToBuyerAccount) ;
Otwórz formularz( „Dokument. Sprzedaż towarów i usług. Formularz obiektowy”, parametr) ;
Koniec procedury

Ten przykład utworzy dokument Sprzedaż towarów i usług i wypełnione na podstawie faktury płatniczej dla kupującego, do której przesłano link.

6. Jak otworzyć formularz i ustawić w nim selekcję

Wybór w formularzach 1C może być prosty lub złożony. Wybór prosty obejmuje wyrażenia takie jak Organizacja = Horns and Hooves LLC. Dobór złożony obejmuje inne rodzaje porównań, np. Na liście. W tym artykule rozważymy organizację selekcji prostej, a odrębny artykuł poświęcimy selekcji złożonej.

Aby uporządkować prosty wybór należy do otwieranego formularza przekazać parametr z kluczem Wybór, wartością będzie struktura, w której kluczem będzie nazwa pola listy dynamicznej, a wartością będą poszukiwane dane.

Na przykład otwórzmy formularz listy katalogów Numery GTD i dokonaj tam wyboru według właściciela - elementu katalogu Nomenklatura.

&Na kliencie
Procedura Polecenie 1 (Polecenie)
Parametr= nowa struktura;

Wybór= nowa struktura;
Wybór. Wstaw("Właściciel", LinkToNomenklatura) ;

Parametr. Wstaw("Wybór", Wybór) ;

Otwórz formularz( "Katalog.Numery GTD.Formularz listy", parametr) ;
Koniec procedury

7. Jak otworzyć formularz wpisu do rejestru informacji

Aby to zrobić, będziesz potrzebować klucza wpisu do rejestru informacji.

Klucz do nagrywania— są to wartości wszystkich pomiarów i okres (jeżeli rejestr jest okresowy). Oznacza to, że klucz rekordu to parametry, dzięki którym można jednoznacznie zidentyfikować rekord.

Algorytm otwierania jest następujący:

1. Do struktury wprowadzamy kluczowe dane rekordu wraz z niezbędnymi wartościami.
2. Powstałą strukturę umieszczamy w tablicy.
3. Tworzymy klucz rekordu z tablicy.
4. Przekazujemy parametr do formularza, który się otwiera Klucz z kluczem zapisu z kroku 3 jako wartością.

&Na kliencie
Procedura Polecenie 1 (Polecenie)
Parametr= nowa struktura;

KeyParameters= nowa struktura;
Kluczowe parametry. Wstaw("Nomenklatura", LinkToNomenklatura) ;
Kluczowe parametry. Wstaw("Typ ceny", LinkToPriceType) ;
Kluczowe parametry. Insert("Kropka", Data) ;

KeyArray = Nowa tablica;
Tablica kluczy. Dodaj(Parametry kluczowe) ;

EntryKey = Nowy ( „Klucz rejestru informacyjnego. Nomenklatura cen”, tablica kluczy) ;

Parametr. Wstaw("Klucz",KluczRekordu) ;

Otwórz formularz( „Rejestr informacji. Ceny nomenklatury. Formularz ewidencyjny”, parametr) ;
Koniec procedury

Mamy przetwarzanie w tej podstawowej formie:

Z tego formularza musimy otworzyć jakiś dodatkowy formularz, a tekst z pola formularza należy przenieść do otwartego formularza. Dodatkowy formularz wygląda następująco:

Tym samym po kliknięciu przycisku „Uruchom” otwiera się dodatkowy formularz z tekstem już wprowadzonym w polu:

Rozważmy sposób rozwiązania takiego problemu.

Rozwiązanie

Aby przenieść parametry pomiędzy zwykłymi formularzami, możesz użyć globalnej zmiennej eksportu modułu formularza lub utworzyć atrybut formularza. Rozważmy obie metody dla naszego zadania.

1. Wykorzystanie globalnej zmiennej eksportu modułu formularza.

Dodaj następujący kod do formularza głównego procedury obsługi przycisku „Uruchom”:

Procedura ButtonExecutePress(Button)Form = GetForm(" Dodatkowy formularz" ) ; // „Tekst” to globalna zmienna eksportowa otwieranego modułu formularza Formularz. Tekst = Elementy formularza. Tekst. Oznaczający; Formularz. Otwarty(); Koniec procedury

Do modułu otwieranego formularza dodana została zmienna tekstowa wraz z obsługą zdarzenia „BeforeOpen”:

Eksport tekstu zmiennego; // Zmienna, do której przekazywana jest wartość z innego formularza Procedura BeforeOpen(Failure, StandardProcessing)FormElements. Przesłany tekst. Wartość = tekst; Koniec procedury

Problem został rozwiązany i to po prostu!

2. Korzystanie z danych formularza.

W przypadku drugiej metody nie musimy nawet przepisywać procedur obsługi przycisków „Uruchom” i „Przed otwarciem”. Wystarczy, że do otwartego formularza dodamy atrybut „Tekst” z typem string.

wnioski

W formularzach zarządzanych przekazywanie parametrów jest znacznie łatwiejsze. W konwencjonalnych formach w większości przypadków stosuje się opisane podejście.

Możesz przetworzyć przykład z artykułu pobierz z linku.

Aby umożliwić automatyczną interakcję pomiędzy formularzami, system udostępnia szereg standardowych parametrów, które służą do kontroli formularzy podczas ich otwierania. Za pomocą tych parametrów system realizuje w polach formularzy wybór z formularzy selekcji, otwieranie formularzy obiektowych, obsługę standardowych poleceń itp. Oznacza to, że udostępniają one wbudowane w system różne scenariusze działania interfejsu. Ale programista może również używać tych parametrów we wbudowanym języku, przekazując je podczas wywoływania metody OpenForm().

Podajemy parametry jakie zapewnia system oraz ich przeznaczenie:

• Tryb wyboru– formularz otwiera się w trybie selekcji. Dostarczane przez rozszerzenie formularza zarządzanego przez dynamiczną listę.
• Bieżący wiersz– ciąg znaków, który po otwarciu zostanie aktywowany na liście. Przekazana jest wartość identyfikująca wiersz. Dostarczane przez rozszerzenie formularza zarządzanego przez dynamiczną listę.
• Wybieranie grup i elementów– parametr ten ustawia właściwość Wybór grup i elementów tabeli głównego atrybutu formularza. Dostarczane przez rozszerzenie formularza zarządzanego przez dynamiczną listę.
• ZezwólWybierzRoot– określa możliwość wyboru korzenia w formularzu z dynamiczną listą wyświetlaną w postaci drzewa. Udostępniane przez rozszerzenie formularza zarządzanego dla listy dynamicznej wyświetlanej w postaci drzewa.
• Wybór– zestaw selekcji na dynamicznej liście. Reprezentuje strukturę. Nazwy elementów odpowiadają nazwom pól, za pomocą których dokonywana jest selekcja, a wartości zawierają wartości selekcji. Dostarczane przez rozszerzenie formularza zarządzanego przez dynamiczną listę.
• Klucz– wartość identyfikująca edytowany obiekt w formularzu. W przypadku braku wartości lub nieprawidłowej wartości, tworzony jest nowy obiekt z wykorzystaniem pozostałych parametrów. Dostarczane przez rozszerzenia formularzy obiektów i menedżera rekordów rejestru informacyjnego.
• Skopiuj wartość– wartość identyfikująca obiekt, który będzie używany do kopiowania podczas tworzenia nowego obiektu. Dostarczane przez rozszerzenia formularzy obiektów i menedżera rekordów rejestru informacyjnego.
• Wartości wypełnienia– wartości do wypełnienia szczegółów nowego obiektu. Reprezentuje strukturę. Nazwy elementów odpowiadają nazwom szczegółów, a wartości zawierają dane, które posłużą do wypełnienia określonych szczegółów. Dostarczane przez rozszerzenia formularzy obiektów i menedżera rekordów rejestru informacyjnego.
• Baza– wartość identyfikująca obiekt, która będzie podstawą przy tworzeniu nowego obiektu poprzez wprowadzenie na tej podstawie. Dostarczane przez rozszerzenia formularzy obiektów.
• Ta grupa– określa typ nowego obiektu: grupa lub element. Dostarczane przez rozszerzenia formularzy obiektów.

Przykład pracy z parametrami formularza

Aby zademonstrować działanie parametrów formularza, rozważ implementację wybierania elementu w polu wejściowym. Istotą przykładu będzie implementacja mechanizmu wyboru elementu z listy w języku wbudowanym.

Zanim zaczniesz pracować z przykładem, musisz mieć konfigurację z następującymi właściwościami:

• Główny tryb uruchamiania – Aplikacja zarządzana;
• istnieje katalog Produkty z hierarchią grup i elementów;
• istnieje katalog Analogues z atrybutem SelectedProduct typu DirectoryLink.Products;
• oba katalogi mają zarządzane formularze elementów.

Zaimplementujmy teraz w tej konfiguracji wszystkie mechanizmy, za pomocą których platforma wybiera element z listy w wbudowanym języku. Robiąc to, zobaczymy, w jaki sposób wykorzystywane są standardowe parametry formularza; jak sam system z nich korzysta; jak programista może z nich skorzystać.

Dodajmy dodatkową flagę, która będzie kontrolowała zamknięcie formularza selekcji po wybraniu elementu. Nazwijmy tę flagę CloseAfterSelection (wpisz Boolean). Dodajmy go jako parametr formularza Formularz wyboru katalogu Produkty.

Aby otworzyć formularz wyboru elementu należy utworzyć procedurę obsługi zdarzenia dla zdarzenia Początek selekcji dla elementu formularza Wybrany produkt w postaci elementu katalogu Analogi:

&Na kliencie

Wybrana proceduraProductStartSelection (przedmiot, przetwarzanie standardowe)

StandardProcessing = Fałsz;

SelectionParameters = Nowa struktura; SelectionParameters.Insert("Tryb wyboru", True); SelectionParameters.Insert("WybórGroupsAndElements", UsingGroupsAndElements.Elements); SelectionParameters.Insert("AllowRootSelection", False); SelectionParameters.Insert("CurrentRow", Obiekt.SelectedProduct); SelectionParameters.Insert("CloseAfterSelection", False); OpenForm("Directory.Products.SelectionForm", SelectionParameters, Elements.SelectedProduct);

Koniec procedury

Należy osobno zająć się trzecim parametrem metody OpenForm(). Parametr ten określa, kto będzie właścicielem formularza selekcji i kto zostanie powiadomiony o dokonanym wyborze. W tym przypadku jako właściciela formularza selekcji określiliśmy sam element formularza, ale za pomocą tego parametru możemy również określić sam formularz. W takim wypadku konieczne będzie zaimplementowanie modułu obsługi Form Module Selection Processing i w nim podjęcie decyzji w jakim atrybucie formularza umieścić wybrane dane.

Drukuj (Ctrl+P)

Opcje formularza

1. Informacje ogólne

Parametry formularza (zakładka Opcje) służą dwóm celom:
● Opisz zbiór danych, które będą miały wpływ na otwarcie formularza (parametryzacja formularza). Aby to zrobić, musisz wymienić wszystkie niezbędne parametry i wskazać ich typy.
● Określ parametry, które będą miały wpływ na klucz unikalności formularza. Aby to zrobić, musisz ustawić właściwość Kluczowy parametr te parametry, które powinny brać udział w tworzeniu klucza unikalności formularza. Podczas próby otwarcia formularza system wyszukuje istniejący formularz, korzystając z wygenerowanego klucza unikalności formularza. Jeżeli w systemie istnieje formularz z otrzymanym kluczem
wyjątkowość, to ta forma powraca; jeśli nie, tworzony jest nowy formularz.
Wywołując formularz, wartości parametrów stworzonych przez programistę można określić w strukturze parametrów wraz z parametrami systemowymi formularzy (jeśli występują).
Parametry formularza można przekazać do formularza w momencie jego tworzenia. Analizę przekazanych parametrów można przeprowadzić w zdarzeniu Kiedy tworzysz na serwerze() (kolekcja Parametry jest właściwością obiektu Zarządzany formularz):

// W miejscu połączenia.
// Utwórz parametr formularza.
Parametry = nowa struktura();
Opcje.Wstaw("Znaczenie", Wstępnie zdefiniowana wartość(„Wyliczenie.Ważne.Ważne”));
// Otwórz formularz z parametrami.
OpenForm („GeneralForm.ViewForm”, Parametry);
…
// W module formularza.
&Na serwerze
Procedura WhenCreatingOnServer (awaria, przetwarzanie standardowe)
Jeśli Parametry. Znaczenie = Wyliczenia.Ważne.Ważne o Następnie
…
koniecJeśli;
Koniec procedury

UWAGA! Po wywołaniu procedury obsługi zdarzeń Kiedy utworzono na serwerze wszystkie parametry formularza niekluczowe są usuwane z kolekcji Parameters.
Rada. Niekluczowe parametry formularza potrzebne do dalszej pracy należy zapisać w danych formularza.

2. Standardowe parametry formularza

Aby umożliwić automatyczną interakcję pomiędzy formularzami, system udostępnia szereg standardowych parametrów, które służą do kontroli formularzy podczas ich otwierania. Za pomocą tych parametrów system realizuje w polach formularzy wybór z formularzy selekcji, otwieranie formularzy obiektowych, obsługę standardowych poleceń itp. Oznacza to, że udostępniają one wbudowane w system różne scenariusze działania interfejsu.
Ale programista może również używać tych parametrów we wbudowanym języku, przekazując je podczas wywoływania metody OpenForm().
Listę standardowych parametrów formularza w zależności od rodzaju rozszerzenia formularza znajdziesz w rozdziałach Wbudowany język - Interfejs
(zarządzany) – Formularz zarządzany – Rozszerzanie… wbudowane certyfikaty

3. Przykład pracy z parametrami formularza

Aby zademonstrować działanie parametrów formularza, rozważ implementację wybierania elementu w polu wejściowym. Istotą przykładu będzie implementacja mechanizmu wyboru elementu z listy w języku wbudowanym.
Zanim zaczniesz pracować z przykładem, musisz mieć konfigurację z następującymi właściwościami:
● istnieje katalog Produkty z hierarchią grup i elementów;
● istnieje katalog Analogs ze szczegółami Wybrany typ produktu KatalogLink.Produkty;
● oba katalogi mają formy elementów.
Zaimplementujmy teraz w tej konfiguracji wszystkie mechanizmy, za pomocą których platforma wybiera element z listy w wbudowanym języku. W tym przypadku zobaczymy:
● w jaki sposób wykorzystywane są standardowe parametry formularza;
● w jaki sposób sam system z nich korzysta;
● jak programista może z nich skorzystać.
Dodajmy jeszcze dodatkowy parametr, który będzie sterował zamknięciem formularza selekcji po wybraniu elementu. Nazwijmy ten parametr Zamknij po zaznaczeniu(Typ logiczny). Dodajmy go jako parametr formularza Formularz wyboru katalogu Produkty.
Aby otworzyć formularz wyboru elementu należy utworzyć procedurę obsługi zdarzenia dla zdarzenia Początek selekcji dla elementu formularza SelectedProduct w postaci elementu katalogu Analogues.

&Na kliencie
Procedura SelectedProductStartSelection (przedmiot, przetwarzanie standardowe)
Standardowe przetwarzanie= Fałsz;
Opcje wyboru= Nowa struktura;
Opcje wyboru.Wstaw(„Tryb wyboru”, Prawda);
Opcje wyboru.Wstaw(„Wybór grup i elementów”, Korzystanie z GroupsAndElements.Elements);
Opcje wyboru.Wstaw(„AllowRootSelection”, fałsz);
Opcje wyboru.Wstaw(„Linia bieżąca”, Obiekt.WybranyProdukt);
Opcje wyboru.Wstaw(„Zamknij po zaznaczeniu”, fałsz);
OpenForm(“Katalog.Produktów.Formularz wyboru”, Opcje wyboru, Przedmioty. Wybrany element);
Koniec procedury
Należy osobno zająć się trzecim parametrem metody OpenForm(). Parametr ten określa, kto będzie właścicielem formularza selekcji i kto zostanie powiadomiony o dokonanym wyborze. W tym przypadku jako właściciela formularza selekcji określiliśmy sam element formularza, ale za pomocą tego parametru możemy również określić sam formularz. W takim przypadku konieczne będzie wdrożenie modułu obsługi Wybór przetwarzania formularz i zdecyduj w nim, w którym atrybucie formularza umieścić wybrane dane.
NOTATKA. Jeżeli nie zaimplementujemy obsługi zdarzenia StartSelection, to jej działania wykona sam system. Dotyczy to wszystkich dalszych procedur obsługi użytych w przykładzie.
Teraz musisz przetworzyć przekazane parametry w formularzu wyboru. Zróbmy to w module obsługi Kiedy utworzono na serwerze() modułu formularza wyboru.

&Na serwerze
Procedura WhenCreatingOnServer (niepowodzenie, przetwarzanie standardowe)
Standardowe przetwarzanie= Fałsz;
Elements.List.SelectingGroupsAndElements = Parametry.SelectingGroupsAndElements;
Elements.List.AllowRootSelection = Parametry.AllowRootSelection;
Elements.List.CurrentRow = Parametry.CurrentRow;
CloseOnSelection = Opcje.ZamknijAfterSelection;
Koniec procedury
W celu sprawdzenia funkcjonalności ustawionych przez nas parametrów formularza za pomocą konfiguratora ustawimy właściwość Lista dla tabeli formularza selekcji Wybieranie grup i elementów do wartości Grupy (bez użycia parametru wybór elementów katalogu nie będzie możliwy).
NOTATKA. Jeżeli tabela List wyświetlająca listę produktów nie ma właściwości SelectionMode ustawionej na True, wówczas wybór produktów nie będzie dostępny.
Teraz musimy zająć się wyborem żądanego elementu w formularzu selekcji. Aby to zrobić, musisz zdefiniować procedurę obsługi zdarzenia SelectValue tabeli formularza.

&Na kliencie
Procedura ListValueSelection(Element, przetwarzanie standardowe, wartość)
Standardowe przetwarzanie= Fałsz;
NotifyOfSelection (wartość);
Koniec procedury
Wszystko, co musimy zrobić, to zaimplementować przetwarzanie wyboru elementów w samym polu wejściowym. Aby to zrobić, musisz obsłużyć wydarzenie Wybór przetwarzania nasze pole wejściowe SelectedProduct.

&Na kliencie
Procedura SelectedItemSelectionProcessing(Element, SelectedValue, StandardProcessing)
Standardowe przetwarzanie= Fałsz;
Obiekt.SelectedProduct = SelectedValue;
Koniec procedury
Niezależnie zaimplementowaliśmy systemowy mechanizm wyboru wartości w polu wejściowym na formularzu.
UWAGA! Ten przykład nie jest kompletny. Jego jedynym celem jest zademonstrowanie mechanizmów pracy z parametrami formularza.
Jeśli podczas tworzenia parametrów (handler SelectedProductStartSelection ()) zamień linię:

Opcje wyboru.Wstaw(„CloseAfterSelection”, True);
Za linię:
Opcje wyboru.Wstaw(„Zamknij po zaznaczeniu”, fałsz) ;
wówczas formularz wyboru nie będzie już zamykany po dokonaniu wyboru. Można to wykorzystać np. do realizacji formularza wyboru (wybór kilku produktów bez zamykania formularza wyboru).