ɎȿȾȿɊȺɅɖɇɈȿ ȺȽȿɇɌɋɌȼɈ ɉɈ ɈȻɊȺɁɈȼȺɇɂɘ

ȽɈɋɍȾȺɊɋɌȼȿɇɇɈȿ ɈȻɊȺɁɈȼȺɌȿɅɖɇɈȿ
ɍɑɊȿɀȾȿɇɂȿ
ȼɕɋɒȿȽɈ ɉɊɈɎȿɋɋɂɈɇȺɅɖɇɈȽɈ ɈȻɊȺɁɈȼȺɇɂə
«ȼɈɊɈɇȿɀɋɄɂɃ ȽɈɋɍȾȺɊɋɌȼȿɇɇɕɃ
ɍɇɂȼȿɊɋɂɌȿɌ»

ɊȺɁɊȺȻɈɌɄȺ ɄɈɆɉɈɇȿɇɌɈȼ
ȼ DELPHI
ɍɱɟɛɧɨ-ɦɟɬɨɞɢɱɟɫɤɨɟ ɩɨɫɨɛɢɟ ɞɥɹ ɜɭɡɨɜ

ɋɨɫɬɚɜɢɬɟɥɢ:
Ƚ.ɗ. ȼɨɳɢɧɫɤɚɹ,
ȼ.Ƚ. Ɋɭɞɚɥɟɜ,
Ɇ.Ⱥ. Ⱥɪɬɟɦɨɜ

ɂɡɞɚɬɟɥɶɫɤɨ-ɩɨɥɢɝɪɚɮɢɱɟɫɤɢɣ ɰɟɧɬɪ
ȼɨɪɨɧɟɠɫɤɨɝɨ ɝɨɫɭɞɚɪɫɬɜɟɧɧɨɝɨ ɭɧɢɜɟɪɫɢɬɟɬɚ
2007
ɍɬɜɟɪɠɞɟɧɨ ɧɚɭɱɧɨ-ɦɟɬɨɞɢɱɟɫɤɢɦ ɫɨɜɟɬɨɦ ɮɚɤɭɥɶɬɟɬɚ ɩɪɢɤɥɚɞɧɨɣ ɦɚɬɟ-
ɦɚɬɢɤɢ, ɢɧɮɨɪɦɚɬɢɤɢ ɢ ɦɟɯɚɧɢɤɢ 14 ɦɚɹ 2007 ɝ., ɩɪɨɬɨɤɨɥ ʋ 9

Ɋɟɰɟɧɡɟɧɬ ɡɚɜ. ɤɚɮ. ɉɢɂɌ ɮ-ɬɚ ɎɄɇ ȼȽɍ ɇ.Ⱥ. Ɍɸɤɚɱɟɜ

ɍɱɟɛɧɨ-ɦɟɬɨɞɢɱɟɫɤɨɟ ɩɨɫɨɛɢɟ ɩɨɞɝɨɬɨɜɥɟɧɨ ɧɚ ɤɚɮɟɞɪɟ ɩɪɨɝɪɚɦɦɧɨɝɨ

ɨɛɟɫɩɟɱɟɧɢɹ ɢ ɚɞɦɢɧɢɫɬɪɢɪɨɜɚɧɢɹ ɢɧɮɨɪɦɚɰɢɨɧɧɵɯ ɫɢɫɬɟɦ ɮɚɤɭɥɶɬɟɬɚ
ɩɪɢɤɥɚɞɧɨɣ ɦɚɬɟɦɚɬɢɤɢ, ɢɧɮɨɪɦɚɬɢɤɢ ɢ ɦɟɯɚɧɢɤɢ ȼɨɪɨɧɟɠɫɤɨɝɨ ɝɨɫɭɞɚɪ-
ɫɬɜɟɧɧɨɝɨ ɭɧɢɜɟɪɫɢɬɟɬɚ.

Ɋɟɤɨɦɟɧɞɭɟɬɫɹ ɞɥɹ ɫɬɭɞɟɧɬɨɜ ɮɚɤɭɥɶɬɟɬɚ ɩɪɢɤɥɚɞɧɨɣ ɦɚɬɟɦɚɬɢɤɢ ȼɨɪɨ-

ɧɟɠɫɤɨɝɨ ɝɨɫɭɞɚɪɫɬɜɟɧɧɨɝɨ ɭɧɢɜɟɪɫɢɬɟɬɚ.

Ⱦɥɹ ɫɩɟɰɢɚɥɶɧɨɫɬɢ: 351500 – Ɇɚɬɟɦɚɬɢɱɟɫɤɨɟ ɨɛɟɫɩɟɱɟɧɢɟ ɢ ɚɞɦɢɧɢɫɬɪɢ-

ɪɨɜɚɧɢɟ ɢɧɮɨɪɦɚɰɢɨɧɧɵɯ ɫɢɫɬɟɦ
2
 ɋɨɞɟɪɠɚɧɢɟ
ȼɜɟɞɟɧɢɟ .............................................................................................................. 4
1. ɂɫɯɨɞɧɵɟ ɩɨɥɨɠɟɧɢɹ.................................................................................... 4
2. ɋɬɪɭɤɬɭɪɚ ɤɨɦɩɨɧɟɧɬɚ................................................................................. 8
2.1. Ɉɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ....................................................................... 8
2.2. ɋɨɡɞɚɧɢɟ ɫɜɨɣɫɬɜ ɤɨɦɩɨɧɟɧɬɚ ............................................ 11
2.3. Ɍɢɩɵ ɫɜɨɣɫɬɜ................................................................................. 14
2.4. Ɇɟɬɨɞɵ ............................................................................................... 16
2.5. ɋɨɛɵɬɢɹ............................................................................................. 18
3. ɉɪɨɟɤɬɢɪɨɜɚɧɢɟ ɤɨɦɩɨɧɟɧɬɚ.................................................................... 23
3.1. ɗɬɚɩɵ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ............................................................. 23
3.2. ɋɨɡɞɚɧɢɟ ɮɚɣɥɚ ɦɨɞɭɥɹ ........................................................... 25
3.3. ɇɚɫɬɪɨɣɤɚ ɤɨɦɩɨɧɟɧɬɚ ............................................................. 28
3.4. Ɉɛɴɹɜɥɟɧɢɟ ɤɨɧɫɬɪɭɤɬɨɪɚ ...................................................... 29
3.5. Ɍɟɫɬɢɪɨɜɚɧɢɟ ɢɧɬɟɪɮɟɣɫɚ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ ........ 30
3.6. ɍɫɬɚɧɨɜɤɚ ɤɨɦɩɨɧɟɧɬɚ ............................................................. 35
3.7. Ɋɟɫɭɪɫ ɤɨɦɩɨɧɟɧɬɚ..................................................................... 40
4. ɉɪɢɦɟɪɵ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ................................................................... 42
4.1. Ʉɨɦɩɨɧɟɧɬ, ɧɚɫɥɟɞɧɢɤ ɤɥɚɫɫɚ TGraphicControl...... 42
4.2. Ʉɨɦɩɨɧɟɧɬ ɞɥɹ ɨɬɨɛɪɚɠɟɧɢɹ ɬɟɤɭɳɟɝɨ ɜɪɟɦɟɧɢ ........ 49
4.3. Ʉɨɦɩɨɧɟɧɬ, ɜɵɩɨɥɧɹɸɳɢɣ ɜɵɱɢɫɥɟɧɢɹ ɧɚɞ
ɫɨɞɟɪɠɢɦɵɦ ɨɩɭɛɥɢɤɨɜɚɧɧɨɝɨ ɫɜɨɣɫɹɬɜɚ TStrings ............. 52
Ɂɚɞɚɧɢɹ .............................................................................................................. 55
Ʌɢɬɟɪɚɬɭɪɚ........................................................................................................ 57

3
 ȼɜɟɞɟɧɢɟ

Cɪɟɞɚ ɜɢɡɭɚɥɶɧɨɝɨ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ Borland Delphi ɫɨɞɟɪɠɢɬ ɜ ɫɟ-

ɛɟ ɛɨɥɶɲɨɟ ɤɨɥɢɱɟɫɬɜɨ ɝɨɬɨɜɵɯ ɤ ɢɫɩɨɥɶɡɨɜɚɧɢɸ ɤɨɦɩɨɧɟɧɬɨɜ, ɧɨ ɩɪɢ
ɪɚɡɪɚɛɨɬɤɟ ɫɥɨɠɧɵɯ ɩɪɢɥɨɠɟɧɢɣ ɞɚɠɟ ɬɚɤɨɝɨ ɦɧɨɝɨɨɛɪɚɡɢɹ ɧɟ ɯɜɚɬɚɟɬ. ȼ
ɬɚɤɢɯ ɫɥɭɱɚɹɯ ɦɨɠɧɨ ɭɫɬɚɧɚɜɥɢɜɚɬɶ ɜ ɫɪɟɞɭ ɤɨɦɩɨɧɟɧɬɵ ɫɬɨɪɨɧɧɢɯ ɩɪɨɢɡ-
ɜɨɞɢɬɟɥɟɣ ɥɢɛɨ ɪɚɡɪɚɛɚɬɵɜɚɬɶ ɫɨɛɫɬɜɟɧɧɵɟ ɤɨɦɩɨɧɟɧɬɵ.
ȼ ɞɚɧɧɨɦ ɭɱɟɛɧɨɦ ɩɨɫɨɛɢɢ ɢɡɥɚɝɚɸɬɫɹ ɨɫɧɨɜɵ ɫɨɡɞɚɧɢɹ ɩɨɥɶɡɨɜɚ-
ɬɟɥɶɫɤɢɯ ɤɨɦɩɨɧɟɧɬɨɜ ɜ ɫɪɟɞɟ Delphi 7. Ɉɩɢɫɵɜɚɸɬɫɹ ɫɬɪɭɤɬɭɪɚ ɤɨɦɩɨɧɟɧɬɚ
ɢ ɦɟɬɨɞɢɤɚ ɪɚɡɪɚɛɨɬɤɢ. ɉɪɢɜɨɞɹɬɫɹ ɩɪɢɦɟɪɵ ɪɟɲɟɧɢɹ ɬɢɩɨɜɵɯ ɡɚɞɚɱ.
Ⱦɥɹ ɪɚɛɨɬɵ ɫ ɩɨɫɨɛɢɟɦ ɬɪɟɛɭɟɬɫɹ ɡɧɚɧɢɟ ɨɫɧɨɜ ɨɛɴɟɤɬɧɨ-
ɨɪɢɟɧɬɢɪɨɜɚɧɧɨɝɨ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɧɚ ɹɡɵɤɟ Delphi.

1. ɂɫɯɨɞɧɵɟ ɩɨɥɨɠɟɧɢɹ

Ʉɨɦɩɨɧɟɧɬ – ɷɬɨ ɪɚɡɧɨɜɢɞɧɨɫɬɶ ɤɥɚɫɫɚ, ɨɛɥɚɞɚɸɳɚɹ ɫɩɨɫɨɛɧɨɫɬɶɸ

ɜɡɚɢɦɨɞɟɣɫɬɜɨɜɚɬɶ ɫ ɢɧɬɟɝɪɢɪɨɜɚɧɧɨɣ ɫɪɟɞɨɣ ɪɚɡɪɚɛɨɬɤɢ (IDE) Delphi ɜɨ
ɜɪɟɦɹ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɩɪɢɥɨɠɟɧɢɣ.
Ʉɨɝɞɚ ɪɚɡɪɚɛɨɬɱɢɤ ɩɪɢɥɨɠɟɧɢɹ ɩɨɦɟɳɚɟɬ ɤɨɦɩɨɧɟɧɬ ɧɚ ɮɨɪɦɭ, ɬɨ
ɞɢɡɚɣɧɟɪ ɮɨɪɦ ɫɨɡɞɚɟɬ ɷɤɡɟɦɩɥɹɪ ɜɵɛɪɚɧɧɨɝɨ ɤɨɦɩɨɧɟɧɬɚ ɢɡ ɫɨɨɬɜɟɬɫɬ-
ɜɭɸɳɟɝɨ ɤɨɦɩɨɧɟɧɬɧɨɝɨ ɤɥɚɫɫɚ. Ʉɨɦɩɨɧɟɧɬ ɨɬɨɛɪɚɠɚɟɬɫɹ ɧɚ ɮɨɪɦɟ, ɚ ɟɝɨ
ɨɩɭɛɥɢɤɨɜɚɧɧɵɟ ɫɜɨɣɫɬɜɚ ɫɬɚɧɨɜɹɬɫɹ ɞɨɫɬɭɩɧɵɦɢ ɞɥɹ ɪɟɞɚɤɬɢɪɨɜɚɧɢɹ ɧɚ
ɷɬɚɩɟ ɪɚɡɪɚɛɨɬɤɢ ɥɢɛɨ ɫ ɩɨɦɨɳɶɸ ɢɧɫɩɟɤɬɨɪɚ ɨɛɴɟɤɬɨɜ, ɥɢɛɨ ɱɟɪɟɡ ɫɨɡ-
ɞɚɧɧɵɟ ɪɚɡɪɚɛɨɬɱɢɤɨɦ ɤɨɦɩɨɧɟɧɬɚ ɪɟɞɚɤɬɨɪɵ ɤɨɦɩɨɧɟɧɬɨɜ ɢ ɪɟɞɚɤɬɨɪɵ
ɫɜɨɣɫɬɜ [1]. Ȼɚɡɨɜɭɸ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ ɤɨɦɩɨɧɟɧɬɨɜ ɨɛɟɫɩɟɱɢɜɚɟɬ ɤɥɚɫɫ
TComponent, ɹɜɥɹɸɳɢɣɫɹ ɩɪɟɞɤɨɦ ɜɫɟɯ ɤɨɦɩɨɧɟɧɬɨɜ. ɇɚɩɪɢɦɟɪ,
TComponent ɪɟɚɥɢɡɭɟɬ ɫɜɨɣɫɬɜɚ Name ɢ Tag, ɤɨɬɨɪɵɟ ɧɚɫɥɟɞɭɸɬɫɹ ɜɫɟ-
ɦɢ ɤɨɦɩɨɧɟɧɬɚɦɢ. Ȼɨɥɟɟ ɬɨɝɨ, TComponent ɫɨɞɟɪɠɢɬ ɦɟɬɨɞɵ ɢ ɫɜɨɣɫɬɜɚ,

4
ɤɨɬɨɪɵɟ ɩɪɟɞɨɫɬɚɜɥɹɸɬ ɤɨɦɩɨɧɟɧɬɚɦ ɜɨɡɦɨɠɧɨɫɬɶ ɨɛɪɚɛɚɬɵɜɚɬɶɫɹ ɞɢɡɚɣ-
ɧɟɪɨɦ ɮɨɪɦ.
ɏɨɬɹ ɤɨɦɩɨɧɟɧɬɵ ɢ ɪɟɚɥɢɡɭɸɬɫɹ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɤɥɚɫɫɨɜ ɹɡɵɤɚ
Delphi, ɧɨ ɨɛɴɹɜɥɟɧɢɟ ɤɥɚɫɫɚ ɧɟ ɹɜɥɹɟɬɫɹ ɨɛɴɹɜɥɟɧɢɟɦ ɤɨɦɩɨɧɟɧɬɚ, ɟɫɥɢ
ɤɥɚɫɫ ɧɟ ɩɨɪɨɠɞɟɧ ɨɬ Ɍɋɨmɪɨnent. ɗɤɡɟɦɩɥɹɪɵ ɤɥɚɫɫɨɜ, ɤɨɬɨɪɵɟ ɩɪɨɢɡ-
ɜɟɞɟɧɵ ɨɬ TComponent, ɧɚɡɵɜɚɸɬɫɹ ɤɨɦɩɨɧɟɧɬɚɦɢ, ɚ ɷɤɡɟɦɩɥɹɪɵ ɜɫɟɯ
ɞɪɭɝɢɯ ɤɥɚɫɫɨɜ ɧɚɡɵɜɚɸɬɫɹ ɨɛɴɟɤɬɚɦɢ. Ƚɥɚɜɧɚɹ ɪɚɡɧɢɰɚ ɦɟɠɞɭ ɷɬɢɦɢ ɞɜɭ-
ɦɹ ɩɨɧɹɬɢɹɦɢ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɬɨɦ, ɱɬɨ ɤɨɦɩɨɧɟɧɬɚɦɢ ɦɨɠɧɨ ɦɚɧɢɩɭɥɢɪɨ-
ɜɚɬɶ ɧɚ ɮɨɪɦɟ, ɬɨɝɞɚ ɤɚɤ ɨɛɴɟɤɬɚɦɢ – ɧɟɥɶɡɹ.
Ɉɫɨɛɟɧɧɨɫɬɢ ɩɨɫɬɪɨɟɧɢɹ ɤɨɦɩɨɧɟɧɬɨɜ:
– ɤɨɦɩɨɧɟɧɬɵ ɢɦɟɸɬ ɞɪɭɝɢɯ ɤɨɧɟɱɧɵɯ ɩɨɥɶɡɨɜɚɬɟɥɟɣ;
– ɤɨɦɩɨɧɟɧɬɵ ɹɜɥɹɸɬɫɹ ɢɧɫɬɪɭɦɟɧɬɚɦɢ ɢ ɢɫɩɨɥɶɡɭɸɬɫɹ ɪɚɡɪɚɛɨɬɱɢɤɚɦɢ
ɩɪɢɥɨɠɟɧɢɣ;
– ɧɚɩɢɫɚɧɢɟ ɤɨɦɩɨɧɟɧɬɨɜ ɹɜɥɹɟɬɫɹ ɨɛɴɟɤɬɧɨ-ɨɪɢɟɧɬɢɪɨɜɚɧɧɵɦ ɧɟɜɢɡɭɚɥɶ-
ɧɵɦ ɩɪɨɰɟɫɫɨɦ.

ȼ ɨɛɳɟɦ ɫɥɭɱɚɟ ɩɪɨɰɟɫɫ ɪɚɡɪɚɛɨɬɤɢ ɤɨɦɩɨɧɟɧɬɚ ɞɨɥɠɟɧ ɜɤɥɸɱɚɬɶ

ɫɥɟɞɭɸɳɢɟ ɷɬɚɩɵ:
– ɮɨɪɦɭɥɢɪɨɜɤɚ ɬɪɟɛɨɜɚɧɢɣ ɤ ɤɨɦɩɨɧɟɧɬɭ ɢ ɜɵɛɨɪ ɤɥɚɫɫɚ-ɩɪɟɞɤɚ;
– ɧɚɩɢɫɚɧɢɟ ɤɨɞɚ ɤɨɦɩɨɧɟɧɬɚ;
– ɨɬɥɚɞɤɚ ɢ ɩɪɟɞɜɚɪɢɬɟɥɶɧɨɟ ɬɟɫɬɢɪɨɜɚɧɢɟ ɤɨɦɩɨɧɟɧɬɚ;
– ɜɤɥɸɱɟɧɢɟ ɤɨɦɩɨɧɟɧɬɚ ɜ ɫɪɟɞɭ Delphi;
– ɨɤɨɧɱɚɬɟɥɶɧɨɟ ɬɟɫɬɢɪɨɜɚɧɢɟ.

ɉɟɪɜɵɣ ɲɚɝ ɩɪɢ ɫɨɡɞɚɧɢɢ ɤɨɦɩɨɧɟɧɬɨɜ – ɢɡɭɱɟɧɢɟ ɢɟɪɚɪɯɢɢ ɛɢɛ-

ɥɢɨɬɟɤɢ ɜɢɡɭɚɥɶɧɵɯ ɤɨɦɩɨɧɟɧɬɨɜ VCL (ɫɦ. ɪɢɫ. 1) ɫ ɰɟɥɶɸ ɜɵɛɨɪɚ ɧɟɩɨ-
ɫɪɟɞɫɬɜɟɧɧɨɝɨ ɩɪɟɞɤɚ. Ɂɞɟɫɶ ɬɪɟɛɭɟɬɫɹ ɜɵɹɜɢɬɶ ɫɭɳɟɫɬɜɭɸɳɢɣ ɤɨɦɩɨɧɟɧɬ,
ɤɨɬɨɪɵɣ ɧɚɢɛɨɥɟɟ ɛɥɢɡɤɨ ɩɨɞɯɨɞɢɬ ɩɨɞ ɬɨ, ɱɬɨ ɬɪɟɛɭɟɬɫɹ ɩɨɥɭɱɢɬɶ, ɢ ɢɡ-
ɦɟɧɢɬɶ ɭɧɚɫɥɟɞɨɜɚɧɧɨɟ ɩɨɜɟɞɟɧɢɟ. ɇɚɩɪɢɦɟɪ, ɞɥɹ ɫɨɡɞɚɧɢɹ ɫɩɟɰɢɚɥɢɡɢɪɨ-

5
ɜɚɧɧɨɝɨ ɩɨɥɹ ɪɟɞɚɤɬɢɪɨɜɚɧɢɹ ɦɨɠɧɨ ɨɩɪɟɞɟɥɢɬɶ ɧɨɜɵɣ ɤɨɦɩɨɧɟɧɬ ɤɚɤ ɩɨ-
ɬɨɦɨɤ ɤɥɚɫɫɚ TCustomEdit ɢ ɫɞɟɥɚɬɶ ɧɭɠɧɵɟ ɦɨɞɢɮɢɤɚɰɢɢ.
Ʉɨɦɩɨɧɟɧɬɵ ɞɟɥɹɬɫɹ ɧɚ ɞɜɟ ɝɪɭɩɩɵ – ɜɢɡɭɚɥɶɧɵɟ ɢ ɧɟɜɢɡɭɚɥɶɧɵɟ.
ȼɢɡɭɚɥɶɧɵɟ ɤɨɦɩɨɧɟɧɬɵ ɨɬɨɛɪɚɠɚɸɬɫɹ ɧɚ ɮɨɪɦɟ ɜɨ ɜɪɟɦɹ ɪɚɛɨɬɵ ɩɪɨ-
ɝɪɚɦɦɵ. Ɉɧɢ ɹɜɥɹɸɬɫɹ ɩɨɬɨɦɤɚɦɢ ɤɥɚɫɫɚ TControl ɢ ɩɨɷɬɨɦɭ ɢɧɨɝɞɚ ɧɚ-
ɡɵɜɚɸɬɫɹ ɷɥɟɦɟɧɬɚɦɢ ɭɩɪɚɜɥɟɧɢɹ. ɉɪɢɦɟɪɚɦɢ ɧɟɜɢɡɭɚɥɶɧɵɯ ɤɨɦɩɨɧɟɧɬɨɜ
ɹɜɥɹɸɬɫɹ ɤɨɦɩɨɧɟɧɬɵ Ttimer, TMenu, TOpenDialog, ɤɨɦɩɨɧɟɧɬɵ ɞɨɫ-
ɬɭɩɚ ɤ ɛɚɡɚɦ ɞɚɧɧɵɯ (TTable, TQuery ɢ ɬ. ɩ.). ɇɟɜɢɡɭɚɥɶɧɵɟ ɤɨɦɩɨɧɟɧ-
ɬɵ ɧɟ ɜɢɞɧɵ ɧɚ ɮɨɪɦɟ ɢ ɪɚɛɨɬɚɸɬ «ɡɚ ɤɭɥɢɫɚɦɢ» ɩɪɢɥɨɠɟɧɢɹ. ɂɯ ɩɪɟɞɤɨɦ
ɧɟ ɹɜɥɹɟɬɫɹ TControl, ɚ ɧɚɫɥɟɞɨɜɚɧɢɟ ɢɞɟɬ ɨɬ Tcomponent.
ȼɢɡɭɚɥɶɧɵɟ ɤɨɦɩɨɧɟɧɬɵ ɞɟɥɹɬɫɹ ɧɚ ɞɜɟ ɝɪɭɩɩɵ – ɝɪɚɮɢɱɟɫɤɢɟ ɢ ɨɤɨɧ-
ɧɵɟ. Ƚɪɚɮɢɱɟɫɤɢɟ ɤɨɦɩɨɧɟɧɬɵ ɩɨɪɨɠɞɚɸɬɫɹ ɨɬ TGraphicControl ɢ ɢɦɟ-
ɸɬ ɜɢɡɭɚɥɶɧɨɟ ɩɪɟɞɫɬɚɜɥɟɧɢɟ, ɧɨ ɧɟ ɩɨɥɭɱɚɸɬ ɮɨɤɭɫɚ ɜɜɨɞɚ. Ƚɥɚɜɧɨɣ ɨɫɨ-
ɛɟɧɧɨɫɬɶɸ ɩɨɬɨɦɤɨɜ TGraphicControl ɹɜɥɹɟɬɫɹ ɧɚɥɢɱɢɟ ɫɜɨɣɫɬɜɚ Can-
vas: TCanvas, ɩɨɡɜɨɥɹɸɳɟɝɨ ɜɵɜɨɞɢɬɶ ɢɡɨɛɪɚɠɟɧɢɟ ɩɪɹɦɨ ɧɚ ɩɨɜɟɪɯɧɨ-
ɫɬɢ ɤɨɦɩɨɧɟɧɬɚ. ɉɪɢɦɟɪɚɦɢ ɝɪɚɮɢɱɟɫɤɢɯ ɤɨɦɩɨɧɟɧɬɨɜ ɹɜɥɹɸɬɫɹ TImage,
TPaintBox, TLabel.
Ɉɤɨɧɧɵɟ ɤɨɦɩɨɧɟɧɬɵ ɩɪɨɢɫɯɨɞɹɬ ɨɬ TWinControl. Ɉɧɢ ɢɧɤɚɩɫɭ-
ɥɢɪɭɸɬ ɮɭɧɤɰɢɢ API ɞɥɹ ɪɚɛɨɬɵ ɫ ɨɤɧɚɦɢ Windows, ɭɦɟɸɬ ɩɨɥɭɱɚɬɶ ɮɨ-
ɤɭɫ ɜɜɨɞɚ ɢ ɫɨɞɟɪɠɚɬ ɫɜɨɣɫɬɜɨ Handle: THandle. Ⱦɚɧɧɨɟ ɫɜɨɣɫɬɜɨ ɯɪɚ-
ɧɢɬ ɞɟɫɤɪɢɩɬɨɪ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɝɨ ɨɤɨɧɧɨɝɨ ɨɛɴɟɤɬɚ Windows ɢ ɦɨɠɟɬ
ɛɵɬɶ ɢɫɩɨɥɶɡɨɜɚɧɨ ɞɥɹ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨɝɨ ɜɵɡɨɜɚ ɮɭɧɤɰɢɣ API ɢ ɨɛɦɟɧɚ
ɫɨɨɛɳɟɧɢɹɦɢ Windows ɦɟɠɞɭ ɤɨɦɩɨɧɟɧɬɚɦɢ.
ɂɧɨɝɞɚ ɞɥɹ ɫɨɡɞɚɧɢɹ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɨɝɨ ɷɥɟɦɟɧɬɚ ɭɩɪɚɜɥɟɧɢɹ ɢɫ-
ɩɨɥɶɡɭɟɬɫɹ ɤɥɚɫɫ TCustomControl. ɗɬɨ ɩɪɹɦɨɣ ɩɨɬɨɦɨɤ TWinControl,
ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɧɚɫɥɟɞɭɸɳɢɣ ɜɫɸ ɟɝɨ ɮɭɧɤɰɢɨɧɚɥɶɧɨɫɬɶ. ɇɨ ɞɨɩɨɥɧɢɬɟɥɶ-
ɧɨ ɨɧ ɜ ɫɟɤɰɢɢ Protected ɫɨɞɟɪɠɢɬ ɫɜɨɣɫɬɜɨ Canvas, ɧɟɨɛɯɨɞɢɦɨɟ ɞɥɹ
ɪɢɫɨɜɚɧɢɹ. ɑɬɨɛɵ ɢɫɩɨɥɶɡɨɜɚɬɶ ɷɬɨ ɫɜɨɣɫɬɜɨ ɜ ɩɨɬɨɦɤɚɯ

6
TCustomControl, ɟɝɨ ɧɚɞɨ ɩɟɪɟɧɟɫɬɢ ɜ ɫɟɤɰɢɸ Public (ɫɦ. ɫɥɟɞɭɸ-
ɳɢɣ ɪɚɡɞɟɥ).

Ɋɢɫ. 1. Ɏɪɚɝɦɟɧɬ ɢɟɪɚɪɯɢɢ ɤɥɚɫɫɨɜ ɛɢɛɥɢɨɬɟɤɢ VCL

Ɋɟɤɨɦɟɧɞɚɰɢɢ ɩɨ ɢɫɩɨɥɶɡɨɜɚɧɢɸ ɪɨɞɢɬɟɥɶɫɤɢɯ ɤɥɚɫɫɨɜ ɜ ɤɚɱɟɫɬɜɟ

ɩɪɟɞɤɚ ɞɥɹ ɧɨɜɨɝɨ ɤɨɦɩɨɧɟɧɬɧɨɝɨ ɤɥɚɫɫɚ ɩɪɢɜɟɞɟɧɵ ɜ ɬɚɛɥɢɰɟ 1.
Ȼɚɡɨɜɵɟ ɤɥɚɫɫɵ Delphi ɞɥɹ ɫɨɡɞɚɧɢɹ ɤɨɦɩɨɧɟɧɬɨɜ Ɍɚɛɥɢɰɚ 1
ɍɧɚɫɥɟɞɨɜɚɧ ɨɬ Ⱦɥɹ ɫɨɡɞɚɧɢɹ
ɋɭɳɟɫɬɜɭɸɳɟɝɨ ɤɨɦɩɨɧɟɧɬɚ Ɇɨɞɢɮɢɰɢɪɨɜɚɧɧɨɣ ɜɟɪɫɢɢ ɪɚɛɨ-
ɬɚɸɳɟɝɨ ɤɨɦɩɨɧɟɧɬɚ
TGraphicControl Ƚɪɚɮɢɱɟɫɤɨɝɨ ɤɨɦɩɨɧɟɧɬɚ, ɧɟ ɬɪɟ-
ɛɭɸɳɟɝɨ ɮɨɤɭɫɚ ɜɜɨɞɚ
TWinControl Ɉɤɨɧɧɨɝɨ ɤɨɦɩɨɧɟɧɬɚ, ɢɫɩɨɥɶ-

