Thực đơn
trang chủMicrosoft

Tạo, xóa và kiểm tra sự hiện diện của một thư mục trong Delphi. Hướng dẫn tạo các thành phần của riêng bạn trong Delphi

Biểu mẫu "Giới thiệu" được sử dụng cho mục đích thông tin. Thông thường nó chứa tên của chương trình, mục đích, tác giả và thỏa thuận cấp phép. Thông thường nó nằm trong menu chính trong Trợ giúp->Giới thiệu về chương trình....

Để tạo biểu mẫu "Giới thiệu" trong Delphi (Delphi, Delphi), bạn cần tạo biểu mẫu thông thường, như trong hình bên dưới:

Để tạo bất kỳ biểu mẫu nào trong Delphi 7, chúng tôi sử dụng lệnh sau từ menu Tệp->Mới->Biểu mẫu và khi phát triển dự án trong môi trường mới hơn, ví dụ Delphi XE2, bạn cần sử dụng lệnh hơi khác: Tệp- >Mới->Biểu mẫu VCL - Delphi .

Sau khi tạo biểu mẫu, bạn cần đặt các kích thước được yêu cầu và nên thực hiện các cài đặt sau:

  • Đặt thuộc tính Vị trí. Giá trị mặc định ở đây là poDesigned, cho biết biểu mẫu mở ra sẽ xuất hiện ở vị trí khi chương trình được tạo. Do đó, bạn cần đặt nó sao cho biểu mẫu xuất hiện ở giữa so với biểu mẫu mà nó được gọi. Để thực hiện việc này, hãy đặt thuộc tính Vị trí thành poOwnerFormCenter.
  • Bạn cũng có thể tắt thuộc tính AutoScroll để ngăn thanh cuộn xuất hiện.
  • Vì biểu mẫu sẽ chứa thông tin tĩnh ngắn gọn nên không cần phải thay đổi kích thước biểu mẫu khi chạy. Do đó, hãy đặt thuộc tính BorderStyle thành bsSingle.
  • Bạn cũng cần định cấu hình các thuộc tính lồng nhau trong BorderIcons. Bạn cần đặt thuộc tính biMinimize và biMaximize thành false, điều này sẽ không cho phép bạn thu nhỏ và mở rộng biểu mẫu tương ứng.

Ngoài tất cả các cài đặt được mô tả, bạn cũng có thể trang trí biểu mẫu bằng nền. Để thực hiện việc này, bạn cần đặt Hình ảnh từ bảng thành phần, nằm trong tab Bổ sung nếu bạn đang viết bằng Delphi 7. Trong thuộc tính, bạn cần đặt ngay giá trị alClient, giá trị này sẽ kéo dài vùng chứa cho hình ảnh đến toàn bộ biểu mẫu.

Ngoài ra, khi sử dụng TLabel, bạn có thể đặt Transparent thành true. Tùy chọn này sẽ làm cho nền của nhãn trong suốt, trông sẽ đẹp hơn nhiều nếu sử dụng nền phụ.

Phần kết luận

Tôi nghĩ tôi sẽ kết thúc bài viết này ở đây. Tài liệu này sẽ hữu ích cho những người mới bắt đầu lập trình Delphi hoặc đơn giản là những người quan tâm đến việc viết chương trình. Nếu bạn gặp bất kỳ khó khăn nào, hãy viết bình luận và ngay khi có thể, tôi sẽ giúp bạn bằng cách sử dụng biểu mẫu “Giới thiệu về chương trình” ở Delphi. Tôi cũng đã đăng một dự án thử nghiệm trong kho lưu trữ với biểu mẫu này và lời gọi của nó từ một biểu mẫu khác.

Tại sao tôi lại ngồi viết hướng dẫn này?

Thứ nhất, bởi vì khi tôi thực sự muốn viết phần đầu tiên của mình, tôi đã đọc hai cuốn sách và chẳng có gì thú vị cả. Sau đó, tôi đọc một cuốn sách khác (ít nhất là nó có một ví dụ hữu ích) và tôi dường như hiểu được nó. Nhưng một thành phần đơn giản như vậy đã được tháo rời nên tôi phải tự mình làm mọi thứ phức tạp hơn, đôi khi một cách ngẫu nhiên, đôi khi tôi ngồi và tìm ra nó, v.v. Kết quả là tôi đã tìm ra, đó là điều tôi mong muốn cho bạn và tôi hy vọng có thể giúp ích cho bạn với hướng dẫn này.

Tất cả các thành phần làm sẵn của tôi có thể được tìm thấy trên trang web http://MihanDelphi.narod.ru

Các thành phần dùng để làm gì?

Delphi có kiến ​​trúc mở - điều này có nghĩa là mọi lập trình viên đều có thể tự do cải thiện môi trường phát triển này theo ý muốn. Ngoài các bộ thành phần tiêu chuẩn đi kèm với Delphi, bạn có thể tạo nhiều thành phần thú vị của riêng mình để đơn giản hóa đáng kể cuộc sống của bạn (tôi đảm bảo với bạn điều này). Bạn cũng có thể truy cập một số trang web thú vị về Delphi và tải xuống một loạt các thành phần thú vị ở đó và sử dụng chúng để tạo ra một số chương trình thú vị. Các thành phần này cũng giải phóng bạn khỏi việc viết “hàng nghìn tấn quặng lời nói”. Ví dụ: bạn đã tạo một thành phần - một nút, khi nhấn vào sẽ lưu dữ liệu từ Memo vào một file tạm thời. Bây giờ, ngay khi bạn cần chức năng này, bạn chỉ cần đặt thành phần này vào biểu mẫu và tận hưởng thành quả. Và bạn sẽ không phải đăng ký điều này mỗi lần cho các chương trình mới của mình - chỉ cần sử dụng thành phần này.

Bước 1. Nảy ra ý tưởng

Bước đầu tiên là trả lời câu hỏi: “Tại sao tôi cần thành phần này và nó sẽ làm gì?” Sau đó, bạn cần suy nghĩ một cách tổng quát về các thuộc tính của nó, các sự kiện mà nó sẽ phản hồi cũng như các chức năng và thủ tục mà thành phần đó nên có. Sau đó, điều rất quan trọng là chọn “tổ tiên” của thành phần, tức là nó sẽ kế thừa lớp nào. Có hai cách ở đây. Hoặc lấy một thành phần làm sẵn làm thành phần kế thừa (nghĩa là sửa đổi một lớp đã tồn tại) hoặc tạo một lớp mới.

Để tạo một lớp mới có 4 trường hợp:

1. Tạo điều khiển Windows (TWinControl)

2. Tạo điều khiển đồ họa (TGraphicControl)

3. Tạo một lớp hoặc điều khiển mới (TCustomControl)

4. Tạo thành phần không trực quan (không hiển thị) (TComponent)

Bây giờ tôi sẽ cố gắng giải thích các thành phần trực quan và không trực quan là gì. Các thành phần trực quan hiển thị khi ứng dụng đang chạy và người dùng có thể tương tác trực tiếp với chúng, ví dụ: Nút là thành phần trực quan.

Các thành phần không trực quan chỉ hiển thị trong quá trình thiết kế ứng dụng (Thời gian thiết kế) và trong khi ứng dụng đang chạy (Thời gian chạy), chúng không hiển thị nhưng chúng có thể thực hiện một số công việc. Thành phần không trực quan được sử dụng phổ biến nhất là Bộ hẹn giờ.

Vì vậy, để bắt đầu từ lời nói đến hành động, chúng ta hãy thử tạo ra một số thành phần siêu đơn giản (chỉ nhằm mục đích làm quen với kỹ thuật tạo thành phần), và sau đó chúng ta sẽ phức tạp hóa nó.

Bước 2: Tạo một mô-đun thành phần trống

Tôi sẽ xem xét bước này dựa trên thiết bị Delphi 3; trong các phiên bản khác, quá trình này không khác nhiều. Hãy thử tạo một nút có thông tin về số lần nhấp chuột vào nút đó.

Để bắt đầu viết chính thành phần đó, bạn cần làm như sau:

    Đóng các dự án bạn đang phát triển (biểu mẫu và mô-đun)

    Từ menu chính chọn Thành phần -> Thành phần mới...

    Một hộp thoại có tên "Thành phần mới" sẽ mở ra trước mặt bạn.

    Trong trường Loại tổ tiên, chọn lớp của thành phần mà bạn muốn sửa đổi. Trong trường hợp của chúng tôi, bạn cần chọn lớp TButton

    Trong trường Tên lớp, nhập tên lớp bạn muốn nhận. Tên phải bắt đầu bằng chữ "T". Chúng tôi sẽ viết ở đó, ví dụ: TCountBtn

    Trong trường Trang bảng màu, chỉ định tên của dấu trang mà thành phần này sẽ xuất hiện sau khi cài đặt. Hãy nhập MyComponents vào đó (bây giờ bạn sẽ có tab riêng với các thành phần trong Delphi!).

    Trường Tên tệp đơn vị được điền tự động, tùy thuộc vào tên thành phần đã chọn. Đây là đường dẫn nơi mô-đun của bạn sẽ được lưu.

    Không cần thay đổi bất cứ điều gì trong trường Đường dẫn tìm kiếm.

    Bây giờ hãy nhấp vào nút Tạo đơn vị và bạn sẽ nhận được những điều sau:

đơn vị ĐếmBtn;

Công dụng

StdCtrl;

Kiểu
TCountBtn = lớp(TButton)

riêng tư
(Khai báo riêng)

được bảo vệ
(Tuyên bố được bảo vệ)

công cộng
(Tuyên bố công khai)

được phát hành
(Các tờ khai đã công bố)

Đăng ký thủ tục;

Thực hiện

Đăng ký thủ tục;
bắt đầu
RegisterComponents("MyComponents", );
kết thúc;

Bước 3. Chúng tôi bắt đầu hiểu tất cả các chỉ thị

Những gì được viết ở đây? Vâng, thực ra vẫn chưa có gì thú vị. Ở đây chúng tôi khai báo một lớp TCountBtn mới và quy trình đăng ký thành phần của bạn trong bảng thành phần.

Chỉ thị riêng Tại đây bạn sẽ viết tất cả các trường ẩn mà bạn sẽ cần để tạo thành phần. Lệnh này cũng mô tả các thủ tục và chức năng cần thiết cho hoạt động của thành phần của nó; những thủ tục và chức năng này không có sẵn cho người dùng. Đối với thành phần của chúng tôi, chúng tôi sẽ viết phần sau ở đó (mục nhập phải bao gồm chữ cái “F” của tên trường: loại của trường này):

FCount: số nguyên;

Chữ "F" phải có mặt. Ở đây chúng tôi đã tạo một trường ẩn Count, trong đó số lần nhấp vào nút sẽ được lưu trữ.

Chỉ thị Được bảo vệ. Tôi thường viết các trình xử lý sự kiện chuột và bàn phím khác nhau ở đây. Chúng ta sẽ viết dòng sau đây ở đây:

thủ tục Nhấp chuột; ghi đè;

Điều này cho biết rằng chúng tôi sẽ xử lý một cú nhấp chuột vào thành phần. Từ "ghi đè" cho biết rằng chúng tôi sẽ ghi đè sự kiện OnClick tiêu chuẩn cho thành phần tổ tiên.

Chỉ thị Public mô tả các thủ tục và chức năng của thành phần sẽ có sẵn cho người dùng. (Ví dụ khi viết code bạn viết tên thành phần, đặt dấu chấm, trước mặt là danh sách các hàm có sẵn được khai báo trong chỉ thị Public). Đối với thành phần của chúng tôi, để hiển thị nguyên tắc sử dụng lệnh này, chúng tôi sẽ tạo một hàm - ShowCount, hàm này sẽ hiển thị một thông báo, thông báo cho người dùng biết họ đã nhấp vào nút bao nhiêu lần. Để thực hiện việc này, hãy viết đoạn mã sau vào chỉ thị Public:

thủ tục ShowCount;

Chỉ thị cuối cùng còn lại được xuất bản. Nó cũng sử dụng các khai báo về các thuộc tính và phương thức mà người dùng có thể truy cập của thành phần. Để thành phần của chúng ta xuất hiện trên biểu mẫu, cần mô tả phương thức tạo thành phần (hàm tạo), bạn cũng có thể viết hàm hủy, nhưng điều này là không cần thiết. Xin lưu ý rằng nếu bạn muốn một số thuộc tính của thành phần xuất hiện trong Trình kiểm tra đối tượng, bạn cần mô tả các thuộc tính này trong chỉ thị Đã xuất bản. Việc này được thực hiện như sau: property Property_name (nhưng ở đây nhớ là không cần viết chữ “F” nữa), sau đó đặt dấu hai chấm “:” kiểu thuộc tính, đọc thủ tục đọc giá trị, viết hàm ghi giá trị;. Nhưng tất cả có vẻ rất khó hiểu. Hãy nhìn vào những gì bạn cần viết cho thành phần của chúng tôi và bạn sẽ hiểu mọi thứ:

hàm tạo Tạo (aowner:TcomComponent);ghi đè; //Người xây dựng
// Đếm thuộc tính

Vậy là tất cả các thông báo đã được đưa ra và chúng ta có thể bắt đầu viết trực tiếp tất cả các thủ tục đã khai báo.

Bước 4. Viết thủ tục và hàm.

Hãy bắt đầu bằng cách viết một hàm tạo. Nó đã được thực hiện một cái gì đó như thế này:

hàm tạo TCountBtn.Create(aowner:TcomComponent);
bắt đầu
kế thừa tạo (Chủ sở hữu);
kết thúc;

Ở đây, về nguyên tắc, bạn không cần phải hiểu gì cả. Trong tất cả các thành phần của tôi, tôi đã viết chính xác điều này (tôi chỉ thay đổi lớp thành phần và thế là xong). Bạn cũng có thể viết ra đây bất kỳ hành động nào bạn muốn thực hiện khi bắt đầu hoạt động của thành phần, tức là tại thời điểm thành phần được cài đặt trên biểu mẫu. Ví dụ: chúng ta có thể đặt giá trị ban đầu của thuộc tính Count. Nhưng chúng tôi sẽ không làm điều này.

Bây giờ chúng ta sẽ viết một thủ tục xử lý một cú click chuột vào một nút:

thủ tục Tcountbtn.Click;
bắt đầu
kế thừa;
FCount:=FCount+1;
kết thúc;

"Nhấp chuột kế thừa" có nghĩa là chúng tôi lặp lại các phương pháp xử lý nhấp chuột tiêu chuẩn (tại sao phải bận tâm và phải làm thêm :)).

Chúng ta còn một thủ tục cuối cùng: ShowCount. Nó có thể trông giống như thế này:

thủ tục TCountBtn.ShowCount;
bắt đầu

kết thúc;

Ở đây hiển thị một thông báo hiển thị số lần nhấp vào nút (ngoài ra, tên của nút này cũng được hiển thị, à, tôi thêm cái này chỉ nhằm mục đích thẩm mỹ).

Và nếu bạn hiểu mọi thứ và làm đúng, thì bạn sẽ nhận được những điều sau:

đơn vị ĐếmBtn;

Công dụng
Windows, Tin nhắn, SysUtils, Lớp học, Đồ họa, Điều khiển, Biểu mẫu, Hộp thoại,
StdCtrls, ExtCtrls;

Kiểu
TCountBtn = lớp(TButton)
riêng tư
(Khai báo riêng)
FCount: số nguyên;
được bảo vệ
(Tuyên bố được bảo vệ)
thủ tục Bấm;ghi đè;
công cộng
(Tuyên bố công khai)
thủ tục ShowCount;
được phát hành
(Các tờ khai đã công bố)
Đếm thuộc tính: số nguyên đọc FCount ghi FCount;

kết thúc;

Đăng ký thủ tục;

Thực hiện

Đăng ký thủ tục;
bắt đầu

kết thúc;


bắt đầu
kế thừa tạo (Chủ sở hữu);
kết thúc;

Thủ tục Tcountbtn.Click;
bắt đầu
kế thừa;
FCount:=FCount+1;
kết thúc;


bắt đầu
Showmessage("Trên nút "+ caption+" bạn đã thực hiện: "+inttostr(FCount)+" click(s)");
kết thúc;
kết thúc.

Lưu nhanh kẻo vô tình làm mất byte code gõ vào :)).

Bước 5. Cài đặt thành phần

Nếu bạn có thể viết và hiểu mọi thứ được đề xuất ở đây thì việc cài đặt thành phần này sẽ không gây ra bất kỳ vấn đề gì cho bạn. Mọi thứ ở đây được thực hiện rất đơn giản. Từ menu chính, chọn Thành phần -> Cài đặt Thành phần. Hộp thoại Cài đặt Thành phần sẽ mở ra trước mặt bạn. Trong đó bạn sẽ thấy hai tab: Vào gói hiện có và Vào gói mới. Bạn được lựa chọn cài đặt thành phần của mình vào gói hiện có hoặc vào gói mới tương ứng. Chúng tôi sẽ chọn từ một gói hiện có.

Trong trường Tên tệp đơn vị, hãy viết tên mô-đun đã lưu của bạn (tất nhiên, bạn cũng cần chỉ định đường dẫn đến nó) hoặc tốt hơn là sử dụng nút Duyệt qua và chọn tệp của bạn trong cửa sổ mở ra.

Bạn không cần thay đổi bất cứ điều gì trong Đường dẫn tìm kiếm; Delphi sẽ thêm mọi thứ vào đó cho bạn.

Trong trường Tên tệp gói, chọn tên gói mà thành phần của bạn sẽ được cài đặt. Chúng tôi sẽ chấp nhận gói mặc định được cung cấp.

Bây giờ hãy nhấp vào nút Ok. Và sau đó một cảnh báo xuất hiện: Gói dclusr30.dpk sẽ được xây dựng lại. Tiếp tục? Delphi hỏi: "Gói hàng như vậy sẽ được thay đổi. Tiếp tục?" Tất nhiên là bạn phải trả lời “Có”. Và nếu bạn đã làm mọi thứ chính xác, một thông báo sẽ xuất hiện cho biết thành phần của bạn đã được cài đặt. Được rồi, bạn có thể hét lên Hoan hô! Đây là thành phần đầu tiên của bạn.

Tạo thuộc tính thuộc loại của bạn

Bây giờ chúng ta sẽ cố gắng tạo một thuộc tính thuộc loại không chuẩn. Hãy xem xét điều này bằng ví dụ về nhãn - TLabel. Thành phần này có thuộc tính sau: Căn chỉnh. Nó có thể nhận các giá trị sau: taLeftJustify, taCenter, taRightJustify. Hãy bắt đầu tạo thuộc tính. Tôi không thể nghĩ ra điều gì thú vị, tuy nhiên, tôi sẽ chỉ cho bạn điều này bằng cách sử dụng ví dụ về tính chất mà tôi đã nghĩ ra. Nó rất đơn giản và sẽ giúp bạn tìm ra nó. Thuộc tính sẽ được gọi là ShowType (loại TShowTp), trong thành phần của chúng tôi, nó sẽ chịu trách nhiệm hiển thị thuộc tính Count. Nếu người dùng đặt thuộc tính ShowType thành Bình thường thì nút này sẽ hoạt động như bình thường. Và nếu người dùng gán giá trị CountToCaption cho thuộc tính này thì số lần nhấp chuột sẽ được hiển thị trên chính nút đó.

Đầu tiên chúng ta cần khai báo một kiểu mới. Mô tả loại phải được thêm vào sau từ Loại. Đây là những gì nó trông giống như lúc đầu:

kiểu
TCountBtn = lớp(TButton)

Đây là những gì nó sẽ giống:

TShowTp = (Bình thường, CountToCaption);

TCountBtn = lớp(TButton)

Ở đây chúng ta đã khai báo một kiểu TShowTp mới, kiểu này chỉ có thể nhận hai giá trị. Tất cả các giá trị bạn muốn thêm được phân tách bằng dấu phẩy.

Bây giờ chúng ta cần tạo một trường kiểu này. Chúng tôi đã biết cách thực hiện việc này và do đó sẽ không gây ra bất kỳ khó khăn nào. Trong Chỉ thị riêng viết:

FShowType:TShowTp;

Chúng tôi đã tạo trường ShowType thuộc loại TShowTp.

Tất nhiên, bạn cần thêm thuộc tính này vào trình kiểm tra đối tượng:

thuộc tính ShowType: TshowTp đọc FshowType ghi FShowType;

Và cuối cùng, để thành phần của chúng tôi phản hồi những thay đổi trong thuộc tính này của người dùng, chúng tôi cần thay đổi một chút trình xử lý sự kiện OnClick. Sau một chút sửa đổi, nó có thể trông giống như thế này:

thủ tục Tcountbtn.Click;
bắt đầu
kế thừa;
FCount:=Fcount+1;
nếu ShowType = Bình thường thì
Chú thích:=Chú thích;


kết thúc;

Tôi sẽ giải thích chuyện gì đã xảy ra. Đầu tiên chúng ta tăng bộ đếm lên một. Sau đó, chúng tôi kiểm tra xem thuộc tính ShowType có giá trị gì. Nếu Bình thường thì chúng tôi không làm gì cả, nhưng nếu CountToCaption thì chúng tôi hiển thị số lần nhấp vào nhãn trên nút. Không khó như lúc đầu.

Cấy bộ đếm thời gian vào thành phần

Điều thường xảy ra là bạn cần chèn một số thành phần khác vào một thành phần, chẳng hạn như bộ hẹn giờ. Như thường lệ, chúng ta sẽ xem xét quá trình này bằng một ví dụ cụ thể. Hãy đảm bảo rằng cứ sau 10 giây, bộ đếm lượt nhấp sẽ tăng gấp đôi. Để làm điều này, chúng tôi sẽ xây dựng bộ đếm thời gian vào nút của mình. Chúng ta cần thực hiện một vài bước đơn giản.

Sau phần sử dụng mô tả các module được thêm vào chương trình, khai báo một biến kiểu TTimer. Hãy gọi nó là Hẹn giờ. Đây là một phần nhỏ của mã:

đơn vị ĐếmBtn;

Công dụng
Windows, Tin nhắn, SysUtils, Lớp học, Đồ họa, Điều khiển, Biểu mẫu, Hộp thoại,
StdCtrls, ExtCtrls;

