การพัฒนาแอปพลิเคชั่นอย่างมืออาชีพด้วย Delphi 5 | เครื่องมือพัฒนา | คอมพิวเตอร์กด 2"2544

การสร้าง ส่วนประกอบเดลฟี

รู้เบื้องต้นเกี่ยวกับการสร้างส่วนประกอบ Delphi

เมื่อพัฒนาแอปพลิเคชันโดยใช้ Borland Delphi จะสะดวกในการสร้างส่วนประกอบด้วยเหตุผลดังต่อไปนี้:

1. ใช้งานง่าย- วางส่วนประกอบบนแบบฟอร์มและคุณต้องตั้งค่าคุณสมบัติและเขียนโค้ดตัวจัดการเหตุการณ์ ดังนั้น หากในโปรเจ็กต์การรวมกันของตัวควบคุมและตัวจัดการเหตุการณ์ที่เชื่อมโยงกันเกิดขึ้นในสองแห่ง ก็สมเหตุสมผลที่จะคิดเกี่ยวกับการสร้างส่วนประกอบที่สอดคล้องกัน หากการรวมกันของตัวควบคุมและตัวจัดการเหตุการณ์ที่เกี่ยวข้องกันเกิดขึ้นมากกว่าสองครั้ง การสร้างส่วนประกอบจะรับประกันว่าจะประหยัดความพยายามในการพัฒนาแอปพลิเคชัน
2. การจัดระเบียบการพัฒนาโครงการกลุ่มอย่างง่าย- ในการพัฒนากลุ่ม แต่ละส่วนของโครงการสามารถกำหนดเป็นส่วนประกอบ และสามารถมอบหมายงานให้กับโปรแกรมเมอร์ที่แตกต่างกันได้ คอมโพเนนต์สามารถดีบั๊กแยกจากแอปพลิเคชันได้ ซึ่งทำได้ค่อนข้างง่าย
3. เรียบง่ายและ วิธีที่มีประสิทธิภาพแบ่งปันรหัสกับโปรแกรมเมอร์อื่น ๆมีเว็บไซต์หลายแห่ง เช่น http://www.torry.net/ ซึ่งคุณสามารถค้นหาส่วนประกอบที่แจกฟรีหรือซื้อได้โดยเสียค่าธรรมเนียมเล็กน้อย

ชุดคุณลักษณะ

ใน Delphi ส่วนประกอบจะถูกจัดเก็บไว้ในแพ็คเกจ รายการแพ็คเกจส่วนประกอบที่ใช้สามารถเรียกได้โดยใช้รายการเมนูส่วนประกอบ/แพ็คเกจการติดตั้ง (อย่างไรก็ตาม ด้วยเหตุผลบางประการ กล่องโต้ตอบนี้มีชื่อตัวเลือกโครงการ)

การใช้กล่องโต้ตอบนี้คุณสามารถเพิ่มได้ แพ็คเกจใหม่(เพิ่ม) ลบอันที่มีอยู่ (ลบ) การลบไม่ได้หมายถึงการลบไฟล์ออกจากดิสก์ แต่เป็นการลบลิงก์ออกจากสภาพแวดล้อมการพัฒนาไปยังแพ็คเกจนี้ เมื่อคุณเพิ่มแพ็คเกจใหม่ ส่วนประกอบที่เก็บไว้ในนั้นจะปรากฏบนจานสี และเมื่อคุณลบมันออกไป ในทางกลับกัน ส่วนประกอบเหล่านั้นจะหายไป แทนที่จะลบแพ็คเกจ คุณสามารถ "ซ่อน" เนื้อหาในขั้นตอนการพัฒนาได้โดยยกเลิกการเลือกชื่อแพ็คเกจในรายการ คุณยังสามารถดูส่วนประกอบและไอคอนได้ (ส่วนประกอบ) สุดท้าย คุณสามารถแก้ไขแพ็คเกจที่ผู้ใช้เพิ่มได้ (แก้ไข) - แพ็คเกจที่มาพร้อมกับ Delphi ไม่สามารถแก้ไขได้ (ปุ่มแก้ไขจะเป็นสีเทา)

ในกล่องโต้ตอบนี้ คุณสามารถระบุวิธีสร้างโปรเจ็กต์ได้: การใช้แพ็คเกจรันไทม์หรือไม่มีแพ็คเกจเหล่านั้น เห็นได้ชัดว่ามีแพ็คเกจส่วนประกอบอยู่สองประเภท: แพ็คเกจรันไทม์ (แพ็คเกจที่ทำงานที่รันไทม์) และแพ็คเกจเวลาออกแบบ (แพ็คเกจที่ใช้ระหว่างการพัฒนา) ทั้งหมดนี้เป็น DLLs (ไลบรารีที่โหลดแบบไดนามิก)

แพ็คเกจรันไทม์ (ส่วนขยาย *.bpl) จะถูกส่งไปยังผู้ใช้พร้อมกับโปรเจ็กต์ หากโปรเจ็กต์ถูกคอมไพล์โดยเปิดใช้งานตัวเลือก Build with runtime packages แอปพลิเคชันเอง (*.exe หรือ *.dll) ในกรณีนี้มีขนาดเล็ก แต่ต้องถ่ายโอนไฟล์ *.bpl ที่ค่อนข้างใหญ่ไปด้วย ตามที่ผู้เชี่ยวชาญระบุว่า การส่งมอบโปรเจ็กต์ด้วยแพ็คเกจรันไทม์จะให้ความได้เปรียบในปริมาณไฟล์ที่ให้มา เฉพาะในกรณีที่ประกอบด้วยโมดูลตั้งแต่ห้าโมดูลขึ้นไป (*.exe หรือ *.dll) ที่เขียนด้วย Delphi เมื่อโมดูลเหล่านี้ทำงานร่วมกัน ทรัพยากรระบบปฏิบัติการจะถูกบันทึกไว้ เนื่องจากแพ็คเกจหนึ่งที่โหลดลงใน RAM จะทำหน้าที่หลายโมดูล

แพ็คเกจเวลาออกแบบ (ส่วนขยาย *.dcp) ใช้ในขั้นตอนการพัฒนาเท่านั้น ในระหว่างการพัฒนา จะสนับสนุนการสร้างส่วนประกอบบนแบบฟอร์ม โครงการ Delphi ที่คอมไพล์แล้วมีโค้ดที่ไม่ได้มาจากแพ็คเกจส่วนประกอบ แต่มาจากไฟล์ *.dcu แม้ว่าไฟล์ *.dcp จะถูกสร้างขึ้นจากไฟล์ *.dcu แต่เนื้อหาอาจไม่เหมือนกันหากมีการเปลี่ยนแปลงกับไฟล์ *.pas และแพ็กเกจไม่ได้รับการคอมไพล์ใหม่ การคอมไพล์ทำได้เฉพาะกับแพ็คเกจที่สร้างโดยโปรแกรมเมอร์เท่านั้น สามารถทำได้โดยการคลิกปุ่มแก้ไขในกล่องโต้ตอบด้านบน หลังจากนี้แบบฟอร์มจะปรากฏขึ้นเพื่อให้คุณสามารถจัดการแพ็คเกจได้

แพคเกจประกอบด้วยสองส่วน ส่วนประกอบด้วยประกอบด้วยรายการโมดูลที่สร้างส่วนประกอบของแพ็คเกจนี้ (*.pas- และ *.dcu-files) และไอคอน (*.dcr-files) ส่วนที่จำเป็นประกอบด้วยลิงก์ไปยังแพ็คเกจอื่นที่จำเป็นสำหรับส่วนประกอบเหล่านี้ในการทำงาน การเพิ่มส่วนประกอบใหม่ให้กับแพ็คเกจทำได้โดยใช้ปุ่มเพิ่ม และการลบส่วนประกอบที่มีอยู่ออกทำได้ด้วยปุ่มลบ จนกว่าแพ็คเกจจะถูกคอมไพล์โดยการคลิกปุ่มคอมไพล์ การเปลี่ยนแปลงใด ๆ ที่ทำกับแพ็คเกจจะไม่ปรากฏในสภาพแวดล้อมการพัฒนา ในที่สุด คำสั่งติดตั้งจะพร้อมใช้งานเมื่อเนื้อหาแพ็คเกจถูกลบออกจากสภาพแวดล้อมการพัฒนาโดยยกเลิกการเลือกชื่อแพ็คเกจในกล่องโต้ตอบก่อนหน้า

คำสั่ง Option ให้คุณเลือกตัวเลือกสำหรับการคอมไพล์แพ็คเกจที่คล้ายกับตัวเลือกโปรเจ็กต์ สิ่งเหล่านี้สามารถใช้เพื่อกำหนดประเภทของแพ็คเกจสำหรับแพ็คเกจที่กำหนด: รันไทม์ เวลาออกแบบ หรือทั้งสองอย่าง (ประเภทแพ็คเกจเริ่มต้น) ตัวเลือกจะกำหนดไดเร็กทอรีที่จะค้นหา โมดูลที่จำเป็นและบันทึกผลการคอมไพล์ นอกจากนี้ยังกำหนดการดำเนินการที่จำเป็นสำหรับการดีบัก: ไม่ว่าจะตรวจสอบช่วงของค่าที่ยอมรับได้ หรือไม่ วิธีดำเนินการปรับให้เหมาะสม วิธีจัดการกับข้อผิดพลาด I/O สุดท้าย ตัวเลือกอาจรวมถึงข้อมูลเวอร์ชันของแพ็คเกจด้วย สิ่งนี้สำคัญมากหากแอปพลิเคชันถูกเผยแพร่พร้อมกับแพ็คเกจรันไทม์: เมื่อโปรแกรมติดตั้งทำงาน ข้อมูลเวอร์ชันจะช่วยให้คุณสามารถแทนที่แพ็คเกจเวอร์ชันเก่าได้อย่างถูกต้อง และในทางกลับกัน หากคุณพยายามติดตั้งแพ็คเกจเวอร์ชันก่อนหน้ากว่า อันหนึ่งมีอยู่แล้วในคอมพิวเตอร์ที่กำหนด ส่วนอันหลังจะไม่ถูกเขียนทับ

เทมเพลตส่วนประกอบ

Delphi ช่วยให้คุณสร้างส่วนประกอบคอมโพสิตอย่างง่ายจากส่วนประกอบทั่วไปบางส่วนที่เลือกไว้ในแบบฟอร์มในขณะออกแบบ ผู้เชี่ยวชาญที่เกี่ยวข้องถูกเรียกโดยใช้รายการเมนู ส่วนประกอบ/สร้างเทมเพลตส่วนประกอบ รายการเมนูนี้จะพร้อมใช้งานหากมีการเลือกส่วนประกอบอย่างน้อยหนึ่งรายการในแบบฟอร์ม หลังจากเลือกแล้ว กล่องโต้ตอบข้อมูลเทมเพลตส่วนประกอบจะปรากฏขึ้น

ในกล่องโต้ตอบนี้ คุณควรระบุชื่อของคลาสและชื่อของเพจบนพาเล็ตส่วนประกอบที่คุณควรวาง ส่วนประกอบใหม่- หากเพจที่มีชื่อนี้ไม่ได้อยู่ในพาเล็ตส่วนประกอบ หน้านั้นจะถูกสร้างขึ้น คุณยังสามารถเปลี่ยนไอคอนที่เสนอสำหรับส่วนประกอบใหม่ได้โดยการอัปโหลดไฟล์ *.bmp ที่เหมาะสม

เมื่อสร้างเทมเพลต ทั้งคุณสมบัติที่เปลี่ยนแปลงโดยโปรแกรมเมอร์ใน Object Inspector และตัวจัดการเหตุการณ์ที่เกี่ยวข้องกับการควบคุมที่เลือกจะถูกจดจำ ในกรณีนี้ ตัวจัดการเหตุการณ์จะถูกจดจำอย่างสมบูรณ์ โดยไม่ต้องกรองการเรียกไปยังส่วนประกอบอื่นๆ (ไม่ได้เลือกในแบบฟอร์ม) ตัวแปรโกลบอล วิธีการ ฯลฯ ดังนั้น หากส่วนประกอบดังกล่าว (ตัวแปร วิธีการ) หายไปในโปรเจ็กต์อื่น เมื่อพยายามคอมไพล์โปรเจ็กต์ดังกล่าว จะได้รับข้อความวินิจฉัย Unknown Identifier

เมื่อใดที่คุณควรใช้เทมเพลต? ประการแรก ในกรณีที่จำเป็นต้องเปลี่ยนคุณสมบัติใดๆ ที่มีอยู่ตามค่าเริ่มต้นในคลาสพื้นฐาน ตัวอย่างเช่น แอปพลิเคชันใช้ตัวควบคุมเพื่อแก้ไขบรรทัดข้อความสีเหลือง คุณสามารถวางส่วนประกอบ TEdit บนแบบฟอร์ม เปลี่ยนคุณสมบัติ Color เป็นสีเหลือง ทำเครื่องหมายส่วนประกอบนี้และบันทึกเป็นเทมเพลต หลังจากนี้ คุณจะสามารถเข้าถึงเทมเพลตนี้ได้ และส่วนประกอบที่วางบนแบบฟอร์มจะมีสีเหลือง อย่างไรก็ตาม คุณไม่ควรใช้โอกาสนี้ในทางที่ผิด เนื่องจากคลาสใหม่จะถูกสร้างขึ้นสำหรับการควบคุมที่มีสีที่เปลี่ยนไป และวิธีการเสมือนทั้งหมดจะถูกทำซ้ำในหน่วยความจำ สิ่งนี้จะส่งผลเสียต่อทรัพยากรระบบปฏิบัติการ

การใช้เทมเพลตส่วนประกอบยังสะดวกเมื่อคุณต้องการถ่ายโอนส่วนประกอบจำนวนหนึ่งพร้อมกับตัวจัดการเหตุการณ์จากแบบฟอร์มหนึ่งไปยังอีกแบบฟอร์มหนึ่ง เมื่อต้องการทำเช่นนี้ พวกเขาทั้งหมดจะถูกเลือก สร้างเทมเพลตส่วนประกอบซึ่งวางอยู่บน เครื่องแบบใหม่- ในกรณีนี้ ไม่เพียงแต่ส่วนประกอบเท่านั้นที่จะถูกถ่ายโอน แต่ยังรวมถึงตัวจัดการเหตุการณ์ ซึ่งไม่สามารถทำได้เมื่อเรียกใช้คำสั่ง Copy/Paste - ในกรณีหลัง ตัวจัดการเหตุการณ์จะหายไป

ส่วนประกอบที่สร้างขึ้นโดยใช้คำสั่งสร้างเทมเพลตส่วนประกอบค่อนข้างแตกต่างจากส่วนประกอบทั่วไปที่สร้างขึ้นโดยใช้วิธีมาตรฐาน (อธิบายไว้ด้านล่าง) ความแตกต่างหลักที่มองเห็นคือ: หากเทมเพลตมีตัวควบคุมหลายตัว หลังจากวางส่วนประกอบดังกล่าวลงในแบบฟอร์มแล้ว คุณสามารถเลือกได้ องค์ประกอบที่แยกจากกันควบคุมและลบออก - ในขณะที่ส่วนที่เหลือจะยังคงอยู่ในแบบฟอร์ม สำหรับส่วนประกอบมาตรฐาน หากมีการควบคุมหลายรายการ จะไม่สามารถเลือกรายการใดรายการหนึ่งแล้วลบออกได้ - ส่วนประกอบจะถูกเลือกและลบออกทั้งหมด

การสร้างส่วนประกอบอย่างง่าย

เมื่อเขียนส่วนประกอบใหม่ คุณต้องมีความชัดเจนว่าส่วนประกอบนั้นถูกเขียนสำหรับโปรแกรมเมอร์ ไม่ใช่ผู้ใช้ปลายทาง ในกรณีนี้ เป็นที่พึงปรารถนาที่โปรแกรมเมอร์จะไม่เจาะลึกรายละเอียดของการใช้งานส่วนประกอบ แต่เพียงใช้คุณสมบัติและเหตุการณ์ที่เปิดเผย สามารถทำได้ผ่านการทดสอบอย่างละเอียดถี่ถ้วน ส่วนประกอบใหม่จะต้องได้รับการทดสอบแม้ในสถานการณ์ที่ไม่ได้ออกแบบไว้อย่างชัดเจน

ขอเสนอปัญหาดังนี้ คุณต้องสร้างปุ่มที่จะส่งเสียงบี๊บเมื่อกด และใช้เป็นส่วนประกอบเพื่อให้โปรแกรมเมอร์สามารถวางลงในแบบฟอร์มและใช้งานได้ โดยทั่วไป เมื่อพิจารณาส่วนประกอบต่างๆ เรามักจะใช้เอฟเฟกต์ภายนอกที่ง่ายที่สุด เช่น เสียงบี๊บ การแสดงข้อความ ฯลฯ นี่หมายความว่าในสถานที่ที่ใช้เอฟเฟกต์ภายนอก สามารถวางโค้ดที่ค่อนข้างซับซ้อนได้ แค่เข้า. ในขณะนี้เขาไม่สนใจเรา

การสร้างส่วนประกอบเริ่มต้นด้วยการเลือกรายการเมนูส่วนประกอบ/ส่วนประกอบใหม่ หลังจากนี้ กล่องโต้ตอบส่วนประกอบใหม่จะปรากฏขึ้นทันที

ในกล่องโต้ตอบนี้ คุณจะต้องกำหนดคลาสบรรพบุรุษ ชื่อของคลาสที่สร้างขึ้นใหม่ หน้าบนพาเล็ตที่จะวางส่วนประกอบใหม่ ชื่อของโมดูลที่มีการนำไปใช้งานของส่วนประกอบใหม่ และเส้นทางไปยัง มัน. หากส่วนประกอบใหม่ใช้โมดูลอื่น ซึ่งเป็นเส้นทางที่ไม่ได้อธิบายไว้ จะต้องกำหนดโมดูลเหล่านั้นในฟิลด์ เส้นทางการค้นหา

ดังนั้นงานแรก (และบางทีอาจเป็นงานหลัก) คือการเลือกคลาสบรรพบุรุษ ในรายการแบบเลื่อนลง ส่วนประกอบทั้งหมดที่มีอยู่ในจานสีจะถูกนำเสนอเป็นคลาสบรรพบุรุษ รวมถึงองค์ประกอบที่ไม่รวมอยู่ในการกระจาย Delphi มาตรฐาน จำเป็นต้องเลือกคลาสที่ใกล้เคียงที่สุดในคุณสมบัติเป็นคลาสบรรพบุรุษ ชั้นเรียนที่ถูกสร้างขึ้น- สำหรับงานของเรา เราสามารถเลือก TWinControl เป็นบรรพบุรุษได้ แต่ในกรณีนี้ เราจะต้องปรับใช้เอฟเฟกต์ภาพทั้งหมดของการคลิกปุ่ม ฯลฯ ดังนั้นเราจึงเลือก TButton เป็นบรรพบุรุษ