7
 ɡɭɸɳɟɝɨ ɞɟɫɤɪɢɩɬɨɪ ɨɤɧɚ ɢɥɢ ɞɥɹ
ɫɨɡɞɚɧɢɹ ɨɛɨɥɨɱɤɢ ɜɨɤɪɭɝ ɫɭɳɟɫɬ-
ɜɭɸɳɢɯ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɢɯ ɨɤɨɧ-
ɧɵɯ ɷɥɟɦɟɧɬɨɜ ɭɩɪɚɜɥɟɧɢɹ
TCustomControl Ɉɪɢɝɢɧɚɥɶɧɨɝɨ ɤɨɦɩɨɧɟɧɬɚ
TComponent ɇɟɜɢɡɭɚɥɶɧɨɝɨ ɤɨɦɩɨɧɟɧɬɚ

Ɂɚɱɚɫɬɭɸ ɧɨɜɨɦɭ ɤɨɦɩɨɧɟɧɬɭ ɧɟ ɧɭɠɧɵ ɜɫɟ ɫɜɨɣɫɬɜɚ ɩɪɟɞɤɚ, ɤɨɬɨ-

ɪɵɯ ɦɨɝɭɬ ɛɵɬɶ ɦɧɨɝɢɟ ɞɟɫɹɬɤɢ. ɑɬɨɛɵ ɭɩɪɨɫɬɢɬɶ ɪɚɡɪɚɛɨɬɤɭ, ɜ ɢɟɪɚɪɯɢɢ
ɤɨɦɩɨɧɟɧɬɨɜ ɢɦɟɸɬɫɹ ɤɨɦɩɨɧɟɧɬɵ, ɜ ɧɚɡɜɚɧɢɢ ɤɨɬɨɪɵɯ ɩɪɢɫɭɬɫɬɜɭɟɬ ɫɥɨ-
ɜɨ «Custom» (ɡɚɤɚɡɧɨɣ). Ɍɚɤɢɟ ɤɨɦɩɨɧɟɧɬɵ ɧɟ ɢɦɟɸɬ ɨɩɭɛɥɢɤɨɜɚɧɧɵɯ
ɫɜɨɣɫɬɜ, ɬ. ɟ. ɫɜɨɣɫɬɜ, ɜɢɞɧɵɯ ɜ ɢɧɫɩɟɤɬɨɪɟ ɨɛɴɟɤɬɨɜ. ȼɫɟ ɫɜɨɣɫɬɜɚ, ɞɨɫ-
ɬɭɩɧɵɟ ɤ ɨɩɭɛɥɢɤɨɜɚɧɢɸ, ɩɟɪɟɱɢɫɥɟɧɵ ɜ ɫɟɤɰɢɢ protected. ɉɨɷɬɨɦɭ
ɟɫɥɢ ɦɵ ɯɨɬɢɦ ɦɨɞɢɮɢɰɢɪɨɜɚɬɶ TEdit, ɧɨ ɧɟ ɜɫɟ ɫɜɨɣɫɬɜɚ TEdit ɧɚɦ
ɧɭɠɧɵ, ɬɨ ɥɭɱɲɟ ɧɚɫɥɟɞɨɜɚɬɶ ɧɟ ɨɬ TEdit, ɚ ɨɬ TCustomEdit. Ⱦɚɥɟɟ,
ɱɬɨɛɵ ɨɩɭɛɥɢɤɨɜɚɬɶ ɧɟɨɛɯɨɞɢɦɵɟ ɫɜɨɣɫɬɜɚ ɜ ɧɚɲɟɦ ɤɨɦɩɨɧɟɧɬɟ, ɫɥɟɞɭɟɬ
ɩɪɢ ɨɛɴɹɜɥɟɧɢɢ ɟɝɨ ɤɥɚɫɫɚ ɩɪɨɫɬɨ ɩɟɪɟɱɢɫɥɢɬɶ ɧɚɡɜɚɧɢɹ ɫɜɨɣɫɬɜ ɜ ɫɟɤɰɢɢ
published.

2. ɋɬɪɭɤɬɭɪɚ ɤɨɦɩɨɧɟɧɬɚ

2.1. Ɉɛɥɚɫɬɢ ɜɢɞɢɦɨɫɬɢ

Ʉɨɦɩɨɧɟɧɬɵ ɢɦɟɸɬ ɪɚɡɧɵɟ ɩɪɨɝɪɚɦɦɧɵɟ ɢɧɬɟɪɮɟɣɫɵ: ɢɧɬɟɪɮɟɣɫ

ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ (ɤɚɤ ɤɨɦɩɨɧɟɧɬ ɦɨɠɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ, ɤɚɤɢɟ ɦɟɬɨɞɵ,
ɫɜɨɣɫɬɜɚ ɢ ɫɨɛɵɬɢɹ ɛɭɞɭɬ ɞɨɫɬɭɩɧɵ), ɢɧɬɟɪɮɟɣɫ ɜɪɟɦɟɧɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ
(ɤɚɤ ɤɨɦɩɨɧɟɧɬ ɜɟɞɺɬ ɫɟɛɹ ɜ ɫɪɟɞɟ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ), ɢɧɬɟɪɮɟɣɫ ɪɚɡɪɚɛɨɬ-
ɱɢɤɚ (ɨɛɟɫɩɟɱɢɜɚɟɬ ɞɨɫɬɭɩ ɤ ɞɟɬɚɥɹɦ ɪɟɚɥɢɡɚɰɢɢ). ɑɬɨɛɵ ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ
ɪɚɡɝɪɚɧɢɱɢɬɶ ɞɨɫɬɭɩ ɤ ɩɨɥɹɦ, ɦɟɬɨɞɚɦ ɢ ɫɜɨɣɫɬɜɚɦ ɤɥɚɫɫɚ (ɬ. ɟ. ɡɚɞɚɬɶ ɨɛ-

8
ɥɚɫɬɶ ɜɢɞɢɦɨɫɬɢ), ɜ Delphi ɨɩɪɟɞɟɥɟɧɵ ɱɟɬɵɪɟ ɨɫɧɨɜɧɵɟ ɞɢɪɟɤɬɢɜɵ, ɩɪɢ-
ɜɟɞɟɧɧɵɟ ɜ ɬɚɛɥɢɰɟ 2.

ɍɪɨɜɧɢ ɞɨɫɬɭɩɚ ɤ ɩɨɥɹɦ ɢ ɦɟɬɨɞɚɦ ɤɥɚɫɫɚ Ɍɚɛɥɢɰɚ 2

Private Ʌɢɱɧɵɟ ɇɟɜɢɞɢɦɵ ɜɧɟ ɦɨɞɭɥɹ ɢɥɢ ɩɪɨɝɪɚɦɦɵ, ɜ
ɤɨɬɨɪɨɣ ɤɥɚɫɫ ɨɛɴɹɜɥɟɧ
Protected Ɂɚɳɢɳɟɧ- ȼɢɞɢɦɵ ɜɟɡɞɟ ɜ ɦɨɞɭɥɟ, ɜ ɤɨɬɨɪɨɦ ɤɥɚɫɫ ɨɛɴ-
ɧɵɟ ɹɜɥɹɟɬɫɹ, ɢ ɢɡ ɥɸɛɨɝɨ ɤɥɚɫɫɚ ɩɨɬɨɦɤɚ, ɧɟɡɚɜɢ-
ɫɢɦɨ ɨɬ ɦɨɞɭɥɹ, ɝɞɟ ɤɥɚɫɫ ɩɨɬɨɦɤɚ ɩɨɹɜɥɹɟɬ-
ɫɹ, ɬ. ɟ. ɞɥɹ ɪɚɡɪɚɛɨɬɱɢɤɨɜ ɞɪɭɝɢɯ ɤɨɦɩɨɧɟɧ-
ɬɨɜ. ȼ ɫɟɤɰɢɹɯ Private ɢ Protected
«ɫɤɪɵɜɚɸɬɫɹ» ɞɟɬɚɥɢ ɪɟɚɥɢɡɚɰɢɢ
Public Ɉɛɳɢɟ Ɉɛɴɟɤɬɵ ɞɚɧɧɨɝɨ ɭɪɨɜɧɹ ɜɢɞɢɦɵ ɜɟɡɞɟ, ɝɞɟ
ɜɨɡɦɨɠɧɚ ɫɫɵɥɤɚ ɧɚ ɤɥɚɫɫ
Published Ɉɩɭɛɥɢɤɨ- ɇɟɬ ɧɢɤɚɤɢɯ ɨɝɪɚɧɢɱɟɧɢɣ ɩɨ ɞɨɫɬɭɩɭ.
ɜɚɧɧɵɟ ɋɜɨɣɫɬɜɚ ɩɨɩɚɞɚɸɬ ɜ ɂɧɫɩɟɤɬɨɪ Ɉɛɴɟɤɬɨɜ
ɜɨ ɜɪɟɦɹ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ. Ʉɥɚɫɫ ɞɨɥɠɟɧ
ɩɪɨɢɫɯɨɞɢɬɶ ɨɬ TComponent

ɉɨɪɨɠɞɟɧɧɵɣ ɤɥɚɫɫ ɦɨɠɟɬ ɩɟɪɟɦɟɫɬɢɬɶ ɫɜɨɣɫɬɜɚ ɜ ɪɚɡɞɟɥ ɫ ɦɟɧɶ-

ɲɢɦɢ ɨɝɪɚɧɢɱɟɧɢɹɦɢ (protected – ɜ public ɢɥɢ ɜ published,
public – ɜ published), ɧɨ ɧɟ ɦɨɠɟɬ ɩɟɪɟɦɟɫɬɢɬɶ ɫɜɨɣɫɬɜɨ ɜ ɪɚɡɞɟɥ ɫ
ɛɨɥɶɲɢɦɢ ɨɝɪɚɧɢɱɟɧɢɹɦɢ ɜ ɞɨɫɬɭɩɟ.
Ɉɛɳɟɩɪɢɧɹɬɨ (ɬɚɤ ɫɥɟɞɭɟɬ ɢɡ ɩɪɢɧɰɢɩɚ ɢɧɤɚɩɫɭɥɹɰɢɢ), ɱɬɨ ɜ ɫɟɤɰɢɢ
private ɪɚɫɩɨɥɚɝɚɸɬɫɹ ɨɛɴɹɜɥɟɧɢɹ ɩɨɥɟɣ ɤɥɚɫɫɚ; ɜ ɫɟɤɰɢɢ protected –
ɦɟɬɨɞɵ ɱɬɟɧɢɹ-ɡɚɩɢɫɢ ɡɧɚɱɟɧɢɣ ɫɜɨɣɫɬɜ, ɨɛɴɹɜɥɟɧɢɹ ɧɟɨɩɭɛɥɢɤɨɜɚɧɧɵɯ
ɫɜɨɣɫɬɜ; ɜ ɫɟɤɰɢɢ public – ɦɟɬɨɞɵ, ɜ ɬɨɦ ɱɢɫɥɟ ɤɨɧɫɬɪɭɤɬɨɪɵ ɢ ɞɟɫɬɪɭɤ-
ɬɨɪɵ, ɢ ɫɜɨɣɫɬɜɚ, ɞɨɫɬɭɩɧɵɟ ɜɨ ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ; ɜ ɫɟɤɰɢɢ published –
ɨɩɭɛɥɢɤɨɜɚɧɧɵɟ ɫɜɨɣɫɬɜɚ.

9
 ɉɪɟɞɩɨɥɨɠɢɦ, ɱɬɨ ɭ ɜɧɨɜɶ ɫɨɡɞɚɧɧɨɝɨ ɤɨɦɩɨɧɟɧɬɚ ɢɦɟɟɬɫɹ ɧɨɜɨɟ
ɫɜɨɣɫɬɜɨ NewProp, ɧɨɜɨɟ ɫɨɛɵɬɢɟ OnNewEvent, ɧɨɜɵɣ ɦɟɬɨɞ New-
Method. Ʉɪɨɦɟ ɬɨɝɨ, ɨɩɭɛɥɢɤɨɜɚɧɵ ɭɧɚɫɥɟɞɨɜɚɧɧɵɟ ɫɜɨɣɫɬɜɚ Height,
Width ɢ ɫɨɛɵɬɢɟ OnClick.
Ɍɨɝɞɚ ɫ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɨɛɥɚɫɬɟɣ ɜɢɞɢɦɨɫɬɢ ɨɛɴɹɜɥɟɧɢɟ ɤɥɚɫɫɚ ɞɥɹ
ɤɨɦɩɨɧɟɧɬɚ ɫɬɪɨɢɬɫɹ ɩɨ ɫɥɟɞɭɸɳɟɣ ɫɯɟɦɟ:

type
TMyComponent = class( <ɉɪɟɞɨɤ> )
private
// ȼɧɭɬɪɟɧɧɢɟ ɩɨɥɹ, ɫɨɞɟɪɠɚɳɢɟ ɡɧɚɱɟɧɢɟ ɧɨɜɨɝɨ ɫɜɨɣɫɬɜɚ
FNewProp : TPropType;
// ȼɧɭɬɪɟɧɧɢɣ ɭɤɚɡɚɬɟɥɶ ɧɚ ɦɟɬɨɞ-ɨɛɪɚɛɨɬɱɢɤ ɫɨɛɵɬɢɹ
FOnNewEvent : TEventType;
protected
// Ɇɟɬɨɞɵ ɱɬɟɧɢɹ-ɡɚɩɢɫɢ ɫɜɨɣɫɬɜɚ
function GetNewProp : TpropType;
procedure SetNewProp(Value : TpropType);
public
// Ʉɨɧɫɬɪɭɤɬɨɪ ɢ ɞɟɫɬɪɭɤɬɨɪ
constructor Create(AOwner : TComponent); override;
destructor Destroy; override;
// ɇɨɜɵɣ ɦɟɬɨɞ
procedure NewMethod;
// Ɇɟɬɨɞ ɞɢɫɩɟɬɱɟɪɢɡɚɰɢɢ ɧɨɜɨɝɨ ɫɨɛɵɬɢɹ OnNewEvent
procedure NewEvent;
published
// Ɉɩɪɟɞɟɥɟɧɢɟ ɧɨɜɨɝɨ ɫɜɨɣɫɬɜɚ
property NewProp : TPropType
read GEtNewProp write SetNewProp;
// Ɉɩɭɛɥɢɤɨɜɚɧɢɟ ɭɧɚɫɥɟɞɨɜɚɧɧɵɯ ɫɜɨɣɫɬɜ,
// ɧɚɯɨɞɢɜɲɢɯɫɹ ɭ ɩɪɟɞɤɚ ɜ ɫɟɤɰɢɢ Protected
property Height;

10
 property Width;
// ɇɨɜɨɟ ɫɨɛɵɬɢɟ
property OnNewEvent : TEventType read FOnNewEvent
write FOnNewEvent;
// Ɉɩɭɛɥɢɤɨɜɚɧɢɟ ɭɧɚɫɥɟɞɨɜɚɧɧɨɝɨ ɫɨɛɵɬɢɹ
property OnClick;
end;
Ⱦɚɥɟɟ ɧɟɨɛɯɨɞɢɦɨ ɧɚɩɢɫɚɬɶ ɤɨɞ ɪɟɚɥɢɡɚɰɢɢ ɧɨɜɵɯ ɦɟɬɨɞɨɜ. ȼ ɫɥɟ-
ɞɭɸɳɢɯ ɪɚɡɞɟɥɚɯ ɫɯɟɦɚ ɤɨɦɩɨɧɟɧɬɚ ɪɚɫɫɦɚɬɪɢɜɚɟɬɫɹ ɛɨɥɟɟ ɩɨɞɪɨɛɧɨ.

2.2. ɋɨɡɞɚɧɢɟ ɫɜɨɣɫɬɜ ɤɨɦɩɨɧɟɧɬɚ

ɋɜɨɣɫɬɜɚ ɩɪɟɞɫɬɚɜɥɹɸɬ ɫɨɛɨɣ ɫɚɦɵɣ ɜɚɠɧɵɣ ɚɫɩɟɤɬ ɥɸɛɨɝɨ ɤɨɦɩɨ-

ɧɟɧɬɚ ɢ ɨɩɪɟɞɟɥɹɸɬ ɝɥɚɜɧɵɣ ɢɧɬɟɪɮɟɣɫ, ɫ ɩɨɦɨɳɶɸ ɤɨɬɨɪɨɝɨ ɩɨɥɶɡɨɜɚ-
ɬɟɥɶ ɦɚɧɢɩɭɥɢɪɭɟɬ ɤɨɦɩɨɧɟɧɬɨɦ ɢ ɧɚɫɬɪɚɢɜɚɟɬ ɟɝɨ ɩɟɪɟɞ ɜɵɩɨɥɧɟɧɢɟɦ
ɩɪɢɥɨɠɟɧɢɹ.
ɋɜɨɣɫɬɜɚ ɢɫɩɨɥɶɡɭɸɬɫɹ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɫɤɪɵɬɶ ɨɬ ɩɨɥɶɡɨɜɚɬɟɥɹ ɞɟ-
ɬɚɥɢ ɪɟɚɥɢɡɚɰɢɢ ɢ ɱɬɨɛɵ ɫɨɡɞɚɬɶ ɷɮɮɟɤɬ ɞɟɣɫɬɜɢɹ ɩɪɢ ɢɡɦɟɧɟɧɢɢ ɡɧɚɱɟ-
ɧɢɹ. ɇɚɩɪɢɦɟɪ, ɢɡɦɟɧɟɧɢɟ ɫɜɨɣɫɬɜɚ Height ɤɨɦɩɨɧɟɧɬɚ TPanel ɧɟ
ɬɨɥɶɤɨ ɢɡɦɟɧɹɟɬ ɡɧɚɱɟɧɢɟ Height, ɧɨ ɢ ɩɪɢɜɨɞɢɬ ɤ ɬɨɦɭ, ɱɬɨ ɤɨɦɩɨɧɟɧɬ
ɩɟɪɟɪɢɫɨɜɵɜɚɟɬ ɫɟɛɹ. ɉɟɪɟɪɢɫɨɜɤɚ ɤɨɦɩɨɧɟɧɬɚ ɹɜɥɹɟɬɫɹ ɬɢɩɢɱɧɵɦ ɷɮɮɟɤ-
ɬɨɦ ɞɟɣɫɬɜɢɹ.
ȼ ɩɪɨɫɬɟɣɲɟɦ ɫɥɭɱɚɟ ɫɜɨɣɫɬɜɨ ɨɩɪɟɞɟɥɹɟɬɫɹ ɫɥɟɞɭɸɳɢɦ ɨɛɪɚɡɨɦ:
property <ɢɦɹ ɫɜɨɣɫɬɜɚ>: <ɬɢɩ ɫɜɨɣɫɬɜɚ> [read <ɦɟɬɨɞ ɱɬɟɧɢɹ
ɫɜɨɣɫɬɜɚ>] [write <ɦɟɬɨɞ ɡɚɩɢɫɢ ɫɜɨɣɫɬɜɚ>].

ɉɪɢɦɟɪ. Ⱦɨɫɬɭɩ ɤ ɩɨɥɸ FField ɬɢɩɚ integer ɪɟɚɥɢɡɭɟɬɫɹ ɱɟɪɟɡ

ɫɜɨɣɫɬɜɨ PField ɬɢɩɚ string. ɉɪɟɨɛɪɚɡɨɜɚɧɢɟ ɬɢɩɨɜ ɩɪɨɢɫɯɨɞɢɬ ɩɪɢ
ɜɵɡɨɜɟ ɦɟɬɨɞɨɜ ɱɬɟɧɢɹ/ɡɚɩɢɫɢ:
interface
type

11
 TMyClass=class(TParentClass)
private
FField: integer; // ɩɨɥɟ
protected
function GetField: string; // ɦɟɬɨɞ
procedure SetField(AValue: string);// ɦɟɬɨɞ
published
property PField: string // ɫɜɨɣɫɬɜɨ
read GetField write SetField;
end;

var MyObj: TMyClass; // ɷɤɡɟɦɩɥɹɪ

implementation

function TMyClass.GetField: string;

begin
Result:=IntToStr(FField);
end;

procedure TMyClass.SetField(AValue: string);

var x,Code: integer;
begin
Val(AValue,x,Code);
// ɩɪɨɜɟɪɤɚ ɤɨɪɪɟɤɬɧɨɫɬɢ ɧɨɜɨɝɨ ɡɧɚɱɟɧɢɹ
if (x<>FField) and (Code=0) then
begin
FField:=x;
//…
// Ⱦɨɩɨɥɧɢɬɟɥɶɧɵɟ ɞɟɣɫɬɜɢɹ, ɟɫɥɢ ɨɧɢ ɧɟɨɛɯɨɞɢɦɵ
end;
end;
end.

12
 ȼ ɞɚɧɧɨɦ ɩɪɢɦɟɪɟ ɞɨɫɬɭɩ ɞɥɹ ɱɬɟɧɢɹ ɩɨɥɹ ɪɟɚɥɢɡɨɜɚɧ ɮɭɧɤɰɢɟɣ
GetField. ȿɫɥɢ ɫɩɟɰɢɚɥɶɧɵɣ ɦɟɬɨɞ ɱɬɟɧɢɹ/ɨɛɧɨɜɥɟɧɢɹ ɧɟ ɬɪɟɛɭɟɬɫɹ, ɬɨ
ɜɦɟɫɬɨ ɢɦɟɧɢ ɦɟɬɨɞɚ ɦɨɠɧɨ ɭɤɚɡɚɬɶ ɢɦɹ ɩɨɥɹ (ɧɨ ɬɨɥɶɤɨ ɜ ɫɥɭɱɚɟ, ɟɫɥɢ
ɬɢɩ ɫɜɨɣɫɬɜɚ ɫɨɜɩɚɞɚɟɬ ɫ ɬɢɩɨɦ ɩɨɥɹ).
ɇɚɩɪɢɦɟɪ,
property PField:string read FField write SetField;

ȿɫɥɢ ɫɜɨɣɫɬɜɨ ɞɨɫɬɭɩɧɨ ɬɨɥɶɤɨ ɞɥɹ ɱɬɟɧɢɹ ɢɥɢ ɞɥɹ ɡɚɩɢɫɢ, ɬɨ ɫɨɨɬ-
ɜɟɬɫɬɜɭɸɳɢɣ ɦɟɬɨɞ ɦɨɠɧɨ ɨɩɭɫɬɢɬɶ.
ɉɨɞɱɟɪɤɧɟɦ, ɱɬɨ ɩɪɢ ɨɛɪɚɳɟɧɢɢ ɤ ɫɜɨɣɫɬɜɭ ɦɟɬɨɞɵ ɱɬɟ-
ɧɢɹ/ɨɛɧɨɜɥɟɧɢɹ ɧɟ ɭɤɚɡɵɜɚɸɬɫɹ. Ⱦɥɹ ɩɨɥɶɡɨɜɚɬɟɥɹ ɨɛɪɚɳɟɧɢɟ ɤ ɫɜɨɣɫɬɜɭ
ɬɚɤɨɟ ɠɟ, ɤɚɤ ɤ ɩɨɥɸ, ɧɚɩɪɢɦɟɪ,
MyObj.PField:=’100’;
…;
s:=MyObj.PField;

ȼɵɡɨɜɵ ɧɟɨɛɯɨɞɢɦɵɯ ɦɟɬɨɞɨɜ ɜɫɬɪɚɢɜɚɸɬɫɹ ɤɨɦɩɢɥɹɬɨɪɨɦ

ɚɜɬɨɦɚɬɢɱɟɫɤɢ.
ɋɜɨɣɫɬɜɨ ɦɨɠɟɬ ɛɵɬɶ ɜɟɤɬɨɪɧɵɦ, ɧɚɩɪɢɦɟɪ,
property Items[Index: integer]: real read
GetItems write SetItems;
ɩɪɢ ɷɬɨɦ ɦɟɬɨɞɵ ɱɬɟɧɢɹ ɢ ɨɛɧɨɜɥɟɧɢɹ ɢɦɟɸɬ ɜɢɞ
function GetItems (Index: integer): real;
procedure SetItems (Index: integer; NewValue: real);

Ⱦɥɹ ɩɪɨɝɪɚɦɦɢɫɬɚ ɬɚɤɨɟ ɫɜɨɣɫɬɜɨ ɜɵɝɥɹɞɢɬ ɤɚɤ ɦɚɫɫɢɜ, ɤ ɷɥɟɦɟɧɬɚɦ

ɤɨɬɨɪɨɝɨ ɦɨɠɧɨ ɨɛɪɚɳɚɬɶɫɹ ɨɛɵɱɧɵɦ ɨɛɪɚɡɨɦ (ɧɚɩɪɢɦɟɪ,
Items[i]:=1.5), ɯɨɬɹ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɟ ɟɦɭ ɩɨɥɟ ɜ ɞɟɣɫɬɜɢɬɟɥɶɧɨɫɬɢ
ɦɨɠɟɬ ɦɚɫɫɢɜɨɦ ɢ ɧɟ ɹɜɥɹɬɶɫɹ. Ɉɞɧɨɦɭ ɢɡ ɜɟɤɬɨɪɧɵɯ ɫɜɨɣɫɬɜ ɦɨɠɧɨ ɩɪɢ-
ɩɢɫɚɬɶ ɚɬɪɢɛɭɬ default, ɬɨɝɞɚ ɩɪɢ ɨɛɪɚɳɟɧɢɢ ɤ ɧɟɦɭ ɢɦɹ ɫɜɨɣɫɬɜɚ ɦɨɠ-

13
ɧɨ ɧɟ ɭɤɚɡɵɜɚɬɶ, ɧɚɩɪɢɦɟɪ MyObject.Items[i]:=1.5 ɛɭɞɟɬ ɷɤɜɢɜɚ-
ɥɟɧɬɧɨ MyObject[i]:=1.5.

2.3. Ɍɢɩɵ ɫɜɨɣɫɬɜ

ȼɨ ɜɪɟɦɹ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɨɩɭɛɥɢɤɨɜɚɧɧɵɟ ɫɜɨɣɫɬɜɚ ɤɨɦɩɨɧɟɧɬɚ ɩɨ-
ɹɜɥɹɸɬɫɹ ɜ ɂɧɫɩɟɤɬɨɪɟ ɨɛɴɟɤɬɨɜ. ɋɩɨɫɨɛɵ ɨɬɨɛɪɚɠɟɧɢɹ ɢ ɪɟɞɚɤɬɢɪɨɜɚɧɢɹ
ɫɜɨɣɫɬɜɚ ɜ ɂɧɫɩɟɤɬɨɪɟ ɨɛɴɟɤɬɨɜ ɡɚɜɢɫɹɬ ɨɬ ɬɢɩɚ ɫɜɨɣɫɬɜɚ.
ȼ Delphi ɫɭɳɟɫɬɜɭɟɬ ɧɟɫɤɨɥɶɤɨ ɫɬɚɧɞɚɪɬɧɵɯ ɪɟɞɚɤɬɨɪɨɜ ɫɜɨɣɫɬɜ. Ɋɟ-
ɞɚɤɬɨɪɵ ɫɜɨɣɫɬɜ ɨɩɪɟɞɟɥɹɸɬ ɮɭɧɤɰɢɨɧɢɪɨɜɚɧɢɟ ɩɪɚɜɨɣ ɱɚɫɬɢ ɫɬɪɚɧɢɰɵ
Property ɜ ɂɧɫɩɟɤɬɨɪɟ ɨɛɴɟɤɬɨɜ. ɇɚɢɛɨɥɟɟ ɪɚɫɩɪɨɫɬɪɚɧɟɧɧɵɟ ɪɟɞɚɤɬɨɪɵ
ɨɩɢɫɚɧɵ ɜ ɬɚɛɥɢɰɟ 3.

Ɋɟɞɚɤɬɨɪɵ ɫɜɨɣɫɬɜ, ɞɨɫɬɭɩɧɵɟ ɜ ɂɧɫɩɟɤɬɨɪɟ ɨɛɴɟɤɬɨɜ Ɍɚɛɥɢɰɚ 3

Ɍɢɩ ɫɜɨɣɫɬɜɚ Ɉɩɢɫɚɧɢɟ ɪɟɞɚɤɬɨɪɚ ɫɜɨɣɫɬɜ ɉɪɢɦɟɪ
ɉɪɨɫɬɨɣ ɉɪɨɫɬɵɟ ɡɧɚɱɟɧɢɹ ɫɜɨɣɫɬɜ, ɬɚɤɢɟ ɤɚɤ ɱɢɫɥɚ, Height
ɫɬɪɨɤɢ ɢ ɬɨɦɭ ɩɨɞɨɛɧɨɟ, ɪɟɞɚɤɬɢɪɭɸɬɫɹ
ɩɪɹɦɨ ɜ ɫɬɪɨɤɟ ɫɜɨɣɫɬɜɚ
ɉɟɪɟɱɢɫɥɢ- ȼɫɟ ɩɟɪɟɱɢɫɥɢɦɵɟ ɡɧɚɱɟɧɢɹ, ɨɩɪɟɞɟɥɟɧɧɵɟ Color
ɦɵɣ ɞɥɹ ɬɢɩɚ, ɨɬɨɛɪɚɠɚɸɬɫɹ ɜ ɨɤɧɟ ɤɨɦɛɢɧɢɪɨ-
ɜɚɧɧɨɝɨ ɫɩɢɫɤɚ. Ɂɧɚɱɟɧɢɹ ɜ ɩɟɪɟɱɢɫɥɟɧɢɢ
ɦɨɠɧɨ ɩɟɪɟɛɢɪɚɬɶ, ɞɜɚɠɞɵ ɳɟɥɤɚɹ ɜ ɫɬɪɨɤɟ
ɫɜɨɣɫɬɜɚ
Ɇɧɨɠɟɫɬɜɨ ȼ ɫɬɪɨɤɟ ɫɜɨɣɫɬɜɚ ɬɢɩɵ ɦɧɨɠɟɫɬɜ ɩɨɹɜɥɹ- Anchors
ɸɬɫɹ ɤɚɤ ɦɧɨɠɟɫɬɜɚ Pascal. Ʉɚɠɞɵɣ ɷɥɟɦɟɧɬ
ɦɧɨɠɟɫɬɜɚ ɩɪɟɞɫɬɚɜɥɟɧ ɜ ɂɧɫɩɟɤɬɨɪɟ ɨɛɴ-
ɟɤɬɨɜ ɨɬɞɟɥɶɧɵɦ ɫɜɨɣɫɬɜɨɦ, ɩɪɢɧɢɦɚɸɳɢɦ
ɡɧɚɱɟɧɢɹ True ɢ False
Ɉɛɴɟɤɬ ɇɚɡɜɚɧɢɟ ɬɢɩɚ ɩɨɹɜɥɹɟɬɫɹ ɜ ɫɬɪɨɤɟ ɫɜɨɣɫɬɜɚ Font
ɜ ɂɧɫɩɟɤɬɨɪɟ ɨɛɴɟɤɬɨɜ. ȿɫɥɢ ɨɛɴɟɤɬ ɢɦɟɟɬ

