Abbiamo l'elaborazione con questa forma base:

Da questo modulo dobbiamo aprire qualche modulo aggiuntivo e il testo dal campo del modulo deve essere trasferito al modulo aperto. Il modulo aggiuntivo è il seguente:

Pertanto, quando si fa clic sul pulsante "Esegui", si apre un modulo aggiuntivo con il testo già inserito nel campo:

Consideriamo un modo per risolvere un problema del genere.

Soluzione

Per trasferire parametri tra moduli regolari, puoi utilizzare la variabile di esportazione globale del modulo del modulo o creare un attributo del modulo. Consideriamo entrambi i metodi per il nostro compito.

1. Utilizzando la variabile di esportazione globale del modulo del modulo.

Aggiungi il seguente codice al modulo principale per la procedura del gestore del pulsante "Esegui":

Procedura ButtonExecutePress(Button)Form = GetForm(" Modulo aggiuntivo" ) ; // "Testo" è una variabile di esportazione globale del modulo del modulo aperto Modulo. Testo = Elementi del modulo. Testo. Senso; Modulo. Aprire() ;

FineProcedura

La variabile text è stata aggiunta al modulo del modulo aperto insieme al gestore di eventi "BeforeOpen": Esportazione di testo variabile;// Variabile a cui viene passato il valore di un altro modulo

Procedura prima dell'apertura (errore, elaborazione standard) Elementi modulo. Testo trasmesso. Valore = Testo; FineProcedura

Il problema è risolto, e molto semplicemente!

2. Utilizzo degli oggetti di scena del modulo.

Per il secondo metodo, non abbiamo nemmeno bisogno di riscrivere i gestori dei pulsanti “Esegui” e “BeforeOpen”. Tutto ciò che serve è aggiungere l'attributo “Testo” con il tipo stringa al modulo aperto.

conclusioni

Nei moduli gestiti, il passaggio dei parametri è molto più semplice. Nelle forme convenzionali, nella maggior parte dei casi viene utilizzato l'approccio descritto. Puoi elaborare l'esempio dall'articolo.

scaricare dal collegamento

Per supportare l'interazione automatica tra i moduli, il sistema fornisce una serie di parametri standard utilizzati per controllare i moduli quando vengono aperti. Utilizzando questi parametri, il sistema implementa nei campi del modulo la selezione dai moduli di selezione, l'apertura dei moduli oggetto, il funzionamento dei comandi standard, ecc. Cioè forniscono vari scenari operativi dell'interfaccia integrati nel sistema. Ma lo sviluppatore può anche utilizzare questi parametri nel linguaggio integrato, passandoli quando chiama il metodo OpenForm().

• Elenchiamo i parametri forniti dal sistema e il loro scopo:– il modulo si apre in modalità di selezione. Fornito dall'estensione del modulo gestito con elenco dinamico.
• Riga corrente– una stringa che verrà attivata nella lista una volta aperta. Viene passato un valore che identifica la stringa. Fornito dall'estensione del modulo gestito con elenco dinamico.
• Selezione di gruppi ed elementi– questo parametro imposta la proprietà Selezione di gruppi ed elementi della tabella dell'attributo principale del modulo. Fornito dall'estensione del modulo gestito con elenco dinamico.
• ConsentiSelezionaRoot– definisce la possibilità di selezionare una radice in un modulo con un elenco dinamico visualizzato come un albero. Fornito da un'estensione del modulo gestito per un elenco dinamico visualizzato come albero.
• Selezione– selezione impostata in un elenco dinamico. Rappresenta una struttura. I nomi degli elementi corrispondono ai nomi dei campi con cui viene effettuata la selezione e i valori contengono i valori di selezione. Fornito dall'estensione del modulo gestito con elenco dinamico.
• Chiave– un valore che identifica l'oggetto in modifica nel modulo. Se il valore manca o non è corretto, viene creato un nuovo oggetto utilizzando i parametri rimanenti. Fornito dalle estensioni del modulo oggetto e dal gestore dei record del registro delle informazioni.
• Copia valore– un valore che identifica l'oggetto che verrà utilizzato per la copia durante la creazione di un nuovo oggetto. Fornito dalle estensioni del modulo oggetto e dal gestore dei record del registro delle informazioni.
• Compila valori– valori per compilare i dettagli di un nuovo oggetto. Rappresenta una struttura. I nomi degli elementi corrispondono ai nomi dei dettagli e i valori contengono i dati che verranno utilizzati per compilare i dettagli specificati. Fornito dalle estensioni del modulo oggetto e dal gestore dei record del registro delle informazioni.
• Base– un valore che identifica l'oggetto che verrà utilizzato come base quando si crea un nuovo oggetto inserendo base. Fornito dalle estensioni del modulo oggetto.
• Questo gruppo– definisce il tipo di nuovo oggetto: gruppo o elemento. Fornito dalle estensioni del modulo oggetto.

Un esempio di come lavorare con i parametri del modulo

Per dimostrare come funzionano i parametri del modulo, diamo un'occhiata all'implementazione della selezione di un elemento in un campo di input. L'essenza dell'esempio sarà l'implementazione del meccanismo per selezionare un elemento da un elenco nel linguaggio integrato.

Quando inizi a lavorare con l'esempio, devi avere una configurazione con le seguenti proprietà:

• Modalità di avvio principale: applicazione gestita;
• c'è una directory Prodotti con una gerarchia di gruppi ed elementi;
• esiste una directory Analogues con l'attributo SelectedProduct del tipo DirectoryLink.Products;
• entrambe le directory hanno moduli di elementi gestiti.

Ora implementiamo in questa configurazione tutti i meccanismi che la piattaforma utilizza per selezionare un elemento dall'elenco nel linguaggio integrato. Così facendo vedremo come vengono utilizzati i parametri del modulo standard; come il sistema stesso li utilizza; come uno sviluppatore può utilizzarli.

Aggiungiamo un ulteriore flag che controllerà la chiusura del form di selezione dopo aver selezionato un elemento. Chiameremo questo flag CloseAfterSelection (tipo Booleano). Aggiungiamolo come parametro del modulo Modulo per la selezione della directory Prodotti.

Per aprire il modulo di selezione dell'elemento, è necessario creare un gestore eventi per l'evento Inizio selezione per l'elemento del modulo Prodotto selezionato sotto forma dell'elemento della directory Analogues:

&SuClient

Procedura selezionataProductStartSelection(Articolo, Elaborazione standard)

Elaborazione standard = False;

SelectionParameters = Nuova struttura; SelectionParameters.Insert("SelectionMode", True); SelectionParameters.Insert("SelectingGroupsAndElements", UsingGroupsAndElements.Elements); SelectionParameters.Insert("AllowRootSelection", False); SelectionParameters.Insert("CurrentRow", Object.SelectedProduct); SelectionParameters.Insert("CloseAfterSelection", False); OpenForm("Directory.Products.SelectionForm", SelectionParameters, Elements.SelectedProduct);

FineProcedura

È necessario soffermarsi separatamente sul terzo parametro del metodo OpenForm(). Questo parametro determina chi sarà il proprietario del modulo di selezione e chi verrà informato della selezione effettuata. In questo caso, abbiamo specificato l'elemento del modulo stesso come proprietario del modulo di selezione, ma possiamo anche specificare il modulo stesso con questo parametro. In questo caso sarà necessario implementare il gestore del Form Module Selection Processing e in esso decidere in quale attributo del form collocare i dati selezionati.

Stampa (Ctrl+P)

Opzioni del modulo

1. Informazioni generali

