Grafische interfaces en tools voor hun ontwikkeling. De klasse XmGadget bevat subklassen

Het creëren van een grafische gebruikersinterface, waarin je grafische elementen moet plaatsen, de algemene structuur en stroom van applicaties moet kiezen, moedigt de programmeur aan om op een bepaalde manier een artiest te worden. Er zijn geen standaardregels die kunnen helpen bij het maken van presentaties, het plaatsen van elementen en het organiseren van een structuur. Een goede grafische gebruikersinterface wordt beschouwd als een kunstwerk. Omdat interface-ontwerp minder een wetenschap dan een kunst is, zijn er op dit gebied geen vaste regels om te volgen. Te veel opties worden bepaald door de aard van de toepassing, gebruikers en context.

Er zijn echter een aantal best practices die ontwikkelaars moeten volgen om het ontwerp van de interface te vergemakkelijken.

¦ Complexe structuren (zoals een boom) voor het koppelen van verschillende menu's moeten worden vermeden. Het is het beste om niet meer dan zes menu's in één menubalk op te nemen, die elk niet meer dan zes opties bevatten.

¦ Objecten moeten een consistente waarde hebben. Om bijvoorbeeld alle pictogrammen te activeren, dubbelklikt u met de muis. Sommige moderne interfaces volgen deze aanbeveling niet en bevatten pictogrammen die pas van kracht worden nadat de gebruiker sleept

bezwaar tegen hen. De schuifbalken mogen alleen worden gebruikt om te scrollen, en als vooraf gebouwde bibliotheekpictogrammen worden gebruikt, moeten deze zorgvuldig worden gecontroleerd om ervoor te zorgen dat bijvoorbeeld het printerpictogram altijd wordt gebruikt om af te drukken.

¦ Dubbelklik met de muis wanneer u alle pictogrammen activeert, zoals hierboven vermeld. En om een ​​vergelijkbaar resultaat te krijgen voor de pictogrammen van objecten die worden geactiveerd door een enkele muisklik, is het raadzaam om ook een dubbelklik te programmeren. Veel opties, zoals die in het menu van het Configuratiescherm, zien eruit als pictogrammen, maar zijn objecten die met een enkele muisklik worden geactiveerd. Bedenk hoe gebruikers zich zouden kunnen gedragen wanneer ze met dergelijke objecten werken (dwz laat ze erop dubbelklikken) en help hen het gewenste resultaat te bereiken.

¦ Interfacemenu's moeten de huidige status van het systeem weergeven. Een van de belangrijkste principes die de meeste makers van grafische gebruikersinterfaces leiden, is om toegang te bieden tot alle interfacetools, ongeacht de acties van de gebruiker. De onderste regel komt goed overeen met eenvoudige toepassingen, maar is minder nuttig voor complexere.

¦ Elementen die in verschillende menu's voorkomen, moeten op één plaats worden geplaatst. De knoppen OK en Annuleren moeten bijvoorbeeld altijd hetzelfde ten opzichte van elkaar worden geplaatst en dezelfde plaats in verschillende dialoogvensters innemen.

¦ Je moet niet streven naar consistentie van menu-items als dit niet overeenkomt met de mening van gebruikers. Gebruikers merken bijvoorbeeld dat het slepen van een bestand van de ene map naar de andere op hetzelfde apparaat ertoe leidt dat het bestand naar de tweede map wordt verplaatst.

Ze geloven ook dat als je een bestand naar een ander apparaat sleept, daar een kopie van het origineel wordt gemaakt. Hieruit volgt dat de implementatie van de sleepfunctie inconsistent zal zijn, d.w.z. verschillend in verschillende gevallen. Dit is echter de wens van de gebruikers, waarmee rekening moet worden gehouden. Streven naar consistentie is slechts een aanbeveling, geen vaste regel.

Ergonomische vereisten voor grafische gebruikersinterfaces bleken duidelijk niet voldoende bij de ontwikkeling van "multimedia" (multimedia) - interactieve systemen die werken met stilstaande beelden en bewegende video, geanimeerde computergraphics en tekst, spraak en geluid van hoge kwaliteit. Ergonomisch onderzoek en ontwikkeling van deze systemen is een complexe en professioneel spannende taak.

De meeste projectmanagers voor applicatieontwikkeling, merkt B. Tognazzini op, wachten op de voltooiing van het project om aan de interface te gaan werken. Dit doet denken aan het bouwen van een huis, wanneer de architect wordt uitgenodigd nadat het bouwframe is geplaatst. Alle ontwikkelaars hebben een andere benadering van het organiseren van het proces van het maken van een interface. Er zijn echter algemene punten waar alle ontwikkelaars zich aan moeten houden:

1) het doel van het softwareproduct in detail begrijpen door nauw met gebruikers te communiceren, vaak hele werkdagen met hen door te brengen, om hun werkstijl en individuele gewoonten beter te begrijpen;

2) het maken van een interface is niet het werk van één persoon, maar van vertegenwoordigers van drie gebieden: een specialist die de mening van gebruikers over de belangrijkste elementen van de interface te weten komt en deze beschrijft; interface-ontwikkelaar en grafische maker;

3) er dient één ervaren persoon te worden voorgedragen als interface-expert en intermediair tussen de werkgroep en gebruikers;

4) controleren, een lay-out maken en opnieuw controleren, want zelfs als het doel van het softwareproduct volledig wordt begrepen, is het onmogelijk om alle behoeften van gebruikers te voorzien.

Interfaces moeten worden gemaakt door mensen, vindt D.Norman, die niet deelnemen aan de ontwikkeling van de applicatie, omdat ontwikkelaars te veel weten over de principes van het programma en dit belemmert het maken van een interface alleen maar. De deugden van een grafische gebruikersinterface worden algemeen erkend, en misschien poëtisch
daarom is het niet het voorwerp van serieuze analyse geworden. De traditionele regel van de softwareontwikkelaar, volgens welke het leergemak de gebruiker vaak verhindert om vervolgens alle functies van het programma volledig te gebruiken, is ook relevant voor de grafische interface. Een voorbeeld is de ontwikkeling van een project voor een Amerikaanse verzekeringsmaatschappij, die één verzekeringsapplicatie voor Macintosh gebruikte, voorzien van een mooie interface, heel gemakkelijk te leren. Na twee jaar werk zijn eindgebruikers echter zo vertrouwd geraakt met de verschillende functies van deze applicatie dat de grafische gebruikersinterface ze alleen maar vertraagde. De keuze voor een grafische interface moet worden bepaald door de aard van de taak van de gebruiker.

Bijgedragen door Saleem Gul en Tomas Pavek

In deze zelfstudie leert u hoe u een eenvoudige grafische gebruikersinterface maakt en er een aantal eenvoudige back-endfunctionaliteit aan toevoegt. We zullen in het bijzonder kijken naar de code die het gedrag van knoppen en velden op een Swing-formulier definieert.

We zullen de lay-out en structuur van de GUI opsplitsen en vervolgens enkele knoppen en tekstvelden toevoegen. Tekstvelden zijn ontworpen om gebruikersinvoer te ontvangen en het resultaat van het programma weer te geven. De knop start de werking van de functies die in het clientgedeelte van het programma zijn ingebouwd. De applicatie die u maakt, is een eenvoudige maar volledig functionele rekenmachine.

Voor een meer gedetailleerde gids over de ontwikkelfuncties van GUI Builder, inclusief videodemonstraties van verschillende ontwerpfuncties, zie .

Geschatte duur: 20 minuten

Oefening 1: Een project maken

De eerste stap is het maken van een IDE-project voor de applicatie die u aan het ontwikkelen bent. Laten we het project NumberAddition noemen.

1. Kies Bestand > Nieuw project. U kunt ook op het pictogram Nieuw project in de werkbalk van de IDE klikken.
2. Selecteer in het gebied Categorieën het Java-knooppunt. Selecteer in het gebied "Projecten" de optie "Java-toepassing". Klik volgende".
3. Voer NumberAddition in het veld Projectnaam in en geef een pad op, zoals uw thuismap, als de locatie van het project.
4. Schakel het selectievakje "Gebruik een aparte map voor het opslaan van bibliotheken" in en geef de locatie van de bibliothekenmap op (optioneel). Voor meer informatie, zie Een bibliotheek delen met andere gebruikers in het document Applicaties ontwikkelen met NetBeans IDE.
5. Verwijder het selectievakje "Maak hoofdklasse" als dit is aangevinkt.
6. Klik op de knop "Voltooien".

Oefening 2: De frontend maken

Om door te gaan met het maken van de interface, moet u een Java-container maken die de andere vereiste GUI-elementen bevat. In deze actie wordt de container gemaakt met behulp van het JFrame-element. De container wordt in een nieuw pakket geplaatst, dat wordt weergegeven onder het knooppunt "Bronpakketten".

Een JFrame-container maken

1. Klik in het venster Projecten met de rechtermuisknop op het knooppunt NumberAddition en selecteer Nieuw > Overige.
2. Selecteer in het dialoogvenster voor het maken van bestanden de categorie Swing GUI Forms en het bestandstype JFrame Form. Klik volgende".
3. Voer NumberAdditionUI in als de klassenaam.
4. Kies dan voor het my.numberaddition pakket.
5. Klik op de knop "Voltooien".

De IDE maakt het NumberAdditionUI-formulier en de NumberAdditionUI-klasse in de NumberAddition-toepassing en opent het NumberAdditionUI-formulier in de GUI Builder. Het my.NumberAddition-pakket vervangt het standaardpakket.

Elementen toevoegen: de frontend maken

Vervolgens wordt met behulp van het "Palet"-venster de externe interface van de applicatie gevuld met een JPanel. Daarna worden drie JLabel-elementen (tekstlabels), drie JTextField-elementen (tekstvelden) en drie JButton-elementen (knoppen) toegevoegd. Als je nog niet eerder met de GUI Builder hebt gewerkt, zie Een swing GUI ontwikkelen in NetBeans IDE voor informatie over het plaatsen van componenten.

Na het slepen en plaatsen van de bovenstaande elementen, zou het JFrame-element eruit moeten zien als de onderstaande afbeelding.

Als de IDE geen paletvenster in de rechterbovenhoek heeft, selecteert u Venster > Palet.

1. Selecteer om te beginnen een paneel uit de categorie Swing Containers in het palet en sleep het naar het JFrame.
2. Het JPanel wordt gemarkeerd. Ga naar het venster "Eigenschappen" en klik op de knop met het weglatingsteken (...) naast het veld "Rand" om een ​​randstijl te selecteren.
3. Selecteer in het dialoogvenster "Rand" "TitledBorder" uit de lijst en voer Nummertoevoeging in het veld "Titel" in. Klik op de knop OK om uw wijzigingen op te slaan en het dialoogvenster te sluiten.
4. Het scherm zou nu een leeg "JFrame"-element moeten weergeven met de titel "Number Addition", zoals weergegeven in de afbeelding. Voeg er drie JLabels, drie JTextFields en drie JButtons aan toe, zoals weergegeven.

Elementen hernoemen

Deze stap hernoemt de elementen die aan het JFrame-element zijn toegevoegd.

1. Dubbelklik op jLabel1 en verander ntrcn ("text" eigenschap) in First Number .
2. Dubbelklik op jLabel2 en verander de tekst in Tweede nummer.
3. Dubbelklik op jLabel3 en verander de tekst in Resultaat .
4. Verwijder de standaardtekst uit jTextField1 . De weergegeven tekst kan worden geconverteerd naar bewerkbaar. Klik hiervoor met de rechtermuisknop op het tekstveld en selecteer "Tekst bewerken" in het pop-upmenu. Hiervoor moet u mogelijk de oorspronkelijke grootte van jTextField1 herstellen. Herhaal deze stap voor de velden jTextField2 en jTextField3.
5. Wijzig de weergavetekst van jButton1 in Wissen . (Als u de knoptekst wilt wijzigen, klikt u met de rechtermuisknop op de knop en kiest u Tekst bewerken. U kunt ook op de knop klikken, pauzeren en opnieuw klikken.)
6. Wijzig de weergavetekst van jButton2 in Toevoegen.
7. Verander de displaytekst van jButton3 in Exit.

Nu zou de voltooide grafische interface eruit moeten zien zoals in de onderstaande afbeelding:

Oefening 3: Functionaliteit toevoegen

In deze oefening voegt u de vereiste functionaliteit toe aan de knoppen "Toevoegen", "Wissen" en "Afsluiten". De velden jTextField1 en jTextField2 worden gebruikt voor gebruikersinvoer en jTextField3 wordt gebruikt om het resultaat van het programma weer te geven. Het gemaakte programma is een eenvoudige rekenmachine. Dus laten we beginnen!

Functionaliteit toevoegen aan de knop "Afsluiten"

Om ervoor te zorgen dat de knoppen functioneel worden, moet aan elk van hen een gebeurtenishandler worden toegewezen die verantwoordelijk is voor het reageren op gebeurtenissen. In ons geval is het vereist om de gebeurtenis van de knopklik te identificeren - door te klikken met de muis of door het toetsenbord te gebruiken. Daarom zal de "ActionListener"-interface worden gebruikt, ontworpen om "ActionEvent"-gebeurtenissen af ​​te handelen.

1. Klik met de rechtermuisknop op de knop "Afsluiten". Selecteer Gebeurtenissen > Actie > actieUitgevoerd in het pop-upmenu. Houd er rekening mee dat het menu nog vele andere evenementen bevat waarop het programma kan reageren! Wanneer de actionPerformed-gebeurtenis is geselecteerd, zal de IDE automatisch een ActionListener-listener toevoegen aan de knop Exit en een handlermethode maken om de actionPerformed-listenermethode af te handelen.
2. De IDE opent automatisch het broncodevenster en laat u zien waar u de actie wilt invoegen die de knop moet uitvoeren wanneer erop wordt geklikt (met behulp van de muis of het toetsenbord). Het venster "Broncode" moet de volgende regels bevatten: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( //TODO voeg hier uw verwerkingscode toe: )
3. Laten we nu de code toevoegen voor de actie die de knop "Afsluiten" moet uitvoeren. Vervang de TODO-regel door System.exit(0); . De voltooide "Exit"-knopcode zou er als volgt uit moeten zien: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( System.exit(0); )

Functionaliteit toevoegen aan de knop "Wissen"

1. Klik met de rechtermuisknop op de knop "Wissen" (jButton1). Selecteer in het menu dat verschijnt "Evenementen > Actie > uitgevoerde actie".
2. Als u op de knop "Wissen" klikt, moet alle tekst uit alle "jTextField"-tekstvelden worden verwijderd. Om dit te doen, voegt u een code toe die lijkt op die hierboven. De voltooide broncode zou er als volgt uit moeten zien: private void jButton1ActionPerformed(java.awt.event.ActionEvent evt)( jTextField1.setText(""); jTextField2.setText(""); jTextField3.setText(""); )

Deze code verwijdert de tekst van alle drie de JTextFields en laat ze leeg.

Functionaliteit toevoegen aan de knop "Toevoegen"

De knop "Toevoegen" moet drie dingen doen.

1. Het neemt eerst de gegevens die door de gebruiker zijn ingevoerd in jTextField1 en jTextField2 en converteert deze van het type "String" naar het type "Float".
2. Het zal dan de optelling van de twee getallen uitvoeren.
3. En ten slotte zal het de som naar een String converteren en in jTextField3 plaatsen.

1. Klik op het tabblad Ontwerpen bovenaan de werkruimte om terug te keren naar het scherm Formulierontwerp.
2. Klik met de rechtermuisknop op de knop "Toevoegen" (jButton2). Selecteer Gebeurtenissen > Actie > actieUitgevoerd in het pop-upmenu.
3. Voeg de code toe voor de acties die de knop "Toevoegen" moet uitvoeren. De voltooide broncode zou er als volgt uit moeten zien: private void jButton2ActionPerformed(java.awt.event.ActionEvent evt)( // Eerst definiëren we float-variabelen. float num1, num2, resultaat; // We moeten de tekst ontleden naar een type float num1 = Float.parseFloat(jTextField1.getText()); num2 = Float.parseFloat(jTextField2.getText()); // Nu kunnen we de optelling uitvoeren. result = num1+num2; // We zullen nu de waarde doorgeven van resultaat naar jTextField3. // Tegelijkertijd gaan we // de waarde van resultaat wijzigen van een float naar een string. jTextField3. setText (String. valueOf (result)); )

Nu is het programma helemaal klaar en kun je beginnen met het bouwen en uitvoeren ervan.

Oefening 4: Uitvoering van het programma

Ga als volgt te werk om een ​​programma in de IDE uit te voeren:

1. Selecteer Uitvoeren > Hoofdproject uitvoeren (of druk op F6).

   Opmerking. Als u een venster opent dat aangeeft dat Project NumberAddition geen hoofdklasse heeft, selecteert u my.NumberAddition.NumberAdditionUI als de hoofdklasse in hetzelfde venster en klikt u op OK.

Om het programma buiten de IDE uit te voeren, doet u het volgende:

Na een paar seconden wordt de applicatie gestart.

Opmerking. Als dubbelklikken op een JAR-bestand de toepassing niet start, raadpleeg dan de JAR-bestandskoppelingen configureren voor uw besturingssysteem voor meer informatie.

U kunt de toepassing ook uitvoeren vanaf de opdrachtregel.

Ga als volgt te werk om de toepassing vanaf de opdrachtregel uit te voeren:

1. Roep een opdrachtprompt of terminalvenster op.
2. Wijzig op de opdrachtregel de huidige directory in de directory NumberAddition/dist.
3. Voer bij de opdrachtprompt de volgende instructie in: java -jar NumberAddition.jar

   Opmerking. Zorg ervoor dat my.NumberAddition.NumberAdditionUI is ingesteld als de hoofdklasse voordat u de toepassing uitvoert. Om dit te controleren, klikt u met de rechtermuisknop op het NumberAddition-projectknooppunt in het deelvenster Projecten, selecteert u Eigenschappen in het pop-upmenu en selecteert u de categorie Uitvoeren in het dialoogvenster Projecteigenschappen. In het veld Hoofdklasse moet my.numberaddition.NumberAdditionUI worden weergegeven.

Mechanisme voor gebeurtenisafhandeling

In deze zelfstudie werd gekeken naar het reageren op een eenvoudige gebeurtenis met een klik op een knop. Er zijn veel gebeurtenissen waarop een applicatie kan reageren. U kunt de lijst met beschikbare gebeurtenissen in de IDE die door GUI-elementen kunnen worden afgehandeld als volgt bekijken:

1. Keer terug naar het bestand NumberAdditionUI.java in de editor. Klik op het tabblad "Ontwerp" om de GUI-structuur in GUI Builder te bekijken.
2. Klik met de rechtermuisknop op een GUI-element en selecteer "Evenementen" in het menu dat verschijnt. Nu kunt u eenvoudig de inhoud van het menu verkennen zonder items te selecteren.
3. Als alternatief kunt u "Eigenschappen" selecteren in het menu "Venster". Klik in het venster Eigenschappen op het tabblad Gebeurtenissen. Op het tabblad Gebeurtenissen kunt u de gebeurtenishandlers bekijken en wijzigen die zijn gekoppeld aan het momenteel actieve GUI-element.
4. De toepassing kan ook reageren op toetsaanslagen, enkele, dubbele of driedubbele klikken, de muisaanwijzer verplaatsen, het formaat van het venster wijzigen en de invoerfocus verplaatsen. Met het menu "Evenementen" kunt u automatisch gebeurtenishandlers maken voor al deze gebeurtenissen. De meest voorkomende hiervan is het evenement "Actie". (Zie voor meer informatie de beste praktijken voor het afhandelen van gebeurtenissen in de Sun Java Events Tutorial.)

Hoe worden evenementen afgehandeld? Telkens wanneer een gebeurtenis wordt geselecteerd in het gebeurtenismenu, maakt de IDE automatisch een zogenaamde gebeurtenislistener en koppelt deze aan de ontwikkelaarscomponent. Volg deze stappen voor meer informatie over het proces voor het afhandelen van gebeurtenissen.

1. Keer terug naar het bestand NumberAdditionUI.java in de editor. Klik op het tabblad "Bron" om de GUI-broncode te bekijken.
2. Scroll naar beneden en bekijk de geïmplementeerde jButton1ActionPerformed() , jButton2ActionPerformed() en jButton3ActionPerformed() methoden. Deze methoden worden event-handlers genoemd.
3. Ga nu verder met de methode initComponents(). Als deze methode niet aanwezig is, zoekt u naar de regel Generated Code en klikt u op het +-teken naast deze regel om de verborgen methode initComponents() weer te geven.
4. Let op het blauwe vak rond de methode initComponents(). Deze code is automatisch gegenereerd door de IDE en kan niet door de gebruiker worden gewijzigd.
5. Kijk nu naar de initComponents() methode zelf. Het bevat onder andere code die GUI-elementen initialiseert en op het formulier plaatst. Deze code wordt automatisch gegenereerd en bijgewerkt wanneer u elementen in de ontwerpmodus plaatst en wijzigt.
6. Zoek in de methode initComponents() het volgende fragment: jButton3.setText("Exit"); jButton3.addActionListener(new java.awt.event.ActionListener() ( public void actionPerformed(java.awt.event.ActionEvent evt) (jButton3ActionPerformed(evt); )));

   Op dit punt wordt een gebeurtenislistener "ActionListener" toegevoegd aan het GUI-element, in dit geval jButton3 . De "ActionListener"-interface heeft een "actionPerformed"-methode van het "ActionEvent"-object, die wordt geïmplementeerd door eenvoudigweg de jButton3ActionPerformed-gebeurtenishandler aan te roepen. Deze knop reageert nu op actiegebeurtenissen. Elke keer dat op de knop wordt geklikt, wordt een "ActionEvent" geactiveerd en doorgegeven aan de "actionPerformed"-methode van de gebeurtenislistenerinterface, die de code uitvoert die door de ontwikkelaar voor die gebeurtenis in de gebeurtenishandler is geleverd.

7. Curriculum Java GUI-toepassingen

Met de komst van verschillende hulpmiddelen voor het ontwikkelen van visuele toepassingen is het schrijven van grafische programma-interfaces een soort kinderspel geworden. Ik prikte met de muis - er verscheen een mal, prikte er een tweede keer in - de knop was getekend. Het lijkt mij dat velen nu niet nadenken over een andere manier van programmeren in een grafische omgeving. Tegen vooruitgang kun je natuurlijk niet pleiten; bij het schrijven van grote projecten komen al deze gemakken goed van pas. Maar daar gaat het gesprek niet over. Soms komt het tot het absurde, een primitieve applicatie wordt geschreven met MFC, VCL enz. Dergelijke programma's eten geheugen als termieten en nemen extra schijfruimte in beslag met hun dikke lichaam. In de regel "wegen" MFC/VCL-analogen tien tot twintig keer meer dan programma's die in pure API zijn geschreven. Hoe zit het met Visual Basic (God vergeef me voor deze zin) met zijn msvbvmXX.dll? Ja, en systeembronnen worden veel meer (meerdere keren) verbruikt. Arme gebruikers, die zichzelf bier onthouden, sparen bankbiljetten om nieuwe hardware te kopen. Is het niet jammer voor de armen? Drinken niet alleen programmeurs bier? Er is nog een positief moment in API-codering, de programmeur komt dichter bij het besturingssysteem. Dienovereenkomstig begrijpt en controleert het het beter. En ja, het is gewoon hartstikke leuk. Ik herhaal, al het bovenstaande is specifiek van toepassing op kleine, eenvoudige programma's, bij grote projecten is alles compleet anders.

Ik hoop dat ik je heb overtuigd. Gaan.

We zullen kijken naar het maken van een eenvoudige vensterinterface met minimale functionaliteit. Het wordt een eenvoudig venster met twee invoervelden en twee knoppen. Wanneer u op de knop "Kopiëren" klikt, wordt de tekst van het eerste invoerveld gekopieerd naar het tweede. Wanneer u op de knop "Sluiten" klikt, beëindigt het programma zijn werk. In de toekomst kan het dienen als sjabloon voor het schrijven van andere, complexere, applicaties. We zullen communiceren in C / C ++, hoewel we Delphi ook niet zullen beledigen. Het algemene principe is hetzelfde, alleen de syntaxis is anders. Om met systeemberichten en API-functies te werken, moet u headerbestanden in uw project opnemen; in C/C++ is het windows.h, in Delphi zijn het windows en berichtenmodules.

Elk Windows-programma bestaat uit drie hoofdonderdelen: een hoofdfunctie, een berichtenlus en een vensterfunctie die alle berichten afhandelt die naar het venster worden verzonden.

Ons programma begint met de functie WinMain(). Dit is de hoofdfunctie. De functie WinMain() voert doorgaans de volgende taken uit:

• Specificeert de vensterklasse. Niet te verwarren met OOP-klasse.
• Registreert deze klasse bij het systeem.
• Creëert het hoofdvenster van de toepassing en andere bedieningselementen.
• Toont een venster op het scherm.
• Start een berichtenlus.
• Het wordt op deze manier gedeclareerd: int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) Laten we de parameters behandelen:
  • hInstance is een handle voor het huidige toepassingsexemplaar.
  • hPrevInstance - Een ingang naar het vorige exemplaar van de toepassing, indien actief.
  • lpCmdLine - verwijzing naar een tekenreeks die de parameters bevat die bij het opstarten aan het programma zijn doorgegeven.
  • nCmdShow - een constante die bepaalt hoe het venster wordt weergegeven. (Zie SW_ constanten).

In Delphi zullen we zo'n plaatje niet zien; in deze ontwikkelomgeving wordt de hoofdfunctie door de compiler voor de programmeur verborgen. Hoewel het natuurlijk aanwezig is in de definitieve code. Om een ​​vensterklasse te registreren, is het noodzakelijk om de velden van de WNDCLASS-typestructuur (in Delphi TWNDCLASS) in te vullen. We hebben hiervoor de wcl-variabele gedeclareerd. wcl.hInstance = hInstance; De variabele hInstance, een handvat voor het huidige toepassingsexemplaar, wordt geïnitialiseerd door de functie WinMain(). In Delphi wordt het impliciet geïnitialiseerd. wcl.lpszClassName = szWinName; Naam van de klasse. We hebben vooraf de tekenreeksvariabele szWinName gemaakt en geïnitialiseerd. wcl.lpfnWndProc = WindowFunc; Een verwijzing naar een vensterfunctie. wcl-stijl = 0; Een constante die de stijl van het venster aangeeft. Hiervoor worden de CS_-vlaggen gebruikt, ik reset ze gewoon. U kunt een combinatie van vlaggen specificeren met behulp van de bitsgewijze "of"-bewerking. wcl.hIcon = LoadIcon(NULL, IDI_ASTERISK); De handle naar het pictogram van de toepassing, zoals geretourneerd door de functie LoadIcon(). Ik heb het standaardpictogram geüpload. Zie IDI_constanten. wcl.hCursor = LoadCursor(NULL,IDC_ARROW); Ga naar de toepassingscursor die wordt geretourneerd door de functie LoadCursor(). Ik heb een standaardpijl geüpload. Zie IDC_constanten. wcl.lpszMenuName = NULL; Aanwijzer naar een tekenreeks die de naam van de menubron voor deze vensterklasse aangeeft. Geen menu, geen wijzer. wcl.cbClsExtra = 0; gereserveerd veld. Wij resetten. wcl.cbWndExtra = 0; gereserveerd veld. Wij resetten. wcl.hbrBackground = (HBRUSH)COLOR_WINDOW; Venster kleur. De constante COLOR_WINDOW wordt gecast naar het HBRUSH-type (casting in Delphi is niet nodig). Met de functie GetStockObject() kunt u ook de kleur van het vensterpenseel of de achtergrondafbeelding instellen. Registreer nu stoutmoedig de vensterklasse.

RegisterClass(&wcl); Een verwijzing naar de wcl-structuur wordt als parameter doorgegeven aan de functie RegisterClass.

Met de volgende regel maken we ons venster.

• De eerste parameter is de naam van de vensterklasse.
• De tweede parameter is de titel van het venster.
• De derde parameter is de vensterstijl. Van de standaard WS_OVERLAPPEDWINDOW, met behulp van de xor-bewerking, heb ik de mogelijkheid om het venster te schalen verwijderd en de knop Maximaliseren uitgeschakeld.
• Vierde en vijfde - de positie van het venster vanaf de linkerbovenhoek van het scherm. Ik heb CW_USEDEFAULT, met deze waarde selecteert het systeem automatisch de positie van het venster.
• De zesde en zevende parameters zijn respectievelijk de breedte en hoogte van het venster.
• De achtste parameter is het eigenaarsvenster. In het hoofdvenster is de eigenaar het bureaublad (0). De bedieningselementen hebben het hoofdvenster.
• De negende is een aanwijzer naar de menuhandle. Geen menu, geen wijzer.
• De tiende parameter is een ingang naar het huidige toepassingsexemplaar.
• Elfde - Wordt gebruikt bij het maken van applicaties met een MDI-interface. We hebben niet nodig.

Vervolgens zullen we de nodige controles maken. Alle bedieningselementen zijn dezelfde vensters, ze hebben alleen een andere klassenaam. Besturingsklassen hoeven niet te worden geregistreerd, ze zijn al voorgedefinieerd in het systeem. Knop - klasse knop. Invoerveld - klasse bewerken. De inscriptie is de ststic klasse. Er zijn veel klassen die overeenkomen met standaardbesturingen. We maken besturingselementen met behulp van de bekende functie CreateWindow() en de onbekende functie CreateWindowEx(). Met CreateWindowEx() kunt u een venster maken met een uitgebreide stijl. We gebruiken het om invoervelden te maken. In deze functie is de eerste parameter toegevoegd, die deze zeer uitgebreide stijl instelt, de overige parameters zijn hetzelfde als voor CreateWindow (). De bedieningselementen zijn onderliggende vensters, hun eigenaar is het hoofdvenster.

Wanneer u besturingselementen maakt, moet u in de functieparameters de hoofdvensterdescriptor specificeren, evenals de WS_CHILD-vensterstijl. Het uiterlijk en de functionaliteit van bedieningselementen kunnen worden gemanipuleerd met behulp van de vlaggen: WS_, ES_, BS_, SS_, door ze te combineren met de bitsgewijze "of" -bewerking. Bij het maken van besturingselementen initialiseren we de bijbehorende variabelen met hun handvatten, die worden geretourneerd door de functies CreateWindow() en CreateWindowEx(). We hebben deze beschrijvingen nodig voor verder werk met besturingselementen. We tonen het venster dat we op het scherm hebben gemaakt en tekenen het opnieuw.

• De eerste parameter is een structuur van het type MSG (in Delphi, type TMSG)
• De tweede parameter is de vensterhandle waarvoor het bericht is bedoeld. Indien NULL of 0, dan alle toepassingsvensters.
• Met de derde en vierde - kunt u het bereik van ontvangen berichten instellen. Indien 0, dan zijn alle berichten geadresseerd aan het venster.

Een vensterfunctie biedt programmafunctionaliteit door systeemberichten te verwerken. De vensterfunctie is een CALLBACK-functie, d.w.z. gebeld door het besturingssysteem als reactie op een inkomend nieuw bericht. De vensterfunctie wordt als volgt gedeclareerd:

LRESULT CALLBACK WindowFunc(HWND hMainWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)

• HMainWnd - hendel naar het hoofdvenster.
• iMsg - berichtnummer. Zie WM_-constanten.
• lParam en wParam zijn berichtparameters.

Wanneer een bericht verschijnt, kunnen we de iMsg-parameter vergelijken met een van de WM_-constanten en de juiste reactie van het programma programmeren.

Bijvoorbeeld: wanneer de linkermuisknop wordt ingedrukt terwijl de muisaanwijzer zich boven het clientgebied van een venster bevindt, wordt de gebeurtenis WM_LBUTTONDOWN geactiveerd. De vensterfunctie wordt aangeroepen, de waarde van de constante WM_LBUTTONDOWN wordt ingevoerd in de parameter iMsg, we kunnen de toestand controleren en de programmareactie programmeren die we nodig hebben.

Binnen de vensterfunctie bevindt zich een select-statement dat de bovenstaande taak uitvoert. De selectie-instructie moet een standaardhandler bevatten, die wordt geïmplementeerd door de DefWindowProc(hMainWnd, iMsg, wParam, lParam);

Als dit niet wordt gedaan, zal ons programma sterven en niet tot leven komen. Veel berichten worden door het systeem zelf verwerkt, zoals: het formaat van het venster wijzigen, het venster minimaliseren / maximaliseren, het systeemmenu oproepen, enz. Dat is waar DefWindowProc() voor is.

Wanneer u met vensterbesturingselementen werkt, wordt een WM_COMMAND-bericht verzonden naar het eigenaarsvenster, waar lParam de handle van het besturingselement bevat, en de hoge byte van de wParam-parameter de identifier is van de gebeurtenis die in het besturingselement is gegenereerd. Bijvoorbeeld: bij het klikken op de knop - BN_CLICKED. Zie constanten BN_, WM_. We kunnen het programma sluiten met de functie PostQuitMessage(0). Deze functie stuurt een WM_QUIT-bericht naar het venster.

Een paar woorden over het schrijven van dergelijke programma's in Delphi. We maken een nieuw project aan, starten de Project Manager, verwijderen Unit1 samen met het formulier. Druk op Ctrl + F12 en open het projectbestand. We verwijderen de formulierenmodule uit gebruik, voegen daar vensters en berichten toe. Verwijder alles tussen begin en einde. De voorbereiding is klaar. Je kunt coderen. Het is onmogelijk om programma's op een pure API te schrijven zonder hulp, die altijd bij de hand zou moeten zijn. Als je Gates zelf was, kun je je niet alles herinneren. Aanbevelen:

• allereerst - MSDN;
• Delphi-helpsysteem (MSTOOLS.HLP-bestand);
• http://www.soobcha.ru/rushelp heeft Russische hulp bij Win32 API.

Bobchenko Maxim downloaden: CreateWnd.zip(2.6K)
archief bevat windows.cpp- en windows.dpr-bestanden

GUI-ontwikkeling

Het belangrijkste middel voor gebruikersinteractie met het programma is de grafische gebruikersinterface (GUI). De GUI van elk softwareproduct is een van de belangrijkste factoren in zijn populariteit.

Het creëren van een competente gebruikersinterface is een arbeidsintensief proces en vereist maximale aandacht voor detail. De gecreëerde interface moet de mogelijkheden van het programma maximaliseren, maar tegelijkertijd de gebruiker niet overladen met een overvloed aan menu's, knoppen, afbeeldingen en tekst.

In de praktijk wordt bij het programmeren van Windows-applicaties uitgebreid gebruik gemaakt van verschillende tools en wizards. Dus, rekening houdend met de standaarden van het geselecteerde besturingssysteem, zal de softwaretool een vensterinterface hebben. Dit is voornamelijk te wijten aan het feit dat vensters de belangrijkste elementen zijn van de grafische interface in besturingssystemen (OS) van de Windows-familie. Het zijn rechthoekige gebieden met hun eigen instellingen, eigenschappen en typen.

Het grafische deel van het trainingsblok omvat vier soorten vensters:

Hoofdvenster - bevat alle navigatie-elementen door het programma, evenals aanvullende informatie die nodig is voor het gemak van het werken met de PS;

Infobase-beheervensters -- bevatten alle besturingselementen van de informatiecomponent van de softwaretool. Ze bieden de toevoeging van tests, informatie, nieuwe gebruikers en beheerders, stellen u in staat om nieuw gemaakte of bestaande gegevens te manipuleren;

Windows voor het werken met softwarefuncties - bieden werk met de belangrijkste functies van het trainingsblok, zoals het afleggen van tests en het bestuderen van colleges;

Vensters voor het weergeven van informatie en statistieken -- worden gebruikt om verschillende soorten informatie weer te geven, evenals statistieken en grafieken.

Het hoofdvenster van het programma zal de volgende bedieningselementen en informatie-uitvoer bevatten:

De titel van het venster, die de naam van het programma en het doel van het venster bevat;

Systeemmenuknoppen die verantwoordelijk zijn voor het verkleinen, verkleinen en sluiten van het programma;

Het gebied van de venstertitel, dat de enige functie van decoratie heeft en nodig is om te voldoen aan de algemene ontwerpbeslissing;

Welkomstruimte;

Weergavegebied voor de dag van de week, huidige datum en tijd;

Gebruikerswerkbalk met knoppen voor toegang tot de belangrijkste functies van het programma;

Administratief paneel, bevat een knop voor toegang tot de administratieve controles van de PS;

Statusbalk met informatie over alle modi van het programma.

Het schema van het hoofdvenster van de grafische interface (weergave van het venster voor de beheerdersaccount) wordt weergegeven in figuur 3.2

Figuur 3.2 - Schema van het hoofdvenster van de grafische interface: 1 - venstertitel; 2 -- systeemmenuknoppen; 3 -- venster titelgebied; 4 -- statusbalk; 5 -- welkom gebied; 6 -- uitvoergebied van de dag van de week, datum en tijd; 7 -- administratief paneel; 8 -- gebruikerspaneel; 9 -- knop om toegang te krijgen tot de leerfase; 10 -- knop om toegang te krijgen tot de testfase; 11 -- knop voor het weergeven van statistieken en grafieken; 12 -- uitgang; 13 -- knop om toegang te krijgen tot het administratieve gedeelte van de applicatie

Rekening houdend met de richting van de ontwikkelde software, werden verschillende niet-standaard grafische oplossingen ontwikkeld om de aandacht en meer interesse voor de applicatie te trekken. Bovendien kun je hierdoor een soort van individualiteit krijgen tussen de rest van de reeks programma's met vergelijkbare thema's en focus.

Een van deze oplossingen kan kleurrijk worden genoemd en een uniek ontwerp creëren, interface-elementen, die op dit gebied geen analogen hebben. We hebben het over geanimeerde inserts op basis van flash-animatie. Met behulp hiervan wordt het ontwerp van de namen van alle belangrijke functionele vensters, navigatie-elementen, de interface van het registratie- en autorisatieformulier geïmplementeerd. De belangrijkste voordelen van deze ontwikkeling zijn: de implementatie van een prettige en gebruiksvriendelijke interface; aanzienlijke vereenvoudiging van het gebruik van het programma, zowel op gebruikers- als op administratief vlak.

Een ander van de belangrijkste voordelen van analoge programma's, zowel in software als in grafische implementatie, is de organisatie van het afleggen van tests op aanvraag. Om dit type test te doorstaan, moet de gebruiker SQL-query's samenstellen uit afzonderlijke, onafhankelijke elementen. Afhankelijk van het type verzoek dat moet worden samengesteld op basis van de voorwaarden van de voorgestelde taak, wordt een bepaalde polygoon gevormd voor montage. De polygoon bevat velden voor het vervangen van operators die er met de muis in worden gesleept vanuit een apart blok, en invoervelden voor de namen van tabellen, velden en voorwaarden.

Gebruikersstatistieken worden geïmplementeerd in de vorm van grafieken, die worden gebouwd afhankelijk van de door hem verkregen resultaten. Elke test heeft zijn eigen dynamiek. Grafieken bevatten alle benodigde labels, worden geïmplementeerd met behulp van de TChart-component en hebben daarom veel besturingselementen die standaard in de component zijn ingebouwd en als resultaat worden geïmplementeerd in de toepassing.

Voor een gebruiksvriendelijkere visualisatie zijn ook de tabelkopstijlen vervangen in plaats van de stijlen die in de standaardontwikkelomgeving zijn geïmplementeerd.

Zo maakten de geïmplementeerde grafische oplossingen het mogelijk om het resultaat te bereiken dat wordt beoogd door het idee van GUI-ontwerp. De gecreëerde interface maximaliseert de mogelijkheden van het programma, maar overlaadt de gebruiker tegelijkertijd niet met een overvloed aan menu's, knoppen, afbeeldingen en tekst.