home Computer

1s 8 creation of an external printing form. Publications

21.06.2023

Instructions

Open the 1C:Enterprise program version 8. Pay attention to the menu item “Service” - “External processing and printing forms”. With its help, you can store external reports, processing, printed forms, as well as processing for filling tabular elements. You can also connect an external form instead of changing an existing one, which would entail interfering with the program configuration.

Launch the 1C:Enterprise program in configurator mode, then create external processing, to do this, execute the command “File” - “New”. In the window that appears, select “External Processing”. A new external processing form will appear on the screen. Give it the name “External”. Then add a new attribute called “Object reference”, specify the type for it – “Document. Link. Sales of goods and services." To create a printable for a different type of document, use the appropriate link type.

Add a new layout by clicking on the corresponding button in the new form window. Name it “Layout”, create an area called “Header”, give it the parameter “Header Text”. Then click on the “Actions” button, select the “Open object module” command. Then insert the module text, you can use the example posted on the website http://www.uasoft.com.ua/content/articles/315/.

Launch the 1C:Enterprise program, go to the Tools menu, select External Printing Forms. Add a new entry to the list of forms. To do this, select the created processing file, and in the tabular section, indicate that the form belongs to the “Sales of goods” document. Check that the new printing plate is working correctly. To do this, open the created document, trace it, then at the bottom of the screen click on the “Print” button, select the “External printing form” option.

Sources:

  • how to change a printed form in 1c

In order to create and edit object forms, the 1C:Enterprise program provides a special form editor (or Form Designer). Application solution object forms are designed to visually represent data while working with the program. The form editor contains several tabs that provide the ability to edit all form elements.

You will need

  • computer, 1C program

Instructions

Using the form editor, you can add one or more “Group – Pages” elements to the form; to do this, click on the green plus sign in the upper left corner of the editor while on the “Elements” tab.
In 1C:Enterprise mode, all existing group elements will be displayed each on a separate tab. To position it above or below the working one, in the “Properties” window of a particular group, in the “Display” item, select the appropriate command.

You can also add elements to the form by dragging the required details into the element tree. To make it easier to navigate form controls when editing or entering data, set the order that suits you, arranging elements in the tree and subordinating them to other elements, and setting the properties of group elements to suit your needs.
To edit form details - change them, create new ones or delete them, use the panel in the details tree area on the corresponding tab.

To edit the command interface, go to the appropriate tab. You will see a command tree, the main branches of which are the “Navigation Panel” and the “Command Panel”. Some commands are added to the command interface tree automatically, but you can also add them yourself by dragging the commands you need from the list of global (general) commands or from the list of form commands.

Form commands are edited in the corresponding list. You can add them, remove them from the list, set properties for each command using the properties palette, which you can call by clicking on the pencil icon in the command line of the list.
To edit form parameters, go to the “Parameters” tab, where you can also add them, delete them, and set the desired properties.

Video on the topic

The chart of accounts, used in accounting to display the economic activities of an enterprise, supports a multi-level hierarchy: account - subaccounts. So that the user can view the data contained in the chart of accounts and correct them, the 1C system allows you to change the form of the account. In addition, the printed form of the invoice can be changed in any other document in 1C.

You will need

  • - personal computer with 1C.

Instructions

Analytical accounting is provided for each account or subaccount. Therefore, when creating and subsequently editing a chart of accounts in 1C, the required number of sub-accounts, that is, analytical accounting objects, can be supplied. Moreover, adjustments to accounts and subaccounts can be made either by a user working with an automated accounting system or by a software developer.

How to add (register) an external printed form (or processing) in 1C Accounting 8.3 (revision 3.0)

2019-05-15T13:40:54+00:00

Often an accountant needs an additional printed form for one of the standard documents 1C: Accounting 8.3 (revision 3.0). Or additional processing is needed, for example, to automatically fill out a document or enter a new one based on it. Usually someone has already developed such a feature and it can be found or ordered from a programmer. And now the revision has been received, all that remains is to add it to the accounting department. How to do it? More on this below, step by step.

1. Open 1C Accounting 3.0 and select the “Administration” -> “Print forms, reports and processing” section in the left panel:

2. Here, find and select “Additional reports and processing”, after checking the “Additional reports and processing” checkbox on the left:

3. Click the "Add from file..." button.

4. And select the file with external printing form or processing (epf extension).