ชื่อของคลาสที่สร้างขึ้นใหม่จะต้องสะท้อนถึงเนื้อหาของส่วนประกอบและไม่ว่าในกรณีใดจะตรงกับชื่อของส่วนประกอบที่ลงทะเบียนแล้ว! ในขั้นตอนการกรอกบทสนทนานี้ ชื่อจะไม่ถูกตรวจสอบสำหรับการแข่งขัน - การผจญภัยที่เกี่ยวข้องกับข้อผิดพลาดดังกล่าวจะเริ่มต้นในภายหลัง...

เมื่อเลือกเพจคุณต้องรู้ว่าหากคุณระบุชื่อ หน้าไม่มีอยู่จากนั้นจะมีการสร้างอันใหม่ขึ้นมา

สุดท้าย เมื่อคุณคลิกปุ่มติดตั้งและตกลง เทมเพลตจะถูกสร้างขึ้นเพื่อใช้ส่วนประกอบใหม่ อย่างไรก็ตาม เมื่อคุณคลิกปุ่มติดตั้ง เทมเพลตจะถูกวางบนจานสีส่วนประกอบ และเมื่อคุณคลิกตกลง เทมเพลตก็จะถูกสร้างขึ้นอย่างง่ายดาย ขอแนะนำให้ใช้ปุ่มติดตั้ง หลังจากติดตั้งส่วนประกอบแล้ว ก็สามารถวางลงในแบบฟอร์มได้ ตอนนี้การเปลี่ยนแปลงทั้งหมดที่ทำกับโค้ดการใช้งานส่วนประกอบจะถูกรวบรวมพร้อมกับโปรเจ็กต์ และโปรแกรมเมอร์จะได้รับข้อความแสดงข้อผิดพลาดทันที หากไม่ได้ติดตั้งส่วนประกอบเพื่อค้นหาข้อผิดพลาดจะต้องคอมไพล์ผ่านตัวแก้ไขแพ็คเกจ (ดูด้านบน) โดยคลิกปุ่มคอมไพล์ซึ่งสะดวกน้อยกว่า

ดังนั้นหลังจากคลิกปุ่มติดตั้งแล้วกล่องโต้ตอบอื่นจะปรากฏขึ้นซึ่งช่วยให้คุณกำหนดแพ็คเกจที่จะวางส่วนประกอบนี้

กล่องโต้ตอบนี้มีสองเพจ โดยหน้าแรกคุณสามารถเลือกหนึ่งในแพ็คเกจที่มีอยู่ได้ และในหน้าที่สองคุณสามารถสร้างเพจใหม่ได้ ขอแนะนำอย่างยิ่งให้ระบุคำอธิบายแบบข้อความสั้นๆ ของแพ็คเกจ นี่คือสิ่งที่จะแสดงในกล่องโต้ตอบที่เรียกโดยคำสั่ง Component/Install packages (ดูด้านบน) หลังจากเลือกแพ็คเกจและกดปุ่ม OK ตัวแก้ไขแพ็คเกจจะถูกเรียก โดยที่โมดูลที่สร้างขึ้นใหม่สำหรับการนำส่วนประกอบใหม่ไปใช้จะถูกวางโดยอัตโนมัติ การไม่ปิดจะมีประโยชน์ แต่ควรเลื่อนไปที่มุมใดมุมหนึ่งของหน้าจอเพื่อให้สามารถเปิดใช้งานได้โดยการกดปุ่มเมาส์

ในเวลาเดียวกัน "ว่าง" จะถูกสร้างขึ้นในตัวแก้ไขโค้ดเพื่ออธิบายส่วนประกอบใหม่:

หน่วยปุ่มบี๊บ; อินเทอร์เฟซใช้ Windows, ข้อความ, SysUtils, คลาส, กราฟิก, การควบคุม, แบบฟอร์ม, กล่องโต้ตอบ, StdCtrls; ประเภท TButtonBeep = class(TButton) ส่วนตัว ( ประกาศส่วนตัว ) ได้รับการคุ้มครอง ( ประกาศที่ได้รับการคุ้มครอง ) สาธารณะ ( ประกาศสาธารณะ ) เผยแพร่ ( ประกาศเผยแพร่ ) สิ้นสุด; ขั้นตอนการลงทะเบียน; ขั้นตอนการดำเนินการ ลงทะเบียน; เริ่ม RegisterComponents("ตัวอย่าง", ); จบ; จบ.

คลาสใหม่นั้นประกาศสี่ส่วนซึ่งความหมายได้อธิบายไว้โดยละเอียดในส่วน“ การมองเห็นตัวแปรและวิธีการ” ของบทความก่อนหน้าในชุดนี้ (ComputerPress No. 1 "2001) นอกจากนี้คลาสใหม่ยังกำหนด ขั้นตอนการลงทะเบียนซึ่งถูกเรียกโดยสภาพแวดล้อมการพัฒนา Delphi ระหว่างการติดตั้งโมดูลนี้เป็นส่วนประกอบ ประกอบด้วยชื่อของเพจบนพาเล็ตที่วางส่วนประกอบนี้และในวงเล็บเหลี่ยม - ชื่อของคลาสโดยทั่วไป เมธอด Register ใช้อาร์เรย์ของประเภทคลาสเป็นพารามิเตอร์ เนื่องจากคอมโพเนนต์หลายรายการสามารถนำไปใช้ในโมดูลเดียวได้ ดังนั้นจึงคั่นด้วยเครื่องหมายจุลภาค เช่น:

ขั้นตอนการลงทะเบียน; เริ่ม RegisterComponents("ตัวอย่าง", ); จบ;

มาแก้ไขงานในมือต่อไป - สร้างปุ่มที่ส่งเสียงแหลม มาทำสิ่งเล็กน้อยก่อน (แต่ปรากฏในภายหลังไม่ถูกต้อง) - กำหนดตัวจัดการ เหตุการณ์ออนคลิกในตัวสร้างปุ่ม เมื่อต้องการทำเช่นนี้ ในส่วนส่วนตัว เรากำหนดส่วนหัวของวิธีการใหม่ BtClick(Sender:TObject) และนำไปใช้ในส่วนการดำเนินการ:

ขั้นตอน TButtonBeep.BtClick(Sender:TObject); เริ่มบี๊บ; จบ;

ตัวสร้างสร้าง (AOwner: TComponent); แทนที่;

พร้อมคำสั่งแทนที่บังคับ! มานำไปใช้ในส่วนการใช้งาน:

ตัวสร้าง TButtonBeep.Create (AOwner: TComponent); เริ่มสืบทอดสร้าง (AOwner);

OnClick:=BtClick; จบ;

หลังจากนี้เรามาคอมไพล์ส่วนประกอบกัน มาวางปุ่มบนแบบฟอร์มจากหน้าตัวอย่างและรันโปรเจ็กต์เพื่อดำเนินการ คุณสามารถตรวจสอบให้แน่ใจว่าปุ่มส่งเสียงบี๊บเมื่อกด!

ตอนนี้เรากลับไปที่สภาพแวดล้อมการพัฒนาและกำหนดตัวจัดการเหตุการณ์ OnClick ในตัวตรวจสอบวัตถุ ในตัวจัดการเหตุการณ์ เราจะแสดงข้อความในชื่อแบบฟอร์ม:

ขั้นตอน TForm1.ButtonBeep1Click(Sender:TObject); เริ่มคำบรรยาย: = "ทดสอบ"; จบ;

ดังนั้น เมื่อเขียนส่วนประกอบใหม่ คุณควรพิจารณาเปลี่ยนคุณสมบัติและตัวจัดการเหตุการณ์โดยใช้ Object Inspector เสมอ หากไม่ควรเปลี่ยนแปลงคุณสมบัติ (เหตุการณ์) ก็ไม่ควรแสดงใน Object Inspector และหากมองเห็นได้อยู่แล้วก็ควรซ่อนไว้ (เราจะพูดถึงเรื่องนี้ในภายหลัง) โปรแกรมเมอร์มีสิทธิ์ทุกประการในการเปลี่ยนแปลงคุณสมบัติใด ๆ ในตัวตรวจสอบวัตถุและหากหลังจากนี้ส่วนประกอบหยุดทำงานผู้พัฒนาส่วนประกอบจะถูกตำหนิ แต่ไม่ว่าในกรณีใดโปรแกรมเมอร์จะใช้มัน

จะตัดสินใจได้อย่างถูกต้องได้อย่างไร? งานนี้- วิธีหนึ่งในการสร้างส่วนประกอบคือการเขียนวิธีการที่มีอยู่ใหม่ เมื่อดูไฟล์ StdCtrls.pas ซึ่งมีการนำซอร์สโค้ดสำหรับคอมโพเนนต์ TButton มาใช้ คุณจะสังเกตได้ว่าไฟล์ดังกล่าวมีวิธีคลิกแบบไดนามิกที่สามารถเขียนใหม่ได้ ดังนั้นเราจึงกลับมาที่ซอร์สโค้ดที่สร้างโดยผู้เชี่ยวชาญ Delphi อีกครั้งเมื่อสร้างส่วนประกอบ (เราลบตัวสร้างและวิธี BtClick) จากนั้นในส่วนสาธารณะ เรากำหนดส่วนหัวของวิธีการ:

ขั้นตอน คลิก; แทนที่;

และนี่คือการนำวิธีการไปใช้:

ขั้นตอน TButtonBeep.Click; เริ่มสืบทอดคลิก;

บี๊บ; จบ;

คุณสามารถตรวจสอบว่าปุ่มส่งเสียงแหลมเมื่อกดหรือไม่ นอกจากนี้ เมื่อคุณกำหนดตัวจัดการเหตุการณ์ในตัวตรวจสอบวัตถุ ตัวจัดการนี้จะถูกดำเนินการและเสียงบี๊บจะไม่หายไป! มีการนำส่วนประกอบไปใช้อย่างถูกต้อง

1. จากตัวอย่างนี้จะมีประโยชน์ในการวิเคราะห์ข้อผิดพลาดที่อาจเกิดขึ้นเมื่อเขียนโค้ด:
2. ลืมคำสั่งแทนที่เมื่อกำหนดส่วนหัวของวิธีการคลิก ปุ่มจะหยุดส่งเสียงบี๊บ ดังนั้นจึงไม่มีการเรียกวิธีการคลิก

การเรียกเมธอดระดับบนที่ถูกลืม (คลิกที่รับมา) ในการดำเนินการตามขั้นตอนคลิก ปุ่มยังคงส่งเสียงบี๊บเมื่อกด แต่โค้ดในตัวจัดการเหตุการณ์ที่กำหนดในตัวตรวจสอบวัตถุจะไม่ถูกดำเนินการ ดังนั้น วิธีการคลิกของคลาสTButtonทำให้เกิดเหตุการณ์OnClick ตอนนี้เรามาเปลี่ยนไอคอนของส่วนประกอบ TButtonBeep บนพาเล็ต ตามค่าเริ่มต้น ไอคอนของส่วนประกอบระดับบนจะถูกใช้สำหรับส่วนประกอบใหม่ เมื่อต้องการทำเช่นนี้ ให้เรียก Image Editor โดยใช้คำสั่ง Tools/Image Editor ในเอดิเตอร์ ให้เรียกคำสั่ง File/New/Component Resource File (*.dcr) หลังจากคำสั่ง Resource/New/Bitmap กล่องโต้ตอบจะปรากฏขึ้นเพื่อแนะนำขนาดไอคอน 32x32 ขนาดเริ่มต้นเหล่านี้ควรเปลี่ยนเป็น 24x24 ซึ่งเป็นขนาดที่ไอคอนคอมโพเนนต์ต้องมี! หลังจากคลิกปุ่ม OK คุณควรวาดภาพโดยใช้เครื่องมือมาตรฐาน คล้ายกับเครื่องมือ- โปรดจำไว้ว่าสีของพิกเซลซ้ายล่างคือสีมาสก์ - สีนี้จะเป็นสี "โปร่งใส"

หลังจากนี้ คุณจะต้องกำหนดชื่อของทรัพยากรใหม่ด้วยไอคอน โดยค่าเริ่มต้น ชื่อของทรัพยากรคือ Bitmap1 ชื่อทรัพยากรใหม่จะต้องตรงกับชื่อของคลาส - ในกรณีของเรา TButtonBeep

ตอนนี้ คุณต้องบันทึกไฟล์ไอคอนในไดเร็กทอรีเดียวกันกับโมดูลที่มีขั้นตอนการลงทะเบียนสำหรับส่วนประกอบนี้ และมีชื่อเดียวกันกับชื่อโมดูล เฉพาะนามสกุลไฟล์เท่านั้นที่จะไม่ใช่ *.pas แต่เป็น *.dcr ไฟล์ที่มีไอคอนส่วนประกอบพร้อมแล้ว อย่างไรก็ตาม หากเราดูที่จานสี Components เราจะเห็นว่าไอคอนเก่ายังคงอยู่ หากคุณรีสตาร์ท Delphi หรือแม้แต่ระบบปฏิบัติการ ไอคอนเก่าจะยังคงอยู่ในจานสี หากต้องการเปลี่ยนไอคอน จะต้องลงทะเบียนส่วนประกอบอีกครั้ง ในการทำเช่นนี้คุณต้องมี:

ตัวอย่างนี้ควรถือเป็นแบบฝึกหัดทดสอบ ก่อนที่จะเขียนส่วนประกอบใหม่ คุณต้องดูว่ามีส่วนประกอบที่คล้ายกันอยู่ในส่วนประกอบที่แจกจ่ายอย่างอิสระหรือไม่ มีเกือบทุกปุ่ม: โปร่งใส, วิ่งหนี, กลม, มีสี ฯลฯ สถานการณ์จะเหมือนกันโดยประมาณกับส่วนประกอบอื่น ๆ - ผู้สืบทอดของคลาสเดียวกัน ดังนั้นบ่อยครั้งที่คุณต้องใช้ส่วนประกอบที่ประกอบด้วยการควบคุมหลายอย่าง

ดังนั้นในตัวอย่างนี้ เราได้สำรวจการใช้เมธอดการเขียนใหม่เพื่อสร้างส่วนประกอบใหม่

การสร้างองค์ประกอบที่ซับซ้อน

สมมติว่าคุณต้องป้อนรายชื่อลูกค้าในแอปพลิเคชัน ในแอปพลิเคชันเดียวกันคุณจะต้องป้อนรายการหมายเลขโทรศัพท์ด้วย การป้อนรายการเป็นการดำเนินการที่ค่อนข้างธรรมดา ดังนั้นคุณควรพิจารณานำไปใช้เป็นส่วนประกอบ

หากต้องการป้อนองค์ประกอบใหม่ลงในรายการ คุณจะต้องมีโปรแกรมแก้ไข - ส่วนประกอบ TEdit ถัดไป ผู้ใช้ควรจะสามารถดูรายการได้ - จำเป็นต้องมีส่วนประกอบ TListBox นอกจากนี้ คุณจะต้องใช้คำสั่งในการเขียนค่าปัจจุบันจาก TEdit ไปยังรายการ แก้ไขรายการที่เลือก และลบออก วิธีที่ง่ายที่สุดในการใช้คำสั่งเหล่านี้คือการใช้ปุ่ม เพื่อให้งานง่ายขึ้น เราจะวางปุ่มเดียวบนแบบฟอร์ม เมื่อคลิกแล้ว เราจะเพิ่มเนื้อหาของส่วนประกอบ TEdit ลงในรายการ

ดังนั้นเราจึงจำเป็นต้องสร้างส่วนประกอบใหม่ที่มี TEdit, TListBox และ TButton เช่นเคย มาเริ่มสร้างมันด้วยคำสั่ง Component/New Component กัน หลังจากนี้ กล่องโต้ตอบจะปรากฏขึ้นโดยคุณควรกำหนดคลาสบรรพบุรุษ ชื่อคลาส และชื่อโมดูล ไม่มีปัญหากับชื่อคลาสและชื่อโมดูล แต่ชื่อของคลาสบรรพบุรุษไม่ชัดเจน เรามีการควบคุมสามแบบ คลาสบรรพบุรุษร่วมกันสำหรับพวกเขาคือ TWinControl แต่ถ้าเราเลือกให้เป็นคลาสบรรพบุรุษ เรากำลังเผชิญกับการใช้งานโค้ด TButton, TEdit และ TListBox ที่ยาวและน่าเบื่อ ในกรณีเช่นนี้ จำเป็นต้องเลือกส่วนประกอบเป็นคลาสบรรพบุรุษที่สามารถเป็น "บิดา" โดยสัมพันธ์กับส่วนประกอบอื่นๆ ในบรรดาส่วนประกอบมาตรฐานที่แจกจ่ายให้กับ Delphi มีสามองค์ประกอบ: TPanel, TGroupBox, TScrollBox ให้เราเลือกพาเนลเป็นคลาสบรรพบุรุษ แต่ไม่ใช่คอมโพเนนต์ TPanel แต่เป็นคลาส TCustomPanel เราจะพูดถึงข้อดีของการเลือก TCustomPanel บน TPanel ด้านล่าง

ตั้งชื่อคลาสใหม่ TListAdd แล้วคลิกปุ่มติดตั้ง หลังจากเลือกแพ็คเกจแล้ว ส่วนประกอบจะถูกติดตั้งในพาเล็ต จากตำแหน่งที่สามารถวางไว้ในรูปแบบของแอปพลิเคชันที่สร้างขึ้นใหม่ วิธีนี้สะดวกเพราะเมื่อคอมไพล์โปรเจ็กต์ โมดูลส่วนประกอบก็จะถูกคอมไพล์ด้วย และหากมีข้อผิดพลาด คอมไพเลอร์จะแสดงข้อความ

มันจะสะดวกกว่าถ้าวางการควบคุมของเราบนแบบฟอร์มบางรูปแบบแล้วสร้างส่วนประกอบจากแบบฟอร์มเหล่านั้น ไม่มีผู้เชี่ยวชาญในแพ็คเกจ Delphi มาตรฐาน ดังนั้นคุณจะต้องสร้างส่วนประกอบด้วยตัวเองและวางไว้บนแผงควบคุม มีความสมเหตุสมผลในการสร้างการควบคุม - TButton, TEdit และ TListBox - ในตัวสร้าง TCustomPanel ซึ่งเห็นได้ชัดว่าต้องมีการเขียนใหม่ สำหรับตอนนี้ มาวางส่วนควบคุมในช่องสี่เหลี่ยมขนาด 100x100 กัน พิกัดของพวกเขายังต้องถูกกำหนดในตัวสร้างด้วย ควรระลึกไว้ว่าหลังจากสร้างคอนสตรัคเตอร์ขององค์ประกอบการควบคุมใด ๆ แล้วยังไม่มีพาเรนต์นั่นคือไม่รู้ว่าหน้าต่างใดที่ควรวัดพิกัดของมุมซ้ายบนด้วยความเคารพ ความพยายามที่จะเปลี่ยนพิกัดของหน้าต่างลูกที่ไม่มีพาเรนต์จะทำให้เกิดข้อยกเว้นทันที ดังนั้น โอเปอเรเตอร์แรกหลังจากเรียกคอนสตรัคเตอร์ควบคุมจะต้องกำหนดพาเรนต์ให้กับมัน ซึ่งเราจะเลือก TCustomPanel เราจะทำให้มันเป็นเจ้าของด้วย ในกรณีนี้ ไม่จำเป็นต้องเขียนตัวทำลายใหม่

ดังนั้นในส่วนการใช้งานเราจึงเพิ่มโมดูล StdCtrls ซึ่งมีคำอธิบายของคลาส TEdit, TButton และ TListBox และในส่วนส่วนตัวเรากำหนดตัวแปรสามตัว:

FEdit ส่วนตัว: TEdit;

FListBox:TListBox;

FButton:Tปุ่ม;

ในส่วนสาธารณะ เราประกาศส่วนหัวของคอนสตรัคเตอร์พร้อมกับคำสั่งแทนที่บังคับ:

ตัวสร้างสร้าง (AOwner: TComponent); แทนที่;

เราใช้ตัวสร้างในส่วนการดำเนินการ: ตัวสร้าง TListAdd.Create (AOwner: TComponent); เริ่มสืบทอดสร้าง (AOwner); FButton:=TButton.Create(ตนเอง);

FButton.Parent:=ตนเอง;

FButton.ซ้าย:=5;

FButton.ด้านบน:=5;

FButton.ความกว้าง:=40;

FButton.Height:=25;

FEdit:=TEdit.Create(ตนเอง);

FEdit.Parent:=ตนเอง;

FEdit.ซ้าย:=50;<100 then Width:=100; if Height<100 then Height:=100; FEdit.Width:=Width-55; FListBox.Width:=Width-10; FListBox.Height:=Height-40; end;

คำสั่งแรกคือการเรียกไปยังตัวจัดการ WM_SIZE เริ่มต้น (สืบทอดมา) หลังจากเรียกแล้ว คุณสมบัติความกว้างและความสูงจะมีความกว้างและความสูงของแผงใหม่ หลังจากนั้น ขนาดขั้นต่ำของส่วนประกอบจะถูกกำหนด ในกรณีนี้คือ 100x100 หากขนาดแนวนอนหรือแนวตั้งน้อยกว่าค่าต่ำสุด จะมีการกำหนดค่าขั้นต่ำไว้ จากนั้นส่วนควบคุมจะถูกปรับขนาดเพื่อให้มีการเยื้องบางส่วนเต็มทั้งแผง ด้วยการคอมไพล์ส่วนประกอบผ่านตัวแก้ไขแพ็คเกจ คุณสามารถทราบได้ในขั้นตอนการพัฒนาว่าส่วนควบคุมบนแผงควบคุมทำงานอย่างถูกต้องเมื่อปรับขนาด และขนาดของส่วนประกอบต้องไม่ต่ำกว่า 100x100

ตอนนี้การดำเนินโครงการทั้งหมดจะเป็นประโยชน์ลองป้อนข้อมูลลงในโปรแกรมแก้ไขข้อความบรรทัดเดียวแล้วคลิกปุ่ม ในกรณีนี้ ไม่มีสิ่งใดถูกเพิ่มลงในรายการ และไม่น่าแปลกใจเลยที่ไม่มีส่วนใดในส่วนประกอบของเราระบุว่าควรทำอะไรเมื่อกดปุ่ม เพื่อให้ตัวจัดการเหตุการณ์เชื่อมโยงกับการคลิกปุ่มคุณสามารถดำเนินการได้เช่นเดียวกับเมื่อเขียนส่วนประกอบ TbuttonBeep นั่นคือกำหนดคลาสใหม่ - ผู้สืบทอดของ TButton และเขียนวิธีการคลิกใหม่ อย่างไรก็ตาม การกำหนดคลาสใหม่ต้องใช้ทรัพยากรระบบ (วิธีการเสมือนจะถูกคูณ) หากเราทำเครื่องหมายส่วนประกอบบนแบบฟอร์มและดูที่ตัวตรวจสอบวัตถุ เราจะพบว่าส่วนประกอบ TlistAdd เปิดเผยคุณสมบัติเพียงเล็กน้อยและไม่มีเหตุการณ์ใด ๆ รวมถึงไม่มีตัวจัดการเหตุการณ์สำหรับปุ่ม OnClick ดังนั้นสิ่งที่เราปฏิเสธในบทที่แล้วว่าเป็นวิธีการที่ไม่ถูกต้อง ซึ่งกำหนดตัวจัดการปุ่ม OnClick ใหม่จึงสามารถใช้ได้ในกรณีนี้ เนื่องจากโปรแกรมเมอร์ไม่สามารถกำหนดตัวจัดการใหม่ในตัวตรวจสอบวัตถุได้ ดังนั้นในส่วนส่วนตัว เราจะอธิบายส่วนหัวของวิธีการใหม่:

ขั้นตอน BtClick(Sender:TObject);

ในการใช้งานตัวสร้าง TListAdd เรากำหนดตัวจัดการนี้ให้กับตัวจัดการเหตุการณ์ FButton.OnClick:

FButton.OnClick:=BtClick;

สุดท้ายนี้ ลองใช้วิธี BtClick มาใช้:

ขั้นตอน TListAdd.BtClick(Sender:TObject); เริ่มต้นถ้าความยาว(FEdit.Text)>0 จากนั้นเริ่ม FListBox.Items.Add(FEdit.Text);

ขั้นแรก เรามาตรวจสอบว่าตัวแก้ไขบรรทัดเดียวว่างเปล่าหรือไม่ เราจะไม่เพิ่มบรรทัดว่างลงในรายการ จากนั้นเราจะถ่ายโอนเนื้อหาของตัวแก้ไขไปยังรายการ (FListBox.Items.Add(FEdit.Text);) และเตรียมตัวแก้ไขสำหรับการป้อนค่าถัดไป กล่าวคือ เราจะล้างข้อความนั้น (ซึ่งได้ถูกโอนไปยังรายการแล้ว ) และถ่ายโอนโฟกัสอินพุตไปที่มัน ตอนนี้หลังจากคอมไพล์และรันแอปพลิเคชันแล้ว คุณสามารถตรวจสอบให้แน่ใจว่ามันทำงานได้อย่างถูกต้อง - เมื่อคุณกดปุ่ม เนื้อหาของโปรแกรมแก้ไขจะถูกโอนไปยังรายการ

การเพิ่มคุณสมบัติและวิธีการ

หากคุณวางส่วนประกอบ TPanel ไว้ถัดจากส่วนประกอบ TListAdd และเปรียบเทียบสิ่งที่แสดงในตัวตรวจสอบวัตถุ คุณจะสังเกตเห็นว่ามีการเปิดเผยคุณสมบัติและเหตุการณ์จำนวนมากสำหรับแผง ในขณะที่คุณสมบัติเพียงไม่กี่รายการเท่านั้นที่ถูกเปิดเผยสำหรับ TListAdd ในขณะเดียวกัน คลาส TCustomPanel ก็เป็นบรรพบุรุษของทั้งสองคอมโพเนนต์ เพื่อให้เข้าใจเหตุผล เรามาเปิดโมดูล ExtCtrls.pas และดูความแตกต่างระหว่างคลาส TCustomPanel และ TPanel โปรดทราบว่าวิธีการและตัวแปรทั้งหมดที่มีฟังก์ชันการทำงานของพาเนลนั้นถูกกำหนดไว้ที่ระดับคลาส TCustomPanel นอกจากนี้ยังกำหนดคุณสมบัติที่จะแสดงในตัวตรวจสอบวัตถุสำหรับ TPanel เฉพาะคุณสมบัติเหล่านี้เท่านั้นที่ถูกกำหนดในส่วนที่ได้รับการป้องกัน การใช้งานคลาส TPanel นั้นง่ายมาก: TCustomPanel ถูกกำหนดให้เป็นบรรพบุรุษและมีการประกาศคุณสมบัติของคลาสนี้ แต่อยู่ในส่วนที่เผยแพร่ จะชัดเจนว่าต้องทำอะไรในคลาส TListAdd เพื่อให้คุณสมบัติและวิธีการของคลาส TcustomPanel ปรากฏในตัวตรวจสอบวัตถุ กล่าวคือ เพื่อประกาศคุณสมบัติ ในส่วนที่เผยแพร่ของคลาส TListAdd เราเขียน:

จัดตำแหน่งคุณสมบัติ;

คุณสมบัติ OnMouseDown;

ตอนนี้เรามาดูกันว่าคุณจะแนะนำคุณสมบัติใหม่ได้อย่างไร (สิ่งที่เราทำข้างต้นคือการประกาศคุณสมบัติที่มีอยู่ใหม่อีกครั้ง) ข้อความบนปุ่มสามารถใช้เป็นคุณสมบัติที่เหมาะสมเพื่อแสดงในตัวตรวจสอบวัตถุ: ให้โปรแกรมเมอร์ที่ใช้ส่วนประกอบ TListAdd เปลี่ยนข้อความในขณะออกแบบ กำลังพยายามแนะนำคุณสมบัติใหม่ (เรียกว่า BtCaption) โดยใช้การประกาศ:

คุณสมบัติ BtCaption: string อ่าน FButton.Caption เขียน FButton.Caption;

ส่งผลให้เกิดข้อผิดพลาดเมื่อพยายามรวบรวมส่วนประกอบ ดังนั้นเราจึงกำหนดส่วนหัวของสองวิธีในส่วนส่วนตัว:

ฟังก์ชัน GetBtCaption:string; ขั้นตอน SetBtCaption (ค่า const: string);

ในส่วนที่เผยแพร่เราประกาศคุณสมบัติ BtCaption:

คุณสมบัติ BtCaption: สตริง อ่าน GetBtCaption เขียน SetBtCaption;

สุดท้ายนี้ เราใช้สองวิธีที่ประกาศไว้ในส่วนการใช้งาน:

ฟังก์ชัน TListAdd.GetBtCaption:string; เริ่มต้นผลลัพธ์: = FButton.Caption; จบ; ขั้นตอน TListAdd.SetBtCaption (ค่า const: string); เริ่มต้น FButton.Caption:=Value; จบ;

หลังจากคอมไพล์ส่วนประกอบโดยใช้ตัวแก้ไขแพ็คเกจ คุณสมบัติใหม่จะปรากฏในตัวตรวจสอบวัตถุ การเปลี่ยนแปลงมูลค่าของทรัพย์สินนี้จะสะท้อนให้เห็นโดยตรงในขั้นตอนการพัฒนา

ตอนนี้เรามากำหนดเหตุการณ์ใหม่กัน ในกรณีนี้ สมเหตุสมผลที่จะสร้างเหตุการณ์ที่ช่วยให้โปรแกรมเมอร์ใช้ส่วนประกอบนี้วิเคราะห์ข้อความก่อนที่จะเพิ่มเนื้อหาของตัวแก้ไขลงในรายการ และอนุญาตหรือปิดใช้งานการเพิ่มข้อความลงในรายการ ดังนั้นวิธีนี้จะต้องมีพารามิเตอร์เป็นค่าปัจจุบันของข้อความในตัวแก้ไขและขึ้นอยู่กับตัวแปรลอจิคัลซึ่งโปรแกรมเมอร์สามารถกำหนดค่าเป็น True หรือ False ได้ นอกจากนี้ ตัวจัดการเหตุการณ์ใดๆ ในคอมโพเนนต์ต้องขึ้นอยู่กับพารามิเตอร์ Sender ซึ่งคอมโพเนนต์ที่เรียกใช้จะส่งผ่านการอ้างอิงถึงตัวมันเอง นี่เป็นสิ่งจำเป็นเนื่องจากในสภาพแวดล้อมการพัฒนา Delphi ตัวจัดการเหตุการณ์เดียวกันสามารถเรียกได้จากส่วนประกอบต่างๆ มากมาย และโปรแกรมเมอร์จะต้องสามารถวิเคราะห์องค์ประกอบที่เรียกว่าตัวจัดการได้ ดังนั้น หลังจากประเภทคำในส่วนอินเทอร์เฟซ ก่อนที่จะกำหนด TListAdd เราจะกำหนดประเภทวิธีการใหม่:

พิมพ์ TFilterEvent=procedure(Sender:TObject; const EditText:string; var CanAdd:boolean) ของ object;

FOnFilter:TFilterEvent;

และในส่วนที่เผยแพร่ เรากำหนดคุณสมบัติประเภทนี้:

คุณสมบัติ OnFilter: TFilterEvent อ่าน FOnFilter เขียน FOnFilter;

เมื่อกำหนดคุณสมบัติใหม่ เราจะอ้างถึงตัวแปร FOnFilter ไม่ใช่วิธีการ - ไม่จำเป็นต้องใช้ที่นี่ ตอนนี้ หากคุณคอมไพล์ส่วนประกอบโดยใช้โปรแกรมแก้ไขแพ็คเกจ คุณจะเห็นเหตุการณ์ OnFilter ปรากฏใน Object Inspector อย่างไรก็ตาม หากเรากำหนดตัวจัดการให้กับมันและรันโปรเจ็กต์เพื่อดำเนินการ มันก็อาจจะไม่ถูกเรียก เนื่องจากเราไม่ได้เรียกมันว่าที่ใดในองค์ประกอบของเรา ตำแหน่งที่ดีในการเรียกเหตุการณ์ OnFilter อยู่ในตัวจัดการเหตุการณ์ OnClick สำหรับ FButton ซึ่งมีการใช้งานอยู่แล้ว ดังนั้นเราจะเปลี่ยนรหัสการใช้งานของวิธี BtClick ที่กำหนดไว้ก่อนหน้านี้:

ขั้นตอน TListAdd.BtClick(Sender:TObject); var CanAdd:บูลีน; เริ่มต้นถ้า length(FEdit.Text)>0 จากนั้นเริ่ม CanAdd:=True;

ถ้าได้รับมอบหมาย (FOnFilter) แล้ว FOnFilter (Self, FEdit.Text, CanAdd);<>ถ้า CanAdd ให้เริ่ม FListBox.Items.Add(FEdit.Text);<>FEdit.Text:=""; FEdit.SetFocus;ปิดเสียงบี๊บ;

จบ; จบ;

ดังนั้นในข้อมูลโค้ดข้างต้น ตัวแปรบูลีน CanAdd จึงถูกกำหนดไว้ เมื่อเขียนโค้ด โปรดทราบว่าโปรแกรมเมอร์อาจไม่สร้างตัวจัดการเหตุการณ์ OnFilter ดังนั้นเราจึงตั้งค่าเริ่มต้นของตัวแปร CanAdd เป็น True - เพิ่มแถวทั้งหมดลงในรายการ ถัดไป ก่อนที่จะเรียก FonFilter คุณควรตรวจสอบว่าโปรแกรมเมอร์ได้สร้างตัวจัดการเหตุการณ์หรือไม่ ซึ่งสามารถทำได้โดยการเรียกเมธอด Assigned ซึ่งส่งกลับค่าบูลีน สำหรับพอยน์เตอร์ การเรียกเมธอด Assigned จะเทียบเท่ากับการตรวจสอบ P<="Z"); end;

โค้ดนี้เข้าใจง่าย ข้อแม้เดียวคือตรวจสอบว่าข้อความไม่ใช่สตริงว่าง ก่อนที่จะตรวจสอบตัวอักษรตัวแรกของข้อความในตัวจัดการเหตุการณ์ ListAdd2Filter การตรวจสอบนี้มีผลบังคับใช้: สตริงใน Object Pascal คืออ็อบเจ็กต์ และสตริงว่างสอดคล้องกับตัวชี้ศูนย์ หากคุณพยายามตรวจสอบตัวอักษรตัวแรกของสตริงว่าง แอปพลิเคชันจะพยายามยกเลิกการอ้างอิง nil ซึ่งจะทำให้เกิดข้อยกเว้น ในกรณีนี้ นี่ไม่ใช่ปัญหา: ก่อนที่จะเรียกตัวจัดการเหตุการณ์ FOnFilter จากคอมโพเนนต์ TListAdd สตริงจะถูกตรวจสอบสำหรับความยาวที่ไม่ใช่ศูนย์ อย่างไรก็ตาม สำหรับส่วนประกอบที่คุณไม่สามารถใช้ซอร์สโค้ดได้ จำเป็นต้องมีการตรวจสอบดังกล่าว!

การซ่อนคุณสมบัติในตัวตรวจสอบวัตถุ

สมมติว่าคุณกำลังสร้างส่วนประกอบการเข้าถึงข้อมูล เช่น ทายาทของคลาส TTable สมมติว่าส่วนประกอบนี้วิเคราะห์รายการตารางที่มีอยู่ในฐานข้อมูล และขึ้นอยู่กับเกณฑ์บางประการ (เช่น การมีอยู่ของฟิลด์บางประเภทและมีชื่อที่แน่นอน) รายการหนึ่งจะถูกเลือกสำหรับงาน สำหรับการทำงานปกติของส่วนประกอบ จะต้องป้อนชื่อของตารางนี้ในคุณสมบัติ TableName แต่คุณสมบัตินี้มองเห็นได้ในตัวตรวจสอบวัตถุ! โปรแกรมเมอร์ที่ใช้ส่วนประกอบนี้อาจเปลี่ยนค่าในระหว่างการพัฒนา ซึ่งอาจทำให้ส่วนประกอบไม่สามารถใช้งานได้ และเขาจะพูดถูก! หากไม่สามารถเปลี่ยนแปลงคุณสมบัติหรือเหตุการณ์ใดๆ ได้ ควรซ่อนไว้

