Borang "Perihal" digunakan untuk tujuan maklumat. Selalunya ia mengandungi nama program, tujuan, pengarang dan perjanjian lesen. Selalunya ia terletak dalam menu utama di bawah Bantuan->Mengenai program....
Untuk mencipta borang "Perihal" dalam Delphi (Delphi, Delphi), anda perlu mencipta borang biasa, seperti dalam rajah di bawah:
Untuk mencipta sebarang bentuk dalam Delphi 7, kami menggunakan arahan berikut daripada menu File->New->Borang, dan apabila membangunkan projek dalam persekitaran yang lebih baharu, contohnya Delphi XE2, anda perlu menggunakan arahan yang sedikit berbeza: File- >Baharu->Borang VCL - Delphi .
Selepas membuat borang, anda perlu menetapkan dimensi yang diperlukan dan disyorkan untuk membuat tetapan berikut:
- Tetapkan sifat Kedudukan. Nilai lalai di sini ialah poDesigned, yang menentukan bahawa borang yang dibuka muncul di tempat asalnya semasa program dibuat. Oleh itu, anda perlu menetapkannya supaya borang kelihatan berpusat berbanding dengan borang yang dipanggil. Untuk melakukan ini, tetapkan sifat Position kepada poOwnerFormCenter.
- Anda juga boleh melumpuhkan sifat AutoScroll untuk menghalang bar skrol daripada muncul.
- Memandangkan borang akan mengandungi maklumat statik ringkas, tidak perlu mengubah saiz borang semasa masa jalan. Oleh itu, tetapkan sifat BorderStyle kepada bsSingle.
- Anda juga perlu mengkonfigurasi sifat bersarang dalam BorderIcons. Anda perlu menetapkan sifat biMinimize dan biMaximize kepada palsu, yang tidak akan membenarkan anda untuk meminimumkan dan mengembangkan borang, masing-masing.
Sebagai tambahan kepada semua tetapan yang diterangkan, anda juga boleh menghiasi borang dengan latar belakang. Untuk melakukan ini, anda perlu meletakkan Imej dari palet komponen, yang terletak di tab Tambahan jika anda menulis dalam Delphi 7. Dalam harta itu, anda perlu segera menetapkan nilai alClient, yang akan meregangkan bekas untuk imej kepada keseluruhan bentuk.
Selain itu, apabila menggunakan TLabel, anda boleh menetapkan Transparent kepada benar. Pilihan ini akan menjadikan latar belakang label telus, yang akan kelihatan lebih cantik jika latar belakang tambahan digunakan.
Kesimpulan
Saya rasa saya akan menamatkan artikel ini di sini. Bahan ini berguna untuk memulakan pengaturcara Delphi atau hanya mereka yang berminat untuk menulis program. Jika anda menghadapi sebarang kesulitan, tulis dalam komen, dan secepat mungkin, saya akan membantu anda menggunakan borang "Mengenai program" di Delphi. Saya juga menyiarkan projek ujian dalam arkib dengan borang ini dan panggilannya daripada borang lain.
Sebelum mencipta komponen anda, anda perlu memilih nenek moyang untuknya. Siapa yang boleh menjadi moyang bagi komponen anda?
Biasanya digunakan sebagai nenek moyang TComponent, TControl, TWinControl, TGraphicControl, TCustomXXXXXX, serta semua komponen palet komponen.
Mari kita ambil contoh komponen TOpenDialog, yang terletak pada halaman Dialog palet komponen. Ia menjalankan tugasnya dengan baik, tetapi ia mempunyai satu kesulitan kecil. Setiap kali anda menggunakannya, anda mesti menukar nilai sifat Pilihan setiap kali. Dan, sebagai peraturan, ini adalah tindakan yang sama.
OpenDialog1.Options:= OpenDialog1.Options + ;
supaya fail yang kami cuba buka dengan dialog ini sebenarnya wujud pada cakera.
Kami telah memilih tugas untuk diri kami sendiri, yang tinggal hanyalah mencipta komponen. Kami mencipta ruang kosong untuk komponen dengan memilih arahan Komponen/Komponen Baharu... daripada menu dan memilih dalam kotak dialog
Jenis nenek moyang: TOpenDialog
Nama Kelas: TOurOpenDialog
Halaman Palet: Ujian Kami
Kami mengklik Ok dan kami kini mempunyai templat untuk komponen masa hadapan kami.
Kami mengatasi pembina untuk komponen ini, i.e. dalam bahagian awam masukkan baris:
constructor Create(AOwner: TComponent); mengatasi;
Mengklik pada baris ini Ctrl + Shift + C mencipta templat untuk kaedah ini, di dalamnya kami memasukkan baris berikut:
mewarisi Create(AOwner); (Panggil pembina yang diwarisi)
Pilihan:= Pilihan + ; (Kami menjalankan tindakan yang kami perlukan)
Sila ambil perhatian: Pintasan papan kekunci Ctrl + Shift + anak panah atas/bawah membolehkan anda menavigasi antara pengisytiharan kaedah dan pelaksanaannya.
Memasang Komponen komponen yang dibuat/Pasang Komponen...
Pasang Dalam Pakej Baharu
Nama fail pakej: C:Program FilesBorlandDelphi4LibOurTest.dpk
Penerangan pakej: Pakej kami yang diuji
Adakah anda tidak suka bahawa komponen kami mempunyai ikon yang sama seperti yang standard? Kemudian mari kita cipta sendiri untuknya.
Untuk melakukan ini, kita perlu memanggil Tools/Image Editor. Cipta fail *.dcr baharu.
Masukkan imej Sumber/Baharu/Bitmap ke dalamnya. Tetapkan saiz imej kepada 24x24 piksel. Dan kemudian - kreativiti anda...
Sila ambil perhatian: warna titik yang sepadan dengan warna titik di sudut kiri bawah gambar akan dianggap TELUS!
Sebaik sahaja anda telah mencipta lukisan anda, namakan semula ia daripada Bitmap1 kepada TOurOpenDialog dan simpan fail itu sebagai OurOpenDialog.dcr.
Keluarkan komponen daripada pakej dan pasang semula (hanya dalam kes ini pautan ke fail *.dcr akan ditambah).
Susun, Pasang dan semoga berjaya!
Pengisytiharan komponen terdiri daripada bahagian seperti swasta, dilindungi, awam dan diterbitkan. Apa yang mereka maksudkan?
Ini adalah arahan keterlihatan.
Semua yang diisytiharkan dalam bahagian persendirian, hanya tersedia di dalam modul di mana kelas diisytiharkan (pengisytiharan peribadi). Di sini, sebagai peraturan, pembolehubah diisytiharkan yang menyimpan nilai harta, serta kaedah (prosedur atau fungsi) untuk mengaksesnya.
Semua yang diisytiharkan dalam bahagian dilindungi, tersedia seperti dalam bahagian peribadi, dan juga kepada keturunan kelas ini (antara muka pembangun).
Di sini anda boleh mengisytiharkan kaedah untuk mengakses nilai harta (jika anda ingin membenarkan kanak-kanak komponen anda menukar kaedah ini),
serta sifat, kaedah dan peristiwa (kaedah untuk bertindak balas terhadap peristiwa) dalam komponen jenis TCustomXXX.
Semua yang diisytiharkan dalam bahagian awam, tersedia kepada mana-mana pengguna komponen (antara muka masa jalan).
Kaedah biasanya diisytiharkan di sini. Hanya hartanah dan acara boleh diisytiharkan dalam bahagian yang diterbitkan (ia diisytiharkan sebagai hartanah).
Mereka tersedia semasa reka bentuk aplikasi (antara muka fasa reka bentuk).
Hartanah
Jenis sifat massif- tatasusunan Object Pascal biasa, tetapi tidak seperti yang terakhir, ia boleh diindeks bukan sahaja oleh nilai angka tetapi juga oleh rentetan. Malangnya, jenis harta ini memerlukan editor harta tersuai (dalam Pemeriksa Objek, editor harta mempunyai butang dengan tiga titik [...]), jadi dalam contoh di bawah harta itu ArrayProp diumumkan dalam bahagian awam.
menaip TOurComponent = kelas(Komponen) persendirian( Pengisytiharan peribadi ) FArrayProp: tatasusunan daripada integer; fungsi GetArrayProp(aIndex: integer): integer; prosedur SetArrayProp(aIndex: integer; const Nilai: integer); dilindungi(Perisytiharan dilindungi) awam(Pengisytiharan awam) harta benda ArrayProp: integer membaca GetArrayProp menulis SetArrayProp; diterbitkan(Pengisytiharan yang diterbitkan) tamat;Penentu hartanah
Penentu lalai menentukan sama ada untuk menyimpan nilai harta dalam fail borang atau tidak. Jika nilai harta sepadan dengan nilai lalai- nilai dalam fail borang tidak disimpan, jika nilai tidak sama - ia disimpan. Anda boleh menyemak ini dengan meletakkan komponen pada borang dan memilih item menu "Lihat sebagai Teks" dengan butang tetikus kanan. Lalai tidak menetapkan nilai awal harta kepada yang ditentukan. Ini mesti dilakukan dalam pembina komponen.
unit Komponen Kami; antara muka kegunaan Windows, SysUtils, Kelas, Grafik, Borang, Kawalan; menaip TOurComponent = kelas(Komponen) persendirian( Pengisytiharan peribadi ) FMyInteger: Integer; dilindungi(Perisytiharan dilindungi) awam(Pengisytiharan awam) pembina Cipta(AOwner: TComponent); mengatasi; diterbitkan(Pengisytiharan yang diterbitkan) harta benda Integer Saya: Integer membaca FMyInteger menulis FMyInteger lalai 10; tamat; pelaksanaan pembina TOurComponent.Create(AOwner: TComponent); bermula diwarisi Cipta(AOwner); FInteger:= 10; tamat; tamat.Penentu nodefault mengatasi nilai harta lalai. Penentu ini biasanya digunakan untuk mengatasi nilai lalai harta warisan.
Sebagai contoh: harta benda AutoSize nodefault;
Penentu disimpan menentukan masa untuk menyimpan nilai harta dalam fail borang. Selepas disimpan boleh berdiri benar(sentiasa simpan) salah(tidak pernah simpan) atau nama fungsi yang mengembalikan hasil Boolean.
harta benda OneProp: integer membaca FOneProp menulis SetOneProp disimpan Salah; harta benda TwoProp: integer membaca FTwoProp menulis SetTwoProp disimpan Benar; harta benda ThreeProp: integer membaca FThreeProp menulis SetThreeProp disimpan Fuct;Dan perkara terakhir:
Untuk menambah gambar pada komponen untuk demonstrasi dalam panel komponen, anda perlu: - menciptanya dengan saiz 24*24 dengan nama fail.dcr (dalam sumber, nama gambar adalah sama dengan nama komponen, dalam huruf besar)
- letak gambar di sebelah komponen.
Dalam persekitaran Delphi pengaturcara bekerja dengan projek - satu set fail dari mana Delphi mencipta aplikasi. Satu projek sepadan dengan satu aplikasi. Satu siri fail projek Delphi menjana dan mengubah suai secara automatik. Pengaturcara boleh menambah failnya sendiri pada projek ( Pascal-modul, fail grafik, DLL– perpustakaan, perpustakaan komponen, sumber, dsb.).
Projek mesti mengandungi elemen berikut:
· fail projek utama dengan sambungan .DPR ( D elphi PR objek). Hanya ada satu fail dengan sambungan ini dalam projek. Ini ialah fail teks kecil dalam bahasa Objek Pascal, yang mengandungi rujukan kepada semua bentuk projek dan memulakan aplikasi;
· fail semua bentuk projek. Untuk setiap borang, sepasang fail dengan nama yang sama dijana - fail Pascal-modul dengan sambungan biasa .PAS dan fail sumber borang dengan sambungan .DFM ( D elphi F atau M ). Sebarang bentuk projek hendaklah sentiasa mempunyai pasangan fail sumber modul sendiri. Sebaliknya tidak perlu, i.e. projek mungkin termasuk modul dan fail sumber yang tidak berkaitan dengan sebarang bentuk aplikasi;
· fail sumber aplikasi (*.RES). Ia mengandungi sumber aplikasi yang tidak termasuk dalam borang;
fail pilihan projek (*.DOF – D elphi O pilihan F ile). Fail ini menyimpan nilai arahan dan pilihan pengkompil, tetapan pemaut, nama direktori kerja, dan parameter baris arahan untuk melancarkan aplikasi.
Contoh program
Sebelum memulakan kerja pada projek seterusnya, pertama sekali, anda harus membuat folder (direktori) berasingan untuk fail projek masa depan. Peraturan ini mesti sentiasa dipatuhi, jika tidak, tidak lama lagi fail projek yang berbeza akan menjadi "bercampur" dalam satu direktori yang akan menjadi agak sukar untuk menyusunnya mengikut projek. Kami akan menganggap pada masa akan datang bahawa folder sedemikian telah dibuat, mari kita panggilnya PO_EVM, ini akan menjadi folder projek semasa.
Jom lancarkan Delphi. Jika muat turun berjaya, maka pada skrin monitor kita akan melihat apa yang ditunjukkan dalam Rajah 1. Dalam bar tajuk tetingkap utama Delphi terdapat tulisan Delphi 3 - Projek1. Ini adalah nama projek dan program kami. Bar tajuk tetingkap borang permohonan berkata Borang1. Jika anda menekan kekunci F12 atau klik pada butang Togol
Borang/Unit(bar alat akses pantas) atau pilih item menu Lihat/Togol Borang/Unit, maka tetingkap editor kod akan bergerak ke latar depan dan kami akan melihat kandungan halaman tersebut Unit 1 editor, yang membentangkan Pascal-kod modul Unit 1. Mari tambah halaman lain pada tetingkap editor kod, yang akan mengandungi kod program utama projek. Untuk melakukan ini, pilih item menu Lihat/Sumber Projek. Di bawah ialah kandungan dua halaman editor kod: Kod Pascal program utama dan kod Pascal modul bentuk utama projek, masing-masing.
Simpan fail projek dalam direktori yang dibuat PO_EVM. Untuk melakukan ini, tekan butang Simpan semua pada panel capaian pantas atau pilih item menu Fail/Simpan Projek Sebagai.... Dalam standard yang muncul Windows- dalam tetingkap menyimpan fail, pilih folder PO_EVM dan simpan secara berurutan Pascal-bentuk kod modul dan Pascal-kod program dalam fail bernama IDE_Un1.pas Dan IDE_Pr.dpr masing-masing.
| program IDE_Pr; IDE_Un1 dalam 'IDE_Un1.pas' (Borang1); Permohonan.Memulakan; Application.CreateForm(TForm1, Form1); Permohonan.Jalankan; |
unit IDE_Un1; Windows, Messages, SysUtils, kelas, Grafik, Kawalan, TForm1 = kelas(TForm) (Pengisytiharan peribadi) (Pengisytiharan awam) |
Jika anda sekarang melihat kandungan folder PO_EVM, maka ia akan mengandungi fail projek berikut: IDE_Pr.dof– fail pilihan projek; IDE_Pr.dpr– fail projek utama; IDE_Pr.res– fail sumber projek; IDE_Un1.pas– Fail kod Pascal untuk modul borang; IDE_Un1.dfm– fail sumber borang.
Adalah dinasihatkan untuk menukar beberapa tetapan persekitaran standard, khususnya, supaya proses penyusunan dan pemautan program dipaparkan pada skrin, dan juga supaya sebelum setiap pelancaran program untuk pelaksanaan, semua fail projek yang diubah suai disimpan secara automatik. Ini boleh dilakukan dalam kotak dialog Pilihan Persekitaran…, yang boleh dipanggil dari menu Pilihan Alat/Persekitaran…. Pada halaman Keutamaan Dalam bab Kandungan desktop tetapkan suis pada kedudukan Desktop sahaja, Dalam bab Pilihan autosimpan pasang suis pada titik Fail editor Dan Desktop, dan dalam bahagian Menyusun dan Menjalankan pasang suis Tunjukkan kemajuan pengkompil .
Program paling mudah dalam Delphi sudah sedia untuk dilaksanakan. Dengan menekan butang Lari pada Bar Alat Akses Pantas atau kekunci F9, anda boleh melihat proses penyusunan dan pemautan program, selepas itu program kami akan mula dilaksanakan. Secara visual, program ini dibentangkan pada skrin sebagai tetingkap kosong dengan standard Windows- bar tajuk yang mengandungi ikon aplikasi, nama borang dan tiga butang kawalan tetingkap. Keluar dari program dan kembali ke persekitaran Delphi dijalankan sebagai standard untuk Windows cara - kombinasi kunci Alt-F4 atau dengan mengklik butang tutup aplikasi. Jika anda kini melihat kandungan folder fail projek PO_EVM, maka anda dapat melihat bahawa dua lagi fail telah muncul di dalamnya: IDE_Un1.dcu dan IDE_Pr.exe - fail modul borang yang disusun dan fail aplikasi boot (boleh laku). Fail IDE_Pr.exe boleh dilaksanakan secara autonomi, i.e. luar persekitaran Delphi. Selepas meninggalkan persekitaran Delphi, fail lain dibuat dalam folder IDE_Pr.dsk– fail dengan tetapan persekitaran pengguna individu.
Mari kita berikan urutan anggaran tindakan seorang pengaturcara yang mencipta program " Kalkulator +/-“. Aplikasi ini, boleh dikatakan, direka untuk melaksanakan operasi tambah dan tolak pada nombor nyata. Apabila dilancarkan, tetingkap program (borang) sepatutnya kelihatan seperti dalam Rajah. 7.
Borang mengandungi tiga baris input/output (komponen jenis TEdit) untuk memasukkan dua operan dan mengeluarkan hasilnya; lima butang (empat jenis komponen TButton dan satu - TBitBtn) – set semula, petunjuk jenis dan hasil operasi ( C, + , – , = ), keluar dari program (Tutup); tiga label untuk menunjukkan operan dan hasilnya (komponen jenis TLabel); memisahkan elemen antara muka untuk menyerlahkan medan output hasil kiraan (komponen TBevel).
Dalam keadaan asalnya, selepas pelancaran Delphi dan menyimpan dua fail projek dengan nama yang ditentukan, kami mempunyai borang kosong. Seterusnya, susunan membina bahagian antara muka aplikasi adalah seperti berikut (hasil tindakan anda boleh dibandingkan dengan lokasi komponen dalam Rajah 7):
1. Bentuk harta Kapsyen dalam pemeriksa objek kita tukar daripada nilai Borang1 kepada nilai rentetan Kalkulator +/-. Perubahan dalam nilai nama borang dapat dilihat dengan serta-merta dalam bar tajuk borang;
2. Pada halaman Standard Palet komponen klik kiri pada imej komponen Label, kemudian gerakkan penuding tetikus ke penjuru kiri sebelah atas borang dan klik kiri di sana. Imej komponen akan muncul di lokasi ini pada borang. Label dengan tulisan Label1. Imej komponen diserlahkan di sekeliling perimeter oleh enam petak hitam - penanda saiz (penanda saiz). Menyerlahkan dengan penanda bermakna komponen ini sedang aktif. Menggunakan tetikus standard Windows- Menggunakan teknik anda boleh menukar saiz komponen dan menggerakkannya di sekeliling bentuk. Untuk mengaktifkan komponen borang lain, hanya klik padanya dengan butang kiri tetikus. Kandungan tab Pemeriksa Objek sentiasa sepadan dengan komponen aktif; apabila komponen lain diaktifkan, komposisi medan Pemeriksa Objek berubah secara automatik. Jom tukar harta Kapsyen komponen Label daripada maksud Label1 kepada nilai operan pertama. Mari kita berikan sifat Nama komponen ini nilai lb_1 .
3. Dengan cara yang sama, kami akan meletakkan komponen label kedua lebih rendah sedikit daripada yang pertama, menetapkan sifat sewajarnya Kapsyen Dan Nama nilai operan ke-2 Dan lb_2 .
4. Pada halaman yang sama Standard Palet komponen memilih komponen Sunting(edit baris) dan letakkannya pada borang di sebelah kanan label pertama. Harta benda Nama menetapkan nilai ed_1, dan harta benda Teks Jom kosongkan.
5. Dengan cara yang sama, kami akan meletakkan baris edit kedua di sebelah kanan label kedua, menetapkan sifat sewajarnya Teks Dan Nama nilai rentetan kosong dan ed_2 .
6. Pada halaman Tambahan palet komponen, pilih komponen Bevel dan letakkannya supaya ia mewakili baris "hasil" di bawah label kedua dan baris input kedua. Harta benda nama, sama rata Serong1, kami tidak akan berubah.
7. Di bawah komponen Serong Mari letakkan pasangan lain "label - baris input" untuk memaparkan hasil pengiraan. Hartanah Nama mari kita berikan nilai lb_3 Dan ed_3, harta benda lb_3.Kapsyen- maksudnya Hasilnya, dan harta benda Teks komponen ed_3– nilai rentetan kosong.
8. Mari letakkan label lain untuk menggambarkan operasi aritmetik semasa: (?, +, –) - operasi tidak ditakrifkan, operasi tambah, operasi tolak. Mari letakkan label ini di antara dua label pertama, lebih dekat dengan sempadan kiri komponen untuk memasukkan operan (lihat Rajah 7). Harta benda Nama menetapkan nilai lb_oper, dan harta benda Kapsyen- maksudnya ? . Mari kita tetapkan juga subsifat Saiz dalam harta fon untuk label ini, sama dengan 14 ;
9.
Mari kita selaraskan komponen. Standard Windows- Menggunakan kaedah ini, kami memilih komponen - label. Untuk melakukan ini, tahan butang Beralih, dengan mengklik butang kiri tetikus pada komponen label secara berurutan, kami mengaktifkan ketiga-tiga label secara serentak. Jika anda kini klik kanan, maka mengikut undang-undang Windows 95 Menu konteks sepatutnya muncul - dan ia muncul. Jom pilih barang Sebuah lign…(penjajaran). Sekarang kita melihat tetingkap pada skrin Penjajaran. Pilih pada panel mendatar perenggan Bahagian kiri dan tekan butang Okey. Akibatnya, ketiga-tiga komponen label akan dijajarkan ke tepi kiri komponen paling kiri. Menggunakan tindakan yang serupa, kami akan menyelaraskan ketiga-tiga baris suntingan. Garis penyuntingan juga boleh diselaraskan dalam saiz dengan memilih ketiga-tiga garisan itu pada masa yang sama dan memilih item dalam menu konteks Saiz…. Kerja "halus" mengubah saiz dan menggerakkan komponen biasanya dilakukan bukan dengan tetikus, tetapi dengan kekunci kursor semasa kekunci shift ditekan, masing-masing. Beralih Dan Ctrl. Tindakan ini boleh dilakukan bukan sahaja dengan satu komponen, tetapi juga dengan kumpulan komponen terpilih.
10. Sekarang mari letak butang kawalan pada borang. Kami mempunyai lima daripadanya (lihat Rajah 7). Empat butang pertama ialah butang set semula, butang operasi (tambah (+) dan tolak (–)) dan butang hasil. Butang kelima ialah butang untuk menamatkan program. Pada halaman Standard Palet komponen, pilih komponen Butang dan letakkan di sebelah kanan baris suntingan pertama. Hartanah Kapsyen Dan Nama tetapkan nilai kepada butang dengan sewajarnya C Dan btn_Clear. Begitu juga, kami meletakkan tiga butang lain pada borang, memanggil (property Nama) mereka btn_sum,btn_sub Dan btn_rez, dengan nama (property Kapsyen) + , – Dan = (lihat Rajah 7). Setelah memilih butang dalam kumpulan, klik dua kali pada sifat kompaun fon dalam Pemeriksa Objek. Di padang Saiz harta benda fon tetapkan saiz fon 14 mata. Selepas menetapkan nilai ini, saiz simbol pada butang akan meningkat.
11. Butang kelima – butang tamat program – dipilih daripada halaman Tambahan. Ini adalah komponen pertama pada halaman ini - butang seperti BitBtn(butang arahan dengan tulisan dan ikon). Setelah meletakkan butang seperti yang ditunjukkan dalam Rajah 7, pilih daripada senarai nilai harta baik hati maksudnya bkTutup. Pilihan ini menentukan sepenuhnya atribut visual dan kefungsian butang.
12. Untuk menyimpulkan proses membina bahagian antara muka program, kami akan mengurangkan bentuk kepada dimensi yang ditunjukkan dalam Rajah 7.
Ini menamatkan peringkat pertama mencipta aplikasi - membina antara muka. Perlu diingatkan bahawa pada mana-mana peringkat pembinaan antara muka, anda boleh menjalankan program untuk pelaksanaan pada bila-bila masa. Dalam proses melaksanakan langkah-langkah yang diterangkan di atas, kami tidak menulis satu baris atau satu operator Pascal. Semua penyertaan dalam teks modul borang permohonan Delphi melakukannya sendiri. Pada ketika ini, perubahan telah berlaku dalam bahagian antara muka modul borang - penerangan tentang komponen yang kami letakkan dalam borang dan modul standard telah ditambah Delphi Butang, StdCtrls, ExtCtrls.
Windows, Mesej, SysUtils, Kelas,
Grafik, Kawalan, Borang, Dialog,
Butang, StdCtrls, ExtCtrls;
TForm1 = kelas(TForm)
lb_Oper: TLabel;
btn_Clear: TButton;
btn_sum: TButton;
btn_sub: TButton;
btn_rez: TButton;
bb_Tutup: TBitBtn;
Kini masanya telah tiba untuk mengisi program kami dengan kandungan tertentu, i.e. laksanakan dalam atur cara operasi tambah dan tolak dua operan dengan hasilnya dimasukkan ke dalam baris keluaran. Program mesti bertindak balas kepada peristiwa yang sangat khusus yang boleh dimulakan oleh pengguna selepas memulakan program. Kami akan mengajar program untuk bertindak balas kepada peristiwa berikut: klik pada butang antara muka perintah (kami mempunyai lima daripadanya) dan memaklumkan pengguna sekiranya nilai operan dimasukkan dengan salah (operand mestilah nombor sahaja). Semua yang kita akan lakukan dipanggil menulis kod pengendali acara.
Mula-mula, mari kita nyatakan secara lisan perkara yang harus berlaku apabila satu butang atau butang lain ditekan, dalam keadaan apa dan dengan mesej kandungan yang harus dipaparkan pada skrin:
1. Klik pada butang “Kosongkan” ( DENGAN) - kosongkan ketiga-tiga baris suntingan dan paparkan tanda soal ( ?) ;
2. Tekan butang “Lipat” ( + ) - tukar imej tanda operasi kepada tanda tambah (+);
3. Klik pada butang “Tolak” ( – ) - tukar imej tanda operasi kepada tanda tolak (–);
4. Klik pada butang “Kira” ( = ) - semak ketepatan data dalam dua baris pertama penyuntingan. Jika data adalah betul (nombor), kemudian lakukan operasi aritmetik yang sesuai dan paparkan hasilnya dalam baris keluaran. Jika ralat dikesan dalam data sumber, mesej tentang ini harus dipaparkan yang menunjukkan lokasi ralat.
Sekarang mari menterjemah (terjemah) setiap titik di atas ke dalam kod Pascal. Setiap komponen mempunyai senarai acara (senarai disediakan pada halaman kedua ( Peristiwa) pemeriksa objek) yang boleh bertindak balas (yang boleh diproses). Tugas kami adalah untuk menulis kod yang akan dilaksanakan apabila peristiwa tertentu berlaku. Untuk butang masuk Delphi beberapa pengendali acara ditakrifkan, kami akan berminat dengan pengendali acara "Klik tunggal pada butang" (mengklik butang kiri tetikus semasa penuding tetikus berada di atas komponen Butang). Penangan ini dipanggil OnClick. Setiap pengendali acara diformatkan sebagai prosedur yang berasingan. Nama prosedur ini dibentuk oleh persekitaran itu sendiri. Delphi.
Mari tulis pengendali acara untuk satu klik pada butang "Kosongkan". Untuk melakukan ini, pilih butang "Kosongkan" pada borang ( DENGAN). Mengaktifkan halaman Peristiwa dalam tetingkap Pemeriksa Objek. Klik dua kali pada medan kosong di lajur kanan di sebelah inskripsi OnClick. Selepas itu Delphi secara automatik memaparkan tetingkap editor kod IDE_Un1 dan meletakkan kursor teks untuk memasukkan teks dalam prosedur TForm1.btn_ClearClick:
prosedur TForm1.btn_ClearClick(Penghantar: TObject);
seolah-olah mengajak kami untuk mula menaip dari tempat ini Pascal-kod prosedur ini. Beri perhatian kepada nama prosedur yang dihasilkan oleh persekitaran Delphi. Ia terdiri daripada nama borang di mana komponen (butang) terletak, nama komponen ini (btn_Clear) dan nama pengendali acara – Klik. Mengikuti kandungan titik pertama algoritma lisan kami, kami memasukkan baris berikut ke dalam badan prosedur Pascal-kod:
lb_Oper.Kapsyen:=’?’; (jenis operasi tidak ditentukan (label – ?))
ed_1.Teks:=”; (garisan jelas untuk memasuki operan pertama)
ed_2.Teks:=”; (garisan jelas untuk memasuki operan kedua)
ed_3.Teks:=”; (garisan jelas untuk memaparkan hasil)
Dengan cara yang sama, kami akan membuat pengendali acara untuk acara "Klik kiri tunggal pada komponen" untuk butang antara muka "Lipat" ( + ) dan “Tolak” ( – ):
– untuk butang “Tambah” baris kod ialah lb_Oper.Caption:=’+’;
– untuk butang “Tolak” baris kod ialah lb_Oper.Caption:=’-‘;
Pengurus acara OnClick untuk butang “Kira” ( = ) akan mengandungi perkara berikut Pascal-kod:
prosedur TForm1.btn_rezClick(Penghantar: TObject);
Val(ed_1.Teks,r1,i);
jika saya<>0 kemudian mula
ShowMessage('Ralat dalam operan pertama');
Val(ed_2.Teks,r2,i);
jika saya<>0 kemudian mula
ShowMessage('Ralat dalam operan kedua');
kes lb_oper.Kapsyen daripada
‘+’ : ed_3.Teks:=FloatToStr(r1+r2);
‘-‘ : ed_3.Teks:=FloatToStr(r1-r2);
else ShowMessage('Jenis operasi tidak ditentukan');
Dalam pengendali acara TForm1.btn_rezClick, dua pembolehubah sebenar tempatan r1 dan r2 diperkenalkan untuk menyimpan nilai berangka dua operan dan pembolehubah integer i untuk digunakan dalam Pascal-procedure Val untuk menukar pembolehubah rentetan kepada perwakilan angka. Pengendali ini melaksanakan titik keempat algoritma lisan program. Pertama, rentetan yang dimasukkan oleh pengguna dan aksara operan pertama diperiksa untuk ketepatannya. Jika ini bukan nombor, maka prosedur ShowMessage memaparkan mesej yang sepadan dengan situasi dan prosedur Keluar menamatkan pelaksanaan kod prosedur. Jika data adalah betul, pembolehubah r1 akan mengambil nilai berangka operan pertama. Operan kedua disemak dengan cara yang sama dan, jika semuanya normal di sini, maka pembolehubah r2 akan mengambil nilai berangka operan kedua.
Operator Case melaksanakan operasi aritmetik pada pembolehubah r1 dan r2 bergantung pada aksara mana ( + , – , ? ) mentakrifkan nilai sifat Kapsyen bagi label lb_oper. Jika tanda operasi aritmetik tidak ditakrifkan (bagi kami ia adalah simbol ? ), maka mesej yang sepadan dipaparkan dan operasi tidak dilakukan.
Perlu diingatkan bahawa, seperti yang diharapkan mengikut peraturan Pascal, ke bahagian antara muka modul borang secara automatik oleh persekitaran Delphi pengepala prosedur telah ditambah - pengendali acara tekan kekunci:
prosedur btn_sumClick(Penghantar: TObject);
prosedur btn_ClearClick(Penghantar: TObject);
prosedur btn_subClick(Penghantar: TObject);
prosedur btn_rezClick(Penghantar: TObject);
Dengan ini, kita boleh melengkapkan pelaksanaan perisian tugas mencipta kalkulator mudah yang melaksanakan operasi menambah dan menolak nombor nyata. Kami juga ambil perhatian bahawa aplikasi kami dilindungi 99% daripada ralat yang berkaitan dengan operasi pada data sumber yang salah (mengapa tidak 100%?).
Subrutin - prosedur dan fungsi dalam bahasa Delphi digunakan untuk melaksanakan operasi khusus. Delphi mempunyai banyak rutin standard, tetapi anda masih perlu mencipta sendiri untuk melaksanakan operasi yang kerap berulang pada data yang mungkin berubah.
Secara umum, ada teknik pengaturcaraan"atas bawah". Metodologi Pengaturcaraan"Atas-bawah" memecahkan tugasan kepada beberapa tugasan yang lebih mudah, yang ditulis dalam bentuk subrutin. Mereka, pada gilirannya, juga dibahagikan, jika perlu, sehingga masalah yang dihadapi oleh pengaturcara mencapai tahap kerumitan yang boleh diterima (iaitu, kesederhanaan!). Jadi ini teknik pengaturcaraan menjadikannya lebih mudah untuk menulis program dengan mencipta rangka yang dipanggil, yang terdiri daripada deskriptor subrutin, yang kemudiannya diisi dengan algoritma tertentu. Perihalan subrutin kosong sebaliknya dipanggil "stub".
DAN prosedur, Dan fungsi membolehkan anda mencapai keputusan yang sama. Tetapi masih ada perbezaan.
Prosedur Delphi ia hanya melakukan operasi yang diperlukan, tetapi tidak mengembalikan sebarang hasil daripada tindakannya. Hasilnya ialah perubahan yang berlaku dalam program semasa pelaksanaan prosedur ini. Khususnya, prosedur boleh menukar nilai pembolehubah, menulis nilai baru ke sel komponen, menulis ke fail, dsb.
Fungsi Delphi juga membolehkan anda melakukan semua perkara di atas, tetapi juga mengembalikan hasil dalam yang ditetapkan kepada dirinya sendiri maksudnya. Iaitu, panggilan fungsi boleh hadir dalam ungkapan di sebelah kanan pengendali tugasan. Jadi fungsi adalah objek yang lebih serba boleh!
Penerangan subrutin terdiri daripada kata kunci prosedur atau fungsi, diikuti dengan nama rutin dengan senarai parameter yang disertakan dalam kurungan. Bila fungsi diikuti dengan titik bertindih dan jenis nilai pulangan. Titik koma biasa diperlukan di bawah! Kod subrutin itu sendiri disertakan dalam "kurung logik" mula/akhir. Untuk fungsi, anda mesti menetapkannya dalam kod kepada pembolehubah dengan nama fungsi atau pembolehubah simpanan khas Hasilnya(sebaik-baiknya) nilai pulangan fungsi. Contoh:
Subrutin yang diterangkan dengan cara ini mesti diletakkan dalam program utama sebelum panggilan pertamanya. Jika tidak, semasa penyusunan, anda akan menerima pemberitahuan bahawa "pengecam tidak diketahui..." Menjejaki perkara ini tidak selalunya mudah. Terdapat jalan keluar - letakkan hanya tajuk subrutin di mana penerangan semua data program diletakkan.
Parameter ialah senarai pengecam yang dipisahkan koma, diikuti dengan titik bertindih dan jenisnya. Jika terdapat beberapa senarai pengecam pelbagai jenis, ia dipisahkan dengan koma bertitik. Semuanya adalah sama seperti dalam hal perihalan data biasa. Inilah yang dipanggil rasmi pilihan. Apabila memanggil subrutin, ia digantikan dengan sebenar- data yang dipisahkan koma dari jenis yang sama seperti yang formal.
Parameter dalam perihalan subrutin mungkin tiada, kemudian ia beroperasi dengan data terus daripada program utama.
Sekarang kita perlu memperkenalkan konsep data tempatan. Ini adalah data - pembolehubah, pemalar, subrutin yang digunakan dan wujud hanya pada masa memanggil subrutin ini. Mereka juga harus diterangkan dalam subrutin ini. Tempat penerangan mereka adalah antara tajuk dan permulaan blok logik - kata kunci bermula. Nama tempatan data mungkin sepadan dengan nama global. Dalam kes ini, pembolehubah tempatan digunakan, dan mengubahnya tidak akan menjejaskan pada yang global dengan nama yang sama.
Dengan cara yang sama seperti jenis, pembolehubah dan pemalar tempatan, prosedur dan fungsi tempatan boleh diperkenalkan yang boleh diterangkan dan digunakan hanya dalam subrutin tertentu.
Sekarang contoh. Mari kita tulis program untuk menjumlahkan dua nombor. Ia akan terdiri daripada Borang yang akan terdapat butang (komponen Butang), dengan mengklik subrutin kami yang akan dilaksanakan, dan dua baris input (komponen Sunting), di mana kita akan memasukkan operan. Mari kita mulakan daripada prosedur.
|
var Borang1: TForm1; A, B, Summa: Integer; prosedur Jumlah(A, B: Integer); pelaksanaan ($R *.dfm) prosedur prosedur Jumlah(A, B: Integer); |
Sekarang mari kita lakukan perkara yang sama dengan fungsi.
var
Borang1: TForm1;
A, B, Summa: Integer;
fungsi
pelaksanaan
($R *.dfm)
prosedur TForm1.Button1Click(Penghantar: TObject);
bermula
A:=StrToInt(Edit1.Teks);
B:=StrToInt(Edit2.Teks);
Summa:=Jumlah(A, B); // Pada pendapat saya, kini lebih jelas dari mana datangnya segala-galanya
Kapsyen:=IntToStr(Summa);
akhir;
fungsi Jumlah(A, B: Integer): Integer;
bermula
Keputusan:=A+B;
akhir;
Terdapat ciri dalam menggunakan struktur data yang besar sebagai parameter, sebagai contoh, tatasusunan yang terdiri daripada beberapa ribu (atau lebih) elemen. Apabila memindahkan sejumlah besar data ke subrutin, mungkin terdapat perbelanjaan besar sumber sistem dan masa. Oleh itu, penghantaran elemen selain daripada nilai itu sendiri digunakan (pemindahan "mengikut nilai", seperti dalam contoh sebelumnya), dan rujukan kepada nama pembolehubah atau pemalar (lulus "dengan nama"). Ini dicapai dengan memasukkan kata kunci sebelum parameter yang ingin kami luluskan dengan nama var.
fungsi Jumlah(A, B: Integer; var Arr: tatasusunan daripada Integer): Integer;
Jika kita melihat huraian subrutin kita dan huraian pengendali klik butang (ini juga subrutin!), yang dicipta oleh Delphi, kita lihat bahawa nama pengendali (Button1Click) didahului dengan TForm1. Seperti yang kita ketahui, dalam Delphi, titik memisahkan objek dan atributnya (sifat dan kaedah). Jadi Delphi mencipta Button1Click sebagai kaedah pada objek Form1. Lebih-lebih lagi surat itu T sebelum objek menunjukkan bahawa Button1Click bukan hanya kaedah objek, tetapi kaedah kelas objek. Mari kita tidak mengganggu dengan ini buat masa ini, tetapi kita hanya akan melakukan perkara yang sama. Dengan menerangkan prosedur atau fungsi kami sebagai kaedah kelas TForm1, kami mendapat peluang untuk menggunakan objek kelas di dalamnya tanpa menyatakan namanya, yang lebih mudah. Iaitu, jika kami menggunakan dalam subrutin kami mana-mana komponen yang diletakkan pada Borang (contohnya, Button1), maka kami menulis
Butang1.Lebar:=100; //Lebar butang
tetapi tidak
Borang1.Butang1.Lebar:=100;
Ia juga menjadi mungkin untuk menggunakan pembolehubah terbina dalam, seperti parameter Pengirim. Dalam setiap pengendali, objek ini menunjuk kepada sumber, iaitu objek yang memanggil rutin yang diberikan. Sebagai contoh, dalam prosedur penjumlahan kami Pengirim = Butang1. Selepas menganalisis pembolehubah ini, anda boleh memutuskan tindakan tertentu.
Setelah menerangkan subrutin sebagai kaedah kelas, kita mesti meletakkan penerangannya di tempat yang sama di mana Delphi meletakkannya - dalam penerangan kelas TForm1. Lihat sendiri di mana huraian prosedur Button1Click terletak. Untuk ini, dengan kursor di dalam rutin Button1Click, klik CTRL+Shift dan butang kawalan kursor " Naik"atau" Bawah" serentak. Akan ada peralihan kepada perihalan subrutin (untuk kembali, ulangi tindakan ini sekali lagi). Letakkan perihalan subrutin anda di sebelahnya, pada baris baharu. Sila ambil perhatian bahawa TForm1 tidak lagi ditulis.
Rekursi- penting dan berkuasa harta prosedur dan fungsi dalam Delphi. Rekursi Ini ialah keupayaan subrutin untuk merujuk kepada dirinya sendiri semasa operasi. Tanpa rekursi, anda perlu menggunakan gelung, yang menjadikan program lebih sukar dibaca. Panggilan rekursif kepada subrutin serta-merta menjelaskan maksud perkara yang berlaku. Sememangnya, anda perlu memastikan bahawa subrutin mesti mempunyai syarat, apabila dipenuhi, pengulangan selanjutnya berhenti, jika tidak subrutin akan masuk ke gelung.
Pembangunan aplikasi profesional dengan Delphi 5 | Alat Pembangunan | ComputerPress 2"2001
Mencipta Komponen Delphi
Pengenalan kepada Mencipta Komponen Delphi
Apabila membangunkan aplikasi menggunakan Borland Delphi, adalah mudah untuk mencipta komponen atas sebab berikut:
- Kemudahan penggunaan. Komponen diletakkan pada borang, dan anda perlu menetapkan nilai harta untuknya dan menulis kod pengendali acara. Oleh itu, jika dalam projek apa-apa gabungan kawalan dan pengendali acara yang dikaitkan dengannya berlaku di dua tempat, maka masuk akal untuk memikirkan tentang mencipta komponen yang sepadan. Jika gabungan kawalan dan pengendali acara yang dikaitkan dengannya berlaku lebih daripada dua kali, maka mencipta komponen dijamin menjimatkan usaha semasa membangunkan aplikasi.
- Organisasi ringkas pembangunan projek kumpulan. Dalam pembangunan kumpulan, bahagian individu projek boleh ditakrifkan sebagai komponen dan kerja boleh diberikan kepada pengaturcara yang berbeza. Komponen boleh dinyahpepijat secara berasingan daripada aplikasi, yang agak mudah dilakukan.
- Cara yang mudah dan berkesan untuk berkongsi kod dengan pengaturcara lain. Terdapat banyak tapak, contohnya http://www.torry.net/, di mana anda boleh mencari komponen yang diedarkan secara bebas atau membelinya dengan bayaran nominal.
Pek Ciri
Dalam Delphi, komponen disimpan dalam pakej. Senarai pakej komponen terpakai boleh dipanggil menggunakan item menu Komponen/Pasang Pakej (namun, atas sebab tertentu dialog ini mempunyai tajuk Pilihan Projek).
Menggunakan dialog ini, anda boleh menambah pakej baharu (Tambah) atau mengalih keluar pakej sedia ada (Alih keluar). Memadam tidak bermakna memadam fail secara fizikal dari cakera, tetapi mengalih keluar pautan dari persekitaran pembangunan ke pakej ini. Apabila anda menambah pakej baharu, komponen yang disimpan di dalamnya muncul pada palet, tetapi apabila anda memadamkannya, sebaliknya, ia hilang. Daripada memadamkan pakej, anda boleh "menyembunyikan" kandungannya pada peringkat pembangunan dengan menyahtanda nama pakej dalam senarai. Anda juga boleh melihat komponen dan ikonnya (Komponen). Akhir sekali, anda boleh mengedit pakej tambah pengguna (Edit) - pakej yang disertakan dengan Delphi tidak boleh diedit (butang Edit dikelabukan).
Dalam dialog ini, anda boleh menentukan cara untuk mencipta projek: menggunakan pakej runtime atau tanpa pakej tersebut. Jelas daripada ini bahawa terdapat dua jenis pakej komponen: pakej runtime (pakej yang berfungsi semasa runtime) dan pakej reka bentuk masa (pakej yang digunakan semasa pembangunan). Kesemuanya adalah DLL (perpustakaan yang dimuatkan secara dinamik).
Pakej masa jalan (*. sambungan bpl) dihantar kepada pengguna akhir bersama-sama dengan projek jika projek itu disusun dengan pilihan Bina dengan pakej masa jalan didayakan. Aplikasi itu sendiri (*.exe atau *.dll) dalam kes ini ternyata kecil, tetapi fail *.bpl agak besar mesti dipindahkan bersama-sama dengannya. Menurut pakar, menyampaikan projek dengan pakej runtime memberikan kelebihan dalam jumlah fail yang dibekalkan, hanya jika ia termasuk lima atau lebih modul (*.exe atau *.dll) yang ditulis dalam Delphi. Apabila modul ini berfungsi bersama, sumber sistem pengendalian disimpan, kerana satu pakej yang dimuatkan ke dalam RAM menyediakan beberapa modul.
Pakej masa reka bentuk (*.sambungan dcp) hanya digunakan pada peringkat pembangunan. Semasa pembangunan, mereka menyokong penciptaan komponen pada borang. Projek Delphi yang disusun termasuk kod bukan daripada pakej komponen, tetapi daripada fail *.dcu. Walaupun fail *.dcp dijana daripada fail *.dcu, kandungannya mungkin tidak sama jika perubahan telah dibuat pada fail *.pas dan pakej belum dikompilasi semula. Penyusunan hanya boleh dilakukan untuk pakej yang dibuat oleh pengaturcara. Ini dicapai dengan mengklik butang Edit dalam dialog di atas. Selepas ini, borang muncul yang membolehkan anda memanipulasi pakej.
Pakej mengandungi dua bahagian. Bahagian Mengandungi mengandungi senarai modul yang membentuk komponen pakej ini (*.pas- dan *.dcu-files) dan ikonnya (*.dcr-files). Bahagian Diperlukan mengandungi pautan ke pakej lain yang diperlukan untuk komponen ini berfungsi. Menambah komponen baharu pada pakej dilakukan dengan butang Tambah, dan mengalih keluar komponen sedia ada dilakukan dengan butang Alih Keluar. Sehingga pakej disusun dengan mengklik butang Compile, sebarang perubahan yang dibuat pada pakej tidak akan muncul dalam persekitaran pembangunan. Akhir sekali, arahan Pasang tersedia apabila kandungan pakej telah dialih keluar daripada persekitaran pembangunan dengan menyahtanda nama pakej dalam dialog sebelumnya.
Perintah Option membolehkan anda memilih pilihan untuk menyusun pakej yang serupa dengan pilihan projek. Ini boleh digunakan untuk menentukan jenis pakej pakej yang diberikan: masa jalan, masa reka bentuk atau kedua-duanya (jenis pakej lalai). Pilihan menentukan direktori untuk mencari modul yang diperlukan dan menyimpan hasil kompilasi. Mereka juga mentakrifkan tindakan yang diperlukan untuk penyahpepijatan: sama ada untuk menyemak julat nilai yang boleh diterima atau tidak, cara melaksanakan pengoptimuman, cara mengendalikan ralat I/O. Akhir sekali, pilihan mungkin termasuk maklumat versi pakej. Ini sangat penting jika aplikasi diedarkan bersama-sama dengan pakej runtime: apabila menjalankan program pemasangan, maklumat versi akan membolehkan anda menggantikan versi pakej yang sudah lapuk dengan betul, dan sebaliknya, jika anda cuba memasang pakej versi yang lebih awal daripada yang sudah tersedia pada komputer tertentu, yang terakhir tidak akan ditimpa.
Templat Komponen
Delphi membolehkan anda mencipta komponen komposit ringkas daripada beberapa komponen biasa yang dipilih pada borang pada masa reka bentuk. Pakar yang sepadan dipanggil menggunakan item menu Komponen/Buat Templat Komponen. Item menu ini tersedia jika sekurang-kurangnya satu komponen dipilih pada borang. Selepas memilihnya, kotak dialog Maklumat Templat Komponen muncul.
Dalam dialog ini, anda harus menentukan nama kelas dan nama halaman pada palet komponen di mana komponen baharu harus diletakkan. Jika halaman dengan nama ini tiada pada palet komponen, ia akan dibuat. Anda juga boleh menukar ikon yang dicadangkan untuk komponen baharu dengan memuat naik fail *.bmp yang sesuai.
Apabila templat dicipta, kedua-dua sifat yang diubah oleh pengaturcara dalam Pemeriksa Objek dan pengendali acara yang dikaitkan dengan kawalan yang dipilih diingati. Dalam kes ini, pengendali acara diingati sepenuhnya, tanpa menapis panggilan ke komponen lain (tidak dipilih pada borang), pembolehubah global, kaedah, dsb. Sehubungan itu, jika komponen tersebut (pembolehubah, kaedah) tiada dalam projek lain, maka apabila cuba menyusun projek sedemikian, mesej diagnostik Pengecam Tidak Diketahui akan diterima.
Bilakah anda harus menggunakan templat? Pertama sekali, dalam kes di mana perlu untuk menukar mana-mana sifat yang tersedia secara lalai dalam kelas asas. Sebagai contoh, aplikasi menggunakan kawalan untuk mengedit baris teks kuning. Anda boleh meletakkan komponen TEdit pada borang, menukar sifat Warna kepada kuning, menandakan komponen ini dan menyimpannya sebagai templat. Selepas ini, anda boleh mengakses templat ini, dan komponen yang diletakkan pada borang akan mempunyai warna kuning. Walau bagaimanapun, anda tidak seharusnya menyalahgunakan peluang ini, kerana kelas baharu akan dibuat untuk kawalan dengan warna yang berubah dan semua kaedah maya akan diduplikasi dalam ingatan. Ini akan memberi kesan negatif kepada sumber sistem pengendalian.
Ia juga mudah untuk menggunakan templat komponen apabila anda perlu memindahkan beberapa komponen bersama dengan pengendali acara dari satu bentuk ke bentuk yang lain. Untuk melakukan ini, mereka semua dipilih, templat komponen dibuat, yang diletakkan pada borang baru. Dalam kes ini, bukan sahaja komponen itu sendiri akan dipindahkan, tetapi juga pengendali acara, yang tidak boleh dicapai apabila memanggil arahan Salin/Tampal - dalam kes kedua, pengendali acara akan hilang.
Komponen yang dibuat menggunakan arahan Cipta Templat Komponen agak berbeza daripada komponen biasa yang dibuat menggunakan kaedah standard (diterangkan di bawah). Secara visual, perbezaan utama ialah ini: jika templat termasuk beberapa kawalan, maka selepas komponen sedemikian diletakkan pada borang, anda boleh memilih kawalan individu dan memadamkannya - manakala selebihnya akan kekal pada borang. Untuk komponen standard, jika ia termasuk beberapa kawalan, tidak mungkin untuk memilih salah satu daripadanya dan memadamkannya - komponen itu dipilih dan dipadam sepenuhnya.
Mencipta Komponen Mudah
Apabila menulis komponen baharu, anda perlu jelas bahawa komponen itu ditulis untuk pengaturcara, bukan pengguna akhir. Dalam kes ini, adalah wajar bahawa pengaturcara tidak menyelidiki butiran pelaksanaan komponen, tetapi hanya menggunakan sifat dan peristiwa yang didedahkan olehnya. Ini dicapai melalui ujian yang sangat teliti. Komponen baharu mesti diuji walaupun dalam situasi yang tidak direka bentuk dengan jelas.
Mari kita kemukakan masalah seperti berikut. Anda perlu mencipta butang yang akan berbunyi apabila ditekan, dan melaksanakannya sebagai komponen supaya pengaturcara boleh meletakkannya pada borang dan menggunakannya. Secara umum, apabila mempertimbangkan komponen, kami akan sering menggunakan kesan luaran yang paling mudah: bip, memaparkan mesej, dsb. Ini menunjukkan bahawa di tempat-tempat di mana kesan luaran digunakan, sebarang kod yang agak kompleks boleh diletakkan. Kami tidak berminat dengannya buat masa ini.
Mencipta komponen bermula dengan memilih item menu Komponen/Komponen baharu. Selepas ini, dialog Komponen Baharu segera muncul.
Dalam dialog ini, anda perlu menentukan kelas nenek moyang, nama kelas yang baru dibuat, halaman pada palet tempat komponen baharu akan diletakkan, nama modul yang mengandungi pelaksanaan komponen baharu dan laluan ke ia. Jika komponen baharu menggunakan modul lain, laluan yang tidak diterangkan, maka ia mesti ditakrifkan dalam medan Laluan Carian.
Jadi, tugas pertama (dan, mungkin, utama) ialah memilih kelas nenek moyang. Dalam senarai juntai bawah, semua komponen yang tersedia dalam palet ditawarkan sebagai kelas nenek moyang, termasuk yang tidak termasuk dalam pengedaran Delphi standard. Adalah perlu untuk memilih sebagai kelas nenek moyang kelas yang sedekat mungkin dalam sifat dengan kelas yang dicipta. Untuk tugas kita, kita boleh, sebagai contoh, pilih TWinControl sebagai nenek moyang, tetapi dalam kes ini kita perlu melaksanakan semua kesan visual klik butang, dsb. Oleh itu, kami memilih TButton sebagai moyang.
Nama kelas yang baru dicipta mesti mencerminkan kandungan komponen dan dalam keadaan tidak bertepatan dengan nama komponen yang telah didaftarkan! Pada peringkat mengisi dialog ini, nama tidak disemak untuk perlawanan - pengembaraan yang berkaitan dengan ralat sedemikian akan bermula kemudian...
Apabila memilih halaman, anda perlu tahu bahawa jika anda menentukan nama halaman yang tidak wujud, halaman baharu akan dibuat.
Akhir sekali, apabila anda mengklik kedua-dua butang Pasang dan OK, templat akan dibuat untuk melaksanakan komponen baharu. Walau bagaimanapun, apabila anda mengklik butang Pasang, templat akan diletakkan pada palet komponen, dan apabila anda mengklik OK, ia hanya dibuat. Adalah disyorkan untuk menggunakan butang Pasang. Selepas komponen dipasang, ia boleh diletakkan pada borang. Sekarang semua perubahan yang dibuat pada kod pelaksanaan komponen akan disusun bersama-sama dengan projek, dan pengaturcara akan segera menerima mesej ralat. Jika komponen tidak dipasang, maka untuk mencari ralat ia mesti disusun melalui editor pakej (lihat di atas) dengan mengklik butang Compile, yang kurang sesuai.
Jadi, selepas mengklik butang Pasang, dialog lain muncul, yang membolehkan anda menentukan pakej di mana komponen ini akan diletakkan.
Dialog ini mempunyai dua halaman, pada yang pertama anda boleh memilih salah satu daripada pakej sedia ada, dan pada yang kedua anda boleh membuat yang baharu. Adalah sangat dinasihatkan untuk memberikan penerangan teks ringkas bagi pakej; inilah yang akan ditunjukkan dalam dialog yang dipanggil oleh perintah Component/Install packages (lihat di atas). Selepas memilih pakej dan menekan butang OK, editor pakej dipanggil, di mana modul yang baru dibuat untuk melaksanakan komponen baru diletakkan secara automatik. Ia berguna untuk tidak menutupnya, tetapi untuk mengalihkannya ke salah satu sudut skrin supaya ia boleh diaktifkan dengan menekan butang tetikus.
Pada masa yang sama, "kosong" akan dibuat dalam editor kod untuk menerangkan komponen baharu:
Butang Bip Unit; antara muka menggunakan Windows, Mesej, SysUtils, Kelas, Grafik, Kawalan, Borang, Dialog, StdCtrls; jenis TButtonBeep = kelas(TButton) persendirian ( Pengisytiharan peribadi ) dilindungi ( Pengisytiharan dilindungi ) awam ( Pengisytiharan awam ) diterbitkan ( Pengisytiharan yang diterbitkan ) tamat; prosedur Daftar; prosedur pelaksanaan Daftar; mulakan RegisterComponents("Sampel", ); akhir; tamat.
Kelas baharu itu sendiri mengisytiharkan empat bahagian, yang maknanya diterangkan secara terperinci dalam bahagian “Keterlihatan pembolehubah dan kaedah” artikel sebelumnya dalam siri ini (ComputerPress No. 1 "2001). Di samping itu, kelas baharu mentakrifkan Prosedur daftar, yang dipanggil oleh persekitaran pembangunan Delphi semasa pemasangan modul ini sebagai komponen. Ia mengandungi nama halaman pada palet tempat komponen ini diletakkan, dan dalam kurungan persegi - nama kelas. Secara umum, kaedah Daftar mengambil tatasusunan jenis kelas sebagai parameter, kerana beberapa komponen boleh dilaksanakan dalam satu modul. Oleh itu, ia dipisahkan dengan koma, contohnya:
Daftar Prosedur; mulakan RegisterComponents("Sampel", ); akhir;
Mari kita teruskan menyelesaikan tugas di tangan - mencipta butang yang membuat berderit. Mula-mula, mari kita lakukan sesuatu yang remeh (tetapi ternyata nanti, salah) - tetapkan pengendali acara OnClick dalam pembina butang. Untuk melakukan ini, dalam bahagian peribadi, kami mentakrifkan pengepala kaedah baharu BtClick(Sender:TObject) dan melaksanakannya dalam bahagian pelaksanaan:
Prosedur TButtonBeep.BtClick(Penghantar:TObject); mulaBip; akhir;
constructor Create(AOwner:TComponent); mengatasi;
dengan arahan penggantian mandatori! Mari kita laksanakan di bahagian pelaksanaan:
Pembina TButtonBeep.Create(AOwner:TComponen); mula mewarisi Cipta(AOwner); OnClick:=BtClick; akhir;
Selepas ini, mari kita susun komponen. Mari letakkan butang pada borang dari halaman Sampel dan jalankan projek untuk pelaksanaan. Anda boleh memastikan bahawa butang berbunyi bip apabila ditekan!
Sekarang mari kita kembali ke persekitaran pembangunan dan tetapkan pengendali acara OnClick dalam pemeriksa objek. Dalam pengendali acara, kami akan memaparkan teks dalam tajuk borang:
Prosedur TForm1.ButtonBeep1Click(Pengirim:TObject); mulakan Kapsyen:="Ujian"; akhir;
Mari jalankan projek dan cuba tekan butang. Tajuk borang bertukar, tetapi butang berhenti berbunyi! Ralatnya ialah kami cuba mentakrifkan dua pengendali untuk satu acara butang OnClick: satu di dalam komponen BtClick, dan satu lagi ditugaskan menggunakan pemeriksa objek. Selepas menyelesaikan pembina TButtonBeep, kami mempunyai pautan kepada pengendali BtClick yang pertama. Kemudian sumber dimuatkan dan kaedah ButtonBeep1Click diberikan kepada pengendali acara OnClick. Dalam kes ini, pautan kepada pengendali pertama - BtClick - hilang tanpa dapat dipulihkan.
Oleh itu, semasa menulis komponen baharu, anda harus sentiasa mempertimbangkan untuk menukar sifat dan pengendali acara menggunakan Pemeriksa Objek. Jika sesuatu harta (acara) tidak sepatutnya berubah, ia tidak sepatutnya ditunjukkan dalam Pemeriksa Objek. Dan jika ia sudah kelihatan, anda harus menyembunyikannya (kita akan membincangkannya kemudian). Pengaturcara mempunyai hak untuk menukar mana-mana sifat dalam pemeriksa objek, dan jika selepas ini komponen berhenti berfungsi, pembangun komponen harus dipersalahkan, tetapi dalam keadaan apa pun pengaturcara menggunakannya.
Bagaimanakah kita boleh menyelesaikan masalah ini dengan betul? Satu cara untuk mencipta komponen adalah dengan menulis semula kaedah sedia ada. Apabila melihat fail StdCtrls.pas, di mana kod sumber untuk komponen TButton dilaksanakan, anda boleh ambil perhatian bahawa ia mengandungi kaedah Klik dinamik yang boleh ditulis semula. Oleh itu, kami kembali semula kepada kod sumber yang dicipta oleh pakar Delphi semasa mencipta komponen (kami mengalih keluar pembina dan kaedah BtClick). Kemudian di bahagian awam kami mentakrifkan pengepala kaedah:
Klik Prosedur; mengatasi;
dan inilah pelaksanaan kaedah tersebut:
Prosedur TButtonBeep.Klik; mula diwarisi Klik; bip; akhir;
Anda boleh mengesahkan bahawa butang itu berbunyi apabila ditekan. Di samping itu, apabila menetapkan pengendali acara dalam pemeriksa objek, pengendali ini dilaksanakan dan bip tidak hilang! Komponen dilaksanakan dengan betul.
Menggunakan contoh ini, adalah berguna untuk menganalisis kemungkinan ralat semasa menulis kod:
- Arahan penggantian terlupa apabila menentukan pengepala kaedah Klik. Butang berhenti berbunyi, oleh itu kaedah Klik tidak dipanggil.
- Panggilan terlupa kepada kaedah nenek moyang (Klik diwarisi) dalam pelaksanaan prosedur Klik. Butang terus berbunyi apabila ditekan, tetapi kod dalam pengendali acara yang diberikan dalam pemeriksa objek tidak dilaksanakan. Oleh itu, kaedah Klik kelas TButton menaikkan acara OnClick.
Sekarang mari kita tukar ikon komponen TButtonBeep pada palet. Secara lalai, ikon komponen nenek moyang digunakan untuk komponen baharu. Untuk melakukan ini, hubungi Editor Imej menggunakan arahan Alat/Editor Imej. Dalam editor, panggil arahan Fail/Baharu/Fail Sumber Komponen (*.dcr). Selepas arahan Sumber/Baru/Bitmap, dialog akan muncul mencadangkan saiz ikon 32x32. Saiz lalai ini harus ditukar kepada 24x24 - ini ialah saiz yang mesti ada pada ikon komponen! Selepas mengklik butang OK, anda harus melukis imej menggunakan alat standard yang serupa dengan alat editor Cat. Ingat bahawa warna piksel kiri bawah ialah warna topeng - warna ini akan menjadi "telus".
Selepas ini, anda perlu mentakrifkan semula nama sumber dengan ikon; secara lalai, namanya ialah Bitmap1. Nama sumber baharu mesti sepadan dengan nama kelas - dalam kes kami TButtonBeep.
Sekarang anda perlu menyimpan fail ikon dalam direktori yang sama dengan modul yang mengandungi prosedur Daftar untuk komponen ini, dan dengan nama yang sama dengan nama modul. Hanya sambungan fail tidak akan menjadi *.pas, tetapi *.dcr. Fail dengan ikon komponen sudah sedia. Walau bagaimanapun, jika kita melihat palet Komponen, kita akan melihat bahawa ikon lama masih ada. Jika anda memulakan semula Delphi atau sistem pengendalian, ikon lama masih akan kekal pada palet. Untuk menukar ikon, komponen mesti didaftarkan semula. Untuk melakukan ini anda perlukan:
Contoh ini harus dianggap sebagai latihan ujian. Sebelum menulis komponen baharu, anda perlu melihat sama ada komponen serupa wujud di kalangan komponen yang diedarkan secara bebas. Terdapat hampir mana-mana butang: lutsinar, lari, bulat, berwarna, dsb. Keadaannya lebih kurang sama dengan komponen lain - keturunan kelas yang sama. Oleh itu, selalunya anda perlu melaksanakan komponen yang terdiri daripada beberapa kawalan.
Oleh itu, dalam contoh ini kami meneroka penggunaan kaedah penulisan semula untuk mencipta komponen baharu.
Mencipta Komponen Kompleks
Katakan anda perlu memasukkan senarai nama pelanggan dalam aplikasi. Dalam aplikasi yang sama, anda juga perlu memasukkan senarai nombor telefon. Memasuki senarai adalah operasi yang agak biasa, jadi anda harus mempertimbangkan untuk melaksanakannya sebagai komponen.
Untuk memasukkan elemen baharu ke dalam senarai, anda memerlukan editor - komponen TEdit. Seterusnya, pengguna seharusnya dapat melihat senarai - komponen TListBox akan diperlukan. Di samping itu, anda memerlukan arahan untuk menulis nilai semasa daripada TEdit ke senarai, mengedit item senarai yang dipilih dan memadamkannya. Cara paling mudah untuk melaksanakan arahan ini ialah menggunakan butang. Untuk memudahkan tugas, kami akan meletakkan satu butang pada borang, apabila diklik kami akan menambah kandungan komponen TEdit ke dalam senarai.
Jadi kita perlu mencipta komponen baharu yang merangkumi TEdit, TListBox dan TButton. Seperti biasa, mari mula menciptanya dengan arahan Komponen/Komponen Baharu. Selepas ini, dialog muncul di mana anda harus menentukan kelas nenek moyang, nama kelas dan nama modul. Tiada masalah dengan nama kelas dan nama modul, tetapi nama kelas nenek moyang tidak jelas. Kami mempunyai tiga kawalan. Kelas nenek moyang yang sama untuk mereka ialah TWinControl. Tetapi jika kita memilihnya sebagai kelas nenek moyang, kita berhadapan dengan pelaksanaan kod TButton, TEdit dan TListBox yang sangat panjang dan membosankan. Dalam kes sedemikian, adalah perlu untuk memilih komponen sebagai kelas nenek moyang yang boleh menjadi "bapa" berhubung dengan komponen lain. Antara komponen standard yang diedarkan dengan Delphi, terdapat tiga: TPanel, TGroupBox, TScrollBox. Mari pilih panel sebagai kelas nenek moyang, tetapi bukan komponen TPanel itu sendiri, tetapi kelas TCustomPanel. Kami akan membincangkan kelebihan memilih TCustomPanel berbanding TPanel di bawah.
Mari namakan kelas baharu TListAdd dan klik butang Pasang. Selepas memilih pakej, komponen akan dipasang dalam palet, dari mana ia boleh diletakkan pada bentuk aplikasi yang baru dibuat. Ini mudah kerana apabila projek disusun, modul komponen juga akan disusun dan jika terdapat ralat, pengkompil akan memaparkan mesej.
Adalah mudah untuk meletakkan kawalan kami pada beberapa bentuk dan kemudian mencipta komponen daripadanya. Tiada pakar sedemikian dalam pakej Delphi standard. Oleh itu, anda perlu membuat sendiri komponen dan meletakkannya pada panel. Adalah munasabah untuk mencipta kawalan - TButton, TEdit dan TListBox - dalam pembina TCustomPanel, yang jelas memerlukan penulisan semula. Buat masa ini, mari letakkan kawalan dalam petak 100x100. Koordinat mereka juga perlu ditentukan dalam pembina. Perlu diingat bahawa selepas pembina mana-mana elemen kawalan telah diusahakan, ia belum mempunyai induk, iaitu, ia tidak tahu tetingkap mana yang harus mengukur koordinat sudut kiri atas berkenaan dengannya. Percubaan untuk menukar koordinat tetingkap kanak-kanak yang tidak mempunyai ibu bapa akan segera membuang pengecualian. Oleh itu, pengendali pertama selepas memanggil pembina kawalan adalah untuk menetapkannya sebagai ibu bapa, yang mana kami akan memilih TCustomPanel. Kami juga akan menjadikannya pemiliknya, dalam kes ini tidak perlu menulis semula pemusnah.
Jadi, dalam bahagian kegunaan kami menambah modul StdCtrls, di mana penerangan kelas TEdit, TButton dan TListBox terletak, dan dalam bahagian peribadi kami mentakrifkan tiga pembolehubah:
FEdit Persendirian:TEdit; FListBox:TListBox; FButton:TButton;
Di bahagian awam, kami mengisytiharkan pengepala pembina dengan arahan override wajib:
Cipta Pembina(AOwner:TComponent); mengatasi;
Kami melaksanakan pembina dalam bahagian pelaksanaan:
Pembina TListAdd.Create(AOwner:TComponen); mula mewarisi Cipta(AOwner); FButton:=TButton.Create(Self); FButton.Parent:=Diri; FButton.Kiri:=5; FButton.Atas:=5; FButton.Width:=40; FButton.Ketinggian:=25; FEdit:=TEdit.Create(Self); FEdit.Parent:=Self; FEdit.Kiri:=50; FEdit.Atas:=5; FEdit.Lebar:=45; FEdit.Ketinggian:=25; FListBox:=TListBox.Create(Self); FListBox.Parent:=Self; FListBox.Kiri:=5; FListBox.Top:=35; FListBox.Width:=90; FListBox.Ketinggian:=60; akhir;
Perlu ditekankan sekali lagi bahawa pemusnah dalam kes ini tidak perlu ditulis semula: panel adalah pemilik semua kawalan, dan apabila pemusnahnya dipanggil, pemusnah kawalan akan dipanggil secara automatik.
Selepas menyusun semula komponen menggunakan editor pakej, perubahan dalam komponen sudah boleh dilihat secara visual, pada peringkat pembangunan.
Kelemahan pertama yang menarik perhatian anda ialah tingkah laku kawalan yang tidak mencukupi semasa menskala komponen. Apabila menukar dimensinya, dimensi dan kedudukan elemen tidak berubah. Di samping itu, komponen boleh dibuat kecil supaya tiga kawalan tidak sesuai padanya. Dan akhirnya, apabila memasang komponen pada borang dari palet komponen dengan klik tetikus mudah, dimensinya juga meninggalkan banyak yang diingini.
Mula-mula, mari kita betulkan saiz lalai komponen, iaitu saiz komponen yang ditetapkan secara automatik apabila anda mengklik pada palet komponen dan kemudian klik pada borang. Untuk melakukan ini, anda hanya perlu menentukan dimensi panel baharu dalam pembina:
Lebar:=100; Tinggi:=100;
Kemudian anda perlu menambah baik tingkah laku komponen semasa penskalaan. Untuk melakukan ini, anda perlu menerima mesej bahawa dimensi telah berubah. Apabila saiz kawalan berubah, sistem menghantar mesej WM_SIZE kepadanya. Mesej ini mesti dipintas. Untuk melakukan ini, dalam bahagian peribadi kami menerangkan pengepala pemintas mesej:
Prosedur WMSize(var Message:Tmessage); mesej WM_SIZE;
dan dalam bahagian pelaksanaan kami melaksanakan pengendalinya:
Prosedur TListAdd.WMSize(var Message:TMessage); mula diwarisi; jika Lebar<100 then Width:=100; if Height<100 then Height:=100; FEdit.Width:=Width-55; FListBox.Width:=Width-10; FListBox.Height:=Height-40; end;
Pernyataan pertama ialah panggilan kepada pengendali WM_SIZE lalai (diwarisi). Selepas memanggilnya, sifat Width dan Height akan mengandungi lebar dan ketinggian baharu panel. Selepas ini, dimensi minimum komponen ditentukan, dalam kes ini 100x100. Jika saiz mendatar atau menegak kurang daripada minimum, maka ia diberikan nilai minimum. Kawalan kemudiannya diskalakan supaya ia mengisi seluruh panel dengan beberapa lekukan. Dengan menyusun komponen melalui editor pakej, anda sudah boleh ambil perhatian pada peringkat pembangunan bahawa kawalan pada panel berfungsi dengan betul apabila diskalakan, dan juga saiz komponen tidak boleh dibuat kurang daripada 100x100.
Sekarang adalah berguna untuk menjalankan keseluruhan projek, cuba masukkan data ke dalam editor teks satu baris dan klik butang. Dalam kes ini, tiada apa yang ditambahkan pada senarai. Dan tidak menghairankan, tidak ada bahagian dalam komponen kami yang menyatakan apa yang perlu dilakukan apabila butang ditekan. Untuk membuat pengendali acara dikaitkan dengan klik butang, anda boleh meneruskan seperti semasa menulis komponen TbuttonBeep, iaitu, tentukan kelas baharu - keturunan TButton dan tulis semula kaedah Klik. Walau bagaimanapun, mentakrifkan kelas baharu memerlukan sumber sistem (kaedah maya didarab). Jika kami menandakan komponen pada borang dan melihat pemeriksa objek, kami akan mendapati bahawa komponen TlistAdd mendedahkan beberapa sifat dan tiada peristiwa, termasuk tiada pengendali acara untuk butang OnClick. Oleh itu, perkara yang kami tolak dalam bab terakhir sebagai kaedah yang salah, mentakrifkan semula pengendali butang OnClick, terpakai dalam kes ini, kerana pengaturcara tidak boleh menetapkan pengendali baharu dalam pemeriksa objek. Jadi, dalam bahagian peribadi kami menerangkan pengepala kaedah baharu:
Prosedur BtClick(Penghantar:TObject);
Dalam pelaksanaan pembina TListAdd, kami menetapkan pengendali ini kepada pengendali acara FButton.OnClick:
FButton.OnClick:=BtClick;
Akhir sekali, mari kita laksanakan kaedah BtClick:
Prosedur TListAdd.BtClick(Penghantar:TObject); mulakan jika panjang(FEdit.Text)>0 kemudian mulakan FListBox.Items.Add(FEdit.Text); FEdit.Text:=""; FEdit.SetFocus; akhir; akhir;
Mula-mula, mari semak sama ada editor satu baris kosong: kami tidak akan menambah baris kosong pada senarai. Kemudian kami memindahkan kandungan editor ke senarai (FListBox.Items.Add(FEdit.Text);) dan menyediakan editor untuk memasukkan nilai seterusnya - iaitu, kami mengosongkannya daripada teks (yang telah dipindahkan ke senarai ) dan pindahkan fokus input kepadanya. Kini, selepas menyusun dan menjalankan aplikasi, anda boleh memastikan ia berfungsi dengan betul - apabila anda menekan butang, kandungan editor dipindahkan ke senarai.
Menambah Sifat dan Kaedah
Jika anda meletakkan komponen TPanel di sebelah komponen TListAdd dan membandingkan apa yang ditunjukkan dalam pemeriksa objek, anda akan melihat bahawa bilangan sifat dan peristiwa yang agak besar didedahkan untuk panel, manakala hanya beberapa sifat yang terdedah untuk TListAdd. Sementara itu, kelas TCustomPanel ialah nenek moyang kedua-dua komponen. Untuk memahami sebabnya, mari buka modul ExtCtrls.pas dan lihat perbezaan antara kelas TCustomPanel dan TPanel. Perlu diingatkan bahawa semua kaedah dan pembolehubah yang menyediakan kefungsian panel ditakrifkan pada peringkat kelas TCustomPanel. Ia juga mentakrifkan sifat yang kemudiannya dipaparkan dalam pemeriksa objek untuk TPanel, hanya sifat ini ditakrifkan dalam bahagian Dilindungi. Pelaksanaan kelas TPanel adalah sangat mudah: TCustomPanel ditakrifkan sebagai nenek moyang, dan sifat kelas ini diisytiharkan, tetapi dalam bahagian yang diterbitkan. Ia menjadi jelas apa yang perlu dilakukan dalam kelas TListAdd untuk sifat dan kaedah kelas TcustomPanel muncul dalam pemeriksa objek, iaitu untuk mengisytiharkan sifat. Dalam bahagian yang diterbitkan dalam kelas TListAdd kami menulis:
Penjajaran Harta; harta OnMouseDown;
Apabila mengisytiharkan harta, anda tidak perlu menentukan jenis atau pembolehubah rujukannya atau kaedah untuk membaca atau menulis harta tersebut. Selepas menyusun komponen melalui editor pakej dalam pemeriksa objek, anda boleh memerhatikan penampilan sifat Align dan acara OnMouseDown. Oleh itu, untuk keturunan kelas TCustom..., pengaturcara mempunyai peluang untuk memilih sifat dan acara yang perlu dipaparkan dalam pemeriksa objek dan yang tidak. Atas sebab inilah kelas TCustom... disyorkan untuk digunakan sebagai nenek moyang untuk mencipta komponen.
Sekarang mari kita lihat bagaimana anda boleh memperkenalkan harta baharu (apa yang kami lakukan di atas ialah pengisytiharan semula sifat sedia ada). Teks pada butang boleh digunakan sebagai sifat yang sesuai untuk dipaparkan dalam pemeriksa objek: biarkan pengaturcara menggunakan komponen TListAdd menukar teks pada masa reka bentuk. Cuba memperkenalkan harta baharu (mari kita panggilnya BtCaption) menggunakan pengisytiharan:
Property BtCaption:string read FButton.Caption write FButton.Caption;
mengakibatkan ralat semasa cuba menyusun komponen. Oleh itu, kami mentakrifkan pengepala dua kaedah dalam bahagian peribadi:
Fungsi GetBtCaption:string; prosedur SetBtCaption(Const Value:string);
Dalam bahagian yang diterbitkan, kami mengisytiharkan harta BtCaption:
BtCaption Harta: rentetan baca GetBtCaption tulis SetBtCaption;
Akhir sekali, kami melaksanakan dua kaedah yang diisytiharkan dalam bahagian pelaksanaan:
Fungsi TListAdd.GetBtCaption:string; mulakan Keputusan:=FButton.Caption; akhir; prosedur TListAdd.SetBtCaption(Const Value:string); mulakan FButton.Caption:=Nilai; akhir;
Selepas menyusun komponen menggunakan editor pakej, sifat baharu muncul dalam Pemeriksa Objek. Perubahan nilai harta ini dicerminkan secara langsung pada peringkat pembangunan.
Sekarang mari kita tentukan acara baharu. Dalam kes ini, adalah munasabah untuk mencipta acara yang membenarkan pengaturcara menggunakan komponen ini untuk menganalisis teks sebelum menambah kandungan editor pada senarai dan membenarkan atau melumpuhkan penambahan teks pada senarai. Oleh itu, kaedah ini mesti mengandungi sebagai parameter nilai semasa teks dalam editor dan bergantung pada pembolehubah Boolean, yang pengaturcara boleh menetapkan nilai Benar atau Salah. Selain itu, mana-mana pengendali peristiwa dalam komponen mesti bergantung pada parameter Pengirim, di mana komponen yang memanggilnya menghantar rujukan kepada dirinya sendiri. Ini adalah perlu kerana dalam persekitaran pembangunan Delphi pengendali acara yang sama boleh dipanggil dari beberapa komponen yang berbeza dan pengaturcara mesti dapat menganalisis komponen mana yang dipanggil pengendali. Jadi, selepas jenis perkataan dalam bahagian antara muka, sebelum mentakrifkan TListAdd, kami menentukan jenis kaedah baharu:
Taip TFilterEvent=procedure(Sender:TObject; const EditText:string; var CanAdd:boolean) objek;
FOnFilter:TFilterEvent;
Dan dalam bahagian yang diterbitkan kami mentakrifkan sifat jenis ini:
Property OnFilter:TFilterEvent baca FOnFilter tulis FOnFilter;
Apabila mentakrifkan harta baharu, kami merujuk kepada pembolehubah FOnFilter, dan bukan kepada kaedah - ia tidak diperlukan di sini. Sekarang, jika anda menyusun komponen menggunakan editor pakej, anda boleh melihat acara OnFilter muncul dalam Pemeriksa Objek. Walau bagaimanapun, jika kami menetapkan pengendali kepadanya dan menjalankan projek untuk pelaksanaan, ia mungkin tidak dipanggil. Ini kerana kami tidak memanggilnya di mana-mana bahagian dalam komponen kami. Tempat yang baik untuk memanggil acara OnFilter adalah dalam pengendali acara OnClick untuk FButton, yang telah dilaksanakan. Oleh itu, kami akan menukar kod pelaksanaan kaedah BtClick yang ditakrifkan sebelum ini:
Prosedur TListAdd.BtClick(Penghantar:TObject); var CanAdd:boolean; mulakan jika length(FEdit.Text)>0 kemudian mulakan CanAdd:=True; jika Ditugaskan(FOnFilter) maka FOnFilter(Self,FEdit.Text,CanAdd); jika BolehTambah kemudian mulakan FListBox.Items.Add(FEdit.Text); FEdit.Text:=""; FEdit.SetFocus; akhir lain bip; akhir; akhir;
Jadi, dalam coretan kod di atas, pembolehubah boolean CanAdd ditakrifkan. Semasa menulis kod, ambil perhatian bahawa pengaturcara mungkin tidak membuat pengendali acara OnFilter. Oleh itu, kami menetapkan nilai lalai pembolehubah CanAdd kepada Benar - tambah semua baris pada senarai. Seterusnya, sebelum memanggil FonFilter, anda harus menyemak sama ada pengaturcara telah mencipta pengendali acara. Ini dicapai dengan memanggil kaedah Ditugaskan, yang mengembalikan nilai boolean. Untuk penunjuk, memanggil kaedah Ditugaskan adalah bersamaan dengan menyemak P<>tiada. Untuk kaedah objek kami tidak boleh menggunakan semakan FOnFilter<>nil, kerana kaedah objek dicirikan oleh dua alamat dan semakan sedemikian tidak akan dibenarkan oleh pengkompil. Tetapi memanggil kaedah Ditugaskan dengan sempurna menyemak sama ada pengendali acara telah dibuat. Kod di atas ialah cara standard sepenuhnya untuk memanggil pengendali acara daripada komponen.
Yang tinggal hanyalah untuk menguji pengendali acara. Mari letakkan dua komponen TListAdd pada borang, untuk satu kita akan membenarkan menambah hanya integer, dan untuk yang lain - hanya perkataan yang bermula dengan huruf besar Inggeris. Oleh itu, kod untuk pengendali acara OnFilter akan kelihatan seperti ini:
Prosedur TForm1.ListAdd1Filter(Penghantar: TObject; const EditText: String; var CanAdd: Boolean); var I,N:integer; mulakan Val(EditText,N,I); BolehTambah:=I=0; akhir; prosedur TForm1.ListAdd2Filter(Penghantar: TObject; const EditText: String; var CanAdd: Boolean); mulakan CanAdd:=False; jika panjang(EditText)>0 maka CanAdd:=(EditText>="A") dan (EditText<="Z"); end;
Kod ini mudah difahami, satu-satunya kaveat ialah ia menyemak bahawa teks itu bukan rentetan kosong sebelum menyemak huruf pertama teks dalam pengendali acara ListAdd2Filter. Menjalankan semakan sedemikian adalah wajib: rentetan dalam Objek Pascal adalah objek, dan rentetan kosong sepadan dengan penunjuk nol. Jika anda cuba menyemak huruf pertama rentetan kosong, aplikasi akan cuba menyahrujuk nil, yang akan membuang pengecualian. Dalam kes ini, ini bukan masalah: sebelum memanggil pengendali acara FOnFilter daripada komponen TListAdd, rentetan diperiksa untuk panjang bukan sifar. Walau bagaimanapun, untuk komponen yang kod sumbernya tidak tersedia untuk anda, pengesahan sedemikian adalah wajib!
Menyembunyikan Sifat dalam Pemeriksa Objek
Katakan anda membuat komponen akses data, sebagai contoh, keturunan kelas TTable. Katakan komponen ini menganalisis senarai jadual yang tersedia dalam pangkalan data, dan berdasarkan beberapa kriteria (contohnya, kehadiran medan jenis tertentu dan dengan nama tertentu), satu dipilih untuk bekerja. Untuk operasi biasa komponen, nama jadual ini mesti dimasukkan dalam sifat TableName. Tetapi harta ini boleh dilihat dalam pemeriksa objek! Pengaturcara yang menggunakan komponen ini boleh mengubah nilainya semasa pembangunan, yang mungkin akan menjadikan komponen tidak boleh beroperasi. Dan dia akan betul! Jika mana-mana sifat atau peristiwa tidak boleh diubah, ia harus disembunyikan.
Kami akan terus mengusahakan komponen TListAdd dan mengalih keluar sifat Kursor daripada pemeriksa objek sebagai tugas model. Sifat ini ditakrifkan dalam bahagian yang diterbitkan dalam kelas TControl dan dipaparkan dalam pemeriksa objek untuk TListAdd dari awal pembangunan komponen. Berdasarkan ini, anda boleh cuba mengatasi sifat ini dalam bahagian yang dilindungi. Pengkompil akan membenarkan penggantian sedemikian, tetapi ia tidak akan membawa kepada hasil yang diingini: sifat Kursor akan kekal dalam pemeriksa objek seperti dahulu... Mana-mana harta, setelah ditakrifkan dalam bahagian yang diterbitkan, akan sentiasa dipaparkan dalam objek pemeriksa untuk semua keturunan kelas ini.
Untuk menyembunyikan harta daripada pemeriksa objek, kami menggunakan dua ciri pengkompil Delphi, iaitu:
- Apabila mengisytiharkan harta baharu dengan nama yang sama dengan harta sedia ada, harta yang ditakrifkan sebelum ini adalah "dibayangi".
- Sifat yang mempunyai akses baca sahaja atau tulis sahaja tidak muncul dalam pemeriksa objek, walaupun ia diisytiharkan dalam bahagian yang diterbitkan.
Sebelum anda mula berusaha untuk menyembunyikan sifat Kursor, adalah idea yang baik untuk mengalih keluar komponen TListAdd daripada borang, jika tidak, pengecualian mungkin berlaku apabila membaca sumber borang. Jadi, dalam bahagian persendirian kami mengisytiharkan pembolehubah FDummy:integer (nama dan jenis pembolehubah boleh menjadi apa sahaja) dan dalam bahagian yang diterbitkan kami mentakrifkan sifat baharu:
Kursor Harta:integer dibaca FDummy;
Sifat baharu mesti dipanggil Kursor, jenisnya mesti sepadan dengan jenis pembolehubah yang ditakrifkan di atas, sifat itu mestilah baca sahaja atau tulis sahaja. Selepas menyusun komponen menggunakan editor pakej, anda harus meletakkan komponen TListAdd pada borang sekali lagi. Anda mungkin mendapati bahawa sifat Kursor tidak lagi kelihatan dalam Pemeriksa Objek.
Sekarang mari kita merumitkan sedikit tugas. Katakan anda mahu kursor ditunjukkan bukan sebagai anak panah, tetapi sebagai jam pasir (crHourGlass). Untuk menukar nilai lalai sifat, nilai baharu mesti diberikan kepada pembolehubah dalam pembina. Apabila cuba memberikan nilai baharu kepada Kursor dalam pembina
Kursor:=crHourGlass;
Pengkompil Delphi akan mengeluarkan mesej diagnostik yang menyatakan bahawa nilai baharu tidak boleh diberikan kepada pembolehubah baca sahaja. Jika anda membuat sifat "tulis sahaja" baharu, pengkompil akan mengeluarkan mesej diagnostik yang berbeza - mengenai jenis data yang tidak serasi. Jika anda mengisytiharkan pembolehubah FDummy:TCursor dan menjadikannya tulis sahaja, pengkompil akan membenarkan tugasan ini, tetapi penampilan kursor tidak akan berubah: ia masih akan menjadi anak panah.
Penyelesaian remeh untuk masalah ini adalah untuk mengisytiharkan kelas keturunan TCustomPanel, dalam pembina yang anda perlukan untuk memberikan nilai baharu kepada pembolehubah Kursor, dan daripadanya menghasilkan komponen TListAdd kami. Penyelesaian ini mempunyai dua kelemahan:
- Ia intensif sumber - kaedah maya berganda.
- Kami menyembunyikan harta dalam pemeriksa objek daripada pengaturcara yang akan menggunakan komponen ini. Kami mahu bekerja dengan hartanah ini.
Oleh itu, penyelesaian kepada masalah ini kelihatan seperti ini: dalam pembina TListAdd kami mengisytiharkan pengendali:
Kursor yang diwarisi:=crHourGlass;
dan itu sahaja! Ini sudah cukup untuk menukar kursor.
Sebelum ini, kami menggunakan perkataan fungsi yang diwarisi hanya untuk memanggil kaedah nenek moyang. Pembinaan ini membolehkan anda lebih memahami maksud warisan sebagai rujukan kepada kelas nenek moyang. Anda boleh mengakses kedua-dua sifat dan kaedah. Apabila mengakses harta, anda boleh membacanya atau memberikan nilai baharu kepadanya; dalam kes ini, kata bantu yang diwarisi muncul di sebelah kiri tanda tugasan. Begitu juga, anda boleh memanggil kaedah nenek moyang tersembunyi. Panggilan hierarki lebih tinggi daripada kelas nenek moyang adalah dilarang - pembinaan
Kursor diwarisi diwarisi:=crHourGlass;
tidak akan menyusun.
Pada ketika ini kami akan menganggap projek ini telah siap. Dalam komponen baharu, kami memintas mesej, mengisytiharkan sifat, menambah sifat dan peristiwa baharu dan menyembunyikan harta yang diisytiharkan sebelum ini. Semua kaedah ini digunakan untuk membuat komponen. Di bawah ini kita akan melihat satu lagi kaedah yang menarik.
Menggunakan Prosedur Cangkuk untuk Mencipta Komponen
Telah disebutkan sebelum ini bahawa setiap kanak-kanak TWinControl mempunyai prosedur yang menerima dan memproses mesej. Jika terdapat rujukan kepada pemegang tetingkap (HWND), maka anda boleh menentukan alamat prosedur ini dan, yang lebih penting, mengatasi alamat ini dan dengan itu memproses mesej yang diterima dengan cara anda sendiri. Sebagai peraturan, tiada siapa yang menulis pengendali lengkap untuk semua mesej; kaedah lalai lama dipanggil lebih kerap. Dalam kes ini, prosedur baharu digunakan sebagai penapis: apabila acara tiba, kod tersebut dilaksanakan. Sebenarnya, ini adalah "perisik" dalam TwinControl: kami dimaklumkan apabila mesej tiba dan beberapa kod boleh dilaksanakan. Jika prosedur Hook dilaksanakan dengan betul, TWinControl terus berfungsi seperti biasa, tanpa menyedari bahawa ia berkongsi mesejnya dengan orang lain.
Prosedur cangkuk ditakrifkan seperti berikut:
Prosedur(var Mesej:TMessage) objek;
Ia bergantung pada pembolehubah jenis TMessage, yang mengandungi semua maklumat tentang mesej. Tetapi mentakrifkan prosedur ini tidak mencukupi. Ia mesti disalin untuk setiap TWinControl yang akan dilampirkan. Ini dicapai dengan memanggil kaedah WinAPI MakeObjectInstance. Kaedah ini mengambil kaedah objek sebagai parameter, membuat salinannya dalam ingatan, dan mengembalikan alamat kaedah baharu. Adalah jelas bahawa ini menyimpan sumber sistem yang perlu dikembalikan kepada sistem. Ini dicapai dengan memanggil kaedah FreeObjectInstance.
Satu lagi syarat penting: sebelum memusnahkan TWinControl, komunikasi dengan prosedur pemprosesan mesej lama mesti dipulihkan, jika tidak, sumber tidak akan dikembalikan kepada sistem. Ini bermakna anda perlu mengingati penuding kepada prosedur lama, yang boleh didapati dengan memanggil kaedah Win API GetWindowLong dengan parameter GWL_WNDPROC. Penunjuk ini juga akan digunakan untuk memanggil pengendali acara lalai TWinControl. Kaedah terbalik, SetWindowLong, digunakan untuk menetapkan prosedur Cangkuk.
Jadi, mari kita rumuskan masalah untuk latihan seterusnya. Katakan kita ingin mencipta komponen yang akan membuat komponen lain - keturunan TWinControl - bip apabila butang tetikus ditekan. Adalah jelas bahawa komponen ini tidak sepatutnya ditunjukkan semasa pelaksanaan aplikasi, jadi kami akan memilih TComponent sebagai kelas moyangnya. Mari kita takrifkan nama kelas sebagai TBeepWnd. Dalam bahagian peribadi kami mentakrifkan tiga pembolehubah:
FOldProc,FNewProc:penunjuk; FControl:TWinControl;
Daripada nama itu jelas bahawa kita akan mengingati pautan ke prosedur lama dalam pembolehubah FOldProc, pautan ke prosedur baru (selepas melaksanakan kaedah MakeObjectInstance) akan disimpan dalam pembolehubah FNewProc. Dan dalam pembolehubah FControl kami akan menyimpan pautan ke elemen kawalan di mana prosedur Hook sedang "digantung". Mari kita tentukan tiga kaedah dalam bahagian yang sama:
Prosedur HookProc(var Message:TMessage); prosedur HookWindow(W:TWinControl); prosedur UnhookWindow;
dan dalam bahagian pelaksanaan kami melaksanakannya:
Prosedur TBeepWnd.HookProc(var Message:TMessage); begin case Message.Msg of WM_LBUTTONDOWN:mulakan (Tugas kami) Bip; Message.Result:=CallWindowProc(FOldProc, FControl.Handle, Message.Msg, Message.WParam, Message.lParam); akhir; WM_DESTROY:mulakan (Apabila tetingkap hendak memusnahkan, keluarkan cangkuk) Message.Result:=CallWindowProc(FOldProc, FControl.Handle, Message.Msg, Message.WParam, Message.lParam); UnhookWindow; akhir; (Panggil pengendali lalai) lain Message.Result:=CallWindowProc(FOldProc, FControl.Handle, Message.Msg, Message.WParam, Message.lParam); akhir; akhir;
Dalam prosedur Hook itu sendiri, mesej dipintas, yang mana tindak balas berlaku - WM_LBUTTONDOWN. Selain itu, sebarang prosedur Cangkuk mesti mengendalikan mesej WM_DESTROY. Ini ialah mesej terakhir yang dihantar ke tetingkap sebelum ia dimusnahkan. Tanggapan kami adalah untuk memulihkan kaedah sebelumnya dengan memanggil kaedah UnhookWindow yang diterangkan di bawah. Akhir sekali, pengendali mesej lalai dipanggil sepanjang menggunakan kaedah CallWindowProc. Melupakan pengendali acara lalai adalah sama seperti melupakan yang diwarisi dalam pengendali acara; dalam 80% kes ini akan membawa kepada tingkah laku aplikasi yang salah. Jangan sekali-kali anda lupa untuk menetapkan keputusan memanggil kaedah CallWindowProc ke medan Hasil pembolehubah Mesej! Kod tidak akan berfungsi dalam kes ini!
Prosedur TBeepWnd.HookWindow(W:TWinControl); mulakan jika csDesigning dalam ComponentState kemudian mulakan (Menyemak jika komponen pada reka bentuk atau masa jalan) FControl:=W; Keluar; akhir; jika Fkawal<>tiada kemudian UnhookWindow; (Keluarkan cangkuk jika ia telah dipasang sebelum ini) jika W<>tiada kemudian mulakan FOldProc:=pointer(GetWindowLong(W.Handle,GWL_WNDPROC)); (Menentukan alamat prosedur lama) FNewProc:=MakeObjectInstance(HookProc); (Buat salinan dalam ingatan) SetWindowLong(W.Handle,GWL_WNDPROC,integer(FNewProc)); (Tetapkan prosedur baharu) tamat; Kawalan:=W; (Rujukan kedai pada kawalan) hujung;
Kaedah ini digunakan untuk menyediakan rutin pengendalian mesej baharu. Pertama, ia menyemak di peringkat mana komponen berada: pada peringkat pembangunan atau pada peringkat pelaksanaan. Jika komponen berada di peringkat pembangunan, iaitu, bendera csDesigning ditetapkan dalam sifat ComponentState, maka hanya pautan ke komponen disimpan tanpa memasang prosedur Hook. Ini dilakukan untuk mengelakkan pemasangan prosedur Hook pada persekitaran pembangunan Delphi. Jika prosedur ini sebelum ini ditetapkan pada kawalan lain, ia dikeluarkan dengan memanggil kaedah UnhookWindow. Selepas ini, alamat prosedur lama diingati (GetWindowLong), salinan dibuat dalam ingatan prosedur baharu (MakeObjectInstance) dan alamat prosedur baharu ditetapkan (SetWindowLong). Jenis tuangan dari integer ke penunjuk digunakan, dan sebaliknya - kaedah yang dipanggil memerlukan (atau mengembalikan) pembolehubah jenis yang tidak sesuai. Akhir sekali, rujukan kepada kawalan disimpan dalam pembolehubah FControl, yang kami takrifkan dalam bahagian peribadi.
Prosedur TBeepWnd.UnhookWindow; mulakan jika (FControl=nil) atau (FOldProc=nil) atau (FNewProc=nil) kemudian Keluar; (Tiada cangkuk dipasang) SetWindowLong(FControl.Handle,GWL_WNDPROC,integer(FOldProc)); (Tetapkan prosedur tetingkap lama) FreeObjectInstance(FNewProc); (Sumber percuma) FControl:=nil; (Mulakan pembolehubah) FOldProc:=nil; FNewProc:=tiada; akhir;
Kaedah ini memulihkan pengendali acara lama. Ia dipanggil daripada kaedah HookProc dan mesti juga dipanggil dari pemusnah komponen - Cangkuk mesti dialih keluar kedua-duanya apabila tetingkap dimusnahkan dan apabila komponen ini dimusnahkan. Kaedah SetWindowLong dengan alamat kaedah lama memulihkan pengendali mesej lama. Selepas ini, anda harus mengembalikan sumber kepada sistem dengan memanggil kaedah FreeObjectInstance.
Jadi, kaedah asas untuk bekerja dengan prosedur Hook telah ditakrifkan. Sekarang anda perlu menulis semula pemusnah supaya prosedur Hook dikeluarkan apabila komponen ini dimusnahkan:
Pemusnah TBeepWnd.Destroy; mulakan UnhookWindow; mewarisi Musnah; akhir;
Dan akhirnya, dalam bahagian yang diterbitkan kami menentukan harta yang akan dipaparkan dalam pemeriksa objek:
property Control:TWinControl baca FControl tulis HookWindow;
Untuk memasang komponen baharu, kami merujuk kepada kaedah yang ditakrifkan sebelum ini, yang, semasa aplikasi sedang berjalan, akan segera "menggantung" prosedur Cangkuk pada komponen, yang akan berbunyi apabila butang ditekan. Ingat bahawa bukannya pengendali Beep, anda boleh menulis sebarang kod boleh laku.
Komponen diuji secara ringkas: ia diletakkan pada borang di mana beberapa komponen keturunan TWinControl diletakkan. Selepas memilih komponen TBeepWnd di latar belakang, mengklik tetikus dalam medan Kawalan dalam pemeriksa objek mengembangkan senarai yang mengandungi semua TWinControl yang ditakrifkan pada borang. Anda harus memilih salah satu daripada mereka dan melancarkan aplikasi. Apabila anda mengklik butang kiri tetikus pada komponen yang dipilih, ia mengeluarkan bunyi berdecit.
Penyunting harta dan penyunting komponen
Semua yang diliputi dalam bahagian sebelumnya berkaitan dengan mencipta kod aplikasi yang akan diedarkan kepada pengguna. Walau bagaimanapun, persekitaran pembangunan Delphi membolehkan anda mengubah suai sendiri. Ini tidak memerlukan pengetahuan tentang bahasa khas, kerana semua kaedah untuk mengubah persekitaran pembangunan ditulis dalam Delphi. Di sini kaedah ini, iaitu editor harta dan editor komponen, dianggap sebahagiannya - dari segi mencipta alat untuk bekerja dengan komponen. Apabila membaca bahan dalam bahagian ini, anda harus memahami dengan jelas bahawa pengguna akhir yang bekerja dengan aplikasi anda tidak akan pernah melihat sama ada editor harta atau editor komponen - ia dicipta untuk pengaturcara dan hanya berfungsi dalam persekitaran pembangunan Delphi.
Penyunting harta
Semasa pembangunan aplikasi, sifat dipaparkan dalam Pemeriksa Objek. Sila ambil perhatian bahawa sifat diedit secara berbeza dalam Pemeriksa Objek. Sesetengah sifat (Lebar, Kapsyen) hanya boleh diberikan nilai teks baharu. Sifat jenis Kursor menyediakan senarai juntai bawah yang boleh anda klik untuk memilih nilai. Sifat jenis Tfont mempunyai tanda "+" di sebelah kiri; Apabila anda mengklik padanya, ia mengembang, membolehkan anda mengubah suai medan individu. Di samping itu, di sebelah kanan terdapat butang dengan tiga titik (butang eliptik), apabila diklik, dialog editor hartanah muncul.
Setiap sifat di atas mempunyai editornya sendiri, dan kelebihan besar persekitaran pembangunan Delphi ialah keupayaan untuk mencipta editor hartanah anda sendiri. Editor hartanah baharu adalah perkara biasa di kalangan komponen yang diedarkan. Tetapi mereka mesti dirawat dengan berhati-hati: mula-mula jalankan ujian pada komputer di mana anda boleh memasang semula Delphi jika perlu. Sebagai peraturan, mereka dicipta oleh pengaturcara yang berkelayakan dan tidak ada aduan tentang kod itu, tetapi mereka sering lupa untuk memasukkan mana-mana DLL dalam editor harta yang diedarkan. Selepas memasang editor sedemikian, kami mendapat beberapa sifat yang tidak boleh diedit - editor lama disekat, dan yang baru tidak berfungsi...
Sebelum mencipta editor hartanah baharu, masuk akal untuk memikirkan sama ada ia berbaloi untuk melakukan ini - anda mungkin boleh mencari editor yang sesuai dalam kalangan editor standard. Jika anda perlu mencipta editor harta, anda mesti mengikut peraturan: anda harus mengelak daripada membuat editor untuk jenis data standard (integer, rentetan, dll.). Pengaturcara lain sudah biasa dengan editor standard, dan mereka mungkin tidak menyukai editor anda. Oleh itu, anda perlu bersederhana dan mendaftarkan editor untuk kelas anda, dan bukan untuk kelas TComponent. Jika pengaturcara menyukai editor harta anda, kebanyakan mereka akan dapat menukar pendaftaran itu sendiri supaya editor berfungsi untuk semua komponen. Kami akan membincangkan isu pendaftaran editor di bawah.
Oleh itu, mari kita kemukakan masalah model, untuk pelaksanaannya diperlukan untuk melaksanakan editor harta benda. Katakan beberapa komponen mempunyai sifat - hari dalam seminggu. Pada dasarnya, untuk memasuki hari dalam seminggu, anda boleh menggunakan editor standard dengan senarai juntai bawah. Walau bagaimanapun, kami mahu pengaturcara di peringkat pembangunan dapat memasuki hari dalam seminggu, dengan menyatakan sama ada nombor sirinya (1 - Isnin, 2 - Selasa, dsb.), atau teks dalam bahasa kebangsaan atau Inggeris. Apabila memasukkan teks, mencampurkan huruf besar dan huruf kecil dibenarkan.
Pertama sekali, anda perlu membuat komponen yang akan menyimpan hari dalam seminggu. Mari buat komponen baharu dengan memanggil arahan Komponen/Baharu komponen. Mari pilih TComponent sebagai kelas nenek moyang dan berikan kelas baharu nama TDayStore. Selepas itu, pasang komponen dalam palet. Sekarang kita perlu memutuskan dalam bentuk apa untuk menyimpan hari dalam seminggu. Adalah jelas bahawa untuk pengecaman yang tidak jelas dan menyimpan sumber ia harus disimpan sebagai integer dengan julat yang sah 1-7. Walau bagaimanapun, jika kita akan mencipta editor hartanah, kita harus ingat peraturan tentang tidak membuat editor baharu untuk jenis sedia ada. Oleh itu, kami akan menentukan jenis baharu - TDayWeek, dan semua operasi dengannya akan dilakukan seperti dengan integer. Mari kita tentukan pembolehubah FDay dalam bahagian peribadi komponen. Oleh kerana pembolehubah ini akan dimulakan kepada 0 apabila pembina lalai dilaksanakan, dan nombor ini berada di luar nilai yang dibenarkan, pembina mesti ditulis semula. Akhir sekali, mari kita tentukan sifat DayWeek dalam bahagian yang diterbitkan untuk memaparkannya dalam pemeriksa objek. Komponen akhir kelihatan seperti ini:
Taip TDayWeek=jenis integer; TDayStore = kelas(TComponen) peribadi ( Perisytiharan peribadi ) FDay:TDayWeek; protected ( Protected declarations ) public ( Public declarations ) constructor Create(AOwner:TComponent); mengatasi; diterbitkan ( Pengisytiharan diterbitkan ) harta DayWeek:TDayWeek baca FDay tulis FDay; akhir; ... pembina pelaksanaan TDayStore.Create(AOwner:TComponent); mula mewarisi Cipta(Pemilik); Hari Jumaat:=1; akhir;
Perlu diberi perhatian kepada pembinaan jarang definisi jenis baru
TDayWeek=jenis integer;
Oleh itu, jenis data baharu diperkenalkan, yang mempunyai saiz yang sama dengan jenis integer; semua operasi pada jenis data ini dijalankan seperti dengan integer. Tujuan operasi ini adalah untuk mengisytiharkan jenis data baharu supaya editor sifat kami boleh digunakan secara khusus padanya dan tidak menjejaskan jenis data lain.
Sekarang mari buat editor untuk sifat TDayWeek. Untuk melakukan ini, tambahkan borang baharu pada projek sedia ada, ingat ia di bawah beberapa nama yang sesuai (DayPropE.pas) dan kecualikan ia daripada projek. Selepas ini, kami akan membuka borang sebagai fail berasingan dan melaksanakan editor harta di dalamnya. Pada peringkat pertama kita tidak memerlukan borang itu, tetapi kemudian kita akan melaksanakan dialog di atasnya.
Modul untuk mencipta editor harta dipanggil DsgnIntf.pas (Antara Muka Reka Bentuk), ia mentakrifkan kelas asas TPropertyEditor dan kelas turunan yang bertujuan untuk mengedit sifat standard - TIntegerProperty, TFloatProperty, TStringProperty, dll. Mekanisme operasi editor harta adalah seperti berikut:
- Ia didaftarkan dalam persekitaran pembangunan Delphi dengan memanggil kaedah RegisterPropertyEditor. Kaedah ini mengambil nilai berikut sebagai parameter:
a) maklumat tentang jenis sifat untuk penyuntingan yang dimaksudkan oleh editor ini. Disebabkan maklumat ini, kami terpaksa menentukan jenis baru TDayWeek;
b) maklumat tentang komponen di mana editor ini boleh digunakan. Editor akan dipanggil bukan sahaja untuk komponen yang ditentukan, tetapi juga untuk semua keturunannya. Jika anda menetapkan ini kepada TComponent, editor akan dipanggil untuk mana-mana komponen;
c) nama harta yang editor ini digunakan. Jika nama ialah rentetan kosong, dua penapis di atas digunakan;
- Kaedah GetValue dipanggil apabila nilai semasa harta perlu dibaca daripada komponen. Untuk sebarang harta, kaedah ini mengembalikan rentetan yang diletakkan dalam pemeriksa objek.
- Kaedah SetValue dipanggil apabila pengaturcara telah memasukkan nilai harta baharu dalam Pemeriksa Objek. Rentetan baharu diluluskan sebagai parameter. Dalam kaedah, ia mesti dianalisis dan ditukar kepada jenis harta yang sedang diedit.
Kaedah GetValue dan SetValue adalah maya; apabila ia ditulis semula, editor harta baharu dicipta. Jadi sekarang kita boleh mula mencipta editor hartanah baharu.
Mari rujuk modul DsgnIntf dalam bahagian kegunaan modul DayPropE.pas dan tentukan kelas baharu dalam bahagian Antara Muka:
Taipkan TDWPropED=class(TPropertyEditor) fungsi awam GetValue:string; mengatasi; procedure SetValue(Const Value:string); mengatasi; akhir;
Bahagian pelaksanaan harus melaksanakan kedua-dua kaedah ini. Dalam kes ini, kami juga memerlukan senarai nama hari dalam seminggu - dalam perumusan awal masalah diperlukan bahawa pengaturcara dapat memasukkan hari dalam seminggu:
Const DayWeek:array of string = ("Isnin", "Selasa", "Rabu", "Khamis", "Jumaat", "Sabtu", "Ahad"); DayWeekEn:array of string = ("Isnin", "Selasa", "Rabu", "Khamis", "Jumaat", "Sabtu", "Ahad");
