Visual C++ Dialog Box กล่องสารพัดประโยชน์ Dialog Box คืออะไร? Dialog Box เป็นหน้าต่างวินโดวส์ชนิดหนึ่ง ที่ถูกสร้างขึ้นมา เพื่อให้ผู้ใช้งาน สามารถติดต่อสื่อสาร กับโปรแกรมของเราได้ง่าย โดยภายใน Dialog Box นี้ จะมีสิ่งที่เรียกว่า Control อยู่ ซึ่ง Control นี้ ก็คือ หน้าต่างวินโดวส์พิเศษ ที่ใช้สำหรับรับข้อมูล หรือส่งข้อมูลออกมายังผู้ใช้ Control ที่เรารู้จักคุ้นเคยกันดี ก็มี Push Button, Check box, Radio button, List box, Edit box, Combo box, Scroll bar, Static control เป็นต้น

Dialog Box มีอยู่ 2 ชนิดคือ

Modal Dialog Box เป็น Dialog box ที่เมื่อเปิดขึ้นมาบนจอแล้ว ผู้ใช้ต้องตอบสนองต่อ Dialog box นี้เสียก่อน จึงจะทำให้โปรแกรมแม่ (parent program) ทำงานต่อไปได้ กล่าวง่าย ๆ ก็คือ เมื่อเปิด Dialog box ชนิด Modal นี้ ขึ้นมาแล้ว ผู้ใช้ จะไม่สามารถย้ายโฟกัส ไปยังส่วนอื่น ๆ ของโปรแกรมได้ จนกว่า Dialog box นี้จะถูกปิดไปเสียก่อน
Modeless Dialog Box เป็น Dialog box ที่เปิดขึ้นมาแล้ว ยอมให้ผู้ใช้ สามารถย้ายโฟกัส ไปยังส่วนอื่น ๆ ของ parent program ได้

แต่เนื่องจาก การสร้างและใช้งาน Modal Dialog Box ง่ายต่อการทำความเข้าใจ ในที่นี้ หนูแจ๋วขออนุญาต อธิบายเฉพาะ Modal Dialog box เท่านั้นนะคะ แต่เพื่อน ๆ ก็ยังสามารถ หารายละเอียด เกี่ยวกับ Modeless Dialog Box จากหนังสือเล่มอื่น ๆ ได้ไม่ยากเลยค่ะ

การสร้างและใช้งาน Modal Dialog Box

สร้าง Dialog box จาก Dialog editor โดยจะเก็บไว้เป็นส่วนหนึ่ง ของ Resource file (file นามสกุล .RC)
สร้างคลาส ที่สืบทอดมาจาก คลาส CDialog มาห่อหุ้ม (encapsulate) Dialog box นี้
จัดการกับ message ที่เกิดขึ้นภายใน Dialog box
กระตุ้นให้ Dialog box นี้ทำงาน (Activated a Dialog box)
ปิด Dialog box เมื่อใช้งานเสร็จสิ้น

ต่อไป เราลองมาสร้าง Dialog box แบบง่าย ๆ เพื่อทำความเข้าใจ กับการทำงานของมันกัน ดังต่อไปนี้นะคะ
1. สร้าง Dialog box จาก Dialog editor
ให้เปิดโปรแกรม Visual C++ ขึ้นมา สร้างโปรเจคท์ใหม่ ตามวิธีการที่ได้กล่าวไปแล้ว ในตอนต้น (**อย่าลืมใช้คำสั่ง Project -> Setting ให้ใช้ MFC ด้วย **) จากนั้น ให้ใช้คำสั่ง Project -> Add to Project -> New เพื่อจะเพิ่มส่วนประกอบ ให้กับโปรเจคท์นี้ ให้เพื่อน ๆ เลือกเพิ่ม Resource script แล้วตั้งชื่อไฟล์ เป็น testdialog.rc
จากนั้น เลือกเมนู Insert ->Resource เพื่อจะเพิ่มส่วนประกอบ เข้าไปในไฟล์ testdialog.rc โดยตอนแรก ให้เลือกเพิ่ม Menu แล้วกด New แล้วสร้างเมนู ตามวิธี ที่ได้อธิบายไปแล้ว ในหัวข้อก่อน ๆ โดยสร้างเมนู ให้มีหัวข้อเมนู (menu item) และหมายเลข ID ดังต่อไปนี้