เราจะทำงานกับส่วนประกอบ TListAdd ต่อไป และลบคุณสมบัติ Cursor ออกจากตัวตรวจสอบวัตถุเป็นงานโมเดล คุณสมบัตินี้ถูกกำหนดไว้ในส่วนเผยแพร่ของคลาส TControl และแสดงในตัวตรวจสอบวัตถุสำหรับ TListAdd ตั้งแต่เริ่มต้นของการพัฒนาส่วนประกอบ จากนี้ คุณสามารถลองกำหนดใหม่ได้ คุณสมบัตินี้ในส่วนการป้องกัน คอมไพลเลอร์จะอนุญาตให้มีการแทนที่ แต่จะไม่นำไปสู่ผลลัพธ์ที่ต้องการ: คุณสมบัติเคอร์เซอร์จะยังคงอยู่ในตัวตรวจสอบวัตถุเหมือนเดิม... คุณสมบัติใด ๆ เมื่อกำหนดไว้ในส่วนที่เผยแพร่แล้วจะถูกแสดงในวัตถุเสมอ ผู้ตรวจสอบลูกหลานทั้งหมดของคลาสนี้

ในการซ่อนคุณสมบัติจากตัวตรวจสอบวัตถุ เราใช้คุณสมบัติสองประการของคอมไพเลอร์ Delphi กล่าวคือ:

1. เมื่อประกาศทรัพย์สินใหม่โดยใช้ชื่อเดียวกันกับทรัพย์สินที่มีอยู่ ทรัพย์สินที่กำหนดไว้ก่อนหน้านี้จะถูก “ซ่อน”
2. คุณสมบัติที่มีสิทธิ์การเข้าถึงแบบอ่านอย่างเดียวหรือเขียนอย่างเดียวจะไม่ปรากฏในตัวตรวจสอบวัตถุ แม้ว่าคุณสมบัติเหล่านั้นจะถูกประกาศในส่วนที่เผยแพร่ก็ตาม

ก่อนที่คุณจะเริ่มทำงานในการซ่อนคุณสมบัติเคอร์เซอร์ เป็นความคิดที่ดีที่จะลบส่วนประกอบ TListAdd ออกจากแบบฟอร์ม มิฉะนั้นอาจเกิดข้อยกเว้นเมื่ออ่านทรัพยากรของฟอร์ม ดังนั้น ในส่วนส่วนตัว เราประกาศตัวแปร FDummy:integer (ชื่อและประเภทของตัวแปรสามารถเป็นอะไรก็ได้) และในส่วนที่เผยแพร่ เรากำหนดคุณสมบัติใหม่:

เคอร์เซอร์คุณสมบัติ: จำนวนเต็มอ่าน FDummy;

คุณสมบัติใหม่จะต้องเรียกว่าเคอร์เซอร์ ประเภทของมันจะต้องตรงกับประเภทของตัวแปรที่กำหนดไว้ข้างต้น คุณสมบัติจะต้องเป็นแบบอ่านอย่างเดียวหรือเขียนอย่างเดียว หลังจากรวบรวมส่วนประกอบโดยใช้ตัวแก้ไขแพ็คเกจ คุณควรวางส่วนประกอบ TListAdd ลงในแบบฟอร์มอีกครั้ง คุณอาจพบว่าคุณสมบัติเคอร์เซอร์ไม่ปรากฏใน Object Inspector อีกต่อไป

ตอนนี้เรามาทำให้งานซับซ้อนขึ้นเล็กน้อย สมมติว่าคุณต้องการให้เคอร์เซอร์แสดงไม่ใช่ลูกศร แต่เป็นนาฬิกาทราย (crHourGlass) หากต้องการเปลี่ยนค่าเริ่มต้นของคุณสมบัติ ต้องกำหนดค่าใหม่ให้กับตัวแปรในตัวสร้าง เมื่อพยายามกำหนดค่าใหม่ให้กับเคอร์เซอร์ในตัวสร้าง

เคอร์เซอร์:=crHourGlass;

คอมไพเลอร์ Delphi จะส่งข้อความวินิจฉัยว่าไม่สามารถกำหนดค่าใหม่ให้กับตัวแปรแบบอ่านอย่างเดียวได้ หากคุณสร้างคุณสมบัติ "เขียนอย่างเดียว" ใหม่ คอมไพลเลอร์จะส่งข้อความวินิจฉัยอื่นเกี่ยวกับประเภทข้อมูลที่เข้ากันไม่ได้ หากคุณประกาศตัวแปร FDummy:TCursor และกำหนดให้เป็นแบบเขียนอย่างเดียว คอมไพลเลอร์จะอนุญาตการมอบหมายนี้ แต่รูปลักษณ์ของเคอร์เซอร์จะไม่เปลี่ยนแปลง แต่จะยังคงเป็นลูกศร

วิธีแก้ไขเล็กๆ น้อยๆ สำหรับปัญหานี้คือการประกาศคลาสสืบทอดของ TCustomPanel ในตัวสร้างที่คุณต้องกำหนดค่าใหม่ให้กับตัวแปร Cursor จากนั้นจึงสร้างส่วนประกอบ TListAdd ของเรา โซลูชันนี้มีข้อเสียสองประการ:

1. ต้องใช้ทรัพยากรมาก - วิธีการเสมือนทวีคูณ
2. เราซ่อนคุณสมบัติในตัวตรวจสอบวัตถุจากโปรแกรมเมอร์ที่จะใช้ส่วนประกอบนี้ เราต้องการทำงานกับทรัพย์สินนี้

ดังนั้นวิธีแก้ปัญหานี้จึงเป็นดังนี้: ในตัวสร้าง TListAdd เราประกาศตัวดำเนินการ:

เคอร์เซอร์ที่สืบทอดมา:=crHourGlass;

และนั่นมัน! เพียงพอที่จะเปลี่ยนเคอร์เซอร์

ก่อนหน้านี้ เราใช้คำฟังก์ชันที่สืบทอดมาเพื่อเรียกเมธอดบรรพบุรุษเท่านั้น โครงสร้างนี้ช่วยให้คุณเข้าใจความหมายของการสืบทอดได้ดีขึ้นโดยอ้างอิงถึงคลาสบรรพบุรุษ คุณสามารถเข้าถึงทั้งคุณสมบัติและวิธีการ เมื่อเข้าถึงคุณสมบัติ คุณสามารถอ่านหรือกำหนดค่าใหม่ให้กับคุณสมบัตินั้นได้ ในกรณีนี้ คำช่วยที่สืบทอดมาจะปรากฏทางด้านซ้ายของป้ายมอบหมายงาน ในทำนองเดียวกัน คุณสามารถเรียกเมธอดบรรพบุรุษที่ซ่อนอยู่ได้ ห้ามเรียกลำดับชั้นที่สูงกว่าคลาสบรรพบุรุษ - การก่อสร้าง

เคอร์เซอร์ที่สืบทอดมา:=crHourGlass;

จะไม่รวบรวม

ณ จุดนี้เราจะถือว่าโครงการนี้เสร็จสมบูรณ์ ในองค์ประกอบใหม่ เราดักจับข้อความ ประกาศคุณสมบัติ เพิ่มคุณสมบัติและเหตุการณ์ใหม่ และซ่อนคุณสมบัติที่ประกาศไว้ก่อนหน้านี้ วิธีการทั้งหมดนี้ใช้เพื่อสร้างส่วนประกอบ ด้านล่างเราจะดูวิธีการอื่นที่น่าสนใจ

การใช้ขั้นตอน Hook เพื่อสร้างส่วนประกอบ

ได้มีการกล่าวไว้ก่อนหน้านี้ว่า TWinControl child แต่ละตัวมีขั้นตอนในการรับและประมวลผลข้อความ หากมีการอ้างอิงถึงตัวจัดการหน้าต่าง (HWND) คุณสามารถกำหนดที่อยู่ของขั้นตอนนี้ได้ และที่สำคัญกว่านั้นคือแทนที่ที่อยู่นี้และประมวลผลข้อความที่ได้รับด้วยวิธีของคุณเอง ตามกฎแล้ว ไม่มีใครเขียนตัวจัดการที่สมบูรณ์สำหรับข้อความทั้งหมด วิธีการเริ่มต้นแบบเก่าจะถูกเรียกบ่อยกว่า ในกรณีนี้ ขั้นตอนใหม่จะถูกใช้เป็นตัวกรอง: เมื่อมีเหตุการณ์มาถึง รหัสจะถูกดำเนินการ อันที่จริง นี่คือ "สายลับ" ใน TwinControl: เราได้รับแจ้งเมื่อมีข้อความมาถึงและโค้ดบางส่วนสามารถดำเนินการได้ หากใช้ขั้นตอน Hook อย่างถูกต้อง TWinControl จะยังคงทำงานตามปกติ โดยไม่รู้ว่ากำลังแชร์ข้อความกับบุคคลอื่น

ขั้นตอนของ hook ถูกกำหนดไว้ดังนี้:

ขั้นตอน (var Message:TMessage) ของ object;

ขึ้นอยู่กับตัวแปรประเภท TMessage ซึ่งมีข้อมูลทั้งหมดเกี่ยวกับข้อความ แต่การกำหนดขั้นตอนนี้ยังไม่เพียงพอ จะต้องคัดลอกสำหรับแต่ละ TWinControl ที่จะแนบ สิ่งนี้สามารถทำได้โดยการเรียกเมธอด WinAPI MakeObjectInstance เมธอดนี้ใช้เมธอดอ็อบเจ็กต์เป็นพารามิเตอร์ สร้างสำเนาในหน่วยความจำ และส่งกลับแอดเดรสของเมธอดใหม่ เห็นได้ชัดว่านี่เป็นการสำรองทรัพยากรระบบที่ต้องส่งคืนให้กับระบบ สิ่งนี้สามารถทำได้โดยการเรียกเมธอด FreeObjectInstance

เงื่อนไขที่สำคัญอีกประการหนึ่ง: ก่อนที่จะทำลาย TWinControl จะต้องกู้คืนการสื่อสารกับขั้นตอนการประมวลผลข้อความเก่า มิฉะนั้นทรัพยากรจะไม่ถูกส่งกลับไปยังระบบ ซึ่งหมายความว่าคุณจะต้องจำตัวชี้ไปยังขั้นตอนเก่า ซึ่งสามารถพบได้โดยการเรียกเมธอด Win API GetWindowLong ด้วยพารามิเตอร์ GWL_WNDPROC ตัวชี้นี้จะใช้เพื่อเรียกตัวจัดการเหตุการณ์เริ่มต้นของ TWinControl วิธีการย้อนกลับ SetWindowLong ใช้เพื่อตั้งค่าขั้นตอน Hook

ดังนั้น เรามากำหนดปัญหาสำหรับการฝึกครั้งต่อไปกันดีกว่า สมมติว่าเราต้องการสร้างส่วนประกอบที่จะทำให้ส่วนประกอบอื่น ๆ - ผู้สืบทอดของ TWinControl - ส่งเสียงบี๊บเมื่อกดปุ่มเมาส์ เป็นที่ชัดเจนว่าไม่ควรแสดงส่วนประกอบนี้ในระหว่างการดำเนินการแอปพลิเคชัน ดังนั้นเราจะเลือก TComponent เป็นคลาสบรรพบุรุษ มากำหนดชื่อคลาสเป็น TBeepWnd ในส่วนส่วนตัว เรากำหนดตัวแปรสามตัว:

FoldProc, FNewProc: ตัวชี้;

Fการควบคุม:TWinControl;

จากชื่อเป็นที่ชัดเจนว่าเราจะจดจำลิงก์ไปยังโพรซีเดอร์เก่าในตัวแปร FOldProc ลิงก์ไปยังโพรซีเดอร์ใหม่ (หลังจากดำเนินการเมธอด MakeObjectInstance) จะถูกเก็บไว้ในตัวแปร FNewProc และในตัวแปร FControl เราจะบันทึกลิงก์ไปยังองค์ประกอบควบคุมที่ขั้นตอน Hook อยู่ในสถานะ "หยุดทำงาน" มากำหนดสามวิธีในส่วนเดียวกัน:

ขั้นตอน HookProc(var Message:TMessage); ขั้นตอน HookWindow(W:TWinControl); ขั้นตอน UnhookWindow;

และในส่วนการนำไปปฏิบัติเราจะนำไปปฏิบัติ:

ในขั้นตอนของ Hook ข้อความจะถูกดักซึ่งมีปฏิกิริยาเกิดขึ้น - WM_LBUTTONDOWN นอกจากนี้ ขั้นตอนของ Hook ใด ๆ ต้องจัดการข้อความ WM_DESTROY นี่เป็นข้อความสุดท้ายที่ส่งไปยังหน้าต่างก่อนที่จะถูกทำลาย การตอบสนองของเราคือการกู้คืนวิธีก่อนหน้าโดยการเรียกวิธี UnhookWindow ที่อธิบายไว้ด้านล่าง ในที่สุด ตัวจัดการข้อความเริ่มต้นจะถูกเรียกตลอดโดยใช้เมธอด CallWindowProc การลืมตัวจัดการเหตุการณ์เริ่มต้นจะเหมือนกับการลืมที่สืบทอดมาในตัวจัดการเหตุการณ์ ใน 80% ของกรณีนี้จะนำไปสู่พฤติกรรมของแอปพลิเคชันที่ไม่ถูกต้อง ไม่ว่าในกรณีใดคุณไม่ควรลืมกำหนดผลลัพธ์ของการเรียกใช้เมธอด CallWindowProc ให้กับฟิลด์ Result ของตัวแปร Message! รหัสจะไม่ทำงานในกรณีนี้!

ขั้นตอน TBeepWnd.HookWindow(W:TWinControl); เริ่มต้นถ้า csDesigning ใน ComponentState จากนั้นเริ่มต้น (ตรวจสอบว่าส่วนประกอบที่การออกแบบหรือรันไทม์) FControl:=W;<>ออก;<>จบ; ถ้า FControl

ไม่มีแล้ว UnhookWindow; (ถอดตะขอออกหากเคยติดตั้งไว้ก่อนหน้านี้) หาก W

ขั้นตอน TBeepWnd.UnhookWindow; เริ่มต้นถ้า (FControl=nil) หรือ (FoldProc=nil) หรือ (FNewProc=nil) แล้วออก; (ไม่ได้ติดตั้ง hook) SetWindowLong(FControl.Handle,GWL_WNDPROC,integer(FoldProc)); (ตั้งค่าขั้นตอนหน้าต่างเก่า) FreeObjectInstance(FNewProc); (ทรัพยากรฟรี) FControl:=nil; (เริ่มต้นตัวแปร) FOldProc:=nil;

FNewProc:=ไม่มี; จบ;

วิธีนี้จะคืนค่าตัวจัดการเหตุการณ์เก่า มันถูกเรียกจากวิธี HookProc และต้องถูกเรียกจาก destructor ของส่วนประกอบด้วย - ต้องลบ Hook ออกทั้งเมื่อหน้าต่างถูกทำลายและเมื่อส่วนประกอบนี้ถูกทำลาย วิธีการSetWindowLongที่มีที่อยู่ของวิธีการเก่าคืนค่าตัวจัดการข้อความเก่า หลังจากนี้ คุณควรส่งคืนทรัพยากรไปยังระบบโดยการเรียกเมธอด FreeObjectInstance

ดังนั้นจึงได้มีการกำหนดวิธีการพื้นฐานสำหรับการทำงานกับขั้นตอน Hook แล้ว ตอนนี้คุณต้องเขียน destructor ใหม่เพื่อให้ขั้นตอน Hook ถูกลบออกเมื่อส่วนประกอบนี้ถูกทำลาย:

Destructor TBeepWnd.ทำลาย; เริ่ม UnhookWindow;

สืบทอดมาทำลาย; จบ;

และสุดท้าย ในส่วนที่เผยแพร่ เรากำหนดคุณสมบัติที่จะแสดงในตัวตรวจสอบวัตถุ:

การควบคุมคุณสมบัติ: TWinControl อ่าน FControl เขียน HookWindow;

ในการติดตั้งส่วนประกอบใหม่ เราอ้างถึงวิธีการที่กำหนดไว้ก่อนหน้านี้ ซึ่งในขณะที่แอปพลิเคชันกำลังทำงานอยู่ จะ "หยุด" ขั้นตอน Hook บนส่วนประกอบทันที ซึ่งจะส่งเสียงบี๊บเมื่อกดปุ่ม โปรดจำไว้ว่าแทนที่จะใช้ตัวดำเนินการ Beep คุณสามารถเขียนโค้ดที่ปฏิบัติการได้

ทุกสิ่งที่กล่าวถึงในส่วนก่อนหน้านี้เกี่ยวข้องกับการสร้างโค้ดแอปพลิเคชันที่จะแจกจ่ายให้กับผู้ใช้ อย่างไรก็ตาม สภาพแวดล้อมการพัฒนา Delphi ช่วยให้คุณสามารถปรับเปลี่ยนตัวเองได้ สิ่งนี้ไม่จำเป็นต้องมีความรู้ภาษาพิเศษ เนื่องจากวิธีการทั้งหมดในการเปลี่ยนแปลงสภาพแวดล้อมการพัฒนาเขียนด้วย Delphi วิธีการเหล่านี้ ได้แก่ ตัวแก้ไขคุณสมบัติและตัวแก้ไขส่วนประกอบ ถือเป็นบางส่วน - ในแง่ของการสร้างเครื่องมือสำหรับการทำงานกับส่วนประกอบ เมื่ออ่านเนื้อหาในส่วนนี้ คุณควรเข้าใจอย่างชัดเจนว่าผู้ใช้ปลายทางที่ทำงานกับแอปพลิเคชันของคุณจะไม่เห็นตัวแก้ไขคุณสมบัติหรือตัวแก้ไขส่วนประกอบ - สร้างขึ้นสำหรับโปรแกรมเมอร์และทำงานเฉพาะในสภาพแวดล้อมการพัฒนา Delphi เท่านั้น

บรรณาธิการทรัพย์สิน

ในระหว่างการพัฒนาแอปพลิเคชัน คุณสมบัติจะแสดงในตัวตรวจสอบวัตถุ โปรดทราบว่าคุณสมบัติได้รับการแก้ไขแตกต่างออกไปใน Object Inspector คุณสมบัติบางอย่าง (ความกว้าง คำบรรยาย) สามารถกำหนดค่าข้อความใหม่ได้เท่านั้น คุณสมบัติประเภทเคอร์เซอร์จะมีรายการแบบเลื่อนลงที่คุณสามารถคลิกเพื่อเลือกค่าได้ คุณสมบัติประเภท TFont มีเครื่องหมาย "+" ทางด้านซ้าย เมื่อคุณคลิก มันจะขยายออก ทำให้คุณสามารถแก้ไขแต่ละฟิลด์ได้ นอกจากนี้ ทางด้านขวาจะมีปุ่มที่มีจุดสามจุด (ปุ่มรูปไข่) เมื่อคลิก กล่องโต้ตอบตัวแก้ไขคุณสมบัติจะปรากฏขึ้น