thủ tục OnTimer(Người gửi: TObject);

Vì bộ đếm thời gian của chúng ta không phải là một biến mà là một thành phần, nên chúng ta cũng cần tạo nó, để làm được điều này, chúng ta sẽ viết vào hàm tạo của nút:

hàm tạo TCountBtn.Create(aowner:TcomComponent);
bắt đầu
kế thừa tạo (Chủ sở hữu);
Bộ hẹn giờ:=TTimer.Create(self);
Hẹn giờ.Đã bật:=true;
Hẹn giờ.OnTimer:=OnTimer;
Bộ hẹn giờ.Interval:=10000;
kết thúc;

Ở đây, một phiên bản bộ đếm thời gian của chúng tôi được tạo và thuộc tính Iterval của nó (được đo bằng mili giây) được gán giá trị 10000 (nghĩa là 10 giây theo thuật ngữ đơn giản).

Trên thực tế, tất cả những gì còn lại là viết chính thủ tục OnTimer. Tôi đã làm nó như thế này:

thủ tục TCountBtn.OnTimer(Người gửi: TObject);
bắt đầu
FCount:=FCount*2;
kết thúc;

Đây đại khái là những gì bạn nên kết thúc với:

đơn vị ĐếmBtn;

Công dụng
Windows, Tin nhắn, SysUtils, Lớp học, Đồ họa, Điều khiển, Biểu mẫu, Hộp thoại,
StdCtrls, ExtCtrls;

Bộ đếm thời gian Var: TTimer;
kiểu
TShowTp = (Bình thường, CountToCaption);
TCountBtn = lớp(TButton)

Riêng tư
(Khai báo riêng)

FCount: số nguyên;
FShowType:TShowTp;
được bảo vệ
(Tuyên bố được bảo vệ)
thủ tục OnTimer(Người gửi: TObject);
thủ tục Bấm;ghi đè;
công cộng
(Tuyên bố công khai)
thủ tục ShowCount;
được phát hành
(Các tờ khai đã công bố)
Đếm thuộc tính: số nguyên đọc FCount ghi FCount;
hàm tạo Tạo (aowner:TcomComponent);ghi đè;
thuộc tính ShowType: TshowTp đọc FshowType ghi FShowType;
kết thúc;

Đăng ký thủ tục;

Thực hiện

Đăng ký thủ tục;
bắt đầu
RegisterComponents("Thành phần Mihan", );
kết thúc;

Trình xây dựng TCountBtn.Create(aowner:TcomComponent);
bắt đầu
kế thừa tạo (Chủ sở hữu);
Bộ hẹn giờ:=TTimer.Create(self);
Hẹn giờ.Đã bật:=false;
Hẹn giờ.OnTimer:=OnTimer;
Bộ hẹn giờ.Interval:=1000;
kết thúc;

Thủ tục Tcountbtn.Click;
bắt đầu
kế thừa;
FCount:=Fcount+1;
Hẹn giờ.Đã bật:=true;
nếu ShowType = Bình thường thì
Chú thích:=Chú thích;
nếu ShowType = CountToCaption thì
Chú thích:="Đếm= "+inttostr(đếm);
kết thúc;

Thủ tục TCountBtn.ShowCount;
bắt đầu
Showmessage("Trên nút "+ caption+" bạn đã thực hiện: "+inttostr(FCount)+" click(s)");
kết thúc;

Thủ tục TCountBtn.OnTimer(Người gửi: TObject);
bắt đầu
FCount:=FCount*2;
kết thúc;

Nếu có điều gì đó không phù hợp với bạn, thì trước tiên hãy kiểm tra xem mọi thứ có được viết chính xác không. Sau đó kiểm tra xem bạn có thiếu mô-đun nào đó trong phần Sử dụng không.

Cài đặt lại một thành phần

Rất thường xuyên cần phải cài đặt lại thành phần của bạn. Nếu bạn cố gắng thực hiện việc này bằng cách chọn Thành phần->Cài đặt Thành phần, Delphi sẽ thành thật cảnh báo bạn rằng gói đã chứa mô-đun có tên đó. Một cửa sổ chứa nội dung của gói sẽ mở ra trước mặt bạn. Trong đó, bạn phải tìm tên thành phần của mình và xóa nó (hoặc nhấp vào nút Xóa). Bây giờ thành phần của bạn không còn trong gói nữa. Sau đó làm theo quy trình tiêu chuẩn để cài đặt thành phần.

Chúc bạn lập trình thành công...

(C) Bản quyền thuộc về Mikhail Christenko! Khi đăng lên các trang khác, bắt buộc phải ghi tên tác giả và địa chỉ trang (http://delphid.dax.ru)!

Trước khi tạo thành phần, bạn cần chọn tổ tiên cho nó. Ai có thể là tổ tiên cho thành phần của bạn?

Thường được sử dụng làm tổ tiên của TComponent, TControl, TWinControl, TGraphicControl, TCustomXXXXXX, cũng như tất cả các thành phần của bảng thành phần.
Hãy lấy ví dụ về thành phần TOpenDialog, nằm trên trang Dialogs của bảng thành phần. Nó hoạt động tốt nhưng có một bất tiện nhỏ. Mỗi lần sử dụng, bạn phải thay đổi giá trị của thuộc tính Options mỗi lần. Và, như một quy luật, đây là những hành động giống nhau.
OpenDialog1.Options:= OpenDialog1.Options + ;

để tệp chúng tôi đang cố mở bằng hộp thoại này thực sự tồn tại trên đĩa.
Chúng tôi đã chọn một nhiệm vụ cho mình, tất cả những gì còn lại là tạo ra một thành phần. Chúng tôi tạo khoảng trống cho thành phần bằng cách chọn lệnh Thành phần/Thành phần mới... từ menu và chọn trong hộp thoại
Loại tổ tiên: TOpenDialog
Tên lớp: TOurOpenDialog
Trang bảng màu: Thử nghiệm của chúng tôi
Chúng tôi đã nhấp vào Ok và bây giờ chúng tôi có mẫu cho thành phần trong tương lai của mình.

Chúng tôi ghi đè hàm tạo cho thành phần này, tức là trong phần công khai chèn dòng:

hàm tạo Tạo (AOWner: TComponent); ghi đè;

Nhấp vào dòng này Ctrl + Shift + C sẽ tạo một mẫu cho phương thức này, bên trong chúng ta chèn các dòng sau:

kế thừa Tạo(AOWner); (Gọi hàm tạo được kế thừa)
Tùy chọn:= Tùy chọn + ; (Chúng tôi thực hiện các hành động chúng tôi cần)

Xin lưu ý: Phím tắt Ctrl + Shift + mũi tên lên/xuống cho phép bạn điều hướng giữa khai báo phương thức và triển khai phương thức đó.

Đang cài đặt Thành phần đã tạo/Cài đặt Thành phần...
Cài đặt vào gói mới
Tên tệp gói: C:Program FilesBorlandDelphi4LibOurTest.dpk
Mô tả gói: Gói đã được thử nghiệm của chúng tôi

Bạn không thích thành phần của chúng ta có biểu tượng giống như thành phần tiêu chuẩn sao? Sau đó, hãy tạo của riêng chúng tôi cho anh ấy.
Để làm điều này, chúng ta cần gọi Tools/Image Editor. Tạo một tệp *.dcr mới.
Chèn hình ảnh Tài nguyên/Mới/Bitmap vào đó. Đặt kích thước hình ảnh thành 24x24 pixel. Và sau đó - sự sáng tạo của bạn...
Xin lưu ý: màu của các chấm trùng với màu của chấm ở góc dưới bên trái của hình sẽ được coi là TRONG SUỐT!
Khi bạn đã tạo xong bản vẽ của mình, hãy đổi tên nó từ Bitmap1 thành TOurOpenDialog và lưu tệp dưới dạng OurOpenDialog.dcr.
Xóa thành phần khỏi gói và cài đặt lại (chỉ trong trường hợp này, liên kết đến tệp *.dcr sẽ được thêm vào).
Biên dịch, cài đặt và chúc may mắn!

đơn vị OurOpenDialog; giao diện công dụng Windows, Tin nhắn, SysUtils, Lớp học, Đồ họa, Điều khiển, Biểu mẫu, Hộp thoại; kiểu TOUROpenDialog = lớp học(TOpenDialog) riêng tư(Khai báo riêng) được bảo vệ công cộng(Tuyên bố công khai) người xây dựng Tạo (AChủ sở hữu: TComponent); ghi đè; được phát hành kết thúc; thủ tục đăng ký; thực hiện thủ tục đăng ký; bắt đầu RegisterComponents("Mẫu", ); kết thúc; (TOUROpenDialog) người xây dựng TOurOpenDialog.Create(AOwner: TComponent); bắt đầu thừa hưởng Tạo(AChủ); (Gọi hàm tạo kế thừa) Options:= Options + ; (Chúng tôi thực hiện các hành động chúng tôi cần) kết thúc; kết thúc.

Một khai báo thành phần bao gồm các phần như riêng tư, được bảo vệ, công cộng và xuất bản. Có ý nghĩa gì?
Đây là những chỉ thị về khả năng hiển thị.
Mọi thứ được khai báo trong phần riêng tư, chỉ khả dụng bên trong mô-đun mà lớp được khai báo (khai báo riêng). Ở đây, theo quy định, các biến được khai báo để lưu trữ các giá trị thuộc tính cũng như các phương thức (thủ tục hoặc hàm) để truy cập chúng.
Mọi thứ được khai báo trong phần được bảo vệ, có sẵn như trong phần riêng tư, cũng như cho các lớp con của lớp này (giao diện dành cho nhà phát triển).
Tại đây bạn có thể khai báo các phương thức truy cập các giá trị thuộc tính (nếu bạn muốn cho phép các thành phần con của mình thay đổi các phương thức này),
cũng như các thuộc tính, phương thức và sự kiện (phương thức phản ứng với sự kiện) trong các thành phần thuộc loại TCustomXXX.
Mọi thứ được khai báo trong phần công cộng, có sẵn cho bất kỳ người dùng nào của thành phần (giao diện thời gian chạy).
Các phương thức thường được khai báo ở đây. Chỉ các thuộc tính và sự kiện mới có thể được khai báo trong phần đã xuất bản (chúng được khai báo là thuộc tính).
Chúng có sẵn trong quá trình thiết kế ứng dụng (giao diện giai đoạn thiết kế).

Của cải

Loại thuộc tính khối núi- mảng Object Pascal thông thường, nhưng không giống như mảng sau, chúng có thể được lập chỉ mục không chỉ bằng các giá trị số mà còn bằng các chuỗi. Thật không may, loại thuộc tính này yêu cầu trình chỉnh sửa thuộc tính tùy chỉnh (trong Trình kiểm tra đối tượng, trình chỉnh sửa thuộc tính có một nút có ba dấu chấm […]), vì vậy trong ví dụ bên dưới thuộc tính mảng chống đỡđã công bố ở phần công cộng.

kiểu TOURComponent = lớp học(Thành phần) riêng tư( Khai báo riêng tư ) FArrayProp: mảng của số nguyên; chức năng GetArrayProp(aIndex: số nguyên): số nguyên; thủ tục SetArrayProp(aIndex: số nguyên; hằng số Giá trị: số nguyên); được bảo vệ(Tuyên bố được bảo vệ) công cộng(Tuyên bố công khai) tài sản ArrayProp: số nguyên đọc GetArrayProp viết SetArrayProp; được phát hành(Các tờ khai đã công bố) kết thúc;

Chỉ định thuộc tính

Người chỉ định mặc định chỉ định có lưu giá trị thuộc tính trong tệp biểu mẫu hay không. Nếu giá trị thuộc tính khớp với giá trị mặc định- giá trị trong tệp biểu mẫu không được lưu, nếu các giá trị không bằng - nó sẽ được lưu. Bạn có thể kiểm tra điều này bằng cách đặt thành phần trên biểu mẫu và chọn mục menu "Xem dưới dạng văn bản" bằng nút chuột phải. Mặc định không đặt giá trị ban đầu của thuộc tính thành giá trị được chỉ định. Việc này phải được thực hiện trong hàm tạo của thành phần.

đơn vị Thành phần của chúng tôi; giao diện công dụng Windows, SysUtils, Lớp, Đồ họa, Biểu mẫu, Điều khiển; kiểu TOURComponent = lớp học(Thành phần) riêng tư( Khai báo riêng ) FMyInteger: Integer; được bảo vệ(Tuyên bố được bảo vệ) công cộng(Tuyên bố công khai) người xây dựng Tạo (AChủ sở hữu: TComponent); ghi đè; được phát hành(Các tờ khai đã công bố) tài sản MyInteger: Số nguyên đọc Số nguyên FMy viết Số nguyên FMy mặc định 10; kết thúc; thực hiện người xây dựng TOurComponent.Create(AOWner: TComponent); bắt đầu thừa hưởng Tạo(AChủ); Số nguyên:= 10; kết thúc; kết thúc.

Người chỉ định không mặc định ghi đè giá trị thuộc tính mặc định. Công cụ xác định này thường được sử dụng để ghi đè giá trị mặc định của thuộc tính được kế thừa.
Ví dụ: tài sản Kich thươc tự động không mặc định;

Người chỉ định được lưu trữ chỉ định thời điểm lưu giá trị thuộc tính trong tệp biểu mẫu. Sau đó được lưu trữ có thể đứng ĐÚNG VẬY(luôn luôn lưu) SAI(không bao giờ lưu) hoặc tên của hàm trả về kết quả Boolean.

tài sản OneProp: số nguyên đọc FOneProp viết SetOneProp được lưu trữ SAI; tài sản TwoProp: số nguyên đọc FTwoProp viết SetTwoProp được lưu trữĐÚNG VẬY; tài sản ThreeProp: số nguyên đọc FThreeProp viết SetThreeProp được lưu trữĐùa;

Và điều cuối cùng:
Để thêm ảnh vào một thành phần để trình diễn trong bảng thành phần, bạn cần: - tạo ảnh có kích thước 24*24 với tên tệp.dcr (trong tài nguyên, tên của ảnh bằng tên của thành phần, viết bằng chữ in hoa)
- đặt hình ảnh bên cạnh thành phần.

  • Ôn tập
  • Quy ước đặt tên
  • Lựa chọn tổ tiên
  • Ví dụ về tạo một thành phần
  1. Ôn tập
  2. Bởi vì Delphi là một môi trường mở và cho phép bạn không chỉ sử dụng các đối tượng từ Thư viện thành phần trực quan (VCL) trong chương trình của mình mà còn có thể tạo các đối tượng mới. Hơn nữa, không có gì khác ngoại trừ Delphi được yêu cầu cho việc này. Tạo một đối tượng mới trong Delphi không phải là một nhiệm vụ quá khó khăn, mặc dù nó đòi hỏi kiến ​​thức về Windows API, lập trình hướng đối tượng và hệ thống phân cấp lớp trong VCL.

    Câu hỏi có thể nảy sinh; Nếu Delphi đã có thư viện riêng thì tại sao lại tạo bất kỳ đối tượng nào khác? Câu trả lời rất đơn giản: bạn không thể tạo một thư viện cho mọi dịp và cho mọi sở thích. Trước hết, các thành phần mới cho phép bạn mở rộng phạm vi của Delphi: ví dụ: sử dụng thư viện đối tượng của bên thứ ba để phát triển các ứng dụng làm việc trên Internet. Thứ hai, chúng cho phép bạn bổ sung hoặc tùy chỉnh các đối tượng có sẵn trong VCL (ví dụ: ghi đè các giá trị thuộc tính mặc định).

  3. Thêm đối tượng mới vào VCL
  4. Giả sử rằng bạn có một thành phần làm sẵn. Làm cách nào để thêm nó vào VCL? Để thực hiện việc này, hãy chọn mục menu Tùy chọn|Cài đặt thành phần... Một hộp thoại sẽ xuất hiện, như trong Hình 1

    Cơm. 1 : Hộp thoại cài đặt thành phần mới

    Nhấp vào “Thêm” và chỉ định mô-đun chứa quy trình đăng ký, nhấp vào “OK” và sau khi biên dịch lại thành công, đối tượng mới sẽ xuất hiện trong bảng màu.

  5. Trống cho một thành phần mới
  6. Trong môi trường Delphi, có một chuyên gia đặc biệt tạo mẫu cho một thành phần mới. Bạn có thể gọi nó trong mục menu File|New Component… (xem Hình 2)


    Cơm. 2 : Chuyên gia tạo thành phần mới

    Trong hộp thoại, bạn cần chỉ định tên của lớp mới (ví dụ: TMyButton), tổ tiên của lớp (TButton) và trang bảng màu nơi đặt thành phần mới (Mẫu). Nếu bạn nhấp vào “OK”, chuyên gia sẽ tạo một mô-đun - mẫu cho thành phần mới:

    đơn vị Đơn vị 1;

    giao diện

    công dụng

    SysUtils, WinTypes, WinProcs, Tin nhắn, Lớp học, Đồ họa, Điều khiển,

    Biểu mẫu, Hộp thoại, StdCtrls;

    kiểu

    TMyButton = lớp(TButton)

    riêng tư

    (Khai báo riêng)

    được bảo vệ

    (Tuyên bố được bảo vệ)

    công cộng

    (Tuyên bố công khai)

    được phát hành

    (Các tờ khai đã công bố)

    kết thúc;

    thủ tục Đăng ký;

    thực hiện

    thủ tục Đăng ký;

    bắt đầu

    RegisterComponents("Mẫu", );

    kết thúc;

    kết thúc.

    Mô-đun này chứa khai báo về một lớp mới và quy trình đăng ký nó trong Bảng thành phần. Trong thủ tụcĐăng kýThành phần tham số đầu tiên là tên của trang (bạn có thể chỉ định tên của mình - một trang mới sẽ xuất hiện); tham số thứ hai là tập hợp các đối tượng cần đăng ký.

    Bây giờ bạn cần lưu mô-đun dưới một tên mới (ví dụ: NEW_BTN.PAS) và bắt đầu thêm các thuộc tính và phương thức mới. Sau khi công việc này hoàn thành và thành phần mới được gỡ lỗi, bạn có thể thêm nó vào Palette (xem chương trước). Nhưng trước đó, nên tạo một tệp tài nguyên có chứa biểu tượng đại diện cho đối tượng này trong Bảng Thành phần. Tệp tài nguyên có thể được tạo bằng chương trình Resource Workshop, nó phải được đặt tên giống hệt với mô-đun đăng ký thành phần và có phần mở rộng .DCR (tức là nếu đối tượng được đăng ký trong mô-đun NEW_B TN .PAS thì tên file tài nguyên sẽ là NEW_BTN.DCR). Tệp tài nguyên phải chứa tài nguyên thuộc loại BITMAP - ảnh có kích thước 28x28 pixel (nhỏ hơn nếu có thể), tên của ảnh phải khớp với tên của lớp (trong trường hợp của chúng tôi là TMYBUTTON).

  7. Quy ước đặt tên

Nếu bạn đã xem mã nguồn VCL, bạn có thể thấy rằng nó tuân theo một vài quy ước đơn giản khi định nghĩa các lớp mới. Delphi không yêu cầu điều này, tên của các phương thức, thuộc tính, v.v. có thể là bất cứ thứ gì, trình biên dịch không quan tâm. Nhưng nếu bạn tuân theo những quy ước này thì việc phát triển các thành phần mới và đọc mã nguồn sẽ trở nên dễ dàng hơn nhiều.

Vì thế:

  • Tất cả các khai báo kiểu đều bắt đầu bằng chữ cái T. Một lần nữa, Delphi không yêu cầu điều này, nhưng điều đó cho thấy rõ ràng rằng "TEdit", chẳng hạn, là một định nghĩa kiểu, không phải là một biến hoặc trường lớp.
  • Tên thuộc tính phải dễ đọc và mang tính thông tin. Chúng ta phải nhớ rằng người dùng sẽ nhìn thấy chúng trong Trình kiểm tra đối tượng. Và cái tên như "TextOrientation" sẽ tiện lợi hơn nhiều so với "TxtOr". Điều tương tự cũng áp dụng cho các phương pháp. Các phương thức có sẵn cho người dùng phải có tên thân thiện với người dùng.
  • Khi tạo thuộc tính của loại Sự kiện, tên của thuộc tính đó phải bắt đầu bằng “Bật” (ví dụ: OnClick, OnCreate, v.v.).
  • Tên của phương thức đọc thuộc tính phải bắt đầu bằng từ “Get”. Ví dụ: phương thức GetStyle phải đọc thuộc tính Style.
  • Tên phương thức để viết thuộc tính phải bắt đầu bằng từ “Set”. Ví dụ: phương thức SetStyle phải ghi vào thuộc tính Style.
  • Trường nội bộ để lưu trữ dữ liệu thuộc tính phải có tên bắt đầu bằng chữ cái “F”. Ví dụ: thuộc tính Handle có thể được lưu trữ trong trường FHandle.

Tất nhiên, có những ngoại lệ cho các quy tắc. Đôi khi sẽ thuận tiện hơn khi chia nhỏ chúng, ví dụ, lớp TTable có các thuộc tính loại Sự kiện được gọi là BeforePost, AfterPost, v.v.

  1. Lựa chọn tổ tiên

Trước khi bắt đầu viết mã, bạn cần phải quyết định, ít nhất là gần đúng, loại thành phần nào bạn sẽ tạo ra. Tiếp theo, dựa trên các thuộc tính mong đợi của nó, xác định lớp tổ tiên. VCL có một số lớp cơ sở được khuyến nghị để kế thừa:

  • Đối tượng - Có thể được sử dụng như tổ tiên nếu thành phần này không cần phải làm việc trong quá trình thiết kế. Ví dụ, đây có thể là một lớp chứa các giá trị của biến môi trường hoặc một lớp để làm việc với các tệp INI.
  • Thành phần - Điểm khởi đầu cho nhiều thành phần vô hình. Lớp này có khả năng tích hợp sẵn để lưu/đọc chính nó vào luồng trong quá trình thiết kế.
  • Kiểm soát đồ họa - Sử dụng lớp này để tạo các thành phần hiển thị không cần tay cầm. Các thành phần như vậy được vẽ trực tiếp trên bề mặt của chúng và yêu cầu ít tài nguyên Windows.
  • Kiểm soát đôi - Lớp cơ sở cho các thành phần có cửa sổ. Cửa sổ này có tay cầm riêng; nó được sử dụng khi truy cập các khả năng của Windows thông qua API.
  • TCustomControl - Hậu duệ của TWinControl, giới thiệu khái niệm về Canvas và phương thức Paint() để kiểm soát tốt hơn việc vẽ thành phần. Lớp này được sử dụng làm cơ sở để xây dựng hầu hết các thành phần hiển thị có tay cầm cửa sổ.
  • TXxxxx - Một lớp như TEdit hoặc TButton. Chúng được sử dụng để xác định thêm các thuộc tính và phương thức của chúng hoặc xác định lại các giá trị mặc định của thuộc tính.
  1. Ví dụ về tạo một thành phần

Ví dụ: hãy tạo một lớp mới, một đột biến TButton, trong đó chúng ta sẽ thay đổi giá trị mặc định của thuộc tính ShowHint thành True và thêm một thuộc tính mới - bộ đếm số lần bấm nút. Đã có sẵn một mẫu mô-đun để tạo thành phần mới (xem đoạn Trống cho một thành phần mới). Bây giờ văn bản nguồn trông như thế này:

đơn vị New_btn;

giao diện

công dụng

SysUtils, WinTypes, WinProcs, Tin nhắn, Lớp học, Đồ họa,

Điều khiển, Biểu mẫu, Hộp thoại, StdCtrls;

kiểu

TMyButton = lớp(TButton)

riêng tư

(Khai báo riêng)

FClickCount: Kéo dài;

được bảo vệ

(Tuyên bố được bảo vệ)

công cộng

(Tuyên bố công khai)

hàm tạo Tạo (AOWner: TComponent); ghi đè;

thủ tục Nhấp chuột; ghi đè;

thuộc tính ClickCount: Đọc lâu FClickCount ghi

  • FClickCount;

    • được phát hành

    (Các tờ khai đã công bố)

    kết thúc;

    thủ tục Đăng ký;

    thực hiện

    hàm tạo TMyButton.Create(AOwner: TComponent);

    bắt đầu

    kế thừa Tạo(AOWner);

    ShowHint:=True;

    FClickCount:=0;

    kết thúc;

    thủ tục TMyButton.Click;

    bắt đầu

    Inc(FClickCount);

    kế thừaClick;

    kết thúc;

    thủ tục Đăng ký;

    bắt đầu

    RegisterComponents("Mẫu", );

    kết thúc;

    kết thúc.

    Để ghi đè giá trị ban đầu của thuộc tính khi tạo đối tượng, bạn cần viết lại hàm tạoTạo nên trong đó gán giá trị mong muốn cho thuộc tính này (không quên gọi hàm tạo tổ tiên trước).

    Thuộc tính mới để đếm số lần nhấn phím được gọi làBấm Đếm. Trường nội bộ của nó để lưu trữ giá trị - FClickCount thuộc loại Longint, dung lượng trường sẽ tồn tại trong thời gian dài.

    Các thành phần được tạo động- đây là những thành phần được phân bổ không gian bộ nhớ khi cần trong quá trình vận hành ứng dụng. Đây là điểm khác biệt của chúng với các thành phần được đặt trên Biểu mẫu khi thiết kế ứng dụng. Khả năng tạo các thành phần một cách linh hoạt là một tiện ích rất lớn cho người lập trình. Ví dụ: bạn có thể tạo nhiều thành phần cùng loại trong một vòng lặp cùng một lúc, tạo thành một mảng chúng, rất dễ quản lý trong tương lai.

    Tất cả các thành phần, giống như các đối tượng, đều có nhiều thuộc tính quyết định hoạt động của chúng. Khi bạn cài đặt một thành phần trên Biểu mẫu từ bảng màu, hầu hết các thuộc tính này được Delphi xác định tự động. Trong khi tạo thành phần động lập trình viên phải mô tả và cấu hình chúng một cách thủ công. Hãy xem nó được thực hiện như thế nào.

    Trước hết, để một thành phần được tạo động xuất hiện, bạn cần phân bổ không gian bộ nhớ cho nó. Việc phân bổ không gian trong bộ nhớ máy tính cho bất kỳ thành phần nào được thực hiện bởi hàm tạo của kiểu đối tượng của thành phần này - phương thức Tạo nên. Để thực hiện việc này, trước tiên bạn cần mô tả một biến thuộc loại mong muốn, sau đó sử dụng phương thức Tạo để cấp phát bộ nhớ. Phương thức Tạo có một tham số Người sở hữu, xác định cái gọi là "chủ sở hữu" cho thành phần được tạo.

    Mặc dù trên thực tế, chủ sở hữu không được yêu cầu tạo mà phải phá hủy thành phần đó. Nghĩa là, khi thành phần chủ sở hữu bị hủy, tất cả các thành phần được chỉ định là chủ sở hữu sẽ tự động bị hủy.
    Khi bạn thường cài đặt một thành phần từ bảng màu, hệ thống sẽ đặt chủ sở hữu của thành phần này làm Biểu mẫu. Cách dễ nhất là làm tương tự. Tuy nhiên, bạn có thể chỉ định chính thành phần này là chủ sở hữu bằng cách sử dụng từ khóa làm tham số Bản thân .

    Hơn nữa. Khi một thành phần được tạo, tức là không gian bộ nhớ được phân bổ cho nó, bạn có thể đặt giá trị cho các tham số của đối tượng này. Trước hết, đây là một thành phần khác, được gọi là “cha mẹ”. Thành phần gốc sẽ chịu trách nhiệm hiển thị thành phần được tạo động của chúng tôi. Điều này có nghĩa là thành phần mới sẽ xuất hiện trong ranh giới của thành phần chính.

    Nếu thành phần chủ sở hữu thuộc loại Thành phần, tức là có thể là bất kỳ thành phần nào thì thành phần cha đã có kiểu Kiểm soát đôi. Nghĩa là, nó phải là thành phần “cửa sổ” có thể nhận và xử lý tin nhắn từ hệ thống Windows. Điều này là cần thiết vì thành phần này phải nằm trong một số thành phần phân cấp nhận và truyền thông báo từ hệ thống Windows. Tin nhắn sẽ được gửi đến thành phần động của chúng tôi thông qua thành phần chính.

    Và một số thành phần hoàn toàn không biết cách nhận tin nhắn từ hệ thống và trong quá trình hoạt động trong trường hợp này, chúng cũng sẽ được kiểm soát bởi thành phần chính, chẳng hạn như Biểu mẫu hoặc Bảng điều khiển mà chúng được đặt trên đó.

    Đương nhiên, một thành phần không thể là thành phần cha của chính nó. Tên của thành phần cha được gán đơn giản cho thuộc tính Cha mẹ thành phần được tạo động.

    Đây là sơ đồ chung để “xây dựng” một thành phần được tạo động:

    var Thành phần: TComponent; //Mô tả một biến cho thành phần

    bắt đầu
    Thành phần:=TComponent.Create(Chủ sở hữu); // Đặt chủ sở hữu
    Component.Parent:=Parent; //Đặt cha mẹ
    kết thúc;

    Đương nhiên, đối với các thành phần trực quan, các giá trị mặc định của các thuộc tính như vị trí trên Biểu mẫu, chiều rộng, chiều cao của thành phần động “mới được tạo” sẽ phù hợp với ít người. Kích thước và vị trí yêu cầu của thành phần cũng sẽ phải được lập trình viên chỉ định.

    Ví dụ: hãy tạo động một thành phần soạn thảo nhiều dòng Bản ghi nhớ. Để nó xuất hiện trên Biểu mẫu khi bạn nhấp vào nút:

    Các bạn, đừng quên chỉ định (liên kết với Thanh tra đối tượng) các quy trình được đề xuất ở đây cho các nút của bạn. Và sau đó những tiếng kêu xuất hiện trong phần bình luận: "chẳng có tác dụng gì cả!"

    Có một tài sản khác Tên! Theo mặc định, Delphi sẽ đặt tên chung theo sau là số sê-ri: Memo1. Khi tạo một thành phần, lập trình viên cũng có thể gán cho thuộc tính Name giá trị mong muốn, ví dụ:

    Memo.Name:="Bản ghi nhớ được tạo động";

    Thành phần này có thể được truy cập bằng tên này hoặc bằng cách chỉ ra biến mà nó được tạo: Bản ghi nhớ. Đương nhiên, trong trường hợp sau, biến phải có tính toàn cục.

    Bây giờ tôi muốn thu hút sự chú ý của bạn đến một sắc thái. Tạo một dự án mới. Hãy tạo ra nó, tạo ra nó, nếu không bạn sẽ không đạt được hiệu quả như tôi mong đợi. Trong dự án mới, chúng ta sẽ tạo thành phần Ghi nhớ tương tự trong trình xử lý OnCreate của Biểu mẫu để Biểu mẫu xuất hiện cùng với thành phần của chúng ta. Đối với Biểu mẫu trống, hãy tạo trình xử lý sự kiện OnCreate và điền mã ở trên vào đó. Và điều gì - khi chúng ta cố gắng thực thi ứng dụng, chúng ta sẽ nhận được lỗi từ trình biên dịch!

    Vấn đề là như thế này. Nhìn vào dự án mới được tạo, thậm chí trước khi thêm các thành phần, vào danh sách được liệt kê trong câu lệnh công dụng mô-đun tiêu chuẩn:

    đơn vị Bài 1;

    giao diện

    công dụng

    Đối thoại;

    Bây giờ, lấy thành phần Ghi nhớ hoặc nút Nút tương tự trong Bảng Thành phần, đặt nó vào Biểu mẫu và xem lại danh sách các mô-đun:

    công dụng
    Windows, Tin nhắn, SysUtils, Biến thể, Lớp, Đồ họa, Điều khiển, Biểu mẫu,
    Đối thoại, StdCtrl;

    Bằng cách gạch chân, tôi đã đánh dấu một mô-đun tự động thêm Delphi vào danh sách các mô-đun được yêu cầu. Trước khi thực thi một ứng dụng, trình biên dịch sẽ xem xét các thành phần đã cài đặt và thêm vào danh sách sử dụng các mô-đun cần thiết để các thành phần đó hoạt động. Vì vậy, ngay cả khi bạn xóa hoàn toàn danh sách này (chỉ để lại " công dụng Các hình thức; "), Delphi sẽ khôi phục nó ở dạng tối thiểu cần thiết cho hoạt động của các thành phần.

    Do đó, việc chúng tôi gặp lỗi trong phiên bản trước là điều đương nhiên - thiếu các mô-đun cần thiết. Bây giờ hãy thoải mái nhấn Chạy!

    Cũng rõ ràng lý do tại sao ứng dụng tạo Bản ghi nhớ bằng cách nhấn nút ngay lập tức bắt đầu hoạt động. Để các thành phần Nút và Ghi nhớ hoạt động, cần có cùng một mô-đun StdCtrls mô tả các thành phần nằm trên tab Tiêu chuẩn. Do đó, khi chúng tôi đặt thành phần Nút trên Biểu mẫu, Delphi đã thêm mô-đun này để đảm bảo rằng Bản ghi nhớ cũng hoạt động.

    Vì vậy, đây là những gì bạn cần làm để ngăn chặn lỗi như vậy xuất hiện! Chỉ cần đặt thành phần mà bạn đang tạo động trên Biểu mẫu từ bảng thành phần và nhấp vào Chạy. Thế là xong, sau khi biên dịch thành phần có thể bị xóa nếu không cần thiết - Delphi sẽ không ghi đè lên mô-đun cần thiết cho hoạt động của nó! Và thành phần được tạo động của bạn sẽ hoạt động.

    Tất nhiên, bạn có thể thực hiện mà không cần thêm các thành phần vào Biểu mẫu rồi xóa chúng mà chúng tôi sẽ tạo động trong chương trình. Hãy nhìn xem - khi bạn di chuột qua bất kỳ thành phần nào trong Bảng Thành phần, một chú giải công cụ sẽ bật lên cùng với tên của mô-đun mà thành phần đó được mô tả. Thêm tên này vào danh sách sử dụng, thế là xong! Nhưng nếu viết sai chữ nào thì hãy tự trách mình.

    Bây giờ câu hỏi được đặt ra: làm thế nào bạn có thể tạo một ứng dụng tương tự như ứng dụng đầu tiên, trong đó thành phần Ghi nhớ được tạo động khi một nút được nhấn, nhưng để nút đó cũng được tạo động!

    Chúng ta có thể tạo động một nút trong trình xử lý OnCreate của Biểu mẫu, giống như thành phần Bản ghi nhớ. Tuy nhiên, nó sẽ không hoạt động - hãy tạo thành phần Ghi nhớ. Đương nhiên, chúng tôi không tạo trình xử lý OnClick cho nó! Hãy làm điều đó.

    Đương nhiên, cách dễ nhất để tạo trình xử lý cho thành phần được tạo động là sử dụng thành phần được tạo sẵn từ bảng màu. Chúng tôi tạo trình xử lý cần thiết cho nó và sau đó chỉ cần xóa thành phần này. Bây giờ tất cả những gì bạn cần làm là gán tên của trình xử lý đã tạo cho thuộc tính tương ứng của thành phần động. Tên của thuộc tính này sẽ khớp với tên của sự kiện tương ứng trong Trình kiểm tra đối tượng. Ví dụ: đối với sự kiện OnClick, chúng tôi viết điều này:

    Button.OnClick:=Button1Click;

    Đương nhiên, tên của trình xử lý có thể là bất kỳ tên nào, nhưng trong trường hợp này tôi đã sử dụng trình xử lý mà Delphi đã tạo cho nút từ bảng màu. Nếu không thích, bạn có thể đổi tên quy trình một cách an toàn, chỉ cần đừng quên đổi tên của nó trong phần mô tả Loại biểu mẫu.

    Bây giờ chúng ta có thể tạo các thành phần một cách linh hoạt và có thể tạo bao nhiêu thành phần tùy thích. Nhưng chúng là những thành phần được tạo động đến mức nhu cầu về chúng vừa xuất hiện vừa biến mất - một cách linh hoạt! Đôi khi bạn cần phải phá hủy một thành phần. Có một phương pháp đơn giản để phá hủy một thành phần: Miễn phí.

    Thành phần.Miễn phí;

    Đó là tất cả. Tất cả các tài nguyên được phân bổ cho hoạt động của thành phần sẽ được giải phóng. Chỉ biến được tạo sẽ còn lại, trỏ đến một đối tượng không còn tồn tại trong bộ nhớ. Sẽ tốt hơn nếu tiêu diệt nó. Điều này được thực hiện bằng cách gán giá trị cho biến không. Có một quy trình thực hiện cả hai hành động này, hủy cả một đối tượng và một biến: FreeAndNil:

    FreeAndNil(Thành phần);

    Và điều này không chỉ áp dụng cho những cái được tạo động - cho bất kỳ thành phần và đối tượng nào trong bộ nhớ.