UMSKT
/
xpmgr
mirror of https://github.com/UMSKT/xpmgr.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
xpmgr/BuildTools/Include/SyncMgr.idl

1189 lines
46 KiB
Plaintext
Raw Blame History

//****************************************************************************
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// File: SyncMgr.idl
//
// Contents: Types and interfaces for integrating with Sync Center.
//
//****************************************************************************
#ifndef DO_NO_IMPORTS
import "objidl.idl";
import "oleidl.idl";
import "shobjidl.idl"; // IShellItem
import "ocidl.idl"; // IObjectWithSite
import "comcat.idl"; // IEnumString
#endif
interface ISyncMgrHandlerCollection;
interface ISyncMgrHandler;
interface ISyncMgrHandlerInfo;
interface ISyncMgrSyncItemContainer;
interface ISyncMgrSyncItem;
interface ISyncMgrSyncItemInfo;
interface IEnumSyncMgrSyncItems;
interface ISyncMgrSessionCreator;
interface ISyncMgrSyncCallback;
interface ISyncMgrUIOperation;
interface ISyncMgrEventLinkUIOperation;
interface ISyncMgrScheduleWizardUIOperation;
interface ISyncMgrControl;
interface ISyncMgrEventStore;
interface ISyncMgrEvent;
interface IEnumSyncMgrEvents;
interface ISyncMgrConflictStore;
interface IEnumSyncMgrConflict;
interface ISyncMgrConflict;
interface ISyncMgrResolutionHandler;
interface ISyncMgrConflictPresenter;
interface ISyncMgrConflictFolder;
interface ISyncMgrConflictItems;
interface ISyncMgrConflictResolutionItems;
const ULONG MAX_SYNCMGR_ID = 64;
const ULONG MAX_SYNCMGR_PROGRESSTEXT = 260;
const ULONG MAX_SYNCMGR_NAME = 128;
//
// The ISyncMgrHandlerCollection interface allows a handler writer to add
// handlers to the Sync Center folder dynamically instead of registering each
// one in the registry. For example, a handler collection could be used to
// expose each music device in the top-level Sync Center folder.
//
// A handler ID is a string that uniquely represents the handler. The ID must
// be unique across all handlers in the system. For that reason, most handler
// IDs will be simply string-ized GUIDs.
//
[
object,
uuid(a7f337a3-d20b-45cb-9ed7-87d094ca5045)
]
interface ISyncMgrHandlerCollection : IUnknown
{
HRESULT GetHandlerEnumerator([out] IEnumString **ppenum);
HRESULT BindToHandler([in, ref, string] LPCWSTR pszHandlerID, [in] REFIID riid, [out, iid_is(riid)] void **ppv);
}
//
// These values specify the capabilities of a handler with respect to the
// actions that can be performed against it.
//
typedef [v1_enum] enum SYNCMGR_HANDLER_CAPABILITIES
{
SYNCMGR_HCM_NONE = 0x00000000,
SYNCMGR_HCM_PROVIDES_ICON = 0x00000001,
SYNCMGR_HCM_EVENT_STORE = 0x00000002,
SYNCMGR_HCM_CONFLICT_STORE = 0x00000004,
SYNCMGR_HCM_SUPPORTS_CONCURRENT_SESSIONS = 0x00000010,
SYNCMGR_HCM_CAN_BROWSE_CONTENT = 0x00010000,
SYNCMGR_HCM_CAN_SHOW_SCHEDULE = 0x00020000,
SYNCMGR_HCM_QUERY_BEFORE_ACTIVATE = 0x00100000,
SYNCMGR_HCM_QUERY_BEFORE_DEACTIVATE = 0x00200000,
SYNCMGR_HCM_QUERY_BEFORE_ENABLE = 0x00400000,
SYNCMGR_HCM_QUERY_BEFORE_DISABLE = 0x00800000,
SYNCMGR_HCM_VALID_MASK = 0x00f30017
} SYNCMGR_HANDLER_CAPABILITIES;
//
// These values specify policies a handler can specify that deviate from
// normal operations.
//
typedef [v1_enum] enum SYNCMGR_HANDLER_POLICIES
{
SYNCMGR_HPM_NONE = 0x00000000,
// These policies prevent tasks from showing up in the UI.
SYNCMGR_HPM_PREVENT_ACTIVATE = 0x00000001,
SYNCMGR_HPM_PREVENT_DEACTIVATE = 0x00000002,
SYNCMGR_HPM_PREVENT_ENABLE = 0x00000004,
SYNCMGR_HPM_PREVENT_DISABLE = 0x00000008,
SYNCMGR_HPM_PREVENT_START_SYNC = 0x00000010,
SYNCMGR_HPM_PREVENT_STOP_SYNC = 0x00000020,
SYNCMGR_HPM_DISABLE_ENABLE = 0x00000100,
SYNCMGR_HPM_DISABLE_DISABLE = 0x00000200,
SYNCMGR_HPM_DISABLE_START_SYNC = 0x00000400,
SYNCMGR_HPM_DISABLE_STOP_SYNC = 0x00000800,
SYNCMGR_HPM_DISABLE_BROWSE = 0x00001000,
SYNCMGR_HPM_DISABLE_SCHEDULE = 0x00002000,
SYNCMGR_HPM_HIDDEN_BY_DEFAULT = 0x00010000,
SYNCMGR_HPM_BACKGROUND_SYNC_ONLY = (SYNCMGR_HPM_PREVENT_START_SYNC | SYNCMGR_HPM_PREVENT_STOP_SYNC),
SYNCMGR_HPM_VALID_MASK = 0x00012f3f
} SYNCMGR_HANDLER_POLICIES;
//
// ISyncMgrHandler is the primary interface implemented by a sync handler.
// Sync Center will instantiate the handler with this interface to get
// properties, to enumerate sync items. and to modify state. It will also be
// instantiated on a separate thread to perform a synchronization or a UI
// operation.
//
// The handler can implement the handler info interface on the same object or
// on a separate object.
//
// The following types of operations can be specified to GetObject():
//
// SYNCMGR_OBJECTID_Icon
// If the handler info interface doesn't return a value from the
// GetIconLocation() method, Sync Center will call GetObject() with this
// object ID to allow the handler to implement IExtractIcon.
// SYNCMGR_OBJECTID_EventStore
// Provide an event store for events specific to the handler.
// SYNCMGR_OBJECTID_ConflictStore
// Provide a conflict store for conflicts specific to the handler.
// SYNCMGR_OBJECTID_BrowseContent
// Show UI to allow the user to browse the content of the handler.
// SYNCMGR_OBJECTID_ShowSchedule
// Show UI that allows the user to configure the schedule for the
// handler.
// SYNCMGR_OBJECTID_QueryBeforeActivate
// Query the user before a handler is activated. This occurs when the
// user requests that a handler in the New Handlers folder be setup.
// SYNCMGR_OBJECTID_QueryBeforeDeactivate
// Query the user when the user chooses to delete a partnership from the
// active partnerships folder.
// SYNCMGR_OBJECTID_QueryBeforeEnable
// Query the user before enabling the handler.
// SYNCMGR_OBJECTID_QueryBeforeDisable
// Query the user before disabling the handler.
//
[
object,
uuid(04ec2e43-ac77-49f9-9b98-0307ef7a72a2)
]
interface ISyncMgrHandler : IUnknown
{
HRESULT GetName([out, string] LPWSTR *ppszName);
HRESULT GetHandlerInfo([out] ISyncMgrHandlerInfo **ppHandlerInfo);
HRESULT GetObject([in] REFGUID rguidObjectID, [in] REFIID riid, [out, iid_is(riid)] void **ppv);
HRESULT GetCapabilities([out] SYNCMGR_HANDLER_CAPABILITIES *pmCapabilities);
HRESULT GetPolicies([out] SYNCMGR_HANDLER_POLICIES *pmPolicies);
HRESULT Activate([in] BOOL fActivate);
HRESULT Enable([in] BOOL fEnable);
HRESULT Synchronize(
[in, ref, string, size_is(cItems)] LPCWSTR *ppszItemIDs,
[in] ULONG cItems,
[in, unique] HWND hwndOwner,
[in] ISyncMgrSessionCreator *pSessionCreator,
[in, unique] IUnknown *punk);
}
//
// These values identify the handler to Sync Center and allow handlers to be
// easily grouped together in the folder.
//
typedef [v1_enum] enum SYNCMGR_HANDLER_TYPE
{
SYNCMGR_HT_UNSPECIFIED = 0, // All handlers that do not specify or do not fit
// in the rest of the options should use this value.
SYNCMGR_HT_APPLICATION = 1, // Handler is an application.
SYNCMGR_HT_DEVICE = 2, // Handler syncs with a device.
SYNCMGR_HT_FOLDER = 3, // Handler syncs with local or remote folders.
SYNCMGR_HT_SERVICE = 4, // Handler syncs with a web service.
SYNCMGR_HT_COMPUTER = 5, // Handler syncs with a computer.
SYNCMGR_HT_MIN = 0,
SYNCMGR_HT_MAX = SYNCMGR_HT_COMPUTER
} SYNCMGR_HANDLER_TYPE;
//
// The ISyncMgrHandlerInfo interface provides all the optional properties for
// the handler. By defining this as an interface the set of properties can be
// changed in the future without requiring handlers to be recompiled. It also
// provides type-safe access to the properties.
//
[
object,
uuid(4ff1d798-ecf7-4524-aa81-1e362a0aef3a)
]
interface ISyncMgrHandlerInfo : IUnknown
{
HRESULT GetType([out] SYNCMGR_HANDLER_TYPE *pnType);
HRESULT GetTypeLabel([out, string] LPWSTR *ppszTypeLabel);
HRESULT GetComment([out, string] LPWSTR *ppszComment);
HRESULT GetLastSyncTime([out] FILETIME *pftLastSync);
HRESULT IsActive();
HRESULT IsEnabled();
HRESULT IsConnected();
}
//
// The ISyncMgrSyncItemContainer interface is implemented by handlers to
// provide information about the items contained in them. Sync Center will
// call QueryInterface() on the ISyncMgrHandler interface to query for the
// ISyncMgrItemContainer interface.
//
[
object,
uuid(90701133-be32-4129-a65c-99e616cafff4)
]
interface ISyncMgrSyncItemContainer : IUnknown
{
HRESULT GetSyncItem([in, ref, string] LPCWSTR pszItemID, [out] ISyncMgrSyncItem **ppItem);
HRESULT GetSyncItemEnumerator([out] IEnumSyncMgrSyncItems **ppenum);
HRESULT GetSyncItemCount([out] ULONG *pcItems);
}
//
// These values specify the capabilities of a sync item with respect to the
// actions that can be performed against it.
//
typedef [v1_enum] enum SYNCMGR_ITEM_CAPABILITIES
{
SYNCMGR_ICM_NONE = 0x00000000,
SYNCMGR_ICM_PROVIDES_ICON = 0x00000001,
SYNCMGR_ICM_EVENT_STORE = 0x00000002,
SYNCMGR_ICM_CONFLICT_STORE = 0x00000004,
SYNCMGR_ICM_CAN_DELETE = 0x00000010,
SYNCMGR_ICM_CAN_BROWSE_CONTENT = 0x00010000,
SYNCMGR_ICM_QUERY_BEFORE_ENABLE = 0x00100000,
SYNCMGR_ICM_QUERY_BEFORE_DISABLE = 0x00200000,
SYNCMGR_ICM_QUERY_BEFORE_DELETE = 0x00400000,
SYNCMGR_ICM_VALID_MASK = 0x00710017
} SYNCMGR_ITEM_CAPABILITIES;
//
// These values specify policies an item can specify that deviate from
// normal operations.
//
typedef [v1_enum] enum SYNCMGR_ITEM_POLICIES
{
SYNCMGR_IPM_NONE = 0x00000000,
SYNCMGR_IPM_PREVENT_ENABLE = 0x00000001,
SYNCMGR_IPM_PREVENT_DISABLE = 0x00000002,
SYNCMGR_IPM_PREVENT_START_SYNC = 0x00000004,
SYNCMGR_IPM_PREVENT_STOP_SYNC = 0x00000008,
SYNCMGR_IPM_DISABLE_ENABLE = 0x00000010,
SYNCMGR_IPM_DISABLE_DISABLE = 0x00000020,
SYNCMGR_IPM_DISABLE_START_SYNC = 0x00000040,
SYNCMGR_IPM_DISABLE_STOP_SYNC = 0x00000080,
SYNCMGR_IPM_DISABLE_BROWSE = 0x00000100,
SYNCMGR_IPM_DISABLE_DELETE = 0x00000200,
SYNCMGR_IPM_HIDDEN_BY_DEFAULT = 0x00010000,
SYNCMGR_IPM_VALID_MASK = 0x000102ff
} SYNCMGR_ITEM_POLICIES;
//
// The ISyncMgrSyncItem interface represents a sync item which typically
// represents a group of data (e.g. a sync item represents a folder of file).
// By defining this as an interface the item can easily be managed and
// implemented as an object, and that object maintains the state of the item
// when accessing the item.
//
// The following types of operations can be specified to GetObject():
//
// SYNCMGR_OBJECTID_Icon
// If the item info interface doesn't return a value from the
// GetIconLocation() method, Sync Center will call GetObject() with this
// object ID to allow the handler to implement IExtractIcon.
// SYNCMGR_OBJECTID_EventStore
// Provide an event store for events specific to the item.
// SYNCMGR_OBJECTID_ConflictStore
// Provide a conflict store for conflicts specific to the item.
// SYNCMGR_OBJECTID_BrowseContent
// Show UI to allow the user to browse the content of the item.
// SYNCMGR_OBJECTID_QueryBeforeEnable
// Query the user before enabling the item.
// SYNCMGR_OBJECTID_QueryBeforeDisable
// Query the user before disabling the item.
// SYNCMGR_OBJECTID_QueryBeforeDelete
// Query the user before deleting an item.
//
[
object,
uuid(b20b24ce-2593-4f04-bd8b-7ad6c45051cd)
]
interface ISyncMgrSyncItem : IUnknown
{
HRESULT GetItemID([out, string] LPWSTR *ppszItemID);
HRESULT GetName([out, string] LPWSTR *ppszName);
HRESULT GetItemInfo([out] ISyncMgrSyncItemInfo **ppItemInfo);
HRESULT GetObject([in] REFGUID rguidObjectID, [in] REFIID riid, [out, iid_is(riid)] void **ppv);
HRESULT GetCapabilities([out] SYNCMGR_ITEM_CAPABILITIES *pmCapabilities);
HRESULT GetPolicies([out] SYNCMGR_ITEM_POLICIES *pmPolicies);
HRESULT Enable([in] BOOL fEnable);
HRESULT Delete();
}
//
// The ISyncMgrSyncItemInfo interface provides all the optional properties for
// the handler. Just as with handler info, by defining this as an interface
// the set of properties can be changed in the future without requiring
// handlers to be recompiled. It also provides type-safe access to the
// properties.
//
// An alternate approach would be to define a single method that returns a
// structure.
//
[
object,
uuid(e7fd9502-be0c-4464-90a1-2b5277031232)
]
interface ISyncMgrSyncItemInfo : IUnknown
{
HRESULT GetTypeLabel([out, string] LPWSTR *ppszTypeLabel);
HRESULT GetComment([out, string] LPWSTR *ppszComment);
HRESULT GetLastSyncTime([out] FILETIME *pftLastSync);
HRESULT IsEnabled();
HRESULT IsConnected();
}
//
// The IEnumSyncMgrSyncItems interface simply enumerates the sync item objects
// managed by the handler.
//
[
object,
uuid(54b3abf3-f085-4181-b546-e29c403c726b)
]
interface IEnumSyncMgrSyncItems : IUnknown
{
HRESULT Next(
[in] ULONG celt,
[out, size_is(celt), length_is(*pceltFetched)] ISyncMgrSyncItem **rgelt,
[out] ULONG *pceltFetched);
HRESULT Skip([in] ULONG celt);
HRESULT Reset();
HRESULT Clone([out] IEnumSyncMgrSyncItems **ppenum);
}
//
// These values are used to indicate the current status of the progress report
// in the call to ReportProgress().
//
typedef [v1_enum] enum SYNCMGR_PROGRESS_STATUS
{
SYNCMGR_PS_UPDATING = 1,
SYNCMGR_PS_UPDATING_INDETERMINATE = 2,
SYNCMGR_PS_SUCCEEDED = 3,
SYNCMGR_PS_FAILED = 4,
SYNCMGR_PS_CANCELED = 5,
SYNCMGR_PS_DISCONNECTED = 6,
SYNCMGR_PS_MAX = SYNCMGR_PS_DISCONNECTED
} SYNCMGR_PROGRESS_STATUS;
//
// These values are used to indicate whether the user has requested a sync
// operation be canceled when progress is being reported.
//
typedef [v1_enum] enum SYNCMGR_CANCEL_REQUEST
{
SYNCMGR_CR_NONE = 0,
SYNCMGR_CR_CANCEL_ITEM = 1,
SYNCMGR_CR_CANCEL_ALL = 2,
SYNCMGR_CR_MAX = SYNCMGR_CR_CANCEL_ALL
} SYNCMGR_CANCEL_REQUEST;
//
// These values are used to indicate the error level of an event in a call to
// the ReportEvent() method.
//
typedef [v1_enum] enum SYNCMGR_EVENT_LEVEL
{
SYNCMGR_EL_INFORMATION = 1,
SYNCMGR_EL_WARNING = 2,
SYNCMGR_EL_ERROR = 3,
SYNCMGR_EL_MAX = SYNCMGR_EL_ERROR
} SYNCMGR_EVENT_LEVEL;
typedef [v1_enum] enum SYNCMGR_EVENT_FLAGS
{
SYNCMGR_EF_NONE = 0x00000000,
SYNCMGR_EF_VALID = 0x00000000
} SYNCMGR_EVENT_FLAGS;
//
// If a handler is implemented to perform automatic synchronizations in an
// external process (e.g. in a service), it needs to provide progress reports
// to Sync Center to allow it to update the UI for the user. It also needs
// to be able to add events to Sync Center's Sync Results folder. To allow
// the background process to report progress and events, an external process
// can CoCreate the CLSID_SyncMgrClient object with CLSCTX_SERVER and specify
// the ISyncMgrSessionCreator interface ID. This will allow that process to
// report progress and events as well as query Sync Center to determine if
// the user canceled the sync.
//
// The ISyncMgrSessionCreator interface is also passed to the Syncrhonize()
// method on the ISyncMgrHandler interface. This allows the handler to report
// progress and events itself or to signal a background proess to report
// progress and events itself.
//
// Note that the ISyncMgrSyncCallback interface should NOT be created in the
// handler and then passed to the external process.
//
[
object,
uuid(17f48517-f305-4321-a08d-b25a834918fd)
]
interface ISyncMgrSessionCreator : IUnknown
{
HRESULT CreateSession(
[in, ref, string] LPCWSTR pszHandlerID,
[in, unique, string, size_is(cItems)] LPCWSTR *ppszItemIDs,
[in] ULONG cItems,
[out] ISyncMgrSyncCallback **ppCallback);
}
//
// The ISyncMgrSyncCallback interface will be passed to the handler in the
// Synchronize() method when starting a sync. The handler is expected to call
// this interface to update the progress UI in the folder for each item and to
// notify Sync Center when it has completed synchronization for each item.
//
// The object implementing this interface will also implement the
// ISyncMgrEvents interface.
//
[
object,
uuid(884ccd87-b139-4937-a4ba-4f8e19513fbe)
]
interface ISyncMgrSyncCallback : IUnknown
{
HRESULT ReportProgress(
[in, ref, string] LPCWSTR pszItemID,
[in, unique, string] LPCWSTR pszProgressText,
[in] SYNCMGR_PROGRESS_STATUS nStatus,
[in] ULONG uCurrentStep,
[in] ULONG uMaxStep,
[in, out, unique] SYNCMGR_CANCEL_REQUEST *pnCancelRequest);
HRESULT SetHandlerProgressText(
[in, ref, string] LPCWSTR pszProgressText,
[in, out, unique] SYNCMGR_CANCEL_REQUEST *pnCancelRequest);
HRESULT ReportEvent(
[in, unique, string] LPCWSTR pszItemID,
[in] SYNCMGR_EVENT_LEVEL nLevel,
[in] SYNCMGR_EVENT_FLAGS nFlags,
[in, ref, string] LPCWSTR pszName,
[in, ref, string] LPCWSTR pszDescription,
[in, unique, string] LPCWSTR pszLinkText,
[in, unique, string] LPCWSTR pszLinkReference,
[in, unique, string] LPCWSTR pszContext, // Handler-specific data to associate with the event
[out] GUID *pguidEventID);
HRESULT CanContinue([in, ref, string] LPCWSTR pszItemID);
HRESULT QueryForAdditionalItems([out] IEnumString **ppenumItemIDs, [out] IEnumUnknown **ppenumPunks);
HRESULT AddItemToSession([in, ref, string] LPCWSTR pszItemID);
HRESULT AddIUnknownToSession([in] IUnknown *punk);
HRESULT ProposeItem([in] ISyncMgrSyncItem *pNewItem);
HRESULT CommitItem([in, ref, string] LPCWSTR pszItemID);
// Report that a sync is being performed that was requested manually from
// outside the Sync Center UI. This will cause a notification balloon to
// be displayed for this handler the first time this is called.
HRESULT ReportManualSync();
}
//
// Handlers implement the ISyncMgrUIOperation interface to provide UI for a
// particular action. Sync Center will call the GetObject() method on the
// handler or on the item to get the right type of UI operation that
// implements this interface. A handler should only implement this interface
// for operations it wants to present UI.
//
// Sync Center will create a separate thread for the UI operation. It will
// then create a new instance of the handler to get the UI object from. If
// the operation is for an item, Sync Center will ask the handler for that
// item and then ask the item for the UI operation.
//
// The following types of operations can be specified to GetObject() on
// ISyncMgrHandler or ISyncMgrSyncItem:
//
// SYNCMGR_OBJECTID_BrowseContent
// Show UI to allow the user to browse the content of the handler or
// item.
// SYNCMGR_OBJECTID_ShowSchedule
// Show UI that allows the user to configure the schedule for the
// handler.
// SYNCMGR_OBJECTID_QueryBeforeActivate
// Query the user before a handler is activated. This occurs when the
// user requests that a handler in the New Handlers folder be setup.
// SYNCMGR_OBJECTID_QueryBeforeDeactivate
// Query the user before removing a handler from the active partnerships
// folder.
// SYNCMGR_OBJECTID_QueryBeforeEnable
// Query the user before enabling a handler or item.
// SYNCMGR_OBJECTID_QueryBeforeDisable
// Query the user before disabling a handler or item.
// SYNCMGR_OBJECTID_QueryBeforeDelete
// Query the user before deleting an item.
//
[
object,
uuid(fc7cfa47-dfe1-45b5-a049-8cfd82bec271)
]
interface ISyncMgrUIOperation : IUnknown
{
HRESULT Run([in, unique] HWND hwndOwner);
}
//
// The ISyncMgrEventLinkUIOperation interface will be called when event links
// are clicked in the sync results folder. Sync Center will call GetObject()
// on the ISyncMgrHandler specifying SYNCMGR_OBJECTID_EventLinkClick for the
// object ID.
//
[
object,
uuid(64522e52-848b-4015-89ce-5a36f00b94ff)
]
interface ISyncMgrEventLinkUIOperation : ISyncMgrUIOperation
{
// The Init() method allows the object to store the event ID so that when
// the Run() method is called it knows which event to operate upon.
HRESULT Init([in] REFGUID rguidEventID, [in] ISyncMgrEvent *pEvent);
}
//
// The ISyncMgrScheduleWizardUIOperation interface allows a handler to display
// the sync schedule wizard for the handler. The wizard can be invoked by
// CoCreating CLSID_SyncMgrScheduleWizard. This is typically done whe Sync
// Center calls the GetObject() method on ISyncMgrHandler specifying
// SYNCMGR_OBJECTID_ShowSchedule for the object ID.
//
[
object,
uuid(459a6c84-21d2-4ddc-8a53-f023a46066f2)
]
interface ISyncMgrScheduleWizardUIOperation : ISyncMgrUIOperation
{
HRESULT InitWizard([in, ref, string] LPCWSTR pszHandlerID);
}
//
// Applications calling ISyncMgrControl can pass this interface to get the
// result of a StartHandlerSync() or StartItemSync() call.
//
[
object,
uuid(2b90f17e-5a3e-4b33-bb7f-1bc48056b94d)
]
interface ISyncMgrSyncResult : IUnknown
{
HRESULT Result([in] SYNCMGR_PROGRESS_STATUS nStatus, [in] UINT cError, [in] UINT cConflicts);
}
//
// These values are used to modify the operations requested on the methods of
// the ISyncMgrControl interface. In particular, they are intended to allow
// the caller to specify whether the operation should be performed
// synchronously or asynchronously.
//
typedef [v1_enum] enum SYNCMGR_CONTROL_FLAGS
{
SYNCMGR_CF_NONE = 0x00000000,
SYNCMGR_CF_NOWAIT = 0x00000000,
SYNCMGR_CF_WAIT = 0x00000001,
SYNCMGR_CF_NOUI = 0x00000002,
SYNCMGR_CF_VALID = 0x00000003
} SYNCMGR_CONTROL_FLAGS;
// These values are used to modify the sync-related operations requested on
// the methods of the ISyncMgrControl interface.
typedef [v1_enum] enum SYNCMGR_SYNC_CONTROL_FLAGS
{
SYNCMGR_SCF_NONE = 0x00000000,
// Normally sync requests are queued if a synchronization is currently in
// progress. If this flag is specified, however, only items that are not
// currently syncing will be synced again once the current sync session
// has completed.
SYNCMGR_SCF_IGNORE_IF_ALREADY_SYNCING = 0x00000001,
SYNCMGR_SCF_VALID = 0x00000001
} SYNCMGR_SYNC_CONTROL_FLAGS;
// This enum is used when ISyncMgrControl::UpdateConflict is called.
typedef [v1_enum] enum SYNCMGR_UPDATE_REASON
{
SYNCMGR_UR_ADDED = 0,
SYNCMGR_UR_CHANGED = 1,
SYNCMGR_UR_REMOVED = 2,
SYNCMGR_UR_MAX = SYNCMGR_UR_REMOVED
} SYNCMGR_UPDATE_REASON;
//
// This interface is implemented by Sync Center and can be CoCreated() by an
// application or handler by specifying CLSID_SyncMgrControl and specify
// CLSCTX_SERVER. It allows the application or handler to start or stop a
// sync or to notify Sync Center of changes to the set of handlers or items
// or to properties. All methods on this interface will not block but will
// queue the request with Sync Center.
//
[
object,
uuid(9B63616C-36B2-46BC-959F-C1593952D19B)
]
interface ISyncMgrControl : IUnknown
{
// These methods add a sync request to the sync request queue for the
// specified handler to sync all items in the handler or the specified
// items respectively that are currently sync-able (excludes disabled and
// disconnected items). If an item is already syncing, it will be synced
// again after the current sync session completes unless the
// SYNCMGR_SCF_IGNORE_IF_ALREADY_SYNCING flag is specified. If a punk is
// specified, the items in the request will always be queued. If a result
// interface is specified Sync Center will notifier that interface when
// the sync request has completed.
HRESULT StartHandlerSync(
[in, ref, string] LPCWSTR pszHandlerID,
[in, unique] HWND hwndOwner,
[in, unique] IUnknown *punk,
[in] SYNCMGR_SYNC_CONTROL_FLAGS nSyncControlFlags,
[in, unique] ISyncMgrSyncResult *pResult);
HRESULT StartItemSync(
[in, ref, string] LPCWSTR pszHandlerID,
[in, ref, string, size_is(cItems)] LPCWSTR *ppszItemIDs,
[in] ULONG cItems,
[in, unique] HWND hwndOwner,
[in, unique] IUnknown *punk,
[in] SYNCMGR_SYNC_CONTROL_FLAGS nSyncControlFlags,
[in, unique] ISyncMgrSyncResult *pResult);
// This method places a sync request in the sync request for all handlers
// to sync all items in each handler. If the handler is already syncing
// items, those items will be synced again once the current session has
// completed.
HRESULT StartSyncAll( [in, unique] HWND hwndOwner);
// These methods signal the handler to indicate that the user wants to
// cancel a currently sync operation for the specified items.
HRESULT StopHandlerSync([in, ref, string] LPCWSTR pszHandlerID);
HRESULT StopItemSync(
[in, ref, string] LPCWSTR pszHandlerID,
[in, ref, string, size_is(cItems)] LPCWSTR *ppszItemIDs,
[in] ULONG cItems);
HRESULT StopSyncAll();
// This method allows Sync Center to be notified when the collection of
// handlers has changed (e.g. new handlers are available or existing
// handlers have been removed).
HRESULT UpdateHandlerCollection(
[in] REFCLSID rclsidCollectionID,
[in] SYNCMGR_CONTROL_FLAGS nControlFlags);
// These methods allows Sync Center to be notified when the handler or the
// item has changed in some way, such as the handler has been disabled or
// the comment string has changed.
HRESULT UpdateHandler(
[in, ref, string] LPCWSTR pszHandlerID,
[in] SYNCMGR_CONTROL_FLAGS nControlFlags);
HRESULT UpdateItem(
[in, ref, string] LPCWSTR pszHandlerID,
[in, ref, string] LPCWSTR pszItemID,
[in] SYNCMGR_CONTROL_FLAGS nControlFlags);
// This method allows Sync Center to be notified when the handler's custom
// event store (implemented by ISyncMgrEventStore) has changed. This
// causes Sync Center to reread the events for the specified item or for
// the whole handler from the handler's event store and to update the
// UI and the sync tray icon.
HRESULT UpdateEvents(
[in, ref, string] LPCWSTR pszHandlerID,
[in, unique, string] LPCWSTR pszItemID,
[in] SYNCMGR_CONTROL_FLAGS nControlFlags);
// This method allows Sync Center to be notified when a specific conflict
// has been updated in the handler's conflit store (implemented by
// ISyncMgrConflitStore). This causes Sync Center to read the conflict
// from the handler's conflict store and to update the UI and the sync
// tray icon.
HRESULT UpdateConflict(
[in, ref, string] LPCWSTR pszHandlerID,
[in, unique, string] LPCWSTR pszItemID,
[in] ISyncMgrConflict *pConflict,
[in] SYNCMGR_UPDATE_REASON nReason);
// This method is similar to UpdateConflict() but it applies to all
// conflicts for the specified item or all items for the specified
// handler.
HRESULT UpdateConflicts(
[in, ref, string] LPCWSTR pszHandlerID,
[in, unique, string] LPCWSTR pszItemID,
[in] SYNCMGR_CONTROL_FLAGS nControlFlags);
// Notifies Sync Center that the activation state of the specified handler
// has changed. This causes the handler to move between the Sync Center
// folder and the Sync Setup folder. A handler must be active before it
// can be synced.
HRESULT ActivateHandler(
[in] BOOL fActivate,
[in, ref, string] LPCWSTR pszHandlerID,
[in, unique] HWND hwndOwner,
[in] SYNCMGR_CONTROL_FLAGS nControlFlags);
// Notifies Sync Center that the enabled state of the specified handler
// has changed. A handler must be enabled before it can be synced,
// although not all handlers support being disabled. A disabled handler
// and its items can be managed, unlike an inactive handler.
HRESULT EnableHandler(
[in] BOOL fEnable,
[in, ref, string] LPCWSTR pszHandlerID,
[in, unique] HWND hwndOwner,
[in] SYNCMGR_CONTROL_FLAGS nControlFlags);
// Notifies Sync Center that the enabled state of the specified sync item
// has changed. A sync item must be enabled before it can be synced.
HRESULT EnableItem(
[in] BOOL fEnable,
[in, ref, string] LPCWSTR pszHandlerID,
[in, ref, string] LPCWSTR pszItemID,
[in, unique] HWND hwndOwner,
[in] SYNCMGR_CONTROL_FLAGS nControlFlags);
}
//
// Sync Center provides a default event store that handlers can use for
// reporting events that are displayed in the Sync Results folder. However,
// if a component already reports events, it might be more convenient for it
// to provide its own event store that enumerates events for the Sync Results
// folder for that handler.
//
// Sync Center will query a handler for an event store if it sets the
// SYNCMGR_HC_EVENT_STORE flag in the mask returned from its
// GetCapabilities() method.
//
[
object,
uuid(37e412f9-016e-44c2-81ff-db3add774266)
]
interface ISyncMgrEventStore : IUnknown
{
HRESULT GetEventEnumerator([out] IEnumSyncMgrEvents **ppenum);
HRESULT GetEventCount([out] ULONG *pcEvents);
HRESULT GetEvent([in] REFGUID rguidEventID, [out] ISyncMgrEvent **ppEvent);
HRESULT RemoveEvent([in, ref, size_is(cEvents)] GUID *pguidEventIDs, [in] ULONG cEvents);
}
//
// An event store allows Sync Center to get an enumerator of all events in
// the store as well as toretrieve individual events. The ISyncMgrEvent
// interface provides the data for the event to Sync Center.
//
[
object,
uuid(fee0ef8b-46bd-4db4-b7e6-ff2c687313bc)
]
interface ISyncMgrEvent : IUnknown
{
HRESULT GetEventID([out, ref] GUID *pguidEventID);
HRESULT GetHandlerID([out, ref, string] LPWSTR *ppszHandlerID);
HRESULT GetItemID([out, ref, string] LPWSTR *ppszItemID);
HRESULT GetLevel([out, ref] SYNCMGR_EVENT_LEVEL *pnLevel);
HRESULT GetFlags([out, ref] SYNCMGR_EVENT_FLAGS *pnFlags);
HRESULT GetTime([out, ref] FILETIME *pfCreationTime);
HRESULT GetName([out, ref, string] LPWSTR *ppszName);
HRESULT GetDescription([out, ref, string] LPWSTR *ppszDescription);
HRESULT GetLinkText([out, ref, string] LPWSTR *ppszLinkText);
HRESULT GetLinkReference([out, ref, string] LPWSTR *ppszLinkReference);
HRESULT GetContext([out, ref, string] LPWSTR *ppszContext);
}
[
object,
uuid(c81a1d4e-8cf7-4683-80e0-bcae88d677b6)
]
interface IEnumSyncMgrEvents : IUnknown
{
HRESULT Next(
[in] ULONG celt,
[out, size_is(celt), length_is(*pceltFetched)] ISyncMgrEvent **rgelt,
[out] ULONG *pceltFetched);
HRESULT Skip([in] ULONG celt);
HRESULT Reset();
HRESULT Clone([out] IEnumSyncMgrEvents **ppenum);
}
typedef struct SYNCMGR_CONFLICT_ID_INFO
{
[unique] BYTE_BLOB *pblobID; // For comparison
[unique] BYTE_BLOB *pblobExtra; // [optional] Extra data used to init conflict objects
} SYNCMGR_CONFLICT_ID_INFO, *PSYNCMGR_CONFLICT_ID_INFO;
// ISyncMgrConflictStore
[
uuid(cf8fc579-c396-4774-85f1-d908a831156e),
pointer_default(unique),
object
]
interface ISyncMgrConflictStore : IUnknown
{
// Enumerate conflicts, scoped to the provided sync handler, sync item
// If the sync handler or sync item is GUID_NULL, or if the partner name is
// NULL, the conflict store should ignore that parameter.
HRESULT EnumConflicts([in, ref, string] LPCWSTR pszHandlerID, [in, unique, string] LPCWSTR pszItemID, [out] IEnumSyncMgrConflict **ppEnum);
// Bind to a particular conflict given its ID
// This is used when the conflict folder binds to a conflict given its PIDL
// or parsing name. The ID is obtained from a conflict that was previously
// extracted from the store. See the notes concerning the ISyncMgrConflict
// interface
HRESULT BindToConflict([in] const SYNCMGR_CONFLICT_ID_INFO *pConflictIdInfo, [in] REFIID riid, [out, iid_is(riid)] void **ppv);
// Remove a set of conflicts from the store given their conflict ids
HRESULT RemoveConflicts([in, size_is(cConflicts)] const SYNCMGR_CONFLICT_ID_INFO *rgConflictIdInfo, [in] DWORD cConflicts);
// Get the number of conflicts in the store
HRESULT GetCount([in, ref, string] LPCWSTR pszHandlerID, [in, unique, string] LPCWSTR pszItemID, [out] DWORD *pnConflicts);
};
// IEnumSyncMgrConflict
[
uuid(82705914-dda3-4893-ba99-49de6c8c8036),
pointer_default(unique),
object
]
interface IEnumSyncMgrConflict : IUnknown
{
// Standard COM enumerator for ISyncMgrConflict*
HRESULT Next([in] ULONG celt, [out, size_is(celt), length_is(*pceltFetched)] ISyncMgrConflict **rgelt, [out] ULONG *pceltFetched);
HRESULT Skip([in] ULONG celt);
HRESULT Reset();
HRESULT Clone([out] IEnumSyncMgrConflict **ppenum);
}
// This is _enum_, not a mask
typedef [v1_enum] enum SYNCMGR_CONFLICT_ITEM_TYPE
{
SYNCMGR_CIT_UPDATED = 0x00000001, // This conflict item was updated
SYNCMGR_CIT_DELETED = 0x00000002, // This conflict item was deleted
} SYNCMGR_CONFLICT_ITEM_TYPE;
typedef DWORD SYNCMGR_CONFLICT_ITEM_TYPE_FLAG;
interface ISyncMgrConflictItems;
interface ISyncMgrConflictResolveInfo;
// ISyncMgrConflict
[
uuid(9c204249-c443-4ba4-85ed-c972681db137),
pointer_default(unique),
object
]
interface ISyncMgrConflict : IUnknown
{
// Get a conflict property (see propkey.h for PKEY types).
// PKEY_ItemNameDisplay - Name of the conflict
// PKEY_Sync_ConflictDescription - Summary of the conflict
// PKEY_Sync_HandlerID - Sync handler that created the conflict
// PKEY_Sync_ItemID - The sync item that created the conflict
// PKEY_DateModified - The time the conflict was detected
HRESULT GetProperty([in] REFPROPERTYKEY propkey, [out] PROPVARIANT *ppropvar);
// Information identifying a conflict within a conflict store.
// Contains two opaque blobs. One is the ID uniquely identifying a conflict
// within a conflict store. The other is optional extra information stored with the
// conflict that may be used by the implementation when creating conflict objects
// in ISyncMgrConflictStore::BindToConflict and RemoveConflicts.
// The size of of the ID blob must be kept short so that the ID may be embedded
// inside the conflict's PIDL or parsing name. Free each member using CoTaskMemFree()
HRESULT GetConflictIdInfo([out] SYNCMGR_CONFLICT_ID_INFO *pConflictIdInfo);
HRESULT GetItemsArray([out] ISyncMgrConflictItems ** ppArray);
// Resolve the conflict using its own UI (sync handler controls UI).
// If the conflict desires standard resolution behavior, it should set the
// pnPresenterNextStep parameter to SYNCMGR_PF_DEFAULT and return S_OK.
HRESULT Resolve([in] ISyncMgrConflictResolveInfo *pResolveInfo);
// Get the resolution handler for the conflict
HRESULT GetResolutionHandler([in] REFIID riid, [out, iid_is(riid)] void **ppvResolutionHandler);
}
typedef [v1_enum] enum SYNCMGR_RESOLUTION_ABILITIES
{
SYNCMGR_RA_KEEPOTHER = 0x00000001,
SYNCMGR_RA_KEEPRECENT = 0x00000002,
SYNCMGR_RA_REMOVEFROMSYNCSET = 0x00000004,
SYNCMGR_RA_KEEP_SINGLE = 0x00000008,
SYNCMGR_RA_KEEP_MULTIPLE = 0x00000010,
SYNCMGR_RA_VALID = 0x0000001f
} SYNCMGR_RESOLUTION_ABILITIES;
typedef DWORD SYNCMGR_RESOLUTION_ABILITIES_FLAGS;
typedef [v1_enum] enum SYNCMGR_RESOLUTION_FEEDBACK
{
SYNCMGR_RF_CONTINUE,
SYNCMGR_RF_REFRESH,
SYNCMGR_RF_CANCEL,
} SYNCMGR_RESOLUTION_FEEDBACK;
// ISyncMgrResolutionHandler
[
uuid(40A3D052-8BFF-4c4b-A338-D4A395700DE9),
pointer_default(unique),
object
]
interface ISyncMgrResolutionHandler : IUnknown
{
HRESULT QueryAbilities([out] SYNCMGR_RESOLUTION_ABILITIES_FLAGS *pdwAbilities);
// Replacing both the first and second items with a third shell item
// This usually is a merged version of the two originals
HRESULT KeepOther([in] IShellItem *psiOther, [out] SYNCMGR_RESOLUTION_FEEDBACK *pFeedback);
// Keep the more recent copy
HRESULT KeepRecent([out] SYNCMGR_RESOLUTION_FEEDBACK *pFeedback);
// Remove both items from the set of items that sync
HRESULT RemoveFromSyncSet([out] SYNCMGR_RESOLUTION_FEEDBACK *pFeedback);
HRESULT KeepItems([in] ISyncMgrConflictResolutionItems *pArray, [out] SYNCMGR_RESOLUTION_FEEDBACK *pFeedback);
}
// ISyncMgrConflictPresenter
[
uuid(0b4f5353-fd2b-42cd-8763-4779f2d508a3),
pointer_default(unique),
object
]
interface ISyncMgrConflictPresenter : IUnknown
{
// Present the conflict to the user.
HRESULT PresentConflict([in] ISyncMgrConflict *pConflict, [in] ISyncMgrConflictResolveInfo *pResolveInfo);
}
typedef [v1_enum] enum SYNCMGR_PRESENTER_NEXT_STEP
{
// Returned to indicate that the conflict has been resolved and subsequent
// selected conflicts should continue to be resolved.
SYNCMGR_PNS_CONTINUE,
// Returned to indicate that the default conflict presenter should be used.
SYNCMGR_PNS_DEFAULT,
// Returned to indicate the conflict resolution should be canceled. No
// more conflicts will resolved if this is returned.
SYNCMGR_PNS_CANCEL,
} SYNCMGR_PRESENTER_NEXT_STEP;
typedef [v1_enum] enum SYNCMGR_PRESENTER_CHOICE
{
// Returned if the user is skipping this conflict or if conflict
// resolution is being canceled.
SYNCMGR_PC_NO_CHOICE,
// Returned if the user chose to keep only one item.
SYNCMGR_PC_KEEP_ONE,
// Returned if the user chose to keep multiple items.
SYNCMGR_PC_KEEP_MULTIPLE,
// Returned if the user chose to keep the most recent item.
SYNCMGR_PC_KEEP_RECENT,
// Returned if the item is to be removed from the sync set.
SYNCMGR_PC_REMOVE_FROM_SYNC_SET,
// Returned if the item is not being resolved but is instead being skipped
// so that it can be resolved at another time.
SYNCMGR_PC_SKIP,
} SYNCMGR_PRESENTER_CHOICE;
// ISyncMgrConflictResolveInfo
[
object,
local, // don't allow marshaling across threads/processes
uuid(c405a219-25a2-442e-8743-b845a2cee93f)
]
interface ISyncMgrConflictResolveInfo : IUnknown
{
//
// Get information about which conflict in a set of conflicts is being
// resolved.
//
HRESULT GetIterationInfo(
[out] UINT *pnCurrentConflict, // Index of conflict in the set.
[out] UINT *pcConflicts, // Count of conflicts being resolved.
[out] UINT *pcRemainingForApplyToAll); // Remaining conflicts to which an 'apply to all' response would be applied.
//
// Get results set by a resolve operation.
//
// Get what the presenter wants to do next step.
HRESULT GetPresenterNextStep([out] SYNCMGR_PRESENTER_NEXT_STEP *pnPresenterNextStep);
// Get what kind of choice was made and whether to apply the choice to all
// subsequent conflicts in the set. If *pfApplyToAll is set to TRUE,
// GetItemChoice() and GetItemChoiceCount() will have information on how
// to apply this choice.
HRESULT GetPresenterChoice([out] SYNCMGR_PRESENTER_CHOICE *pnPresenterChoice, [out] BOOL *pfApplyToAll);
// Get the count of items user wants to keep.
HRESULT GetItemChoiceCount([out] UINT *pcChoices);
// Get the index of a specific item the user wants to keep. The index is
// the index into the conflict's item array and is passed to the resolver
// for subsequent conflicts in the same set if the user chooses to apply
// the same operation to all selected conflicts of the same type from the
// same handler.
HRESULT GetItemChoice([in] UINT iChoice, [out] UINT *piChoiceIndex);
//
// Set the results of a resolve operation.
//
// Set what the presenter wants to do next.
HRESULT SetPresenterNextStep([in] SYNCMGR_PRESENTER_NEXT_STEP nPresenterNextStep);
// Set what kind of choice was made and whether to apply the choice to
// all subsequent conflicts in the set. If fApplyToAll is set to TRUE,
// SetItemChoices() must also be called.
HRESULT SetPresenterChoice([in] SYNCMGR_PRESENTER_CHOICE nPresenterChoice, [in] BOOL fApplyToAll);
// Set the array of indexes representing which items the user wants to
// keep. This is used if the user chooses to apply the same operation to
// all selected conflicts of the same type from the same handler.
HRESULT SetItemChoices([in, ref, size_is(cChoices)] UINT *prgiConflictItemIndexes, [in] UINT cChoices);
}
// ISyncMgrConflictFolder
[
uuid(59287f5e-bc81-4fca-a7f1-e5a8ecdb1d69),
pointer_default(unique),
local
]
interface ISyncMgrConflictFolder : IUnknown
{
// Used to map a conflict to its IShellItem
HRESULT GetConflictIDList([in] ISyncMgrConflict *pConflict, [out] PIDLIST_RELATIVE *ppidlConflict);
}
typedef struct CONFIRM_CONFLICT_ITEM
{
IShellItem2 *pShellItem; // the item
LPWSTR pszOriginalName; // If NULL then IShellItem's display name will be used
LPWSTR pszAlternateName; // If multiple items will be kept then this item must be renamed to
// pszAlternateName. User may or may not have an ability to change the name.
LPWSTR pszLocationShort; // the string presented to the user the represents the "location"
LPWSTR pszLocationFull; // longer version of the above
SYNCMGR_CONFLICT_ITEM_TYPE nType; // Type of the item - updated or deleted
} CONFIRM_CONFLICT_ITEM;
cpp_quote("#if defined(__cplusplus)")
cpp_quote("__inline void FreeConfirmConflictItem(__inout CONFIRM_CONFLICT_ITEM *pcci)")
cpp_quote("{")
cpp_quote(" if (pcci->pShellItem)")
cpp_quote(" {")
cpp_quote(" pcci->pShellItem->Release();")
cpp_quote(" }")
cpp_quote(" ::CoTaskMemFree(pcci->pszOriginalName);")
cpp_quote(" ::CoTaskMemFree(pcci->pszAlternateName);")
cpp_quote(" ::CoTaskMemFree(pcci->pszLocationShort);")
cpp_quote(" ::CoTaskMemFree(pcci->pszLocationFull);")
cpp_quote(" ::ZeroMemory(pcci, sizeof(*pcci));")
cpp_quote("}")
cpp_quote("#endif // defined(__cplusplus)")
typedef struct CONFIRM_CONFLICT_RESULT_INFO
{
LPWSTR pszNewName; // Item's new name or NULL if item has not been renamed
UINT iItemIndex; // Item index
} CONFIRM_CONFLICT_RESULT_INFO;
// ISyncMgrConflictItems
[
uuid(9C7EAD52-8023-4936-A4DB-D2A9A99E436A),
pointer_default(unique),
object
]
interface ISyncMgrConflictItems : IUnknown
{
HRESULT GetCount([out] UINT *pCount);
// returns S_OK if successful
// returns E_INVALIDARG if iIndex is out of range
HRESULT GetItem([in] UINT iIndex, [out] CONFIRM_CONFLICT_ITEM *pItemInfo);
}
// ISyncMgrConflictResolutionItems
[
uuid(458725B9-129D-4135-A998-9CEAFEC27007),
pointer_default(unique),
object
]
interface ISyncMgrConflictResolutionItems : IUnknown
{
HRESULT GetCount([out] UINT *pCount);
// returns S_OK if successful
// returns E_INVALIDARG if iIndex is out of range
HRESULT GetItem([in] UINT iIndex, [out] CONFIRM_CONFLICT_RESULT_INFO *pItemInfo);
}
// CLSID definitions.
[
uuid(bff8075e-5a75-4c59-b35a-bd4804636dd4), // LIBID_SyncMgrObjects (not registered)
helpstring("Microsoft Sync Center Objects"),
lcid(0x0000),
version(1.0)
]
library SyncMgrObjects
{
[uuid(1202db60-1dac-42c5-aed5-1abdd432248e)] coclass SyncMgrClient { interface ISyncMgrSessionCreator; };
[uuid(1a1f4206-0688-4e7f-be03-d82ec69df9a5)] coclass SyncMgrControl { interface ISyncMgrControl; };
[uuid(8d8b8e30-c451-421b-8553-d2976afa648c)] coclass SyncMgrScheduleWizard { interface ISyncMgrScheduleWizardUIOperation; };
[uuid(9c73f5e5-7ae7-4e32-a8e8-8d23b85255bf)] coclass SyncMgrFolder { interface IShellFolder2; };
[uuid(2e9e59c0-b437-4981-a647-9c34b9b90891)] coclass SyncSetupFolder { interface IShellFolder2; };
[uuid(289978ac-a101-4341-a817-21eba7fd046d)] coclass ConflictFolder { interface IShellFolder2; };
[uuid(71d99464-3b6b-475c-b241-e15883207529)] coclass SyncResultsFolder { interface IShellFolder2; };
[uuid(7a0f6ab7-ed84-46b6-b47e-02aa159a152b)] coclass SimpleConflictPresenter { interface ISyncMgrConflictPresenter; };
};
//
// SYNCMGR_OBJECTID_* GUIDs are defined in shlguid.h.
//
Reference in New Issue View Git Blame Copy Permalink