menu item = Show Dialog	หมายเลข ID = IDM_SHOWDIALOG
menu item = Exit	หมายเลข ID = IDM_EXIT

เลือกเมนู Insert->Resource แล้วเลือกเพิ่ม Dialog จากนั้นกด New ดังแสดงในรูป

ก็จะเข้าสู่ Dialog Editor ซึ่งจะมีการสร้าง Dialog box ให้ พร้อมกับมีปุ่ม OK และ Cancel มาให้ด้วย โดยด้านขวามือ จะมีไดอะล๊อกของ Control ต่าง ๆ ที่เราสามารถ นำไปใส่ไว้ใน Dialog box ที่สร้างขึ้นได้

ลองดับเบิ้ลคลิ๊กที่บริเวณว่าง ๆ ตรงไหนก็ได้ภายใน Dialog box ก็จะได้ Dialog Properties ขึ้นมา โดยในแท็ป General จะมี ID เป็น IDD_DIALOG1 ซึ่งเราสามารถ เปลี่ยนเป็นชื่ออื่นก็ได้ ค่า ID นี้ เราจะนำไป ใช้เป็นพารามิเตอร์ เพื่อส่งผ่านให้กับ class ที่เราสืบทอดมาจาก CDialog เพื่อ ใช้ในการสร้าง Dialog นี้ ออกมาบนหน้าจอต่อไป ส่วนข้อความ ที่อยู่ในช่อง Caption จะเป็นข้อความ ที่จะถูกนำไปแสดง บน Title bar ของ Dialog box นี้ ให้ลองเปลี่ยน เป็นข้อความใด ๆ ก็ได้ ก็จะทำให้ ข้อความบน Title bar ของ Dialog box เปลี่ยนแปลง ตามไปด้วย ดังรูป

ต่อไปเราจะสร้าง control ง่าย ๆ ลงบน Dialog box โดย ใช้วิธีลากแล้วปล่อย (drag and drop) โดยเอาเมาส์ ไปชี้ที่ สัญลักษณ์ ของปุ่มกด (button) ก็จะมี ข้อความแสดงออกมา บอกว่า สัญลักษณ์นี้ เป็นของ button

จากนั้น ใช้เมาส์ลากปุ่มกดไปวางบน Dialog box ที่สร้างขึ้น โดย Dialog Editor จะตั้งชื่อ บนปุ่มกด ให้โดยอัตโนมัติ เป็น Button1, Button2, Button3 ไปเรื่อย ๆ แต่เราสามารถ เปลี่ยนเป็นชื่อใด ๆ ก็ได้ ตามต้องการ แต่ในตอนนี้ ให้ลากปุ่มกด ไปวางบน Dialog box เพียง 2 ปุ่มก่อน ซึ่งคือปุ่ม Button1 และ Button2 ตามลำดับ

ลองดับเบิ้ลคลิ๊ก ที่ปุ่มกด Button1 ก็จะได้หน้าจอ Push Button Properties ขึ้นมา ภายใน จะมีช่อง สำหรับใส่ค่า ID ของปุ่มกดนี้ โดยเราสามารถ ตั้งชื่อเป็นอะไรก็ได้ ตามต้องการ แต่ควรให้ขึ้นต้นด้วย IDC_ เพื่อบอกให้รู้ว่าเป็น ID ของ Control ส่วนในช่อง Caption ก็จะบรรจุข้อความ ที่จะแสดงออก บนปุ่มนี้ โดยเราสามารถ กำหนดให้เป็นอะไรก็ได้ ตามใจชอบ

คราวนี้เราลองมาทำความรู้จักกับ Control อีกตัวหนึ่ง คือ Static Text ซึ่งเป็น Control ที่จะ แสดงข้อความต่าง ๆ ออกบนหน้าจอของ Dialog box โดยเอาเมาส์ ไปคลิ๊กที่ Static Text แล้วลากมาวางบน Dialog Box

ลองดับเบิ้ลคลิ๊กที่ Static text ที่วางบน Dialog box ก็จะได้ Text Properties ขึ้นมา โดยในช่อง ID จะบรรจุค่า ID ของ static text นี้อยู่ ซึ่งคือ IDC_STATIC และในช่อง Caption ก็ใช้เก็บข้อความ ที่จะแสดงออกมา บน Static text ตอนนี้ เราพิมพ์ข้อความว่า Text in Dialog box ลงไป

เราสามารถลบ control ที่ไม่ต้องการ ออกจาก Dialog box ที่สร้างขึ้นนี้ได้ง่าย ๆ ด้วยการเอาเมาส์ ไปคลิ๊กที่ control ตัวที่ต้องการลบ แล้วกดปุ่ม Del บนคีย์บอร์ด ก็จะสามารถลบ control นั้นออกไปได้ ให้เราลองลบปุ่ม Cancel ออกด้วยวิธีดังกล่าวดู

จากนั้น ให้ใช้เมาส์ลากแล้ววาง Control ต่าง ๆ บน Dialog box ให้อยู่ในตำแหน่งที่สวยงามดังรูป

จากนั้นเรียกเมนู File->Save All เพื่อบันทึกไฟล์ทั้งหมด เก็บลงในฮาร์ดดิสก์ เราลองมาดูภายใน รีซอร์สไฟล์ ที่เราสร้างขึ้น โดยคลิ๊กที่แท็ป Ressource View ก็จะเห็นว่า ในรีซอร์สไฟล์ ที่ชื่อ testdialog.rc จะมี Dialog box อยู่ภายใน 1 Dialog ซึ่งมีหมายเลข ID เป็น IDD_DIALOG1, และมี menu อยู่ภายใน มีหมายเลข ID เป็น IDR_MENU1 ตามลำดับ เราสามารถ เปลี่ยนหมายเลข ID เหล่านี้เป็นอะไรก็ได้ ตามใจชอบ โดยใช้วิธีที่ได้กล่าวไปแล้ว ข้างต้น

2. สร้างคลาสที่สืบทอดมาจากคลาส CDialog มาห่อหุ้ม (encapsulate) Dialog box
ทำได้ โดยการประกาศคลาส ซึ่งสืบทอดมาจากคลาส CDialog โดย Constructor ของคลาส ที่เราสร้างขึ้นมานี้ จะมีการเรียกใช้ Contructor ของคลาส CDialog ด้วย ซึ่งมีรูปแบบดังนี้

CDialog(UINT ID, CWnd *Owner = NULL);

โดย

ID คือค่าหมายเลข ID ของ Dialog box ที่เราสร้างเก็บไว้ในรีซอร์ทไฟล์

