ბეჭდვა (Ctrl+P)

ფორმის პარამეტრები

1. ზოგადი ინფორმაცია

ფორმის პარამეტრები (ჩანართების პარამეტრები) ემსახურება ორ მიზანს:
● აღწერეთ მონაცემთა ნაკრები, რომელიც გავლენას მოახდენს ფორმის გახსნაზე (ფორმის პარამეტრიზაცია). ამისათვის თქვენ უნდა ჩამოთვალოთ ყველა საჭირო პარამეტრი და მიუთითოთ მათი ტიპები.
● განსაზღვრეთ პარამეტრები, რომლებიც გავლენას მოახდენს ფორმის უნიკალურობის გასაღებზე. ამისათვის თქვენ უნდა დააყენოთ ქონება ძირითადი პარამეტრიის პარამეტრები, რომლებიც მონაწილეობენ ფორმის უნიკალურობის გასაღების ფორმირებაში. როდესაც ცდილობთ ფორმის გახსნას, სისტემა ეძებს არსებულ ფორმას გენერირებული ფორმის უნიკალურობის გასაღების გამოყენებით. თუ სისტემაში არის ფორმა მიღებული გასაღებით
უნიკალურობა, ეს ფორმა დაბრუნდა; თუ არა, იქმნება ახალი ფორმა.
ფორმის გამოძახებისას, დეველოპერის მიერ შექმნილი პარამეტრის მნიშვნელობები შეიძლება იყოს მითითებული პარამეტრის სტრუქტურაში, ფორმის სისტემის პარამეტრებთან ერთად (ასეთის არსებობის შემთხვევაში).
ფორმის პარამეტრები შეიძლება გადაეცეს ფორმას მისი შექმნის მომენტში. გავლილი პარამეტრების ანალიზი შეიძლება ჩატარდეს ღონისძიებაში OnCreateOnServer () (პარამეტრების კოლექცია არის ობიექტის საკუთრება მართული ფორმა):

// ზარის საიტზე.
// ფორმის პარამეტრის ფორმირება.
პარამეტრები = New Struc();
ოფციები.ჩასმა("მნიშვნელობა", წინასწარგანსაზღვრული მნიშვნელობა(„აღრიცხვა.მნიშვნელობა.მნიშვნელოვანი“));
// გახსენით ფორმა პარამეტრებით.
OpenForm ("GeneralForm.ViewForm", პარამეტრები);
…
// ფორმის მოდულში.
&სერვერზე
Პროცედურა OnCreateOnServer (მარცხი, სტანდარტული დამუშავება)
Თუ პარამეტრები.მნიშვნელობა = შენიშვნები.მნიშვნელოვნება.მნიშვნელოვანიოჰ მაშინ
…
Დაასრულე თუ;
დასრულების პროცედურა

ყურადღება! მოვლენის დამმუშავებლის დარეკვის შემდეგ OnCreateOnServerყველა არასაკვანძო ფორმის პარამეტრი ამოღებულია პარამეტრების კოლექციიდან.
რჩევა. ფორმის მონაცემებში უნდა იყოს შენახული ფორმის არასაკვანძო პარამეტრები, რომლებიც აუცილებელია შემდგომი მუშაობისთვის.

2. სტანდარტული ფორმის ვარიანტები

ფორმებს შორის ავტომატური ურთიერთქმედების მხარდასაჭერად, სისტემა გთავაზობთ უამრავ სტანდარტულ ვარიანტს, რომლებიც გამოიყენება ფორმების გასაკონტროლებლად მათი გახსნისას. ამ პარამეტრების დახმარებით სისტემა ახორციელებს ფორმის ველებში შერჩევას შერჩევის ფორმებიდან, ობიექტის ფორმების გახსნა, სტანდარტული ბრძანებების მოქმედება და ა.შ. ანუ ისინი უზრუნველყოფენ სისტემაში ჩაშენებულ ინტერფეისის მუშაობის სხვადასხვა სცენარს.
მაგრამ დეველოპერს ასევე შეუძლია გამოიყენოს ეს პარამეტრები 1C:Enterprise ენაში მათი გადაცემით OpenForm() მეთოდის გამოძახებისას.
სტანდარტული ფორმის პარამეტრების სია, რომელიც დამოკიდებულია ფორმის გაფართოების ტიპზე, შეგიძლიათ იხილოთ განყოფილებებში ჩაშენებული ენა - ინტერფეისი
(მართული) - მართული ფორმა - Extension...inlineცნობები.

3. ფორმის პარამეტრებთან მუშაობის მაგალითი

იმის საჩვენებლად, თუ როგორ მუშაობს ფორმის პარამეტრები, განვიხილოთ შეყვანის ველში ელემენტის არჩევის განხორციელება. მაგალითის არსი იქნება ჩაშენებულ ენაში სიიდან ელემენტის არჩევის მექანიზმის განხორციელება.
იმ დროისთვის, როდესაც მაგალითზე მუშაობას დაიწყებთ, თქვენ უნდა გქონდეთ კონფიგურაცია, რომელსაც აქვს შემდეგი თვისებები:
● არის საქონლის დირექტორია ჯგუფებისა და ელემენტების იერარქიით;
● არის დირექტორია Analogues ატრიბუტი SelectedProduct ტიპის DirectoryLink.Products;
● ორივე საცნობარო წიგნს აქვს პუნქტის ფორმები.
ახლა ჩვენ ამ კონფიგურაციაში ვნერგავთ ყველა მექანიზმს, რომელსაც პლატფორმა იყენებს სიიდან ელემენტის შესარჩევად, ჩაშენებულ ენაზე. ამით ჩვენ დავინახავთ:
● როგორ გამოიყენება სტანდარტული ფორმის პარამეტრები;
● როგორ იყენებს სისტემა მათ;
● როგორ შეუძლია დეველოპერს მათი გამოყენება.
დავამატოთ დამატებითი პარამეტრიის, რომელიც აკონტროლებს არჩეული ფორმის დახურვას ელემენტის შერჩევის შემდეგ. დავარქვათ ეს პარამეტრი CloseAfterSelection(ლოგიკური ტიპი). დავამატოთ ის, როგორც საქონლის დირექტორიას ფორმის შერჩევის ფორმის პარამეტრი.
ელემენტის შერჩევის ფორმის გასახსნელად აუცილებელია SelectStart ღონისძიების მოვლენის დამმუშავებლის შექმნა SelectedItem ფორმის ელემენტში Analogues დირექტორია ელემენტის სახით.

&კლიენტი
Პროცედურა SelectedItemSelectionStart (საქონელი, სტანდარტული დამუშავება)
სტანდარტული დამუშავება= ყალბი;
არჩევანის პარამეტრები= ახალი სტრუქტურა;
SelectionParameters.Insert("SelectionMode", True);
SelectionParameters.Insert("SelectGroupsAndItems", UsingGroupsAndItems.Items);
SelectionParameters.Insert("AllowRootSelection", False);
SelectionParameters.Insert("მიმდინარე ხაზი", ობიექტი.SelectedItem);
SelectionParameters.Insert("CloseAfterSelection", False);
OpenForm ("Catalog.Products.ChoiceForm", არჩევანის პარამეტრები, Items.SelectedProduct);
დასრულების პროცედურა
ჩვენ ცალკე უნდა ვისაუბროთ OpenForm() მეთოდის მესამე პარამეტრზე. ეს პარამეტრი განსაზღვრავს ვინ იქნება შერჩევის ფორმის მფლობელი და ვის ეცნობება შერჩევის შესახებ. AT ამ საქმესჩვენ დავაკონკრეტეთ თავად ფორმის ელემენტი, როგორც შერჩევის ფორმის მფლობელი, მაგრამ ჩვენ ასევე შეგვიძლია დავაზუსტოთ თავად ფორმა ამ პარამეტრით. ამ შემთხვევაში, საჭირო იქნება დამმუშავებლის დანერგვა HandlingChoiceჩამოაყალიბეთ მოდული და გადაწყვიტეთ მასში რომელ ფორმის ატრიბუტში მოათავსოთ არჩეული მონაცემები.
ᲨᲔᲜᲘᲨᲕᲜᲐ. თუ ჩვენ არ განვახორციელებთ მოვლენის დამმუშავებლის StartChoice-ს, მაშინ სისტემა თავად შეასრულებს თავის მოქმედებებს. ეს ეხება ყველა შემდგომ დამმუშავებელს, რომლებიც გამოიყენება მაგალითში.
ახლა ჩვენ უნდა დავამუშაოთ გავლილი პარამეტრები არჩევის ფორმაში. მოდით გავაკეთოთ ეს დამმუშავებელში OnCreateOnServer() შერჩეული ფორმის მოდულის.

