1c parametrii de procesare a formularelor de imprimare externă. Ieșirea formularelor tipărite cu cerere de date în formularul „Tipărește documente” din subsistemul „Tipărește” BSP. Fișier de procesare extern

Acest articol vă va spune în detaliu cum un începător cu puține cunoștințe despre 1C 8 poate crea un formular tipărit. De exemplu, să luăm una dintre cele mai comune configurații 1C 8 - Contabilitate 2.0. Crearea unui formular tipărit 1C etape de scriere:

Crearea unui formular de tipărire extern;
Crearea unui aspect de formular tipărit;
Scrierea codului de program pentru a afișa pe ecran datele de formular tipărite;
Crearea parametrilor pentru înregistrarea automată a unui formular tipărit;
Conectarea unui formular de imprimare extern la bază 1C Întreprinderi.

Crearea unui formular tipărit 1C. Formularea problemei

Suntem solicitați în configurație Contabilitate 2.0 creați un formular tipărit pentru un document Recepția de bunuri și servicii. În antetul formularului tipărit, afișați următoarele date:

Organizare;
contraparte;
Acord de contrapartidă;
Data chitanței.

Afișați datele din secțiunea tabelară ca tabel Bunuri document. Tabelul trebuie să includă următoarele coloane:

Nomenclatură;
Cantitate;
Preț;
Sumă;
Și, de asemenea, prețul articolului pentru data curentă (după tipul de preț din document).

Fișier de procesare extern

Să trecem la rezolvarea problemei. Mai întâi, să deschidem 1C 8 în modul Configurator. În acest mod sunt efectuate toate dezvoltările pe platforma 1C 8. Acum trebuie să creăm un fișier de procesare extern. Pentru a face acest lucru, faceți clic pe meniu Fișier -> Nou... sau prin pictograma unui fișier nou.

În fereastra care se deschide, selectați elementul Prelucrare externă.

Următorul pe teren Nume Trebuie să introduceți numele procesării externe. În cazul nostru, îl vom numi pur și simplu „PrintForm”; câmpul sinonim va fi completat automat. Vă rugăm să rețineți că în câmp Nume, prelucrare externă, numele trebuie scris fără spații sau semne de punctuație.

Să adăugăm atribute de procesare externe LinkToObject și selectați tip pentru el DocumentLink Primirea Bunurilor și Serviciilor. Pentru a face acest lucru, în arborele metadatelor de procesare externă 1C, selectați elementul Rechiziteși apăsați butonul Adăuga(buton cu plus verde). Fereastra cu proprietățile atributelor se va deschide în partea dreaptă a ecranului, în câmp Nume Hai să scriem - ReferenceToObject. ÎN camp Tip apăsați butonul cu trei puncte.

Să extindem ramura în arborele de tip DocumentLink, și găsiți acolo elementul Recepție de bunuri și servicii, bifați caseta de lângă acesta și faceți clic BINE.

Să salvăm fișierul de procesare externă pe hard disk pentru a face acest lucru, folosiți meniul Fișier -> Salvare, pictograma Salvați(dischetă albastră) sau o comandă rapidă de la tastatură Ctrl+S. Să denumim fișierul salvat „PrintForm”.

Crearea unui aspect de formular tipărit

Să începem să creăm un aspect al formularului de printare 1C. Aspectul servește ca șablon pentru ieșirea formularului tipărit, așa că dacă doriți ca formularul tipărit să arate bine, ar trebui să-i acordați atenție.

Să adăugăm un nou aspect în arborele metadatelor de procesare externă, nu vom schimba nimic în fereastra de proiectare a aspectului și facem clic pe butonul Gata.

În noul aspect care se deschide, vom crea mai multe zone necesare pentru afișarea formularului tipărit. Toate zonele de aspect de care avem nevoie vor fi orizontale, așa că pentru a crea o zonă nouă, selectați numărul necesar de linii de aspect și accesați meniul Tabel -> Nume -> Atribuiți nume sau utilizați comanda rapidă de la tastatură Ctrl + Shift + N, apoi introduceți numele regiunii în casetă. Când creați o zonă de aspect, nu vă fie teamă să faceți o greșeală cu numărul de linii pe care le puteți adăuga sau elimina oricând. Pentru a șterge o linie de aspect 1C, selectați linia dorită și selectați elementul din meniul contextual Șterge. Pentru a adăuga o nouă linie la aspect, selectați orice linie a aspectului și selectați elementul din meniul contextual Extinde.

Adăugarea unui antet de aspect

În primul rând, să creăm o zonă Un capac, va afișa datele pentru antetul formularului de tipărire. Pentru această zonă vom avea nevoie de șapte linii de aspect. Să le selectăm și, așa cum am scris mai sus, să apăsăm combinația de taste Ctrl + Shift + N, în câmp Nume scrieți „Pălărie” și apăsați butonul Bine.

Să umplem zona de aspect cu datele de care avem nevoie. De obicei, niciun formular tipărit nu este complet fără un titlu, așa că haideți să creăm unul și în antetul nostru de aspect. Întrucât în titlu, pe lângă numele formularului tipărit, vom afișa și numărul documentului din care a fost tipărit, vom seta ca parametru textul titlului din layout. Un parametru de aspect este o celulă de aspect special desemnată în care pot fi scoase diverse date folosind limbajul 1C 8 încorporat. Titlul ar trebui să fie afișat pe toată lățimea formularului tipărit, așa că haideți să decidem câte celule de aspect vor fi suficiente pentru a imprima pe o orientare standard peisaj a foii.

De obicei sunt suficiente treisprezece sau paisprezece celule de aspect, selectați-le în primul rând al zonei Un capacși se combină într-o singură celulă ( Meniu contextual -> Îmbinare). După aceasta, faceți dublu clic pe celula mare rezultată și scrieți numele parametrului, în cazul nostru „TitleText”. Pentru ca textul introdus să devină un parametru cu drepturi depline, faceți clic dreapta pe celulă și selectați elementul din meniul contextual Proprietăți. Pe marcaj Aspect haideti sa gasim terenul Umplereși selectați valoarea Parametru. Parametrii din aspectul 1C sunt indicați prin paranteze „<>».

Titlul formularului tipărit ar trebui să iasă în evidență printre celelalte text, așa că selectați din nou celula și utilizați pictogramele de pe panoul de formatare a aspectului pentru a seta alinierea textului Centratși dimensiunea fontului 14.

După textul titlului îl vom afișa în zonă Un capac informații despre organizație, contraparte, contractul de contraparte și data primirii mărfurilor. Întrucât toate aceste date sunt preluate și din document, le vom oficializa și cu parametri. În plus, înainte de fiecare parametru ar trebui să scrieți un text explicativ, astfel încât utilizatorul să poată înțelege cu ușurință unde se află organizația, unde este contrapartea etc. Toate aceste acțiuni sunt similare cu crearea unui titlu, așa că nu mă voi opri asupra lor în detaliu, voi oferi doar o imagine a ceea ce ar trebui să se întâmple în final.

Figura arată cum diferă parametrii de aspect de textul obișnuit.

Adăugarea unui antet de tabel de aspect

Ultimul lucru pe care trebuie să-l creăm în această zonă de aspect este antetul tabelului, în care vor fi afișate datele părții tabelare Bunuri. Coloanele necesare pentru tabel au fost descrise în secțiunea „Declarație de problemă”. De asemenea, vom crea un antet de tabel folosind o combinație de celule și text de scriere (numele coloanelor). Selectați marginile antetului tabelului folosind instrumentul Cadru, care se află în panoul de formatare a aspectului.

Adăugarea unui tabel la un aspect

Să creăm o altă zonă în aspect - Date. Tabelul de date al părții tabelare va fi afișat în acesta Bunuri. Pentru această zonă, avem nevoie de o singură linie de aspect. Pentru a afișa toate rândurile părții tabulare într-o formă tipărită, vom completa și afișa această zonă de numărul necesar de ori. Coloane din zonă Date ar trebui să coincidă cu coloanele din antetul tabelului, deci completarea acestuia nu va fi dificilă. Singura diferenta este in zona Date avem nevoie de parametri, nu doar de text. De asemenea, rețineți că, implicit, parametrii numerici sunt formatați la dreapta, iar parametrii de text sunt formatați la stânga. Pentru a selecta coloanele, trebuie să utilizați și instrumentul Cadru.

Adăugarea unui subsol la un aspect

Ultima zonă de aspect de care avem nevoie este subsol. Va afișa totalurile după cantitate și cantitate. Crearea este similară cu crearea unei zone Date, dar în plus rezultatele ar trebui evidențiate cu caractere aldine.

Rezultatul final ar trebui să fie un aspect care să arate astfel:

Crearea unui formular tipărit 1C. Programare

Să începem programarea - aceasta este cea mai importantă etapă în crearea unui formular tipărit. În primul rând, să mergem la modulul obiect formular de tipărire externă, aici vom programa. Pentru a face acest lucru, în fereastra principală de procesare externă, faceți clic Acțiuni -> Deschide modul obiect.

Trebuie să creați o funcție de export în modulul obiect formular de tipărire extern Sigiliu().

Funcție Print() Export EndFunction

Vă rugăm să rețineți că această caracteristică este necesară pentru formularele de tipărire externe în configurații care utilizează aplicația obișnuită. Tot codul de program ulterior necesar pentru afișarea formularului tipărit va fi scris în această funcție.

Inițializarea variabilelor de bază

Să creăm o variabilă TabDoc, care va conține un document de foaie de calcul - acesta este exact forma tipărită în care vom afișa zonele umplute ale aspectului.

TabDoc = nou TabularDocument;

La o variabilă Aspect Vom obține aspectul de formular tipărit pe care l-am creat. Pentru a face acest lucru, folosim funcția încorporată GetLayout(<ИмяМакета>).

Layout = GetLayout("Layout");

Vom converti toate zonele layout-ului în variabile. Pentru a face acest lucru, folosim metoda layout-ului GetArea(<ИмяОбласти>) .

HeaderArea = Layout.GetArea("Header"); AreaData = Layout.GetArea("Date"); AreaFooter = Layout.GetArea("Footer");

Ieșirea antetului unui formular tipărit într-un document de foaie de calcul

Toate variabilele necesare sunt inițializate. Să începem să completăm și să afișăm zonele de aspect într-un document de foaie de calcul. Mai întâi de toate, să completăm titlul formularului imprimabil pentru aceasta trebuie să trecem parametrul Textul titlului, pe care l-am creat în layout, textul de care avem nevoie. Pentru a completa valorile parametrilor, zona de aspect are o colecție specială, care se numește - Opțiuni. Din care prin „.” poți obține orice parametru. În textul antetului vom transfera textul: „Formular tipărit”, precum și numărul documentului.

Header Area.Parameters.TitleText = "Tipărește formular"+LinkToObject.Number;

Vom completa parametrii rămași ai antetului în mod similar, vom obține toate valorile necesare pentru aceștia din detalii Referință la obiect, care conține un link către documentul de tipărit.

HeaderArea.Parameters.Organization = LinkToObject.Organization; HeaderArea.Parameters.Account = LinkToObject.Account; HeaderArea.Parameters.ReceiptDate = LinkToObject.Date; Antet Area.Parameters.Counterparty Agreement = LinkToObject.Counterparty Agreement;

Toți parametrii antetului sunt completați, îl vom afișa în foaia de calcul creată de noi, pentru aceasta folosim metoda Ieșire(<Область>) .

TabDoc.Output(HeaderArea);

Scrierea unei cereri pentru un handicap tipărit

Să începem să umplem și să desenăm zona Date. Crearea unui formular tipărit 1C implică și scrierea unei interogări, avem nevoie de el pentru a obține date tabelare Bunuri si preturi Nomenclaturi pentru data curentă vom folosi Cerere. Limbajul de interogare 1C 8 este similar cu SQL, sau mai degrabă copiază practic capacitățile operatorului său SELECT, dar întreaga interogare este scrisă în rusă. Prin urmare, dacă sunteți cel puțin vag familiarizat cu SQL, atunci veți înțelege cu ușurință limbajul de interogare 1C 8.

În această formă tipărită, cererea va fi destul de simplă și mulți vor spune că ar fi posibil să se facă fără ea, dar cunoașterea limbajului de interogare și capacitatea de a-l folosi cu competență este una dintre principalele abilități ale unui programator 1C. Interogările vă permit să obțineți mostre de date complexe folosind mai puține resurse, iar textul interogării este mult mai ușor de înțeles decât codul programului scris fără a utiliza o interogare (sau cu o utilizare minimă a acesteia). În plus, 1C 8 are un designer de interogări foarte bun care vă permite să asamblați interactiv o interogare din tabelele necesare.

Să creăm o variabilă care va conține cererea.

Solicitare = Solicitare nouă;

Vom compune textul cererii folosind constructorul de solicitare. Pentru început, să scriem:

Solicitare.Text = "";