คุณสมบัติแต่ละอย่างข้างต้นมีตัวแก้ไขของตัวเอง และข้อดีที่สำคัญของสภาพแวดล้อมการพัฒนา Delphi คือความสามารถในการสร้างตัวแก้ไขคุณสมบัติของคุณเอง ตัวแก้ไขคุณสมบัติใหม่ค่อนข้างพบได้ทั่วไปในคอมโพเนนต์แบบกระจาย แต่จะต้องได้รับการปฏิบัติด้วยความระมัดระวัง: เริ่มแรกให้ทำการทดสอบบนคอมพิวเตอร์ที่คุณสามารถติดตั้ง Delphi ใหม่ได้หากจำเป็น ตามกฎแล้วพวกมันถูกสร้างขึ้นโดยโปรแกรมเมอร์ที่มีคุณสมบัติเหมาะสมและไม่มีข้อตำหนิเกี่ยวกับโค้ด แต่มักจะลืมรวม DLL ใด ๆ ไว้ในตัวแก้ไขคุณสมบัติแบบกระจาย หลังจากติดตั้งตัวแก้ไขดังกล่าว เราจะพบคุณสมบัติจำนวนหนึ่งที่ไม่สามารถแก้ไขได้ - ตัวแก้ไขเก่าถูกบล็อก และตัวแก้ไขใหม่ใช้งานไม่ได้...

ก่อนที่จะสร้างตัวแก้ไขคุณสมบัติใหม่ ควรพิจารณาว่าควรทำสิ่งนี้หรือไม่ คุณอาจจะพบตัวแก้ไขที่เหมาะสมในบรรดาตัวแก้ไขมาตรฐานก็ได้ หากคุณต้องสร้างตัวแก้ไขคุณสมบัติ คุณต้องปฏิบัติตามกฎ: คุณควรหลีกเลี่ยงการสร้างตัวแก้ไขสำหรับชนิดข้อมูลมาตรฐาน (จำนวนเต็ม สตริง ฯลฯ) โปรแกรมเมอร์คนอื่นๆ คุ้นเคยกับโปรแกรมแก้ไขมาตรฐาน และพวกเขาอาจไม่ชอบโปรแกรมแก้ไขของคุณ ดังนั้น คุณจะต้องถ่อมตัวและลงทะเบียนเอดิเตอร์สำหรับคลาสของคุณ ไม่ใช่สำหรับคลาส TComponent หากโปรแกรมเมอร์ชอบตัวแก้ไขคุณสมบัติของคุณ ส่วนใหญ่จะสามารถเปลี่ยนการลงทะเบียนได้ด้วยตนเอง เพื่อให้ตัวแก้ไขทำงานได้กับส่วนประกอบทั้งหมด เราจะหารือเกี่ยวกับปัญหาการลงทะเบียนบรรณาธิการด้านล่าง

ดังนั้น เรามาสร้างปัญหาโมเดลสำหรับการนำไปปฏิบัติซึ่งจำเป็นต้องใช้ตัวแก้ไขคุณสมบัติ สมมติว่าองค์ประกอบบางส่วนมีคุณสมบัติ - วันในสัปดาห์ โดยหลักการแล้ว หากต้องการป้อนวันในสัปดาห์ คุณสามารถใช้โปรแกรมแก้ไขมาตรฐานพร้อมรายการแบบเลื่อนลงได้ อย่างไรก็ตาม เราต้องการให้โปรแกรมเมอร์ที่อยู่ในขั้นตอนการพัฒนาสามารถป้อนวันในสัปดาห์ โดยระบุหมายเลขซีเรียล (1 - วันจันทร์, 2 - วันอังคาร ฯลฯ) หรือข้อความเป็นภาษาประจำชาติหรือภาษาอังกฤษ เมื่อป้อนข้อความ อนุญาตให้ผสมอักษรตัวพิมพ์ใหญ่และตัวพิมพ์เล็กได้

ก่อนอื่น คุณต้องสร้างส่วนประกอบที่จะจัดเก็บวันในสัปดาห์ มาสร้างส่วนประกอบใหม่โดยการเรียกคำสั่ง Component/New Component เลือก TComponent เป็นคลาสบรรพบุรุษและตั้งชื่อคลาสใหม่ว่า TDayStore หลังจากนั้นให้ติดตั้งส่วนประกอบในจานสี ตอนนี้เราต้องตัดสินใจว่าจะจัดเก็บวันในสัปดาห์ในรูปแบบใด เป็นที่ชัดเจนว่าเพื่อการระบุที่ชัดเจนและประหยัดทรัพยากร ควรจัดเก็บเป็นจำนวนเต็มโดยมีช่วงที่ถูกต้อง 1-7 อย่างไรก็ตาม หากเราจะสร้างตัวแก้ไขคุณสมบัติ เราควรจำกฎเกี่ยวกับการไม่สร้างตัวแก้ไขใหม่สำหรับประเภทที่มีอยู่ ดังนั้นเราจะกำหนดประเภทใหม่ - TDayWeek และเราจะดำเนินการทั้งหมดกับมันเช่นเดียวกับจำนวนเต็ม มากำหนดตัวแปร FDay ในส่วนส่วนตัวของส่วนประกอบกัน เนื่องจากตัวแปรนี้จะเริ่มต้นเป็น 0 เมื่อมีการดำเนินการตัวสร้างเริ่มต้น และตัวเลขนี้อยู่นอกค่าที่อนุญาต ตัวสร้างจะต้องถูกเขียนใหม่ สุดท้ายนี้ เรามากำหนดคุณสมบัติ DayWeek ในส่วนเผยแพร่เพื่อแสดงในตัวตรวจสอบวัตถุ องค์ประกอบสุดท้ายมีลักษณะดังนี้:

พิมพ์ TDayWeek=พิมพ์จำนวนเต็ม;

TDayStore = คลาส (TComponent) ส่วนตัว (การประกาศส่วนตัว) FDay: TDayWeek;

ได้รับการคุ้มครอง ( ประกาศที่ได้รับการคุ้มครอง ) สาธารณะ ( ประกาศสาธารณะ ) ตัวสร้าง สร้าง (AOwner: TComponent); แทนที่;

เผยแพร่ (ประกาศเผยแพร่) คุณสมบัติ DayWeek:TDayWeek อ่าน FDay เขียน FDay;

จบ; ... ตัวสร้างการใช้งาน TDayStore.Create (AOwner: TComponent); เริ่มสืบทอดสร้าง (Aowner);

วันศุกร์:=1; จบ;

1. เป็นสิ่งที่ควรค่าแก่การใส่ใจกับการสร้างคำจำกัดความประเภทใหม่ที่หายาก

   TDayWeek=พิมพ์จำนวนเต็ม;

   ดังนั้นจึงมีการแนะนำประเภทข้อมูลใหม่ซึ่งมีขนาดเท่ากับประเภทจำนวนเต็ม การดำเนินการทั้งหมดในประเภทข้อมูลนี้จะดำเนินการเช่นเดียวกับจำนวนเต็ม จุดประสงค์ของการดำเนินการนี้คือการประกาศประเภทข้อมูลใหม่เพื่อให้สามารถใช้ตัวแก้ไขคุณสมบัติของเรากับข้อมูลดังกล่าวโดยเฉพาะ และไม่ส่งผลกระทบต่อประเภทข้อมูลอื่น

   ตอนนี้เรามาสร้างตัวแก้ไขสำหรับคุณสมบัติ TDayWeek กันดีกว่า ในการดำเนินการนี้ ให้เพิ่มแบบฟอร์มใหม่ให้กับโปรเจ็กต์ที่มีอยู่ จำไว้ภายใต้ชื่อที่เหมาะสม (DayPropE.pas) และแยกออกจากโปรเจ็กต์ หลังจากนี้ เราจะเปิดแบบฟอร์มเป็นไฟล์แยกต่างหาก และใช้ตัวแก้ไขคุณสมบัติในนั้น ในระยะแรกเราไม่จำเป็นต้องมีแบบฟอร์ม แต่ภายหลังเราจะดำเนินการโต้ตอบกับแบบฟอร์มนั้น

2. โมดูลสำหรับการสร้างตัวแก้ไขคุณสมบัติเรียกว่า DsgnIntf.pas (Design Interface) ซึ่งกำหนดคลาสพื้นฐาน TPropertyEditor และคลาสสืบทอดที่มีไว้สำหรับการแก้ไขคุณสมบัติมาตรฐาน - TIntegerProperty, TFloatProperty, TStringProperty เป็นต้น กลไกการทำงานของตัวแก้ไขคุณสมบัติมีดังนี้:
3. เมธอด SetValue จะถูกเรียกเมื่อโปรแกรมเมอร์ได้ป้อนค่าคุณสมบัติใหม่ใน Object Inspector สตริงใหม่ถูกส่งผ่านเป็นพารามิเตอร์ โดยวิธีการจะต้องวิเคราะห์และแปลงเป็นประเภทคุณสมบัติที่กำลังแก้ไข

เมธอด GetValue และ SetValue เป็นแบบเสมือน เมื่อเขียนใหม่ จะมีการสร้างตัวแก้ไขคุณสมบัติใหม่ ตอนนี้เราสามารถเริ่มสร้างตัวแก้ไขคุณสมบัติใหม่ได้แล้ว

มาดูโมดูล DsgnIntf ​​​​ในส่วนการใช้งานของโมดูล DayPropE.pas และกำหนดคลาสใหม่ในส่วนอินเทอร์เฟซ:

พิมพ์ฟังก์ชันสาธารณะ TDWPropED=class(TPropertyEditor) GetValue:string; แทนที่;

ขั้นตอน SetValue (ค่า const: string); แทนที่;

จบ;

• ส่วนการดำเนินการควรใช้ทั้งสองวิธีนี้ ในกรณีนี้ เราต้องการรายชื่อวันในสัปดาห์เพิ่มเติม - ในการกำหนดปัญหาเบื้องต้น โปรแกรมเมอร์ต้องสามารถป้อนวันในสัปดาห์ได้:
• Const DayWeek:อาร์เรย์ของสตริง = ("วันจันทร์", "วันอังคาร", "วันพุธ", "วันพฤหัสบดี", "วันศุกร์", "วันเสาร์", "วันอาทิตย์");
• DayWeekEn:array of string = ("วันจันทร์", "วันอังคาร", "วันพุธ", "วันพฤหัสบดี", "วันศุกร์", "วันเสาร์", "วันอาทิตย์");
• ทบทวน

1. ส่วนการดำเนินการควรใช้ทั้งสองวิธีนี้ ในกรณีนี้ เราต้องการรายชื่อวันในสัปดาห์เพิ่มเติม - ในการกำหนดปัญหาเบื้องต้น โปรแกรมเมอร์ต้องสามารถป้อนวันในสัปดาห์ได้:
2. แบบแผนการตั้งชื่อ

   การคัดเลือกบรรพบุรุษ

3. ตัวอย่างการสร้างส่วนประกอบ
4. เนื่องจาก Delphi เป็นสภาพแวดล้อมแบบเปิดและช่วยให้คุณไม่เพียงแต่ใช้วัตถุจาก Visual Component Library (VCL) ในโปรแกรมของคุณเท่านั้น แต่ยังสามารถสร้างวัตถุใหม่ได้อีกด้วย ยิ่งไปกว่านั้น ไม่มีอะไรนอกจาก Delphi ที่จำเป็นสำหรับสิ่งนี้ การสร้างวัตถุใหม่ใน Delphi ไม่ใช่เรื่องยาก แม้ว่าจะต้องอาศัยความรู้เกี่ยวกับ Windows API, การเขียนโปรแกรมเชิงวัตถุ และลำดับชั้นของคลาสใน VCL

   คำถามอาจเกิดขึ้น; ถ้า Delphi มีไลบรารีของตัวเองอยู่แล้ว ทำไมต้องสร้างอ็อบเจ็กต์อื่นอีก? 1 คำตอบนั้นง่ายมาก: คุณไม่สามารถสร้างห้องสมุดสำหรับทุกโอกาสและทุกรสนิยมได้ ประการแรก ส่วนประกอบใหม่ช่วยให้คุณสามารถขยายขอบเขตของ Delphi ได้ เช่น การใช้ไลบรารีวัตถุของบุคคลที่สามเพื่อพัฒนาแอปพลิเคชันสำหรับการทำงานบนอินเทอร์เน็ต

   คลิก “เพิ่ม” และระบุโมดูลที่มีขั้นตอนการลงทะเบียน คลิก “ตกลง” และหลังจากการคอมไพล์ใหม่สำเร็จ ออบเจ็กต์ใหม่จะปรากฏในจานสี

5. ว่างเปล่าสำหรับส่วนประกอบใหม่
6. ในสภาพแวดล้อม Delphi มีผู้เชี่ยวชาญพิเศษที่สร้างเทมเพลตสำหรับส่วนประกอบใหม่ คุณสามารถเรียกมันได้ในรายการเมนู ไฟล์|ส่วนประกอบใหม่... (ดูรูปที่ 2)

   
   

   คำถามอาจเกิดขึ้น; ถ้า Delphi มีไลบรารีของตัวเองอยู่แล้ว ทำไมต้องสร้างอ็อบเจ็กต์อื่นอีก? 2 : ผู้เชี่ยวชาญในการสร้างส่วนประกอบใหม่

   ในกล่องโต้ตอบ คุณต้องระบุชื่อของคลาสใหม่ (เช่น TMyButton) บรรพบุรุษของคลาส (TButton) และหน้าจานสีที่จะวางส่วนประกอบใหม่ (ตัวอย่าง) หากคุณคลิก "ตกลง" ผู้เชี่ยวชาญจะสร้างโมดูล - เทมเพลตสำหรับส่วนประกอบใหม่:

   หน่วย หน่วยที่ 1;

   อินเตอร์เฟซ

   การใช้งาน

   SysUtils, WinTypes, WinProcs, ข้อความ, คลาส, กราฟิก, การควบคุม,

   แบบฟอร์ม, กล่องโต้ตอบ, StdCtrls;

   พิมพ์

   TMyButton = คลาส (TButton)

   ส่วนตัว

   (ประกาศส่วนตัว)

   ได้รับการคุ้มครอง

   (ประกาศที่ได้รับการคุ้มครอง)

   สาธารณะ

   (ประกาศสาธารณะ)

   ที่ตีพิมพ์

   (ประกาศเผยแพร่)

   จบ;

   ขั้นตอนการลงทะเบียน;

   การดำเนินการ

   ขั้นตอนการลงทะเบียน;

   เริ่ม

   RegisterComponents("ตัวอย่าง", );

   จบ;

   จบ.

   โมดูลประกอบด้วยการประกาศคลาสใหม่และขั้นตอนการลงทะเบียนใน Component Palette อยู่ในขั้นตอนลงทะเบียนส่วนประกอบ พารามิเตอร์แรกคือชื่อของเพจ (คุณสามารถระบุชื่อของคุณ - หน้าใหม่จะปรากฏขึ้น) พารามิเตอร์ที่สองคือชุดของวัตถุที่จะลงทะเบียน

   ตอนนี้คุณต้องบันทึกโมดูลภายใต้ชื่อใหม่ (เช่น NEW_BTN.PAS) และเริ่มเพิ่มคุณสมบัติและวิธีการใหม่ หลังจากงานนี้เสร็จสิ้นและส่วนประกอบใหม่ได้รับการดีบั๊กแล้ว คุณสามารถเพิ่มมันลงใน Palette ได้ (ดูบทที่แล้ว) แต่ก่อนหน้านั้น ขอแนะนำให้สร้างไฟล์ทรัพยากรที่จะมีไอคอนเพื่อแสดงวัตถุนี้ใน Component Palette ไฟล์ทรัพยากรสามารถสร้างขึ้นได้โดยใช้โปรแกรม Resource Workshop โดยจะต้องตั้งชื่อให้เหมือนกับโมดูลการลงทะเบียนส่วนประกอบทุกประการ และมีนามสกุล .DCR (เช่น หากวัตถุได้รับการลงทะเบียนในโมดูล NEW_Bเทนเนสซี .PAS ดังนั้นชื่อไฟล์ทรัพยากรจะเป็น NEW_BTN.DCR) ไฟล์ทรัพยากรจะต้องมีทรัพยากรประเภท BITMAP - รูปภาพที่มีขนาด 28x28 พิกเซล (เล็กกว่าถ้าเป็นไปได้) ชื่อของรูปภาพจะต้องตรงกับชื่อของคลาส (ในกรณีของเรา TMYBUTTON)

7. Const DayWeek:อาร์เรย์ของสตริง = ("วันจันทร์", "วันอังคาร", "วันพุธ", "วันพฤหัสบดี", "วันศุกร์", "วันเสาร์", "วันอาทิตย์");

หากคุณได้ดูซอร์สโค้ด VCL คุณอาจเห็นว่าเป็นไปตามแบบแผนง่ายๆ บางประการเมื่อกำหนดคลาสใหม่ Delphi ไม่ต้องการสิ่งนี้ ชื่อวิธีการ คุณสมบัติ ฯลฯ จะเป็นอะไรก็ได้คอมไพเลอร์ไม่สนใจ แต่ถ้าคุณปฏิบัติตามแบบแผนเหล่านี้ การพัฒนาส่วนประกอบใหม่และการอ่านซอร์สโค้ดก็จะง่ายขึ้นมาก

ดังนั้น:

• การประกาศประเภททั้งหมดขึ้นต้นด้วยตัวอักษร T อีกครั้งหนึ่งที่ Delphi ไม่ต้องการสิ่งนี้ แต่ทำให้ชัดเจนว่า "TEdit" เป็นคำนิยามประเภท ไม่ใช่ตัวแปรคลาสหรือฟิลด์
• ชื่อทรัพย์สินควรอ่านง่ายและให้ข้อมูล
• เราต้องจำไว้ว่าผู้ใช้จะเห็นพวกเขาในตัวตรวจสอบวัตถุ และชื่อเช่น "TextOrientation" สะดวกกว่า "TxtOr" มาก เช่นเดียวกับวิธีการต่างๆ
• วิธีการที่ผู้ใช้ใช้ได้ควรมีชื่อที่ใช้งานง่าย
• เมื่อสร้างคุณสมบัติของประเภทเหตุการณ์ ชื่อของคุณสมบัติดังกล่าวต้องขึ้นต้นด้วย “On” (เช่น OnClick, OnCreate ฯลฯ)
• ชื่อของวิธีการอ่านคุณสมบัติต้องขึ้นต้นด้วยคำว่า “Get”

ตัวอย่างเช่น วิธีการ GetStyle ต้องอ่านคุณสมบัติ Style

1. DayWeekEn:array of string = ("วันจันทร์", "วันอังคาร", "วันพุธ", "วันพฤหัสบดี", "วันศุกร์", "วันเสาร์", "วันอาทิตย์");

ชื่อวิธีการเขียนคุณสมบัติต้องขึ้นต้นด้วยคำว่า Set

• ตัวอย่างเช่น วิธีการ SetStyle ต้องเขียนไปยังคุณสมบัติ Style ช่องภายในสำหรับจัดเก็บข้อมูลทรัพย์สินต้องมีชื่อขึ้นต้นด้วยตัวอักษร “F”
• ตัวอย่างเช่น คุณสมบัติ Handle สามารถจัดเก็บไว้ในเขตข้อมูล FHandle แน่นอนว่ามีข้อยกเว้นสำหรับกฎเกณฑ์ บางครั้งการแบ่งพวกมันจะสะดวกกว่า เช่น คลาส TTable มีคุณสมบัติประเภทเหตุการณ์ที่เรียกว่า BeforePost, AfterPost เป็นต้น
• ก่อนที่คุณจะเริ่มเขียนโค้ด คุณต้องตัดสินใจว่าจะสร้างส่วนประกอบประเภทใดเป็นอย่างน้อยโดยประมาณ ถัดไป ขึ้นอยู่กับคุณสมบัติที่คาดไว้ ให้กำหนดคลาสบรรพบุรุษ VCL มีคลาสพื้นฐานหลายคลาสที่แนะนำสำหรับการสืบทอด: ถึงวัตถุ
• - สามารถใช้เป็นบรรพบุรุษได้หากไม่จำเป็นต้องใช้งานส่วนประกอบนี้ในระหว่างการออกแบบ นี่อาจเป็นคลาสที่มีค่าของตัวแปรสภาพแวดล้อมหรือคลาสสำหรับการทำงานกับไฟล์ INI ทีคอมโพเนนท์
• - จุดเริ่มต้นของส่วนประกอบที่มองไม่เห็นมากมาย คลาสนี้มีความสามารถในตัวในการบันทึก/อ่านตัวเองลงในสตรีมระหว่างการออกแบบ TGraphicControl
• - ใช้คลาสนี้เพื่อสร้างส่วนประกอบที่มองเห็นได้ซึ่งไม่จำเป็นต้องมีที่จับ ส่วนประกอบดังกล่าววาดบนพื้นผิวโดยตรงและต้องใช้ทรัพยากร Windows เพียงเล็กน้อย - คลาสเช่น TEdit หรือ TButton ใช้เพื่อกำหนดคุณสมบัติและวิธีการเพิ่มเติมหรือกำหนดค่าเริ่มต้นของคุณสมบัติใหม่

1. ทบทวน

