Windows COM & Shell Development: Advanced Component Programming#

Introduction#

Component Object Model (COM) is the foundation of Windows component programming, providing a binary standard for creating reusable software components. Combined with Windows Shell programming, COM enables deep integration with the Windows operating system, creating powerful extensions and system-level applications.

COM & Shell Technologies#

🔌 COM Interfaces: IUnknown, IClassFactory, IDispatch
🏠 Shell Extensions: Context menus, property sheets, icon handlers
📋 OLE Automation: IDispatch-based scripting interfaces
🎨 ActiveX Controls: Reusable UI components
🔄 Shell Integration: File type handlers, protocol handlers
📁 Namespace Extensions: Custom folder implementations
🎯 Shell Services: Background tasks, system tray integration

COM Architecture#

1
graph TB
2
    subgraph "COM Architecture"
3
        Client[Client Application] --> Proxy[COM Proxy]
4
        Proxy --> SCM[Service Control Manager]
5
        SCM --> Server[COM Server]
6

7
        subgraph "COM Interfaces"
8
            IUnknown[IUnknown]
9
            IClassFactory[IClassFactory]
10
            IDispatch[IDispatch]
11
            Custom[Custom Interfaces]
12
        end
13

14
        subgraph "Shell Integration"
15
            Shell[Windows Shell] --> ShellExt[Shell Extensions]
16
            ShellExt --> ContextMenu[Context Menu]
17
            ShellExt --> PropSheet[Property Sheet]
18
            ShellExt --> IconHandler[Icon Handler]
19
        end
20

21
        subgraph "OLE Services"
22
            OLE[OLE Compound Documents]
23
            Automation[OLE Automation]
24
            ActiveX[ActiveX Controls]
25
        end
26
    end

Core COM Programming#

1. Basic COM Interface Implementation#

1
// Basic COM interface implementation
2
#include <windows.h>
3
#include <unknwn.h>
4
#include <objbase.h>
5

6
// Custom interface definition
7
interface ICalculator : public IUnknown {
8
    virtual HRESULT STDMETHODCALLTYPE Add(double a, double b, double* result) = 0;
9
    virtual HRESULT STDMETHODCALLTYPE Subtract(double a, double b, double* result) = 0;
10
    virtual HRESULT STDMETHODCALLTYPE Multiply(double a, double b, double* result) = 0;
11
    virtual HRESULT STDMETHODCALLTYPE Divide(double a, double b, double* result) = 0;
12
};
13

14
// {12345678-1234-5678-9012-123456789012}
15
static const CLSID CLSID_Calculator =
16
{ 0x12345678, 0x1234, 0x5678, { 0x90, 0x12, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12 } };
17

18
// COM component implementation
19
class Calculator : public ICalculator {
20
private:
21
    ULONG m_refCount;
22

23
public:
24
    Calculator() : m_refCount(1) {
25
        InterlockedIncrement(&g_serverLockCount);
26
    }
27

28
    virtual ~Calculator() {
29
        InterlockedDecrement(&g_serverLockCount);
30
    }
31

32
    // IUnknown implementation
33
    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject) override {
34
        if (!ppvObject) return E_INVALIDARG;
35

36
        *ppvObject = nullptr;
37

38
        if (IsEqualIID(riid, IID_IUnknown)) {
39
            *ppvObject = static_cast<IUnknown*>(this);
40
        }
41
        else if (IsEqualIID(riid, __uuidof(ICalculator))) {
42
            *ppvObject = static_cast<ICalculator*>(this);
43
        }
44
        else {
45
            return E_NOINTERFACE;
46
        }
47

48
        AddRef();
49
        return S_OK;
50
    }
51

52
    ULONG STDMETHODCALLTYPE AddRef() override {
53
        return InterlockedIncrement(&m_refCount);
54
    }
55

56
    ULONG STDMETHODCALLTYPE Release() override {
57
        ULONG count = InterlockedDecrement(&m_refCount);
58
        if (count == 0) {
59
            delete this;
60
        }
61
        return count;
62
    }
63

64
    // ICalculator implementation
65
    HRESULT STDMETHODCALLTYPE Add(double a, double b, double* result) override {
66
        if (!result) return E_INVALIDARG;
67
        *result = a + b;
68
        return S_OK;
69
    }
70

71
    HRESULT STDMETHODCALLTYPE Subtract(double a, double b, double* result) override {
72
        if (!result) return E_INVALIDARG;
73
        *result = a - b;
74
        return S_OK;
75
    }
76

77
    HRESULT STDMETHODCALLTYPE Multiply(double a, double b, double* result) override {
78
        if (!result) return E_INVALIDARG;
79
        *result = a * b;
80
        return S_OK;
81
    }
82

83
    HRESULT STDMETHODCALLTYPE Divide(double a, double b, double* result) override {
84
        if (!result) return E_INVALIDARG;
85
        if (b == 0) return DISP_E_DIVBYZERO;
86
        *result = a / b;
87
        return S_OK;
88
    }
89
};
90

91
// Class factory implementation
92
class CalculatorFactory : public IClassFactory {
93
private:
94
    ULONG m_refCount;
95

96
public:
97
    CalculatorFactory() : m_refCount(1) {
98
        InterlockedIncrement(&g_serverLockCount);
99
    }
100

101
    virtual ~CalculatorFactory() {
102
        InterlockedDecrement(&g_serverLockCount);
103
    }
104

105
    // IUnknown implementation
106
    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject) override {
107
        if (!ppvObject) return E_INVALIDARG;
108

109
        *ppvObject = nullptr;
110

111
        if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IClassFactory)) {
112
            *ppvObject = static_cast<IClassFactory*>(this);
113
            AddRef();
114
            return S_OK;
115
        }
116

117
        return E_NOINTERFACE;
118
    }
119

120
    ULONG STDMETHODCALLTYPE AddRef() override {
121
        return InterlockedIncrement(&m_refCount);
122
    }
123

124
    ULONG STDMETHODCALLTYPE Release() override {
125
        ULONG count = InterlockedDecrement(&m_refCount);
126
        if (count == 0) {
127
            delete this;
128
        }
129
        return count;
130
    }
131

132
    // IClassFactory implementation
133
    HRESULT STDMETHODCALLTYPE CreateInstance(IUnknown* pUnkOuter, REFIID riid,
134
                                           void** ppvObject) override {
135
        if (pUnkOuter) return CLASS_E_NOAGGREGATION;
136
        if (!ppvObject) return E_INVALIDARG;
137

138
        *ppvObject = nullptr;
139

140
        Calculator* calculator = new Calculator();
141
        if (!calculator) return E_OUTOFMEMORY;
142

143
        HRESULT hr = calculator->QueryInterface(riid, ppvObject);
144
        calculator->Release();
145

146
        return hr;
147
    }
148

149
    HRESULT STDMETHODCALLTYPE LockServer(BOOL fLock) override {
150
        if (fLock) {
151
            InterlockedIncrement(&g_serverLockCount);
152
        } else {
153
            InterlockedDecrement(&g_serverLockCount);
154
        }
155
        return S_OK;
156
    }
157
};
158

159
// Global server lock count
160
LONG g_serverLockCount = 0;
161

162
// DLL exports for COM registration
163
extern "C" HRESULT STDAPICALLTYPE DllCanUnloadNow() {
164
    return (g_serverLockCount == 0) ? S_OK : S_FALSE;
165
}
166

167
extern "C" HRESULT STDAPICALLTYPE DllGetClassObject(REFCLSID rclsid, REFIID riid,
168
                                                   void** ppvObject) {
169
    if (!ppvObject) return E_INVALIDARG;
170

171
    *ppvObject = nullptr;
172

173
    if (IsEqualCLSID(rclsid, CLSID_Calculator)) {
174
        CalculatorFactory* factory = new CalculatorFactory();
175
        if (!factory) return E_OUTOFMEMORY;
176

177
        HRESULT hr = factory->QueryInterface(riid, ppvObject);
178
        factory->Release();
179

180
        return hr;
181
    }
182

183
    return CLASS_E_CLASSNOTAVAILABLE;
184
}

2. Advanced COM Patterns#

1
// COM smart pointer wrapper
2
template<typename T>
3
class COMPtr {
4
private:
5
    T* m_ptr;
6

7
public:
8
    COMPtr() : m_ptr(nullptr) {}
9

10
    COMPtr(T* ptr) : m_ptr(ptr) {
11
        if (m_ptr) m_ptr->AddRef();
12
    }
13

14
    COMPtr(const COMPtr& other) : m_ptr(other.m_ptr) {
15
        if (m_ptr) m_ptr->AddRef();
16
    }
17

18
    ~COMPtr() {
19
        if (m_ptr) m_ptr->Release();
20
    }
21

22
    COMPtr& operator=(T* ptr) {
23
        if (m_ptr != ptr) {
24
            if (m_ptr) m_ptr->Release();
25
            m_ptr = ptr;
26
            if (m_ptr) m_ptr->AddRef();
27
        }
28
        return *this;
29
    }
30

31
    COMPtr& operator=(const COMPtr& other) {
32
        return *this = other.m_ptr;
33
    }
34

35
    T* operator->() const { return m_ptr; }
36
    T& operator*() const { return *m_ptr; }
37
    operator T*() const { return m_ptr; }
38

39
    T** GetAddressOf() {
40
        return &m_ptr;
41
    }
42

43
    void Reset() {
44
        if (m_ptr) {
45
            m_ptr->Release();
46
            m_ptr = nullptr;
47
        }
48
    }
49

50
    T* Detach() {
51
        T* ptr = m_ptr;
52
        m_ptr = nullptr;
53
        return ptr;
54
    }
55

56
    HRESULT CoCreateInstance(REFCLSID rclsid, IUnknown* pUnkOuter = nullptr,
57
                            DWORD dwClsContext = CLSCTX_INPROC_SERVER) {
58
        Reset();
59
        return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext,
60
                                __uuidof(T), reinterpret_cast<void**>(&m_ptr));
61
    }
62

63
    template<typename Q>
64
    HRESULT QueryInterface(Q** ppvObject) {
65
        return m_ptr ? m_ptr->QueryInterface(__uuidof(Q),
66
                                           reinterpret_cast<void**>(ppvObject)) : E_NOINTERFACE;
67
    }
68
};
69

70
// Connection point implementation for events
71
template<typename EventInterface>
72
class ConnectionPointImpl : public IConnectionPoint {
73
private:
74
    IUnknown* m_pUnkOuter;
75
    std::vector<COMPtr<EventInterface>> m_connections;
76
    DWORD m_nextCookie;
77

78
public:
79
    ConnectionPointImpl(IUnknown* pUnkOuter)
80
        : m_pUnkOuter(pUnkOuter), m_nextCookie(1) {}
81

82
    // IUnknown implementation (delegate to outer)
83
    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject) override {
84
        return m_pUnkOuter->QueryInterface(riid, ppvObject);
85
    }
86

87
    ULONG STDMETHODCALLTYPE AddRef() override {
88
        return m_pUnkOuter->AddRef();
89
    }
90

91
    ULONG STDMETHODCALLTYPE Release() override {
92
        return m_pUnkOuter->Release();
93
    }
94

95
    // IConnectionPoint implementation
96
    HRESULT STDMETHODCALLTYPE GetConnectionInterface(IID* pIID) override {
97
        if (!pIID) return E_POINTER;
98
        *pIID = __uuidof(EventInterface);
99
        return S_OK;
100
    }
101

102
    HRESULT STDMETHODCALLTYPE GetConnectionPointContainer(
103
        IConnectionPointContainer** ppCPC) override {
104
        if (!ppCPC) return E_POINTER;
105
        return m_pUnkOuter->QueryInterface(IID_IConnectionPointContainer,
106
                                         reinterpret_cast<void**>(ppCPC));
107
    }
108

109
    HRESULT STDMETHODCALLTYPE Advise(IUnknown* pUnkSink, DWORD* pdwCookie) override {
110
        if (!pUnkSink || !pdwCookie) return E_POINTER;
111

112
        COMPtr<EventInterface> sink;
113
        HRESULT hr = pUnkSink->QueryInterface(__uuidof(EventInterface),
114
                                            reinterpret_cast<void**>(&sink));
115
        if (FAILED(hr)) return hr;
116

117
        m_connections.push_back(sink);
118
        *pdwCookie = m_nextCookie++;
119

120
        return S_OK;
121
    }
122

123
    HRESULT STDMETHODCALLTYPE Unadvise(DWORD dwCookie) override {
124
        // Find and remove connection by cookie
125
        auto it = std::find_if(m_connections.begin(), m_connections.end(),
126
            [dwCookie](const COMPtr<EventInterface>& conn) {
127
                // Implementation depends on how you store cookies
128
                return false; // Simplified for example
129
            });
130

131
        if (it != m_connections.end()) {
132
            m_connections.erase(it);
133
            return S_OK;
134
        }
135

136
        return CONNECT_E_NOCONNECTION;
137
    }
138

139
    HRESULT STDMETHODCALLTYPE EnumConnections(IEnumConnections** ppEnum) override {
140
        // Implementation for connection enumeration
141
        return E_NOTIMPL;
142
    }
143

144
    // Fire events to all connected sinks
145
    template<typename... Args>
146
    void FireEvent(HRESULT(STDMETHODCALLTYPE EventInterface::*method)(Args...),
147
                   Args... args) {
148
        for (auto& sink : m_connections) {
149
            if (sink) {
150
                (sink.get()->*method)(args...);
151
            }
152
        }
153
    }
154
};

Shell Extension Development#

1
// Context menu shell extension
2
#include <shlobj.h>
3
#include <shlwapi.h>
4

5
class ContextMenuExtension : public IShellExtInit, public IContextMenu {
6
private:
7
    ULONG m_refCount;
8
    std::vector<std::wstring> m_selectedFiles;
9

10
public:
11
    ContextMenuExtension() : m_refCount(1) {}
12

13
    virtual ~ContextMenuExtension() {}
14

15
    // IUnknown implementation
16
    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject) override {
17
        if (!ppvObject) return E_INVALIDARG;
18

19
        *ppvObject = nullptr;
20

21
        if (IsEqualIID(riid, IID_IUnknown)) {
22
            *ppvObject = static_cast<IUnknown*>(static_cast<IShellExtInit*>(this));
23
        }
24
        else if (IsEqualIID(riid, IID_IShellExtInit)) {
25
            *ppvObject = static_cast<IShellExtInit*>(this);
26
        }
27
        else if (IsEqualIID(riid, IID_IContextMenu)) {
28
            *ppvObject = static_cast<IContextMenu*>(this);
29
        }
30
        else {
31
            return E_NOINTERFACE;
32
        }
33

34
        AddRef();
35
        return S_OK;
36
    }