14
 ɩɭɛɥɢɤɭɟɦɵɟ ɫɜɨɣɫɬɜɚ, ɬɨ ɫɜɨɣɫɬɜɨ ɨɛɴɟɤɬɚ
ɜ ɂɧɫɩɟɤɬɨɪɟ ɪɚɫɲɢɪɹɟɬɫɹ ɢ ɩɨɹɜɥɹɟɬɫɹ
ɜɨɡɦɨɠɧɨɫɬɶ ɨɬɪɟɞɚɤɬɢɪɨɜɚɬɶ ɤɚɠɞɨɟ ɩɨɞ-
ɫɜɨɣɫɬɜɨ (ɧɚɩɪɢɦɟɪ, ɧɚɡɜɚɧɢɟ ɲɪɢɮɬɚ)

ɉɨɞɱɟɪɤɧɟɦ, ɟɫɥɢ ɫɨɡɞɚɧɧɵɟ ɜ ɜɚɲɟɦ ɤɨɦɩɨɧɟɧɬɟ ɫɜɨɣɫɬɜɚ ɢɦɟɸɬ

ɬɢɩɵ, ɩɟɪɟɱɢɫɥɟɧɧɵɟ ɜ ɬɚɛɥɢɰɟ, ɬɨ ɩɪɢɥɚɝɚɬɶ ɞɨɩɨɥɧɢɬɟɥɶɧɵɟ ɭɫɢɥɢɹ ɢ
ɫɨɡɞɚɜɚɬɶ ɪɟɞɚɤɬɨɪɵ ɫɜɨɣɫɬɜ ɧɟɬ ɨɫɨɛɨɣ ɧɟɨɛɯɨɞɢɦɨɫɬɢ, Delphi ɜɫɟ ɫɞɟɥɚ-
ɟɬ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ. ȼ ɱɚɫɬɧɨɫɬɢ, ɫɬɚɧɞɚɪɬɧɵɟ ɪɟɞɚɤɬɨɪɵ ɜɵɡɵɜɚɸɬɫɹ ɩɪɢ
ɩɨɩɵɬɤɟ ɪɟɞɚɤɬɢɪɨɜɚɧɢɹ ɫɜɨɣɫɬɜ ɬɢɩɨɜ TFont, TStrings, TPicture ɢ
ɧɟɤɨɬɨɪɵɯ ɞɪɭɝɢɯ. ȼ ɛɨɥɟɟ ɫɥɨɠɧɵɯ ɫɥɭɱɚɹɯ, ɧɚɩɪɢɦɟɪ, ɩɪɢ ɫɨɡɞɚɧɢɢ ɜɟɤ-
ɬɨɪɧɵɯ ɫɜɨɣɫɬɜ, ɫɥɟɞɭɟɬ ɪɚɡɪɚɛɚɬɵɜɚɬɶ ɫɨɛɫɬɜɟɧɧɵɟ ɪɟɞɚɤɬɨɪɵ ɫɜɨɣɫɬɜ,
ɢɧɚɱɟ ɫɜɨɣɫɬɜɨ ɧɟ ɫɦɨɠɟɬ ɛɵɬɶ ɨɬɨɛɪɚɠɟɧɨ ɜ ɂɧɫɩɟɤɬɨɪɟ ɨɛɴɟɤɬɨɜ.
ɋɬɚɧɞɚɪɬɧɵɟ ɪɟɞɚɤɬɨɪɵ ɫɜɨɣɫɬɜ ɜɵɩɨɥɧɟɧɵ ɜ ɜɢɞɟ ɤɥɚɫɫɨɜ. ɂɧɬɟɪ-
ɮɟɣɫɵ ɤ ɤɥɚɫɫɚɦ ɧɚɯɨɞɹɬɫɹ ɜ ɦɨɞɭɥɟ Dsgnintf.pas (ɫɦ. ɤɚɬɚɥɨɝ
..\Delphi7\Source\ToolsApi). ɂɡɭɱɟɧɢɟ ɷɬɨɝɨ ɦɨɞɭɥɹ – ɧɟɨɛɯɨɞɢɦɵɣ ɷɬɚɩ
ɩɪɢ ɧɚɩɢɫɚɧɢɢ ɫɨɛɫɬɜɟɧɧɵɯ ɪɟɞɚɤɬɨɪɨɜ ɫɜɨɣɫɬɜ.
Ȼɚɡɨɜɵɦ ɹɜɥɹɟɬɫɹ ɤɥɚɫɫ TPropertyEditor. ȿɝɨ ɩɨɬɨɦɤɚɦɢ ɹɜɥɹ-
ɸɬɫɹ ɬɢɩɢɡɢɪɨɜɚɧɧɵɟ ɤɥɚɫɫɵ TIntegerProperty, TColorProperty,
TCharProperty, TSetProperty, TFloatProperty,
TstringProperty, TFontNameProperty, TCaptionProperty,
Tfont-Property ɢ ɞɪ. ɇɚɡɧɚɱɟɧɢɹ ɤɥɚɫɫɨɜ ɫɨɨɬɜɟɬɫɬɜɭɸɬ ɧɚɡɜɚɧɢɸ.
Ʉɥɚɫɫ TFloatProperty ɫɜɹɡɚɧ ɫɨ ɫɜɨɣɫɬɜɚɦɢ, ɤɨɬɨɪɵɟ ɢɦɟɸɬ ɬɢɩ
Float, ɤɥɚɫɫ TFontProperty ɫɜɹɡɚɧ ɫɨ ɫɜɨɣɫɬɜɚɦɢ, ɤɨɬɨɪɵɟ ɢɦɟɸɬ ɬɢɩ
TFont ɢ ɬ. ɩ.
Ⱦɥɹ ɫɨɡɞɚɧɢɹ ɧɨɜɨɝɨ ɪɟɞɚɤɬɨɪɚ ɫɜɨɣɫɬɜ ɧɟɨɛɯɨɞɢɦɨ ɜɵɛɪɚɬɶ ɜ ɤɚɱɟ-
ɫɬɜɟ ɩɪɟɞɤɚ ɥɢɛɨ ɨɞɢɧ ɢɡ ɬɢɩɢɡɢɪɨɜɚɧɧɵɯ ɤɥɚɫɫɨɜ, ɥɢɛɨ, ɟɫɥɢ ɩɨɞɯɨɞɹɳɟ-

15
ɝɨ ɤɥɚɫɫɚ ɧɟɬ, ɜɵɛɪɚɬɶ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ TPropertyEditor ɢ ɩɟɪɟɨɩɪɟ-
ɞɟɥɢɬɶ ɧɟɤɨɬɨɪɵɟ ɟɝɨ ɦɟɬɨɞɵ. Ȼɨɥɟɟ ɩɨɞɪɨɛɧɭɸ ɢɧɮɨɪɦɚɰɢɸ ɫɦ. ɜ [3, 5].

2.4. Ɇɟɬɨɞɵ
ɉɨɫɤɨɥɶɤɭ ɦɟɬɨɞɵ ɞɨɫɬɭɩɧɵ ɩɨɥɶɡɨɜɚɬɟɥɹɦ ɜɨ ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ
ɤɨɦɩɨɧɟɧɬ, ɜɚɠɧɨ ɩɪɚɜɢɥɶɧɨ ɢɯ ɢɦɟɧɨɜɚɬɶ. ɂɦɟɧɚ ɦɟɬɨɞɨɜ ɞɨɥɠɧɵ ɛɵɬɶ
ɨɩɢɫɚɬɟɥɶɧɵɦɢ ɢ ɢɫɩɨɥɶɡɨɜɚɬɶ ɚɤɬɢɜɧɵɟ ɝɥɚɝɨɥɵ. ɉɨɞɨɛɧɵɦ ɠɟ ɨɛɪɚɡɨɦ
ɢɦɟɧɚ ɮɭɧɤɰɢɣ ɞɨɥɠɧɵ ɭɤɚɡɵɜɚɬɶ ɧɚ ɬɨ, ɱɬɨ ɨɧɢ ɜɨɡɜɪɚɳɚɸɬ. ȼɨɬ ɧɟ-
ɫɤɨɥɶɤɨ ɩɪɢɦɟɪɨɜ ɩɨɞɯɨɞɹɳɢɯ ɢ ɧɟɩɨɞɯɨɞɹɳɢɯ ɢɦɟɧ ɦɟɬɨɞɨɜ [2]:
ɉɨɞɯɨɞɹɳɢɟ ɇɟɩɨɞɯɨɞɹɳɢɟ
Procedure CutToClipboard procedure Cut
Procedure SetHeight procedure SetH
function GetTextLen function Len

Ɇɟɬɨɞɵ ɦɨɝɭɬ ɪɚɡɦɟɳɚɬɶɫɹ ɜ ɪɚɡɞɟɥɚɯ public, protected ɢɥɢ

private ɨɛɴɹɜɥɟɧɢɹ ɤɨɦɩɨɧɟɧɬɚ. Ɋɟɲɟɧɢɟ ɨ ɬɨɦ, ɝɞɟ ɫɥɟɞɭɟɬ ɪɚɡɦɟɫɬɢɬɶ
ɤɨɧɤɪɟɬɧɵɣ ɦɟɬɨɞ, ɡɚɜɢɫɢɬ ɨɬ ɬɨɝɨ, ɤɚɤ ɨɧ ɛɭɞɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ. Ɇɟɬɨɞɵ,
ɞɨɫɬɭɩɧɵɟ ɩɨɥɶɡɨɜɚɬɟɥɸ ɜɨ ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ, ɞɨɥɠɧɵ ɪɚɡɦɟɳɚɬɶɫɹ ɜ
ɪɚɡɞɟɥɟ public (ɨɛɳɟɞɨɫɬɭɩɧɵɣ). ɋɩɟɰɢɮɢɱɟɫɤɢɟ, ɡɚɜɢɫɹɳɢɟ ɨɬ ɪɟɚɥɢɡɚ-
ɰɢɢ ɦɟɬɨɞɵ ɞɨɥɠɧɵ ɪɚɡɦɟɳɚɬɶɫɹ, ɩɨ ɦɟɧɶɲɟɣ ɦɟɪɟ, ɜ ɪɚɡɞɟɥɟ protected
(ɡɚɳɢɳɟɧɧɵɣ). ȼ ɷɬɨɦ ɫɥɭɱɚɟ ɩɨɥɶɡɨɜɚɬɟɥɶ ɤɨɦɩɨɧɟɧɬɚ ɧɟ ɫɦɨɠɟɬ ɫɥɭɱɚɣ-
ɧɨ ɜɵɩɨɥɧɢɬɶ ɦɟɬɨɞɵ, ɡɚɜɢɫɹɳɢɟ ɨɬ ɪɟɚɥɢɡɚɰɢɢ. Ɇɟɬɨɞɵ, ɤɨɬɨɪɵɟ ɞɨɥɠɧɵ
ɛɵɬɶ ɞɨɫɬɭɩɧɵ ɜ ɩɨɪɨɠɞɟɧɧɵɯ ɤɥɚɫɫɚɯ, ɫɥɟɞɭɟɬ ɪɚɫɩɨɥɚɝɚɬɶ ɜ ɪɚɡɞɟɥɟ
protected.
Ɂɚɦɟɱɚɧɢɟ. Ɇɟɬɨɞɵ, ɨɛɴɹɜɥɟɧɧɵɟ ɭ ɩɪɟɞɤɚ ɫ ɚɬɪɢɛɭɬɚɦɢ virtual,
dynamic ɢɥɢ abstract, ɫɥɟɞɭɟɬ ɩɟɪɟɨɩɪɟɞɟɥɹɬɶ ɫ ɚɬɪɢɛɭɬɨɦ
override.
ȼɫɟ ɤɨɦɩɨɧɟɧɬɵ Delphi ɞɨɥɠɧɵ ɢɦɟɬɶ ɦɟɬɨɞ-ɤɨɧɫɬɪɭɤɬɨɪ, ɢɫɩɨɥɶ-
ɡɭɟɦɵɣ ɞɥɹ ɫɨɡɞɚɧɢɹ ɷɤɡɟɦɩɥɹɪɚ ɤɥɚɫɫɚ ɢ ɢɦɟɸɳɢɣ ɫɥɟɞɭɸɳɢɣ ɜɢɞ:
constructor Create(AOwner : TComponent); override;

16
 Ʉɨɧɟɱɧɨ, ɧɟ ɤɚɠɞɵɣ ɤɨɦɩɨɧɟɧɬɧɵɣ ɤɥɚɫɫ ɧɭɠɞɚɟɬɫɹ ɜ ɨɩɪɟɞɟɥɟɧɢɢ
ɧɨɜɨɝɨ ɤɨɧɫɬɪɭɤɬɨɪɚ. Ɇɨɠɧɨ ɭɧɚɫɥɟɞɨɜɚɬɶ ɤɨɧɫɬɪɭɤɬɨɪ ɨɬ ɩɪɟɞɤɚ. ȼ ɥɸɛɨɦ
ɫɥɭɱɚɟ, ɤɨɧɫɬɪɭɤɬɨɪ ɫɨɞɟɪɠɢɬ ɩɚɪɚɦɟɬɪ ɬɢɩɚ TComponent, ɭɤɚɡɵɜɚɸɳɢɣ
ɧɚ ɜɥɚɞɟɥɶɰɚ (Owner) ɤɨɦɩɨɧɟɧɬɚ. ȼɥɚɞɟɥɟɰ – ɷɬɨ ɤɨɦɩɨɧɟɧɬ, ɜɵɡɵɜɚɸɳɢɣ
ɩɪɢ ɫɜɨɟɦ ɭɧɢɱɬɨɠɟɧɢɢ ɞɟɫɬɪɭɤɬɨɪɵ ɩɨɞɱɢɧɟɧɧɵɯ ɤɨɦɩɨɧɟɧɬɨɜ.
Ⱦɥɹ ɤɨɦɩɨɧɟɧɬɨɜ ɤɨɧɫɬɪɭɤɬɨɪ Create – ɷɬɨ ɢ ɟɫɬɶ ɦɟɫɬɨ, ɝɞɟ ɭɫɬɚ-
ɧɚɜɥɢɜɚɸɬɫɹ ɡɧɚɱɟɧɢɹ ɫɜɨɣɫɬɜ ɩɨ ɭɦɨɥɱɚɧɢɸ. ɇɚɩɪɢɦɟɪ:
constructor TSampleControl.Create = class(TWinControl)
begin
inherited Create(AOwner) ;
FHeight := 25; {ɍɫɬɚɧɨɜɤɚ ɡɧɚɱɟɧɢɣ ɩɨ ɭɦɨɥɱɚɧɢɸ}
FWidth := 50;
FColor := clWindows;
end;

ɇɟɨɛɯɨɞɢɦɨ ɩɨɫɥɟ ɨɛɴɹɜɥɟɧɢɹ ɤɨɧɫɬɪɭɤɬɨɪɚ ɡɚɞɚɬɶ ɞɢɪɟɤɬɢɜɭ

override. ɉɪɨɩɭɫɤ ɷɬɨɣ ɞɢɪɟɤɬɢɜɵ ɫɢɧɬɚɤɫɢɱɟɫɤɢ ɡɚɤɨɧɟɧ, ɧɨ ɟɫɥɢ ɬɚɤ
ɫɞɟɥɚɬɶ, ɬɨ ɤɨɦɩɨɧɟɧɬ ɧɟɥɶɡɹ ɛɭɞɟɬ ɩɨɦɟɫɬɢɬɶ ɧɚ ɮɨɪɦɭ.
Ɉɬɦɟɬɢɦ, ɱɬɨ ɜ ɩɟɪɟɨɩɪɟɞɟɥɟɧɧɨɦ ɤɨɧɫɬɪɭɤɬɨɪɟ ɩɟɪɜɵɦ ɞɨɥɠɟɧ ɜɵ-
ɡɵɜɚɬɶɫɹ ɤɨɧɫɬɪɭɤɬɨɪ ɩɪɟɞɤɚ, ɫɧɚɛɠɟɧɧɵɣ ɤɥɸɱɟɜɵɦ ɫɥɨɜɨɦ inherited
(ɭɧɚɫɥɟɞɨɜɚɧɧɵɣ), ɞɚɥɟɟ ɡɚɩɢɫɵɜɚɸɬɫɹ ɨɩɟɪɚɰɢɢ, ɫɩɟɰɢɮɢɱɧɵɟ ɞɥɹ ɞɚɧɧɨ-
ɝɨ ɤɨɦɩɨɧɟɧɬɚ.
ȿɫɥɢ ɭɞɚɥɟɧɢɟ ɤɨɦɩɨɧɟɧɬɚ ɢɡ ɩɚɦɹɬɢ ɞɨɥɠɧɨ ɫɨɩɪɨɜɨɠɞɚɬɶɫɹ ɞɨ-
ɩɨɥɧɢɬɟɥɶɧɵɦɢ ɞɟɣɫɬɜɢɹɦɢ, ɬɨ ɜ ɤɨɦɩɨɧɟɧɬɟ ɞɨɥɠɟɧ ɛɵɬɶ ɩɟɪɟɨɩɪɟɞɟɥɟɧ
ɞɟɫɬɪɭɤɬɨɪ:
destructor Destroy; override;

ȼ ɞɟɫɬɪɭɤɬɨɪɟ, ɭɧɢɱɬɨɠɚɸɳɟɦ ɷɤɡɟɦɩɥɹɪ ɤɨɦɩɨɧɟɧɬɚ, ɩɨɪɹɞɨɤ ɞɟɣ-

ɫɬɜɢɣ ɨɛɪɚɬɧɵɣ:
destructor TSampleControl.Destroy;
begin

17
 // ɡɚɜɟɪɲɚɸɳɢɟ ɨɩɟɪɚɰɢɢ,
// ɨɫɜɨɛɨɠɞɟɧɢɟ ɩɚɦɹɬɢ,
// ɜɵɡɨɜ ɞɟɫɬɪɭɤɬɨɪɨɜ ɨɛɴɟɤɬɨɜ, ɫɨɡɞɚɧɧɵɯ
// ɜ ɫɨɫɬɚɜɟ ɤɨɦɩɨɧɟɧɬɚ ɢ ɬ.ɩ.
…
// ɩɨɫɥɟɞɧɢɦ ɜɵɡɵɜɚɟɬɫɹ ɭɧɚɫɥɟɞɨɜɚɧɧɵɣ ɞɟɫɬɪɭɤɬɨɪ
inherited Destroy;
end;

ɇɚ ɩɪɚɤɬɢɤɟ ɜɦɟɫɬɨ Destroy ɨɛɵɱɧɨ ɜɵɡɵɜɚɸɬ ɦɟɬɨɞ Free, ɭɧɚɫ-

ɥɟɞɨɜɚɧɧɵɣ ɨɬ TObject. Ɇɟɬɨɞ Free ɛɟɡɨɩɚɫɧɟɟ, ɬɚɤ ɤɚɤ ɩɟɪɟɞ ɜɵɡɨɜɨɦ
ɞɟɫɬɪɭɤɬɨɪɚ ɨɧ ɩɪɨɜɟɪɹɟɬ ɧɚɥɢɱɢɟ ɤɨɦɩɨɧɟɧɬɚ ɜ ɩɚɦɹɬɢ:
if Self<>nil then Destroy;

2.5. ɋɨɛɵɬɢɹ
ɋɨɛɵɬɢɟ ɤɨɦɩɨɧɟɧɬɚ – ɷɬɨ ɟɝɨ ɫɜɨɣɫɬɜɨ ɩɪɨɰɟɞɭɪɧɨɝɨ ɬɢɩɚ, ɩɪɟɞɧɚ-
ɡɧɚɱɟɧɧɨɟ ɞɥɹ ɫɨɡɞɚɧɢɹ ɪɟɚɤɰɢɢ ɤɨɦɩɨɧɟɧɬɚ ɧɚ ɬɟ ɢɥɢ ɢɧɵɟ ɜɧɟɲɧɢɟ ɜɨɡ-
ɞɟɣɫɬɜɢɹ (ɫɨ ɫɬɨɪɨɧɵ ɩɨɥɶɡɨɜɚɬɟɥɹ, ɚɩɩɚɪɚɬɭɪɵ ɢɥɢ ɞɪɭɝɢɯ ɩɪɨɝɪɚɦɦ).
Ɍɚɤɨɦɭ ɫɜɨɣɫɬɜɭ ɧɟɨɛɯɨɞɢɦɨ ɩɪɢɫɜɨɢɬɶ ɚɞɪɟɫ ɦɟɬɨɞɚ, ɤɨɬɨɪɵɣ ɛɭɞɟɬ ɜɵ-
ɡɵɜɚɬɶɫɹ ɜ ɦɨɦɟɧɬ ɧɚɫɬɭɩɥɟɧɢɹ ɫɨɛɵɬɢɹ ɫ ɞɚɧɧɵɦ ɤɨɦɩɨɧɟɧɬɨɦ.
ɋɨɛɵɬɢɹ ɢɦɟɸɬ ɪɚɡɥɢɱɧɨɟ ɱɢɫɥɨ ɩɚɪɚɦɟɬɪɨɜ. ȼ ɩɪɨɫɬɟɣɲɟɦ ɫɥɭɱɚɟ
ɩɚɪɚɦɟɬɪ ɨɞɢɧ – Sender ɬɢɩɚ TObject, ɭɤɚɡɵɜɚɸɳɢɣ ɧɚ ɨɛɴɟɤɬ-
ɢɫɬɨɱɧɢɤ ɫɨɛɵɬɢɹ. ɋɨɨɬɜɟɬɫɬɜɭɸɳɢɟ ɫɨɛɵɬɢɹ, ɧɚɩɪɢɦɟɪ ɫɨɛɵɬɢɹ On-
Click ɢ OnDblClick, ɢɦɟɸɬ ɬɢɩ
type TNotifyEvent = procedure (Sender: TObject) of object;

ȼ ɨɩɢɫɚɧɢɟ ɩɪɨɰɟɞɭɪɧɨɝɨ ɬɢɩɚ ɞɥɹ ɦɟɬɨɞɚ ɧɟɨɛɯɨɞɢɦɨ ɞɨɛɚɜɥɹɬɶ

ɡɚɪɟɡɟɪɜɢɪɨɜɚɧɧɵɟ ɫɥɨɜɚ of object. Ɉɛɵɱɧɵɣ ɩɪɨɰɟɞɭɪɧɵɣ ɬɢɩ ɢ ɩɪɨ-
ɰɟɞɭɪɧɵɣ ɬɢɩ ɞɥɹ ɦɟɬɨɞɚ ɧɟɫɨɜɦɟɫɬɢɦɵ, ɬɚɤ ɤɚɤ ɜ ɦɟɬɨɞ, ɤɪɨɦɟ ɨɩɢɫɚɧ-
ɧɵɯ ɩɚɪɚɦɟɬɪɨɜ, ɧɟɹɜɧɨ ɩɟɪɟɞɚɟɬɫɹ ɩɚɪɚɦɟɬɪ Self – ɭɤɚɡɚɬɟɥɶ ɧɚ ɜɵɡɜɚɜ-

18
ɲɢɣ ɟɝɨ ɨɛɴɟɤɬ. ɉɨɷɬɨɦɭ ɫɨɛɵɬɢɸ ɦɨɠɧɨ ɩɪɢɫɜɚɢɜɚɬɶ ɬɨɥɶɤɨ ɦɟɬɨɞɵ
ɤɥɚɫɫɚ, ɫɨɜɦɟɫɬɢɦɵɟ ɩɨ ɱɢɫɥɭ ɢ ɬɢɩɭ ɩɚɪɚɦɟɬɪɨɜ.
Ɍɢɩ TNotifyEvent ɢɦɟɟɬ, ɜ ɱɚɫɬɧɨɫɬɢ, ɫɨɛɵɬɢɟ ɳɟɥɱɤɚ ɦɵɲɶɸ ɧɚ
ɤɨɦɩɨɧɟɧɬɟ.
ȼ ɞɪɭɝɢɯ ɫɨɛɵɬɢɹɯ ɦɨɝɭɬ ɩɪɢɫɭɬɫɬɜɨɜɚɬɶ ɞɨɩɨɥɧɢɬɟɥɶɧɵɟ ɩɚɪɚɦɟɬ-
ɪɵ, ɧɚɩɪɢɦɟɪ, ɞɥɹ ɫɨɛɵɬɢɹ ɩɟɪɟɦɟɳɟɧɢɹ ɭɤɚɡɚɬɟɥɹ ɦɵɲɢ OnMouseMove
ɨɩɢɫɚɧɢɟ ɬɢɩɚ ɫɨɛɵɬɢɹ ɢɦɟɟɬ ɜɢɞ
type TMouseMoveEvent = procedure(Sender: TObject; Shift:
TShiftState; X, Y: Integer) of object;

ɝɞɟ ɩɚɪɚɦɟɬɪ Shift ɩɨɡɜɨɥɹɟɬ ɭɡɧɚɬɶ, ɛɵɥɢ ɥɢ ɧɚɠɚɬɵ ɩɪɢ ɩɟɪɟɦɟ-

ɳɟɧɢɢ ɭɤɚɡɚɬɟɥɹ ɭɩɪɚɜɥɹɸɳɢɟ ɤɥɚɜɢɲɢ ɢɥɢ ɤɧɨɩɤɢ ɦɵɲɢ; ɩɚɪɚɦɟɬɪɵ X ɢ
Y ɫɨɞɟɪɠɚɬ ɧɨɜɵɟ ɤɨɨɪɞɢɧɚɬɵ ɭɤɚɡɚɬɟɥɹ ɦɵɲɢ ɜ ɤɥɢɟɧɬɫɤɨɣ ɨɛɥɚɫɬɢ ɨɛɴ-
ɟɤɬɚ Sender.
ɋɨɛɵɬɢɹ ɧɚɠɚɬɢɹ/ɨɬɩɭɫɤɚɧɢɹ ɤɧɨɩɤɢ ɦɵɲɢ OnMouse-
Down/OnMouseUp ɢɦɟɸɬ ɬɢɩ
type
TMouseEvent = procedure(Sender: TObject;
Button: TMouseButton; Shift: TShiftState;
X, Y: Integer) of object;

ɝɞɟ Button: TMouseButton – ɢɞɟɧɬɢɮɢɤɚɬɨɪ ɤɧɨɩɤɢ,

TMouseButton = (mbLeft, mbRight, mbMiddle).

ɇɚɠɚɬɢɟ ɢ ɨɬɩɭɫɤɚɧɢɟ ɤɥɚɜɢɲ ɤɥɚɜɢɚɬɭɪɵ OnKeyDown:

type TKeyEvent = procedure(Sender: TObject;
var Key: Word; Shift: TShiftState) of object;
ɝɞɟ Key – ɜɢɪɬɭɚɥɶɧɵɣ ɤɨɞ Windows ɧɚɠɚɬɨɣ ɤɥɚɜɢɲɢ.
Cɨɛɵɬɢɟ OnKeyPressed ɜɨɡɧɢɤɚɟɬ ɩɪɢ ɜɜɨɞɟ ɫ ɤɥɚɜɢɚɬɭɪɵ ɫɢɦɜɨ-
ɥɚ ASCII. Ɂɞɟɫɶ Key – ASCII-ɤɨɞ ɧɚɠɚɬɨɣ ɤɥɚɜɢɲɢ ɢ ɢɦɟɟɬ ɬɢɩ

19
 type
TKeyPressEvent = procedure(Sender: TObject;
var Key: Char) of object;
Ɂɚɦɟɬɢɦ, ɱɬɨ ɫɨɨɛɳɟɧɢɹ ɨɬ ɤɥɚɜɢɚɬɭɪɵ ɩɨɫɬɭɩɚɸɬ ɬɨɦɭ ɷɥɟɦɟɧɬɭ,
ɤɨɬɨɪɵɣ ɜ ɞɚɧɧɵɣ ɦɨɦɟɧɬ ɢɦɟɥ ɮɨɤɭɫ ɜɜɨɞɚ. ȿɫɥɢ ɭ ɮɨɪɦɵ, ɜɥɚɞɟɸɳɟɣ
ɷɥɟɦɟɧɬɨɦ ɭɩɪɚɜɥɟɧɢɹ, ɭɫɬɚɧɨɜɢɬɶ ɡɧɚɱɟɧɢɟ ɫɜɨɣɫɬɜɚ KeyPreview ɜ
True, ɬɨ ɫɨɛɵɬɢɹ ɛɭɞɭɬ ɫɧɚɱɚɥɚ ɨɛɪɚɛɨɬɚɧɵ ɮɨɪɦɨɣ.
ɉɟɪɟɱɟɧɶ ɬɢɩɨɜ ɫɬɚɧɞɚɪɬɧɵɯ ɫɨɛɵɬɢɣ ɫɦ. ɜ ɮɚɣɥɟ controls.pas ɜ
ɤɚɬɚɥɨɝɟ ..\Delphi7\Source\VCL.
ɋɨɜɦɟɫɬɢɦɵɟ ɫɨɛɵɬɢɹ ɦɨɠɧɨ ɩɪɢɫɜɚɢɜɚɬɶ ɜɨ ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ ɩɪɨ-
ɝɪɚɦɦɵ, ɧɚɩɪɢɦɟɪ,
Button1.OnMouseMove:=Button2.OnMouseMove;
…
Button1.OnClick:=Form1.OnPaint;
…
Edit1.OnChange:=Button1Click;

