Ammattimainen sovelluskehitys Delphi 5 | Kehitystyökalut | ComputerPress 2"2001

Luominen Delphin komponentit

Johdatus Delphi-komponenttien luomiseen

Kehitettäessä sovelluksia Borland Delphillä on kätevää luoda komponentteja seuraavista syistä:

1. Helppokäyttöisyys. Komponentti sijoitetaan lomakkeeseen, ja sinun on asetettava sille ominaisuusarvot ja kirjoitettava tapahtumakäsittelijän koodi. Siksi, jos projektissa jokin yhdistelmä ohjaimia ja niihin liittyviä tapahtumakäsittelijöitä esiintyy kahdessa paikassa, on järkevää ajatella vastaavan komponentin luomista. Jos ohjaimien ja niihin liittyvien tapahtumakäsittelijöiden yhdistelmä esiintyy useammin kuin kahdesti, komponentin luominen säästää taatusti vaivaa sovellusta kehitettäessä.
2. Yksinkertainen ryhmäprojektikehityksen organisointi. Ryhmäkehityksessä yksittäiset projektin osat voidaan määritellä komponenteiksi ja työ voidaan osoittaa eri ohjelmoijille. Komponenttien viankorjaus voidaan tehdä erikseen sovelluksesta, mikä on melko helppoa.
3. Yksinkertainen ja tehokas tapa koodin jakaminen muiden ohjelmoijien kanssa. On monia sivustoja, esimerkiksi http://www.torry.net/, joista voit löytää vapaasti jaettavia komponentteja tai ostaa niitä nimellistä maksua vastaan.

Ominaisuuspaketit

Delphissä komponentit säilytetään paketeissa. Käytettyjen komponenttipakettien luettelo voidaan avata Komponentti/Asenna paketit -valikosta (jostain syystä tämän valintaikkunan otsikko on kuitenkin Project Options).

Tämän valintaikkunan avulla voit lisätä uusi paketti(Lisää), poista olemassa oleva (Poista). Poistaminen ei tarkoita tiedoston fyysistä poistamista levyltä, vaan linkin poistamista kehitysympäristöstä tähän pakettiin. Kun lisäät uuden paketin, siihen tallennetut komponentit ilmestyvät paletille, ja kun poistat sen, ne päinvastoin katoavat. Paketin poistamisen sijaan voit "piilottaa" sen sisällön kehitysvaiheessa poistamalla valinnan paketin nimestä luettelosta. Voit myös tarkastella komponentteja ja niiden kuvakkeita (Components). Lopuksi voit muokata käyttäjien lisäämiä paketteja (Muokkaa) - Delphin mukana tulevia paketteja ei voi muokata (Muokkaa-painike näkyy harmaana).

Tässä valintaikkunassa voit määrittää, miten projekti luodaan: käyttämällä ajonaikaisia ​​paketteja vai ilman niitä. Tästä on selvää, että komponenttipaketteja on kahta tyyppiä: runtime-paketti (ajonaikaisesti toimiva paketti) ja suunnittelunaikainen paketti (kehityksen aikana käytetty paketti). Ne ovat kaikki DLL-tiedostoja (dynaamisesti ladattuja kirjastoja).

Ajonaikaiset paketit (*.bpl-laajennus) toimitetaan loppukäyttäjälle projektin mukana, jos projekti on käännetty Build with runtime packages -asetuksen ollessa käytössä. Itse sovellus (*.exe tai *.dll) osoittautuu tässä tapauksessa pieneksi, mutta sen mukana on siirrettävä melko suuria *.bpl-tiedostoja. Asiantuntijoiden mukaan projektin toimittaminen ajonaikaisilla paketeilla antaa edun toimitettujen tiedostojen määrässä vain, jos se sisältää viisi tai useampia Delphissä kirjoitettuja moduulia (*.exe tai *.dll). Kun nämä moduulit toimivat yhdessä, käyttöjärjestelmän resursseja säästyy, koska yksi RAM-muistiin ladattu paketti palvelee useita moduuleja.

Suunnitteluaikapaketteja (*.dcp-laajennus) käytetään vain kehitysvaiheessa. Kehityksen aikana ne tukevat komponenttien luomista lomakkeelle. Käytetty Delphi-projekti ei sisällä koodia komponenttipaketista, vaan *.dcu-tiedostoista. Vaikka *.dcp-tiedosto luodaan *.dcu-tiedostosta, niiden sisältö ei välttämättä ole sama, jos *.pas-tiedostoon on tehty muutoksia eikä pakettia ole käännetty uudelleen. Kääntäminen on mahdollista vain ohjelmoijien luomille paketeille. Tämä saavutetaan napsauttamalla Muokkaa-painiketta yllä olevassa valintaikkunassa. Tämän jälkeen näkyviin tulee lomake, jonka avulla voit käsitellä pakettia.

Paketti sisältää kaksi osaa. Sisältää luettelon moduuleista, jotka muodostavat tämän paketin komponentit (*.pas- ja *.dcu-tiedostot) ja niiden kuvakkeet (*.dcr-tiedostot). Pakollinen-osio sisältää linkkejä muihin näiden komponenttien toimintaan vaadittaviin paketteihin. Uuden komponentin lisääminen pakettiin tapahtuu Lisää-painikkeella ja olemassa olevan komponentin poistaminen tapahtuu Poista-painikkeella. Ennen kuin paketti on käännetty napsauttamalla Käännä-painiketta, pakettiin tehdyt muutokset eivät näy kehitysympäristössä. Lopuksi Asenna-komento on käytettävissä, kun paketin sisältö on poistettu kehitysympäristöstä poistamalla valinta paketin nimestä edellisessä valintaikkunassa.

Optio-komennon avulla voit valita paketin käännösvaihtoehtoja, jotka ovat samanlaisia ​​kuin projektiasetukset. Niitä voidaan käyttää määrittämään, minkä tyyppinen paketti tietty paketti on: ajonaikainen, suunnitteluaika tai molemmat (oletuspakettityyppi). Vaihtoehdot määrittelevät hakemistot, joista haetaan tarvittavat moduulit ja tallenna kokoamisen tulokset. Ne määrittelevät myös virheenkorjaukseen vaadittavat toimenpiteet: tarkistetaanko hyväksyttävien arvojen alue, miten optimoinnit suoritetaan, miten I/O-virheitä käsitellään. Lopuksi vaihtoehdot voivat sisältää paketin versiotietoja. Tämä on erittäin tärkeää, jos sovellusta jaetaan ajonaikaisten pakettien kanssa: kun asennusohjelma suoritetaan, versiotietojen avulla voit korvata pakettien vanhentuneet versiot oikein ja päinvastoin, jos yrität asentaa paketin, jonka versio on vanhempi kuin joka on jo saatavilla tietyllä tietokoneella, jälkimmäistä ei korvata.

Komponenttimallit

Delphin avulla voit luoda yksinkertaisia ​​komposiittikomponentteja muutamista yleisistä komponenteista, jotka on valittu lomakkeelle suunnittelun aikana. Vastaava asiantuntija kutsutaan käyttämällä valikkokohtaa Komponentit/Luo komponenttimalli. Tämä valikkokohta on käytettävissä, jos lomakkeesta on valittu vähintään yksi komponentti. Kun olet valinnut sen, Component Template Information -valintaikkuna tulee näkyviin.

Tässä valintaikkunassa sinun tulee määrittää luokan nimi ja sen sivun nimi komponenttipaletissa, johon sinun tulee sijoittaa uusi komponentti. Jos tämänniminen sivu ei ole komponenttipaletissa, se luodaan. Voit myös muuttaa uuden komponentin ehdotettua kuvaketta lataamalla sopivan *.bmp-tiedoston.

Kun malli luodaan, sekä ohjelmoijan Object Inspectorissa muuttamat ominaisuudet että valittuihin ohjaimiin liittyvät tapahtumakäsittelijät muistetaan. Tässä tapauksessa tapahtumakäsittelijät muistetaan kokonaan ilman, että suodatetaan kutsuja muihin (ei valittuna lomakkeella) komponentteihin, globaaleihin muuttujiin, menetelmiin jne. Vastaavasti, jos tällaiset komponentit (muuttujat, menetelmät) puuttuvat toisesta projektista, yritettäessä kääntää tällaista projektia, vastaanotetaan Unknown Identifier -diagnostiikkaviesti.

Milloin malleja kannattaa käyttää? Ensinnäkin tapauksissa, joissa on tarpeen muuttaa perusluokassa oletusarvoisesti saatavilla olevia ominaisuuksia. Esimerkiksi sovellus käyttää ohjausobjektia keltaisen tekstirivin muokkaamiseen. Voit sijoittaa TEdit-komponentin lomakkeeseen, muuttaa Color-ominaisuuden keltaiseksi, merkitä tämän komponentin ja tallentaa sen mallina. Tämän jälkeen pääset käsiksi tähän malliin ja lomakkeelle asetettu komponentti on keltainen. Tätä mahdollisuutta ei kuitenkaan kannata käyttää väärin, koska ohjaukselle luodaan uusi luokka muuttuneella värillä ja kaikki virtuaaliset menetelmät kopioidaan muistiin. Tämä vaikuttaa negatiivisesti käyttöjärjestelmän resursseihin.

On myös kätevää käyttää komponenttipohjia, kun joudut siirtämään useita komponentteja tapahtumakäsittelijöiden ohella lomakkeesta toiseen. Tätä varten ne kaikki valitaan, luodaan komponenttimalli, joka asetetaan päälle uusi univormu. Tällöin ei siirretä vain itse komponentteja, vaan myös tapahtumakäsittelijät, mitä ei voida saavuttaa kutsuttaessa Copy/Paste-komentoja - jälkimmäisessä tapauksessa tapahtumakäsittelijät menetetään.

Create Component Template -komennolla luodut komponentit eroavat melkoisesti tavallisista komponenteista, jotka on luotu vakiomenetelmällä (kuvattu alla). Visuaalisesti tärkein ero on tämä: jos malli sisältää useita säätimiä, voit valita sen jälkeen, kun tällainen komponentti on asetettu lomakkeeseen erillinen elementti hallitse ja poista se - loput jäävät lomakkeeseen. Vakiokomponenteille, jotka sisältävät useita ohjaimia, ei ole mahdollista valita yhtä niistä ja poistaa sitä - komponentti valitaan ja poistetaan kokonaan.

Yksinkertaisen komponentin luominen

Kun kirjoitat uutta komponenttia, sinun on tehtävä selväksi, että komponentti kirjoitetaan ohjelmoijille, ei loppukäyttäjille. Tässä tapauksessa on toivottavaa, että ohjelmoija ei syvenny komponentin toteutuksen yksityiskohtiin, vaan yksinkertaisesti käyttää sen paljastamia ominaisuuksia ja tapahtumia. Tämä saavutetaan erittäin perusteellisella testauksella. Uusi komponentti on testattava myös tilanteissa, joihin sitä ei ole selkeästi suunniteltu.

Esitetään ongelma seuraavasti. Sinun on luotava painike, joka antaa äänimerkin, kun sitä painetaan, ja toteuttaa se osana, jotta ohjelmoija voi sijoittaa sen lomakkeelle ja käyttää sitä. Yleensä komponentteja harkitessamme käytämme melko usein yksinkertaisimpia ulkoisia tehosteita: piippausta, viestin näyttämistä jne. Tämä tarkoittaa, että paikkoihin, joissa käytetään ulkoisia tehosteita, voidaan sijoittaa mikä tahansa melko monimutkainen koodi. Juuri sisään tällä hetkellä hän ei kiinnosta meitä.

Komponentin luominen alkaa valitsemalla Komponentti/Uudet komponentit -valikkokohta. Tämän jälkeen Uusi komponentti -valintaikkuna tulee välittömästi näkyviin.

Tässä valintaikkunassa sinun on määritettävä esi-isäluokka, juuri luodun luokan nimi, paletin sivu, jolle uusi komponentti sijoitetaan, uuden komponentin toteutuksen sisältävän moduulin nimi ja polku se. Jos uusi komponentti käyttää muita moduuleja, joiden polkua ei ole kuvattu, ne on määritettävä Hakupolku -kentässä.

Joten ensimmäinen (ja ehkä tärkein) tehtävä on esivanhempien luokan valitseminen. Pudotusvalikossa kaikki paletissa saatavilla olevat komponentit tarjotaan esivanhempana, mukaan lukien ne, jotka eivät sisälly Delphi-standardin jakeluun. Esivanhempaksi tulee valita luokka, joka on ominaisuuksiltaan mahdollisimman lähellä luotava luokka. Tehtäväämme varten voimme esimerkiksi valita esi-isäksi TWinControlin, mutta tässä tapauksessa meidän on toteutettava kaikki painikkeen napsautusten visuaaliset tehosteet jne. Siksi valitsemme esi-isäksi TButtonin.

Uuden luokan nimen tulee kuvastaa komponentin sisältöä, eikä se saa missään tapauksessa olla sama kuin jo rekisteröidyn komponentin nimi! Tämän dialogin täyttövaiheessa nimiä ei tarkisteta osumien varalta - tällaiseen virheeseen liittyvät seikkailut alkavat myöhemmin...

