Het programmatisch openen van formulieren in een beheerde 1C-applicatie verschilt aanzienlijk van het openen in een reguliere applicatie. Laten we beginnen met de oude methode. Het bestaat uit het ontvangen van een formulier en het vervolgens openen in de normale of modale modus (wanneer geopend in de modale modus, blokkeert het formulier het werk van het programma).

GetForm (). Open()

Dit is de langzaamste methode om formulieren te openen. U kunt het formulier echter programmatisch verwerken voordat u het opent. Om de code te verwerken, moet je een beetje veranderen:

Formulier = GetForm ( "Document. Ontvangst van goederenDiensten. Documentformulier") ;
// Hier voeren we acties uit met het formulier
Het formulier. Open ();

Houd er rekening mee dat wanneer het formulier wordt ontvangen, een andere gebeurtenisprocedure wordt uitgevoerd OpCreateAtServer.

Laten we eens kijken naar andere methoden waarmee u sneller en gemakkelijker formulieren in een beheerde 1C-toepassing kunt openen. Afhankelijk van de specifieke situatie kunnen verschillende methoden worden gebruikt.

1. Hoe een objectformulier te openen in een beheerde applicatie, als er een link naar is.

In dit geval is alles uiterst eenvoudig.

RefLink = Directory's. Nomenclatuur. FindByCode ("000000001");
OpenValue (RefLink);

2. Hoe u het selectieformulier opent en vervolgens de geselecteerde waarde krijgt.

Hiervoor is er een functie Voer Waarde in (). De functie heeft 3 parameters:

• De variabele waarnaar de geselecteerde waarde wordt geschreven;
• Een hint die wordt weergegeven in het selectievenster;
• Beschrijving van de soorten waarden om te selecteren. Er kunnen verschillende typen zijn. Voordat u een specifieke waarde kiest, wordt u gevraagd een type te selecteren.

Als resultaat van het uitvoeren van de functie, wordt het standaard selectieformulier voor het object van het opgegeven type geopend.

Var-waarde;
Matrix = nieuwe matrix;
Reeks. Toevoegen (Type ( "DirectoryLink.Nomenclatuur") ) ;
Reeks. Toevoegen (Type ( "DirectoryLink. Aannemers") ) ;

TypeDescription = nieuwe TypeDescription (array);

Res = EnterValue (Waarde, "Hint", Beschrijving van typen);

Met de vorige methoden konden alleen de formulieren worden geopend die standaard voor objecten zijn ingesteld (objectformulier of selectieformulier). Als u een willekeurige vorm moet openen, kunt u de functie gebruiken: OpenForm ().

Deze functie heeft nogal wat parameters. Laten we er een paar bekijken:

• Formulier naam- hier kunt u een van de standaard objectvormen kiezen, bijvoorbeeld Selectieformulier of Lijstformulier... Of een specifiek formulier gemaakt door de ontwikkelaars.
• Opties- hiermee kunt u overstappen naar het formulier in het formulier structuren enkele parameters voordat u het opent, waardoor de uitvoergegevens worden gedefinieerd. Parameters kunnen alle gegevens zijn die van de client naar de server kunnen worden overgedragen. De parameters die zijn doorgegeven bij het openen van het formulier kunnen in de procedure worden verwerkt OnCreateAtServer () op het geopende formulier.
• Formulier openingsmodus- heeft 3 opties: onafhankelijk, blokkeer de hele interface, blokkeer het formulier van de eigenaar.

Laten we eens kijken hoe de functie wordt toegepast OpenForm () in verschillende situaties.

3. Hoe de vorm van een bestaand object te openen

Elk formulier heeft één belangrijke rekwisieten. Het wordt vetgedrukt weergegeven in de lijst met formulierattributen en wordt meestal genoemd Een voorwerp op formulieren van elementen van mappen, documenten. Andere objecten kunnen een andere naam hebben. Om de vorm van een bestaand object te openen, moet u de parameter doorgeven aan het geopende formulier Toets met een waarde in de vorm van een objectreferentie.

& Op Client
Procedure Commando1 (Commando)
Parameter = nieuwe structuur;
Parameter. Invoegen ("Sleutel", FindS ());
OpenForm (, Parameter);
Einde van de procedure

&Op server
FindC () functie;
Directory's terugsturen. Aannemers. Zoeken op de vereiste ("INN", "745107734623")
Eindfunctie

4. Hoe de vorm van een nieuw object te openen?

Hier volstaat een functie OpenForm () zonder parameters.

& Op Client
Procedure Commando1 (Commando)
OpenForm ( "Directory. Aannemers. Objectformulier") ;
Einde van de procedure

5. Hoe een nieuw objectformulier te openen en op basis van iets in te vullen?

U moet een parameter doorgeven Baseren, waarvan de waarde een verwijzing is naar het fill-base-object. Hiermee wordt de procedure gestart. ProcessingFill ().

& Op Client
Procedure Commando1 (Commando)
Parameter = nieuwe structuur;
Parameter. Invoegen ("Basis", Accountlink naar Koper);
OpenForm ( "Document.RealizationGoodsServices.ObjectForm", Parameter) ;
Einde van de procedure

Dit voorbeeld zal een document maken Verkoop van goederen en diensten en ingevuld op basis van de factuur voor betaling aan de koper, waarvan de link werd doorgestuurd.

6. Hoe een formulier te openen en er een selectie op te zetten

Selectie op 1C-formulieren kan eenvoudig en complex zijn. Eenvoudige selectie levert uitdrukkingen als Organisatie = LLC "Horns and Hooves". Gecompliceerde selectie omvat andere soorten vergelijking, bijvoorbeeld In de lijst... In dit artikel zullen we de organisatie van een eenvoudige selectie beschouwen, en een apart artikel zal aan de complexe worden gewijd.

Om een ​​eenvoudige selectie te organiseren, moet u een parameter met een sleutel doorgeven aan het geopende formulier Selectie, zal de waarde een structuur zijn waarin de sleutel de naam is van het dynamische lijstveld en de waarde de vereiste gegevens.

Laten we bijvoorbeeld de vorm van de directorylijst openen GTD-nummers en maak daar een selectie door de eigenaar - een directory-element Nomenclatuur.

& Op Client
Procedure Commando1 (Commando)
Parameter = nieuwe structuur;

Selectie = nieuwe structuur;
Selectie. Invoegen ("Eigenaar", ReferentieNomenclatuur);

Parameter. Invoegen ("Selectie", Selectie);

OpenForm ( "Directory.NumbersGTD.Lijstformulier", Parameter) ;
Einde van de procedure

7. Hoe het ite openen?

Hiervoor heeft u een informatieregister-schrijfsleutel nodig.

Opnamesleutel- dit zijn de waarden van alle metingen en de periode (indien het register periodiek is). Dat wil zeggen dat de recordsleutel de parameters zijn waarmee de record op unieke wijze kan worden geïdentificeerd.

Het openingsalgoritme is als volgt:

1. We voeren de gegevens van de recordsleutel met de benodigde waarden in de structuur in.
2. We plaatsen de resulterende structuur in een array.
3. Maak een recordsleutel van de array.
4. We geven de parameter door aan het geopende formulier Toets met de recordsleutel uit item 3 als waarde.

& Op Client
Procedure Commando1 (Commando)
Parameter = nieuwe structuur;

KeyParameters = nieuwe structuur;
Belangrijkste parameters. Invoegen ("Nomenclatuur", ReferentieNomenclatuur);
Belangrijkste parameters. Invoegen ("PriceType", LinkPriceType);
Belangrijkste parameters. Invoegen ("Periode", Datum);

KeyArray = Nieuwe array;
MatrixKey. Toevoegen (KeyParameters);

SleutelRecord = Nieuw ( "DataRecordRecordKey.Nomenclatuur Prijzen", ArrayKey);

Parameter. Invoegen ("Sleutel", KeyRecord);

OpenForm ( "Informatieregister. Nomenclatuur Prijzen. Recordformulier", Parameter) ;
Einde van de procedure

Goedendag iedereen!
Ik denk dat de informatie in dit onderwerp zeer nuttig zal zijn voor veel bezoekers van dit forum.
Lange tijd kon ik het probleem niet oplossen - hoe de vorm van een nieuw document te openen zodat het niet leeg opent, maar al gedeeltelijk programmatisch is ingevuld, terwijl het document zelf nog niet naar de database is geschreven? Ik heb veel tijd besteed aan het zoeken naar een oplossing voor dit probleem op internet, heb veel forums bezocht waar dit probleem aan de orde was, maar slechts een paar van hen kwamen oplossingen tegen. De eenvoudigste is om eerst programmatisch een nieuw document te maken, programmatisch de nodige details in te vullen, het document naar de database te schrijven en het vervolgens voor de gebruiker te openen. Wat als de gebruiker het niet wil opslaan? Wat als hij van gedachten verandert en het open formulier sluit? In dit geval blijft het reeds vastgelegde document in de database. En wie heeft er extra documenten in de database nodig?
En als u het document niet opslaat, is de meest populaire optie het gebruik van de GetForm-methode ("Documents.NeedDocumentView.DocumentForm"). Maar in dit geval kunt u een leeg documentformulier krijgen en dit eenvoudig weergeven met de methode Open () . Dit is ook geen optie...
Na enige tijd werd het probleem opgelost met behulp van de globale contextfunctie "FillPropertyValues".

Wereldwijde context
VullenEigenschapWaarden
Syntaxis:
VulPropertyValues ​​​​(<Приемник>, <Источник>, <Список свойств>, <Исключая свойства>)
Beschrijving:
Kopieert eigenschapswaarden<Источника>in eigenschappen<Приемника>... Matching wordt gedaan door eigenschapsnamen.

Aan de hand van mijn taak als voorbeeld, zou ik willen uitleggen hoe deze functie kan worden gebruikt om het formulier van een nieuw document in te vullen. De taak was als volgt - Er is één document (Werkopdracht), waarvan het attribuut van de tabelsectie een ander document is (Dienstenverlening). Het was dus noodzakelijk om dit te doen bij het toevoegen van een nieuw document "Dienstenverlening" aan de tabelsectie van de "Order-Order", de vorm van een nieuw document "Rendering van diensten" met reeds ingevulde gegevens afkomstig van de volgorde van waaruit de schepping werd aangeroepen. Tegelijkertijd, zodat het nieuwe document zelf, op het moment dat zijn vorm op het scherm verschijnt, nog niet in de database is geschreven. Dit moest gebeuren als de gebruiker plotseling besluit het document niet in te vullen en het formulier gewoon sluit.
Hier is een codefragment met een oplossing voor het probleem:

& Op de clientprocedure EnterRecord () RecordForm = GetForm ("Document.ProvisionMedServices.ObjectForm"); Vul de Eigenschapswaarden in (Record Form.Object, Object, "Datum, Specialist, Specialisatie, Verpleegkundige, Uitvoeringsstatus",); // Vul de waarden in van de attributen, waarvan de namen hetzelfde zijn in beide documenten TekStr = Elements.Receiving.CurrentData; // Gegevens van de huidige regel van het brondocument PropertyStructure = New Structure; // De structuur bevat de waarden van die details die op het formulier van een nieuw document moeten worden ingevuld, maar die niet in het brondocument PropertyStructure.Insert ("OutfitRecord", Object.Link); StructureProperties.Insert ("ReceptionTime", TekStr.ReceptionTime); FillValues ​​​​of Properties (RecordForm.Object, PropertyStructure, "AttireRecord, Reception Time",); RecordForm.Open (); Einde van de procedure

Dat wil zeggen, we doen alle bewerkingen rechtstreeks op de client, zonder contact met de server, binnen één onafhankelijk opgestelde procedure. In feite kunt u op deze manier het formulier van elk document of naslagwerk invullen en openen. Eerst vulde ik de details van het ene formulier in het andere in met behulp van formulierobjecten en vervolgens, met behulp van het object "Structuur", waarin ik de ontbrekende details invoegde, vulde ik wat meer details van het geopende formulier in en opende toen het formulier .
Ik hoop dat dit thema tijd zal besparen voor velen die met een soortgelijk probleem te maken hebben gehad!

Hoe open ik de vorm van een bestaand object?

Bij het openen van de vorm van een bestaand object moet naast de naam van het formulier ook het object worden aangegeven waarvan de vorm moet worden geopend. Hiervoor worden de formulierparameter Sleutel en een link naar het voor ons interessante object gebruikt.

Als u bijvoorbeeld vanuit het formulier van de lijst met organisaties het formulier van de organisatie moet openen waarop de cursor zich bevindt, kunt u dit op de volgende manier doen:

We geven de formulierparameters door in de vorm van een structuur, waarbij de naam van het structuurelement overeenkomt met de naam van de formulierparameter, en de waarde is de waarde waarop we de formulierparameter willen instellen.

Als u niet de hoofdvorm, maar een willekeurige vorm van een in de configurator gemaakt object wilt openen, in plaats van de standaardnaam van de hoofdvorm (ObjectForm), wordt het woord Form aangegeven en, door een punt erna, de naam van het formulier dat in de configurator is gemaakt.

Bijvoorbeeld:

ReferenceItemRef = Items.List.CurrentString; Formulierparameters = Nieuwe structuur ("Key", ReferenceElementRef); OpenForm ("Directory.Organizations.Form.UniversalFormObject", Formulierparameters);

Opgemerkt moet worden dat in het geval dat, afgezien van een verwijzing naar een object, er geen parameters aan het te openen formulier hoeven te worden doorgegeven en het de hoofdvorm van het bestaande object is, u een eenvoudigere methode kunt gebruiken - open het formulier via de procedure OpenWaarde ():

OpenValue (Items.Lijst.CurrentLine);

Deze methode is minder veelzijdig, maar bespaart in sommige gevallen tijd en moeite. In het beschouwde geval kan één zo'n regel bijvoorbeeld de hele procedure met drie regels vervangen die we eerder schreven.

Wees echter voorzichtig bij het gebruik van deze procedure. In sommige gevallen kan dit extra aanroepen naar de server veroorzaken, bijvoorbeeld wanneer u een formulier voor een item in een hiërarchische catalogus moet openen. Bij gebruik van deze procedure zal het platform een ​​extra oproep naar de server doen om te bepalen of het element een groep is of niet, aangezien er verschillende formulieren moeten worden geopend voor het element en voor de groep.

Tegelijkertijd kan de ontwikkelaar deze informatie vooraf binnen zijn algoritme kennen en met behulp van de functie OpenForm () kan de ontwikkelaar het vereiste formulier openen zonder extra oproepen naar de server, waarbij onmiddellijk de standaardnaam van het hoofdformulier wordt gespecificeerd .