ȼ ɪɟɡɭɥɶɬɚɬɟ ɨɞɢɧ ɨɛɴɟɤɬ ɛɭɞɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɨɛɪɚɛɨɬɱɢɤɢ ɫɨɜɦɟɫ-

ɬɢɦɨɝɨ ɫɨɛɵɬɢɹ ɞɪɭɝɨɝɨ ɨɛɴɟɤɬɚ. ɗɬɚ ɜɨɡɦɨɠɧɨɫɬɶ ɧɚɡɵɜɚɟɬɫɹ
ɞɟɥɟɝɢɪɨɜɚɧɢɟɦ.
ɂɬɚɤ, ɫɨɛɵɬɢɹ ɪɟɚɥɢɡɭɸɬɫɹ ɫ ɩɨɦɨɳɶɸ ɭɤɚɡɚɬɟɥɟɣ ɧɚ ɦɟɬɨɞɵ. Ⱦɥɹ
ɤɚɠɞɨɝɨ ɫɨɛɵɬɢɹ ɨɩɪɟɞɟɥɹɸɬɫɹ ɫɜɨɣɫɬɜɚ. ɗɬɨ ɩɨɡɜɨɥɹɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɂɧ-
ɫɩɟɤɬɨɪ ɨɛɴɟɤɬɨɜ ɞɥɹ ɧɚɡɧɚɱɟɧɢɹ ɫɨɛɵɬɢɹɦ ɨɛɪɚɛɨɬɱɢɤɨɜ ɜɨ ɜɪɟɦɹ ɩɪɨɟɤ-
ɬɢɪɨɜɚɧɢɹ. ɉɨɹɫɧɢɦ ɫɤɚɡɚɧɧɨɟ ɧɚ ɩɪɢɦɟɪɟ.
Ɋɚɫɫɦɨɬɪɢɦ ɫɥɟɞɭɸɳɢɣ ɮɪɚɝɦɟɧɬ ɤɨɞɚ, ɩɨɤɚɡɵɜɚɸɳɢɣ ɧɟɫɤɨɥɶɤɨ
ɫɬɚɧɞɚɪɬɧɵɯ ɫɨɛɵɬɢɣ, ɨɛɴɹɜɥɟɧɧɵɯ ɜ ɤɥɚɫɫɟ TControl:
type
TControl = class(TComponent)
private
FOnClick : TNotifyEvent;
FOnDblClick : TNotifyEvent

20
 FOnMouseDown : TMouseEvent;
FOnMouseMove : TMouseMiveEvent;
…
protected
procedure Click; dynamic;
property OnClick: TNotifyEvent
read FOnClick write FOnClick;
property OnDblClick : TNotifyEvent
read FOnDblClick write OnDblClick;
property OnMouseDown : TMouseEvent
read FOnMouseDown write FOnMouseDown;
property OnMouseMove : TMouseMoveEvent
read FOnMouseMove write FOnMouseMove;
…

end;

ɋɨɛɵɬɢɹ ɫɨɫɬɨɹɬ ɢɡ ɞɜɭɯ ɱɚɫɬɟɣ. ȼɨ-ɩɟɪɜɵɯ, ɞɥɹ ɫɨɛɵɬɢɹ ɬɪɟɛɭɟɬɫɹ

ɜɧɭɬɪɟɧɧɟɟ ɩɨɥɟ ɞɚɧɧɵɯ (ɧɚɩɪɢɦɟɪ FOnClick), ɤɨɬɨɪɨɟ ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ
ɯɪɚɧɟɧɢɹ ɭɤɚɡɚɬɟɥɹ ɧɚ ɦɟɬɨɞ. ȼɨ-ɜɬɨɪɵɯ, ɫɨɡɞɚɟɬɫɹ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɟ ɫɜɨɣ-
ɫɬɜɨ (ɧɚɩɪɢɦɟɪ OnClick), ɤɨɬɨɪɨɟ ɜɨ ɜɪɟɦɹ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɩɪɟɞɨɫɬɚɜɥɹ-
ɟɬ ɜɨɡɦɨɠɧɨɫɬɶ ɩɪɢɫɨɟɞɢɧɟɧɢɹ ɨɛɪɚɛɨɬɱɢɤɨɜ ɫɨɛɵɬɢɣ.
ɋɨɛɵɬɢɹ, ɨɛɳɢɟ ɞɥɹ ɜɫɟɯ ɤɨɦɩɨɧɟɧɬɨɜ: OnClick, OnDblClick,
OnMouseDown, OnMouseMove, OnMouseUp, OnDragOver,
OnDragDrop, OnEndDrag.
ɋɨɛɵɬɢɹ ɨɤɨɧɧɵɯ ɷɥɟɦɟɧɬɨɜ ɭɩɪɚɜɥɟɧɢɹ: OnEnter, OnExit, On-
KeyDown, OnKeyUp, OnKeyPress.
ɉɨ ɭɦɨɥɱɚɧɢɸ ɜɫɟ ɞɚɧɧɵɟ ɫɨɛɵɬɢɹ ɜ ɤɥɚɫɫɟ TComponent ɨɛɴɹɜɥɟ-
ɧɵ ɜ ɫɟɤɰɢɢ protected. ɋɥɟɞɨɜɚɬɟɥɶɧɨ, ɫɬɚɧɞɚɪɬɧɵɟ ɫɨɛɵɬɢɹ ɧɟ ɜɢɞɧɵ
ɩɨɥɶɡɨɜɚɬɟɥɹɦ ɤɨɦɩɨɧɟɧɬɚ ɢ ɞɨɥɠɧɵ ɛɵɬɶ ɩɨɜɬɨɪɧɨ ɨɛɴɹɜɥɟɧɵ (ɨɩɭɛɥɢ-
ɤɨɜɚɧɵ) ɜ ɫɟɤɰɢɢ published.
type

21
 TEdit=class(TCustomEdit)
private
…
published
property OnClick;
end;
Ɍɚɤ ɤɚɤ ɫɨɛɵɬɢɹ Delphi ɨɯɜɚɬɵɜɚɸɬ ɛɨɥɶɲɭɸ ɱɚɫɬɶ ɫɨɨɛɳɟɧɢɣ Win-
dows, ɬɨ ɪɚɡɪɚɛɨɬɱɢɤɭ ɧɨɜɨɝɨ ɤɨɦɩɨɧɟɧɬɚ, ɤɚɤ ɩɪɚɜɢɥɨ, ɛɵɜɚɟɬ ɞɨɫɬɚɬɨɱɧɨ
ɨɩɭɛɥɢɤɨɜɚɬɶ ɜ ɫɜɨɟɦ ɤɨɦɩɨɧɟɧɬɟ ɫɨɛɵɬɢɹ ɩɪɟɞɤɚ.
ȼ ɛɨɥɟɟ ɫɥɨɠɧɨɣ ɫɢɬɭɚɰɢɢ, ɤɨɝɞɚ ɢɦɟɸɳɢɯɫɹ ɫɬɚɧɞɚɪɬɧɵɯ ɫɨɛɵɬɢɣ
ɧɟɞɨɫɬɚɬɨɱɧɨ, ɦɨɠɧɨ ɨɩɪɟɞɟɥɢɬɶ ɧɨɜɵɟ ɫɨɛɵɬɢɹ. Ɇɟɬɨɞɢɤɚ ɦɨɠɟɬ ɨɬɥɢ-
ɱɚɬɶɫɹ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɡɚɞɚɱɢ. Ɉɛɵɱɧɨ ɜ ɞɨɩɨɥɧɟɧɢɟ ɤ ɨɛɴɹɜɥɟɧɢɸ ɩɨɥɹ
ɢ ɫɜɨɣɫɬɜɚ ɞɥɹ ɫɨɛɵɬɢɹ ɜɜɨɞɹɬ ɦɟɬɨɞɵ ɞɢɫɩɟɬɱɟɪɢɡɚɰɢɢ ɫɨɛɵɬɢɣ (event-
dispatching methods). ɗɬɢ ɦɟɬɨɞɵ ɧɭɠɧɵ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɨɩɪɟɞɟɥɢɬɶ, ɫɨɡ-
ɞɚɧ ɥɢ ɤɨɞ ɨɛɪɚɛɨɬɤɢ ɩɪɨɢɡɨɲɟɞɲɟɝɨ ɫɨɛɵɬɢɹ ɞɥɹ ɞɚɧɧɨɝɨ ɤɨɦɩɨɧɟɧɬɚ, ɢ
ɬɨɝɞɚ ɨɛɴɹɜɥɹɸɬɫɹ ɤɚɤ ɡɚɳɢɳɟɧɧɵɟ (protected). ȼ ɤɥɚɫɫɟ TControl
ɛɢɛɥɢɨɬɟɤɢ VCL ɞɥɹ ɫɜɨɣɫɬɜɚ OnClick ɨɩɪɟɞɟɥɟɧ ɦɟɬɨɞ ɞɢɫɩɟɬɱɟɪɢɡɚ-
ɰɢɢ ɫ ɧɚɡɜɚɧɢɟɦ Click:
type
TControl = class (TComponent)
private
FOnClick: TNotifyEvent;
protected
procedure Click; dynamic;
property OnClick: TNotifyEvent
read FOnClick write FOnClick;
end;

implementation
procedure TControl.Click;
begin

22
 if Assigned (FOnClick) then FOnClick (Self);
end;

Ɇɟɬɨɞ Click ɩɪɟɞɧɚɡɧɚɱɟɧ ɞɥɹ ɜɵɡɨɜɚ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɨɝɨ ɨɛɪɚɛɨɬ-

ɱɢɤɚ ɫɨɛɵɬɢɹ, ɟɫɥɢ ɨɧ ɭɤɚɡɚɧ ɜ ɩɪɨɝɪɚɦɦɟ. Ɋɚɡɭɦɟɟɬɫɹ, Click ɬɚɤɠɟ ɞɨɥ-
ɠɟɧ ɛɵɬɶ ɝɞɟ-ɬɨ ɜɵɡɜɚɧ. ȼ ɫɥɭɱɚɟ TControl ɦɟɬɨɞ Click ɜɵɡɵɜɚɟɬɫɹ
ɜɧɭɬɪɢ ɨɛɪɚɛɨɬɱɢɤɚ Windows-ɫɨɨɛɳɟɧɢɹ WM_MOUSEDOWN. ɇɨ ɦɨɝɭɬ ɛɵɬɶ ɢ
ɞɪɭɝɢɟ ɜɚɪɢɚɧɬɵ. Ȼɨɥɟɟ ɩɨɞɪɨɛɧɭɸ ɢɧɮɨɪɦɚɰɢɸ ɦɨɠɧɨ ɩɨɥɭɱɢɬɶ ɩɪɢ ɢɡɭ-
ɱɟɧɢɢ ɦɨɞɭɥɹ Controls.pas ɛɢɛɥɢɨɬɟɤɢ VCL (ɝɞɟ ɨɩɢɫɚɧ ɤɥɚɫɫ
TControl), ɚ ɬɚɤɠɟ ɜ [1–4].

3. ɉɪɨɟɤɬɢɪɨɜɚɧɢɟ ɤɨɦɩɨɧɟɧɬɚ

3.1. ɗɬɚɩɵ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ

Ɋɚɫɫɦɨɬɪɢɦ ɩɪɨɰɟɫɫ ɫɨɡɞɚɧɢɹ ɤɨɦɩɨɧɟɧɬɚ ɧɚ ɨɱɟɧɶ ɩɪɨɫɬɨɦ ɩɪɢɦɟɪɟ

ɫɨɡɞɚɧɢɹ ɩɨɬɨɦɤɚ ɤɨɦɩɨɧɟɧɬɚ Button (Ʉɧɨɩɤɚ) [2].
ɉɪɨɰɟɫɫ, ɨɩɢɫɚɧɧɵɣ ɞɚɥɟɟ, ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɥɹ ɪɚɡɪɚɛɨɬɤɢ ɥɸ-
ɛɨɝɨ ɤɨɦɩɨɧɟɧɬɚ Delphi, ɧɟɡɚɜɢɫɢɦɨ ɨɬ ɟɝɨ ɫɥɨɠɧɨɫɬɢ.
1. ɉɪɨɰɟɫɫ ɧɚɱɢɧɚɟɬɫɹ ɫ ɫɨɡɞɚɧɢɹ ɤɚɬɚɥɨɝɚ, ɜ ɤɨɬɨɪɵɣ ɛɭɞɟɬ ɡɚɩɢɫɚɧ
ɦɨɞɭɥɶ ɤɨɦɩɨɧɟɧɬɚ ɢ ɬɟɫɬɨɜɨɟ ɩɪɢɥɨɠɟɧɢɟ. Ʉɨɦɩɨɧɟɧɬɵ ɫɬɪɨɹɬɫɹ ɜɧɭɬɪɢ
ɦɨɞɭɥɟɣ Delphi ɫɩɨɫɨɛɨɦ, ɨɱɟɧɶ ɩɨɯɨɠɢɦ ɧɚ ɦɨɞɭɥɢ ɮɨɪɦ Delphi ɫ ɨɛɴɹɜ-
ɥɟɧɢɟɦ ɤɥɚɫɫɚ ɞɥɹ ɤɨɦɩɨɧɟɧɬɚ, ɩɨɹɜɥɹɸɳɢɦɫɹ ɜ ɪɚɡɞɟɥɟ ɢɧɬɟɪɮɟɣɫɚ ɢ ɨɩ-
ɪɟɞɟɥɟɧɢɟɦ ɦɟɬɨɞɨɜ, ɤɨɬɨɪɵɟ ɩɨɹɜɥɹɸɬɫɹ ɜ ɪɚɡɞɟɥɟ ɪɟɚɥɢɡɚɰɢɢ.
2. ɋɥɟɞɭɸɳɢɣ ɲɚɝ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɫɨɡɞɚɧɢɢ ɦɨɞɭɥɹ ɤɨɦɩɨɧɟɧɬɚ. ɗɬɨ
ɦɨɠɧɨ ɜɵɩɨɥɧɢɬɶ ɥɢɛɨ ɜɪɭɱɧɭɸ, ɥɢɛɨ ɡɚɞɟɣɫɬɜɨɜɚɜ ɗɤɫɩɟɪɬɚ ɤɨɦɩɨɧɟɧ-
ɬɨɜ (Component Expert).
3. ɉɨɫɥɟ ɬɨɝɨ ɤɚɤ ɨɩɪɟɞɟɥɟɧɵ ɛɚɡɨɜɵɟ ɷɥɟɦɟɧɬɵ ɦɨɞɭɥɹ, ɜɵɩɨɥɧɹɟɬɫɹ
ɫɥɟɞɭɸɳɢɣ ɲɚɝ, ɡɚɤɥɸɱɚɸɳɢɣɫɹ ɜ ɨɛɴɹɜɥɟɧɢɢ ɤɥɚɫɫɚ ɢ ɧɚɩɢɫɚɧɢɢ ɩɨɞ-
ɞɟɪɠɢɜɚɸɳɢɯ ɦɟɬɨɞɨɜ.

23
 4. Ⱦɚɥɟɟ ɤɨɦɩɨɧɟɧɬ ɦɨɠɧɨ ɬɟɫɬɢɪɨɜɚɬɶ. Ɍɚɤ ɤɚɤ ɭ ɤɨɦɩɨɧɟɧɬɚ ɟɫɬɶ ɞɜɚ
ɢɧɬɟɪɮɟɣɫɚ – ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ ɢ ɜɪɟɦɟɧɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ, ɬɨ ɢ ɬɟɫɬɢ-
ɪɨɜɚɧɢɟ ɜɵɩɨɥɧɹɟɬɫɹ ɜ ɞɜɚ ɲɚɝɚ. Ɍɟɫɬɢɪɨɜɚɧɢɟ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ ɦɨɠ-
ɧɨ ɞɟɥɚɬɶ ɫɪɚɡɭ ɠɟ ɩɨɫɥɟ ɨɤɨɧɱɚɧɢɹ ɤɨɞɢɪɨɜɚɧɢɹ, ɧɨ ɬɟɫɬɢɪɨɜɚɧɢɟ ɜɪɟɦɟ-
ɧɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɦɨɠɧɨ ɩɪɨɜɨɞɢɬɶ ɬɨɥɶɤɨ ɩɨɫɥɟ ɬɨɝɨ, ɤɚɤ ɤɨɦɩɨɧɟɧɬ
ɛɭɞɟɬ ɡɚɪɟɝɢɫɬɪɢɪɨɜɚɧ ɜ Delphi ɢ ɩɨɹɜɢɬɫɹ ɧɚ ɩɚɥɢɬɪɟ ɤɨɦɩɨɧɟɧɬɨɜ.
Ɋɚɫɫɦɨɬɪɢɦ ɩɟɪɟɱɢɫɥɟɧɧɵɟ ɲɚɝɢ ɛɨɥɟɟ ɩɨɞɪɨɛɧɨ.
ɉɨɧɚɱɚɥɭ ɤɚɬɚɥɨɝ ɛɭɞɟɬ ɫɨɞɟɪɠɚɬɶ ɨɞɢɧ ɮɚɣɥ ɦɨɞɭɥɹ ɤɨɦɩɨɧɟɧɬɚ, ɧɨ
ɧɚ ɫɬɚɞɢɢ ɬɟɫɬɢɪɨɜɚɧɢɹ ɜ ɤɚɬɚɥɨɝɟ ɩɨɹɜɹɬɫɹ ɜɫɟ ɮɚɣɥɵ, ɚɫɫɨɰɢɢɪɭɸɳɢɟɫɹ
ɫ ɨɬɞɟɥɶɧɵɦ ɩɪɨɟɤɬɨɦ Delphi.
ɂɫɯɨɞɧɵɣ ɤɨɞ ɤɨɦɩɨɧɟɧɬɚ ɪɚɫɩɨɥɚɝɚɟɬɫɹ ɜ ɦɨɞɭɥɟ. ɏɨɬɹ ɜɨɡɦɨɠɧɨ
ɩɨɦɟɫɬɢɬɶ ɜ ɟɞɢɧɫɬɜɟɧɧɵɣ ɦɨɞɭɥɶ ɥɸɛɨɟ ɤɨɥɢɱɟɫɬɜɨ ɤɨɦɩɨɧɟɧɬɨɜ, ɨɛɵɱɧɨ
ɜ ɦɨɞɭɥɶ ɩɨɦɟɳɚɸɬɫɹ ɬɨɥɶɤɨ ɷɥɟɦɟɧɬɵ ɭɩɪɚɜɥɟɧɢɹ, ɛɥɢɡɤɢɟ ɩɨ ɫɦɵɫɥɭ.
ɋɭɳɟɫɬɜɭɟɬ ɞɜɚ ɫɩɨɫɨɛɚ ɫɨɡɞɚɧɢɹ ɦɨɞɭɥɹ ɤɨɦɩɨɧɟɧɬɚ – «ɪɭɱɧɨɣ» ɢ ɫ
ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɷɤɫɩɟɪɬɚ ɤɨɦɩɨɧɟɧɬɨɜ.
ɗɤɫɩɟɪɬ ɤɨɦɩɨɧɟɧɬɨɜ ɭɩɪɨɳɚɟɬ ɡɚɞɚɱɭ ɫɨɡɞɚɧɢɹ ɦɨɞɭɥɹ ɤɨɦɩɨɧɟɧɬɚ.
Ɉɧ ɝɟɧɟɪɢɪɭɟɬ ɫɢɧɬɚɤɫɢɱɟɫɤɢ ɤɨɪɪɟɤɬɧɵɣ ɦɨɞɭɥɶ Delphi, ɫɨɞɟɪɠɚɳɢɣ ɛɚ-
ɡɨɜɭɸ ɪɟɚɥɢɡɚɰɢɸ ɤɨɦɩɨɧɟɧɬɚ. Ɉɧ ɬɚɤɠɟ ɫɨɡɞɚɟɬ «ɡɚɝɥɭɲɤɢ», ɜɤɥɸɱɚɸ-
ɳɢɟ ɩɭɫɬɨɟ ɨɛɴɹɜɥɟɧɢɟ ɤɥɚɫɫɚ ɢ ɩɪɨɰɟɞɭɪɭ Register, ɚ ɬɚɤɠɟ ɡɚɩɨɥɧɟɧɧɵɣ
ɪɚɡɞɟɥ uses ɦɨɞɭɥɹ ɤɨɦɩɨɧɟɧɬɚ. ɗɤɫɩɟɪɬ ɧɟ ɝɟɧɟɪɢɪɭɟɬ ɧɢɤɚɤɨɣ ɮɭɧɤ-
ɰɢɨɧɚɥɶɧɨɫɬɢ, ɨɛɟɫɩɟɱɢɜɚɹ ɬɨɥɶɤɨ ɤɚɪɤɚɫ ɢɥɢ ɮɭɧɞɚɦɟɧɬ, ɧɚ ɤɨɬɨɪɨɦ
ɫɬɪɨɢɬɫɹ ɤɨɦɩɨɧɟɧɬ.
ɂɦɹ, ɤɨɬɨɪɨɟ ɛɭɞɟɬ ɜɵɛɪɚɧɨ ɞɥɹ ɤɥɚɫɫɚ ɤɨɦɩɨɧɟɧɬɚ, ɛɭɞɟɬ ɩɪɟɞɩɢɫɵ-
ɜɚɬɶ ɫɩɨɫɨɛ ɨɛɪɚɳɟɧɢɹ ɤ ɧɟɦɭ ɜ ɫɪɟɞɟ Delphi. ȿɫɥɢ ɢɦɹ ɤɥɚɫɫɚ ɧɚɱɢɧɚɟɬɫɹ ɫ
Ɍ, ɬɨ Delphi ɭɛɢɪɚɟɬ ɩɟɪɜɵɣ ɫɢɦɜɨɥ ɢ ɢɫɩɨɥɶɡɭɟɬ ɨɫɬɚɜɲɭɸɫɹ ɫɬɪɨɤɭ ɤɚɤ ɢɦɹ
ɤɨɦɩɨɧɟɧɬɚ. ȿɫɥɢ ɢɦɹ ɤɥɚɫɫɚ ɧɟ ɧɚɱɢɧɚɟɬɫɹ ɫ Ɍ, ɬɨ ɢɫɩɨɥɶɡɭɟɬɫɹ ɜɫɟ ɢɦɹ. Ɋɟ-
ɡɭɥɶɬɢɪɭɸɳɟɟ ɢɦɹ ɨɬɨɛɪɚɠɚɟɬɫɹ ɜ ɜɢɞɟ ɩɨɞɫɤɚɡɤɢ, ɟɫɥɢ ɩɨɡɢɰɢɨɧɢɪɨɜɚɬɶ
ɤɭɪɫɨɪ ɧɚɞ ɤɨɦɩɨɧɟɧɬɨɦ ɜ ɩɚɥɢɬɪɟ ɤɨɦɩɨɧɟɧɬɨɜ. Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ Delphi ɦɨɝ-
ɥɚ ɭɫɬɚɧɨɜɢɬɶ ɤɨɦɩɨɧɟɧɬ, ɟɝɨ ɢɦɹ ɞɨɥɠɧɨ ɛɵɬɶ ɭɧɢɤɚɥɶɧɵɦ.
24
 ȼ ɞɨɩɨɥɧɟɧɢɟ ɤ ɜɵɛɨɪɭ ɢɦɟɧɢ ɤɨɦɩɨɧɟɧɬɚ ɧɟɨɛɯɨɞɢɦɨ ɜɵɛɪɚɬɶ ɢ
ɢɦɹ ɞɥɹ ɮɚɣɥɚ ɦɨɞɭɥɹ. ȼɨ ɢɡɛɟɠɚɧɢɟ ɧɟɨɞɧɨɡɧɚɱɧɨɫɬɢ ɥɭɱɲɟ ɜɫɟɝɨ ɢɦɟɬɶ
ɭɧɢɤɚɥɶɧɵɟ ɢɦɟɧɚ ɮɚɣɥɨɜ. ɇɚɩɪɢɦɟɪ, ɧɟɪɚɡɭɦɧɨ ɞɥɹ ɤɨɦɩɨɧɟɧɬɚ, ɜɵɛɪɚɧ-
ɧɨɝɨ ɞɥɹ ɩɪɢɦɟɪɚ, ɢɫɩɨɥɶɡɨɜɚɬɶ ɢɦɹ ɦɨɞɭɥɹ Button, ɬɚɤ ɤɚɤ ɜ Delphi ɦɨ-
ɞɭɥɶ ɫ ɬɚɤɢɦ ɢɦɟɧɟɦ ɭɠɟ ɟɫɬɶ. ɉɨɞɞɟɪɠɚɧɢɟ ɢɦɟɧ ɮɚɣɥɨɜ ɦɨɞɭɥɟɣ ɭɧɢ-
ɤɚɥɶɧɵɦɢ ɨɫɨɛɟɧɧɨ ɜɚɠɧɨ ɬɨɝɞɚ, ɤɨɝɞɚ ɭɫɬɚɧɚɜɥɢɜɚɟɬɫɹ ɦɧɨɝɨ ɤɨɦɩɨɧɟɧ-
ɬɨɜ ɢɡ ɪɚɡɧɵɯ ɢɫɬɨɱɧɢɤɨɜ.
ɋɥɟɞɭɹ ɭɩɨɦɹɧɭɬɵɦ ɜɵɲɟ ɫɨɝɥɚɲɟɧɢɹɦ, ɧɚɡɨɜɺɦ ɤɥɚɫɫ ɫɨɡɞɚɜɚɟɦɨɝɨ
ɤɨɦɩɨɧɟɧɬɚ TMyButton. Ɉɛɴɹɜɥɟɧɢɟ ɤɥɚɫɫɚ – ɷɬɨ ɬɨ ɦɟɫɬɨ, ɝɞɟ ɨɛɴɹɜɥɹɸɬ-
ɫɹ ɪɚɡɥɢɱɧɵɟ ɢɧɬɟɪɮɟɣɫɵ ɤɨɦɩɨɧɟɧɬɚ. Ʉɨɧɤɪɟɬɧɨ, ɫ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɨɣ ɬɨɱ-
ɤɢ ɡɪɟɧɢɹ, ɧɚɢɛɨɥɟɟ ɜɚɠɧɵɦɢ ɹɜɥɹɸɬɫɹ ɪɚɡɞɟɥɵ public ɢ published,
ɩɨɫɤɨɥɶɤɭ ɢɦɟɧɧɨ ɨɧɢ ɨɩɪɟɞɟɥɹɸɬ ɢɧɬɟɪɮɟɣɫɵ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ
(runtime) ɢ ɜɪɟɦɟɧɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ (design-time) ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ.
ɋɜɨɣɫɬɜɚ, ɦɟɬɨɞɵ ɢ ɫɨɛɵɬɢɹ, ɨɛɴɹɜɥɟɧɧɵɟ ɜ ɪɚɡɞɟɥɟ public, ɫɨ-
ɫɬɚɜɥɹɸɬ ɢɧɬɟɪɮɟɣɫ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ. ɇɚ ɷɬɢ ɷɥɟɦɟɧɬɵ ɦɨɠɧɨ ɫɨ-
ɫɥɚɬɶɫɹ ɢɥɢ ɢɯ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɬɨɥɶɤɨ ɬɨɝɞɚ, ɤɨɝɞɚ ɩɪɢɥɨɠɟɧɢɟ, ɢɫ-
ɩɨɥɶɡɭɸɳɟɟ ɤɨɦɩɨɧɟɧɬ, ɜɵɩɨɥɧɹɟɬɫɹ. ɋɜɨɣɫɬɜɚ ɢ ɫɨɛɵɬɢɹ, ɨɛɴɹɜɥɟɧɧɵɟ ɜ
ɪɚɡɞɟɥɟ published, ɬɚɤɠɟ ɞɨɫɬɭɩɧɵ ɜɨ ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ, ɧɨ ɛɨɥɟɟ ɜɚɠ-
ɧɨ ɬɨ, ɱɬɨ ɨɧɢ ɞɨɫɬɭɩɧɵ ɜ ɂɧɫɩɟɤɬɨɪɟ ɨɛɴɟɤɬɨɜ ɜɨ ɜɪɟɦɹ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ.
ɗɤɫɩɟɪɬ ɤɨɦɩɨɧɟɧɬɨɜ ɧɟ ɡɚɩɨɥɧɹɟɬ ɜɫɟɯ ɪɚɡɞɟɥɨɜ ɝɟɧɟɪɢɪɭɟɦɨɝɨ
ɤɥɚɫɫɚ ɤɨɦɩɨɧɟɧɬɚ. Ɉɧ ɨɝɪɚɧɢɱɢɜɚɟɬɫɹ ɨɛɴɹɜɥɟɧɢɟɦ ɱɟɬɵɪɟɯ ɪɚɡɥɢɱɧɵɯ
ɪɚɡɞɟɥɨɜ.

3.2. ɋɨɡɞɚɧɢɟ ɮɚɣɥɚ ɦɨɞɭɥɹ

ɗɤɫɩɟɪɬ ɤɨɦɩɨɧɟɧɬɨɜ ɹɜɥɹɟɬɫɹ ɩɨɥɟɡɧɵɦ ɢɧɫɬɪɭɦɟɧɬɨɦ ɩɪɢ ɫɨɡɞɚ-
ɧɢɢ ɦɨɞɭɥɟɣ ɧɨɜɵɯ ɤɨɦɩɨɧɟɧɬɨɜ. ɇɚ ɪɢɫ. 2 ɩɪɟɞɫɬɚɜɥɟɧɨ ɞɢɚɥɨɝɨɜɨɟ ɨɤɧɨ
ɗɤɫɩɟɪɬɚ ɤɨɦɩɨɧɟɧɬɨɜ, ɨɬɨɛɪɚɠɚɟɦɨɟ ɩɪɢ ɜɵɛɨɪɟ ɩɭɧɤɬɚ ɦɟɧɸ
File|New|Other|Component ɢɥɢ Component|New Component.