I parametri del modulo (scheda Opzioni) hanno due scopi:
● Descrivere l'insieme di dati che influenzeranno l'apertura del modulo (parametrizzazione del modulo). Per fare ciò, è necessario elencare tutti i parametri necessari e indicarne i tipi.
● Determinare i parametri che influenzeranno la chiave di unicità del modulo. Per fare ciò è necessario impostare la proprietà Parametro chiave quei parametri che dovrebbero partecipare alla formazione della chiave di unicità del modulo. Quando si tenta di aprire un modulo, il sistema cerca un modulo esistente utilizzando la chiave di unicità del modulo generata. Se nel sistema esiste un modulo con la chiave ricevuta
unicità, è questa forma che ritorna; in caso contrario, viene creato un nuovo modulo.
Quando si richiama un modulo, i valori dei parametri creati dallo sviluppatore possono essere specificati nella struttura dei parametri insieme ai parametri di sistema dei moduli (se presenti).
I parametri del modulo possono essere passati al modulo al momento della sua creazione. Nell'evento è possibile eseguire l'analisi dei parametri passati Quando si crea sul server() (la raccolta Parametri è una proprietà dell'oggetto Modulo gestito):

// Nel luogo della chiamata.
// Crea un parametro del modulo.
Parametri = nuova struttura();
Opzioni.Inserisci("Importanza", Valore predefinito("Enumerazione.Importanza.Importante"));
// Apre il modulo con i parametri.
OpenForm (“GeneralForm.ViewForm”, Parametri);
…
// Nel modulo del modulo.
&Sul server
Procedura Quando si crea sul server (errore, elaborazione standard)
Se Parametri.Importanza = Enumerazioni.Importanza.Importante o Allora
…
finisci se;
FineProcedura

ATTENZIONE! Dopo aver chiamato il gestore eventi Quando creato sul server tutti i parametri del modulo non chiave vengono rimossi dalla raccolta Parametri.
Consiglio. I parametri del modulo non chiave necessari per ulteriori lavori devono essere salvati nei dati del modulo.

2. Parametri del modulo standard

Per supportare l'interazione automatica tra i moduli, il sistema fornisce una serie di parametri standard utilizzati per controllare i moduli quando vengono aperti. Utilizzando questi parametri, il sistema implementa nei campi del modulo la selezione dai moduli di selezione, l'apertura dei moduli oggetto, il funzionamento dei comandi standard, ecc. Cioè forniscono vari scenari operativi dell'interfaccia integrati nel sistema.
Ma lo sviluppatore può anche utilizzare questi parametri nel linguaggio integrato, passandoli quando chiama il metodo OpenForm().
Un elenco dei parametri del modulo standard a seconda del tipo di estensione del modulo è disponibile nelle sezioni Lingua incorporata: interfaccia
(gestito) – Modulo gestito – Estensione... integrato certificati

3. Esempio di lavoro con i parametri del modulo

Per dimostrare come funzionano i parametri del modulo, diamo un'occhiata all'implementazione della selezione di un elemento in un campo di input. L'essenza dell'esempio sarà l'implementazione del meccanismo per selezionare un elemento da un elenco nel linguaggio integrato.
Quando inizi a lavorare con l'esempio, devi avere una configurazione con le seguenti proprietà:
● esiste una directory Prodotti con una gerarchia di gruppi ed elementi;
● esiste una directory Analoghi con i dettagli del tipo di prodotto selezionato DirectoryLink.Prodotti;
● entrambe le directory hanno forme di elementi.
Ora implementiamo in questa configurazione tutti i meccanismi che la piattaforma utilizza per selezionare un elemento dall'elenco nel linguaggio integrato. In questo caso vedremo:
● come vengono utilizzati i parametri del modulo standard;
● come il sistema stesso li utilizza;
● come uno sviluppatore può utilizzarli.
Aggiungiamo un ulteriore parametro che controllerà la chiusura del modulo di selezione dopo aver selezionato un elemento. Chiamiamo questo parametro Chiudi dopo la selezione(tipo booleano). Aggiungiamolo come parametro del modulo Modulo per la selezione della directory Prodotti.
Per aprire il modulo di selezione dell'elemento, è necessario creare un gestore eventi per l'evento Inizio selezione per l'elemento del modulo SelectedProduct sotto forma di elemento della directory Analogues.

&SuClient
Procedura SelectedProductStartSelection(Articolo, Elaborazione standard)
Elaborazione standard= Falso;
Opzioni di selezione= Nuova struttura;
Opzioni di selezione.Inserisci(“ModalitàSelezione”, Vero);
Opzioni di selezione.Inserisci(“Selezione di gruppi ed elementi”, Utilizzo di GroupsAndElements.Elements);
Opzioni di selezione.Inserisci(“AllowRootSelection”, Falso);
Opzioni di selezione.Inserisci(“LineaCorrente”, Object.SelectedProduct);
Opzioni di selezione.Inserisci(“ChiudiDopoSelezione”, Falso);
OpenForm("Directory.Products.SelectionForm", Opzioni di selezione, Articoli.Prodottoselezionato);
FineProcedura
È necessario soffermarsi separatamente sul terzo parametro del metodo OpenForm(). Questo parametro determina chi sarà il proprietario del modulo di selezione e chi verrà informato della selezione effettuata. In questo caso, abbiamo specificato l'elemento del modulo stesso come proprietario del modulo di selezione, ma possiamo anche specificare il modulo stesso con questo parametro. In questo caso sarà necessario implementare un gestore Selezione elaborazione modulo del modulo e decidi in esso in quale attributo del modulo inserire i dati selezionati.
NOTA. Se non implementiamo il gestore di eventi StartSelection, il sistema stesso eseguirà le sue azioni. Ciò vale anche per tutti gli altri gestori utilizzati nell'esempio.
Ora è necessario elaborare i parametri passati nel modulo di selezione. Facciamolo nel gestore Quando creato sul server() del modulo del modulo di selezione.

&Sul server
Procedura WhenCreatingOnServer(Errore, StandardProcessing)
Elaborazione standard= Falso;
Elements.List.SelectingGroupsAndElements = Parametri.SelectingGroupsAndElements;
Elements.List.AllowRootSelection = Parametri.AllowRootSelection;
Elementi.List.CurrentRow = Parametri.CurrentRow;
CloseOnSelection = Opzioni.CloseAfterSelection;
FineProcedura
Per verificare la funzionalità dei parametri del form che abbiamo impostato, utilizzare il configuratore per impostare la proprietà Elenco per la tabella del form di selezione Selezione di gruppi ed elementi al valore Gruppi (senza utilizzare il parametro, la selezione degli elementi della directory non sarà disponibile).
NOTA. Se la tabella List che visualizza un elenco di prodotti non ha la proprietà SelectionMode impostata su True, la selezione dei prodotti non sarà disponibile.
Ora dobbiamo gestire la selezione dell'elemento desiderato nel modulo di selezione. Per fare ciò è necessario definire un gestore per l'evento SelectValue della tabella del modulo.

&SuClient
Procedura ListValueSelection(Elemento, StandardElaborazione, Valore)
Elaborazione standard= Falso;
Notificadellaselezione(Valore);
FineProcedura
Tutto quello che dobbiamo fare è implementare l'elaborazione della selezione degli elementi nel campo di input stesso. Per fare questo è necessario gestire l'evento Selezione elaborazione il nostro campo di input SelectedProduct.

&SuClient
Procedura SelectedItemSelectionProcessing(Articolo, SelectedValue, StandardProcessing)
Elaborazione standard= Falso;
Object.SelectedProduct = SelectedValue;
FineProcedura
Abbiamo implementato in modo indipendente un meccanismo di sistema per selezionare un valore in un campo di input su un modulo.
ATTENZIONE! Questo esempio non è completo. Il suo unico scopo è dimostrare i meccanismi per lavorare con i parametri del modulo.
Se durante la creazione dei parametri (handler SelezioneInizioProdottoSelezionato()) sostituire la riga:

Opzioni di selezione.Inserisci(“ChiudiDopoSelezione”, Vero);
per riga:
Opzioni di selezione.Inserisci(“ChiudiDopoSelezione”, Falso) ;
quindi il modulo di selezione non si chiuderà più una volta effettuata la selezione. Questo può essere utilizzato, ad esempio, per implementare un modulo di selezione (selezionare più prodotti senza chiudere il modulo di selezione).

Questo articolo descrive come utilizzare mezzi standard per passare un valore come parametro all'apertura di un modulo gestito 8.2, rispetto a come un'operazione simile potrebbe essere implementata nei moduli regolari.

Come i parametri vengono passati nelle forme regolari

Nelle forme ordinarie c'erano 2 possibilità per passare un parametro:
1) un metodo meno comune: nel modulo dell'oggetto nella scheda "Dettagli" sono stati aggiunti attributi e, se necessario, l'accesso è stato determinato visivamente
2) un metodo più comune: una variabile di esportazione è stata dichiarata nel modulo del modulo e il valore è stato elaborato nel gestore “Before Opening”

in entrambi i casi la chiamata al modulo era simile a questa:

Modulo = Object.GetForm("SelectionForm",FormOwner, UniquenessKey);
Modulo.Parametro = ValoreParametro;
Modulo.Apri();

Come vengono passati i parametri nei moduli gestiti

I moduli gestiti ora hanno la possibilità di passare immediatamente i parametri quando il modulo viene ricevuto. I parametri vengono passati come struttura:

Parametri = Nuova struttura("ValoreCorrente", UltimoElemento);
SelectionForm = GetForm("Directory. Nomenclature.SelectionForm", Parametri);
OggettoTrovato = SelectionForm.OpenModal();

Inoltre, il modulo gestito ora dispone di “estensioni del modulo” (oggetto, libro di consultazione, documento, report). A seconda del tipo di oggetto, viene determinata la composizione dei parametri disponibili. Ad esempio, se nel modulo di selezione della directory è necessario posizionarsi su un elemento specifico, allora viene utilizzato il parametro “CurrentValue”. Il grande vantaggio è che il modulo stesso non richiede la scrittura di gestori per parametri predefiniti, il che riduce la quantità di codice.

Lo sviluppatore ha anche la possibilità di definire i propri parametri (nel progettista di moduli gestiti, la scheda “Parametri”). La durata dei parametri è limitata dal gestore OnCreationOnServer, il che è logico perché i parametri sono richiesti solo durante la creazione di un modulo, ma se questo parametro determina l'unicità del modulo (il flag "parametro chiave" è impostato nelle proprietà del parametro), sarà disponibile in altri gestori.

Per passare un parametro di manipolazione specifico, devi fare qualcosa in più:

1) Definire il parametro in forma controllata.
Nel gestore OnCreationOnServer, definire l'elaborazione di questo parametro (accesso ai parametri passati tramite la proprietà "Parameters", che ha il tipo FormDataStructure)
2) Descrivere la ricezione del form e passare il valore del nuovo parametro nei parametri della funzione GetForm.
Quindi il codice sarà simile a:
- Nel luogo in cui ricevi il modulo

Parametri = Nuova struttura("NuovoParametro", UltimoElemento);
SelectionForm = GetForm("Directory. Nomenclature.SelectionForm", Parametri);

In un modulo del modulo gestito

&Sul server
Procedura al momento della creazione sul server (errore, elaborazione standard)
Se Parametri.Property("NuovoParametro") Allora
// ecco il codice di elaborazione dei parametri
finisci se;
FineProcedura

Conclusione

Forse questo articolo sarà utile a qualcuno, farà risparmiare tempo e ti salverà da codice non necessario. Per informazioni più dettagliate sull'elenco completo dei parametri del modulo gestito, si consiglia di consultare la guida "Interfaccia gestita\Modulo gestito".

[è necessario registrarsi per visualizzare il collegamento]

L'apertura dei moduli a livello di codice in un'applicazione 1C gestita è significativamente diversa dall'apertura in un'applicazione normale. Diamo prima un'occhiata al vecchio metodo. Consiste nel ricevere un modulo e poi aprirlo in modalità normale o modale (se aperto in modalità modale, il modulo blocca il programma).

OttieniForm() . Aprire()

Questo è il metodo più lento per aprire i moduli. Tuttavia, consente di elaborare il modulo a livello di codice prima di aprirlo. Per elaborare il codice è necessario modificare leggermente:

Modulo = OttieniForm( "Documento. Ricevuta di beni e servizi. Modulo di documento") ;
//Qui eseguiamo azioni con il modulo
Modulo. Aprire() ;

Va tenuto presente che al ricevimento del modulo verrà eseguita un'altra procedura evento Quandocreatosulserver.

Diamo un'occhiata ad altri metodi che consentono di aprire moduli in un'applicazione 1C gestita in modo più rapido e conveniente. A seconda della situazione specifica, possono essere utilizzati metodi diversi.

1. Come aprire un modulo oggetto in un'applicazione gestita se è presente un collegamento ad esso.

In questo caso, tutto è estremamente semplice.

RefLink = Directory. Nomenclatura. TrovaPerCodice("000000001" ) ;
ValoreAperto(CollegamentoRif) ;

2. Come aprire il modulo di selezione e quindi ottenere il valore selezionato.

C'è una funzione per questo ImmettereValore(). La funzione ha 3 parametri:

• La variabile in cui verrà scritto il valore selezionato;
• Un suggerimento che verrà visualizzato nella finestra di selezione;
• Descrizione dei tipi di valori selezionati. Potrebbero esserci diversi tipi, nel qual caso ti verrà richiesto di selezionare un tipo prima di selezionare un valore specifico.

Come risultato dell'esecuzione della funzione, si aprirà il modulo di selezione predefinito per un oggetto del tipo specificato.

Valore variabile;
Array= nuovo Array;
Vettore. Aggiungi(Tipo( "DirectoryLink.Nomenclatura") ) ;
Vettore. Aggiungi(Tipo( "DirectoryLink. Controparti") ) ;

TypeDescription= nuova TypeDescription(Array) ;

Res = EnterValue(Valore, "Suggerimento", TypeDescription) ;

I metodi precedenti consentivano solo di aprire i moduli predefiniti per gli oggetti (modulo oggetto o modulo di selezione). Se devi aprire un modulo personalizzato, puoi utilizzare la funzione OpenForm().

Questa funzione ha alcuni parametri. Diamo un'occhiata ad alcuni di essi:

• Nome del modulo— qui puoi selezionare una delle forme oggetto standard, ad esempio, Modulo di selezione O Modulo elenco. O un modulo specifico creato dagli sviluppatori.
• Opzioni— ti consente di trasferirlo nel modulo nel modulo strutture alcuni parametri prima di aprirlo, determinando così i dati di output. I parametri possono essere qualsiasi dato che può essere passato dal client al server. I parametri passati all'apertura del form possono essere elaborati nella procedura Quando si crea sul server() al modulo in fase di apertura.
• Modalità di apertura del modulo— ha 3 opzioni: indipendente, blocca l'intera interfaccia, blocca il modulo del proprietario.

Diamo un'occhiata a come viene utilizzata la funzione ApriForm() in varie situazioni.

3. Come aprire il form di un oggetto esistente

Ogni modulo ha un attributo chiave. È evidenziato in grassetto nell'elenco dei dettagli del modulo e solitamente viene chiamato Un oggetto sotto forma di elementi di libri e documenti di consultazione. Altri oggetti potrebbero avere un nome diverso. Per aprire un modulo di un oggetto esistente, è necessario passare un parametro al modulo che si sta aprendo Chiave con il valore come riferimento a un oggetto.

