The correct CChildFrame is not activated after the predecessor is closed.

Question

The correct CChildFrame is not activated after the predecessor is closed.

Flaviu_ 1,071

MFC MDI application. Opened several CChildFrame s. (To illustrate better my issue I identified every CChildFrame with an unique id.)

Opened, lets say, 5 CChildFrame. 1, 2, 3, 4, 5.

List the order of the CChildFrame by menu: About: List Childs:

User's image

C:\Project\TT\MainFrm.cpp(237) : atlTraceGeneral - Child: 5
C:\Project\TT\MainFrm.cpp(237) : atlTraceGeneral - Child: 4
C:\Project\TT\MainFrm.cpp(237) : atlTraceGeneral - Child: 3
C:\Project\TT\MainFrm.cpp(237) : atlTraceGeneral - Child: 2
C:\Project\TT\MainFrm.cpp(237) : atlTraceGeneral - Child: 1

Now, change their focus, by clicking on their tabs: click 1, then 4, then 2, then 3. List childs again:

User's image

C:\Project\TT\MainFrm.cpp(237) : atlTraceGeneral - Child: 3
C:\Project\TT\MainFrm.cpp(237) : atlTraceGeneral - Child: 2
C:\Project\TT\MainFrm.cpp(237) : atlTraceGeneral - Child: 4
C:\Project\TT\MainFrm.cpp(237) : atlTraceGeneral - Child: 1
C:\Project\TT\MainFrm.cpp(237) : atlTraceGeneral - Child: 5

So, the focus is on CChildFrame 3.

Now, close this tab. Now, the logic will be the focus should move on CChildFrame 2 (the previous focused CChildFrame). But the focus is going to CChildFrame 5. Not ok. How can I change this illogical behaviour?

The test application could be found here: https://1drv.ms/u/c/dedcb6ef190b8fd4/EcmqdcH4nBhCoP0Dsn51opIB5PKcAQ_ZmoJkZs0tN-Tm2w?e=qY4him

4 answers

Your answer

Answer 1

RLWA32 50,066

It appears that when Child Window 3 is closed MFC activates the next MDI child window, not the previous one.

Following subclass procedure for mdi client window appears to achieve your desired result. It hasn't been tested extensively.

LRESULT CMainFrame::MDIClientProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, UINT_PTR uiSubclass, DWORD_PTR dwRefData)
{
	if (msg == WM_MDIACTIVATE)
	{
		_RPT1(_CRT_WARN,"WM_MDIACTIVATE Activate Child 0x%p\n", (HWND)wParam);
	}
	else if (msg == WM_MDINEXT)
	{
		_RPT2(_CRT_WARN,"WM_MDINEXT Current Child HWND: 0x%p, Activate %s\n", (HWND)wParam, lParam == 0 ? "Next" : "Previous");
	}
	else if (msg == WM_MDIDESTROY)
	{
		_RPT1(_CRT_WARN, "WM_MDIDESTROY Destroy Child 0x%p\n", (HWND)wParam);
		CMainFrame* p = (CMainFrame*)dwRefData;
		p->MDIPrev();
	}
	else if (msg == WM_NCDESTROY)
		RemoveWindowSubclass(hwnd, MDIClientProc, uiSubclass);

	return DefSubclassProc(hwnd, msg, wParam, lParam);
}

Flaviu_ 1,071 Reputation points

2025-07-22T14:58:15.06+00:00

Interesting approach. Thank you. However, this one does not focus the last focused CChildFrame, just the previous CChildFrame tab. And this the problem become painful, to setup the previous focused tab, which can be not the previous one, of course.
RLWA32 50,066 Reputation points

2025-07-22T16:44:29.96+00:00

What you want to achieve is not clear to me. Can you give us some additional examples that illustrate your objective? Earlier, you wrote:

Now, the logic will be the focus should move on CChildFrame 2 (the previous focused CChildFrame).

The sample code does move to mdi child window 2. That's why I'm confused about what you want to accomplish.
Flaviu_ 1,071 Reputation points

2025-07-23T09:48:55.3133333+00:00

@RLWA32 ahh, sorry to create confusion. I'll try to explain better.

So, if you have a MDI app which has, lets say, 5 childs open. Once you open it, and try to close them (without doing anything), from File->Close, the childs will be closing as follow:

close child 5, close child 4, close child 3, close child 2, close child 1. Done.

Scenario 2: Open the same 5 childs. After you open these, focus child 1, then focus child 3.

Now try to close the childs from File->Close. Remember you have focus on child 3. Close child 3. Remember, you had focus on child 1, but once you close child 3, the focus will go on child 5. Which is not logical, the focus should go on child 1.

Of course, this behaviour should go for every child until all of them are closed. I hope to be more clear than first time.

Answer 2

Varsha Dundigalla(INFOSYS LIMITED) 795 Microsoft External Staff

Thank you for reaching out. Please find the answer below:
Activate the Last-Focused MDI Child Instead of Z-Order Default

Problem
In an MFC MDI application, when a child window is closed, MFC activates the next window based on Z-order. This can lead to unintuitive behavior—for example, closing tab 3 activates tab 5 instead of tab 2, which was previously focused.

Fix: Track Activation History

To resolve this, subclass the MDI client window and maintain your own activation history. This allows you to activate the last-focused child window when the current one is closed.

Implementation

In CMainFrame.h:

std::deque m_activationHistory;
static LRESULT CALLBACK MDIClientProc(HWND, UINT, WPARAM, LPARAM, UINT_PTR, DWORD_PTR);

In CMainFrame::OnCreate:

SetWindowSubclass(m_hWndMDIClient, MDIClientProc, 0, (DWORD_PTR)this);

Subclass Procedure:

LRESULT CALLBACK CMainFrame::MDIClientProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
                                           UINT_PTR uiSubclass, DWORD_PTR dwRefData)
{
    auto* pMain = reinterpret_cast(dwRefData);

    switch (msg)
    {
        case WM_MDIACTIVATE:
        {
            HWND h = (HWND)lParam;
            if (::IsWindow(h)) {
                auto& hist = pMain->m_activationHistory;
                hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());
                hist.push_front(h);
            }
            break;
        }

        case WM_MDIDESTROY:
        {
            HWND h = (HWND)wParam;
            auto& hist = pMain->m_activationHistory;
            hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());

            for (HWND prev : hist) {
                if (::IsWindow(prev)) {
                    ::SendMessage(hwnd, WM_MDIACTIVATE, (WPARAM)prev, 0);
                    break;
                }
            }
            break;
        }

        case WM_NCDESTROY:
            RemoveWindowSubclass(hwnd, MDIClientProc, uiSubclass);
            break;
    }

    return DefSubclassProc(hwnd, msg, wParam, lParam);
}