5. In the new window, click the "Save and close" button.

6. Open the desired document and make sure that another printable form option appears in the print button or an item in the “Create based on” menu or a new button on the form toolbar. Ready!

Sincerely, Vladimir Milkin(teacher and developer).

Life goes on, legislation changes, the developer releases configuration updates and we again have a choice: install the update ourselves or again call the programmer to “install a new release”...

Let's get acquainted with the mechanism for changing printing forms without changing the configuration.


In the practice of every accountant using 1C, there has ever been a need to modify the configuration for themselves: some adjusted the accuracy of the price or amount in the invoice, some inserted a logo and adjusted the appearance of the invoice. Everything would be fine, but a great many such changes accumulate over time and when the time comes to update the release, a dilemma arises: either lose all the changes made, or call a programmer to transfer all the changes to the new release (of course for an additional fee). How to be? To somehow simplify updating configurations, the developers created a new mechanism: “External processing, printed forms, processing for filling out tabular parts.” Today we will look at only part of this mechanism - printing forms.


Any subject is best learned by example. Let's set ourselves the following task: add to the configuration the ability to print an invoice (document “Sales of goods and services”) with our company logo. In addition, it is necessary that in the header of the document the inscriptions "provider" And "buyer" were highlighted in bold and finally, it is necessary that at the bottom of the document there is a place for the signature of the security service that authorized the shipment.


Let us introduce two additional conditions:

  • The new printed form should replace the old form "Invoice"
  • The configuration cannot be changed, since we want to use auto-update of the configuration in the future

Well, what's the task? Seems too complicated? Well, the more complex it is, the more interesting it is, and the more you want to solve it. Then get to work.


We launch our database in Configurator mode. Open the configuration by selecting the command in the main menu "Configuration > Open Configuration". We will not change the configuration itself under any circumstances. We will use it as a prototype. We will do the main work here, but we will edit external processing. We create external processing with a command in the main menu "File > New". Selecting the type of document "External processing". For the first processing, let's set a name "Branded Invoice"


Important! The processing name must not contain spaces, just like variable names.