37

38
    ULONG STDMETHODCALLTYPE AddRef() override {
39
        return InterlockedIncrement(&m_refCount);
40
    }
41

42
    ULONG STDMETHODCALLTYPE Release() override {
43
        ULONG count = InterlockedDecrement(&m_refCount);
44
        if (count == 0) {
45
            delete this;
46
        }
47
        return count;
48
    }
49

50
    // IShellExtInit implementation
51
    HRESULT STDMETHODCALLTYPE Initialize(LPCITEMIDLIST pidlFolder,
52
                                       IDataObject* pDataObj,
53
                                       HKEY hkeyProgID) override {
54
        if (!pDataObj) return E_INVALIDARG;
55

56
        m_selectedFiles.clear();
57

58
        // Get selected files from data object
59
        FORMATETC fmt = { CF_HDROP, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
60
        STGMEDIUM stg = {};
61

62
        if (SUCCEEDED(pDataObj->GetData(&fmt, &stg))) {
63
            HDROP hDrop = static_cast<HDROP>(stg.hGlobal);
64
            UINT fileCount = DragQueryFileW(hDrop, 0xFFFFFFFF, nullptr, 0);
65

66
            for (UINT i = 0; i < fileCount; i++) {
67
                wchar_t filePath[MAX_PATH];
68
                if (DragQueryFileW(hDrop, i, filePath, MAX_PATH)) {
69
                    m_selectedFiles.push_back(filePath);
70
                }
71
            }
72

73
            ReleaseStgMedium(&stg);
74
        }
75

76
        return S_OK;
77
    }
78

79
    // IContextMenu implementation
80
    HRESULT STDMETHODCALLTYPE QueryContextMenu(HMENU hMenu, UINT indexMenu,
81
                                              UINT idCmdFirst, UINT idCmdLast,
82
                                              UINT uFlags) override {
83
        if (!(uFlags & CMF_DEFAULTONLY)) {
84
            // Add custom menu items
85
            InsertMenuW(hMenu, indexMenu++, MF_STRING | MF_BYPOSITION,
86
                       idCmdFirst + 0, L"Custom Action 1");
87
            InsertMenuW(hMenu, indexMenu++, MF_STRING | MF_BYPOSITION,
88
                       idCmdFirst + 1, L"Custom Action 2");
89
            InsertMenuW(hMenu, indexMenu++, MF_SEPARATOR | MF_BYPOSITION,
90
                       0, nullptr);
91

92
            return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, 2);
93
        }
94

95
        return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, 0);
96
    }
97

98
    HRESULT STDMETHODCALLTYPE InvokeCommand(LPCMINVOKECOMMANDINFO pici) override {
99
        BOOL fUnicode = FALSE;
100

101
        if (pici->cbSize == sizeof(CMINVOKECOMMANDINFOEX)) {
102
            fUnicode = (pici->fMask & CMIC_MASK_UNICODE) != 0;
103
        }
104

105
        UINT command;
106
        if (fUnicode) {
107
            LPCMINVOKECOMMANDINFOEX picix = (LPCMINVOKECOMMANDINFOEX)pici;
108
            command = HIWORD(picix->lpVerbW) ? 0 : LOWORD(picix->lpVerbW);
109
        } else {
110
            command = HIWORD(pici->lpVerb) ? 0 : LOWORD(pici->lpVerb);
111
        }
112

113
        switch (command) {
114
            case 0:
115
                // Execute custom action 1
116
                ExecuteCustomAction1();
117
                break;
118
            case 1:
119
                // Execute custom action 2
120
                ExecuteCustomAction2();
121
                break;
122
            default:
123
                return E_INVALIDARG;
124
        }
125

126
        return S_OK;
127
    }
128

129
    HRESULT STDMETHODCALLTYPE GetCommandString(UINT_PTR idCmd, UINT uType,
130
                                             UINT* pReserved, LPSTR pszName,
131
                                             UINT cchMax) override {
132
        if (uType == GCS_HELPTEXTW) {
133
            switch (idCmd) {
134
                case 0:
135
                    wcscpy_s(reinterpret_cast<LPWSTR>(pszName), cchMax,
136
                            L"Help text for custom action 1");
137
                    return S_OK;
138
                case 1:
139
                    wcscpy_s(reinterpret_cast<LPWSTR>(pszName), cchMax,
140
                            L"Help text for custom action 2");
141
                    return S_OK;
142
            }
143
        }
144

145
        return E_INVALIDARG;
146
    }
147

148
private:
149
    void ExecuteCustomAction1() {
150
        // Implementation for custom action 1
151
        MessageBoxW(nullptr, L"Custom Action 1 executed!", L"Shell Extension", MB_OK);
152
    }
153

154
    void ExecuteCustomAction2() {
155
        // Implementation for custom action 2
156
        for (const auto& file : m_selectedFiles) {
157
            // Process each selected file
158
            std::wstring message = L"Processing: " + file;
159
            MessageBoxW(nullptr, message.c_str(), L"Shell Extension", MB_OK);
160
        }
161
    }
162
};

2. Property Sheet Shell Extension#

1
// Property sheet shell extension
2
class PropertySheetExtension : public IShellExtInit, public IShellPropSheetExt {
3
private:
4
    ULONG m_refCount;
5
    std::wstring m_selectedFile;
6

7
    // Property page dialog procedure
8
    static INT_PTR CALLBACK PropPageDlgProc(HWND hDlg, UINT message,
9
                                           WPARAM wParam, LPARAM lParam) {
10
        PropertySheetExtension* pThis = nullptr;
11

12
        if (message == WM_INITDIALOG) {
13
            PROPSHEETPAGEW* psp = reinterpret_cast<PROPSHEETPAGEW*>(lParam);
14
            pThis = reinterpret_cast<PropertySheetExtension*>(psp->lParam);
15
            SetWindowLongPtrW(hDlg, DWLP_USER, reinterpret_cast<LONG_PTR>(pThis));
16

17
            // Initialize dialog with file information
18
            pThis->InitializePropertyPage(hDlg);
19
        } else {
20
            pThis = reinterpret_cast<PropertySheetExtension*>(
21
                GetWindowLongPtrW(hDlg, DWLP_USER)
22
            );
23
        }
24

25
        if (pThis) {
26
            return pThis->HandlePropertyPageMessage(hDlg, message, wParam, lParam);
27
        }
28

29
        return FALSE;
30
    }
31

32
public:
33
    PropertySheetExtension() : m_refCount(1) {}
34

35
    virtual ~PropertySheetExtension() {}
36

37
    // IUnknown implementation
38
    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject) override {
39
        if (!ppvObject) return E_INVALIDARG;
40

41
        *ppvObject = nullptr;
42

43
        if (IsEqualIID(riid, IID_IUnknown)) {
44
            *ppvObject = static_cast<IUnknown*>(static_cast<IShellExtInit*>(this));
45
        }
46
        else if (IsEqualIID(riid, IID_IShellExtInit)) {
47
            *ppvObject = static_cast<IShellExtInit*>(this);
48
        }
49
        else if (IsEqualIID(riid, IID_IShellPropSheetExt)) {
50
            *ppvObject = static_cast<IShellPropSheetExt*>(this);
51
        }
52
        else {
53
            return E_NOINTERFACE;
54
        }
55

56
        AddRef();
57
        return S_OK;
58
    }
59

60
    ULONG STDMETHODCALLTYPE AddRef() override {
61
        return InterlockedIncrement(&m_refCount);
62
    }
63

64
    ULONG STDMETHODCALLTYPE Release() override {
65
        ULONG count = InterlockedDecrement(&m_refCount);
66
        if (count == 0) {
67
            delete this;
68
        }
69
        return count;
70
    }
71

72
    // IShellExtInit implementation
73
    HRESULT STDMETHODCALLTYPE Initialize(LPCITEMIDLIST pidlFolder,
74
                                       IDataObject* pDataObj,
75
                                       HKEY hkeyProgID) override {
76
        if (!pDataObj) return E_INVALIDARG;
77

78
        // Get selected file
79
        FORMATETC fmt = { CF_HDROP, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
80
        STGMEDIUM stg = {};
81

82
        if (SUCCEEDED(pDataObj->GetData(&fmt, &stg))) {
83
            HDROP hDrop = static_cast<HDROP>(stg.hGlobal);
84
            wchar_t filePath[MAX_PATH];
85

86
            if (DragQueryFileW(hDrop, 0, filePath, MAX_PATH)) {
87
                m_selectedFile = filePath;
88
            }
89

90
            ReleaseStgMedium(&stg);
91
        }
92

93
        return S_OK;
94
    }
95

96
    // IShellPropSheetExt implementation
97
    HRESULT STDMETHODCALLTYPE AddPages(LPFNSVADDPROPSHEETPAGE pfnAddPage,
98
                                     LPARAM lParam) override {
99
        // Create property page
100
        PROPSHEETPAGEW psp = {};
101
        psp.dwSize = sizeof(psp);
102
        psp.dwFlags = PSP_USEREFPARENT | PSP_USETITLE;
103
        psp.hInstance = GetModuleHandle(nullptr);
104
        psp.pszTemplate = MAKEINTRESOURCEW(IDD_PROPPAGE);
105
        psp.pfnDlgProc = PropPageDlgProc;
106
        psp.pszTitle = L"Custom Properties";
107
        psp.lParam = reinterpret_cast<LPARAM>(this);
108
        psp.pcRefParent = &m_refCount;
109

110
        HPROPSHEETPAGE hPage = CreatePropertySheetPageW(&psp);
111
        if (hPage) {
112
            if (pfnAddPage(hPage, lParam)) {
113
                AddRef(); // Page holds a reference
114
                return S_OK;
115
            } else {
116
                DestroyPropertySheetPage(hPage);
117
            }
118
        }
119

120
        return E_FAIL;
121
    }
122

123
    HRESULT STDMETHODCALLTYPE ReplacePage(EXPPS uPageID,
124
                                        LPFNSVADDPROPSHEETPAGE pfnReplaceWith,
125
                                        LPARAM lParam) override {
126
        return E_NOTIMPL;
127
    }
128

129
private:
130
    void InitializePropertyPage(HWND hDlg) {
131
        // Set file name
132
        SetDlgItemTextW(hDlg, IDC_FILENAME, m_selectedFile.c_str());
133

134
        // Get file attributes
135
        DWORD attributes = GetFileAttributesW(m_selectedFile.c_str());
136
        if (attributes != INVALID_FILE_ATTRIBUTES) {
137
            CheckDlgButton(hDlg, IDC_READONLY,
138
                          (attributes & FILE_ATTRIBUTE_READONLY) ? BST_CHECKED : BST_UNCHECKED);
139
            CheckDlgButton(hDlg, IDC_HIDDEN,
140
                          (attributes & FILE_ATTRIBUTE_HIDDEN) ? BST_CHECKED : BST_UNCHECKED);
141
            CheckDlgButton(hDlg, IDC_SYSTEM,
142
                          (attributes & FILE_ATTRIBUTE_SYSTEM) ? BST_CHECKED : BST_UNCHECKED);
143
        }
144

145
        // Get file size
146
        WIN32_FILE_ATTRIBUTE_DATA fileData;
147
        if (GetFileAttributesExW(m_selectedFile.c_str(), GetFileExInfoStandard, &fileData)) {
148
            LARGE_INTEGER size;
149
            size.LowPart = fileData.nFileSizeLow;
150
            size.HighPart = fileData.nFileSizeHigh;
151

152
            wchar_t sizeText[64];
153
            swprintf_s(sizeText, L"%lld bytes", size.QuadPart);
154
            SetDlgItemTextW(hDlg, IDC_FILESIZE, sizeText);
155
        }
156
    }
157

158
    INT_PTR HandlePropertyPageMessage(HWND hDlg, UINT message,
159
                                     WPARAM wParam, LPARAM lParam) {
160
        switch (message) {
161
            case WM_COMMAND:
162
                if (HIWORD(wParam) == BN_CLICKED) {
163
                    // Enable Apply button when checkboxes change
164
                    PropSheet_Changed(GetParent(hDlg), hDlg);
165
                }
166
                break;
167

168
            case WM_NOTIFY:
169
                {
170
                    LPNMHDR pnmh = reinterpret_cast<LPNMHDR>(lParam);
171
                    if (pnmh->code == PSN_APPLY) {
172
                        // Apply changes
173
                        ApplyChanges(hDlg);
174
                        return PSNRET_NOERROR;
175
                    }
176
                }
177
                break;
178

179
            case WM_DESTROY:
180
                // Clean up
181
                Release();
182
                break;
183
        }
184

185
        return FALSE;
186
    }
187

188
    void ApplyChanges(HWND hDlg) {
189
        DWORD attributes = GetFileAttributesW(m_selectedFile.c_str());
190
        if (attributes == INVALID_FILE_ATTRIBUTES) return;
191

192
        // Update attributes based on checkbox states
193
        if (IsDlgButtonChecked(hDlg, IDC_READONLY)) {
194
            attributes |= FILE_ATTRIBUTE_READONLY;
195
        } else {
196
            attributes &= ~FILE_ATTRIBUTE_READONLY;
197
        }
198

199
        if (IsDlgButtonChecked(hDlg, IDC_HIDDEN)) {
200
            attributes |= FILE_ATTRIBUTE_HIDDEN;
201
        } else {
202
            attributes &= ~FILE_ATTRIBUTE_HIDDEN;
203
        }
204

205
        if (IsDlgButtonChecked(hDlg, IDC_SYSTEM)) {
206
            attributes |= FILE_ATTRIBUTE_SYSTEM;
207
        } else {
208
            attributes &= ~FILE_ATTRIBUTE_SYSTEM;
209
        }
210

211
        SetFileAttributesW(m_selectedFile.c_str(), attributes);
212
    }
213
};