Kun valitset sivua, sinun on tiedettävä, että jos määrität nimen olematon sivu, sitten luodaan uusi.

Lopuksi, kun napsautat sekä Asenna- että OK-painiketta, luodaan malli uuden komponentin toteuttamiseksi. Kuitenkin, kun napsautat Asenna-painiketta, malli sijoitetaan komponenttipalettiin, ja kun napsautat OK, se yksinkertaisesti luodaan. On suositeltavaa käyttää Asenna-painiketta. Kun komponentti on asennettu, se voidaan asettaa lomakkeelle. Nyt kaikki komponentin toteutuskoodiin tehdyt muutokset käännetään projektin mukana ja ohjelmoija saa välittömästi virheilmoitukset. Jos komponenttia ei ole asennettu, virheiden löytämiseksi se on käännettävä pakettieditorin kautta (katso yllä) napsauttamalla Compile-painiketta, mikä ei ole niin kätevää.

Joten, kun napsautat Asenna-painiketta, näkyviin tulee toinen valintaikkuna, jonka avulla voit määrittää paketin, johon tämä komponentti sijoitetaan.

Tässä valintaikkunassa on kaksi sivua, joista ensimmäisellä voit valita yhden olemassa olevista paketeista ja toisella voit luoda uuden. On erittäin suositeltavaa antaa lyhyt tekstikuvaus paketista. Tämä näkyy Komponentti/Asenna paketit -komennon kutsumassa valintaikkunassa (katso yllä). Paketin valinnan ja OK-painikkeen painamisen jälkeen avautuu pakettieditori, johon sijoitetaan automaattisesti juuri luotu moduuli uuden komponentin toteuttamiseksi. On hyödyllistä olla sulkematta sitä, vaan siirtää se johonkin näytön kulmista, jotta se voidaan aktivoida painamalla hiiren painiketta.

Samanaikaisesti koodieditoriin luodaan "tyhjä" kuvaamaan uutta komponenttia:

Unit ButtonBeep; käyttöliittymä käyttää Windowsia, Viestit, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; tyyppi TButtonBeep = luokka(TButton) yksityinen ( Yksityiset ilmoitukset ) suojattu ( Suojatut ilmoitukset ) julkinen ( Julkiset ilmoitukset ) julkaistu ( Julkaistut ilmoitukset ) end; menettely Rekisteri; täytäntöönpanomenettely Rekisteri; begin RegisterComponents("Samples", ); loppu; loppu.

Uusi luokka itse ilmoittaa neljä osiota, joiden merkitys on kuvattu yksityiskohtaisesti tämän sarjan edellisen artikkelin (ComputerPress No. 1 "2001") osiossa "Muuttujat ja menetelmät". Lisäksi uusi luokka määrittelee Rekisteröintimenettely, jota Delphi-kehitysympäristö kutsuu tämän moduulin asennuksen aikana. Se sisältää sen sivun nimen, johon tämä komponentti on sijoitettu, ja hakasulkeissa - luokan nimen. Rekisteröintimenetelmä ottaa parametriksi joukon luokkatyyppejä, koska yhdessä moduulissa voidaan toteuttaa useita komponentteja, joten ne erotetaan toisistaan ​​pilkulla.

Menettelyrekisteri; begin RegisterComponents("Samples", ); loppu;

Jatketaan käsillä olevan tehtävän ratkaisemista - näppäilevän painikkeen luomista. Tehdään ensin triviaali asia (mutta kuten myöhemmin käy ilmi, väärin) - määritä käsittelijä OnClick-tapahtumat painikekonstruktorissa. Tätä varten määrittelemme yksityisessä osiossa uuden menetelmän BtClick(Sender:TObject) otsikon ja toteutamme sen toteutusosiossa:

Toimenpide TButtonBeep.BtClick(Lähettäjä:TObject); beep; loppu;

rakentaja Luo(AOwner:TComponent); ohittaa;

pakollisella ohituskäskyllä! Toteutetaan se toteutusosiossa:

Rakentaja TButtonBeep.Create(AOwner:TComponent); alkaa peritty Luo(AOwner);

OnClick:=BtClick; loppu;

Tämän jälkeen kootaan komponentti. Laitetaan painike Mallit-sivun lomakkeeseen ja ajetaan projekti suoritettavaksi. Voit varmistaa, että painike antaa äänimerkin, kun sitä painetaan!

Palataan nyt kehitysympäristöön ja määritetään OnClick-tapahtumakäsittelijä objektitarkistusohjelmassa. Tapahtumakäsittelijässä näytämme tekstin lomakkeen otsikossa:

Toimenpide TForm1.ButtonBeep1Click(Lähettäjä:TObject); begin Caption:="Testaa"; loppu;

Siksi uusia komponentteja kirjoitettaessa kannattaa aina harkita ominaisuuksien ja tapahtumakäsittelijöiden muuttamista Object Inspectorin avulla. Jos ominaisuuden (tapahtuman) ei pitäisi muuttua, sitä ei pitäisi näyttää Objektitarkistajassa. Ja jos se on jo näkyvissä, sinun tulee piilottaa se (puhumme tästä myöhemmin). Ohjelmoijalla on täysi oikeus muuttaa objektitarkastajan ominaisuuksia, ja jos tämän jälkeen komponentti lakkaa toimimasta, syy on komponentin kehittäjä, mutta ei missään tapauksessa sitä käyttävä ohjelmoija.

Miten voi päättää oikein? tämä tehtävä? Yksi tapa luoda komponentteja on kirjoittaa olemassa olevia menetelmiä uudelleen. Kun katsot StdCtrls.pas-tiedostoa, jossa TButton-komponentin lähdekoodi on toteutettu, voit huomata, että se sisältää dynaamisen Click-menetelmän, joka voidaan kirjoittaa uudelleen. Siksi palaamme takaisin Delphi-asiantuntijan luomaan lähdekoodiin komponenttia luotaessa (poistamme rakentajan ja BtClick-menetelmän). Sitten julkisessa osiossa määritämme menetelmän otsikon:

Menettelytapa Napsauta; ohittaa;

ja tässä on menetelmän toteutus:

Toimenpide TButtonBeep.Click; aloita peritty Click;

piippaus; loppu;

Voit varmistaa, että painike narisee, kun sitä painetaan. Lisäksi, kun määrität tapahtumakäsittelijän kohteen tarkastajassa, tämä käsittelijä suoritetaan eikä äänimerkki katoa! Komponentti on toteutettu oikein.

1. Tämän esimerkin avulla on hyödyllistä analysoida mahdollisia virheitä koodia kirjoitettaessa:
2. Unohtunut ohituskäsky määritettäessä Click-menetelmän otsikkoa. Painike lakkaa piippamasta, joten Click-menetelmää ei kutsuta.

Unohtunut kutsu esi-isämenetelmään (peritty Click) Click-menettelyn toteutuksessa. Painike jatkaa piippausta, kun sitä painetaan, mutta objektin tarkastajassa määritetyn tapahtumakäsittelijän koodia ei suoriteta. Siksi TButton-luokan Click-menetelmä nostaa OnClick-tapahtuman. Muutetaan nyt paletin TButtonBeep-komponentin kuvake. Oletusarvoisesti esi-isäkomponentin kuvaketta käytetään uudelle komponentille. Voit tehdä tämän kutsumalla kuvaeditoria Tools/Image Editor -komennolla. Kutsu editorissa komento File/New/Component Resource File (*.dcr). Resource/New/Bitmap-komennon jälkeen näkyviin tulee valintaikkuna, joka ehdottaa kuvakkeen kokoa 32x32. Nämä oletuskoot tulisi muuttaa 24x24-kokoisiksi - tämä on komponenttikuvakkeiden koko! Kun olet napsauttanut OK-painiketta, sinun tulee piirtää kuva käyttämällä vakiotyökaluja , samanlainen kuin työkalut. Muista, että vasemman alakulman pikselin väri on maskin väri - tämä väri on "läpinäkyvä".

Tämän jälkeen sinun on määritettävä uudelleen resurssin nimi kuvakkeella, sen nimi on Bitmap1. Uuden resurssin nimen on vastattava luokan nimeä - tässä tapauksessa TButtonBeep.

Nyt sinun on tallennettava kuvaketiedosto samaan hakemistoon kuin moduuli, joka sisältää tämän komponentin rekisteröintimenettelyn, ja samalla nimellä kuin moduulin nimi. Vain tiedostopääte ei ole *.pas, vaan *.dcr. Komponenttikuvakkeella varustettu tiedosto on valmis. Kuitenkin, jos katsomme Komponentit-palettia, näemme, että vanha kuvake on edelleen siellä. Jos käynnistät Delphin tai jopa käyttöjärjestelmän uudelleen, vanha kuvake jää silti paletille. Jotta kuvaketta voidaan muuttaa, komponentti on rekisteröitävä uudelleen. Tätä varten tarvitset:

Tätä esimerkkiä tulisi pitää testiharjoituksena. Ennen kuin kirjoitat uuden komponentin, sinun on tarkistettava, onko vapaasti jaettujen komponenttien joukossa vastaavia. Painikkeita on melkein mitä tahansa: läpinäkyviä, juoksevia, pyöreitä, värillisiä jne. Tilanne on suunnilleen sama muiden komponenttien - saman luokan jälkeläisten - kanssa. Siksi useimmiten joudut toteuttamaan komponentteja, jotka koostuvat useista ohjaimista.

Siksi tässä esimerkissä tutkimme menetelmän uudelleenkirjoituksen käyttöä uusien komponenttien luomiseksi.

Monimutkaisen komponentin luominen

Oletetaan, että sinun on syötettävä luettelo asiakkaiden nimistä sovellukseen. Samassa sovelluksessa sinun on myös syötettävä luettelo puhelinnumeroista. Listan syöttäminen on melko yleinen toiminto, joten sinun kannattaa harkita sen toteuttamista komponenttina.

Uuden elementin syöttämiseksi luetteloon tarvitset editorin - TEdit-komponentin. Seuraavaksi käyttäjän pitäisi pystyä tarkastelemaan luetteloa - TListBox-komponenttia tarvitaan. Lisäksi tarvitset komentoja TEditin nykyisen arvon kirjoittamiseen luetteloon, valitun luettelokohteen muokkaamiseen ja sen poistamiseen. Helpoin tapa toteuttaa nämä komennot on painikkeiden käyttö. Tehtävän yksinkertaistamiseksi laitamme lomakkeeseen yhden painikkeen, jota klikattaessa lisäämme listaan ​​TEdit-komponentin sisällön.

Joten meidän on luotava uusi komponentti, joka sisältää TEditin, TListBoxin ja TButtonin. Kuten aina, aloitetaan sen luominen Komponentti/Uusi komponentti -komennolla. Tämän jälkeen näkyviin tulee valintaikkuna, jossa sinun tulee määrittää esi-isäluokka, luokan nimi ja moduulin nimi. Luokan nimen ja moduulin nimen kanssa ei ole ongelmia, mutta esi-isäluokan nimi on epäselvä. Meillä on kolme ohjausta. Niiden yhteinen esi-isäluokka on TWinControl. Mutta jos valitsemme sen esi-isäluokaksi, edessämme on erittäin pitkä ja ikävä TButton-, TEdit- ja TListBox-koodien toteutus. Tällaisissa tapauksissa on tarpeen valita esi-isäluokaksi komponentti, joka voi olla "isä" suhteessa muihin komponentteihin. Delphin kanssa jaettavien vakiokomponenttien joukossa on kolme: TPanel, TGroupBox, TScrollBox. Valitaan esi-isäluokaksi paneeli, mutta ei itse TPanel-komponenttia, vaan TCustomPanel-luokka. Keskustelemme alla TCustomPanelin valinnan eduista TPaneliin verrattuna.

Nimetään uusi luokka TListAdd ja napsauta Asenna-painiketta. Paketin valinnan jälkeen komponentti asennetaan palettiin, josta se voidaan sijoittaa juuri luodun sovelluksen lomakkeeseen. Tämä on kätevää, koska kun projekti käännetään, myös komponenttimoduuli käännetään ja jos tulee virheitä, kääntäjä näyttää viestin.

Olisi kätevää sijoittaa säätimet jollekin lomakkeelle ja sitten luoda niistä komponentti. Delphi-standardipaketissa ei ole tällaista asiantuntijaa. Siksi sinun on luotava komponentit itse ja asetettava ne paneeliin. Ohjaimet - TButton, TEdit ja TListBox - on järkevää luoda TCustomPanel-konstruktorissa, mikä luonnollisesti vaatii sen uudelleenkirjoittamista. Laitetaan nyt säätimet 100x100 neliöön. Niiden koordinaatit on myös määritettävä konstruktorissa. On syytä muistaa, että sen jälkeen kun minkä tahansa ohjauselementin konstruktori on työstetty, sillä ei ole vielä ylätasoa, eli se ei tiedä minkä ikkunan suhteen sen tulisi mitata vasemman yläkulman koordinaatit. Jos ali-ikkunan koordinaatteja yritetään muuttaa, jolla ei ole vanhempia, syntyy välittömästi poikkeus. Siksi ensimmäinen operaattori ohjauksen rakentajan kutsumisen jälkeen määrittää sille ylätason, jolle valitsemme TCustomPanel. Teemme siitä myös niiden omistajan, tässä tapauksessa tuhoajaa ei tarvitse kirjoittaa uudelleen.

Joten käyttöosaan lisäämme StdCtrls-moduulin, jossa ovat TEdit-, TButton- ja TListBox-luokkien kuvaukset, ja yksityisessä osiossa määritämme kolme muuttujaa:

Yksityinen FEdit:TEdit;

FListBox:TListBox;

FButton:TButton;

Julkisessa osiossa ilmoitamme konstruktoriotsikon pakollisella ohituskäskyllä:

Constructor Create(AOwner:TComponent); ohittaa;

Toteutamme rakentajan toteutusosiossa: Rakentaja TListAdd.Create(AOwner:TComponent); alkaa peritty Luo(AOwner); FButton:=TButton.Create(Self);

FButton.Parent:=Itse;

FButton.Left:=5;

FButton.Top:=5;

FButton.Width:=40;

FButton.Height:=25;

FEdit:=TEmuokkaa.Luo(itse);

FEdit.Parent:=Itse;

FEdit.Left:=50;<100 then Width:=100; if Height<100 then Height:=100; FEdit.Width:=Width-55; FListBox.Width:=Width-10; FListBox.Height:=Height-40; end;

Ensimmäinen lauseke on kutsu WM_SIZE-oletuskäsittelijälle (peritty). Kutsumisen jälkeen Leveys- ja Korkeus-ominaisuudet sisältävät paneelin uuden leveyden ja korkeuden. Tämän jälkeen määritetään komponentin minimimitat, tässä tapauksessa 100x100. Jos vaaka- tai pystykoko on pienempi kuin minimi, sille annetaan vähimmäisarvo. Säätimet skaalataan sitten niin, että ne täyttävät koko paneelin jossain sisennyksellä. Kääntämällä komponentin pakettieditorin kautta voit jo kehitysvaiheessa huomata, että paneelin säätimet toimivat oikein skaalattaessa, ja myös, että komponentin kokoa ei saa tehdä pienemmäksi kuin 100x100.

Nyt on hyödyllistä ajaa koko projekti, yrittää syöttää tiedot yksiriviseen tekstieditoriin ja napsauttaa painiketta. Tässä tapauksessa luetteloon ei lisätä mitään. Eikä ole yllättävää, että missään komponentissamme ei ole määritelty, mitä pitäisi tehdä, kun painiketta painetaan. Jotta tapahtumakäsittelijä liitetään napin painallukseen, voit toimia kuten kirjoitettaessa TbuttonBeep-komponenttia, eli määritellä uusi luokka - TButtonin jälkeläinen ja kirjoittaa uudelleen Click-metodi. Uuden luokan määrittäminen vaatii kuitenkin järjestelmäresursseja (virtuaaliset menetelmät kerrotaan). Jos merkitsemme komponentin lomakkeeseen ja katsomme objektiasetinta, huomaamme, että TlistAdd-komponentti paljastaa vain vähän ominaisuuksia eikä mitään tapahtumia, mukaan lukien ei tapahtumakäsittelijöitä OnClick-painikkeelle. Siksi se, mitä hylkäsimme viimeisessä luvussa virheellisenä menetelmänä, OnClick-painikekäsittelijän uudelleenmäärittelyssä, pätee tässä tapauksessa, koska ohjelmoija ei voi osoittaa uutta käsittelijää objektitarkistusohjelmassa. Joten yksityisessä osiossa kuvataan uuden menetelmän otsikko:

Toimenpide BtClick(Lähettäjä:TObject);

TListAdd-konstruktorin toteutuksessa määritämme tämän käsittelijän FButton.OnClick-tapahtumakäsittelijälle:

FButton.OnClick:=BtClick;

Toteutetaan lopuksi BtClick-menetelmä:

Toimenpide TListAdd.BtClick(Lähettäjä:TObject); aloita jos pituus(FEdit.Teksti)>0 ja aloita sitten FListBox.Items.Add(FEdit.Text);

Ensin tarkistetaan, onko yksirivinen editori tyhjä: emme lisää tyhjiä rivejä luetteloon. Sitten siirrämme editorin sisällön listalle (FListBox.Items.Add(FEdit.Text);) ja valmistelemme editorin seuraavan arvon syöttämiseen - eli tyhjennämme sen tekstistä (joka on jo siirretty listaan ) ja siirrä syötteen kohdistus siihen. Nyt sovelluksen kääntämisen ja suorittamisen jälkeen voit varmistaa, että se toimii oikein - kun painat painiketta, editorin sisältö siirtyy luetteloon.

Ominaisuuksien ja menetelmien lisääminen

Jos sijoitat TPanel-komponentin TListAdd-komponentin viereen ja vertailet objektiasetuksissa näkyvää sisältöä, huomaat, että paneelille paljastuu melko suuri määrä ominaisuuksia ja tapahtumia, kun taas TListAddille paljastuu vain muutama ominaisuus. Samaan aikaan TCustomPanel-luokka on molempien komponenttien esi-isä. Ymmärtääksemme syyn, avataan ExtCtrls.pas-moduuli ja tarkastellaan eroa TCustomPanel- ja TPanel-luokkien välillä. Voidaan huomata, että kaikki menetelmät ja muuttujat, jotka tarjoavat paneelin toiminnallisuuden, on määritelty TCustomPanel-luokkatasolla. Se määrittelee myös ominaisuudet, jotka sitten näytetään TPanelin objektitarkistusohjelmassa. Vain nämä ominaisuudet määritellään Suojattu-osiossa. TPanel-luokan toteutus on erittäin yksinkertaista: TCustomPanel on määritelty esi-isäksi, ja tämän luokan ominaisuudet ilmoitetaan, mutta julkaistussa osiossa. Tulee selväksi, mitä TListAdd-luokassa pitää tehdä, jotta TcustomPanel-luokan ominaisuudet ja menetelmät näkyisivät objektin tarkastajassa, eli ominaisuuksien ilmoittaminen. TListAdd-luokan julkaistussa osiossa kirjoitamme:

Kohdista omaisuus;

ominaisuus OnMouseDown;

Katsotaan nyt, kuinka voit ottaa käyttöön uuden kiinteistön (edellä teimme olemassa olevien kiinteistöjen uudelleen ilmoittamisen). Painikkeen tekstiä voidaan käyttää sopivana ominaisuutena näytettäväksi objektiasetuksissa: anna TListAdd-komponenttia käyttävän ohjelmoijan muuttaa tekstiä suunnitteluhetkellä. Yritetään ottaa käyttöön uusi ominaisuus (kutsutaanko sitä BtCaptioniksi) ilmoituksen avulla:

Ominaisuus BtCaption:string lue FButton.Caption kirjoittaa FButton.Caption;

aiheuttaa virheen yritettäessä kääntää komponenttia. Siksi määrittelemme kahden menetelmän otsikot yksityisessä osiossa:

Funktio GetBtCaption:string; menettely SetBtCaption(const Arvo:merkkijono);

Ilmoitamme julkaistussa osiossa BtCaption-ominaisuuden:

Ominaisuus BtCaption:string lue GetBtCaption kirjoittaa SetBtCaption;

Lopuksi toteutamme toteutusosiossa kaksi ilmoitettua menetelmää:

Funktio TListAdd.GetBtCaption:string; begin Tulos:=FButton.Caption; loppu; menettely TListAdd.SetBtCaption(const Arvo:merkkijono); begin FButton.Caption:=Arvo; loppu;

Kun komponentti on käännetty pakettieditorilla, uusi ominaisuus tulee näkyviin Object Inspectoriin. Tämän kiinteistön arvon muutos näkyy suoraan kehitysvaiheessa.

Määritellään nyt uusi tapahtuma. Tässä tapauksessa olisi järkevää luoda tapahtuma, jonka avulla tätä komponenttia käyttävä ohjelmoija voi analysoida tekstiä ennen editorin sisällön lisäämistä luetteloon ja sallia tai estää tekstin lisäämisen luetteloon. Siksi tämän menetelmän tulee sisältää parametrina editorissa olevan tekstin nykyinen arvo ja riippua loogisesta muuttujasta, jolle ohjelmoija voi antaa arvon True tai False. Lisäksi minkä tahansa komponentin tapahtumakäsittelijän on oltava riippuvainen Sender-parametrista, jossa sitä kutsuva komponentti välittää viittauksen itseensä. Tämä on välttämätöntä, koska Delphi-kehitysympäristössä sama tapahtumakäsittelijä voidaan kutsua useasta eri komponentista ja ohjelmoijan tulee pystyä analysoimaan, mikä komponentti on nimeltään käsittelijä. Joten, käyttöliittymäosiossa olevan sanatyypin jälkeen, ennen TListAdd:n määrittämistä, määrittelemme uuden menetelmätyypin:

Kirjoita objektin TFilterEvent=procedure(Lähettäjä:TObject; const EditText:string; var CanAdd:boolean);

FOnFilter:TFilterEvent;

Ja julkaistussa osiossa määrittelemme tämän tyyppisen ominaisuuden:

Ominaisuus OnFilter:TFilterEvent lukea FOnFilter kirjoittaa FOnFilter;

Uutta ominaisuutta määriteltäessä viitataan FOnFilter-muuttujaan, emme menetelmiin - niitä ei vaadita tässä. Jos nyt käännät komponentin pakettieditorilla, voit nähdä OnFilter-tapahtuman näkyvän Object Inspectorissa. Jos kuitenkin määritämme sille käsittelijän ja suoritamme projektin, sitä ei ehkä kutsuta. Tämä johtuu siitä, että emme ole kutsuneet sitä missään komponentissamme. Hyvä paikka kutsua OnFilter-tapahtuma on FButtonin OnClick-tapahtumakäsittelijä, joka on jo toteutettu. Siksi muutamme aiemmin määritellyn BtClick-menetelmän toteutuskoodia:

Toimenpide TListAdd.BtClick(Lähettäjä:TObject); var CanAdd:boolean; aloita jos pituus(FEdit.Teksti)>0 sitten alkaa CanAdd:=True;

jos Assigned(FOnFilter) then FOnFilter(Self,FEdit.Text,CanAdd);<>jos CanAdd aloita FListBox.Items.Add(FEdit.Text);<>FEdit.Text:=""; FEdit.SetFocus; lopuksi piippaus;

loppu; loppu;

Joten yllä olevassa koodinpätkässä looginen muuttuja CanAdd on määritelty. Kun kirjoitat koodia, ota huomioon, että ohjelmoija ei välttämättä luo OnFilter-tapahtumakäsittelijää. Siksi asetamme CanAdd-muuttujan oletusarvoksi True - lisää kaikki rivit luetteloon. Seuraavaksi, ennen kuin kutsut FonFilteriä, tarkista, onko ohjelmoija luonut tapahtumakäsittelijän. Tämä saavutetaan kutsumalla Assigned-metodia, joka palauttaa loogisen arvon. Osoittimen kohdalla Assigned-menetelmän kutsuminen vastaa P:n tarkistamista<="Z"); end;

Koodi on helppo ymmärtää, ainoa varoitus on, että se tarkistaa, ettei teksti ole tyhjä merkkijono ennen kuin tarkistaa tekstin ensimmäisen kirjaimen ListAdd2Filter tapahtumakäsittelijässä. Tällaisen tarkistuksen suorittaminen on pakollista: Object Pascalin merkkijonot ovat objekteja ja tyhjä merkkijono vastaa nolla-osoitinta. Jos yrität tarkistaa tyhjän merkkijonon ensimmäisen kirjaimen, sovellus yrittää poistaa viittauksen nollasta, mikä tekee poikkeuksen. Tässä tapauksessa tämä ei ole ongelma: ennen kuin FOnFilter-tapahtumakäsittelijä kutsutaan TListAdd-komponentista, merkkijono tarkistetaan nollasta poikkeavan pituuden suhteen. Kuitenkin komponenteille, joiden lähdekoodi ei ole saatavillasi, tällainen vahvistus on pakollinen!

Ominaisuuksien piilottaminen Object Inspectorissa

Oletetaan, että teet tiedon käyttökomponentin, esimerkiksi TTable-luokan jälkeläisen. Oletetaan, että tämä komponentti analysoi tietokannassa olevien taulukoiden luettelon ja joidenkin kriteerien perusteella (esimerkiksi tietyn tyyppisen ja tietynnimisen kentän olemassaolo) valitaan työhön. Komponentin normaalia toimintaa varten tämän taulukon nimi on syötettävä TableName-ominaisuuteen. Mutta tämä ominaisuus näkyy esineen tarkastajassa! Tätä komponenttia käyttävä ohjelmoija voi muuttaa sen arvoa kehityksen aikana, mikä oletettavasti tekisi komponentista käyttökelvottoman. Ja hän tulee olemaan oikeassa! Jos jotakin ominaisuuksista tai tapahtumista ei voi muuttaa, ne tulee piilottaa.

Jatkamme TListAdd-komponentin työstämistä ja poistamme Cursor-ominaisuuden objektitarkistuksesta mallitehtävänä. Tämä ominaisuus on määritelty TControl-luokan julkaistussa osiossa, ja se näkyy TListAdd-objektien tarkastajassa komponenttien kehittämisen alusta lähtien. Tämän perusteella voit yrittää määritellä uudelleen tämä omaisuus suojatussa osassa. Kääntäjä sallii tällaisen ohituksen, mutta se ei johda haluttuun tulokseen: Kohdistin-ominaisuus pysyy objektiasetuksissa sellaisena kuin se oli... Mikä tahansa ominaisuus, joka on määritetty julkaistussa osiossa, näkyy aina objektissa tarkastaja kaikille tämän luokan jälkeläisille.

Ominaisuuden piilottamiseen objektitarkastajalta käytämme Delphi-kääntäjän kahta ominaisuutta, nimittäin:

1. Kun ilmoitat uuden ominaisuuden samalla nimellä kuin olemassa oleva ominaisuus, aiemmin määritetty ominaisuus on "varjostettu".
2. Ominaisuudet, joilla on vain luku- tai kirjoitusoikeus, eivät näy objektiasetuksissa, vaikka ne olisi ilmoitettu julkaistussa osiossa.

Ennen kuin alat piilottaa Cursor-ominaisuuden, on hyvä idea poistaa TListAdd-komponentit lomakkeesta, muuten lomakeresurssia luettaessa voi tapahtua poikkeus. Joten yksityisessä osiossa ilmoitamme muuttujan FDummy:integer (muuttujan nimi ja tyyppi voivat olla mitä tahansa) ja julkaistussa osiossa määritämme uuden ominaisuuden:

Ominaisuus Kohdistin:integer lue FDummy;

Uuden ominaisuuden on oltava nimeltään Cursor, sen tyypin on vastattava edellä määritellyn muuttujan tyyppiä, ominaisuuden tulee olla vain luku tai kirjoitus. Kun komponentti on käännetty pakettieditorilla, sinun tulee sijoittaa TListAdd-komponentti lomakkeelle uudelleen. Saatat huomata, että Kohdistin-ominaisuus ei ole enää näkyvissä Object Inspectorissa.

Monimutkaistaan ​​nyt tehtävää hieman. Oletetaan, että haluat, että kohdistin ei näy nuolena, vaan tiimalasina (crHourGlass). Jos haluat muuttaa ominaisuuksien oletusarvoa, uusi arvo on määritettävä muuttujalle konstruktorissa. Kun yritetään määrittää kursorille uusi arvo konstruktorissa

Kohdistin:=crHourGlass;

Delphi-kääntäjä antaa diagnostisen viestin, jossa todetaan, että uutta arvoa ei voida määrittää vain luku -muuttujalle. Jos teet uuden "vain kirjoitus" -ominaisuuden, kääntäjä lähettää toisen diagnostisen viestin – yhteensopimattomista tietotyypeistä. Jos määrität muuttujan FDummy:TCursor ja teet siitä vain kirjoitustavan, kääntäjä sallii tämän määrityksen, mutta kohdistimen ulkonäkö ei muutu: se on silti nuoli.

Triviaali ratkaisu tähän ongelmaan on ilmoittaa TCustomPanelin jälkeläinen luokka, jonka rakentajassa sinun tulee antaa Cursor-muuttujalle uusi arvo ja tuottaa siitä TListAdd-komponenttimme. Tällä ratkaisulla on kaksi haittaa:

1. Se on resurssivaltaista - virtuaaliset menetelmät moninkertaistuvat.
2. Piilotimme kohteen objektitarkastajan ominaisuuden ohjelmoijalta, joka käyttää tätä komponenttia. Haluamme työskennellä tämän kiinteistön kanssa.

Siksi ratkaisu tähän ongelmaan näyttää tältä: TListAdd-konstruktorissa ilmoitamme operaattorin:

Peritty kohdistin:=crHourGlass;

ja siinä se! Tämä riittää kursorin vaihtamiseen.

Aikaisemmin käytimme perittyä funktiosanaa vain esi-isän menetelmän kutsumiseen. Tämän rakenteen avulla voit ymmärtää paremmin periytyneen merkityksen viittauksena esi-isäluokkaan. Voit käyttää sekä ominaisuuksia että menetelmiä. Kun käytät ominaisuutta, voit joko lukea sen tai määrittää sille uuden arvon; tässä tapauksessa apusana peritty näkyy tehtävämerkin vasemmalla puolella. Vastaavasti voit kutsua piilotettuja esivanhempia menetelmiä. Esivanhempien luokkaa korkeammat hierarkiakutsut ovat kiellettyjä - rakentaminen

Peritty peritty Kohdistin:=crHourGlass;

ei kokoa.

Tässä vaiheessa katsomme tämän projektin päättyneeksi. Uudessa komponentissa sieppasimme viestin, määritimme ominaisuudet, lisäsimme uusia ominaisuuksia ja tapahtumia ja piilotimme aiemmin ilmoitetun ominaisuuden. Kaikkia näitä menetelmiä käytetään komponenttien luomiseen. Alla tarkastellaan toista mielenkiintoista menetelmää.

Koukkumenettelyjen käyttäminen komponenttien luomiseen

Aiemmin mainittiin, että jokaisella TWinControl-lapsella on menettely, joka vastaanottaa ja käsittelee viestejä. Jos on viittaus ikkunan kahvaan (HWND), voit määrittää tämän menettelyn osoitteen ja mikä tärkeintä, ohittaa tämän osoitteen ja siten käsitellä vastaanotetut viestit omalla tavallasi. Yleensä kukaan ei kirjoita täydellisiä käsittelijöitä kaikille viesteille; vanhaa oletusmenetelmää kutsutaan useammin. Tässä tapauksessa uutta proseduuria käytetään suodattimena: kun tapahtuma saapuu, koodi suoritetaan. Itse asiassa tämä on "vakooja" TwinControlissa: saamme ilmoituksen, kun viesti saapuu ja jokin koodi voidaan suorittaa. Jos Hook-toiminto on toteutettu oikein, TWinControl jatkaa toimintaansa normaalisti tietämättä, että se jakaa viestejään jonkun muun kanssa.

Koukkumenettely määritellään seuraavasti:

Objektin proseduuri(var Message:TMessage);

Se riippuu TMessage-tyyppisestä muuttujasta, joka sisältää kaikki viestin tiedot. Mutta tämän menettelyn määritteleminen ei riitä. Se on kopioitava jokaiselle TWinControlille, johon se liitetään. Tämä saavutetaan kutsumalla WinAPI-menetelmä MakeObjectInstance. Tämä menetelmä ottaa objektimetodin parametriksi, tekee siitä kopion muistiin ja palauttaa uuden menetelmän osoitteen. On selvää, että tämä varaa järjestelmäresursseja, jotka on palautettava järjestelmään. Tämä saavutetaan kutsumalla FreeObjectInstance-menetelmää.

Toinen tärkeä ehto: ennen TWinControlin tuhoamista viestintä vanhan viestinkäsittelyprosessin kanssa on palautettava, muuten resursseja ei palauteta järjestelmään. Tämä tarkoittaa, että sinun on muistettava osoitin vanhaan proseduuriin, joka löytyy kutsumalla Win API GetWindowLong -metodia parametrilla GWL_WNDPROC. Tätä osoitinta käytetään myös kutsumaan TWinControlin oletustapahtumakäsittelijöitä. Käänteistä menetelmää, SetWindowLong, käytetään Hook-proseduurin asettamiseen.

Joten muotoillaan ongelma seuraavaa harjoitusta varten. Oletetaan, että haluamme luoda komponentin, joka saa muut komponentit - TWinControlin jälkeläiset - piippaamaan, kun hiiren painiketta painetaan. On selvää, että tätä komponenttia ei tule näyttää sovelluksen suorituksen aikana, joten valitsemme TComponentin esi-isäluokaksi. Määritellään luokan nimeksi TBeepWnd. Yksityisessä osiossa määritämme kolme muuttujaa:

FoldProc,FNewProc:osoitin;

FControl:TWinControl;

Nimien perusteella on selvää, että muistamme linkin vanhaan proseduuriin FOLDProc-muuttujassa, linkki uuteen proseduuriin (MakeObjectInstance-metodin suorittamisen jälkeen) tallennetaan FNewProc-muuttujaan. Ja FControl-muuttujaan tallennamme linkin ohjauselementtiin, johon Hook-menettely on tällä hetkellä "riippuva". Määritellään kolme menetelmää samassa osiossa:

Toimenpide HookProc(var Message:TMessage); menettely HookWindow(W:TWinControl); menettely UnhookWindow;

ja toteutusosiossa toteutamme ne:

Itse Hook-proseduurissa siepataan viesti, johon tapahtuu reaktio - WM_LBUTTONDOWN. Lisäksi minkä tahansa Hook-proseduurin on käsiteltävä WM_DESTROY-sanoma. Tämä on viimeinen viesti, joka lähetetään ikkunaan ennen kuin se tuhoutuu. Vastauksemme on palauttaa edellinen menetelmä kutsumalla alla kuvattua UnhookWindow-menetelmää. Lopuksi oletusviestinkäsittelijät kutsutaan kauttaaltaan CallWindowProc-menetelmällä. Oletustapahtumakäsittelijän unohtaminen on sama kuin tapahtumakäsittelijän perimän unohtaminen 80 %:ssa tapauksista, mikä johtaa virheelliseen sovelluksen toimintaan. Älä missään tapauksessa unohda liittää CallWindowProc-menetelmän kutsun tulosta Viesti-muuttujan Result-kenttään! Koodi ei toimi tässä tapauksessa!

Toimenpide TBeepWnd.HookWindow(W:TWinControl); begin if csDesigning in ComponentState then begin (Tarkistaa, onko komponentti suunnittelussa vai ajon aikana) FControl:=W;<>Poistu;<>loppu;

jos FControl

Toimenpide TBeepWnd.UnhookWindow; aloita jos (FControl=nil) tai (FOldProc=nil) tai (FNewProc=nil) sitten Exit; (Koukkua ei asennettu) SetWindowLong(FControl.Handle,GWL_WNDPROC,integer(FOldProc)); (Aseta vanha ikkunamenettely) FreeObjectInstance(FNewProc); (Ilmaiset resurssit) FControl:=nil; (Aloita muuttujat) FOLDProc:=nil;

FNewProc:=nolla; loppu;

Tämä menetelmä palauttaa vanhan tapahtumakäsittelijän. Sitä kutsutaan HookProc-menetelmästä ja se on kutsuttava myös komponentin tuhoajasta - Hook on poistettava sekä ikkunan tuhoutuessa että tämän komponentin tuhoutuessa. SetWindowLong-metodi vanhan menetelmän osoitteella palauttaa vanhan viestinkäsittelijän. Tämän jälkeen sinun tulee palauttaa resurssit järjestelmään kutsumalla FreeObjectInstance-metodi.

Joten perusmenetelmät Hook-menettelyä varten on määritelty. Nyt sinun on kirjoitettava tuhoaja uudelleen, jotta Hook-menettely poistetaan, kun tämä komponentti tuhoutuu:

Destructor TBeepWnd.Destroy; aloita UnhookWindow;

perinnöllinen Destroy; loppu;

Ja lopuksi, julkaistussa osiossa määritämme ominaisuuden, joka näytetään objektiasetuksissa:

ominaisuus Control:TWinControl lukea FControl kirjoittaa HookWindow;

Uuden komponentin asentamiseksi viittaamme aiemmin määritettyyn menetelmään, joka sovelluksen ollessa käynnissä "riittää" komponenttiin välittömästi Hook-proseduurin, joka piippaa, kun painiketta painetaan. Muista, että piippausoperaattorin sijaan voit kirjoittaa minkä tahansa suoritettavan koodin.

Kaikki edellisissä osissa käsitelty liittyy käyttäjille jaettavan sovelluskoodin luomiseen. Delphi-kehitysympäristössä voit kuitenkin muokata itseään. Tämä ei edellytä erityiskielen taitoa, koska kaikki menetelmät kehitysympäristön muuttamiseen on kirjoitettu Delphissä. Tässä näitä menetelmiä, nimittäin ominaisuuseditoreja ja komponenttieditoreja, tarkastellaan osittain - komponenttien kanssa työskentelyyn tarkoitettujen työkalujen luomisen kannalta. Kun luet tämän osan materiaaleja, sinun tulee ymmärtää selvästi, että sovelluksesi kanssa työskentelevä loppukäyttäjä ei koskaan näe ominaisuuseditoria tai komponenttieditoria - ne on luotu ohjelmoijille ja toimivat vain Delphi-kehitysympäristössä.

Kiinteistöjen toimittajat

Sovelluksen kehittämisen aikana ominaisuudet näkyvät Object Inspectorissa. Huomaa, että ominaisuuksia muokataan eri tavalla Object Inspectorissa. Joillekin ominaisuuksille (leveys, kuvateksti) voidaan määrittää vain uusi tekstiarvo. Kohdistintyyppinen ominaisuus tarjoaa avattavan luettelon, jota napsauttamalla voit valita arvon. TFont-tyypin ominaisuudessa on "+"-merkki vasemmalla; Kun napsautat sitä, se laajenee, jolloin voit muokata yksittäisiä kenttiä. Lisäksi oikealla on painike, jossa on kolme pistettä (elliptinen painike), kun sitä napsautetaan, näkyviin tulee ominaisuuden muokkausikkuna.

Jokaisella yllä olevilla ominaisuuksilla on oma editorinsa, ja Delphi-kehitysympäristön suuri etu on mahdollisuus luoda omia ominaisuuseditoreja. Uudet ominaisuuseditorit ovat melko yleisiä hajautettujen komponenttien joukossa. Mutta niihin tulee suhtautua varoen: suorita testit aluksi tietokoneella, johon voit tarvittaessa asentaa Delphin uudelleen. Pääsääntöisesti ne ovat pätevien ohjelmoijien luomia, eikä koodista ole valittamista, mutta usein he unohtavat sisällyttää DLL-tiedostot hajautettuun ominaisuuseditoriin. Tällaisen editorin asentamisen jälkeen saamme useita ominaisuuksia, joita ei voi muokata - vanha editori on estetty, ja uusi ei toimi...

Ennen uuden kiinteistöeditorin luomista on järkevää pohtia, kannattaako tämä tehdä - vakioeditorien joukosta löydät todennäköisesti sopivan. Jos sinun on luotava ominaisuuseditori, sinun on noudatettava sääntöä: sinun tulee välttää editorien luomista vakiotietotyypeille (kokonaisluku, merkkijono jne.). Muut ohjelmoijat ovat tottuneet tavallisiin editoreihin, eivätkä he välttämättä pidä sinun omastasi. Siksi sinun on oltava vaatimaton ja rekisteröitävä editori luokkaasi, ei TComponent-luokkaan. Jos ohjelmoijat pitävät kiinteistöeditoristasi, useimmat heistä voivat muuttaa rekisteröinnin itse niin, että editori toimii kaikille komponenteille. Käsittelemme toimittajan rekisteröintiä alla.

Esitetään siis malliongelma, jonka toteuttamiseksi tulee ottaa käyttöön ominaisuuseditori. Oletetaan, että jollakin komponentilla on ominaisuus - viikonpäivä. Periaatteessa voit syöttää viikonpäivän tavallisella editorilla, jossa on avattava luettelo. Haluamme kuitenkin, että ohjelmoija voi kehitysvaiheessa syöttää viikonpäivän ja määrittää joko sen sarjanumeron (1 - maanantai, 2 - tiistai jne.) tai tekstin kansallisella tai englannin kielellä. Tekstiä syötettäessä isojen ja pienten kirjainten sekoittaminen on sallittua.

Ensinnäkin sinun on luotava komponentti, joka tallentaa viikonpäivän. Luodaan uusi komponentti kutsumalla Komponentti/Uusi komponentti -komento. Valitaan esi-isäluokaksi TComponent ja annetaan uudelle luokalle nimi TDayStore. Asenna sen jälkeen komponentti palettiin. Nyt meidän on päätettävä, missä muodossa viikonpäivä tallennetaan. On selvää, että yksiselitteistä tunnistamista ja resurssien säästämistä varten se tulee tallentaa kokonaislukuna kelvollisilla alueilla 1-7. Jos aiomme kuitenkin luoda ominaisuuseditorin, meidän tulee muistaa sääntö, jonka mukaan olemassa oleville tyypeille ei luoda uusia muokkaajia. Siksi määrittelemme uuden tyypin - TDayWeek, ja teemme sen kanssa kaikki toiminnot kuten kokonaislukujen kanssa. Määritetään FDay-muuttuja komponentin yksityiseen osioon. Koska tämä muuttuja alustetaan 0:ksi, kun oletuskonstruktori suoritetaan, ja tämä luku on sallittujen arvojen ulkopuolella, konstruktori on kirjoitettava uudelleen. Lopuksi määritellään DayWeek-ominaisuus julkaistussa osiossa, jotta se näytetään objektiasetuksissa. Lopullinen komponentti näyttää tältä:

Kirjoita TDayWeek=tyyppi kokonaisluku;

TDayStore = class(TComponent) yksityinen ( Yksityiset ilmoitukset ) FDay:TDayWeek;

suojattu ( Suojatut ilmoitukset ) julkinen ( Julkiset ilmoitukset ) konstruktori Luo(AOwner:TComponent); ohittaa; julkaistu ( Julkaistut ilmoitukset ) omaisuus DayWeek:TDayWeek lukea FDay kirjoittaa FDay;

loppu; ... toteutuskonstruktori TDayStore.Create(AOwner:TComponent); alkaa peritty Luo(Omistaja);

FDay: = 1; loppu;

On syytä kiinnittää huomiota uuden tyypin määritelmän harvinaiseen rakenteeseen

1. TDayWeek=tyyppi kokonaisluku;

   Siten otetaan käyttöön uusi tietotyyppi, joka on samankokoinen kuin kokonaislukutyyppi, kaikki tämän tietotyypin toiminnot suoritetaan kuten kokonaislukujen kanssa. Tämän toiminnon tarkoitus on ilmoittaa uusi tietotyyppi, jotta ominaisuuseditoriamme voidaan soveltaa erityisesti siihen eikä se vaikuta muihin tietotyyppeihin.

   Luodaan nyt editori TDayWeek-omaisuudelle. Tätä varten lisää uusi lomake olemassa olevaan projektiin, muista se jollain sopivalla nimellä (DayPropE.pas) ja sulje se pois projektista. Tämän jälkeen avaamme lomakkeen erillisenä tiedostona ja toteutamme siihen ominaisuuseditorin. Ensimmäisessä vaiheessa emme tarvitse lomaketta, mutta myöhemmin toteutamme siitä dialogin.

   Ominaisuuseditorien luontimoduuli on nimeltään DsgnIntf.pas (Design Interface), se määrittelee perusluokan TPropertyEditor ja jälkeläisluokat, jotka on tarkoitettu vakioominaisuuksien muokkaamiseen - TIntegerProperty, TFloatProperty, TStringProperty jne. Ominaisuuseditorien toimintamekanismi on seuraava:

2. Se rekisteröidään Delphi-kehitysympäristössä kutsumalla RegisterPropertyEditor-metodia. Tämä menetelmä ottaa seuraavat arvot parametreiksi:
3. SetValue-menetelmää kutsutaan, kun ohjelmoija on syöttänyt uuden ominaisuuden arvon Object Inspectoriin. Uusi merkkijono välitetään parametrina. Menetelmässä se on analysoitava ja muunnettava muokattavan ominaisuuden tyypiksi.

GetValue- ja SetValue-menetelmät ovat virtuaalisia, kun ne kirjoitetaan uudelleen, luodaan uusia ominaisuuseditoreja. Joten nyt voimme aloittaa uuden omaisuuseditorin luomisen.

Katsotaanpa DsgnIntf-moduulia DayPropE.pas-moduulin käyttöosiossa ja määritellään uusi luokka Käyttöliittymä-osiossa:

Tyyppi TDWPropED=class(TPertyEditor) julkinen funktio GetValue:string; ohittaa; menettely SetValue(const Arvo:merkkijono); ohittaa; loppu;

Toteutusosion tulisi toteuttaa molemmat menetelmät. Tässä tapauksessa tarvitsemme lisäksi luettelon viikonpäivien nimistä - ongelman alkuperäisessä muotoilussa ohjelmoijan on pystyttävä syöttämään viikonpäivä:

Const DayWeek:array of string = ("maanantai", "tiistai", "keskiviikko", "torstai", "perjantai", "lauantai", "sunnuntai");

• DayWeekEn:array of string = ("maanantai", "tiistai", "keskiviikko", "torstai", "perjantai", "lauantai", "sunnuntai");
• Arvostelu
• Nimeämiskäytännöt
• Esivanhempien valinta

1. DayWeekEn:array of string = ("maanantai", "tiistai", "keskiviikko", "torstai", "perjantai", "lauantai", "sunnuntai");
2. Esimerkki komponentin luomisesta

   Koska Delphi on avoin ympäristö, jonka avulla voit paitsi käyttää visuaalisen komponenttikirjaston (VCL) objekteja ohjelmassasi, myös luoda uusia objekteja. Lisäksi tähän ei vaadita mitään muuta kuin Delphiä. Uuden objektin luominen Delphissä ei ole kovin vaikea tehtävä, vaikka se vaatiikin tietoa Windows API:sta, olio-ohjelmoinnista ja VCL:n luokkahierarkiasta.

3. Kysymys voi herää; Jos Delphillä on jo oma kirjasto, miksi luoda muita objekteja?
4. Vastaus on yksinkertainen: et voi luoda kirjastoa kaikkiin tilanteisiin ja jokaiseen makuun. Ensinnäkin uudet komponentit mahdollistavat Delphin laajentamisen: esimerkiksi kolmannen osapuolen objektikirjastojen avulla voit kehittää sovelluksia Internetissä työskentelemiseen.

   Toiseksi niiden avulla voit täydentää tai mukauttaa VCL:ssä saatavilla olevia objekteja (esimerkiksi ohittaa oletusarvot). 1 Uusien objektien lisääminen VCL:ään

   Napsauta "Lisää" ja määritä rekisteröintimenettelyn sisältävä moduuli, napsauta "OK" ja onnistuneen uudelleenkäännöksen jälkeen uusi objekti ilmestyy palettiin.

5. Tyhjä uutta komponenttia varten
6. Delphi-ympäristössä on erityinen asiantuntija, joka luo mallin uudelle komponentille. Voit kutsua sitä valikkokohdassa Tiedosto|Uusi komponentti... (katso kuva 2)

   
   

   Toiseksi niiden avulla voit täydentää tai mukauttaa VCL:ssä saatavilla olevia objekteja (esimerkiksi ohittaa oletusarvot). 2 : Asiantuntija uuden komponentin luomiseen

   Valintaikkunassa sinun on määritettävä uuden luokan nimi (esimerkiksi TMyButton), luokan esi-isä (TButton) ja palettisivu, johon uusi komponentti sijoitetaan (Samples). Jos napsautat "OK", asiantuntija luo moduulin - mallin uudelle komponentille:

   yksikkö Yksikkö1;

   käyttöliittymä

   käyttää

   SysUtils, WinTypes, WinProcs, viestit, luokat, grafiikka, säätimet,

   Lomakkeet, valintaikkunat, StdCtrl;

   tyyppi

   TmyButton = luokka(TButton)

   yksityinen

   (yksityiset ilmoitukset)

   suojattu

   (Suojatut ilmoitukset)

   julkinen

   (Julkiset ilmoitukset)

   julkaistu

   (Julkaistu ilmoitukset)

   loppu;

   menettely Rekisteri;

   täytäntöönpanoa

   menettely Rekisteri;

   alkaa

   RegisterComponents("Samples", );

   loppu;

   loppu.

   Moduuli sisältää uuden luokan ilmoituksen ja menettelyn sen rekisteröimiseksi Komponenttipalettiin. MenettelyssäRegisterComponents ensimmäinen parametri on sivun nimi (voit määrittää nimesi - uusi sivu tulee näkyviin); toinen parametri on joukko rekisteröitäviä objekteja.

   Nyt sinun on tallennettava moduuli uudella nimellä (esimerkiksi NEW_BTN.PAS) ja aloitettava uusien ominaisuuksien ja menetelmien lisääminen. Kun tämä työ on valmis ja uuden komponentin virheenkorjaus on tehty, voit lisätä sen palettiin (katso edellinen luku). Mutta ennen sitä on suositeltavaa luoda resurssitiedosto, joka sisältää kuvakkeen edustamaan tätä objektia komponenttipaletissa. Resurssitiedosto voidaan luoda Resource Workshop -ohjelmalla, sen on nimettävä täsmälleen samalla tavalla kuin komponentin rekisteröintimoduulilla ja sen tunniste on .DCR (eli jos objekti on rekisteröity NEW_B-moduuliin TN .PAS, resurssitiedoston nimi on NEW_BTN.DCR). Resurssitiedoston tulee sisältää BITMAP-tyyppinen resurssi - kuva, jonka koko on 28x28 pikseliä (pienempi jos mahdollista), kuvan nimen tulee vastata luokan nimeä (tapauksessamme TMYBUTTON).

7. Arvostelu

Jos olet katsonut VCL-lähdekoodia, olet ehkä huomannut, että se noudattaa muutamia yksinkertaisia ​​käytäntöjä määriteltäessä uusia luokkia. Delphi ei vaadi tätä, menetelmien nimet, ominaisuudet jne. voi olla mitä tahansa, kääntäjä ei välitä. Mutta jos noudatat näitä käytäntöjä, uusien komponenttien kehittäminen ja lähdekoodin lukeminen tulee paljon helpommaksi.

Niin:

• Kaikki tyyppimääritykset alkavat kirjaimella T. Delphi ei taaskaan vaadi tätä, mutta tekee selväksi, että esimerkiksi "TEdit" on tyyppimäärittely, ei luokkamuuttuja tai kenttä.
• Kiinteistöjen nimien tulee olla helposti luettavia ja informatiivisia.
• Meidän on muistettava, että käyttäjä näkee ne Object Inspectorissa. Ja nimi, kuten "TextOrientation" on paljon kätevämpi kuin "TxtOr". Sama pätee menetelmiin.
• Käyttäjien käytettävissä olevilla menetelmillä tulee olla käyttäjäystävälliset nimet.
• Tapahtumatyyppisiä ominaisuuksia luotaessa tällaisen ominaisuuden nimen tulee alkaa kirjaimella "On" (esimerkiksi OnClick, OnCreate jne.).
• Omaisuuden lukumenetelmän nimen tulee alkaa sanalla "Get".

Esimerkiksi GetStyle-metodin on luettava Style-ominaisuus.

1. Nimeämiskäytännöt

Ominaisuuden kirjoittamismenetelmän nimen tulee alkaa sanalla "Set".

• Esimerkiksi SetStyle-metodin on kirjoitettava Style-ominaisuuteen. Kiinteistötietojen tallennuskentän sisäisessä kentässä tulee olla F-kirjaimella alkava nimi.
• Esimerkiksi Handle-ominaisuus voidaan tallentaa FHandle-kenttään. Tietysti sääntöihin on poikkeuksia. Joskus on kätevämpää rikkoa ne, esimerkiksi TTable-luokassa on Tapahtumatyyppi-ominaisuudet nimeltä BeforePost, AfterPost jne.
• Ennen kuin aloitat koodin kirjoittamisen, sinun on päätettävä ainakin suunnilleen, millaisen komponentin aiot luoda. Seuraavaksi määritä esivanhempien luokka sen odotettujen ominaisuuksien perusteella. VCL:llä on useita perusluokkia, joita suositellaan periytymiseen: TOobjekti
• - Voidaan käyttää esi-isänä, jos tätä komponenttia ei tarvitse työstää suunnittelun aikana. Tämä voi olla esimerkiksi luokka, joka sisältää ympäristömuuttujien arvot, tai luokka INI-tiedostojen kanssa työskentelemiseen. TComponent
• - Lähtökohta monille näkymättömille komponenteille. Tällä luokalla on sisäänrakennettu kyky tallentaa/lukea itsensä streamiksi suunnittelun aikana. TGraphicControl
• - Käytä tätä luokkaa luodaksesi näkyviä komponentteja, jotka eivät tarvitse kahvaa. Tällaiset komponentit piirtyvät suoraan pinnalle ja vaativat vähän Windows-resursseja. - Luokka, kuten TEdit tai TButton. Niitä käytetään niiden ominaisuuksien ja menetelmien määrittämiseen tai ominaisuuksien oletusarvojen uudelleenmäärittämiseen.

1. Esivanhempien valinta

Luodaan esimerkiksi uusi luokka, TButton-mutantti, jossa muutetaan ShowHint-ominaisuuden oletusarvoksi True ja lisätään uusi ominaisuus - painikkeen klikkauslaskuri. Uuden komponentin luomista varten on jo moduulimalli (katso kappale Tyhjä uutta komponenttia varten). Nyt lähdeteksti näyttää tältä:

yksikkö Uusi_btn;

käyttöliittymä

käyttää

SysUtils, WinTypes, WinProcs, Viestit, Luokat, Grafiikka,

Säätimet, lomakkeet, valintaikkunat, StdCtrl;

tyyppi

TmyButton = luokka(TButton)

yksityinen

(yksityiset ilmoitukset)

FClickCount: Longint;

suojattu

(Suojatut ilmoitukset)

julkinen

(Julkiset ilmoitukset)

konstruktori Luo(AOmistaja: TComponent); ohittaa;

menettely Napsauta; ohittaa;

ominaisuus ClickCount: Longint read FClickCount kirjoittaa

FClickCount;

julkaistu

(Julkaistu ilmoitukset)

loppu;

menettely Rekisteri;

täytäntöönpanoa

rakentaja TMyButton.Create(AOwner: TComponent);

alkaa

peritty Luo(AOwner);

ShowHint:=Tosi;

FClickCount:=0;

loppu;

menettely TMyButton.Click;

alkaa

Inc(FClickCount);

perittyNapsautus;

loppu;

menettely Rekisteri;

alkaa

RegisterComponents("Samples", );

loppu;

loppu.

Jotta voit ohittaa ominaisuuden alkuperäisen arvon objektia luotaessa, sinun on kirjoitettava rakentaja uudelleenLuoda jossa määrität halutun arvon tälle ominaisuudelle (unohtamatta kutsua ensin esi-isän konstruktoria).

Uusi ominaisuus näppäinpainallusten laskemiseen on nimeltäänClickCount. Sen sisäinen kenttä arvon tallentamiseen - FClickCount on Longint-tyyppinen, kenttäkapasiteettia riittää pitkään.

Olemme jo tutustuneet komponentteihin Delfoi artikkelissa, ja vaikka emme vieläkään ymmärrä ohjelmoinnista mitään, uskon silti, että haluamme jo alkaa luoda jotain itse mahdollisimman nopeasti. Siksi ehdotan juuri nyt, että kirjoitat ensimmäisen hakemuksesi Delphiin ja mietit, miten ja missä ohjelmakoodi kirjoitetaan, sekä katsoa mitä Delphi tekee ohjelmia luodessaan ja miten luotu projekti rakentuu. No, sen jälkeen siirrymme teorian lisätutkimukseen.

Tietokonekirjallisuudessa on tapana kirjoittaa ensimmäinen sovellus, joka näyttää merkinnän "HelloWord" näytöllä, mutta muutamme sitä hieman ja luomme ensimmäisen sovelluksemme, joka näyttää merkinnän "Hei Delphi".

On selvää, että meidän on ensin käynnistettävä itse Delphi. Kun kuoriikkuna on avautunut edessämme, luomme uuden projektin Tiedosto | Uusi | VCL-lomakehakemus - Delphi.

Katsotaan nyt projektipäällikköä. Alla olevassa kuvassa on ikkuna, jossa kaikki puun oksat on laajennettu, jotta voimme tarkastella kaikkia uuden projektin komponentteja.

Piirustus. Luotavan sovelluksen projektipäällikkö

Kokonainen puu on ilmestynyt projektipäällikköön. Katsotaanpa tämän puun jokaista kohtaa.

ProjectGroup1 (Puun otsikko)- projektiryhmän nimi. Yhdessä projektiryhmässä voi olla useita hakemuksia. Meidän tapauksessamme loimme yhden uuden sovelluksen, joten vain tämä tulee ryhmään. Jos napsautat Project Manager -ikkunassa Uusi-painiketta ja luot uuden sovelluksen, se lisätään olemassa olevaan projektiryhmään.

Project1.exe- hankkeen (hakemuksen) nimi. Kun luomme uuden sovelluksen, Delphi antaa sille nimen Project ja järjestysnumeron.

Yksikkö1.pas- moduuli. Projekti koostuu moduuleista. Jokainen ohjelmaikkuna on tallennettu erilliseen moduuliin, ja näemme näytöllä, että sovelluksellamme on ikkuna, ja juuri tämä ikkuna sijaitsee siinä. Tiedostot, joissa on laajennus pas sisältää moduulin lähdekoodin. Tiedostonimi on sama kuin moduulin nimi.

Yksikkö1.dfm on visuaalinen muoto. Se tallennetaan tiedostoon, jolla on sama nimi kuin moduuli, mutta tunnisteella dfm.

Kun meillä on useita sovelluksia projektissa, vain yksi niistä on aktiivinen, ja juuri tätä voimme suorittaa ja korjata Delphi-kuoriympäristössä. Aktiivisen sovelluksen nimi kirjoitetaan lihavoituna. Voit vaihtaa aktiivisen sovelluksen kaksoisnapsauttamalla sen nimeä hiiren vasemmalla painikkeella tai napsauttamalla hiiren kakkospainikkeella halutun projektin nimeä ja valitsemalla pikavalikosta Aktivoi.

Mutta nyt työskentelemme vain yhden sovelluksen kanssa, joten jos loit kaksi, toinen on poistettava. Voit tehdä tämän valitsemalla sovelluksen nimen ja painamalla näppäimistön Poista-painiketta. Edessämme avautuu ikkuna, joka vahvistaa poiston. Jos napsautat Kyllä, sovellus poistetaan projektiryhmästä.

On huomattava, että tiedostoja ei itse asiassa poisteta levyltä. Ne pysyvät paikoillaan, mutta eivät näy projektissamme. Siksi, jos tallensimme projektin, emmekä enää tarvitse tiedostoja, voimme löytää nämä tiedostot ja poistaa ne manuaalisesti. Jos meillä ei ollut aikaa tallentaa tiedostoja, ne eivät luonnollisesti ole levyllä.

Tallennetaan uusi sovelluksemme. Voit tehdä tämän valitsemalla päävalikosta Tiedosto | Tallenna kaikki. Edessämme avautuu tavallinen tiedostojen tallennusikkuna. Aluksi Delphi pyytää sinua antamaan moduulin nimen. Oletuksena nykyinen nimi on Unit1.pas. Muutetaan se MainUnitiksi ja klikataan Tallenna-painiketta.

Tässä on huomioitava, että et voi kirjoittaa nimiä välilyönneillä tai venäjäksi. Jos yrität syöttää jotain tällaista, tapahtuu virhe, tiedostoasi ei tallenneta ja sinun on toistettava tallennusprosessi uudelleen. Muista valita kansio, johon haluat tallentaa moduulin ja projektit. On suositeltavaa, että kaikki yhden projektin tiedostot tallennetaan yhteen kansioon, ainakin aluksi, kunnes saat kokemusta.

Kun olemme tallentaneet pääyksikön, Delphi kysyy meiltä tulevan projektin nimeä. Koska päätimme kirjoittaa uuden hakemuksen nimeltä Hei Delphi, esitellään sitten HelloDelphi täällä. Projektin nimi sekä moduulin nimi tulee syöttää ilman välilyöntejä ja vain latinalaisin kirjaimin. Kun olet syöttänyt projektin nimen, voimme napsauttaa Tallenna-painiketta. Projekti tallennetaan tiedostoon nimellä HeiDelphi.dpr. Kun haluamme avata tämän projektin uudelleen, meidän on avattava tämä tiedosto. Tiedostoja ei tarvitse avata tunnisteella pas, koska se on vain olennainen osa projektia. Sinun on avattava tiedostot tunnisteella dpr.

Yritä valita nimet, jotka kuvastavat parhaiten moduulin sisältöä, jotta myöhemmin on helpompi ymmärtää, mitä tiedostot tarkoittavat suurissa projekteissa. Lisäksi on hyvä muistaa, että projektin nimi määrittelee projektin tulevan suoritettavan ohjelmatiedoston nimen. Jos jätät nimeksi Project 1, suoritettavan tiedoston nimi on Project1.exe.

On suositeltavaa tallentaa projektit erillisiin kansioihin. On parempi, että jokaiselle projektille on erillinen kansio, koska jokainen projekti koostuu useista tiedostoista, ja kun meillä on suuria projekteja, emme voi erottaa niitä toisistaan, jos ne ovat samassa kansiossa. Tämän projektin kansioon kannattaa myös tallentaa kaikki projektia varten luomamme lisälomakkeet tai moduulit. Tässä tapauksessa meidän on helpompi kopioida ne toiselle tietokoneelle, arkistoida tai siirtää toiseen kansioon.

Katsotaan nyt kuinka projektipäällikkömme on vaihtunut. Kuten näet, projektin nimi on muuttunut HelloDelphiksi ja moduulin nimi MainUnitiksi.

Avataan nyt kansio, johon tallensimme projektimme ja katsotaan mitä tiedostoja siellä on.

1. HelloDelphi.cfg- tiedostot tunnisteella cfg, sisältävät projektin määritykset.

2. HelloDelphi.dof- tiedostot tunnisteella dof, sisältävät projektivaihtoehtoja.

3. HelloDelphi.dpr- tiedostot tunnisteella dpr, tämä on itse projekti. Tämä tiedosto sisältää kuvauksen projektissa käytetyistä moduuleista ja ohjelman alustuskoodin. Sitä voidaan käyttää myös koodin kirjoittamiseen. Tulevaisuudessa selvitetään, mitä tähän moduuliin voidaan kirjoittaa ja miksi.

4. HelloDelphi.res- tiedostot tunnisteella res, sisältävät projektiresursseja, kuten kuvakkeita, kohdistimia jne. Delphi sijoittaa oletusarvoisesti vain kuvakkeen tähän tiedostoon, mutta tämä ei tarkoita, että et voi käyttää tiedostoa muiden resurssien tallentamiseen.

5.MainUnit.pas- tiedostot tunnisteella pas, sisältävät moduulien lähdekoodin.

6.MainUnit.dfm- tiedostot tunnisteella dfm, sisältävät visuaalista tietoa muodosta.

7.MainUnit.ddp- tiedostot tunnisteella ddp, määrittää moduulin aputiedostoja, kuten kaavioita. Jos et käytä kaavioita, voit poistaa nämä tiedostot, vaikka ne silti luodaan.

8.MainUnit.dcu- tiedosto tunnisteella dcu, edustaa koottua projektimoduulia välimuodossa. Kun ohjelma käännetään, kaikki moduulit käännetään DCU-muotoisiksi tiedostoiksi ja kootaan sitten yhdeksi, jolloin saadaan yksi suoritettava tiedosto. Jos moduuli ei ole muuttunut viimeisen käännöksen jälkeen, Delphi ohittaa sen ja käyttää olemassa olevaa DCU-muotoista tiedostoa rakentamisen aikana käännösnopeuden lisäämiseksi. Et voi vielä saada tätä tiedostoa, koska et ole vielä kääntänyt projektiasi.

Lähdekooditiedostot (pas-tunnisteella) ovat tekstitiedostoja, joita muokkaamme koodieditorissa. Visuaaliset lomaketiedostot (dfm-tunnisteella) luodaan automaattisesti, ja ne tallentavat tietoa lomakkeen sisällöstä sekä itse lomakkeen asetukset. Avasin tämän tiedoston Notepadilla ja näin siellä:

objektin muoto1: TForm1
Vasen = 0
Yläosa = 0
Kuvateksti = "lomake1"
ClientHeight = 213
ClientWidth = 455
Väri = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = "Tahoma"
Fontti.Tyyli =
OldCreateOrder = False
PixelsPerinch = 96
Tekstin korkeus = 13
Loppu

Ensimmäinen rivi ilmaisee kohteen, sen nimen ja tyypin. Sitten on luettelo kohteen ominaisuuksista ja niille määritetyistä arvoista. Komponenttien ominaisuuksien kuvaus päättyy avainsanaan loppu.

Jos sinulla on ongelmia lomakkeen avaamisessa, voit avata visuaalisen lomaketiedoston tekstieditorissa ja säätää tarvittavaa ominaisuutta. Tämä voi olla tarpeen, kun lomakkeessa on komponentti, joka muodostaa yhteyden tietokantaan. Jos yhteys on aktiivinen ja tietokanta ei ole käytettävissä, silloin kun avaat lomakkeen, Delphi yrittää muodostaa yhteyden tietokantaan, ja jos yhteys ei onnistu, lomake ei välttämättä näy. Tässä tapauksessa sinun on avattava tällainen tiedosto tekstieditorissa ja muokattava tietokantayhteyden ominaisuuksia. Voit katkaista yhteyden tai korjata polun toiseen tietokantaan (itse tietokannoista puhumme myöhemmin).

Palataan nyt HelloDelphi-ohjelmaan, joka meidän on kirjoitettava. Katsotaanpa ensin, mitä meillä jo on. Periaatteessa emme ole tehneet mitään erikoista, mutta meillä on jo valmiina ikkuna, joka voidaan muuttaa ohjelmaksi. Tätä varten sinun on koottava projekti. Kokoaksesi projektin valitse kohde valikosta Projekti | Kääntää HelloDelphi tai paina Ctrl+F9. Jos emme ole muuttaneet mitään Delphin asetuksissa, meidän pitäisi nähdä kokoamisen tilaikkuna.

Piirustus. Kokoonpanon tilaikkuna Delphissä

Selvitetään, mitä tämä ikkuna näyttää meille.

Tämä ikkuna näyttää kokoamisen tilan melko hyvin. Kolme merkitystä kiinnostaa.

Vihjeitä- viestejä. Nämä ovat yksinkertaisia ​​viestejä, jotka osoittavat paikkoja, joissa koodia voidaan parantaa. Olet esimerkiksi ilmoittanut muuttujan, mutta et käyttänyt sitä. Tässä tapauksessa vastaava viesti tulee näkyviin. Tämä ei tietenkään ole virhe, ja ohjelma kääntää silti. Mutta näiden viestien ansiosta voit nähdä, missä ylimääräinen muuttuja on ilmoitettu tai kenties jotain vain unohdettu.

Varoitus-varoitukset. Sinun on kiinnitettävä niihin enemmän huomiota. Olet esimerkiksi ilmoittanut muuttujan ja yrittänyt sitten käyttää sitä antamatta alkuarvoa. Tässä tapauksessa varoitus tulee näkyviin. Jälleen, tämä ei ole virhe ja ohjelma kääntää, mutta Delphi varoittaa mahdollisesta virheestä. Tällaiset varoitukset on tarkistettava, koska saatat todella unohtaa tehdä jotain, ja tämä voi jo johtaa kohtalokkaaseen ohjelman suoritusvirheeseen.

Virheet- Nämä ovat todellisia virheitä. Ne osoittavat paikat, joissa on tehty vakava virhe, minkä vuoksi ohjelmaa ei voida kääntää.

Kuten näet, meillä ei ole viestejä, varoituksia tai virheitä. Ja tämä on ymmärrettävää, koska emme ole vielä tehneet mitään emmekä ole ehtineet pilata meille luotua työkappaletta. Ohjelma on koottu. Napsauta vain OK ja tämä ikkuna sulkeutuu. Voit saada ikkunan katoamaan automaattisesti, kun käännös on valmis, valitsemalla Sulje automaattisesti onnistuneen käännös -ruudun, mutta en suosittele tätä.

Palataan nyt takaisin kansioon, johon projektin tallensimme, ja katsotaan, mikä on muuttunut. Suoritettava tiedosto ilmestyi tähän kansioon HeiDelphi.exe. Käynnistä se ja näemme tyhjän ikkunan.

Muutetaan lomakkeemme otsikko muotoon Hei Delphi. Kuten tiedät, Delphissä kaikki objektit, mikä tarkoittaa, että ohjelmaikkuna on myös objekti. Ikkunan otsikko on todennäköisesti ikkunan ominaisuus. Jos haluat muuttaa tätä ominaisuutta, sinun on mentävä objektien tarkastajaan (Ominaisuudet-välilehti), etsittävä Caption-ominaisuus ja syötettävä sana HelloDelphi sen syöttökenttään (nyt meillä on Form1 kirjoitettuna sinne ja kun suoritamme HelloDelphi.exe-tiedoston, näemme lomakkeen otsikolla Form1). Tämän jälkeen voit painaa Enter tai yksinkertaisesti siirtyä toiselle riville, jolla on eri ominaisuus.

Suoritetaan tämän jälkeen ohjelmamme. Voit tehdä tämän kääntämällä sen uudelleen ja suorittamalla tiedoston. Tällä kertaa teemme kuitenkin asiat toisin. Valitse Suorita-valikosta Suorita (tai paina näppäimistön F9-näppäintä). Delphi kääntää ja suorittaa valmiin ohjelman välittömästi. Kuten näette, ohjelmointi ei ole niin pelottavaa kuin miltä näyttää ensi silmäyksellä.

Piirustus. Objektin tarkastaja. Tekstitysominaisuuden muuttaminen

Oppitunnin liitteenä (artikkeli) lähde, jota katsomalla voit tutustua ohjelman täydelliseen lähdekoodiin ja nähdä kuinka luotu ohjelma toimii. Lähdekoodin mukana on kommentteja, jotta voit helposti ymmärtää sen. Mutta suosittelen tekemään kaiken itse. Näin ymmärrät paremmin ja nopeammin, mitä tällä oppitunnilla käsiteltiin.

Jotta voisi ladata Delphin lähde Tätä oppituntia varten sinun on vierailtava mainostajan verkkosivustolla. Tämän jälkeen linkki Delphin lähde HelloDelphi-tunnille. Ensimmäisen sovelluksemme luominen Delphissä
Napsauta tätä linkkiä

Julkaisupäivä

Kaikkia lomakkeita ei tarvitse luoda, kun sovellus käynnistyy. Jotkut on parempi luoda ohjelman ollessa käynnissä.

Missä tapauksessa on parempi luoda lomake dynaamisesti?

Haluaisin korostaa kahta pääkohtaa.

1. Jos lomaketta käytetään harvoin ja on suuri todennäköisyys, että sitä ei kutsuta ollenkaan. Esimerkki olisi Tietoja-ikkuna.
2. Jos ikkunamme esiintymien määrä voi olla enemmän kuin yksi.

Kuten aina, näytän sinulle, kuinka lomake luodaan dynaamisesti esimerkin avulla.

Esimerkki dynaamisesta lomakkeen luomisesta.

1. Napsauta päävalikon kohtaa "Tiedosto".
2. Sitten uusi.

Ohjelma itse hahmotteli tulevan muodon luokan. Koska Luomme ikkunan painamalla painiketta, suosittelen poistamaan seuraavat koodirivit.

var Form2: TForm2; // Jos annoit lomakkeelle nimen, tämä koodin osa vaihtelee

Järjestämme ilmoituksen paikallisesti, nappikäsittelijän sisällä. Tallennetaan tuloksena oleva moduuli.

Palataan nyt päälomakkeeseen. Yhdistetään äskettäin luotu moduuli siihen: Tiedosto->Käytä yksikköä...-> Valitse tarvitsemasi (voit lisätä sen Käyttökohteet-osioon).

Luodaan kaksi painiketta. Luomme uuden ikkunan kahdella eri tavalla:

menettely TForm1.Button1Click(Lähettäjä: TObject); var Form2: TForm2; begin Form2:= TForm2.Create(Application);

Form2.Caption:= "Uusi lomake, menetelmä 1";

Form2.Show; loppu;

menettely TForm1.Button2Click(Lähettäjä: TObject); var Form2: TForm2; alkaa Application.CreateForm(TForm2,Form2); Form2.Caption:= "Uusi lomake, menetelmä 2"; Form2.Show; loppu; No, kaikki on hyvin yksinkertaista, mutta jos sinulla on vielä kysyttävää, kirjoita kommentteihin. Vastaan ​​kerran. Kehitys

ohjelmisto

Windows-käyttöjärjestelmälle ja muille suosituille voidaan tehdä erilaisilla työkaluilla. Niistä, joille on ominaista suuri suosio venäläisten ja ulkomaisten ohjelmoijien keskuudessa, ovat: Delphi ohjelma. Mitkä ovat tämän kehitystyökalun erityispiirteet? Mitkä ovat sen merkittävimmät ominaisuudet? Yleistä tietoa Delphistä Delphi - kehitysympäristö

sovellusohjelmia , jotka on suunniteltu toimimaan Windowsissa, MacOS:ssa sekä mobiililaitteissa käyttöjärjestelmät

- iOS ja Android. Sille on ominaista kielen ja koodin luontimenettelyjen yksinkertaisuus.

Tarjoaa tarvittaessa matalan tason viestintää käyttöjärjestelmän ja C- ja C++-kielellä kirjoitettujen kirjastojen kanssa. Delphillä luodut ohjelmat eivät vaadi kolmannen osapuolen komentotuloksia, kuten Java-virtuaalikonetta. Delphi on kehitysympäristö, jota voivat menestyksekkäästi käyttää sekä ammattilaiset että koulutustarkoituksiin. Peruskykynsä hallitsemiseksi ei vaadita korkeaa pätevyyttä ja tietoa monimutkaiset kielet ohjelmistotuote mistä me puhumme. Kun tietty IT-yritys perustelee kehitysympäristön valintaa, Delphistä tulee monien ohjelmoijien valinta, ja he suosittelevat sitä käyttöön. Tämä johtuu siitä, että annettu ympäristö avulla voit luoda sovelluksia nopeimmassa mahdollisessa ajassa, tarjota niitä korkea suorituskyky jopa niissä tietokoneissa, joissa on vaatimattomat laitteistotiedot. Merkittävä argumentti kyseisen kehitysympäristön valinnan puolesta on se, että sitä voidaan täydentää uusilla työkaluilla, joita ei ole tarjottu standardi setti Delphi-rajapinnassa olevia ratkaisuja.

Tutkikaamme nyt Delphi-ominaisuuksien käytännön käytön vivahteita.

Käyttöliittymän yksityiskohdat

Ensinnäkin voit kiinnittää huomiota joihinkin kyseisen ohjelmistokehitysympäristön käyttöliittymän ominaisuuksiin. Siten ohjelman työtilan rakenne olettaa samanaikainen työ useilla pääikkunoilla. Tarkastellaan tätä ominaisuutta tarkemmin.

Delphi-kehitysympäristö, erityisesti versio 7, sisältää seuraavien avainmoduulien käytön: lomakesuunnittelija, editori, paletti, objektitarkistus ja hakuteos. Joissakin Delphi-muokkauksissa merkityt komponentit voivat olla nimetty eri tavalla. Esimerkiksi editori voi vastata ohjelmakoodi-ikkunaa ja suunnittelija voi vastata lomakeikkunaa. Kuitenkin toiminnallinen tarkoitus heidän tulee olemaan samat. Merkityt kohteet Delphi käyttöliittymä voi täydentää erilaisia ​​apuvälineitä. Kahta ensimmäistä pidetään tärkeimpinä ohjelmakehitysmenettelyjen kannalta. Mutta loput ovat myös tärkeitä. Katsotaanpa merkittyjen Delphi-moduulien käytön ominaisuuksia.

Lomakkeiden suunnittelija, editori ja paletti

Lomakkeen suunnittelijan avulla kehittäjä luo käyttöliittymän ohjelmalleen. Sen koodi puolestaan ​​​​kirjoitetaan editoriin. Monet ohjelmoijat suosittelevat Delphi-kehitysympäristön valitsemista eniten optimaalinen ratkaisu, argumenttina he mainitsevat muotosuunnittelijan helppokäyttöisyyden. Jotkut asiantuntijat uskovat, että tämä prosessi on enemmän kuin peli.

Heti kun käyttäjä aloittaa ohjelman luomisen ja käynnistää lomakesuunnittelijan, siinä ei aluksi ole elementtejä, se on tyhjä. Mutta voit täyttää sen välittömästi käyttämällä työkaluja, jotka sijaitsevat toisessa Delphi-moduulissa - paletissa. lomakesuunnittelijassa konfiguroituja ohjelmia on ohjattava komennoilla, jotka puolestaan ​​​​kirjoitetaan editorissa.

Mutta palataan nyt palettiin. Sen avulla voit sijoittaa tarvittavat objektit lomakesuunnittelualueelle. Jotta voit käyttää tiettyä työkalua, sinun tulee napsauttaa sitä kerran - kun se on palettialueella, ja toisen kerran - lomakesuunnitteluikkunassa. Tämän jälkeen vastaava objekti siirtyy kehitysalueelle ja voit kirjoittaa sille koodin editorissa.

Objektin tarkastaja

Toinen tärkeä Delphin sisältämä elementti - sovelluskehitysympäristö Windows-käyttöjärjestelmälle ja muille yleisille alustoille - on objektitarkistus. Saatat huomata, että siinä näkyvät tiedot muuttuvat: tähän vaikuttaa lomakkeen suunnittelualueella valitun objektin tila.

Kohteen tarkastajan rakenne on seuraava. Se koostuu kahdesta ikkunasta. Jokainen niistä sisältää algoritmeja, jotka määrittävät vastaavien komponenttien käyttäytymisen. Ensimmäinen näyttää ominaisuuksia, toinen näyttää tapahtumat. Jos ohjelmoija haluaa tehdä säätöjä algoritmeihin, jotka vaikuttavat tiettyyn komponenttiin, käytetään objektitarkastajan ominaisuuksia. Voit esimerkiksi muuttaa tiettyjen ohjelman käyttöliittymäelementtien sijaintia, niiden korkeutta ja leveyttä.

Object Inspectorissa on välilehtiä, joiden avulla voit vaihtaa sivujen välillä, jotka näyttävät ominaisuuksia tai tapahtumia, jotka liittyvät suoraan editoriin. Joten jos kaksoisnapsautat minkä tahansa näytöllä näkyvän kohteen oikeaa puolta, tiettyä tapahtumaa vastaava koodi tallennetaan editoriin.

Delphin ohjelmistokehitykseen sisältyy Object Inspectorin käyttäminen ongelmien ratkaisemiseen erilaisia ​​tehtäviä. Tämän määrää se tosiasia, että tämän työkalun avulla voit muuttaa käytännössä kaikkien lomakkeella olevien objektien ominaisuuksia sekä itse lomaketta. Katsotaanpa tarkemmin joitain esineen tarkastajan kanssa työskentelyn ominaisuuksia.

Objektin tarkastaja: Ominaisuuksien käyttäminen

Ymmärtääksesi, kuinka Delphi IDE toimii Object Inspectorin ja Form Inspectorin välisessä vuorovaikutuksessa, voit yrittää tehdä muutoksia joidenkin Windowsin yleisten ohjelmistoliittymäelementtien ominaisuuksiin - esimerkiksi muistiin, painikkeeseen ja luettelolaatikkoon (me teemme tutkia niiden olemusta tarkemmin hieman myöhemmin). Ensin sinun on asetettava ne lomakkeelle käytettävissä olevilla Delphi-työkaluilla.

Voit kokeilla kokeilla Ctl3D-ominaisuutta. Voit tehdä tämän napsauttamalla lomaketta, siirtymällä objektitarkastajaan ja muuttamalla kyseisen kiinteistön arvoa. Tämän jälkeen lomake muuttuu merkittävästi. Samalla Ctl3D-ominaisuus muuttuu jokaisessa suunnitteluikkunaan sijoitetussa elementissä.

Kun kokeet on suoritettu, voimme palata lomakkeeseen ja aktivoida Ctl3D-arvon. Sen jälkeen katsotaan Memo- ja Listbox-elementtejä. Nyt voit muuttaa niiden ominaisuuksia, sijaintia lomakkeella ja ulkoasua. Esimerkiksi valitsemalla valikosta Muokkaa-vaihtoehdon ja sitten Koko, ohjelmoija voi muuttaa objektien leveyttä ja korkeutta. Voit keskittää ne valitsemalla Muokkaa ja Tasaa. Vastaavat toimet vaikuttavat Object Inspectorissa näkyviin elementteihin.

Kyseisellä Delphi-moduulilla voit muuttaa komponenttien ominaisuuksia. Joten esimerkiksi jos tehtävänä on määrittää heille tietty väri, eli vaihtoehtoja useiden työkalujen käyttämiseen kerralla. Ensinnäkin alueelle voidaan syöttää väriä vastaava komento - esimerkiksi punainen - clRed. Toiseksi käyttäjä voi valita haluttu väri luettelosta. Kolmanneksi on mahdollisuus kaksoisnapsauttaa Väriominaisuuksia - värin valintaikkuna tulee näkyviin. Samoin kehittäjä voi muuttaa objektien muita attribuutteja - esimerkiksi fonttityyppiä, sen väriä tai kokoa.

Hakemisto

Delphi on kehitysympäristö, jota täydentävät melko yksityiskohtaiset apujärjestelmä. Pääset siihen valitsemalla valikosta Ohje. Tämän jälkeen yksi yllä mainitsemistamme näkyy ikkunassa. ohjelmistomoduulit kyseinen kehitysympäristö - hakuteos. Sen käytön erikoisuus on, että kun painat F1, käyttäjä saa tietyn vihjeen, joka kuvastaa nykyisen työkalun käytön erityispiirteitä. Jos esimerkiksi ohjelmoija työskentelee objektitarkastajan kanssa, hän voi valita yhden ominaisuuksista, painaa sitten F1 ja saada taustatiedot vastaavasta vaihtoehdosta. Sama voidaan tehdä työskenneltäessä minkä tahansa muun käyttöliittymäelementin kanssa, joka sisältää Delphi 7 -kehitysympäristön ja muut vastaavan tyyppisen ohjelmiston versiot.

Muut käyttöliittymäelementit

Muiden kyseisen käyttöliittymän merkittävien osien joukossa ohjelmistoratkaisu- valikko, paneeli nopea pääsy, sekä kuvankäsittelyohjelma. Mitä tulee valikkoon, sen avulla ohjelmoija pääsee nopeasti käsiksi tarvittavat komponentit, joka on läsnä kehitysympäristön rakenteessa. Voit käyttää sitä joko hiirellä tai pikanäppäimillä. Heti valikon alapuolella on pikakäyttöpaneeli. Jotkut sen toiminnoista kopioivat valikon toiminnot, mutta ne ovat nopeampia käyttää. Delphi on vähän samanlainen Maalaus ohjelma Windowsissa. Eli sen avulla voit tehdä kuviin yksinkertaisia ​​säätöjä, laittaa niihin kirjoituksia ja muita elementtejä.

Ohjelmointityökalut

Delphi on kehitysympäristö, joka sisältää suuri määrä työkalut, jotka on suunniteltu parantamaan ohjelmoijan tehokkuutta. Siten edellä käsiteltyjä avainmoduuleja täydentää joukko erikoistyökaluja. Näitä ovat debuggeri, kääntäjä sekä WinSight- ja WinSpector-komponentit. Huomaa, että joissakin Delphi-versioissa merkityt elementit on asennettava erikseen. Tutkitaanpa niiden erityispiirteitä.

Delphi Debugger

Mitä tulee debuggeriin - tämä työkalu täydentää koodieditoria toteutuksen suhteen tarvittava tarkastus asiaankuuluvaa ohjelmistoalgoritmit oikeellisuuden vuoksi. Sen avulla kehittäjä voi itse asiassa tutkia lähdekoodiaan rivi riviltä. Joissain tapauksissa, kun ratkaistaan ​​tehtävää, kuten komponenttien kehitystä, Delphiä itsenäisenä tuotteena voidaan täydentää ulkoisella debuggerilla, joka antaa ohjelmoijalle paremmat mahdollisuudet tarkistaa luotavan ohjelmiston koodi.

Delphi kääntäjä

Tarkastellaan nyt kyseessä olevan kehitysympäristön kääntäjän erityispiirteitä. Huomaa, että Delphi-rakenteessa voi olla useita vastaavia elementtejä. Joten on mahdollisuus käyttää DCC-kääntäjää, joka on hyödyllinen tapauksissa, joissa tehtävänä on työskennellä sovelluksen kanssa ulkoisessa debuggerissa.

Winsight ja WinSpector

Määritetyt moduulit ovat niitä, jotka on asennettava lisäksi Delphiin. Niille on ominaista suhteellisen vaikea hallita. Monet Delphi-kehitysympäristön valinneet ohjelmoijat uskovat kuitenkin, että nämä komponentit on opeteltava käyttämään. Näin ollen Winsight-moduulia käytetään monitorointiin Windowsin viestit. Komponentti, kuten WinSpector, tarvitaan tallentamaan tietokoneen tila erityinen tiedosto. Jos kohtaat ongelmia ohjelmistokehityksen aikana, voit aina avata tämän tiedoston ja katsoa, ​​mikä saattaa aiheuttaa ongelman.

Vakiokomponentit

Delphi kehitysympäristö, yleistä tietoa opimme sisältää useita vakiokomponentteja, joista on myös hyödyllistä tietää. Asiantuntijat luokittelevat nämä seuraavasti: MainMenu, PopupMenu, Label, Edit, Memo, Button, Checkbox, Radiobutton, Listbox, Combobox, Scrollbar, Groupbox, Panel ja Scrollbox. Tutkitaanpa niiden erityispiirteitä tarkemmin.

MainMenu-komponentti on suunniteltu sijoittamaan päävalikko käyttöliittymään luotu ohjelma. Tätä varten sinun on sijoitettava vastaava elementti lomakkeeseen, kutsuttava Items-ominaisuus objektiasetusten kautta ja määritettävä sitten tarvittavat valikkokohdat.

PopupMenu-komponentti on suunniteltu sijoittamaan ponnahdusvalikoita luodun ohjelman käyttöliittymään, eli ne, jotka avautuvat napsautuksella napsauta oikeaa painiketta hiiret.

Label-komponenttia käytetään tekstin näyttämiseen ohjelmaikkunassa. Se voidaan räätälöidä, esimerkiksi asettaa haluttu fontti Object Inspectorissa.

Muokkaa-komponenttia käytetään tuomaan näyttöön tekstinpätkä, jota käyttäjä voi muokata ohjelman ollessa käynnissä. Sitä täydentää Memo-komponentti, jota puolestaan ​​voidaan käyttää suurempien tekstien käsittelyyn. Tämä kohde sisältää esimerkiksi vaihtoehtoja, kuten tekstin kopioinnin.

Painikekomponentti on suunniteltu suorittamaan tiettyjä toimintoja painamalla painiketta ohjelman ollessa käynnissä. Lomakkeelle on asetettava vastaava elementti ja syötettävä sitten tarvittava ohjelmakoodi.

Checkbox-komponentin avulla voit näyttää viivoja näytöllä pienellä ikkunalla, johon valintaruutu voidaan asettaa hiirellä. Samanlainen elementti on Radiopainike. Ne eroavat ensinnäkin ulkonäkö- toinen komponentti on tehty ympyrän muodossa, ja toiseksi, ensimmäinen elementti mahdollistaa useiden vaihtoehtojen samanaikaisen valinnan, Radiopainike - vain yksi.

Listbox-komponenttia käytetään näyttämään näytöllä luettelo, jota käyttäjä voi selata hiirellä. Toinen elementti, Combobox, on jonkin verran samanlainen kuin se, mutta sitä täydentää mahdollisuus kirjoittaa tekstiä erityiseen kenttään.

Vierityspalkkikomponentti on vierityspalkki ikkunoissa. Näkyy yleensä automaattisesti heti, kun tekstitila tai objekteja sisältävä lomake kasvaa ikkunaa suuremmaksi.

Groupbox-komponenttia käytetään tallentamaan liikejärjestys ikkunoiden välillä, kun sitä napsautetaan. TAB-näppäimet. Voidaan täydentää Panel-elementillä, jolla voidaan siirtää useita objekteja lomakkeella.

Scrollbox-komponentin avulla voit kiinnittää lomakkeelle alueen, jota voidaan vierittää sekä vaaka- että pystysuunnassa. Tämä ominaisuus luonnehtii Delphin tärkeimmät kehitysikkunat oletuksena. Mutta jos tällainen vaihtoehto on otettava käyttöön tietyssä lomakkeen osassa, voit käyttää Scrollbox-komponenttia.

Jatkaa

Delphi on sovelluskehitysympäristö suuria mahdollisuuksia, jolle on samalla ominaista päätoimintojen helppokäyttöisyys. Sen rakenteeseen sisältyvien työkalujen avulla voit luoda eniten eri tyyppejä ohjelmia Windowsille ja muille suosituille käyttöjärjestelmille.

Monien ohjelmoijien Delphi-kehitystyökalujen valinnan määrää vastaavien ohjelmistojen käyttöliittymien helppokäyttöisyys sekä laaja valikoima työkaluja, jotka ovat hyödyllisiä työskentelyyn missä tahansa ohjelman luomisvaiheessa - suunnitteluvaiheessa, algoritmien ohjelmointivaiheessa. tai virheenkorjaus.