&SuClient
Procedura Comando1 (Comando)
Parametro= nuova struttura;
Parametro. Inserisci("Chiave", TrovaC() );
OpenForm(, Parametro) ;
FineProcedura

&Sul server
Funzione TrovaC();
Directory di ritorno. Controparti. TrovaPerRequisiti ("TIN", "745107734623")
EndFunction

4. Come aprire un nuovo modulo oggetto

Una semplice funzione andrà bene qui ApriForm() senza alcun parametro.

&SuClient
Procedura Comando1 (Comando)
ApriForm( "Directory. Controparti. Modulo oggetto") ;
FineProcedura

5. Come aprire un nuovo modulo oggetto e compilarlo in base a qualcosa

Devi passare un parametro Base, il cui valore sarà un riferimento all'oggetto base di riempimento. Questo avvierà la procedura ProcessFill().

&SuClient
Procedura Comando1 (Comando)
Parametro= nuova struttura;
Parametro. Insert("Base", LinkToAccountAcquirente) ;
ApriForm( "Documento. Vendita di beni e servizi. Modulo oggetto", Parametro) ;
FineProcedura

Questo esempio creerà un documento Vendite di beni e servizi e compilato sulla base di una fattura per il pagamento all'acquirente, il cui collegamento è stato trasmesso.

6. Come aprire un modulo e impostarne una selezione

La selezione sui moduli 1C può essere semplice o complessa. La selezione semplice implica espressioni come Organizzazione = Horns and Hooves LLC. La selezione complessa implica altri tipi di confronto, ad es. Sulla lista. In questo articolo considereremo l'organizzazione della selezione semplice e un articolo separato sarà dedicato alla selezione complessa.

Per organizzare una selezione semplice è necessario passare un parametro con una chiave al form che si apre Selezione, il valore sarà una struttura in cui la chiave è il nome del campo dell'elenco dinamico e il valore rappresenta i dati cercati.

Ad esempio, apriamo il modulo dell'elenco delle directory Numeri GTD e fai una selezione lì per proprietario - elemento directory Nomenclatura.

&SuClient
Procedura Comando1 (Comando)
Parametro= nuova struttura;

selezione=nuova struttura;
Selezione. Insert("Proprietario", LinkToNomenclatura) ;

Parametro. Inserisci("Selezione", Selezione) ;

ApriForm( "Elenco indirizzi.Numeri GTD.Modulo elenco", Parametro) ;
FineProcedura

7. Come aprire il modulo di iscrizione al registro informazioni

Per fare ciò avrai bisogno della chiave di accesso al registro delle informazioni.

Chiave di registrazione— questi sono i valori di tutte le misurazioni e il periodo (se il registro è periodico). Cioè, una chiave di record rappresenta i parametri con cui un record può essere identificato in modo univoco.

L'algoritmo di apertura è il seguente:

1. Inseriamo nella struttura i dati chiave del record con i valori necessari.
2. Inseriamo la struttura risultante in un array.
3. Creiamo una chiave record dall'array.
4. Passiamo un parametro al form che si apre Chiave con la chiave di registrazione del passaggio 3 come valore.

&SuClient
Procedura Comando1 (Comando)
Parametro= nuova struttura;

Parametrichiave= nuova struttura;
Parametri chiave. Insert("Nomenclatura", LinkANomenclatura) ;
Parametri chiave. Insert("TipoPrezzo", LinkToPrezzo) ;
Parametri chiave. Insert("Periodo", Data) ;

KeyArray = Nuovo array;
KeyArray. Aggiungi(Parametrichiave) ;

Chiave di immissione = Nuovo( "Informazioni RegistroRegistro Chiave.PrezziNomenclatura", KeyArray) ;

Parametro. Inserisci("Chiave", ChiaveRecord) ;

ApriForm( "Registro delle informazioni. Prezzi della nomenclatura. Modulo di registrazione", Parametro) ;
FineProcedura