3. Icon Handler Shell Extension#

1
// Icon handler shell extension
2
class IconHandlerExtension : public IShellExtInit, public IExtractIconW {
3
private:
4
    ULONG m_refCount;
5
    std::wstring m_filePath;
6

7
public:
8
    IconHandlerExtension() : m_refCount(1) {}
9

10
    virtual ~IconHandlerExtension() {}
11

12
    // IUnknown implementation
13
    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject) override {
14
        if (!ppvObject) return E_INVALIDARG;
15

16
        *ppvObject = nullptr;
17

18
        if (IsEqualIID(riid, IID_IUnknown)) {
19
            *ppvObject = static_cast<IUnknown*>(static_cast<IShellExtInit*>(this));
20
        }
21
        else if (IsEqualIID(riid, IID_IShellExtInit)) {
22
            *ppvObject = static_cast<IShellExtInit*>(this);
23
        }
24
        else if (IsEqualIID(riid, IID_IExtractIconW)) {
25
            *ppvObject = static_cast<IExtractIconW*>(this);
26
        }
27
        else {
28
            return E_NOINTERFACE;
29
        }
30

31
        AddRef();
32
        return S_OK;
33
    }
34

35
    ULONG STDMETHODCALLTYPE AddRef() override {
36
        return InterlockedIncrement(&m_refCount);
37
    }
38

39
    ULONG STDMETHODCALLTYPE Release() override {
40
        ULONG count = InterlockedDecrement(&m_refCount);
41
        if (count == 0) {
42
            delete this;
43
        }
44
        return count;
45
    }
46

47
    // IShellExtInit implementation
48
    HRESULT STDMETHODCALLTYPE Initialize(LPCITEMIDLIST pidlFolder,
49
                                       IDataObject* pDataObj,
50
                                       HKEY hkeyProgID) override {
51
        if (!pDataObj) return E_INVALIDARG;
52

53
        // Get file path
54
        FORMATETC fmt = { CF_HDROP, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
55
        STGMEDIUM stg = {};
56

57
        if (SUCCEEDED(pDataObj->GetData(&fmt, &stg))) {
58
            HDROP hDrop = static_cast<HDROP>(stg.hGlobal);
59
            wchar_t filePath[MAX_PATH];
60

61
            if (DragQueryFileW(hDrop, 0, filePath, MAX_PATH)) {
62
                m_filePath = filePath;
63
            }
64

65
            ReleaseStgMedium(&stg);
66
        }
67

68
        return S_OK;
69
    }
70

71
    // IExtractIconW implementation
72
    HRESULT STDMETHODCALLTYPE GetIconLocation(UINT uFlags, LPWSTR pszIconFile,
73
                                            UINT cchMax, int* piIndex,
74
                                            UINT* pwFlags) override {
75
        // Check if we should provide a custom icon
76
        if (ShouldProvideCustomIcon()) {
77
            // Return path to our icon file
78
            wcscpy_s(pszIconFile, cchMax, L"C:\\Path\\To\\CustomIcon.ico");
79
            *piIndex = 0;
80
            *pwFlags = GIL_PERINSTANCE | GIL_DONTCACHE;
81
            return S_OK;
82
        }
83

84
        // Let shell use default icon
85
        return S_FALSE;
86
    }
87

88
    HRESULT STDMETHODCALLTYPE Extract(LPCWSTR pszFile, UINT nIconIndex,
89
                                    HICON* phiconLarge, HICON* phiconSmall,
90
                                    UINT nIconSize) override {
91
        // Generate custom icon dynamically
92
        if (ShouldProvideCustomIcon()) {
93
            *phiconLarge = CreateCustomIcon(HIWORD(nIconSize));
94
            *phiconSmall = CreateCustomIcon(LOWORD(nIconSize));
95

96
            if (*phiconLarge || *phiconSmall) {
97
                return S_OK;
98
            }
99
        }
100

101
        return S_FALSE;
102
    }
103

104
private:
105
    bool ShouldProvideCustomIcon() {
106
        // Logic to determine if we should provide custom icon
107
        // For example, based on file extension or content
108
        std::wstring extension = std::filesystem::path(m_filePath).extension().wstring();
109
        return _wcsicmp(extension.c_str(), L".custom") == 0;
110
    }
111

112
    HICON CreateCustomIcon(int size) {
113
        // Create a simple colored square icon
114
        HDC hdcScreen = GetDC(nullptr);
115
        HDC hdcMem = CreateCompatibleDC(hdcScreen);
116

117
        HBITMAP hBitmap = CreateCompatibleBitmap(hdcScreen, size, size);
118
        HBITMAP hOldBitmap = static_cast<HBITMAP>(SelectObject(hdcMem, hBitmap));
119

120
        // Draw custom icon content
121
        RECT rect = { 0, 0, size, size };
122
        HBRUSH hBrush = CreateSolidBrush(RGB(0, 128, 255));
123
        FillRect(hdcMem, &rect, hBrush);
124
        DeleteObject(hBrush);
125

126
        // Draw some text or pattern
127
        SetTextColor(hdcMem, RGB(255, 255, 255));
128
        SetBkMode(hdcMem, TRANSPARENT);
129
        DrawTextW(hdcMem, L"C", -1, &rect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
130

131
        SelectObject(hdcMem, hOldBitmap);
132
        DeleteDC(hdcMem);
133
        ReleaseDC(nullptr, hdcScreen);
134

135
        // Create icon from bitmap
136
        ICONINFO iconInfo = {};
137
        iconInfo.fIcon = TRUE;
138
        iconInfo.hbmColor = hBitmap;
139
        iconInfo.hbmMask = hBitmap;
140

141
        HICON hIcon = CreateIconIndirect(&iconInfo);
142
        DeleteObject(hBitmap);
143

144
        return hIcon;
145
    }
146
};

OLE Automation#

1. IDispatch Implementation#

1
// OLE Automation object with IDispatch
2
class AutomationObject : public IDispatch {
3
private:
4
    ULONG m_refCount;
5
    ITypeInfo* m_pTypeInfo;
6

7
    // Property values
8
    BSTR m_name;
9
    long m_value;
10

11
public:
12
    AutomationObject() : m_refCount(1), m_pTypeInfo(nullptr),
13
                        m_name(nullptr), m_value(0) {
14
        // Load type information
15
        LoadTypeInfo();
16
    }
17

18
    virtual ~AutomationObject() {
19
        if (m_pTypeInfo) m_pTypeInfo->Release();
20
        SysFreeString(m_name);
21
    }
22

23
    // IUnknown implementation
24
    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject) override {
25
        if (!ppvObject) return E_INVALIDARG;
26

27
        *ppvObject = nullptr;
28

29
        if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IDispatch)) {
30
            *ppvObject = static_cast<IDispatch*>(this);
31
            AddRef();
32
            return S_OK;
33
        }
34

35
        return E_NOINTERFACE;
36
    }
37

38
    ULONG STDMETHODCALLTYPE AddRef() override {
39
        return InterlockedIncrement(&m_refCount);
40
    }
41

42
    ULONG STDMETHODCALLTYPE Release() override {
43
        ULONG count = InterlockedDecrement(&m_refCount);
44
        if (count == 0) {
45
            delete this;
46
        }
47
        return count;
48
    }
49

50
    // IDispatch implementation
51
    HRESULT STDMETHODCALLTYPE GetTypeInfoCount(UINT* pctinfo) override {
52
        if (!pctinfo) return E_INVALIDARG;
53
        *pctinfo = m_pTypeInfo ? 1 : 0;
54
        return S_OK;
55
    }
56

57
    HRESULT STDMETHODCALLTYPE GetTypeInfo(UINT iTInfo, LCID lcid,
58
                                        ITypeInfo** ppTInfo) override {
59
        if (!ppTInfo) return E_INVALIDARG;
60

61
        *ppTInfo = nullptr;
62

63
        if (iTInfo != 0) return DISP_E_BADINDEX;
64

65
        if (m_pTypeInfo) {
66
            m_pTypeInfo->AddRef();
67
            *ppTInfo = m_pTypeInfo;
68
            return S_OK;
69
        }
70

71
        return E_NOTIMPL;
72
    }
73

74
    HRESULT STDMETHODCALLTYPE GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
75
                                          UINT cNames, LCID lcid,
76
                                          DISPID* rgDispId) override {
77
        if (m_pTypeInfo) {
78
            return DispGetIDsOfNames(m_pTypeInfo, rgszNames, cNames, rgDispId);
79
        }
80

81
        // Manual implementation for common properties/methods
82
        if (cNames == 1) {
83
            if (_wcsicmp(rgszNames[0], L"Name") == 0) {
84
                rgDispId[0] = 1;
85
                return S_OK;
86
            }
87
            else if (_wcsicmp(rgszNames[0], L"Value") == 0) {
88
                rgDispId[0] = 2;
89
                return S_OK;
90
            }
91
            else if (_wcsicmp(rgszNames[0], L"DoSomething") == 0) {
92
                rgDispId[0] = 3;
93
                return S_OK;
94
            }
95
        }
96

97
        return DISP_E_UNKNOWNNAME;
98
    }
99

100
    HRESULT STDMETHODCALLTYPE Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
101
                                   WORD wFlags, DISPPARAMS* pDispParams,
102
                                   VARIANT* pVarResult, EXCEPINFO* pExcepInfo,
103
                                   UINT* puArgErr) override {
104
        if (m_pTypeInfo) {
105
            return DispInvoke(this, m_pTypeInfo, dispIdMember, wFlags,
106
                             pDispParams, pVarResult, pExcepInfo, puArgErr);
107
        }
108

109
        // Manual implementation
110
        switch (dispIdMember) {
111
            case 1: // Name property
112
                if (wFlags & DISPATCH_PROPERTYGET) {
113
                    if (pVarResult) {
114
                        VariantInit(pVarResult);
115
                        pVarResult->vt = VT_BSTR;
116
                        pVarResult->bstrVal = SysAllocString(m_name);
117
                    }
118
                    return S_OK;
119
                }
120
                else if (wFlags & DISPATCH_PROPERTYPUT) {
121
                    if (pDispParams->cArgs >= 1 &&
122
                        pDispParams->rgvarg[0].vt == VT_BSTR) {
123
                        SysFreeString(m_name);
124
                        m_name = SysAllocString(pDispParams->rgvarg[0].bstrVal);
125
                        return S_OK;
126
                    }
127
                    return DISP_E_TYPEMISMATCH;
128
                }
129
                break;
130

131
            case 2: // Value property
132
                if (wFlags & DISPATCH_PROPERTYGET) {
133
                    if (pVarResult) {
134
                        VariantInit(pVarResult);
135
                        pVarResult->vt = VT_I4;
136
                        pVarResult->lVal = m_value;
137
                    }
138
                    return S_OK;
139
                }
140
                else if (wFlags & DISPATCH_PROPERTYPUT) {
141
                    if (pDispParams->cArgs >= 1 &&
142
                        pDispParams->rgvarg[0].vt == VT_I4) {
143
                        m_value = pDispParams->rgvarg[0].lVal;
144
                        return S_OK;
145
                    }
146
                    return DISP_E_TYPEMISMATCH;
147
                }
148
                break;
149

150
            case 3: // DoSomething method
151
                if (wFlags & DISPATCH_METHOD) {
152
                    // Perform some action
153
                    if (pVarResult) {
154
                        VariantInit(pVarResult);
155
                        pVarResult->vt = VT_BSTR;
156
                        pVarResult->bstrVal = SysAllocString(L"Action performed");
157
                    }
158
                    return S_OK;
159
                }
160
                break;
161
        }
162

163
        return DISP_E_MEMBERNOTFOUND;
164
    }
165

166
private:
167
    void LoadTypeInfo() {
168
        // Load type information from type library
169
        ITypeLib* pTypeLib = nullptr;
170

171
        if (SUCCEEDED(LoadRegTypeLib(__uuidof(MyTypeLib), 1, 0, 0, &pTypeLib))) {
172
            pTypeLib->GetTypeInfoOfGuid(__uuidof(IMyAutomationInterface), &m_pTypeInfo);
173
            pTypeLib->Release();
174
        }
175
    }
176
};
177

178
// Automation helper functions
179
class AutomationHelper {
180
public:
181
    static HRESULT CreateSafeArray(VARTYPE vt, ULONG size, SAFEARRAY** ppsa) {
182
        SAFEARRAYBOUND bounds;
183
        bounds.lLbound = 0;
184
        bounds.cElements = size;
185

186
        *ppsa = SafeArrayCreate(vt, 1, &bounds);
187
        return *ppsa ? S_OK : E_OUTOFMEMORY;
188
    }
189

190
    static HRESULT SafeArrayPutElement(SAFEARRAY* psa, LONG index, void* pv) {
191
        return ::SafeArrayPutElement(psa, &index, pv);
192
    }
193

194
    static HRESULT SafeArrayGetElement(SAFEARRAY* psa, LONG index, void* pv) {
195
        return ::SafeArrayGetElement(psa, &index, pv);
196
    }
197

198
    static HRESULT VariantFromString(const std::wstring& str, VARIANT* pVar) {
199
        VariantInit(pVar);
200
        pVar->vt = VT_BSTR;
201
        pVar->bstrVal = SysAllocString(str.c_str());
202
        return pVar->bstrVal ? S_OK : E_OUTOFMEMORY;
203
    }
204

205
    static std::wstring VariantToString(const VARIANT& var) {
206
        if (var.vt == VT_BSTR && var.bstrVal) {
207
            return var.bstrVal;
208
        }
209

210
        // Convert other types to string
211
        VARIANT varStr;
212
        VariantInit(&varStr);
213

214
        if (SUCCEEDED(VariantChangeType(&varStr, const_cast<VARIANT*>(&var), 0, VT_BSTR))) {
215
            std::wstring result = varStr.bstrVal ? varStr.bstrVal : L"";
216
            VariantClear(&varStr);
217
            return result;
218
        }
219

220
        return L"";
221
    }
222
};

Shell Services Integration#

1. System Tray Service#