Now let's do a little "plagiarism". Let's copy the layout "Invoice" from document "Sales of Goods and Services". To do this, we will find it in the branch "Documentation" configuration tree. Expand this thread by clicking on the icon «+» and find the layout we need "Invoice"(it's in the thread "Layouts"). In order to copy this object, you need to select this layout in the tree and run the command "Edit > Copy"(the same action occurs with the combination CTRL+C). Now let's go to the processing we created, select a label in the tree "Layouts" and in the main menu select the item - "Edit > Paste" (CTRL+V). The result should look like Figure 1.


Now double-click to open the layout.

What is a "layout"

Let's say a few words about the purpose of the layout.

Layout- storage "building blocks", areas from which, like bricks, a tabular document is built, which we are accustomed to calling a printed form. Areas are defined using horizontal and vertical sections or their intersections. Our layout has only horizontal sections: “Header”, “Supplier”, “Buyer”, “Table Header”, “Row” (see Fig. 2). An area is a set of cells. As in MS Excel, cells can be merged, text and background colors, fonts, and so on can be changed. All cell settings can be viewed and changed in the cell properties window. You can call the settings window by right-clicking on the cell and selecting the context menu item "Properties"(the same result is achieved by the keyboard shortcut Alt+Enter).


A cell can contain one of three types of values:

  1. text– a value of this type will be printed in the same form;
  2. parameter– a cell of this type contains the name of a variable whose value will be printed.
  3. sample– cells of this type are a combination of the first and second options. The cell can contain text and variables. In order for a program to distinguish text from a variable, variables must be enclosed in square brackets: "Today is [Date]".

Important! The table editor displays the values ​​of cells of the second and third types in triangular brackets. In Figure 2 there is a cell with text "Buyer"- looks like text, and to the right of the cell "Buyer's Presentation"- parameter.

Why am I telling all this? Now you know in which cells you can easily change the contents, and in which it is undesirable to change anything, since you will need to make changes to the printing algorithm.

Let us now return to our task. We created the processing, copied the layout and are ready to modify it to suit ourselves. First, let's take a closer look at it.

What's included in the printable layout

The layout structure of all documents is very similar. Having carefully examined one document, we can understand others. First section "Title". When this section is displayed, a document header will be generated, consisting of the type, date and document number. It is followed by sections "Supplier" and "Buyer", in which the program will display information about the supplier and buyer, respectively. Next is a more interesting section "Additional information", which developers use to display other information on the document, for example, information about the contract with its number and date. The peculiarity of this section is that it can be displayed many times, and each time it can contain different information. What exactly to print and when is described in the printing algorithm.

This completes the header of the document. The header is usually followed by a tabular section. Interestingly, the layout describes two options for displaying the tabular part: "Table Header", "String" and "HeaderTablePlaces" And "StringPlace". Depending on whether your column is filled or not "Mest" in the document, the first or second option for displaying the tabular part of the document will be used. The curious reader has probably already wondered: why in the header output section "Price" And "Sum" are placed in triangular brackets as if they were variables? That’s right – these are variables in which, depending on the document settings, the inscription will be displayed "Price", "Price with VAT" or "Price without VAT" and similarly for the amount.

Well, below in the layout there are sections with the help of which the results of the document and signature are displayed.

Editing the layout

It would be nice to place the logo above the information about the supplier and buyer. I suggest editing the layout area "Title". It is necessary to reduce the size of the cell containing the contents "TitleText". This cell consists of several merged cells. We change the size as follows:

  1. Let's carefully copy the contents of the merged cell "TitleText"(to do this, you need to select the cell and use the command “Edit > Copy” or keyboard shortcut CTRL+C)
  2. Having selected this cell, select the item in the main menu "Table - Merge", which will lead to the opposite effect - the merged cell will be split into many original cells
  3. Now let's select a smaller number of cells - instead of cell 2 of column, we will start merging from column 6, ending it at column 32 - and click on the button again "Merge"
  4. Team "Edit > Paste" (CTRL+V) insert the contents of the previous merged cell into the new merged cell
  5. We simply clear the freed cells in columns 2 – 5 (select them and press the Delete key)

Now you can insert a picture with a logo into the free space. To do this, select the item in the menu “Table > Pictures > Picture...”. Find the file with our logo on the disk and click “ OK" Now let's move the image to the free space. The result should look like in Figure 3.


Now let’s highlight the values ​​in the cells in bold "Provider" And "Buyer"(Fig. 4). To do this, find the parameter in the cell properties "Font" and set the style to bold.



And finally, it remains to add the signature of the security service. We will post this information in the section "Signatures". To get space for signatures you need to expand the section. Select line 37, right-click on it and select "Expand", and so on twice. In one of the added lines we will place a place for the signature of the security service. As a result, everything should look like in Figure 5.



Important! In a typical configuration, two languages ​​are used: Russian and Ukrainian. The layout stores the text representation in both languages ​​(the cell design is general). In order to enter the Ukrainian version of the inscription we added, you need to go to the cell properties and to the field "Text" press the button "search". A window will open for entering text representations in different languages ​​(Fig. 6).

How to ensure printing

So, the layout is ready. Now is the time to work on the algorithm for printing it.

In order for us to painlessly integrate this layout into the configuration and use it, the processing that we created must satisfy the following conditions:

  1. You need to create props in processing "Object Link" with type "AnyLink"
  2. You need to create a procedure in the processing module "Print() Export" without parameters and be sure to specify the keyword " Export"

The first point is needed so that the printing algorithm knows where to get the data for printing, and the second is the printing algorithm itself. Let's fulfill these conditions.

In the window panel, select the window for editing our processing (in Figure 7). A window will open with a tree of objects for our processing. Selecting a branch "Requisites" and press the button "Add",. The attribute properties window will open. Let's enter the name - "Object Link" and indicate the type "AnyLink". Now we can move on to the text of the print module. We won’t write it from scratch; instead, we’ll copy it from the document "Sales of Goods and Services".



To do this, find in the configuration tree among the documents "Sales of Goods and Services", right-click on it and select "Open object module"(see Figure 8).



This will open the document module. We need the first function "PrintDocument". Its text must be selected and copied. It is very convenient to highlight the text of a function when it is collapsed, but you must also highlight the line below it, otherwise you risk copying only the title.

See in Figure 9, we have highlighted the title and the line below it. After that, copy it to the clipboard. Main menu "Edit > Copy" (or CTRL+C).



We have memorized the text on the clipboard, now let’s move on to our processing again "Branded Invoice". Click on the button "Actions > Open Object Module"(Fig. 10).



Paste the copied text: "Edit > Paste" (or CTRL+V).

Now it is necessary to slightly edit the copied text, since it was written for printing a document from the document itself, and we are collecting it from external processing. To do this you need:

  1. Rename function to "Print"
  2. Replace "ThisObject" on "Object Link"
  3. Replace "ThisObject" on "Object Link"
  4. Replace "Organization Bank Account" on “Link to Object.Organization Bank Account”
  5. Replace "Products. Summary" on "LinkToObject.Products.Total"

For these actions you can use the main menu item "Edit > Replace".

After this, you must check for syntax. There is a magic combination for this: CTRL+F7. As a result, the following message should appear: "No syntax errors found!"

Well, with this we have completed all the dirty work. Now we can save the results of our work in a file, for example "Branded Invoice.epf". To do this, you need to make the window for this processing active and save it using the main menu of the program "File > Save As...". Processing file name – "Branded Invoice.epf"(it will be offered by default). You can save it temporarily to your desktop so you can find it faster later.

Important! As you saw, we did not make any changes within our configuration. For all the actions described above, you don’t even need to remove it from support (that is, enable the ability to change).

Connecting external processing to the configuration

Now we can connect processing to our invoice. To do this, launch in mode. Go to the menu "Service", where there are three points related to the mechanism “External processing, printing forms, processing for filling out tabular parts”. In our case, we only need the item "External printing forms"(see Fig. 11).



This will open the directory "External processing", with selection by type "printed forms". It will store a list of all external printed forms, indicating which documents they are for and in what cases they need to be shown.



Important! The processing itself will be stored in the database along with other data, that is, after saving the processing inside the database, we will not need an external file.

We need to create a new element in the directory. Click Insert. Now let's look at the contents of the element. In the name we include a meaningful brief description of the essence of this form, for example, "Company invoice". Like any other directory, it also has a code. Let's leave it as default. The type attribute is filled in by default and cannot be edited – "Print form". And the last element of the header is a comment. Here, as usual, there is more detail about the purpose of the printing form. In addition to the header, the elements of this directory have two bookmarks. The second contains information about restricting access rights to this processing. This topic is beyond the scope of this article (we will talk about this and other settings of access rights without modifying the configuration in one of the upcoming issues).

Let's take a closer look at the first tab.

The tab contains four columns. Object representation– the type of document for which we would like to use our printing form,

Selection– a condition under which this printed form should be available. For example, we redesigned the printed form of the invoice and translated it into English. And we want for clients from the folder "European" instead of a standard printed form "Sales Invoice" A new form was printed in English. To do this, you can use the column "Selection". An example of such selection is shown in Figure 13.



But in our task no selections are needed.

Printable Form File– indicates the file from which to take the layout and printing procedure. In this cell you need to select the file we saved on the desktop.

Replaceable printing plate– if we want the printed form we created to replace one of the standard ones for this document, then we need to indicate which one needs to be replaced. If there is nothing to select, an additional printed form will appear.

In our case, we need to "Branded Invoice" was printed instead of the usual invoice. To do this, select in this field "Sales Invoice".

Now let's save this element. And open any invoice.

It should look like shown in Figure 14.



Well, this concludes the task that we set for ourselves at the beginning of the article. We believe that we were able to illustrate the possibilities that the use of the external processing mechanism opens up for the user.

To consolidate your skills, you can try to independently add to the configuration an additional printed form “To the warehouse” for the document “Receipt of goods and services”, which would repeat the usual invoice, but without prices and amounts, and would also contain fields for entering the accepted quantity.

Good afternoon.

Today I want to tell you how to create external printed forms for the “Salary and Personnel Management 3.0” configuration. As you know, ZUP 3.0 uses a library of standard subsystems, which means the processing structure looks completely different. When I first had to make a printed form for the BSP in managed forms (then it was UT 11), the first thing I did was go to the ITS disk in order to find detailed documentation there about what export procedures, what parameters should be processed and how it all works. Here ITS disappointed me a little, because... everything is told there about how the procedures should look in the document module, and in the external printed form the parameters of the “print” procedure are rearranged, so I had to look for information in other sources and tinker with the subsystem from the inside.

Well, let's begin. What we get at the end can be used as a template.

Step one- obvious. Let's create a new processing. Let's assign it an arbitrary name: "Print Sample".

Step two. Let's create a layout. Since we have a test example, I will create the simplest layout, without a single parameter.

Step three- The most interesting. Open the object module and start programming. According to the BSP, when registering an external processing, it (the processing) must indicate what it can do, what objects it is attached to, and what it is called. When asked what processing it can do, it should return a list of commands - this is a table of values. In our case, the processing can output one printed form, so there will be only one command. To generate a table of values, we will define a couple of procedures that will always be the same in all external printed forms:

//procedure that prepares the command table structure

Function GetTableCommand()

// Create an empty command table and columns in it
Commands = New ValueTable;

// What the description of the printed form will look like for the user
Commands.Columns.Add("View", NewTypeDescription("Row"));

// The name of our layout, so that we can distinguish the called command in print processing
Commands.Columns.Add("Identifier", New TypeDescription("String"));

// This sets how the processing command should be called
// Possible options:
// - OpeningForm - in this case, the identifier column should indicate the name of the form that the system will open
// - CallClientMethod - call the client export procedure from the processing form module
// - Call ServerMethod - call a server export procedure from the processing object module
Commands.Columns.Add("Usage", New TypeDescription("Row"));

// The next parameter specifies whether a notification should be shown when a processing job starts and ends. Doesn't make sense when opening the form
Commands.Columns.Add("ShowAlert", NewTypeDescription("Boolean"));

// For a printed form, it must contain the string PrintMXL
Commands.Columns.Add("Modifier", New TypeDescription("Row"));

Return Team;

EndFunction

//Creates a new row in the command table

Function AddCommand(CommandTable, View, Identifier, Usage, ShowAlert = False, Modifier = "")
NewCommand = CommandTable.Add();
New Team. View = View;
New Team. Identifier= Identifier;
New Team. Usage = Usage;
New Team. ShowAlert= ShowAlert;
New Team. Modifier= Modifier;
EndFunction

Function InformationOnExternalProcessing() Export
Registration Parameters = New Structure;
ArrayDestinations = New Array;
Array of Assignments.Add("Document.Hiring");
Registration Parameters.Insert("View", "PrintForm"); //maybe - Filling an Object, Additional Report, Creating Related Objects...
Registration Parameters.Insert("Destination", Array of Destination);
Registration Parameters.Insert("Name", "Hello World"); //name under which the processing will be registered in the directory of external processing
Registration Parameters.Insert("Version", "1.0");
Registration Parameters.Insert("SafeMode", TRUE);
Registration Parameters.Insert("Information", "SAMPLE");//this is what the description of the printable form will look like for the user
CommandTable = GetCommandTable();
AddCommand(CommandTable, "Hello World", "Layout", "CallServerMethod", True, "MXL Print");
Registration Parameters.Insert("Commands", CommandTable);
ReturnRegistrationParameters;
EndFunction

Actually, you will have to tinker with it every time you create a new external printing form. From the piece of code it is clear that we will link it to the “Hiring” document, accordingly you write your own. Our printed form will be called “Hello World”, again we’ll change it to our own. Here it would be convenient to write an obvious billboard in the template so that it catches the eye, so as not to forget to correct it later; in my opinion, “Hello world” comes in handy. The version is for yourself, write what you want, it will be displayed in the form of an element in the directory of external processing. The word "SAMPLE" is also visible only in the form of a directory of printed forms. Next, we add a command, here the second parameter is the name of the button, this is what the user will see in the document in the “print” menu item.

This set of three procedures is enough for the processing to be added to the directory of external processing; all this confusing code is service and has nothing to do with the printing algorithm. In fact, the authors of the BSP forced us to program in such a difficult way that if previously you immediately started writing the “Print” function, now when you write processing from scratch, and not according to a sample, you will waste time on the service. Previously, registration parameters were optional and were indicated in the processing layout, now everything looks much more serious. The first impression when I saw this was cool, so many possibilities, everything is unified... but in practice I always create just one command in one processing, and link it to one document. Those. in fact, I need two lines for registration: object name, button name. And here everything is so... well, oh well, it’s not for me to judge.

Step four- no less interesting.

PRINT function?

But no, now it’s not a function, but a procedure.

How can I get the layout back?

Send it to the global print subsystem module function.

Okay

Here is the text of this procedure:

Procedure Print(Array of Objects, Collection of PrintForms, PrintObjects, Output Parameters) Export
If PrintManagement.NeedPrintLayout(CollectionPrintForms, "Layout") Then
Print Management.Output TabularDocumentIntoCollection(CollectionofPrintForms,
"Layout", "Layout",
GenerateTabDocumentSample(Array of Objects, Print Objects));
endIf;
End of Procedure

Now for clarification. The first line of the procedure contains a slightly unclear condition. The fact is that when we call the print procedure, the system passes us a table of values, which indicates what we need to print. In essence, the function ManagePrint.NeedPrintLayout(...) checks for the presence in the table of values ​​of a row in which in the "Name" column there is a row with the name of the layout. In practice, in most cases the thing is useless, because... our processing will be able to generate only one printed form. Those. This condition can be omitted and it will not affect performance.

Next, Print Management. Output TabularDocumentIntoCollection(...) - this is what adds the tabular layout where it is needed, so that it can then be displayed on the screen. If you need to show your spreadsheet document in your own window (not in a standard one), then do not call this procedure, but simply write your code here.

I would also like to add that the Print procedure is performed on the client and, if necessary, you can open a free form here in order to ask the user for additional information necessary for printing.

Next, GenerateTabDocumentSample(...) is a function that we have to write in the processing module and which returns a tabular document. In 100 out of 100 cases it will be server-based, because... we need to get the value of the details from the objects listed in the "Object Array" parameter.

Step five- creating a layout.

Hurray, we'll finally get down to the layout algorithm, data retrieval, etc.

But in our sample we will act prosaically and I won’t even comment here)))