ตัวอย่างเช่น เรามาสร้างคลาสใหม่ กลายพันธุ์ TButton ซึ่งเราจะเปลี่ยนค่าเริ่มต้นของคุณสมบัติ ShowHint เป็น True และเพิ่มคุณสมบัติใหม่ - ตัวนับการคลิกปุ่ม มีเทมเพลตโมดูลสำหรับสร้างส่วนประกอบใหม่อยู่แล้ว (ดูย่อหน้า ว่างเปล่าสำหรับส่วนประกอบใหม่- ตอนนี้ข้อความต้นฉบับมีลักษณะดังนี้:

หน่วย New_btn;

อินเตอร์เฟซ

การใช้งาน

SysUtils, WinTypes, WinProcs, ข้อความ, คลาส, กราฟิก,

การควบคุม แบบฟอร์ม กล่องโต้ตอบ StdCtrls;

พิมพ์

TMyButton = คลาส (TButton)

ส่วนตัว

(ประกาศส่วนตัว)

FClickCount: ลองจินต์;

ได้รับการคุ้มครอง

(ประกาศที่ได้รับการคุ้มครอง)

สาธารณะ

(ประกาศสาธารณะ)

ตัวสร้างสร้าง (AOwner: TComponent); แทนที่;

ขั้นตอน คลิก; แทนที่;

คุณสมบัติ ClickCount: Longint อ่าน FClickCount เขียน

FClickCount;

ที่ตีพิมพ์

(ประกาศเผยแพร่)

จบ;

ขั้นตอนการลงทะเบียน;

การดำเนินการ

ตัวสร้าง TMyButton.Create (AOwner: TComponent);

เริ่ม

สืบทอดสร้าง (AOwner);

ShowHint:=จริง;

FClickCount:=0;

จบ;

ขั้นตอน TMyButton.Click;

เริ่ม

Inc(FClickCount);

สืบทอดคลิก;

จบ;

ขั้นตอนการลงทะเบียน;

เริ่ม

RegisterComponents("ตัวอย่าง", );

จบ;

จบ.

เพื่อที่จะแทนที่ค่าเริ่มต้นของคุณสมบัติเมื่อสร้างวัตถุ คุณต้องเขียนตัวสร้างใหม่สร้าง โดยที่คุณกำหนดค่าที่ต้องการให้กับคุณสมบัตินี้ (อย่าลืมเรียกตัวสร้างบรรพบุรุษก่อน)

คุณสมบัติใหม่สำหรับการนับจังหวะคีย์เรียกว่าคลิกนับ ฟิลด์ภายในสำหรับจัดเก็บค่า - FClickCount เป็นประเภท Longint ความจุของฟิลด์จะคงอยู่เป็นเวลานาน

เราได้ทำความคุ้นเคยกับส่วนประกอบต่างๆ แล้ว เดลฟีในบทความและแม้ว่าเราจะยังไม่เข้าใจอะไรเกี่ยวกับการเขียนโปรแกรม แต่ฉันก็ยังคิดว่าเราต้องการเริ่มสร้างบางสิ่งด้วยตัวเราเองให้เร็วที่สุด ดังนั้นตอนนี้ฉันเสนอให้เขียนแอปพลิเคชันแรกของคุณใน Delphi และพิจารณาว่าโค้ดโปรแกรมถูกเขียนอย่างไรและที่ไหน รวมถึงดูว่า Delphi ทำอะไรเมื่อสร้างโปรแกรม และโครงสร้างโครงการที่สร้างขึ้นมีอย่างไร หลังจากนั้นเราจะไปศึกษาทฤษฎีต่อไป

ในวรรณคดีคอมพิวเตอร์เป็นเรื่องปกติที่จะเขียนแอปพลิเคชันแรกที่แสดงคำจารึก "HelloWord" บนหน้าจอ แต่เราจะเปลี่ยนเล็กน้อยและสร้างแอปพลิเคชันแรกของเราที่จะแสดงคำจารึก “สวัสดีเดลฟี่”.

เป็นที่ชัดเจนว่าก่อนอื่นเราต้องเปิดตัว Delphi เอง หลังจากที่หน้าต่างเชลล์เปิดต่อหน้าเรา เราก็สร้างโปรเจ็กต์ใหม่ ไฟล์ | ใหม่ | การสมัครแบบฟอร์ม VCL - Delphi.

ตอนนี้เรามาดูผู้จัดการโครงการกันดีกว่า รูปด้านล่างแสดงหน้าต่างที่กิ่งก้านทั้งหมดของต้นไม้ถูกขยาย เพื่อให้เราสามารถดูส่วนประกอบทั้งหมดของโปรเจ็กต์ใหม่ได้

การวาดภาพ. ผู้จัดการโครงการสำหรับแอปพลิเคชันที่กำลังสร้าง

ต้นไม้ทั้งต้นปรากฏในผู้จัดการโครงการ ลองดูที่แต่ละจุดบนต้นไม้นี้

ProjectGroup1 (ส่วนหัวของแผนภูมิ)- ชื่อกลุ่มโครงการ สามารถมีได้หลายแอปพลิเคชันในกลุ่มโครงการเดียว ในกรณีของเรา เราได้สร้างแอปพลิเคชันใหม่ขึ้นมาหนึ่งรายการ ดังนั้นจะมีเพียงแอปพลิเคชันนี้เท่านั้นที่จะอยู่ในกลุ่ม หากคุณคลิกปุ่มใหม่ในหน้าต่างตัวจัดการโครงการและสร้างแอปพลิเคชันใหม่ แอปพลิเคชันนั้นจะถูกเพิ่มในกลุ่มโครงการที่มีอยู่

Project1.exe- ชื่อโครงการ (ใบสมัคร) เมื่อเราสร้างแอปพลิเคชันใหม่ Delphi จะตั้งชื่อให้กับมันว่า Project บวกกับหมายเลขลำดับ

Unit1.pas- โมดูล โครงการประกอบด้วยโมดูล แต่ละหน้าต่างโปรแกรมจะถูกเก็บไว้ในโมดูลแยกกันและเราจะเห็นว่าบนหน้าจอแอปพลิเคชันของเรามีหน้าต่างและเป็นหน้าต่างนี้ที่อยู่ในนั้น ไฟล์ที่มีนามสกุล ผ่านมีซอร์สโค้ดของโมดูล ชื่อไฟล์เหมือนกับโมดูล

Unit1.dfmเป็นรูปแบบการมองเห็น มันถูกบันทึกในไฟล์ที่มีชื่อเดียวกับโมดูล แต่มีนามสกุล ดีเอฟเอ็ม.

เมื่อเรามีแอปพลิเคชั่นหลายตัวในโปรเจ็กต์ จะมีแอปพลิเคชั่นเดียวเท่านั้นที่แอ็คทีฟ และเป็นแอปพลิเคชั่นนี้ที่เราสามารถดำเนินการและแก้ไขข้อบกพร่องในสภาพแวดล้อมเชลล์ Delphi ชื่อของแอปพลิเคชันที่ใช้งานอยู่จะเขียนด้วยตัวหนา หากต้องการเปลี่ยนแอปพลิเคชันที่ใช้งานอยู่ เพียงดับเบิลคลิกที่ชื่อด้วยปุ่มซ้ายของเมาส์หรือคลิกขวาที่ชื่อโครงการที่ต้องการแล้วเลือกเปิดใช้งานจากเมนูบริบท

แต่ตอนนี้เราจะทำงานกับแอปพลิเคชันเดียวเท่านั้น ดังนั้นหากคุณสร้างสองแอปพลิเคชัน จะต้องลบแอปพลิเคชันที่สองออก ในการดำเนินการนี้ ให้เลือกชื่อแอปพลิเคชันแล้วกดปุ่ม Delete บนแป้นพิมพ์ หน้าต่างจะปรากฏขึ้นก่อนที่เราจะยืนยันการลบ หากคุณคลิกใช่ แอปพลิเคชันจะถูกลบออกจากกลุ่มโครงการ

ควรสังเกตว่าไฟล์ไม่ได้ถูกลบออกจากดิสก์จริงๆ ยังคงอยู่แต่จะไม่แสดงในโครงการของเรา ดังนั้น หากเราบันทึกโปรเจ็กต์และเราไม่ต้องการไฟล์อีกต่อไป เราสามารถค้นหาไฟล์เหล่านี้และลบออกด้วยตนเอง หากเราไม่มีเวลาบันทึกไฟล์ไฟล์เหล่านั้นจะไม่อยู่ในดิสก์โดยธรรมชาติ

มาบันทึกแอปพลิเคชันใหม่ของเรากันเถอะ เมื่อต้องการทำเช่นนี้ ให้เลือกจากเมนูหลัก ไฟล์ | บันทึกทั้งหมด- หน้าต่างบันทึกไฟล์มาตรฐานจะเปิดต่อหน้าเรา ในการเริ่มต้น Delphi จะขอให้คุณป้อนชื่อโมดูล ตามค่าเริ่มต้น ชื่อปัจจุบันคือ Unit1.pas มาเปลี่ยนเป็น MainUnit แล้วคลิกปุ่มบันทึก

ควรสังเกตว่าคุณไม่สามารถป้อนชื่อด้วยการเว้นวรรคหรือเป็นภาษารัสเซียได้ หากคุณพยายามป้อนสิ่งนี้ จะเกิดข้อผิดพลาด ไฟล์ของคุณจะไม่ถูกบันทึก และคุณจะต้องทำขั้นตอนการบันทึกซ้ำอีกครั้ง อย่าลืมเลือกโฟลเดอร์ที่คุณต้องการบันทึกโมดูลและโปรเจ็กต์ ขอแนะนำให้เก็บไฟล์ทั้งหมดของโปรเจ็กต์ไว้ในโฟลเดอร์เดียว อย่างน้อยก็ในตอนแรก จนกว่าคุณจะได้รับประสบการณ์

หลังจากที่เราบันทึก MainUnit แล้ว Delphi จะถามชื่อโครงการในอนาคตจากเรา เนื่องจากเราตัดสินใจเขียนแอปพลิเคชันใหม่ที่เรียกว่า สวัสดีเดลฟีถ้าอย่างนั้นเรามาแนะนำ HelloDelphi กันที่นี่ ต้องป้อนชื่อโปรเจ็กต์และชื่อโมดูลโดยไม่เว้นวรรคและเป็นอักขระละตินเท่านั้น หลังจากป้อนชื่อโครงการแล้ว เราก็สามารถคลิกปุ่มบันทึกได้ โครงการจะถูกบันทึกไว้ในไฟล์ภายใต้ชื่อ สวัสดีDelphi.dpr- เมื่อเราต้องการเปิดโปรเจ็กต์นี้อีกครั้ง เราจำเป็นต้องเปิดไฟล์นี้โดยเฉพาะ ไม่จำเป็นต้องเปิดไฟล์ที่มีนามสกุล ผ่านเพราะมันเป็นเพียงส่วนสำคัญของโครงการเท่านั้น คุณต้องเปิดไฟล์ที่มีนามสกุล สปส.

พยายามเลือกชื่อที่สะท้อนถึงเนื้อหาของโมดูลได้แม่นยำที่สุด เพื่อให้เข้าใจได้ง่ายขึ้นในภายหลังว่าไฟล์นั้นมีไว้ทำอะไรในโครงการขนาดใหญ่ นอกจากนี้ ขอแนะนำให้จำไว้ว่าชื่อโปรเจ็กต์ระบุชื่อของไฟล์โปรแกรมปฏิบัติการในอนาคตของโปรเจ็กต์ หากคุณปล่อยให้ชื่อโครงการ 1 ชื่อของไฟล์ปฏิบัติการจะเป็น Project1.exe.

ขอแนะนำให้บันทึกโครงการในโฟลเดอร์แยกกัน ควรมีโฟลเดอร์แยกต่างหากสำหรับแต่ละโปรเจ็กต์ เนื่องจากแต่ละโปรเจ็กต์ประกอบด้วยไฟล์จำนวนมาก และเมื่อเรามีโปรเจ็กต์ขนาดใหญ่ เราจะไม่สามารถแยกออกจากกันหากอยู่ในโฟลเดอร์เดียวกัน ขอแนะนำให้บันทึกแบบฟอร์มหรือโมดูลเพิ่มเติมทั้งหมดที่เราจะสร้างสำหรับโครงการไว้ในโฟลเดอร์ของโครงการนี้ ในกรณีนี้ จะง่ายกว่าสำหรับเราที่จะคัดลอกไปยังคอมพิวเตอร์เครื่องอื่น เก็บถาวร หรือย้ายไปยังโฟลเดอร์อื่น

ตอนนี้เรามาดูกันว่าผู้จัดการโครงการของเราเปลี่ยนแปลงไปอย่างไร อย่างที่คุณเห็น ชื่อโปรเจ็กต์ได้เปลี่ยนเป็น HelloDelphi และชื่อโมดูลเป็น MainUnit

ตอนนี้เรามาเปิดโฟลเดอร์ที่เราบันทึกโครงการของเราแล้วดูว่ามีไฟล์อะไรบ้าง

1. HelloDelphi.cfg- ไฟล์ที่มีนามสกุล CFGมีการกำหนดค่าโครงการ

2. HelloDelphi.dof- ไฟล์ที่มีนามสกุล อมีตัวเลือกโครงการ

3. HelloDelphi.dpr- ไฟล์ที่มีนามสกุล สปสนี่คือโครงการเอง ไฟล์นี้มีคำอธิบายของโมดูลที่ใช้ในโครงการและรหัสการเริ่มต้นโปรแกรม สามารถใช้เขียนโค้ดได้ด้วย ในอนาคต เราจะค้นหาว่าอะไรที่สามารถเขียนได้ในโมดูลนี้ และเพราะเหตุใด

4. HelloDelphi.res- ไฟล์ที่มีนามสกุล ความละเอียดประกอบด้วยทรัพยากรโครงการ เช่น ไอคอน เคอร์เซอร์ ฯลฯ ตามค่าเริ่มต้น Delphi จะวางเฉพาะไอคอนในไฟล์นี้ แต่ไม่ได้หมายความว่าคุณไม่สามารถใช้ไฟล์เพื่อจัดเก็บทรัพยากรอื่น ๆ ได้

5.MainUnit.pas- ไฟล์ที่มีนามสกุล ผ่านมีซอร์สโค้ดของโมดูล

6.MainUnit.dfm- ไฟล์ที่มีนามสกุล ดีเอฟเอ็มมีข้อมูลภาพเกี่ยวกับรูปร่าง

7.MainUnit.ddp- ไฟล์ที่มีนามสกุล ดีดีพีกำหนดไฟล์เสริมของโมดูล เช่น ไดอะแกรม หากคุณไม่ใช้แผนภูมิ คุณสามารถลบไฟล์เหล่านี้ได้ แม้ว่าไฟล์เหล่านั้นจะยังคงถูกสร้างขึ้นก็ตาม

8.MainUnit.dcu- ไฟล์ที่มีนามสกุล ดีซียูแสดงถึงโมดูลโครงการที่คอมไพล์ในรูปแบบระดับกลาง เมื่อคอมไพล์โปรแกรม โมดูลทั้งหมดจะถูกคอมไพล์เป็นไฟล์รูปแบบ DCU จากนั้นจึงประกอบเป็นไฟล์เดียว ส่งผลให้ได้ไฟล์ปฏิบัติการเพียงไฟล์เดียว หากโมดูลไม่มีการเปลี่ยนแปลงนับตั้งแต่การคอมไพล์ครั้งล่าสุด Delphi จะข้ามและใช้ไฟล์รูปแบบ DCU ที่มีอยู่ในระหว่างการสร้างเพื่อเพิ่มความเร็วในการคอมไพล์ คุณยังไม่มีไฟล์นี้เนื่องจากคุณยังไม่ได้รวบรวมโครงการของคุณ

ไฟล์ซอร์สโค้ด (ที่มีนามสกุล pa) คือไฟล์ข้อความที่เราจะแก้ไขในตัวแก้ไขโค้ด ไฟล์ฟอร์มภาพ (ที่มีนามสกุล dfm) จะถูกสร้างขึ้นโดยอัตโนมัติ และจะจัดเก็บข้อมูลเกี่ยวกับสิ่งที่อยู่ในแบบฟอร์ม รวมถึงการตั้งค่าสำหรับฟอร์มเอง ฉันเปิดไฟล์นี้ด้วย Notepad และนี่คือสิ่งที่ฉันเห็นที่นั่น:

วัตถุ Form1: TForm1
ซ้าย = 0
บนสุด = 0
คำบรรยาย = "Form1"
ความสูงลูกค้า = 213
ความกว้างของไคลเอ็นต์ = 455
สี = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
แบบอักษรความสูง = -11
Font.Name = "ทาโฮมา"
แบบอักษร.สไตล์=
OldCreateOrder = เท็จ
PixelsPerInch = 96
ความสูงข้อความ=13
จบ

บรรทัดแรกระบุวัตถุ ชื่อ และประเภท จากนั้นจะมีรายการคุณสมบัติของวัตถุและค่าที่กำหนดให้กับวัตถุเหล่านั้น คำอธิบายของคุณสมบัติส่วนประกอบลงท้ายด้วยคำสำคัญ จบ.

หากคุณมีปัญหาในการเปิดแบบฟอร์ม คุณสามารถเปิดไฟล์ฟอร์มภาพในโปรแกรมแก้ไขข้อความและปรับคุณสมบัติที่จำเป็นได้ ซึ่งอาจจำเป็นเมื่อแบบฟอร์มมีส่วนประกอบที่เชื่อมต่อกับฐานข้อมูล หากการเชื่อมต่อทำงานอยู่และฐานข้อมูลไม่พร้อมใช้งาน เมื่อคุณเปิดแบบฟอร์ม Delphi จะพยายามเชื่อมต่อกับฐานข้อมูล และหากการเชื่อมต่อไม่สำเร็จ แบบฟอร์มอาจไม่แสดงขึ้น ในกรณีนี้ คุณต้องเปิดไฟล์ดังกล่าวในโปรแกรมแก้ไขข้อความและแก้ไขคุณสมบัติของการเชื่อมต่อกับฐานข้อมูล คุณสามารถยกเลิกการเชื่อมต่อหรือแก้ไขเส้นทางไปยังฐานข้อมูลอื่นได้ (เราจะพูดถึงฐานข้อมูลในภายหลัง)

ตอนนี้เรากลับมาที่โปรแกรม HelloDelphi ที่เราต้องเขียนกัน ก่อนอื่นเรามาดูสิ่งที่เรามีอยู่แล้ว โดยพื้นฐานแล้วเราไม่ได้ทำอะไรเป็นพิเศษ แต่เรามีหน้าต่างสำเร็จรูปที่สามารถเปลี่ยนเป็นโปรแกรมได้แล้ว ในการดำเนินการนี้ คุณจะต้องคอมไพล์โปรเจ็กต์ หากต้องการคอมไพล์โปรเจ็กต์ ให้เลือกรายการจากเมนู โครงการ | คอมไพล์ HelloDelphiหรือกด Ctrl+F9- หากเราไม่ได้เปลี่ยนแปลงสิ่งใดในการตั้งค่า Delphi เราควรจะเห็นหน้าต่างสถานะการคอมไพล์

การวาดภาพ. หน้าต่างสถานะการรวบรวมใน Delphi

เรามาดูกันว่าหน้าต่างนี้แสดงอะไรให้เราเห็น

หน้าต่างนี้แสดงสถานะการรวบรวมได้ค่อนข้างดี ความหมาย 3 ประการเป็นที่สนใจ

คำแนะนำ- ข้อความ นี่เป็นข้อความง่ายๆ ที่ชี้ให้เห็นถึงจุดที่สามารถปรับปรุงโค้ดได้ ตัวอย่างเช่น คุณประกาศตัวแปรแต่ไม่ได้ใช้ตัวแปรนั้น ในกรณีนี้ ข้อความที่เกี่ยวข้องจะปรากฏขึ้น แน่นอนว่านี่ไม่ใช่ข้อผิดพลาด และโปรแกรมจะยังคงคอมไพล์อยู่ แต่ด้วยข้อความเหล่านี้ คุณจะสามารถเห็นได้ว่ามีการประกาศตัวแปรพิเศษที่ไหนหรือบางทีอาจมีบางสิ่งที่ถูกลืมไป

คำเตือน- คำเตือน คุณต้องใส่ใจพวกเขาให้มากขึ้น ตัวอย่างเช่น คุณประกาศตัวแปร แล้วพยายามใช้ตัวแปรนั้นโดยไม่กำหนดค่าเริ่มต้น ในกรณีนี้ คำเตือนจะปรากฏขึ้น นี่ไม่ใช่ข้อผิดพลาดและโปรแกรมจะคอมไพล์ แต่ Delphi เตือนคุณถึงข้อผิดพลาดที่อาจเกิดขึ้น จำเป็นต้องตรวจสอบคำเตือนดังกล่าว เนื่องจากคุณอาจลืมทำบางสิ่งบางอย่างได้ และอาจนำไปสู่ข้อผิดพลาดในการทำงานของโปรแกรมที่ร้ายแรงได้

ข้อผิดพลาด- นี่เป็นความผิดพลาดที่แท้จริง ระบุสถานที่ที่เกิดข้อผิดพลาดร้ายแรง ซึ่งเป็นสาเหตุที่ไม่สามารถคอมไพล์โปรแกรมได้

อย่างที่คุณเห็น เราไม่มีข้อความ คำเตือน หรือข้อผิดพลาดใดๆ และนี่ก็เป็นเรื่องที่เข้าใจได้เพราะเรายังไม่ได้ทำอะไรและไม่มีเวลาทำลายชิ้นงานที่สร้างมาให้เรา โปรแกรมได้รับการเรียบเรียงแล้ว เพียงคลิกตกลงและหน้าต่างนี้จะปิดลง คุณสามารถทำให้หน้าต่างหายไปโดยอัตโนมัติเมื่อการคอมไพล์เสร็จสมบูรณ์โดยทำเครื่องหมายที่ช่องปิดอัตโนมัติเมื่อคอมไพล์สำเร็จ แต่ฉันไม่แนะนำให้ทำเช่นนี้

ตอนนี้กลับไปที่โฟลเดอร์ที่เราบันทึกโครงการและดูว่ามีอะไรเปลี่ยนแปลงไปบ้าง ไฟล์ปฏิบัติการปรากฏในโฟลเดอร์นี้ สวัสดีDelphi.exe- มาเปิดใช้งานแล้วเราจะเห็นหน้าต่างว่าง

มาเปลี่ยนชื่อแบบฟอร์มของเราเป็น สวัสดีเดลฟี- ดังที่คุณทราบใน Delphi วัตถุทั้งหมดซึ่งหมายความว่าหน้าต่างโปรแกรมก็เป็นวัตถุเช่นกัน ชื่อหน้าต่างมักเป็นคุณสมบัติของหน้าต่าง ในการเปลี่ยนแปลงคุณสมบัตินี้คุณต้องไปที่ตัวตรวจสอบวัตถุ (แท็บคุณสมบัติ) ค้นหาคุณสมบัติคำอธิบายภาพและป้อนคำว่า HelloDelphi ในช่องป้อนข้อมูล (ตอนนี้เรามี Form1 เขียนไว้ที่นั่นและเมื่อเราเรียกใช้ HelloDelphi.exe เราจะเห็นแบบฟอร์ม โดยมีชื่อเรื่องว่า Form1) หลังจากนี้ คุณสามารถกด Enter หรือไปที่บรรทัดอื่นที่มีคุณสมบัติอื่นได้

หลังจากทั้งหมดนี้ มารันโปรแกรมของเรากันดีกว่า เมื่อต้องการทำเช่นนี้ คุณสามารถคอมไพล์อีกครั้งและเรียกใช้ไฟล์ได้ อย่างไรก็ตาม ครั้งนี้เราจะทำสิ่งที่แตกต่างออกไป เลือกเรียกใช้จากเมนูเรียกใช้ (หรือกดปุ่ม F9 บนแป้นพิมพ์ของคุณ) Delphi จะคอมไพล์และรันโปรแกรมที่เสร็จสมบูรณ์ทันที อย่างที่คุณเห็นการเขียนโปรแกรมไม่ได้น่ากลัวอย่างที่คิดเมื่อมองแวบแรก

การวาดภาพ. ตัวตรวจสอบวัตถุ การเปลี่ยนคุณสมบัติคำอธิบายภาพ

แนบมากับบทเรียน (บทความ) แหล่งที่มาโดยดูว่าคุณสามารถทำความคุ้นเคยกับซอร์สโค้ดทั้งหมดของโปรแกรมและดูวิธีการทำงานของโปรแกรมที่สร้างขึ้นได้ ซอร์สโค้ดจะมาพร้อมกับความคิดเห็น ดังนั้นคุณจึงสามารถเข้าใจได้ง่าย แต่ฉันขอแนะนำให้ทำทุกอย่างด้วยตัวเอง วิธีนี้จะทำให้คุณเข้าใจสิ่งที่อภิปรายในบทเรียนนี้ได้ดีขึ้นและเร็วขึ้น

เพื่อให้สามารถดาวน์โหลดได้ แหล่งที่มาของเดลฟีสำหรับบทเรียนนี้ คุณต้องไปที่เว็บไซต์ของผู้ลงโฆษณา หลังจากนี้จะมีลิงค์ไปที่ แหล่งที่มาของเดลฟีสู่บทเรียน HelloDelphi การสร้างแอปพลิเคชันแรกของเราใน Delphi
คลิกที่ลิงค์นี้

วันที่ตีพิมพ์

ไม่จำเป็นต้องสร้างแบบฟอร์มทั้งหมดเมื่อแอปพลิเคชันเริ่มต้น บางส่วนถูกสร้างขึ้นได้ดีขึ้นในขณะที่โปรแกรมกำลังทำงาน

ในกรณีใดจะดีกว่าถ้าสร้างแบบฟอร์มแบบไดนามิก?

ฉันจะเน้นสองประเด็นหลัก

1. หากแบบฟอร์มไม่ค่อยได้ใช้และมีความเป็นไปได้สูงที่จะไม่ถูกเรียกเลย ตัวอย่างจะเป็นหน้าต่าง "เกี่ยวกับ"
2. หากจำนวนอินสแตนซ์ของหน้าต่างของเราสามารถมีได้มากกว่าหนึ่งรายการ

และเช่นเคย ฉันจะแสดงให้คุณเห็นถึงวิธีสร้างแบบฟอร์มแบบไดนามิกพร้อมตัวอย่าง

ตัวอย่างการสร้างฟอร์มแบบไดนามิก

1. คลิกรายการเมนูหลัก "ไฟล์"
2. แล้วใหม่.

ตัวโปรแกรมเองได้ร่างคลาสของรูปแบบในอนาคตออกมา เพราะ เราจะสร้างหน้าต่างโดยการกดปุ่ม ฉันแนะนำให้ลบบรรทัดโค้ดต่อไปนี้

เป็น Form2: TForm2; // หากคุณตั้งชื่อให้กับฟอร์ม โค้ดส่วนนี้จะแตกต่างออกไป

เราจัดระเบียบการประกาศภายในเครื่อง ภายในตัวจัดการปุ่ม มาบันทึกโมดูลผลลัพธ์กัน

ตอนนี้เรากลับมาที่ฟอร์มหลักกันดีกว่า มาเชื่อมต่อโมดูลที่สร้างขึ้นใหม่เข้ากับมัน: ไฟล์->ใช้หน่วย...-> เลือกโมดูลที่คุณต้องการ (คุณสามารถเพิ่มได้ในส่วนการใช้งาน)

มาสร้างสองปุ่มกัน เราจะสร้างหน้าต่างใหม่ด้วยสองวิธี:

ขั้นตอน TForm1.Button1Click (ผู้ส่ง: TObject); เป็น Form2: TForm2; เริ่ม Form2:= TForm2.Create (Application);

Form2.Caption:= "แบบฟอร์มใหม่ วิธีที่ 1";

Form2.แสดง; จบ;

ขั้นตอน TForm1.Button2Click (ผู้ส่ง: TObject); เป็น Form2: TForm2; เริ่ม Application.CreateForm(TForm2,Form2); Form2.Caption:= "แบบฟอร์มใหม่ วิธีที่ 2"; Form2.แสดง; จบ; ทุกอย่างง่ายมาก แต่ถ้าคุณยังมีคำถามใด ๆ เขียนในความคิดเห็น ฉันจะตอบครั้งเดียวการพัฒนา

ซอฟต์แวร์

สำหรับ Windows OS และโปรแกรมยอดนิยมอื่น ๆ สามารถทำได้โดยใช้เครื่องมือหลากหลายประเภท ในบรรดาผู้ที่ได้รับความนิยมอย่างมากในหมู่โปรแกรมเมอร์ชาวรัสเซียและต่างประเทศ ได้แก่ : โปรแกรมเดลฟี- เครื่องมือพัฒนานี้มีความเฉพาะเจาะจงอย่างไร? คุณสมบัติที่โดดเด่นที่สุดคืออะไร? ข้อมูลทั่วไปเกี่ยวกับเดลฟี Delphi - สภาพแวดล้อมการพัฒนา

แอพพลิเคชั่น ซึ่งได้รับการออกแบบมาให้ทำงานบน Windows, MacOS รวมถึงอุปกรณ์เคลื่อนที่ระบบปฏิบัติการ

- iOS และ Android โดดเด่นด้วยความเรียบง่ายของภาษาและขั้นตอนการสร้างโค้ด

หากจำเป็น ให้จัดให้มีการสื่อสารระดับต่ำกับระบบปฏิบัติการและไลบรารีที่เขียนด้วยภาษา C และ C++ โปรแกรมที่สร้างโดยใช้ Delphi ไม่จำเป็นต้องมีเชลล์ของบริษัทอื่นในการรัน เช่น Java Virtual Machine Delphi คือสภาพแวดล้อมการพัฒนาที่ทั้งมืออาชีพและเพื่อการศึกษาสามารถใช้ได้อย่างประสบความสำเร็จ เพื่อที่จะเชี่ยวชาญความสามารถขั้นพื้นฐาน ไม่จำเป็นต้องมีคุณสมบัติและความรู้สูง ภาษาที่ซับซ้อน ผลิตภัณฑ์ซอฟต์แวร์เกี่ยวกับเรื่องไหน เรากำลังพูดถึง- เมื่อบริษัทไอทีแห่งใดแห่งหนึ่งให้เหตุผลในการเลือกสภาพแวดล้อมการพัฒนา Delphi จะกลายเป็นตัวเลือกของโปรแกรมเมอร์จำนวนมาก และได้รับการแนะนำจากพวกเขาให้ใช้งาน นี่เป็นเพราะความจริงที่ว่า สภาพแวดล้อมที่กำหนดช่วยให้คุณสร้างแอปพลิเคชันได้ในเวลาที่เร็วที่สุดเท่าที่จะเป็นไปได้ ประสิทธิภาพสูงแม้แต่ในคอมพิวเตอร์ที่มีข้อกำหนดฮาร์ดแวร์พอประมาณ ข้อโต้แย้งที่สำคัญในการเลือกสภาพแวดล้อมการพัฒนาที่เป็นปัญหาคือสามารถเสริมด้วยเครื่องมือใหม่ๆ ที่ไม่มีให้มาได้ ชุดมาตรฐานโซลูชันที่มีอยู่ในอินเทอร์เฟซ Delphi

ให้เราศึกษาถึงความแตกต่างของการใช้งานความสามารถของ Delphi ในทางปฏิบัติ

ข้อมูลจำเพาะของอินเทอร์เฟซ

ก่อนอื่น คุณสามารถใส่ใจกับคุณลักษณะบางอย่างของอินเทอร์เฟซของสภาพแวดล้อมการพัฒนาซอฟต์แวร์ที่เป็นปัญหาได้ ดังนั้นโครงสร้างของพื้นที่ทำงานของโปรแกรมจึงถือว่า ทำงานพร้อมกันมีหน้าต่างหลักหลายบาน พิจารณาคุณสมบัตินี้โดยละเอียด

สภาพแวดล้อมการพัฒนา Delphi โดยเฉพาะเวอร์ชัน 7 เกี่ยวข้องกับการใช้โมดูลหลักต่อไปนี้: ผู้ออกแบบแบบฟอร์ม ตัวแก้ไข จานสี ตัวตรวจสอบวัตถุ และหนังสืออ้างอิง ในการปรับเปลี่ยน Delphi บางส่วน ส่วนประกอบที่ทำเครื่องหมายไว้อาจมีชื่อแตกต่างออกไป ตัวอย่างเช่น ตัวแก้ไขอาจสอดคล้องกับหน้าต่างรหัสโปรแกรม และผู้ออกแบบอาจสอดคล้องกับหน้าต่างแบบฟอร์ม อย่างไรก็ตาม วัตถุประสงค์การทำงานของพวกเขาก็จะเหมือนกัน รายการที่ทำเครื่องหมายไว้ อินเตอร์เฟซเดลฟีสามารถเสริมเครื่องมือเสริมต่างๆได้ สองรายการแรกถือเป็นรายการหลักจากมุมมองของขั้นตอนการพัฒนาโปรแกรม แต่ที่เหลือก็มีความสำคัญเช่นกัน มาดูคุณสมบัติของการใช้โมดูล Delphi ที่ทำเครื่องหมายไว้

ผู้ออกแบบแบบฟอร์ม ผู้แก้ไข และจานสี

ด้วยความช่วยเหลือของผู้ออกแบบฟอร์ม นักพัฒนาจะสร้างอินเทอร์เฟซของโปรแกรมของเขา ในทางกลับกันโค้ดของมันถูกเขียนในตัวแก้ไข โปรแกรมเมอร์หลายคนแนะนำให้เลือกสภาพแวดล้อมการพัฒนา Delphi มากที่สุด ทางออกที่ดีที่สุดเพื่อเป็นข้อโต้แย้ง พวกเขาอ้างถึงความง่ายในการใช้งานของตัวออกแบบฟอร์ม ผู้เชี่ยวชาญบางคนเชื่อว่ากระบวนการนี้เป็นเหมือนเกมมากกว่า

ทันทีที่ผู้ใช้เริ่มสร้างโปรแกรมและเรียกใช้ตัวออกแบบฟอร์ม ในตอนแรกไม่มีองค์ประกอบใดอยู่ในนั้น โปรแกรมจะว่างเปล่า แต่คุณสามารถกรอกข้อมูลได้ทันทีโดยใช้เครื่องมือที่อยู่ในโมดูล Delphi อื่น - จานสี โปรแกรมที่ได้รับการกำหนดค่าในตัวออกแบบฟอร์มจะต้องถูกควบคุมโดยคำสั่ง ซึ่งในทางกลับกันจะถูกเขียนในตัวแก้ไข

แต่ขอกลับไปที่จานสีในตอนนี้ เมื่อใช้สิ่งนี้ คุณสามารถวางวัตถุที่จำเป็นในพื้นที่ตัวออกแบบฟอร์มได้ หากต้องการใช้เครื่องมือเฉพาะ คุณควรคลิกหนึ่งครั้งที่เครื่องมือนั้น - ขณะที่เครื่องมือนั้นอยู่ในพื้นที่จานสี และคลิกครั้งที่สอง - ในหน้าต่างตัวออกแบบแบบฟอร์ม หลังจากนี้ ออบเจ็กต์ที่เกี่ยวข้องจะย้ายไปยังพื้นที่การพัฒนา และคุณสามารถเขียนโค้ดได้ในตัวแก้ไข

ตัวตรวจสอบวัตถุ

องค์ประกอบสำคัญอีกประการหนึ่งที่ Delphi มี - สภาพแวดล้อมการพัฒนาแอปพลิเคชันสำหรับ Windows OS และแพลตฟอร์มทั่วไปอื่น ๆ - คือตัวตรวจสอบวัตถุ คุณอาจสังเกตเห็นว่าข้อมูลที่แสดงในนั้นเปลี่ยนแปลงไป ซึ่งได้รับผลกระทบจากสถานะของออบเจ็กต์ที่เลือกในพื้นที่ตัวออกแบบฟอร์ม

โครงสร้างของตัวตรวจสอบวัตถุมีดังนี้ ประกอบด้วยหน้าต่างสองบาน แต่ละรายการมีอัลกอริธึมที่กำหนดพฤติกรรมของส่วนประกอบที่เกี่ยวข้อง อันแรกแสดงคุณสมบัติ ส่วนอันที่สองแสดงเหตุการณ์ หากโปรแกรมเมอร์ต้องการปรับเปลี่ยนอัลกอริธึมที่ส่งผลต่อส่วนประกอบเฉพาะ ความสามารถของตัวตรวจสอบวัตถุก็จะถูกนำมาใช้ ตัวอย่างเช่น คุณสามารถเปลี่ยนตำแหน่งขององค์ประกอบอินเทอร์เฟซโปรแกรมบางอย่าง ความสูงและความกว้างได้

ตัวตรวจสอบวัตถุมีแท็บที่ให้คุณสลับระหว่างเพจที่แสดงคุณสมบัติหรือเหตุการณ์ที่เกี่ยวข้องโดยตรงกับตัวแก้ไข ดังนั้น หากคุณดับเบิลคลิกทางด้านขวาของรายการใด ๆ ที่แสดงบนหน้าจอ โค้ดที่สอดคล้องกับเหตุการณ์ใดเหตุการณ์หนึ่งจะถูกบันทึกในตัวแก้ไข

การพัฒนาซอฟต์แวร์ใน Delphi เกี่ยวข้องกับการใช้ Object Inspector เพื่อแก้ไขปัญหา งานที่แตกต่างกัน- สิ่งนี้ถูกกำหนดไว้ล่วงหน้าโดยข้อเท็จจริงที่ว่าด้วยความช่วยเหลือของเครื่องมือนี้คุณสามารถเปลี่ยนคุณสมบัติของวัตถุใด ๆ ที่อยู่ในแบบฟอร์มได้เช่นเดียวกับตัวแบบฟอร์มเอง มาดูคุณสมบัติบางอย่างของการทำงานกับตัวตรวจสอบวัตถุกันดีกว่า

ตัวตรวจสอบวัตถุ: การใช้คุณสมบัติ

เพื่อให้เข้าใจว่า Delphi IDE ทำงานอย่างไรในแง่ของการโต้ตอบระหว่าง Object Inspector และ Form Inspector คุณสามารถลองทำการเปลี่ยนแปลงคุณสมบัติขององค์ประกอบอินเทอร์เฟซซอฟต์แวร์ทั่วไปใน Windows เช่น Memo, Button และ Listbox (เราจะ เราจะมาสำรวจแก่นแท้ของมันโดยละเอียดในภายหลัง) ขั้นแรก คุณต้องวางไว้บนแบบฟอร์มโดยใช้เครื่องมือ Delphi ที่มีอยู่

คุณสามารถลองทดสอบด้วยคุณสมบัติ Ctl3D ในการดำเนินการนี้ คุณต้องคลิกที่แบบฟอร์ม จากนั้นไปที่ตัวตรวจสอบวัตถุ และเปลี่ยนค่าของคุณสมบัติที่ต้องการ หลังจากนี้แบบฟอร์มจะเปลี่ยนไปอย่างมาก ในเวลาเดียวกัน คุณสมบัติ Ctl3D จะเปลี่ยนไปในแต่ละองค์ประกอบที่วางอยู่ในหน้าต่างการออกแบบ

หลังจากดำเนินการทดลองแล้ว เราสามารถกลับไปที่แบบฟอร์มและเปิดใช้งานค่า Ctl3D ได้ หลังจากนั้น เรามาดูองค์ประกอบ Memo และ Listbox กัน ตอนนี้คุณสามารถเปลี่ยนคุณสมบัติ ตำแหน่งบนแบบฟอร์ม และลักษณะที่ปรากฏได้ ตัวอย่างเช่น ด้วยการเลือกตัวเลือกแก้ไขในรายการเมนูแล้วเลือกขนาด โปรแกรมเมอร์สามารถเปลี่ยนความกว้างและความสูงของวัตถุได้ มีตัวเลือกให้จัดกึ่งกลางโดยเลือกแก้ไขและจัดตำแหน่ง การดำเนินการที่เกี่ยวข้องจะส่งผลต่อองค์ประกอบที่แสดงใน Object Inspector

การใช้โมดูล Delphi ดังกล่าว คุณสามารถเปลี่ยนคุณสมบัติของส่วนประกอบต่างๆ ได้ ตัวอย่างเช่นหากงานคือการกำหนดให้พวกเขา สีเฉพาะนั่นคือตัวเลือกสำหรับการใช้เครื่องมือหลายอย่างพร้อมกัน ขั้นแรก คำสั่งที่สอดคล้องกับสี เช่น สีแดง - clRed สามารถป้อนลงในพื้นที่ได้ ประการที่สอง ผู้ใช้สามารถเลือกได้ สีที่ต้องการจากรายการ ประการที่สามมีตัวเลือกให้ดับเบิลคลิกที่คุณสมบัติสี - หน้าต่างการเลือกสีจะปรากฏขึ้น ในทำนองเดียวกัน นักพัฒนาสามารถเปลี่ยนคุณลักษณะอื่นๆ ของวัตถุได้ เช่น ประเภทแบบอักษร สี หรือขนาด

ไดเรกทอรี

Delphi เป็นสภาพแวดล้อมการพัฒนาที่เสริมด้วยรายละเอียดค่อนข้างมาก ระบบช่วยเหลือ- หากต้องการเข้าถึง ให้เลือกวิธีใช้จากเมนู หลังจากนี้ หนึ่งในสิ่งที่เราระบุไว้ข้างต้นจะปรากฏในหน้าต่าง โมดูลซอฟต์แวร์สภาพแวดล้อมการพัฒนาที่เป็นปัญหา - หนังสืออ้างอิง ลักษณะเฉพาะของการใช้งานคือเมื่อคุณกด F1 ผู้ใช้จะได้รับคำแนะนำเฉพาะที่สะท้อนถึงลักษณะเฉพาะของการใช้เครื่องมือปัจจุบัน ตัวอย่างเช่น หากโปรแกรมเมอร์ทำงานร่วมกับตัวตรวจสอบวัตถุ เขาสามารถเลือกคุณสมบัติอย่างใดอย่างหนึ่ง จากนั้นกด F1 และรับ ข้อมูลความเป็นมาเกี่ยวกับตัวเลือกที่เกี่ยวข้อง สามารถทำได้เช่นเดียวกันเมื่อทำงานกับองค์ประกอบอินเทอร์เฟซอื่น ๆ ที่มีสภาพแวดล้อมการพัฒนา Delphi 7 และซอฟต์แวร์ประเภทอื่น ๆ ที่เกี่ยวข้อง

องค์ประกอบอินเทอร์เฟซอื่น ๆ

ในบรรดาองค์ประกอบที่สำคัญอื่น ๆ ของอินเทอร์เฟซที่เป็นปัญหา โซลูชันซอฟต์แวร์- เมนูแผง เข้าถึงได้อย่างรวดเร็วตลอดจนโปรแกรมแก้ไขรูปภาพ ส่วนเมนูก็ช่วยให้โปรแกรมเมอร์เข้าถึงได้อย่างรวดเร็ว ส่วนประกอบที่จำเป็นที่มีอยู่ในโครงสร้างของสภาพแวดล้อมการพัฒนา คุณสามารถใช้มันโดยใช้เมาส์หรือใช้ปุ่มลัด ด้านล่างของเมนูคือแผงการเข้าถึงด่วน ฟังก์ชั่นบางอย่างซ้ำกับเมนู แต่เข้าถึงได้เร็วกว่า Delphi ค่อนข้างคล้ายกับ โปรแกรมเพ้นท์บน Windows นั่นคือด้วยความช่วยเหลือนี้คุณสามารถปรับแต่งรูปภาพใส่คำจารึกและองค์ประกอบอื่น ๆ ได้อย่างง่ายดาย

เครื่องมือการเขียนโปรแกรม

Delphi คือสภาพแวดล้อมการพัฒนาที่ประกอบด้วย จำนวนมากเครื่องมือที่ออกแบบมาเพื่อปรับปรุงประสิทธิภาพของโปรแกรมเมอร์ ดังนั้นโมดูลสำคัญที่เรากล่าวถึงข้างต้นจึงได้รับการเสริมด้วยชุดของ เครื่องมือพิเศษ- ซึ่งรวมถึงดีบักเกอร์ คอมไพเลอร์ รวมถึงส่วนประกอบ WinSight และ WinSpector โปรดทราบว่าใน Delphi บางเวอร์ชัน องค์ประกอบที่ทำเครื่องหมายจะต้องติดตั้งแยกต่างหาก เรามาศึกษาข้อมูลเฉพาะของพวกเขากันดีกว่า

ดีบักเกอร์เดลฟี

เกี่ยวกับดีบักเกอร์ - เครื่องมือนี้เสริมโปรแกรมแก้ไขโค้ดในแง่ของการใช้งาน การตรวจสอบที่จำเป็นที่เกี่ยวข้อง อัลกอริธึมซอฟต์แวร์เพื่อความถูกต้อง ด้วยสิ่งนี้ นักพัฒนาสามารถตรวจสอบซอร์สโค้ดของเขาทีละบรรทัดได้ ในบางกรณี เมื่อแก้ไขงาน เช่น การพัฒนาส่วนประกอบ Delphi ซึ่งเป็นผลิตภัณฑ์อิสระสามารถเสริมด้วยดีบักเกอร์ภายนอกได้ ซึ่งช่วยให้โปรแกรมเมอร์มีความสามารถเพิ่มขึ้นในการตรวจสอบโค้ดของซอฟต์แวร์ที่ถูกสร้างขึ้น

คอมไพเลอร์เดลฟี

ให้เราศึกษาข้อมูลเฉพาะของคอมไพเลอร์ของสภาพแวดล้อมการพัฒนาที่เป็นปัญหา โปรดทราบว่าอาจมีองค์ประกอบที่เกี่ยวข้องหลายประการในโครงสร้าง Delphi ดังนั้นจึงมีตัวเลือกให้ใช้คอมไพเลอร์ DCC ซึ่งมีประโยชน์ในกรณีที่งานคือการทำงานกับแอปพลิเคชันในดีบักเกอร์ภายนอก

Winsight และ WinSpector

โมดูลที่ระบุคือโมดูลที่ต้องติดตั้งเพิ่มเติมบน Delphi มีลักษณะเฉพาะคือมีความยากในการเรียนรู้ อย่างไรก็ตาม โปรแกรมเมอร์จำนวนมากที่เลือกสภาพแวดล้อมการพัฒนา Delphi เชื่อว่าส่วนประกอบเหล่านี้จะต้องเรียนรู้การใช้งาน ดังนั้นจึงใช้โมดูล Winsight ในการตรวจสอบ ข้อความของวินโดวส์- จำเป็นต้องมีส่วนประกอบเช่น WinSpector เพื่อบันทึกสถานะของคอมพิวเตอร์ ไฟล์พิเศษ- หากคุณพบปัญหาใดๆ ในระหว่างการพัฒนาซอฟต์แวร์ คุณสามารถเปิดไฟล์นี้ได้ตลอดเวลาและดูว่าอะไรเป็นสาเหตุของปัญหา

ส่วนประกอบมาตรฐาน

สภาพแวดล้อมการพัฒนา Delphi ข้อมูลทั่วไปที่เรากำลังเรียนรู้มีองค์ประกอบมาตรฐานจำนวนหนึ่งที่เป็นประโยชน์ต่อการทราบด้วย ผู้เชี่ยวชาญจัดประเภทสิ่งเหล่านี้เป็น: MainMenu, PopupMenu, Label, Edit, Memo, Button, Checkbox, Radiobutton, Listbox, Combobox, Scrollbar, Groupbox, Panel และ Scrollbox เรามาศึกษารายละเอียดเฉพาะของพวกเขากันดีกว่า

ส่วนประกอบ MainMenu ได้รับการออกแบบมาเพื่อวางเมนูหลักในอินเทอร์เฟซ โปรแกรมที่สร้างขึ้น- ในการทำเช่นนี้ คุณต้องวางองค์ประกอบที่เกี่ยวข้องบนแบบฟอร์ม จากนั้นเรียกคุณสมบัติรายการผ่านตัวตรวจสอบวัตถุ จากนั้นกำหนดรายการเมนูที่จำเป็น

ส่วนประกอบ PopupMenu ได้รับการออกแบบมาเพื่อวางเมนูป๊อปอัปในส่วนต่อประสานของโปรแกรมที่สร้างขึ้นนั่นคือเมนูที่เปิดด้วยการคลิก คลิกขวาหนู

องค์ประกอบป้ายกำกับใช้เพื่อแสดงข้อความในหน้าต่างโปรแกรม สามารถปรับแต่งได้ เช่น ตั้งค่า แบบอักษรที่ต้องการในตัวตรวจสอบวัตถุ

องค์ประกอบแก้ไขใช้เพื่อแสดงข้อความบนหน้าจอที่ผู้ใช้สามารถแก้ไขในขณะที่โปรแกรมกำลังทำงานอยู่ ได้รับการเสริมด้วยองค์ประกอบ Memo ซึ่งสามารถใช้เพื่อทำงานกับข้อความขนาดใหญ่ได้ รายการนี้รวมถึงตัวเลือกต่างๆ เช่น การคัดลอกข้อความ

ส่วนประกอบปุ่มได้รับการออกแบบมาเพื่อดำเนินการบางอย่างโดยการกดปุ่มในขณะที่โปรแกรมกำลังทำงาน จำเป็นต้องวางองค์ประกอบที่เกี่ยวข้องลงในแบบฟอร์ม จากนั้นป้อนรหัสโปรแกรมที่ต้องการ

ส่วนประกอบช่องทำเครื่องหมายช่วยให้คุณสามารถแสดงเส้นบนหน้าจอด้วยหน้าต่างเล็กๆ ซึ่งสามารถวางช่องทำเครื่องหมายได้โดยใช้เมาส์ องค์ประกอบที่คล้ายกันคือ Radiobutton พวกเขาแตกต่างกันประการแรก รูปร่าง- องค์ประกอบที่สองถูกสร้างขึ้นในรูปแบบของวงกลมและประการที่สององค์ประกอบแรกช่วยให้สามารถเลือกหลายตัวเลือกพร้อมกันได้ Radiobutton - เพียงอันเดียวเท่านั้น

ส่วนประกอบกล่องรายการใช้เพื่อแสดงรายการบนหน้าจอที่ผู้ใช้สามารถเลื่อนดูโดยใช้เมาส์ องค์ประกอบอื่นคือ Combobox ค่อนข้างคล้ายกัน แต่เสริมด้วยความสามารถในการป้อนข้อความในฟิลด์พิเศษ

องค์ประกอบแถบเลื่อนเป็นแถบเลื่อนในหน้าต่าง โดยทั่วไปจะปรากฏโดยอัตโนมัติทันทีที่พื้นที่ข้อความหรือแบบฟอร์มที่มีวัตถุมีขนาดใหญ่กว่าหน้าต่าง

คอมโพเนนต์ Groupbox ใช้เพื่อบันทึกลำดับการเคลื่อนไหวระหว่างหน้าต่างเมื่อคลิก ปุ่มแท็บ- สามารถเสริมด้วยองค์ประกอบ Panel ซึ่งสามารถใช้เพื่อย้ายวัตถุต่างๆ บนแบบฟอร์มได้

ส่วนประกอบ Scrollbox ช่วยให้คุณสามารถแก้ไขพื้นที่บนแบบฟอร์มที่สามารถเลื่อนได้ทั้งแนวนอนและแนวตั้ง คุณสมบัตินี้จะกำหนดลักษณะของหน้าต่างการพัฒนา Delphi หลักตามค่าเริ่มต้น แต่ถ้าจำเป็นต้องเปิดใช้งานตัวเลือกดังกล่าวในส่วนเฉพาะของแบบฟอร์ม คุณสามารถใช้ส่วนประกอบ Scrollbox ได้

ประวัติย่อ

Delphi เป็นสภาพแวดล้อมการพัฒนาแอปพลิเคชันด้วย โอกาสที่ดีในขณะเดียวกันก็โดดเด่นด้วยความสะดวกในการใช้งานฟังก์ชั่นหลัก ด้วยความช่วยเหลือของเครื่องมือที่รวมอยู่ในโครงสร้าง คุณสามารถสร้างประโยชน์สูงสุดได้ ประเภทต่างๆโปรแกรมสำหรับ Windows และระบบปฏิบัติการยอดนิยมอื่น ๆ

ตัวเลือกเครื่องมือพัฒนา Delphi โดยโปรแกรมเมอร์หลายคนนั้นพิจารณาจากความง่ายในการใช้งานอินเทอร์เฟซของซอฟต์แวร์ที่เกี่ยวข้องตลอดจนเครื่องมือมากมายที่มีประโยชน์สำหรับการทำงานในทุกขั้นตอนของการสร้างโปรแกรม - ในขั้นตอนของการออกแบบการเขียนโปรแกรมอัลกอริทึม หรือการดีบัก