Plasați cursorul mouse-ului între ghilimele și apăsați butonul dreapta al mouse-ului. În meniul contextual care se deschide, selectați elementul Constructor de solicitări, ne va ajuta foarte mult în crearea unui formular de printare 1C. După aceasta, se va deschide fereastra de proiectare de interogări, care conține multe file, dar pentru interogarea noastră vom avea nevoie doar de patru: „Tabele și câmpuri”, „Relații”, „Condiții”, „Asocieri / Aliasuri”.

Pentru interogarea noastră vom avea nevoie de două tabele: partea de tabel Bunuri document Recepția de bunuri și serviciiși un instantaneu al celor mai recente informații cu privire la data curentă a registrului Preturile articolelor.

În partea stângă a ferestrei de designer găsim coloana Bază de date. Conține un arbore cu toate obiectele metadate, haideți să le găsim pe cele de care avem nevoie. Pentru a face acest lucru, să deschidem firul Documentațieși găsiți documentul Primirea Bunurilor și Serviciilor, să-l deschidem și să găsim partea tabulară Bunuri, trageți-l în coloana designerului de interogări Mese. Puteți trage în trei moduri: prin glisare, făcând dublu clic pe tabel sau selectând-o și făcând clic pe butonul „>”. Să deschidem firul Registre de informațiiși găsiți masa acolo Nomenclatură prețuri.Comandă rapidă Ultimele, trageți-l și în coloană Mese. Aceste două tabele sunt suficiente pentru interogarea noastră.

Să selectăm câmpurile de care avem nevoie din tabelele rezultate. Pentru a face acest lucru, în coloană Mese hai sa deschidem masa și găsiți câmpurile: Nomenclatură, Sumă, Preț, Cantitateși trageți-le în a treia coloană a constructorului - Câmpuri. Să extindem tabelul , să găsim câmpul Prețși, de asemenea, trageți-l în Câmpuri.

Structura tabelelor și câmpurilor solicitării noastre este gata, acum să trecem la condiții. Avem nevoie de datele tabelare Bunuri nu au fost luate din toate chitanțele, ci doar din cea pe care o tipărim. Pentru a face acest lucru, vom impune o condiție pe masă Primirea BunurilorServiciiMarfa. Să mergem la fila „Condiții” a designerului de interogări. Într-o coloană Câmpuri tabelele pe care le-am selectat mai devreme sunt localizate, pentru condiție vom avea nevoie de un câmp Legătură de la masă Primirea Bunurilor și Serviciilor Bunuri, Să-l tragem în fereastra Condiții.

În cererile 1C puteți utiliza parametrii, aceștia sunt necesari pentru a transfera date către cerere. De exemplu, dacă dorim să limităm selecția documentelor la un anumit document, atunci putem folosi un parametru pentru a trece un link către acest document către cerere și folosim acest parametru în condiție. Este exact ceea ce vom face în cererea noastră.

După fereastră Condiții am adăugat un câmp Legătură, designerul de interogări însuși va crea un parametru cu același nume și îl va plasa după semnul „=”. Acest parametru poate fi redenumit dacă se dorește. În textul cererii, parametrii sunt marcați cu semnul „&”, dar în acest caz nu este necesar, deoarece se presupune că a doua parte a condiției conține un parametru, trebuie doar să vă amintiți acest lucru. Cum se transmite o valoare unui parametru de cerere 1C va fi discutat mai jos.

Deoarece în cerere nu folosim un tabel complet de prețuri pentru articol, ci unul virtual (o felie din acesta din urmă în acest caz), trebuie să stabilim condițiile pentru formarea acestui tabel virtual, în cazul nostru acesta este data limită și condiția pentru tipul de prețuri (prețurile care au un tip de preț strict definit este cel care este specificat în bonul pe care îl tipărim).

Pentru a completa parametrii tabelului virtual, accesați fila Tabele și câmpuri constructor de interogări, în coloană Mese selectați tabelul PrețuriNomenclaturăTăiereUltimeși apăsați butonul Opțiuni de masă virtuală, situat în partea de sus. În fereastra care se deschide, în câmp Perioadă ar trebui să setați un parametru la care să fie trecută data la care se va face reducerea prețului. În cazul nostru, aceasta va fi data curentă (adică astăzi), așa că vom numi parametrul „&CurrentDate”. În câmpul de condiții vom scrie condițiile pentru tipul de preț, îl vom trece și în parametrul, pe care îl vom numi „&TypePrice”. Condiția rezultată va arăta astfel (unde TipPreț- măsurarea registrului Preturile articolelor):

PriceType = &PriceType

Parametrii tabelului virtual sunt completați, faceți clic pe butonul Bine.

Acum că am limitat selecția doar la documentul de care avem nevoie, să creăm conexiuni între tabelele de interogări. Dacă acest lucru nu se face, atunci prețurile din tabelul PricesNomenclatureSliceLast nu vor fi asociate articolului din chitanță. Să mergem la filă Conexiuni designer de interogări. Să creăm o conexiune pe tot terenul Nomenclaturăîntre cele două mese ale noastre. Pentru a face acest lucru, apăsați butonul Adăuga, în câmp tabelul 1 selectați un tabel Primirea BunurilorServiciiMarfa, iar în câmpul Tabel 2 - PricesNomenclatureSliceLast. În condițiile de comunicare, selectați câmpurile Nomenclatură din ambele mese.

De asemenea, trebuie remarcat faptul că în selecția interogării trebuie să obținem toate rândurile din partea filă Bunuriși prețurile numai dacă sunt disponibile la data curentă pentru tipul de preț al documentului. Astfel, datele tabelare Bunuri sunt obligatorii, dar datele de defalcare a prețurilor nu sunt disponibile. Prin urmare, în relațiile dintre aceste tabele, este necesar să se folosească așa-numitul LEFT JOIN, iar tabelul din stânga (sau necesar) va fi Primirea BunurilorServiciiMarfa, și dreapta (sau opțional) PriceNomenclatureSliceLast. Pentru ca îmbinarea din stânga a tabelelor de interogări să funcționeze așa cum am descris mai sus, trebuie să bifați caseta Toate după câmp Tabelul 1.

Solicitarea este aproape gata, nu mai rămâne decât să lucrăm puțin la aliasurile de câmp. Să mergem la marcaj Sindicate/Alias-uriși setați un alias pentru câmp PrețuriNomenclatură Slice Ultimele.Preț. Porecla va fi - Preț ca astăzi, este necesar pentru ca numele câmpurilor de selecție a interogării și numele parametrilor din aspectul formularului tipărit să se potrivească.

Lucrarea în designerul de interogări este acum finalizată, faceți clic pe OK. După ce fereastra designerului se închide, veți vedea că linia cu textul cererii este completată și arată astfel:

Solicitare.Text = "SELECT | Recepție BunuriServiciiProduse.Nomenclatură, | Recepție BunuriServiciiProduse.Suma, | Primire BunuriServiciiProduse.Preț, | Primire BunuriServiciiProduse.Cantitate, | Nomenclatură Prețuri Secțiunea de Ultime.Preț AS PrețToday. |FeiROM | GoodsServices.Goods AS Recepție ProduseServiciiProduse |. CONEXIUNEA STÂNGA RegisterInformation.PricesNomenclature.SliceLast (| &CurrentDate, PriceType = &PriceType) AS PricesNomenclatureSliceLast ON Receipt of GoodsServicesProducts.Nomenclature |

Executarea cererii

Să transmitem parametrii necesari cererii pentru aceasta vom folosi metoda de solicitare SetParameter(<ИмяПараметра>,<Значение>). Pentru a obține data curentă, utilizați funcția încorporată data curentă (), returnează data și ora computerului.

Să lansăm o interogare pentru a obține o mostră cu datele de care avem nevoie. Pentru a face acest lucru, mai întâi utilizați metoda de solicitare Alerga(), iar apoi metoda Alege().

Selectare = Query.Run().Select();

Completarea tabelului formular tipărit

Ca urmare, în variabila Probă va conține o selecție de rezultate ale interogării, puteți naviga prin ea folosind metoda Următorul(), iar pentru a parcurge totul ai nevoie de o buclă Pa. Designul va fi după cum urmează:

While Select.Next() Loop EndLoop;

În această buclă vom completa și afișa zona de aspect Date. Dar mai întâi, să inițializam două variabile de tip numeric. În ele vom colecta totalurile după cantitate și cantitate pe care trebuie să le afișam în zonă subsol.

Suma totală = 0; TotalQuantity = 0;

În interiorul buclei vom umple zona Date date din elementul de selecție curent în variabile Valoare totalăȘi Cantitatea totala adăugați valori de sumă și cantitate și, în final, afișați zona într-un document de foaie de calcul folosind metoda deja familiară nouă Ieșire (). Deoarece numele câmpurilor din cererea noastră coincid complet cu numele parametrilor zonei Date, apoi pentru a completa vom folosi procedura încorporată FillPropertyValues(<Приемник>, <Источник>), care copiază valorile proprietăților<Источника>la proprietăți<Приемника>.

While Selection.Next() Loop FillPropertyValues(AreaData.Parameters,Selection); TotalSum = TotalSum + Sample.Sum; TotalQuantity = TotalQuantity + Sample.Quantity; TabDoc.Output(AreaData); EndCycle;

Ieșirea subsolului unui formular tipărit într-un document de foaie de calcul

Rămâne să umpleți și să afișați ultima zonă a aspectului - subsol. Am pregătit deja datele pentru completarea, completarea și retragerea se efectuează conform aceleiași scheme.

AreaFooter.Parameters.TotalQuantity = TotalQuantity; AreaFooter.Parameters.TotalSum = TotalSum; TabDoc.Output(AreaFooter);

Documentul din foaia de calcul este complet completat; nu rămâne decât să îl afișați pe ecran, astfel încât utilizatorul să poată vizualiza formularul tipărit și să îl imprime dacă este necesar. Dar în configurațiile tipice 1C 8, procedurile modulelor speciale sunt responsabile pentru ieșirea formularelor tipărite externe. Prin urmare, este suficient să reveniți de la funcție Sigiliu() document foaie de calcul completat.

Return TabDoc;

În acest moment, etapa de programare este finalizată și crearea formularului de printare 1c este aproape finalizată. Textul complet al funcției Sigiliu() Nu îl voi da aici, îl puteți privi în fișierul imprimabil, pe care îl puteți descărca în partea de jos a articolului.

Crearea unui formular tipărit 1C. Opțiuni de înregistrare automată

Când conectați un formular de tipărire extern la baza de date, sistemul nu stabilește automat pentru ce document sau carte de referință este destinat formularul de tipărire, trebuie să îl selectați manual; Și dacă o altă persoană a scris formularul tipărit și ești însărcinat doar să-l conectezi, atunci alegerea poate deveni ambiguă. Pentru a evita astfel de probleme, în toate formele tipărite externe este necesar să se creeze un layout cu parametrii de auto-înregistrare. Dacă este creat și formatat corect, sistemul stabilește automat pentru ce document sau carte de referință este destinat formularul tipărit.

Se face astfel:

În procesarea externă, creăm un nou aspect. Îl numim „Setări_Înregistrare automată” (este important să nu greșești!).
În prima celulă a aspectului scriem Documentație.(sau Directoare.) și numele documentului la care trebuie să conectați formularul tipărit.

Conectarea unui formular de imprimare extern la bază

Porniți 1C 8 în modul Companie;
Accesați meniu Service -> Rapoarte suplimentare și procesare -> Formulare suplimentare tipărite externe;
Faceți clic pe butonul Adăuga;
În fereastra care se deschide, faceți clic pe pictograma Înlocuiți fișierul de procesare extern;
Dacă ați creat parametri de auto-înregistrare, atunci suntem de acord să-i folosim;
Dacă nu ați creat parametri de auto-înregistrare, atunci în partea tabelară Accesoriu placă de imprimare adăugați documentul solicitat sau cartea de referință;
apasa butonul BINE.

După aceasta, formularul de tipărire externă va fi disponibil în meniu Sigiliu document Recepția de bunuri și servicii. Crearea formularului tipărit 1C poate fi considerată acum finalizată.

Să ne gândim să scriem cea mai simplă formă tipărită în 1s 8,1 - 8,2 folosind exemplu de configurare Contabilitatea întreprinderii 2.0. Să presupunem că trebuie să scrieți un formular tipărit extern pentru un document: afișați datele de bază ale documentului, precum și din partea tabelară Bunuri: nomenclatură, preț, cantitate și cantitate.

Puteți descărca exemplul rezultat din .

În configurator 1C Întreprinderi 8 creați procesare externă ( Fișier->Nou->Procesare externă), setați numele, creați detaliile necesare pentru formularul tipărit extern Referință la obiect cu tip DocumentLink Vânzări de bunuri și servicii.

Crearea unui aspect de formular tipărit

Adăugați unul nou aspect, lăsați tipul de aspect document foaie de calcul. Creăm trei zone pe aspect: Antet, dateȘi subsol. Acest lucru se poate face selectând numărul necesar de linii și făcând clic pe meniu Tabel->Nume->Atribuiți nume (Ctrl+Shift+N).

După aceasta, începem să plasăm text și parametri în zone. O vom pune în antet numele formularului tipărit, numărul documentuluiȘi organizare, și, de asemenea, desenați marginile antetului tabelului și scrieți numele coloanelor. Când creați un parametru în proprietățile celulei, în fila Layout ar trebui să setați proprietatea Umplereîn sens Parametru.

În zonă Date haideți să creăm parametri pentru afișarea rândurilor în secțiunea tabelară( Nomenclatură, preț etc.), iar în zonă subsol pentru totaluri după cantitate și sumă.

Programare

Să mergem la modulul obiect formular de tipărire Acțiuni->Deschide modul obiect.

Să creăm acolo o funcție de export care este obligatorie pentru formularele tipărite. Sigiliu().

Funcția Print () Export EndFunction

În funcție vom crea o variabilă pentru document foaie de calcul, în care va fi scos forma tipărită, obținem aspectȘi zonele de amenajare.

TabDoc = nou TabularDocument; Layout = GetLayout("Layout"); HeaderArea = Layout.GetArea("Header" ); AreaData = Layout.GetArea("Date" ); AreaFooter = Layout.GetArea("Footer" );

Să completăm parametrii pălăriiși adu-l la document foaie de calcul.

HeaderArea.Parameters.HeaderText = +LinkToObject.Number; HeaderArea.Parameters.Organization = LinkToObject.Organization; TabDoc.Output(HeaderArea);

Pentru a obține rânduri de tabel Bunuri folosim cererea.

Trecem detaliile la parametrul de solicitare Referință la obiect, pentru a indica în stare UNDE, că avem nevoie de date doar din documentul din care derivăm formularul tipărit. Pentru a obține un exemplu de interogare, o executăm mai întâi și apoi selectăm rândurile.

Selectare = Query.Run().Select();