Function GenerateTabDocumentSample(Array of Objects, Print Objects)
tabDoc = New TabularDocument;
layout = GetLayout("Layout");

AreaHeader = Layout.GetArea("Header");
tabDoc.Output(areaHeader);

Return TabDoc;
EndFunction

That's all, thanks for your attention

External printed forms for a regular application (for the configuration Enterprise Accounting 2.0, Salary and Human Resources Management 2.5, Trade Management 10.3, etc.) are created quite simply compared to external printed forms for a managed application.

Why create external printing forms?

The advantage of an external printed form compared to a conventional one is that it allows you to avoid changing the configuration of the information base. This means that the process of subsequent configuration updates will not be complicated. In addition, external printed forms, along with external processing, are the only option for expanding the functionality of basic versions of 1C configurations, which cannot be changed at all.

And one last thing: external printed forms are easier to replicate, because they are a separate file that can be quickly connected to the infobase.

How to create an external printing form

Let's look at the process of creating an external 1C printed form step by step:

  1. We create external processing. To do this, select the menu item in the configurator File - New... And in the dialog box that opens - External processing.
  2. Create an external processing attribute with the name Object Reference. Attribute type is a link to a directory or document for which an external printed form is being created. The same form can be used for several types of objects, in this case the attribute data type Object Reference must be composite.
  3. In the object module we create an export function with the name Seal, which should return a ready-made printed spreadsheet document.

It often happens that you need to slightly adjust the layout of an existing printed form and make it external. For example, add the organization’s seal and the manager’s signature to the layout.

Creating an external printing form based on a standard one with minor changes

Let's consider this procedure using the example of creating an external printed form of a universal transfer document for a document Sales of goods and services 1C: Accounting. It will differ from the standard printed form by the presence of the organization's seal.

  1. Creating external processing with props Object Reference, data type - DocumentLink. Sales of Goods and Services.
  2. We find the layout of the standard UPD printed form (it is located in the general layouts) and copy (drag) it into the external processing window. Layouts of other printed forms may be located in the documents or reference books themselves.
  3. We make the necessary changes to the copied layout of the printed form.
  4. We find the function responsible for generating the printed form. This function should return the generated spreadsheet document. Copy its contents to the export function Seal() in the external processing object module.
    In our case this is the function PrintUniversalTransferDocument() Export from document object module Sales of goods and services.
    If the layout changes were significant (areas and/or parameters changed), then appropriate adjustments must be made to the print function.
  5. We are trying to save external processing. However, you will likely receive error messages that indicate that some of the procedures and functions called by the print function are missing. These functions and procedures must be found in the source document and also copied into the external processing object module. Or adjust the link if the original function or procedure is exported.
  6. (not necessary). To test an external printing form, it is convenient to make a form on which to place the props Object Reference. Button Execute must call a procedure Seal() from the object module. To do this, the button click event is given a procedure: