[prev in list] [next in list] [prev in thread] [next in thread]
List: wine-devel
Subject: msi automation patches
From: Misha Koshelev <mk144210 () bcm ! tmc ! edu>
Date: 2007-02-28 18:28:46
Message-ID: 1172687327.27209.6.camel () misha-laptop
[Download RAW message or body]
Ok, so since my patches weren't commited to git yet, I've consolidated
the new automation changes I've made in the attached patches. James and
Rob, if they look good to you I will submit these version to
wine-patches (so my total will once again be four patches, 1 is
http://www.winehq.org/pipermail/wine-patches/2007-February/036359.html ,
2 and 3 attached, and 4 is
http://www.winehq.org/pipermail/wine-patches/2007-February/036362.html ) and
wait to submit anything more for automation until all 4 patches are in.
Please let me know Rob (I used DispGetParam, thanks a lot, so probably just need to
look at my AutomationObject::Invoke and then the individual object Invoke handlers in
the 0003 patch below) and James (I guess in regards to comments and formatting).
Thanks a lot
Misha
[Attachment #3 (unknown)]
From 7a26ec8da0ca6d2b031a35191a865882cf5a64b4 Mon Sep 17 00:00:00 2001
From: Misha Koshelev <mk144210@bcm.tmc.edu>
Date: Wed, 28 Feb 2007 12:08:52 -0600
Subject: msi: Expand IDL file to contain all OLE automation interfaces.
---
dlls/msi/msiserver.idl | 873 +++++++++++++++++++++++++++++++++++++++---
dlls/msi/msiserver_dispids.h | 180 +++++++++
2 files changed, 993 insertions(+), 60 deletions(-)
diff --git a/dlls/msi/msiserver.idl b/dlls/msi/msiserver.idl
index 9966d90..8735b7c 100644
--- a/dlls/msi/msiserver.idl
+++ b/dlls/msi/msiserver.idl
@@ -1,5 +1,6 @@
/*
* Copyright (C) 2007 Mike McCormack
+ * Copyright (C) 2007 Misha Koshelev
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -16,14 +17,21 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
+#include "msiserver_dispids.h"
import "unknwn.idl";
import "wtypes.idl";
import "objidl.idl";
import "oaidl.idl";
-[ uuid(000C1092-0000-0000-C000-000000000046), version(1.0) ]
+[
+ uuid(000C1092-0000-0000-C000-000000000046),
+ version(1.0),
+ helpstring("Microsoft Windows Installer Object Library")
+]
library WindowsInstaller
{
+ /* TLib :
+ * Forward declare all types defined in this typelib */
dispinterface Installer;
dispinterface Record;
dispinterface Session;
@@ -37,87 +45,832 @@ library WindowsInstaller
dispinterface Product;
dispinterface Patch;
- [ uuid(000C1090-0000-0000-C000-000000000046) ]
- dispinterface Installer
- {
- properties:
- methods:
- }
-
- [ uuid(000C1093-0000-0000-C000-000000000046) ]
- dispinterface Record
- {
- properties:
- methods:
- }
-
- [ uuid(000C1095-0000-0000-C000-000000000046) ]
- dispinterface StringList
- {
+ typedef enum {
+ msiUILevelNoChange = 0,
+ msiUILevelDefault = 1,
+ msiUILevelNone = 2,
+ msiUILevelBasic = 3,
+ msiUILevelReduced = 4,
+ msiUILevelFull = 5,
+ msiUILevelHideCancel = 32,
+ msiUILevelProgressOnly = 64,
+ msiUILevelEndDialog = 128,
+ msiUILevelSourceResOnly = 256
+ } MsiUILevel;
+
+ typedef enum {
+ msiInstallStateNotUsed = -7,
+ msiInstallStateBadConfig = -6,
+ msiInstallStateIncomplete = -5,
+ msiInstallStateSourceAbsent = -4,
+ msiInstallStateInvalidArg = -2,
+ msiInstallStateUnknown = -1,
+ msiInstallStateBroken = 0,
+ msiInstallStateAdvertised = 1,
+ msiInstallStateRemoved = 1,
+ msiInstallStateAbsent = 2,
+ msiInstallStateLocal = 3,
+ msiInstallStateSource = 4,
+ msiInstallStateDefault = 5
+ } MsiInstallState;
+
+ typedef enum {
+ msiReinstallModeFileMissing = 2,
+ msiReinstallModeFileOlderVersion = 4,
+ msiReinstallModeFileEqualVersion = 8,
+ msiReinstallModeFileExact = 16,
+ msiReinstallModeFileVerify = 32,
+ msiReinstallModeFileReplace = 64,
+ msiReinstallModeMachineData = 128,
+ msiReinstallModeUserData = 256,
+ msiReinstallModeShortcut = 512,
+ msiReinstallModePackage = 1024
+ } MsiReinstallMode;
+
+ typedef enum {
+ msiInstallTypeDefault = 0,
+ msiInstallTypeNetworkImage = 1,
+ msiInstallTypeSingleInstance = 2
+ } MsiInstallType;
+
+ typedef enum {
+ msiInstallModeNoSourceResolution = -3,
+ msiInstallModeNoDetection = -2,
+ msiInstallModeExisting = -1,
+ msiInstallModeDefault = 0
+ } MsiInstallMode;
+
+ typedef enum {
+ msiSignatureInfoCertificate = 0,
+ msiSignatureInfoHash = 1
+ } MsiSignatureInfo;
+
+ typedef enum {
+ msiReadStreamInteger = 0,
+ msiReadStreamBytes = 1,
+ msiReadStreamAnsi = 2,
+ msiReadStreamDirect = 3
+ } MsiReadStream;
+
+ typedef enum {
+ msiRunModeAdmin = 0,
+ msiRunModeAdvertise = 1,
+ msiRunModeMaintenance = 2,
+ msiRunModeRollbackEnabled = 3,
+ msiRunModeLogEnabled = 4,
+ msiRunModeOperations = 5,
+ msiRunModeRebootAtEnd = 6,
+ msiRunModeRebootNow = 7,
+ msiRunModeCabinet = 8,
+ msiRunModeSourceShortNames = 9,
+ msiRunModeTargetShortNames = 10,
+ msiRunModeWindows9x = 12,
+ msiRunModeZawEnabled = 13,
+ msiRunModeScheduled = 16,
+ msiRunModeRollback = 17,
+ msiRunModeCommit = 18
+ } MsiRunMode;
+
+ typedef enum {
+ msiInstallContextFirstVisible = 0,
+ msiInstallContextUserManaged = 1,
+ msiInstallContextUser = 2,
+ msiInstallContextMachine = 4,
+ msiInstallContextAllUserManaged = 8
+ } MsiInstallContext;
+
+ [
+ uuid(000C1090-0000-0000-C000-000000000046),
+ helpcontext(0x00002328)
+ ]
+ dispinterface Installer {
properties:
+ [id(DISPID_INSTALLER_UILEVEL)]
+ MsiUILevel UILevel;
methods:
- }
+ [id(DISPID_INSTALLER_CREATERECORD)]
+ Record* CreateRecord([in] long Count);
+ [id(DISPID_INSTALLER_OPENPACKAGE)]
+ Session* OpenPackage(
+ [in] VARIANT PackagePath,
+ [in, optional, defaultvalue(0)] long Options);
+ [id(DISPID_INSTALLER_OPENPRODUCT)]
+ Session* OpenProduct([in] BSTR ProductCode);
+ [id(DISPID_INSTALLER_OPENDATABASE)]
+ Database* OpenDatabase(
+ [in] BSTR DatabasePath,
+ [in] VARIANT OpenMode);
+ [id(DISPID_INSTALLER_SUMMARYINFORMATION), propget]
+ SummaryInfo* SummaryInformation(
+ [in] BSTR PackagePath,
+ [in, optional, defaultvalue(0)] long UpdateCount);
+ [id(DISPID_INSTALLER_ENABLELOG)]
+ void EnableLog(
+ [in] BSTR LogMode,
+ [in] BSTR LogFile);
+ [id(DISPID_INSTALLER_INSTALLPRODUCT)]
+ void InstallProduct(
+ [in] BSTR PackagePath,
+ [in, optional, defaultvalue("0")] BSTR PropertyValues);
+ [id(DISPID_INSTALLER_VERSION), propget]
+ BSTR Version();
+ [id(DISPID_INSTALLER_LASTERRORRECORD)]
+ Record* LastErrorRecord();
+ [id(DISPID_INSTALLER_REGISTRYVALUE)]
+ BSTR RegistryValue(
+ [in] VARIANT Root,
+ [in] BSTR Key,
+ [in, optional] VARIANT Value);
+ [id(DISPID_INSTALLER_FILEATTRIBUTES)]
+ long FileAttributes([in] BSTR FilePath);
+ [id(DISPID_INSTALLER_FILESIZE)]
+ long FileSize([in] BSTR FilePath);
+ [id(DISPID_INSTALLER_FILEVERSION)]
+ BSTR FileVersion(
+ [in] BSTR FilePath,
+ [in, optional] VARIANT Language);
+ [id(DISPID_INSTALLER_ENVIRONMENT), propget]
+ BSTR Environment([in] BSTR Variable);
+ [id(DISPID_INSTALLER_ENVIRONMENT), propput]
+ void Environment(
+ [in] BSTR Variable,
+ [in] BSTR rhs);
+ [id(DISPID_INSTALLER_PRODUCTSTATE), propget]
+ MsiInstallState ProductState([in] BSTR Product);
+ [id(DISPID_INSTALLER_PRODUCTINFO), propget]
+ BSTR ProductInfo(
+ [in] BSTR Product,
+ [in] BSTR Attribute);
+ [id(DISPID_INSTALLER_CONFIGUREPRODUCT)]
+ void ConfigureProduct(
+ [in] BSTR Product,
+ [in] long InstallLevel,
+ [in] MsiInstallState InstallState);
+ [id(DISPID_INSTALLER_REINSTALLPRODUCT)]
+ void ReinstallProduct(
+ [in] BSTR Product,
+ [in] MsiReinstallMode ReinstallMode);
+ [id(DISPID_INSTALLER_COLLECTUSERINFO)]
+ void CollectUserInfo([in] BSTR Product);
+ [id(DISPID_INSTALLER_APPLYPATCH)]
+ void ApplyPatch(
+ [in] BSTR PatchPackage,
+ [in] BSTR InstallPackage,
+ [in] MsiInstallType InstallType,
+ [in] BSTR CommandLine);
+ [id(DISPID_INSTALLER_FEATUREPARENT), propget]
+ BSTR FeatureParent(
+ [in] BSTR Product,
+ [in] BSTR Feature);
+ [id(DISPID_INSTALLER_FEATURESTATE), propget]
+ MsiInstallState FeatureState(
+ [in] BSTR Product,
+ [in] BSTR Feature);
+ [id(DISPID_INSTALLER_USEFEATURE)]
+ void UseFeature(
+ [in] BSTR Product,
+ [in] BSTR Feature,
+ [in] MsiInstallMode InstallMode);
+ [id(DISPID_INSTALLER_FEATUREUSAGECOUNT), propget]
+ long FeatureUsageCount(
+ [in] BSTR Product,
+ [in] BSTR Feature);
+ [id(DISPID_INSTALLER_FEATUREUSAGEDATE), propget]
+ DATE FeatureUsageDate(
+ [in] BSTR Product,
+ [in] BSTR Feature);
+ [id(DISPID_INSTALLER_CONFIGUREFEATURE)]
+ void ConfigureFeature(
+ [in] BSTR Product,
+ [in] BSTR Feature,
+ [in] MsiInstallState InstallState);
+ [id(DISPID_INSTALLER_REINSTALLFEATURE)]
+ void ReinstallFeature(
+ [in] BSTR Product,
+ [in] BSTR Feature,
+ [in] MsiReinstallMode ReinstallMode);
+ [id(DISPID_INSTALLER_PROVIDECOMPONENT)]
+ BSTR ProvideComponent(
+ [in] BSTR Product,
+ [in] BSTR Feature,
+ [in] BSTR Component,
+ [in] long InstallMode);
+ [id(DISPID_INSTALLER_COMPONENTPATH), propget]
+ BSTR ComponentPath(
+ [in] BSTR Product,
+ [in] BSTR Component);
+ [id(DISPID_INSTALLER_PROVIDEQUALIFIEDCOMPONENT)]
+ BSTR ProvideQualifiedComponent(
+ [in] BSTR Category,
+ [in] BSTR Qualifier,
+ [in] long InstallMode);
+ [id(DISPID_INSTALLER_QUALIFIERDESCRIPTION), propget]
+ BSTR QualifierDescription(
+ [in] BSTR Category,
+ [in] BSTR Qualifier);
+ [id(DISPID_INSTALLER_COMPONENTQUALIFIERS), propget]
+ StringList* ComponentQualifiers([in] BSTR Category);
+ [id(DISPID_INSTALLER_PRODUCTS), propget]
+ StringList* Products();
+ [id(DISPID_INSTALLER_FEATURES), propget]
+ StringList* Features([in] BSTR Product);
+ [id(DISPID_INSTALLER_COMPONENTS), propget]
+ StringList* Components();
+ [id(DISPID_INSTALLER_COMPONENTCLIENTS), propget]
+ StringList* ComponentClients([in] BSTR Component);
+ [id(DISPID_INSTALLER_PATCHES), propget]
+ StringList* Patches([in] BSTR Product);
+ [id(DISPID_INSTALLER_RELATEDPRODUCTS), propget]
+ StringList* RelatedProducts([in] BSTR UpgradeCode);
+ [id(DISPID_INSTALLER_PATCHINFO), propget]
+ BSTR PatchInfo(
+ [in] BSTR Patch,
+ [in] BSTR Attribute);
+ [id(DISPID_INSTALLER_PATCHTRANSFORMS), propget]
+ BSTR PatchTransforms(
+ [in] BSTR Product,
+ [in] BSTR Patch);
+ [id(DISPID_INSTALLER_ADDSOURCE)]
+ void AddSource(
+ [in] BSTR Product,
+ [in] BSTR User,
+ [in] BSTR Source);
+ [id(DISPID_INSTALLER_CLEARSOURCELIST)]
+ void ClearSourceList(
+ [in] BSTR Product,
+ [in] BSTR User);
+ [id(DISPID_INSTALLER_FORCESOURCELISTRESOLUTION)]
+ void ForceSourceListResolution(
+ [in] BSTR Product,
+ [in] BSTR User);
+ [id(DISPID_INSTALLER_GETSHORTCUTTARGET), propget]
+ Record* GetShortcutTarget([in] BSTR ShortcutPath);
+ [id(DISPID_INSTALLER_FILEHASH)]
+ Record* FileHash(
+ [in] BSTR FilePath,
+ [in] long Options);
+ [id(DISPID_INSTALLER_FILESIGNATUREINFO)]
+ SAFEARRAY(unsigned char) FileSignatureInfo(
+ [in] BSTR FilePath,
+ [in] long Options,
+ [in] MsiSignatureInfo Format);
+ [id(DISPID_INSTALLER_REMOVEPATCHES)]
+ void RemovePatches(
+ [in] BSTR PatchList,
+ [in] BSTR Product,
+ [in] MsiInstallType UninstallType,
+ [in, optional, defaultvalue("0")] BSTR PropertyList);
+ [id(DISPID_INSTALLER_APPLYMULTIPLEPATCHES)]
+ void ApplyMultiplePatches(
+ [in] BSTR PatchPackage,
+ [in] BSTR Product,
+ [in] BSTR PropertiesList);
+ [id(DISPID_INSTALLER_PRODUCT), propget]
+ Product* Product(
+ [in] BSTR Product,
+ [in] BSTR UserSid,
+ [in] MsiInstallContext iContext);
+ [id(DISPID_INSTALLER_PATCH), propget]
+ Patch* Patch(
+ [in] BSTR PatchCode,
+ [in] BSTR ProductCode,
+ [in] BSTR UserSid,
+ [in] MsiInstallContext iContext);
+ [id(DISPID_INSTALLER_PRODUCTSEX), propget]
+ RecordList* ProductsEx(
+ [in] BSTR Product,
+ [in] BSTR UserSid,
+ [in] long Contexts);
+ [id(DISPID_INSTALLER_PATCHESEX), propget]
+ RecordList* PatchesEx(
+ [in] BSTR Product,
+ [in] BSTR UserSid,
+ [in] long Contexts,
+ [in] long filter);
+ [id(DISPID_INSTALLER_EXTRACTPATCHXMLDATA)]
+ BSTR ExtractPatchXMLData([in] BSTR PatchPath);
+ };
- [ uuid(000C1096-0000-0000-C000-000000000046) ]
- dispinterface RecordList
- {
+ [
+ uuid(000C1093-0000-0000-C000-000000000046),
+ helpcontext(0x00002454)
+ ]
+ dispinterface Record {
properties:
methods:
- }
+ [id(DISPID_RECORD_STRINGDATA), propget]
+ BSTR StringData([in] long Field);
+ [id(DISPID_RECORD_STRINGDATA), propput]
+ void StringData(
+ [in] long Field,
+ [in] BSTR rhs);
+ [id(DISPID_RECORD_INTEGERDATA), propget]
+ long IntegerData([in] long Field);
+ [id(DISPID_RECORD_INTEGERDATA), propput]
+ void IntegerData(
+ [in] long Field,
+ [in] long rhs);
+ [id(DISPID_RECORD_SETSTREAM)]
+ void SetStream(
+ [in] long Field,
+ [in] BSTR FilePath);
+ [id(DISPID_RECORD_READSTREAM)]
+ BSTR ReadStream(
+ [in] long Field,
+ [in] long Length,
+ [in] MsiReadStream Format);
+ [id(DISPID_RECORD_FIELDCOUNT), propget]
+ long FieldCount();
+ [id(DISPID_RECORD_ISNULL), propget]
+ VARIANT_BOOL IsNull([in] long Field);
+ [id(DISPID_RECORD_DATASIZE), propget]
+ long DataSize([in] long Field);
+ [id(DISPID_RECORD_CLEARDATA)]
+ void ClearData();
+ [id(DISPID_RECORD_FORMATTEXT)]
+ BSTR FormatText();
+ };
- [ uuid(000C109A-0000-0000-C000-000000000046) ]
- dispinterface UIPreview
- {
+ typedef enum {
+ msiDoActionStatusNoAction = 0,
+ msiDoActionStatusSuccess = 1,
+ msiDoActionStatusUserExit = 2,
+ msiDoActionStatusFailure = 3,
+ msiDoActionStatusSuspend = 4,
+ msiDoActionStatusFinished = 5,
+ msiDoActionStatusWrongState = 6,
+ msiDoActionStatusBadActionData = 7
+ } MsiDoActionStatus;
+
+ typedef enum {
+ msiEvaluateConditionFalse = 0,
+ msiEvaluateConditionTrue = 1,
+ msiEvaluateConditionNone = 2,
+ msiEvaluateConditionError = 3
+ } _MsiEvaluateCondition; /* Added underscore to avoid conflict with function name */
+
+ typedef enum {
+ msiMessageStatusError = -1,
+ msiMessageStatusNone = 0,
+ msiMessageStatusOk = 1,
+ msiMessageStatusCancel = 2,
+ msiMessageStatusAbort = 3,
+ msiMessageStatusRetry = 4,
+ msiMessageStatusIgnore = 5,
+ msiMessageStatusYes = 6,
+ msiMessageStatusNo = 7
+ } MsiMessageStatus;
+
+ typedef enum {
+ msiMessageTypeFatalExit = 0,
+ msiMessageTypeError = 16777216,
+ msiMessageTypeWarning = 33554432,
+ msiMessageTypeUser = 50331648,
+ msiMessageTypeInfo = 67108864,
+ msiMessageTypeFilesInUse = 83886080,
+ msiMessageTypeResolveSource = 100663296,
+ msiMessageTypeOutOfDiskSpace = 117440512,
+ msiMessageTypeActionStart = 134217728,
+ msiMessageTypeActionData = 150994944,
+ msiMessageTypeProgress = 167772160,
+ msiMessageTypeCommonData = 184549376,
+ msiMessageTypeOk = 0,
+ msiMessageTypeOkCancel = 1,
+ msiMessageTypeAbortRetryIgnore = 2,
+ msiMessageTypeYesNoCancel = 3,
+ msiMessageTypeYesNo = 4,
+ msiMessageTypeRetryCancel = 5,
+ msiMessageTypeDefault1 = 0,
+ msiMessageTypeDefault2 = 256,
+ msiMessageTypeDefault3 = 512
+ } MsiMessageType;
+
+ typedef enum {
+ msiCostTreeSelfOnly = 0,
+ msiCostTreeChildren = 1,
+ msiCostTreeParents = 2
+ } MsiCostTree;
+
+ typedef enum {
+ msiDatabaseStateRead = 0,
+ msiDatabaseStateWrite = 1
+ } MsiDatabaseState;
+
+ [
+ uuid(000C109E-0000-0000-C000-000000000046),
+ helpcontext(0x000025e4)
+ ]
+ dispinterface Session {
properties:
methods:
- }
+ [id(DISPID_SESSION_INSTALLER), propget]
+ Installer* Installer();
+ [id(DISPID_SESSION_PROPERTY), propget]
+ BSTR Property([in] BSTR Name);
+ [id(DISPID_SESSION_PROPERTY), propput]
+ void Property(
+ [in] BSTR Name,
+ [in] BSTR rhs);
+ [id(DISPID_SESSION_LANGUAGE), propget]
+ long Language();
+ [id(DISPID_SESSION_MODE), propget]
+ VARIANT_BOOL Mode([in] MsiRunMode Flag);
+ [id(DISPID_SESSION_MODE), propput]
+ void Mode(
+ [in] MsiRunMode Flag,
+ [in] VARIANT_BOOL rhs);
+ [id(DISPID_SESSION_DATABASE), propget]
+ Database* Database();
+ [id(DISPID_SESSION_SOURCEPATH), propget]
+ BSTR SourcePath([in] BSTR Folder);
+ [id(DISPID_SESSION_TARGETPATH), propget]
+ BSTR TargetPath([in] BSTR Folder);
+ [id(DISPID_SESSION_TARGETPATH), propput]
+ void TargetPath(
+ [in] BSTR Folder,
+ [in] BSTR rhs);
+ [id(DISPID_SESSION_DOACTION)]
+ MsiDoActionStatus DoAction([in] BSTR Action);
+ [id(DISPID_SESSION_SEQUENCE)]
+ MsiDoActionStatus Sequence(
+ [in] BSTR Table,
+ [in, optional] VARIANT Mode);
+ [id(DISPID_SESSION_EVALUATECONDITION)]
+ _MsiEvaluateCondition EvaluateCondition([in] BSTR Expression);
+ [id(DISPID_SESSION_FORMATRECORD)]
+ BSTR FormatRecord([in] Record* Record);
+ [id(DISPID_SESSION_MESSAGE)]
+ MsiMessageStatus Message(
+ [in] MsiMessageType Kind,
+ [in] Record* Record);
+ [id(DISPID_SESSION_FEATURECURRENTSTATE), propget]
+ MsiInstallState FeatureCurrentState([in] BSTR Feature);
+ [id(DISPID_SESSION_FEATUREREQUESTSTATE), propget]
+ MsiInstallState FeatureRequestState([in] BSTR Feature);
+ [id(DISPID_SESSION_FEATUREREQUESTSTATE), propput]
+ void FeatureRequestState(
+ [in] BSTR Feature,
+ [in] MsiInstallState rhs);
+ [id(DISPID_SESSION_FEATUREVALIDSTATES), propget]
+ long FeatureValidStates([in] BSTR Feature);
+ [id(DISPID_SESSION_FEATURECOST), propget]
+ long FeatureCost(
+ [in] BSTR Feature,
+ [in] MsiCostTree CostTree,
+ [in] MsiInstallState State);
+ [id(DISPID_SESSION_COMPONENTCURRENTSTATE), propget]
+ MsiInstallState ComponentCurrentState([in] BSTR Component);
+ [id(DISPID_SESSION_COMPONENTREQUESTSTATE), propget]
+ MsiInstallState ComponentRequestState([in] BSTR Component);
+ [id(DISPID_SESSION_COMPONENTREQUESTSTATE), propput]
+ void ComponentRequestState(
+ [in] BSTR Component,
+ [in] MsiInstallState rhs);
+ [id(DISPID_SESSION_SETINSTALLLEVEL)]
+ void SetInstallLevel([in] long Level);
+ [id(DISPID_SESSION_VERIFYDISKSPACE), propget]
+ VARIANT_BOOL VerifyDiskSpace();
+ [id(DISPID_SESSION_PRODUCTPROPERTY), propget]
+ BSTR ProductProperty([in] BSTR Property);
+ [id(DISPID_SESSION_FEATUREINFO), propget]
+ FeatureInfo* FeatureInfo([in] BSTR Feature);
+ [id(DISPID_SESSION_COMPONENTCOSTS), propget]
+ RecordList* ComponentCosts(
+ [in] BSTR Component,
+ [in] MsiInstallState State);
+ };
+
+ typedef enum {
+ msiTransformErrorNone = 0,
+ msiTransformErrorAddExistingRow = 1,
+ msiTransformErrorDeleteNonExistingRow = 2,
+ msiTransformErrorAddExistingTable = 4,
+ msiTransformErrorDeleteNonExistingTable = 8,
+ msiTransformErrorUpdateNonExistingRow = 16,
+ msiTransformErrorChangeCodePage = 32,
+ msiTransformErrorViewTransform = 256
+ } MsiTransformError;
+
+ typedef enum {
+ msiTransformValidationNone = 0,
+ msiTransformValidationLanguage = 1,
+ msiTransformValidationProduct = 2,
+ msiTransformValidationPlatform = 4,
+ msiTransformValidationMajorVer = 8,
+ msiTransformValidationMinorVer = 16,
+ msiTransformValidationUpdateVer = 32,
+ msiTransformValidationLess = 64,
+ msiTransformValidationLessOrEqual = 128,
+ msiTransformValidationEqual = 256,
+ msiTransformValidationGreaterOrEqual = 512,
+ msiTransformValidationGreater = 1024,
+ msiTransformValidationUpgradeCode = 2048
+ } MsiTransformValidation;
- [ uuid(000C109B-0000-0000-C000-000000000046) ]
- dispinterface SummaryInfo
- {
+ [
+ uuid(000C109D-0000-0000-C000-000000000046),
+ helpcontext(0x0000251c)
+ ]
+ dispinterface Database {
properties:
methods:
- }
+ [id(DISPID_DATABASE_DATABASESTATE), propget]
+ MsiDatabaseState DatabaseState();
+ [id(DISPID_DATABASE_SUMMARYINFORMATION), propget]
+ SummaryInfo* SummaryInformation([in, optional, defaultvalue(0)] long UpdateCount);
+ [id(DISPID_DATABASE_OPENVIEW)]
+ View* OpenView([in] BSTR Sql);
+ [id(DISPID_DATABASE_COMMIT)]
+ void Commit();
+ [id(DISPID_DATABASE_PRIMARYKEYS), propget]
+ Record* PrimaryKeys([in] BSTR Table);
+ [id(DISPID_DATABASE_IMPORT)]
+ void Import(
+ [in] BSTR Folder,
+ [in] BSTR File);
+ [id(DISPID_DATABASE_EXPORT)]
+ void Export(
+ [in] BSTR Table,
+ [in] BSTR Folder,
+ [in] BSTR File);
+ [id(DISPID_DATABASE_MERGE)]
+ VARIANT_BOOL Merge(
+ [in] Database* Database,
+ [in, optional, defaultvalue("0")] BSTR ErrorTable);
+ [id(DISPID_DATABASE_GENERATETRANSFORM)]
+ VARIANT_BOOL GenerateTransform(
+ [in] Database* ReferenceDatabase,
+ [in, optional, defaultvalue("0")] BSTR TransformFile);
+ [id(DISPID_DATABASE_APPLYTRANSFORM)]
+ void ApplyTransform(
+ [in] BSTR TransformFile,
+ [in] MsiTransformError ErrorConditions);
+ [id(DISPID_DATABASE_ENABLEUIPREVIEW)]
+ UIPreview* EnableUIPreview();
+ [id(DISPID_DATABASE_TABLEPERSISTENT), propget]
+ _MsiEvaluateCondition TablePersistent([in] BSTR Table);
+ [id(DISPID_DATABASE_CREATETRANSFORMSUMMARYINFO)]
+ void CreateTransformSummaryInfo(
+ [in] Database* ReferenceDatabase,
+ [in] BSTR TransformFile,
+ [in] MsiTransformError ErrorConditions,
+ [in] MsiTransformValidation Validation);
+ };
- [ uuid(000C109C-0000-0000-C000-000000000046) ]
- dispinterface View
- {
+ [
+ uuid(000C109B-0000-0000-C000-000000000046),
+ helpcontext(0x00002580)
+ ]
+ dispinterface SummaryInfo {
properties:
methods:
- }
+ [id(DISPID_SUMMARYINFO_PROPERTY), propget]
+ VARIANT Property([in] long Pid);
+ [id(DISPID_SUMMARYINFO_PROPERTY), propput]
+ void Property(
+ [in] long Pid,
+ [in] VARIANT rhs);
+ [id(DISPID_SUMMARYINFO_PROPERTYCOUNT), propget]
+ long PropertyCount();
+ [id(DISPID_SUMMARYINFO_PERSIST)]
+ void Persist();
+ };
- [ uuid(000C109D-0000-0000-C000-000000000046) ]
- dispinterface Database
- {
+ typedef enum {
+ msiViewModifySeek = -1,
+ msiViewModifyRefresh = 0,
+ msiViewModifyInsert = 1,
+ msiViewModifyUpdate = 2,
+ msiViewModifyAssign = 3,
+ msiViewModifyReplace = 4,
+ msiViewModifyMerge = 5,
+ msiViewModifyDelete = 6,
+ msiViewModifyInsertTemporary = 7,
+ msiViewModifyValidate = 8,
+ msiViewModifyValidateNew = 9,
+ msiViewModifyValidateField = 10,
+ msiViewModifyValidateDelete = 11
+ } _MsiViewModify; /* Added underscore to avoid conflict with MsiViewModify function in msiquery.h */
+
+ typedef enum {
+ msiColumnInfoNames = 0,
+ msiColumnInfoTypes = 1
+ } MsiColumnInfo;
+
+ [
+ uuid(000C109C-0000-0000-C000-000000000046),
+ helpcontext(0x000024b8)
+ ]
+ dispinterface View {
+ properties:
+ methods:
+ [id(DISPID_VIEW_EXECUTE)]
+ void Execute([in, optional, defaultvalue(0)] Record* Params);
+ [id(DISPID_VIEW_FETCH)]
+ Record* Fetch();
+ [id(DISPID_VIEW_MODIFY)]
+ void Modify(
+ [in] _MsiViewModify Mode,
+ Record* Record);
+ [id(DISPID_VIEW_COLUMNINFO), propget]
+ Record* ColumnInfo([in] MsiColumnInfo Info);
+ [id(DISPID_VIEW_CLOSE)]
+ void Close();
+ [id(DISPID_VIEW_GETERROR)]
+ BSTR GetError();
+ };
+
+ [
+ uuid(000C109A-0000-0000-C000-000000000046),
+ helpcontext(0x00002648)
+ ]
+ dispinterface UIPreview {
+ properties:
+ methods:
+ [id(DISPID_UIPREVIEW_PROPERTY), propget]
+ BSTR Property([in] BSTR Name);
+ [id(DISPID_UIPREVIEW_PROPERTY), propput]
+ void Property(
+ [in] BSTR Name,
+ [in] BSTR rhs);
+ [id(DISPID_UIPREVIEW_VIEWDIALOG)]
+ void ViewDialog([in] BSTR Dialog);
+ [id(DISPID_UIPREVIEW_VIEWBILLBOARD)]
+ void ViewBillboard(
+ [in] BSTR Control,
+ [in] BSTR Billboard);
+ };
+
+ [
+ uuid(000C109F-0000-0000-C000-000000000046),
+ helpcontext(0x0000238c)
+ ]
+ dispinterface FeatureInfo {
properties:
+ [id(DISPID_FEATUREINFO_ATTRIBUTES)]
+ long Attributes;
methods:
- }
-
- [ uuid(000C109E-0000-0000-C000-000000000046) ]
- dispinterface Session
- {
- properties:
- methods:
- }
-
- [ uuid(000C109F-0000-0000-C000-000000000046) ]
- dispinterface FeatureInfo
- {
+ [id(DISPID_FEATUREINFO_TITLE), propget]
+ BSTR Title();
+ [id(DISPID_FEATUREINFO_DESCRIPTION), propget]
+ BSTR Description();
+ };
+
+ [
+ uuid(000C1096-0000-0000-C000-000000000046),
+ helpcontext(0x000023f3)
+ ]
+ dispinterface RecordList {
+ properties:
+ methods:
+ [id(DISPID_RECORDLIST__NEWENUM)]
+ IUnknown _NewEnum();
+ [id(DISPID_RECORDLIST_ITEM), propget]
+ Record* Item(long Index);
+ [id(DISPID_RECORDLIST_COUNT), propget]
+ long Count();
+ };
+
+ [
+ uuid(000C1095-0000-0000-C000-000000000046),
+ helpcontext(0x000023f0)
+ ]
+ dispinterface StringList {
properties:
methods:
- }
+ [id(DISPID_STRINGLIST__NEWENUM)]
+ IUnknown _NewEnum();
+ [id(DISPID_STRINGLIST_ITEM), propget]
+ BSTR Item(long Index);
+ [id(DISPID_STRINGLIST_COUNT), propget]
+ long Count();
+ };
- [ uuid(000C10A0-0000-0000-C000-000000000046) ]
- dispinterface Product
- {
+ typedef enum {
+ msiInstallSourceTypeUnknown = 0,
+ msiInstallSourceTypeNetwork = 1,
+ msiInstallSourceTypeURL = 2,
+ msiInstallSourceTypeMedia = 4
+ } MsiInstallSourceType;
+
+ [
+ uuid(000C10A0-0000-0000-C000-000000000046),
+ helpcontext(0x00002396)
+ ]
+ dispinterface Product {
properties:
methods:
- }
+ [id(DISPID_PRODUCT_PRODUCTCODE), propget]
+ BSTR ProductCode();
+ [id(DISPID_PRODUCT_USERSID), propget]
+ BSTR UserSid();
+ [id(DISPID_PRODUCT_CONTEXT), propget]
+ MsiInstallContext Context();
+ [id(DISPID_PRODUCT_STATE), propget]
+ MsiInstallState State();
+ [id(DISPID_PRODUCT_INSTALLPROPERTY), propget]
+ BSTR InstallProperty([in] BSTR Name);
+ [id(DISPID_PRODUCT_COMPONENTSTATE), propget]
+ MsiInstallState ComponentState([in] BSTR Component);
+ [id(DISPID_PRODUCT_FEATURESTATE), propget]
+ MsiInstallState FeatureState([in] BSTR Feature);
+ [id(DISPID_PRODUCT_SOURCES), propget]
+ StringList* Sources([in] long SourceType);
+ [id(DISPID_PRODUCT_MEDIADISKS), propget]
+ RecordList* MediaDisks();
+ [id(DISPID_PRODUCT_SOURCELISTADDSOURCE)]
+ void SourceListAddSource(
+ [in] MsiInstallSourceType iSourceType,
+ [in] BSTR Source,
+ [in] long dwIndex);
+ [id(DISPID_PRODUCT_SOURCELISTADDMEDIADISK)]
+ void SourceListAddMediaDisk(
+ [in] long dwDiskId,
+ [in] BSTR VolumeLabel,
+ [in] BSTR DiskPrompt);
+ [id(DISPID_PRODUCT_SOURCELISTCLEARSOURCE)]
+ void SourceListClearSource(
+ [in] MsiInstallSourceType iSourceType,
+ [in] BSTR Source);
+ [id(DISPID_PRODUCT_SOURCELISTCLEARMEDIADISK)]
+ void SourceListClearMediaDisk([in] long iDiskId);
+ [id(DISPID_PRODUCT_SOURCELISTCLEARALL)]
+ void SourceListClearAll([in] MsiInstallSourceType iSourceType);
+ [id(DISPID_PRODUCT_SOURCELISTFORCERESOLUTION)]
+ void SourceListForceResolution();
+ [id(DISPID_PRODUCT_SOURCELISTINFO), propget]
+ BSTR SourceListInfo([in] BSTR Property);
+ [id(DISPID_PRODUCT_SOURCELISTINFO), propput]
+ void SourceListInfo(
+ [in] BSTR Property,
+ [in] BSTR retval);
+ };
- [ uuid(000C10A1-0000-0000-C000-000000000046) ]
- dispinterface Patch
- {
+ [
+ uuid(000C10A1-0000-0000-C000-000000000046),
+ helpcontext(0x000023aa)
+ ]
+ dispinterface Patch {
properties:
methods:
- }
-}
+ [id(DISPID_PATCH_PATCHCODE), propget]
+ BSTR PatchCode();
+ [id(DISPID_PATCH_PRODUCTCODE), propget]
+ BSTR ProductCode();
+ [id(DISPID_PATCH_USERSID), propget]
+ BSTR UserSid();
+ [id(DISPID_PATCH_CONTEXT), propget]
+ MsiInstallContext Context();
+ [id(DISPID_PATCH_STATE), propget]
+ MsiInstallState State();
+ [id(DISPID_PATCH_SOURCES), propget]
+ StringList* Sources([in] long SourceType);
+ [id(DISPID_PATCH_MEDIADISKS), propget]
+ RecordList* MediaDisks();
+ [id(DISPID_PATCH_SOURCELISTADDSOURCE)]
+ void SourceListAddSource(
+ [in] MsiInstallSourceType iSourceType,
+ [in] BSTR Source,
+ [in] long dwIndex);
+ [id(DISPID_PATCH_SOURCELISTADDMEDIADISK)]
+ void SourceListAddMediaDisk(
+ [in] long dwDiskId,
+ [in] BSTR VolumeLabel,
+ [in] BSTR DiskPrompt);
+ [id(DISPID_PATCH_SOURCELISTCLEARSOURCE)]
+ void SourceListClearSource(
+ [in] MsiInstallSourceType iSourceType,
+ [in] BSTR Source);
+ [id(DISPID_PATCH_SOURCELISTCLEARMEDIADISK)]
+ void SourceListClearMediaDisk([in] long iDiskId);
+ [id(DISPID_PATCH_SOURCELISTCLEARALL)]
+ void SourceListClearAll([in] MsiInstallSourceType iSourceType);
+ [id(DISPID_PATCH_SOURCELISTFORCERESOLUTION)]
+ void SourceListForceResolution();
+ [id(DISPID_PATCH_SOURCELISTINFO), propget]
+ BSTR SourceListInfo([in] BSTR Property);
+ [id(DISPID_PATCH_SOURCELISTINFO), propput]
+ void SourceListInfo(
+ [in] BSTR Property,
+ [in] BSTR retval);
+ [id(DISPID_PATCH_PATCHPROPERTY), propget]
+ BSTR PatchProperty([in] BSTR Property);
+ };
+
+ typedef enum {
+ msiDatabaseNullInteger = -2147483648
+ } Constants;
+
+ typedef enum {
+ msiOpenDatabaseModeReadOnly = 0,
+ msiOpenDatabaseModeTransact = 1,
+ msiOpenDatabaseModeDirect = 2,
+ msiOpenDatabaseModeCreate = 3,
+ msiOpenDatabaseModeCreateDirect = 4,
+ msiOpenDatabaseModePatchFile = 32
+ } MsiOpenDatabaseMode;
+
+ typedef enum {
+ msiSignatureOptionInvalidHashFatal = 1
+ } MsiSignatureOption;
+};
diff --git a/dlls/msi/msiserver_dispids.h b/dlls/msi/msiserver_dispids.h
new file mode 100644
index 0000000..093efb0
--- /dev/null
+++ b/dlls/msi/msiserver_dispids.h
@@ -0,0 +1,180 @@
+/*
+ * Copyright (C) 2007 Misha Koshelev
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define DISPID_INSTALLER_UILEVEL 6
+#define DISPID_INSTALLER_CREATERECORD 1
+#define DISPID_INSTALLER_OPENPACKAGE 2
+#define DISPID_INSTALLER_OPENPRODUCT 3
+#define DISPID_INSTALLER_OPENDATABASE 4
+#define DISPID_INSTALLER_SUMMARYINFORMATION 5
+#define DISPID_INSTALLER_ENABLELOG 7
+#define DISPID_INSTALLER_INSTALLPRODUCT 8
+#define DISPID_INSTALLER_VERSION 9
+#define DISPID_INSTALLER_LASTERRORRECORD 10
+#define DISPID_INSTALLER_REGISTRYVALUE 11
+#define DISPID_INSTALLER_FILEATTRIBUTES 13
+#define DISPID_INSTALLER_FILESIZE 15
+#define DISPID_INSTALLER_FILEVERSION 16
+#define DISPID_INSTALLER_ENVIRONMENT 12
+#define DISPID_INSTALLER_PRODUCTSTATE 17
+#define DISPID_INSTALLER_PRODUCTINFO 18
+#define DISPID_INSTALLER_CONFIGUREPRODUCT 19
+#define DISPID_INSTALLER_REINSTALLPRODUCT 20
+#define DISPID_INSTALLER_COLLECTUSERINFO 21
+#define DISPID_INSTALLER_APPLYPATCH 22
+#define DISPID_INSTALLER_FEATUREPARENT 23
+#define DISPID_INSTALLER_FEATURESTATE 24
+#define DISPID_INSTALLER_USEFEATURE 25
+#define DISPID_INSTALLER_FEATUREUSAGECOUNT 26
+#define DISPID_INSTALLER_FEATUREUSAGEDATE 27
+#define DISPID_INSTALLER_CONFIGUREFEATURE 28
+#define DISPID_INSTALLER_REINSTALLFEATURE 29
+#define DISPID_INSTALLER_PROVIDECOMPONENT 30
+#define DISPID_INSTALLER_COMPONENTPATH 31
+#define DISPID_INSTALLER_PROVIDEQUALIFIEDCOMPONENT 32
+#define DISPID_INSTALLER_QUALIFIERDESCRIPTION 33
+#define DISPID_INSTALLER_COMPONENTQUALIFIERS 34
+#define DISPID_INSTALLER_PRODUCTS 35
+#define DISPID_INSTALLER_FEATURES 36
+#define DISPID_INSTALLER_COMPONENTS 37
+#define DISPID_INSTALLER_COMPONENTCLIENTS 38
+#define DISPID_INSTALLER_PATCHES 39
+#define DISPID_INSTALLER_RELATEDPRODUCTS 40
+#define DISPID_INSTALLER_PATCHINFO 41
+#define DISPID_INSTALLER_PATCHTRANSFORMS 42
+#define DISPID_INSTALLER_ADDSOURCE 43
+#define DISPID_INSTALLER_CLEARSOURCELIST 44
+#define DISPID_INSTALLER_FORCESOURCELISTRESOLUTION 45
+#define DISPID_INSTALLER_GETSHORTCUTTARGET 46
+#define DISPID_INSTALLER_FILEHASH 47
+#define DISPID_INSTALLER_FILESIGNATUREINFO 48
+#define DISPID_INSTALLER_REMOVEPATCHES 49
+#define DISPID_INSTALLER_APPLYMULTIPLEPATCHES 51
+#define DISPID_INSTALLER_PRODUCT 53
+#define DISPID_INSTALLER_PATCH 56
+#define DISPID_INSTALLER_PRODUCTSEX 52
+#define DISPID_INSTALLER_PATCHESEX 55
+#define DISPID_INSTALLER_EXTRACTPATCHXMLDATA 57
+
+#define DISPID_RECORD_STRINGDATA 1
+#define DISPID_RECORD_INTEGERDATA 2
+#define DISPID_RECORD_SETSTREAM 3
+#define DISPID_RECORD_READSTREAM 4
+#define DISPID_RECORD_FIELDCOUNT 0
+#define DISPID_RECORD_ISNULL 6
+#define DISPID_RECORD_DATASIZE 5
+#define DISPID_RECORD_CLEARDATA 7
+#define DISPID_RECORD_FORMATTEXT 8
+
+#define DISPID_SESSION_INSTALLER 1
+#define DISPID_SESSION_PROPERTY 2
+#define DISPID_SESSION_LANGUAGE 3
+#define DISPID_SESSION_MODE 4
+#define DISPID_SESSION_DATABASE 5
+#define DISPID_SESSION_SOURCEPATH 6
+#define DISPID_SESSION_TARGETPATH 7
+#define DISPID_SESSION_DOACTION 8
+#define DISPID_SESSION_SEQUENCE 9
+#define DISPID_SESSION_EVALUATECONDITION 10
+#define DISPID_SESSION_FORMATRECORD 11
+#define DISPID_SESSION_MESSAGE 12
+#define DISPID_SESSION_FEATURECURRENTSTATE 13
+#define DISPID_SESSION_FEATUREREQUESTSTATE 14
+#define DISPID_SESSION_FEATUREVALIDSTATES 15
+#define DISPID_SESSION_FEATURECOST 16
+#define DISPID_SESSION_COMPONENTCURRENTSTATE 17
+#define DISPID_SESSION_COMPONENTREQUESTSTATE 18
+#define DISPID_SESSION_SETINSTALLLEVEL 19
+#define DISPID_SESSION_VERIFYDISKSPACE 20
+#define DISPID_SESSION_PRODUCTPROPERTY 21
+#define DISPID_SESSION_FEATUREINFO 22
+#define DISPID_SESSION_COMPONENTCOSTS 23
+
+#define DISPID_DATABASE_DATABASESTATE 1
+#define DISPID_DATABASE_SUMMARYINFORMATION 2
+#define DISPID_DATABASE_OPENVIEW 3
+#define DISPID_DATABASE_COMMIT 4
+#define DISPID_DATABASE_PRIMARYKEYS 5
+#define DISPID_DATABASE_IMPORT 6
+#define DISPID_DATABASE_EXPORT 7
+#define DISPID_DATABASE_MERGE 8
+#define DISPID_DATABASE_GENERATETRANSFORM 9
+#define DISPID_DATABASE_APPLYTRANSFORM 10
+#define DISPID_DATABASE_ENABLEUIPREVIEW 11
+#define DISPID_DATABASE_TABLEPERSISTENT 12
+#define DISPID_DATABASE_CREATETRANSFORMSUMMARYINFO 13
+
+#define DISPID_SUMMARYINFO_PROPERTY 1
+#define DISPID_SUMMARYINFO_PROPERTYCOUNT 2
+#define DISPID_SUMMARYINFO_PERSIST 3
+
+#define DISPID_VIEW_EXECUTE 1
+#define DISPID_VIEW_FETCH 2
+#define DISPID_VIEW_MODIFY 3
+#define DISPID_VIEW_COLUMNINFO 5
+#define DISPID_VIEW_CLOSE 4
+#define DISPID_VIEW_GETERROR 6
+
+#define DISPID_UIPREVIEW_PROPERTY 1
+#define DISPID_UIPREVIEW_VIEWDIALOG 2
+#define DISPID_UIPREVIEW_VIEWBILLBOARD 3
+
+#define DISPID_FEATUREINFO_ATTRIBUTES 3
+#define DISPID_FEATUREINFO_TITLE 1
+#define DISPID_FEATUREINFO_DESCRIPTION 2
+
+#define DISPID_RECORDLIST__NEWENUM -4
+#define DISPID_RECORDLIST_ITEM 0
+#define DISPID_RECORDLIST_COUNT 1
+
+#define DISPID_STRINGLIST__NEWENUM -4
+#define DISPID_STRINGLIST_ITEM 0
+#define DISPID_STRINGLIST_COUNT 1
+
+#define DISPID_PRODUCT_PRODUCTCODE 1
+#define DISPID_PRODUCT_USERSID 2
+#define DISPID_PRODUCT_CONTEXT 3
+#define DISPID_PRODUCT_STATE 4
+#define DISPID_PRODUCT_INSTALLPROPERTY 5
+#define DISPID_PRODUCT_COMPONENTSTATE 6
+#define DISPID_PRODUCT_FEATURESTATE 7
+#define DISPID_PRODUCT_SOURCES 14
+#define DISPID_PRODUCT_MEDIADISKS 15
+#define DISPID_PRODUCT_SOURCELISTADDSOURCE 8
+#define DISPID_PRODUCT_SOURCELISTADDMEDIADISK 9
+#define DISPID_PRODUCT_SOURCELISTCLEARSOURCE 10
+#define DISPID_PRODUCT_SOURCELISTCLEARMEDIADISK 11
+#define DISPID_PRODUCT_SOURCELISTCLEARALL 12
+#define DISPID_PRODUCT_SOURCELISTFORCERESOLUTION 13
+#define DISPID_PRODUCT_SOURCELISTINFO 16
+
+#define DISPID_PATCH_PATCHCODE 1
+#define DISPID_PATCH_PRODUCTCODE 2
+#define DISPID_PATCH_USERSID 3
+#define DISPID_PATCH_CONTEXT 4
+#define DISPID_PATCH_STATE 5
+#define DISPID_PATCH_SOURCES 12
+#define DISPID_PATCH_MEDIADISKS 13
+#define DISPID_PATCH_SOURCELISTADDSOURCE 6
+#define DISPID_PATCH_SOURCELISTADDMEDIADISK 7
+#define DISPID_PATCH_SOURCELISTCLEARSOURCE 8
+#define DISPID_PATCH_SOURCELISTCLEARMEDIADISK 9
+#define DISPID_PATCH_SOURCELISTCLEARALL 10
+#define DISPID_PATCH_SOURCELISTFORCERESOLUTION 11
+#define DISPID_PATCH_SOURCELISTINFO 14
+#define DISPID_PATCH_PATCHPROPERTY 15
--
1.4.1
["0003-msi-Add-partial-expandable-OLE-automation-support.txt" (0003-msi-Add-partial-expandable-OLE-automation-support.txt)]
From 5a41c336b7c27d70ce50bdc7e930a6bf6692c7ce Mon Sep 17 00:00:00 2001
From: Misha Koshelev <mk144210@bcm.tmc.edu>
Date: Wed, 28 Feb 2007 12:10:18 -0600
Subject: msi: Add partial, expandable OLE automation support.
---
dlls/msi/Makefile.in | 3
dlls/msi/automation.c | 826 +++++++++++++++++++++++++++++++++++++++++++++++++
dlls/msi/msipriv.h | 4
3 files changed, 833 insertions(+), 0 deletions(-)
diff --git a/dlls/msi/Makefile.in b/dlls/msi/Makefile.in
index 5fb0941..3418fb5 100644
--- a/dlls/msi/Makefile.in
+++ b/dlls/msi/Makefile.in
@@ -12,6 +12,7 @@ C_SRCS = \
action.c \
alter.c \
appsearch.c \
+ automation.c \
classes.c \
create.c \
custom.c \
@@ -47,6 +48,8 @@ C_SRCS = \
upgrade.c \
where.c
+IDL_H_SRCS = msiserver.idl
+IDL_I_SRCS = msiserver.idl
IDL_TLB_SRCS = msiserver.idl
BISON_SRCS = \
diff --git a/dlls/msi/automation.c b/dlls/msi/automation.c
new file mode 100644
index 0000000..cfb2cf1
--- /dev/null
+++ b/dlls/msi/automation.c
@@ -0,0 +1,826 @@
+/*
+ * Implementation of OLE Automation for Microsoft Installer (msi.dll)
+ *
+ * Copyright 2007 Misha Koshelev
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include <stdarg.h>
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+#include "winuser.h"
+#include "msidefs.h"
+#include "msipriv.h"
+#include "activscp.h"
+#include "oleauto.h"
+#include "wine/debug.h"
+#include "wine/unicode.h"
+
+#include "msiserver.h"
+#include "msiserver_dispids.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msi);
+
+/* FIXME: I don't know how big this should be */
+#define MAX_MSI_STRING 1000
+
+/*
+ * AutomationObject - "base" class for all automation objects. For each interface, \
we implement Invoke function + * called from \
AutomationObject::Invoke, and pass this function to create_automation_object. + */
+
+typedef interface AutomationObject AutomationObject;
+
+interface AutomationObject {
+ /*
+ * VTables - We provide IDispatch, IProvideClassInfo, IProvideClassInfo2, \
IProvideMultipleClassInfo + */
+ const IDispatchVtbl *lpVtbl;
+ const IProvideClassInfoVtbl *lpvtblIProvideClassInfo;
+ const IProvideClassInfo2Vtbl *lpvtblIProvideClassInfo2;
+ const IProvideMultipleClassInfoVtbl *lpvtblIProvideMultipleClassInfo;
+
+ /* Object reference count */
+ LONG ref;
+
+ /* Clsid for this class and it's appropriate ITypeInfo object */
+ LPCLSID clsid;
+ ITypeInfo *iTypeInfo;
+
+ /* The MSI handle of the current object */
+ MSIHANDLE msiHandle;
+
+ /* A function that is called from AutomationObject::Invoke, specific to this \
type of object. */ + HRESULT (STDMETHODCALLTYPE *funcInvoke)(
+ AutomationObject* This,
+ DISPID dispIdMember,
+ REFIID riid,
+ LCID lcid,
+ WORD wFlags,
+ DISPPARAMS* pDispParams,
+ VARIANT* pVarResult,
+ EXCEPINFO* pExcepInfo,
+ UINT* puArgErr);
+};
+
+/* VTables */
+static const struct IDispatchVtbl AutomationObject_Vtbl;
+static const struct IProvideClassInfoVtbl AutomationObject_IProvideClassInfo_Vtbl;
+static const struct IProvideClassInfo2Vtbl AutomationObject_IProvideClassInfo2_Vtbl; \
+static const struct IProvideMultipleClassInfoVtbl \
AutomationObject_IProvideMultipleClassInfo_Vtbl; +
+/* Load type info so we don't have to process GetIDsOfNames */
+HRESULT WINAPI LoadTypeInfo(IDispatch *iface, ITypeInfo **pptinfo, REFIID clsid, \
LCID lcid) +{
+ HRESULT hr;
+ LPTYPELIB pLib = NULL;
+ LPTYPEINFO pInfo = NULL;
+ WCHAR szMsiServer[] = {'m','s','i','s','e','r','v','e','r','.','t','l','b'};
+
+ TRACE("(%p)->(%s,%d)\n", iface, debugstr_guid(clsid), lcid);
+
+ /* Load registered type library */
+ hr = LoadRegTypeLib(&LIBID_WindowsInstaller, 1, 0, lcid, &pLib);
+ if (FAILED(hr)) {
+ hr = LoadTypeLib(szMsiServer, &pLib);
+ if (FAILED(hr)) {
+ ERR("Could not load msiserver.tlb\n");
+ return hr;
+ }
+ }
+
+ /* Get type information for object */
+ hr = ITypeLib_GetTypeInfoOfGuid(pLib, clsid, &pInfo);
+ ITypeLib_Release(pLib);
+ if (FAILED(hr)) {
+ ERR("Could not load ITypeInfo for %s\n", debugstr_guid(clsid));
+ return hr;
+ }
+ *pptinfo = pInfo;
+ return S_OK;
+}
+
+/* Create the automation object, placing the result in the pointer ppObj. The \
automation object is created + * with the appropriate clsid and invocation function. \
*/ +HRESULT create_automation_object(MSIHANDLE msiHandle, IUnknown *pUnkOuter, LPVOID \
*ppObj, REFIID clsid, + HRESULT (STDMETHODCALLTYPE \
*funcInvoke)(AutomationObject*,DISPID,REFIID,LCID,WORD,DISPPARAMS*, + \
VARIANT*,EXCEPINFO*,UINT*)) +{
+ AutomationObject *object;
+ HRESULT hr;
+
+ TRACE("(%ld,%p,%p,%s,%p)\n", (unsigned long)msiHandle, pUnkOuter, ppObj, \
debugstr_guid(clsid), funcInvoke); +
+ if( pUnkOuter )
+ return CLASS_E_NOAGGREGATION;
+
+ object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, \
sizeof(AutomationObject)); +
+ /* Set all the VTable references */
+ object->lpVtbl = &AutomationObject_Vtbl;
+ object->lpvtblIProvideClassInfo = &AutomationObject_IProvideClassInfo_Vtbl;
+ object->lpvtblIProvideClassInfo2 = &AutomationObject_IProvideClassInfo2_Vtbl;
+ object->lpvtblIProvideMultipleClassInfo = \
&AutomationObject_IProvideMultipleClassInfo_Vtbl; + object->ref = 1;
+
+ /* Store data that was passed */
+ object->msiHandle = msiHandle;
+ object->clsid = (LPCLSID)clsid;
+ object->funcInvoke = funcInvoke;
+
+ /* Load our TypeInfo so we don't have to process GetIDsOfNames */
+ object->iTypeInfo = NULL;
+ hr = LoadTypeInfo((IDispatch *)object, &object->iTypeInfo, clsid, 0x0);
+ if (FAILED(hr)) {
+ HeapFree(GetProcessHeap(), 0, object);
+ return hr;
+ }
+
+ *ppObj = object;
+
+ return S_OK;
+}
+
+/* Macros to get pointer to AutomationObject from the other VTables. */
+static inline AutomationObject *obj_from_IProvideClassInfo( IProvideClassInfo *iface \
) +{
+ return (AutomationObject *)((char*)iface - FIELD_OFFSET(AutomationObject, \
lpvtblIProvideClassInfo)); +}
+
+static inline AutomationObject *obj_from_IProvideClassInfo2( IProvideClassInfo2 \
*iface ) +{
+ return (AutomationObject *)((char*)iface - FIELD_OFFSET(AutomationObject, \
lpvtblIProvideClassInfo2)); +}
+
+static inline AutomationObject *obj_from_IProvideMultipleClassInfo( \
IProvideMultipleClassInfo *iface ) +{
+ return (AutomationObject *)((char*)iface - FIELD_OFFSET(AutomationObject, \
lpvtblIProvideMultipleClassInfo)); +}
+
+/*
+ * AutomationObject methods
+ */
+
+/*** IUnknown methods ***/
+static HRESULT WINAPI AutomationObject_QueryInterface(IDispatch* iface, REFIID riid, \
void** ppvObject) +{
+ AutomationObject *This = (AutomationObject *)iface;
+
+ TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
+
+ if ( (This==0) || (ppvObject==0) )
+ return E_INVALIDARG;
+
+ *ppvObject = 0;
+
+ if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IDispatch) || \
IsEqualGUID(riid, This->clsid)) + *ppvObject = This;
+ else if (IsEqualGUID(riid, &IID_IProvideClassInfo))
+ *ppvObject = (IProvideClassInfo*)&(This->lpvtblIProvideClassInfo);
+ else if (IsEqualGUID(riid, &IID_IProvideClassInfo2))
+ *ppvObject = (IProvideClassInfo2*)&(This->lpvtblIProvideClassInfo2);
+ else if (IsEqualGUID(riid, &IID_IProvideMultipleClassInfo))
+ *ppvObject = (IProvideMultipleClassInfo*)&(This->lpvtblIProvideMultipleClassInfo);
+
+ if ((*ppvObject)==0)
+ {
+ TRACE("() : asking for unsupported interface %s\n",debugstr_guid(riid));
+ return E_NOINTERFACE;
+ }
+
+ /*
+ * Query Interface always increases the reference count by one when it is
+ * successful
+ */
+ IClassFactory_AddRef(iface);
+
+ return S_OK;
+}
+
+static ULONG WINAPI AutomationObject_AddRef(IDispatch* iface)
+{
+ AutomationObject *This = (AutomationObject *)iface;
+
+ TRACE("(%p/%p)\n", iface, This);
+
+ return InterlockedIncrement(&This->ref);
+}
+
+static ULONG WINAPI AutomationObject_Release(IDispatch* iface)
+{
+ AutomationObject *This = (AutomationObject *)iface;
+ ULONG ref = InterlockedDecrement(&This->ref);
+
+ TRACE("(%p/%p)\n", iface, This);
+
+ if (!ref)
+ {
+ MsiCloseHandle(This->msiHandle);
+ HeapFree(GetProcessHeap(), 0, This);
+ }
+
+ return ref;
+}
+
+/*** IDispatch methods ***/
+static HRESULT WINAPI AutomationObject_GetTypeInfoCount(
+ IDispatch* iface,
+ UINT* pctinfo)
+{
+ AutomationObject *This = (AutomationObject *)iface;
+
+ TRACE("(%p/%p)->(%p)\n", iface, This, pctinfo);
+ *pctinfo = 1;
+ return S_OK;
+}
+
+static HRESULT WINAPI AutomationObject_GetTypeInfo(
+ IDispatch* iface,
+ UINT iTInfo,
+ LCID lcid,
+ ITypeInfo** ppTInfo)
+{
+ AutomationObject *This = (AutomationObject *)iface;
+ TRACE("(%p/%p)->(%d,%d,%p)\n", iface, This, iTInfo, lcid, ppTInfo);
+
+ ITypeInfo_AddRef(This->iTypeInfo);
+ *ppTInfo = This->iTypeInfo;
+ return S_OK;
+}
+
+static HRESULT WINAPI AutomationObject_GetIDsOfNames(
+ IDispatch* iface,
+ REFIID riid,
+ LPOLESTR* rgszNames,
+ UINT cNames,
+ LCID lcid,
+ DISPID* rgDispId)
+{
+ AutomationObject *This = (AutomationObject *)iface;
+ TRACE("(%p/%p)->(%p,%p,%d,%d,%p)\n", iface, This, riid, rgszNames, cNames, lcid, \
rgDispId); +
+ if (!IsEqualGUID(riid, &IID_NULL)) return E_INVALIDARG;
+ return ITypeInfo_GetIDsOfNames(This->iTypeInfo, rgszNames, cNames, rgDispId);
+}
+
+/* Some error checking is done here to simplify individual object function \
invocation */ +static HRESULT WINAPI AutomationObject_Invoke(
+ IDispatch* iface,
+ DISPID dispIdMember,
+ REFIID riid,
+ LCID lcid,
+ WORD wFlags,
+ DISPPARAMS* pDispParams,
+ VARIANT* pVarResult,
+ EXCEPINFO* pExcepInfo,
+ UINT* puArgErr)
+{
+ AutomationObject *This = (AutomationObject *)iface;
+ HRESULT hr;
+ unsigned int uArgErr;
+ VARIANT varResultDummy;
+ BSTR bstrName = NULL;
+
+ TRACE("(%p/%p)->(%d,%p,%d,%d,%p,%p,%p,%p)\n", iface, This, dispIdMember, riid, \
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); +
+ if (!IsEqualIID(riid, &IID_NULL))
+ {
+ ERR("riid was %s instead of IID_NULL\n", debugstr_guid(riid));
+ return DISP_E_UNKNOWNNAME;
+ }
+
+ if (!pDispParams)
+ {
+ ERR("NULL pDispParams not allowed\n");
+ return DISP_E_PARAMNOTOPTIONAL;
+ }
+
+ if (wFlags & DISPATCH_PROPERTYGET && !pVarResult)
+ {
+ ERR("NULL pVarResult not allowed when DISPATCH_PROPERTYGET specified\n");
+ return DISP_E_PARAMNOTOPTIONAL;
+ }
+
+ /* This simplifies our individual object invocation functions */
+ if (puArgErr == NULL) puArgErr = &uArgErr;
+ if (pVarResult == NULL) pVarResult = &varResultDummy;
+
+ /* Assume return type is void unless determined otherwise */
+ VariantInit(pVarResult);
+
+ /* If we are tracing, we want to see the name of the member we are invoking */
+ if (TRACE_ON(msi))
+ {
+ ITypeInfo_GetDocumentation(This->iTypeInfo, dispIdMember, &bstrName, NULL, NULL, \
NULL); + TRACE("Method %d, %s\n", dispIdMember, debugstr_w(bstrName));
+ }
+
+ hr = This->funcInvoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr);
+
+ if (hr == DISP_E_MEMBERNOTFOUND) {
+ if (bstrName == NULL) ITypeInfo_GetDocumentation(This->iTypeInfo, dispIdMember, \
&bstrName, NULL, NULL, NULL); + FIXME("Method %d, %s wflags %d not implemented, clsid \
%s\n", dispIdMember, debugstr_w(bstrName), wFlags, debugstr_guid(This->clsid)); + \
} +
+ TRACE("Returning %d, %s\n", hr, hr == S_OK ? "ok" : "not ok");
+
+ return hr;
+}
+
+static const struct IDispatchVtbl AutomationObject_Vtbl =
+{
+ AutomationObject_QueryInterface,
+ AutomationObject_AddRef,
+ AutomationObject_Release,
+ AutomationObject_GetTypeInfoCount,
+ AutomationObject_GetTypeInfo,
+ AutomationObject_GetIDsOfNames,
+ AutomationObject_Invoke
+};
+
+/*
+ * IProvideClassInfo methods
+ */
+
+static HRESULT WINAPI AutomationObject_IProvideClassInfo_QueryInterface(
+ IProvideClassInfo* iface,
+ REFIID riid,
+ VOID** ppvoid)
+{
+ AutomationObject *This = obj_from_IProvideClassInfo(iface);
+ return AutomationObject_QueryInterface((IDispatch *)This, riid, ppvoid);
+}
+
+static ULONG WINAPI AutomationObject_IProvideClassInfo_AddRef(IProvideClassInfo* \
iface) +{
+ AutomationObject *This = obj_from_IProvideClassInfo(iface);
+ return AutomationObject_AddRef((IDispatch *)This);
+}
+
+static ULONG WINAPI AutomationObject_IProvideClassInfo_Release(IProvideClassInfo* \
iface) +{
+ AutomationObject *This = obj_from_IProvideClassInfo(iface);
+ return AutomationObject_Release((IDispatch *)This);
+}
+
+static HRESULT WINAPI AutomationObject_GetClassInfo(IProvideClassInfo* iface, \
ITypeInfo** ppTI) +{
+ AutomationObject *This = obj_from_IProvideClassInfo(iface);
+
+ TRACE("(%p/%p)->(%p)\n", iface, This, ppTI);
+ return LoadTypeInfo((IDispatch *)This, ppTI, This->clsid, 0);
+}
+
+static const IProvideClassInfoVtbl AutomationObject_IProvideClassInfo_Vtbl =
+{
+ AutomationObject_IProvideClassInfo_QueryInterface,
+ AutomationObject_IProvideClassInfo_AddRef,
+ AutomationObject_IProvideClassInfo_Release,
+ AutomationObject_GetClassInfo
+};
+
+/*
+ * IProvideClassInfo2 methods
+ */
+
+static HRESULT WINAPI AutomationObject_IProvideClassInfo2_QueryInterface(
+ IProvideClassInfo2* iface,
+ REFIID riid,
+ VOID** ppvoid)
+{
+ AutomationObject *This = obj_from_IProvideClassInfo2(iface);
+ return AutomationObject_QueryInterface((IDispatch *)This, riid, ppvoid);
+}
+
+static ULONG WINAPI AutomationObject_IProvideClassInfo2_AddRef(IProvideClassInfo2* \
iface) +{
+ AutomationObject *This = obj_from_IProvideClassInfo2(iface);
+ return AutomationObject_AddRef((IDispatch *)This);
+}
+
+static ULONG WINAPI AutomationObject_IProvideClassInfo2_Release(IProvideClassInfo2* \
iface) +{
+ AutomationObject *This = obj_from_IProvideClassInfo2(iface);
+ return AutomationObject_Release((IDispatch *)This);
+}
+
+static HRESULT WINAPI \
AutomationObject_IProvideClassInfo2_GetClassInfo(IProvideClassInfo2* iface, \
ITypeInfo** ppTI) +{
+ AutomationObject *This = obj_from_IProvideClassInfo2(iface);
+ return AutomationObject_GetClassInfo((IProvideClassInfo*)&(This->lpvtblIProvideClassInfo), \
ppTI); +}
+
+static HRESULT WINAPI AutomationObject_GetGUID(IProvideClassInfo2* iface, DWORD \
dwGuidKind, GUID* pGUID) +{
+ AutomationObject *This = obj_from_IProvideClassInfo2(iface);
+ TRACE("(%p/%p)->(%d,%s)\n", iface, This, dwGuidKind, debugstr_guid(pGUID));
+
+ if (dwGuidKind != GUIDKIND_DEFAULT_SOURCE_DISP_IID)
+ return E_INVALIDARG;
+ else {
+ *pGUID = *This->clsid;
+ return S_OK;
+ }
+}
+
+static const IProvideClassInfo2Vtbl AutomationObject_IProvideClassInfo2_Vtbl =
+{
+ AutomationObject_IProvideClassInfo2_QueryInterface,
+ AutomationObject_IProvideClassInfo2_AddRef,
+ AutomationObject_IProvideClassInfo2_Release,
+ AutomationObject_IProvideClassInfo2_GetClassInfo,
+ AutomationObject_GetGUID
+};
+
+/*
+ * IProvideMultipleClassInfo methods
+ */
+
+static HRESULT WINAPI AutomationObject_IProvideMultipleClassInfo_QueryInterface(
+ IProvideMultipleClassInfo* iface,
+ REFIID riid,
+ VOID** ppvoid)
+{
+ AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
+ return AutomationObject_QueryInterface((IDispatch *)This, riid, ppvoid);
+}
+
+static ULONG WINAPI \
AutomationObject_IProvideMultipleClassInfo_AddRef(IProvideMultipleClassInfo* iface) \
+{ + AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
+ return AutomationObject_AddRef((IDispatch *)This);
+}
+
+static ULONG WINAPI \
AutomationObject_IProvideMultipleClassInfo_Release(IProvideMultipleClassInfo* iface) \
+{ + AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
+ return AutomationObject_Release((IDispatch *)This);
+}
+
+static HRESULT WINAPI \
AutomationObject_IProvideMultipleClassInfo_GetClassInfo(IProvideMultipleClassInfo* \
iface, ITypeInfo** ppTI) +{
+ AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
+ return AutomationObject_GetClassInfo((IProvideClassInfo*)&(This->lpvtblIProvideClassInfo), \
ppTI); +}
+
+static HRESULT WINAPI \
AutomationObject_IProvideMultipleClassInfo_GetGUID(IProvideMultipleClassInfo* iface, \
DWORD dwGuidKind, GUID* pGUID) +{
+ AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
+ return AutomationObject_GetGUID((IProvideClassInfo2*)&(This->lpvtblIProvideClassInfo2), \
dwGuidKind, pGUID); +}
+
+static HRESULT WINAPI \
AutomationObject_GetMultiTypeInfoCount(IProvideMultipleClassInfo* iface, ULONG* pcti) \
+{ + AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
+
+ TRACE("(%p/%p)->(%p)\n", iface, This, pcti);
+ *pcti = 1;
+ return S_OK;
+}
+
+static HRESULT WINAPI AutomationObject_GetInfoOfIndex(IProvideMultipleClassInfo* \
iface, + ULONG iti,
+ DWORD dwFlags,
+ ITypeInfo** pptiCoClass,
+ DWORD* pdwTIFlags,
+ ULONG* pcdispidReserved,
+ IID* piidPrimary,
+ IID* piidSource)
+{
+ AutomationObject *This = obj_from_IProvideMultipleClassInfo(iface);
+
+ TRACE("(%p/%p)->(%d,%d,%p,%p,%p,%p,%p)\n", iface, This, iti, dwFlags, \
pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, piidSource); +
+ if (iti != 0)
+ return E_INVALIDARG;
+
+ if (dwFlags & MULTICLASSINFO_GETTYPEINFO)
+ LoadTypeInfo((IDispatch *)This, pptiCoClass, This->clsid, 0);
+
+ if (dwFlags & MULTICLASSINFO_GETNUMRESERVEDDISPIDS)
+ {
+ *pdwTIFlags = 0;
+ *pcdispidReserved = 0;
+ }
+
+ if (dwFlags & MULTICLASSINFO_GETIIDPRIMARY){
+ *piidPrimary = *This->clsid;
+ }
+
+ if (dwFlags & MULTICLASSINFO_GETIIDSOURCE){
+ *piidSource = *This->clsid;
+ }
+
+ return S_OK;
+}
+
+static const IProvideMultipleClassInfoVtbl \
AutomationObject_IProvideMultipleClassInfo_Vtbl = +{
+ AutomationObject_IProvideMultipleClassInfo_QueryInterface,
+ AutomationObject_IProvideMultipleClassInfo_AddRef,
+ AutomationObject_IProvideMultipleClassInfo_Release,
+ AutomationObject_IProvideMultipleClassInfo_GetClassInfo,
+ AutomationObject_IProvideMultipleClassInfo_GetGUID,
+ AutomationObject_GetMultiTypeInfoCount,
+ AutomationObject_GetInfoOfIndex
+};
+
+/*
+ * Individual Object Invocation Functions
+ */
+
+HRESULT WINAPI RecordImpl_Invoke(
+ AutomationObject* This,
+ DISPID dispIdMember,
+ REFIID riid,
+ LCID lcid,
+ WORD wFlags,
+ DISPPARAMS* pDispParams,
+ VARIANT* pVarResult,
+ EXCEPINFO* pExcepInfo,
+ UINT* puArgErr)
+{
+ WCHAR szString[MAX_MSI_STRING];
+ DWORD dwLen = MAX_MSI_STRING;
+ UINT ret;
+ VARIANTARG varg0, varg1;
+ HRESULT hr;
+
+ VariantInit(&varg0);
+ VariantInit(&varg1);
+
+ switch (dispIdMember)
+ {
+ case DISPID_RECORD_STRINGDATA:
+ if (wFlags & DISPATCH_PROPERTYGET) {
+ hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
+ if (hr != S_OK) return hr;
+ V_VT(pVarResult) = VT_BSTR;
+ if ((ret = MsiRecordGetStringW(This->msiHandle, V_I4(&varg0), szString, &dwLen)) \
== ERROR_SUCCESS) + V_BSTR(pVarResult) = SysAllocString(szString);
+ else
+ {
+ TRACE("MsiRecordGetString returned %d\n", ret);
+ V_BSTR(pVarResult) = NULL;
+ }
+ } else if (wFlags & DISPATCH_PROPERTYPUT) {
+ hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
+ if (hr != S_OK) return hr;
+ hr = DispGetParam(pDispParams, DISPID_PROPERTYPUT, VT_BSTR, &varg1, \
puArgErr); + if (hr != S_OK) return hr;
+ if ((ret = MsiRecordSetStringW(This->msiHandle, V_I4(&varg0), V_BSTR(&varg1))) != \
ERROR_SUCCESS) + TRACE("MsiRecordSetString returned %d\n", ret);
+ }
+ break;
+
+ default:
+ return DISP_E_MEMBERNOTFOUND;
+ }
+
+ return S_OK;
+}
+
+HRESULT WINAPI ViewImpl_Invoke(
+ AutomationObject* This,
+ DISPID dispIdMember,
+ REFIID riid,
+ LCID lcid,
+ WORD wFlags,
+ DISPPARAMS* pDispParams,
+ VARIANT* pVarResult,
+ EXCEPINFO* pExcepInfo,
+ UINT* puArgErr)
+{
+ MSIHANDLE msiHandle;
+ IDispatch *iDispatch = NULL;
+ UINT ret;
+ VARIANTARG varg0, varg1;
+ HRESULT hr;
+
+ VariantInit(&varg0);
+ VariantInit(&varg1);
+
+ switch (dispIdMember)
+ {
+ case DISPID_VIEW_EXECUTE:
+ if (wFlags & DISPATCH_METHOD)
+ {
+ hr = DispGetParam(pDispParams, 0, VT_DISPATCH, &varg0, puArgErr);
+ if (hr == S_OK)
+ MsiViewExecute(This->msiHandle, ((AutomationObject \
*)V_DISPATCH(&varg0))->msiHandle); + else
+ MsiViewExecute(This->msiHandle, 0);
+ }
+ break;
+
+ case DISPID_VIEW_FETCH:
+ if (wFlags & DISPATCH_METHOD)
+ {
+ V_VT(pVarResult) = VT_DISPATCH;
+ if ((ret = MsiViewFetch(This->msiHandle, &msiHandle)) == ERROR_SUCCESS)
+ create_automation_object(msiHandle, NULL, (LPVOID)&iDispatch, &DIID_Record, \
RecordImpl_Invoke); + else TRACE("MsiViewFetch returned %d\n", ret);
+ V_DISPATCH(pVarResult) = iDispatch;
+ }
+ break;
+
+ case DISPID_VIEW_CLOSE:
+ if (wFlags & DISPATCH_METHOD)
+ {
+ MsiViewClose(This->msiHandle);
+ }
+ break;
+
+ default:
+ return DISP_E_MEMBERNOTFOUND;
+ }
+
+ return S_OK;
+}
+
+HRESULT WINAPI DatabaseImpl_Invoke(
+ AutomationObject* This,
+ DISPID dispIdMember,
+ REFIID riid,
+ LCID lcid,
+ WORD wFlags,
+ DISPPARAMS* pDispParams,
+ VARIANT* pVarResult,
+ EXCEPINFO* pExcepInfo,
+ UINT* puArgErr)
+{
+ MSIHANDLE msiHandle;
+ IDispatch *iDispatch = NULL;
+ UINT ret;
+ VARIANTARG varg0, varg1;
+ HRESULT hr;
+
+ VariantInit(&varg0);
+ VariantInit(&varg1);
+
+ switch (dispIdMember)
+ {
+ case DISPID_DATABASE_OPENVIEW:
+ if (wFlags & DISPATCH_METHOD)
+ {
+ hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
+ if (hr != S_OK) return hr;
+ V_VT(pVarResult) = VT_DISPATCH;
+ if ((ret = MsiDatabaseOpenViewW(This->msiHandle, V_BSTR(&varg0), &msiHandle)) == \
ERROR_SUCCESS) + create_automation_object(msiHandle, NULL, (LPVOID)&iDispatch, \
&DIID_View, ViewImpl_Invoke); + else TRACE("MsiDatabaseOpenView returned %d\n", \
ret); + V_DISPATCH(pVarResult) = iDispatch;
+ }
+ break;
+
+ default:
+ return DISP_E_MEMBERNOTFOUND;
+ }
+
+ return S_OK;
+}
+
+HRESULT WINAPI SessionImpl_Invoke(
+ AutomationObject* This,
+ DISPID dispIdMember,
+ REFIID riid,
+ LCID lcid,
+ WORD wFlags,
+ DISPPARAMS* pDispParams,
+ VARIANT* pVarResult,
+ EXCEPINFO* pExcepInfo,
+ UINT* puArgErr)
+{
+ WCHAR szString[MAX_MSI_STRING];
+ DWORD dwLen = MAX_MSI_STRING;
+ IDispatch *iDispatch = NULL;
+ MSIHANDLE msiHandle;
+ LANGID langId;
+ UINT ret;
+ INSTALLSTATE iInstalled, iAction;
+ VARIANTARG varg0, varg1;
+ HRESULT hr;
+
+ VariantInit(&varg0);
+ VariantInit(&varg1);
+
+ switch (dispIdMember)
+ {
+ case DISPID_SESSION_PROPERTY:
+ if (wFlags & DISPATCH_PROPERTYGET) {
+ hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
+ if (hr != S_OK) return hr;
+ V_VT(pVarResult) = VT_BSTR;
+ if (MsiGetPropertyW(This->msiHandle, V_BSTR(&varg0), szString, &dwLen) == \
ERROR_SUCCESS) + V_BSTR(pVarResult) = SysAllocString(szString);
+ else
+ V_BSTR(pVarResult) = NULL;
+ } else if (wFlags & DISPATCH_PROPERTYPUT) {
+ hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
+ if (hr != S_OK) return hr;
+ hr = DispGetParam(pDispParams, DISPID_PROPERTYPUT, VT_BSTR, &varg1, \
puArgErr); + if (hr != S_OK) return hr;
+ if ((ret = MsiSetPropertyW(This->msiHandle, V_BSTR(&varg0), V_BSTR(&varg1))) != \
ERROR_SUCCESS) + TRACE("MsiSetProperty returned %d\n", ret);
+ }
+ break;
+
+ case DISPID_SESSION_LANGUAGE:
+ if (wFlags & DISPATCH_PROPERTYGET) {
+ langId = MsiGetLanguage(This->msiHandle);
+ V_VT(pVarResult) = VT_I4;
+ V_I4(pVarResult) = langId;
+ }
+ break;
+
+ case DISPID_SESSION_MODE:
+ if (wFlags & DISPATCH_PROPERTYGET) {
+ hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
+ if (hr != S_OK) return hr;
+ V_VT(pVarResult) = VT_BOOL;
+ V_BOOL(pVarResult) = MsiGetMode(This->msiHandle, V_I4(&varg0));
+ } else if (wFlags & DISPATCH_PROPERTYPUT) {
+ hr = DispGetParam(pDispParams, 0, VT_I4, &varg0, puArgErr);
+ if (hr != S_OK) return hr;
+ hr = DispGetParam(pDispParams, DISPID_PROPERTYPUT, VT_BOOL, &varg1, \
puArgErr); + if (hr != S_OK) return hr;
+ if ((ret = MsiSetMode(This->msiHandle, V_I4(&varg0), V_BOOL(&varg1))) != \
ERROR_SUCCESS) + TRACE("MsiSetMode returned %d\n", ret);
+ }
+ break;
+
+ case DISPID_SESSION_DATABASE:
+ if (wFlags & DISPATCH_PROPERTYGET) {
+ V_VT(pVarResult) = VT_DISPATCH;
+ if ((msiHandle = MsiGetActiveDatabase(This->msiHandle)))
+ create_automation_object(msiHandle, NULL, (LPVOID)&iDispatch, &DIID_Database, \
DatabaseImpl_Invoke); + else TRACE("MsiGetActiveDatabase failed\n");
+ V_DISPATCH(pVarResult) = iDispatch;
+ }
+ break;
+
+ case DISPID_SESSION_FEATURECURRENTSTATE:
+ if (wFlags & DISPATCH_PROPERTYGET) {
+ hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
+ if (hr != S_OK) return hr;
+ V_VT(pVarResult) = VT_I4;
+ if ((ret = MsiGetFeatureStateW(This->msiHandle, V_BSTR(&varg0), &iInstalled, \
&iAction)) == ERROR_SUCCESS) + V_I4(pVarResult) = iInstalled;
+ else
+ {
+ TRACE("MsiGetFeatureState returned %d\n", ret);
+ V_I4(pVarResult) = msiInstallStateUnknown;
+ }
+ }
+ break;
+
+ case DISPID_SESSION_FEATUREREQUESTSTATE:
+ if (wFlags & DISPATCH_PROPERTYGET) {
+ hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
+ if (hr != S_OK) return hr;
+ V_VT(pVarResult) = VT_I4;
+ if ((ret = MsiGetFeatureStateW(This->msiHandle, V_BSTR(&varg0), &iInstalled, \
&iAction)) == ERROR_SUCCESS) + V_I4(pVarResult) = iAction;
+ else
+ {
+ TRACE("MsiGetFeatureState returned %d\n", ret);
+ V_I4(pVarResult) = msiInstallStateUnknown;
+ }
+ } else if (wFlags & DISPATCH_PROPERTYPUT) {
+ hr = DispGetParam(pDispParams, 0, VT_BSTR, &varg0, puArgErr);
+ if (hr != S_OK) return hr;
+ hr = DispGetParam(pDispParams, DISPID_PROPERTYPUT, VT_I4, &varg1, \
puArgErr); + if (hr != S_OK) return hr;
+ if ((ret = MsiSetFeatureStateW(This->msiHandle, V_BSTR(&varg0), V_I4(&varg1))) != \
ERROR_SUCCESS) + TRACE("MsiSetFeatureState returned %d\n", ret);
+ }
+ break;
+
+ default:
+ return DISP_E_MEMBERNOTFOUND;
+ }
+
+ return S_OK;
+}
+
+/* Wrapper around create_automation_object to create a session object. */
+HRESULT create_session(MSIHANDLE msiHandle, IDispatch **pDispatch)
+{
+ return create_automation_object(msiHandle, NULL, (LPVOID)pDispatch, \
&DIID_Session, SessionImpl_Invoke); +}
diff --git a/dlls/msi/msipriv.h b/dlls/msi/msipriv.h
index 971f71e..23768c0 100644
--- a/dlls/msi/msipriv.h
+++ b/dlls/msi/msipriv.h
@@ -788,6 +788,10 @@ extern VOID ControlEvent_SubscribeToEven
extern VOID ControlEvent_UnSubscribeToEvent( MSIPACKAGE *package, LPCWSTR event,
LPCWSTR control, LPCWSTR attribute );
+/* OLE automation */
+extern HRESULT create_session(MSIHANDLE msiHandle, IDispatch **pDispatch);
+extern HRESULT WINAPI LoadTypeInfo(IDispatch *iface, ITypeInfo **pptinfo, REFIID \
clsid, LCID lcid); +
/* User Interface messages from the actions */
extern void ui_progress(MSIPACKAGE *, int, int, int, int);
extern void ui_actiondata(MSIPACKAGE *, LPCWSTR, MSIRECORD *);
--
1.4.1
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic