1c verplichte vermelding in het formulier. Programmatisch elementen van beheerde formulieren toevoegen en wijzigen. Vervanging van een enkele waarde waarvoor de gebruiker rechten heeft

Basisinvoermechanisme is een van de toepassingsmechanismen van het platform. Hiermee kunt u het werk van de gebruiker met de applicatieoplossing vereenvoudigen en hem behoeden voor het opnieuw invoeren van gegevens die al in de informatiebank zijn opgeslagen.

Laten we naar een eenvoudig voorbeeld kijken. Laten we zeggen dat er in een applicatieoplossing een document is Ontvangst van goederen, waarin wordt vastgelegd dat bepaalde nomenclatuuritems in de organisatie voorkomen:

Nadat het artikel is ontvangen van de leverancier, moet er een document worden opgesteld Betaling voor goederen en diensten, waarin de leverancier wordt vermeld en het bedrag dat aan hem moet worden overgemaakt voor de geleverde goederen:

In een dergelijke situatie kunt u met het invoermechanisme op basis daarvan een document genereren Betaling voor goederen en diensten automatisch, met behulp van informatie die in het document is opgeslagen Ontvangst van goederen. Dit gebeurt letterlijk met één muisklik:

Na het uitvoeren van deze opdracht maakt het systeem een ​​nieuw document aan Betaling voor goederen en diensten en vul zijn gegevens in volgens de informatie op het ontvangstbewijs. De gebruiker hoeft alleen specifieke betaalrekeningen te selecteren als de leverancier en onze organisatie er meerdere hebben.

Met het gebaseerde invoermechanisme kunt u dus nieuwe applicatie-oplossingsobjecten (directories, documenten, enz.) maken op basis van informatie die zich in andere bestaande applicatie-oplossingsobjecten bevindt.

Interface-ontwikkeling in 1C bestaat uit twee delen: de ontwikkeling van een menu of bureaublad en de ontwikkeling van 1C-schermformulieren. De vensters waarmee de gebruiker in 1C werkt, worden 1C-schermformulieren of kortweg 1C-formulieren genoemd.

Gebruikers in het programma werken met 1C-formulieren. Bovendien zien gebruikers alleen 1C-formulieren. Daarom is dit vanuit het oogpunt van gebruiksgemak in het programma een van de belangrijke elementen. Tegelijkertijd kunt u meer tijd verspillen aan het ontwikkelen van een 1C-formulier dan aan het programmeren van het meest complexe algoritme.

Een veelgemaakte fout die programmeurs maken, is proberen alles naar hun zin te maken. Maak de achtergrond blauw en de tekst groen. Of geel op zwart. Of hoe hij het leuk vindt in een ander favoriet programma.

Helaas is deze aanpak verkeerd, omdat gebruikers gewend zijn te werken met standaard 1C-formulieren, die de meerderheid vormen in de configuratie. Je eigen fiets tekenen en deze markeren met Courier-inscripties zoals "Copyright Vasya Pupkin" getuigt duidelijk van slechte smaak.

Nu zullen we een kort educatief programma doorlopen over het tekenen van 1C-formulieren.

Wat zijn formulieren 1C

Formulier 1C is een presentatiemethode voor de gebruiker. Normaal gesproken bestaat een formulier uit een reeks velden die moeten worden ingevuld en een reeks knoppen (menuopdrachten) die moeten worden bediend. De meeste 1C-objecten hebben formulier 1C.

De 1C thin client gebruikt ‘gewone’ 1C-formulieren. Dit betekent dat de programmeur eenvoudigweg met de muis een 1C-formulier tekent, net zoals dat in Visual Studio en andere frameworks gebeurt.

De 1C thin client en de 1C webclient gebruiken 1C beheerde formulieren. Dit betekent dat hun grootte, 1C-vorm en de locatie van de velden erop niet met de muis kunnen worden gewijzigd. Ze worden automatisch gegenereerd op basis van de instellingen. In de volgende lessen zullen we het hebben over beheerde 1C-formulieren.

De meeste vormen van 1C-standaardconfiguraties in 1C hebben hun eigen standaardpresentatie die bekend is voor de gebruiker.

Hoe 1C-formulieren werken

De logica (volgorde) van gebruikerswerk in 1C is als volgt:

De gebruiker werkt dus altijd met 1C-formulieren, beginnend met het 1C-lijstformulier en vervolgens naar het 1C-elementformulier. Als de programmeur de formulieren niet heeft getekend, genereert 1C standaard de formulieren. Ze missen natuurlijk de ideale schoonheid en perfectie, maar ze laten je wel werken.

Een automatisch gegenereerd 1C-lijstformulier bevat doorgaans een minimum aan velden (respectievelijk code/naam en datum/nummer). Het automatisch gegenereerde elementformulier bevat doorgaans alle velden (details) van boven naar beneden.

De taak van het 1C-formulier is het openen en wachten op gebruikersacties. Als je handelt, reageer dan. De basis van de 1C-formuliermodule zijn dus gebeurtenishandlers. Dit zijn functies die worden aangeroepen wanneer de gebruiker een actie uitvoert op het 1C-formulier.

Waar bevinden zich 1C-formulieren?

Wanneer u in de 1C Enterprise-modus vrijwel elk 1C-object selecteert (map, document, rapport, verwerking, enz.), wordt de vorm van dit object voor u geopend.

Selecteer in de configurator in het configuratievenster het object dat u nodig hebt, vouw de vertakking uit om de subvertakking 1C Form te zien.

Een andere optie is om de objecteditor te openen (tweemaal met de muis of de cursor te plaatsen en Enter) en naar het tabblad 1C Formulieren te gaan.

Hier is een lijst met 1C-formulieren. Eén van de toegevoegde 1C-formulieren kan worden toegevoegd als het standaardformulier (1C-lijstformulier, 1C-elementformulier, enzovoort).

Creëren van 1C-formulieren

Om een ​​nieuw 1C-formulier toe te voegen, klikt u op de knop Toevoegen (Ins op het toetsenbord). Om een ​​bestaande in te voeren, dubbelklikt u erop met de muis.

De ontwerper zal u vragen om het type 1C-formulier te selecteren - 1C-elementformulier, lijst. Hier kunt u opdrachtpanelen op het 1C-formulier toevoegen of verwijderen. Meestal blijven deze instellingen standaard ongewijzigd.

Het 1C-formulier wordt geopend, standaard ingevuld - alle bestaande details van het 1C-object zijn eraan toegevoegd. U kunt de specifieke lijst met verplichte velden aanvinken op het tweede tabblad van de ontwerper.

Onnodige gegevens kunnen worden verwijderd. Om dit te doen selecteert u één of meerdere velden en drukt u op Del.

Om andere details naar de vrije ruimte te verplaatsen, selecteert u ze op dezelfde manier en sleept u ze met de muis.

Om nieuwe details aan het 1C-formulier toe te voegen, klikt u op de knop in het paneel Gegevensplaatsing (menu Formulier/Gegevensplaatsing), vinkt u de vakjes aan voor de elementen die moeten worden toegevoegd, evenals de “Labels invoegen” en “Automatisch plaatsen” selectievakjes.

Als alternatief kunt u eenvoudigweg een besturingselement toevoegen door op de overeenkomstige knop in het onderstaande paneel te klikken of door Formulier/Insert-besturingselement in het menu te selecteren. Klik twee keer met de linkermuisknop op het bedieningselement (veld) en de eigenschappen ervan worden geopend. De eigenschap “Data” bevat de naam van het attribuut. Hier kunt u deze wijzigen of toewijzen.

De eigenschappen van het besturingselement bevatten ook selectievakjes waarmee u de weergave van het besturingselement kunt bepalen. U kunt selectievakjes gebruiken om knoppen voor selecteren, vervolgkeuzelijsten, wissen, zichtbaarheid en toegankelijkheid in of uit te schakelen.

Bijna alle documentformulieren gebruiken bladwijzers. Het toevoegen van een bladwijzer is hetzelfde als het toevoegen van een ander besturingselement (zie hierboven), alleen hoeft u het besturingselement “Paneel” te selecteren. Om een ​​paneelpagina toe te voegen, klikt u er met de rechtermuisknop op en selecteert u Pagina toevoegen. Andere besturingselementen (velden) kunt u eenvoudigweg naar paneelpagina's slepen en neerzetten.

Om de grootte van het 1C-formulier te wijzigen, verplaatst u eenvoudigweg de cursor naar de rand van het 1C-formulier, klikt u op de linkermuisknop en sleept u eenvoudigweg de rand van het 1C-formulier.

Om formulier 1C te laten werken, d.w.z. heeft iets gedaan als reactie op gebruikersacties - u moet handlerfuncties toevoegen. Voer de eigenschappen in van een willekeurig element (door erop te dubbelklikken met de linkermuisknop) of het 1C-formulier zelf (op dezelfde manier in de formulierkop). Helemaal onderaan het eigenschappenvenster bevindt zich een sectie met de naam “Evenementen”. Selecteer een handig evenement (voor alle velden is dit meestal “Bij Wijzigen”, bij het formulier “Bij Opening”) en klik op de knop met een vergrootglas. De gebeurtenishandler wordt geopend.

Voor knoppen is het toevoegen hetzelfde. Naast willekeurige handlers kunt u echter een van de standaardhandlers voor dit formulier kiezen (voor het directoryformulier zijn dit enkele standaardacties, voor het documentformulier - andere). Selecteer gewoon een van de standaardacties in de eigenschap "Actie" of klik op het kruisje als u uw eigen handler wilt maken.

Waarschijnlijk kunnen geen enkel algoritme de database beschermen tegen fouten die optreden wanneer gebruikers gegevens invoeren. De belangrijkste problemen die verband houden met menselijke onoplettendheid kunnen in de volgende lijst worden geïdentificeerd:

  • Verkeerde objectkeuze;
  • Onjuiste hoeveelheid of typefout in de naam;
  • Duplicatie van directory-elementen, hun niet-uniciteit of verkeerde sortering;
  • Het negeren van het invullen van velden die cruciaal zijn voor een correcte berekening en een soepele werking van het programma.

De oplossing voor het laatste probleem is, voor de achtste versie van het 1C-programma, het controleren of de formuliergegevens zijn ingevuld.

Controle van de voltooiing van een regulier formulier

Wanneer de gebruiker het formulier opent en de startmodus “Normale toepassing” is, worden de vereiste elementen gemarkeerd met een rode stippellijn (Fig. 1).

Zoals uit het bovenstaande voorbeeld blijkt, zijn de verplichte velden in het document “Verkoop van goederen en diensten” “Nummer” en “Tegenpartij”. In dit geval kan het veld “Nummer” niet worden bewerkt. Dit betekent dat wanneer een document in de informatiebank wordt opgenomen, het automatisch wordt ingevuld volgens de nummeringsregels die voor deze organisatie zijn vastgelegd.

Het opnemen van directory-items of het plaatsen van documenten die niet-ingevulde verplichte velden bevatten, zal een uitzondering veroorzaken (Fig. 2).

Rijst. 2

Meer gedetailleerde informatie over welk specifiek veld niet is ingevuld, kunt u zien in het serviceberichtenvenster.

Het teken zelf, dat aangeeft dat het veld moet worden ingevuld, wordt ingesteld in de eigenschappen van het formulierelement. Voor deze:

  1. Open het formulier in de Configurator;
  2. Klik met de rechtermuisknop op het formulierelement en open het venster “Eigenschappen”;
  3. Het is noodzakelijk om de selectievakjes AutoMark Unfilled en AutoSelect Unfilled in het submenu “Gebruik” aan te vinken (Fig. 3);

Directe verificatie wordt in de regel in de objectmodule geschreven.

Voor directory's en niet-geposte documenten is het raadzaam om bij het vastleggen van een element de voltooiingscontroleprocedure op te roepen. Documenten die niet volledig zijn voltooid, als ze worden uitgevoerd, kunnen in de database worden vastgelegd en het is beter om de verificatieprocedure op te roepen vóór de vorming van bewegingen, dat wil zeggen tijdens de uitvoering. Het is raadzaam om controles uit te voeren op de verwerking en rapporten met verplichte velden direct in de knopklikverwerking.

U kunt controleren of de waarde die aan het veld wordt doorgegeven, verschilt van de lege waarde (de standaardwaarde) met behulp van de functie ValueFilled (“Waarde”). Houd er echter rekening mee dat als het veld een samengesteld gegevenstype heeft, het uitvoeren van deze functie een uitzondering zal opleveren.

Validatie in beheerde formulieren

De eigenaardigheden van de werking van het platform in de client-serverversie laten ook hun stempel op de vulcontrole.

Eerst moet u begrijpen welke procedure volgt bij het invoeren van een object in deze bedieningsmodus.

Dus nadat u op de knop "Opnemen", "OK", "Pass" hebt geklikt:

  1. Op de cliënt wordt de procedure “Vóór opname” aangeroepen;
  2. De gegevens worden naar de server overgebracht en de gebeurtenissen die in de formuliermodule op de server zijn gespecificeerd, vinden plaats (hier kunt u de ProcessingFillingCheckOnServer-procedure uitvoeren);
  3. De formuliergegevens worden overgebracht naar de objectmodule op de server (het wordt mogelijk om de standaardprocedure ProcessingCheckFill te starten);
  4. Gegevens uit de module worden teruggestuurd naar de formuliermodule op de server en de BeforeWritingOnServer-procedure vindt plaats;
  5. De gegevens worden teruggestuurd naar de objectmodule en er vindt nog een BeforeWrite-procedure plaats;
  6. Het object wordt rechtstreeks naar de database geschreven.

Op elk punt in dit diagram kunt u de functie CheckFill() invoegen. Na de details te hebben doorgenomen, in de eigenschappen waarvan het attribuut "Invulcontrole" de waarde "Geef een fout" heeft (Fig. 4), zal deze functie, als ten minste één ervan niet is ingevuld, "False" retourneren .

Verschillen tussen de handlers ProcessingFillCheck() en ProcessingFillCheckOnServer().

Omdat de interface van een beheerde applicatie zowel objectdetails als directe formulierdetails kan bevatten, zijn deze twee procedures gescheiden. Tegelijkertijd zijn ze vergelijkbaar in parameters die kunnen worden doorgegeven aan de handlers:

  1. Weigering (het resultaat van de controle wordt hier verzonden);
  2. Aangevinkte details (gegevenstype – array, indien niet ingevuld, worden alle details waarvoor “Check vulling” is ingesteld in de eigenschappen gecontroleerd, anders worden programmatisch geselecteerde details verwerkt).

Met de procedure ProcessingFillingCheckOnServer() kunt u details controleren die niet rechtstreeks verband houden met het object dat wordt bewerkt. Elke programmeur bepaalt zelf wat en in hoeverre hij wil controleren.

De procedure ProcessingCheckFill() controleert de basisgegevens.

Heel vaak moet u tijdens het werken in het 1C-programma snel meerdere documenten invoeren of nieuwe objecten aan mappen toevoegen (type artikel, organisatie, magazijn, kassa, enz.). Tegelijkertijd heeft niet iedereen inzicht in hoe de invoer van basiswaarden kan worden geautomatiseerd, zodat bij het maken ervan de vereiste waarden onmiddellijk in de velden worden vervangen. Hoe je dit doet, vertel ik je in dit artikel.
Het 1C-programma beschikt over mechanismen waarmee u snel de waarden van details in documenten en naslagwerken kunt invullen. Op basis van hun actie kunnen ze worden onderverdeeld in de volgende typen:

  • Vervanging van één waarde
  • Een waarde vervangen door selectie
  • Statistische details invullen
  • Vervanging van eerder ingevoerde gegevens
  • Waarden vervangen met behulp van een patroon
  • Een nieuw document invoeren door te kopiëren

Vervanging van een enkele waarde waarvoor de gebruiker rechten heeft.

Stel dat uw organisatie drie magazijnen heeft. Deze worden in de database ingevoerd. Tegelijkertijd mag de manager slechts goederen van één persoon verkopen. Bij het aanmaken van een nieuw document wordt dit magazijn automatisch ingevoegd. Dit werkt op basis van de ingestelde rechten van de gebruiker. Dat wil zeggen, door de rechten uit te schakelen op objecten waarmee de gebruiker niet werkt, kunt u de gegevensinvoer automatiseren.

Een waarde vervangen op basis van de selectie die is opgegeven in het lijstformulier.

Als de lijst is ingesteld op selectie op een bepaald detail (kassa, bankrekening, magazijn), wordt dit detail automatisch ingevuld in het nieuwe document. U stelt bijvoorbeeld de selectie per kassa in in de vorm van een lijst met kassadocumenten. Wanneer u een nieuw betaaldocument afgeeft, wordt informatie over de geselecteerde kassa automatisch uit de lijst gehaald. En omdat er voor de kassa een organisatie is opgegeven, worden gegevens over de organisatie automatisch ingevuld. U kunt selecties gebruiken in elke lijst met documenten.

Statistische details invullen.

Het 1C-programma houdt statistieken bij over de invoer van basiswaarden voor elke gebruiker. Als u bij het aanmaken van een nieuw document twee keer dezelfde organisatie, divisie, magazijn, zakelijke transactie, etc. hebt ingevoerd, analyseert het programma de laatst ingevoerde waarden. Het statistische vulalgoritme ‘past’ zich dus automatisch aan elke gebruiker aan.
Als de gebruiker deze keten in een nieuw document schendt, zal het programma dit begrijpen en na een tijdje nieuwe waarden gaan vervangen, maar in het eerste dergelijke document zullen de waarden niet worden vervangen.
Het invullen van eerder ingevoerde gegevens bij het selecteren van de waarde van een ander detail is mogelijk als u bijvoorbeeld een handelsovereenkomst of contract selecteert waarbij alle hoofdvelden zijn ingevuld (magazijn, betalingsschema, prijzen, etc.). Bij het vastleggen van een overeenkomst of contract in een document worden de gegevens ingevuld volgens de volgende regels:

alle gegevens die in de overeenkomst of het contract zijn vermeld, worden ingevuld;

als een waarde (bijvoorbeeld verdeling) niet in de overeenkomst of het contract is gespecificeerd, wordt deze waarde ingevuld volgens de statistieken. Als bij het invoeren van een nieuw document de waarden zijn ingevuld volgens de statistieken, worden ze opnieuw gevuld als ze in de overeenkomst of het contract zijn gedefinieerd.

Vervanging van waarden met behulp van een sjabloon.

Houd er rekening mee dat wanneer een nieuw type item wordt gemaakt, u standaardwaarden kunt opgeven die in nieuwe objecten worden vervangen. Bij het registreren van een nieuw artikel voor dit type artikel worden deze waarden automatisch ingevuld. Een ander voorbeeld is de automatische vervanging van informatie over een afdeling in een document als de gebruiker die het document opstelt, informatie heeft over de afdeling die op de gebruikerskaart is gedefinieerd.

Een nieuw document invoeren door te kopiëren.

Alles is hier eenvoudig. Als de gebruiker al een soortgelijk document heeft ingevoerd, kan dit worden gekopieerd en kunnen de gewijzigde gegevens worden gecorrigeerd. Controleer alle details en let vooral op details zoals de datum.

Hier volgen vijf belangrijke manieren om het gemakkelijker te maken vergelijkbare documenten en naslagwerken in te voeren. Zorg ervoor dat u ze in uw dagelijkse werk gebruikt

Hoe voer je snel de waarde van details in 1C in?

Met het 1C:Enterprise-platform kunt u programmatisch elementen van een beheerd formulier toevoegen en wijzigen. Laten we uitzoeken waarom dit nodig zou kunnen zijn.

In verschillende gevallen kan een softwarematige aanpassing van het formulier nodig zijn:

  • Bij het finaliseren van standaardconfiguraties om de daaropvolgende updateprocedure te vergemakkelijken. In dit geval wordt alleen de formuliermodule gewijzigd. Modules zijn veel gemakkelijker te updaten dan formulieren.
  • Bij het implementeren van enkele veelvoorkomende algoritmen. In het subsysteem ‘Verbod op het bewerken van objectdetails’ kan bijvoorbeeld programmatisch een knop worden gemaakt voor alle objecten die met het subsysteem zijn verbonden, om de mogelijkheid te bieden details te bewerken.
  • Bij het implementeren van enkele specifieke algoritmen. In de nomenclatuurdirectory worden bijvoorbeeld velden gemaakt voor het bewerken van aanvullende details.

In een beheerd formulier kunt u het volgende programmatisch toevoegen, wijzigen en verwijderen:

  • benodigdheden;
  • lokale teams;
  • elementen.

Al deze bewerkingen zijn alleen mogelijk op de server.

Programmatische hervorming heeft beperkingen:

  • U kunt alleen programmatisch toegevoegde details/opdrachten/elementen verwijderen. U kunt in de configurator gemaakte objecten niet programmatisch verwijderen.
  • U kunt een attribuut niet als hoofdattribuut toewijzen.

Formulieropdrachten wijzigen

Om de samenstelling van opdrachten voor een object te beheren Beheerdformulier er is een collectie Teams

    Toevoegen (< ИмяКоманды >)

    Hoeveelheid ()

    Vinden (< ИмяКоманды >)

    Verwijderen (< Команда >)

De Teams-collectie is beschikbaar op zowel de client als de server. U kunt de verzameling (Add() en Delete() methoden) alleen op de server wijzigen. U kunt het aantal elementen zoeken en ophalen (de methoden Find () en Count ()), zowel op de client als op de server.

Laten we, als voorbeeld van het werken met formulieropdrachten, een nieuw ChangeHistory-commando maken met de kop "ChangeHistory...", waarmee de handler wordt aangeroepen Weergavegeschiedenis(). De creatie vindt plaats wanneer het formulier wordt geopend.

&Op server
Procedure WhenCreatingOnServer (fout, standaardverwerking)
Team = Teams. Toevoegen( "Geschiedenis van veranderingen");
Team . Actie = ;
Team . Titel = "Geschiedenis van veranderingen...";
EindeProcedure
&OnClient
Procedure Connectable_DisplayHistory(Command)
// opdrachtacties
EindeProcedure

De opdrachthandler moet zich op een formulier bevinden en een &OnClient-compilatierichtlijn hebben.

Formuliergegevens wijzigen

Het lezen van de samenstelling van de formulierdetails wordt uitgevoerd door de functie Details ophalen(< Путь >) retourneert een array van het type FormAttributes. De functieparameter specificeert het pad naar het bovenliggende attribuut (als een tekenreeks). Als de parameter wordt weggelaten of een lege tekenreeks wordt opgegeven, worden de details op het hoogste niveau geretourneerd.

Het wijzigen van de details gebeurt met behulp van de methode Wijzig details(<Details toegevoegd>, <Verwijderbare details>) voorwerp Beheerdformulier. Naar parameters Details toegevoegd En Verwijderbare details Arrays met elementen van het type Form Attributes worden verzonden.

Aandacht!

Het proces van het veranderen van de samenstelling van details is behoorlijk arbeidsintensief. Het formulier wordt daadwerkelijk opnieuw gemaakt. In dit opzicht wordt het werken met formulierdetails in batchmodus uitgevoerd.

Laten we een nieuw formulierkenmerk maken met de naam Koper:


AddedDetails = Nieuwe array;
Details toegevoegd. Add(Nieuwe formulierkenmerken(“Koper”, Nieuwe Typebeschrijving (“Directory Link. Tegenpartijen”), “Klant”));

// Wijzigingen in de samenstelling van details
);

Formulierelementen wijzigen

Om de samenstelling van elementen van een object te controleren Beheerdformulier er is een collectie Elementen. De collectie kent verschillende methoden:

    Invoegen (< Имя>, < ТипЭлемента>, < Родитель>, < Элемент >)

    Toevoegen (< Имя>, < ТипЭлемента>, < Родитель >)

    Hoeveelheid ()

    Vinden (< Имя >)

    Beweging(< Элемент>, < Родитель>, < МестоРасположения >)

    Verwijderen (< Элемент >)

De Items-collectie is beschikbaar op zowel de client als de server. Een verzameling wijzigen (Insert methoden () , Toevoegen () , Verplaatsen () en Verwijderen () ) zijn alleen beschikbaar op de server. U kunt het aantal elementen zoeken en ophalen (de methoden Find () en Count ()), zowel op de client als op de server. Verzamelelementen kunnen zijn:

  • FormulierGroep;
  • FormulierTabel;
  • Formulierveld;
  • Formulierknop.

U kunt gebeurtenishandlers programmatisch toewijzen aan formulierelementen. Voor deze doeleinden is de methode bedoeld SetActie(< ИмяСобытия>, < Действие >) .

Laten we eens kijken naar enkele van de meest voorkomende voorbeelden in de praktijk van het werken met opdrachten, details en formulierelementen.

Een opdracht en de bijbehorende knop toevoegen:

// Maak een opdracht
Team = Teams. Toevoegen( "Geschiedenis van veranderingen");
Team . Actie = "Plug-in_DisplayHistory"; // Het formulier moet een procedure bevatten met de opgegeven naam
Team . Rubriek = "Geschiedenis van veranderingen...";
// Maak een knop en koppel deze aan een opdracht
Element = Artikelen. Toevoegen( "Geschiedenis van veranderingen", Type("FormulierKnop" ));
Element.CommandName = "Geschiedenis van veranderingen";

Een attribuut en het bijbehorende invoerveld toevoegen:

// Beschrijving van de toegevoegde details
AddedDetails = Nieuwe array;
Details toegevoegd. Toevoegen(Nieuwe formulier rekwisieten (“Koper”, Nieuwe typebeschrijving ( "DirectoryLink. Tegenpartijen"), "Klant" ));
// De samenstelling van details wijzigen
Wijzigingsdetails(details toegevoegd);
// Een invoerveld maken en verbinding maken met het attribuut
Element = Artikelen. Add("Koper" , Type("Formulierveld" ));
Element . Weergave = Formulierveldweergave. Invoerveld;
Element . PadNaarGegevens= "Koper" ;

Een gebeurtenishandler aan een formulierelement toewijzen:

ArtikelKlant. SetActie("Als het verandert", "Connected_BuyerOnChange");

&OnClient
Procedure Connected_BuyerOnChange(Element)
// Gebeurtenisacties
EindeProcedure

Aandacht!

Procedures die zijn ingesteld als gebeurtenishandlers vanuit code met behulp van de methode SetActie(), wordt aanbevolen om het voorvoegsel Connectable_ in te stellen.

Aandacht!

U kunt de verwerking downloaden met voorbeelden van programmatisch zoeken en wijzigen van details, opdrachten en elementen van een beheerd formulier.



Vond je het artikel leuk? Deel het
Druk dit artikel af
Bovenkant