Visual Component จริงๆ แล้วเป็นคลาส หากต้องการเขียนคลาส คุณสามารถเขียนลงในไฟล์ *.pas ได้โดยตรง แต่ในการเขียนการควบคุม คุณต้องใช้แพ็คเกจ เลือก ใหม่ จากเมนู ไฟล์ เพื่อสร้างแพ็คเกจใหม่ นี่คือแพ็คเกจที่ใช้ในการจัดเก็บและติดตั้งตัวควบคุม จากนั้นคลิกปุ่มเพิ่มในหน้าต่างแพ็คเกจเพื่อเพิ่มส่วนประกอบ (หน่วย)
เลือกส่วนประกอบใหม่ที่ด้านบนของกล่องโต้ตอบป๊อปอัป เนื่องจากเป็นไปไม่ได้ที่จะเขียนโปรแกรมคุณสมบัติ วิธีการ และเหตุการณ์ทั้งหมดของตัวควบคุมด้วยตัวเอง คุณจึงต้องเลือกคลาสบรรพบุรุษ (หรือ "คลาสหลัก" หรือ "คลาสพื้นฐาน") แล้วเพิ่มคุณสมบัติ วิธีการ และของคุณเอง เหตุการณ์ที่เกิดขึ้น เลือกคลาสระดับบนสุดที่ต้องการในกล่องแบบเลื่อนลงหลังประเภทระดับบนสุด เนื่องจากการเขียนการควบคุมด้วยภาพจำเป็นต้องมีการวาดภาพ TGraphicControl จึงถูกเลือกเป็นคลาสบรรพบุรุษ จากนั้นใส่ชื่อของตัวควบคุมใหม่ (คลาส) ในกล่อง ชื่อคลาส ซึ่งโดยปกติจะขึ้นต้นด้วย "T" Palette Page ใช้เพื่อเลือกชื่อหน้าควบคุมของตัวควบคุมใหม่ในหน้าต่าง Delphi เช่น "มาตรฐาน" คุณสามารถเลือกได้ด้วยตัวเอง เพิ่มเส้นทางและชื่อไฟล์ของไฟล์ควบคุมใหม่ในชื่อไฟล์หน่วยแล้วคลิกปุ่มตกลง มีการเพิ่มการควบคุมใหม่ ตอนนี้ได้เวลาเขียนโค้ดสำหรับการควบคุมแล้ว
ต่อไปนี้จะใช้การเขียนแถบเลื่อนที่สามารถปรับแต่งรูปภาพเป็นตัวอย่างเพื่อแสดงวิธีการเขียนตัวควบคุมภาพ
ปฏิบัติตามวิธีการข้างต้น เลือก TGraphicControl เป็นคลาสบรรพบุรุษ และชื่อของตัวควบคุมใหม่คือ TPigHorizontalScroller หลังจากเลือกเส้นทางไฟล์และชื่อไฟล์แล้ว ให้คลิกปุ่ม OK เพื่อเริ่มเขียนโค้ด
การควบคุมแต่ละรายการจะถูกสร้างขึ้น (สร้าง) และถูกลบ (ทำลาย) ดังนั้นจึงต้องเขียนทั้งสองกระบวนการนี้ก่อน สำหรับทุกขั้นตอนในการควบคุม จะต้องกำหนดไว้ก่อนแล้วจึงเขียนในภายหลัง กระบวนการหรือคุณสมบัติที่กำหนดไว้มีสามประเภท: 1. กระบวนการหรือคุณสมบัติที่กำหนดหลังจาก PRivate จะถูกใช้ภายในโดยการควบคุมและไม่สามารถมองเห็นได้โดยผู้ที่ใช้การควบคุม 2. กระบวนการหรือคุณสมบัติที่กำหนดหลังจากการป้องกันโดยทั่วไปจะมองไม่เห็นและผู้อื่นสามารถใช้ได้เมื่อเท่านั้น ผู้อื่นใช้การควบคุม การควบคุมจะมองเห็นได้เฉพาะเมื่อเขียนการควบคุมอื่น ๆ เป็นคลาสบรรพบุรุษเท่านั้น 3. ตัวควบคุมที่กำหนดหลังจากสาธารณะสามารถถูกเรียกโดยผู้อื่นในโปรแกรมเท่านั้น 4. ตัวควบคุมที่กำหนดหลังจากเผยแพร่สามารถดูได้ในหน้าต่างคุณสมบัติ (Object สารวัตร) เนื่องจากกระบวนการสร้างและการลบไม่เพียงดำเนินการโดยอัตโนมัติเมื่อมีการสร้างการควบคุมในระหว่างกระบวนการเขียนโปรแกรมเท่านั้น แต่ยังอาจถูกเรียกเมื่อมีการสร้างการควบคุมแบบไดนามิกระหว่างการรันโปรแกรมด้วย จึงถูกกำหนดไว้หลังจากสาธารณะ (1) (หมายเลขซีเรียลระบุตำแหน่งของโค้ดของขั้นตอนย่อยในซอร์สโปรแกรมที่แนบมาด้านล่าง) บางทีคุณอาจยังไม่รู้ว่าควรคอมไพล์อะไรในทั้งสองกระบวนการและจะคอมไพล์อย่างไร เราจะพูดถึงเรื่องนี้ด้านล่าง
ก่อนอื่นเรามาเพิ่มคุณสมบัติบางอย่างให้กับการควบคุมนี้กันก่อน เรากำหนดคุณสมบัติ Max เพื่อตั้งค่าหรืออ่านค่าสูงสุดของแถบเลื่อน เนื่องจากโดยทั่วไปแอ็ตทริบิวต์ไม่ได้ใช้โดยตรงในโปรแกรม จึงต้องกำหนดตัวแปรให้สอดคล้องกับแอ็ตทริบิวต์ และสามารถแก้ไขหรืออ่านค่าของตัวแปรได้ เนื่องจากจะใช้ภายในตัวควบคุมเท่านั้น เราจึงกำหนดไว้ตามหลังส่วนตัว (2) (โดยทั่วไป ตัวแปรที่เกี่ยวข้องกับคุณลักษณะจะขึ้นต้นด้วย "F" เช่น FMax) หลังจากกำหนดตัวแปรแล้ว ให้กำหนดคุณลักษณะ คุณสมบัตินี้จะต้องมองเห็นได้ในหน้าต่าง Object Inspector ดังนั้นให้กำหนดและเผยแพร่ (3) ไวยากรณ์ที่กำหนดคือ:
คุณสมบัติ <ชื่อคุณสมบัติ>:<ประเภท> อ่าน <ตัวแปรที่สอดคล้องกันเมื่ออ่านคุณสมบัตินี้> เขียน <ตัวแปรหรือขั้นตอนที่สอดคล้องกันเมื่อเขียนคุณสมบัตินี้>
ตัวแปรและคุณลักษณะอื่นๆ ยังถูกกำหนดในลักษณะเดียวกัน (เช่น ค่าต่ำสุดต่ำสุด ค่าปัจจุบันของมูลค่า เป็นต้น) ต่อไป เราจะกำหนดคุณสมบัติและตัวแปรต่างๆ สำหรับการตั้งค่ารูปภาพบนแถบเลื่อน (เนื่องจากตัวแปรรูปภาพมีความพิเศษ เราจะพูดถึงแยกกัน) เรากำหนด LeftButtonUpPicture (รูปภาพปุ่มซ้าย), LeftButtonDownPicture (รูปภาพกดปุ่มซ้าย) ฯลฯ เป็นประเภท TBitmap (ต้องกำหนดตัวแปรที่สอดคล้องกัน)
คุณต้องสังเกตว่าในซอร์สโปรแกรมที่แนบมา เมื่อกำหนดคุณลักษณะเหล่านี้ ตัวแปรที่สอดคล้องกับคุณลักษณะที่อ่านแล้วอ่านคือ F... แต่ตัวแปรที่สอดคล้องกับคุณลักษณะที่ระบุหลังจากเขียนไม่ใช่ตัวแปร แต่มีลักษณะคล้ายกับ Set ... นี่เป็นกระบวนการที่ปรับแต่งเอง กระบวนการในฐานะฟังก์ชันถูกกำหนดเป็น:
ขั้นตอน <ชื่อขั้นตอน>(ค่า: <ประเภทของค่าของแอตทริบิวต์ที่กำลังตั้งค่า>)
เนื่องจากจำเป็นต้องทำสิ่งอื่นเมื่อเขียนแอตทริบิวต์ประเภทนี้ คุณไม่สามารถใช้ตัวแปรเพื่อจัดการมันได้ คุณควรใช้กระบวนการเพื่อจัดการมัน โดยทั่วไปกระบวนการนี้ถูกกำหนดไว้หลังจากได้รับการป้องกัน ในขั้นตอนประเภทนี้ คำสั่งเช่น ⑷ ใช้เพื่อกำหนดค่าให้กับตัวแปรประเภท TBitmap ซึ่งถูกนำมาใช้เนื่องจากตัวแปรประเภทนี้ไม่สามารถกำหนดค่าได้โดยตรง
หลังจากกำหนดคุณสมบัติของตัวแปรประเภท TBitmap เหล่านี้แล้ว คุณจะต้องเขียนโค้ดในกระบวนการสร้างและทำลายกระบวนการที่กล่าวถึงข้างต้น เนื่องจาก TBitmap ก็เป็นคลาสเช่นกัน จึงต้องสร้างขึ้นในระหว่างกระบวนการสร้าง (5) และจะต้องถูกปล่อยออกมา (ฟรี) ในระหว่างกระบวนการทำลาย (6) คำสั่งที่สืบทอดที่อ้างถึงใน ⑺ ที่นี่ใช้เพื่อระบุว่ากระบวนการนั้นสืบทอดมาจากคลาสบรรพบุรุษ (อันนี้ต้องไม่ทิ้ง)
เนื่องจากเรากำลังเขียนตัวควบคุมด้วยภาพ เราจึงต้องวาดภาพบนตัวควบคุม คลาสบรรพบุรุษของการควบคุมของเรา TGraphicControl ห่อหุ้มวัตถุ Canvas (canvas) และเราสามารถใช้มันโดยตรงในการวาดภาพ หากคุณยังไม่คุ้นเคยกับการใช้ Canvas เป็นความคิดที่ดีที่จะหาหนังสือมาอ่าน
สิ่งต่อไปที่ต้องทำคือการวาดภาพ จะวาดภาพบนตัวควบคุมได้อย่างไร? มีเหตุการณ์ Paint ในคลาสบรรพบุรุษ TGraphicControl ซึ่งจะถูกทริกเกอร์โดยอัตโนมัติเมื่อจำเป็นต้องวาดตัวควบคุมใหม่ สิ่งที่เราต้องทำตอนนี้คือเขียนโปรแกรมสำหรับงานนี้ ขั้นแรกให้กำหนดวัตถุ Canvas หลังจากป้องกันแล้ว เนื่องจากมีอยู่แล้วในคลาสบรรพบุรุษ จึงไม่จำเป็นต้องเพิ่มคำอธิบายใดๆ⑻ เราจะใช้วัตถุนี้ในการวาดภาพ ถัดไป คุณต้องกำหนดกระบวนการ Paint และเขียนโค้ดเพื่อวาดส่วนควบคุม กำหนดกระบวนการ Paint ก่อนจากสาธารณะ เนื่องจากถูกทริกเกอร์โดยคลาสบรรพบุรุษแทนที่จะถูกเรียกโดยผู้ใช้ จึงต้องเพิ่มการแทนที่ในภายหลัง มิฉะนั้น การควบคุมจะไม่กลายเป็นการควบคุมด้วยภาพเนื่องจากกระบวนการ Paint จะไม่ถูกเรียกใช้ ต่อไปเราจะเขียนโค้ดสำหรับกระบวนการ Paint⑽
T_Height และตัวแปรอื่นๆ ในกระบวนการ Paint ของโปรแกรมต้นทางที่แนบมากับบทความนี้ใช้เพื่อบันทึกขนาดของปุ่ม ตัวเลื่อน ฯลฯ ในแถบเลื่อน ส่วนนี้ของโปรแกรมไม่แตกต่างจากโปรแกรมในแอปพลิเคชันทั่วไปมากนัก . ส่วนใหญ่มีไว้สำหรับ Operate บนผืนผ้าใบ ฉันเชื่อว่าทุกคนจะเข้าใจได้ในทันที เป็นที่น่าสังเกตว่าการพิจารณาตัวแปร FAutoSize ต่อไปนี้คือตัวแปรบูลีนที่เกี่ยวข้องกับแอตทริบิวต์ AutoSize ของตัวควบคุม โปรดทราบว่าในโค้ดของตัวควบคุม โดยทั่วไปคุณสมบัติจะไม่ถูกเรียกโดยตรง แต่จะใช้ตัวแปรที่เกี่ยวข้อง
เมื่อมาถึงจุดนี้ในโปรแกรม คุณได้ปรากฏตัวสำหรับการควบคุมใหม่ของคุณในที่สุด แต่ยังไม่สามารถเลื่อนได้ ตอนนี้เรามาเขียนเหตุการณ์ของเมาส์ที่จะทำให้เราสามารถจัดการมันได้ คำจำกัดความของกระบวนการของเมาส์นั้นคล้ายคลึงกับกระบวนการ Paint มาก ยกเว้นว่าจะต้องเพิ่มคำอธิบายพารามิเตอร์ที่ส่วนท้าย เหตุการณ์ของเมาส์จะแบ่งออกเป็นสามประเภท: MouseDown, MouseMove และ MouseUp จะต้องเพิ่มหลังคำจำกัดความ ถัดไปเขียนโค้ดไว้ด้านหลัง หมายเหตุ: เหตุการณ์เมาส์ที่นี่คือ Mouse... ไม่ใช่ OnMouse ปกติ.... แต่คำจำกัดความของ ⒀ ใช้สำหรับอะไร? คำจำกัดความเหตุการณ์ที่นี่มีไว้สำหรับผู้ใช้ กล่าวคือ เมื่อใช้การควบคุม จะถูกแสดงบนหน้าเหตุการณ์ใน Object Inspector
รหัสสำหรับเหตุการณ์เมาส์เหล่านี้ก็ง่ายมากเช่นกัน โดยจะกำหนดพิกัดของเมาส์ วาดภาพที่เกี่ยวข้องบนผืนผ้าใบ ฯลฯ และทริกเกอร์เหตุการณ์ที่เกี่ยวข้องในเวลาเดียวกัน เป็นที่น่าสังเกตว่าเมื่อเรียกเหตุการณ์ที่กำหนดเอง คุณต้องใช้คำสั่งเช่น ⒁ ก่อน เพื่อพิจารณาว่าผู้ใช้ได้เขียนโค้ดสำหรับเหตุการณ์หรือไม่ นี่เป็นสิ่งสำคัญมาก มิฉะนั้นจะเกิดข้อผิดพลาดขึ้น
ทุกคนสังเกตเห็นว่าเหตุการณ์ที่เพิ่งเรียกนั้นถูกปรับแต่งทั้งหมด และวิธีการที่กำหนดไว้ก็ง่ายมากเช่นกัน ซึ่งคล้ายกับการกำหนดคุณสมบัติ ยกเว้นว่าประเภทนั้นเป็น TNotifyEvent
TNotifyEvent เป็นเหตุการณ์เริ่มต้นซึ่งกำหนดเป็น:
TNotifyEvent = ขั้นตอน (ผู้ส่ง: TObject)
หากคุณต้องการกำหนดรูปแบบอื่นของเหตุการณ์ คุณต้องทำสิ่งนี้: เขียนก่อนแล้วจึงพิมพ์
<ชื่อประเภทเหตุการณ์> = ขั้นตอน (<พารามิเตอร์>:<ประเภท>)
ตัวอย่างเช่น:
TCustomEvent = ขั้นตอน (a: จำนวนเต็ม; b: สตริง);
จากนั้นให้นิยามตามหลัง public:
<ชื่อเหตุการณ์>:<ชื่อชนิดเหตุการณ์>
ตัวอย่างเช่น:
เหตุการณ์: TCustomEvent;
หลังจากอ่านข้อความนี้แล้วคุณควรจะเข้าใจขั้นตอนทั้งหมด หากข้อผิดพลาดในการคอมไพล์หรือการทำงานเกิดขึ้น โปรดตรวจสอบจุดต่อไปนี้:
1. มีคำสั่งที่สืบทอดมาในกระบวนการสร้างและทำลายหรือไม่?
2. มีการสร้างและปล่อยตัวแปรประเภท TBitmap หรือไม่?
3. มีชื่อควบคุมก่อนกระบวนการหรือไม่ เช่น TPigHorizontalScroller.MoseMove
วิธีตรวจสอบว่าเมาส์เข้าหรือออกจากตัวควบคุม:
กำหนดกระบวนการต่อไปนี้:
ขั้นตอน MouseEnter (var Msg: TMessage ข้อความ CM_MOUSEENTER;
ขั้นตอน MouseLeave (var Msg: TMessage ข้อความ CM_MOUSELEAVE;