GUI ที่เข้ารหัสด้วยมือเทียบกับ GUI ของนักออกแบบ Qt [ปิด]

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

สำหรับคนหนึ่งฉันพบว่าการเขียนโค้ดด้วยมือนั้นง่ายกว่าการใช้ Qt Designer แม้ว่าสำหรับ GUI Designer ที่ซับซ้อนอาจสมเหตุสมผล GUI ขนาดใหญ่อาจเป็นไปได้โดยใช้ Designer แต่เมื่อเวลาผ่านไปพวกเขาอาจจัดการได้ยากมากเมื่อความซับซ้อนเพิ่มขึ้น (นี่เป็นเพียงความคิดเห็นของฉัน) ฉันยังดาวน์โหลดซอร์สโค้ด AmaroK เพื่อดูว่าคนเหล่านั้นกำลังทำอะไรอยู่และพบการเรียก addWidget () และเพื่อน ๆ มากมาย แต่ไม่มีไฟล์ XML ใดที่สร้างโดย Designer (ยกเว้น: AmaroK ต้องเป็นแอปพลิเคชั่นโปรดของฉันเลยทีเดียว ทุกแพลตฟอร์ม)

แล้ววิธีที่ "ถูกต้อง" ในการสร้าง GUI คืออะไร? นักออกแบบหรือรหัส? ให้เราพิจารณา GUI ประเภทต่อไปนี้สำหรับการสนทนานี้:

1. กล่องโต้ตอบง่ายๆที่ต้องป้อนข้อมูลแสดงผลลัพธ์และออก สมมติว่าเป็นแอปพลิเคชันที่ใช้ URL ของ YouTube และดาวน์โหลดวิดีโอไปยังฮาร์ดดิสก์ของผู้ใช้ ประเภทของแอปพลิเคชันที่มือใหม่มักจะเริ่มต้นด้วย
2. GUI ระดับกลางเช่นตัวแก้ไขบันทึกย่อช่วยเตือนที่มีแถบเครื่องมือ / รายการเมนูบางรายการ ลองใช้ xPad ตัวอย่าง ( http://getxpad.com/ ) ฉันว่าแอปพลิเคชันส่วนใหญ่อยู่ในประเภท "ยูทิลิตี้"
3. GUI ที่ซับซ้อนมากเช่น AmaroK หรือ OpenOffice คุณจะรู้ว่าเมื่อคุณเห็นพวกเขาเพราะมันทำให้ตาของคุณมีเลือดออก

ประสบการณ์ของเรากับนักออกแบบเริ่มต้นในไตรมาสที่ 3

Qt3

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

Qt4

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

การประเมินของฉันคือไม่มีที่ไหนที่มีประโยชน์เท่ากับ Interface Builder บน Mac OS X แต่ ณ จุดนี้ฉันสามารถเห็นการใช้ไฟล์ Designer โดยตรงในโปรแกรม

เราไม่ได้ย้ายกลับไปที่ Designer ตั้งแต่ Qt3 แต่ยังคงใช้เพื่อสร้างต้นแบบและดีบักเค้าโครง

สำหรับปัญหาของคุณ:

1. คุณอาจหลีกเลี่ยงการใช้กล่องโต้ตอบมาตรฐานที่ Qt นำเสนอ QInputDialogหรือถ้าคุณคลาสย่อย QDialog ตรวจสอบให้แน่ใจว่าได้ใช้QButtonDialogBox เพื่อให้แน่ใจว่าปุ่มของคุณมีรูปแบบแพลตฟอร์มที่เหมาะสม

2. คุณอาจทำบางอย่างได้ จำกัด มากขึ้นเช่น xPad ที่มีฟังก์ชันการทำงานของ Designer ที่ จำกัด

3. ฉันไม่คิดว่าคุณจะเขียนบางอย่างเช่น OpenOffice กับ Designer ได้ แต่นั่นอาจไม่ใช่ประเด็น

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

จากประสบการณ์ของฉันกับ Qt Designer และชุดเครื่องมือ / UI-tools อื่น ๆ :

• เครื่องมือ UI เร่งความเร็วในการทำงาน
• เครื่องมือ UI ช่วยให้ปรับแต่งเลย์เอาต์ได้ง่ายขึ้นในภายหลัง
• เครื่องมือ UI ช่วยให้ผู้ที่ไม่ใช่โปรแกรมเมอร์ทำงานออกแบบ UI ได้ง่ายขึ้น / เป็นไปได้

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

ฉันไม่พบว่าขนาดของโครงการสร้างความแตกต่างเลย ประสบการณ์ของคุณอาจแตกต่างกันไป

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

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

องค์กรที่ฉันทำงานได้ย้ายแอปพลิเคชัน GUI ไปยัง Qt เมื่อหลายปีก่อน ฉันคิดว่ามีหลายแง่มุมที่ควรค่าแก่การกล่าวถึง:

• การทำงานกับ Qt Designer อย่างน้อย ณ จุดนั้นก็ไม่ใช่ตัวเลือกที่เป็นจริง: มีคุณสมบัติมากมายเกินไปที่ไม่สามารถทำได้ด้วย Qt Designer;
• อนุสัญญาและโครงสร้างที่ต้องเก็บรักษาไว้ป้องกันการใช้ Qt Designer;
• เมื่อคุณเริ่มต้นโดยไม่มี Designer แล้วอาจเป็นเรื่องยากที่จะย้อนกลับไป
• สิ่งที่สำคัญที่สุดคือโปรแกรมเมอร์คุ้นเคยกับการเขียนโปรแกรมโดยใช้ vi หรือ emacs เป็นอย่างมากแทนที่จะใช้ GUI IDE

ประสบการณ์ของตัวเองซึ่งย้อนกลับไปประมาณ 4 ปีโดยใช้ Qt3.3 เป็นไปไม่ได้ที่พฤติกรรมแบบไดนามิกในไดอะล็อกใน Designer

เพียงเพื่อบอกว่าฉันได้เขียนและดูแล GUI ที่ซับซ้อนใน Qt โดยไม่ใช้ Qt Designer ไม่ใช่เพราะฉันไม่ชอบ Qt Designer แต่เป็นเพราะฉันไม่เคยทำงานแบบนั้นมาก่อน

ส่วนหนึ่งเป็นเรื่องของสไตล์และคุณมาจากไหน: เมื่อฉันเริ่มใช้ Qt ฉันมีประสบการณ์ที่น่าสยดสยองเกี่ยวกับ Dreamweaver และ Frontpage และเครื่องมือ HTML แบบภาพอื่น ๆ และเป็นที่นิยมในการเขียนโค้ดด้วย HomeSite และหันไปใช้ Photoshop เพื่อเลย์เอาต์ที่ยุ่งยาก ปัญหาที่เกิดขึ้น

มีอันตรายกับรหัสภาพ IDE ที่คุณพยายามเก็บไว้ในเครื่องมือภาพ แต่ท้ายที่สุดก็ต้องปรับแต่งโค้ดด้วยเช่นกันในรูปแบบที่ไม่เข้าใจ

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

ขอให้โชคดีกับ Qt - เป็นชุดเครื่องมือที่ยอดเยี่ยมไม่ว่าคุณจะใช้มันและ Qt Creator ดูเหมือนจะเป็น IDE ที่ยอดเยี่ยม

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

ตั้งแต่ฉันเปลี่ยนจาก Delphi เป็น Java สำหรับแอป GUI (ย้อนกลับไปในปี 2002) ฉันไม่เคยใช้นักออกแบบอีกเลย ฉันชอบตัวจัดการเลย์เอาต์มากกว่า และใช่คุณจะได้รับรหัสสำเร็จรูป แต่การย้ายวัตถุบนตัวออกแบบ UI อาจใช้เวลามากพอ ๆ กับการเปลี่ยนต้นแบบ นอกจากนี้ฉันจะติดอยู่กับ IDE ที่ช้า นั่นคือสำหรับกรณี Java / C # ตกลงในขณะที่สำหรับ Qt (โดยเฉพาะ Qt4) จะไม่ใช้ สำหรับ Qt3 ฉันสงสัยว่าทำไมจึงควรแก้ไขโค้ดที่สร้างขึ้น - ไม่สามารถเพิ่มโค้ดในไฟล์อื่นได้หรือไม่? ด้วยเหตุผลใด?

เกี่ยวกับกรณีที่กล่าวถึง: 1) Hand Coded GUI มีแนวโน้มที่จะเขียนได้เร็วขึ้นอย่างน้อยก็ถ้าคุณรู้จักไลบรารีของคุณ หากคุณเป็นมือใหม่และไม่รู้จักพวกเขาคุณอาจประหยัดเวลาและเรียนรู้น้อยลงกับนักออกแบบเนื่องจากคุณไม่จำเป็นต้องเรียนรู้ API ที่คุณใช้ แต่ "เรียนรู้น้อยกว่า" เป็นปัจจัยสำคัญดังนั้นในทั้งสองกรณีฉันจะพูดว่า Hand Coded GUI

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

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

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

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

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

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

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

ต้องบอกว่าฉันทำหน้าต่างหลักและวิดเจ็ตที่ซับซ้อนด้วยมือ ฉันคิดว่านี่เป็นวิธีที่ Trolltech ตั้งใจไว้ QFormLayoutเป็นคลาสที่มีไว้เพื่อสร้างไดอะล็อกอินพุตโดยทางโปรแกรมได้อย่างง่ายดาย

อย่างไรก็ตามนักออกแบบใน Qt 4 ไม่ใช่ IDE เหมือนที่มีใน Qt 3 มันเป็นเพียงตัวแก้ไขสำหรับแก้ไขไฟล์. ui ฉันชอบแบบนั้น. IDE ข้ามแพลตฟอร์มใหม่จะถูกเรียกว่า Qt Creator

มันเป็นโพสต์เก่า แต่ฉันจะแนะนำให้คุณดู Clementine ซึ่งเป็นเครื่องเล่นเพลงที่ (ฉันคิดว่า) มาจาก Amarok พวกเขาใช้ Qt4 และจากสิ่งที่ฉันเห็นมีโฟลเดอร์uiอยู่ในโฟลเดอร์srcของโครงการ ในโฟลเดอร์uiอย่างที่ใคร ๆ คาดว่าจะมีไฟล์ . uiทุกประเภท หากคุณรวบรวมและเริ่มต้น Clementine คุณจะเห็นว่า GUI ค่อนข้างซับซ้อนและค่อนข้างดี

สำหรับฉันมันขึ้นอยู่กับว่าตรรกะถูกห่อหุ้มในวิดเจ็ต / GUI มากแค่ไหน หากเป็นเพียงรูปแบบธรรมดาฉันชอบใช้ QtDesigner

หากมีการตรวจสอบหรือการโต้ตอบที่ซับซ้อนฉันมักจะตั้งโปรแกรมไว้

เรากำลังใช้ Qt Designer หากใครต้องการสร้าง Gui
สิ่งนี้คือการสร้างวิดเจ็ตเล็ก ๆ น้อย ๆ สำหรับงานบางอย่าง (เช่นเดียวกับที่คุณทำในคลาสดีไซน์) จากนั้นรวมเข้าด้วยกันเป็น "parent-gui"

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

นอกจากนี้เรากำลังสร้าง. ui-Files ซึ่งสามารถสร้างได้ในระหว่างการสร้างกระบวนการ จนถึงขณะนี้ไม่จำเป็นต้องแก้ไขไฟล์เหล่านั้นด้วยมือ

สร้างส่วนต่างๆของ UI ของคุณ
ในไฟล์. UI ที่แตกต่างกันโดยใช้ QtDesigner
จากนั้นนำมารวมกัน (และเพิ่มความซับซ้อน) ในโค้ด

มีสิ่งที่คุณไม่สามารถทำใน Qt ออกแบบที่คุณสามารถทำในรหัส
เพื่อ Qt ออกแบบเป็นเพียงส่วนหนึ่งหนึ่ง (ที่ดี) ของโซ่เครื่องมือ