Result

When a tab is closed, the last-focused child window is activated, providing a more intuitive user experience.
Let us know if the issue persists after following these steps. We’ll be happy to assist further if needed.

Flaviu_ 1,071 Reputation points

2025-07-23T09:51:22.0566667+00:00

Hi @Varsha Dundigalla(INFOSYS LIMITED) . Thank you for your solution, let me a few time to try it and I'll let you know.
Varsha Dundigalla(INFOSYS LIMITED) 795 Reputation points Microsoft External Staff

2025-07-24T05:14:09.98+00:00

Okay, noted with Thanks.

Flaviu_ 1,071

I tried your suggested code. Unfortunately, works correctly only for the first child closed. If you close the second child, the focus will go to the last (most right) child.

Here is the code I tried:

Header:

// Attributes
public:
	std::deque<HWND> m_activationHistory;
...
	static LRESULT CALLBACK MDIClientProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, 
											UINT_PTR uiSubclass, DWORD_PTR dwRefData);

Implementation:

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (-1 == CMDIFrameWndEx::OnCreate(lpCreateStruct))
		return -1;
	SetWindowSubclass(m_hWndMDIClient, MDIClientProc, 0, reinterpret_cast<DWORD_PTR>(this));

and

LRESULT CMainFrame::MDIClientProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
									UINT_PTR uiSubclass, DWORD_PTR dwRefData)
{
	auto pMain = reinterpret_cast<CMainFrame*>(dwRefData);
	switch (uMsg)
	{
	case WM_MDIACTIVATE:
	{
		HWND h = (HWND)wParam;
		if (::IsWindow(h))
		{
			auto& hist = pMain->m_activationHistory;
			hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());
			hist.push_front(h);
		}
		break;
	}
	case WM_MDIDESTROY:
	{
		HWND h = (HWND)wParam;
		auto& hist = pMain->m_activationHistory;
		hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());
		for (HWND prev : hist)
		{
			if (::IsWindow(prev))
			{
				::SendMessage(hWnd, WM_MDIACTIVATE, (WPARAM)prev, 0);
				break;
			}
		}
		break;
	}
	case WM_NCDESTROY:
		RemoveWindowSubclass(hWnd, MDIClientProc, uiSubclass);
		break;
	}
	return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}

I suspect the framework force somehow the focus for the last (most right) child. The test app could also be found here: https://1drv.ms/u/c/dedcb6ef190b8fd4/EU14uibr5LtPuRcpGdSA-zQBsqNVQgXMr53a1B38H3RFtg?e=zMUjdu

Varsha Dundigalla(INFOSYS LIMITED) 795 Microsoft External Staff

Override the OnDestroy() method in your CChildFrame class and implement logic to activate the next visible tab based on Z-order (tab order). This ensures correct and expected tab focus behavior.

ChildFrame.h

class CChildFrame : public CMDIChildWndEx
{
protected:
    virtual void OnDestroy();
    CMDIChildWnd* FindNextTabbedChild();
};

Source File: ChildFrame.cpp

void CChildFrame::OnDestroy()
{
    CMDIFrameWndEx* pMainFrame = DYNAMIC_DOWNCAST(CMDIFrameWndEx, AfxGetMainWnd());
    if (pMainFrame && pMainFrame->MDIGetActive() == this)
    {
        if (CMDIChildWnd* pNextChild = FindNextTabbedChild())
        {
            // Activate next child before destruction
            pNextChild->MDIActivate();
        }
    }

    CMDIChildWndEx::OnDestroy();
}

CMDIChildWnd* CChildFrame::FindNextTabbedChild()
{
    CMDIChildWnd* pFirst = nullptr;
    CMDIChildWnd* pNext = nullptr;

    CMDIChildWnd* pCurrent = this;
    CWnd* pFrame = GetTopLevelFrame();
    CMDIChildWnd* pChild = DYNAMIC_DOWNCAST(CMDIChildWnd, pFrame->GetWindow(GW_CHILD));

    while (pChild)
    {
        if (!pFirst && ::IsWindowVisible(pChild->m_hWnd))
            pFirst = pChild;

        if (pChild == pCurrent)
        {
            pNext = DYNAMIC_DOWNCAST(CMDIChildWnd, pChild->GetNextWindow());
            while (pNext && (!::IsWindowVisible(pNext->m_hWnd) || pNext == this))
                pNext = DYNAMIC_DOWNCAST(CMDIChildWnd, pNext->GetNextWindow());
            break;
        }

        pChild = DYNAMIC_DOWNCAST(CMDIChildWnd, pChild->GetNextWindow());
    }

    if (!pNext)
        pNext = pFirst;

    return (pNext && pNext != this) ? pNext : nullptr;
}

What This Does

Activates the next tab in Z-order when a tab is closed.
Skips hidden or minimized windows.
Wraps around to the first tab if the closed tab was the last.
Prevents reactivating the same window if it’s the only one.

Closing any tab will now correctly activate the adjacent tab in the expected tab order — not the last tab. This works reliably for all positions (first/middle/last tab) and is compatible with modern MFC tabbed interfaces (CMDIFrameWndEx).

Let us know if the issue persists after following these steps. We’ll be happy to assist further if needed.

Flaviu_ 1,071

@Varsha Dundigalla(INFOSYS LIMITED)

Interesting approach. To activate the predecessor before to close the current one. Unfortunately, does not work correctly. Does work for the first child closed. But if you close another child, the focus goes to the last (most right) child.

I have adapted your code (basically does what your code does, yours does not working on my side due to bad pointer conversion, but this does not matter now):

CMDIChildWnd* CChildFrame::FindNextTabbedChild()
{
	CMDIFrameWnd* pMainFrame = static_cast<CMDIFrameWnd*>(AfxGetMainWnd());
	// Get the first MDI child window
	CWnd* pChild = pMainFrame->MDIGetActive();
	int count{};
	while (pChild)
	{
		// You can check the runtime class to ensure it's a CChildFrame
		if (pChild->IsKindOf(RUNTIME_CLASS(CChildFrame)))
		{
			CChildFrame* pChildFrame = static_cast<CChildFrame*>(pChild);
			CTTDoc* doc = static_cast<CTTDoc*>(pChildFrame->GetActiveDocument());
			if (doc)
				TRACE(">>>%d\n", doc->m_nDocId);
			if (1 == count)	// next opened child
				return pChildFrame;
			// Do something with pChildFrame
			TRACE(_T("Found child frame: 0x%p\n"), pChildFrame);
			count++;
		}
		// Get the next MDI child
		pChild = pChild->GetWindow(GW_HWNDNEXT);
	}
	return nullptr;
}

Of course, there has no error protection. If you close a child, works correctly. But if you close another child, the focus go to the last (most right) child.

P.S. This is the demo app: https://1drv.ms/u/c/dedcb6ef190b8fd4/EUEz9i-gj_5ImY3FlJpDRKQBBwJHdx4CLVjByCM4i5_w0A?e=PXluax

Varsha Dundigalla(INFOSYS LIMITED) 795 Microsoft External Staff

Thanks for sharing details.

This resolves the issue where closing an MDI child does not activate the correct next child—especially when using CMDITabInfo-based tabbed interfaces in MFC Feature Pack.

Step 1: Modify CMainFrame

In MainFrm.h

class CMainFrame : public CMDIFrameWndEx
{
public:
    void ActivateNextTab();

protected:
    CMDIChildWnd* m_pLastActiveChild = nullptr;
    BOOL m_bInCloseSequence = FALSE;

    afx_msg void OnMDIActivate(BOOL bActivate, CWnd* pActivateWnd, CWnd* pDeactivateWnd);
    DECLARE_MESSAGE_MAP()
};

BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWndEx)
    ON_WM_MDIACTIVATE()
END_MESSAGE_MAP()

void CMainFrame::OnMDIActivate(BOOL bActivate, CWnd* pActivateWnd, CWnd* pDeactivateWnd)
{
    CMDIFrameWndEx::OnMDIActivate(bActivate, pActivateWnd, pDeactivateWnd);

    if (!m_bInCloseSequence && bActivate)
    {
        m_pLastActiveChild = DYNAMIC_DOWNCAST(CMDIChildWnd, pActivateWnd);
    }
}

void CMainFrame::ActivateNextTab()
{
    m_bInCloseSequence = TRUE;

    CMDIChildWnd* pActive = MDIGetActive();

    // 1. Try next in z-order
    HWND hNext = pActive ? ::GetWindow(pActive->m_hWnd, GW_HWNDNEXT) : nullptr;
    while (hNext)
    {
        CMDIChildWnd* pNext = DYNAMIC_DOWNCAST(CMDIChildWnd, CWnd::FromHandle(hNext));
        if (pNext && ::IsWindowVisible(pNext->m_hWnd))
        {
            pNext->MDIActivate();
            m_bInCloseSequence = FALSE;
            return;
        }
        hNext = ::GetWindow(hNext, GW_HWNDNEXT);
    }

    // 2. Try previous in z-order
    HWND hPrev = pActive ? ::GetWindow(pActive->m_hWnd, GW_HWNDPREV) : nullptr;
    while (hPrev)
    {
        CMDIChildWnd* pPrev = DYNAMIC_DOWNCAST(CMDIChildWnd, CWnd::FromHandle(hPrev));
        if (pPrev && ::IsWindowVisible(pPrev->m_hWnd))
        {
            pPrev->MDIActivate();
            m_bInCloseSequence = FALSE;
            return;
        }
        hPrev = ::GetWindow(hPrev, GW_HWNDPREV);
    }

    // 3. Fallback to last known active child
    if (m_pLastActiveChild && ::IsWindowVisible(m_pLastActiveChild->m_hWnd))
    {
        m_pLastActiveChild->MDIActivate();
    }

    m_bInCloseSequence = FALSE;
}

Step 2: Modify CChildFrame

In ChildFrame.h

class CChildFrame : public CMDIChildWndEx
{
protected:
    virtual void OnDestroy();
};

void CChildFrame::OnDestroy()
{
    CMainFrame* pMainFrame = DYNAMIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
    BOOL bWasActive = pMainFrame && (pMainFrame->MDIGetActive() == this);

    CMDIChildWndEx::OnDestroy(); // Proceed with normal destruction

    if (bWasActive && pMainFrame)
    {
        pMainFrame->ActivateNextTab();
    }
}

How It Works

OnMDIActivate() tracks the last focused child.
OnDestroy() calls ActivateNextTab() only if the closing child was active.
ActivateNextTab() tries: Next visible child in z-order. Previous visible child. Last known active child.
Uses flags to avoid flicker or reentrancy issues.
Works even if tabs are rearranged or windows are hidden.

To Use in Your App

Make sure you're using CMDIFrameWndEx and CMDIChildWndEx

Let us know if the issue persists after following these steps. We’ll be happy to assist further if needed.

Varsha Dundigalla(INFOSYS LIMITED) 795 Reputation points Microsoft External Staff

2025-08-07T07:00:10.0866667+00:00

Hope you're doing well! Please let us know if the issue persists or resolved.
Flaviu_ 1,071 Reputation points

2025-08-07T15:11:20.2566667+00:00

@Varsha Dundigalla(INFOSYS LIMITED) Ahh, did not see your messages, let me try it, ok? And I'll let you know. Thank you a lot!!!

Flaviu_ 1,071

I have tried your solution and does not work.

The code from CChildFrame:

void CChildFrame::OnDestroy()
{
	CMainFrame* pMainFrame = DYNAMIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
	BOOL bWasActive = pMainFrame && (pMainFrame->MDIGetActive() == this);
	CMDIChildWndEx::OnDestroy();
	// TODO: Add your message handler code here
	if (bWasActive && pMainFrame)
	{
		pMainFrame->ActivateNextTab();
	}
}

is too late. Here is the tab order:

Child: HWND: 0x0000000000191116 index: 2, id: 3
Child: HWND: 0x00000000001513E6 index: 1, id: 2
Child: HWND: 0x00000000002D0C34 index: 3, id: 4
Child: HWND: 0x0000000000430F5A index: 0, id: 1
Child: HWND: 0x00000000000A07A0 index: 4, id: 5

And when I tried to close tab 3, the tab was closed:

User's image

And the last tab got the focus, tab 5, but tab 2 suppose to get the focus.

I put this code into CChildFrame::OnClose handler:

void CChildFrame::OnClose()
{
	// TODO: Add your message handler code here and/or call default
	CMainFrame* pMainFrame = DYNAMIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
	BOOL bWasActive = pMainFrame && (pMainFrame->MDIGetActive() == this);
	CMDIChildWndEx::OnClose();
	if (bWasActive && pMainFrame)
	{
		pMainFrame->ActivateNextTab();
	}
}

And does work somehow, I mean the focus goes eventually to the right tab, but only after is flashing the last (most right) tab:

Child: HWND: 0x00000000005105E4 index: 2, id: 3
Child: HWND: 0x0000000000081408 index: 1, id: 2
Child: HWND: 0x00000000007C1106 index: 3, id: 4
Child: HWND: 0x0000000000770838 index: 0, id: 1
Child: HWND: 0x0000000000460F5A index: 4, id: 5

User's image

and then finally goes the the correct tab:
User's image

Varsha Dundigalla(INFOSYS LIMITED) 795 Microsoft External Staff

Thank you for sharing details.

Fixing Wrong Tab Activation When Closing in MDI Apps (MFC)

The previous one failed because it relied on MDI’s default behavior, which picks the next window by creation order instead of last active order.

Now we track the last active child ourselves, so after closing one, focus correctly returns to the previously active child.

Step 1 – Track Tab History

CMainFrame.h

#include <deque>

class CMainFrame : public CMDIFrameWndEx {
public:
    std::deque m_activationHistory;
    BOOL m_bInClose = FALSE;

    static LRESULT CALLBACK MDIClientProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
                                          UINT_PTR uIdSubclass, DWORD_PTR dwRefData);
};

CMainFrame.cpp

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) {
    if (CMDIFrameWndEx::OnCreate(lpCreateStruct) == -1)
        return -1;

    SetWindowSubclass(m_hWndMDIClient, MDIClientProc, 0, reinterpret_cast(this));
    return 0;
}

LRESULT CALLBACK CMainFrame::MDIClientProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam,
                                           UINT_PTR uIdSubclass, DWORD_PTR dwRefData) {
    auto pMain = reinterpret_cast(dwRefData);
    auto& hist = pMain->m_activationHistory;

    switch (msg) {
        case WM_MDIACTIVATE: {
            HWND hActive = (HWND)lParam;
            if (hActive && ::IsWindow(hActive)) {
                hist.erase(std::remove(hist.begin(), hist.end(), hActive), hist.end());
                hist.push_front(hActive);
            }
            break;
        }
        case WM_MDIDESTROY: {
            HWND hDestroyed = (HWND)wParam;
            hist.erase(std::remove(hist.begin(), hist.end(), hDestroyed), hist.end());
            break;
        }
        case WM_NCDESTROY:
            RemoveWindowSubclass(hWnd, MDIClientProc, uIdSubclass);
            break;
    }

    return DefSubclassProc(hWnd, msg, wParam, lParam);
}

Step 2 – Activate Correct Tab Before Closing

CChildFrame.cpp

void CChildFrame::OnClose() {
    CMainFrame* pMain = DYNAMIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
    if (!pMain) {
        CMDIChildWndEx::OnClose();
        return;
    }

    if (pMain->m_bInClose) {
        CMDIChildWndEx::OnClose();
        return;
    }

    pMain->m_bInClose = TRUE;

    if (pMain->MDIGetActive() == this) {
        for (HWND h : pMain->m_activationHistory) {
            if (h != m_hWnd && ::IsWindow(h)) {
                ::SendMessage(pMain->m_hWndMDIClient, WM_MDIACTIVATE, (WPARAM)h, 0);
                break;
            }
        }
    }

    CMDIChildWndEx::OnClose();
    pMain->m_bInClose = FALSE;
}

Why It Works

Activates the correct tab before MFC can choose the wrong one
Uses real usage history, not creation order
No flicker or flash
Works for any tab sequence

Let us know if the issue persists after following these steps. We’ll be happy to assist further if needed.

Answer 3

RLWA32 50,066

@Flaviu_ Give the following a try -

LRESULT CALLBACK CMainFrame::MDIClientProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
	UINT_PTR uiSubclass, DWORD_PTR dwRefData)
{
	auto* pMain = reinterpret_cast<CMainFrame*>(dwRefData);
	static bool InDestroy = false;

	switch (msg)
	{
	case WM_MDIACTIVATE:
	{
		HWND h = (HWND)wParam;
		_RPT1(_CRT_WARN, "WM_MDIACTIVATE Child 0x%p\n", h);
		auto &hist = pMain->m_activationHistory;
		if (hist.empty() || h != hist.front())
		{
			if (!InDestroy)
			{
				hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());
				hist.push_front(h);
				for (auto& f : hist)
				{
					CMDIChildWndEx* pChild = DYNAMIC_DOWNCAST(CMDIChildWndEx, FromHandle(f));
					_RPT1(_CRT_WARN, "Activate Focus Child 0x%p, %d\n", f, (DYNAMIC_DOWNCAST(CTTDoc, pChild->GetActiveDocument()))->m_nDocId);
				}
			}
		}
		break;
	}

	case WM_MDIDESTROY:
	{
		HWND h = (HWND)wParam;
		_RPT1(_CRT_WARN, "WM_MDIDESTROY Destroy Child 0x%p\n", h);
		InDestroy = true;
		auto result = DefSubclassProc(hwnd, msg, wParam, lParam);
		InDestroy = false;
		auto& hist = pMain->m_activationHistory;
		hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());

		if (!hist.empty())
		{
			::SendMessage(hwnd, WM_MDIACTIVATE, (WPARAM)hist.front(), 0);
		}

		for (auto& f : hist)
		{
			CMDIChildWndEx* pChild = DYNAMIC_DOWNCAST(CMDIChildWndEx, FromHandle(f));
			_RPT1(_CRT_WARN, "Destroy Focus Child 0x%p %d\n", f, (DYNAMIC_DOWNCAST(CTTDoc, pChild->GetActiveDocument()))->m_nDocId);
		}

		return result;

		break;
	}

	case WM_NCDESTROY:
		RemoveWindowSubclass(hwnd, MDIClientProc, uiSubclass);
		break;
	}

	return DefSubclassProc(hwnd, msg, wParam, lParam);
}

The idea was to prevent the order of the focused windows from being changed by an extra WM_MDIACTIVATE message sent by the framework. After it handles a message it prints the focus order so you can tell where focus should go upon closing a child window.

Flaviu_ 1,071

Yes, it works, except one annoying fact: when you close a child, the last (most right) child tab is activating for very short time. Which is not ok, if you have a slow machine, this short activation for the last tab can be seen clearly.

LRESULT CMainFrame::MDIClientProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
									UINT_PTR uiSubclass, DWORD_PTR dwRefData)
{
	static bool InDestroy = false;
	auto pMain = reinterpret_cast<CMainFrame*>(dwRefData);
	switch (uMsg)
	{
	case WM_MDIACTIVATE:
	{
		HWND h = (HWND)wParam;
		TRACE(_T("WM_MDIACTIVATE Child 0x%p\n"), h);
		auto& hist = pMain->m_activationHistory;
		if (hist.empty() || h != hist.front())
		{
			if (!InDestroy)
			{
				hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());
				hist.push_front(h);
				for (auto& f : hist)
				{
					CMDIChildWndEx* pChild = DYNAMIC_DOWNCAST(CMDIChildWndEx, FromHandle(f));
					TRACE(_T("Activate Focus Child 0x%p, %d\n"), f, (DYNAMIC_DOWNCAST(CTTDoc, pChild->GetActiveDocument()))->m_nDocId);
				}
			}
		}
		break;
	}
	case WM_MDIDESTROY:
	{
		HWND h = (HWND)wParam;
		TRACE(_T("WM_MDIDESTROY Destroy Child 0x%p\n"), h);
		InDestroy = true;
		auto result = DefSubclassProc(hWnd, uMsg, wParam, lParam);
		InDestroy = false;
		auto& hist = pMain->m_activationHistory;
		hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());
		if (!hist.empty())
		{
			::SendMessage(hWnd, WM_MDIACTIVATE, (WPARAM)hist.front(), 0);
		}
		for (auto& f : hist)
		{
			CMDIChildWndEx* pChild = DYNAMIC_DOWNCAST(CMDIChildWndEx, FromHandle(f));
			TRACE(_T("Destroy Focus Child 0x%p %d\n"), f, (DYNAMIC_DOWNCAST(CTTDoc, pChild->GetActiveDocument()))->m_nDocId);
		}
		return result;
		break;
	}
	case WM_NCDESTROY:
		RemoveWindowSubclass(hWnd, MDIClientProc, uiSubclass);
		break;
	}
	return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}

The test demo could be seen here: https://1drv.ms/u/c/dedcb6ef190b8fd4/EXHdWjZStkhGpjsYWyg3KbkBdtI1MUB1LIQywOuGlp0r9g?e=jnocXd

RLWA32 50,066 Reputation points

2025-07-24T17:55:29.6466667+00:00

Yes, I'm aware of the momentary effect. It was not very pronounced on my system. Considering that your objective is to work against the usual flow of control I was willing to accept it.

RLWA32 50,066

@Flaviu_ I made a change to the WM_MDIACTIVE handler so that it returns without calling DefSubclassProc if InDestroy is true. Let me know what you think.

if (!InDestroy)
{
	hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());
	hist.push_front(h);
	for (auto& f : hist)
	{
		CMDIChildWndEx* pChild = DYNAMIC_DOWNCAST(CMDIChildWndEx, FromHandle(f));
		_RPT2(_CRT_WARN, "Activate Focus Child 0x%p, %d\n", f, (DYNAMIC_DOWNCAST(CTTDoc, pChild->GetActiveDocument()))->m_nDocId);
	}
}
else  // added
	return 0;  //added

Flaviu_ 1,071 Reputation points

2025-07-25T08:33:27.5266667+00:00

"Yes, I'm aware of the momentary effect. It was not very pronounced on my system. Considering that your objective is to work against the usual flow of control I was willing to accept it."

Yes, but this solution will be used in a real app, and looks un-professional that flickering ...

"I made a change to the WM_MDIACTIVE handler so that it returns without calling DefSubclassProc if InDestroy is true. Let me know what you think."

Unfortunately does not work, the flicker is still there.

RLWA32 50,066

Its hard for me to see the flickering on my system. But I tried something else.

I moved the InDestroy flag from a static local variable in the subclass procedure to a member variable of CMainFrame. Then I added a WM_MDIACTIVATE handler to CChildFrame that does not call the base class method if the InDestroy flag is true.

Subclass proc - minor changes

LRESULT CALLBACK CMainFrame::MDIClientProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
	UINT_PTR uiSubclass, DWORD_PTR dwRefData)
{
	auto* pMain = reinterpret_cast<CMainFrame*>(dwRefData);

	switch (msg)
	{
	case WM_MDIACTIVATE:
	{
		HWND h = (HWND)wParam;
		_RPT1(_CRT_WARN, "WM_MDIACTIVATE Child 0x%p\n", h);
		auto &hist = pMain->m_activationHistory;
		if (hist.empty() || h != hist.front())
		{
			if (!pMain->m_bInDestroy)
			{
				hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());
				hist.push_front(h);
				for (auto& f : hist)
				{
					CMDIChildWndEx* pChild = DYNAMIC_DOWNCAST(CMDIChildWndEx, FromHandle(f));
					_RPT2(_CRT_WARN, "Activate Focus Child 0x%p, %d\n", f, (DYNAMIC_DOWNCAST(CTTDoc, pChild->GetActiveDocument()))->m_nDocId);
				}
			}
		}
		break;
	}

	case WM_MDIDESTROY:
	{
		HWND h = (HWND)wParam;
		_RPT1(_CRT_WARN, "WM_MDIDESTROY Destroy Child 0x%p\n", h);
		pMain->m_bInDestroy = true;
		auto result = DefSubclassProc(hwnd, msg, wParam, lParam);
		pMain->m_bInDestroy = false;
		auto& hist = pMain->m_activationHistory;
		hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());

		if (!hist.empty())
		{
			::SendMessage(hwnd, WM_MDIACTIVATE, (WPARAM)hist.front(), 0);
		}

		for (auto& f : hist)
		{
			CMDIChildWndEx* pChild = DYNAMIC_DOWNCAST(CMDIChildWndEx, FromHandle(f));
			_RPT1(_CRT_WARN, "Destroy Focus Child 0x%p %d\n", f, (DYNAMIC_DOWNCAST(CTTDoc, pChild->GetActiveDocument()))->m_nDocId);
		}

		return result;

		break;
	}

	case WM_NCDESTROY:
		RemoveWindowSubclass(hwnd, MDIClientProc, uiSubclass);
		break;
	}

	return DefSubclassProc(hwnd, msg, wParam, lParam);
}