ɗɤɫɩɟɪɬ ɤɨɦɩɨɧɟɧɬɨɜ ɬɪɟɛɭɟɬ ɜɜɟɫɬɢ ɫɥɟɞɭɸɳɭɸ ɢɧɮɨɪɦɚɰɢɸ:

25
 – ɢɦɹ ɤɥɚɫɫɚ-ɩɪɟɞɤɚ, ɨɬ ɤɨɬɨɪɨɝɨ ɛɭɞɟɬ ɩɨɪɨɠɞɟɧ ɧɨɜɵɣ ɤɨɦɩɨɧɟɧɬ;
– ɢɦɹ ɤɥɚɫɫɚ ɧɨɜɨɝɨ ɤɨɦɩɨɧɟɧɬɚ;
– ɢɦɹ ɫɬɪɚɧɢɰɵ ɩɚɥɢɬɪɵ ɤɨɦɩɨɧɟɧɬɨɜ;
– ɢɦɹ ɦɨɞɭɥɹ ɤɨɦɩɨɧɟɧɬɚ. ȿɫɥɢ ɤɚɬɚɥɨɝ ɦɨɞɭɥɹ ɧɟ ɫɨɞɟɪɠɢɬɫɹ ɜ
Search path, ɨɧ ɛɭɞɟɬ ɬɭɞɚ ɞɨɛɚɜɥɟɧ;
– ɩɭɬɢ ɞɥɹ ɩɨɢɫɤɚ ɮɚɣɥɨɜ.

Ɋɢɫ. 2. Ⱦɢɚɥɨɝɨɜɨɟ ɨɤɧɨ ɗɤɫɩɟɪɬɚ ɤɨɦɩɨɧɟɧɬɨɜ

ɉɪɟɠɞɟ ɜɫɟɝɨ, ɜɜɟɞɢɬɟ ɢɦɹ ɞɥɹ ɤɥɚɫɫɚ ɤɨɦɩɨɧɟɧɬɚ. ȼɫɩɨɦɧɢɬɟ, ɱɬɨ

ɢɦɟɧɚ ɤɥɚɫɫɨɜ ɤɨɦɩɨɧɟɧɬɨɜ ɞɨɥɠɧɵ ɛɵɬɶ ɭɧɢɤɚɥɶɧɵɦɢ ɢ ɱɬɨ ɗɤɫɩɟɪɬ ɤɨɦ-
ɩɨɧɟɧɬɨɜ ɧɟ ɪɚɡɪɟɲɢɬ ɜɜɟɫɬɢ ɢɦɹ ɤɥɚɫɫɚ, ɤɨɬɨɪɨɟ ɭɠɟ ɡɚɪɟɝɢɫɬɪɢɪɨɜɚɧɨ ɜ
Delphi. ɉɨɫɥɟ ɜɜɨɞɚ ɢɦɟɧɢ, ɤɨɬɨɪɨɟ ɛɭɞɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɞɥɹ ɤɥɚɫɫɚ ɤɨɦ-
ɩɨɧɟɧɬɚ, ɞɨɥɠɟɧ ɛɵɬɶ ɜɵɛɪɚɧ ɤɥɚɫɫ-ɩɪɟɞɨɤ. Ʌɢɛɨ ɧɚɛɟɪɢɬɟ ɢɦɹ ɤɥɚɫɫɚ, ɢɡ
ɤɨɬɨɪɨɝɨ ɯɨɬɢɬɟ ɩɨɪɨɞɢɬɶ ɧɨɜɵɣ ɤɨɦɩɨɧɟɧɬ, ɥɢɛɨ ɜɵɛɟɪɢɬɟ ɟɝɨ ɢɡ ɪɚɫɤɪɵ-
ɜɚɸɳɟɝɨɫɹ ɫɩɢɫɤɚ. ɋɩɢɫɨɤ ɫɨɞɟɪɠɢɬ ɜɫɟ ɤɨɦɩɨɧɟɧɬɵ, ɡɚɪɟɝɢɫɬɪɢɪɨɜɚɧɧɵɟ
ɜ ɧɚɫɬɨɹɳɢɣ ɦɨɦɟɧɬ ɜ Delphi, ɢ ɜɵɛɨɪ ɢɦɟɧɢ ɢɡ ɫɩɢɫɤɚ ɨɛɵɱɧɨ ɛɟɡɨɩɚɫɧɟɟ,
ɱɟɦ ɜɜɨɞ ɟɝɨ ɜɪɭɱɧɭɸ, ɩɨɫɤɨɥɶɤɭ ɜɵ ɫɦɨɠɟɬɟ ɢɡɛɟɠɚɬɶ ɨɩɟɱɚɬɨɤ.
ɋɥɟɞɭɸɳɢɣ ɲɚɝ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɜɵɛɨɪɟ ɫɬɪɚɧɢɰɵ ɩɚɥɢɬɪɵ ɤɨɦɩɨɧɟɧ-
ɬɨɜ, ɝɞɟ ɩɨɹɜɢɬɫɹ ɧɨɜɵɣ ɤɨɦɩɨɧɟɧɬ ɩɨɫɥɟ ɪɟɝɢɫɬɪɚɰɢɢ ɟɝɨ ɜ Delphi. Ɋɚɫ-

26
ɤɪɵɜɚɸɳɢɣɫɹ ɫɩɢɫɨɤ ɫɨɞɟɪɠɢɬ ɜɫɟ ɢɦɟɸɳɢɟɫɹ ɜ ɩɚɥɢɬɪɟ ɫɬɪɚɧɢɰɵ. ȿɫɥɢ
ɠɟ ɜɵ ɯɨɬɢɬɟ ɫɨɡɞɚɬɶ ɧɨɜɭɸ ɫɬɪɚɧɢɰɭ, ɬɨ ɩɪɨɫɬɨ ɜɜɟɞɢɬɟ ɜ ɩɨɥɟ ɟɟ ɢɦɹ.
ɑɟɬɜɺɪɬɚɹ ɫɬɪɨɤɚ ɫɨɞɟɪɠɢɬ ɩɨɥɧɨɟ ɢɦɹ ɦɨɞɭɥɹ ɨɛɴɹɜɥɹɟɦɨɝɨ ɤɥɚɫɫɚ.
ɉɨɫɥɟɞɧɹɹ ɫɬɪɨɤɚ ɨɩɪɟɞɟɥɹɟɬ ɦɚɪɲɪɭɬɵ ɞɥɹ ɩɨɢɫɤɚ ɮɚɣɥɚ. ȿɫɥɢ
ɜɜɟɞɟɧɧɵɣ ɜ ɩɪɟɞɵɞɭɳɟɣ ɫɬɪɨɤɟ ɩɭɬɶ ɧɟ ɫɨɞɟɪɠɢɬɫɹ ɜ Search Path, ɬɨ ɨɧ
ɛɭɞɟɬ ɬɭɞɚ ɞɨɛɚɜɥɟɧ.
ɉɨɫɥɟ ɜɜɨɞɚ ɜɫɟɯ ɞɚɧɧɵɯ ɧɚɠɦɢɬɟ ɤɧɨɩɤɭ ɈɄ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɪɟɞ-
ɩɢɫɚɬɶ Delphi ɫɨɡɞɚɬɶ ɧɨɜɵɣ ɦɨɞɭɥɶ. (Ʉɧɨɩɤɭ Install ɧɚɠɢɦɚɬɶ ɧɟ ɫɥɟɞɭɟɬ!)
Ⱦɥɹ ɬɟɯ ɡɧɚɱɟɧɢɣ, ɤɨɬɨɪɵɟ ɭɤɚɡɚɧɵ ɧɚ ɪɢɫ. 2, ɗɤɫɩɟɪɬ ɤɨɦɩɨɧɟɧɬɨɜ ɫɝɟɧɟ-
ɪɢɪɭɟɬ ɫɥɟɞɭɸɳɢɣ ɲɚɛɥɨɧ ɤɨɦɩɨɧɟɧɬɚ:

unit UMyButton;
interface
uses Windows, Messages, SysUtils, Classes, Controls,
StdCtrls;
type
TMyButton = class(TButton)
private
{ Private declarations }
protected
{ Protected declarations }
public
{ Public declarations }
published
{ Published declarations }
end;
procedure Register;
implementation
procedure Register;
begin
RegisterComponents('MyPalette', [TMyButton]);
end;
end.
27
 3.3. ɇɚɫɬɪɨɣɤɚ ɤɨɦɩɨɧɟɧɬɚ
ɉɨɫɥɟ ɫɨɡɞɚɧɢɹ ɤɚɪɤɚɫɚ ɞɥɹ ɤɨɦɩɨɧɟɧɬɚ ɫɥɟɞɭɸɳɢɣ ɲɚɝ ɜ ɨɛɳɟɦ
ɩɪɨɰɟɫɫɟ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɧɚɩɢɫɚɧɢɢ ɤɨɞɚ, ɤɨɬɨɪɵɣ ɧɚɫɬɪɨɢɬ ɤɚɪɤɚɫ ɢ, ɬɟɦ
ɫɚɦɵɦ, ɩɨɥɧɨɫɬɶɸ ɨɩɪɟɞɟɥɢɬ ɧɨɜɵɣ ɤɨɦɩɨɧɟɧɬ. ɇɚɩɢɫɚɧɢɟ ɤɨɞɚ ɜɤɥɸɱɚɟɬ
ɨɩɪɟɞɟɥɟɧɢɟ ɫɜɨɣɫɬɜ, ɦɟɬɨɞɨɜ ɢ ɫɨɛɵɬɢɣ ɤɨɦɩɨɧɟɧɬɚ, ɚ ɪɚɜɧɨ ɢ ɪɟɚɥɢɡɚ-
ɰɢɸ ɜɫɩɨɦɨɝɚɬɟɥɶɧɵɯ ɦɟɬɨɞɨɜ ɜ ɪɚɡɞɟɥɟ implementation ɦɨɞɭɥɹ. Ⱦɚɧ-
ɧɚɹ ɱɚɫɬɶ ɩɪɨɰɟɫɫɚ ɲɢɪɨɤɨ ɜɚɪɶɢɪɭɟɬɫɹ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɬɢɩɚ ɫɨɡɞɚɜɚɟɦɨ-
ɝɨ ɤɨɦɩɨɧɟɧɬɚ. ȼɫɟ, ɱɬɨ ɬɪɟɛɭɟɬɫɹ ɞɥɹ ɩɪɨɫɬɨɝɨ ɩɟɪɟɨɩɪɟɞɟɥɟɧɢɹ ɡɧɚɱɟɧɢɣ
ɩɨ ɭɦɨɥɱɚɧɢɸ, ɷɬɨ ɤɨɧɫɬɪɭɤɬɨɪ ɞɥɹ ɩɟɪɟɨɩɪɟɞɟɥɹɟɦɨɝɨ ɤɨɦɩɨɧɟɧɬɚ.

unit UMyButton;
interface
uses Classes, Controls, Forms, StdCtrls;
type
TMyButton = class( TButton )
public
constructor Create( AOwner : TComponent ); override;
published
property Height default 26;
property Width default 80;
end;
procedure Register;

implementation
constructor TMyButton.Create( AOwner : TComponent );
begin
// He ɡɚɛɭɞɶɬɟ ɜɵɡɜɚɬɶ ɤɨɧɫɬɪɭɤɬɨɪ ɩɪɟɞɤɚ
inherited Create(AOwner);
// ɍɫɬɚɧɨɜɤɚ ɧɨɜɵɯ ɡɧɚɱɟɧɢɣ ɩɨ ɭɦɨɥɱɚɧɢɸ
Width := 80;
Height := 26;
end;
// ɉɪɨɰɟɞɭɪɚ Register
28
 procedure Register;
begin
RegisterComponents(‘MyPalette', [TMyButton] );
end;
end.

3.4. Ɉɛɴɹɜɥɟɧɢɟ ɤɨɧɫɬɪɭɤɬɨɪɚ

ȼɫɟ ɤɨɦɩɨɧɟɧɬɵ ɧɚɫɥɟɞɭɸɬ ɨɬ ɤɥɚɫɫɚ Ɍɋɨmɪɨnent ɜɢɪɬɭɚɥɶɧɵɣ
ɤɨɧɫɬɪɭɤɬɨɪ Create. Ⱦɚɠɟ ɟɫɥɢ ɜ ɩɨɪɨɠɞɟɧɧɨɦ ɤɥɚɫɫɟ ɤɨɧɫɬɪɭɤɬɨɪ ɢ ɩɟ-
ɪɟɨɩɪɟɞɟɥɹɟɬɫɹ (ɬɚɤ ɤɚɤ ɨɧ ɨɛɴɹɜɥɟɧ ɜɢɪɬɭɚɥɶɧɵɦ), ɬɨ ɟɝɨ ɫɩɢɫɨɤ ɩɚɪɚ-
ɦɟɬɪɨɜ ɢɡɦɟɧɢɬɶ ɧɟɥɶɡɹ. Ʉɨɧɫɬɪɭɤɬɨɪ ɩɪɢɧɢɦɚɟɬ ɜɫɟɝɨ ɨɞɢɧ ɚɪɝɭɦɟɧɬ, ɹɜ-
ɥɹɸɳɢɣɫɹ ɫɫɵɥɤɨɣ ɧɚ ɤɨɦɩɨɧɟɧɬ, ɤɨɬɨɪɵɣ ɛɭɞɟɬ ɜɥɚɞɟɬɶ ɧɨɜɵɦ ɤɨɦɩɨ-
ɧɟɧɬɨɦ. ȼɥɚɞɟɥɟɰ ɧɟɫɟɬ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɶ ɡɚ ɪɚɡɪɭɲɟɧɢɟ ɜɫɟɯ ɤɨɦɩɨɧɟɧɬɨɜ
ɢɡ ɫɜɨɟɝɨ ɫɩɢɫɤɚ Components.
Ʉɨɧɫɬɪɭɤɬɨɪ Create ɞɥɹ ɤɨɦɩɨɧɟɧɬɚ ɜɫɟɝɞɚ ɩɨɦɟɳɚɟɬɫɹ ɜ ɪɚɡɞɟɥ
public. ȼ ɞɨɩɨɥɧɟɧɢɟ ɤ ɨɛɴɹɜɥɟɧɢɸ ɤɨɧɫɬɪɭɤɬɨɪɚ ɜ ɧɭɠɧɨɦ ɪɚɡɞɟɥɟ ɧɟ
ɡɚɛɭɞɶɬɟ ɞɨɛɚɜɢɬɶ ɤ ɟɝɨ ɨɛɴɹɜɥɟɧɢɸ ɞɢɪɟɤɬɢɜɭ override. ȿɫɥɢ ɞɢɪɟɤɬɢ-
ɜɚ override ɩɪɨɩɭɳɟɧɚ, ɬɨ ɤɨɦɩɨɧɟɧɬ ɛɭɞɟɬ ɤɨɦɩɢɥɢɪɨɜɚɬɶɫɹ, ɧɨ ɩɪɢ
ɫɨɡɞɚɧɢɢ ɤɨɦɩɨɧɟɧɬɚ ɜɨ ɜɪɟɦɹ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɞɢɡɚɣɧɟɪɨɦ ɮɨɪɦ ɛɭɞɟɬ
ɜɵɡɜɚɧ ɧɟ ɬɨɬ ɤɨɧɫɬɪɭɤɬɨɪ. ɉɪɨɩɭɫɤ ɞɢɪɟɤɬɢɜɵ override ɪɚɡɪɵɜɚɟɬ ɜɢɪ-
ɬɭɚɥɶɧɭɸ ɰɟɩɨɱɤɭ ɢɟɪɚɪɯɢɢ, ɫɭɳɟɫɬɜɭɸɳɭɸ ɦɟɠɞɭ ɤɨɧɫɬɪɭɤɬɨɪɚɦɢ. Ʉɨ-
ɝɞɚ ɞɢɡɚɣɧɟɪ ɮɨɪɦ ɫɨɡɞɚɟɬ ɧɨɜɵɣ ɤɨɦɩɨɧɟɧɬ, ɨɧ ɞɥɹ ɨɩɪɟɞɟɥɟɧɢɹ ɬɨɝɨ, ɤɚ-
ɤɨɣ ɤɨɧɫɬɪɭɤɬɨɪ ɧɭɠɧɨ ɜɵɡɜɚɬɶ, ɢɫɩɨɥɶɡɭɟɬ ɩɨɥɢɦɨɪɮɢɡɦ. ɇɨ ɩɨɫɤɨɥɶɤɭ
ɜɢɪɬɭɚɥɶɧɚɹ ɰɟɩɨɱɤɚ ɪɚɡɨɪɜɚɧɚ, ɜɦɟɫɬɨ TMyButton.Create ɛɭɞɟɬ ɜɵ-
ɡɜɚɧ TButton.Create.
ȼ ɤɨɧɫɬɪɭɤɬɨɪɟ ɨɛɵɱɧɨ ɩɟɪɟɨɩɪɟɞɟɥɹɸɬɫɹ ɡɧɚɱɟɧɢɹ ɩɨ ɭɦɨɥɱɚɧɢɸ.
ɉɪɢ ɩɟɪɟɨɩɪɟɞɟɥɟɧɢɢ ɡɧɚɱɟɧɢɣ ɩɨ ɭɦɨɥɱɚɧɢɸ ɞɥɹ ɤɨɦɩɨɧɟɧɬɚ ɬɚɤɠɟ
ɭɞɨɛɧɨ ɩɨɜɬɨɪɧɨ ɨɛɴɹɜɢɬɶ ɩɟɪɟɨɩɪɟɞɟɥɹɟɦɵɟ ɫɜɨɣɫɬɜɚ ɢ ɭɤɚɡɚɬɶ ɧɨɜɵɟ
ɡɧɚɱɟɧɢɹ ɩɨ ɭɦɨɥɱɚɧɢɸ, ɢɫɩɨɥɶɡɭɹ ɞɢɪɟɤɬɢɜɭ default.

29
 Ɍɚɤ ɤɚɤ ɤɨɧɫɬɪɭɤɬɨɪ ɹɜɥɹɟɬɫɹ ɜɢɪɬɭɚɥɶɧɵɦ, ɫɧɚɱɚɥɚ ɜɵɡɵɜɚɟɬɫɹ ɭɧɚɫ-
ɥɟɞɨɜɚɧɧɵɣ ɤɨɧɫɬɪɭɤɬɨɪ. ɗɬɨ ɝɚɪɚɧɬɢɪɭɟɬ ɩɪɚɜɢɥɶɧɨɟ ɫɨɡɞɚɧɢɟ ɤɨɦɩɨɧɟɧ-
ɬɚ. ɉɪɢ ɩɟɪɟɨɩɪɟɞɟɥɟɧɢɢ ɡɧɚɱɟɧɢɣ ɩɨ ɭɦɨɥɱɚɧɢɸ ɨɫɨɛɟɧɧɨ ɜɚɠɧɨ ɜɵɡɜɚɬɶ
ɭɧɚɫɥɟɞɨɜɚɧɧɵɣ ɤɨɧɫɬɪɭɤɬɨɪ, ɩɨɫɤɨɥɶɤɭ ɨɧ ɧɟɫɟɬ ɨɬɜɟɬɫɬɜɟɧɧɨɫɬɶ ɡɚ ɭɫɬɚ-
ɧɨɜɤɭ ɢɫɯɨɞɧɵɯ ɡɧɚɱɟɧɢɣ ɩɨ ɭɦɨɥɱɚɧɢɸ, ɤɨɬɨɪɵɟ ɦɵ ɩɵɬɚɟɦɫɹ ɩɟɪɟɨɩɪɟ-
ɞɟɥɢɬɶ. ȿɫɥɢ ɭɧɚɫɥɟɞɨɜɚɧɧɵɣ ɤɨɧɫɬɪɭɤɬɨɪ ɜɵɡɜɚɬɶ ɩɨɫɥɟ ɭɫɬɚɧɨɜɤɢ ɧɨɜɵɯ
ɡɧɚɱɟɧɢɣ ɩɨ ɭɦɨɥɱɚɧɢɸ, ɬɨ ɛɭɞɭɬ ɜɨɫɫɬɚɧɨɜɥɟɧɵ ɢɫɯɨɞɧɵɟ ɡɧɚɱɟɧɢɹ.

3.5. Ɍɟɫɬɢɪɨɜɚɧɢɟ ɢɧɬɟɪɮɟɣɫɚ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ

Ɍɟɫɬɢɪɨɜɚɧɢɟ ɤɨɦɩɨɧɟɧɬɚ ɧɟɫɤɨɥɶɤɨ ɨɬɥɢɱɚɟɬɫɹ ɨɬ ɬɟɫɬɢɪɨɜɚɧɢɹ
ɩɨɥɧɨɝɨ ɩɪɢɥɨɠɟɧɢɹ Delphi. Ɋɚɡɥɢɱɢɟ ɩɨɪɨɠɞɚɟɬɫɹ ɬɟɦ ɮɚɤɬɨɦ, ɱɬɨ ɤɨɦ-
ɩɨɧɟɧɬɵ ɢɦɟɸɬ ɞɜɚ ɨɬɞɟɥɶɧɵɯ, ɯɨɬɹ ɢ ɫɯɨɞɧɵɯ ɢɧɬɟɪɮɟɣɫɚ, ɧɭɠɞɚɸɳɢɯɫɹ
ɜ ɩɪɨɜɟɪɤɟ. Ʉɨɝɞɚ ɤɨɦɩɨɧɟɧɬ ɢɫɩɨɥɶɡɭɟɬɫɹ ɜ ɩɪɢɥɨɠɟɧɢɢ, ɬɨ ɟɝɨ ɩɨɜɟɞɟɧɢɟ
ɨɩɪɟɞɟɥɹɟɬ ɢɧɬɟɪɮɟɣɫ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ. Ɉɞɧɚɤɨ ɤɨɝɞɚ ɤɨɦɩɨɧɟɧɬ ɩɨ-
ɦɟɳɚɟɬɫɹ ɧɚ ɮɨɪɦɭ ɜ ɫɪɟɞɟ Delphi, ɬɨ ɩɨɜɟɞɟɧɢɟ ɤɨɦɩɨɧɟɧɬɚ ɞɢɤɬɭɟɬɫɹ ɟɝɨ
ɢɧɬɟɪɮɟɣɫɨɦ ɜɪɟɦɟɧɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ. Ⱦɥɹ ɫɨɡɞɚɧɢɹ ɤɚɱɟɫɬɜɟɧɧɨɝɨ ɤɨɦ-
ɩɨɧɟɧɬɚ ɫɥɟɞɭɟɬ ɩɪɨɜɟɪɢɬɶ ɨɛɚ ɢɧɬɟɪɮɟɣɫɚ. ȼɩɨɥɧɟ ɜɨɡɦɨɠɧɨ ɫɨɡɞɚɬɶ
ɤɨɦɩɨɧɟɧɬ, ɤɨɬɨɪɵɣ ɩɪɚɜɢɥɶɧɨ ɜɟɞɟɬ ɫɟɛɹ ɜɨ ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ, ɧɨ ɧɟɩɪɚ-
ɜɢɥɶɧɨ ɜɨ ɜɪɟɦɹ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ, ɢ ɧɚɨɛɨɪɨɬ.
ɉɪɟɠɞɟ ɜɫɟɝɨ ɩɪɨɬɟɫɬɢɪɭɟɦ ɢɧɬɟɪɮɟɣɫ ɤɨɦɩɨɧɟɧɬɚ ɜɪɟɦɟɧɢ ɜɵɩɨɥ-
ɧɟɧɢɹ. Ⱦɥɹ ɬɚɤɨɝɨ ɩɨɪɹɞɤɚ ɟɫɬɶ ɧɟɫɤɨɥɶɤɨ ɩɪɢɱɢɧ. ȼɨ-ɩɟɪɜɵɯ, ɩɪɨɬɟɫɬɢɪɨ-
ɜɚɬɶ ɩɨɜɟɞɟɧɢɟ ɤɨɦɩɨɧɟɧɬɚ ɜɨ ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ ɝɨɪɚɡɞɨ ɥɟɝɱɟ, ɱɟɦ ɩɨɜɟ-
ɞɟɧɢɟ ɜɨ ɜɪɟɦɹ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ. ȼɨ-ɜɬɨɪɵɯ, ɞɥɹ ɛɨɥɶɲɢɧɫɬɜɚ ɤɨɦɩɨɧɟɧɬɨɜ
ɢɧɬɟɪɮɟɣɫ ɜɪɟɦɟɧɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɜɟɫɶɦɚ ɩɨɯɨɠ ɧɚ ɢɧɬɟɪɮɟɣɫ ɜɪɟɦɟɧɢ
ɜɵɩɨɥɧɟɧɢɹ. Ɍɟɫɬɢɪɨɜɚɧɢɟ ɫɪɟɞɵ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ ɩɨɦɨɠɟɬ ɭɛɟɞɢɬɶɫɹ
ɜ ɬɨɦ, ɱɬɨ ɤɨɦɩɨɧɟɧɬ ɛɭɞɟɬ ɩɪɚɜɢɥɶɧɨ ɪɚɛɨɬɚɬɶ ɜɨ ɜɪɟɦɹ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ.
ɂ, ɜ-ɬɪɟɬɶɢɯ, ɞɥɹ ɩɨɢɫɤɚ ɨɲɢɛɨɤ ɜɨ ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨ-
ɜɚɬɶ ɜɫɬɪɨɟɧɧɵɣ ɨɬɥɚɞɱɢɤ, ɤɨɬɨɪɵɣ ɧɟɞɨɫɬɭɩɟɧ ɜɨ ɜɪɟɦɹ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ.

30
 Ⱦɥɹ ɩɪɨɜɟɪɤɢ ɧɚɲɟɝɨ ɧɨɜɨɝɨ ɤɨɦɩɨɧɟɧɬɚ MyButton ɧɭɠɧɨ ɫɨɡɞɚɬɶ
ɬɟɫɬɨɜɨɟ ɩɪɢɥɨɠɟɧɢɟ. ɋɨɡɞɚɧɢɟ ɬɟɫɬɨɜɵɯ ɩɪɢɥɨɠɟɧɢɣ ɹɜɥɹɟɬɫɹ ɝɥɚɜɧɨɣ
ɩɪɢɱɢɧɨɣ ɜɵɞɟɥɟɧɢɹ ɞɥɹ ɦɨɞɭɥɹ ɤɚɠɞɨɝɨ ɤɨɦɩɨɧɟɧɬɚ ɨɬɞɟɥɶɧɨɝɨ ɤɚɬɚɥɨɝɚ.
Ʉɚɬɚɥɨɝ ɫɨɞɟɪɠɢɬ ɢɫɯɨɞɧɵɣ ɮɚɣɥ ɤɨɦɩɨɧɟɧɬɚ ɢ ɜɫɟ ɮɚɣɥɵ, ɚɫɫɨɰɢɢɪɭɸ-
ɳɢɟɫɹ ɫ ɬɟɫɬɨɜɵɦ ɩɪɨɟɤɬɨɦ. ɇɚɥɢɱɢɟ ɩɨɞ ɪɭɤɚɦɢ ɬɟɫɬɨɜɵɯ ɩɪɢɥɨɠɟɧɢɣ
ɨɛɥɟɝɱɚɟɬ ɩɨɞɞɟɪɠɤɭ ɤɨɦɩɨɧɟɧɬɨɜ, ɬɚɤ ɤɚɤ ɤɨɝɞɚ ɤɨɦɩɨɧɟɧɬ ɩɪɢɯɨɞɢɬɫɹ
ɦɨɞɢɮɢɰɢɪɨɜɚɬɶ, ɬɨ ɭ ɜɚɫ ɭɠɟ ɛɭɞɟɬ ɬɟɫɬɨɜɨɟ ɩɪɢɥɨɠɟɧɢɟ, ɩɨɫɬɪɨɟɧɧɨɟ ɜ
ɬɨɦ ɠɟ ɫɚɦɨɦ ɤɚɬɚɥɨɝɟ, ɱɬɨ ɢ ɤɨɦɩɨɧɟɧɬ.
ɂɬɚɤ, ɤɚɤ ɠɟ ɩɪɨɬɟɫɬɢɪɨɜɚɬɶ ɧɨɜɵɣ ɤɨɦɩɨɧɟɧɬ, ɟɫɥɢ ɨɧ ɞɚɠɟ ɧɟ ɩɨɹɜ-
ɥɹɟɬɫɹ ɜ ɩɚɥɢɬɪɟ ɤɨɦɩɨɧɟɧɬɨɜ? ȼɦɟɫɬɨ ɬɨɝɨ ɱɬɨɛɵ ɢɫɩɨɥɶɡɨɜɚɬɶ ɞɢɡɚɣɧɟɪ
ɮɨɪɦ ɞɥɹ ɩɨɦɟɳɟɧɢɹ ɤɨɦɩɨɧɟɧɬɚ ɧɚ ɮɨɪɦɭ, ɚ ɡɚɬɟɦ ɢɫɩɨɥɶɡɨɜɚɬɶ ɂɧɫɩɟɤɬɨɪ
ɨɛɴɟɤɬɨɜ ɞɥɹ ɢɡɦɟɧɟɧɢɹ ɤɚɤɢɯ-ɬɨ ɫɜɨɣɫɬɜ ɤɨɦɩɨɧɟɧɬɚ, ɦɵ ɞɢɧɚɦɢɱɟɫɤɢ ɫɨɡ-
ɞɚɞɢɦ ɷɤɡɟɦɩɥɹɪ ɤɨɦɩɨɧɟɧɬɚ ɜɨ ɜɪɟɦɹ ɫɨɡɞɚɧɢɹ ɮɨɪɦɵ ɧɚɲɟɝɨ ɩɪɢɥɨɠɟɧɢɹ.
Ⱦɢɧɚɦɢɱɟɫɤɨɟ ɫɨɡɞɚɧɢɟ ɤɨɦɩɨɧɟɧɬɚ ɩɪɟɞɨɫɬɚɜɢɬ ɧɚɦ ɜɨɡɦɨɠɧɨɫɬɶ ɫɨɡɞɚɬɶ
ɤɨɦɩɨɧɟɧɬ, ɧɟ ɪɟɝɢɫɬɪɢɪɭɹ ɟɝɨ ɜ Delphi. Ɋɟɝɢɫɬɪɚɰɢɹ ɩɪɟɞɫɬɚɜɥɹɟɬ ɫɨɛɨɣ
ɩɪɨɰɟɫɫ, ɜ ɬɟɱɟɧɢɟ ɤɨɬɨɪɨɝɨ Delphi ɫɬɚɧɨɜɢɬɫɹ ɢɡɜɟɫɬɧɨ ɨ ɤɨɦɩɨɧɟɧɬɚɯ, ɪɚɡ-
ɦɟɳɟɧɧɵɯ ɜ ɩɚɥɢɬɪɟ ɤɨɦɩɨɧɟɧɬɨɜ. Ɋɟɝɢɫɬɪɚɰɢɹ ɞɨɥɠɧɚ ɜɵɩɨɥɧɹɬɶɫɹ ɞɥɹ
ɩɪɨɜɟɪɤɢ ɩɨɜɟɞɟɧɢɹ ɤɨɦɩɨɧɟɧɬɚ ɜɨ ɜɪɟɦɹ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ, ɧɨ ɞɥɹ ɩɪɨɜɟɪɤɢ
ɩɨɜɟɞɟɧɢɹ ɤɨɦɩɨɧɟɧɬɚ ɜɨ ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ ɨɧɚ ɧɟɨɛɹɡɚɬɟɥɶɧɚ.
ȼ ɬɨɦ ɠɟ ɫɚɦɨɦ ɤɚɬɚɥɨɝɟ, ɝɞɟ ɭɠɟ ɟɫɬɶ ɦɨɞɭɥɶ ɤɨɦɩɨɧɟɧɬɚ, ɫɨɡɞɚɣɬɟ
ɧɨɜɵɣ ɩɪɨɟɤɬ. Ⱦɥɹ ɬɟɫɬɢɪɨɜɚɧɢɹ ɤɨɦɩɨɧɟɧɬɚ ɩɨɧɚɞɨɛɢɬɫɹ ɩɪɨɫɬɚɹ ɮɨɪɦɚ.
Ⱦɢɧɚɦɢɱɟɫɤɨɟ ɫɨɡɞɚɧɢɟ ɤɨɦɩɨɧɟɧɬɚ ɫɜɨɞɢɬɫɹ ɤ ɫɥɟɞɭɸɳɢɦ ɲɚɝɚɦ.
1. Ⱦɨɛɚɜɢɬɶ ɧɨɜɵɣ ɦɨɞɭɥɶ ɤɨɦɩɨɧɟɧɬɚ ɜ ɪɚɡɞɟɥ uses ɦɨɞɭɥɹ ɤɨɦɩɨɧɟɧɬɚ.
2. Ⱦɨɛɚɜɢɬɶ ɜ ɤɥɚɫɫ ɮɨɪɦɵ ɩɨɥɟ, ɤɨɬɨɪɨɟ ɛɭɞɟɬ ɫɫɵɥɤɨɣ ɧɚ ɤɨɦɩɨɧɟɧɬ.
3. ɋɨɡɞɚɬɶ ɤɨɦɩɨɧɟɧɬ ɜ ɫɨɛɵɬɢɢ ɮɨɪɦɵ OnCreate.
4. ɍɫɬɚɧɨɜɢɬɶ ɫɜɨɣɫɬɜɨ ɤɨɦɩɨɧɟɧɬɚ Parent.
5. ɍɫɬɚɧɨɜɢɬɶ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɦ ɨɛɪɚɡɨɦ ɞɨɩɨɥɧɢɬɟɥɶɧɵɟ ɫɜɨɣɫɬɜɚ ɤɨɦ-
ɩɨɧɟɧɬɚ.
unit Mainform;
31
 interface
uses SysUtils, WinTypes, WinProcs, Messages, Classes,
Graphics, Controls, Forms, Dialogs, StdCtrls,
UMyButton;
type
TForml = class(TForm)
procedure FormCreate(Sender: TObject);
private
{ɉɪɢɜɚɬɧɵɟ ɨɛɴɹɜɥɟɧɢɹ }
public
{Ɉɛɳɟɞɨɫɬɭɩɧɵɟ ɨɛɴɹɜɥɟɧɢɹ J
BtnTest : TMyButton;
end;
var
Forml: TForml;
implementation
{$R *.DFM}
procedure TForml.FormCreate(Sender: TObject);
begin
BtnTest := TMyButton.Create( Self ) ;
BtnTest.Parent := Self;
BtnTest.Left := 100;
BtnTest.Top := 100;
BtnTest.Caption := 'MyButton';
end;
end.

ɉɟɪɜɵɣ ɲɚɝ ɞɨɫɬɚɬɨɱɧɨ ɩɪɨɫɬ ɢ ɰɟɥɟɧɚɩɪɚɜɥɟɧ. Ɍɚɤ ɤɚɤ ɦɵ ɛɭɞɟɦ

ɫɫɵɥɚɬɶɫɹ ɧɚ ɬɢɩ ɧɨɜɨɝɨ ɤɨɦɩɨɧɟɧɬɚ, ɬɨ ɧɭɠɧɨ ɜɤɥɸɱɢɬɶ ɷɬɨɬ ɦɨɞɭɥɶ ɤɨɦ-
ɩɨɧɟɧɬɚ ɜ uses-ɪɚɡɞɟɥ ɦɨɞɭɥɹ ɤɨɦɩɨɧɟɧɬɚ. ȼɬɨɪɨɣ ɲɚɝ ɫɜɹɡɚɧ ɫ ɞɨɛɚɜɥɟɧɢ-
ɟɦ ɩɨɥɹ ɨɛɴɟɤɬɚ ɜ ɪɚɡɞɟɥ public ɤɥɚɫɫɚ ɮɨɪɦɵ. ɉɨɥɟ ɨɛɴɟɤɬɚ ɛɭɞɟɬ ɢɫ-
ɩɨɥɶɡɨɜɚɬɶɫɹ ɞɥɹ ɫɫɵɥɤɢ ɧɚ ɫɨɡɞɚɜɚɟɦɵɣ ɤɨɦɩɨɧɟɧɬ, ɢ, ɫɥɟɞɨɜɚɬɟɥɶɧɨ, ɬɢ-
ɩɨɦ ɩɨɥɹ ɛɭɞɟɬ ɜɧɨɜɶ ɫɨɡɞɚɧɧɵɣ ɤɨɦɩɨɧɟɧɬɧɵɣ ɤɥɚɫɫ. ȼ ɬɟɤɭɳɟɣ ɬɟɫɬɨɜɨɣ
ɩɪɨɝɪɚɦɦɟ ɩɨɥɟ BtnTest ɨɛɴɹɜɥɹɟɬɫɹ ɬɢɩɨɦ TMyButton.
32
 ȼɫɟ ɨɫɬɚɥɶɧɵɟ ɲɚɝɢ ɫɜɹɡɚɧɵ ɫ ɨɛɪɚɛɨɬɱɢɤɨɦ ɫɨɛɵɬɢɹ ɮɨɪɦɵ
OnCreate. ɇɚɢɛɨɥɟɟ ɤɨɪɨɬɤɢɣ ɩɭɬɶ ɞɥɹ ɫɨɡɞɚɧɢɹ ɨɛɪɚɛɨɬɱɢɤɚ ɫɨɛɵɬɢɹ
OnCreate ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɞɜɨɣɧɨɦ ɳɟɥɱɤɟ ɧɚ ɧɟɡɚɧɹɬɨɦ ɦɟɫɬɟ ɮɨɪɦɵ. ɗɬɨ
ɫɨɡɞɚɫɬ ɦɟɬɨɞ FormCreate, ɜ ɤɨɬɨɪɨɦ ɛɭɞɟɬ ɫɨɡɞɚɧ ɤɨɦɩɨɧɟɧɬ BtnTest.
ɉɟɪɜɚɹ ɡɚɞɚɱɚ, ɤɨɬɨɪɚɹ ɞɨɥɠɧɚ ɜɵɩɨɥɧɹɬɶɫɹ ɜ ɦɟɬɨɞɟ FormCreate,
ɫɨɫɬɨɢɬ ɜ ɪɟɚɥɢɡɚɰɢɢ ɷɤɡɟɦɩɥɹɪɚ ɧɨɜɨɝɨ ɤɨɦɩɨɧɟɧɬɚ ɩɭɬɟɦ ɨɛɪɚɳɟɧɢɹ ɤ
ɤɨɧɫɬɪɭɤɬɨɪɭ ɤɨɦɩɨɧɟɧɬɚ. ȿɞɢɧɫɬɜɟɧɧɨɟ ɪɟɲɟɧɢɟ, ɤɨɬɨɪɨɟ ɧɟɨɛɯɨɞɢɦɨ
ɩɪɢɧɹɬɶ ɧɚ ɷɬɨɦ ɷɬɚɩɟ, ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɨɩɪɟɞɟɥɟɧɢɢ ɬɨɝɨ, ɱɬɨ ɡɚɞɚɬɶ ɜ ɤɚɱɟ-
ɫɬɜɟ ɜɥɚɞɟɥɶɰɚ ɤɨɦɩɨɧɟɧɬɚ. ȼ ɛɨɥɶɲɢɧɫɬɜɟ ɫɢɬɭɚɰɢɣ ɜɥɚɞɟɥɶɰɟɦ ɛɭɞɟɬ
ɮɨɪɦɚ. ȼ ɦɟɬɨɞɟ FormCreate ɤɨɧɫɬɪɭɤɬɨɪɭ TMyButton ɩɟɪɟɞɚɟɬɫɹ ɩɚ-
ɪɚɦɟɬɪ Self, ɭɤɚɡɵɜɚɸɳɢɣ ɧɚ ɬɨ, ɱɬɨ ɷɬɚ ɮɨɪɦɚ ɛɭɞɟɬ ɫɥɭɠɢɬɶ ɜɥɚɞɟɥɶ-
ɰɟɦ ɧɨɜɨɝɨ ɤɨɦɩɨɧɟɧɬɚ.
ɉɨɫɥɟ ɫɨɡɞɚɧɢɹ ɤɨɦɩɨɧɟɧɬɚ ɜɫɟ ɟɳɟ ɧɟɨɛɯɨɞɢɦɨ ɜɵɩɨɥɧɢɬɶ ɨɞɧɭ ɢɡ
ɫɚɦɵɯ ɜɚɠɧɵɯ ɡɚɞɚɱ – ɭɫɬɚɧɨɜɢɬɶ ɫɜɨɣɫɬɜɨ Parent, ɭɤɚɡɵɜɚɸɳɟɟ ɧɚ ɪɨ-
ɞɢɬɟɥɶɫɤɢɣ ɤɨɦɩɨɧɟɧɬ. Ɋɨɞɢɬɟɥɶɫɤɢɣ ɤɨɦɩɨɧɟɧɬ (ɧɟ ɫɥɟɞɭɟɬ ɩɭɬɚɬɶ ɟɝɨ ɫ
ɤɨɦɩɨɧɟɧɬɨɦ-ɩɪɟɞɤɨɦ, ɨɬ ɤɨɬɨɪɨɝɨ ɢɞɟɬ ɧɚɫɥɟɞɨɜɚɧɢɟ) ɹɜɥɹɟɬɫɹ ɤɨɧɬɟɣɧɟ-
ɪɨɦ ɞɪɭɝɢɯ ɤɨɦɩɨɧɟɧɬɨɜ, ɬ. ɟ. ɫɨɞɟɪɠɢɬ ɢɯ ɜɢɡɭɚɥɶɧɨ. ɍɫɬɚɧɨɜɤɚ ɫɜɨɣɫɬɜɚ
Parent ɩɨɦɟɫɬɢɬ ɬɟɤɭɳɢɣ ɤɨɦɩɨɧɟɧɬ ɜ ɫɩɢɫɨɤ Controls ɪɨɞɢɬɟɥɹ.
ɋɩɢɫɨɤ Controls ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ ɭɫɬɚɧɨɜɥɟɧɢɹ ɩɨɪɹɞɤɚ ɨɛɯɨɞɚ ɷɥɟ-
ɦɟɧɬɨɜ ɭɩɪɚɜɥɟɧɢɹ (tab order) ɢ Z-ɭɩɨɪɹɞɨɱɢɜɚɧɢɹ ɫɪɟɞɢ ɩɪɢɧɚɞɥɟɠɚɳɢɯ
ɤɨɦɩɨɧɟɧɬɭ ɷɥɟɦɟɧɬɨɜ ɭɩɪɚɜɥɟɧɢɹ. Ⱦɪɭɝɨɟ ɜɚɠɧɨɟ ɩɪɢɦɟɧɟɧɢɟ ɫɩɢɫɤɚ
Controls ɩɪɨɢɫɯɨɞɢɬ ɜɨ ɜɪɟɦɹ ɪɢɫɨɜɚɧɢɹ. Ɋɨɞɢɬɟɥɶɫɤɢɣ ɤɨɦɩɨɧɟɧɬ
(Parent) ɢɫɩɨɥɶɡɭɟɬ ɫɩɢɫɨɤ Controls ɞɥɹ ɜɵɞɚɱɢ ɤɨɦɚɧɞɵ ɧɚɪɢɫɨɜɚɬɶ
ɫɟɛɹ ɜɫɟɦ ɞɨɱɟɪɧɢɦ ɤɨɦɩɨɧɟɧɬɚɦ. ɋɥɟɞɨɜɚɬɟɥɶɧɨ, ɟɫɥɢ ɷɥɟɦɟɧɬɚ ɭɩɪɚɜɥɟ-
ɧɢɹ ɜ ɪɨɞɢɬɟɥɶɫɤɨɦ ɫɩɢɫɤɟ Controls ɧɟɬ, ɬɨ ɨɧ ɢ ɧɟ ɩɨɹɜɢɬɫɹ ɩɪɢ ɜɵ-
ɩɨɥɧɟɧɢɢ ɩɪɢɥɨɠɟɧɢɹ.
Ɍɨɥɶɤɨ ɩɨɬɨɦɤɢ TWinControl ɦɨɝɭɬ ɛɵɬɶ ɪɨɞɢɬɟɥɶɫɤɢɦɢ. ɉɪɢɦɟɪɚɦɢ
ɤɨɦɩɨɧɟɧɬɨɜ ɹɜɥɹɸɬɫɹ Panel ɢ GroupBox. Ʉɥɚɫɫ TForm ɬɚɤɠɟ ɹɜɥɹɟɬɫɹ

33
ɩɨɬɨɦɤɨɦ TWinControl ɢ, ɫɥɟɞɨɜɚɬɟɥɶɧɨ, ɬɚɤɠɟ ɦɨɠɟɬ ɛɵɬɶ ɤɨɧɬɟɣɧɟɪɨɦ. ɋ
ɰɟɥɶɸ ɬɟɫɬɢɪɨɜɚɧɢɹ ɧɨɜɨɝɨ ɤɨɦɩɨɧɟɧɬɚ ɦɵ ɯɨɬɢɦ ɢɦɢɬɢɪɨɜɚɬɶ ɞɟɣɫɬɜɢɟ ɩɨ-
ɦɟɳɟɧɢɹ ɤɨɦɩɨɧɟɧɬɚ ɧɚ ɮɨɪɦɭ. ɋɥɟɞɨɜɚɬɟɥɶɧɨ, ɜ ɦɟɬɨɞɟ FormCreate ɫɜɨɣ-
ɫɬɜɨ BtnTest.Parent ɦɟɧɹɟɬɫɹ ɧɚ Self, ɫɫɵɥɚɹɫɶ ɧɚ ɮɨɪɦɭ.
ɉɨɫɥɟ ɭɫɬɚɧɨɜɤɢ ɫɜɨɣɫɬɜɚ Parent ɦɨɠɟɬ ɩɨɬɪɟɛɨɜɚɬɶɫɹ ɧɟɤɨɬɨɪɚɹ
ɦɨɞɢɮɢɤɚɰɢɹ ɫɜɨɣɫɬɜ ɤɨɦɩɨɧɟɧɬɚ. ɗɬɨ ɦɨɝɭɬ ɛɵɬɶ ɫɜɨɣɫɬɜɚ ɩɨɡɢɰɢɨɧɢɪɨ-
ɜɚɧɢɹ Left ɢ Ɍɨɪ. ȿɫɥɢ ɤɨɦɩɨɧɟɧɬ ɢɦɟɟɬ ɡɚɝɨɥɨɜɨɤ, ɬɨ ɱɚɫɬɨ ɭɫɬɚɧɚɜɥɢ-
ɜɚɟɬɫɹ ɢ ɫɜɨɣɫɬɜɨ Caption. Ⱦɥɹ ɬɟɫɬɢɪɨɜɚɧɢɹ ɤɨɦɩɨɧɟɧɬɚ MyButton ɭɫ-
ɬɚɧɨɜɤɢ ɬɪɟɯ ɭɩɨɦɹɧɭɬɵɯ ɫɜɨɣɫɬɜ ɞɨɫɬɚɬɨɱɧɨ, ɬɚɤ ɤɚɤ ɧɢɤɚɤɢɯ ɧɨɜɵɯ ɜɨɡ-
ɦɨɠɧɨɫɬɟɣ ɧɟ ɞɨɛɚɜɥɹɥɨɫɶ. Ⱦɥɹ ɬɟɫɬɢɪɨɜɚɧɢɹ ɛɨɥɟɟ ɫɥɨɠɧɵɯ ɤɨɦɩɨɧɟɧɬɨɜ
ɜ ɞɚɧɧɵɣ ɦɨɦɟɧɬ ɦɨɠɟɬ ɩɨɬɪɟɛɨɜɚɬɶɫɹ ɭɫɬɚɧɨɜɤɚ ɢ ɞɪɭɝɢɯ ɫɜɨɣɫɬɜ ɢ ɨɛɪɚ-
ɛɨɬɱɢɤɨɜ ɫɨɛɵɬɢɣ.
ȼ ɬɟɫɬɨɜɨɦ ɩɪɢɥɨɠɟɧɢɢ ɦɨɠɧɨ ɦɨɞɢɮɢɰɢɪɨɜɚɬɶ ɥɸɛɨɟ ɞɨɫɬɭɩɧɨɟ ɜɨ
ɜɪɟɦɹ ɜɵɩɨɥɧɟɧɢɹ ɫɜɨɣɫɬɜɨ. ȿɞɢɧɫɬɜɟɧɧɨɟ ɪɟɚɥɶɧɨɟ ɨɝɪɚɧɢɱɟɧɢɟ ɡɚɤɥɸ-
ɱɚɟɬɫɹ ɜ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɭɫɬɚɧɨɜɢɬɶ ɫɜɨɣɫɬɜɨ Parent, ɤɚɤ ɛɵɥɨ ɨɩɢɫɚɧɨ
ɜɵɲɟ, ɞɨ ɬɨɝɨ, ɤɚɤ ɭɫɬɚɧɚɜɥɢɜɚɬɶ ɞɪɭɝɢɟ ɫɜɨɣɫɬɜɚ. ȼɵɩɨɥɧɟɧɢɟ ɩɨɞɨɛɧɨɝɨ
ɬɪɟɛɨɜɚɧɢɹ ɧɟɨɛɯɨɞɢɦɨ ɩɨɬɨɦɭ, ɱɬɨ ɢɡɦɟɧɟɧɢɟ ɧɟɤɨɬɨɪɵɯ ɫɜɨɣɫɬɜ ɡɚɫɬɚɜ-
ɥɹɟɬ ɤɨɦɩɨɧɟɧɬ ɩɟɪɟɪɢɫɨɜɵɜɚɬɶ ɫɟɛɹ, ɢ ɟɫɥɢ ɤɨɦɩɨɧɟɧɬ ɧɟ ɜɤɥɸɱɟɧ ɟɳɟ ɜ
ɫɩɢɫɨɤ Controls ɩɪɟɞɤɚ, ɬɨ ɢɡɦɟɧɟɧɢɟ ɨɛɫɭɠɞɚɟɦɵɯ ɫɜɨɣɫɬɜ ɧɟ ɞɚɫɬ ɠɟ-
ɥɚɟɦɨɝɨ ɷɮɮɟɤɬɚ.
ɇɚ ɪɢɫ. 3 ɩɨɤɚɡɚɧ ɪɟɡɭɥɶɬɚɬ ɪɚɛɨɬɵ ɬɟɫɬɨɜɨɝɨ ɩɪɢɥɨɠɟɧɢɹ TestBtns.

Ɋɢɫ. 3.
34
 Ɍɨɬ ɠɟ ɫɚɦɵɣ ɫɩɨɫɨɛ, ɤɨɬɨɪɵɣ ɢɫɩɨɥɶɡɨɜɚɥɫɹ ɞɥɹ ɬɟɫɬɢɪɨɜɚɧɢɹ ɤɨɦ-
ɩɨɧɟɧɬɚ, ɦɨɠɟɬ ɩɪɢɦɟɧɹɬɶɫɹ ɜ Delphi ɜɫɟɝɞɚ, ɤɨɝɞɚ ɧɟɨɛɯɨɞɢɦɨ ɞɢɧɚɦɢɱɟ-
ɫɤɨɟ ɫɨɡɞɚɧɢɟ ɤɨɦɩɨɧɟɧɬɚ. ɂ ɡɞɟɫɶ ɫɥɨɠɧɨɫɬɶ ɡɚɤɥɸɱɚɟɬɫɹ ɜ ɭɫɬɚɧɨɜɤɟ
ɫɜɨɣɫɬɜɚ Parent. ȼ ɩɪɨɝɪɚɦɦɚɯ ɬɟɫɬɢɪɨɜɚɧɢɹ ɤɨɦɩɨɧɟɧɬɨɜ ɫɜɨɣɫɬɜɨ
Parent ɨɛɵɱɧɨ ɭɫɬɚɧɚɜɥɢɜɚɟɬɫɹ ɜ Self, ɱɬɨ ɭɤɚɡɵɜɚɟɬ ɧɚ ɨɬɜɟɬɫɬɜɟɧ-
ɧɨɫɬɶ ɮɨɪɦɵ ɡɚ ɪɢɫɨɜɚɧɢɟ ɷɥɟɦɟɧɬɚ ɭɩɪɚɜɥɟɧɢɹ. Ɉɞɧɚɤɨ ɜ ɩɪɢɥɨɠɟɧɢɢ ɷɬɨ
ɦɨɠɟɬ ɛɵɬɶ ɮɨɪɦɚ, ɩɚɧɟɥɶ, GroupBox ɢ ɬ. ɩ.

3.6. ɍɫɬɚɧɨɜɤɚ ɤɨɦɩɨɧɟɧɬɚ

Ⱦɥɹ ɩɟɪɟɯɨɞɚ ɤ ɫɥɟɞɭɸɳɟɦɭ ɭɪɨɜɧɸ ɬɟɫɬɢɪɨɜɚɧɢɹ ɤɨɦɩɨɧɟɧɬ ɞɨɥ-
ɠɟɧ ɛɵɬɶ ɜɤɥɸɱɟɧ ɜ ɩɚɥɢɬɪɭ. Ʉɨɝɞɚ ɭɫɬɚɧɚɜɥɢɜɚɟɬɫɹ ɧɨɜɵɣ ɦɨɞɭɥɶ ɤɨɦ-
ɩɨɧɟɧɬɚ, ɛɢɛɥɢɨɬɟɤɚ ɤɨɦɩɨɧɟɧɬɨɜ ɩɟɪɟɫɬɪɚɢɜɚɟɬɫɹ. ȼ ɫɩɢɫɨɤ ɭɫɬɚɧɨɜɥɟɧ-
ɧɵɯ ɦɨɝɭɬ ɩɨɩɚɫɬɶ ɬɨɥɶɤɨ ɬɟ ɦɨɞɭɥɢ, ɤɨɬɨɪɵɟ ɫɨɞɟɪɠɚɬ ɩɪɨɰɟɞɭɪɭ
Register. ɇɚɩɨɦɧɢɦ, ɱɬɨ ɜ ɩɪɨɰɟɞɭɪɟ Register ɜɵɡɵɜɚɟɬɫɹ ɩɪɨɰɟɞɭɪɚ
RegisterComponents, ɢɦɟɸɳɚɹ ɜ ɤɚɱɟɫɬɜɟ ɩɚɪɚɦɟɬɪɨɜ ɬɪɟɛɭɟɦɭɸ ɩɚ-
ɥɢɬɪɭ ɢ ɦɚɫɫɢɜ ɤɨɦɩɨɧɟɧɬɨɜ, ɠɟɥɚɸɳɢɯ ɬɚɦ ɨɬɨɛɪɚɡɢɬɶɫɹ.
Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ ɤɨɦɩɨɧɟɧɬ ɩɨɹɜɢɥɫɹ ɜ ɩɚɥɢɬɪɟ, ɟɝɨ ɧɭɠɧɨ ɫɜɹɡɚɬɶ ɫ
ɛɢɛɥɢɨɬɟɤɨɣ ɤɨɦɩɨɧɟɧɬɨɜ Delphi, ɜɤɥɸɱɢɜ ɜ ɫɨɫɬɚɜ ɩɚɤɟɬɚ.
Ɏɚɤɬɢɱɟɫɤɢ ɩɚɤɟɬ Delphi – ɷɬɨ ɞɢɧɚɦɢɱɟɫɤɢ ɡɚɝɪɭɠɚɟɦɚɹ ɛɢɛɥɢɨɬɟɤɚ
ɫ ɪɚɫɲɢɪɟɧɢɟɦ .bpl. ɂɧɮɨɪɦɚɰɢɹ ɨ ɫɨɫɬɚɜɟ ɩɚɤɟɬɚ ɢ ɪɟɠɢɦɚɯ ɤɨɦɩɢɥɹ-
ɰɢɢ ɩɚɤɟɬɚ ɫɨɞɟɪɠɢɬɫɹ ɜ ɬɟɤɫɬɨɜɨɦ ɮɚɣɥɟ .dpk. Ʉɨɦɩɨɧɟɧɬɵ ɢɡ ɩɚɤɟɬɨɜ
ɨɬɨɛɪɚɠɚɸɬɫɹ ɧɚ ɩɚɥɢɬɪɟ ɤɨɦɩɨɧɟɧɬɨɜ. Ʉɨɦɩɨɧɟɧɬɵ, ɩɨɫɬɚɜɥɹɟɦɵɟ ɫ Del-
phi, ɫɝɪɭɩɩɢɪɨɜɚɧɵ ɩɨ ɢɯ ɮɭɧɤɰɢɨɧɚɥɶɧɨɦɭ ɧɚɡɧɚɱɟɧɢɸ ɜ ɧɟɫɤɨɥɶɤɨ ɮɚɣ-
ɥɨɜ .bpl.
Ɂɚɤɪɨɣɬɟ ɜɫɟ ɩɪɨɟɤɬɵ ɜ Delphi ɢ ɡɚɝɪɭɡɢɬɟ ɦɨɞɭɥɶ ɫ ɤɨɦɩɨɧɟɧɬɨɦ
UMyButton.Pas. Ⱦɥɹ ɭɫɬɚɧɨɜɤɢ ɤɨɦɩɨɧɟɧɬɚ ɜɵɡɨɜɢɬɟ ɢɡ ɦɟɧɸ ɨɤɧɨ ɢɧ-
ɫɬɚɥɥɹɰɢɢ Component|Install Component (ɪɢɫ. 4).

35
 Ɋɢɫ. 4. Ɉɤɧɨ ɭɫɬɚɧɨɜɤɢ ɤɨɦɩɨɧɟɧɬɚ

ɇɨɜɵɣ ɤɨɦɩɨɧɟɧɬ ɦɨɠɟɬ ɛɵɬɶ ɭɫɬɚɧɨɜɥɟɧ ɜ ɫɭɳɟɫɬɜɭɸɳɢɣ ɩɚɤɟɬ

(Into existing package) ɢɥɢ ɧɨɜɵɣ ɩɚɤɟɬ (Into new package). ɗɬɨ ɨɩɪɟɞɟɥɹɟɬ-
ɫɹ ɜɵɛɨɪɨɦ ɡɚɤɥɚɞɤɢ.
ȼ ɩɟɪɜɨɣ ɫɬɪɨɤɟ ɞɨɥɠɧɨ ɛɵɬɶ ɭɤɚɡɚɧɨ ɢɦɹ ɦɨɞɭɥɹ, ɫɨɞɟɪɠɚɳɟɝɨ
ɤɥɚɫɫ ɤɨɦɩɨɧɟɧɬɚ. ȼ ɧɚɲɟɦ ɫɥɭɱɚɟ ɷɬɨ UMyButton.pas.
ȼɬɨɪɚɹ ɫɬɪɨɤɚ ɫɨɞɟɪɠɢɬ ɦɚɪɲɪɭɬɵ ɩɨɢɫɤɚ ɮɚɣɥɨɜ.
Ɍɪɟɬɶɹ ɫɬɪɨɤɚ ɨɩɪɟɞɟɥɹɟɬ ɢɦɹ ɩɚɤɟɬɚ, ɜ ɤɨɬɨɪɵɣ ɛɭɞɟɬ ɜɤɥɸɱɟɧ ɤɨɦ-
ɩɨɧɟɧɬ. Ɋɚɡɭɦɟɟɬɫɹ, ɫɨɛɫɬɜɟɧɧɵɟ ɤɨɦɩɨɧɟɧɬɵ ɩɪɚɜɢɥɶɧɟɟ ɫɨɯɪɚɧɹɬɶ ɜ ɧɨ-
ɜɵɯ, ɫɩɟɰɢɚɥɶɧɨ ɞɥɹ ɧɢɯ ɫɨɡɞɚɧɧɵɯ ɩɚɤɟɬɚɯ. ȿɫɥɢ ɤɨɦɩɨɧɟɧɬ ɞɨɛɚɜɥɹɟɬɫɹ
ɜ ɫɭɳɟɫɬɜɭɸɳɢɣ ɩɚɤɟɬ, ɬɨ ɨɧ ɦɨɠɟɬ ɛɵɬɶ ɜɵɛɪɚɧ ɢɡ ɜɵɩɚɞɚɸɳɟɝɨ ɫɩɢɫɤɚ,
ɢɧɚɱɟ ɜɜɨɞɢɬɫɹ ɢɦɹ ɧɨɜɨɝɨ ɩɚɤɟɬɚ. Ɋɚɫɲɢɪɟɧɢɟ .dpk ɛɭɞɟɬ ɞɨɛɚɜɥɟɧɨ ɚɜ-
ɬɨɦɚɬɢɱɟɫɤɢ. ɇɚɩɪɢɦɟɪ, ɟɫɥɢ ɩɚɤɟɬ ɧɚɡɵɜɚɟɬɫɹ MyButton, ɬɨ ɪɟɞɚɤɬɨɪ
ɩɚɤɟɬɚ ɝɟɧɟɪɢɪɭɟɬ ɢɫɯɨɞɧɵɣ ɮɚɣɥ ɫ ɢɦɟɧɟɦ MyButton.dpk, ɤɨɦɩɢɥɹɬɨɪ
ɝɟɧɟɪɢɪɭɟɬ ɜɵɩɨɥɧɹɟɦɵɣ ɮɚɣɥ (DLL) MyButton.bpl ɢ ɜɫɩɨɦɨɝɚɬɟɥɶ-
ɧɵɣ ɛɢɧɚɪɧɵɣ ɛɢɛɥɢɨɬɟɱɧɵɣ ɮɚɣɥ ɫ ɢɦɟɧɟɦ MyButton.dcp.
ɉɨɫɥɟɞɧɹɹ ɫɬɪɨɤɚ ɦɨɠɟɬ ɫɨɞɟɪɠɚɬɶ ɤɪɚɬɤɨɟ ɨɩɢɫɚɧɢɟ ɩɚɤɟɬɚ.
Ɂɚɩɨɥɧɢɜ ɩɨɥɹ ɢ ɧɚɠɚɜ ɤɧɨɩɤɭ OK, ɭɫɬɚɧɚɜɥɢɜɚɟɦ ɤɨɦɩɨɧɟɧɬ.
ȼ ɩɨɹɜɢɜɲɟɦɫɹ ɨɤɧɟ (ɪɢɫ. 5) ɧɚɞɨ ɞɚɬɶ ɩɨɥɨɠɢɬɟɥɶɧɵɣ ɨɬɜɟɬ ɧɚ ɩɪɢɝɥɚɲɟ-
ɧɢɟ ɨɬɤɨɦɩɢɥɢɪɨɜɚɬɶ ɩɚɤɟɬ.
36
 Ɋɢɫ. 5
ɋɥɟɞɭɸɳɟɟ ɨɤɧɨ ɫɜɢɞɟɬɟɥɶɫɬɜɭɟɬ ɨɛ ɭɫɩɟɲɧɨɣ ɢɧɫɬɚɥɥɹɰɢɢ ɩɚɤɟɬɚ
ɢ ɪɟɝɢɫɬɪɚɰɢɢ ɤɨɦɩɨɧɟɧɬɚ.

Ɋɢɫ. 6
Ɂɚɦɟɱɚɧɢɟ. ȼ ɞɚɧɧɨɦ ɫɥɭɱɚɟ ɨɬɤɨɦɩɢɥɢɪɨɜɚɧɧɵɣ ɮɚɣɥ .bpl ɡɚɩɢ-
ɫɚɥɫɹ ɜ ɪɚɛɨɱɢɟ ɩɚɩɤɢ Delphi ɜ C:\Program Files\Borland\... ȼɨ ɦɧɨɝɢɯ ɫɥɭ-
ɱɚɹɯ ɞɨɫɬɭɩ ɜ ɷɬɢ ɩɚɩɤɢ ɡɚɤɪɵɬ ɚɞɦɢɧɢɫɬɪɚɬɨɪɨɦ. Ɍɨɝɞɚ ɫɥɟɞɭɟɬ ɹɜɧɨ ɭɤɚ-
ɡɚɬɶ ɩɚɩɤɢ ɧɚɡɧɚɱɟɧɢɹ ɜ ɩɭɧɤɬɟ ɦɟɧɸ Project | Options ɧɚ ɜɤɥɚɞɤɟ Directo-
riesŇConditionals ɜ ɫɬɪɨɤɚɯ Output Directory ɢ DCP Output Directory.
Ʉɚɤ ɬɨɥɶɤɨ ɤɨɦɩɨɧɟɧɬ ɭɫɬɚɧɨɜɥɟɧ ɜ ɩɚɥɢɬɪɟ, ɟɝɨ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨ-
ɜɚɬɶ ɜ ɩɪɢɥɨɠɟɧɢɹɯ Delphi, ɩɪɟɞɜɚɪɢɬɟɥɶɧɨ ɩɪɨɬɟɫɬɢɪɨɜɚɜ ɩɨɜɟɞɟɧɢɟ ɤɨɦ-
ɩɨɧɟɧɬɚ ɜɨ ɜɪɟɦɹ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ. Ɍɟɫɬɢɪɨɜɚɧɢɟ ɯɚɪɚɤɬɟɪɢɫɬɢɤ ɤɨɦɩɨɧɟɧ-
ɬɚ ɜɪɟɦɟɧɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɜɟɫɶɦɚ ɫɥɨɠɧɵɦ, ɨɫɨɛɟɧɧɨ
ɟɫɥɢ ɤɨɦɩɨɧɟɧɬ ɢɦɟɟɬ ɦɧɨɝɨ ɫɜɨɣɫɬɜ. ȼ ɧɚɲɟɦ ɫɥɭɱɚɟ ɜɫɟ, ɱɬɨ ɧɭɠɧɨ ɫɞɟ-
ɥɚɬɶ – ɷɬɨ ɩɨɦɟɫɬɢɬɶ ɷɤɡɟɦɩɥɹɪ ɧɚ ɮɨɪɦɭ ɢ ɩɪɨɜɟɪɢɬɶ, ɞɟɣɫɬɜɭɸɬ ɥɢ ɧɨɜɵɟ
ɡɧɚɱɟɧɢɹ ɪɚɡɦɟɪɚ. ȿɫɥɢ ɤɨɦɩɨɧɟɧɬ ɪɚɛɨɬɚɟɬ ɧɟɩɪɚɜɢɥɶɧɨ ɢɥɢ ɛɨɥɶɲɟ ɧɟ
ɩɪɟɞɫɬɚɜɥɹɟɬ ɢɧɬɟɪɟɫ, ɟɝɨ ɦɨɠɧɨ ɭɞɚɥɢɬɶ ɢɡ IDE ɫ ɩɨɦɨɳɶɸ ɨɤɧɚ ɭɫɬɚɧɨɜ-
ɤɢ ɩɚɤɟɬɚ (ɫɦ. ɪɢɫ. 8 ɢ ɬɚɛɥ. 5).
ɉɨɫɥɟ ɢɫɩɪɚɜɥɟɧɢɹ ɨɲɢɛɨɤ ɢ ɞɥɹ ɞɚɥɶɧɟɣɲɟɣ ɨɬɥɚɞɤɢ ɭɞɨɛɧɨ ɜɨɫ-
ɩɨɥɶɡɨɜɚɬɶɫɹ ɪɟɞɚɤɬɨɪɨɦ ɩɚɤɟɬɨɜ, ɜ ɤɨɬɨɪɨɦ ɦɨɠɧɨ ɞɨɛɚɜɥɹɬɶ ɢ ɭɞɚɥɹɬɶ

37
ɤɨɦɩɨɧɟɧɬɵ ɜ ɩɚɤɟɬ, ɤɨɦɩɢɥɢɪɨɜɚɬɶ ɩɚɤɟɬɵ. Ɋɟɞɚɤɬɨɪ ɩɚɤɟɬɨɜ (ɪɢɫ. 7) ɚɜ-
ɬɨɦɚɬɢɱɟɫɤɢ ɩɨɹɜɢɬɫɹ, ɟɫɥɢ ɡɚɝɪɭɡɢɬɶ ɩɚɤɟɬ DPK ɜ Delphi ɱɟɪɟɡ ɦɟɧɸ File
|Open Project. Ɍɚɤɠɟ ɨɧ ɛɭɞɟɬ ɜɵɡɜɚɧ, ɟɫɥɢ ɜɵɛɪɚɬɶ ɩɪɢ ɭɫɬɚɧɨɜɤɟ ɩɚɤɟɬɚ
ɜɤɥɚɞɤɭ Into Existing Package.

Ɋɢɫ. 7. Ɋɟɞɚɤɬɨɪ ɩɚɤɟɬɨɜ

ȼ ɨɤɧɟ ɪɟɞɚɤɬɨɪɚ ɩɪɟɞɫɬɚɜɥɟɧ ɮɚɣɥ DPK, ɤɨɬɨɪɵɣ ɜ ɧɚɲɟɦ ɩɪɢɦɟɪɟ ɢɦɟɟɬ
ɜɢɞ:
package my_butt_pack;
{$R *.res}
{Ⱦɥɹ ɫɨɤɪɚɳɟɧɢɹ ɨɛɴɟɦɚ ɨɩɰɢɢ ɤɨɦɩɢɥɹɰɢɢ ɨɩɭɳɟɧɵ}
requires // ɬɪɟɛɭɟɦɵɟ ɛɢɛɥɢɨɬɟɤɢ
rtl, vcl;
contains // ɫɨɞɟɪɠɚɧɢɟ ɩɚɤɟɬɚ
UMyButton in 'UMyButton.pas';
end.
Ʉɧɨɩɤɚ Compile ɩɨɡɜɨɥɹɟɬ ɨɬɤɨɦɩɢɥɢɪɨɜɚɬɶ ɬɟɤɭɳɢɣ ɩɚɤɟɬ (ɫɟɤɰɢɹ
Contains) ɢ ɭɫɬɚɧɨɜɢɬɶ ɟɝɨ ɜ ɫɪɟɞɭ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɤɚɤ ɩɚɤɟɬ ɜɪɟɦɟɧɢ ɩɪɨ-
ɟɤɬɢɪɨɜɚɧɢɹ (ɤɧɨɩɤɚ Install). Ʉɧɨɩɤɚ Add ɞɨɛɚɜɥɹɟɬ ɦɨɞɭɥɶ ɜ ɩɚɤɟɬ, ɚ Remove
ɭɞɚɥɹɟɬ ɜɵɞɟɥɟɧɧɵɣ ɦɨɞɭɥɶ ɢɡ ɩɚɤɟɬɚ. Ʉɧɨɩɤɚ Option ɨɬɨɛɪɚɠɚɟɬ ɫɬɚɧɞɚɪɬ-
ɧɨɟ ɨɤɧɨ ɨɩɰɢɣ ɩɪɨɟɤɬɨɜ ɢ ɩɚɤɟɬɨɜ. Ɋɚɡɭɦɟɟɬɫɹ, ɩɨɫɥɟɞɧɢɟ ɞɟɣɫɬɜɢɹ ɥɟɝɤɨ
ɜɵɩɨɥɧɢɬɶ ɢ ɨɛɵɱɧɵɦ ɪɟɞɚɤɬɢɪɨɜɚɧɢɟɦ ɮɚɣɥɚ, ɧɚɩɪɢɦɟɪ, ɜ NotePad.

38
 ɉɪɢɦɟɱɚɧɢɟ. ȿɫɥɢ ɜɵ ɪɚɫɩɪɨɫɬɪɚɧɹɟɬɟ ɤɨɦɩɨɧɟɧɬ ɛɟɡ ɢɫɯɨɞɧɵɯ ɤɨ-
ɞɨɜ, ɬɨ ɩɨɥɶɡɨɜɚɬɟɥɹɦ ɜɚɲɟɝɨ ɤɨɦɩɨɧɟɧɬɚ ɫɥɟɞɭɟɬ ɩɟɪɟɞɚɬɶ ɮɚɣɥɵ:
– BPL-ɮɚɣɥ, ɫɨɞɟɪɠɚɳɢɣ ɤɨɦɩɨɧɟɧɬ (ɜ ɧɚɲɟɦ ɫɥɭɱɚɟ – MyButton.bpl);
– DCU-ɮɚɣɥ ɫ ɨɬɤɨɦɩɢɥɢɪɨɜɚɧɧɵɦ ɦɨɞɭɥɟɦ (UMyButton.dcu, ɫɫɵɥɤɚ
ɧɚ ɷɬɨɬ ɮɚɣɥ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɩɨɹɜɥɹɟɬɫɹ ɜ ɫɟɤɰɢɢ Uses ɦɨɞɭɥɹ ɩɪɢ ɪɚɡ-
ɦɟɳɟɧɢɢ ɤɨɦɩɨɧɟɧɬɚ ɧɚ ɮɨɪɦɟ).
ɑɬɨɛɵ ɭɫɬɚɧɨɜɢɬɶ BPL-ɩɚɤɟɬ ɜ ɫɪɟɞɭ Delphi (ɜ ɨɬɫɭɬɫɬɜɢɟ ɞɪɭɝɢɯ
ɮɚɣɥɨɜ), ɩɨɥɶɡɨɜɚɬɟɥɶ ɞɨɥɠɟɧ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɭɧɤɬ ɦɟɧɸ Component | Install
Packages, ɩɪɢ ɜɵɛɨɪɟ ɤɨɬɨɪɨɝɨ ɩɨɹɜɥɹɟɬɫɹ ɞɢɚɥɨɝɨɜɨɟ ɨɤɧɨ ɭɫɬɚɧɨɜɤɢ ɩɚ-
ɤɟɬɚ (ɪɢɫ. 8).

Ɋɢɫ. 8. Ɉɤɧɨ ɭɫɬɚɧɨɜɤɢ ɩɚɤɟɬɚ

ɋɩɢɫɨɤ Design Packages ɩɪɟɞɨɫɬɚɜɥɹɟɬ ɜɫɟ ɩɚɤɟɬɵ, ɜɤɥɸɱɟɧɧɵɟ ɜ

IDE. Ⱦɥɹ ɪɚɛɨɬɵ ɫɨ ɫɩɢɫɤɨɦ ɢɫɩɨɥɶɡɭɸɬɫɹ ɫɥɟɞɭɸɳɢɟ ɤɧɨɩɤɢ (ɬɚɛɥ. 5).

39
 Ɍɚɛɥɢɰɚ 5
Add ɂɧɫɬɚɥɥɢɪɭɟɬ ɩɚɤɟɬ ɜɪɟɦɟɧɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ (ɮɚɣɥɵ
*.bpl, ɧɚɯɨɞɹɳɢɟɫɹ ɜ ɩɚɩɤɟ ..\delphi\bin ɢɥɢ ɜ ɭɤɚɡɚɧɧɨɣ
ɜɚɦɢ ɩɚɩɤɟ). ɋɨɞɟɪɠɢɦɨɟ ɩɚɤɟɬɚ ɨɬɨɛɪɚɡɢɬɫɹ ɧɚ ɩɚɥɢɬɪɟ
ɤɨɦɩɨɧɟɧɬɨɜ ɢ ɛɭɞɟɬ ɞɨɫɬɭɩɧɨ ɜɨ ɜɫɟɯ ɩɪɨɟɤɬɚɯ
Remove ɍɞɚɥɹɟɬ ɢɡ IDE ɜɵɞɟɥɟɧɧɵɣ ɩɚɤɟɬ. Ⱦɥɹ ɭɞɚɥɟɧɢɹ ɦɨɠɧɨ ɭɛ-
ɪɚɬɶ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɣ ɮɥɚɠɨɤ. ȼɫɟ ɤɨɦɩɨɧɟɧɬɵ, ɡɚɪɟɝɢɫɬ-
ɪɢɪɨɜɚɧɧɵɟ ɜ ɩɚɤɟɬɟ, ɛɭɞɭɬ ɧɟɞɨɫɬɭɩɧɵ
Edit Ɉɬɤɪɵɜɚɟɬ ɜɵɛɪɚɧɧɵɣ ɩɚɤɟɬ ɜ Ɋɟɞɚɤɬɨɪɟ ɩɚɤɟɬɨɜ, ɟɫɥɢ ɞɨɫ-
ɬɭɩɟɧ ɟɝɨ ɢɫɯɨɞɧɵɣ ɬɟɤɫɬ
Components ɉɨɤɚɡɵɜɚɟɬ ɤɨɦɩɨɧɟɧɬɵ, ɜɤɥɸɱɟɧɧɵɟ ɜ ɞɚɧɧɵɣ ɩɚɤɟɬ

Ɏɥɚɠɨɤ Build With Runtime Packages ɭɤɚɡɵɜɚɟɬ ɧɚ ɧɟɨɛɯɨɞɢɦɨɫɬɶ ɢɫ-

ɩɨɥɶɡɨɜɚɧɢɹ ɩɚɤɟɬɨɜ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ ɩɪɢ ɫɨɡɞɚɧɢɢ EXE-ɮɚɣɥɚ. ɂɦɹ
ɬɪɟɛɭɟɦɨɝɨ ɩɚɤɟɬɚ (DCP-ɮɚɣɥɚ) ɞɨɩɢɫɵɜɚɟɬɫɹ ɜ ɫɬɪɨɤɭ ɪɟɞɚɤɬɢɪɨɜɚɧɢɹ ɢɥɢ
ɜɵɛɢɪɚɟɬɫɹ ɧɚɠɚɬɢɟɦ ɤɧɨɩɤɢ Add. (ɂɡ-ɡɚ ɨɝɪɚɧɢɱɟɧɧɨɫɬɢ ɨɛɴɟɦɚ ɩɨɫɨɛɢɹ
ɜɨɩɪɨɫɵ ɢɫɩɨɥɶɡɨɜɚɧɢɹ Runtime Packages ɡɞɟɫɶ ɧɟ ɪɚɫɫɦɚɬɪɢɜɚɸɬɫɹ).
ɑɬɨɛɵ ɢɫɩɨɥɶɡɨɜɚɬɶ ɬɟɤɭɳɭɸ ɤɨɧɮɢɝɭɪɚɰɢɸ ɩɚɤɟɬɨɜ ɜ ɤɚɱɟɫɬɜɟ
ɤɨɧɮɢɝɭɪɚɰɢɢ ɩɨ ɭɦɨɥɱɚɧɢɸ ɞɥɹ ɜɫɟɯ ɩɪɨɟɤɬɨɜ, ɭɫɬɚɧɨɜɢɬɟ ɮɥɚɠɨɤ
Default.
ȿɫɥɢ ɠɟ ɤɨɦɩɨɧɟɧɬ ɪɚɫɩɪɨɫɬɪɚɧɹɟɬɫɹ ɜ ɢɫɯɨɞɧɵɯ ɤɨɞɚɯ, ɬɨ ɩɨɥɶɡɨ-
ɜɚɬɟɥɸ ɜɦɟɫɬɨ .bpl ɫɥɟɞɭɟɬ ɩɪɟɞɨɫɬɚɜɢɬɶ ɮɚɣɥɵ .pas ɢ, ɜɨɡɦɨɠɧɨ,
.dpk ɢ .dcr.

3.7. Ɋɟɫɭɪɫ ɤɨɦɩɨɧɟɧɬɚ

ɋɭɳɟɫɬɜɭɟɬ ɢ ɞɨɩɨɥɧɢɬɟɥɶɧɚɹ ɡɚɞɚɱɚ, ɜɵɩɨɥɧɹɟɦɚɹ ɜ ɩɪɨɰɟɫɫɟ ɭɫɬɚ-
ɧɨɜɤɢ. Ʉɨɝɞɚ ɭɫɬɚɧɚɜɥɢɜɚɟɬɫɹ ɤɨɦɩɨɧɟɧɬ, Delphi ɩɪɨɫɦɚɬɪɢɜɚɟɬ ɤɚɬɚɥɨɝɢ,
ɩɟɪɟɱɢɫɥɟɧɧɵɟ ɜ ɩɭɬɢ ɩɨɢɫɤɚ, ɩɵɬɚɹɫɶ ɨɛɧɚɪɭɠɢɬɶ ɮɚɣɥ, ɢɦɟɸɳɢɣ ɬɨ ɠɟ
ɫɚɦɨɟ ɢɦɹ, ɱɬɨ ɢ ɦɨɞɭɥɶ, ɧɨ ɫ ɪɚɫɲɢɪɟɧɢɟɦ. dcr. Ɋɚɫɲɢɪɟɧɢɟ dcr – ɷɬɨ
ɫɨɤɪɚɳɟɧɢɟ ɨɬ Delphi Component Resource, ɢ ɮɚɣɥɵ dcr ɧɚ ɫɚɦɨɦ ɞɟɥɟ ɹɜ-
40
ɥɹɸɬɫɹ ɮɚɣɥɚɦɢ ɪɟɫɭɪɫɨɜ Windows. ȿɫɥɢ ɮɚɣɥ ɪɟɫɭɪɫɚ ɞɥɹ ɭɫɬɚɧɚɜɥɢɜɚɟ-
ɦɨɝɨ ɤɨɦɩɨɧɟɧɬɚ ɧɚɣɞɟɧ, ɬɨ ɟɝɨ ɫɨɞɟɪɠɢɦɨɟ ɬɚɤɠɟ ɫɜɹɡɵɜɚɟɬɫɹ ɫ ɛɢɛɥɢɨ-
ɬɟɤɨɣ ɤɨɦɩɨɧɟɧɬɨɜ. Ƚɥɚɜɧɚɹ ɰɟɥɶ ɮɚɣɥɚ ɪɟɫɭɪɫɚ ɤɨɦɩɨɧɟɧɬɚ ɡɚɤɥɸɱɚɟɬɫɹ ɜ
ɡɚɞɚɧɢɢ ɪɚɫɬɪɨɜɵɯ ɢɡɨɛɪɚɠɟɧɢɣ (ɩɢɤɬɨɝɪɚɦɦ), ɩɪɟɞɫɬɚɜɥɹɸɳɢɯ ɤɨɦɩɨ-
ɧɟɧɬɵ ɜ ɩɚɥɢɬɪɟ.
Ⱦɥɹ ɫɨɡɞɚɧɢɹ dcr-ɮɚɣɥɨɜ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ɩɪɨɝɪɚɦɦɭ Image
Editor, ɩɨɫɬɚɜɥɹɟɦɭɸ ɜɦɟɫɬɟ ɫ Delphi. ȼ ɦɟɧɸ ɩɪɨɝɪɚɦɦɵ ɜɵɛɟɪɢɬɟ File |
New | Component Resource File (.dcr). Ⱦɚɥɟɟ ɜ ɦɟɧɸ ɜɵɛɟɪɢɬɟ Resource |
New | Bitmap. ȼ ɞɢɚɥɨɝɨɜɨɦ ɨɤɧɟ ɩɚɪɚɦɟɬɪɨɜ ɪɚɫɬɪɨɜɨɝɨ ɢɡɨɛɪɚɠɟɧɢɹ ɡɚ-
ɞɚɣɬɟ ɪɚɡɦɟɪ 24×24 ɩɢɤɫɟɥɹ ɢ ɪɟɠɢɦ VGA (16 colors). ɇɚɪɢɫɭɣɬɟ ɬɪɟɛɭɟ-
ɦɭɸ ɩɢɤɬɨɝɪɚɦɦɭ. ɇɢɠɧɢɣ ɥɟɜɵɣ ɩɢɤɫɟɥɶ ɜ ɪɚɫɬɪɨɜɨɦ ɢɡɨɛɪɚɠɟɧɢɢ ɫɥɭ-
ɠɢɬ ɜ ɤɚɱɟɫɬɜɟ ɢɧɞɢɤɚɬɨɪɚ ɩɪɨɡɪɚɱɧɨɝɨ ɰɜɟɬɚ. ȼɫɟ ɞɪɭɝɢɟ ɩɢɤɫɟɥɢ ɛɢɬɨɜɨ-
ɝɨ ɢɡɨɛɪɚɠɟɧɢɹ ɫ ɬɚɤɢɦ ɠɟ ɰɜɟɬɨɦ ɛɭɞɭɬ ɤɚɡɚɬɶɫɹ ɩɪɨɡɪɚɱɧɵɦɢ.
ɂɦɹ ɩɢɤɬɨɝɪɚɦɦɵ ɞɨɥɠɧɨ ɫɨɜɩɚɞɚɬɶ ɫ ɢɦɟɧɟɦ ɤɥɚɫɫɚ ɤɨɦɩɨɧɟɧɬɚ,
ɧɨ ɡɚɩɢɫɚɧɨ ɩɪɨɩɢɫɧɵɦɢ ɛɭɤɜɚɦɢ. ȼ ɧɚɲɟɦ ɫɥɭɱɚɟ ɩɟɪɟɢɦɟɧɭɣɬɟ
Bitmap1 ɧɚ TMYBUTTON. ɗɬɨ ɢɡɨɛɪɚɠɟɧɢɟ ɧɭɠɧɨ ɫɨɯɪɚɧɢɬɶ ɜ ɩɚɩɤɟ, ɜ
ɤɨɬɨɪɨɣ ɧɚɯɨɞɢɬɫɹ ɦɨɞɭɥɶ ɤɨɦɩɨɧɟɧɬɚ, ɫ ɢɦɟɧɟɦ, ɫɨɜɩɚɞɚɸɳɢɦ ɫ ɢɦɟɧɟɦ
ɦɨɞɭɥɹ ɤɨɦɩɨɧɟɧɬɚ ɢ c ɪɚɫɲɢɪɟɧɢɟɦ. dcr – UMYBUTTON.DCR. Ⱦɥɹ ɧɚ-
ɞɟɠɧɨɫɬɢ ɞɨɛɚɜɶɬɟ ɫɬɪɨɱɤɭ {$R 'UMYBUTTON.DCR'} ɜ ɬɟɤɫɬ dpk-
ɮɚɣɥɚ:
package my_butt_pack;
{$R *.res}
{$R 'UMYBUTTON.DCR'}
…
ɉɨɫɥɟ ɷɬɨɝɨ ɩɨɬɪɟɛɭɟɬɫɹ ɬɨɥɶɤɨ ɭɫɬɚɧɨɜɢɬɶ ɤɨɦɩɨɧɟɧɬ ɜ ɧɭɠɧɵɣ ɩɚ-
ɤɟɬ ɧɚ ɧɭɠɧɭɸ ɩɚɥɢɬɪɭ. ȿɫɥɢ ɮɚɣɥ ɪɟɫɭɪɫɚ ɧɨɜɵɯ ɤɨɦɩɨɧɟɧɬɨɜ ɧɟ ɫɨɡɞɚɧ,
ɬɨ Delphi ɛɭɞɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɪɚɫɬɪɨɜɨɟ ɢɡɨɛɪɚɠɟɧɢɟ ɩɪɟɞɤɚ, ɟɫɥɢ ɬɚɤɨɜɨɟ
ɢɦɟɟɬɫɹ, ɢɥɢ ɢɡɨɛɪɚɠɟɧɢɟ ɩɨ ɭɦɨɥɱɚɧɢɸ.

41
 4. ɉɪɢɦɟɪɵ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ

4.1. Ʉɨɦɩɨɧɟɧɬ, ɧɚɫɥɟɞɧɢɤ ɤɥɚɫɫɚ TGraphicControl

ȼ ɤɚɱɟɫɬɜɟ ɛɨɥɟɟ ɫɥɨɠɧɨɝɨ ɩɪɢɦɟɪɚ ɫɨɡɞɚɞɢɦ ɤɨɦɩɨɧɟɧɬ Gr, ɩɪɟɞɧɚ-
ɡɧɚɱɟɧɧɵɣ ɞɥɹ ɪɢɫɨɜɚɧɢɹ ɝɪɚɮɢɤɚ ɮɭɧɤɰɢɢ y=a*x*x ɜ ɨɤɧɟ
(x1,y1,x2,y2).
ȼɵɛɨɪ ɤɥɚɫɫɚ-ɩɪɟɞɤɚ ɨɩɪɟɞɟɥɹɟɬɫɹ ɬɟɦ, ɱɬɨ ɞɥɹ ɞɚɧɧɨɝɨ ɤɨɦɩɨɧɟɧɬɚ
ɬɪɟɛɭɟɬɫɹ ɜɨɡɦɨɠɧɨɫɬɶ ɪɢɫɨɜɚɧɢɹ, ɧɨ ɧɟ ɧɭɠɟɧ ɮɨɤɭɫ ɜɜɨɞɚ. ɉɭɛɥɢɤɭɟ-
ɦɵɦɢ ɫɜɨɣɫɬɜɚɦɢ ɞɨɥɠɧɵ ɛɵɬɶ ɤɨɷɮɮɢɰɢɟɧɬ a ɢ ɤɨɨɪɞɢɧɚɬɵ
x1,y1,x2,y2. ɇɢɠɟ ɩɪɢɜɟɞɟɧɨ ɨɩɢɫɚɧɢɟ ɤɥɚɫɫɚ TGr, ɨɩɪɟɞɟɥɹɸɳɟɝɨ ɬɚ-
ɤɨɣ ɤɨɦɩɨɧɟɧɬ [3].

unit UGr;
interface
uses Windows, Messages, SysUtils, Classes,
Controls,Graphics;
type
TGr = class(TGraphicControl)
private
FPen:TPen;
FBrush:TBrush;
Fx1,Fy1,Fx2,Fy2:real;//ɤɨɨɪɞɢɧɚɬɵ ɨɤɧɚ
Fa:real; //ɤɨɷɮɮɢɰɢɟɧɬ ɮɭɧɤɰɢɢ
function II(x:real):Integer; //ɩɟɪɟɜɨɞ ɪɟɚɥɶɧɨɣ ɤɨɨɪɞɢɧɚɬɵ x
//ɜ ɷɤɪɚɧɧɭɸ
function JJ(y:real):Integer; //ɩɟɪɟɜɨɞ ɪɟɚɥɶɧɨɣ ɤɨɨɪɞɢɧɚɬɵ
// y ɜ ɷɤɪɚɧɧɭɸ
function F(x:real):real; //ɮɭɧɤɰɢɹ, ɨɩɪɟɞɟɥɹɸɳɚɹ ɝɪɚɮɢɤ
procedure SetX1(Value:real); //ɭɫɬɚɧɨɜɤɚ ɤɨɨɪɞɢɧɚɬɵ x1
procedure SetY1(Value:real); //ɭɫɬɚɧɨɜɤɚ ɤɨɨɪɞɢɧɚɬɵ y1
procedure SetX2(Value:real); //ɭɫɬɚɧɨɜɤɚ ɤɨɨɪɞɢɧɚɬɵ x2
procedure SetY2(Value:real); //ɭɫɬɚɧɨɜɤɚ ɤɨɨɪɞɢɧɚɬɵ y2

42
 procedure SetA(Value:real); //ɭɫɬɚɧɨɜɤɚ ɤɨɷɮɮɢɰɢɟɧɬɚ a
procedure SetBrush(Value:TBrush); //ɭɫɬɚɧɨɜɤɚ ɤɢɫɬɢ
procedure SetPen(Value:TPen); //ɭɫɬɚɧɨɜɤɚ ɩɟɪɚ
protected
{ Protected declarations }
public
{ Public declarations }
constructor Create(AOwner:TComponent);override;
destructor Destroy;override;
procedure Paint;override;//ɩɟɪɟɪɢɫɨɜɤɚ
published
procedure StyleChanged(Sender: TObject); dynamic;

//ɩɭɛɥɢɤɭɟɦɵɟ ɫɜɨɣɫɬɜɚ: ɧɚɫɥɟɞɭɟɦɵɟ

property Align;
property Anchors;
property DragCursor;
property DragKind;
property DragMode;
property Enabled;
property Constraints;
property ParentShowHint;
property ShowHint;
property Visible;

//ɩɭɛɥɢɤɭɟɦɵɟ ɫɜɨɣɫɬɜɚ: ɫɨɛɫɬɜɟɧɧɵɟ

property Pen:TPen read FPen write SetPen
property Brush:TBrush read FBrush write SetBrush;
property x1:real read FX1 write SetX1;
property x2:real read FX2 write SetX2;
property Y1:real read FY1 write SetY1;
property Y2:real read FY2 write SetY2;
property A:real read FA write SetA;

//ɩɭɛɥɢɤɭɟɦɵɟ ɧɚɫɥɟɞɭɟɦɵɟ ɫɨɛɵɬɢɹ

property OnDragDrop;

43
 property OnDragOver;
property OnEndDrag;
property OnMouseDown;
property OnMouseMove;
property OnMouseUp;
property OnStartDock;
property OnStartDrag;
end;

procedure Register;

implementation

// ɤɨɧɫɬɪɭɤɬɨɪ
constructor TGr.Create(AOwner:TComponent);
begin
inherited Create(AOwner);
ControlStyle:= ControlStyle+[csReplicatable];
FX1:= –1;
FX2:=10;
FY1:= –1;
FY2:=10;
Fa:=1;
Left:=10;
Top:=10;
Width:=300;
Height:=200;
FPen:=TPen.Create;
FPen.OnChange:=StyleChanged;
FBrush:=TBrush.Create;
FBrush.OnChange:=StyleChanged;
end;

// ɭɫɬɚɧɨɜɤɚ ɤɨɨɪɞɢɧɚɬɵ x1
procedure TGr.SetX1(Value:real);
begin

44
 if FX1<>Value then
begin
FX1:=Value;
Paint;
end;
end;

// ɭɫɬɚɧɨɜɤɚ ɤɨɨɪɞɢɧɚɬɵ y1
procedure TGr.SetY1(Value:real);
begin
if FY1<>Value then
begin
FX1:=Value;
Paint;
end;
end;

// ɭɫɬɚɧɨɜɤɚ ɤɨɨɪɞɢɧɚɬɵ x2
procedure TGr.SetX2(Value:real);
begin
if FX2<>Value then
begin
FX2:=Value;
Paint;
end;
end;
// ɭɫɬɚɧɨɜɤɚ ɤɨɨɪɞɢɧɚɬɵ y2
procedure TGr.SetY2(Value:real);
begin
if FY2<>Value then
begin
FY2:=Value;
Paint;
end;
end;

45
 // ɭɫɬɚɧɨɜɤɚ ɤɨɷɮɮɢɰɢɟɧɬɚ a
procedure TGr.SetA(Value:real);
begin
if FA<>Value then
begin
FA:=Value;
Paint;
end;
end;
// ɭɫɬɚɧɨɜɤɚ ɤɢɫɬɢ
procedure TGr.SetBrush(Value:TBrush);
begin
if FBrush<>Value then
begin
FBrush:=Value;
Paint;
end;
end;
// ɭɫɬɚɧɨɜɤɚ ɩɟɪɚ
procedure TGr.SetPen(Value:TPen);
begin
if FPen<>Value then
begin
FPen:=Value;
Paint;
end;
end;

//ɜɵɱɢɫɥɟɧɢɟ ɷɤɪɚɧɧɨɣ ɤɨɨɪɞɢɧɚɬɵ II ɞɥɹ ɪɟɚɥɶɧɨɣ ɤɨɨɪɞɢɧɚɬɵ x

function TGr.II(x:real):Integer;
begin
Result:=Round((x-FX1)*Width/(FX2-FX1));
end;

46
//ɜɵɱɢɫɥɟɧɢɟ ɷɤɪɚɧɧɨɣ ɤɨɨɪɞɢɧɚɬɵ JJ ɞɥɹ ɪɟɚɥɶɧɨɣ ɤɨɨɪɞɢɧɚɬɵ y
function TGr.JJ(y:real):Integer;
begin
Result:=Height-Round((y-FY1)*Height/(FY2-FY1));
end;

//ɮɭɧɤɰɢɹ, ɨɩɪɟɞɟɥɹɸɳɚɹ ɝɪɚɮɢɤ

function TGr.F(x:real):real;
begin
Result:=Fa*x*x;
end;

//ɞɟɫɬɪɭɤɬɨɪ
destructor TGr.Destroy;
begin
FPen.Free;
FBrush.Free;
inherited destroy;
end;

//ɩɟɪɟɪɢɫɨɜɤɚ ɤɨɦɩɨɧɟɧɬɚ
procedure TGr.Paint;
const
n=60;//ɤɨɥɢɱɟɫɬɜɨ ɬɨɱɟɤ, ɩɨ ɤɨɬɨɪɵɦ ɫɬɪɨɢɬɫɹ ɝɪɚɮɢɤ
var
I : integer;
h,x : real;
begin
h:=(X2-X1)/n;//ɲɚɝ ɢɡɦɟɧɟɧɢɹ ɚɪɝɭɦɟɧɬɚ ɮɭɧɤɰɢɢ
with Canvas do
begin
//ɪɢɫɨɜɚɧɢɟ ɨɫɟɣ ɤɨɨɪɞɢɧɚɬ
Rectangle(0,0,Width,height);
MoveTo(II(X1),JJ(0));

47
 LineTo(II(X2),JJ(0));
MoveTo(II(0),JJ(Y1));
LineTo(II(0),JJ(Y2));
//ɤɪɢɜɚɹ ɥɢɧɢɹ ɝɪɚɮɢɤɚ y=F(x) ɪɢɫɭɟɬɫɹ ɤɚɤ
// ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɨɬɪɟɡɤɨɜ[x,F(x),x+h,F(x+h)]
x := X1;
MoveTo(II(x),JJ(F(x)));
for I := 1 to n do
begin
x := x+h;
LineTo(II(x),JJ(F(x)));
end;
end;
end;
{ɩɪɨɰɟɞɭɪɚ ɪɟɝɢɫɬɪɚɰɢɢ}
procedure Register;
begin
RegisterComponents('My', [TGr]);
end;
end.

48
 ɇɚ ɪɢɫ. 5 ɩɪɟɞɫɬɚɜɥɟɧ ɢɧɬɟɪɮɟɣɫ ɤɨɦɩɨɧɟɧɬɚ Gr ɜɪɟɦɟɧɢ ɩɪɨɟɤɬɢɪɨ-
ɜɚɧɢɹ.

Ɋɢɫ. 5. Ɍɟɫɬɢɪɨɜɚɧɢɟ ɤɨɦɩɨɧɟɧɬɚ Gr

4.2. Ʉɨɦɩɨɧɟɧɬ ɞɥɹ ɨɬɨɛɪɚɠɟɧɢɹ ɬɟɤɭɳɟɝɨ ɜɪɟɦɟɧɢ

Ɍɟɤɭɳɟɟ ɜɪɟɦɹ ɨɬɨɛɪɚɠɚɟɬɫɹ ɧɚ ɤɨɦɩɨɧɟɧɬɟ-ɩɨɬɨɦɤɟ TCustomLa-
bel ɩɨ ɫɨɛɵɬɢɸ OnTimer ɤɨɦɩɨɧɟɧɬɚ TTimer.
ȼɵɛɟɪɢɬɟ ɩɭɧɤɬ ɦɟɧɸ Component | New Component ɢ ɜ ɨɬɤɪɵɜɲɟɦɫɹ
ɞɢɚɥɨɝɨɜɨɦ ɨɤɧɟ ɡɚɞɚɣɬɟ ɢɦɹ ɤɨɦɩɨɧɟɧɬɚ Class Name (TTimeLabel), ɢɦɹ
ɤɨɦɩɨɧɟɧɬɚ-ɩɪɟɞɤɚ Ancestor Type (TCustomlabel), ɧɚɡɜɚɧɢɟ ɩɚɥɢɬɪɵ
(Samples) ɢ ɢɦɹ ɦɨɞɭɥɹ, ɫɨɞɟɪɠɚɳɟɝɨ ɤɨɦɩɨɧɟɧɬ (ɧɚɩɪɢɦɟɪ,
F:\IRA\TimeLabel.pas).
Ȼɭɞɟɬ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɫɨɡɞɚɧɚ ɡɚɝɨɬɨɜɤɚ ɦɨɞɭɥɹ, ɤɨɬɨɪɭɸ ɧɟɨɛɯɨɞɢɦɨ
ɨɬɪɟɞɚɤɬɢɪɨɜɚɬɶ ɫɥɟɞɭɸɳɢɦ ɨɛɪɚɡɨɦ:

49
unit TimeLabel;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls,
Forms, Dialogs, StdCtrls, extctrls;

type
TTimeLabel = class(TCustomLabel)
private
FActive: Boolean;
protected
T: Ttimer; // Ɍɚɣɦɟɪ
procedure GetTime (s: Tobject);
procedure ChangeActive(a: boolean);
public
constructor Create (Owner: Tcomponent); override;
destructor Destroy; override;
published
property Active: Boolean read FActive write ChangeActive;
property Color;
property Font;
end;

procedure Register;

implementation

procedure TTimeLabel.GetTime;
begin
// ɗɬɨɬ ɦɟɬɨɞ ɨɬɨɛɪɚɠɚɟɬ ɧɚ ɡɚɝɨɥɨɜɤɟ ɜɪɟɦɹ. ɑɬɨɛɵ ɜɫɟ
// ɪɚɛɨɬɚɥɨ, ɟɝɨ ɧɚɞɨ ɛɭɞɟɬ ɧɚɡɧɚɱɢɬɶ ɫɨɛɵɬɢɸ OnTimer
// ɬɚɣɦɟɪɚ.
if Active then

50
 Caption:=TimeToStr(Time);
end;

procedure TTimeLabel.ChangeActive;
begin
FActive:=A;
T.Enabled:=A;
Visible:=A;
end;

constructor TTimeLabel.create;
begin
Inherited create(Owner);
T:=TTimer.Create(Self);
T.Enabled:=true;
T.Interval:=1000;
// ɉɪɢɫɜɚɢɜɚɟɦ ɫɨɛɵɬɢɸ ɨɛɪɚɛɨɬɱɢɤ:
T.OnTimer:=GetTime;
FActive:=True;
Width:=50;
Height:=30;
end;

destructor TTimeLabel.destroy;
begin
T.Free;
inherited Destroy;
end;

procedure Register;
begin
RegisterComponents('Samples', [TTimeLabel]);
end;
end.

51
 Ⱦɥɹ ɬɟɫɬɢɪɨɜɚɧɢɹ ɫɨɡɞɚɣɬɟ ɧɨɜɵɣ ɩɪɨɟɤɬ, ɞɨɛɚɜɶɬɟ ɜ ɫɟɤɰɢɸ uses
ɫɫɵɥɤɭ ɧɚ ɦɨɞɭɥɶ TimeLabel ɢ ɜ ɨɛɪɚɛɨɬɱɢɤ OnCreate ɞɥɹ ɮɨɪɦɵ ɡɚ-
ɩɢɲɢɬɟ:
procedure TForm1.FormCreate(Sender: TObject);
var L: TTimeLabel;
begin
L:=TTimeLabel.Create(self);
L.Parent:=Self;
L.top:=0;
L.Left:=Clientwidth-L.width;
end;
Ⱦɥɹ ɭɫɬɚɧɨɜɤɢ ɤɨɦɩɨɧɟɧɬɚ ɜ ɫɪɟɞɭ Delphi ɜɵɛɟɪɢɬɟ ɩɭɧɤɬ ɦɟɧɸ
Component | Install Component, ɭɤɚɡɚɜ ɧɚ ɫɬɪɚɧɢɰɟ Into New Package ɢɦɹ
ɦɨɞɭɥɹ TimeLabel.pas ɢ ɢɦɹ ɩɚɤɟɬɚ TimeLabelPack.dpk.

4.3. Ʉɨɦɩɨɧɟɧɬ, ɜɵɩɨɥɧɹɸɳɢɣ ɜɵɱɢɫɥɟɧɢɹ

ɧɚɞ ɫɨɞɟɪɠɢɦɵɦ ɨɩɭɛɥɢɤɨɜɚɧɧɨɝɨ ɫɜɨɣɫɬɜɚ TStrings
ȼ ɤɚɱɟɫɬɜɟ ɩɪɟɞɤɚ ɜɵɛɟɪɟɦ TCustomGroupBox, ɤɨɬɨɪɵɣ ɛɭɞɟɬ ɞɨ-
ɩɨɥɧɢɬɟɥɶɧɨ ɫɨɞɟɪɠɚɬɶ ɤɧɨɩɤɭ btCalc ɢ ɦɟɬɤɭ lbResult ɞɥɹ ɜɵɜɨɞɚ
ɪɟɡɭɥɶɬɚɬɨɜ. ɇɚ ɦɟɬɤɟ ɛɭɞɟɬ ɨɬɨɛɪɚɠɟɧɚ ɫɭɦɦɚ ɡɧɚɱɟɧɢɣ, ɜɜɟɞɟɧɧɵɯ ɜ
ɦɧɨɝɨɫɬɪɨɱɧɨɦ ɫɜɨɣɫɬɜɟ Text ɬɢɩɚ TStrings (ɩɪɟɞɩɨɥɚɝɚɟɬɫɹ, ɱɬɨ ɤɚɠ-
ɞɨɟ ɡɧɚɱɟɧɢɟ ɡɚɧɢɦɚɟɬ ɨɞɧɭ ɫɬɪɨɤɭ).

Ɇɨɞɭɥɶ ɤɨɦɩɨɧɟɧɬɚ ɢɦɟɟɬ ɜɢɞ:

unit CalcBox;

interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls,
Forms, Dialogs, StdCtrls;
type
TCalcBox = class(TCustomGroupBox)

52
 private
FText: TStrings;
btCalc: TButton;
lbResult: TLabel;
protected
procedure SetText(value: TStrings);
procedure btCalcClick(sender: TObject);
public
{ Public declarations }
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
published
{ Published declarations }
property Caption;
property Top;
property Height;
property Width;
// ɋɜɨɣɫɬɜɨ ɤɥɚɫɫɚ TStrings
property Text: TStrings read FText write SetText;
end;

procedure Register;

implementation

constructor TCalcBox.Create(AOwner: TComponent);

begin
inherited Create(AOwner);
Width := 200; Height := 150;
caption:='ɋɭɦɦɚ';

btCalc:=TButton.Create (self);
with btCalc do begin
Width := 75; Height := 25;

53
 Parent:=Self;
Top:=120;
Left:=0;
Caption:='Calculate';
// Ⱦɟɥɟɝɢɪɭɟɦ ɦɟɬɨɞ btCalcClick ɫɨɛɵɬɢɸ OnClick
OnClick:=btCalcClick;
end;

lbResult:=TLabel.Create (self);
with lbResult do begin
Width := 75; Height := 25;
Parent:=Self;
top:=60;
Left:=0;
Caption:='';
end;
//ɋɨɡɞɚɟɦ ɩɨɬɨɦɨɤ ɚɛɫɬɪɚɤɬɧɨɝɨ ɤɥɚɫɫɚ TStrings
FText:=TStringList.create;
FText.clear;
end;

procedure TCalcBox.SetText(Value: TStrings);

begin
// Ʉɨɩɢɪɭɟɦ ɜ ɩɨɥɟ FText ɫɨɞɟɪɠɢɦɨɟ TStrings
FText.Assign(Value);
end;

procedure TCalcBox.btCalcClick(Sender: TObject);

var sum: extended;
i: integer;
begin
// ɉɨɞɫɱɢɬɵɜɚɟɦ ɫɭɦɦɭ ɜɜɟɞɟɧɧɵɯ ɡɧɚɱɟɧɢɣ
try
Sum:=0;

54
 for i:=0 to Text.Count-1 do
Sum:=Sum+ StrToFloat(Text[i]);
lbResult.Caption:=FloatToStr(Sum);
except
ShowMessage('Ɉɲɢɛɤɚ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ!');
end;
end;

destructor TCalcBox.Destroy;
begin
btCalc.free;
lbResult.Free;
inherited Destroy;
end;

procedure Register;
begin
RegisterComponents('Samples', [TCalcBox]);
end;

end.

Ɂɚɞɚɧɢɹ

ȼ ɤɚɠɞɨɦ ɡɚɞɚɧɢɢ ɬɪɟɛɭɟɬɫɹ:

– ɫɨɡɞɚɬɶ ɤɥɚɫɫ ɞɥɹ ɤɨɦɩɨɧɟɧɬɚ;
– ɫɨɡɞɚɬɶ ɬɟɫɬɢɪɭɸɳɟɟ ɩɪɢɥɨɠɟɧɢɟ;
– ɩɪɨɜɟɪɢɬɶ ɪɚɛɨɬɭ ɤɨɦɩɨɧɟɧɬɚ ɩɪɢ ɞɢɧɚɦɢɱɟɫɤɨɦ ɫɨɡɞɚɧɢɢ;
– ɭɫɬɚɧɨɜɢɬɶ ɤɨɦɩɨɧɟɧɬ;
– ɩɪɨɬɟɫɬɢɪɨɜɚɬɶ ɢɧɬɟɪɮɟɣɫ ɜɪɟɦɟɧɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ;
– ɩɨɞɝɨɬɨɜɢɬɶ ɨɬɱɟɬ.
ɋɬɪɭɤɬɭɪɚ ɨɬɱɟɬɧɨɣ ɪɚɛɨɬɵ ɞɨɥɠɧɚ ɛɵɬɶ ɩɨɫɬɪɨɟɧɚ ɩɨ ɨɛɳɟɣ ɫɯɟɦɟ.
ɋɥɟɞɭɟɬ ɨɛɪɚɬɢɬɶ ɜɧɢɦɚɧɢɟ ɧɚ ɨɬɪɚɠɟɧɢɟ ɫɥɟɞɭɸɳɟɣ ɢɧɮɨɪɦɚɰɢɢ. ȼ ɪɚɡ-

55
ɞɟɥɟ «Ⱥɧɚɥɢɡ ɡɚɞɚɱɢ» ɧɟɨɛɯɨɞɢɦɨ ɨɛɨɫɧɨɜɚɬɶ ɜɵɛɨɪ ɤɥɚɫɫɚ-ɩɪɟɞɤɚ ɤɨɦ-
ɩɨɧɟɧɬɚ, ɚ ɬɚɤɠɟ ɜɵɛɨɪ ɩɭɛɥɢɤɭɟɦɵɯ ɫɜɨɣɫɬɜ. ȼ ɪɚɡɞɟɥɟ «ɉɥɚɧ ɬɟɫɬɢɪɨɜɚ-
ɧɢɹ» ɬɪɟɛɭɟɬɫɹ ɨɩɢɫɚɧɢɟ ɤɚɤ ɢɧɬɟɪɮɟɣɫɚ ɜɪɟɦɟɧɢ ɜɵɩɨɥɧɟɧɢɹ, ɬɚɤ ɢ ɢɧ-
ɬɟɪɮɟɣɫɚ ɜɪɟɦɟɧɢ ɩɪɨɟɤɬɢɪɨɜɚɧɢɹ.
1. ɋɢɫɬɟɦɧɵɟ ɱɚɫɵ.
2. ɋɢɫɬɟɦɧɚɹ ɞɚɬɚ.
3. Ⱥɬɪɢɛɭɬɵ ɮɚɣɥɚ.
4. ɇɟɩɪɹɦɨɭɝɨɥɶɧɚɹ ɤɧɨɩɤɚ.
5. ɉɟɪɟɦɟɳɚɟɦɚɹ ɤɧɨɩɤɚ.
6. Ƚɪɚɮɢɤ ɮɭɧɤɰɢɢ:
ɚ) ɮɭɧɤɰɢɹ ɡɚɞɚɧɚ ɬɚɛɥɢɱɧɨ;
ɛ) ɡɧɚɱɟɧɢɹ ɚɪɝɭɦɟɧɬɨɜ ɢ ɮɭɧɤɰɢɢ ɡɚɞɚɧɵ ɜ ɮɚɣɥɟ;
ɜ) ɮɭɧɤɰɢɹ ɜɵɛɢɪɚɟɬɫɹ ɢɡ ɡɚɞɚɧɧɨɝɨ ɤɚɤ ɩɟɪɟɱɢɫɥɢɦɵɣ ɬɢɩ ɫɩɢɫɤɚ.
7. ɇɟɩɪɹɦɨɭɝɨɥɶɧɨɟ ɢɡɨɛɪɚɠɟɧɢɟ.
8. ȼɢɡɭɚɥɶɧɨɟ ɛɢɧɚɪɧɨɟ ɞɟɪɟɜɨ.
9. ȼɢɡɭɚɥɶɧɵɣ ɝɪɚɮ.
10. ɋɬɨɥɛɢɤɨɜɚɹ ɞɢɚɝɪɚɦɦɚ.
11. Ʉɪɭɝɨɜɚɹ ɞɢɚɝɪɚɦɦɚ.
12. Ʌɢɧɟɣɱɚɬɚɹ ɞɢɚɝɪɚɦɦɚ.
13. ɉɨ ɞɚɬɟ ɨɩɪɟɞɟɥɢɬɶ ɡɧɚɤ ɡɨɞɢɚɤɚ ɢ «ɡɜɟɪɹ».
14. ɉɨ ɞɚɬɟ ɨɩɪɟɞɟɥɢɬɶ ɞɟɧɶ ɧɟɞɟɥɢ.
15. ɋɭɦɦɚ ɞɜɭɯ ɩɨɥɢɧɨɦɨɜ.
16. Ɂɧɚɱɟɧɢɟ ɩɨɥɢɧɨɦɚ.
17. ɉɪɨɢɡɜɟɞɟɧɢɟ ɞɜɭɯ ɩɨɥɢɧɨɦɨɜ.
18. ɋɤɚɥɹɪɧɨɟ ɩɪɨɢɡɜɟɞɟɧɢɟ ɞɜɭɯ ɩɨɥɢɧɨɦɨɜ.
19. Ʉɨɦɩɨɧɟɧɬ «ɉɥɨɬɧɨɫɬɢ ɪɚɫɩɪɟɞɟɥɟɧɢɹ ɜɟɪɨɹɬɧɨɫɬɟɣ».
20. Ʉɨɦɩɨɧɟɧɬ «ɋɩɥɚɣɧɵ».
21. Ʉɨɦɩɨɧɟɧɬ «StringGrid + ComboBox».

