What is handle to the CFileDialog Dropdown control created when we type in the FileName control?

You can use Spy++ to get the handl and control ID of the combo box

I presume that you are bringing up that dialog box by using

   CFileDialog http://msdn.microsoft.com/en-us/library/dk77e5e7(VS.80).aspx

Is that correct?  You are then calling its
    DoModal  http://msdn.microsoft.com/en-us/library/3xb6dhth(VS.80).aspx
function. Is that also correct?  

If so, then the first part of your task is providing a way for the calling object (your program that calls CFileDialog:DoModal() ) get a chance to take some action while the dialog is running (you normally need to wait for it to complete).  You can start by reading this:

   Setting View and Sort in a File Open Dialog
   http://www.experts-exchange.com/A_1334.html

It shows how to ad an OnFIleNameChange() handler.  If my guesses are correct and if you can get that far, then let me know and I will provide the rest of the details on how to obtain the data from the dropdown list.

I am curious, howerver:  Why do you want to know this?

Using EnumChildWIndows() we cn get child window handle. which passes parent window handle. see the example below.

Spy++ is using this technique to get all the window handle and class name, text etc....

You can get spy++ source code from codeproject.com.

#include <iostream>
#include <windows.h>

using namespace std;

BOOL CALLBACK EnumChildProc(HWND hwnd, LPARAM lParam) {

    cout << "hwnd_Child = " << hwnd << endl;
    return TRUE; // must return TRUE; If return is FALSE it stops the recursion
}

int main() {
   
   HWND hwnd = FindWindow(0, "WindowClass");
   EnumChildWindows(hwnd, EnumChildProc, 0);
   return 0;
}

I became interested in this question and have the following solution to propose.

Based on the concept that DanRollins introduced regarding OnFileNameChange().  Basically, we retrieve the handle to the combo box, then subclass it to give it a new WNDPROC.  In this WNDPROC, we wait for the CBN_SELCHANGE notification, which is fired when the selection changes, then handle it appropriately.  In this example, I just ASSERT; you can do whatever you want though.

The following code assumes we have a class CMyFileDialog, and a member BOOL m_bGotWndProc initialised to FALSE in the constructor.

HTH

LRESULT CALLBACK wndProcComboNew ( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	// Retrieve the old WNDPROC
	WNDPROC wndProcOld = NULL;
	VERIFY ( wndProcOld = ( WNDPROC ) GetProp ( hWnd, _T("Original_WndProc") ) );
	if ( !wndProcOld ) return 0; 
	// Handle selection changed in combo accordingly
	if ( uMsg == WM_COMMAND && HIWORD(wParam) == CBN_SELCHANGE )
		ASSERT ( FALSE ); 
	return ::CallWindowProc ( wndProcOld, hWnd, uMsg, wParam, lParam );
} 
/*virtual*/ void CMyFileDialog::OnFileNameChange()
{
	if ( m_bGotWndProc ) return;
	CWnd* pWnd = GetParent()->GetDlgItem ( 0x47C );	// Handle of combo where user types filename
	if ( !pWnd ) return; 
	// Get the old WNDPROC and store it as a property so we can retrieve it in our new WNDPROC
	LONG_PTR wndProcOld = ::SetWindowLongPtr ( pWnd->m_hWnd, GWLP_WNDPROC, ( LONG ) wndProcComboNew );
	if ( wndProcOld )
	{
		if ( ! SetProp ( pWnd->m_hWnd, _T("Original_WndProc"), ( HANDLE ) wndProcOld ) )
		{
			return;
		}
		m_bGotWndProc = TRUE;
	}
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

I still don't know why on earth you want to monkey with that dropdown box.  

It is there to make things easier for the user -- it lists all the items that match with the initial user input.  Instead of typing the full name, you type a partial name, press "down arrow" a few times, and enter.

I assume that there is a specific thing that you want to do; that is, a special reason that you want to control what's in the drop-down list.

 Why not tell us the secret?

I don't ask that out if idle curiousity.  I ask it becasue there is almost certainly a way to accomplish your goal (whatever it is) without messing around with the drop-down box.

As I thought -- You don't need to mess with the drop-down box.

Just wait for the OnFileNameChange notif and disable the OK button at that point.

Pop up a message box in explanation, if you think the user needs it.

Adding a custom message proc via m_ofn.lpfnHook will not work.  It gets called when an item in the list control is clicked, or when the "file types" combo gets dropped down, but not for messages going to the filename combo.

OK.  The following code achieves what you are after.  Every time the text in the edit control part of the combo box changes, I TRACE a message.  You can of course do what you want here; eg disable OK button etc.  This covers what you originally stated that you wanted.  

I achieve this by uisng a technique similar to what MFC does when creating, say, a frame window.  I set a hook immediately before creating my file dialog.  When the hook function gets called, I swap the window procedure of the created window with my own one, which specifically handles the event of the text in a combo changing (I just TRACE a message).  This is OK to do since there is only one combo of style drop down, (not drop list), which is the filename one, but if this becomes a problem, we could always check the ID of the control we receive the event for to ensure it is the correct combo.

NOTE: the code can probably be tidied a bit more than what I present here; for example, I use a public member of CMyFileDialog as the hook procedure.  Maybe the hook could be added in an override of DoModal() instead of in client code (my test dialog).  We could also tidy the use of a global HHOOK too I guess, but these are left as an exercise to the reader :)