1
// System tray service with shell integration
2
class ShellTrayService {
3
private:
4
    HWND m_hWnd;
5
    NOTIFYICONDATAW m_nid;
6
    HMENU m_hContextMenu;
7
    UINT m_taskbarCreatedMsg;
8

9
    static const UINT WM_TRAYNOTIFY = WM_USER + 1;
10

11
public:
12
    ShellTrayService() : m_hWnd(nullptr), m_hContextMenu(nullptr) {
13
        m_taskbarCreatedMsg = RegisterWindowMessageW(L"TaskbarCreated");
14
        ZeroMemory(&m_nid, sizeof(m_nid));
15
    }
16

17
    ~ShellTrayService() {
18
        RemoveTrayIcon();
19
        if (m_hContextMenu) {
20
            DestroyMenu(m_hContextMenu);
21
        }
22
    }
23

24
    bool Initialize(HWND hWnd, HICON hIcon, const std::wstring& tooltip) {
25
        m_hWnd = hWnd;
26

27
        // Setup notification icon data
28
        m_nid.cbSize = sizeof(m_nid);
29
        m_nid.hWnd = hWnd;
30
        m_nid.uID = 1;
31
        m_nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
32
        m_nid.uCallbackMessage = WM_TRAYNOTIFY;
33
        m_nid.hIcon = hIcon;
34
        wcscpy_s(m_nid.szTip, tooltip.c_str());
35

36
        // Add to system tray
37
        bool result = Shell_NotifyIconW(NIM_ADD, &m_nid);
38

39
        if (result) {
40
            CreateContextMenu();
41
        }
42

43
        return result;
44
    }
45

46
    void ShowBalloonNotification(const std::wstring& title,
47
                                const std::wstring& message,
48
                                DWORD iconType = NIIF_INFO,
49
                                UINT timeout = 5000) {
50
        m_nid.uFlags |= NIF_INFO;
51
        m_nid.uTimeout = timeout;
52
        m_nid.dwInfoFlags = iconType;
53
        wcscpy_s(m_nid.szInfoTitle, title.c_str());
54
        wcscpy_s(m_nid.szInfo, message.c_str());
55

56
        Shell_NotifyIconW(NIM_MODIFY, &m_nid);
57

58
        // Reset flags
59
        m_nid.uFlags &= ~NIF_INFO;
60
    }
61

62
    void UpdateIcon(HICON hNewIcon, const std::wstring& newTooltip = L"") {
63
        m_nid.hIcon = hNewIcon;
64

65
        if (!newTooltip.empty()) {
66
            wcscpy_s(m_nid.szTip, newTooltip.c_str());
67
        }
68

69
        Shell_NotifyIconW(NIM_MODIFY, &m_nid);
70
    }
71

72
    LRESULT HandleTrayMessage(WPARAM wParam, LPARAM lParam) {
73
        if (wParam == m_nid.uID) {
74
            switch (lParam) {
75
                case WM_RBUTTONUP:
76
                    ShowContextMenu();
77
                    break;
78

79
                case WM_LBUTTONDBLCLK:
80
                    // Handle double-click
81
                    OnTrayDoubleClick();
82
                    break;
83

84
                case NIN_BALLOONUSERCLICK:
85
                    // Handle balloon click
86
                    OnBalloonClick();
87
                    break;
88

89
                case NIN_BALLOONTIMEOUT:
90
                    // Handle balloon timeout
91
                    OnBalloonTimeout();
92
                    break;
93
            }
94
        }
95

96
        return 0;
97
    }
98

99
    LRESULT HandleTaskbarRecreated() {
100
        // Re-add icon when taskbar is recreated
101
        Shell_NotifyIconW(NIM_ADD, &m_nid);
102
        return 0;
103
    }
104

105
private:
106
    void CreateContextMenu() {
107
        m_hContextMenu = CreatePopupMenu();
108

109
        AppendMenuW(m_hContextMenu, MF_STRING, ID_SHOW, L"&Show");
110
        AppendMenuW(m_hContextMenu, MF_STRING, ID_CONFIGURE, L"&Configure...");
111
        AppendMenuW(m_hContextMenu, MF_SEPARATOR, 0, nullptr);
112
        AppendMenuW(m_hContextMenu, MF_STRING, ID_ABOUT, L"&About");
113
        AppendMenuW(m_hContextMenu, MF_SEPARATOR, 0, nullptr);
114
        AppendMenuW(m_hContextMenu, MF_STRING, ID_EXIT, L"E&xit");
115

116
        // Set default menu item
117
        SetMenuDefaultItem(m_hContextMenu, ID_SHOW, FALSE);
118
    }
119

120
    void ShowContextMenu() {
121
        POINT pt;
122
        GetCursorPos(&pt);
123

124
        // Required for proper menu behavior
125
        SetForegroundWindow(m_hWnd);
126

127
        UINT cmd = TrackPopupMenu(m_hContextMenu,
128
                                 TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_NONOTIFY,
129
                                 pt.x, pt.y, 0, m_hWnd, nullptr);
130

131
        // Handle menu commands
132
        switch (cmd) {
133
            case ID_SHOW:
134
                OnShowCommand();
135
                break;
136
            case ID_CONFIGURE:
137
                OnConfigureCommand();
138
                break;
139
            case ID_ABOUT:
140
                OnAboutCommand();
141
                break;
142
            case ID_EXIT:
143
                OnExitCommand();
144
                break;
145
        }
146

147
        // Required for proper menu cleanup
148
        PostMessage(m_hWnd, WM_NULL, 0, 0);
149
    }
150

151
    void RemoveTrayIcon() {
152
        if (m_nid.hWnd) {
153
            Shell_NotifyIconW(NIM_DELETE, &m_nid);
154
        }
155
    }
156

157
    // Event handlers
158
    virtual void OnTrayDoubleClick() {
159
        OnShowCommand();
160
    }
161

162
    virtual void OnBalloonClick() {
163
        // Override in derived class
164
    }
165

166
    virtual void OnBalloonTimeout() {
167
        // Override in derived class
168
    }
169

170
    virtual void OnShowCommand() {
171
        ShowWindow(m_hWnd, SW_SHOW);
172
        SetForegroundWindow(m_hWnd);
173
    }
174

175
    virtual void OnConfigureCommand() {
176
        // Show configuration dialog
177
    }
178

179
    virtual void OnAboutCommand() {
180
        MessageBoxW(m_hWnd, L"Shell Tray Service\nVersion 1.0",
181
                   L"About", MB_OK | MB_ICONINFORMATION);
182
    }
183

184
    virtual void OnExitCommand() {
185
        PostMessage(m_hWnd, WM_CLOSE, 0, 0);
186
    }
187

188
    // Menu command IDs
189
    enum {
190
        ID_SHOW = 1000,
191
        ID_CONFIGURE,
192
        ID_ABOUT,
193
        ID_EXIT
194
    };
195
};

COM Registration & Deployment#

1. COM Registration Functions#

