How do you identify "File Explorer" instances in an `IShellWindows` collection?

user_1889329 0
Viewed 82

I'm trying to get a list of all "File Explorer" instances currently running. It's fairly straight forward getting a list that includes all instances, but I find myself running into a brick wall filtering that list to only "File Explorer" instances.

The following piece of code retrieves all Explorer instances, meaning both "File Explorer" and "Internet Explorer":

#include <comdef.h>
#include <ExDisp.h>
#include <ShlGuid.h>
#include <Windows.h>

#include <cstdio>

using _com_util::CheckError;
using std::puts;

_COM_SMARTPTR_TYPEDEF(IShellWindows, __uuidof(IShellWindows));

int main()
{
    CheckError(::CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE));

    // Acquire IShellWindows interface
    IShellWindowsPtr spShellWindows{};
    CheckError(spShellWindows.CreateInstance(CLSID_ShellWindows, nullptr, CLSCTX_LOCAL_SERVER));

    // Request iterator
    IUnknownPtr spEnum{};
    CheckError(spShellWindows->_NewEnum(&spEnum));
    IEnumVARIANTPtr spEnumVariant{};
    CheckError(spEnum.QueryInterface(__uuidof(spEnumVariant), &spEnumVariant));

    // Iterate over shell windows ...
    while (true) {
        variant_t var{};
        // ... one element at a time
        HRESULT hr = spEnumVariant->Next(1, &var, nullptr);
        CheckError(hr);

        // Iterator depleted?
        if (hr == S_FALSE) break;

        // Did we get the expected `IDispatch` interface?
        if (var.vt != VT_DISPATCH) continue;

        IDispatchPtr spDisp{};
        spDisp.Attach(var.pdispVal, true);

        puts("Got suspect; need ID");

        // That was easy; now on to some real challenges
    }
}

The obvious attempt

My first take at the problem was to just get rid of everything that isn't "File Explorer". Asking for the IWebBrowser2 interface would certainly only get an affirmative response from objects that actually are web browsers. Adding the following to the code above:

_COM_SMARTPTR_TYPEDEF(IWebBrowser2, __uuidof(IWebBrowser2));

// ...

int main()
{
    // ...

        IWebBrowser2Ptr spWebBrowser{};
        hr = spDisp.QueryInterface(__uuidof(spWebBrowser), &spWebBrowser);
        if (SUCCEEDED(hr)) puts("Implements IWebBrowser2");

    // ...

After making the changes and running the code while an "Internet Explorer" instance is running produces the desired output. However, running the code while a "File Explorer" instance is running produces the same output! That's a surprise and a disappointment, all at the same time.

More robust, less useful

Exluding objects that can be identified as "not File Explorer" didn't work out. Let's try to only include objects that can be identified as "File Explorer" instead. That sounds even more obvious, but as we've learned, "obvious" and "not" go hand in hand when it comes to the Windows Shell.

I haven't actually implemented this, but the IShellWindows interface provides an Item method that can return only objects that match a particular ShellWindowTypeConstants (e.g. SWC_EXPLORER or SWC_BROWSER). Or return an object at a particular index in the window collection. But not BOTH!

So, yes, (potentially) more robust, but also less useful as it doesn't meet my requirements as soon as more than one instances of "File Explorer" are running. Bummer.

Circumstantial evidence

While neither of the above led anywhere, I started over and went on a full-blown investigation looking for hints. Since "File Explorer" browses the Shell namespace, there may be something to that account. The following outlines the approach, based on an article by Raymond Chen titled A big little program: Monitoring Internet Explorer and Explorer windows, part 1: Enumeration:

  1. Starting from the IDispatch interface above, ask for a service with ID SID_STopLevelBrowser to get an IShellBrowser interface.
  2. Call IShellBrowser::QueryActiveShellView to get an IShellView interface.
  3. Ask the IShellView whether it implements something Shell-namespace-y, e.g. IPersistIDList.
  4. If it does, conclude that we're holding a reference to a "File Explorer" instance.

This appears to produce the desired result, though it's not clear to me future-proof this is or when it stops working. Leaving aside how overly convoluted this appears, I'm concerned about its reliability.

Question

What's the recommended/robust/reliable way to identify all "File Explorer" instances in an IShellWindows collection? I will favor solutions based on official documentation, though I understand that this is the Windows Shell and there's next to no documentation at all.

windows-shell winapi com c++
1 Answers

Here's a possibility ...

#include <comdef.h>
#include <ExDisp.h>
#include <ShlGuid.h>
#include <Windows.h>

#include <cstdio>
#include <atlbase.h>
#include <string>

using _com_util::CheckError;
using std::puts;
using std::string;

_COM_SMARTPTR_TYPEDEF(IShellWindows, __uuidof(IShellWindows));

//nicked from StackOverflow
std::string ProcessIdToName(DWORD_PTR processId)
{
    std::string ret;
    HANDLE handle = OpenProcess(
        PROCESS_QUERY_LIMITED_INFORMATION,
        FALSE,
        processId /* This is the PID, you can find one from windows task manager */
    );
    if (handle)
    {
        DWORD buffSize = 1024;
        CHAR buffer[1024];
        if (QueryFullProcessImageNameA(handle, 0, buffer, &buffSize))
        {
            ret = buffer;
        }
        else
        {
            printf("Error GetModuleBaseNameA : %lu", GetLastError());
        }
        CloseHandle(handle);
    }
    else
    {
        printf("Error OpenProcess : %lu", GetLastError());
    }
    return ret;
}

int main()
{
    CheckError(::CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE));

    // Acquire IShellWindows interface
    IShellWindowsPtr spShellWindows{};
    CheckError(spShellWindows.CreateInstance(CLSID_ShellWindows, nullptr, CLSCTX_LOCAL_SERVER));

    // Request iterator
    IUnknownPtr spEnum{};
    CheckError(spShellWindows->_NewEnum(&spEnum));
    IEnumVARIANTPtr spEnumVariant{};
    CheckError(spEnum.QueryInterface(__uuidof(spEnumVariant), &spEnumVariant));

    // Iterate over shell windows ...
    while (true) {
        variant_t var{};
        // ... one element at a time
        HRESULT hr = spEnumVariant->Next(1, &var, nullptr);
        CheckError(hr);

        // Iterator depleted?
        if (hr == S_FALSE) break;

        // Did we get the expected `IDispatch` interface?
        if (var.vt != VT_DISPATCH) continue;

        IDispatchPtr spDisp{};
        spDisp.Attach(var.pdispVal, true);

        puts("Got suspect; need ID");

        // That was easy; now on to some real challenges

        CComPtr<IWebBrowser2> lpWB;
        spDisp->QueryInterface(&lpWB);
        SHANDLE_PTR hWnd{ 0 };
        lpWB->get_HWND(&hWnd);

        if (hWnd)
        {
            DWORD pid = 0;
            GetWindowThreadProcessId((HWND)hWnd, &pid);

            if (pid != 0)
            {
                puts("pid");
                auto s = ProcessIdToName((DWORD_PTR)pid);
                puts(s.c_str());
            }
        }
    }
}
user_11813530
Related