CChildFrame handler for WM_MDIACTIVATE -

void CChildFrame::OnMDIActivate(BOOL bActivate, CWnd* pActivateWnd, CWnd* pDeactivateWnd)
{
	const auto parent = GetParentFrame();
	if (parent->IsKindOf(RUNTIME_CLASS(CMainFrame)))
	{
		auto pMain = DYNAMIC_DOWNCAST(CMainFrame, parent);
		if (!pMain->m_bInDestroy)
		{
			CMDIChildWndEx::OnMDIActivate(bActivate, pActivateWnd, pDeactivateWnd);
		}
	}
}

Maybe this will help. :)

RLWA32 50,066 Reputation points

2025-07-25T17:13:32.42+00:00

@Flaviu_, I tried a different approach above to deal with the momentary activation and flickering problem. Please give it a try when you have a chance.
Flaviu_ 1,071 Reputation points

2025-07-27T12:26:52.3733333+00:00
@RLWA32 Hi. I have tried your approach, unfortnately does not work either:

Here is the application opened with 5 tabs:

And the their order is (regarding the last used childs):

C:\Project\TT\MainFrm.cpp(302) : atlTraceGeneral - Child: 3 C:\Project\TT\MainFrm.cpp(302) : atlTraceGeneral - Child: 2 C:\Project\TT\MainFrm.cpp(302) : atlTraceGeneral - Child: 4 C:\Project\TT\MainFrm.cpp(302) : atlTraceGeneral - Child: 1 C:\Project\TT\MainFrm.cpp(302) : atlTraceGeneral - Child: 5

As you see, the tab 5 is the first used child, and 3 is the last used and current one. So, if I close child 3, the next focused child should be 2, then 4, then 1, then 5 (last one).

I put a break point here:

And I am closing the childs, one by one. When I close the current one, tab 3:

and break point is here:

As you see, when I close child 3, the focus go to tab 5 (the most right) and then go to tab 2:

Which is not correct. I don't know why when you close a child, MFC framework force the focus on the most right child.
Flaviu_ 1,071 Reputation points

2025-07-27T12:33:25.0366667+00:00

@RLWA32 & @Varsha Dundigalla(INFOSYS LIMITED)
I am out of the office until 4 August, and I cannot answer here, but I definitely follow your posts. I want to kindly thank you for your assistance. I will come back from 4 August onwards.

RLWA32 50,066

I reworked the code and the only override I left in CChildFrame was to OnMDIActive so that you can set a breakpoint for observation. It does nothing but call the base class method.

Removed bool flag for flagging child window destruction.

Set the BOOL value m_bActivateLastVisibleTab to FALSE prior to activating the desired tab from activation history.

Revised CMainFrame functions -

void CMainFrame::OnHelpListchilds()
{
    // TODO: Add your command handler code here
	HWND hChild = ::GetWindow(m_hWndMDIClient, GW_CHILD);
	CWnd* pWnd = CWnd::FromHandle(hChild);
	while (pWnd)
	{
		if (pWnd->IsKindOf(RUNTIME_CLASS(CMDIChildWndEx)))
		{
			auto c = static_cast<CMDIChildWndEx*>(pWnd);
			auto ptc = c->GetRelatedTabGroup();
			auto tab = ptc->GetTabFromHwnd(c->GetSafeHwnd());
			CTTDoc* pDoc = static_cast<CTTDoc*>(c->GetActiveDocument());
			_RPTN(_CRT_WARN, "Child: HWND: 0x%p index: %d, id: %d\n", c->GetSafeHwnd(), tab, pDoc->m_nDocId);
		}
		pWnd = pWnd->GetNextWindow();
	}
}

Outputs the tab index and the id.

LRESULT CALLBACK CMainFrame::MDIClientProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
	UINT_PTR uiSubclass, DWORD_PTR dwRefData)
{
	auto* pMain = reinterpret_cast<CMainFrame*>(dwRefData);

	switch (msg)
	{
	case WM_MDIACTIVATE:
	{
		HWND h = (HWND)wParam;
		_RPT1(_CRT_WARN, "WM_MDIACTIVATE Child 0x%p\n", h);
		auto &hist = pMain->m_activationHistory;
		if (hist.empty() || h != hist.front())
		{
			hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());
			hist.push_front(h);
			//for (auto& f : hist)
			//{
			//	CMDIChildWndEx* pChild = DYNAMIC_DOWNCAST(CMDIChildWndEx, FromHandle(f));
			//	auto ptc = pChild->GetRelatedTabGroup();
			//	auto tab = ptc->GetTabFromHwnd(f);
			//	_RPT2(_CRT_WARN, "Activate Focus Child 0x%p, index: %d, id: %d\n", f, tab, (DYNAMIC_DOWNCAST(CTTDoc, pChild->GetActiveDocument()))->m_nDocId);
			//}
		}
		break;
	}

	case WM_MDIDESTROY:
	{
		HWND h = (HWND)wParam;
		_RPT1(_CRT_WARN, "WM_MDIDESTROY Destroy Child 0x%p\n", h);
		auto& hist = pMain->m_activationHistory;
		hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());

		if (!hist.empty())
		{
			CMDIChildWndEx* pChild = DYNAMIC_DOWNCAST(CMDIChildWndEx, FromHandle(hist.front()));
			auto ptc = pChild->GetRelatedTabGroup();
			auto tab = ptc->GetTabFromHwnd(hist.front());
			ptc->m_bActivateLastVisibleTab = FALSE;
			ptc->ActivateMDITab(tab);
		}

		//for (auto& f : hist)
		//{
		//	CMDIChildWndEx* pChild = DYNAMIC_DOWNCAST(CMDIChildWndEx, FromHandle(f));
		//	auto ptc = pChild->GetRelatedTabGroup();
		//	auto tab = ptc->GetTabFromHwnd(f);
		//	_RPT1(_CRT_WARN, "Destroy Focus Child 0x%p, index %d, id: %d\n", f, tab, (DYNAMIC_DOWNCAST(CTTDoc, pChild->GetActiveDocument()))->m_nDocId);
		//}

		//return result;

		break;
	}

	case WM_NCDESTROY:
		RemoveWindowSubclass(hwnd, MDIClientProc, uiSubclass);
		break;
	}

	return DefSubclassProc(hwnd, msg, wParam, lParam);
}

Setting the m_bActivateLastVisibleTab flag to FALSE seemed to prevent the flashing issue on my system. Breaking in OnMDIActivate and looking at the window never showed the wrong active tab.

Flaviu_ 1,071 Reputation points

2025-08-04T18:36:22.95+00:00

@RLWA32 Thank you, I can hardly wait to try your solution. I'll let you know.
Flaviu_ 1,071 Reputation points

2025-08-05T17:29:29.6833333+00:00

@RLWA32 Looks very promising, and seems to work correctly :) But let me test it intensively (put more traces, etc.).
Flaviu_ 1,071 Reputation points

2025-08-05T17:37:23.64+00:00

Actually that annoying flash is happen on another tab than last one, but I don't realize which one ...
RLWA32 50,066 Reputation points

2025-08-05T18:28:54.8366667+00:00

Can you give me more detailed feedback so that the issue can be reproduced?

Flaviu_ 1,071

Yes, I can. I feel we are not far away from a solution.

To reproduce this annoying and incorrect flash, just override CChildFrame::OnMDIActivate as follow:

void CChildFrame::OnMDIActivate(BOOL bActivate, CWnd* pActivateWnd, CWnd* pDeactivateWnd)
{
	CMDIChildWndEx::OnMDIActivate(bActivate, pActivateWnd, pDeactivateWnd);
	if (bActivate && pActivateWnd)
		_RPTN(_CRT_WARN, "CChildFrame::OnMDIActivate: %d\n", 
			static_cast<CTTDoc*>(static_cast<CChildFrame*>(pActivateWnd)->GetActiveDocument())->m_nDocId);
	// TODO: Add your message handler code here
	int dummy = 0;	// just to put a break point here
}

On CMainFrame, this is the tested code:

LRESULT CMainFrame::MDIClientProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
									UINT_PTR uiSubclass, DWORD_PTR dwRefData)
{
	auto* pMain = reinterpret_cast<CMainFrame*>(dwRefData);
	switch (uMsg)
	{
	case WM_MDIACTIVATE:
	{
		HWND h = (HWND)wParam;
//		_RPT1(_CRT_WARN, "WM_MDIACTIVATE Child 0x%p\n", h);
		auto& hist = pMain->m_activationHistory;
		if (hist.empty() || h != hist.front())
		{
			hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());
			hist.push_front(h);
		}
		break;
	}
	case WM_MDIDESTROY:
	{
		HWND h = (HWND)wParam;
//		_RPT1(_CRT_WARN, "WM_MDIDESTROY Destroy Child 0x%p\n", h);
		auto& hist = pMain->m_activationHistory;
		hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());
		if (!hist.empty())
		{
			CMDIChildWndEx* pChild = DYNAMIC_DOWNCAST(CMDIChildWndEx, FromHandle(hist.front()));
			auto ptc = pChild->GetRelatedTabGroup();
			auto tab = ptc->GetTabFromHwnd(hist.front());
			ptc->m_bActivateLastVisibleTab = FALSE;
			ptc->ActivateMDITab(tab);
		}
		break;
	}
	case WM_NCDESTROY:
		RemoveWindowSubclass(hWnd, MDIClientProc, uiSubclass);
		break;
	}
	return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}

Then open, let's say 10 tabs, and activate randomly few of them (you might want to list them from CMainFrame::OnHelpListchilds). Then try to close it one by one. At some point, you'll see when CChildFrame::OnMDIActivate is called twice for every ONE closed tab, for instance, having 10 tabs open, when I closed tab 3, I got:

CChildFrame::OnMDIActivate: 9
CChildFrame::OnMDIActivate: 3

When I closed tab 5, I got:

CChildFrame::OnMDIActivate: 9
CChildFrame::OnMDIActivate: 5

And so on ... and this is happen when I have 10 opened tabs and the last one is tab 10, not 9.

P.S. Thank you a lot!!!

RLWA32 50,066 Reputation points

2025-08-08T15:43:04.4966667+00:00

So far I haven't identified the trigger for the extra call to OnMDIActivate. Another issue is that MFC wants to use an internal array of tab information to determine activation but this array is not accessible.
Flaviu_ 1,071 Reputation points

2025-08-10T17:14:46.43+00:00

"So far I haven't identified the trigger for the extra call to OnMDIActivate"
Me neither, I noticed two calls for WM_MDIACTIVATE, which cause that buggy flash.

"Another issue is that MFC wants to use an internal array of tab information to determine activation but this array is not accessible."

I tried myself several trials, none of them worked, and I felt this task get out of my hands, that is the reason why I posted here this issue ...
RLWA32 50,066 Reputation points

2025-08-10T17:18:18.07+00:00

Take a look at the code in my most recent Answer.

Answer 4

@Flaviu_ It seems to me that MFC's MDI Client class handles selecting and activating the next MDI child in its OnMDIDestroy handler.

I didn't see any convenient way to override functions (they weren't virtual) and the data structures that MFC uses to track MDI child windows/tabs just aren't accessible.

So instead of trying to change how MFC activates MDI child windows/tabs I decided to work around the flash problem by letting MFC do its thing while preventing screen updating and then activating the desired MDC child from the z order history. Even though screen updating was prevented MFC still changes the z order so I added some additional code to keep the activation history and the z order in sync.

The next iteration of MDIClientProc -

LRESULT CALLBACK CMainFrame::MDIClientProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
    UINT_PTR uiSubclass, DWORD_PTR dwRefData)
{
    auto* pMain = reinterpret_cast<CMainFrame*>(dwRefData);
    static bool InDestroy = false;

    switch (msg)
    {
    case WM_MDIACTIVATE:
    {
        HWND h = (HWND)wParam;
        _RPT1(_CRT_WARN, "WM_MDIACTIVATE Child 0x%p, InDestroy: %s\n", h, InDestroy ? "true" : "false");
        auto &hist = pMain->m_activationHistory;

        // If Indestroy = true then MFC has changed the z order to bring its choice to the top
        // We're going to activate our own MDI Child so put MFC's choice back in the activation history z order

        if (InDestroy)
        {
            // Find previous window from history to use with SetWindowPos
            for (auto pos = 0; pos < hist.size(); pos++)
            {
                if (h == hist.at(pos))
                {
                    --pos;
                    if (pos >= 0)  // Can't have a negative index into deque
                    {
                        HWND prev = hist.at(pos);
                        ::SetWindowPos(h, prev, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
                    }
                    break;
                }
            }
        }
        else
        {
            // Handle ordinary activation
            if (hist.empty() || h != hist.front())
            {
                hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());
                hist.push_front(h);
            }
        }
        break;
    }

    case WM_MDIDESTROY:
    {
        HWND h = (HWND)wParam;
        InDestroy = true;  // Set flag that a tab has been closed
        _RPT1(_CRT_WARN, "Before: WM_MDIDESTROY Destroy Child 0x%p, InDestroy: %s\n", h, InDestroy ? "true" : "false");
        auto& hist = pMain->m_activationHistory;

        hist.erase(std::remove(hist.begin(), hist.end(), h), hist.end());
        
        if (!hist.empty())
        {
            CMDIChildWndEx* pChild = DYNAMIC_DOWNCAST(CMDIChildWndEx, FromHandle(hist.front()));
            // Let MFC handle the MDI child close but prevent screen updating of the Child activated by MFC
            pMain->SetRedraw(FALSE);
            auto result = DefSubclassProc(hwnd, msg, wParam, lParam);
            // MDI Child was destroyed by DefSubclassProc so reset the flag
            // MDI Child z order was changed by MFC -- handled in WM_MDIACTIVATE
            InDestroy = false;
            _RPT1(_CRT_WARN, "After: WM_MDIDESTROY Destroy Child 0x%p, InDestroy: %s\n", h, InDestroy ? "true" : "false");
            // Active the desired MDI Child from the activation history
            pChild->MDIActivate();
            // Redraw the updated windows
            pMain->SetRedraw(TRUE);
            pMain->RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_UPDATENOW);
            return result;
        }
        else
            InDestroy = false;

        break;
    }

    case WM_NCDESTROY:
        RemoveWindowSubclass(hwnd, MDIClientProc, uiSubclass);
        break;
    }

    return DefSubclassProc(hwnd, msg, wParam, lParam);
}

I also added some code to display the MDI child window z order and also the activation history so you can see that they are synchronized.

void CMainFrame::OnHelpListchilds()
{
    // TODO: Add your command handler code here
    HWND hChild = ::GetWindow(m_hWndMDIClient, GW_CHILD);
    CWnd* pWnd = CWnd::FromHandle(hChild);
    while (pWnd)
    {
        if (pWnd->IsKindOf(RUNTIME_CLASS(CMDIChildWndEx)))
        {
            auto c = static_cast<CMDIChildWndEx*>(pWnd);
            auto ptc = c->GetRelatedTabGroup();
            auto tab = ptc->GetTabFromHwnd(c->GetSafeHwnd());
            CTTDoc* pDoc = static_cast<CTTDoc*>(c->GetActiveDocument());
            _RPTN(_CRT_WARN, "Child: HWND: 0x%p index: %d, id: %d\n", c->GetSafeHwnd(), tab, pDoc->m_nDocId);
        }
        pWnd = pWnd->GetNextWindow();
    }

    for (auto& f : m_activationHistory)
    {
        CMDIChildWndEx* pChild = DYNAMIC_DOWNCAST(CMDIChildWndEx, FromHandle(f));
        auto ptc = pChild->GetRelatedTabGroup();
        auto tab = ptc->GetTabFromHwnd(f);
        _RPT2(_CRT_WARN, "History: Child 0x%p, index: %d, id: %d\n", f, tab, (DYNAMIC_DOWNCAST(CTTDoc, pChild->GetActiveDocument()))->m_nDocId);
    }
}

I look forward to the results of your next round of testing. :)

Flaviu_ 1,071 Reputation points

2025-08-11T13:09:21.9466667+00:00

Interesting approach: to block the painting of entire CMainFrame. Not bad, but this solution get other issues. For instance, when you close the entire app, you'll have a flash with entire main frame. And I don;t know if is the only issue here, while I tested the solution until now, I discovered this flash ... I donlt know if is the only one. P.S. Open 2 tabs, close entire app, no flash. Open 2 tabs, change their focus, and close the app again, you'll see the flash.
RLWA32 50,066 Reputation points

2025-08-11T14:39:33.04+00:00

One brute force method to avoid a flash when closing the app is to handle WM_CLOSE in CMainFrame -

void CMainFrame::OnClose() { // Calling both may be overkill SetRedraw(FALSE); ShowWindow(SW_HIDE); CMDIFrameWndEx::OnClose(); }
RLWA32 50,066 Reputation points

2025-08-12T01:27:03.97+00:00

I think this is a better approach -

void CMainFrame::OnClose() { // Calling both may be overkill RemoveWindowSubclass(m_hWndMDIClient, MDIClientProc, 42); //ShowWindow(SW_HIDE); CMDIFrameWndEx::OnClose(); }
Flaviu_ 1,071 Reputation points

2025-08-12T06:23:30.5833333+00:00

I got the idea, let me test a bit this solution.
RLWA32 50,066 Reputation points

2025-08-12T08:21:18.9333333+00:00

If you remove the subclass and still see flashing at close its not me. :)

Share via

The correct CChildFrame is not activated after the predecessor is closed.

4 answers

Your answer