În continuare, în buclă completăm parametrii zonei Date pentru fiecare linie de selecție a documentului și afișați-le în document foaie de calcul. De asemenea, calculăm valorile totale în buclă cantitățiȘi sume. Nu vom completa fiecare parametru separat, ci vom folosi procedura CompletațiPropertyValues((<Приемник>, <Источник>) din context global, copiază valorile proprietăților <Источника> la proprietăți <Приемника> . Potrivirea se face după numele proprietăților. Puteți citi mai multe despre asta în asistent de sintaxă 1C Enterprise 8.

Suma totală = 0; TotalQuantity = 0 ; While Selection.Next() Loop FillPropertyValues(AreaData.Parameters,Selection); TotalSum = TotalSum + Sample.Sum; TotalQuantity = TotalQuantity + Sample.Quantity; TabDoc.Output(AreaData); EndCycle ;

Umpleți și afișați zona subsol.

AreaFooter.Parameters.TotalQuantity = TotalQuantity; AreaFooter.Parameters.TotalSum = TotalSum; TabDoc.Output(AreaFooter);

Întoarcerea documentului de foaie de calcul completat din funcție Sigiliu().

returnează TabDoc;

Dacă utilizați una dintre configurațiile standard, atunci după returnarea documentului foaie de calcul 1C va afișa formularul tipărit pe ecran. Puteți utiliza, de asemenea, metoda documentului tabelar pentru ieșire. Spectacol().

5. Conectarea unui formular tipărit la un document

ÎN configurații standard 1C 8 Există un director pentru înregistrarea formularelor tipărite externe Procesare externă. Pentru a vă conecta, accesați meniul în modul întreprindere Service->Rapoarte și procesare suplimentare->Formulare suplimentare tipărite externe.

Adăugați un nou element de director, încărcați formularul tipărit de pe disc și selectați tipul de document.

Acum în document Vânzări de bunuri și servicii Va apărea un nou tipăribil.

Înregistrarea automată a formularului tipărit

Pentru a vă asigura că atunci când conectați un formular de tipărire nu trebuie să selectați manual tipul de document, puteți configura auto-înregistrare. Pentru a face acest lucru, adăugați un aspect nou și apelați-l Setări_Înregistrare automată(asta este singura cale) și în prima ei celulă scriem Documentație.<Наименование документа> (sau Directoare.<Наименование справочника> ).

Acum, când conectăm un formular de tipărire, ni se va cere să folosim parametrii de auto-înregistrare.

Toată lumea a văzut de mai multe ori cum, în configurațiile tipice construite pe baza BSP (Library of Standard Subsystems), formularele tipărite construite pe baza unui document Spreadsheet sunt scoase într-un formular special „Print Documents”. Acest formular face parte din subsistemul „Print” din BSP. Atunci când dezvoltați propriile formulare tipărite, uneori este necesar să solicitați utilizatorului date suplimentare necesare pentru tipărire. Aici apare întrebarea cum să afișați în acest caz formularul tipărit în formularul „Tipărește document”. În acest articol, voi vedea cum să implementez ieșirea unui formular tipărit în formularul menționat din subsistemul „Print”, dacă dorim să solicităm date suplimentare de la utilizator înainte de a scoate formularul tipărit. Două cazuri vor fi luate în considerare aici: atunci când un formular tipărit este implementat folosind subsistemul „Rapoarte suplimentare și procesare” și când un formular tipărit este adăugat la configurație în modul configurator, de exemplu. se fac modificări la configurația standard.

Formularul „PrintDocuments” oferă câteva funcții suplimentare atunci când lucrați cu formulare tipărite, cum ar fi:

butonul pentru a imprima la o imprimantă, direct în formular;
indicarea numărului de exemplare, formă tipărită;
editarea formularului tipărit generat;
posibilitatea de a salva un formular tipărit în diverse formate de date (Excel, Word, PDF etc.);
trimiterea unui formular tipărit prin e-mail;
Lucru convenabil cu un set de documente.

Acest formular este acum folosit de 1C în toate configurațiile standard pentru a afișa formulare tipărite ale documentelor și elemente de director. Și, desigur, atunci când ne dezvoltăm propriile formulare tipărite, pentru a nu depăși practica acceptată, ar trebui să ne afișam și formularele tipărite folosind instrumentele furnizate.

Când folosiți metode standard pentru adăugarea formularelor tipărite, subsistemul „Print” va face totul pentru noi și va afișa formularul tipărit după cum este necesar. De exemplu:

La adăugarea unei comenzi de imprimare la un document utilizând subsistemul „Imprimare”, trebuie să descriem comanda de imprimare în procedura Adăugare comenzi de imprimare, indicând managerul de imprimare în care este implementată procedura de imprimare;
La crearea procesării suplimentare, trebuie, în modulul obiect de procesare din funcția InformationOnExternalProcessing, să descriem o comandă cu tipul de utilizare Apelul unei metode de server și să implementăm imediat procedura Print, care într-un anumit fel implementează apelul pentru a genera un tipărit. formă.

În astfel de cazuri, așa cum am spus deja, subsistemul de imprimare va scoate formularul tipărit pe care l-am generat singur, după cum este necesar. Astfel de metode implică formarea directă a unei forme de imprimare, adică. a trecut obiectele de tipărit la procedura de imprimare, a generat un document foaie de calcul și l-a afișat pe ecran.

Ce se întâmplă dacă, înainte de a începe să generați un document de foaie de calcul, trebuie să solicitați câteva date de la utilizator? Acestea. trebuie să arătăm formularul. În acest caz, ordinea standard de formare a unui formular tipărit este încălcată și trebuie să ne gândim cum să ne transferăm formularul tipărit în formularul „Tipărește documentele”.

În acest caz, sunt posibile două situații:

Când o placă de imprimare este creată cu o modificare a configurației;
Atunci când un formular tipărit este creat fără modificarea configurației, de ex. Se utilizează subsistemul „Rapoarte și procesări suplimentare”.

Creăm un formular tipărit adăugându-l prin configurator.

Prima variație. Prin crearea de procesare cu echipa.

Această opțiune implică adăugarea procesării direct la obiectele metadate:

Să luăm în considerare opțiunea când trebuie să implementăm o formă tipărită a unui anumit obiect, de exemplu, un element de director. Pentru a face acest lucru, trebuie să lucrăm în patru zone de procesare:

Creați o comandă care va apela formularul nostru imprimabil;
Creați formularul în sine;
Creați un aspect al unui formular tipărit;
Efectuați modificări în modulul manager de procesare.

Crearea unei echipe

Specificați în proprietățile comenzii:

Grupul în care dorim ca echipa să fie afișată în formular;
Tipul de parametru este exact cartea de referință sau documentul a cărui formă tipărită o facem;
Modul de utilizare a parametrului este Multiplu. Astfel încât să puteți afișa simultan formulare tipărite pentru mai multe elemente selectate în listă.

În modulul de comandă, deschidem formularul de procesare, trecându-i elementele de director selectate pentru care este necesar să generăm formulare tipărite. Să nu împărțim firele de păr aici și să corectăm ușor codul standard pe care platforma îl inserează în procedura de procesare a comenzilor:

&Pe Procedura de procesare a comenzilor Client (Parametrul comenzii, Parametrii de execuție a comenzii) //Inserați conținutul handler-ului. FormParameters = Structură nouă ("DataForPrint", CommandParameters); OpenForm("Processing.PrintForm.Form",FormParameters,CommandExecutionParameters.Source,CommandExecutionParameters.Uniqueness,CommandExecutionParameters.Window,CommandExecutionParameters.NavigationLink); EndProcedure

Parametrul de procedură Command Parameter conține exact elementele pe care le-am selectat pentru imprimare.

Crearea unui formular

Să adăugăm un formular la procesare, să creăm un atribut de formular de tip Listă de valori și detaliile necesare pentru ca noi să introducem parametri suplimentari pentru formularul tipărit:

DataForPrint - tip ListValues;

Număr de rânduri - tip Număr.

Exemplul meu va fi pur demonstrativ, așa că să determinăm condiționat că scopul meu este să tipărim reprezentarea elementului selectat și numărul de linii pe care le selectăm ca parametru suplimentar pe formular.

Accesați modulul formular și scrieți următorul cod:

&OnServerProcedureWhenCreatingOnServer(Eşec, StandardProcessing)PrintData.LoadValues(Parameters.PrintData); Sfârșitul procedurii &Pe Procedura Client Print (Comandă) Print ManagementClient.ExecutePrintCommand("Processing.PrintForm", //Print Manager "PrintForm", //Identifier GetObjectsForPrint(), //PrintObjectsThisObject, //Proprietar formularul - formularul din care print se numește GetPrintParameters()); //Parametri de tipărire - parametri arbitrari pentru transferul către managerul de imprimare Sfârșitul procedurii &Pe Server Funcția GetObjectsForPrint() Array = DataForPrint.UploadValues(); Return Array; EndFunction &OnServer Funcție GetPrintParameters()PrintParameters = Structură nouă; Print Options.Insert("Titlul formularului", "Tipărirea formularului"); //Unul dintre parametrii pentru formularul „Tipărește document”. //Specifică titlul formularului de ieșire imprimabil. //Aici adăugăm parametrii noștri, pe care dorim să îi transferăm suplimentar în managerul de imprimare. PrintOptions.Insert("Număr de rânduri", Număr de rânduri); ReturnPrintOptions; EndFunction

Definim procedura WhenCreatingOnServer și în ea citim din parametrul pe care l-am transmis de la comandă la deschiderea formularului, lista de obiecte pentru care trebuie să generăm un formular tipărit.

Creăm o comandă Print în formular și scriem handlerul acesteia, în care numim funcția modulului general ManagePrintClient.ExecutePrintCommand, setați parametrii necesari acestei funcție și anume:

Print Manager - numele obiectului din modulul manager, care este definit de funcția Print, care formează formularul nostru tipărit;
Identificator - identificatorul formularului de tipărire care trebuie tipărit. Folosind acest identificator, vom selecta în funcția de imprimare a modulului manager ce formular de tipărire trebuie tipărit;
Obiectele de tipărire sunt direct acele obiecte pentru care sunt generate formulare de tipărire;
Proprietarul formularului;
Parametri de imprimare - aici creăm și trecem o structură cu parametrii de printare, aici trecem parametrii noștri suplimentari pe care i-am solicitat utilizatorului în formularul de procesare.

De fapt, apelând funcția ExecutePrintCommand din formularul de procesare, ne rezolvăm problema de ieșire a formularului tipărit în formularul „PrintDocuments”. Apoi subsistemul „Print” va efectua acțiuni standard și va aduce execuția la procedura Print, pe care trebuie să o definim în modulul manager al procesării noastre.

Crearea unui aspect de formular tipărit

Efectuarea de modificări la modulul manager de procesare

Din acest moment, desfășurăm acțiuni standard pentru dezvoltarea formularelor tipărite folosind subsistemul „Print” din BSP.

Adăugați următorul cod la modulul manager:

Procedură Imprimare (Matrice de obiecte, Opțiuni de imprimare, Colecție de formulare de tipărire, Obiecte de imprimare, Opțiuni de ieșire) Exportați dacă trebuie să imprimați controlul (Colecție de formulare de tipărire, „Formular de tipărire”) Apoi controlați Imprimarea documentului în colecție (Colecție de formulare de tipărire, formular „Print Form”, NStr(“ru = „Print form””), PrintLayout( Array of Objects, Print Parameters), „Processing.PrintForm.PF_MXL_PrintForm”,); endIf; Sfârșitul procedurii &Pe server Funcția PrintLayout(Object Array, Print Options) TabularDocument = New TabularDocument; //Creează un document de foaie de calcul ///////////////////////////////////////////// //////////////////////////////////////////////////////////////////// /////////////// // PARTEA SUPLĂSATĂ A MODULULUI // //Aici creăm formularul nostru tipărit Layout = GetLayout("PF_MXL_PrintForm"); Pentru fiecare obiect din matrice de obiecte Loop AreaHeader = Layout.GetArea("Header"); RegionObject = Layout.GetArea("Obiect"); TabularDocument.Output(HeaderArea); AreaObject.Parameters["Object"] = Obiect; TabularDocument.Output(AreaObject); Pentru cont = 1 ByPrint Options["Număr de rânduri"] Ciclu AreaLine = Layout.GetArea("Line"); AreaString.Parameters["String"] = Număr; TabularDocument.Output(AreaString); EndCycle; TabularDocument.OutputHorizontalPageSeparator(); EndCycle; //PARTE SUPRADEFINITĂ A MODULULUI ////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////// ///////////////// Returnează TabularDocument; //Return documentul de tabel End of Function

A doua varianta. Prin implementarea comenzii print.

Această opțiune este foarte asemănătoare cu prima în ceea ce privește implementarea tipăririi. Diferența sa este în modul de a crea o comandă care va fi afișată în interfață și va începe imprimarea noastră.

În acest caz, atunci când definim o comandă de imprimare, folosim și subsistemul „Print” din BSP. În loc să definim o comandă pentru deschiderea procesării în procesarea în sine, trebuie să mergem la modulul manager al obiectului la care dorim să adăugăm un formular de imprimare și să specificăm o descriere a comenzii de imprimare în procedură. AddPrintCommands(PrintCommands):

Procedura AddPrintCommands(PrintCommands) ExportPrintCommand = PrintCommands.Add(); PrintCommand.Identifier = "PrintForm"; PrintCommand.View = NStr("ru = "Tipărește un formular tipărit""); PrintCommand.Handler = "GeneralModulePrintForm.ProcessingPrintFormCommand"; PrintCommand.Order = 100; EndProcedure

Aici adăugăm o comandă de tipărire numită „Print printed form” la toate formularele de director (vă reamintesc că lucrăm cu directorul contrapărților). Și aici este punctul principal care trebuie luat în considerare. Puteți adăuga două tipuri de comenzi în formular:

1. Apelarea procedurii Print din modulul manager;

2. Apelarea unei metode client.

Este exact ceea ce trebuie să numim metoda client. Metoda client ne va permite să apelăm un formular de procesare în care vom solicita de la utilizator datele de care avem nevoie înainte de a tipări.

Pentru a implementa un astfel de apel, este necesar să specificați un Handler pentru acesta atunci când definiți o comandă (vezi codul de mai sus). Un șir de caractere care conține calea către funcția client este transmis manevrului de comandă, de exemplu. calea către funcția Export a modulului comun de pe client. Această funcție va fi apelată atunci când faceți clic pe comanda de imprimare pe care o adăugăm în formulare.

După cum înțelegeți, pentru ca acest lucru să funcționeze, trebuie să creați acest modul general și să definiți funcția Export. Prin urmare, scriem următorul cod în modulul nostru general:

Funcție ProcessingPrintCommandPrintForm(PrintParameters) Export //Inserați conținutul handler-ului. FormParameters = New Structure("DataForPrint", PrintParameters.PrintObjects); OpenForm("Processing.PrintForm.Form", FormParameters); EndFunction

Aici facem același lucru ca și în prima implementare, deschidem formularul de tipărire, doar că acum Datele noastre de imprimare vor fi conținute în parametrul trecut la funcția Parametrii de imprimare, sau mai degrabă în câmpul lui Print Objects.

După ce deschidem formularul de procesare, toate acțiunile sunt similare cu prima opțiune.

Implementarea acestei optiuni se regaseste in configuratii standard, in mecanisme asociate tiparirii consimtamantului la prelucrarea datelor cu caracter personal.

Creăm procesări suplimentare.

Ce se întâmplă dacă aceasta nu este configurația noastră și este acceptată? Și, în general, nu vrem să intrăm în configurație și să o edităm?

În acest caz, trebuie să folosim subsistemul „Rapoarte și procesare suplimentare” din BSP.

Cu această soluție, trebuie să scriem cod în doar două locuri și toate acestea sunt în procesarea noastră suplimentară viitoare:

1. Modul obiect procesare;

2. Modulul formular de procesare.

În modulul obiect scriem următorul cod:

//////////////////////////////////////////////////////////////////// ////////////////////////// // INTERFAȚA PROGRAMULUI Zona #ProgramInterface // Returnează informații despre procesarea externă. Funcție InformationOnExternalProcessing() ExportRegistrationParameters = AdditionalReportsAndProcessing.InformationOnExternalProcessing("2.2.2.1"); Înregistrare Parameters.View = AdditionalReportsAndProcessingClientServer.ProcessingViewPrintedForm(); Parametri de înregistrare.Versiune = "1.0"; NewCommand = Înregistrare Parameters.Commands.Add(); NewCommand.Presentation = NStr("ru = "Formular tipărit extern cu cererea de date preliminare""); NewCommand.Identifier = "ExternalPrintForm"; NewCommand.Use = AdditionalReportsAndProcessingClientServer.CommandTypeOpenForm(); NewCommand.ShowAlert = Adevărat; NewCommand.Modifier = "PrintMXL"; ReturnRegistrationParameters; Procedura EndFunctions Imprimare (Date de tipărire, Colecție de formulare, Obiecte de tipărire, Parametri de ieșire) Export dacă PrintControl.NeedPrintLayout(PrintFormsCollection, "ExternalPrintForm") Apoi PrintManage.OutputTabularDocumentIntoCollection(PrintFormsCollection, "StringFormsCollection, "Stram(ExternalForma"), "Str. "), PrintLayout(PrintData ),); endIf; Sfârșitul procedurii &Pe server Funcția PrintLayout(PrintData)PrintParameters = PrintData.Value; //Primește parametrii de tipărire de la primul element din Value List Object Array = PrintData.Copy(); //Copiați lista de valori ArrayObjects.Delete(0); //Șterge liniile elementului copiat care conține Opțiuni de imprimare TabularDocument = New TabularDocument; //Creează un document de foaie de calcul ///////////////////////////////////////////// //////////////////////////////////////////////////////////////////// /////////////// // PARTEA SUPLĂSATĂ A MODULULUI // //Aici creăm formularul nostru tipărit Layout = GetLayout("Layout"); Pentru fiecare obiect din matrice de obiecte Loop AreaHeader = Layout.GetArea("Header"); RegionObject = Layout.GetArea("Obiect"); TabularDocument.Output(HeaderArea); AreaObject.Parameters["Object"] = Obiect; TabularDocument.Output(AreaObject); Pentru cont = 1 ByPrint Options["Număr de rânduri"] Ciclu AreaLine = Layout.GetArea("Line"); AreaString.Parameters["String"] = Număr; TabularDocument.Output(AreaString); EndCycle; TabularDocument.OutputHorizontalPageSeparator(); EndCycle; //PARTE SUPRADEFINITĂ A MODULULUI /////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////// ///////////////// Returnează TabularDocument; //Return foaia de calcul EndFunction #EndArea

Există două funcții și o procedură.

Funcția standard pentru procesarea suplimentară este InformationOnExternalProcessing(); fără aceasta, sistemul nu va înțelege că aceasta este o procesare suplimentară. Punctul important aici este de a indica faptul că comanda implementată în această prelucrare este de tip Deschiderea unui formular. Acestea. vom deschide formularul după cum avem nevoie. Urmează definirea procedurii Print și a funcției care generează direct documentul nostru de calcul.

Aici trebuie să acordați atenție faptului că comanda de imprimare în acest caz ar trebui să conțină doar 4 parametri, și nu 5, așa cum este cazul definiției obișnuite a comenzii de imprimare din modulul manager. În acest caz, nu există niciun parametru pentru transmiterea Setărilor de imprimare. Prin urmare, va trebui să fim creativi pentru a transmite nu doar obiectele în sine pentru care este generat formularul tipărit, ci și parametrii pe care îi solicităm utilizatorului în formular.

Și așa am definit procesarea suplimentară, comanda din care se va deschide formularul de procesare. Prin urmare, următorul pas este crearea unui formular de procesare.

În acest formular, trebuie să creăm trei detalii pentru a stoca valorile de care vom avea nevoie mai târziu. Să numim aceste detalii după cum urmează:

ID comandă - tastați șir

ObjectsAssignments - tip List of Values

În modulul acestui formular scriem următorul cod:

&Despre procedura de server Când este creată pe server (Eșec, Procesare standard) //La crearea pe server, amintiți-vă parametrii standard trecuți de subsistemul AdditionalReportsAndProcessing AdditionalProcessingLink = Parameters.AdditionalProcessingLink; CommandIdentifier = Parameters.CommandIdentifier; Destination Objects.LoadValues(Parameters.Destination Objects); EndProcedure &OnClient Procedure Print(Comandă) // Obține cheia de unicitate a formularului care se deschide. UniqueKey = String(New UniqueIdentifier); //Definirea și completarea parametrilor standard pentru formularul general Print DocumentsOpening Parameters = New Structure("DataSource, SourceParameters"); OpeningParameters.DataSource = AdditionalProcessingLink; OpeningParameters.SourceParameters = New Structure("CommandIdentifier, DestinationObjects"); OpeningParameters.SourceParameters.CommandIdentifier = CommandIdentifier; //Obiectele de tipărit și parametrii introduși în formular vor fi procesați //vom trece prin parametrul Source Parameters.Destination ObjectsOpening Parameters.Source Parameters.Destination Objects = GetDestination ObjectsAndPrint Parameters(); OpenForm("GeneralForm.PrintDocuments", OpeningParameters,FormOwner,UniqueKey); Sfârșitul procedurii &Pe funcția de server GetDestinationObjectsAndPrintParameters()PrintData = DestinationObjects.Copy(); //////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// //////// // PARTEA SUPRASCRITĂ A MODULULUI // //Aici creăm structura Print Parameters și o completăm cu parametrii //care trebuie să fie trecuți la funcția de tipărire Print Parameters = New Structure; PrintOptions.Insert("Număr de rânduri", Număr de rânduri); PrintData.Insert(0, PrintOptions); //PARTE SUPRADEFINITĂ A MODULULUI /////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////// ///////////////// ReturnPrintData; EndFunction

În procedura When CreateOnServer, completăm cele trei detalii pe care le-am creat pentru a stoca parametrii trecuți în formularul de procesare.

În continuare, definim un handler pentru butonul de imprimare de pe formular. În acest handler, trebuie să deschidem noi înșine formularul „Print Documents” pentru aceasta, trebuie să pregătim parametrii de deschidere ai unei anumite structuri. În această structură, trebuie definite cel puțin două câmpuri:

Parametrii sursă, care includ identificatorul de comandă și obiectele de destinație:

ID comandă - salvat și atunci când este creat pe server, acesta este identificatorul comenzii care a numit formularul nostru de procesare. Prin urmare, folosind identificatorul, vom determina ce trebuie să imprimăm în procedura Print din modulul obiect.

Obiecte de atribuire - tocmai în acest câmp trebuie să trecem o matrice de obiecte pentru care este generat formularul tipărit, precum și parametrii solicitați utilizatorului în formular.

Modul în care definesc obiectele destinație poate fi văzut în funcție GetObjectsDestinationsAndPrintOptions. Aici copiem obiectele noastre de destinație din elementele de recuzită a formularului, în locul elementului de matrice cu index 0, lipim parametrii noștri de imprimare.

În viitor, matricea definită în acest fel va fi transferată din formularul „Print Documents” ca prim parametru al procedurii Print object module, pe care am definit-o mai devreme.

Dacă revenim la definiția modulului obiect de procesare și ne uităm la funcția PrintLayout, în primele trei rânduri ale funcției puteți vedea cum extrag parametrii și obiectele noastre din datele transferate în procedura Print și apoi lucrez cu ele.

Astfel de manipulări cu parametrul Obiecte de atribuire sunt determinate de specificul apelării procedurii modulului obiect Print. Puteți urmări personal modul în care parametrii sunt transferați și cum sunt efectuate apelurile de funcții prin deschiderea modulului de formular Document Printing.

Rezultat.

Ca urmare a unor astfel de manipulări, vom primi trei comenzi pe formularul din care dorim să afișăm formularul tipărit:

Numerotarea comenzilor corespunde ordinii opțiunilor de implementare.

Toate aceste comenzi vor face același lucru:

Afișați formularul de solicitare a parametrilor suplimentari

Ieșiți formularele tipărite generate în formularul „Tipărește documente”.. Exact ce ne-am dorit:

P.S. Ca șabloane, pentru a implementa propriile mele formulare tipărite cu o solicitare de parametri suplimentari, încarc ambele procese care sunt implicate în toate cele trei metode de generare a unui formular tipărit.