Logos Bible Software Code Blog

// create the named close splash screen event, making sure we're the first process to create it

SetLastError(ERROR_SUCCESS);

HANDLE hCloseSplashEvent = CreateEvent(NULL, TRUE, FALSE, _T("CloseSplashScreenEvent"));

if (GetLastError() == ERROR_ALREADY_EXISTS)

    ExitProcess(0);

// call LoadSplashImage() etc.

// call SetSplashImage() etc.

// launch the WPF application

HANDLE hProcess = LaunchWpfApplication();

AllowSetForegroundWindow(GetProcessId(hProcess));

// display the splash screen for as long as it's needed

HANDLE aHandles[2] = { hProcess, hCloseSplashEvent };

PumpMsgWaitForMultipleObjects(2, &aHandles[0], INFINITE);

inline DWORD PumpMsgWaitForMultipleObjects(DWORD nCount, LPHANDLE pHandles, DWORD dwMilliseconds)

{

    // useful variables

    const DWORD dwStartTickCount = ::GetTickCount();

    // loop until done

    for (;;)

    {

        // calculate timeout

        const DWORD dwElapsed = GetTickCount() - dwStartTickCount;

        const DWORD dwTimeout = dwMilliseconds == INFINITE ? INFINITE :

            dwElapsed < dwMilliseconds ? dwMilliseconds - dwElapsed : 0;

        // wait for a handle to be signaled or a message

        const DWORD dwWaitResult = MsgWaitForMultipleObjects(nCount, pHandles, FALSE, dwTimeout, QS_ALLINPUT);

        if (dwWaitResult == WAIT_OBJECT_0 + nCount)

        {

            // pump messages

            MSG msg;

            while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) != FALSE)

            {

                // check for WM_QUIT

                if (msg.message == WM_QUIT)

                {

                    // repost quit message and return

                    PostQuitMessage((int) msg.wParam);

                    return WAIT_OBJECT_0 + nCount;

                }

                // dispatch thread message

                TranslateMessage(&msg);

                DispatchMessage(&msg);

            }

        }

        else

        {

            // timeout on actual wait or any other object

            return dwWaitResult;

        }

    }

}

Did you specifically choose the named event over something like WaitForInputIdle()? If you used that, then the C# code wouldn't need to know about the splash screen at all.

I had never actually heard of WaitForInputIdle before. One problem is that it sounds like it is a blocking call, but this thread (that's calling it) needs to pump messages. (One could write a loop that waits for a short time, then pumps any messages, then waits again.)

I think some experimentation is required; it would be rather nice if the C# application didn't have to know about the splash screen.

I just tried using WaitForInputIdle in the following manner: After creating the WPF process, I created a background thread that called WaitForInputIdle(hProcess, INFINITE), then returned. In the main thread, I used PumpMsgWaitForMultipleObjects to wait for the thread handle. (Thus, I was pumping messages while waiting for the WPF application to be idle.)

Unfortunately, WaitForInputIdle returned (and thus the splash screen disappeared) several seconds before my WPF application's UI was visible on the screen. I tried launching several different WPF applications and in every case, the splash screen disappeared too soon; without spending a lot of time debugging the issue, it looks like WaitForInputIdle does not correctly detect if a WPF application has finished initialising and is waiting for input.

I was curious, so I tried several things to see what was going on here. With the following code, I was able to successfully wait for a WPF app to become visible before closing my test launching app.

  // Run it with this code.
  if (WaitForMainWindow(pi.hProcess, hi.dwProcessId))
  {
    PumpMessagesAndWaitForInputIdle(pi.hProcess);
  }
  PostQuitMessage(0);

  // SUPPORTING FUNCTIONS

  // Returns false when it's time to quit.
  bool PumpMessages()
  {
    // pump messages
    MSG msg;
    while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) != FALSE)
    {
      // check for WM_QUIT
      if (msg.message == WM_QUIT)
      {
        return false;
      }
  
      // dispatch thread message
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
  
    return true;
  }
  
  // Returns false when it's time to quit.
  bool PumpMessagesAndWaitForInputIdle(HANDLE hProcess)
  {
    while (WaitForInputIdle(hProcess, 10) == WAIT_TIMEOUT)
    {
      if (!PumpMessages())
      {
        return false;
      }
    }
    return true;
  }
  
  bool FoundWindowHandle;
  BOOL CALLBACK FindMainWindow(HWND hWnd, LPARAM lParam)
  {
    DWORD DesiredProcessId = (DWORD)lParam;
    DWORD testProcessId = NULL;
    if (0 < GetWindowThreadProcessId(hWnd, (LPDWORD)(&testProcessId)))
    {
      if (testProcessId == DesiredProcessId)
      {
        if (0 != IsWindowVisible(hWnd))
        {
          FoundWindowHandle = true;
          return FALSE; // Quit looking.  Found it!
        }
      }
    }
  
    // Keep looking.
    return TRUE;
  }
  
  // Returns false when the app should quit.
  bool WaitForMainWindow(HANDLE hProcess, DWORD processId)
  {
    while (!FoundWindowHandle)
    {
      DWORD exitCode = 0;
      if (0 != GetExitCodeProcess(hProcess, &exitCode))
      {
        if (exitCode != STILL_ACTIVE)
        {
          return false; // We'll never find the main window, the process no longer exists.
        }
      }
  
      if (!PumpMessages())
      {
        return false; // Time to quit.
      }
  
      // Look for the main window for the process we want.
      FoundWindowHandle = false;
      EnumDesktopWindows(NULL, FindMainWindow, processId);
      if (FoundWindowHandle)
      {
        return true;
      }
    }
  
    return true;
  }

My C++ skills are a bit rusty, if possible could you please post the complete project source code.