HTH

class CMyFileDialog : public CFileDialog
{
public:
	// Standard constructor
	explicit CMyFileDialog(BOOL bOpenFileDialog, // TRUE for FileOpen, FALSE for FileSaveAs
		LPCTSTR lpszDefExt = NULL,
		LPCTSTR lpszFileName = NULL,
		DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
		LPCTSTR lpszFilter = NULL,
		CWnd* pParentWnd = NULL,
		DWORD dwSize = 0,
		BOOL bVistaStyle = TRUE) : CFileDialog ( bOpenFileDialog, lpszDefExt, lpszFileName, dwFlags, lpszFilter, pParentWnd, dwSize, bVistaStyle )
	{
	} 
	// Hook procedure waiting for file dialog creation
	static LRESULT CALLBACK WaitForFileDlgHook(int code, WPARAM wParam, LPARAM lParam); 
protected: 
	// Have we changed the WNDPROC?
	static BOOL s_bGotWndProc;
}; 
/* static */ BOOL CMyFileDialog::s_bGotWndProc = FALSE; 
// Global, stores the original hook procedure
HHOOK g_hHookOrig_WaitForFileDlg = NULL; 
LRESULT CALLBACK wndProcDlgNew ( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	// Retrieve the old WNDPROC
	WNDPROC wndProcOld = NULL;
	VERIFY ( wndProcOld = ( WNDPROC ) GetProp ( hWnd, _T("Original_WndProc") ) );
	if ( !wndProcOld ) return 0; 
	// Handle change in edit control on combo accordingly
	if ( uMsg == WM_COMMAND && HIWORD(wParam) == CBN_EDITCHANGE )
	{
		TRACE ( _T("Handle the edit text being changed in whatever way here!\n") );
	} 
	return ::CallWindowProc ( wndProcOld, hWnd, uMsg, wParam, lParam );
} 
LRESULT CALLBACK CMyFileDialog::WaitForFileDlgHook(int code, WPARAM wParam, LPARAM lParam)
{
	if ( code = HCBT_CREATEWND )
	{
		//
		// Window has been created
		//		 
		HWND hwndCreated = ( HWND ) wParam;
		ASSERT ( hwndCreated != NULL );		// The window that has been created.  Should not be NULL. 
		LONG_PTR wndProcOld = ::SetWindowLongPtr ( hwndCreated, GWLP_WNDPROC, ( LONG ) wndProcDlgNew);
		if ( wndProcOld )
		{
			if ( ! SetProp ( hwndCreated, _T("Original_WndProc"), ( HANDLE ) wndProcOld ) )
			{
				ASSERT ( FALSE );	// Bad.  Cannot continue, but attempt to restore the original WNDPROC.
				::SetWindowLongPtr ( hwndCreated, GWLP_WNDPROC, ( LONG ) wndProcOld );
			} 
			s_bGotWndProc = TRUE; 
		}
	}
	// Remove hook
	::UnhookWindowsHookEx ( g_hHookOrig_WaitForFileDlg ); 
	return 0;
} 
// Client code to create a CMyFileDialog 
// Create hook, then create dialog.
g_hHookOrig_WaitForFileDlg = ::SetWindowsHookEx ( WH_CBT, CMyFileDialog::WaitForFileDlgHook, NULL, ::GetCurrentThreadId() );
CMyFileDialog dlg ( TRUE, _T("*.*"), NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, _T("All files (*.*)|*.*|Text files (*.txt)|*.txt||") );
dlg.DoModal();
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:

The designers already put in place this very simple mechanism to disallow unwanted selections without exiting from the dialog.  See:

  CFileDialog::OnFileNameOK  
  http://msdn.microsoft.com/en-us/library/f9707521.aspx

BOOL CFileDlgEx::OnFileNameOK( )
{
	BOOL nRet=0;   // OK to allwo
	CString s= GetFileTitle();
	if ( s == L"Control Panel" ) {
		MessageBeep(-1);
		nRet=1;   // nope.  Disallowed.
	}
	return (nRet );
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10: