aboutsummaryrefslogtreecommitdiff
path: root/src/api
diff options
context:
space:
mode:
authorRob Mensching <rob@firegiant.com>2024-03-07 01:44:51 -0800
committerRob Mensching <rob@firegiant.com>2024-03-07 10:55:57 -0800
commitdea25ba9bcfd65200b60339c2e4bc060cdf20723 (patch)
tree91dae5127a7eeb4f0e59252194fc7ec7153a2781 /src/api
parent3d2d46f62fc01e2653d0251ad9703090574e7c41 (diff)
downloadwix-dea25ba9bcfd65200b60339c2e4bc060cdf20723.tar.gz
wix-dea25ba9bcfd65200b60339c2e4bc060cdf20723.tar.bz2
wix-dea25ba9bcfd65200b60339c2e4bc060cdf20723.zip
Move wixstdba functions to Bal.wixext build
Diffstat (limited to 'src/api')
-rw-r--r--src/api/burn/balutil/BalBaseBAFunctionsProc.cpp1099
-rw-r--r--src/api/burn/balutil/balutil.vcxproj5
-rw-r--r--src/api/burn/balutil/inc/BAFunctions.h243
-rw-r--r--src/api/burn/balutil/inc/BalBaseBAFunctions.h1020
-rw-r--r--src/api/burn/balutil/inc/BalBaseBAFunctionsProc.h15
-rw-r--r--src/api/burn/balutil/inc/IBAFunctions.h75
-rw-r--r--src/api/burn/balutil/precomp.h4
-rw-r--r--src/api/burn/inc/BootstrapperApplication.h15
-rw-r--r--src/api/burn/test/BalUtilUnitTest/BAFunctionsTests.cpp47
-rw-r--r--src/api/burn/test/BalUtilUnitTest/BalUtilUnitTest.vcxproj3
-rw-r--r--src/api/burn/test/BalUtilUnitTest/TestBAFunctions.cpp39
-rw-r--r--src/api/burn/test/BalUtilUnitTest/TestBAFunctions.h8
-rw-r--r--src/api/burn/test/BalUtilUnitTest/precomp.h2
13 files changed, 1 insertions, 2574 deletions
diff --git a/src/api/burn/balutil/BalBaseBAFunctionsProc.cpp b/src/api/burn/balutil/BalBaseBAFunctionsProc.cpp
deleted file mode 100644
index 38ebf65c..00000000
--- a/src/api/burn/balutil/BalBaseBAFunctionsProc.cpp
+++ /dev/null
@@ -1,1099 +0,0 @@
1// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
2
3#include "precomp.h"
4
5static HRESULT BalBaseBAFunctionsProcOnDestroy(
6 __in IBAFunctions* pBAFunctions,
7 __in BA_ONDESTROY_ARGS* pArgs,
8 __inout BA_ONDESTROY_RESULTS* /*pResults*/
9 )
10{
11 return pBAFunctions->OnDestroy(pArgs->fReload);
12}
13
14static HRESULT BalBaseBAFunctionsProcOnDetectBegin(
15 __in IBAFunctions* pBAFunctions,
16 __in BA_ONDETECTBEGIN_ARGS* pArgs,
17 __inout BA_ONDETECTBEGIN_RESULTS* pResults
18 )
19{
20 return pBAFunctions->OnDetectBegin(pArgs->fCached, pArgs->registrationType, pArgs->cPackages, &pResults->fCancel);
21}
22
23static HRESULT BalBaseBAFunctionsProcOnDetectComplete(
24 __in IBAFunctions* pBAFunctions,
25 __in BA_ONDETECTCOMPLETE_ARGS* pArgs,
26 __inout BA_ONDETECTCOMPLETE_RESULTS* /*pResults*/
27 )
28{
29 return pBAFunctions->OnDetectComplete(pArgs->hrStatus, pArgs->fEligibleForCleanup);
30}
31
32static HRESULT BalBaseBAFunctionsProcOnPlanBegin(
33 __in IBAFunctions* pBAFunctions,
34 __in BA_ONPLANBEGIN_ARGS* pArgs,
35 __inout BA_ONPLANBEGIN_RESULTS* pResults
36 )
37{
38 return pBAFunctions->OnPlanBegin(pArgs->cPackages, &pResults->fCancel);
39}
40
41static HRESULT BalBaseBAFunctionsProcOnPlanComplete(
42 __in IBAFunctions* pBAFunctions,
43 __in BA_ONPLANCOMPLETE_ARGS* pArgs,
44 __inout BA_ONPLANCOMPLETE_RESULTS* /*pResults*/
45 )
46{
47 return pBAFunctions->OnPlanComplete(pArgs->hrStatus);
48}
49
50static HRESULT BalBaseBAFunctionsProcOnStartup(
51 __in IBAFunctions* pBAFunctions,
52 __in BA_ONSTARTUP_ARGS* /*pArgs*/,
53 __inout BA_ONSTARTUP_RESULTS* /*pResults*/
54 )
55{
56 return pBAFunctions->OnStartup();
57}
58
59static HRESULT BalBaseBAFunctionsProcOnShutdown(
60 __in IBAFunctions* pBAFunctions,
61 __in BA_ONSHUTDOWN_ARGS* /*pArgs*/,
62 __inout BA_ONSHUTDOWN_RESULTS* pResults
63 )
64{
65 return pBAFunctions->OnShutdown(&pResults->action);
66}
67
68static HRESULT BalBaseBAFunctionsProcOnDetectForwardCompatibleBundle(
69 __in IBAFunctions* pBAFunctions,
70 __in BA_ONDETECTFORWARDCOMPATIBLEBUNDLE_ARGS* pArgs,
71 __inout BA_ONDETECTFORWARDCOMPATIBLEBUNDLE_RESULTS* pResults
72 )
73{
74 return pBAFunctions->OnDetectForwardCompatibleBundle(pArgs->wzBundleId, pArgs->relationType, pArgs->wzBundleTag, pArgs->fPerMachine, pArgs->wzVersion, pArgs->fMissingFromCache, &pResults->fCancel);
75}
76
77static HRESULT BalBaseBAFunctionsProcOnDetectUpdateBegin(
78 __in IBAFunctions* pBAFunctions,
79 __in BA_ONDETECTUPDATEBEGIN_ARGS* pArgs,
80 __inout BA_ONDETECTUPDATEBEGIN_RESULTS* pResults
81 )
82{
83 return pBAFunctions->OnDetectUpdateBegin(pArgs->wzUpdateLocation, &pResults->fCancel, &pResults->fSkip);
84}
85
86static HRESULT BalBaseBAFunctionsProcOnDetectUpdate(
87 __in IBAFunctions* pBAFunctions,
88 __in BA_ONDETECTUPDATE_ARGS* pArgs,
89 __inout BA_ONDETECTUPDATE_RESULTS* pResults
90 )
91{
92 return pBAFunctions->OnDetectUpdate(pArgs->wzUpdateLocation, pArgs->dw64Size, pArgs->wzHash, pArgs->hashAlgorithm, pArgs->wzVersion, pArgs->wzTitle, pArgs->wzSummary, pArgs->wzContentType, pArgs->wzContent, &pResults->fCancel, &pResults->fStopProcessingUpdates);
93}
94
95static HRESULT BalBaseBAFunctionsProcOnDetectUpdateComplete(
96 __in IBAFunctions* pBAFunctions,
97 __in BA_ONDETECTUPDATECOMPLETE_ARGS* pArgs,
98 __inout BA_ONDETECTUPDATECOMPLETE_RESULTS* pResults
99 )
100{
101 return pBAFunctions->OnDetectUpdateComplete(pArgs->hrStatus, &pResults->fIgnoreError);
102}
103
104static HRESULT BalBaseBAFunctionsProcOnDetectRelatedBundle(
105 __in IBAFunctions* pBAFunctions,
106 __in BA_ONDETECTRELATEDBUNDLE_ARGS* pArgs,
107 __inout BA_ONDETECTRELATEDBUNDLE_RESULTS* pResults
108 )
109{
110 return pBAFunctions->OnDetectRelatedBundle(pArgs->wzBundleId, pArgs->relationType, pArgs->wzBundleTag, pArgs->fPerMachine, pArgs->wzVersion, pArgs->fMissingFromCache, &pResults->fCancel);
111}
112
113static HRESULT BalBaseBAFunctionsProcOnDetectPackageBegin(
114 __in IBAFunctions* pBAFunctions,
115 __in BA_ONDETECTPACKAGEBEGIN_ARGS* pArgs,
116 __inout BA_ONDETECTPACKAGEBEGIN_RESULTS* pResults
117 )
118{
119 return pBAFunctions->OnDetectPackageBegin(pArgs->wzPackageId, &pResults->fCancel);
120}
121
122static HRESULT BalBaseBAFunctionsProcOnDetectCompatiblePackage(
123 __in IBAFunctions* pBAFunctions,
124 __in BA_ONDETECTCOMPATIBLEMSIPACKAGE_ARGS* pArgs,
125 __inout BA_ONDETECTCOMPATIBLEMSIPACKAGE_RESULTS* pResults
126 )
127{
128 return pBAFunctions->OnDetectCompatibleMsiPackage(pArgs->wzPackageId, pArgs->wzCompatiblePackageId, pArgs->wzCompatiblePackageVersion, &pResults->fCancel);
129}
130
131static HRESULT BalBaseBAFunctionsProcOnDetectRelatedMsiPackage(
132 __in IBAFunctions* pBAFunctions,
133 __in BA_ONDETECTRELATEDMSIPACKAGE_ARGS* pArgs,
134 __inout BA_ONDETECTRELATEDMSIPACKAGE_RESULTS* pResults
135 )
136{
137 return pBAFunctions->OnDetectRelatedMsiPackage(pArgs->wzPackageId, pArgs->wzUpgradeCode, pArgs->wzProductCode, pArgs->fPerMachine, pArgs->wzVersion, pArgs->operation, &pResults->fCancel);
138}
139
140static HRESULT BalBaseBAFunctionsProcOnDetectPatchTarget(
141 __in IBAFunctions* pBAFunctions,
142 __in BA_ONDETECTPATCHTARGET_ARGS* pArgs,
143 __inout BA_ONDETECTPATCHTARGET_RESULTS* pResults
144 )
145{
146 return pBAFunctions->OnDetectPatchTarget(pArgs->wzPackageId, pArgs->wzProductCode, pArgs->patchState, &pResults->fCancel);
147}
148
149static HRESULT BalBaseBAFunctionsProcOnDetectMsiFeature(
150 __in IBAFunctions* pBAFunctions,
151 __in BA_ONDETECTMSIFEATURE_ARGS* pArgs,
152 __inout BA_ONDETECTMSIFEATURE_RESULTS* pResults
153 )
154{
155 return pBAFunctions->OnDetectMsiFeature(pArgs->wzPackageId, pArgs->wzFeatureId, pArgs->state, &pResults->fCancel);
156}
157
158static HRESULT BalBaseBAFunctionsProcOnDetectPackageComplete(
159 __in IBAFunctions* pBAFunctions,
160 __in BA_ONDETECTPACKAGECOMPLETE_ARGS* pArgs,
161 __inout BA_ONDETECTPACKAGECOMPLETE_RESULTS* /*pResults*/
162 )
163{
164 return pBAFunctions->OnDetectPackageComplete(pArgs->wzPackageId, pArgs->hrStatus, pArgs->state, pArgs->fCached);
165}
166
167static HRESULT BalBaseBAFunctionsProcOnPlanRelatedBundle(
168 __in IBAFunctions* pBAFunctions,
169 __in BA_ONPLANRELATEDBUNDLE_ARGS* pArgs,
170 __inout BA_ONPLANRELATEDBUNDLE_RESULTS* pResults
171 )
172{
173 return pBAFunctions->OnPlanRelatedBundle(pArgs->wzBundleId, pArgs->recommendedState, &pResults->requestedState, &pResults->fCancel);
174}
175
176static HRESULT BalBaseBAFunctionsProcOnPlanRollbackBoundary(
177 __in IBAFunctions* pBAFunctions,
178 __in BA_ONPLANROLLBACKBOUNDARY_ARGS* pArgs,
179 __inout BA_ONPLANROLLBACKBOUNDARY_RESULTS* pResults
180 )
181{
182 return pBAFunctions->OnPlanRollbackBoundary(pArgs->wzRollbackBoundaryId, pArgs->fRecommendedTransaction, &pResults->fTransaction, &pResults->fCancel);
183}
184
185static HRESULT BalBaseBAFunctionsProcOnPlanPackageBegin(
186 __in IBAFunctions* pBAFunctions,
187 __in BA_ONPLANPACKAGEBEGIN_ARGS* pArgs,
188 __inout BA_ONPLANPACKAGEBEGIN_RESULTS* pResults
189 )
190{
191 return pBAFunctions->OnPlanPackageBegin(pArgs->wzPackageId, pArgs->state, pArgs->fCached, pArgs->installCondition, pArgs->repairCondition, pArgs->recommendedState, pArgs->recommendedCacheType, &pResults->requestedState, &pResults->requestedCacheType, &pResults->fCancel);
192}
193
194static HRESULT BalBaseBAFunctionsProcOnPlanCompatibleMsiPackageBegin(
195 __in IBAFunctions* pBAFunctions,
196 __in BA_ONPLANCOMPATIBLEMSIPACKAGEBEGIN_ARGS* pArgs,
197 __inout BA_ONPLANCOMPATIBLEMSIPACKAGEBEGIN_RESULTS* pResults
198 )
199{
200 return pBAFunctions->OnPlanCompatibleMsiPackageBegin(pArgs->wzPackageId, pArgs->wzCompatiblePackageId, pArgs->wzCompatiblePackageVersion, pArgs->fRecommendedRemove, &pResults->fRequestRemove, &pResults->fCancel);
201}
202
203static HRESULT BalBaseBAFunctionsProcOnPlanCompatibleMsiPackageComplete(
204 __in IBAFunctions* pBAFunctions,
205 __in BA_ONPLANCOMPATIBLEMSIPACKAGECOMPLETE_ARGS* pArgs,
206 __inout BA_ONPLANCOMPATIBLEMSIPACKAGECOMPLETE_RESULTS* /*pResults*/
207 )
208{
209 return pBAFunctions->OnPlanCompatibleMsiPackageComplete(pArgs->wzPackageId, pArgs->wzCompatiblePackageId, pArgs->hrStatus, pArgs->fRequestedRemove);
210}
211
212static HRESULT BalBaseBAFunctionsProcOnPlanPatchTarget(
213 __in IBAFunctions* pBAFunctions,
214 __in BA_ONPLANPATCHTARGET_ARGS* pArgs,
215 __inout BA_ONPLANPATCHTARGET_RESULTS* pResults
216 )
217{
218 return pBAFunctions->OnPlanPatchTarget(pArgs->wzPackageId, pArgs->wzProductCode, pArgs->recommendedState, &pResults->requestedState, &pResults->fCancel);
219}
220
221static HRESULT BalBaseBAFunctionsProcOnPlanMsiFeature(
222 __in IBAFunctions* pBAFunctions,
223 __in BA_ONPLANMSIFEATURE_ARGS* pArgs,
224 __inout BA_ONPLANMSIFEATURE_RESULTS* pResults
225 )
226{
227 return pBAFunctions->OnPlanMsiFeature(pArgs->wzPackageId, pArgs->wzFeatureId, pArgs->recommendedState, &pResults->requestedState, &pResults->fCancel);
228}
229
230static HRESULT BalBaseBAFunctionsProcOnPlanPackageComplete(
231 __in IBAFunctions* pBAFunctions,
232 __in BA_ONPLANPACKAGECOMPLETE_ARGS* pArgs,
233 __inout BA_ONPLANPACKAGECOMPLETE_RESULTS* /*pResults*/
234 )
235{
236 return pBAFunctions->OnPlanPackageComplete(pArgs->wzPackageId, pArgs->hrStatus, pArgs->requested);
237}
238
239static HRESULT BalBaseBAFunctionsProcOnPlannedCompatiblePackage(
240 __in IBAFunctions* pBAFunctions,
241 __in BA_ONPLANNEDCOMPATIBLEPACKAGE_ARGS* pArgs,
242 __inout BA_ONPLANNEDCOMPATIBLEPACKAGE_RESULTS* /*pResults*/
243 )
244{
245 return pBAFunctions->OnPlannedCompatiblePackage(pArgs->wzPackageId, pArgs->wzCompatiblePackageId, pArgs->fRemove);
246}
247
248static HRESULT BalBaseBAFunctionsProcOnPlannedPackage(
249 __in IBAFunctions* pBAFunctions,
250 __in BA_ONPLANNEDPACKAGE_ARGS* pArgs,
251 __inout BA_ONPLANNEDPACKAGE_RESULTS* /*pResults*/
252 )
253{
254 return pBAFunctions->OnPlannedPackage(pArgs->wzPackageId, pArgs->execute, pArgs->rollback, pArgs->fPlannedCache, pArgs->fPlannedUncache);
255}
256
257static HRESULT BalBaseBAFunctionsProcOnApplyBegin(
258 __in IBAFunctions* pBAFunctions,
259 __in BA_ONAPPLYBEGIN_ARGS* pArgs,
260 __inout BA_ONAPPLYBEGIN_RESULTS* pResults
261 )
262{
263 return pBAFunctions->OnApplyBegin(pArgs->dwPhaseCount, &pResults->fCancel);
264}
265
266static HRESULT BalBaseBAFunctionsProcOnElevateBegin(
267 __in IBAFunctions* pBAFunctions,
268 __in BA_ONELEVATEBEGIN_ARGS* /*pArgs*/,
269 __inout BA_ONELEVATEBEGIN_RESULTS* pResults
270 )
271{
272 return pBAFunctions->OnElevateBegin(&pResults->fCancel);
273}
274
275static HRESULT BalBaseBAFunctionsProcOnElevateComplete(
276 __in IBAFunctions* pBAFunctions,
277 __in BA_ONELEVATECOMPLETE_ARGS* pArgs,
278 __inout BA_ONELEVATECOMPLETE_RESULTS* /*pResults*/
279 )
280{
281 return pBAFunctions->OnElevateComplete(pArgs->hrStatus);
282}
283
284static HRESULT BalBaseBAFunctionsProcOnProgress(
285 __in IBAFunctions* pBAFunctions,
286 __in BA_ONPROGRESS_ARGS* pArgs,
287 __inout BA_ONPROGRESS_RESULTS* pResults
288 )
289{
290 return pBAFunctions->OnProgress(pArgs->dwProgressPercentage, pArgs->dwOverallPercentage, &pResults->fCancel);
291}
292
293static HRESULT BalBaseBAFunctionsProcOnError(
294 __in IBAFunctions* pBAFunctions,
295 __in BA_ONERROR_ARGS* pArgs,
296 __inout BA_ONERROR_RESULTS* pResults
297 )
298{
299 return pBAFunctions->OnError(pArgs->errorType, pArgs->wzPackageId, pArgs->dwCode, pArgs->wzError, pArgs->dwUIHint, pArgs->cData, pArgs->rgwzData, pArgs->nRecommendation, &pResults->nResult);
300}
301
302static HRESULT BalBaseBAFunctionsProcOnRegisterBegin(
303 __in IBAFunctions* pBAFunctions,
304 __in BA_ONREGISTERBEGIN_ARGS* pArgs,
305 __inout BA_ONREGISTERBEGIN_RESULTS* pResults
306 )
307{
308 return pBAFunctions->OnRegisterBegin(pArgs->recommendedRegistrationType, &pResults->fCancel, &pResults->registrationType);
309}
310
311static HRESULT BalBaseBAFunctionsProcOnRegisterComplete(
312 __in IBAFunctions* pBAFunctions,
313 __in BA_ONREGISTERCOMPLETE_ARGS* pArgs,
314 __inout BA_ONREGISTERCOMPLETE_RESULTS* /*pResults*/
315 )
316{
317 return pBAFunctions->OnRegisterComplete(pArgs->hrStatus);
318}
319
320static HRESULT BalBaseBAFunctionsProcOnCacheBegin(
321 __in IBAFunctions* pBAFunctions,
322 __in BA_ONCACHEBEGIN_ARGS* /*pArgs*/,
323 __inout BA_ONCACHEBEGIN_RESULTS* pResults
324 )
325{
326 return pBAFunctions->OnCacheBegin(&pResults->fCancel);
327}
328
329static HRESULT BalBaseBAFunctionsProcOnCachePackageBegin(
330 __in IBAFunctions* pBAFunctions,
331 __in BA_ONCACHEPACKAGEBEGIN_ARGS* pArgs,
332 __inout BA_ONCACHEPACKAGEBEGIN_RESULTS* pResults
333 )
334{
335 return pBAFunctions->OnCachePackageBegin(pArgs->wzPackageId, pArgs->cCachePayloads, pArgs->dw64PackageCacheSize, pArgs->fVital, &pResults->fCancel);
336}
337
338static HRESULT BalBaseBAFunctionsProcOnCacheAcquireBegin(
339 __in IBAFunctions* pBAFunctions,
340 __in BA_ONCACHEACQUIREBEGIN_ARGS* pArgs,
341 __inout BA_ONCACHEACQUIREBEGIN_RESULTS* pResults
342 )
343{
344 return pBAFunctions->OnCacheAcquireBegin(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->wzSource, pArgs->wzDownloadUrl, pArgs->wzPayloadContainerId, pArgs->recommendation, &pResults->action, &pResults->fCancel);
345}
346
347static HRESULT BalBaseBAFunctionsProcOnCacheAcquireProgress(
348 __in IBAFunctions* pBAFunctions,
349 __in BA_ONCACHEACQUIREPROGRESS_ARGS* pArgs,
350 __inout BA_ONCACHEACQUIREPROGRESS_RESULTS* pResults
351 )
352{
353 return pBAFunctions->OnCacheAcquireProgress(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->dw64Progress, pArgs->dw64Total, pArgs->dwOverallPercentage, &pResults->fCancel);
354}
355
356static HRESULT BalBaseBAFunctionsProcOnCacheAcquireResolving(
357 __in IBAFunctions* pBAFunctions,
358 __in BA_ONCACHEACQUIRERESOLVING_ARGS* pArgs,
359 __inout BA_ONCACHEACQUIRERESOLVING_RESULTS* pResults
360 )
361{
362 return pBAFunctions->OnCacheAcquireResolving(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->rgSearchPaths, pArgs->cSearchPaths, pArgs->fFoundLocal, pArgs->dwRecommendedSearchPath, pArgs->wzDownloadUrl, pArgs->wzPayloadContainerId, pArgs->recommendation, &pResults->dwChosenSearchPath, &pResults->action, &pResults->fCancel);
363}
364
365static HRESULT BalBaseBAFunctionsProcOnCacheAcquireComplete(
366 __in IBAFunctions* pBAFunctions,
367 __in BA_ONCACHEACQUIRECOMPLETE_ARGS* pArgs,
368 __inout BA_ONCACHEACQUIRECOMPLETE_RESULTS* pResults
369 )
370{
371 return pBAFunctions->OnCacheAcquireComplete(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->hrStatus, pArgs->recommendation, &pResults->action);
372}
373
374static HRESULT BalBaseBAFunctionsProcOnCacheVerifyBegin(
375 __in IBAFunctions* pBAFunctions,
376 __in BA_ONCACHEVERIFYBEGIN_ARGS* pArgs,
377 __inout BA_ONCACHEVERIFYBEGIN_RESULTS* pResults
378 )
379{
380 return pBAFunctions->OnCacheVerifyBegin(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, &pResults->fCancel);
381}
382
383static HRESULT BalBaseBAFunctionsProcOnCacheVerifyProgress(
384 __in IBAFunctions* pBAFunctions,
385 __in BA_ONCACHEVERIFYPROGRESS_ARGS* pArgs,
386 __inout BA_ONCACHEVERIFYPROGRESS_RESULTS* pResults
387 )
388{
389 return pBAFunctions->OnCacheVerifyProgress(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->dw64Progress, pArgs->dw64Total, pArgs->dwOverallPercentage, pArgs->verifyStep, &pResults->fCancel);
390}
391
392static HRESULT BalBaseBAFunctionsProcOnCacheVerifyComplete(
393 __in IBAFunctions* pBAFunctions,
394 __in BA_ONCACHEVERIFYCOMPLETE_ARGS* pArgs,
395 __inout BA_ONCACHEVERIFYCOMPLETE_RESULTS* pResults
396 )
397{
398 return pBAFunctions->OnCacheVerifyComplete(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->hrStatus, pArgs->recommendation, &pResults->action);
399}
400
401static HRESULT BalBaseBAFunctionsProcOnCachePackageComplete(
402 __in IBAFunctions* pBAFunctions,
403 __in BA_ONCACHEPACKAGECOMPLETE_ARGS* pArgs,
404 __inout BA_ONCACHEPACKAGECOMPLETE_RESULTS* pResults
405 )
406{
407 return pBAFunctions->OnCachePackageComplete(pArgs->wzPackageId, pArgs->hrStatus, pArgs->recommendation, &pResults->action);
408}
409
410static HRESULT BalBaseBAFunctionsProcOnCacheComplete(
411 __in IBAFunctions* pBAFunctions,
412 __in BA_ONCACHECOMPLETE_ARGS* pArgs,
413 __inout BA_ONCACHECOMPLETE_RESULTS* /*pResults*/
414 )
415{
416 return pBAFunctions->OnCacheComplete(pArgs->hrStatus);
417}
418
419static HRESULT BalBaseBAFunctionsProcOnExecuteBegin(
420 __in IBAFunctions* pBAFunctions,
421 __in BA_ONEXECUTEBEGIN_ARGS* pArgs,
422 __inout BA_ONEXECUTEBEGIN_RESULTS* pResults
423 )
424{
425 return pBAFunctions->OnExecuteBegin(pArgs->cExecutingPackages, &pResults->fCancel);
426}
427
428static HRESULT BalBaseBAFunctionsProcOnExecutePackageBegin(
429 __in IBAFunctions* pBAFunctions,
430 __in BA_ONEXECUTEPACKAGEBEGIN_ARGS* pArgs,
431 __inout BA_ONEXECUTEPACKAGEBEGIN_RESULTS* pResults
432 )
433{
434 return pBAFunctions->OnExecutePackageBegin(pArgs->wzPackageId, pArgs->fExecute, pArgs->action, pArgs->uiLevel, pArgs->fDisableExternalUiHandler, &pResults->fCancel);
435}
436
437static HRESULT BalBaseBAFunctionsProcOnExecutePatchTarget(
438 __in IBAFunctions* pBAFunctions,
439 __in BA_ONEXECUTEPATCHTARGET_ARGS* pArgs,
440 __inout BA_ONEXECUTEPATCHTARGET_RESULTS* pResults
441 )
442{
443 return pBAFunctions->OnExecutePatchTarget(pArgs->wzPackageId, pArgs->wzTargetProductCode, &pResults->fCancel);
444}
445
446static HRESULT BalBaseBAFunctionsProcOnExecuteProgress(
447 __in IBAFunctions* pBAFunctions,
448 __in BA_ONEXECUTEPROGRESS_ARGS* pArgs,
449 __inout BA_ONEXECUTEPROGRESS_RESULTS* pResults
450 )
451{
452 return pBAFunctions->OnExecuteProgress(pArgs->wzPackageId, pArgs->dwProgressPercentage, pArgs->dwOverallPercentage, &pResults->fCancel);
453}
454
455static HRESULT BalBaseBAFunctionsProcOnExecuteMsiMessage(
456 __in IBAFunctions* pBAFunctions,
457 __in BA_ONEXECUTEMSIMESSAGE_ARGS* pArgs,
458 __inout BA_ONEXECUTEMSIMESSAGE_RESULTS* pResults
459 )
460{
461 return pBAFunctions->OnExecuteMsiMessage(pArgs->wzPackageId, pArgs->messageType, pArgs->dwUIHint, pArgs->wzMessage, pArgs->cData, pArgs->rgwzData, pArgs->nRecommendation, &pResults->nResult);
462}
463
464static HRESULT BalBaseBAFunctionsProcOnExecuteFilesInUse(
465 __in IBAFunctions* pBAFunctions,
466 __in BA_ONEXECUTEFILESINUSE_ARGS* pArgs,
467 __inout BA_ONEXECUTEFILESINUSE_RESULTS* pResults
468 )
469{
470 return pBAFunctions->OnExecuteFilesInUse(pArgs->wzPackageId, pArgs->cFiles, pArgs->rgwzFiles, pArgs->nRecommendation, pArgs->source, &pResults->nResult);
471}
472
473static HRESULT BalBaseBAFunctionsProcOnExecutePackageComplete(
474 __in IBAFunctions* pBAFunctions,
475 __in BA_ONEXECUTEPACKAGECOMPLETE_ARGS* pArgs,
476 __inout BA_ONEXECUTEPACKAGECOMPLETE_RESULTS* pResults
477 )
478{
479 return pBAFunctions->OnExecutePackageComplete(pArgs->wzPackageId, pArgs->hrStatus, pArgs->restart, pArgs->recommendation, &pResults->action);
480}
481
482static HRESULT BalBaseBAFunctionsProcOnExecuteProcessCancel(
483 __in IBAFunctions* pBAFunctions,
484 __in BA_ONEXECUTEPROCESSCANCEL_ARGS* pArgs,
485 __inout BA_ONEXECUTEPROCESSCANCEL_RESULTS* pResults
486 )
487{
488 return pBAFunctions->OnExecuteProcessCancel(pArgs->wzPackageId, pArgs->dwProcessId, pArgs->recommendation, &pResults->action);
489}
490
491static HRESULT BalBaseBAFunctionsProcOnExecuteComplete(
492 __in IBAFunctions* pBAFunctions,
493 __in BA_ONEXECUTECOMPLETE_ARGS* pArgs,
494 __inout BA_ONEXECUTECOMPLETE_RESULTS* /*pResults*/
495 )
496{
497 return pBAFunctions->OnExecuteComplete(pArgs->hrStatus);
498}
499
500static HRESULT BalBaseBAFunctionsProcOnUnregisterBegin(
501 __in IBAFunctions* pBAFunctions,
502 __in BA_ONUNREGISTERBEGIN_ARGS* pArgs,
503 __inout BA_ONUNREGISTERBEGIN_RESULTS* pResults
504 )
505{
506 return pBAFunctions->OnUnregisterBegin(pArgs->recommendedRegistrationType, &pResults->registrationType);
507}
508
509static HRESULT BalBaseBAFunctionsProcOnUnregisterComplete(
510 __in IBAFunctions* pBAFunctions,
511 __in BA_ONUNREGISTERCOMPLETE_ARGS* pArgs,
512 __inout BA_ONUNREGISTERCOMPLETE_RESULTS* /*pResults*/
513 )
514{
515 return pBAFunctions->OnUnregisterComplete(pArgs->hrStatus);
516}
517
518static HRESULT BalBaseBAFunctionsProcOnApplyComplete(
519 __in IBAFunctions* pBAFunctions,
520 __in BA_ONAPPLYCOMPLETE_ARGS* pArgs,
521 __inout BA_ONAPPLYCOMPLETE_RESULTS* pResults
522 )
523{
524 return pBAFunctions->OnApplyComplete(pArgs->hrStatus, pArgs->restart, pArgs->recommendation, &pResults->action);
525}
526
527static HRESULT BalBaseBAFunctionsProcOnLaunchApprovedExeBegin(
528 __in IBAFunctions* pBAFunctions,
529 __in BA_ONLAUNCHAPPROVEDEXEBEGIN_ARGS* /*pArgs*/,
530 __inout BA_ONLAUNCHAPPROVEDEXEBEGIN_RESULTS* pResults
531 )
532{
533 return pBAFunctions->OnLaunchApprovedExeBegin(&pResults->fCancel);
534}
535
536static HRESULT BalBaseBAFunctionsProcOnLaunchApprovedExeComplete(
537 __in IBAFunctions* pBAFunctions,
538 __in BA_ONLAUNCHAPPROVEDEXECOMPLETE_ARGS* pArgs,
539 __inout BA_ONLAUNCHAPPROVEDEXECOMPLETE_RESULTS* /*pResults*/
540 )
541{
542 return pBAFunctions->OnLaunchApprovedExeComplete(pArgs->hrStatus, pArgs->dwProcessId);
543}
544
545static HRESULT BalBaseBAFunctionsProcOnPlanMsiPackage(
546 __in IBAFunctions* pBAFunctions,
547 __in BA_ONPLANMSIPACKAGE_ARGS* pArgs,
548 __inout BA_ONPLANMSIPACKAGE_RESULTS* pResults
549 )
550{
551 return pBAFunctions->OnPlanMsiPackage(pArgs->wzPackageId, pArgs->fExecute, pArgs->action, pArgs->recommendedFileVersioning, &pResults->fCancel, &pResults->actionMsiProperty, &pResults->uiLevel, &pResults->fDisableExternalUiHandler, &pResults->fileVersioning);
552}
553
554static HRESULT BalBaseBAFunctionsProcOnBeginMsiTransactionBegin(
555 __in IBAFunctions* pBAFunctions,
556 __in BA_ONBEGINMSITRANSACTIONBEGIN_ARGS* pArgs,
557 __inout BA_ONBEGINMSITRANSACTIONBEGIN_RESULTS* pResults
558 )
559{
560 return pBAFunctions->OnBeginMsiTransactionBegin(pArgs->wzTransactionId, &pResults->fCancel);
561}
562
563static HRESULT BalBaseBAFunctionsProcOnBeginMsiTransactionComplete(
564 __in IBAFunctions* pBAFunctions,
565 __in BA_ONBEGINMSITRANSACTIONCOMPLETE_ARGS* pArgs,
566 __inout BA_ONBEGINMSITRANSACTIONCOMPLETE_RESULTS* /*pResults*/
567 )
568{
569 return pBAFunctions->OnBeginMsiTransactionComplete(pArgs->wzTransactionId, pArgs->hrStatus);
570}
571
572static HRESULT BalBaseBAFunctionsProcOnCommitMsiTransactionBegin(
573 __in IBAFunctions* pBAFunctions,
574 __in BA_ONCOMMITMSITRANSACTIONBEGIN_ARGS* pArgs,
575 __inout BA_ONCOMMITMSITRANSACTIONBEGIN_RESULTS* pResults
576 )
577{
578 return pBAFunctions->OnCommitMsiTransactionBegin(pArgs->wzTransactionId, &pResults->fCancel);
579}
580
581static HRESULT BalBaseBAFunctionsProcOnCommitMsiTransactionComplete(
582 __in IBAFunctions* pBAFunctions,
583 __in BA_ONCOMMITMSITRANSACTIONCOMPLETE_ARGS* pArgs,
584 __inout BA_ONCOMMITMSITRANSACTIONCOMPLETE_RESULTS* pResults
585 )
586{
587 return pBAFunctions->OnCommitMsiTransactionComplete(pArgs->wzTransactionId, pArgs->hrStatus, pArgs->restart, pArgs->recommendation, &pResults->action);
588}
589
590static HRESULT BalBaseBAFunctionsProcOnRollbackMsiTransactionBegin(
591 __in IBAFunctions* pBAFunctions,
592 __in BA_ONROLLBACKMSITRANSACTIONBEGIN_ARGS* pArgs,
593 __inout BA_ONROLLBACKMSITRANSACTIONBEGIN_RESULTS* /*pResults*/
594 )
595{
596 return pBAFunctions->OnRollbackMsiTransactionBegin(pArgs->wzTransactionId);
597}
598
599static HRESULT BalBaseBAFunctionsProcOnRollbackMsiTransactionComplete(
600 __in IBAFunctions* pBAFunctions,
601 __in BA_ONROLLBACKMSITRANSACTIONCOMPLETE_ARGS* pArgs,
602 __inout BA_ONROLLBACKMSITRANSACTIONCOMPLETE_RESULTS* pResults
603 )
604{
605 return pBAFunctions->OnRollbackMsiTransactionComplete(pArgs->wzTransactionId, pArgs->hrStatus, pArgs->restart, pArgs->recommendation, &pResults->action);
606}
607
608static HRESULT BalBaseBAFunctionsProcOnPauseAutomaticUpdatesBegin(
609 __in IBAFunctions* pBAFunctions,
610 __in BA_ONPAUSEAUTOMATICUPDATESBEGIN_ARGS* /*pArgs*/,
611 __inout BA_ONPAUSEAUTOMATICUPDATESBEGIN_RESULTS* /*pResults*/
612 )
613{
614 return pBAFunctions->OnPauseAutomaticUpdatesBegin();
615}
616
617static HRESULT BalBaseBAFunctionsProcOnPauseAutomaticUpdatesComplete(
618 __in IBAFunctions* pBAFunctions,
619 __in BA_ONPAUSEAUTOMATICUPDATESCOMPLETE_ARGS* pArgs,
620 __inout BA_ONPAUSEAUTOMATICUPDATESCOMPLETE_RESULTS* /*pResults*/
621 )
622{
623 return pBAFunctions->OnPauseAutomaticUpdatesComplete(pArgs->hrStatus);
624}
625
626static HRESULT BalBaseBAFunctionsProcOnSystemRestorePointBegin(
627 __in IBAFunctions* pBAFunctions,
628 __in BA_ONSYSTEMRESTOREPOINTBEGIN_ARGS* /*pArgs*/,
629 __inout BA_ONSYSTEMRESTOREPOINTBEGIN_RESULTS* /*pResults*/
630 )
631{
632 return pBAFunctions->OnSystemRestorePointBegin();
633}
634
635static HRESULT BalBaseBAFunctionsProcOnSystemRestorePointComplete(
636 __in IBAFunctions* pBAFunctions,
637 __in BA_ONSYSTEMRESTOREPOINTCOMPLETE_ARGS* pArgs,
638 __inout BA_ONSYSTEMRESTOREPOINTCOMPLETE_RESULTS* /*pResults*/
639 )
640{
641 return pBAFunctions->OnSystemRestorePointComplete(pArgs->hrStatus);
642}
643
644static HRESULT BalBaseBAFunctionsProcOnPlanForwardCompatibleBundle(
645 __in IBAFunctions* pBAFunctions,
646 __in BA_ONPLANFORWARDCOMPATIBLEBUNDLE_ARGS* pArgs,
647 __inout BA_ONPLANFORWARDCOMPATIBLEBUNDLE_RESULTS* pResults
648 )
649{
650 return pBAFunctions->OnPlanForwardCompatibleBundle(pArgs->wzBundleId, pArgs->relationType, pArgs->wzBundleTag, pArgs->fPerMachine, pArgs->wzVersion, pArgs->fRecommendedIgnoreBundle, &pResults->fCancel, &pResults->fIgnoreBundle);
651}
652
653static HRESULT BalBaseBAFunctionsProcOnCacheContainerOrPayloadVerifyBegin(
654 __in IBAFunctions* pBAFunctions,
655 __in BA_ONCACHECONTAINERORPAYLOADVERIFYBEGIN_ARGS* pArgs,
656 __inout BA_ONCACHECONTAINERORPAYLOADVERIFYBEGIN_RESULTS* pResults
657 )
658{
659 return pBAFunctions->OnCacheContainerOrPayloadVerifyBegin(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, &pResults->fCancel);
660}
661
662static HRESULT BalBaseBAFunctionsProcOnCacheContainerOrPayloadVerifyProgress(
663 __in IBAFunctions* pBAFunctions,
664 __in BA_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS_ARGS* pArgs,
665 __inout BA_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS_RESULTS* pResults
666 )
667{
668 return pBAFunctions->OnCacheContainerOrPayloadVerifyProgress(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->dw64Progress, pArgs->dw64Total, pArgs->dwOverallPercentage, &pResults->fCancel);
669}
670
671static HRESULT BalBaseBAFunctionsProcOnCacheContainerOrPayloadVerifyComplete(
672 __in IBAFunctions* pBAFunctions,
673 __in BA_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE_ARGS* pArgs,
674 __inout BA_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE_RESULTS* /*pResults*/
675 )
676{
677 return pBAFunctions->OnCacheContainerOrPayloadVerifyComplete(pArgs->wzPackageOrContainerId, pArgs->wzPayloadId, pArgs->hrStatus);
678}
679
680static HRESULT BalBaseBAFunctionsProcOnCachePayloadExtractBegin(
681 __in IBAFunctions* pBAFunctions,
682 __in BA_ONCACHEPAYLOADEXTRACTBEGIN_ARGS* pArgs,
683 __inout BA_ONCACHEPAYLOADEXTRACTBEGIN_RESULTS* pResults
684 )
685{
686 return pBAFunctions->OnCachePayloadExtractBegin(pArgs->wzContainerId, pArgs->wzPayloadId, &pResults->fCancel);
687}
688
689static HRESULT BalBaseBAFunctionsProcOnCachePayloadExtractProgress(
690 __in IBAFunctions* pBAFunctions,
691 __in BA_ONCACHEPAYLOADEXTRACTPROGRESS_ARGS* pArgs,
692 __inout BA_ONCACHEPAYLOADEXTRACTPROGRESS_RESULTS* pResults
693 )
694{
695 return pBAFunctions->OnCachePayloadExtractProgress(pArgs->wzContainerId, pArgs->wzPayloadId, pArgs->dw64Progress, pArgs->dw64Total, pArgs->dwOverallPercentage, &pResults->fCancel);
696}
697
698static HRESULT BalBaseBAFunctionsProcOnCachePayloadExtractComplete(
699 __in IBAFunctions* pBAFunctions,
700 __in BA_ONCACHEPAYLOADEXTRACTCOMPLETE_ARGS* pArgs,
701 __inout BA_ONCACHEPAYLOADEXTRACTCOMPLETE_RESULTS* /*pResults*/
702 )
703{
704 return pBAFunctions->OnCachePayloadExtractComplete(pArgs->wzContainerId, pArgs->wzPayloadId, pArgs->hrStatus);
705}
706
707static HRESULT BalBaseBAFunctionsProcOnPlanRestoreRelatedBundle(
708 __in IBAFunctions* pBAFunctions,
709 __in BA_ONPLANRESTORERELATEDBUNDLE_ARGS* pArgs,
710 __inout BA_ONPLANRESTORERELATEDBUNDLE_RESULTS* pResults
711 )
712{
713 return pBAFunctions->OnPlanRestoreRelatedBundle(pArgs->wzBundleId, pArgs->recommendedState, &pResults->requestedState, &pResults->fCancel);
714}
715
716static HRESULT BalBaseBAFunctionsProcOnPlanRelatedBundleType(
717 __in IBAFunctions* pBAFunctions,
718 __in BA_ONPLANRELATEDBUNDLETYPE_ARGS* pArgs,
719 __inout BA_ONPLANRELATEDBUNDLETYPE_RESULTS* pResults
720 )
721{
722 return pBAFunctions->OnPlanRelatedBundleType(pArgs->wzBundleId, pArgs->recommendedType, &pResults->requestedType, &pResults->fCancel);
723}
724
725static HRESULT BalBaseBAFunctionsProcOnApplyDowngrade(
726 __in IBAFunctions* pBAFunctions,
727 __in BA_ONAPPLYDOWNGRADE_ARGS* pArgs,
728 __inout BA_ONAPPLYDOWNGRADE_RESULTS* pResults
729 )
730{
731 return pBAFunctions->OnApplyDowngrade(pArgs->hrRecommended, &pResults->hrStatus);
732}
733
734static HRESULT BalBaseBAFunctionsProcOnDetectRelatedBundlePackage(
735 __in IBAFunctions* pBAFunctions,
736 __in BA_ONDETECTRELATEDBUNDLEPACKAGE_ARGS* pArgs,
737 __inout BA_ONDETECTRELATEDBUNDLEPACKAGE_RESULTS* pResults
738 )
739{
740 return pBAFunctions->OnDetectRelatedBundlePackage(pArgs->wzPackageId, pArgs->wzBundleId, pArgs->relationType, pArgs->fPerMachine, pArgs->wzVersion, &pResults->fCancel);
741}
742
743static HRESULT BalBaseBAFunctionsProcOnCachePackageNonVitalValidationFailure(
744 __in IBAFunctions* pBAFunctions,
745 __in BA_ONCACHEPACKAGENONVITALVALIDATIONFAILURE_ARGS* pArgs,
746 __inout BA_ONCACHEPACKAGENONVITALVALIDATIONFAILURE_RESULTS* pResults
747 )
748{
749 return pBAFunctions->OnCachePackageNonVitalValidationFailure(pArgs->wzPackageId, pArgs->hrStatus, pArgs->recommendation, &pResults->action);
750}
751
752static HRESULT BalBaseBAFunctionsProcOnThemeLoaded(
753 __in IBAFunctions* pBAFunctions,
754 __in BA_FUNCTIONS_ONTHEMELOADED_ARGS* pArgs,
755 __inout BA_FUNCTIONS_ONTHEMELOADED_RESULTS* /*pResults*/
756 )
757{
758 return pBAFunctions->OnThemeLoaded(pArgs->hWnd);
759}
760
761static HRESULT BalBaseBAFunctionsProcWndProc(
762 __in IBAFunctions* pBAFunctions,
763 __in BA_FUNCTIONS_WNDPROC_ARGS* pArgs,
764 __inout BA_FUNCTIONS_WNDPROC_RESULTS* pResults
765 )
766{
767 return pBAFunctions->WndProc(pArgs->hWnd, pArgs->uMsg, pArgs->wParam, pArgs->lParam, &pResults->fProcessed, &pResults->lResult);
768}
769
770static HRESULT BalBaseBAFunctionsProcOnThemeControlLoading(
771 __in IBAFunctions* pBAFunctions,
772 __in BA_FUNCTIONS_ONTHEMECONTROLLOADING_ARGS* pArgs,
773 __inout BA_FUNCTIONS_ONTHEMECONTROLLOADING_RESULTS* pResults
774 )
775{
776 return pBAFunctions->OnThemeControlLoading(pArgs->wzName, &pResults->fProcessed, &pResults->wId, &pResults->dwAutomaticBehaviorType);
777}
778
779static HRESULT BalBaseBAFunctionsProcOnThemeControlWmCommand(
780 __in IBAFunctions* pBAFunctions,
781 __in BA_FUNCTIONS_ONTHEMECONTROLWMCOMMAND_ARGS* pArgs,
782 __inout BA_FUNCTIONS_ONTHEMECONTROLWMCOMMAND_RESULTS* pResults
783 )
784{
785 return pBAFunctions->OnThemeControlWmCommand(pArgs->wParam, pArgs->wzName, pArgs->wId, pArgs->hWnd, &pResults->fProcessed, &pResults->lResult);
786}
787
788static HRESULT BalBaseBAFunctionsProcOnThemeControlWmNotify(
789 __in IBAFunctions* pBAFunctions,
790 __in BA_FUNCTIONS_ONTHEMECONTROLWMNOTIFY_ARGS* pArgs,
791 __inout BA_FUNCTIONS_ONTHEMECONTROLWMNOTIFY_RESULTS* pResults
792 )
793{
794 return pBAFunctions->OnThemeControlWmNotify(pArgs->lParam, pArgs->wzName, pArgs->wId, pArgs->hWnd, &pResults->fProcessed, &pResults->lResult);
795}
796
797static HRESULT BalBaseBAFunctionsProcOnThemeControlLoaded(
798 __in IBAFunctions* pBAFunctions,
799 __in BA_FUNCTIONS_ONTHEMECONTROLLOADED_ARGS* pArgs,
800 __inout BA_FUNCTIONS_ONTHEMECONTROLLOADED_RESULTS* pResults
801 )
802{
803 return pBAFunctions->OnThemeControlLoaded(pArgs->wzName, pArgs->wId, pArgs->hWnd, &pResults->fProcessed);
804}
805
806/*******************************************************************
807BalBaseBAFunctionsProc - requires pvContext to be of type IBAFunctions.
808Provides a default mapping between the message based BAFunctions interface and
809the COM-based BAFunctions interface.
810
811*******************************************************************/
812HRESULT WINAPI BalBaseBAFunctionsProc(
813 __in BA_FUNCTIONS_MESSAGE message,
814 __in const LPVOID pvArgs,
815 __inout LPVOID pvResults,
816 __in_opt LPVOID pvContext
817 )
818{
819 IBAFunctions* pBAFunctions = reinterpret_cast<IBAFunctions*>(pvContext);
820 HRESULT hr = pBAFunctions->BAFunctionsProc(message, pvArgs, pvResults, pvContext);
821
822 if (E_NOTIMPL == hr)
823 {
824 switch (message)
825 {
826 case BA_FUNCTIONS_MESSAGE_ONCREATE:
827 // ONCREATE is handled when the function is created, not via callback.
828 break;
829 case BA_FUNCTIONS_MESSAGE_ONDESTROY:
830 hr = BalBaseBAFunctionsProcOnDestroy(pBAFunctions, reinterpret_cast<BA_ONDESTROY_ARGS*>(pvArgs), reinterpret_cast<BA_ONDESTROY_RESULTS*>(pvResults));
831 break;
832 case BA_FUNCTIONS_MESSAGE_ONSTARTUP:
833 hr = BalBaseBAFunctionsProcOnStartup(pBAFunctions, reinterpret_cast<BA_ONSTARTUP_ARGS*>(pvArgs), reinterpret_cast<BA_ONSTARTUP_RESULTS*>(pvResults));
834 break;
835 case BA_FUNCTIONS_MESSAGE_ONSHUTDOWN:
836 hr = BalBaseBAFunctionsProcOnShutdown(pBAFunctions, reinterpret_cast<BA_ONSHUTDOWN_ARGS*>(pvArgs), reinterpret_cast<BA_ONSHUTDOWN_RESULTS*>(pvResults));
837 break;
838 case BA_FUNCTIONS_MESSAGE_ONDETECTBEGIN:
839 hr = BalBaseBAFunctionsProcOnDetectBegin(pBAFunctions, reinterpret_cast<BA_ONDETECTBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTBEGIN_RESULTS*>(pvResults));
840 break;
841 case BA_FUNCTIONS_MESSAGE_ONDETECTCOMPLETE:
842 hr = BalBaseBAFunctionsProcOnDetectComplete(pBAFunctions, reinterpret_cast<BA_ONDETECTCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTCOMPLETE_RESULTS*>(pvResults));
843 break;
844 case BA_FUNCTIONS_MESSAGE_ONPLANBEGIN:
845 hr = BalBaseBAFunctionsProcOnPlanBegin(pBAFunctions, reinterpret_cast<BA_ONPLANBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANBEGIN_RESULTS*>(pvResults));
846 break;
847 case BA_FUNCTIONS_MESSAGE_ONPLANCOMPLETE:
848 hr = BalBaseBAFunctionsProcOnPlanComplete(pBAFunctions, reinterpret_cast<BA_ONPLANCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANCOMPLETE_RESULTS*>(pvResults));
849 break;
850 case BA_FUNCTIONS_MESSAGE_ONDETECTFORWARDCOMPATIBLEBUNDLE:
851 hr = BalBaseBAFunctionsProcOnDetectForwardCompatibleBundle(pBAFunctions, reinterpret_cast<BA_ONDETECTFORWARDCOMPATIBLEBUNDLE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTFORWARDCOMPATIBLEBUNDLE_RESULTS*>(pvResults));
852 break;
853 case BA_FUNCTIONS_MESSAGE_ONDETECTUPDATEBEGIN:
854 hr = BalBaseBAFunctionsProcOnDetectUpdateBegin(pBAFunctions, reinterpret_cast<BA_ONDETECTUPDATEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTUPDATEBEGIN_RESULTS*>(pvResults));
855 break;
856 case BA_FUNCTIONS_MESSAGE_ONDETECTUPDATE:
857 hr = BalBaseBAFunctionsProcOnDetectUpdate(pBAFunctions, reinterpret_cast<BA_ONDETECTUPDATE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTUPDATE_RESULTS*>(pvResults));
858 break;
859 case BA_FUNCTIONS_MESSAGE_ONDETECTUPDATECOMPLETE:
860 hr = BalBaseBAFunctionsProcOnDetectUpdateComplete(pBAFunctions, reinterpret_cast<BA_ONDETECTUPDATECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTUPDATECOMPLETE_RESULTS*>(pvResults));
861 break;
862 case BA_FUNCTIONS_MESSAGE_ONDETECTRELATEDBUNDLE:
863 hr = BalBaseBAFunctionsProcOnDetectRelatedBundle(pBAFunctions, reinterpret_cast<BA_ONDETECTRELATEDBUNDLE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTRELATEDBUNDLE_RESULTS*>(pvResults));
864 break;
865 case BA_FUNCTIONS_MESSAGE_ONDETECTPACKAGEBEGIN:
866 hr = BalBaseBAFunctionsProcOnDetectPackageBegin(pBAFunctions, reinterpret_cast<BA_ONDETECTPACKAGEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTPACKAGEBEGIN_RESULTS*>(pvResults));
867 break;
868 case BA_FUNCTIONS_MESSAGE_ONDETECTRELATEDMSIPACKAGE:
869 hr = BalBaseBAFunctionsProcOnDetectRelatedMsiPackage(pBAFunctions, reinterpret_cast<BA_ONDETECTRELATEDMSIPACKAGE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTRELATEDMSIPACKAGE_RESULTS*>(pvResults));
870 break;
871 case BA_FUNCTIONS_MESSAGE_ONDETECTPATCHTARGET:
872 hr = BalBaseBAFunctionsProcOnDetectPatchTarget(pBAFunctions, reinterpret_cast<BA_ONDETECTPATCHTARGET_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTPATCHTARGET_RESULTS*>(pvResults));
873 break;
874 case BA_FUNCTIONS_MESSAGE_ONDETECTMSIFEATURE:
875 hr = BalBaseBAFunctionsProcOnDetectMsiFeature(pBAFunctions, reinterpret_cast<BA_ONDETECTMSIFEATURE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTMSIFEATURE_RESULTS*>(pvResults));
876 break;
877 case BA_FUNCTIONS_MESSAGE_ONDETECTPACKAGECOMPLETE:
878 hr = BalBaseBAFunctionsProcOnDetectPackageComplete(pBAFunctions, reinterpret_cast<BA_ONDETECTPACKAGECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTPACKAGECOMPLETE_RESULTS*>(pvResults));
879 break;
880 case BA_FUNCTIONS_MESSAGE_ONPLANRELATEDBUNDLE:
881 hr = BalBaseBAFunctionsProcOnPlanRelatedBundle(pBAFunctions, reinterpret_cast<BA_ONPLANRELATEDBUNDLE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANRELATEDBUNDLE_RESULTS*>(pvResults));
882 break;
883 case BA_FUNCTIONS_MESSAGE_ONPLANPACKAGEBEGIN:
884 hr = BalBaseBAFunctionsProcOnPlanPackageBegin(pBAFunctions, reinterpret_cast<BA_ONPLANPACKAGEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANPACKAGEBEGIN_RESULTS*>(pvResults));
885 break;
886 case BA_FUNCTIONS_MESSAGE_ONPLANPATCHTARGET:
887 hr = BalBaseBAFunctionsProcOnPlanPatchTarget(pBAFunctions, reinterpret_cast<BA_ONPLANPATCHTARGET_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANPATCHTARGET_RESULTS*>(pvResults));
888 break;
889 case BA_FUNCTIONS_MESSAGE_ONPLANMSIFEATURE:
890 hr = BalBaseBAFunctionsProcOnPlanMsiFeature(pBAFunctions, reinterpret_cast<BA_ONPLANMSIFEATURE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANMSIFEATURE_RESULTS*>(pvResults));
891 break;
892 case BA_FUNCTIONS_MESSAGE_ONPLANPACKAGECOMPLETE:
893 hr = BalBaseBAFunctionsProcOnPlanPackageComplete(pBAFunctions, reinterpret_cast<BA_ONPLANPACKAGECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANPACKAGECOMPLETE_RESULTS*>(pvResults));
894 break;
895 case BA_FUNCTIONS_MESSAGE_ONAPPLYBEGIN:
896 hr = BalBaseBAFunctionsProcOnApplyBegin(pBAFunctions, reinterpret_cast<BA_ONAPPLYBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONAPPLYBEGIN_RESULTS*>(pvResults));
897 break;
898 case BA_FUNCTIONS_MESSAGE_ONELEVATEBEGIN:
899 hr = BalBaseBAFunctionsProcOnElevateBegin(pBAFunctions, reinterpret_cast<BA_ONELEVATEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONELEVATEBEGIN_RESULTS*>(pvResults));
900 break;
901 case BA_FUNCTIONS_MESSAGE_ONELEVATECOMPLETE:
902 hr = BalBaseBAFunctionsProcOnElevateComplete(pBAFunctions, reinterpret_cast<BA_ONELEVATECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONELEVATECOMPLETE_RESULTS*>(pvResults));
903 break;
904 case BA_FUNCTIONS_MESSAGE_ONPROGRESS:
905 hr = BalBaseBAFunctionsProcOnProgress(pBAFunctions, reinterpret_cast<BA_ONPROGRESS_ARGS*>(pvArgs), reinterpret_cast<BA_ONPROGRESS_RESULTS*>(pvResults));
906 break;
907 case BA_FUNCTIONS_MESSAGE_ONERROR:
908 hr = BalBaseBAFunctionsProcOnError(pBAFunctions, reinterpret_cast<BA_ONERROR_ARGS*>(pvArgs), reinterpret_cast<BA_ONERROR_RESULTS*>(pvResults));
909 break;
910 case BA_FUNCTIONS_MESSAGE_ONREGISTERBEGIN:
911 hr = BalBaseBAFunctionsProcOnRegisterBegin(pBAFunctions, reinterpret_cast<BA_ONREGISTERBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONREGISTERBEGIN_RESULTS*>(pvResults));
912 break;
913 case BA_FUNCTIONS_MESSAGE_ONREGISTERCOMPLETE:
914 hr = BalBaseBAFunctionsProcOnRegisterComplete(pBAFunctions, reinterpret_cast<BA_ONREGISTERCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONREGISTERCOMPLETE_RESULTS*>(pvResults));
915 break;
916 case BA_FUNCTIONS_MESSAGE_ONCACHEBEGIN:
917 hr = BalBaseBAFunctionsProcOnCacheBegin(pBAFunctions, reinterpret_cast<BA_ONCACHEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEBEGIN_RESULTS*>(pvResults));
918 break;
919 case BA_FUNCTIONS_MESSAGE_ONCACHEPACKAGEBEGIN:
920 hr = BalBaseBAFunctionsProcOnCachePackageBegin(pBAFunctions, reinterpret_cast<BA_ONCACHEPACKAGEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEPACKAGEBEGIN_RESULTS*>(pvResults));
921 break;
922 case BA_FUNCTIONS_MESSAGE_ONCACHEACQUIREBEGIN:
923 hr = BalBaseBAFunctionsProcOnCacheAcquireBegin(pBAFunctions, reinterpret_cast<BA_ONCACHEACQUIREBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEACQUIREBEGIN_RESULTS*>(pvResults));
924 break;
925 case BA_FUNCTIONS_MESSAGE_ONCACHEACQUIREPROGRESS:
926 hr = BalBaseBAFunctionsProcOnCacheAcquireProgress(pBAFunctions, reinterpret_cast<BA_ONCACHEACQUIREPROGRESS_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEACQUIREPROGRESS_RESULTS*>(pvResults));
927 break;
928 case BA_FUNCTIONS_MESSAGE_ONCACHEACQUIRERESOLVING:
929 hr = BalBaseBAFunctionsProcOnCacheAcquireResolving(pBAFunctions, reinterpret_cast<BA_ONCACHEACQUIRERESOLVING_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEACQUIRERESOLVING_RESULTS*>(pvResults));
930 break;
931 case BA_FUNCTIONS_MESSAGE_ONCACHEACQUIRECOMPLETE:
932 hr = BalBaseBAFunctionsProcOnCacheAcquireComplete(pBAFunctions, reinterpret_cast<BA_ONCACHEACQUIRECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEACQUIRECOMPLETE_RESULTS*>(pvResults));
933 break;
934 case BA_FUNCTIONS_MESSAGE_ONCACHEVERIFYBEGIN:
935 hr = BalBaseBAFunctionsProcOnCacheVerifyBegin(pBAFunctions, reinterpret_cast<BA_ONCACHEVERIFYBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEVERIFYBEGIN_RESULTS*>(pvResults));
936 break;
937 case BA_FUNCTIONS_MESSAGE_ONCACHEVERIFYPROGRESS:
938 hr = BalBaseBAFunctionsProcOnCacheVerifyProgress(pBAFunctions, reinterpret_cast<BA_ONCACHEVERIFYPROGRESS_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEVERIFYPROGRESS_RESULTS*>(pvResults));
939 break;
940 case BA_FUNCTIONS_MESSAGE_ONCACHEVERIFYCOMPLETE:
941 hr = BalBaseBAFunctionsProcOnCacheVerifyComplete(pBAFunctions, reinterpret_cast<BA_ONCACHEVERIFYCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEVERIFYCOMPLETE_RESULTS*>(pvResults));
942 break;
943 case BA_FUNCTIONS_MESSAGE_ONCACHEPACKAGECOMPLETE:
944 hr = BalBaseBAFunctionsProcOnCachePackageComplete(pBAFunctions, reinterpret_cast<BA_ONCACHEPACKAGECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEPACKAGECOMPLETE_RESULTS*>(pvResults));
945 break;
946 case BA_FUNCTIONS_MESSAGE_ONCACHECOMPLETE:
947 hr = BalBaseBAFunctionsProcOnCacheComplete(pBAFunctions, reinterpret_cast<BA_ONCACHECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHECOMPLETE_RESULTS*>(pvResults));
948 break;
949 case BA_FUNCTIONS_MESSAGE_ONEXECUTEBEGIN:
950 hr = BalBaseBAFunctionsProcOnExecuteBegin(pBAFunctions, reinterpret_cast<BA_ONEXECUTEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEBEGIN_RESULTS*>(pvResults));
951 break;
952 case BA_FUNCTIONS_MESSAGE_ONEXECUTEPACKAGEBEGIN:
953 hr = BalBaseBAFunctionsProcOnExecutePackageBegin(pBAFunctions, reinterpret_cast<BA_ONEXECUTEPACKAGEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEPACKAGEBEGIN_RESULTS*>(pvResults));
954 break;
955 case BA_FUNCTIONS_MESSAGE_ONEXECUTEPATCHTARGET:
956 hr = BalBaseBAFunctionsProcOnExecutePatchTarget(pBAFunctions, reinterpret_cast<BA_ONEXECUTEPATCHTARGET_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEPATCHTARGET_RESULTS*>(pvResults));
957 break;
958 case BA_FUNCTIONS_MESSAGE_ONEXECUTEPROGRESS:
959 hr = BalBaseBAFunctionsProcOnExecuteProgress(pBAFunctions, reinterpret_cast<BA_ONEXECUTEPROGRESS_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEPROGRESS_RESULTS*>(pvResults));
960 break;
961 case BA_FUNCTIONS_MESSAGE_ONEXECUTEMSIMESSAGE:
962 hr = BalBaseBAFunctionsProcOnExecuteMsiMessage(pBAFunctions, reinterpret_cast<BA_ONEXECUTEMSIMESSAGE_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEMSIMESSAGE_RESULTS*>(pvResults));
963 break;
964 case BA_FUNCTIONS_MESSAGE_ONEXECUTEFILESINUSE:
965 hr = BalBaseBAFunctionsProcOnExecuteFilesInUse(pBAFunctions, reinterpret_cast<BA_ONEXECUTEFILESINUSE_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEFILESINUSE_RESULTS*>(pvResults));
966 break;
967 case BA_FUNCTIONS_MESSAGE_ONEXECUTEPACKAGECOMPLETE:
968 hr = BalBaseBAFunctionsProcOnExecutePackageComplete(pBAFunctions, reinterpret_cast<BA_ONEXECUTEPACKAGECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEPACKAGECOMPLETE_RESULTS*>(pvResults));
969 break;
970 case BA_FUNCTIONS_MESSAGE_ONEXECUTECOMPLETE:
971 hr = BalBaseBAFunctionsProcOnExecuteComplete(pBAFunctions, reinterpret_cast<BA_ONEXECUTECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTECOMPLETE_RESULTS*>(pvResults));
972 break;
973 case BA_FUNCTIONS_MESSAGE_ONUNREGISTERBEGIN:
974 hr = BalBaseBAFunctionsProcOnUnregisterBegin(pBAFunctions, reinterpret_cast<BA_ONUNREGISTERBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONUNREGISTERBEGIN_RESULTS*>(pvResults));
975 break;
976 case BA_FUNCTIONS_MESSAGE_ONUNREGISTERCOMPLETE:
977 hr = BalBaseBAFunctionsProcOnUnregisterComplete(pBAFunctions, reinterpret_cast<BA_ONUNREGISTERCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONUNREGISTERCOMPLETE_RESULTS*>(pvResults));
978 break;
979 case BA_FUNCTIONS_MESSAGE_ONAPPLYCOMPLETE:
980 hr = BalBaseBAFunctionsProcOnApplyComplete(pBAFunctions, reinterpret_cast<BA_ONAPPLYCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONAPPLYCOMPLETE_RESULTS*>(pvResults));
981 break;
982 case BA_FUNCTIONS_MESSAGE_ONLAUNCHAPPROVEDEXEBEGIN:
983 hr = BalBaseBAFunctionsProcOnLaunchApprovedExeBegin(pBAFunctions, reinterpret_cast<BA_ONLAUNCHAPPROVEDEXEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONLAUNCHAPPROVEDEXEBEGIN_RESULTS*>(pvResults));
984 break;
985 case BA_FUNCTIONS_MESSAGE_ONLAUNCHAPPROVEDEXECOMPLETE:
986 hr = BalBaseBAFunctionsProcOnLaunchApprovedExeComplete(pBAFunctions, reinterpret_cast<BA_ONLAUNCHAPPROVEDEXECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONLAUNCHAPPROVEDEXECOMPLETE_RESULTS*>(pvResults));
987 break;
988 case BA_FUNCTIONS_MESSAGE_ONPLANMSIPACKAGE:
989 hr = BalBaseBAFunctionsProcOnPlanMsiPackage(pBAFunctions, reinterpret_cast<BA_ONPLANMSIPACKAGE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANMSIPACKAGE_RESULTS*>(pvResults));
990 break;
991 case BA_FUNCTIONS_MESSAGE_ONBEGINMSITRANSACTIONBEGIN:
992 hr = BalBaseBAFunctionsProcOnBeginMsiTransactionBegin(pBAFunctions, reinterpret_cast<BA_ONBEGINMSITRANSACTIONBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONBEGINMSITRANSACTIONBEGIN_RESULTS*>(pvResults));
993 break;
994 case BA_FUNCTIONS_MESSAGE_ONBEGINMSITRANSACTIONCOMPLETE:
995 hr = BalBaseBAFunctionsProcOnBeginMsiTransactionComplete(pBAFunctions, reinterpret_cast<BA_ONBEGINMSITRANSACTIONCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONBEGINMSITRANSACTIONCOMPLETE_RESULTS*>(pvResults));
996 break;
997 case BA_FUNCTIONS_MESSAGE_ONCOMMITMSITRANSACTIONBEGIN:
998 hr = BalBaseBAFunctionsProcOnCommitMsiTransactionBegin(pBAFunctions, reinterpret_cast<BA_ONCOMMITMSITRANSACTIONBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCOMMITMSITRANSACTIONBEGIN_RESULTS*>(pvResults));
999 break;
1000 case BA_FUNCTIONS_MESSAGE_ONCOMMITMSITRANSACTIONCOMPLETE:
1001 hr = BalBaseBAFunctionsProcOnCommitMsiTransactionComplete(pBAFunctions, reinterpret_cast<BA_ONCOMMITMSITRANSACTIONCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCOMMITMSITRANSACTIONCOMPLETE_RESULTS*>(pvResults));
1002 break;
1003 case BA_FUNCTIONS_MESSAGE_ONROLLBACKMSITRANSACTIONBEGIN:
1004 hr = BalBaseBAFunctionsProcOnRollbackMsiTransactionBegin(pBAFunctions, reinterpret_cast<BA_ONROLLBACKMSITRANSACTIONBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONROLLBACKMSITRANSACTIONBEGIN_RESULTS*>(pvResults));
1005 break;
1006 case BA_FUNCTIONS_MESSAGE_ONROLLBACKMSITRANSACTIONCOMPLETE:
1007 hr = BalBaseBAFunctionsProcOnRollbackMsiTransactionComplete(pBAFunctions, reinterpret_cast<BA_ONROLLBACKMSITRANSACTIONCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONROLLBACKMSITRANSACTIONCOMPLETE_RESULTS*>(pvResults));
1008 case BA_FUNCTIONS_MESSAGE_ONPAUSEAUTOMATICUPDATESBEGIN:
1009 hr = BalBaseBAFunctionsProcOnPauseAutomaticUpdatesBegin(pBAFunctions, reinterpret_cast<BA_ONPAUSEAUTOMATICUPDATESBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONPAUSEAUTOMATICUPDATESBEGIN_RESULTS*>(pvResults));
1010 break;
1011 case BA_FUNCTIONS_MESSAGE_ONPAUSEAUTOMATICUPDATESCOMPLETE:
1012 hr = BalBaseBAFunctionsProcOnPauseAutomaticUpdatesComplete(pBAFunctions, reinterpret_cast<BA_ONPAUSEAUTOMATICUPDATESCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPAUSEAUTOMATICUPDATESCOMPLETE_RESULTS*>(pvResults));
1013 break;
1014 case BA_FUNCTIONS_MESSAGE_ONSYSTEMRESTOREPOINTBEGIN:
1015 hr = BalBaseBAFunctionsProcOnSystemRestorePointBegin(pBAFunctions, reinterpret_cast<BA_ONSYSTEMRESTOREPOINTBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONSYSTEMRESTOREPOINTBEGIN_RESULTS*>(pvResults));
1016 break;
1017 case BA_FUNCTIONS_MESSAGE_ONSYSTEMRESTOREPOINTCOMPLETE:
1018 hr = BalBaseBAFunctionsProcOnSystemRestorePointComplete(pBAFunctions, reinterpret_cast<BA_ONSYSTEMRESTOREPOINTCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONSYSTEMRESTOREPOINTCOMPLETE_RESULTS*>(pvResults));
1019 break;
1020 case BA_FUNCTIONS_MESSAGE_ONPLANNEDPACKAGE:
1021 hr = BalBaseBAFunctionsProcOnPlannedPackage(pBAFunctions, reinterpret_cast<BA_ONPLANNEDPACKAGE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANNEDPACKAGE_RESULTS*>(pvResults));
1022 break;
1023 case BA_FUNCTIONS_MESSAGE_ONPLANFORWARDCOMPATIBLEBUNDLE:
1024 hr = BalBaseBAFunctionsProcOnPlanForwardCompatibleBundle(pBAFunctions, reinterpret_cast<BA_ONPLANFORWARDCOMPATIBLEBUNDLE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANFORWARDCOMPATIBLEBUNDLE_RESULTS*>(pvResults));
1025 break;
1026 case BA_FUNCTIONS_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYBEGIN:
1027 hr = BalBaseBAFunctionsProcOnCacheContainerOrPayloadVerifyBegin(pBAFunctions, reinterpret_cast<BA_ONCACHECONTAINERORPAYLOADVERIFYBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHECONTAINERORPAYLOADVERIFYBEGIN_RESULTS*>(pvResults));
1028 break;
1029 case BA_FUNCTIONS_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS:
1030 hr = BalBaseBAFunctionsProcOnCacheContainerOrPayloadVerifyProgress(pBAFunctions, reinterpret_cast<BA_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS_RESULTS*>(pvResults));
1031 break;
1032 case BA_FUNCTIONS_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE:
1033 hr = BalBaseBAFunctionsProcOnCacheContainerOrPayloadVerifyComplete(pBAFunctions, reinterpret_cast<BA_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE_RESULTS*>(pvResults));
1034 break;
1035 case BA_FUNCTIONS_MESSAGE_ONCACHEPAYLOADEXTRACTBEGIN:
1036 hr = BalBaseBAFunctionsProcOnCachePayloadExtractBegin(pBAFunctions, reinterpret_cast<BA_ONCACHEPAYLOADEXTRACTBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEPAYLOADEXTRACTBEGIN_RESULTS*>(pvResults));
1037 break;
1038 case BA_FUNCTIONS_MESSAGE_ONCACHEPAYLOADEXTRACTPROGRESS:
1039 hr = BalBaseBAFunctionsProcOnCachePayloadExtractProgress(pBAFunctions, reinterpret_cast<BA_ONCACHEPAYLOADEXTRACTPROGRESS_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEPAYLOADEXTRACTPROGRESS_RESULTS*>(pvResults));
1040 break;
1041 case BA_FUNCTIONS_MESSAGE_ONCACHEPAYLOADEXTRACTCOMPLETE:
1042 hr = BalBaseBAFunctionsProcOnCachePayloadExtractComplete(pBAFunctions, reinterpret_cast<BA_ONCACHEPAYLOADEXTRACTCOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEPAYLOADEXTRACTCOMPLETE_RESULTS*>(pvResults));
1043 break;
1044 case BA_FUNCTIONS_MESSAGE_ONPLANROLLBACKBOUNDARY:
1045 hr = BalBaseBAFunctionsProcOnPlanRollbackBoundary(pBAFunctions, reinterpret_cast<BA_ONPLANROLLBACKBOUNDARY_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANROLLBACKBOUNDARY_RESULTS*>(pvResults));
1046 break;
1047 case BA_FUNCTIONS_MESSAGE_ONDETECTCOMPATIBLEMSIPACKAGE:
1048 hr = BalBaseBAFunctionsProcOnDetectCompatiblePackage(pBAFunctions, reinterpret_cast<BA_ONDETECTCOMPATIBLEMSIPACKAGE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTCOMPATIBLEMSIPACKAGE_RESULTS*>(pvResults));
1049 break;
1050 case BA_FUNCTIONS_MESSAGE_ONPLANCOMPATIBLEMSIPACKAGEBEGIN:
1051 hr = BalBaseBAFunctionsProcOnPlanCompatibleMsiPackageBegin(pBAFunctions, reinterpret_cast<BA_ONPLANCOMPATIBLEMSIPACKAGEBEGIN_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANCOMPATIBLEMSIPACKAGEBEGIN_RESULTS*>(pvResults));
1052 break;
1053 case BA_FUNCTIONS_MESSAGE_ONPLANCOMPATIBLEMSIPACKAGECOMPLETE:
1054 hr = BalBaseBAFunctionsProcOnPlanCompatibleMsiPackageComplete(pBAFunctions, reinterpret_cast<BA_ONPLANCOMPATIBLEMSIPACKAGECOMPLETE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANCOMPATIBLEMSIPACKAGECOMPLETE_RESULTS*>(pvResults));
1055 break;
1056 case BA_FUNCTIONS_MESSAGE_ONPLANNEDCOMPATIBLEPACKAGE:
1057 hr = BalBaseBAFunctionsProcOnPlannedCompatiblePackage(pBAFunctions, reinterpret_cast<BA_ONPLANNEDCOMPATIBLEPACKAGE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANNEDCOMPATIBLEPACKAGE_RESULTS*>(pvResults));
1058 break;
1059 case BA_FUNCTIONS_MESSAGE_ONPLANRESTORERELATEDBUNDLE:
1060 hr = BalBaseBAFunctionsProcOnPlanRestoreRelatedBundle(pBAFunctions, reinterpret_cast<BA_ONPLANRESTORERELATEDBUNDLE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANRESTORERELATEDBUNDLE_RESULTS*>(pvResults));
1061 break;
1062 case BA_FUNCTIONS_MESSAGE_ONPLANRELATEDBUNDLETYPE:
1063 hr = BalBaseBAFunctionsProcOnPlanRelatedBundleType(pBAFunctions, reinterpret_cast<BA_ONPLANRELATEDBUNDLETYPE_ARGS*>(pvArgs), reinterpret_cast<BA_ONPLANRELATEDBUNDLETYPE_RESULTS*>(pvResults));
1064 break;
1065 case BA_FUNCTIONS_MESSAGE_ONAPPLYDOWNGRADE:
1066 hr = BalBaseBAFunctionsProcOnApplyDowngrade(pBAFunctions, reinterpret_cast<BA_ONAPPLYDOWNGRADE_ARGS*>(pvArgs), reinterpret_cast<BA_ONAPPLYDOWNGRADE_RESULTS*>(pvResults));
1067 break;
1068 case BA_FUNCTIONS_MESSAGE_ONEXECUTEPROCESSCANCEL:
1069 hr = BalBaseBAFunctionsProcOnExecuteProcessCancel(pBAFunctions, reinterpret_cast<BA_ONEXECUTEPROCESSCANCEL_ARGS*>(pvArgs), reinterpret_cast<BA_ONEXECUTEPROCESSCANCEL_RESULTS*>(pvResults));
1070 break;
1071 case BA_FUNCTIONS_MESSAGE_ONDETECTRELATEDBUNDLEPACKAGE:
1072 hr = BalBaseBAFunctionsProcOnDetectRelatedBundlePackage(pBAFunctions, reinterpret_cast<BA_ONDETECTRELATEDBUNDLEPACKAGE_ARGS*>(pvArgs), reinterpret_cast<BA_ONDETECTRELATEDBUNDLEPACKAGE_RESULTS*>(pvResults));
1073 break;
1074 case BA_FUNCTIONS_MESSAGE_ONCACHEPACKAGENONVITALVALIDATIONFAILURE:
1075 hr = BalBaseBAFunctionsProcOnCachePackageNonVitalValidationFailure(pBAFunctions, reinterpret_cast<BA_ONCACHEPACKAGENONVITALVALIDATIONFAILURE_ARGS*>(pvArgs), reinterpret_cast<BA_ONCACHEPACKAGENONVITALVALIDATIONFAILURE_RESULTS*>(pvResults));
1076 break;
1077 case BA_FUNCTIONS_MESSAGE_ONTHEMELOADED:
1078 hr = BalBaseBAFunctionsProcOnThemeLoaded(pBAFunctions, reinterpret_cast<BA_FUNCTIONS_ONTHEMELOADED_ARGS*>(pvArgs), reinterpret_cast<BA_FUNCTIONS_ONTHEMELOADED_RESULTS*>(pvResults));
1079 break;
1080 case BA_FUNCTIONS_MESSAGE_WNDPROC:
1081 hr = BalBaseBAFunctionsProcWndProc(pBAFunctions, reinterpret_cast<BA_FUNCTIONS_WNDPROC_ARGS*>(pvArgs), reinterpret_cast<BA_FUNCTIONS_WNDPROC_RESULTS*>(pvResults));
1082 break;
1083 case BA_FUNCTIONS_MESSAGE_ONTHEMECONTROLLOADING:
1084 hr = BalBaseBAFunctionsProcOnThemeControlLoading(pBAFunctions, reinterpret_cast<BA_FUNCTIONS_ONTHEMECONTROLLOADING_ARGS*>(pvArgs), reinterpret_cast<BA_FUNCTIONS_ONTHEMECONTROLLOADING_RESULTS*>(pvResults));
1085 break;
1086 case BA_FUNCTIONS_MESSAGE_ONTHEMECONTROLWMCOMMAND:
1087 hr = BalBaseBAFunctionsProcOnThemeControlWmCommand(pBAFunctions, reinterpret_cast<BA_FUNCTIONS_ONTHEMECONTROLWMCOMMAND_ARGS*>(pvArgs), reinterpret_cast<BA_FUNCTIONS_ONTHEMECONTROLWMCOMMAND_RESULTS*>(pvResults));
1088 break;
1089 case BA_FUNCTIONS_MESSAGE_ONTHEMECONTROLWMNOTIFY:
1090 hr = BalBaseBAFunctionsProcOnThemeControlWmNotify(pBAFunctions, reinterpret_cast<BA_FUNCTIONS_ONTHEMECONTROLWMNOTIFY_ARGS*>(pvArgs), reinterpret_cast<BA_FUNCTIONS_ONTHEMECONTROLWMNOTIFY_RESULTS*>(pvResults));
1091 break;
1092 case BA_FUNCTIONS_MESSAGE_ONTHEMECONTROLLOADED:
1093 hr = BalBaseBAFunctionsProcOnThemeControlLoaded(pBAFunctions, reinterpret_cast<BA_FUNCTIONS_ONTHEMECONTROLLOADED_ARGS*>(pvArgs), reinterpret_cast<BA_FUNCTIONS_ONTHEMECONTROLLOADED_RESULTS*>(pvResults));
1094 break;
1095 }
1096 }
1097
1098 return hr;
1099}
diff --git a/src/api/burn/balutil/balutil.vcxproj b/src/api/burn/balutil/balutil.vcxproj
index 280f21b8..7d539b5b 100644
--- a/src/api/burn/balutil/balutil.vcxproj
+++ b/src/api/burn/balutil/balutil.vcxproj
@@ -52,7 +52,6 @@
52 </PropertyGroup> 52 </PropertyGroup>
53 53
54 <ItemGroup> 54 <ItemGroup>
55 <ClCompile Include="BalBaseBAFunctionsProc.cpp" />
56 <ClCompile Include="BalBootstrapperEngine.cpp" /> 55 <ClCompile Include="BalBootstrapperEngine.cpp" />
57 <ClCompile Include="balcondition.cpp" /> 56 <ClCompile Include="balcondition.cpp" />
58 <ClCompile Include="balinfo.cpp" /> 57 <ClCompile Include="balinfo.cpp" />
@@ -64,15 +63,11 @@
64 <ClCompile Include="msg.cpp" /> 63 <ClCompile Include="msg.cpp" />
65 </ItemGroup> 64 </ItemGroup>
66 <ItemGroup> 65 <ItemGroup>
67 <ClInclude Include="inc\BAFunctions.h" />
68 <ClInclude Include="inc\BalBaseBAFunctions.h" />
69 <ClInclude Include="inc\BalBaseBAFunctionsProc.h" />
70 <ClInclude Include="inc\BalBaseBootstrapperApplication.h" /> 66 <ClInclude Include="inc\BalBaseBootstrapperApplication.h" />
71 <ClInclude Include="inc\balcondition.h" /> 67 <ClInclude Include="inc\balcondition.h" />
72 <ClInclude Include="inc\balinfo.h" /> 68 <ClInclude Include="inc\balinfo.h" />
73 <ClInclude Include="inc\balretry.h" /> 69 <ClInclude Include="inc\balretry.h" />
74 <ClInclude Include="inc\balutil.h" /> 70 <ClInclude Include="inc\balutil.h" />
75 <ClInclude Include="inc\IBAFunctions.h" />
76 <ClInclude Include="inc\IBootstrapperApplication.h" /> 71 <ClInclude Include="inc\IBootstrapperApplication.h" />
77 <ClInclude Include="inc\IBootstrapperEngine.h" /> 72 <ClInclude Include="inc\IBootstrapperEngine.h" />
78 <ClInclude Include="BalBootstrapperEngine.h" /> 73 <ClInclude Include="BalBootstrapperEngine.h" />
diff --git a/src/api/burn/balutil/inc/BAFunctions.h b/src/api/burn/balutil/inc/BAFunctions.h
deleted file mode 100644
index 7908a74c..00000000
--- a/src/api/burn/balutil/inc/BAFunctions.h
+++ /dev/null
@@ -1,243 +0,0 @@
1#pragma once
2// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
3
4#include "IBootstrapperEngine.h"
5
6#ifdef __cplusplus
7extern "C" {
8#endif
9
10// The first 1024 messages are reserved so that the BA messages have the same value here.
11enum BA_FUNCTIONS_MESSAGE
12{
13 BA_FUNCTIONS_MESSAGE_ONCREATE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCREATE,
14 BA_FUNCTIONS_MESSAGE_ONDESTROY = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDESTROY,
15 BA_FUNCTIONS_MESSAGE_ONSTARTUP = BOOTSTRAPPER_APPLICATION_MESSAGE_ONSTARTUP,
16 BA_FUNCTIONS_MESSAGE_ONSHUTDOWN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONSHUTDOWN,
17 BA_FUNCTIONS_MESSAGE_ONDETECTBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTBEGIN,
18 BA_FUNCTIONS_MESSAGE_ONDETECTCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTCOMPLETE,
19 BA_FUNCTIONS_MESSAGE_ONPLANBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANBEGIN,
20 BA_FUNCTIONS_MESSAGE_ONPLANCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANCOMPLETE,
21 BA_FUNCTIONS_MESSAGE_ONDETECTFORWARDCOMPATIBLEBUNDLE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTFORWARDCOMPATIBLEBUNDLE,
22 BA_FUNCTIONS_MESSAGE_ONDETECTUPDATEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATEBEGIN,
23 BA_FUNCTIONS_MESSAGE_ONDETECTUPDATE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATE,
24 BA_FUNCTIONS_MESSAGE_ONDETECTUPDATECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTUPDATECOMPLETE,
25 BA_FUNCTIONS_MESSAGE_ONDETECTRELATEDBUNDLE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTRELATEDBUNDLE,
26 BA_FUNCTIONS_MESSAGE_ONDETECTPACKAGEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPACKAGEBEGIN,
27 BA_FUNCTIONS_MESSAGE_ONDETECTRELATEDMSIPACKAGE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTRELATEDMSIPACKAGE,
28 BA_FUNCTIONS_MESSAGE_ONDETECTPATCHTARGET = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPATCHTARGET,
29 BA_FUNCTIONS_MESSAGE_ONDETECTMSIFEATURE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTMSIFEATURE,
30 BA_FUNCTIONS_MESSAGE_ONDETECTPACKAGECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTPACKAGECOMPLETE,
31 BA_FUNCTIONS_MESSAGE_ONPLANRELATEDBUNDLE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANRELATEDBUNDLE,
32 BA_FUNCTIONS_MESSAGE_ONPLANPACKAGEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPACKAGEBEGIN,
33 BA_FUNCTIONS_MESSAGE_ONPLANPATCHTARGET = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPATCHTARGET,
34 BA_FUNCTIONS_MESSAGE_ONPLANMSIFEATURE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANMSIFEATURE,
35 BA_FUNCTIONS_MESSAGE_ONPLANPACKAGECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANPACKAGECOMPLETE,
36 BA_FUNCTIONS_MESSAGE_ONAPPLYBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONAPPLYBEGIN,
37 BA_FUNCTIONS_MESSAGE_ONELEVATEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONELEVATEBEGIN,
38 BA_FUNCTIONS_MESSAGE_ONELEVATECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONELEVATECOMPLETE,
39 BA_FUNCTIONS_MESSAGE_ONPROGRESS = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPROGRESS,
40 BA_FUNCTIONS_MESSAGE_ONERROR = BOOTSTRAPPER_APPLICATION_MESSAGE_ONERROR,
41 BA_FUNCTIONS_MESSAGE_ONREGISTERBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONREGISTERBEGIN,
42 BA_FUNCTIONS_MESSAGE_ONREGISTERCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONREGISTERCOMPLETE,
43 BA_FUNCTIONS_MESSAGE_ONCACHEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEBEGIN,
44 BA_FUNCTIONS_MESSAGE_ONCACHEPACKAGEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPACKAGEBEGIN,
45 BA_FUNCTIONS_MESSAGE_ONCACHEACQUIREBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIREBEGIN,
46 BA_FUNCTIONS_MESSAGE_ONCACHEACQUIREPROGRESS = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIREPROGRESS,
47 BA_FUNCTIONS_MESSAGE_ONCACHEACQUIRERESOLVING = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIRERESOLVING,
48 BA_FUNCTIONS_MESSAGE_ONCACHEACQUIRECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEACQUIRECOMPLETE,
49 BA_FUNCTIONS_MESSAGE_ONCACHEVERIFYBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYBEGIN,
50 BA_FUNCTIONS_MESSAGE_ONCACHEVERIFYCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYCOMPLETE,
51 BA_FUNCTIONS_MESSAGE_ONCACHEPACKAGECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPACKAGECOMPLETE,
52 BA_FUNCTIONS_MESSAGE_ONCACHECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECOMPLETE,
53 BA_FUNCTIONS_MESSAGE_ONEXECUTEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEBEGIN,
54 BA_FUNCTIONS_MESSAGE_ONEXECUTEPACKAGEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPACKAGEBEGIN,
55 BA_FUNCTIONS_MESSAGE_ONEXECUTEPATCHTARGET = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPATCHTARGET,
56 BA_FUNCTIONS_MESSAGE_ONEXECUTEPROGRESS = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPROGRESS,
57 BA_FUNCTIONS_MESSAGE_ONEXECUTEMSIMESSAGE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEMSIMESSAGE,
58 BA_FUNCTIONS_MESSAGE_ONEXECUTEFILESINUSE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEFILESINUSE,
59 BA_FUNCTIONS_MESSAGE_ONEXECUTEPACKAGECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPACKAGECOMPLETE,
60 BA_FUNCTIONS_MESSAGE_ONEXECUTECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTECOMPLETE,
61 BA_FUNCTIONS_MESSAGE_ONUNREGISTERBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONUNREGISTERBEGIN,
62 BA_FUNCTIONS_MESSAGE_ONUNREGISTERCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONUNREGISTERCOMPLETE,
63 BA_FUNCTIONS_MESSAGE_ONAPPLYCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONAPPLYCOMPLETE,
64 BA_FUNCTIONS_MESSAGE_ONLAUNCHAPPROVEDEXEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONLAUNCHAPPROVEDEXEBEGIN,
65 BA_FUNCTIONS_MESSAGE_ONLAUNCHAPPROVEDEXECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONLAUNCHAPPROVEDEXECOMPLETE,
66 BA_FUNCTIONS_MESSAGE_ONPLANMSIPACKAGE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANMSIPACKAGE,
67 BA_FUNCTIONS_MESSAGE_ONBEGINMSITRANSACTIONBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONBEGINMSITRANSACTIONBEGIN,
68 BA_FUNCTIONS_MESSAGE_ONBEGINMSITRANSACTIONCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONBEGINMSITRANSACTIONCOMPLETE,
69 BA_FUNCTIONS_MESSAGE_ONCOMMITMSITRANSACTIONBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCOMMITMSITRANSACTIONBEGIN,
70 BA_FUNCTIONS_MESSAGE_ONCOMMITMSITRANSACTIONCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCOMMITMSITRANSACTIONCOMPLETE,
71 BA_FUNCTIONS_MESSAGE_ONROLLBACKMSITRANSACTIONBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONROLLBACKMSITRANSACTIONBEGIN,
72 BA_FUNCTIONS_MESSAGE_ONROLLBACKMSITRANSACTIONCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONROLLBACKMSITRANSACTIONCOMPLETE,
73 BA_FUNCTIONS_MESSAGE_ONPAUSEAUTOMATICUPDATESBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPAUSEAUTOMATICUPDATESBEGIN,
74 BA_FUNCTIONS_MESSAGE_ONPAUSEAUTOMATICUPDATESCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPAUSEAUTOMATICUPDATESCOMPLETE,
75 BA_FUNCTIONS_MESSAGE_ONSYSTEMRESTOREPOINTBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONSYSTEMRESTOREPOINTBEGIN,
76 BA_FUNCTIONS_MESSAGE_ONSYSTEMRESTOREPOINTCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONSYSTEMRESTOREPOINTCOMPLETE,
77 BA_FUNCTIONS_MESSAGE_ONPLANNEDPACKAGE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANNEDPACKAGE,
78 BA_FUNCTIONS_MESSAGE_ONPLANFORWARDCOMPATIBLEBUNDLE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANFORWARDCOMPATIBLEBUNDLE,
79 BA_FUNCTIONS_MESSAGE_ONCACHEVERIFYPROGRESS = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEVERIFYPROGRESS,
80 BA_FUNCTIONS_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYBEGIN,
81 BA_FUNCTIONS_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYCOMPLETE,
82 BA_FUNCTIONS_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHECONTAINERORPAYLOADVERIFYPROGRESS,
83 BA_FUNCTIONS_MESSAGE_ONCACHEPAYLOADEXTRACTBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPAYLOADEXTRACTBEGIN,
84 BA_FUNCTIONS_MESSAGE_ONCACHEPAYLOADEXTRACTCOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPAYLOADEXTRACTCOMPLETE,
85 BA_FUNCTIONS_MESSAGE_ONCACHEPAYLOADEXTRACTPROGRESS = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPAYLOADEXTRACTPROGRESS,
86 BA_FUNCTIONS_MESSAGE_ONPLANROLLBACKBOUNDARY = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANROLLBACKBOUNDARY,
87 BA_FUNCTIONS_MESSAGE_ONDETECTCOMPATIBLEMSIPACKAGE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTCOMPATIBLEMSIPACKAGE,
88 BA_FUNCTIONS_MESSAGE_ONPLANCOMPATIBLEMSIPACKAGEBEGIN = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANCOMPATIBLEMSIPACKAGEBEGIN,
89 BA_FUNCTIONS_MESSAGE_ONPLANCOMPATIBLEMSIPACKAGECOMPLETE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANCOMPATIBLEMSIPACKAGECOMPLETE,
90 BA_FUNCTIONS_MESSAGE_ONPLANNEDCOMPATIBLEPACKAGE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANNEDCOMPATIBLEPACKAGE,
91 BA_FUNCTIONS_MESSAGE_ONPLANRESTORERELATEDBUNDLE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANRESTORERELATEDBUNDLE,
92 BA_FUNCTIONS_MESSAGE_ONPLANRELATEDBUNDLETYPE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONPLANRELATEDBUNDLETYPE,
93 BA_FUNCTIONS_MESSAGE_ONAPPLYDOWNGRADE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONAPPLYDOWNGRADE,
94 BA_FUNCTIONS_MESSAGE_ONEXECUTEPROCESSCANCEL = BOOTSTRAPPER_APPLICATION_MESSAGE_ONEXECUTEPROCESSCANCEL,
95 BA_FUNCTIONS_MESSAGE_ONDETECTRELATEDBUNDLEPACKAGE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONDETECTRELATEDBUNDLEPACKAGE,
96 BA_FUNCTIONS_MESSAGE_ONCACHEPACKAGENONVITALVALIDATIONFAILURE = BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPACKAGENONVITALVALIDATIONFAILURE,
97
98 BA_FUNCTIONS_MESSAGE_ONTHEMELOADED = 1024,
99 BA_FUNCTIONS_MESSAGE_WNDPROC,
100 BA_FUNCTIONS_MESSAGE_ONTHEMECONTROLLOADING,
101 BA_FUNCTIONS_MESSAGE_ONTHEMECONTROLWMCOMMAND,
102 BA_FUNCTIONS_MESSAGE_ONTHEMECONTROLWMNOTIFY,
103 BA_FUNCTIONS_MESSAGE_ONTHEMECONTROLLOADED,
104};
105
106typedef HRESULT(WINAPI *PFN_BA_FUNCTIONS_PROC)(
107 __in BA_FUNCTIONS_MESSAGE message,
108 __in const LPVOID pvArgs,
109 __inout LPVOID pvResults,
110 __in_opt LPVOID pvContext
111 );
112
113// Should be the same as THEME_FIRST_ASSIGN_CONTROL_ID.
114// BAFunctions must only assign ids in the range [BAFUNCTIONS_FIRST_ASSIGN_CONTROL_ID, 0x8000) to avoid collisions.
115const WORD BAFUNCTIONS_FIRST_ASSIGN_CONTROL_ID = 0x4000;
116
117struct BA_FUNCTIONS_CREATE_ARGS
118{
119 DWORD cbSize;
120 DWORD64 qwBAFunctionsAPIVersion;
121 IBootstrapperEngine* pEngine;
122 BOOTSTRAPPER_COMMAND* pCommand;
123};
124
125struct BA_FUNCTIONS_CREATE_RESULTS
126{
127 DWORD cbSize;
128 PFN_BA_FUNCTIONS_PROC pfnBAFunctionsProc;
129 LPVOID pvBAFunctionsProcContext;
130};
131
132struct BA_FUNCTIONS_DESTROY_ARGS
133{
134 DWORD cbSize;
135 BOOL fReload;
136};
137
138struct BA_FUNCTIONS_DESTROY_RESULTS
139{
140 DWORD cbSize;
141 BOOL fDisableUnloading; // indicates the BAFunctions dll must not be unloaded after BAFunctionsDestroy.
142};
143
144struct BA_FUNCTIONS_ONTHEMECONTROLLOADED_ARGS
145{
146 DWORD cbSize;
147 LPCWSTR wzName;
148 WORD wId;
149 HWND hWnd;
150};
151
152struct BA_FUNCTIONS_ONTHEMECONTROLLOADED_RESULTS
153{
154 DWORD cbSize;
155 BOOL fProcessed;
156};
157
158struct BA_FUNCTIONS_ONTHEMECONTROLLOADING_ARGS
159{
160 DWORD cbSize;
161 LPCWSTR wzName;
162};
163
164struct BA_FUNCTIONS_ONTHEMECONTROLLOADING_RESULTS
165{
166 DWORD cbSize;
167 BOOL fProcessed;
168 WORD wId;
169 DWORD dwAutomaticBehaviorType;
170};
171
172struct BA_FUNCTIONS_ONTHEMECONTROLWMCOMMAND_ARGS
173{
174 DWORD cbSize;
175 WPARAM wParam;
176 LPCWSTR wzName;
177 WORD wId;
178 HWND hWnd;
179};
180
181struct BA_FUNCTIONS_ONTHEMECONTROLWMCOMMAND_RESULTS
182{
183 DWORD cbSize;
184 BOOL fProcessed;
185 LRESULT lResult;
186};
187
188struct BA_FUNCTIONS_ONTHEMECONTROLWMNOTIFY_ARGS
189{
190 DWORD cbSize;
191 LPNMHDR lParam;
192 LPCWSTR wzName;
193 WORD wId;
194 HWND hWnd;
195};
196
197struct BA_FUNCTIONS_ONTHEMECONTROLWMNOTIFY_RESULTS
198{
199 DWORD cbSize;
200 BOOL fProcessed;
201 LRESULT lResult;
202};
203
204struct BA_FUNCTIONS_ONTHEMELOADED_ARGS
205{
206 DWORD cbSize;
207 HWND hWnd;
208};
209
210struct BA_FUNCTIONS_ONTHEMELOADED_RESULTS
211{
212 DWORD cbSize;
213};
214
215struct BA_FUNCTIONS_WNDPROC_ARGS
216{
217 DWORD cbSize;
218 HWND hWnd;
219 UINT uMsg;
220 WPARAM wParam;
221 LPARAM lParam;
222};
223
224struct BA_FUNCTIONS_WNDPROC_RESULTS
225{
226 DWORD cbSize;
227 BOOL fProcessed;
228 LRESULT lResult;
229};
230
231typedef HRESULT(WINAPI *PFN_BA_FUNCTIONS_CREATE)(
232 __in const BA_FUNCTIONS_CREATE_ARGS* pArgs,
233 __inout BA_FUNCTIONS_CREATE_RESULTS* pResults
234 );
235
236typedef void (WINAPI *PFN_BA_FUNCTIONS_DESTROY)(
237 __in const BA_FUNCTIONS_DESTROY_ARGS* pArgs,
238 __inout BA_FUNCTIONS_DESTROY_RESULTS* pResults
239 );
240
241#ifdef __cplusplus
242}
243#endif
diff --git a/src/api/burn/balutil/inc/BalBaseBAFunctions.h b/src/api/burn/balutil/inc/BalBaseBAFunctions.h
deleted file mode 100644
index df0b7006..00000000
--- a/src/api/burn/balutil/inc/BalBaseBAFunctions.h
+++ /dev/null
@@ -1,1020 +0,0 @@
1#pragma once
2// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
3
4#include <windows.h>
5#include <msiquery.h>
6
7#include <BootstrapperApplication.h>
8
9#include "IBAFunctions.h"
10
11class CBalBaseBAFunctions : public IBAFunctions
12{
13public: // IUnknown
14 virtual STDMETHODIMP QueryInterface(
15 __in REFIID riid,
16 __out LPVOID *ppvObject
17 )
18 {
19 if (!ppvObject)
20 {
21 return E_INVALIDARG;
22 }
23
24 *ppvObject = NULL;
25
26 if (::IsEqualIID(__uuidof(IBAFunctions), riid))
27 {
28 *ppvObject = static_cast<IBAFunctions*>(this);
29 }
30 else if (::IsEqualIID(__uuidof(IBootstrapperApplication), riid))
31 {
32 *ppvObject = static_cast<IBootstrapperApplication*>(this);
33 }
34 else if (::IsEqualIID(IID_IUnknown, riid))
35 {
36 *ppvObject = static_cast<IUnknown*>(this);
37 }
38 else // no interface for requested iid
39 {
40 return E_NOINTERFACE;
41 }
42
43 AddRef();
44 return S_OK;
45 }
46
47 virtual STDMETHODIMP_(ULONG) AddRef()
48 {
49 return ::InterlockedIncrement(&this->m_cReferences);
50 }
51
52 virtual STDMETHODIMP_(ULONG) Release()
53 {
54 long l = ::InterlockedDecrement(&this->m_cReferences);
55 if (0 < l)
56 {
57 return l;
58 }
59
60 delete this;
61 return 0;
62 }
63
64public: // IBootstrapperApplication
65 virtual STDMETHODIMP_(HRESULT) BAProc(
66 __in BOOTSTRAPPER_APPLICATION_MESSAGE /*message*/,
67 __in const LPVOID /*pvArgs*/,
68 __inout LPVOID /*pvResults*/
69 )
70 {
71 return E_NOTIMPL;
72 }
73
74 virtual STDMETHODIMP_(void) BAProcFallback(
75 __in BOOTSTRAPPER_APPLICATION_MESSAGE /*message*/,
76 __in const LPVOID /*pvArgs*/,
77 __inout LPVOID /*pvResults*/,
78 __inout HRESULT* /*phr*/
79 )
80 {
81 }
82
83 virtual STDMETHODIMP OnCreate(
84 __in IBootstrapperEngine* pEngine,
85 __in BOOTSTRAPPER_COMMAND* /*pCommand*/
86 )
87 {
88 HRESULT hr = S_OK;
89
90 pEngine->AddRef();
91 m_pEngine = pEngine;
92
93 return hr;
94 }
95
96 virtual STDMETHODIMP OnDestroy(
97 __in BOOL /*fReload*/
98 )
99 {
100 return S_OK;
101 }
102
103 virtual STDMETHODIMP OnStartup()
104 {
105 return S_OK;
106 }
107
108 virtual STDMETHODIMP OnShutdown(
109 __inout BOOTSTRAPPER_SHUTDOWN_ACTION* /*pAction*/
110 )
111 {
112 return S_OK;
113 }
114
115 virtual STDMETHODIMP OnDetectBegin(
116 __in BOOL /*fCached*/,
117 __in BOOTSTRAPPER_REGISTRATION_TYPE /*registrationType*/,
118 __in DWORD /*cPackages*/,
119 __inout BOOL* /*pfCancel*/
120 )
121 {
122 return S_OK;
123 }
124
125 virtual STDMETHODIMP OnDetectForwardCompatibleBundle(
126 __in_z LPCWSTR /*wzBundleId*/,
127 __in BOOTSTRAPPER_RELATION_TYPE /*relationType*/,
128 __in_z LPCWSTR /*wzBundleTag*/,
129 __in BOOL /*fPerMachine*/,
130 __in LPCWSTR /*wzVersion*/,
131 __in BOOL /*fMissingFromCache*/,
132 __inout BOOL* /*pfCancel*/
133 )
134 {
135 return S_OK;
136 }
137
138 virtual STDMETHODIMP OnDetectUpdateBegin(
139 __in_z LPCWSTR /*wzUpdateLocation*/,
140 __inout BOOL* /*pfCancel*/,
141 __inout BOOL* /*pfSkip*/
142 )
143 {
144 return S_OK;
145 }
146
147 virtual STDMETHODIMP OnDetectUpdate(
148 __in_z LPCWSTR /*wzUpdateLocation*/,
149 __in DWORD64 /*dw64Size*/,
150 __in_z_opt LPCWSTR /*wzHash*/,
151 __in BOOTSTRAPPER_UPDATE_HASH_TYPE /*hashAlgorithm*/,
152 __in LPCWSTR /*wzVersion*/,
153 __in_z LPCWSTR /*wzTitle*/,
154 __in_z LPCWSTR /*wzSummary*/,
155 __in_z LPCWSTR /*wzContentType*/,
156 __in_z LPCWSTR /*wzContent*/,
157 __inout BOOL* /*pfCancel*/,
158 __inout BOOL* /*pfStopProcessingUpdates*/
159 )
160 {
161 return S_OK;
162 }
163
164 virtual STDMETHODIMP OnDetectUpdateComplete(
165 __in HRESULT /*hrStatus*/,
166 __inout BOOL* /*pfIgnoreError*/
167 )
168 {
169 return S_OK;
170 }
171
172 virtual STDMETHODIMP OnDetectRelatedBundle(
173 __in_z LPCWSTR /*wzBundleId*/,
174 __in BOOTSTRAPPER_RELATION_TYPE /*relationType*/,
175 __in_z LPCWSTR /*wzBundleTag*/,
176 __in BOOL /*fPerMachine*/,
177 __in LPCWSTR /*wzVersion*/,
178 __in BOOL /*fMissingFromCache*/,
179 __inout BOOL* /*pfCancel*/
180 )
181 {
182 return S_OK;
183 }
184
185 virtual STDMETHODIMP OnDetectPackageBegin(
186 __in_z LPCWSTR /*wzPackageId*/,
187 __inout BOOL* /*pfCancel*/
188 )
189 {
190 return S_OK;
191 }
192
193 virtual STDMETHODIMP OnDetectCompatibleMsiPackage(
194 __in_z LPCWSTR /*wzPackageId*/,
195 __in_z LPCWSTR /*wzCompatiblePackageId*/,
196 __in LPCWSTR /*wzCompatiblePackageVersion*/,
197 __inout BOOL* /*pfCancel*/
198 )
199 {
200 return S_OK;
201 }
202
203 virtual STDMETHODIMP OnDetectRelatedMsiPackage(
204 __in_z LPCWSTR /*wzPackageId*/,
205 __in_z LPCWSTR /*wzUpgradeCode*/,
206 __in_z LPCWSTR /*wzProductCode*/,
207 __in BOOL /*fPerMachine*/,
208 __in LPCWSTR /*wzVersion*/,
209 __in BOOTSTRAPPER_RELATED_OPERATION /*operation*/,
210 __inout BOOL* /*pfCancel*/
211 )
212 {
213 return S_OK;
214 }
215
216 virtual STDMETHODIMP OnDetectPatchTarget(
217 __in_z LPCWSTR /*wzPackageId*/,
218 __in_z LPCWSTR /*wzProductCode*/,
219 __in BOOTSTRAPPER_PACKAGE_STATE /*patchState*/,
220 __inout BOOL* /*pfCancel*/
221 )
222 {
223 return S_OK;
224 }
225
226 virtual STDMETHODIMP OnDetectMsiFeature(
227 __in_z LPCWSTR /*wzPackageId*/,
228 __in_z LPCWSTR /*wzFeatureId*/,
229 __in BOOTSTRAPPER_FEATURE_STATE /*state*/,
230 __inout BOOL* /*pfCancel*/
231 )
232 {
233 return S_OK;
234 }
235
236 virtual STDMETHODIMP OnDetectPackageComplete(
237 __in_z LPCWSTR /*wzPackageId*/,
238 __in HRESULT /*hrStatus*/,
239 __in BOOTSTRAPPER_PACKAGE_STATE /*state*/,
240 __in BOOL /*fCached*/
241 )
242 {
243 return S_OK;
244 }
245
246 virtual STDMETHODIMP OnDetectComplete(
247 __in HRESULT /*hrStatus*/,
248 __in BOOL /*fEligibleForCleanup*/
249 )
250 {
251 return S_OK;
252 }
253
254 virtual STDMETHODIMP OnPlanBegin(
255 __in DWORD /*cPackages*/,
256 __inout BOOL* /*pfCancel*/
257 )
258 {
259 return S_OK;
260 }
261
262 virtual STDMETHODIMP OnPlanRelatedBundle(
263 __in_z LPCWSTR /*wzBundleId*/,
264 __in BOOTSTRAPPER_REQUEST_STATE /*recommendedState*/,
265 __inout BOOTSTRAPPER_REQUEST_STATE* /*pRequestedState*/,
266 __inout BOOL* /*pfCancel*/
267 )
268 {
269 return S_OK;
270 }
271
272 virtual STDMETHODIMP OnPlanRollbackBoundary(
273 __in_z LPCWSTR /*wzRollbackBoundaryId*/,
274 __in BOOL /*fRecommendedTransaction*/,
275 __inout BOOL* /*pfTransaction*/,
276 __inout BOOL* /*pfCancel*/
277 )
278 {
279 return S_OK;
280 }
281
282 virtual STDMETHODIMP OnPlanPackageBegin(
283 __in_z LPCWSTR /*wzPackageId*/,
284 __in BOOTSTRAPPER_PACKAGE_STATE /*state*/,
285 __in BOOL /*fCached*/,
286 __in BOOTSTRAPPER_PACKAGE_CONDITION_RESULT /*installCondition*/,
287 __in BOOTSTRAPPER_PACKAGE_CONDITION_RESULT /*repairCondition*/,
288 __in BOOTSTRAPPER_REQUEST_STATE /*recommendedState*/,
289 __in BOOTSTRAPPER_CACHE_TYPE /*recommendedCacheType*/,
290 __inout BOOTSTRAPPER_REQUEST_STATE* /*pRequestState*/,
291 __inout BOOTSTRAPPER_CACHE_TYPE* /*pRequestedCacheType*/,
292 __inout BOOL* /*pfCancel*/
293 )
294 {
295 return S_OK;
296 }
297
298 virtual STDMETHODIMP OnPlanCompatibleMsiPackageBegin(
299 __in_z LPCWSTR /*wzPackageId*/,
300 __in_z LPCWSTR /*wzCompatiblePackageId*/,
301 __in LPCWSTR /*wzCompatiblePackageVersion*/,
302 __in BOOL /*fRecommendedRemove*/,
303 __inout BOOL* /*pfRequestRemove*/,
304 __inout BOOL* /*pfCancel*/
305 )
306 {
307 return S_OK;
308 }
309
310 virtual STDMETHODIMP OnPlanCompatibleMsiPackageComplete(
311 __in_z LPCWSTR /*wzPackageId*/,
312 __in_z LPCWSTR /*wzCompatiblePackageId*/,
313 __in HRESULT /*hrStatus*/,
314 __in BOOL /*fRequestedRemove*/
315 )
316 {
317 return S_OK;
318 }
319
320 virtual STDMETHODIMP OnPlanPatchTarget(
321 __in_z LPCWSTR /*wzPackageId*/,
322 __in_z LPCWSTR /*wzProductCode*/,
323 __in BOOTSTRAPPER_REQUEST_STATE /*recommendedState*/,
324 __inout BOOTSTRAPPER_REQUEST_STATE* /*pRequestedState*/,
325 __inout BOOL* /*pfCancel*/
326 )
327 {
328 return S_OK;
329 }
330
331 virtual STDMETHODIMP OnPlanMsiFeature(
332 __in_z LPCWSTR /*wzPackageId*/,
333 __in_z LPCWSTR /*wzFeatureId*/,
334 __in BOOTSTRAPPER_FEATURE_STATE /*recommendedState*/,
335 __inout BOOTSTRAPPER_FEATURE_STATE* /*pRequestedState*/,
336 __inout BOOL* /*pfCancel*/
337 )
338 {
339 return S_OK;
340 }
341
342 virtual STDMETHODIMP OnPlanMsiPackage(
343 __in_z LPCWSTR /*wzPackageId*/,
344 __in BOOL /*fExecute*/,
345 __in BOOTSTRAPPER_ACTION_STATE /*action*/,
346 __in BOOTSTRAPPER_MSI_FILE_VERSIONING /*recommendedFileVersioning*/,
347 __inout BOOL* /*pfCancel*/,
348 __inout BURN_MSI_PROPERTY* /*pActionMsiProperty*/,
349 __inout INSTALLUILEVEL* /*pUiLevel*/,
350 __inout BOOL* /*pfDisableExternalUiHandler*/,
351 __inout BOOTSTRAPPER_MSI_FILE_VERSIONING* /*pFileVersioning*/
352 )
353 {
354 return S_OK;
355 }
356
357 virtual STDMETHODIMP OnPlanPackageComplete(
358 __in_z LPCWSTR /*wzPackageId*/,
359 __in HRESULT /*hrStatus*/,
360 __in BOOTSTRAPPER_REQUEST_STATE /*requested*/
361 )
362 {
363 return S_OK;
364 }
365
366 virtual STDMETHODIMP OnPlannedCompatiblePackage(
367 __in_z LPCWSTR /*wzPackageId*/,
368 __in_z LPCWSTR /*wzCompatiblePackageId*/,
369 __in BOOL /*fRemove*/
370 )
371 {
372 return S_OK;
373 }
374
375 virtual STDMETHODIMP OnPlannedPackage(
376 __in_z LPCWSTR /*wzPackageId*/,
377 __in BOOTSTRAPPER_ACTION_STATE /*execute*/,
378 __in BOOTSTRAPPER_ACTION_STATE /*rollback*/,
379 __in BOOL /*fPlannedCache*/,
380 __in BOOL /*fPlannedUncache*/
381 )
382 {
383 return S_OK;
384 }
385
386 virtual STDMETHODIMP OnPlanComplete(
387 __in HRESULT /*hrStatus*/
388 )
389 {
390 return S_OK;
391 }
392
393 virtual STDMETHODIMP OnApplyBegin(
394 __in DWORD /*dwPhaseCount*/,
395 __inout BOOL* /*pfCancel*/
396 )
397 {
398 return S_OK;
399 }
400
401 virtual STDMETHODIMP OnElevateBegin(
402 __inout BOOL* /*pfCancel*/
403 )
404 {
405 return S_OK;
406 }
407
408 virtual STDMETHODIMP OnElevateComplete(
409 __in HRESULT /*hrStatus*/
410 )
411 {
412 return S_OK;
413 }
414
415 virtual STDMETHODIMP OnProgress(
416 __in DWORD /*dwProgressPercentage*/,
417 __in DWORD /*dwOverallProgressPercentage*/,
418 __inout BOOL* /*pfCancel*/
419 )
420 {
421 return IDNOACTION;
422 }
423
424 virtual STDMETHODIMP OnError(
425 __in BOOTSTRAPPER_ERROR_TYPE /*errorType*/,
426 __in_z LPCWSTR /*wzPackageId*/,
427 __in DWORD /*dwCode*/,
428 __in_z LPCWSTR /*wzError*/,
429 __in DWORD /*dwUIHint*/,
430 __in DWORD /*cData*/,
431 __in_ecount_z_opt(cData) LPCWSTR* /*rgwzData*/,
432 __in int /*nRecommendation*/,
433 __inout int* /*pResult*/
434 )
435 {
436 return S_OK;
437 }
438
439 virtual STDMETHODIMP OnRegisterBegin(
440 __in BOOTSTRAPPER_REGISTRATION_TYPE /*recommendedRegistrationType*/,
441 __inout BOOL* /*pfCancel*/,
442 __inout BOOTSTRAPPER_REGISTRATION_TYPE* /*pRegistrationType*/
443 )
444 {
445 return S_OK;
446 }
447
448 virtual STDMETHODIMP OnRegisterComplete(
449 __in HRESULT /*hrStatus*/
450 )
451 {
452 return S_OK;
453 }
454
455 virtual STDMETHODIMP OnCacheBegin(
456 __inout BOOL* /*pfCancel*/
457 )
458 {
459 return S_OK;
460 }
461
462 virtual STDMETHODIMP OnCachePackageBegin(
463 __in_z LPCWSTR /*wzPackageId*/,
464 __in DWORD /*cCachePayloads*/,
465 __in DWORD64 /*dw64PackageCacheSize*/,
466 __in BOOL /*fVital*/,
467 __inout BOOL* /*pfCancel*/
468 )
469 {
470 return S_OK;
471 }
472
473 virtual STDMETHODIMP OnCacheAcquireBegin(
474 __in_z LPCWSTR /*wzPackageOrContainerId*/,
475 __in_z_opt LPCWSTR /*wzPayloadId*/,
476 __in_z LPCWSTR /*wzSource*/,
477 __in_z_opt LPCWSTR /*wzDownloadUrl*/,
478 __in_z_opt LPCWSTR /*wzPayloadContainerId*/,
479 __in BOOTSTRAPPER_CACHE_OPERATION /*recommendation*/,
480 __inout BOOTSTRAPPER_CACHE_OPERATION* /*pAction*/,
481 __inout BOOL* /*pfCancel*/
482 )
483 {
484 return S_OK;
485 }
486
487 virtual STDMETHODIMP OnCacheAcquireProgress(
488 __in_z LPCWSTR /*wzPackageOrContainerId*/,
489 __in_z_opt LPCWSTR /*wzPayloadId*/,
490 __in DWORD64 /*dw64Progress*/,
491 __in DWORD64 /*dw64Total*/,
492 __in DWORD /*dwOverallPercentage*/,
493 __inout BOOL* /*pfCancel*/
494 )
495 {
496 return S_OK;
497 }
498
499 virtual STDMETHODIMP OnCacheAcquireResolving(
500 __in_z_opt LPCWSTR /*wzPackageOrContainerId*/,
501 __in_z_opt LPCWSTR /*wzPayloadId*/,
502 __in_z LPCWSTR* /*rgSearchPaths*/,
503 __in DWORD /*cSearchPaths*/,
504 __in BOOL /*fFoundLocal*/,
505 __in DWORD /*dwRecommendedSearchPath*/,
506 __in_z_opt LPCWSTR /*wzDownloadUrl*/,
507 __in_z_opt LPCWSTR /*wzPayloadContainerId*/,
508 __in BOOTSTRAPPER_CACHE_RESOLVE_OPERATION /*recommendation*/,
509 __inout DWORD* /*pdwChosenSearchPath*/,
510 __inout BOOTSTRAPPER_CACHE_RESOLVE_OPERATION* /*pAction*/,
511 __inout BOOL* /*pfCancel*/
512 )
513 {
514 return S_OK;
515 }
516
517 virtual STDMETHODIMP OnCacheAcquireComplete(
518 __in_z LPCWSTR /*wzPackageOrContainerId*/,
519 __in_z_opt LPCWSTR /*wzPayloadId*/,
520 __in HRESULT /*hrStatus*/,
521 __in BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION /*recommendation*/,
522 __inout BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION* /*pAction*/
523 )
524 {
525 return S_OK;
526 }
527
528 virtual STDMETHODIMP OnCacheVerifyBegin(
529 __in_z LPCWSTR /*wzPackageOrContainerId*/,
530 __in_z LPCWSTR /*wzPayloadId*/,
531 __inout BOOL* /*pfCancel*/
532 )
533 {
534 return S_OK;
535 }
536
537 virtual STDMETHODIMP OnCacheVerifyProgress(
538 __in_z_opt LPCWSTR /*wzPackageOrContainerId*/,
539 __in_z_opt LPCWSTR /*wzPayloadId*/,
540 __in DWORD64 /*dw64Progress*/,
541 __in DWORD64 /*dw64Total*/,
542 __in DWORD /*dwOverallPercentage*/,
543 __in BOOTSTRAPPER_CACHE_VERIFY_STEP /*verifyStep*/,
544 __inout BOOL* /*pfCancel*/
545 )
546 {
547 return S_OK;
548 }
549
550 virtual STDMETHODIMP OnCacheVerifyComplete(
551 __in_z LPCWSTR /*wzPackageOrContainerId*/,
552 __in_z LPCWSTR /*wzPayloadId*/,
553 __in HRESULT /*hrStatus*/,
554 __in BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION /*recommendation*/,
555 __inout BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION* /*pAction*/
556 )
557 {
558 return S_OK;
559 }
560
561 virtual STDMETHODIMP OnCachePackageComplete(
562 __in_z LPCWSTR /*wzPackageId*/,
563 __in HRESULT /*hrStatus*/,
564 __in BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION /*recommendation*/,
565 __inout BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION* /*pAction*/
566 )
567 {
568 return S_OK;
569 }
570
571 virtual STDMETHODIMP OnCacheComplete(
572 __in HRESULT /*hrStatus*/
573 )
574 {
575 return S_OK;
576 }
577
578 virtual STDMETHODIMP OnExecuteBegin(
579 __in DWORD /*cExecutingPackages*/,
580 __inout BOOL* /*pfCancel*/
581 )
582 {
583 return S_OK;
584 }
585
586 virtual STDMETHODIMP OnExecutePackageBegin(
587 __in_z LPCWSTR /*wzPackageId*/,
588 __in BOOL /*fExecute*/,
589 __in BOOTSTRAPPER_ACTION_STATE /*action*/,
590 __in INSTALLUILEVEL /*uiLevel*/,
591 __in BOOL /*fDisableExternalUiHandler*/,
592 __inout BOOL* /*pfCancel*/
593 )
594 {
595 return S_OK;
596 }
597
598 virtual STDMETHODIMP OnExecutePatchTarget(
599 __in_z LPCWSTR /*wzPackageId*/,
600 __in_z LPCWSTR /*wzTargetProductCode*/,
601 __inout BOOL* /*pfCancel*/
602 )
603 {
604 return S_OK;
605 }
606
607 virtual STDMETHODIMP OnExecuteProgress(
608 __in_z LPCWSTR /*wzPackageId*/,
609 __in DWORD /*dwProgressPercentage*/,
610 __in DWORD /*dwOverallProgressPercentage*/,
611 __inout BOOL* /*pfCancel*/
612 )
613 {
614 return S_OK;
615 }
616
617 virtual STDMETHODIMP OnExecuteMsiMessage(
618 __in_z LPCWSTR /*wzPackageId*/,
619 __in INSTALLMESSAGE /*messageType*/,
620 __in DWORD /*dwUIHint*/,
621 __in_z LPCWSTR /*wzMessage*/,
622 __in DWORD /*cData*/,
623 __in_ecount_z_opt(cData) LPCWSTR* /*rgwzData*/,
624 __in int /*nRecommendation*/,
625 __inout int* /*pResult*/
626 )
627 {
628 return S_OK;
629 }
630
631 virtual STDMETHODIMP OnExecuteFilesInUse(
632 __in_z LPCWSTR /*wzPackageId*/,
633 __in DWORD /*cFiles*/,
634 __in_ecount_z(cFiles) LPCWSTR* /*rgwzFiles*/,
635 __in int /*nRecommendation*/,
636 __in BOOTSTRAPPER_FILES_IN_USE_TYPE /*source*/,
637 __inout int* /*pResult*/
638 )
639 {
640 return S_OK;
641 }
642
643 virtual STDMETHODIMP OnExecutePackageComplete(
644 __in_z LPCWSTR /*wzPackageId*/,
645 __in HRESULT /*hrStatus*/,
646 __in BOOTSTRAPPER_APPLY_RESTART /*restart*/,
647 __in BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION /*recommendation*/,
648 __inout BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION* /*pAction*/
649 )
650 {
651 return S_OK;
652 }
653
654 virtual STDMETHODIMP OnExecuteComplete(
655 __in HRESULT /*hrStatus*/
656 )
657 {
658 return S_OK;
659 }
660
661 virtual STDMETHODIMP OnUnregisterBegin(
662 __in BOOTSTRAPPER_REGISTRATION_TYPE /*recommendedRegistrationType*/,
663 __inout BOOTSTRAPPER_REGISTRATION_TYPE* /*pRegistrationType*/
664 )
665 {
666 return S_OK;
667 }
668
669 virtual STDMETHODIMP OnUnregisterComplete(
670 __in HRESULT /*hrStatus*/
671 )
672 {
673 return S_OK;
674 }
675
676 virtual STDMETHODIMP OnApplyComplete(
677 __in HRESULT /*hrStatus*/,
678 __in BOOTSTRAPPER_APPLY_RESTART /*restart*/,
679 __in BOOTSTRAPPER_APPLYCOMPLETE_ACTION /*recommendation*/,
680 __inout BOOTSTRAPPER_APPLYCOMPLETE_ACTION* /*pAction*/
681 )
682 {
683 return S_OK;
684 }
685
686 virtual STDMETHODIMP OnLaunchApprovedExeBegin(
687 __inout BOOL* /*pfCancel*/
688 )
689 {
690 return S_OK;
691 }
692
693 virtual STDMETHODIMP OnLaunchApprovedExeComplete(
694 __in HRESULT /*hrStatus*/,
695 __in DWORD /*dwProcessId*/
696 )
697 {
698 return S_OK;
699 }
700
701 virtual STDMETHODIMP OnBeginMsiTransactionBegin(
702 __in_z LPCWSTR /*wzTransactionId*/,
703 __inout BOOL* /*pfCancel*/
704 )
705 {
706 return S_OK;
707 }
708
709 virtual STDMETHODIMP OnBeginMsiTransactionComplete(
710 __in_z LPCWSTR /*wzTransactionId*/,
711 __in HRESULT /*hrStatus*/
712 )
713 {
714 return S_OK;
715 }
716
717 virtual STDMETHODIMP OnCommitMsiTransactionBegin(
718 __in_z LPCWSTR /*wzTransactionId*/,
719 __inout BOOL* /*pfCancel*/
720 )
721 {
722 return S_OK;
723 }
724
725 virtual STDMETHODIMP OnCommitMsiTransactionComplete(
726 __in_z LPCWSTR /*wzTransactionId*/,
727 __in HRESULT /*hrStatus*/,
728 __in BOOTSTRAPPER_APPLY_RESTART /*restart*/,
729 __in BOOTSTRAPPER_EXECUTEMSITRANSACTIONCOMPLETE_ACTION /*recommendation*/,
730 __inout BOOTSTRAPPER_EXECUTEMSITRANSACTIONCOMPLETE_ACTION* /*pAction*/
731 )
732 {
733 return S_OK;
734 }
735
736 virtual STDMETHODIMP OnRollbackMsiTransactionBegin(
737 __in_z LPCWSTR /*wzTransactionId*/
738 )
739 {
740 return S_OK;
741 }
742
743 virtual STDMETHODIMP OnRollbackMsiTransactionComplete(
744 __in_z LPCWSTR /*wzTransactionId*/,
745 __in HRESULT /*hrStatus*/,
746 __in BOOTSTRAPPER_APPLY_RESTART /*restart*/,
747 __in BOOTSTRAPPER_EXECUTEMSITRANSACTIONCOMPLETE_ACTION /*recommendation*/,
748 __inout BOOTSTRAPPER_EXECUTEMSITRANSACTIONCOMPLETE_ACTION* /*pAction*/
749 )
750 {
751 return S_OK;
752 }
753
754 virtual STDMETHODIMP OnPauseAutomaticUpdatesBegin(
755 )
756 {
757 return S_OK;
758 }
759
760 virtual STDMETHODIMP OnPauseAutomaticUpdatesComplete(
761 __in HRESULT /*hrStatus*/
762 )
763 {
764 return S_OK;
765 }
766
767 virtual STDMETHODIMP OnSystemRestorePointBegin(
768 )
769 {
770 return S_OK;
771 }
772
773 virtual STDMETHODIMP OnSystemRestorePointComplete(
774 __in HRESULT /*hrStatus*/
775 )
776 {
777 return S_OK;
778 }
779
780 virtual STDMETHODIMP OnPlanForwardCompatibleBundle(
781 __in_z LPCWSTR /*wzBundleId*/,
782 __in BOOTSTRAPPER_RELATION_TYPE /*relationType*/,
783 __in_z LPCWSTR /*wzBundleTag*/,
784 __in BOOL /*fPerMachine*/,
785 __in LPCWSTR /*wzVersion*/,
786 __in BOOL /*fRecommendedIgnoreBundle*/,
787 __inout BOOL* /*pfCancel*/,
788 __inout BOOL* /*pfIgnoreBundle*/
789 )
790 {
791 return S_OK;
792 }
793
794 virtual STDMETHODIMP OnCacheContainerOrPayloadVerifyBegin(
795 __in_z_opt LPCWSTR /*wzPackageOrContainerId*/,
796 __in_z_opt LPCWSTR /*wzPayloadId*/,
797 __inout BOOL* /*pfCancel*/
798 )
799 {
800 return S_OK;
801 }
802
803 virtual STDMETHODIMP OnCacheContainerOrPayloadVerifyProgress(
804 __in_z_opt LPCWSTR /*wzPackageOrContainerId*/,
805 __in_z_opt LPCWSTR /*wzPayloadId*/,
806 __in DWORD64 /*dw64Progress*/,
807 __in DWORD64 /*dw64Total*/,
808 __in DWORD /*dwOverallPercentage*/,
809 __inout BOOL* /*pfCancel*/
810 )
811 {
812 return S_OK;
813 }
814
815 virtual STDMETHODIMP OnCacheContainerOrPayloadVerifyComplete(
816 __in_z_opt LPCWSTR /*wzPackageOrContainerId*/,
817 __in_z_opt LPCWSTR /*wzPayloadId*/,
818 __in HRESULT /*hrStatus*/
819 )
820 {
821 return S_OK;
822 }
823
824 virtual STDMETHODIMP OnCachePayloadExtractBegin(
825 __in_z_opt LPCWSTR /*wzPackageOrContainerId*/,
826 __in_z_opt LPCWSTR /*wzPayloadId*/,
827 __inout BOOL* /*pfCancel*/
828 )
829 {
830 return S_OK;
831 }
832
833 virtual STDMETHODIMP OnCachePayloadExtractProgress(
834 __in_z_opt LPCWSTR /*wzPackageOrContainerId*/,
835 __in_z_opt LPCWSTR /*wzPayloadId*/,
836 __in DWORD64 /*dw64Progress*/,
837 __in DWORD64 /*dw64Total*/,
838 __in DWORD /*dwOverallPercentage*/,
839 __inout BOOL* /*pfCancel*/
840 )
841 {
842 return S_OK;
843 }
844
845 virtual STDMETHODIMP OnCachePayloadExtractComplete(
846 __in_z_opt LPCWSTR /*wzPackageOrContainerId*/,
847 __in_z_opt LPCWSTR /*wzPayloadId*/,
848 __in HRESULT /*hrStatus*/
849 )
850 {
851 return S_OK;
852 }
853
854 virtual STDMETHODIMP OnPlanRestoreRelatedBundle(
855 __in_z LPCWSTR /*wzBundleId*/,
856 __in BOOTSTRAPPER_REQUEST_STATE /*recommendedState*/,
857 __inout BOOTSTRAPPER_REQUEST_STATE* /*pRequestedState*/,
858 __inout BOOL* /*pfCancel*/
859 )
860 {
861 return S_OK;
862 }
863
864 virtual STDMETHODIMP OnPlanRelatedBundleType(
865 __in_z LPCWSTR /*wzBundleId*/,
866 __in BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE /*recommendedType*/,
867 __inout BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE* /*pRequestedType*/,
868 __inout BOOL* /*pfCancel*/
869 )
870 {
871 return S_OK;
872 }
873
874 virtual STDMETHODIMP OnApplyDowngrade(
875 __in HRESULT /*hrRecommended*/,
876 __in HRESULT* /*phrStatus*/
877 )
878 {
879 return S_OK;
880 }
881
882 virtual STDMETHODIMP OnExecuteProcessCancel(
883 __in_z LPCWSTR /*wzPackageId*/,
884 __in DWORD /*dwProcessId*/,
885 __in BOOTSTRAPPER_EXECUTEPROCESSCANCEL_ACTION /*recommendation*/,
886 __inout BOOTSTRAPPER_EXECUTEPROCESSCANCEL_ACTION* /*pAction*/
887 )
888 {
889 return S_OK;
890 }
891
892 virtual STDMETHODIMP OnDetectRelatedBundlePackage(
893 __in_z LPCWSTR /*wzPackageId*/,
894 __in_z LPCWSTR /*wzBundleId*/,
895 __in BOOTSTRAPPER_RELATION_TYPE /*relationType*/,
896 __in BOOL /*fPerMachine*/,
897 __in LPCWSTR /*wzVersion*/,
898 __inout BOOL* /*pfCancel*/
899 )
900 {
901 return S_OK;
902 }
903
904 virtual STDMETHODIMP OnCachePackageNonVitalValidationFailure(
905 __in_z LPCWSTR /*wzPackageId*/,
906 __in HRESULT /*hrStatus*/,
907 __in BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION /*recommendation*/,
908 __inout BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION* /*pAction*/
909 )
910 {
911 return S_OK;
912 }
913
914public: // IBAFunctions
915 virtual STDMETHODIMP OnPlan(
916 )
917 {
918 return S_OK;
919 }
920
921 virtual STDMETHODIMP OnThemeLoaded(
922 __in HWND hWnd
923 )
924 {
925 HRESULT hr = S_OK;
926
927 m_hwndParent = hWnd;
928
929 return hr;
930 }
931
932 virtual STDMETHODIMP WndProc(
933 __in HWND /*hWnd*/,
934 __in UINT /*uMsg*/,
935 __in WPARAM /*wParam*/,
936 __in LPARAM /*lParam*/,
937 __inout BOOL* /*pfProcessed*/,
938 __inout LRESULT* /*plResult*/
939 )
940 {
941 return S_OK;
942 }
943
944 virtual STDMETHODIMP BAFunctionsProc(
945 __in BA_FUNCTIONS_MESSAGE /*message*/,
946 __in const LPVOID /*pvArgs*/,
947 __inout LPVOID /*pvResults*/,
948 __in_opt LPVOID /*pvContext*/
949 )
950 {
951 return E_NOTIMPL;
952 }
953
954 virtual STDMETHODIMP OnThemeControlLoading(
955 __in LPCWSTR /*wzName*/,
956 __inout BOOL* /*pfProcessed*/,
957 __inout WORD* /*pwId*/,
958 __inout DWORD* /*pdwAutomaticBehaviorType*/
959 )
960 {
961 return S_OK;
962 }
963
964 virtual STDMETHODIMP OnThemeControlWmCommand(
965 __in WPARAM /*wParam*/,
966 __in LPCWSTR /*wzName*/,
967 __in WORD /*wId*/,
968 __in HWND /*hWnd*/,
969 __inout BOOL* /*pfProcessed*/,
970 __inout LRESULT* /*plResult*/
971 )
972 {
973 return S_OK;
974 }
975
976 virtual STDMETHODIMP OnThemeControlWmNotify(
977 __in LPNMHDR /*lParam*/,
978 __in LPCWSTR /*wzName*/,
979 __in WORD /*wId*/,
980 __in HWND /*hWnd*/,
981 __inout BOOL* /*pfProcessed*/,
982 __inout LRESULT* /*plResult*/
983 )
984 {
985 return S_OK;
986 }
987
988 virtual STDMETHODIMP OnThemeControlLoaded(
989 __in LPCWSTR /*wzName*/,
990 __in WORD /*wId*/,
991 __in HWND /*hWnd*/,
992 __inout BOOL* /*pfProcessed*/
993 )
994 {
995 return S_OK;
996 }
997
998protected:
999 CBalBaseBAFunctions(HMODULE hModule)
1000 {
1001 m_cReferences = 1;
1002 m_hModule = hModule;
1003
1004 m_hwndParent = NULL;
1005 m_pEngine = NULL;
1006 }
1007
1008 virtual ~CBalBaseBAFunctions()
1009 {
1010 ReleaseNullObject(m_pEngine);
1011 }
1012
1013private:
1014 long m_cReferences;
1015
1016protected:
1017 IBootstrapperEngine* m_pEngine;
1018 HMODULE m_hModule;
1019 HWND m_hwndParent;
1020};
diff --git a/src/api/burn/balutil/inc/BalBaseBAFunctionsProc.h b/src/api/burn/balutil/inc/BalBaseBAFunctionsProc.h
deleted file mode 100644
index 65eeb0b4..00000000
--- a/src/api/burn/balutil/inc/BalBaseBAFunctionsProc.h
+++ /dev/null
@@ -1,15 +0,0 @@
1#pragma once
2// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
3
4/*******************************************************************
5BalBaseBAFunctionsProc - requires pvContext to be of type IBAFunctions.
6Provides a default mapping between the message based BAFunctions interface and
7the COM-based BAFunctions interface.
8
9*******************************************************************/
10HRESULT WINAPI BalBaseBAFunctionsProc(
11 __in BA_FUNCTIONS_MESSAGE message,
12 __in const LPVOID pvArgs,
13 __inout LPVOID pvResults,
14 __in_opt LPVOID pvContext
15 );
diff --git a/src/api/burn/balutil/inc/IBAFunctions.h b/src/api/burn/balutil/inc/IBAFunctions.h
deleted file mode 100644
index 42b64f9b..00000000
--- a/src/api/burn/balutil/inc/IBAFunctions.h
+++ /dev/null
@@ -1,75 +0,0 @@
1#pragma once
2// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
3
4
5#include "IBootstrapperApplication.h"
6#include "BAFunctions.h"
7
8DECLARE_INTERFACE_IID_(IBAFunctions, IBootstrapperApplication, "0FB445ED-17BD-49C7-BE19-479776F8AE96")
9{
10 // OnThemeLoaded - Called after the BA finished loading all the controls for the theme.
11 //
12 STDMETHOD(OnThemeLoaded)(
13 __in HWND hWnd
14 ) = 0;
15
16 // WndProc - Called if the BA hasn't handled the message.
17 //
18 STDMETHOD(WndProc)(
19 __in HWND hWnd,
20 __in UINT uMsg,
21 __in WPARAM wParam,
22 __in LPARAM lParam,
23 __inout BOOL* pfProcessed,
24 __inout LRESULT* plResult
25 ) = 0;
26
27 // BAFunctionsProc - The PFN_BA_FUNCTIONS_PROC can call this method to give the BAFunctions raw access to the callback from WixStdBA.
28 // This might be used to help the BAFunctions support more than one version of the engine/WixStdBA.
29 STDMETHOD(BAFunctionsProc)(
30 __in BA_FUNCTIONS_MESSAGE message,
31 __in const LPVOID pvArgs,
32 __inout LPVOID pvResults,
33 __in_opt LPVOID pvContext
34 ) = 0;
35
36 // OnThemeControlLoading - Called while creating a control for the theme.
37 //
38 STDMETHOD(OnThemeControlLoading)(
39 __in LPCWSTR wzName,
40 __inout BOOL* pfProcessed,
41 __inout WORD* pwId,
42 __inout DWORD* pdwAutomaticBehaviorType
43 ) = 0;
44
45 // OnThemeControlWmCommand - Called when WM_COMMAND is received for a control.
46 //
47 STDMETHOD(OnThemeControlWmCommand)(
48 __in WPARAM wParam,
49 __in LPCWSTR wzName,
50 __in WORD wId,
51 __in HWND hWnd,
52 __inout BOOL* pfProcessed,
53 __inout LRESULT* plResult
54 ) = 0;
55
56 // OnThemeControlWmNotify - Called when WM_NOTIFY is received for a control.
57 //
58 STDMETHOD(OnThemeControlWmNotify)(
59 __in LPNMHDR lParam,
60 __in LPCWSTR wzName,
61 __in WORD wId,
62 __in HWND hWnd,
63 __inout BOOL* pfProcessed,
64 __inout LRESULT* plResult
65 ) = 0;
66
67 // OnThemeControlLoaded - Called after a control was created for the theme.
68 //
69 STDMETHOD(OnThemeControlLoaded)(
70 __in LPCWSTR wzName,
71 __in WORD wId,
72 __in HWND hWnd,
73 __inout BOOL* pfProcessed
74 ) = 0;
75};
diff --git a/src/api/burn/balutil/precomp.h b/src/api/burn/balutil/precomp.h
index 68e07a44..753bc21f 100644
--- a/src/api/burn/balutil/precomp.h
+++ b/src/api/burn/balutil/precomp.h
@@ -30,13 +30,11 @@
30#include <thmutil.h> 30#include <thmutil.h>
31#include <xmlutil.h> 31#include <xmlutil.h>
32 32
33#include "IBAFunctions.h" 33#include "IBootstrapperApplication.h"
34 34
35#include "balutil.h" 35#include "balutil.h"
36#include "BalBootstrapperEngine.h" 36#include "BalBootstrapperEngine.h"
37#include "balcondition.h" 37#include "balcondition.h"
38#include "balinfo.h" 38#include "balinfo.h"
39#include "balretry.h" 39#include "balretry.h"
40
41#include "BalBaseBAFunctionsProc.h"
42#include "msg.h" 40#include "msg.h"
diff --git a/src/api/burn/inc/BootstrapperApplication.h b/src/api/burn/inc/BootstrapperApplication.h
index 79b1df80..8b945b77 100644
--- a/src/api/burn/inc/BootstrapperApplication.h
+++ b/src/api/burn/inc/BootstrapperApplication.h
@@ -729,21 +729,6 @@ struct BA_ONCREATE_ARGS
729{ 729{
730 DWORD dwApiVersion; 730 DWORD dwApiVersion;
731 BOOTSTRAPPER_COMMAND command; 731 BOOTSTRAPPER_COMMAND command;
732 // BOOTSTRAPPER_ACTION action;
733 // BOOTSTRAPPER_DISPLAY display;
734
735 // LPWSTR wzCommandLine;
736 // INT32 nCmdShow;
737
738 // BOOTSTRAPPER_RESUME_TYPE resumeType;
739 // HWND hwndSplashScreen;
740
741 // BOOTSTRAPPER_RELATION_TYPE relationType;
742 // BOOL fPassthrough;
743
744 // LPWSTR wzLayoutDirectory;
745 // LPWSTR wzBootstrapperWorkingFolder;
746 // LPWSTR wzBootstrapperApplicationDataPath;
747}; 732};
748 733
749struct BA_ONCREATE_RESULTS 734struct BA_ONCREATE_RESULTS
diff --git a/src/api/burn/test/BalUtilUnitTest/BAFunctionsTests.cpp b/src/api/burn/test/BalUtilUnitTest/BAFunctionsTests.cpp
deleted file mode 100644
index ba04c1bb..00000000
--- a/src/api/burn/test/BalUtilUnitTest/BAFunctionsTests.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
1// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
2
3#include "precomp.h"
4
5using namespace System;
6using namespace Xunit;
7using namespace WixInternal::TestSupport;
8using namespace WixInternal::TestSupport::XunitExtensions;
9
10namespace BalUtilTests
11{
12 public ref class BAFunctions
13 {
14 public:
15 [Fact(Skip = "Need a mock implementation of IBootstrapperEngine to test BAFunctions.")]
16 void CanCreateTestBAFunctions()
17 {
18 HRESULT hr = S_OK;
19 BA_FUNCTIONS_CREATE_ARGS args = { };
20 BA_FUNCTIONS_CREATE_RESULTS results = { };
21 IBootstrapperEngine* pEngine = NULL;
22 BOOTSTRAPPER_COMMAND command = { };
23 IBAFunctions* pBAFunctions = NULL;
24
25 args.cbSize = sizeof(args);
26 args.pEngine = pEngine;
27 args.pCommand = &command;
28
29 results.cbSize = sizeof(results);
30
31 try
32 {
33 BalInitialize(pEngine);
34
35 hr = CreateBAFunctions(NULL, &args, &results);
36 NativeAssert::Succeeded(hr, "Failed to create BAFunctions.");
37
38 pBAFunctions = reinterpret_cast<IBAFunctions*>(results.pvBAFunctionsProcContext);
39 }
40 finally
41 {
42 ReleaseObject(pEngine);
43 ReleaseObject(pBAFunctions);
44 }
45 }
46 };
47}
diff --git a/src/api/burn/test/BalUtilUnitTest/BalUtilUnitTest.vcxproj b/src/api/burn/test/BalUtilUnitTest/BalUtilUnitTest.vcxproj
index de79fe33..114ab26d 100644
--- a/src/api/burn/test/BalUtilUnitTest/BalUtilUnitTest.vcxproj
+++ b/src/api/burn/test/BalUtilUnitTest/BalUtilUnitTest.vcxproj
@@ -37,20 +37,17 @@
37 </PropertyGroup> 37 </PropertyGroup>
38 38
39 <ItemGroup> 39 <ItemGroup>
40 <ClCompile Include="BAFunctionsTests.cpp" />
41 <ClCompile Include="BootstrapperApplicationTests.cpp" /> 40 <ClCompile Include="BootstrapperApplicationTests.cpp" />
42 <ClCompile Include="precomp.cpp"> 41 <ClCompile Include="precomp.cpp">
43 <PrecompiledHeader>Create</PrecompiledHeader> 42 <PrecompiledHeader>Create</PrecompiledHeader>
44 <!-- Warnings from referencing netstandard dlls --> 43 <!-- Warnings from referencing netstandard dlls -->
45 <DisableSpecificWarnings>4564;4691</DisableSpecificWarnings> 44 <DisableSpecificWarnings>4564;4691</DisableSpecificWarnings>
46 </ClCompile> 45 </ClCompile>
47 <ClCompile Include="TestBAFunctions.cpp" />
48 <ClCompile Include="TestBootstrapperApplication.cpp" /> 46 <ClCompile Include="TestBootstrapperApplication.cpp" />
49 </ItemGroup> 47 </ItemGroup>
50 48
51 <ItemGroup> 49 <ItemGroup>
52 <ClInclude Include="precomp.h" /> 50 <ClInclude Include="precomp.h" />
53 <ClInclude Include="TestBAFunctions.h" />
54 <ClInclude Include="TestBootstrapperApplication.h" /> 51 <ClInclude Include="TestBootstrapperApplication.h" />
55 </ItemGroup> 52 </ItemGroup>
56 53
diff --git a/src/api/burn/test/BalUtilUnitTest/TestBAFunctions.cpp b/src/api/burn/test/BalUtilUnitTest/TestBAFunctions.cpp
deleted file mode 100644
index 3e850442..00000000
--- a/src/api/burn/test/BalUtilUnitTest/TestBAFunctions.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
1// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
2
3#include "precomp.h"
4#include "BalBaseBAFunctions.h"
5#include "BalBaseBAFunctionsProc.h"
6
7class CTestBAFunctions : public CBalBaseBAFunctions
8{
9public:
10 CTestBAFunctions(
11 __in HMODULE hModule
12 ) : CBalBaseBAFunctions(hModule)
13 {
14 }
15};
16
17HRESULT CreateBAFunctions(
18 __in HMODULE hModule,
19 __in const BA_FUNCTIONS_CREATE_ARGS* pArgs,
20 __inout BA_FUNCTIONS_CREATE_RESULTS* pResults
21 )
22{
23 HRESULT hr = S_OK;
24 CTestBAFunctions* pFunction = NULL;
25
26 pFunction = new CTestBAFunctions(hModule);
27 ExitOnNull(pFunction, hr, E_OUTOFMEMORY, "Failed to create new test bafunctions object.");
28
29 hr = pFunction->OnCreate(pArgs->pEngine, pArgs->pCommand);
30 ExitOnFailure(hr, "Failed to initialize new test bafunctions.");
31
32 pResults->pfnBAFunctionsProc = BalBaseBAFunctionsProc;
33 pResults->pvBAFunctionsProcContext = pFunction;
34 pFunction = NULL;
35
36LExit:
37 ReleaseObject(pFunction);
38 return hr;
39}
diff --git a/src/api/burn/test/BalUtilUnitTest/TestBAFunctions.h b/src/api/burn/test/BalUtilUnitTest/TestBAFunctions.h
deleted file mode 100644
index e25e40c3..00000000
--- a/src/api/burn/test/BalUtilUnitTest/TestBAFunctions.h
+++ /dev/null
@@ -1,8 +0,0 @@
1#pragma once
2// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
3
4HRESULT CreateBAFunctions(
5 __in HMODULE hModule,
6 __in const BA_FUNCTIONS_CREATE_ARGS* pArgs,
7 __inout BA_FUNCTIONS_CREATE_RESULTS* pResults
8 );
diff --git a/src/api/burn/test/BalUtilUnitTest/precomp.h b/src/api/burn/test/BalUtilUnitTest/precomp.h
index 4cdd262c..78add593 100644
--- a/src/api/burn/test/BalUtilUnitTest/precomp.h
+++ b/src/api/burn/test/BalUtilUnitTest/precomp.h
@@ -16,11 +16,9 @@
16#include <dictutil.h> 16#include <dictutil.h>
17 17
18#include <IBootstrapperApplication.h> 18#include <IBootstrapperApplication.h>
19#include <IBAFunctions.h>
20#include <balutil.h> 19#include <balutil.h>
21#include <balretry.h> 20#include <balretry.h>
22 21
23#include "TestBAFunctions.h"
24#include "TestBootstrapperApplication.h" 22#include "TestBootstrapperApplication.h"
25 23
26#pragma managed 24#pragma managed
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-17 21:32:25 +0000