56
 Ʌɢɬɟɪɚɬɭɪɚ

1. Ⱥɥɟɤɫɚɧɞɪɨɜɫɤɢɣ Ⱥ. Ⱦ. Delphi 5.0. Ɋɚɡɪɚɛɨɬɤɚ ɤɨɪɩɨɪɚɬɢɜɧɵɯ ɩɪɢɥɨɠɟ-

ɧɢɣ / Ⱥ.Ⱦ. Ⱥɥɟɤɫɚɧɞɪɨɜɫɤɢɣ. – Ɇ. : ȾɆɄ, 2000. – 512 ɫ.
2. Ʉɨɧɨɩɤɚ Ɋ. ɋɨɡɞɚɧɢɟ ɨɪɢɝɢɧɚɥɶɧɵɯ ɤɨɦɩɨɧɟɧɬɨɜ ɜ ɫɪɟɞɟ DELPHI /
Ɋ. Ʉɨɧɨɩɤɚ. – Ʉɢɟɜ : ɇɂɉɎ – ȾɢɚɋɨɮɬɅɬɞ, 1996. – 512 ɫ.
3. Ɇɟɬɨɞɢɱɟɫɤɢɟ ɭɤɚɡɚɧɢɹ ɤ ɤɭɪɫɭ «ȼɢɡɭɚɥɶɧɨɟ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɟ ɜ Del-
phi». Ɉɛɴɟɤɬɧɨ-ɨɪɢɟɧɬɢɪɨɜɚɧɧɨɟ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɟ. ɋɨɡɞɚɧɢɟ ɧɨɜɨɝɨ
ɤɨɦɩɨɧɟɧɬɚ / ɫɨɫɬ. : ɇ.Ⱥ. Ɍɸɤɚɱɟɜ, ȼ.Ƚ. Ɋɭɞɚɥɟɜ, Ɇ.ȼ. Ȼɚɤɥɚɧɨɜ. – ȼɨɪɨ-
ɧɟɠ: ɅɈɉ ȼȽɍ, 1999. – 34 ɫ.
4. Ʉɷɧɬɭ Ɇ. Delphi 7 ɞɥɹ ɩɪɨɮɟɫɫɢɨɧɚɥɨɜ / Ɇ. Ʉɷɧɬɭ. – ɋɉɛ. : ɉɢɬɟɪ, 2004. –
1101 ɫ.
5. Ɍɟɣɤɫɟɣɪɚ ɋ. Delphi 5. Ɋɭɤɨɜɨɞɫɬɜɨ ɪɚɡɪɚɛɨɬɱɢɤɚ / ɋ. Ɍɟɣɤɫɟɣɪɚ, Ʉ. ɉɚ-
ɱɟɤɨ. – Ɇ. : ȼɢɥɶɹɦɫ, 2000. – Ɍ. 2 : Ɋɚɡɪɚɛɨɬɤɚ ɤɨɦɩɨɧɟɧɬɨɜ ɢ ɩɪɨɝɪɚɦɦɢ-
ɪɨɜɚɧɢɟ ɛɚɡ ɞɚɧɧɵɯ. – 992 ɫ.

57
 ɍɱɟɛɧɨɟ ɢɡɞɚɧɢɟ

ɊȺɁɊȺȻɈɌɄȺ ɄɈɆɉɈɇȿɇɌɈȼ ȼ DELPHI

ɍɱɟɛɧɨ-ɦɟɬɨɞɢɱɟɫɤɨɟ ɩɨɫɨɛɢɟ ɞɥɹ ɜɭɡɨɜ

ɋɨɫɬɚɜɢɬɟɥɢ:
ȼɨɳɢɧɫɤɚɹ Ƚɢɥɶɞɚ ɗɞɝɚɪɨɜɧɚ,
Ɋɭɞɚɥɟɜ ȼɚɥɟɪɢɣ Ƚɟɧɧɚɞɶɟɜɢɱ,
Ⱥɪɬɟɦɨɜ Ɇɢɯɚɢɥ Ⱥɧɚɬɨɥɶɟɜɢɱ

Ɋɟɞɚɤɬɨɪ Ɉ.Ⱥ. ɂɫɚɟɜɚ

ɉɨɞɩɢɫɚɧɨ ɜ ɩɟɱɚɬɶ 27.09.07. Ɏɨɪɦɚɬ 60×84/16. ɍɫɥ. ɩɟɱ. ɥ. 3,4.

Ɍɢɪɚɠ 50 ɷɤɡ. Ɂɚɤɚɡ 2003.

ɂɡɞɚɬɟɥɶɫɤɨ-ɩɨɥɢɝɪɚɮɢɱɟɫɤɢɣ ɰɟɧɬɪ
ȼɨɪɨɧɟɠɫɤɨɝɨ ɝɨɫɭɞɚɪɫɬɜɟɧɧɨɝɨ ɭɧɢɜɟɪɫɢɬɟɬɚ.
394000, ɝ. ȼɨɪɨɧɟɠ, ɩɥ. ɢɦ. Ʌɟɧɢɧɚ, 10. Ɍɟɥ. 208-298, 598-026 (ɮɚɤɫ)
http://www.ppc.vsu.ru; e-mail: pp_center@typ.vsu.ru

Ɉɬɩɟɱɚɬɚɧɨ ɜ ɬɢɩɨɝɪɚɮɢɢ ɂɡɞɚɬɟɥɶɫɤɨ-ɩɨɥɢɝɪɚɮɢɱɟɫɤɨɝɨ ɰɟɧɬɪɚ

ȼɨɪɨɧɟɠɫɤɨɝɨ ɝɨɫɭɞɚɪɫɬɜɟɧɧɨɝɨ ɭɧɢɜɟɪɫɢɬɟɬɚ.
394000, ɝ. ȼɨɪɨɧɟɠ, ɭɥ. ɉɭɲɤɢɧɫɤɚɹ, 3. Ɍɟɥ. 204-133.

58