1s 8 attiva una forma controllata. Pulsanti di opzione, app normale, moduli gestiti

09.12.2023 Interessante

1. Campo di immissione
2. Casella di controllo
3. Cambia

Campo di immissione

Di norma, un campo di input è associato a un attributo dell'oggetto e ne riflette i dati. Questo è forse uno degli elementi più comuni, ha diversi modi per selezionare un valore:

Selezione da un elenco (modalità di selezione elenco)

Selezione da un altro modulo (pulsante Seleziona)

Pulsanti di controllo

L'implementazione degli esempi precedenti non richiede uno sforzo significativo da parte dello sviluppatore. ad esempio, per la modalità lista è necessario riempire la lista di un elemento con valori; per selezionare da un'altra maschera è sufficiente associare semplicemente l'elemento di controllo ai dati della directory. Ma per i pulsanti di controllo, dovrai scrivere più codice per elaborare i clic su ciascun pulsante, anche se non sarà grande:

Procedura pvSelezione della nomenclaturaRegolamento(Elemento, Direzione, StandardElaborazione)
//Seleziona i dati per il campo di input
// in questo caso, la directory Nomenclature
Richiesta = Nuova richiesta;
Richiesta.Testo=
"SCEGLIERE
| Nomenclatura.Link come prodotto
|DA
| Directory.Nomenclature AS Nomenclatura
|ORDINA PER
| Nomenclatura.Codice";
TZNomenclature = Richiesta.Esegui().Upload();

//cerca l'elemento della directory corrente specificato nel campo di input
ElementoCorrente = TZNomenclature.Find(Elemento.valore);

Se TechElement = Non definito Allora
// se l'elemento non viene trovato, imposta il numero di indice
// fuori dalla tabella dei valori, perché il primo elemento in
// la tabella dei valori ha indice 0
Indice tecnico = -1;
Altrimenti
// se l'elemento viene trovato ne otteniamo l'indice
TechIndex = TZNomenclature.Index(TechElement);
finisci se;

// calcola un nuovo indice a seconda della pressione del pulsante
// meno davanti alla variabile La direzione è posizionata in modo che quando
// facendo clic sulla freccia in alto viene mostrato l'elemento sopra di essa
// e quindi con un indice più piccolo
NewIndex = Direzione TechIndex;

// ottiene il numero di elementi nella directory
// sottrai uno perché tutte le raccolte nella versione 8.1 iniziano da 0
Numero diElementi = TZNomenclature.Quantità()-1;

Se NovIndex< 0 Или НовИндекс >Numero di elementi Quindi
// se durante la modifica l'indice è esterno alla tabella dei valori
// cioè. il suo numero è quindi maggiore dell'indice più grande o minore di 0
// non modifica il valore e ne informa l'utente
Notify("Hai raggiunto il limite della directory");
Altrimenti
// assegna un nuovo valore, "Prodotto" è il nome della colonna della tabella dei valori
Elemento.valore = TZNomenclature.Get(NuovoIndice).Prodotto;
finisci se;

Fine della procedura

Casella di controllo

Nella maggior parte dei programmi, una casella di controllo serve per visualizzare due stati: selezionato, deselezionato. In 1c la casella di controllo ha tre stati; nel terzo stato la casella di controllo viene visualizzata come selezionata e allo stesso tempo ombreggiata. I tre stati sono disponibili solo se i dati della casella di controllo sono un numero e gli stati hanno i seguenti significati:

Interruttore

L'interruttore viene utilizzato per selezionare un valore da un numero limitato di valori possibili (preferibilmente non più di cinque) e i valori non possono essere combinati, ad esempio: adatto per selezionare il sesso di una persona. Un altro esempio: supponiamo che un'azienda offra uno dei 3 sconti su un prodotto e gli sconti non si sommano:

In questo caso, la comodità di utilizzare i pulsanti di opzione potrebbe risiedere nel fatto che ciascuno di essi può avere un valore, che è impostato nella proprietà "Valore selezionabile". E poi "Sconto 5%" può memorizzare il valore 5 o 0,05.

È importante ricordare tre cose quando si utilizzano gli switch:

La prima opzione dovrebbe avere la proprietà "FirstInGroup" (in questo esempio è l'opzione "Sconto 5%).

I commutatori correlati in modo significativo a un gruppo dovrebbero andare in fila quando si imposta l'ordine di attraversamento, senza interruzioni da parte di altri elementi del modulo. L'ordine di attraversamento viene impostato dal menu "Modulo -> Impostazione ordine di attraversamento", per questo esempio è simile al seguente:

Il tipo di valore selezionato è impostato per lo switch che ha la proprietà "FirstInGroup".

Aggiungi un frame di gruppo al modulo e posiziona gli interruttori tramite la voce di menu Modulo -> Inserisci controllo... e seleziona gli interruttori nella finestra che si apre:

Nella parte destra della finestra, aggiungi il valore dell'interruttore quanto necessario, seleziona la casella "Promozioni - primo nel gruppo" in modo che questo interruttore venga selezionato automaticamente.

Dopo aver aggiunto gli switch, selezioniamo il tipo di dati per il primo valore “Azioni”, nel nostro caso assegniamo il valore “Tipo Titoli”:

E il valore dell'interruttore stesso viene inserito in Dati -> Valore selezionato. Per le azioni questo è 0, le obbligazioni - 1, le fatture - 2 e le quote - 3. Ma prima di inserire questi dati, è necessario controllare l'ordine.

Se gli switch non sono in ordine, lo switch non verrà effettuato, ovvero non potremo selezionare il valore dell'obbligazione. Per abilitare questa funzionalità è necessario selezionare il menu Modulo -> Impostazione ordine di attraversamento e posizionare tutti gli interruttori in ordine.

Controllare il valore selezionabile degli interruttori dopo aver corretto l'ordine.

Non resta che scrivere il codice del programma nell’evento di commutazione “azione” “Al cambio”:

Se Tipo CB = 0 Allora

AltrimentiSeCBType = 1 Allora

ThisForm.FormElements.Receipt.Columns.NCD.Availability = 1; // solo per le obbligazioni consentiamo NKD

AltrimentiSeCBType = 2 Allora

ThisForm.FormElements.Receipt.Columns.NCD.Availability = 0;

AltrimentiSeCBType = 3 Allora

ThisForm.FormElements.Receipt.Columns.NCD.Availability = 0;

finisci se;

Ora, quando selezioni l'interruttore "Obbligazioni", puoi modificare il valore della colonna degli asset.

Ho letto molti forum e da nessuna parte ho visto una descrizione comprensibile del lavoro con "Switch". Quindi ho deciso di scriverlo io stesso.

A mio avviso, l’errore più comune è l’idea sbagliata sullo “Switch”. Quando si posizionano più “Interruttori”, ad esempio 3, su un modulo, molte persone credono che nella logica del programma si tratti di 3 oggetti diversi che si influenzano a vicenda. Ma, in effetti, il programma percepisce tutti e 3 gli "Interruttori" come un unico oggetto. E sceglierne uno cambia lo stato di questo oggetto. Diamo un'occhiata a un esempio.

1. Crea tre pulsanti di opzione sul modulo. Per comodità non cambieremo i nomi.
2. Evidenziare Switch1. Nelle sue proprietà, nella sezione “BASE”, seleziona la prima casella di gruppo. “TIPO VALORE” seleziona un numero. (Poi vedremo perché esattamente il numero). La lunghezza può essere impostata su uno, ma ciò non fornisce alcuna funzionalità speciale.
3. Selezionare “Switch2” nella colonna “VALORE SELEZIONATO” e inserire 1.
4. Selezionare “Switch3” nella colonna “VALORE SELEZIONATO” e inserire 2.
In sostanza, con le azioni 3 e 4, si imposta un flag che cambierà quando si selezionerà il corrispondente “Switch”. In “Switch1” il “VALORE SELEZIONATO” predefinito è zero.
5. Controllare se gli interruttori sono in "WALKING ORDER" in ordine. (ad esempio: 13,14,15)(Fig. 1). è richiesto un ordine continuo di attraversamento tramite interruttore. L'ordine di auto-bypass è abilitato (le posizioni sono numerate 13, 15, 20) (Fig. 2) in questo caso gli interruttori uno sotto l'altro non funzioneranno. È necessario rimuovere l'uso dell'ordine automatico dal modulo e, se necessario, specificare manualmente l'ordine.

Come impostare l'ordine di attraversamento per i dettagli. All'interno del modulo, nel menu "Dialogo", è necessario deselezionare la casella di controllo "Ordine di attraversamento automatico". Successivamente è possibile utilizzare “Dialogo” -> “Impostazione dell'ordine di attraversamento” o “Dialogo” -> “Ordine di viaggio”. Il secondo metodo mi sembra il più conveniente. Con questo metodo, per ogni oggetto viene visualizzata un'immagine con il numero dell'oggetto. Tutto quello che devi fare è cliccare sui numeri, selezionando i dettagli nell'ordine che preferisci.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

6. Seleziona "Switch1" e scrivi la procedura di cui abbiamo bisogno.
Per esempio:

EF=ElementiForm; Se Switch1=0 Allora EF.Payment Status.Value = "Non pagato"; AltrimentiSe Switch1=1 Allora EF.Payment Status.Value = "Parzialmente pagato"; AltrimentiSe Switch1=2 Allora EF.Payment Status.Value = "Pagato"; finisci se;

7. Premere F7. Premi F5. Vediamo che funziona tutto, siamo alla grande. E il grande BOSS ci dà un bonus.

SPIEGAZIONE DEL CODICE

Perché c'è "Switch1" ovunque? Poiché è già stato detto, il programma percepisce tutti e tre gli elementi come uno solo, e poiché "Switch1" è il primo nel gruppo, il programma lo percepisce come l'elemento intero. Se rendi "Switch2" il principale nel gruppo , allora il controllo di correttezza dovrà essere effettuato secondo "Switch2".
Ebbene, da dove vengono "0", "1", "2"? Impostiamo i valori che l'oggetto assume quando si cambia "Interruttori" nei paragrafi 3 e 4.

EPILOGO:

Questo codice viene fornito come esempio di funzionamento con gli interruttori. Secondo me questo è più chiaro e comprensibile. Ma vale la pena ricordare che in "Tipo valore" puoi selezionare immediatamente ciò di cui hai bisogno: un valore predefinito da una directory, un'enumerazione, ad esempio, o un valore di stringa. Cioè, nell'esempio sopra, era possibile assegnare immediatamente gli interruttori come valori non 0,1,2, ma immediatamente "Non pagato", "Pagato parzialmente", "Pagato". E poi il codice verrà ridotto a una riga:

Elementi del modulo.Stato pagamento.Valore = Switch1;

Il risultato sarà lo stesso.

//////////////////////////////////////////////////////////////////////////////////////////

Gli interruttori nelle forme controllate (UF) sono stati resi più intuitivi.

Quando crei uno Switch, devi ricordare il duo Attributes, Form Element.
Prima di tutto, devi creare gli attributi del modulo. Imposta il tipo dell'attributo su quali valori accetterà il tuo switch. Ho scelto il tipo String. Qui hai due opzioni: se hai creato un attributo Oggetto, il valore accettato dal tuo switch verrà salvato nel database, se lo aggiungi semplicemente all'elenco dei dettagli del modulo, il risultato accettato dal tuo switch non verrà salvato.

Successivamente, trascina e rilascia gli attributi di cui abbiamo bisogno in Elementi del modulo. Quando si crea un elemento del modulo, l'elemento nelle proprietà "Visualizza" avrà il tipo "Campo di input". Selezionare "Cambio campo" dall'elenco. Di conseguenza, otterrai un modulo simile a questo:

Compiliamo il titolo dell'elemento del modulo, il colore, il carattere, la posizione e altre bellezze secondo i tuoi gusti.
C'è un elemento nelle proprietà dell'elemento del modulo. "Elenco di selezione": in esso inserisci i valori che assumerà il tuo interruttore quando selezioni l'uno o l'altro elemento. Nel mio esempio ho aggiunto righe con i valori “Record”, “Cancel Post”, “Post”.

Successivamente, l'interruttore è pronto per l'uso.

A seconda che l'opzione sia un attributo Object o un attributo Form, utilizzi il seguente codice per ottenere il valore memorizzato in esso:

SwitchFormElementFormElement // accede direttamente se questo è un attributo del form Object.SwitchInsideDB // accede tramite l'elemento Object. ai tuoi dati

Klyuev V.V.

http://prof1c.kklab.ru

LAVORARE CON GLI INTERRUTTORI

Si prega di tenere in considerazione tutti gli utenti del servizio del sito: inserisco materiali nella sezione Principianti!!!

8.2 Moduli gestiti

Durante lo studio del comportamento dei moduli gestiti, i programmatori o gli sviluppatori di interfacce si trovano ad affrontare la questione di dove si trovano gli switch nei moduli gestiti e come aggiungerli al modulo. È una piccola cosa, ma è spiacevole che venga dedicato molto tempo a queste sciocchezze, anche se questo tempo potrebbe essere dedicato allo sviluppo e all’ottimizzazione dell’algoritmo, piuttosto che alla progettazione del modulo.

Quindi, creiamo una configurazione vuota per comprendere la domanda o scegliamone una tipica.
Vai al gruppo contenente le directory e aggiungi una nuova directory per sperimentare. Vorrei sottolineare che la configurazione deve avere la modalità di avvio principale: Applicazione gestita.

Creiamo quindi una nuova directory e aggiungiamo l'attributo "Property1", di tipo "Boolean"

Ora andiamo alla scheda Moduli e aggiungiamo un nuovo modulo.

Quindi, il modulo controllato è stato creato, ora lavoriamo con il modulo e scopriamo dove si trova l'interruttore.
Ecco la nostra forma e su di essa vediamo i nostri oggetti di scena, ma sotto forma di bandiera

Quindi cosa abbiamo fatto di sbagliato?
Diamo un'occhiata alle proprietà degli oggetti di scena per vedere se c'è un passaggio al tipo di controllo.
E vediamo che il campo Cambia non è qui! (Dove abbiamo sbagliato?

Apparentemente, il tipo di controllo sul modulo dipende dal tipo di dati, torniamo alle proprietà del modulo, ovvero la scheda dettagli, e cambiamo le proprietà del nostro attributo, ovvero il suo tipo "Booleano", al tipo "Numero ”.

Ora torniamo alle proprietà del controllo e controlliamo se la vista del controllo è stata aggiunta alle sue proprietà - - - E evviva, vediamo la vista lì - Cambia campo.

Ora guarda il modulo, cosa vediamo:

Vediamo: 3 valori predefiniti, 3 opzioni, ma ne abbiamo bisogno di due, torniamo alle proprietà dell'attributo e guardiamo le proprietà "Numero di colonne" lì

Per 2: imposta il Numero di colonne - 2.

Questo potrebbe fermare un po' un programmatore stanco)), ma ora lo sappiamo sia lui che noi!

8.2 Forme regolari.

Noioso con gli interruttori nelle forme ordinarie.
Ci sono momenti del genere, e accadono, in cui è necessario modificare un modulo già pronto, che ha già alcuni interruttori, ed è necessario aggiungere un altro interruttore a questo modulo. È qui che sorge una sorta di noiosità, che richiede molto tempo, e non tempo per programmare il codice, ma una perdita di tempo per visualizzare questi interruttori per l'utente.

Quindi diamo un'occhiata a un esempio. Esiste un documento del genere per la rettifica delle entrate in 1C UPP: esiste sicuramente. Una volta avevamo bisogno di aggiungere delle opzioni in modo che venissero tracciate voci leggermente diverse per la contabilità. Qual è il problema, sembrerebbe che dobbiamo, dobbiamo, lo faremo. Ma questo modulo ha già 2 pulsanti di opzione.

Ecco come appare il modulo in cui dobbiamo aggiungere più opzioni

Nella scheda Avanzate vorremmo inserire altri due pulsanti di opzione. Quindi il primo passo è aggiungere coraggiosamente un nuovo elemento di controllo nel punto in cui ci serve e inserirlo.

Sembrerebbe che tutto sia semplice. Creiamo un nuovo attributo con il tipo "Numero" e inseriamo 2 interruttori, uno dei quali sarà in grado di scrivere dati nell'attributo e l'altro no.

Aggiungere un nuovo elemento di controllo - Switch, aggiungere Switch2 nella tabella con il numero e la descrizione degli interruttori, impostare prima Switch1 nel gruppo e premere OK. Posiziona i controlli creati sul modulo. Aggiorniamo la configurazione del database (F7) e la eseguiamo per il debug.

Durante l'esecuzione (quando si crea un nuovo documento in modalità 1C:Enterprise), vediamo che non importa quanto proviamo a fare clic su Switch2, non succede nulla. Gli elementi non funzionano come dovrebbero. C'è un trucco qui.
Ritorna al configuratore. Selezionare la voce di menu Modulo -> Imposta ordine di attraversamento... (è importante che il modulo sia aperto sullo schermo)

Affinché i nostri Switch funzionino, è necessario interrompere l'ordine automatico e accettarne uno manuale. E inseriscilo nel modulo in modo che i nostri interruttori vadano uno dopo l'altro in ordine.