1
// COM registration utilities
2
class COMRegistration {
3
public:
4
    static HRESULT RegisterServer(const CLSID& clsid,
5
                                 const std::wstring& friendlyName,
6
                                 const std::wstring& progId,
7
                                 const std::wstring& dllPath) {
8
        HRESULT hr;
9
        wchar_t clsidString[39];
10

11
        StringFromGUID2(clsid, clsidString, 39);
12

13
        // Register CLSID
14
        std::wstring clsidKey = L"CLSID\\" + std::wstring(clsidString);
15

16
        hr = SetRegistryValue(HKEY_CLASSES_ROOT, clsidKey, L"", friendlyName);
17
        if (FAILED(hr)) return hr;
18

19
        hr = SetRegistryValue(HKEY_CLASSES_ROOT, clsidKey + L"\\InprocServer32",
20
                             L"", dllPath);
21
        if (FAILED(hr)) return hr;
22

23
        hr = SetRegistryValue(HKEY_CLASSES_ROOT, clsidKey + L"\\InprocServer32",
24
                             L"ThreadingModel", L"Apartment");
25
        if (FAILED(hr)) return hr;
26

27
        // Register ProgID
28
        if (!progId.empty()) {
29
            hr = SetRegistryValue(HKEY_CLASSES_ROOT, progId, L"", friendlyName);
30
            if (FAILED(hr)) return hr;
31

32
            hr = SetRegistryValue(HKEY_CLASSES_ROOT, progId + L"\\CLSID",
33
                                 L"", clsidString);
34
            if (FAILED(hr)) return hr;
35

36
            hr = SetRegistryValue(HKEY_CLASSES_ROOT, clsidKey + L"\\ProgID",
37
                                 L"", progId);
38
            if (FAILED(hr)) return hr;
39
        }
40

41
        return S_OK;
42
    }
43

44
    static HRESULT UnregisterServer(const CLSID& clsid,
45
                                   const std::wstring& progId) {
46
        wchar_t clsidString[39];
47
        StringFromGUID2(clsid, clsidString, 39);
48

49
        std::wstring clsidKey = L"CLSID\\" + std::wstring(clsidString);
50

51
        // Remove CLSID entries
52
        SHDeleteKeyW(HKEY_CLASSES_ROOT, (clsidKey + L"\\InprocServer32").c_str());
53
        SHDeleteKeyW(HKEY_CLASSES_ROOT, (clsidKey + L"\\ProgID").c_str());
54
        SHDeleteKeyW(HKEY_CLASSES_ROOT, clsidKey.c_str());
55

56
        // Remove ProgID entries
57
        if (!progId.empty()) {
58
            SHDeleteKeyW(HKEY_CLASSES_ROOT, (progId + L"\\CLSID").c_str());
59
            SHDeleteKeyW(HKEY_CLASSES_ROOT, progId.c_str());
60
        }
61

62
        return S_OK;
63
    }
64

65
    static HRESULT RegisterShellExtension(const CLSID& clsid,
66
                                         const std::wstring& fileExtension,
67
                                         const std::wstring& contextMenuText) {
68
        wchar_t clsidString[39];
69
        StringFromGUID2(clsid, clsidString, 39);
70

71
        // Register for file extension
72
        std::wstring extKey = fileExtension + L"\\shellex\\ContextMenuHandlers\\MyExtension";
73
        return SetRegistryValue(HKEY_CLASSES_ROOT, extKey, L"", clsidString);
74
    }
75

76
private:
77
    static HRESULT SetRegistryValue(HKEY hKeyRoot, const std::wstring& subKey,
78
                                   const std::wstring& valueName,
79
                                   const std::wstring& value) {
80
        HKEY hKey;
81
        LONG result = RegCreateKeyExW(hKeyRoot, subKey.c_str(), 0, nullptr,
82
                                     REG_OPTION_NON_VOLATILE, KEY_WRITE, nullptr,
83
                                     &hKey, nullptr);
84

85
        if (result != ERROR_SUCCESS) {
86
            return HRESULT_FROM_WIN32(result);
87
        }
88

89
        result = RegSetValueExW(hKey, valueName.c_str(), 0, REG_SZ,
90
                               reinterpret_cast<const BYTE*>(value.c_str()),
91
                               static_cast<DWORD>((value.length() + 1) * sizeof(wchar_t)));
92

93
        RegCloseKey(hKey);
94

95
        return result == ERROR_SUCCESS ? S_OK : HRESULT_FROM_WIN32(result);
96
    }
97
};
98

99
// DLL entry points for COM registration
100
extern "C" HRESULT STDAPICALLTYPE DllRegisterServer() {
101
    // Register all COM classes in this DLL
102
    HRESULT hr = COMRegistration::RegisterServer(
103
        CLSID_Calculator,
104
        L"Calculator COM Component",
105
        L"MyApp.Calculator",
106
        GetCurrentDLLPath()
107
    );
108

109
    return hr;
110
}
111

112
extern "C" HRESULT STDAPICALLTYPE DllUnregisterServer() {
113
    return COMRegistration::UnregisterServer(CLSID_Calculator, L"MyApp.Calculator");
114
}
115

116
// Utility function to get current DLL path
117
std::wstring GetCurrentDLLPath() {
118
    wchar_t path[MAX_PATH];
119
    GetModuleFileNameW(GetModuleHandle(nullptr), path, MAX_PATH);
120
    return path;
121
}

Best Practices & Performance#

1. COM Error Handling#

1
// COM error handling utilities
2
class COMErrorHandler {
3
public:
4
    static void LogCOMError(HRESULT hr, const std::wstring& operation) {
5
        std::wstring errorMsg = GetCOMErrorMessage(hr);
6
        // Log to system event log or file
7
        LogError(L"COM Error in " + operation + L": " + errorMsg);
8
    }
9

10
    static std::wstring GetCOMErrorMessage(HRESULT hr) {
11
        wchar_t* msgBuf = nullptr;
12

13
        DWORD result = FormatMessageW(
14
            FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
15
            nullptr, hr, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
16
            reinterpret_cast<LPWSTR>(&msgBuf), 0, nullptr
17
        );
18

19
        std::wstring message;
20
        if (result && msgBuf) {
21
            message = msgBuf;
22
            LocalFree(msgBuf);
23
        } else {
24
            wchar_t buffer[32];
25
            swprintf_s(buffer, L"HRESULT: 0x%08X", hr);
26
            message = buffer;
27
        }
28

29
        return message;
30
    }
31

32
    static bool IsCOMError(HRESULT hr) {
33
        return FAILED(hr);
34
    }
35
};
36

37
// RAII COM initialization
38
class COMInitializer {
39
private:
40
    HRESULT m_hr;
41

42
public:
43
    COMInitializer(DWORD coinitFlags = COINIT_APARTMENTTHREADED) {
44
        m_hr = CoInitializeEx(nullptr, coinitFlags);
45
    }
46

47
    ~COMInitializer() {
48
        if (SUCCEEDED(m_hr)) {
49
            CoUninitialize();
50
        }
51
    }
52

53
    bool IsInitialized() const {
54
        return SUCCEEDED(m_hr);
55
    }
56

57
    HRESULT GetInitResult() const {
58
        return m_hr;
59
    }
60
};

Conclusion#

Windows COM and Shell development provides powerful mechanisms for creating system-integrated applications and reusable components. By mastering COM interfaces, shell extensions, and OLE automation, developers can build sophisticated applications that seamlessly integrate with the Windows operating system and provide enhanced user experiences.

The techniques demonstrated in this guide form the foundation for advanced Windows development, enabling the creation of shell extensions, automation objects, and system services that leverage the full power of the Windows platform.