&სერვერზე
Პროცედურა OnCreateOnServer (მარცხი, სტანდარტული დამუშავება)
სტანდარტული დამუშავება= ყალბი;
Elements.List.SelectGroupsAndItems = Parameters.SelectGroupsAndItems;
Elements.List.AllowSelectRoot = Parameters.AllowSelectRoot;
Items.List.CurrentRow = Parameters.CurrentRow;
CloseOnSelection = Parameters.CloseAfterSelection;
დასრულების პროცედურა
იმისათვის, რომ შევამოწმოთ ჩვენს მიერ დაყენებული ფორმის პარამეტრების შესრულება, კონფიგურატორის გამოყენებით დავაყენებთ შერჩევის ფორმის ცხრილის List თვისებას. აირჩიეთ ჯგუფები და ნივთები Groups მნიშვნელობამდე (პარამეტრის გამოყენების გარეშე ლექსიკონის ელემენტების შერჩევა არ იქნება ხელმისაწვდომი).
ᲨᲔᲜᲘᲨᲕᲜᲐ. თუ List ცხრილში, რომელიც აჩვენებს პროდუქტების სიას, არ აქვს SelectionMode თვისება დაყენებული True, მაშინ პროდუქტების შერჩევა არ იქნება ხელმისაწვდომი.
ახლა ჩვენ უნდა მოვაგვაროთ სასურველი ნივთის შერჩევა შერჩევის ფორმაში. ამისათვის თქვენ უნდა განსაზღვროთ მოვლენის დამმუშავებელი ფორმის ცხრილის SelectValues ​​ღონისძიებისთვის.

&კლიენტი
Პროცედურა ListSelectionValues ​​(ერთეული, სტანდარტული დამუშავება, მნიშვნელობა)
სტანდარტული დამუშავება= ყალბი;
NotifySelection (მნიშვნელობა);
დასრულების პროცედურა
ჩვენთვის რჩება თვით შეყვანის ველში ელემენტის შერჩევის დამუშავების განხორციელება. ამისათვის თქვენ უნდა გაუმკლავდეთ ღონისძიებას HandlingChoiceჩვენი შეყვანის ველი SelectedProduct.

&კლიენტი
Პროცედურა SelectedItemProcessingChoice (საქონელი, SelectedValue, StandardProcessing)
სტანდარტული დამუშავება= ყალბი;
Object.SelectedItem = SelectedValue;
დასრულების პროცედურა
ჩვენ დამოუკიდებლად განვახორციელეთ სისტემური მექანიზმი ფორმის შეყვანის ველში მნიშვნელობის შერჩევისთვის.
ყურადღება!ეს მაგალითი არ არის სრული. მისი ერთადერთი მიზანია ფორმის პარამეტრებთან მუშაობის მექანიკის დემონსტრირება.
თუ პარამეტრების შექმნისას (დამმუშავებელი SelectedItemSelectionStart()) შეცვალეთ ხაზი:

SelectionParameters.Insert("CloseAfterSelection", True );
ხაზამდე:
SelectionParameters.Insert("CloseAfterSelection", False) ;
მაშინ შერჩევის ფორმა შეწყვეტს დახურვას შერჩევის გაკეთების შემდეგ. ეს შეიძლება გამოყენებულ იქნას, მაგალითად, შერჩევის ფორმის დასანერგად (მრავალი პროდუქტის შერჩევა შერჩევის ფორმის დახურვის გარეშე).

ფორმებს შორის ავტომატური ურთიერთქმედების მხარდასაჭერად, სისტემა გთავაზობთ უამრავ სტანდარტულ ვარიანტს, რომლებიც გამოიყენება ფორმების გასაკონტროლებლად მათი გახსნისას. ამ პარამეტრების დახმარებით სისტემა ახორციელებს ფორმის ველებში შერჩევას შერჩევის ფორმებიდან, ობიექტის ფორმების გახსნა, სტანდარტული ბრძანებების მოქმედება და ა.შ. ანუ ისინი უზრუნველყოფენ სისტემაში ჩაშენებულ ინტერფეისის მუშაობის სხვადასხვა სცენარს. მაგრამ დეველოპერს ასევე შეუძლია გამოიყენოს ეს პარამეტრები 1C:Enterprise ენაში მათი გადაცემით OpenForm() მეთოდის გამოძახებისას.

ჩვენ ჩამოვთვლით სისტემის მიერ მოწოდებულ პარამეტრებს და მათ დანიშნულებას:

• შერჩევის რეჟიმი– ფორმა იხსნება შერჩევის რეჟიმში. მოწოდებულია გაფართოებით მართული ფორმა დინამიური სია.
• მიმდინარე ხაზი– სტრიქონი, რომელიც გააქტიურდება სიაში გახსნისას. გადაეცემა მნიშვნელობა, რომელიც განსაზღვრავს სტრიქონს. მოწოდებულია დინამიური სიის მართული ფორმის გაფართოებით.
• აირჩიეთ ჯგუფები და ნივთები– ეს პარამეტრი ადგენს ფორმის მთავარი ატრიბუტის ცხრილის SelectGroupAndItems თვისებას. მოწოდებულია დინამიური სიის მართული ფორმის გაფართოებით.
• AllowSelectionRoot– განსაზღვრავს, შეიძლება თუ არა ფესვის არჩევა ხის სახით ნაჩვენები დინამიური სიით. მოწოდებულია დინამიური სიის მართული ფორმის გაფართოებით, რომელიც ნაჩვენებია როგორც ხე.
• შერჩევა– შერჩევა მითითებულია დინამიურ სიაში. წარმოადგენს სტრუქტურას. ელემენტების სახელები შეესაბამება იმ ველების სახელებს, რომლითაც ხდება შერჩევა, ხოლო მნიშვნელობები შეიცავს შერჩევის მნიშვნელობებს. მოწოდებულია დინამიური სიის მართული ფორმის გაფართოებით.
• Გასაღები– ფორმაში რედაქტირებული ობიექტის იდენტიფიცირების მნიშვნელობა. თუ მნიშვნელობა აკლია ან არასწორია, ახალი ობიექტი იქმნება დარჩენილი პარამეტრების გამოყენებით. მოწოდებულია ობიექტის ფორმებით და საინფორმაციო რეესტრის ჩანაწერების მენეჯერის გაფართოებებით.
• ValueCopy- მნიშვნელობა, რომელიც განსაზღვრავს ობიექტს, რომელიც გამოყენებული იქნება კოპირებისთვის ახალი ობიექტის შექმნისას. მოწოდებულია ობიექტის ფორმებით და საინფორმაციო რეესტრის ჩანაწერების მენეჯერის გაფართოებებით.
• ღირებულებების შევსება- მნიშვნელობები ახალი ობიექტის დეტალების შესავსებად. წარმოადგენს სტრუქტურას. ელემენტების სახელები შეესაბამება ატრიბუტების სახელებს, ხოლო მნიშვნელობები შეიცავს მონაცემებს, რომლებიც გამოყენებული იქნება მითითებული ატრიბუტების შესავსებად. მოწოდებულია ობიექტის ფორმებით და საინფორმაციო რეესტრის ჩანაწერების მენეჯერის გაფართოებებით.
• ბაზა- მნიშვნელობა, რომელიც განსაზღვრავს ობიექტს, რომელიც გამოყენებული იქნება საფუძვლად ახალი ობიექტის შექმნისას ბაზაზე შეყვანის გზით. მოწოდებულია ობიექტის ფორმის გაფართოებებით.
• ეს ჯგუფი– განსაზღვრავს ახალი ობიექტის ტიპს: ჯგუფს ან ელემენტს. მოწოდებულია ობიექტის ფორმის გაფართოებებით.

ფორმის პარამეტრებთან მუშაობის მაგალითი

იმის საჩვენებლად, თუ როგორ მუშაობს ფორმის პარამეტრები, განვიხილოთ შეყვანის ველში ელემენტის არჩევის განხორციელება. მაგალითის არსი იქნება ჩაშენებულ ენაში სიიდან ელემენტის არჩევის მექანიზმის განხორციელება.

იმ დროისთვის, როდესაც მაგალითზე მუშაობას დაიწყებთ, თქვენ უნდა გქონდეთ კონფიგურაცია, რომელსაც აქვს შემდეგი თვისებები:

• გაშვების მთავარი რეჟიმი არის მართული აპლიკაცია;
• არის საქონლის დირექტორია ჯგუფებისა და ელემენტების იერარქიით;
• არის დირექტორია Analogues ატრიბუტი SelectedItem of DirectoryReference.Goods type;
• ორივე საცნობარო წიგნს აქვს მართული ელემენტის ფორმები.

ახლა ჩვენ ამ კონფიგურაციაში ვნერგავთ ყველა მექანიზმს, რომელსაც პლატფორმა იყენებს სიიდან ელემენტის შესარჩევად, ჩაშენებულ ენაზე. ამით ჩვენ დავინახავთ, თუ როგორ გამოიყენება სტანდარტული ფორმის პარამეტრები; როგორ იყენებს მათ თავად სისტემა; როგორ შეუძლია დეველოპერს მათი გამოყენება.

მოდით დავამატოთ დამატებითი დროშა, რომელიც გააკონტროლებს შერჩევის ფორმის დახურვას ელემენტის შერჩევის შემდეგ. მოდით ამ დროშას ვუწოდოთ CloseAfterSelection (ბულის ტიპი). მოდით დავამატოთ ის საქონლის დირექტორიაში Selection Form-ის ფორმის პარამეტრად.

ელემენტის შერჩევის ფორმის გასახსნელად აუცილებელია SelectStart ღონისძიების მოვლენის დამმუშავებლის შექმნა SelectedItem ფორმის ელემენტისთვის Analogues დირექტორია ელემენტის სახით:

&კლიენტი

პროცედურა SelectedItemSelectionStart (პუნქტი, სტანდარტული დამუშავება)

StandardProcessing = False;

ChoiceParameters = ახალი სტრუქტურა; 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);

დასრულების პროცედურა

ჩვენ ცალკე უნდა ვისაუბროთ OpenForm() მეთოდის მესამე პარამეტრზე. ეს პარამეტრი განსაზღვრავს ვინ იქნება შერჩევის ფორმის მფლობელი და ვის ეცნობება შერჩევის შესახებ. ამ შემთხვევაში, ჩვენ დავაკონკრეტეთ თავად ფორმის ელემენტი, როგორც შერჩევის ფორმის მფლობელი, მაგრამ ჩვენ ასევე შეგვიძლია განვსაზღვროთ თავად ფორმა ამ პარამეტრით. ამ შემთხვევაში, საჭირო იქნება ფორმის მოდულის SelectProcess დამმუშავებლის დანერგვა და მასში გადაწყვეტა, რომელ ფორმის ატრიბუტში მოათავსოთ შერჩეული მონაცემები.

ფორმების პროგრამულად გახსნა მართულ 1C აპლიკაციაში მნიშვნელოვნად განსხვავდება მათი გახსნისგან ჩვეულებრივ აპლიკაციაში. დავიწყოთ ძველი მეთოდით. იგი მოიცავს ფორმის მიღებას და მის შემდგომ გახსნას ნორმალურ ან მოდალურ რეჟიმში (მოდალურ რეჟიმში გახსნისას ფორმა ბლოკავს პროგრამას).

GetForm(). ღია ()

ეს არის ფორმების გახსნის ყველაზე ნელი მეთოდი. თუმცა, ის საშუალებას გაძლევთ პროგრამულად დაამუშავოთ ფორმა მის გახსნამდე. დამუშავებისთვის, კოდი ოდნავ უნდა შეიცვალოს:

Form= GetForm( "დოკუმენტი. საქონლისა და მომსახურების მიღება. დოკუმენტის ფორმა") ;
//აქ ვასრულებთ მოქმედებებს ფორმით
Ფორმა. Open() ;

გასათვალისწინებელია, რომ ფორმის მიღებისას განხორციელდება სხვა ღონისძიების პროცედურა OnCreateOnServer.

განვიხილოთ სხვა მეთოდები, რომლებიც საშუალებას გაძლევთ გახსნათ ფორმები მართულ 1C აპლიკაციაში უფრო სწრაფად და მოხერხებულად. კონკრეტული სიტუაციიდან გამომდინარე, შეიძლება გამოყენებულ იქნას სხვადასხვა მეთოდი.

1. როგორ გავხსნათ ობიექტის ფორმა მართულ აპლიკაციაში, თუ მასზე ბმული არსებობს.

ამ შემთხვევაში, ყველაფერი ძალიან მარტივია.

RefReference= ცნობები. ნომენკლატურა. FindByCode("000000001");
OpenValue(ReferenceReference) ;

2. როგორ გავხსნათ შერჩევის ფორმა და შემდეგ მივიღოთ არჩეული მნიშვნელობა.

ამისთვის არის ფუნქცია EnterValue().ფუნქციას აქვს 3 პარამეტრი:

• ცვლადი, რომელშიც არჩეული მნიშვნელობა ჩაიწერება;
• მინიშნება, რომელიც გამოჩნდება შერჩევის ველში;
• შერჩეული მნიშვნელობების ტიპების აღწერა. შეიძლება იყოს რამდენიმე ტიპი, შემდეგ კონკრეტული მნიშვნელობის არჩევამდე მოგეთხოვებათ აირჩიოთ ტიპი.

ფუნქციის შესრულების შედეგად გაიხსნება მითითებული ტიპის ობიექტის ნაგულისხმევი შერჩევის ფორმა.

ცვლადი მნიშვნელობა;
Array= ახალი მასივი;
მასივი. დამატება(ტიპი( "DirectoryLink.Nomenclature") ) ;
მასივი. დამატება(ტიპი( "DirectoryLink. კონტრაგენტები") ) ;

TypeDescription= new TypeDescription(Array) ;

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

წინა მეთოდები იძლეოდა მხოლოდ ობიექტებისთვის ნაგულისხმევად დაყენებული ფორმების გახსნას (ობიექტის ფორმა ან შერჩევის ფორმა). თუ თქვენ გჭირდებათ თვითნებური ფორმის გახსნა, შეგიძლიათ გამოიყენოთ ფუნქცია OpenForm().

ამ ფუნქციას აქვს საკმაოდ ბევრი პარამეტრი. განვიხილოთ ზოგიერთი მათგანი:

• ფორმის სახელი- აქ შეგიძლიათ აირჩიოთ ობიექტის რომელიმე სტანდარტული ფორმა, მაგალითად, FormSelectან FormList. ან დეველოპერების მიერ შექმნილი კონკრეტული ფორმა.
• Პარამეტრები- საშუალებას გაძლევთ გადაიტანოთ ფორმაში ფორმაში სტრუქტურებირამდენიმე პარამეტრი მის გახსნამდე, რითაც განისაზღვრება გამომავალი მონაცემები. პარამეტრები შეიძლება იყოს ნებისმიერი მონაცემი, რომელიც შეიძლება გადაეცეს კლიენტიდან სერვერზე. ფორმის გახსნისას მიღებული პარამეტრები შეიძლება დამუშავდეს პროცედურაში OnCreateOnServer ()გახსნილ ფორმაზე.
• ფორმის გახსნის რეჟიმი- აქვს 3 ვარიანტი: დამოუკიდებელი, დაბლოკოს მთელი ინტერფეისი, დაბლოკოს მფლობელის ფორმა.

ვნახოთ, როგორ გამოიყენება ფუნქცია OpenForm()სხვადასხვა სიტუაციებში.

3. როგორ გავხსნათ არსებული ობიექტის ფორმა

თითოეულ ფორმას აქვს ერთი ძირითადი ატრიბუტი. ფორმის ატრიბუტების ჩამონათვალში იგი ხაზგასმულია თამამად და ჩვეულებრივ უწოდებენ Საგანიდირექტორიების, დოკუმენტების ელემენტების ფორმებში. სხვა ობიექტებს შეიძლება ჰქონდეთ განსხვავებული სახელი. არსებული ობიექტის ფორმის გასახსნელად, თქვენ უნდა გადასცეთ პარამეტრი გახსნილ ფორმას Გასაღებიმნიშვნელობით, როგორც ობიექტის მითითებით.

&კლიენტი
პროცედურის ბრძანება 1 (ბრძანება)
პარამეტრი= ახალი სტრუქტურა;
Პარამეტრი. Insert("Key" , FindC() );
OpenForm(, პარამეტრი) ;
დასრულების პროცედურა

&სერვერზე
FindC() ფუნქცია;
დააბრუნეთ სახელმძღვანელოები. კონტრაგენტები. FindByAttribute ("TIN", "745107734623")
ბოლო ფუნქციები

4. როგორ გავხსნათ ახალი ობიექტის ფორმა

ეს მხოლოდ ფუნქციაა OpenForm()ყოველგვარი პარამეტრის გარეშე.

&კლიენტი
პროცედურის ბრძანება 1 (ბრძანება)
OpenForm ( "საცნობარო წიგნი. კონტრაგენტები. ობიექტის ფორმა") ;
დასრულების პროცედურა

5. როგორ გავხსნათ ახალი ობიექტის ფორმა და შევავსოთ რაღაცის საფუძველზე

საჭიროა პარამეტრის გადაცემა ბაზა, რომლის მნიშვნელობა იქნება მითითება შევსების ბაზის ობიექტზე. ეს დაიწყებს პროცედურას HandleFill().

&კლიენტი
პროცედურის ბრძანება 1 (ბრძანება)
პარამეტრი= ახალი სტრუქტურა;
Პარამეტრი. Insert("მიზეზი" , LinkToAccountToBuyer) ;
OpenForm ( "დოკუმენტი. საქონლისა და მომსახურების რეალიზაცია. ობიექტის ფორმა", Პარამეტრი) ;
დასრულების პროცედურა

ეს მაგალითი შექმნის დოკუმენტს საქონლისა და მომსახურების რეალიზაციადა შევსებულია მყიდველისთვის გადახდის ინვოისის საფუძველზე, რომლის ბმული გადაეცა.

6. როგორ გავხსნათ ფორმა და დავაყენოთ მასზე არჩევანი

1C ფორმებზე შერჩევა შეიძლება იყოს მარტივი და რთული. მარტივი შერჩევა მოიცავს გამონათქვამებს, როგორიცაა ორგანიზაცია = Horns and Hooves LLC.კომპლექსური შერჩევა მოიცავს სხვა სახის შედარებებს, მაგალითად, ჩამოთვლილი. ამ სტატიაში განვიხილავთ მარტივი შერჩევის ორგანიზებას, ხოლო რთულს ცალკე სტატია დაეთმობა.

მარტივი შერჩევის ორგანიზებისთვის, თქვენ უნდა გაიაროთ პარამეტრი გახსნილი ფორმის გასაღებით შერჩევა, მნიშვნელობა იქნება სტრუქტურა, რომელშიც გასაღები არის დინამიური სიის ველის სახელი და მნიშვნელობა არის საძიებელი მონაცემები.

მაგალითად, გავხსნათ საძიებო სიის ფორმა არა-GTEდა ჩვენ იქ გავაკეთებთ შერჩევას მფლობელის მიერ - დირექტორიას ელემენტს ნომენკლატურა.

&კლიენტი
პროცედურის ბრძანება 1 (ბრძანება)
პარამეტრი= ახალი სტრუქტურა;

შერჩევა= ახალი სტრუქტურა;
შერჩევა. ჩასმა ("მფლობელი", LinkToNomenclature) ;

Პარამეტრი. ჩასმა ("არჩევა", შერჩევა) ;

OpenForm ( "Directory.GTE Numbers.List Form", Პარამეტრი) ;
დასრულების პროცედურა

7. როგორ გავხსნათ საინფორმაციო რეესტრის შესვლის ფორმა

ამისათვის საჭიროა ინფორმაციის რეესტრის ჩანაწერის გასაღები.

ჩანაწერის გასაღებიარის ყველა გაზომვის მნიშვნელობები და პერიოდი (თუ რეესტრი პერიოდულია). ანუ ჩანაწერის გასაღები არის ის პარამეტრები, რომლითაც შესაძლებელია ჩანაწერის ცალსახად იდენტიფიცირება.

გახსნის ალგორითმი შემდეგია:

1. ჩვენ შევიყვანთ ჩანაწერის გასაღების მონაცემებს საჭირო მნიშვნელობებით სტრუქტურაში.
2. მიღებულ სტრუქტურას ვათავსებთ მასივში.
3. მასივიდან ვქმნით ჩანაწერის გასაღებს.
4. პარამეტრის გადაცემა გახსნილ ფორმაში Გასაღებიჩანაწერის გასაღები მე-3 პუნქტიდან, როგორც მნიშვნელობა.

&კლიენტი
პროცედურის ბრძანება 1 (ბრძანება)
პარამეტრი= ახალი სტრუქტურა;

KeyParameters= ახალი სტრუქტურა;
საკვანძო პარამეტრები. Insert("ნომენკლატურა", LinkToNomenclature) ;
საკვანძო პარამეტრები. Insert("PriceType" , LinkToPriceType) ;
საკვანძო პარამეტრები. ჩასმა ("პერიოდი", თარიღი) ;

ArrayKey = ახალი მასივი;
ArrayKey. დამატება(KeyParameters) ;

ჩანაწერის გასაღები = ახალი ( "ინფორმაცია RegisterRecordKey.NomenclaturePrices", ArrayKey);

Პარამეტრი. Insert("Key", RecordKey) ;

OpenForm ( "საინფორმაციო რეესტრი. ნომენკლატურული ფასები. ჩანაწერის ფორმა", Პარამეტრი) ;
დასრულების პროცედურა

ეს სტატია აღწერს, თუ როგორ უნდა გადავიტანოთ მნიშვნელობა, როგორც პარამეტრი, როგორც პარამეტრი, მართული ფორმის 8.2 გახსნისას, შედარებით, თუ როგორ შეიძლება მსგავსი ოპერაციის განხორციელება ჩვეულებრივ ფორმებში.

როგორ ხდება პარამეტრების გადაცემა ნორმალურ ფორმებში

ნორმალურ ფორმებში არსებობდა პარამეტრის გადაცემის 2 შესაძლებლობა:
1) ნაკლებად გავრცელებული მეთოდი: "დეტალების" ჩანართზე ობიექტის სახით დაემატა საყრდენი, საჭიროების შემთხვევაში, წვდომა განისაზღვრა ვიზუალური საშუალებებით.
2) უფრო გავრცელებული გზა: საექსპორტო ცვლადი გამოცხადდა ფორმის მოდულში და მნიშვნელობა დამუშავდა "გახსნის წინ" დამმუშავებელში.

ორივე შემთხვევაში, ფორმის გამოძახება ასე გამოიყურებოდა:

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

როგორ ხდება პარამეტრების გადაცემა მართულ ფორმებში

მართულ ფორმებს ახლა აქვთ შესაძლებლობა დაუყოვნებლივ გადასცენ პარამეტრები ფორმის მიღებისას. პარამეტრები გადაეცემა როგორც სტრუქტურა:

პარამეტრები = ახალი სტრუქტურა ("CurrentValue",LastItem);
ChoiceForm = GetForm ("Catalog.Nomenclature.ChoiceForm",Parameters);
FoundItem = ChoiceForm.OpenModal();

ასევე, მართულ ფორმას აქვს „ფორმის გაფართოებები“ (ობიექტი, დირექტორია, დოკუმენტი, ანგარიში). ობიექტის ტიპის მიხედვით, განისაზღვრება ხელმისაწვდომი პარამეტრების სია. მაგალითად, თუ საჭიროა ლექსიკონის შერჩევის ფორმაში გარკვეული ელემენტის განლაგება, მაშინ გამოიყენება "CurrentValue" პარამეტრი. დიდი პლიუსი ის არის, რომ თავად ფორმაში არ არის საჭირო წინასწარ განსაზღვრული პარამეტრების დამმუშავებლების ჩაწერა, რაც ამცირებს კოდის რაოდენობას.

ასევე, დეველოპერს აქვს შესაძლებლობა განსაზღვროს საკუთარი პარამეტრები (მართული ფორმის დიზაინერში, "პარამეტრების" ჩანართში). პარამეტრების სიცოცხლე შეზღუდულია OnCreateOnServer დამმუშავებლის მიერ, რაც ლოგიკურია, რადგან პარამეტრები საჭიროა მხოლოდ ფორმის შექმნისას, მაგრამ თუ ეს პარამეტრი განსაზღვრავს ფორმის უნიკალურობას („ძირითადი პარამეტრი“ დროშა მითითებულია პარამეტრის თვისებებში), ის ხელმისაწვდომი იქნება სხვა დამმუშავებლებში.

კონკრეტული მანიპულაციის პარამეტრის გასაცემად, ცოტა მეტი უნდა გააკეთოთ:

1) განსაზღვრეთ პარამეტრი მართული ფორმით.
OnCreateAtServer დამმუშავებელში, განსაზღვრეთ ამ პარამეტრის დამუშავება (გადავლილ პარამეტრებზე წვდომა FormDataStructure ტიპის "პარამეტრების" თვისებით)
2) აღწერეთ ფორმის მიღება და გადაიტანეთ ახალი პარამეტრის მნიშვნელობა GetForm ფუნქციის პარამეტრებში.
ასე რომ, კოდი ასე გამოიყურება:
- ფორმის მიღების ადგილზე

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

მართული ფორმის მოდულში

&სერვერზე
პროცედურა CreationOnServer-ზე (მარცხი, სტანდარტული დამუშავება)
If Parameters.Property("NewParameter") მაშინ
// პარამეტრის დამუშავების კოდი აქ
Დაასრულე თუ;
დასრულების პროცედურა

დასკვნა

შესაძლოა, ეს სტატია ვინმეს გამოადგეს, ის დაზოგავს დროს და გიხსნით ზედმეტი კოდისგან. უფრო დეტალური ინფორმაციისთვის სრული სიამართული ფორმის პარამეტრების მიხედვით, რეკომენდირებულია იხილოთ დახმარება "მართული ინტერფეისი \ მართული ფორმა".

[ბმულის სანახავად საჭიროა დარეგისტრირება]