Owner คือตัวชี้ (pointer) ที่ชี้ไปยังวินโดวส์แม่ (parent window) ที่เป็นเจ้าของ Dialog box นี้ ถ้าค่า Owner เป็น NULL ก็หมายความว่า วินโดวส์แม่ ของ Dialog box นี้ คือวินโดวส์หลัก ของโปรแกรมเรา (application's main window)

ตัวอย่างการประกาศคลาสชื่อ CSampleDialog ซึ่งสืบทอดมาจาก CDialog แสดงดังนี้

/* this is a dialog class */
class CSampleDialog : public Cdialog
{
  public:
                /* function constructor ที่เรียกใช้ constructor ของคลาส CDialog */
	CSampleDialog(UINT ID, CWnd *parent) : CDialog(ID, parent) { }
              
	/* ประกาศฟังก์ชั่นที่จะจัดการกับ message ที่เกิดขึ้นใน Dialog box */
	afx_msg void OnButton1();
	afx_msg void OnButton2();
	
	/* ประกาศการ map message */
	DECLARE_MESSAGE_MAP()
 };

3. จัดการกับ message ที่เกิดขึ้นภายใน Dialog box
เนื่องจากคลาส CDialog สืบทอด มาจากคลาส CWnd ดังนั้น มันจึงมีคุณสมบัติ ของหน้าต่างวินโดวส์ด้วย ดังนั้น เหตุการณ์ใด ๆ ที่เกิดขึ้นภายใน Dialog box ก็จะมีการส่ง message มาให้ Dialog box นั้น รับรู้ด้วย เพราะฉะนั้น Dialog box แต่ละ Dialog box จะต้องมีการ map message และมีการ เขียนฟังก์ชั่น ที่จัดการกับ message ที่เราสนใจ ไว้ในโค้ดโปรแกรม ส่วนของ Dialog box นั้นด้วย โดยทั่วไปแล้ว Control แต่ละตัว ที่อยู่ภายใน Dialog box จะมีค่า ID ของตัวเองอยู่ เมื่อใดก็ตาม ที่ผู้ใช้ มีการเข้าถึง control ก็จะมี message WM_COMMAND พร้อมกับค่า ID ของคอนโทรลนั้น ถูกส่งมา ให้หน้าต่าง Dialog box ของเรา ดังนั้น เราสามารถ ใช้มาโคร ON_COMMAND ในการ ถอดรหัส และจัดการกับ message ที่ส่งมาจาก control แต่ละตัวได้
ยังมี Control หลายตัว ที่มีการสร้างรหัส notification code ซึ่งเป็นค่า ที่จำเพาะลงไป เพื่อบอกว่า มีการกระทำอะไรกับ control นั้น และเราต้องใช้มาโคร ที่แตกต่างออกไป ในการตรวจจับ และจัดการกับ notification code นั้น เช่น มาโคร ON_LBN_DBLCLK(ID, HandlerName) จะใช้ตรวจจับ การดับเบิ้ลคลิ๊ก ที่ List Box (List box เป็น control ชนิดหนึ่ง ที่ประกอบไปด้วย หัวข้อเลือก เป็นแถวลงมา ตามแนวตั้ง)

4. กระตุ้นให้ Dialog box นี้ทำงาน (Activated a Dialog box)
เมื่อเราสร้าง Dialog box ขึ้นไว้ในรีซอร์สไฟล์ และสืบทอดคลาสจาก CDialog มาหุ้มห่อ Dialog box นี้แล้ว เราก็จะสามารถ เรียก Dialog box นี้ให้ทำงานได้ โดยใช้คำสั่ง DoModal() ซึ่งมีรูปแบบคำสั่ง ดังต่อไปนี้

virtual int CDialog::DoModal( );
ฟังก์ชั่นนี้ จะคืนค่า รหัสสิ้นสุดการทำงาน (termination code) ที่ถูกสร้างขึ้นโดย dialog box เมื่อมันปิดลง หรือจะคืนค่า -1 ออกมาถ้าไม่สามารถ แสดงหน้าต่าง Dialog box ออกทางจอภาพได้ หรือจะคืนค่า IDABORT ออกมาถ้าเกิด ข้อผิดพลาดขึ้น หลังจากแสดง Dialog box ออกบนจอแล้ว ฟังก์ชั่น DoModal( ); จะไม่คืนค่ากลับมา จนกว่ามันจะถูกปิดลงเสียก่อน

5. การปิด Dialog box
ตามปกติแล้ว Dialog box จะปิดโดยอัตโนมัติ เมื่อมันได้รับ message IDOK หรือ IDCANCEL ซึ่ง message ทั้ง 2 ตัวนี้ จะถูกส่งออกมาเมื่อ มีการกดปุ่ม OK หรือ Cancel โดยคลาส CDialog ได้จัดเตรียมฟังก์ชั่น ที่ใช้จัดการกับ message ทั้ง 2 ตัวนี้ อยู่ภายในคลาส เรียบร้อยแล้ว คือฟังก์ชั่น OnOK( ) และ OnCancel( ) เราไม่จำเป็น ต้องประกาศฟังก์ชั่นทั้ง 2 นี้ไว้ใน Message Map เลย แต่ถ้าเราต้องการ จะเขียน โค้ดควบคุม (Override) ฟังก์ชั่นเหล่านี้ ก็สามารถทำได้เช่นกัน หรือเราอาจ สั่งปิด Dialog box นี้เองก็ได้ โดยใช้ คำสั่ง EndDialog() ซึ่งเป็นฟังก์ชั่นสมาชิก ของคลาส CDialog โดยมีรูปแบบคือ

void CDialog::EndDialog(int Status);

โดยที่ Status คือค่าที่ต้องการจะให้ส่งกลับมาจากฟังก์ชั่น DoModal() นั่นเอง

คราวนี้ เราลองมาเขียนโปรแกรมกัน โดยหลังจากสร้างเมนู และ Dialog box เก็บไว้ใน ไฟล์รีซอร์ทแล้ว เราก็จะมา ประกาศคลาสต่าง ๆ ที่จำเป็นใน ไฟล์ชื่อ testdialog.h โดยเลือกให้สร้างไฟล์ ชื่อ sampledialog.h ด้วยวิธีที่ได้กล่าวไปแล้ว ข้างต้น แล้วเขียนโปรแกรมลงไป ดังต่อไปนี้


/* file sampledialog.h */
/* the main window class */
class CMainWin : public CFrameWnd
{
  public:	CMainWin();	/* function constructor */
	afx_msg void OnShowDialog( ); /* ฟังก์ชั่นต้นแบบ ถูกเรียกใช้เมื่อเลือกเมนู ShowDialog*/
	afx_msg void OnExit( );	  /* ฟังก์ชั่นที่ถูกเรียกใช้เมื่อเลือกเมนู Exit */
	DECLARE_MESSAGE_MAP( )   /* ประกาศ message map ของหน้าต่างวินโดวส์หลัก */
  };


/* the application class */
class CApp : public CWinApp
{
  public:	BOOL InitInstance( );
 };

/* this is a dialog class */
class CSampleDialog : public CDialog
 {
    public:
                /* function constructor ที่เรียกใช้ constructor ของคลาส CDialog */
	CSampleDialog(UINT ID, CWnd *parent) : CDialog(ID, parent) { }

	/* ประกาศฟังก์ชั่นที่จะจัดการกับ message ที่เกิดขึ้นใน Dialog box */
	afx_msg void OnButton1();
	afx_msg void OnButton2();
	
	/* ประกาศการ map message ของ Dialog*/
	DECLARE_MESSAGE_MAP()
   };

จากนั้นสร้างไฟล์ใหม่ชื่อ sampledialog.cpp แล้วพิมพ์คำสั่งลงไปดังนี้


/* sampledialog.cpp */
#include <afxwin.h>
#include "sampledialog.h"
#include "resource.h"

/* รายละเอียดของคลาส CMainWin */
CMainWin::CMainWin( )
{
	Create(NULL, "My Simple Dialog box", WS_OVERLAPPEDWINDOW, rectDefault,
  		NULL, MAKEINTRESOURCE(IDR_MENU1));
 }
/* initialize application */
BOOL CApp::InitInstance()
{
	m_pMainWnd = new CMainWin;
	m_pMainWnd -> ShowWindow(m_nCmdShow);
	m_pMainWnd ->UpdateWindow( );
	
	return TRUE;
 }

/* message map ของวินโดวส์หลัก */
BEGIN_MESSAGE_MAP(CMainWin, CFrameWnd)
	ON_COMMAND(IDM_SHOWDIALOG, OnShowDialog)
	ON_COMMAND(IDM_EXIT, OnExit)
END_MESSAGE_MAP()

/* ตัวจัดการ message ของวินโดวส์หลัก */
afx_msg void CMainWin::OnShowDialog( )
{ 
  CSampleDialog mydialog(IDD_DIALOG1, this); /* สร้าง object ของคลาส CSampleDialog */
  mydialog.DoModal( );		/* activate modal dialog box */
 }

afx_msg void CMainWin::OnExit( )
{
  DestroyWindow( );
 }

/* Message Map ของคลาส CSampleDialog */
BEGIN_MESSAGE_MAP(CSampleDialog, CDialog)
	ON_COMMAND(IDC_BUTTON1, OnButton1)
	ON_COMMAND(IDC_BUTTON2, OnButton2)
END_MESSAGE_MAP( )
/* ฟังก์ชั่นที่จัดการ กับ button1 */
afx_msg void CSampleDialog::OnButton1( )
{
 MessageBox("You press button1");
 }

/*ฟังก์ชั่นที่จัดการกับ button2 */
afx_msg void CSampleDialog::OnButton2( )
 {
   MessageBox("You press button2");
}

CApp myapp;	/* สร้าง object ของคลาส CApp  เป็นจุดเริ่มต้นของการทำงานของโปรแกรม*/

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

เมื่อคลิ๊กที่เมนู Show Dialog ก็จะแสดง Dialog box ออกมาดังรูป จะเห็นว่าเมื่อสร้าง Dialog box แบบ Modal ออกมา เรียบร้อยแล้ว เราจะไม่สามารถ ย้ายไปคลิ๊ก ที่วินโดวส์แม่ (parent window) ให้กลับมา active ได้เลย จนกว่าจะปิด Dialog box นี้ ลงเสียก่อน

เมื่อคลิ๊ก ที่ปุ่มกด Button1 หรือ Button2 บน Dialog box ก็จะมีการตอบสนอง ตามที่เราได้ map message เอาไว้ โดยมี Message box ออกมา บนจอภาพ เพื่อแจ้งให้ทราบว่า เรากดปุ่มใดออกไป และเมื่อกดปุ่ม OK ก็จะมีการ เรียกใช้ ฟังก์ชั่น OnOK( ) ซึ่งถูกกำหนด ไว้ในคลาส CDialog โดยอัตโนมัติ ซึ่งมีผล ทำให้หน้าต่าง ของ Dialog box นี้ปิดลง

คราวนี้ เรามาดู รายละเอียด ของโปรแกรมของเรานะคะ โดยในไฟล์ sampledialog.h จะมีการ ประกาศคลาสของ Dialog box ขึ้นมา 1 คลาสชื่อ CSampleDialog โดยสืบทอด มาจากคลาส CDialog ดังแสดงข้างล่างนี้ค่ะ



/* this is a dialog class */
class CSampleDialog : public CDialog
 {
    public:
                /* function constructor ที่เรียกใช้ constructor ของคลาส CDialog */
	CSampleDialog(UINT ID, CWnd *parent) : CDialog(ID, parent) { }

	/* ประกาศฟังก์ชั่นที่จะจัดการกับ message ที่เกิดขึ้นใน Dialog box */
	afx_msg void OnButton1();
	afx_msg void OnButton2();
	
	/* ประกาศการ map message ของ Dialog*/
	DECLARE_MESSAGE_MAP()
   };

จะเห็นว่าในส่วนของ function constructor ของคลาส CSampleDialog จะมีการเรียกใช้ function constructor ของคลาสแม่ คือ คลาส CDialog โดยส่งค่า ID และ parent ไปให้ โดยไม่มี คำสั่งอะไรเพิ่มเติม ดังแสดงด้านล่างนี้

CSampleDialog(UINT ID, CWnd* parent) : CDialog( ID, parent) { }
จากนั้น ก็จะเป็นการประกาศฟังก์ชั่นต้นแบบ ที่ใช้จัดการกับ message ที่จะเกิดขึ้นใน Dialog box นี้

afx_msg void OnButton1( );
afx_msg void OnButton2( );
ส่วนสุดท้าย ก็เป็นการประกาศ การ map message ให้กับหน้าต่าง Dialog box นี้
DECLARE_MESSAGE_MAP( )
ดังที่กล่าว ไว้ในตอนต้น แล้วว่า หน้าต่างของวินโดวส์ ทุกหน้าต่าง สามารถรับ message ได้ทั้งสิ้น ดังนั้นหน้าต่างของ Dialog box ของเรา ที่สร้างขึ้น ถ้าต้องการ ให้สามารถรับ message ได้ ก็จะต้องมีการ ประกาศการ map message ไว้ด้วย

จากนั้น เรามาดู รายละเอียดของ ไฟล์ sampledialog.cpp กัน โดยให้เราสังเกต รายละเอียด ของฟังก์ชั่น OnShowDialog( ) ซึ่งจะถูกเรียกใช้ เมื่อมีการ เลือกเมนู ที่มี ID เป็น IDM_SHOWDIALOG


afx_msg void CMainWin::OnShowDialog( )
{
  CSampleDialog mydialog(IDD_DIALOG1, this); /* สร้าง object ของคลาส CSampleDialog */
  mydialog.DoModal( );		/* activate modal dialog box */
 }

จะเห็นว่า ในการสร้างวัตถุเป้าหมาย ของคลาส CSampleDialog นั้น จะมีการส่งผ่าน ค่าพารามิเตอร์ ไปให้ function constructor ด้วย

IDD_DIALOG1 คือค่า ID ของ Dialog box ที่เราสร้างไว้ใน รีซอร์ส ไฟล์นั้นเอง
this คือค่าตัวชี้ ไปยังหน้าต่าง ที่เป็นเจ้าของ Dialog box นี้ ซึ่งในที่นี้ กำหนดให้เป็น this ก็หมายถึง หน้าต่างวินโดวส์หลัก ของโปรแกรมเรานั่นเอง ที่เป็นเจ้าของ Dialog box นี้

จากนั้น ก็เป็นการกระตุ้น (activate) ให้ Dialog box ของเราแสดงออกมาบนจอภาพ และรอรับ message ที่จะเกิดขึ้นภายใน Dialog box นี้ โดยใช้คำสั่ง DoModal( ); อยู่ต่อกับชื่อของ วัตถุเป้าหมาย ของ Dialog box ที่เราสร้างขึ้น โดยมีเครื่องหมาย จุด ( . ) กั้นกลาง


    mydialog.DoModal( );

หลังจากคำสั่งนี้ Dialog box ของเรา ก็จะปรากฎ ออกมาบนจอภาพ และรอรับ message ที่จะเกิดขึ้นภายใน Dialog box นี้ โดย message map ของ Dialog box นี้ได้ประกาศไว้ใน ไฟล์ sampledialog.cpp ดังนี้


BEGIN_MESSAGE_MAP(CSampleDialog, CDialog)
	ON_COMMAND(IDC_BUTTON1, OnButton1)
	ON_COMMAND(IDC_BUTTON2, OnButton2)
END_MESSAGE_MAP( )

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


    BEGIN_MESSAGE_MAP(CSampleDialog,  CDialog)

เมื่อมีการกดปุ่ม ที่มีหมายเลข ID เป็น IDC_BUTTON1 หรือ IDC_BUTTON2 ก็จะมีการเรียกใช้ ฟังก์ชั่น OnButton1( ) หรือ OnButton2( ) ตาม ลำดับ ซึ่งภายในฟังก์ชั่นเหล่านั้น ก็มีการทำงานง่าย ๆ คือ มีการแสดง message box ออกมา บอกว่า ผู้ใช้กดเลือกปุ่มใด เท่านั้นเอง


/* ฟังก์ชั่นที่จัดการ กับ button1 */
afx_msg void CSampleDialog::OnButton1( )
{
 MessageBox("You press button1");
 }

/*ฟังก์ชั่นที่จัดการกับ button2 */
afx_msg void CSampleDialog::OnButton2( )
 {
   MessageBox("You press button2");
}

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

เป็นยังไงบ้างคะ งงหรือเปล่า? ถ้างง ก็ค่อย ๆ อ่านทบทวนใหม่ช้า ๆ อีกครั้งนะคะ แล้วคราวหน้า เราจะพูดถึง รายละเอียดของ control ที่สำคัญ ๆ ใน Dialog box กันนะคะ สวัสดีค่ะ

หนูแจ่ว

Hosted by www.Geocities.ws